npm - @gricha/perry - Versions diffs - 0.3.4 → 0.3.6 - Mend

@gricha/perry 0.3.4 → 0.3.6

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 (12) hide show

package/dist/agent/router.js +16 -0
package/dist/agent/run.js +2 -0
package/dist/agent/web/assets/{index-CZjSxNrg.js → index-C-xi0Vax.js} +34 -34
package/dist/agent/web/index.html +1 -1
package/dist/index.js +21 -3
package/dist/perry-worker +0 -0
package/dist/session-manager/adapters/claude.js +11 -0
package/dist/session-manager/adapters/opencode.js +131 -32
package/dist/session-manager/manager.js +19 -0
package/dist/sessions/registry.js +129 -0
package/dist/update-checker.js +5 -5
package/package.json +1 -1

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

@@ -5,7 +5,7 @@
     <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-CZjSxNrg.js"></script>
+    <script type="module" crossorigin src="/assets/index-C-xi0Vax.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-CYo-1I5o.css">
   </head>
   <body>

package/dist/index.js CHANGED Viewed

@@ -662,9 +662,24 @@ sshCmd
 program
     .command('update')
     .description('Update Perry to the latest version')
-    .action(async () => {
+    .option('-f, --force', 'Force update even if already on latest version')
+    .action(async (options) => {
+    const { fetchLatestVersion, compareVersions } = await import('./update-checker.js');
+    const currentVersion = pkg.version;
+    console.log(`Current version: ${currentVersion}`);
+    console.log('Checking for updates...');
+    const latestVersion = await fetchLatestVersion();
+    if (!latestVersion) {
+        console.error('Failed to fetch latest version. Please try again later.');
+        process.exit(1);
+    }
+    console.log(`Latest version: ${latestVersion}`);
+    if (compareVersions(currentVersion, latestVersion) <= 0 && !options.force) {
+        console.log('Already up to date.');
+        process.exit(0);
+    }
+    console.log(`Updating Perry from ${currentVersion} to ${latestVersion}...`);
     const { spawn } = await import('child_process');
-    console.log('Updating Perry...');
     const child = spawn('bash', ['-c', 'curl -fsSL https://raw.githubusercontent.com/gricha/perry/main/install.sh | bash'], {
         stdio: 'inherit',
     });
@@ -756,5 +771,8 @@ function handleError(err) {
     }
     process.exit(1);
 }
-checkForUpdates(pkg.version);
+const isWorkerCommand = process.argv[2] === 'worker';
+if (!isWorkerCommand) {
+    checkForUpdates(pkg.version);
+}
 program.parse();

package/dist/perry-worker CHANGED Viewed

Binary file

package/dist/session-manager/adapters/claude.js CHANGED Viewed

@@ -15,6 +15,7 @@ export class ClaudeCodeAdapter {
     errorCallback;
     pendingMessage = null;
     messageResolver = null;
+    currentMessageId;
     onMessage(callback) {
         this.messageCallback = callback;
     }
@@ -154,6 +155,11 @@ export class ClaudeCodeAdapter {
             return;
         }
         if (msg.type === 'assistant' && msg.message?.content) {
+            // Capture message ID from upstream when assistant message starts
+            const messageId = msg.message.id || msg.id;
+            if (messageId) {
+                this.currentMessageId = messageId;
+            }
             for (const block of msg.message.content) {
                 if (block.type === 'tool_use') {
                     this.emitMessage({
@@ -161,6 +167,7 @@ export class ClaudeCodeAdapter {
                         content: JSON.stringify(block.input, null, 2),
                         toolName: block.name,
                         toolId: block.id,
+                        messageId: this.currentMessageId,
                         timestamp,
                     });
                 }
@@ -173,6 +180,7 @@ export class ClaudeCodeAdapter {
                 this.emitMessage({
                     type: 'assistant',
                     content: delta.text,
+                    messageId: this.currentMessageId,
                     timestamp,
                 });
             }
@@ -182,13 +190,16 @@ export class ClaudeCodeAdapter {
             this.emitMessage({
                 type: 'done',
                 content: 'Response complete',
+                messageId: this.currentMessageId,
                 timestamp,
             });
+            this.currentMessageId = undefined;
         }
     }
     handleProcessExit(code) {
         this.process = null;
         this.terminal = null;
+        this.currentMessageId = undefined;
         if (this.status === 'interrupted') {
             this.emitMessage({
                 type: 'system',

package/dist/session-manager/adapters/opencode.js CHANGED Viewed

@@ -3,6 +3,9 @@ const MESSAGE_TIMEOUT_MS = 30000;
 const SSE_TIMEOUT_MS = 120000;
 const serverPorts = new Map();
 const serverStarting = new Map();
+let hostServerPort = null;
+let hostServerStarting = null;
+let hostServerProcess = null;
 async function findAvailablePort(containerName) {
     const script = `import socket; s=socket.socket(); s.bind(('', 0)); print(s.getsockname()[1]); s.close()`;
     const result = await execInContainer(containerName, ['python3', '-c', script], {
@@ -70,7 +73,9 @@ export class OpenCodeAdapter {
     model;
     status = 'idle';
     port;
+    isHost = false;
     sseProcess = null;
+    currentMessageId;
     messageCallback;
     statusCallback;
     errorCallback;
@@ -84,14 +89,17 @@ export class OpenCodeAdapter {
         this.errorCallback = callback;
     }
     async start(options) {
-        if (options.isHost) {
-            throw new Error('OpenCode adapter does not support host mode');
-        }
+        this.isHost = options.isHost;
         this.containerName = options.containerName;
         this.agentSessionId = options.agentSessionId;
         this.model = options.model;
         try {
-            this.port = await startServer(this.containerName);
+            if (this.isHost) {
+                this.port = await this.startServerHost();
+            }
+            else {
+                this.port = await startServer(this.containerName);
+            }
             this.setStatus('idle');
         }
         catch (err) {
@@ -99,8 +107,61 @@ export class OpenCodeAdapter {
             throw err;
         }
     }
+    async startServerHost() {
+        if (hostServerPort && (await this.isServerRunningHost(hostServerPort))) {
+            return hostServerPort;
+        }
+        if (hostServerStarting) {
+            return hostServerStarting;
+        }
+        const startPromise = (async () => {
+            const port = await this.findAvailablePortHost();
+            console.log(`[opencode] Starting server on port ${port} on host`);
+            hostServerProcess = Bun.spawn(['opencode', 'serve', '--port', String(port), '--hostname', '127.0.0.1'], {
+                stdin: 'ignore',
+                stdout: 'pipe',
+                stderr: 'pipe',
+            });
+            for (let i = 0; i < 30; i++) {
+                await new Promise((resolve) => setTimeout(resolve, 500));
+                if (await this.isServerRunningHost(port)) {
+                    console.log(`[opencode] Server ready on port ${port}`);
+                    hostServerPort = port;
+                    hostServerStarting = null;
+                    return port;
+                }
+            }
+            hostServerStarting = null;
+            if (hostServerProcess) {
+                hostServerProcess.kill();
+                await hostServerProcess.exited;
+                hostServerProcess = null;
+            }
+            throw new Error('Failed to start OpenCode server on host');
+        })();
+        hostServerStarting = startPromise;
+        return startPromise;
+    }
+    async findAvailablePortHost() {
+        const server = Bun.serve({
+            port: 0,
+            fetch: () => new Response(''),
+        });
+        const port = server.port;
+        server.stop();
+        return port;
+    }
+    async isServerRunningHost(port) {
+        try {
+            const response = await fetch(`http://localhost:${port}/session`, { method: 'GET' });
+            return response.ok;
+        }
+        catch {
+            return false;
+        }
+    }
     async sendMessage(message) {
-        if (!this.containerName || !this.port) {
+        if (!this.port) {
             const err = new Error('Adapter not started');
             this.emitError(err);
             throw err;
@@ -120,10 +181,12 @@ export class OpenCodeAdapter {
             this.emit({ type: 'system', content: 'Processing...' });
             await this.sendAndStream(baseUrl, message);
             this.setStatus('idle');
-            this.emit({ type: 'done', content: 'Response complete' });
+            this.emit({ type: 'done', content: 'Response complete', messageId: this.currentMessageId });
+            this.currentMessageId = undefined;
         }
         catch (err) {
             this.cleanup();
+            this.currentMessageId = undefined;
             this.setStatus('error');
             this.emitError(err);
             this.emit({ type: 'error', content: err.message });
@@ -131,7 +194,20 @@ export class OpenCodeAdapter {
         }
     }
     async createSession(baseUrl) {
-        const payload = this.model ? JSON.stringify({ model: this.model }) : '{}';
+        const payload = this.model ? { model: this.model } : {};
+        if (this.isHost) {
+            const response = await fetch(`${baseUrl}/session`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(payload),
+                signal: AbortSignal.timeout(MESSAGE_TIMEOUT_MS),
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to create session: ${response.statusText}`);
+            }
+            const session = await response.json();
+            return session.id;
+        }
         const result = await execInContainer(this.containerName, [
             'curl',
             '-s',
@@ -144,7 +220,7 @@ export class OpenCodeAdapter {
             '-H',
             'Content-Type: application/json',
             '-d',
-            payload,
+            JSON.stringify(payload),
         ], { user: 'workspace' });
         if (result.exitCode !== 0) {
             throw new Error(`Failed to create session: ${result.stderr || 'Unknown error'}`);
@@ -155,23 +231,36 @@ export class OpenCodeAdapter {
     async sendAndStream(baseUrl, message) {
         const sseReady = this.startSSEStream();
         await new Promise((resolve) => setTimeout(resolve, 100));
-        const payload = JSON.stringify({ parts: [{ type: 'text', text: message }] });
-        const result = await execInContainer(this.containerName, [
-            'curl',
-            '-s',
-            '-f',
-            '--max-time',
-            String(MESSAGE_TIMEOUT_MS / 1000),
-            '-X',
-            'POST',
-            `${baseUrl}/session/${this.agentSessionId}/message`,
-            '-H',
-            'Content-Type: application/json',
-            '-d',
-            payload,
-        ], { user: 'workspace' });
-        if (result.exitCode !== 0) {
-            throw new Error(`Failed to send message: ${result.stderr || 'Connection failed'}`);
+        const payload = { parts: [{ type: 'text', text: message }] };
+        if (this.isHost) {
+            const response = await fetch(`${baseUrl}/session/${this.agentSessionId}/message`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(payload),
+                signal: AbortSignal.timeout(MESSAGE_TIMEOUT_MS),
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to send message: ${response.statusText}`);
+            }
+        }
+        else {
+            const result = await execInContainer(this.containerName, [
+                'curl',
+                '-s',
+                '-f',
+                '--max-time',
+                String(MESSAGE_TIMEOUT_MS / 1000),
+                '-X',
+                'POST',
+                `${baseUrl}/session/${this.agentSessionId}/message`,
+                '-H',
+                'Content-Type: application/json',
+                '-d',
+                JSON.stringify(payload),
+            ], { user: 'workspace' });
+            if (result.exitCode !== 0) {
+                throw new Error(`Failed to send message: ${result.stderr || 'Connection failed'}`);
+            }
         }
         await sseReady;
     }
@@ -180,18 +269,18 @@ export class OpenCodeAdapter {
             const seenTools = new Set();
             let resolved = false;
             let receivedIdle = false;
-            const proc = Bun.spawn([
-                'docker',
-                'exec',
-                '-i',
-                this.containerName,
+            const curlArgs = [
                 'curl',
                 '-s',
                 '-N',
                 '--max-time',
                 String(SSE_TIMEOUT_MS / 1000),
                 `http://localhost:${this.port}/event`,
-            ], { stdin: 'ignore', stdout: 'pipe', stderr: 'pipe' });
+            ];
+            const spawnArgs = this.isHost
+                ? curlArgs
+                : ['docker', 'exec', '-i', this.containerName, ...curlArgs];
+            const proc = Bun.spawn(spawnArgs, { stdin: 'ignore', stdout: 'pipe', stderr: 'pipe' });
             this.sseProcess = proc;
             const decoder = new TextDecoder();
             let buffer = '';
@@ -236,8 +325,15 @@ export class OpenCodeAdapter {
                                 }
                                 if (event.type === 'message.part.updated' && event.properties.part) {
                                     const part = event.properties.part;
+                                    if (part.messageID) {
+                                        this.currentMessageId = part.messageID;
+                                    }
                                     if (part.type === 'text' && event.properties.delta) {
-                                        this.emit({ type: 'assistant', content: event.properties.delta });
+                                        this.emit({
+                                            type: 'assistant',
+                                            content: event.properties.delta,
+                                            messageId: this.currentMessageId,
+                                        });
                                     }
                                     else if (part.type === 'tool' && part.tool && !seenTools.has(part.id)) {
                                         seenTools.add(part.id);
@@ -246,12 +342,14 @@ export class OpenCodeAdapter {
                                             content: JSON.stringify(part.state?.input, null, 2),
                                             toolName: part.state?.title || part.tool,
                                             toolId: part.id,
+                                            messageId: this.currentMessageId,
                                         });
                                         if (part.state?.status === 'completed' && part.state?.output) {
                                             this.emit({
                                                 type: 'tool_result',
                                                 content: part.state.output,
                                                 toolId: part.id,
+                                                messageId: this.currentMessageId,
                                             });
                                         }
                                     }
@@ -290,6 +388,7 @@ export class OpenCodeAdapter {
     }
     async interrupt() {
         this.cleanup();
+        this.currentMessageId = undefined;
         if (this.status === 'running') {
             this.setStatus('interrupted');
             this.emit({ type: 'system', content: 'Interrupted' });

package/dist/session-manager/manager.js CHANGED Viewed

@@ -3,10 +3,15 @@ import { ClaudeCodeAdapter } from './adapters/claude';
 import { OpenCodeAdapter } from './adapters/opencode';
 import { getContainerName } from '../docker';
 import { HOST_WORKSPACE_NAME } from '../shared/client-types';
+import * as registry from '../sessions/registry';
 const DEFAULT_BUFFER_SIZE = 1000;
 export class SessionManager {
     sessions = new Map();
     clientIdCounter = 0;
+    stateDir = null;
+    init(stateDir) {
+        this.stateDir = stateDir;
+    }
     generateSessionId() {
         return `session-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
     }
@@ -69,6 +74,15 @@ export class SessionManager {
             isHost,
         });
         this.sessions.set(sessionId, session);
+        if (this.stateDir) {
+            await registry.createSession(this.stateDir, {
+                perrySessionId: sessionId,
+                workspaceName: options.workspaceName,
+                agentType: options.agentType,
+                agentSessionId: options.agentSessionId ?? null,
+                projectPath: options.projectPath ?? null,
+            });
+        }
         return sessionId;
     }
     handleAdapterMessage(sessionId, message) {
@@ -101,6 +115,11 @@ export class SessionManager {
         const currentAgentSessionId = session.adapter.getAgentSessionId();
         if (currentAgentSessionId !== undefined && previousAgentSessionId !== currentAgentSessionId) {
             session.info.agentSessionId = currentAgentSessionId;
+            if (this.stateDir) {
+                registry.linkAgentSession(this.stateDir, sessionId, currentAgentSessionId).catch((err) => {
+                    this.handleAdapterError(sessionId, new Error(`Failed to link agent session: ${err.message}`));
+                });
+            }
             const updateMessage = {
                 type: 'system',
                 content: JSON.stringify({ agentSessionId: currentAgentSessionId }),

package/dist/sessions/registry.js ADDED Viewed

@@ -0,0 +1,129 @@
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { join, dirname } from 'path';
+import lockfile from 'proper-lockfile';
+function getStorePath(stateDir) {
+    return join(stateDir, 'session-registry.json');
+}
+function getLockPath(stateDir) {
+    return join(stateDir, '.session-registry.lock');
+}
+async function ensureLockfile(stateDir) {
+    const lockPath = getLockPath(stateDir);
+    try {
+        await mkdir(dirname(lockPath), { recursive: true });
+        await writeFile(lockPath, '', { flag: 'wx' });
+    }
+    catch (err) {
+        if (err.code !== 'EEXIST') {
+            throw err;
+        }
+    }
+}
+async function withLock(stateDir, fn) {
+    await ensureLockfile(stateDir);
+    const lockPath = getLockPath(stateDir);
+    let release;
+    try {
+        release = await lockfile.lock(lockPath, {
+            retries: { retries: 10, minTimeout: 50, maxTimeout: 500 },
+        });
+        return await fn();
+    }
+    finally {
+        if (release) {
+            await release();
+        }
+    }
+}
+async function loadRegistry(stateDir) {
+    const storePath = getStorePath(stateDir);
+    try {
+        const content = await readFile(storePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return { version: 1, sessions: {} };
+    }
+}
+async function saveRegistry(stateDir, registry) {
+    const storePath = getStorePath(stateDir);
+    await mkdir(dirname(storePath), { recursive: true });
+    await writeFile(storePath, JSON.stringify(registry, null, 2));
+}
+/**
+ * Create a new session record. Called when first message is sent.
+ * agentSessionId will be null until agent responds.
+ */
+export async function createSession(stateDir, session) {
+    return withLock(stateDir, async () => {
+        const registry = await loadRegistry(stateDir);
+        const now = new Date().toISOString();
+        const record = {
+            perrySessionId: session.perrySessionId,
+            workspaceName: session.workspaceName,
+            agentType: session.agentType,
+            agentSessionId: session.agentSessionId ?? null,
+            projectPath: session.projectPath ?? null,
+            createdAt: now,
+            lastActivity: now,
+        };
+        registry.sessions[session.perrySessionId] = record;
+        await saveRegistry(stateDir, registry);
+        return record;
+    });
+}
+/**
+ * Link an agent session ID to an existing Perry session.
+ * Called when agent responds and provides its session ID.
+ */
+export async function linkAgentSession(stateDir, perrySessionId, agentSessionId) {
+    return withLock(stateDir, async () => {
+        const registry = await loadRegistry(stateDir);
+        const record = registry.sessions[perrySessionId];
+        if (!record) {
+            return null;
+        }
+        record.agentSessionId = agentSessionId;
+        record.lastActivity = new Date().toISOString();
+        await saveRegistry(stateDir, registry);
+        return record;
+    });
+}
+/**
+ * Get all sessions for a workspace.
+ */
+export async function getSessionsForWorkspace(stateDir, workspaceName) {
+    const registry = await loadRegistry(stateDir);
+    return Object.values(registry.sessions)
+        .filter((record) => record.workspaceName === workspaceName)
+        .sort((a, b) => new Date(b.lastActivity).getTime() - new Date(a.lastActivity).getTime());
+}
+/**
+ * Import an external session (discovered from agent storage).
+ * Creates a Perry session record for a session that wasn't started through Perry.
+ */
+export async function importExternalSession(stateDir, session) {
+    return withLock(stateDir, async () => {
+        const registry = await loadRegistry(stateDir);
+        // Check if already imported (inside lock to prevent race)
+        for (const record of Object.values(registry.sessions)) {
+            if (record.agentType === session.agentType &&
+                record.agentSessionId === session.agentSessionId) {
+                return record;
+            }
+        }
+        const now = new Date().toISOString();
+        const record = {
+            perrySessionId: session.perrySessionId,
+            workspaceName: session.workspaceName,
+            agentType: session.agentType,
+            agentSessionId: session.agentSessionId,
+            projectPath: session.projectPath ?? null,
+            createdAt: session.createdAt ?? now,
+            lastActivity: session.lastActivity ?? now,
+        };
+        registry.sessions[session.perrySessionId] = record;
+        await saveRegistry(stateDir, registry);
+        return record;
+    });
+}

package/dist/update-checker.js CHANGED Viewed

@@ -27,7 +27,7 @@ async function writeCache(cache) {
         // Ignore cache write errors
     }
 }
-async function fetchLatestVersion() {
+export async function fetchLatestVersion() {
     try {
         const response = await fetch(`https://api.github.com/repos/${GITHUB_REPO}/releases/latest`, {
             signal: AbortSignal.timeout(3000),
@@ -46,7 +46,7 @@ async function fetchLatestVersion() {
         return null;
     }
 }
-function compareVersions(current, latest) {
+export function compareVersions(current, latest) {
     const currentParts = current.split('.').map(Number);
     const latestParts = latest.split('.').map(Number);
     for (let i = 0; i < Math.max(currentParts.length, latestParts.length); i++) {
@@ -72,9 +72,9 @@ export async function checkForUpdates(currentVersion) {
             await writeCache({ lastCheck: now, latestVersion });
         }
         if (latestVersion && compareVersions(currentVersion, latestVersion) > 0) {
-            console.log('');
-            console.log(`\x1b[33mUpdate available: \x1b[90m${currentVersion}\x1b[0m → \x1b[32m${latestVersion}\x1b[0m  \x1b[33mRun: \x1b[36mperry update\x1b[0m`);
-            console.log('');
+            console.error('');
+            console.error(`\x1b[33mUpdate available: \x1b[90m${currentVersion}\x1b[0m → \x1b[32m${latestVersion}\x1b[0m  \x1b[33mRun: \x1b[36mperry update\x1b[0m`);
+            console.error('');
         }
     }
     catch {

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@gricha/perry",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "description": "Self-contained CLI for spinning up Docker-in-Docker development environments with SSH and proxy helpers.",
   "type": "module",
   "bin": {