@gricha/perry 0.2.3 → 0.2.4

package/dist/agents/index.js

@@ -0,0 +1,177 @@
+import fs from 'fs/promises';
+import { claudeProvider, opencodeProvider, codexProvider } from '../sessions/agents';
+import { claudeCodeSync } from './sync/claude-code';
+import { opencodeSync } from './sync/opencode';
+import { codexSync } from './sync/codex';
+import { createDockerFileCopier } from './sync/copier';
+import { expandPath } from '../config/loader';
+import * as docker from '../docker';
+export const agents = {
+    'claude-code': {
+        agentType: 'claude-code',
+        sync: claudeCodeSync,
+        sessions: claudeProvider,
+    },
+    opencode: {
+        agentType: 'opencode',
+        sync: opencodeSync,
+        sessions: opencodeProvider,
+    },
+    codex: {
+        agentType: 'codex',
+        sync: codexSync,
+        sessions: codexProvider,
+    },
+};
+export function createSyncContext(containerName, agentConfig) {
+    return {
+        containerName,
+        agentConfig,
+        async hostFileExists(filePath) {
+            try {
+                const expanded = expandPath(filePath);
+                const stat = await fs.stat(expanded);
+                return stat.isFile();
+            }
+            catch {
+                return false;
+            }
+        },
+        async hostDirExists(dirPath) {
+            try {
+                const expanded = expandPath(dirPath);
+                const stat = await fs.stat(expanded);
+                return stat.isDirectory();
+            }
+            catch {
+                return false;
+            }
+        },
+        async readHostFile(filePath) {
+            try {
+                const expanded = expandPath(filePath);
+                return await fs.readFile(expanded, 'utf-8');
+            }
+            catch {
+                return null;
+            }
+        },
+        async readContainerFile(filePath) {
+            try {
+                const result = await docker.execInContainer(containerName, ['cat', filePath], {
+                    user: 'workspace',
+                });
+                if (result.exitCode !== 0) {
+                    return null;
+                }
+                return result.stdout;
+            }
+            catch {
+                return null;
+            }
+        },
+    };
+}
+export async function syncAgent(provider, context, copier) {
+    const result = {
+        copied: [],
+        generated: [],
+        skipped: [],
+        errors: [],
+    };
+    for (const dir of provider.getRequiredDirs()) {
+        try {
+            await copier.ensureDir(context.containerName, dir);
+        }
+        catch (err) {
+            result.errors.push({ path: dir, error: String(err) });
+        }
+    }
+    const files = await provider.getFilesToSync(context);
+    for (const file of files) {
+        const exists = await context.hostFileExists(file.source);
+        if (!exists) {
+            if (file.optional) {
+                result.skipped.push(file.source);
+            }
+            else {
+                result.errors.push({ path: file.source, error: 'File not found' });
+            }
+            continue;
+        }
+        try {
+            await copier.copyFile(context.containerName, file);
+            result.copied.push(file.source);
+        }
+        catch (err) {
+            result.errors.push({ path: file.source, error: String(err) });
+        }
+    }
+    const directories = await provider.getDirectoriesToSync(context);
+    for (const dir of directories) {
+        const exists = await context.hostDirExists(dir.source);
+        if (!exists) {
+            if (dir.optional) {
+                result.skipped.push(dir.source);
+            }
+            else {
+                result.errors.push({ path: dir.source, error: 'Directory not found' });
+            }
+            continue;
+        }
+        try {
+            await copier.copyDirectory(context.containerName, dir);
+            result.copied.push(dir.source);
+        }
+        catch (err) {
+            result.errors.push({ path: dir.source, error: String(err) });
+        }
+    }
+    const configs = await provider.getGeneratedConfigs(context);
+    for (const config of configs) {
+        try {
+            await copier.writeConfig(context.containerName, config);
+            result.generated.push(config.dest);
+        }
+        catch (err) {
+            result.errors.push({ path: config.dest, error: String(err) });
+        }
+    }
+    return result;
+}
+export async function syncAllAgents(containerName, agentConfig, copier) {
+    const actualCopier = copier || createDockerFileCopier();
+    const context = createSyncContext(containerName, agentConfig);
+    const results = {
+        'claude-code': { copied: [], generated: [], skipped: [], errors: [] },
+        opencode: { copied: [], generated: [], skipped: [], errors: [] },
+        codex: { copied: [], generated: [], skipped: [], errors: [] },
+    };
+    for (const [agentType, agent] of Object.entries(agents)) {
+        results[agentType] = await syncAgent(agent.sync, context, actualCopier);
+    }
+    return results;
+}
+export function getCredentialFilePaths() {
+    const paths = [];
+    for (const agent of Object.values(agents)) {
+        const dummyContext = {
+            containerName: '',
+            agentConfig: { port: 0, credentials: { env: {}, files: {} }, scripts: {} },
+            hostFileExists: async () => false,
+            hostDirExists: async () => false,
+            readHostFile: async () => null,
+            readContainerFile: async () => null,
+        };
+        const filesPromise = agent.sync.getFilesToSync(dummyContext);
+        filesPromise.then((files) => {
+            for (const file of files) {
+                if (file.category === 'credential') {
+                    paths.push(file.source);
+                }
+            }
+        });
+    }
+    return ['~/.claude/.credentials.json', '~/.codex/auth.json'];
+}
+export { createDockerFileCopier, createMockFileCopier } from './sync/copier';

