@gricha/perry 0.0.1 → 0.1.1

package/dist/sessions/agents/claude.js

@@ -0,0 +1,86 @@
+import { parseClaudeSessionContent } from '../parser';
+import { decodeClaudeProjectPath, extractFirstUserPrompt, extractClaudeSessionName } from './utils';
+export const claudeProvider = {
+    async discoverSessions(containerName, exec) {
+        const result = await exec(containerName, [
+            'bash',
+            '-c',
+            'find /home/workspace/.claude/projects -name "*.jsonl" -type f ! -name "agent-*.jsonl" -printf "%p\\t%T@\\t%s\\n" 2>/dev/null || true',
+        ], { user: 'workspace' });
+        const sessions = [];
+        if (result.exitCode === 0 && result.stdout.trim()) {
+            const lines = result.stdout.trim().split('\n').filter(Boolean);
+            for (const line of lines) {
+                const parts = line.split('\t');
+                if (parts.length >= 3) {
+                    const file = parts[0];
+                    const mtime = Math.floor(parseFloat(parts[1]) || 0);
+                    const size = parseInt(parts[2], 10) || 0;
+                    if (size === 0)
+                        continue;
+                    const id = file.split('/').pop()?.replace('.jsonl', '') || '';
+                    const projDir = file.split('/').slice(-2, -1)[0] || '';
+                    const projectPath = decodeClaudeProjectPath(projDir);
+                    if (!projectPath.startsWith('/workspace') && !projectPath.startsWith('/home/workspace')) {
+                        continue;
+                    }
+                    sessions.push({
+                        id,
+                        agentType: 'claude-code',
+                        mtime,
+                        projectPath,
+                        filePath: file,
+                    });
+                }
+            }
+        }
+        return sessions;
+    },
+    async getSessionDetails(containerName, rawSession, exec) {
+        const catResult = await exec(containerName, ['cat', rawSession.filePath], {
+            user: 'workspace',
+        });
+        if (catResult.exitCode !== 0) {
+            return null;
+        }
+        const messages = parseClaudeSessionContent(catResult.stdout).filter((msg) => msg.type !== 'system');
+        const firstPrompt = extractFirstUserPrompt(messages);
+        const name = extractClaudeSessionName(catResult.stdout);
+        if (messages.length === 0) {
+            return null;
+        }
+        return {
+            id: rawSession.id,
+            name: name || null,
+            agentType: rawSession.agentType,
+            projectPath: rawSession.projectPath,
+            messageCount: messages.length,
+            lastActivity: new Date(rawSession.mtime * 1000).toISOString(),
+            firstPrompt,
+        };
+    },
+    async getSessionMessages(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 null;
+        }
+        const filePath = findResult.stdout.trim();
+        const catResult = await exec(containerName, ['cat', filePath], {
+            user: 'workspace',
+        });
+        if (catResult.exitCode !== 0) {
+            return null;
+        }
+        const messages = parseClaudeSessionContent(catResult.stdout)
+            .filter((msg) => msg.type !== 'system')
+            .filter((msg) => msg.type === 'tool_use' ||
+            msg.type === 'tool_result' ||
+            (msg.content && msg.content.trim().length > 0));
+        return { id: sessionId, messages };
+    },
+};

package/dist/sessions/agents/codex.js

