@moxt-ai/cli 0.3.3-beta.0 → 0.3.3-beta.2

package/README.md

@@ -193,6 +193,11 @@ moxt workflow task assign -w <workspace-id> <workflow-file-id> <task-id> --teamm
 moxt workflow task assign -w <workspace-id> <workflow-file-id> <task-id> --clear
 moxt workflow task delete -w <workspace-id> <workflow-file-id> <task-id>
 
+# Manage workflow task comments
+moxt workflow comment create -w <workspace-id> <workflow-file-id> <task-id> --content-path <local-path>
+moxt workflow comment list -w <workspace-id> <workflow-file-id> <task-id>
+moxt workflow comment delete -w <workspace-id> <workflow-file-id> <task-id> <comment-id>
+
 # Inspect or abort workflow agent runs
 moxt workflow run status -w <workspace-id> <workflow-file-id> <trigger-id> [trigger-id...]
 moxt workflow run output -w <workspace-id> <workflow-file-id> <trigger-id>
@@ -201,6 +206,8 @@ moxt workflow run abort -w <workspace-id> <workflow-file-id> <trigger-id>
 
 Workflow, status, and task descriptions are read from local UTF-8 text files with `--desc-file`.
 Inline `--desc` is not supported.
+Workflow task comment content is read only from a local UTF-8 text file with `--content-path` and is limited to
+5,000 characters. Inline `--content` is not supported.
 Workflow status type values are `1=todo`, `2=in-progress`, and `3=done`.
 
 #### File command options

package/dist/index.js

@@ -6,6 +6,157 @@ import updateNotifier from "update-notifier";
 // src/program.ts
 import { Command } from "commander";
 
