bridge-agent 0.2.10 → 0.3.0

package/dist/__tests__/pty-manager.test.d.ts

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

package/dist/__tests__/pty-manager.test.js

@@ -0,0 +1,75 @@
+import { describe, test, expect, mock, beforeEach, afterEach } from 'bun:test';
+import { EventEmitter } from 'node:events';
+const killCalls = [];
+const spawned = [];
+class FakePty extends EventEmitter {
+    pid;
+    writes = [];
+    resizes = [];
+    constructor(pid) {
+        super();
+        this.pid = pid;
+    }
+    write(data) {
+        this.writes.push(data);
+    }
+    resize(cols, rows) {
+        this.resizes.push({ cols, rows });
+    }
+    kill() {
+        this.emit('exit', { exitCode: null, signal: 'SIGTERM' });
+    }
+    onData(handler) {
+        this.on('data', handler);
+    }
+    onExit(handler) {
+        this.on('exit', handler);
+    }
+}
+mock.module('node-pty', () => ({
+    spawn: mock(() => {
+        const pty = new FakePty(1000 + spawned.length);
+        spawned.push(pty);
+        return pty;
+    }),
+}));
+const realKill = process.kill;
+const killMock = mock((pid, signal) => {
+    killCalls.push({ pid, signal });
+});
+const { PtyManager } = await import('../pty/manager.js');
+describe('PtyManager duplicate spawn recovery', () => {
+    beforeEach(() => {
+        spawned.length = 0;
+        killCalls.length = 0;
+        process.kill = killMock;
+    });
+    afterEach(() => {
+        process.kill = realKill;
+        killMock.mockClear();
+    });
+    test('replaces an existing handle instead of rejecting the second spawn', () => {
+        const manager = new PtyManager();
+        const outputs = [];
+        const exits = [];
+        const first = manager.spawn('panel-1', 'claude', '/bin/claude', [], 80, 24, data => outputs.push(`first:${data}`), (exitCode, signal) => exits.push({ exitCode, signal }));
+        const second = manager.spawn('panel-1', 'claude', '/bin/claude', [], 100, 30, data => outputs.push(`second:${data}`), (exitCode, signal) => exits.push({ exitCode, signal }));
+        expect(first).toBe(true);
+        expect(second).toBe(true);
+        expect(spawned.length).toBe(2);
+        expect(killCalls.length).toBeGreaterThan(0);
+        expect(killCalls[0]?.pid).toBe(-1000);
+        spawned[0].emit('data', 'old-output');
+        spawned[0].emit('exit', { exitCode: 0, signal: null });
+        spawned[1].emit('data', 'new-output');
+        expect(outputs).toEqual([Buffer.from('new-output').toString('base64')].map(v => `second:${v}`));
+        expect(exits).toEqual([]);
+    });
+    test('kill removes the active handle so a later spawn stays clean', () => {
+        const manager = new PtyManager();
+        expect(manager.spawn('panel-2', 'sh', '/bin/sh', [], 80, 24, () => { }, () => { })).toBe(true);
+        manager.kill('panel-2', true);
+        expect(manager.spawn('panel-2', 'sh', '/bin/sh', [], 80, 24, () => { }, () => { })).toBe(true);
+        expect(spawned.length).toBe(2);
+    });
+});

package/dist/commands/auth.d.ts

@@ -0,0 +1 @@
+export declare function runAuth(serverUrl: string, noBrowser?: boolean, providedToken?: string): Promise<void>;

package/dist/commands/auth.js