@@ -0,0 +1,110 @@
+import { extractContent } from './utils';
+function parseCodexMessages(content) {
+    const lines = content.split('\n').filter(Boolean);
+    let sessionId = null;
+    const messages = [];
+    if (lines.length > 0) {
+        try {
+            const meta = JSON.parse(lines[0]);
+            if (meta.session_id) {
+                sessionId = meta.session_id;
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    for (let i = 1; i < lines.length; i++) {
+        try {
+            const event = JSON.parse(lines[i]);
+            const role = event.payload?.role || event.payload?.message?.role;
+            const content = event.payload?.content || event.payload?.message?.content;
+            if (role === 'user' || role === 'assistant') {
+                const textContent = extractContent(content);
+                messages.push({
+                    type: role,
+                    content: textContent || undefined,
+                    timestamp: event.timestamp ? new Date(event.timestamp).toISOString() : undefined,
+                });
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return { sessionId, messages };
+}
+export const codexProvider = {
+    async discoverSessions(containerName, exec) {
+        const result = await exec(containerName, [
+            'sh',
+            '-c',
+            'find /home/workspace/.codex/sessions -name "rollout-*.jsonl" -type f -printf "%p\\t%T@\\t" -exec wc -l {} \\; 2>/dev/null || true',
+        ], { user: 'workspace' });
+        const sessions = [];
+        if (result.exitCode === 0 && result.stdout.trim()) {
+            const lines = result.stdout.trim().split('\n').filter(Boolean);
+            for (const line of lines) {
+                const parts = line.split('\t');
+                if (parts.length >= 2) {
+                    const file = parts[0];
+                    const mtime = Math.floor(parseFloat(parts[1]) || 0);
+                    const id = file.split('/').pop()?.replace('.jsonl', '') || '';
+                    const projPath = file
+                        .replace('/home/workspace/.codex/sessions/', '')
+                        .replace(/\/[^/]+$/, '');
+                    sessions.push({
+                        id,
+                        agentType: 'codex',
+                        projectPath: projPath,
+                        mtime,
+                        filePath: file,
+                    });
+                }
+            }
+        }
+        return sessions;
+    },
+    async getSessionDetails(containerName, rawSession, exec) {
+        const catResult = await exec(containerName, ['cat', rawSession.filePath], {
+            user: 'workspace',
+        });
+        if (catResult.exitCode !== 0) {
+            return null;
+        }
+        const { sessionId, messages } = parseCodexMessages(catResult.stdout);
+        const firstPrompt = messages.find((msg) => msg.type === 'user' && msg.content && msg.content.trim().length > 0)?.content;
+        if (messages.length === 0) {
+            return null;
+        }
+        return {
+            id: sessionId || rawSession.id,
+            name: null,
+            agentType: rawSession.agentType,
+            projectPath: rawSession.projectPath,
+            messageCount: messages.length,
+            lastActivity: new Date(rawSession.mtime * 1000).toISOString(),
+            firstPrompt: firstPrompt ? firstPrompt.slice(0, 200) : null,
+        };
+    },
+    async getSessionMessages(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 null;
+        }
+        const files = findResult.stdout.trim().split('\n').filter(Boolean);
+        for (const file of files) {
+            const catResult = await exec(containerName, ['cat', file], {
+                user: 'workspace',
+            });
+            if (catResult.exitCode !== 0)
+                continue;
+            const { sessionId: parsedId, messages } = parseCodexMessages(catResult.stdout);
+            const fileId = file.split('/').pop()?.replace('.jsonl', '') || '';
+            if (parsedId === sessionId || fileId === sessionId) {
+                return { id: parsedId || fileId, messages };
+            }
+        }
+        return null;
+    },
+};

package/dist/sessions/agents/index.js

@@ -0,0 +1,44 @@
+import { claudeProvider } from './claude';
+import { opencodeProvider } from './opencode';
+import { codexProvider } from './codex';
+export { claudeProvider } from './claude';
+export { opencodeProvider } from './opencode';
+export { codexProvider } from './codex';
+const providers = {
+    'claude-code': claudeProvider,
+    opencode: opencodeProvider,
+    codex: codexProvider,
+};
+export async function discoverAllSessions(containerName, exec) {
+    const results = await Promise.all([
+        claudeProvider.discoverSessions(containerName, exec),
+        opencodeProvider.discoverSessions(containerName, exec),
+        codexProvider.discoverSessions(containerName, exec),
+    ]);
+    return results.flat();
+}
+export async function getSessionDetails(containerName, rawSession, exec) {
+    const provider = providers[rawSession.agentType];
+    if (!provider)
+        return null;
+    return provider.getSessionDetails(containerName, rawSession, exec);
+}
+export async function getSessionMessages(containerName, sessionId, agentType, exec) {
+    const provider = providers[agentType];
+    if (!provider)
+        return null;
+    const result = await provider.getSessionMessages(containerName, sessionId, exec);
+    if (!result)
+        return null;
+    return { ...result, agentType };
+}
+export async function findSessionMessages(containerName, sessionId, exec) {
+    const agentTypes = ['claude-code', 'opencode', 'codex'];
+    for (const agentType of agentTypes) {
+        const result = await getSessionMessages(containerName, sessionId, agentType, exec);
+        if (result && result.messages.length > 0) {
+            return result;
+        }
+    }
+    return null;
+}

package/dist/sessions/agents/opencode.js

@@ -0,0 +1,168 @@
+import { extractContent } from './utils';
+export const opencodeProvider = {
+    async discoverSessions(containerName, exec) {
+        const result = await exec(containerName, [
+            'sh',
+            '-c',
+            'find /home/workspace/.local/share/opencode/storage/session -name "ses_*.json" -type f 2>/dev/null || true',
+        ], { user: 'workspace' });
+        const sessions = [];
+        if (result.exitCode === 0 && result.stdout.trim()) {
+            const files = result.stdout.trim().split('\n').filter(Boolean);
+            const catAll = await exec(containerName, ['sh', '-c', `cat ${files.map((f) => `"${f}"`).join(' ')} 2>/dev/null | jq -s '.'`], { user: 'workspace' });
+            if (catAll.exitCode === 0) {
+                try {
+                    const sessionData = JSON.parse(catAll.stdout);
+                    for (let i = 0; i < sessionData.length; i++) {
+                        const data = sessionData[i];
+                        const file = files[i];
+                        const id = data.id || file.split('/').pop()?.replace('.json', '') || '';
+                        const mtime = Math.floor((data.time?.updated || 0) / 1000);
+                        sessions.push({
+                            id,
+                            agentType: 'opencode',
+                            projectPath: data.directory || '',
+                            mtime,
+                            name: data.title || undefined,
+                            filePath: file,
+                        });
+                    }
+                }
+                catch {
+                    // Skip on parse error
+                }
+            }
+        }
+        return sessions;
+    },
+    async getSessionDetails(containerName, rawSession, exec) {
+        const msgDir = `/home/workspace/.local/share/opencode/storage/message/${rawSession.id}`;
+        const listMsgsResult = await exec(containerName, ['bash', '-c', `ls -1 "${msgDir}"/msg_*.json 2>/dev/null | sort`], { user: 'workspace' });
+        const messages = [];
+        if (listMsgsResult.exitCode === 0 && listMsgsResult.stdout.trim()) {
+            const msgFiles = listMsgsResult.stdout.trim().split('\n').filter(Boolean);
+            for (const msgFile of msgFiles) {
+                const msgResult = await exec(containerName, ['cat', msgFile], {
+                    user: 'workspace',
+                });
+                if (msgResult.exitCode !== 0)
+                    continue;
+                try {
+                    const msg = JSON.parse(msgResult.stdout);
+                    if (msg.role === 'user' || msg.role === 'assistant') {
+                        const content = extractContent(msg.content);
+                        messages.push({ type: msg.role, content: content || undefined });
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+        const firstPrompt = messages.find((msg) => msg.type === 'user' && msg.content && msg.content.trim().length > 0)?.content;
+        if (messages.length === 0) {
+            return null;
+        }
+        return {
+            id: rawSession.id,
+            name: rawSession.name || null,
+            agentType: rawSession.agentType,
+            projectPath: rawSession.projectPath,
+            messageCount: messages.length,
+            lastActivity: new Date(rawSession.mtime * 1000).toISOString(),
+            firstPrompt: firstPrompt ? firstPrompt.slice(0, 200) : null,
+        };
+    },
+    async getSessionMessages(containerName, sessionId, exec) {
+        const findResult = await exec(containerName, [
+            'bash',
+            '-c',
+            `find /home/workspace/.local/share/opencode/storage/session -name "${sessionId}.json" -type f 2>/dev/null | head -1`,
+        ], { user: 'workspace' });
+        if (findResult.exitCode !== 0 || !findResult.stdout.trim()) {
+            return null;
+        }
+        const filePath = findResult.stdout.trim();
+        const catResult = await exec(containerName, ['cat', filePath], {
+            user: 'workspace',
+        });
+        if (catResult.exitCode !== 0) {
+            return null;
+        }
+        let internalId;
+        try {
+            const session = JSON.parse(catResult.stdout);
+            internalId = session.id;
+        }
+        catch {
+            return null;
+        }
+        const msgDir = `/home/workspace/.local/share/opencode/storage/message/${internalId}`;
+        const partDir = `/home/workspace/.local/share/opencode/storage/part`;
+        const listMsgsResult = await exec(containerName, ['bash', '-c', `ls -1 "${msgDir}"/msg_*.json 2>/dev/null | sort`], { user: 'workspace' });
+        if (listMsgsResult.exitCode !== 0 || !listMsgsResult.stdout.trim()) {
+            return { id: sessionId, messages: [] };
+        }
+        const messages = [];
+        const msgFiles = listMsgsResult.stdout.trim().split('\n').filter(Boolean);
+        for (const msgFile of msgFiles) {
+            const msgResult = await exec(containerName, ['cat', msgFile], {
+                user: 'workspace',
+            });
+            if (msgResult.exitCode !== 0)
+                continue;
+            try {
+                const msg = JSON.parse(msgResult.stdout);
+                if (!msg.id || (msg.role !== 'user' && msg.role !== 'assistant'))
+                    continue;
+                const timestamp = msg.time?.created ? new Date(msg.time.created).toISOString() : undefined;
+                const listPartsResult = await exec(containerName, ['bash', '-c', `ls -1 "${partDir}/${msg.id}"/prt_*.json 2>/dev/null | sort`], { user: 'workspace' });
+                if (listPartsResult.exitCode === 0 && listPartsResult.stdout.trim()) {
+                    const partFiles = listPartsResult.stdout.trim().split('\n').filter(Boolean);
+                    for (const partFile of partFiles) {
+                        const partResult = await exec(containerName, ['cat', partFile], {
+                            user: 'workspace',
+                        });
+                        if (partResult.exitCode !== 0)
+                            continue;
+                        try {
+                            const part = JSON.parse(partResult.stdout);
+                            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: undefined,
+                                    toolName: part.state?.title || part.tool,
+                                    toolId: part.callID || part.id,
+                                    toolInput: JSON.stringify(part.state?.input, null, 2),
+                                    timestamp,
+                                });
+                                if (part.state?.output) {
+                                    messages.push({
+                                        type: 'tool_result',
+                                        content: part.state.output,
+                                        toolId: part.callID || part.id,
+                                        timestamp,
+                                    });
+                                }
+                            }
+                        }
+                        catch {
+                            continue;
+                        }
+                    }
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        return { id: sessionId, messages };
+    },
+};

package/dist/sessions/agents/types.js

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

package/dist/sessions/agents/utils.js

@@ -0,0 +1,31 @@
+export function decodeClaudeProjectPath(encoded) {
+    return encoded.replace(/-/g, '/');
+}
+export function extractFirstUserPrompt(messages) {
+    const firstPrompt = messages.find((msg) => msg.type === 'user' && msg.content && msg.content.trim().length > 0);
+    return firstPrompt?.content ? firstPrompt.content.slice(0, 200) : null;
+}
+export function extractClaudeSessionName(content) {
+    const lines = content.split('\n').filter((line) => line.trim());
+    for (const line of lines) {
+        try {
+            const obj = JSON.parse(line);
+            if (obj.type === 'system' && obj.subtype === 'session_name') {
+                return obj.name || null;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+export function extractContent(content) {
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        const text = content.find((c) => c.type === 'text')?.text;
+        return typeof text === 'string' ? text : null;
+    }
+    return null;
+}

package/dist/shared/base-websocket.js

@@ -1,4 +1,16 @@
-import { WebSocketServer } from 'ws';
+import { WebSocket, WebSocketServer } from 'ws';
+export function safeSend(ws, data) {
+    if (ws.readyState !== WebSocket.OPEN) {
+        return false;
+    }
+    try {
+        ws.send(data);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 export class BaseWebSocketServer {
     wss;
     connections = new Map();

package/dist/shared/constants.js

@@ -1,7 +1,8 @@
 export const DEFAULT_AGENT_PORT = 7391;
 export const SSH_PORT_RANGE_START = 2200;
 export const SSH_PORT_RANGE_END = 2400;
-export const WORKSPACE_IMAGE = 'workspace:latest';
+export const WORKSPACE_IMAGE_LOCAL = 'workspace:latest';
+export const WORKSPACE_IMAGE_REGISTRY = 'ghcr.io/gricha/perry';
 export const VOLUME_PREFIX = 'workspace-';
 export const CONTAINER_PREFIX = 'workspace-';
 export const AGENT_SESSION_PATHS = {

package/dist/terminal/base-handler.js

@@ -0,0 +1,68 @@
+export class BaseTerminalSession {
+    process = null;
+    terminal = null;
+    shell;
+    size;
+    onData = null;
+    onExit = null;
+    constructor(shell, size) {
+        this.shell = shell;
+        this.size = size || { cols: 80, rows: 24 };
+    }
+    start() {
+        if (this.process) {
+            throw new Error('Terminal session already started');
+        }
+        const config = this.getSpawnConfig();
+        this.process = Bun.spawn(config.command, {
+            cwd: config.cwd,
+            env: config.env,
+            terminal: {
+                cols: this.size.cols,
+                rows: this.size.rows,
+                data: (_terminal, chunk) => {
+                    if (this.onData) {
+                        this.onData(Buffer.from(chunk));
+                    }
+                },
+            },
+        });
+        this.terminal = this.process.terminal;
+        this.process.exited.then((code) => {
+            this.process = null;
+            this.terminal = null;
+            if (this.onExit) {
+                this.onExit(code);
+            }
+        });
+    }
+    write(data) {
+        if (!this.terminal) {
+            return;
+        }
+        this.terminal.write(data.toString());
+    }
+    resize(size) {
+        this.size = size;
+        if (!this.terminal) {
+            return;
+        }
+        this.terminal.resize(size.cols, size.rows);
+    }
+    setOnData(callback) {
+        this.onData = callback;
+    }
+    setOnExit(callback) {
+        this.onExit = callback;
+    }
+    kill() {
+        if (this.process) {
+            this.process.kill();
+            this.process = null;
+            this.terminal = null;
+        }
+    }
+    isRunning() {
+        return this.process !== null;
+    }
+}

package/dist/terminal/handler.js

@@ -1,84 +1,27 @@
-export class TerminalSession {
-    process = null;
-    terminal = null;
+import { BaseTerminalSession } from './base-handler';
+export class TerminalSession extends BaseTerminalSession {
     containerName;
     user;
-    shell;
-    size;
-    onData = null;
-    onExit = null;
     constructor(options) {
+        super(options.shell || '/bin/bash', options.size);
         this.containerName = options.containerName;
         this.user = options.user || 'workspace';
-        this.shell = options.shell || '/bin/bash';
-        this.size = options.size || { cols: 80, rows: 24 };
     }
-    start() {
-        if (this.process) {
-            throw new Error('Terminal session already started');
-        }
-        const args = [
-            'exec',
-            '-it',
-            '-u',
-            this.user,
-            '-e',
-            `TERM=xterm-256color`,
-            this.containerName,
-            this.shell,
-            '-l',
-        ];
-        this.process = Bun.spawn(['docker', ...args], {
-            terminal: {
-                cols: this.size.cols,
-                rows: this.size.rows,
-                data: (_terminal, chunk) => {
-                    if (this.onData) {
-                        this.onData(Buffer.from(chunk));
-                    }
-                },
-            },
-        });
-        this.terminal = this.process.terminal;
-        this.process.exited.then((code) => {
-            this.process = null;
-            this.terminal = null;
-            if (this.onExit) {
-                this.onExit(code);
-            }
-        });
-    }
-    write(data) {
-        if (!this.terminal) {
-            return;
-        }
-        this.terminal.write(data.toString());
-    }
-    resize(size) {
-        this.size = size;
-        console.log('[terminal] Resize request:', size.cols, 'x', size.rows);
-        if (!this.terminal) {
-            console.log('[terminal] No terminal yet, storing size for later');
-            return;
-        }
-        this.terminal.resize(size.cols, size.rows);
-        console.log('[terminal] Resized terminal to', size.cols, 'x', size.rows);
-    }
-    setOnData(callback) {
-        this.onData = callback;
-    }
-    setOnExit(callback) {
-        this.onExit = callback;
-    }
-    kill() {
-        if (this.process) {
-            this.process.kill();
-            this.process = null;
-            this.terminal = null;
-        }
-    }
-    isRunning() {
-        return this.process !== null;
+    getSpawnConfig() {
+        return {
+            command: [
+                'docker',
+                'exec',
+                '-it',
+                '-u',
+                this.user,
+                '-e',
+                'TERM=xterm-256color',
+                this.containerName,
+                this.shell,
+                '-l',
+            ],
+        };
     }
 }
 export function createTerminalSession(options) {