+// src/utils/output.ts
+var colors = {
+  bold: "\x1B[1m",
+  blue: "\x1B[1;34m",
+  green: "\x1B[32m",
+  red: "\x1B[31m",
+  cyan: "\x1B[36m",
+  dim: "\x1B[2m",
+  reset: "\x1B[0m"
+};
+function print(message) {
+  console.log(message);
+}
+function printError(message) {
+  console.error(`${colors.red}${message}${colors.reset}`);
+}
+
+// src/utils/runtime-context.ts
+var DEFAULT_USER_HOST = "api.moxt.ai";
+var SANDBOX_ENV_KEYS = ["BASE_API_HOST", "SANDBOX_TOOL_API_TOKEN", "MOXT_REPO_PAYLOAD", "MOXT_WORKSPACE_ID"];
+var RuntimeContextError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RuntimeContextError";
+  }
+};
+function resolveRuntimeContext(env = process.env) {
+  if (hasAnySandboxEnv(env)) {
+    return resolveSandboxRuntimeContext(env);
+  }
+  const apiKey = readNonEmptyEnv(env, "MOXT_API_KEY");
+  if (apiKey) {
+    return {
+      mode: "user",
+      host: readNonEmptyEnv(env, "MOXT_HOST") ?? DEFAULT_USER_HOST,
+      apiKey
+    };
+  }
+  throw new RuntimeContextError("Missing auth. Set sandbox environment variables or MOXT_API_KEY.");
+}
+function resolveSandboxRuntimeContext(env = process.env) {
+  const missingKeys = SANDBOX_ENV_KEYS.filter((key) => !readNonEmptyEnv(env, key));
+  if (missingKeys.length > 0) {
+    throw new RuntimeContextError(`Incomplete sandbox environment. Missing: ${missingKeys.join(", ")}.`);
+  }
+  return {
+    mode: "sandbox",
+    baseApiHost: normalizeBaseApiHost(readRequiredEnv(env, "BASE_API_HOST")),
+    sandboxToolApiToken: readRequiredEnv(env, "SANDBOX_TOOL_API_TOKEN"),
+    workspaceId: readRequiredEnv(env, "MOXT_WORKSPACE_ID"),
+    repoPayload: parseRepoPayload(readRequiredEnv(env, "MOXT_REPO_PAYLOAD"))
+  };
+}
+function parseRepoPayload(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new RuntimeContextError(`MOXT_REPO_PAYLOAD must be valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!isRecord(parsed)) {
+    throw new RuntimeContextError("MOXT_REPO_PAYLOAD must be a JSON object.");
+  }
+  const personal = parseRepoEntry(parsed.personal, "personal");
+  const teamsValue = parsed.teams;
+  if (!Array.isArray(teamsValue)) {
+    throw new RuntimeContextError("MOXT_REPO_PAYLOAD.teams must be an array.");
+  }
+  const teams = teamsValue.map((entry, index) => parseRepoEntry(entry, `teams[${index}]`));
+  const workspace = parsed.workspace == null ? null : parseRepoEntry(parsed.workspace, "workspace");
+  return { personal, teams, workspace };
+}
+function normalizeBaseApiHost(value) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    throw new RuntimeContextError("BASE_API_HOST must not be empty.");
+  }
+  return trimmed.replace(/\/+$/, "");
+}
+function hasAnySandboxEnv(env) {
+  return SANDBOX_ENV_KEYS.some((key) => readNonEmptyEnv(env, key) !== void 0);
+}
+function readRequiredEnv(env, key) {
+  const value = readNonEmptyEnv(env, key);
+  if (!value) {
+    throw new RuntimeContextError(`${key} is required.`);
+  }
+  return value;
+}
+function readNonEmptyEnv(env, key) {
+  const value = env[key];
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function parseRepoEntry(value, path2) {
+  if (!isRecord(value)) {
+    throw new RuntimeContextError(`MOXT_REPO_PAYLOAD.${path2} must be an object.`);
+  }
+  const repoId = readStringField(value, "repoId", path2);
+  const name = readStringField(value, "name", path2);
+  return { repoId, name };
+}
+function readStringField(record2, field, path2) {
+  const value = record2[field];
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new RuntimeContextError(`MOXT_REPO_PAYLOAD.${path2}.${field} must be a non-empty string.`);
+  }
+  return value;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/utils/sandbox-path.ts
+function listRepoEntries(repoPayload) {
+  return [
+    repoPayload.personal,
+    ...repoPayload.teams,
+    ...repoPayload.workspace ? [repoPayload.workspace] : []
+  ];
+}
+
+// src/commands/auth.ts
+function registerAuthCommand(program2) {
+  const auth = program2.command("auth").description("Authentication utilities");
+  auth.command("status").description("Show CLI authentication mode").action(() => {
+    try {
+      const context = resolveRuntimeContext();
+      if (context.mode === "sandbox") {
+        print(`${colors.bold}Mode${colors.reset}: sandbox`);
+        print(`${colors.bold}Workspace${colors.reset}: ${context.workspaceId}`);
+        print(`${colors.bold}Base API${colors.reset}: ${context.baseApiHost}`);
+        print(`${colors.bold}Repos${colors.reset}:`);
+        for (const repo of listRepoEntries(context.repoPayload)) {
+          print(`  ${repo.name}	${repo.repoId}`);
+        }
+        return;
+      }
+      print(`${colors.bold}Mode${colors.reset}: user`);
+      print(`${colors.bold}Host${colors.reset}: ${context.host}`);
+    } catch (error) {
+      if (error instanceof RuntimeContextError) {
+        printError(error.message);
+        process.exit(1);
+      }
+      throw error;
+    }
+  });
+}
+
 // src/commands/file.ts
 import * as fs from "fs";
 
@@ -149,7 +300,7 @@ function getApiKeyOrUndefined() {
 
 // src/utils/http.ts
 function getUserAgent() {
-  return `moxt-cli/${"0.3.3-beta.0"} (${platform()}/${arch()}) node/${process.versions.node}`;
+  return `moxt-cli/${"0.3.3-beta.2"} (${platform()}/${arch()}) node/${process.versions.node}`;
 }
 async function fetchApi(method, path2, body) {
   const apiKey = getApiKey();
@@ -205,23 +356,6 @@ async function httpRaw(method, path2, body) {
   };
 }
 
-// src/utils/output.ts
-var colors = {
-  bold: "\x1B[1m",
-  blue: "\x1B[1;34m",
-  green: "\x1B[32m",
-  red: "\x1B[31m",
-  cyan: "\x1B[36m",
-  dim: "\x1B[2m",
-  reset: "\x1B[0m"
-};
-function print(message) {
-  console.log(message);
-}
-function printError(message) {
-  console.error(`${colors.red}${message}${colors.reset}`);
-}
-
 // src/utils/search-options.ts
 var SearchOptionsError = class extends Error {
   constructor(message) {
@@ -946,7 +1080,10 @@ function registerWorkspaceCommand(program2) {
 
 // src/commands/workflow.ts
 import * as fs3 from "fs";
+import { TextDecoder } from "util";
 var MAX_DESC_LENGTH = 5e3;
+var MAX_COMMENT_CONTENT_LENGTH = 5e3;
+var MAX_COMMENT_CONTENT_BYTES = MAX_COMMENT_CONTENT_LENGTH * 4;
 var WorkflowOptionsError = class extends Error {
   constructor(message) {
     super(message);
@@ -1052,6 +1189,42 @@ function readDescFile(path2) {
   }
   return content;
 }
+function readCommentContentFile(path2) {
+  if (!fs3.existsSync(path2)) {
+    throw new WorkflowOptionsError(`Error: comment content file not found: ${path2}`);
+  }
+  const stat = fs3.statSync(path2);
+  if (!stat.isFile()) {
+    throw new WorkflowOptionsError(`Error: comment content path is not a file: ${path2}`);
+  }
+  if (stat.size > MAX_COMMENT_CONTENT_BYTES) {
+    throw new WorkflowOptionsError(
+      `Error: comment content file must be at most ${MAX_COMMENT_CONTENT_LENGTH} characters.`
+    );
+  }
+  const buffer2 = fs3.readFileSync(path2);
+  if (buffer2.includes(0)) {
+    throw new WorkflowOptionsError("Error: comment content file must not contain NUL bytes.");
+  }
+  if (isBinaryContent(buffer2)) {
+    throw new WorkflowOptionsError("Error: comment content file must be UTF-8 text, not binary content.");
+  }
+  let content;
+  try {
+    content = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(buffer2);
+  } catch {
+    throw new WorkflowOptionsError("Error: comment content file must contain valid UTF-8 text.");
+  }
+  if (content.length === 0) {
+    throw new WorkflowOptionsError("Error: comment content file must not be empty.");
+  }
+  if (content.length > MAX_COMMENT_CONTENT_LENGTH) {
+    throw new WorkflowOptionsError(
+      `Error: comment content file must be at most ${MAX_COMMENT_CONTENT_LENGTH} characters.`
+    );
+  }
+  return content;
+}
 function parseAssigneeBody(options, allowClear) {
   const hasClear = options.clear === true;
   const humanId = parseOptionalPositiveInteger(options.humanId, "--human-id");
@@ -1111,10 +1284,34 @@ function failResponse(response) {
   process.exit(1);
 }
 function priorityLabel(value) {
-  if (value === 0) return "urgent";
-  if (value === 1) return "high";
-  if (value === 2) return "medium";
-  return "low";
+  switch (value) {
+    case 0:
+      return "urgent";
+    case 1:
+      return "high";
+    case 2:
+      return "medium";
+    case 3:
+      return "low";
+    default: {
+      const unsupportedValue = value;
+      throw new Error(`Unsupported workflow task priority: ${String(unsupportedValue)}`);
+    }
+  }
+}
+function statusTypeLabel(value) {
+  switch (value) {
+    case 1:
+      return "todo";
+    case 2:
+      return "in-progress";
+    case 3:
+      return "done";
+    default: {
+      const unsupportedValue = value;
+      throw new Error(`Unsupported workflow status type: ${String(unsupportedValue)}`);
+    }
+  }
 }
 function formatAssignee(assignee) {
   if (!assignee) return "-";
@@ -1126,17 +1323,149 @@ function formatAssignee(assignee) {
 function printWorkflow(item) {
   print(`${colors.bold}${item.fileId}${colors.reset}	owner=${item.ownerHumanId ?? "-"}	desc=${item.desc ?? "-"}`);
 }
-function printStatus(item) {
-  print(
-    `${colors.bold}${item.scopedId}${colors.reset}	${item.name}	type=${item.type}	preferred=${formatAssignee(item.preferredAssignee)}`
+function indentation(size) {
+  return " ".repeat(size);
+}
+function escapeTerminalControlCharacters(value) {
+  return value.replace(/\r\n/g, "\n").replace(
+    /[\u0000-\u0008\u000B-\u001F\u007F-\u009F]/g,
+    (character) => `\\u${character.charCodeAt(0).toString(16).padStart(4, "0")}`
   );
 }
-function printTask(item) {
+function formatDetailScalar(value) {
+  if (value === null) return "null";
+  if (typeof value === "string") {
+    const escaped = escapeTerminalControlCharacters(value);
+    if (escaped === "") return '""';
+    if (/\n/.test(escaped)) return JSON.stringify(escaped);
+    return escaped;
+  }
+  return String(value);
+}
+function printDetailField(name, value, indent = 0) {
+  print(`${indentation(indent)}${name}: ${formatDetailScalar(value)}`);
+}
+function printDetailTextField(name, value, indent = 0) {
+  if (value === null || value === "") {
+    printDetailField(name, value, indent);
+    return;
+  }
+  const escaped = escapeTerminalControlCharacters(value);
+  print(`${indentation(indent)}${name}:`);
+  for (const line of escaped.split("\n")) {
+    print(`${indentation(indent + 2)}${line}`);
+  }
+}
+function printAssigneeDetail(name, assignee, indent = 0) {
+  if (assignee === null) {
+    printDetailField(name, null, indent);
+    return;
+  }
+  print(`${indentation(indent)}${name}:`);
+  printDetailField("type", assignee.type, indent + 2);
+  switch (assignee.type) {
+    case "human":
+      printDetailField("humanId", assignee.humanId, indent + 2);
+      printDetailField("displayName", assignee.displayName, indent + 2);
+      printDetailField("avatarUrl", assignee.avatarUrl, indent + 2);
+      return;
+    case "assistant":
+      printDetailField("aiAssistantId", assignee.aiAssistantId, indent + 2);
+      printDetailField("displayName", assignee.displayName, indent + 2);
+      printDetailField("avatarUrl", assignee.avatarUrl, indent + 2);
+      return;
+    case "teammate":
+      printDetailField("aiTeammateId", assignee.aiTeammateId, indent + 2);
+      printDetailField("displayName", assignee.displayName, indent + 2);
+      printDetailField("avatarUrl", assignee.avatarUrl, indent + 2);
+      return;
+    case "unknown":
+      printDetailField("humanId", assignee.humanId, indent + 2);
+      printDetailField("aiAssistantId", assignee.aiAssistantId, indent + 2);
+      printDetailField("aiTeammateId", assignee.aiTeammateId, indent + 2);
+  }
+}
+function printStatusRemainingFields(item, indent) {
+  printDetailField("name", item.name, indent);
+  printDetailTextField("desc", item.desc, indent);
+  printDetailField("type", `${item.type} (${statusTypeLabel(item.type)})`, indent);
+  printAssigneeDetail("preferredAssignee", item.preferredAssignee, indent);
+  printDetailField("order", item.order, indent);
+}
+function printStatusDetail(item) {
+  print(`${colors.bold}Status${colors.reset}`);
+  printDetailField("scopedId", item.scopedId);
+  printStatusRemainingFields(item, 0);
+}
+function printWorkflowDetail(item) {
+  print(`${colors.bold}Workflow${colors.reset}`);
+  printDetailField("fileId", item.fileId);
+  printDetailField("ownerHumanId", item.ownerHumanId);
+  printDetailTextField("desc", item.desc);
+  if (item.statusList.length === 0) {
+    print("statusList: []");
+  } else {
+    print("statusList:");
+    for (const status of item.statusList) {
+      print(`  - scopedId: ${status.scopedId}`);
+      printStatusRemainingFields(status, 4);
+    }
+  }
+  if (item.transitions.length === 0) {
+    print("transitions: []");
+  } else {
+    print("transitions:");
+    for (const transition of item.transitions) {
+      print(`  - statusFromScopedId: ${transition.statusFromScopedId}`);
+      printDetailField("statusToScopedId", transition.statusToScopedId, 4);
+    }
+  }
+}
+function printTaskSummary(item) {
   const runIds = item.agentRuns.map((run) => run.pipelineTriggerId).join(",") || "-";
   print(
     `${colors.bold}#${item.scopedId}${colors.reset}	${item.title}	status=${item.statusScopedId}	priority=${priorityLabel(item.priority)}	assignee=${formatAssignee(item.assignee)}	runs=${runIds}`
   );
 }
