@ouro.bot/cli 0.1.0-alpha.227 → 0.1.0-alpha.228

package/changelog.json

@@ -1,10 +1,16 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.228",
+      "changes": [
+        "refactor(repertoire): credential access layer with encrypted store, vault config types, golden path integration test"
+      ]
+    },
     {
       "version": "0.1.0-alpha.227",
       "changes": [
-        "fix: direct filesystem name resolution in sendProactiveBlueBubblesMessageToSession — bypass store.get()/listAll() with raw fs reads on friends directory when store lookup fails"
+        "fix: direct filesystem name resolution in sendProactiveBlueBubblesMessageToSession"
       ]
     },
     {

package/dist/heart/auth/auth-flow.js

@@ -93,6 +93,9 @@ const DEFAULT_SECRETS_TEMPLATE = {
         skipConfirmation: true,
         port: 3978,
     },
+    vault: {
+        masterPassword: "",
+    },
     integrations: {
         perplexityApiKey: "",
         openaiEmbeddingsApiKey: "",

package/dist/heart/config.js

@@ -117,6 +117,9 @@ const DEFAULT_SECRETS_TEMPLATE = {
         webhookPath: "/bluebubbles-webhook",
         requestTimeoutMs: 30000,
     },
+    vault: {
+        masterPassword: "",
+    },
     integrations: {
         perplexityApiKey: "",
         openaiEmbeddingsApiKey: "",
@@ -138,6 +141,7 @@ function defaultRuntimeConfig() {
         teamsChannel: { ...DEFAULT_SECRETS_TEMPLATE.teamsChannel },
         bluebubbles: { ...DEFAULT_SECRETS_TEMPLATE.bluebubbles },
         bluebubblesChannel: { ...DEFAULT_SECRETS_TEMPLATE.bluebubblesChannel },
+        vault: { ...DEFAULT_SECRETS_TEMPLATE.vault },
         integrations: { ...DEFAULT_SECRETS_TEMPLATE.integrations },
     };
 }

package/dist/repertoire/api-client.js

@@ -10,37 +10,34 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.apiRequest = apiRequest;
 const api_error_1 = require("../heart/api-error");
 const runtime_1 = require("../nerves/runtime");
-const bitwarden_client_1 = require("./bitwarden-client");
+const credential_access_1 = require("./credential-access");
 /**
  * Execute an authenticated API request with standard logging and error handling.
  * Returns the response body as a pretty-printed JSON string.
  */
 async function apiRequest(options) {
-    const { baseUrl, method, path, token, clientName, serviceLabel, connectionName, body, extraHeaders, contentType, eventMeta, vaultKey, vaultField, } = options;
-    // Resolve token from vault if vaultKey is provided
+    const { baseUrl, method, path, token, clientName, serviceLabel, connectionName, body, extraHeaders, contentType, eventMeta, credentialDomain, credentialField, } = options;
+    // Resolve token from credential store if credentialDomain is provided
     let resolvedToken = token;
-    if (vaultKey) {
+    if (credentialDomain) {
         try {
-            const client = (0, bitwarden_client_1.getBitwardenClient)();
-            if (!client.isConnected()) {
-                return (0, api_error_1.handleApiError)(new Error("Vault is locked — connect the vault first"), serviceLabel, connectionName);
-            }
-            resolvedToken = await client.getRawSecret(vaultKey, vaultField ?? "apiKey");
+            const store = (0, credential_access_1.getCredentialStore)();
+            resolvedToken = await store.getRawSecret(credentialDomain, credentialField ?? "password");
             (0, runtime_1.emitNervesEvent)({
-                event: "client.vault_fetch",
+                event: "client.credential_fetch",
                 component: "clients",
-                message: `fetched credential from vault for ${serviceLabel}`,
-                meta: { client: clientName, vaultKey },
+                message: `fetched credential from store for ${serviceLabel}`,
+                meta: { client: clientName, credentialDomain },
             });
         }
         catch (err) {
             (0, runtime_1.emitNervesEvent)({
                 level: "error",
-                event: "client.vault_error",
+                event: "client.credential_error",
                 component: "clients",
-                message: `failed to fetch vault credential for ${serviceLabel}`,
+                message: `failed to fetch credential for ${serviceLabel}`,
                 /* v8 ignore next -- defensive: getRawSecret throws Error instances @preserve */
-                meta: { client: clientName, vaultKey, reason: err instanceof Error ? err.message : String(err) },
+                meta: { client: clientName, credentialDomain, reason: err instanceof Error ? err.message : String(err) },
             });
             return (0, api_error_1.handleApiError)(err, serviceLabel, connectionName);
         }

package/dist/repertoire/credential-access.js

@@ -0,0 +1,449 @@
+"use strict";
+/**
+ * Credential access layer — store-agnostic credential management.
+ *
+ * Two backends, one interface:
+ *   - BuiltInCredentialStore: AES-256-GCM encrypted files, zero npm deps
+ *   - AacCredentialStore: delegates to the `aac` CLI (Bitwarden Agent Access)
+ *
+ * Raw secrets are NEVER returned to callers except via getRawSecret(),
+ * which is reserved for internal use by the credential gateway (apiRequest).
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AacCredentialStore = exports.BuiltInCredentialStore = void 0;
+exports.domainToSlug = domainToSlug;
+exports.getCredentialStore = getCredentialStore;
+exports.resetCredentialStore = resetCredentialStore;
+const crypto = __importStar(require("node:crypto"));
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+const node_child_process_1 = require("node:child_process");
+const runtime_1 = require("../nerves/runtime");
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Convert a domain string to a filesystem-safe slug. */
+function domainToSlug(domain) {
+    return domain
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+class BuiltInCredentialStore {
+    vaultDir;
+    keyPath;
+    masterKey = null;
+    constructor(agentName, vaultDir, keyDir) {
+        const homeBase = process.env.WEBSITE_SITE_NAME ? "/home" : os.homedir();
+        this.vaultDir = vaultDir ?? path.join(homeBase, "AgentBundles", `${agentName}.ouro`, "vault");
+        const effectiveKeyDir = keyDir ?? path.join(homeBase, ".agentsecrets", agentName);
+        this.keyPath = path.join(effectiveKeyDir, "vault.key");
+    }
+    isReady() {
+        return true;
+    }
+    async get(domain) {
+        (0, runtime_1.emitNervesEvent)({
+            event: "repertoire.credential_get_start",
+            component: "repertoire",
+            message: `getting credential for ${domain}`,
+            meta: { domain },
+        });
+        const stored = this.readEncrypted(domain);
+        if (!stored) {
+            (0, runtime_1.emitNervesEvent)({
+                event: "repertoire.credential_get_end",
+                component: "repertoire",
+                message: `no credential found for ${domain}`,
+                meta: { domain, found: false },
+            });
+            return null;
+        }
+        (0, runtime_1.emitNervesEvent)({
+            event: "repertoire.credential_get_end",
+            component: "repertoire",
+            message: `credential found for ${domain}`,
+            meta: { domain, found: true },
+        });
+        return {
+            domain: stored.domain,
+            username: stored.username,
+            notes: stored.notes,
+            createdAt: stored.createdAt,
+        };
+    }
+    async getRawSecret(domain, field) {
+        const stored = this.readEncrypted(domain);
+        if (!stored) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "repertoire.credential_get_error",
+                component: "repertoire",
+                message: `no credential found for domain "${domain}"`,
+                meta: { domain, field, reason: `no credential found for domain "${domain}"` },
+            });
+            throw new Error(`no credential found for domain "${domain}"`);
+        }
+        const value = stored[field];
+        if (value === undefined || value === null) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "repertoire.credential_get_error",
+                component: "repertoire",
+                message: `field "${field}" not found for domain "${domain}"`,
+                meta: { domain, field, reason: `field "${field}" not found for domain "${domain}"` },
+            });
+            throw new Error(`field "${field}" not found for domain "${domain}"`);
+        }
+        return String(value);
+    }
+    async store(domain, data) {
+        (0, runtime_1.emitNervesEvent)({
+            event: "repertoire.credential_store_start",
+            component: "repertoire",
+            message: `storing credential for ${domain}`,
+            meta: { domain },
+        });
+        this.ensureDirs();
+        const key = this.getOrCreateKey();
+        const credential = {
+            domain,
+            username: data.username,
+            password: data.password,
+            notes: data.notes,
+            createdAt: new Date().toISOString(),
+        };
+        const plaintext = JSON.stringify(credential);
+        const iv = crypto.randomBytes(12);
+        const cipher = crypto.createCipheriv("aes-256-gcm", key, iv);
+        const encrypted = Buffer.concat([cipher.update(plaintext, "utf-8"), cipher.final()]);
+        const tag = cipher.getAuthTag();
+        const payload = {
+            iv: iv.toString("hex"),
+            tag: tag.toString("hex"),
+            data: encrypted.toString("hex"),
+        };
+        const slug = domainToSlug(domain);
+        const encPath = path.join(this.vaultDir, `${slug}.enc`);
+        fs.writeFileSync(encPath, JSON.stringify(payload), "utf-8");
+        (0, runtime_1.emitNervesEvent)({
+            event: "repertoire.credential_store_end",
+            component: "repertoire",
+            message: `credential stored for ${domain}`,
+            meta: { domain },
+        });
+    }
+    async list() {
+        (0, runtime_1.emitNervesEvent)({
+            event: "repertoire.credential_list_start",
+            component: "repertoire",
+            message: "listing credentials",
+            meta: {},
+        });
+        if (!fs.existsSync(this.vaultDir)) {
+            (0, runtime_1.emitNervesEvent)({
+                event: "repertoire.credential_list_end",
+                component: "repertoire",
+                message: "credential list complete (no vault dir)",
+                meta: { count: 0 },
+            });
+            return [];
+        }
+        const files = fs.readdirSync(this.vaultDir).filter((f) => f.endsWith(".enc"));
+        const results = [];
+        for (const file of files) {
+            const slug = file.replace(/\.enc$/, "");
+            let stored = null;
+            try {
+                stored = this.readEncryptedBySlug(slug);
+            }
+            catch {
+                // Skip corrupt/unreadable files
+            }
+            if (stored) {
+                results.push({
+                    domain: stored.domain,
+                    username: stored.username,
+                    notes: stored.notes,
+                    createdAt: stored.createdAt,
+                });
+            }
+        }
+        (0, runtime_1.emitNervesEvent)({
+            event: "repertoire.credential_list_end",
+            component: "repertoire",
+            message: "credential list complete",
+            meta: { count: results.length },
+        });
+        return results;
+    }
+    async delete(domain) {
+        (0, runtime_1.emitNervesEvent)({
+            event: "repertoire.credential_delete_start",
+            component: "repertoire",
+            message: `deleting credential for ${domain}`,
+            meta: { domain },
+        });
+        const slug = domainToSlug(domain);
+        const encPath = path.join(this.vaultDir, `${slug}.enc`);
+        if (!fs.existsSync(encPath)) {
+            (0, runtime_1.emitNervesEvent)({
+                event: "repertoire.credential_delete_end",
+                component: "repertoire",
+                message: `no credential to delete for ${domain}`,
+                meta: { domain, deleted: false },
+            });
+            return false;
+        }
+        fs.unlinkSync(encPath);
+        (0, runtime_1.emitNervesEvent)({
+            event: "repertoire.credential_delete_end",
+            component: "repertoire",
+            message: `credential deleted for ${domain}`,
+            meta: { domain, deleted: true },
+        });
+        return true;
+    }
+    // --- Private ---
+    ensureDirs() {
+        if (!fs.existsSync(this.vaultDir)) {
+            fs.mkdirSync(this.vaultDir, { recursive: true });
+        }
+        const keyDir = path.dirname(this.keyPath);
+        if (!fs.existsSync(keyDir)) {
+            fs.mkdirSync(keyDir, { recursive: true, mode: 0o700 });
+        }
+    }
+    getOrCreateKey() {
+        if (this.masterKey)
+            return this.masterKey;
+        if (fs.existsSync(this.keyPath)) {
+            this.masterKey = fs.readFileSync(this.keyPath);
+            return this.masterKey;
+        }
+        // Generate new 256-bit key
+        const key = crypto.randomBytes(32);
+        fs.writeFileSync(this.keyPath, key, { mode: 0o600 });
+        this.masterKey = key;
+        return key;
+    }
+    readEncrypted(domain) {
+        return this.readEncryptedBySlug(domainToSlug(domain));
+    }
+    readEncryptedBySlug(slug) {
+        const encPath = path.join(this.vaultDir, `${slug}.enc`);
+        if (!fs.existsSync(encPath))
+            return null;
+        const key = this.getOrCreateKey();
+        const raw = fs.readFileSync(encPath, "utf-8");
+        const payload = JSON.parse(raw);
+        const iv = Buffer.from(payload.iv, "hex");
+        const tag = Buffer.from(payload.tag, "hex");
+        const encrypted = Buffer.from(payload.data, "hex");
+        const decipher = crypto.createDecipheriv("aes-256-gcm", key, iv);
+        decipher.setAuthTag(tag);
+        const decrypted = Buffer.concat([decipher.update(encrypted), decipher.final()]);
+        return JSON.parse(decrypted.toString("utf-8"));
+    }
+}
+exports.BuiltInCredentialStore = BuiltInCredentialStore;
+// ---------------------------------------------------------------------------
+// AacCredentialStore — delegates to `aac` CLI
+// ---------------------------------------------------------------------------
+function execAac(args) {
+    return new Promise((resolve, reject) => {
+        (0, node_child_process_1.execFile)("aac", args, { timeout: 10_000 }, (err, stdout) => {
+            if (err) {
+                reject(new Error(`aac CLI error: ${err.message}`));
+                return;
+            }
+            resolve(stdout);
+        });
+    });
+}
+class AacCredentialStore {
+    aacAvailable = null;
+    isReady() {
+        // Synchronous check — returns last-known state or false if unchecked
+        return this.aacAvailable === true;
+    }
+    async checkReady() {
+        try {
+            const stdout = await execAac(["connections", "list"]);
+            const parsed = JSON.parse(stdout);
+            this.aacAvailable = Array.isArray(parsed) && parsed.length > 0;
+        }
+        catch {
+            this.aacAvailable = false;
+        }
+        return this.aacAvailable;
+    }
+    async get(domain) {
+        (0, runtime_1.emitNervesEvent)({
+            event: "repertoire.credential_get_start",
+            component: "repertoire",
+            message: `getting credential via aac for ${domain}`,
+            meta: { domain, backend: "aac" },
+        });
+        try {
+            const stdout = await execAac(["--domain", domain, "--output", "json"]);
+            const parsed = JSON.parse(stdout);
+            if (!parsed.success) {
+                (0, runtime_1.emitNervesEvent)({
+                    event: "repertoire.credential_get_end",
+                    component: "repertoire",
+                    message: `no aac credential for ${domain}`,
+                    meta: { domain, found: false, backend: "aac" },
+                });
+                return null;
+            }
+            const cred = parsed.credential;
+            (0, runtime_1.emitNervesEvent)({
+                event: "repertoire.credential_get_end",
+                component: "repertoire",
+                message: `aac credential found for ${domain}`,
+                meta: { domain, found: true, backend: "aac" },
+            });
+            return {
+                domain,
+                username: cred.username,
+                notes: cred.notes,
+                createdAt: cred.createdAt ?? new Date().toISOString(),
+            };
+        }
+        catch {
+            (0, runtime_1.emitNervesEvent)({
+                event: "repertoire.credential_get_end",
+                component: "repertoire",
+                message: `aac credential lookup failed for ${domain}`,
+                meta: { domain, found: false, backend: "aac" },
+            });
+            return null;
+        }
+    }
+    async getRawSecret(domain, field) {
+        const stdout = await execAac(["--domain", domain, "--output", "json"]);
+        const parsed = JSON.parse(stdout);
+        if (!parsed.success) {
+            throw new Error(`aac lookup failed for domain "${domain}": ${parsed.error ?? "unknown error"}`);
+        }
+        const value = parsed.credential[field];
+        if (value === undefined || value === null) {
+            throw new Error(`field "${field}" not found for domain "${domain}"`);
+        }
+        return String(value);
+    }
+    async store(_domain, _data) {
+        throw new Error("store() is not supported in aac mode — aac is read-from-vault only. " +
+            "Use BuiltInCredentialStore for agent-owned credentials, or manage vault items " +
+            "directly in Bitwarden.");
+    }
+    async list() {
+        (0, runtime_1.emitNervesEvent)({
+            event: "repertoire.credential_list_start",
+            component: "repertoire",
+            message: "listing aac connections",
+            meta: { backend: "aac" },
+        });
+        try {
+            const stdout = await execAac(["connections", "list"]);
+            const parsed = JSON.parse(stdout);
+            const results = (Array.isArray(parsed) ? parsed : []).map((item) => ({
+                domain: String(item.domain ?? ""),
+                username: item.username ? String(item.username) : undefined,
+                notes: item.notes ? String(item.notes) : undefined,
+                createdAt: item.createdAt ? String(item.createdAt) : new Date().toISOString(),
+            }));
+            (0, runtime_1.emitNervesEvent)({
+                event: "repertoire.credential_list_end",
+                component: "repertoire",
+                message: "aac connections listed",
+                meta: { backend: "aac", count: results.length },
+            });
+            return results;
+        }
+        catch {
+            (0, runtime_1.emitNervesEvent)({
+                event: "repertoire.credential_list_end",
+                component: "repertoire",
+                message: "aac connections list failed",
+                meta: { backend: "aac", count: 0 },
+            });
+            return [];
+        }
+    }
+    async delete(_domain) {
+        throw new Error("delete() is not supported in aac mode — manage vault items directly in Bitwarden.");
+    }
+}
+exports.AacCredentialStore = AacCredentialStore;
+// ---------------------------------------------------------------------------
+// Singleton + auto-detection
+// ---------------------------------------------------------------------------
+let _store = null;
+/**
+ * Get the credential store singleton.
+ * Tries aac first (if binary exists and has sessions); falls back to BuiltInCredentialStore.
+ */
+function getCredentialStore() {
+    if (_store)
+        return _store;
+    // Default to BuiltInCredentialStore — aac detection is async and
+    // would need to be done at startup. For now, always use built-in.
+    // Callers can explicitly create AacCredentialStore if needed.
+    let agentName;
+    try {
+        // Dynamic import to avoid circular dependency at module level
+        const identity = require("../heart/identity");
+        agentName = identity.getAgentName();
+    }
+    catch {
+        agentName = "default";
+    }
+    _store = new BuiltInCredentialStore(agentName);
+    (0, runtime_1.emitNervesEvent)({
+        event: "repertoire.credential_store_init",
+        component: "repertoire",
+        message: "credential store initialized",
+        meta: { backend: "built-in", agentName },
+    });
+    return _store;
+}
+/** Reset the singleton — for tests only. */
+function resetCredentialStore() {
+    _store = null;
+}

