@ouro.bot/cli 0.1.0-alpha.83 → 0.1.0-alpha.831

package/dist/repertoire/tools-shell.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shellToolDefinitions = void 0;
+const child_process_1 = require("child_process");
+const shell_sessions_1 = require("./shell-sessions");
+const identity_1 = require("../heart/identity");
+const runtime_1 = require("../nerves/runtime");
+const tool_arguments_1 = require("./tool-arguments");
+function shellOwner(ctx) {
+    (0, tool_arguments_1.assertRelationshipToolOwner)(ctx);
+    const agentName = ctx?.agentName ?? (0, identity_1.getAgentName)();
+    return { agentName, agentRoot: ctx?.agentRoot ?? (0, identity_1.getAgentRoot)(agentName) };
+}
+exports.shellToolDefinitions = [
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "shell",
+                description: "Run a shell command and return stdout/stderr. Each call starts in the runtime's working directory; cd does not persist between calls. Use dedicated tools instead of shell when available: read_file instead of cat, edit_file instead of sed, glob instead of find, grep instead of grep/rg. Reserve shell for operations that genuinely need the shell: installing packages, running builds/tests, git operations, process management. Be careful with destructive commands -- consider reversibility before running. If a command fails, read the error output before retrying with a different approach.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        command: { type: "string" },
+                        timeout_ms: {
+                            type: "number",
+                            description: "Timeout in milliseconds. Default: 30000. Max: 600000.",
+                        },
+                        background: {
+                            type: "boolean",
+                            description: "Run in background and return immediately with a process ID. Records belong to the initiating agent and live only in process memory. Use separately authorized shell_status/shell_tail calls to monitor. Revocation does not kill a started process; runtime restart loses its record.",
+                        },
+                    },
+                    required: ["command"],
+                    additionalProperties: false,
+                },
+            },
+        },
+        approvalPolicy: (args) => {
+            const command = typeof args.command === "string" ? args.command.trim().split(/\s+/) : [];
+            if (command[0] === "docker" && command[1] === "restart" && command.length > 2) {
+                return {
+                    kind: "required",
+                    policyId: "shell.docker-lifecycle.v1",
+                    actionClass: "service-control",
+                    requiresSoleCall: true,
+                };
+            }
+            return { kind: "not_required" };
+        },
+        handler: (a, ctx) => {
+            (0, tool_arguments_1.assertRelationshipToolOwner)(ctx);
+            // Destructive pattern detection (friction, not a block)
+            const destructivePatterns = (0, shell_sessions_1.detectDestructivePatterns)(a.command);
+            if (destructivePatterns.length > 0) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    event: "tool.shell.destructive_detected",
+                    component: "tools",
+                    message: `destructive pattern detected: ${destructivePatterns.join(", ")}`,
+                    meta: { command: a.command, patterns: destructivePatterns },
+                });
+            }
+            // Background mode: spawn and return immediately
+            if (a.background === true) {
+                const session = (0, shell_sessions_1.spawnBackgroundShell)(a.command, shellOwner(ctx));
+                return JSON.stringify({ id: session.id, command: session.command, status: session.status });
+            }
+            const MAX_TIMEOUT = 600000;
+            const requestedTimeout = Number(a.timeout_ms) || 0;
+            let configDefault = 30000;
+            const owner = ctx?.agentName !== undefined || ctx?.agentRoot !== undefined ? shellOwner(ctx) : undefined;
+            try {
+                configDefault = (0, identity_1.loadAgentConfig)(owner).shell?.defaultTimeout ?? 30000;
+            }
+            catch (error) {
+                if (owner)
+                    throw error;
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn", component: "tools", event: "tool.shell_config_unavailable",
+                    message: "legacy shell caller has no configuration; using the default timeout",
+                    meta: { fallbackTimeout: configDefault },
+                });
+            }
+            const baseTimeout = requestedTimeout > 0 ? requestedTimeout : configDefault;
+            const timeout = Math.min(baseTimeout, MAX_TIMEOUT);
+            const output = (0, child_process_1.execSync)(a.command, {
+                encoding: "utf-8",
+                timeout,
+            });
+            if (destructivePatterns.length > 0) {
+                return `${output}\n\n--- destructive pattern detected: ${destructivePatterns.join(", ")} ---`;
+            }
+            return output;
+        },
+        summaryKeys: ["command"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "shell_status",
+                description: "Check separately authorized status of background shell processes owned by this agent. Omit id to list this agent's records. Records live only in process memory; runtime restart loses observability, and revoked access does not kill a started process.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        id: { type: "string", description: "Background shell process ID" },
+                    },
+                },
+            },
+        },
+        handler: (a, ctx) => {
+            if (!a.id) {
+                return JSON.stringify((0, shell_sessions_1.listShellSessions)(shellOwner(ctx)));
+            }
+            const session = (0, shell_sessions_1.getShellSession)(a.id, shellOwner(ctx));
+            if (!session)
+                return `process not found: ${a.id}`;
+            return JSON.stringify(session);
+        },
+        summaryKeys: ["id"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "shell_tail",
+                description: "Show recent output from a background shell process owned by this agent. Access is reauthorized on each call. Revocation does not kill a started process, and runtime restart loses the in-memory record.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        id: { type: "string", description: "Background shell process ID" },
+                    },
+                    required: ["id"],
+                },
+            },
+        },
+        handler: (a, ctx) => {
+            /* v8 ignore next -- schema requires id, defensive guard @preserve */
+            if (!a.id)
+                return "id is required";
+            const output = (0, shell_sessions_1.tailShellSession)(a.id, shellOwner(ctx));
+            if (output === undefined)
+                return `process not found: ${a.id}`;
+            return output || "(no output yet)";
+        },
+        summaryKeys: ["id"],
+    },
+];

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

@@ -0,0 +1,119 @@
+"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. 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"] },
+                    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" },
+                    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;
+        const sessionKey = ctx.currentSession?.key;
+        if (trustLevel !== "family" || profileId !== "sanctuary-owner" || typeof requestId !== "string" || !requestId.trim()
+            || typeof sessionKey !== "string" || !sessionKey.trim() || !sessionEventId.trim()
+            || ctx.currentSession?.friendId !== friendId || ctx.currentSession.channel !== "telegram" || ctx.currentExternalEvent) {
+            throw new Error("steward policy mutation requires a current authenticated owner Telegram request and session");
+        }
+        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: args.source ?? "", ...(args.expiresAt ? { expiresAt: args.expiresAt } : {}) };
+        }
+        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?.friendId !== friendId || ctx.currentSession.key !== sessionKey || ctx.currentSession.channel !== "telegram" || ctx.currentExternalEvent) {
+                throw new Error("steward policy owner authorization or session changed before mutation");
+            }
+            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 } },
+                mutation,
+            });
+            (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.steward_policy_tool_call", message: "updated steward policy", meta: { action: args.action } });
+            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;
+}