weaver-work-cli 0.1.29 → 0.1.32

package/dist/chunks/chunk-DW6AUUKS.js

@@ -0,0 +1,508 @@
+import { createRequire as __esbuildCreateRequire } from 'node:module';
+const require = __esbuildCreateRequire(import.meta.url);
+import {
+  E10AuthSession,
+  E10_AUTH_REQUIRED_MESSAGE,
+  getActiveProfile,
+  hasXiaoEEnv,
+  tryXiaoEUnifiedLogin
+} from "./chunk-2GA5ZIQL.js";
+import {
+  CliError
+} from "./chunk-LUSPKZKY.js";
+
+// src/internal/e10/auth-recovery.ts
+var AUTH_REQUIRED_CODES = /* @__PURE__ */ new Set(["-2", "401"]);
+var AUTH_REQUIRED_MARKERS = [
+  "\u672A\u767B\u5F55",
+  "\u8BF7\u767B\u5F55",
+  "\u91CD\u65B0\u767B\u5F55",
+  "\u767B\u5F55\u5931\u6548",
+  "\u767B\u5F55\u5DF2\u5931\u6548",
+  "\u767B\u5F55\u8FC7\u671F",
+  "\u767B\u5F55\u5DF2\u8FC7\u671F",
+  "\u767B\u5F55\u8D85\u65F6",
+  "\u4F1A\u8BDD\u5931\u6548",
+  "\u4F1A\u8BDD\u8FC7\u671F",
+  "\u8BA4\u8BC1\u5931\u8D25",
+  "\u8EAB\u4EFD\u8BA4\u8BC1\u5931\u8D25",
+  "token expired",
+  "token timeout",
+  "token invalid",
+  "session expired",
+  "login required",
+  "not logged in",
+  "not login"
+];
+var recoveryInFlight = /* @__PURE__ */ new Map();
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function responseCodes(value) {
+  const root = asRecord(value);
+  if (!root) return [];
+  const data = asRecord(root.data);
+  const resBase = asRecord(root.res_base);
+  const nestedResBase = asRecord(data?.res_base);
+  return [root.code, data?.code, resBase?.ret, nestedResBase?.ret].filter((item) => item !== void 0 && item !== null).map(String);
+}
+function authenticationTextFields(value) {
+  if (typeof value === "string") return [value];
+  const root = asRecord(value);
+  if (!root) return [];
+  const data = asRecord(root.data);
+  const values = [];
+  for (const record of [root, data]) {
+    if (!record) continue;
+    for (const key of ["message", "msg", "error", "errorMsg", "rawText"]) values.push(record[key]);
+  }
+  return values.filter((item) => typeof item === "string" || typeof item === "number").map(String);
+}
+function responseText(response) {
+  const fields = authenticationTextFields(response.value);
+  if (fields.length) return fields.join("\n");
+  if (asRecord(response.value)) return "";
+  if (typeof response.text === "string" && response.text) return response.text;
+  if (response.content && response.content.length) {
+    return response.content.subarray(0, 8 * 1024).toString("utf8");
+  }
+  return "";
+}
+function isE10AuthenticationRequired(response) {
+  if (response.status === 401 || response.status === 302) return true;
+  if (responseCodes(response.value).some((code) => AUTH_REQUIRED_CODES.has(code))) return true;
+  const text = responseText(response).toLowerCase();
+  if (!text) return false;
+  if (text.includes("login.jsp")) return true;
+  if (text.includes("<input") && text.includes("password")) return true;
+  return AUTH_REQUIRED_MARKERS.some((marker) => text.includes(marker.toLowerCase()));
+}
+function globalOptions(ctx) {
+  return typeof ctx.getGlobalOptions === "function" ? ctx.getGlobalOptions() : {};
+}
+function canAutomaticallyRecoverXiaoE(ctx) {
+  const options = globalOptions(ctx);
+  return !options.auth && hasXiaoEEnv(ctx.env || process.env, options);
+}
+async function recoverXiaoEAuthSession(ctx, currentSession) {
+  if (!canAutomaticallyRecoverXiaoE(ctx)) return null;
+  const options = globalOptions(ctx);
+  const profile = options.profile || getActiveProfile();
+  const baseUrl = currentSession.getBaseUrl();
+  const key = `${profile}
+${baseUrl}`;
+  const existing = recoveryInFlight.get(key);
+  if (existing) return existing;
+  const recovery = (async () => {
+    const login = await tryXiaoEUnifiedLogin({
+      env: ctx.env,
+      baseUrl,
+      profileBaseUrl: baseUrl,
+      allowBundledEnvScript: true,
+      allowTokenScript: true,
+      tenantKeyFallback: currentSession.tenantKey,
+      profileHint: profile
+      // Intentionally no logger: transparent recovery must not leak an
+      // intermediate "login" step into agent stdout/stderr or JSON output.
+    });
+    return login?.session || null;
+  })();
+  recoveryInFlight.set(key, recovery);
+  try {
+    return await recovery;
+  } finally {
+    if (recoveryInFlight.get(key) === recovery) recoveryInFlight.delete(key);
+  }
+}
+function sameE10SessionIdentity(current, recovered) {
+  const currentBaseUrl = current.getBaseUrl().replace(/\/+$/u, "").toLowerCase();
+  const recoveredBaseUrl = recovered.getBaseUrl().replace(/\/+$/u, "").toLowerCase();
+  if (currentBaseUrl !== recoveredBaseUrl) return false;
+  return !current.userId || !recovered.userId || current.userId === recovered.userId;
+}
+
+// src/internal/e10/context.ts
+async function getE10Session(ctx, load = {}) {
+  const options = ctx.getGlobalOptions();
+  return E10AuthSession.fromOptions(options, ctx.cwd, load);
+}
+async function requireE10Session(ctx, load = {}) {
+  const session = await getE10Session(ctx, load);
+  if (!session) {
+    throw new CliError(E10_AUTH_REQUIRED_MESSAGE, 3 /* AuthError */);
+  }
+  return session;
+}
+
+// src/internal/e10/request-runtime.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_BIG_INT_STRINGS = true;
+var RESERVED_HEADERS = [
+  "authorization",
+  "cookie",
+  "eteamsid",
+  "token"
+];
+var E10ApiError = class extends CliError {
+  type;
+  subtype;
+  code;
+  retryable;
+  details;
+  constructor(type, subtype, message, options = {}) {
+    super(message, options.exitCode ?? 1 /* GeneralError */);
+    this.name = "E10ApiError";
+    this.type = type;
+    this.subtype = subtype;
+    this.code = options.code;
+    this.retryable = options.retryable ?? false;
+    this.details = options.details;
+  }
+};
+var E10RequestRuntime = class {
+  constructor(ctx, session, dependencies = {}) {
+    this.ctx = ctx;
+    this.session = session;
+    this.fetchFn = dependencies.fetch || globalThis.fetch;
+    this.attachSessionTicket = dependencies.attachSessionTicket === true;
+    this.recoverAuthentication = dependencies.recoverAuthentication || ((current) => recoverXiaoEAuthSession(this.ctx, current));
+    this.interceptors = [
+      ...this.ctx.hooks?.getE10RequestInterceptors?.() || [],
+      ...dependencies.interceptors || []
+    ];
+  }
+  ctx;
+  session;
+  interceptors;
+  fetchFn;
+  attachSessionTicket;
+  recoverAuthentication;
+  async requestJson(request) {
+    return this.request({ ...request, responseType: "json" });
+  }
+  async requestBinary(request) {
+    return this.request({ ...request, responseType: "binary" });
+  }
+  async request(request) {
+    const mutable = this.prepareRequest(request);
+    try {
+      await this.runBeforeRequest(mutable, this.sessionContext());
+      this.assertPath(mutable.path);
+      if (mutable.path !== request.path) {
+        throw new E10ApiError("policy", "path_rewrite_denied", "E10 API \u62E6\u622A\u5668\u4E0D\u80FD\u4FEE\u6539\u8BF7\u6C42\u8DEF\u5F84", {
+          exitCode: 6 /* PolicyError */,
+          details: { from: request.path, to: mutable.path }
+        });
+      }
+      stripReservedHeaders(mutable.headers);
+      const requestEteamsId = this.session.eteamsId;
+      let parsed = await this.executeRequest(mutable, request.trustedHeaders);
+      if (!mutable.streamBody && isE10AuthenticationRequired(parsed) && await this.recoverExpiredSession(requestEteamsId)) {
+        parsed = await this.executeRequest(mutable, request.trustedHeaders);
+      }
+      await this.runAfterResponse(mutable, this.sessionContext(), parsed);
+      return parsed;
+    } catch (error) {
+      await this.runOnError(mutable, this.sessionContext(), error);
+      throw error;
+    }
+  }
+  async executeRequest(request, trustedHeaders = {}) {
+    const url = withQuery(this.session.getBaseUrl(), request.path, request.query);
+    const headers = this.composeHeaders(request, trustedHeaders);
+    const init = this.buildFetchInit(request, headers);
+    const response = await this.fetchWithTimeout(url, init, request.timeoutMs);
+    return this.readResponse(
+      response,
+      request.responseType,
+      request.bigIntStrings,
+      request.maxResponseBytes,
+      request.timeoutMs
+    );
+  }
+  async recoverExpiredSession(requestEteamsId) {
+    if (this.session.eteamsId && this.session.eteamsId !== requestEteamsId) return true;
+    let recovered;
+    try {
+      recovered = await this.recoverAuthentication(this.session);
+    } catch {
+      return false;
+    }
+    if (!recovered) return false;
+    if (!sameE10SessionIdentity(this.session, recovered)) {
+      throw new E10ApiError(
+        "authentication",
+        "session_context_changed",
+        "XiaoE \u81EA\u52A8\u6062\u590D\u540E\u7684\u767B\u5F55\u8EAB\u4EFD\u6216 E10 \u73AF\u5883\u53D1\u751F\u53D8\u5316\uFF0C\u672C\u6B21\u8BF7\u6C42\u672A\u91CD\u8BD5",
+        { exitCode: 3 /* AuthError */, retryable: false }
+      );
+    }
+    const original = this.session;
+    if (typeof original.replaceWith === "function") {
+      original.replaceWith(recovered);
+      this.session = original;
+    } else {
+      this.session = recovered;
+    }
+    return true;
+  }
+  prepareRequest(request) {
+    return {
+      module: request.module,
+      operation: request.operation,
+      method: (request.method || "POST").toUpperCase(),
+      path: request.path,
+      query: { ...request.query || {} },
+      headers: sanitizePublicHeaders(request.headers || {}),
+      body: request.body,
+      form: request.form,
+      formData: request.formData,
+      streamBody: request.streamBody,
+      maxResponseBytes: request.maxResponseBytes,
+      timeoutMs: request.timeoutMs || DEFAULT_TIMEOUT_MS,
+      responseType: request.responseType || "json",
+      bigIntStrings: request.bigIntStrings ?? DEFAULT_BIG_INT_STRINGS
+    };
+  }
+  sessionContext() {
+    return {
+      baseUrl: this.session.getBaseUrl(),
+      userId: this.session.userId,
+      agentType: this.session.agentType
+    };
+  }
+  async runBeforeRequest(request, session) {
+    for (const interceptor of this.interceptors) {
+      await interceptor.beforeRequest?.({ request, session });
+    }
+  }
+  async runAfterResponse(request, session, response) {
+    for (const interceptor of this.interceptors) {
+      await interceptor.afterResponse?.({
+        request: requestForHook(request),
+        session,
+        response: responseForHook(response)
+      });
+    }
+  }
+  async runOnError(request, session, error) {
+    for (const interceptor of this.interceptors) {
+      await interceptor.onError?.({ request, session, error });
+    }
+  }
+  assertPath(requestPath) {
+    if (typeof requestPath !== "string" || !requestPath.startsWith("/") || requestPath.startsWith("//")) {
+      throw new E10ApiError("validation", "path_invalid", "\u8BF7\u6C42\u8DEF\u5F84\u5FC5\u987B\u662F\u76F8\u5BF9\u7EDD\u5BF9\u8DEF\u5F84", {
+        exitCode: 2 /* UsageError */
+      });
+    }
+    if (/^https?:/i.test(requestPath) || /[\r\n]/.test(requestPath) || requestPath.includes("/../")) {
+      throw new E10ApiError("validation", "path_invalid", "\u8BF7\u6C42\u8DEF\u5F84\u4E0D\u5141\u8BB8\u8DE8\u57DF\u6216\u8DEF\u5F84\u9003\u9038", {
+        exitCode: 2 /* UsageError */
+      });
+    }
+    if (!requestPath.startsWith("/api/")) {
+      throw new E10ApiError("validation", "path_not_allowed", "E10 API \u53EA\u80FD\u8C03\u7528 /api/ \u8DEF\u5F84", {
+        exitCode: 2 /* UsageError */
+      });
+    }
+  }
+  composeHeaders(request, trustedHeaders = {}) {
+    return {
+      Accept: "application/json, text/plain, */*",
+      // E10 各端（含 eBuilder 表单运行态）依赖这两个头；缺失时 EB formdata 接口会直接返回
+      // 业务失败（CLI 侧表现为 business_error「泛微接口返回业务失败」，且响应无可读 message，
+      // 极易被误判为「EB 未配置/环境不对」）。standalone skill 的脚本一直带这两个头。
+      langType: "zh_CN",
+      timeZoneOffset: String((/* @__PURE__ */ new Date()).getTimezoneOffset()),
+      ...request.headers,
+      Cookie: this.attachSessionTicket ? this.session.cookieHeaderWithSessionTicket() : this.session.cookieHeader(),
+      eteamsid: this.session.eteamsId,
+      "User-Agent": this.session.uaHeader(),
+      Origin: this.session.getBaseUrl(),
+      "X-Weaver-Cli-Source": "weaver-work-cli",
+      "X-Weaver-Cli-Version": this.ctx.packageInfo?.version || "unknown",
+      ...request.module ? { "X-Weaver-Cli-Module": request.module } : {},
+      ...request.operation ? { "X-Weaver-Cli-Operation": request.operation } : {},
+      ...trustedHeaders
+    };
+  }
+  buildFetchInit(request, headers) {
+    const init = {
+      method: request.method,
+      headers,
+      redirect: "manual"
+    };
+    if (request.streamBody) {
+      init.body = request.streamBody;
+      init.duplex = "half";
+    } else if (request.formData) {
+      init.body = request.formData;
+    } else if (request.form !== void 0) {
+      headers["Content-Type"] = "application/x-www-form-urlencoded;charset=UTF-8";
+      init.body = String(request.form);
+    } else if (request.body !== void 0) {
+      headers["Content-Type"] = "application/json;charset=UTF-8";
+      init.body = JSON.stringify(request.body);
+    }
+    return init;
+  }
+  async fetchWithTimeout(url, init, timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      return await this.fetchFn(url, { ...init, signal: controller.signal });
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new E10ApiError("network", "timeout", `\u8BF7\u6C42\u8D85\u65F6\uFF08${timeoutMs}ms\uFF09`, {
+          retryable: false,
+          exitCode: 4 /* NetworkError */
+        });
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      throw new E10ApiError("network", "transport", `\u8BF7\u6C42\u5931\u8D25\uFF1A${message}`, {
+        retryable: true,
+        exitCode: 4 /* NetworkError */
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async readResponse(response, responseType, bigIntStrings = DEFAULT_BIG_INT_STRINGS, maxResponseBytes, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    if (responseType === "binary") {
+      return {
+        status: response.status,
+        headers: response.headers,
+        content: Buffer.from(await response.arrayBuffer()),
+        contentType: response.headers.get("content-type") || "application/octet-stream"
+      };
+    }
+    const text = maxResponseBytes === void 0 ? await response.text() : await readBoundedText(response, maxResponseBytes, timeoutMs);
+    let value = {};
+    let parseError;
+    try {
+      value = text ? bigIntStrings ? parseJsonPreservingBigInts(text) : JSON.parse(text) : {};
+    } catch (error) {
+      parseError = error instanceof Error ? error : new Error(String(error));
+    }
+    return {
+      status: response.status,
+      headers: response.headers,
+      text,
+      value,
+      ...parseError ? { parseError } : {}
+    };
+  }
+};
+function parseJsonPreservingBigInts(text) {
+  return JSON.parse(quoteLargeJsonIntegers(text));
+}
+var LONG_INTEGER_MIN_DIGITS = 16;
+var JSON_STRING_OR_NUMBER = /"(?:[^"\\]|\\.)*"|-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/g;
+var LONG_DIGIT_RUN = /\d{16}/;
+function quoteLargeJsonIntegers(text) {
+  if (!LONG_DIGIT_RUN.test(text)) return text;
+  return text.replace(JSON_STRING_OR_NUMBER, (token) => {
+    if (token.charCodeAt(0) === 34) return token;
+    if (token.includes(".") || token.includes("e") || token.includes("E")) return token;
+    const digitCount = token.charCodeAt(0) === 45 ? token.length - 1 : token.length;
+    return digitCount >= LONG_INTEGER_MIN_DIGITS ? `"${token}"` : token;
+  });
+}
+function createE10RequestRuntime(ctx, session, dependencies = {}) {
+  return new E10RequestRuntime(ctx, session, dependencies);
+}
+function withQuery(baseUrl, requestPath, query = {}) {
+  const url = new URL(`${baseUrl}${requestPath}`);
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0 || value === null) continue;
+    if (Array.isArray(value)) {
+      for (const item of value) url.searchParams.append(key, String(item));
+    } else {
+      url.searchParams.set(key, String(value));
+    }
+  }
+  return url;
+}
+async function readBoundedText(response, limit, timeoutMs) {
+  if (!response.body) return "";
+  const reader = response.body.getReader();
+  const chunks = [];
+  let size = 0;
+  let expired = false;
+  const timer = setTimeout(() => {
+    expired = true;
+    void reader.cancel().catch(() => void 0);
+  }, timeoutMs);
+  try {
+    while (true) {
+      const next = await reader.read();
+      if (expired) throw new E10ApiError("network", "timeout", "\u6587\u4EF6\u670D\u52A1\u54CD\u5E94\u8BFB\u53D6\u8D85\u65F6", { retryable: false });
+      if (next.done) break;
+      size += next.value.byteLength;
+      if (size > limit) {
+        await reader.cancel().catch(() => void 0);
+        throw new E10ApiError("network", "response_too_large", "\u6587\u4EF6\u670D\u52A1\u54CD\u5E94\u8D85\u8FC7\u5927\u5C0F\u4E0A\u9650", { retryable: false });
+      }
+      chunks.push(next.value);
+    }
+    return Buffer.concat(chunks, size).toString("utf8");
+  } catch (error) {
+    if (error instanceof E10ApiError) throw error;
+    throw new E10ApiError("network", "response_read_failed", "\u6587\u4EF6\u670D\u52A1\u54CD\u5E94\u8BFB\u53D6\u5931\u8D25", { retryable: false });
+  } finally {
+    clearTimeout(timer);
+    reader.releaseLock();
+  }
+}
+function sanitizePublicHeaders(headers) {
+  const next = { ...headers };
+  stripReservedHeaders(next);
+  return next;
+}
+function stripReservedHeaders(headers) {
+  for (const key of Object.keys(headers)) {
+    if (RESERVED_HEADERS.includes(key.toLowerCase())) {
+      delete headers[key];
+    }
+  }
+}
+function responseForHook(response) {
+  if ("content" in response) {
+    return {
+      status: response.status,
+      headers: new Headers(response.headers),
+      contentType: response.contentType,
+      contentLength: response.content.length
+    };
+  }
+  return {
+    status: response.status,
+    headers: new Headers(response.headers),
+    value: cloneForHook(response.value),
+    text: response.text
+  };
+}
+function requestForHook(request) {
+  return {
+    ...request,
+    query: { ...request.query },
+    headers: { ...request.headers },
+    body: cloneForHook(request.body),
+    streamBody: void 0
+  };
+}
+function cloneForHook(value) {
+  if (value === void 0 || value === null) return value;
+  try {
+    return structuredClone(value);
+  } catch {
+    return value;
+  }
+}
+
+export {
+  requireE10Session,
+  E10ApiError,
+  createE10RequestRuntime
+};