npm - @gricha/perry - Versions diffs - 0.2.0 → 0.2.2 - Mend

@gricha/perry 0.2.0 → 0.2.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (22) hide show

package/README.md +18 -2
package/dist/agent/router.js +235 -89
package/dist/agent/run.js +55 -4
package/dist/agent/web/assets/index-DIOWcVH-.css +1 -0
package/dist/agent/web/assets/index-DN_QW9sL.js +104 -0
package/dist/agent/web/index.html +2 -2
package/dist/client/api.js +2 -2
package/dist/docker/eager-pull.js +65 -0
package/dist/index.js +47 -23
package/dist/perry-worker +0 -0
package/dist/sessions/agents/claude.js +19 -0
package/dist/sessions/agents/codex.js +40 -0
package/dist/sessions/agents/index.js +63 -0
package/dist/sessions/agents/opencode-storage.js +218 -0
package/dist/sessions/agents/opencode.js +17 -3
package/dist/sessions/cache.js +5 -0
package/dist/shared/constants.js +1 -1
package/dist/tailscale/index.js +80 -0
package/dist/workspace/manager.js +104 -53
package/package.json +3 -2
package/dist/agent/web/assets/index-CaFOQOgc.css +0 -1
package/dist/agent/web/assets/index-DQmM39Em.js +0 -104

package/dist/agent/web/index.html CHANGED Viewed

@@ -5,8 +5,8 @@
     <link rel="icon" type="image/x-icon" href="/favicon.ico" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Perry</title>
-    <script type="module" crossorigin src="/assets/index-DQmM39Em.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-CaFOQOgc.css">
+    <script type="module" crossorigin src="/assets/index-DN_QW9sL.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-DIOWcVH-.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/client/api.js CHANGED Viewed

@@ -66,9 +66,9 @@ export class ApiClient {
             throw this.wrapError(err);
         }
     }
