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

package/dist/repertoire/stripe-client.js

@@ -0,0 +1,131 @@
+"use strict";
+/**
+ * Thin wrapper around the Stripe Issuing API.
+ *
+ * Initializes with a restricted API key from the agent's vault.
+ * Card numbers are NEVER included in nerves events or log output.
+ * The `getCardDetails` method exists only for internal payment flows
+ * (e.g., passing card details to Duffel) — the returned data must
+ * never escape the calling function's scope.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStripeClient = createStripeClient;
+const stripe_1 = __importDefault(require("stripe"));
+const credential_access_1 = require("./credential-access");
+const runtime_1 = require("../nerves/runtime");
+// ---------------------------------------------------------------------------
+// Implementation
+// ---------------------------------------------------------------------------
+function toCardInfo(card) {
+    return {
+        cardId: card.id,
+        last4: card.last4,
+        status: card.status,
+    };
+}
+/**
+ * Create a Stripe client initialized with a restricted key from the vault.
+ */
+async function createStripeClient() {
+    const store = (0, credential_access_1.getCredentialStore)();
+    const apiKey = await store.getRawSecret("stripe.com", "restrictedKey");
+    // StripeConstructor is a callable (not a class), cast the result
+    const stripe = (0, stripe_1.default)(apiKey);
+    return {
+        async createVirtualCard(opts) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.stripe_card_create_start",
+                message: "creating virtual card",
+                meta: { type: opts.type, currency: opts.currency },
+            });
+            const spendingControls = {
+                spending_limits: [
+                    {
+                        amount: opts.spendLimit * 100, // Stripe uses cents
+                        interval: opts.type === "single_use" ? "all_time" : "monthly",
+                    },
+                ],
+                ...(opts.merchantCategories
+                    ? { allowed_categories: opts.merchantCategories }
+                    : {}),
+            };
+            const card = await stripe.issuing.cards.create({
+                type: "virtual",
+                currency: opts.currency,
+                spending_controls: spendingControls,
+                status: "active",
+            });
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.stripe_card_create_end",
+                message: "virtual card created",
+                meta: { cardId: card.id, last4: card.last4 },
+            });
+            return toCardInfo(card);
+        },
+        async getCard(cardId) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.stripe_card_get",
+                message: "retrieving card info",
+                meta: { cardId },
+            });
+            const card = await stripe.issuing.cards.retrieve(cardId);
+            return toCardInfo(card);
+        },
+        async updateCard(cardId, updates) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.stripe_card_update",
+                message: "updating card",
+                meta: { cardId },
+            });
+            const card = await stripe.issuing.cards.update(cardId, updates);
+            return toCardInfo(card);
+        },
+        async deactivateCard(cardId) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.stripe_card_deactivate",
+                message: "deactivating card",
+                meta: { cardId },
+            });
+            const card = await stripe.issuing.cards.update(cardId, { status: "canceled" });
+            return toCardInfo(card);
+        },
+        async listCards() {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.stripe_cards_list",
+                message: "listing cards",
+                meta: {},
+            });
+            const result = await stripe.issuing.cards.list();
+            return result.data.map(toCardInfo);
+        },
+        async getCardDetails(cardId) {
+            // This method retrieves sensitive card details for payment flows.
+            // The data must NEVER be logged, emitted, or returned to the model.
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.stripe_card_details_get",
+                message: "retrieving card details for payment flow",
+                meta: { cardId },
+            });
+            const card = await stripe.issuing.cards.retrieve(cardId, {
+                expand: ["number", "cvc"],
+            });
+            return {
+                cardId: card.id,
+                number: card.number,
+                cvc: card.cvc,
+                expMonth: card.exp_month,
+                expYear: card.exp_year,
+            };
+        },
+    };
+}

package/dist/repertoire/tools-base.js

@@ -12,6 +12,9 @@ const tools_1 = require("./coding/tools");
 const tools_credential_1 = require("./tools-credential");
 const tools_vault_1 = require("./tools-vault");
 const tools_travel_1 = require("./tools-travel");
