@finchagentic/mcp 4.1.0 → 4.2.0

package/dist/wallet.js

@@ -66,19 +66,54 @@ exports.MEV_PROTECT_ENABLED = !!process.env.FINCH_BROADCAST_RPC;
 exports.BASE_CHAIN_ID = 8453;
 const WALLET_DIR = path.join(os.homedir(), ".finch");
 const WALLET_FILE = path.join(WALLET_DIR, "wallet.json");
+// Per-install random secret folded into the no-passphrase key derivation
+// (see getMachineKey). Generated once via crypto.randomBytes and stored
+// 0600 next to the wallet - real entropy, unlike hostname/platform/arch
+// which are guessable/public and give an attacker who copies the wallet
+// file everything they need to also derive the key.
+const LOCAL_SECRET_FILE = path.join(WALLET_DIR, ".local-secret");
 let _cachedWallet = null;
 function clearWalletCache() { _cachedWallet = null; }
+function getOrCreateLocalSecret() {
+    try {
+        const existing = fs.readFileSync(LOCAL_SECRET_FILE, "utf8").trim();
+        if (existing)
+            return existing;
+    }
+    catch { /* doesn't exist yet, or unreadable - (re)create below */ }
+    const secret = crypto.randomBytes(32).toString("hex");
+    if (!fs.existsSync(WALLET_DIR))
+        fs.mkdirSync(WALLET_DIR, { recursive: true });
+    fs.writeFileSync(LOCAL_SECRET_FILE, secret, { mode: 0o600 });
+    return secret;
+}
 function getMachineKey() {
     // A passphrase is meant to make the wallet portable (move the encrypted
     // file + set the same passphrase elsewhere and it still decrypts) - so when
     // one is set, derive the key from ONLY the passphrase, no machine binding.
-    // Without a passphrase, fall back to machine info as convenience-only
-    // encryption (prevents casual reads, not security against an attacker who
-    // has both the file and the system info).
     const passphrase = process.env.FINCH_WALLET_PASSPHRASE ?? "";
     if (passphrase) {
         return crypto.createHash("sha256").update(passphrase).digest("hex").slice(0, 32);
     }
+    // Without a passphrase, this is convenience-only encryption - it still
+    // can't stop an attacker who obtains BOTH files (the encrypted wallet and
+    // this local secret), the same as any locally-stored key material. What it
+    // does stop is the weaker, more common case this used to be vulnerable to:
+    // hostname/platform/arch alone are public/guessable, so a copy of just the
+    // wallet file (backup sync, stolen disk, malware scraping known paths) used
+    // to be enough to brute-force the key offline. Folding in a random,
+    // file-local secret means the wallet file alone is no longer sufficient.
+    return crypto
+        .createHash("sha256")
+        .update(getOrCreateLocalSecret() + os.hostname() + os.platform() + os.arch())
+        .digest("hex")
+        .slice(0, 32);
+}
+/** Pre-entropy-fix no-passphrase key: machine info only, no local secret.
+ *  Kept solely so wallets encrypted before this fix still open; migrated to
+ *  the new scheme in place on first successful decrypt, same pattern as
+ *  getLegacyMachineKey below. */
+function getLegacyMachineOnlyKey() {
     return crypto
         .createHash("sha256")
         .update(os.hostname() + os.platform() + os.arch())
@@ -91,9 +126,15 @@ function getMachineKey() {
  * decrypted on the exact machine that created it - never portable. Kept
  * solely so those existing wallets still open; getOrCreateWallet migrates
  * them to the portable scheme in place on first successful decrypt.
+ *
+ * `passphrase` is a parameter, not read from env, because the whole point of
+ * this fallback is testing what the file was ACTUALLY encrypted with - which
+ * may not be today's FINCH_WALLET_PASSPHRASE. The most common case this
+ * exists for: a user who never set a passphrase before (so the file was
+ * encrypted with "" + machine info) setting one for the FIRST time just now -
+ * at that moment env has the new passphrase, but the file predates it.
  */
-function getLegacyMachineKey() {
-    const passphrase = process.env.FINCH_WALLET_PASSPHRASE ?? "";
+function getLegacyMachineKey(passphrase) {
     return crypto
         .createHash("sha256")
         .update(passphrase + os.hostname() + os.platform() + os.arch())
@@ -106,13 +147,34 @@ function warnIfNoPassphrase() {
         return;
     _passphraseWarned = true;
     // stderr only - stdout is reserved for MCP JSON-RPC framing when running as a server.
-    process.stderr.write("\n⚠️  FINCH_WALLET_PASSPHRASE is not set. Your Base mainnet wallet " +
-        `(${WALLET_FILE}) is encrypted with a key derived only from this machine's ` +
-        "hostname/platform/arch - low entropy, and crackable by anyone who copies the " +
-        "file (backup sync, stolen disk, malware). Set FINCH_WALLET_PASSPHRASE to a " +
-        "strong secret for real protection. This wallet holds real funds.\n\n");
+    process.stderr.write("\n⚠️  FINCH_WALLET_PASSPHRASE is not set. Your local wallet " +
+        `(${WALLET_FILE}, used on both Base and Robinhood Chain) is encrypted with a key derived from a random ` +
+        `per-install secret (${LOCAL_SECRET_FILE}) plus this machine's hostname/platform/arch. That stops the wallet ` +
+        "file alone from being crackable, but anyone who copies BOTH files together (backup sync, stolen disk, " +
+        "malware) still gets the wallet. Set FINCH_WALLET_PASSPHRASE to a strong secret you keep out of that backup " +
+        "for real protection. This wallet holds real funds.\n\n");
 }
+let _walletCreationPromise = null;
 async function getOrCreateWallet() {
+    if (_cachedWallet)
+        return _cachedWallet;
+    // In-process mutex: two concurrent first-run callers (before _cachedWallet
+    // is set) must not each independently generate + write their own random
+    // wallet - only one write can ever survive on disk, and the loser would go
+    // on signing in-memory with a keypair that no longer matches what's
+    // persisted, silently switching the user's wallet identity mid-session.
+    // Chain all concurrent first-run callers through one shared promise.
+    if (_walletCreationPromise)
+        return _walletCreationPromise;
+    _walletCreationPromise = loadOrCreateWallet();
+    try {
+        return await _walletCreationPromise;
+    }
+    finally {
+        _walletCreationPromise = null;
+    }
+}
+async function loadOrCreateWallet() {
     if (_cachedWallet)
         return _cachedWallet;
     warnIfNoPassphrase();
@@ -129,22 +191,55 @@ async function getOrCreateWallet() {
             // machine (it still needs that machine's hostname/platform/arch) - it
             // can't rescue a wallet file copied to a new machine from before this
             // fix; there was no passphrase-only secret saved anywhere to recover.
-            try {
-                const wallet = await ethers_1.ethers.Wallet.fromEncryptedJson(encrypted, getLegacyMachineKey());
-                _cachedWallet = wallet;
+            //
+            // Try two legacy candidates: today's passphrase (in case it was already
+            // set when this file was encrypted) and "" (the common case - a user
+            // setting FINCH_WALLET_PASSPHRASE for the first time, whose existing
+            // file predates having any passphrase at all).
+            const legacyCandidates = [...new Set([process.env.FINCH_WALLET_PASSPHRASE ?? "", ""])];
+            let legacyWallet = null;
+            for (const candidate of legacyCandidates) {
+                try {
+                    legacyWallet = await ethers_1.ethers.Wallet.fromEncryptedJson(encrypted, getLegacyMachineKey(candidate));
+                    break;
+                }
+                catch { /* try next candidate */ }
+            }
+            if (legacyWallet) {
+                _cachedWallet = legacyWallet;
                 // Migrate in place to the portable scheme now that we've proven we
                 // hold the right key, so this only ever needs to happen once.
                 try {
-                    const migrated = await wallet.encrypt(getMachineKey());
+                    const migrated = await legacyWallet.encrypt(getMachineKey());
                     fs.writeFileSync(WALLET_FILE, migrated, { mode: 0o600 });
                     process.stderr.write(`\nMigrated ${WALLET_FILE} to the portable passphrase scheme.\n\n`);
                 }
                 catch {
                     /* migration is best-effort - the legacy key still works next run either way */
                 }
-                return wallet;
+                return legacyWallet;
+            }
+            // Third tier: no passphrase ever set, and this wallet predates the fix
+            // that folds a random local secret into the no-passphrase key (it was
+            // encrypted with hostname/platform/arch alone). Try that exact old
+            // derivation before giving up.
+            if (!process.env.FINCH_WALLET_PASSPHRASE) {
+                try {
+                    const oldNoPassWallet = await ethers_1.ethers.Wallet.fromEncryptedJson(encrypted, getLegacyMachineOnlyKey());
+                    _cachedWallet = oldNoPassWallet;
+                    try {
+                        const migrated = await oldNoPassWallet.encrypt(getMachineKey());
+                        fs.writeFileSync(WALLET_FILE, migrated, { mode: 0o600 });
+                        process.stderr.write(`\nMigrated ${WALLET_FILE} to the higher-entropy no-passphrase scheme.\n\n`);
+                    }
+                    catch {
+                        /* migration is best-effort - the legacy key still works next run either way */
+                    }
+                    return oldNoPassWallet;
+                }
+                catch { /* not this scheme either - fall through to the hard failure below */ }
             }
-            catch {
+            {
                 // A wallet file already exists but couldn't be decrypted under either
                 // scheme - this almost always means FINCH_WALLET_PASSPHRASE doesn't
                 // match what encrypted it, or this is a different machine and no
@@ -166,9 +261,25 @@ async function getOrCreateWallet() {
     if (!fs.existsSync(WALLET_DIR))
         fs.mkdirSync(WALLET_DIR, { recursive: true });
     const encrypted = await wallet.encrypt(getMachineKey());
-    fs.writeFileSync(WALLET_FILE, encrypted, { mode: 0o600 });
-    _cachedWallet = wallet;
-    return wallet;
+    try {
+        // Exclusive create ("wx") - guards the cross-process version of the race
+        // the in-process mutex above already closes: two separate `finch`
+        // invocations racing on the very first run, before this file exists.
+        fs.writeFileSync(WALLET_FILE, encrypted, { mode: 0o600, flag: "wx" });
+        _cachedWallet = wallet;
+        return wallet;
+    }
+    catch (writeErr) {
+        if (writeErr?.code !== "EEXIST")
+            throw writeErr;
+        // Another process won the race and created the file first. Use theirs -
+        // never sign with the wallet we generated in memory once it's clear it
+        // isn't the one actually persisted to disk.
+        const encryptedExisting = fs.readFileSync(WALLET_FILE, "utf8");
+        const existingWallet = await ethers_1.ethers.Wallet.fromEncryptedJson(encryptedExisting, getMachineKey());
+        _cachedWallet = existingWallet;
+        return existingWallet;
+    }
 }
 async function signRequest(toolName) {
     const wallet = await getOrCreateWallet();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@finchagentic/mcp",
-  "version": "4.1.0",
+  "version": "4.2.0",
   "description": "The runtime layer for Agentic AI. Persistent memory, autonomous agents, and workflows that survive every session.",
   "main": "dist/index.js",
   "bin": {
@@ -9,7 +9,7 @@
   },
   "preferGlobal": true,
   "scripts": {
-    "build": "tsc",
+    "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc",
     "dev": "ts-node src/index.ts",
     "start": "node dist/index.js",
     "test": "vitest run",

package/dist/tools/framework.js

@@ -1,150 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FRAMEWORK_TOOLS = void 0;
-exports.handleFrameworkTool = handleFrameworkTool;
-const convex_js_1 = require("../convex.js");
-exports.FRAMEWORK_TOOLS = [
-    {
-        name: "list_playbooks",
-        description: "List available Noel Framework playbooks - predefined multi-step workflows. " +
-            "Includes 4 system playbooks (Daily Market Scan, DCA Setup, Portfolio Rebalance Check, " +
-            "Research Sweep) plus any you've created. Each step is Sentinel-gated.",
-        inputSchema: { type: "object", properties: {}, required: [] },
-    },
-    {
-        name: "run_playbook",
-        description: "Execute a Noel Framework playbook. Each step runs through Sentinel before the " +
-            "matching tool executes it. Steps map directly to finch tools (market, vault, agent, " +
-            "memory, automation). Playbook halts immediately if Sentinel blocks a step.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                playbook_name: {
-                    type: "string",
-                    description: "Exact name of the playbook. Use list_playbooks to see available ones.",
-                },
-                task_description: {
-                    type: "string",
-                    description: "Optional context passed as overrideParams to the playbook run.",
-                },
-            },
-            required: ["playbook_name"],
-        },
-    },
-    {
-        name: "get_finch_ledger",
-        description: "Get the Noel Framework audit trail - every Sentinel gate decision " +
-            "(approved / blocked / warned), which checks ran, duration, and reason. " +
-            "Full transparency on what agents are and aren't allowed to do.",
-        inputSchema: { type: "object", properties: {}, required: [] },
-    },
-];
-async function handleFrameworkTool(name, args) {
-    const a = (args ?? {});
-    switch (name) {
-        // ── list_playbooks ──────────────────────────────────────────────────────
-        case "list_playbooks": {
-            const result = await (0, convex_js_1.callConvex)("/framework/playbooks", "GET", undefined, "list_playbooks");
-            const pbs = result.playbooks ?? [];
-            if (pbs.length === 0) {
-                return { content: [{ type: "text", text: "No playbooks found." }] };
-            }
-            const list = pbs
-                .map((p) => {
-                const steps = (() => {
-                    try {
-                        return JSON.parse(p.steps).length;
-                    }
-                    catch {
-                        return "?";
-                    }
-                })();
-                return `• **${p.name}**${p.isPublic ? " 🌐" : " 👤"} - ${steps} steps\n  ${p.description}\n  Used ${p.usageCount} times`;
-            })
-                .join("\n\n");
-            return { content: [{ type: "text", text: `**Available Playbooks**\n\n${list}` }] };
-        }
-        // ── run_playbook ────────────────────────────────────────────────────────
-        case "run_playbook": {
-            if (!a.playbook_name) {
-                return { content: [{ type: "text", text: "playbook_name is required" }], isError: true };
-            }
-            // Resolve playbook ID by name
-            const pbList = await (0, convex_js_1.callConvex)("/framework/playbooks", "GET", undefined, "run_playbook");
-            const playbook = (pbList.playbooks ?? []).find((p) => p.name.toLowerCase() === String(a.playbook_name).toLowerCase());
-            if (!playbook) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `Playbook "${a.playbook_name}" not found. Use list_playbooks to see available ones.`,
-                        }],
-                    isError: true,
-                };
-            }
-            const result = await (0, convex_js_1.callConvex)("/framework/playbook/run", "POST", {
-                playbookId: playbook._id,
-                overrideParams: a.task_description,
-            }, "run_playbook");
-            if (result.error) {
-                return { content: [{ type: "text", text: `Run failed: ${result.error}` }], isError: true };
-            }
-            if (result.blocked) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: [
-                                `🛡️ **Sentinel blocked playbook at step ${result.step}**`,
-                                ``,
-                                `**Tool:** ${result.tool}`,
-                                `**Reason:** ${result.reason}`,
-                                ``,
-                                `This is a mechanical safety gate. The action violates the agent's permission boundary.`,
-                                `Completed steps before block: ${result.results?.length ?? 0}`,
-                            ].join("\n"),
-                        }],
-                };
-            }
-            const steps = result.results ?? [];
-            const succeeded = steps.filter(r => r.success).length;
-            const stepLines = steps.map((r) => `${r.success ? "✅" : "❌"} Step ${r.step} [${r.role}]: ${r.tool}${r.error ? ` - ${r.error}` : ""}`);
-            return {
-                content: [{
-                        type: "text",
-                        text: [
-                            `✅ **Playbook "${a.playbook_name}" completed**`,
-                            ``,
-                            `${succeeded}/${steps.length} steps successful`,
-                            `Run ID: \`${result.runId}\``,
-                            ``,
-                            ...stepLines,
-                        ].join("\n"),
-                    }],
-            };
-        }
-        // ── get_finch_ledger ─────────────────────────────────────────────────────
-        case "get_finch_ledger": {
-            const result = await (0, convex_js_1.callConvex)("/swarm/ledger", "GET", undefined, "get_finch_ledger");
-            const entries = result.entries ?? [];
-            if (entries.length === 0) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: "No ledger entries yet. Run a playbook to see Sentinel decisions.",
-                        }],
-                };
-            }
-            const lines = entries.map((e) => {
-                const icon = e.decision === "approved" ? "✅" : e.decision === "blocked" ? "🚫" : "⚠️";
-                return `${icon} **${e.agentId}** → \`${e.action}\`\n  ${e.reason} (${e.durationMs}ms)`;
-            });
-            return {
-                content: [{
-                        type: "text",
-                        text: `**Noel Ledger** (last ${entries.length} decisions)\n\n${lines.join("\n\n")}`,
-                    }],
-            };
-        }
-        default:
-            return null;
-    }
-}