@bivy/bivy 0.0.0 → 0.1.0-staging.2

package/dist/runtime/ruleset-store.js

@@ -0,0 +1,117 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+// Copyright (c) 2026 Petter André Sjulstad
+// Bivy's app-owned ruleset registry — the source of truth for user-authored
+// run-orchestration policy (docs/rulesets.md).
+//
+// A ruleset decides what happens when a run fails: retry, reroute through a
+// fallback chain, or park for a human. The schema + pure matcher live in
+// src/policy/ruleset.ts; this module is only the STORAGE seam. It mirrors
+// local-model-store.ts: a small JSON file under the app dir, non-secret config
+// only, validated with the policy's own `validateRuleset` before it can steer a
+// live run. It is deliberately node-local (policy is per-machine), not synced
+// through the credential envelope.
+//
+// One ruleset may be marked ACTIVE — that's the one the work-queue effector
+// consults (see server.ts activeQueueRuleset). When none is active, the queue
+// falls back to the built-in DEFAULT_RULESET.
+import fs from "node:fs";
+import path from "node:path";
+import { validateRuleset } from "../policy/ruleset.js";
+const FILE_NAME = "rulesets.json";
+function configPath(dir) {
+    return path.join(dir, FILE_NAME);
+}
+export function loadRulesets(dir) {
+    const file = configPath(dir);
+    if (!fs.existsSync(file))
+        return { activeName: null, rulesets: {} };
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+        if (!parsed || typeof parsed !== "object")
+            return { activeName: null, rulesets: {} };
+        const rawRulesets = parsed.rulesets;
+        const rulesets = {};
+        if (rawRulesets && typeof rawRulesets === "object") {
+            for (const spec of Object.values(rawRulesets)) {
+                // Re-validate on read: a hand-edited or partially-migrated file never
+                // yields a shape the matcher can't trust. Invalid entries are dropped.
+                const result = validateRuleset(spec);
+                if (result.ok && result.ruleset)
+                    rulesets[result.ruleset.name] = result.ruleset;
+            }
+        }
+        const activeRaw = parsed.activeName;
+        const activeName = typeof activeRaw === "string" && rulesets[activeRaw] ? activeRaw : null;
+        return { activeName, rulesets };
+    }
+    catch {
+        return { activeName: null, rulesets: {} };
+    }
+}
+export function saveRulesets(dir, file) {
+    fs.mkdirSync(dir, { recursive: true });
+    const safe = {
+        activeName: file.activeName && file.rulesets[file.activeName] ? file.activeName : null,
+        rulesets: file.rulesets || {},
+    };
+    const target = configPath(dir);
+    fs.writeFileSync(target, `${JSON.stringify(safe, null, 2)}\n`, { mode: 0o600 });
+    try {
+        fs.chmodSync(target, 0o600);
+    }
+    catch {
+        /* best effort */
+    }
+}
+/** Full rulesets + active flag, for the UI. Sorted by name (active first). */
+export function listRulesetInfos(dir) {
+    const { activeName, rulesets } = loadRulesets(dir);
+    return Object.values(rulesets)
+        .map((r) => ({ ...r, active: r.name === activeName }))
+        .sort((a, b) => Number(b.active) - Number(a.active) || a.name.localeCompare(b.name));
+}
+/**
+ * Validate and store a ruleset (insert or update, keyed by name). Pass
+ * `active: true` to make it the queue's active ruleset, `false` to clear the
+ * active flag if this ruleset currently holds it, or omit to leave it unchanged.
+ * Throws with a human-readable message when the input fails validation.
+ */
+export function upsertRuleset(dir, input, active) {
+    const result = validateRuleset(input);
+    if (!result.ok || !result.ruleset) {
+        throw new Error(`Invalid ruleset: ${result.errors.join("; ") || "did not match the expected shape"}`);
+    }
+    const ruleset = result.ruleset;
+    const file = loadRulesets(dir);
+    file.rulesets[ruleset.name] = ruleset;
+    if (active === true)
+        file.activeName = ruleset.name;
+    else if (active === false && file.activeName === ruleset.name)
+        file.activeName = null;
+    saveRulesets(dir, file);
+    return { name: ruleset.name };
+}
+export function removeRuleset(dir, name) {
+    const file = loadRulesets(dir);
+    const key = String(name ?? "").trim();
+    if (!key)
+        throw new Error("ruleset name required");
+    delete file.rulesets[key];
+    if (file.activeName === key)
+        file.activeName = null;
+    saveRulesets(dir, file);
+}
+/**
+ * The active ruleset, but only if it `appliesTo` the given context — the
+ * work-queue effector calls this so an authored session-only ruleset never
+ * silently steers unattended queue runs. Undefined means "use the default".
+ */
+export function activeRulesetFor(dir, context) {
+    const { activeName, rulesets } = loadRulesets(dir);
+    if (!activeName)
+        return undefined;
+    const ruleset = rulesets[activeName];
+    if (!ruleset || !ruleset.appliesTo.includes(context))
+        return undefined;
+    return ruleset;
+}

