@gricha/perry 0.0.1 → 0.1.1

package/README.md

@@ -12,9 +12,13 @@
 
 <p align="center">Isolated, self-hosted workspaces accessible over Tailscale. AI coding agents, web UI, and remote terminal access.</p>
 
+## Overview
+
+Perry is designed to run on a machine within a **secure private network** such as [Tailscale](https://tailscale.com). It provides isolated Docker-based development environments that you can access remotely via CLI, web UI, or SSH from any device on your network.
+
 ## Features
 
-- **AI Coding Agents** - Claude Code, OpenCode, GitHub Copilot pre-installed
+- **AI Coding Agents** - Claude Code, OpenCode, Codex CLI pre-installed
 - **Self-Hosted** - Run on your own hardware, full control
 - **Remote Access** - Use from anywhere via Tailscale, CLI, web, or SSH
 - **Web UI** - Manage workspaces from your browser
@@ -28,26 +32,13 @@
 npm install -g @gricha/perry
 ```
 
-### Build Base Image
-
-```bash
-perry build
-```
-
 ### Start Agent
 
 ```bash
 perry agent run
 ```
 
-Web UI: **http://localhost:7391**
-
-The agent runs on port 7391 by default. For remote access, install as a service:
-
-```bash
-perry agent install
-systemctl --user start perry-agent
-```
+Web UI: **http://localhost:7391** (or your Tailscale host)
 
 ### Create & Use Workspaces
 
@@ -60,42 +51,47 @@ perry create myproject
 # Or clone a repo
 perry create myproject --clone git@github.com:user/repo.git
 
-# SSH into workspace
-perry list  # Find SSH port
-ssh -p 2201 workspace@localhost
+# Shell into workspace
+perry shell myproject
 
 # Manage workspaces
 perry start myproject
 perry stop myproject
 perry delete myproject
+perry list
 ```
 
 **Via Web UI:**
 
-Open http://localhost:7391 and click "+" to create a workspace.
+Open http://localhost:7391 (or your Tailscale host) and click "+" to create a workspace.
 
 ## Security
 
-Perry is designed for use within **secure networks** like [Tailscale](https://tailscale.com). The web UI and API have no authentication, making them ideal for private networks where you can safely access workspaces remotely without additional security concerns.
-
-For public internet exposure, place behind a reverse proxy with authentication.
+Perry is designed for use within **secure private networks** like [Tailscale](https://tailscale.com). The web UI and API currently have no authentication - this is intentional for private network use where all devices are trusted.
 
 ## Configuration
 
-Configure credentials and environment variables via Web UI → Settings or edit `~/.config/perry/config.json`:
+Configure credentials and agent settings via Web UI → Settings or edit `~/.config/perry/config.json`:
 
 ```json
 {
   "credentials": {
-    "env": {
-      "ANTHROPIC_API_KEY": "sk-ant-...",
-      "OPENAI_API_KEY": "sk-...",
-      "GITHUB_TOKEN": "ghp_..."
-    },
+    "env": {},
     "files": {
       "~/.ssh/id_ed25519": "~/.ssh/id_ed25519",
       "~/.gitconfig": "~/.gitconfig"
     }
+  },
+  "agents": {
+    "github": {
+      "token": "ghp_..."
+    },
+    "claude_code": {
+      "oauth_token": "..."
+    },
+    "opencode": {
+      "zen_token": "..."
+    }
   }
 }
 ```
@@ -116,8 +112,6 @@ Restart workspaces to apply changes.
 ```bash
 # Agent
 perry agent run [--port PORT]
-perry agent install
-perry agent uninstall
 perry agent status
 
 # Workspaces
@@ -126,10 +120,8 @@ perry start <name>
 perry stop <name>
 perry delete <name>
 perry list
+perry shell <name>
 perry logs <name>
-
-# Build
-perry build [--no-cache]
 ```
 
 ## Development

package/dist/agent/router.js

@@ -8,6 +8,7 @@ import { getDockerVersion, execInContainer } from '../docker';
 import { saveAgentConfig } from '../config/loader';
 import { setSessionName, getSessionNamesForWorkspace, deleteSessionName, } from '../sessions/metadata';
 import { parseClaudeSessionContent } from '../sessions/parser';
+import { discoverAllSessions, getSessionDetails as getAgentSessionDetails, getSessionMessages, findSessionMessages, } from '../sessions/agents';
 const WorkspaceStatusSchema = z.enum(['running', 'stopped', 'creating', 'error']);
 const WorkspacePortsSchema = z.object({
     ssh: z.number(),
@@ -56,37 +57,6 @@ function mapErrorToORPC(err, defaultMessage) {
     }
     throw new ORPCError('INTERNAL_SERVER_ERROR', { message });
 }
-function decodeClaudeProjectPath(encoded) {
-    return encoded.replace(/-/g, '/');
-}
-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;
-}
-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;
-}
-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;
-}
 export function createRouter(ctx) {
     const listWorkspaces = os.handler(async () => {
         return ctx.workspaces.list();
@@ -479,211 +449,21 @@ export function createRouter(ctx) {
             throw new ORPCError('PRECONDITION_FAILED', { message: 'Workspace is not running' });
         }
         const containerName = `workspace-${input.workspaceName}`;
-        const rawSessions = [];
-        const claudeResult = await execInContainer(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' });
-        if (claudeResult.exitCode === 0 && claudeResult.stdout.trim()) {
-            const lines = claudeResult.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;
-                    rawSessions.push({
-                        id,
-                        agentType: 'claude-code',
-                        mtime,
-                        projectPath,
-                        filePath: file,
-                    });
-                }
-            }
-        }
-        const opencodeResult = await execInContainer(containerName, [
-            'sh',
-            '-c',
-            'find /home/workspace/.local/share/opencode/storage/session -name "ses_*.json" -type f 2>/dev/null || true',
-        ], { user: 'workspace' });
-        if (opencodeResult.exitCode === 0 && opencodeResult.stdout.trim()) {
-            const files = opencodeResult.stdout.trim().split('\n').filter(Boolean);
-            const catAll = await execInContainer(containerName, ['sh', '-c', `cat ${files.map((f) => `"${f}"`).join(' ')} 2>/dev/null | jq -s '.'`], { user: 'workspace' });
-            if (catAll.exitCode === 0) {
-                try {
-                    const sessions = JSON.parse(catAll.stdout);
-                    for (let i = 0; i < sessions.length; i++) {
-                        const data = sessions[i];
-                        const file = files[i];
-                        const id = data.id || file.split('/').pop()?.replace('.json', '') || '';
-                        const mtime = Math.floor((data.time?.updated || 0) / 1000);
-                        rawSessions.push({
-                            id,
-                            agentType: 'opencode',
-                            projectPath: data.directory || '',
-                            mtime,
-                            name: data.title || undefined,
-                            filePath: file,
-                        });
-                    }
-                }
-                catch {
-                    // Skip on parse error
-                }
-            }
-        }
-        const codexResult = await execInContainer(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' });
-        if (codexResult.exitCode === 0 && codexResult.stdout.trim()) {
-            const lines = codexResult.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(/\/[^/]+$/, '');
-                    rawSessions.push({
-                        id,
-                        agentType: 'codex',
-                        projectPath: projPath,
-                        mtime,
-                        filePath: file,
-                    });
-                }
-            }
-        }
+        const rawSessions = await discoverAllSessions(containerName, execInContainer);
         const customNames = await getSessionNamesForWorkspace(ctx.stateDir, input.workspaceName);
         const filteredSessions = rawSessions
             .filter((s) => !input.agentType || s.agentType === input.agentType)
             .sort((a, b) => b.mtime - a.mtime);
         const paginatedRawSessions = filteredSessions.slice(offset, offset + limit);
         const sessions = [];
-        for (const session of paginatedRawSessions) {
-            if (session.agentType === 'claude-code') {
-                const catResult = await execInContainer(containerName, ['cat', session.filePath], {
-                    user: 'workspace',
-                });
-                if (catResult.exitCode !== 0) {
-                    continue;
-                }
-                const messages = parseClaudeSessionContent(catResult.stdout).filter((msg) => msg.type !== 'system');
-                const firstPrompt = extractFirstUserPrompt(messages);
-                const name = extractClaudeSessionName(catResult.stdout);
-                if (messages.length === 0) {
-                    continue;
-                }
+        for (const rawSession of paginatedRawSessions) {
+            const details = await getAgentSessionDetails(containerName, rawSession, execInContainer);
+            if (details) {
                 sessions.push({
-                    id: session.id,
-                    name: customNames[session.id] || name || null,
-                    agentType: session.agentType,
-                    projectPath: session.projectPath,
-                    messageCount: messages.length,
-                    lastActivity: new Date(session.mtime * 1000).toISOString(),
-                    firstPrompt,
+                    ...details,
+                    name: customNames[details.id] || details.name,
                 });
-                continue;
             }
-            if (session.agentType === 'opencode') {
-                const msgDir = `/home/workspace/.local/share/opencode/storage/message/${session.id}`;
-                const listMsgsResult = await execInContainer(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 execInContainer(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) {
-                    continue;
-                }
-                sessions.push({
-                    id: session.id,
-                    name: customNames[session.id] || session.name || null,
-                    agentType: session.agentType,
-                    projectPath: session.projectPath,
-                    messageCount: messages.length,
-                    lastActivity: new Date(session.mtime * 1000).toISOString(),
-                    firstPrompt: firstPrompt ? firstPrompt.slice(0, 200) : null,
-                });
-                continue;
-            }
-            const catResult = await execInContainer(containerName, ['cat', session.filePath], {
-                user: 'workspace',
-            });
-            if (catResult.exitCode !== 0) {
-                continue;
-            }
-            const lines = catResult.stdout.split('\n').filter(Boolean);
-            let sessionId = session.id;
-            if (lines.length > 0) {
-                try {
-                    const meta = JSON.parse(lines[0]);
-                    if (meta.session_id) {
-                        sessionId = meta.session_id;
-                    }
-                }
-                catch {
-                    // ignore
-                }
-            }
-            const messages = [];
-            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 });
-                    }
-                }
-                catch {
-                    continue;
-                }
-            }
-            const firstPrompt = messages.find((msg) => msg.type === 'user' && msg.content && msg.content.trim().length > 0)?.content;
-            if (messages.length === 0) {
-                continue;
-            }
-            sessions.push({
-                id: sessionId,
-                name: customNames[sessionId] || null,
-                agentType: session.agentType,
-                projectPath: session.projectPath,
-                messageCount: messages.length,
-                lastActivity: new Date(session.mtime * 1000).toISOString(),
-                firstPrompt: firstPrompt ? firstPrompt.slice(0, 200) : null,
-            });
         }
         return {
             sessions,
@@ -706,195 +486,50 @@ export function createRouter(ctx) {
         workspaceName: z.string(),
         sessionId: z.string(),
         agentType: z.enum(['claude-code', 'opencode', 'codex']).optional(),
+        limit: z.number().optional(),
+        offset: z.number().optional(),
     }))
         .handler(async ({ input }) => {
         const isHost = input.workspaceName === HOST_WORKSPACE_NAME;
+        let result;
         if (isHost) {
             const config = ctx.config.get();
             if (!config.allowHostAccess) {
                 throw new ORPCError('PRECONDITION_FAILED', { message: 'Host access is disabled' });
             }
-            return getHostSession(input.sessionId, input.agentType);
+            result = await getHostSession(input.sessionId, input.agentType);
         }
-        const workspace = await ctx.workspaces.get(input.workspaceName);
-        if (!workspace) {
-            throw new ORPCError('NOT_FOUND', { message: 'Workspace not found' });
-        }
-        if (workspace.status !== 'running') {
-            throw new ORPCError('PRECONDITION_FAILED', { message: 'Workspace is not running' });
-        }
-        const containerName = `workspace-${input.workspaceName}`;
-        const messages = [];
-        if (!input.agentType || input.agentType === 'claude-code') {
-            const safeSessionId = input.sessionId.replace(/[^a-zA-Z0-9_-]/g, '');
-            const findResult = await execInContainer(containerName, [
-                'find',
-                '/home/workspace/.claude/projects',
-                '-name',
-                `${safeSessionId}.jsonl`,
-                '-type',
-                'f',
-            ], { user: 'workspace' });
-            const foundPath = findResult.stdout.trim().split('\n')[0];
-            if (findResult.exitCode === 0 && foundPath) {
-                const filePath = foundPath;
-                const catResult = await execInContainer(containerName, ['cat', filePath], {
-                    user: 'workspace',
-                });
-                if (catResult.exitCode === 0) {
-                    const parsed = 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: input.sessionId, agentType: 'claude-code', messages: parsed };
-                }
-            }
-        }
-        if (!input.agentType || input.agentType === 'opencode') {
-            const findResult = await execInContainer(containerName, [
-                'bash',
-                '-c',
-                `find /home/workspace/.local/share/opencode/storage/session -name "${input.sessionId}.json" -type f 2>/dev/null | head -1`,
-            ], { user: 'workspace' });
-            if (findResult.exitCode === 0 && findResult.stdout.trim()) {
-                const filePath = findResult.stdout.trim();
-                const catResult = await execInContainer(containerName, ['cat', filePath], {
-                    user: 'workspace',
-                });
-                if (catResult.exitCode === 0) {
-                    try {
-                        const session = JSON.parse(catResult.stdout);
-                        const msgDir = `/home/workspace/.local/share/opencode/storage/message/${session.id}`;
-                        const partDir = `/home/workspace/.local/share/opencode/storage/part`;
-                        const listMsgsResult = await execInContainer(containerName, ['bash', '-c', `ls -1 "${msgDir}"/msg_*.json 2>/dev/null | sort`], { user: 'workspace' });
-                        if (listMsgsResult.exitCode === 0 && listMsgsResult.stdout.trim()) {
-                            const msgFiles = listMsgsResult.stdout.trim().split('\n').filter(Boolean);
-                            for (const msgFile of msgFiles) {
-                                const msgResult = await execInContainer(containerName, ['cat', msgFile], {
-                                    user: 'workspace',
-                                });
-                                if (msgResult.exitCode === 0) {
-                                    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 execInContainer(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 execInContainer(containerName, ['cat', partFile], { user: 'workspace' });
-                                                if (partResult.exitCode === 0) {
-                                                    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: input.sessionId, agentType: 'opencode', messages };
-                    }
-                    catch {
-                        // Session parse failed
-                    }
-                }
+        else {
+            const workspace = await ctx.workspaces.get(input.workspaceName);
+            if (!workspace) {
+                throw new ORPCError('NOT_FOUND', { message: 'Workspace not found' });
             }
-        }
-        if (!input.agentType || input.agentType === 'codex') {
-            const findResult = await execInContainer(containerName, [
-                'bash',
-                '-c',
-                `find /home/workspace/.codex/sessions -name "rollout-*.jsonl" -type f 2>/dev/null`,
-            ], { user: 'workspace' });
-            if (findResult.exitCode === 0 && findResult.stdout.trim()) {
-                const files = findResult.stdout.trim().split('\n').filter(Boolean);
-                for (const filePath of files) {
-                    const headResult = await execInContainer(containerName, ['bash', '-c', `head -1 "${filePath}"`], { user: 'workspace' });
-                    let sessionId = filePath.split('/').pop()?.replace('.jsonl', '') || '';
-                    if (headResult.exitCode === 0 && headResult.stdout.trim()) {
-                        try {
-                            const meta = JSON.parse(headResult.stdout.trim());
-                            if (meta.session_id)
-                                sessionId = meta.session_id;
-                        }
-                        catch {
-                            // Use filename
-                        }
-                    }
-                    if (sessionId === input.sessionId) {
-                        const catResult = await execInContainer(containerName, ['cat', filePath], {
-                            user: 'workspace',
-                        });
-                        if (catResult.exitCode === 0) {
-                            const lines = catResult.stdout.split('\n').filter(Boolean);
-                            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 parsedContent = extractContent(content);
-                                        messages.push({
-                                            type: role,
-                                            content: parsedContent || undefined,
-                                            timestamp: event.timestamp
-                                                ? new Date(event.timestamp).toISOString()
-                                                : undefined,
-                                        });
-                                    }
-                                }
-                                catch {
-                                    continue;
-                                }
-                            }
-                            return { id: input.sessionId, agentType: 'codex', messages };
-                        }
-                    }
-                }
+            if (workspace.status !== 'running') {
+                throw new ORPCError('PRECONDITION_FAILED', { message: 'Workspace is not running' });
             }
+            const containerName = `workspace-${input.workspaceName}`;
+            result = input.agentType
+                ? await getSessionMessages(containerName, input.sessionId, input.agentType, execInContainer)
+                : await findSessionMessages(containerName, input.sessionId, execInContainer);
+        }
+        if (!result) {
+            throw new ORPCError('NOT_FOUND', { message: 'Session not found' });
+        }
+        const allMessages = result.messages || [];
+        const total = allMessages.length;
+        if (input.limit !== undefined) {
+            const offset = input.offset ?? 0;
+            const startIndex = Math.max(0, total - offset - input.limit);
+            const endIndex = total - offset;
+            const paginatedMessages = allMessages.slice(startIndex, endIndex);
+            return {
+                ...result,
+                messages: paginatedMessages,
+                total,
+                hasMore: startIndex > 0,
+            };
         }
-        throw new ORPCError('NOT_FOUND', { message: 'Session not found' });
+        return { ...result, total, hasMore: false };
     });
     const renameSession = os
         .input(z.object({