package/dist/agents/sync/claude-code.js

@@ -0,0 +1,84 @@
+export const claudeCodeSync = {
+    getRequiredDirs() {
+        return ['/home/workspace/.claude'];
+    },
+    async getFilesToSync(_context) {
+        return [
+            {
+                source: '~/.claude/.credentials.json',
+                dest: '/home/workspace/.claude/.credentials.json',
+                category: 'credential',
+                permissions: '600',
+                optional: true,
+            },
+            {
+                source: '~/.claude/settings.json',
+                dest: '/home/workspace/.claude/settings.json',
+                category: 'preference',
+                permissions: '644',
+                optional: true,
+            },
+            {
+                source: '~/.claude/CLAUDE.md',
+                dest: '/home/workspace/.claude/CLAUDE.md',
+                category: 'preference',
+                permissions: '644',
+                optional: true,
+            },
+        ];
+    },
+    async getDirectoriesToSync(context) {
+        const agentsDirExists = await context.hostDirExists('~/.claude/agents');
+        if (!agentsDirExists) {
+            return [];
+        }
+        return [
+            {
+                source: '~/.claude/agents',
+                dest: '/home/workspace/.claude/agents',
+                category: 'preference',
+                optional: true,
+            },
+        ];
+    },
+    async getGeneratedConfigs(context) {
+        const hostConfigContent = await context.readHostFile('~/.claude.json');
+        const containerConfigContent = await context.readContainerFile('/home/workspace/.claude.json');
+        let hostMcpServers = {};
+        if (hostConfigContent) {
+            try {
+                const parsed = JSON.parse(hostConfigContent);
+                if (parsed.mcpServers && typeof parsed.mcpServers === 'object') {
+                    hostMcpServers = parsed.mcpServers;
+                }
+            }
+            catch {
+                // Invalid JSON, ignore
+            }
+        }
+        let containerConfig = {};
+        if (containerConfigContent) {
+            try {
+                containerConfig = JSON.parse(containerConfigContent);
+            }
+            catch {
+                // Invalid JSON, start fresh
+            }
+        }
+        containerConfig.hasCompletedOnboarding = true;
+        if (Object.keys(hostMcpServers).length > 0) {
+            const existingMcp = containerConfig.mcpServers && typeof containerConfig.mcpServers === 'object'
+                ? containerConfig.mcpServers
+                : {};
+            containerConfig.mcpServers = { ...existingMcp, ...hostMcpServers };
+        }
+        return [
+            {
+                dest: '/home/workspace/.claude.json',
+                content: JSON.stringify(containerConfig, null, 2),
+                permissions: '644',
+                category: 'preference',
+            },
+        ];
+    },
+};

package/dist/agents/sync/codex.js

@@ -0,0 +1,29 @@
+export const codexSync = {
+    getRequiredDirs() {
+        return ['/home/workspace/.codex'];
+    },
+    async getFilesToSync(_context) {
+        return [
+            {
+                source: '~/.codex/auth.json',
+                dest: '/home/workspace/.codex/auth.json',
+                category: 'credential',
+                permissions: '600',
+                optional: true,
+            },
+            {
+                source: '~/.codex/config.toml',
+                dest: '/home/workspace/.codex/config.toml',
+                category: 'preference',
+                permissions: '600',
+                optional: true,
+            },
+        ];
+    },
+    async getDirectoriesToSync(_context) {
+        return [];
+    },
+    async getGeneratedConfigs(_context) {
+        return [];
+    },
+};

