@ouro.bot/cli 0.1.0-alpha.65 → 0.1.0-alpha.651

package/dist/repertoire/skills.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSkillsDir = getSkillsDir;
+exports.getHarnessSkillsDir = getHarnessSkillsDir;
 exports.listSkills = listSkills;
 exports.loadSkill = loadSkill;
 exports.getLoadedSkills = getLoadedSkills;
@@ -42,6 +43,7 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const identity_1 = require("../heart/identity");
 const runtime_1 = require("../nerves/runtime");
+const plugins_1 = require("./plugins");
 // Skills live in {agentRoot}/skills/ directory
 function getSkillsDir() {
     return path.join((0, identity_1.getAgentRoot)(), "skills");
@@ -50,6 +52,10 @@ function getSkillsDir() {
 function getProtocolMirrorDir() {
     return path.join(getSkillsDir(), "protocols");
 }
+// Harness-level skills live in {repoRoot}/skills/ directory.
+function getHarnessSkillsDir() {
+    return path.join((0, identity_1.getRepoRoot)(), "skills");
+}
 function listMarkdownBasenames(dir) {
     if (!fs.existsSync(dir))
         return [];
@@ -59,7 +65,7 @@ function listMarkdownBasenames(dir) {
         .map((f) => path.basename(f, ".md"))
         .sort();
 }
-// in-memory store for loaded skills
+// process-local store for loaded skills
 const loadedSkills = [];
 function listSkills() {
     (0, runtime_1.emitNervesEvent)({
@@ -70,7 +76,14 @@ function listSkills() {
     });
     const baseSkills = listMarkdownBasenames(getSkillsDir());
     const protocolMirrors = listMarkdownBasenames(getProtocolMirrorDir());
-    const skills = [...new Set([...baseSkills, ...protocolMirrors])].sort();
+    const harnessSkills = listMarkdownBasenames(getHarnessSkillsDir());
+    const pluginSkills = (0, plugins_1.listPluginSkills)((0, plugins_1.listEnabledPlugins)());
+    // Agent skills (base + protocol) come first; harness skills are fallback;
+    // plugin skills surface after harness skills. Set deduplicates by name —
+    // agent overrides harness overrides plugins.
+    const skills = [
+        ...new Set([...baseSkills, ...protocolMirrors, ...harnessSkills, ...pluginSkills]),
+    ].sort();
     (0, runtime_1.emitNervesEvent)({
         event: "repertoire.load_end",
         component: "repertoire",
@@ -88,6 +101,7 @@ function loadSkill(skillName) {
     });
     const directSkillPath = path.join(getSkillsDir(), `${skillName}.md`);
     const protocolMirrorPath = path.join(getProtocolMirrorDir(), `${skillName}.md`);
+    const harnessSkillPath = path.join(getHarnessSkillsDir(), `${skillName}.md`);
     let resolvedPath = null;
     // 1) Direct agent skill.
     if (fs.existsSync(directSkillPath)) {
@@ -97,6 +111,35 @@ function loadSkill(skillName) {
     else if (fs.existsSync(protocolMirrorPath)) {
         resolvedPath = protocolMirrorPath;
     }
+    // 3) Harness-level skill (ships with npm package).
+    else if (fs.existsSync(harnessSkillPath)) {
+        resolvedPath = harnessSkillPath;
+    }
+    // 4) Plugin skill fallback. Iterate enabled plugins; first match wins.
+    if (!resolvedPath) {
+        for (const plugin of (0, plugins_1.listEnabledPlugins)()) {
+            try {
+                const content = (0, plugins_1.loadPluginSkill)(plugin.id, skillName);
+                if (!loadedSkills.includes(skillName)) {
+                    loadedSkills.push(skillName);
+                }
+                (0, runtime_1.emitNervesEvent)({
+                    event: "repertoire.load_end",
+                    component: "repertoire",
+                    message: "loaded skill",
+                    meta: {
+                        operation: "loadSkill",
+                        skill: skillName,
+                        path: `plugin:${plugin.id}`,
+                    },
+                });
+                return content;
+            }
+            catch {
+                // try next plugin
+            }
+        }
+    }
     if (!resolvedPath) {
         (0, runtime_1.emitNervesEvent)({
             level: "error",
@@ -106,12 +149,13 @@ function loadSkill(skillName) {
             meta: {
                 operation: "loadSkill",
                 skill: skillName,
-                checkedPaths: [directSkillPath, protocolMirrorPath],
+                checkedPaths: [directSkillPath, protocolMirrorPath, harnessSkillPath],
             },
         });
         throw new Error(`skill '${skillName}' not found in:\n` +
             `- ${directSkillPath}\n` +
-            `- ${protocolMirrorPath}`);
+            `- ${protocolMirrorPath}\n` +
+            `- ${harnessSkillPath}`);
     }
     const content = fs.readFileSync(resolvedPath, "utf-8");
     if (!loadedSkills.includes(skillName)) {

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/tool-results.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.okToolResult = okToolResult;
+exports.frictionToolResult = frictionToolResult;
+const runtime_1 = require("../nerves/runtime");
+function okToolResult(tool, data) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "tools",
+        event: "tool.structured_ok",
+        message: "tool returned structured result",
+        meta: { tool },
+    });
+    return JSON.stringify({ ok: true, tool, data }, null, 2);
+}
+function frictionToolResult(tool, friction) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "tools",
+        event: "tool.structured_friction",
+        message: "tool returned structured result",
+        meta: {
+            tool,
+            kind: friction.kind,
+            recoverability: friction.recoverability,
+            signature: friction.signature,
+        },
+    });
+    return JSON.stringify({ ok: false, tool, friction }, null, 2);
+}

package/dist/repertoire/tools-attachments.js

@@ -0,0 +1,317 @@
+"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.attachmentToolDefinitions = void 0;
+const fs = __importStar(require("node:fs/promises"));
+const identity_1 = require("../heart/identity");
+const provider_credentials_1 = require("../heart/provider-credentials");
+const minimax_1 = require("../heart/providers/minimax");
+const minimax_vlm_1 = require("../heart/providers/minimax-vlm");
+const store_1 = require("../heart/attachments/store");
+const materialize_1 = require("../heart/attachments/materialize");
+const runtime_1 = require("../nerves/runtime");
+const tool_results_1 = require("./tool-results");
+const LIST_ATTACHMENTS_DESCRIPTION = "List the most recent attachments the harness preserved across senses. Use this when you need a stable attachment_id, " +
+    "when a repair flow says an attachment could not be found, or when you want to inspect what artifacts are currently on hand " +
+    "before asking the user to resend anything.";
+const MATERIALIZE_ATTACHMENT_DESCRIPTION = "Materialize an attachment into a concrete file path the harness can inspect or hand to other tools. " +
+    "Use variant=original when you want the raw file. Use variant=vision_safe for images when you want the harness to normalize " +
+    "size and format into a VLM-safe image before retrying.";
+const DESCRIBE_IMAGE_DESCRIPTION = "Use this to inspect an image attachment with a targeted question, or to re-interrogate an image after a wrong first answer. " +
+    "The harness materializes the original attachment, normalizes it into a VLM-safe image when needed, and sends it through the vision-language model. " +
+    "Prefer specific prompts like 'what is the confirmation number?' over 'describe this image'. " +
+    "Pass attachment_id when you have it; attachment_guid is accepted as a compatibility alias.";
+function trimArg(value) {
+    return value?.trim() ?? "";
+}
+function resolveAttachmentId(args) {
+    return trimArg(args.attachment_id) || trimArg(args.attachment_guid);
+}
+function parseLimit(raw) {
+    if (!raw)
+        return undefined;
+    const parsed = Number.parseInt(raw, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0)
+        return undefined;
+    return parsed;
+}
+function normalizeThrownReason(error) {
+    const rendered = String(error);
+    return rendered.startsWith("Error: ") ? rendered.slice(7) : rendered;
+}
+function attachmentNotFound(tool, attachmentId) {
+    const friction = {
+        kind: "local_repair",
+        recoverability: "transformable",
+        summary: `Attachment ${attachmentId} is not in the recent attachment store anymore.`,
+        signature: `${tool}:attachment-not-found`,
+        suggested_next_actions: [
+            {
+                kind: "tool",
+                tool: "list_recent_attachments",
+                reason: "Find the current attachment_id for the artifact you want to inspect before retrying.",
+            },
+        ],
+    };
+    return (0, tool_results_1.frictionToolResult)(tool, friction);
+}
+function missingAttachmentId(tool) {
+    return (0, tool_results_1.frictionToolResult)(tool, {
+        kind: "input_error",
+        recoverability: "transformable",
+        summary: "An attachment id is required for this tool call.",
+        signature: `${tool}:missing-attachment-id`,
+        suggested_next_actions: [
+            {
+                kind: "tool",
+                tool: "list_recent_attachments",
+                reason: "Inspect the current recent attachments and retry with attachment_id.",
+            },
+        ],
+    });
+}
+function missingPrompt() {
+    return (0, tool_results_1.frictionToolResult)("describe_image", {
+        kind: "input_error",
+        recoverability: "transformable",
+        summary: "describe_image needs a targeted prompt before retrying.",
+        signature: "describe_image:missing-prompt",
+        suggested_next_actions: [
+            {
+                kind: "message",
+                message: "Retry with a specific question like 'what is the confirmation number?' or 'what date is shown?'",
+            },
+        ],
+    });
+}
+function normalizeMaterializeError(tool, attachmentId, reason) {
+    if (reason.startsWith("Attachment not found:")) {
+        return attachmentNotFound(tool, attachmentId);
+    }
+    if (reason.includes("is not an image")) {
+        return (0, tool_results_1.frictionToolResult)(tool, {
+            kind: "input_error",
+            recoverability: "transformable",
+            summary: `Attachment ${attachmentId} is not an image, so it cannot produce a vision_safe variant.`,
+            signature: `${tool}:not-image`,
+            suggested_next_actions: [
+                {
+                    kind: "tool",
+                    tool: "materialize_attachment",
+                    reason: "Retry with variant=original if you need the raw file instead.",
+                    args: { attachment_id: attachmentId, variant: "original" },
+                },
+            ],
+        });
+    }
+    return (0, tool_results_1.frictionToolResult)(tool, {
+        kind: "local_repair",
+        recoverability: "retryable",
+        summary: reason,
+        signature: `${tool}:materialize-failed`,
+        suggested_next_actions: [
+            {
+                kind: "tool",
+                tool: "materialize_attachment",
+                reason: "Retry materialization once more in case the file path or normalization target changed.",
+                args: { attachment_id: attachmentId, variant: "vision_safe" },
+            },
+        ],
+    });
+}
+async function buildImageDataUrl(filePath, mimeType) {
+    const buffer = await fs.readFile(filePath);
+    const encoded = buffer.toString("base64");
+    const normalizedMime = mimeType?.trim().toLowerCase() || "image/jpeg";
+    return `data:${normalizedMime};base64,${encoded}`;
+}
+exports.attachmentToolDefinitions = [
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "list_recent_attachments",
+                description: LIST_ATTACHMENTS_DESCRIPTION,
+                parameters: {
+                    type: "object",
+                    properties: {
+                        kind: {
+                            type: "string",
+                            enum: ["image", "audio", "document", "binary", "unknown"],
+                            description: "Optional attachment kind filter.",
+                        },
+                        limit: {
+                            type: "string",
+                            description: "Optional numeric limit for how many attachments to return.",
+                        },
+                    },
+                },
+            },
+        },
+        handler: async (args) => {
+            const agentName = (0, identity_1.getAgentName)();
+            const kind = trimArg(args.kind);
+            const attachments = (0, store_1.listRecentAttachments)(agentName, {
+                kind: kind ? kind : undefined,
+                limit: parseLimit(args.limit),
+            });
+            return (0, tool_results_1.okToolResult)("list_recent_attachments", attachments);
+        },
+        summaryKeys: ["kind", "limit"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "materialize_attachment",
+                description: MATERIALIZE_ATTACHMENT_DESCRIPTION,
+                parameters: {
+                    type: "object",
+                    properties: {
+                        attachment_id: {
+                            type: "string",
+                            description: "Stable attachment id such as attachment:cli-local-file:... or attachment:bluebubbles:...",
+                        },
+                        attachment_guid: {
+                            type: "string",
+                            description: "Compatibility alias for older callers. Prefer attachment_id.",
+                        },
+                        variant: {
+                            type: "string",
+                            enum: ["original", "vision_safe"],
+                            description: "Which attachment variant to materialize.",
+                        },
+                    },
+                    required: ["variant"],
+                },
+            },
+        },
+        handler: async (args) => {
+            const attachmentId = resolveAttachmentId(args);
+            if (!attachmentId) {
+                return missingAttachmentId("materialize_attachment");
+            }
+            const agentName = (0, identity_1.getAgentName)();
+            const variant = trimArg(args.variant) === "vision_safe" ? "vision_safe" : "original";
+            try {
+                const materialized = await (0, materialize_1.materializeAttachment)(agentName, attachmentId, { variant });
+                return (0, tool_results_1.okToolResult)("materialize_attachment", materialized);
+            }
+            catch (error) {
+                const reason = normalizeThrownReason(error);
+                return normalizeMaterializeError("materialize_attachment", attachmentId, reason);
+            }
+        },
+        summaryKeys: ["attachment_id", "attachment_guid", "variant"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "describe_image",
+                description: DESCRIBE_IMAGE_DESCRIPTION,
+                parameters: {
+                    type: "object",
+                    properties: {
+                        attachment_id: {
+                            type: "string",
+                            description: "Stable attachment id for the image you want to inspect.",
+                        },
+                        attachment_guid: {
+                            type: "string",
+                            description: "Compatibility alias for older callers. Prefer attachment_id.",
+                        },
+                        prompt: {
+                            type: "string",
+                            description: "A targeted question about the image.",
+                        },
+                    },
+                    required: ["prompt"],
+                },
+            },
+        },
+        handler: async (args) => {
+            const attachmentId = resolveAttachmentId(args);
+            if (!attachmentId) {
+                return missingAttachmentId("describe_image");
+            }
+            const prompt = trimArg(args.prompt);
+            if (!prompt) {
+                return missingPrompt();
+            }
+            const agentName = (0, identity_1.getAgentName)();
+            try {
+                const materialized = await (0, materialize_1.materializeAttachment)(agentName, attachmentId, { variant: "vision_safe" });
+                const imageDataUrl = await buildImageDataUrl(materialized.path, materialized.mimeType);
+                const credential = await (0, provider_credentials_1.readProviderCredentialRecord)(agentName, "minimax");
+                const apiKey = credential.ok ? credential.record.credentials.apiKey : undefined;
+                if (!apiKey) {
+                    return (0, tool_results_1.frictionToolResult)("describe_image", {
+                        kind: "external_blocker",
+                        recoverability: "blocked",
+                        summary: "MiniMax credentials are missing, so image understanding is unavailable until credentials are fixed.",
+                        signature: "describe_image:minimax-missing-key",
+                        suggested_next_actions: [
+                            {
+                                kind: "message",
+                                message: "Run `ouro auth --agent <agent> --provider minimax`, then retry describe_image.",
+                            },
+                        ],
+                    });
+                }
+                const description = await (0, minimax_vlm_1.minimaxVlmDescribe)({
+                    apiKey: String(apiKey),
+                    prompt,
+                    imageDataUrl,
+                    baseURL: minimax_1.MINIMAX_PROVIDER_BASE_URL,
+                    attachmentGuid: attachmentId,
+                    mimeType: materialized.mimeType,
+                });
+                (0, runtime_1.emitNervesEvent)({
+                    component: "tools",
+                    event: "tool.describe_image_success",
+                    message: "describe_image returned a description",
+                    meta: { attachmentId },
+                });
+                return description;
+            }
+            catch (error) {
+                const reason = normalizeThrownReason(error);
+                return normalizeMaterializeError("describe_image", attachmentId, reason);
+            }
+        },
+        summaryKeys: ["attachment_id", "attachment_guid", "prompt"],
+    },
+];