bridge-agent 0.2.11 → 0.2.13

package/dist/pty/manager.js

@@ -0,0 +1,144 @@
+import * as pty from 'node-pty';
+import { AGENT_SPECS } from './agents.js';
+export class PtyManager {
+    handles = new Map();
+    nextInstanceId = 1;
+    lastErrors = new Map();
+    spawn(agentId, agentKey, binary, args, cols, rows, onData, onExit, ctx) {
+        // Same logical panel may be re-spawned after reconnect/remount while the old PTY
+        // is still registered locally. This happens when a new spawn is processed before
+        // a prior kill message reaches the daemon. Replace the old handle in-process
+        // instead of surfacing SPAWN_DUPLICATE back to the server.
+        const existing = this.handles.get(agentId);
+        if (existing) {
+            console.warn('[daemon] pty.spawn.replace_existing', { agentId, oldPid: existing.pid, newAgentKey: agentKey });
+            this.kill(agentId, true);
+        }
+        const clampedCols = Math.max(1, Math.min(500, cols));
+        const clampedRows = Math.max(1, Math.min(500, rows));
+        const env = {
+            ...process.env,
+            TERM: 'xterm-256color',
+            COLORTERM: 'truecolor',
+        };
+        if (ctx) {
+            env['BRIDGE_SERVER_URL'] = ctx.serverUrl;
+            env['BRIDGE_TOKEN'] = ctx.token;
+            env['BRIDGE_WORKSPACE_ID'] = ctx.workspaceId;
+            env['BRIDGE_PROJECT_ID'] = ctx.projectId;
+            // Merge project-scoped env vars — these override process.env
+            if (ctx.projectEnv)
+                Object.assign(env, ctx.projectEnv);
+        }
+        const bridgeMcpUrl = process.env['BRIDGE_MCP_URL'];
+        if (bridgeMcpUrl) {
+            env['BRIDGE_MCP_URL'] = bridgeMcpUrl;
+        }
+        let proc;
+        try {
+            proc = pty.spawn(binary, args, {
+                name: 'xterm-256color',
+                cols: clampedCols,
+                rows: clampedRows,
+                cwd: ctx?.cwd,
+                env,
+            });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            this.lastErrors.set(agentId, msg);
+            console.error('[daemon] pty.spawn.failed', { agentId, agentKey, error: msg });
+            return false;
+        }
+        const instanceId = this.nextInstanceId++;
+        const handle = { agentId, agentKey, process: proc, pid: proc.pid, killed: false, instanceId };
+        proc.onData(data => {
+            const current = this.handles.get(agentId);
+            if (!current || current.instanceId !== instanceId || handle.killed)
+                return;
+            onData(Buffer.from(data).toString('base64'));
+        });
+        proc.onExit(({ exitCode, signal }) => {
+            const current = this.handles.get(agentId);
+            if (!current || current.instanceId !== instanceId || handle.killed)
+                return;
+            if (handle.killed)
+                return;
+            this.handles.delete(agentId);
+            console.log('[daemon] pty.exit', { agentId, exitCode, signal });
+            onExit(exitCode ?? null, signal ? String(signal) : null);
+        });
+        this.lastErrors.delete(agentId);
+        this.handles.set(agentId, handle);
+        console.log('[daemon] pty.spawn.success', { agentId, agentKey, args, cwd: ctx?.cwd });
+        return true;
+    }
+    write(agentId, data, source) {
+        const handle = this.handles.get(agentId);
+        if (!handle)
+            return;
+        const decoded = Buffer.from(data, 'base64').toString();
+        // Only apply agent-specific formatInput for orchestrator injections.
+        // User keystrokes from xterm already carry the correct terminators —
+        // appending \n/\r to every character would submit each keystroke immediately.
+        const spec = AGENT_SPECS.find(s => s.key === handle.agentKey);
+        const formatted = (source === 'orchestrator' && spec?.formatInput)
+            ? spec.formatInput(decoded)
+            : decoded;
+        handle.process.write(formatted);
+    }
+    kill(agentId, force = false) {
+        const handle = this.handles.get(agentId);
+        if (!handle)
+            return;
+        handle.killed = true;
+        this.handles.delete(agentId);
+        const pid = handle.pid;
+        if (force) {
+            // Kill entire process group: SIGTERM first, then SIGKILL after 2s
+            try {
+                process.kill(-pid, 'SIGTERM');
+            }
+            catch {
+                handle.process.kill();
+            }
+            setTimeout(() => {
+                try {
+                    process.kill(-pid, 'SIGKILL');
+                }
+                catch { /* already dead */ }
+            }, 2000);
+        }
+        else {
+            try {
+                process.kill(-pid, 'SIGTERM');
+            }
+            catch {
+                handle.process.kill();
+            }
+        }
+        console.log('[daemon] pty.kill', { agentId, force });
+    }
+    resize(agentId, cols, rows) {
+        const handle = this.handles.get(agentId);
+        if (!handle)
+            return;
+        const clampedCols = Math.max(1, Math.min(500, cols));
+        const clampedRows = Math.max(1, Math.min(500, rows));
+        handle.process.resize(clampedCols, clampedRows);
+    }
+    getLastError(agentId) {
+        return this.lastErrors.get(agentId);
+    }
+    killAll() {
+        for (const handle of this.handles.values()) {
+            try {
+                process.kill(-handle.pid, 'SIGTERM');
+            }
+            catch {
+                handle.process.kill();
+            }
+        }
+        this.handles.clear();
+    }
+}

