@gricha/perry 0.2.6 → 0.3.1

package/dist/chat/base-chat-websocket.js

@@ -1,86 +0,0 @@
-import { BaseWebSocketServer, safeSend } from '../shared/base-websocket';
-import { getContainerName } from '../docker';
-import { HOST_WORKSPACE_NAME } from '../shared/client-types';
-export class BaseChatWebSocketServer 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 = this.createConnection(ws, workspaceName);
-        this.connections.set(ws, connection);
-        const connectedMessage = {
-            type: 'connected',
-            workspaceName,
-            timestamp: new Date().toISOString(),
-        };
-        if (this.agentType) {
-            connectedMessage.agentType = this.agentType;
-        }
-        safeSend(ws, JSON.stringify(connectedMessage));
-        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) => {
-                        safeSend(ws, JSON.stringify(chatMessage));
-                    };
-                    if (!connection.session) {
-                        if (isHostMode) {
-                            connection.session = this.createHostSession(message.sessionId, onMessage, message.model, message.projectPath);
-                        }
-                        else {
-                            const containerName = getContainerName(workspaceName);
-                            connection.session = this.createContainerSession(containerName, message.sessionId, onMessage, message.model);
-                        }
-                    }
-                    else if (message.model && connection.session.setModel) {
-                        connection.session.setModel(message.model);
-                    }
-                    await connection.session.sendMessage(message.content);
-                }
-            }
-            catch (err) {
-                safeSend(ws, 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(`${this.agentType || '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/chat/base-claude-session.js

@@ -1,169 +0,0 @@
-import { DEFAULT_CLAUDE_MODEL } from '../shared/constants';
-export class BaseClaudeSession {
-    process = null;
-    sessionId;
-    model;
-    sessionModel;
-    onMessage;
-    buffer = '';
-    constructor(sessionId, model, onMessage) {
-        this.sessionId = sessionId;
-        this.model = model || DEFAULT_CLAUDE_MODEL;
-        this.sessionModel = this.model;
-        this.onMessage = onMessage;
-    }
-    async sendMessage(userMessage) {
-        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 || `Claude 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;
-        }
-    }
-    getNoOutputErrorMessage() {
-        return 'No response from Claude. Check if Claude is authenticated.';
-    }
-    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(`[${this.getLogPrefix()}] 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(),
-                });
-            }
-        }
-    }
-    getSessionId() {
-        return this.sessionId;
-    }
-}

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';