@gricha/perry 0.2.1 → 0.2.3

package/dist/chat/opencode-handler.js

@@ -1,21 +1,47 @@
+import { BaseOpencodeSession } from './base-opencode-session';
 import { opencodeProvider } from '../sessions/agents/opencode';
-export class OpencodeSession {
-    process = null;
+export class OpencodeSession extends BaseOpencodeSession {
     containerName;
     workDir;
-    sessionId;
-    model;
-    sessionModel;
-    onMessage;
-    buffer = '';
-    historyLoaded = false;
     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;
-        this.sessionModel = options.model;
-        this.onMessage = onMessage;
+    }
+    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) {
@@ -68,191 +94,6 @@ export class OpencodeSession {
             console.error('[opencode] Failed to load history:', err);
         }
     }
-    async sendMessage(userMessage) {
-        if (this.sessionId && !this.historyLoaded) {
-            await this.loadHistory();
-        }
-        const args = [
-            '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);
-        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.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('[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 createOpencodeSession(options, onMessage) {
     return new OpencodeSession(options, onMessage);

package/dist/chat/types.js

@@ -0,0 +1 @@
+export {};

package/dist/docker/index.js

@@ -1,6 +1,6 @@
 import { spawn } from 'child_process';
+import { CONTAINER_PREFIX } from '../shared/constants';
 export * from './types';
-const CONTAINER_PREFIX = 'workspace-';
 export function getContainerName(name) {
     return `${CONTAINER_PREFIX}${name}`;
 }

package/dist/index.js

@@ -201,6 +201,12 @@ program
             console.log(`  Uptime: ${formatUptime(info.uptime)}`);
             console.log(`  Workspaces: ${info.workspacesCount}`);
             console.log(`  Docker: ${info.dockerVersion}`);
+            if (info.tailscale?.running) {
+                console.log(`  Tailscale: ${info.tailscale.dnsName}`);
+                if (info.tailscale.httpsUrl) {
+                    console.log(`  HTTPS URL: ${info.tailscale.httpsUrl}`);
+                }
+            }
         }
     }
     catch (err) {
@@ -599,6 +605,42 @@ program
         process.exit(1);
     }
 });
+const workerCmd = program
+    .command('worker')
+    .description('Worker mode commands (for use inside containers)');
+workerCmd
+    .command('sessions')
+    .argument('<subcommand>', 'Subcommand: list, messages, or delete')
+    .argument('[sessionId]', 'Session ID (required for messages and delete)')
+    .description('Manage OpenCode sessions')
+    .action(async (subcommand, sessionId) => {
+    const { listOpencodeSessions, getOpencodeSessionMessages, deleteOpencodeSession } = await import('./sessions/agents/opencode-storage');
+    if (subcommand === 'list') {
+        const sessions = await listOpencodeSessions();
+        console.log(JSON.stringify(sessions));
+    }
+    else if (subcommand === 'messages') {
+        if (!sessionId) {
+            console.error('Usage: perry worker sessions messages <session_id>');
+            process.exit(1);
+        }
+        const result = await getOpencodeSessionMessages(sessionId);
+        console.log(JSON.stringify(result));
+    }
+    else if (subcommand === 'delete') {
+        if (!sessionId) {
+            console.error('Usage: perry worker sessions delete <session_id>');
+            process.exit(1);
+        }
+        const result = await deleteOpencodeSession(sessionId);
+        console.log(JSON.stringify(result));
+    }
+    else {
+        console.error(`Unknown subcommand: ${subcommand}`);
+        console.error('Available: list, messages, delete');
+        process.exit(1);
+    }
+});
 function handleError(err) {
     if (err instanceof ApiClientError) {
         console.error(`Error: ${err.message}`);

package/dist/sessions/agents/claude.js

@@ -83,4 +83,23 @@ export const claudeProvider = {
             (msg.content && msg.content.trim().length > 0));
         return { id: sessionId, messages };
     },
+    async deleteSession(containerName, sessionId, exec) {
+        const safeSessionId = sessionId.replace(/[^a-zA-Z0-9_-]/g, '');
+        const findResult = await exec(containerName, [
+            'bash',
+            '-c',
+            `find /home/workspace/.claude/projects -name "${safeSessionId}.jsonl" -type f 2>/dev/null | head -1`,
+        ], { user: 'workspace' });
+        if (findResult.exitCode !== 0 || !findResult.stdout.trim()) {
+            return { success: false, error: 'Session not found' };
+        }
+        const filePath = findResult.stdout.trim();
+        const rmResult = await exec(containerName, ['rm', '-f', filePath], {
+            user: 'workspace',
+        });
+        if (rmResult.exitCode !== 0) {
+            return { success: false, error: rmResult.stderr || 'Failed to delete session file' };
+        }
+        return { success: true };
+    },
 };

