@trops/dash-core 0.1.446 → 0.1.448

package/dist/electron/index.js

@@ -424,6 +424,11 @@ const MCP_GET_CATALOG$1 = "mcp-get-catalog";
 const MCP_GET_CATALOG_COMPLETE = "mcp-get-catalog-complete";
 const MCP_GET_CATALOG_ERROR = "mcp-get-catalog-error";
 
+const MCP_GET_KNOWN_EXTERNAL$1 = "mcp-get-known-external";
+
+const MCP_INSTALL_KNOWN_EXTERNAL_CONFIRM$2 = "mcp-install-known-external-confirm";
+const MCP_INSTALL_KNOWN_EXTERNAL_RESULT$2 = "mcp-install-known-external-result";
+
 const MCP_RUN_AUTH$1 = "mcp-run-auth";
 const MCP_RUN_AUTH_COMPLETE = "mcp-run-auth-complete";
 const MCP_RUN_AUTH_ERROR = "mcp-run-auth-error";
@@ -453,6 +458,9 @@ var mcpEvents$1 = {
   MCP_GET_CATALOG: MCP_GET_CATALOG$1,
   MCP_GET_CATALOG_COMPLETE,
   MCP_GET_CATALOG_ERROR,
+  MCP_GET_KNOWN_EXTERNAL: MCP_GET_KNOWN_EXTERNAL$1,
+  MCP_INSTALL_KNOWN_EXTERNAL_CONFIRM: MCP_INSTALL_KNOWN_EXTERNAL_CONFIRM$2,
+  MCP_INSTALL_KNOWN_EXTERNAL_RESULT: MCP_INSTALL_KNOWN_EXTERNAL_RESULT$2,
   MCP_RUN_AUTH: MCP_RUN_AUTH$1,
   MCP_RUN_AUTH_COMPLETE,
   MCP_RUN_AUTH_ERROR,
@@ -5296,7 +5304,7 @@ const layoutController$1 = {
 
 var layoutController_1 = layoutController$1;
 
-var mcpController$3 = {exports: {}};
+var mcpController$4 = {exports: {}};
 
 var streamableHttp$1 = {};
 
@@ -26032,7 +26040,7 @@ async function refreshGoogleOAuthToken(tokenRefresh) {
   console.log("[mcpController] Google OAuth token refreshed successfully");
 }
 
-const mcpController$2 = {
+const mcpController$3 = {
   /**
    * startServer
    * Start an MCP server with the given config and credentials
@@ -26070,13 +26078,13 @@ const mcpController$2 = {
       try {
         // Stop if in stale/error state
         if (activeServers.has(serverName)) {
-          await mcpController$2.stopServer(win, serverName);
+          await mcpController$3.stopServer(win, serverName);
         }
 
         // Merge with catalog entry to pick up updated command/args
         // (saved provider config may reference a stale or archived package)
         try {
-          const { catalog } = mcpController$2.getCatalog(win);
+          const { catalog } = mcpController$3.getCatalog(win);
           const catalogEntry = (catalog || []).find(
             (entry) => entry.name === serverName,
           );
@@ -26602,6 +26610,48 @@ const mcpController$2 = {
     }
   },
 
+  /**
+   * getKnownExternalCatalog
+   * Load the curated allow-list of MCP servers known to exist outside the
+   * built-in catalog. Used by the AI Widget Builder to suggest installable
+   * servers and as the trust boundary for `install_known_mcp_server` —
+   * the install tool will reject any id that doesn't appear here.
+   *
+   * @returns {{ success, servers } | { error, message, servers }}
+   */
+  getKnownExternalCatalog: () => {
+    try {
+      const catalogPath = path$c.join(
+        __dirname,
+        "..",
+        "mcp",
+        "knownExternalMcpServers.json",
+      );
+
+      if (!fs$8.existsSync(catalogPath)) {
+        return { success: true, servers: [] };
+      }
+
+      const catalogData = fs$8.readFileSync(catalogPath, "utf8");
+      const catalog = JSON.parse(catalogData);
+
+      return {
+        success: true,
+        servers: catalog.servers || [],
+      };
+    } catch (error) {
+      console.error(
+        "[mcpController] Error loading known-external catalog:",
+        error,
+      );
+      return {
+        error: true,
+        message: error.message,
+        servers: [],
+      };
+    }
+  },
+
   /**
    * listConnectedServers
    * Returns all connected servers with their cached tool lists.
@@ -26765,17 +26815,17 @@ const mcpController$2 = {
     );
     const promises = [];
     for (const [serverName] of activeServers) {
-      promises.push(mcpController$2.stopServer(null, serverName));
+      promises.push(mcpController$3.stopServer(null, serverName));
     }
     await Promise.allSettled(promises);
     console.log("[mcpController] All servers stopped");
   },
 };
 
-mcpController$3.exports = mcpController$2;
-mcpController$3.exports.refreshGoogleOAuthToken = refreshGoogleOAuthToken;
+mcpController$4.exports = mcpController$3;
+mcpController$4.exports.refreshGoogleOAuthToken = refreshGoogleOAuthToken;
 
-var mcpControllerExports = mcpController$3.exports;
+var mcpControllerExports = mcpController$4.exports;
 
 /**
  * Scoped package identity utilities.
@@ -51231,7 +51281,7 @@ var jsonSchemaToZod_1 = { jsonSchemaToZod: jsonSchemaToZod$1, jsonSchemaProperty
 
 const https$2 = require$$8$1;
 const { randomUUID } = require$$1$6;
-const { BrowserWindow } = require$$0$1;
+const { BrowserWindow: BrowserWindow$1 } = require$$0$1;
 const { McpServer } = mcp;
 const {
   StreamableHTTPServerTransport,
@@ -51275,7 +51325,7 @@ function broadcastStateChanged(toolName, result) {
     /* leave null */
   }
   const payload = { toolName, result: parsed };
-  for (const win of BrowserWindow.getAllWindows()) {
+  for (const win of BrowserWindow$1.getAllWindows()) {
     if (!win.isDestroyed()) {
       try {
         win.webContents.send("dash-mcp:state-changed", payload);
@@ -51341,7 +51391,7 @@ const registeredPrompts = [];
  * Register a tool to be exposed via the MCP server.
  * Call this before starting the server (or restart after registering).
  */
-function registerTool$6(toolDef) {
+function registerTool$7(toolDef) {
   registeredTools.push(toolDef);
 }
 
@@ -51722,7 +51772,7 @@ const mcpDashServerController$4 = {
   },
 
   // Expose registration functions for other controllers
-  registerTool: registerTool$6,
+  registerTool: registerTool$7,
   registerResource: registerResource$1,
   registerPrompt: registerPrompt$1,
   getServerContext,
@@ -61842,7 +61892,7 @@ async function handleListProviders$1() {
  * add_provider — Adds a new provider with encrypted credentials.
  * Credentials are accepted on input but never returned in the response.
  */
-async function handleAddProvider$1({
+async function handleAddProvider$2({
   name,
   type,
   providerClass,
@@ -62667,7 +62717,7 @@ var toolHandlers$1 = {
   handleSearchRegistryThemes: handleSearchRegistryThemes$1,
   handleSearchRegistryDashboards: handleSearchRegistryDashboards$1,
   handleListProviders: handleListProviders$1,
-  handleAddProvider: handleAddProvider$1,
+  handleAddProvider: handleAddProvider$2,
   handleRemoveProvider: handleRemoveProvider$1,
   handleGetSetupGuide: handleGetSetupGuide$1,
   handleSetLayout: handleSetLayout$1,
@@ -62692,7 +62742,7 @@ var toolHandlers$1 = {
  */
 
 const Anthropic = require$$0$9;
-const mcpController$1 = mcpControllerExports;
+const mcpController$2 = mcpControllerExports;
 const cliController$1 = cliController_1;
 const toolDefinitions = toolDefinitions$1;
 const toolHandlers = toolHandlers$1;
@@ -62988,7 +63038,7 @@ const llmController$1 = {
             isError = true;
           } else {
             try {
-              const mcpResult = await mcpController$1.callTool(
+              const mcpResult = await mcpController$2.callTool(
                 win,
                 serverName,
                 toolBlock.name,
@@ -74145,6 +74195,99 @@ function findWidget(registry, packageId) {
   return null;
 }
 
+/**
+ * Dedup duplicate `{type: "..."}` entries inside a `providers: [...]`
+ * array literal in a .dash.js source string. Mirrors the regex used at
+ * AI-build write time in dash-electron's WidgetBuilderModal so old
+ * AI-generated widgets get healed before publish (the runtime parse
+ * dedup keeps consumers correct, but the raw .dash.js text on disk
+ * stays dirty unless we rewrite it).
+ *
+ * Conservative: only handles a single-level array of object literals.
+ * More exotic forms fall through unchanged and the runtime dedup picks
+ * up the slack.
+ *
+ * @param {string} source
+ * @returns {{ source: string, dropped: number }}
+ */
+function dedupProvidersInDashSource(source) {
+  if (!source) return { source, dropped: 0 };
+  let totalDropped = 0;
+  const cleaned = source.replace(
+    /(providers\s*:\s*\[)([^[\]]*?)(\])/,
+    (match, head, body, tail) => {
+      const chunks = body
+        .split(/(\{[^{}]*\})/)
+        .filter((s) => s && /\S/.test(s));
+      const seenTypes = new Set();
+      const kept = [];
+      let dropped = 0;
+      for (const chunk of chunks) {
+        if (!chunk.startsWith("{")) continue;
+        const typeMatch = chunk.match(/type\s*:\s*["']([^"']+)["']/);
+        if (!typeMatch) {
+          kept.push(chunk.trim());
+          continue;
+        }
+        const t = typeMatch[1];
+        if (seenTypes.has(t)) {
+          dropped++;
+          continue;
+        }
+        seenTypes.add(t);
+        kept.push(chunk.trim());
+      }
+      if (dropped === 0) return match;
+      totalDropped += dropped;
+      return `${head}${kept.join(", ")}${tail}`;
+    },
+  );
+  return { source: cleaned, dropped: totalDropped };
+}
+
+/**
+ * Walk a widget package's `.dash.js` files and rewrite any with
+ * duplicate provider-type entries. Returns counts so the publish
+ * caller can log what was healed. Errors are non-fatal — a single
+ * unparseable .dash.js shouldn't block the whole publish.
+ */
+function cleanupProvidersInWidgetPackage(widgetPath) {
+  const summary = { filesScanned: 0, filesRewritten: 0, totalDropped: 0 };
+  try {
+    const widgetsDir =
+      findWidgetsDir(widgetPath) || path.join(widgetPath, "widgets");
+    if (!fs.existsSync(widgetsDir)) return summary;
+    for (const file of fs.readdirSync(widgetsDir)) {
+      if (!file.endsWith(".dash.js")) continue;
+      const filePath = path.join(widgetsDir, file);
+      try {
+        const original = fs.readFileSync(filePath, "utf8");
+        summary.filesScanned++;
+        const { source: deduped, dropped } =
+          dedupProvidersInDashSource(original);
+        if (dropped > 0 && deduped !== original) {
+          fs.writeFileSync(filePath, deduped, "utf8");
+          summary.filesRewritten++;
+          summary.totalDropped += dropped;
+          console.log(
+            `[widgetRegistry] Cleaned ${dropped} duplicate provider(s) from ${file}`,
+          );
+        }
+      } catch (err) {
+        console.warn(
+          `[widgetRegistry] cleanupProviders skip ${file}: ${err.message}`,
+        );
+      }
+    }
+  } catch (err) {
+    console.warn(
+      "[widgetRegistry] cleanupProvidersInWidgetPackage failed:",
+      err.message,
+    );
+  }
+  return summary;
+}
+
 /**
  * Scan a widget package directory for `.dash.js` component configs and
  * return the parsed configs. Used when the widget registry's cached
@@ -74487,6 +74630,21 @@ async function prepareWidgetForPublish$1(appId, packageId, options = {}) {
       }
     }
 
+    // 5b. Heal `.dash.js` source files that have duplicate
+    //     provider-type entries before we read configs / build the
+    //     manifest / zip. AI-generated configs occasionally double a
+    //     `{type:"..."}` entry; the runtime dedup makes it invisible
+    //     on the publisher's machine, but we don't want the dirty raw
+    //     text shipping to the registry. Mirrors the write-time dedup
+    //     in dash-electron's WidgetBuilderModal so older widgets
+    //     authored before that fix landed get cleaned at publish.
+    const providerCleanupSummary = cleanupProvidersInWidgetPackage(widget.path);
+    if (providerCleanupSummary.filesRewritten > 0) {
+      console.log(
+        `[widgetRegistry] Provider cleanup: rewrote ${providerCleanupSummary.filesRewritten} file(s), removed ${providerCleanupSummary.totalDropped} duplicate(s)`,
+      );
+    }
+
     // 6. Build manifest using the widget's component configs. The
     //    registry cache may be missing widgets (orphaned / locally-
     //    registered packages), so fall back to scanning the package's
@@ -75772,6 +75930,9 @@ const {
   MCP_READ_RESOURCE,
   MCP_SERVER_STATUS,
   MCP_GET_CATALOG,
+  MCP_GET_KNOWN_EXTERNAL,
+  MCP_INSTALL_KNOWN_EXTERNAL_CONFIRM: MCP_INSTALL_KNOWN_EXTERNAL_CONFIRM$1,
+  MCP_INSTALL_KNOWN_EXTERNAL_RESULT: MCP_INSTALL_KNOWN_EXTERNAL_RESULT$1,
   MCP_RUN_AUTH,
 } = events$8;
 
@@ -75868,6 +76029,45 @@ const mcpApi$2 = {
    */
   getCatalog: () => ipcRenderer$i.invoke(MCP_GET_CATALOG),
 
+  /**
+   * getKnownExternalCatalog
+   * Load the curated allow-list of MCP servers known to exist outside the
+   * built-in catalog. The AI Widget Builder reads this to advertise
+   * "you can install <X> via Add Custom MCP" and as the trust boundary
+   * for the `install_known_mcp_server` dash MCP tool — only ids in this
+   * list are installable via that path.
+   *
+   * @returns {Promise<{ success, servers } | { error, message, servers }>}
+   */
+  getKnownExternalCatalog: () => ipcRenderer$i.invoke(MCP_GET_KNOWN_EXTERNAL),
+
+  /**
+   * onInstallKnownExternalConfirm
+   * Subscribe to install-confirm requests emitted by the dash MCP server
+   * tool `install_known_mcp_server`. The renderer renders a confirmation
+   * modal and replies with { confirmed, credentials } via
+   * sendInstallKnownExternalResult().
+   *
+   * @param {(payload: { id, requestId, server }) => void} callback
+   * @returns {() => void} cleanup
+   */
+  onInstallKnownExternalConfirm: (callback) => {
+    const handler = (_e, data) => callback(data);
+    ipcRenderer$i.on(MCP_INSTALL_KNOWN_EXTERNAL_CONFIRM$1, handler);
+    return () =>
+      ipcRenderer$i.removeListener(MCP_INSTALL_KNOWN_EXTERNAL_CONFIRM$1, handler);
+  },
+
+  /**
+   * sendInstallKnownExternalResult
+   * Reply to a confirm request with the user's decision + credentials.
+   *
+   * @param {string} requestId
+   * @param {{ confirmed: boolean, credentials?: object, error?: string }} result
+   */
+  sendInstallKnownExternalResult: (requestId, result) =>
+    ipcRenderer$i.send(MCP_INSTALL_KNOWN_EXTERNAL_RESULT$1, { requestId, result }),
+
   /**
    * runAuth
    * Run a one-shot auth command for an MCP server (e.g., OAuth browser flow)
@@ -77176,7 +77376,7 @@ var mcpDashServerApi_1 = mcpDashServerApi$2;
  * Call registerDashboardTools() during app startup (before or after server start).
  */
 
-const { registerTool: registerTool$5 } = mcpDashServerController_1;
+const { registerTool: registerTool$6 } = mcpDashServerController_1;
 const { dashboardTools } = toolDefinitions$1;
 const {
   handleListDashboards,
@@ -77207,7 +77407,7 @@ function registerDashboardTools$1() {
       console.warn(`[dashboardTools] No handler found for tool: ${tool.name}`);
       continue;
     }
-    registerTool$5({
+    registerTool$6({
       name: tool.name,
       description: tool.description,
       inputSchema: tool.inputSchema,
@@ -77228,7 +77428,7 @@ var dashboardTools_1 = { registerDashboardTools: registerDashboardTools$1 };
  * Call registerWidgetTools() during app startup (before or after server start).
  */
 
-const { registerTool: registerTool$4 } = mcpDashServerController_1;
+const { registerTool: registerTool$5 } = mcpDashServerController_1;
 const { widgetTools } = toolDefinitions$1;
 const {
   handleAddWidget,
@@ -77259,7 +77459,7 @@ function registerWidgetTools$1() {
       console.warn(`[widgetTools] No handler found for tool: ${tool.name}`);
       continue;
     }
-    registerTool$4({
+    registerTool$5({
       name: tool.name,
       description: tool.description,
       inputSchema: tool.inputSchema,
@@ -77278,7 +77478,7 @@ var widgetTools_1 = { registerWidgetTools: registerWidgetTools$1 };
  * Call registerThemeTools() during app startup (before or after server start).
  */
 
-const { registerTool: registerTool$3 } = mcpDashServerController_1;
+const { registerTool: registerTool$4 } = mcpDashServerController_1;
 const { themeTools } = toolDefinitions$1;
 const {
   handleListThemes,
@@ -77309,7 +77509,7 @@ function registerThemeTools$1() {
       console.warn(`[themeTools] No handler found for tool: ${tool.name}`);
       continue;
     }
-    registerTool$3({
+    registerTool$4({
       name: tool.name,
       description: tool.description,
       inputSchema: tool.inputSchema,
@@ -77328,18 +77528,18 @@ var themeTools_1 = { registerThemeTools: registerThemeTools$1 };
  * Call registerProviderTools() during app startup (before or after server start).
  */
 
-const { registerTool: registerTool$2 } = mcpDashServerController_1;
+const { registerTool: registerTool$3 } = mcpDashServerController_1;
 const { providerTools } = toolDefinitions$1;
 const {
   handleListProviders,
-  handleAddProvider,
+  handleAddProvider: handleAddProvider$1,
   handleRemoveProvider,
 } = toolHandlers$1;
 
 // Map tool names to handler functions
 const handlerMap$4 = {
   list_providers: handleListProviders,
-  add_provider: handleAddProvider,
+  add_provider: handleAddProvider$1,
   remove_provider: handleRemoveProvider,
 };
 
@@ -77353,7 +77553,7 @@ function registerProviderTools$1() {
       console.warn(`[providerTools] No handler found for tool: ${tool.name}`);
       continue;
     }
-    registerTool$2({
+    registerTool$3({
       name: tool.name,
       description: tool.description,
       inputSchema: tool.inputSchema,
@@ -77374,7 +77574,7 @@ var providerTools_1 = { registerProviderTools: registerProviderTools$1 };
  * Call registerGuideTools() during app startup.
  */
 
-const { registerTool: registerTool$1 } = mcpDashServerController_1;
+const { registerTool: registerTool$2 } = mcpDashServerController_1;
 const { guideTools } = toolDefinitions$1;
 const { handleGetSetupGuide } = toolHandlers$1;
 
@@ -77389,7 +77589,7 @@ function registerGuideTools$1() {
       console.warn(`[guideTools] No handler found for tool: ${tool.name}`);
       continue;
     }
-    registerTool$1({
+    registerTool$2({
       name: tool.name,
       description: tool.description,
       inputSchema: tool.inputSchema,
@@ -77408,7 +77608,7 @@ var guideTools_1 = { registerGuideTools: registerGuideTools$1 };
  * Call registerLayoutTools() during app startup (before or after server start).
  */
 
-const { registerTool } = mcpDashServerController_1;
+const { registerTool: registerTool$1 } = mcpDashServerController_1;
 const { layoutTools } = toolDefinitions$1;
 const {
   handleSetLayout,
@@ -77432,7 +77632,7 @@ function registerLayoutTools$1() {
       console.warn(`[layoutTools] No handler found for tool: ${tool.name}`);
       continue;
     }
-    registerTool({
+    registerTool$1({
       name: tool.name,
       description: tool.description,
       inputSchema: tool.inputSchema,
@@ -77444,6 +77644,194 @@ function registerLayoutTools$1() {
 
 var layoutTools_1 = { registerLayoutTools: registerLayoutTools$1 };
 
+/**
+ * installExternalMcpTool.js
+ *
+ * Registers the `install_known_mcp_server` tool on Dash's own MCP server.
+ *
+ * Why this tool exists:
+ * The AI Widget Builder asks Claude to use MCP-first when a user requests
+ * a widget for an external service. The built-in catalog covers 13 servers;
+ * for anything else the AI consults the curated allow-list at
+ * `electron/mcp/knownExternalMcpServers.json`. To keep the user in control
+ * (npm install + spawning a child process is a non-trivial trust grant),
+ * the actual install is gated by a renderer-side confirmation modal: this
+ * tool emits an IPC event with the curated entry, waits for the user's
+ * response, and only then routes through the existing add-provider flow.
+ *
+ * Trust boundary: the `id` argument MUST match an entry in
+ * knownExternalMcpServers.json. Any other id is rejected before the
+ * confirmation modal is even shown.
+ *
+ * Returns one of:
+ *   - { success: true, name }      — installed
+ *   - { success: false, declined } — user clicked Cancel
+ *   - { success: false, error }    — id not in allow-list, IPC timeout, or
+ *                                    install error from add-provider flow
+ */
+
+const { BrowserWindow } = require$$0$1;
+const { registerTool } = mcpDashServerController_1;
+const mcpController$1 = mcpControllerExports;
+const {
+  MCP_INSTALL_KNOWN_EXTERNAL_CONFIRM,
+  MCP_INSTALL_KNOWN_EXTERNAL_RESULT,
+} = mcpEvents$1;
+const { handleAddProvider } = toolHandlers$1;
+const { ipcMain } = require$$0$1;
+
+const CONFIRM_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes — user may stop to read
+
+// Pending requests keyed by requestId so we can resolve when the result IPC arrives.
+const pendingRequests = new Map();
+
+let resultListenerInstalled = false;
+function ensureResultListener() {
+  if (resultListenerInstalled) return;
+  resultListenerInstalled = true;
+  ipcMain.on(MCP_INSTALL_KNOWN_EXTERNAL_RESULT, (_event, payload) => {
+    const { requestId, result } = payload || {};
+    const pending = pendingRequests.get(requestId);
+    if (!pending) return;
+    pendingRequests.delete(requestId);
+    clearTimeout(pending.timer);
+    pending.resolve(result || { confirmed: false });
+  });
+}
+
+function findEntryInAllowList(id) {
+  const { servers } = mcpController$1.getKnownExternalCatalog();
+  if (!Array.isArray(servers)) return null;
+  return servers.find((s) => s && s.id === id) || null;
+}
+
+function newRequestId() {
+  return `mcp-install-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+async function awaitUserConfirmation(server) {
+  ensureResultListener();
+  const requestId = newRequestId();
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      if (pendingRequests.has(requestId)) {
+        pendingRequests.delete(requestId);
+        resolve({ confirmed: false, error: "Install confirmation timed out" });
+      }
+    }, CONFIRM_TIMEOUT_MS);
+    pendingRequests.set(requestId, { resolve, timer });
+
+    // Broadcast to all open windows; whichever has the modal mounted picks it up.
+    const wins = BrowserWindow.getAllWindows();
+    if (wins.length === 0) {
+      pendingRequests.delete(requestId);
+      clearTimeout(timer);
+      resolve({ confirmed: false, error: "No window available" });
+      return;
+    }
+    for (const win of wins) {
+      if (!win.isDestroyed()) {
+        win.webContents.send(MCP_INSTALL_KNOWN_EXTERNAL_CONFIRM, {
+          requestId,
+          id: server.id,
+          server,
+        });
+      }
+    }
+  });
+}
+
+function ok(payload) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload) }],
+  };
+}
+
+function fail(payload) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload) }],
+    isError: true,
+  };
+}
+
+async function handleInstallKnownMcpServer({ id, name }) {
+  if (!id || typeof id !== "string") {
+    return fail({ success: false, error: "id is required" });
+  }
+  const server = findEntryInAllowList(id);
+  if (!server) {
+    return fail({
+      success: false,
+      error: `id "${id}" is not in the known-external MCP allow-list. The user can only install servers explicitly listed in knownExternalMcpServers.json.`,
+    });
+  }
+
+  const decision = await awaitUserConfirmation(server);
+  if (!decision || !decision.confirmed) {
+    if (decision?.error) {
+      return fail({ success: false, error: decision.error });
+    }
+    return ok({ success: false, declined: true });
+  }
+
+  // Route through the existing add-provider tool handler. The renderer
+  // collected credentials in its modal — we trust those to match the
+  // curated `credentialSchema`.
+  const providerName = (name && name.trim()) || server.name || server.id;
+  try {
+    const addResult = await handleAddProvider({
+      name: providerName,
+      type: server.id,
+      providerClass: "mcp",
+      credentials: decision.credentials || {},
+      mcpConfig: server.mcpConfig,
+    });
+    if (addResult?.isError) {
+      // Surface add-provider's error text verbatim.
+      return addResult;
+    }
+    return ok({ success: true, name: providerName, type: server.id });
+  } catch (err) {
+    return fail({ success: false, error: err.message });
+  }
+}
+
+const installExternalMcpToolDef = {
+  name: "install_known_mcp_server",
+  description:
+    "Install an MCP server from Dash's curated known-external allow-list. The user is shown a confirmation modal before any install runs. Use this when the user asks for a widget that needs a service NOT in the built-in MCP catalog but IS in the known-external list. Returns { success, name } on install, { success: false, declined: true } if the user cancels, or an error if the id isn't allow-listed.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      id: {
+        type: "string",
+        description:
+          "The id of the server in the known-external catalog (e.g. 'trello', 'asana', 'stripe').",
+      },
+      name: {
+        type: "string",
+        description:
+          "Optional display name for the resulting provider entry. Defaults to the catalog entry's name.",
+      },
+    },
+    required: ["id"],
+  },
+};
+
+function registerInstallKnownMcpServerTool$1() {
+  registerTool({
+    ...installExternalMcpToolDef,
+    handler: handleInstallKnownMcpServer,
+  });
+  console.log("[installExternalMcpTool] Registered install_known_mcp_server");
+}
+
+var installExternalMcpTool = {
+  registerInstallKnownMcpServerTool: registerInstallKnownMcpServerTool$1,
+  // Exported for tests
+  handleInstallKnownMcpServer,
+};
+
 /**
  * resourceDefinitions.js
  *
@@ -78414,6 +78802,9 @@ const { registerThemeTools } = themeTools_1;
 const { registerProviderTools } = providerTools_1;
 const { registerGuideTools } = guideTools_1;
 const { registerLayoutTools } = layoutTools_1;
+const {
+  registerInstallKnownMcpServerTool,
+} = installExternalMcpTool;
 const { registerResources } = resources;
 const { registerPrompts } = promptRegistration;
 registerDashboardTools();
@@ -78422,6 +78813,7 @@ registerThemeTools();
 registerProviderTools();
 registerGuideTools();
 registerLayoutTools();
+registerInstallKnownMcpServerTool();
 registerResources();
 registerPrompts();