plugin-build-visualization-block 0.1.1

package/dist/server/actions/build.js

@@ -0,0 +1,915 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var build_exports = {};
+__export(build_exports, {
+  WORKER_JOB_BUILD_VISUALIZATION_PROCESS: () => WORKER_JOB_BUILD_VISUALIZATION_PROCESS,
+  build: () => build,
+  enqueueBuild: () => enqueueBuild,
+  failTimedOutBuilds: () => failTimedOutBuilds,
+  getResult: () => getResult,
+  processQueuedBuild: () => processQueuedBuild,
+  recoverInterruptedBuilds: () => recoverInterruptedBuilds,
+  registerBuildQueue: () => registerBuildQueue,
+  retry: () => retry,
+  startBuildQueueProcessor: () => startBuildQueueProcessor,
+  unregisterBuildQueue: () => unregisterBuildQueue
+});
+module.exports = __toCommonJS(build_exports);
+var import_crypto = __toESM(require("crypto"));
+var import_constants = require("../../shared/constants");
+var import_introspector = require("../pipeline/introspector");
+var import_analyzer = require("../pipeline/analyzer");
+var import_validator = require("../pipeline/validator");
+var import_generator = require("../pipeline/generator");
+var import_fallback = require("../pipeline/fallback");
+const WORKER_JOB_BUILD_VISUALIZATION_PROCESS = "build-visualization:process";
+const BUILD_VISUALIZATION_QUEUE_CHANNEL = "plugin-build-visualization-block.build";
+const BUILD_VISUALIZATION_QUEUE_WAKE_CHANNEL = "plugin-build-visualization-block.build.wake";
+const BUILD_VISUALIZATION_QUEUE_REDIS_CONNECTION = "plugin-build-visualization-block.build.queue";
+const BUILD_VISUALIZATION_QUEUE_CONCURRENCY = Math.max(
+  1,
+  Number.parseInt(
+    process.env.BUILD_VISUALIZATION_QUEUE_CONCURRENCY || process.env.BUILD_VISUALIZATION_MAX_CONCURRENCY || "1",
+    10
+  ) || 1
+);
+const BUILD_VISUALIZATION_QUEUE_TIMEOUT_MS = Math.max(
+  import_constants.BUILD_TIMEOUT_MS,
+  Number.parseInt(process.env.BUILD_VISUALIZATION_QUEUE_TIMEOUT_MS || "", 10) || import_constants.BUILD_TIMEOUT_MS
+);
+const BUILD_VISUALIZATION_QUEUE_POLL_INTERVAL_MS = Math.max(
+  1e3,
+  Number.parseInt(process.env.BUILD_VISUALIZATION_QUEUE_POLL_INTERVAL_MS || "", 10) || 5e3
+);
+const BUILD_RUN_LOCK_TTL_MS = Math.max(
+  6e4,
+  Number.parseInt(process.env.BUILD_VISUALIZATION_RUN_LOCK_TTL_MS || "", 10) || 24 * 60 * 60 * 1e3
+);
+const BUILD_HEARTBEAT_INTERVAL_MS = Math.max(
+  5e3,
+  Number.parseInt(process.env.BUILD_VISUALIZATION_HEARTBEAT_MS || "", 10) || 3e4
+);
+const BUILD_STALE_MS = Math.max(
+  BUILD_HEARTBEAT_INTERVAL_MS * 2,
+  Number.parseInt(process.env.BUILD_VISUALIZATION_STALE_MS || "", 10) || 12e4
+);
+function getPubSubManager(app) {
+  return app.pubSubManager;
+}
+function getRedisConnectionManager(app) {
+  return app.redisConnectionManager;
+}
+function getEventQueueInternals(app) {
+  return app.eventQueue;
+}
+function getAppIdentity(app) {
+  return app;
+}
+function getBuildModel(app) {
+  return app.db.getModel(import_constants.COLLECTION_NAME);
+}
+const buildQueueStates = /* @__PURE__ */ new WeakMap();
+function getBuildQueueState(app) {
+  let state = buildQueueStates.get(app);
+  if (!state) {
+    state = { timer: null, kickTimer: null, processing: false, wakeHandler: null };
+    buildQueueStates.set(app, state);
+  }
+  return state;
+}
+class StaleBuildRunError extends Error {
+  constructor(buildId, runId) {
+    super(`Build run ${runId} for record ${buildId} is no longer current`);
+    this.name = "StaleBuildRunError";
+  }
+}
+function isBuildVisualizationWorker(app) {
+  const workerMode = process.env.WORKER_MODE || "";
+  return app.serving(WORKER_JOB_BUILD_VISUALIZATION_PROCESS) || workerMode === "worker" || workerMode === "task" || process.env.APP_ROLE === "worker";
+}
+function getBuildWorkerId(app) {
+  const identity = getAppIdentity(app);
+  return [
+    process.env.HOSTNAME || process.env.COMPUTERNAME || "worker",
+    identity.name || "app",
+    identity.instanceId || "0",
+    process.pid
+  ].join(":");
+}
+async function updateRecordForRun(app, run, values, optional = false) {
+  const model = getBuildModel(app);
+  const [affected] = await model.update(values, {
+    where: {
+      id: run.buildId,
+      buildRunId: run.runId
+    }
+  });
+  if (!affected && !optional) {
+    throw new StaleBuildRunError(run.buildId, run.runId);
+  }
+  return affected > 0;
+}
+async function claimBuildRun(app, run, workerId) {
+  const now = /* @__PURE__ */ new Date();
+  const model = getBuildModel(app);
+  const [affected] = await model.update(
+    {
+      buildPhase: "analyzing",
+      buildStartedAt: now,
+      buildHeartbeatAt: now,
+      buildWorkerId: workerId
+    },
+    {
+      where: {
+        id: run.buildId,
+        status: "building",
+        buildPhase: "queued",
+        buildRunId: run.runId
+      }
+    }
+  );
+  return affected > 0;
+}
+function startBuildHeartbeat(app, run) {
+  const timer = setInterval(() => {
+    updateRecordForRun(app, run, { buildHeartbeatAt: /* @__PURE__ */ new Date() }, true).catch((error) => {
+      var _a, _b;
+      (_b = (_a = app.log) == null ? void 0 : _a.warn) == null ? void 0 : _b.call(
+        _a,
+        `[plugin-build-visualization-block] Failed to update heartbeat for build ${run.runId}`,
+        error
+      );
+    });
+  }, BUILD_HEARTBEAT_INTERVAL_MS);
+  return () => clearInterval(timer);
+}
+function getBuildQueueRedisKey(app) {
+  const appName = getAppIdentity(app).name || process.env.APP_NAME || "main";
+  return `${appName}:plugin-build-visualization-block:build:queue`;
+}
+async function getBuildQueueRedis(app) {
+  var _a, _b;
+  const manager = getRedisConnectionManager(app);
+  if (!(manager == null ? void 0 : manager.getConnectionSync)) {
+    return void 0;
+  }
+  try {
+    const connectionString = process.env.QUEUE_ADAPTER_REDIS_URL || process.env.REDIS_URL;
+    return await manager.getConnectionSync(
+      BUILD_VISUALIZATION_QUEUE_REDIS_CONNECTION,
+      connectionString ? { connectionString } : void 0
+    );
+  } catch (error) {
+    (_b = (_a = app.log) == null ? void 0 : _a.debug) == null ? void 0 : _b.call(
+      _a,
+      `[plugin-build-visualization-block] Redis queue unavailable; DB polling fallback active: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return void 0;
+  }
+}
+async function enqueueBuildToRedis(app, message) {
+  var _a, _b, _c, _d;
+  const redis = await getBuildQueueRedis(app);
+  if (!redis) return false;
+  try {
+    await redis.sendCommand(["RPUSH", getBuildQueueRedisKey(app), JSON.stringify(message)]);
+    (_b = (_a = app.log) == null ? void 0 : _a.debug) == null ? void 0 : _b.call(
+      _a,
+      `[plugin-build-visualization-block] Enqueued build ${message.runId} for record "${message.buildId}" to Redis`
+    );
+    return true;
+  } catch (error) {
+    (_d = (_c = app.log) == null ? void 0 : _c.warn) == null ? void 0 : _d.call(
+      _c,
+      `[plugin-build-visualization-block] Failed to enqueue build to Redis; DB polling fallback active`,
+      error
+    );
+    return false;
+  }
+}
+async function publishBuildQueueWake(app, message) {
+  var _a, _b, _c, _d;
+  try {
+    await ((_b = (_a = getPubSubManager(app)) == null ? void 0 : _a.publish) == null ? void 0 : _b.call(
+      _a,
+      BUILD_VISUALIZATION_QUEUE_WAKE_CHANNEL,
+      { buildId: message == null ? void 0 : message.buildId, runId: message == null ? void 0 : message.runId },
+      { skipSelf: !isBuildVisualizationWorker(app) }
+    ));
+  } catch (error) {
+    (_d = (_c = app.log) == null ? void 0 : _c.debug) == null ? void 0 : _d.call(
+      _c,
+      `[plugin-build-visualization-block] Wake publish skipped: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function drainRedisBuildQueue(app, count) {
+  var _a, _b;
+  const redis = await getBuildQueueRedis(app);
+  if (!redis) return [];
+  const key = getBuildQueueRedisKey(app);
+  const messages = [];
+  for (let i = 0; i < count; i += 1) {
+    const raw = await redis.sendCommand(["LPOP", key]);
+    if (!raw) break;
+    try {
+      messages.push(JSON.parse(String(raw)));
+    } catch (error) {
+      (_b = (_a = app.log) == null ? void 0 : _a.warn) == null ? void 0 : _b.call(
+        _a,
+        `[plugin-build-visualization-block] Dropped invalid Redis build message: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  return messages;
+}
+function clearLocalBuildMemoryQueue(app) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const eventQueue = getEventQueueInternals(app);
+  const fullChannel = (_a = eventQueue.getFullChannel) == null ? void 0 : _a.call(eventQueue, BUILD_VISUALIZATION_QUEUE_CHANNEL);
+  const { adapter } = eventQueue;
+  const queue = fullChannel ? (_c = (_b = adapter == null ? void 0 : adapter.queues) == null ? void 0 : _b.get) == null ? void 0 : _c.call(_b, fullChannel) : void 0;
+  if (!(queue == null ? void 0 : queue.length)) return;
+  (_e = (_d = adapter == null ? void 0 : adapter.queues) == null ? void 0 : _d.set) == null ? void 0 : _e.call(_d, fullChannel, []);
+  (_g = (_f = app.log) == null ? void 0 : _f.warn) == null ? void 0 : _g.call(
+    _f,
+    `[plugin-build-visualization-block] Cleared ${queue.length} stale local memory message(s) on non-worker node; queued DB builds will be picked up by workers`
+  );
+}
+function startBuildQueueProcessor(app) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const state = getBuildQueueState(app);
+  if (!isBuildVisualizationWorker(app)) {
+    (_b = (_a = app.log) == null ? void 0 : _a.debug) == null ? void 0 : _b.call(
+      _a,
+      "[plugin-build-visualization-block] Build queue processor disabled on non-worker node"
+    );
+    return;
+  }
+  if (state.timer) return;
+  state.wakeHandler = async () => {
+    scheduleBuildQueueTick(app, 0);
+  };
+  const subscribe = (_d = (_c = getPubSubManager(app)) == null ? void 0 : _c.subscribe) == null ? void 0 : _d.call(
+    _c,
+    BUILD_VISUALIZATION_QUEUE_WAKE_CHANNEL,
+    state.wakeHandler
+  );
+  if (subscribe instanceof Promise) {
+    subscribe.catch((error) => {
+      var _a2, _b2;
+      (_b2 = (_a2 = app.log) == null ? void 0 : _a2.debug) == null ? void 0 : _b2.call(
+        _a2,
+        `[plugin-build-visualization-block] Wake subscribe skipped: ${error instanceof Error ? error.message : String(error)}`
+      );
+    });
+  }
+  state.timer = setInterval(
+    () => scheduleBuildQueueTick(app, 0),
+    BUILD_VISUALIZATION_QUEUE_POLL_INTERVAL_MS
+  );
+  (_f = (_e = state.timer).unref) == null ? void 0 : _f.call(_e);
+  scheduleBuildQueueTick(app, 1e3);
+  (_h = (_g = app.log) == null ? void 0 : _g.info) == null ? void 0 : _h.call(
+    _g,
+    `[plugin-build-visualization-block] Build queue processor started (interval ${BUILD_VISUALIZATION_QUEUE_POLL_INTERVAL_MS}ms)`
+  );
+}
+function stopBuildVisualizationQueueProcessor(app) {
+  var _a, _b;
+  const state = getBuildQueueState(app);
+  if (state.timer) {
+    clearInterval(state.timer);
+    state.timer = null;
+  }
+  if (state.kickTimer) {
+    clearTimeout(state.kickTimer);
+    state.kickTimer = null;
+  }
+  if (state.wakeHandler) {
+    const unsubscribe = (_b = (_a = getPubSubManager(app)) == null ? void 0 : _a.unsubscribe) == null ? void 0 : _b.call(
+      _a,
+      BUILD_VISUALIZATION_QUEUE_WAKE_CHANNEL,
+      state.wakeHandler
+    );
+    if (unsubscribe instanceof Promise) {
+      unsubscribe.catch(() => void 0);
+    }
+    state.wakeHandler = null;
+  }
+  state.processing = false;
+}
+function scheduleBuildQueueTick(app, delayMs) {
+  var _a, _b;
+  const state = getBuildQueueState(app);
+  if (state.kickTimer) return;
+  state.kickTimer = setTimeout(() => {
+    state.kickTimer = null;
+    runBuildQueueTick(app).catch((error) => {
+      var _a2, _b2;
+      (_b2 = (_a2 = app.log) == null ? void 0 : _a2.error) == null ? void 0 : _b2.call(_a2, "[plugin-build-visualization-block] Build queue tick failed", error);
+    });
+  }, delayMs);
+  (_b = (_a = state.kickTimer).unref) == null ? void 0 : _b.call(_a);
+}
+async function runBuildQueueTick(app) {
+  const state = getBuildQueueState(app);
+  if (state.processing || !isBuildVisualizationWorker(app)) return;
+  state.processing = true;
+  try {
+    await failTimedOutBuilds(app);
+    const redisMessages = await drainRedisBuildQueue(app, BUILD_VISUALIZATION_QUEUE_CONCURRENCY);
+    await processBuildQueueMessages(app, redisMessages);
+    const remaining = Math.max(1, BUILD_VISUALIZATION_QUEUE_CONCURRENCY - redisMessages.length);
+    await processQueuedBuildsFromDb(app, remaining);
+  } finally {
+    state.processing = false;
+  }
+}
+function createBuildQueueMessageFromRecord(record) {
+  const runId = record.get("buildRunId");
+  if (!runId) return null;
+  const queuedAtRaw = record.get("buildQueuedAt");
+  const createdById = record.get("createdById");
+  return {
+    buildId: String(record.get("id")),
+    runId: String(runId),
+    userId: typeof createdById === "number" || typeof createdById === "string" ? createdById : null,
+    queuedAt: queuedAtRaw ? new Date(queuedAtRaw).toISOString() : (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function processQueuedBuildsFromDb(app, count) {
+  const repository = app.db.getRepository(import_constants.COLLECTION_NAME);
+  const records = await repository.find({
+    filter: {
+      status: "building",
+      buildPhase: "queued"
+    },
+    sort: ["buildQueuedAt"],
+    limit: count
+  });
+  const messages = records.map((record) => createBuildQueueMessageFromRecord(record)).filter((message) => message !== null);
+  await processBuildQueueMessages(app, messages);
+}
+async function processBuildQueueMessages(app, messages) {
+  if (!messages.length) return;
+  await Promise.all(messages.map((message) => processQueuedBuild(app, message)));
+}
+async function runBuild(app, db, run) {
+  const repository = db.getRepository(import_constants.COLLECTION_NAME);
+  const record = await repository.findById(run.buildId);
+  if (!record) {
+    throw new Error("Build record not found");
+  }
+  if (record.get("buildRunId") !== run.runId) {
+    throw new StaleBuildRunError(run.buildId, run.runId);
+  }
+  const requirement = String(record.get("requirement") ?? "");
+  const dataSource = String(record.get("dataSource") ?? "main");
+  const llmService = record.get("llmService");
+  const model = record.get("model");
+  const rawCollections = record.get("collections");
+  const collections = Array.isArray(rawCollections) ? rawCollections.filter((name) => typeof name === "string") : [];
+  if (!llmService || !model) {
+    throw new Error("LLM service or model is missing in the build configuration");
+  }
+  await updateRecordForRun(app, run, {
+    status: "building",
+    buildPhase: "analyzing",
+    buildLog: "Analyzing collections and requirement",
+    errorMessage: null,
+    blockSpec: null,
+    blockSchema: null,
+    adjustments: null,
+    usedFallback: false,
+    buildHeartbeatAt: /* @__PURE__ */ new Date()
+  });
+  const summary = await (0, import_introspector.introspect)(app, { dataSource, collections });
+  const analysis = await (0, import_analyzer.analyze)(app, { requirement, summary, llmService, model });
+  let usedFallback = analysis.usedFallback;
+  if (analysis.error) {
+    await updateRecordForRun(
+      app,
+      run,
+      {
+        errorMessage: analysis.error,
+        buildLog: `Analyzer fell back: ${analysis.error}`,
+        usedFallback: true
+      },
+      true
+    );
+  }
+  const validation = (0, import_validator.validate)(analysis.spec, summary);
+  usedFallback = usedFallback || validation.usedFallback;
+  const specForGeneration = validation.usedFallback ? (0, import_fallback.buildFallbackSpec)(summary) : validation.spec;
+  await updateRecordForRun(app, run, {
+    buildPhase: "generating",
+    buildLog: "Generating block schema",
+    buildHeartbeatAt: /* @__PURE__ */ new Date()
+  });
+  const result = (0, import_generator.generate)(specForGeneration, summary);
+  if (!result.ok) {
+    throw new Error(
+      result.failedNode ? `Schema generation failed at "${result.failedNode}": ${result.error}` : `Schema generation failed: ${result.error}`
+    );
+  }
+  usedFallback = usedFallback || result.usedFallback;
+  await updateRecordForRun(app, run, {
+    status: "completed",
+    buildPhase: "completed",
+    blockSpec: specForGeneration,
+    blockSchema: result.schema,
+    adjustments: validation.adjustments,
+    usedFallback,
+    buildLog: usedFallback ? "Build completed using the fallback specification" : "Build completed successfully",
+    errorMessage: null,
+    buildHeartbeatAt: /* @__PURE__ */ new Date()
+  });
+}
+async function withBuildRunLock(app, buildId, fn) {
+  return app.lockManager.runExclusive(
+    `build-visualization:run:${buildId}`,
+    fn,
+    BUILD_RUN_LOCK_TTL_MS
+  );
+}
+async function processQueuedBuild(app, message) {
+  var _a, _b;
+  const buildId = message == null ? void 0 : message.buildId;
+  const runId = message == null ? void 0 : message.runId;
+  if (!buildId || !runId) {
+    (_b = (_a = app.log) == null ? void 0 : _a.warn) == null ? void 0 : _b.call(_a, "[plugin-build-visualization-block] Build queue message missing buildId or runId");
+    return;
+  }
+  await withBuildRunLock(app, buildId, async () => {
+    var _a2, _b2, _c, _d, _e, _f, _g, _h, _i, _j;
+    const run = { buildId, runId };
+    const workerId = getBuildWorkerId(app);
+    const claimed = await claimBuildRun(app, run, workerId);
+    if (!claimed) {
+      (_b2 = (_a2 = app.log) == null ? void 0 : _a2.info) == null ? void 0 : _b2.call(
+        _a2,
+        `[plugin-build-visualization-block] Build ${runId} for record "${buildId}" was already claimed or stale`
+      );
+      return;
+    }
+    const repository = app.db.getRepository(import_constants.COLLECTION_NAME);
+    const record = await repository.findById(buildId);
+    if (!record) {
+      (_d = (_c = app.log) == null ? void 0 : _c.warn) == null ? void 0 : _d.call(
+        _c,
+        `[plugin-build-visualization-block] Build record "${buildId}" not found; skipping queued build`
+      );
+      return;
+    }
+    if (record.get("status") !== "building") {
+      (_f = (_e = app.log) == null ? void 0 : _e.info) == null ? void 0 : _f.call(
+        _e,
+        `[plugin-build-visualization-block] Build record "${buildId}" is ${record.get(
+          "status"
+        )}; skipping queued build`
+      );
+      return;
+    }
+    const stopHeartbeat = startBuildHeartbeat(app, run);
+    try {
+      await runBuild(app, app.db, run);
+    } catch (error) {
+      if (error instanceof StaleBuildRunError) {
+        (_h = (_g = app.log) == null ? void 0 : _g.info) == null ? void 0 : _h.call(_g, `[plugin-build-visualization-block] ${error.message}`);
+        return;
+      }
+      (_j = (_i = app.log) == null ? void 0 : _i.error) == null ? void 0 : _j.call(_i, "[plugin-build-visualization-block] Build worker error", error);
+      await markBuildError(app, buildId, runId, error);
+    } finally {
+      stopHeartbeat();
+    }
+  });
+}
+async function markBuildError(app, buildId, runId, error) {
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  if (runId) {
+    await updateRecordForRun(
+      app,
+      { buildId, runId },
+      {
+        status: "error",
+        buildPhase: "failed",
+        errorMessage,
+        buildLog: errorMessage,
+        buildHeartbeatAt: /* @__PURE__ */ new Date()
+      },
+      true
+    );
+    return;
+  }
+  await app.db.getRepository(import_constants.COLLECTION_NAME).update({
+    filterByTk: buildId,
+    values: {
+      status: "error",
+      buildPhase: "failed",
+      errorMessage,
+      buildLog: errorMessage
+    }
+  });
+}
+async function enqueueBuild(app, message) {
+  var _a, _b;
+  try {
+    const queuedInRedis = await enqueueBuildToRedis(app, message);
+    if (queuedInRedis) {
+      await publishBuildQueueWake(app, message);
+      return;
+    }
+    await publishBuildQueueWake(app, message);
+    if (isBuildVisualizationWorker(app)) {
+      await app.eventQueue.publish(BUILD_VISUALIZATION_QUEUE_CHANNEL, message, {
+        timeout: BUILD_VISUALIZATION_QUEUE_TIMEOUT_MS,
+        maxRetries: 0
+      });
+      return;
+    }
+    (_b = (_a = app.log) == null ? void 0 : _a.warn) == null ? void 0 : _b.call(
+      _a,
+      `[plugin-build-visualization-block] Redis queue is unavailable; build ${message.runId} for record "${message.buildId}" will remain queued until a worker DB poller picks it up`
+    );
+  } catch (error) {
+    await markBuildError(app, message.buildId, message.runId, error);
+    throw error;
+  }
+}
+function registerBuildQueue(app) {
+  app.eventQueue.subscribe(BUILD_VISUALIZATION_QUEUE_CHANNEL, {
+    concurrency: BUILD_VISUALIZATION_QUEUE_CONCURRENCY,
+    idle: () => isBuildVisualizationWorker(app),
+    process: async (message) => {
+      await processQueuedBuild(app, message);
+    }
+  });
+  if (!isBuildVisualizationWorker(app)) {
+    app.on("afterStart", () => clearLocalBuildMemoryQueue(app));
+  }
+}
+function unregisterBuildQueue(app) {
+  app.eventQueue.unsubscribe(BUILD_VISUALIZATION_QUEUE_CHANNEL);
+  stopBuildVisualizationQueueProcessor(app);
+}
+async function recoverInterruptedBuilds(app) {
+  var _a, _b;
+  const repository = app.db.getRepository(import_constants.COLLECTION_NAME);
+  const model = getBuildModel(app);
+  const staleBefore = new Date(Date.now() - BUILD_STALE_MS);
+  const records = await repository.find({
+    filter: {
+      status: "building",
+      $or: [{ buildHeartbeatAt: null }, { buildHeartbeatAt: { $lt: staleBefore } }]
+    }
+  });
+  let requeued = 0;
+  for (const record of records) {
+    const buildId = String(record.get("id"));
+    const previousRunId = record.get("buildRunId") || null;
+    const runId = String(previousRunId || import_crypto.default.randomUUID());
+    const [affected] = await model.update(
+      {
+        buildPhase: "queued",
+        buildLog: "Build re-queued after worker restart",
+        buildRunId: runId,
+        buildQueuedAt: /* @__PURE__ */ new Date(),
+        buildStartedAt: null,
+        buildHeartbeatAt: null,
+        buildWorkerId: null
+      },
+      {
+        where: {
+          id: buildId,
+          status: "building",
+          buildRunId: previousRunId
+        }
+      }
+    );
+    if (!affected) {
+      continue;
+    }
+    await enqueueBuild(app, {
+      buildId,
+      runId,
+      userId: null,
+      queuedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    requeued += 1;
+  }
+  if (requeued) {
+    (_b = (_a = app.log) == null ? void 0 : _a.info) == null ? void 0 : _b.call(_a, `[plugin-build-visualization-block] Re-queued ${requeued} interrupted build(s)`);
+  }
+}
+async function failTimedOutBuilds(app) {
+  var _a, _b;
+  const repository = app.db.getRepository(import_constants.COLLECTION_NAME);
+  const model = getBuildModel(app);
+  const now = Date.now();
+  const timeoutBefore = new Date(now - import_constants.BUILD_TIMEOUT_MS);
+  const staleBefore = new Date(now - BUILD_STALE_MS);
+  const records = await repository.find({
+    filter: {
+      status: "building",
+      $or: [
+        { buildStartedAt: { $lt: timeoutBefore } },
+        { $and: [{ buildStartedAt: null }, { buildQueuedAt: { $lt: timeoutBefore } }] }
+      ]
+    }
+  });
+  let failed = 0;
+  for (const record of records) {
+    const heartbeatRaw = record.get("buildHeartbeatAt");
+    const heartbeatStale = !heartbeatRaw || new Date(heartbeatRaw).getTime() < staleBefore.getTime();
+    if (!heartbeatStale) {
+      continue;
+    }
+    const buildId = String(record.get("id"));
+    const previousRunId = record.get("buildRunId") ?? null;
+    const [affected] = await model.update(
+      {
+        status: "error",
+        buildPhase: "failed",
+        errorMessage: "Build timed out",
+        buildLog: "Build timed out",
+        buildHeartbeatAt: /* @__PURE__ */ new Date()
+      },
+      {
+        where: {
+          id: buildId,
+          status: "building",
+          buildRunId: previousRunId
+        }
+      }
+    );
+    if (affected) {
+      failed += 1;
+    }
+  }
+  if (failed) {
+    (_b = (_a = app.log) == null ? void 0 : _a.info) == null ? void 0 : _b.call(_a, `[plugin-build-visualization-block] Failed ${failed} timed-out build(s)`);
+  }
+}
+function getCurrentRoles(ctx) {
+  var _a;
+  const roles = (_a = ctx.state) == null ? void 0 : _a.currentRoles;
+  return Array.isArray(roles) ? roles.filter((role) => typeof role === "string") : [];
+}
+function t(ctx, key, options) {
+  return ctx.t(key, { ns: import_constants.PLUGIN_NAME, ...options });
+}
+function readStringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function getRecordCollections(record) {
+  return readStringArray(record.get("collections"));
+}
+function getRecordCreatedById(record) {
+  const direct = record.get("createdById");
+  if (typeof direct === "string" || typeof direct === "number") {
+    return direct;
+  }
+  const createdBy = record.get("createdBy");
+  if (createdBy && typeof createdBy === "object") {
+    const id = createdBy.id;
+    if (typeof id === "string" || typeof id === "number") {
+      return id;
+    }
+  }
+  return null;
+}
+function getCurrentUserId(ctx) {
+  var _a, _b;
+  const id = (_b = (_a = ctx.auth) == null ? void 0 : _a.user) == null ? void 0 : _b.id;
+  return typeof id === "string" || typeof id === "number" ? id : null;
+}
+function sameId(left, right) {
+  return left !== null && right !== null && String(left) === String(right);
+}
+function assertBuildRecordAccess(ctx, record) {
+  const roles = getCurrentRoles(ctx);
+  if (roles.includes("root")) {
+    return;
+  }
+  if (sameId(getRecordCreatedById(record), getCurrentUserId(ctx))) {
+    return;
+  }
+  const collections = getRecordCollections(record);
+  if (collections.length === 0) {
+    ctx.throw(403, t(ctx, "You do not have permission to read this build"));
+  }
+  assertCollectionPermissions(ctx, collections);
+}
+function asNonEmptyString(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function validateInput(ctx, values) {
+  if (!Array.isArray(values.collections)) {
+    ctx.throw(400, t(ctx, "At least one collection is required"));
+  }
+  const collections = values.collections.filter(
+    (item) => typeof item === "string" && item.trim().length > 0
+  );
+  if (collections.length < import_constants.MIN_COLLECTIONS) {
+    ctx.throw(400, t(ctx, "At least one collection is required"));
+  }
+  if (collections.length > import_constants.MAX_COLLECTIONS) {
+    ctx.throw(400, t(ctx, "A maximum of {{max}} collections can be selected", { max: import_constants.MAX_COLLECTIONS }));
+  }
+  const requirement = asNonEmptyString(values.requirement);
+  if (!requirement) {
+    ctx.throw(400, t(ctx, "A requirement is required"));
+  }
+  if (requirement.length > import_constants.MAX_REQUIREMENT_CHARS) {
+    ctx.throw(
+      400,
+      t(ctx, "The requirement must be {{max}} characters or fewer", { max: import_constants.MAX_REQUIREMENT_CHARS })
+    );
+  }
+  const llmService = asNonEmptyString(values.llmService);
+  const model = asNonEmptyString(values.model);
+  if (!llmService || !model) {
+    ctx.throw(400, t(ctx, "An LLM service and model are required"));
+  }
+  const dataSource = asNonEmptyString(values.dataSource) ?? "main";
+  const primaryCollection = asNonEmptyString(values.primaryCollection) ?? collections[0];
+  return { requirement, collections, dataSource, primaryCollection, llmService, model };
+}
+function assertCollectionPermissions(ctx, collections) {
+  const roles = getCurrentRoles(ctx);
+  if (roles.includes("root")) {
+    return;
+  }
+  const app = ctx.app;
+  for (const collection of collections) {
+    const allowed = app.acl.can({ roles, resource: collection, action: "list" });
+    if (!allowed) {
+      ctx.throw(403, t(ctx, 'You do not have permission to read collection "{{collection}}"', { collection }));
+    }
+  }
+}
+async function build(ctx, next) {
+  var _a, _b;
+  const params = ctx.action.params;
+  const values = params.values ?? {};
+  const input = validateInput(ctx, values);
+  assertCollectionPermissions(ctx, input.collections);
+  const runId = import_crypto.default.randomUUID();
+  const userId = ((_b = (_a = ctx.auth) == null ? void 0 : _a.user) == null ? void 0 : _b.id) ?? null;
+  const repository = ctx.db.getRepository(import_constants.COLLECTION_NAME);
+  const record = await repository.create({
+    values: {
+      requirement: input.requirement,
+      collections: input.collections,
+      dataSource: input.dataSource,
+      primaryCollection: input.primaryCollection,
+      llmService: input.llmService,
+      model: input.model,
+      status: "building",
+      buildPhase: "queued",
+      buildRunId: runId,
+      buildQueuedAt: /* @__PURE__ */ new Date(),
+      createdById: userId
+    }
+  });
+  const buildId = String(record.get("id"));
+  await enqueueBuild(ctx.app, {
+    buildId,
+    runId,
+    userId,
+    queuedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  ctx.body = {
+    id: record.get("id"),
+    status: "building",
+    buildPhase: "queued"
+  };
+  await next();
+}
+function getFilterByTk(ctx) {
+  const filterByTk = ctx.action.params.filterByTk;
+  if (typeof filterByTk === "number") {
+    return filterByTk;
+  }
+  if (typeof filterByTk === "string" && filterByTk.trim().length > 0) {
+    return filterByTk;
+  }
+  ctx.throw(400, t(ctx, "A build id is required"));
+}
+async function retry(ctx, next) {
+  var _a, _b;
+  const filterByTk = getFilterByTk(ctx);
+  const repository = ctx.db.getRepository(import_constants.COLLECTION_NAME);
+  const record = await repository.findById(filterByTk);
+  if (!record) {
+    ctx.throw(404, t(ctx, "Build record not found"));
+  }
+  assertBuildRecordAccess(ctx, record);
+  const runId = import_crypto.default.randomUUID();
+  const userId = ((_b = (_a = ctx.auth) == null ? void 0 : _a.user) == null ? void 0 : _b.id) ?? null;
+  await repository.update({
+    filterByTk,
+    values: {
+      status: "building",
+      buildPhase: "queued",
+      buildRunId: runId,
+      buildQueuedAt: /* @__PURE__ */ new Date(),
+      buildLog: "Build re-queued via retry",
+      errorMessage: null,
+      blockSchema: null,
+      blockSpec: null,
+      adjustments: null,
+      usedFallback: false,
+      buildStartedAt: null,
+      buildHeartbeatAt: null,
+      buildWorkerId: null
+    }
+  });
+  const buildId = String(record.get("id"));
+  await enqueueBuild(ctx.app, {
+    buildId,
+    runId,
+    userId,
+    queuedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  ctx.body = {
+    id: record.get("id"),
+    status: "building",
+    buildPhase: "queued"
+  };
+  await next();
+}
+async function getResult(ctx, next) {
+  const filterByTk = getFilterByTk(ctx);
+  const repository = ctx.db.getRepository(import_constants.COLLECTION_NAME);
+  const record = await repository.findById(filterByTk);
+  if (!record) {
+    ctx.throw(404, t(ctx, "Build record not found"));
+  }
+  assertBuildRecordAccess(ctx, record);
+  ctx.body = {
+    id: record.get("id"),
+    status: record.get("status"),
+    buildPhase: record.get("buildPhase"),
+    blockSchema: record.get("blockSchema"),
+    blockSpec: record.get("blockSpec"),
+    adjustments: record.get("adjustments"),
+    usedFallback: record.get("usedFallback"),
+    errorMessage: record.get("errorMessage")
+  };
+  await next();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WORKER_JOB_BUILD_VISUALIZATION_PROCESS,
+  build,
+  enqueueBuild,
+  failTimedOutBuilds,
+  getResult,
+  processQueuedBuild,
+  recoverInterruptedBuilds,
+  registerBuildQueue,
+  retry,
+  startBuildQueueProcessor,
+  unregisterBuildQueue
+});