@gricha/perry 0.2.2 → 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

@@ -1,6 +1,6 @@
 import { BaseWebSocketServer, safeSend } from '../shared/base-websocket';
 import { getContainerName } from '../docker';
-import { HOST_WORKSPACE_NAME } from '../shared/types';
+import { HOST_WORKSPACE_NAME } from '../shared/client-types';
 export class BaseChatWebSocketServer extends BaseWebSocketServer {
     isHostAccessAllowed;
     constructor(options) {
@@ -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/base-claude-session.js

@@ -0,0 +1,169 @@
+import { DEFAULT_CLAUDE_MODEL } from '../shared/constants';
+export class BaseClaudeSession {
+    process = null;
+    sessionId;
+    model;
+    sessionModel;
+    onMessage;
+    buffer = '';
+    constructor(sessionId, model, onMessage) {
+        this.sessionId = sessionId;
+        this.model = model || DEFAULT_CLAUDE_MODEL;
+        this.sessionModel = this.model;
+        this.onMessage = onMessage;
+    }
+    async sendMessage(userMessage) {
+        const logPrefix = this.getLogPrefix();
+        const { command, options } = this.getSpawnConfig(userMessage);
+        console.log(`[${logPrefix}] Running:`, command.join(' '));
+        this.onMessage({
+            type: 'system',
+            content: 'Processing your message...',
+            timestamp: new Date().toISOString(),
+        });
+        try {
+            const proc = Bun.spawn(command, {
+                stdin: 'ignore',
+                stdout: 'pipe',
+                stderr: 'pipe',
+                ...options,
+            });
+            this.process = proc;
+            if (!proc.stdout || !proc.stderr) {
+                throw new Error('Failed to get process streams');
+            }
+            console.log(`[${logPrefix}] Process spawned, waiting for output...`);
+            const stderrPromise = new Response(proc.stderr).text();
+            const decoder = new TextDecoder();
+            let receivedAnyOutput = false;
+            for await (const chunk of proc.stdout) {
+                const text = decoder.decode(chunk);
+                console.log(`[${logPrefix}] Received chunk:`, text.length, 'bytes');
+                receivedAnyOutput = true;
+                this.buffer += text;
+                this.processBuffer();
+            }
+            const exitCode = await proc.exited;
+            console.log(`[${logPrefix}] Process exited with code:`, exitCode, 'receivedOutput:', receivedAnyOutput);
+            const stderrText = await stderrPromise;
+            if (stderrText) {
+                console.error(`[${logPrefix}] stderr:`, stderrText);
+            }
+            if (exitCode !== 0) {
+                this.onMessage({
+                    type: 'error',
+                    content: stderrText || `Claude exited with code ${exitCode}`,
+                    timestamp: new Date().toISOString(),
+                });
+                return;
+            }
+            if (!receivedAnyOutput) {
+                this.onMessage({
+                    type: 'error',
+                    content: this.getNoOutputErrorMessage(),
+                    timestamp: new Date().toISOString(),
+                });
+                return;
+            }
+            this.onMessage({
+                type: 'done',
+                content: 'Response complete',
+                timestamp: new Date().toISOString(),
+            });
+        }
+        catch (err) {
+            console.error(`[${logPrefix}] Error:`, err);
+            this.onMessage({
+                type: 'error',
+                content: err.message,
+                timestamp: new Date().toISOString(),
+            });
+        }
+        finally {
+            this.process = null;
+        }
+    }
+    getNoOutputErrorMessage() {
+        return 'No response from Claude. Check if Claude is authenticated.';
+    }
+    processBuffer() {
+        const lines = this.buffer.split('\n');
+        this.buffer = lines.pop() || '';
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            try {
+                const msg = JSON.parse(line);
+                this.handleStreamMessage(msg);
+            }
+            catch {
+                console.error(`[${this.getLogPrefix()}] Failed to parse:`, line);
+            }
+        }
+    }
+    handleStreamMessage(msg) {
+        const timestamp = new Date().toISOString();
+        if (msg.type === 'system' && msg.subtype === 'init') {
+            this.sessionId = msg.session_id;
+            this.sessionModel = this.model;
+            this.onMessage({
+                type: 'system',
+                content: `Session started: ${msg.session_id?.slice(0, 8)}...`,
+                timestamp,
+            });
+            return;
+        }
+        if (msg.type === 'assistant' && msg.message?.content) {
+            for (const block of msg.message.content) {
+                if (block.type === 'tool_use') {
+                    this.onMessage({
+                        type: 'tool_use',
+                        content: JSON.stringify(block.input, null, 2),
+                        toolName: block.name,
+                        toolId: block.id,
+                        timestamp,
+                    });
+                }
+            }
+            return;
+        }
+        if (msg.type === 'stream_event' && msg.event?.type === 'content_block_delta') {
+            const delta = msg.event?.delta;
+            if (delta?.type === 'text_delta' && delta?.text) {
+                this.onMessage({
+                    type: 'assistant',
+                    content: delta.text,
+                    timestamp,
+                });
+            }
+            return;
+        }
+    }
+    async interrupt() {
+        if (this.process) {
+            this.process.kill();
+            this.process = null;
+            this.onMessage({
+                type: 'system',
+                content: 'Chat interrupted',
+                timestamp: new Date().toISOString(),
+            });
+        }
+    }
+    setModel(model) {
+        if (this.model !== model) {
+            this.model = model;
+            if (this.sessionModel !== model) {
+                this.sessionId = undefined;
+                this.onMessage({
+                    type: 'system',
+                    content: `Switching to model: ${model}`,
+                    timestamp: new Date().toISOString(),
+                });
+            }
+        }
+    }
+    getSessionId() {
+        return this.sessionId;
+    }
+}