@runcofactor/cli 0.10.0

package/dist/task-IQC3YR5K.js

@@ -0,0 +1,922 @@
+import { createRequire as __cr } from "module"; const require = __cr(import.meta.url);
+import {
+  apiRequest
+} from "./chunk-WOHL4FTB.js";
+import "./chunk-SJJW77WN.js";
+import "./chunk-3CZU7XCS.js";
+import {
+  getArgValue,
+  hasFlag,
+  resolveConfig
+} from "./chunk-A4OFTUVV.js";
+import "./chunk-JWHYXEA2.js";
+import "./chunk-VKVL7WBN.js";
+
+// src/task.ts
+import process from "process";
+import { execSync } from "child_process";
+import { readFileSync } from "fs";
+function getHeadCommit() {
+  try {
+    return execSync("git rev-parse HEAD", { encoding: "utf-8" }).trim();
+  } catch {
+    return null;
+  }
+}
+function printHelp() {
+  console.log(
+    [
+      "canary task: Manage trigger-based agent tasks",
+      "",
+      "Sub-commands:",
+      "  create                         Create a new task",
+      "  list [options]                 List tasks",
+      "  get <id>                       Get task details",
+      "  update <id> [options]           Update task fields",
+      "  complete <id> [--pr <number>] [--commit <sha>] Mark task complete (--pr preferred under squash-merge)",
+      '  set-commit <id> [--pr <number>] [--commit <sha>] Update resolution PR/commit (use "" to clear)',
+      "  cancel <id>                    Cancel a task",
+      "  reopen <id> [--status <s>]     Reopen a canceled task (default: actionable)",
+      "  release <id> [--status <s>]    Release an in-progress task (default: actionable)",
+      "  trigger <id>                   Manually trigger a task",
+      "  claim <id>                     Claim a task (mark in progress)",
+      "  execute <id> --instance <id>   Execute task on a sandbox instance",
+      "  comment <id> <message>         Add a comment to a task",
+      "  comments <id>                  List comments for a task",
+      "  subtasks <id>                  List subtasks of a parent task",
+      "  link-customer <id> [opts]      Link a customer to a task",
+      "  unlink-customer <id> [opts]    Unlink a customer from a task",
+      "",
+      "Create options:",
+      "  --title <text>                 Short title (required)",
+      "  --description <text>           Task description (required, or -file/-stdin)",
+      "  --description-file <path>      Read description from file",
+      "  --description-stdin            Read description from stdin (pipe or heredoc)",
+      "  --trigger <type>               Trigger type (required)",
+      "  --commit <sha>                 Source commit (default: git HEAD)",
+      "  --flag <name>                  Flag name (for flag-* triggers)",
+      "  --knob <key>                   Knob key (for knob-* triggers)",
+      "  --pr <number>                  PR number (for pr-merged)",
+      "  --scheduled-date <date>        ISO date (for scheduled)",
+      "  --assign <email>               Assignee",
+      "  --priority <0|1|2>             Priority (0=normal, 1=high, 2=critical)",
+      "  --tag <tag>                    Tag (repeatable)",
+      "  --repo <owner/repo>            Target repo (auto-selected if org has one)",
+      "  --role <frontend|backend|...>  Resolve repo by role (alternative to --repo)",
+      "  --expires <date>               Expiry date (ISO 8601)",
+      "  --parent <id>                  Parent task ID (creates a subtask)",
+      "  --customer <value>             Customer (org UUID or freeform name, repeatable)",
+      "",
+      "Update options:",
+      "  --title <text>                 New title",
+      "  --description <text>           New description",
+      "  --description-file <path>      Read new description from file",
+      "  --description-stdin            Read new description from stdin",
+      '  --assign <email>               New assignee (use "" to unassign)',
+      "  --priority <0|1|2>             New priority",
+      "  --tag <tag>                    Replace tags (repeatable)",
+      '  --commit <sha>                 Resolution commit (use "" to clear)',
+      "",
+      "List options:",
+      "  --assigned-to <email>          Filter by assignee",
+      "  --page <n>                     Page number (1-based, default 1)",
+      "  --page-size <n>                Page size (max 100, default 25)",
+      "  --parent <id>                  Filter by parent task (show subtasks)",
+      "  --group-key <key>              Filter by groupKey",
+      "  --priority <val>               Filter by priority (repeatable). Accepts critical|high|normal|0|1|2",
+      "  --sort <field> [<dir>]         Sort by field (repeatable, applied in order).",
+      "                                   field \u2208 priority | createdAt (alias: date)",
+      "                                   dir   \u2208 asc | desc (default: desc)",
+      "                                   Default: --sort priority desc --sort createdAt asc",
+      "  --status <status>              Filter by status",
+      "  --trigger <type>               Filter by trigger type",
+      "",
+      "Link-customer options:",
+      "  --org <orgId>                  Organization UUID to link",
+      "  --name <text>                  Freeform customer name (e.g. prospect)",
+      "",
+      "Unlink-customer options:",
+      "  --customer-id <id>             Customer link ID (from `canary task get`)",
+      "",
+      "Trigger types:",
+      "  production-deploy, flag-deprecated, flag-cleanup, flag-deleted,",
+      "  knob-deprecated, knob-cleanup, knob-deleted, scheduled,",
+      "  pr-merged, immediate, manual",
+      "",
+      "Global options:",
+      "  --env <env>                    Target environment",
+      "  --json                         JSON output",
+      "  --api-url <url>                API URL override",
+      "  --token <key>                  Token override"
+    ].join("\n")
+  );
+}
+var STATUS_ICONS = {
+  waiting: "\u23F3",
+  actionable: "\u{1F7E2}",
+  in_progress: "\u{1F535}",
+  completed: "\u2705",
+  canceled: "\u274C",
+  expired: "\u23F0"
+};
+var PRIORITY_LABELS = ["normal", "high", "critical"];
+var PRIORITY_VALUE_BY_NAME = {
+  normal: 0,
+  high: 1,
+  critical: 2
+};
+function parsePriorityArgs(argv) {
+  const values = [];
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] !== "--priority" || !argv[i + 1]) continue;
+    const raw = argv[i + 1].toLowerCase();
+    for (const part of raw.split(",").map((s) => s.trim()).filter(Boolean)) {
+      if (part in PRIORITY_VALUE_BY_NAME) {
+        values.push(PRIORITY_VALUE_BY_NAME[part]);
+      } else {
+        const n = Number(part);
+        if (!Number.isInteger(n)) {
+          console.error(`Error: invalid --priority value "${part}". Use critical|high|normal or 0|1|2.`);
+          process.exit(1);
+        }
+        values.push(n);
+      }
+    }
+  }
+  return values;
+}
+function parseSortArgs(argv) {
+  const tokens = [];
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] !== "--sort" || !argv[i + 1]) continue;
+    const field = argv[i + 1];
+    const maybeDir = argv[i + 2];
+    let dir;
+    if (maybeDir && !maybeDir.startsWith("--")) {
+      if (maybeDir === "asc" || maybeDir === "desc") {
+        dir = maybeDir;
+      } else {
+        console.error(
+          `Error: invalid --sort direction "${maybeDir}" for field "${field}". Use: asc, desc.`
+        );
+        process.exit(1);
+      }
+    }
+    tokens.push(dir ? `${field}:${dir}` : field);
+  }
+  return tokens;
+}
+async function handleList(argv, apiUrl, token) {
+  const jsonOutput = hasFlag(argv, "--json");
+  const status = getArgValue(argv, "--status");
+  const triggerType = getArgValue(argv, "--trigger");
+  const assignedTo = getArgValue(argv, "--assigned-to");
+  const page = getArgValue(argv, "--page");
+  const pageSize = getArgValue(argv, "--page-size");
+  const parentId = getArgValue(argv, "--parent");
+  const groupKey = getArgValue(argv, "--group-key");
+  const priorities = parsePriorityArgs(argv);
+  const sortTokens = parseSortArgs(argv);
+  const params = new URLSearchParams();
+  if (status) params.set("status", status);
+  if (triggerType) params.set("triggerType", triggerType);
+  if (assignedTo) params.set("assignedTo", assignedTo);
+  if (parentId) params.set("parentTaskId", parentId);
+  if (groupKey) params.set("groupKey", groupKey);
+  if (priorities.length > 0) params.set("priority", priorities.join(","));
+  if (sortTokens.length > 0) params.set("sort", sortTokens.join(","));
+  if (page) params.set("page", page);
+  if (pageSize) params.set("pageSize", pageSize);
+  const qs = params.toString();
+  const path = `/tasks${qs ? `?${qs}` : ""}`;
+  const result = await apiRequest(apiUrl, token, "GET", path);
+  if (!result.ok) {
+    console.error(`Error: ${result.error ?? "Unknown error"}`);
+    process.exit(1);
+  }
+  if (jsonOutput) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (result.data.length === 0) {
+    console.log("No tasks found.");
+    return;
+  }
+  console.log(`Tasks (page ${result.pagination.page}/${result.pagination.totalPages}, ${result.pagination.totalItems} total):
+`);
+  for (const task of result.data) {
+    const icon = STATUS_ICONS[task.status] ?? "?";
+    const priority = task.priority > 0 ? ` [${PRIORITY_LABELS[task.priority]}]` : "";
+    const commit = task.sourceCommit ? ` (${task.sourceCommit.slice(0, 7)})` : "";
+    const created = task.createdAt ? new Date(task.createdAt).toLocaleString() : "";
+    const updated = task.updatedAt ? new Date(task.updatedAt).toLocaleString() : "";
+    console.log(`  ${icon} ${task.id.slice(0, 8)} | ${task.title}${priority}${commit}`);
+    console.log(`     trigger=${task.triggerType} status=${task.status} created=${created} updated=${updated}`);
+  }
+}
+async function handleGet(argv, apiUrl, token) {
+  const id = argv[0];
+  if (!id || id.startsWith("--")) {
+    console.error("Error: Missing task ID.");
+    console.error("Usage: canary task get <id>");
+    process.exit(1);
+  }
+  const jsonOutput = hasFlag(argv, "--json");
+  const result = await apiRequest(apiUrl, token, "GET", `/tasks/${id}`);
+  if (!result.ok || !result.data) {
+    console.error(`Error: ${result.error ?? "Task not found"}`);
+    process.exit(1);
+  }
+  if (jsonOutput) {
+    console.log(JSON.stringify(result.data, null, 2));
+    return;
+  }
+  const task = result.data;
+  const icon = STATUS_ICONS[task.status] ?? "?";
+  console.log(`${icon} ${task.title}`);
+  console.log(`ID:           ${task.id}`);
+  console.log(`Status:       ${task.status}`);
+  console.log(`Trigger:      ${task.triggerType}`);
+  console.log(`Priority:     ${PRIORITY_LABELS[task.priority] ?? task.priority}`);
+  if (task.sourceCommit) console.log(`Source:       ${task.sourceCommit}`);
+  if (task.resolutionCommit) console.log(`Resolution:   ${task.resolutionCommit}`);
+  if (task.assignedTo) console.log(`Assigned to:  ${task.assignedTo}`);
+  if (task.tags.length > 0) console.log(`Tags:         ${task.tags.join(", ")}`);
+  if (task.groupKey) console.log(`Group key:    ${task.groupKey}`);
+  if (task.parentTaskId) console.log(`Parent:       ${task.parentTaskId}`);
+  if (task.subtaskSummary && task.subtaskSummary.total > 0) {
+    const s = task.subtaskSummary;
+    console.log(`Subtasks:     ${s.completed}/${s.total} completed, ${s.inProgress} in progress, ${s.canceled} canceled`);
+  }
+  if (task.relevantCustomers && task.relevantCustomers.length > 0) {
+    console.log("Customers:");
+    for (const c of task.relevantCustomers) {
+      const orgTag = c.orgId ? ` (org: ${c.orgId.slice(0, 8)})` : " (freeform)";
+      console.log(`    ${c.name}${orgTag} [${c.id}]`);
+    }
+  }
+  console.log(`Created:      ${task.createdAt}`);
+  console.log(`Updated:      ${task.updatedAt}`);
+  if (task.triggeredAt) console.log(`Triggered:    ${task.triggeredAt}`);
+  if (task.completedAt) console.log(`Completed:    ${task.completedAt}`);
+  if (Object.keys(task.triggerConfig).length > 0) {
+    console.log(`Trigger cfg:  ${JSON.stringify(task.triggerConfig)}`);
+  }
+  console.log(`
+Description:
+${task.description}`);
+  if (task.attachments && task.attachments.length > 0) {
+    console.log("\nAttachments:");
+    for (const att of task.attachments) {
+      const sizeKb = Math.round(att.sizeBytes / 1024);
+      console.log(`  ${att.filename} (${sizeKb} KB) \u2014 ${att.downloadUrl}`);
+    }
+  }
+  if (task.events && task.events.length > 0) {
+    console.log("\nEvent history:");
+    for (const evt of task.events) {
+      console.log(`  ${evt.createdAt} ${evt.eventType} by ${evt.actor ?? "system"}`);
+    }
+  }
+}
+async function handleSubtasks(argv, apiUrl, token) {
+  const id = argv[0];
+  if (!id || id.startsWith("--")) {
+    console.error("Error: Missing parent task ID.");
+    console.error("Usage: canary task subtasks <parent-id>");
+    process.exit(1);
+  }
+  const jsonOutput = hasFlag(argv, "--json");
+  const result = await apiRequest(
+    apiUrl,
+    token,
+    "GET",
+    `/tasks/${id}/subtasks`
+  );
+  if (!result.ok) {
+    console.error(`Error: ${result.error ?? "Failed to list subtasks"}`);
+    process.exit(1);
+  }
+  if (jsonOutput) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  const subtasks = result.data ?? [];
+  if (subtasks.length === 0) {
+    console.log("No subtasks found.");
+    return;
+  }
+  console.log(`Subtasks of ${id} (${subtasks.length} total):
+`);
+  for (const task of subtasks) {
+    const icon = STATUS_ICONS[task.status] ?? "?";
+    const priority = task.priority > 0 ? ` [${PRIORITY_LABELS[task.priority]}]` : "";
+    const created = task.createdAt ? new Date(task.createdAt).toLocaleString() : "";
+    console.log(`  ${icon} ${task.id.slice(0, 8)} | ${task.title}${priority}`);
+    console.log(`     status=${task.status} created=${created}`);
+  }
+}
+async function handleCreate(argv, apiUrl, token) {
+  const title = getArgValue(argv, "--title");
+  const triggerType = getArgValue(argv, "--trigger");
+  let description = getArgValue(argv, "--description");
+  const descriptionFile = getArgValue(argv, "--description-file");
+  const descriptionStdin = hasFlag(argv, "--description-stdin");
+  const jsonOutput = hasFlag(argv, "--json");
+  if (!title) {
+    console.error("Error: --title is required.");
+    process.exit(1);
+  }
+  if (!triggerType) {
+    console.error("Error: --trigger is required.");
+    process.exit(1);
+  }
+  if (descriptionFile) {
+    try {
+      description = readFileSync(descriptionFile, "utf-8");
+    } catch (err) {
+      console.error(`Error reading description file: ${err}`);
+      process.exit(1);
+    }
+  } else if (descriptionStdin) {
+    try {
+      description = readFileSync("/dev/stdin", "utf-8");
+    } catch (err) {
+      console.error(`Error reading description from stdin: ${err}`);
+      process.exit(1);
+    }
+  }
+  if (!description) {
+    console.error("Error: --description, --description-file, or --description-stdin is required.");
+    process.exit(1);
+  }
+  const triggerConfig = {};
+  const flagName = getArgValue(argv, "--flag");
+  const knobKey = getArgValue(argv, "--knob");
+  const prNumber = getArgValue(argv, "--pr");
+  const scheduledDate = getArgValue(argv, "--scheduled-date");
+  if (flagName) triggerConfig.flagName = flagName;
+  if (knobKey) triggerConfig.knobKey = knobKey;
+  if (prNumber) triggerConfig.prNumber = parseInt(prNumber, 10);
+  if (scheduledDate) triggerConfig.scheduledDate = scheduledDate;
+  const commit = getArgValue(argv, "--commit") ?? getHeadCommit();
+  let propertyGithubRepoId = getArgValue(argv, "--repo-id");
+  const repoFullName = getArgValue(argv, "--repo");
+  const role = getArgValue(argv, "--role");
+  if (!propertyGithubRepoId) {
+    const reposResult = await apiRequest(apiUrl, token, "GET", "/tasks/repos");
+    if (!reposResult.ok || !reposResult.data?.length) {
+      console.error("Error: No GitHub repositories linked to your organization.");
+      console.error("Connect a repository first before creating tasks.");
+      process.exit(1);
+    }
+    if (repoFullName) {
+      const match = reposResult.data.find((r) => r.repoFullName === repoFullName);
+      if (!match) {
+        console.error(`Error: Repository "${repoFullName}" not found in your organization.`);
+        console.error(`Available: ${reposResult.data.map((r) => r.repoFullName).join(", ")}`);
+        process.exit(1);
+      }
+      propertyGithubRepoId = match.id;
+    } else if (role) {
+      const matches = reposResult.data.filter((r) => r.role === role);
+      if (matches.length === 0) {
+        console.error(`Error: No repos found with role "${role}".`);
+        const seenRoles = Array.from(
+          new Set(reposResult.data.map((r) => r.role).filter((x) => !!x))
+        );
+        if (seenRoles.length) console.error(`Available roles: ${seenRoles.join(", ")}`);
+        process.exit(1);
+      }
+      if (matches.length > 1) {
+        console.error(
+          `Error: Multiple repos with role "${role}". Use --repo <owner/repo> to disambiguate.`
+        );
+        console.error(`Available: ${matches.map((r) => r.repoFullName).join(", ")}`);
+        process.exit(1);
+      }
+      propertyGithubRepoId = matches[0].id;
+    } else if (reposResult.data.length === 1) {
+      propertyGithubRepoId = reposResult.data[0].id;
+    } else {
+      console.error(
+        "Error: Multiple repos found. Use --repo <owner/repo> or --role <role> to specify."
+      );
+      console.error(`Available: ${reposResult.data.map((r) => r.repoFullName).join(", ")}`);
+      process.exit(1);
+    }
+  }
+  if (triggerType === "pr-merged") {
+    triggerConfig.propertyGithubRepoId = propertyGithubRepoId;
+  }
+  const tags = [];
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === "--tag" && argv[i + 1]) {
+      tags.push(argv[i + 1]);
+    }
+  }
+  const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  const customers = [];
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === "--customer" && argv[i + 1]) {
+      const val = argv[i + 1];
+      if (UUID_RE.test(val)) {
+        customers.push({ orgId: val });
+      } else {
+        customers.push({ name: val });
+      }
+    }
+  }
+  const assignedTo = getArgValue(argv, "--assign");
+  const priorityRaw = getArgValue(argv, "--priority");
+  const expiresAt = getArgValue(argv, "--expires");
+  const parentTaskId = getArgValue(argv, "--parent");
+  const body = {
+    propertyGithubRepoId,
+    title,
+    description,
+    triggerType,
+    triggerConfig,
+    sourceCommit: commit,
+    assignedTo: assignedTo ?? void 0,
+    priority: priorityRaw ? parseInt(priorityRaw, 10) : void 0,
+    tags: tags.length > 0 ? tags : void 0,
+    parentTaskId: parentTaskId ?? void 0,
+    expiresAt: expiresAt ?? void 0,
+    customers: customers.length > 0 ? customers : void 0
+  };
+  const result = await apiRequest(apiUrl, token, "POST", "/tasks", body);
+  if (!result.ok) {
+    console.error(`Error: ${result.error ?? "Failed to create task"}`);
+    process.exit(1);
+  }
+  if (jsonOutput) {
+    console.log(JSON.stringify(result.data, null, 2));
+    return;
+  }
+  const task = result.data;
+  console.log(`Task created: ${task.id}`);
+  console.log(`  Title:    ${task.title}`);
+  console.log(`  Status:   ${task.status}`);
+  console.log(`  Trigger:  ${task.triggerType}`);
+  if (task.sourceCommit) console.log(`  Commit:   ${task.sourceCommit.slice(0, 7)}`);
+  if (triggerType === "pr-merged") {
+    console.log("\nThis task will become actionable when the matching PR is merged.");
+  }
+}
+async function handleUpdate(argv, apiUrl, token) {
+  const id = argv[0];
+  if (!id || id.startsWith("--")) {
+    console.error("Error: Missing task ID.");
+    console.error("Usage: canary task update <id> [--title ...] [--description ...] [--assign ...] [--priority ...] [--tag ...]");
+    process.exit(1);
+  }
+  const jsonOutput = hasFlag(argv, "--json");
+  const title = getArgValue(argv, "--title");
+  let description = getArgValue(argv, "--description");
+  const descriptionFile = getArgValue(argv, "--description-file");
+  const descriptionStdin = hasFlag(argv, "--description-stdin");
+  const assignRaw = getArgValue(argv, "--assign");
+  const priorityRaw = getArgValue(argv, "--priority");
+  const commitRaw = getArgValue(argv, "--commit");
+  if (descriptionFile) {
+    try {
+      description = readFileSync(descriptionFile, "utf-8");
+    } catch (err) {
+      console.error(`Error reading description file: ${err}`);
+      process.exit(1);
+    }
+  } else if (descriptionStdin) {
+    try {
+      description = readFileSync("/dev/stdin", "utf-8");
+    } catch (err) {
+      console.error(`Error reading description from stdin: ${err}`);
+      process.exit(1);
+    }
+  }
+  const tags = [];
+  let hasTags = false;
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === "--tag") {
+      hasTags = true;
+      if (argv[i + 1]) tags.push(argv[i + 1]);
+    }
+  }
+  const body = {};
+  if (title) body.title = title;
+  if (description) body.description = description;
+  if (assignRaw !== void 0) body.assignedTo = assignRaw === "" ? null : assignRaw;
+  if (priorityRaw) body.priority = parseInt(priorityRaw, 10);
+  if (hasTags) body.tags = tags;
+  if (commitRaw !== void 0) body.resolutionCommit = commitRaw === "" ? null : commitRaw;
+  if (Object.keys(body).length === 0) {
+    console.error("Error: No fields to update. Provide at least one of --title, --description, --assign, --priority, --tag, --commit.");
+    process.exit(1);
+  }
+  const result = await apiRequest(apiUrl, token, "PATCH", `/tasks/${id}`, body);
+  if (!result.ok) {
+    console.error(`Error: ${result.error ?? "Failed to update task"}`);
+    process.exit(1);
+  }
+  if (jsonOutput) {
+    console.log(JSON.stringify(result.data, null, 2));
+    return;
+  }
+  const task = result.data;
+  console.log(`Task ${id} updated.`);
+  console.log(`  Title:    ${task.title}`);
+  console.log(`  Priority: ${PRIORITY_LABELS[task.priority] ?? task.priority}`);
+  if (task.assignedTo) console.log(`  Assigned: ${task.assignedTo}`);
+}
+async function handleComplete(argv, apiUrl, token) {
+  const id = argv[0];
+  if (!id || id.startsWith("--")) {
+    console.error("Error: Missing task ID.");
+    console.error("Usage: canary task complete <id> [--pr <number>] [--commit <sha>]");
+    process.exit(1);
+  }
+  const prRaw = getArgValue(argv, "--pr");
+  const prNumber = parsePrFlag(prRaw);
+  const explicitCommit = getArgValue(argv, "--commit");
+  const commit = explicitCommit ?? (prNumber !== void 0 ? void 0 : getHeadCommit() ?? void 0);
+  const jsonOutput = hasFlag(argv, "--json");
+  const body = {};
+  if (commit) body.resolutionCommit = commit;
+  if (prNumber !== void 0) body.resolutionPrNumber = prNumber;
+  const result = await apiRequest(apiUrl, token, "POST", `/tasks/${id}/complete`, body);
+  if (!result.ok) {
+    console.error(`Error: ${result.error ?? "Failed to complete task"}`);
+    process.exit(1);
+  }
+  if (jsonOutput) {
+    console.log(JSON.stringify(result.data, null, 2));
+    return;
+  }
+  console.log(`Task ${id} marked as completed.`);
+  if (prNumber !== void 0) console.log(`Resolution PR: #${prNumber}`);
+  if (commit) console.log(`Resolution commit: ${commit.slice(0, 7)}`);
+}
+async function handleSetCommit(argv, apiUrl, token) {
+  const id = argv[0];
+  if (!id || id.startsWith("--")) {
+    console.error("Error: Missing task ID.");
+    console.error("Usage: canary task set-commit <id> [--pr <number>] [--commit <sha>]");
+    process.exit(1);
+  }
+  const prRaw = getArgValue(argv, "--pr");
+  const prFlagPresent = prRaw !== void 0;
+  const prNumber = prFlagPresent ? prRaw === "" ? null : parsePrFlag(prRaw) ?? void 0 : void 0;
+  const explicit = getArgValue(argv, "--commit");
+  let commit;
+  if (explicit !== void 0) {
+    commit = explicit === "" ? null : explicit;
+  } else if (prFlagPresent) {
+    commit = void 0;
+  } else {
+    const head = getHeadCommit();
+    if (head === null) {
+      console.error("Error: Could not determine commit \u2014 not in a git repo. Pass --commit <sha> or --pr <n> explicitly.");
+      process.exit(1);
+    }
+    commit = head;
+  }
+  const body = {};
+  if (commit !== void 0) body.resolutionCommit = commit;
+  if (prNumber !== void 0) body.resolutionPrNumber = prNumber;
+  if (Object.keys(body).length === 0) {
+    console.error("Error: Nothing to update. Pass --commit <sha> or --pr <n>.");
+    process.exit(1);
+  }
+  const jsonOutput = hasFlag(argv, "--json");
+  const result = await apiRequest(apiUrl, token, "PATCH", `/tasks/${id}`, body);
+  if (!result.ok) {
+    console.error(`Error: ${result.error ?? "Failed to update resolution"}`);
+    process.exit(1);
+  }
+  if (jsonOutput) {
+    console.log(JSON.stringify(result.data, null, 2));
+    return;
+  }
+  if (commit === null) console.log(`Task ${id} resolution commit cleared.`);
+  else if (commit !== void 0) console.log(`Task ${id} resolution commit set to ${commit.slice(0, 7)}.`);
+  if (prNumber === null) console.log(`Task ${id} resolution PR cleared.`);
+  else if (prNumber !== void 0) console.log(`Task ${id} resolution PR set to #${prNumber}.`);
+}
+function parsePrFlag(raw) {
+  if (raw === void 0 || raw === "") return void 0;
+  if (raw.includes("/") || raw.includes("http")) {
+    console.error(`Error: --pr expects a number, got "${raw}". Pass the PR number only.`);
+    process.exit(1);
+  }
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n <= 0) {
+    console.error(`Error: --pr must be a positive integer, got "${raw}".`);
+    process.exit(1);
+  }
+  return n;
+}
+async function handleCancel(argv, apiUrl, token) {
+  const id = argv[0];
+  if (!id || id.startsWith("--")) {
+    console.error("Error: Missing task ID.");
+    process.exit(1);
+  }
+  const result = await apiRequest(apiUrl, token, "POST", `/tasks/${id}/cancel`);
+  if (!result.ok) {
+    console.error(`Error: ${result.error ?? "Failed to cancel task"}`);
+    process.exit(1);
+  }
+  console.log(`Task ${id} canceled.`);
+}
+async function handleTrigger(argv, apiUrl, token) {
+  const id = argv[0];
+  if (!id || id.startsWith("--")) {
+    console.error("Error: Missing task ID.");
+    process.exit(1);
+  }
+  const result = await apiRequest(apiUrl, token, "POST", `/tasks/${id}/trigger`);
+  if (!result.ok) {
+    console.error(`Error: ${result.error ?? "Failed to trigger task"}`);
+    process.exit(1);
+  }
+  console.log(`Task ${id} triggered (now actionable).`);
+}
+async function handleReopen(argv, apiUrl, token) {
+  const id = argv[0];
+  if (!id || id.startsWith("--")) {
+    console.error("Error: Missing task ID.");
+    console.error("Usage: canary task reopen <id> [--status <actionable|in_progress>]");
+    process.exit(1);
+  }
+  const status = getArgValue(argv, "--status") ?? "actionable";
+  if (status !== "actionable" && status !== "in_progress") {
+    console.error(`Error: Invalid status "${status}". Must be "actionable" or "in_progress".`);
+    process.exit(1);
+  }
+  const jsonOutput = hasFlag(argv, "--json");
+  const result = await apiRequest(apiUrl, token, "POST", `/tasks/${id}/reopen`, { status });
+  if (!result.ok) {
+    console.error(`Error: ${result.error ?? "Failed to reopen task"}`);
+    process.exit(1);
+  }
+  if (jsonOutput) {
+    console.log(JSON.stringify(result.data, null, 2));
+    return;
+  }
+  console.log(`Task ${id} reopened (now ${status}).`);
+}
+async function handleRelease(argv, apiUrl, token) {
+  const id = argv[0];
+  if (!id || id.startsWith("--")) {
+    console.error("Error: Missing task ID.");
+    console.error("Usage: canary task release <id> [--status <actionable|waiting>]");
+    process.exit(1);
+  }
+  const status = getArgValue(argv, "--status") ?? "actionable";
+  if (status !== "actionable" && status !== "waiting") {
+    console.error(`Error: Invalid status "${status}". Must be "actionable" or "waiting".`);
+    process.exit(1);
+  }
+  const jsonOutput = hasFlag(argv, "--json");
+  const result = await apiRequest(apiUrl, token, "POST", `/tasks/${id}/release`, { status });
+  if (!result.ok) {
+    console.error(`Error: ${result.error ?? "Failed to release task"}`);
+    process.exit(1);
+  }
+  if (jsonOutput) {
+    console.log(JSON.stringify(result.data, null, 2));
+    return;
+  }
+  console.log(`Task ${id} released (now ${status}).`);
+}
+async function handleClaim(argv, apiUrl, token) {
+  const id = argv[0];
+  if (!id || id.startsWith("--")) {
+    console.error("Error: Missing task ID.");
+    process.exit(1);
+  }
+  const result = await apiRequest(apiUrl, token, "POST", `/tasks/${id}/claim`);
+  if (!result.ok) {
+    console.error(`Error: ${result.error ?? "Failed to claim task"}`);
+    process.exit(1);
+  }
+  console.log(`Task ${id} claimed (now in progress).`);
+}
+async function handleExecute(argv, apiUrl, token) {
+  const id = argv[0];
+  if (!id || id.startsWith("--")) {
+    console.error("Error: Missing task ID.");
+    console.error("Usage: canary task execute <id> --instance <instanceId>");
+    process.exit(1);
+  }
+  const instanceId = getArgValue(argv, "--instance");
+  if (!instanceId) {
+    console.error("Error: --instance <instanceId> is required.");
+    process.exit(1);
+  }
+  const result = await apiRequest(
+    apiUrl,
+    token,
+    "POST",
+    `/tasks/${id}/execute`,
+    { instanceId }
+  );
+  if (!result.ok) {
+    console.error(`Error: ${result.error ?? "Failed to execute task"}`);
+    process.exit(1);
+  }
+  console.log(`Task ${id} dispatched to sandbox instance ${instanceId}.`);
+  if (result.data?.jobId) {
+    console.log(`Job ID: ${result.data.jobId}`);
+  }
+}
+async function handleLinkCustomer(argv, apiUrl, token) {
+  const id = argv[0];
+  if (!id || id.startsWith("--")) {
+    console.error("Error: Missing task ID.");
+    console.error('Usage: canary task link-customer <id> --org <orgId> | --name "Customer Name"');
+    process.exit(1);
+  }
+  const orgId = getArgValue(argv, "--org");
+  const name = getArgValue(argv, "--name");
+  if (!orgId && !name) {
+    console.error('Error: --org <orgId> or --name "Customer Name" is required.');
+    process.exit(1);
+  }
+  const body = {};
+  if (orgId) body.orgId = orgId;
+  if (name) body.name = name;
+  const result = await apiRequest(
+    apiUrl,
+    token,
+    "POST",
+    `/tasks/${id}/customers`,
+    body
+  );
+  if (!result.ok) {
+    console.error(`Error: ${result.error ?? "Failed to link customer"}`);
+    process.exit(1);
+  }
+  console.log(`Customer linked to task ${id}: ${result.data?.name ?? name ?? orgId}`);
+}
+async function handleUnlinkCustomer(argv, apiUrl, token) {
+  const id = argv[0];
+  if (!id || id.startsWith("--")) {
+    console.error("Error: Missing task ID.");
+    console.error("Usage: canary task unlink-customer <taskId> --customer-id <customerId>");
+    process.exit(1);
+  }
+  const customerId = getArgValue(argv, "--customer-id");
+  if (!customerId) {
+    console.error("Error: --customer-id is required. Use `canary task get <id>` to see customer IDs.");
+    process.exit(1);
+  }
+  const result = await apiRequest(
+    apiUrl,
+    token,
+    "DELETE",
+    `/tasks/${id}/customers/${customerId}`
+  );
+  if (!result.ok) {
+    console.error(`Error: ${result.error ?? "Failed to unlink customer"}`);
+    process.exit(1);
+  }
+  console.log(`Customer unlinked from task ${id}.`);
+}
+async function handleComment(argv, apiUrl, token) {
+  const id = argv[0];
+  if (!id || id.startsWith("--")) {
+    console.error("Error: Missing task ID.");
+    console.error("Usage: canary task comment <id> <message>");
+    console.error("       canary task comment <id> --body <message>");
+    process.exit(1);
+  }
+  let body = getArgValue(argv, "--body");
+  if (!body) {
+    const rest = argv.slice(1).filter((a) => !a.startsWith("--"));
+    body = rest.join(" ").trim();
+  }
+  if (!body) {
+    console.error("Error: Comment body is required.");
+    console.error('Usage: canary task comment <id> "Your comment here"');
+    process.exit(1);
+  }
+  const result = await apiRequest(
+    apiUrl,
+    token,
+    "POST",
+    `/tasks/${id}/comments`,
+    { body }
+  );
+  if (!result.ok) {
+    console.error(`Error: ${result.error ?? "Failed to add comment"}`);
+    process.exit(1);
+  }
+  console.log(`Comment added to task ${id.slice(0, 8)}.`);
+}
+async function handleComments(argv, apiUrl, token) {
+  const id = argv[0];
+  if (!id || id.startsWith("--")) {
+    console.error("Error: Missing task ID.");
+    console.error("Usage: canary task comments <id>");
+    process.exit(1);
+  }
+  const jsonOutput = hasFlag(argv, "--json");
+  const page = getArgValue(argv, "--page") ?? "1";
+  const result = await apiRequest(
+    apiUrl,
+    token,
+    "GET",
+    `/tasks/${id}/comments?page=${page}&pageSize=25`
+  );
+  if (!result.ok) {
+    console.error(`Error: ${result.error ?? "Failed to list comments"}`);
+    process.exit(1);
+  }
+  if (jsonOutput) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (result.data.length === 0) {
+    console.log("No comments.");
+    return;
+  }
+  console.log(`Comments (page ${result.pagination.page}/${result.pagination.totalPages}, ${result.pagination.totalItems} total):
+`);
+  for (const c of result.data) {
+    const author = c.authorDisplayName ?? c.authorId.slice(0, 8);
+    const date = new Date(c.createdAt).toLocaleString();
+    console.log(`  ${author} \xB7 ${date}`);
+    console.log(`  ${c.body}
+`);
+  }
+}
+async function runTask(argv) {
+  const [subCommand, ...rest] = argv;
+  if (!subCommand || hasFlag(argv, "--help", "-h")) {
+    printHelp();
+    return;
+  }
+  const { apiUrl, token } = await resolveConfig(argv);
+  switch (subCommand) {
+    case "create":
+      await handleCreate(rest, apiUrl, token);
+      break;
+    case "list":
+      await handleList(rest, apiUrl, token);
+      break;
+    case "get":
+      await handleGet(rest, apiUrl, token);
+      break;
+    case "update":
+      await handleUpdate(rest, apiUrl, token);
+      break;
+    case "complete":
+      await handleComplete(rest, apiUrl, token);
+      break;
+    case "set-commit":
+      await handleSetCommit(rest, apiUrl, token);
+      break;
+    case "cancel":
+      await handleCancel(rest, apiUrl, token);
+      break;
+    case "reopen":
+      await handleReopen(rest, apiUrl, token);
+      break;
+    case "release":
+      await handleRelease(rest, apiUrl, token);
+      break;
+    case "trigger":
+      await handleTrigger(rest, apiUrl, token);
+      break;
+    case "claim":
+      await handleClaim(rest, apiUrl, token);
+      break;
+    case "execute":
+      await handleExecute(rest, apiUrl, token);
+      break;
+    case "comment":
+      await handleComment(rest, apiUrl, token);
+      break;
+    case "comments":
+      await handleComments(rest, apiUrl, token);
+      break;
+    case "subtasks":
+      await handleSubtasks(rest, apiUrl, token);
+      break;
+    case "link-customer":
+      await handleLinkCustomer(rest, apiUrl, token);
+      break;
+    case "unlink-customer":
+      await handleUnlinkCustomer(rest, apiUrl, token);
+      break;
+    default:
+      console.error(`Unknown sub-command: ${subCommand}`);
+      printHelp();
+      process.exit(1);
+  }
+}
+export {
+  runTask
+};
+//# sourceMappingURL=task-IQC3YR5K.js.map