@lidianai/cli 0.1.2 → 0.1.4

package/README.md

@@ -43,6 +43,10 @@ When `--payment-rail x402` is used, CLI performs:
 Submit feedback later:
 4. `POST /v1/consume/feedback` with `executionId`, `rank`, optional `feedback`
 
+Default payment rail behavior when `--payment-rail` is omitted:
+- with API key/token: `prepaid_credits`
+- without auth: `x402`
+
 ## Dev
 
 ```bash

package/package.json

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

package/src/commands/account.ts

@@ -17,7 +17,7 @@ export interface AccountApiResponse {
 
 export const runAccountCommand = async (
   http: HttpClient,
-  apiKey: string,
+  apiKey: string | undefined,
 ): Promise<AccountApiResponse> => {
   return http.get<AccountApiResponse>("/v1/account", apiKey);
 };

package/src/commands/consume.ts

@@ -34,7 +34,7 @@ export interface ConsumeCommandResult {
 
 export const runConsumeCommand = async (
   http: HttpClient,
-  apiKey: string,
+  apiKey: string | undefined,
   input: ConsumeCommandInput,
 ): Promise<ConsumeCommandResult> => {
   if (!isUuid(input.endpointId)) {

package/src/commands/discover.ts

@@ -18,12 +18,21 @@ export interface DiscoverApiResponse {
     name: string;
     description: string | null;
     endpointBase: string;
-    authType: "none" | "api_key" | "bearer" | "basic" | "oauth2" | "custom";
     defaultCostPerUse: number;
     isActive: boolean;
+    requiresClientAuth: boolean;
+    paymentModes: Array<"x402" | "prepaid_credits">;
+    isExecutable: boolean;
     openapiSpecUrl: string | null;
     createdAt: string;
     updatedAt: string;
+    endpoints?: Array<{
+      id: string;
+      path: string;
+      method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS";
+      description?: string | null;
+      pricingCents: number;
+    }>;
     matchScore?: number;
     matchPercent?: number;
   }>;
@@ -34,7 +43,7 @@ export interface DiscoverApiResponse {
 
 export const runDiscoverCommand = async (
   http: HttpClient,
-  apiKey: string,
+  apiKey: string | undefined,
   input: DiscoverCommandInput,
 ): Promise<DiscoverApiResponse> => {
   if (input.pageSize < 1 || input.pageSize > 3) {

package/src/commands/feedback.ts

@@ -17,7 +17,7 @@ export interface FeedbackApiResponse {
 
 export const runFeedbackCommand = async (
   http: HttpClient,
-  apiKey: string,
+  apiKey: string | undefined,
   input: FeedbackCommandInput,
 ): Promise<FeedbackApiResponse> => {
   if (!isUuid(input.executionId)) {

package/src/index.ts

@@ -108,8 +108,9 @@ const main = async (): Promise<void> => {
       }
       const paramsRaw = asString(parsed.options.params) ?? "{}";
       const params = parseJsonObject(paramsRaw, "--params");
-      const paymentRail = asPaymentRail(
-        asString(parsed.options["payment-rail"]) ?? "prepaid_credits",
+      const paymentRail = resolvePaymentRail(
+        asString(parsed.options["payment-rail"]),
+        apiKey,
       );
       const network = asNetwork(asString(parsed.options.network));
       const result = await runConsumeCommand(http, apiKey, {
@@ -294,6 +295,16 @@ const asPaymentRail = (value: string): PaymentRail => {
   throw new CliError("Invalid --payment-rail. Use prepaid_credits or x402.");
 };
 
+const resolvePaymentRail = (
+  value: string | undefined,
+  apiKey: string | undefined,
+): PaymentRail => {
+  if (value) {
+    return asPaymentRail(value);
+  }
+  return apiKey && apiKey.trim().length > 0 ? "prepaid_credits" : "x402";
+};
+
 const asAuthType = (
   value: string | undefined,
 ):

package/src/lib/auth.ts

@@ -1,15 +1,8 @@
 import { readConfig } from "@/lib/config";
-import { CliError } from "@/lib/errors";
 
 export const resolveApiKey = async (
   argsApiKey: string | undefined,
-): Promise<string> => {
+): Promise<string | undefined> => {
   const config = await readConfig();
-  const key = argsApiKey ?? process.env.LIDIAN_API_KEY ?? config.apiKey;
-  if (!key) {
-    throw new CliError(
-      "Missing API key. Use `lidian login --key ld_...`, pass --api-key, or set LIDIAN_API_KEY.",
-    );
-  }
-  return key;
+  return argsApiKey ?? process.env.LIDIAN_API_KEY ?? config.apiKey;
 };

package/src/lib/http.ts

@@ -13,25 +13,30 @@ export interface ApiFailure {
   };
 }
 
-type ApiResponse<T> = ApiSuccess<T> | ApiFailure;
+interface PlainApiError {
+  error?: string;
+  message?: string;
+}
+
+type ApiResponse<T> = ApiSuccess<T> | ApiFailure | PlainApiError;
 
 export interface HttpClient {
-  get<T>(path: string, apiKey: string): Promise<T>;
-  post<T, B>(path: string, body: B, apiKey: string): Promise<T>;
+  get<T>(path: string, apiKey?: string): Promise<T>;
+  post<T, B>(path: string, body: B, apiKey?: string): Promise<T>;
 }
 
 export const createHttpClient = (baseUrl: string): HttpClient => {
   const normalizedBaseUrl = baseUrl.replace(/\/$/, "");
 
   return {
-    async get<T>(path: string, apiKey: string): Promise<T> {
+    async get<T>(path: string, apiKey?: string): Promise<T> {
       const response = await fetch(`${normalizedBaseUrl}${path}`, {
         method: "GET",
         headers: authHeaders(apiKey),
       });
       return handleResponse<T>(response);
     },
-    async post<T, B>(path: string, body: B, apiKey: string): Promise<T> {
+    async post<T, B>(path: string, body: B, apiKey?: string): Promise<T> {
       const response = await fetch(`${normalizedBaseUrl}${path}`, {
         method: "POST",
         headers: {
@@ -45,9 +50,14 @@ export const createHttpClient = (baseUrl: string): HttpClient => {
   };
 };
 
-const authHeaders = (apiKey: string): HeadersInit => ({
-  Authorization: `Bearer ${apiKey}`,
-});
+const authHeaders = (apiKey?: string): HeadersInit => {
+  if (!apiKey || apiKey.trim().length === 0) {
+    return {};
+  }
+  return {
+    Authorization: `Bearer ${apiKey}`,
+  };
+};
 
 const handleResponse = async <T>(response: Response): Promise<T> => {
   const json = (await response
@@ -58,6 +68,22 @@ const handleResponse = async <T>(response: Response): Promise<T> => {
     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);
   }
 

package/src/lib/output.ts

@@ -42,9 +42,15 @@ export const printDiscoverResult = (
     const confidence = item.matchPercent
       ? ` confidence=${item.matchPercent.toFixed(1)}%`
       : "";
+    const modes = item.paymentModes.join(",");
     print(
-      `- ${item.name} (${item.id}) auth=${item.authType} cost=${item.defaultCostPerUse}c (${formatUsd(item.defaultCostPerUse)})${confidence}`,
+      `- ${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(
+        `  · endpoint=${endpoint.id} ${endpoint.method} ${endpoint.path} cost=${endpoint.pricingCents}c (${formatUsd(endpoint.pricingCents)})`,
+      );
+    }
   }
 };
 

