@gricha/perry 0.2.2 → 0.2.4

package/dist/index.js

@@ -177,6 +177,23 @@ program
         handleError(err);
     }
 });
+program
+    .command('clone <source> <clone-name>')
+    .description('Clone an existing workspace')
+    .action(async (source, cloneName) => {
+    try {
+        const client = await getClient();
+        console.log(`Cloning workspace '${source}' to '${cloneName}'...`);
+        console.log('This may take a while for large workspaces.');
+        const workspace = await client.cloneWorkspace(source, cloneName);
+        console.log(`Workspace '${cloneName}' created.`);
+        console.log(`  Status: ${workspace.status}`);
+        console.log(`  SSH Port: ${workspace.ports.ssh}`);
+    }
+    catch (err) {
+        handleError(err);
+    }
+});
 program
     .command('info [name]')
     .description('Show workspace or agent info')
@@ -288,15 +305,21 @@ program
             console.error(`Workspace '${name}' is not running (status: ${workspace.status})`);
             process.exit(1);
         }
+        let effectivePorts = ports;
         if (ports.length === 0) {
-            console.log(`Workspace '${name}' is running.`);
-            console.log('');
-            console.log('Usage: perry proxy <name> <port> [<port>...]');
-            console.log('  Examples:');
-            console.log('    perry proxy alpha 3000         # Forward port 3000');
-            console.log('    perry proxy alpha 8080:3000    # Forward local 8080 to remote 3000');
-            console.log('    perry proxy alpha 3000 5173    # Forward multiple ports');
-            return;
+            const configuredForwards = workspace.ports.forwards || [];
+            if (configuredForwards.length === 0) {
+                console.log(`No ports configured for workspace '${name}'.`);
+                console.log('');
+                console.log('Configure ports with: perry ports <name> <port> [<port>...]');
+                console.log('  Example: perry ports ' + name + ' 3000 5173');
+                console.log('');
+                console.log('Or specify ports directly: perry proxy <name> <port> [<port>...]');
+                console.log('  Example: perry proxy ' + name + ' 3000 5173');
+                return;
+            }
+            effectivePorts = configuredForwards.map((p) => String(p));
+            console.log(`Using configured ports: ${configuredForwards.join(', ')}`);
         }
         if (isLocalWorker(worker)) {
             const containerName = getContainerName(name);
@@ -305,7 +328,7 @@ program
                 console.error(`Could not get IP for container '${containerName}'`);
                 process.exit(1);
             }
-            const forwards = ports.map(parseDockerPortForward);
+            const forwards = effectivePorts.map(parseDockerPortForward);
             console.log(`Forwarding ports: ${formatDockerPortForwards(forwards)}`);
             console.log(`Container IP: ${containerIp}`);
             console.log('Press Ctrl+C to stop.');
@@ -330,7 +353,7 @@ program
             await new Promise(() => { });
         }
         else {
-            const forwards = ports.map(parsePortForward);
+            const forwards = effectivePorts.map(parsePortForward);
             console.log(`Forwarding ports: ${formatPortForwards(forwards)}`);
             console.log('Press Ctrl+C to stop.');
             console.log('');
@@ -354,6 +377,47 @@ program
         handleError(err);
     }
 });
+program
+    .command('ports <name> [ports...]')
+    .description('Configure ports to forward for a workspace')
+    .action(async (name, ports) => {
+    try {
+        const client = await getClient();
+        const workspace = await client.getWorkspace(name);
+        if (!workspace) {
+            console.error(`Workspace '${name}' not found`);
+            process.exit(1);
+        }
+        if (ports.length === 0) {
+            const currentPorts = workspace.ports.forwards || [];
+            if (currentPorts.length === 0) {
+                console.log(`No ports configured for workspace '${name}'.`);
+                console.log('');
+                console.log('Usage: perry ports <name> <port> [<port>...]');
+                console.log('  Example: perry ports ' + name + ' 3000 5173 8080');
+            }
+            else {
+                console.log(`Ports configured for '${name}': ${currentPorts.join(', ')}`);
+            }
+            return;
+        }
+        const portNumbers = ports.map((p) => {
+            const num = parseInt(p, 10);
+            if (isNaN(num) || num < 1 || num > 65535) {
+                console.error(`Invalid port number: ${p}`);
+                process.exit(1);
+            }
+            return num;
+        });
+        await client.setPortForwards(name, portNumbers);
+        console.log(`Ports configured for '${name}': ${portNumbers.join(', ')}`);
+        console.log('');
+        console.log(`Run 'perry proxy ${name}' to start forwarding.`);
+    }
+    catch (err) {
+        handleError(err);
+    }
+});
 const configCmd = program.command('config').description('Manage configuration');
 configCmd
     .command('show')
