@gricha/perry 0.2.6 → 0.3.0

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

@@ -0,0 +1,317 @@
+import { execInContainer } from '../../docker';
+const MESSAGE_TIMEOUT_MS = 30000;
+const SSE_TIMEOUT_MS = 120000;
+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 getServerLogs(containerName) {
+    try {
+        const result = await execInContainer(containerName, ['tail', '-20', '/tmp/opencode-server.log'], {
+            user: 'workspace',
+        });
+        return result.stdout;
+    }
+    catch {
+        return '(no logs available)';
+    }
+}
+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] 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 ready on port ${port}`);
+                serverPorts.set(containerName, port);
+                serverStarting.delete(containerName);
+                return port;
+            }
+        }
+        serverStarting.delete(containerName);
+        const logs = await getServerLogs(containerName);
+        throw new Error(`Failed to start OpenCode server. Logs:\n${logs}`);
+    })();
+    serverStarting.set(containerName, startPromise);
+    return startPromise;
+}
+export class OpenCodeAdapter {
+    agentType = 'opencode';
+    containerName;
+    agentSessionId;
+    model;
+    status = 'idle';
+    port;
+    sseProcess = null;
+    messageCallback;
+    statusCallback;
+    errorCallback;
+    onMessage(callback) {
+        this.messageCallback = callback;
+    }
+    onStatusChange(callback) {
+        this.statusCallback = callback;
+    }
+    onError(callback) {
+        this.errorCallback = callback;
+    }
+    async start(options) {
+        if (options.isHost) {
+            throw new Error('OpenCode adapter does not support host mode');
+        }
+        this.containerName = options.containerName;
+        this.agentSessionId = options.agentSessionId;
+        this.model = options.model;
+        try {
+            this.port = await startServer(this.containerName);
+            this.setStatus('idle');
+        }
+        catch (err) {
+            this.emitError(err);
+            throw err;
+        }
+    }
+    async sendMessage(message) {
+        if (!this.containerName || !this.port) {
+            const err = new Error('Adapter not started');
+            this.emitError(err);
+            throw err;
+        }
+        if (this.status === 'running') {
+            const err = new Error('Session is already processing a message');
+            this.emitError(err);
+            throw err;
+        }
+        const baseUrl = `http://localhost:${this.port}`;
+        try {
+            if (!this.agentSessionId) {
+                this.agentSessionId = await this.createSession(baseUrl);
+                this.emit({ type: 'system', content: `Session: ${this.agentSessionId.slice(0, 8)}...` });
+            }
+            this.setStatus('running');
+            this.emit({ type: 'system', content: 'Processing...' });
+            await this.sendAndStream(baseUrl, message);
+            this.setStatus('idle');
+            this.emit({ type: 'done', content: 'Response complete' });
+        }
+        catch (err) {
+            this.cleanup();
+            this.setStatus('error');
+            this.emitError(err);
+            this.emit({ type: 'error', content: err.message });
+            throw err;
+        }
+    }
+    async createSession(baseUrl) {
+        const payload = this.model ? JSON.stringify({ model: this.model }) : '{}';
+        const result = await execInContainer(this.containerName, [
+            'curl',
+            '-s',
+            '-f',
+            '--max-time',
+            String(MESSAGE_TIMEOUT_MS / 1000),
+            '-X',
+            'POST',
+            `${baseUrl}/session`,
+            '-H',
+            'Content-Type: application/json',
+            '-d',
+            payload,
+        ], { user: 'workspace' });
+        if (result.exitCode !== 0) {
+            throw new Error(`Failed to create session: ${result.stderr || 'Unknown error'}`);
+        }
+        const session = JSON.parse(result.stdout);
+        return session.id;
+    }
+    async sendAndStream(baseUrl, message) {
+        const sseReady = this.startSSEStream();
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        const payload = JSON.stringify({ parts: [{ type: 'text', text: message }] });
+        const result = await execInContainer(this.containerName, [
+            'curl',
+            '-s',
+            '-f',
+            '--max-time',
+            String(MESSAGE_TIMEOUT_MS / 1000),
+            '-X',
+            'POST',
+            `${baseUrl}/session/${this.agentSessionId}/message`,
+            '-H',
+            'Content-Type: application/json',
+            '-d',
+            payload,
+        ], { user: 'workspace' });
+        if (result.exitCode !== 0) {
+            throw new Error(`Failed to send message: ${result.stderr || 'Connection failed'}`);
+        }
+        await sseReady;
+    }
+    startSSEStream() {
+        return new Promise((resolve, reject) => {
+            const seenTools = new Set();
+            let resolved = false;
+            let receivedIdle = false;
+            const proc = Bun.spawn([
+                'docker',
+                'exec',
+                '-i',
+                this.containerName,
+                'curl',
+                '-s',
+                '-N',
+                '--max-time',
+                String(SSE_TIMEOUT_MS / 1000),
+                `http://localhost:${this.port}/event`,
+            ], { stdin: 'ignore', stdout: 'pipe', stderr: 'pipe' });
+            this.sseProcess = proc;
+            const decoder = new TextDecoder();
+            let buffer = '';
+            const finish = () => {
+                if (!resolved) {
+                    resolved = true;
+                    resolve();
+                }
+            };
+            const timeout = setTimeout(() => {
+                proc.kill();
+                if (!resolved) {
+                    resolved = true;
+                    reject(new Error('SSE stream timeout'));
+                }
+            }, SSE_TIMEOUT_MS);
+            (async () => {
+                if (!proc.stdout) {
+                    clearTimeout(timeout);
+                    reject(new Error('Failed to start SSE stream'));
+                    return;
+                }
+                try {
+                    for await (const chunk of proc.stdout) {
+                        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);
+                                if (event.type === 'session.idle') {
+                                    receivedIdle = true;
+                                    clearTimeout(timeout);
+                                    proc.kill();
+                                    finish();
+                                    return;
+                                }
+                                if (event.type === 'message.part.updated' && event.properties.part) {
+                                    const part = event.properties.part;
+                                    if (part.type === 'text' && event.properties.delta) {
+                                        this.emit({ type: 'assistant', content: event.properties.delta });
+                                    }
+                                    else if (part.type === 'tool' && part.tool && !seenTools.has(part.id)) {
+                                        seenTools.add(part.id);
+                                        this.emit({
+                                            type: 'tool_use',
+                                            content: JSON.stringify(part.state?.input, null, 2),
+                                            toolName: part.state?.title || part.tool,
+                                            toolId: part.id,
+                                        });
+                                        if (part.state?.status === 'completed' && part.state?.output) {
+                                            this.emit({
+                                                type: 'tool_result',
+                                                content: part.state.output,
+                                                toolId: part.id,
+                                            });
+                                        }
+                                    }
+                                }
+                            }
+                            catch {
+                                // Invalid JSON, skip
+                            }
+                        }
+                    }
+                }
+                catch (err) {
+                    clearTimeout(timeout);
+                    if (!resolved) {
+                        resolved = true;
+                        reject(err);
+                    }
+                    return;
+                }
+                clearTimeout(timeout);
+                if (receivedIdle) {
+                    finish();
+                }
+                else if (!resolved) {
+                    resolved = true;
+                    reject(new Error('SSE stream ended unexpectedly without session.idle'));
+                }
+            })();
+        });
+    }
+    cleanup() {
+        if (this.sseProcess) {
+            this.sseProcess.kill();
+            this.sseProcess = null;
+        }
+    }
+    async interrupt() {
+        this.cleanup();
+        if (this.status === 'running') {
+            this.setStatus('interrupted');
+            this.emit({ type: 'system', content: 'Interrupted' });
+        }
+    }
+    async dispose() {
+        await this.interrupt();
+    }
+    getAgentSessionId() {
+        return this.agentSessionId;
+    }
+    getStatus() {
+        return this.status;
+    }
+    setStatus(status) {
+        this.status = status;
+        this.statusCallback?.(status);
+    }
+    emit(msg) {
+        this.messageCallback?.({ ...msg, timestamp: new Date().toISOString() });
+    }
+    emitError(error) {
+        this.errorCallback?.(error);
+    }
+}

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

