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

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.1"} (${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) {
@@ -1111,10 +1245,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 +1284,128 @@ 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 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 printTask(item) {
+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(
@@ -1192,13 +1461,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(
@@ -1284,7 +1547,7 @@ function registerStatusCommands(workflow) {
         failResponse(response);
       }
       stopSpinner(true, "Status created");
-      printStatus(response.data);
+      printStatusDetail(response.data);
     }
   );
   addPreferredAssigneeOptions(
@@ -1319,7 +1582,7 @@ function registerStatusCommands(workflow) {
         failResponse(response);
       }
       stopSpinner(true, "Status updated");
-      printStatus(response.data);
+      printStatusDetail(response.data);
     }
   );
   addWorkspaceOption(
@@ -1415,7 +1678,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 +1695,7 @@ function registerTaskCommands(workflow) {
       failResponse(response);
     }
     stopSpinner(true, "Task fetched");
-    printTask(response.data);
+    printTaskDetail(response.data);
   });
   addAssigneeOptions(
     addWorkspaceOption(
@@ -1463,7 +1726,7 @@ function registerTaskCommands(workflow) {
         failResponse(response);
       }
       stopSpinner(true, "Task created");
-      printTask(response.data);
+      printTaskDetail(response.data);
     }
   );
   addWorkspaceOption(
@@ -1497,7 +1760,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 +1780,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 +1802,7 @@ function registerTaskCommands(workflow) {
         failResponse(response);
       }
       stopSpinner(true, "Task moved");
-      printTask(response.data);
+      printTaskDetail(response.data);
     }
   );
   addAssigneeOptions(
@@ -1564,7 +1827,7 @@ function registerTaskCommands(workflow) {
         failResponse(response);
       }
       stopSpinner(true, "Task assignee updated");
-      printTask(response.data);
+      printTaskDetail(response.data);
     }
   );
   addWorkspaceOption(
@@ -1642,6 +1905,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 +1923,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.1",
     node_version: process.versions.node,
     os: platform2(),
     arch: arch2(),
@@ -1705,7 +1969,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.1",
     client_type: "cli",
     metric_data_list: batch.map((m) => ({
       profile: "cli",
@@ -1846,9 +2110,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.1" }
 }).notify();
-var program = createProgram("0.3.3-beta.0");
+var program = createProgram("0.3.3-beta.1");
 instrumentProgram(program);
 installExitHandler();
 program.parseAsync(process.argv).then(async () => {