@ouro.bot/cli 0.1.0-alpha.231 → 0.1.0-alpha.234

package/dist/repertoire/mcp-tools.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * First-class MCP tool integration — converts MCP server tools into ToolDefinitions
+ * so the model can call them directly without shell indirection.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mcpToolsAsDefinitions = mcpToolsAsDefinitions;
+const runtime_1 = require("../nerves/runtime");
+/**
+ * Convert all tools from an McpManager into ToolDefinition objects.
+ * Each tool gets named `{server}_{tool}` (e.g., `browser_navigate`).
+ * The handler calls `mcpManager.callTool()` and returns concatenated text content.
+ */
+function mcpToolsAsDefinitions(mcpManager) {
+    if (!mcpManager)
+        return [];
+    return mcpManager.listAllTools().flatMap((entry) => entry.tools.map((tool) => ({
+        tool: {
+            type: "function",
+            function: {
+                name: `${entry.server}_${tool.name}`,
+                description: tool.description || `MCP tool: ${tool.name} (server: ${entry.server})`,
+                parameters: tool.inputSchema ?? { type: "object", properties: {} },
+            },
+        },
+        handler: async (args) => {
+            (0, runtime_1.emitNervesEvent)({
+                event: "mcp.tool_start",
+                component: "repertoire",
+                message: `calling MCP tool ${entry.server}/${tool.name}`,
+                meta: { server: entry.server, tool: tool.name },
+            });
+            try {
+                const result = await mcpManager.callTool(entry.server, tool.name, args);
+                const text = result.content
+                    .filter((c) => c.type === "text" && c.text)
+                    .map((c) => c.text)
+                    .join("");
+                (0, runtime_1.emitNervesEvent)({
+                    event: "mcp.tool_end",
+                    component: "repertoire",
+                    message: `MCP tool ${entry.server}/${tool.name} completed`,
+                    meta: { server: entry.server, tool: tool.name },
+                });
+                return text;
+            }
+            catch (error) {
+                const reason = error instanceof Error ? error.message : String(error);
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    event: "mcp.tool_error",
+                    component: "repertoire",
+                    message: `MCP tool ${entry.server}/${tool.name} failed: ${reason}`,
+                    meta: { server: entry.server, tool: tool.name, reason },
+                });
+                return `[mcp error] ${entry.server}/${tool.name}: ${reason}`;
+            }
+        },
+        mcpServer: entry.server,
+    })));
+}

package/dist/repertoire/tools-base.js

@@ -10,6 +10,7 @@ const tools_continuity_1 = require("./tools-continuity");
 const tools_config_1 = require("./tools-config");
 const tools_1 = require("./coding/tools");
 const tools_credential_1 = require("./tools-credential");
+const tools_vault_1 = require("./tools-vault");
 const tools_travel_1 = require("./tools-travel");
 // Re-export flow tools for consumers that import them from tools-base
 var tools_flow_1 = require("./tools-flow");
@@ -35,6 +36,7 @@ exports.baseToolDefinitions = [
     ...tools_config_1.configToolDefinitions,
     ...tools_1.codingToolDefinitions,
     ...tools_credential_1.credentialToolDefinitions,
+    ...tools_vault_1.vaultToolDefinitions,
     ...tools_travel_1.travelToolDefinitions,
 ];
 // Convenience array of just the tool schemas (no handler/integration metadata).

package/dist/repertoire/tools-credential.js

@@ -95,7 +95,6 @@ exports.credentialToolDefinitions = [
                 return `Credential store error: ${err instanceof Error ? err.message : String(err)}`;
             }
         },
-        confirmationRequired: true,
         summaryKeys: ["domain"],
     },
     {
@@ -178,7 +177,6 @@ exports.credentialToolDefinitions = [
                 return `Credential delete error: ${err instanceof Error ? err.message : String(err)}`;
             }
         },
-        confirmationRequired: true,
         summaryKeys: ["domain"],
     },
 ];

package/dist/repertoire/tools-vault.js