package/dist/sessions/agents/codex.js

@@ -107,4 +107,44 @@ export const codexProvider = {
         }
         return null;
     },
+    async deleteSession(containerName, sessionId, exec) {
+        const findResult = await exec(containerName, ['bash', '-c', `find /home/workspace/.codex/sessions -name "*.jsonl" -type f 2>/dev/null`], { user: 'workspace' });
+        if (findResult.exitCode !== 0 || !findResult.stdout.trim()) {
+            return { success: false, error: 'No session files found' };
+        }
+        const files = findResult.stdout.trim().split('\n').filter(Boolean);
+        for (const file of files) {
+            const fileId = file.split('/').pop()?.replace('.jsonl', '') || '';
+            if (fileId === sessionId) {
+                const rmResult = await exec(containerName, ['rm', '-f', file], {
+                    user: 'workspace',
+                });
+                if (rmResult.exitCode !== 0) {
+                    return { success: false, error: rmResult.stderr || 'Failed to delete session file' };
+                }
+                return { success: true };
+            }
+            const headResult = await exec(containerName, ['head', '-1', file], {
+                user: 'workspace',
+            });
+            if (headResult.exitCode === 0) {
+                try {
+                    const meta = JSON.parse(headResult.stdout);
+                    if (meta.session_id === sessionId) {
+                        const rmResult = await exec(containerName, ['rm', '-f', file], {
+                            user: 'workspace',
+                        });
+                        if (rmResult.exitCode !== 0) {
+                            return { success: false, error: rmResult.stderr || 'Failed to delete session file' };
+                        }
+                        return { success: true };
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+        return { success: false, error: 'Session not found' };
+    },
 };

package/dist/sessions/agents/index.js

@@ -42,3 +42,66 @@ export async function findSessionMessages(containerName, sessionId, exec) {
     }
     return null;
 }
+export async function deleteSession(containerName, sessionId, agentType, exec) {
+    const provider = providers[agentType];
+    if (!provider) {
+        return { success: false, error: 'Unknown agent type' };
+    }
+    return provider.deleteSession(containerName, sessionId, exec);
+}
+export async function searchSessions(containerName, query, exec) {
+    const safeQuery = query.replace(/['"\\]/g, '\\$&');
+    const searchPaths = [
+        '/home/workspace/.claude/projects',
+        '/home/workspace/.local/share/opencode/storage',
+        '/home/workspace/.codex/sessions',
+    ];
+    const rgCommand = `rg -l -i --no-messages "${safeQuery}" ${searchPaths.join(' ')} 2>/dev/null | head -100`;
+    const result = await exec(containerName, ['bash', '-c', rgCommand], {
+        user: 'workspace',
+    });
+    if (result.exitCode !== 0 || !result.stdout.trim()) {
+        return [];
+    }
+    const files = result.stdout.trim().split('\n').filter(Boolean);
+    const results = [];
+    for (const file of files) {
+        let sessionId = null;
+        let agentType = null;
+        if (file.includes('/.claude/projects/')) {
+            const match = file.match(/\/([^/]+)\.jsonl$/);
+            if (match && !match[1].startsWith('agent-')) {
+                sessionId = match[1];
+                agentType = 'claude-code';
+            }
+        }
+        else if (file.includes('/.local/share/opencode/storage/')) {
+            if (file.includes('/session/') && file.endsWith('.json')) {
+                const match = file.match(/\/(ses_[^/]+)\.json$/);
+                if (match) {
+                    sessionId = match[1];
+                    agentType = 'opencode';
+                }
+            }
+            else if (file.includes('/part/') || file.includes('/message/')) {
+                continue;
+            }
+        }
+        else if (file.includes('/.codex/sessions/')) {
+            const match = file.match(/\/([^/]+)\.jsonl$/);
+            if (match) {
+                sessionId = match[1];
+                agentType = 'codex';
+            }
+        }
+        if (sessionId && agentType) {
+            results.push({
+                sessionId,
+                agentType,
+                filePath: file,
+                matchCount: 1,
+            });
+        }
+    }
+    return results;
+}

package/dist/sessions/agents/opencode-storage.js

@@ -0,0 +1,218 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as os from 'node:os';
+function getStorageBase(homeDir) {
+    const home = homeDir || os.homedir();
+    return path.join(home, '.local', 'share', 'opencode', 'storage');
+}
+export async function listOpencodeSessions(homeDir) {
+    const storageBase = getStorageBase(homeDir);
+    const sessionDir = path.join(storageBase, 'session');
+    const sessions = [];
+    try {
+        const projectDirs = await fs.readdir(sessionDir, { withFileTypes: true });
+        for (const projectDir of projectDirs) {
+            if (!projectDir.isDirectory())
+                continue;
+            const projectPath = path.join(sessionDir, projectDir.name);
+            const sessionFiles = await fs.readdir(projectPath);
+            for (const sessionFile of sessionFiles) {
+                if (!sessionFile.startsWith('ses_') || !sessionFile.endsWith('.json'))
+                    continue;
+                const filePath = path.join(projectPath, sessionFile);
+                try {
+                    const stat = await fs.stat(filePath);
+                    const content = await fs.readFile(filePath, 'utf-8');
+                    const data = JSON.parse(content);
+                    if (!data.id)
+                        continue;
+                    sessions.push({
+                        id: data.id,
+                        title: data.title || '',
+                        directory: data.directory || '',
+                        mtime: data.time?.updated || Math.floor(stat.mtimeMs),
+                        file: filePath,
+                    });
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+    }
+    catch {
+        // Storage doesn't exist
+    }
+    return sessions;
+}
+export async function getOpencodeSessionMessages(sessionId, homeDir) {
+    const storageBase = getStorageBase(homeDir);
+    const sessionDir = path.join(storageBase, 'session');
+    const messageDir = path.join(storageBase, 'message');
+    const partDir = path.join(storageBase, 'part');
+    const sessionFile = await findSessionFile(sessionDir, sessionId);
+    if (!sessionFile) {
+        return { id: sessionId, messages: [] };
+    }
+    let internalId;
+    try {
+        const content = await fs.readFile(sessionFile, 'utf-8');
+        const data = JSON.parse(content);
+        internalId = data.id;
+        if (!internalId) {
+            return { id: sessionId, messages: [] };
+        }
+    }
+    catch {
+        return { id: sessionId, messages: [] };
+    }
+    const msgDir = path.join(messageDir, internalId);
+    const messages = [];
+    try {
+        const msgFiles = (await fs.readdir(msgDir))
+            .filter((f) => f.startsWith('msg_') && f.endsWith('.json'))
+            .sort();
+        for (const msgFile of msgFiles) {
+            const msgPath = path.join(msgDir, msgFile);
+            try {
+                const content = await fs.readFile(msgPath, 'utf-8');
+                const msg = JSON.parse(content);
+                if (!msg.id || (msg.role !== 'user' && msg.role !== 'assistant'))
+                    continue;
+                const partMsgDir = path.join(partDir, msg.id);
+                try {
+                    const partFiles = (await fs.readdir(partMsgDir))
+                        .filter((f) => f.startsWith('prt_') && f.endsWith('.json'))
+                        .sort();
+                    for (const partFile of partFiles) {
+                        const partPath = path.join(partMsgDir, partFile);
+                        try {
+                            const partContent = await fs.readFile(partPath, 'utf-8');
+                            const part = JSON.parse(partContent);
+                            const timestamp = msg.time?.created
+                                ? new Date(msg.time.created).toISOString()
+                                : undefined;
+                            if (part.type === 'text' && part.text) {
+                                messages.push({
+                                    type: msg.role,
+                                    content: part.text,
+                                    timestamp,
+                                });
+                            }
+                            else if (part.type === 'tool') {
+                                const toolName = part.state?.title || part.tool || '';
+                                const callId = part.callID || part.id || '';
+                                messages.push({
+                                    type: 'tool_use',
+                                    toolName,
+                                    toolId: callId,
+                                    toolInput: part.state?.input ? JSON.stringify(part.state.input) : '',
+                                    timestamp,
+                                });
+                                if (part.state?.output) {
+                                    messages.push({
+                                        type: 'tool_result',
+                                        content: part.state.output,
+                                        toolId: callId,
+                                        timestamp,
+                                    });
+                                }
+                            }
+                        }
+                        catch {
+                            continue;
+                        }
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    catch {
+        // No messages
+    }
+    return { id: sessionId, messages };
+}
+async function findSessionFile(sessionDir, sessionId) {
+    try {
+        const projectDirs = await fs.readdir(sessionDir, { withFileTypes: true });
+        for (const projectDir of projectDirs) {
+            if (!projectDir.isDirectory())
+                continue;
+            const filePath = path.join(sessionDir, projectDir.name, `${sessionId}.json`);
+            try {
+                await fs.access(filePath);
+                return filePath;
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    catch {
+        // Directory doesn't exist
+    }
+    return null;
+}
+export async function deleteOpencodeSession(sessionId, homeDir) {
+    const storageBase = getStorageBase(homeDir);
+    const sessionDir = path.join(storageBase, 'session');
+    const messageDir = path.join(storageBase, 'message');
+    const partDir = path.join(storageBase, 'part');
+    const sessionFile = await findSessionFile(sessionDir, sessionId);
+    if (!sessionFile) {
+        return { success: false, error: 'Session not found' };
+    }
+    let internalId = null;
+    try {
+        const content = await fs.readFile(sessionFile, 'utf-8');
+        const data = JSON.parse(content);
+        internalId = data.id;
+    }
+    catch {
+        // Continue with session file deletion only
+    }
+    try {
+        await fs.unlink(sessionFile);
+    }
+    catch (err) {
+        return { success: false, error: `Failed to delete session file: ${err}` };
+    }
+    if (internalId) {
+        const msgDir = path.join(messageDir, internalId);
+        try {
+            const msgFiles = await fs.readdir(msgDir);
+            for (const msgFile of msgFiles) {
+                if (!msgFile.startsWith('msg_') || !msgFile.endsWith('.json'))
+                    continue;
+                const msgPath = path.join(msgDir, msgFile);
+                try {
+                    const content = await fs.readFile(msgPath, 'utf-8');
+                    const msg = JSON.parse(content);
+                    if (msg.id) {
+                        const partMsgDir = path.join(partDir, msg.id);
+                        try {
+                            await fs.rm(partMsgDir, { recursive: true });
+                        }
+                        catch {
+                            // Parts may not exist
+                        }
+                    }
+                }
+                catch {
+                    // Skip malformed messages
+                }
+            }
+            await fs.rm(msgDir, { recursive: true });
+        }
+        catch {
+            // Messages directory may not exist
+        }
+    }
+    return { success: true };
+}