bridge-agent 0.2.11 → 0.2.13

package/dist/metrics.d.ts

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

package/dist/metrics.js

@@ -0,0 +1,123 @@
+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 ramStatsMacos() {
+    const total = os.totalmem();
+    const free = os.freemem();
+    // Parse vm_stat to get cached pages
+    // "Cached" = (Pages speculative + Pages inactive) * page_size
+    // These are file-backed pages that can be reclaimed by the system
+    let cachedPages = 0;
+    try {
+        const r = spawnSync('vm_stat', ['-c', '10'], { encoding: 'utf-8', timeout: 2000, stdio: 'pipe' });
+        if (r.status === 0 && r.stdout) {
+            // vm_stat reports page size at top: "page size of 16384 bytes"
+            const pgSizeMatch = r.stdout.match(/page size of (\d+) bytes/);
+            const speccMatch = r.stdout.match(/Pages speculative:\s*(\d+)/);
+            const inactMatch = r.stdout.match(/Pages inactive:\s*(\d+)/);
+            if (speccMatch && inactMatch) {
+                const PAGE_SIZE = pgSizeMatch ? parseInt(pgSizeMatch[1], 10) : 4096;
+                cachedPages = (parseInt(speccMatch[1], 10) + parseInt(inactMatch[1], 10)) * PAGE_SIZE;
+            }
+        }
+    }
+    catch { /* ignore */ }
+    return {
+        totalMb: Math.round(total / 1024 / 1024),
+        usedMb: Math.round((total - free) / 1024 / 1024),
+        cachedMb: Math.round(cachedPages / 1024 / 1024),
+    };
+}
+function ramStats() {
+    if (process.platform === 'darwin')
+        return ramStatsMacos();
+    // Linux: cached is included in free per os.freemem() docs, so cached ~= 0
+    const total = os.totalmem();
+    const free = os.freemem();
+    return {
+        totalMb: Math.round(total / 1024 / 1024),
+        usedMb: Math.round((total - free) / 1024 / 1024),
+        cachedMb: 0,
+    };
+}
+// ── 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,
+            ramCachedMb: ram.cachedMb,
+            battery: cachedBattery,
+        });
+    }, METRICS_INTERVAL_MS);
+    return () => clearInterval(timer);
+}

package/dist/pty/agents.d.ts

@@ -0,0 +1,30 @@
+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;
+    /**
+     * Agent-specific version directory globs (relative to HOME).
+     * Each entry is a glob pattern; the binary name is appended.
+     */
+    versionDirGlobs?: string[];
+}
+declare const AGENT_SPECS: AgentSpec[];
+export { AGENT_SPECS };
+export type { AgentSpec };
+export declare function detectAgents(globalAgentPaths?: Record<string, string>): Promise<AgentInfo[]>;

package/dist/pty/agents.js