@@ -0,0 +1,175 @@
+import { sessionManager } from './manager';
+import { HOST_WORKSPACE_NAME } from '../shared/client-types';
+function safeSend(ws, data) {
+    try {
+        ws.send(data);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export class LiveChatHandler {
+    connections = new Map();
+    isHostAccessAllowed;
+    agentType;
+    constructor(options) {
+        this.isHostAccessAllowed = options.isHostAccessAllowed || (() => false);
+        this.agentType = options.agentType;
+    }
+    handleOpen(ws, workspaceName) {
+        const isHostMode = workspaceName === HOST_WORKSPACE_NAME;
+        if (isHostMode && !this.isHostAccessAllowed()) {
+            ws.close(4003, 'Host access is disabled');
+            return;
+        }
+        const connection = {
+            ws,
+            workspaceName,
+            sessionId: null,
+            clientId: null,
+            agentType: this.agentType,
+        };
+        this.connections.set(ws, connection);
+        safeSend(ws, JSON.stringify({
+            type: 'connected',
+            workspaceName,
+            agentType: this.agentType,
+            timestamp: new Date().toISOString(),
+        }));
+    }
+    async handleMessage(ws, data) {
+        const connection = this.connections.get(ws);
+        if (!connection)
+            return;
+        try {
+            const message = JSON.parse(data);
+            if (message.type === 'connect') {
+                await this.handleConnect(connection, message);
+                return;
+            }
+            if (message.type === 'disconnect') {
+                this.handleDisconnect(connection);
+                return;
+            }
+            if (message.type === 'interrupt') {
+                if (connection.sessionId) {
+                    await sessionManager.interrupt(connection.sessionId);
+                }
+                return;
+            }
+            if (message.type === 'message' && message.content) {
+                await this.handleChatMessage(connection, message);
+            }
+        }
+        catch (err) {
+            safeSend(ws, JSON.stringify({
+                type: 'error',
+                content: err.message,
+                timestamp: new Date().toISOString(),
+            }));
+        }
+    }
+    handleClose(ws, _code, _reason) {
+        const connection = this.connections.get(ws);
+        if (connection) {
+            this.handleDisconnect(connection);
+        }
+        this.connections.delete(ws);
+    }
+    handleError(ws, error) {
+        console.error('Live chat WebSocket error:', error);
+        const connection = this.connections.get(ws);
+        if (connection) {
+            this.handleDisconnect(connection);
+        }
+        this.connections.delete(ws);
+    }
+    async handleConnect(connection, message) {
+        const { ws, workspaceName } = connection;
+        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);
+            if (found) {
+                connection.sessionId = found.sessionId;
+                const sendFn = (msg) => {
+                    safeSend(ws, JSON.stringify(msg));
+                };
+                const clientId = sessionManager.connectClient(found.sessionId, sendFn, {
+                    resumeFromId: message.resumeFromId,
+                });
+                if (clientId) {
+                    connection.clientId = clientId;
+                    safeSend(ws, JSON.stringify({
+                        type: 'session_joined',
+                        sessionId: found.sessionId,
+                        status: found.info.status,
+                        agentSessionId: found.info.agentSessionId,
+                        timestamp: new Date().toISOString(),
+                    }));
+                    return;
+                }
+            }
+        }
+        const sessionId = await sessionManager.startSession({
+            workspaceName,
+            agentType,
+            sessionId: message.sessionId,
+            agentSessionId: message.agentSessionId,
+            model: message.model,
+            projectPath: message.projectPath,
+        });
+        connection.sessionId = sessionId;
+        const sendFn = (msg) => {
+            safeSend(ws, JSON.stringify(msg));
+        };
+        const clientId = sessionManager.connectClient(sessionId, sendFn);
+        connection.clientId = clientId;
+        safeSend(ws, JSON.stringify({
+            type: 'session_started',
+            sessionId,
+            timestamp: new Date().toISOString(),
+        }));
+    }
+    async handleChatMessage(connection, message) {
+        if (!connection.sessionId) {
+            await this.handleConnect(connection, {
+                type: 'connect',
+                agentType: message.agentType || this.agentType,
+                agentSessionId: message.agentSessionId,
+                model: message.model,
+                projectPath: message.projectPath,
+            });
+        }
+        if (!connection.sessionId) {
+            throw new Error('Failed to create session');
+        }
+        await sessionManager.sendMessage(connection.sessionId, message.content);
+    }
+    handleDisconnect(connection) {
+        if (connection.sessionId && connection.clientId) {
+            sessionManager.disconnectClient(connection.sessionId, connection.clientId);
+            connection.clientId = null;
+        }
+    }
+    getConnectionCount() {
+        return this.connections.size;
+    }
+    closeConnectionsForWorkspace(workspaceName) {
+        for (const [ws, connection] of this.connections) {
+            if (connection.workspaceName === workspaceName) {
+                this.handleDisconnect(connection);
+                ws.close(1001, 'Workspace stopped');
+                this.connections.delete(ws);
+            }
+        }
+    }
+    close() {
+        for (const [ws, connection] of this.connections.entries()) {
+            this.handleDisconnect(connection);
+            ws.close(1001, 'Server shutting down');
+        }
+        this.connections.clear();
+    }
+}

package/dist/session-manager/index.js

@@ -0,0 +1,3 @@
+export { SessionManager, sessionManager } from './manager';
+export { RingBuffer } from './ring-buffer';
+export { LiveChatWebSocketServer, createLiveChatWebSocketServer } from './websocket';