@gricha/perry 0.0.1

package/dist/chat/host-opencode-handler.js

@@ -0,0 +1,169 @@
+import { homedir } from 'os';
+export class HostOpencodeSession {
+    process = null;
+    workDir;
+    sessionId;
+    onMessage;
+    buffer = '';
+    constructor(options, onMessage) {
+        this.workDir = options.workDir || homedir();
+        this.sessionId = options.sessionId;
+        this.onMessage = onMessage;
+    }
+    async sendMessage(userMessage) {
+        const args = ['run', '--format', 'json'];
+        if (this.sessionId) {
+            args.push('--session', this.sessionId);
+        }
+        args.push(userMessage);
+        console.log('[host-opencode] Running: opencode', args.join(' '));
+        this.onMessage({
+            type: 'system',
+            content: 'Processing your message...',
+            timestamp: new Date().toISOString(),
+        });
+        try {
+            const proc = Bun.spawn(['opencode', ...args], {
+                cwd: this.workDir,
+                stdin: 'ignore',
+                stdout: 'pipe',
+                stderr: 'pipe',
+                env: {
+                    ...process.env,
+                },
+            });
+            this.process = proc;
+            if (!proc.stdout || !proc.stderr) {
+                throw new Error('Failed to get process streams');
+            }
+            console.log('[host-opencode] Process spawned, waiting for output...');
+            const stderrPromise = new Response(proc.stderr).text();
+            const decoder = new TextDecoder();
+            let receivedAnyOutput = false;
+            for await (const chunk of proc.stdout) {
+                const text = decoder.decode(chunk);
+                console.log('[host-opencode] Received chunk:', text.length, 'bytes');
+                receivedAnyOutput = true;
+                this.buffer += text;
+                this.processBuffer();
+            }
+            const exitCode = await proc.exited;
+            console.log('[host-opencode] Process exited with code:', exitCode, 'receivedOutput:', receivedAnyOutput);
+            const stderrText = await stderrPromise;
+            if (stderrText) {
+                console.error('[host-opencode] stderr:', stderrText);
+            }
+            if (exitCode !== 0) {
+                this.onMessage({
+                    type: 'error',
+                    content: stderrText || `OpenCode exited with code ${exitCode}`,
+                    timestamp: new Date().toISOString(),
+                });
+                return;
+            }
+            if (!receivedAnyOutput) {
+                this.onMessage({
+                    type: 'error',
+                    content: 'No response from OpenCode. Check if OpenCode is installed and configured.',
+                    timestamp: new Date().toISOString(),
+                });
+                return;
+            }
+            this.onMessage({
+                type: 'done',
+                content: 'Response complete',
+                timestamp: new Date().toISOString(),
+            });
+        }
+        catch (err) {
+            console.error('[host-opencode] Error:', err);
+            this.onMessage({
+                type: 'error',
+                content: err.message,
+                timestamp: new Date().toISOString(),
+            });
+        }
+        finally {
+            this.process = null;
+        }
+    }
+    processBuffer() {
+        const lines = this.buffer.split('\n');
+        this.buffer = lines.pop() || '';
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            try {
+                const event = JSON.parse(line);
+                this.handleStreamEvent(event);
+            }
+            catch {
+                console.error('[host-opencode] Failed to parse:', line);
+            }
+        }
+    }
+    handleStreamEvent(event) {
+        const timestamp = new Date().toISOString();
+        if (event.type === 'step_start' && event.sessionID) {
+            if (!this.sessionId) {
+                this.sessionId = event.sessionID;
+                this.onMessage({
+                    type: 'system',
+                    content: `Session started ${this.sessionId}`,
+                    timestamp,
+                });
+            }
+            return;
+        }
+        if (event.type === 'text' && event.part?.text) {
+            this.onMessage({
+                type: 'assistant',
+                content: event.part.text,
+                timestamp,
+            });
+            return;
+        }
+        if (event.type === 'tool_use' && event.part) {
+            const toolName = event.part.tool || 'unknown';
+            const toolId = event.part.callID || event.part.id;
+            const input = event.part.state?.input;
+            const output = event.part.state?.output;
+            const title = event.part.state?.title || input?.description || toolName;
+            console.log('[host-opencode] Tool use:', toolName, title);
+            this.onMessage({
+                type: 'tool_use',
+                content: JSON.stringify(input, null, 2),
+                toolName: title || toolName,
+                toolId,
+                timestamp,
+            });
+            if (output) {
+                this.onMessage({
+                    type: 'tool_result',
+                    content: output,
+                    toolName,
+                    toolId,
+                    timestamp,
+                });
+            }
+            return;
+        }
+    }
+    async interrupt() {
+        if (this.process) {
+            this.process.kill();
+            this.process = null;
+            this.onMessage({
+                type: 'system',
+                content: 'Chat interrupted',
+                timestamp: new Date().toISOString(),
+            });
+        }
+    }
+    getSessionId() {
+        return this.sessionId;
+    }
+}
+export function createHostOpencodeSession(options, onMessage) {
+    return new HostOpencodeSession(options, onMessage);
+}

