@gricha/perry 0.2.3 → 0.2.5

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.3",
+  "version": "0.2.5",
   "description": "Self-contained CLI for spinning up Docker-in-Docker development environments with SSH and proxy helpers.",
   "type": "module",
   "bin": {