weaver-work-cli 0.1.32 → 0.1.33

package/dist/chunks/{chunk-WSKBSQ2U.js → chunk-PRHJGPMA.js}

@@ -8,11 +8,11 @@ import {
 import {
   createE10RequestRuntime,
   requireE10Session
-} from "./chunk-DW6AUUKS.js";
+} from "./chunk-6ATGWRZM.js";
 import {
   E10_SESSION_EXPIRED_MESSAGE,
   getActiveProfile
-} from "./chunk-2GA5ZIQL.js";
+} from "./chunk-D223PTXU.js";
 
 // src/shortcuts/workflow/host.ts
 var DEFAULT_TIMEOUT_MS = 3e4;

package/dist/chunks/{chunk-6EFWDL7Y.js → chunk-Q6LWB5HX.js}

@@ -10,11 +10,11 @@ import {
   E10ApiError,
   createE10RequestRuntime,
   requireE10Session
-} from "./chunk-DW6AUUKS.js";
+} from "./chunk-6ATGWRZM.js";
 import {
   E10_SESSION_EXPIRED_MESSAGE,
   getActiveProfile
-} from "./chunk-2GA5ZIQL.js";
+} from "./chunk-D223PTXU.js";
 
 // src/shortcuts/hrm/host.ts
 function inferProfile(ctx) {

package/dist/chunks/{chunk-IURUFGZK.js → chunk-RBGOMK4Y.js}

@@ -10,11 +10,11 @@ import {
   E10ApiError,
   createE10RequestRuntime,
   requireE10Session
-} from "./chunk-DW6AUUKS.js";
+} from "./chunk-6ATGWRZM.js";
 import {
   E10_SESSION_EXPIRED_MESSAGE,
   getActiveProfile
-} from "./chunk-2GA5ZIQL.js";
+} from "./chunk-D223PTXU.js";
 
 // src/shortcuts/im/host.ts
 import { createHash } from "node:crypto";
@@ -113,7 +113,8 @@ function createImHost(ctx, dependencies = {}) {
   async function runtime() {
     return createE10RequestRuntime(ctx, await ensureSession(), {
       interceptors: dependencies.interceptors,
-      fetch: dependencies.fetch
+      fetch: dependencies.fetch,
+      recoverAuthentication: dependencies.recoverAuthentication
     });
   }
   async function request(request2) {
@@ -172,38 +173,48 @@ function createImHost(ctx, dependencies = {}) {
   }
   async function requestBinary(url, headers = {}) {
     const session = await ensureSession();
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), 6e4);
+    const baseUrl = new URL(session.getBaseUrl());
+    let target;
     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
+      target = new URL(url, baseUrl);
+    } catch {
+      throw imValidationError("download_url_invalid", "\u4E0B\u8F7D\u5730\u5740\u4E0D\u662F\u5408\u6CD5 URL");
+    }
+    if (target.origin !== baseUrl.origin) {
+      throw imValidationError("download_url_cross_origin", "\u4E0B\u8F7D\u5730\u5740\u4E0D\u5141\u8BB8\u8DE8 E10 \u73AF\u5883");
+    }
+    assertPath(target.pathname);
+    const query = {};
+    for (const [key, value] of target.searchParams) {
+      const previous = query[key];
+      if (previous === void 0) query[key] = value;
+      else if (Array.isArray(previous)) previous.push(value);
+      else query[key] = [previous, value];
+    }
+    let response;
+    try {
+      response = await (await runtime()).requestBinary({
+        module: "im",
+        operation: "im.file.download",
+        method: "GET",
+        path: target.pathname,
+        query,
+        headers,
+        timeoutMs: 6e4
       });
-      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);
+      mapRuntimeNetworkError(error);
+    }
+    if (response.status === 401 || response.status === 302) {
+      throw imAuthError("session_expired", E10_SESSION_EXPIRED_MESSAGE);
     }
