@moxt-ai/cli 0.3.2 → 0.3.3-beta.1

package/dist/index.js

@@ -1,9 +1,162 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command } from "commander";
 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";
 
@@ -147,7 +300,7 @@ function getApiKeyOrUndefined() {
 
 // src/utils/http.ts
 function getUserAgent() {
-  return `moxt-cli/${"0.3.2"} (${platform()}/${arch()}) node/${process.versions.node}`;
+  return `moxt-cli/${"0.3.3-beta.1"} (${platform()}/${arch()}) node/${process.versions.node}`;
 }
 async function fetchApi(method, path2, body) {
   const apiKey = getApiKey();
@@ -187,6 +340,9 @@ async function httpPut(path2, body) {
 async function httpPost(path2, body) {
   return request("POST", path2, body);
 }
+async function httpPatch(path2, body) {
+  return request("PATCH", path2, body);
+}
 async function httpDelete(path2, body) {
   return request("DELETE", path2, body);
 }
@@ -200,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) {
@@ -939,6 +1078,844 @@ function registerWorkspaceCommand(program2) {
   });
 }
 
+// src/commands/workflow.ts
+import * as fs3 from "fs";
+var MAX_DESC_LENGTH = 5e3;
+var WorkflowOptionsError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WorkflowOptionsError";
+  }
+};
+function runOrExit3(fn) {
+  try {
+    return fn();
+  } catch (err) {
+    if (err instanceof WorkflowOptionsError || err instanceof SpaceOptionsError || err instanceof SearchOptionsError) {
+      printError(err.message);
+      process.exit(1);
+    }
+    throw err;
+  }
+}
+function addWorkspaceOption(command) {
+  return command.requiredOption("-w, --workspace <workspaceId>", "Workspace ID");
+}
+function addSpaceOptions2(command) {
+  return addWorkspaceOption(command).option("-s, --space <name>", "Space name (personal or teamspace name)").option("--personal", "Use personal space (default)").option("--team-space-id <teamSpaceId>", "Team space ID").option("--teammate-id <teammateId>", "Teammate ID (teammate space)");
+}
+function addAssigneeOptions(command) {
+  return command.option("--human-id <humanId>", "Human assignee ID").option("--assistant-id <assistantId>", "AI assistant assignee ID").option("--teammate-id <teammateId>", "AI teammate assignee ID");
+}
+function addPreferredAssigneeOptions(command) {
+  return command.option("--preferred-human-id <humanId>", "Preferred human assignee ID").option("--preferred-assistant-id <assistantId>", "Preferred AI assistant assignee ID").option("--preferred-teammate-id <teammateId>", "Preferred AI teammate assignee ID");
+}
+function parsePositiveInteger(raw, label) {
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isInteger(parsed) || parsed <= 0 || String(parsed) !== raw) {
+    throw new WorkflowOptionsError(`Error: ${label} must be a positive integer, got "${raw}".`);
+  }
+  return parsed;
+}
+function parseOptionalPositiveInteger(raw, label) {
+  if (raw == null || raw === "") return void 0;
+  return parsePositiveInteger(raw, label);
+}
+function parseStatusType(raw) {
+  if (raw == null || raw === "") return void 0;
+  const parsed = Number.parseInt(raw, 10);
+  if ((parsed === 1 || parsed === 2 || parsed === 3) && String(parsed) === raw) return parsed;
+  throw new WorkflowOptionsError("Error: --type must be one of 1 (todo), 2 (in-progress), or 3 (done).");
+}
+function parseRequiredStatusType(raw) {
+  const value = parseStatusType(raw);
+  if (value === void 0) {
+    throw new WorkflowOptionsError("Error: --type is required.");
+  }
+  return value;
+}
+function parsePriority(raw) {
+  if (raw == null || raw === "") return void 0;
+  if (raw === "urgent") return 0;
+  if (raw === "high") return 1;
+  if (raw === "medium") return 2;
+  if (raw === "low") return 3;
+  throw new WorkflowOptionsError('Error: --priority must be "urgent", "high", "medium", or "low".');
+}
+function parseRequiredPriority(raw) {
+  return parsePriority(raw ?? "medium") ?? 2;
+}
+function parseWorkflowScope(raw) {
+  if (raw == null || raw === "") return "all";
+  if (raw === "all" || raw === "owner_is_me") return raw;
+  throw new WorkflowOptionsError('Error: --scope must be "all" or "owner_is_me".');
+}
+function parseTaskScope(raw) {
+  if (raw == null || raw === "") return "all";
+  if (raw === "all" || raw === "assigned_to_me" || raw === "subscribed_by_me" || raw === "owner_is_me") {
+    return raw;
+  }
+  throw new WorkflowOptionsError(
+    'Error: --scope must be "all", "assigned_to_me", "subscribed_by_me", or "owner_is_me".'
+  );
+}
+function parseFileIds(raw, label = "--file-ids") {
+  if (raw == null || raw === "") return void 0;
+  const ids = raw.split(",").map((item) => item.trim()).filter(Boolean);
+  if (ids.length === 0) {
+    throw new WorkflowOptionsError(`Error: ${label} must include at least one file ID.`);
+  }
+  return ids;
+}
+function readDescFile(path2) {
+  if (path2 == null || path2 === "") return void 0;
+  if (!fs3.existsSync(path2)) {
+    throw new WorkflowOptionsError(`Error: desc file not found: ${path2}`);
+  }
+  const stat = fs3.statSync(path2);
+  if (!stat.isFile()) {
+    throw new WorkflowOptionsError(`Error: desc file is not a file: ${path2}`);
+  }
+  const buffer2 = fs3.readFileSync(path2);
+  if (isBinaryContent(buffer2)) {
+    throw new WorkflowOptionsError("Error: desc file must be UTF-8 text, not binary content.");
+  }
+  const content = buffer2.toString("utf8");
+  if (content.length > MAX_DESC_LENGTH) {
+    throw new WorkflowOptionsError(`Error: desc file must be at most ${MAX_DESC_LENGTH} characters.`);
+  }
+  return content;
+}
+function parseAssigneeBody(options, allowClear) {
+  const hasClear = options.clear === true;
+  const humanId = parseOptionalPositiveInteger(options.humanId, "--human-id");
+  const assistantId = parseOptionalPositiveInteger(options.assistantId, "--assistant-id");
+  const teammateId = parseOptionalPositiveInteger(options.teammateId, "--teammate-id");
+  const count = (humanId !== void 0 ? 1 : 0) + (assistantId !== void 0 ? 1 : 0) + (teammateId !== void 0 ? 1 : 0);
+  if (hasClear && !allowClear) {
+    throw new WorkflowOptionsError("Error: --clear is not supported here.");
+  }
+  if (hasClear && count > 0) {
+    throw new WorkflowOptionsError("Error: --clear cannot be used with assignee ID options.");
+  }
+  if (count > 1) {
+    throw new WorkflowOptionsError("Error: assignee ID options are mutually exclusive.");
+  }
+  if (hasClear) return {};
+  if (humanId !== void 0) return { assigneeHumanId: humanId };
+  if (assistantId !== void 0) return { assigneeAiAssistantId: assistantId };
+  if (teammateId !== void 0) return { assigneeAiTeammateId: teammateId };
+  return {};
+}
+function parsePreferredAssigneeBody(options) {
+  const hasClear = options.clearPreferredAssignee === true;
+  const humanId = parseOptionalPositiveInteger(options.preferredHumanId, "--preferred-human-id");
+  const assistantId = parseOptionalPositiveInteger(options.preferredAssistantId, "--preferred-assistant-id");
+  const teammateId = parseOptionalPositiveInteger(options.preferredTeammateId, "--preferred-teammate-id");
+  const count = (humanId !== void 0 ? 1 : 0) + (assistantId !== void 0 ? 1 : 0) + (teammateId !== void 0 ? 1 : 0);
+  if (hasClear && count > 0) {
+    throw new WorkflowOptionsError("Error: --clear-preferred-assignee cannot be used with preferred assignee ID options.");
+  }
+  if (count > 1) {
+    throw new WorkflowOptionsError("Error: preferred assignee ID options are mutually exclusive.");
+  }
+  if (hasClear) return { preferredAssigneeHumanId: null };
+  if (humanId !== void 0) return { preferredAssigneeHumanId: humanId };
+  if (assistantId !== void 0) return { preferredAssigneeAiAssistantId: assistantId };
+  if (teammateId !== void 0) return { preferredAssigneeAiTeammateId: teammateId };
+  return {};
+}
+function assertNonEmptyBody(body) {
+  if (Object.keys(body).length === 0) {
+    throw new WorkflowOptionsError("Error: at least one update option must be provided.");
+  }
+}
+function buildQuery(params) {
+  const query = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0) {
+      query.set(key, String(value));
+    }
+  }
+  const text = query.toString();
+  return text ? `?${text}` : "";
+}
+function failResponse(response) {
+  printError(`Error [${response.status}]: ${JSON.stringify(response.data)}`);
+  process.exit(1);
+}
+function priorityLabel(value) {
+  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 "-";
+  if (assignee.type === "human") return assignee.displayName ?? `human:${assignee.humanId}`;
+  if (assignee.type === "assistant") return assignee.displayName ?? `assistant:${assignee.aiAssistantId}`;
+  if (assignee.type === "teammate") return assignee.displayName ?? `teammate:${assignee.aiTeammateId}`;
+  return "unknown";
+}
+function printWorkflow(item) {
+  print(`${colors.bold}${item.fileId}${colors.reset}	owner=${item.ownerHumanId ?? "-"}	desc=${item.desc ?? "-"}`);
+}
+function indentation(size) {
+  return " ".repeat(size);
+}
+function formatDetailScalar(value) {
+  if (value === null) return "null";
+  if (value === "") return '""';
+  if (typeof value === "string" && /[\r\n]/.test(value)) return JSON.stringify(value);
+  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;
+  }
+  print(`${indentation(indent)}${name}:`);
+  for (const line of value.split(/\r?\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 registerWorkflowCommand(program2) {
+  const workflow = program2.command("workflow").description("Workflow operations");
+  addWorkspaceOption(
+    workflow.command("list").description("List accessible workflows").option("--scope <scope>", "Workflow scope: all or owner_is_me", "all")
+  ).action(async (options) => {
+    const scope = runOrExit3(() => parseWorkflowScope(options.scope));
+    startSpinner("Fetching workflows...");
+    const response = await httpGet(
+      `/workspaces/${options.workspace}/workflows${buildQuery({ scope })}`
+    );
+    if (!response.ok) {
+      stopSpinner(false, "Failed");
+      failResponse(response);
+    }
+    if (response.data.workflows.length === 0) {
+      stopSpinner(true, "No workflows found.");
+      return;
+    }
+    stopSpinner(true, `Found ${response.data.workflows.length} workflow(s)`);
+    for (const item of response.data.workflows) printWorkflow(item);
+  });
+  addSpaceOptions2(
+    workflow.command("create").description("Create a blank workflow").requiredOption("-p, --path <path>", "Target .workflow path").option("--desc-file <localPath>", "Local UTF-8 text file for workflow description").option("--owner-human-id <humanId>", "Workflow owner human ID")
+  ).action(async (options) => {
+    const body = runOrExit3(() => {
+      const next = {
+        path: options.path,
+        ...resolveSpaceSelector(options)
+      };
+      const desc = readDescFile(options.descFile);
+      if (desc !== void 0) next.desc = desc;
+      const ownerHumanId = parseOptionalPositiveInteger(options.ownerHumanId, "--owner-human-id");
+      if (ownerHumanId !== void 0) next.ownerHumanId = ownerHumanId;
+      return next;
+    });
+    startSpinner("Creating workflow...");
+    const response = await httpPost(`/workspaces/${options.workspace}/workflows`, body);
+    if (!response.ok) {
+      stopSpinner(false, "Failed");
+      failResponse(response);
+    }
+    stopSpinner(true, "Workflow created");
+    printWorkflow(response.data);
+  });
+  addWorkspaceOption(workflow.command("get").description("Get a workflow").argument("<workflowFileId>")).action(
+    async (workflowFileId, options) => {
+      startSpinner("Fetching workflow...");
+      const response = await httpGet(
+        `/workspaces/${options.workspace}/workflows/${workflowFileId}`
+      );
+      if (!response.ok) {
+        stopSpinner(false, "Failed");
+        failResponse(response);
+      }
+      stopSpinner(true, "Workflow fetched");
+      printWorkflowDetail(response.data);
+    }
+  );
+  addWorkspaceOption(
+    workflow.command("update").description("Update workflow metadata").argument("<workflowFileId>").option("--desc-file <localPath>", "Local UTF-8 text file for workflow description").option("--owner-human-id <humanId>", "Workflow owner human ID")
+  ).action(async (workflowFileId, options) => {
+    const body = runOrExit3(() => {
+      const next = {};
+      const desc = readDescFile(options.descFile);
+      if (desc !== void 0) next.desc = desc;
+      const ownerHumanId = parseOptionalPositiveInteger(options.ownerHumanId, "--owner-human-id");
+      if (ownerHumanId !== void 0) next.ownerHumanId = ownerHumanId;
+      assertNonEmptyBody(next);
+      return next;
+    });
+    startSpinner("Updating workflow...");
+    const response = await httpPatch(`/workspaces/${options.workspace}/workflows/${workflowFileId}`, body);
+    if (!response.ok) {
+      stopSpinner(false, "Failed");
+      failResponse(response);
+    }
+    stopSpinner(true, "Workflow updated");
+    printWorkflow(response.data);
+  });
+  addWorkspaceOption(
+    workflow.command("delete").description("Delete a workflow").argument("<workflowFileId>").option("--message <message>", "Commit message")
+  ).action(async (workflowFileId, options) => {
+    startSpinner("Deleting workflow...");
+    const response = await httpDelete(
+      `/workspaces/${options.workspace}/workflows/${workflowFileId}`,
+      options.message ? { message: options.message } : {}
+    );
+    if (!response.ok) {
+      stopSpinner(false, "Failed");
+      failResponse(response);
+    }
+    stopSpinner(true, `Deleted: ${response.data.fileId}`);
+  });
+  addWorkspaceOption(workflow.command("duplicate").description("Duplicate a workflow").argument("<workflowFileId>")).action(
+    async (workflowFileId, options) => {
+      startSpinner("Duplicating workflow...");
+      const response = await httpPost(
+        `/workspaces/${options.workspace}/workflows/${workflowFileId}/duplicate`,
+        {}
+      );
+      if (!response.ok) {
+        stopSpinner(false, "Failed");
+        failResponse(response);
+      }
+      stopSpinner(true, "Workflow duplicated");
+      printWorkflow(response.data);
+    }
+  );
+  registerStatusCommands(workflow);
+  registerTransitionCommands(workflow);
+  registerTaskCommands(workflow);
+  registerRunCommands(workflow);
+}
+function registerStatusCommands(workflow) {
+  const status = workflow.command("status").description("Workflow status operations");
+  addPreferredAssigneeOptions(
+    addWorkspaceOption(
+      status.command("create").description("Create a workflow status").argument("<workflowFileId>").requiredOption("--name <name>", "Status name").requiredOption("--type <type>", "Status type value: 1=todo, 2=in-progress, 3=done").option("--desc-file <localPath>", "Local UTF-8 text file for status description")
+    )
+  ).action(
+    async (workflowFileId, options) => {
+      const body = runOrExit3(() => {
+        const next = {
+          name: options.name,
+          type: parseRequiredStatusType(options.type)
+        };
+        const desc = readDescFile(options.descFile);
+        if (desc !== void 0) next.desc = desc;
+        Object.assign(next, parsePreferredAssigneeBody(options));
+        return next;
+      });
+      startSpinner("Creating status...");
+      const response = await httpPost(
+        `/workspaces/${options.workspace}/workflows/${workflowFileId}/statuses`,
+        body
+      );
+      if (!response.ok) {
+        stopSpinner(false, "Failed");
+        failResponse(response);
+      }
+      stopSpinner(true, "Status created");
+      printStatusDetail(response.data);
+    }
+  );
+  addPreferredAssigneeOptions(
+    addWorkspaceOption(
+      status.command("update").description("Update a workflow status").argument("<workflowFileId>").argument("<statusScopedId>").option("--name <name>", "Status name").option("--type <type>", "Status type value: 1=todo, 2=in-progress, 3=done").option("--desc-file <localPath>", "Local UTF-8 text file for status description").option("--clear-desc", "Clear status description").option("--clear-preferred-assignee", "Clear preferred assignee")
+    )
+  ).action(
+    async (workflowFileId, statusScopedId, options) => {
+      const body = runOrExit3(() => {
+        if (options.descFile && options.clearDesc) {
+          throw new WorkflowOptionsError("Error: --desc-file cannot be used with --clear-desc.");
+        }
+        const next = {};
+        if (options.name) next.name = options.name;
+        const type = parseStatusType(options.type);
+        if (type !== void 0) next.type = type;
+        const desc = readDescFile(options.descFile);
+        if (desc !== void 0) next.desc = desc;
+        if (options.clearDesc) next.desc = null;
+        Object.assign(next, parsePreferredAssigneeBody(options));
+        assertNonEmptyBody(next);
+        return next;
+      });
+      const id = runOrExit3(() => parsePositiveInteger(statusScopedId, "statusScopedId"));
+      startSpinner("Updating status...");
+      const response = await httpPatch(
+        `/workspaces/${options.workspace}/workflows/${workflowFileId}/statuses/${id}`,
+        body
+      );
+      if (!response.ok) {
+        stopSpinner(false, "Failed");
+        failResponse(response);
+      }
+      stopSpinner(true, "Status updated");
+      printStatusDetail(response.data);
+    }
+  );
+  addWorkspaceOption(
+    status.command("move-after").description("Move a workflow status after another status").argument("<workflowFileId>").argument("<statusScopedId>").option("--after <statusScopedId>", "Anchor status scoped ID").option("--first", "Move to first position")
+  ).action(
+    async (workflowFileId, statusScopedId, options) => {
+      const { id, anchoredStatusScopedId } = runOrExit3(() => {
+        if (options.after && options.first) {
+          throw new WorkflowOptionsError("Error: --after cannot be used with --first.");
+        }
+        if (!options.after && !options.first) {
+          throw new WorkflowOptionsError("Error: either --after or --first is required.");
+        }
+        return {
+          id: parsePositiveInteger(statusScopedId, "statusScopedId"),
+          anchoredStatusScopedId: options.first ? null : parsePositiveInteger(options.after, "--after")
+        };
+      });
+      startSpinner("Moving status...");
+      const response = await httpPost(
+        `/workspaces/${options.workspace}/workflows/${workflowFileId}/statuses/${id}/move-after`,
+        { anchoredStatusScopedId }
+      );
+      if (!response.ok) {
+        stopSpinner(false, "Failed");
+        failResponse(response);
+      }
+      stopSpinner(true, "Status moved");
+    }
+  );
+  addWorkspaceOption(
+    status.command("delete").description("Delete a workflow status").argument("<workflowFileId>").argument("<statusScopedId>")
+  ).action(async (workflowFileId, statusScopedId, options) => {
+    const id = runOrExit3(() => parsePositiveInteger(statusScopedId, "statusScopedId"));
+    startSpinner("Deleting status...");
+    const response = await httpDelete(
+      `/workspaces/${options.workspace}/workflows/${workflowFileId}/statuses/${id}`
+    );
+    if (!response.ok) {
+      stopSpinner(false, "Failed");
+      failResponse(response);
+    }
+    stopSpinner(true, `Deleted: ${response.data.scopedId}`);
+  });
+}
+function registerTransitionCommands(workflow) {
+  const transition = workflow.command("transition").description("Workflow transition operations");
+  for (const action of ["create", "delete"]) {
+    addWorkspaceOption(
+      transition.command(action).description(`${action === "create" ? "Create" : "Delete"} a workflow transition`).argument("<workflowFileId>").requiredOption("--from <statusScopedId>", "Source status scoped ID").requiredOption("--to <statusScopedId>", "Target status scoped ID")
+    ).action(async (workflowFileId, options) => {
+      const body = runOrExit3(() => ({
+        statusFromScopedId: parsePositiveInteger(options.from, "--from"),
+        statusToScopedId: parsePositiveInteger(options.to, "--to")
+      }));
+      startSpinner(`${action === "create" ? "Creating" : "Deleting"} transition...`);
+      const response = action === "create" ? await httpPost(
+        `/workspaces/${options.workspace}/workflows/${workflowFileId}/transitions`,
+        body
+      ) : await httpDelete(
+        `/workspaces/${options.workspace}/workflows/${workflowFileId}/transitions`,
+        body
+      );
+      if (!response.ok) {
+        stopSpinner(false, "Failed");
+        failResponse(response);
+      }
+      stopSpinner(true, action === "create" ? "Transition created" : "Transition deleted");
+      print(`${response.data.statusFromScopedId} -> ${response.data.statusToScopedId}`);
+    });
+  }
+}
+function registerTaskCommands(workflow) {
+  const task = workflow.command("task").description("Workflow task operations");
+  addWorkspaceOption(
+    task.command("list").description("List workflow tasks").option("--workflow-file-id <workflowFileId>", "Filter by workflow file ID").option("--scope <scope>", "Task scope", "all").option("-l, --limit <limit>", "Maximum number of tasks to return", "20").option("--cursor <cursor>", "Pagination cursor")
+  ).action(
+    async (options) => {
+      const query = runOrExit3(() => buildQuery({
+        scope: parseTaskScope(options.scope),
+        limit: parseSearchLimit(options.limit, 20, 100),
+        cursor: options.cursor,
+        workflowFileId: options.workflowFileId
+      }));
+      startSpinner("Fetching workflow tasks...");
+      const response = await httpGet(`/workspaces/${options.workspace}/workflow-tasks${query}`);
+      if (!response.ok) {
+        stopSpinner(false, "Failed");
+        failResponse(response);
+      }
+      if (response.data.tasks.length === 0) {
+        stopSpinner(true, "No workflow tasks found.");
+        return;
+      }
+      stopSpinner(true, `Found ${response.data.tasks.length} task(s)`);
+      for (const item of response.data.tasks) printTaskSummary(item);
+      if (response.data.nextCursor) print(`${colors.dim}nextCursor=${response.data.nextCursor}${colors.reset}`);
+    }
+  );
+  addWorkspaceOption(
+    task.command("get").description("Get a workflow task").argument("<workflowFileId>").argument("<taskScopedId>")
+  ).action(async (workflowFileId, taskScopedId, options) => {
+    const id = runOrExit3(() => parsePositiveInteger(taskScopedId, "taskScopedId"));
+    startSpinner("Fetching task...");
+    const response = await httpGet(
+      `/workspaces/${options.workspace}/workflows/${workflowFileId}/tasks/${id}`
+    );
+    if (!response.ok) {
+      stopSpinner(false, "Failed");
+      failResponse(response);
+    }
+    stopSpinner(true, "Task fetched");
+    printTaskDetail(response.data);
+  });
+  addAssigneeOptions(
+    addWorkspaceOption(
+      task.command("create").description("Create a workflow task").argument("<workflowFileId>").requiredOption("--title <title>", "Task title").requiredOption("--status <statusScopedId>", "Status scoped ID").option("--priority <priority>", "Priority: urgent, high, medium, or low", "medium").option("--desc-file <localPath>", "Local UTF-8 text file for task description").option("--owner-human-id <humanId>", "Task owner human ID")
+    )
+  ).action(
+    async (workflowFileId, options) => {
+      const body = runOrExit3(() => {
+        const next = {
+          title: options.title,
+          statusScopedId: parsePositiveInteger(options.status, "--status"),
+          priority: parseRequiredPriority(options.priority)
+        };
+        const desc = readDescFile(options.descFile);
+        if (desc !== void 0) next.desc = desc;
+        const ownerHumanId = parseOptionalPositiveInteger(options.ownerHumanId, "--owner-human-id");
+        if (ownerHumanId !== void 0) next.ownerHumanId = ownerHumanId;
+        Object.assign(next, parseAssigneeBody(options, false));
+        return next;
+      });
+      startSpinner("Creating task...");
+      const response = await httpPost(
+        `/workspaces/${options.workspace}/workflows/${workflowFileId}/tasks`,
+        body
+      );
+      if (!response.ok) {
+        stopSpinner(false, "Failed");
+        failResponse(response);
+      }
+      stopSpinner(true, "Task created");
+      printTaskDetail(response.data);
+    }
+  );
+  addWorkspaceOption(
+    task.command("update").description("Update workflow task metadata").argument("<workflowFileId>").argument("<taskScopedId>").option("--title <title>", "Task title").option("--priority <priority>", "Priority: urgent, high, medium, or low").option("--desc-file <localPath>", "Local UTF-8 text file for task description").option("--clear-desc", "Clear task description").option("--owner-human-id <humanId>", "Task owner human ID")
+  ).action(
+    async (workflowFileId, taskScopedId, options) => {
+      const body = runOrExit3(() => {
+        if (options.descFile && options.clearDesc) {
+          throw new WorkflowOptionsError("Error: --desc-file cannot be used with --clear-desc.");
+        }
+        const next = {};
+        if (options.title) next.title = options.title;
+        const priority = parsePriority(options.priority);
+        if (priority !== void 0) next.priority = priority;
+        const desc = readDescFile(options.descFile);
+        if (desc !== void 0) next.desc = desc;
+        if (options.clearDesc) next.desc = null;
+        const ownerHumanId = parseOptionalPositiveInteger(options.ownerHumanId, "--owner-human-id");
+        if (ownerHumanId !== void 0) next.ownerHumanId = ownerHumanId;
+        assertNonEmptyBody(next);
+        return next;
+      });
+      const id = runOrExit3(() => parsePositiveInteger(taskScopedId, "taskScopedId"));
+      startSpinner("Updating task...");
+      const response = await httpPatch(
+        `/workspaces/${options.workspace}/workflows/${workflowFileId}/tasks/${id}/metadata`,
+        body
+      );
+      if (!response.ok) {
+        stopSpinner(false, "Failed");
+        failResponse(response);
+      }
+      stopSpinner(true, "Task updated");
+      printTaskDetail(response.data);
+    }
+  );
+  for (const action of ["add-linked-files", "remove-linked-files"]) {
+    addWorkspaceOption(
+      task.command(action).description(`${action === "add-linked-files" ? "Add" : "Remove"} linked files on a workflow task`).argument("<workflowFileId>").argument("<taskScopedId>").requiredOption("--file-ids <ids>", "Comma-separated file IDs")
+    ).action(
+      async (workflowFileId, taskScopedId, options) => {
+        const { id, fileIds } = runOrExit3(() => ({
+          id: parsePositiveInteger(taskScopedId, "taskScopedId"),
+          fileIds: parseFileIds(options.fileIds, "--file-ids")
+        }));
+        startSpinner(action === "add-linked-files" ? "Adding linked files..." : "Removing linked files...");
+        const path2 = `/workspaces/${options.workspace}/workflows/${workflowFileId}/tasks/${id}/linked-files`;
+        const response = action === "add-linked-files" ? await httpPost(path2, { fileIds }) : await httpDelete(path2, { fileIds });
+        if (!response.ok) {
+          stopSpinner(false, "Failed");
+          failResponse(response);
+        }
+        stopSpinner(true, action === "add-linked-files" ? "Linked files added" : "Linked files removed");
+        printTaskDetail(response.data);
+      }
+    );
+  }
+  addWorkspaceOption(
+    task.command("move").description("Move a workflow task to another status").argument("<workflowFileId>").argument("<taskScopedId>").requiredOption("--status <statusScopedId>", "Target status scoped ID")
+  ).action(
+    async (workflowFileId, taskScopedId, options) => {
+      const { id, statusScopedId } = runOrExit3(() => ({
+        id: parsePositiveInteger(taskScopedId, "taskScopedId"),
+        statusScopedId: parsePositiveInteger(options.status, "--status")
+      }));
+      startSpinner("Moving task...");
+      const response = await httpPatch(
+        `/workspaces/${options.workspace}/workflows/${workflowFileId}/tasks/${id}/status`,
+        { statusScopedId }
+      );
+      if (!response.ok) {
+        stopSpinner(false, "Failed");
+        failResponse(response);
+      }
+      stopSpinner(true, "Task moved");
+      printTaskDetail(response.data);
+    }
+  );
+  addAssigneeOptions(
+    addWorkspaceOption(
+      task.command("assign").description("Update workflow task assignee").argument("<workflowFileId>").argument("<taskScopedId>").option("--clear", "Clear assignee")
+    )
+  ).action(
+    async (workflowFileId, taskScopedId, options) => {
+      const body = runOrExit3(() => {
+        const next = parseAssigneeBody(options, true);
+        if (Object.keys(next).length === 0 && options.clear !== true) assertNonEmptyBody(next);
+        return next;
+      });
+      const id = runOrExit3(() => parsePositiveInteger(taskScopedId, "taskScopedId"));
+      startSpinner("Updating task assignee...");
+      const response = await httpPatch(
+        `/workspaces/${options.workspace}/workflows/${workflowFileId}/tasks/${id}/assignee`,
+        body
+      );
+      if (!response.ok) {
+        stopSpinner(false, "Failed");
+        failResponse(response);
+      }
+      stopSpinner(true, "Task assignee updated");
+      printTaskDetail(response.data);
+    }
+  );
+  addWorkspaceOption(
+    task.command("delete").description("Delete a workflow task").argument("<workflowFileId>").argument("<taskScopedId>")
+  ).action(async (workflowFileId, taskScopedId, options) => {
+    const id = runOrExit3(() => parsePositiveInteger(taskScopedId, "taskScopedId"));
+    startSpinner("Deleting task...");
+    const response = await httpDelete(
+      `/workspaces/${options.workspace}/workflows/${workflowFileId}/tasks/${id}`
+    );
+    if (!response.ok) {
+      stopSpinner(false, "Failed");
+      failResponse(response);
+    }
+    stopSpinner(true, `Deleted: ${response.data.scopedId}`);
+  });
+}
+function registerRunCommands(workflow) {
+  const run = workflow.command("run").description("Workflow agent run operations");
+  addWorkspaceOption(
+    run.command("status").description("Get workflow agent run statuses").argument("<workflowFileId>").argument("<triggerIds...>")
+  ).action(async (workflowFileId, triggerIds, options) => {
+    const workflowPipelineTriggerIds = runOrExit3(
+      () => triggerIds.map((triggerId) => parsePositiveInteger(triggerId, "workflowPipelineTriggerId"))
+    );
+    startSpinner("Fetching run statuses...");
+    const response = await httpPost(
+      `/workspaces/${options.workspace}/workflows/${workflowFileId}/pipeline/triggers/statuses`,
+      { workflowPipelineTriggerIds }
+    );
+    if (!response.ok) {
+      stopSpinner(false, "Failed");
+      failResponse(response);
+    }
+    stopSpinner(true, `Found ${response.data.length} run status item(s)`);
+    for (const item of response.data) {
+      print(`${colors.bold}${item.workflowPipelineTriggerId}${colors.reset}	${item.pipelineStatus}`);
+    }
+  });
+  addWorkspaceOption(
+    run.command("output").description("Get workflow agent run output events").argument("<workflowFileId>").argument("<triggerId>")
+  ).action(async (workflowFileId, triggerId, options) => {
+    const id = runOrExit3(() => parsePositiveInteger(triggerId, "workflowPipelineTriggerId"));
+    startSpinner("Fetching run output...");
+    const response = await httpGet(
+      `/workspaces/${options.workspace}/workflows/${workflowFileId}/pipeline/trigger/${id}/output`
+    );
+    if (!response.ok) {
+      stopSpinner(false, "Failed");
+      failResponse(response);
+    }
+    stopSpinner(true, `Run ${response.data.workflowPipelineTriggerId}`);
+    for (const event of response.data.pipelineEvents) print(event);
+  });
+  addWorkspaceOption(
+    run.command("abort").description("Abort a workflow agent run").argument("<workflowFileId>").argument("<triggerId>")
+  ).action(async (workflowFileId, triggerId, options) => {
+    const id = runOrExit3(() => parsePositiveInteger(triggerId, "workflowPipelineTriggerId"));
+    startSpinner("Aborting run...");
+    const response = await httpPost(
+      `/workspaces/${options.workspace}/workflows/${workflowFileId}/pipeline/trigger/${id}/abort`,
+      {}
+    );
+    if (!response.ok) {
+      stopSpinner(false, "Failed");
+      failResponse(response);
+    }
+    stopSpinner(true, `Abort accepted: ${id}`);
+  });
+}
+
+// src/program.ts
+function createProgram(version) {
+  const program2 = new Command();
+  program2.name("moxt").description("Moxt CLI - AI Workspace").version(version).action(() => {
+    program2.help();
+  });
+  registerAuthCommand(program2);
+  registerWhoamiCommand(program2);
+  registerWorkspaceCommand(program2);
+  registerFileCommand(program2);
+  registerMemoryCommand(program2);
+  registerWorkflowCommand(program2);
+  registerMiniappCommand(program2);
+  registerTelemetryCommand(program2);
+  return program2;
+}
+
 // src/telemetry/client.ts
 import { arch as arch2, platform as platform2 } from "os";
 var buffer = [];
@@ -946,7 +1923,7 @@ var FLUSH_TIMEOUT_MS = 3e3;
 var MAX_BATCH_SIZE = 100;
 function commonLabels() {
   return {
-    cli_version: "0.3.2",
+    cli_version: "0.3.3-beta.1",
     node_version: process.versions.node,
     os: platform2(),
     arch: arch2(),
@@ -992,7 +1969,7 @@ async function flush() {
   }
   const batch = buffer.splice(0, MAX_BATCH_SIZE);
   const payload = {
-    release_id: "0.3.2",
+    release_id: "0.3.3-beta.1",
     client_type: "cli",
     metric_data_list: batch.map((m) => ({
       profile: "cli",
@@ -1133,20 +2110,11 @@ function installExitHandler() {
 
 // src/index.ts
 updateNotifier({
-  pkg: { name: "@moxt-ai/cli", version: "0.3.2" }
+  pkg: { name: "@moxt-ai/cli", version: "0.3.3-beta.1" }
 }).notify();
-var program = new Command();
-program.name("moxt").description("Moxt CLI - AI Workspace").version("0.3.2").action(() => {
-  program.help();
-});
+var program = createProgram("0.3.3-beta.1");
 instrumentProgram(program);
 installExitHandler();
-registerWhoamiCommand(program);
-registerWorkspaceCommand(program);
-registerFileCommand(program);
-registerMemoryCommand(program);
-registerMiniappCommand(program);
-registerTelemetryCommand(program);
 program.parseAsync(process.argv).then(async () => {
   await flush();
 }).catch(async (err) => {