@doist/automations-cli 1.20.2 → 1.21.0

package/dist/index.js

@@ -7,7 +7,7 @@ import {
   collectSkillStatus,
   getInstaller,
   updateAllInstalledSkills
-} from "./chunk-GUWS3EHG.js";
+} from "./chunk-ZWFZ2DD3.js";
 
 // ../../node_modules/ajv/dist/compile/codegen/code.js
 var require_code = __commonJS({
@@ -6899,7 +6899,7 @@ import { fileURLToPath } from "node:url";
 // package.json
 var package_default = {
   name: "@doist/automations-cli",
-  version: "1.20.2",
+  version: "1.21.0",
   description: "Command-line client for Todoist Automations",
   type: "module",
   bin: {
@@ -6945,7 +6945,7 @@ var package_default = {
   dependencies: {
     "@doist/cli-core": "1.7.0",
     "@napi-rs/keyring": "2.1.0",
-    ai: "7.0.86",
+    ai: "7.0.137",
     commander: "15.0.0",
     oauth4webapi: "3.8.8",
     open: "11.0.4"
@@ -6953,7 +6953,7 @@ var package_default = {
   devDependencies: {
     "@doist/automations-core": "*",
     "@doist/automations-sdk": "*",
-    "@types/node": "24.19.1",
+    "@types/node": "24.19.2",
     "conventional-changelog-conventionalcommits": "9.3.1",
     esbuild: "0.28.2",
     "semantic-release": "25.0.9",
@@ -28149,6 +28149,7 @@ var cronScheduleSchema = (() => {
   });
 })();
 var scheduleValueSchema = external_exports.union([intervalScheduleSchema, cronScheduleSchema]).meta({ description: "The schedule definition for the trigger." });
+var TRIGGER_TYPES = ["schedule", "webhook", "api"];
 var scheduleTriggerSchema = external_exports.object({
   type: external_exports.literal("schedule"),
   value: scheduleValueSchema,
@@ -28986,7 +28987,7 @@ var ImportLocalOAuthConnectionBodySchema = external_exports.object({
    * matched to it.
    */
   repairConnectionId: external_exports.uuid().optional()
-});
+}).meta({ id: "ImportLocalOAuthConnection" });
 var LocalOAuthSetupSchema = external_exports.object({
   /** RFC 7591 registration endpoint; null when the server offers none. */
   registrationEndpoint: external_exports.string().url().nullable(),
@@ -29138,20 +29139,20 @@ var updateAutomationSchema = external_exports.object({
   manifest: manifestSchema.optional()
 }).refine((data) => Object.keys(data).length > 0, {
   message: "At least one field must be provided"
-});
+}).meta({ id: "UpdateAutomation" });
 var updateAutomationMetadataSchema = external_exports.object({
   name: external_exports.string().min(1),
   description: external_exports.string()
-});
+}).meta({ id: "UpdateAutomationMetadata" });
 var updateAutomationScheduleSchema = external_exports.object({
   value: scheduleValueSchema
-});
+}).meta({ id: "UpdateAutomationSchedule" });
 var updateAutomationVisibilitySchema = external_exports.object({
   visibility: external_exports.enum(AUTOMATION_VISIBILITIES)
-});
+}).meta({ id: "UpdateAutomationVisibility" });
 var moveAutomationSchema = external_exports.object({
   visibility: external_exports.enum(AUTOMATION_VISIBILITIES).default("workspace")
-});
+}).meta({ id: "MoveAutomation" });
 
 // ../../packages/core/dist/esm/schemas/automation-connection.schema.js
 var AutomationConnectionMappingSchema = external_exports.object({
@@ -29168,7 +29169,7 @@ var UpsertAutomationConnectionSchema = external_exports.object({
    * the service infers the role from `connection.capabilities[0]`.
    */
   connectionType: external_exports.enum(CONNECTION_TYPES).optional()
-}).strict();
+}).strict().meta({ id: "UpsertAutomationConnection" });
 var SetAutomationConnectionsSchema = external_exports.object({
   mappings: external_exports.array(AutomationConnectionMappingSchema).nonempty("mappings cannot be empty")
 }).strict();
