@gricha/perry 0.2.6 → 0.3.1

package/dist/chat/opencode-handler.js

@@ -1,100 +0,0 @@
-import { BaseOpencodeSession } from './base-opencode-session';
-import { opencodeProvider } from '../sessions/agents/opencode';
-export class OpencodeSession extends BaseOpencodeSession {
-    containerName;
-    workDir;
-    constructor(options, onMessage) {
-        super(options.sessionId, options.model, onMessage);
-        this.containerName = options.containerName;
-        this.workDir = options.workDir || '/home/workspace';
-    }
-    getLogPrefix() {
-        return 'opencode';
-    }
-    getNoOutputErrorMessage() {
-        return 'No response from OpenCode. Check if OpenCode is configured in the workspace.';
-    }
-    getSpawnConfig(userMessage) {
-        const args = [
-            'docker',
-            'exec',
-            '-i',
-            '-u',
-            'workspace',
-            '-w',
-            this.workDir,
-            this.containerName,
-            'stdbuf',
-            '-oL',
-            'opencode',
-            'run',
-            '--format',
-            'json',
-        ];
-        if (this.sessionId) {
-            args.push('--session', this.sessionId);
-        }
-        if (this.model) {
-            args.push('--model', this.model);
-        }
-        args.push(userMessage);
-        return {
-            command: args,
-            options: {},
-        };
-    }
-    async loadHistory() {
-        if (this.historyLoaded || !this.sessionId) {
-            return;
-        }
-        this.historyLoaded = true;
-        const exec = async (containerName, command, options) => {
-            const args = ['exec'];
-            if (options?.user) {
-                args.push('-u', options.user);
-            }
-            args.push(containerName, ...command);
-            const proc = Bun.spawn(['docker', ...args], {
-                stdin: 'ignore',
-                stdout: 'pipe',
-                stderr: 'pipe',
-            });
-            const [stdout, stderr, exitCode] = await Promise.all([
-                new Response(proc.stdout).text(),
-                new Response(proc.stderr).text(),
-                proc.exited,
-            ]);
-            return { stdout, stderr, exitCode };
-        };
-        try {
-            const result = await opencodeProvider.getSessionMessages(this.containerName, this.sessionId, exec);
-            if (result && result.messages.length > 0) {
-                this.onMessage({
-                    type: 'system',
-                    content: `Loading ${result.messages.length} messages from session history...`,
-                    timestamp: new Date().toISOString(),
-                });
-                for (const msg of result.messages) {
-                    this.onMessage({
-                        type: msg.type,
-                        content: msg.content || '',
-                        toolName: msg.toolName,
-                        toolId: msg.toolId,
-                        timestamp: msg.timestamp || new Date().toISOString(),
-                    });
-                }
-                this.onMessage({
-                    type: 'system',
-                    content: 'Session history loaded',
-                    timestamp: new Date().toISOString(),
-                });
-            }
-        }
-        catch (err) {
-            console.error('[opencode] Failed to load history:', err);
-        }
-    }
-}
-export function createOpencodeSession(options, onMessage) {
-    return new OpencodeSession(options, onMessage);
-}

package/dist/chat/opencode-server.js