package/dist/agents/sync/copier.js

@@ -0,0 +1,89 @@
+import fs from 'fs/promises';
+import os from 'os';
+import path from 'path';
+import * as docker from '../../docker';
+import { expandPath } from '../../config/loader';
+export function createDockerFileCopier() {
+    return {
+        async ensureDir(containerName, dir) {
+            await docker.execInContainer(containerName, ['mkdir', '-p', dir], {
+                user: 'workspace',
+            });
+        },
+        async copyFile(containerName, file) {
+            const expandedSource = expandPath(file.source);
+            const permissions = file.permissions || '644';
+            const destDir = path.dirname(file.dest);
+            await docker.execInContainer(containerName, ['mkdir', '-p', destDir], {
+                user: 'workspace',
+            });
+            await docker.copyToContainer(containerName, expandedSource, file.dest);
+            await docker.execInContainer(containerName, ['chown', 'workspace:workspace', file.dest], {
+                user: 'root',
+            });
+            await docker.execInContainer(containerName, ['chmod', permissions, file.dest], {
+                user: 'workspace',
+            });
+        },
+        async copyDirectory(containerName, dir) {
+            const expandedSource = expandPath(dir.source);
+            const tempTar = path.join(os.tmpdir(), `agent-sync-${Date.now()}.tar`);
+            try {
+                const { execSync } = await import('child_process');
+                execSync(`tar -cf "${tempTar}" -C "${expandedSource}" .`, { stdio: 'pipe' });
+                await docker.execInContainer(containerName, ['mkdir', '-p', dir.dest], {
+                    user: 'workspace',
+                });
+                await docker.copyToContainer(containerName, tempTar, '/tmp/agent-sync.tar');
+                await docker.execInContainer(containerName, ['tar', '-xf', '/tmp/agent-sync.tar', '-C', dir.dest], { user: 'workspace' });
+                await docker.execInContainer(containerName, ['rm', '/tmp/agent-sync.tar'], {
+                    user: 'workspace',
+                });
+                await docker.execInContainer(containerName, ['find', dir.dest, '-type', 'f', '-exec', 'chmod', '644', '{}', '+'], { user: 'workspace' });
+                await docker.execInContainer(containerName, ['find', dir.dest, '-type', 'd', '-exec', 'chmod', '755', '{}', '+'], { user: 'workspace' });
+            }
+            finally {
+                await fs.unlink(tempTar).catch(() => { });
+            }
+        },
+        async writeConfig(containerName, config) {
+            const tempFile = path.join(os.tmpdir(), `agent-config-${Date.now()}.json`);
+            const permissions = config.permissions || '644';
+            await fs.writeFile(tempFile, config.content, 'utf-8');
+            try {
+                const destDir = path.dirname(config.dest);
+                await docker.execInContainer(containerName, ['mkdir', '-p', destDir], {
+                    user: 'workspace',
+                });
+                await docker.copyToContainer(containerName, tempFile, config.dest);
+                await docker.execInContainer(containerName, ['chown', 'workspace:workspace', config.dest], {
+                    user: 'root',
+                });
+                await docker.execInContainer(containerName, ['chmod', permissions, config.dest], {
+                    user: 'workspace',
+                });
+            }
+            finally {
+                await fs.unlink(tempFile).catch(() => { });
+            }
+        },
+    };
+}
+export function createMockFileCopier() {
+    const calls = [];
+    return {
+        calls,
+        async ensureDir(containerName, dir) {
+            calls.push({ method: 'ensureDir', args: [containerName, dir] });
+        },
+        async copyFile(containerName, file) {
+            calls.push({ method: 'copyFile', args: [containerName, file] });
+        },
+        async copyDirectory(containerName, dir) {
+            calls.push({ method: 'copyDirectory', args: [containerName, dir] });
+        },
+        async writeConfig(containerName, config) {
+            calls.push({ method: 'writeConfig', args: [containerName, config] });
+        },
+    };
+}

package/dist/agents/sync/opencode.js