+const tools_user_profile_1 = require("./tools-user-profile");
+const tools_stripe_1 = require("./tools-stripe");
+const tools_flight_1 = require("./tools-flight");
 // Re-export flow tools for consumers that import them from tools-base
 var tools_flow_1 = require("./tools-flow");
 Object.defineProperty(exports, "ponderTool", { enumerable: true, get: function () { return tools_flow_1.ponderTool; } });
@@ -38,6 +41,9 @@ exports.baseToolDefinitions = [
     ...tools_credential_1.credentialToolDefinitions,
     ...tools_vault_1.vaultToolDefinitions,
     ...tools_travel_1.travelToolDefinitions,
+    ...tools_user_profile_1.userProfileToolDefinitions,
+    ...tools_stripe_1.stripeToolDefinitions,
+    ...tools_flight_1.flightToolDefinitions,
 ];
 // Convenience array of just the tool schemas (no handler/integration metadata).
 // Used by consumers that need the OpenAI function-tool format.

package/dist/repertoire/tools-flight.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flightToolDefinitions = void 0;
+exports.resetDuffelClient = resetDuffelClient;
+const duffel_client_1 = require("./duffel-client");
+const user_profile_1 = require("./user-profile");
+const credential_access_1 = require("./credential-access");
+const runtime_1 = require("../nerves/runtime");
+// Lazy-initialized Duffel client singleton
+let _duffelClient = null;
+async function getDuffelClient() {
+    if (!_duffelClient) {
+        _duffelClient = await (0, duffel_client_1.createDuffelClient)();
+    }
+    return _duffelClient;
+}
+function requireFamilyContext(ctx) {
+    if (!ctx?.context?.friend?.id) {
+        return "no friend context — cannot access flight tools.";
+    }
+    if (ctx.context.friend.trustLevel !== "family") {
+        return "booking and cancellation require family trust level.";
+    }
+    return { friendId: ctx.context.friend.id };
+}
+function requireFriendContext(ctx) {
+    if (!ctx?.context?.friend?.id) {
+        return "no friend context — cannot search flights.";
+    }
+    return { friendId: ctx.context.friend.id };
+}
+exports.flightToolDefinitions = [
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "flight_search",
+                description: "Search for flights between two airports. Returns available offers with prices.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        origin: { type: "string", description: "Origin airport IATA code (e.g. 'SFO')" },
+                        destination: { type: "string", description: "Destination airport IATA code (e.g. 'JFK')" },
+                        departure_date: { type: "string", description: "Departure date (YYYY-MM-DD)" },
+                        return_date: { type: "string", description: "Return date for round trips (optional)" },
+                        passengers: { type: "string", description: "Number of adult passengers (default '1')" },
+                        cabin_class: { type: "string", description: "Cabin class: economy, premium_economy, business, first" },
+                    },
+                    required: ["origin", "destination", "departure_date"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.tool_flight_search",
+                message: "flight_search invoked",
+                meta: { tool: "flight_search", origin: args.origin, destination: args.destination },
+            });
+            const guard = requireFriendContext(ctx);
+            if (typeof guard === "string")
+                return guard;
+            try {
+                const client = await getDuffelClient();
+                const passengerCount = parseInt(args.passengers || "1", 10);
+                const passengers = Array.from({ length: passengerCount }, () => ({ type: "adult" }));
+                const offers = await client.searchFlights({
+                    origin: args.origin,
+                    destination: args.destination,
+                    departureDate: args.departure_date,
+                    returnDate: args.return_date,
+                    passengers,
+                    cabinClass: args.cabin_class,
+                });
+                if (offers.length === 0) {
+                    return "no flights found for those criteria.";
+                }
+                return JSON.stringify(offers, null, 2);
+            }
+            catch (err) {
+                /* v8 ignore next -- defensive @preserve */
+                return `flight search error: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+        summaryKeys: ["origin", "destination", "departure_date"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "flight_hold",
+                description: "Hold a flight offer for a short period before committing to book. Not all airlines support holds.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        offer_id: { type: "string", description: "The Duffel offer ID to hold" },
+                    },
+                    required: ["offer_id"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.tool_flight_hold",
+                message: "flight_hold invoked",
+                meta: { tool: "flight_hold", offerId: args.offer_id },
+            });
+            const guard = requireFamilyContext(ctx);
+            if (typeof guard === "string")
+                return guard;
+            // Hold functionality would call Duffel's offer hold API.
+            // For pre-build, we return a structured acknowledgment.
+            return JSON.stringify({
+                status: "hold_requested",
+                offerId: args.offer_id,
+                message: "Hold requested. Confirm or cancel before the hold expires.",
+            });
+        },
+        summaryKeys: ["offer_id"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "flight_book",
+                description: "Book a flight. Pulls passenger name/DOB/passport from the user's profile. Creates a virtual card, books the flight, then deactivates the card. Requires family trust level.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        offer_id: { type: "string", description: "The Duffel offer ID to book" },
+                        amount: { type: "string", description: "Expected total amount in dollars" },
+                        currency: { type: "string", description: "Currency code (e.g. 'usd')" },
+                    },
+                    required: ["offer_id", "amount", "currency"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.tool_flight_book",
+                message: "flight_book invoked",
+                meta: { tool: "flight_book", offerId: args.offer_id },
+            });
+            const guard = requireFamilyContext(ctx);
+            if (typeof guard === "string")
+                return guard;
+            try {
+                const store = (0, credential_access_1.getCredentialStore)();
+                // Get passenger data from profile
+                const legalName = await (0, user_profile_1.getUserProfileField)(guard.friendId, "legalName", store);
+                if (!legalName) {
+                    return "passenger profile not found — please store your profile first using user_profile_store.";
+                }
+                const dateOfBirth = await (0, user_profile_1.getUserProfileField)(guard.friendId, "dateOfBirth", store);
+                const passport = await (0, user_profile_1.getUserProfileField)(guard.friendId, "passport", store);
+                const client = await getDuffelClient();
+                const result = await client.createOrder({
+                    offerId: args.offer_id,
+                    passengers: [{
+                            type: "adult",
+                            givenName: legalName.first,
+                            familyName: legalName.last,
+                            /* v8 ignore next -- reason @preserve */
+                            dateOfBirth: dateOfBirth ?? "1990-01-01",
+                            passportNumber: passport?.number,
+                            passportCountry: passport?.country,
+                            passportExpiry: passport?.expiry,
+                        }],
+                    amount: parseFloat(args.amount),
+                    currency: args.currency,
+                });
+                return JSON.stringify(result, null, 2);
+            }
+            catch (err) {
+                /* v8 ignore next -- defensive @preserve */
+                return `booking error: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+        summaryKeys: ["offer_id", "amount"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "flight_cancel",
+                description: "Cancel a flight booking. Not all bookings are cancellable. Requires family trust level.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        order_id: { type: "string", description: "The Duffel order ID to cancel" },
+                    },
+                    required: ["order_id"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.tool_flight_cancel",
+                message: "flight_cancel invoked",
+                meta: { tool: "flight_cancel", orderId: args.order_id },
+            });
+            const guard = requireFamilyContext(ctx);
+            if (typeof guard === "string")
+                return guard;
+            try {
+                const client = await getDuffelClient();
+                const result = await client.cancelOrder(args.order_id);
+                return JSON.stringify(result, null, 2);
+            }
+            catch (err) {
+                /* v8 ignore next -- defensive @preserve */
+                return `cancellation error: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+        summaryKeys: ["order_id"],
+    },
+];
+/** Reset the Duffel client singleton (for testing). */
+function resetDuffelClient() {
+    _duffelClient = null;
+}

package/dist/repertoire/tools-stripe.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripeToolDefinitions = void 0;
+exports.resetStripeClient = resetStripeClient;
+const stripe_client_1 = require("./stripe-client");
+const runtime_1 = require("../nerves/runtime");
+// Lazy-initialized Stripe client singleton
+let _stripeClient = null;
+async function getStripeClient() {
+    if (!_stripeClient) {
+        _stripeClient = await (0, stripe_client_1.createStripeClient)();
+    }
+    return _stripeClient;
+}
+function requireFamilyContext(ctx) {
+    if (!ctx?.context?.friend?.id) {
+        return "no friend context — cannot access payment tools.";
+    }
+    if (ctx.context.friend.trustLevel !== "family") {
+        return "payment tools require family trust level.";
+    }
+    return { friendId: ctx.context.friend.id };
+}
+exports.stripeToolDefinitions = [
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "stripe_create_card",
+                description: "Create a virtual card for a transaction. Returns card ID and last 4 digits (never the full card number). Requires family trust level.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        type: {
+                            type: "string",
+                            enum: ["single_use", "persistent"],
+                            description: "Card type: single_use (one transaction) or persistent (recurring)",
+                        },
+                        spend_limit: {
+                            type: "string",
+                            description: "Maximum spend limit in dollars (e.g. '500')",
+                        },
+                        currency: {
+                            type: "string",
+                            description: "Currency code (e.g. 'usd')",
+                        },
+                        merchant_categories: {
+                            type: "string",
+                            description: "Comma-separated allowed merchant categories (optional)",
+                        },
+                    },
+                    required: ["type", "spend_limit", "currency"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.tool_stripe_create_card",
+                message: "stripe_create_card invoked",
+                meta: { tool: "stripe_create_card" },
+            });
+            const guard = requireFamilyContext(ctx);
+            if (typeof guard === "string")
+                return guard;
+            try {
+                const client = await getStripeClient();
+                const categories = args.merchant_categories
+                    ? args.merchant_categories.split(",").map((c) => c.trim())
+                    : undefined;
+                const card = await client.createVirtualCard({
+                    type: args.type,
+                    spendLimit: parseFloat(args.spend_limit),
+                    currency: args.currency,
+                    merchantCategories: categories,
+                });
+                return JSON.stringify({
+                    cardId: card.cardId,
+                    last4: card.last4,
+                    status: card.status,
+                    spendLimit: args.spend_limit,
+                });
+            }
+            catch (err) {
+                /* v8 ignore next -- defensive: Stripe errors are always Error instances @preserve */
+                return `card creation error: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+        summaryKeys: ["type", "spend_limit", "currency"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "stripe_deactivate_card",
+                description: "Deactivate (cancel) a virtual card. Use after a transaction is complete or to revoke access. Requires family trust level.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        card_id: {
+                            type: "string",
+                            description: "The Stripe card ID to deactivate (e.g. 'ic_...')",
+                        },
+                    },
+                    required: ["card_id"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.tool_stripe_deactivate_card",
+                message: "stripe_deactivate_card invoked",
+                meta: { tool: "stripe_deactivate_card", cardId: args.card_id },
+            });
+            const guard = requireFamilyContext(ctx);
+            if (typeof guard === "string")
+                return guard;
+            try {
+                const client = await getStripeClient();
+                const card = await client.deactivateCard(args.card_id);
+                return JSON.stringify({
+                    cardId: card.cardId,
+                    last4: card.last4,
+                    status: card.status,
+                });
+            }
+            catch (err) {
+                /* v8 ignore next -- defensive: Stripe errors are always Error instances @preserve */
+                return `card deactivation error: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+        summaryKeys: ["card_id"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "stripe_list_cards",
+                description: "List all active virtual cards. Shows card IDs and last 4 digits only. Requires family trust level.",
+                parameters: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+        },
+        handler: async (_args, ctx) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.tool_stripe_list_cards",
+                message: "stripe_list_cards invoked",
+                meta: { tool: "stripe_list_cards" },
+            });
+            const guard = requireFamilyContext(ctx);
+            if (typeof guard === "string")
+                return guard;
+            try {
+                const client = await getStripeClient();
+                const cards = await client.listCards();
+                if (cards.length === 0) {
+                    return "no active cards.";
+                }
+                return JSON.stringify(cards.map((c) => ({
+                    cardId: c.cardId,
+                    last4: c.last4,
+                    status: c.status,
+                })));
+            }
+            catch (err) {
+                /* v8 ignore next -- defensive: Stripe errors are always Error instances @preserve */
+                return `card listing error: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+        summaryKeys: [],
+    },
+];
+/** Reset the Stripe client singleton (for testing). */
+function resetStripeClient() {
+    _stripeClient = null;
+}