+    if (response.status !== 200) {
+      throw new ImCliError("api", "download_failed", `\u4E0B\u8F7D\u5931\u8D25 HTTP ${response.status}`, {
+        code: response.status,
+        exitCode: 1
+      });
+    }
+    return response.content;
   }
   async function getSelfIdentity() {
     if (selfIdentity) return selfIdentity;
@@ -265,11 +276,17 @@ function createImHost(ctx, dependencies = {}) {
       timeoutMs: 15e3
     });
     const preData = preRes?.data || {};
+    const preInfo = preData.imUploadInfoDto || preData;
+    const preFileObj = preInfo?.fileObj && (preInfo.fileObj.id || preInfo.fileObj.fileid) ? preInfo.fileObj : null;
+    const preUploadType = String(preData.uploadType || preInfo?.uploadType || "");
+    if (preFileObj && (!preData.preUploadId || preUploadType === "second")) {
+      return preFileObj;
+    }
     if (!preData.preUploadId) {
-      throw new ImCliError("api", "upload_check_failed", `preUploadCheck \u5931\u8D25`, { details: preRes, exitCode: 1 });
+      throw new ImCliError("api", "upload_check_failed", `preUploadCheck \u5931\u8D25\uFF08\u672A\u8FD4\u56DE preUploadId\uFF0C\u4E5F\u6CA1\u6709\u53EF\u590D\u7528\u7684\u79D2\u4F20 fileObj\uFF09`, { details: preRes, exitCode: 1 });
     }
     const preUploadId = String(preData.preUploadId);
-    const uploadType = preData.uploadType || "common";
+    const uploadType = preUploadType || "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 })) {

package/dist/chunks/chunk-VBCFFFGT.js

