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

package/dist/repertoire/tools-credential.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.credentialToolDefinitions = void 0;
+const credential_access_1 = require("./credential-access");
+const runtime_1 = require("../nerves/runtime");
+exports.credentialToolDefinitions = [
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "credential_get",
+                description: "Get credential metadata for a domain. Returns username, notes, and creation date. Never returns passwords — the credential gateway handles secret injection internally.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        domain: {
+                            type: "string",
+                            description: "Domain to look up (e.g. 'airbnb.com', 'api.openweathermap.org')",
+                        },
+                    },
+                    required: ["domain"],
+                },
+            },
+        },
+        handler: async (args) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.credential_tool_call",
+                message: "credential_get invoked",
+                meta: { tool: "credential_get", domain: args.domain },
+            });
+            try {
+                const store = (0, credential_access_1.getCredentialStore)();
+                const meta = await store.get(args.domain);
+                if (!meta) {
+                    return `No credential found for "${args.domain}".`;
+                }
+                return JSON.stringify(meta, null, 2);
+            }
+            catch (err) {
+                /* v8 ignore next -- defensive: store.get wraps errors @preserve */
+                return `Credential error: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+        summaryKeys: ["domain"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "credential_store",
+                description: "Store credentials the agent acquired (e.g. during sign-up). The password is accepted in args because the model generated it. Stored passwords are never returned later — only metadata is visible.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        domain: {
+                            type: "string",
+                            description: "Domain these credentials are for (e.g. 'airbnb.com')",
+                        },
+                        username: {
+                            type: "string",
+                            description: "Username or email for the account",
+                        },
+                        password: {
+                            type: "string",
+                            description: "Password for the account",
+                        },
+                        notes: {
+                            type: "string",
+                            description: "Optional notes about this credential",
+                        },
+                    },
+                    required: ["domain", "username", "password"],
+                },
+            },
+        },
+        handler: async (args) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.credential_tool_call",
+                message: "credential_store invoked",
+                meta: { tool: "credential_store", domain: args.domain },
+            });
+            try {
+                const store = (0, credential_access_1.getCredentialStore)();
+                await store.store(args.domain, {
+                    username: args.username,
+                    password: args.password,
+                    notes: args.notes,
+                });
+                return `Credentials stored for "${args.domain}".`;
+            }
+            catch (err) {
+                /* v8 ignore next -- defensive: store.store wraps errors @preserve */
+                return `Credential store error: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+        confirmationRequired: true,
+        summaryKeys: ["domain"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "credential_list",
+                description: "List stored credential domains. Returns metadata only (domain, username, notes, creation date). Never returns passwords.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        search: {
+                            type: "string",
+                            description: "Optional search filter to match against domain names",
+                        },
+                    },
+                },
+            },
+        },
+        handler: async (args) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.credential_tool_call",
+                message: "credential_list invoked",
+                meta: { tool: "credential_list" },
+            });
+            try {
+                const store = (0, credential_access_1.getCredentialStore)();
+                let items = await store.list();
+                // Client-side search filter
+                if (args.search) {
+                    const term = args.search.toLowerCase();
+                    items = items.filter((item) => item.domain.toLowerCase().includes(term) ||
+                        (item.username && item.username.toLowerCase().includes(term)));
+                }
+                return JSON.stringify(items, null, 2);
+            }
+            catch (err) {
+                /* v8 ignore next -- defensive: store.list wraps errors @preserve */
+                return `Credential list error: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+        summaryKeys: ["search"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "credential_delete",
+                description: "Delete stored credentials for a domain.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        domain: {
+                            type: "string",
+                            description: "Domain whose credentials should be deleted",
+                        },
+                    },
+                    required: ["domain"],
+                },
+            },
+        },
+        handler: async (args) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.credential_tool_call",
+                message: "credential_delete invoked",
+                meta: { tool: "credential_delete", domain: args.domain },
+            });
+            try {
+                const store = (0, credential_access_1.getCredentialStore)();
+                const deleted = await store.delete(args.domain);
+                if (deleted) {
+                    return `Credentials for "${args.domain}" deleted.`;
+                }
+                return `No credential found for "${args.domain}".`;
+            }
+            catch (err) {
+                /* v8 ignore next -- defensive: store.delete wraps errors @preserve */
+                return `Credential delete error: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+        confirmationRequired: true,
+        summaryKeys: ["domain"],
+    },
+];

package/dist/repertoire/travel-api-client.js

@@ -9,7 +9,6 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TRAVEL_ADVISORY_RSS_URL = void 0;
-exports.setWeatherVaultConfig = setWeatherVaultConfig;
 exports.getWeather = getWeather;
 exports.getWeatherByCity = getWeatherByCity;
 exports.parseAdvisoryLevel = parseAdvisoryLevel;