@@ -0,0 +1,51 @@
+export const opencodeSync = {
+    getRequiredDirs() {
+        return ['/home/workspace/.config/opencode'];
+    },
+    async getFilesToSync(_context) {
+        return [];
+    },
+    async getDirectoriesToSync(_context) {
+        return [];
+    },
+    async getGeneratedConfigs(context) {
+        const zenToken = context.agentConfig.agents?.opencode?.zen_token;
+        if (!zenToken) {
+            return [];
+        }
+        const hostConfigContent = await context.readHostFile('~/.config/opencode/opencode.json');
+        let mcpConfig = {};
+        if (hostConfigContent) {
+            try {
+                const parsed = JSON.parse(hostConfigContent);
+                if (parsed.mcp && typeof parsed.mcp === 'object') {
+                    mcpConfig = parsed.mcp;
+                }
+            }
+            catch {
+                // Invalid JSON, ignore
+            }
+        }
+        const config = {
+            provider: {
+                opencode: {
+                    options: {
+                        apiKey: zenToken,
+                    },
+                },
+            },
+            model: 'opencode/claude-sonnet-4',
+        };
+        if (Object.keys(mcpConfig).length > 0) {
+            config.mcp = mcpConfig;
+        }
+        return [
+            {
+                dest: '/home/workspace/.config/opencode/opencode.json',
+                content: JSON.stringify(config, null, 2),
+                permissions: '600',
+                category: 'credential',
+            },
+        ];
+    },
+};

package/dist/agents/sync/types.js

@@ -0,0 +1 @@
+export {};

package/dist/agents/types.js

@@ -0,0 +1 @@
+export {};

package/dist/chat/base-chat-websocket.js

