@bivy/bivy 0.0.0 → 0.1.0-staging.2

package/dist/session-event-coalescer.js

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+// Copyright (c) 2026 Petter André Sjulstad
+const defaultTimers = {
+    schedule: (fn, ms) => setTimeout(fn, ms),
+    cancel: (h) => clearTimeout(h),
+};
+export class SessionEventCoalescer {
+    pending = new Map();
+    timers = new Map();
+    coalesceMs;
+    emit;
+    clock;
+    constructor(opts) {
+        this.coalesceMs = opts.coalesceMs;
+        this.emit = opts.emit;
+        this.clock = opts.timers ?? defaultTimers;
+    }
+    /** Queue a self-superseding update for `sessionId`, replacing any pending one. */
+    push(sessionId, payload) {
+        this.pending.set(sessionId, payload);
+        if (!this.timers.has(sessionId)) {
+            this.timers.set(sessionId, this.clock.schedule(() => this.flush(sessionId), this.coalesceMs));
+        }
+    }
+    /** Emit the pending update for `sessionId` immediately, if any. */
+    flush(sessionId) {
+        this.cancelTimer(sessionId);
+        if (this.pending.has(sessionId)) {
+            const payload = this.pending.get(sessionId);
+            this.pending.delete(sessionId);
+            this.emit(payload);
+        }
+    }
+    /** Drop any pending update and timer for `sessionId` without emitting (teardown). */
+    clear(sessionId) {
+        this.cancelTimer(sessionId);
+        this.pending.delete(sessionId);
+    }
+    /** Number of sessions with a pending update (test/introspection aid). */
+    get size() {
+        return this.pending.size;
+    }
+    cancelTimer(sessionId) {
+        const handle = this.timers.get(sessionId);
+        if (handle !== undefined) {
+            this.clock.cancel(handle);
+            this.timers.delete(sessionId);
+        }
+    }
+}

package/dist/session-identity.js

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+// Copyright (c) 2026 Petter André Sjulstad
+import path from "node:path";
+/**
+ * The identity key two rows share iff they're the same durable conversation: a
+ * resolved on-disk path when known (so relative/absolute spellings of the same
+ * file collapse together), else the bare id. Shared by dedupeSessionSummaries
+ * below and by native-session-discovery.ts's cross-check against Bivy-managed
+ * sessions (issue #156) — one identity scheme, not two copies of it.
+ */
+export function sessionIdentityKey(ref) {
+    return ref.path ? `ref:${path.resolve(ref.path)}` : `id:${ref.id}`;
+}
+/** Collapse adapter-local rows that point at the same durable conversation. */
+export function dedupeSessionSummaries(sessions, ownerFor) {
+    const byIdentity = new Map();
+    for (const session of sessions) {
+        const owner = ownerFor(session);
+        const ref = owner?.path || session.path;
+        const identity = sessionIdentityKey(ref ? { path: ref } : { id: session.id });
+        const current = byIdentity.get(identity);
+        if (!current) {
+            byIdentity.set(identity, session);
+            continue;
+        }
+        const score = (candidate) => {
+            const candidateOwner = ownerFor(candidate);
+            return Number(candidateOwner?.id === candidate.id) * 2 + Number(candidateOwner?.runtimeId === candidate.agent);
+        };
+        if (score(session) > score(current))
+            byIdentity.set(identity, session);
+    }
+    return [...byIdentity.values()];
+}

