@getworkbench/core 0.2.1 → 0.3.0

package/dist/index.js

@@ -1,3 +1,93 @@
+import {
+  UI_DIST_PATH,
+  buildRouteTable,
+  buildWorkbenchApp,
+  computeBasePath,
+  renderIndexHtml,
+  resolveBasePath,
+  serveStaticAsset
+} from "./chunk-O7DNWUZD.js";
+
+// src/core/discover.ts
+import { Queue } from "bullmq";
+import { Redis } from "ioredis";
+async function discoverQueues(connection, prefix = "bull") {
+  const normalized = normalizeConnection(connection);
+  const client = createScanClient(normalized);
+  const firstError = captureFirstError(client);
+  try {
+    await Promise.race([client.ping(), firstError.promise]);
+    const names = await scanQueueNames(client, prefix);
+    return names.map(
+      (name) => new Queue(name, {
+        connection: { ...normalized },
+        prefix
+      })
+    );
+  } finally {
+    firstError.dispose();
+    client.disconnect();
+  }
+}
+function captureFirstError(client) {
+  let onError = null;
+  const promise = new Promise((_, reject) => {
+    onError = (err) => reject(err);
+    client.once("error", onError);
+  });
+  client.on("error", () => {
+  });
+  return {
+    promise,
+    dispose: () => {
+      if (onError) client.off("error", onError);
+    }
+  };
+}
+function normalizeConnection(connection) {
+  if (typeof connection === "string") {
+    return { url: connection };
+  }
+  return { ...connection };
+}
+function createScanClient(opts) {
+  const { url, ...rest } = opts;
+  if (url) {
+    return new Redis(url, {
+      ...rest,
+      lazyConnect: false,
+      maxRetriesPerRequest: 1
+    });
+  }
+  return new Redis({ ...rest, lazyConnect: false, maxRetriesPerRequest: 1 });
+}
+async function scanQueueNames(client, prefix) {
+  const pattern = `${prefix}:*:meta`;
+  const names = /* @__PURE__ */ new Set();
+  let cursor = "0";
+  do {
+    const [next, batch] = await client.scan(
+      cursor,
+      "MATCH",
+      pattern,
+      "COUNT",
+      500
+    );
+    cursor = next;
+    for (const key of batch) {
+      const name = parseQueueName(key, prefix);
+      if (name) names.add(name);
+    }
+  } while (cursor !== "0");
+  return Array.from(names).sort();
+}
+function parseQueueName(key, prefix) {
+  const head = `${prefix}:`;
+  const tail = ":meta";
+  if (!key.startsWith(head) || !key.endsWith(tail)) return null;
+  return key.slice(head.length, key.length - tail.length);
+}
+
 // src/core/queue-manager.ts
 import { FlowProducer } from "bullmq";
 import { LRUCache } from "lru-cache";
@@ -1689,24 +1779,56 @@ var QueueManager = class {
 };
 
 // src/core/workbench.ts
-var WorkbenchCore = class {
+var WorkbenchCore = class _WorkbenchCore {
   options;
   queueManager;
-  constructor(options) {
+  discovery;
+  constructor(options, discovery = null) {
     const opts = Array.isArray(options) ? { queues: options } : options;
     this.options = {
       title: "Workbench",
       readonly: false,
       ...opts
     };
-    if (!this.options.queues || this.options.queues.length === 0) {
+    this.discovery = discovery;
+    const explicit = this.options.queues ?? [];
+    const allowEmpty = !!this.options.redis;
+    if (explicit.length === 0 && !allowEmpty) {
       throw new Error(
         "Workbench requires at least one queue. Pass queues directly or provide a redis connection for auto-discovery."
       );
     }
-    this.queueManager = new QueueManager(
-      this.options.queues,
-      this.options.tags || []
+    this.queueManager = new QueueManager(explicit, this.options.tags || []);
+  }
+  /**
+   * Async factory: build a `WorkbenchCore` from `WorkbenchOptions`, performing
+   * BullMQ queue auto-discovery via `SCAN <prefix>:*:meta` when `queues` is
+   * not provided.
+   *
+   * - When `queues` is set explicitly, behaves like `new WorkbenchCore(opts)`.
+   * - When only `redis` is set, scans the connection for queues, caps at
+   *   `maxQueues` (default 100) to avoid connection storms with very large
+   *   deployments, and constructs the core with the resulting list.
+   * - When no queues are discovered, the core is constructed with an empty
+   *   queue map so the dashboard can render an "empty" state instead of
+   *   erroring out.
+   */
+  static async fromOptions(opts) {
+    if (opts.queues?.length) {
+      return new _WorkbenchCore(opts);
+    }
+    if (!opts.redis) {
+      throw new Error(
+        "WorkbenchCore.fromOptions requires either `queues` or `redis`"
+      );
+    }
+    const prefix = opts.prefix ?? "bull";
+    const cap = opts.maxQueues ?? 100;
+    const all = await discoverQueues(opts.redis, prefix);
+    const queues = all.slice(0, cap);
+    return new _WorkbenchCore(
+      { ...opts, queues },
+      { total: all.length, capped: all.length > cap, cap }
     );
   }
   /**
@@ -1737,577 +1859,12 @@ var WorkbenchCore = class {
       logo: this.options.logo,
       readonly: this.options.readonly,
       queues: this.queueManager.getQueueNames(),
-      tags: this.queueManager.getTagFields()
+      tags: this.queueManager.getTagFields(),
+      discovery: this.discovery
     };
   }
 };
 
-// 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);
@@ -2380,11 +1937,10 @@ export {
   UI_DIST_PATH,
   WorkbenchCore,
   buildRouteTable,
-  buildWorkbenchApp,
   checkBasicAuth,
   computeBasePath,
-  createApiRoutes,
   createFetchHandler,
+  discoverQueues,
   renderIndexHtml,
   resolveBasePath,
   serveStaticAsset