weaver-work-cli 0.1.29 → 0.1.32

package/dist/chunks/chunk-H7J4DC5R.js

@@ -0,0 +1,464 @@
+import { createRequire as __esbuildCreateRequire } from 'node:module';
+const require = __esbuildCreateRequire(import.meta.url);
+import {
+  createE10RequestRuntime,
+  requireE10Session
+} from "./chunk-DW6AUUKS.js";
+import {
+  E10_REAUTH_GUIDANCE,
+  E10_SESSION_EXPIRED_MESSAGE,
+  getActiveProfile
+} from "./chunk-2GA5ZIQL.js";
+import {
+  CliError
+} from "./chunk-LUSPKZKY.js";
+
+// src/shortcuts/invoice/errors.ts
+var InvoiceCliError = class extends CliError {
+  type;
+  subtype;
+  code;
+  retryable;
+  stage;
+  details;
+  partialData;
+  constructor(type, subtype, message, options = {}) {
+    super(message, options.exitCode ?? 5 /* InternalError */);
+    this.name = "InvoiceCliError";
+    this.type = type;
+    this.subtype = subtype;
+    this.code = options.code;
+    this.retryable = options.retryable ?? false;
+    this.stage = options.stage;
+    this.details = options.details;
+    this.partialData = options.partialData;
+  }
+};
+function invoiceValidationError(subtype, message, details) {
+  return new InvoiceCliError("validation", subtype, message, {
+    details,
+    exitCode: 2 /* UsageError */
+  });
+}
+function invoiceAuthError(subtype, message, details) {
+  return new InvoiceCliError("authentication", subtype, message, {
+    details,
+    exitCode: 3 /* AuthError */
+  });
+}
+function invoiceNetworkError(subtype, message, options = {}) {
+  return new InvoiceCliError("network", subtype, message, {
+    ...options,
+    retryable: options.retryable ?? true,
+    exitCode: 4 /* NetworkError */
+  });
+}
+function invoiceConfirmationError(action, details) {
+  return new InvoiceCliError("confirmation", "required", "\u8BE5\u64CD\u4F5C\u9700\u8981\u660E\u786E\u786E\u8BA4", {
+    details: { action, ...details },
+    exitCode: 10 /* ConfirmationRequired */
+  });
+}
+function invoicePartialError(message, partialData, details) {
+  return new InvoiceCliError("partial", "write_uncertain", message, {
+    details,
+    partialData,
+    exitCode: 11 /* Partial */
+  });
+}
+function isInvoiceNetworkError(error) {
+  return Boolean(
+    error && typeof error === "object" && "type" in error && error.type === "network"
+  );
+}
+
+// src/shortcuts/invoice/host.ts
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+var MAX_DOWNLOAD_BYTES = 50 * 1024 * 1024;
+var TOKEN_SERVICE = "cn.weaver.weaver-work-cli.invoice-token";
+var INVOICE_SESSION_EXPIRED_CODE = "-2";
+function assertPath(requestPath) {
+  if (typeof requestPath !== "string" || !requestPath.startsWith("/") || requestPath.startsWith("//")) {
+    throw invoiceValidationError("path_invalid", "\u8BF7\u6C42\u8DEF\u5F84\u5FC5\u987B\u662F\u76F8\u5BF9\u7EDD\u5BF9\u8DEF\u5F84");
+  }
+  if (/^https?:/i.test(requestPath) || /[\r\n]/.test(requestPath) || requestPath.includes("/../")) {
+    throw invoiceValidationError("path_invalid", "\u8BF7\u6C42\u8DEF\u5F84\u4E0D\u5141\u8BB8\u8DE8\u57DF\u6216\u8DEF\u5F84\u9003\u9038");
+  }
+  if (!requestPath.startsWith("/api/")) {
+    throw invoiceValidationError("path_not_allowed", "\u4E1A\u7968\u901A\u53EA\u80FD\u8C03\u7528 /api/ \u8DEF\u5F84");
+  }
+}
+function responseRoot(value) {
+  return value?.res_base || value?.data?.res_base || value;
+}
+function responseMessage(value) {
+  const root = responseRoot(value);
+  return typeof root?.message === "string" ? root.message : typeof root?.msg === "string" ? root.msg : "\u6CDB\u5FAE\u63A5\u53E3\u8FD4\u56DE\u4E1A\u52A1\u5931\u8D25";
+}
+function responseCode(value) {
+  const root = responseRoot(value);
+  return root?.ret ?? root?.code;
+}
+function isInvoiceSessionExpired(value) {
+  const code = responseCode(value);
+  return code !== void 0 && String(code) === INVOICE_SESSION_EXPIRED_CODE;
+}
+function tokenAccount(session) {
+  return createHash("sha256").update(`${session.profile}
+${session.baseUrl}
+${session.userId}`).digest("hex");
+}
+function createInvoiceTokenStore(session) {
+  const account = tokenAccount(session);
+  let entryPromise = null;
+  async function entry() {
+    if (!entryPromise) {
+      entryPromise = import("@napi-rs/keyring").then(({ Entry }) => new Entry(TOKEN_SERVICE, account));
+    }
+    return entryPromise;
+  }
+  return {
+    async load() {
+      try {
+        const value = await (await entry()).getPassword();
+        return typeof value === "string" && value.trim() ? value : null;
+      } catch {
+        return null;
+      }
+    },
+    async save(token) {
+      if (!token.trim()) return false;
+      try {
+        await (await entry()).setPassword(token);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    async clear() {
+      try {
+        await (await entry()).deletePassword();
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  };
+}
+async function clearInvoiceTokenForSession(session) {
+  return createInvoiceTokenStore(session).clear();
+}
+function inferProfile(ctx) {
+  const options = ctx.getGlobalOptions();
+  return options.profile || getActiveProfile();
+}
+function trustedInvoiceHeaders(invoiceToken) {
+  return invoiceToken ? { token: invoiceToken } : {};
+}
+function createInvoiceHost(ctx, dependencies = {}) {
+  let e10Session = null;
+  let sessionContext = null;
+  let invoiceToken = null;
+  let tokenStore = null;
+  const requireSession = dependencies.requireSession || requireE10Session;
+  const tokenStoreFactory = dependencies.tokenStoreFactory || createInvoiceTokenStore;
+  async function ensureSession() {
+    if (!e10Session) {
+      e10Session = await requireSession(ctx);
+      sessionContext = {
+        baseUrl: e10Session.getBaseUrl(),
+        profile: inferProfile(ctx),
+        userId: e10Session.userId
+      };
+    }
+    return e10Session;
+  }
+  async function getSession() {
+    await ensureSession();
+    return sessionContext;
+  }
+  async function ensureInvoiceToken(timeoutMs = 3e4) {
+    await ensureSession();
+    const context = await getSession();
+    tokenStore ||= tokenStoreFactory(context);
+    if (invoiceToken) return invoiceToken;
+    invoiceToken = await tokenStore.load();
+    if (invoiceToken) return invoiceToken;
+    const tokenResponse = await invoiceRequest({
+      method: "GET",
+      path: "/api/inc/proxy/getToken",
+      query: { appType: 1 },
+      needsInvoiceToken: false,
+      timeoutMs
+    });
+    const token = tokenResponse?.data?.token;
+    if (typeof token !== "string" || !token.trim()) {
+      throw invoiceAuthError("invoice_token_missing", "\u672A\u53D6\u5F97\u4E1A\u7968\u901A\u4E1A\u52A1 Token");
+    }
+    await tokenStore.save(token);
+    invoiceToken = token;
+    return token;
+  }
+  async function ensureContext(needsInvoiceToken, timeoutMs, path) {
+    await ensureSession();
+    const tokenEndpoint = path === "/api/inc/proxy/getToken" || path === "/api/app/inc/proxy/getToken";
+    if (tokenEndpoint) return void 0;
+    if (!needsInvoiceToken) {
+    }
+    return ensureInvoiceToken(timeoutMs);
+  }
+  async function clearCachedInvoiceToken() {
+    invoiceToken = null;
+    await tokenStore?.clear().catch(() => false);
+  }
+  async function runtime() {
+    return createE10RequestRuntime(ctx, await ensureSession(), {
+      interceptors: dependencies.interceptors,
+      fetch: dependencies.fetch
+    });
+  }
+  function businessError(value) {
+    const code = responseCode(value);
+    return new InvoiceCliError("api", "business_error", responseMessage(value), {
+      code: String(code),
+      details: { ret: code },
+      exitCode: 1
+    });
+  }
+  async function handleBusinessResponse(value, retry, canRetry) {
+    const code = responseCode(value);
+    if (code === void 0 || code === 0 || code === 200) return value;
+    if (isInvoiceSessionExpired(value)) {
+      await clearCachedInvoiceToken();
+      if (canRetry) return retry();
+      throw invoiceAuthError(
+        "invoice_session_expired",
+        `\u53D1\u7968\u4E1A\u52A1\u767B\u5F55\u6001\u5DF2\u5931\u6548\uFF0C\u5DF2\u6E05\u7406\u672C\u5730\u53D1\u7968 Token\u3002${E10_REAUTH_GUIDANCE}`,
+        { ret: code }
+      );
+    }
+    throw businessError(value);
+  }
+  async function invoiceRequest(request, canRetryExpiredToken = true) {
+    const {
+      method = "POST",
+      path,
+      query,
+      headers,
+      body,
+      operation,
+      needsInvoiceToken = true,
+      timeoutMs = 3e4
+    } = request;
+    assertPath(path);
+    const token = await ensureContext(needsInvoiceToken, timeoutMs, path);
+    const response = await (await runtime()).requestJson({
+      module: "invoice",
+      operation,
+      method,
+      path,
+      query,
+      headers,
+      body,
+      timeoutMs,
+      trustedHeaders: trustedInvoiceHeaders(token)
+    });
+    if (response.status === 401 || response.status === 302) {
+      throw invoiceAuthError("session_expired", E10_SESSION_EXPIRED_MESSAGE, { httpStatus: response.status });
+    }
+    if (response.parseError) {
+      if (response.status < 200 || response.status >= 300) {
+        throw new InvoiceCliError("api", "http_error", `\u6CDB\u5FAE\u63A5\u53E3 HTTP ${response.status}`, {
+          code: response.status,
+          details: { status: response.status },
+          exitCode: 1
+        });
+      }
+      throw invoiceNetworkError("protocol", `\u63A5\u53E3\u8FD4\u56DE\u4E0D\u662F\u5408\u6CD5 JSON\uFF08HTTP ${response.status}\uFF09`, { retryable: false });
+    }
+    if (response.status < 200 || response.status >= 300) {
+      throw new InvoiceCliError("api", "http_error", `\u6CDB\u5FAE\u63A5\u53E3 HTTP ${response.status}`, {
+        code: response.status,
+        details: { status: response.status, message: responseMessage(response.value) },
+        exitCode: 1
+      });
+    }
+    let value = response.value;
+    if (request.rewriteJsonText && response.text) {
+      try {
+        value = JSON.parse(request.rewriteJsonText(response.text));
+      } catch {
+        value = response.value;
+      }
+    }
+    return handleBusinessResponse(value, () => invoiceRequest(request, false), canRetryExpiredToken && Boolean(token));
+  }
+  async function invoiceMultipartRequest(request, canRetryExpiredToken = true) {
+    const {
+      method = "POST",
+      path,
+      query,
+      fields = {},
+      file,
+      headers,
+      operation,
+      needsInvoiceToken = true,
+      timeoutMs = 3e4
+    } = request;
+    if (!file && !Object.values(fields).some((value) => value !== void 0 && value !== null && value !== "")) {
+      throw invoiceValidationError("input_invalid", "multipart \u8BF7\u6C42\u9700\u8981\u6587\u4EF6\u3001URL \u6216\u8868\u5355\u5B57\u6BB5");
+    }
+    assertPath(path);
+    const token = await ensureContext(needsInvoiceToken, timeoutMs, path);
+    const form = new FormData();
+    for (const [key, value] of Object.entries(fields)) {
+      if (value === void 0 || value === null) continue;
+      form.append(key, typeof value === "string" ? value : JSON.stringify(value));
+    }
+    if (file) {
+      const content = await readFile(file.path);
+      form.append("file", new Blob([content], { type: file.mimeType || "application/octet-stream" }), file.name);
+    }
+    const response = await (await runtime()).requestJson({
+      module: "invoice",
+      operation,
+      method,
+      path,
+      query,
+      headers,
+      formData: form,
+      timeoutMs,
+      trustedHeaders: trustedInvoiceHeaders(token)
+    });
+    if (response.status === 401 || response.status === 302) {
+      throw invoiceAuthError("session_expired", E10_SESSION_EXPIRED_MESSAGE, { httpStatus: response.status });
+    }
+    if (response.parseError) {
+      throw invoiceNetworkError("protocol", `\u63A5\u53E3\u8FD4\u56DE\u4E0D\u662F\u5408\u6CD5 JSON\uFF08HTTP ${response.status}\uFF09`, { retryable: false });
+    }
+    if (response.status < 200 || response.status >= 300) {
+      throw new InvoiceCliError("api", "http_error", `\u6CDB\u5FAE\u63A5\u53E3 HTTP ${response.status}`, {
+        code: response.status,
+        details: { status: response.status, message: responseMessage(response.value) },
+        exitCode: 1
+      });
+    }
+    return handleBusinessResponse(response.value, () => invoiceMultipartRequest(request, false), canRetryExpiredToken && Boolean(token));
+  }
+  async function invoiceFormRequest(request, canRetryExpiredToken = true) {
+    const {
+      method = "POST",
+      path,
+      query,
+      fields = {},
+      operation,
+      needsInvoiceToken = true,
+      timeoutMs = 3e4
+    } = request;
+    assertPath(path);
+    const token = await ensureContext(needsInvoiceToken, timeoutMs, path);
+    const form = new URLSearchParams();
+    for (const [key, value] of Object.entries(fields)) {
+      if (value === void 0 || value === null) continue;
+      form.set(key, typeof value === "string" ? value : JSON.stringify(value));
+    }
+    const response = await (await runtime()).requestJson({
+      module: "invoice",
+      operation,
+      method,
+      path,
+      query,
+      form,
+      timeoutMs,
+      trustedHeaders: trustedInvoiceHeaders(token)
+    });
+    if (response.status === 401 || response.status === 302) {
+      throw invoiceAuthError("session_expired", E10_SESSION_EXPIRED_MESSAGE, { httpStatus: response.status });
+    }
+    if (response.parseError) {
+      throw invoiceNetworkError("protocol", `\u63A5\u53E3\u8FD4\u56DE\u4E0D\u662F\u5408\u6CD5 JSON\uFF08HTTP ${response.status}\uFF09`, { retryable: false });
+    }
+    if (response.status < 200 || response.status >= 300) {
+      throw new InvoiceCliError("api", "http_error", `\u6CDB\u5FAE\u63A5\u53E3 HTTP ${response.status}`, {
+        code: response.status,
+        details: { status: response.status, message: responseMessage(response.value) },
+        exitCode: 1
+      });
+    }
+    return handleBusinessResponse(response.value, () => invoiceFormRequest(request, false), canRetryExpiredToken && Boolean(token));
+  }
+  async function invoiceDownload({ id, fid, needLog = false, operation, timeoutMs = 3e4 }, canRetryExpiredToken = true) {
+    const token = await ensureContext(true, timeoutMs, "/api/inc/file/download");
+    const response = await (await runtime()).requestBinary({
+      module: "invoice",
+      operation,
+      method: "GET",
+      path: "/api/inc/file/download",
+      query: { id, fid, needLog },
+      headers: { Accept: "application/octet-stream, application/pdf, */*" },
+      timeoutMs,
+      trustedHeaders: trustedInvoiceHeaders(token)
+    });
+    if (response.status === 401 || response.status === 302) {
+      throw invoiceAuthError("session_expired", E10_SESSION_EXPIRED_MESSAGE, { httpStatus: response.status });
+    }
+    const contentType = response.contentType;
+    const declaredLength = Number(response.headers.get("content-length"));
+    if (Number.isFinite(declaredLength) && declaredLength > MAX_DOWNLOAD_BYTES) {
+      throw invoiceNetworkError("response_too_large", `\u4E0B\u8F7D\u6587\u4EF6\u8D85\u8FC7 ${MAX_DOWNLOAD_BYTES} \u5B57\u8282\u9650\u5236`, { retryable: false });
+    }
+    const content = response.content;
+    const looksLikeJson = /^[\s\r\n]*[\[{]/u.test(content.subarray(0, 64).toString("utf8"));
+    if (response.status < 200 || response.status >= 300 || contentType.includes("json") || looksLikeJson) {
+      let value = {};
+      try {
+        value = JSON.parse(content.toString("utf8"));
+      } catch {
+        value = {};
+      }
+      if (isInvoiceSessionExpired(value)) {
+        await clearCachedInvoiceToken();
+        if (canRetryExpiredToken && token) return invoiceDownload({ id, fid, needLog, operation, timeoutMs }, false);
+        throw invoiceAuthError(
+          "invoice_session_expired",
+          `\u53D1\u7968\u4E1A\u52A1\u767B\u5F55\u6001\u5DF2\u5931\u6548\uFF0C\u5DF2\u6E05\u7406\u672C\u5730\u53D1\u7968 Token\u3002${E10_REAUTH_GUIDANCE}`,
+          { ret: responseCode(value), status: response.status }
+        );
+      }
+      throw new InvoiceCliError("api", "download_failed", responseMessage(value) || `\u4E0B\u8F7D\u5931\u8D25\uFF08HTTP ${response.status}\uFF09`, {
+        code: response.status,
+        details: { status: response.status, ret: responseCode(value) },
+        exitCode: 1
+      });
+    }
+    if (!content.length) {
+      throw invoiceNetworkError("protocol", "\u4E0B\u8F7D\u63A5\u53E3\u8FD4\u56DE\u7A7A\u6587\u4EF6", { retryable: false });
+    }
+    if (content.length > MAX_DOWNLOAD_BYTES) {
+      throw invoiceNetworkError("response_too_large", `\u4E0B\u8F7D\u6587\u4EF6\u8D85\u8FC7 ${MAX_DOWNLOAD_BYTES} \u5B57\u8282\u9650\u5236`, { retryable: false });
+    }
+    return { content, contentType };
+  }
+  return {
+    invoiceRequest,
+    invoiceMultipartRequest,
+    invoiceFormRequest,
+    invoiceDownload,
+    getSession,
+    invalidateToken() {
+      invoiceToken = null;
+      void clearCachedInvoiceToken();
+    }
+  };
+}
+
+export {
+  InvoiceCliError,
+  invoiceValidationError,
+  invoiceConfirmationError,
+  invoicePartialError,
+  isInvoiceNetworkError,
+  clearInvoiceTokenForSession,
+  createInvoiceHost
+};