@vm0/cli 9.213.5 → 9.213.7

package/workflow-DR5N3QR7.js

@@ -0,0 +1,1218 @@
+#!/usr/bin/env node
+import { createRequire as __createRequire } from "node:module";
+const require = __createRequire(import.meta.url);
+import {
+  formatDurationSeconds,
+  parseDurationSeconds
+} from "./chunk-J7RLLIWI.js";
+import {
+  formatRelativeTime
+} from "./chunk-RGP625TN.js";
+import {
+  isInteractive,
+  promptConfirm
+} from "./chunk-JFY6GK7Y.js";
+import {
+  copyWorkflow,
+  createWorkflow,
+  createWorkflowTrigger,
+  deleteWorkflow,
+  deleteWorkflowTrigger,
+  disableWorkflowTrigger,
+  enableWorkflowTrigger,
+  getWorkflow,
+  getWorkflowTrigger,
+  listWorkflowTriggers,
+  listWorkflows,
+  runWorkflow,
+  updateWorkflow,
+  updateWorkflowTrigger
+} from "./chunk-3WC7YF42.js";
+import "./chunk-LTDQISD7.js";
+import {
+  withErrorHandler
+} from "./chunk-3F4RFLPX.js";
+import {
+  source_default
+} from "./chunk-JUTUEPIR.js";
+import "./chunk-LRHXR7JT.js";
+import {
+  Command
+} from "./chunk-B3W2RUBP.js";
+import {
+  init_esm_shims
+} from "./chunk-DIRAZ3YX.js";
+
+// src/commands/zero/workflow/index.ts
+init_esm_shims();
+
+// src/commands/zero/workflow/create.ts
+init_esm_shims();
+import { readFileSync as readFileSync2 } from "fs";
+
+// src/lib/skill-directory.ts
+init_esm_shims();
+import { readFileSync, readdirSync } from "fs";
+import { join } from "path";
+var IGNORED_NAMES = /* @__PURE__ */ new Set(["node_modules", ".git", ".DS_Store"]);
+function readSupplementaryFiles(dirPath) {
+  const files = [];
+  function walk(dir, prefix) {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") || IGNORED_NAMES.has(entry.name)) continue;
+      const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        walk(join(dir, entry.name), relPath);
+      } else {
+        if (relPath === "SKILL.md") {
+          throw new Error(
+            "SKILL.md is reserved and generated automatically; remove it from the directory"
+          );
+        }
+        files.push({
+          path: relPath,
+          content: readFileSync(join(dir, entry.name), "utf-8")
+        });
+      }
+    }
+  }
+  walk(dirPath, "");
+  return files;
+}
+
+// src/commands/zero/workflow/format.ts
+init_esm_shims();
+function formatWorkflowAgentName(workflow) {
+  return workflow.agentDisplayName ?? workflow.agentName ?? "-";
+}
+
+// src/commands/zero/workflow/create.ts
+var createCommand = new Command().name("create").description("Create a workflow under an agent").argument("<name>", "Workflow name (lowercase alphanumeric with hyphens)").option(
+  "--agent <id>",
+  "Agent ID to host the workflow (defaults to ZERO_AGENT_ID)"
+).option("--instruction <text>", "Workflow instruction text").option(
+  "--instruction-file <path>",
+  "Path to a file containing the instruction"
+).option(
+  "--dir <path>",
+  "Path to a directory of supplementary files (SKILL.md is not allowed)"
+).option("--display-name <name>", "Workflow display name").option("--description <text>", "Workflow description").option("--public", "Create as an org-public workflow").addHelpText(
+  "after",
+  `
+Examples:
+  zero workflow create my-workflow --agent <agent-id> --instruction "Summarize the inbox"
+  zero workflow create my-workflow --instruction-file ./instruction.md
+  zero workflow create my-workflow --instruction "Do things" --dir ./workflows/my-workflow/files/
+  zero workflow create shared-workflow --instruction "Shared logic" --public
+
+Notes:
+  - A workflow belongs to exactly one agent; provide --agent or set ZERO_AGENT_ID
+  - SKILL.md is synthesized from (name, description, instruction); do not include it
+  - --dir uploads supplementary files only; any SKILL.md is rejected
+  - New workflows are private by default
+  - Copy a workflow onto another agent: zero workflow copy <workflow-id> --to-agent <agent-id>`
+).action(
+  withErrorHandler(
+    async (name, options) => {
+      const agentId = options.agent ?? process.env.ZERO_AGENT_ID;
+      if (!agentId) {
+        console.error(source_default.red("\u2717 --agent is required"));
+        console.error(
+          source_default.dim(
+            "  Provide --agent <agent-id> or run inside an agent sandbox (ZERO_AGENT_ID)"
+          )
+        );
+        process.exit(1);
+      }
+      if (options.instruction && options.instructionFile) {
+        console.error(
+          source_default.red("\u2717 Use either --instruction or --instruction-file")
+        );
+        console.error(source_default.dim("  Provide only one instruction source"));
+        process.exit(1);
+      }
+      const instruction = options.instructionFile ? readFileSync2(options.instructionFile, "utf-8") : options.instruction;
+      const files = options.dir ? readSupplementaryFiles(options.dir) : void 0;
+      const workflow = await createWorkflow({
+        agentId,
+        chatThreadId: process.env.ZERO_CHAT_THREAD_ID || void 0,
+        name,
+        instruction,
+        files,
+        displayName: options.displayName,
+        description: options.description,
+        visibility: options.public ? "public" : void 0
+      });
+      console.log(source_default.green(`\u2713 Workflow "${workflow.name}" created`));
+      console.log(`  ID:           ${workflow.id}`);
+      console.log(`  Name:         ${workflow.name}`);
+      console.log(`  Agent Name:   ${formatWorkflowAgentName(workflow)}`);
+      console.log(`  Agent ID:     ${workflow.agentId}`);
+      console.log(`  Visibility:   ${workflow.visibility}`);
+      if (files) {
+        console.log(`  Files:        ${files.length} file(s)`);
+      }
+      if (workflow.displayName) {
+        console.log(`  Display Name: ${workflow.displayName}`);
+      }
+      if (workflow.description) {
+        console.log(`  Description:  ${workflow.description}`);
+      }
+      console.log();
+      console.log(
+        `Copy onto another agent: zero workflow copy ${workflow.id} --to-agent <agent-id>`
+      );
+    }
+  )
+);
+
+// src/commands/zero/workflow/edit.ts
+init_esm_shims();
+import { readFileSync as readFileSync3 } from "fs";
+var editCommand = new Command().name("edit").description("Update a workflow's instruction, files, or metadata").argument("<workflowId>", "Workflow ID").option("--instruction <text>", "New instruction text").option(
+  "--instruction-file <path>",
+  "Path to a file containing the instruction"
+).option(
+  "--dir <path>",
+  "Path to a directory of supplementary files (SKILL.md is not allowed)"
+).option("--display-name <name>", "New display name").option("--description <text>", "New description").addHelpText(
+  "after",
+  `
+Examples:
+  zero workflow edit <workflow-id> --instruction "New steps"
+  zero workflow edit <workflow-id> --instruction-file ./instruction.md
+  zero workflow edit <workflow-id> --dir ./workflows/my-workflow/files/
+  zero workflow edit <workflow-id> --display-name "My Workflow" --description "Does things"
+
+Notes:
+  - SKILL.md is synthesized automatically; --dir uploads supplementary files only
+  - At least one of --instruction, --instruction-file, --dir, --display-name, or --description is required`
+).action(
+  withErrorHandler(
+    async (workflowId, options) => {
+      if (options.instruction && options.instructionFile) {
+        console.error(
+          source_default.red("\u2717 Use either --instruction or --instruction-file")
+        );
+        console.error(source_default.dim("  Provide only one instruction source"));
+        process.exit(1);
+      }
+      const instruction = options.instructionFile ? readFileSync3(options.instructionFile, "utf-8") : options.instruction;
+      const files = options.dir ? readSupplementaryFiles(options.dir) : void 0;
+      if (instruction === void 0 && files === void 0 && options.displayName === void 0 && options.description === void 0) {
+        console.error(source_default.red("\u2717 Nothing to update"));
+        console.error(
+          source_default.dim(
+            "  Provide --instruction, --instruction-file, --dir, --display-name, or --description"
+          )
+        );
+        process.exit(1);
+      }
+      const workflow = await updateWorkflow(workflowId, {
+        instruction,
+        files,
+        displayName: options.displayName,
+        description: options.description
+      });
+      console.log(source_default.green(`\u2713 Workflow "${workflow.name}" updated`));
+      if (instruction !== void 0) {
+        console.log(`  Instruction:  updated`);
+      }
+      if (files) {
+        console.log(`  Files:        ${files.length} file(s)`);
+      }
+      if (options.displayName !== void 0) {
+        console.log(`  Display Name: ${workflow.displayName ?? "-"}`);
+      }
+      if (options.description !== void 0) {
+        console.log(`  Description:  ${workflow.description ?? "-"}`);
+      }
+    }
+  )
+);
+
+// src/commands/zero/workflow/view.ts
+init_esm_shims();
+var viewCommand = new Command().name("view").description("View a workflow").argument("<workflowId>", "Workflow ID").addHelpText(
+  "after",
+  `
+Examples:
+  zero workflow view <workflow-id>`
+).action(
+  withErrorHandler(async (workflowId) => {
+    const workflow = await getWorkflow(workflowId);
+    console.log(source_default.bold(workflow.name));
+    if (workflow.displayName) console.log(source_default.dim(workflow.displayName));
+    console.log();
+    console.log(`ID:           ${workflow.id}`);
+    console.log(`Name:         ${workflow.name}`);
+    console.log(`Visibility:   ${workflow.visibility}`);
+    console.log(`Agent Name:   ${formatWorkflowAgentName(workflow)}`);
+    console.log(`Agent ID:     ${workflow.agentId}`);
+    if (workflow.displayName)
+      console.log(`Display Name: ${workflow.displayName}`);
+    if (workflow.description)
+      console.log(`Description:  ${workflow.description}`);
+    if (workflow.files && workflow.files.length > 0) {
+      console.log();
+      console.log(source_default.dim("\u2500\u2500 Files \u2500\u2500"));
+      for (const f of workflow.files) {
+        console.log(`  ${f.path} (${f.size} bytes)`);
+      }
+    }
+    console.log();
+    if (workflow.instruction) {
+      console.log(source_default.dim("\u2500\u2500 Instruction \u2500\u2500"));
+      console.log(workflow.instruction);
+    } else {
+      console.log(source_default.dim("No instruction"));
+    }
+  })
+);
+
+// src/commands/zero/workflow/list.ts
+init_esm_shims();
+var listCommand = new Command().name("list").alias("ls").description("List visible workflows, optionally scoped to one agent").option("--agent <id>", "Only list workflows hosted by this agent").addHelpText(
+  "after",
+  `
+Examples:
+  zero workflow list
+  zero workflow list --agent <agent-id>`
+).action(
+  withErrorHandler(async (options) => {
+    const workflows = await listWorkflows({ agentId: options.agent });
+    if (workflows.length === 0) {
+      console.log(source_default.dim("No workflows found"));
+      console.log(
+        source_default.dim(
+          "  Create one with: zero workflow create <name> --agent <agent-id> --instruction <text>"
+        )
+      );
+      return;
+    }
+    const idWidth = Math.max(
+      2,
+      ...workflows.map((s) => {
+        return s.id.length;
+      })
+    );
+    const nameWidth = Math.max(
+      4,
+      ...workflows.map((s) => {
+        return s.name.length;
+      })
+    );
+    const agentWidth = Math.max(
+      10,
+      ...workflows.map((s) => {
+        return formatWorkflowAgentName(s).length;
+      })
+    );
+    const agentIdWidth = Math.max(
+      8,
+      ...workflows.map((s) => {
+        return s.agentId.length;
+      })
+    );
+    const header = [
+      "ID".padEnd(idWidth),
+      "NAME".padEnd(nameWidth),
+      "VISIBILITY".padEnd(10),
+      "AGENT NAME".padEnd(agentWidth),
+      "AGENT ID".padEnd(agentIdWidth),
+      "DESCRIPTION"
+    ].join("  ");
+    console.log(source_default.dim(header));
+    for (const workflow of workflows) {
+      const row = [
+        workflow.id.padEnd(idWidth),
+        workflow.name.padEnd(nameWidth),
+        workflow.visibility.padEnd(10),
+        formatWorkflowAgentName(workflow).padEnd(agentWidth),
+        workflow.agentId.padEnd(agentIdWidth),
+        workflow.description ?? "-"
+      ].join("  ");
+      console.log(row);
+    }
+  })
+);
+
+// src/commands/zero/workflow/delete.ts
+init_esm_shims();
+var deleteCommand = new Command().name("delete").alias("rm").description("Delete a workflow").argument("<workflowId>", "Workflow ID").option("-y, --yes", "Skip confirmation prompt").addHelpText(
+  "after",
+  `
+Examples:
+  zero workflow delete <workflow-id>
+  zero workflow delete <workflow-id> -y
+
+Notes:
+  - Use -y to skip confirmation in non-interactive mode`
+).action(
+  withErrorHandler(async (workflowId, options) => {
+    const workflow = await getWorkflow(workflowId);
+    if (!options.yes) {
+      if (!isInteractive()) {
+        throw new Error("--yes flag is required in non-interactive mode");
+      }
+      const confirmed = await promptConfirm(
+        `Delete workflow '${workflow.name}'?`,
+        false
+      );
+      if (!confirmed) {
+        console.log(source_default.dim("Cancelled"));
+        return;
+      }
+    }
+    await deleteWorkflow(workflowId);
+    console.log(source_default.green(`\u2713 Workflow "${workflow.name}" deleted`));
+  })
+);
+
+// src/commands/zero/workflow/copy.ts
+init_esm_shims();
+var copyCommand = new Command().name("copy").description("Copy (fork) a workflow onto another agent").argument("<workflowId>", "Workflow ID to copy").requiredOption("--to-agent <agent-id>", "Target agent ID").addHelpText(
+  "after",
+  `
+Examples:
+  zero workflow copy <workflow-id> --to-agent <agent-id>`
+).action(
+  withErrorHandler(
+    async (workflowId, options) => {
+      const workflow = await copyWorkflow(workflowId, options.toAgent);
+      console.log(source_default.green(`\u2713 Workflow "${workflow.name}" copied`));
+      console.log(`  ID:           ${workflow.id}`);
+      console.log(`  Agent Name:   ${formatWorkflowAgentName(workflow)}`);
+      console.log(`  Agent ID:     ${workflow.agentId}`);
+      console.log();
+      console.log(`View it: zero workflow view ${workflow.id}`);
+    }
+  )
+);
+
+// src/commands/zero/workflow/run.ts
+init_esm_shims();
+var runCommand = new Command().name("run").description("Run a workflow once in a new chat thread").argument("<workflowId>", "Workflow ID").addHelpText(
+  "after",
+  `
+Examples:
+  zero workflow run <workflow-id>`
+).action(
+  withErrorHandler(async (workflowId) => {
+    const result = await runWorkflow(workflowId);
+    console.log(source_default.green("\u2713 Workflow run started"));
+    console.log(`  Run ID:        ${result.runId}`);
+    console.log(`  Chat Thread:   ${result.chatThreadId}`);
+    console.log();
+    console.log(`Stream logs: zero logs ${result.runId}`);
+  })
+);
+
+// src/commands/zero/workflow/trigger/index.ts
+init_esm_shims();
+
+// src/commands/zero/workflow/trigger/display.ts
+init_esm_shims();
+var GMAIL_TEXT_FIELDS = [
+  "from",
+  "subject",
+  "body",
+  "to",
+  "cc"
+];
+function isWebhookTrigger(trigger) {
+  return trigger.kind === "event" && trigger.eventType === "webhook-received";
+}
+function quote(value) {
+  return `"${value}"`;
+}
+function quoteList(values) {
+  return values.map(quote).join(", ");
+}
+function textMatcherParts(field, matcher) {
+  const parts = [];
+  if (matcher.contains) {
+    parts.push(`${field} contains ${quote(matcher.contains)}`);
+  }
+  if (matcher.containsAny) {
+    parts.push(`${field} contains any of ${quoteList(matcher.containsAny)}`);
+  }
+  if (matcher.doesNotContain) {
+    parts.push(`${field} does not contain ${quote(matcher.doesNotContain)}`);
+  }
+  if (matcher.doesNotContainAny) {
+    parts.push(
+      `${field} does not contain any of ${quoteList(matcher.doesNotContainAny)}`
+    );
+  }
+  return parts;
+}
+function formatGmailMatchSummary(config) {
+  const match = config.match;
+  if (!match) {
+    return "all inbound messages";
+  }
+  const parts = [];
+  for (const field of GMAIL_TEXT_FIELDS) {
+    const matcher = match[field];
+    if (matcher) {
+      parts.push(...textMatcherParts(field, matcher));
+    }
+  }
+  return parts.length > 0 ? parts.join("; ") : "all inbound messages";
+}
+function formatWorkflowTriggerEntry(trigger) {
+  if (trigger.kind === "event" && trigger.eventType === "gmail-new-message") {
+    return `Gmail new message: ${formatGmailMatchSummary(trigger.eventConfig)}`;
+  }
+  if (trigger.kind === "event" && trigger.eventType === "gmail-label-applied") {
+    return `Gmail label applied: ${quote(trigger.eventConfig.labelName)}`;
+  }
+  if (isWebhookTrigger(trigger)) {
+    return `Webhook: ${trigger.webhookUrl}`;
+  }
+  const { schedule } = trigger;
+  switch (schedule.type) {
+    case "cron":
+      return `${schedule.cronExpression} (${schedule.timezone})`;
+    case "once":
+      return `at ${schedule.atTime} (${schedule.timezone})`;
+    case "loop":
+      return `every ${formatDurationSeconds(schedule.intervalSeconds)}`;
+  }
+}
+function formatRunTime(value) {
+  return value ? formatRelativeTime(value) : source_default.dim("-");
+}
+function signedCurlExample(trigger) {
+  const secret = trigger.webhookSecret ?? "<signing-secret>";
+  return [
+    `BODY='{"hello":"world"}'`,
+    "TIMESTAMP=$(date +%s)",
+    `SIGNATURE=$(printf "%s.%s" "$TIMESTAMP" "$BODY" | openssl dgst -sha256 -hmac "${secret}" -hex | awk '{print $2}')`,
+    `curl -X POST "${trigger.webhookUrl}" \\`,
+    '  -H "Content-Type: application/json" \\',
+    '  -H "X-VM0-Timestamp: $TIMESTAMP" \\',
+    '  -H "X-VM0-Signature: $SIGNATURE" \\',
+    '  --data "$BODY"'
+  ].join("\n");
+}
+function printWorkflowTriggersTable(triggers) {
+  const idWidth = Math.max(
+    2,
+    ...triggers.map((trigger) => {
+      return trigger.id.length;
+    })
+  );
+  const scheduleWidth = Math.max(
+    7,
+    ...triggers.map((trigger) => {
+      return formatWorkflowTriggerEntry(trigger).length;
+    })
+  );
+  console.log(
+    source_default.dim(
+      [
+        "ID".padEnd(idWidth),
+        "STATUS".padEnd(8),
+        "TRIGGER".padEnd(scheduleWidth),
+        "NEXT RUN"
+      ].join("  ")
+    )
+  );
+  for (const trigger of triggers) {
+    const status = trigger.enabled ? source_default.green("enabled") : source_default.yellow("disabled");
+    console.log(
+      [
+        trigger.id.padEnd(idWidth),
+        status.padEnd(8 + (trigger.enabled ? 0 : 2)),
+        formatWorkflowTriggerEntry(trigger).padEnd(scheduleWidth),
+        formatRunTime(trigger.nextRunAt)
+      ].join("  ")
+    );
+  }
+}
+function printWorkflowTriggerDetails(trigger, options) {
+  const status = trigger.enabled ? source_default.green("enabled") : source_default.yellow("disabled");
+  console.log(`${"Kind:".padEnd(14)}${trigger.kind}`);
+  console.log(`${"ID:".padEnd(14)}${trigger.id}`);
+  if (options?.workflowRef) {
+    console.log(`${"Workflow:".padEnd(14)}${options.workflowRef}`);
+  }
+  console.log(`${"Status:".padEnd(14)}${status}`);
+  console.log(
+    `${"Trigger:".padEnd(14)}${trigger.kind === "event" ? trigger.eventType === "gmail-new-message" ? "Gmail new message" : trigger.eventType === "gmail-label-applied" ? "Gmail label applied" : "Webhook" : formatWorkflowTriggerEntry(trigger)}`
+  );
+  if (trigger.kind === "event" && trigger.eventType === "gmail-new-message") {
+    console.log(
+      `${"Match:".padEnd(14)}${formatGmailMatchSummary(trigger.eventConfig)}`
+    );
+  }
+  if (trigger.kind === "event" && trigger.eventType === "gmail-label-applied") {
+    console.log(`${"Label:".padEnd(14)}${trigger.eventConfig.labelName}`);
+  }
+  if (isWebhookTrigger(trigger)) {
+    console.log(`${"Webhook URL:".padEnd(14)}${trigger.webhookUrl}`);
+    console.log(
+      `${"Secret:".padEnd(14)}${source_default.dim(`ends with ${trigger.secretLastFour}`)}`
+    );
+    console.log(
+      `${"Last received:".padEnd(14)}${formatRunTime(trigger.lastReceivedAt)}`
+    );
+    if (trigger.webhookSecret) {
+      console.log(
+        `${"Signing key:".padEnd(14)}${trigger.webhookSecret} ${source_default.dim(
+          "(shown only once)"
+        )}`
+      );
+      console.log("");
+      console.log(source_default.bold("Signed curl example:"));
+      console.log(signedCurlExample(trigger));
+    }
+  }
+  console.log(`${"Owner:".padEnd(14)}${trigger.ownerUserId}`);
+  console.log(
+    `${"Chat thread:".padEnd(14)}${trigger.chatThreadId ?? source_default.dim("-")}`
+  );
+  console.log(`${"Next run:".padEnd(14)}${formatRunTime(trigger.nextRunAt)}`);
+  console.log(`${"Last run:".padEnd(14)}${formatRunTime(trigger.lastRunAt)}`);
+}
+
+// src/commands/zero/workflow/trigger/gmail-config.ts
+init_esm_shims();
+import { readFileSync as readFileSync4 } from "fs";
+var TEXT_FIELD_LABELS = {
+  from: "from",
+  subject: "subject",
+  body: "body",
+  to: "to",
+  cc: "cc"
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function textFieldFromKey(key) {
+  switch (key) {
+    case "from":
+    case "subject":
+    case "body":
+    case "to":
+    case "cc":
+      return key;
+    default:
+      return null;
+  }
+}
+function formatFieldName(field) {
+  return TEXT_FIELD_LABELS[field];
+}
+function parseNonEmptyString(value, path) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`${path} must be a non-empty string`);
+  }
+  return value;
+}
+function parseNonEmptyStringArray(value, path) {
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new Error(`${path} must be a non-empty string array`);
+  }
+  return value.map((item, index) => {
+    return parseNonEmptyString(item, `${path}[${index}]`);
+  });
+}
+function parseTextMatcher(field, value) {
+  if (!isRecord(value)) {
+    throw new Error(`${formatFieldName(field)} must be an object`);
+  }
+  const matcher = {};
+  for (const key of Object.keys(value)) {
+    switch (key) {
+      case "contains":
+        matcher.contains = parseNonEmptyString(
+          value[key],
+          `${formatFieldName(field)}.contains`
+        );
+        break;
+      case "containsAny":
+        matcher.containsAny = parseNonEmptyStringArray(
+          value[key],
+          `${formatFieldName(field)}.containsAny`
+        );
+        break;
+      case "doesNotContain":
+        matcher.doesNotContain = parseNonEmptyString(
+          value[key],
+          `${formatFieldName(field)}.doesNotContain`
+        );
+        break;
+      case "doesNotContainAny":
+        matcher.doesNotContainAny = parseNonEmptyStringArray(
+          value[key],
+          `${formatFieldName(field)}.doesNotContainAny`
+        );
+        break;
+      default:
+        throw new Error(
+          `Unsupported Gmail trigger text matcher "${key}" for ${formatFieldName(field)}`
+        );
+    }
+  }
+  if (matcher.contains === void 0 && matcher.containsAny === void 0 && matcher.doesNotContain === void 0 && matcher.doesNotContainAny === void 0) {
+    throw new Error(
+      `${formatFieldName(field)} must include at least one text matcher`
+    );
+  }
+  return matcher;
+}
+function parseMatch(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!isRecord(value)) {
+    throw new Error("match must be an object");
+  }
+  const match = {};
+  for (const key of Object.keys(value)) {
+    const field = textFieldFromKey(key);
+    if (field === null) {
+      throw new Error(
+        `Unsupported Gmail trigger match field "${key}". Supported fields: from, subject, body, to, cc`
+      );
+    }
+    match[field] = parseTextMatcher(field, value[key]);
+  }
+  return Object.keys(match).length > 0 ? match : void 0;
+}
+function readConfigMatch(path) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync4(path, "utf-8"));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Failed to read Gmail trigger config "${path}": ${message}`
+    );
+  }
+  if (!isRecord(parsed)) {
+    throw new Error("Gmail trigger config must be a JSON object");
+  }
+  for (const key of Object.keys(parsed)) {
+    if (key !== "match") {
+      throw new Error(
+        `Unsupported Gmail trigger config field "${key}". Use a top-level match object`
+      );
+    }
+  }
+  return parseMatch(parsed.match);
+}
+function textFlagSpecs(options) {
+  return [
+    {
+      field: "from",
+      contains: options.fromContains,
+      doesNotContain: options.fromNotContains
+    },
+    {
+      field: "subject",
+      contains: options.subjectContains,
+      doesNotContain: options.subjectNotContains
+    },
+    {
+      field: "body",
+      contains: options.bodyContains,
+      doesNotContain: options.bodyNotContains
+    },
+    {
+      field: "to",
+      contains: options.toContains,
+      doesNotContain: options.toNotContains
+    },
+    {
+      field: "cc",
+      contains: options.ccContains,
+      doesNotContain: options.ccNotContains
+    }
+  ];
+}
+function hasGmailTriggerOptions(options) {
+  return options.config !== void 0 || textFlagSpecs(options).some((spec) => {
+    return spec.contains !== void 0 || spec.doesNotContain !== void 0;
+  });
+}
+function hasGmailLabelOption(options) {
+  return options.label !== void 0;
+}
+function buildMatchFromFlags(options) {
+  const match = {};
+  for (const spec of textFlagSpecs(options)) {
+    const matcher = {};
+    if (spec.contains !== void 0) {
+      if (spec.contains.length === 0) {
+        throw new Error(
+          `${formatFieldName(spec.field)} contains must be non-empty`
+        );
+      }
+      matcher.contains = spec.contains;
+    }
+    if (spec.doesNotContain !== void 0) {
+      if (spec.doesNotContain.length === 0) {
+        throw new Error(
+          `${formatFieldName(spec.field)} doesNotContain must be non-empty`
+        );
+      }
+      matcher.doesNotContain = spec.doesNotContain;
+    }
+    if (matcher.contains !== void 0 || matcher.doesNotContain !== void 0) {
+      match[spec.field] = matcher;
+    }
+  }
+  return Object.keys(match).length > 0 ? match : void 0;
+}
+function buildGmailNewMessageEventConfig(options) {
+  if (options.config !== void 0 && textFlagSpecs(options).some((spec) => {
+    return spec.contains !== void 0 || spec.doesNotContain !== void 0;
+  })) {
+    throw new Error("Use either --config or Gmail text match flags, not both");
+  }
+  const match = options.config !== void 0 ? readConfigMatch(options.config) : buildMatchFromFlags(options);
+  return match ? { provider: "gmail", event: "new_message", match } : { provider: "gmail", event: "new_message" };
+}
+function buildGmailLabelAppliedEventConfig(options) {
+  const labelName = options.label?.trim();
+  if (!labelName) {
+    throw new Error(
+      'gmail-label-applied triggers require --label "Label name"'
+    );
+  }
+  return { provider: "gmail", event: "label_applied", labelName };
+}
+
+// src/commands/zero/workflow/trigger/index.ts
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var SCHEDULE_KINDS = ["cron", "once", "loop"];
+var EVENT_KINDS = [
+  "gmail-new-message",
+  "gmail-label-applied",
+  "webhook"
+];
+var TRIGGER_KINDS = [...SCHEDULE_KINDS, ...EVENT_KINDS];
+var EXACTLY_ONE_FLAG_MESSAGE = "Provide exactly one of --expr (cron), --at (once), --every (loop), Gmail match options, or --label";
+function addGmailTriggerOptions(command) {
+  return command.option(
+    "--config <path>",
+    "Path to a Gmail new message trigger config JSON"
+  ).option("--label <name>", "Gmail label name for label-applied triggers").option("--from-contains <text>", "Require the From header to contain text").option(
+    "--from-not-contains <text>",
+    "Require the From header not to contain text"
+  ).option(
+    "--subject-contains <text>",
+    "Require the Subject header to contain text"
+  ).option(
+    "--subject-not-contains <text>",
+    "Require the Subject header not to contain text"
+  ).option(
+    "--body-contains <text>",
+    "Require the message body to contain text"
+  ).option(
+    "--body-not-contains <text>",
+    "Require the message body not to contain text"
+  ).option("--to-contains <text>", "Require the To header to contain text").option(
+    "--to-not-contains <text>",
+    "Require the To header not to contain text"
+  ).option("--cc-contains <text>", "Require the Cc header to contain text").option(
+    "--cc-not-contains <text>",
+    "Require the Cc header not to contain text"
+  );
+}
+function timezoneOrUtc(timezone) {
+  return timezone ?? "UTC";
+}
+function assertValidTimezone(timezone) {
+  new Intl.DateTimeFormat("en-US", { timeZone: timezone });
+}
+function hasExplicitOffset(value) {
+  return /(?:Z|[+-]\d{2}:?\d{2})$/i.test(value);
+}
+function parseLocalDateTime(value) {
+  const match = value.match(
+    /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,3}))?)?$/
+  );
+  if (!match) {
+    throw new Error(
+      `Invalid at time: "${value}". Use ISO datetime, e.g. 2026-06-10T09:00 or 2026-06-10T09:00:00Z`
+    );
+  }
+  return {
+    year: Number(match[1]),
+    month: Number(match[2]),
+    day: Number(match[3]),
+    hour: Number(match[4]),
+    minute: Number(match[5]),
+    second: match[6] ? Number(match[6]) : 0,
+    millisecond: match[7] ? Number(match[7].padEnd(3, "0")) : 0
+  };
+}
+function zonedParts(instant, timezone) {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone: timezone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hourCycle: "h23"
+  }).formatToParts(instant);
+  const values = /* @__PURE__ */ new Map();
+  for (const part of parts) {
+    if (part.type !== "literal") {
+      values.set(part.type, part.value);
+    }
+  }
+  return {
+    year: Number(values.get("year")),
+    month: Number(values.get("month")),
+    day: Number(values.get("day")),
+    hour: Number(values.get("hour")),
+    minute: Number(values.get("minute")),
+    second: Number(values.get("second"))
+  };
+}
+function wallTimeToUtcIso(value, timezone) {
+  assertValidTimezone(timezone);
+  if (hasExplicitOffset(value)) {
+    const instant = new Date(value);
+    if (Number.isNaN(instant.getTime())) {
+      throw new Error(`Invalid at time: "${value}"`);
+    }
+    return instant.toISOString();
+  }
+  const target = parseLocalDateTime(value);
+  const targetUtc = Date.UTC(
+    target.year,
+    target.month - 1,
+    target.day,
+    target.hour,
+    target.minute,
+    target.second,
+    target.millisecond
+  );
+  let guess = targetUtc;
+  for (let i = 0; i < 3; i++) {
+    const parts = zonedParts(new Date(guess), timezone);
+    const renderedUtc = Date.UTC(
+      parts.year,
+      parts.month - 1,
+      parts.day,
+      parts.hour,
+      parts.minute,
+      parts.second,
+      target.millisecond
+    );
+    guess += targetUtc - renderedUtc;
+  }
+  const result = new Date(guess);
+  const rendered = zonedParts(result, timezone);
+  if (rendered.year !== target.year || rendered.month !== target.month || rendered.day !== target.day || rendered.hour !== target.hour || rendered.minute !== target.minute || rendered.second !== target.second) {
+    throw new Error(
+      `Invalid at time for ${timezone}: "${value}". The local time does not exist`
+    );
+  }
+  return result.toISOString();
+}
+function buildSchedule(kind, options) {
+  switch (kind) {
+    case "cron":
+      if (!options.expr) {
+        throw new Error(
+          'cron triggers require --expr (e.g. --expr "0 9 * * *")'
+        );
+      }
+      return {
+        type: "cron",
+        cronExpression: options.expr,
+        timezone: timezoneOrUtc(options.timezone)
+      };
+    case "once": {
+      if (!options.at) {
+        throw new Error(
+          'once triggers require --at (e.g. --at "2026-06-10T09:00")'
+        );
+      }
+      const timezone = timezoneOrUtc(options.timezone);
+      return {
+        type: "once",
+        atTime: wallTimeToUtcIso(options.at, timezone),
+        timezone
+      };
+    }
+    case "loop":
+      if (!options.every) {
+        throw new Error("loop triggers require --every (e.g. --every 15m)");
+      }
+      return {
+        type: "loop",
+        intervalSeconds: parseDurationSeconds(options.every)
+      };
+    default:
+      throw new Error(
+        `Unknown trigger kind: "${kind}". Use one of: ${TRIGGER_KINDS.join(", ")}`
+      );
+  }
+}
+function hasScheduleAddOptions(options) {
+  return options.expr !== void 0 || options.at !== void 0 || options.every !== void 0 || options.timezone !== void 0;
+}
+function buildCreateRequest(kind, options) {
+  if (kind === "gmail-new-message") {
+    if (hasScheduleAddOptions(options)) {
+      throw new Error(
+        "--expr, --at, --every, and --timezone only apply to schedule triggers"
+      );
+    }
+    if (hasGmailLabelOption(options)) {
+      throw new Error("--label only applies to gmail-label-applied triggers");
+    }
+    return {
+      kind: "event",
+      eventType: "gmail-new-message",
+      eventConfig: buildGmailNewMessageEventConfig(options)
+    };
+  }
+  if (kind === "gmail-label-applied") {
+    if (hasScheduleAddOptions(options)) {
+      throw new Error(
+        "--expr, --at, --every, and --timezone only apply to schedule triggers"
+      );
+    }
+    if (hasGmailTriggerOptions(options)) {
+      throw new Error(
+        "Gmail match flags and --config only apply to gmail-new-message triggers"
+      );
+    }
+    return {
+      kind: "event",
+      eventType: "gmail-label-applied",
+      eventConfig: buildGmailLabelAppliedEventConfig(options)
+    };
+  }
+  if (kind === "webhook") {
+    if (hasScheduleAddOptions(options)) {
+      throw new Error(
+        "--expr, --at, --every, and --timezone only apply to schedule triggers"
+      );
+    }
+    if (hasGmailTriggerOptions(options) || hasGmailLabelOption(options)) {
+      throw new Error("Gmail trigger flags only apply to Gmail event triggers");
+    }
+    return {
+      kind: "event",
+      eventType: "webhook-received",
+      eventConfig: {
+        provider: "webhook",
+        event: "received",
+        auth: { mode: "hmac-sha256" }
+      }
+    };
+  }
+  if (hasGmailTriggerOptions(options) || hasGmailLabelOption(options)) {
+    throw new Error("Gmail trigger flags only apply to Gmail event triggers");
+  }
+  return { schedule: buildSchedule(kind, options) };
+}
+function buildUpdate(options) {
+  const flagCount = [options.expr, options.at, options.every].filter(
+    (value) => {
+      return value !== void 0;
+    }
+  ).length;
+  const hasGmailOptions = hasGmailTriggerOptions(options);
+  const hasLabelOption = hasGmailLabelOption(options);
+  if (hasGmailOptions && hasLabelOption) {
+    throw new Error("Use either Gmail match options or --label");
+  }
+  if (hasLabelOption) {
+    if (flagCount > 0 || options.timezone !== void 0) {
+      throw new Error("Use either schedule flags or --label");
+    }
+    return { eventConfig: buildGmailLabelAppliedEventConfig(options) };
+  }
+  if (hasGmailOptions) {
+    if (flagCount > 0 || options.timezone !== void 0) {
+      throw new Error("Use either schedule flags or Gmail match options");
+    }
+    return { eventConfig: buildGmailNewMessageEventConfig(options) };
+  }
+  if (flagCount !== 1) {
+    throw new Error(EXACTLY_ONE_FLAG_MESSAGE);
+  }
+  if (options.timezone && !options.expr && !options.at) {
+    throw new Error("--timezone only applies to --expr and --at");
+  }
+  if (options.expr) {
+    return { schedule: buildSchedule("cron", options) };
+  }
+  if (options.at) {
+    return { schedule: buildSchedule("once", options) };
+  }
+  return { schedule: buildSchedule("loop", options) };
+}
+async function resolveWorkflowId(ref, options) {
+  if (UUID_RE.test(ref)) {
+    return ref;
+  }
+  const agentId = options.agent ?? process.env.ZERO_AGENT_ID;
+  const workflows = await listWorkflows(agentId ? { agentId } : {});
+  const matches = workflows.filter((workflow) => {
+    return workflow.name === ref;
+  });
+  if (matches.length === 0) {
+    const hint = agentId ? ` under agent "${agentId}"` : ". Provide --agent <agent-id> or use the workflow ID";
+    throw new Error(`Workflow not found: "${ref}"${hint}`);
+  }
+  if (matches.length > 1) {
+    throw new Error(
+      `Ambiguous workflow name: "${ref}". Provide --agent <agent-id> or use the workflow ID`
+    );
+  }
+  return matches[0].id;
+}
+var addCommand = addGmailTriggerOptions(
+  new Command().name("add").description("Add a trigger to a workflow").argument("<workflow>", "Workflow ID or name").argument("<kind>", `Trigger type: ${TRIGGER_KINDS.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(
+    "-z, --timezone <tz>",
+    "IANA timezone for cron/once (default: UTC)"
+  )
+).option("--agent <id>", "Agent ID for resolving a workflow name").addHelpText(
+  "after",
+  `
+Examples:
+  zero workflow trigger add tell-a-joke cron --expr "0 9 * * *" -z Asia/Shanghai
+  zero workflow trigger add tell-a-joke once --at "2026-06-10T09:00" -z Asia/Shanghai
+  zero workflow trigger add tell-a-joke loop --every 15m
+  zero workflow trigger add triage gmail-new-message --from-contains "@example.com"
+  zero workflow trigger add triage gmail-new-message --config ./gmail-trigger.json
+  zero workflow trigger add triage gmail-label-applied --label "Support"
+  zero workflow trigger add triage webhook
+
+Notes:
+  - Workflow names resolve under --agent, then ZERO_AGENT_ID, then all visible workflows
+  - Gmail triggers match all inbound messages when no text match rules are provided
+  - Webhook triggers print the signing secret only once after creation
+  - Use the workflow ID when a name is ambiguous`
+).action(
+  withErrorHandler(
+    async (workflowRef, kind, options) => {
+      if (options.timezone && kind !== "cron" && kind !== "once" && kind !== "gmail-new-message") {
+        throw new Error("--timezone only applies to cron and once triggers");
+      }
+      const workflowId = await resolveWorkflowId(workflowRef, options);
+      const body = buildCreateRequest(kind, options);
+      const trigger = await createWorkflowTrigger(workflowId, body);
+      console.log(
+        source_default.green(`\u2713 Trigger added to workflow "${workflowRef}"`)
+      );
+      printWorkflowTriggerDetails(trigger, { workflowRef });
+    }
+  )
+);
+var updateCommand = addGmailTriggerOptions(
+  new Command().name("update").description("Replace a workflow trigger's schedule or Gmail match config").argument("<trigger>", "Workflow trigger ID").option("--expr <expression>", 'New cron schedule (e.g. "0 9 * * *")').option("--at <iso-time>", 'New one-time fire (e.g. "2026-06-10T09:00")').option("--every <duration>", "New loop interval (e.g. 15m, 1h, 90s)").option("-z, --timezone <tz>", "IANA timezone for --expr / --at")
+).addHelpText(
+  "after",
+  `
+Examples:
+  zero workflow trigger update 22222222-2222-4222-8222-222222222222 --expr "0 9 * * *" -z Asia/Shanghai
+  zero workflow trigger update 22222222-2222-4222-8222-222222222222 --at "2026-06-10T09:00" -z UTC
+  zero workflow trigger update 22222222-2222-4222-8222-222222222222 --every 10m
+  zero workflow trigger update 22222222-2222-4222-8222-222222222222 --from-contains "@example.com"
+  zero workflow trigger update 22222222-2222-4222-8222-222222222222 --config ./gmail-trigger.json
+  zero workflow trigger update 22222222-2222-4222-8222-222222222222 --label "Support"`
+).action(
+  withErrorHandler(async (id, options) => {
+    const trigger = await updateWorkflowTrigger(id, buildUpdate(options));
+    console.log(source_default.green(`\u2713 Trigger ${trigger.id} updated`));
+    printWorkflowTriggerDetails(trigger);
+  })
+);
+var listCommand2 = new Command().name("list").alias("ls").description("List a workflow's triggers").argument("<workflow>", "Workflow ID or name").option("--agent <id>", "Agent ID for resolving a workflow name").addHelpText(
+  "after",
+  `
+Examples:
+  zero workflow trigger list tell-a-joke
+  zero workflow trigger list tell-a-joke --agent <agent-id>`
+).action(
+  withErrorHandler(
+    async (workflowRef, options) => {
+      const workflowId = await resolveWorkflowId(workflowRef, options);
+      const triggers = await listWorkflowTriggers(workflowId);
+      if (triggers.length === 0) {
+        console.log(source_default.dim("No triggers"));
+        console.log(
+          source_default.dim(
+            `  Add one with: zero workflow trigger add ${workflowRef} cron --expr "0 9 * * *"`
+          )
+        );
+        return;
+      }
+      printWorkflowTriggersTable(triggers);
+    }
+  )
+);
+var showCommand = new Command().name("show").description("Show a workflow trigger").argument("<trigger>", "Workflow trigger ID").action(
+  withErrorHandler(async (id) => {
+    const trigger = await getWorkflowTrigger(id);
+    printWorkflowTriggerDetails(trigger);
+  })
+);
+var rmCommand = new Command().name("rm").alias("remove").description("Remove a workflow trigger").argument("<trigger>", "Workflow trigger ID").action(
+  withErrorHandler(async (id) => {
+    await deleteWorkflowTrigger(id);
+    console.log(source_default.green(`\u2713 Trigger ${id} removed`));
+  })
+);
+var enableCommand = new Command().name("enable").description("Enable a workflow trigger").argument("<trigger>", "Workflow trigger ID").action(
+  withErrorHandler(async (id) => {
+    const trigger = await enableWorkflowTrigger(id);
+    console.log(source_default.green(`\u2713 Trigger ${trigger.id} enabled`));
+  })
+);
+var disableCommand = new Command().name("disable").description("Disable a workflow trigger").argument("<trigger>", "Workflow trigger ID").action(
+  withErrorHandler(async (id) => {
+    const trigger = await disableWorkflowTrigger(id);
+    console.log(source_default.green(`\u2713 Trigger ${trigger.id} disabled`));
+  })
+);
+var triggerCommand = new Command().name("trigger").description("Manage a workflow's triggers").addCommand(addCommand).addCommand(updateCommand).addCommand(listCommand2).addCommand(showCommand).addCommand(rmCommand).addCommand(enableCommand).addCommand(disableCommand).addHelpText(
+  "after",
+  `
+Examples:
+  Add a trigger:      zero workflow trigger add <workflow> cron --expr "0 9 * * *"
+  Add a webhook:      zero workflow trigger add <workflow> webhook
+  Update a schedule:  zero workflow trigger update <trigger-id> --every 10m
+  List triggers:      zero workflow trigger list <workflow>
+  Inspect a trigger:  zero workflow trigger show <trigger-id>
+  Pause one trigger:  zero workflow trigger disable <trigger-id>`
+);
+
+// src/commands/zero/workflow/index.ts
+var zeroWorkflowCommand = new Command("workflow").description("Manage workflows").addCommand(createCommand).addCommand(editCommand).addCommand(viewCommand).addCommand(listCommand).addCommand(deleteCommand).addCommand(copyCommand).addCommand(runCommand).addCommand(triggerCommand).addHelpText(
+  "after",
+  `
+Examples:
+  Create under an agent:   zero workflow create my-workflow --agent <agent-id> --instruction "Do things"
+  List workflows:          zero workflow list
+  View workflow content:   zero workflow view <workflow-id>
+  Update workflow content: zero workflow edit <workflow-id> --instruction "New steps"
+  Copy onto another agent: zero workflow copy <workflow-id> --to-agent <agent-id>
+  Run a workflow once:     zero workflow run <workflow-id>
+  Manage triggers:         zero workflow trigger --help
+  Delete a workflow:       zero workflow delete <workflow-id> -y`
+);
+export {
+  zeroWorkflowCommand
+};
+//# sourceMappingURL=workflow-DR5N3QR7.js.map