@@ -0,0 +1,228 @@
+import which from 'which';
+import fs from 'fs';
+import path from 'path';
+import net from 'net';
+import { spawnSync } from 'child_process';
+// 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,
+        versionDirGlobs: ['.local/share/claude/versions/*'],
+    },
+    {
+        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,
+        versionDirGlobs: ['.local/share/qwen/versions/*'],
+    },
+    {
+        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,
+    },
+    {
+        key: 'kimi',
+        displayName: 'Kimi Code',
+        binary: 'kimi',
+        checkAuth: async () => checkDir('.kimi') || checkEnv('KIMI_API_KEY'),
+        assignSessionId: true,
+        spawnArgs: ['--yolo'],
+        resumeArgs: (id) => ['-r', id, '--yolo'],
+        supportsMcpConfig: true,
+        // NOTE: Kimi does not support --system-prompt-file
+        // Role prompts disabled via buildRolePromptArgs()
+        formatInput: appendCR,
+        versionDirGlobs: ['.local/share/uv/tools/kimi-cli/bin', '.local/share/kimi/versions/*'],
+    },
+];
+export { AGENT_SPECS };
+// ── Version detection helpers ────────────────────────────────────────────────
+const HOME = process.env['HOME'] ?? '/Users/unknown';
+/** Run `binary --version` and return the first non-empty stdout line, or undefined on failure. */
+function getVersionFromBinary(binaryPath) {
+    try {
+        const r = spawnSync(binaryPath, ['--version'], { timeout: 5000 });
+        if (r.status !== 0)
+            return undefined;
+        const firstLine = (r.stdout ?? r.stderr ?? Buffer.from(''))
+            .toString('utf8')
+            .split('\n')[0]
+            .trim();
+        return firstLine || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Scan agent-specific version directories for a working binary.
+ * Returns candidates in order they should be tried (newest first).
+ */
+function scanVersionDirs(spec) {
+    if (!spec.versionDirGlobs?.length)
+        return [];
+    // Use a simple glob-style scan — no extra dependencies needed
+    const results = [];
+    const patterns = spec.versionDirGlobs;
+    for (const pattern of patterns) {
+        const baseDir = path.join(HOME, pattern.replace(/\/\*$/, ''));
+        // If pattern ends in /*, scan that directory for versions
+        if (pattern.endsWith('/*')) {
+            let entries = [];
+            try {
+                entries = fs.readdirSync(baseDir);
+            }
+            catch { /* dir doesn't exist */ }
+            // Sort newest-first (assuming version numbers in dir names)
+            entries.sort((a, b) => b.localeCompare(a));
+            for (const entry of entries) {
+                const candidate = path.join(baseDir, entry, spec.binary);
+                if (fs.existsSync(candidate)) {
+                    const version = getVersionFromBinary(candidate);
+                    results.push({ path: candidate, version });
+                }
+            }
+        }
+        else {
+            // Literal path (e.g. ~/.local/share/uv/tools/kimi-cli/bin/kimi)
+            const candidate = path.join(HOME, pattern);
+            if (fs.existsSync(candidate)) {
+                const version = getVersionFromBinary(candidate);
+                results.push({ path: candidate, version });
+            }
+        }
+    }
+    return results;
+}
+/**
+ * Resolve the best working binary for an agent.
+ *
+ * Priority order:
+ *  1. Config override (global agentPaths from BridgeConfig)
+ *  2. which() result + spawnSync --version validation
+ *  3. Version directory scan (newest first) + spawnSync validation
+ *
+ * Returns { path, version } or throws if no working binary found.
+ */
+async function resolveAgentBinary(spec, globalAgentPaths = {}) {
+    // 1. Config override
+    if (globalAgentPaths[spec.key]) {
+        const override = globalAgentPaths[spec.key];
+        const version = getVersionFromBinary(override);
+        if (version)
+            return { path: override, version };
+    }
+    // 2. which() + spawnSync validation
+    try {
+        const whichPath = await which(spec.binary);
+        if (whichPath && fs.existsSync(whichPath)) {
+            const version = getVersionFromBinary(whichPath);
+            if (version !== undefined) {
+                return { path: whichPath, version };
+            }
+        }
+    }
+    catch { /* not in PATH */ }
+    // 3. Version directory scan
+    const candidates = scanVersionDirs(spec);
+    for (const candidate of candidates) {
+        if (candidate.version !== undefined) {
+            return candidate;
+        }
+    }
+    // Last resort: which() result even if --version failed (backward compat)
+    try {
+        const whichPath = await which(spec.binary);
+        if (whichPath)
+            return { path: whichPath };
+    }
+    catch { /* not in PATH */ }
+    throw new Error(`No working binary found for agent '${spec.key}'`);
+}
+export async function detectAgents(globalAgentPaths = {}) {
+    const results = [];
+    for (const spec of AGENT_SPECS) {
+        try {
+            const { path: binaryPath, version } = await resolveAgentBinary(spec, globalAgentPaths);
+            const authOk = await spec.checkAuth();
+            const authStatus = authOk ? 'ok' : 'missing';
+            results.push({ key: spec.key, displayName: spec.displayName, binaryPath, authStatus, version });
+        }
+        catch {
+            // binary not found or not spawnable — 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,22 @@
+import type { WorkspaceId, ProjectId, AgentId } from '../shared/types.js';
+export interface SpawnContext {
+    serverUrl: string;
+    token: string;
+    workspaceId: WorkspaceId;
+    projectId: ProjectId;
+    agentId?: AgentId;
+    cwd?: string;
+    /** Extra env vars from .jerico/settings.json — merged over process.env */
+    projectEnv?: Record<string, string>;
+}
+export declare class PtyManager {
+    private handles;
+    private nextInstanceId;
+    private lastErrors;
+    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;
+    getLastError(agentId: string): string | undefined;
+    killAll(): void;
+}