package/dist/repertoire/guardrails.js

@@ -282,21 +282,21 @@ function checkWriteTrustGuardrails(toolName, args, context) {
         return allow;
     return deny(REASONS.needsTrustForWrite);
 }
-// --- vault tool trust gating ---
-// Vault write tools: family only
-const VAULT_FAMILY_TOOLS = new Set(["vault_store", "vault_delete"]);
-// Vault read tools: friend+
-const VAULT_TRUSTED_TOOLS = new Set(["vault_get", "vault_list"]);
+// --- credential tool trust gating ---
+// Credential write tools: family only
+const CREDENTIAL_FAMILY_TOOLS = new Set(["credential_store", "credential_delete"]);
+// Credential read tools: friend+
+const CREDENTIAL_TRUSTED_TOOLS = new Set(["credential_get", "credential_list"]);
 // Travel tools: friend+ (weather_lookup accesses vault credentials indirectly;
 // advisory and geocode are public APIs but gated for consistency)
 const TRAVEL_TRUSTED_TOOLS = new Set(["weather_lookup", "travel_advisory", "geocode_search"]);
-function checkVaultTrustGuardrails(toolName, context) {
-    if (VAULT_FAMILY_TOOLS.has(toolName)) {
+function checkCredentialTrustGuardrails(toolName, context) {
+    if (CREDENTIAL_FAMILY_TOOLS.has(toolName)) {
         if (context.trustLevel === "family")
             return allow;
         return deny(REASONS.needsTrust);
     }
-    if (VAULT_TRUSTED_TOOLS.has(toolName) || TRAVEL_TRUSTED_TOOLS.has(toolName)) {
+    if (CREDENTIAL_TRUSTED_TOOLS.has(toolName) || TRAVEL_TRUSTED_TOOLS.has(toolName)) {
         if ((0, types_1.isTrustedLevel)(context.trustLevel))
             return allow;
         return deny(REASONS.needsTrust);
@@ -304,10 +304,10 @@ function checkVaultTrustGuardrails(toolName, context) {
     return allow;
 }
 function checkTrustLevelGuardrails(toolName, args, context) {
-    // Vault tools have their own trust rules that apply at all levels
-    const vaultResult = checkVaultTrustGuardrails(toolName, context);
-    if (!vaultResult.allowed)
-        return vaultResult;
+    // Credential tools have their own trust rules that apply at all levels
+    const credentialResult = checkCredentialTrustGuardrails(toolName, context);
+    if (!credentialResult.allowed)
+        return credentialResult;
     // MCP server-specific trust (e.g. browser blocked in group chats) — applies at all trust levels
     if (toolName === "shell") {
         const mcpResult = checkMcpServerTrust(args.command || "", context);

package/dist/repertoire/tools-base.js

@@ -9,7 +9,7 @@ const tools_session_1 = require("./tools-session");
 const tools_continuity_1 = require("./tools-continuity");
 const tools_config_1 = require("./tools-config");
 const tools_1 = require("./coding/tools");
-const tools_vault_1 = require("./tools-vault");
+const tools_credential_1 = require("./tools-credential");
 const tools_travel_1 = require("./tools-travel");
 // Re-export flow tools for consumers that import them from tools-base
 var tools_flow_1 = require("./tools-flow");
@@ -34,7 +34,7 @@ exports.baseToolDefinitions = [
     ...tools_continuity_1.continuityToolDefinitions,
     ...tools_config_1.configToolDefinitions,
     ...tools_1.codingToolDefinitions,
-    ...tools_vault_1.vaultToolDefinitions,
+    ...tools_credential_1.credentialToolDefinitions,
     ...tools_travel_1.travelToolDefinitions,
 ];
 // Convenience array of just the tool schemas (no handler/integration metadata).