weaver-work-cli 0.1.29 → 0.1.32

package/dist/chunks/calendar-JKPIRKFD.js

@@ -0,0 +1,1195 @@
+import { createRequire as __esbuildCreateRequire } from 'node:module';
+const require = __esbuildCreateRequire(import.meta.url);
+import {
+  E10ApiError,
+  createE10RequestRuntime,
+  requireE10Session
+} from "./chunk-DW6AUUKS.js";
+import {
+  E10_SESSION_EXPIRED_MESSAGE,
+  getActiveProfile
+} from "./chunk-2GA5ZIQL.js";
+import {
+  CliError,
+  isCliError,
+  toErrorEnvelope
+} from "./chunk-LUSPKZKY.js";
+import "./chunk-BUSC6UAE.js";
+
+// src/shortcuts/calendar/index.ts
+import { readFile as readFile2 } from "node:fs/promises";
+
+// src/shortcuts/calendar/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";
+
+// src/shortcuts/calendar/errors.ts
+var CalendarCliError = class extends CliError {
+  type;
+  subtype;
+  code;
+  retryable;
+  stage;
+  details;
+  partialData;
+  constructor(type, subtype, message, options = {}) {
+    super(message, options.exitCode ?? 5 /* InternalError */);
+    this.name = "CalendarCliError";
+    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 calendarValidationError(subtype, message, details) {
+  return new CalendarCliError("validation", subtype, message, {
+    details,
+    exitCode: 2 /* UsageError */
+  });
+}
+function calendarAuthError(subtype, message, details) {
+  return new CalendarCliError("authentication", subtype, message, {
+    details,
+    exitCode: 3 /* AuthError */
+  });
+}
+function calendarNetworkError(subtype, message, options = {}) {
+  return new CalendarCliError("network", subtype, message, {
+    ...options,
+    retryable: options.retryable ?? true,
+    exitCode: 4 /* NetworkError */
+  });
+}
+function calendarConfirmationError(action, details) {
+  return new CalendarCliError("confirmation", "required", "\u8BE5\u64CD\u4F5C\u9700\u8981\u660E\u786E\u786E\u8BA4", {
+    details: { action, ...details },
+    exitCode: 10 /* ConfirmationRequired */
+  });
+}
+function calendarPartialError(message, partialData, details) {
+  return new CalendarCliError("partial", "write_uncertain", message, {
+    details,
+    partialData,
+    exitCode: 11 /* Partial */
+  });
+}
+
+// src/shortcuts/calendar/continuation.ts
+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, "calendar-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 createCalendarContinuationSigner(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 calendarValidationError("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 calendarValidationError("continuation_invalid", "continuation \u7B7E\u540D\u6821\u9A8C\u5931\u8D25");
+      let value;
+      try {
+        value = JSON.parse(Buffer.from(body, "base64url").toString("utf8"));
+      } catch {
+        throw calendarValidationError("continuation_invalid", "continuation \u5185\u5BB9\u65E0\u6CD5\u89E3\u6790");
+      }
+      if (value.operation !== expectedOperation) {
+        throw calendarValidationError("continuation_mismatch", "continuation \u4E0D\u5C5E\u4E8E\u5F53\u524D\u64CD\u4F5C");
+      }
+      if (!Number.isSafeInteger(value.expiresAt) || value.expiresAt < Date.now()) {
+        throw calendarValidationError("continuation_expired", "continuation \u5DF2\u8FC7\u671F");
+      }
+      return value;
+    }
+  };
+}
+
+// src/shortcuts/calendar/host.ts
+function inferProfile(ctx) {
+  const options = ctx.getGlobalOptions();
+  return options.profile || getActiveProfile();
+}
+function isBusinessSuccess(value) {
+  if (!value || typeof value !== "object") return false;
+  const datajson = value.datajson;
+  if (datajson && typeof datajson === "object") {
+    return datajson.status === true;
+  }
+  if (value.resultCode !== void 0 && value.resultCode !== null) {
+    return Number(value.resultCode) === 200;
+  }
+  if ("data" in value) return true;
+  return false;
+}
+function businessMessage(value) {
+  if (!value || typeof value !== "object") return "\u6CDB\u5FAE\u63A5\u53E3\u8FD4\u56DE\u4E1A\u52A1\u5931\u8D25";
+  const candidates = [value.resultMsg, value.msg, value.message, value.datajson?.message];
+  for (const item of candidates) {
+    if (typeof item === "string" && item.trim()) return item;
+  }
+  return "\u6CDB\u5FAE\u63A5\u53E3\u8FD4\u56DE\u4E1A\u52A1\u5931\u8D25";
+}
+function assertPath(requestPath) {
+  if (typeof requestPath !== "string" || !requestPath.startsWith("/") || requestPath.startsWith("//")) {
+    throw calendarValidationError("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 calendarValidationError("path_invalid", "\u8BF7\u6C42\u8DEF\u5F84\u4E0D\u5141\u8BB8\u8DE8\u57DF\u6216\u8DEF\u5F84\u9003\u9038");
+  }
+  if (!requestPath.startsWith("/api/")) {
+    throw calendarValidationError("path_not_allowed", "\u65E5\u7A0B\u6A21\u5757\u53EA\u80FD\u8C03\u7528 /api/ \u8DEF\u5F84");
+  }
+}
+function omitEmptyQueryValues(query) {
+  if (!query) return void 0;
+  return Object.fromEntries(Object.entries(query).filter(([, value]) => value !== "" && value !== void 0 && value !== null));
+}
+function mapRuntimeNetworkError(error) {
+  if (error instanceof E10ApiError && error.type === "network") {
+    throw calendarNetworkError(error.subtype, error.message, {
+      retryable: error.retryable,
+      details: error.details
+    });
+  }
+  throw error;
+}
+function createCalendarHost(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: inferProfile(ctx),
+        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(), {
+      interceptors: dependencies.interceptors,
+      fetch: dependencies.fetch
+    });
+  }
+  async function request(request2) {
+    const { method, path, query, body, operation, timeoutMs = 3e4 } = request2;
+    assertPath(path);
+    const resolvedMethod = method || "POST";
+    let response;
+    try {
+      response = await (await runtime()).requestJson({
+        module: "calendar",
+        operation,
+        method: resolvedMethod,
+        path,
+        query: omitEmptyQueryValues(query),
+        body,
+        headers: { "X-Requested-With": "XMLHttpRequest" },
+        timeoutMs
+      });
+    } catch (error) {
+      mapRuntimeNetworkError(error);
+    }
+    if (response.status === 401 || response.status === 302) {
+      throw calendarAuthError("session_expired", E10_SESSION_EXPIRED_MESSAGE, { httpStatus: response.status });
+    }
+    if (response.parseError) {
+      if (response.status < 200 || response.status >= 300) {
+        throw new CalendarCliError("api", "http_error", `\u6CDB\u5FAE\u63A5\u53E3 HTTP ${response.status}`, {
+          code: response.status,
+          details: { status: response.status },
+          exitCode: 1
+        });
+      }
+      throw calendarNetworkError("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 CalendarCliError("api", "http_error", `\u6CDB\u5FAE\u63A5\u53E3 HTTP ${response.status}`, {
+        code: response.status,
+        details: { status: response.status, message: businessMessage(response.value) },
+        exitCode: 1
+      });
+    }
+    if (response.status === 404) {
+      throw new CalendarCliError("api", "app_not_installed", "\u63A5\u53E3\u8FD4\u56DE 404\uFF0C\u5F53\u524D\u73AF\u5883\u53EF\u80FD\u672A\u5B89\u88C5\u300C\u65E5\u7A0B\u300D\u5E94\u7528\uFF0C\u8BF7\u5148\u5B89\u88C5/\u90E8\u7F72\u5E94\u7528\u540E\u518D\u8BD5", {
+        code: response.status,
+        exitCode: 1
+      });
+    }
+    if (!isBusinessSuccess(response.value)) {
+      throw new CalendarCliError("api", "business_error", businessMessage(response.value), {
+        details: { message: businessMessage(response.value) },
+        exitCode: 1
+      });
+    }
+    return response.value;
+  }
+  return { request, getSession };
+}
+
+// src/shortcuts/calendar/operations/types.ts
+function calendarSuccess(action, data, meta) {
+  const payload = { ok: true, action, data };
+  if (meta && Object.keys(meta).length > 0) payload.meta = meta;
+  return payload;
+}
+function schemaOf(properties, options = {}) {
+  return {
+    type: "object",
+    additionalProperties: false,
+    properties,
+    ...options.required?.length ? { required: options.required } : {},
+    ...options.description ? { description: options.description } : {}
+  };
+}
+var SCHEMA_ID = { oneOf: [{ type: "integer" }, { type: "string", pattern: "^\\d+$" }] };
+var SCHEMA_DATETIME_MINUTE = { type: "string", pattern: "^\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}$" };
+var SCHEMA_DATE = { type: "string", pattern: "^\\d{4}-\\d{2}-\\d{2}$" };
+var SCHEMA_SWITCH = { type: "integer", enum: [0, 1] };
+
+// src/shortcuts/calendar/operations/read.ts
+var LIST_UNIQUE_INDENT = "E49255BD213B480CB13DFB8E1B4159ED";
+var AGENDA_APP_TAG = "weaver-calendar-eb";
+var AGENDA_FORM_TAG = "uf_agn_agenda";
+var MIN_APP_VERSION = "4.1.4";
+async function buildDatajson(host, mainTable, extra = {}) {
+  const session = await host.getSession();
+  const datajson = {
+    mainTable,
+    header: { operator: session.userId },
+    ...extra
+  };
+  return { datajson };
+}
+function pageInfo(args) {
+  const pageNo = args.pageNo !== void 0 ? String(args.pageNo) : void 0;
+  const pageSize = args.pageSize !== void 0 ? String(args.pageSize) : void 0;
+  if (pageNo === void 0 && pageSize === void 0) return void 0;
+  return {
+    pageNo: pageNo ?? "1",
+    pageSize: pageSize ?? "10"
+  };
+}
+var calendarList = {
+  name: "calendar.list",
+  resource: "calendar",
+  method: "list",
+  action: "calendar.list",
+  summary: "\u5206\u9875\u67E5\u8BE2\u65E5\u7A0B\u5217\u8868\uFF0C\u652F\u6301\u6309\u65F6\u95F4\u8303\u56F4\u548C\u5173\u952E\u5B57\u7B5B\u9009\uFF1B\u4E5F\u7528\u4E8E\u66F4\u65B0/\u5220\u9664\u524D\u6309\u540D\u79F0\u83B7\u53D6\u65E5\u7A0B ID",
+  capability: "calendar",
+  risk: "read",
+  inputSchema: schemaOf({
+    start_time: { type: "string", pattern: "^\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}$", description: "\u5F00\u59CB\u65F6\u95F4\u7B5B\u9009\uFF08yyyy-MM-dd HH:mm\uFF09" },
+    end_time: { type: "string", pattern: "^\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}$", description: "\u7ED3\u675F\u65F6\u95F4\u7B5B\u9009\uFF08yyyy-MM-dd HH:mm\uFF09" },
+    keywork: { type: "string", description: "\u5173\u952E\u5B57\u68C0\u7D22\uFF08\u6309\u65E5\u7A0B\u540D\u79F0\u6A21\u7CCA\u5339\u914D\uFF0C\u5B57\u6BB5\u540D\u62FC\u5199\u4E3A keywork\uFF09" },
+    page_no: { type: "integer", minimum: 1, default: 1, description: "\u9875\u7801" },
+    page_size: { type: "integer", minimum: 1, maximum: 100, default: 10, description: "\u6BCF\u9875\u6761\u6570" }
+  }),
+  handler: async (args, { host }) => {
+    const mainTable = {};
+    if (args.start_time !== void 0) mainTable.start_time = args.start_time;
+    if (args.end_time !== void 0) mainTable.end_time = args.end_time;
+    if (args.keywork !== void 0) mainTable.keywork = args.keywork;
+    if (args.page_no !== void 0) mainTable.page_no = args.page_no;
+    if (args.page_size !== void 0) mainTable.page_size = args.page_size;
+    const response = await host.request({
+      method: "POST",
+      path: "/api/esb/server/event/triggerActionFlow",
+      operation: "calendar.list",
+      body: {
+        customParams: { mainTable },
+        moduleSource: "",
+        uniqueIndent: LIST_UNIQUE_INDENT
+      }
+    });
+    return calendarSuccess("calendar.list", response);
+  }
+};
+var calendarGet = {
+  name: "calendar.get",
+  resource: "calendar",
+  method: "get",
+  action: "calendar.get",
+  summary: "\u6309\u65E5\u7A0B\u6570\u636E ID \u67E5\u8BE2\u5355\u6761\u65E5\u7A0B\u5B8C\u6574\u4FE1\u606F\uFF1B\u4E5F\u4F5C\u4E3A\u66F4\u65B0\u3001\u5220\u9664\u524D\u7684\u8F85\u52A9\u67E5\u8BE2",
+  capability: "calendar",
+  risk: "read",
+  inputSchema: schemaOf({ id: SCHEMA_ID }, { required: ["id"] }),
+  handler: async (args, { host }) => {
+    const id = String(args.id);
+    const body = await buildDatajson(host, { id });
+    const response = await host.request({
+      method: "POST",
+      path: "/api/ebuilder/form/formdata/v2/getFormDataByPk/queryAgenda",
+      operation: "calendar.get",
+      body
+    });
+    return calendarSuccess("calendar.get", response);
+  }
+};
+var calendarCount = {
+  name: "calendar.count",
+  resource: "calendar",
+  method: "count",
+  action: "calendar.count",
+  summary: "\u67E5\u8BE2\u65E5\u7A0B\u6570\u636E\u603B\u6570\u91CF",
+  capability: "calendar",
+  risk: "read",
+  inputSchema: schemaOf({}),
+  handler: async (_args, { host }) => {
+    const body = await buildDatajson(host, {});
+    const response = await host.request({
+      method: "POST",
+      path: "/api/ebuilder/form/formdata/v2/getFormDataCount/queryAgendaCount",
+      operation: "calendar.count",
+      body
+    });
+    return calendarSuccess("calendar.count", response);
+  }
+};
+function dictOperation(name, method, summary, path, filterField) {
+  return {
+    name,
+    resource: "calendar",
+    method,
+    action: name,
+    summary,
+    capability: "calendar",
+    risk: "read",
+    inputSchema: schemaOf({
+      ...filterField ? { [filterField]: { type: "string", description: "\u6309\u540D\u79F0\u7B5B\u9009\uFF1B\u4E0D\u4F20\u5219\u67E5\u8BE2\u5168\u90E8\uFF08\u6CE8\u610F\u4E0D\u53EF\u4F20\u7A7A\u5B57\u7B26\u4E32\uFF09" } } : {},
+      pageNo: { type: "integer", minimum: 1, default: 1 },
+      pageSize: { type: "integer", minimum: 1, maximum: 100, default: 10 }
+    }),
+    handler: async (args, { host }) => {
+      const mainTable = {};
+      if (filterField && args[filterField] !== void 0) {
+        mainTable[filterField] = args[filterField];
+      }
+      const page = pageInfo(args);
+      const body = await buildDatajson(host, mainTable, page ? { pageInfo: page } : {});
+      const response = await host.request({
+        method: "POST",
+        path,
+        operation: name,
+        body
+      });
+      return calendarSuccess(name, response);
+    }
+  };
+}
+var calendarPriorityList = dictOperation(
+  "calendar.priority.list",
+  "priority.list",
+  "\u67E5\u8BE2\u65E5\u7A0B\u7D27\u6025\u7A0B\u5EA6\u9009\u9879\u5217\u8868\uFF08priority \u5B57\u6BB5\u53EF\u9009\u503C\uFF09",
+  "/api/ebuilder/form/formdata/v2/getFormDataList/queryAgendaPriority",
+  "priority_name"
+);
+var calendarTypeList = dictOperation(
+  "calendar.type.list",
+  "type.list",
+  "\u67E5\u8BE2\u65E5\u7A0B\u7C7B\u578B\u9009\u9879\u5217\u8868\uFF08agn_type \u5B57\u6BB5\u53EF\u9009\u503C\uFF09",
+  "/api/ebuilder/form/formdata/v2/getFormDataList/queryAgendaType",
+  "type_name"
+);
+function compareVersion(a, b) {
+  const pa = a.split(".").map((part) => Number(part) || 0);
+  const pb = b.split(".").map((part) => Number(part) || 0);
+  const length = Math.max(pa.length, pb.length);
+  for (let i = 0; i < length; i++) {
+    const x = pa[i] ?? 0;
+    const y = pb[i] ?? 0;
+    if (x !== y) return x > y ? 1 : -1;
+  }
+  return 0;
+}
+function firstId(value) {
+  if (Array.isArray(value) && value.length > 0) {
+    const first = value[0];
+    if (typeof first === "string" || typeof first === "number") return String(first);
+    if (first && typeof first === "object") {
+      const record = first;
+      const id = record.id ?? record.appId ?? record.app_id;
+      if (id !== void 0 && id !== null && id !== "") return String(id);
+    }
+  }
+  if (typeof value === "string" || typeof value === "number") return String(value);
+  return void 0;
+}
+var calendarAppCheck = {
+  name: "calendar.app.check",
+  resource: "calendar",
+  method: "app.check",
+  action: "calendar.app.check",
+  summary: "\u68C0\u6D4B\u300C\u65E5\u7A0B\u300D\u5E94\u7528\u662F\u5426\u5B89\u88C5\u53CA\u7248\u672C\uFF08\u8981\u6C42 >= 4.1.4\uFF09\uFF0C\u5E76\u8FD4\u56DE\u65E5\u7A0B\u8868\u5355 ID\uFF08\u7528\u4E8E\u8BE6\u60C5\u5361\u7247\u9875\u94FE\u63A5\uFF09",
+  capability: "calendar",
+  risk: "read",
+  inputSchema: schemaOf({}),
+  handler: async (_args, { host }) => {
+    const appIdsResponse = await host.request({
+      method: "GET",
+      path: "/api/bs/ebuilder/app/tags/getAppIds",
+      operation: "calendar.app.check",
+      query: { tag: AGENDA_APP_TAG }
+    }).catch(() => void 0);
+    const appId = firstId(appIdsResponse?.data);
+    if (!appId) {
+      return calendarSuccess("calendar.app.check", {
+        installed: false,
+        reason: "app_not_found",
+        message: "\u672A\u68C0\u6D4B\u5230\u300C\u65E5\u7A0B\u300D\u5E94\u7528\uFF08getAppIds \u672A\u8FD4\u56DE appId\uFF09\uFF0C\u8BF7\u5148\u5B89\u88C5\u5E94\u7528"
+      });
+    }
+    const versionResponse = await host.request({
+      method: "GET",
+      path: "/api/installer/public/querySpAppVersionInfo",
+      operation: "calendar.app.check",
+      query: { appId }
+    }).catch(() => void 0);
+    const commitVersion = versionResponse?.data?.commitVersion ?? versionResponse?.commitVersion;
+    let formId;
+    for (let attempt = 0; attempt < 3 && !formId; attempt++) {
+      const formResponse = await host.request({
+        method: "GET",
+        path: "/api/ebuilder/form/obj/getObjsByTag",
+        operation: "calendar.app.check",
+        query: { tag: AGENDA_FORM_TAG, appId }
+      }).catch(() => void 0);
+      formId = firstId(formResponse?.data);
+      if (!formId && attempt < 2) {
+        await new Promise((resolve2) => setTimeout(resolve2, 800));
+      }
+    }
+    const hasVersion = typeof commitVersion === "string" && commitVersion.trim() !== "";
+    const installed = hasVersion && commitVersion !== null && commitVersion !== void 0;
+    const versionOk = installed && compareVersion(commitVersion, MIN_APP_VERSION) >= 0;
+    return calendarSuccess("calendar.app.check", {
+      installed,
+      appId,
+      commitVersion: installed ? commitVersion : null,
+      versionOk,
+      minRequiredVersion: MIN_APP_VERSION,
+      formId: formId ?? null,
+      status: !installed ? "NOT_INSTALLED" : versionOk ? "OK" : "VERSION_TOO_LOW"
+    });
+  }
+};
+var calendarReadOperations = [
+  calendarList,
+  calendarGet,
+  calendarCount,
+  calendarPriorityList,
+  calendarTypeList,
+  calendarAppCheck
+];
+
+// src/shortcuts/calendar/operations/write.ts
+import { createHash } from "node:crypto";
+
+// src/shortcuts/calendar/operations/shared.ts
+var FORBIDDEN_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function asObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw calendarValidationError("input_not_object", "\u8F93\u5165\u5FC5\u987B\u662F JSON \u5BF9\u8C61");
+  }
+  return value;
+}
+function assertNoForbiddenKeys(input) {
+  for (const key of Object.keys(input)) {
+    if (FORBIDDEN_KEYS.has(key)) {
+      throw calendarValidationError("forbidden_key", `\u8F93\u5165\u5305\u542B\u975E\u6CD5\u5B57\u6BB5\uFF1A${key}`);
+    }
+  }
+}
+function assertDateTimeMinute(value, field) {
+  if (typeof value !== "string" || !/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}$/.test(value)) {
+    throw calendarValidationError("datetime_invalid", `${field} \u5FC5\u987B\u662F yyyy-MM-dd HH:mm \u683C\u5F0F`);
+  }
+  return value;
+}
+function pickDefined(value, keys) {
+  const result = {};
+  for (const key of keys) {
+    if (value[key] !== void 0) result[key] = value[key];
+  }
+  return result;
+}
+function optionId(value) {
+  if (Array.isArray(value) && value.length > 0 && typeof value[0] === "object" && value[0] !== null) {
+    const id = value[0].id;
+    if (id !== void 0 && id !== null && id !== "") return String(id);
+    return void 0;
+  }
+  if (typeof value === "string" && value) return value;
+  if (typeof value === "number") return String(value);
+  return void 0;
+}
+function participantIds(value) {
+  if (typeof value === "string" && value) return value;
+  if (Array.isArray(value)) return value.map((item) => String(item)).join(",");
+  return void 0;
+}
+function defaultEndTime(startTime) {
+  const match = /^(\d{4}-\d{2}-\d{2}) (\d{2}):(\d{2})$/.exec(startTime);
+  if (!match) return startTime;
+  const [, date, hour, minute] = match;
+  let nextHour = Number(hour) + 1;
+  let nextDay = date;
+  if (nextHour >= 24) {
+    nextHour -= 24;
+    const [y, m, d] = date.split("-").map(Number);
+    const tomorrow = new Date(Date.UTC(y, m - 1, d + 1));
+    nextDay = `${tomorrow.getUTCFullYear()}-${String(tomorrow.getUTCMonth() + 1).padStart(2, "0")}-${String(tomorrow.getUTCDate()).padStart(2, "0")}`;
+  }
+  return `${nextDay} ${String(nextHour).padStart(2, "0")}:${minute}`;
+}
+
+// src/shortcuts/calendar/operations/write.ts
+var CONTINUATION_TTL_SECONDS = 600;
+var OPTIONAL_FIELDS = [
+  "next_start_remind",
+  "next_end_remind",
+  "all_day",
+  "agn_desc",
+  "location",
+  "place",
+  "part_receipt",
+  "remind",
+  "start_reminder",
+  "remind_type",
+  "start_hours",
+  "start_mins",
+  "end_reminder",
+  "end_hours",
+  "end_mins",
+  "repeat_type",
+  "repeat_custom_type",
+  "repeat_custom_cycle",
+  "repeat_week_unit",
+  "repeat_month_unit",
+  "repeat_end_date",
+  "repeat_end_type",
+  "repeat_end_num",
+  "repeat_desc"
+];
+var MAIN_TABLE_SCHEMA = {
+  agn_name: { type: "string", minLength: 1, description: "\u65E5\u7A0B\u540D\u79F0" },
+  start_time: SCHEMA_DATETIME_MINUTE,
+  end_time: SCHEMA_DATETIME_MINUTE,
+  participants: { type: "string", description: "\u53C2\u4E0E\u4EBA\u4EBA\u5458 ID\uFF08\u591A\u4E2A\u9017\u53F7\u5206\u9694\uFF09\uFF1B\u7F3A\u7701\u65F6\u81EA\u52A8\u5E26\u5F53\u524D\u64CD\u4F5C\u4EBA" },
+  agn_type: { type: "string", description: "\u65E5\u7A0B\u7C7B\u578B\u9009\u9879 ID\uFF08\u5148\u901A\u8FC7 calendar.type.list \u83B7\u53D6\uFF09" },
+  priority: { type: "string", description: "\u7D27\u6025\u7A0B\u5EA6\u9009\u9879 ID\uFF08\u5148\u901A\u8FC7 calendar.priority.list \u83B7\u53D6\uFF09" },
+  next_start_remind: { type: "string", description: "\u4E0B\u6B21\u63D0\u9192\u65F6\u95F4\uFF08\u5F00\u59CB\u524D\uFF09yyyy-MM-dd HH:mm:ss" },
+  next_end_remind: { type: "string", description: "\u4E0B\u6B21\u63D0\u9192\u65F6\u95F4\uFF08\u7ED3\u675F\u524D\uFF09yyyy-MM-dd HH:mm:ss" },
+  all_day: SCHEMA_SWITCH,
+  agn_desc: { type: "string", description: "\u65E5\u7A0B\u8BE6\u60C5" },
+  location: { type: "string", description: "\u4F4D\u7F6E" },
+  place: { type: "string", description: "\u5730\u70B9" },
+  part_receipt: SCHEMA_SWITCH,
+  remind: SCHEMA_SWITCH,
+  start_reminder: { type: "string", enum: ["NOW", "M5", "M15", "H1", "D1", "CUSTOM"], description: "\u5F00\u59CB\u524D\u63D0\u9192" },
+  remind_type: { type: "string", enum: ["system", "message", "email"], description: "\u63D0\u9192\u65B9\u5F0F" },
+  start_hours: { type: "integer", description: "\u63D0\u524D\u5C0F\u65F6\uFF08start_reminder=CUSTOM \u65F6\uFF09" },
+  start_mins: { type: "integer", description: "\u63D0\u524D\u5206\u949F\uFF08start_reminder=CUSTOM \u65F6\uFF09" },
+  end_reminder: { type: "string", enum: ["NOW", "M5", "M15", "H1", "D1", "CUSTOM"], description: "\u7ED3\u675F\u524D\u63D0\u9192" },
+  end_hours: { type: "integer", description: "\u7ED3\u675F\u5C0F\u65F6\uFF08end_reminder=CUSTOM \u65F6\uFF09" },
+  end_mins: { type: "integer", description: "\u7ED3\u675F\u5206\u949F\uFF08end_reminder=CUSTOM \u65F6\uFF09" },
+  repeat_type: { type: "string", enum: ["NONE", "D1", "W1", "W2", "M1", "CUSTOM"], description: "\u91CD\u590D\u7C7B\u578B" },
+  repeat_custom_type: { type: "string", enum: ["D", "W", "M"], description: "\u91CD\u590D\u9891\u7387\uFF08repeat_type=CUSTOM \u65F6\uFF09" },
+  repeat_custom_cycle: { type: "integer", description: "\u91CD\u590D\u95F4\u9694" },
+  repeat_week_unit: { type: "string", enum: ["MO", "TU", "WE", "TH", "FR", "SA", "SU"], description: "\u6BCF\u5468\u7684" },
+  repeat_month_unit: { type: "string", description: "\u6BCF\u6708\u7684\uFF081~31\uFF09" },
+  repeat_end_date: SCHEMA_DATE,
+  repeat_end_type: { type: "string", enum: ["0", "1", "2"], description: "\u7ED3\u675F\u7C7B\u578B\uFF1A0 \u6307\u5B9A\u65F6\u95F4 / 1 \u6307\u5B9A\u6B21\u6570 / 2 \u6C38\u4E0D\u7ED3\u675F" },
+  repeat_end_num: { type: "integer", description: "\u6B21\u6570\uFF08repeat_end_type=1 \u65F6\uFF09" },
+  repeat_desc: { type: "string", description: "\u91CD\u590D\u89C4\u5219\u63CF\u8FF0" }
+};
+function fingerprint(value) {
+  return createHash("sha256").update(JSON.stringify(value ?? null)).digest("hex").slice(0, 32);
+}
+function requireConfirm(args, action) {
+  if (args.confirm !== true) {
+    throw calendarConfirmationError(action, { hint: "\u91CD\u65B0\u8C03\u7528\u65F6\u4F20\u5165 confirm=true \u4E0E prepare \u8FD4\u56DE\u7684 continuation" });
+  }
+}
+async function verifyLease(args, action, env) {
+  const lease = await env.continuation.verify(args.continuation, action);
+  const session = await env.host.getSession();
+  if (lease.baseUrl !== session.baseUrl || lease.profile !== session.profile || lease.userId !== session.userId) {
+    throw calendarValidationError("context_mismatch", "\u786E\u8BA4\u4E0A\u4E0B\u6587\u5DF2\u53D8\u5316\uFF08\u79DF\u6237\u6216\u767B\u5F55\u8D26\u53F7\u4E0D\u540C\uFF09\uFF0C\u8BF7\u91CD\u65B0\u6267\u884C prepare");
+  }
+  return lease;
+}
+function isNetworkError(error) {
+  return error instanceof CalendarCliError && error.type === "network";
+}
+async function buildWriteDatajson(host, mainTableList) {
+  const session = await host.getSession();
+  return {
+    datajson: {
+      operationinfo: { printCost: false },
+      datas: mainTableList.map((mainTable) => ({ mainTable })),
+      header: { operator: session.userId }
+    }
+  };
+}
+async function normalizeMainTable(args, host) {
+  const session = await host.getSession();
+  const agnName = args.agn_name;
+  if (typeof agnName !== "string" || !agnName.trim()) {
+    throw calendarValidationError("agn_name_required", "agn_name\uFF08\u65E5\u7A0B\u540D\u79F0\uFF09\u5FC5\u586B");
+  }
+  const startTime = assertDateTimeMinute(args.start_time, "start_time");
+  const endTime = args.end_time !== void 0 ? assertDateTimeMinute(args.end_time, "end_time") : defaultEndTime(startTime);
+  const participants = args.participants !== void 0 && args.participants !== "" ? args.participants : session.userId;
+  const mainTable = {
+    agn_name: agnName.trim(),
+    start_time: startTime,
+    end_time: endTime,
+    participants,
+    ...pickDefined(args, [...OPTIONAL_FIELDS])
+  };
+  if (args.agn_type !== void 0) mainTable.agn_type = args.agn_type;
+  if (args.priority !== void 0) mainTable.priority = args.priority;
+  return mainTable;
+}
+var calendarCreatePrepare = {
+  name: "calendar.create.prepare",
+  resource: "calendar",
+  method: "create.prepare",
+  action: "calendar.create.prepare",
+  summary: "\u51C6\u5907\u521B\u5EFA\u65E5\u7A0B\uFF1A\u6821\u9A8C\u5B57\u6BB5\u3001\u8865\u9ED8\u8BA4\u503C\uFF08\u53C2\u4E0E\u4EBA\u9ED8\u8BA4\u5F53\u524D\u4EBA\u3001\u65F6\u957F\u9ED8\u8BA4 1 \u5C0F\u65F6\uFF09\u5E76\u751F\u6210\u786E\u8BA4\u9884\u89C8\uFF0C\u4E0D\u5199\u5165",
+  capability: "calendar",
+  risk: "high-risk-write",
+  requiresConfirmation: true,
+  inputSchema: schemaOf({ ...MAIN_TABLE_SCHEMA }, { required: ["agn_name", "start_time"] }),
+  handler: async (args, { host, continuation }) => {
+    if (args.agn_type === void 0) {
+      throw calendarValidationError("agn_type_required", "agn_type\uFF08\u65E5\u7A0B\u7C7B\u578B\uFF09\u5FC5\u586B\uFF0C\u8BF7\u5148\u901A\u8FC7 calendar.type.list \u83B7\u53D6\u9009\u9879 ID");
+    }
+    if (args.priority === void 0) {
+      throw calendarValidationError("priority_required", "priority\uFF08\u7D27\u6025\u7A0B\u5EA6\uFF09\u5FC5\u586B\uFF0C\u8BF7\u5148\u901A\u8FC7 calendar.priority.list \u83B7\u53D6\u9009\u9879 ID");
+    }
+    const mainTable = await normalizeMainTable(args, host);
+    const session = await host.getSession();
+    const preview = { ...mainTable };
+    const token = await continuation.issue(
+      {
+        operation: "calendar.create.apply",
+        baseUrl: session.baseUrl,
+        profile: session.profile,
+        userId: session.userId,
+        payload: mainTable,
+        fingerprint: fingerprint(mainTable)
+      },
+      CONTINUATION_TTL_SECONDS * 1e3
+    );
+    return calendarSuccess("calendar.create.prepare", {
+      status: "AWAITING_CONFIRMATION",
+      preview,
+      continuation: token,
+      expiresInSeconds: CONTINUATION_TTL_SECONDS
+    });
+  }
+};
+var calendarCreateApply = {
+  name: "calendar.create.apply",
+  resource: "calendar",
+  method: "create.apply",
+  action: "calendar.create.apply",
+  summary: "\u63D0\u4EA4\u521B\u5EFA\u65E5\u7A0B\uFF1B\u5FC5\u987B\u5728\u7528\u6237\u660E\u786E\u786E\u8BA4\u540E\u8C03\u7528\uFF0C\u4E14\u8981\u6C42 prepare \u8FD4\u56DE\u7684 continuation",
+  capability: "calendar",
+  risk: "high-risk-write",
+  requiresConfirmation: true,
+  inputSchema: schemaOf(
+    { ...MAIN_TABLE_SCHEMA, confirm: { const: true }, continuation: { type: "string", minLength: 1 } },
+    { required: ["agn_name", "start_time", "confirm", "continuation"] }
+  ),
+  handler: async (args, env) => {
+    requireConfirm(args, "calendar.create.apply");
+    const lease = await verifyLease(args, "calendar.create.apply", env);
+    const mainTable = await normalizeMainTable(args, env.host);
+    if (lease.fingerprint !== fingerprint(mainTable)) {
+      throw calendarValidationError("target_changed", "\u65E5\u7A0B\u5185\u5BB9\u4E0E prepare \u65F6\u7684\u5FEB\u7167\u4E0D\u4E00\u81F4\uFF0C\u8BF7\u91CD\u65B0\u6267\u884C prepare");
+    }
+    const body = await buildWriteDatajson(env.host, [mainTable]);
+    let response;
+    try {
+      response = await env.host.request({
+        method: "POST",
+        path: "/api/ebuilder/form/formdata/v2/saveFormData/createAgenda",
+        operation: "calendar.create.apply",
+        body
+      });
+    } catch (error) {
+      if (isNetworkError(error)) {
+        throw calendarPartialError(
+          "\u521B\u5EFA\u8BF7\u6C42\u53D1\u9001\u540E\u8FDE\u63A5\u4E2D\u65AD\uFF0C\u662F\u5426\u5DF2\u521B\u5EFA\u4E0D\u786E\u5B9A\uFF0C\u7981\u6B62\u81EA\u52A8\u91CD\u8BD5\uFF0C\u8BF7\u901A\u8FC7 calendar.list \u590D\u6838",
+          { attempted: { agn_name: mainTable.agn_name } },
+          { stage: "create" }
+        );
+      }
+      throw error;
+    }
+    return calendarSuccess("calendar.create.apply", {
+      status: "COMPLETE",
+      result: response
+    });
+  }
+};
+async function fetchCurrentMainTable(id, host) {
+  const session = await host.getSession();
+  const response = await host.request({
+    method: "POST",
+    path: "/api/ebuilder/form/formdata/v2/getFormDataByPk/queryAgenda",
+    operation: "calendar.update.prepare",
+    body: {
+      datajson: {
+        mainTable: { id },
+        header: { operator: session.userId }
+      }
+    }
+  });
+  const datas = response?.datajson?.datas;
+  const mainTable = Array.isArray(datas) && datas[0]?.mainTable ? datas[0].mainTable : void 0;
+  if (!mainTable) {
+    throw calendarValidationError("not_found", `\u65E5\u7A0B ${id} \u4E0D\u5B58\u5728\u6216\u65E0\u6743\u67E5\u770B\uFF0C\u65E0\u6CD5\u66F4\u65B0`);
+  }
+  return mainTable;
+}
+function mainTableToUpdateFields(mainTable) {
+  const result = { id: mainTable.id };
+  const scalarKeys = [
+    "agn_name",
+    "start_time",
+    "end_time",
+    "agn_desc",
+    "place",
+    "location",
+    "next_start_remind",
+    "next_end_remind",
+    "all_day",
+    "part_receipt",
+    "remind",
+    "start_hours",
+    "start_mins",
+    "end_hours",
+    "end_mins",
+    "repeat_custom_cycle",
+    "repeat_end_date",
+    "repeat_end_num",
+    "repeat_desc"
+  ];
+  for (const key of scalarKeys) {
+    if (mainTable[key] !== void 0) result[key] = mainTable[key];
+  }
+  const optionKeys = ["agn_type", "priority", "start_reminder", "remind_type", "end_reminder", "repeat_type", "repeat_custom_type", "repeat_week_unit", "repeat_month_unit", "repeat_end_type"];
+  for (const key of optionKeys) {
+    const id = optionId(mainTable[key]);
+    if (id !== void 0) result[key] = id;
+  }
+  const participants = participantIds(mainTable.participants);
+  if (participants !== void 0) result.participants = participants;
+  return result;
+}
+var calendarUpdatePrepare = {
+  name: "calendar.update.prepare",
+  resource: "calendar",
+  method: "update.prepare",
+  action: "calendar.update.prepare",
+  summary: "\u51C6\u5907\u66F4\u65B0\u65E5\u7A0B\uFF08\u5168\u91CF\u8986\u76D6\uFF09\uFF1A\u5148\u67E5\u5F53\u524D\u8BE6\u60C5\uFF0C\u5408\u5E76\u7528\u6237\u4FEE\u6539\u5E76\u751F\u6210\u786E\u8BA4\u9884\u89C8\uFF0C\u4E0D\u5199\u5165",
+  capability: "calendar",
+  risk: "high-risk-write",
+  requiresConfirmation: true,
+  inputSchema: schemaOf({
+    id: SCHEMA_ID,
+    ...MAIN_TABLE_SCHEMA
+  }, { required: ["id"] }),
+  handler: async (args, { host, continuation }) => {
+    const id = String(args.id);
+    const current = await fetchCurrentMainTable(id, host);
+    const base = mainTableToUpdateFields(current);
+    const overrides = {};
+    for (const key of ["agn_name", "start_time", "end_time", "participants", "agn_type", "priority", ...OPTIONAL_FIELDS]) {
+      if (args[key] !== void 0) overrides[key] = args[key];
+    }
+    if (overrides.start_time !== void 0 && overrides.end_time === void 0) {
+      overrides.end_time = defaultEndTime(String(overrides.start_time));
+    }
+    const merged = { ...base, ...overrides };
+    const session = await host.getSession();
+    const token = await continuation.issue(
+      {
+        operation: "calendar.update.apply",
+        baseUrl: session.baseUrl,
+        profile: session.profile,
+        userId: session.userId,
+        payload: merged,
+        fingerprint: fingerprint(merged)
+      },
+      CONTINUATION_TTL_SECONDS * 1e3
+    );
+    return calendarSuccess("calendar.update.prepare", {
+      status: "AWAITING_CONFIRMATION",
+      preview: {
+        before: base,
+        after: merged,
+        changedFields: Object.keys(overrides)
+      },
+      continuation: token,
+      expiresInSeconds: CONTINUATION_TTL_SECONDS
+    });
+  }
+};
+var calendarUpdateApply = {
+  name: "calendar.update.apply",
+  resource: "calendar",
+  method: "update.apply",
+  action: "calendar.update.apply",
+  summary: "\u63D0\u4EA4\u66F4\u65B0\u65E5\u7A0B\uFF1B\u5FC5\u987B\u5728\u7528\u6237\u660E\u786E\u786E\u8BA4\u540E\u8C03\u7528\uFF0C\u4E14\u8981\u6C42 prepare \u8FD4\u56DE\u7684 continuation",
+  capability: "calendar",
+  risk: "high-risk-write",
+  requiresConfirmation: true,
+  inputSchema: schemaOf({
+    id: SCHEMA_ID,
+    ...MAIN_TABLE_SCHEMA,
+    confirm: { const: true },
+    continuation: { type: "string", minLength: 1 }
+  }, { required: ["id", "confirm", "continuation"] }),
+  handler: async (args, env) => {
+    requireConfirm(args, "calendar.update.apply");
+    const lease = await verifyLease(args, "calendar.update.apply", env);
+    const id = String(args.id);
+    const payload = lease.payload || {};
+    if (String(payload.id ?? "") !== id) {
+      throw calendarValidationError("target_changed", "\u65E5\u7A0B ID \u4E0E prepare \u65F6\u7684\u5FEB\u7167\u4E0D\u4E00\u81F4\uFF0C\u8BF7\u91CD\u65B0\u6267\u884C prepare");
+    }
+    const body = await buildWriteDatajson(env.host, [payload]);
+    let response;
+    try {
+      response = await env.host.request({
+        method: "POST",
+        path: "/api/ebuilder/form/formdata/v2/updateFormData/updateAgenda",
+        operation: "calendar.update.apply",
+        body
+      });
+    } catch (error) {
+      if (isNetworkError(error)) {
+        throw calendarPartialError(
+          "\u66F4\u65B0\u8BF7\u6C42\u53D1\u9001\u540E\u8FDE\u63A5\u4E2D\u65AD\uFF0C\u662F\u5426\u5DF2\u66F4\u65B0\u4E0D\u786E\u5B9A\uFF0C\u7981\u6B62\u81EA\u52A8\u91CD\u8BD5\uFF0C\u8BF7\u901A\u8FC7 calendar.get \u590D\u6838",
+          { attempted: { id } },
+          { stage: "update" }
+        );
+      }
+      throw error;
+    }
+    return calendarSuccess("calendar.update.apply", {
+      status: "COMPLETE",
+      result: response
+    });
+  }
+};
+var calendarDeletePrepare = {
+  name: "calendar.delete.prepare",
+  resource: "calendar",
+  method: "delete.prepare",
+  action: "calendar.delete.prepare",
+  summary: "\u51C6\u5907\u5220\u9664\u65E5\u7A0B\uFF1A\u67E5\u5F53\u524D\u8BE6\u60C5\u5E76\u751F\u6210\u786E\u8BA4\u9884\u89C8\uFF0C\u4E0D\u5220\u9664",
+  capability: "calendar",
+  risk: "high-risk-write",
+  requiresConfirmation: true,
+  inputSchema: schemaOf({ id: SCHEMA_ID }, { required: ["id"] }),
+  handler: async (args, { host, continuation }) => {
+    const id = String(args.id);
+    const current = await fetchCurrentMainTable(id, host);
+    const session = await host.getSession();
+    const preview = {
+      id,
+      agn_name: current.agn_name,
+      start_time: current.start_time,
+      end_time: current.end_time
+    };
+    const token = await continuation.issue(
+      {
+        operation: "calendar.delete.apply",
+        baseUrl: session.baseUrl,
+        profile: session.profile,
+        userId: session.userId,
+        payload: { id },
+        fingerprint: fingerprint({ id })
+      },
+      CONTINUATION_TTL_SECONDS * 1e3
+    );
+    return calendarSuccess("calendar.delete.prepare", {
+      status: "AWAITING_CONFIRMATION",
+      preview,
+      continuation: token,
+      expiresInSeconds: CONTINUATION_TTL_SECONDS
+    });
+  }
+};
+var calendarDeleteApply = {
+  name: "calendar.delete.apply",
+  resource: "calendar",
+  method: "delete.apply",
+  action: "calendar.delete.apply",
+  summary: "\u63D0\u4EA4\u5220\u9664\u65E5\u7A0B\uFF1B\u4E0D\u53EF\u9006\uFF0C\u5FC5\u987B\u5728\u7528\u6237\u660E\u786E\u786E\u8BA4\u540E\u8C03\u7528",
+  capability: "calendar",
+  risk: "high-risk-write",
+  requiresConfirmation: true,
+  inputSchema: schemaOf({
+    id: SCHEMA_ID,
+    confirm: { const: true },
+    continuation: { type: "string", minLength: 1 }
+  }, { required: ["id", "confirm", "continuation"] }),
+  handler: async (args, env) => {
+    requireConfirm(args, "calendar.delete.apply");
+    const lease = await verifyLease(args, "calendar.delete.apply", env);
+    const id = String(args.id);
+    if (lease.fingerprint !== fingerprint({ id })) {
+      throw calendarValidationError("target_changed", "\u65E5\u7A0B ID \u4E0E prepare \u65F6\u7684\u5FEB\u7167\u4E0D\u4E00\u81F4\uFF0C\u8BF7\u91CD\u65B0\u6267\u884C prepare");
+    }
+    const body = await buildWriteDatajson(env.host, [{ id }]);
+    let response;
+    try {
+      response = await env.host.request({
+        method: "POST",
+        path: "/api/ebuilder/form/formdata/v2/deleteFormData/deleteAgenda",
+        operation: "calendar.delete.apply",
+        body
+      });
+    } catch (error) {
+      if (isNetworkError(error)) {
+        throw calendarPartialError(
+          "\u5220\u9664\u8BF7\u6C42\u53D1\u9001\u540E\u8FDE\u63A5\u4E2D\u65AD\uFF0C\u662F\u5426\u5DF2\u5220\u9664\u4E0D\u786E\u5B9A\uFF0C\u7981\u6B62\u81EA\u52A8\u91CD\u8BD5\uFF0C\u8BF7\u901A\u8FC7 calendar.get \u590D\u6838",
+          { attempted: { id } },
+          { stage: "delete" }
+        );
+      }
+      throw error;
+    }
+    return calendarSuccess("calendar.delete.apply", {
+      status: "COMPLETE",
+      result: response
+    });
+  }
+};
+var calendarWriteOperations = [
+  calendarCreatePrepare,
+  calendarCreateApply,
+  calendarUpdatePrepare,
+  calendarUpdateApply,
+  calendarDeletePrepare,
+  calendarDeleteApply
+];
+
+// src/shortcuts/calendar/operations/registry.ts
+function buildRegistry() {
+  const registry = /* @__PURE__ */ new Map();
+  const definitions = [
+    ...calendarReadOperations,
+    ...calendarWriteOperations
+  ];
+  for (const definition of definitions) {
+    if (registry.has(definition.name)) {
+      throw new Error(`duplicate calendar operation: ${definition.name}`);
+    }
+    registry.set(definition.name, definition);
+  }
+  return registry;
+}
+var calendarOperationRegistry = buildRegistry();
+function calendarOperationDefinitions() {
+  return [...calendarOperationRegistry.values()];
+}
+function getCalendarOperation(operation) {
+  const definition = calendarOperationRegistry.get(operation);
+  if (!definition) {
+    throw calendarValidationError("operation_unknown", `\u65E5\u7A0B\u6A21\u5757\u4E0D\u652F\u6301\u64CD\u4F5C\uFF1A${operation}`);
+  }
+  return definition;
+}
+
+// src/shortcuts/calendar/manifest.ts
+var WITHHELD = [];
+function buildOperations() {
+  return calendarOperationDefinitions().map((definition) => ({
+    name: definition.name,
+    resource: definition.resource,
+    summary: definition.summary,
+    ...definition.capability ? { capability: definition.capability } : {},
+    risk: definition.risk,
+    ...definition.requiresConfirmation ? { requiresConfirmation: true } : {},
+    inputSchema: definition.inputSchema
+  }));
+}
+var calendarManifest = {
+  schemaVersion: 1,
+  name: "calendar",
+  title: "\u6CDB\u5FAEE10\u65E5\u7A0B\u7BA1\u7406\uFF08\u521B\u5EFA/\u67E5\u8BE2/\u66F4\u65B0/\u5220\u9664/\u5B57\u5178\uFF09",
+  version: "0.1.0",
+  host: "e10-calendar",
+  status: "builtin",
+  sourceSkill: "weaver-e10-calendar",
+  capabilities: ["calendar"],
+  operations: buildOperations(),
+  withheldOperations: WITHHELD
+};
+
+// src/shortcuts/calendar/operations.ts
+async function executeCalendarOperation(operation, rawInput, context) {
+  const definition = getCalendarOperation(operation);
+  const input = asObject(rawInput);
+  assertNoForbiddenKeys(input);
+  return definition.handler(input, context);
+}
+
+// src/shortcuts/calendar/index.ts
+function asOptions(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+function stripBom(value) {
+  return value.replace(/^\uFEFF+/, "");
+}
+async function inputFrom(options, extra = {}) {
+  const opts = asOptions(options);
+  let input = {};
+  if (opts.input && opts.inputJson) {
+    throw calendarValidationError("input_conflict", "\u4E0D\u80FD\u540C\u65F6\u4F20 --input \u548C --input-json");
+  }
+  if (opts.inputJson) {
+    input = parseJsonInput(String(opts.inputJson), "--input-json");
+  }
+  if (opts.input) {
+    let raw;
+    try {
+      raw = stripBom(opts.input === "-" ? await readStdin() : await readFile2(String(opts.input), "utf8"));
+    } catch {
+      throw calendarValidationError("input_unreadable", `\u65E0\u6CD5\u8BFB\u53D6 --input\uFF1A${String(opts.input)}`);
+    }
+    input = parseJsonInput(raw, "--input");
+  }
+  return {
+    ...input,
+    ...Object.fromEntries(Object.entries(extra).filter(([, value]) => value !== void 0 && value !== ""))
+  };
+}
+function parseJsonInput(raw, label) {
+  try {
+    const parsed = JSON.parse(stripBom(raw));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error("input must be an object");
+    }
+    return parsed;
+  } catch {
+    throw calendarValidationError("input_invalid", `${label} \u4E0D\u662F\u5408\u6CD5 JSON \u5BF9\u8C61`);
+  }
+}
+function successEnvelope(operation, result) {
+  return {
+    schemaVersion: 1,
+    ok: true,
+    operation,
+    data: result.data === void 0 ? null : result.data,
+    ...result.meta ? { meta: result.meta } : {},
+    warnings: []
+  };
+}
+function failureEnvelope(error) {
+  const structured = error;
+  return {
+    schemaVersion: 1,
+    ok: false,
+    ...structured?.partialData === void 0 ? {} : { data: structured.partialData },
+    error: toErrorEnvelope(error)
+  };
+}
+async function executeAndPrint(ctx, operation, input) {
+  try {
+    const result = await executeCalendarOperation(operation, input, {
+      ctx,
+      host: createCalendarHost(ctx),
+      continuation: createCalendarContinuationSigner(ctx)
+    });
+    ctx.output.write(successEnvelope(operation, result), { json: true });
+  } catch (error) {
+    console.error(JSON.stringify(failureEnvelope(error), null, 2));
+    process.exitCode = isCliError(error) ? error.exitCode : 1 /* GeneralError */;
+  }
+}
+var calendarShortcut = {
+  name: "calendar",
+  description: "\u6CDB\u5FAEE10\u65E5\u7A0B\u7BA1\u7406 CLI\uFF08\u521B\u5EFA/\u67E5\u8BE2/\u66F4\u65B0/\u5220\u9664/\u5B57\u5178\uFF09",
+  category: "shortcut",
+  register({ program, action }) {
+    const calendar = program.command("calendar").description("\u6CDB\u5FAEE10\u65E5\u7A0B\u7BA1\u7406\uFF08\u521B\u5EFA/\u67E5\u8BE2\u5217\u8868/\u8BE6\u60C5/\u603B\u6570/\u66F4\u65B0/\u5220\u9664/\u7C7B\u578B/\u7D27\u6025\u7A0B\u5EA6\uFF09");
+    calendar.command("schema").description("Print calendar operation manifest for agents").action(action((ctx) => {
+      ctx.output.write(calendarManifest, { json: true });
+    }));
+    calendar.command("run").description("Run a calendar operation with JSON input").argument("<operation>", "operation name, e.g. calendar.list").option("--input <path>", "JSON input file, or - for stdin").option("--input-json <json>", "inline JSON input object").action(action(async (ctx, operation, options) => {
+      await executeAndPrint(ctx, String(operation), await inputFrom(options));
+    }));
+    calendar.command("get").description("\u67E5\u8BE2\u5355\u6761\u65E5\u7A0B\u8BE6\u60C5\uFF08calendar.get \u8584\u5305\u88C5\uFF09").option("--input <path>", "JSON input file, or - for stdin").option("--input-json <json>", "inline JSON input object").option("--id <id>", "\u65E5\u7A0B\u6570\u636E ID").action(action(async (ctx, options) => {
+      const opts = asOptions(options);
+      await executeAndPrint(ctx, "calendar.get", await inputFrom(options, { id: opts.id }));
+    }));
+    calendar.command("count").description("\u67E5\u8BE2\u65E5\u7A0B\u603B\u6570\uFF08calendar.count \u8584\u5305\u88C5\uFF09").action(action(async (ctx) => {
+      await executeAndPrint(ctx, "calendar.count", {});
+    }));
+  }
+};
+export {
+  calendarShortcut,
+  inputFrom,
+  successEnvelope
+};