package/dist/session-ref.js

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+// Copyright (c) 2026 Petter André Sjulstad
+import path from "node:path";
+/**
+ * Reduce an id-based runtime's resume ref to the bare session id it expects.
+ *
+ * A ref may arrive as the id itself (the common case — e.g. straight from Bivy's
+ * metadata store) or, for adapters that surface an on-disk transcript path, as a
+ * ".../<id>.jsonl" file (Claude Code lists sessions from ~/.claude that way). Both
+ * normalize to "<id>".
+ */
+export function sessionIdFromRef(ref) {
+    return /[/\\]|\.jsonl$/i.test(ref) ? path.basename(ref).replace(/\.jsonl$/i, "") : ref;
+}
+/**
+ * Normalize a resume ref into the token the owning runtime actually expects,
+ * enforcing the sessions-dir guard only where it applies.
+ *
+ * Bivy is the unifying store for sessions started anywhere, so resume must work
+ * for every runtime — but runtimes differ in what a "session ref" is:
+ *
+ *   - Path-based runtimes (pi) resume by reading a transcript file. The daemon
+ *     can be handed an arbitrary path by a remote client, so these refs are
+ *     confined to the node's sessions directory (path-traversal guard).
+ *   - Id-based runtimes (Claude Code, …) resume by an opaque session id they
+ *     validate themselves and store their transcripts elsewhere (~/.claude).
+ *     There is no local file to confine, so the guard must NOT apply — doing so
+ *     is what made those sessions fail with "Session file is outside the
+ *     sessions directory".
+ *
+ * Throws for a path-based ref that escapes `sessionsDir`.
+ */
+export function resolveResumeRef(opts) {
+    const { ref, resumesByPath, sessionsDir } = opts;
+    if (!resumesByPath)
+        return sessionIdFromRef(ref);
+    const resolved = path.resolve(ref);
+    if (!resolved.startsWith(path.resolve(sessionsDir) + path.sep)) {
+        throw new Error("Session file is outside the sessions directory");
+    }
+    return resolved;
+}
+/**
+ * Decide what to resume a client-named session from when the node isn't holding
+ * it in memory (a restart, an idle close, or a session this process never
+ * opened — the PWA lists sessions straight from durable metadata). Prefer an
+ * explicit transcript path, then the path metadata recorded, and finally — for
+ * id-based runtimes that keep no confinable local file — the session id itself.
+ *
+ * Returns undefined when nothing durable is known: a session this node never
+ * started, or one that was deleted. The caller turns that into "Session not
+ * found" rather than resurrecting a bogus session from an arbitrary id. This is
+ * the decision that lets a real-but-closed session resume instead of failing —
+ * the root of the PWA's "can't resume sessions / sessions not found".
+ */
+export function resumeRefFor(opts) {
+    const explicit = opts.path?.trim();
+    if (explicit)
+        return explicit;
+    if (opts.metaPath)
+        return opts.metaPath;
+    if (opts.metaKnown && opts.id)
+        return opts.id;
+    return undefined;
+}

package/dist/stt-cli.js

