@bivy/bivy 0.0.0 → 0.1.0-staging.2

package/dist/exec.js

@@ -0,0 +1,209 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+// Copyright (c) 2026 Petter André Sjulstad
+// `bivy exec "<prompt>"` — one-shot, headless agent run for scripting and pipes.
+// Creates (or resumes) a session, sends one prompt, waits for the turn to finish,
+// prints the final answer to stdout, and exits. Working details stay on stderr so
+// stdout is just the answer (pipe-friendly). `--json` emits a structured result.
+//
+//   bivy exec "summarize README.md"
+//   bivy exec --agent claude "what does src/server.ts do?"
+//   bivy exec --session <ref> "and now add a test"      # continue a session
+//   echo "explain this" | bivy exec -                    # prompt from stdin
+import { WebSocket } from "ws";
+const err = (s) => process.stderr.write(s);
+function parseArgs(argv) {
+    let url = process.env.BIVY_URL || `http://localhost:${process.env.PORT || "4317"}`;
+    let token = process.env.BIVY_DEVICE_TOKEN || undefined;
+    let agent;
+    let session;
+    let json = false;
+    let timeoutMs = Number(process.env.BIVY_EXEC_TIMEOUT_MS) || 10 * 60 * 1000;
+    const prompt = [];
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "--url" && argv[i + 1])
+            url = argv[++i];
+        else if (arg.startsWith("--url="))
+            url = arg.slice("--url=".length);
+        else if (arg === "--token" && argv[i + 1])
+            token = argv[++i];
+        else if (arg.startsWith("--token="))
+            token = arg.slice("--token=".length);
+        else if ((arg === "-a" || arg === "--agent") && argv[i + 1])
+            agent = argv[++i];
+        else if (arg.startsWith("--agent="))
+            agent = arg.slice("--agent=".length);
+        else if (arg === "--session" && argv[i + 1])
+            session = argv[++i];
+        else if (arg.startsWith("--session="))
+            session = arg.slice("--session=".length);
+        else if (arg === "--json")
+            json = true;
+        else if (arg === "--timeout" && argv[i + 1])
+            timeoutMs = Number(argv[++i]) * 1000;
+        else
+            prompt.push(arg);
+    }
+    return { url: url.replace(/\/+$/, ""), token, agent, session, prompt: prompt.join(" "), json, timeoutMs };
+}
+function authHeaders(token) {
+    return { "content-type": "application/json", ...(token ? { authorization: `Bearer ${token}` } : {}) };
+}
+async function api(url, token, pathName, init = {}) {
+    const res = await fetch(`${url}${pathName}`, { ...init, headers: { ...authHeaders(token), ...(init.headers || {}) } });
+    const data = (await res.json().catch(() => ({})));
+    if (!res.ok)
+        throw new Error(data?.error || `HTTP ${res.status} for ${pathName}`);
+    return data;
+}
+function wsUrl(baseUrl, token) {
+    const u = new URL(baseUrl);
+    u.protocol = u.protocol === "https:" ? "wss:" : "ws:";
+    u.pathname = "/ws";
+    u.search = token ? `?access_token=${encodeURIComponent(token)}` : "";
+    return u.toString();
+}
+// Pull plain text out of a runtime message/content shape (mirrors the TUI).
+function textContent(value) {
+    if (value === undefined || value === null)
+        return "";
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value))
+        return value.map(textContent).filter(Boolean).join("");
+    if (typeof value === "object") {
+        const r = value;
+        if (r.type === "thinking" || r.type === "reasoning")
+            return "";
+        if (typeof r.text === "string")
+            return r.text;
+        if (typeof r.content === "string" || Array.isArray(r.content))
+            return textContent(r.content);
+        if (typeof r.output === "string")
+            return r.output;
+    }
+    return "";
+}
+function assistantText(event) {
+    const message = event.message;
+    return textContent(message?.content ?? event.content ?? event.text);
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(chunk);
+    return Buffer.concat(chunks).toString("utf8");
+}
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    let prompt = args.prompt.trim();
+    if (prompt === "-" || (!prompt && !process.stdin.isTTY))
+        prompt = (await readStdin()).trim();
+    if (!prompt) {
+        err('Usage: bivy exec "<prompt>"  (or pipe the prompt on stdin)\n');
+        process.exit(2);
+    }
+    // Establish the session — resume by ref or create fresh with the chosen agent.
+    let sessionId;
+    try {
+        if (args.session) {
+            const opened = await api(args.url, args.token, "/api/sessions/open", {
+                method: "POST",
+                body: JSON.stringify({ path: args.session, ...(args.agent ? { agent: args.agent } : {}) }),
+            });
+            sessionId = opened.id;
+        }
+        else {
+            const created = await api(args.url, args.token, "/api/session", {
+                method: "POST",
+                body: JSON.stringify(args.agent ? { agent: args.agent } : {}),
+            });
+            sessionId = created.id;
+        }
+    }
+    catch (error) {
+        err(`Could not start a session: ${error instanceof Error ? error.message : String(error)}\n`);
+        process.exit(1);
+        return;
+    }
+    err(`\x1b[2m· session ${sessionId.slice(0, 8)} — working…\x1b[22m\n`);
+    const socket = new WebSocket(wsUrl(args.url, args.token));
+    let answer = "";
+    let settled = false;
+    const finish = (code, errorText) => {
+        if (settled)
+            return;
+        settled = true;
+        try {
+            socket.close();
+        }
+        catch { }
+        if (errorText) {
+            err(`${errorText}\n`);
+            process.exit(code);
+            return;
+        }
+        if (args.json)
+            process.stdout.write(JSON.stringify({ sessionId, answer }) + "\n");
+        else
+            process.stdout.write(answer.replace(/\s+$/, "") + "\n");
+        process.exit(code);
+    };
+    const timer = setTimeout(() => finish(1, `Timed out after ${Math.round(args.timeoutMs / 1000)}s.`), args.timeoutMs);
+    timer.unref?.();
+    socket.on("open", async () => {
+        try {
+            await api(args.url, args.token, "/api/session/prompt", {
+                method: "POST",
+                body: JSON.stringify({ sessionId, text: prompt, clientMessageId: `exec-${sessionId}` }),
+            });
+        }
+        catch (error) {
+            finish(1, `Prompt failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    });
+    socket.on("error", (e) => finish(1, `Connection error: ${e instanceof Error ? e.message : String(e)}`));
+    // A close here means the socket dropped before an `agent_end` event was ever
+    // seen (a real completion calls finish(0) itself, closing the socket and
+    // setting `settled` first — so this handler is then a no-op). That's always
+    // abnormal: a mid-turn disconnect must exit non-zero even when partial
+    // assistant text already streamed in, otherwise a script reading `answer`
+    // (or just checking $?) sees a clean success for a truncated reply.
+    socket.on("close", () => {
+        if (settled)
+            return;
+        finish(1, answer ? "Connection closed before the turn finished (received a partial answer)." : "Connection closed before the turn finished.");
+    });
+    socket.on("message", (raw) => {
+        let msg;
+        try {
+            msg = JSON.parse(raw.toString());
+        }
+        catch {
+            return;
+        }
+        if (msg.sessionId && msg.sessionId !== sessionId)
+            return;
+        const type = msg.type;
+        if (type === "session.event") {
+            const ev = (msg.event || {});
+            if (ev.type === "message_start" || ev.type === "message_update" || ev.type === "message_end") {
+                const text = assistantText(ev);
+                if (text)
+                    answer = text; // events carry the full message text so far
+            }
+            else if (ev.type === "agent_end") {
+                clearTimeout(timer);
+                finish(0);
+            }
+        }
+        else if (type === "session.error") {
+            clearTimeout(timer);
+            finish(1, String(msg.error || "Session error"));
+        }
+    });
+}
+main().catch((error) => {
+    err(`${error instanceof Error ? error.stack : String(error)}\n`);
+    process.exit(1);
+});

package/dist/git-auth.js

@@ -0,0 +1,155 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+// Copyright (c) 2026 Petter André Sjulstad
+// Git credential handling for repos Bivy clones on behalf of a user.
+//
+// Remotes are kept CLEAN (https://github.com/<owner>/<repo>.git); credentials are
+// supplied on demand by a daemon-owned git credential helper. The helper stores
+// NO token on disk — on every git operation it calls the node's loopback
+// git-credential endpoint (see src/server.ts) and gets a FRESH token. This keeps
+// nothing long-lived or stale on disk (important once tokens are short-lived
+// GitHub App installation tokens), and works for both daemon- and agent-run git
+// since both run under a live daemon.
+import fs from "node:fs";
+import path from "node:path";
+import { defaultDataDir } from "./data-dir.js";
+// Set by configureGitAuth() at daemon startup. Falls back to BIVY_DATA_DIR / the
+// default data dir so the module still works in tests and one-off scripts.
+let credRootOverride = null;
+function credDir() {
+    return credRootOverride ?? path.join(defaultDataDir(), "git-cred");
+}
+function shimPath() {
+    return path.join(credDir(), "credential-helper.sh");
+}
+function workerPath() {
+    return path.join(credDir(), "credential-helper.mjs");
+}
+function endpointPath() {
+    return path.join(credDir(), "endpoint.json");
+}
+/** The token-free remote URL for a repo. */
+export function cleanRemoteUrl(owner, repo) {
+    return `https://github.com/${owner}/${repo}.git`;
+}
+// The credential-helper worker (plain ESM, run by node). Reads git's request on
+// stdin, and for a github.com repo fetches a fresh token from the node's loopback
+// endpoint. Finds endpoint.json next to itself (import.meta.url), so no paths are
+// baked in. Prints nothing on any miss/error, so git fails auth cleanly (fast,
+// because the daemon runs it with GIT_TERMINAL_PROMPT=0).
+const WORKER_SOURCE = `import fs from 'node:fs';
+import http from 'node:http';
+if (process.argv[2] !== 'get') process.exit(0);
+let input = '';
+try { input = fs.readFileSync(0, 'utf8'); } catch { process.exit(0); }
+const attrs = {};
+for (const line of input.split('\\n')) { const i = line.indexOf('='); if (i > 0) attrs[line.slice(0, i)] = line.slice(i + 1).trim(); }
+if (attrs.host !== 'github.com') process.exit(0);
+const m = /^([^/]+)\\/(.+?)(?:\\.git)?$/.exec(attrs.path || '');
+if (!m) process.exit(0);
+let ep;
+try { ep = JSON.parse(fs.readFileSync(new URL('./endpoint.json', import.meta.url), 'utf8')); } catch { process.exit(0); }
+if (!ep || !ep.url || !ep.secret) process.exit(0);
+const u = new URL(ep.url + '/api/git-credential');
+u.searchParams.set('owner', m[1]);
+u.searchParams.set('repo', m[2]);
+const token = await new Promise((resolve) => {
+  const req = http.get(u, { headers: { 'x-bivy-bootstrap': ep.secret } }, (res) => {
+    if (res.statusCode !== 200) { res.resume(); return resolve(null); }
+    let body = ''; res.setEncoding('utf8');
+    res.on('data', (d) => (body += d));
+    res.on('end', () => { try { resolve(JSON.parse(body).token || null); } catch { resolve(null); } });
+  });
+  req.on('error', () => resolve(null));
+  req.setTimeout(5000, () => { req.destroy(); resolve(null); });
+});
+if (token) process.stdout.write('username=x-access-token\\npassword=' + token + '\\n');
+`;
+function shDq(s) {
+    return `"${s.replace(/(["\\$\`])/g, "\\$1")}"`;
+}
+function writeIfChanged(file, content, mode) {
+    let existing = "";
+    try {
+        existing = fs.readFileSync(file, "utf8");
+    }
+    catch {
+        // not written yet
+    }
+    if (existing !== content)
+        fs.writeFileSync(file, content, { mode });
+    fs.chmodSync(file, mode);
+}
+/**
+ * (Re)write the credential helper and return the git-config helper path. The
+ * helper is a tiny sh shim that execs THIS daemon's node (absolute path baked in,
+ * so it works regardless of the caller's PATH — e.g. an agent shell) on the worker
+ * script above. Idempotent.
+ */
+export function ensureCredentialHelper() {
+    fs.mkdirSync(credDir(), { recursive: true, mode: 0o700 });
+    writeIfChanged(workerPath(), WORKER_SOURCE, 0o700);
+    const shim = `#!/usr/bin/env sh\nexec ${shDq(process.execPath)} ${shDq(workerPath())} "$@"\n`;
+    writeIfChanged(shimPath(), shim, 0o700);
+    return shimPath();
+}
+/** Point the module at the node data dir and materialize the helper. */
+export function configureGitAuth(appDir) {
+    credRootOverride = path.join(appDir, "git-cred");
+    ensureCredentialHelper();
+}
+/**
+ * Publish the loopback endpoint (URL + bootstrap secret) that the helper calls to
+ * fetch a fresh token. 0600 — the secret gates the endpoint against other local
+ * users on a shared host. Call once the daemon knows its port + bootstrap secret.
+ */
+export function writeGitCredentialEndpoint(url, secret) {
+    fs.mkdirSync(credDir(), { recursive: true, mode: 0o700 });
+    writeIfChanged(endpointPath(), `${JSON.stringify({ url, secret })}\n`, 0o600);
+}
+/**
+ * `-c` flags that make a single git invocation use the helper for github.com with
+ * the repo path (so the helper can resolve owner/repo). Non-secret (only the
+ * helper's path). Use for daemon-run clone/fetch/push against a clean URL.
+ */
+export function credConfigArgs() {
+    const helper = ensureCredentialHelper();
+    return [
+        // Reset the credential-helper chain BEFORE adding bivy's helper. Git collects
+        // helpers from system/global/local config and consults them in order, using the
+        // FIRST that returns a password; command-line `-c` is appended last. So without a
+        // reset, any pre-existing github.com helper on the host (osxkeychain, `gh`, store,
+        // manager-core) is consulted first and would hand the agent the human's personal,
+        // broadly-scoped token instead of bivy's scoped, short-lived one. An empty helper
+        // value clears the accumulated list, so bivy's is the only helper that runs.
+        "-c",
+        "credential.helper=",
+        "-c",
+        "credential.https://github.com.helper=",
+        "-c",
+        `credential.https://github.com.helper=${helper}`,
+        "-c",
+        "credential.https://github.com.useHttpPath=true",
+    ];
+}
+/** Env that makes git non-interactive, so a credential miss fails fast (never hangs). */
+export function gitNonInteractiveEnv() {
+    return { ...process.env, GIT_TERMINAL_PROMPT: "0" };
+}
+/**
+ * Persist the helper config into a clone's local `.git/config` so AGENT-run git
+ * (a bare `git push origin` from inside the workspace) authenticates too, without
+ * the daemon's `-c` flags. Only the helper path is stored — never a token.
+ */
+export async function configureRepoCredentialHelper(git, dest) {
+    const helper = ensureCredentialHelper();
+    await git(["-C", dest, "config", "--local", "credential.https://github.com.useHttpPath", "true"]);
+    // Reset the helper chain for this repo, then set ONLY bivy's helper, so AGENT-run
+    // git never falls back to an inherited host helper holding the human's personal
+    // token (see credConfigArgs for the full rationale). Clear any prior values first
+    // so re-running stays idempotent (--unset-all returns 5 when the key is absent).
+    await git(["-C", dest, "config", "--local", "--unset-all", "credential.helper"]).catch(() => { });
+    await git(["-C", dest, "config", "--local", "--unset-all", "credential.https://github.com.helper"]).catch(() => { });
+    await git(["-C", dest, "config", "--local", "--add", "credential.helper", ""]);
+    await git(["-C", dest, "config", "--local", "--add", "credential.https://github.com.helper", ""]);
+    await git(["-C", dest, "config", "--local", "--add", "credential.https://github.com.helper", helper]);
+}

package/dist/github-app-auth.js

@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+// Copyright (c) 2026 Petter André Sjulstad
+import { createSign } from "node:crypto";
+/**
+ * GitHub App installation tokens (M2, flavor A: user-owned app, key on the node).
+ *
+ * The node holds the app private key and mints its own short-lived installation
+ * access tokens — the control plane never sees a repo-capable credential. A JWT
+ * signed with the app key is exchanged for a 1h installation token scoped to the
+ * repos the app is installed on; comments/PRs then post as `<app>[bot]`.
+ *
+ * Dependency-free (node:crypto only), matching the rest of the webhook path.
+ */
+const b64url = (input) => Buffer.from(input).toString("base64url");
+/**
+ * Build a short-lived GitHub App JWT (RS256). `iat` is backdated 30s to tolerate
+ * clock skew; `exp` is 9 min out (GitHub's ceiling is 10). `iss` is the app id.
+ */
+export function createAppJwt(appId, privateKeyPem, nowSec) {
+    const header = { alg: "RS256", typ: "JWT" };
+    const payload = { iat: nowSec - 30, exp: nowSec + 540, iss: String(appId) };
+    const signingInput = `${b64url(JSON.stringify(header))}.${b64url(JSON.stringify(payload))}`;
+    const signature = createSign("RSA-SHA256").update(signingInput).end().sign(privateKeyPem);
+    return `${signingInput}.${b64url(signature)}`;
+}
+/** Exchange an app JWT for a 1h installation access token. */
+export async function mintInstallationToken(opts) {
+    const nowSec = opts.nowSec ?? Math.floor(Date.now() / 1000);
+    const jwt = createAppJwt(opts.appId, opts.privateKeyPem, nowSec);
+    const doFetch = opts.fetchImpl ?? fetch;
+    const res = await doFetch(`https://api.github.com/app/installations/${opts.installationId}/access_tokens`, {
+        method: "POST",
+        headers: {
+            authorization: `Bearer ${jwt}`,
+            accept: "application/vnd.github+json",
+            "x-github-api-version": "2022-11-28",
+            "user-agent": "bivy",
+        },
+    });
+    if (!res.ok) {
+        const detail = await res.text().catch(() => "");
+        throw new Error(`GitHub installation token request failed (${res.status}): ${detail.slice(0, 200)}`);
+    }
+    const data = (await res.json().catch(() => ({})));
+    if (!data.token)
+        throw new Error("GitHub installation token response had no token");
+    return { token: data.token, expiresAt: data.expires_at ?? "" };
+}
+/**
+ * Resolve the installation id for a repo the app is installed on, via
+ * `GET /repos/{owner}/{repo}/installation` (authed with an app JWT — no
+ * installation token needed yet, which is the chicken/egg this breaks). Returns
+ * undefined when the app isn't installed there (404) or on any API error, so the
+ * caller falls back to the user PAT. `owner`/`repo` are expected pre-validated.
+ */
+export async function resolveInstallationId(opts) {
+    const nowSec = opts.nowSec ?? Math.floor(Date.now() / 1000);
+    const jwt = createAppJwt(opts.appId, opts.privateKeyPem, nowSec);
+    const doFetch = opts.fetchImpl ?? fetch;
+    const res = await doFetch(`https://api.github.com/repos/${opts.owner}/${opts.repo}/installation`, {
+        headers: {
+            authorization: `Bearer ${jwt}`,
+            accept: "application/vnd.github+json",
+            "x-github-api-version": "2022-11-28",
+            "user-agent": "bivy",
+        },
+    });
+    if (!res.ok)
+        return undefined;
+    const data = (await res.json().catch(() => ({})));
+    return data.id != null ? String(data.id) : undefined;
+}
+/**
+ * Per-installation token cache. Reuses a token until ~5 min before it expires,
+ * so one webhook burst doesn't mint a token per work item. Injectable fetch/clock
+ * for tests.
+ */
+export class InstallationTokenCache {
+    appId;
+    privateKeyPem;
+    fetchImpl;
+    now;
+    cache = new Map();
+    static SKEW_MS = 5 * 60 * 1000;
+    constructor(appId, privateKeyPem, fetchImpl = fetch, now = () => Date.now()) {
+        this.appId = appId;
+        this.privateKeyPem = privateKeyPem;
+        this.fetchImpl = fetchImpl;
+        this.now = now;
+    }
+    async get(installationId) {
+        const key = String(installationId);
+        const hit = this.cache.get(key);
+        if (hit?.expiresAt && Date.parse(hit.expiresAt) - this.now() > InstallationTokenCache.SKEW_MS) {
+            return hit.token;
+        }
+        const fresh = await mintInstallationToken({
+            appId: this.appId,
+            privateKeyPem: this.privateKeyPem,
+            installationId,
+            nowSec: Math.floor(this.now() / 1000),
+            fetchImpl: this.fetchImpl,
+        });
+        this.cache.set(key, fresh);
+        return fresh.token;
+    }
+}