+function printTaskDetail(item) {
+  print(`${colors.bold}Task${colors.reset}`);
+  printDetailField("scopedId", item.scopedId);
+  printDetailField("workflowFileId", item.workflowFileId);
+  printDetailField("ownerHumanId", item.ownerHumanId);
+  printDetailField("title", item.title);
+  printDetailTextField("desc", item.desc);
+  printDetailField("statusScopedId", item.statusScopedId);
+  printDetailField("priority", `${item.priority} (${priorityLabel(item.priority)})`);
+  printAssigneeDetail("assignee", item.assignee);
+  if (item.linkedFileIds.length === 0) {
+    print("linkedFileIds: []");
+  } else {
+    print("linkedFileIds:");
+    for (const fileId of item.linkedFileIds) print(`  - ${fileId}`);
+  }
+  printDetailField("subscribed", item.subscribed);
+  if (item.agentRuns.length === 0) {
+    print("agentRuns: []");
+  } else {
+    print("agentRuns:");
+    for (const run of item.agentRuns) {
+      print(`  - pipelineTriggerId: ${run.pipelineTriggerId}`);
+      printAssigneeDetail("executor", run.executor, 4);
+    }
+  }
+  printDetailField("createdAt", item.createdAt);
+  printDetailField("latestActAt", item.latestActAt);
+}
+function printCommentDetail(item) {
+  print(`${colors.bold}Comment${colors.reset}`);
+  printDetailField("id", item.id);
+  printDetailField("workflowFileId", item.workflowFileId);
+  printDetailField("workflowTaskScopedId", item.workflowTaskScopedId);
+  printDetailTextField("content", item.content);
+  printAssigneeDetail("createdBy", item.createdBy);
+  printDetailField("createdAt", item.createdAt);
+  printDetailField("updatedAt", item.updatedAt);
+}
 function registerWorkflowCommand(program2) {
   const workflow = program2.command("workflow").description("Workflow operations");
   addWorkspaceOption(
@@ -1192,13 +1521,7 @@ function registerWorkflowCommand(program2) {
         failResponse(response);
       }
       stopSpinner(true, "Workflow fetched");
-      printWorkflow(response.data);
-      print(`${colors.bold}Statuses${colors.reset}`);
-      for (const status of response.data.statusList) printStatus(status);
-      print(`${colors.bold}Transitions${colors.reset}`);
-      for (const transition of response.data.transitions) {
-        print(`${transition.statusFromScopedId} -> ${transition.statusToScopedId}`);
-      }
+      printWorkflowDetail(response.data);
     }
   );
   addWorkspaceOption(
@@ -1254,6 +1577,7 @@ function registerWorkflowCommand(program2) {
   registerStatusCommands(workflow);
   registerTransitionCommands(workflow);
   registerTaskCommands(workflow);
+  registerCommentCommands(workflow);
   registerRunCommands(workflow);
 }
 function registerStatusCommands(workflow) {
@@ -1284,7 +1608,7 @@ function registerStatusCommands(workflow) {
         failResponse(response);
       }
       stopSpinner(true, "Status created");
-      printStatus(response.data);
+      printStatusDetail(response.data);
     }
   );
   addPreferredAssigneeOptions(
@@ -1319,7 +1643,7 @@ function registerStatusCommands(workflow) {
         failResponse(response);
       }
       stopSpinner(true, "Status updated");
-      printStatus(response.data);
+      printStatusDetail(response.data);
     }
   );
   addWorkspaceOption(
@@ -1415,7 +1739,7 @@ function registerTaskCommands(workflow) {
         return;
       }
       stopSpinner(true, `Found ${response.data.tasks.length} task(s)`);
-      for (const item of response.data.tasks) printTask(item);
+      for (const item of response.data.tasks) printTaskSummary(item);
       if (response.data.nextCursor) print(`${colors.dim}nextCursor=${response.data.nextCursor}${colors.reset}`);
     }
   );