@@ -20,22 +19,13 @@ exports.geocode = geocode;
 exports.reverseGeocode = reverseGeocode;
 exports.searchPOI = searchPOI;
 const runtime_1 = require("../nerves/runtime");
-const bitwarden_client_1 = require("./bitwarden-client");
+const credential_access_1 = require("./credential-access");
 // --- OpenWeatherMap ---
-/**
- * Vault item ID and field name for OpenWeatherMap API key.
- * Override via setWeatherVaultConfig() for custom vault layouts.
- */
-let weatherVaultItemId = "openweathermap-api";
-let weatherVaultField = "apiKey";
-function setWeatherVaultConfig(itemId, field) {
-    weatherVaultItemId = itemId;
-    if (field)
-        weatherVaultField = field;
-}
+/** Domain used for weather API key credential retrieval. */
+const WEATHER_CREDENTIAL_DOMAIN = "api.openweathermap.org";
 async function getWeatherApiKey() {
-    const client = (0, bitwarden_client_1.getBitwardenClient)();
-    return client.getRawSecret(weatherVaultItemId, weatherVaultField);
+    const store = (0, credential_access_1.getCredentialStore)();
+    return store.getRawSecret(WEATHER_CREDENTIAL_DOMAIN, "password");
 }
 async function getWeather(lat, lon) {
     return withNervesEvents("getWeather", { lat, lon }, async () => {

package/dist/senses/bluebubbles/index.js

@@ -1067,44 +1067,37 @@ async function sendProactiveBlueBubblesMessageToSession(params, deps = {}) {
     catch {
         friend = null;
     }
-    // Fallback: if friendId is a name (not UUID), resolve via listAll
-    /* v8 ignore start -- name resolution fallback + diagnostics @preserve */
-    if (!friend && store.listAll) {
+    // Direct filesystem fallback — store.get() with name resolution wasn't working in production
+    // despite correct compiled code. Bypass the entire store abstraction.
+    /* v8 ignore start -- direct filesystem name resolution @preserve */
+    if (!friend) {
         try {
-            const all = await store.listAll();
-            (0, runtime_1.emitNervesEvent)({
-                component: "senses",
-                event: "senses.bluebubbles_proactive_name_resolve",
-                message: "attempting name-based friend resolution",
-                meta: {
-                    friendId: params.friendId,
-                    storeHasListAll: true,
-                    friendCount: all.length,
-                    friendNames: all.map((f) => f.name ?? "<no name>"),
-                },
-            });
-            friend = all.find((f) => f.name?.toLowerCase() === params.friendId.toLowerCase()) ?? null;
+            const friendsDir = path.join((0, identity_1.getAgentRoot)(), "friends");
+            const files = fs.readdirSync(friendsDir).filter((f) => f.endsWith(".json"));
+            for (const file of files) {
+                const raw = JSON.parse(fs.readFileSync(path.join(friendsDir, file), "utf-8"));
+                if (raw.name?.toLowerCase() === params.friendId.toLowerCase()) {
+                    friend = raw;
+                    (0, runtime_1.emitNervesEvent)({
+                        component: "senses",
+                        event: "senses.bluebubbles_proactive_name_resolved",
+                        message: "resolved friend by name via direct filesystem scan",
+                        meta: { friendId: params.friendId, resolvedId: raw.id, name: raw.name },
+                    });
+                    break;
+                }
+            }
         }
         catch (err) {
             (0, runtime_1.emitNervesEvent)({
                 level: "warn",
                 component: "senses",
                 event: "senses.bluebubbles_proactive_name_resolve_error",
-                message: "name resolution fallback failed",
+                message: "direct filesystem name resolution failed",
                 meta: { friendId: params.friendId, error: err instanceof Error ? err.message : String(err) },
             });
-            friend = null;
         }
     }
-    else if (!friend) {
-        (0, runtime_1.emitNervesEvent)({
-            level: "warn",
-            component: "senses",
-            event: "senses.bluebubbles_proactive_name_resolve_skip",
-            message: "name resolution skipped: store.listAll not available",
-            meta: { friendId: params.friendId, hasListAll: typeof store.listAll },
-        });
-    }
     /* v8 ignore stop */
     if (!friend) {
         (0, runtime_1.emitNervesEvent)({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.226",
+  "version": "0.1.0-alpha.228",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",

package/skills/browser-navigation.md

@@ -44,7 +44,7 @@ Follow this pattern for every page interaction:
 3. Use `browser_type` for username/password fields
 4. Use `browser_click` to submit
 5. Wait for redirect, then verify login succeeded via snapshot
-6. NEVER hardcode credentials -- use `vault_get` to retrieve login info
+6. NEVER hardcode credentials -- use `credential_get` to retrieve login info
 
 ### Search Forms (Hotels, Flights, Rentals)
 1. Navigate to the search page
@@ -58,7 +58,7 @@ Follow this pattern for every page interaction:
 ### Booking Forms
 1. **ALWAYS confirm with the user before proceeding to payment**
 2. Fill traveler information
-3. Use vault credentials for payment (via `vault_get` -- NEVER type raw card numbers)
+3. Use stored credentials for payment (via `credential_get` -- NEVER type raw card numbers)
 4. Screenshot the final review page for user confirmation
 5. Only click "Book" / "Confirm" after explicit user approval
 
@@ -98,7 +98,7 @@ The stealth configuration handles most fingerprinting automatically. Additionall
 - **CAPTCHAs**: Stop and ask the user to solve manually.
 - **Stale elements**: Re-snapshot the page and retry the interaction.
 - **Blocked/403**: The site may have detected automation. Wait 30 seconds and try with a different approach (e.g., direct URL instead of navigation).
-- **Session expired**: Re-login using stored vault credentials.
+- **Session expired**: Re-login using stored stored credentials.
 
 ## Human Confirmation Gates
 

package/skills/travel-planning.md

@@ -71,10 +71,25 @@ Present top 3-5 options comparing:
 - **Never proceed with a financial commitment without explicit approval**
 
 ### Credential Handling
-- Use `vault_get` to retrieve payment credentials (never expose raw values)
-- Use `vault_get` for loyalty program numbers
-- Use browser-navigation skill form patterns for entering credentials
-- The credential gateway ensures secrets never enter model context
+
+Credentials are managed through the credential access layer, which stores
+agent-owned secrets encrypted in the bundle vault. Raw passwords never
+enter model context.
+
+- Use `credential_get` to check what credentials exist for a domain (metadata only, never passwords)
+- Use `credential_store` to save credentials the agent acquired (e.g., during sign-up for a service)
+- The credential gateway automatically injects secrets into API requests via `getRawSecret()`
+- Use browser-navigation skill form patterns for entering credentials during interactive sessions
+
+**How credentials work:**
+- Agent-owned credentials are AES-256-GCM encrypted in `~/AgentBundles/<agent>.ouro/vault/`
+- The master key lives at `~/.agentsecrets/<agent>/vault.key` (auto-generated on first use)
+- The agent can sign up for services and store its own credentials
+- Stored passwords are never returned to the model — only metadata (domain, username, notes)
+
+**Upgrade path:** Install `aac` (Bitwarden Agent Access CLI) for vault-backed credentials.
+When `aac` is available, the harness can read credentials from Bitwarden directly,
+enabling access to human-managed vault items without storing them locally.
 
 ### Post-Booking
 - Save confirmation details (confirmation number, dates, hotel name, airline, booking reference)
@@ -105,35 +120,15 @@ Track and reference these travel preferences:
 - `weather_lookup` - Current weather by city or coordinates
 - `travel_advisory` - US State Dept advisory by country code
 - `geocode_search` - Location/POI search with coordinates
-- `vault_get` - Retrieve credentials (payment, loyalty)
-- `vault_store` - Store new credentials (family trust required)
+- `credential_get` - Check credential metadata for a domain (never returns passwords)
+- `credential_store` - Store credentials the agent acquired (family trust, confirmation required)
+- `credential_list` - List stored credential domains
+- `credential_delete` - Delete stored credentials (family trust, confirmation required)
 
 ### MCP Tools (when configured)
 - Browser tools via `@playwright/mcp` - see `browser-navigation` skill
 - Duffel flight search (when MCP server available)
 - Expedia hotel search (when MCP server available)
-- Bitwarden vault management via `@bitwarden/mcp-server` (agent-facing interactive vault access)
-
-### Bitwarden MCP Server
-
-For agent-facing vault interaction (browsing items, searching, reading fields), configure
-`@bitwarden/mcp-server` as an MCP server in agent.json:
-
-```json
-{
-  "mcpServers": {
-    "bitwarden": {
-      "command": "npx",
-      "args": ["@bitwarden/mcp-server"]
-    }
-  }
-}
-```
-
-This is distinct from the built-in `bw` CLI-based credential gateway, which handles
-harness-internal secret injection (e.g., API keys injected into tool requests via
-`getRawSecret()`). The MCP server is for the agent to interactively browse and manage
-vault items on behalf of the user.
 
 ### Human Confirmation Required For
 - Any booking or payment