@gricha/perry 0.2.2 → 0.2.4

package/dist/chat/base-opencode-session.js

@@ -0,0 +1,181 @@
+export class BaseOpencodeSession {
+    process = null;
+    sessionId;
+    model;
+    sessionModel;
+    onMessage;
+    buffer = '';
+    historyLoaded = false;
+    constructor(sessionId, model, onMessage) {
+        this.sessionId = sessionId;
+        this.model = model;
+        this.sessionModel = model;
+        this.onMessage = onMessage;
+    }
+    async sendMessage(userMessage) {
+        if (this.sessionId && !this.historyLoaded) {
+            await this.loadHistory();
+        }
+        const logPrefix = this.getLogPrefix();
+        const { command, options } = this.getSpawnConfig(userMessage);
+        console.log(`[${logPrefix}] Running:`, command.join(' '));
+        this.onMessage({
+            type: 'system',
+            content: 'Processing your message...',
+            timestamp: new Date().toISOString(),
+        });
+        try {
+            const proc = Bun.spawn(command, {
+                stdin: 'ignore',
+                stdout: 'pipe',
+                stderr: 'pipe',
+                ...options,
+            });
+            this.process = proc;
+            if (!proc.stdout || !proc.stderr) {
+                throw new Error('Failed to get process streams');
+            }
+            console.log(`[${logPrefix}] 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(`[${logPrefix}] Received chunk:`, text.length, 'bytes');
+                receivedAnyOutput = true;
+                this.buffer += text;
+                this.processBuffer();
+            }
+            const exitCode = await proc.exited;
+            console.log(`[${logPrefix}] Process exited with code:`, exitCode, 'receivedOutput:', receivedAnyOutput);
+            const stderrText = await stderrPromise;
+            if (stderrText) {
+                console.error(`[${logPrefix}] 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: this.getNoOutputErrorMessage(),
+                    timestamp: new Date().toISOString(),
+                });
+                return;
+            }
+            this.onMessage({
+                type: 'done',
+                content: 'Response complete',
+                timestamp: new Date().toISOString(),
+            });
+        }
+        catch (err) {
+            console.error(`[${logPrefix}] 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(`[${this.getLogPrefix()}] 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.sessionModel = this.model;
+                this.historyLoaded = true;
+                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(`[${this.getLogPrefix()}] 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(),
+            });
+        }
+    }
+    setModel(model) {
+        if (this.model !== model) {
+            this.model = model;
+            if (this.sessionModel !== model) {
+                this.sessionId = undefined;
+                this.historyLoaded = false;
+                this.onMessage({
+                    type: 'system',
+                    content: `Switching to model: ${model}`,
+                    timestamp: new Date().toISOString(),
+                });
+            }
+        }
+    }
+    getSessionId() {
+        return this.sessionId;
+    }
+}

package/dist/chat/handler.js

@@ -1,22 +1,18 @@
-export class ChatSession {
-    process = null;
+import { BaseClaudeSession } from './base-claude-session';
+export class ChatSession extends BaseClaudeSession {
     containerName;
     workDir;
-    sessionId;
-    model;
-    sessionModel;
-    onMessage;
-    buffer = '';
     constructor(options, onMessage) {
+        super(options.sessionId, options.model, onMessage);
         this.containerName = options.containerName;
         this.workDir = options.workDir || '/home/workspace';
-        this.sessionId = options.sessionId;
-        this.model = options.model || 'sonnet';
-        this.sessionModel = this.model;
-        this.onMessage = onMessage;
     }
-    async sendMessage(userMessage) {
+    getLogPrefix() {
+        return 'chat';
+    }
+    getSpawnConfig(userMessage) {
         const args = [
+            'docker',
             'exec',
             '-u',
             'workspace',
@@ -37,152 +33,13 @@ export class ChatSession {
             args.push('--resume', this.sessionId);
         }
         args.push(userMessage);
-        console.log('[chat] 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('[chat] 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('[chat] Received chunk:', text.length, 'bytes');
-                receivedAnyOutput = true;
-                this.buffer += text;
-                this.processBuffer();
-            }
-            const exitCode = await proc.exited;
-            console.log('[chat] Process exited with code:', exitCode, 'receivedOutput:', receivedAnyOutput);
-            const stderrText = await stderrPromise;
-            if (stderrText) {
-                console.error('[chat] stderr:', stderrText);
-            }
-            if (exitCode !== 0) {
-                this.onMessage({
-                    type: 'error',
-                    content: stderrText || `Claude exited with code ${exitCode}`,
-                    timestamp: new Date().toISOString(),
-                });
-                return;
-            }
-            if (!receivedAnyOutput) {
-                this.onMessage({
-                    type: 'error',
-                    content: 'No response from Claude. Check if Claude is authenticated in the workspace.',
-                    timestamp: new Date().toISOString(),
-                });
-                return;
-            }
-            this.onMessage({
-                type: 'done',
-                content: 'Response complete',
-                timestamp: new Date().toISOString(),
-            });
-        }
-        catch (err) {
-            console.error('[chat] 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 msg = JSON.parse(line);
-                this.handleStreamMessage(msg);
-            }
-            catch {
-                console.error('[chat] Failed to parse:', line);
-            }
-        }
-    }
-    handleStreamMessage(msg) {
-        const timestamp = new Date().toISOString();
-        if (msg.type === 'system' && msg.subtype === 'init') {
-            this.sessionId = msg.session_id;
-            this.sessionModel = this.model;
-            this.onMessage({
-                type: 'system',
-                content: `Session started: ${msg.session_id?.slice(0, 8)}...`,
-                timestamp,
-            });
-            return;
-        }
-        if (msg.type === 'assistant' && msg.message?.content) {
-            for (const block of msg.message.content) {
-                if (block.type === 'tool_use') {
-                    this.onMessage({
-                        type: 'tool_use',
-                        content: JSON.stringify(block.input, null, 2),
-                        toolName: block.name,
-                        toolId: block.id,
-                        timestamp,
-                    });
-                }
-            }
-            return;
-        }
-        if (msg.type === 'stream_event' && msg.event?.type === 'content_block_delta') {
-            const delta = msg.event?.delta;
-            if (delta?.type === 'text_delta' && delta?.text) {
-                this.onMessage({
-                    type: 'assistant',
-                    content: delta.text,
-                    timestamp,
-                });
-            }
-            return;
-        }
-    }
-    async interrupt() {
-        if (this.process) {
-            this.process.kill();
-            this.process = 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(),
-                });
-            }
-        }
+        return {
+            command: args,
+            options: {},
+        };
     }
-    getSessionId() {
-        return this.sessionId;
+    getNoOutputErrorMessage() {
+        return 'No response from Claude. Check if Claude is authenticated in the workspace.';
     }
 }
 export function createChatSession(options, onMessage) {

package/dist/chat/host-handler.js

@@ -1,19 +1,17 @@
 import { homedir } from 'os';
-export class HostChatSession {
-    process = null;
+import { BaseClaudeSession } from './base-claude-session';
+export class HostChatSession extends BaseClaudeSession {
     workDir;
-    sessionId;
-    model;
-    onMessage;
-    buffer = '';
     constructor(options, onMessage) {
+        super(options.sessionId, options.model, onMessage);
         this.workDir = options.workDir || homedir();
-        this.sessionId = options.sessionId;
-        this.model = options.model || 'sonnet';
-        this.onMessage = onMessage;
     }
-    async sendMessage(userMessage) {
+    getLogPrefix() {
+        return 'host-chat';
+    }
+    getSpawnConfig(userMessage) {
         const args = [
+            'claude',
             '--print',
             '--verbose',
             '--output-format',
@@ -27,142 +25,15 @@ export class HostChatSession {
             args.push('--resume', this.sessionId);
         }
         args.push(userMessage);
-        console.log('[host-chat] Running: claude', args.join(' '));
-        this.onMessage({
-            type: 'system',
-            content: 'Processing your message...',
-            timestamp: new Date().toISOString(),
-        });
-        try {
-            const proc = Bun.spawn(['claude', ...args], {
+        return {
+            command: args,
+            options: {
                 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-chat] 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-chat] Received chunk:', text.length, 'bytes');
-                receivedAnyOutput = true;
-                this.buffer += text;
-                this.processBuffer();
-            }
-            const exitCode = await proc.exited;
-            console.log('[host-chat] Process exited with code:', exitCode, 'receivedOutput:', receivedAnyOutput);
-            const stderrText = await stderrPromise;
-            if (stderrText) {
-                console.error('[host-chat] stderr:', stderrText);
-            }
-            if (exitCode !== 0) {
-                this.onMessage({
-                    type: 'error',
-                    content: stderrText || `Claude exited with code ${exitCode}`,
-                    timestamp: new Date().toISOString(),
-                });
-                return;
-            }
-            if (!receivedAnyOutput) {
-                this.onMessage({
-                    type: 'error',
-                    content: 'No response from Claude. Check if Claude is authenticated.',
-                    timestamp: new Date().toISOString(),
-                });
-                return;
-            }
-            this.onMessage({
-                type: 'done',
-                content: 'Response complete',
-                timestamp: new Date().toISOString(),
-            });
-        }
-        catch (err) {
-            console.error('[host-chat] 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 msg = JSON.parse(line);
-                this.handleStreamMessage(msg);
-            }
-            catch {
-                console.error('[host-chat] Failed to parse:', line);
-            }
-        }
-    }
-    handleStreamMessage(msg) {
-        const timestamp = new Date().toISOString();
-        if (msg.type === 'system' && msg.subtype === 'init') {
-            this.sessionId = msg.session_id;
-            this.onMessage({
-                type: 'system',
-                content: `Session started: ${msg.session_id?.slice(0, 8)}...`,
-                timestamp,
-            });
-            return;
-        }
-        if (msg.type === 'assistant' && msg.message?.content) {
-            for (const block of msg.message.content) {
-                if (block.type === 'tool_use') {
-                    this.onMessage({
-                        type: 'tool_use',
-                        content: JSON.stringify(block.input, null, 2),
-                        toolName: block.name,
-                        toolId: block.id,
-                        timestamp,
-                    });
-                }
-            }
-            return;
-        }
-        if (msg.type === 'stream_event' && msg.event?.type === 'content_block_delta') {
-            const delta = msg.event?.delta;
-            if (delta?.type === 'text_delta' && delta?.text) {
-                this.onMessage({
-                    type: 'assistant',
-                    content: delta.text,
-                    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 createHostChatSession(options, onMessage) {