bridge-agent 0.1.0-beta.0

package/dist/metrics.d.ts

@@ -0,0 +1,10 @@
+export interface SystemMetrics {
+    cpu: number;
+    ramUsedMb: number;
+    ramTotalMb: number;
+    battery?: {
+        percent: number;
+        charging: boolean;
+    };
+}
+export declare function startMetricsRelay(sendFn: (metrics: SystemMetrics) => void): () => void;

package/dist/metrics.js

@@ -0,0 +1,91 @@
+import os from 'os';
+import fs from 'fs';
+import { spawnSync } from 'node:child_process';
+function cpuSnapshot() {
+    let idle = 0, total = 0;
+    for (const cpu of os.cpus()) {
+        idle += cpu.times.idle;
+        total += cpu.times.user + cpu.times.nice + cpu.times.sys + cpu.times.idle + (cpu.times.irq ?? 0);
+    }
+    return { idle, total };
+}
+let lastSnapshot = cpuSnapshot();
+function cpuPercent() {
+    const now = cpuSnapshot();
+    const dIdle = now.idle - lastSnapshot.idle;
+    const dTotal = now.total - lastSnapshot.total;
+    lastSnapshot = now;
+    if (dTotal === 0)
+        return 0;
+    return Math.round((1 - dIdle / dTotal) * 100);
+}
+// ── RAM ─────────────────────────────────────────────────────────────────────
+function ramStats() {
+    const total = os.totalmem();
+    const free = os.freemem();
+    return {
+        totalMb: Math.round(total / 1024 / 1024),
+        usedMb: Math.round((total - free) / 1024 / 1024),
+    };
+}
+// ── Battery ─────────────────────────────────────────────────────────────────
+function batteryMacos() {
+    try {
+        const r = spawnSync('pmset', ['-g', 'batt'], { encoding: 'utf-8', timeout: 2000, stdio: 'pipe' });
+        if (r.status !== 0 || !r.stdout)
+            return undefined;
+        const m = r.stdout.match(/(\d+)%;\s*(charging|discharging|charged|finishing charge)/i);
+        if (!m)
+            return undefined;
+        const percent = parseInt(m[1], 10);
+        const charging = /charging|charged|finishing/i.test(m[2]);
+        return { percent, charging };
+    }
+    catch {
+        return undefined;
+    }
+}
+function batteryLinux() {
+    try {
+        const base = '/sys/class/power_supply';
+        const dirs = fs.readdirSync(base).filter(d => /^BAT/i.test(d));
+        if (dirs.length === 0)
+            return undefined;
+        const bat = `${base}/${dirs[0]}`;
+        const percent = parseInt(fs.readFileSync(`${bat}/capacity`, 'utf-8').trim(), 10);
+        const status = fs.readFileSync(`${bat}/status`, 'utf-8').trim().toLowerCase();
+        const charging = status === 'charging' || status === 'full';
+        return { percent, charging };
+    }
+    catch {
+        return undefined;
+    }
+}
+function battery() {
+    const p = process.platform;
+    if (p === 'darwin')
+        return batteryMacos();
+    if (p === 'linux')
+        return batteryLinux();
+    return undefined;
+}
+// ── Relay ────────────────────────────────────────────────────────────────────
+const METRICS_INTERVAL_MS = 10_000;
+const BATTERY_EVERY_N = 3; // battery checked every 3rd tick (30s)
+export function startMetricsRelay(sendFn) {
+    let tick = 0;
+    let cachedBattery = battery();
+    const timer = setInterval(() => {
+        tick++;
+        if (tick % BATTERY_EVERY_N === 0)
+            cachedBattery = battery();
+        const ram = ramStats();
+        sendFn({
+            cpu: cpuPercent(),
+            ramUsedMb: ram.usedMb,
+            ramTotalMb: ram.totalMb,
+            battery: cachedBattery,
+        });
+    }, METRICS_INTERVAL_MS);
+    return () => clearInterval(timer);
+}

package/dist/pty/agents.d.ts

@@ -0,0 +1,25 @@
+import type { AgentKey, AgentInfo } from '../shared/types.js';
+interface AgentSpec {
+    key: AgentKey;
+    displayName: string;
+    binary: string;
+    checkAuth: () => Promise<boolean>;
+    /** If true, daemon generates a UUID at spawn and passes --session-id <uuid> to the CLI */
+    assignSessionId?: boolean;
+    /** Args to always prepend on fresh spawn (before --session-id) */
+    spawnArgs?: string[];
+    /** Args to prepend when resuming a specific session */
+    resumeArgs?: (sessionId: string) => string[];
+    /** Whether this agent supports `--mcp-config <path>` */
+    supportsMcpConfig?: boolean;
+    /**
+     * Transform injection text before writing to the PTY.
+     * Responsible for appending the correct line terminator for this agent's TUI.
+     * Daemons >= v1.1 apply this; the server sends raw text without a terminator.
+     */
+    formatInput?: (text: string) => string;
+}
+declare const AGENT_SPECS: AgentSpec[];
+export { AGENT_SPECS };
+export type { AgentSpec };
+export declare function detectAgents(): Promise<AgentInfo[]>;

