@ouro.bot/cli 0.1.0-alpha.94 → 0.1.0-alpha.940

package/dist/repertoire/tools-steward-policy.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stewardPolicyToolDefinition = void 0;
+const steward_policy_1 = require("../heart/steward-policy");
+const runtime_1 = require("../nerves/runtime");
+function arrayArgument(raw, label) {
+    if (!raw)
+        throw new Error(`${label} is required`);
+    const value = JSON.parse(raw);
+    if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string"))
+        throw new Error(`${label} must be a JSON string array`);
+    return value;
+}
+exports.stewardPolicyToolDefinition = {
+    tool: {
+        type: "function",
+        function: {
+            name: "steward_policy_manage",
+            description: "Read or update the household steward's typed desired-state and routine-action policy. Updates require the current authenticated owner Telegram request and fresh authorization. Replay identities can never update it. correct_provenance (key, source, correction) is only for fixing a wrong attribution on an existing desired state: it replaces the recorded source and records the correction note, never changes the value, and leaves an audit row; do not use it to change a value. expectedVersion is optional; omit it to apply against the current policy version, or supply a version from read for explicit stale-write detection.",
+            parameters: {
+                type: "object",
+                properties: {
+                    action: { type: "string", enum: ["read", "set_desired_state", "grant_routine_action", "correct_provenance"] },
+                    expectedVersion: { type: "integer", minimum: 0, description: "Optional version returned by read. When omitted, the runtime uses the current policy version." },
+                    key: { type: "string" },
+                    value: { type: "string" },
+                    provenance: { type: "string", enum: ["stated", "observed", "default", "installed_explicit_policy"] },
+                    source: { type: "string", description: "Who or what stated this. For correct_provenance, the corrected attribution that replaces the recorded source." },
+                    correction: { type: "string", description: "correct_provenance only: required note naming what is being corrected and why." },
+                    routineAction: { type: "string" },
+                    targetsJson: { type: "string", description: "JSON array of exact target names" },
+                    maxCount: { type: "integer", minimum: 1 },
+                    windowMs: { type: "integer", minimum: 1 },
+                    verificationRequired: { type: "boolean" },
+                    exclusionsJson: { type: "string", description: "JSON array of exact excluded target names" },
+                    expiresAt: { type: "string" },
+                },
+                required: ["action"],
+                additionalProperties: false,
+            },
+        },
+    },
+    handler: (args, ctx) => {
+        if (!ctx?.agentRoot)
+            throw new Error("steward policy runtime is unavailable");
+        if (!ctx.relationshipAuthorization)
+            throw new Error("steward policy access requires authenticated relationship authority");
+        if (args.action === "read") {
+            (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.steward_policy_tool_call", message: "read steward policy", meta: { action: "read" } });
+            return JSON.stringify((0, steward_policy_1.readStewardPolicy)(ctx.agentRoot));
+        }
+        const relationship = ctx.relationshipAuthorization;
+        const actor = relationship.actor;
+        if (!actor)
+            throw new Error("steward policy mutation requires authenticated relationship authority");
+        const { friendId, trustLevel, sessionEventId } = actor;
+        const { profileId, requestId } = relationship;
+        (0, steward_policy_1.assertNotReplayIdentity)(ctx.agentRoot, [friendId, ctx.delegatedCommand?.delegateFriendId]);
+        const sessionKey = ctx.currentSession?.key;
+        const delegated = ctx.delegatedCommand;
+        // Two ways to hold owner authority: the owner's own Telegram turn, or a delegated
+        // command the A2A server admitted (grant checked, owner already notified).
+        const sessionMatches = () => delegated
+            ? ctx.currentSession?.channel === "a2a" && ctx.delegatedCommand === delegated
+                && friendId === delegated.principalFriendId && requestId === delegated.commandId
+                && sessionEventId === `a2a-delegated:${delegated.commandId}`
+            : ctx.currentSession?.friendId === friendId && ctx.currentSession.channel === "telegram";
+        if (trustLevel !== "family" || profileId !== "sanctuary-owner" || typeof requestId !== "string" || !requestId.trim()
+            || typeof sessionKey !== "string" || !sessionKey.trim() || !sessionEventId.trim()
+            || !sessionMatches() || ctx.currentExternalEvent) {
+            throw new Error(delegated
+                ? "steward policy mutation requires a current admitted delegated owner command"
+                : "steward policy mutation requires a current authenticated owner Telegram request and session");
+        }
+        const sourceFor = (raw) => delegated
+            ? `${delegated.principalName} via ${delegated.delegateName} (delegated)${raw?.trim() ? `: ${raw.trim()}` : ""}`
+            : raw ?? "";
+        const expectedVersion = args.expectedVersion === undefined ? undefined : Number(args.expectedVersion);
+        if (expectedVersion !== undefined && (!Number.isSafeInteger(expectedVersion) || expectedVersion < 0))
+            throw new Error("expectedVersion must be a nonnegative integer");
+        let mutation;
+        if (args.action === "set_desired_state") {
+            if (args.provenance !== "stated" && args.provenance !== "observed" && args.provenance !== "default")
+                throw new Error("desired state provenance is invalid");
+            mutation = { kind: "set_desired_state", key: args.key ?? "", value: args.value ?? "", provenance: args.provenance, source: sourceFor(args.source), ...(args.expiresAt ? { expiresAt: args.expiresAt } : {}) };
+        }
+        else if (args.action === "correct_provenance") {
+            mutation = { kind: "correct_provenance", key: args.key ?? "", source: sourceFor(args.source), correction: args.correction ?? "" };
+        }
+        else if (args.action === "grant_routine_action") {
+            if (args.provenance !== "stated" && args.provenance !== "installed_explicit_policy")
+                throw new Error("routine action provenance is invalid");
+            const targets = arrayArgument(args.targetsJson, "targetsJson");
+            const exclusions = arrayArgument(args.exclusionsJson, "exclusionsJson");
+            const verificationRequired = args.verificationRequired;
+            if (verificationRequired !== true)
+                throw new Error("verificationRequired must be true");
+            mutation = {
+                kind: "grant_routine_action",
+                key: args.key ?? "",
+                action: args.routineAction ?? "",
+                targets,
+                maxCount: Number(args.maxCount),
+                windowMs: Number(args.windowMs),
+                verificationRequired,
+                exclusions,
+                provenance: args.provenance,
+                ...(args.expiresAt ? { expiresAt: args.expiresAt } : {}),
+            };
+        }
+        else
+            throw new Error("steward policy action is invalid");
+        const agentRoot = ctx.agentRoot;
+        return Promise.resolve(relationship.authorizeTool("steward_policy_manage", args)).then((authorization) => {
+            if (!authorization.allowed)
+                throw new Error(`steward policy authorization denied: ${authorization.reason}`);
+            if (typeof authorization.profileVersion !== "number" || !Number.isSafeInteger(authorization.profileVersion) || authorization.profileVersion < 1 || !authorization.receiptId.trim()) {
+                throw new Error("steward policy owner authorization is not versioned");
+            }
+            if (ctx.relationshipAuthorization !== relationship || relationship.profileId !== profileId || relationship.requestId !== requestId
+                || relationship.actor?.friendId !== friendId || relationship.actor.trustLevel !== trustLevel || relationship.actor.sessionEventId !== sessionEventId
+                || ctx.currentSession?.key !== sessionKey || !sessionMatches() || ctx.currentExternalEvent) {
+                throw new Error("steward policy owner authorization or session changed before mutation");
+            }
+            const versionBefore = (0, steward_policy_1.readStewardPolicy)(agentRoot).version;
+            const result = (0, steward_policy_1.updateStewardPolicy)(agentRoot, {
+                expectedVersion: expectedVersion ?? (0, steward_policy_1.readStewardPolicy)(agentRoot).version,
+                actor: {
+                    friendId, trustLevel, sessionEventId,
+                    authorization: { profileId, requestId, sessionKey, receiptId: authorization.receiptId, profileVersion: authorization.profileVersion },
+                    ...(delegated ? { delegatedVia: { delegateFriendId: delegated.delegateFriendId, delegateDid: delegated.delegateDid, noticeId: delegated.noticeId } } : {}),
+                },
+                mutation,
+            });
+            (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.steward_policy_tool_call", message: "updated steward policy", meta: { action: args.action } });
+            if (mutation.kind === "set_desired_state" && result.version === versionBefore) {
+                // A same-value restatement writes nothing; the entry is necessarily present.
+                const existing = result.desiredStates[mutation.key];
+                return JSON.stringify({ ...result, unchanged: true, note: `already recorded as ${existing.value} (source: ${existing.source})` });
+            }
+            return JSON.stringify(result);
+        });
+    },
+    riskProfile: (args) => args.action === "read"
+        ? { mutates: "none", risk: "low" }
+        : { mutates: "durable_state_write", risk: "high", reason: "updates typed household steward policy under current authenticated owner authority" },
+};

package/dist/repertoire/tools-stripe.js

@@ -0,0 +1,224 @@
+"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");
+const store_1 = require("../commerce/store");
+// 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 };
+}
+function parseExactSpendLimit(raw) {
+    const value = raw.trim();
+    if (!/^\d+(?:\.\d{1,2})?$/.test(value))
+        throw new Error("spend_limit must be an exact decimal with at most two places");
+    return Number(value);
+}
+function consumeReservedCommerce(ctx, toolName) {
+    if (!ctx?.commerceAuthority || !ctx.agentRoot)
+        return null;
+    const result = (0, store_1.consumeReservedCommerceAuthority)({
+        agentRoot: ctx.agentRoot,
+        checkoutId: ctx.commerceAuthority.checkoutId,
+        reservationToken: ctx.commerceAuthority.reservationToken,
+        toolName,
+        friendId: ctx.context?.friend?.id,
+    });
+    return result.ok ? null : `commerce authority consume error: ${result.reason}`;
+}
+function markCommerceAttempted(ctx, toolName) {
+    if (!ctx?.commerceAuthority || !ctx.agentRoot)
+        return null;
+    const result = (0, store_1.markReservedCommerceAuthorityAttempted)({
+        agentRoot: ctx.agentRoot,
+        checkoutId: ctx.commerceAuthority.checkoutId,
+        reservationToken: ctx.commerceAuthority.reservationToken,
+        toolName,
+        friendId: ctx.context?.friend?.id,
+    });
+    return result.ok ? null : `commerce authority attempt error: ${result.reason}`;
+}
+exports.stripeToolDefinitions = [
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "stripe_create_card",
+                description: "Create a virtual card for an approved transaction. Returns card ID and last 4 digits (never the full card number). Requires family trust level and a matching confirmed commerce checkout.",
+                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 from the confirmed commerce constraints.",
+                        },
+                        commerce_authority: {
+                            type: "string",
+                            description: "Optional explicit authority token for external/manual flows; normally omit so Ouro consumes the matching confirmed checkout without exposing a bearer token.",
+                        },
+                    },
+                    required: ["type", "spend_limit", "currency", "merchant_categories"],
+                },
+            },
+        },
+        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 categories = args.merchant_categories.split(",").map((c) => c.trim()).filter(Boolean);
+                if (categories.length === 0)
+                    throw new Error("merchant_categories is required");
+                const spendLimit = parseExactSpendLimit(args.spend_limit);
+                const attemptError = markCommerceAttempted(ctx, "stripe_create_card");
+                if (attemptError)
+                    return attemptError;
+                const client = await getStripeClient();
+                const card = await client.createVirtualCard({
+                    type: args.type,
+                    spendLimit,
+                    currency: args.currency,
+                    merchantCategories: categories,
+                });
+                const consumeError = consumeReservedCommerce(ctx, "stripe_create_card");
+                if (consumeError)
+                    return consumeError;
+                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"],
+        riskProfile: { mutates: "external_side_effect", risk: "high", reason: "creates a virtual payment card" },
+    },
+    {
+        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"],
+        riskProfile: { mutates: "external_side_effect", risk: "high", reason: "deactivates a virtual payment card" },
+    },
+    {
+        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;
+}