@gricha/perry 0.2.3 → 0.2.5

package/dist/agents/__tests__/sync.test.js

@@ -0,0 +1,272 @@
+import { describe, it, expect } from 'vitest';
+import { syncAgent, syncAllAgents, getCredentialFilePaths, createSyncContext } from '../index';
+import { createMockFileCopier } from '../sync/copier';
+function createMockContext(overrides = {}) {
+    return {
+        containerName: 'test-container',
+        agentConfig: {
+            port: 7777,
+            credentials: { env: {}, files: {} },
+            scripts: {},
+        },
+        hostFileExists: async () => false,
+        hostDirExists: async () => false,
+        readHostFile: async () => null,
+        readContainerFile: async () => null,
+        ...overrides,
+    };
+}
+describe('syncAgent', () => {
+    it('creates required directories', async () => {
+        const provider = {
+            getRequiredDirs: () => ['/home/workspace/.test'],
+            getFilesToSync: async () => [],
+            getDirectoriesToSync: async () => [],
+            getGeneratedConfigs: async () => [],
+        };
+        const context = createMockContext();
+        const copier = createMockFileCopier();
+        await syncAgent(provider, context, copier);
+        expect(copier.calls).toContainEqual({
+            method: 'ensureDir',
+            args: ['test-container', '/home/workspace/.test'],
+        });
+    });
+    it('copies files that exist', async () => {
+        const provider = {
+            getRequiredDirs: () => [],
+            getFilesToSync: async () => [
+                {
+                    source: '~/.test/file.json',
+                    dest: '/home/workspace/.test/file.json',
+                    category: 'credential',
+                    permissions: '600',
+                },
+            ],
+            getDirectoriesToSync: async () => [],
+            getGeneratedConfigs: async () => [],
+        };
+        const context = createMockContext({
+            hostFileExists: async (path) => path === '~/.test/file.json',
+        });
+        const copier = createMockFileCopier();
+        const result = await syncAgent(provider, context, copier);
+        expect(copier.calls).toContainEqual({
+            method: 'copyFile',
+            args: [
+                'test-container',
+                {
+                    source: '~/.test/file.json',
+                    dest: '/home/workspace/.test/file.json',
+                    category: 'credential',
+                    permissions: '600',
+                },
+            ],
+        });
+        expect(result.copied).toContain('~/.test/file.json');
+    });
+    it('skips optional files that do not exist', async () => {
+        const provider = {
+            getRequiredDirs: () => [],
+            getFilesToSync: async () => [
+                {
+                    source: '~/.test/optional.json',
+                    dest: '/home/workspace/.test/optional.json',
+                    category: 'preference',
+                    optional: true,
+                },
+            ],
+            getDirectoriesToSync: async () => [],
+            getGeneratedConfigs: async () => [],
+        };
+        const context = createMockContext({
+            hostFileExists: async () => false,
+        });
+        const copier = createMockFileCopier();
+        const result = await syncAgent(provider, context, copier);
+        expect(result.skipped).toContain('~/.test/optional.json');
+        expect(result.errors).toHaveLength(0);
+        expect(copier.calls.filter((c) => c.method === 'copyFile')).toHaveLength(0);
+    });
+    it('reports errors for missing required files', async () => {
+        const provider = {
+            getRequiredDirs: () => [],
+            getFilesToSync: async () => [
+                {
+                    source: '~/.test/required.json',
+                    dest: '/home/workspace/.test/required.json',
+                    category: 'credential',
+                    optional: false,
+                },
+            ],
+            getDirectoriesToSync: async () => [],
+            getGeneratedConfigs: async () => [],
+        };
+        const context = createMockContext({
+            hostFileExists: async () => false,
+        });
+        const copier = createMockFileCopier();
+        const result = await syncAgent(provider, context, copier);
+        expect(result.errors).toContainEqual({
+            path: '~/.test/required.json',
+            error: 'File not found',
+        });
+    });
+    it('copies directories that exist', async () => {
+        const provider = {
+            getRequiredDirs: () => [],
+            getFilesToSync: async () => [],
+            getDirectoriesToSync: async () => [
+                {
+                    source: '~/.test/dir',
+                    dest: '/home/workspace/.test/dir',
+                    category: 'preference',
+                },
+            ],
+            getGeneratedConfigs: async () => [],
+        };
+        const context = createMockContext({
+            hostDirExists: async (path) => path === '~/.test/dir',
+        });
+        const copier = createMockFileCopier();
+        const result = await syncAgent(provider, context, copier);
+        expect(copier.calls).toContainEqual({
+            method: 'copyDirectory',
+            args: [
+                'test-container',
+                {
+                    source: '~/.test/dir',
+                    dest: '/home/workspace/.test/dir',
+                    category: 'preference',
+                },
+            ],
+        });
+        expect(result.copied).toContain('~/.test/dir');
+    });
+    it('generates configs', async () => {
+        const provider = {
+            getRequiredDirs: () => [],
+            getFilesToSync: async () => [],
+            getDirectoriesToSync: async () => [],
+            getGeneratedConfigs: async () => [
+                {
+                    dest: '/home/workspace/.test/config.json',
+                    content: '{"key": "value"}',
+                    permissions: '644',
+                    category: 'preference',
+                },
+            ],
+        };
+        const context = createMockContext();
+        const copier = createMockFileCopier();
+        const result = await syncAgent(provider, context, copier);
+        expect(copier.calls).toContainEqual({
+            method: 'writeConfig',
+            args: [
+                'test-container',
+                {
+                    dest: '/home/workspace/.test/config.json',
+                    content: '{"key": "value"}',
+                    permissions: '644',
+                    category: 'preference',
+                },
+            ],
+        });
+        expect(result.generated).toContain('/home/workspace/.test/config.json');
+    });
+    it('tracks all results correctly', async () => {
+        const provider = {
+            getRequiredDirs: () => ['/home/workspace/.test'],
+            getFilesToSync: async () => [
+                {
+                    source: '~/.test/exists.json',
+                    dest: '/home/workspace/.test/exists.json',
+                    category: 'credential',
+                },
+                {
+                    source: '~/.test/optional.json',
+                    dest: '/home/workspace/.test/optional.json',
+                    category: 'preference',
+                    optional: true,
+                },
+            ],
+            getDirectoriesToSync: async () => [],
+            getGeneratedConfigs: async () => [
+                {
+                    dest: '/home/workspace/.test/generated.json',
+                    content: '{}',
+                    category: 'preference',
+                },
+            ],
+        };
+        const context = createMockContext({
+            hostFileExists: async (path) => path === '~/.test/exists.json',
+        });
+        const copier = createMockFileCopier();
+        const result = await syncAgent(provider, context, copier);
+        expect(result.copied).toEqual(['~/.test/exists.json']);
+        expect(result.skipped).toEqual(['~/.test/optional.json']);
+        expect(result.generated).toEqual(['/home/workspace/.test/generated.json']);
+        expect(result.errors).toHaveLength(0);
+    });
+});
+describe('syncAllAgents', () => {
+    it('syncs all three agents', async () => {
+        const copier = createMockFileCopier();
+        const results = await syncAllAgents('test-container', {
+            port: 7777,
+            credentials: { env: {}, files: {} },
+            scripts: {},
+        }, copier);
+        expect(results['claude-code']).toBeDefined();
+        expect(results['opencode']).toBeDefined();
+        expect(results['codex']).toBeDefined();
+    });
+    it('returns results per agent', async () => {
+        const copier = createMockFileCopier();
+        const results = await syncAllAgents('test-container', {
+            port: 7777,
+            credentials: { env: {}, files: {} },
+            scripts: {},
+        }, copier);
+        for (const agentType of ['claude-code', 'opencode', 'codex']) {
+            const result = results[agentType];
+            expect(result).toHaveProperty('copied');
+            expect(result).toHaveProperty('generated');
+            expect(result).toHaveProperty('skipped');
+            expect(result).toHaveProperty('errors');
+        }
+    });
+});
+describe('getCredentialFilePaths', () => {
+    it('returns credential files from providers', () => {
+        const paths = getCredentialFilePaths();
+        expect(paths).toContain('~/.claude/.credentials.json');
+        expect(paths).toContain('~/.codex/auth.json');
+    });
+    it('does not include preference-only files', () => {
+        const paths = getCredentialFilePaths();
+        expect(paths).not.toContain('~/.claude/settings.json');
+        expect(paths).not.toContain('~/.codex/config.toml');
+    });
+});
+describe('createSyncContext', () => {
+    it('creates context with correct container name', () => {
+        const context = createSyncContext('my-container', {
+            port: 7777,
+            credentials: { env: {}, files: {} },
+            scripts: {},
+        });
+        expect(context.containerName).toBe('my-container');
+    });
+    it('creates context with agent config', () => {
+        const config = {
+            port: 7777,
+            credentials: { env: {}, files: {} },
+            scripts: {},
+            agents: { opencode: { zen_token: 'test' } },
+        };
+        const context = createSyncContext('my-container', config);
+        expect(context.agentConfig).toBe(config);
+    });
+});

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] });
+        },
+    };
+}