package/dist/pty/spawn-helper-health.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Resolve the spawn-helper binary path for the currently loaded node-pty module
+ * and active platform/architecture.
+ */
+export declare function resolveSpawnHelperPath(): string | undefined;
+/**
+ * Check whether the node-pty spawn-helper is executable by file permission
+ * AND by performing a silent test spawn.
+ *
+ * We test-spawn because npm tarballs can strip +x from the helper, which
+ * causes `posix_spawnp failed` on macOS even when the file looks okay.
+ */
+export declare function isSpawnHelperHealthy(): boolean;

package/dist/pty/spawn-helper-health.js

@@ -0,0 +1,54 @@
+import fs from 'fs';
+import path from 'path';
+import * as pty from 'node-pty';
+/**
+ * Resolve the spawn-helper binary path for the currently loaded node-pty module
+ * and active platform/architecture.
+ */
+export function resolveSpawnHelperPath() {
+    try {
+        const nodePtyEntry = require.resolve('node-pty');
+        // require.resolve('node-pty') returns .../node-pty/lib/index.js
+        // The prebuilds folder is at the package root, one level above lib/
+        const nodePtyDir = path.resolve(path.dirname(nodePtyEntry), '..');
+        const helperPath = path.join(nodePtyDir, 'prebuilds', `${process.platform}-${process.arch}`, 'spawn-helper');
+        return helperPath;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Check whether the node-pty spawn-helper is executable by file permission
+ * AND by performing a silent test spawn.
+ *
+ * We test-spawn because npm tarballs can strip +x from the helper, which
+ * causes `posix_spawnp failed` on macOS even when the file looks okay.
+ */
+export function isSpawnHelperHealthy() {
+    const helperPath = resolveSpawnHelperPath();
+    if (!helperPath || !fs.existsSync(helperPath)) {
+        return true; // If node-pty doesn't ship a helper, we assume it's fine (e.g. Windows)
+    }
+    // 1. Permission check
+    try {
+        fs.accessSync(helperPath, fs.constants.X_OK);
+    }
+    catch {
+        return false;
+    }
+    // 2. Functional test: silently spawn /bin/sh and immediately kill it.
+    //    We intentionally do NOT register onData/onExit to avoid log noise.
+    try {
+        const proc = pty.spawn('/bin/sh', [], {
+            name: 'xterm-256color',
+            cols: 80,
+            rows: 24,
+        });
+        proc.kill();
+    }
+    catch {
+        return false;
+    }
+    return true;
+}

package/dist/shared/types.d.ts

@@ -0,0 +1,87 @@
+export * from '@jerico/shared';
+/** Messages sent from server to daemon (client from daemon's perspective) */
+export type ClientMessage = {
+    type: 'spawn';
+    agentId: string;
+    daemonId: string;
+    agentKey: string;
+    cols: number;
+    rows: number;
+    sessionId?: string;
+    projectId?: string;
+    workspaceId?: string;
+    cwd?: string;
+    role?: string;
+    runnerCmd?: string;
+    orchestratorOwned?: boolean;
+} | {
+    type: 'input';
+    agentId: string;
+    daemonId: string;
+    data: string;
+    source?: 'user' | 'orchestrator';
+} | {
+    type: 'kill';
+    agentId: string;
+    daemonId: string;
+    force: boolean;
+} | {
+    type: 'resize';
+    agentId: string;
+    daemonId: string;
+    cols: number;
+    rows: number;
+} | {
+    type: 'detect_agents';
+    daemonId?: string;
+} | {
+    type: 'dir_list';
+    daemonId: string;
+    requestId: string;
+    path: string;
+};
+/** Messages sent from daemon to server */
+export type ServerMessage = {
+    type: 'output';
+    agentId: string;
+    data: string;
+} | {
+    type: 'exit';
+    agentId: string;
+    exitCode: number | null;
+    signal: string | null;
+} | {
+    type: 'agents';
+    daemonId: string;
+    list: import('@jerico/shared').AgentInfo[];
+} | {
+    type: 'ready';
+    version: string;
+    name?: string;
+    spawnHelperBroken?: boolean;
+} | {
+    type: 'error';
+    code: string;
+    message: string;
+} | {
+    type: 'session_started';
+    agentId: string;
+    sessionId: string;
+} | {
+    type: 'dir_list_result';
+    requestId: string;
+    path: string;
+    entries: import('@jerico/shared').DirEntry[];
+} | {
+    type: 'panel_token_usage';
+    agentId: string;
+    contextWindowPct: number;
+    quota5hPct: number;
+    quota5hResetInSec: number;
+} | {
+    type: 'system_metrics';
+    daemonId: string;
+    cpu: number;
+    ramUsedMb: number;
+    ramTotalMb: number;
+};

package/dist/shared/types.js

@@ -0,0 +1,4 @@
+// Re-export shared primitives from @jerico/shared to eliminate duplication.
+// Daemon-specific message types remain local because they are a narrower subset
+// than the server/web message unions.
+export * from '@jerico/shared';

package/dist/ws/client.d.ts

@@ -0,0 +1,3 @@
+import { PtyManager } from '../pty/manager.js';
+export declare function isDaemonWsConnected(): boolean;
+export declare function startDaemonConnection(manager: PtyManager): void;