@getworkbench/core 0.1.0 → 0.2.1

package/dist/index.js

@@ -1,297 +1,3 @@
-// src/index.ts
-import { dirname, join } from "path";
-import { fileURLToPath } from "url";
-
-// src/api/router.ts
-import { Hono } from "hono";
-function parseSort(sort) {
-  if (!sort) return void 0;
-  const [field, dir] = sort.split(":");
-  if (!field) return void 0;
-  return {
-    field,
-    direction: dir === "asc" ? "asc" : "desc"
-  };
-}
-function createApiRoutes(core) {
-  const app = new Hono();
-  const qm = core.queueManager;
-  app.post("/refresh", async (c) => {
-    qm.clearCache();
-    return c.json({ success: true });
-  });
-  app.get("/overview", async (c) => {
-    const stats = await qm.getOverview();
-    return c.json(stats);
-  });
-  app.get("/counts", async (c) => {
-    const counts = await qm.getQuickCounts();
-    return c.json(counts);
-  });
-  app.get("/runs", async (c) => {
-    const limit = Number(c.req.query("limit")) || 50;
-    const cursor = c.req.query("cursor");
-    const start = cursor ? Number(cursor) : 0;
-    const sort = parseSort(c.req.query("sort"));
-    const status = c.req.query("status");
-    const q = c.req.query("q");
-    const from = c.req.query("from");
-    const to = c.req.query("to");
-    const tagsParam = c.req.query("tags");
-    let tags;
-    if (tagsParam) {
-      try {
-        tags = JSON.parse(tagsParam);
-      } catch {
-        const tagPairs = tagsParam.split(",");
-        tags = {};
-        for (const pair of tagPairs) {
-          const [key, value] = pair.split(":");
-          if (key && value) {
-            tags[key.trim()] = value.trim();
-          }
-        }
-      }
-    }
-    let timeRange;
-    if (from && to) {
-      timeRange = {
-        start: Number(from),
-        end: Number(to)
-      };
-    }
-    let text;
-    if (q) {
-      if (!q.includes(":")) {
-        text = q;
-      } else {
-        const parts = q.split(" ");
-        const textParts = parts.filter((p) => !p.includes(":"));
-        if (textParts.length > 0) {
-          text = textParts.join(" ");
-        }
-      }
-    }
-    const filters = status || tags || text || timeRange ? {
-      status,
-      tags,
-      text,
-      timeRange
-    } : void 0;
-    const result = await qm.getAllRuns(limit, start, sort, filters);
-    return c.json(result);
-  });
-  app.get("/schedulers", async (c) => {
-    const repeatableSort = parseSort(c.req.query("repeatableSort"));
-    const delayedSort = parseSort(c.req.query("delayedSort"));
-    const result = await qm.getSchedulers(repeatableSort, delayedSort);
-    return c.json(result);
-  });
-  app.post("/test", async (c) => {
-    if (core.options.readonly) {
-      return c.json({ error: "Dashboard is in readonly mode" }, 403);
-    }
-    const body = await c.req.json();
-    if (!body.queueName || !body.jobName) {
-      return c.json({ error: "queueName and jobName are required" }, 400);
-    }
-    try {
-      const result = await qm.enqueueJob(body);
-      return c.json(result);
-    } catch (e) {
-      return c.json({ error: e.message }, 400);
-    }
-  });
-  app.get("/queue-names", (c) => {
-    const names = qm.getQueueNames();
-    return c.json(names);
-  });
-  app.get("/queues", async (c) => {
-    const queues = await qm.getQueues();
-    return c.json(queues);
-  });
-  app.get("/metrics", async (c) => {
-    const metrics = await qm.getMetrics();
-    return c.json(metrics);
-  });
-  app.get("/activity", async (c) => {
-    const stats = await qm.getActivityStats();
-    return c.json(stats);
-  });
-  app.get("/queues/:name/jobs", async (c) => {
-    const { name } = c.req.param();
-    const status = c.req.query("status");
-    const limit = Number(c.req.query("limit")) || 50;
-    const cursor = c.req.query("cursor");
-    const start = cursor ? Number(cursor) : 0;
-    const sort = parseSort(c.req.query("sort"));
-    const result = await qm.getJobs(name, status, limit, start, sort);
-    return c.json(result);
-  });
-  app.get("/jobs/:queue/:id", async (c) => {
-    const { queue, id } = c.req.param();
-    const job = await qm.getJob(queue, id);
-    if (!job) {
-      return c.json({ error: "Job not found" }, 404);
-    }
-    return c.json(job);
-  });
-  app.post("/jobs/:queue/:id/retry", async (c) => {
-    if (core.options.readonly) {
-      return c.json({ error: "Dashboard is in readonly mode" }, 403);
-    }
-    const { queue, id } = c.req.param();
-    const success = await qm.retryJob(queue, id);
-    if (!success) {
-      return c.json({ error: "Failed to retry job" }, 400);
-    }
-    return c.json({ success: true });
-  });
-  app.post("/jobs/:queue/:id/remove", async (c) => {
-    if (core.options.readonly) {
-      return c.json({ error: "Dashboard is in readonly mode" }, 403);
-    }
-    const { queue, id } = c.req.param();
-    const success = await qm.removeJob(queue, id);
-    if (!success) {
-      return c.json({ error: "Failed to remove job" }, 400);
-    }
-    return c.json({ success: true });
-  });
-  app.post("/jobs/:queue/:id/promote", async (c) => {
-    if (core.options.readonly) {
-      return c.json({ error: "Dashboard is in readonly mode" }, 403);
-    }
-    const { queue, id } = c.req.param();
-    const success = await qm.promoteJob(queue, id);
-    if (!success) {
-      return c.json({ error: "Failed to promote job" }, 400);
-    }
-    return c.json({ success: true });
-  });
-  app.get("/search", async (c) => {
-    const query = c.req.query("q") || "";
-    const limit = Number(c.req.query("limit")) || 20;
-    if (!query) {
-      return c.json({ results: [] });
-    }
-    const results = await qm.search(query, limit);
-    return c.json({ results });
-  });
-  app.get("/tags/:field/values", async (c) => {
-    const { field } = c.req.param();
-    const limit = Number(c.req.query("limit")) || 50;
-    const tagFields = qm.getTagFields();
-    if (tagFields.length > 0 && !tagFields.includes(field)) {
-      return c.json(
-        { error: `Field "${field}" is not a configured tag field` },
-        400
-      );
-    }
-    const values = await qm.getTagValues(field, limit);
-    return c.json({ field, values });
-  });
-  app.post("/queues/:name/clean", async (c) => {
-    if (core.options.readonly) {
-      return c.json({ error: "Dashboard is in readonly mode" }, 403);
-    }
-    const { name } = c.req.param();
-    const body = await c.req.json();
-    const count = await qm.cleanJobs(name, body.status, body.grace || 0);
-    return c.json({ removed: count });
-  });
-  app.post("/bulk/retry", async (c) => {
-    if (core.options.readonly) {
-      return c.json({ error: "Dashboard is in readonly mode" }, 403);
-    }
-    const body = await c.req.json();
-    const result = await qm.bulkRetry(body.jobs);
-    return c.json(result);
-  });
-  app.post("/bulk/delete", async (c) => {
-    if (core.options.readonly) {
-      return c.json({ error: "Dashboard is in readonly mode" }, 403);
-    }
-    const body = await c.req.json();
-    const result = await qm.bulkDelete(body.jobs);
-    return c.json(result);
-  });
-  app.post("/bulk/promote", async (c) => {
-    if (core.options.readonly) {
-      return c.json({ error: "Dashboard is in readonly mode" }, 403);
-    }
-    const body = await c.req.json();
-    const result = await qm.bulkPromote(body.jobs);
-    return c.json(result);
-  });
-  app.post("/queues/:name/pause", async (c) => {
-    if (core.options.readonly) {
-      return c.json({ error: "Dashboard is in readonly mode" }, 403);
-    }
-    const { name } = c.req.param();
-    try {
-      await qm.pauseQueue(name);
-      return c.json({ success: true, paused: true });
-    } catch (error) {
-      return c.json(
-        {
-          error: error instanceof Error ? error.message : "Failed to pause queue"
-        },
-        404
-      );
-    }
-  });
-  app.post("/queues/:name/resume", async (c) => {
-    if (core.options.readonly) {
-      return c.json({ error: "Dashboard is in readonly mode" }, 403);
-    }
-    const { name } = c.req.param();
-    try {
-      await qm.resumeQueue(name);
-      return c.json({ success: true, paused: false });
-    } catch (error) {
-      return c.json(
-        {
-          error: error instanceof Error ? error.message : "Failed to resume queue"
-        },
-        404
-      );
-    }
-  });
-  app.get("/flows", async (c) => {
-    const limit = Number(c.req.query("limit")) || 50;
-    const flows = await qm.getFlows(limit);
-    return c.json({ flows });
-  });
-  app.get("/flows/:queueName/:jobId", async (c) => {
-    const { queueName, jobId } = c.req.param();
-    const flow = await qm.getFlow(queueName, jobId);
-    if (!flow) {
-      return c.json({ error: "Flow not found" }, 404);
-    }
-    return c.json(flow);
-  });
-  app.post("/flows", async (c) => {
-    if (core.options.readonly) {
-      return c.json({ error: "Dashboard is in readonly mode" }, 403);
-    }
-    const body = await c.req.json();
-    if (!body.name || !body.queueName || !body.children?.length) {
-      return c.json(
-        { error: "name, queueName, and children are required" },
-        400
-      );
-    }
-    try {
-      const result = await qm.createFlow(body);
-      return c.json(result);
-    } catch (e) {
-      return c.json({ error: e.message }, 400);
-    }
-  });
-  return app;
-}
-
 // src/core/queue-manager.ts
 import { FlowProducer } from "bullmq";
 import { LRUCache } from "lru-cache";
