@gricha/perry 0.3.12 → 0.3.13

package/dist/session-manager/adapters/opencode.js

@@ -13,6 +13,19 @@ async function findAvailablePort(containerName) {
     });
     return parseInt(result.stdout.trim(), 10);
 }
+async function findExistingServer(containerName) {
+    try {
+        const result = await execInContainer(containerName, ['sh', '-c', 'pgrep -a -f "opencode serve" | grep -oP "\\--port \\K[0-9]+" | head -1'], { user: 'workspace' });
+        const port = parseInt(result.stdout.trim(), 10);
+        if (port && (await isServerRunning(containerName, port))) {
+            return port;
+        }
+    }
+    catch {
+        // No existing server
+    }
+    return null;
+}
 async function isServerRunning(containerName, port) {
     try {
         const result = await execInContainer(containerName, ['curl', '-s', '-o', '/dev/null', '-w', '%{http_code}', `http://localhost:${port}/session`], { user: 'workspace' });
@@ -34,8 +47,14 @@ async function getServerLogs(containerName) {
     }
 }
 async function startServer(containerName) {
-    const existing = serverPorts.get(containerName);
-    if (existing && (await isServerRunning(containerName, existing))) {
+    const cached = serverPorts.get(containerName);
+    if (cached && (await isServerRunning(containerName, cached))) {
+        return cached;
+    }
+    const existing = await findExistingServer(containerName);
+    if (existing) {
+        console.log(`[opencode] Found existing server on port ${existing} in ${containerName}`);
+        serverPorts.set(containerName, existing);
         return existing;
     }
     const starting = serverStarting.get(containerName);
@@ -176,6 +195,7 @@ export class OpenCodeAdapter {
             if (!this.agentSessionId) {
                 this.agentSessionId = await this.createSession(baseUrl);
                 this.emit({ type: 'system', content: `Session: ${this.agentSessionId.slice(0, 8)}...` });
+                this.statusCallback?.(this.status);
             }
             this.setStatus('running');
             this.emit({ type: 'system', content: 'Processing...' });
@@ -229,7 +249,10 @@ export class OpenCodeAdapter {
         return session.id;
     }
     async sendAndStream(baseUrl, message) {
-        const sseReady = this.startSSEStream();
+        let sseError = null;
+        const sseReady = this.startSSEStream().catch((err) => {
+            sseError = err;
+        });
         await new Promise((resolve) => setTimeout(resolve, 100));
         const payload = { parts: [{ type: 'text', text: message }] };
         if (this.isHost) {
@@ -263,6 +286,9 @@ export class OpenCodeAdapter {
             }
         }
         await sseReady;
+        if (sseError) {
+            throw sseError;
+        }
     }
     startSSEStream() {
         return new Promise((resolve, reject) => {
@@ -284,6 +310,7 @@ export class OpenCodeAdapter {
             this.sseProcess = proc;
             const decoder = new TextDecoder();
             let buffer = '';
+            let eventCount = 0;
             const finish = () => {
                 if (!resolved) {
                     resolved = true;
@@ -316,7 +343,9 @@ export class OpenCodeAdapter {
                                 continue;
                             try {
                                 const event = JSON.parse(data);
+                                eventCount++;
                                 if (event.type === 'session.idle') {
+                                    console.log(`[opencode] SSE received session.idle after ${eventCount} events`);
                                     receivedIdle = true;
                                     clearTimeout(timeout);
                                     proc.kill();
@@ -375,7 +404,7 @@ export class OpenCodeAdapter {
                 }
                 else if (!resolved) {
                     resolved = true;
-                    reject(new Error('SSE stream ended unexpectedly without session.idle'));
+                    reject(new Error(`SSE stream ended unexpectedly without session.idle (received ${eventCount} events)`));
                 }
             })().catch((err) => {
                 clearTimeout(timeout);

package/dist/session-manager/bun-handler.js

@@ -90,7 +90,7 @@ export class LiveChatHandler {
         const agentType = message.agentType || this.agentType;
         if (message.sessionId) {
             // Look up by internal sessionId or agentSessionId (Claude session ID)
-            const found = sessionManager.findSession(message.sessionId);
+            const found = await sessionManager.findSession(message.sessionId);
             if (found) {
                 connection.sessionId = found.sessionId;
                 const sendFn = (msg) => {

package/dist/session-manager/manager.js

@@ -241,18 +241,41 @@ export class SessionManager {
         const session = this.sessions.get(sessionId);
         return session?.info ?? null;
     }
-    findSession(id) {
-        // First try direct lookup by internal sessionId
+    async findSession(id) {
+        // First try direct lookup by internal sessionId (in-memory cache)
         const direct = this.sessions.get(id);
         if (direct) {
             return { sessionId: id, info: direct.info };
         }
-        // Then search by agentSessionId (Claude session ID)
+        // Then search by agentSessionId in memory
         for (const [sessionId, session] of this.sessions) {
             if (session.info.agentSessionId === id) {
                 return { sessionId, info: session.info };
             }
         }
+        // Not in memory - check disk registry
+        if (this.stateDir) {
+            // Try lookup by perrySessionId first
+            let record = await registry.getSession(this.stateDir, id);
+            // Then try by agentSessionId
+            if (!record) {
+                record = await registry.findByAgentSessionId(this.stateDir, id);
+            }
+            // Found on disk - restore the session
+            if (record) {
+                const restoredId = await this.startSession({
+                    sessionId: record.perrySessionId,
+                    workspaceName: record.workspaceName,
+                    agentType: record.agentType,
+                    agentSessionId: record.agentSessionId ?? undefined,
+                    projectPath: record.projectPath ?? undefined,
+                });
+                const restored = this.sessions.get(restoredId);
+                if (restored) {
+                    return { sessionId: restoredId, info: restored.info };
+                }
+            }
+        }
         return null;
     }
     getSessionStatus(sessionId) {

package/dist/sessions/registry.js

@@ -98,6 +98,25 @@ export async function getSessionsForWorkspace(stateDir, workspaceName) {
         .filter((record) => record.workspaceName === workspaceName)
         .sort((a, b) => new Date(b.lastActivity).getTime() - new Date(a.lastActivity).getTime());
 }
+/**
+ * Get a specific session by perrySessionId.
+ */
+export async function getSession(stateDir, perrySessionId) {
+    const registry = await loadRegistry(stateDir);
+    return registry.sessions[perrySessionId] ?? null;
+}
+/**
+ * Find a session by agentSessionId.
+ */
+export async function findByAgentSessionId(stateDir, agentSessionId) {
+    const registry = await loadRegistry(stateDir);
+    for (const record of Object.values(registry.sessions)) {
+        if (record.agentSessionId === agentSessionId) {
+            return record;
+        }
+    }
+    return null;
+}
 /**
  * Import an external session (discovered from agent storage).
  * Creates a Perry session record for a session that wasn't started through Perry.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gricha/perry",
-  "version": "0.3.12",
+  "version": "0.3.13",
   "description": "Self-contained CLI for spinning up Docker-in-Docker development environments with SSH and proxy helpers.",
   "type": "module",
   "bin": {