package/dist/chat/index.js

@@ -0,0 +1,2 @@
+export * from './handler';
+export * from './websocket';

package/dist/chat/opencode-handler.js

@@ -0,0 +1,177 @@
+export class OpencodeSession {
+    process = null;
+    containerName;
+    workDir;
+    sessionId;
+    onMessage;
+    buffer = '';
+    constructor(options, onMessage) {
+        this.containerName = options.containerName;
+        this.workDir = options.workDir || '/home/workspace';
+        this.sessionId = options.sessionId;
+        this.onMessage = onMessage;
+    }
+    async sendMessage(userMessage) {
+        const args = [
+            'exec',
+            '-u',
+            'workspace',
+            '-w',
+            this.workDir,
+            this.containerName,
+            'opencode',
+            'run',
+            '--format',
+            'json',
+        ];
+        if (this.sessionId) {
+            args.push('--session', this.sessionId);
+        }
+        args.push(userMessage);
+        console.log('[opencode] Running:', 'docker', args.join(' '));
+        this.onMessage({
+            type: 'system',
+            content: 'Processing your message...',
+            timestamp: new Date().toISOString(),
+        });
+        try {
+            const proc = Bun.spawn(['docker', ...args], {
+                stdin: 'ignore',
+                stdout: 'pipe',
+                stderr: 'pipe',
+            });
+            this.process = proc;
+            if (!proc.stdout || !proc.stderr) {
+                throw new Error('Failed to get process streams');
+            }
+            console.log('[opencode] Process spawned, waiting for output...');
+            const stderrPromise = new Response(proc.stderr).text();
+            const decoder = new TextDecoder();
+            let receivedAnyOutput = false;
+            for await (const chunk of proc.stdout) {
+                const text = decoder.decode(chunk);
+                console.log('[opencode] Received chunk:', text.length, 'bytes');
+                receivedAnyOutput = true;
+                this.buffer += text;
+                this.processBuffer();
+            }
+            const exitCode = await proc.exited;
+            console.log('[opencode] Process exited with code:', exitCode, 'receivedOutput:', receivedAnyOutput);
+            const stderrText = await stderrPromise;
+            if (stderrText) {
+                console.error('[opencode] stderr:', stderrText);
+            }
+            if (exitCode !== 0) {
+                this.onMessage({
+                    type: 'error',
+                    content: stderrText || `OpenCode exited with code ${exitCode}`,
+                    timestamp: new Date().toISOString(),
+                });
+                return;
+            }
+            if (!receivedAnyOutput) {
+                this.onMessage({
+                    type: 'error',
+                    content: 'No response from OpenCode. Check if OpenCode is configured in the workspace.',
+                    timestamp: new Date().toISOString(),
+                });
+                return;
+            }
+            this.onMessage({
+                type: 'done',
+                content: 'Response complete',
+                timestamp: new Date().toISOString(),
+            });
+        }
+        catch (err) {
+            console.error('[opencode] Error:', err);
+            this.onMessage({
+                type: 'error',
+                content: err.message,
+                timestamp: new Date().toISOString(),
+            });
+        }
+        finally {
+            this.process = null;
+        }
+    }
+    processBuffer() {
+        const lines = this.buffer.split('\n');
+        this.buffer = lines.pop() || '';
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            try {
+                const event = JSON.parse(line);
+                this.handleStreamEvent(event);
+            }
+            catch {
+                console.error('[opencode] Failed to parse:', line);
+            }
+        }
+    }
+    handleStreamEvent(event) {
+        const timestamp = new Date().toISOString();
+        if (event.type === 'step_start' && event.sessionID) {
+            if (!this.sessionId) {
+                this.sessionId = event.sessionID;
+                this.onMessage({
+                    type: 'system',
+                    content: `Session started ${this.sessionId}`,
+                    timestamp,
+                });
+            }
+            return;
+        }
+        if (event.type === 'text' && event.part?.text) {
+            this.onMessage({
+                type: 'assistant',
+                content: event.part.text,
+                timestamp,
+            });
+            return;
+        }
+        if (event.type === 'tool_use' && event.part) {
+            const toolName = event.part.tool || 'unknown';
+            const toolId = event.part.callID || event.part.id;
+            const input = event.part.state?.input;
+            const output = event.part.state?.output;
+            const title = event.part.state?.title || input?.description || toolName;
+            console.log('[opencode] Tool use:', toolName, title);
+            this.onMessage({
+                type: 'tool_use',
+                content: JSON.stringify(input, null, 2),
+                toolName: title || toolName,
+                toolId,
+                timestamp,
+            });
+            if (output) {
+                this.onMessage({
+                    type: 'tool_result',
+                    content: output,
+                    toolName,
+                    toolId,
+                    timestamp,
+                });
+            }
+            return;
+        }
+    }
+    async interrupt() {
+        if (this.process) {
+            this.process.kill();
+            this.process = null;
+            this.onMessage({
+                type: 'system',
+                content: 'Chat interrupted',
+                timestamp: new Date().toISOString(),
+            });
+        }
+    }
+    getSessionId() {
+        return this.sessionId;
+    }
+}
+export function createOpencodeSession(options, onMessage) {
+    return new OpencodeSession(options, onMessage);
+}