@@ -2036,12 +1742,651 @@ var WorkbenchCore = class {
   }
 };
 
-// src/index.ts
+// src/server/hono-app.ts
+import { Hono as Hono2 } from "hono";
+import { basicAuth } from "hono/basic-auth";
+import { cors } from "hono/cors";
+
+// src/api/router.ts
+import { Hono } from "hono";
+
+// src/api/handlers.ts
+function parseSort(sort) {
+  if (!sort) return void 0;
+  const [field, dir] = sort.split(":");
+  if (!field) return void 0;
+  return {
+    field,
+    direction: dir === "asc" ? "asc" : "desc"
+  };
+}
+var readonlyError = {
+  status: 403,
+  body: { error: "Dashboard is in readonly mode" }
+};
+function buildRouteTable(core) {
+  const qm = core.queueManager;
+  const isReadonly = () => !!core.options.readonly;
+  return [
+    {
+      method: "post",
+      path: "/refresh",
+      handler: async () => {
+        qm.clearCache();
+        return { status: 200, body: { success: true } };
+      }
+    },
+    {
+      method: "get",
+      path: "/overview",
+      handler: async () => ({
+        status: 200,
+        body: await qm.getOverview()
+      })
+    },
+    {
+      method: "get",
+      path: "/counts",
+      handler: async () => ({
+        status: 200,
+        body: await qm.getQuickCounts()
+      })
+    },
+    {
+      method: "get",
+      path: "/runs",
+      handler: async ({ query }) => {
+        const limit = Number(query.limit) || 50;
+        const cursor = query.cursor;
+        const start = cursor ? Number(cursor) : 0;
+        const sort = parseSort(query.sort);
+        const status = query.status;
+        const q = query.q;
+        const from = query.from;
+        const to = query.to;
+        const tagsParam = query.tags;
+        let tags;
+        if (tagsParam) {
+          try {
+            tags = JSON.parse(tagsParam);
+          } catch {
+            const tagPairs = tagsParam.split(",");
+            tags = {};
+            for (const pair of tagPairs) {
+              const [key, value] = pair.split(":");
+              if (key && value) {
+                tags[key.trim()] = value.trim();
+              }
+            }
+          }
+        }
+        let timeRange;
+        if (from && to) {
+          timeRange = {
+            start: Number(from),
+            end: Number(to)
+          };
+        }
+        let text;
+        if (q) {
+          if (!q.includes(":")) {
+            text = q;
+          } else {
+            const parts = q.split(" ");
+            const textParts = parts.filter((p) => !p.includes(":"));
+            if (textParts.length > 0) {
+              text = textParts.join(" ");
+            }
+          }
+        }
+        const filters = status || tags || text || timeRange ? {
+          status,
+          tags,
+          text,
+          timeRange
+        } : void 0;
+        return {
+          status: 200,
+          body: await qm.getAllRuns(limit, start, sort, filters)
+        };
+      }
+    },
+    {
+      method: "get",
+      path: "/schedulers",
+      handler: async ({ query }) => {
+        const repeatableSort = parseSort(query.repeatableSort);
+        const delayedSort = parseSort(query.delayedSort);
+        return {
+          status: 200,
+          body: await qm.getSchedulers(repeatableSort, delayedSort)
+        };
+      }
+    },
+    {
+      method: "post",
+      path: "/test",
+      handler: async ({ body }) => {
+        if (isReadonly()) return readonlyError;
+        const req = body;
+        if (!req?.queueName || !req.jobName) {
+          return {
+            status: 400,
+            body: { error: "queueName and jobName are required" }
+          };
+        }
+        try {
+          const result = await qm.enqueueJob(req);
+          return { status: 200, body: result };
+        } catch (e) {
+          return { status: 400, body: { error: e.message } };
+        }
+      }
+    },
+    {
+      method: "get",
+      path: "/queue-names",
+      handler: async () => ({
+        status: 200,
+        body: qm.getQueueNames()
+      })
+    },
+    {
+      method: "get",
+      path: "/queues",
+      handler: async () => ({
+        status: 200,
+        body: await qm.getQueues()
+      })
+    },
+    {
+      method: "get",
+      path: "/metrics",
+      handler: async () => ({
+        status: 200,
+        body: await qm.getMetrics()
+      })
+    },
+    {
+      method: "get",
+      path: "/activity",
+      handler: async () => ({
+        status: 200,
+        body: await qm.getActivityStats()
+      })
+    },
+    {
+      method: "get",
+      path: "/queues/:name/jobs",
+      handler: async ({ params, query }) => {
+        const name = params.name;
+        const status = query.status;
+        const limit = Number(query.limit) || 50;
+        const cursor = query.cursor;
+        const start = cursor ? Number(cursor) : 0;
+        const sort = parseSort(query.sort);
+        return {
+          status: 200,
+          body: await qm.getJobs(name, status, limit, start, sort)
+        };
+      }
+    },
+    {
+      method: "get",
+      path: "/jobs/:queue/:id",
+      handler: async ({ params }) => {
+        const job = await qm.getJob(params.queue, params.id);
+        if (!job) {
+          return { status: 404, body: { error: "Job not found" } };
+        }
+        return { status: 200, body: job };
+      }
+    },
+    {
+      method: "post",
+      path: "/jobs/:queue/:id/retry",
+      handler: async ({ params }) => {
+        if (isReadonly()) return readonlyError;
+        const success = await qm.retryJob(params.queue, params.id);
+        if (!success) {
+          return { status: 400, body: { error: "Failed to retry job" } };
+        }
+        return { status: 200, body: { success: true } };
+      }
+    },
+    {
+      method: "post",
+      path: "/jobs/:queue/:id/remove",
+      handler: async ({ params }) => {
+        if (isReadonly()) return readonlyError;
+        const success = await qm.removeJob(params.queue, params.id);
+        if (!success) {
+          return { status: 400, body: { error: "Failed to remove job" } };
+        }
+        return { status: 200, body: { success: true } };
+      }
+    },
+    {
+      method: "post",
+      path: "/jobs/:queue/:id/promote",
+      handler: async ({ params }) => {
+        if (isReadonly()) return readonlyError;
+        const success = await qm.promoteJob(params.queue, params.id);
+        if (!success) {
+          return { status: 400, body: { error: "Failed to promote job" } };
+        }
+        return { status: 200, body: { success: true } };
+      }
+    },
+    {
+      method: "get",
+      path: "/search",
+      handler: async ({ query }) => {
+        const q = query.q || "";
+        const limit = Number(query.limit) || 20;
+        if (!q) return { status: 200, body: { results: [] } };
+        const results = await qm.search(q, limit);
+        return { status: 200, body: { results } };
+      }
+    },
+    {
+      method: "get",
+      path: "/tags/:field/values",
+      handler: async ({ params, query }) => {
+        const field = params.field;
+        const limit = Number(query.limit) || 50;
+        const tagFields = qm.getTagFields();
+        if (tagFields.length > 0 && !tagFields.includes(field)) {
+          return {
+            status: 400,
+            body: {
+              error: `Field "${field}" is not a configured tag field`
+            }
+          };
+        }
+        const values = await qm.getTagValues(field, limit);
+        return { status: 200, body: { field, values } };
+      }
+    },
+    {
+      method: "post",
+      path: "/queues/:name/clean",
+      handler: async ({ params, body }) => {
+        if (isReadonly()) return readonlyError;
+        const req = body;
+        if (!req) {
+          return { status: 400, body: { error: "Body required" } };
+        }
+        const count = await qm.cleanJobs(
+          params.name,
+          req.status,
+          req.grace || 0
+        );
+        return { status: 200, body: { removed: count } };
+      }
+    },
+    {
+      method: "post",
+      path: "/bulk/retry",
+      handler: async ({ body }) => {
+        if (isReadonly()) return readonlyError;
+        const req = body;
+        if (!req?.jobs) {
+          return { status: 400, body: { error: "jobs is required" } };
+        }
+        return { status: 200, body: await qm.bulkRetry(req.jobs) };
+      }
+    },
+    {
+      method: "post",
+      path: "/bulk/delete",
+      handler: async ({ body }) => {
+        if (isReadonly()) return readonlyError;
+        const req = body;
+        if (!req?.jobs) {
+          return { status: 400, body: { error: "jobs is required" } };
+        }
+        return { status: 200, body: await qm.bulkDelete(req.jobs) };
+      }
+    },
+    {
+      method: "post",
+      path: "/bulk/promote",
+      handler: async ({ body }) => {
+        if (isReadonly()) return readonlyError;
+        const req = body;
+        if (!req?.jobs) {
+          return { status: 400, body: { error: "jobs is required" } };
+        }
+        return { status: 200, body: await qm.bulkPromote(req.jobs) };
+      }
+    },
+    {
+      method: "post",
+      path: "/queues/:name/pause",
+      handler: async ({ params }) => {
+        if (isReadonly()) return readonlyError;
+        try {
+          await qm.pauseQueue(params.name);
+          return { status: 200, body: { success: true, paused: true } };
+        } catch (error) {
+          return {
+            status: 404,
+            body: {
+              error: error instanceof Error ? error.message : "Failed to pause queue"
+            }
+          };
+        }
+      }
+    },
+    {
+      method: "post",
+      path: "/queues/:name/resume",
+      handler: async ({ params }) => {
+        if (isReadonly()) return readonlyError;
+        try {
+          await qm.resumeQueue(params.name);
+          return { status: 200, body: { success: true, paused: false } };
+        } catch (error) {
+          return {
+            status: 404,
+            body: {
+              error: error instanceof Error ? error.message : "Failed to resume queue"
+            }
+          };
+        }
+      }
+    },
+    {
+      method: "get",
+      path: "/flows",
+      handler: async ({ query }) => {
+        const limit = Number(query.limit) || 50;
+        const flows = await qm.getFlows(limit);
+        return { status: 200, body: { flows } };
+      }
+    },
+    {
+      method: "get",
+      path: "/flows/:queueName/:jobId",
+      handler: async ({ params }) => {
+        const flow = await qm.getFlow(params.queueName, params.jobId);
+        if (!flow) {
+          return { status: 404, body: { error: "Flow not found" } };
+        }
+        return { status: 200, body: flow };
+      }
+    },
+    {
+      method: "post",
+      path: "/flows",
+      handler: async ({ body }) => {
+        if (isReadonly()) return readonlyError;
+        const req = body;
+        if (!req?.name || !req.queueName || !req.children?.length) {
+          return {
+            status: 400,
+            body: { error: "name, queueName, and children are required" }
+          };
+        }
+        try {
+          const result = await qm.createFlow(req);
+          return { status: 200, body: result };
+        } catch (e) {
+          return { status: 400, body: { error: e.message } };
+        }
+      }
+    }
+  ];
+}
+
+// src/api/router.ts
+function createApiRoutes(core) {
+  const app = new Hono();
+  for (const route of buildRouteTable(core)) {
+    app[route.method](route.path, async (c) => {
+      let body;
+      const method = c.req.method;
+      if (method !== "GET" && method !== "HEAD") {
+        const contentType = c.req.header("content-type") ?? "";
+        if (contentType.includes("application/json")) {
+          try {
+            body = await c.req.json();
+          } catch {
+            body = void 0;
+          }
+        }
+      }
+      const input = {
+        params: c.req.param(),
+        query: c.req.query(),
+        body
+      };
+      const result = await route.handler(input);
+      return new Response(JSON.stringify(result.body), {
+        status: result.status,
+        headers: { "Content-Type": "application/json" }
+      });
+    });
+  }
+  return app;
+}
+
+// src/server/base-path.ts
+var CLIENT_ROUTES = [
+  /\/queues\/[^/]+\/jobs\/[^/]+\/?$/,
+  /\/queues\/[^/]+\/?$/,
+  /\/flows\/[^/]+\/[^/]+\/?$/,
+  /\/schedulers\/?$/,
+  /\/flows\/?$/,
+  /\/metrics\/?$/,
+  /\/test\/?$/
+];
+function computeBasePath(pathname) {
+  let basePath = pathname;
+  for (const route of CLIENT_ROUTES) {
+    basePath = basePath.replace(route, "");
+  }
+  if (!basePath.endsWith("/")) {
+    basePath = `${basePath}/`;
+  }
+  return basePath;
+}
+function resolveBasePath(override, pathname) {
+  if (override) {
+    return override.endsWith("/") ? override : `${override}/`;
+  }
+  return computeBasePath(pathname);
+}
+
+// src/server/static-assets.ts
+import { existsSync, readFileSync } from "fs";
+import { join as join2 } from "path";
+
+// src/ui-dist.ts
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
 var UI_DIST_PATH = join(dirname(fileURLToPath(import.meta.url)), "ui");