@@ -0,0 +1,88 @@
+import https from 'https';
+import http from 'http';
+import { saveConfig } from '../config.js';
+function sanitizeToken(raw) {
+    return (raw ?? '').trim();
+}
+export async function runAuth(serverUrl, noBrowser = false, providedToken) {
+    console.log('[bridge] Starting auth flow...');
+    console.log(`[bridge] Server: ${serverUrl}`);
+    console.log('[bridge] Open this URL to generate a daemon token:');
+    console.log(`  ${serverUrl}/connect`);
+    const inlineToken = sanitizeToken(providedToken);
+    if (inlineToken) {
+        console.log('[bridge] Using token from --token');
+    }
+    if (noBrowser) {
+        if (inlineToken) {
+            console.log('[bridge] --no-browser ignored because --token is provided.');
+        }
+        else {
+            console.log('[bridge] --no-browser: exiting after printing URL.');
+            process.exit(0);
+        }
+    }
+    let token = inlineToken;
+    if (!token) {
+        console.log();
+        console.log('[bridge] After authenticating, paste your token here:');
+        token = await promptToken();
+    }
+    if (!token) {
+        console.error('[bridge] No token provided. Exiting.');
+        process.exit(1);
+    }
+    // Validate token with server
+    const isValid = await validateToken(serverUrl, token);
+    if (!isValid) {
+        console.error('[bridge] Token validation failed. Please try again.');
+        process.exit(1);
+    }
+    const wsBase = serverUrl.replace(/^https?:\/\//, (match) => match.startsWith('https') ? 'wss://' : 'ws://');
+    const wsUrl = wsBase.replace(/\/?$/, '/ws/daemon');
+    saveConfig({
+        server: wsUrl,
+        token,
+        name: process.env['HOSTNAME'] ?? 'My Machine',
+    });
+    console.log('[bridge] Auth successful! Config saved to ~/.bridge/config.json');
+    console.log('[bridge] Run: bridge-agent start');
+    process.exit(0);
+}
+async function promptToken() {
+    return new Promise(resolve => {
+        process.stdout.write('Token: ');
+        let input = '';
+        process.stdin.setEncoding('utf-8');
+        process.stdin.on('data', (chunk) => {
+            input += chunk;
+            if (input.includes('\n')) {
+                process.stdin.pause();
+                resolve(input.trim());
+            }
+        });
+        process.stdin.resume();
+    });
+}
+async function validateToken(serverUrl, token) {
+    return new Promise(resolve => {
+        const url = new URL('/api/tokens/validate', serverUrl);
+        const isHttps = url.protocol === 'https:';
+        const lib = isHttps ? https : http;
+        const options = {
+            hostname: url.hostname,
+            port: url.port || (isHttps ? 443 : 80),
+            path: url.pathname,
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${token}`,
+            },
+        };
+        const req = lib.request(options, (res) => {
+            resolve(res.statusCode === 200);
+        });
+        req.on('error', () => resolve(false));
+        req.end();
+    });
+}

package/dist/commands/start.d.ts

@@ -0,0 +1 @@
+export declare function runStart(): void;

package/dist/commands/start.js

@@ -0,0 +1,258 @@
+import { createServer } from 'node:http';
+import { execSync, spawn } from 'node:child_process';
+import { writeFileSync, readFileSync, existsSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import path from 'path';
+import { PtyManager } from '../pty/manager.js';
+import { startDaemonConnection, isDaemonWsConnected } from '../ws/client.js';
+const PLIST_NAME = 'com.jerico.bridge-agent.plist';
+const LAUNCH_AGENTS = path.join(homedir(), 'Library', 'LaunchAgents');
+const PLIST_PATH = path.join(LAUNCH_AGENTS, PLIST_NAME);
+const LOG_OUT = path.join(homedir(), 'bridge-daemon.log');
+const LOG_ERR = path.join(homedir(), 'bridge-daemon.err.log');
+const LOCK_PATH = path.join(homedir(), '.bridge', 'daemon.lock');
+function getDaemonEntry() {
+    // Prefer the global npm install — use npm root to find the canonical path.
+    // Falls back to argv[1] realpath (works when run directly by Node).
+    // Last resort: process.execPath (Node.js binary itself).
+    const candidates = [
+        ...(process.env.npm_config_global_prefix
+            ? [path.join(process.env.npm_config_global_prefix, 'lib', 'node_modules', 'bridge-agent', 'dist', 'index.js')]
+            : []),
+        ...(process.argv[1] ? [process.argv[1]] : []),
+        process.execPath,
+    ];
+    for (const p of candidates) {
+        try {
+            return require('node:fs').realpathSync(p);
+        }
+        catch { /* try next */ }
+    }
+    return process.execPath;
+}
+/**
+ * Acquire a lock to prevent multiple daemon instances.
+ * Uses a simple PID file — if the stored PID is still running, refuse to start.
+ * Returns true if lock acquired, false if another instance is already running.
+ */
+function acquireDaemonLock() {
+    try {
+        mkdirSync(path.dirname(LOCK_PATH), { recursive: true });
+    }
+    catch { /* exists */ }
+    if (existsSync(LOCK_PATH)) {
+        try {
+            const { pid } = JSON.parse(readFileSync(LOCK_PATH, 'utf8'));
+            if (pid && process.kill(pid, 0)) {
+                console.warn('[bridge] daemon.already.running', { pid, lock: LOCK_PATH });
+                return false;
+            }
+        }
+        catch { /* stale lock — overwrite */ }
+    }
+    writeFileSync(LOCK_PATH, JSON.stringify({ pid: process.pid, startedAt: Date.now() }), 'utf8');
+    return true;
+}
+function getShellPath() {
+    // Get the user's full PATH by running 'which' for known binaries.
+    // This tells us where each binary lives, and we collect all those dirs.
+    // Works on any machine — we discover what's available rather than hardcoding.
+    const knownBinaries = ['claude', 'codex', 'qwen', 'ollama', 'aider', 'python3', 'node', 'bun', 'sh'];
+    const dirs = new Set();
+    dirs.add(path.join(homedir(), '.nvm', 'versions', 'node', `v${process.versions.node}`, 'bin'));
+    dirs.add(path.join(homedir(), '.local', 'bin'));
+    dirs.add('/opt/homebrew/bin');
+    dirs.add('/usr/local/bin');
+    dirs.add('/usr/bin');
+    dirs.add('/bin');
+    // Also add directories that appear in PATH at startup
+    const currentPath = process.env.PATH ?? '';
+    for (const d of currentPath.split(':')) {
+        if (d && !d.startsWith('/dev') && !d.startsWith('/tmp')) {
+            dirs.add(d);
+        }
+    }
+    // Discover dirs by locating each known binary
+    for (const bin of knownBinaries) {
+        try {
+            const resolved = execSync(`which ${bin} 2>/dev/null`, { stdio: 'pipe' }).toString().trim();
+            if (resolved && resolved.startsWith('/')) {
+                dirs.add(path.dirname(resolved));
+            }
+        }
+        catch { /* binary not found — skip */ }
+    }
+    // Claude Code often installed as VS Code extension — discover it
+    const vscodeExtensions = path.join(homedir(), '.vscode', 'extensions');
+    try {
+        const entries = execSync(`ls "${vscodeExtensions}" 2>/dev/null`, { stdio: 'pipe' }).toString().split('\n');
+        for (const entry of entries) {
+            if (entry.startsWith('anthropic.claude-code-')) {
+                const binDir = path.join(vscodeExtensions, entry, 'resources', 'native-binary');
+                if (existsSync(binDir))
+                    dirs.add(binDir);
+            }
+        }
+    }
+    catch { /* vscode extensions not found — skip */ }
+    return [...dirs].join(':');
+}
+function setupLaunchd(daemonEntry) {
+    try {
+        execSync(`mkdir -p "${LAUNCH_AGENTS}"`, { stdio: 'pipe' });
+    }
+    catch { /* exists */ }
+    const shellPath = getShellPath();
+    const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>com.jerico.bridge-agent</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${daemonEntry}</string>
+    <string>start</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${LOG_OUT}</string>
+  <key>StandardErrorPath</key>
+  <string>${LOG_ERR}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>${shellPath}</string>
+    <key>BRIDGE_DAEMON</key>
+    <string>1</string>
+  </dict>
+</dict>
+</plist>
+`;
+    try {
+        writeFileSync(PLIST_PATH, plist, 'utf-8');
+        return true;
+    }
+    catch (err) {
+        console.warn('[bridge] launchd.plist.write.failed', { error: String(err) });
+        return false;
+    }
+}
+function tryLaunchd() {
+    try {
+        // Force-kill any stale entry then reload — kickstart is more reliable than unload for zombie cleanup
+        execSync(`launchctl kickstart -kp gui/$(id -u)/${PLIST_NAME} 2>/dev/null; launchctl unload "${PLIST_PATH}" 2>/dev/null; launchctl load "${PLIST_PATH}"`, { stdio: 'pipe' });
+        return { ok: true, permissionDenied: false };
+    }
+    catch (err) {
+        const msg = String(err);
+        const denied = msg.includes('Permission denied') || msg.includes('not allowed') || msg.includes('bootstrap');
+        return { ok: false, permissionDenied: denied };
+    }
+}
+function startAsDaemon(daemonEntry) {
+    try {
+        const child = spawn(daemonEntry, ['start'], {
+            detached: true,
+            stdio: 'ignore',
+            env: { ...process.env, PATH: getShellPath(), BRIDGE_DAEMON: '1' },
+        });
+        child.unref();
+        setTimeout(() => {
+            const running = child.pid && process.kill(child.pid, 0);
+            if (running) {
+                console.log('[bridge] daemon.pid', { pid: child.pid });
+                console.log('[bridge] background.ok', { log: LOG_OUT });
+            }
+            else {
+                console.error('[bridge] background.failed — check: tail -f', { log: LOG_ERR });
+            }
+        }, 2000);
+    }
+    catch (err) {
+        console.error('[bridge] background.spawn.failed', { error: String(err) });
+    }
+}
+/**
+ * Verify the daemon is actually healthy after launchd reports success.
+ * launchd can say "loaded" but the daemon might exit 1 second later.
+ * Polls the health endpoint for up to 6 seconds before accepting success.
+ */
+function verifyDaemonHealth() {
+    const healthPort = parseInt(process.env['HEALTH_PORT'] ?? '3101', 10);
+    const deadline = Date.now() + 6000;
+    const tryConnect = () => {
+        if (Date.now() > deadline) {
+            console.error('[bridge] health.verify.timeout — daemon may have crashed immediately');
+            return;
+        }
+        try {
+            const http = require('node:http');
+            const req = http.get(`http://127.0.0.1:${healthPort}/health`, (res) => {
+                if (res.statusCode === 200) {
+                    console.log('[bridge] health.verify.ok');
+                }
+                else {
+                    setTimeout(tryConnect, 500);
+                }
+            });
+            req.on('error', () => { setTimeout(tryConnect, 500); });
+            req.setTimeout(1000, () => { req.destroy(); setTimeout(tryConnect, 500); });
+        }
+        catch {
+            setTimeout(tryConnect, 500);
+        }
+    };
+    setTimeout(tryConnect, 1000);
+}
+function runDaemonServices() {
+    const manager = new PtyManager();
+    startDaemonConnection(manager);
+    const healthPort = parseInt(process.env['HEALTH_PORT'] ?? '3101', 10);
+    const health = createServer((_, res) => {
+        const connected = isDaemonWsConnected();
+        const body = JSON.stringify({ status: 'ok', connected, uptime: process.uptime() });
+        res.writeHead(connected ? 200 : 503, { 'Content-Type': 'application/json' });
+        res.end(body);
+    });
+    health.listen(healthPort, '127.0.0.1', () => {
+        console.log(`[bridge] health. listening on 127.0.0.1:${healthPort}`);
+    });
+    health.on('error', (err) => {
+        console.error('[bridge] health.error', { error: err.message });
+    });
+}
+export function runStart() {
+    const isDaemon = process.env['BRIDGE_DAEMON'] === '1' || process.argv.includes('--daemon');
+    console.log('[bridge] Starting bridge-agent daemon...');
+    if (isDaemon) {
+        runDaemonServices();
+        return;
+    }
+    // Prevent multiple daemon instances on the same machine.
+    if (!acquireDaemonLock()) {
+        console.warn('[bridge] start.aborted.already.running');
+        process.exit(1);
+    }
+    const daemonEntry = getDaemonEntry();
+    const plistWritten = setupLaunchd(daemonEntry);
+    const { ok: launched, permissionDenied } = plistWritten ? tryLaunchd() : { ok: false, permissionDenied: false };
+    if (launched) {
+        console.log('[bridge] launchd.ok — managed, auto-restart enabled');
+        console.log('[bridge] logs: tail -f', { out: LOG_OUT, err: LOG_ERR });
+        verifyDaemonHealth();
+        process.exit(0);
+        return;
+    }
+    if (permissionDenied) {
+        console.warn('[bridge] launchd.permission.denied');
+        console.warn('[bridge]   → Auto-start on login requires:');
+        console.warn(`[bridge]   sudo launchctl bootstrap gui/$(id -u) "${PLIST_PATH}"`);
+        console.warn('[bridge] Falling back to background process...\n');
+    }
+    startAsDaemon(daemonEntry);
+    process.exit(0);
+}

package/dist/config.d.ts

@@ -0,0 +1,25 @@
+export interface BridgeConfig {
+    server: string;
+    token: string;
+    name: string;
+    /** Global agent binary path overrides (key = agentKey, value = absolute path) */
+    agentPaths?: Record<string, string>;
+}
+/** Project-level settings from .jerico/settings.json in cwd */
+export interface ProjectSettings {
+    /** Override agent binary paths (key = agentKey, value = absolute path) */
+    agentPaths?: Record<string, string>;
+    /** Override the agent binary to prefer in this project */
+    preferredAgent?: string;
+    /** Shell hooks — see lifecycle hooks (ISSUE 7) */
+    hooks?: Record<string, string>;
+    /** Additional env vars injected into spawned agents in this project */
+    env?: Record<string, string>;
+}
+export declare function loadConfig(): BridgeConfig;
+export declare function saveConfig(config: BridgeConfig): void;
+/**
+ * Load project-level settings from .jerico/settings.json in the given directory (or cwd).
+ * Returns empty object if the file does not exist or fails to parse.
+ */
+export declare function loadProjectSettings(cwd?: string): ProjectSettings;

package/dist/config.js

@@ -0,0 +1,85 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+/** New global path; legacy ~/.bridge/config.json is still supported as fallback */
+const JERICO_CONFIG_PATH = path.join(os.homedir(), '.jerico', 'settings.json');
+const CONFIG_PATH = path.join(os.homedir(), '.bridge', 'config.json');
+export function loadConfig() {
+    // Prefer new ~/.jerico/settings.json; fall back to legacy ~/.bridge/config.json
+    const configPath = fs.existsSync(JERICO_CONFIG_PATH) ? JERICO_CONFIG_PATH : CONFIG_PATH;
+    if (!fs.existsSync(configPath)) {
+        console.error('[bridge] Config not found. Run: bridge-agent auth');
+        process.exit(1);
+    }
+    const raw = fs.readFileSync(configPath, 'utf-8');
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        console.error('[bridge] Invalid config file at', CONFIG_PATH);
+        process.exit(1);
+    }
+    if (!parsed || typeof parsed !== 'object') {
+        console.error('[bridge] Config must be a JSON object. Run: bridge-agent auth');
+        process.exit(1);
+    }
+    const obj = parsed;
+    const server = typeof obj['server'] === 'string' ? obj['server'] : '';
+    const token = typeof obj['token'] === 'string' ? obj['token'] : '';
+    const name = typeof obj['name'] === 'string' ? obj['name'] : 'bridge-agent';
+    if (!server || !token) {
+        console.error('[bridge] Config missing server or token. Run: bridge-agent auth');
+        process.exit(1);
+    }
+    const config = { server, token, name };
+    if (obj['agentPaths'] && typeof obj['agentPaths'] === 'object' && !Array.isArray(obj['agentPaths'])) {
+        config.agentPaths = Object.fromEntries(Object.entries(obj['agentPaths'])
+            .filter(([, v]) => typeof v === 'string'));
+    }
+    return config;
+}
+export function saveConfig(config) {
+    // Always write to new ~/.jerico path
+    const dir = path.dirname(JERICO_CONFIG_PATH);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(JERICO_CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 });
+}
+/**
+ * Load project-level settings from .jerico/settings.json in the given directory (or cwd).
+ * Returns empty object if the file does not exist or fails to parse.
+ */
+export function loadProjectSettings(cwd) {
+    const settingsPath = path.join(cwd ?? process.cwd(), '.jerico', 'settings.json');
+    if (!fs.existsSync(settingsPath))
+        return {};
+    try {
+        const raw = fs.readFileSync(settingsPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            return {};
+        const obj = parsed;
+        const result = {};
+        if (typeof obj['preferredAgent'] === 'string')
+            result.preferredAgent = obj['preferredAgent'];
+        if (obj['hooks'] && typeof obj['hooks'] === 'object' && !Array.isArray(obj['hooks'])) {
+            result.hooks = Object.fromEntries(Object.entries(obj['hooks'])
+                .filter(([, v]) => typeof v === 'string'));
+        }
+        if (obj['env'] && typeof obj['env'] === 'object' && !Array.isArray(obj['env'])) {
+            result.env = Object.fromEntries(Object.entries(obj['env'])
+                .filter(([, v]) => typeof v === 'string'));
+        }
+        if (obj['agentPaths'] && typeof obj['agentPaths'] === 'object' && !Array.isArray(obj['agentPaths'])) {
+            result.agentPaths = Object.fromEntries(Object.entries(obj['agentPaths'])
+                .filter(([, v]) => typeof v === 'string'));
+        }
+        return result;
+    }
+    catch {
+        console.warn('[bridge] Failed to parse .jerico/settings.json, ignoring');
+        return {};
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};