-    async startWorkspace(name) {
+    async startWorkspace(name, options) {
         try {
-            return await this.client.workspaces.start({ name });
+            return await this.client.workspaces.start({ name, clone: options?.clone, env: options?.env });
         }
         catch (err) {
             throw this.wrapError(err);

package/dist/docker/eager-pull.js ADDED Viewed

@@ -0,0 +1,65 @@
+import { imageExists, tryPullImage, getDockerVersion } from './index';
+import { WORKSPACE_IMAGE_REGISTRY } from '../shared/constants';
+import pkg from '../../package.json';
+const RETRY_INTERVAL_MS = 20000;
+const MAX_RETRIES = 10;
+let pullInProgress = false;
+let pullComplete = false;
+async function isDockerAvailable() {
+    try {
+        await getDockerVersion();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function pullWorkspaceImage() {
+    const registryImage = `${WORKSPACE_IMAGE_REGISTRY}:${pkg.version}`;
+    const exists = await imageExists(registryImage);
+    if (exists) {
+        console.log(`[agent] Workspace image ${registryImage} already available`);
+        return true;
+    }
+    console.log(`[agent] Pulling workspace image ${registryImage}...`);
+    const pulled = await tryPullImage(registryImage);
+    if (pulled) {
+        console.log('[agent] Workspace image pulled successfully');
+        return true;
+    }
+    console.log('[agent] Failed to pull image - will retry later');
+    return false;
+}
+export async function startEagerImagePull() {
+    if (pullInProgress || pullComplete) {
+        return;
+    }
+    pullInProgress = true;
+    const attemptPull = async (attempt) => {
+        if (attempt > MAX_RETRIES) {
+            console.log('[agent] Max retries reached for image pull - giving up background pull');
+            pullInProgress = false;
+            return;
+        }
+        const dockerAvailable = await isDockerAvailable();
+        if (!dockerAvailable) {
+            if (attempt === 1) {
+                console.log('[agent] Docker not available - will retry in background');
+            }
+            setTimeout(() => attemptPull(attempt + 1), RETRY_INTERVAL_MS);
+            return;
+        }
+        const success = await pullWorkspaceImage();
+        if (success) {
+            pullComplete = true;
+            pullInProgress = false;
+        }
+        else {
+            setTimeout(() => attemptPull(attempt + 1), RETRY_INTERVAL_MS);
+        }
+    };
+    attemptPull(1);
+}
+export function isImagePullComplete() {
+    return pullComplete;
+}

package/dist/index.js CHANGED Viewed

@@ -131,36 +131,18 @@ program
         handleError(err);
     }
 });
-program
-    .command('create <name>')
-    .description('Create a new workspace')
-    .option('--clone <url>', 'Git repository URL to clone')
-    .action(async (name, options) => {
-    try {
-        const client = await getClient();
-        console.log(`Creating workspace '${name}'...`);
-        const workspace = await client.createWorkspace({
-            name,
-            clone: options.clone,
-        });
-        console.log(`Workspace '${workspace.name}' created.`);
-        console.log(`  Status: ${workspace.status}`);
-        console.log(`  SSH Port: ${workspace.ports.ssh}`);
-    }
-    catch (err) {
-        handleError(err);
-    }
-});
 program
     .command('start <name>')
-    .description('Start a stopped workspace')
-    .action(async (name) => {
+    .description('Start a workspace (creates it if it does not exist)')
+    .option('--clone <url>', 'Git repository URL to clone (when creating)')
+    .action(async (name, options) => {
     try {
         const client = await getClient();
         console.log(`Starting workspace '${name}'...`);
-        const workspace = await client.startWorkspace(name);
+        const workspace = await client.startWorkspace(name, { clone: options.clone });
         console.log(`Workspace '${workspace.name}' started.`);
         console.log(`  Status: ${workspace.status}`);
+        console.log(`  SSH Port: ${workspace.ports.ssh}`);
     }
     catch (err) {
         handleError(err);
@@ -219,6 +201,12 @@ program
             console.log(`  Uptime: ${formatUptime(info.uptime)}`);
             console.log(`  Workspaces: ${info.workspacesCount}`);
             console.log(`  Docker: ${info.dockerVersion}`);
+            if (info.tailscale?.running) {
+                console.log(`  Tailscale: ${info.tailscale.dnsName}`);
+                if (info.tailscale.httpsUrl) {
+                    console.log(`  HTTPS URL: ${info.tailscale.httpsUrl}`);
+                }
+            }
         }
     }
     catch (err) {
@@ -617,6 +605,42 @@ program
         process.exit(1);
     }
 });
+const workerCmd = program
+    .command('worker')
+    .description('Worker mode commands (for use inside containers)');
+workerCmd
+    .command('sessions')
+    .argument('<subcommand>', 'Subcommand: list, messages, or delete')
+    .argument('[sessionId]', 'Session ID (required for messages and delete)')
+    .description('Manage OpenCode sessions')
+    .action(async (subcommand, sessionId) => {
+    const { listOpencodeSessions, getOpencodeSessionMessages, deleteOpencodeSession } = await import('./sessions/agents/opencode-storage');
+    if (subcommand === 'list') {
+        const sessions = await listOpencodeSessions();
+        console.log(JSON.stringify(sessions));
+    }
+    else if (subcommand === 'messages') {
+        if (!sessionId) {
+            console.error('Usage: perry worker sessions messages <session_id>');
+            process.exit(1);
+        }
+        const result = await getOpencodeSessionMessages(sessionId);
+        console.log(JSON.stringify(result));
+    }
+    else if (subcommand === 'delete') {
+        if (!sessionId) {
+            console.error('Usage: perry worker sessions delete <session_id>');
+            process.exit(1);
+        }
+        const result = await deleteOpencodeSession(sessionId);
+        console.log(JSON.stringify(result));
+    }
+    else {
+        console.error(`Unknown subcommand: ${subcommand}`);
+        console.error('Available: list, messages, delete');
+        process.exit(1);
+    }
+});
 function handleError(err) {
     if (err instanceof ApiClientError) {
         console.error(`Error: ${err.message}`);

package/dist/perry-worker ADDED Viewed

Binary file

package/dist/sessions/agents/claude.js CHANGED Viewed

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

package/dist/sessions/agents/codex.js CHANGED Viewed

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

package/dist/sessions/agents/index.js CHANGED Viewed

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

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

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

package/dist/sessions/agents/opencode.js CHANGED Viewed

@@ -1,6 +1,6 @@
 export const opencodeProvider = {
     async discoverSessions(containerName, exec) {
-        const result = await exec(containerName, ['perry-session-reader', 'list'], {
+        const result = await exec(containerName, ['perry', 'worker', 'sessions', 'list'], {
             user: 'workspace',
         });
         if (result.exitCode !== 0) {
@@ -22,7 +22,7 @@ export const opencodeProvider = {
         }
     },
     async getSessionDetails(containerName, rawSession, exec) {
-        const result = await exec(containerName, ['perry-session-reader', 'messages', rawSession.id], {
+        const result = await exec(containerName, ['perry', 'worker', 'sessions', 'messages', rawSession.id], {
             user: 'workspace',
         });
         if (result.exitCode !== 0) {
@@ -50,7 +50,7 @@ export const opencodeProvider = {
         }
     },
     async getSessionMessages(containerName, sessionId, exec) {
-        const result = await exec(containerName, ['perry-session-reader', 'messages', sessionId], {
+        const result = await exec(containerName, ['perry', 'worker', 'sessions', 'messages', sessionId], {
             user: 'workspace',
         });
         if (result.exitCode !== 0) {
@@ -67,4 +67,18 @@ export const opencodeProvider = {
             return null;
         }
     },
+    async deleteSession(containerName, sessionId, exec) {
+        const result = await exec(containerName, ['perry', 'worker', 'sessions', 'delete', sessionId], {
+            user: 'workspace',
+        });
+        if (result.exitCode !== 0) {
+            return { success: false, error: result.stderr || 'Failed to delete session' };
+        }
+        try {
+            return JSON.parse(result.stdout);
+        }
+        catch {
+            return { success: false, error: 'Invalid response from worker' };
+        }
+    },
 };

package/dist/sessions/cache.js CHANGED Viewed

@@ -49,4 +49,9 @@ export class SessionsCacheManager {
         cache.recent = cache.recent.filter((s) => s.workspaceName !== workspaceName);
         await this.save();
     }
+    async removeSession(workspaceName, sessionId) {
+        const cache = await this.load();
+        cache.recent = cache.recent.filter((s) => !(s.workspaceName === workspaceName && s.sessionId === sessionId));
+        await this.save();
+    }
 }

package/dist/shared/constants.js CHANGED Viewed

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