+
+// src/server/static-assets.ts
+function serveStaticAsset(filename) {
+  const filePath = join2(UI_DIST_PATH, "assets", filename);
+  if (!existsSync(filePath)) {
+    return { status: 404, body: null, contentType: "text/plain" };
+  }
+  const body = readFileSync(filePath);
+  const contentType = filename.endsWith(".js") ? "application/javascript" : filename.endsWith(".css") ? "text/css" : filename.endsWith(".svg") ? "image/svg+xml" : filename.endsWith(".png") ? "image/png" : filename.endsWith(".woff2") ? "font/woff2" : "application/octet-stream";
+  return { status: 200, body, contentType };
+}
+function renderIndexHtml(basePath, title) {
+  const indexPath = join2(UI_DIST_PATH, "index.html");
+  if (existsSync(indexPath)) {
+    let html = readFileSync(indexPath, "utf-8");
+    html = html.replace("<head>", `<head>
+    <base href="${basePath}">`);
+    return { body: html, contentType: "text/html; charset=utf-8" };
+  }
+  return {
+    body: fallbackHtml(title, basePath),
+    contentType: "text/html; charset=utf-8"
+  };
+}
+function fallbackHtml(title, basePath) {
+  return `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <base href="${basePath}">
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>${title}</title>
+    <style>
+      body {
+        font-family: system-ui, sans-serif;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        min-height: 100vh;
+        margin: 0;
+        background: #0a0a0a;
+        color: #fafafa;
+      }
+      .message {
+        text-align: center;
+        padding: 2rem;
+      }
+      code {
+        background: #1a1a1a;
+        padding: 0.5rem 1rem;
+        border-radius: 0.5rem;
+        display: block;
+        margin-top: 1rem;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="message">
+      <h1>${title}</h1>
+      <p>UI assets not found. Build @getworkbench/core first:</p>
+      <code>bun run --filter=@getworkbench/core build</code>
+    </div>
+  </body>
+</html>`;
+}
+
+// src/server/hono-app.ts
+function buildWorkbenchApp(core) {
+  const app = new Hono2();
+  app.use("/api/*", cors());
+  if (core.requiresAuth()) {
+    app.use(
+      "*",
+      basicAuth({
+        username: core.options.auth.username,
+        password: core.options.auth.password
+      })
+    );
+  }
+  app.route("/api", createApiRoutes(core));
+  app.get("/config", (c) => c.json(core.getConfig()));
+  app.get("/assets/:file", (c) => {
+    const fileName = c.req.param("file");
+    const asset = serveStaticAsset(fileName);
+    if (asset.status === 404 || !asset.body) {
+      return c.text("Not found", 404);
+    }
+    return new Response(new Uint8Array(asset.body), {
+      status: 200,
+      headers: { "Content-Type": asset.contentType }
+    });
+  });
+  app.get("*", (c) => {
+    const url = new URL(c.req.url);
+    const basePath = resolveBasePath(core.options.basePath, url.pathname);
+    const html = renderIndexHtml(basePath, core.options.title || "Workbench");
+    return c.html(html.body);
+  });
+  return app;
+}
+
+// src/api/fetch-handler.ts
+function createFetchHandler(options) {
+  const core = new WorkbenchCore(options);
+  const app = buildWorkbenchApp(core);
+  const basePath = normalizeBasePath(core.options.basePath);
+  const fetchHandler = async (req) => {
+    if (basePath) {
+      const url = new URL(req.url);
+      if (url.pathname === basePath || url.pathname.startsWith(`${basePath}/`)) {
+        const rewritten = url.pathname.slice(basePath.length) || "/";
+        url.pathname = rewritten;
+        const init = {
+          method: req.method,
+          headers: req.headers,
+          body: req.method === "GET" || req.method === "HEAD" ? void 0 : req.body,
+          // @ts-expect-error duplex is required for streaming bodies in Node 18+
+          duplex: "half",
+          redirect: req.redirect
+        };
+        return app.fetch(new Request(url.toString(), init));
+      }
+    }
+    return app.fetch(req);
+  };
+  return {
+    fetch: fetchHandler,
+    core
+  };
+}
+function normalizeBasePath(value) {
+  if (!value) return null;
+  const trimmed = value.endsWith("/") ? value.slice(0, -1) : value;
+  if (trimmed === "" || trimmed === "/") return null;
+  return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+}
+
+// src/server/basic-auth.ts
+function checkBasicAuth(authHeader, username, password) {
+  if (!authHeader) return false;
+  const [scheme, encoded] = authHeader.split(" ");
+  if (!scheme || scheme.toLowerCase() !== "basic" || !encoded) return false;
+  let decoded;
+  try {
+    decoded = Buffer.from(encoded, "base64").toString("utf-8");
+  } catch {
+    return false;
+  }
+  const idx = decoded.indexOf(":");
+  if (idx === -1) return false;
+  const user = decoded.slice(0, idx);
+  const pass = decoded.slice(idx + 1);
+  return safeEqual(user, username) && safeEqual(pass, password);
+}
+function safeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) {
+    diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  }
+  return diff === 0;
+}
+var BASIC_AUTH_CHALLENGE = {
+  status: 401,
+  headers: { "WWW-Authenticate": 'Basic realm="Workbench"' },
+  body: "Unauthorized"
+};
 export {
+  BASIC_AUTH_CHALLENGE,
   QueueManager,
   UI_DIST_PATH,
   WorkbenchCore,
-  createApiRoutes
+  buildRouteTable,
+  buildWorkbenchApp,
+  checkBasicAuth,
+  computeBasePath,
+  createApiRoutes,
+  createFetchHandler,
+  renderIndexHtml,
+  resolveBasePath,
+  serveStaticAsset
 };
 //# sourceMappingURL=index.js.map