package/dist/chat/opencode-websocket.js

@@ -0,0 +1,95 @@
+import { WebSocket } from 'ws';
+import { BaseWebSocketServer } from '../shared/base-websocket';
+import { createOpencodeSession } from './opencode-handler';
+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 = {
+            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(() => { });
+        }
+    }
+}

package/dist/chat/websocket.js

@@ -0,0 +1,100 @@
+import { WebSocket } from 'ws';
+import { BaseWebSocketServer } from '../shared/base-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 {
+    getConfig;
+    isHostAccessAllowed;
+    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 = {
+            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(() => { });
+        }
+    }
+}

package/dist/client/api.js

@@ -0,0 +1,138 @@
+import { createORPCClient } from '@orpc/client';
+import { RPCLink } from '@orpc/client/fetch';
+import { DEFAULT_AGENT_PORT } from '../shared/constants';
+export class ApiClientError extends Error {
+    status;
+    code;
+    constructor(message, status, code) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.name = 'ApiClientError';
+    }
+}
+export class ApiClient {
+    baseUrl;
+    client;
+    constructor(options) {
+        this.baseUrl = options.baseUrl.replace(/\/$/, '');
+        const link = new RPCLink({
+            url: `${this.baseUrl}/rpc`,
+            fetch: (url, init) => fetch(url, { ...init, signal: AbortSignal.timeout(options.timeout || 30000) }),
+        });
+        this.client = createORPCClient(link);
+    }
+    async health() {
+        const response = await fetch(`${this.baseUrl}/health`);
+        return response.json();
+    }
+    async info() {
+        try {
+            return await this.client.info();
+        }
+        catch (err) {
+            throw this.wrapError(err);
+        }
+    }
+    async listWorkspaces() {
+        try {
+            return await this.client.workspaces.list();
+        }
+        catch (err) {
+            throw this.wrapError(err);
+        }
+    }
+    async getWorkspace(name) {
+        try {
+            return await this.client.workspaces.get({ name });
+        }
+        catch (err) {
+            throw this.wrapError(err);
+        }
+    }
+    async createWorkspace(request) {
+        try {
+            return await this.client.workspaces.create(request);
+        }
+        catch (err) {
+            throw this.wrapError(err);
+        }
+    }
+    async deleteWorkspace(name) {
+        try {
+            await this.client.workspaces.delete({ name });
+        }
+        catch (err) {
+            throw this.wrapError(err);
+        }
+    }
+    async startWorkspace(name) {
+        try {
+            return await this.client.workspaces.start({ name });
+        }
+        catch (err) {
+            throw this.wrapError(err);
+        }
+    }
+    async stopWorkspace(name) {
+        try {
+            return await this.client.workspaces.stop({ name });
+        }
+        catch (err) {
+            throw this.wrapError(err);
+        }
+    }
+    async getLogs(name, tail) {
+        try {
+            return await this.client.workspaces.logs({ name, tail });
+        }
+        catch (err) {
+            throw this.wrapError(err);
+        }
+    }
+    async syncWorkspace(name) {
+        try {
+            await this.client.workspaces.sync({ name });
+        }
+        catch (err) {
+            throw this.wrapError(err);
+        }
+    }
+    getTerminalUrl(name) {
+        const wsUrl = this.baseUrl.replace(/^http/, 'ws');
+        return `${wsUrl}/rpc/terminal/${encodeURIComponent(name)}`;
+    }
+    wrapError(err) {
+        if (err instanceof ApiClientError) {
+            return err;
+        }
+        if (err instanceof Error) {
+            if (err.message.includes('fetch failed') || err.message.includes('ECONNREFUSED')) {
+                return new ApiClientError(`Cannot connect to agent at ${this.baseUrl}`, 0, 'CONNECTION_FAILED');
+            }
+            if (err.name === 'TimeoutError' || err.message.includes('timeout')) {
+                return new ApiClientError('Request timed out', 0, 'TIMEOUT');
+            }
+            const orpcError = err;
+            if (orpcError.code) {
+                return new ApiClientError(err.message, orpcError.status || 500, orpcError.code);
+            }
+            return new ApiClientError(err.message, 0, 'UNKNOWN');
+        }
+        return new ApiClientError('Unknown error', 0, 'UNKNOWN');
+    }
+}
+export function createApiClient(worker, port) {
+    let baseUrl;
+    if (worker.includes('://')) {
+        baseUrl = worker;
+    }
+    else if (worker.includes(':')) {
+        baseUrl = `http://${worker}`;
+    }
+    else {
+        const effectivePort = port || DEFAULT_AGENT_PORT;
+        baseUrl = `http://${worker}:${effectivePort}`;
+    }
+    return new ApiClient({ baseUrl });
+}