@@ -0,0 +1,110 @@
+"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.vaultToolDefinitions = void 0;
+const crypto = __importStar(require("node:crypto"));
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const identity_1 = require("../heart/identity");
+const vault_setup_1 = require("./vault-setup");
+const runtime_1 = require("../nerves/runtime");
+exports.vaultToolDefinitions = [
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "vault_setup",
+                description: "Set up the agent's credential vault. Creates a Bitwarden account on the configured Vaultwarden server. One-time operation — idempotent if vault already exists.",
+                parameters: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+        },
+        handler: async () => {
+            const agentName = (0, identity_1.getAgentName)();
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.vault_tool_call",
+                message: "vault_setup invoked",
+                meta: { tool: "vault_setup", agentName },
+            });
+            try {
+                const config = (0, identity_1.loadAgentConfig)();
+                const { email, serverUrl } = (0, identity_1.resolveVaultConfig)(agentName, config.vault);
+                // Generate a strong random master password (32 bytes -> base64)
+                const masterPassword = crypto.randomBytes(32).toString("base64");
+                // Store master password in secrets.json BEFORE creating the account
+                // so it's not lost if the process crashes after registration
+                const secretsPath = (0, identity_1.getAgentSecretsPath)(agentName);
+                const secretsDir = path.dirname(secretsPath);
+                if (!fs.existsSync(secretsDir)) {
+                    fs.mkdirSync(secretsDir, { recursive: true, mode: 0o700 });
+                }
+                let secrets = {};
+                if (fs.existsSync(secretsPath)) {
+                    try {
+                        secrets = JSON.parse(fs.readFileSync(secretsPath, "utf-8"));
+                    }
+                    catch {
+                        // If secrets.json is corrupt, start fresh but don't lose the file
+                        secrets = {};
+                    }
+                }
+                secrets.vault = {
+                    ...(typeof secrets.vault === "object" && secrets.vault !== null ? secrets.vault : {}),
+                    masterPassword,
+                    email,
+                    serverUrl,
+                };
+                fs.writeFileSync(secretsPath, JSON.stringify(secrets, null, 2) + "\n", {
+                    mode: 0o600,
+                });
+                // Create the vault account
+                const result = await (0, vault_setup_1.createVaultAccount)(agentName, serverUrl, email, masterPassword);
+                if (!result.success) {
+                    return `Vault setup failed: ${result.error}`;
+                }
+                return `Vault created at ${serverUrl} for ${email}. Master password stored in secrets.json.`;
+            }
+            catch (err) {
+                /* v8 ignore next -- defensive: error handling @preserve */
+                const reason = err instanceof Error ? err.message : String(err);
+                return `Vault setup error: ${reason}`;
+            }
+        },
+        summaryKeys: [],
+    },
+];

package/dist/repertoire/tools.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.surfaceToolDef = exports.restTool = exports.ponderTool = exports.observeTool = exports.settleTool = exports.tools = void 0;
+exports.resetMcpDefinitions = resetMcpDefinitions;
 exports.getToolsForChannel = getToolsForChannel;
 exports.isConfirmationRequired = isConfirmationRequired;
 exports.isConfirmationAlwaysRequired = isConfirmationAlwaysRequired;
@@ -16,6 +17,7 @@ const runtime_1 = require("../nerves/runtime");
 const guardrails_1 = require("./guardrails");
 const identity_1 = require("../heart/identity");
 const tools_surface_1 = require("./tools-surface");
