weaver-work-cli 0.1.29 → 0.1.32

package/dist/chunks/chunk-IURUFGZK.js

@@ -0,0 +1,477 @@
+import { createRequire as __esbuildCreateRequire } from 'node:module';
+const require = __esbuildCreateRequire(import.meta.url);
+import {
+  ImCliError,
+  imAuthError,
+  imNetworkError,
+  imValidationError
+} from "./chunk-ZEDWSH32.js";
+import {
+  E10ApiError,
+  createE10RequestRuntime,
+  requireE10Session
+} from "./chunk-DW6AUUKS.js";
+import {
+  E10_SESSION_EXPIRED_MESSAGE,
+  getActiveProfile
+} from "./chunk-2GA5ZIQL.js";
+
+// src/shortcuts/im/host.ts
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { dirname, extname, resolve } from "node:path";
+var IM_PREFIX = "/api/em/msg/executeIm";
+function inferProfile(ctx) {
+  const options = ctx.getGlobalOptions();
+  return options.profile || getActiveProfile();
+}
+function assertPath(requestPath) {
+  if (typeof requestPath !== "string" || !requestPath.startsWith("/") || requestPath.startsWith("//")) {
+    throw imValidationError("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 imValidationError("path_invalid", "\u8BF7\u6C42\u8DEF\u5F84\u4E0D\u5141\u8BB8\u8DE8\u57DF\u6216\u8DEF\u5F84\u9003\u9038");
+  }
+}
+function formBody(form) {
+  if (!form) return void 0;
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(form)) {
+    if (value === void 0 || value === null) continue;
+    params.set(key, typeof value === "string" ? value : JSON.stringify(value));
+  }
+  return params;
+}
+function mapRuntimeNetworkError(error) {
+  if (error instanceof E10ApiError && error.type === "network") {
+    throw imNetworkError(error.subtype, error.message, {
+      retryable: error.retryable,
+      details: error.details
+    });
+  }
+  throw error;
+}
+function guessMime(name) {
+  const ext = extname(String(name || "")).toLowerCase();
+  const map = {
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".bmp": "image/bmp",
+    ".svg": "image/svg+xml",
+    ".pdf": "application/pdf",
+    ".txt": "text/plain",
+    ".md": "text/markdown",
+    ".doc": "application/msword",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ".xls": "application/vnd.ms-excel",
+    ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ".ppt": "application/vnd.ms-powerpoint",
+    ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    ".zip": "application/zip",
+    ".rar": "application/x-rar-compressed",
+    ".mp4": "video/mp4",
+    ".mp3": "audio/mpeg"
+  };
+  return map[ext] || "application/octet-stream";
+}
+async function md5File(filePath) {
+  const hash = createHash("md5");
+  const { createReadStream } = await import("node:fs");
+  const stream = createReadStream(filePath);
+  for await (const chunk of stream) hash.update(chunk);
+  return hash.digest("hex");
+}
+function createImHost(ctx, dependencies = {}) {
+  let e10Session = null;
+  let sessionContext = null;
+  let selfIdentity = null;
+  const personCache = /* @__PURE__ */ new Map();
+  const i18nCache = /* @__PURE__ */ new Map();
+  const requireSession = dependencies.requireSession || requireE10Session;
+  async function ensureSession() {
+    if (!e10Session) {
+      e10Session = await requireSession(ctx);
+      sessionContext = {
+        baseUrl: e10Session.getBaseUrl(),
+        profile: inferProfile(ctx),
+        userId: e10Session.userId,
+        tenantKey: e10Session.tenantKey,
+        eteamsId: e10Session.eteamsId,
+        agentType: e10Session.agentType
+      };
+    }
+    return e10Session;
+  }
+  async function getSession() {
+    await ensureSession();
+    return sessionContext;
+  }
+  async function runtime() {
+    return createE10RequestRuntime(ctx, await ensureSession(), {
+      interceptors: dependencies.interceptors,
+      fetch: dependencies.fetch
+    });
+  }
+  async function request(request2) {
+    const {
+      method,
+      path,
+      query,
+      body,
+      operation,
+      form,
+      multipart,
+      headers: extraHeaders = {},
+      // 与源 skill 一致：普通 JSON 请求 15 秒超时即视为失败（超时不做重试）
+      timeoutMs = 15e3
+    } = request2;
+    assertPath(path);
+    const resolvedMethod = method || (body === void 0 && form === void 0 && multipart === void 0 ? "GET" : "POST");
+    let response;
+    try {
+      response = await (await runtime()).requestJson({
+        module: "im",
+        operation,
+        method: resolvedMethod,
+        path,
+        query,
+        body: multipart === void 0 ? body : void 0,
+        form: multipart === void 0 && form === void 0 ? void 0 : formBody(form ?? {}),
+        formData: multipart,
+        headers: { "X-Requested-With": "XMLHttpRequest", ...extraHeaders },
+        timeoutMs
+      });
+    } catch (error) {
+      mapRuntimeNetworkError(error);
+    }
+    if (response.status === 401 || response.status === 302) {
+      throw imAuthError("session_expired", E10_SESSION_EXPIRED_MESSAGE, { httpStatus: response.status });
+    }
+    if (response.parseError) {
+      if (response.status < 200 || response.status >= 300) {
+        throw new ImCliError("api", "http_error", `\u6CDB\u5FAE\u63A5\u53E3 HTTP ${response.status}`, {
+          code: response.status,
+          details: { status: response.status },
+          exitCode: 1
+        });
+      }
+      throw imNetworkError("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 ImCliError("api", "http_error", `\u6CDB\u5FAE\u63A5\u53E3 HTTP ${response.status}`, {
+        code: response.status,
+        details: { status: response.status },
+        exitCode: 1
+      });
+    }
+    return response.value;
+  }
+  async function requestBinary(url, headers = {}) {
+    const session = await ensureSession();
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 6e4);
+    try {
+      const resp = await (dependencies.fetch || globalThis.fetch)(url, {
+        headers: {
+          accept: "application/json, text/plain, */*",
+          cookie: session.cookieHeader(),
+          eteamsid: session.eteamsId,
+          "user-agent": session.uaHeader(),
+          origin: session.getBaseUrl(),
+          ...headers
+        },
+        redirect: "manual",
+        signal: controller.signal
+      });
+      if (resp.status === 401 || resp.status === 302) {
+        throw imAuthError("session_expired", E10_SESSION_EXPIRED_MESSAGE);
+      }
+      if (resp.status !== 200) {
+        throw new ImCliError("api", "download_failed", `\u4E0B\u8F7D\u5931\u8D25 HTTP ${resp.status}`, {
+          code: resp.status,
+          exitCode: 1
+        });
+      }
+      return Buffer.from(await resp.arrayBuffer());
+    } catch (error) {
+      if (error instanceof ImCliError) throw error;
+      const message = error instanceof Error ? error.message : String(error);
+      throw imNetworkError("transport", `\u4E0B\u8F7D\u5931\u8D25\uFF1A${message}`, { retryable: true });
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async function getSelfIdentity() {
+    if (selfIdentity) return selfIdentity;
+    await ensureSession();
+    const base = sessionContext?.baseUrl || "";
+    if (!base) throw imAuthError("self_identity_unavailable", "\u7F3A\u5C11 baseUrl\uFF0C\u8BF7\u5148\u767B\u5F55");
+    const res = await request({
+      method: "POST",
+      path: `/api/baseserver/layout/teamsCheck?clientType=not_xinchuang&client=WEB&domainName=${encodeURIComponent(base)}`,
+      body: {},
+      operation: "im.self.identity"
+    });
+    const cur = res?.currentUser || res?.data?.currentUser || {};
+    const uid = String(cur.imUid || sessionContext?.userId || "");
+    const cid = String(cur.imCid || "");
+    const name = cur.name || cur.realName || cur.userName || "";
+    if (!uid || !cid) {
+      throw imAuthError("self_identity_incomplete", `teamsCheck \u672A\u8FD4\u56DE\u5B8C\u6574 IM \u8EAB\u4EFD\uFF08imUid=${uid || "-"}, imCid=${cid || "-"}\uFF09\uFF0C\u8BF7\u786E\u8BA4\u767B\u5F55\u6001\u540E\u91CD\u8BD5`);
+    }
+    selfIdentity = { uid, cid, name };
+    return selfIdentity;
+  }
+  async function uploadFile(filePath, options = {}) {
+    const abs = resolve(filePath);
+    if (!existsSync(abs)) throw imValidationError("file_not_found", `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`);
+    const st = await stat(abs);
+    if (!st.isFile()) throw imValidationError("file_invalid", `\u4E0D\u662F\u6587\u4EF6: ${abs}`);
+    const name = options.name || filePath.split(/[\\/]/).pop() || "file";
+    const size = st.size;
+    const md5 = await md5File(abs);
+    const data = await readFile(abs);
+    const mime = guessMime(name);
+    const permission = options.permission !== void 0 ? String(options.permission) : "3";
+    const shareUsers = options.shareUsers !== void 0 ? String(options.shareUsers) : "";
+    const shareGroups = options.shareGroups !== void 0 ? String(options.shareGroups) : "";
+    const lastModified = Math.round(st.mtimeMs);
+    const base = sessionContext?.baseUrl || (await getSession()).baseUrl;
+    const uploadHeaders = { devtype: "5", langtype: "zh_CN", timezoneoffset: String((/* @__PURE__ */ new Date()).getTimezoneOffset()) };
+    const preForm = new FormData();
+    const preFields = {
+      module: "im",
+      size: String(size),
+      name,
+      lastModified: String(lastModified),
+      lastModifiedDate: String(lastModified),
+      MD5: md5,
+      permission,
+      shareUsers,
+      shareGroups,
+      shareExternals: ""
+    };
+    for (const [k, v] of Object.entries(preFields)) preForm.append(k, v);
+    const preRes = await request({
+      method: "POST",
+      path: "/api/file/preUploadCheck",
+      multipart: preForm,
+      headers: uploadHeaders,
+      operation: "im.file.upload.check",
+      timeoutMs: 15e3
+    });
+    const preData = preRes?.data || {};
+    if (!preData.preUploadId) {
+      throw new ImCliError("api", "upload_check_failed", `preUploadCheck \u5931\u8D25`, { details: preRes, exitCode: 1 });
+    }
+    const preUploadId = String(preData.preUploadId);
+    const uploadType = preData.uploadType || "common";
+    const upForm = new FormData();
+    upForm.append("data", new Blob([data], { type: mime }), name);
+    for (const [k, v] of Object.entries({ module: "im", permission, shareUsers, shareGroups, shareExternals: "", uploadType, preUploadId, MD5: md5 })) {
+      upForm.append(k, v);
+    }
+    const upRes = await request({
+      method: "POST",
+      path: "/api/file/valid/upload",
+      multipart: upForm,
+      headers: uploadHeaders,
+      operation: "im.file.upload.do",
+      timeoutMs: 6e4
+    });
+    const upData = upRes?.data || {};
+    if (!upData.fileObj || !upData.fileObj.id && !upData.fileObj.fileid) {
+      throw new ImCliError("api", "upload_failed", `valid/upload \u5931\u8D25`, { details: upRes, exitCode: 1 });
+    }
+    return upData.fileObj;
+  }
+  async function resolveUsersByIds(ids) {
+    const unique = [...new Set(ids.map((x) => String(x)).filter(Boolean))];
+    const miss = unique.filter((id) => !personCache.has(id));
+    const result = {};
+    for (const id of unique) {
+      const hit = personCache.get(id);
+      if (hit) result[id] = hit;
+    }
+    for (let i = 0; i < miss.length; i += 100) {
+      const batch = miss.slice(i, i + 100);
+      const res = await request({
+        method: "POST",
+        path: "/api/hrm/common/getEmployeeByIds",
+        body: { userIdList: batch, externalIdList: [] },
+        headers: { devtype: "5" },
+        operation: "im.person.resolveByIds",
+        timeoutMs: 15e3
+      });
+      const list = res?.data?.userList;
+      if (Array.isArray(list)) {
+        for (const u of list) {
+          const brief = {
+            uid: String(u.id ?? ""),
+            name: String(u.name ?? ""),
+            cid: String(u.imCid ?? u.cid ?? ""),
+            jobNum: String(u.jobNum ?? u.job_num ?? ""),
+            department: String(u.department ?? ""),
+            departmentId: String(u.departmentId ?? u.department_id ?? ""),
+            subCompany: String(u.subCompany ?? u.subcompany ?? ""),
+            position: String(u.position ?? ""),
+            mobile: String(u.mobile ?? "")
+          };
+          if (brief.uid) {
+            personCache.set(brief.uid, brief);
+            result[brief.uid] = brief;
+          }
+        }
+      }
+    }
+    return result;
+  }
+  async function searchEmployeeByName(name) {
+    const baseForm = {
+      browserMultiple: true,
+      authWecahtBook: false,
+      wxDepNeedConvertCount: 0,
+      wxEmpNeedConvertCount: 0,
+      wxTotalNeedConvertCount: 0
+    };
+    const formDatas = {
+      status: [{ statusSelect: ["normal"] }],
+      subcompany: [{ subcompanyOpt: "in" }],
+      department: [{ departmentOpt: "in" }],
+      role: [{ roleOpt: "in" }],
+      position: [{ positionOpt: "in" }],
+      superior: [{ superiorOpt: "in" }]
+    };
+    if (/@/.test(name)) formDatas.email = [{ emailOpt: "in", emailInput: name }];
+    else if (/^\d{11}$/.test(name)) formDatas.mobile = [{ mobileOpt: "in", mobileInput: name }];
+    else if (/^\d+$/.test(name) || /^[A-Za-z][A-Za-z0-9]*\d[A-Za-z0-9]*$/.test(name)) formDatas.job_num = [{ job_numOpt: "in", job_numInput: name }];
+    else formDatas.username = [{ usernameOpt: "in", usernameInput: name }];
+    const out = [];
+    let current = 1;
+    const pageSize = 200;
+    for (; ; ) {
+      const res = await request({
+        method: "POST",
+        path: "/api/hrm/common/browser/data/resource",
+        body: { ...baseForm, cmd: "all", formDatas, quickSearchDatas: {}, type: "and", current, pageSize, containsNoneAccount: false, containsPartTimeEmployee: false, containsDls: false },
+        operation: "im.person.search",
+        timeoutMs: 15e3
+      });
+      const rows = res?.data?.data;
+      if (!Array.isArray(rows)) break;
+      for (const r of rows) {
+        if (!r?.name) continue;
+        const brief = {
+          uid: String(r.id ?? ""),
+          name: String(r.name),
+          cid: String(r.imCid ?? r.cid ?? ""),
+          jobNum: String(r.jobNum ?? r.job_num ?? ""),
+          department: String(r.department ?? ""),
+          departmentId: String(r.departmentId ?? r.department_id ?? ""),
+          subCompany: String(r.subCompany ?? r.subcompany ?? ""),
+          position: String(r.position ?? ""),
+          mobile: String(r.mobile ?? "")
+        };
+        if (brief.uid) personCache.set(brief.uid, brief);
+        out.push(brief);
+      }
+      if (rows.length < pageSize) break;
+      current++;
+      if (current > 5) break;
+    }
+    return out;
+  }
+  async function fetchI18nLabels(ids) {
+    const result = {};
+    const unique = [...new Set(ids.map((x) => String(x)).filter((x) => /^\d+$/.test(x)))];
+    const miss = unique.filter((id) => !i18nCache.has(id));
+    for (const id of unique) {
+      const hit = i18nCache.get(id);
+      if (hit !== void 0) result[id] = hit;
+    }
+    if (miss.length === 0) return result;
+    try {
+      const res = await request({
+        method: "POST",
+        path: "/api/bs/i18n/labelmanage/getHtmlLabelNames",
+        body: miss,
+        operation: "im.i18n.labels",
+        timeoutMs: 15e3
+      });
+      const data = res?.data || {};
+      for (const id of miss) {
+        if (data[id] !== void 0 && data[id] !== null) {
+          const text = String(data[id]);
+          i18nCache.set(id, text);
+          result[id] = text;
+        }
+      }
+    } catch {
+    }
+    return result;
+  }
+  async function buildPreviewUrl(options) {
+    await ensureSession();
+    const kind = options.kind === "video" ? "video" : "img";
+    const payload = { tag: kind === "video" ? "1" : "0", msgid: String(options.msgid) };
+    if (options.groupId !== void 0 && options.groupId !== null && String(options.groupId) !== "") {
+      payload.flag = 1;
+      payload.group_id = String(options.groupId);
+    } else {
+      payload.flag = 0;
+      payload.user = { cid: String(options.user?.cid ?? ""), uid: String(options.user?.uid ?? "") };
+    }
+    const weappAuthStr = Buffer.from(JSON.stringify(payload), "utf-8").toString("base64");
+    const params = new URLSearchParams();
+    params.set("fileId", String(options.fileId));
+    params.set("type", kind === "video" ? "video" : "imgs");
+    if (kind !== "video") params.set("imgFormat", options.imgFormat || "small");
+    params.set("authModule", "im");
+    params.set("weappAuthStr", weappAuthStr);
+    return `${(sessionContext?.baseUrl || "").replace(/\/+$/, "")}/api/file/preview?${params.toString()}`;
+  }
+  async function buildDownloadUrl(options) {
+    await ensureSession();
+    const kind = options.kind === "video" ? "video" : "img";
+    const payload = { tag: kind === "video" ? "1" : "0", msgid: String(options.msgid) };
+    if (options.groupId !== void 0 && options.groupId !== null && String(options.groupId) !== "") {
+      payload.flag = 1;
+      payload.group_id = String(options.groupId);
+    } else {
+      payload.flag = 0;
+      payload.user = { cid: String(options.user?.cid ?? ""), uid: String(options.user?.uid ?? "") };
+    }
+    const weappAuthStr = Buffer.from(JSON.stringify(payload), "utf-8").toString("base64");
+    const params = new URLSearchParams();
+    params.set("type", kind === "video" ? "video" : "imgs");
+    if (kind !== "video") params.set("imgFormat", options.imgFormat || "small");
+    params.set("authModule", "im");
+    params.set("weappAuthStr", weappAuthStr);
+    return `${(sessionContext?.baseUrl || "").replace(/\/+$/, "")}/api/file/remotedownload/${String(options.fileId)}/im/true?${params.toString()}`;
+  }
+  return {
+    request,
+    requestBinary,
+    getSession,
+    getSelfIdentity,
+    uploadFile,
+    resolveUsersByIds,
+    searchEmployeeByName,
+    fetchI18nLabels,
+    buildPreviewUrl,
+    buildDownloadUrl
+  };
+}
+
+export {
+  mkdir,
+  writeFile,
+  dirname,
+  IM_PREFIX,
+  assertPath,
+  createImHost
+};