package/dist/pty/agents.js

@@ -0,0 +1,108 @@
+import which from 'which';
+import fs from 'fs';
+import path from 'path';
+import net from 'net';
+// Standard \n terminator — works for readline-based CLIs (sh, Codex, Gemini, Ollama, Aider)
+const appendLF = (text) => text + '\n';
+// TUI agents that treat \n as soft newline (multi-line mode) and \r as submit.
+// Strip any trailing \r/\n first to avoid a double-submit on the last line.
+// Applies to: Claude Code, Qwen CLI.
+const appendCR = (text) => text.replace(/[\r\n]+$/, '') + '\r';
+const AGENT_SPECS = [
+    {
+        key: 'sh',
+        displayName: 'Shell',
+        binary: 'sh',
+        checkAuth: async () => true,
+        formatInput: appendLF,
+    },
+    {
+        key: 'claude',
+        displayName: 'Claude Code',
+        binary: 'claude',
+        checkAuth: async () => checkDir('.claude') || checkEnv('ANTHROPIC_API_KEY'),
+        assignSessionId: true,
+        spawnArgs: ['--dangerously-skip-permissions'],
+        resumeArgs: (id) => ['--dangerously-skip-permissions', '--resume', id],
+        supportsMcpConfig: true,
+        formatInput: appendCR,
+    },
+    {
+        key: 'codex',
+        displayName: 'Codex CLI',
+        binary: 'codex',
+        checkAuth: async () => checkEnv('OPENAI_API_KEY'),
+        spawnArgs: ['--full-auto'],
+        supportsMcpConfig: true,
+        formatInput: appendCR,
+    },
+    {
+        key: 'qwen',
+        displayName: 'Qwen CLI',
+        binary: 'qwen',
+        checkAuth: async () => checkDir('.qwen'),
+        assignSessionId: true,
+        spawnArgs: ['--yolo'],
+        resumeArgs: (id) => ['--resume', id, '--yolo'],
+        supportsMcpConfig: true,
+        formatInput: appendCR,
+    },
+    {
+        key: 'gemini',
+        displayName: 'Gemini',
+        binary: 'gemini',
+        checkAuth: async () => checkEnv('GEMINI_API_KEY'),
+        supportsMcpConfig: true,
+        formatInput: appendLF,
+    },
+    {
+        key: 'ollama',
+        displayName: 'Ollama',
+        binary: 'ollama',
+        checkAuth: async () => checkPort(11434),
+        formatInput: appendLF,
+    },
+    {
+        key: 'aider',
+        displayName: 'Aider',
+        binary: 'aider',
+        checkAuth: async () => checkEnv('OPENAI_API_KEY') || checkEnv('ANTHROPIC_API_KEY'),
+        supportsMcpConfig: true,
+        formatInput: appendLF,
+    },
+];
+export { AGENT_SPECS };
+export async function detectAgents() {
+    const results = [];
+    for (const spec of AGENT_SPECS) {
+        try {
+            const binaryPath = await which(spec.binary);
+            const authOk = await spec.checkAuth();
+            const authStatus = authOk ? 'ok' : 'missing';
+            results.push({ key: spec.key, displayName: spec.displayName, binaryPath, authStatus });
+        }
+        catch {
+            // binary not in PATH — skip
+        }
+    }
+    console.log('[daemon] agent.detect.done', {
+        found: results.map(a => a.key),
+        missing: AGENT_SPECS.map(s => s.key).filter(k => !results.find(r => r.key === k)),
+    });
+    return results;
+}
+function checkDir(name) {
+    return fs.existsSync(path.join(process.env['HOME'] ?? '', name));
+}
+function checkEnv(key) {
+    return !!process.env[key];
+}
+async function checkPort(port) {
+    return new Promise(resolve => {
+        const s = net.createConnection(port, '127.0.0.1');
+        s.setTimeout(200);
+        s.on('connect', () => { s.destroy(); resolve(true); });
+        s.on('error', () => resolve(false));
+        s.on('timeout', () => { s.destroy(); resolve(false); });
+    });
+}

package/dist/pty/claude-quota.d.ts

@@ -0,0 +1,12 @@
+export interface QuotaInfo {
+    prompts5h: number;
+    limit5h: number;
+    resetAt: number;
+    tier: string;
+}
+/**
+ * Start a global watcher that polls Claude Code JSONL files every 60s
+ * to count user prompts within the rolling 5-hour window.
+ * Returns a cleanup function.
+ */
+export declare function startClaudeQuotaWatcher(onQuota: (info: QuotaInfo) => void): () => void;