+const mcp_tools_1 = require("./mcp-tools");
 function safeGetAgentRoot() {
     try {
         return (0, identity_1.getAgentRoot)();
@@ -36,6 +38,13 @@ var tools_surface_2 = require("./tools-surface");
 Object.defineProperty(exports, "surfaceToolDef", { enumerable: true, get: function () { return tools_surface_2.surfaceToolDef; } });
 // All tool definitions in a single registry
 const allDefinitions = [...tools_base_1.baseToolDefinitions, ...tools_bluebubbles_1.bluebubblesToolDefinitions, ...tools_teams_1.teamsToolDefinitions, ...ado_semantic_1.adoSemanticToolDefinitions, ...tools_github_1.githubToolDefinitions, tools_surface_1.surfaceToolDefinition];
+// MCP tool definitions — populated each time getToolsForChannel() is called with an mcpManager.
+// Kept separate from allDefinitions so execTool/isConfirmation* can find them.
+let mcpDefinitions = [];
+/** Exported for testing — reset the MCP definitions cache. */
+function resetMcpDefinitions() {
+    mcpDefinitions = [];
+}
 function baseToolsForCapabilities() {
     // Use baseToolDefinitions at call time so dynamically-added tools are included
     return tools_base_1.baseToolDefinitions.map((d) => d.tool);
@@ -66,7 +75,7 @@ function filterByCapability(toolList, providerCapabilities) {
 // Teams/integration tools are included only if their integration is in availableIntegrations.
 // When toolPreferences is provided, matching preferences are appended to tool descriptions.
 // When providerCapabilities is provided, tools with requiredCapability are filtered.
-function getToolsForChannel(capabilities, toolPreferences, _context, providerCapabilities) {
+function getToolsForChannel(capabilities, toolPreferences, _context, providerCapabilities, mcpManager) {
     const baseTools = baseToolsForCapabilities();
     const bluebubblesTools = capabilities?.channel === "bluebubbles"
         ? tools_bluebubbles_1.bluebubblesToolDefinitions.map((d) => d.tool)
@@ -98,18 +107,29 @@ function getToolsForChannel(capabilities, toolPreferences, _context, providerCap
             result = [...baseTools, ...bluebubblesTools, ...enrichedIntegrationTools];
         }
     }
+    // Append first-class MCP tools when mcpManager is provided
+    if (mcpManager) {
+        mcpDefinitions = (0, mcp_tools_1.mcpToolsAsDefinitions)(mcpManager);
+        const mcpSchemas = mcpDefinitions.map((d) => d.tool);
+        result = [...result, ...mcpSchemas];
+    }
     return filterByCapability(result, providerCapabilities);
 }
+// Look up a tool definition from the combined registry (native + MCP).
+function findDefinition(toolName) {
+    return allDefinitions.find((d) => d.tool.function.name === toolName)
+        ?? mcpDefinitions.find((d) => d.tool.function.name === toolName);
+}
 // Check whether a tool requires user confirmation before execution.
 // Reads from ToolDefinition.confirmationRequired instead of a separate Set.
 function isConfirmationRequired(toolName) {
-    const def = allDefinitions.find((d) => d.tool.function.name === toolName);
+    const def = findDefinition(toolName);
     return def?.confirmationRequired === true;
 }
 // Check whether a tool's confirmation is non-bypassable (cannot be skipped by skipConfirmation).
 // Used for T2 config proposals that must always require operator approval.
 function isConfirmationAlwaysRequired(toolName) {
-    const def = allDefinitions.find((d) => d.tool.function.name === toolName);
+    const def = findDefinition(toolName);
     return def?.confirmationAlwaysRequired === true;
 }
 function normalizeGuardArgs(_name, args) {
@@ -122,8 +142,8 @@ async function execTool(name, args, ctx) {
         message: "tool execution started",
         meta: { name, ...(name === "shell" && args.command ? { command: args.command } : {}) },
     });
-    // Look up from combined registry
-    const def = allDefinitions.find((d) => d.tool.function.name === name);
+    // Look up from combined registry (native + MCP)
+    const def = findDefinition(name);
     if (!def) {
         (0, runtime_1.emitNervesEvent)({
             level: "error",
@@ -135,10 +155,13 @@ async function execTool(name, args, ctx) {
         return `unknown: ${name}`;
     }
     // Guardrail check: structural + trust-level
+    const mcpDef = mcpDefinitions.find((d) => d.tool.function.name === name);
     const guardContext = {
         readPaths: tools_base_1.editFileReadTracker,
         trustLevel: ctx?.context?.friend?.trustLevel,
         agentRoot: safeGetAgentRoot(),
+        ...(mcpDef?.mcpServer ? { mcpServerName: mcpDef.mcpServer } : {}),
+        ...(ctx?.context?.isGroupChat !== undefined ? { isGroupChat: (ctx?.context).isGroupChat } : {}),
     };
     const guardArgs = normalizeGuardArgs(name, args);
     const guardResult = (0, guardrails_1.guardInvocation)(name, guardArgs, guardContext);
@@ -194,7 +217,7 @@ function summarizeUnknownArgs(args) {
     return summarizeKeyValues(args, keys);
 }
 function summarizeArgs(name, args) {
-    const def = allDefinitions.find((d) => d.tool.function.name === name);
+    const def = findDefinition(name);
     if (def && def.summaryKeys !== undefined) {
         return summarizeKeyValues(args, def.summaryKeys);
     }

package/dist/repertoire/travel-api-client.js

@@ -11,6 +11,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TRAVEL_ADVISORY_RSS_URL = void 0;
 exports.getWeather = getWeather;
 exports.getWeatherByCity = getWeatherByCity;
+exports.isoToCountryName = isoToCountryName;
 exports.parseAdvisoryLevel = parseAdvisoryLevel;
 exports.parseCountryName = parseCountryName;
 exports.parseAdvisoryText = parseAdvisoryText;
@@ -69,6 +70,49 @@ function parseWeatherResponse(data) {
  * Returns XML/RSS with per-country advisory items.
  */
 exports.TRAVEL_ADVISORY_RSS_URL = "https://travel.state.gov/_res/rss/TAsTWs.xml";
+/**
+ * Mapping of ISO 3166-1 alpha-2 codes to country names, ONLY for codes
+ * where ISO differs from FIPS 10-4 (which the State Dept RSS feed uses).
+ *
+ * The RSS feed Country-Tag uses FIPS codes. Callers typically pass ISO codes.
+ * When the codes match (e.g. AF for Afghanistan), no lookup is needed.
+ * This table handles the ~30 codes where they diverge.
+ */
+const ISO_FIPS_DIVERGENCE = {
+    AT: "Austria", // FIPS: AU
+    AU: "Australia", // FIPS: AS
+    BD: "Bangladesh", // FIPS: BG
+    BN: "Brunei", // FIPS: BX
+    BO: "Bolivia", // FIPS: BL
+    CH: "Switzerland", // FIPS: SZ
+    CZ: "Czechia", // FIPS: EZ
+    DE: "Germany", // FIPS: GM
+    ES: "Spain", // FIPS: SP
+    FI: "Finland", // FIPS: FI → same, but title might say "Finland"
+    GQ: "Equatorial Guinea", // FIPS: EK
+    HR: "Croatia", // FIPS: HR → same
+    IE: "Ireland", // FIPS: EI
+    KP: "North Korea", // FIPS: KN
+    KR: "South Korea", // FIPS: KS
+    LT: "Lithuania", // FIPS: LH
+    MM: "Burma", // FIPS: BM (State Dept uses "Burma (Myanmar)")
+    NO: "Norway", // FIPS: NO → same
+    PH: "Philippines", // FIPS: RP
+    RO: "Romania", // FIPS: RO → same
+    SE: "Sweden", // FIPS: SW
+    TL: "Timor-Leste", // FIPS: TT
+    TW: "Taiwan", // FIPS: TW → same
+    VA: "Holy See", // FIPS: VT
+    YE: "Yemen", // FIPS: YM
+};
+/**
+ * Look up the expected country name for an ISO alpha-2 code,
+ * but ONLY when that code diverges from the FIPS code used in the RSS feed.
+ * Returns undefined for codes where ISO == FIPS (no title fallback needed).
+ */
+function isoToCountryName(isoCode) {
+    return ISO_FIPS_DIVERGENCE[isoCode.toUpperCase()];
+}
 /**
  * Parse advisory level (1-4) from an RSS item title like
  * "Afghanistan - Level 4: Do Not Travel"
@@ -103,31 +147,53 @@ async function getTravelAdvisory(countryCode) {
             throw new Error(`Travel advisory API error: ${res.status} ${res.statusText}`);
         }
         const xml = await res.text();
+        const upperCode = countryCode.toUpperCase();
+        // When the caller's ISO code diverges from FIPS, we need a title-based fallback.
+        const expectedCountryName = isoToCountryName(upperCode);
         // Parse RSS items via regex (no XML parser dependency needed).
         // Each <item> contains <title>, <pubDate>, and <category domain="Country-Tag">.
         const itemPattern = /<item>([\s\S]*?)<\/item>/g;
+        let titleFallbackMatch = null;
         let match;
         while ((match = itemPattern.exec(xml)) !== null) {
             const block = match[1];
-            // Extract country tag from <category domain="Country-Tag">XX</category>
-            const tagMatch = block.match(/<category\s+domain="Country-Tag">(.*?)<\/category>/);
-            const tag = tagMatch?.[1]?.trim().toUpperCase();
-            // The RSS feed uses FIPS country codes (e.g. "AF" for Afghanistan),
-            // which sometimes differ from ISO 3166. Try exact match first.
-            if (tag !== countryCode.toUpperCase())
-                continue;
             const titleMatch = block.match(/<title>(.*?)<\/title>/);
             const title = titleMatch?.[1] ?? "";
             const pubDateMatch = block.match(/<pubDate>(.*?)<\/pubDate>/);
             const pubDate = pubDateMatch?.[1]?.trim() ?? "";
-            return {
-                countryCode,
-                countryName: parseCountryName(title),
-                advisoryLevel: parseAdvisoryLevel(title),
-                advisoryText: parseAdvisoryText(title),
-                lastUpdated: pubDate,
-            };
+            // Extract country tag from <category domain="Country-Tag">XX</category>
+            const tagMatch = block.match(/<category\s+domain="Country-Tag">(.*?)<\/category>/);
+            const tag = tagMatch?.[1]?.trim().toUpperCase();
+            // Primary match: FIPS tag matches the requested code directly.
+            // Skip this path when the caller's ISO code is known to diverge from FIPS —
+            // e.g. ISO "ES" = Spain, but FIPS "ES" = El Salvador. In that case, only
+            // the title-based fallback should match.
+            if (tag === upperCode && !expectedCountryName) {
+                return {
+                    countryCode,
+                    countryName: parseCountryName(title),
+                    advisoryLevel: parseAdvisoryLevel(title),
+                    advisoryText: parseAdvisoryText(title),
+                    lastUpdated: pubDate,
+                };
+            }
+            // Title-based match: when ISO differs from FIPS, match by country name.
+            // Uses startsWith to handle names like "Burma (Myanmar)" matching "Burma".
+            if (expectedCountryName && !titleFallbackMatch) {
+                const titleCountry = parseCountryName(title);
+                if (titleCountry.toLowerCase().startsWith(expectedCountryName.toLowerCase())) {
+                    titleFallbackMatch = {
+                        countryCode,
+                        countryName: titleCountry,
+                        advisoryLevel: parseAdvisoryLevel(title),
+                        advisoryText: parseAdvisoryText(title),
+                        lastUpdated: pubDate,
+                    };
+                }
+            }
         }
+        if (titleFallbackMatch)
+            return titleFallbackMatch;
         throw new Error(`No travel advisory found for country code "${countryCode}"`);
     });
 }

package/dist/repertoire/vault-setup.js

@@ -0,0 +1,241 @@
+"use strict";
+/**
+ * Vault setup module — Bitwarden/Vaultwarden account creation.
+ *
+ * Implements the Bitwarden registration protocol using Node.js crypto:
+ * - PBKDF2-SHA256 for master key derivation
+ * - HKDF-SHA256 for key stretching
+ * - AES-256-CBC for symmetric key protection
+ * - RSA-2048 keypair for asymmetric encryption
+ *
+ * All crypto follows the Bitwarden security whitepaper:
+ * https://bitwarden.com/help/bitwarden-security-white-paper/
+ */
+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.deriveMasterKey = deriveMasterKey;
+exports.deriveMasterPasswordHash = deriveMasterPasswordHash;
+exports.deriveStretchedMasterKey = deriveStretchedMasterKey;
+exports.makeProtectedSymmetricKey = makeProtectedSymmetricKey;
+exports.createVaultAccount = createVaultAccount;
+const crypto = __importStar(require("node:crypto"));
+const runtime_1 = require("../nerves/runtime");
+// ---------------------------------------------------------------------------
+// Crypto primitives
+// ---------------------------------------------------------------------------
+/**
+ * Derive the master key from password and email using PBKDF2-SHA256.
+ * Email is lowercased and used as the salt per Bitwarden spec.
+ */
+function deriveMasterKey(password, email, iterations) {
+    return new Promise((resolve, reject) => {
+        crypto.pbkdf2(password, email.toLowerCase(), iterations, 32, "sha256", (err, key) => {
+            /* v8 ignore next -- defensive: pbkdf2 rejects on invalid input @preserve */
+            if (err)
+                reject(err);
+            else
+                resolve(key);
+        });
+    });
+}
+/**
+ * Derive the master password hash: PBKDF2-SHA256(masterKey, password, 1 iteration).
+ * This hash is sent to the server for authentication — it never sees the master key.
+ */
+function deriveMasterPasswordHash(masterKey, password) {
+    return new Promise((resolve, reject) => {
+        crypto.pbkdf2(masterKey, password, 1, 32, "sha256", (err, hash) => {
+            /* v8 ignore next -- defensive: pbkdf2 rejects on invalid input @preserve */
+            if (err)
+                reject(err);
+            else
+                resolve(hash.toString("base64"));
+        });
+    });
+}
+/**
+ * Stretch the master key using HKDF-Expand-only (RFC 5869 §2.3) to produce a 64-byte key.
+ * First 32 bytes = encryption key, last 32 bytes = MAC key.
+ *
+ * CRITICAL: Bitwarden uses HKDF-Expand ONLY (no Extract step).
+ * Node.js crypto.hkdfSync() does Extract+Expand which produces DIFFERENT output.
+ * Reference: https://github.com/bitwarden/sdk-internal/blob/main/crates/bitwarden-crypto/src/util.rs
+ * Bitwarden calls Hkdf::<Sha256>::from_prk(masterKey).expand(info, output) — Expand only.
+ */
+function deriveStretchedMasterKey(masterKey) {
+    const encKey = hkdfExpandOnly(masterKey, "enc", 32);
+    const macKey = hkdfExpandOnly(masterKey, "mac", 32);
+    return Buffer.concat([encKey, macKey]);
+}
+/**
+ * HKDF-Expand only (RFC 5869 §2.3) — no Extract step.
+ * Matches Bitwarden's Hkdf::from_prk(prk).expand(info).
+ */
+function hkdfExpandOnly(prk, info, length) {
+    const hashLen = 32; // SHA-256
+    const n = Math.ceil(length / hashLen);
+    let okm = Buffer.alloc(0);
+    let t = Buffer.alloc(0);
+    for (let i = 1; i <= n; i++) {
+        t = crypto.createHmac("sha256", prk)
+            .update(Buffer.concat([t, Buffer.from(info, "utf8"), Buffer.from([i])]))
+            .digest();
+        okm = Buffer.concat([okm, t]);
+    }
+    return okm.subarray(0, length);
+}
+/**
+ * Encrypt data with AES-256-CBC and HMAC-SHA256 MAC.
+ * Returns a Bitwarden "type 2" cipherstring: "2.<iv>|<ct>|<mac>"
+ */
+function encryptWithStretchedKey(data, stretchedKey) {
+    const encKey = stretchedKey.subarray(0, 32);
+    const macKey = stretchedKey.subarray(32, 64);
+    const iv = crypto.randomBytes(16);
+    const cipher = crypto.createCipheriv("aes-256-cbc", encKey, iv);
+    const ct = Buffer.concat([cipher.update(data), cipher.final()]);
+    // MAC covers iv + ct
+    const mac = crypto.createHmac("sha256", macKey)
+        .update(iv)
+        .update(ct)
+        .digest();
+    return `2.${iv.toString("base64")}|${ct.toString("base64")}|${mac.toString("base64")}`;
+}
+/**
+ * Generate a 64-byte symmetric key, encrypt it with the stretched master key.
+ * Returns the "protected symmetric key" cipherstring.
+ */
+function makeProtectedSymmetricKey(stretchedMasterKey) {
+    const symKey = crypto.randomBytes(64);
+    return encryptWithStretchedKey(symKey, stretchedMasterKey);
+}
+/**
+ * Generate an RSA-2048 keypair.
+ * Returns { publicKey: base64-DER, privateKeyDer: Buffer }.
+ */
+function generateRsaKeypair() {
+    const { publicKey, privateKey } = crypto.generateKeyPairSync("rsa", {
+        modulusLength: 2048,
+        publicKeyEncoding: { type: "spki", format: "der" },
+        privateKeyEncoding: { type: "pkcs8", format: "der" },
+    });
+    return {
+        publicKeyB64: publicKey.toString("base64"),
+        privateKeyDer: privateKey,
+    };
+}
+// ---------------------------------------------------------------------------
+// Registration
+// ---------------------------------------------------------------------------
+const KDF_PBKDF2 = 0;
+const KDF_ITERATIONS = 600000;
+/**
+ * Create a Bitwarden account on the configured Vaultwarden server.
+ * Uses the Bitwarden registration API with standard KDF implementation.
+ */
+async function createVaultAccount(agentName, serverUrl, email, masterPassword) {
+    (0, runtime_1.emitNervesEvent)({
+        event: "repertoire.vault_setup_start",
+        component: "repertoire",
+        message: `creating vault account for ${agentName}`,
+        meta: { agentName, serverUrl, email },
+    });
+    try {
+        // Step 1: Derive keys
+        const masterKey = await deriveMasterKey(masterPassword, email, KDF_ITERATIONS);
+        const masterPasswordHash = await deriveMasterPasswordHash(masterKey, masterPassword);
+        const stretchedKey = deriveStretchedMasterKey(masterKey);
+        // Step 2: Generate symmetric key (64 bytes = 32 enc + 32 mac), encrypt with stretched key
+        const symKey = crypto.randomBytes(64);
+        const protectedSymKey = encryptWithStretchedKey(symKey, stretchedKey);
+        // Step 3: Generate RSA keypair, encrypt private key with the symmetric key
+        const { publicKeyB64, privateKeyDer } = generateRsaKeypair();
+        const encryptedPrivateKey = encryptWithStretchedKey(privateKeyDer, symKey);
+        // Step 4: POST registration
+        const res = await fetch(`${serverUrl}/api/accounts/register`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                name: agentName,
+                email,
+                masterPasswordHash,
+                masterPasswordHint: null,
+                key: protectedSymKey,
+                kdf: KDF_PBKDF2,
+                kdfIterations: KDF_ITERATIONS,
+                keys: {
+                    publicKey: publicKeyB64,
+                    encryptedPrivateKey,
+                },
+            }),
+        });
+        if (!res.ok) {
+            let errorDetail;
+            try {
+                const body = await res.json();
+                errorDetail = body.message ?? `HTTP ${res.status} ${res.statusText}`;
+            }
+            catch {
+                errorDetail = `HTTP ${res.status} ${res.statusText}`;
+            }
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "repertoire.vault_setup_error",
+                component: "repertoire",
+                message: `vault registration failed: ${errorDetail}`,
+                meta: { agentName, serverUrl, email, reason: errorDetail },
+            });
+            return { success: false, email, serverUrl, error: errorDetail };
+        }
+        (0, runtime_1.emitNervesEvent)({
+            event: "repertoire.vault_setup_end",
+            component: "repertoire",
+            message: `vault account created for ${agentName}`,
+            meta: { agentName, serverUrl, email },
+        });
+        return { success: true, email, serverUrl };
+    }
+    catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "repertoire.vault_setup_error",
+            component: "repertoire",
+            message: `vault setup failed: ${reason}`,
+            meta: { agentName, serverUrl, email, reason },
+        });
+        return { success: false, email, serverUrl, error: reason };
+    }
+}