@vm0/cli 9.252.1 → 9.254.0

package/{workflow-W2HNGAVJ.js → workflow-M5KSFXFM.js}

@@ -19,14 +19,17 @@ import {
   listWorkflows,
   updateWorkflow,
   updateWorkflowAutomation
-} from "./chunk-FBISVSTZ.js";
-import "./chunk-OAESJHRL.js";
+} from "./chunk-RPYYZK6K.js";
+import "./chunk-5SWLOAHS.js";
 import "./chunk-SB7EZ2ZO.js";
 import {
   source_default,
   withErrorHandler
-} from "./chunk-7NPYHUEQ.js";
-import "./chunk-DK3C2ME6.js";
+} from "./chunk-7JATDT76.js";
+import {
+  decodeZeroTokenPayload,
+  isFeatureEnabled
+} from "./chunk-D4OTAABD.js";
 import {
   Command
 } from "./chunk-LD4ZVU4O.js";
@@ -620,6 +623,14 @@ function workflowAutomationKindLabel(automation) {
       return "Gmail label applied";
     case "github-label-applied":
       return "GitHub label applied";
+    case "github-deployment-status-created":
+      return "GitHub deployment status created";
+    case "github-issue-comment-created":
+      return "GitHub issue comment created";
+    case "github-pull-request-review-submitted":
+      return "GitHub pull request review submitted";
+    case "github-workflow-job-completed":
+      return "GitHub workflow job completed";
     case "github-workflow-run-completed":
       return "GitHub workflow completed";
     case "google-calendar-event-created":
@@ -689,20 +700,71 @@ function printWorkflowAutomationsTable(automations) {
     );
   }
 }