package/dist/chunks/chunk-LUSPKZKY.js

@@ -0,0 +1,53 @@
+import { createRequire as __esbuildCreateRequire } from 'node:module';
+const require = __esbuildCreateRequire(import.meta.url);
+
+// src/core/errors.ts
+var CliError = class extends Error {
+  exitCode;
+  constructor(message, exitCode = 1 /* GeneralError */) {
+    super(message);
+    this.name = "CliError";
+    this.exitCode = exitCode;
+  }
+};
+function isCliError(error) {
+  return error instanceof CliError;
+}
+function isStructuredError(error) {
+  return Boolean(
+    error && typeof error === "object" && "type" in error && "subtype" in error && "message" in error && typeof error.type === "string" && typeof error.subtype === "string" && typeof error.message === "string"
+  );
+}
+function toErrorEnvelope(error) {
+  if (isStructuredError(error)) {
+    return {
+      type: error.type,
+      subtype: error.subtype,
+      ...error.code === void 0 ? {} : { code: error.code },
+      message: error.message,
+      retryable: error.retryable ?? false,
+      ...error.stage ? { stage: error.stage } : {},
+      ...error.details === void 0 ? {} : { details: error.details }
+    };
+  }
+  if (isCliError(error)) {
+    return {
+      type: error.exitCode === 3 /* AuthError */ ? "authentication" : "cli",
+      subtype: error.exitCode === 2 /* UsageError */ ? "usage" : "error",
+      message: error.message,
+      retryable: false
+    };
+  }
+  return {
+    type: "internal",
+    subtype: "unexpected",
+    message: error instanceof Error ? error.message : String(error),
+    retryable: false
+  };
+}
+
+export {
+  CliError,
+  isCliError,
+  toErrorEnvelope
+};