@@ -41,7 +41,7 @@ export class BaseChatWebSocketServer extends BaseWebSocketServer {
                     };
                     if (!connection.session) {
                         if (isHostMode) {
-                            connection.session = this.createHostSession(message.sessionId, onMessage, message.model);
+                            connection.session = this.createHostSession(message.sessionId, onMessage, message.model, message.projectPath);
                         }
                         else {
                             const containerName = getContainerName(workspaceName);

package/dist/chat/opencode-websocket.js

@@ -15,7 +15,7 @@ export class OpencodeWebSocketServer extends BaseChatWebSocketServer {
             workspaceName,
         };
     }
-    createHostSession(sessionId, onMessage, messageModel) {
+    createHostSession(sessionId, onMessage, messageModel, _projectPath) {
         const model = messageModel || this.getConfig?.()?.agents?.opencode?.model;
         return createHostOpencodeSession({ sessionId, model }, onMessage);
     }

package/dist/chat/websocket.js

@@ -15,10 +15,10 @@ export class ChatWebSocketServer extends BaseChatWebSocketServer {
             workspaceName,
         };
     }
-    createHostSession(sessionId, onMessage, messageModel) {
+    createHostSession(sessionId, onMessage, messageModel, projectPath) {
         const config = this.getConfig();
         const model = messageModel || config.agents?.claude_code?.model;
-        return createHostChatSession({ sessionId, model }, onMessage);
+        return createHostChatSession({ sessionId, model, workDir: projectPath }, onMessage);
     }
     createContainerSession(containerName, sessionId, onMessage, messageModel) {
         const config = this.getConfig();

package/dist/client/api.js

@@ -98,6 +98,31 @@ export class ApiClient {
             throw this.wrapError(err);
         }
     }
+    async getPortForwards(name) {
+        try {
+            const result = await this.client.workspaces.getPortForwards({ name });
+            return result.forwards;
+        }
+        catch (err) {
+            throw this.wrapError(err);
+        }
+    }
+    async setPortForwards(name, forwards) {
+        try {
+            return await this.client.workspaces.setPortForwards({ name, forwards });
+        }
+        catch (err) {
+            throw this.wrapError(err);
+        }
+    }
+    async cloneWorkspace(sourceName, cloneName) {
+        try {
+            return await this.client.workspaces.clone({ sourceName, cloneName });
+        }
+        catch (err) {
+            throw this.wrapError(err);
+        }
+    }
     getTerminalUrl(name) {
         const wsUrl = this.baseUrl.replace(/^http/, 'ws');
         return `${wsUrl}/rpc/terminal/${encodeURIComponent(name)}`;

package/dist/config/loader.js

@@ -16,7 +16,10 @@ export function createDefaultAgentConfig() {
             env: {},
             files: {},
         },
-        scripts: {},
+        scripts: {
+            post_start: ['~/.perry/userscripts'],
+            fail_on_error: false,
+        },
         agents: {},
         allowHostAccess: true,
         ssh: {
@@ -29,6 +32,18 @@ export function createDefaultAgentConfig() {
         },
     };
 }
+function migratePostStart(value) {
+    if (!value) {
+        return ['~/.perry/userscripts'];
+    }
+    if (typeof value === 'string') {
+        return [value, '~/.perry/userscripts'];
+    }
+    if (Array.isArray(value)) {
+        return value.length > 0 ? value : ['~/.perry/userscripts'];
+    }
+    return ['~/.perry/userscripts'];
+}
 export async function loadAgentConfig(configDir) {
     const dir = getConfigDir(configDir);
     const configPath = path.join(dir, CONFIG_FILE);
@@ -41,7 +56,10 @@ export async function loadAgentConfig(configDir) {
                 env: config.credentials?.env || {},
                 files: config.credentials?.files || {},
             },
-            scripts: config.scripts || {},
+            scripts: {
+                post_start: migratePostStart(config.scripts?.post_start),
+                fail_on_error: config.scripts?.fail_on_error ?? false,
+            },
             agents: config.agents || {},
             allowHostAccess: config.allowHostAccess ?? true,
             ssh: {

package/dist/docker/eager-pull.js

@@ -5,6 +5,7 @@ const RETRY_INTERVAL_MS = 20000;
 const MAX_RETRIES = 10;
 let pullInProgress = false;
 let pullComplete = false;
+let abortController = null;
 async function isDockerAvailable() {
     try {
         await getDockerVersion();
@@ -35,7 +36,13 @@ export async function startEagerImagePull() {
         return;
     }
     pullInProgress = true;
+    abortController = new AbortController();
+    const signal = abortController.signal;
     const attemptPull = async (attempt) => {
+        if (signal.aborted) {
+            pullInProgress = false;
+            return;
+        }
         if (attempt > MAX_RETRIES) {
             console.log('[agent] Max retries reached for image pull - giving up background pull');
             pullInProgress = false;
@@ -46,7 +53,8 @@ export async function startEagerImagePull() {
             if (attempt === 1) {
                 console.log('[agent] Docker not available - will retry in background');
             }
-            setTimeout(() => attemptPull(attempt + 1), RETRY_INTERVAL_MS);
+            const timer = setTimeout(() => attemptPull(attempt + 1), RETRY_INTERVAL_MS);
+            timer.unref();
             return;
         }
         const success = await pullWorkspaceImage();
@@ -54,12 +62,20 @@ export async function startEagerImagePull() {
             pullComplete = true;
             pullInProgress = false;
         }
-        else {
-            setTimeout(() => attemptPull(attempt + 1), RETRY_INTERVAL_MS);
+        else if (!signal.aborted) {
+            const timer = setTimeout(() => attemptPull(attempt + 1), RETRY_INTERVAL_MS);
+            timer.unref();
         }
     };
     attemptPull(1);
 }
+export function stopEagerImagePull() {
+    if (abortController) {
+        abortController.abort();
+        abortController = null;
+    }
+    pullInProgress = false;
+}
 export function isImagePullComplete() {
     return pullComplete;
 }

package/dist/docker/index.js

@@ -410,3 +410,30 @@ export async function getLogs(containerName, options = {}) {
     const { stdout, stderr } = await docker(args);
     return stdout + stderr;
 }
+export async function cloneVolume(sourceVolume, destVolume) {
+    if (!(await volumeExists(sourceVolume))) {
+        throw new Error(`Source volume '${sourceVolume}' does not exist`);
+    }
+    if (await volumeExists(destVolume)) {
+        throw new Error(`Volume '${destVolume}' already exists`);
+    }
+    await createVolume(destVolume);
+    try {
+        await docker([
+            'run',
+            '--rm',
+            '-v',
+            `${sourceVolume}:/source:ro`,
+            '-v',
+            `${destVolume}:/dest`,
+            'alpine',
+            'sh',
+            '-c',
+            'cp -a /source/. /dest/',
+        ]);
+    }
+    catch (err) {
+        await removeVolume(destVolume, true).catch(() => { });
+        throw new Error(`Failed to clone volume: ${err.message}`);
+    }
+}