@@ -29326,8 +29327,29 @@ var automationDraftListResponseSchema = external_exports.object({
 var finalizeAutomationDraftResponseSchema = external_exports.object({
   automation: automationSchema
 });
+var draftTestTriggerSelectorSchema = external_exports.union([
+  external_exports.object({ index: external_exports.int().min(0) }),
+  external_exports.object({ event: external_exports.string().min(1) })
+]);
+var testAutomationDraftRequestSchema = external_exports.object({
+  trigger: draftTestTriggerSelectorSchema.optional(),
+  payload: external_exports.unknown().optional(),
+  metadata: external_exports.record(external_exports.string(), external_exports.unknown()).optional()
+}).meta({ id: "TestAutomationDraftRequest" });
+var draftTestTriggerSchema = external_exports.object({
+  index: external_exports.int().min(0),
+  count: external_exports.int().min(1),
+  type: external_exports.enum(TRIGGER_TYPES),
+  event: external_exports.string().optional(),
+  inputSource: external_exports.enum(["schedule", "sample-event", "supplied", "empty"])
+});
 var testAutomationDraftResponseSchema = external_exports.object({
-  success: external_exports.literal(true)
+  success: external_exports.literal(true),
+  draftId: external_exports.string(),
+  testRunId: external_exports.string(),
+  status: external_exports.enum(AUTOMATION_RUN_STATUSES),
+  connectorCalls: external_exports.literal("mocked"),
+  trigger: draftTestTriggerSchema
 });
 var AUTOMATION_OPEN_DRAFT_CONFLICT_CODE = "automation_open_draft_conflict";
 var AutomationOpenDraftConflictSchema = external_exports.object({
@@ -29340,13 +29362,25 @@ var AutomationDraftNotReadySchema = external_exports.object({
   code: external_exports.literal(AUTOMATION_DRAFT_NOT_READY_CODE),
   message: external_exports.string()
 });
+var DRAFT_TEST_REQUEST_ERROR_CODES = [
+  "draft_test_not_ready",
+  "draft_test_trigger_not_found",
+  "draft_test_payload_required",
+  "draft_test_payload_filtered",
+  "draft_test_payload_invalid",
+  "draft_test_payload_unsupported"
+];
+var DraftTestRequestErrorSchema = external_exports.object({
+  code: external_exports.enum(DRAFT_TEST_REQUEST_ERROR_CODES),
+  message: external_exports.string()
+});
 
 // ../../packages/core/dist/esm/schemas/automation-draft-connection.schema.js
 var CreateAutomationDraftConnectionSchema = external_exports.object({
   connectorId: external_exports.string().trim().min(1, "connectorId is required"),
   connectionType: external_exports.enum(CONNECTION_TYPES),
   connectionId: uuidv7Schema.min(1, "connectionId is required")
-}).strict();
+}).strict().meta({ id: "CreateAutomationDraftConnection" });
 var AutomationDraftConnectionSchema = external_exports.object({
   draftId: external_exports.string(),
   connectorId: external_exports.string(),
@@ -29515,13 +29549,13 @@ var getChatConversationsQuerySchema = external_exports.object({
 });
 var createChatConversationSchema = external_exports.object({
   title: external_exports.string().nullable().optional()
-});
+}).meta({ id: "CreateChatConversation" });
 var updateChatConversationSchema = external_exports.object({
   title: external_exports.string().nullable().optional(),
   isArchived: external_exports.boolean().optional()
 }).refine((value) => value.title !== void 0 || value.isArchived !== void 0, {
   message: "At least one field must be provided"
-});
+}).meta({ id: "UpdateChatConversation" });
 
 // ../../packages/core/dist/esm/schemas/automation-preview-artifact.schema.js
 var automationPreviewSources = ["synthetic", "run"];
@@ -29651,10 +29685,23 @@ var automationTestRunStepStatusSchema = external_exports.object({
   stepId: external_exports.string().min(1),
   status: external_exports.enum(AUTOMATION_RUN_STATUSES)
 });
+var automationTestRunFailedStepSchema = external_exports.object({
+  stepId: external_exports.string().min(1),
+  description: external_exports.string().optional(),
+  error: external_exports.string().optional()
+});
 var automationTestRunProgressSchema = external_exports.object({
   draftId: external_exports.string().min(1),
   status: external_exports.enum(AUTOMATION_RUN_STATUSES),
-  steps: external_exports.array(automationTestRunStepStatusSchema).default([])
+  steps: external_exports.array(automationTestRunStepStatusSchema).default([]),
+  // Optional so results stored before these fields existed still parse.
+  runId: external_exports.string().min(1).optional(),
+  failedStep: automationTestRunFailedStepSchema.optional(),
+  /** Why a failed or skipped run stopped. */
+  error: external_exports.string().optional(),
+  result: AutomationRunResultSchema.nullable().optional(),
+  /** A test run simulates every connector call, reads included. */
+  connectorCalls: external_exports.literal("mocked").optional()
 });
 var automationTestRunPreviewTriggerSchema = external_exports.union([
   external_exports.object({
@@ -29947,6 +29994,47 @@ var cohortMatrixResponseSchema = external_exports.object({
   rows: external_exports.array(cohortMatrixRowSchema)
 });
 
+// ../../packages/core/dist/esm/schemas/draft-test-run.schema.js
+var DraftTestRunFailedStepSchema = external_exports.object({
+  stepId: external_exports.string(),
+  description: external_exports.string(),
+  error: external_exports.string().nullable()
+});
+var draftTestRunDetailDtoBaseShape = {
+  id: external_exports.string(),
+  draftId: external_exports.string(),
+  // The automation an edit draft belongs to; null for a draft of a new automation.
+  automationId: external_exports.string().nullable(),
+  mode: external_exports.literal("test"),
+  // A test run simulates every connector call, reads included, with a model.
+  connectorCalls: external_exports.literal("mocked"),
+  createdAt: external_exports.string(),
+  updatedAt: external_exports.string(),
+  result: AutomationRunResultSchema.nullable(),
+  temporalUrl: external_exports.string().nullish(),
+  steps: external_exports.array(AutomationRunStepDtoSchema),
+  failedStep: DraftTestRunFailedStepSchema.nullable()
+};
+var DraftTestRunDetailDtoSchema = external_exports.discriminatedUnion("status", [
+  external_exports.object({ ...draftTestRunDetailDtoBaseShape, status: external_exports.literal("pending") }),
+  external_exports.object({ ...draftTestRunDetailDtoBaseShape, status: external_exports.literal("running") }),
+  external_exports.object({ ...draftTestRunDetailDtoBaseShape, status: external_exports.literal("completed") }),
+  external_exports.object({ ...draftTestRunDetailDtoBaseShape, status: external_exports.literal("cancelled") }),
+  external_exports.object({ ...draftTestRunDetailDtoBaseShape, status: external_exports.literal("data-expired") }),
+  external_exports.object({
+    ...draftTestRunDetailDtoBaseShape,
+    status: external_exports.literal("failed"),
+    failureReason: external_exports.string().nullish(),
+    failureCategory: external_exports.enum(FAILURE_CATEGORIES).nullish().catch(null)
+  }),
+  external_exports.object({
+    ...draftTestRunDetailDtoBaseShape,
+    status: external_exports.literal("skipped"),
+    skipReason: external_exports.string().nullish(),
+    skipCategory: external_exports.enum(SKIP_CATEGORIES).nullish()
+  })
+]);
+
 // ../../packages/core/dist/esm/types/workspace.types.js
 var WORKSPACE_PLANS = ["STARTER", "BUSINESS"];
 var WORKSPACE_ROLES = ["ADMIN", "MEMBER", "GUEST"];
@@ -30139,7 +30227,7 @@ var NotificationResponseSchema = external_exports.object({
   const isStatusResponse = data.status !== void 0 && data.action === void 0;
   const isAnswer = data.action === "answer" && data.value !== void 0 && data.status === void 0;
   return isStatusResponse || isAnswer;
-}, { message: 'Provide either { status } or { action: "answer", value }' });
+}, { message: 'Provide either { status } or { action: "answer", value }' }).meta({ id: "NotificationResponse" });
 var NOTIFICATION_STATUSES = [
   ...INFO_NOTIFICATION_STATUSES,
   ...PROMPT_NOTIFICATION_STATUSES
@@ -30322,10 +30410,10 @@ var RegisterPushSubscriptionSchema = external_exports.object({
   endpoint: external_exports.url().max(768),
   keys: PushSubscriptionKeysSchema,
   deviceName: external_exports.string().max(255).optional()
-});
+}).meta({ id: "RegisterPushSubscription" });
 var UpdatePushSubscriptionSchema = external_exports.object({
   deviceName: external_exports.string().max(255).nullable().optional()
-});
+}).meta({ id: "UpdatePushSubscription" });
 var RemovePushSubscriptionByEndpointQuerySchema = external_exports.object({
   endpoint: external_exports.url().max(768)
 });
