@ouro.bot/cli 0.1.0-alpha.66 → 0.1.0-alpha.661

package/dist/repertoire/tools-commerce.js

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commerceToolDefinitions = void 0;
+const identity_1 = require("../heart/identity");
+const runtime_1 = require("../nerves/runtime");
+const store_1 = require("../commerce/store");
+function requireFamilyContext(ctx) {
+    if (!ctx?.context?.friend?.id)
+        return "no friend context — cannot use commerce tools.";
+    if (ctx.context.friend.trustLevel !== "family")
+        return "commerce tools require family trust level.";
+    /* v8 ignore next -- no-agentRoot fallback depends on process argv; normal tool calls inject agentRoot @preserve */
+    if (ctx.agentRoot)
+        return { friendId: ctx.context.friend.id, agentRoot: ctx.agentRoot };
+    return { friendId: ctx.context.friend.id, agentRoot: (0, identity_1.getAgentRoot)() };
+}
+function parseItems(raw) {
+    if (!raw?.trim())
+        return undefined;
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed))
+        throw new Error("items_json must be a JSON array");
+    return parsed.map((item) => {
+        if (!item || typeof item !== "object" || Array.isArray(item))
+            throw new Error("each item must be an object");
+        const record = item;
+        if (typeof record.name !== "string" || !record.name.trim())
+            throw new Error("each item needs a name");
+        return {
+            name: record.name,
+            ...(typeof record.quantity === "number" ? { quantity: record.quantity } : {}),
+            ...(typeof record.amount === "number" ? { amount: record.amount } : {}),
+        };
+    });
+}
+function parseExpiryMinutes(raw) {
+    if (!raw?.trim())
+        return undefined;
+    const value = Number.parseInt(raw, 10);
+    if (!Number.isInteger(value) || value <= 0)
+        throw new Error("expires_minutes must be a positive integer");
+    return value;
+}
+function parseExactAmount(raw) {
+    const value = raw?.trim();
+    if (!value || !/^\d+(?:\.\d{1,2})?$/.test(value))
+        throw new Error("amount must be an exact decimal with at most two places");
+    return Number(value);
+}
+function parseToolName(raw) {
+    const toolName = raw?.trim();
+    if (!toolName)
+        throw new Error("tool_name is required");
+    return toolName;
+}
+function parseConstraints(raw) {
+    if (!raw?.trim())
+        return undefined;
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        throw new Error("constraints_json must be a JSON object");
+    return Object.fromEntries(Object.entries(parsed).map(([key, value]) => [key, String(value)]));
+}
+function validateToolConstraints(toolName, constraints) {
+    if (toolName !== "stripe_create_card")
+        return;
+    if (!constraints?.type)
+        throw new Error("constraints_json.type is required for stripe_create_card");
+    if (!constraints.merchant_categories)
+        throw new Error("constraints_json.merchant_categories is required for stripe_create_card");
+}
+exports.commerceToolDefinitions = [
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "commerce_checkout_preview",
+                description: "Create an AP2-compatible local checkout preview before any payment or booking action. Requires family trust.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        merchant: { type: "string", description: "Merchant, provider, or counterparty name." },
+                        amount: { type: "string", description: "Exact total amount." },
+                        currency: { type: "string", description: "Currency code, e.g. usd." },
+                        tool_name: { type: "string", description: "Exact tool this authority may be used with, e.g. stripe_create_card, flight_hold, or flight_book." },
+                        constraints_json: { type: "string", description: "JSON object of exact tool-argument constraints; required for stripe_create_card type and merchant_categories, and recommended for flight offer_id." },
+                        reason: { type: "string", description: "Why this purchase/booking is being made." },
+                        items_json: { type: "string", description: "Optional JSON array of {name, quantity, amount} items." },
+                        expires_minutes: { type: "string", description: "Optional expiry window in minutes; defaults to 30." },
+                    },
+                    required: ["merchant", "amount", "currency", "tool_name", "reason"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.tool_commerce_checkout_preview",
+                message: "commerce_checkout_preview invoked",
+                meta: { tool: "commerce_checkout_preview", merchant: args.merchant },
+            });
+            const guard = requireFamilyContext(ctx);
+            if (typeof guard === "string")
+                return guard;
+            try {
+                const expiresInMinutes = parseExpiryMinutes(args.expires_minutes);
+                const toolName = parseToolName(args.tool_name);
+                const constraints = parseConstraints(args.constraints_json);
+                const items = parseItems(args.items_json);
+                validateToolConstraints(toolName, constraints);
+                const record = (0, store_1.createCommercePreview)({
+                    agentRoot: guard.agentRoot,
+                    friendId: guard.friendId,
+                    merchant: args.merchant,
+                    amount: parseExactAmount(args.amount),
+                    currency: args.currency,
+                    allowedTools: [toolName],
+                    constraints,
+                    reason: args.reason,
+                    items,
+                    ...(expiresInMinutes ? { expiresInMinutes } : {}),
+                });
+                const confirmationMessage = (0, store_1.commerceConfirmationMessage)(record);
+                return JSON.stringify({
+                    checkoutId: record.id,
+                    merchant: record.merchant,
+                    amount: record.amount,
+                    currency: record.currency,
+                    allowedTools: record.allowedTools,
+                    constraints: record.constraints,
+                    expiresAt: record.expiresAt,
+                    digest: record.digest,
+                    confirmationMessage,
+                    next: `Ask the family user to send the confirmationMessage exactly in a new turn after reviewing merchant, amount, currency, tool, and constraints; then call commerce_checkout_commit from that same turn.`,
+                }, null, 2);
+            }
+            catch (error) {
+                return `commerce preview error: ${error instanceof Error ? error.message : /* v8 ignore next -- defensive non-Error parser failures */ String(error)}`;
+            }
+        },
+        summaryKeys: ["merchant", "amount", "currency"],
+        riskProfile: { mutates: "durable_state_write", risk: "high", reason: "creates a purchase mandate preview" },
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "commerce_checkout_commit",
+                description: "Confirm an exact checkout preview for the next matching payment/booking tool call. Requires family trust and confirmation=CONFIRM_PURCHASE.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        checkout_id: { type: "string", description: "Checkout preview ID." },
+                        digest: { type: "string", description: "Digest returned by commerce_checkout_preview." },
+                        confirmation: { type: "string", description: "Must be CONFIRM_PURCHASE." },
+                    },
+                    required: ["checkout_id", "digest", "confirmation"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.tool_commerce_checkout_commit",
+                message: "commerce_checkout_commit invoked",
+                meta: { tool: "commerce_checkout_commit", checkoutId: args.checkout_id },
+            });
+            const guard = requireFamilyContext(ctx);
+            if (typeof guard === "string")
+                return guard;
+            try {
+                const record = (0, store_1.confirmCommercePreview)({
+                    agentRoot: guard.agentRoot,
+                    checkoutId: args.checkout_id,
+                    digest: args.digest,
+                    confirmation: args.confirmation,
+                    friendId: guard.friendId,
+                    currentUserMessage: ctx?.currentUserMessage,
+                });
+                return JSON.stringify({
+                    checkoutId: record.id,
+                    status: record.status,
+                    expiresAt: record.expiresAt,
+                    use: "Call the approved payment or booking tool with the exact merchant/tool/amount/currency/constraint arguments; Ouro will consume the matching authority without exposing a bearer token.",
+                }, null, 2);
+            }
+            catch (error) {
+                return `commerce commit error: ${error instanceof Error ? error.message : /* v8 ignore next -- defensive non-Error store failures */ String(error)}`;
+            }
+        },
+        summaryKeys: ["checkout_id"],
+        riskProfile: { mutates: "durable_state_write", risk: "high", reason: "confirms a purchase mandate" },
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "commerce_receipt_get",
+                description: "Read a local commerce checkout/mandate receipt. Requires family trust.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        checkout_id: { type: "string", description: "Checkout ID." },
+                    },
+                    required: ["checkout_id"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.tool_commerce_receipt_get",
+                message: "commerce_receipt_get invoked",
+                meta: { tool: "commerce_receipt_get", checkoutId: args.checkout_id },
+            });
+            const guard = requireFamilyContext(ctx);
+            if (typeof guard === "string")
+                return guard;
+            const record = (0, store_1.readCommerceRecord)(guard.agentRoot, args.checkout_id);
+            return record ? JSON.stringify(record, null, 2) : `commerce checkout not found: ${args.checkout_id}`;
+        },
+        summaryKeys: ["checkout_id"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "commerce_access_log",
+                description: "Read the commerce authority access log. Requires family trust.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        limit: { type: "string", description: "Number of recent entries to return; defaults to 20." },
+                    },
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.tool_commerce_access_log",
+                message: "commerce_access_log invoked",
+                meta: { tool: "commerce_access_log" },
+            });
+            const guard = requireFamilyContext(ctx);
+            if (typeof guard === "string")
+                return guard;
+            const limit = args.limit ? Number.parseInt(args.limit, 10) : 20;
+            return JSON.stringify((0, store_1.readCommerceAccessLog)(guard.agentRoot, Number.isInteger(limit) ? limit : 20), null, 2);
+        },
+        summaryKeys: ["limit"],
+    },
+];

