Add session deletion and search functionality

Session Deletion:
- Add deleteSession to AgentSessionProvider interface
- Implement hard delete for Claude Code, Codex, and OpenCode sessions
- Add perry worker sessions delete subcommand for OpenCode
- Add sessions.delete API endpoint with host session support
- Add delete button and confirmation dialog to session list UI

Session Search:
- Add search input above session list with debounced filtering
- Filter sessions by name, first prompt, ID, and project path
- Show filtered count in header
- Display "No sessions match" message when search returns empty

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: gricha

src/agent/router.ts

@@ -21,6 +21,7 @@ import {
   getSessionDetails as getAgentSessionDetails,
   getSessionMessages,
   findSessionMessages,
+  deleteSession as deleteSessionFromProvider,
 } from '../sessions/agents';
 import type { SessionsCacheManager } from '../sessions/cache';
 import type { ModelCacheManager } from '../models/cache';
@@ -32,6 +33,7 @@ import {
 import {
   listOpencodeSessions,
   getOpencodeSessionMessages,
+  deleteOpencodeSession,
 } from '../sessions/agents/opencode-storage';
 
 const WorkspaceStatusSchema = z.enum(['running', 'stopped', 'creating', 'error']);
@@ -708,6 +710,127 @@ export function createRouter(ctx: RouterContext) {
       return { success: true };
     });
 