package/dist/pty/claude-quota.js

@@ -0,0 +1,114 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+const WINDOW_MS = 5 * 60 * 60 * 1000; // 5 hours in ms
+const TIER_LIMITS = {
+    free: 10,
+    pro: 40,
+    max_5x: 200,
+    max_20x: 200,
+};
+function readTier() {
+    const configPath = path.join(os.homedir(), '.jerico', 'settings.json');
+    try {
+        if (!fs.existsSync(configPath))
+            return 'pro';
+        const obj = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        const tier = obj['claudeTier'];
+        if (typeof tier === 'string' && tier in TIER_LIMITS)
+            return tier;
+    }
+    catch { /* ignore */ }
+    return 'pro';
+}
+function countPromptsInWindow() {
+    const base = path.join(os.homedir(), '.claude', 'projects');
+    if (!fs.existsSync(base))
+        return { prompts5h: 0, resetAt: 0 };
+    const now = Date.now();
+    const cutoff = now - WINDOW_MS;
+    let oldestInWindow = Infinity;
+    let count = 0;
+    try {
+        const dirs = fs.readdirSync(base, { withFileTypes: true }).filter(d => d.isDirectory());
+        for (const dir of dirs) {
+            const dirPath = path.join(base, dir.name);
+            let files;
+            try {
+                files = fs.readdirSync(dirPath).filter(f => f.endsWith('.jsonl'));
+            }
+            catch {
+                continue;
+            }
+            for (const file of files) {
+                const filePath = path.join(dirPath, file);
+                let content;
+                try {
+                    // Skip files larger than 20MB to avoid blocking the event loop
+                    const stat = fs.statSync(filePath);
+                    if (stat.size > 20 * 1024 * 1024)
+                        continue;
+                    content = fs.readFileSync(filePath, 'utf-8');
+                }
+                catch {
+                    continue;
+                }
+                for (const line of content.split('\n')) {
+                    const trimmed = line.trim();
+                    if (!trimmed)
+                        continue;
+                    try {
+                        const entry = JSON.parse(trimmed);
+                        // Only count external user prompts (not tool results, system messages, etc.)
+                        if (entry['type'] !== 'user')
+                            continue;
+                        const msg = entry['message'];
+                        if (msg?.['role'] !== 'user')
+                            continue;
+                        if (entry['userType'] !== undefined && entry['userType'] !== 'external')
+                            continue;
+                        const ts = entry['timestamp'];
+                        if (typeof ts !== 'string')
+                            continue;
+                        const epoch = Date.parse(ts);
+                        if (isNaN(epoch) || epoch < cutoff)
+                            continue;
+                        count++;
+                        if (epoch < oldestInWindow)
+                            oldestInWindow = epoch;
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+            }
+        }
+    }
+    catch { /* no-op */ }
+    const resetAt = isFinite(oldestInWindow) ? oldestInWindow + WINDOW_MS : 0;
+    return { prompts5h: count, resetAt };
+}
+/**
+ * Start a global watcher that polls Claude Code JSONL files every 60s
+ * to count user prompts within the rolling 5-hour window.
+ * Returns a cleanup function.
+ */
+export function startClaudeQuotaWatcher(onQuota) {
+    const tick = () => {
+        const tier = readTier();
+        const limit5h = TIER_LIMITS[tier] ?? 40;
+        const { prompts5h, resetAt } = countPromptsInWindow();
+        onQuota({ prompts5h, limit5h, resetAt, tier });
+    };
+    try {
+        tick();
+    }
+    catch (err) {
+        console.warn('[quota] initial poll failed', err);
+    }
+    const interval = setInterval(() => { try {
+        tick();
+    }
+    catch { /* silent */ } }, 60_000);
+    return () => clearInterval(interval);
+}

package/dist/pty/claude-usage.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Start polling Claude's JSONL session file for token usage.
+ * Calls onUsage whenever new data is found. Returns a cleanup function.
+ */
+export declare function startClaudeUsageWatcher(agentId: string, sessionId: string, onUsage: (agentId: string, usedPct: number, usedTokens: number) => void): () => void;

package/dist/pty/claude-usage.js

@@ -0,0 +1,92 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+// All current Claude models have 200k context window
+const CONTEXT_WINDOW = 200_000;
+/**
+ * Search ~/.claude/projects/ subdirectories for a JSONL file matching the given sessionId.
+ * Claude Code stores sessions at: ~/.claude/projects/<encoded-cwd>/<sessionId>.jsonl
+ */
+function findJSONL(sessionId) {
+    const base = path.join(os.homedir(), '.claude', 'projects');
+    if (!fs.existsSync(base))
+        return undefined;
+    try {
+        const dirs = fs.readdirSync(base, { withFileTypes: true })
+            .filter(d => d.isDirectory());
+        for (const dir of dirs) {
+            const candidate = path.join(base, dir.name, `${sessionId}.jsonl`);
+            if (fs.existsSync(candidate))
+                return candidate;
+        }
+    }
+    catch { /* no-op */ }
+    return undefined;
+}
+/**
+ * Read the JSONL file and return the most recent token usage.
+ * Claude Code persists: entry.message.usage = { input_tokens, cache_creation_input_tokens, cache_read_input_tokens, output_tokens }
+ * used% = (input + cache_creation + cache_read) / context_window
+ */
+function parseLastUsage(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const lines = content.trim().split('\n');
+        // Scan from end to find the most recent assistant entry with usage
+        for (let i = lines.length - 1; i >= 0; i--) {
+            const line = lines[i]?.trim();
+            if (!line)
+                continue;
+            try {
+                const entry = JSON.parse(line);
+                const usage = entry.message?.usage
+                    ?? entry.usage;
+                if (!usage || typeof usage !== 'object')
+                    continue;
+                const u = usage;
+                const usedTokens = (u.input_tokens ?? 0)
+                    + (u.cache_creation_input_tokens ?? 0)
+                    + (u.cache_read_input_tokens ?? 0);
+                if (usedTokens === 0)
+                    continue;
+                const usedPct = Math.min(100, Math.round((usedTokens / CONTEXT_WINDOW) * 100));
+                return { usedPct, usedTokens };
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    catch { /* file not readable */ }
+    return null;
+}
+/**
+ * Start polling Claude's JSONL session file for token usage.
+ * Calls onUsage whenever new data is found. Returns a cleanup function.
+ */
+export function startClaudeUsageWatcher(agentId, sessionId, onUsage) {
+    let filePath;
+    let lastUsedTokens = -1;
+    const tick = () => {
+        // Lazily locate the JSONL file (may not exist immediately after spawn)
+        if (!filePath)
+            filePath = findJSONL(sessionId);
+        if (!filePath)
+            return;
+        const result = parseLastUsage(filePath);
+        if (!result)
+            return;
+        // Only emit when value actually changed to avoid spamming the WS
+        if (result.usedTokens === lastUsedTokens)
+            return;
+        lastUsedTokens = result.usedTokens;
+        onUsage(agentId, result.usedPct, result.usedTokens);
+    };
+    // First poll after 2s (JSONL may not exist yet), then every 3s
+    const initial = setTimeout(tick, 2000);
+    const interval = setInterval(tick, 3000);
+    return () => {
+        clearTimeout(initial);
+        clearInterval(interval);
+    };
+}

package/dist/pty/manager.d.ts

@@ -0,0 +1,18 @@
+export interface SpawnContext {
+    serverUrl: string;
+    token: string;
+    workspaceId: string;
+    projectId: string;
+    agentId?: string;
+    cwd?: string;
+    /** Extra env vars from .jerico/settings.json — merged over process.env */
+    projectEnv?: Record<string, string>;
+}
+export declare class PtyManager {
+    private handles;
+    spawn(agentId: string, agentKey: string, binary: string, args: string[], cols: number, rows: number, onData: (data: string) => void, onExit: (exitCode: number | null, signal: string | null) => void, ctx?: SpawnContext): boolean;
+    write(agentId: string, data: string, source?: string): void;
+    kill(agentId: string, force?: boolean): void;
+    resize(agentId: string, cols: number, rows: number): void;
+    killAll(): void;
+}

package/dist/pty/manager.js

@@ -0,0 +1,125 @@
+import * as pty from 'node-pty';
+import { AGENT_SPECS } from './agents.js';
+export class PtyManager {
+    handles = new Map();
+    spawn(agentId, agentKey, binary, args, cols, rows, onData, onExit, ctx) {
+        if (this.handles.has(agentId)) {
+            // Kill the stale PTY before spawning a new one for the same agentId
+            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);
+            console.error('[daemon] pty.spawn.failed', { agentId, agentKey, error: msg });
+            return false;
+        }
+        const handle = { agentId, agentKey, process: proc, pid: proc.pid, killed: false };
+        proc.onData(data => {
+            onData(Buffer.from(data).toString('base64'));
+        });
+        proc.onExit(({ exitCode, signal }) => {
+            if (handle.killed)
+                return;
+            this.handles.delete(agentId);
+            console.log('[daemon] pty.exit', { agentId, exitCode, signal });
+            onExit(exitCode ?? null, signal ? String(signal) : null);
+        });
+        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);
+    }
+    killAll() {
+        for (const handle of this.handles.values()) {
+            try {
+                process.kill(-handle.pid, 'SIGTERM');
+            }
+            catch {
+                handle.process.kill();
+            }
+        }
+        this.handles.clear();
+    }
+}