@@ -0,0 +1,131 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+// Copyright (c) 2026 Petter André Sjulstad
+// `bivy voice` — configure speech-to-text (voice input) from the terminal.
+//
+// Mirrors the web app's Settings → Voice input panel: pick a preferred provider
+// and store a per-provider API key (encrypted in the SecretVault). Keeps CLI and
+// React in parity via the shared helpers in stt.ts.
+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 { STT_PROVIDERS, getSttConfig, isSttProvider, removeSttKey, resolveSttKey, setSttKey, setSttProvider, sttProviderList, } from "./stt.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");
+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 voice <status|provider|key|remove>
+
+Commands:
+  bivy voice                         Show the current provider and which keys are set
+  bivy voice status                  (same as above)
+  bivy voice provider <groq|openai>  Choose the preferred transcription provider
+  bivy voice key <groq|openai> [key] Store an API key (prompts when the key is omitted)
+  bivy voice remove <groq|openai>    Forget a stored API key
+
+Providers:
+  groq     ${STT_PROVIDERS.groq.model} — fast, low cost, strong multilingual
+  openai   ${STT_PROVIDERS.openai.model} — top accuracy
+`);
+}
+function parseProvider(value) {
+    if (!isSttProvider(value)) {
+        throw new Error(`Provider must be one of: ${sttProviderList().join(", ")}`);
+    }
+    return value;
+}
+async function printStatus() {
+    const config = await getSttConfig(appDir);
+    console.log(`Preferred provider: ${config.provider}`);
+    for (const p of config.providers) {
+        const active = p.id === config.provider ? " (preferred)" : "";
+        console.log(`  ${p.configured ? "✓" : "·"} ${p.id.padEnd(7)} ${p.label} — ${p.model}${active}`);
+    }
+    console.log(config.providers.some((p) => p.configured)
+        ? ""
+        : "\nNo keys set yet. Run 'bivy voice key groq' or 'bivy voice key openai'.");
+}
+async function main() {
+    const [cmd, arg, ...rest] = process.argv.slice(2);
+    if (!cmd || cmd === "help" || cmd === "--help" || cmd === "-h") {
+        usage();
+        return;
+    }
+    switch (cmd) {
+        case "status":
+            await printStatus();
+            return;
+        case "provider": {
+            const provider = parseProvider(arg);
+            setSttProvider(appDir, provider);
+            console.log(`Preferred voice provider set to ${provider}.`);
+            if (!(await resolveSttKey(appDir, provider))) {
+                console.log(`No key stored for ${provider} yet — run 'bivy voice key ${provider}'.`);
+            }
+            return;
+        }
+        case "key": {
+            const provider = parseProvider(arg);
+            const value = rest.join(" ").trim() || (await askHidden(`${STT_PROVIDERS[provider].label} API key: `));
+            setSttKey(appDir, provider, value);
+            console.log(`Saved ${provider} key.`);
+            return;
+        }
+        case "remove": {
+            const provider = parseProvider(arg);
+            console.log(removeSttKey(appDir, provider) ? `Removed ${provider} key.` : `No ${provider} key was stored.`);
+            return;
+        }
+        default:
+            console.error(`Unknown command: ${cmd}\n`);
+            usage();
+            process.exitCode = 1;
+    }
+}
+main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});

package/dist/stt.js

@@ -0,0 +1,168 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+// Copyright (c) 2026 Petter André Sjulstad
+// Speech-to-text (voice input) — shared logic for the node server and the CLI.
+//
+// A voice recording captured in the web app (or any client) is forwarded to the
+// node, which holds the provider API key and makes the transcription call on the
+// user's behalf. Two providers are supported; the user picks a preferred one and
+// stores a key per provider. Keys live in the encrypted SecretVault (never in
+// settings.json); the preferred provider is a plain setting.
+//
+// Both providers expose the same OpenAI-compatible /audio/transcriptions
+// multipart endpoint that returns `{ text }`, which keeps the call site uniform.
+import fs from "node:fs";
+import path from "node:path";
+import { SecretVault } from "./secrets.js";
+export const STT_PROVIDERS = {
+    groq: {
+        id: "groq",
+        label: "Groq (Whisper)",
+        url: "https://api.groq.com/openai/v1/audio/transcriptions",
+        model: "whisper-large-v3-turbo",
+        keyEnv: "GROQ_API_KEY",
+    },
+    openai: {
+        id: "openai",
+        label: "OpenAI",
+        url: "https://api.openai.com/v1/audio/transcriptions",
+        model: "gpt-4o-mini-transcribe",
+        keyEnv: "OPENAI_API_KEY",
+    },
+};
+export const DEFAULT_STT_PROVIDER = "groq";
+/** Max audio payload we forward to a provider (their own caps are ~25 MB). */
+export const MAX_AUDIO_BYTES = 25 * 1024 * 1024;
+export function isSttProvider(value) {
+    return value === "groq" || value === "openai";
+}
+export function sttProviderList() {
+    return Object.keys(STT_PROVIDERS);
+}
+/** Vault secret id holding a provider's API key. */
+export function sttKeyId(provider) {
+    return `stt.${provider}`;
+}
+function settingsPath(appDir) {
+    return path.join(appDir, "settings.json");
+}
+function readSettings(appDir) {
+    try {
+        const file = settingsPath(appDir);
+        return fs.existsSync(file) ? JSON.parse(fs.readFileSync(file, "utf8")) : {};
+    }
+    catch {
+        return {};
+    }
+}
+// Read-modify-write so we never clobber unrelated settings (approvalMode, etc.).
+function writeSettings(appDir, settings) {
+    fs.mkdirSync(appDir, { recursive: true });
+    fs.writeFileSync(settingsPath(appDir), `${JSON.stringify(settings, null, 2)}\n`);
+}
+export function getSttProvider(appDir) {
+    const raw = readSettings(appDir).sttProvider;
+    return isSttProvider(raw) ? raw : DEFAULT_STT_PROVIDER;
+}
+export function setSttProvider(appDir, provider) {
+    if (!isSttProvider(provider))
+        throw new Error(`Unknown speech provider: ${provider}`);
+    const settings = readSettings(appDir);
+    settings.sttProvider = provider;
+    writeSettings(appDir, settings);
+    return provider;
+}
+/** Resolve a provider key: stored vault secret first, then env-var fallback. */
+export async function resolveSttKey(appDir, provider) {
+    const fromVault = await new SecretVault(appDir).resolve(sttKeyId(provider)).catch(() => undefined);
+    if (fromVault)
+        return fromVault;
+    const env = process.env[STT_PROVIDERS[provider].keyEnv];
+    return env && env.trim() ? env.trim() : undefined;
+}
+export function setSttKey(appDir, provider, key) {
+    if (!isSttProvider(provider))
+        throw new Error(`Unknown speech provider: ${provider}`);
+    const value = String(key || "").trim();
+    if (!value)
+        throw new Error("API key cannot be empty.");
+    new SecretVault(appDir).setLocal(sttKeyId(provider), value, `${STT_PROVIDERS[provider].label} speech-to-text key`);
+}
+export function removeSttKey(appDir, provider) {
+    if (!isSttProvider(provider))
+        throw new Error(`Unknown speech provider: ${provider}`);
+    return new SecretVault(appDir).delete(sttKeyId(provider));
+}
+/** The voice-input status the settings UIs render: chosen provider + which keys exist. */
+export async function getSttConfig(appDir) {
+    const provider = getSttProvider(appDir);
+    const providers = await Promise.all(sttProviderList().map(async (id) => ({
+        id,
+        label: STT_PROVIDERS[id].label,
+        model: STT_PROVIDERS[id].model,
+        configured: Boolean(await resolveSttKey(appDir, id)),
+    })));
+    return { provider, providers };
+}
+/** Send audio to the chosen provider and return the transcript text. */
+export async function transcribeAudio(input) {
+    const provider = isSttProvider(input.provider) ? input.provider : getSttProvider(input.appDir);
+    const spec = STT_PROVIDERS[provider];
+    if (!input.audio || input.audio.length === 0)
+        throw new Error("No audio was recorded.");
+    if (input.audio.length > MAX_AUDIO_BYTES)
+        throw new Error("Recording is too large to transcribe.");
+    const key = await resolveSttKey(input.appDir, provider);
+    if (!key) {
+        throw new Error(`No API key set for ${spec.label}. Add one in Settings → Voice input, or run 'bivy voice key ${provider}'.`);
+    }
+    const mime = input.mimeType || "audio/webm";
+    const filename = input.filename || `audio.${extensionForMime(mime)}`;
+    const form = new FormData();
+    // Copy into a plain Uint8Array — a Node Buffer's backing store is typed as
+    // possibly-SharedArrayBuffer, which isn't a valid BlobPart under DOM lib types.
+    form.append("file", new Blob([new Uint8Array(input.audio)], { type: mime }), filename);
+    form.append("model", spec.model);
+    form.append("response_format", "json");
+    if (input.language)
+        form.append("language", input.language);
+    let res;
+    try {
+        res = await fetch(spec.url, { method: "POST", headers: { authorization: `Bearer ${key}` }, body: form });
+    }
+    catch (error) {
+        throw new Error(`Could not reach ${spec.label}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const body = await res.text();
+    if (!res.ok) {
+        let detail = body.slice(0, 300);
+        try {
+            detail = JSON.parse(body)?.error?.message || detail;
+        }
+        catch {
+            /* keep raw body */
+        }
+        throw new Error(`${spec.label} transcription failed (${res.status}): ${detail}`);
+    }
+    let data;
+    try {
+        data = JSON.parse(body);
+    }
+    catch {
+        throw new Error(`${spec.label} returned an unreadable response.`);
+    }
+    return String(data.text ?? "").trim();
+}
+function extensionForMime(mime) {
+    const m = mime.toLowerCase();
+    if (m.includes("webm"))
+        return "webm";
+    if (m.includes("ogg"))
+        return "ogg";
+    if (m.includes("mp4") || m.includes("m4a") || m.includes("aac"))
+        return "m4a";
+    if (m.includes("mpeg") || m.includes("mp3"))
+        return "mp3";
+    if (m.includes("wav"))
+        return "wav";
+    return "webm";
+}