@bivy/bivy 0.10.1-staging.182 → 0.10.1-staging.183

package/dist/credentials/index.js

@@ -13,7 +13,7 @@
 // `src/credentials/`. Later phases move the implementations under this directory
 // and wire selection into the live path. See docs/credentials-service-plan.md.
 // --- The record model + selection (new, pure) ------------------------------
-export { DEFAULT_LABEL, normalizeProvider, normalizeLabel, credKey, parseCredKey, agentNativeLabel, defaultSyncFor, resolveCredential, missingPresetLabels, } from "./records.js";
+export { DEFAULT_LABEL, normalizeProvider, normalizeLabel, credKey, parseCredKey, agentNativeLabel, defaultSyncFor, inferReferenceBackend, resolveCredential, missingPresetLabels, } from "./records.js";
 // --- The v3 document engine: schema, migration, merge (new, pure) -----------
 export { emptyDocument, recordFromStored, preferIncomingRecord, tombstoneWinsRecord, migrateToV3, mergeDocuments, } from "./document.js";
 // --- Selection presets (config-as-code) -------------------------------------
@@ -25,4 +25,4 @@ export { createCredentialStore, buildAgentCredentialEnv, apiKeyEnvVar, NodeCrede
 // --- The daemon credential API (ours — currently named pi-auth.ts) ----------
 // Phase 5 renames the file to `src/credentials/api.ts`; the facade keeps the
 // import path stable so call sites don't churn when it moves.
-export { listProviders, exportProviderAuth, exportProviderAuthTombstones, importProviderAuth, setProviderApiKey, setProviderCredential, removeProvider, } from "../runtime/pi-auth.js";
+export { listProviders, exportProviderAuth, exportProviderAuthTombstones, importProviderAuth, setProviderApiKey, setProviderCredential, setProviderReference, removeProvider, } from "../runtime/pi-auth.js";

package/dist/credentials/records.js

@@ -57,6 +57,20 @@ export function defaultSyncFor(origin) {
     // logins stay on the node they were made on until explicitly promoted.
     return origin === "bivy" ? "account" : "node";
 }
+/**
+ * The reference backend a pointer targets, inferred from its scheme:
+ * `op://…` → 1Password, `env://NAME` → an environment variable. Anything else
+ * (a bare value, a `secret://` local-vault ref, junk) returns undefined — a
+ * reference credential must point at an external, per-node-resolvable secret.
+ */
+export function inferReferenceBackend(ref) {
+    const value = String(ref ?? "").trim();
+    if (value.startsWith("op://"))
+        return "1password";
+    if (value.startsWith("env://"))
+        return "env";
+    return undefined;
+}
 function recordsForProvider(records, provider) {
     const id = normalizeProvider(provider);
     return records.filter((r) => r.provider === id);

package/dist/runtime/credential-store.js

@@ -21,7 +21,7 @@ import path from "node:path";
 import { randomBytes } from "node:crypto";
 import { seal, open } from "../e2e.js";
 import { migrateToV3, mergeDocuments, recordFromStored, emptyDocument, } from "../credentials/document.js";
-import { credKey, parseCredKey, DEFAULT_LABEL } from "../credentials/records.js";
+import { credKey, parseCredKey, normalizeLabel, DEFAULT_LABEL } from "../credentials/records.js";
 const LOCK_STALE_MS = 30_000;
 const LOCK_RETRY_MS = 25;
 const LOCK_TIMEOUT_MS = 10_000;
@@ -221,6 +221,45 @@ export class BivyCredentialStore {
             throw new Error("API key cannot be empty");
         await this.modify(provider, async () => ({ type: "api_key", key: apiKey }));
     }
+    /**
+     * Store a reference credential — a pointer (`op://…` / `env://NAME`) resolved
+     * per-node at read time (see the resolver), never the secret itself. The
+     * pointer is safe to sync across nodes; the secret stays in the manager. A
+     * reference is api-key-shaped, so it cannot model a rotating OAuth token set.
+     * Writes at `provider:label` (defaulting to the provider's default slot).
+     */
+    async setReference(provider, ref, backend, label = DEFAULT_LABEL) {
+        const id = providerId(provider);
+        if (!id)
+            throw new Error("Provider is required");
+        const pointer = String(ref ?? "").trim();
+        if (!pointer)
+            throw new Error("Reference cannot be empty");
+        const key = credKey(id, label);
+        await this.enqueue(id, async () => {
+            await this.acquireLock();
+            try {
+                const document = this.readDocument();
+                const existing = document.credentials[key];
+                const record = {
+                    provider: id,
+                    label: normalizeLabel(label),
+                    source: { kind: "reference", ref: pointer, backend },
+                    // Preserve an existing record's sync/origin; a new reference is a
+                    // Bivy-first, opt-out-sync credential (only the pointer ever syncs).
+                    sync: existing?.sync ?? "account",
+                    origin: existing?.origin ?? "bivy",
+                    updatedAt: Date.now(),
+                };
+                document.credentials[key] = record;
+                delete document.deletedAt[key];
+                this.writeDocument(document);
+            }
+            finally {
+                await this.releaseLock();
+            }
+        });
+    }
     /**
      * Every stored credential, keyed by provider id — the cross-node snapshot.
      * The wire stays provider-keyed (v2 shape), so only `provider:default` records

package/dist/runtime/credentials.js

@@ -10,8 +10,10 @@
 //
 // This keeps Bivy's hot credential path decoupled from Pi: Pi is just another
 // agent that reads the same store.
+import path from "node:path";
 import { createCredentialVault } from "./credential-store.js";
 import { refreshModelOAuth } from "./oauth/model-oauth.js";
+import { resolveSecret } from "../secrets.js";
 import { resolveCredential } from "../credentials/records.js";
 import { loadPresets, defaultPresetsPath } from "../credentials/presets.js";
 /** Refresh an OAuth token this many ms before it expires (clock-skew guard). */
@@ -22,10 +24,14 @@ export class NodeCredentialResolver {
     store;
     presetsPath;
     presetsCache;
+    appDir;
     constructor(credsDir) {
         this.credsDir = credsDir;
         this.store = createCredentialVault(credsDir);
         this.presetsPath = defaultPresetsPath(credsDir);
+        // The data dir that holds the local secret vault, for resolving `secret://`
+        // references (`op://`/`env://` need no dir). credsDir is `<appDir>/credentials`.
+        this.appDir = path.dirname(credsDir);
     }
     /** The node's selection presets, read once per resolver (see presets.ts). */
     presets() {
@@ -40,14 +46,22 @@ export class NodeCredentialResolver {
         // Selection is data-driven: pick the record for this provider per the active
         // preset (records.ts). With one credential per provider this resolves to that
         // credential; ambiguity (multiple accounts, no preset) returns nothing rather
-        // than guessing. Reference records are resolved in a later phase.
+        // than guessing.
         const records = await this.store.listRecords().catch(() => []);
         const selection = resolveCredential(id, records, this.presets());
         if (!selection)
             return undefined;
         const source = selection.record.source;
-        if (source.kind !== "stored")
-            return undefined;
+        // A reference credential is a pointer (op:// / env://) resolved per-node at
+        // read time via the secret vault — the secret never lived in our store. It is
+        // api-key-shaped. A node that can't resolve it (no `op` session, missing env)
+        // reports no credential here rather than falling back to another account.
+        if (source.kind === "reference") {
+            const token = (await resolveSecret(source.ref, this.appDir).catch(() => undefined))?.trim();
+            if (!token)
+                return undefined;
+            return { provider: id, kind: "api_key", token };
+        }
         const cred = source.cred;
         if (cred.type === "api_key") {
             const token = typeof cred.key === "string" ? cred.key : "";

package/dist/runtime/pi-auth.js

@@ -9,6 +9,7 @@
 // pi-oauth bridge supplies (Bivy has no model catalog of its own).
 import { createCredentialVault } from "./credential-store.js";
 import { listPiProviders } from "./pi-oauth.js";
+import { inferReferenceBackend } from "../credentials/records.js";
 /**
  * Enumerate model providers with their current auth status. The catalog + status
  * come from Pi's provider list (joined with our injected store); the stored
@@ -77,6 +78,25 @@ export async function setProviderCredential(credsDir, provider, opts) {
         return cred;
     });
 }
+/**
+ * Store a reference credential for a model provider: a pointer (`op://…` /
+ * `env://NAME`) that Bivy resolves per-node at read time, so the secret stays in
+ * the password manager / environment and never enters the vault. The backend is
+ * inferred from the pointer's scheme. This is the recommended way to use a
+ * password-manager-held model key — it supersedes wiring `ANTHROPIC_API_KEY:
+ * op://…` through `cli.json`, because a reference is labeled, selectable, and
+ * visible in the Models UI like any other credential.
+ */
+export async function setProviderReference(credsDir, provider, ref) {
+    const id = provider.trim().toLowerCase();
+    if (!id)
+        throw new Error("Provider is required");
+    const pointer = String(ref ?? "").trim();
+    const backend = inferReferenceBackend(pointer);
+    if (!backend)
+        throw new Error("Reference must be an op:// or env:// pointer");
+    await createCredentialVault(credsDir).setReference(id, pointer, backend);
+}
 /** Forget a provider's stored credential (API key or OAuth token). */
 export async function removeProvider(credsDir, provider) {
     const id = provider.trim().toLowerCase();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bivy/bivy",
-  "version": "0.10.1-staging.182",
+  "version": "0.10.1-staging.183",
   "type": "module",
   "license": "AGPL-3.0-only",
   "description": "Run coding agents on machines you own. Open-source, self-hostable agent workspace.",