@gricha/perry 0.3.7 → 0.3.9

package/dist/agent/index.js

@@ -1,5 +1,13 @@
 #!/usr/bin/env node
 import { startAgent } from './run';
+process.on('unhandledRejection', (reason, promise) => {
+    console.error('[agent] Unhandled promise rejection:', reason);
+    console.error('[agent] Promise:', promise);
+});
+process.on('uncaughtException', (err) => {
+    console.error('[agent] Uncaught exception:', err);
+    process.exit(1);
+});
 startAgent().catch((err) => {
     console.error('[agent] Fatal error:', err);
     process.exit(1);

package/dist/agent/router.js

@@ -4,15 +4,16 @@ import os_module from 'os';
 import { promises as fs } from 'fs';
 import path from 'path';
 import { HOST_WORKSPACE_NAME } from '../shared/client-types';
-import { getDockerVersion, execInContainer } from '../docker';
+import { getDockerVersion, execInContainer, getContainerName } from '../docker';
+import { createWorkerClient } from '../worker/client';
 import { saveAgentConfig } from '../config/loader';
 import { setSessionName, getSessionNamesForWorkspace, deleteSessionName, } from '../sessions/metadata';
 import * as sessionRegistry from '../sessions/registry';
 import { discoverSSHKeys } from '../ssh/discovery';
-import { parseClaudeSessionContent } from '../sessions/parser';
 import { discoverAllSessions, getSessionDetails as getAgentSessionDetails, getSessionMessages, findSessionMessages, deleteSession as deleteSessionFromProvider, searchSessions as searchSessionsInContainer, } from '../sessions/agents';
 import { discoverClaudeCodeModels, discoverHostOpencodeModels, discoverContainerOpencodeModels, } from '../models/discovery';
-import { listOpencodeSessions, getOpencodeSessionMessages, deleteOpencodeSession, } from '../sessions/agents/opencode-storage';
+import { deleteOpencodeSession } from '../sessions/agents/opencode-storage';
+import { SessionIndex } from '../worker/session-index';
 import { sessionManager } from '../session-manager';
 const WorkspaceStatusSchema = z.enum(['running', 'stopped', 'creating', 'error']);
 const WorkspacePortsSchema = z.object({
@@ -95,7 +96,19 @@ export function createRouter(ctx) {
         if (!workspace) {
             throw new ORPCError('NOT_FOUND', { message: 'Workspace not found' });
         }
-        return workspace;
+        let workerVersion = null;
+        if (workspace.status === 'running') {
+            try {
+                const containerName = getContainerName(input.name);
+                const client = await createWorkerClient(containerName);
+                const health = await client.health();
+                workerVersion = health.version;
+            }
+            catch {
+                // Worker not reachable
+            }
+        }
+        return { ...workspace, workerVersion };
     });
     const createWorkspace = os
         .input(z.object({
@@ -190,6 +203,15 @@ export function createRouter(ctx) {
             results,
         };
     });
+    const updateWorker = os.input(z.object({ name: z.string() })).handler(async ({ input }) => {
+        try {
+            await ctx.workspaces.updateWorkerBinary(input.name);
+            return { success: true };
+        }
+        catch (err) {
+            mapErrorToORPC(err, 'Failed to update worker');
+        }
+    });
     const touchWorkspace = os
         .input(z.object({ name: z.string() }))
         .output(WorkspaceInfoSchema)
@@ -411,170 +433,59 @@ export function createRouter(ctx) {
             });
         }
     });
