atoo-studio 0.0.1 → 0.0.2

package/dist/src/services/ssh-manager.js

@@ -0,0 +1,359 @@
+import { Client } from 'ssh2';
+import fs from 'fs';
+import net from 'net';
+import { CA_CERT_PATH, PROXY_PORT } from '../config.js';
+import { deobfuscate } from './obfuscation.js';
+class SshManager {
+    connections = new Map();
+    async connect(config) {
+        if (this.connections.has(config.id) && this.connections.get(config.id).connected) {
+            return;
+        }
+        const client = new Client();
+        const connectConfig = {
+            host: config.host,
+            port: config.port,
+            username: config.username,
+        };
+        if (config.auth_method === 'password' && config.password_obfuscated) {
+            connectConfig.password = deobfuscate(config.password_obfuscated);
+        }
+        else if (config.auth_method === 'privatekey' && config.private_key_obfuscated) {
+            connectConfig.privateKey = deobfuscate(config.private_key_obfuscated);
+            if (config.passphrase_obfuscated) {
+                connectConfig.passphrase = deobfuscate(config.passphrase_obfuscated);
+            }
+        }
+        else if (config.auth_method === 'systemkey' && config.system_key_path) {
+            connectConfig.privateKey = fs.readFileSync(config.system_key_path, 'utf-8');
+            if (config.passphrase_obfuscated) {
+                connectConfig.passphrase = deobfuscate(config.passphrase_obfuscated);
+            }
+        }
+        const active = {
+            id: config.id,
+            client,
+            config,
+            connected: false,
+            reverseTunnelServers: [],
+            forwardTunnels: new Map(),
+        };
+        this.connections.set(config.id, active);
+        return new Promise((resolve, reject) => {
+            client.on('ready', async () => {
+                console.log(`[ssh] Connected to ${config.host}:${config.port} as ${config.username}`);
+                active.connected = true;
+                try {
+                    // Setup reverse tunnels so remote claude can reach our proxy
+                    await this.setupReverseTunnel(config.id, 3000, 3010);
+                    await this.setupReverseTunnel(config.id, PROXY_PORT, PROXY_PORT);
+                    // Upload CA cert to remote
+                    await this.uploadCaCert(config.id);
+                    resolve();
+                }
+                catch (err) {
+                    console.error(`[ssh] Post-connect setup failed:`, err.message);
+                    resolve(); // still connected, just tunnel setup failed
+                }
+            });
+            client.on('error', (err) => {
+                console.error(`[ssh] Connection error for ${config.id}:`, err.message);
+                active.connected = false;
+                active.error = err.message;
+                if (!active.connected)
+                    reject(err);
+            });
+            client.on('end', () => {
+                console.log(`[ssh] Connection ended for ${config.id}`);
+                active.connected = false;
+                this.cleanupConnection(config.id);
+            });
+            client.on('close', () => {
+                active.connected = false;
+                this.cleanupConnection(config.id);
+            });
+            client.connect(connectConfig);
+        });
+    }
+    async disconnect(id) {
+        const active = this.connections.get(id);
+        if (!active)
+            return;
+        this.cleanupConnection(id);
+        active.client.end();
+        this.connections.delete(id);
+        console.log(`[ssh] Disconnected ${id}`);
+    }
+    async disconnectAll() {
+        for (const id of Array.from(this.connections.keys())) {
+            await this.disconnect(id);
+        }
+    }
+    isConnected(id) {
+        return this.connections.get(id)?.connected ?? false;
+    }
+    getStatus(id) {
+        const active = this.connections.get(id);
+        if (!active)
+            return { connected: false };
+        return { connected: active.connected, error: active.error };
+    }
+    // SFTP operations
+    async getSftp(id) {
+        const active = this.connections.get(id);
+        if (!active || !active.connected)
+            throw new Error('SSH not connected');
+        if (active.sftp)
+            return active.sftp;
+        return new Promise((resolve, reject) => {
+            active.client.sftp((err, sftp) => {
+                if (err)
+                    return reject(err);
+                active.sftp = sftp;
+                resolve(sftp);
+            });
+        });
+    }
+    async sftpReaddir(id, dirPath) {
+        const sftp = await this.getSftp(id);
+        return new Promise((resolve, reject) => {
+            sftp.readdir(dirPath, (err, list) => {
+                if (err)
+                    return reject(err);
+                const entries = list
+                    .filter(item => !item.filename.startsWith('.'))
+                    .map(item => ({
+                    name: item.filename,
+                    type: item.attrs.isDirectory() ? 'dir' : 'file',
+                    size: item.attrs.size,
+                }))
+                    .sort((a, b) => {
+                    if (a.type !== b.type)
+                        return a.type === 'dir' ? -1 : 1;
+                    return a.name.localeCompare(b.name);
+                });
+                resolve(entries);
+            });
+        });
+    }
+    async sftpMkdir(id, dirPath) {
+        const sftp = await this.getSftp(id);
+        return new Promise((resolve, reject) => {
+            sftp.mkdir(dirPath, (err) => {
+                if (err)
+                    return reject(err);
+                resolve();
+            });
+        });
+    }
+    async sftpReadFile(id, filePath) {
+        const sftp = await this.getSftp(id);
+        return new Promise((resolve, reject) => {
+            let data = '';
+            const stream = sftp.createReadStream(filePath, { encoding: 'utf8' });
+            stream.on('data', (chunk) => { data += chunk; });
+            stream.on('end', () => resolve(data));
+            stream.on('error', reject);
+        });
+    }
+    async sftpWriteFile(id, filePath, content) {
+        const sftp = await this.getSftp(id);
+        return new Promise((resolve, reject) => {
+            const stream = sftp.createWriteStream(filePath);
+            stream.on('close', () => resolve());
+            stream.on('error', reject);
+            stream.end(content);
+        });
+    }
+    async sftpStat(id, filePath) {
+        const sftp = await this.getSftp(id);
+        return new Promise((resolve, reject) => {
+            sftp.stat(filePath, (err, stats) => {
+                if (err)
+                    return reject(err);
+                resolve(stats);
+            });
+        });
+    }
+    async sftpUnlink(id, filePath) {
+        const sftp = await this.getSftp(id);
+        return new Promise((resolve, reject) => {
+            sftp.unlink(filePath, (err) => {
+                if (err)
+                    return reject(err);
+                resolve();
+            });
+        });
+    }
+    async sftpRmdir(id, dirPath) {
+        const sftp = await this.getSftp(id);
+        return new Promise((resolve, reject) => {
+            sftp.rmdir(dirPath, (err) => {
+                if (err)
+                    return reject(err);
+                resolve();
+            });
+        });
+    }
+    async sftpRename(id, oldPath, newPath) {
+        const sftp = await this.getSftp(id);
+        return new Promise((resolve, reject) => {
+            sftp.rename(oldPath, newPath, (err) => {
+                if (err)
+                    return reject(err);
+                resolve();
+            });
+        });
+    }
+    // Exec
+    async exec(id, cmd, opts) {
+        const active = this.connections.get(id);
+        if (!active || !active.connected)
+            throw new Error('SSH not connected');
+        const fullCmd = opts?.cwd ? `cd ${shellEscape(opts.cwd)} && ${cmd}` : cmd;
+        return new Promise((resolve, reject) => {
+            active.client.exec(fullCmd, (err, stream) => {
+                if (err)
+                    return reject(err);
+                let stdout = '';
+                let stderr = '';
+                stream.on('data', (data) => { stdout += data.toString(); });
+                stream.stderr.on('data', (data) => { stderr += data.toString(); });
+                stream.on('close', (code) => {
+                    if (code !== 0 && stderr) {
+                        reject(new Error(stderr.trim() || `Command failed with code ${code}`));
+                    }
+                    else {
+                        resolve(stdout);
+                    }
+                });
+            });
+        });
+    }
+    async execPty(id, cmd, opts) {
+        const active = this.connections.get(id);
+        if (!active || !active.connected)
+            throw new Error('SSH not connected');
+        const fullCmd = opts.cwd ? `cd ${shellEscape(opts.cwd)} && ${cmd}` : cmd;
+        const envVars = opts.env || {};
+        return new Promise((resolve, reject) => {
+            active.client.exec(fullCmd, {
+                pty: {
+                    rows: opts.rows || 30,
+                    cols: opts.cols || 120,
+                    term: 'xterm-256color',
+                },
+                env: envVars,
+            }, (err, stream) => {
+                if (err)
+                    return reject(err);
+                resolve(stream);
+            });
+        });
+    }
+    // Reverse tunnel: remote:remotePort -> local:localPort
+    async setupReverseTunnel(id, remotePort, localPort) {
+        const active = this.connections.get(id);
+        if (!active || !active.connected)
+            throw new Error('SSH not connected');
+        // Register tcp connection handler before requesting forwarding
+        active.client.on('tcp connection', (info, accept, _reject) => {
+            if (info.destPort === remotePort) {
+                const channel = accept();
+                const socket = net.createConnection(localPort, '127.0.0.1', () => {
+                    channel.pipe(socket);
+                    socket.pipe(channel);
+                });
+                socket.on('error', () => channel.close());
+                channel.on('error', () => socket.destroy());
+            }
+        });
+        return new Promise((resolve, reject) => {
+            active.client.forwardIn('127.0.0.1', remotePort, (err) => {
+                if (err) {
+                    console.warn(`[ssh] Failed to set up reverse tunnel ${remotePort} -> ${localPort}:`, err.message);
+                    return reject(err);
+                }
+                console.log(`[ssh] Reverse tunnel: remote:${remotePort} -> local:${localPort}`);
+                resolve();
+            });
+        });
+    }
+    // Forward tunnel: on-demand, for port proxy
+    async getOrCreateForwardTunnel(id, remotePort) {
+        const active = this.connections.get(id);
+        if (!active || !active.connected)
+            throw new Error('SSH not connected');
+        const existing = active.forwardTunnels.get(remotePort);
+        if (existing)
+            return existing.localPort;
+        // Create a local TCP server that pipes through SSH forwardOut
+        return new Promise((resolve, reject) => {
+            const server = net.createServer((localSocket) => {
+                active.client.forwardOut('127.0.0.1', 0, '127.0.0.1', remotePort, (err, stream) => {
+                    if (err) {
+                        localSocket.destroy();
+                        return;
+                    }
+                    localSocket.pipe(stream);
+                    stream.pipe(localSocket);
+                    localSocket.on('error', () => stream.close());
+                    stream.on('error', () => localSocket.destroy());
+                });
+            });
+            server.listen(0, '127.0.0.1', () => {
+                const localPort = server.address().port;
+                active.forwardTunnels.set(remotePort, { localPort, server });
+                console.log(`[ssh] Forward tunnel: local:${localPort} -> remote:${remotePort}`);
+                resolve(localPort);
+            });
+            server.on('error', reject);
+        });
+    }
+    // Upload CA cert to remote
+    async uploadCaCert(id) {
+        try {
+            const certContent = fs.readFileSync(CA_CERT_PATH, 'utf-8');
+            await this.exec(id, 'mkdir -p ~/.atoo-studio');
+            await this.sftpWriteFile(id, '.atoo-studio/ca.pem', certContent);
+            console.log(`[ssh] Uploaded CA cert to remote ~/.atoo-studio/ca.pem`);
+        }
+        catch (err) {
+            console.warn(`[ssh] Failed to upload CA cert:`, err.message);
+        }
+    }
+    // Verify claude CLI exists on remote
+    async verifyClaudeCli(id) {
+        try {
+            await this.exec(id, 'which claude');
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    cleanupConnection(id) {
+        const active = this.connections.get(id);
+        if (!active)
+            return;
+        for (const server of active.reverseTunnelServers) {
+            try {
+                server.close();
+            }
+            catch { }
+        }
+        active.reverseTunnelServers = [];
+        for (const [, tunnel] of active.forwardTunnels) {
+            try {
+                tunnel.server.close();
+            }
+            catch { }
+        }
+        active.forwardTunnels.clear();
+        active.sftp = undefined;
+    }
+}
+function shellEscape(s) {
+    return "'" + s.replace(/'/g, "'\\''") + "'";
+}
+export const sshManager = new SshManager();

package/dist/src/session-writer.d.ts

@@ -0,0 +1,9 @@
+import type { Session } from './state/types.js';
+/**
+ * Write forked session events as a JSONL file to Claude's session storage.
+ * Path: ~/.claude/projects/<project-dir-hash>/<session-uuid>.jsonl
+ *
+ * Rewrites sessionId fields to match the new session, and generates fresh
+ * UUIDs for each event while maintaining the parentUuid chain.
+ */
+export declare function writeSessionJsonl(session: Session, directory: string): string;

package/dist/src/session-writer.js

@@ -0,0 +1,66 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import crypto from 'crypto';
+import { v4 as uuidv4 } from 'uuid';
+/**
+ * Convert an absolute directory path to the Claude project dir hash format.
+ * Replaces all non-alphanumeric chars with '-'.
+ * e.g. /home/furti/myproject → -home-furti-myproject
+ * Truncates at 200 chars with a hash suffix for very long paths.
+ */
+function projectDirHash(directory) {
+    const hashed = directory.replace(/[^a-zA-Z0-9]/g, '-');
+    if (hashed.length <= 200)
+        return hashed;
+    const suffix = crypto.createHash('sha256').update(directory).digest('hex').slice(0, 12);
+    return `${hashed.slice(0, 200)}-${suffix}`;
+}
+/**
+ * Extract the UUID portion from a session ID (strip "sess_" prefix).
+ */
+function sessionUuid(sessionId) {
+    return sessionId.replace(/^sess_/, '');
+}
+/**
+ * Write forked session events as a JSONL file to Claude's session storage.
+ * Path: ~/.claude/projects/<project-dir-hash>/<session-uuid>.jsonl
+ *
+ * Rewrites sessionId fields to match the new session, and generates fresh
+ * UUIDs for each event while maintaining the parentUuid chain.
+ */
+export function writeSessionJsonl(session, directory) {
+    const dirHash = projectDirHash(path.resolve(directory));
+    const projectDir = path.join(os.homedir(), '.claude', 'projects', dirHash);
+    const uuid = sessionUuid(session.id);
+    const jsonlPath = path.join(projectDir, `${uuid}.jsonl`);
+    // Ensure directory exists
+    fs.mkdirSync(projectDir, { recursive: true });
+    // Build UUID remap: old UUID → new UUID (preserves parentUuid chain)
+    const uuidMap = new Map();
+    for (const event of session.events) {
+        if (event.uuid) {
+            uuidMap.set(event.uuid, uuidv4());
+        }
+    }
+    const lines = [];
+    for (const event of session.events) {
+        const rewritten = { ...event };
+        // Rewrite sessionId to the new forked session UUID (Claude Code uses camelCase, no "sess_" prefix)
+        rewritten.sessionId = uuid;
+        // Remove legacy underscore field if present
+        delete rewritten.session_id;
+        // Rewrite uuid to fresh UUID
+        if (rewritten.uuid && uuidMap.has(rewritten.uuid)) {
+            rewritten.uuid = uuidMap.get(rewritten.uuid);
+        }
+        // Rewrite parentUuid chain
+        if (rewritten.parentUuid && uuidMap.has(rewritten.parentUuid)) {
+            rewritten.parentUuid = uuidMap.get(rewritten.parentUuid);
+        }
+        lines.push(JSON.stringify(rewritten));
+    }
+    fs.writeFileSync(jsonlPath, lines.join('\n') + '\n');
+    console.log(`[session-writer] Wrote ${lines.length} events to ${jsonlPath}`);
+    return jsonlPath;
+}

package/dist/src/spawner.d.ts

@@ -0,0 +1,56 @@
+export interface ITerminal {
+    write(data: string): void;
+    resize(cols: number, rows: number): void;
+    kill(): void;
+    onData(handler: (data: string) => void): {
+        dispose(): void;
+    };
+    onExit(handler: (exit: {
+        exitCode: number;
+    }) => void): {
+        dispose(): void;
+    };
+    pid?: number;
+}
+export interface SpawnOptions {
+    command: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+    cols?: number;
+    rows?: number;
+    envId?: string;
+    preloadSessionId?: string;
+    logPrefix?: string;
+}
+/**
+ * Generic PTY spawn. Returns an envId immediately.
+ * Scrollback and process tracking are managed automatically.
+ */
+export declare function spawnProcess(options: SpawnOptions): {
+    envId: string;
+    term: ITerminal;
+    pid: number;
+};
+/**
+ * Spawn a remote process via SSH. Returns the same tracked structure.
+ */
+export declare function spawnRemoteProcess(options: {
+    sshConnectionId: string;
+    command: string;
+    cwd: string;
+    cols?: number;
+    rows?: number;
+    envId?: string;
+    logPrefix?: string;
+}): Promise<{
+    envId: string;
+    term: ITerminal;
+}>;
+export declare function getScrollback(envId: string): string;
+export declare function getProcessPid(envId: string): number | undefined;
+export declare function getPreloadSessionId(envId: string): string | undefined;
+export declare function killCliProcess(envId: string): boolean;
+export declare function killAllCliProcesses(): void;
+export declare function getPty(envId: string): ITerminal | undefined;
+export declare function getEnvIdForSession(sessionId: string): string | undefined;

package/dist/src/spawner.js

@@ -0,0 +1,135 @@
+import * as pty from 'node-pty';
+import os from 'os';
+import { v4 as uuidv4 } from 'uuid';
+import { sshManager } from './services/ssh-manager.js';
+import { store } from './state/store.js';
+class SshTerminalAdapter {
+    channel;
+    pid = undefined;
+    constructor(channel) {
+        this.channel = channel;
+    }
+    write(data) { this.channel.write(data); }
+    resize(cols, rows) { this.channel.setWindow(rows, cols, rows * 16, cols * 8); }
+    kill() { this.channel.close(); }
+    onData(handler) {
+        const cb = (data) => handler(data.toString());
+        this.channel.on('data', cb);
+        return { dispose: () => { this.channel.off('data', cb); } };
+    }
+    onExit(handler) {
+        const cb = (code) => handler({ exitCode: code ?? 1 });
+        this.channel.on('exit', cb);
+        return { dispose: () => { } };
+    }
+}
+const spawnedProcesses = new Map();
+const MAX_SPAWNER_SCROLLBACK = 200_000;
+const spawnerScrollback = new Map();
+/**
+ * Generic PTY spawn. Returns an envId immediately.
+ * Scrollback and process tracking are managed automatically.
+ */
+export function spawnProcess(options) {
+    const cwd = options.cwd || process.env.HOME || os.homedir();
+    const envId = options.envId || `proc_${uuidv4()}`;
+    const logPrefix = options.logPrefix || options.command;
+    const term = pty.spawn(options.command, options.args || [], {
+        name: 'xterm-256color',
+        cols: options.cols || 120,
+        rows: options.rows || 30,
+        cwd,
+        env: (options.env || { ...process.env }),
+    });
+    const pid = term.pid;
+    console.log(`[spawner] Started ${logPrefix} (pid=${pid}, envId=${envId}): ${options.command} ${(options.args || []).join(' ')}`);
+    spawnedProcesses.set(envId, { pty: term, envId, pid, preloadSessionId: options.preloadSessionId });
+    spawnerScrollback.set(envId, '');
+    // Scrollback buffer (activity tracking is handled by agent adapters via PtyActivityTracker)
+    term.onData((data) => {
+        let buf = spawnerScrollback.get(envId) || '';
+        buf += data;
+        if (buf.length > MAX_SPAWNER_SCROLLBACK)
+            buf = buf.slice(-MAX_SPAWNER_SCROLLBACK);
+        spawnerScrollback.set(envId, buf);
+    });
+    term.onExit(({ exitCode }) => {
+        console.log(`[spawner] ${logPrefix} (pid=${pid}) exited with code ${exitCode}`);
+        spawnedProcesses.delete(envId);
+        spawnerScrollback.delete(envId);
+    });
+    return { envId, term, pid };
+}
+/**
+ * Spawn a remote process via SSH. Returns the same tracked structure.
+ */
+export async function spawnRemoteProcess(options) {
+    const envId = options.envId || `remote_${uuidv4()}`;
+    const logPrefix = options.logPrefix || 'remote';
+    if (!sshManager.isConnected(options.sshConnectionId)) {
+        throw new Error('SSH connection not active');
+    }
+    const channel = await sshManager.execPty(options.sshConnectionId, options.command, {
+        cwd: options.cwd,
+        rows: options.rows || 30,
+        cols: options.cols || 120,
+    });
+    const term = new SshTerminalAdapter(channel);
+    console.log(`[spawner] Started ${logPrefix} via SSH (envId=${envId}): ${options.command}`);
+    spawnedProcesses.set(envId, { pty: term, envId, pid: 0 });
+    spawnerScrollback.set(envId, '');
+    term.onData((data) => {
+        let buf = spawnerScrollback.get(envId) || '';
+        buf += data;
+        if (buf.length > MAX_SPAWNER_SCROLLBACK)
+            buf = buf.slice(-MAX_SPAWNER_SCROLLBACK);
+        spawnerScrollback.set(envId, buf);
+    });
+    term.onExit(({ exitCode }) => {
+        console.log(`[spawner] ${logPrefix} via SSH exited with code ${exitCode}`);
+        spawnedProcesses.delete(envId);
+        spawnerScrollback.delete(envId);
+    });
+    return { envId, term };
+}
+// ═══════════════════════════════════════════════════════
+// Process registry queries
+// ═══════════════════════════════════════════════════════
+export function getScrollback(envId) {
+    return spawnerScrollback.get(envId) || '';
+}
+export function getProcessPid(envId) {
+    return spawnedProcesses.get(envId)?.pid;
+}
+export function getPreloadSessionId(envId) {
+    return spawnedProcesses.get(envId)?.preloadSessionId;
+}
+export function killCliProcess(envId) {
+    const proc = spawnedProcesses.get(envId);
+    if (proc) {
+        proc.pty.kill();
+        spawnedProcesses.delete(envId);
+        spawnerScrollback.delete(envId);
+        console.log(`[spawner] Killed process for ${envId}`);
+        return true;
+    }
+    return false;
+}
+export function killAllCliProcesses() {
+    for (const [id, proc] of Array.from(spawnedProcesses.entries())) {
+        console.log(`[spawner] Killing process for ${id}`);
+        proc.pty.kill();
+    }
+    spawnedProcesses.clear();
+    spawnerScrollback.clear();
+}
+export function getPty(envId) {
+    return spawnedProcesses.get(envId)?.pty;
+}
+export function getEnvIdForSession(sessionId) {
+    const session = store.sessions.get(sessionId);
+    if (session && spawnedProcesses.has(session.environmentId)) {
+        return session.environmentId;
+    }
+    return undefined;
+}