@gricha/perry 0.2.1 → 0.2.3

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,10 +77,22 @@ 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.
 
+NOTE: Using this software can be dangerous, don't expose it on the network. Any user that can access perry's web server may be able to do serious damage to your system. Keep it closed in Tailscale network.
+
+Perry by default allows the API to interact with the host machine as well - while it's intended purpose is to manage docker containers, sometimes, for simplicity I run some of my jobs directly on my machine. This can be disabled. When you start perry, you can pass a `--no-host-access` flag.
+
+`perry agent run --no-host-access`
+
+This will ensure that perry can only stand up/tear down docker containers. While this reduces the attack surface, it is only as good as docker is as sandbox (and it may very well not be).
+
 ## Configuration
 
 Configure credentials and agent settings via Web UI → Settings or edit `~/.config/perry/config.json`:

package/dist/agent/file-watcher.js

@@ -0,0 +1,138 @@
+import { watch } from 'fs';
+import { access } from 'fs/promises';
+import { expandPath } from '../config/loader';
+const STANDARD_CREDENTIAL_FILES = [
+    '~/.gitconfig',
+    '~/.claude/.credentials.json',
+    '~/.codex/auth.json',
+    '~/.codex/config.toml',
+];
+export class FileWatcher {
+    watchers = new Map();
+    config;
+    syncCallback;
+    debounceMs;
+    debounceTimer = null;
+    pendingSync = false;
+    constructor(options) {
+        this.config = options.config;
+        this.syncCallback = options.syncCallback;
+        this.debounceMs = options.debounceMs ?? 500;
+        this.setupWatchers();
+    }
+    updateConfig(config) {
+        this.config = config;
+        this.rebuildWatchers();
+    }
+    stop() {
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        for (const [filePath, watcher] of this.watchers) {
+            watcher.close();
+            console.log(`[file-watcher] Stopped watching: ${filePath}`);
+        }
+        this.watchers.clear();
+    }
+    collectWatchPaths() {
+        const paths = new Set();
+        for (const sourcePath of Object.values(this.config.credentials.files)) {
+            paths.add(expandPath(sourcePath));
+        }
+        for (const stdPath of STANDARD_CREDENTIAL_FILES) {
+            paths.add(expandPath(stdPath));
+        }
+        if (this.config.ssh?.global?.copy) {
+            for (const keyPath of this.config.ssh.global.copy) {
+                paths.add(expandPath(keyPath));
+            }
+        }
+        if (this.config.ssh?.workspaces) {
+            for (const wsConfig of Object.values(this.config.ssh.workspaces)) {
+                if (wsConfig.copy) {
+                    for (const keyPath of wsConfig.copy) {
+                        paths.add(expandPath(keyPath));
+                    }
+                }
+            }
+        }
+        return Array.from(paths);
+    }
+    async setupWatchers() {
+        const paths = this.collectWatchPaths();
+        for (const filePath of paths) {
+            await this.watchFile(filePath);
+        }
+    }
+    async watchFile(filePath) {
+        if (this.watchers.has(filePath)) {
+            return;
+        }
+        try {
+            await access(filePath);
+        }
+        catch {
+            return;
+        }
+        try {
+            const watcher = watch(filePath, (eventType) => {
+                if (eventType === 'change' || eventType === 'rename') {
+                    this.handleFileChange(filePath);
+                }
+            });
+            watcher.on('error', (err) => {
+                console.error(`[file-watcher] Error watching ${filePath}:`, err);
+                this.watchers.delete(filePath);
+            });
+            this.watchers.set(filePath, watcher);
+            console.log(`[file-watcher] Watching: ${filePath}`);
+        }
+        catch (err) {
+            console.error(`[file-watcher] Failed to watch ${filePath}:`, err);
+        }
+    }
+    handleFileChange(filePath) {
+        console.log(`[file-watcher] Change detected: ${filePath}`);
+        this.scheduleSync();
+    }
+    scheduleSync() {
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+        }
+        this.pendingSync = true;
+        this.debounceTimer = setTimeout(async () => {
+            this.debounceTimer = null;
+            if (this.pendingSync) {
+                this.pendingSync = false;
+                try {
+                    console.log('[file-watcher] Triggering sync...');
+                    await this.syncCallback();
+                    console.log('[file-watcher] Sync completed');
+                }
+                catch (err) {
+                    console.error('[file-watcher] Sync failed:', err);
+                }
+            }
+        }, this.debounceMs);
+    }
+    rebuildWatchers() {
+        const newPaths = new Set(this.collectWatchPaths());
+        const currentPaths = new Set(this.watchers.keys());
+        for (const filePath of currentPaths) {
+            if (!newPaths.has(filePath)) {
+                const watcher = this.watchers.get(filePath);
+                if (watcher) {
+                    watcher.close();
+                    this.watchers.delete(filePath);
+                    console.log(`[file-watcher] Stopped watching: ${filePath}`);
+                }
+            }
+        }
+        for (const filePath of newPaths) {
+            if (!currentPaths.has(filePath)) {
+                this.watchFile(filePath);
+            }
+        }
+    }
+}

package/dist/agent/router.js

@@ -3,14 +3,15 @@ import * as z from 'zod';
 import os_module from 'os';
 import { promises as fs } from 'fs';
 import path from 'path';
-import { HOST_WORKSPACE_NAME } from '../shared/types';
+import { HOST_WORKSPACE_NAME } from '../shared/client-types';
 import { getDockerVersion, execInContainer } from '../docker';
 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 () => {
@@ -220,6 +222,7 @@ export function createRouter(ctx) {
         const newConfig = { ...currentConfig, credentials: input };
         ctx.config.set(newConfig);
         await saveAgentConfig(newConfig, ctx.configDir);
+        ctx.triggerAutoSync();
         return input;
     });
     const getScripts = os.output(ScriptsSchema).handler(async () => {
@@ -233,6 +236,7 @@ export function createRouter(ctx) {
         const newConfig = { ...currentConfig, scripts: input };
         ctx.config.set(newConfig);
         await saveAgentConfig(newConfig, ctx.configDir);
+        ctx.triggerAutoSync();
         return input;
     });
     const getAgents = os.output(CodingAgentsSchema).handler(async () => {
@@ -246,6 +250,7 @@ export function createRouter(ctx) {
         const newConfig = { ...currentConfig, agents: input };
         ctx.config.set(newConfig);
         await saveAgentConfig(newConfig, ctx.configDir);
+        ctx.triggerAutoSync();
         return input;
     });
     const getSSHSettings = os.output(SSHSettingsSchema).handler(async () => {
@@ -264,6 +269,7 @@ export function createRouter(ctx) {
         const newConfig = { ...currentConfig, ssh: input };
         ctx.config.set(newConfig);
         await saveAgentConfig(newConfig, ctx.configDir);
+        ctx.triggerAutoSync();
         return input;
     });
     const listSSHKeys = os.output(z.array(SSHKeyInfoSchema)).handler(async () => {
@@ -305,32 +311,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 +361,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 +425,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 +578,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 +865,8 @@ export function createRouter(ctx) {
             clearName: clearSessionName,
             getRecent: getRecentSessions,
             recordAccess: recordSessionAccess,
+            delete: deleteSession,
+            search: searchSessions,
         },
         models: {
             list: listModels,