+  const deleteSession = os
+    .input(
+      z.object({
+        workspaceName: z.string(),
+        sessionId: z.string(),
+        agentType: z.enum(['claude-code', 'opencode', 'codex']),
+      })
+    )
+    .handler(async ({ input }) => {
+      const isHost = input.workspaceName === HOST_WORKSPACE_NAME;
+
+      if (isHost) {
+        const config = ctx.config.get();
+        if (!config.allowHostAccess) {
+          throw new ORPCError('PRECONDITION_FAILED', { message: 'Host access is disabled' });
+        }
+
+        const result = await deleteHostSession(input.sessionId, input.agentType);
+        if (!result.success) {
+          throw new ORPCError('INTERNAL_SERVER_ERROR', { message: result.error || 'Failed to delete session' });
+        }
+
+        await deleteSessionName(ctx.stateDir, input.workspaceName, input.sessionId);
+        await ctx.sessionsCache.removeSession(input.workspaceName, input.sessionId);
+
+        return { success: true };
+      }
+
+      const workspace = await ctx.workspaces.get(input.workspaceName);
+      if (!workspace) {
+        throw new ORPCError('NOT_FOUND', { message: 'Workspace not found' });
+      }
+      if (workspace.status !== 'running') {
+        throw new ORPCError('PRECONDITION_FAILED', { message: 'Workspace is not running' });
+      }
+
+      const containerName = `workspace-${input.workspaceName}`;
+
+      const result = await deleteSessionFromProvider(
+        containerName,
+        input.sessionId,
+        input.agentType,
+        execInContainer
+      );
+
+      if (!result.success) {
+        throw new ORPCError('INTERNAL_SERVER_ERROR', { message: result.error || 'Failed to delete session' });
+      }
+
+      await deleteSessionName(ctx.stateDir, input.workspaceName, input.sessionId);
+      await ctx.sessionsCache.removeSession(input.workspaceName, input.sessionId);
+
+      return { success: true };
+    });
+
+  async function deleteHostSession(
+    sessionId: string,
+    agentType: 'claude-code' | 'opencode' | 'codex'
+  ): Promise<{ success: boolean; error?: string }> {
+    const homeDir = os_module.homedir();
+
+    if (agentType === 'claude-code') {
+      const safeSessionId = sessionId.replace(/[^a-zA-Z0-9_-]/g, '');
+      const claudeProjectsDir = path.join(homeDir, '.claude', 'projects');
+
+      try {
+        const projectDirs = await fs.readdir(claudeProjectsDir);
+        for (const projectDir of projectDirs) {
+          const sessionFile = path.join(claudeProjectsDir, projectDir, `${safeSessionId}.jsonl`);
+          try {
+            await fs.unlink(sessionFile);
+            return { success: true };
+          } catch {
+            continue;
+          }
+        }
+      } catch {
+        return { success: false, error: 'Session not found' };
+      }
+      return { success: false, error: 'Session not found' };
+    }
+
+    if (agentType === 'opencode') {
+      return deleteOpencodeSession(sessionId);
+    }
+
+    if (agentType === 'codex') {
+      const codexSessionsDir = path.join(homeDir, '.codex', 'sessions');
+      try {
+        const files = await fs.readdir(codexSessionsDir);
+        for (const file of files) {
+          if (!file.endsWith('.jsonl')) continue;
+          const filePath = path.join(codexSessionsDir, file);
+          const fileId = file.replace('.jsonl', '');
+
+          if (fileId === sessionId) {
+            await fs.unlink(filePath);
+            return { success: true };
+          }
+
+          try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            const firstLine = content.split('\n')[0];
+            const meta = JSON.parse(firstLine) as { session_id?: string };
+            if (meta.session_id === sessionId) {
+              await fs.unlink(filePath);
+              return { success: true };
+            }
+          } catch {
+            continue;
+          }
+        }
+      } catch {
+        return { success: false, error: 'Session not found' };
+      }
+      return { success: false, error: 'Session not found' };
+    }
+
+    return { success: false, error: 'Unsupported agent type' };
+  }
+
   const getHostInfo = os.handler(async () => {
     const config = ctx.config.get();
     return {
@@ -813,6 +936,7 @@ export function createRouter(ctx: RouterContext) {
       clearName: clearSessionName,
       getRecent: getRecentSessions,
       recordAccess: recordSessionAccess,
+      delete: deleteSession,
     },
     models: {
       list: listModels,

src/index.ts

@@ -673,11 +673,11 @@ const workerCmd = program
 
 workerCmd
   .command('sessions')
-  .argument('<subcommand>', 'Subcommand: list or messages')
-  .argument('[sessionId]', 'Session ID (required for messages)')
+  .argument('<subcommand>', 'Subcommand: list, messages, or delete')
+  .argument('[sessionId]', 'Session ID (required for messages and delete)')
   .description('Manage OpenCode sessions')
   .action(async (subcommand: string, sessionId?: string) => {
-    const { listOpencodeSessions, getOpencodeSessionMessages } =
+    const { listOpencodeSessions, getOpencodeSessionMessages, deleteOpencodeSession } =
       await import('./sessions/agents/opencode-storage');
 
     if (subcommand === 'list') {
@@ -690,9 +690,16 @@ workerCmd
       }
       const result = await getOpencodeSessionMessages(sessionId);
       console.log(JSON.stringify(result));
+    } else if (subcommand === 'delete') {
+      if (!sessionId) {
+        console.error('Usage: perry worker sessions delete <session_id>');
+        process.exit(1);
+      }
+      const result = await deleteOpencodeSession(sessionId);
+      console.log(JSON.stringify(result));
     } else {
       console.error(`Unknown subcommand: ${subcommand}`);
-      console.error('Available: list, messages');
+      console.error('Available: list, messages, delete');
       process.exit(1);
     }
   });

src/sessions/agents/claude.ts

@@ -121,4 +121,36 @@ export const claudeProvider: AgentSessionProvider = {
       );
     return { id: sessionId, messages };
   },
+
+  async deleteSession(
+    containerName: string,
+    sessionId: string,
+    exec: ExecInContainer
+  ): Promise<{ success: boolean; error?: string }> {
+    const safeSessionId = sessionId.replace(/[^a-zA-Z0-9_-]/g, '');
+    const findResult = await exec(
+      containerName,
+      [
+        'bash',
+        '-c',
+        `find /home/workspace/.claude/projects -name "${safeSessionId}.jsonl" -type f 2>/dev/null | head -1`,
+      ],
+      { user: 'workspace' }
+    );
+
+    if (findResult.exitCode !== 0 || !findResult.stdout.trim()) {
+      return { success: false, error: 'Session not found' };
+    }
+
+    const filePath = findResult.stdout.trim();
+    const rmResult = await exec(containerName, ['rm', '-f', filePath], {
+      user: 'workspace',
+    });
+
+    if (rmResult.exitCode !== 0) {
+      return { success: false, error: rmResult.stderr || 'Failed to delete session file' };
+    }
+
+    return { success: true };
+  },
 };

src/sessions/agents/codex.ts

@@ -157,4 +157,58 @@ export const codexProvider: AgentSessionProvider = {
 
     return null;
   },
+
+  async deleteSession(
+    containerName: string,
+    sessionId: string,
+    exec: ExecInContainer
+  ): Promise<{ success: boolean; error?: string }> {
+    const findResult = await exec(
+      containerName,
+      ['bash', '-c', `find /home/workspace/.codex/sessions -name "*.jsonl" -type f 2>/dev/null`],
+      { user: 'workspace' }
+    );
+
+    if (findResult.exitCode !== 0 || !findResult.stdout.trim()) {
+      return { success: false, error: 'No session files found' };
+    }
+
+    const files = findResult.stdout.trim().split('\n').filter(Boolean);
+
+    for (const file of files) {
+      const fileId = file.split('/').pop()?.replace('.jsonl', '') || '';
+
+      if (fileId === sessionId) {
+        const rmResult = await exec(containerName, ['rm', '-f', file], {
+          user: 'workspace',
+        });
+        if (rmResult.exitCode !== 0) {
+          return { success: false, error: rmResult.stderr || 'Failed to delete session file' };
+        }
+        return { success: true };
+      }
+
+      const headResult = await exec(containerName, ['head', '-1', file], {
+        user: 'workspace',
+      });
+      if (headResult.exitCode === 0) {
+        try {
+          const meta = JSON.parse(headResult.stdout) as { session_id?: string };
+          if (meta.session_id === sessionId) {
+            const rmResult = await exec(containerName, ['rm', '-f', file], {
+              user: 'workspace',
+            });
+            if (rmResult.exitCode !== 0) {
+              return { success: false, error: rmResult.stderr || 'Failed to delete session file' };
+            }
+            return { success: true };
+          }
+        } catch {
+          continue;
+        }
+      }
+    }
+
+    return { success: false, error: 'Session not found' };
+  },
 };

