@microfox/ai-worker-cli 1.0.1

package/dist/index.js

@@ -0,0 +1,1379 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command2 } from "commander";
+
+// src/commands/push.ts
+import { Command } from "commander";
+import * as esbuild from "esbuild";
+import { execSync } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import { pathToFileURL } from "url";
+import { builtinModules } from "module";
+import { glob } from "glob";
+import * as yaml from "js-yaml";
+import chalk from "chalk";
+import ora from "ora";
+var NODE_BUILTINS = new Set(
+  builtinModules.map((m) => m.startsWith("node:") ? m.slice("node:".length) : m)
+);
+function isBuiltinModule(specifier) {
+  const s = specifier.startsWith("node:") ? specifier.slice("node:".length) : specifier;
+  return NODE_BUILTINS.has(s);
+}
+function getPackageNameFromSpecifier(specifier) {
+  if (specifier.startsWith("@")) {
+    const [scope, name] = specifier.split("/");
+    return name ? `${scope}/${name}` : specifier;
+  }
+  return specifier.split("/")[0];
+}
+function tryResolveLocalImport(fromFile, specifier) {
+  const baseDir = path.dirname(fromFile);
+  const raw = path.resolve(baseDir, specifier);
+  const candidates = [
+    raw,
+    `${raw}.ts`,
+    `${raw}.tsx`,
+    `${raw}.js`,
+    `${raw}.mjs`,
+    `${raw}.cjs`
+  ];
+  for (const c of candidates) {
+    if (fs.existsSync(c) && fs.statSync(c).isFile()) return c;
+  }
+  if (fs.existsSync(raw) && fs.statSync(raw).isDirectory()) {
+    const idxCandidates = [
+      path.join(raw, "index.ts"),
+      path.join(raw, "index.tsx"),
+      path.join(raw, "index.js"),
+      path.join(raw, "index.mjs"),
+      path.join(raw, "index.cjs")
+    ];
+    for (const c of idxCandidates) {
+      if (fs.existsSync(c) && fs.statSync(c).isFile()) return c;
+    }
+  }
+  return null;
+}
+function extractImportSpecifiers(source) {
+  const specs = [];
+  const re1 = /(?:^|\n)\s*(?!import\s+type)(?:import|export)\s+[\s\S]*?\sfrom\s*['"]([^'"]+)['"]/g;
+  for (const match of source.matchAll(re1)) {
+    if (match[1]) specs.push(match[1]);
+  }
+  const re2 = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+  for (const match of source.matchAll(re2)) {
+    if (match[1]) specs.push(match[1]);
+  }
+  const re3 = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+  for (const match of source.matchAll(re3)) {
+    if (match[1]) specs.push(match[1]);
+  }
+  return specs;
+}
+function extractEnvVarUsageFromSource(source) {
+  const runtimeKeys = /* @__PURE__ */ new Set();
+  const buildtimeKeys = /* @__PURE__ */ new Set();
+  const reProcessDot = /\bprocess\.env\??\.([A-Za-z_][A-Za-z0-9_]*)\b/g;
+  for (const match of source.matchAll(reProcessDot)) {
+    const key = match[1];
+    if (key) runtimeKeys.add(key);
+  }
+  const reProcessBracket = /\bprocess\.env\[\s*['"]([^'"]+)['"]\s*\]/g;
+  for (const match of source.matchAll(reProcessBracket)) {
+    const key = match[1];
+    if (key) runtimeKeys.add(key);
+  }
+  const reImportMetaDot = /\bimport\.meta\.env\.([A-Za-z_][A-Za-z0-9_]*)\b/g;
+  for (const match of source.matchAll(reImportMetaDot)) {
+    const key = match[1];
+    if (key) buildtimeKeys.add(key);
+  }
+  const reImportMetaBracket = /\bimport\.meta\.env\[\s*['"]([^'"]+)['"]\s*\]/g;
+  for (const match of source.matchAll(reImportMetaBracket)) {
+    const key = match[1];
+    if (key) buildtimeKeys.add(key);
+  }
+  return { runtimeKeys, buildtimeKeys };
+}
+async function collectEnvUsageForWorkers(workerEntryFiles, projectRoot) {
+  void projectRoot;
+  const runtimeKeys = /* @__PURE__ */ new Set();
+  const buildtimeKeys = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [...workerEntryFiles];
+  while (queue.length > 0) {
+    const file = queue.pop();
+    const normalized = path.resolve(file);
+    if (visited.has(normalized)) continue;
+    visited.add(normalized);
+    if (!fs.existsSync(normalized) || !fs.statSync(normalized).isFile()) continue;
+    const src = fs.readFileSync(normalized, "utf-8");
+    const usage = extractEnvVarUsageFromSource(src);
+    usage.runtimeKeys.forEach((k) => runtimeKeys.add(k));
+    usage.buildtimeKeys.forEach((k) => buildtimeKeys.add(k));
+    const specifiers = extractImportSpecifiers(src);
+    for (const spec of specifiers) {
+      if (!spec) continue;
+      if (spec.startsWith(".")) {
+        const resolved = tryResolveLocalImport(normalized, spec);
+        if (resolved) queue.push(resolved);
+        continue;
+      }
+      if (spec.startsWith("/")) continue;
+      if (isBuiltinModule(spec)) continue;
+    }
+  }
+  runtimeKeys.delete("");
+  buildtimeKeys.delete("");
+  runtimeKeys.delete("node");
+  buildtimeKeys.delete("node");
+  return { runtimeKeys, buildtimeKeys };
+}
+function readJsonFile(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function findMonorepoRoot(startDir) {
+  let dir = path.resolve(startDir);
+  while (true) {
+    const pkgPath = path.join(dir, "package.json");
+    if (fs.existsSync(pkgPath)) {
+      const pkg = readJsonFile(pkgPath);
+      if (pkg?.workspaces) return dir;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) return startDir;
+    dir = parent;
+  }
+}
+async function collectRuntimeDependenciesForWorkers(workerEntryFiles, projectRoot) {
+  const deps = /* @__PURE__ */ new Set(["@microfox/ai-worker", "@aws-sdk/client-sqs"]);
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [...workerEntryFiles];
+  while (queue.length > 0) {
+    const file = queue.pop();
+    const normalized = path.resolve(file);
+    if (visited.has(normalized)) continue;
+    visited.add(normalized);
+    if (!fs.existsSync(normalized) || !fs.statSync(normalized).isFile()) continue;
+    const src = fs.readFileSync(normalized, "utf-8");
+    const specifiers = extractImportSpecifiers(src);
+    for (const spec of specifiers) {
+      if (!spec) continue;
+      if (spec.startsWith(".")) {
+        const resolved = tryResolveLocalImport(normalized, spec);
+        if (resolved) queue.push(resolved);
+        continue;
+      }
+      if (spec.startsWith("/")) continue;
+      if (isBuiltinModule(spec)) continue;
+      deps.add(getPackageNameFromSpecifier(spec));
+    }
+  }
+  deps.delete("");
+  deps.delete("node");
+  deps.delete("serverless");
+  deps.delete("serverless-offline");
+  deps.delete("@aws-sdk/client-sqs");
+  deps.delete("@microfox/ai-worker");
+  return deps;
+}
+function buildDependenciesMap(projectRoot, deps) {
+  const projectPkg = readJsonFile(path.join(projectRoot, "package.json")) || {};
+  const projectDeps = projectPkg.dependencies || {};
+  const projectDevDeps = projectPkg.devDependencies || {};
+  const repoRoot = findMonorepoRoot(projectRoot);
+  const workerPkg = readJsonFile(path.join(repoRoot, "packages", "ai-worker", "package.json")) || {};
+  const workerCliPkg = readJsonFile(
+    path.join(repoRoot, "packages", "ai-worker-cli", "package.json")
+  ) || {};
+  const workspaceDeps = {
+    ...workerPkg.dependencies || {},
+    ...workerPkg.devDependencies || {},
+    ...workerCliPkg.dependencies || {},
+    ...workerCliPkg.devDependencies || {}
+  };
+  const out = {};
+  for (const dep of Array.from(deps).sort()) {
+    const range = projectDeps[dep] || projectDevDeps[dep] || workspaceDeps[dep];
+    if (range) {
+      out[dep] = String(range);
+    }
+  }
+  return out;
+}
+function getServiceNameFromProjectId(projectId) {
+  const cleanedProjectId = projectId.replace(/-/g, "").slice(0, 15);
+  return `p-${cleanedProjectId}`;
+}
+function validateEnvironment() {
+  try {
+    execSync("npm --version", { stdio: "ignore" });
+  } catch (error) {
+    console.error(chalk.red("\u274C npm is not installed or not in PATH."));
+    process.exit(1);
+  }
+}
+async function scanWorkers(aiPath = "app/ai") {
+  const pattern = path.join(aiPath, "**/*.worker.ts").replace(/\\/g, "/");
+  const files = await glob(pattern);
+  const workers = [];
+  for (const filePath of files) {
+    try {
+      let workerConfig;
+      let workerId;
+      if (!workerId) {
+        const content = fs.readFileSync(filePath, "utf-8");
+        const idMatch = content.match(/createWorker\s*(?:<[^>]+>)?\s*\(\s*\{[\s\S]*?id:\s*['"]([^'"]+)['"]/);
+        if (!idMatch) {
+          console.warn(chalk.yellow(`\u26A0\uFE0F  Skipping ${filePath}: No worker ID found`));
+          continue;
+        }
+        workerId = idMatch[1];
+      }
+      const relativePath = path.relative(aiPath, filePath);
+      const handlerDir = path.dirname(relativePath);
+      const handlerName = path.basename(relativePath, ".worker.ts");
+      const handlerPath = path.join("handlers", handlerDir, `${handlerName}`).replace(/\\/g, "/");
+      workers.push({
+        id: workerId,
+        filePath,
+        handlerPath,
+        workerConfig
+      });
+    } catch (error) {
+      console.error(chalk.red(`\u274C Error processing ${filePath}:`), error);
+    }
+  }
+  return workers;
+}
+async function generateHandlers(workers, outputDir) {
+  const handlersDir = path.join(outputDir, "handlers");
+  if (fs.existsSync(handlersDir)) {
+    fs.rmSync(handlersDir, { recursive: true, force: true });
+  }
+  fs.mkdirSync(handlersDir, { recursive: true });
+  for (const worker of workers) {
+    const handlerFile = path.join(handlersDir, worker.handlerPath.replace("handlers/", "") + ".js");
+    const handlerDir = path.dirname(handlerFile);
+    if (!fs.existsSync(handlerDir)) {
+      fs.mkdirSync(handlerDir, { recursive: true });
+    }
+    const handlerAbsPath = path.resolve(handlerFile);
+    const workerAbsPath = path.resolve(worker.filePath);
+    let relativeImportPath = path.relative(path.dirname(handlerAbsPath), workerAbsPath);
+    if (!relativeImportPath.startsWith(".")) {
+      relativeImportPath = "./" + relativeImportPath;
+    }
+    relativeImportPath = relativeImportPath.replace(/\.ts$/, "");
+    relativeImportPath = relativeImportPath.split(path.sep).join("/");
+    const fileContent = fs.readFileSync(worker.filePath, "utf-8");
+    const defaultExport = /export\s+default\s+createWorker/.test(fileContent);
+    const exportMatch = fileContent.match(/export\s+(const|let)\s+(\w+)\s*=\s*createWorker/);
+    const exportName = exportMatch ? exportMatch[2] : "worker";
+    const tempEntryFile = handlerFile.replace(".js", ".temp.ts");
+    const workerRef = defaultExport ? "workerModule.default" : `workerModule.${exportName}`;
+    const tempEntryContent = `
+import { createLambdaHandler } from '@microfox/ai-worker/handler';
+import * as workerModule from '${relativeImportPath}';
+
+const workerAgent = ${workerRef};
+if (!workerAgent || typeof workerAgent.handler !== 'function') {
+  throw new Error('Worker module must export a createWorker result (default or named) with .handler');
+}
+
+export const handler = createLambdaHandler(workerAgent.handler, workerAgent.outputSchema);
+export const exportedWorkerConfig = workerModule.workerConfig || workerAgent?.workerConfig;
+`;
+    fs.writeFileSync(tempEntryFile, tempEntryContent);
+    try {
+      const fixLazyCachePlugin = {
+        name: "fix-lazy-cache",
+        setup(build3) {
+          build3.onEnd(async (result) => {
+            if (result.errors.length > 0) return;
+            let bundledCode = fs.readFileSync(handlerFile, "utf-8");
+            let modified = false;
+            const pattern = /(require\("kind-of",\s*"typeOf"\);\s*)require_for_own\(\);/g;
+            if (pattern.test(bundledCode)) {
+              bundledCode = bundledCode.replace(
+                pattern,
+                '$1require("for-own", "forOwn");'
+              );
+              modified = true;
+            }
+            if (bundledCode.includes("import_meta.url")) {
+              bundledCode = bundledCode.replace(
+                /import_meta\.url/g,
+                'require("url").pathToFileURL(__filename).href'
+              );
+              modified = true;
+            }
+            const beforeCreateRequire = bundledCode;
+            bundledCode = bundledCode.replace(
+              /\bcreateRequire\s*\(\s*(?:undefined|void\s*0)\s*\)/g,
+              'createRequire(require("url").pathToFileURL(__filename).href)'
+            );
+            if (bundledCode !== beforeCreateRequire) modified = true;
+            if (modified) {
+              fs.writeFileSync(handlerFile, bundledCode, "utf-8");
+            }
+          });
+        }
+      };
+      await esbuild.build({
+        entryPoints: [tempEntryFile],
+        bundle: true,
+        platform: "node",
+        target: "node20",
+        format: "cjs",
+        outfile: handlerFile,
+        // We exclude aws-sdk as it's included in Lambda runtime
+        // We exclude canvas because it's a binary dependency often problematic in bundling
+        external: [
+          "aws-sdk",
+          "canvas",
+          "@microfox/puppeteer-sls",
+          "@sparticuz/chromium"
+        ],
+        // Force lazy-cache to eagerly load modules during bundling
+        // This prevents runtime dynamic require() calls that fail in bundled code
+        define: {
+          "process.env.UNLAZY": '"true"'
+        },
+        // Force bundling of all packages to avoid runtime module resolution issues
+        // This ensures clone-deep, lazy-cache, and all transitive deps are bundled
+        packages: "bundle",
+        plugins: [fixLazyCachePlugin],
+        logLevel: "error"
+      });
+      fs.unlinkSync(tempEntryFile);
+    } catch (error) {
+      console.error(chalk.red(`Error bundling handler for ${worker.id}:`), error);
+    }
+  }
+  console.log(chalk.green(`\u2713 Generated ${workers.length} bundled handlers`));
+}
+function generateDocsHandler(outputDir, serviceName, stage, region) {
+  const handlerFile = path.join(outputDir, "handlers", "docs.js");
+  const tempEntryFile = handlerFile.replace(".js", ".temp.ts");
+  const handlerDir = path.dirname(handlerFile);
+  if (!fs.existsSync(handlerDir)) {
+    fs.mkdirSync(handlerDir, { recursive: true });
+  }
+  const handlerContent = `/**
+ * Auto-generated docs handler for Microfox compatibility
+ * DO NOT EDIT - This file is generated by @microfox/ai-worker-cli
+ */
+
+import { APIGatewayProxyEvent, APIGatewayProxyResult } from 'aws-lambda';
+
+export const handler = async (
+  event: APIGatewayProxyEvent
+): Promise<APIGatewayProxyResult> => {
+  // Return OpenAPI JSON for Microfox
+  const openapi = {
+    openapi: '3.0.3',
+    info: {
+      title: 'AI Worker Service',
+      version: '1.0.0',
+      description: 'Auto-generated OpenAPI for background workers service',
+    },
+    servers: [
+      {
+        url: 'https://{apiId}.execute-api.{region}.amazonaws.com/{stage}',
+        variables: {
+          apiId: { default: 'REPLACE_ME' },
+          region: { default: '${region}' },
+          stage: { default: '${stage}' },
+        },
+      },
+    ],
+    paths: {
+      '/docs.json': {
+        get: {
+          operationId: 'getDocs',
+          summary: 'Get OpenAPI schema',
+          responses: {
+            '200': {
+              description: 'OpenAPI JSON',
+              content: {
+                'application/json': {
+                  schema: { type: 'object' },
+                },
+              },
+            },
+          },
+        },
+      },
+      '/workers/config': {
+        get: {
+          operationId: 'getWorkersConfig',
+          summary: 'Get workers config (queue urls map)',
+          parameters: [
+            {
+              name: 'x-workers-config-key',
+              in: 'header',
+              required: false,
+              schema: { type: 'string' },
+              description: 'Optional API key header (if configured)',
+            },
+          ],
+          responses: {
+            '200': {
+              description: 'Workers config map',
+              content: {
+                'application/json': {
+                  schema: {
+                    type: 'object',
+                    properties: {
+                      version: { type: 'string' },
+                      stage: { type: 'string' },
+                      region: { type: 'string' },
+                      workers: { type: 'object' },
+                    },
+                  },
+                },
+              },
+            },
+            '401': {
+              description: 'Unauthorized',
+              content: {
+                'application/json': {
+                  schema: {
+                    type: 'object',
+                    properties: { error: { type: 'string' } },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+      '/workers/trigger': {
+        post: {
+          operationId: 'triggerWorker',
+          summary: 'Trigger a worker by sending a raw SQS message body',
+          parameters: [
+            {
+              name: 'workerId',
+              in: 'query',
+              required: false,
+              schema: { type: 'string' },
+              description: 'Worker ID (can also be provided in JSON body as workerId)',
+            },
+            {
+              name: 'x-workers-trigger-key',
+              in: 'header',
+              required: false,
+              schema: { type: 'string' },
+              description: 'Optional API key header (if configured)',
+            },
+          ],
+          requestBody: {
+            required: true,
+            content: {
+              'application/json': {
+                schema: {
+                  type: 'object',
+                  properties: {
+                    workerId: { type: 'string' },
+                    // Prefer sending the exact SQS message body your worker expects
+                    body: { type: 'object' },
+                    messageBody: { type: 'string' },
+                  },
+                  additionalProperties: true,
+                },
+              },
+            },
+          },
+          responses: {
+            '200': {
+              description: 'Enqueued',
+              content: {
+                'application/json': {
+                  schema: {
+                    type: 'object',
+                    properties: {
+                      ok: { type: 'boolean' },
+                      workerId: { type: 'string' },
+                      stage: { type: 'string' },
+                      queueName: { type: 'string' },
+                      queueUrl: { type: 'string' },
+                      messageId: { type: 'string' },
+                    },
+                  },
+                },
+              },
+            },
+            '400': {
+              description: 'Bad request',
+              content: {
+                'application/json': {
+                  schema: {
+                    type: 'object',
+                    properties: { error: { type: 'string' } },
+                  },
+                },
+              },
+            },
+            '401': {
+              description: 'Unauthorized',
+              content: {
+                'application/json': {
+                  schema: {
+                    type: 'object',
+                    properties: { error: { type: 'string' } },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+    'x-service': {
+      serviceName: '${serviceName}',
+      stage: '${stage}',
+      region: '${region}',
+    },
+  };
+
+  return {
+    statusCode: 200,
+    headers: {
+      'Content-Type': 'application/json',
+      'Access-Control-Allow-Origin': '*',
+    },
+    body: JSON.stringify(openapi, null, 2),
+  };
+};
+`;
+  fs.writeFileSync(tempEntryFile, handlerContent);
+  esbuild.buildSync({
+    entryPoints: [tempEntryFile],
+    bundle: true,
+    platform: "node",
+    target: "node20",
+    outfile: handlerFile,
+    external: [
+      "aws-sdk",
+      "canvas",
+      "@microfox/puppeteer-sls",
+      "@sparticuz/chromium"
+    ],
+    define: {
+      "process.env.UNLAZY": '"true"'
+    },
+    packages: "bundle"
+  });
+  fs.unlinkSync(tempEntryFile);
+  console.log(chalk.green(`\u2713 Generated docs.json handler`));
+}
+function generateTriggerHandler(outputDir, serviceName) {
+  const handlerFile = path.join(outputDir, "handlers", "workers-trigger.js");
+  const tempEntryFile = handlerFile.replace(".js", ".temp.ts");
+  const handlerDir = path.dirname(handlerFile);
+  if (!fs.existsSync(handlerDir)) {
+    fs.mkdirSync(handlerDir, { recursive: true });
+  }
+  const handlerContent = `/**
+ * Auto-generated worker trigger handler
+ * DO NOT EDIT - This file is generated by @microfox/ai-worker-cli
+ */
+
+import { APIGatewayProxyEvent, APIGatewayProxyResult } from 'aws-lambda';
+import { SQSClient, GetQueueUrlCommand, SendMessageCommand } from '@aws-sdk/client-sqs';
+
+const SERVICE_NAME = ${JSON.stringify(serviceName)};
+
+function jsonResponse(statusCode: number, body: any): APIGatewayProxyResult {
+  return {
+    statusCode,
+    headers: {
+      'Content-Type': 'application/json',
+      'Access-Control-Allow-Origin': '*',
+    },
+    body: JSON.stringify(body),
+  };
+}
+
+export const handler = async (event: APIGatewayProxyEvent): Promise<APIGatewayProxyResult> => {
+  // Optional API key
+  const apiKey = process.env.WORKERS_TRIGGER_API_KEY;
+  if (apiKey) {
+    const providedKey = event.headers['x-workers-trigger-key'] || event.headers['X-Workers-Trigger-Key'];
+    if (providedKey !== apiKey) {
+      return jsonResponse(401, { error: 'Unauthorized' });
+    }
+  }
+
+  const stage =
+    (event as any)?.requestContext?.stage ||
+    process.env.ENVIRONMENT ||
+    process.env.STAGE ||
+    'prod';
+  const region = process.env.AWS_REGION || 'us-east-1';
+
+  const qsWorkerId = event.queryStringParameters?.workerId;
+
+  let parsedBody: any = undefined;
+  if (event.body) {
+    try {
+      parsedBody = JSON.parse(event.body);
+    } catch {
+      parsedBody = undefined;
+    }
+  }
+
+  const workerId = (parsedBody && parsedBody.workerId) || qsWorkerId;
+  if (!workerId || typeof workerId !== 'string') {
+    return jsonResponse(400, { error: 'workerId is required (query param workerId or JSON body workerId)' });
+  }
+
+  // Prefer JSON body fields, otherwise send raw event.body
+  let messageBody: string | undefined;
+  if (parsedBody && typeof parsedBody.messageBody === 'string') {
+    messageBody = parsedBody.messageBody;
+  } else if (parsedBody && parsedBody.body !== undefined) {
+    messageBody = typeof parsedBody.body === 'string' ? parsedBody.body : JSON.stringify(parsedBody.body);
+  } else if (event.body) {
+    messageBody = event.body;
+  }
+
+  if (!messageBody) {
+    return jsonResponse(400, { error: 'body/messageBody is required' });
+  }
+
+  const queueName = \`\${SERVICE_NAME}-\${workerId}-\${stage}\`;
+  const sqs = new SQSClient({ region });
+
+  let queueUrl: string;
+  try {
+    const urlRes = await sqs.send(new GetQueueUrlCommand({ QueueName: queueName }));
+    if (!urlRes.QueueUrl) {
+      return jsonResponse(404, { error: 'Queue URL not found', queueName });
+    }
+    queueUrl = String(urlRes.QueueUrl);
+  } catch (e: any) {
+    return jsonResponse(404, { error: 'Queue does not exist or not accessible', queueName, message: String(e?.message || e) });
+  }
+
+  try {
+    const sendRes = await sqs.send(new SendMessageCommand({ QueueUrl: queueUrl, MessageBody: messageBody }));
+    return jsonResponse(200, {
+      ok: true,
+      workerId,
+      stage,
+      queueName,
+      queueUrl,
+      messageId: sendRes.MessageId || null,
+    });
+  } catch (e: any) {
+    return jsonResponse(500, { error: 'Failed to send message', message: String(e?.message || e) });
+  }
+};
+`;
+  fs.writeFileSync(tempEntryFile, handlerContent);
+  esbuild.buildSync({
+    entryPoints: [tempEntryFile],
+    bundle: true,
+    platform: "node",
+    target: "node20",
+    outfile: handlerFile,
+    external: [
+      "aws-sdk",
+      "canvas",
+      "@microfox/puppeteer-sls",
+      "@sparticuz/chromium"
+    ],
+    define: {
+      "process.env.UNLAZY": '"true"'
+    },
+    packages: "bundle",
+    logLevel: "error"
+  });
+  fs.unlinkSync(tempEntryFile);
+  console.log(chalk.green(`\u2713 Generated /workers/trigger handler`));
+}
+function generateWorkersConfigHandler(outputDir, workers, serviceName) {
+  const handlerFile = path.join(outputDir, "handlers", "workers-config.js");
+  const tempEntryFile = handlerFile.replace(".js", ".temp.ts");
+  const handlerDir = path.dirname(handlerFile);
+  if (fs.existsSync(handlerDir) && !fs.existsSync(handlerFile)) {
+  } else if (!fs.existsSync(handlerDir)) {
+    fs.mkdirSync(handlerDir, { recursive: true });
+  }
+  const handlerContent = `/**
+ * Auto-generated workers-config Lambda handler
+ * DO NOT EDIT - This file is generated by @microfox/ai-worker-cli
+ */
+
+import { APIGatewayProxyEvent, APIGatewayProxyResult } from 'aws-lambda';
+import { SQSClient, GetQueueUrlCommand } from '@aws-sdk/client-sqs';
+
+// Worker IDs embedded at build time so this endpoint doesn't depend on any generated files.
+const WORKER_IDS: string[] = ${JSON.stringify(workers.map((w) => w.id), null, 2)};
+const SERVICE_NAME = ${JSON.stringify(serviceName)};
+
+export const handler = async (
+  event: APIGatewayProxyEvent
+): Promise<APIGatewayProxyResult> => {
+// ... same logic ...
+  // Check API key if configured
+  const apiKey = process.env.WORKERS_CONFIG_API_KEY;
+  if (apiKey) {
+    const providedKey = event.headers['x-workers-config-key'] || event.headers['X-Workers-Config-Key'];
+    if (providedKey !== apiKey) {
+      return {
+        statusCode: 401,
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ error: 'Unauthorized' }),
+      };
+    }
+  }
+
+  // Stage resolution:
+  // - Prefer API Gateway stage (microfox tends to deploy APIs on "prod")
+  // - Fallback to ENVIRONMENT/STAGE env vars
+  // - Default to "prod" (safer for microfox) if nothing else is set
+  const stage =
+    (event as any)?.requestContext?.stage ||
+    process.env.ENVIRONMENT ||
+    process.env.STAGE ||
+    'prod';
+  const region = process.env.AWS_REGION || 'us-east-1';
+
+  // Resolve queue URLs dynamically via SQS so we return actual URLs.
+  // NOTE: Node 20 Lambda runtime does NOT guarantee 'aws-sdk' v2 is available.
+  // We use AWS SDK v3 and bundle it into this handler.
+  const sqs = new SQSClient({ region });
+  const workers: Record<string, { queueUrl: string; region: string }> = {};
+  const attemptedQueueNames: string[] = [];
+  const errors: Array<{ workerId: string; queueName: string; message: string; name?: string }> = [];
+  const debug = event.queryStringParameters?.debug === '1' || event.queryStringParameters?.debug === 'true';
+
+  await Promise.all(
+    WORKER_IDS.map(async (workerId) => {
+      const queueName = \`\${SERVICE_NAME}-\${workerId}-\${stage}\`;
+      attemptedQueueNames.push(queueName);
+      try {
+        const result = await sqs.send(new GetQueueUrlCommand({ QueueName: queueName }));
+        if (result?.QueueUrl) {
+          workers[workerId] = { queueUrl: String(result.QueueUrl), region };
+        }
+      } catch (e) {
+        const err = e as any;
+        const message = String(err?.message || err || 'Unknown error');
+        const name = err?.name ? String(err.name) : undefined;
+        // Log so CloudWatch shows what's going on (nonexistent queue vs permission vs region).
+        console.error('[workers-config] getQueueUrl failed', { workerId, queueName, name, message });
+        errors.push({ workerId, queueName, name, message });
+      }
+    })
+  );
+
+  return {
+    statusCode: 200,
+    headers: {
+      'Content-Type': 'application/json',
+      'Access-Control-Allow-Origin': '*',
+    },
+    body: JSON.stringify({
+      version: '1.0.0',
+      stage,
+      region,
+      workers,
+      ...(debug ? { attemptedQueueNames, errors } : {}),
+    }),
+  };
+};
+`;
+  fs.writeFileSync(tempEntryFile, handlerContent);
+  esbuild.buildSync({
+    entryPoints: [tempEntryFile],
+    bundle: true,
+    platform: "node",
+    target: "node20",
+    outfile: handlerFile,
+    external: [
+      "aws-sdk",
+      "canvas",
+      "@microfox/puppeteer-sls",
+      "@sparticuz/chromium"
+    ],
+    define: {
+      "process.env.UNLAZY": '"true"'
+    },
+    packages: "bundle"
+  });
+  fs.unlinkSync(tempEntryFile);
+  console.log(chalk.green(`\u2713 Generated workers-config handler`));
+}
+function loadEnvVars(envPath = ".env") {
+  const env = {};
+  if (!fs.existsSync(envPath)) {
+    console.warn(chalk.yellow(`\u26A0\uFE0F  .env file not found at ${envPath}`));
+    return env;
+  }
+  const content = fs.readFileSync(envPath, "utf-8");
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const match = trimmed.match(/^([^=]+)=(.*)$/);
+    if (match) {
+      const key = match[1].trim();
+      const value = match[2].trim().replace(/^["']|["']$/g, "");
+      env[key] = value;
+    }
+  }
+  return env;
+}
+function processScheduleEvents(scheduleConfig) {
+  if (!scheduleConfig) {
+    return [];
+  }
+  const events = [];
+  const schedules = Array.isArray(scheduleConfig) ? scheduleConfig : [scheduleConfig];
+  for (const schedule of schedules) {
+    if (typeof schedule === "string") {
+      events.push({
+        schedule
+      });
+      continue;
+    }
+    if (typeof schedule === "object" && schedule !== null) {
+      const scheduleEvent = { schedule: {} };
+      if (schedule.rate) {
+        if (Array.isArray(schedule.rate)) {
+          scheduleEvent.schedule.rate = schedule.rate;
+        } else {
+          scheduleEvent.schedule.rate = schedule.rate;
+        }
+      } else {
+        continue;
+      }
+      if (schedule.enabled !== void 0) {
+        scheduleEvent.schedule.enabled = schedule.enabled;
+      }
+      if (schedule.input !== void 0) {
+        scheduleEvent.schedule.input = schedule.input;
+      }
+      if (schedule.inputPath !== void 0) {
+        scheduleEvent.schedule.inputPath = schedule.inputPath;
+      }
+      if (schedule.inputTransformer !== void 0) {
+        scheduleEvent.schedule.inputTransformer = schedule.inputTransformer;
+      }
+      if (schedule.name !== void 0) {
+        scheduleEvent.schedule.name = schedule.name;
+      }
+      if (schedule.description !== void 0) {
+        scheduleEvent.schedule.description = schedule.description;
+      }
+      if (schedule.method !== void 0) {
+        scheduleEvent.schedule.method = schedule.method;
+      }
+      if (schedule.timezone !== void 0) {
+        scheduleEvent.schedule.timezone = schedule.timezone;
+      }
+      if (Object.keys(scheduleEvent.schedule).length === 1 && scheduleEvent.schedule.rate) {
+        if (typeof scheduleEvent.schedule.rate === "string") {
+          events.push({
+            schedule: scheduleEvent.schedule.rate
+          });
+        } else {
+          events.push(scheduleEvent);
+        }
+      } else {
+        events.push(scheduleEvent);
+      }
+    }
+  }
+  return events;
+}
+function generateServerlessConfig(workers, stage, region, envVars, serviceName) {
+  const resources = {
+    Resources: {},
+    Outputs: {}
+  };
+  const queueArns = [];
+  const providerEnvironment = {
+    STAGE: stage,
+    NODE_ENV: stage
+  };
+  const customConfig = {
+    stage: `\${env:ENVIRONMENT, '${stage}'}`,
+    "serverless-offline": {
+      httpPort: 4e3,
+      lambdaPort: 4002,
+      useChildProcesses: true,
+      useWorkerThreads: true,
+      noCookieValidation: true,
+      allowCache: true,
+      hideStackTraces: false,
+      disableCookieValidation: true,
+      noTimeout: true,
+      environment: "${file(env.json)}"
+    }
+  };
+  for (const worker of workers) {
+    const queueName = `WorkerQueue${worker.id.replace(/[^a-zA-Z0-9]/g, "")}`;
+    const queueLogicalId = `${queueName}${stage}`;
+    const dlqLogicalId = `${queueName}DLQ${stage}`;
+    const sqsCfg = worker.workerConfig?.sqs;
+    const retention = typeof sqsCfg?.messageRetentionPeriod === "number" ? sqsCfg.messageRetentionPeriod : 1209600;
+    const dlqRetention = typeof sqsCfg?.deadLetterMessageRetentionPeriod === "number" ? sqsCfg.deadLetterMessageRetentionPeriod : retention;
+    const visibilityTimeout = typeof sqsCfg?.visibilityTimeout === "number" ? sqsCfg.visibilityTimeout : (worker.workerConfig?.timeout || 300) + 60;
+    const maxReceiveCountRaw = typeof sqsCfg?.maxReceiveCount === "number" ? sqsCfg.maxReceiveCount : 1;
+    const maxReceiveCount = Math.max(1, Math.floor(maxReceiveCountRaw));
+    resources.Resources[dlqLogicalId] = {
+      Type: "AWS::SQS::Queue",
+      Properties: {
+        QueueName: `\${self:service}-${worker.id}-dlq-\${opt:stage, env:ENVIRONMENT, '${stage}'}`,
+        MessageRetentionPeriod: dlqRetention
+      }
+    };
+    resources.Resources[queueLogicalId] = {
+      Type: "AWS::SQS::Queue",
+      Properties: {
+        // Use ${self:service} to avoid hardcoding service name
+        QueueName: `\${self:service}-${worker.id}-\${opt:stage, env:ENVIRONMENT, '${stage}'}`,
+        VisibilityTimeout: visibilityTimeout,
+        MessageRetentionPeriod: retention,
+        RedrivePolicy: {
+          deadLetterTargetArn: { "Fn::GetAtt": [dlqLogicalId, "Arn"] },
+          maxReceiveCount
+        }
+      }
+    };
+    resources.Outputs[`${queueLogicalId}Url`] = {
+      Description: `Queue URL for worker ${worker.id}`,
+      Value: { Ref: queueLogicalId },
+      Export: {
+        Name: `\${self:service}-${worker.id}-queue-url`
+      }
+    };
+    queueArns.push({ "Fn::GetAtt": [queueLogicalId, "Arn"] });
+  }
+  const functions = {};
+  for (const worker of workers) {
+    const functionName = `worker${worker.id.replace(/[^a-zA-Z0-9]/g, "")}`;
+    const events = [
+      {
+        sqs: {
+          arn: { "Fn::GetAtt": [`WorkerQueue${worker.id.replace(/[^a-zA-Z0-9]/g, "")}${stage}`, "Arn"] },
+          batchSize: 1
+        }
+      }
+    ];
+    if (worker.workerConfig?.schedule) {
+      const scheduleEvents = processScheduleEvents(worker.workerConfig.schedule);
+      events.push(...scheduleEvents);
+    }
+    functions[functionName] = {
+      // IMPORTANT: Keep AWS handler string to exactly one dot: "<modulePath>.handler"
+      handler: `${worker.handlerPath}.handler`,
+      timeout: worker.workerConfig?.timeout || 300,
+      memorySize: worker.workerConfig?.memorySize || 512,
+      events
+    };
+    if (worker.workerConfig?.layers?.length) {
+      functions[functionName].layers = worker.workerConfig.layers;
+    }
+  }
+  functions["getDocs"] = {
+    handler: "handlers/docs.handler",
+    events: [
+      {
+        http: {
+          path: "/docs.json",
+          method: "GET",
+          cors: true
+        }
+      }
+    ]
+  };
+  functions["triggerWorker"] = {
+    handler: "handlers/workers-trigger.handler",
+    events: [
+      {
+        http: {
+          path: "/workers/trigger",
+          method: "POST",
+          cors: true
+        }
+      }
+    ]
+  };
+  functions["workersConfig"] = {
+    handler: "handlers/workers-config.handler",
+    events: [
+      {
+        http: {
+          path: "workers/config",
+          method: "GET",
+          cors: true
+        }
+      }
+    ]
+  };
+  const safeEnvVars = {};
+  const allowedPrefixes = ["OPENAI_", "ANTHROPIC_", "DATABASE_", "MONGODB_", "REDIS_", "WORKERS_", "REMOTION_"];
+  for (const [key, value] of Object.entries(envVars)) {
+    if (allowedPrefixes.some((prefix) => key.startsWith(prefix))) {
+      safeEnvVars[key] = value;
+    }
+  }
+  resources.Outputs["ApiEndpoints"] = {
+    Description: "API Endpoints",
+    Value: {
+      "Fn::Join": [
+        "",
+        [
+          "API: https://",
+          { "Ref": "ApiGatewayRestApi" },
+          ".execute-api.",
+          { "Ref": "AWS::Region" },
+          `.amazonaws.com/\${env:ENVIRONMENT, '${stage}'}`
+        ]
+      ]
+    }
+  };
+  return {
+    service: serviceName,
+    package: {
+      excludeDevDependencies: true,
+      patterns: [
+        "!venv/**",
+        "!.idea/**",
+        "!.vscode/**",
+        "!src/**",
+        "!node_modules/serverless-offline/**",
+        "!node_modules/typescript/**",
+        "!node_modules/@types/**",
+        "!node_modules/aws-sdk/**",
+        "!node_modules/@aws-sdk/**"
+      ]
+    },
+    custom: customConfig,
+    provider: {
+      name: "aws",
+      runtime: "nodejs20.x",
+      region,
+      versionFunctions: false,
+      // Use ENVIRONMENT from env.json to drive the actual deployed stage (Microfox defaults to prod).
+      stage: `\${env:ENVIRONMENT, '${stage}'}`,
+      environment: "${file(env.json)}",
+      iam: {
+        role: {
+          statements: [
+            {
+              Effect: "Allow",
+              Action: [
+                "sqs:SendMessage",
+                "sqs:ReceiveMessage",
+                "sqs:DeleteMessage",
+                "sqs:GetQueueAttributes"
+              ],
+              Resource: queueArns
+            },
+            {
+              Effect: "Allow",
+              Action: ["sqs:GetQueueUrl"],
+              // GetQueueUrl is not resource-scoped for unknown queue ARNs, must be '*'
+              Resource: "*"
+            }
+          ]
+        }
+      }
+    },
+    plugins: ["serverless-offline"],
+    functions,
+    resources
+  };
+}
+async function generateWorkersMap(stage, region, outputDir) {
+  const serverlessDir = path.join(outputDir, ".serverless");
+  if (!fs.existsSync(serverlessDir)) {
+    fs.mkdirSync(serverlessDir, { recursive: true });
+  }
+  const workers = await scanWorkers();
+  const stackName = `ai-router-workers-${stage}-${stage}`;
+  let queueUrls = {};
+  const spinner = ora("Fetching CloudFormation outputs...").start();
+  try {
+    const output = execSync(
+      `aws cloudformation describe-stacks --stack-name ${stackName} --region ${region} --query "Stacks[0].Outputs" --output json`,
+      { encoding: "utf-8", stdio: "pipe" }
+    );
+    const outputs = JSON.parse(output);
+    const outputMap = {};
+    for (const output2 of outputs) {
+      const key = output2.OutputKey;
+      if (key && key.endsWith("Url")) {
+        const workerId = key.replace("WorkerQueue", "").replace("Url", "").toLowerCase();
+        outputMap[key] = output2.OutputValue;
+      }
+    }
+    for (const worker of workers) {
+      const sanitizedId = worker.id.replace(/[^a-zA-Z0-9]/g, "");
+      const queueKey = `WorkerQueue${sanitizedId}${stage}Url`;
+      const matchingKey = Object.keys(outputMap).find((k) => k.toLowerCase() === queueKey.toLowerCase());
+      if (matchingKey && outputMap[matchingKey]) {
+        queueUrls[worker.id] = {
+          queueUrl: outputMap[matchingKey],
+          region
+        };
+      }
+    }
+    spinner.succeed("Fetched CloudFormation outputs");
+  } catch (error) {
+    spinner.warn("Could not fetch CloudFormation outputs. Using deterministic queue URLs.");
+    for (const worker of workers) {
+      queueUrls[worker.id] = {
+        queueUrl: `https://sqs.${"${aws:region}"}.amazonaws.com/${"${aws:accountId}"}/${"${self:service}"}-${worker.id}-${stage}`,
+        region
+      };
+    }
+  }
+  const mapContent = `/**
+ * Auto-generated workers map
+ * DO NOT EDIT - This file is generated by deploy-workers script
+ */
+
+export const workersMap = ${JSON.stringify(queueUrls, null, 2)} as const;
+`;
+  const mapFile = path.join(serverlessDir, "workers-map.generated.ts");
+  fs.writeFileSync(mapFile, mapContent);
+  console.log(chalk.green(`\u2713 Generated workers map: ${mapFile}`));
+}
+async function build2(args) {
+  const stage = args.stage || process.env.STAGE || "prod";
+  const region = args.region || process.env.AWS_REGION || "us-east-1";
+  const aiPath = args["ai-path"] || "app/ai";
+  console.log(chalk.blue(`\u{1F4E6} Building workers (stage: ${stage}, region: ${region})...`));
+  const spinner = ora("Scanning workers...").start();
+  const workers = await scanWorkers(aiPath);
+  if (workers.length === 0) {
+    spinner.warn("No workers found.");
+    return;
+  }
+  spinner.succeed(`Found ${workers.length} worker(s)`);
+  workers.forEach((w) => console.log(chalk.gray(`  - ${w.id} (${w.filePath})`)));
+  const serverlessDir = path.join(process.cwd(), ".serverless-workers");
+  if (!fs.existsSync(serverlessDir)) {
+    fs.mkdirSync(serverlessDir, { recursive: true });
+  }
+  const runtimeDeps = await collectRuntimeDependenciesForWorkers(
+    workers.map((w) => w.filePath),
+    process.cwd()
+  );
+  const dependencies = buildDependenciesMap(process.cwd(), runtimeDeps);
+  const packageJson = {
+    name: "ai-router-workers",
+    version: "1.0.0",
+    description: "Auto-generated serverless workers",
+    private: true,
+    dependencies,
+    scripts: {
+      build: "echo 'Already compiled.'"
+    },
+    devDependencies: {
+      serverless: "^3.38.0",
+      "serverless-offline": "^13.3.3",
+      "@aws-sdk/client-sqs": "^3.700.0"
+    }
+  };
+  fs.writeFileSync(
+    path.join(serverlessDir, "package.json"),
+    JSON.stringify(packageJson, null, 2)
+  );
+  const envVars = loadEnvVars();
+  const workerEntryFiles = workers.map((w) => w.filePath);
+  const { runtimeKeys: runtimeEnvKeys, buildtimeKeys: buildtimeEnvKeys } = await collectEnvUsageForWorkers(workerEntryFiles, process.cwd());
+  const referencedEnvKeys = /* @__PURE__ */ new Set([
+    ...Array.from(runtimeEnvKeys),
+    ...Array.from(buildtimeEnvKeys)
+  ]);
+  const runtimeList = Array.from(runtimeEnvKeys).sort();
+  const buildtimeList = Array.from(buildtimeEnvKeys).sort();
+  const missingFromDotEnv = Array.from(referencedEnvKeys).filter((k) => !(k in envVars)).sort();
+  if (runtimeList.length || buildtimeList.length) {
+    console.log(
+      chalk.blue(
+        `\u2139\uFE0F  Detected env usage from worker code: runtime=${runtimeList.length}, buildtime=${buildtimeList.length}`
+      )
+    );
+    if (missingFromDotEnv.length > 0) {
+      console.log(
+        chalk.yellow(
+          `\u26A0\uFE0F  These referenced envs were not found in .env (so they will NOT be written to env.json): ${missingFromDotEnv.slice(0, 25).join(", ")}${missingFromDotEnv.length > 25 ? " ..." : ""}`
+        )
+      );
+    }
+  }
+  let serviceName = args["service-name"]?.trim() || `ai-router-workers-${stage}`;
+  const microfoxJsonPath = path.join(process.cwd(), "microfox.json");
+  if (fs.existsSync(microfoxJsonPath)) {
+    try {
+      const microfoxConfig = JSON.parse(fs.readFileSync(microfoxJsonPath, "utf-8"));
+      if (microfoxConfig.projectId) {
+        if (!args["service-name"]?.trim()) {
+          serviceName = getServiceNameFromProjectId(microfoxConfig.projectId);
+        }
+        console.log(chalk.blue(`\u2139\uFE0F  Using service name from microfox.json: ${serviceName}`));
+      }
+    } catch (error) {
+      console.warn(chalk.yellow("\u26A0\uFE0F  Failed to parse microfox.json, using default service name"));
+    }
+  }
+  ora("Generating handlers...").start().succeed("Generated handlers");
+  await generateHandlers(workers, serverlessDir);
+  const extractSpinner = ora("Extracting worker configs from bundled handlers...").start();
+  for (const worker of workers) {
+    try {
+      const handlerFile = path.join(serverlessDir, worker.handlerPath + ".js");
+      if (fs.existsSync(handlerFile)) {
+        const handlerUrl = pathToFileURL(path.resolve(handlerFile)).href;
+        try {
+          const module = await import(handlerUrl);
+          if (module.exportedWorkerConfig) {
+            worker.workerConfig = module.exportedWorkerConfig;
+            if (module.exportedWorkerConfig.layers?.length) {
+              console.log(chalk.gray(`  \u2713 ${worker.id}: found ${module.exportedWorkerConfig.layers.length} layer(s)`));
+            }
+          } else {
+            console.warn(chalk.yellow(`  \u26A0 ${worker.id}: exportedWorkerConfig not found in handler`));
+          }
+        } catch (importError) {
+          console.log(chalk.gray(`  \u2139 ${worker.id}: extracting config from source (import failed: ${importError?.message?.slice(0, 50) || "runtime error"}...)`));
+          try {
+            const sourceContent = fs.readFileSync(worker.filePath, "utf-8");
+            const workerConfigMatch = sourceContent.match(/export\s+const\s+workerConfig[^=]*=\s*(\{[\s\S]*?\});/);
+            if (workerConfigMatch) {
+              let configStr = workerConfigMatch[1].replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|\s)\/\/[^\n]*/gm, "$1");
+              const configObj = new Function("return " + configStr)();
+              if (configObj && (configObj.layers || configObj.timeout || configObj.memorySize || configObj.schedule)) {
+                worker.workerConfig = configObj;
+                if (configObj.layers?.length) {
+                  console.log(chalk.gray(`  \u2713 ${worker.id}: found ${configObj.layers.length} layer(s) from source file`));
+                }
+                if (configObj.schedule) {
+                  console.log(chalk.gray(`  \u2713 ${worker.id}: found schedule configuration`));
+                }
+              }
+            }
+          } catch (fallbackError) {
+            console.warn(chalk.yellow(`  \u26A0 ${worker.id}: fallback extraction also failed, using defaults`));
+          }
+        }
+      } else {
+        console.warn(chalk.yellow(`  \u26A0 ${worker.id}: handler file not found: ${handlerFile}`));
+      }
+    } catch (error) {
+      console.warn(chalk.yellow(`  \u26A0 ${worker.id}: failed to extract config: ${error?.message || error}`));
+    }
+  }
+  extractSpinner.succeed("Extracted configs");
+  generateWorkersConfigHandler(serverlessDir, workers, serviceName);
+  generateDocsHandler(serverlessDir, serviceName, stage, region);
+  generateTriggerHandler(serverlessDir, serviceName);
+  const config = generateServerlessConfig(workers, stage, region, envVars, serviceName);
+  const envStage = fs.existsSync(microfoxJsonPath) ? "prod" : stage;
+  const safeEnvVars = {
+    ENVIRONMENT: envStage,
+    STAGE: envStage,
+    NODE_ENV: envStage
+  };
+  const allowedPrefixes = ["OPENAI_", "ANTHROPIC_", "DATABASE_", "MONGODB_", "REDIS_", "WORKERS_", "REMOTION_"];
+  for (const [key, value] of Object.entries(envVars)) {
+    if (key.startsWith("AWS_")) continue;
+    if (allowedPrefixes.some((prefix) => key.startsWith(prefix)) || referencedEnvKeys.has(key)) {
+      safeEnvVars[key] = value;
+    }
+  }
+  fs.writeFileSync(
+    path.join(serverlessDir, "env.json"),
+    JSON.stringify(safeEnvVars, null, 2)
+  );
+  const yamlContent = yaml.dump(config, { indent: 2 });
+  const yamlPath = path.join(serverlessDir, "serverless.yml");
+  fs.writeFileSync(yamlPath, yamlContent);
+  console.log(chalk.green(`\u2713 Generated serverless.yml: ${yamlPath}`));
+}
+async function deploy(args) {
+  const stage = args.stage || process.env.STAGE || "prod";
+  const region = args.region || process.env.AWS_REGION || "us-east-1";
+  const skipDeploy = args["skip-deploy"] || false;
+  const skipInstall = args["skip-install"] || false;
+  if (skipDeploy) {
+    console.log(chalk.yellow("\u23ED\uFE0F  Skipping deployment (--skip-deploy flag)"));
+    return;
+  }
+  const serverlessDir = path.join(process.cwd(), ".serverless-workers");
+  const yamlPath = path.join(serverlessDir, "serverless.yml");
+  if (!fs.existsSync(yamlPath)) {
+    console.error(chalk.red('\u274C serverless.yml not found. Run "build" first.'));
+    process.exit(1);
+  }
+  console.log(chalk.blue(`\u{1F680} Deploying to AWS (stage: ${stage}, region: ${region})...`));
+  validateEnvironment();
+  try {
+    if (!skipInstall && !fs.existsSync(path.join(serverlessDir, "node_modules"))) {
+      console.log(chalk.blue("\u{1F4E6} Installing serverless dependencies..."));
+      execSync("npm install", {
+        cwd: serverlessDir,
+        stdio: "inherit"
+      });
+    }
+    const microfoxJsonPath = path.join(process.cwd(), "microfox.json");
+    if (fs.existsSync(microfoxJsonPath)) {
+      console.log(chalk.blue("\u2139\uFE0F  Found microfox.json, deploying via Microfox Cloud..."));
+      fs.copyFileSync(microfoxJsonPath, path.join(serverlessDir, "microfox.json"));
+      const envVars = loadEnvVars();
+      execSync("npx microfox@latest push", {
+        cwd: serverlessDir,
+        stdio: "inherit"
+      });
+      console.log(chalk.green("\u2713 Deployment triggered via Microfox!"));
+      return;
+    }
+    execSync("npx serverless deploy", {
+      cwd: serverlessDir,
+      stdio: "inherit",
+      env: {
+        ...process.env,
+        STAGE: stage,
+        AWS_REGION: region
+      }
+    });
+    console.log(chalk.green("\u2713 Deployment complete!"));
+  } catch (error) {
+    console.error(chalk.red("\u274C Deployment failed"));
+    process.exit(1);
+  }
+  await generateWorkersMap(stage, region, serverlessDir);
+}
+var pushCommand = new Command().name("push").description("Build and deploy background workers to AWS").option("-s, --stage <stage>", "Deployment stage", "prod").option("-r, --region <region>", "AWS region", "us-east-1").option("--ai-path <path>", "Path to AI directory containing workers", "app/ai").option("--service-name <name>", "Override serverless service name (defaults to ai-router-workers-<stage>)").option("--skip-deploy", "Skip deployment, only build", false).option("--skip-install", "Skip npm install in serverless directory", false).action(async (options) => {
+  await build2(options);
+  await deploy(options);
+});
+
+// src/index.ts
+var program = new Command2();
+program.name("ai-worker").description("CLI tooling for deploying ai-router background workers").version("0.1.0");
+program.addCommand(pushCommand);
+program.parse(process.argv);
+var aiWorkerCli = program;
+export {
+  aiWorkerCli
+};
+//# sourceMappingURL=index.js.map