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

package/dist/index.js

@@ -1,9 +1,11 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command } from "commander";
 import updateNotifier from "update-notifier";
 
+// src/program.ts
+import { Command } from "commander";
+
 // src/commands/file.ts
 import * as fs from "fs";
 
@@ -147,7 +149,7 @@ function getApiKeyOrUndefined() {
 
 // src/utils/http.ts
 function getUserAgent() {
-  return `moxt-cli/${"0.3.1"} (${platform()}/${arch()}) node/${process.versions.node}`;
+  return `moxt-cli/${"0.3.3-beta.0"} (${platform()}/${arch()}) node/${process.versions.node}`;
 }
 async function fetchApi(method, path2, body) {
   const apiKey = getApiKey();
@@ -187,6 +189,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);
 }
@@ -217,6 +222,59 @@ function printError(message) {
   console.error(`${colors.red}${message}${colors.reset}`);
 }
 
+// src/utils/search-options.ts
+var SearchOptionsError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SearchOptionsError";
+  }
+};
+function parseSearchLimit(raw, defaultValue, max) {
+  if (raw == null || raw === "") {
+    return defaultValue;
+  }
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isInteger(parsed) || parsed <= 0 || String(parsed) !== raw) {
+    throw new SearchOptionsError(`Error: --limit must be a positive integer, got "${raw}".`);
+  }
+  if (parsed > max) {
+    throw new SearchOptionsError(`Error: --limit must be less than or equal to ${max}.`);
+  }
+  return parsed;
+}
+function parseSearchMode(raw) {
+  if (raw == null || raw === "") {
+    return "any";
+  }
+  if (raw === "all" || raw === "any") {
+    return raw;
+  }
+  throw new SearchOptionsError(`Error: --mode must be "any" or "all", got "${raw}".`);
+}
+function parseTeammateId(raw) {
+  if (raw == null || raw === "") {
+    return void 0;
+  }
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isInteger(parsed) || parsed <= 0 || String(parsed) !== raw) {
+    throw new SearchOptionsError(`Error: --teammate-id must be a positive integer, got "${raw}".`);
+  }
+  return parsed;
+}
+
+// src/utils/run-or-exit.ts
+function runOrExit(fn) {
+  try {
+    return fn();
+  } catch (err) {
+    if (err instanceof SpaceOptionsError || err instanceof SearchOptionsError) {
+      printError(err.message);
+      process.exit(1);
+    }
+    throw err;
+  }
+}
+
 // src/utils/spinner.ts
 var frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
 var intervalId = null;
@@ -240,22 +298,48 @@ function stopSpinner(success, message) {
 }
 
 // src/commands/file.ts