@@ -1432,7 +1756,7 @@ function registerTaskCommands(workflow) {
       failResponse(response);
     }
     stopSpinner(true, "Task fetched");
-    printTask(response.data);
+    printTaskDetail(response.data);
   });
   addAssigneeOptions(
     addWorkspaceOption(
@@ -1463,7 +1787,7 @@ function registerTaskCommands(workflow) {
         failResponse(response);
       }
       stopSpinner(true, "Task created");
-      printTask(response.data);
+      printTaskDetail(response.data);
     }
   );
   addWorkspaceOption(
@@ -1497,7 +1821,7 @@ function registerTaskCommands(workflow) {
         failResponse(response);
       }
       stopSpinner(true, "Task updated");
-      printTask(response.data);
+      printTaskDetail(response.data);
     }
   );
   for (const action of ["add-linked-files", "remove-linked-files"]) {
@@ -1517,7 +1841,7 @@ function registerTaskCommands(workflow) {
           failResponse(response);
         }
         stopSpinner(true, action === "add-linked-files" ? "Linked files added" : "Linked files removed");
-        printTask(response.data);
+        printTaskDetail(response.data);
       }
     );
   }
@@ -1539,7 +1863,7 @@ function registerTaskCommands(workflow) {
         failResponse(response);
       }
       stopSpinner(true, "Task moved");
