@bivy/bivy 0.0.0 → 0.1.0-staging.2

package/dist/runtime/agent-service.js

@@ -0,0 +1,439 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+// Copyright (c) 2026 Petter André Sjulstad
+import { RPC_PROTOCOL_VERSION } from "./rpc-protocol.js";
+const defaultReaperTimers = {
+    schedule: (fn, ms) => setTimeout(fn, ms),
+    cancel: (h) => clearTimeout(h),
+};
+function modelKey(model) {
+    return model ? `${model.provider}:${model.id}` : "";
+}
+export class AgentService {
+    runtimeProvider;
+    log;
+    sessions = new Map();
+    binding = new Map();
+    detachReapMs;
+    timers;
+    now;
+    sweepHandle;
+    constructor(options) {
+        this.runtimeProvider = options.runtimeProvider;
+        this.log = options.log ?? (() => { });
+        this.detachReapMs = options.detachReapMs && options.detachReapMs > 0 ? options.detachReapMs : 0;
+        this.timers = options.timers ?? defaultReaperTimers;
+        this.now = options.now ?? (() => Date.now());
+        if (this.detachReapMs)
+            this.armSweep();
+    }
+    /** Number of live (non-disposed) sessions — test/introspection aid. */
+    get sessionCount() {
+        return this.sessions.size;
+    }
+    /** Attach the service to a new daemon connection. */
+    accept(conn) {
+        conn.onMessage((message) => {
+            void this.dispatch(conn, message).catch((error) => {
+                this.log(`agent-service dispatch error: ${error instanceof Error ? error.stack : String(error)}`);
+            });
+        });
+        conn.onClose(() => this.handleConnClose(conn));
+    }
+    /** Reap every session (service shutdown). */
+    disposeAll() {
+        if (this.sweepHandle !== undefined) {
+            this.timers.cancel(this.sweepHandle);
+            this.sweepHandle = undefined;
+        }
+        for (const svc of [...this.sessions.values()])
+            this.reap(svc);
+    }
+    // ---- idle-reaper (detached sessions) --------------------------------------
+    /** Schedule the next sweep at ~half the TTL, so worst-case overshoot is bounded. */
+    armSweep() {
+        if (!this.detachReapMs)
+            return;
+        this.sweepHandle = this.timers.schedule(() => this.sweep(), Math.max(1, Math.floor(this.detachReapMs / 2)));
+    }
+    /**
+     * Reap sessions that have been DETACHED (no bound daemon connection) and IDLE
+     * (not currently streaming) for at least the TTL. Never touches an attached or
+     * streaming session — a live turn keeps running. Public for tests; also re-arms.
+     */
+    sweep() {
+        if (!this.detachReapMs)
+            return;
+        const now = this.now();
+        for (const svc of [...this.sessions.values()]) {
+            if (svc.disposed || svc.conn)
+                continue; // attached → keep
+            if (svc.session?.isStreaming)
+                continue; // mid-turn → keep (don't kill a live turn)
+            if (now - svc.lastActiveAt >= this.detachReapMs) {
+                this.log(`agent-service reaping detached idle session ${svc.id} (idle ${Math.round((now - svc.lastActiveAt) / 1000)}s)`);
+                this.reap(svc);
+            }
+        }
+        this.armSweep();
+    }
+    async dispatch(conn, message) {
+        switch (message.t) {
+            case "start":
+                return this.handleStart(conn, message);
+            case "rt":
+                return this.handleRuntimeCall(conn, message);
+            case "req":
+                return this.handleRequest(conn, message);
+            case "notify":
+                return this.handleNotify(conn, message);
+            case "intercept-res":
+                return this.handleInterceptResult(conn, message);
+            case "tool-invoke-res":
+                return this.handleToolInvokeResult(conn, message);
+        }
+    }
+    // ---- start / attach -------------------------------------------------------
+    async handleStart(conn, message) {
+        if (message.protocol !== RPC_PROTOCOL_VERSION) {
+            conn.send({ t: "res", id: message.id, ok: false, error: `Unsupported RPC protocol ${message.protocol} (service speaks ${RPC_PROTOCOL_VERSION})` });
+            return;
+        }
+        try {
+            if (message.op === "attach") {
+                const existing = message.options.sessionId ? this.sessions.get(message.options.sessionId) : undefined;
+                if (!existing || existing.disposed)
+                    throw new Error(`No detached session to attach: ${message.options.sessionId}`);
+                // Re-bind: detach any stale connection, resync full state, resume forwarding.
+                existing.conn = conn;
+                existing.pendingIntercepts.clear();
+                existing.pendingInvokes.clear();
+                existing.lastActiveAt = this.now(); // re-attach counts as activity
+                this.binding.set(conn, existing);
+                existing.lastSent = this.mirror(existing.session);
+                conn.send({ t: "started", id: message.id, snapshot: this.initialSnapshot(existing) });
+                return;
+            }
+            const runtime = this.runtimeProvider(message.runtime, message.sandbox);
+            // Shell first so the interceptor closure can reference the not-yet-built session.
+            const svc = {
+                id: "",
+                runtime,
+                session: undefined,
+                unsubscribe: () => { },
+                conn,
+                interceptSeq: 1,
+                pendingIntercepts: new Map(),
+                invokeSeq: 1,
+                pendingInvokes: new Map(),
+                lastSent: undefined,
+                disposed: false,
+                lastActiveAt: this.now(),
+            };
+            const toolInterceptor = message.options.hasToolInterceptor ? this.makeInterceptor(svc) : undefined;
+            // Reconstruct a proxy ToolProvider from the specs the daemon sent, so the
+            // hosted runtime gets the tools while each call routes back to the daemon.
+            const toolProvider = message.options.toolSpecs?.length ? this.makeToolProvider(svc, message.options.toolSpecs) : undefined;
+            const workspace = message.options.workspace ?? process.cwd();
+            const result = message.op === "open" && message.options.sessionFile
+                ? await runtime.openSession({ workspace, sessionFile: message.options.sessionFile, toolInterceptor, toolProvider })
+                : await runtime.createSession({ workspace, toolInterceptor, toolProvider });
+            svc.session = result.session;
+            svc.id = result.session.id;
+            svc.lastSent = this.mirror(result.session);
+            this.sessions.set(svc.id, svc);
+            this.binding.set(conn, svc);
+            svc.unsubscribe = result.session.subscribe((event) => this.forward(svc, event));
+            const snapshot = this.initialSnapshot(svc);
+            if (result.warning)
+                snapshot.warning = result.warning;
+            conn.send({ t: "started", id: message.id, snapshot });
+        }
+        catch (error) {
+            conn.send({ t: "res", id: message.id, ok: false, error: error instanceof Error ? error.message : String(error) });
+        }
+    }
+    // ---- session-less runtime calls ------------------------------------------
+    async handleRuntimeCall(conn, message) {
+        if (message.protocol !== RPC_PROTOCOL_VERSION) {
+            conn.send({ t: "res", id: message.id, ok: false, error: `Unsupported RPC protocol ${message.protocol}` });
+            return;
+        }
+        try {
+            const runtime = this.runtimeProvider(message.runtime, message.sandbox);
+            let value;
+            if (message.method === "listSessions") {
+                value = await runtime.listSessions();
+            }
+            else if (message.method === "deleteSession") {
+                value = (await runtime.deleteSession?.(message.args[0], message.args[1])) ?? false;
+            }
+            conn.send({ t: "res", id: message.id, ok: true, value });
+        }
+        catch (error) {
+            conn.send({ t: "res", id: message.id, ok: false, error: error instanceof Error ? error.message : String(error) });
+        }
+    }
+    // ---- per-session method dispatch -----------------------------------------
+    async handleRequest(conn, message) {
+        const svc = this.binding.get(conn);
+        if (!svc) {
+            conn.send({ t: "res", id: message.id, ok: false, error: "No session bound to this connection" });
+            return;
+        }
+        const s = svc.session;
+        const [a0, a1] = message.args;
+        try {
+            let value;
+            let snapshot;
+            switch (message.method) {
+                case "prompt":
+                    await s.prompt(a0, a1);
+                    break;
+                case "abort":
+                    await s.abort();
+                    break;
+                case "setModel":
+                    await s.setModel(a0, a1);
+                    snapshot = { currentModel: s.getCurrentModel() ?? null };
+                    break;
+                case "getModels":
+                    value = await s.getModels();
+                    break;
+                case "getAllModels":
+                    value = (await s.getAllModels?.()) ?? [];
+                    break;
+                case "getUsage":
+                    value = (await s.getUsage?.()) ?? undefined;
+                    break;
+                case "suggestName":
+                    value = await s.suggestName(a0);
+                    break;
+                case "invokeCommand":
+                    await s.invokeCommand?.(a0, a1);
+                    break;
+                case "interactiveTuiCommand":
+                    value = (await s.interactiveTuiCommand?.()) ?? null;
+                    break;
+            }
+            conn.send({ t: "res", id: message.id, ok: true, value, snapshot });
+        }
+        catch (error) {
+            conn.send({ t: "res", id: message.id, ok: false, error: error instanceof Error ? error.message : String(error) });
+        }
+    }
+    handleNotify(conn, message) {
+        const svc = this.binding.get(conn);
+        if (!svc)
+            return;
+        if (message.method === "dispose") {
+            this.reap(svc);
+            return;
+        }
+        try {
+            if (message.method === "setName")
+                svc.session.setName(message.args[0]);
+            else if (message.method === "setThinkingLevel")
+                svc.session.setThinkingLevel?.(message.args[0]);
+        }
+        catch (error) {
+            this.log(`agent-service notify ${message.method} error: ${String(error)}`);
+        }
+    }
+    handleInterceptResult(conn, message) {
+        const svc = this.binding.get(conn);
+        const resolve = svc?.pendingIntercepts.get(message.id);
+        if (svc && resolve) {
+            svc.pendingIntercepts.delete(message.id);
+            resolve(message.decision);
+        }
+    }
+    handleToolInvokeResult(conn, message) {
+        const svc = this.binding.get(conn);
+        const resolve = svc?.pendingInvokes.get(message.id);
+        if (svc && resolve) {
+            svc.pendingInvokes.delete(message.id);
+            resolve(message.result);
+        }
+    }
+    // ---- tool interception (reverse RPC to the daemon) ------------------------
+    makeInterceptor(svc) {
+        return (ctx) => {
+            const conn = svc.conn;
+            // Detached (daemon gone): never run an unapproved tool.
+            if (!conn)
+                return { block: true, reason: "agent daemon disconnected" };
+            return new Promise((resolve) => {
+                const id = svc.interceptSeq++;
+                svc.pendingIntercepts.set(id, resolve);
+                // If the turn aborts service-side, settle immediately so nothing hangs.
+                ctx.signal?.addEventListener("abort", () => {
+                    if (svc.pendingIntercepts.delete(id))
+                        resolve({});
+                }, { once: true });
+                conn.send({ t: "intercept", id, ctx: { sessionId: ctx.sessionId, toolName: ctx.toolName, input: ctx.input } });
+            });
+        };
+    }
+    // ---- node-hosted tools (reverse RPC to the daemon) ------------------------
+    /**
+     * Build a proxy ToolProvider from the specs the daemon sent. `list()` returns
+     * those specs (so the hosted runtime registers the tools); `invoke()` forwards
+     * the call to the daemon as a `tool-invoke` and resolves on its
+     * `tool-invoke-res`, so the tool executes on the daemon where its credentials
+     * live — the same reverse-RPC shape the guardian uses.
+     */
+    makeToolProvider(svc, specs) {
+        return {
+            list: () => specs,
+            invoke: (toolName, toolCallId, params, signal) => {
+                const conn = svc.conn;
+                // Detached (daemon gone): can't run a tool whose implementation lives there.
+                if (!conn)
+                    return Promise.resolve({ content: [{ type: "text", text: "agent daemon disconnected" }], isError: true });
+                return new Promise((resolve) => {
+                    const id = svc.invokeSeq++;
+                    svc.pendingInvokes.set(id, resolve);
+                    // If the turn aborts service-side, settle immediately so nothing hangs.
+                    signal?.addEventListener("abort", () => {
+                        if (svc.pendingInvokes.delete(id))
+                            resolve({ content: [{ type: "text", text: "aborted" }], isError: true });
+                    }, { once: true });
+                    conn.send({ t: "tool-invoke", id, sessionId: svc.id, toolName, toolCallId, params });
+                });
+            },
+        };
+    }
+    // ---- event forwarding + snapshots ----------------------------------------
+    forward(svc, event) {
+        svc.lastActiveAt = this.now(); // any runtime event is activity (reaper anchor)
+        const conn = svc.conn;
+        if (!conn)
+            return; // detached: the daemon re-syncs full state on attach
+        // agent_end is the boundary the daemon's post-turn logic reads (usage
+        // refresh, worktree diff, PR detection). Force the authoritative post-turn
+        // state onto that frame so the mirror is correct even for a runtime that
+        // mutates messages/sessionFile exactly at agent_end (no prior message_end
+        // delta) — the "set before agent_end" invariant in process.ts.
+        const authoritative = event.type === "agent_end";
+        const snapshot = this.snapshotDelta(svc, authoritative);
+        const message = snapshot ? { t: "event", event, snapshot } : { t: "event", event };
+        conn.send(message);
+    }
+    mirror(session) {
+        return {
+            isStreaming: session.isStreaming,
+            sessionFile: session.sessionFile,
+            name: session.getName(),
+            currentModelKey: modelKey(session.getCurrentModel()),
+            activePid: session.activePid?.(),
+            thinkingLevel: session.getThinkingLevel?.(),
+            messageCount: session.getMessages().length,
+        };
+    }
+    /**
+     * Diff the current session state against lastSent; return only what changed.
+     * When `authoritative`, force the post-turn fields (isStreaming/sessionFile/
+     * activePid/messages) into the delta even if unchanged, so the caller can
+     * guarantee the agent_end frame carries them.
+     */
+    snapshotDelta(svc, authoritative = false) {
+        const s = svc.session;
+        const now = this.mirror(s);
+        const prev = svc.lastSent;
+        const delta = {};
+        let changed = false;
+        if (authoritative || now.isStreaming !== prev.isStreaming) {
+            delta.isStreaming = now.isStreaming;
+            changed = true;
+        }
+        if (authoritative || now.sessionFile !== prev.sessionFile) {
+            delta.sessionFile = now.sessionFile ?? null;
+            changed = true;
+        }
+        if (now.name !== prev.name) {
+            delta.name = now.name ?? null;
+            changed = true;
+        }
+        if (now.currentModelKey !== prev.currentModelKey) {
+            delta.currentModel = s.getCurrentModel() ?? null;
+            changed = true;
+        }
+        if (authoritative || now.activePid !== prev.activePid) {
+            delta.activePid = now.activePid ?? null;
+            changed = true;
+        }
+        if (now.thinkingLevel !== prev.thinkingLevel) {
+            delta.thinkingLevel = now.thinkingLevel ?? null;
+            changed = true;
+        }
+        if (authoritative || now.messageCount !== prev.messageCount) {
+            delta.messages = s.getMessages();
+            changed = true;
+        }
+        svc.lastSent = now;
+        return changed ? delta : undefined;
+    }
+    initialSnapshot(svc) {
+        const s = svc.session;
+        return {
+            sessionId: s.id,
+            cwd: s.cwd,
+            isStreaming: s.isStreaming,
+            sessionFile: s.sessionFile ?? null,
+            name: s.getName() ?? null,
+            currentModel: s.getCurrentModel() ?? null,
+            activePid: s.activePid?.() ?? null,
+            thinkingLevel: s.getThinkingLevel?.() ?? null,
+            messages: s.getMessages(),
+            capabilities: svc.runtime.capabilities,
+            supportsThinking: s.supportsThinking?.() ?? false,
+            availableThinkingLevels: s.getAvailableThinkingLevels?.() ?? [],
+            commands: s.getCommands?.() ?? [],
+        };
+    }
+    // ---- teardown -------------------------------------------------------------
+    handleConnClose(conn) {
+        const svc = this.binding.get(conn);
+        this.binding.delete(conn);
+        if (!svc || svc.disposed)
+            return;
+        if (svc.conn !== conn)
+            return; // a newer connection already took over
+        // Detach: keep the child running, deny any tool waiting on the vanished daemon.
+        svc.conn = null;
+        svc.lastActiveAt = this.now(); // start the idle-reaper clock from the detach
+        for (const resolve of svc.pendingIntercepts.values())
+            resolve({ block: true, reason: "agent daemon disconnected" });
+        svc.pendingIntercepts.clear();
+        for (const resolve of svc.pendingInvokes.values())
+            resolve({ content: [{ type: "text", text: "agent daemon disconnected" }], isError: true });
+        svc.pendingInvokes.clear();
+        this.log(`agent-service session ${svc.id} detached (kept running)`);
+    }
+    reap(svc) {
+        if (svc.disposed)
+            return;
+        svc.disposed = true;
+        for (const resolve of svc.pendingIntercepts.values())
+            resolve({ block: true, reason: "session disposed" });
+        svc.pendingIntercepts.clear();
+        for (const resolve of svc.pendingInvokes.values())
+            resolve({ content: [{ type: "text", text: "session disposed" }], isError: true });
+        svc.pendingInvokes.clear();
+        try {
+            svc.unsubscribe();
+        }
+        catch {
+            // ignore
+        }
+        try {
+            svc.session?.dispose();
+        }
+        catch (error) {
+            this.log(`agent-service dispose error for ${svc.id}: ${String(error)}`);
+        }
+        if (svc.conn)
+            this.binding.delete(svc.conn);
+        this.sessions.delete(svc.id);
+    }
+}