package/dist/chunks/chunk-NIAJ5ZCG.js

@@ -0,0 +1,73 @@
+import { createRequire as __esbuildCreateRequire } from 'node:module';
+const require = __esbuildCreateRequire(import.meta.url);
+import {
+  esbValidationError
+} from "./chunk-GPMFD4RD.js";
+
+// src/shortcuts/esb/continuation.ts
+import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
+import { existsSync } from "node:fs";
+import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+function stateRoot(ctx) {
+  const configured = ctx?.config?.path();
+  if (configured) return resolve(configured, "..");
+  return process.env.WEAVER_WORK_CLI_HOME || process.env.WORK_CLI_HOME || resolve(homedir(), ".weaver-work-cli");
+}
+async function loadKey(ctx) {
+  const keysDir = resolve(stateRoot(ctx), "keys");
+  const filename = resolve(keysDir, "esb-continuation.key");
+  await mkdir(keysDir, { recursive: true, mode: 448 });
+  if (existsSync(filename)) return readFile(filename);
+  const key = randomBytes(32);
+  try {
+    await writeFile(filename, key, { flag: "wx", mode: 384 });
+    if (process.platform !== "win32") await chmod(filename, 384).catch(() => void 0);
+    return key;
+  } catch {
+    return readFile(filename);
+  }
+}
+function encode(value) {
+  return Buffer.from(JSON.stringify(value)).toString("base64url");
+}
+function signature(payload, key) {
+  return createHmac("sha256", key).update(payload).digest("base64url");
+}
+function createEsbContinuationSigner(ctx) {
+  return {
+    async issue(payload, ttlMs = 10 * 6e4) {
+      const issuedAt = Date.now();
+      const body = encode({ ...payload, issuedAt, expiresAt: issuedAt + ttlMs });
+      const sig = signature(body, await loadKey(ctx));
+      return `${body}.${sig}`;
+    },
+    async verify(token, expectedOperation) {
+      if (typeof token !== "string" || !token.includes(".")) {
+        throw esbValidationError("continuation_invalid", "continuation \u65E0\u6548");
+      }
+      const [body, provided] = token.split(".");
+      const expected = signature(body, await loadKey(ctx));
+      const valid = provided.length === expected.length && timingSafeEqual(Buffer.from(provided), Buffer.from(expected));
+      if (!valid) throw esbValidationError("continuation_invalid", "continuation \u7B7E\u540D\u6821\u9A8C\u5931\u8D25");
+      let value;
+      try {
+        value = JSON.parse(Buffer.from(body, "base64url").toString("utf8"));
+      } catch {
+        throw esbValidationError("continuation_invalid", "continuation \u5185\u5BB9\u65E0\u6CD5\u89E3\u6790");
+      }
+      if (value.operation !== expectedOperation) {
+        throw esbValidationError("continuation_mismatch", "continuation \u4E0D\u5C5E\u4E8E\u5F53\u524D\u64CD\u4F5C");
+      }
+      if (!Number.isSafeInteger(value.expiresAt) || value.expiresAt < Date.now()) {
+        throw esbValidationError("continuation_expired", "continuation \u5DF2\u8FC7\u671F");
+      }
+      return value;
+    }
+  };
+}
+
+export {
+  createEsbContinuationSigner
+};