@bivy/bivy 0.0.0 → 0.1.0-staging.10

package/dist/runtime/credentials.js

@@ -0,0 +1,153 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+// Copyright (c) 2026 Petter André Sjulstad
+// Shared credential resolver for agent env injection.
+//
+// A node-level resolver so every agent runtime can reuse the model-provider
+// logins the user did once, instead of re-authenticating per agent. It reads
+// Bivy's own credential store (credential-store.ts) DIRECTLY — api keys and
+// non-expired OAuth tokens need no Pi at all. Only an expired OAuth token
+// touches Pi, via the isolated pi-oauth bridge, to run the provider's refresh.
+//
+// This keeps Bivy's hot credential path decoupled from Pi: Pi is just another
+// agent that reads the same store.
+import { createCredentialVault } from "./credential-store.js";
+import { refreshModelOAuth } from "./oauth/model-oauth.js";
+/** Refresh an OAuth token this many ms before it expires (clock-skew guard). */
+const OAUTH_REFRESH_SKEW_MS = 60_000;
+/** Resolver over Bivy's credential store, with OAuth refresh-on-read via the bridge. */
+export class NodeCredentialResolver {
+    credsDir;
+    store;
+    constructor(credsDir) {
+        this.credsDir = credsDir;
+        this.store = createCredentialVault(credsDir);
+    }
+    async getCredential(provider) {
+        const id = provider.trim().toLowerCase();
+        if (!id)
+            return undefined;
+        const cred = await this.store.read(id).catch(() => undefined);
+        if (!cred)
+            return undefined;
+        if (cred.type === "api_key") {
+            const token = typeof cred.key === "string" ? cred.key : "";
+            if (!token)
+                return undefined;
+            return { provider: id, kind: "api_key", token, ...(cred.env ? { env: cred.env } : {}) };
+        }
+        // OAuth: use the stored access token while it's fresh; otherwise ask Pi to
+        // run the provider's refresh (which rotates + persists back into our store
+        // under the store lock).
+        let token = typeof cred.access === "string" ? cred.access : "";
+        const expires = Number(cred.expires) || 0;
+        if (!token || expires <= Date.now() + OAUTH_REFRESH_SKEW_MS) {
+            const refreshed = await refreshModelOAuth(this.credsDir, id).catch(() => undefined);
+            if (refreshed)
+                token = refreshed;
+        }
+        if (!token)
+            return undefined;
+        const env = cred.env;
+        return { provider: id, kind: "oauth", token, ...(env ? { env } : {}) };
+    }
+    /** Providers with a stored credential — the vault's contents (not ambient env). */
+    async listConfigured() {
+        const infos = await this.store.list().catch(() => []);
+        return infos.map((info) => info.providerId);
+    }
+}
+/** Build the shared credential resolver from the node's credential vault dir. */
+export function createCredentialStore(credsDir) {
+    return new NodeCredentialResolver(credsDir);
+}
+// Conventional environment variables agent CLIs/SDKs read for each provider. This
+// is how a login the user did once inside Bivy reaches an arbitrary agent process:
+// the agent doesn't know about Bivy's vault, but it does read these env vars.
+const PROVIDER_ENV_KEYS = {
+    anthropic: "ANTHROPIC_API_KEY",
+    openai: "OPENAI_API_KEY",
+    openrouter: "OPENROUTER_API_KEY",
+    google: "GEMINI_API_KEY",
+    gemini: "GEMINI_API_KEY",
+    "google-vertex": "GOOGLE_API_KEY",
+    groq: "GROQ_API_KEY",
+    mistral: "MISTRAL_API_KEY",
+    deepseek: "DEEPSEEK_API_KEY",
+    xai: "XAI_API_KEY",
+    together: "TOGETHER_API_KEY",
+    fireworks: "FIREWORKS_API_KEY",
+    cohere: "COHERE_API_KEY",
+    perplexity: "PERPLEXITY_API_KEY",
+};
+/** Env var an api-key credential for `provider` should be exposed under. */
+export function apiKeyEnvVar(provider) {
+    return PROVIDER_ENV_KEYS[provider] ?? `${provider.replace(/[^a-z0-9]+/gi, "_").toUpperCase()}_API_KEY`;
+}
+// A custom endpoint's base URL is stored in its credential `env` under one of
+// these vars. When that endpoint is the session's ACTIVE provider we also alias
+// its key to the matching standard key var, so an agent that reads OPENAI_* /
+// AZURE_OPENAI_* / ANTHROPIC_* picks up the custom endpoint. Injected only for
+// the active provider — a global base-URL var would hijack the real provider.
+const BASE_URL_TO_KEY_VAR = {
+    OPENAI_BASE_URL: "OPENAI_API_KEY",
+    AZURE_OPENAI_BASE_URL: "AZURE_OPENAI_API_KEY",
+    ANTHROPIC_BASE_URL: "ANTHROPIC_API_KEY",
+};
+/**
+ * Map every credential the node holds (or a chosen subset) to the environment
+ * variables an agent process reads, so one sign-in inside Bivy serves whatever
+ * runtime/model the user selects — not just the Pi agent. Anthropic OAuth
+ * (Claude Pro/Max) is exposed as CLAUDE_CODE_OAUTH_TOKEN; every other credential
+ * is exposed as the provider's API-key var.
+ *
+ * Provider-scoped `env` (custom base URLs) is injected ONLY for `activeProvider`
+ * — the session's selected provider. Base-URL vars like OPENAI_BASE_URL are
+ * global to the agent process, so injecting a custom endpoint's base URL for a
+ * non-active provider would silently redirect the real provider. Best-effort: a
+ * provider that fails to resolve is skipped rather than failing the session.
+ */
+export async function buildAgentCredentialEnv(store, providers, activeProvider) {
+    const ids = providers ?? (store.listConfigured ? await store.listConfigured().catch(() => []) : []);
+    const active = activeProvider?.trim().toLowerCase() || undefined;
+    // Process the active provider LAST so its base URL and standard-key alias win
+    // over a same-named var from another provider (e.g. a real "openai" key var
+    // must not clobber an active custom endpoint's aliased OPENAI_API_KEY).
+    const ordered = active ? [...ids].sort((a, b) => Number(a === active) - Number(b === active)) : ids;
+    const env = {};
+    for (const id of ordered) {
+        let cred;
+        try {
+            cred = await store.getCredential(id);
+        }
+        catch {
+            continue;
+        }
+        if (!cred)
+            continue;
+        const isActive = !!active && cred.provider === active;
+        if (cred.kind === "oauth") {
+            // OAuth *subscription* tokens are provider-specific and are not accepted
+            // as a plain API key. Only Anthropic has a documented env var an external
+            // agent reads (Claude Code's OAuth token); other providers' subscription
+            // logins can't be handed off this way, so don't emit a misleading key.
+            if (cred.provider !== "anthropic")
+                continue;
+            Object.assign(env, cred.env ?? {});
+            env.CLAUDE_CODE_OAUTH_TOKEN = cred.token;
+        }
+        else {
+            env[apiKeyEnvVar(cred.provider)] = cred.token;
+            // A custom endpoint's base URL (and standard-key alias) is injected only
+            // when it's the active provider, so it can't hijack the real provider.
+            if (isActive && cred.env) {
+                Object.assign(env, cred.env);
+                for (const baseVar of Object.keys(cred.env)) {
+                    const keyVar = BASE_URL_TO_KEY_VAR[baseVar];
+                    if (keyVar && cred.token)
+                        env[keyVar] = cred.token;
+                }
+            }
+        }
+    }
+    return env;
+}

