@gricha/perry 0.2.1 → 0.2.2

package/README.md

@@ -10,11 +10,23 @@
   <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License: MIT"></a>
 </p>
 
-<p align="center">Isolated, self-hosted workspaces accessible over Tailscale. AI coding agents, web UI, and remote terminal access.</p>
+<p align="center">
+  Continue your coding sessions on the go. Self-hosted workspaces, accessible over Tailscale.
+</p>
+
+<p align="center">
+  <img src="assets/demo-terminal-mobile.gif" alt="Terminal" width="280">
+  &nbsp;&nbsp;&nbsp;
+  <img src="assets/demo-chat-mobile.gif" alt="Chat" width="280">
+</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.
+Perry is an agent (agent P) designed to run as a daemon on your machine. It allows your clients - other machines through CLI, web, or mobile app - to connect directly to your workspaces over the Tailscale network.
+
+It can be connected directly to your host, or it can create docker containers so that your work can be fully isolated.
+
+Continue your sessions on the go!
 
 ## Features
 
@@ -65,6 +77,10 @@ perry list
 
 Open http://localhost:7391 (or your Tailscale host) and click "+" to create a workspace.
 
+<p align="center">
+  <img src="assets/demo.gif" alt="Web UI Demo" width="800">
+</p>
+
 ## Security
 
 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.

package/dist/agent/router.js

@@ -9,8 +9,9 @@ import { saveAgentConfig } from '../config/loader';
 import { setSessionName, getSessionNamesForWorkspace, deleteSessionName, } from '../sessions/metadata';
 import { discoverSSHKeys } from '../ssh/discovery';
 import { parseClaudeSessionContent } from '../sessions/parser';
-import { discoverAllSessions, getSessionDetails as getAgentSessionDetails, getSessionMessages, findSessionMessages, } from '../sessions/agents';
+import { discoverAllSessions, getSessionDetails as getAgentSessionDetails, getSessionMessages, findSessionMessages, deleteSession as deleteSessionFromProvider, searchSessions as searchSessionsInContainer, } from '../sessions/agents';
 import { discoverClaudeCodeModels, discoverHostOpencodeModels, discoverContainerOpencodeModels, } from '../models/discovery';
