@gricha/perry 0.3.18 → 0.3.19

package/dist/client/api.js

@@ -174,7 +174,7 @@ export class ApiClient {
         return new ApiClientError('Unknown error', 0, 'UNKNOWN');
     }
 }
-export function createApiClient(worker, port) {
+export function createApiClient(worker, port, timeoutMs) {
     let baseUrl;
     if (worker.includes('://')) {
         baseUrl = worker;
@@ -186,5 +186,5 @@ export function createApiClient(worker, port) {
         const effectivePort = port || DEFAULT_AGENT_PORT;
         baseUrl = `http://${worker}:${effectivePort}`;
     }
-    return new ApiClient({ baseUrl });
+    return new ApiClient({ baseUrl, timeout: timeoutMs });
 }

package/dist/index.js

@@ -118,9 +118,9 @@ async function checkLocalAgent() {
         return false;
     }
 }
-async function getClient() {
+async function getClient(timeoutMs) {
     const worker = await getWorkerWithFallback();
-    return createApiClient(worker);
+    return createApiClient(worker, undefined, timeoutMs);
 }
 async function getWorkerWithFallback() {
     let worker = await getWorker();
@@ -284,7 +284,7 @@ program
     .option('-a, --all', 'Sync all running workspaces')
     .action(async (name, options) => {
     try {
-        const client = await getClient();
+        const client = await getClient(5 * 60 * 1000);
         if (options.all) {
             console.log('Syncing all running workspaces...');
             const result = await client.syncAllWorkspaces();
@@ -846,7 +846,7 @@ program
     try {
         console.log('');
         console.log('Syncing all running workspaces...');
-        const client = createApiClient(`localhost:${agentPort}`);
+        const client = createApiClient(`localhost:${agentPort}`, undefined, 5 * 60 * 1000);
         const result = await client.syncAllWorkspaces();
         if (result.results.length === 0) {
             console.log('No running workspaces to sync.');

package/dist/worker/client.js

@@ -31,7 +31,11 @@ async function isWorkerRunning(ip) {
     }
 }
 async function startWorkerInContainer(containerName) {
-    await execInContainer(containerName, ['sh', '-c', 'nohup perry worker serve > /tmp/perry-worker.log 2>&1 &'], { user: 'workspace' });
+    await execInContainer(containerName, [
+        'sh',
+        '-c',
+        "nohup sh -c 'if [ -x /usr/local/bin/perry ]; then exec /usr/local/bin/perry worker serve; else exec perry worker serve; fi' > /tmp/perry-worker.log 2>&1 &",
+    ], { user: 'workspace' });
 }
 async function ensureWorkerRunning(containerName) {
     const ip = await getContainerIp(containerName);

package/dist/workspace/manager.js

@@ -217,35 +217,38 @@ export class WorkspaceManager {
             }
         }
     }
-    async setupWorkspaceCredentials(containerName, workspaceName) {
+    async setupWorkspaceCredentials(containerName, workspaceName, options) {
         await this.copyGitConfig(containerName);
         await this.copyCredentialFiles(containerName);
         await this.syncEnvironmentFile(containerName);
         await syncAllAgents(containerName, this.config);
         await this.copyPerryWorker(containerName);
-        await this.startWorkerServer(containerName);
+        await this.ensurePerryOnPath(containerName);
+        await this.startWorkerServer(containerName, options);
         if (workspaceName) {
             await this.setupSSHKeys(containerName, workspaceName);
         }
     }
     async copyPerryWorker(containerName) {
         const installedPath = path.join(os.homedir(), '.perry', 'bin', 'perry');
+        const cwdDistPath = path.join(process.cwd(), 'dist', 'perry-worker');
         const distDir = path.dirname(new URL(import.meta.url).pathname);
         const distPath = path.join(distDir, '..', 'perry-worker');
-        let workerBinaryPath = distPath;
-        try {
-            await fs.access(installedPath);
-            workerBinaryPath = installedPath;
-        }
-        catch {
+        let workerBinaryPath = null;
+        for (const candidate of [installedPath, cwdDistPath, distPath]) {
             try {
-                await fs.access(distPath);
+                await fs.access(candidate);
+                workerBinaryPath = candidate;
+                break;
             }
             catch {
-                console.warn(`[sync] perry binary not found at ${installedPath} or ${distPath}, session discovery may not work`);
-                return;
+                // Try next
             }
         }
+        if (!workerBinaryPath) {
+            console.warn(`[sync] perry binary not found at ${installedPath}, ${cwdDistPath}, or ${distPath}, session discovery may not work`);
+            return;
+        }
         const destPath = '/usr/local/bin/perry';
         await docker.copyToContainer(containerName, workerBinaryPath, destPath);
         await docker.execInContainer(containerName, ['chown', 'root:root', destPath], {
@@ -255,6 +258,13 @@ export class WorkspaceManager {
             user: 'root',
         });
     }
+    async ensurePerryOnPath(containerName) {
+        await docker.execInContainer(containerName, [
+            'sh',
+            '-c',
+            'if [ -x /usr/local/bin/perry ]; then mkdir -p /home/workspace/.local/bin && ln -sf /usr/local/bin/perry /home/workspace/.local/bin/perry; fi',
+        ], { user: 'workspace' });
+    }
     async updateWorkerBinary(name) {
         const workspace = await this.state.getWorkspace(name);
         if (!workspace) {
@@ -267,27 +277,42 @@ export class WorkspaceManager {
         }
         await docker.execInContainer(containerName, ['sh', '-c', 'pkill -f "perry worker serve" || true'], { user: 'workspace' });
         await this.copyPerryWorker(containerName);
-        await this.startWorkerServer(containerName);
+        await this.startWorkerServer(containerName, { strictWorker: true });
     }
-    async startWorkerServer(containerName) {
+    async startWorkerServer(containerName, options) {
         const WORKER_PORT = 7392;
         const ip = await docker.getContainerIp(containerName);
         if (!ip) {
             console.warn(`[sync] Could not get container IP for ${containerName}, skipping worker server`);
             return;
         }
+        const desiredVersion = pkg.version;
+        const hasSyncedPerry = (await docker.execInContainer(containerName, ['sh', '-c', 'test -x /usr/local/bin/perry'], {
+            user: 'workspace',
+        })).exitCode === 0;
         try {
             const healthResponse = await fetch(`http://${ip}:${WORKER_PORT}/health`, {
                 signal: AbortSignal.timeout(1000),
             });
             if (healthResponse.ok) {
-                return;
+                if (!hasSyncedPerry) {
+                    return;
+                }
+                const health = (await healthResponse.json().catch(() => null));
+                if (health?.version === desiredVersion) {
+                    return;
+                }
+                await docker.execInContainer(containerName, ['sh', '-c', 'pkill -f "perry worker serve" || true'], { user: 'workspace' });
             }
         }
         catch {
             // Worker not running, start it
         }
-        await docker.execInContainer(containerName, ['sh', '-c', 'nohup perry worker serve > /tmp/perry-worker.log 2>&1 &'], { user: 'workspace' });
+        await docker.execInContainer(containerName, [
+            'sh',
+            '-c',
+            "nohup sh -c 'if [ -x /usr/local/bin/perry ]; then exec /usr/local/bin/perry worker serve; else exec perry worker serve; fi' > /tmp/perry-worker.log 2>&1 &",
+        ], { user: 'workspace' });
         const deadline = Date.now() + 10000;
         while (Date.now() < deadline) {
             await new Promise((r) => setTimeout(r, 200));
@@ -295,7 +320,14 @@ export class WorkspaceManager {
                 const response = await fetch(`http://${ip}:${WORKER_PORT}/health`, {
                     signal: AbortSignal.timeout(500),
                 });
-                if (response.ok) {
+                if (!response.ok) {
+                    continue;
+                }
+                if (!hasSyncedPerry) {
+                    return;
+                }
+                const health = (await response.json().catch(() => null));
+                if (health?.version === desiredVersion) {
                     return;
                 }
             }
@@ -303,6 +335,9 @@ export class WorkspaceManager {
                 // Not ready yet
             }
         }
+        if (options.strictWorker && hasSyncedPerry) {
+            throw new Error(`[sync] Worker server failed to start in ${containerName}. Check /tmp/perry-worker.log`);
+        }
         console.warn(`[sync] Worker server failed to start in ${containerName}`);
     }
     async runUserScripts(containerName) {
@@ -473,7 +508,7 @@ export class WorkspaceManager {
             await this.state.setWorkspace(workspace);
             await docker.startContainer(containerName);
             await docker.waitForContainerReady(containerName);
-            await this.setupWorkspaceCredentials(containerName, name);
+            await this.setupWorkspaceCredentials(containerName, name, { strictWorker: false });
             workspace.status = 'running';
             await this.state.setWorkspace(workspace);
             await this.runUserScripts(containerName);
@@ -551,7 +586,7 @@ export class WorkspaceManager {
             }
             await docker.startContainer(containerName);
             await docker.waitForContainerReady(containerName);
-            await this.setupWorkspaceCredentials(containerName, name);
+            await this.setupWorkspaceCredentials(containerName, name, { strictWorker: false });
             workspace.status = 'running';
             workspace.lastUsed = new Date().toISOString();
             await this.state.setWorkspace(workspace);
@@ -630,7 +665,7 @@ export class WorkspaceManager {
         if (!running) {
             throw new Error(`Workspace '${name}' is not running`);
         }
-        await this.setupWorkspaceCredentials(containerName, name);
+        await this.setupWorkspaceCredentials(containerName, name, { strictWorker: true });
     }
     async setPortForwards(name, forwards) {
         const workspace = await this.state.getWorkspace(name);
@@ -722,7 +757,7 @@ export class WorkspaceManager {
             await this.state.setWorkspace(workspace);
             await docker.startContainer(cloneContainerName);
             await docker.waitForContainerReady(cloneContainerName);
-            await this.setupWorkspaceCredentials(cloneContainerName, cloneName);
+            await this.setupWorkspaceCredentials(cloneContainerName, cloneName, { strictWorker: false });
             workspace.status = 'running';
             await this.state.setWorkspace(workspace);
             await this.runUserScripts(cloneContainerName);

package/package.json

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