@@ -0,0 +1,226 @@
+import { createRequire as __esbuildCreateRequire } from 'node:module';
+const require = __esbuildCreateRequire(import.meta.url);
+import {
+  SCHEMA_ID,
+  ebBusinessSuccess,
+  meetingSuccess,
+  meetingValidationError
+} from "./chunk-MEEFGWTM.js";
+
+// src/shortcuts/meeting/operations/env.ts
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+var EB_SMOKE_PATH = "/api/ebuilder/form/formdata/v2/getFormDataList/query_meeting_baseset";
+var STD_CALENDAR_PATH = "/api/meeting/detail/getCalendarBaseData";
+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");
+}
+function meetingStateDir(ctx) {
+  return resolve(stateRoot(ctx), "meeting");
+}
+function cacheFile(ctx) {
+  return resolve(stateRoot(ctx), "meeting", "env-mode.json");
+}
+function emptyCache() {
+  return { schemaVersion: 1, environments: {} };
+}
+async function readCache(ctx) {
+  const file = cacheFile(ctx);
+  if (!existsSync(file)) return emptyCache();
+  try {
+    const parsed = JSON.parse(await readFile(file, "utf8"));
+    if (!parsed || typeof parsed !== "object" || !parsed.environments) return emptyCache();
+    return parsed;
+  } catch {
+    return emptyCache();
+  }
+}
+async function writeCache(ctx, baseUrl, mode, smokePath) {
+  try {
+    const file = cacheFile(ctx);
+    await mkdir(resolve(file, ".."), { recursive: true });
+    const cache = await readCache(ctx);
+    cache.environments[baseUrl] = { mode, smokePath, detectedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    await writeFile(file, JSON.stringify(cache, null, 2), "utf8");
+    return void 0;
+  } catch (error) {
+    return `\u73AF\u5883\u6A21\u5F0F\u7F13\u5B58\u5199\u5165\u5931\u8D25\uFF08\u4E0D\u5F71\u54CD\u672C\u6B21\u7ED3\u679C\uFF0C\u4E0B\u6B21\u4F1A\u91CD\u65B0\u5192\u70DF\uFF09\uFF1A${error instanceof Error ? error.message : String(error)}`;
+  }
+}
+var DEFAULT_MEETING_MODE = "eb";
+function describeEnvError(error) {
+  if (error instanceof Error) {
+    return `${error.type ?? "api"}/${error.subtype ?? "error"}: ${error.message}`;
+  }
+  return String(error);
+}
+async function probeAndPersist(host, ctx, knownEbError, options = {}) {
+  const persist = options.persist !== false;
+  const session = await host.getSession();
+  let ebError = knownEbError;
+  if (ebError === void 0) {
+    try {
+      await host.request({
+        method: "POST",
+        path: EB_SMOKE_PATH,
+        operation: "meeting.env.detect",
+        // EB list 的 datajson 内必须出现 mainTable 节点（空对象即可）：缺失时服务端报
+        // “mainTable解析异常,请参照文档修正数据格式”，冒烟会**假失败**并把 EB 环境误判为
+        // 标准版（2026-09-20 真机复现）。
+        body: { datajson: { mainTable: {}, header: { operator: session.userId } } },
+        // EB 响应不含 code/status（形如 {datajson:{datas:[...]}}），默认的 isBusinessSuccess
+        // 会判为 false → 冒烟假失败 → EB 环境被误判为标准版。
+        acceptBusiness: ebBusinessSuccess
+      });
+      const warning = await writeCache(ctx, session.baseUrl, "eb", EB_SMOKE_PATH);
+      return { mode: "eb", smokePath: EB_SMOKE_PATH, warning };
+    } catch (error) {
+      ebError = error;
+    }
+  }
+  try {
+    await host.request({
+      method: "GET",
+      path: STD_CALENDAR_PATH,
+      operation: "meeting.env.detect"
+    });
+    const warning = persist ? await writeCache(ctx, session.baseUrl, "standard", STD_CALENDAR_PATH) : void 0;
+    return {
+      mode: "standard",
+      smokePath: STD_CALENDAR_PATH,
+      ebSmokeFailed: true,
+      ebSmokeError: describeEnvError(ebError),
+      warning
+    };
+  } catch (stdError) {
+    throw meetingValidationError(
+      "env_unavailable",
+      "\u5F53\u524D\u73AF\u5883 EB \u7248\u4E0E\u6807\u51C6\u7248\u4F1A\u8BAE\u63A5\u53E3\u5192\u70DF\u5747\u672A\u901A\u8FC7\uFF0C\u8BF7\u786E\u8BA4\u4F1A\u8BAE\u5E94\u7528\u5DF2\u5B89\u88C5\u4E14\u63A5\u53E3\u5DF2\u914D\u7F6E\u5B8C\u6574",
+      {
+        eb: describeEnvError(ebError),
+        standard: describeEnvError(stdError)
+      }
+    );
+  }
+}
+async function resolveMeetingEnvMode(host, ctx, options = {}) {
+  const session = await host.getSession();
+  if (options.refresh === true) {
+    return { ...await probeAndPersist(host, ctx), fromCache: false };
+  }
+  const cache = await readCache(ctx);
+  const cached = cache.environments[session.baseUrl];
+  if (cached && (cached.mode === "eb" || cached.mode === "standard")) {
+    return {
+      mode: cached.mode,
+      smokePath: cached.smokePath,
+      fromCache: true,
+      detectedAt: cached.detectedAt
+    };
+  }
+  return { mode: DEFAULT_MEETING_MODE, smokePath: EB_SMOKE_PATH, fromCache: false, assumed: true };
+}
+async function degradeMeetingEnvToStandard(host, ctx, ebError, options = {}) {
+  const probed = await probeAndPersist(host, ctx, ebError, options);
+  return {
+    mode: "standard",
+    smokePath: probed.smokePath,
+    ebError: probed.ebSmokeError ?? describeEnvError(ebError),
+    ...probed.warning ? { warning: probed.warning } : {}
+  };
+}
+var meetingEnvDetect = {
+  name: "meeting.env.detect",
+  resource: "env",
+  method: "detect",
+  action: "meeting.env.detect",
+  summary: "\u63A2\u6D4B\u5F53\u524D\u73AF\u5883\u4F1A\u8BAE\u6A21\u5F0F\uFF1A**\u65E0\u63A2\u6D4B\u7ED3\u8BBA\u65F6\u76F4\u63A5\u6309 EB \u7248\u8FD4\u56DE**\uFF08`assumed=true`\uFF0C\u4E0D\u5192\u70DF\u3001\u4E0D\u5199\u7F13\u5B58\uFF09\uFF1BEB \u8D70\u4E0D\u901A\u65F6\u7531 EB \u8C03\u7528\u94FE\u81EA\u52A8\u5B9E\u63A2\u6807\u51C6\u7248\u5E76\u628A `standard` \u56FA\u5316\u8FDB\u7F13\u5B58\uFF1B`refresh=true` \u5F3A\u5236\u91CD\u65B0\u5192\u70DF",
+  capability: "env",
+  risk: "read",
+  inputSchema: {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      refresh: { type: "boolean", description: 'true=\u5FFD\u7565\u7F13\u5B58\u5F3A\u5236\u91CD\u65B0\u5192\u70DF\u5E76\u66F4\u65B0\u7F13\u5B58\uFF08\u7528\u6237\u8BF4"\u91CD\u65B0\u63A2\u6D4B/\u5237\u65B0\u6A21\u5F0F"\u65F6\u4F7F\u7528\uFF09' },
+      profileId: SCHEMA_ID
+    }
+  },
+  handler: async (args, { host, ctx }) => {
+    const result = await resolveMeetingEnvMode(host, ctx, { refresh: args.refresh === true });
+    const { warning, ...data } = result;
+    return meetingSuccess(
+      "meeting.env.detect",
+      data,
+      warning ? { warnings: [warning] } : void 0
+    );
+  }
+};
+var meetingCalendarBase = {
+  name: "meeting.calendar.base",
+  resource: "env",
+  method: "calendar.base",
+  action: "meeting.calendar.base",
+  summary: "\u67E5\u8BE2\u65E5\u5386/\u5EFA\u4F1A\u57FA\u7840\u4FE1\u606F\uFF08getCalendarBaseData\uFF09\uFF1AonlyFlowCreate / workFlowBaseIds / repeatWorkFlowBaseIds / existWorkFlow",
+  capability: "env",
+  risk: "read",
+  inputSchema: { type: "object", additionalProperties: false, properties: {} },
+  handler: async (_args, { host }) => {
+    const response = await host.request({
+      method: "GET",
+      path: STD_CALENDAR_PATH,
+      operation: "meeting.calendar.base"
+    });
+    const createBaseData = response?.data?.createBaseData ?? response?.createBaseData ?? null;
+    return meetingSuccess("meeting.calendar.base", { createBaseData, raw: response });
+  }
+};
+var meetingDetailField = {
+  name: "meeting.detail.field",
+  resource: "meeting",
+  method: "detail.field",
+  action: "meeting.detail.field",
+  summary: "\u67E5\u8BE2\u4F1A\u8BAE\u8BE6\u60C5\u8868\u5355\u7ED3\u6784\u4E0E options\uFF08getMeetingDetailField\uFF09\uFF1Aid / operateType / fromWorkflow / isReadOnly",
+  capability: "meeting",
+  risk: "read",
+  inputSchema: {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      id: SCHEMA_ID,
+      operateType: { type: "string", description: "\u64CD\u4F5C\u7C7B\u578B\uFF0C\u5982 SUBMIT/UPDATE/CHANGE" },
+      fromWorkflow: { type: "integer", enum: [0, 1] },
+      isReadOnly: { type: "integer", enum: [0, 1] }
+    },
+    required: ["id"]
+  },
+  handler: async (args, { host }) => {
+    const query = { id: String(args.id) };
+    if (args.operateType !== void 0) query.operateType = args.operateType;
+    if (args.fromWorkflow !== void 0) query.fromWorkflow = args.fromWorkflow;
+    if (args.isReadOnly !== void 0) query.isReadOnly = args.isReadOnly;
+    const response = await host.request({
+      method: "GET",
+      path: "/api/meeting/detail/getMeetingDetailField",
+      operation: "meeting.detail.field",
+      query
+    });
+    return meetingSuccess("meeting.detail.field", { data: response?.data ?? response });
+  }
+};
+var meetingEnvOperations = [
+  meetingEnvDetect,
+  meetingCalendarBase,
+  meetingDetailField
+];
+
+export {
+  meetingStateDir,
+  readCache,
+  resolveMeetingEnvMode,
+  degradeMeetingEnvToStandard,
+  meetingEnvOperations
+};