create-svc 0.1.62 → 0.1.63

package/src/service-runtime/workers/cli.ts

@@ -15,6 +15,12 @@ const config = {
   hostname: serviceConfig.dns.hostname,
   neonDatabaseName: serviceConfig.neon.database_name,
   neonRoleName: serviceConfig.neon.role_name,
+  triggerDev: {
+    projectRefEnv: serviceConfig.workers?.trigger_dev?.project_ref_env || "TRIGGER_PROJECT_REF",
+    accessTokenEnv: serviceConfig.workers?.trigger_dev?.access_token_env || "TRIGGER_ACCESS_TOKEN",
+    secretKeyEnv: serviceConfig.workers?.trigger_dev?.secret_key_env || "TRIGGER_SECRET_KEY",
+    waitlistTaskId: serviceConfig.workers?.trigger_dev?.waitlist_task_id || `${serviceConfig.service_id}-waitlist-follow-up`,
+  },
   git: {
     enabled: Boolean(serviceConfig.git?.enabled),
     owner: serviceConfig.git?.owner || "anmho",
@@ -35,18 +41,28 @@ export async function main(argv = Bun.argv.slice(2)) {
 
   if (command === "create") {
     return runMain("Create", async () => {
+      ensureTriggerDevConfig();
       ensureAuthResourceServer();
       ensureAuthClient();
       const databaseUrl = await resolveDatabaseUrl({ preferRemote: true });
       await applySchemaWithRetries(databaseUrl);
       await ensureHyperdrive(databaseUrl);
+      deployTriggerDevTasks();
+      publishTriggerDevSecret();
       run("wrangler", ["deploy"]);
       return `Created https://${config.hostname}`;
     });
   }
 
   if (command === "deploy") {
+    if (hasHelpFlag(rest)) {
+      console.log(formatHelp());
+      return;
+    }
     return runMain("Deploy", () => {
+      ensureTriggerDevConfig();
+      deployTriggerDevTasks();
+      publishTriggerDevSecret();
       run("wrangler", ["deploy", ...rest]);
       return `Deployed https://${config.hostname}`;
     });
@@ -148,6 +164,10 @@ export async function main(argv = Bun.argv.slice(2)) {
   throw new Error(`Unknown command: ${command}\n\n${formatHelp()}`);
 }
 
+function hasHelpFlag(args: string[]) {
+  return args.includes("--help") || args.includes("-h") || args.includes("help");
+}
+
 function formatHelp() {
   return [
     "Usage:",
@@ -507,6 +527,11 @@ async function runDoctor() {
     return "dashboard directory found";
   });
   await record(results, "authctl", "warn", () => runAuthDoctor().detail);
+  await record(results, "Trigger.dev config", "fail", () => {
+    ensureTriggerDevConfig();
+    return `${config.triggerDev.waitlistTaskId} configured`;
+  });
+  await record(results, "Trigger.dev CLI", "warn", () => checkCommand("trigger"));
   await record(results, "deployed health", "warn", async () => {
     const response = await fetch(`https://${config.hostname}/healthz`, { signal: AbortSignal.timeout(5_000) });
     if (!response.ok) {
@@ -523,6 +548,69 @@ async function runDoctor() {
   return output;
 }
 
+function ensureTriggerDevConfig() {
+  const missing = [];
+  if (!process.env[config.triggerDev.projectRefEnv]?.trim()) {
+    missing.push(config.triggerDev.projectRefEnv);
+  }
+  if (!process.env[config.triggerDev.accessTokenEnv]?.trim()) {
+    missing.push(config.triggerDev.accessTokenEnv);
+  }
+  if (!process.env[config.triggerDev.secretKeyEnv]?.trim()) {
+    missing.push(config.triggerDev.secretKeyEnv);
+  }
+  if (missing.length > 0) {
+    throw new Error(`${formatList(missing)} required for Workers Trigger.dev task deployment and dispatch`);
+  }
+}
+
+function formatList(values: string[]) {
+  if (values.length <= 1) {
+    return values[0] ?? "";
+  }
+  if (values.length === 2) {
+    return values.join(" and ");
+  }
+  return `${values.slice(0, -1).join(", ")}, and ${values.at(-1)}`;
+}
+
+function deployTriggerDevTasks() {
+  run("trigger", ["deploy", "--project-ref", process.env[config.triggerDev.projectRefEnv]?.trim() || ""]);
+}
+
+function publishTriggerDevSecret() {
+  const secret = process.env[config.triggerDev.secretKeyEnv]?.trim();
+  if (!secret) {
+    throw new Error(`${config.triggerDev.secretKeyEnv} required to publish the Workers Trigger.dev secret`);
+  }
+  const wrangler = resolveCommandPath("wrangler");
+  if (!wrangler) {
+    throw new Error("missing required command: wrangler");
+  }
+  runShell(`printf %s "$${config.triggerDev.secretKeyEnv}" | ${shellQuote(wrangler)} secret put TRIGGER_SECRET_KEY --name ${shellQuote(config.serviceName)}`);
+}
+
+function runShell(script: string) {
+  const shell = Bun.which("sh");
+  if (!shell) {
+    throw new Error("missing required command: sh");
+  }
+  const result = Bun.spawnSync([shell, "-c", script], {
+    cwd: process.cwd(),
+    env: process.env,
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit",
+  });
+  if (!result.success) {
+    throw new Error(`shell command failed with exit code ${result.exitCode}: ${script}`);
+  }
+}
+
+function shellQuote(value: string) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
 async function record(
   results: Array<{ name: string; status: DoctorStatus; detail: string }>,
   name: string,

package/src/service.test.ts

@@ -2,7 +2,13 @@ import { expect, test } from "bun:test";
 import { mkdtemp, mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { findGeneratedServiceRoot, formatOutsideServiceCommandError, generatedDependenciesInstalled, normalizeScaffoldArgs } from "./service";
+import {
+  findGeneratedServiceRoot,
+  formatOutsideServiceCommandError,
+  generatedDependenciesInstalled,
+  generatedServiceCommandHelp,
+  normalizeScaffoldArgs,
+} from "./service";
 
 test("normalizeScaffoldArgs treats explicit scaffold commands as generator commands", () => {
   expect(normalizeScaffoldArgs(["create", "launch-api", "--yes"])).toEqual(["launch-api", "--yes"]);
@@ -23,7 +29,7 @@ test("formatOutsideServiceCommandError rejects repo-local commands outside gener
 test("formatOutsideServiceCommandError does not treat positional names as scaffold commands", () => {
   const message = formatOutsideServiceCommandError("launch-api");
   expect(message).toContain("Unknown command: launch-api");
-  expect(message).toContain("service create <service_id>");
+  expect(message).toContain("service new <service_id>");
 });
 
 test("findGeneratedServiceRoot detects generated service context from nested directories", async () => {
@@ -47,3 +53,10 @@ test("generatedDependenciesInstalled requires node_modules when package.json exi
   await mkdir(join(root, "node_modules"));
   expect(generatedDependenciesInstalled(root)).toBeTrue();
 });
+
+test("generatedServiceCommandHelp intercepts deploy help before side effects", () => {
+  expect(generatedServiceCommandHelp(["deploy", "--help"])).toContain("service deploy");
+  expect(generatedServiceCommandHelp(["deploy", "-h"])).toContain("--environment");
+  expect(generatedServiceCommandHelp(["deploy"])).toBeUndefined();
+  expect(generatedServiceCommandHelp(["destroy", "--help"])).toBeUndefined();
+});

package/src/service.ts

@@ -58,7 +58,7 @@ export function formatOutsideServiceCommandError(command: string) {
       "",
       "No service.jsonc was found in this directory or its parents.",
       "To create a new service, run:",
-      "  service create <service_id>",
+      "  service new <service_id>",
     ].join("\n");
   }
 
@@ -85,6 +85,12 @@ function isGeneratedServiceRoot(path: string) {
 }
 
 async function delegateToGeneratedService(serviceRoot: string, argv: string[]) {
+  const commandHelp = generatedServiceCommandHelp(argv);
+  if (commandHelp) {
+    console.log(commandHelp);
+    return;
+  }
+
   ensureGeneratedDependencies(serviceRoot);
   process.chdir(serviceRoot);
   process.env.CREATE_SVC_SERVICE_ROOT = serviceRoot;
@@ -123,3 +129,27 @@ function ensureGeneratedDependencies(serviceRoot: string) {
     process.exit(result.exitCode || 1);
   }
 }
+
+export function generatedServiceCommandHelp(argv: string[]) {
+  const [command, ...rest] = argv;
+  if (command !== "deploy" || !hasHelpFlag(rest)) {
+    return undefined;
+  }
+
+  return [
+    "Usage:",
+    "  service deploy [--ci] [--environment main|preview|personal] [--name <name>]",
+    "",
+    "Options:",
+    "  --ci                         Run without interactive prompts",
+    "  --environment <environment>  Deploy main, preview, or personal",
+    "  --name <name>                Name preview or personal environment",
+    "  --build <local|cloudbuild>   Select image build strategy",
+    "  --cloud-build                Use Cloud Build",
+    "  --destroy                    Destroy a non-main deployment environment",
+  ].join("\n");
+}
+
+function hasHelpFlag(args: string[]) {
+  return args.includes("--help") || args.includes("-h") || args.includes("help");
+}

package/templates/shared/.env.example

@@ -3,7 +3,7 @@
 
 DATABASE_URL=postgres://{{LOCAL_DATABASE_USER}}:{{LOCAL_DATABASE_PASSWORD}}@127.0.0.1:{{LOCAL_DATABASE_PORT}}/{{LOCAL_DATABASE_NAME}}?sslmode=disable
 
-TEMPORAL_ENABLED=false
+TEMPORAL_ENABLED=true
 TEMPORAL_ADDRESS=localhost:7233
 TEMPORAL_NAMESPACE=default
 TEMPORAL_TASK_QUEUE={{SERVICE_ID}}

package/templates/shared/README.md

@@ -55,10 +55,49 @@ Local runtime uses:
 
 - `DATABASE_URL` from `.env.local`, pointed at Docker Compose Postgres
 - `{{COMMAND_MIGRATE}}` and `{{COMMAND_DEV}}`, which open Docker Desktop if needed, wait for Docker readiness, and start Docker Compose Postgres
-- `TEMPORAL_ENABLED=false` by default; set Temporal env vars locally only when you want to run against a real Temporal server
+- `TEMPORAL_ENABLED=true` by default with `localhost:7233` and `default`; set `TEMPORAL_ENABLED=false` when you are not running a local Temporal server
 
 No cloud credentials are required for local HTTP development after Docker and Postgres are running.
 
+## Temporal
+
+Temporal is enabled by default for generated services.
+
+Local development uses these generated defaults:
+
+- `TEMPORAL_ENABLED=true`
+- `TEMPORAL_ADDRESS=localhost:7233`
+- `TEMPORAL_NAMESPACE=default`
+- `TEMPORAL_TASK_QUEUE={{TEMPORAL_TASK_QUEUE}}`
+
+The generated app deploys a Cloud Run API service and, when Temporal is enabled,
+a separate Cloud Run worker service named `{{SERVICE_ID}}-worker`.
+When `POST /v1/triggers/waitlist` or the ConnectRPC `RecordTrigger` method
+creates a trigger, the API service starts `waitlistFollowUpWorkflow` /
+`WaitlistFollowUpWorkflow` asynchronously on the service task queue. The API
+request only waits for the trigger record; workflow completion happens through
+Temporal and is polled by the worker service.
+Local `{{COMMAND_DEV}}` starts the API process and the worker process together.
+
+Production and preview deploys render `TEMPORAL_ENABLED=true` into the Cloud Run
+manifest unless you override it. For Temporal Cloud, replace the local defaults
+with real connection settings before the worker can run:
+
+- `TEMPORAL_ADDRESS`
+- `TEMPORAL_NAMESPACE`
+- any TLS certificate/key or API-key settings used by your worker code
+
+If a service does not need Temporal, opt out with:
+
+```bash
+TEMPORAL_ENABLED=false {{COMMAND_DEV}}
+TEMPORAL_ENABLED=false {{COMMAND_DEPLOY}}
+```
+
+When Cloud Run starts with Temporal enabled but without address or namespace
+values, the generated runtime fails during startup with an explicit
+configuration error instead of silently running a broken worker.
+
 ## Remote provisioning
 
 The generated service config lives in [service.jsonc](service.jsonc).
@@ -158,14 +197,7 @@ Optional remote-only Vault overrides for Neon admin key lookup:
 
 The generator only stores application-facing connection material in Secret Manager. Neon admin credentials stay local to create and deploy.
 
-## Temporal
-
-Cloud Run variants include an in-process Temporal worker in the service process.
-Production Temporal is enabled when you set `TEMPORAL_ENABLED=true`, or when
-`TEMPORAL_ADDRESS`, `TEMPORAL_API_KEY`, or `TEMPORAL_API_KEY_SECRET` is present
-during deploy rendering.
-
-For Temporal Cloud, provide:
+For production Temporal Cloud, provide:
 
 ```bash
 TEMPORAL_ENABLED=true

package/templates/shared/scripts/dev.ts

@@ -1,10 +1,10 @@
 import { readLocalEnv } from "./local-env";
 import { ensureLocalPostgres } from "./local-docker";
 
-const command = Bun.argv.slice(2);
+const { apiCommand, workerCommand } = parseCommands(Bun.argv.slice(2));
 
-if (command.length === 0) {
-  throw new Error("Usage: bun run ./scripts/dev.ts <command...>");
+if (apiCommand.length === 0) {
+  throw new Error("Usage: bun run ./scripts/dev.ts <api-command...> [--worker <worker-command...>]");
 }
 
 await ensureLocalPostgres();
@@ -17,11 +17,43 @@ if (env.DATABASE_URL && !env.CLOUDFLARE_HYPERDRIVE_LOCAL_CONNECTION_STRING_HYPER
   env.CLOUDFLARE_HYPERDRIVE_LOCAL_CONNECTION_STRING_HYPERDRIVE = env.DATABASE_URL;
 }
 
-const child = Bun.spawn(command, {
+const api = Bun.spawn(apiCommand, {
   stdin: "inherit",
   stdout: "inherit",
   stderr: "inherit",
   env,
 });
 
-process.exit(await child.exited);
+const worker = workerCommand
+  ? Bun.spawn(workerCommand, {
+      stdin: "ignore",
+      stdout: "inherit",
+      stderr: "inherit",
+      env: {
+        ...env,
+        PORT: env.TEMPORAL_WORKER_PORT || "0",
+      },
+    })
+  : undefined;
+
+for (const signal of ["SIGINT", "SIGTERM"] as const) {
+  process.on(signal, () => {
+    api.kill(signal);
+    worker?.kill(signal);
+  });
+}
+
+const exitCode = await Promise.race([api.exited, worker?.exited ?? new Promise<never>(() => {})]);
+api.kill();
+worker?.kill();
+process.exit(exitCode);
+
+function parseCommands(argv: string[]) {
+  const separator = argv.indexOf("--worker");
+  if (separator === -1) {
+    return { apiCommand: argv, workerCommand: undefined };
+  }
+  const apiCommand = argv.slice(0, separator);
+  const workerCommand = argv.slice(separator + 1);
+  return { apiCommand, workerCommand: workerCommand.length > 0 ? workerCommand : undefined };
+}

package/templates/shared/service.jsonc

@@ -53,7 +53,7 @@
   },
 
   "temporal": {
-    "enabled": false,
+    "enabled": true,
     "address": "localhost:7233",
     "namespace": "default",
     "task_queue": "{{SERVICE_ID}}",
@@ -117,6 +117,12 @@
   "workers": {
     "script_name": "{{SERVICE_ID}}",
     "hyperdrive_binding": "HYPERDRIVE",
-    "cron": "*/15 * * * *"
+    "trigger_dev": {
+      "project_ref_env": "TRIGGER_PROJECT_REF",
+      "access_token_env": "TRIGGER_ACCESS_TOKEN",
+      "secret_key_env": "TRIGGER_SECRET_KEY",
+      "api_url": "https://api.trigger.dev",
+      "waitlist_task_id": "{{SERVICE_ID}}-waitlist-follow-up"
+    }
   }
 }

package/templates/shared/service.yaml

@@ -5,18 +5,21 @@ metadata:
   labels:
     managed_by: create-service
     service_id: ${SERVICE_ID}
+    service_role: ${SERVICE_ROLE}
   annotations:
-    run.googleapis.com/ingress: all
+    run.googleapis.com/ingress: ${SERVICE_INGRESS}
 spec:
   template:
     metadata:
       labels:
         managed_by: create-service
         service_id: ${SERVICE_ID}
+        service_role: ${SERVICE_ROLE}
     spec:
       serviceAccountName: ${RUNTIME_SERVICE_ACCOUNT}
       containers:
         - image: ${IMAGE_URL}
+${CONTAINER_COMMAND}
           ports:
             - containerPort: 8080
           env:

package/templates/targets/workers/.github/workflows/deploy.yml

@@ -16,5 +16,8 @@ jobs:
       - run: bun run deploy
         env:
           CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
+          TRIGGER_PROJECT_REF: ${{ secrets.TRIGGER_PROJECT_REF }}
+          TRIGGER_ACCESS_TOKEN: ${{ secrets.TRIGGER_ACCESS_TOKEN }}
+          TRIGGER_SECRET_KEY: ${{ secrets.TRIGGER_SECRET_KEY }}
       - if: ${{ vars.GCX_ENABLED == 'true' }}
         run: bun run dashboards

package/templates/targets/workers/.github/workflows/preview.yml

@@ -30,3 +30,6 @@ jobs:
       - run: service deploy --name {{SERVICE_ID}}-pr-${{ steps.pr.outputs.number }}
         env:
           CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
+          TRIGGER_PROJECT_REF: ${{ secrets.TRIGGER_PROJECT_REF }}
+          TRIGGER_ACCESS_TOKEN: ${{ secrets.TRIGGER_ACCESS_TOKEN }}
+          TRIGGER_SECRET_KEY: ${{ secrets.TRIGGER_SECRET_KEY }}

package/templates/targets/workers/README.md

@@ -8,6 +8,7 @@ This `{{PROFILE}}` profile targets `{{RUNTIME}} + {{FRAMEWORK}}` on Cloudflare W
 - a lightweight waitlist/launch API
 - the `service` CLI for create, deploy, doctor, dashboards, DNS, and destroy
 - a Hyperdrive binding for Neon-backed Postgres persistence
+- Trigger.dev task dispatch for background trigger execution
 - a production API origin at `https://{{API_HOSTNAME}}`
 
 ## Commands
@@ -17,6 +18,8 @@ wrangler dev
 bun run test
 bun run lint
 bun run migrate
+bun run trigger -- --help
+bun run trigger:dev
 service create
 service deploy
 bun run dashboards
@@ -48,6 +51,31 @@ binding and create the small waitlist/trigger schema on first use.
 - `POST /webhooks/:provider`
 - `GET /webhooks/:provider/health`
 
+## Trigger.dev
+
+Cloudflare Workers services use Trigger.dev for background work. The Worker is
+the API surface; it records trigger rows and dispatches the generated
+`{{SERVICE_ID}}-waitlist-follow-up` task.
+
+Required production configuration:
+
+```bash
+export TRIGGER_PROJECT_REF=<project ref>
+export TRIGGER_ACCESS_TOKEN=<personal access token>
+export TRIGGER_SECRET_KEY=<secret key>
+```
+
+`service create` and `service deploy` deploy the Trigger.dev task before the
+Worker deploy and fail clearly if these values are missing.
+GitHub Actions deploys require matching repository secrets:
+`TRIGGER_PROJECT_REF`, `TRIGGER_ACCESS_TOKEN`, and `TRIGGER_SECRET_KEY`.
+
+The Trigger.dev CLI is installed in this generated package as a dev dependency
+from the `trigger.dev` npm package.
+Use `bun run trigger -- <args>` for ad-hoc commands, `bun run trigger:dev` for
+local task development, and `bun run trigger:deploy` when you want to deploy
+tasks directly without running the full service deploy.
+
 ## Production
 
 ```bash

package/templates/targets/workers/package.json

@@ -13,12 +13,16 @@
     "deploy": "service deploy",
     "dashboards": "service dashboards",
     "auth": "service auth",
-    "destroy": "service destroy"
+    "destroy": "service destroy",
+    "trigger": "trigger",
+    "trigger:dev": "trigger dev",
+    "trigger:deploy": "trigger deploy"
   },
   "dependencies": {
     "@anmho/authctl": "0.1.1",
     "@clack/prompts": "^1.2.0",
     "@neondatabase/api-client": "^2.7.1",
+    "@trigger.dev/sdk": "^4.4.6",
     "hono": "^4.10.1",
     "pg": "^8.16.3"
   },
@@ -26,6 +30,7 @@
     "@cloudflare/workers-types": "latest",
     "@types/pg": "^8.16.0",
     "@types/bun": "latest",
+    "trigger.dev": "^4.4.6",
     "typescript": "^5.9.3",
     "wrangler": "^4.49.0"
   }

package/templates/targets/workers/src/index.ts

@@ -1,6 +1,7 @@
 import { Hono } from "hono";
 import { authMiddleware } from "./auth";
 import { createStorage } from "./storage";
+import { createTriggerDevDispatcher, TriggerDispatchError, type TriggerDispatcher } from "./trigger";
 
 type Env = {
   HYPERDRIVE?: Hyperdrive;
@@ -8,10 +9,14 @@ type Env = {
   AUTH_ISSUER?: string;
   AUTH_AUDIENCE?: string;
   AUTH_JWKS_URL?: string;
+  TRIGGER_SECRET_KEY?: string;
+  TRIGGER_TASK_ID?: string;
+  TRIGGER_API_URL?: string;
 };
 
-export function createApp() {
+export function createApp(options: { triggerDispatcher?: TriggerDispatcher } = {}) {
   const app = new Hono<{ Bindings: Env }>();
+  const triggerDispatcher = options.triggerDispatcher ?? createTriggerDevDispatcher();
 
   app.get("/healthz", (context) => context.json({ status: "ok" }));
   app.get("/readyz", (context) => context.json({ status: "ok" }));
@@ -104,26 +109,36 @@ export function createApp() {
   });
 
   app.post("/v1/triggers/waitlist", async (context) => {
-    const body = await context.req.json().catch(() => ({}));
-    const trigger = await createStorage(context.env).recordTrigger({
-      type: String(body.type ?? "manual"),
-      entryId: body.entry_id ?? body.entryId ?? null,
-      payload: body,
-    });
-    return context.json({ trigger }, 202);
+    try {
+      const body = await context.req.json().catch(() => ({}));
+      const trigger = await createStorage(context.env).recordTrigger({
+        type: String(body.type ?? "manual"),
+        entryId: body.entry_id ?? body.entryId ?? null,
+        payload: body,
+      });
+      const run = await triggerDispatcher.dispatchWaitlistFollowUp(trigger, context.env);
+      return context.json({ trigger, trigger_dev_run_id: run.id }, 202);
+    } catch (error) {
+      return writeError(context, error);
+    }
   });
 
   app.post("/webhooks/:provider", async (context) => {
-    const rawBody = await context.req.text();
-    const trigger = await createStorage(context.env).recordTrigger({
-      type: `webhook.${context.req.param("provider")}`,
-      entryId: null,
-      payload: {
-        headers: Object.fromEntries(context.req.raw.headers),
-        rawBody,
-      },
-    });
-    return context.json({ trigger }, 202);
+    try {
+      const rawBody = await context.req.text();
+      const trigger = await createStorage(context.env).recordTrigger({
+        type: `webhook.${context.req.param("provider")}`,
+        entryId: null,
+        payload: {
+          headers: Object.fromEntries(context.req.raw.headers),
+          rawBody,
+        },
+      });
+      const run = await triggerDispatcher.dispatchWaitlistFollowUp(trigger, context.env);
+      return context.json({ trigger, trigger_dev_run_id: run.id }, 202);
+    } catch (error) {
+      return writeError(context, error);
+    }
   });
 
   app.get("/webhooks/:provider/health", (context) => context.json({ status: "ok", provider: context.req.param("provider") }));
@@ -153,6 +168,9 @@ function writeError(context: any, error: unknown) {
   if (error instanceof ValidationError) {
     return context.json({ error: error.message, code: error.code }, 400);
   }
+  if (error instanceof TriggerDispatchError) {
+    return context.json({ error: error.message, code: error.code }, 500);
+  }
   console.error(error);
   return context.json({ error: "internal server error", code: "internal" }, 500);
 }
@@ -188,11 +206,4 @@ function csvCell(value: string) {
 
 export default {
   fetch: app.fetch,
-  async scheduled(_event: ScheduledEvent, env: Env, context: ExecutionContext) {
-    context.waitUntil(
-      createStorage(env).claimQueuedTriggers(10).then((triggers) => {
-        console.log("processed waitlist triggers", triggers.length);
-      })
-    );
-  },
 };

package/templates/targets/workers/src/trigger.ts

@@ -0,0 +1,81 @@
+import type { WaitlistTrigger } from "./storage";
+
+export type TriggerRun = {
+  id: string;
+};
+
+export type TriggerDispatcher = {
+  dispatchWaitlistFollowUp(trigger: WaitlistTrigger, env: TriggerEnv): Promise<TriggerRun>;
+};
+
+export type TriggerEnv = {
+  TRIGGER_SECRET_KEY?: string;
+  TRIGGER_TASK_ID?: string;
+  TRIGGER_API_URL?: string;
+};
+
+export class TriggerDispatchError extends Error {
+  constructor(
+    readonly code: string,
+    message: string
+  ) {
+    super(message);
+  }
+}
+
+export function createTriggerDevDispatcher(): TriggerDispatcher {
+  return {
+    async dispatchWaitlistFollowUp(trigger, env) {
+      const config = triggerConfigFromEnv(env);
+      const response = await fetch(`${config.apiUrl}/api/v1/tasks/${encodeURIComponent(config.taskId)}/trigger`, {
+        method: "POST",
+        headers: {
+          authorization: `Bearer ${config.secretKey}`,
+          "content-type": "application/json",
+        },
+        body: JSON.stringify({
+          payload: {
+            triggerId: trigger.id,
+            type: trigger.type,
+            entryId: trigger.entry_id,
+            payload: parsePayload(trigger.payload_json),
+          },
+          options: {
+            idempotencyKey: trigger.id,
+          },
+        }),
+      });
+
+      if (!response.ok) {
+        throw new TriggerDispatchError("trigger_dev_request_failed", `Trigger.dev task trigger failed with ${response.status}: ${await response.text()}`);
+      }
+
+      const result = (await response.json()) as { id?: string };
+      if (!result.id) {
+        throw new TriggerDispatchError("trigger_dev_missing_run_id", "Trigger.dev did not return a run id");
+      }
+      return { id: result.id };
+    },
+  };
+}
+
+function triggerConfigFromEnv(env: TriggerEnv = {}) {
+  const secretKey = env.TRIGGER_SECRET_KEY?.trim();
+  if (!secretKey) {
+    throw new TriggerDispatchError("trigger_dev_not_configured", "TRIGGER_SECRET_KEY is required to dispatch Trigger.dev tasks");
+  }
+
+  return {
+    secretKey,
+    taskId: env.TRIGGER_TASK_ID?.trim() || "{{SERVICE_ID}}-waitlist-follow-up",
+    apiUrl: (env.TRIGGER_API_URL?.trim() || "https://api.trigger.dev").replace(/\/$/, ""),
+  };
+}
+
+function parsePayload(value: string) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return {};
+  }
+}