codehere 0.2.2 → 0.3.0-rc.10

package/dist/infrastructure/orchestration/session-manager.js

@@ -0,0 +1,278 @@
+/**
+ * In-memory registry of active task sessions + audit-log derived observation.
+ *
+ * Two kinds of session surfaced to the UI:
+ *   1. spawned   — started via codehere.spawn; we own the subprocess, can kill.
+ *   2. observed  — derived from the audit log. Claude Code sessions running
+ *                  in the user's terminals, IDE, or elsewhere on this machine.
+ *                  codehere didn't start them and can't kill them, but shows
+ *                  them so the dashboard reflects reality from first load.
+ *
+ * Durable state lives in the audit log (F0). On daemon restart, spawned
+ * sessions are gone but observed ones remain (they're re-derived from the log).
+ */
+import { existsSync, readFileSync } from 'fs';
+import { execFileSync } from 'child_process';
+import { ClaudeCodeAdapter } from './claude-code-adapter.js';
+import { CodexAdapter } from './codex-adapter.js';
+import { AiderAdapter } from './aider-adapter.js';
+import { OpenCodeAdapter } from './opencode-adapter.js';
+import { buildGenericAdapter, loadAgentsConfig } from './generic-cli-adapter.js';
+import { buildConductorAdapter } from './conductor-adapter.js';
+import { seedAgentsConfig } from './agents-config-seed.js';
+import { AUDIT_FILE } from '../hooks/claude-sdk-hook.js';
+import { appendSpawned, appendCompleted, loadRecent } from './session-persistence.js';
+// ── Agent registry ─────────────────────────────────────────────────────────────
+// All backends codehere can spawn. Order here drives the default UI dropdown
+// order. Built-in adapters first; user-config-driven ones appended from
+// ~/.codehere/agents.yaml (generic-cli-adapter). isInstalled() gates visibility
+// so an adapter registering for an un-installed CLI is harmless.
+const BUILTIN_REGISTRY = [ClaudeCodeAdapter, CodexAdapter, AiderAdapter, OpenCodeAdapter];
+// Seed the default agents.yaml if this user has never configured one, so Gemini
+// / Cursor / Pi / Antigravity / Goose appear in the registry pre-wired. They
+// stay hidden in the UI until isInstalled() flips to true. Idempotent.
+seedAgentsConfig();
+const REGISTRY = [
+    ...BUILTIN_REGISTRY,
+    // User-configurable adapters — "plug any CLI" escape hatch, seeded with
+    // popular CLI agents above. Users can add/edit/remove entries freely.
+    ...loadAgentsConfig().map(buildGenericAdapter),
+];
+// F6 Conductor — the meta-agent. Registered LAST so it sees the full registry
+// at lookup time. The lookup function is closed over `REGISTRY` so it always
+// returns the current populated array (including any future user adapters).
+// Conductor is appended to the same array so UIs that iterate REGISTRY see it.
+REGISTRY.push(buildConductorAdapter(() => REGISTRY));
+export function availableAgents() {
+    return REGISTRY.map((a) => ({ id: a.id, label: a.label, installed: a.isInstalled() }));
+}
+/** Per-agent readiness across the full registry. Powers the setup-aware UI. */
+export function readinessForAllAgents() {
+    return REGISTRY.map((a) => {
+        if (a.checkReadiness)
+            return a.checkReadiness();
+        // Fallback for adapters that haven't implemented checkReadiness yet: treat
+        // "installed" as "ready", "not installed" as "needs_install without hint".
+        const installed = a.isInstalled();
+        return installed
+            ? { id: a.id, label: a.label, state: 'ready', installed: true }
+            : { id: a.id, label: a.label, state: 'needs_install', installed: false };
+    });
+}
+export function getAdapter(id) {
+    return REGISTRY.find((a) => a.id === id);
+}
+export function allAdapters() {
+    return REGISTRY;
+}
+export function agentProcessPatterns() {
+    return REGISTRY.map((a) => ({
+        regex: a.processPattern,
+        agent: a.id,
+        label: a.label,
+    }));
+}
+const DEFAULT_OBSERVED_WINDOW_MS = 10 * 60 * 1000; // 10 minutes
+function parseEtime(s) {
+    // ps etime formats: "MM:SS", "HH:MM:SS", "D-HH:MM:SS"
+    let rest = s;
+    let days = 0;
+    if (rest.includes('-')) {
+        const [d, r] = rest.split('-');
+        days = parseInt(d, 10) || 0;
+        rest = r;
+    }
+    const parts = rest.split(':').map((p) => parseInt(p, 10) || 0);
+    if (parts.length === 2)
+        return parts[0] * 60 + parts[1];
+    if (parts.length === 3)
+        return days * 86400 + parts[0] * 3600 + parts[1] * 60 + parts[2];
+    return 0;
+}
+export class SessionManager {
+    sessions = new Map();
+    /** Read-only sessions replayed from ~/.codehere/sessions.jsonl on daemon start.
+     *  These subprocesses are long-dead; we surface them so the user doesn't lose
+     *  their Final reports across restarts. */
+    persistedCache = loadRecent(20);
+    spawn(prompt, agentId = 'claude-code', options) {
+        const adapter = getAdapter(agentId);
+        if (!adapter) {
+            throw new Error(`Unknown agent: ${agentId}. Registered: ${REGISTRY.map((a) => a.id).join(', ')}`);
+        }
+        if (!adapter.isInstalled()) {
+            throw new Error(`Agent ${adapter.label} (${adapter.id}) is not installed on this machine`);
+        }
+        const session = adapter.spawn(prompt, options);
+        this.sessions.set(session.sessionId, session);
+        // Persistence: write the spawned record immediately so a daemon crash still
+        // leaves an audit trail of what was attempted. Subscribe to exit so we can
+        // capture the final status + steps + artifacts when the session settles.
+        const cwd = options?.cwd ?? process.cwd();
+        appendSpawned({
+            id: session.sessionId,
+            agent: session.agent,
+            prompt,
+            cwd,
+            startedAt: session.startedAt,
+        });
+        const unsubscribe = session.subscribe((event) => {
+            if (event.type !== 'exit')
+                return;
+            const data = event.data;
+            appendCompleted({
+                id: session.sessionId,
+                status: session.status,
+                durationMs: Number(data?.durationMs ?? Date.now() - session.startedAt),
+                completedAt: Date.now(),
+                steps: session.steps ? [...session.steps] : undefined,
+                artifacts: session.artifacts,
+            });
+            unsubscribe();
+        });
+        return session;
+    }
+    /** Persisted (read-only) sessions from prior daemon runs. Cached at boot. */
+    listPersisted() {
+        return this.persistedCache;
+    }
+    get(sessionId) {
+        return this.sessions.get(sessionId);
+    }
+    list() {
+        return Array.from(this.sessions.values());
+    }
+    kill(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return false;
+        session.kill();
+        return true;
+    }
+    /**
+     * Active Claude Code sessions on this machine, derived from the audit log.
+     * A session is "active" if any tool call from it was recorded within the
+     * last `maxAgeMs` milliseconds. Returns most-recent first.
+     *
+     * Note: codehere-spawned sessions may also appear here because they produce
+     * audit entries just like any other Claude Code session. The UI distinguishes
+     * by provenance.
+     */
+    listObserved(maxAgeMs = DEFAULT_OBSERVED_WINDOW_MS) {
+        if (!existsSync(AUDIT_FILE))
+            return [];
+        const now = Date.now();
+        const cutoff = now - maxAgeMs;
+        const byId = new Map();
+        let content;
+        try {
+            content = readFileSync(AUDIT_FILE, 'utf-8');
+        }
+        catch {
+            return [];
+        }
+        const lines = content.split('\n');
+        // Walk backwards — most recent lines first — and stop early when we
+        // pass the window. Audit log appends chronologically.
+        for (let i = lines.length - 1; i >= 0; i--) {
+            const line = lines[i].trim();
+            if (!line)
+                continue;
+            let entry;
+            try {
+                entry = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (!entry.sessionId)
+                continue;
+            const ts = typeof entry.timestamp === 'number'
+                ? entry.timestamp
+                : entry.timestamp
+                    ? Date.parse(String(entry.timestamp))
+                    : 0;
+            if (!ts)
+                continue;
+            if (ts < cutoff)
+                break; // past the window; older entries can't qualify
+            const existing = byId.get(entry.sessionId);
+            if (existing) {
+                existing.eventCount += 1;
+                if (ts < existing.firstEventAt)
+                    existing.firstEventAt = ts;
+            }
+            else {
+                byId.set(entry.sessionId, {
+                    sessionId: entry.sessionId,
+                    firstEventAt: ts,
+                    lastEventAt: ts,
+                    eventCount: 1,
+                    recentTool: entry.toolName,
+                    provenance: 'observed',
+                });
+            }
+        }
+        return Array.from(byId.values()).sort((a, b) => b.lastEventAt - a.lastEventAt);
+    }
+    /**
+     * Agent processes running on this machine right now.
+     * Enumerates via `ps`, filters to known agent executables, returns most
+     * recently started first. This is the primary F1d surface — it reflects
+     * "what AI agents are alive on your machine" independent of whether
+     * they've produced audit events yet.
+     */
+    listActiveAgents() {
+        let out;
+        try {
+            out = execFileSync('ps', ['-A', '-o', 'pid,tty,etime,args'], {
+                encoding: 'utf-8',
+                timeout: 2000,
+            });
+        }
+        catch {
+            return [];
+        }
+        const agents = [];
+        const lines = out.trim().split('\n').slice(1); // drop header
+        for (const line of lines) {
+            const m = line.trim().match(/^(\d+)\s+(\S+)\s+(\S+)\s+(.+)$/);
+            if (!m)
+                continue;
+            const [, pidStr, tty, etime, args] = m;
+            // Skip ourselves — the codehere daemon would otherwise show up repeatedly
+            if (/\bcodehere\b|\bch\s+start\b/.test(args))
+                continue;
+            // Skip the audit tailer from other codehere commands
+            if (/scan-tool|codehere-audit/.test(args))
+                continue;
+            let matched = null;
+            for (const p of agentProcessPatterns()) {
+                if (p.regex.test(args)) {
+                    matched = { agent: p.agent, label: p.label };
+                    break;
+                }
+            }
+            if (!matched)
+                continue;
+            const uptimeSeconds = parseEtime(etime);
+            const startedAt = Date.now() - uptimeSeconds * 1000;
+            agents.push({
+                pid: parseInt(pidStr, 10),
+                tty,
+                agent: matched.agent,
+                label: matched.label,
+                args: args.length > 200 ? args.slice(0, 200) + '…' : args,
+                startedAt,
+                uptimeSeconds,
+                provenance: 'detected',
+            });
+        }
+        return agents.sort((a, b) => b.startedAt - a.startedAt);
+    }
+    static _instance;
+    static getInstance() {
+        return (this._instance ??= new SessionManager());
+    }
+}
+//# sourceMappingURL=session-manager.js.map

package/dist/infrastructure/orchestration/session-persistence.js

@@ -0,0 +1,109 @@
+/**
+ * Session persistence — survives daemon restart.
+ *
+ * Beta.3 dogfood surfaced a reliability gap: after `ch start` exited and was
+ * relaunched, the task UI was empty even when completed sessions had produced
+ * valuable final reports. The audit log (hook-events.jsonl) persisted every
+ * tool call but not the session-level PM state (prompt, artifacts, steps).
+ *
+ * This module adds a minimal two-record schema:
+ *   { t: 'spawned',   id, agent, prompt, cwd, startedAt }
+ *   { t: 'completed', id, status, durationMs, steps, artifacts, completedAt }
+ *
+ * On spawn, we write the first line. On exit, we write the second. On daemon
+ * start, we read the last N pairs and surface them as read-only "persisted"
+ * sessions (no kill button, no live stream; the subprocess died with the
+ * previous daemon).
+ *
+ * Write path stays append-only — never rewrites history. Lock-free because
+ * single writer (the daemon). If two daemons ran concurrently the worst case
+ * is interleaved lines, which the reader tolerates.
+ */
+import { existsSync, mkdirSync, appendFileSync, readFileSync } from 'fs';
+import { homedir } from 'os';
+import { join, dirname } from 'path';
+const SESSIONS_FILE = join(homedir(), '.codehere', 'sessions.jsonl');
+function ensureDir() {
+    const dir = dirname(SESSIONS_FILE);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+}
+export function appendSpawned(rec) {
+    try {
+        ensureDir();
+        appendFileSync(SESSIONS_FILE, JSON.stringify({ t: 'spawned', ...rec }) + '\n', 'utf-8');
+    }
+    catch {
+        /* persistence is best-effort; never break the spawn path */
+    }
+}
+export function appendCompleted(rec) {
+    try {
+        ensureDir();
+        appendFileSync(SESSIONS_FILE, JSON.stringify({ t: 'completed', ...rec }) + '\n', 'utf-8');
+    }
+    catch {
+        /* best-effort */
+    }
+}
+/**
+ * Walk the session log backward, pair spawned+completed records by id, return
+ * the most recent `limit` completed pairs sorted newest-first.
+ *
+ * We only surface fully-completed sessions because an orphaned `spawned` with
+ * no `completed` means either: (a) the daemon died mid-task (subprocess also
+ * died, no artifacts), or (b) a concurrent daemon is mid-flight (not ours to
+ * show). Either way, not useful in the UI.
+ */
+export function loadRecent(limit = 20) {
+    if (!existsSync(SESSIONS_FILE))
+        return [];
+    let content;
+    try {
+        content = readFileSync(SESSIONS_FILE, 'utf-8');
+    }
+    catch {
+        return [];
+    }
+    const spawned = new Map();
+    const completed = [];
+    for (const line of content.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        let rec;
+        try {
+            rec = JSON.parse(trimmed);
+        }
+        catch {
+            continue;
+        }
+        if (rec.t === 'spawned')
+            spawned.set(rec.id, rec);
+        else if (rec.t === 'completed')
+            completed.push(rec);
+    }
+    const merged = [];
+    // Walk completed in reverse so we return newest-first
+    for (let i = completed.length - 1; i >= 0 && merged.length < limit; i--) {
+        const c = completed[i];
+        const s = spawned.get(c.id);
+        if (!s)
+            continue; // orphan completed (shouldn't happen but harmless)
+        merged.push({
+            sessionId: s.id,
+            agent: s.agent,
+            prompt: s.prompt,
+            cwd: s.cwd,
+            startedAt: s.startedAt,
+            status: c.status,
+            durationMs: c.durationMs,
+            completedAt: c.completedAt,
+            steps: c.steps,
+            artifacts: c.artifacts,
+            provenance: 'persisted',
+        });
+    }
+    return merged;
+}
+//# sourceMappingURL=session-persistence.js.map

package/dist/infrastructure/protocols/mcp-helpers.js

@@ -2,41 +2,21 @@
  * MCP helper functions — shared between MCP server and trust command.
  * Extracted to avoid circular imports.
  */
-import { readFileSync, statSync, readdirSync } from 'fs';
-import { join, extname } from 'path';
+import { readFileSync } from 'fs';
+import { collectCodeFiles } from '../security/file-collection.js';
 // ── File collection ──────────────────────────────────────────────────────────
-const CODE_EXTENSIONS = new Set([
-    '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
-    '.py', '.rb', '.go', '.java', '.cs', '.php',
-    '.sh', '.bash', '.zsh',
-    '.sql', '.html', '.vue', '.svelte',
-]);
-const IGNORE_DIRS = new Set(['node_modules', '.git', 'dist', 'build', '.next', 'coverage', '.cache', '.codehere', '.codehere-cache']);
+// Uses the shared walker — same exclusion rules as trust and report.
 export function collectFilesForMCP(target) {
+    const paths = collectCodeFiles(target);
     const result = [];
-    function walk(dir) {
-        for (const entry of readdirSync(dir, { withFileTypes: true })) {
-            if (IGNORE_DIRS.has(entry.name))
-                continue;
-            const full = join(dir, entry.name);
-            if (entry.isDirectory()) {
-                walk(full);
-            }
-            else if (CODE_EXTENSIONS.has(extname(entry.name))) {
-                try {
-                    result.push({ filepath: full, code: readFileSync(full, 'utf-8') });
-                }
-                catch {
-                    // skip unreadable files
-                }
-            }
+    for (const filepath of paths) {
+        try {
+            result.push({ filepath, code: readFileSync(filepath, 'utf-8') });
+        }
+        catch {
+            // skip unreadable files (iCloud-evicted, permissions, too large)
         }
     }
-    const stat = statSync(target);
-    if (stat.isFile()) {
-        return [{ filepath: target, code: readFileSync(target, 'utf-8') }];
-    }
-    walk(target);
     return result;
 }
 // ── Scoring ──────────────────────────────────────────────────────────────────