@pancake-apps/server 0.0.1

package/dist/index.cjs

@@ -0,0 +1,985 @@
+'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 zodToJsonSchema = require('zod-to-json-schema');
+var fsSync = require('fs');
+
+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 __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/server/mcp.ts
+function visibilityToAudience(visibility) {
+  switch (visibility) {
+    case "model":
+      return ["assistant"];
+    case "app":
+      return ["user"];
+    case "both":
+    default:
+      return ["assistant", "user"];
+  }
+}
+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 result = await handleMethod(config, request.method, request.params ?? {});
+      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) {
+  switch (method) {
+    case "initialize":
+      return {
+        protocolVersion: "2024-11-05",
+        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) => ({
+          name: tool.name,
+          description: tool.description,
+          inputSchema: tool.inputSchema,
+          annotations: {
+            audience: visibilityToAudience(tool.visibility)
+          },
+          _meta: tool.ui ? {
+            ui: {
+              visibility: visibilityToAudience(tool.visibility),
+              resourceUri: getUIResourceUri(tool.name, tool.category)
+            }
+          } : 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) => ({
+          uri: resource.uri,
+          name: resource.name,
+          mimeType: "text/html;profile=mcp-app",
+          _meta: {
+            ui: {
+              prefersBorder: resource.definition.prefersBorder,
+              autoResize: resource.definition.autoResize,
+              csp: resource.definition.csp
+            }
+          }
+        }))
+      };
+    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_mcp = __esm({
+  "src/server/mcp.ts"() {
+  }
+});
+
+// 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/"
+  ];
+  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) => {
+        res.setHeader(key, value);
+      });
+      res.status(response.status);
+      if (response.body) {
+        const reader = response.body.getReader();
+        const pump = async () => {
+          const { done, value } = await reader.read();
+          if (done) {
+            res.end();
+            return;
+          }
+          res.write(Buffer.from(value));
+          return pump();
+        };
+        await pump();
+      } else {
+        res.end();
+      }
+    } catch (error) {
+      if (isDevelopment()) {
+        console.warn(`[Pancake] Vite proxy failed for ${req.path}:`, error);
+      }
+      next();
+    }
+  };
+}
+function generateHMRTemplate(serverUrl, 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>
+    <base href="${serverUrl}/" />
+    <script type="module">
+      import { injectIntoGlobalHook } from "${serverUrl}/@react-refresh";
+      injectIntoGlobalHook(window);
+      window.$RefreshReg$ = () => {};
+      window.$RefreshSig$ = () => (type) => type;
+      window.__vite_plugin_react_preamble_installed__ = true;
+    </script>
+    <script type="module" src="${serverUrl}/@vite/client"></script>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module">
+      // Initialize Pancake client before loading the view
+      import('${serverUrl}/src/pancake-init.ts')
+        .then(async (mod) => {
+          if (mod.init) await mod.init();
+        })
+        .catch(() => {
+          // pancake-init.ts might not exist, that's ok
+        })
+        .finally(() => {
+          import('${serverUrl}/src/views/${viewName}/index.tsx')
+            .catch(() => import('${serverUrl}/src/views/${viewName}.tsx'))
+            .catch(() => import('${serverUrl}/src/views/${viewName}/index.ts'))
+            .catch(() => import('${serverUrl}/src/views/${viewName}.ts'))
+            .catch((err) => {
+              console.error('Failed to load view:', err);
+              document.body.innerHTML = '<pre style="color: red;">Failed to load view: ' + err.message + '</pre>';
+            });
+        });
+    </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) {
+    const vitePort = devServerConfig.vitePort ?? 5173;
+    return generateHMRTemplate(`http://localhost:${vitePort}`, 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
+});
+function visibilityToAudience2(visibility) {
+  switch (visibility) {
+    case "model":
+      return ["assistant"];
+    case "app":
+      return ["user"];
+    case "both":
+    default:
+      return ["assistant", "user"];
+  }
+}
+async function startStdioServer(config) {
+  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) => ({
+          name: tool.name,
+          description: tool.description,
+          inputSchema: tool.inputSchema,
+          annotations: {
+            audience: visibilityToAudience2(tool.visibility)
+          },
+          _meta: tool.ui ? {
+            ui: {
+              visibility: visibilityToAudience2(tool.visibility),
+              resourceUri: getUIResourceUri2(tool.name, tool.category)
+            }
+          } : 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) => ({
+          uri: resource.uri,
+          name: resource.name,
+          mimeType: "text/html;profile=mcp-app",
+          _meta: {
+            ui: {
+              prefersBorder: resource.definition.prefersBorder,
+              autoResize: resource.definition.autoResize,
+              csp: resource.definition.csp
+            }
+          }
+        }))
+      };
+    }
+  );
+  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"() {
+  }
+});
+
+// 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) {
+    const viteProxy = createViteProxy(config.config.devServer);
+    app.use(viteProxy);
+  }
+  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
+  });
+  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
+    });
+  }
+  return new Promise((resolve3) => {
+    const httpServer = app.listen(config.port, config.host, () => {
+      if (config.config?.debug) {
+        console.log(`Pancake server "${config.name}" running on http://${config.host}:${config.port}`);
+        console.log(`  MCP endpoint: ${mcpRoute}`);
+        console.log(`  UI endpoint: /ui/:viewName`);
+        console.log(`  Tools registered: ${config.tools.size}`);
+      }
+      resolve3({
+        close: () => new Promise((resolveClose) => {
+          httpServer.close(() => resolveClose());
+        })
+      });
+    });
+  });
+}
+var init_server = __esm({
+  "src/server/index.ts"() {
+    init_mcp();
+    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: createServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+      const serverConfig = {
+        name: config.name,
+        version: config.version,
+        tools,
+        uiResources,
+        middlewareChain,
+        events,
+        port,
+        host,
+        transport
+      };
+      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;
+        serverConfig.config = cfg;
+      }
+      server = await createServer2(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;
+}
+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
+    }
+  };
+}
+
+exports.createApp = createApp;
+exports.discoverViews = discoverViews;
+exports.discoverViewsAsync = discoverViewsAsync;
+exports.isActionConfig = isActionConfig;
+exports.isDataConfig = isDataConfig;
+exports.isToolConfig = isToolConfig;
+exports.isViewConfig = isViewConfig;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map