package/dist/runtime/session-location.js

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+// Copyright (c) 2026 Petter André Sjulstad
+/**
+ * Session-location registry — the Stage 2 seam (docs/agent-node-decoupling.md).
+ *
+ * Stage 1 moved the agent's process off the daemon; Stage 2 makes the daemon
+ * stateless by letting ANY daemon instance serve ANY session. The missing piece
+ * is a shared map from a session to the agent service that hosts it — a
+ * generalization of the control plane's existing `sessionId → nodeId` index
+ * (services/control-plane/src/store.ts) with the agent-service address added.
+ *
+ * This module defines the seam and a node-local default. Today the daemon holds
+ * the live handle in `openSessions` (src/server.ts) and resumes from local disk
+ * on a miss; with a shared implementation of this interface, a miss instead
+ * resolves the session's agent-service address and re-attaches to the still-live
+ * session via `RemoteRuntime.attachSession` (the Stage 1 `attach` op) — no local
+ * handle, no local disk. The interface is async so a control-plane-backed
+ * implementation (an HTTP round-trip) drops in behind the same flag without
+ * touching call sites.
+ *
+ * Kept dependency-free and unit-testable, in the style of
+ * services/relay/src/backpressure.ts.
+ */
+import { InMemoryLocationRegistry } from "./location-registry.js";
+/**
+ * Node-local registry: each daemon knows only its own sessions. This is exactly
+ * today's behavior (no cross-daemon routing) and the safe default while the flag
+ * is off. A shared, control-plane-backed implementation replaces it to unlock
+ * true statelessness — same interface, so no call site changes.
+ */
+export class InMemorySessionLocationRegistry {
+    // Built on the generic keyed registry (location-registry.ts); this class just
+    // keys by sessionId and preserves the location-shaped API its callers use.
+    registry = new InMemoryLocationRegistry();
+    async record(location) {
+        if (!location.sessionId)
+            throw new Error("SessionLocation.sessionId is required");
+        await this.registry.record(location.sessionId, location);
+    }
+    async lookup(sessionId) {
+        return this.registry.lookup(sessionId);
+    }
+    async forget(sessionId) {
+        await this.registry.forget(sessionId);
+    }
+    /** Number of recorded locations (test/introspection aid). */
+    get size() {
+        return this.registry.size;
+    }
+}

package/dist/runtime/types.js

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+// Copyright (c) 2026 Petter André Sjulstad
+// Runtime-agnostic agent interface.
+//
+// This is the seam that lets Bivy drive *any* agent runtime, not
+// just Pi. Everything the daemon, guardian, relay and UI need from "the agent"
+// is expressed here in terms that contain no Pi types. A concrete runtime
+// (Pi today; Claude Agent SDK, a generic RPC agent, etc. later) lives behind an
+// `AgentRuntime` implementation that maps these calls onto its own SDK.
+//
+// The shapes below are deliberately a *subset* of what Pi exposes — exactly the
+// surface `src/server.ts` consumes — so the first adapter is a thin wrapper and
+// the contract is small enough for other runtimes to satisfy.
+//
+// Nothing imports this yet; it is the target interface for the migration
+// described in docs/pluggable-runtime.md.
+export {};

package/dist/secrets-cli.js