+    const hostSessionIndex = new SessionIndex();
+    let hostSessionIndexInitialized = false;
     async function listHostSessions(input) {
+        if (!hostSessionIndexInitialized) {
+            await hostSessionIndex.initialize();
+            hostSessionIndex.startWatchers();
+            hostSessionIndexInitialized = true;
+        }
         const limit = input.limit ?? 50;
         const offset = input.offset ?? 0;
-        const homeDir = os_module.homedir();
-        const rawSessions = [];
-        if (!input.agentType || input.agentType === 'claude-code') {
-            const claudeProjectsDir = path.join(homeDir, '.claude', 'projects');
-            try {
-                const projectDirs = await fs.readdir(claudeProjectsDir);
-                for (const projectDir of projectDirs) {
-                    const projectPath = path.join(claudeProjectsDir, projectDir);
-                    const stat = await fs.stat(projectPath);
-                    if (!stat.isDirectory())
-                        continue;
-                    const files = await fs.readdir(projectPath);
-                    for (const file of files) {
-                        if (!file.endsWith('.jsonl') || file.startsWith('agent-'))
-                            continue;
-                        const filePath = path.join(projectPath, file);
-                        const fileStat = await fs.stat(filePath);
-                        const sessionId = file.replace('.jsonl', '');
-                        rawSessions.push({
-                            id: sessionId,
-                            agentType: 'claude-code',
-                            projectPath: projectDir.replace(/-/g, '/'),
-                            mtime: fileStat.mtimeMs,
-                            filePath,
-                        });
-                    }
-                }
-            }
-            catch {
-                // Directory doesn't exist or not readable
-            }
-        }
-        if (!input.agentType || input.agentType === 'opencode') {
-            const opencodeSessions = await listOpencodeSessions();
-            for (const session of opencodeSessions) {
-                rawSessions.push({
-                    id: session.id,
-                    agentType: 'opencode',
-                    projectPath: session.directory || homeDir,
-                    mtime: session.mtime,
-                    filePath: session.file,
-                    name: session.title || undefined,
-                });
-            }
+        let sessions = hostSessionIndex.list();
+        if (input.agentType) {
+            const filterType = input.agentType === 'claude-code' ? 'claude' : input.agentType;
+            sessions = sessions.filter((s) => s.agentType === filterType);
         }
-        rawSessions.sort((a, b) => b.mtime - a.mtime);
+        const nonEmptySessions = sessions.filter((s) => s.messageCount > 0);
         const sessionNames = await getSessionNamesForWorkspace(ctx.configDir, HOST_WORKSPACE_NAME);
-        const sessions = await Promise.all(rawSessions.map(async (raw) => {
-            let firstPrompt = null;
-            let messageCount = 0;
-            if (raw.agentType === 'claude-code') {
-                try {
-                    const fileContent = await fs.readFile(raw.filePath, 'utf-8');
-                    const lines = fileContent.trim().split('\n').filter(Boolean);
-                    messageCount = lines.length;
-                    for (const line of lines) {
-                        try {
-                            const entry = JSON.parse(line);
-                            if ((entry.type === 'user' || entry.type === 'human') && entry.message?.content) {
-                                const msgContent = entry.message.content;
-                                if (Array.isArray(msgContent)) {
-                                    const textBlock = msgContent.find((b) => b.type === 'text');
-                                    if (textBlock?.text) {
-                                        firstPrompt = textBlock.text.slice(0, 200);
-                                        break;
-                                    }
-                                }
-                                else if (typeof msgContent === 'string') {
-                                    firstPrompt = msgContent.slice(0, 200);
-                                    break;
-                                }
-                            }
-                        }
-                        catch {
-                            continue;
-                        }
-                    }
-                }
-                catch {
-                    // Can't read file
-                }
-            }
-            else if (raw.agentType === 'opencode') {
-                const sessionMessages = await getOpencodeSessionMessages(raw.id);
-                const userAssistantMessages = sessionMessages.messages.filter((m) => m.type === 'user' || m.type === 'assistant');
-                messageCount = userAssistantMessages.length;
-                if (raw.name) {
-                    firstPrompt = raw.name;
-                }
-                else {
-                    const firstUserMsg = userAssistantMessages.find((m) => m.type === 'user' && m.content);
-                    if (firstUserMsg?.content) {
-                        firstPrompt = firstUserMsg.content.slice(0, 200);
-                    }
-                }
-            }
-            return {
-                id: raw.id,
-                name: sessionNames[raw.id] || null,
-                agentType: raw.agentType,
-                projectPath: raw.projectPath,
-                messageCount,
-                lastActivity: new Date(raw.mtime).toISOString(),
-                firstPrompt,
-            };
+        const paginatedSessions = nonEmptySessions.slice(offset, offset + limit).map((s) => ({
+            id: s.id,
+            name: sessionNames[s.id] || null,
+            agentType: (s.agentType === 'claude' ? 'claude-code' : s.agentType),
+            projectPath: s.directory,
+            messageCount: s.messageCount,
+            lastActivity: new Date(s.lastActivity).toISOString(),
+            firstPrompt: s.firstPrompt,
         }));
-        const nonEmptySessions = sessions.filter((s) => s.messageCount > 0);
-        const paginatedSessions = nonEmptySessions.slice(offset, offset + limit);
         return {
             sessions: paginatedSessions,
             total: nonEmptySessions.length,
             hasMore: offset + limit < nonEmptySessions.length,
         };
     }
-    async function getHostSession(sessionId, agentType) {
-        const homeDir = os_module.homedir();
-        const messages = [];
-        if (!agentType || 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 {
-                        const content = await fs.readFile(sessionFile, 'utf-8');
-                        const parsed = parseClaudeSessionContent(content)
-                            .filter((msg) => msg.type !== 'system')
-                            .filter((msg) => msg.type === 'tool_use' ||
-                            msg.type === 'tool_result' ||
-                            (msg.content && msg.content.trim().length > 0));
-                        messages.push(...parsed);
-                        break;
-                    }
-                    catch {
-                        // File not found in this project dir
-                    }
-                }
-            }
-            catch {
-                // Directory doesn't exist
-            }
-            if (messages.length > 0) {
-                return { id: sessionId, agentType: 'claude-code', messages };
-            }
-        }
-        if (!agentType || agentType === 'opencode') {
-            const sessionData = await getOpencodeSessionMessages(sessionId);
-            if (sessionData.messages.length > 0) {
-                const opencodeMessages = sessionData.messages.map((m) => ({
-                    type: m.type,
-                    content: m.content,
-                    toolName: m.toolName,
-                    toolId: m.toolId,
-                    toolInput: m.toolInput,
-                    timestamp: m.timestamp,
-                }));
-                return { id: sessionId, agentType: 'opencode', messages: opencodeMessages };
-            }
+    async function getHostSession(sessionId, _agentType) {
+        if (!hostSessionIndexInitialized) {
+            await hostSessionIndex.initialize();
+            hostSessionIndex.startWatchers();
+            hostSessionIndexInitialized = true;
         }
-        return { id: sessionId, messages };
+        const session = hostSessionIndex.get(sessionId);
+        if (!session) {
+            return { id: sessionId, messages: [] };
+        }
+        const result = await hostSessionIndex.getMessages(sessionId, { limit: 10000, offset: 0 });
+        const agentType = session.agentType === 'claude' ? 'claude-code' : session.agentType;
+        const messages = result.messages.map((m) => ({
+            type: m.type,
+            content: m.content,
+            toolName: m.toolName,
+            toolId: m.toolId,
+            toolInput: m.toolInput,
+            timestamp: m.timestamp,
+        }));
+        return { id: sessionId, agentType, messages };
     }
     async function listSessionsCore(input) {
         const limit = input.limit ?? 50;
@@ -616,16 +527,13 @@ export function createRouter(ctx) {
             .filter((s) => !input.agentType || s.agentType === input.agentType)
             .sort((a, b) => b.mtime - a.mtime);
         const paginatedRawSessions = filteredSessions.slice(offset, offset + limit);
-        const sessions = [];
-        for (const rawSession of paginatedRawSessions) {
-            const details = await getAgentSessionDetails(containerName, rawSession, execInContainer);
-            if (details) {
-                sessions.push({
-                    ...details,
-                    name: customNames[details.id] || details.name,
-                });
-            }
-        }
+        const detailsResults = await Promise.all(paginatedRawSessions.map((rawSession) => getAgentSessionDetails(containerName, rawSession, execInContainer)));
+        const sessions = detailsResults
+            .filter((details) => details !== null)
+            .map((details) => ({
+            ...details,
+            name: customNames[details.id] || details.name,
+        }));
         return {
             sessions,
             total: filteredSessions.length,
@@ -647,6 +555,7 @@ export function createRouter(ctx) {
         workspaceName: z.string(),
         sessionId: z.string(),
         agentType: z.enum(['claude-code', 'opencode', 'codex']).optional(),
+        projectPath: z.string().optional(),
         limit: z.number().optional(),
         offset: z.number().optional(),
     }))
@@ -670,7 +579,7 @@ export function createRouter(ctx) {
             }
             const containerName = `workspace-${input.workspaceName}`;
             result = input.agentType
-                ? await getSessionMessages(containerName, input.sessionId, input.agentType, execInContainer)
+                ? await getSessionMessages(containerName, input.sessionId, input.agentType, execInContainer, input.projectPath)
                 : await findSessionMessages(containerName, input.sessionId, execInContainer);
         }
         if (!result) {
@@ -1113,6 +1022,7 @@ export function createRouter(ctx) {
             touch: touchWorkspace,
             getPortForwards: getPortForwards,
             setPortForwards: setPortForwards,
+            updateWorker: updateWorker,
         },
         sessions: {
             list: listSessions,