@pancake-apps/server 0.0.0-snapshot-20260125200133

package/dist/index.cjs

@@ -0,0 +1,1519 @@
+'use strict';
+
+var express = require('express');
+var fs2 = require('fs/promises');
+var path2 = require('path');
+var index_js = require('@modelcontextprotocol/sdk/server/index.js');
+var stdio_js = require('@modelcontextprotocol/sdk/server/stdio.js');
+var types_js = require('@modelcontextprotocol/sdk/types.js');
+var child_process = require('child_process');
+var zodToJsonSchema = require('zod-to-json-schema');
+var fsSync = require('fs');
+var net = require('net');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var express__default = /*#__PURE__*/_interopDefault(express);
+var fs2__namespace = /*#__PURE__*/_interopNamespace(fs2);
+var path2__namespace = /*#__PURE__*/_interopNamespace(path2);
+var fsSync__namespace = /*#__PURE__*/_interopNamespace(fsSync);
+var net__namespace = /*#__PURE__*/_interopNamespace(net);
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/utils/metadata.ts
+function mapVisibilityToMcp(visibility) {
+  switch (visibility) {
+    case "model":
+      return ["model"];
+    case "app":
+      return ["app"];
+    case "both":
+    default:
+      return ["model", "app"];
+  }
+}
+function mapVisibilityToOpenAI(visibility) {
+  switch (visibility) {
+    case "model":
+      return { "openai/visibility": "public", "openai/widgetAccessible": false };
+    case "app":
+      return { "openai/visibility": "private", "openai/widgetAccessible": true };
+    case "both":
+    default:
+      return { "openai/visibility": "public", "openai/widgetAccessible": true };
+  }
+}
+function mapVisibilityToAudience(visibility) {
+  switch (visibility) {
+    case "model":
+      return ["assistant"];
+    case "app":
+      return ["user"];
+    case "both":
+    default:
+      return ["assistant", "user"];
+  }
+}
+var init_metadata = __esm({
+  "src/utils/metadata.ts"() {
+  }
+});
+
+// src/utils/csp.ts
+function generateMcpCSPMetadata(csp) {
+  const result = {};
+  if (csp.connectDomains && csp.connectDomains.length > 0) {
+    result.connectDomains = csp.connectDomains;
+  }
+  if (csp.resourceDomains && csp.resourceDomains.length > 0) {
+    result.resourceDomains = csp.resourceDomains;
+  }
+  if (csp.scriptDomains && csp.scriptDomains.length > 0) {
+    result.scriptDomains = csp.scriptDomains;
+  }
+  return result;
+}
+function generateOpenAICSPMetadata(csp) {
+  const result = {};
+  if (csp.connectDomains && csp.connectDomains.length > 0) {
+    result.connect_domains = csp.connectDomains;
+  }
+  if (csp.resourceDomains && csp.resourceDomains.length > 0) {
+    result.resource_domains = csp.resourceDomains;
+  }
+  if (csp.scriptDomains && csp.scriptDomains.length > 0) {
+    result.script_domains = csp.scriptDomains;
+  }
+  return result;
+}
+var init_csp = __esm({
+  "src/utils/csp.ts"() {
+  }
+});
+
+// src/adapters/mcp.ts
+var McpAdapter;
+var init_mcp = __esm({
+  "src/adapters/mcp.ts"() {
+    init_metadata();
+    init_csp();
+    McpAdapter = class {
+      /**
+       * Build tool metadata for MCP protocol
+       */
+      buildToolMeta(tool, uiUri) {
+        const visibility = mapVisibilityToMcp(tool.visibility);
+        const uiMeta = {
+          visibility,
+          ...uiUri ? { resourceUri: uiUri } : {}
+        };
+        const annotations = {
+          audience: mapVisibilityToAudience(tool.visibility)
+        };
+        const meta = {
+          ui: uiMeta,
+          "ui/visibility": visibility,
+          ...uiUri ? { "ui/resourceUri": uiUri } : {}
+        };
+        return {
+          annotations,
+          _meta: meta
+        };
+      }
+      /**
+       * Build UI resource metadata for MCP protocol
+       */
+      buildUIResourceMeta(uiDef) {
+        const uiMeta = {};
+        if (uiDef.csp) {
+          const cspMetadata = generateMcpCSPMetadata(uiDef.csp);
+          if (Object.keys(cspMetadata).length > 0) {
+            uiMeta.csp = cspMetadata;
+          }
+        }
+        if (uiDef.prefersBorder !== void 0) {
+          uiMeta.prefersBorder = uiDef.prefersBorder;
+        }
+        if (uiDef.autoResize !== void 0) {
+          uiMeta.autoResize = uiDef.autoResize;
+        }
+        if (uiDef.domain) {
+          uiMeta.domain = uiDef.domain;
+        }
+        const result = {
+          mimeType: "text/html;profile=mcp-app"
+        };
+        if (Object.keys(uiMeta).length > 0) {
+          result._meta = { ui: uiMeta };
+        }
+        return result;
+      }
+    };
+  }
+});
+
+// src/adapters/openai.ts
+var OpenAIAdapter;
+var init_openai = __esm({
+  "src/adapters/openai.ts"() {
+    init_metadata();
+    init_csp();
+    OpenAIAdapter = class {
+      /**
+       * Build tool metadata for OpenAI protocol
+       */
+      buildToolMeta(tool, uiUri) {
+        const meta = {};
+        const visibilitySettings = mapVisibilityToOpenAI(tool.visibility);
+        Object.assign(meta, visibilitySettings);
+        if (uiUri) {
+          meta["openai/outputTemplate"] = uiUri;
+        }
+        const annotations = {
+          audience: mapVisibilityToAudience(tool.visibility)
+        };
+        return {
+          annotations,
+          _meta: Object.keys(meta).length > 0 ? meta : void 0
+        };
+      }
+      /**
+       * Build UI resource metadata for OpenAI protocol
+       */
+      buildUIResourceMeta(uiDef) {
+        const meta = {};
+        if (uiDef.csp) {
+          const cspMetadata = generateOpenAICSPMetadata(uiDef.csp);
+          if (Object.keys(cspMetadata).length > 0) {
+            meta["openai/widgetCSP"] = cspMetadata;
+          }
+        }
+        if (uiDef.prefersBorder !== void 0) {
+          meta["openai/widgetPrefersBorder"] = uiDef.prefersBorder;
+        }
+        if (uiDef.domain) {
+          meta["openai/widgetDomain"] = uiDef.domain;
+        }
+        const result = {
+          mimeType: "text/html+skybridge"
+        };
+        if (Object.keys(meta).length > 0) {
+          result._meta = meta;
+        }
+        return result;
+      }
+    };
+  }
+});
+
+// src/adapters/index.ts
+function createAdapter(protocol) {
+  return protocol === "openai" ? new OpenAIAdapter() : new McpAdapter();
+}
+var init_adapters = __esm({
+  "src/adapters/index.ts"() {
+    init_mcp();
+    init_openai();
+    init_mcp();
+    init_openai();
+  }
+});
+
+// src/utils/detect-protocol.ts
+function detectProtocol(req, defaultProtocol = "mcp") {
+  const headers = req.headers;
+  const accept = getHeader(headers, "accept");
+  if (accept && accept.includes("text/html+skybridge")) {
+    return "openai";
+  }
+  const openaiHeader = getHeader(headers, "x-openai-client");
+  if (openaiHeader) {
+    return "openai";
+  }
+  const userAgent = getHeader(headers, "user-agent");
+  if (userAgent && (userAgent.includes("ChatGPT") || userAgent.includes("OpenAI"))) {
+    return "openai";
+  }
+  return defaultProtocol;
+}
+function getHeader(headers, name) {
+  const value = headers[name] || headers[name.toLowerCase()];
+  if (Array.isArray(value)) {
+    return value[0];
+  }
+  return value;
+}
+var init_detect_protocol = __esm({
+  "src/utils/detect-protocol.ts"() {
+  }
+});
+
+// src/server/mcp.ts
+function createMcpHandler(config) {
+  return async (req, res) => {
+    const request = req.body;
+    if (request.jsonrpc !== "2.0") {
+      res.status(400).json({
+        jsonrpc: "2.0",
+        id: request.id ?? null,
+        error: { code: -32600, message: "Invalid Request: Not JSON-RPC 2.0" }
+      });
+      return;
+    }
+    try {
+      const protocol = detectProtocol(req, config.defaultProtocol);
+      const adapter = createAdapter(protocol);
+      const result = await handleMethod(config, request.method, request.params ?? {}, adapter);
+      const response = {
+        jsonrpc: "2.0",
+        id: request.id,
+        result
+      };
+      res.json(response);
+    } catch (error) {
+      const response = {
+        jsonrpc: "2.0",
+        id: request.id,
+        error: {
+          code: -32603,
+          message: error instanceof Error ? error.message : "Internal error",
+          data: error instanceof Error ? { stack: error.stack } : void 0
+        }
+      };
+      res.json(response);
+    }
+  };
+}
+async function handleMethod(config, method, params, adapter) {
+  switch (method) {
+    case "initialize":
+      return {
+        protocolVersion: "2025-11-21",
+        capabilities: {
+          tools: {},
+          resources: {}
+        },
+        serverInfo: {
+          name: config.name,
+          version: config.version
+        }
+      };
+    case "tools/list":
+      return {
+        tools: Array.from(config.tools.values()).filter((tool) => tool.visibility !== "app").map((tool) => {
+          const uiUri = tool.ui ? getUIResourceUri(tool.name, tool.category) : void 0;
+          const meta = adapter.buildToolMeta(tool, uiUri);
+          return {
+            name: tool.name,
+            description: tool.description,
+            inputSchema: tool.inputSchema,
+            annotations: meta.annotations,
+            _meta: tool.ui ? meta._meta : void 0
+          };
+        })
+      };
+    case "tools/call": {
+      const toolName = params["name"];
+      const args = params["arguments"] ?? {};
+      const result = await config.executeTool(toolName, args);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result)
+          }
+        ],
+        structuredContent: result
+      };
+    }
+    case "resources/list":
+      return {
+        resources: Array.from(config.uiResources.values()).map((resource) => {
+          const meta = adapter.buildUIResourceMeta(resource.definition);
+          return {
+            uri: resource.uri,
+            name: resource.name,
+            mimeType: meta.mimeType,
+            _meta: meta._meta
+          };
+        })
+      };
+    case "resources/read": {
+      const uri = params["uri"];
+      const resource = config.uiResources.get(uri);
+      if (!resource) {
+        throw new Error(`Resource not found: ${uri}`);
+      }
+      let htmlContent;
+      const htmlPath = resource.definition.html;
+      if (htmlPath.trim().startsWith("<")) {
+        htmlContent = htmlPath;
+      } else {
+        const fsPromises = await import('fs/promises');
+        const pathModule = await import('path');
+        const fullPath = pathModule.resolve(process.cwd(), htmlPath);
+        htmlContent = await fsPromises.readFile(fullPath, "utf-8");
+      }
+      return {
+        contents: [
+          {
+            uri,
+            mimeType: "text/html",
+            text: htmlContent
+          }
+        ]
+      };
+    }
+    case "notifications/initialized":
+    case "ping":
+      return {};
+    default:
+      throw new Error(`Unknown method: ${method}`);
+  }
+}
+function getUIResourceUri(toolName, category) {
+  const name = toolName.replace(/^(view|action|data|tool):/, "");
+  return `pancake://ui/${category}/${name}`;
+}
+var init_mcp2 = __esm({
+  "src/server/mcp.ts"() {
+    init_adapters();
+    init_detect_protocol();
+  }
+});
+
+// src/server/dev-proxy.ts
+function isDevelopment() {
+  return process.env["NODE_ENV"] !== "production";
+}
+function createViteProxy(config) {
+  const vitePort = config.vitePort ?? 5173;
+  const viteUrl = `http://localhost:${vitePort}`;
+  const vitePaths = [
+    "/@vite/",
+    "/@react-refresh",
+    "/assets/",
+    "/src/",
+    "/__vite_ping",
+    "/@fs/",
+    "/node_modules/.vite/",
+    "/node_modules/.pnpm/"
+    // pnpm store - Vite client imports from here
+  ];
+  return async (req, res, next) => {
+    const shouldProxy = vitePaths.some((p) => req.path.startsWith(p));
+    if (!shouldProxy) {
+      next();
+      return;
+    }
+    try {
+      const targetUrl = `${viteUrl}${req.url}`;
+      const response = await fetch(targetUrl, {
+        method: req.method,
+        headers: {
+          ...Object.fromEntries(
+            Object.entries(req.headers).filter(
+              ([key]) => !["host", "connection"].includes(key.toLowerCase())
+            )
+          )
+        }
+      });
+      response.headers.forEach((value, key) => {
+        if (key.toLowerCase() !== "transfer-encoding") {
+          res.setHeader(key, value);
+        }
+      });
+      res.status(response.status);
+      const body = await response.arrayBuffer();
+      res.end(Buffer.from(body));
+    } catch (error) {
+      console.error(`[Pancake] Vite proxy failed for ${req.path}: ${error.message}`);
+      next();
+    }
+  };
+}
+function generateHMRTemplate(viewName) {
+  return `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>${viewName}</title>
+    <!-- All Vite resources go through the proxy using relative URLs -->
+    <script type="module">
+      import { injectIntoGlobalHook } from "/@react-refresh";
+      injectIntoGlobalHook(window);
+      window.$RefreshReg$ = () => {};
+      window.$RefreshSig$ = () => (type) => type;
+      window.__vite_plugin_react_preamble_installed__ = true;
+    </script>
+    <script type="module" src="/@vite/client"></script>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module">
+      // Initialize Pancake client before loading the view
+      import('/src/pancake-init.ts')
+        .then(async (mod) => {
+          if (mod.init) await mod.init();
+        })
+        .catch(() => {
+          // pancake-init.ts might not exist, that's ok
+        })
+        .finally(() => {
+          // Try each path and log which one fails and why
+          const paths = [
+            '/src/views/${viewName}/index.tsx',
+            '/src/views/${viewName}.tsx',
+            '/src/views/${viewName}/index.ts',
+            '/src/views/${viewName}.ts'
+          ];
+
+          async function tryImport(index) {
+            if (index >= paths.length) {
+              document.body.innerHTML = '<pre style="color: red;">Failed to load view: No valid module found</pre>';
+              return;
+            }
+            const path = paths[index];
+            try {
+              console.log('[Pancake] Trying to import:', path);
+              await import(path);
+              console.log('[Pancake] Successfully imported:', path);
+            } catch (err) {
+              console.error('[Pancake] Failed to import ' + path + ':', err);
+              // If this was the first path (the expected one), show the error
+              if (index === 0) {
+                document.body.innerHTML = '<pre style="color: red;">Failed to load view ' + path + ':\\n\\n' + err.message + '\\n\\n' + (err.stack || '') + '</pre>';
+              } else {
+                tryImport(index + 1);
+              }
+            }
+          }
+
+          tryImport(0);
+        });
+    </script>
+  </body>
+</html>`;
+}
+var init_dev_proxy = __esm({
+  "src/server/dev-proxy.ts"() {
+  }
+});
+function createUIRoutes(uiResources, devServerConfig) {
+  const router = express.Router();
+  router.get("/:category/:name", async (req, res) => {
+    const { category, name } = req.params;
+    const uri = `pancake://ui/${category}/${name}`;
+    const resource = uiResources.get(uri);
+    if (!resource) {
+      res.status(404).json({ error: `UI not found: ${category}/${name}` });
+      return;
+    }
+    try {
+      const html = await getUIHtml(resource.definition, name, devServerConfig);
+      res.type("html").send(html);
+    } catch (error) {
+      res.status(500).json({
+        error: "Failed to load UI",
+        details: error instanceof Error ? error.message : String(error)
+      });
+    }
+  });
+  router.get("/:name", async (req, res) => {
+    const { name } = req.params;
+    for (const category of ["view", "action", "tool"]) {
+      const uri = `pancake://ui/${category}/${name}`;
+      const resource = uiResources.get(uri);
+      if (resource) {
+        try {
+          const html = await getUIHtml(resource.definition, name, devServerConfig);
+          res.type("html").send(html);
+          return;
+        } catch (error) {
+          res.status(500).json({
+            error: "Failed to load UI",
+            details: error instanceof Error ? error.message : String(error)
+          });
+          return;
+        }
+      }
+    }
+    res.status(404).json({ error: `UI not found: ${name}` });
+  });
+  return router;
+}
+async function getUIHtml(ui, viewName, devServerConfig) {
+  if (isDevelopment() && devServerConfig) {
+    return generateHMRTemplate(viewName);
+  }
+  if (ui.html.trim().startsWith("<")) {
+    return ui.html;
+  }
+  const htmlPath = path2__namespace.resolve(process.cwd(), ui.html);
+  const content = await fs2__namespace.readFile(htmlPath, "utf-8");
+  return content;
+}
+var init_routes = __esm({
+  "src/server/routes.ts"() {
+    init_dev_proxy();
+  }
+});
+
+// src/server/stdio.ts
+var stdio_exports = {};
+__export(stdio_exports, {
+  startStdioServer: () => startStdioServer
+});
+async function startStdioServer(config) {
+  const adapter = createAdapter(config.protocol ?? "mcp");
+  const server = new index_js.Server(
+    {
+      name: config.name,
+      version: config.version
+    },
+    {
+      capabilities: {
+        tools: {},
+        resources: {}
+      }
+    }
+  );
+  server.setRequestHandler(
+    types_js.ListToolsRequestSchema,
+    async () => {
+      return {
+        tools: Array.from(config.tools.values()).map((tool) => {
+          const uiUri = tool.ui ? getUIResourceUri2(tool.name, tool.category) : void 0;
+          const meta = adapter.buildToolMeta(tool, uiUri);
+          return {
+            name: tool.name,
+            description: tool.description,
+            inputSchema: tool.inputSchema,
+            annotations: meta.annotations,
+            _meta: tool.ui ? meta._meta : void 0
+          };
+        })
+      };
+    }
+  );
+  server.setRequestHandler(
+    types_js.CallToolRequestSchema,
+    async (request) => {
+      const { name, arguments: args = {} } = request.params;
+      const result = await config.executeTool(name, args);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result)
+          }
+        ],
+        structuredContent: result
+      };
+    }
+  );
+  server.setRequestHandler(
+    types_js.ListResourcesRequestSchema,
+    async () => {
+      return {
+        resources: Array.from(config.uiResources.values()).map((resource) => {
+          const meta = adapter.buildUIResourceMeta(resource.definition);
+          return {
+            uri: resource.uri,
+            name: resource.name,
+            mimeType: meta.mimeType,
+            _meta: meta._meta
+          };
+        })
+      };
+    }
+  );
+  server.setRequestHandler(
+    types_js.ReadResourceRequestSchema,
+    async (request) => {
+      const { uri } = request.params;
+      const resource = config.uiResources.get(uri);
+      if (!resource) {
+        throw new Error(`Resource not found: ${uri}`);
+      }
+      return {
+        contents: [
+          {
+            uri,
+            mimeType: "text/html",
+            text: resource.definition.html
+          }
+        ]
+      };
+    }
+  );
+  const transport = new stdio_js.StdioServerTransport();
+  await server.connect(transport);
+  return {
+    close: async () => {
+      await server.close();
+    }
+  };
+}
+function getUIResourceUri2(toolName, category) {
+  const name = toolName.replace(/^(view|action|data|tool):/, "");
+  return `pancake://ui/${category}/${name}`;
+}
+var init_stdio = __esm({
+  "src/server/stdio.ts"() {
+    init_adapters();
+  }
+});
+
+// src/tunnel/index.ts
+var tunnel_exports = {};
+__export(tunnel_exports, {
+  createTunnel: () => createTunnel,
+  isTunnelProviderAvailable: () => isTunnelProviderAvailable
+});
+async function createTunnel(config) {
+  if (config.provider === "cloudflare") {
+    return createCloudflareTunnel(config.port);
+  } else if (config.provider === "ngrok") {
+    return createNgrokTunnel(config.port, config.authtoken);
+  } else {
+    throw new Error(`Unknown tunnel provider: ${config.provider}`);
+  }
+}
+async function createCloudflareTunnel(port) {
+  let state = "idle";
+  let process2 = null;
+  return new Promise((resolve3, reject) => {
+    state = "starting";
+    process2 = child_process.spawn("cloudflared", ["tunnel", "--url", `http://localhost:${port}`], {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let resolved = false;
+    const urlPattern = /https:\/\/[a-zA-Z0-9-]+\.trycloudflare\.com/;
+    const handleOutput = (data) => {
+      const output = data.toString();
+      const match = output.match(urlPattern);
+      if (match && !resolved) {
+        resolved = true;
+        state = "active";
+        const tunnelUrl = match[0];
+        resolve3({
+          url: tunnelUrl,
+          close: async () => {
+            if (process2 && state === "active") {
+              state = "terminated";
+              process2.kill("SIGTERM");
+              process2 = null;
+            }
+          }
+        });
+      }
+    };
+    process2.stdout?.on("data", handleOutput);
+    process2.stderr?.on("data", handleOutput);
+    process2.on("error", (error) => {
+      state = "terminated";
+      if (!resolved) {
+        if (error.code === "ENOENT") {
+          reject(new Error(
+            "cloudflared is not installed. Install it with:\n  macOS: brew install cloudflared\n  Linux: https://developers.cloudflare.com/cloudflare-one/connections/connect-apps/install-and-setup/installation/"
+          ));
+        } else {
+          reject(new Error(`Failed to start cloudflared: ${error.message}`));
+        }
+      }
+    });
+    process2.on("exit", (code) => {
+      state = "terminated";
+      if (!resolved) {
+        reject(new Error(`cloudflared exited with code ${code} before providing a tunnel URL`));
+      }
+    });
+    setTimeout(() => {
+      if (!resolved) {
+        state = "terminated";
+        process2?.kill("SIGTERM");
+        reject(new Error("Timed out waiting for cloudflared to provide a tunnel URL"));
+      }
+    }, 3e4);
+  });
+}
+async function createNgrokTunnel(port, authtoken) {
+  let state = "idle";
+  let process2 = null;
+  return new Promise((resolve3, reject) => {
+    state = "starting";
+    const args = ["http", String(port)];
+    if (authtoken) {
+      args.push("--authtoken", authtoken);
+    }
+    args.push("--log", "stdout", "--log-format", "json");
+    process2 = child_process.spawn("ngrok", args, {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let resolved = false;
+    const urlPattern = /https:\/\/[a-zA-Z0-9-]+\.ngrok(-free)?\.app/;
+    const handleOutput = (data) => {
+      const output = data.toString();
+      const lines = output.split("\n").filter(Boolean);
+      for (const line of lines) {
+        try {
+          const json = JSON.parse(line);
+          if (json.url && !resolved) {
+            resolved = true;
+            state = "active";
+            resolve3({
+              url: json.url,
+              close: async () => {
+                if (process2 && state === "active") {
+                  state = "terminated";
+                  process2.kill("SIGTERM");
+                  process2 = null;
+                }
+              }
+            });
+            return;
+          }
+        } catch {
+          const match = line.match(urlPattern);
+          if (match && !resolved) {
+            resolved = true;
+            state = "active";
+            resolve3({
+              url: match[0],
+              close: async () => {
+                if (process2 && state === "active") {
+                  state = "terminated";
+                  process2.kill("SIGTERM");
+                  process2 = null;
+                }
+              }
+            });
+            return;
+          }
+        }
+      }
+    };
+    process2.stdout?.on("data", handleOutput);
+    process2.stderr?.on("data", handleOutput);
+    process2.on("error", (error) => {
+      state = "terminated";
+      if (!resolved) {
+        if (error.code === "ENOENT") {
+          reject(new Error(
+            "ngrok is not installed. Install it with:\n  macOS: brew install ngrok\n  Linux/Windows: https://ngrok.com/download"
+          ));
+        } else {
+          reject(new Error(`Failed to start ngrok: ${error.message}`));
+        }
+      }
+    });
+    process2.on("exit", (code) => {
+      state = "terminated";
+      if (!resolved) {
+        reject(new Error(`ngrok exited with code ${code} before providing a tunnel URL`));
+      }
+    });
+    setTimeout(() => {
+      if (!resolved) {
+        state = "terminated";
+        process2?.kill("SIGTERM");
+        reject(new Error("Timed out waiting for ngrok to provide a tunnel URL"));
+      }
+    }, 3e4);
+  });
+}
+async function isTunnelProviderAvailable(provider) {
+  const command = provider === "cloudflare" ? "cloudflared" : "ngrok";
+  return new Promise((resolve3) => {
+    const process2 = child_process.spawn(command, ["--version"], {
+      stdio: "ignore"
+    });
+    process2.on("error", () => resolve3(false));
+    process2.on("exit", (code) => resolve3(code === 0));
+  });
+}
+var init_tunnel = __esm({
+  "src/tunnel/index.ts"() {
+  }
+});
+
+// src/server/index.ts
+var server_exports = {};
+__export(server_exports, {
+  createServer: () => createServer
+});
+function generateRequestId() {
+  return `req_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 9)}`;
+}
+async function createServer(config) {
+  const app = express__default.default();
+  app.use(express__default.default.json());
+  if (config.config?.cors) {
+    const corsConfig = config.config.cors;
+    app.use((req, res, next) => {
+      const origin = corsConfig.origin;
+      if (origin === true) {
+        res.setHeader("Access-Control-Allow-Origin", "*");
+      } else if (typeof origin === "string") {
+        res.setHeader("Access-Control-Allow-Origin", origin);
+      } else if (Array.isArray(origin)) {
+        const requestOrigin = req.headers.origin;
+        if (requestOrigin && origin.includes(requestOrigin)) {
+          res.setHeader("Access-Control-Allow-Origin", requestOrigin);
+        }
+      }
+      if (corsConfig.credentials) {
+        res.setHeader("Access-Control-Allow-Credentials", "true");
+      }
+      if (corsConfig.methods) {
+        res.setHeader("Access-Control-Allow-Methods", corsConfig.methods.join(", "));
+      }
+      if (corsConfig.allowedHeaders) {
+        res.setHeader("Access-Control-Allow-Headers", corsConfig.allowedHeaders.join(", "));
+      }
+      if (req.method === "OPTIONS") {
+        res.status(204).end();
+        return;
+      }
+      next();
+    });
+  }
+  if (isDevelopment() && config.config?.devServer) {
+    app.use(createViteProxy(config.config.devServer));
+  }
+  const uiRoutes = createUIRoutes(config.uiResources, config.config?.devServer);
+  app.use("/ui", uiRoutes);
+  const executeTool = async (toolName, input, metadata = {}) => {
+    const tool = config.tools.get(toolName);
+    if (!tool) {
+      throw new Error(`Unknown tool: ${toolName}`);
+    }
+    const ctx = {
+      requestId: generateRequestId(),
+      toolName,
+      metadata
+    };
+    const startTime = Date.now();
+    try {
+      const result = await config.middlewareChain.execute(
+        { toolName, input, metadata },
+        () => tool.handler(input, ctx)
+      );
+      config.events.emit("tool:success", {
+        toolName,
+        result,
+        durationMs: Date.now() - startTime
+      });
+      return result;
+    } catch (error) {
+      config.events.emit("tool:error", {
+        toolName,
+        error,
+        durationMs: Date.now() - startTime
+      });
+      throw error;
+    }
+  };
+  const mcpRoute = config.config?.serverRoute ?? "/mcp";
+  const mcpHandler = createMcpHandler({
+    name: config.name,
+    version: config.version,
+    tools: config.tools,
+    uiResources: config.uiResources,
+    executeTool,
+    defaultProtocol: config.config?.protocol
+  });
+  app.post(mcpRoute, mcpHandler);
+  app.get("/health", (_req, res) => {
+    res.json({ status: "ok", name: config.name, version: config.version });
+  });
+  if (config.transport === "stdio") {
+    const { startStdioServer: startStdioServer2 } = await Promise.resolve().then(() => (init_stdio(), stdio_exports));
+    return startStdioServer2({
+      name: config.name,
+      version: config.version,
+      tools: config.tools,
+      uiResources: config.uiResources,
+      executeTool,
+      protocol: config.config?.protocol
+    });
+  }
+  return new Promise((resolve3) => {
+    const httpServer = app.listen(config.port, config.host, async () => {
+      const baseUrl = `http://localhost:${config.port}`;
+      const viewNames = config.viewNames ?? [];
+      const actionNames = config.actionNames ?? [];
+      const dataNames = config.dataNames ?? [];
+      let tunnel = null;
+      if (config.config?.tunnel) {
+        const provider = config.config.tunnel.provider;
+        const { isTunnelProviderAvailable: isTunnelProviderAvailable2, createTunnel: createTunnel2 } = await Promise.resolve().then(() => (init_tunnel(), tunnel_exports));
+        const isAvailable = await isTunnelProviderAvailable2(provider);
+        if (!isAvailable) {
+          console.log("");
+          console.log(`  \x1B[33m\u26A0\x1B[0m  Tunnel provider "${provider}" is not installed`);
+          if (provider === "cloudflare") {
+            console.log(`     Install with: \x1B[1mbrew install cloudflared\x1B[0m`);
+          } else {
+            console.log(`     Install with: \x1B[1mbrew install ngrok\x1B[0m`);
+          }
+          console.log(`     Continuing without tunnel...`);
+          console.log("");
+        } else {
+          console.log(`  \x1B[36m\u2192\x1B[0m  Starting ${provider} tunnel...`);
+          try {
+            const tunnelConfig = {
+              provider,
+              port: config.port
+            };
+            if (config.config.tunnel.authtoken) {
+              tunnelConfig.authtoken = config.config.tunnel.authtoken;
+            }
+            tunnel = await createTunnel2(tunnelConfig);
+            console.log(`  \x1B[32m\u2713\x1B[0m  Tunnel started: \x1B[1m${tunnel.url}\x1B[0m`);
+          } catch (error) {
+            console.log(`  \x1B[31m\u2717\x1B[0m  Tunnel failed: ${error.message}`);
+          }
+        }
+      }
+      if (config.config?.debug) {
+        console.log("");
+        console.log(`  \x1B[1m\x1B[32m\u2713\x1B[0m \x1B[1m${config.name}\x1B[0m is running`);
+        console.log("");
+        console.log(`  \x1B[2m\u279C\x1B[0m  \x1B[1mServer:\x1B[0m   ${baseUrl}`);
+        console.log(`  \x1B[2m\u279C\x1B[0m  \x1B[1mMCP:\x1B[0m      ${baseUrl}${mcpRoute}`);
+        if (viewNames.length > 0) {
+          console.log(`  \x1B[2m\u279C\x1B[0m  \x1B[1mViews:\x1B[0m    ${viewNames.map((v) => `${baseUrl}/ui/${v}`).join("\n              ")}`);
+        }
+        if (tunnel) {
+          const providerName = config.config.tunnel?.provider === "cloudflare" ? "Cloudflare" : "ngrok";
+          console.log("");
+          console.log(`  \x1B[1m\x1B[35m\u26A1\x1B[0m \x1B[1mTunnel (${providerName}):\x1B[0m`);
+          console.log(`  \x1B[2m\u279C\x1B[0m  \x1B[1mPublic:\x1B[0m   ${tunnel.url}`);
+          console.log(`  \x1B[2m\u279C\x1B[0m  \x1B[1mMCP:\x1B[0m      ${tunnel.url}${mcpRoute}`);
+          console.log("");
+          console.log(`  \x1B[33m\u26A0\x1B[0m  \x1B[2mTunnel URL is ephemeral and will change on restart\x1B[0m`);
+        }
+        console.log("");
+        console.log(`  \x1B[2mRegistered:\x1B[0m`);
+        console.log(`    ${viewNames.length} view${viewNames.length !== 1 ? "s" : ""}${viewNames.length > 0 ? ` (${viewNames.join(", ")})` : ""}`);
+        console.log(`    ${actionNames.length} action${actionNames.length !== 1 ? "s" : ""}${actionNames.length > 0 ? ` (${actionNames.join(", ")})` : ""}`);
+        console.log(`    ${dataNames.length} data fetcher${dataNames.length !== 1 ? "s" : ""}${dataNames.length > 0 ? ` (${dataNames.join(", ")})` : ""}`);
+        console.log("");
+        if (!tunnel) {
+          console.log(`  \x1B[2mNext steps:\x1B[0m`);
+          console.log(`    \x1B[36m1.\x1B[0m Open a view in your browser: ${baseUrl}/ui/${viewNames[0] || "yourView"}`);
+          console.log(`    \x1B[36m2.\x1B[0m Connect an MCP client to: ${baseUrl}${mcpRoute}`);
+          console.log(`    \x1B[36m3.\x1B[0m Expose for AI clients: \x1B[2mngrok http ${config.port}\x1B[0m or \x1B[2mcloudflared tunnel --url http://localhost:${config.port}\x1B[0m`);
+          console.log("");
+        } else {
+          console.log(`  \x1B[2mNext steps:\x1B[0m`);
+          console.log(`    \x1B[36m1.\x1B[0m Open a view in your browser: ${baseUrl}/ui/${viewNames[0] || "yourView"}`);
+          console.log(`    \x1B[36m2.\x1B[0m Connect an MCP client to: ${tunnel.url}${mcpRoute}`);
+          console.log("");
+        }
+      }
+      resolve3({
+        close: async () => {
+          if (tunnel) {
+            await tunnel.close();
+          }
+          return new Promise((resolveClose) => {
+            httpServer.close(() => resolveClose());
+          });
+        }
+      });
+    });
+  });
+}
+var init_server = __esm({
+  "src/server/index.ts"() {
+    init_mcp2();
+    init_routes();
+    init_dev_proxy();
+  }
+});
+
+// src/view.ts
+function isViewConfig(value) {
+  return typeof value === "object" && value !== null && "description" in value && "ui" in value;
+}
+
+// src/action.ts
+function isActionConfig(value) {
+  return typeof value === "object" && value !== null && "description" in value && "input" in value && "output" in value && "handler" in value;
+}
+
+// src/data.ts
+function isDataConfig(value) {
+  return typeof value === "object" && value !== null && "description" in value && "input" in value && "output" in value && "handler" in value && !("ui" in value);
+}
+
+// src/tool.ts
+function isToolConfig(value) {
+  return typeof value === "object" && value !== null && "name" in value && "description" in value && "input" in value && "output" in value && "handler" in value;
+}
+
+// src/normalizers.ts
+function toJsonSchema(schema) {
+  if (!schema) {
+    return { type: "object", properties: {} };
+  }
+  return zodToJsonSchema.zodToJsonSchema(schema);
+}
+function normalizeView(name, config) {
+  const toolName = `view:${name}`;
+  return {
+    name: toolName,
+    description: config.description,
+    inputSchema: toJsonSchema(config.input),
+    outputSchema: toJsonSchema(config.data),
+    handler: async (input, ctx) => {
+      if (config.handler) {
+        const validated = config.input ? config.input.parse(input) : input;
+        return config.handler(validated, {
+          ...ctx,
+          viewName: name
+        });
+      }
+      return {};
+    },
+    ui: config.ui,
+    visibility: config.visibility ?? "both",
+    category: "view"
+  };
+}
+function normalizeAction(name, config) {
+  const toolName = `action:${name}`;
+  return {
+    name: toolName,
+    description: config.description,
+    inputSchema: toJsonSchema(config.input),
+    outputSchema: toJsonSchema(config.output),
+    handler: async (input, ctx) => {
+      const validated = config.input.parse(input);
+      return config.handler(validated, {
+        ...ctx,
+        actionName: name
+      });
+    },
+    ui: config.ui,
+    visibility: config.visibility ?? "both",
+    category: "action"
+  };
+}
+function normalizeData(name, config) {
+  const toolName = `data:${name}`;
+  return {
+    name: toolName,
+    description: config.description,
+    inputSchema: toJsonSchema(config.input),
+    outputSchema: toJsonSchema(config.output),
+    handler: async (input, ctx) => {
+      const validated = config.input.parse(input);
+      return config.handler(validated, {
+        ...ctx,
+        dataName: name
+      });
+    },
+    ui: void 0,
+    // Data fetchers don't have UI
+    visibility: config.visibility ?? "both",
+    category: "data"
+  };
+}
+function normalizeTool(name, config) {
+  return {
+    name: config.name || name,
+    description: config.description,
+    inputSchema: toJsonSchema(config.input),
+    outputSchema: toJsonSchema(config.output),
+    handler: async (input, ctx) => {
+      const validated = config.input.parse(input);
+      return config.handler(validated, ctx);
+    },
+    ui: config.ui,
+    visibility: config.visibility ?? "both",
+    category: "tool"
+  };
+}
+
+// src/app.ts
+var TypedEventEmitter = class {
+  listeners = /* @__PURE__ */ new Map();
+  on(event, handler) {
+    const handlers = this.listeners.get(event) ?? /* @__PURE__ */ new Set();
+    handlers.add(handler);
+    this.listeners.set(event, handlers);
+    return () => handlers.delete(handler);
+  }
+  emit(event, payload) {
+    const handlers = this.listeners.get(event);
+    if (handlers) {
+      for (const handler of handlers) {
+        handler(payload);
+      }
+    }
+  }
+};
+var MiddlewareChain = class {
+  middlewares = [];
+  constructor(initial) {
+    if (initial) {
+      this.middlewares = [...initial];
+    }
+  }
+  add(middleware) {
+    this.middlewares.push(middleware);
+  }
+  async execute(ctx, handler) {
+    const state = /* @__PURE__ */ new Map();
+    const middlewareCtx = { ...ctx, state };
+    let index = 0;
+    let result;
+    const next = async () => {
+      if (index < this.middlewares.length) {
+        const mw = this.middlewares[index++];
+        await mw(middlewareCtx, next);
+      } else {
+        result = await handler();
+      }
+    };
+    await next();
+    return result;
+  }
+};
+var PluginManager = class {
+  constructor(plugins = []) {
+    this.plugins = plugins;
+  }
+  async runHook(hook, context) {
+    for (const plugin of this.plugins) {
+      const fn = plugin[hook];
+      if (typeof fn === "function") {
+        await fn.call(plugin, context);
+      }
+    }
+  }
+};
+function createApp(config) {
+  if (!config.name) {
+    throw new Error("App name is required");
+  }
+  if (!config.version) {
+    throw new Error("App version is required");
+  }
+  const events = new TypedEventEmitter();
+  const middlewareChain = new MiddlewareChain(config.middleware);
+  const pluginManager = new PluginManager(config.plugins);
+  const tools = /* @__PURE__ */ new Map();
+  const uiResources = /* @__PURE__ */ new Map();
+  for (const [name, viewConfig] of Object.entries(config.views ?? {})) {
+    const tool = normalizeView(name, viewConfig);
+    tools.set(tool.name, tool);
+    if (tool.ui) {
+      const uri = `pancake://ui/view/${name}`;
+      uiResources.set(uri, {
+        name,
+        uri,
+        definition: tool.ui
+      });
+    }
+  }
+  for (const [name, actionConfig] of Object.entries(config.actions ?? {})) {
+    const tool = normalizeAction(name, actionConfig);
+    tools.set(tool.name, tool);
+    if (tool.ui) {
+      const uri = `pancake://ui/action/${name}`;
+      uiResources.set(uri, {
+        name,
+        uri,
+        definition: tool.ui
+      });
+    }
+  }
+  for (const [name, dataConfig] of Object.entries(config.data ?? {})) {
+    const tool = normalizeData(name, dataConfig);
+    tools.set(tool.name, tool);
+  }
+  for (const [name, toolConfig] of Object.entries(config.tools ?? {})) {
+    const tool = normalizeTool(name, toolConfig);
+    tools.set(tool.name, tool);
+    if (tool.ui) {
+      const uri = `pancake://ui/tool/${name}`;
+      uiResources.set(uri, {
+        name,
+        uri,
+        definition: tool.ui
+      });
+    }
+  }
+  events.emit("app:init", { config });
+  let server = null;
+  const app = {
+    async start(options = {}) {
+      const port = options.port ?? 3e3;
+      const host = options.host ?? "0.0.0.0";
+      const transport = options.transport ?? "http";
+      for (const plugin of config.plugins ?? []) {
+        await pluginManager.runHook("onInit", { app: config, plugin });
+      }
+      const { createServer: createServer3 } = await Promise.resolve().then(() => (init_server(), server_exports));
+      const serverConfig = {
+        name: config.name,
+        version: config.version,
+        tools,
+        uiResources,
+        middlewareChain,
+        events,
+        port,
+        host,
+        transport,
+        viewNames: Object.keys(config.views ?? {}),
+        actionNames: Object.keys(config.actions ?? {}),
+        dataNames: Object.keys(config.data ?? {})
+      };
+      if (config.config) {
+        const cfg = {};
+        if (config.config.cors !== void 0) cfg.cors = config.config.cors;
+        if (config.config.debug !== void 0) cfg.debug = config.config.debug;
+        if (config.config.serverRoute !== void 0) cfg.serverRoute = config.config.serverRoute;
+        if (config.config.devServer !== void 0) cfg.devServer = config.config.devServer;
+        if (config.config.protocol !== void 0) cfg.protocol = config.config.protocol;
+        if (config.config.tunnel !== void 0) cfg.tunnel = config.config.tunnel;
+        serverConfig.config = cfg;
+      }
+      server = await createServer3(serverConfig);
+      for (const plugin of config.plugins ?? []) {
+        await pluginManager.runHook("onStart", { app: config, plugin });
+      }
+      events.emit("app:start", { port, transport });
+    },
+    async stop() {
+      if (server) {
+        for (const plugin of config.plugins ?? []) {
+          await pluginManager.runHook("onShutdown", { app: config, plugin });
+        }
+        await server.close();
+        server = null;
+        events.emit("app:shutdown", { graceful: true });
+      }
+    },
+    handler() {
+      return async (_req, _res, next) => {
+        next();
+      };
+    },
+    async handleRequest(_req) {
+      return new Response("Not implemented", { status: 501 });
+    },
+    use(middleware) {
+      middlewareChain.add(middleware);
+    },
+    on(event, handler) {
+      return events.on(event, handler);
+    }
+  };
+  return app;
+}
+
+// src/helpers.ts
+function defineView(config) {
+  return config;
+}
+function defineAction(config) {
+  return config;
+}
+function defineData(config) {
+  return config;
+}
+function defineTool(config) {
+  return config;
+}
+function discoverViews(dir) {
+  const views = {};
+  const absoluteDir = path2__namespace.resolve(process.cwd(), dir);
+  try {
+    const entries = fsSync__namespace.readdirSync(absoluteDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const indexHtml = path2__namespace.join(absoluteDir, entry.name, "index.html");
+        const metadataJson = path2__namespace.join(absoluteDir, entry.name, "metadata.json");
+        if (fileExistsSync(indexHtml) && fileExistsSync(metadataJson)) {
+          const metadata = parseMetadataSync(metadataJson);
+          views[entry.name] = createViewFromDiscovery(entry.name, indexHtml, metadata);
+        }
+      } else if (entry.name.endsWith(".html")) {
+        const baseName = entry.name.replace(".html", "");
+        const metadataPath = path2__namespace.join(absoluteDir, `${baseName}.json`);
+        const htmlPath = path2__namespace.join(absoluteDir, entry.name);
+        if (fileExistsSync(metadataPath)) {
+          const metadata = parseMetadataSync(metadataPath);
+          views[baseName] = createViewFromDiscovery(baseName, htmlPath, metadata);
+        }
+      }
+    }
+  } catch (error) {
+    console.warn(`[Pancake] Could not discover views from ${dir}:`, error);
+  }
+  return views;
+}
+async function discoverViewsAsync(dir) {
+  const views = {};
+  const absoluteDir = path2__namespace.resolve(process.cwd(), dir);
+  try {
+    const entries = await fs2__namespace.readdir(absoluteDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const indexHtml = path2__namespace.join(absoluteDir, entry.name, "index.html");
+        const metadataJson = path2__namespace.join(absoluteDir, entry.name, "metadata.json");
+        if (await fileExists(indexHtml) && await fileExists(metadataJson)) {
+          const metadata = await parseMetadata(metadataJson);
+          views[entry.name] = createViewFromDiscovery(entry.name, indexHtml, metadata);
+        }
+      } else if (entry.name.endsWith(".html")) {
+        const baseName = entry.name.replace(".html", "");
+        const metadataPath = path2__namespace.join(absoluteDir, `${baseName}.json`);
+        const htmlPath = path2__namespace.join(absoluteDir, entry.name);
+        if (await fileExists(metadataPath)) {
+          const metadata = await parseMetadata(metadataPath);
+          views[baseName] = createViewFromDiscovery(baseName, htmlPath, metadata);
+        }
+      }
+    }
+  } catch (error) {
+    console.warn(`[Pancake] Could not discover views from ${dir}:`, error);
+  }
+  return views;
+}
+async function fileExists(filePath) {
+  try {
+    await fs2__namespace.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function fileExistsSync(filePath) {
+  try {
+    fsSync__namespace.accessSync(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function parseMetadata(filePath) {
+  const content = await fs2__namespace.readFile(filePath, "utf-8");
+  return JSON.parse(content);
+}
+function parseMetadataSync(filePath) {
+  const content = fsSync__namespace.readFileSync(filePath, "utf-8");
+  return JSON.parse(content);
+}
+function createViewFromDiscovery(name, htmlPath, metadata) {
+  return {
+    description: metadata.description,
+    // Note: input/data from JSON are JSON Schema, not Zod
+    // We'll need to handle this specially in the normalizer
+    visibility: metadata.visibility ?? "both",
+    ui: {
+      html: htmlPath,
+      name
+    }
+  };
+}
+
+// src/index.ts
+init_tunnel();
+function isPortAvailable(port, host = "0.0.0.0") {
+  return new Promise((resolve3) => {
+    const server = net__namespace.createServer();
+    server.once("error", () => {
+      resolve3(false);
+    });
+    server.once("listening", () => {
+      server.close(() => resolve3(true));
+    });
+    server.listen(port, host);
+  });
+}
+async function getAvailablePort(options = {}) {
+  const { startPort = 3e3, host = "0.0.0.0", maxAttempts = 100 } = options;
+  for (let i = 0; i < maxAttempts; i++) {
+    const port = startPort + i;
+    if (await isPortAvailable(port, host)) {
+      return port;
+    }
+  }
+  throw new Error(`No available port found after ${maxAttempts} attempts starting from ${startPort}`);
+}
+async function getAvailablePorts(preferredPorts, host = "0.0.0.0") {
+  const assignedPorts = /* @__PURE__ */ new Set();
+  const results = [];
+  for (const preferred of preferredPorts) {
+    let port = preferred;
+    let attempts = 0;
+    const maxAttempts = 100;
+    while (attempts < maxAttempts) {
+      if (!assignedPorts.has(port) && await isPortAvailable(port, host)) {
+        assignedPorts.add(port);
+        results.push(port);
+        break;
+      }
+      port++;
+      attempts++;
+    }
+    if (attempts === maxAttempts) {
+      throw new Error(`Could not find available port starting from ${preferred}`);
+    }
+  }
+  return results;
+}
+
+exports.createApp = createApp;
+exports.createTunnel = createTunnel;
+exports.defineAction = defineAction;
+exports.defineData = defineData;
+exports.defineTool = defineTool;
+exports.defineView = defineView;
+exports.discoverViews = discoverViews;
+exports.discoverViewsAsync = discoverViewsAsync;
+exports.getAvailablePort = getAvailablePort;
+exports.getAvailablePorts = getAvailablePorts;
+exports.isActionConfig = isActionConfig;
+exports.isDataConfig = isDataConfig;
+exports.isPortAvailable = isPortAvailable;
+exports.isToolConfig = isToolConfig;
+exports.isTunnelProviderAvailable = isTunnelProviderAvailable;
+exports.isViewConfig = isViewConfig;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map