@gricha/perry 0.0.1

package/dist/client/config.js

@@ -0,0 +1,34 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { DEFAULT_CONFIG_DIR, CLIENT_CONFIG_FILE } from '../shared/types';
+function getClientConfigPath(configDir) {
+    return path.join(configDir || DEFAULT_CONFIG_DIR, CLIENT_CONFIG_FILE);
+}
+export async function loadClientConfig(configDir) {
+    const configPath = getClientConfigPath(configDir);
+    try {
+        const content = await fs.readFile(configPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            return null;
+        }
+        throw err;
+    }
+}
+export async function saveClientConfig(config, configDir) {
+    const configPath = getClientConfigPath(configDir);
+    const dir = path.dirname(configPath);
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+}
+export async function getWorker(configDir) {
+    const config = await loadClientConfig(configDir);
+    return config?.worker || null;
+}
+export async function setWorker(worker, configDir) {
+    const config = (await loadClientConfig(configDir)) || { worker: '' };
+    config.worker = worker;
+    await saveClientConfig(config, configDir);
+}

package/dist/client/docker-proxy.js

@@ -0,0 +1,103 @@
+export async function startDockerProxy(options) {
+    const { containerIp, forwards, onConnect, onError } = options;
+    const servers = [];
+    for (const fwd of forwards) {
+        try {
+            const server = Bun.listen({
+                hostname: '0.0.0.0',
+                port: fwd.localPort,
+                socket: {
+                    open(socket) {
+                        socket.data = { upstream: null, buffer: [] };
+                        Bun.connect({
+                            hostname: containerIp,
+                            port: fwd.remotePort,
+                            socket: {
+                                open(upstream) {
+                                    socket.data.upstream = upstream;
+                                    upstream.data = { downstream: socket };
+                                    for (const chunk of socket.data.buffer) {
+                                        upstream.write(chunk);
+                                    }
+                                    socket.data.buffer = [];
+                                },
+                                data(upstream, data) {
+                                    const downstream = upstream.data?.downstream;
+                                    if (downstream) {
+                                        downstream.write(data);
+                                    }
+                                },
+                                close(upstream) {
+                                    const downstream = upstream.data?.downstream;
+                                    if (downstream) {
+                                        downstream.end();
+                                    }
+                                },
+                                error(upstream, err) {
+                                    const downstream = upstream.data?.downstream;
+                                    if (downstream) {
+                                        downstream.end();
+                                    }
+                                    if (onError)
+                                        onError(err);
+                                },
+                            },
+                        }).catch((err) => {
+                            socket.end();
+                            if (onError)
+                                onError(err);
+                        });
+                    },
+                    data(socket, data) {
+                        if (socket.data.upstream) {
+                            socket.data.upstream.write(data);
+                        }
+                        else {
+                            socket.data.buffer.push(Buffer.from(data));
+                        }
+                    },
+                    close(socket) {
+                        if (socket.data.upstream) {
+                            socket.data.upstream.end();
+                        }
+                    },
+                    error(socket, err) {
+                        if (socket.data.upstream) {
+                            socket.data.upstream.end();
+                        }
+                        if (onError)
+                            onError(err);
+                    },
+                },
+            });
+            servers.push(server);
+            if (onConnect)
+                onConnect(fwd.localPort);
+        }
+        catch (err) {
+            if (onError)
+                onError(err);
+        }
+    }
+    return () => {
+        for (const server of servers) {
+            server.stop();
+        }
+    };
+}
+export function formatPortForwards(forwards) {
+    return forwards
+        .map((f) => f.localPort === f.remotePort ? String(f.localPort) : `${f.localPort}:${f.remotePort}`)
+        .join(', ');
+}
+export function parsePortForward(spec) {
+    if (spec.includes(':')) {
+        const [local, remote] = spec.split(':');
+        return {
+            localPort: parseInt(local, 10),
+            remotePort: parseInt(remote, 10),
+        };
+    }
+    const port = parseInt(spec, 10);
+    return { localPort: port, remotePort: port };
+}

package/dist/client/index.js

@@ -0,0 +1,4 @@
+export * from './api';
+export * from './config';
+export * from './shell';
+export * from './proxy';

package/dist/client/proxy.js

