@lidianai/cli 0.1.4 → 0.1.5

package/README.md

@@ -2,19 +2,41 @@
 
 Bun CLI for Lidian core REST endpoints.
 
-## Install
+## Install & Run
+
+### Quick Run (no install)
 
 ```bash
 bunx @lidianai/cli --help
+npm exec @lidianai/cli -- --help
+```
+
+### Global Install
+
+```bash
+# bun
+bun add -g @lidianai/cli
+
+# npm
+npm install -g @lidianai/cli
+
+# yarn
+yarn global add @lidianai/cli
+
+# pnpm
+pnpm add -g @lidianai/cli
+
+# Then run
+lidian --help
 ```
 
 ## Commands
 
 ```bash
-lidian discover --q "<term>" [--page 1] [--pageSize 1..3] [--category <name>] [--auth-type none|api_key|bearer|basic|oauth2|custom] [--min-price <cents>] [--max-price <cents>] [--api-key <key>] [--env production|staging] [--api-base <url>] [--json]
-lidian consume --endpoint-id <uuid> --params '<json>' [--payment-rail prepaid_credits|x402] [--network base|ethereum] [--api-key <key>] [--env production|staging] [--api-base <url>] [--json]
-lidian feedback --execution-id <uuid> --rank <0..10> [--feedback "<text>"] [--api-key <key>] [--env production|staging] [--api-base <url>] [--json]
-lidian account [--api-key <key>] [--env production|staging] [--api-base <url>] [--json]
+lidian discover --q "<term>" [--page 1] [--pageSize 1..3] [--category <name>] [--auth-type none|api_key|bearer|basic|oauth2|custom] [--min-price <cents>] [--max-price <cents>] [--env production|staging] [--api-base <url>] [--json]
+lidian consume --endpoint-id <uuid> --params '<json>' [--payment-rail prepaid_credits|x402] [--network base|ethereum] [--env production|staging] [--api-base <url>] [--json]
+lidian feedback --execution-id <uuid> --rank <0..10> [--feedback "<text>"] [--env production|staging] [--api-base <url>] [--json]
+lidian account [--env production|staging] [--api-base <url>] [--json]
 lidian login [--key ld_...] [--json]
 lidian --help
 ```

package/dist/index.js

