@microfox/ai-worker-cli 1.0.2 → 1.0.3

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command2 } from "commander";
+import { Command as Command3 } from "commander";
 
 // src/commands/push.ts
 import { Command } from "commander";
@@ -132,6 +132,50 @@ async function collectEnvUsageForWorkers(workerEntryFiles, projectRoot) {
   buildtimeKeys.delete("node");
   return { runtimeKeys, buildtimeKeys };
 }
+async function collectCalleeWorkerIds(workers, projectRoot) {
+  void projectRoot;
+  const calleeIdsByWorker = /* @__PURE__ */ new Map();
+  const workerIds = new Set(workers.map((w) => w.id));
+  for (const worker of workers) {
+    const calleeIds = /* @__PURE__ */ new Set();
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [worker.filePath];
+    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 re = /(?:ctx\.)?dispatchWorker\s*\(\s*['"]([^'"]+)['"]/g;
+      for (const match of src.matchAll(re)) {
+        if (match[1]) calleeIds.add(match[1]);
+      }
+      const specifiers = extractImportSpecifiers(src);
+      for (const spec of specifiers) {
+        if (!spec || !spec.startsWith(".")) continue;
+        const resolved = tryResolveLocalImport(normalized, spec);
+        if (resolved) queue.push(resolved);
+      }
+    }
+    if (calleeIds.size > 0) {
+      for (const calleeId of calleeIds) {
+        if (!workerIds.has(calleeId)) {
+          console.warn(
+            chalk.yellow(
+              `\u26A0\uFE0F  Worker "${worker.id}" calls "${calleeId}" which is not in scanned workers (typo or other service?). Queue URL will not be auto-injected.`
+            )
+          );
+        }
+      }
+      calleeIdsByWorker.set(worker.id, calleeIds);
+    }
+  }
+  return calleeIdsByWorker;
+}
+function sanitizeWorkerIdForEnv(workerId) {
+  return workerId.replace(/-/g, "_").toUpperCase();
+}
 function readJsonFile(filePath) {
   try {
     return JSON.parse(fs.readFileSync(filePath, "utf-8"));
@@ -184,6 +228,20 @@ async function collectRuntimeDependenciesForWorkers(workerEntryFiles, projectRoo
   deps.delete("@microfox/ai-worker");
   return deps;
 }
+function getJobStoreType() {
+  const raw = process.env.WORKER_DATABASE_TYPE?.toLowerCase();
+  if (raw === "mongodb" || raw === "upstash-redis") return raw;
+  return "upstash-redis";
+}
+function filterDepsForJobStore(runtimeDeps, jobStoreType) {
+  const filtered = new Set(runtimeDeps);
+  filtered.delete("mongodb");
+  filtered.delete("@upstash/redis");
+  if (jobStoreType === "mongodb") filtered.add("mongodb");
+  else filtered.add("@upstash/redis");
+  if (runtimeDeps.has("mongodb")) filtered.add("mongodb");
+  return filtered;
+}
 function buildDependenciesMap(projectRoot, deps) {
   const projectPkg = readJsonFile(path.join(projectRoot, "package.json")) || {};
   const projectDeps = projectPkg.dependencies || {};
@@ -253,8 +311,116 @@ async function scanWorkers(aiPath = "app/ai") {
   }
   return workers;
 }
-async function generateHandlers(workers, outputDir) {
+async function scanQueues(aiPath = "app/ai") {
+  const base = aiPath.replace(/\\/g, "/");
+  const pattern = `${base}/queues/**/*.queue.ts`;
+  const files = await glob(pattern);
+  const queues = [];
+  for (const filePath of files) {
+    try {
+      const content = fs.readFileSync(filePath, "utf-8");
+      const idMatch = content.match(/defineWorkerQueue\s*\(\s*\{[\s\S]*?id:\s*['"]([^'"]+)['"]/);
+      if (!idMatch) {
+        console.warn(chalk.yellow(`\u26A0\uFE0F  Skipping ${filePath}: No queue id found in defineWorkerQueue`));
+        continue;
+      }
+      const queueId = idMatch[1];
+      const steps = [];
+      const stepsMatch = content.match(/steps:\s*\[([\s\S]*?)\]/);
+      if (stepsMatch) {
+        const stepsStr = stepsMatch[1];
+        const stepRegex = /\{\s*workerId:\s*['"]([^'"]+)['"](?:,\s*delaySeconds:\s*(\d+))?(?:,\s*mapInputFromPrev:\s*['"]([^'"]+)['"])?\s*\}/g;
+        let m;
+        while ((m = stepRegex.exec(stepsStr)) !== null) {
+          steps.push({
+            workerId: m[1],
+            delaySeconds: m[2] ? parseInt(m[2], 10) : void 0,
+            mapInputFromPrev: m[3]
+          });
+        }
+      }
+      let schedule;
+      const scheduleStrMatch = content.match(/schedule:\s*['"]([^'"]+)['"]/);
+      const scheduleObjMatch = content.match(/schedule:\s*(\{[^}]+(?:\{[^}]*\}[^}]*)*\})/);
+      if (scheduleStrMatch) {
+        schedule = scheduleStrMatch[1];
+      } else if (scheduleObjMatch) {
+        try {
+          schedule = new Function("return " + scheduleObjMatch[1])();
+        } catch {
+          schedule = void 0;
+        }
+      }
+      queues.push({ id: queueId, filePath, steps, schedule });
+    } catch (error) {
+      console.error(chalk.red(`\u274C Error processing ${filePath}:`), error);
+    }
+  }
+  return queues;
+}
+function generateQueueRegistry(queues, outputDir, projectRoot) {
+  const generatedDir = path.join(outputDir, "generated");
+  if (!fs.existsSync(generatedDir)) {
+    fs.mkdirSync(generatedDir, { recursive: true });
+  }
+  const registryContent = `/**
+ * Auto-generated queue registry. DO NOT EDIT.
+ * Generated by @microfox/ai-worker-cli from .queue.ts files.
+ */
+
+const QUEUES = ${JSON.stringify(queues.map((q) => ({ id: q.id, steps: q.steps, schedule: q.schedule })), null, 2)};
+
+export function getQueueById(queueId) {
+  return QUEUES.find((q) => q.id === queueId);
+}
+
+export function getNextStep(queueId, stepIndex) {
+  const queue = getQueueById(queueId);
+  if (!queue || !queue.steps || stepIndex < 0 || stepIndex >= queue.steps.length - 1) {
+    return undefined;
+  }
+  const step = queue.steps[stepIndex + 1];
+  return step ? { workerId: step.workerId, delaySeconds: step.delaySeconds, mapInputFromPrev: step.mapInputFromPrev } : undefined;
+}
+
+export function invokeMapInput(_queueId, _stepIndex, prevOutput, _initialInput) {
+  return prevOutput;
+}
+`;
+  const registryPath = path.join(generatedDir, "workerQueues.registry.js");
+  fs.writeFileSync(registryPath, registryContent);
+  console.log(chalk.green(`\u2713 Generated queue registry: ${registryPath}`));
+}
+function getWorkersInQueues(queues) {
+  const set = /* @__PURE__ */ new Set();
+  for (const q of queues) {
+    for (const step of q.steps) {
+      set.add(step.workerId);
+    }
+  }
+  return set;
+}
+function mergeQueueCallees(calleeIds, queues, workers) {
+  const merged = new Map(calleeIds);
+  const workerIds = new Set(workers.map((w) => w.id));
+  for (const queue of queues) {
+    for (let i = 0; i < queue.steps.length - 1; i++) {
+      const fromWorkerId = queue.steps[i].workerId;
+      const toWorkerId = queue.steps[i + 1].workerId;
+      if (!workerIds.has(toWorkerId)) continue;
+      let callees = merged.get(fromWorkerId);
+      if (!callees) {
+        callees = /* @__PURE__ */ new Set();
+        merged.set(fromWorkerId, callees);
+      }
+      callees.add(toWorkerId);
+    }
+  }
+  return merged;
+}
+async function generateHandlers(workers, outputDir, queues = []) {
   const handlersDir = path.join(outputDir, "handlers");
+  const workersInQueues = getWorkersInQueues(queues);
   if (fs.existsSync(handlersDir)) {
     fs.rmSync(handlersDir, { recursive: true, force: true });
   }
@@ -279,18 +445,76 @@ async function generateHandlers(workers, outputDir) {
     const exportName = exportMatch ? exportMatch[2] : "worker";
     const tempEntryFile = handlerFile.replace(".js", ".temp.ts");
     const workerRef = defaultExport ? "workerModule.default" : `workerModule.${exportName}`;
-    const tempEntryContent = `
+    const inQueue = workersInQueues.has(worker.id);
+    const registryRelPath = path.relative(path.dirname(path.resolve(handlerFile)), path.join(outputDir, "generated", "workerQueues.registry")).split(path.sep).join("/");
+    const registryImportPath = registryRelPath.startsWith(".") ? registryRelPath : "./" + registryRelPath;
+    const handlerCreation = inQueue ? `
+import { createLambdaHandler, wrapHandlerForQueue } from '@microfox/ai-worker/handler';
+import * as queueRegistry from '${registryImportPath}';
+import * as workerModule from '${relativeImportPath}';
+
+const WORKER_LOG_PREFIX = '[WorkerEntrypoint]';
+
+const workerAgent = ${workerRef};
+if (!workerAgent || typeof workerAgent.handler !== 'function') {
+  throw new Error('Worker module must export a createWorker result (default or named) with .handler');
+}
+
+const queueRuntime = {
+  getNextStep: queueRegistry.getNextStep,
+  invokeMapInput: queueRegistry.invokeMapInput,
+};
+const wrappedHandler = wrapHandlerForQueue(workerAgent.handler, queueRuntime);
+
+const baseHandler = createLambdaHandler(wrappedHandler, workerAgent.outputSchema);
+
+export const handler = async (event: any, context: any) => {
+  const records = Array.isArray((event as any)?.Records) ? (event as any).Records.length : 0;
+  try {
+    console.log(WORKER_LOG_PREFIX, {
+      workerId: workerAgent.id,
+      inQueue: true,
+      records,
+      requestId: (context as any)?.awsRequestId,
+    });
+  } catch {
+    // Best-effort logging only
+  }
+  return baseHandler(event, context);
+};
+
+export const exportedWorkerConfig = workerModule.workerConfig || workerAgent?.workerConfig;
+` : `
 import { createLambdaHandler } from '@microfox/ai-worker/handler';
 import * as workerModule from '${relativeImportPath}';
 
+const WORKER_LOG_PREFIX = '[WorkerEntrypoint]';
+
 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);
+const baseHandler = createLambdaHandler(workerAgent.handler, workerAgent.outputSchema);
+
+export const handler = async (event: any, context: any) => {
+  const records = Array.isArray((event as any)?.Records) ? (event as any).Records.length : 0;
+  try {
+    console.log(WORKER_LOG_PREFIX, {
+      workerId: workerAgent.id,
+      inQueue: false,
+      records,
+      requestId: (context as any)?.awsRequestId,
+    });
+  } catch {
+    // Best-effort logging only
+  }
+  return baseHandler(event, context);
+};
+
 export const exportedWorkerConfig = workerModule.workerConfig || workerAgent?.workerConfig;
 `;
+    const tempEntryContent = handlerCreation;
     fs.writeFileSync(tempEntryFile, tempEntryContent);
     try {
       const fixLazyCachePlugin = {
@@ -702,7 +926,76 @@ export const handler = async (event: APIGatewayProxyEvent): Promise<APIGatewayPr
   fs.unlinkSync(tempEntryFile);
   console.log(chalk.green(`\u2713 Generated /workers/trigger handler`));
 }
-function generateWorkersConfigHandler(outputDir, workers, serviceName) {
+function generateQueueStarterHandler(outputDir, queue, serviceName) {
+  const safeId = queue.id.replace(/[^a-zA-Z0-9]/g, "");
+  const handlerFile = path.join(outputDir, "handlers", `queue-starter-${safeId}.js`);
+  const tempEntryFile = handlerFile.replace(".js", ".temp.ts");
+  const handlerDir = path.dirname(handlerFile);
+  if (!fs.existsSync(handlerDir)) {
+    fs.mkdirSync(handlerDir, { recursive: true });
+  }
+  const firstWorkerId = queue.steps[0]?.workerId;
+  if (!firstWorkerId) return;
+  const handlerContent = `/**
+ * Auto-generated queue-starter for queue "${queue.id}"
+ * DO NOT EDIT - This file is generated by @microfox/ai-worker-cli
+ */
+
+import { ScheduledHandler } from 'aws-lambda';
+import { SQSClient, GetQueueUrlCommand, SendMessageCommand } from '@aws-sdk/client-sqs';
+
+const QUEUE_ID = ${JSON.stringify(queue.id)};
+const FIRST_WORKER_ID = ${JSON.stringify(firstWorkerId)};
+const SERVICE_NAME = ${JSON.stringify(serviceName)};
+
+export const handler: ScheduledHandler = async () => {
+  const stage = process.env.ENVIRONMENT || process.env.STAGE || 'prod';
+  const region = process.env.AWS_REGION || 'us-east-1';
+  const queueName = \`\${SERVICE_NAME}-\${FIRST_WORKER_ID}-\${stage}\`;
+
+  const sqs = new SQSClient({ region });
+  const { QueueUrl } = await sqs.send(new GetQueueUrlCommand({ QueueName: queueName }));
+  if (!QueueUrl) {
+    throw new Error('Queue URL not found: ' + queueName);
+  }
+
+  const jobId = 'job-' + Date.now() + '-' + Math.random().toString(36).slice(2, 11);
+  const initialInput = {};
+  const messageBody = {
+    workerId: FIRST_WORKER_ID,
+    jobId,
+    input: {
+      ...initialInput,
+      __workerQueue: { id: QUEUE_ID, stepIndex: 0, initialInput },
+    },
+    context: {},
+    metadata: { __workerQueue: { id: QUEUE_ID, stepIndex: 0, initialInput } },
+    timestamp: new Date().toISOString(),
+  };
+
+  await sqs.send(new SendMessageCommand({
+    QueueUrl,
+    MessageBody: JSON.stringify(messageBody),
+  }));
+
+  console.log('[queue-starter] Dispatched first worker for queue:', { queueId: QUEUE_ID, jobId, workerId: FIRST_WORKER_ID });
+};
+`;
+  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"],
+    packages: "bundle",
+    logLevel: "error"
+  });
+  fs.unlinkSync(tempEntryFile);
+  console.log(chalk.green(`\u2713 Generated queue-starter for ${queue.id}`));
+}
+function generateWorkersConfigHandler(outputDir, workers, serviceName, queues = []) {
   const handlerFile = path.join(outputDir, "handlers", "workers-config.js");
   const tempEntryFile = handlerFile.replace(".js", ".temp.ts");
   const handlerDir = path.dirname(handlerFile);
@@ -718,8 +1011,9 @@ function generateWorkersConfigHandler(outputDir, workers, serviceName) {
 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.
+// Worker IDs and queue definitions embedded at build time.
 const WORKER_IDS: string[] = ${JSON.stringify(workers.map((w) => w.id), null, 2)};
+const QUEUES = ${JSON.stringify(queues.map((q) => ({ id: q.id, steps: q.steps, schedule: q.schedule })), null, 2)};
 const SERVICE_NAME = ${JSON.stringify(serviceName)};
 
 export const handler = async (
@@ -790,6 +1084,7 @@ export const handler = async (
       stage,
       region,
       workers,
+      queues: QUEUES,
       ...(debug ? { attemptedQueueNames, errors } : {}),
     }),
   };
@@ -899,7 +1194,7 @@ function processScheduleEvents(scheduleConfig) {
   }
   return events;
 }
-function generateServerlessConfig(workers, stage, region, envVars, serviceName) {
+function generateServerlessConfig(workers, stage, region, envVars, serviceName, calleeIds = /* @__PURE__ */ new Map(), queues = []) {
   const resources = {
     Resources: {},
     Outputs: {}
@@ -988,6 +1283,21 @@ function generateServerlessConfig(workers, stage, region, envVars, serviceName)
     if (worker.workerConfig?.layers?.length) {
       functions[functionName].layers = worker.workerConfig.layers;
     }
+    const callees = calleeIds.get(worker.id);
+    if (callees && callees.size > 0) {
+      const env = {};
+      for (const calleeId of callees) {
+        const calleeWorker = workers.find((w) => w.id === calleeId);
+        if (calleeWorker) {
+          const queueLogicalId = `WorkerQueue${calleeWorker.id.replace(/[^a-zA-Z0-9]/g, "")}${stage}`;
+          const envKey = `WORKER_QUEUE_URL_${sanitizeWorkerIdForEnv(calleeId)}`;
+          env[envKey] = { Ref: queueLogicalId };
+        }
+      }
+      if (Object.keys(env).length > 0) {
+        functions[functionName].environment = env;
+      }
+    }
   }
   functions["getDocs"] = {
     handler: "handlers/docs.handler",
@@ -1025,8 +1335,21 @@ function generateServerlessConfig(workers, stage, region, envVars, serviceName)
       }
     ]
   };
+  for (const queue of queues) {
+    if (queue.schedule) {
+      const safeId = queue.id.replace(/[^a-zA-Z0-9]/g, "");
+      const fnName = `queueStarter${safeId}`;
+      const scheduleEvents = processScheduleEvents(queue.schedule);
+      functions[fnName] = {
+        handler: `handlers/queue-starter-${safeId}.handler`,
+        timeout: 60,
+        memorySize: 128,
+        events: scheduleEvents
+      };
+    }
+  }
   const safeEnvVars = {};
-  const allowedPrefixes = ["OPENAI_", "ANTHROPIC_", "DATABASE_", "MONGODB_", "REDIS_", "WORKERS_", "REMOTION_"];
+  const allowedPrefixes = ["OPENAI_", "ANTHROPIC_", "DATABASE_", "MONGODB_", "REDIS_", "UPSTASH_", "WORKER_", "WORKERS_", "WORKFLOW_", "REMOTION_", "QUEUE_JOB_", "DEBUG_WORKER_QUEUES"];
   for (const [key, value] of Object.entries(envVars)) {
     if (allowedPrefixes.some((prefix) => key.startsWith(prefix))) {
       safeEnvVars[key] = value;
@@ -1179,7 +1502,9 @@ async function build2(args) {
     workers.map((w) => w.filePath),
     process.cwd()
   );
-  const dependencies = buildDependenciesMap(process.cwd(), runtimeDeps);
+  const jobStoreType = getJobStoreType();
+  const filteredDeps = filterDepsForJobStore(runtimeDeps, jobStoreType);
+  const dependencies = buildDependenciesMap(process.cwd(), filteredDeps);
   const packageJson = {
     name: "ai-router-workers",
     version: "1.0.0",
@@ -1238,8 +1563,13 @@ async function build2(args) {
       console.warn(chalk.yellow("\u26A0\uFE0F  Failed to parse microfox.json, using default service name"));
     }
   }
+  const queues = await scanQueues(aiPath);
+  if (queues.length > 0) {
+    console.log(chalk.blue(`\u2139\uFE0F  Found ${queues.length} queue(s): ${queues.map((q) => q.id).join(", ")}`));
+    generateQueueRegistry(queues, serverlessDir, process.cwd());
+  }
   ora("Generating handlers...").start().succeed("Generated handlers");
-  await generateHandlers(workers, serverlessDir);
+  await generateHandlers(workers, serverlessDir, queues);
   const extractSpinner = ora("Extracting worker configs from bundled handlers...").start();
   for (const worker of workers) {
     try {
@@ -1286,17 +1616,24 @@ async function build2(args) {
     }
   }
   extractSpinner.succeed("Extracted configs");
-  generateWorkersConfigHandler(serverlessDir, workers, serviceName);
+  generateWorkersConfigHandler(serverlessDir, workers, serviceName, queues);
   generateDocsHandler(serverlessDir, serviceName, stage, region);
   generateTriggerHandler(serverlessDir, serviceName);
-  const config = generateServerlessConfig(workers, stage, region, envVars, serviceName);
+  for (const queue of queues) {
+    if (queue.schedule) {
+      generateQueueStarterHandler(serverlessDir, queue, serviceName);
+    }
+  }
+  let calleeIds = await collectCalleeWorkerIds(workers, process.cwd());
+  calleeIds = mergeQueueCallees(calleeIds, queues, workers);
+  const config = generateServerlessConfig(workers, stage, region, envVars, serviceName, calleeIds, queues);
   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_"];
+  const allowedPrefixes = ["OPENAI_", "ANTHROPIC_", "DATABASE_", "MONGODB_", "REDIS_", "UPSTASH_", "WORKER_", "WORKERS_", "WORKFLOW_", "REMOTION_", "QUEUE_JOB_", "DEBUG_WORKER_QUEUES"];
   for (const [key, value] of Object.entries(envVars)) {
     if (key.startsWith("AWS_")) continue;
     if (allowedPrefixes.some((prefix) => key.startsWith(prefix)) || referencedEnvKeys.has(key)) {
@@ -1370,10 +1707,86 @@ var pushCommand = new Command().name("push").description("Build and deploy backg
   await deploy(options);
 });
 
+// src/commands/new.ts
+import { Command as Command2 } from "commander";
+import * as fs2 from "fs";
+import * as path2 from "path";
+import chalk2 from "chalk";
+import ora2 from "ora";
+var newCommand = new Command2().name("new").description("Scaffold a new background worker file").argument("<id>", "Worker ID (used as the worker id and filename)").option("--dir <path>", "Directory for the worker file", "app/ai/workers").option("--schedule <expression>", 'Optional schedule expression (e.g. "cron(0 3 * * ? *)" or "rate(1 hour)")').option("--timeout <seconds>", "Lambda timeout in seconds", "300").option("--memory <mb>", "Lambda memory size in MB", "512").action((id, options) => {
+  const spinner = ora2("Scaffolding worker...").start();
+  try {
+    const projectRoot = process.cwd();
+    const dir = path2.resolve(projectRoot, options.dir || "app/ai/workers");
+    if (!fs2.existsSync(dir)) {
+      fs2.mkdirSync(dir, { recursive: true });
+    }
+    const fileSafeId = id.trim().replace(/[^a-zA-Z0-9_-]+/g, "-");
+    const filePath = path2.join(dir, `${fileSafeId}.worker.ts`);
+    if (fs2.existsSync(filePath)) {
+      spinner.fail(`File already exists: ${path2.relative(projectRoot, filePath)}`);
+      process.exitCode = 1;
+      return;
+    }
+    const timeout = Number(options.timeout || "300") || 300;
+    const memorySize = Number(options.memory || "512") || 512;
+    const scheduleLine = options.schedule ? `  schedule: '${options.schedule}',
+` : "";
+    const contents = `import { createWorker, type WorkerConfig } from '@microfox/ai-worker';
+import { z } from 'zod';
+import type { WorkerHandlerParams } from '@microfox/ai-worker/handler';
+
+const InputSchema = z.object({
+  // TODO: define input fields
+});
+
+const OutputSchema = z.object({
+  // TODO: define output fields
+});
+
+type Input = z.infer<typeof InputSchema>;
+type Output = z.infer<typeof OutputSchema>;
+
+export const workerConfig: WorkerConfig = {
+  timeout: ${timeout},
+  memorySize: ${memorySize},
+${scheduleLine}};
+
+export default createWorker<typeof InputSchema, Output>({
+  id: '${id}',
+  inputSchema: InputSchema,
+  outputSchema: OutputSchema,
+  async handler({ input, ctx }: WorkerHandlerParams<Input, Output>) {
+    const { jobId, workerId, jobStore, dispatchWorker } = ctx;
+    console.log('[${id}] start', { jobId, workerId });
+
+    await jobStore?.update({ status: 'running' });
+
+    // TODO: implement your business logic here
+    const result: Output = {} as any;
+
+    await jobStore?.update({ status: 'completed', output: result });
+    return result;
+  },
+});
+`;
+    fs2.writeFileSync(filePath, contents, "utf-8");
+    spinner.succeed(
+      `Created worker: ${chalk2.cyan(path2.relative(projectRoot, filePath))}
+Next: run ${chalk2.yellow("npx @microfox/ai-worker-cli@latest push")} to build & deploy your workers.`
+    );
+  } catch (error) {
+    spinner.fail("Failed to scaffold worker");
+    console.error(chalk2.red(error?.stack || error?.message || String(error)));
+    process.exitCode = 1;
+  }
+});
+
 // src/index.ts
-var program = new Command2();
-program.name("ai-worker").description("CLI tooling for deploying ai-router background workers").version("0.1.0");
+var program = new Command3();
+program.name("ai-worker").description("CLI tooling for deploying ai-router background workers").version("1.0.0");
 program.addCommand(pushCommand);
+program.addCommand(newCommand);
 program.parse(process.argv);
 var aiWorkerCli = program;
 export {