feat(events): phase 8.4 — CLI commands for events

giovaborgogno · claude · giovaborgogno · commit c9148ec76fc3 · 2026-02-28T21:43:43.000-08:00
Add `trigger events list` and `trigger events publish` commands:
- events/index.ts: parent command registration
- events/list.ts: list event definitions with subscriber count
- events/publish.ts: publish event with JSON payload
- apiClient.ts: listEvents() and publishEvent() methods

Usage:
  trigger events list
  trigger events publish order.created --payload '{"orderId":"123"}'

Co-Authored-By: Claude Opus 4.6 &lt;noreply@anthropic.com&gt;
diff --git a/packages/cli-v3/src/apiClient.ts b/packages/cli-v3/src/apiClient.ts
@@ -40,6 +40,8 @@ import {
   ApiBranchListResponseBody,
   GenerateRegistryCredentialsResponseBody,
   RemoteBuildProviderStatusResponseBody,
+  ListEventsResponseBody,
+  PublishEventResponseBody,
 } from "@trigger.dev/core/v3";
 import {
   WorkloadDebugLogRequestBody,
@@ -547,6 +549,41 @@ export class CliApiClient {
     });
   }
 
+  async listEvents(projectRef: string) {
+    if (!this.accessToken) {
+      throw new Error("listEvents: No access token");
+    }
+
+    return wrapZodFetch(ListEventsResponseBody, `${this.apiURL}/api/v1/events`, {
+      method: "GET",
+      headers: {
+        ...this.getHeaders(),
+        "x-trigger-project-ref": projectRef,
+      },
+    });
+  }
+
+  async publishEvent(projectRef: string, eventId: string, payload: unknown) {
+    if (!this.accessToken) {
+      throw new Error("publishEvent: No access token");
+    }
+
+    const encodedEventId = encodeURIComponent(eventId);
+
+    return wrapZodFetch(
+      PublishEventResponseBody,
+      `${this.apiURL}/api/v1/events/${encodedEventId}/publish`,
+      {
+        method: "POST",
+        headers: {
+          ...this.getHeaders(),
+          "x-trigger-project-ref": projectRef,
+        },
+        body: JSON.stringify({ payload }),
+      }
+    );
+  }
+
   get dev() {
     return {
       config: this.devConfig.bind(this),
diff --git a/packages/cli-v3/src/cli/index.ts b/packages/cli-v3/src/cli/index.ts
@@ -18,6 +18,7 @@ import { VERSION } from "../version.js";
 import { installExitHandler } from "./common.js";
 import { configureInstallMcpCommand } from "../commands/install-mcp.js";
 import { configureInstallRulesCommand } from "../commands/install-rules.js";
+import { configureEventsCommand } from "../commands/events/index.js";
 
 export const program = new Command();
 
@@ -42,5 +43,6 @@ configureAnalyzeCommand(program);
 configureMcpCommand(program);
 configureInstallMcpCommand(program);
 configureInstallRulesCommand(program);
+configureEventsCommand(program);
 
 installExitHandler();
diff --git a/packages/cli-v3/src/commands/events/index.ts b/packages/cli-v3/src/commands/events/index.ts
@@ -0,0 +1,14 @@
+import { Command } from "commander";
+import { configureEventsListCommand } from "./list.js";
+import { configureEventsPublishCommand } from "./publish.js";
+
+export function configureEventsCommand(program: Command) {
+  const events = program
+    .command("events")
+    .description("Manage pub/sub events");
+
+  configureEventsListCommand(events);
+  configureEventsPublishCommand(events);
+
+  return events;
+}
diff --git a/packages/cli-v3/src/commands/events/list.ts b/packages/cli-v3/src/commands/events/list.ts
@@ -0,0 +1,105 @@
+import { Command } from "commander";
+import { z } from "zod";
+import {
+  CommonCommandOptions,
+  commonOptions,
+  handleTelemetry,
+  wrapCommandAction,
+} from "../../cli/common.js";
+import { printInitialBanner } from "../../utilities/initialBanner.js";
+import { isLoggedIn } from "../../utilities/session.js";
+import { loadConfig } from "../../config.js";
+import { resolveLocalEnvVars } from "../../utilities/localEnvVars.js";
+import { CliApiClient } from "../../apiClient.js";
+import { intro, outro } from "@clack/prompts";
+import { spinner } from "../../utilities/windows.js";
+import { logger } from "../../utilities/logger.js";
+import { tryCatch } from "@trigger.dev/core";
+
+const EventsListOptions = CommonCommandOptions.extend({
+  config: z.string().optional(),
+  projectRef: z.string().optional(),
+  envFile: z.string().optional(),
+});
+
+type EventsListOptions = z.infer<typeof EventsListOptions>;
+
+export function configureEventsListCommand(program: Command) {
+  return commonOptions(
+    program
+      .command("list")
+      .description("List all event definitions in the project")
+      .option("-c, --config <config file>", "The name of the config file")
+      .option("-p, --project-ref <project ref>", "The project ref")
+      .option("--env-file <env file>", "Path to the .env file")
+  ).action(async (options) => {
+    await handleTelemetry(async () => {
+      await printInitialBanner(false, options.profile);
+      await eventsListCommand(options);
+    });
+  });
+}
+
+async function eventsListCommand(options: unknown) {
+  return await wrapCommandAction(
+    "eventsListCommand",
+    EventsListOptions,
+    options,
+    async (opts) => {
+      return await _eventsListCommand(opts);
+    }
+  );
+}
+
+async function _eventsListCommand(options: EventsListOptions) {
+  intro("Listing event definitions");
+
+  const envVars = resolveLocalEnvVars(options.envFile);
+
+  const authentication = await isLoggedIn(options.profile);
+  if (!authentication.ok) {
+    outro(`Not logged in. Use \`trigger login\` first.`);
+    return;
+  }
+
+  const [configError, resolvedConfig] = await tryCatch(
+    loadConfig({
+      overrides: { project: options.projectRef ?? envVars.TRIGGER_PROJECT_REF },
+      configFile: options.config,
+      warn: false,
+    })
+  );
+
+  if (configError || !resolvedConfig?.project) {
+    outro("Could not resolve project. Use --project-ref or configure trigger.config.ts.");
+    return;
+  }
+
+  const loadingSpinner = spinner();
+  loadingSpinner.start("Fetching events...");
+
+  const apiClient = new CliApiClient(authentication.auth.apiUrl, authentication.auth.accessToken);
+  const result = await apiClient.listEvents(resolvedConfig.project);
+
+  if (!result.success) {
+    loadingSpinner.stop("Failed to fetch events");
+    logger.error(result.error);
+    return;
+  }
+
+  loadingSpinner.stop(`Found ${result.data.data.length} event(s)`);
+
+  if (result.data.data.length === 0) {
+    outro("No events defined yet. Define events with `event()` in your task files.");
+    return;
+  }
+
+  logger.table(
+    result.data.data.map((evt) => ({
+      id: evt.slug,
+      version: evt.version,
+      subscribers: String(evt.subscriberCount),
+      schema: evt.hasSchema ? "yes" : "no",
+    }))
+  );
+}
diff --git a/packages/cli-v3/src/commands/events/publish.ts b/packages/cli-v3/src/commands/events/publish.ts
@@ -0,0 +1,120 @@
+import { Command } from "commander";
+import { z } from "zod";
+import {
+  CommonCommandOptions,
+  commonOptions,
+  handleTelemetry,
+  wrapCommandAction,
+} from "../../cli/common.js";
+import { printInitialBanner } from "../../utilities/initialBanner.js";
+import { isLoggedIn } from "../../utilities/session.js";
+import { loadConfig } from "../../config.js";
+import { resolveLocalEnvVars } from "../../utilities/localEnvVars.js";
+import { CliApiClient } from "../../apiClient.js";
+import { intro, outro } from "@clack/prompts";
+import { spinner } from "../../utilities/windows.js";
+import { logger } from "../../utilities/logger.js";
+import { tryCatch } from "@trigger.dev/core";
+
+const EventsPublishOptions = CommonCommandOptions.extend({
+  config: z.string().optional(),
+  projectRef: z.string().optional(),
+  envFile: z.string().optional(),
+  payload: z.string(),
+});
+
+type EventsPublishOptions = z.infer<typeof EventsPublishOptions>;
+
+export function configureEventsPublishCommand(program: Command) {
+  return commonOptions(
+    program
+      .command("publish <eventId>")
+      .description("Publish an event with a JSON payload")
+      .requiredOption("--payload <json>", "JSON payload to publish")
+      .option("-c, --config <config file>", "The name of the config file")
+      .option("-p, --project-ref <project ref>", "The project ref")
+      .option("--env-file <env file>", "Path to the .env file")
+  ).action(async (eventId: string, options) => {
+    await handleTelemetry(async () => {
+      await printInitialBanner(false, options.profile);
+      await eventsPublishCommand({ ...options, eventId });
+    });
+  });
+}
+
+const EventsPublishCommandInput = EventsPublishOptions.extend({
+  eventId: z.string(),
+});
+
+type EventsPublishCommandInput = z.infer<typeof EventsPublishCommandInput>;
+
+async function eventsPublishCommand(options: unknown) {
+  return await wrapCommandAction(
+    "eventsPublishCommand",
+    EventsPublishCommandInput,
+    options,
+    async (opts) => {
+      return await _eventsPublishCommand(opts);
+    }
+  );
+}
+
+async function _eventsPublishCommand(options: EventsPublishCommandInput) {
+  intro(`Publishing event "${options.eventId}"`);
+
+  // Parse JSON payload
+  let payload: unknown;
+  try {
+    payload = JSON.parse(options.payload);
+  } catch {
+    outro("Invalid JSON payload. Provide valid JSON with --payload.");
+    return;
+  }
+
+  const envVars = resolveLocalEnvVars(options.envFile);
+
+  const authentication = await isLoggedIn(options.profile);
+  if (!authentication.ok) {
+    outro(`Not logged in. Use \`trigger login\` first.`);
+    return;
+  }
+
+  const [configError, resolvedConfig] = await tryCatch(
+    loadConfig({
+      overrides: { project: options.projectRef ?? envVars.TRIGGER_PROJECT_REF },
+      configFile: options.config,
+      warn: false,
+    })
+  );
+
+  if (configError || !resolvedConfig?.project) {
+    outro("Could not resolve project. Use --project-ref or configure trigger.config.ts.");
+    return;
+  }
+
+  const loadingSpinner = spinner();
+  loadingSpinner.start("Publishing event...");
+
+  const apiClient = new CliApiClient(authentication.auth.apiUrl, authentication.auth.accessToken);
+  const result = await apiClient.publishEvent(resolvedConfig.project, options.eventId, payload);
+
+  if (!result.success) {
+    loadingSpinner.stop("Failed to publish event");
+    logger.error(result.error);
+    return;
+  }
+
+  loadingSpinner.stop("Event published");
+
+  logger.info(`Event ID: ${result.data.eventId}`);
+  logger.info(`Triggered ${result.data.runs.length} run(s)`);
+
+  if (result.data.runs.length > 0) {
+    logger.table(
+      result.data.runs.map((run) => ({
+        task: run.taskIdentifier,
+        runId: run.runId,
+      }))
+    );
+  }
+}