@@ -400,8 +464,15 @@ configCmd
     for (const [dest, src] of Object.entries(config.credentials.files)) {
         console.log(`    - ${dest} <- ${src}`);
     }
-    if (config.scripts.post_start) {
-        console.log(`  Post-start Script: ${config.scripts.post_start}`);
+    const scripts = config.scripts.post_start;
+    if (scripts && scripts.length > 0) {
+        console.log(`  Post-start Scripts: ${scripts.length}`);
+        for (const script of scripts) {
+            console.log(`    - ${script}`);
+        }
+    }
+    if (config.scripts.fail_on_error) {
+        console.log(`  Scripts Fail on Error: enabled`);
     }
 });
 const sshCmd = program.command('ssh').description('Manage SSH keys for workspaces');

package/dist/shared/constants.js

@@ -1,4 +1,5 @@
 export const DEFAULT_AGENT_PORT = 7391;
+export const DEFAULT_CLAUDE_MODEL = 'sonnet';
 export const SSH_PORT_RANGE_START = 2200;
 export const SSH_PORT_RANGE_END = 2400;
 export const WORKSPACE_IMAGE_LOCAL = 'perry:latest';

package/dist/shared/types.js

@@ -1,4 +1,3 @@
-export const HOST_WORKSPACE_NAME = '@host';
 export const DEFAULT_CONFIG_DIR = process.env.PERRY_CONFIG_DIR || `${process.env.HOME}/.config/perry`;
 export const STATE_FILE = 'state.json';
 export const CONFIG_FILE = 'config.json';

package/dist/terminal/websocket.js

@@ -3,7 +3,7 @@ import { BaseWebSocketServer, safeSend } from '../shared/base-websocket';
 import { createTerminalSession } from './handler';
 import { createHostTerminalSession } from './host-handler';
 import { isControlMessage } from './types';