@@ -0,0 +1,134 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+// Copyright (c) 2026 Petter André Sjulstad
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { SecretVault } from "./secrets.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(__dirname, "..");
+const appDir = process.env.BIVY_DATA_DIR ?? path.join(repoRoot, ".bivy");
+const vault = new SecretVault(appDir);
+async function askHidden(question) {
+    if (!input.isTTY) {
+        const rl = createInterface({ input, output });
+        try {
+            return await rl.question(question);
+        }
+        finally {
+            rl.close();
+        }
+    }
+    return new Promise((resolve, reject) => {
+        let value = "";
+        const onData = (chunk) => {
+            for (const char of chunk.toString("utf8")) {
+                if (char === "\u0003") {
+                    cleanup();
+                    output.write("\n");
+                    reject(new Error("Cancelled"));
+                    return;
+                }
+                if (char === "\r" || char === "\n") {
+                    cleanup();
+                    output.write("\n");
+                    resolve(value);
+                    return;
+                }
+                if (char === "\u007f" || char === "\b")
+                    value = value.slice(0, -1);
+                else
+                    value += char;
+            }
+        };
+        const cleanup = () => { input.off("data", onData); input.setRawMode(false); input.pause(); };
+        output.write(question);
+        input.setRawMode(true);
+        input.resume();
+        input.on("data", onData);
+    });
+}
+function usage() {
+    console.log(`Usage: bivy secrets <list|set|ref|delete|doctor|resolve>
+
+Commands:
+  bivy secrets list
+  bivy secrets set <id> [value]       Store an encrypted local secret (prompts when value is omitted)
+  bivy secrets ref <id> <op://...>    Store a 1Password reference instead of the raw secret
+  bivy secrets ref <id> <env://VAR>   Store an environment-variable reference
+  bivy secrets delete <id>
+  bivy secrets doctor
+  bivy secrets resolve <id>           Verify a secret resolves without printing it
+
+Common ids:
+  github.repo-token
+  model.anthropic
+  model.openai
+  integration.github
+`);
+}
+async function main() {
+    const [cmd, id, ...rest] = process.argv.slice(2);
+    if (!cmd || cmd === "help" || cmd === "--help") {
+        usage();
+        return;
+    }
+    if (cmd === "list") {
+        const records = vault.list();
+        if (records.length === 0) {
+            console.log("No Bivy secrets configured.");
+            return;
+        }
+        for (const record of records) {
+            const target = record.backend === "local" ? "encrypted local" : record.ref;
+            console.log(`${record.id}\t${record.backend}\t${target}\tupdated ${record.updatedAt}`);
+        }
+        return;
+    }
+    if (cmd === "set") {
+        if (!id)
+            throw new Error("Missing secret id.");
+        const value = rest.length ? rest.join(" ") : await askHidden(`Secret value for ${id}: `);
+        vault.setLocal(id, value);
+        console.log(`✓ Stored ${id} in the encrypted local Bivy vault (${vault.file}).`);
+        return;
+    }
+    if (cmd === "ref") {
+        if (!id || rest.length === 0)
+            throw new Error("Usage: bivy secrets ref <id> <op://...|env://VAR>");
+        const ref = rest.join(" ").trim();
+        vault.setReference(id, ref);
+        console.log(`✓ Stored ${id} as ${ref}. Bivy will resolve it at runtime; the raw secret is not stored by Bivy.`);
+        return;
+    }
+    if (cmd === "delete" || cmd === "rm") {
+        if (!id)
+            throw new Error("Missing secret id.");
+        const removed = vault.delete(id);
+        console.log(removed ? `✓ Deleted ${id}.` : `No secret named ${id}.`);
+        return;
+    }
+    if (cmd === "resolve") {
+        if (!id)
+            throw new Error("Missing secret id.");
+        const value = await vault.resolve(id);
+        if (!value)
+            throw new Error(`${id} did not resolve to a value.`);
+        console.log(`✓ ${id} resolves (${value.length} bytes).`);
+        return;
+    }
+    if (cmd === "doctor") {
+        const result = await vault.doctor();
+        for (const check of result.checks)
+            console.log(`${check.ok ? "✓" : "!"} ${check.name}: ${check.detail}`);
+        if (!result.ok)
+            process.exitCode = 1;
+        return;
+    }
+    usage();
+    process.exitCode = 1;
+}
+main().catch((error) => {
+    console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+});

package/dist/secrets.js

