@gricha/perry 0.3.0 → 0.3.2

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

@@ -1,181 +0,0 @@
-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,47 +0,0 @@
-import { BaseClaudeSession } from './base-claude-session';
-export class ChatSession extends BaseClaudeSession {
-    containerName;
-    workDir;
-    constructor(options, onMessage) {
-        super(options.sessionId, options.model, onMessage);
-        this.containerName = options.containerName;
-        this.workDir = options.workDir || '/home/workspace';
-    }
-    getLogPrefix() {
-        return 'chat';
-    }
-    getSpawnConfig(userMessage) {
-        const args = [
-            'docker',
-            'exec',
-            '-u',
-            'workspace',
-            '-w',
-            this.workDir,
-            this.containerName,
-            'claude',
-            '--print',
-            '--verbose',
-            '--output-format',
-            'stream-json',
-            '--include-partial-messages',
-            '--model',
-            this.model,
-            '--dangerously-skip-permissions',
-        ];
-        if (this.sessionId) {
-            args.push('--resume', this.sessionId);
-        }
-        args.push(userMessage);
-        return {
-            command: args,
-            options: {},
-        };
-    }
-    getNoOutputErrorMessage() {
-        return 'No response from Claude. Check if Claude is authenticated in the workspace.';
-    }
-}
-export function createChatSession(options, onMessage) {
-    return new ChatSession(options, onMessage);
-}

package/dist/chat/host-handler.js

@@ -1,41 +0,0 @@
-import { homedir } from 'os';
-import { BaseClaudeSession } from './base-claude-session';
-export class HostChatSession extends BaseClaudeSession {
-    workDir;
-    constructor(options, onMessage) {
-        super(options.sessionId, options.model, onMessage);
-        this.workDir = options.workDir || homedir();
-    }
-    getLogPrefix() {
-        return 'host-chat';
-    }
-    getSpawnConfig(userMessage) {
-        const args = [
-            'claude',
-            '--print',
-            '--verbose',
-            '--output-format',
-            'stream-json',
-            '--include-partial-messages',
-            '--model',
-            this.model,
-            '--dangerously-skip-permissions',
-        ];
-        if (this.sessionId) {
-            args.push('--resume', this.sessionId);
-        }
-        args.push(userMessage);
-        return {
-            command: args,
-            options: {
-                cwd: this.workDir,
-                env: {
-                    ...process.env,
-                },
-            },
-        };
-    }
-}
-export function createHostChatSession(options, onMessage) {
-    return new HostChatSession(options, onMessage);
-}

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

@@ -1,144 +0,0 @@
-import { homedir } from 'os';
-import { promises as fs } from 'fs';
-import path from 'path';
-import { BaseOpencodeSession } from './base-opencode-session';
-export class HostOpencodeSession extends BaseOpencodeSession {
-    workDir;
-    constructor(options, onMessage) {
-        super(options.sessionId, options.model, onMessage);
-        this.workDir = options.workDir || homedir();
-    }
-    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) {
-            return;
-        }
-        this.historyLoaded = true;
-        try {
-            const homeDir = homedir();
-            const sessionDir = path.join(homeDir, '.local', 'share', 'opencode', 'storage', 'session');
-            const sessionFile = path.join(sessionDir, `${this.sessionId}.json`);
-            let internalId;
-            try {
-                const sessionContent = await fs.readFile(sessionFile, 'utf-8');
-                const session = JSON.parse(sessionContent);
-                internalId = session.id;
-            }
-            catch {
-                return;
-            }
-            const msgDir = path.join(homeDir, '.local', 'share', 'opencode', 'storage', 'message', internalId);
-            const partDir = path.join(homeDir, '.local', 'share', 'opencode', 'storage', 'part');
-            let msgFiles;
-            try {
-                const files = await fs.readdir(msgDir);
-                msgFiles = files.filter((f) => f.startsWith('msg_') && f.endsWith('.json')).sort();
-            }
-            catch {
-                return;
-            }
-            const messages = [];
-            for (const msgFile of msgFiles) {
-                try {
-                    const msgContent = await fs.readFile(path.join(msgDir, msgFile), 'utf-8');
-                    const msg = JSON.parse(msgContent);
-                    if (!msg.id || (msg.role !== 'user' && msg.role !== 'assistant'))
-                        continue;
-                    const timestamp = msg.time?.created
-                        ? new Date(msg.time.created).toISOString()
-                        : new Date().toISOString();
-                    const partMsgDir = path.join(partDir, msg.id);
-                    let partFiles;
-                    try {
-                        const files = await fs.readdir(partMsgDir);
-                        partFiles = files.filter((f) => f.startsWith('prt_') && f.endsWith('.json')).sort();
-                    }
-                    catch {
-                        continue;
-                    }
-                    for (const partFile of partFiles) {
-                        try {
-                            const partContent = await fs.readFile(path.join(partMsgDir, partFile), 'utf-8');
-                            const part = JSON.parse(partContent);
-                            if (part.type === 'text' && part.text) {
-                                messages.push({
-                                    type: msg.role,
-                                    content: part.text,
-                                    timestamp,
-                                });
-                            }
-                            else if (part.type === 'tool' && part.tool) {
-                                messages.push({
-                                    type: 'tool_use',
-                                    content: JSON.stringify(part.state?.input, null, 2),
-                                    toolName: part.state?.title || part.tool,
-                                    toolId: part.callID || part.id,
-                                    timestamp,
-                                });
-                                if (part.state?.output) {
-                                    messages.push({
-                                        type: 'tool_result',
-                                        content: part.state.output,
-                                        toolId: part.callID || part.id,
-                                        timestamp,
-                                    });
-                                }
-                            }
-                        }
-                        catch {
-                            continue;
-                        }
-                    }
-                }
-                catch {
-                    continue;
-                }
-            }
-            if (messages.length > 0) {
-                this.onMessage({
-                    type: 'system',
-                    content: `Loading ${messages.length} messages from session history...`,
-                    timestamp: new Date().toISOString(),
-                });
-                for (const msg of messages) {
-                    this.onMessage(msg);
-                }
-                this.onMessage({
-                    type: 'system',
-                    content: 'Session history loaded',
-                    timestamp: new Date().toISOString(),
-                });
-            }
-        }
-        catch (err) {
-            console.error('[host-opencode] Failed to load history:', err);
-        }
-    }
-}
-export function createHostOpencodeSession(options, onMessage) {
-    return new HostOpencodeSession(options, onMessage);
-}

package/dist/chat/index.js

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

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);
-}