-import { HOST_WORKSPACE_NAME } from '../shared/types';
+import { HOST_WORKSPACE_NAME } from '../shared/client-types';
 export class TerminalWebSocketServer extends BaseWebSocketServer {
     getContainerName;
     isHostAccessAllowed;

package/dist/workspace/manager.js

@@ -9,6 +9,7 @@ import * as docker from '../docker';
 import { getContainerName } from '../docker';
 import { VOLUME_PREFIX, WORKSPACE_IMAGE_LOCAL, WORKSPACE_IMAGE_REGISTRY, SSH_PORT_RANGE_START, SSH_PORT_RANGE_END, } from '../shared/constants';
 import { collectAuthorizedKeys, collectCopyKeys } from '../ssh/sync';
+import { syncAllAgents } from '../agents';
 async function findAvailablePort(start, end) {
     for (let port = start; port <= end; port++) {
         const available = await new Promise((resolve) => {
@@ -127,97 +128,6 @@ export class WorkspaceManager {
             });
         }
     }
-    async setupClaudeCodeConfig(containerName) {
-        const localClaudeCredentials = expandPath('~/.claude/.credentials.json');
-        const configContent = JSON.stringify({ hasCompletedOnboarding: true });
-        const tempFile = path.join(os.tmpdir(), `ws-claude-config-${Date.now()}.json`);
-        try {
-            await fs.writeFile(tempFile, configContent);
-            await docker.copyToContainer(containerName, tempFile, '/home/workspace/.claude.json');
-            await docker.execInContainer(containerName, ['chown', 'workspace:workspace', '/home/workspace/.claude.json'], { user: 'root' });
-            await docker.execInContainer(containerName, ['chmod', '644', '/home/workspace/.claude.json'], { user: 'workspace' });
-        }
-        finally {
-            await fs.unlink(tempFile).catch(() => { });
-        }
-        try {
-            await fs.access(localClaudeCredentials);
-            await docker.execInContainer(containerName, ['mkdir', '-p', '/home/workspace/.claude'], {
-                user: 'workspace',
-            });
-            await copyCredentialToContainer({
-                source: '~/.claude/.credentials.json',
-                dest: '/home/workspace/.claude/.credentials.json',
-                containerName,
-                filePermissions: '600',
-                tempPrefix: 'ws-claude-creds',
-            });
-        }
-        catch {
-            // No credentials file - that's OK, user may use oauth_token env var instead
-        }
-    }
-    async copyCodexCredentials(containerName) {
-        const codexDir = expandPath('~/.codex');
-        try {
-            await fs.access(codexDir);
-        }
-        catch {
-            return;
-        }
-        await docker.execInContainer(containerName, ['mkdir', '-p', '/home/workspace/.codex'], {
-            user: 'workspace',
-        });
-        await copyCredentialToContainer({
-            source: '~/.codex/auth.json',
-            dest: '/home/workspace/.codex/auth.json',
-            containerName,
-            filePermissions: '600',
-            tempPrefix: 'ws-codex-auth',
-        });
-        await copyCredentialToContainer({
-            source: '~/.codex/config.toml',
-            dest: '/home/workspace/.codex/config.toml',
-            containerName,
-            filePermissions: '600',
-            tempPrefix: 'ws-codex-config',
-        });
-    }
-    async setupOpencodeConfig(containerName) {
-        const zenToken = this.config.agents?.opencode?.zen_token;
-        if (!zenToken) {
-            return;
-        }
-        const config = {
-            provider: {
-                opencode: {
-                    options: {
-                        apiKey: zenToken,
-                    },
-                },
-            },
-            model: 'opencode/claude-sonnet-4',
-        };
-        const configJson = JSON.stringify(config, null, 2);
-        const tempFile = `/tmp/ws-opencode-config-${Date.now()}.json`;
-        await fs.writeFile(tempFile, configJson, 'utf-8');
-        try {
-            await docker.execInContainer(containerName, ['mkdir', '-p', '/home/workspace/.config/opencode'], {
-                user: 'workspace',
-            });
-            await docker.copyToContainer(containerName, tempFile, '/home/workspace/.config/opencode/opencode.json');
-            await docker.execInContainer(containerName, ['chown', 'workspace:workspace', '/home/workspace/.config/opencode/opencode.json'], { user: 'root' });
-            await docker.execInContainer(containerName, ['chmod', '600', '/home/workspace/.config/opencode/opencode.json'], { user: 'workspace' });
-        }
-        finally {
-            try {
-                await fs.unlink(tempFile);
-            }
-            catch {
-                // Ignore cleanup errors
-            }
-        }
-    }
     async copyGitConfig(containerName) {
         await copyCredentialToContainer({
             source: '~/.gitconfig',
@@ -279,9 +189,7 @@ export class WorkspaceManager {
     async setupWorkspaceCredentials(containerName, workspaceName) {
         await this.copyGitConfig(containerName);
         await this.copyCredentialFiles(containerName);
-        await this.setupClaudeCodeConfig(containerName);
-        await this.copyCodexCredentials(containerName);
-        await this.setupOpencodeConfig(containerName);
+        await syncAllAgents(containerName, this.config);
         await this.copyPerryWorker(containerName);
         if (workspaceName) {
             await this.setupSSHKeys(containerName, workspaceName);
@@ -306,30 +214,70 @@ export class WorkspaceManager {
             user: 'root',
         });
     }
-    async runPostStartScript(containerName) {
-        const scriptPath = this.config.scripts.post_start;
-        if (!scriptPath) {
+    async runUserScripts(containerName) {
+        const scriptPaths = this.config.scripts.post_start;
+        if (!scriptPaths || scriptPaths.length === 0) {
             return;
         }
-        const expandedPath = expandPath(scriptPath);
+        const failOnError = this.config.scripts.fail_on_error ?? false;
+        for (const scriptPath of scriptPaths) {
+            const expandedPath = expandPath(scriptPath);
+            try {
+                const stat = await fs.stat(expandedPath);
+                if (stat.isDirectory()) {
+                    await this.runScriptsFromDirectory(containerName, expandedPath, failOnError);
+                }
+                else if (stat.isFile()) {
+                    await this.runSingleScript(containerName, expandedPath, failOnError);
+                }
+            }
+            catch (err) {
+                if (err.code === 'ENOENT') {
+                    continue;
+                }
+                console.warn(`Error accessing script path ${expandedPath}:`, err);
+                if (failOnError) {
+                    throw err;
+                }
+            }
+        }
+    }
+    async runScriptsFromDirectory(containerName, dirPath, failOnError) {
+        const entries = await fs.readdir(dirPath, { withFileTypes: true });
+        const scripts = entries
+            .filter((e) => e.isFile() && e.name.endsWith('.sh'))
+            .map((e) => e.name)
+            .sort();
+        for (const scriptName of scripts) {
+            const scriptPath = path.join(dirPath, scriptName);
+            await this.runSingleScript(containerName, scriptPath, failOnError);
+        }
+    }
+    async runSingleScript(containerName, scriptPath, failOnError) {
+        const scriptName = path.basename(scriptPath);
+        const destPath = `/workspace/.perry-script-${scriptName}`;
         try {
-            await fs.access(expandedPath);
+            await docker.copyToContainer(containerName, scriptPath, destPath);
+            await docker.execInContainer(containerName, ['chown', 'workspace:workspace', destPath], {
+                user: 'root',
+            });
+            await docker.execInContainer(containerName, ['chmod', '+x', destPath], {
+                user: 'workspace',
+            });
+            console.log(`[scripts] Running: ${scriptPath}`);
+            await docker.execInContainer(containerName, ['bash', destPath], {
+                user: 'workspace',
+            });
+            await docker.execInContainer(containerName, ['rm', '-f', destPath], {
+                user: 'workspace',
+            });
         }
-        catch {
-            console.warn(`Post-start script not found, skipping: ${expandedPath}`);
-            return;
+        catch (err) {
+            console.warn(`[scripts] Error running ${scriptPath}:`, err);
+            if (failOnError) {
+                throw err;
+            }
         }
-        const destPath = '/workspace/post-start.sh';
-        await docker.copyToContainer(containerName, expandedPath, destPath);
-        await docker.execInContainer(containerName, ['chown', 'workspace:workspace', destPath], {
-            user: 'root',
-        });
-        await docker.execInContainer(containerName, ['chmod', '+x', destPath], {
-            user: 'workspace',
-        });
-        await docker.execInContainer(containerName, ['bash', destPath], {
-            user: 'workspace',
-        });
     }
     async syncWorkspaceStatus(workspace) {
         if (workspace.status === 'creating') {
@@ -437,7 +385,7 @@ export class WorkspaceManager {
             await this.setupWorkspaceCredentials(containerName, name);
             workspace.status = 'running';
             await this.state.setWorkspace(workspace);
-            await this.runPostStartScript(containerName);
+            await this.runUserScripts(containerName);
             return workspace;
         }
         catch (err) {
@@ -516,7 +464,7 @@ export class WorkspaceManager {
             workspace.status = 'running';
             workspace.lastUsed = new Date().toISOString();
             await this.state.setWorkspace(workspace);
-            await this.runPostStartScript(containerName);
+            await this.runUserScripts(containerName);
             return workspace;
         }
         catch (err) {
@@ -593,4 +541,119 @@ export class WorkspaceManager {
         }
         await this.setupWorkspaceCredentials(containerName, name);
     }
+    async setPortForwards(name, forwards) {
+        const workspace = await this.state.getWorkspace(name);
+        if (!workspace) {
+            throw new Error(`Workspace '${name}' not found`);
+        }
+        workspace.ports.forwards = forwards;
+        await this.state.setWorkspace(workspace);
+        return workspace;
+    }
+    async getPortForwards(name) {
+        const workspace = await this.state.getWorkspace(name);
+        if (!workspace) {
+            throw new Error(`Workspace '${name}' not found`);
+        }
+        return workspace.ports.forwards || [];
+    }
+    async clone(sourceName, cloneName) {
+        const source = await this.state.getWorkspace(sourceName);
+        if (!source) {
+            throw new Error(`Workspace '${sourceName}' not found`);
+        }
+        const existing = await this.state.getWorkspace(cloneName);
+        if (existing) {
+            throw new Error(`Workspace '${cloneName}' already exists`);
+        }
+        const sourceContainerName = getContainerName(sourceName);
+        const cloneContainerName = getContainerName(cloneName);
+        const sourceVolumeName = `${VOLUME_PREFIX}${sourceName}`;
+        const sourceDockerVolume = `${VOLUME_PREFIX}${sourceName}-docker`;
+        const cloneVolumeName = `${VOLUME_PREFIX}${cloneName}`;
+        const cloneDockerVolume = `${VOLUME_PREFIX}${cloneName}-docker`;
+        const workspace = {
+            name: cloneName,
+            status: 'creating',
+            containerId: '',
+            created: new Date().toISOString(),
+            repo: source.repo,
+            ports: {
+                ssh: 0,
+                forwards: source.ports.forwards ? [...source.ports.forwards] : undefined,
+            },
+            lastUsed: new Date().toISOString(),
+        };
+        await this.state.setWorkspace(workspace);
+        const wasRunning = await docker.containerRunning(sourceContainerName);
+        try {
+            if (wasRunning) {
+                await docker.stopContainer(sourceContainerName);
+            }
+            await docker.cloneVolume(sourceVolumeName, cloneVolumeName);
+            await docker.cloneVolume(sourceDockerVolume, cloneDockerVolume);
+            if (wasRunning) {
+                await docker.startContainer(sourceContainerName);
+            }
+            const workspaceImage = await ensureWorkspaceImage();
+            const sshPort = await findAvailablePort(SSH_PORT_RANGE_START, SSH_PORT_RANGE_END);
+            const containerEnv = {
+                ...this.config.credentials.env,
+            };
+            if (this.config.agents?.github?.token) {
+                containerEnv.GITHUB_TOKEN = this.config.agents.github.token;
+            }
+            if (this.config.agents?.claude_code?.oauth_token) {
+                containerEnv.CLAUDE_CODE_OAUTH_TOKEN = this.config.agents.claude_code.oauth_token;
+            }
+            if (workspace.repo) {
+                containerEnv.WORKSPACE_REPO_URL = workspace.repo;
+            }
+            const containerId = await docker.createContainer({
+                name: cloneContainerName,
+                image: workspaceImage,
+                hostname: cloneName,
+                privileged: true,
+                restartPolicy: 'unless-stopped',
+                env: containerEnv,
+                volumes: [
+                    { source: cloneVolumeName, target: '/home/workspace', readonly: false },
+                    { source: cloneDockerVolume, target: '/var/lib/docker', readonly: false },
+                ],
+                ports: [{ hostPort: sshPort, containerPort: 22, protocol: 'tcp' }],
+                labels: {
+                    'workspace.name': cloneName,
+                    'workspace.managed': 'true',
+                },
+            });
+            workspace.containerId = containerId;
+            workspace.ports.ssh = sshPort;
+            await this.state.setWorkspace(workspace);
+            await docker.startContainer(cloneContainerName);
+            await docker.waitForContainerReady(cloneContainerName);
+            await this.setupWorkspaceCredentials(cloneContainerName, cloneName);
+            workspace.status = 'running';
+            await this.state.setWorkspace(workspace);
+            await this.runUserScripts(cloneContainerName);
+            return workspace;
+        }
+        catch (err) {
+            workspace.status = 'error';
+            await this.state.setWorkspace(workspace);
+            if (await docker.containerExists(cloneContainerName)) {
+                await docker.removeContainer(cloneContainerName, true).catch(() => { });
+            }
+            if (await docker.volumeExists(cloneVolumeName)) {
+                await docker.removeVolume(cloneVolumeName, true).catch(() => { });
+            }
+            if (await docker.volumeExists(cloneDockerVolume)) {
+                await docker.removeVolume(cloneDockerVolume, true).catch(() => { });
+            }
+            await this.state.deleteWorkspace(cloneName).catch(() => { });
+            if (wasRunning && !(await docker.containerRunning(sourceContainerName))) {
+                await docker.startContainer(sourceContainerName).catch(() => { });
+            }
+            throw err;
+        }
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gricha/perry",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Self-contained CLI for spinning up Docker-in-Docker development environments with SSH and proxy helpers.",
   "type": "module",
   "bin": {
@@ -13,7 +13,7 @@
     "build": "rm -rf ./dist && bun run build:ts && bun run build:worker && bun run build:web && bun link",
     "build:ts": "tsc && chmod +x dist/index.js",
     "build:worker": "bun build src/index.ts --compile --outfile dist/perry-worker --target=bun",
-    "build:web": "cp src/shared/client-types.ts web/src/lib/types.ts && cd web && bun run build && cp -r dist ../dist/agent/web",
+    "build:web": "cd web && bun run build && cp -r dist ../dist/agent/web",
     "test": "vitest run",
     "test:web": "playwright test",
     "test:tui": "vitest run --config vitest.tui.config.js",
@@ -24,7 +24,8 @@
     "format:check": "oxfmt --check src/ test/",
     "check": "bun run lint && bun run format:check && bun x tsc --noEmit",
     "lint:web": "cd web && bun run lint",
-    "validate": "bun run check && bun run build && bun run test && bun run lint:web && bun run test:web"
+    "validate": "bun run check && bun run build && bun run test && bun run lint:web && bun run test:web",
+    "build:binaries": "bun run scripts/build-binaries.ts"
   },
   "engines": {
     "bun": ">=1.3.5"