@warlok-net/cli 0.1.0

package/dist/cli.js

@@ -0,0 +1,798 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_promises = require("fs/promises");
+var import_node_os = __toESM(require("os"));
+var import_node_path = __toESM(require("path"));
+var import_node_process = require("process");
+var import_promises2 = require("readline/promises");
+var import_sdk = require("@warlok-net/sdk");
+var SHORT_FLAG_MAP = {
+  p: "prompt",
+  d: "description",
+  i: "image",
+  e: "entity",
+  t: "entity",
+  n: "name",
+  o: "output",
+  k: "api-key",
+  u: "base-url"
+};
+var DEFAULT_API_URL = "https://api.warlok.net";
+var DEFAULT_CONFIG_FILENAME = "config.json";
+var GENERATION_STATUSES = /* @__PURE__ */ new Set([
+  "pending",
+  "preprocessing",
+  "generating",
+  "rigging",
+  "complete",
+  "failed"
+]);
+var ENTITY_ALIASES = {
+  noun: "noun",
+  person: "person",
+  place: "place",
+  thing: "thing",
+  character: "person",
+  creature: "person",
+  environment: "place",
+  prop: "thing",
+  weapon: "thing",
+  vehicle: "thing",
+  material: "thing"
+};
+function parseArgs(args) {
+  const positional = [];
+  const options = {};
+  for (let i = 0; i < args.length; i += 1) {
+    const token = args[i];
+    if (token === "--") {
+      positional.push(...args.slice(i + 1));
+      break;
+    }
+    if (token.startsWith("--no-")) {
+      options[token.slice(5)] = false;
+      continue;
+    }
+    if (token.startsWith("--")) {
+      const [rawKey, inlineValue] = token.slice(2).split("=", 2);
+      if (inlineValue !== void 0) {
+        options[rawKey] = inlineValue;
+        continue;
+      }
+      const next = args[i + 1];
+      if (next && !next.startsWith("-")) {
+        options[rawKey] = next;
+        i += 1;
+      } else {
+        options[rawKey] = true;
+      }
+      continue;
+    }
+    if (token.startsWith("-") && token.length > 1) {
+      const raw = token.slice(1);
+      if (raw.length > 1) {
+        const alias2 = SHORT_FLAG_MAP[raw[0]];
+        if (alias2) {
+          options[alias2] = raw.slice(1);
+          continue;
+        }
+      }
+      const alias = SHORT_FLAG_MAP[raw];
+      if (!alias) {
+        positional.push(token);
+        continue;
+      }
+      const next = args[i + 1];
+      if (next && !next.startsWith("-")) {
+        options[alias] = next;
+        i += 1;
+      } else {
+        options[alias] = true;
+      }
+      continue;
+    }
+    positional.push(token);
+  }
+  return { positional, options };
+}
+function stringOption(options, key) {
+  const value = options[key];
+  if (typeof value === "string" && value.trim()) {
+    return value.trim();
+  }
+  return void 0;
+}
+function numberOption(options, key) {
+  const raw = stringOption(options, key);
+  if (!raw) {
+    return void 0;
+  }
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function booleanOption(options, key, defaultValue) {
+  const value = options[key];
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "string") {
+    const normalized = value.toLowerCase();
+    if (normalized === "false" || normalized === "0" || normalized === "no") {
+      return false;
+    }
+    if (normalized === "true" || normalized === "1" || normalized === "yes") {
+      return true;
+    }
+  }
+  return defaultValue;
+}
+function isUrl(value) {
+  try {
+    const parsed = new URL(value);
+    return parsed.protocol === "http:" || parsed.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function normalizeEntityType(raw) {
+  if (!raw) {
+    return "thing";
+  }
+  const normalized = raw.toLowerCase();
+  const mapped = ENTITY_ALIASES[normalized];
+  if (!mapped) {
+    throw new Error(
+      `Unsupported entity type "${raw}". Use noun|person|place|thing.`
+    );
+  }
+  return mapped;
+}
+function resolveConfigPath(options) {
+  return stringOption(options || {}, "config") || process.env.WARLOK_CONFIG_PATH || import_node_path.default.join(import_node_os.default.homedir(), ".warlok", DEFAULT_CONFIG_FILENAME);
+}
+async function readCliConfig(options) {
+  const configPath = resolveConfigPath(options);
+  try {
+    const raw = await (0, import_promises.readFile)(configPath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") {
+      return {};
+    }
+    return parsed;
+  } catch {
+    return {};
+  }
+}
+async function writeCliConfig(nextConfig, options) {
+  const configPath = resolveConfigPath(options);
+  const dir = import_node_path.default.dirname(configPath);
+  await (0, import_promises.mkdir)(dir, { recursive: true });
+  await (0, import_promises.writeFile)(configPath, `${JSON.stringify(nextConfig, null, 2)}
+`, "utf8");
+  return configPath;
+}
+function resolveBaseUrl(options, config) {
+  return stringOption(options, "base-url") || process.env.WARLOK_API_URL || config?.apiUrl || DEFAULT_API_URL;
+}
+function isLocalBaseUrl(baseUrl) {
+  try {
+    const parsed = new URL(baseUrl);
+    return parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1" || parsed.hostname.endsWith(".local");
+  } catch {
+    return false;
+  }
+}
+function resolveApiKey(options, baseUrl, config) {
+  const provided = stringOption(options, "api-key") || process.env.WARLOK_API_KEY || config?.apiKey;
+  if (provided) {
+    return provided;
+  }
+  if (isLocalBaseUrl(baseUrl)) {
+    return "wk_dev_local";
+  }
+  throw new Error(
+    "Missing API key. Set WARLOK_API_KEY or pass --api-key <key>."
+  );
+}
+function createClient(options, config) {
+  const baseUrl = resolveBaseUrl(options, config);
+  const apiKey = resolveApiKey(options, baseUrl, config);
+  return new import_sdk.WarlokClient({ apiKey, baseUrl });
+}
+function shouldPrintJson(options) {
+  return booleanOption(options, "json", false);
+}
+function print(value, asJson) {
+  if (asJson) {
+    process.stdout.write(`${JSON.stringify(value, null, 2)}
+`);
+    return;
+  }
+  if (typeof value === "string") {
+    process.stdout.write(`${value}
+`);
+    return;
+  }
+  process.stdout.write(`${JSON.stringify(value, null, 2)}
+`);
+}
+async function loadImageInput(imageInput) {
+  if (!imageInput) {
+    return {};
+  }
+  if (isUrl(imageInput)) {
+    return { imageUrl: imageInput };
+  }
+  const absolutePath = import_node_path.default.resolve(process.cwd(), imageInput);
+  const data = await (0, import_promises.readFile)(absolutePath);
+  return { imageBase64: data.toString("base64") };
+}
+function defaultOutputPath(id, format) {
+  return import_node_path.default.resolve(
+    process.cwd(),
+    format === "rigged" ? `${id}-rigged.glb` : `${id}.glb`
+  );
+}
+async function writeBlobToFile(blob, outputPath) {
+  const arrayBuffer = await blob.arrayBuffer();
+  const buffer = Buffer.from(arrayBuffer);
+  await (0, import_promises.writeFile)(outputPath, buffer);
+}
+function formatGenerationSummary(generation) {
+  return {
+    id: generation.id,
+    name: generation.name,
+    entityType: generation.entityType,
+    status: generation.status,
+    progress: generation.progress,
+    modelUrl: generation.outputs.modelUrl,
+    riggedModelUrl: generation.outputs.riggedModelUrl,
+    error: generation.error,
+    createdAt: generation.createdAt,
+    updatedAt: generation.updatedAt
+  };
+}
+async function runGenerate(args) {
+  const parsed = parseArgs(args);
+  const options = parsed.options;
+  const positional = [...parsed.positional];
+  const isCharacterSubcommand = positional[0]?.toLowerCase() === "character";
+  const descriptionPositional = isCharacterSubcommand ? positional.slice(1).join(" ").trim() : "";
+  const prompt = stringOption(options, "prompt") || stringOption(options, "description") || (descriptionPositional || void 0);
+  const image = stringOption(options, "image");
+  if (!prompt && !image) {
+    if (isCharacterSubcommand) {
+      throw new Error(
+        "Character generation requires a description and/or --image."
+      );
+    }
+    throw new Error("Generate requires --prompt/--description and/or --image.");
+  }
+  const requestedEntity = stringOption(options, "entity") || stringOption(options, "type");
+  const entityType = isCharacterSubcommand ? "person" : normalizeEntityType(requestedEntity);
+  if (isCharacterSubcommand && requestedEntity) {
+    const normalized = normalizeEntityType(requestedEntity);
+    if (normalized !== "person") {
+      throw new Error(
+        "Character subcommand always generates entity type person. Remove --entity/--type override."
+      );
+    }
+  }
+  const config = await readCliConfig(options);
+  const client = createClient(options, config);
+  const { imageUrl, imageBase64 } = await loadImageInput(image);
+  const generation = await client.generate({
+    name: stringOption(options, "name"),
+    entityType,
+    prompt,
+    imageUrl,
+    imageBase64,
+    options: {
+      rigForMixamo: booleanOption(options, "rig", entityType === "person"),
+      includeTpose: booleanOption(options, "tpose", entityType === "person"),
+      optimize: booleanOption(options, "optimize", true)
+    }
+  });
+  const wait = booleanOption(options, "wait", false);
+  const asJson = shouldPrintJson(options);
+  if (!wait) {
+    print(
+      {
+        ...formatGenerationSummary(generation),
+        message: "Generation queued. Use `warlok status <id>` to check progress, or pass --wait."
+      },
+      asJson
+    );
+    return;
+  }
+  const completed = await client.waitForCompletion(generation.id, {
+    pollingInterval: numberOption(options, "interval") || 2e3,
+    timeout: numberOption(options, "timeout") || 3e5
+  });
+  print(formatGenerationSummary(completed), asJson);
+}
+async function runStatus(args) {
+  const parsed = parseArgs(args);
+  const id = parsed.positional[0];
+  if (!id) {
+    throw new Error("Status requires a generation id: warlok status <id>");
+  }
+  const config = await readCliConfig(parsed.options);
+  const client = createClient(parsed.options, config);
+  const generation = await client.getGeneration(id);
+  print(formatGenerationSummary(generation), shouldPrintJson(parsed.options));
+}
+async function runList(args) {
+  const parsed = parseArgs(args);
+  const statusInput = stringOption(parsed.options, "status");
+  const status = statusInput ? statusInput : void 0;
+  if (status && !GENERATION_STATUSES.has(status)) {
+    throw new Error(
+      `Unsupported status "${statusInput}". Use pending|preprocessing|generating|rigging|complete|failed.`
+    );
+  }
+  const config = await readCliConfig(parsed.options);
+  const client = createClient(parsed.options, config);
+  const generations = await client.listGenerations({
+    limit: numberOption(parsed.options, "limit"),
+    status,
+    entityType: normalizeEntityType(stringOption(parsed.options, "entity"))
+  });
+  const rows = generations.map(formatGenerationSummary);
+  print({ total: rows.length, items: rows }, true);
+}
+async function runDownload(args) {
+  const parsed = parseArgs(args);
+  const id = parsed.positional[0];
+  if (!id) {
+    throw new Error("Download requires a generation id: warlok download <id>");
+  }
+  const format = booleanOption(
+    parsed.options,
+    "rigged",
+    false
+  ) ? "rigged" : booleanOption(parsed.options, "model", false) ? "model" : void 0;
+  const outputPath = stringOption(parsed.options, "output") || defaultOutputPath(id, format);
+  const config = await readCliConfig(parsed.options);
+  const client = createClient(parsed.options, config);
+  const blob = await client.downloadGeneration(id, format);
+  await writeBlobToFile(blob, outputPath);
+  print(
+    {
+      id,
+      format: format || "best_available",
+      output: outputPath
+    },
+    true
+  );
+}
+async function runTools(args) {
+  const parsed = parseArgs(args);
+  const config = await readCliConfig(parsed.options);
+  const baseUrl = resolveBaseUrl(parsed.options, config);
+  const apiKey = resolveApiKey(parsed.options, baseUrl, config);
+  const response = await fetch(`${baseUrl}/api/v1/mcp/tools`, {
+    headers: {
+      Authorization: `Bearer ${apiKey}`
+    }
+  });
+  const payload = await response.json();
+  if (!response.ok) {
+    throw new Error(
+      payload?.error?.message || `Failed to fetch tools (${response.status})`
+    );
+  }
+  print(payload?.data || payload, true);
+}
+async function runAgent(args) {
+  const [subcommand, ...rest] = args;
+  if (subcommand !== "run") {
+    throw new Error("Agent command requires `run`: warlok agent run <goal>");
+  }
+  const parsed = parseArgs(rest);
+  const goal = parsed.positional.join(" ").trim();
+  if (!goal) {
+    throw new Error("Agent goal is required: warlok agent run <goal>");
+  }
+  const config = await readCliConfig(parsed.options);
+  const baseUrl = resolveBaseUrl(parsed.options, config);
+  const apiKey = resolveApiKey(parsed.options, baseUrl, config);
+  const toolsResponse = await fetch(`${baseUrl}/api/v1/mcp/tools`, {
+    headers: {
+      Authorization: `Bearer ${apiKey}`
+    }
+  });
+  const toolsPayload = await toolsResponse.json();
+  const tools = toolsPayload?.data?.tools || [];
+  print(
+    {
+      goal,
+      message: "Use the listed MCP tools from your agent runtime to execute this goal.",
+      tools: tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description
+      }))
+    },
+    true
+  );
+}
+function redactApiKey(key) {
+  if (!key) {
+    return void 0;
+  }
+  if (key.length <= 8) {
+    return "****";
+  }
+  return `${key.slice(0, 4)}...${key.slice(-4)}`;
+}
+async function promptForApiKey() {
+  const rl = (0, import_promises2.createInterface)({ input: import_node_process.stdin, output: import_node_process.stdout });
+  try {
+    const entered = (await rl.question("Enter WARLOK API key: ")).trim();
+    if (!entered) {
+      throw new Error("API key is required.");
+    }
+    return entered;
+  } finally {
+    rl.close();
+  }
+}
+async function verifyCredentials(apiKey, baseUrl) {
+  try {
+    const response = await fetch(`${baseUrl}/api/v1/generations`, {
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+    if (response.ok) {
+      return { ok: true };
+    }
+    let message = `HTTP ${response.status}`;
+    try {
+      const payload = await response.json();
+      message = payload?.error?.message || payload?.error?.code || message;
+    } catch {
+    }
+    return { ok: false, reason: message };
+  } catch (error) {
+    return {
+      ok: false,
+      reason: error instanceof Error ? error.message : "request failed"
+    };
+  }
+}
+async function runDoctor(args) {
+  const parsed = parseArgs(args);
+  const asJson = shouldPrintJson(parsed.options);
+  const config = await readCliConfig(parsed.options);
+  const baseUrl = resolveBaseUrl(parsed.options, config);
+  const hasApiKey = Boolean(
+    stringOption(parsed.options, "api-key") || process.env.WARLOK_API_KEY || config.apiKey
+  );
+  const checks = [];
+  checks.push({
+    name: "base_url",
+    ok: isUrl(baseUrl),
+    detail: isUrl(baseUrl) ? baseUrl : `invalid URL: ${baseUrl}`
+  });
+  let healthOk = false;
+  try {
+    const response = await fetch(`${baseUrl}/api/v1/health`);
+    healthOk = response.ok;
+    checks.push({
+      name: "health",
+      ok: response.ok,
+      detail: response.ok ? "reachable" : `HTTP ${response.status}`
+    });
+  } catch (error) {
+    checks.push({
+      name: "health",
+      ok: false,
+      detail: error instanceof Error ? error.message : "request failed"
+    });
+  }
+  checks.push({
+    name: "api_key",
+    ok: hasApiKey,
+    detail: hasApiKey ? "configured" : "missing (WARLOK_API_KEY/config/--api-key)"
+  });
+  if (hasApiKey && healthOk) {
+    try {
+      const client = createClient(parsed.options, config);
+      await client.listGenerations({ limit: 1 });
+      checks.push({
+        name: "auth",
+        ok: true,
+        detail: "API key accepted"
+      });
+    } catch (error) {
+      checks.push({
+        name: "auth",
+        ok: false,
+        detail: formatCliError(error)
+      });
+    }
+  }
+  if (hasApiKey && healthOk) {
+    try {
+      const apiKey = resolveApiKey(parsed.options, baseUrl, config);
+      const response = await fetch(`${baseUrl}/api/v1/mcp/tools`, {
+        headers: {
+          Authorization: `Bearer ${apiKey}`
+        }
+      });
+      checks.push({
+        name: "mcp_tools",
+        ok: response.ok,
+        detail: response.ok ? "reachable" : `HTTP ${response.status}`
+      });
+    } catch (error) {
+      checks.push({
+        name: "mcp_tools",
+        ok: false,
+        detail: error instanceof Error ? error.message : "request failed"
+      });
+    }
+  }
+  const summary = {
+    ok: checks.every((check) => check.ok),
+    baseUrl,
+    configPath: resolveConfigPath(parsed.options),
+    checks
+  };
+  if (asJson) {
+    print(summary, true);
+    return;
+  }
+  process.stdout.write("Warlok doctor\n\n");
+  for (const check of checks) {
+    process.stdout.write(
+      `${check.ok ? "OK" : "FAIL"} ${check.name}: ${check.detail}
+`
+    );
+  }
+  process.stdout.write(`
+Overall: ${summary.ok ? "healthy" : "issues found"}
+`);
+}
+async function runAuth(args) {
+  const [subcommand, ...rest] = args;
+  const parsed = parseArgs(rest);
+  const asJson = shouldPrintJson(parsed.options);
+  const config = await readCliConfig(parsed.options);
+  const baseUrl = resolveBaseUrl(parsed.options, config);
+  switch (subcommand) {
+    case "login": {
+      const apiKey = stringOption(parsed.options, "api-key") || process.env.WARLOK_API_KEY || await promptForApiKey();
+      const nextConfig = {
+        ...config,
+        apiUrl: baseUrl,
+        apiKey,
+        profile: config.profile || "default"
+      };
+      const verify = await verifyCredentials(apiKey, baseUrl);
+      if (!verify.ok) {
+        throw new Error(`Auth verification failed: ${verify.reason || "unknown"}`);
+      }
+      const savedPath = await writeCliConfig(nextConfig, parsed.options);
+      print(
+        {
+          message: "Login successful",
+          apiUrl: baseUrl,
+          apiKey: redactApiKey(apiKey),
+          configPath: savedPath
+        },
+        asJson
+      );
+      return;
+    }
+    case "whoami": {
+      const effectiveApiKey = stringOption(parsed.options, "api-key") || process.env.WARLOK_API_KEY || config.apiKey;
+      const verify = effectiveApiKey ? await verifyCredentials(effectiveApiKey, baseUrl) : { ok: false, reason: "no API key configured" };
+      print(
+        {
+          authenticated: verify.ok,
+          reason: verify.ok ? void 0 : verify.reason,
+          apiUrl: baseUrl,
+          apiKey: redactApiKey(effectiveApiKey),
+          configPath: resolveConfigPath(parsed.options),
+          source: {
+            apiKey: stringOption(parsed.options, "api-key") ? "flag" : process.env.WARLOK_API_KEY ? "env" : config.apiKey ? "config" : "none"
+          }
+        },
+        asJson
+      );
+      return;
+    }
+    case "logout": {
+      const keepBaseUrl = booleanOption(parsed.options, "keep-base-url", true);
+      const nextConfig = {
+        ...config,
+        apiKey: void 0,
+        apiUrl: keepBaseUrl ? config.apiUrl : void 0
+      };
+      const savedPath = await writeCliConfig(nextConfig, parsed.options);
+      print(
+        {
+          message: "Logged out",
+          configPath: savedPath,
+          keptBaseUrl: keepBaseUrl
+        },
+        asJson
+      );
+      return;
+    }
+    default:
+      throw new Error("Auth command requires login|whoami|logout");
+  }
+}
+async function runMcp(args) {
+  const [subcommand, ...rest] = args;
+  const parsed = parseArgs(rest);
+  const config = await readCliConfig(parsed.options);
+  const baseUrl = resolveBaseUrl(parsed.options, config);
+  const apiKey = resolveApiKey(parsed.options, baseUrl, config);
+  if (subcommand !== "print-config") {
+    throw new Error("MCP command requires `print-config`.");
+  }
+  const json = {
+    mcpServers: {
+      warlok: {
+        command: "pnpm",
+        args: ["dlx", "@warlok-net/mcp-server@latest"],
+        env: {
+          WARLOK_API_URL: baseUrl,
+          WARLOK_API_KEY: apiKey
+        }
+      }
+    }
+  };
+  const format = stringOption(parsed.options, "format") || "json";
+  if (format === "json") {
+    print(json, true);
+    return;
+  }
+  if (format === "env") {
+    process.stdout.write(`WARLOK_API_URL=${baseUrl}
+`);
+    process.stdout.write(`WARLOK_API_KEY=${apiKey}
+`);
+    process.stdout.write("pnpm dlx @warlok-net/mcp-server@latest\n");
+    return;
+  }
+  throw new Error("Unsupported MCP format. Use --format json|env.");
+}
+function mainHelpText() {
+  return `
+Warlok CLI
+
+Usage:
+  warlok <command> [options]
+
+Commands:
+  generate      Start a generation from prompt/image
+  status <id>   Get generation status
+  list          List generations
+  download <id> Download generated model
+  auth          Login/logout and inspect CLI auth state
+  doctor        Validate local CLI/API configuration
+  mcp           MCP helper commands
+  tools         List MCP-compatible tools from API
+  agent run     Print agent execution context for a goal
+
+Global options:
+  --api-key <key>      API key (or set WARLOK_API_KEY)
+  --base-url <url>     API base URL (or set WARLOK_API_URL)
+  --config <path>      Config path (or set WARLOK_CONFIG_PATH)
+  --json               JSON output where supported
+
+Generate options:
+  generate character "<description>" [--image <path-or-url>] [--wait]
+  --prompt, -p <text>
+  --description, -d <text>  Alias for --prompt
+  --image, -i <path-or-url>
+  --entity, -e <noun|person|place|thing> (aliases supported)
+  --name, -n <name>
+  --wait               Poll until terminal status
+  --interval <ms>      Poll interval when --wait (default 2000)
+  --timeout <ms>       Timeout when --wait (default 300000)
+  --rig / --no-rig
+  --tpose / --no-tpose
+  --optimize / --no-optimize
+
+Download options:
+  --rigged             Prefer rigged model
+  --model              Prefer base model
+  --output, -o <path>  Save path (default: ./<id>.glb)
+
+Auth:
+  auth login [--api-key <key>] [--base-url <url>]
+  auth whoami
+  auth logout [--keep-base-url=true]
+
+Doctor:
+  doctor [--json]
+
+MCP:
+  mcp print-config [--format json|env]
+`.trimStart();
+}
+async function run(argv) {
+  const [command, ...rest] = argv;
+  if (!command || command === "help" || command === "--help" || command === "-h") {
+    process.stdout.write(mainHelpText());
+    process.stdout.write("\n");
+    return;
+  }
+  switch (command) {
+    case "generate":
+      await runGenerate(rest);
+      return;
+    case "status":
+      await runStatus(rest);
+      return;
+    case "list":
+      await runList(rest);
+      return;
+    case "download":
+      await runDownload(rest);
+      return;
+    case "auth":
+      await runAuth(rest);
+      return;
+    case "doctor":
+      await runDoctor(rest);
+      return;
+    case "mcp":
+      await runMcp(rest);
+      return;
+    case "tools":
+      await runTools(rest);
+      return;
+    case "agent":
+      await runAgent(rest);
+      return;
+    default:
+      throw new Error(`Unknown command: ${command}`);
+  }
+}
+function formatCliError(error) {
+  if (error instanceof import_sdk.WarlokError) {
+    return `${error.message} [${error.code}]`;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return "Unknown error";
+}
+
+// src/cli.ts
+run(process.argv.slice(2)).catch((error) => {
+  process.stderr.write(`Error: ${formatCliError(error)}
+`);
+  process.exit(1);
+});