@@ -30359,7 +30447,7 @@ var createSubscriptionSchema = external_exports.object({
   triggerEventId: external_exports.string().min(1, "Trigger event ID is required"),
   outputSchema: external_exports.record(external_exports.string(), external_exports.unknown()),
   inputSchema: external_exports.record(external_exports.string(), external_exports.unknown()).optional()
-});
+}).meta({ id: "CreateSubscription" });
 var subscriptionResponseSchema = external_exports.object({
   id: external_exports.string(),
   agentId: external_exports.string(),
@@ -30395,7 +30483,7 @@ var UserOnboardingStateSchema = external_exports.object({
 });
 var AcceptTermsSchema = external_exports.object({
   version: external_exports.string().trim().min(1).max(64)
-});
+}).meta({ id: "AcceptTerms" });
 var ConnectorIdSchema = external_exports.string().trim().min(1);
 var InterestedConnectorIdsSchema = external_exports.array(ConnectorIdSchema).max(100);
 var ConnectorPreferencesSchema = external_exports.object({
@@ -30442,7 +30530,7 @@ var UserPreferencesSchema = external_exports.object({
 });
 var CompleteOnboardingSchema = external_exports.object({
   connectors: ConnectorPreferencesUpdateSchema.optional()
-}).default({});
+}).default({}).meta({ id: "CompleteOnboarding" });
 var UpdateUserPreferencesSchema = external_exports.object({
   connectors: ConnectorPreferencesUpdateSchema.optional(),
   notifications: NotificationPreferencesUpdateSchema.optional(),
@@ -30461,7 +30549,7 @@ var UpdateUserPreferencesSchema = external_exports.object({
     value.notifications?.usageBalance
   ];
   return channelGroups.some((group) => group && ("email" in group && group.email !== void 0 || group.push !== void 0));
-}, { message: "At least one preference field must be provided" });
+}, { message: "At least one preference field must be provided" }).meta({ id: "UpdateUserPreferences" });
 
 // ../../packages/core/dist/esm/schemas/webhook-events/automation-created.event.js
 var AutomationCreatedDataSchema = external_exports.object({
@@ -30637,14 +30725,14 @@ var CreateWebhookEventSubscriptionRequestSchema = external_exports.object({
   eventTypes: external_exports.array(external_exports.enum(WEBHOOK_EVENT_TYPES)).min(1),
   subjectAutomationId: external_exports.string().optional(),
   description: external_exports.string().max(WEBHOOK_EVENT_SUBSCRIPTION_DESCRIPTION_MAX_LENGTH).optional()
-}).superRefine(rejectAccountScopedWithSubject);
+}).superRefine(rejectAccountScopedWithSubject).meta({ id: "CreateWebhookEventSubscriptionRequest" });
 var UpdateWebhookEventSubscriptionRequestSchema = external_exports.object({
   url: WebhookEndpointUrlSchema,
   eventTypes: external_exports.array(external_exports.enum(WEBHOOK_EVENT_TYPES)).min(1),
   status: external_exports.enum(WEBHOOK_EVENT_SUBSCRIPTION_STATUSES),
   description: external_exports.string().max(WEBHOOK_EVENT_SUBSCRIPTION_DESCRIPTION_MAX_LENGTH).nullable(),
   subjectAutomationId: external_exports.string().nullable()
-}).partial().superRefine(rejectAccountScopedWithSubject);
+}).partial().superRefine(rejectAccountScopedWithSubject).meta({ id: "UpdateWebhookEventSubscriptionRequest" });
 var WebhookEventDeliveryDtoSchema = external_exports.object({
   id: external_exports.string(),
   eventType: external_exports.enum(WEBHOOK_EVENT_TYPES),
@@ -31117,7 +31205,8 @@ var automationDraftsEndpoints = {
   list: root3,
   detail: (id) => `${root3}/${encodeURIComponent(id)}`,
   finalize: (id) => `${root3}/${encodeURIComponent(id)}/finalize`,
-  test: (id) => `${root3}/${encodeURIComponent(id)}/test`
+  test: (id) => `${root3}/${encodeURIComponent(id)}/test`,
+  testRun: (id, runId) => `${root3}/${encodeURIComponent(id)}/test-runs/${encodeURIComponent(runId)}`
 };
 
 // ../../packages/sdk/dist/esm/clients/automation-drafts/automation-drafts-client.js
@@ -31131,6 +31220,16 @@ function getDraftNotReadyError(error62) {
   const parsed = AutomationDraftNotReadySchema.safeParse(error62.responseData);
   return parsed.success ? parsed.data : null;
 }
+function getDraftTestRequestError(error62) {
+  if (!(error62 instanceof AutomationsRequestError) || error62.httpStatusCode !== 400) {
+    return null;
+  }
+  const parsed = DraftTestRequestErrorSchema.safeParse(error62.responseData);
+  return parsed.success ? parsed.data : null;
+}
+function isRequestOptions(value) {
+  return Boolean(value && ("signal" in value || "headers" in value));
+}
 var AutomationDraftsClient = class extends BaseClient {
   async list(args = {}, options) {
     const { cursor, limit } = CursorPaginationSchema.parse(args);
@@ -31191,16 +31290,35 @@ var AutomationDraftsClient = class extends BaseClient {
     });
     return finalizeAutomationDraftResponseSchema.parse(data);
   }
-  async test(draftId, options) {
+  /** Starts a test run; `request` picks the trigger and supplies the event to test with. */
+  async test(draftId, requestOrOptions, options) {
     const id = IdSchema.parse(draftId);
+    const request2 = isRequestOptions(requestOrOptions) ? void 0 : requestOrOptions;
     const data = await this.request({
       method: "POST",
       path: automationDraftsEndpoints.test(id),
-      options
+      body: request2 ? testAutomationDraftRequestSchema.parse(request2) : void 0,
+      options: isRequestOptions(requestOrOptions) ? requestOrOptions : options
     });
     return testAutomationDraftResponseSchema.parse(data);
   }
+  /** A test run of this draft, with its steps; `args` match the run detail's. */
+  async getTestRun(draftId, runId, args = {}, options) {
+    const data = await this.request({
+      method: "GET",
+      path: automationDraftsEndpoints.testRun(IdSchema.parse(draftId), IdSchema.parse(runId)),
+      query: toTestRunQuery(args),
+      options
+    });
+    return DraftTestRunDetailDtoSchema.parse(data);
+  }
 };
+function toTestRunQuery(args) {
+  return {
+    includeGeneratedCode: args.includeGeneratedCode ? true : void 0,
+    includeToolCallPreviews: args.includeToolCallPreviews
+  };
+}
 
 // ../../packages/sdk/dist/esm/clients/automation-runs/endpoints.js
 var automationRunsEndpoints = {
@@ -31209,7 +31327,7 @@ var automationRunsEndpoints = {
 };
 
 // ../../packages/sdk/dist/esm/clients/automation-runs/automation-runs-client.js
-function isRequestOptions(value) {
+function isRequestOptions2(value) {
   return Boolean(value && ("signal" in value || "headers" in value));
 }
 var AutomationRunsClient = class extends BaseClient {
@@ -31228,8 +31346,8 @@ var AutomationRunsClient = class extends BaseClient {
   async get(automationId, runId, argsOrOptions, options) {
     const aId = IdSchema.parse(automationId);
     const rId = IdSchema.parse(runId);
-    const args = isRequestOptions(argsOrOptions) ? void 0 : argsOrOptions;
-    const requestOptions = isRequestOptions(argsOrOptions) ? argsOrOptions : options;
+    const args = isRequestOptions2(argsOrOptions) ? void 0 : argsOrOptions;
+    const requestOptions = isRequestOptions2(argsOrOptions) ? argsOrOptions : options;
     const data = await this.request({
       method: "GET",
       path: automationRunsEndpoints.detail(aId, rId),
@@ -31488,7 +31606,9 @@ var WorkspaceAutomationDraftConnectionsClient = class extends BaseClient {
 var workspaceAutomationDraftsEndpoints = {
   list: (workspaceId) => `${root7(workspaceId)}`,
   detail: (workspaceId, id) => `${root7(workspaceId)}/${encodeURIComponent(id)}`,
-  finalize: (workspaceId, id) => `${root7(workspaceId)}/${encodeURIComponent(id)}/finalize`
+  finalize: (workspaceId, id) => `${root7(workspaceId)}/${encodeURIComponent(id)}/finalize`,
+  test: (workspaceId, id) => `${root7(workspaceId)}/${encodeURIComponent(id)}/test`,
+  testRun: (workspaceId, id, runId) => `${root7(workspaceId)}/${encodeURIComponent(id)}/test-runs/${encodeURIComponent(runId)}`
 };
 function root7(workspaceId) {
   return `/workspaces/${encodeURIComponent(workspaceId)}/automation-drafts`;
@@ -31554,6 +31674,24 @@ var WorkspaceAutomationDraftsClient = class extends BaseClient {
     });
     return finalizeAutomationDraftResponseSchema.parse(data);
   }
+  async test(workspaceId, draftId, request2 = {}, options) {
+    const data = await this.request({
+      method: "POST",
+      path: workspaceAutomationDraftsEndpoints.test(IdSchema.parse(workspaceId), IdSchema.parse(draftId)),
+      body: testAutomationDraftRequestSchema.parse(request2),
+      options
+    });
+    return testAutomationDraftResponseSchema.parse(data);
+  }
+  async getTestRun(workspaceId, draftId, runId, args = {}, options) {
+    const data = await this.request({
+      method: "GET",
+      path: workspaceAutomationDraftsEndpoints.testRun(IdSchema.parse(workspaceId), IdSchema.parse(draftId), IdSchema.parse(runId)),
+      query: toTestRunQuery(args),
+      options
+    });
+    return DraftTestRunDetailDtoSchema.parse(data);
+  }
 };
 
 // ../../packages/sdk/dist/esm/clients/workspace-chat/endpoints.js
@@ -32497,25 +32635,47 @@ function summarizeRun(run) {
     result: run.result,
     temporalUrl: run.temporalUrl,
     triggeredBy: run.triggeredBy,
-    steps: run.steps.map((step) => ({
-      stepId: step.stepId,
-      type: step.type,
-      description: step.description,
-      status: step.status,
-      startedAt: step.startedAt,
-      completedAt: step.completedAt,
-      error: step.error,
-      toolCalls: step.toolCalls?.map((toolCall) => ({
-        id: toolCall.id,
-        name: toolCall.name,
-        argumentKeys: toolCall.argumentKeys,
-        hasResult: toolCall.hasResult,
-        hasError: toolCall.hasError,
-        resultPreview: toolCall.resultPreview,
-        errorPreview: toolCall.errorPreview,
-        timestamp: toolCall.timestamp
-      }))
+    steps: summarizeRunSteps(run.steps)
+  };
+}
+function summarizeRunSteps(steps) {
+  return steps.map((step) => ({
+    stepId: step.stepId,
+    type: step.type,
+    description: step.description,
+    status: step.status,
+    startedAt: step.startedAt,
+    completedAt: step.completedAt,
+    error: step.error,
+    toolCalls: step.toolCalls?.map((toolCall) => ({
+      id: toolCall.id,
+      name: toolCall.name,
+      argumentKeys: toolCall.argumentKeys,
+      hasResult: toolCall.hasResult,
+      hasError: toolCall.hasError,
+      resultPreview: toolCall.resultPreview,
+      errorPreview: toolCall.errorPreview,
+      timestamp: toolCall.timestamp
     }))
+  }));
+}
+
+// ../../packages/sdk/dist/esm/summaries/draft-test-run-summary.js
+function summarizeDraftTestRun(run) {
+  return {
+    id: run.id,
+    draftId: run.draftId,
+    automationId: run.automationId,
+    status: run.status,
+    connectorCalls: run.connectorCalls,
+    createdAt: run.createdAt,
+    updatedAt: run.updatedAt,
+    failureCategory: getRunOutcomeCategory(run),
+    failureReason: getRunOutcomeReason(run),
+    failedStep: run.failedStep,
+    result: run.result,
+    temporalUrl: run.temporalUrl,
+    steps: summarizeRunSteps(run.steps)
   };
 }
 
@@ -34168,7 +34328,9 @@ async function runApiCommand(command, operation, presentation, execution = {}) {
   try {
     const globalOptions = getGlobalOptions(command);
     mode = getOutputMode(globalOptions);
-    const apiConfiguration = await resolveApiConfiguration(globalOptions);
+    const apiConfiguration = await resolveApiConfiguration(globalOptions, {
+      minimumTokenLifetimeMs: execution.minimumTokenLifetimeMs
+    });
     source = apiConfiguration.source;
     const context = {
       api: createAutomationsApi(apiConfiguration),
@@ -34184,6 +34346,8 @@ async function runApiCommand(command, operation, presentation, execution = {}) {
     );
     stopEarlySpinner();
     writeResult(mode, result, presentation);
+    const exitCode = execution.exitCode?.(result);
+    if (exitCode !== void 0) process.exitCode = exitCode;
   } catch (error62) {
     if (abortController.signal.aborted) {
       writeFailure(mode, "interrupted", {
@@ -34351,16 +34515,21 @@ function formatRun(run) {
     `Failure reason: ${getRunOutcomeReason(run) ?? "none"}`,
     `Result: ${run.result?.text ?? "none"}`,
     `Steps: ${run.steps.length}`,
-    ...isInsufficientCredit(run) ? ["", topUpAdvisory()] : []
+    ...isInsufficientCredit(run) ? ["", topUpAdvisory()] : [],
+    ...formatRunSteps(run.steps)
   ];
-  for (const [index, step] of run.steps.entries()) {
+  return lines.join("\n");
+}
+function formatRunSteps(steps, { toolCallLabel = "Tool" } = {}) {
+  const lines = [];
+  for (const [index, step] of steps.entries()) {
     lines.push("", `${index + 1}. ${step.stepId} [${step.status}] ${step.description}`);
     lines.push(`   Type: ${step.type}`);
     if (step.startedAt) lines.push(`   Started: ${step.startedAt}`);
     if (step.completedAt) lines.push(`   Completed: ${step.completedAt}`);
     if (step.error) lines.push(`   Error: ${step.error}`);
     for (const toolCall of step.toolCalls ?? []) {
-      lines.push(`   Tool: ${toolCall.name} (${toolCall.id})`);
+      lines.push(`   ${toolCallLabel}: ${toolCall.name} (${toolCall.id})`);
       if (toolCall.argumentKeys.length > 0) {
         lines.push(`     Args: ${toolCall.argumentKeys.join(", ")}`);
       }
@@ -34370,7 +34539,7 @@ function formatRun(run) {
       if (toolCall.resultPreview) lines.push(`     Result preview: ${toolCall.resultPreview}`);
     }
   }
-  return lines.join("\n");
+  return lines;
 }
 function getResourceName(manifest) {
   if (!isRecord2(manifest)) return "(unnamed)";
@@ -36842,6 +37011,8 @@ async function readSource(options, input2) {
 
 // src/commands/draft/draft-service.ts
 import { CliError as CliError4, getErrorMessage as getErrorMessage7 } from "@doist/cli-core";
+import { readFile as readFile3 } from "node:fs/promises";
+import { setTimeout as wait2 } from "node:timers/promises";
 
 // src/lib/manifest-diff.ts
 function stableStringify(value) {
@@ -36904,7 +37075,11 @@ function resolveDraftApi(api, workspaceId, signal) {
       upsertConnection: (draftId, body) => api.automationDraftConnections.upsert(draftId, body, { signal }),
       getConnectionStatus: async (draftId) => (await api.automationDraftConnections.getStatus(draftId, { signal })).validation,
       finalize: (draftId) => api.automationDrafts.finalize(draftId, { signal }),
-      getAutomation: (automationId) => api.automations.get(automationId, { signal })
+      getAutomation: (automationId) => api.automations.get(automationId, { signal }),
+      test: (draftId, request2) => api.automationDrafts.test(draftId, request2, { signal }),
+      getTestRun: (draftId, runId, args, requestSignal) => api.automationDrafts.getTestRun(draftId, runId, args, {
+        signal: requestSignal ?? signal
+      })
     };
   }
   return {
@@ -36918,7 +37093,11 @@ function resolveDraftApi(api, workspaceId, signal) {
       signal
     })).validation,
     finalize: (draftId) => api.workspaceAutomationDrafts.finalize(workspaceId, draftId, { signal }),
-    getAutomation: (automationId) => api.workspaceAutomations.get(workspaceId, automationId, { signal })
+    getAutomation: (automationId) => api.workspaceAutomations.get(workspaceId, automationId, { signal }),
+    test: (draftId, request2) => api.workspaceAutomationDrafts.test(workspaceId, draftId, request2, { signal }),
+    getTestRun: (draftId, runId, args, requestSignal) => api.workspaceAutomationDrafts.getTestRun(workspaceId, draftId, runId, args, {
+      signal: requestSignal ?? signal
+    })
   };
 }
 async function createDraft(draftApi, { manifest, automationId }) {
@@ -37054,12 +37233,7 @@ async function publishDraft(draftApi, { draftId, confirmed }) {
   } catch (error62) {
     const notReady = getDraftNotReadyError(error62);
     if (!notReady) throw error62;
-    throw new CliError4("DRAFT_NOT_READY", notReady.message, {
-      hints: [
-        `See the issues: tda draft view ${draftId}`,
-        `Bind connections: tda draft connect ${draftId} --auto`
-      ]
-    });
+    throw draftNotReadyError(notReady.message, draftId, draftApi.scope);
   }
   const automationId = published.automation.id;
   let automation;
@@ -37137,6 +37311,136 @@ function normaliseManifest(manifest) {
   const parsed = manifestSchema.safeParse(manifest);
   return parsed.success ? parsed.data : manifest;
 }
+var DEFAULT_POLL_INTERVALS_MS = { first: 2e3, max: 1e4 };
+var STATUS_REQUEST_GRACE_MS = 1e4;
+var OPEN_RUN_STATUSES = /* @__PURE__ */ new Set([
+  "pending",
+  "running"
+]);
+async function startDraftTest(draftApi, {
+  draftId,
+  request: request2,
+  wait: waitFor,
+  signal
+}) {
+  let started;
+  try {
+    started = await draftApi.test(draftId, request2);
+  } catch (error62) {
+    const refusal = getDraftTestRequestError(error62);
+    if (!refusal) throw error62;
+    throw toDraftTestCliError(refusal, draftId, draftApi.scope);
+  }
+  const base = {
+    draftId,
+    testRunId: started.testRunId,
+    trigger: started.trigger,
+    connectorCalls: started.connectorCalls,
+    command: `tda draft test-run ${draftId} ${started.testRunId} ${scopeFlag(draftApi.scope)}`
+  };
+  if (!waitFor) {
+    return { action: "test_started", ...base, status: started.status };
+  }
+  const intervals = waitFor.pollIntervalsMs ?? DEFAULT_POLL_INTERVALS_MS;
+  const deadline = Date.now() + waitFor.timeoutMs;
+  let intervalMs = intervals.first;
+  let last = null;
+  while (true) {
+    const requestTimeout = AbortSignal.timeout(
+      Math.max(deadline - Date.now(), 0) + (waitFor.requestGraceMs ?? STATUS_REQUEST_GRACE_MS)
+    );
+    try {
+      last = await draftApi.getTestRun(
+        draftId,
+        started.testRunId,
+        void 0,
+        AbortSignal.any([signal, requestTimeout])
+      );
+    } catch (error62) {
+      if (signal.aborted || !requestTimeout.aborted) throw error62;
+      return toFinished(base, last, "timed_out");
+    }
+    if (!OPEN_RUN_STATUSES.has(last.status)) {
+      return toFinished(base, last, toOutcome(last.status));
+    }
+    const remainingMs = deadline - Date.now();
+    if (remainingMs <= 0) {
+      return toFinished(base, last, "timed_out");
+    }
+    await wait2(Math.min(intervalMs, remainingMs), void 0, { signal });
+    intervalMs = Math.min(intervalMs * 2, intervals.max);
+  }
+}
+function toFinished(base, run, outcome) {
+  return {
+    action: "test_finished",
+    ...base,
+    outcome,
+    status: run?.status ?? "pending",
+    failedStep: run?.failedStep ?? null,
+    error: run?.failedStep?.error ?? (run ? getRunOutcomeReason(run) : null) ?? (run?.status === "data-expired" ? "Temporal no longer holds this run's history, so its outcome is unknown" : null),
+    result: run?.result ?? null
+  };
+}
+function toOutcome(status) {
+  switch (status) {
+    case "completed":
+      return "passed";
+    case "skipped":
+      return "skipped";
+    case "cancelled":
+      return "cancelled";
+    default:
+      return "failed";
+  }
+}
+function draftNotReadyError(message, draftId, scope) {
+  const flag = scopeFlag(scope);
+  return new CliError4("DRAFT_NOT_READY", message, {
+    hints: [
+      `See the issues: tda draft view ${draftId} ${flag}`,
+      `Bind connections: tda draft connect ${draftId} --auto ${flag}`
+    ]
+  });
+}
+function toDraftTestCliError(refusal, draftId, scope) {
+  const flag = scopeFlag(scope);
+  switch (refusal.code) {
+    case "draft_test_not_ready":
+      return draftNotReadyError(refusal.message, draftId, scope);
+    case "draft_test_payload_required":
+    case "draft_test_payload_filtered":
+      return new CliError4(refusal.code.toUpperCase(), refusal.message, {
+        hints: [
+          `Test with a real event: tda draft test ${draftId} --trigger <event> --payload-file <path> ${flag}`
+        ]
+      });
+    default:
+      return new CliError4(refusal.code.toUpperCase(), refusal.message);
+  }
+}
+function parseTriggerOption(value) {
+  return /^\d+$/.test(value) ? { index: Number(value) } : { event: value };
+}
+async function readTestPayloadFile(path) {
+  let content;
+  try {
+    content = await readFile3(path, "utf8");
+  } catch (error62) {
+    throw new CliError4(
+      "PAYLOAD_UNREADABLE",
+      `Could not read ${path}: ${getErrorMessage7(error62)}`
+    );
+  }
+  try {
+    return JSON.parse(content);
+  } catch (error62) {
+    throw new CliError4(
+      "PAYLOAD_UNREADABLE",
+      `${path} is not valid JSON: ${getErrorMessage7(error62)}`
+    );
+  }
+}
 
 // src/commands/draft/format.ts
 function formatDraftDelete(result) {
@@ -37246,6 +37550,72 @@ function describeDiff(diff) {
   if (diff.steps.reordered) parts.push("steps reordered");
   return parts.join("; ");
 }
+var MOCKED_CONNECTOR_CALLS_LINE = "Connector calls: mocked (simulated by a model; nothing was read from or written to your services)";
+function formatDraftTestRun(run) {
+  const reason = getRunOutcomeReason(run);
+  const lines = [
+    `Test run: ${run.id}`,
+    `Draft: ${run.draftId}`,
+    `Automation: ${run.automationId ?? "none (the draft creates a new one)"}`,
+    `Status: ${run.status}`,
+    MOCKED_CONNECTOR_CALLS_LINE,
+    `Created: ${run.createdAt}`,
+    `Updated: ${run.updatedAt}`
+  ];
+  if (run.failedStep) {
+    lines.push(
+      `Failed step: ${run.failedStep.stepId} (${run.failedStep.description})`,
+      `Error: ${run.failedStep.error ?? reason ?? "none reported"}`
+    );
+  } else if (reason) {
+    lines.push(`${run.status === "skipped" ? "Skip" : "Failure"} reason: ${reason}`);
+  }
+  lines.push(
+    `Result: ${run.result?.text ?? "none"}`,
+    `Steps: ${run.steps.length}`,
+    ...formatRunSteps(run.steps, { toolCallLabel: "Tool (mocked)" })
+  );
+  return lines.join("\n");
+}
+var INPUT_SOURCE_LABELS = {
+  schedule: "as a scheduled run",
+  "sample-event": "with the built-in sample event",
+  supplied: "with the supplied payload",
+  empty: "with an empty request body"
+};
+var OUTCOME_LABELS = {
+  passed: "passed",
+  failed: "failed",
+  skipped: "was skipped",
+  cancelled: "was cancelled",
+  timed_out: "did not finish before the timeout"
+};
+function formatDraftTest(result) {
+  const { trigger } = result;
+  const which = trigger.type === "webhook" ? `webhook ${trigger.event}` : trigger.type;
+  const lines = [
+    result.action === "test_started" ? `Started test run ${result.testRunId} for draft ${result.draftId}.` : `Test run ${result.testRunId} for draft ${result.draftId} ${OUTCOME_LABELS[result.outcome]}.`,
+    `Trigger: ${trigger.index} of ${trigger.count} (${which}), ${INPUT_SOURCE_LABELS[trigger.inputSource]}`
+  ];
+  if (result.action === "test_finished") {
+    if (result.outcome === "timed_out") lines.push(`Status: ${result.status}`);
+    if (result.failedStep) {
+      lines.push(
+        `Failed step: ${result.failedStep.stepId} (${result.failedStep.description})`
+      );
+    }
+    if (result.error)
+      lines.push(`${result.outcome === "skipped" ? "Reason" : "Error"}: ${result.error}`);
+    if (result.result) lines.push(`Result: ${result.result.text}`);
+  }
+  lines.push(MOCKED_CONNECTOR_CALLS_LINE, `Details: ${result.command}`);
+  if (trigger.count > 1) {
+    lines.push(
+      `This draft has ${trigger.count} triggers; test another with --trigger <index|event>.`
+    );
+  }
+  return lines.join("\n");
+}
 
 // src/commands/draft/validate-command.ts
 import { CliError as CliError5 } from "@doist/cli-core";
@@ -37300,8 +37670,10 @@ function formatManifestValidation(result) {
 }
 
 // src/commands/draft/index.ts
+var DEFAULT_TEST_WAIT = "10m";
+var TOKEN_LIFETIME_MARGIN_MS = 2 * 60 * 1e3;
 function registerDraftCommand(program) {
-  const draft = program.command("draft").description("Author and inspect automation drafts");
+  const draft = program.command("draft").description("Author, test and inspect automation drafts");
   registerDraftValidateCommand(draft);
   addWorkspaceScopeOptions(
     addCursorPaginationOptions(
@@ -37425,6 +37797,63 @@ function registerDraftCommand(program) {
       { spinner: options.yes === true ? "Publishing..." : "Loading draft..." }
     );
   });
+  addWorkspaceScopeOptions(
+    draft.command("test").description("Start a test run of a draft, with mocked connector calls").argument("<draft-id>", "Draft ID").option("--wait", "Wait for the run to end and exit 1 unless it passed").option(
+      "--timeout <duration>",
+      `How long --wait waits, such as 90s or 15m (default ${DEFAULT_TEST_WAIT})`
+    ).option(
+      "--trigger <index|event>",
+      "The trigger to test: its position in the manifest's triggers, or a webhook event"
+    ).option(
+      "--payload-file <path>",
+      "A JSON event to test with: a webhook trigger's event or an API trigger's body"
+    )
+  ).action(async (draftId, options, command) => {
+    await runApiCommand(
+      command,
+      async ({ api, signal }) => {
+        if (options.timeout !== void 0 && options.wait !== true) {
+          throw new Error("--timeout only applies with --wait.");
+        }
+        const timeoutMs = parseTestTimeout(options.timeout ?? DEFAULT_TEST_WAIT);
+        const draftApi = resolveDraftApi(api, await resolveWorkspaceScope(options), signal);
+        return startDraftTest(draftApi, {
+          draftId,
+          request: {
+            ...options.trigger !== void 0 ? { trigger: parseTriggerOption(options.trigger) } : {},
+            ...options.payloadFile !== void 0 ? { payload: await readTestPayloadFile(options.payloadFile) } : {}
+          },
+          wait: options.wait === true ? { timeoutMs } : null,
+          signal
+        });
+      },
+      { human: formatDraftTest },
+      {
+        spinner: options.wait === true ? "Testing draft..." : "Starting test run...",
+        minimumTokenLifetimeMs: options.wait === true ? tryParseTestTimeout(options.timeout ?? DEFAULT_TEST_WAIT) + TOKEN_LIFETIME_MARGIN_MS : void 0,
+        exitCode: (result) => result.action === "test_finished" && result.outcome !== "passed" ? 1 : void 0
+      }
+    );
+  });
+  addWorkspaceScopeOptions(
+    draft.command("test-run").description("Show a draft's test run with step and failure details").argument("<draft-id>", "Draft ID").argument("<run-id>", "Test run ID").option("--full", "Include raw step results and generated code in machine output")
+  ).action(async (draftId, runId, options, command) => {
+    await runApiCommand(
+      command,
+      async ({ api, signal }) => {
+        const draftApi = resolveDraftApi(api, await resolveWorkspaceScope(options), signal);
+        return draftApi.getTestRun(draftId, runId, {
+          includeGeneratedCode: options.full === true,
+          includeToolCallPreviews: true
+        });
+      },
+      {
+        human: formatDraftTestRun,
+        json: options.full === true ? void 0 : summarizeDraftTestRun
+      },
+      { spinner: "Loading test run..." }
+    );
+  });
   addWorkspaceScopeOptions(
     draft.command("delete").description("Delete a draft after previewing which one it is").argument("<draft-id>", "Draft ID").option("--yes", "Confirm deletion")
   ).action(async (draftId, options, command) => {
@@ -37461,6 +37890,20 @@ function streamDraftList(options, fetchPage) {
     async (args) => summarizeDraftListPage(await fetchPage(args))
   );
 }
+function tryParseTestTimeout(value) {
+  try {
+    return durationStringToMilliseconds(value);
+  } catch {
+    return 0;
+  }
+}
+function parseTestTimeout(value) {
+  try {
+    return durationStringToMilliseconds(value);
+  } catch {
+    throw new Error(`Invalid --timeout ${value}; use a duration such as 90s, 15m or 1h.`);
+  }
+}
 
 // src/commands/run/index.ts
 import { Option as Option7 } from "commander";