@itpay/cli 0.1.10 → 0.2.1

package/lib/http.js

@@ -0,0 +1,151 @@
+import { DEFAULT_API_BASE, apiBase, apiTimeoutMs, configuredApiBase, cryptoRandom, readConfig, readCredentials, readSessionToken, readState, safeErrorMessage, writeState } from "./env.js";
+
+async function coreApi(pathname, options = {}, flags = {}) {
+  const headers = { "Content-Type": "application/json" };
+  const credentials = readCredentials();
+  if (flags.access_token) {
+    const raw = String(flags.access_token);
+    headers.Authorization = raw.toLowerCase().startsWith("bearer ") ? raw : `Bearer ${raw}`;
+  } else {
+    const sessionToken = readSessionToken(credentials);
+    if (sessionToken) headers.Authorization = `Bearer ${sessionToken}`;
+  }
+  if (options.idempotencyKey || flags.idempotency_key) {
+    headers["Idempotency-Key"] = String(options.idempotencyKey || flags.idempotency_key);
+  }
+  if (!options.noAgentHeaders) {
+    headers["X-ItPay-Agent-Fingerprint"] = coreAgentFingerprint(flags);
+    headers["X-ItPay-Agent-Name"] = coreAgentDisplayName(flags);
+  }
+  if (options.ops) {
+    headers["X-ItPay-Ops-Token"] = sandboxOpsToken(flags);
+  }
+  Object.assign(headers, options.headers || {});
+  if (flags.request_id) headers["X-Request-ID"] = String(flags.request_id);
+  if (flags.correlation_id) headers["X-Correlation-ID"] = String(flags.correlation_id);
+  const targetURL = coreURL(pathname, flags);
+  const timeoutMs = apiTimeoutMs(flags);
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let response;
+  try {
+    response = await fetch(targetURL, {
+      method: options.method || "GET",
+      headers,
+      body: options.body ? JSON.stringify(options.body) : undefined,
+      signal: controller.signal
+    });
+  } catch (error) {
+    if (error?.name === "AbortError") {
+      throw new Error(`request timed out after ${Math.ceil(timeoutMs / 1000)}s: ${safeRequestTarget(targetURL)}`);
+    }
+    throw new Error(`network request failed: ${safeRequestTarget(targetURL)}: ${safeErrorMessage(error)}`);
+  } finally {
+    clearTimeout(timer);
+  }
+  const text = await response.text();
+  let payload = {};
+  if (text) {
+    try {
+      payload = JSON.parse(text);
+    } catch {
+      payload = { text };
+    }
+  }
+  if (!response.ok || payload.success === false) {
+    const error = new Error(payload.error || payload.message || `request failed: ${response.status}`);
+    error.status = response.status;
+    if (response.status === 401 && String(pathname).startsWith("/v1/me/")) {
+      error.message = "buyer session required or expired; run status --refresh --json, then run setup --method alipay --json if unauthenticated";
+      error.next = [
+        { type: "verify_buyer_session", command: cliCommand("status", "--refresh", "--json"), safe_for_agent: true },
+        { type: "start_auth_if_needed", command: cliCommand("setup", "--method", "alipay", "--json"), safe_for_agent: true }
+      ];
+    }
+    throw error;
+  }
+  return payload.data ?? payload;
+}
+
+function safeRequestTarget(target) {
+  try {
+    const url = new URL(String(target));
+    return `${url.origin}${url.pathname}`;
+  } catch {
+    return String(target).split("?")[0];
+  }
+}
+
+function coreAgentFingerprint(flags = {}) {
+  const explicit = flags.agent_fingerprint || flags.agent_device_fingerprint || process.env.ITPAY_AGENT_FINGERPRINT || process.env.ITPAY_AGENT_DEVICE_FINGERPRINT;
+  if (explicit) return String(explicit);
+  const state = readState();
+  if (state.core_agent_fingerprint) return state.core_agent_fingerprint;
+  const fingerprint = `itp_cli_${cryptoRandom()}`;
+  writeState({ ...state, core_agent_fingerprint: fingerprint });
+  return fingerprint;
+}
+
+function coreAgentDisplayName(flags = {}) {
+  return String(flags.agent_name || flags.agent_display_name || process.env.ITPAY_AGENT_NAME || "ItPay CLI buyer agent");
+}
+
+function coreURL(pathname, flags = {}) {
+  if (/^https?:\/\//i.test(String(pathname))) return String(pathname);
+  return `${coreApiBase(flags)}${pathname.startsWith("/") ? "" : "/"}${pathname}`;
+}
+
+function coreApiBase(flags = {}, config = readConfig()) {
+  const base = flags.api_base || flags.core_api_base || configuredApiBase(config) || DEFAULT_API_BASE;
+  return String(base).replace(/\/$/, "");
+}
+
+function sandboxOpsToken(flags = {}) {
+  const token = flags.ops_token || flags.sandbox_ops_token || process.env.ITPAY_SANDBOX_OPS_TOKEN || process.env.ITPAY_OPS_TOKEN;
+  if (!token) throw new Error("sandbox ops token is required; set ITPAY_SANDBOX_OPS_TOKEN or pass --ops-token");
+  return String(token);
+}
+
+async function api(pathname, options, flags = {}) {
+  const config = readConfig();
+  const credentials = readCredentials();
+  const base = apiBase(flags, config);
+  const headers = { "Content-Type": "application/json" };
+  if (flags.access_token) {
+    headers.Authorization = String(flags.access_token);
+  } else {
+    const sessionToken = readSessionToken(credentials);
+    if (sessionToken) {
+      headers.Authorization = `Bearer ${sessionToken}`;
+    }
+  }
+  if (flags.new_api_user || flags.new_api_user_id || flags.user_id) {
+    headers["New-Api-User"] = String(flags.new_api_user || flags.new_api_user_id || flags.user_id);
+  }
+  const timeoutMs = apiTimeoutMs(flags);
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let response;
+  try {
+    response = await fetch(`${base}${pathname}`, {
+      method: options.method,
+      headers,
+      body: options.body ? JSON.stringify(options.body) : undefined,
+      signal: controller.signal
+    });
+  } catch (error) {
+    if (error?.name === "AbortError") {
+      throw new Error(`request timed out after ${Math.ceil(timeoutMs / 1000)}s: ${pathname}`);
+    }
+    throw error;
+  } finally {
+    clearTimeout(timer);
+  }
+  const payload = await response.json().catch(() => ({}));
+  if (!response.ok || payload.success === false) {
+    throw new Error(payload.message || `request failed: ${response.status}`);
+  }
+  return payload.data ?? payload;
+}
+
+export { coreApi, safeRequestTarget, coreAgentFingerprint, coreAgentDisplayName, coreURL, coreApiBase, sandboxOpsToken, api };

package/lib/ops.js

@@ -0,0 +1,135 @@
+import { coreApi } from "./http.js";
+import { cryptoRandom, intFlag, output, positional, queryString, readJSON } from "./env.js";
+
+async function ops(command, rest, flags) {
+  if (command !== "sandbox") throw new Error(`unknown ops command: ${command || ""}`);
+  const area = rest[0];
+  const action = rest[1];
+  if (area === "worker" && action === "run-once") {
+    output(await coreApi("/v1/sandbox/workers/run-once", { method: "POST", ops: true }, flags));
+    return;
+  }
+  if (area === "recover-alipay-once") {
+    output(await coreApi("/v1/local/workers/recover-alipay-sandbox-once", { method: "POST", ops: true }, flags));
+    return;
+  }
+  if (area === "payment" && action === "query") {
+    const paymentIntentID = flags.payment_intent || flags.payment_intent_id || positional(rest, 2);
+    if (!paymentIntentID) throw new Error("payment_intent_id is required");
+    output(await coreApi(`/v1/payment-intents/${encodeURIComponent(paymentIntentID)}/alipay-sandbox-query`, { method: "POST", ops: true }, flags));
+    return;
+  }
+  if (area === "refund") {
+    const refundID = flags.refund || flags.refund_id || positional(rest, 2);
+    if (!refundID) throw new Error("refund_id is required");
+    if (action === "show") {
+      output(await coreApi(`/v1/sandbox/ops/refunds/${encodeURIComponent(refundID)}`, { method: "GET", ops: true }, flags));
+      return;
+    }
+    if (action === "approve" || action === "reject") {
+      output(await coreApi(`/v1/sandbox/ops/refunds/${encodeURIComponent(refundID)}/${action}`, {
+        method: "POST",
+        ops: true,
+        idempotencyKey: flags.idempotency_key || `idem_cli_refund_${action}_${refundID}`,
+        body: {
+          reason_code: flags.reason || flags.reason_code || (action === "approve" ? "approved_by_ops" : "not_eligible"),
+          note: flags.note || ""
+        }
+      }, flags));
+      return;
+    }
+    if (action === "execute") {
+      output(await coreApi(`/v1/sandbox/ops/refunds/${encodeURIComponent(refundID)}/execute`, {
+        method: "POST",
+        ops: true,
+        idempotencyKey: flags.idempotency_key || `idem_cli_refund_execute_${refundID}`
+      }, flags));
+      return;
+    }
+  }
+  if (area === "ledger" && action === "entries") {
+    const params = new URLSearchParams();
+    if (flags.order || flags.order_id) params.set("order_id", String(flags.order || flags.order_id));
+    if (flags.refund || flags.refund_id) params.set("refund_id", String(flags.refund || flags.refund_id));
+    if (flags.payment_intent || flags.payment_intent_id) params.set("payment_intent_id", String(flags.payment_intent || flags.payment_intent_id));
+    if ([...params.keys()].length === 0) {
+      throw new Error("ledger filter is required: use --order, --refund, or --payment-intent");
+    }
+    output(await coreApi(`/v1/sandbox/ops/ledger/entries${queryString(params)}`, { method: "GET", ops: true }, flags));
+    return;
+  }
+  if (area === "reconciliation") {
+    if (action === "run") {
+      output(await coreApi("/v1/sandbox/ops/reconciliation-runs", {
+        method: "POST",
+        ops: true,
+        idempotencyKey: flags.idempotency_key || `idem_cli_reconciliation_${cryptoRandom()}`,
+        body: {
+          reconciliation_run_id: flags.reconciliation_run_id || flags.run_id || "",
+          status: flags.status || "matched",
+          expected_amount_minor: intFlag(flags.expected_amount_minor || flags.expected || 0, "expected_amount_minor"),
+          observed_amount_minor: intFlag(flags.observed_amount_minor || flags.observed || 0, "observed_amount_minor"),
+          currency: flags.currency || "CNY",
+          raw_statement_ref: flags.raw_statement_ref || flags.statement_ref || ""
+        }
+      }, flags));
+      return;
+    }
+    if (action === "show") {
+      const runID = flags.reconciliation_run_id || flags.run_id || positional(rest, 2);
+      if (!runID) throw new Error("reconciliation_run_id is required");
+      output(await coreApi(`/v1/sandbox/ops/reconciliation-runs/${encodeURIComponent(runID)}`, { method: "GET", ops: true }, flags));
+      return;
+    }
+  }
+  if (area === "settlement" && action === "show") {
+    const settlementBatchID = flags.settlement_batch || flags.settlement_batch_id || positional(rest, 2);
+    if (!settlementBatchID) throw new Error("settlement_batch_id is required");
+    output(await coreApi(`/v1/sandbox/ops/settlement-batches/${encodeURIComponent(settlementBatchID)}`, { method: "GET", ops: true }, flags));
+    return;
+  }
+  throw new Error(`unknown ops sandbox command: ${rest.join(" ")}`);
+}
+
+async function admin(command, rest, flags) {
+  if (command === "orders") {
+    const params = new URLSearchParams();
+    for (const key of ["account_id", "status", "provider", "limit"]) {
+      if (flags[key]) params.set(key, flags[key]);
+    }
+    const suffix = params.toString() ? `?${params.toString()}` : "";
+    output(await api(`/api/itp/admin/orders${suffix}`, { method: "GET" }, flags));
+    return;
+  }
+  if (command === "payment-events") {
+    const params = new URLSearchParams();
+    for (const key of ["order_id", "checkout_id", "out_trade_no", "provider", "event_type", "signature_verified", "limit"]) {
+      if (flags[key]) params.set(key, flags[key]);
+    }
+    const suffix = params.toString() ? `?${params.toString()}` : "";
+    output(await api(`/api/itp/admin/payment-events${suffix}`, { method: "GET" }, flags));
+    return;
+  }
+  if (command === "outbox") {
+    const params = new URLSearchParams();
+    for (const key of ["status", "event_type", "aggregate_id", "limit"]) {
+      if (flags[key]) params.set(key, flags[key]);
+    }
+    const suffix = params.toString() ? `?${params.toString()}` : "";
+    output(await api(`/api/itp/admin/outbox${suffix}`, { method: "GET" }, flags));
+    return;
+  }
+  if (command === "process-outbox") {
+    output(await api("/api/itp/admin/outbox/process", { method: "POST" }, flags));
+    return;
+  }
+  if (command === "recover-order") {
+    const orderId = rest[0];
+    if (!orderId) throw new Error("order_id is required");
+    output(await api(`/api/itp/admin/orders/${encodeURIComponent(orderId)}/recover`, { method: "POST" }, flags));
+    return;
+  }
+  throw new Error(`unknown admin command: ${command || ""}`);
+}
+
+export { ops, admin };