package/dist/runtime/host.js

@@ -0,0 +1,153 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+// Copyright (c) 2026 Petter André Sjulstad
+import { listRuntimes, makeRuntime } from "./index.js";
+import { RemoteRuntime, connectSocketTransport } from "./remote.js";
+function remoteRuntimeSelection() {
+    const flag = process.env.BIVY_REMOTE_RUNTIME?.trim();
+    if (!flag || flag === "0" || flag.toLowerCase() === "false")
+        return null;
+    const addr = process.env.BIVY_REMOTE_RUNTIME_ADDR?.trim();
+    if (!addr)
+        return null; // enabled but nowhere to connect — stay in-process
+    const all = ["1", "true", "all", "*"].includes(flag.toLowerCase());
+    const ids = all ? null : new Set(flag.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean));
+    return { addr, enabled: (id) => all || Boolean(ids?.has(id)) };
+}
+/**
+ * Whether the remote-runtime path is active at all (flag set AND an address to
+ * connect to). Stage 3 gates startup adoption and the control-plane location
+ * registry on this so those hooks are inert — and the daemon byte-identical —
+ * when the flag is off (docs/agent-node-decoupling.md).
+ */
+export function remoteRuntimeEnabled() {
+    return remoteRuntimeSelection() !== null;
+}
+/** Fill a RuntimeInfo's partial capabilities into a full, default-false surface. */
+function fullCapabilities(partial) {
+    return { toolInterception: false, modelSelection: false, packages: false, resume: false, fork: false, ...partial };
+}
+export function enforcementLevelFor(capabilities, runtimeId) {
+    if (capabilities.toolInterception)
+        return "strong";
+    if (runtimeId === "generic-cli")
+        return "boundary";
+    return "observe_only";
+}
+/**
+ * Small runtime host seam above concrete adapters. The node should talk to this
+ * for registry lookup, adapter caching, session create/open/list, and capability
+ * reporting instead of scattering runtime glue through server.ts.
+ */
+export class RuntimeHost {
+    options;
+    cache = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    list(currentId) {
+        return listRuntimes(currentId);
+    }
+    resolveRuntimeId(requested, fallback) {
+        const wantId = (requested || fallback).toLowerCase();
+        const info = this.list().find((candidate) => candidate.id === wantId);
+        if (!info)
+            throw new Error(`Unknown agent: ${wantId}`);
+        if (info.status !== "available")
+            throw new Error(`${info.displayName} is not available on this node yet.`);
+        return wantId;
+    }
+    get(requested, fallback, sandbox) {
+        // Remote path (opt-in, reversible): return a RemoteRuntime that drives the
+        // runtime in a separate agent service. Checked BEFORE resolveRuntimeId so a
+        // runtime the daemon can't run locally (e.g. the Claude SDK isn't installed
+        // here) is still offloadable — remote availability is the service's business.
+        const remote = remoteRuntimeSelection();
+        const wantId = (requested || fallback).toLowerCase();
+        if (remote && remote.enabled(wantId))
+            return this.getRemote(wantId, remote.addr, sandbox);
+        const id = this.resolveRuntimeId(requested, fallback);
+        // A per-session sandbox override bakes into the runtime's launch flags, so it
+        // must not share the cached instance built for the node default. Key such
+        // runtimes by tier; runtimes without an override keep the plain-id entry.
+        const key = sandbox ? `${id}::sandbox=${sandbox}` : id;
+        let rt = this.cache.get(key);
+        if (!rt) {
+            rt = makeRuntime({ ...this.options, runtime: id, sandbox });
+            this.cache.set(key, rt);
+            if (!sandbox && rt.id !== id)
+                this.cache.set(rt.id, rt);
+        }
+        return rt;
+    }
+    /**
+     * Per-session remote routing (Stage 3, docs/agent-node-decoupling.md): build (or
+     * reuse) a RemoteRuntime pointed at a SPECIFIC agent-service address, rather than
+     * the process-wide BIVY_REMOTE_RUNTIME_ADDR. An adopted session may live on a
+     * different service than the node default, so re-attach must target the address
+     * recorded for that session. Caching is keyed by address, so distinct services
+     * get distinct runtime facades.
+     */
+    getRemoteAt(id, addr, sandbox) {
+        return this.getRemote(id, addr, sandbox);
+    }
+    /** Build (and cache) a RemoteRuntime facade for `id`, addressed at `addr`. */
+    getRemote(id, addr, sandbox) {
+        const key = `remote::${addr}::${id}${sandbox ? `::sandbox=${sandbox}` : ""}`;
+        let rt = this.cache.get(key);
+        if (!rt) {
+            // Passing `id` as currentId includes it even if it's hidden from the picker,
+            // so the capability/displayName lookup works for any known runtime.
+            const info = this.list(id).find((candidate) => candidate.id === id);
+            if (!info)
+                throw new Error(`Unknown agent: ${id}`);
+            rt = new RemoteRuntime({
+                targetRuntime: id,
+                displayName: info.displayName,
+                capabilities: fullCapabilities(info.capabilities),
+                sandbox,
+                agentServiceAddress: addr,
+                connect: () => connectSocketTransport(addr),
+            });
+            this.cache.set(key, rt);
+        }
+        return rt;
+    }
+    summary(runtime) {
+        return {
+            id: runtime.id,
+            displayName: runtime.displayName,
+            capabilities: runtime.capabilities,
+            enforcementLevel: enforcementLevelFor(runtime.capabilities, runtime.id),
+        };
+    }
+    async createSession(runtime, options) {
+        return runtime.createSession(options);
+    }
+    async openSession(runtime, options) {
+        return runtime.openSession(options);
+    }
+    async listSessions(runtime) {
+        return runtime.listSessions();
+    }
+    /** Ask a runtime to forget a session from its own store (see
+     *  AgentRuntime.deleteSession). No-ops to `false` for runtimes that keep no
+     *  store of their own. */
+    async deleteSession(runtime, sessionId, sessionFile) {
+        return (await runtime.deleteSession?.(sessionId, sessionFile)) ?? false;
+    }
+    /** Fast, build-free transcript read for opening a session (see AgentRuntime.readMessages). */
+    readMessages(runtime, sessionFile) {
+        return runtime.readMessages?.(sessionFile);
+    }
+    /** Enumerate a runtime's own provider-native sessions this node didn't start
+     *  (see AgentRuntime.discoverNativeSessions, issue #156). Empty for a runtime
+     *  that doesn't support discovery, or on any adapter-level failure. */
+    async discoverNativeSessions(runtime) {
+        try {
+            return (await runtime.discoverNativeSessions?.()) ?? [];
+        }
+        catch {
+            return [];
+        }
+    }
+}