@ouro.bot/cli 0.1.0-alpha.237 → 0.1.0-alpha.238

package/dist/repertoire/tools-user-profile.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.userProfileToolDefinitions = void 0;
+const user_profile_1 = require("./user-profile");
+const credential_access_1 = require("./credential-access");
+const runtime_1 = require("../nerves/runtime");
+function requireFamilyContext(ctx) {
+    if (!ctx?.context?.friend?.id) {
+        return "no friend context — cannot access user profile.";
+    }
+    if (ctx.context.friend.trustLevel !== "family") {
+        return "user profile access requires family trust level.";
+    }
+    return { friendId: ctx.context.friend.id };
+}
+exports.userProfileToolDefinitions = [
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "user_profile_store",
+                description: "Store or update user profile fields (legal name, DOB, passport, etc.) in the agent's vault. Fields are merged with any existing profile. Requires family trust level.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        fields: {
+                            type: "string",
+                            description: 'JSON object with profile fields to store/update. Keys: legalName, dateOfBirth, gender, nationality, passport, driverLicense, email, phone, addresses, loyaltyPrograms, preferences, emergencyContact.',
+                        },
+                    },
+                    required: ["fields"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.tool_user_profile_store",
+                message: "user_profile_store invoked",
+                meta: { tool: "user_profile_store" },
+            });
+            const guard = requireFamilyContext(ctx);
+            if (typeof guard === "string")
+                return guard;
+            let fields;
+            try {
+                fields = JSON.parse(args.fields);
+            }
+            catch {
+                return "invalid JSON in fields parameter.";
+            }
+            try {
+                const store = (0, credential_access_1.getCredentialStore)();
+                await (0, user_profile_1.updateUserProfileFields)(guard.friendId, fields, store);
+                return `profile fields stored for ${guard.friendId}.`;
+            }
+            catch (err) {
+                /* v8 ignore next -- defensive: updateUserProfileFields errors are always Error instances @preserve */
+                return `failed to store profile: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+        summaryKeys: ["fields"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "user_profile_get",
+                description: "Retrieve a specific field from a user's profile. Only returns the requested field, never the full profile. Requires family trust level.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        field: {
+                            type: "string",
+                            description: "The profile field to retrieve: legalName, dateOfBirth, gender, nationality, passport, driverLicense, email, phone, addresses, loyaltyPrograms, preferences, emergencyContact.",
+                        },
+                    },
+                    required: ["field"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.tool_user_profile_get",
+                message: "user_profile_get invoked",
+                meta: { tool: "user_profile_get", field: args.field },
+            });
+            const guard = requireFamilyContext(ctx);
+            if (typeof guard === "string")
+                return guard;
+            try {
+                const store = (0, credential_access_1.getCredentialStore)();
+                const value = await (0, user_profile_1.getUserProfileField)(guard.friendId, args.field, store);
+                if (value === undefined) {
+                    return `field "${args.field}" is not set on the profile.`;
+                }
+                /* v8 ignore next -- platform-dependent v8 branch counting on ternary @preserve */
+                return typeof value === "string" ? value : JSON.stringify(value, null, 2);
+            }
+            catch (err) {
+                /* v8 ignore next -- defensive: getUserProfileField errors are always Error instances @preserve */
+                return `failed to get profile field: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+        summaryKeys: ["field"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "user_profile_delete",
+                description: "Delete a user's entire profile from the vault. This is irreversible. Requires family trust level.",
+                parameters: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+        },
+        handler: async (_args, ctx) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.tool_user_profile_delete",
+                message: "user_profile_delete invoked",
+                meta: { tool: "user_profile_delete" },
+            });
+            const guard = requireFamilyContext(ctx);
+            if (typeof guard === "string")
+                return guard;
+            try {
+                const store = (0, credential_access_1.getCredentialStore)();
+                const deleted = await (0, user_profile_1.deleteUserProfile)(guard.friendId, store);
+                return deleted
+                    ? `profile deleted for ${guard.friendId}.`
+                    : `no profile found for ${guard.friendId}.`;
+            }
+            catch (err) {
+                /* v8 ignore next -- defensive: deleteUserProfile errors are always Error instances @preserve */
+                return `failed to delete profile: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+        summaryKeys: [],
+    },
+];

package/dist/repertoire/user-profile.js

@@ -0,0 +1,118 @@
+"use strict";
+/**
+ * User profile model and vault storage.
+ *
+ * Profiles are stored as secure notes in the agent's Vaultwarden vault,
+ * keyed by friend ID: `user-profile/{friendId}`.
+ *
+ * The storage layer uses the existing CredentialStore interface — the profile
+ * JSON is stored in the `password` field of a login item (the vault's most
+ * reliable field for arbitrary data). Field-level access ensures the full
+ * profile is never dumped to model context unnecessarily.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storeUserProfile = storeUserProfile;
+exports.getUserProfile = getUserProfile;
+exports.getUserProfileField = getUserProfileField;
+exports.deleteUserProfile = deleteUserProfile;
+exports.updateUserProfileFields = updateUserProfileFields;
+const runtime_1 = require("../nerves/runtime");
+// ---------------------------------------------------------------------------
+// Storage key
+// ---------------------------------------------------------------------------
+function profileKey(friendId) {
+    return `user-profile/${friendId}`;
+}
+// ---------------------------------------------------------------------------
+// CRUD operations
+// ---------------------------------------------------------------------------
+/**
+ * Store a complete user profile in the vault.
+ * Overwrites any existing profile for the given friend ID.
+ */
+async function storeUserProfile(friendId, profile, store) {
+    (0, runtime_1.emitNervesEvent)({
+        event: "repertoire.user_profile_store",
+        component: "repertoire",
+        message: `storing user profile for ${friendId}`,
+        meta: { friendId },
+    });
+    const key = profileKey(friendId);
+    /* v8 ignore start -- platform-dependent v8 branch counting on await @preserve */
+    await store.store(key, {
+        password: JSON.stringify(profile),
+        notes: "user-profile",
+    });
+    /* v8 ignore stop */
+}
+/**
+ * Retrieve the full user profile for a friend.
+ * Returns null if no profile exists or if the stored data is invalid.
+ */
+async function getUserProfile(friendId, store) {
+    (0, runtime_1.emitNervesEvent)({
+        event: "repertoire.user_profile_get",
+        component: "repertoire",
+        message: `getting user profile for ${friendId}`,
+        meta: { friendId },
+    });
+    try {
+        const raw = await store.getRawSecret(profileKey(friendId), "password");
+        const parsed = JSON.parse(raw);
+        return parsed;
+        /* v8 ignore next 2 -- platform-dependent v8 branch counting on catch @preserve */
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Retrieve a specific field from a user profile.
+ * Returns undefined if the profile doesn't exist or the field is not set.
+ */
+async function getUserProfileField(friendId, field, store) {
+    const profile = await getUserProfile(friendId, store);
+    if (!profile)
+        return undefined;
+    return profile[field];
+}
+/**
+ * Delete a user profile from the vault.
+ * Returns true if the profile was deleted, false if it didn't exist.
+ */
+async function deleteUserProfile(friendId, store) {
+    (0, runtime_1.emitNervesEvent)({
+        event: "repertoire.user_profile_delete",
+        component: "repertoire",
+        message: `deleting user profile for ${friendId}`,
+        meta: { friendId },
+    });
+    return store.delete(profileKey(friendId));
+}
+/**
+ * Update specific fields on a user profile, merging with existing data.
+ * Creates the profile if it doesn't exist.
+ * Preferences are merged (not replaced) at the key level.
+ */
+async function updateUserProfileFields(friendId, fields, store) {
+    (0, runtime_1.emitNervesEvent)({
+        event: "repertoire.user_profile_update",
+        component: "repertoire",
+        message: `updating user profile fields for ${friendId}`,
+        meta: { friendId, fieldCount: Object.keys(fields).length },
+    });
+    const existing = await getUserProfile(friendId, store);
+    let merged;
+    if (existing) {
+        // Merge preferences at key level
+        const mergedPreferences = {
+            ...existing.preferences,
+            ...(fields.preferences ?? {}),
+        };
+        merged = { ...existing, ...fields, preferences: mergedPreferences };
+    }
+    else {
+        merged = fields;
+    }
+    await storeUserProfile(friendId, merged, store);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.237",
+  "version": "0.1.0-alpha.238",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",
@@ -42,7 +42,8 @@
     "ink": "^3.2.0",
     "openai": "^6.27.0",
     "react": "^17.0.2",
-    "semver": "^7.7.4"
+    "semver": "^7.7.4",
+    "stripe": "^22.0.0"
   },
   "repository": {
     "type": "git",

package/skills/agent-commerce.md

@@ -0,0 +1,106 @@
+# Agent Commerce Skill
+
+How to book, purchase, and pay for things on behalf of humans.
+
+## Three Patterns
+
+### Pattern A: API (Structured, Preferred)
+
+For services with direct API access: Duffel flights, LiteAPI hotels.
+
+1. Search using the API tool (`flight_search`, LiteAPI MCP)
+2. Present options to the human with prices and details
+3. Human approves a specific option and price
+4. Book using the API tool with passenger data from `user_profile_get`
+5. Create a single-use virtual card via `stripe_create_card`
+6. Complete payment through the API
+7. Deactivate the card via `stripe_deactivate_card`
+8. Confirm booking to the human
+
+**Key tools**: `flight_search`, `flight_book`, `flight_cancel`, `user_profile_get`, `user_profile_store`, `stripe_create_card`, `stripe_deactivate_card`, `stripe_list_cards`
+
+### Pattern B: Browser (Best-Effort)
+
+For sites without API access, use browser automation via Playwright MCP.
+
+1. Navigate to the booking site
+2. Search for the requested service
+3. Fill forms using data from `user_profile_get`
+4. Use a virtual card from `stripe_create_card` for payment
+5. If blocked by anti-bot measures, fall back to Pattern C
+6. Complete and confirm the booking
+
+**Limitations**: Browser automation is fragile. Sites may block, layouts change, CAPTCHAs appear. Always have Pattern C as fallback.
+
+### Pattern C: Link-Only (Primary for Hostile Sites)
+
+For sites that block automation or require complex human interaction.
+
+1. Research the best options using browser tools or API tools
+2. Prepare a curated link with pre-filled parameters where possible
+3. Send the link to the human with a summary of what to book
+4. Human completes the booking in their own browser
+
+**When to use**: Always use Pattern C as the primary approach for sites known to block automation (most airline direct sites, hotel chains, rental car sites). Pattern B is best-effort, not reliable.
+
+## Payment autonomy Levels
+
+- **Level 0**: No autonomous payments. Agent researches, human pays manually.
+- **Level 1**: Agent creates virtual cards, human approves each transaction explicitly.
+- **Level 2**: Agent can book pre-approved items (within budget, approved categories) without per-transaction approval.
+- **Level 3**: Full delegation with spending limits. Agent manages a budget and books as needed.
+
+Default is Level 1. Level changes require explicit human approval.
+
+## Error Handling
+
+### Price Change Guard
+Before completing a booking, verify the final price matches the approved price within 5%. If the price changed more than 5%, stop and report to the human. Never pay a price the human didn't approve.
+
+### Partial Failure Reporting
+When booking involves multiple services (e.g., flight + hotel), each service may succeed or fail independently — this is a partial failure scenario. Report the status of each service separately. **Never auto-cancel a successful booking because a related booking failed.** Let the human decide.
+
+Example: "Flight SFO-JFK booked (confirmation: ABC123). Hotel booking failed: no availability for those dates. Would you like me to search for alternative hotels?"
+
+### Refund Flow
+If a booking fails after card creation:
+1. Deactivate the virtual card immediately
+2. Report the failure to the human
+3. If a charge was made, note it for the human to follow up with the provider
+
+## CAPTCHA Handling
+
+When a CAPTCHA appears during browser automation (Pattern B):
+1. Take a screenshot and send it to the human
+2. Explain what page you're on and what you were trying to do
+3. Ask the human to solve the CAPTCHA in their own browser
+4. Switch to Pattern C (link-only) for this transaction
+
+Never attempt to solve CAPTCHAs programmatically.
+
+## Card Number Isolation
+
+Card numbers must NEVER appear in:
+- Tool return values shown to the model
+- Nerves events or logs
+- Chat messages to the human
+- Any stored state or memory
+
+The only place card numbers exist is inside the Stripe client's internal payment flow functions, scoped to a single function call. The model only ever sees card IDs and last-4 digits.
+
+## Profile Data Usage
+
+Access profile data only when needed for the current transaction:
+- `user_profile_get` to retrieve specific fields (never dump full profile)
+- Passport data only for international bookings
+- Loyalty program numbers only when booking with that program
+- Emergency contact only when the booking service requires it
+
+## Self-Test
+
+Before first use, run the commerce self-test to verify all services are configured:
+- Stripe: creates and deactivates a test virtual card
+- Duffel: runs a test flight search
+- LiteAPI: verifies API key in vault
+
+Report results to the human with actionable next steps for any failures.

package/skills/commerce-setup-guide.md

@@ -0,0 +1,116 @@
+# Commerce Setup Guide
+
+Human-facing guide for configuring the agent's commerce capabilities.
+
+## Architecture Overview
+
+The agent's commerce system has three pillars:
+
+1. **User Profile**: Secure storage of personal data (name, passport, payment preferences) in Vaultwarden, accessed only when needed for specific transactions.
+
+2. **Booking Delegation**: Direct API access to flight (Duffel) and hotel (LiteAPI) booking systems, plus browser automation fallback for sites without APIs.
+
+3. **Payment**: Stripe Issuing virtual cards created per-transaction, with spend limits and merchant category restrictions. Card numbers never enter the model's context.
+
+## Setup Steps
+
+### 1. Stripe Issuing (Required for Payments)
+
+- Create a Stripe account: https://dashboard.stripe.com
+- Enable Stripe Issuing (requires business verification)
+- Create a restricted API key: https://dashboard.stripe.com/apikeys
+  - Permissions needed: `issuing_cards:write`, `issuing_cards:read`
+- Store in vault: `credential_store stripe.com --password <key>`
+
+### 2. Duffel (Flights)
+
+- Create a Duffel account: https://app.duffel.com
+- Generate a sandbox token: https://app.duffel.com/tokens
+- Store in vault: `credential_store duffel.com --password <token>`
+
+### 3. LiteAPI (Hotels)
+
+- Create a LiteAPI account: https://dashboard.liteapi.travel
+- Get your sandbox API key
+- Store in vault: `credential_store liteapi.travel --password <key>`
+- Configure MCP server in agent.json (see commerce-setup.md skill for details)
+
+### 4. User Profile
+
+Store your travel profile with the agent:
+```
+user_profile_store '{"legalName":{"first":"...","last":"..."},"email":"...","phone":"...","preferences":{}}'
+```
+
+## Tool Reference
+
+### User Profile Tools
+| Tool | Description | Trust Level |
+|------|-------------|-------------|
+| `user_profile_store` | Store/update profile fields | Family |
+| `user_profile_get` | Retrieve a specific profile field | Family |
+| `user_profile_delete` | Delete entire profile | Family |
+
+### Payment Tools
+| Tool | Description | Trust Level |
+|------|-------------|-------------|
+| `stripe_create_card` | Create a virtual card | Family |
+| `stripe_deactivate_card` | Deactivate a card | Family |
+| `stripe_list_cards` | List active cards | Family |
+
+### Flight Tools
+| Tool | Description | Trust Level |
+|------|-------------|-------------|
+| `flight_search` | Search for flights | Friend |
+| `flight_hold` | Hold a flight offer | Family |
+| `flight_book` | Book a flight | Family |
+| `flight_cancel` | Cancel a booking | Family |
+
+### Hotel Tools
+Hotels are accessed through the LiteAPI MCP server. Tools are dynamically registered when the MCP server connects. Common tools include search, get rates, and book.
+
+## Security Model
+
+### Credential Gateway
+All API keys are stored in the agent's Vaultwarden vault. They are never exposed as environment variables or stored in config files. MCP servers receive credentials at startup via `vault:` env resolution.
+
+### Card Number Isolation
+Virtual card numbers exist only within the Stripe client's internal functions during a payment flow. They are never:
+- Returned to the model in tool outputs
+- Included in nerves events or logs
+- Stored in any persistent state
+- Shown in chat messages
+
+The model only sees card IDs (e.g., `ic_...`) and last-4 digits.
+
+### Trust Gating
+- **Family trust required**: All profile, payment, and booking tools
+- **Friend trust sufficient**: Flight search (read-only, no payment)
+- **Stranger/acquaintance**: No commerce access
+
+### Vault Resolution Failures
+When a `vault:` reference cannot be resolved for an MCP server:
+- The specific server is skipped (not crashed)
+- Other servers continue to start normally
+- An error event is emitted with the specific resolution failure
+- Error messages are actionable (e.g., "item not found", "field empty")
+
+## Verification Tiers
+
+### Tier 1: Real-Tested
+- User profile vault CRUD (tested against live Vaultwarden)
+- MCP credential injection (tested with real `vault:` env resolution)
+- Tool registration and guardrail enforcement
+
+### Tier 2: Mocked
+- Stripe Issuing API calls (mocked SDK)
+- Duffel flight API calls (mocked HTTP)
+- LiteAPI hotel API calls (MCP config only)
+- Full booking flow (profile -> search -> card -> book -> confirm -> deactivate)
+- Card number leakage verification
+
+### Post-Handoff
+- Real Stripe Issuing card creation (requires live Stripe account with Issuing)
+- Real Duffel booking (requires live API key)
+- Real LiteAPI hotel search (requires live MCP server)
+- Browser automation for Pattern B sites

package/skills/commerce-setup.md

@@ -0,0 +1,84 @@
+# Commerce Setup Wizard
+
+Step-by-step guide for setting up the agent's commerce infrastructure: payment, booking, and accommodation APIs.
+
+last_verified: 2026-04-06
+
+## Prerequisites
+
+- Agent vault must be set up (run `vault_setup` tool if not done)
+- Vault must be reachable at the configured server URL
+
+## Step 1: Stripe Issuing (Payments)
+
+1. Create a Stripe account at https://dashboard.stripe.com
+2. Enable Stripe Issuing (requires business verification)
+3. Create a restricted API key at https://dashboard.stripe.com/apikeys
+   - Enable only `issuing_cards:write` and `issuing_cards:read` permissions
+4. Store the key in the vault: `credential_store stripe.com --password <restricted_key> --notes "Stripe Issuing restricted key"`
+
+### Verification
+Run `stripe_list_cards` to verify the key works. Expected: empty list or existing cards.
+
+## Step 2: Duffel (Flights)
+
+1. Create a Duffel account at https://app.duffel.com
+2. Generate a sandbox API token at https://app.duffel.com/tokens
+   - Start with sandbox mode for testing
+   - Switch to live mode when ready for real bookings
+3. Store the key in the vault: `credential_store duffel.com --password <api_token> --notes "Duffel API token (sandbox)"`
+
+### Verification
+Run `flight_search` with any route (e.g., SFO to JFK). Expected: list of flight offers.
+
+## Step 3: LiteAPI (Hotels)
+
+1. Create a LiteAPI account at https://dashboard.liteapi.travel
+2. Get your sandbox API key from the dashboard
+3. Store the key in the vault: `credential_store liteapi.travel --password <api_key> --notes "LiteAPI sandbox key"`
+4. Configure the MCP server in agent.json:
+   ```json
+   {
+     "mcpServers": {
+       "liteapi": {
+         "command": "npx",
+         "args": ["tsx", "src/index.ts"],
+         "cwd": "/path/to/liteapi-mcp-server",
+         "env": {
+           "LITEAPI_API_KEY": "vault:liteapi.travel/apiKey"
+         }
+       }
+     }
+   }
+   ```
+
+### Verification
+The LiteAPI MCP server will start automatically when the agent boots. Check agent logs for `mcp.connect_end` event for the liteapi server.
+
+## Step 4: User Profile
+
+Store the human's travel profile:
+```
+user_profile_store '{"legalName": {"first": "...", "last": "..."}, "email": "...", "phone": "...", "preferences": {}}'
+```
+
+Optional but recommended fields: dateOfBirth, passport, driverLicense, addresses, loyaltyPrograms.
+
+## Self-Test
+
+After setup, run the commerce self-test to verify all services:
+- Stripe: creates and deactivates a test virtual card
+- Duffel: runs a test flight search
+- LiteAPI: verifies the API key is stored in the vault
+
+The self-test reports per-service health with actionable error messages:
+- "Flights working, hotels not yet -- LiteAPI key missing."
+- "Your Duffel key returned 401. Verify it at app.duffel.com/tokens."
+
+## Security Model
+
+- All API keys stored in the agent's Vaultwarden vault (not env vars)
+- Card numbers never appear in model context or logs
+- Virtual cards are single-use by default, deactivated after each transaction
+- User profile access requires family trust level
+- Vault credentials are resolved at MCP server startup, not at runtime