+import { listOpencodeSessions, getOpencodeSessionMessages, deleteOpencodeSession, } from '../sessions/agents/opencode-storage';
 const WorkspaceStatusSchema = z.enum(['running', 'stopped', 'creating', 'error']);
 const WorkspacePortsSchema = z.object({
     ssh: z.number(),
@@ -207,6 +208,7 @@ export function createRouter(ctx) {
             workspacesCount: allWorkspaces.length,
             dockerVersion,
             terminalConnections: ctx.terminalServer.getConnectionCount(),
+            tailscale: ctx.tailscale,
         };
     });
     const getCredentials = os.output(CredentialsSchema).handler(async () => {
@@ -305,32 +307,16 @@ export function createRouter(ctx) {
             }
         }
         if (!input.agentType || input.agentType === 'opencode') {
-            const opencodeDir = path.join(homeDir, '.opencode', 'sessions');
-            try {
-                const sessions = await fs.readdir(opencodeDir);
-                for (const sessionDir of sessions) {
-                    const sessionPath = path.join(opencodeDir, sessionDir);
-                    const stat = await fs.stat(sessionPath);
-                    if (!stat.isDirectory())
-                        continue;
-                    const sessionFile = path.join(sessionPath, 'session.json');
-                    try {
-                        const sessionStat = await fs.stat(sessionFile);
-                        rawSessions.push({
-                            id: sessionDir,
-                            agentType: 'opencode',
-                            projectPath: homeDir,
-                            mtime: sessionStat.mtimeMs,
-                            filePath: sessionFile,
-                        });
-                    }
-                    catch {
-                        // session.json doesn't exist
-                    }
-                }
-            }
-            catch {
-                // Directory doesn't exist
+            const opencodeSessions = await listOpencodeSessions();
+            for (const session of opencodeSessions) {
+                rawSessions.push({
+                    id: session.id,
+                    agentType: 'opencode',
+                    projectPath: session.directory || homeDir,
+                    mtime: session.mtime,
+                    filePath: session.file,
+                    name: session.title || undefined,
+                });
             }
         }
         rawSessions.sort((a, b) => b.mtime - a.mtime);
@@ -371,16 +357,17 @@ export function createRouter(ctx) {
                 }
             }
             else if (raw.agentType === 'opencode') {
-                try {
-                    const sessionContent = await fs.readFile(raw.filePath, 'utf-8');
-                    const sessionData = JSON.parse(sessionContent);
-                    messageCount = sessionData.messages?.length || 0;
-                    if (sessionData.title) {
-                        firstPrompt = sessionData.title;
-                    }
+                const sessionMessages = await getOpencodeSessionMessages(raw.id);
+                const userAssistantMessages = sessionMessages.messages.filter((m) => m.type === 'user' || m.type === 'assistant');
+                messageCount = userAssistantMessages.length;
+                if (raw.name) {
+                    firstPrompt = raw.name;
                 }
-                catch {
-                    // Can't read file
+                else {
+                    const firstUserMsg = userAssistantMessages.find((m) => m.type === 'user' && m.content);
+                    if (firstUserMsg?.content) {
+                        firstPrompt = firstUserMsg.content.slice(0, 200);
+                    }
                 }
             }
             return {
@@ -434,57 +421,17 @@ export function createRouter(ctx) {
             }
         }
         if (!agentType || agentType === 'opencode') {
-            const sessionDir = path.join(homeDir, '.opencode', 'sessions', sessionId);
-            const partsDir = path.join(sessionDir, 'part');
-            try {
-                const partFiles = await fs.readdir(partsDir);
-                const sortedParts = partFiles.sort();
-                for (const partFile of sortedParts) {
-                    const partPath = path.join(partsDir, partFile);
-                    try {
-                        const partContent = await fs.readFile(partPath, 'utf-8');
-                        const part = JSON.parse(partContent);
-                        if (part.role === 'user' && part.content) {
-                            const textContent = Array.isArray(part.content)
-                                ? part.content
-                                    .filter((c) => c.type === 'text')
-                                    .map((c) => c.text)
-                                    .join('\n')
-                                : part.content;
-                            messages.push({
-                                type: 'user',
-                                content: textContent,
-                                timestamp: part.time || null,
-                            });
-                        }
-                        else if (part.role === 'assistant') {
-                            if (part.content) {
-                                const textContent = Array.isArray(part.content)
-                                    ? part.content
-                                        .filter((c) => c.type === 'text')
-                                        .map((c) => c.text)
-                                        .join('\n')
-                                    : part.content;
-                                if (textContent) {
-                                    messages.push({
-                                        type: 'assistant',
-                                        content: textContent,
-                                        timestamp: part.time || null,
-                                    });
-                                }
-                            }
-                        }
-                    }
-                    catch {
-                        // Can't parse part
-                    }
-                }
-                if (messages.length > 0) {
-                    return { id: sessionId, agentType: 'opencode', messages };
-                }
-            }
-            catch {
-                // Directory doesn't exist
+            const sessionData = await getOpencodeSessionMessages(sessionId);
+            if (sessionData.messages.length > 0) {
+                const opencodeMessages = sessionData.messages.map((m) => ({
+                    type: m.type,
+                    content: m.content,
+                    toolName: m.toolName,
+                    toolId: m.toolId,
+                    toolInput: m.toolInput,
+                    timestamp: m.timestamp,
+                }));
+                return { id: sessionId, agentType: 'opencode', messages: opencodeMessages };
             }
         }
         return { id: sessionId, messages };
@@ -627,6 +574,196 @@ export function createRouter(ctx) {
         await ctx.sessionsCache.recordAccess(input.workspaceName, input.sessionId, input.agentType);
         return { success: true };
     });
+    const deleteSession = os
+        .input(z.object({
+        workspaceName: z.string(),
+        sessionId: z.string(),
+        agentType: z.enum(['claude-code', 'opencode', 'codex']),
+    }))
+        .handler(async ({ input }) => {
+        const isHost = input.workspaceName === HOST_WORKSPACE_NAME;
+        if (isHost) {
+            const config = ctx.config.get();
+            if (!config.allowHostAccess) {
+                throw new ORPCError('PRECONDITION_FAILED', { message: 'Host access is disabled' });
+            }
+            const result = await deleteHostSession(input.sessionId, input.agentType);
+            if (!result.success) {
+                throw new ORPCError('INTERNAL_SERVER_ERROR', {
+                    message: result.error || 'Failed to delete session',
+                });
+            }
+            await deleteSessionName(ctx.stateDir, input.workspaceName, input.sessionId);
+            await ctx.sessionsCache.removeSession(input.workspaceName, input.sessionId);
+            return { success: true };
+        }
+        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 result = await deleteSessionFromProvider(containerName, input.sessionId, input.agentType, execInContainer);
+        if (!result.success) {
+            throw new ORPCError('INTERNAL_SERVER_ERROR', {
+                message: result.error || 'Failed to delete session',
+            });
+        }
+        await deleteSessionName(ctx.stateDir, input.workspaceName, input.sessionId);
+        await ctx.sessionsCache.removeSession(input.workspaceName, input.sessionId);
+        return { success: true };
+    });
+    const searchSessions = os
+        .input(z.object({
+        workspaceName: z.string(),
+        query: z.string().min(1).max(500),
+    }))
+        .handler(async ({ input }) => {
+        const isHost = input.workspaceName === HOST_WORKSPACE_NAME;
+        if (isHost) {
+            const config = ctx.config.get();
+            if (!config.allowHostAccess) {
+                throw new ORPCError('PRECONDITION_FAILED', { message: 'Host access is disabled' });
+            }
+            const results = await searchHostSessions(input.query);
+            return { results };
+        }
+        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 results = await searchSessionsInContainer(containerName, input.query, execInContainer);
+        return { results };
+    });
+    async function searchHostSessions(query) {
+        const homeDir = os_module.homedir();
+        const safeQuery = query.replace(/['"\\]/g, '\\$&');
+        const searchPaths = [
+            path.join(homeDir, '.claude', 'projects'),
+            path.join(homeDir, '.local', 'share', 'opencode', 'storage'),
+            path.join(homeDir, '.codex', 'sessions'),
+        ].filter((p) => {
+            try {
+                require('fs').accessSync(p);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        });
+        if (searchPaths.length === 0) {
+            return [];
+        }
+        const { execSync } = await import('child_process');
+        try {
+            const output = execSync(`rg -l -i --no-messages "${safeQuery}" ${searchPaths.join(' ')} 2>/dev/null | head -100`, {
+                encoding: 'utf-8',
+                timeout: 30000,
+            });
+            const files = output.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('/.codex/sessions/')) {
+                    const match = file.match(/\/([^/]+)\.jsonl$/);
+                    if (match) {
+                        sessionId = match[1];
+                        agentType = 'codex';
+                    }
+                }
+                if (sessionId && agentType) {
+                    results.push({ sessionId, agentType, matchCount: 1 });
+                }
+            }
+            return results;
+        }
+        catch {
+            return [];
+        }
+    }
+    async function deleteHostSession(sessionId, agentType) {
+        const homeDir = os_module.homedir();
+        if (agentType === 'claude-code') {
+            const safeSessionId = sessionId.replace(/[^a-zA-Z0-9_-]/g, '');
+            const claudeProjectsDir = path.join(homeDir, '.claude', 'projects');
+            try {
+                const projectDirs = await fs.readdir(claudeProjectsDir);
+                for (const projectDir of projectDirs) {
+                    const sessionFile = path.join(claudeProjectsDir, projectDir, `${safeSessionId}.jsonl`);
+                    try {
+                        await fs.unlink(sessionFile);
+                        return { success: true };
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+            }
+            catch {
+                return { success: false, error: 'Session not found' };
+            }
+            return { success: false, error: 'Session not found' };
+        }
+        if (agentType === 'opencode') {
+            return deleteOpencodeSession(sessionId);
+        }
+        if (agentType === 'codex') {
+            const codexSessionsDir = path.join(homeDir, '.codex', 'sessions');
+            try {
+                const files = await fs.readdir(codexSessionsDir);
+                for (const file of files) {
+                    if (!file.endsWith('.jsonl'))
+                        continue;
+                    const filePath = path.join(codexSessionsDir, file);
+                    const fileId = file.replace('.jsonl', '');
+                    if (fileId === sessionId) {
+                        await fs.unlink(filePath);
+                        return { success: true };
+                    }
+                    try {
+                        const content = await fs.readFile(filePath, 'utf-8');
+                        const firstLine = content.split('\n')[0];
+                        const meta = JSON.parse(firstLine);
+                        if (meta.session_id === sessionId) {
+                            await fs.unlink(filePath);
+                            return { success: true };
+                        }
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+            }
+            catch {
+                return { success: false, error: 'Session not found' };
+            }
+            return { success: false, error: 'Session not found' };
+        }
+        return { success: false, error: 'Unsupported agent type' };
+    }
     const getHostInfo = os.handler(async () => {
         const config = ctx.config.get();
         return {
@@ -724,6 +861,8 @@ export function createRouter(ctx) {
             clearName: clearSessionName,
             getRecent: getRecentSessions,
             recordAccess: recordSessionAccess,
+            delete: deleteSession,
+            search: searchSessions,
         },
         models: {
             list: listModels,

package/dist/agent/run.js

@@ -13,13 +13,14 @@ import { createRouter } from './router';
 import { serveStatic } from './static';
 import { SessionsCacheManager } from '../sessions/cache';
 import { ModelCacheManager } from '../models/cache';
+import { getTailscaleStatus, getTailscaleIdentity, startTailscaleServe, stopTailscaleServe, } from '../tailscale';
 import pkg from '../../package.json';
 const startTime = Date.now();
 function sendJson(res, status, data) {
     res.writeHead(status, { 'Content-Type': 'application/json' });
     res.end(JSON.stringify(data));
 }
-function createAgentServer(configDir, config) {
+function createAgentServer(configDir, config, tailscale) {
     let currentConfig = config;
     const workspaces = new WorkspaceManager(configDir, currentConfig);
     const sessionsCache = new SessionsCacheManager(configDir);
@@ -60,12 +61,14 @@ function createAgentServer(configDir, config) {
         terminalServer,
         sessionsCache,
         modelCache,
+        tailscale,
     });
     const rpcHandler = new RPCHandler(router);
     const server = createServer(async (req, res) => {
         const url = new URL(req.url || '/', 'http://localhost');
         const method = req.method;
         const pathname = url.pathname;
+        const identity = getTailscaleIdentity(req);
         res.setHeader('Access-Control-Allow-Origin', '*');
         res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
         res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
@@ -76,7 +79,11 @@ function createAgentServer(configDir, config) {
         }
         try {
             if (pathname === '/health' && method === 'GET') {
-                sendJson(res, 200, { status: 'ok', version: pkg.version });
+                const response = { status: 'ok', version: pkg.version };
+                if (identity) {
+                    response.user = identity.email;
+                }
+                sendJson(res, 200, response);
                 return;
             }
             if (pathname.startsWith('/rpc')) {
@@ -151,7 +158,38 @@ export async function startAgent(options = {}) {
     const port = options.port || parseInt(process.env.PERRY_PORT || '', 10) || config.port || DEFAULT_AGENT_PORT;
     console.log(`[agent] Config directory: ${configDir}`);
     console.log(`[agent] Starting on port ${port}...`);
-    const { server, terminalServer, chatServer, opencodeServer } = createAgentServer(configDir, config);
+    const tailscale = await getTailscaleStatus();
+    let tailscaleServeActive = false;
+    if (tailscale.running && tailscale.dnsName) {
+        console.log(`[agent] Tailscale detected: ${tailscale.dnsName}`);
+        if (!tailscale.httpsEnabled) {
+            console.log(`[agent] Tailscale HTTPS not enabled in tailnet, skipping Serve`);
+        }
+        else {
+            const result = await startTailscaleServe(port);
+            if (result.success) {
+                tailscaleServeActive = true;
+                console.log(`[agent] Tailscale Serve enabled`);
+            }
+            else if (result.error === 'permission_denied') {
+                console.log(`[agent] Tailscale Serve requires operator permissions`);
+                console.log(`[agent] To enable: ${result.message}`);
+                console.log(`[agent] Continuing without HTTPS...`);
+            }
+            else {
+                console.log(`[agent] Tailscale Serve failed: ${result.message || 'unknown error'}`);
+            }
+        }
+    }
+    const tailscaleInfo = tailscale.running && tailscale.dnsName
+        ? {
+            running: true,
+            dnsName: tailscale.dnsName,
+            serveActive: tailscaleServeActive,
+            httpsUrl: tailscaleServeActive ? `https://${tailscale.dnsName}` : undefined,
+        }
+        : undefined;
+    const { server, terminalServer, chatServer, opencodeServer } = createAgentServer(configDir, config, tailscaleInfo);
     server.on('error', async (err) => {
         if (err.code === 'EADDRINUSE') {
             console.error(`[agent] Error: Port ${port} is already in use.`);
@@ -169,14 +207,25 @@ export async function startAgent(options = {}) {
     });
     server.listen(port, '::', () => {
         console.log(`[agent] Agent running at http://localhost:${port}`);
+        if (tailscale.running && tailscale.dnsName) {
+            const shortName = tailscale.dnsName.split('.')[0];
+            console.log(`[agent] Tailnet: http://${shortName}:${port}`);
+            if (tailscaleServeActive) {
+                console.log(`[agent] Tailnet HTTPS: https://${tailscale.dnsName}`);
+            }
+        }
         console.log(`[agent] oRPC endpoint: http://localhost:${port}/rpc`);
         console.log(`[agent] WebSocket terminal: ws://localhost:${port}/rpc/terminal/:name`);
         console.log(`[agent] WebSocket chat (Claude): ws://localhost:${port}/rpc/chat/:name`);
         console.log(`[agent] WebSocket chat (OpenCode): ws://localhost:${port}/rpc/opencode/:name`);
         startEagerImagePull();
     });
-    const shutdown = () => {
+    const shutdown = async () => {
         console.log('[agent] Shutting down...');
+        if (tailscaleServeActive) {
+            console.log('[agent] Stopping Tailscale Serve...');
+            await stopTailscaleServe();
+        }
         chatServer.close();
         opencodeServer.close();
         terminalServer.close();