package/dist/runtime/ansi.js

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+// Copyright (c) 2026 Petter André Sjulstad
+// ANSI escape-sequence stripping for user-facing CLI output.
+//
+// Dumb-pipe CLI agents (OpenCode, Aider, …) colorize their stdout/stderr with
+// ANSI SGR/CSI escapes meant for a real terminal. Bivy relays that text into the
+// app's "Agent output" pane verbatim, where the escapes render as garbage like
+// `[91m[1mError: [0m…` instead of a red bold "Error:". The pane shows plain
+// text, so the color codes carry no information — strip them at display time.
+//
+// We strip only what's emitted to the UI, never the buffered stdout/stderr the
+// runtime parses for exit-code/error logic, so parsing stays byte-exact.
+// ESC () or 8-bit CSI (›) introducer followed by either:
+//   • an OSC string (`ESC ] … BEL` — window title / hyperlinks), or
+//   • a CSI sequence (`ESC [ params final-byte` — colors, cursor moves).
+// The final-byte class is deliberately broad so SGR colors (incl. 24-bit),
+// cursor moves, and erase codes are all removed. Mirrors the widely-used
+// `ansi-regex` pattern, restated with explicit escapes (no literal control
+// characters in source).
+const ANSI_PATTERN = new RegExp([
+    "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d/#&.:=?%@~_]*)*)?\\u0007)",
+    "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))",
+].join("|"), "g");
+/** Remove ANSI escape sequences from a string for plain-text display. */
+export function stripAnsi(input) {
+    return input.replace(ANSI_PATTERN, "");
+}