@@ -1,285 +0,0 @@
-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;
-    model;
-    sessionModel;
-    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.model = options.model;
-        this.sessionModel = options.model;
-        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 sessionPayload = this.model ? JSON.stringify({ model: this.model }) : '{}';
-                const createResult = await execInContainer(this.containerName, [
-                    'curl',
-                    '-s',
-                    '-X',
-                    'POST',
-                    `${baseUrl}/session`,
-                    '-H',
-                    'Content-Type: application/json',
-                    '-d',
-                    sessionPayload,
-                ], { user: 'workspace' });
-                const session = JSON.parse(createResult.stdout);
-                this.sessionId = session.id;
-                this.sessionModel = this.model;
-                this.onMessage({
-                    type: 'system',
-                    content: `Session started ${this.sessionId}`,
-                    timestamp: new Date().toISOString(),
-                });
-            }
-            this.responseComplete = false;
-            this.seenToolUse.clear();
-            this.seenToolResult.clear();
-            const { ready, done } = await this.startSSEStream(port);
-            await ready;
-            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 done;
-            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) {
-        let resolveReady;
-        let resolveDone;
-        const ready = new Promise((r) => (resolveReady = r));
-        const done = new Promise((r) => (resolveDone = r));
-        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 = '';
-        let hasReceivedData = false;
-        const processChunk = (chunk) => {
-            buffer += decoder.decode(chunk);
-            if (!hasReceivedData) {
-                hasReceivedData = true;
-                resolveReady();
-            }
-            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();
-                        resolveDone();
-                        return;
-                    }
-                }
-                catch {
-                    continue;
-                }
-            }
-        };
-        (async () => {
-            if (!proc.stdout) {
-                resolveReady();
-                resolveDone();
-                return;
-            }
-            for await (const chunk of proc.stdout) {
-                processChunk(chunk);
-                if (this.responseComplete)
-                    break;
-            }
-            resolveDone();
-        })();
-        setTimeout(() => {
-            if (!hasReceivedData) {
-                resolveReady();
-            }
-        }, 500);
-        setTimeout(() => {
-            if (!this.responseComplete) {
-                proc.kill();
-                resolveDone();
-            }
-        }, 120000);
-        return { ready, done };
-    }
-    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(),
-            });
-        }
-    }
-    setModel(model) {
-        if (this.model !== model) {
-            this.model = model;
-            if (this.sessionModel !== model) {
-                this.sessionId = undefined;
-                this.onMessage({
-                    type: 'system',
-                    content: `Switching to model: ${model}`,
-                    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,31 +0,0 @@
-import { BaseChatWebSocketServer, } from './base-chat-websocket';
-import { createHostOpencodeSession } from './host-opencode-handler';
-import { createOpenCodeServerSession } from './opencode-server';
-export class OpencodeWebSocketServer extends BaseChatWebSocketServer {
-    agentType = 'opencode';
-    getConfig;
-    constructor(options) {
-        super(options);
-        this.getConfig = options.getConfig;
-    }
-    createConnection(ws, workspaceName) {
-        return {
-            ws,
-            session: null,
-            workspaceName,
-        };
-    }
-    createHostSession(sessionId, onMessage, messageModel, _projectPath) {
-        const model = messageModel || this.getConfig?.()?.agents?.opencode?.model;
-        return createHostOpencodeSession({ sessionId, model }, onMessage);
-    }
-    createContainerSession(containerName, sessionId, onMessage, messageModel) {
-        const model = messageModel || this.getConfig?.()?.agents?.opencode?.model;
-        return createOpenCodeServerSession({
-            containerName,
-            workDir: '/home/workspace',
-            sessionId,
-            model,
-        }, onMessage);
-    }
-}

package/dist/chat/websocket.js

@@ -1,33 +0,0 @@
-import { BaseChatWebSocketServer, } from './base-chat-websocket';
-import { createChatSession } from './handler';
-import { createHostChatSession } from './host-handler';
-export class ChatWebSocketServer extends BaseChatWebSocketServer {
-    getConfig;
-    agentType = '';
-    constructor(options) {
-        super(options);
-        this.getConfig = options.getConfig;
-    }
-    createConnection(ws, workspaceName) {
-        return {
-            ws,
-            session: null,
-            workspaceName,
-        };
-    }
-    createHostSession(sessionId, onMessage, messageModel, projectPath) {
-        const config = this.getConfig();
-        const model = messageModel || config.agents?.claude_code?.model;
-        return createHostChatSession({ sessionId, model, workDir: projectPath }, onMessage);
-    }
-    createContainerSession(containerName, sessionId, onMessage, messageModel) {
-        const config = this.getConfig();
-        const model = messageModel || config.agents?.claude_code?.model;
-        return createChatSession({
-            containerName,
-            workDir: '/home/workspace',
-            sessionId,
-            model,
-        }, onMessage);
-    }
-}