@gricha/perry 0.0.1 → 0.1.1

package/dist/chat/opencode-server.js

@@ -0,0 +1,252 @@
+import { execInContainer } from '../docker';
+const serverPorts = new Map();
+const serverStarting = new Map();
+async function findAvailablePort(containerName) {
+    const script = `import socket; s=socket.socket(); s.bind(('', 0)); print(s.getsockname()[1]); s.close()`;
+    const result = await execInContainer(containerName, ['python3', '-c', script], {
+        user: 'workspace',
+    });
+    return parseInt(result.stdout.trim(), 10);
+}
+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' });
+        return result.stdout.trim() === '200';
+    }
+    catch {
+        return false;
+    }
+}
+async function startServer(containerName) {
+    const existing = serverPorts.get(containerName);
+    if (existing && (await isServerRunning(containerName, existing))) {
+        return existing;
+    }
+    const starting = serverStarting.get(containerName);
+    if (starting) {
+        return starting;
+    }
+    const startPromise = (async () => {
+        const port = await findAvailablePort(containerName);
+        console.log(`[opencode-server] Starting server on port ${port} in ${containerName}`);
+        await execInContainer(containerName, [
+            'sh',
+            '-c',
+            `nohup opencode serve --port ${port} --hostname 127.0.0.1 > /tmp/opencode-server.log 2>&1 &`,
+        ], { user: 'workspace' });
+        for (let i = 0; i < 30; i++) {
+            await new Promise((resolve) => setTimeout(resolve, 500));
+            if (await isServerRunning(containerName, port)) {
+                console.log(`[opencode-server] Server started on port ${port}`);
+                serverPorts.set(containerName, port);
+                serverStarting.delete(containerName);
+                return port;
+            }
+        }
+        serverStarting.delete(containerName);
+        throw new Error('Failed to start OpenCode server');
+    })();
+    serverStarting.set(containerName, startPromise);
+    return startPromise;
+}
+export class OpenCodeServerSession {
+    containerName;
+    workDir;
+    sessionId;
+    onMessage;
+    sseProcess = null;
+    responseComplete = false;
+    seenToolUse = new Set();
+    seenToolResult = new Set();
+    constructor(options, onMessage) {
+        this.containerName = options.containerName;
+        this.workDir = options.workDir || '/home/workspace';
+        this.sessionId = options.sessionId;
+        this.onMessage = onMessage;
+    }
+    async sendMessage(userMessage) {
+        const port = await startServer(this.containerName);
+        const baseUrl = `http://localhost:${port}`;
+        this.onMessage({
+            type: 'system',
+            content: 'Processing your message...',
+            timestamp: new Date().toISOString(),
+        });
+        try {
+            if (!this.sessionId) {
+                const createResult = await execInContainer(this.containerName, [
+                    'curl',
+                    '-s',
+                    '-X',
+                    'POST',
+                    `${baseUrl}/session`,
+                    '-H',
+                    'Content-Type: application/json',
+                    '-d',
+                    '{}',
+                ], { user: 'workspace' });
+                const session = JSON.parse(createResult.stdout);
+                this.sessionId = session.id;
+                this.onMessage({
+                    type: 'system',
+                    content: `Session started ${this.sessionId}`,
+                    timestamp: new Date().toISOString(),
+                });
+            }
+            this.responseComplete = false;
+            this.seenToolUse.clear();
+            this.seenToolResult.clear();
+            const ssePromise = this.startSSEStream(port);
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            const messagePayload = JSON.stringify({
+                parts: [{ type: 'text', text: userMessage }],
+            });
+            execInContainer(this.containerName, [
+                'curl',
+                '-s',
+                '-X',
+                'POST',
+                `${baseUrl}/session/${this.sessionId}/message`,
+                '-H',
+                'Content-Type: application/json',
+                '-d',
+                messagePayload,
+            ], { user: 'workspace' }).catch((err) => {
+                console.error('[opencode-server] Send error:', err);
+            });
+            await ssePromise;
+            this.onMessage({
+                type: 'done',
+                content: 'Response complete',
+                timestamp: new Date().toISOString(),
+            });
+        }
+        catch (err) {
+            console.error('[opencode-server] Error:', err);
+            this.onMessage({
+                type: 'error',
+                content: err.message,
+                timestamp: new Date().toISOString(),
+            });
+        }
+    }
+    async startSSEStream(port) {
+        return new Promise((resolve) => {
+            const proc = Bun.spawn([
+                'docker',
+                'exec',
+                '-i',
+                this.containerName,
+                'curl',
+                '-s',
+                '-N',
+                '--max-time',
+                '120',
+                `http://localhost:${port}/event`,
+            ], {
+                stdin: 'ignore',
+                stdout: 'pipe',
+                stderr: 'pipe',
+            });
+            this.sseProcess = proc;
+            const decoder = new TextDecoder();
+            let buffer = '';
+            const processChunk = (chunk) => {
+                buffer += decoder.decode(chunk);
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    if (!line.startsWith('data: '))
+                        continue;
+                    const data = line.slice(6).trim();
+                    if (!data)
+                        continue;
+                    try {
+                        const event = JSON.parse(data);
+                        this.handleEvent(event);
+                        if (event.type === 'session.idle') {
+                            this.responseComplete = true;
+                            proc.kill();
+                            resolve();
+                            return;
+                        }
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+            };
+            (async () => {
+                if (!proc.stdout) {
+                    resolve();
+                    return;
+                }
+                for await (const chunk of proc.stdout) {
+                    processChunk(chunk);
+                    if (this.responseComplete)
+                        break;
+                }
+                resolve();
+            })();
+            setTimeout(() => {
+                if (!this.responseComplete) {
+                    proc.kill();
+                    resolve();
+                }
+            }, 120000);
+        });
+    }
+    handleEvent(event) {
+        const timestamp = new Date().toISOString();
+        if (event.type === 'message.part.updated' && event.properties.part) {
+            const part = event.properties.part;
+            if (part.type === 'text' && event.properties.delta) {
+                this.onMessage({
+                    type: 'assistant',
+                    content: event.properties.delta,
+                    timestamp,
+                });
+            }
+            else if (part.type === 'tool' && part.tool) {
+                const state = part.state;
+                const partId = part.id;
+                if (!this.seenToolUse.has(partId)) {
+                    this.seenToolUse.add(partId);
+                    this.onMessage({
+                        type: 'tool_use',
+                        content: JSON.stringify(state?.input, null, 2),
+                        toolName: state?.title || part.tool,
+                        toolId: partId,
+                        timestamp,
+                    });
+                }
+                if (state?.status === 'completed' && state?.output && !this.seenToolResult.has(partId)) {
+                    this.seenToolResult.add(partId);
+                    this.onMessage({
+                        type: 'tool_result',
+                        content: state.output,
+                        toolId: partId,
+                        timestamp,
+                    });
+                }
+            }
+        }
+    }
+    async interrupt() {
+        if (this.sseProcess) {
+            this.sseProcess.kill();
+            this.sseProcess = null;
+            this.onMessage({
+                type: 'system',
+                content: 'Chat interrupted',
+                timestamp: new Date().toISOString(),
+            });
+        }
+    }
+    getSessionId() {
+        return this.sessionId;
+    }
+}
+export function createOpenCodeServerSession(options, onMessage) {
+    return new OpenCodeServerSession(options, onMessage);
+}

package/dist/chat/opencode-websocket.js

@@ -1,95 +1,23 @@
-import { WebSocket } from 'ws';
-import { BaseWebSocketServer } from '../shared/base-websocket';
-import { createOpencodeSession } from './opencode-handler';
+import { BaseChatWebSocketServer, } from './base-chat-websocket';
 import { createHostOpencodeSession } from './host-opencode-handler';
-import { getContainerName } from '../docker';
-import { HOST_WORKSPACE_NAME } from '../shared/types';
-export class OpencodeWebSocketServer extends BaseWebSocketServer {
-    isHostAccessAllowed;
-    constructor(options) {
-        super(options);
-        this.isHostAccessAllowed = options.isHostAccessAllowed || (() => false);
-    }
-    handleConnection(ws, workspaceName) {
-        const isHostMode = workspaceName === HOST_WORKSPACE_NAME;
-        if (isHostMode && !this.isHostAccessAllowed()) {
-            ws.close(4003, 'Host access is disabled');
-            return;
-        }
-        const connection = {
+import { createOpenCodeServerSession } from './opencode-server';
+export class OpencodeWebSocketServer extends BaseChatWebSocketServer {
+    agentType = 'opencode';
+    createConnection(ws, workspaceName) {
+        return {
             ws,
             session: null,
             workspaceName,
         };
-        this.connections.set(ws, connection);
-        ws.send(JSON.stringify({
-            type: 'connected',
-            workspaceName,
-            agentType: 'opencode',
-            timestamp: new Date().toISOString(),
-        }));
-        ws.on('message', async (data) => {
-            const str = typeof data === 'string' ? data : data.toString();
-            try {
-                const message = JSON.parse(str);
-                if (message.type === 'interrupt') {
-                    if (connection.session) {
-                        await connection.session.interrupt();
-                        connection.session = null;
-                    }
-                    return;
-                }
-                if (message.type === 'message' && message.content) {
-                    const onMessage = (chatMessage) => {
-                        if (ws.readyState === WebSocket.OPEN) {
-                            ws.send(JSON.stringify(chatMessage));
-                        }
-                    };
-                    if (!connection.session) {
-                        if (isHostMode) {
-                            connection.session = createHostOpencodeSession({
-                                sessionId: message.sessionId,
-                            }, onMessage);
-                        }
-                        else {
-                            const containerName = getContainerName(workspaceName);
-                            connection.session = createOpencodeSession({
-                                containerName,
-                                workDir: '/home/workspace',
-                                sessionId: message.sessionId,
-                            }, onMessage);
-                        }
-                    }
-                    await connection.session.sendMessage(message.content);
-                }
-            }
-            catch (err) {
-                ws.send(JSON.stringify({
-                    type: 'error',
-                    content: err.message,
-                    timestamp: new Date().toISOString(),
-                }));
-            }
-        });
-        ws.on('close', () => {
-            const conn = this.connections.get(ws);
-            if (conn?.session) {
-                conn.session.interrupt().catch(() => { });
-            }
-            this.connections.delete(ws);
-        });
-        ws.on('error', (err) => {
-            console.error('OpenCode WebSocket error:', err);
-            const conn = this.connections.get(ws);
-            if (conn?.session) {
-                conn.session.interrupt().catch(() => { });
-            }
-            this.connections.delete(ws);
-        });
     }
-    cleanupConnection(connection) {
-        if (connection.session) {
-            connection.session.interrupt().catch(() => { });
-        }
+    createHostSession(sessionId, onMessage) {
+        return createHostOpencodeSession({ sessionId }, onMessage);
+    }
+    createContainerSession(containerName, sessionId, onMessage) {
+        return createOpenCodeServerSession({
+            containerName,
+            workDir: '/home/workspace',
+            sessionId,
+        }, onMessage);
     }
 }

package/dist/chat/websocket.js

@@ -1,100 +1,33 @@
-import { WebSocket } from 'ws';
-import { BaseWebSocketServer } from '../shared/base-websocket';
+import { BaseChatWebSocketServer, } from './base-chat-websocket';
 import { createChatSession } from './handler';
 import { createHostChatSession } from './host-handler';
-import { getContainerName } from '../docker';
-import { HOST_WORKSPACE_NAME } from '../shared/types';
-export class ChatWebSocketServer extends BaseWebSocketServer {
+export class ChatWebSocketServer extends BaseChatWebSocketServer {
     getConfig;
-    isHostAccessAllowed;
+    agentType = '';
     constructor(options) {
         super(options);
         this.getConfig = options.getConfig;
-        this.isHostAccessAllowed = options.isHostAccessAllowed || (() => false);
     }
-    handleConnection(ws, workspaceName) {
-        const isHostMode = workspaceName === HOST_WORKSPACE_NAME;
-        if (isHostMode && !this.isHostAccessAllowed()) {
-            ws.close(4003, 'Host access is disabled');
-            return;
-        }
-        const connection = {
+    createConnection(ws, workspaceName) {
+        return {
             ws,
             session: null,
             workspaceName,
         };
-        this.connections.set(ws, connection);
-        ws.send(JSON.stringify({
-            type: 'connected',
-            workspaceName,
-            timestamp: new Date().toISOString(),
-        }));
-        ws.on('message', async (data) => {
-            const str = typeof data === 'string' ? data : data.toString();
-            try {
-                const message = JSON.parse(str);
-                if (message.type === 'interrupt') {
-                    if (connection.session) {
-                        await connection.session.interrupt();
-                        connection.session = null;
-                    }
-                    return;
-                }
-                if (message.type === 'message' && message.content) {
-                    const onMessage = (chatMessage) => {
-                        if (ws.readyState === WebSocket.OPEN) {
-                            ws.send(JSON.stringify(chatMessage));
-                        }
-                    };
-                    if (!connection.session) {
-                        const config = this.getConfig();
-                        const model = config.agents?.claude_code?.model;
-                        if (isHostMode) {
-                            connection.session = createHostChatSession({
-                                sessionId: message.sessionId,
-                                model,
-                            }, onMessage);
-                        }
-                        else {
-                            const containerName = getContainerName(workspaceName);
-                            connection.session = createChatSession({
-                                containerName,
-                                workDir: '/home/workspace',
-                                sessionId: message.sessionId,
-                                model,
-                            }, onMessage);
-                        }
-                    }
-                    await connection.session.sendMessage(message.content);
-                }
-            }
-            catch (err) {
-                ws.send(JSON.stringify({
-                    type: 'error',
-                    content: err.message,
-                    timestamp: new Date().toISOString(),
-                }));
-            }
-        });
-        ws.on('close', () => {
-            const conn = this.connections.get(ws);
-            if (conn?.session) {
-                conn.session.interrupt().catch(() => { });
-            }
-            this.connections.delete(ws);
-        });
-        ws.on('error', (err) => {
-            console.error('Chat WebSocket error:', err);
-            const conn = this.connections.get(ws);
-            if (conn?.session) {
-                conn.session.interrupt().catch(() => { });
-            }
-            this.connections.delete(ws);
-        });
     }
-    cleanupConnection(connection) {
-        if (connection.session) {
-            connection.session.interrupt().catch(() => { });
-        }
+    createHostSession(sessionId, onMessage) {
+        const config = this.getConfig();
+        const model = config.agents?.claude_code?.model;
+        return createHostChatSession({ sessionId, model }, onMessage);
+    }
+    createContainerSession(containerName, sessionId, onMessage) {
+        const config = this.getConfig();
+        const model = config.agents?.claude_code?.model;
+        return createChatSession({
+            containerName,
+            workDir: '/home/workspace',
+            sessionId,
+            model,
+        }, onMessage);
     }
 }

package/dist/client/ws-shell.js

@@ -54,9 +54,21 @@ export async function openWSShell(options) {
         let connected = false;
         const stdin = process.stdin;
         const stdout = process.stdout;
+        const safeSend = (data) => {
+            if (ws.readyState !== WebSocket.OPEN) {
+                return false;
+            }
+            try {
+                ws.send(data);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        };
         const sendResize = () => {
-            if (ws.readyState === WebSocket.OPEN && stdout.columns && stdout.rows) {
-                ws.send(JSON.stringify({ type: 'resize', cols: stdout.columns, rows: stdout.rows }));
+            if (stdout.columns && stdout.rows) {
+                safeSend(JSON.stringify({ type: 'resize', cols: stdout.columns, rows: stdout.rows }));
             }
         };
         ws.on('open', () => {
@@ -93,9 +105,7 @@ export async function openWSShell(options) {
             }
         });
         stdin.on('data', (data) => {
-            if (ws.readyState === WebSocket.OPEN) {
-                ws.send(data);
-            }
+            safeSend(data);
         });
         stdout.on('resize', sendResize);
         const cleanup = () => {

package/dist/docker/index.js

@@ -188,6 +188,24 @@ export async function createContainer(options) {
 export async function startContainer(name) {
     await docker(['start', name]);
 }
+export async function waitForContainerReady(name, options = {}) {
+    const timeout = options.timeout ?? 30000;
+    const interval = options.interval ?? 100;
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+        try {
+            const result = await execInContainer(name, ['true']);
+            if (result.exitCode === 0) {
+                return;
+            }
+        }
+        catch {
+            // Container not ready yet
+        }
+        await new Promise((resolve) => setTimeout(resolve, interval));
+    }
+    throw new Error(`Container '${name}' did not become ready within ${timeout}ms`);
+}
 export async function stopContainer(name, timeout = 10) {
     await docker(['stop', '-t', String(timeout), name]);
 }
@@ -335,7 +353,29 @@ export async function imageExists(tag) {
     }
 }
 export async function pullImage(tag) {
-    await docker(['pull', tag]);
+    return new Promise((resolve, reject) => {
+        const child = spawn('docker', ['pull', tag], {
+            stdio: ['ignore', 'inherit', 'inherit'],
+        });
+        child.on('error', reject);
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`Failed to pull image ${tag}`));
+            }
+        });
+    });
+}
+export async function tryPullImage(tag) {
+    try {
+        await pullImage(tag);
+        return true;
+    }
+    catch {
+        return false;
+    }
 }
 export async function buildImage(tag, context, options = {}) {
     const args = ['build', '-t', tag];

package/dist/index.js

@@ -11,7 +11,7 @@ import { startProxy, parsePortForward, formatPortForwards } from './client/proxy
 import { startDockerProxy, parsePortForward as parseDockerPortForward, formatPortForwards as formatDockerPortForwards, } from './client/docker-proxy';
 import { loadAgentConfig, getConfigDir, ensureConfigDir } from './config/loader';
 import { buildImage } from './docker';
-import { DEFAULT_AGENT_PORT, WORKSPACE_IMAGE } from './shared/constants';
+import { DEFAULT_AGENT_PORT, WORKSPACE_IMAGE_LOCAL } from './shared/constants';
 const program = new Command();
 program
     .name('perry')
@@ -430,9 +430,9 @@ program
     .option('--no-cache', 'Build without cache')
     .action(async (options) => {
     const buildContext = './perry';
-    console.log(`Building workspace image ${WORKSPACE_IMAGE}...`);
+    console.log(`Building workspace image ${WORKSPACE_IMAGE_LOCAL}...`);
     try {
-        await buildImage(WORKSPACE_IMAGE, buildContext, {
+        await buildImage(WORKSPACE_IMAGE_LOCAL, buildContext, {
             noCache: options.noCache === false ? false : !options.cache,
         });
         console.log('Build complete.');
@@ -452,6 +452,21 @@ function handleError(err) {
     else if (err instanceof Error) {
         console.error(`Error: ${err.message}`);
     }
+    else if (err && typeof err === 'object') {
+        const errObj = err;
+        if ('message' in errObj && typeof errObj.message === 'string') {
+            console.error(`Error: ${errObj.message}`);
+        }
+        else if ('code' in errObj) {
+            console.error(`Error: ${String(errObj.code)}`);
+        }
+        else {
+            console.error(`Error: ${JSON.stringify(err)}`);
+        }
+    }
+    else if (err !== undefined && err !== null) {
+        console.error(`Error: ${String(err)}`);
+    }
     else {
         console.error('An unknown error occurred');
     }