src/sessions/agents/index.ts

@@ -65,3 +65,16 @@ export async function findSessionMessages(
   }
   return null;
 }
+
+export async function deleteSession(
+  containerName: string,
+  sessionId: string,
+  agentType: AgentType,
+  exec: ExecInContainer
+): Promise<{ success: boolean; error?: string }> {
+  const provider = providers[agentType];
+  if (!provider) {
+    return { success: false, error: 'Unknown agent type' };
+  }
+  return provider.deleteSession(containerName, sessionId, exec);
+}

src/sessions/agents/opencode-storage.ts

@@ -196,3 +196,63 @@ async function findSessionFile(sessionDir: string, sessionId: string): Promise<s
 
   return null;
 }
+
+export async function deleteOpencodeSession(
+  sessionId: string,
+  homeDir?: string
+): Promise<{ success: boolean; error?: string }> {
+  const storageBase = getStorageBase(homeDir);
+  const sessionDir = path.join(storageBase, 'session');
+  const messageDir = path.join(storageBase, 'message');
+  const partDir = path.join(storageBase, 'part');
+
+  const sessionFile = await findSessionFile(sessionDir, sessionId);
+  if (!sessionFile) {
+    return { success: false, error: 'Session not found' };
+  }
+
+  let internalId: string | null = null;
+  try {
+    const content = await fs.readFile(sessionFile, 'utf-8');
+    const data = JSON.parse(content);
+    internalId = data.id;
+  } catch {
+    // Continue with session file deletion only
+  }
+
+  try {
+    await fs.unlink(sessionFile);
+  } catch (err) {
+    return { success: false, error: `Failed to delete session file: ${err}` };
+  }
+
+  if (internalId) {
+    const msgDir = path.join(messageDir, internalId);
+    try {
+      const msgFiles = await fs.readdir(msgDir);
+      for (const msgFile of msgFiles) {
+        if (!msgFile.startsWith('msg_') || !msgFile.endsWith('.json')) continue;
+        const msgPath = path.join(msgDir, msgFile);
+        try {
+          const content = await fs.readFile(msgPath, 'utf-8');
+          const msg = JSON.parse(content);
+          if (msg.id) {
+            const partMsgDir = path.join(partDir, msg.id);
+            try {
+              await fs.rm(partMsgDir, { recursive: true });
+            } catch {
+              // Parts may not exist
+            }
+          }
+        } catch {
+          // Skip malformed messages
+        }
+      }
+      await fs.rm(msgDir, { recursive: true });
+    } catch {
+      // Messages directory may not exist
+    }
+  }
+
+  return { success: true };
+}

src/sessions/agents/opencode.ts

@@ -120,4 +120,28 @@ export const opencodeProvider: AgentSessionProvider = {
       return null;
     }
   },
+
+  async deleteSession(
+    containerName: string,
+    sessionId: string,
+    exec: ExecInContainer
+  ): Promise<{ success: boolean; error?: string }> {
+    const result = await exec(
+      containerName,
+      ['perry', 'worker', 'sessions', 'delete', sessionId],
+      {
+        user: 'workspace',
+      }
+    );
+
+    if (result.exitCode !== 0) {
+      return { success: false, error: result.stderr || 'Failed to delete session' };
+    }
+
+    try {
+      return JSON.parse(result.stdout) as { success: boolean; error?: string };
+    } catch {
+      return { success: false, error: 'Invalid response from worker' };
+    }
+  },
 };