@microfox/ai-worker 1.0.1

package/dist/index.js

@@ -0,0 +1,734 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  clearWorkersConfigCache: () => clearWorkersConfigCache,
+  createLambdaEntrypoint: () => createLambdaEntrypoint,
+  createLambdaHandler: () => createLambdaHandler,
+  createWorker: () => createWorker,
+  dispatch: () => dispatch,
+  dispatchLocal: () => dispatchLocal,
+  getWorkersConfig: () => getWorkersConfig,
+  resolveQueueUrl: () => resolveQueueUrl
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+function getWorkersTriggerUrl() {
+  const raw = process.env.WORKER_BASE_URL || process.env.NEXT_PUBLIC_WORKER_BASE_URL || process.env.WORKERS_TRIGGER_API_URL || process.env.NEXT_PUBLIC_WORKERS_TRIGGER_API_URL || process.env.WORKERS_CONFIG_API_URL || process.env.NEXT_PUBLIC_WORKERS_CONFIG_API_URL;
+  if (!raw) {
+    throw new Error(
+      "WORKER_BASE_URL (preferred) or NEXT_PUBLIC_WORKER_BASE_URL is required for background workers"
+    );
+  }
+  const url = new URL(raw);
+  url.search = "";
+  url.hash = "";
+  const path = url.pathname || "";
+  url.pathname = path.replace(/\/?workers\/(trigger|config)\/?$/, "");
+  const basePath = url.pathname.replace(/\/+$/, "");
+  url.pathname = `${basePath}/workers/trigger`.replace(/\/+$/, "");
+  return url.toString();
+}
+function serializeContext(ctx) {
+  const serialized = {};
+  if (ctx.requestId) {
+    serialized.requestId = ctx.requestId;
+  }
+  if (ctx.metadata && typeof ctx.metadata === "object") {
+    Object.assign(serialized, ctx.metadata);
+  }
+  if (ctx._serializeContext && typeof ctx._serializeContext === "function") {
+    const custom = ctx._serializeContext();
+    Object.assign(serialized, custom);
+  }
+  return serialized;
+}
+async function dispatch(workerId, input, inputSchema, options, ctx) {
+  const validatedInput = inputSchema.parse(input);
+  const jobId = options.jobId || `job-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  const triggerUrl = getWorkersTriggerUrl();
+  const serializedContext = ctx ? serializeContext(ctx) : {};
+  const messageBody = {
+    workerId,
+    jobId,
+    input: validatedInput,
+    context: serializedContext,
+    webhookUrl: options.webhookUrl,
+    metadata: options.metadata || {},
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  const triggerKey = process.env.WORKERS_TRIGGER_API_KEY;
+  if (triggerKey) {
+    headers["x-workers-trigger-key"] = triggerKey;
+  }
+  const response = await fetch(triggerUrl, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      workerId,
+      body: messageBody
+    })
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(
+      `Failed to trigger worker "${workerId}": ${response.status} ${response.statusText}${text ? ` - ${text}` : ""}`
+    );
+  }
+  const data = await response.json().catch(() => ({}));
+  const messageId = data?.messageId ? String(data.messageId) : `trigger-${jobId}`;
+  return {
+    messageId,
+    status: "queued",
+    jobId
+  };
+}
+async function dispatchLocal(handler, input, ctx) {
+  return handler({ input, ctx: ctx || {} });
+}
+
+// src/mongoJobStore.ts
+var import_mongodb = require("mongodb");
+var uri = process.env.MONGODB_WORKER_URI || process.env.DATABASE_MONGODB_URI || process.env.MONGODB_URI;
+var dbName = process.env.MONGODB_WORKER_DB || process.env.MONGODB_DB || "worker";
+var collectionName = process.env.MONGODB_WORKER_JOBS_COLLECTION || "worker_jobs";
+var clientPromise = null;
+function getClient() {
+  if (!uri) {
+    throw new Error(
+      "MongoDB URI required for job store. Set DATABASE_MONGODB_URI or MONGODB_URI."
+    );
+  }
+  if (!clientPromise) {
+    clientPromise = new import_mongodb.MongoClient(uri, {
+      maxPoolSize: 10,
+      minPoolSize: 0,
+      serverSelectionTimeoutMS: 1e4
+    }).connect();
+  }
+  return clientPromise;
+}
+async function getCollection() {
+  const client = await getClient();
+  return client.db(dbName).collection(collectionName);
+}
+function createMongoJobStore(workerId, jobId, input, metadata) {
+  return {
+    update: async (update) => {
+      try {
+        const coll = await getCollection();
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const existing = await coll.findOne({ _id: jobId });
+        let metadataUpdate = { ...existing?.metadata ?? {} };
+        if (update.metadata) {
+          Object.assign(metadataUpdate, update.metadata);
+        }
+        if (update.progress !== void 0 || update.progressMessage !== void 0) {
+          metadataUpdate.progress = update.progress;
+          metadataUpdate.progressMessage = update.progressMessage;
+        }
+        const set = {
+          updatedAt: now,
+          metadata: metadataUpdate
+        };
+        if (update.status !== void 0) {
+          set.status = update.status;
+          if (["completed", "failed"].includes(update.status) && !existing?.completedAt) {
+            set.completedAt = now;
+          }
+        }
+        if (update.output !== void 0) set.output = update.output;
+        if (update.error !== void 0) set.error = update.error;
+        if (existing) {
+          await coll.updateOne({ _id: jobId }, { $set: set });
+        } else {
+          const doc = {
+            _id: jobId,
+            jobId,
+            workerId,
+            status: update.status ?? "queued",
+            input: input ?? {},
+            output: update.output,
+            error: update.error,
+            metadata: metadataUpdate,
+            createdAt: now,
+            updatedAt: now,
+            completedAt: set.completedAt
+          };
+          if (doc.status === "completed" || doc.status === "failed") {
+            doc.completedAt = doc.completedAt ?? now;
+          }
+          await coll.updateOne({ _id: jobId }, { $set: doc }, { upsert: true });
+        }
+      } catch (e) {
+        console.error("[Worker] MongoDB job store update failed:", {
+          jobId,
+          workerId,
+          error: e?.message ?? String(e)
+        });
+      }
+    },
+    get: async () => {
+      try {
+        const coll = await getCollection();
+        const doc = await coll.findOne({ _id: jobId });
+        if (!doc) return null;
+        const { _id, ...r } = doc;
+        return r;
+      } catch (e) {
+        console.error("[Worker] MongoDB job store get failed:", {
+          jobId,
+          workerId,
+          error: e?.message ?? String(e)
+        });
+        return null;
+      }
+    }
+  };
+}
+async function upsertJob(jobId, workerId, input, metadata) {
+  const coll = await getCollection();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await coll.updateOne(
+    { _id: jobId },
+    {
+      $set: {
+        _id: jobId,
+        jobId,
+        workerId,
+        status: "queued",
+        input: input ?? {},
+        metadata: metadata ?? {},
+        createdAt: now,
+        updatedAt: now
+      }
+    },
+    { upsert: true }
+  );
+}
+function isMongoJobStoreConfigured() {
+  return Boolean(uri?.trim());
+}
+
+// src/handler.ts
+async function sendWebhook(webhookUrl, payload) {
+  try {
+    const response = await fetch(webhookUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": "ai-router-worker/1.0"
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "");
+      console.error("[Worker] Webhook callback failed:", {
+        url: webhookUrl,
+        status: response.status,
+        statusText: response.statusText,
+        errorText
+      });
+    } else {
+      console.log("[Worker] Webhook callback successful:", {
+        url: webhookUrl,
+        status: response.status
+      });
+    }
+  } catch (error) {
+    console.error("[Worker] Webhook callback error:", {
+      url: webhookUrl,
+      error: error?.message || String(error),
+      stack: error?.stack
+    });
+  }
+}
+function createLambdaHandler(handler, outputSchema) {
+  return async (event, lambdaContext) => {
+    const promises = event.Records.map(async (record) => {
+      let messageBody = null;
+      try {
+        messageBody = JSON.parse(record.body);
+        const { workerId, jobId, input, context, webhookUrl, metadata = {} } = messageBody;
+        let jobStore;
+        if (isMongoJobStoreConfigured()) {
+          await upsertJob(jobId, workerId, input, metadata);
+          jobStore = createMongoJobStore(workerId, jobId, input, metadata);
+        }
+        const handlerContext = {
+          jobId,
+          workerId,
+          requestId: context.requestId || lambdaContext.awsRequestId,
+          ...jobStore ? { jobStore } : {},
+          ...context
+        };
+        if (jobStore) {
+          try {
+            await jobStore.update({ status: "running" });
+            console.log("[Worker] Job status updated to running:", {
+              jobId,
+              workerId
+            });
+          } catch (error) {
+            console.warn("[Worker] Failed to update status to running:", {
+              jobId,
+              workerId,
+              error: error?.message || String(error)
+            });
+          }
+        }
+        let output;
+        try {
+          output = await handler({
+            input,
+            ctx: handlerContext
+          });
+          if (outputSchema) {
+            output = outputSchema.parse(output);
+          }
+        } catch (error) {
+          const errorPayload = {
+            jobId,
+            workerId,
+            status: "error",
+            error: {
+              message: error.message || "Unknown error",
+              stack: error.stack,
+              name: error.name || "Error"
+            },
+            metadata
+          };
+          if (jobStore) {
+            try {
+              await jobStore.update({
+                status: "failed",
+                error: errorPayload.error
+              });
+              console.log("[Worker] Job status updated to failed:", {
+                jobId,
+                workerId
+              });
+            } catch (updateError) {
+              console.warn("[Worker] Failed to update job store on error:", {
+                jobId,
+                workerId,
+                error: updateError?.message || String(updateError)
+              });
+            }
+          }
+          if (webhookUrl) {
+            await sendWebhook(webhookUrl, errorPayload);
+          }
+          throw error;
+        }
+        if (jobStore) {
+          try {
+            await jobStore.update({
+              status: "completed",
+              output
+            });
+            console.log("[Worker] Job status updated to completed:", {
+              jobId,
+              workerId
+            });
+          } catch (updateError) {
+            console.warn("[Worker] Failed to update job store on success:", {
+              jobId,
+              workerId,
+              error: updateError?.message || String(updateError)
+            });
+          }
+        }
+        console.log("[Worker] Job completed:", {
+          jobId,
+          workerId,
+          output
+        });
+        const successPayload = {
+          jobId,
+          workerId,
+          status: "success",
+          output,
+          metadata
+        };
+        if (webhookUrl) {
+          await sendWebhook(webhookUrl, successPayload);
+        }
+      } catch (error) {
+        console.error("[Worker] Error processing SQS record:", {
+          jobId: messageBody?.jobId ?? "(parse failed)",
+          workerId: messageBody?.workerId ?? "(parse failed)",
+          error: error?.message || String(error),
+          stack: error?.stack
+        });
+        throw error;
+      }
+    });
+    await Promise.all(promises);
+  };
+}
+
+// src/config.ts
+var cachedConfig = null;
+var cacheExpiry = 0;
+var CACHE_TTL_MS = 5 * 60 * 1e3;
+async function getWorkersConfig(apiUrl, apiKey) {
+  const now = Date.now();
+  if (cachedConfig && now < cacheExpiry) {
+    return cachedConfig;
+  }
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (apiKey) {
+    headers["x-workers-config-key"] = apiKey;
+  }
+  const response = await fetch(apiUrl, {
+    method: "GET",
+    headers
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch workers config: ${response.status} ${response.statusText}`
+    );
+  }
+  const config = await response.json();
+  cachedConfig = config;
+  cacheExpiry = now + CACHE_TTL_MS;
+  return config;
+}
+async function resolveQueueUrl(workerId, apiUrl, apiKey) {
+  const config = await getWorkersConfig(apiUrl, apiKey);
+  const worker = config.workers[workerId];
+  if (!worker) {
+    throw new Error(
+      `Worker "${workerId}" not found in workers config. Available workers: ${Object.keys(config.workers).join(", ")}`
+    );
+  }
+  return worker.queueUrl;
+}
+function clearWorkersConfigCache() {
+  cachedConfig = null;
+  cacheExpiry = 0;
+}
+
+// src/index.ts
+function createWorker(config) {
+  const { id, inputSchema, outputSchema, handler } = config;
+  const agent = {
+    id,
+    handler,
+    inputSchema,
+    outputSchema,
+    async dispatch(input, options) {
+      const mode = options.mode ?? "auto";
+      const envWantsLocal = process.env.NODE_ENV === "development" && process.env.WORKERS_LOCAL_MODE !== "false";
+      const isLocal = mode === "local" || mode === "auto" && envWantsLocal;
+      if (isLocal) {
+        const parsedInput = inputSchema.parse(input);
+        const localJobId = options.jobId || `local-${Date.now()}`;
+        let directJobStore = null;
+        const nextJsPathAlias = "@/app/api/workflows/stores/jobStore";
+        const explicitPath = process.env.WORKER_JOB_STORE_MODULE_PATH;
+        const resolveJobStore = async () => {
+          try {
+            const module2 = await import(nextJsPathAlias);
+            if (module2?.updateJob) {
+              return { updateJob: module2.updateJob, setJob: module2.setJob };
+            }
+          } catch {
+          }
+          if (explicitPath) {
+            try {
+              const module2 = await import(explicitPath).catch(() => {
+                return require(explicitPath);
+              });
+              if (module2?.updateJob) {
+                return { updateJob: module2.updateJob, setJob: module2.setJob };
+              }
+            } catch {
+            }
+          }
+          return null;
+        };
+        directJobStore = await resolveJobStore();
+        if (directJobStore) {
+          console.log("[Worker] Using direct job store in local mode (no HTTP needed)");
+        }
+        let jobStoreUrl;
+        if (options.webhookUrl) {
+          try {
+            const webhookUrlObj = new URL(options.webhookUrl);
+            jobStoreUrl = webhookUrlObj.pathname.replace(/\/webhook$/, "");
+            jobStoreUrl = `${webhookUrlObj.origin}${jobStoreUrl}`;
+          } catch {
+          }
+        }
+        jobStoreUrl = jobStoreUrl || process.env.WORKER_JOB_STORE_URL;
+        const createLocalJobStore = (directStore, httpUrl) => {
+          if (directStore) {
+            return {
+              update: async (update) => {
+                try {
+                  const updatePayload = {};
+                  if (update.status !== void 0) {
+                    updatePayload.status = update.status;
+                  }
+                  if (update.metadata !== void 0) {
+                    updatePayload.metadata = update.metadata;
+                  }
+                  if (update.progress !== void 0) {
+                    updatePayload.metadata = {
+                      ...updatePayload.metadata,
+                      progress: update.progress,
+                      progressMessage: update.progressMessage
+                    };
+                  }
+                  if (update.output !== void 0) {
+                    updatePayload.output = update.output;
+                  }
+                  if (update.error !== void 0) {
+                    updatePayload.error = update.error;
+                  }
+                  await directStore.updateJob(localJobId, updatePayload);
+                  console.log("[Worker] Local job updated (direct DB):", {
+                    jobId: localJobId,
+                    workerId: id,
+                    updates: Object.keys(updatePayload)
+                  });
+                } catch (error) {
+                  console.warn("[Worker] Failed to update local job (direct DB):", {
+                    jobId: localJobId,
+                    workerId: id,
+                    error: error?.message || String(error)
+                  });
+                }
+              },
+              get: async () => {
+                try {
+                  if (directStore) {
+                    const nextJsPath = "@/app/api/workflows/stores/jobStore";
+                    const explicitPath2 = process.env.WORKER_JOB_STORE_MODULE_PATH;
+                    for (const importPath of [nextJsPath, explicitPath2].filter(Boolean)) {
+                      try {
+                        const module2 = await import(importPath);
+                        if (module2?.getJob) {
+                          return await module2.getJob(localJobId);
+                        }
+                      } catch {
+                      }
+                    }
+                  }
+                  return null;
+                } catch (error) {
+                  console.warn("[Worker] Failed to get local job (direct DB):", {
+                    jobId: localJobId,
+                    workerId: id,
+                    error: error?.message || String(error)
+                  });
+                  return null;
+                }
+              }
+            };
+          }
+          if (!httpUrl) {
+            return void 0;
+          }
+          return {
+            update: async (update) => {
+              try {
+                const updatePayload = { jobId: localJobId, workerId: id };
+                if (update.status !== void 0) {
+                  updatePayload.status = update.status;
+                }
+                if (update.metadata !== void 0) {
+                  updatePayload.metadata = update.metadata;
+                }
+                if (update.progress !== void 0) {
+                  updatePayload.metadata = {
+                    ...updatePayload.metadata,
+                    progress: update.progress,
+                    progressMessage: update.progressMessage
+                  };
+                }
+                if (update.output !== void 0) {
+                  updatePayload.output = update.output;
+                }
+                if (update.error !== void 0) {
+                  updatePayload.error = update.error;
+                }
+                const response = await fetch(`${httpUrl}/update`, {
+                  method: "POST",
+                  headers: { "Content-Type": "application/json" },
+                  body: JSON.stringify(updatePayload)
+                });
+                if (!response.ok) {
+                  throw new Error(`Job store update failed: ${response.status} ${response.statusText}`);
+                }
+                console.log("[Worker] Local job updated (HTTP):", {
+                  jobId: localJobId,
+                  workerId: id,
+                  updates: Object.keys(updatePayload)
+                });
+              } catch (error) {
+                console.warn("[Worker] Failed to update local job (HTTP):", {
+                  jobId: localJobId,
+                  workerId: id,
+                  error: error?.message || String(error)
+                });
+              }
+            },
+            get: async () => {
+              try {
+                const response = await fetch(`${httpUrl}/${id}/${localJobId}`, {
+                  method: "GET",
+                  headers: { "Content-Type": "application/json" }
+                });
+                if (!response.ok) {
+                  if (response.status === 404) {
+                    return null;
+                  }
+                  throw new Error(`Job store get failed: ${response.status} ${response.statusText}`);
+                }
+                return await response.json();
+              } catch (error) {
+                console.warn("[Worker] Failed to get local job (HTTP):", {
+                  jobId: localJobId,
+                  workerId: id,
+                  error: error?.message || String(error)
+                });
+                return null;
+              }
+            }
+          };
+        };
+        const jobStore = createLocalJobStore(directJobStore, jobStoreUrl);
+        if (directJobStore?.setJob) {
+          try {
+            await directJobStore.setJob(localJobId, {
+              jobId: localJobId,
+              workerId: id,
+              status: "queued",
+              input: parsedInput,
+              metadata: options.metadata || {}
+            });
+          } catch (error) {
+            console.warn("[Worker] Failed to create initial job record:", {
+              jobId: localJobId,
+              workerId: id,
+              error: error?.message || String(error)
+            });
+          }
+        }
+        const handlerContext = {
+          jobId: localJobId,
+          workerId: id,
+          ...jobStore ? { jobStore } : {}
+        };
+        try {
+          if (jobStore) {
+            await jobStore.update({ status: "running" });
+          }
+          const output = await dispatchLocal(handler, parsedInput, handlerContext);
+          if (jobStore) {
+            await jobStore.update({ status: "completed", output });
+          }
+          if (options.webhookUrl) {
+            try {
+              await fetch(options.webhookUrl, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                  jobId: localJobId,
+                  workerId: id,
+                  status: "success",
+                  output,
+                  metadata: options.metadata
+                })
+              });
+            } catch (error) {
+              console.warn("[Worker] Local webhook call failed:", error);
+            }
+          }
+          return {
+            messageId: `local-${Date.now()}`,
+            status: "queued",
+            jobId: localJobId
+          };
+        } catch (error) {
+          if (jobStore) {
+            await jobStore.update({
+              status: "failed",
+              error: {
+                message: error.message || "Unknown error",
+                stack: error.stack,
+                name: error.name || "Error"
+              }
+            });
+          }
+          if (options.webhookUrl) {
+            try {
+              await fetch(options.webhookUrl, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                  jobId: localJobId,
+                  workerId: id,
+                  status: "error",
+                  error: {
+                    message: error.message || "Unknown error",
+                    stack: error.stack,
+                    name: error.name || "Error"
+                  },
+                  metadata: options.metadata
+                })
+              });
+            } catch (webhookError) {
+              console.warn("[Worker] Local error webhook call failed:", webhookError);
+            }
+          }
+          throw error;
+        }
+      }
+      return dispatch(id, input, inputSchema, options);
+    }
+  };
+  return agent;
+}
+function createLambdaEntrypoint(agent) {
+  return createLambdaHandler(agent.handler, agent.outputSchema);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clearWorkersConfigCache,
+  createLambdaEntrypoint,
+  createLambdaHandler,
+  createWorker,
+  dispatch,
+  dispatchLocal,
+  getWorkersConfig,
+  resolveQueueUrl
+});
+//# sourceMappingURL=index.js.map