package/dist/runtime/anthropic-preflight.js

@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+// Copyright (c) 2026 Petter André Sjulstad
+// Anthropic (Claude Code SDK) credential preflight + auth-error phrasing.
+//
+// The Claude Agent SDK authenticates via `ANTHROPIC_API_KEY`, a Claude
+// Pro/Max subscription token (`CLAUDE_CODE_OAUTH_TOKEN`), or the `claude` CLI's
+// own on-disk login. Bivy's shared vault forwards whichever Anthropic credential
+// the node holds (see credentials.ts / claude-code.ts's resolveCredentialEnv),
+// but when the node has none, the SDK spawns and its very first request fails
+// with an opaque upstream `unexpected status 401 Unauthorized: …`.
+//
+// This module detects the no-credential state up front so Bivy can surface a
+// clear, actionable message instead of the raw 401, and phrases any auth failure
+// that still slips through (expired token, revoked key) with the same guidance.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+/** Candidate paths for the `claude` CLI's own stored login (`.credentials.json`). */
+export function claudeCredentialFiles(deps = {}) {
+    const home = deps.home ?? os.homedir();
+    const dirs = [deps.configDir ?? process.env.CLAUDE_CONFIG_DIR, path.join(home, ".claude")]
+        .filter((d) => Boolean(d && d.trim()));
+    return dirs.map((d) => path.join(d, ".credentials.json"));
+}
+/** How to fix a missing/invalid Anthropic credential — shared by both messages. */
+const ANTHROPIC_AUTH_FIX = [
+    "• Add an Anthropic API key or sign in with Claude under Models & providers, or",
+    "• Run `claude` on this node and use `/login` to sign in with your Claude subscription.",
+].join("\n");
+/** Shown when the node has no Anthropic credential at all (preflight block). */
+export const ANTHROPIC_NO_CREDENTIAL_MESSAGE = [
+    "Claude Code has no Anthropic credential on this node, so it can't start a turn — it would fail with `401 Unauthorized`.",
+    "",
+    "Sign in one of these ways, then start the session again:",
+    ANTHROPIC_AUTH_FIX,
+].join("\n");
+/** Appended to a raw auth failure that surfaced from the SDK despite a credential. */
+export const ANTHROPIC_AUTH_HINT = ["This looks like an authentication failure.", ANTHROPIC_AUTH_FIX].join("\n");
+/**
+ * Whether the Claude Code SDK will find a usable Anthropic credential given the
+ * environment it will run with. True when an API key or OAuth token is in the
+ * env, or the `claude` CLI has a login on disk. On macOS the CLI login lives in
+ * the Keychain (no inspectable file), so this returns true there rather than
+ * risk false-blocking a working login — the SDK falls back to its own auth.
+ */
+export function hasAnthropicCredential(env, deps = {}) {
+    if (env.ANTHROPIC_API_KEY?.trim() || env.CLAUDE_CODE_OAUTH_TOKEN?.trim())
+        return true;
+    const platform = deps.platform ?? process.platform;
+    if (platform === "darwin")
+        return true;
+    const exists = deps.fileExists ?? ((p) => {
+        try {
+            return fs.existsSync(p);
+        }
+        catch {
+            return false;
+        }
+    });
+    return claudeCredentialFiles(deps).some(exists);
+}
+/**
+ * Returns an actionable error when the Claude Code SDK has no usable Anthropic
+ * credential, or undefined when one is present so the turn should proceed.
+ */
+export function anthropicCredentialPreflight(env, deps = {}) {
+    return hasAnthropicCredential(env, deps) ? undefined : ANTHROPIC_NO_CREDENTIAL_MESSAGE;
+}
+/** True when a raw error string looks like an Anthropic auth failure (401 etc.). */
+export function isAnthropicAuthError(raw) {
+    return /\b401\b|unauthorized|authentication|invalid x-api-key|(missing|invalid).*(bearer|api[\s_-]?key|token)/i.test(raw);
+}
+/**
+ * Phrase an SDK error for the user: an auth failure gets the sign-in guidance
+ * appended; anything else is returned unchanged.
+ */
+export function describeAnthropicError(raw) {
+    const text = raw.trim() || "Claude Code error";
+    return isAnthropicAuthError(text) ? `${text}\n\n${ANTHROPIC_AUTH_HINT}` : text;
+}