@@ -0,0 +1,575 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/commands/account.ts
+var runAccountCommand = async (http, apiKey) => {
+  return http.get("/v1/account", apiKey);
+};
+
+// src/lib/errors.ts
+class CliError extends Error {
+  code;
+  constructor(message, code = 1) {
+    super(message);
+    this.name = "CliError";
+    this.code = code;
+  }
+}
+
+// src/lib/x402.ts
+var requestPaymentRequirements = async (http, apiKey, endpointId, network) => {
+  return http.post("/v1/payments/requirements", { endpointId, ...network ? { network } : {} }, apiKey);
+};
+var verifyPaymentAddress = async (http, apiKey, payTo) => {
+  return http.post("/v1/payments/verify", { payTo }, apiKey);
+};
+
+// src/commands/consume.ts
+var runConsumeCommand = async (http, apiKey, input) => {
+  if (!isUuid(input.endpointId)) {
+    throw new CliError("endpointId must be a valid UUID.");
+  }
+  if (input.paymentRail === "x402") {
+    const requirements = await requestPaymentRequirements(http, apiKey, input.endpointId, input.network);
+    const verification = await verifyPaymentAddress(http, apiKey, requirements.payTo);
+    const execution2 = await http.post("/v1/consume", input, apiKey);
+    return {
+      execution: execution2,
+      payment: {
+        requirements,
+        verified: verification.valid
+      }
+    };
+  }
+  const execution = await http.post("/v1/consume", input, apiKey);
+  return { execution };
+};
+var isUuid = (value) => {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+};
+
+// src/commands/discover.ts
+var runDiscoverCommand = async (http, apiKey, input) => {
+  if (input.pageSize < 1 || input.pageSize > 3) {
+    throw new CliError("pageSize must be between 1 and 3.");
+  }
+  const params = new URLSearchParams;
+  params.set("q", input.q);
+  params.set("page", String(input.page));
+  params.set("pageSize", String(input.pageSize));
+  if (input.category)
+    params.set("category", input.category);
+  if (input.authType)
+    params.set("authType", input.authType);
+  if (typeof input.minPrice === "number") {
+    params.set("minPrice", String(input.minPrice));
+  }
+  if (typeof input.maxPrice === "number") {
+    params.set("maxPrice", String(input.maxPrice));
+  }
+  return http.get(`/v1/discover?${params.toString()}`, apiKey);
+};
+
+// src/commands/feedback.ts
+var runFeedbackCommand = async (http, apiKey, input) => {
+  if (!isUuid2(input.executionId)) {
+    throw new CliError("executionId must be a valid UUID.");
+  }
+  if (!Number.isInteger(input.rank) || input.rank < 0 || input.rank > 10) {
+    throw new CliError("rank must be an integer between 0 and 10.");
+  }
+  if (typeof input.feedback === "string" && input.feedback.length > 1000) {
+    throw new CliError("feedback cannot exceed 1000 characters.");
+  }
+  return http.post("/v1/consume/feedback", input, apiKey);
+};
+var isUuid2 = (value) => {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+};
+
+// src/commands/login.ts
+import { stdin, stdout } from "process";
+import { createInterface } from "readline/promises";
+
+// src/lib/config.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { dirname, join } from "path";
+var CONFIG_PATH = join(homedir(), ".lidian", "config.json");
+var getConfigPath = () => CONFIG_PATH;
+var readConfig = async () => {
+  try {
+    const raw = await readFile(CONFIG_PATH, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return {};
+    }
+    const apiKey = "apiKey" in parsed && typeof parsed.apiKey === "string" ? parsed.apiKey : undefined;
+    return { apiKey };
+  } catch {
+    return {};
+  }
+};
+var writeConfig = async (config) => {
+  await mkdir(dirname(CONFIG_PATH), { recursive: true });
+  await writeFile(CONFIG_PATH, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+};
+
+// src/lib/output.ts
+var print = (message) => {
+  process.stdout.write(`${message}
+`);
+};
+var printError = (message) => {
+  process.stderr.write(`${message}
+`);
+};
+var printResult = (result, asJson) => {
+  if (asJson) {
+    print(JSON.stringify(result, null, 2));
+    return;
+  }
+  print(formatForHuman(result));
+};
+var printDiscoverResult = (result, asJson) => {
+  if (asJson) {
+    printResult(result, true);
+    return;
+  }
+  if (result.items.length === 0) {
+    print("No APIs found.");
+    return;
+  }
+  print(`Found ${result.items.length} of ${result.total} APIs (page ${result.page}).`);
+  for (const item of result.items) {
+    const confidence = item.matchPercent ? ` confidence=${item.matchPercent.toFixed(1)}%` : "";
+    const modes = item.paymentModes.join(",");
+    print(`- ${item.name} (${item.id}) cost=${item.defaultCostPerUse}c (${formatUsd(item.defaultCostPerUse)}) executable=${String(item.isExecutable)} requiresClientAuth=${String(item.requiresClientAuth)} paymentModes=${modes}${confidence}`);
+    for (const endpoint of item.endpoints ?? []) {
+      print(`  \xB7 endpoint=${endpoint.id} ${endpoint.method} ${endpoint.path} cost=${endpoint.pricingCents}c (${formatUsd(endpoint.pricingCents)})`);
+    }
+  }
+};
+var printConsumeResult = (result, asJson) => {
+  if (asJson) {
+    printResult(result.execution, true);
+    return;
+  }
+  if (result.payment) {
+    print(`x402 preflight: payTo=${result.payment.requirements.payTo} amount=${result.payment.requirements.amountFormatted} verified=${String(result.payment.verified)}`);
+  }
+  printExecutionResult(result.execution);
+};
+var printAccountResult = (result, asJson) => {
+  if (asJson) {
+    printResult(result, true);
+    return;
+  }
+  print(`Account: ${result.user.id}`);
+  print(`Balance: ${result.balance.balance} cents (${formatUsd(result.balance.balance)})`);
+};
+var printFeedbackResult = (result, asJson) => {
+  if (asJson) {
+    printResult(result, true);
+    return;
+  }
+  const feedback = result.feedback ?? "<none>";
+  print(`Feedback saved for execution=${result.executionId} rank=${result.rank} submittedBy=${result.submittedBy}`);
+  print(`Updated at: ${result.updatedAt}`);
+  print(`Comment: ${feedback}`);
+};
+var printExecutionResult = (result) => {
+  print(`Execution ID: ${result.executionId}`);
+  print(`Execution succeeded. Spent=${result.credits.spent} cents (${formatUsd(result.credits.spent)}) balance=${result.credits.balance} cents (${formatUsd(result.credits.balance)})`);
+  print(JSON.stringify(result.data, null, 2));
+};
+var formatForHuman = (value) => {
+  if (typeof value === "string") {
+    return value;
+  }
+  return JSON.stringify(value, null, 2);
+};
+var formatUsd = (cents) => {
+  return `$${(cents / 100).toFixed(2)}`;
+};
+var fail = (error) => {
+  if (error instanceof CliError) {
+    printError(`Error: ${error.message}`);
+    process.exit(error.code);
+  }
+  if (error instanceof Error) {
+    printError(`Error: ${error.message}`);
+    process.exit(1);
+  }
+  printError("Error: Unknown failure");
+  process.exit(1);
+};
+
+// src/commands/login.ts
+var runLoginCommand = async (input) => {
+  const key = input.key ?? await promptForKeyViaBrowserFlow();
+  validateApiKey(key);
+  const current = await readConfig();
+  await writeConfig({
+    ...current,
+    apiKey: key
+  });
+  return { path: getConfigPath() };
+};
+var promptForKeyViaBrowserFlow = async () => {
+  const loginUrl = "https://app.lidian.ai/login?next=/user/api-keys";
+  openUrl(loginUrl);
+  print(`Open this URL to authenticate and create/copy an API key:
+${loginUrl}`);
+  const rl = createInterface({ input: stdin, output: stdout });
+  try {
+    const entered = (await rl.question("Paste your API key (ld_...): ")).trim();
+    if (!entered) {
+      throw new CliError("No API key entered.");
+    }
+    return entered;
+  } finally {
+    rl.close();
+  }
+};
+var validateApiKey = (key) => {
+  if (!key.startsWith("ld_")) {
+    throw new CliError("Invalid API key format. Expected key starting with ld_.");
+  }
+};
+var openUrl = (url) => {
+  try {
+    if (process.platform === "darwin") {
+      Bun.spawn(["open", url], { stdout: "ignore", stderr: "ignore" });
+      return;
+    }
+    if (process.platform === "win32") {
+      Bun.spawn(["cmd", "/c", "start", "", url], {
+        stdout: "ignore",
+        stderr: "ignore"
+      });
+      return;
+    }
+    Bun.spawn(["xdg-open", url], { stdout: "ignore", stderr: "ignore" });
+  } catch {}
+};
+
+// src/lib/auth.ts
+var resolveApiKey = async (argsApiKey) => {
+  const config = await readConfig();
+  return argsApiKey ?? process.env.LIDIAN_API_KEY ?? config.apiKey;
+};
+
+// src/lib/http.ts
+var createHttpClient = (baseUrl) => {
+  const normalizedBaseUrl = baseUrl.replace(/\/$/, "");
+  return {
+    async get(path, apiKey) {
+      const response = await fetch(`${normalizedBaseUrl}${path}`, {
+        method: "GET",
+        headers: authHeaders(apiKey)
+      });
+      return handleResponse(response);
+    },
+    async post(path, body, apiKey) {
+      const response = await fetch(`${normalizedBaseUrl}${path}`, {
+        method: "POST",
+        headers: {
+          ...authHeaders(apiKey),
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(body)
+      });
+      return handleResponse(response);
+    }
+  };
+};
+var authHeaders = (apiKey) => {
+  if (!apiKey || apiKey.trim().length === 0) {
+    return {};
+  }
+  return {
+    Authorization: `Bearer ${apiKey}`
+  };
+};
+var handleResponse = async (response) => {
+  const json = await response.json().catch(() => null);
+  if (!response.ok) {
+    if (json && "success" in json && json.success === false) {
+      throw new CliError(`${json.error.code}: ${json.error.message}`, 1);
+    }
+    if (json && typeof json === "object" && "error" in json && typeof json.error === "string") {
+      throw new CliError(json.error, 1);
+    }
+    if (json && typeof json === "object" && "message" in json && typeof json.message === "string") {
+      throw new CliError(json.message, 1);
+    }
+    throw new CliError(`Request failed with status ${response.status}`, 1);
+  }
+  if (!json || !("success" in json) || json.success !== true) {
+    throw new CliError("Unexpected API response format", 1);
+  }
+  return json.data;
+};
+
+// src/index.ts
+var DEFAULT_API_BASE = "https://api.lidian.ai";
+var API_BASE_BY_ENV = {
+  production: "https://api.lidian.ai",
+  staging: "https://staging-api.lidian.ai"
+};
+var GLOBAL_OPTIONS = new Set(["api-key", "api-base", "env", "json", "help"]);
+var BOOLEAN_OPTIONS = new Set(["json", "help"]);
+var COMMAND_OPTIONS = {
+  discover: new Set([
+    "q",
+    "page",
+    "pageSize",
+    "category",
+    "auth-type",
+    "min-price",
+    "max-price"
+  ]),
+  consume: new Set(["endpoint-id", "params", "payment-rail", "network"]),
+  feedback: new Set(["execution-id", "rank", "feedback"]),
+  account: new Set([]),
+  login: new Set(["key"])
+};
+var main = async () => {
+  if (process.argv.length <= 2 || process.argv.includes("--help")) {
+    printUsage();
+    return;
+  }
+  const parsed = parseArgs(process.argv.slice(2));
+  const apiBase = resolveApiBase(asString(parsed.options["api-base"]), asEnvironment(asString(parsed.options.env) ?? process.env.LIDIAN_ENV));
+  const asJson = Boolean(parsed.options.json);
+  const http = createHttpClient(apiBase);
+  switch (parsed.command) {
+    case "login": {
+      const key = asString(parsed.options.key);
+      const result = await runLoginCommand({ key });
+      if (asJson) {
+        print(JSON.stringify({ success: true, data: result }, null, 2));
+      } else {
+        print(`Saved API key to ${result.path}`);
+      }
+      return;
+    }
+    case "discover": {
+      const apiKey = await resolveApiKey(asString(parsed.options["api-key"]));
+      const qValue = asString(parsed.options.q);
+      if (!qValue) {
+        throw new CliError("Missing --q for discover command.");
+      }
+      const page = toInt(asString(parsed.options.page), 1);
+      const pageSize = toInt(asString(parsed.options.pageSize), 1);
+      const authType = asAuthType(asString(parsed.options["auth-type"]));
+      const minPrice = toNumber(asString(parsed.options["min-price"]), "min-price");
+      const maxPrice = toNumber(asString(parsed.options["max-price"]), "max-price");
+      const result = await runDiscoverCommand(http, apiKey, {
+        q: qValue,
+        page,
+        pageSize,
+        category: asString(parsed.options.category),
+        ...authType ? { authType } : {},
+        ...typeof minPrice === "number" ? { minPrice } : {},
+        ...typeof maxPrice === "number" ? { maxPrice } : {}
+      });
+      printDiscoverResult(result, asJson);
+      return;
+    }
+    case "consume": {
+      const apiKey = await resolveApiKey(asString(parsed.options["api-key"]));
+      const endpointIdValue = asString(parsed.options["endpoint-id"]);
+      if (!endpointIdValue) {
+        throw new CliError("Missing --endpoint-id for consume command.");
+      }
+      const paramsRaw = asString(parsed.options.params) ?? "{}";
+      const params = parseJsonObject(paramsRaw, "--params");
+      const paymentRail = resolvePaymentRail(asString(parsed.options["payment-rail"]), apiKey);
+      const network = asNetwork(asString(parsed.options.network));
+      const result = await runConsumeCommand(http, apiKey, {
+        endpointId: endpointIdValue,
+        params,
+        paymentRail,
+        ...network ? { network } : {}
+      });
+      printConsumeResult(result, asJson);
+      return;
+    }
+    case "account": {
+      const apiKey = await resolveApiKey(asString(parsed.options["api-key"]));
+      const result = await runAccountCommand(http, apiKey);
+      printAccountResult(result, asJson);
+      return;
+    }
+    case "feedback": {
+      const apiKey = await resolveApiKey(asString(parsed.options["api-key"]));
+      const executionId = asString(parsed.options["execution-id"]);
+      if (!executionId) {
+        throw new CliError("Missing --execution-id for feedback command.");
+      }
+      const rankRaw = asString(parsed.options.rank);
+      if (!rankRaw) {
+        throw new CliError("Missing --rank for feedback command.");
+      }
+      const rank = toIntInRange(rankRaw, "rank", 0, 10);
+      const feedback = asString(parsed.options.feedback);
+      const result = await runFeedbackCommand(http, apiKey, {
+        executionId,
+        rank,
+        ...feedback ? { feedback } : {}
+      });
+      printFeedbackResult(result, asJson);
+      return;
+    }
+    default:
+      throw new CliError("Unknown command.", 1);
+  }
+};
+var parseArgs = (argv) => {
+  const command = argv[0];
+  if (command !== "discover" && command !== "consume" && command !== "feedback" && command !== "account" && command !== "login") {
+    printUsage();
+    throw new CliError("Invalid command. Use one of: login, discover, consume, feedback, account.", 1);
+  }
+  const options = {};
+  let index = 1;
+  while (index < argv.length) {
+    const token = argv[index];
+    if (!token || !token.startsWith("--")) {
+      throw new CliError(`Unexpected argument: ${token ?? "<empty>"}`);
+    }
+    const key = token.slice(2);
+    const allowedForCommand = COMMAND_OPTIONS[command];
+    if (!GLOBAL_OPTIONS.has(key) && !allowedForCommand.has(key)) {
+      throw new CliError(`Unknown option for ${command}: --${key}`);
+    }
+    const next = argv[index + 1];
+    if (!next || next.startsWith("--")) {
+      if (!BOOLEAN_OPTIONS.has(key)) {
+        throw new CliError(`Missing value for --${key}`);
+      }
+      options[key] = true;
+      index += 1;
+      continue;
+    }
+    options[key] = next;
+    index += 2;
+  }
+  return {
+    command,
+    options
+  };
+};
+var printUsage = () => {
+  print("Usage:");
+  print("  lidian login [--key ld_...] [--json]");
+  print('  lidian discover --q "<term>" [--page 1] [--pageSize 1..3] [--category <name>] [--auth-type none|api_key|bearer|basic|oauth2|custom]');
+  print("               [--min-price <cents>] [--max-price <cents>] [--env production|staging] [--api-base <url>] [--json]");
+  print("  lidian consume --endpoint-id <uuid> --params '<json>' [--payment-rail prepaid_credits|x402] [--network base|ethereum] [--env production|staging] [--api-base <url>] [--json]");
+  print('  lidian feedback --execution-id <uuid> --rank <0..10> [--feedback "<text>"] [--env production|staging] [--api-base <url>] [--json]');
+  print("  lidian account [--env production|staging] [--api-base <url>] [--json]");
+  print("");
+  print("Auth (all optional):");
+  print("  --api-key <key> | LIDIAN_API_KEY | lidian login");
+  print("");
+  print("Env resolution:");
+  print("  --api-base > LIDIAN_API_BASE > --env > LIDIAN_ENV > production");
+  print(`  production=${API_BASE_BY_ENV.production}`);
+  print(`  staging=${API_BASE_BY_ENV.staging}`);
+};
+var asString = (value) => {
+  if (typeof value === "string")
+    return value;
+  return;
+};
+var toInt = (value, fallback) => {
+  if (!value)
+    return fallback;
+  const parsed = Number.parseInt(value, 10);
+  if (Number.isNaN(parsed) || parsed < 1) {
+    throw new CliError(`Invalid integer value: ${value}`);
+  }
+  return parsed;
+};
+var toIntInRange = (value, flagName, min, max) => {
+  const parsed = Number.parseInt(value, 10);
+  if (Number.isNaN(parsed) || String(parsed) !== value || parsed < min || parsed > max) {
+    throw new CliError(`Invalid --${flagName} value: ${value}. Expected integer ${min}..${max}.`);
+  }
+  return parsed;
+};
+var toNumber = (value, flagName) => {
+  if (!value)
+    return;
+  const parsed = Number(value);
+  if (Number.isNaN(parsed)) {
+    throw new CliError(`Invalid --${flagName} value: ${value}`);
+  }
+  return parsed;
+};
+var parseJsonObject = (value, flagName) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch {
+    throw new CliError(`${flagName} must be valid JSON.`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new CliError(`${flagName} must be a JSON object.`);
+  }
+  return parsed;
+};
+var asPaymentRail = (value) => {
+  if (value === "prepaid_credits" || value === "x402")
+    return value;
+  throw new CliError("Invalid --payment-rail. Use prepaid_credits or x402.");
+};
+var resolvePaymentRail = (value, apiKey) => {
+  if (value) {
+    return asPaymentRail(value);
+  }
+  return apiKey && apiKey.trim().length > 0 ? "prepaid_credits" : "x402";
+};
+var asAuthType = (value) => {
+  if (!value)
+    return;
+  const valid = new Set([
+    "none",
+    "api_key",
+    "bearer",
+    "basic",
+    "oauth2",
+    "custom"
+  ]);
+  if (valid.has(value)) {
+    return value;
+  }
+  throw new CliError("Invalid --auth-type. Use none, api_key, bearer, basic, oauth2, or custom.");
+};
+var asNetwork = (value) => {
+  if (!value)
+    return;
+  if (value === "base" || value === "ethereum")
+    return value;
+  throw new CliError("Invalid --network. Use base or ethereum.");
+};
+var asEnvironment = (value) => {
+  if (!value)
+    return;
+  if (value === "production" || value === "staging")
+    return value;
+  throw new CliError("Invalid --env. Use production or staging.");
+};
+var resolveApiBase = (cliApiBase, environment) => {
+  if (cliApiBase)
+    return cliApiBase;
+  if (process.env.LIDIAN_API_BASE)
+    return process.env.LIDIAN_API_BASE;
+  if (environment)
+    return API_BASE_BY_ENV[environment];
+  return DEFAULT_API_BASE;
+};
+main().catch(fail);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lidianai/cli",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "private": false,
   "type": "module",
   "publishConfig": {

package/src/index.ts

@@ -209,19 +209,21 @@ const printUsage = (): void => {
     '  lidian discover --q "<term>" [--page 1] [--pageSize 1..3] [--category <name>] [--auth-type none|api_key|bearer|basic|oauth2|custom]',
   );
   print(
-    "               [--min-price <cents>] [--max-price <cents>] [--api-key <key>] [--env production|staging] [--api-base <url>] [--json]",
+    "               [--min-price <cents>] [--max-price <cents>] [--env production|staging] [--api-base <url>] [--json]",
   );
   print(
-    "  lidian consume --endpoint-id <uuid> --params '<json>' [--payment-rail prepaid_credits|x402] [--api-key <key>] [--env production|staging] [--api-base <url>] [--json]",
+    "  lidian consume --endpoint-id <uuid> --params '<json>' [--payment-rail prepaid_credits|x402] [--network base|ethereum] [--env production|staging] [--api-base <url>] [--json]",
   );
-  print("             [--network base|ethereum]");
   print(
-    '  lidian feedback --execution-id <uuid> --rank <0..10> [--feedback "<text>"] [--api-key <key>] [--env production|staging] [--api-base <url>] [--json]',
+    '  lidian feedback --execution-id <uuid> --rank <0..10> [--feedback "<text>"] [--env production|staging] [--api-base <url>] [--json]',
   );
   print(
-    "  lidian account [--api-key <key>] [--env production|staging] [--api-base <url>] [--json]",
+    "  lidian account [--env production|staging] [--api-base <url>] [--json]",
   );
   print("");
+  print("Auth (all optional):");
+  print("  --api-key <key> | LIDIAN_API_KEY | lidian login");
+  print("");
   print("Env resolution:");
   print("  --api-base > LIDIAN_API_BASE > --env > LIDIAN_ENV > production");
   print(`  production=${API_BASE_BY_ENV.production}`);