weaver-work-cli 0.1.29 → 0.1.31

package/dist/chunks/chunk-R2IJAK7T.js

@@ -0,0 +1,464 @@
+import { createRequire as __esbuildCreateRequire } from 'node:module';
+const require = __esbuildCreateRequire(import.meta.url);
+import {
+  createE10RequestRuntime,
+  requireE10Session
+} from "./chunk-H3WDBYJW.js";
+import {
+  E10_REAUTH_GUIDANCE,
+  E10_SESSION_EXPIRED_MESSAGE,
+  getActiveProfile
+} from "./chunk-324YPTC2.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
+};

package/dist/chunks/chunk-R7O5PUWO.js

@@ -0,0 +1,205 @@
+import { createRequire as __esbuildCreateRequire } from 'node:module';
+const require = __esbuildCreateRequire(import.meta.url);
+import {
+  EsbCliError,
+  esbApiError,
+  esbAuthError,
+  esbNetworkError,
+  esbPermissionError,
+  esbValidationError,
+  esbWriteUncertain
+} from "./chunk-GPMFD4RD.js";
+import {
+  E10ApiError,
+  createE10RequestRuntime,
+  requireE10Session
+} from "./chunk-H3WDBYJW.js";
+import {
+  E10_SESSION_EXPIRED_MESSAGE,
+  getActiveProfile
+} from "./chunk-324YPTC2.js";
+
+// src/shortcuts/esb/host.ts
+var ESB_PATHS = {
+  inputFormat: "/api/bs/esb/setting/customData/application/copyCustomData",
+  trigger: "/api/esb/server/event/triggerActionFlow"
+};
+var TRIGGER_RESULT_CODES = {
+  100: { subtype: "parameter_invalid" },
+  101: { subtype: "batch_key_invalid" },
+  201: { subtype: "flow_not_bound" },
+  202: { subtype: "execute_failed" },
+  203: { subtype: "execute_timeout", retryable: true },
+  204: { subtype: "permission_denied", permission: true },
+  400: { subtype: "license_required" },
+  401: { subtype: "tenant_permission_denied", permission: true },
+  402: { subtype: "flow_disabled" },
+  403: { subtype: "tenant_missing", permission: true },
+  404: { subtype: "flow_not_found" },
+  500: { subtype: "execute_failed" },
+  501: { subtype: "result_fetch_failed", retryable: true },
+  502: { subtype: "result_fetch_timeout", retryable: true },
+  505: { subtype: "flow_running", retryable: true },
+  506: { subtype: "execution_loop_conflict" },
+  507: { subtype: "throttled", retryable: true },
+  508: { subtype: "throttled", retryable: true },
+  509: { subtype: "execution_terminated" },
+  510: { subtype: "memory_exceeded" },
+  511: { subtype: "throttled", retryable: true },
+  512: { subtype: "flow_in_recycle_bin" }
+};
+var TARGET_FATAL_SUBTYPES = /* @__PURE__ */ new Set([
+  "flow_not_found",
+  "flow_not_bound",
+  "flow_disabled",
+  "flow_in_recycle_bin",
+  "parameter_invalid"
+]);
+function isEsbFlowUnavailable(error) {
+  return error instanceof EsbCliError && TARGET_FATAL_SUBTYPES.has(error.subtype);
+}
+function triggerResultCode(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const raw = value.resultCode;
+  if (raw === void 0 || raw === null || raw === "") return void 0;
+  const numeric = Number(raw);
+  return Number.isFinite(numeric) ? numeric : void 0;
+}
+function assertPath(requestPath) {
+  if (typeof requestPath !== "string" || !requestPath.startsWith("/") || requestPath.startsWith("//")) {
+    throw esbValidationError("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 esbValidationError("path_invalid", "\u8BF7\u6C42\u8DEF\u5F84\u4E0D\u5141\u8BB8\u8DE8\u57DF\u6216\u8DEF\u5F84\u9003\u9038");
+  }
+  if (!requestPath.startsWith("/api/")) {
+    throw esbValidationError("path_not_allowed", "ESB \u52A8\u4F5C\u6D41\u53EA\u80FD\u8C03\u7528 /api/ \u8DEF\u5F84");
+  }
+}
+function mapRuntimeNetworkError(error) {
+  if (error instanceof E10ApiError && error.type === "network") {
+    throw esbNetworkError(error.subtype, error.message, {
+      retryable: error.retryable,
+      details: error.details
+    });
+  }
+  throw error;
+}
+function createEsbHost(ctx, dependencies = {}) {
+  let e10Session = null;
+  let sessionContext = null;
+  const requireSession = dependencies.requireSession || requireE10Session;
+  async function ensureSession() {
+    if (!e10Session) {
+      e10Session = await requireSession(ctx);
+      sessionContext = {
+        baseUrl: e10Session.getBaseUrl(),
+        profile: ctx.getGlobalOptions().profile || getActiveProfile(),
+        userId: e10Session.userId,
+        tenantKey: e10Session.tenantKey,
+        eteamsId: e10Session.eteamsId
+      };
+    }
+    return e10Session;
+  }
+  async function getSession() {
+    await ensureSession();
+    return sessionContext;
+  }
+  async function runtime() {
+    return createE10RequestRuntime(ctx, await ensureSession(), { fetch: dependencies.fetch });
+  }
+  async function send(operation, path, body) {
+    assertPath(path);
+    let response;
+    try {
+      response = await (await runtime()).requestJson({
+        module: "esb",
+        operation,
+        method: "POST",
+        path,
+        body,
+        headers: { "X-Requested-With": "XMLHttpRequest" },
+        timeoutMs: 6e4
+      });
+    } catch (error) {
+      mapRuntimeNetworkError(error);
+    }
+    if (response.status === 401 || response.status === 302) {
+      throw esbAuthError(
+        "session_expired",
+        E10_SESSION_EXPIRED_MESSAGE,
+        { httpStatus: response.status }
+      );
+    }
+    if (response.parseError) {
+      if (response.status < 200 || response.status >= 300) {
+        throw esbApiError("http_error", `\u6CDB\u5FAE\u63A5\u53E3 HTTP ${response.status}`, {
+          code: response.status,
+          details: { status: response.status }
+        });
+      }
+      throw esbNetworkError("protocol", `\u63A5\u53E3\u8FD4\u56DE\u4E0D\u662F\u5408\u6CD5 JSON\uFF08HTTP ${response.status}\uFF09`, { retryable: false });
+    }
+    if (response.status < 200 || response.status >= 300) {
+      throw esbApiError("http_error", `\u6CDB\u5FAE\u63A5\u53E3 HTTP ${response.status}`, {
+        code: response.status,
+        details: { status: response.status }
+      });
+    }
+    return response.value;
+  }
+  function assertTriggerSuccess(value, operation) {
+    const code = triggerResultCode(value);
+    const record = value && typeof value === "object" ? value : {};
+    const serverMessage = typeof record.resultMsg === "string" ? record.resultMsg.trim() : "";
+    if (code === void 0) {
+      throw esbNetworkError("protocol", "\u89E6\u53D1\u63A5\u53E3\u672A\u8FD4\u56DE resultCode\uFF0C\u65E0\u6CD5\u5224\u5B9A\u6267\u884C\u7ED3\u679C", {
+        retryable: false,
+        details: { operation }
+      });
+    }
+    if (code === 200) return value;
+    const rule = TRIGGER_RESULT_CODES[code] || { subtype: "business_error" };
+    const message = serverMessage || `\u52A8\u4F5C\u6D41\u6267\u884C\u5931\u8D25\uFF08resultCode=${code}\uFF09`;
+    const options = {
+      code,
+      retryable: rule.retryable ?? false,
+      details: { operation, resultCode: code, resultMsg: serverMessage }
+    };
+    if (rule.permission) throw esbPermissionError(rule.subtype, message, options);
+    throw esbApiError(rule.subtype, message, options);
+  }
+  return {
+    async inputFormat(applicationId) {
+      const value = await send("esb.input-format", ESB_PATHS.inputFormat, { applicationId });
+      const code = triggerResultCode(value);
+      if (code !== void 0 && code !== 200) assertTriggerSuccess(value, "esb.input-format");
+      return value;
+    },
+    async trigger(payload) {
+      let value;
+      try {
+        value = await send("esb.trigger.apply", ESB_PATHS.trigger, payload);
+      } catch (error) {
+        if (error instanceof EsbCliError && error.type === "network") {
+          throw esbWriteUncertain(
+            `\u89E6\u53D1\u8BF7\u6C42\u5DF2\u53D1\u51FA\u4F46\u672A\u53D6\u5F97\u7ED3\u679C\uFF08${error.subtype}\uFF09\uFF1A\u65E0\u6CD5\u786E\u8BA4\u52A8\u4F5C\u6D41\u662F\u5426\u5DF2\u6267\u884C\uFF0C\u8BF7\u5148\u5728 ESB \u4E2D\u5FC3\u67E5\u770B\u52A8\u4F5C\u6D41\u8FD0\u884C\u65E5\u5FD7\u540E\u518D\u51B3\u5B9A\u662F\u5426\u91CD\u8BD5`,
+            { cause: error.message }
+          );
+        }
+        throw error;
+      }
+      return assertTriggerSuccess(value, "esb.trigger.apply");
+    },
+    getSession
+  };
+}
+
+export {
+  ESB_PATHS,
+  TARGET_FATAL_SUBTYPES,
+  isEsbFlowUnavailable,
+  triggerResultCode,
+  createEsbHost
+};