-function printGithubWorkflowRunFilters(automation) {
-  if (automation.kind !== "event" || automation.eventType !== "github-workflow-run-completed") {
+function printGithubFilters(automation) {
+  if (automation.kind !== "event") {
     return;
   }
   const printFilter = (label, values) => {
     console.log(`${`${label}:`.padEnd(14)}${values?.join(", ") ?? "any"}`);
   };
-  const { filters } = automation.eventConfig;
-  printFilter("Repositories", filters.repositories);
-  printFilter("Workflows", filters.workflows);
-  printFilter("Conclusions", filters.conclusions);
-  printFilter("Branches", filters.branches);
-  printFilter("Events", filters.events);
-  printFilter("Actors", filters.actors);
+  switch (automation.eventType) {
+    case "github-workflow-run-completed": {
+      const { filters } = automation.eventConfig;
+      printFilter("Repositories", filters.repositories);
+      printFilter("Workflows", filters.workflows);
+      printFilter("Conclusions", filters.conclusions);
+      printFilter("Branches", filters.branches);
+      printFilter("Events", filters.events);
+      printFilter("Actors", filters.actors);
+      return;
+    }
+    case "github-workflow-job-completed": {
+      const { filters } = automation.eventConfig;
+      printFilter("Repositories", filters.repositories);
+      printFilter("Workflows", filters.workflows);
+      printFilter("Jobs", filters.jobs);
+      printFilter("Conclusions", filters.conclusions);
+      printFilter("Branches", filters.branches);
+      printFilter("Runner labels", filters.runnerLabels);
+      printFilter("Runner groups", filters.runnerGroups);
+      return;
+    }
+    case "github-pull-request-review-submitted": {
+      const { filters } = automation.eventConfig;
+      printFilter("Repositories", filters.repositories);
+      printFilter("Review states", filters.reviewStates);
+      printFilter("Base branches", filters.baseBranches);
+      printFilter("Head branches", filters.headBranches);
+      printFilter("Authors", filters.trustedAuthors);
+      return;
+    }
+    case "github-deployment-status-created": {
+      const { filters } = automation.eventConfig;
+      printFilter("Repositories", filters.repositories);
+      printFilter("Environments", filters.environments);
+      printFilter("States", filters.states);
+      printFilter("Refs", filters.refs);
+      console.log(
+        `${"Production:".padEnd(14)}${filters.productionEnvironment === void 0 ? "any" : String(filters.productionEnvironment)}`
+      );
+      printFilter("Creators", filters.creators);
+      printFilter("Apps", filters.apps);
+      return;
+    }
+    case "github-issue-comment-created": {
+      const { filters } = automation.eventConfig;
+      printFilter("Repositories", filters.repositories);
+      console.log(
+        `${"Subject:".padEnd(14)}${formatGithubSubject(filters.subject)}`
+      );
+      printFilter("Authors", filters.trustedAuthors);
+      printFilter("Prefixes", filters.commentPrefixes);
+      return;
+    }
+    default: {
+      return;
+    }
+  }
 }
 function printWorkflowAutomationDetails(automation, options) {
   const status = automation.enabled ? source_default.green("enabled") : source_default.yellow("disabled");
@@ -734,7 +796,7 @@ function printWorkflowAutomationDetails(automation, options) {
       `${"Actor:".padEnd(14)}${automation.eventConfig.filters.actor.type}`
     );
   }
-  printGithubWorkflowRunFilters(automation);
+  printGithubFilters(automation);
   if (isGoogleCalendarAutomation(automation)) {
     console.log(
       `${"Calendar:".padEnd(14)}${automation.eventConfig.calendarId}`
@@ -1063,7 +1125,31 @@ var EVENT_KINDS = [
   "notion-page-content-updated",
   "webhook"
 ];
-var AUTOMATION_KINDS = [...SCHEDULE_KINDS, ...EVENT_KINDS];
+var GITHUB_WEBHOOK_EVENT_KINDS = [
+  "github-workflow-job-completed",
+  "github-pull-request-review-submitted",
+  "github-deployment-status-created",
+  "github-issue-comment-created"
+];
+function githubWebhookAutomationsEnabled() {
+  const payload = decodeZeroTokenPayload();
+  return isFeatureEnabled("githubWebhookAutomations" /* GithubWebhookAutomations */, {
+    userId: payload?.userId,
+    orgId: payload?.orgId
+  });
+}
+function automationKinds() {
+  return [
+    ...SCHEDULE_KINDS,
+    ...EVENT_KINDS,
+    ...githubWebhookAutomationsEnabled() ? GITHUB_WEBHOOK_EVENT_KINDS : []
+  ];
+}
+function githubWebhookEventKind(kind) {
+  return GITHUB_WEBHOOK_EVENT_KINDS.some((eventKind) => {
+    return eventKind === kind;
+  });
+}
 var EXACTLY_ONE_FLAG_MESSAGE = "Provide exactly one of --expr (cron), --at (once), --every (loop), Gmail match options, --label, --subject, --actor, --calendar-id, --page-url, --parent-page-url, or --database-url";
 function addGmailAutomationOptions(command) {
   return command.option(
@@ -1095,22 +1181,52 @@ function addGmailAutomationOptions(command) {
 function addGithubAutomationOptions(command) {
   return command.option(
     "--subject <subject>",
-    "GitHub subject filter for github-label-applied: both | issues | pull-requests"
+    "GitHub subject filter for label/comment automations: both | issues | pull-requests"
   ).option(
     "--actor <actor>",
     "GitHub actor filter: me | anyone for labels, or comma-separated logins for workflow runs"
   ).option(
     "--repository <repositories>",
-    "GitHub workflow run repositories, comma-separated owner/name values"
+    "GitHub repositories, comma-separated owner/name values"
   ).option(
     "--workflow <workflows>",
     "GitHub workflows, comma-separated IDs, names, or paths"
   ).option(
     "--conclusion <conclusions>",
-    "Workflow run conclusions, comma-separated values"
-  ).option("--branch <branches>", "Workflow run branches, comma-separated").option(
+    "Workflow run or job conclusions, comma-separated values"
+  ).option(
+    "--branch <branches>",
+    "Workflow run or job branches, comma-separated"
+  ).option(
     "--triggering-event <events>",
     "Workflow run triggering events, comma-separated"
+  ).option("--job <jobs>", "GitHub Actions job names or IDs, comma-separated").option("--runner-label <labels>", "Runner labels, comma-separated").option(
+    "--runner-group <groups>",
+    "Runner group names or IDs, comma-separated"
+  ).option(
+    "--review-state <states>",
+    "Review states: approved, changes_requested, commented, or any"
+  ).option(
+    "--base-branch <branches>",
+    "Pull request base branches, comma-separated"
+  ).option(
+    "--head-branch <branches>",
+    "Pull request head branches, comma-separated"
+  ).option(
+    "--trusted-author <logins>",
+    "Trusted GitHub author logins, comma-separated; omit to allow anyone"
+  ).option("--environment <names>", "Deployment environments, comma-separated").option("--deployment-state <states>", "Deployment states, comma-separated").option("--ref <refs>", "Deployment refs, comma-separated").option(
+    "--production-environment <value>",
+    "Deployment environment filter: true | false | any"
+  ).option(
+    "--creator <logins>",
+    "Deployment creator logins or IDs, comma-separated"
+  ).option(
+    "--app <apps>",
+    "Deployment GitHub App slugs, names, or IDs, comma-separated"
+  ).option(
+    "--comment-prefix <prefixes>",
+    "Required trimmed comment prefixes, comma-separated"
   );
 }
 function timezoneOrUtc(timezone) {
@@ -1245,7 +1361,7 @@ function buildSchedule(kind, options) {
       };
     default:
       throw new Error(
-        `Unknown automation kind: "${kind}". Use one of: ${AUTOMATION_KINDS.join(", ")}`
+        `Unknown automation kind: "${kind}". Use one of: ${automationKinds().join(", ")}`
       );
   }
 }
@@ -1258,8 +1374,56 @@ function hasGithubLabelAutomationOptions(options) {
 function hasGithubWorkflowRunSpecificOptions(options) {
   return options.repository !== void 0 || options.workflow !== void 0 || options.conclusion !== void 0 || options.branch !== void 0 || options.triggeringEvent !== void 0;
 }
+var GITHUB_AUTOMATION_OPTION_KEYS = [
+  "subject",
+  "actor",
+  "repository",
+  "workflow",
+  "job",
+  "conclusion",
+  "branch",
+  "triggeringEvent",
+  "runnerLabel",
+  "runnerGroup",
+  "reviewState",
+  "baseBranch",
+  "headBranch",
+  "trustedAuthor",
+  "environment",
+  "deploymentState",
+  "ref",
+  "productionEnvironment",
+  "creator",
+  "app",
+  "commentPrefix"
+];
+function githubOptionValue(options, key) {
+  return options[key];
+}
+function hasGithubWebhookOptions(options) {
+  return GITHUB_AUTOMATION_OPTION_KEYS.some((key) => {
+    return githubOptionValue(options, key) !== void 0;
+  });
+}
 function hasGithubAutomationOptions(options) {
-  return hasGithubLabelAutomationOptions(options) || hasGithubWorkflowRunSpecificOptions(options);
+  return hasGithubLabelAutomationOptions(options) || hasGithubWorkflowRunSpecificOptions(options) || hasGithubWebhookOptions(options);
+}
+function assertOnlyGithubAutomationOptions(options, allowed) {
+  const invalid = GITHUB_AUTOMATION_OPTION_KEYS.find((key) => {
+    return githubOptionValue(options, key) !== void 0 && !allowed.includes(key);
+  });
+  if (invalid) {
+    throw new Error(
+      `--${invalid.replace(/[A-Z]/g, (match) => {
+        return `-${match.toLowerCase()}`;
+      })} does not apply to this GitHub automation`
+    );
+  }
+}
+function hasAnyGithubAutomationOption(options, allowed) {
+  return allowed.some((key) => {
+    return githubOptionValue(options, key) !== void 0;
+  });
 }
 function hasCalendarAutomationOptions(options) {
   return options.calendarId !== void 0;
@@ -1380,7 +1544,7 @@ function parseGithubWorkflowRunFilter(value, fallback) {
     )
   );
   if (values.length === 0) {
-    throw new Error("GitHub workflow run filters cannot be empty; use any");
+    throw new Error("GitHub filters cannot be empty; use any");
   }
   return values;
 }
@@ -1400,6 +1564,64 @@ function parseGithubWorkflowRunConclusions(value, fallback) {
     );
   });
 }
+var GITHUB_PULL_REQUEST_REVIEW_STATES = ["approved", "changes_requested", "commented"];
+var GITHUB_DEPLOYMENT_STATES = [
+  "error",
+  "failure",
+  "inactive",
+  "in_progress",
+  "pending",
+  "queued",
+  "success",
+  "waiting"
+];
+function parseGithubReviewStates(value, fallback) {
+  const values = parseGithubWorkflowRunFilter(value, fallback);
+  if (!values) {
+    return void 0;
+  }
+  return values.map((state) => {
+    if (GITHUB_PULL_REQUEST_REVIEW_STATES.includes(
+      state
+    )) {
+      return state;
+    }
+    throw new Error(
+      `Invalid --review-state "${state}". Use one of: ${GITHUB_PULL_REQUEST_REVIEW_STATES.join(", ")}, any`
+    );
+  });
+}
+function parseGithubDeploymentStates(value, fallback) {
+  const values = parseGithubWorkflowRunFilter(value, fallback);
+  if (!values) {
+    return void 0;
+  }
+  return values.map((state) => {
+    if (GITHUB_DEPLOYMENT_STATES.includes(state)) {
+      return state;
+    }
+    throw new Error(
+      `Invalid --deployment-state "${state}". Use one of: ${GITHUB_DEPLOYMENT_STATES.join(", ")}, any`
+    );
+  });
+}
+function parseProductionEnvironment(value, fallback) {
+  if (value === void 0) {
+    return fallback;
+  }
+  switch (value.trim().toLowerCase()) {
+    case "any":
+      return void 0;
+    case "true":
+      return true;
+    case "false":
+      return false;
+    default:
+      throw new Error(
+        `Invalid --production-environment "${value}". Use true, false, or any`
+      );
+  }
+}
 function buildGithubWorkflowRunCompletedEventConfig(options, existing) {
   const filters = existing?.eventConfig.filters;
   return {
@@ -1427,6 +1649,119 @@ function buildGithubWorkflowRunCompletedEventConfig(options, existing) {
     }
   };
 }
+function buildGithubWorkflowJobCompletedEventConfig(options, existing) {
+  const filters = existing?.eventConfig.filters;
+  return {
+    provider: "github",
+    event: "workflow_job_completed",
+    filters: {
+      repositories: parseGithubWorkflowRunFilter(
+        options.repository,
+        filters?.repositories
+      ),
+      workflows: parseGithubWorkflowRunFilter(
+        options.workflow,
+        filters?.workflows
+      ),
+      jobs: parseGithubWorkflowRunFilter(options.job, filters?.jobs),
+      conclusions: parseGithubWorkflowRunConclusions(
+        options.conclusion,
+        filters?.conclusions
+      ),
+      branches: parseGithubWorkflowRunFilter(options.branch, filters?.branches),
+      runnerLabels: parseGithubWorkflowRunFilter(
+        options.runnerLabel,
+        filters?.runnerLabels
+      ),
+      runnerGroups: parseGithubWorkflowRunFilter(
+        options.runnerGroup,
+        filters?.runnerGroups
+      )
+    }
+  };
+}
+function buildGithubPullRequestReviewSubmittedEventConfig(options, existing) {
+  const filters = existing?.eventConfig.filters;
+  return {
+    provider: "github",
+    event: "pull_request_review_submitted",
+    filters: {
+      repositories: parseGithubWorkflowRunFilter(
+        options.repository,
+        filters?.repositories
+      ),
+      reviewStates: parseGithubReviewStates(
+        options.reviewState,
+        filters?.reviewStates
+      ),
+      baseBranches: parseGithubWorkflowRunFilter(
+        options.baseBranch,
+        filters?.baseBranches
+      ),
+      headBranches: parseGithubWorkflowRunFilter(
+        options.headBranch,
+        filters?.headBranches
+      ),
+      trustedAuthors: parseGithubWorkflowRunFilter(
+        options.trustedAuthor,
+        filters?.trustedAuthors
+      )
+    }
+  };
+}
+function buildGithubDeploymentStatusCreatedEventConfig(options, existing) {
+  const filters = existing?.eventConfig.filters;
+  return {
+    provider: "github",
+    event: "deployment_status_created",
+    filters: {
+      repositories: parseGithubWorkflowRunFilter(
+        options.repository,
+        filters?.repositories
+      ),
+      environments: parseGithubWorkflowRunFilter(
+        options.environment,
+        filters?.environments
+      ),
+      states: parseGithubDeploymentStates(
+        options.deploymentState,
+        filters?.states
+      ),
+      refs: parseGithubWorkflowRunFilter(options.ref, filters?.refs),
+      productionEnvironment: parseProductionEnvironment(
+        options.productionEnvironment,
+        filters?.productionEnvironment
+      ),
+      creators: parseGithubWorkflowRunFilter(
+        options.creator,
+        filters?.creators
+      ),
+      apps: parseGithubWorkflowRunFilter(options.app, filters?.apps)
+    }
+  };
+}
+function buildGithubIssueCommentCreatedEventConfig(options, existing) {
+  const filters = existing?.eventConfig.filters;
+  return {
+    provider: "github",
+    event: "issue_comment_created",
+    filters: {
+      repositories: parseGithubWorkflowRunFilter(
+        options.repository,
+        filters?.repositories
+      ),
+      subject: parseGithubSubject(options.subject, filters?.subject ?? "both"),
+      trustedAuthors: parseGithubWorkflowRunFilter(
+        options.trustedAuthor,
+        filters?.trustedAuthors
+      ),
+      commentPrefixes: parseGithubWorkflowRunFilter(
+        options.commentPrefix,
+        filters?.commentPrefixes
+      )
+    }
+  };
+}
 function buildGmailNewMessageCreateRequest(options) {
   assertNoScheduleAddOptions(options);
   if (hasGmailLabelOption(options)) {
@@ -1471,6 +1806,7 @@ function buildGithubLabelAppliedCreateRequest(options) {
       "Workflow run filter flags only apply to github-workflow-run-completed automations"
     );
   }
+  assertOnlyGithubAutomationOptions(options, ["subject", "actor"]);
   return {
     kind: "event",
     eventType: "github-label-applied",
@@ -1489,6 +1825,14 @@ function buildGithubWorkflowRunCompletedCreateRequest(options) {
       "--subject only applies to github-label-applied automations"
     );
   }
+  assertOnlyGithubAutomationOptions(options, [
+    "repository",
+    "workflow",
+    "conclusion",
+    "branch",
+    "triggeringEvent",
+    "actor"
+  ]);
   assertNoCalendarAutomationOptions(options);
   assertNoNotionAutomationOptions(options);
   return {
@@ -1497,6 +1841,76 @@ function buildGithubWorkflowRunCompletedCreateRequest(options) {
     eventConfig: buildGithubWorkflowRunCompletedEventConfig(options)
   };
 }
+function assertGithubWebhookCreateOptions(options, allowed) {
+  assertNoScheduleAddOptions(options);
+  if (hasGmailAutomationOptions(options) || hasGmailLabelOption(options)) {
+    throw new Error(
+      "Gmail automation flags only apply to Gmail event automations"
+    );
+  }
+  assertNoCalendarAutomationOptions(options);
+  assertNoNotionAutomationOptions(options);
+  assertOnlyGithubAutomationOptions(options, allowed);
+}
+function buildGithubWorkflowJobCompletedCreateRequest(options) {
+  assertGithubWebhookCreateOptions(options, [
+    "repository",
+    "workflow",
+    "job",
+    "conclusion",
+    "branch",
+    "runnerLabel",
+    "runnerGroup"
+  ]);
+  return {
+    kind: "event",
+    eventType: "github-workflow-job-completed",
+    eventConfig: buildGithubWorkflowJobCompletedEventConfig(options)
+  };
+}
+function buildGithubPullRequestReviewSubmittedCreateRequest(options) {
+  assertGithubWebhookCreateOptions(options, [
+    "repository",
+    "reviewState",
+    "baseBranch",
+    "headBranch",
+    "trustedAuthor"
+  ]);
+  return {
+    kind: "event",
+    eventType: "github-pull-request-review-submitted",
+    eventConfig: buildGithubPullRequestReviewSubmittedEventConfig(options)
+  };
+}
+function buildGithubDeploymentStatusCreatedCreateRequest(options) {
+  assertGithubWebhookCreateOptions(options, [
+    "repository",
+    "environment",
+    "deploymentState",
+    "ref",
+    "productionEnvironment",
+    "creator",
+    "app"
+  ]);
+  return {
+    kind: "event",
+    eventType: "github-deployment-status-created",
+    eventConfig: buildGithubDeploymentStatusCreatedEventConfig(options)
+  };
+}
+function buildGithubIssueCommentCreatedCreateRequest(options) {
+  assertGithubWebhookCreateOptions(options, [
+    "repository",
+    "subject",
+    "trustedAuthor",
+    "commentPrefix"
+  ]);
+  return {
+    kind: "event",
+    eventType: "github-issue-comment-created",
+    eventConfig: buildGithubIssueCommentCreatedEventConfig(options)
+  };
+}
 function buildGoogleCalendarEventCreateRequest(eventType, options) {
   assertNoScheduleAddOptions(options);
   if (hasGmailAutomationOptions(options) || hasGmailLabelOption(options) || hasGithubAutomationOptions(options) || hasNotionAutomationOptions(options)) {
@@ -1657,6 +2071,14 @@ function buildCreateRequest(kind, options) {
       return buildGithubLabelAppliedCreateRequest(options);
     case "github-workflow-run-completed":
       return buildGithubWorkflowRunCompletedCreateRequest(options);
+    case "github-workflow-job-completed":
+      return buildGithubWorkflowJobCompletedCreateRequest(options);
+    case "github-pull-request-review-submitted":
+      return buildGithubPullRequestReviewSubmittedCreateRequest(options);
+    case "github-deployment-status-created":
+      return buildGithubDeploymentStatusCreatedCreateRequest(options);
+    case "github-issue-comment-created":
+      return buildGithubIssueCommentCreatedCreateRequest(options);
     case "google-calendar-event-created":
       return buildGoogleCalendarEventCreateRequest(kind, options);
     case "google-calendar-event-updated":
@@ -1675,6 +2097,125 @@ function buildCreateRequest(kind, options) {
       return buildScheduleCreateRequest(kind, options);
   }
 }
+function buildGithubWorkflowEventUpdate(options, existing) {
+  switch (existing.eventType) {
+    case "github-workflow-run-completed": {
+      if (hasGmailAutomationOptions(options) || hasGmailLabelOption(options) || options.subject !== void 0) {
+        throw new Error(
+          "Gmail, label, and subject flags do not apply to GitHub workflow run automations"
+        );
+      }
+      if (!hasGithubAutomationOptions(options)) {
+        throw new Error(
+          "Provide a GitHub workflow run filter flag; use any to clear a filter"
+        );
+      }
+      assertOnlyGithubAutomationOptions(options, [
+        "repository",
+        "workflow",
+        "conclusion",
+        "branch",
+        "triggeringEvent",
+        "actor"
+      ]);
+      return {
+        eventConfig: buildGithubWorkflowRunCompletedEventConfig(
+          options,
+          existing
+        )
+      };
+    }
+    case "github-workflow-job-completed": {
+      const allowed = [
+        "repository",
+        "workflow",
+        "job",
+        "conclusion",
+        "branch",
+        "runnerLabel",
+        "runnerGroup"
+      ];
+      assertOnlyGithubAutomationOptions(options, allowed);
+      if (!hasAnyGithubAutomationOption(options, allowed)) {
+        throw new Error(
+          "Provide a GitHub workflow job filter flag; use any to clear a filter"
+        );
+      }
+      return {
+        eventConfig: buildGithubWorkflowJobCompletedEventConfig(
+          options,
+          existing
+        )
+      };
+    }
+    case "github-pull-request-review-submitted": {
+      const allowed = [
+        "repository",
+        "reviewState",
+        "baseBranch",
+        "headBranch",
+        "trustedAuthor"
+      ];
+      assertOnlyGithubAutomationOptions(options, allowed);
+      if (!hasAnyGithubAutomationOption(options, allowed)) {
+        throw new Error(
+          "Provide a GitHub pull request review filter flag; use any to clear a filter"
+        );
+      }
+      return {
+        eventConfig: buildGithubPullRequestReviewSubmittedEventConfig(
+          options,
+          existing
+        )
+      };
+    }
+    case "github-deployment-status-created": {
+      const allowed = [
+        "repository",
+        "environment",
+        "deploymentState",
+        "ref",
+        "productionEnvironment",
+        "creator",
+        "app"
+      ];
+      assertOnlyGithubAutomationOptions(options, allowed);
+      if (!hasAnyGithubAutomationOption(options, allowed)) {
+        throw new Error(
+          "Provide a GitHub deployment status filter flag; use any to clear a filter"
+        );
+      }
+      return {
+        eventConfig: buildGithubDeploymentStatusCreatedEventConfig(
+          options,
+          existing
+        )
+      };
+    }
+    case "github-issue-comment-created": {
+      const allowed = [
+        "repository",
+        "subject",
+        "trustedAuthor",
+        "commentPrefix"
+      ];
+      assertOnlyGithubAutomationOptions(options, allowed);
+      if (!hasAnyGithubAutomationOption(options, allowed)) {
+        throw new Error(
+          "Provide a GitHub issue comment filter flag; use any to clear a filter"
+        );
+      }
+      return {
+        eventConfig: buildGithubIssueCommentCreatedEventConfig(
+          options,
+          existing
+        )
+      };
+    }
+    default:
+      return void 0;
+  }
+}
 function buildEventUpdate(options, existing) {
   const hasGmailOptions = hasGmailAutomationOptions(options);
   const hasLabelOption = hasGmailLabelOption(options);
@@ -1693,6 +2234,7 @@ function buildEventUpdate(options, existing) {
         "Workflow run filter flags only apply to github-workflow-run-completed automations"
       );
     }
+    assertOnlyGithubAutomationOptions(options, ["subject", "actor"]);
     if (!hasLabelOption && !hasGithubOptions) {
       throw new Error(
         "Provide --label, --subject, or --actor for github-label-applied automations"
@@ -1702,23 +2244,12 @@ function buildEventUpdate(options, existing) {
       eventConfig: buildGithubLabelAppliedEventConfig(options, existing)
     };
   }
-  if (existing.eventType === "github-workflow-run-completed") {
-    if (hasGmailOptions || hasLabelOption || options.subject !== void 0) {
-      throw new Error(
-        "Gmail, label, and subject flags do not apply to GitHub workflow run automations"
-      );
-    }
-    if (!hasGithubAutomationOptions(options)) {
-      throw new Error(
-        "Provide a GitHub workflow run filter flag; use any to clear a filter"
-      );
-    }
-    return {
-      eventConfig: buildGithubWorkflowRunCompletedEventConfig(
-        options,
-        existing
-      )
-    };
+  const githubWorkflowUpdate = buildGithubWorkflowEventUpdate(
+    options,
+    existing
+  );
+  if (githubWorkflowUpdate) {
+    return githubWorkflowUpdate;
   }
   if (hasGithubOptions) {
     throw new Error(
@@ -1784,7 +2315,7 @@ function buildUpdate(options, existing) {
 }
 var addCommand = addGithubAutomationOptions(
   addGmailAutomationOptions(
-    new Command().name("add").description("Add an automation to a workflow").argument("<workflow>", "Workflow ID or name").argument("<kind>", `Automation type: ${AUTOMATION_KINDS.join(" | ")}`).option("--expr <expression>", 'Cron expression for kind "cron"').option("--at <iso-time>", 'Fire time for kind "once"').option(
+    new Command().name("add").description("Add an automation to a workflow").argument("<workflow>", "Workflow ID or name").argument("<kind>", `Automation type: ${automationKinds().join(" | ")}`).option("--expr <expression>", 'Cron expression for kind "cron"').option("--at <iso-time>", 'Fire time for kind "once"').option(
       "--every <duration>",
       'Interval for kind "loop" (e.g. 15m, 1h, 90s)'
     ).option(
@@ -1835,6 +2366,11 @@ Notes:
 ).action(
   withErrorHandler(
     async (workflowRef, kind, options) => {
+      if (githubWebhookEventKind(kind) && !githubWebhookAutomationsEnabled()) {
+        throw new Error(
+          "GitHub webhook automations are not enabled for this workspace"
+        );
+      }
       if (options.timezone && kind !== "cron" && kind !== "once" && kind !== "gmail-new-message") {
         throw new Error(
           "--timezone only applies to cron and once automations"
@@ -1957,4 +2493,4 @@ Examples:
 export {
   zeroWorkflowCommand
 };
-//# sourceMappingURL=workflow-W2HNGAVJ.js.map
+//# sourceMappingURL=workflow-M5KSFXFM.js.map