@@ -0,0 +1,264 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+// Copyright (c) 2026 Petter André Sjulstad
+import { execFile } from "node:child_process";
+import { randomBytes, createCipheriv, createDecipheriv } from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+const exec = promisify(execFile);
+function nowIso() { return new Date().toISOString(); }
+function empty() { return { version: 1, records: {} }; }
+// The vault's LAST-RESORT default (used only by `new SecretVault()` with no
+// appDir — every daemon path passes an explicit one). Deliberately the home dir,
+// NOT the daemon's <install>/.bivy: the vault refuses to mint a master key inside
+// a git working tree, and <install>/.bivy is inside the repo in a dev checkout.
+export function defaultSecretsDir(appDir) {
+    if (appDir)
+        return appDir;
+    return process.env.BIVY_DATA_DIR || path.join(os.homedir(), ".bivy");
+}
+/** True if `dir`, or any of its parents, is a git working tree (has a `.git` entry). */
+function isInsideGitWorkTree(dir) {
+    let current = path.resolve(dir);
+    for (;;) {
+        if (fs.existsSync(path.join(current, ".git")))
+            return true;
+        const parent = path.dirname(current);
+        if (parent === current)
+            return false;
+        current = parent;
+    }
+}
+export function normalizeSecretId(id) {
+    const value = String(id || "").trim();
+    if (!/^[A-Za-z0-9][A-Za-z0-9_.:/@-]{0,127}$/.test(value)) {
+        throw new Error("Secret id must be 1-128 chars: letters, numbers, dot, dash, underscore, colon, slash, or @.");
+    }
+    return value;
+}
+function fileMode(file, mode) {
+    try {
+        fs.chmodSync(file, mode);
+    }
+    catch { }
+}
+function readJson(file) {
+    let raw;
+    try {
+        raw = fs.readFileSync(file, "utf8");
+    }
+    catch (error) {
+        // Only a missing file means "nothing stored yet". Any other read failure
+        // (permission denied, I/O error, etc.) must not be treated as empty.
+        if (error?.code === "ENOENT")
+            return empty();
+        throw error;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        return { version: 1, records: parsed.records && typeof parsed.records === "object" ? parsed.records : {} };
+    }
+    catch {
+        // The file exists but is corrupt/truncated. Overwriting it with an empty
+        // record set would silently discard every stored secret reference, so
+        // fail loudly instead and let the caller decide how to recover.
+        throw new Error(`Secrets file at ${file} is corrupt and could not be parsed. Refusing to reset it to empty. ` +
+            `Restore it from a backup, or remove the file manually if you intend to start fresh.`);
+    }
+}
+function writeJson(file, data) {
+    fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+    const tmp = `${file}.tmp`;
+    fs.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}\n`, { mode: 0o600 });
+    fileMode(tmp, 0o600);
+    fs.renameSync(tmp, file);
+    fileMode(file, 0o600);
+}
+export class SecretVault {
+    dir;
+    file;
+    keyFile;
+    data;
+    constructor(appDir = defaultSecretsDir()) {
+        this.dir = appDir;
+        this.file = path.join(appDir, "secrets.json");
+        this.keyFile = path.join(appDir, "secrets.key");
+        this.data = readJson(this.file);
+    }
+    reload() { this.data = readJson(this.file); }
+    list() {
+        this.reload();
+        return Object.values(this.data.records)
+            .sort((a, b) => a.id.localeCompare(b.id))
+            .map(({ ciphertext: _ciphertext, tag: _tag, ...record }) => ({ ...record, configured: true }));
+    }
+    getRecord(id) {
+        this.reload();
+        return this.data.records[normalizeSecretId(id)];
+    }
+    async resolve(idOrRef) {
+        const value = String(idOrRef || "").trim();
+        if (!value)
+            return undefined;
+        if (value.startsWith("secret://"))
+            return this.resolve(value.slice("secret://".length));
+        if (value.startsWith("env://"))
+            return process.env[value.slice("env://".length)] || undefined;
+        if (value.startsWith("op://"))
+            return readOnePassword(value);
+        const record = this.getRecord(value);
+        if (!record)
+            return undefined;
+        if (record.backend === "env")
+            return record.ref ? process.env[record.ref.replace(/^env:\/\//, "")] || undefined : undefined;
+        if (record.backend === "1password")
+            return record.ref ? readOnePassword(record.ref) : undefined;
+        if (record.backend === "local")
+            return this.decryptRecord(record);
+        return undefined;
+    }
+    setReference(id, ref, description) {
+        const normalized = normalizeSecretId(id);
+        const trimmed = String(ref || "").trim();
+        let backend;
+        if (trimmed.startsWith("op://"))
+            backend = "1password";
+        else if (trimmed.startsWith("env://"))
+            backend = "env";
+        else
+            throw new Error("Secret references must start with op:// or env://");
+        const prev = this.data.records[normalized];
+        const at = nowIso();
+        this.data.records[normalized] = {
+            id: normalized,
+            backend,
+            ref: trimmed,
+            description: description ?? prev?.description,
+            createdAt: prev?.createdAt ?? at,
+            updatedAt: at,
+        };
+        writeJson(this.file, this.data);
+    }
+    setLocal(id, plaintext, description) {
+        const normalized = normalizeSecretId(id);
+        const value = String(plaintext || "");
+        if (!value)
+            throw new Error("Secret value cannot be empty.");
+        const prev = this.data.records[normalized];
+        const at = nowIso();
+        const encrypted = this.encrypt(value);
+        this.data.records[normalized] = {
+            id: normalized,
+            backend: "local",
+            description: description ?? prev?.description,
+            createdAt: prev?.createdAt ?? at,
+            updatedAt: at,
+            ...encrypted,
+        };
+        writeJson(this.file, this.data);
+    }
+    set(id, valueOrRef, description) {
+        const value = String(valueOrRef || "").trim();
+        if (value.startsWith("op://") || value.startsWith("env://"))
+            this.setReference(id, value, description);
+        else
+            this.setLocal(id, valueOrRef, description);
+    }
+    delete(id) {
+        const normalized = normalizeSecretId(id);
+        const had = Boolean(this.data.records[normalized]);
+        if (had) {
+            delete this.data.records[normalized];
+            writeJson(this.file, this.data);
+        }
+        return had;
+    }
+    async doctor() {
+        const checks = [];
+        const dirExists = fs.existsSync(this.dir);
+        checks.push({ name: "secrets directory", ok: dirExists, detail: this.dir });
+        if (fs.existsSync(this.file))
+            checks.push({ name: "secrets file permissions", ok: modeIsPrivate(this.file), detail: this.file });
+        if (fs.existsSync(this.keyFile))
+            checks.push({ name: "local key file permissions", ok: modeIsPrivate(this.keyFile), detail: this.keyFile });
+        checks.push({ name: "1Password CLI", ok: await commandExists("op"), detail: "required for op:// references" });
+        checks.push({ name: "GitHub CLI", ok: await commandExists("gh"), detail: "fallback for GitHub tokens when no Bivy secret is configured" });
+        return { ok: checks.every((c) => c.ok || c.name === "1Password CLI" || c.name === "GitHub CLI"), checks };
+    }
+    key() {
+        try {
+            const raw = fs.readFileSync(this.keyFile, "utf8").trim();
+            const key = Buffer.from(raw, "base64");
+            if (key.length === 32)
+                return key;
+            // File exists but is malformed/truncated — surface it rather than silently
+            // minting a new key that makes every stored secret undecryptable.
+            throw new Error(`Local secrets key at ${this.keyFile} is invalid (expected 32 bytes)`);
+        }
+        catch (error) {
+            // Only mint a fresh key when the file genuinely does not exist. A transient
+            // read failure (EMFILE, permission blip) must NOT regenerate the key.
+            if (error?.code !== "ENOENT")
+                throw error;
+        }
+        if (isInsideGitWorkTree(this.dir)) {
+            throw new Error(`Refusing to create the local secrets master key inside a git working tree (${this.dir}). ` +
+                `Point BIVY_DATA_DIR (or the vault's appDir) somewhere outside of any git repository — ` +
+                `e.g. ${path.join(os.homedir(), ".bivy")}.`);
+        }
+        fs.mkdirSync(this.dir, { recursive: true, mode: 0o700 });
+        const key = randomBytes(32);
+        fs.writeFileSync(this.keyFile, `${key.toString("base64")}\n`, { mode: 0o600 });
+        fileMode(this.keyFile, 0o600);
+        return key;
+    }
+    encrypt(plaintext) {
+        const iv = randomBytes(12);
+        const cipher = createCipheriv("aes-256-gcm", this.key(), iv);
+        const ciphertext = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+        const tag = cipher.getAuthTag();
+        return { iv: iv.toString("base64"), tag: tag.toString("base64"), ciphertext: ciphertext.toString("base64") };
+    }
+    decryptRecord(record) {
+        if (!record.iv || !record.tag || !record.ciphertext)
+            return undefined;
+        const decipher = createDecipheriv("aes-256-gcm", this.key(), Buffer.from(record.iv, "base64"));
+        decipher.setAuthTag(Buffer.from(record.tag, "base64"));
+        return Buffer.concat([decipher.update(Buffer.from(record.ciphertext, "base64")), decipher.final()]).toString("utf8");
+    }
+}
+async function commandExists(command) {
+    const which = process.platform === "win32" ? "where" : "command";
+    const args = process.platform === "win32" ? [command] : ["-v", command];
+    try {
+        await exec(which, args, process.platform === "win32" ? {} : { shell: true });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readOnePassword(ref) {
+    try {
+        const { stdout } = await exec("op", ["read", ref], { env: process.env });
+        return stdout.trim() || undefined;
+    }
+    catch (error) {
+        throw new Error(`Could not read ${ref} with 1Password CLI. Run 'op signin' and check the reference.`);
+    }
+}
+function modeIsPrivate(file) {
+    if (os.platform() === "win32")
+        return true;
+    try {
+        const mode = fs.statSync(file).mode & 0o777;
+        return (mode & 0o077) === 0;
+    }
+    catch {
+        return false;
+    }
+}
+export async function resolveSecret(value, appDir) {
+    return new SecretVault(appDir).resolve(value);
+}