package/src/lib/x402.ts

@@ -27,7 +27,7 @@ export interface PaymentVerifyResponse {
 
 export const requestPaymentRequirements = async (
   http: HttpClient,
-  apiKey: string,
+  apiKey: string | undefined,
   endpointId: string,
   network?: string,
 ): Promise<PaymentRequirementsResponse> => {
@@ -43,7 +43,7 @@ export const requestPaymentRequirements = async (
 
 export const verifyPaymentAddress = async (
   http: HttpClient,
-  apiKey: string,
+  apiKey: string | undefined,
   payTo: string,
 ): Promise<PaymentVerifyResponse> => {
   return http.post<PaymentVerifyResponse, { payTo: string }>(

package/dist/index.js

@@ -1,556 +0,0 @@
-#!/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)}%` : "";
-    print(`- ${item.name} (${item.id}) auth=${item.authType} cost=${item.defaultCostPerUse}c (${formatUsd(item.defaultCostPerUse)})${confidence}`);
-  }
-};
-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();
-  const key = argsApiKey ?? process.env.LIDIAN_API_KEY ?? config.apiKey;
-  if (!key) {
-    throw new CliError("Missing API key. Use `lidian login --key ld_...`, pass --api-key, or set LIDIAN_API_KEY.");
-  }
-  return key;
-};
-
-// 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) => ({
-  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);
-    }
-    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 = asPaymentRail(asString(parsed.options["payment-rail"]) ?? "prepaid_credits");
-      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>] [--api-key <key>] [--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]");
-  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]');
-  print("  lidian account [--api-key <key>] [--env production|staging] [--api-base <url>] [--json]");
-  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 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);