-function runOrExit(fn) {
-  try {
-    return fn();
-  } catch (err) {
-    if (err instanceof SpaceOptionsError) {
-      printError(err.message);
-      process.exit(1);
-    }
-    throw err;
-  }
-}
 function addSpaceOptions(cmd) {
   return cmd.requiredOption("-w, --workspace <workspaceId>", "Workspace ID").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 registerFileCommand(program2) {
   const file = program2.command("file").description("File operations");
+  addSpaceOptions(
+    file.command("search").description("Search files in accessible spaces").argument("<query>", "Search query").option("-l, --limit <limit>", "Maximum number of files to return", "30").option("--mode <mode>", "Keyword matching mode: any or all", "any")
+  ).action(async (query, options) => {
+    const spaceParams = runOrExit(() => resolveSpaceSelector(options));
+    const limit = runOrExit(() => parseSearchLimit(options.limit, 30, 80));
+    const mode = runOrExit(() => parseSearchMode(options.mode));
+    startSpinner("Searching files...");
+    const response = await httpPost(
+      `/workspaces/${options.workspace}/files/search`,
+      {
+        query,
+        limit,
+        mode,
+        ...spaceParams
+      }
+    );
+    if (!response.ok) {
+      stopSpinner(false, "Failed");
+      printError(`Error [${response.status}]: ${JSON.stringify(response.data)}`);
+      process.exit(1);
+    }
+    const { items } = response.data;
+    if (items.length === 0) {
+      stopSpinner(true, "No files found.");
+      return;
+    }
+    stopSpinner(true, `Found ${items.length} file(s)`);
+    for (const item of items) {
+      print(`${colors.bold}${item.rank}. ${item.filePath}${colors.reset}`);
+      print(`${colors.dim}repo=${item.repoId} file=${item.fileId}${colors.reset}`);
+      const snippet = item.contentHighlight?.text ?? item.semanticSnippets[0]?.content;
+      if (snippet) {
+        print(snippet);
+      }
+      print("");
+    }
+  });
   addSpaceOptions(
     file.command("get-url").description("Resolve the shareable browser URL for a file").requiredOption("-p, --path <path>", "File path")
   ).action(async (options) => {
@@ -469,6 +553,43 @@ function registerFileCommand(program2) {
   );
 }
 
+// src/commands/memory.ts
+function registerMemoryCommand(program2) {
+  const memory = program2.command("memory").description("Memory operations");
+  memory.command("search").description("Search archived agent memory").requiredOption("-w, --workspace <workspaceId>", "Workspace ID").option("--teammate-id <teammateId>", "Search a managed AI teammate memory").option("-l, --limit <limit>", "Maximum number of memory chunks to return", "5").argument("<query>", "Search query").action(
+    async (query, options) => {
+      const limit = runOrExit(() => parseSearchLimit(options.limit, 5, 10));
+      const teammateId = runOrExit(() => parseTeammateId(options.teammateId));
+      startSpinner("Searching memory...");
+      const response = await httpPost(
+        `/workspaces/${options.workspace}/memory/search`,
+        {
+          query,
+          limit,
+          ...teammateId !== void 0 ? { agentId: teammateId } : {}
+        }
+      );
+      if (!response.ok) {
+        stopSpinner(false, "Failed");
+        printError(`Error [${response.status}]: ${JSON.stringify(response.data)}`);
+        process.exit(1);
+      }
+      const { items } = response.data;
+      if (items.length === 0) {
+        stopSpinner(true, "No memory found.");
+        return;
+      }
+      stopSpinner(true, `Found ${items.length} memory chunk(s)`);
+      for (const item of items) {
+        print(`${colors.bold}${item.rank}. pipeline=${item.pipelineId} chunk=${item.chunkIndex}${colors.reset}`);
+        print(`${colors.dim}chunkId=${item.chunkId}${item.contentTruncated ? " truncated=true" : ""}${colors.reset}`);
+        print(item.content);
+        print("");
+      }
+    }
+  );
+}
+
 // src/utils/miniapp-db.ts
 var MiniappDbOptionsError = class extends Error {
   constructor(message) {
@@ -823,6 +944,714 @@ 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) {
+  if (value === 0) return "urgent";
+  if (value === 1) return "high";
+  if (value === 2) return "medium";
+  return "low";
+}
+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 printStatus(item) {
+  print(
+    `${colors.bold}${item.scopedId}${colors.reset}	${item.name}	type=${item.type}	preferred=${formatAssignee(item.preferredAssignee)}`
+  );
+}
+function printTask(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 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");
+      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}`);
+      }
+    }
+  );
+  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");
+      printStatus(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");
+      printStatus(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) printTask(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");
+    printTask(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");
+      printTask(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");
+      printTask(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");
+        printTask(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");
+      printTask(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");
+      printTask(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();
+  });
+  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 = [];
@@ -830,7 +1659,7 @@ var FLUSH_TIMEOUT_MS = 3e3;
 var MAX_BATCH_SIZE = 100;
 function commonLabels() {
   return {
-    cli_version: "0.3.1",
+    cli_version: "0.3.3-beta.0",
     node_version: process.versions.node,
     os: platform2(),
     arch: arch2(),
@@ -876,7 +1705,7 @@ async function flush() {
   }
   const batch = buffer.splice(0, MAX_BATCH_SIZE);
   const payload = {
-    release_id: "0.3.1",
+    release_id: "0.3.3-beta.0",
     client_type: "cli",
     metric_data_list: batch.map((m) => ({
       profile: "cli",
@@ -1017,19 +1846,11 @@ function installExitHandler() {
 
 // src/index.ts
 updateNotifier({
-  pkg: { name: "@moxt-ai/cli", version: "0.3.1" }
+  pkg: { name: "@moxt-ai/cli", version: "0.3.3-beta.0" }
 }).notify();
-var program = new Command();
-program.name("moxt").description("Moxt CLI - AI Workspace").version("0.3.1").action(() => {
-  program.help();
-});
+var program = createProgram("0.3.3-beta.0");
 instrumentProgram(program);
 installExitHandler();
-registerWhoamiCommand(program);
-registerWorkspaceCommand(program);
-registerFileCommand(program);
-registerMiniappCommand(program);
-registerTelemetryCommand(program);
 program.parseAsync(process.argv).then(async () => {
   await flush();
 }).catch(async (err) => {