@gricha/perry 0.2.1 → 0.2.3

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) {

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

@@ -1,21 +1,37 @@
 import { homedir } from 'os';
 import { promises as fs } from 'fs';
 import path from 'path';
-export class HostOpencodeSession {
-    process = null;
+import { BaseOpencodeSession } from './base-opencode-session';
+export class HostOpencodeSession extends BaseOpencodeSession {
     workDir;
-    sessionId;
-    model;
-    sessionModel;
-    onMessage;
-    buffer = '';
-    historyLoaded = false;
     constructor(options, onMessage) {
+        super(options.sessionId, options.model, onMessage);
         this.workDir = options.workDir || homedir();
-        this.sessionId = options.sessionId;
-        this.model = options.model;
-        this.sessionModel = options.model;
-        this.onMessage = onMessage;
+    }
+    getLogPrefix() {
+        return 'host-opencode';
+    }
+    getNoOutputErrorMessage() {
+        return 'No response from OpenCode. Check if OpenCode is installed and configured.';
+    }
+    getSpawnConfig(userMessage) {
+        const args = ['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: {
+                cwd: this.workDir,
+                env: {
+                    ...process.env,
+                },
+            },
+        };
     }
     async loadHistory() {
         if (this.historyLoaded || !this.sessionId) {
@@ -122,181 +138,6 @@ export class HostOpencodeSession {
             console.error('[host-opencode] Failed to load history:', err);
         }
     }
-    async sendMessage(userMessage) {
-        if (this.sessionId && !this.historyLoaded) {
-            await this.loadHistory();
-        }
-        const args = ['-oL', 'opencode', 'run', '--format', 'json'];
-        if (this.sessionId) {
-            args.push('--session', this.sessionId);
-        }
-        if (this.model) {
-            args.push('--model', this.model);
-        }
-        args.push(userMessage);
-        console.log('[host-opencode] Running: stdbuf', args.join(' '));
-        this.onMessage({
-            type: 'system',
-            content: 'Processing your message...',
-            timestamp: new Date().toISOString(),
-        });
-        try {
-            const proc = Bun.spawn(['stdbuf', ...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.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('[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(),
-            });
-        }
-    }
-    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;
-    }
 }
 export function createHostOpencodeSession(options, onMessage) {
     return new HostOpencodeSession(options, onMessage);