-      printTask(response.data);
+      printTaskDetail(response.data);
     }
   );
   addAssigneeOptions(
@@ -1564,7 +1888,7 @@ function registerTaskCommands(workflow) {
         failResponse(response);
       }
       stopSpinner(true, "Task assignee updated");
-      printTask(response.data);
+      printTaskDetail(response.data);
     }
   );
   addWorkspaceOption(
@@ -1582,6 +1906,71 @@ function registerTaskCommands(workflow) {
     stopSpinner(true, `Deleted: ${response.data.scopedId}`);
   });
 }
+function registerCommentCommands(workflow) {
+  const comment = workflow.command("comment").description("Workflow task comment operations");
+  addWorkspaceOption(
+    comment.command("create").description("Create a workflow task comment").argument("<workflowFileId>").argument("<taskScopedId>").requiredOption("--content-path <localPath>", "Local UTF-8 text file for comment content")
+  ).action(
+    async (workflowFileId, taskScopedId, options) => {
+      const { id, content } = runOrExit3(() => ({
+        id: parsePositiveInteger(taskScopedId, "taskScopedId"),
+        content: readCommentContentFile(options.contentPath)
+      }));
+      startSpinner("Creating comment...");
+      const response = await httpPost(
+        `/workspaces/${options.workspace}/workflows/${workflowFileId}/tasks/${id}/comments`,
+        { content }
+      );
+      if (!response.ok) {
+        stopSpinner(false, "Failed");
+        failResponse(response);
+      }
+      stopSpinner(true, "Comment created");
+      printCommentDetail(response.data);
+    }
+  );
+  addWorkspaceOption(
+    comment.command("list").description("List workflow task comments").argument("<workflowFileId>").argument("<taskScopedId>")
+  ).action(async (workflowFileId, taskScopedId, options) => {
+    const id = runOrExit3(() => parsePositiveInteger(taskScopedId, "taskScopedId"));
+    startSpinner("Fetching comments...");
+    const response = await httpGet(
+      `/workspaces/${options.workspace}/workflows/${workflowFileId}/tasks/${id}/comments`
+    );
+    if (!response.ok) {
+      stopSpinner(false, "Failed");
+      failResponse(response);
+    }
+    if (response.data.items.length === 0) {
+      stopSpinner(true, "No comments found.");
+      return;
+    }
+    stopSpinner(true, `Found ${response.data.items.length} comment(s)`);
+    response.data.items.forEach((item, index) => {
+      if (index > 0) print("");
+      printCommentDetail(item);
+    });
+  });
+  addWorkspaceOption(
+    comment.command("delete").description("Delete a workflow task comment").argument("<workflowFileId>").argument("<taskScopedId>").argument("<commentId>")
+  ).action(
+    async (workflowFileId, taskScopedId, commentId, options) => {
+      const ids = runOrExit3(() => ({
+        task: parsePositiveInteger(taskScopedId, "taskScopedId"),
+        comment: parsePositiveInteger(commentId, "commentId")
+      }));
+      startSpinner("Deleting comment...");
+      const response = await httpDelete(
+        `/workspaces/${options.workspace}/workflows/${workflowFileId}/tasks/${ids.task}/comments/${ids.comment}`
+      );
+      if (!response.ok) {
+        stopSpinner(false, "Failed");
+        failResponse(response);
+      }
+      stopSpinner(true, `Deleted: ${response.data.id}`);
+    }
+  );
+}
 function registerRunCommands(workflow) {
   const run = workflow.command("run").description("Workflow agent run operations");
   addWorkspaceOption(
@@ -1642,6 +2031,7 @@ function createProgram(version) {
   program2.name("moxt").description("Moxt CLI - AI Workspace").version(version).action(() => {
     program2.help();
   });
+  registerAuthCommand(program2);
   registerWhoamiCommand(program2);
   registerWorkspaceCommand(program2);
   registerFileCommand(program2);
@@ -1659,7 +2049,7 @@ var FLUSH_TIMEOUT_MS = 3e3;
 var MAX_BATCH_SIZE = 100;
 function commonLabels() {
   return {
-    cli_version: "0.3.3-beta.0",
+    cli_version: "0.3.3-beta.2",
     node_version: process.versions.node,
     os: platform2(),
     arch: arch2(),
@@ -1705,7 +2095,7 @@ async function flush() {
   }
   const batch = buffer.splice(0, MAX_BATCH_SIZE);
   const payload = {
-    release_id: "0.3.3-beta.0",
+    release_id: "0.3.3-beta.2",
     client_type: "cli",
     metric_data_list: batch.map((m) => ({
       profile: "cli",
@@ -1846,9 +2236,9 @@ function installExitHandler() {
 
 // src/index.ts
 updateNotifier({
-  pkg: { name: "@moxt-ai/cli", version: "0.3.3-beta.0" }
+  pkg: { name: "@moxt-ai/cli", version: "0.3.3-beta.2" }
 }).notify();
-var program = createProgram("0.3.3-beta.0");
+var program = createProgram("0.3.3-beta.2");
 instrumentProgram(program);
 installExitHandler();
 program.parseAsync(process.argv).then(async () => {