package/dist/repertoire/tools-config.js

@@ -0,0 +1,186 @@
+"use strict";
+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.configToolDefinitions = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+const identity_1 = require("../heart/identity");
+const config_registry_1 = require("../heart/config-registry");
+exports.configToolDefinitions = [
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "read_config",
+                description: "Read current agent configuration with tier annotations, descriptions, defaults, and effects. Optionally filter by topic to see only related settings.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        related_to: {
+                            type: "string",
+                            description: "Optional topic to filter results (e.g., 'model', 'logging', 'senses'). Case-insensitive partial match.",
+                        },
+                    },
+                },
+            },
+        },
+        handler: (a) => {
+            const entries = a.related_to
+                ? (0, config_registry_1.getRegistryEntriesByTopic)(a.related_to)
+                : (0, config_registry_1.getRegistryEntries)();
+            const agentRoot = (0, identity_1.getAgentRoot)();
+            const configPath = path.join(agentRoot, "agent.json");
+            let rawConfig = {};
+            try {
+                rawConfig = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+            }
+            catch {
+                /* v8 ignore next -- defensive: agent.json read failure in read_config @preserve */
+                (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.read_config_error", message: "failed to read agent.json", meta: { path: configPath } });
+            }
+            const result = entries.map((entry) => {
+                const parts = entry.path.split(".");
+                let current = rawConfig;
+                for (const part of parts) {
+                    if (current && typeof current === "object" && !Array.isArray(current)) {
+                        current = current[part];
+                    }
+                    else {
+                        current = undefined;
+                        break;
+                    }
+                }
+                const isExplicit = current !== undefined;
+                let source;
+                let currentValue;
+                if (isExplicit) {
+                    source = "explicit";
+                    currentValue = current;
+                }
+                else if (entry.default !== undefined) {
+                    source = "default";
+                    currentValue = entry.default;
+                }
+                else {
+                    source = "unset";
+                    currentValue = null;
+                }
+                return {
+                    path: entry.path,
+                    currentValue,
+                    source,
+                    tier: entry.tier,
+                    description: entry.description,
+                    default: entry.default !== undefined ? entry.default : null,
+                    effects: entry.effects,
+                    topics: entry.topics,
+                };
+            });
+            (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.read_config", message: `read_config returned ${result.length} entries`, meta: { count: result.length, topic: a.related_to ?? null } });
+            return JSON.stringify({ entries: result }, null, 2);
+        },
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "update_config",
+                description: "Update an agent configuration value. Managed keys (version, enabled) cannot be modified.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        path: { type: "string", description: "Config key in dot-notation (e.g., 'context.contextMargin', 'logging.level')" },
+                        value: { type: "string", description: "New value as JSON (e.g., '25', '\"debug\"', '[\"terminal\", \"ndjson\"]')" },
+                    },
+                    required: ["path", "value"],
+                },
+            },
+        },
+        handler: (a) => {
+            const entry = (0, config_registry_1.getRegistryEntry)(a.path);
+            if (!entry) {
+                (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.update_config_error", message: `unknown config path: ${a.path}`, meta: { path: a.path } });
+                return `Error: unknown config path "${a.path}". Use read_config to see available paths.`;
+            }
+            let parsedValue;
+            try {
+                parsedValue = JSON.parse(a.value);
+            }
+            catch {
+                (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.update_config_error", message: `invalid JSON value for ${a.path}`, meta: { path: a.path, value: a.value } });
+                return `Error: invalid JSON value. Provide value as valid JSON (e.g., 25, "debug", ["terminal"]).`;
+            }
+            // Validate value against registry entry's validator
+            /* v8 ignore next -- all current entries have validators; guard kept for future entries without one @preserve */
+            if (entry.validate) {
+                const validationError = entry.validate(parsedValue);
+                if (validationError) {
+                    (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.update_config_error", message: `validation failed for ${a.path}: ${validationError}`, meta: { path: a.path, value: a.value, validationError } });
+                    return `Error: validation failed for "${a.path}": ${validationError}`;
+                }
+            }
+            // Managed: refuse
+            if (entry.tier === "managed") {
+                (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.update_config_refused", message: `refused managed change to ${a.path}`, meta: { path: a.path, tier: "managed" } });
+                return `This key is managed by the harness and cannot be modified directly.`;
+            }
+            const agentRoot = (0, identity_1.getAgentRoot)();
+            const configPath = path.join(agentRoot, "agent.json");
+            let rawConfig;
+            try {
+                rawConfig = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+            }
+            catch {
+                /* v8 ignore next -- defensive: agent.json read failure in update_config @preserve */
+                return `Error: failed to read agent.json at ${configPath}`;
+            }
+            // Apply change immediately
+            const parts = entry.path.split(".");
+            let target = rawConfig;
+            for (let i = 0; i < parts.length - 1; i++) {
+                if (!(parts[i] in target) || typeof target[parts[i]] !== "object" || target[parts[i]] === null) {
+                    target[parts[i]] = {};
+                }
+                target = target[parts[i]];
+            }
+            target[parts[parts.length - 1]] = parsedValue;
+            fs.writeFileSync(configPath, JSON.stringify(rawConfig, null, 2) + "\n", "utf-8");
+            (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.update_config_applied", message: `applied config change to ${a.path}`, meta: { path: a.path, tier: entry.tier, value: parsedValue } });
+            return `Success: "${a.path}" updated to ${JSON.stringify(parsedValue)}. Change applied immediately.`;
+        },
+        riskProfile: { mutates: "durable_state_write", risk: "high", reason: "writes agent.json" },
+    },
+];