@@ -0,0 +1,96 @@
+import { spawn } from 'child_process';
+export function parsePortForward(spec) {
+    if (spec.includes(':')) {
+        const [local, remote] = spec.split(':');
+        return {
+            localPort: parseInt(local, 10),
+            remotePort: parseInt(remote, 10),
+        };
+    }
+    const port = parseInt(spec, 10);
+    return { localPort: port, remotePort: port };
+}
+export async function startProxy(options) {
+    const { worker, sshPort, forwards, user = 'workspace', onConnect, onDisconnect, onError, } = options;
+    const workerHost = worker.includes(':') ? worker.split(':')[0] : worker;
+    return new Promise((resolve, reject) => {
+        const sshArgs = [
+            '-N',
+            '-o',
+            'StrictHostKeyChecking=no',
+            '-o',
+            'UserKnownHostsFile=/dev/null',
+            '-o',
+            'LogLevel=ERROR',
+            '-o',
+            'ServerAliveInterval=60',
+            '-o',
+            'ServerAliveCountMax=3',
+            '-p',
+            String(sshPort),
+        ];
+        for (const fwd of forwards) {
+            sshArgs.push('-L', `${fwd.localPort}:localhost:${fwd.remotePort}`);
+        }
+        sshArgs.push(`${user}@${workerHost}`);
+        const proc = spawn('ssh', sshArgs, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let connected = false;
+        let errorOutput = '';
+        proc.stderr?.on('data', (data) => {
+            errorOutput += data.toString();
+        });
+        const connectionTimeout = setTimeout(() => {
+            if (!connected) {
+                proc.kill();
+                reject(new Error('SSH connection timeout'));
+            }
+        }, 30000);
+        setTimeout(() => {
+            if (proc.exitCode === null) {
+                connected = true;
+                clearTimeout(connectionTimeout);
+                if (onConnect) {
+                    onConnect();
+                }
+            }
+        }, 2000);
+        proc.on('error', (err) => {
+            clearTimeout(connectionTimeout);
+            if (!connected) {
+                reject(err);
+            }
+            else if (onError) {
+                onError(err);
+            }
+        });
+        const cleanup = () => {
+            process.removeListener('SIGINT', handleSignal);
+            process.removeListener('SIGTERM', handleSignal);
+        };
+        const handleSignal = () => {
+            proc.kill('SIGTERM');
+        };
+        process.on('SIGINT', handleSignal);
+        process.on('SIGTERM', handleSignal);
+        proc.on('close', (code) => {
+            clearTimeout(connectionTimeout);
+            cleanup();
+            if (!connected) {
+                reject(new Error(`SSH failed: ${errorOutput || `exit code ${code}`}`));
+            }
+            else {
+                if (onDisconnect) {
+                    onDisconnect(code || 0);
+                }
+                resolve();
+            }
+        });
+    });
+}
+export function formatPortForwards(forwards) {
+    return forwards
+        .map((f) => f.localPort === f.remotePort ? String(f.localPort) : `${f.localPort}:${f.remotePort}`)
+        .join(', ');
+}

package/dist/client/shell.js

@@ -0,0 +1,71 @@
+import { spawn } from 'child_process';
+function extractHost(worker) {
+    let host = worker;
+    if (host.startsWith('http://')) {
+        host = host.slice(7);
+    }
+    else if (host.startsWith('https://')) {
+        host = host.slice(8);
+    }
+    if (host.includes(':')) {
+        host = host.split(':')[0];
+    }
+    return host;
+}
+export async function openSSHShell(options) {
+    const { worker, sshPort, user = 'workspace', onConnect, onDisconnect, onError } = options;
+    const host = extractHost(worker);
+    return new Promise((resolve, reject) => {
+        const sshArgs = [
+            '-o',
+            'StrictHostKeyChecking=no',
+            '-o',
+            'UserKnownHostsFile=/dev/null',
+            '-o',
+            'LogLevel=ERROR',
+            '-p',
+            String(sshPort),
+            `${user}@${host}`,
+        ];
+        const proc = spawn('ssh', sshArgs, {
+            stdio: 'inherit',
+        });
+        let connected = false;
+        const connectionTimeout = setTimeout(() => {
+            if (!connected) {
+                proc.kill();
+                reject(new Error('SSH connection timeout'));
+            }
+        }, 30000);
+        setTimeout(() => {
+            if (proc.exitCode === null) {
+                connected = true;
+                clearTimeout(connectionTimeout);
+                if (onConnect) {
+                    onConnect();
+                }
+            }
+        }, 500);
+        proc.on('error', (err) => {
+            clearTimeout(connectionTimeout);
+            if (!connected) {
+                reject(err);
+            }
+            else if (onError) {
+                onError(err);
+            }
+        });
+        proc.on('close', (code) => {
+            clearTimeout(connectionTimeout);
+            if (!connected && code !== 0) {
+                reject(new Error(`SSH failed with exit code ${code}`));
+            }
+            else {
+                if (onDisconnect) {
+                    onDisconnect(code || 0);
+                }
+                resolve();
+            }
+        });
+    });
+}

package/dist/client/ws-shell.js

@@ -0,0 +1,120 @@
+import WebSocket from 'ws';
+import { spawn } from 'child_process';
+export function isLocalWorker(worker) {
+    const host = worker
+        .replace(/^https?:\/\//, '')
+        .split(':')[0]
+        .toLowerCase();
+    return host === 'localhost' || host === '127.0.0.1';
+}
+export async function openDockerExec(options) {
+    const { containerName, onConnect, onDisconnect, onError } = options;
+    return new Promise((resolve, reject) => {
+        const args = [
+            'exec',
+            '-it',
+            '-u',
+            'workspace',
+            '-e',
+            'TERM=xterm-256color',
+            containerName,
+            '/bin/bash',
+            '-l',
+        ];
+        const proc = spawn('docker', args, {
+            stdio: 'inherit',
+        });
+        let connected = false;
+        setTimeout(() => {
+            if (proc.exitCode === null) {
+                connected = true;
+                if (onConnect)
+                    onConnect();
+            }
+        }, 100);
+        proc.on('error', (err) => {
+            if (!connected) {
+                reject(err);
+            }
+            else if (onError) {
+                onError(err);
+            }
+        });
+        proc.on('close', (code) => {
+            if (onDisconnect)
+                onDisconnect(code || 0);
+            resolve();
+        });
+    });
+}
+export async function openWSShell(options) {
+    const { url, onConnect, onDisconnect, onError } = options;
+    return new Promise((resolve, reject) => {
+        const ws = new WebSocket(url);
+        let connected = false;
+        const stdin = process.stdin;
+        const stdout = process.stdout;
+        const sendResize = () => {
+            if (ws.readyState === WebSocket.OPEN && stdout.columns && stdout.rows) {
+                ws.send(JSON.stringify({ type: 'resize', cols: stdout.columns, rows: stdout.rows }));
+            }
+        };
+        ws.on('open', () => {
+            connected = true;
+            if (stdin.isTTY) {
+                stdin.setRawMode(true);
+            }
+            stdin.resume();
+            sendResize();
+            if (onConnect) {
+                onConnect();
+            }
+        });
+        ws.on('message', (data) => {
+            const text = typeof data === 'string' ? data : data.toString();
+            stdout.write(text);
+        });
+        ws.on('close', (code) => {
+            if (stdin.isTTY) {
+                stdin.setRawMode(false);
+            }
+            stdin.pause();
+            if (onDisconnect) {
+                onDisconnect(code);
+            }
+            resolve();
+        });
+        ws.on('error', (err) => {
+            if (!connected) {
+                reject(err);
+            }
+            else if (onError) {
+                onError(err);
+            }
+        });
+        stdin.on('data', (data) => {
+            if (ws.readyState === WebSocket.OPEN) {
+                ws.send(data);
+            }
+        });
+        stdout.on('resize', sendResize);
+        const cleanup = () => {
+            stdout.removeListener('resize', sendResize);
+            if (stdin.isTTY) {
+                stdin.setRawMode(false);
+            }
+            ws.close();
+        };
+        process.on('SIGINT', cleanup);
+        process.on('SIGTERM', cleanup);
+    });
+}
+export function getTerminalWSUrl(worker, workspaceName) {
+    let base = worker;
+    if (!base.startsWith('http://') && !base.startsWith('https://')) {
+        base = `http://${base}`;
+    }
+    const wsProtocol = base.startsWith('https://') ? 'wss://' : 'ws://';
+    const host = base.replace(/^https?:\/\//, '');
+    return `${wsProtocol}${host}/rpc/terminal/${encodeURIComponent(workspaceName)}`;
+}

package/dist/config/loader.js

@@ -0,0 +1,59 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import { DEFAULT_CONFIG_DIR, CONFIG_FILE } from '../shared/types';
+import { DEFAULT_AGENT_PORT } from '../shared/constants';
+export function getConfigDir(configDir) {
+    return configDir || process.env.WS_CONFIG_DIR || DEFAULT_CONFIG_DIR;
+}
+export async function ensureConfigDir(configDir) {
+    const dir = getConfigDir(configDir);
+    await fs.mkdir(dir, { recursive: true });
+}
+export function createDefaultAgentConfig() {
+    return {
+        port: DEFAULT_AGENT_PORT,
+        credentials: {
+            env: {},
+            files: {},
+        },
+        scripts: {},
+        agents: {},
+        allowHostAccess: true,
+    };
+}
+export async function loadAgentConfig(configDir) {
+    const dir = getConfigDir(configDir);
+    const configPath = path.join(dir, CONFIG_FILE);
+    try {
+        const content = await fs.readFile(configPath, 'utf-8');
+        const config = JSON.parse(content);
+        return {
+            port: config.port || DEFAULT_AGENT_PORT,
+            credentials: {
+                env: config.credentials?.env || {},
+                files: config.credentials?.files || {},
+            },
+            scripts: config.scripts || {},
+            agents: config.agents || {},
+            allowHostAccess: config.allowHostAccess ?? true,
+        };
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            return createDefaultAgentConfig();
+        }
+        throw err;
+    }
+}
+export async function saveAgentConfig(config, configDir) {
+    const dir = getConfigDir(configDir);
+    await ensureConfigDir(dir);
+    const configPath = path.join(dir, CONFIG_FILE);
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2), 'utf-8');
+}
+export function expandPath(filePath) {
+    if (filePath.startsWith('~/')) {
+        return path.join(process.env.HOME || '', filePath.slice(2));
+    }
+    return filePath;
+}