weaver-work-cli 0.1.29 → 0.1.32

package/dist/chunks/project-G6XV66DZ.js

@@ -0,0 +1,1361 @@
+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/project/index.ts
+import { readFile as readFile2 } from "node:fs/promises";
+
+// src/shortcuts/project/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/project/errors.ts
+var ProjectCliError = class extends CliError {
+  type;
+  subtype;
+  code;
+  retryable;
+  stage;
+  details;
+  partialData;
+  constructor(type, subtype, message, options = {}) {
+    super(message, options.exitCode ?? 5 /* InternalError */);
+    this.name = "ProjectCliError";
+    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 projectValidationError(subtype, message, details) {
+  return new ProjectCliError("validation", subtype, message, {
+    details,
+    exitCode: 2 /* UsageError */
+  });
+}
+function projectAuthError(subtype, message, details) {
+  return new ProjectCliError("authentication", subtype, message, {
+    details,
+    exitCode: 3 /* AuthError */
+  });
+}
+function projectNetworkError(subtype, message, options = {}) {
+  return new ProjectCliError("network", subtype, message, {
+    ...options,
+    retryable: options.retryable ?? true,
+    exitCode: 4 /* NetworkError */
+  });
+}
+function projectApiError(subtype, message, details) {
+  return new ProjectCliError("api", subtype, message, {
+    details,
+    exitCode: 1 /* GeneralError */
+  });
+}
+function projectPartialError(message, partialData, details) {
+  return new ProjectCliError("partial", "write_uncertain", message, {
+    details,
+    partialData,
+    exitCode: 11 /* Partial */
+  });
+}
+
+// src/shortcuts/project/continuation.ts
+function projectStateRoot(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(projectStateRoot(ctx), "keys");
+  const filename = resolve(keysDir, "project-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 createProjectContinuationSigner(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 projectValidationError("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 projectValidationError("continuation_invalid", "continuation \u7B7E\u540D\u6821\u9A8C\u5931\u8D25");
+      let value;
+      try {
+        value = JSON.parse(Buffer.from(body, "base64url").toString("utf8"));
+      } catch {
+        throw projectValidationError("continuation_invalid", "continuation \u5185\u5BB9\u65E0\u6CD5\u89E3\u6790");
+      }
+      if (value.operation !== expectedOperation) {
+        throw projectValidationError("continuation_mismatch", "continuation \u4E0D\u5C5E\u4E8E\u5F53\u524D\u64CD\u4F5C");
+      }
+      if (!Number.isSafeInteger(value.expiresAt) || value.expiresAt < Date.now()) {
+        throw projectValidationError("continuation_expired", "continuation \u5DF2\u8FC7\u671F");
+      }
+      return value;
+    }
+  };
+}
+
+// src/shortcuts/project/host.ts
+var PROJECT_PATH_PREFIXES = [
+  "/api/ebuilder/form/formdata/v2/",
+  "/api/ebuilder/form/dataset/v2/",
+  "/api/ebuilder/common/ds/",
+  "/api/ebproject/backendConsole/",
+  "/api/bs/ebuilder/app/tags/",
+  "/api/hrm/common/browser/",
+  "/api/installer/public/"
+];
+function inferProfile(ctx) {
+  const options = ctx.getGlobalOptions();
+  return options.profile || getActiveProfile();
+}
+function businessMessage(value) {
+  if (!value || typeof value !== "object") return "\u6CDB\u5FAE\u63A5\u53E3\u8FD4\u56DE\u4E1A\u52A1\u5931\u8D25";
+  const candidates = [
+    value.msg,
+    value.message,
+    value.resultMsg,
+    value.datajson?.message,
+    value.datajson?.msg,
+    value.data?.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 isDatajsonSuccess(value) {
+  const status = value?.datajson?.status;
+  return status === true || status === "true";
+}
+function isWeaverSuccess(value) {
+  if (!value || typeof value !== "object") return false;
+  return Number(value.code) === 200 && value.fail !== true && value.status !== false && value.status !== "false";
+}
+function assertDatajsonSuccess(value, operation) {
+  if (!isDatajsonSuccess(value)) {
+    throw projectApiError("business_failed", businessMessage(value), { operation, response: value });
+  }
+}
+function assertWeaverSuccess(value, operation) {
+  if (!isWeaverSuccess(value)) {
+    throw projectApiError("business_failed", businessMessage(value), { operation, response: value });
+  }
+}
+function assertPath(requestPath) {
+  if (typeof requestPath !== "string" || !requestPath.startsWith("/") || requestPath.startsWith("//")) {
+    throw projectValidationError("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 projectValidationError("path_invalid", "\u8BF7\u6C42\u8DEF\u5F84\u4E0D\u5141\u8BB8\u8DE8\u57DF\u6216\u8DEF\u5F84\u9003\u9038");
+  }
+  if (!PROJECT_PATH_PREFIXES.some((prefix) => requestPath.startsWith(prefix))) {
+    throw projectValidationError("path_not_allowed", "\u4E8B\u4E95\u7136\u9879\u76EE\u6A21\u5757\u53EA\u80FD\u8C03\u7528\u6E90\u8D44\u6599\u5141\u8BB8\u7684 /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 projectNetworkError(error.subtype, error.message, {
+      retryable: error.retryable,
+      details: error.details
+    });
+  }
+  throw error;
+}
+function createProjectHost(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, formData, operation, timeoutMs = 3e4 } = request2;
+    assertPath(path);
+    let effectiveBody = body;
+    let effectiveFormData;
+    if (formData) {
+      effectiveFormData = new FormData();
+      for (const [key, value] of Object.entries(formData)) {
+        if (value !== void 0) effectiveFormData.append(key, String(value));
+      }
+    }
+    let response;
+    try {
+      response = await (await runtime()).requestJson({
+        module: "project",
+        operation,
+        method: (method || "POST").toUpperCase(),
+        path,
+        query: omitEmptyQueryValues(query),
+        body: effectiveBody,
+        formData: effectiveFormData,
+        headers: { "X-Requested-With": "XMLHttpRequest" },
+        timeoutMs
+      });
+    } catch (error) {
+      mapRuntimeNetworkError(error);
+    }
+    if (response.status === 401 || response.status === 302) {
+      throw projectAuthError("session_expired", E10_SESSION_EXPIRED_MESSAGE, {
+        httpStatus: response.status
+      });
+    }
+    if (response.parseError) {
+      throw projectNetworkError("protocol", `\u63A5\u53E3\u8FD4\u56DE\u4E0D\u662F\u5408\u6CD5 JSON\uFF08HTTP ${response.status}\uFF09`, { retryable: false });
+    }
+    if (response.status === 404) {
+      throw new ProjectCliError("api", "endpoint_not_found", `\u63A5\u53E3\u8FD4\u56DE 404\uFF0C\u5F53\u524D\u73AF\u5883\u53EF\u80FD\u672A\u5B89\u88C5\u4E8B\u4E95\u7136\u9879\u76EE\u5E94\u7528\u6216\u63A5\u53E3\u4E0D\u5B58\u5728\uFF08${path}\uFF09`, {
+        code: response.status,
+        details: { path },
+        exitCode: 1
+      });
+    }
+    if (response.status < 200 || response.status >= 300) {
+      throw new ProjectCliError("api", "http_error", `\u6CDB\u5FAE\u63A5\u53E3 HTTP ${response.status}`, {
+        code: response.status,
+        details: { status: response.status, message: businessMessage(response.value) },
+        exitCode: 1
+      });
+    }
+    return response.value;
+  }
+  return { request, getSession };
+}
+
+// src/shortcuts/project/operations/types.ts
+function projectSuccess(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.oneOf?.length ? { oneOf: options.oneOf } : {},
+    ...options.anyOf?.length ? { anyOf: options.anyOf } : {},
+    ...options.description ? { description: options.description } : {}
+  };
+}
+var SCHEMA_ID_STRING = { type: "string", minLength: 1, pattern: "^\\d+$" };
+var SCHEMA_PAGE_NO = { type: "integer", minimum: 1, default: 1 };
+var SCHEMA_PAGE_SIZE = { type: "integer", minimum: 1, maximum: 1e3, default: 10 };
+var SCHEMA_FILTERS = {
+  type: "object",
+  additionalProperties: true,
+  description: "\u6E90\u63A5\u53E3 mainTable \u8FC7\u6EE4\u5B57\u6BB5\u3002\u4EC5\u4F20\u7528\u6237\u660E\u786E\u6307\u5B9A\u7684\u5B57\u6BB5\uFF1B\u7A7A\u5B57\u7B26\u4E32\u4F1A\u88AB\u89C6\u4E3A\u672A\u6307\u5B9A\u3002"
+};
+var SCHEMA_FIELDS = {
+  type: "object",
+  additionalProperties: true,
+  description: "\u6E90\u63A5\u53E3 mainTable \u5B57\u6BB5\u3002\u5B57\u6BB5\u540D\u548C\u53D6\u503C\u5FC5\u987B\u5148\u6309\u6A21\u5757 reference \u5B8C\u6210\u540D\u79F0\u5230 ID \u7684\u89E3\u6790\u3002"
+};
+var SCHEMA_RECORDS = {
+  type: "array",
+  minItems: 1,
+  maxItems: 100,
+  items: SCHEMA_FIELDS,
+  description: "\u5F85\u5199\u5165\u8BB0\u5F55\uFF0C\u6700\u591A 100 \u6761\uFF0C\u603B\u5927\u5C0F\u4E0D\u5F97\u8D85\u8FC7 10M\u3002"
+};
+var SCHEMA_CONFIRM = { const: true, description: "\u5FC5\u987B\u4E3A true\uFF0C\u8868\u793A\u7528\u6237\u5DF2\u660E\u786E\u786E\u8BA4\u672C\u6B21\u5199\u5165\u3002" };
+var SCHEMA_CONTINUATION = { type: "string", minLength: 1, description: "prepare \u8FD4\u56DE\u7684 continuation\uFF0C\u5FC5\u987B\u539F\u6837\u4F20\u5165\u3002" };
+
+// src/shortcuts/project/operations/shared.ts
+function asObject(value, field = "input") {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw projectValidationError("field_invalid", `${field} \u5FC5\u987B\u662F JSON \u5BF9\u8C61`);
+  }
+  return value;
+}
+function assertNoForbiddenKeys(input) {
+  for (const key of Object.keys(input)) {
+    if (!/^[A-Za-z][A-Za-z0-9_]*$/.test(key)) {
+      throw projectValidationError("field_invalid", `\u4E0D\u5141\u8BB8\u7684\u5B57\u6BB5\u540D\uFF1A${key}`);
+    }
+  }
+}
+function idString(value, field) {
+  if (value === void 0 || value === null || value === "") {
+    throw projectValidationError("field_required", `${field} \u4E0D\u80FD\u4E3A\u7A7A`);
+  }
+  const text = String(value);
+  if (!/^\d+$/.test(text)) throw projectValidationError("field_invalid", `${field} \u5FC5\u987B\u662F\u6570\u5B57 ID \u5B57\u7B26\u4E32`);
+  return text;
+}
+function positiveInt(value, field, fallback, maximum = 1e3) {
+  if (value === void 0 || value === null || value === "") return fallback;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 1 || parsed > maximum) {
+    throw projectValidationError("field_invalid", `${field} \u5FC5\u987B\u662F 1-${maximum} \u7684\u6574\u6570`);
+  }
+  return parsed;
+}
+function compactFilters(value) {
+  if (!value) return {};
+  return Object.fromEntries(
+    Object.entries(value).filter(([, item]) => item !== void 0 && item !== null && item !== "")
+  );
+}
+function queryText(value, field) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  if (typeof value !== "string") throw projectValidationError("field_invalid", `${field} \u5FC5\u987B\u662F\u5B57\u7B26\u4E32`);
+  return value;
+}
+async function operatorId(host) {
+  const session = await host.getSession();
+  if (!session.userId) throw projectValidationError("operator_missing", "\u5F53\u524D\u767B\u5F55\u4F1A\u8BDD\u7F3A\u5C11 operator\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55");
+  return session.userId;
+}
+function stableFingerprint(value) {
+  const text = JSON.stringify(value, (_key, item) => {
+    if (item && typeof item === "object" && !Array.isArray(item)) {
+      return Object.fromEntries(Object.entries(item).sort(([a], [b]) => a.localeCompare(b)));
+    }
+    return item;
+  });
+  let hash = 0;
+  for (let index = 0; index < text.length; index += 1) {
+    hash = hash * 31 + text.charCodeAt(index) >>> 0;
+  }
+  return `${text.length}:${hash.toString(16)}`;
+}
+
+// src/shortcuts/project/operations/read.ts
+var APP_TAG = "weaver-project-eb";
+var DEFAULT_OBJ_IDS = { task: "1020270486210527232", project: "1020275562853482532" };
+var MIN_VERSION = [20, 6, 11];
+function buildCardUrl(baseUrl, objId, dataId) {
+  if (!baseUrl || !objId || !dataId || /[\s/\\?#]/u.test(dataId)) return null;
+  return `${baseUrl.replace(/\/+$/u, "")}/sp/ebdfpage/card/0/${objId}/${dataId}`;
+}
+var CURRENT_USER_FILTERS = /* @__PURE__ */ new Set([
+  "manager",
+  "participant",
+  "participants",
+  "tester",
+  "customer_manager",
+  "acceptance_manager"
+]);
+var SCHEMA_OUTPUT_FIELDS = {
+  type: "array",
+  minItems: 1,
+  maxItems: 50,
+  uniqueItems: true,
+  items: { type: "string", minLength: 1, maxLength: 100, pattern: "^[A-Za-z][A-Za-z0-9_]*" },
+  description: "\u53EF\u9009\uFF1B\u53EA\u4FDD\u7559\u6307\u5B9A mainTable \u5B57\u6BB5\u3002id \u548C\u8BB0\u5F55\u540D\u79F0\u5B57\u6BB5\u59CB\u7EC8\u4FDD\u7559\uFF1Bfields \u4E0D\u542B detail_url \u65F6\u4E0D\u4F1A\u89E3\u6790\u8BE6\u60C5\u94FE\u63A5\u3002"
+};
+async function resolveCurrentUserFilters(filters, host) {
+  for (const [key, value] of Object.entries(filters)) {
+    if (value === "@me" && CURRENT_USER_FILTERS.has(key)) {
+      filters[key] = await operatorId(host);
+    }
+  }
+}
+function outputFields(value) {
+  if (value === void 0) return null;
+  if (!Array.isArray(value) || value.length === 0) {
+    throw projectValidationError("field_invalid", "fields \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32\u6570\u7EC4");
+  }
+  const fields = [];
+  for (const item of value) {
+    if (typeof item !== "string" || !/^[A-Za-z]/.test(item) || /[^A-Za-z0-9_]/.test(item)) {
+      throw projectValidationError("field_invalid", "fields \u5305\u542B\u975E\u6CD5\u5B57\u6BB5\u540D");
+    }
+    fields.push(item);
+  }
+  return [...new Set(fields)];
+}
+function compactDatajson(datajson, fields, requiredFields) {
+  if (!fields) return datajson;
+  const keep = /* @__PURE__ */ new Set([...fields, "id", "detail_url", ...requiredFields]);
+  const value = datajson;
+  const rows = Array.isArray(value?.datas) ? value.datas : [];
+  for (const row of rows) {
+    const mainTable = row?.mainTable;
+    if (!mainTable || typeof mainTable !== "object" || Array.isArray(mainTable)) continue;
+    row.mainTable = Object.fromEntries(
+      Object.entries(mainTable).filter(([key]) => keep.has(key))
+    );
+  }
+  return datajson;
+}
+function normalizeFieldNames(value, inputName) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value) || value.length === 0) {
+    throw projectValidationError("field_invalid", `${inputName} \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32\u6570\u7EC4`);
+  }
+  const names = [];
+  for (const item of value) {
+    if (typeof item !== "string" || item.trim() === "" || item.length > 100) {
+      throw projectValidationError("field_invalid", `${inputName} \u5305\u542B\u975E\u6CD5\u5B57\u6BB5\u540D`);
+    }
+    names.push(item);
+  }
+  return [...new Set(names)];
+}
+function filterFormFieldResponse(response, fieldNames, fieldKeyword) {
+  if (fieldNames.length === 0 && !fieldKeyword) return response;
+  if (!response || typeof response !== "object") return response;
+  const groups = response?.data?.data;
+  if (!Array.isArray(groups)) return response;
+  const keyword = fieldKeyword?.toLowerCase() ?? null;
+  const nextGroups = groups.map((group) => {
+    if (!group || typeof group !== "object" || !Array.isArray(group.fields)) return group;
+    return {
+      ...group,
+      fields: group.fields.filter((field) => {
+        if (!field || typeof field !== "object") return false;
+        const name = typeof field.name === "string" ? field.name : "";
+        const text = typeof field.text === "string" ? field.text : "";
+        if (fieldNames.length > 0) return fieldNames.includes(name);
+        return keyword ? name.toLowerCase().includes(keyword) || text.toLowerCase().includes(keyword) : true;
+      })
+    };
+  });
+  return { ...response, data: { ...response.data, data: nextGroups } };
+}
+function operationTable(name) {
+  return name === "project.project.list" || name === "project.project.detail" ? "project" : "task";
+}
+async function decorateDetailUrls(host, operation, datajson) {
+  const value = datajson;
+  const rows = Array.isArray(value?.datas) ? value.datas : [];
+  const targets = rows.map((row) => row?.mainTable).filter((row) => row?.id !== void 0 && row?.id !== null);
+  if (targets.length === 0) return datajson;
+  try {
+    const objId = await getObject(host, operationTable(operation));
+    const session = await host.getSession();
+    for (const row of targets) {
+      const url = buildCardUrl(session.baseUrl, objId, String(row.id));
+      if (url) row.detail_url = url;
+    }
+  } catch (error) {
+    if (value && typeof value === "object") {
+      value.detail_url_warning = `\u8BE6\u60C5\u94FE\u63A5\u6682\u4E0D\u53EF\u7528\uFF1A${error instanceof Error ? error.message : String(error)}\uFF1B\u4E3B\u67E5\u8BE2\u5DF2\u6210\u529F\uFF0C\u4E0D\u8981\u56E0\u6B64\u91CD\u8BD5\u3002`;
+    }
+  }
+  return datajson;
+}
+function table(value) {
+  if (value !== "task" && value !== "project") {
+    throw projectValidationError("field_invalid", "table \u5FC5\u987B\u662F task \u6216 project");
+  }
+  return value;
+}
+function versionAtLeast(version) {
+  const parts = version.split(".").map((item) => Number(item) || 0);
+  for (let index = 0; index < Math.max(parts.length, MIN_VERSION.length); index += 1) {
+    const left = parts[index] ?? 0;
+    const right = MIN_VERSION[index] ?? 0;
+    if (left > right) return true;
+    if (left < right) return false;
+  }
+  return true;
+}
+async function getAppId(host) {
+  const response = await host.request({
+    method: "GET",
+    path: "/api/bs/ebuilder/app/tags/getAppIds",
+    query: { tag: APP_TAG },
+    operation: "project.app.ids"
+  });
+  assertWeaverSuccess(response, "project.app.ids");
+  const data = response?.data;
+  const appId = Array.isArray(data) && data.length > 0 ? String(data[0]) : "";
+  if (!appId) throw new Error("\u5F53\u524D\u73AF\u5883\u672A\u5B89\u88C5\u4E8B\u4E95\u7136\u9879\u76EE\u7BA1\u7406\u5E94\u7528");
+  return appId;
+}
+async function getObject(host, value) {
+  const response = await host.request({
+    method: "GET",
+    path: "/api/ebproject/backendConsole/getCurrentObjId",
+    query: { objId: DEFAULT_OBJ_IDS[value] },
+    operation: "project.object.id"
+  });
+  assertWeaverSuccess(response, "project.object.id");
+  const object = String(response?.data ?? "");
+  if (!object) throw new Error("\u63A5\u53E3\u672A\u8FD4\u56DE\u5F53\u524D\u73AF\u5883\u5BF9\u8C61 ID");
+  return object;
+}
+async function datajsonRequest(host, operation, path, payload, query) {
+  const response = await host.request({
+    method: "POST",
+    path,
+    query,
+    body: { datajson: JSON.stringify(payload) },
+    operation
+  });
+  assertDatajsonSuccess(response, operation);
+  return response;
+}
+function listOperation(name, path, nameField, descField, statusField) {
+  return {
+    name,
+    resource: "project",
+    method: "list",
+    action: name,
+    summary: "\u5206\u9875\u67E5\u8BE2\u9879\u76EE/\u4EFB\u52A1\u5217\u8868\uFF0C\u9ED8\u8BA4\u7B2C 1 \u9875 10 \u6761\uFF0C\u672A\u6307\u5B9A\u72B6\u6001\u65F6\u4EC5\u67E5\u8BE2\u672A\u5F00\u59CB\u548C\u8FDB\u884C\u4E2D",
+    risk: "read",
+    inputSchema: schemaOf({
+      filters: SCHEMA_FILTERS,
+      pageNo: SCHEMA_PAGE_NO,
+      pageSize: SCHEMA_PAGE_SIZE,
+      name: { type: "string", description: `${nameField} \u6A21\u7CCA\u641C\u7D22\uFF0C\u901A\u8FC7 URL Query \u4F20\u9012` },
+      description: { type: "string", description: `${descField} \u6A21\u7CCA\u641C\u7D22\uFF0C\u901A\u8FC7 URL Query \u4F20\u9012` },
+      allStatuses: { type: "boolean", default: false, description: "\u4E3A true \u65F6\u4E0D\u4F20\u7CFB\u7EDF\u72B6\u6001\u548C\u4E1A\u52A1\u72B6\u6001\uFF0C\u67E5\u8BE2\u5168\u90E8\u72B6\u6001\uFF1B\u4E0D\u80FD\u4E0E\u4E1A\u52A1\u72B6\u6001\u540C\u65F6\u4F20" },
+      withDetailUrl: { type: "boolean", default: true, description: "\u662F\u5426\u4E3A\u6BCF\u6761\u8BB0\u5F55\u8865\u5145 detail_url\uFF1B\u4F20 false \u53EF\u8DF3\u8FC7\u94FE\u63A5\u89E3\u6790" },
+      fields: SCHEMA_OUTPUT_FIELDS
+    }),
+    handler: async (args, { host }) => {
+      const pageNo = positiveInt(args.pageNo, "pageNo", 1);
+      const pageSize = positiveInt(args.pageSize, "pageSize", 10);
+      const filters = compactFilters(args.filters);
+      await resolveCurrentUserFilters(filters, host);
+      const allStatuses = args.allStatuses === true;
+      if (allStatuses && (filters.sys_status !== void 0 || filters[statusField] !== void 0)) {
+        throw projectValidationError("field_conflict", "allStatuses \u4E0D\u80FD\u4E0E sys_status \u6216\u4E1A\u52A1\u72B6\u6001\u540C\u65F6\u4F20");
+      }
+      if (allStatuses) {
+        delete filters.sys_status;
+      } else if (filters[statusField] === void 0 && filters.sys_status === void 0) {
+        filters.sys_status = "todo,doing";
+      } else if (filters[statusField] !== void 0) {
+        delete filters.sys_status;
+      }
+      const response = await datajsonRequest(host, name, path, {
+        mainTable: filters,
+        pageInfo: { pageNo, pageSize },
+        header: { operator: await operatorId(host) }
+      }, {
+        [nameField]: queryText(args.name, "name"),
+        [descField]: queryText(args.description, "description")
+      });
+      const fields = outputFields(args.fields);
+      const shouldDecorate = args.withDetailUrl !== false && (!fields || fields.includes("detail_url"));
+      const decorated = shouldDecorate ? await decorateDetailUrls(host, name, response?.datajson ?? null) : response?.datajson ?? null;
+      const datajson = compactDatajson(decorated, fields, [nameField]);
+      return projectSuccess(name, datajson, { pageNo, pageSize });
+    }
+  };
+}
+function detailOperation(name, path, nameField) {
+  return {
+    name,
+    resource: "project",
+    method: "detail",
+    action: name,
+    summary: "\u6309\u4E3B\u952E\u67E5\u8BE2\u5355\u6761\u9879\u76EE/\u4EFB\u52A1\u8BE6\u60C5",
+    risk: "read",
+    inputSchema: schemaOf({
+      id: SCHEMA_ID_STRING,
+      withDetailUrl: { type: "boolean", default: true, description: "\u662F\u5426\u4E3A\u8BB0\u5F55\u8865\u5145 detail_url\uFF1B\u4F20 false \u53EF\u8DF3\u8FC7\u94FE\u63A5\u89E3\u6790" },
+      fields: SCHEMA_OUTPUT_FIELDS
+    }, { required: ["id"] }),
+    handler: async (args, { host }) => {
+      const id = idString(args.id, "id");
+      const response = await datajsonRequest(host, name, path, {
+        mainTable: { id },
+        header: { operator: await operatorId(host) }
+      });
+      const fields = outputFields(args.fields);
+      const shouldDecorate = args.withDetailUrl !== false && (!fields || fields.includes("detail_url"));
+      const decorated = shouldDecorate ? await decorateDetailUrls(host, name, response?.datajson ?? null) : response?.datajson ?? null;
+      const datajson = compactDatajson(decorated, fields, [nameField]);
+      return projectSuccess(name, datajson, { id });
+    }
+  };
+}
+function dictionaryOperation(name, path, summary) {
+  return {
+    name,
+    resource: "project",
+    method: "dictionary",
+    action: name,
+    summary,
+    risk: "read",
+    inputSchema: schemaOf({
+      filters: SCHEMA_FILTERS,
+      pageNo: { ...SCHEMA_PAGE_NO, default: 1 },
+      pageSize: { ...SCHEMA_PAGE_SIZE, default: 100 },
+      fields: SCHEMA_OUTPUT_FIELDS
+    }),
+    handler: async (args, { host }) => {
+      const pageNo = positiveInt(args.pageNo, "pageNo", 1);
+      const pageSize = positiveInt(args.pageSize, "pageSize", 100);
+      const response = await datajsonRequest(host, name, path, {
+        mainTable: compactFilters(args.filters),
+        pageInfo: { pageNo, pageSize },
+        header: { operator: await operatorId(host) }
+      });
+      const datajson = compactDatajson(response?.datajson ?? null, outputFields(args.fields), []);
+      return projectSuccess(name, datajson, { pageNo, pageSize });
+    }
+  };
+}
+function hrmOperation(name, path, kind, summary) {
+  return {
+    name,
+    resource: "project",
+    method: "resolve",
+    action: name,
+    summary,
+    risk: "read",
+    inputSchema: schemaOf({
+      name: { type: "string", minLength: 1 },
+      match: { type: "string", enum: ["exact", "fuzzy"], default: "exact" },
+      ...kind === "employee" ? { status: { type: "string", enum: ["normal", "all"], default: "normal" } } : {}
+    }, { required: ["name"] }),
+    handler: async (args, { host }) => {
+      const body = kind === "employee" ? {
+        browserMultiple: true,
+        authWecahtBook: false,
+        wxDepNeedConvertCount: 0,
+        wxEmpNeedConvertCount: 0,
+        wxTotalNeedConvertCount: 0,
+        cmd: "all",
+        current: 1,
+        pageSize: 30,
+        formDatas: {
+          username: [{ usernameOpt: args.match === "fuzzy" ? "in" : "eq", usernameInput: args.name }],
+          status: [{ statusSelect: args.status === "all" ? [] : ["normal"] }]
+        },
+        quickSearchDatas: {},
+        type: "and",
+        containsNoneAccount: false,
+        containsPartTimeEmployee: false
+      } : {
+        browserMultiple: true,
+        virtualType: "ALL",
+        cmd: "list",
+        current: 1,
+        pageSize: 200,
+        formDatas: {
+          name: [{
+            nameCondition: { id: args.match === "fuzzy" ? "in" : "eq", content: "\u7B49\u4E8E", disabled: false },
+            name: args.name
+          }]
+        },
+        quickSearchDatas: {},
+        type: "and",
+        stopDepartment: false
+      };
+      const response = await host.request({ method: "POST", path, body, operation: name });
+      assertWeaverSuccess(response, name);
+      const data = response?.data;
+      const rows = Array.isArray(data?.data) ? data.data : [];
+      return projectSuccess(name, {
+        total: typeof data?.total === "number" ? data.total : rows.length,
+        rows: rows.map((row) => ({
+          id: row?.id === void 0 || row?.id === null ? null : String(row.id),
+          name: row?.name ?? row?.title ?? null,
+          department: row?.department ?? row?.supDepartment ?? row?.supSubDepartment ?? null,
+          title: row?.title ?? null
+        }))
+      });
+    }
+  };
+}
+var projectReadOperations = [
+  {
+    name: "project.app.ids",
+    resource: "project",
+    method: "metadata",
+    action: "project.app.ids",
+    summary: "\u6309\u56FA\u5B9A\u5E94\u7528\u6807\u7B7E\u83B7\u53D6\u5F53\u524D\u73AF\u5883\u7684\u4E8B\u4E95\u7136\u5E94\u7528 ID",
+    risk: "read",
+    inputSchema: schemaOf({}),
+    handler: async (_args, { host }) => projectSuccess("project.app.ids", {
+      appId: await getAppId(host)
+    })
+  },
+  {
+    name: "project.object.id",
+    resource: "project",
+    method: "metadata",
+    action: "project.object.id",
+    summary: "\u5C06\u4EFB\u52A1/\u9879\u76EE\u51FA\u5382\u951A\u70B9\u8F6C\u6362\u6210\u5F53\u524D\u73AF\u5883\u5BF9\u8C61 ID",
+    risk: "read",
+    inputSchema: schemaOf(
+      { table: { type: "string", enum: ["task", "project"] } },
+      { required: ["table"] }
+    ),
+    handler: async (args, { host }) => {
+      const value = table(args.table);
+      return projectSuccess("project.object.id", { table: value, objId: await getObject(host, value) });
+    }
+  },
+  {
+    name: "project.form.fields",
+    resource: "project",
+    method: "metadata",
+    action: "project.form.fields",
+    summary: "\u83B7\u53D6\u4EFB\u52A1/\u9879\u76EE\u8868\u5355\u5B57\u6BB5\u5B9A\u4E49\uFF1B\u672A\u4F20 groupId/sourceId \u65F6\u81EA\u52A8\u89E3\u6790",
+    risk: "read",
+    inputSchema: schemaOf({
+      table: { type: "string", enum: ["task", "project"] },
+      groupId: { type: "string", description: "\u53EF\u9009\uFF1B\u7F3A\u7701\u65F6\u81EA\u52A8\u8C03\u7528 project.app.ids" },
+      sourceId: { type: "string", description: "\u53EF\u9009\uFF1B\u7F3A\u7701\u65F6\u6309 table \u81EA\u52A8\u89E3\u6790\u5F53\u524D\u73AF\u5883 objId" },
+      detailFieldsGroup: { type: "boolean", default: true },
+      enableMerge: { type: "boolean", default: true },
+      fieldNames: {
+        type: "array",
+        minItems: 1,
+        maxItems: 50,
+        uniqueItems: true,
+        items: { type: "string", minLength: 1, maxLength: 100 },
+        description: "\u53EF\u9009\uFF1B\u53EA\u8FD4\u56DE\u6307\u5B9A name \u7684\u5B57\u6BB5\u5B9A\u4E49\u3002\u4E0E fieldKeyword \u540C\u65F6\u4F20\u65F6 fieldNames \u4F18\u5148\u3002"
+      },
+      fieldKeyword: {
+        type: "string",
+        minLength: 1,
+        maxLength: 100,
+        description: "\u53EF\u9009\uFF1B\u6309\u5B57\u6BB5 name/text \u6A21\u7CCA\u8FC7\u6EE4\u5B57\u6BB5\u5B9A\u4E49\uFF0C\u7528\u4E8E\u628A\u4E2D\u6587\u5B57\u6BB5\u540D\u89E3\u6790\u6210 field name\u3002"
+      }
+    }, { required: ["table"] }),
+    handler: async (args, { host }) => {
+      const value = table(args.table);
+      const groupId = args.groupId ? String(args.groupId) : await getAppId(host);
+      const sourceId = args.sourceId ? String(args.sourceId) : await getObject(host, value);
+      const response = await host.request({
+        method: "POST",
+        path: "/api/ebuilder/common/ds/fields",
+        formData: {
+          groupId,
+          sourceId,
+          sourceType: "FORM",
+          detailFieldsGroup: args.detailFieldsGroup === false ? "false" : "true",
+          enableMerge: args.enableMerge === false ? "false" : "true",
+          customParam: JSON.stringify({ terminal: "" }),
+          params: "[]"
+        },
+        operation: "project.form.fields"
+      });
+      assertWeaverSuccess(response, "project.form.fields");
+      const data = filterFormFieldResponse(
+        response,
+        normalizeFieldNames(args.fieldNames, "fieldNames"),
+        args.fieldKeyword === void 0 || args.fieldKeyword === null || args.fieldKeyword === "" ? null : String(args.fieldKeyword)
+      );
+      return projectSuccess("project.form.fields", data, { table: value, groupId, sourceId });
+    }
+  },
+  {
+    name: "project.form.options",
+    resource: "project",
+    method: "metadata",
+    action: "project.form.options",
+    summary: "\u83B7\u53D6\u9009\u62E9\u7C7B\u5B57\u6BB5\u9009\u9879\uFF1B\u672A\u4F20 groupId/sourceId \u65F6\u81EA\u52A8\u89E3\u6790",
+    risk: "read",
+    inputSchema: schemaOf({
+      table: { type: "string", enum: ["task", "project"] },
+      fieldName: { type: "string", minLength: 1 },
+      groupId: { type: "string" },
+      sourceId: { type: "string" },
+      optionLevel: { type: "integer", minimum: 1, default: 1 }
+    }, { required: ["table", "fieldName"] }),
+    handler: async (args, { host }) => {
+      const value = table(args.table);
+      const groupId = args.groupId ? String(args.groupId) : await getAppId(host);
+      const sourceId = args.sourceId ? String(args.sourceId) : await getObject(host, value);
+      const response = await host.request({
+        method: "GET",
+        path: "/api/ebuilder/common/ds/options",
+        query: {
+          fieldName: args.fieldName,
+          objId: sourceId,
+          sourceType: "FORM",
+          groupId,
+          optionLevel: args.optionLevel ?? 1
+        },
+        operation: "project.form.options"
+      });
+      assertWeaverSuccess(response, "project.form.options");
+      return projectSuccess("project.form.options", response, { table: value, groupId, sourceId });
+    }
+  },
+  {
+    name: "project.form.data.page",
+    resource: "project",
+    method: "metadata",
+    action: "project.form.data.page",
+    summary: "\u5728\u5173\u8054\u8868\u5355\u4E2D\u6309\u6807\u9898\u5B57\u6BB5\u5206\u9875\u67E5\u8BE2\u8BB0\u5F55\uFF0C\u7528\u4E8E Ebuilder \u540D\u79F0\u5230 ID \u89E3\u6790",
+    risk: "read",
+    inputSchema: schemaOf({
+      refObjId: SCHEMA_ID_STRING,
+      fieldKey: { type: "string", minLength: 1 },
+      value: { type: "string", minLength: 1 },
+      pageNo: SCHEMA_PAGE_NO,
+      pageSize: SCHEMA_PAGE_SIZE
+    }, { required: ["refObjId", "fieldKey", "value"] }),
+    handler: async (args, { host }) => {
+      const pageNo = positiveInt(args.pageNo, "pageNo", 1);
+      const pageSize = positiveInt(args.pageSize, "pageSize", 10);
+      const response = await host.request({
+        method: "POST",
+        path: "/api/ebuilder/form/dataset/v2/getAllData",
+        body: {
+          datajson: {
+            header: { objId: idString(args.refObjId, "refObjId") },
+            mainTable: { [String(args.fieldKey)]: args.value },
+            pageInfo: { pageNo, pageSize },
+            operationinfo: { isReturnDetail: "n", fieldNoFindIgnore: "false" }
+          }
+        },
+        operation: "project.form.data.page"
+      });
+      assertDatajsonSuccess(response?.data, "project.form.data.page");
+      return projectSuccess("project.form.data.page", response?.data?.datajson ?? null, { pageNo, pageSize });
+    }
+  },
+  {
+    name: "project.version.check",
+    resource: "project",
+    method: "diagnose",
+    action: "project.version.check",
+    summary: "\u67E5\u8BE2\u4E8B\u4E95\u7136\u5E94\u7528\u7248\u672C\u5E76\u5224\u65AD\u662F\u5426\u6EE1\u8DB3 20.6.11\uFF1B\u4EC5\u7528\u4E8E\u5F02\u5E38\u8BCA\u65AD\u6216\u7528\u6237\u4E3B\u52A8\u8BE2\u95EE",
+    risk: "read",
+    inputSchema: schemaOf({ appId: { type: "string", description: "\u53EF\u9009\uFF1B\u7F3A\u7701\u65F6\u81EA\u52A8\u89E3\u6790" } }),
+    handler: async (args, { host }) => {
+      const appId = args.appId ? String(args.appId) : await getAppId(host);
+      const response = await host.request({
+        method: "GET",
+        path: "/api/installer/public/querySpAppVersionInfo",
+        query: { appId },
+        operation: "project.version.check"
+      });
+      assertWeaverSuccess(response, "project.version.check");
+      const version = String(response?.data?.commitVersion ?? "");
+      if (!version) throw new Error("\u63A5\u53E3\u672A\u8FD4\u56DE\u5E94\u7528\u7248\u672C");
+      return projectSuccess("project.version.check", {
+        appId,
+        version,
+        minimumVersion: MIN_VERSION.join("."),
+        supported: versionAtLeast(version)
+      });
+    }
+  },
+  listOperation(
+    "project.task.list",
+    "/api/ebuilder/form/formdata/v2/getFormDataList/queryTasks",
+    "task_name",
+    "task_desc",
+    "task_status"
+  ),
+  detailOperation("project.task.detail", "/api/ebuilder/form/formdata/v2/getFormDataByPk/queryTaskDetail", "task_name"),
+  listOperation(
+    "project.project.list",
+    "/api/ebuilder/form/formdata/v2/getFormDataList/queryProjects",
+    "proj_name",
+    "proj_desc",
+    "proj_status"
+  ),
+  detailOperation("project.project.detail", "/api/ebuilder/form/formdata/v2/getFormDataByPk/queryProjDetail", "proj_name"),
+  dictionaryOperation("project.dictionary.task-type", "/api/ebuilder/form/formdata/v2/getFormDataList/queryTaskTypes", "\u67E5\u8BE2\u4EFB\u52A1\u7C7B\u578B"),
+  dictionaryOperation("project.dictionary.task-priority", "/api/ebuilder/form/formdata/v2/getFormDataList/queryTaskPriorities", "\u67E5\u8BE2\u4EFB\u52A1\u7D27\u6025\u7A0B\u5EA6"),
+  dictionaryOperation("project.dictionary.task-status", "/api/ebuilder/form/formdata/v2/getFormDataList/queryTaskStatus", "\u67E5\u8BE2\u4EFB\u52A1\u72B6\u6001"),
+  dictionaryOperation("project.dictionary.project-type", "/api/ebuilder/form/formdata/v2/getFormDataList/queryProjTypes", "\u67E5\u8BE2\u9879\u76EE\u7C7B\u578B"),
+  dictionaryOperation("project.dictionary.project-priority", "/api/ebuilder/form/formdata/v2/getFormDataList/queryProjPriorities", "\u67E5\u8BE2\u9879\u76EE\u7D27\u6025\u7A0B\u5EA6"),
+  dictionaryOperation("project.dictionary.project-status", "/api/ebuilder/form/formdata/v2/getFormDataList/queryProjStatus", "\u67E5\u8BE2\u9879\u76EE\u72B6\u6001"),
+  hrmOperation("project.employee.resolve", "/api/hrm/common/browser/data/resource", "employee", "\u6309\u59D3\u540D\u7CBE\u786E\u6216\u6A21\u7CCA\u89E3\u6790\u5458\u5DE5 ID\uFF0C\u9ED8\u8BA4\u4EC5\u67E5\u5728\u804C\u5458\u5DE5"),
+  hrmOperation("project.department.resolve", "/api/hrm/common/browser/data/department", "organization", "\u6309\u540D\u79F0\u7CBE\u786E\u6216\u6A21\u7CCA\u89E3\u6790\u90E8\u95E8 ID"),
+  hrmOperation("project.subcompany.resolve", "/api/hrm/common/browser/data/subcompany", "organization", "\u6309\u540D\u79F0\u7CBE\u786E\u6216\u6A21\u7CCA\u89E3\u6790\u5206\u90E8 ID")
+];
+
+// src/shortcuts/project/operations/write.ts
+var WRITE_TARGETS = {
+  taskCreate: { entity: "task", action: "create", listPath: "", detailPath: "/api/ebuilder/form/formdata/v2/getFormDataByPk/queryTaskDetail", writePath: "/api/ebuilder/form/formdata/v2/saveFormData/createTask" },
+  taskUpdate: { entity: "task", action: "update", listPath: "", detailPath: "/api/ebuilder/form/formdata/v2/getFormDataByPk/queryTaskDetail", writePath: "/api/ebuilder/form/formdata/v2/updateFormData/updateTask" },
+  taskDelete: { entity: "task", action: "delete", listPath: "", detailPath: "/api/ebuilder/form/formdata/v2/getFormDataByPk/queryTaskDetail", writePath: "/api/ebuilder/form/formdata/v2/deleteFormData/deleteTask" },
+  projectCreate: { entity: "project", action: "create", listPath: "", detailPath: "/api/ebuilder/form/formdata/v2/getFormDataByPk/queryProjDetail", writePath: "/api/ebuilder/form/formdata/v2/saveFormData/createProject" },
+  projectUpdate: { entity: "project", action: "update", listPath: "", detailPath: "/api/ebuilder/form/formdata/v2/getFormDataByPk/queryProjDetail", writePath: "/api/ebuilder/form/formdata/v2/updateFormData/updateProject" },
+  projectDelete: { entity: "project", action: "delete", listPath: "", detailPath: "/api/ebuilder/form/formdata/v2/getFormDataByPk/queryProjDetail", writePath: "/api/ebuilder/form/formdata/v2/deleteFormData/deleteProject" }
+};
+function resolveManager(value, operator) {
+  return value === void 0 || value === null || value === "" || value === "@me" ? operator : value;
+}
+function records(value) {
+  if (!Array.isArray(value) || value.length < 1 || value.length > 100) {
+    throw projectValidationError("records_invalid", "records \u5FC5\u987B\u662F 1-100 \u6761\u8BB0\u5F55\u6570\u7EC4");
+  }
+  return value.map((item, index) => {
+    const record = asObject(item, `records[${index}]`);
+    if (Object.keys(record).length === 0) {
+      throw projectValidationError("records_invalid", `records[${index}] \u4E0D\u80FD\u4E3A\u7A7A\u5BF9\u8C61`);
+    }
+    return record;
+  });
+}
+async function detail(host, target, id, operation) {
+  const response = await host.request({
+    method: "POST",
+    path: target.detailPath,
+    body: {
+      datajson: JSON.stringify({
+        mainTable: { id },
+        header: { operator: await operatorId(host) }
+      })
+    },
+    operation
+  });
+  assertDatajsonSuccess(response, operation);
+  return response?.datajson ?? null;
+}
+async function sendWrite(host, operation, path, datajsonObject) {
+  let response;
+  try {
+    response = await host.request({
+      method: "POST",
+      path,
+      body: { datajson: datajsonObject },
+      operation
+    });
+  } catch (error) {
+    if (error?.type === "network") {
+      throw projectPartialError("\u5199\u5165\u8BF7\u6C42\u5DF2\u53D1\u51FA\u4F46\u7ED3\u679C\u4E0D\u786E\u5B9A\uFF0C\u8BF7\u52FF\u81EA\u52A8\u91CD\u8BD5\uFF1B\u5148\u6267\u884C\u53EA\u8BFB\u56DE\u67E5\u786E\u8BA4\u7ED3\u679C", {
+        operation,
+        path
+      }, error.details);
+    }
+    throw error;
+  }
+  assertDatajsonSuccess(response, operation);
+  return response?.datajson ?? null;
+}
+async function verifySession(env, continuation) {
+  if (continuation.userId !== await operatorId(env.host)) {
+    throw projectValidationError("continuation_mismatch", "continuation \u4E0E\u5F53\u524D\u767B\u5F55\u4F1A\u8BDD\u4E0D\u5339\u914D");
+  }
+}
+function createOperations(namePrefix, target) {
+  const prepareName = `${namePrefix}.prepare`;
+  const applyName = `${namePrefix}.apply`;
+  return [
+    {
+      name: prepareName,
+      resource: "project",
+      method: "write.prepare",
+      action: prepareName,
+      summary: `\u9884\u89C8\u5E76\u751F\u6210${target.entity === "task" ? "\u4EFB\u52A1" : "\u9879\u76EE"}\u521B\u5EFA\u5199\u5165 continuation\uFF0C\u4E0D\u53D1\u751F\u5199\u5165`,
+      risk: "read-before-write",
+      inputSchema: schemaOf({ records: SCHEMA_RECORDS }, { required: ["records"] }),
+      handler: async (args, env) => {
+        const operator = await operatorId(env.host);
+        const datajson = {
+          header: { operator },
+          operationinfo: {},
+          datas: records(args.records).map((mainTable) => ({
+            mainTable: { ...mainTable, manager: resolveManager(mainTable.manager, operator) }
+          }))
+        };
+        const continuation = await env.continuation.issue({
+          operation: applyName,
+          userId: datajson.header.operator,
+          datajson
+        });
+        return projectSuccess(prepareName, {
+          continuation,
+          request: { datajson },
+          recordCount: datajson.datas.length
+        }, { requiresConfirmation: true });
+      }
+    },
+    {
+      name: applyName,
+      resource: "project",
+      method: "write.apply",
+      action: applyName,
+      summary: `\u7ECF\u7528\u6237\u786E\u8BA4\u540E\u521B\u5EFA${target.entity === "task" ? "\u4EFB\u52A1" : "\u9879\u76EE"}`,
+      risk: "high-risk-write",
+      requiresConfirmation: true,
+      inputSchema: schemaOf({
+        continuation: SCHEMA_CONTINUATION,
+        confirm: SCHEMA_CONFIRM
+      }, { required: ["continuation", "confirm"] }),
+      handler: async (args, env) => {
+        if (args.confirm !== true) throw projectValidationError("confirm_required", "confirm \u5FC5\u987B\u4E3A true");
+        const continuation = await env.continuation.verify(String(args.continuation), applyName);
+        await verifySession(env, continuation);
+        const datajson = asObject(continuation.datajson, "continuation.datajson");
+        const response = await sendWrite(env.host, applyName, target.writePath, datajson);
+        return projectSuccess(applyName, response, { targetType: target.entity, writeAction: "create" });
+      }
+    }
+  ];
+}
+function updateOperations(namePrefix, target) {
+  const prepareName = `${namePrefix}.prepare`;
+  const applyName = `${namePrefix}.apply`;
+  return [
+    {
+      name: prepareName,
+      resource: "project",
+      method: "write.prepare",
+      action: prepareName,
+      summary: `\u56DE\u67E5\u5E76\u9884\u89C8${target.entity === "task" ? "\u4EFB\u52A1" : "\u9879\u76EE"}\u66F4\u65B0\uFF0C\u751F\u6210 continuation\uFF0C\u4E0D\u53D1\u751F\u5199\u5165`,
+      risk: "read-before-write",
+      inputSchema: schemaOf({ id: SCHEMA_ID_STRING, fields: SCHEMA_FIELDS }, { required: ["id", "fields"] }),
+      handler: async (args, env) => {
+        const id = idString(args.id, "id");
+        const fields = asObject(args.fields, "fields");
+        if (Object.keys(fields).length === 0) {
+          throw projectValidationError("fields_required", "fields \u81F3\u5C11\u5305\u542B\u4E00\u4E2A\u8981\u66F4\u65B0\u7684\u5B57\u6BB5");
+        }
+        const operator = await operatorId(env.host);
+        if (fields.manager === "@me") fields.manager = operator;
+        const current = await detail(env.host, target, id, `${namePrefix}.prepare`);
+        const datajson = {
+          header: { operator },
+          operationinfo: {},
+          datas: [{ mainTable: { id, ...fields } }]
+        };
+        const continuation = await env.continuation.issue({
+          operation: applyName,
+          userId: datajson.header.operator,
+          id,
+          fingerprint: stableFingerprint(current),
+          datajson
+        });
+        return projectSuccess(prepareName, {
+          continuation,
+          request: { datajson },
+          current
+        }, { requiresConfirmation: true, id });
+      }
+    },
+    {
+      name: applyName,
+      resource: "project",
+      method: "write.apply",
+      action: applyName,
+      summary: `\u7ECF\u7528\u6237\u786E\u8BA4\u5E76\u786E\u8BA4\u76EE\u6807\u672A\u53D8\u5316\u540E\u66F4\u65B0${target.entity === "task" ? "\u4EFB\u52A1" : "\u9879\u76EE"}`,
+      risk: "high-risk-write",
+      requiresConfirmation: true,
+      inputSchema: schemaOf({
+        continuation: SCHEMA_CONTINUATION,
+        confirm: SCHEMA_CONFIRM
+      }, { required: ["continuation", "confirm"] }),
+      handler: async (args, env) => {
+        if (args.confirm !== true) throw projectValidationError("confirm_required", "confirm \u5FC5\u987B\u4E3A true");
+        const continuation = await env.continuation.verify(String(args.continuation), applyName);
+        await verifySession(env, continuation);
+        const id = idString(continuation.id, "continuation.id");
+        const current = await detail(env.host, target, id, applyName);
+        if (stableFingerprint(current) !== continuation.fingerprint) {
+          throw projectValidationError("target_changed", "\u76EE\u6807\u6570\u636E\u5728\u786E\u8BA4\u540E\u5DF2\u53D8\u5316\uFF0C\u8BF7\u91CD\u65B0\u6267\u884C prepare");
+        }
+        const datajson = asObject(continuation.datajson, "continuation.datajson");
+        const response = await sendWrite(env.host, applyName, target.writePath, datajson);
+        return projectSuccess(applyName, response, { targetType: target.entity, writeAction: "update", id });
+      }
+    }
+  ];
+}
+function deleteOperations(namePrefix, target) {
+  const prepareName = `${namePrefix}.prepare`;
+  const applyName = `${namePrefix}.apply`;
+  return [
+    {
+      name: prepareName,
+      resource: "project",
+      method: "write.prepare",
+      action: prepareName,
+      summary: `\u56DE\u67E5${target.entity === "task" ? "\u4EFB\u52A1" : "\u9879\u76EE"}\u5E76\u751F\u6210\u4E0D\u53EF\u9006\u5220\u9664 continuation\uFF0C\u4E0D\u53D1\u751F\u5220\u9664`,
+      risk: "read-before-write",
+      inputSchema: schemaOf({ id: SCHEMA_ID_STRING }, { required: ["id"] }),
+      handler: async (args, env) => {
+        const id = idString(args.id, "id");
+        const current = await detail(env.host, target, id, prepareName);
+        const datajson = {
+          header: { operator: await operatorId(env.host) },
+          datas: [{ mainTable: { id } }]
+        };
+        const continuation = await env.continuation.issue({
+          operation: applyName,
+          userId: datajson.header.operator,
+          id,
+          fingerprint: stableFingerprint(current),
+          datajson
+        });
+        return projectSuccess(prepareName, {
+          continuation,
+          request: { datajson },
+          current
+        }, { requiresConfirmation: true, id, irreversible: true });
+      }
+    },
+    {
+      name: applyName,
+      resource: "project",
+      method: "write.apply",
+      action: applyName,
+      summary: `\u7ECF\u7528\u6237\u786E\u8BA4\u5E76\u786E\u8BA4\u76EE\u6807\u672A\u53D8\u5316\u540E\u5220\u9664${target.entity === "task" ? "\u4EFB\u52A1" : "\u9879\u76EE"}\uFF0C\u4E0D\u53EF\u6062\u590D`,
+      risk: "high-risk-write",
+      requiresConfirmation: true,
+      inputSchema: schemaOf({
+        continuation: SCHEMA_CONTINUATION,
+        confirm: SCHEMA_CONFIRM
+      }, { required: ["continuation", "confirm"] }),
+      handler: async (args, env) => {
+        if (args.confirm !== true) throw projectValidationError("confirm_required", "confirm \u5FC5\u987B\u4E3A true");
+        const continuation = await env.continuation.verify(String(args.continuation), applyName);
+        await verifySession(env, continuation);
+        const id = idString(continuation.id, "continuation.id");
+        const current = await detail(env.host, target, id, applyName);
+        if (stableFingerprint(current) !== continuation.fingerprint) {
+          throw projectValidationError("target_changed", "\u76EE\u6807\u6570\u636E\u5728\u786E\u8BA4\u540E\u5DF2\u53D8\u5316\uFF0C\u8BF7\u91CD\u65B0\u6267\u884C prepare");
+        }
+        const datajson = asObject(continuation.datajson, "continuation.datajson");
+        const response = await sendWrite(env.host, applyName, target.writePath, datajson);
+        return projectSuccess(applyName, response, { targetType: target.entity, writeAction: "delete", id });
+      }
+    }
+  ];
+}
+var projectWriteOperations = [
+  ...createOperations("project.task.create", WRITE_TARGETS.taskCreate),
+  ...updateOperations("project.task.update", WRITE_TARGETS.taskUpdate),
+  ...deleteOperations("project.task.delete", WRITE_TARGETS.taskDelete),
+  ...createOperations("project.project.create", WRITE_TARGETS.projectCreate),
+  ...updateOperations("project.project.update", WRITE_TARGETS.projectUpdate),
+  ...deleteOperations("project.project.delete", WRITE_TARGETS.projectDelete)
+];
+
+// src/shortcuts/project/operations/registry.ts
+function buildRegistry() {
+  const registry = /* @__PURE__ */ new Map();
+  const definitions = [
+    ...projectReadOperations,
+    ...projectWriteOperations
+  ];
+  for (const definition of definitions) {
+    if (registry.has(definition.name)) {
+      throw new Error(`duplicate project operation: ${definition.name}`);
+    }
+    registry.set(definition.name, definition);
+  }
+  return registry;
+}
+var projectOperationRegistry = buildRegistry();
+function projectOperationDefinitions() {
+  return [...projectOperationRegistry.values()];
+}
+function getProjectOperation(operation) {
+  const definition = projectOperationRegistry.get(operation);
+  if (!definition) {
+    throw projectValidationError("operation_unknown", `\u4E8B\u4E95\u7136\u9879\u76EE\u6A21\u5757\u4E0D\u652F\u6301\u64CD\u4F5C\uFF1A${operation}`);
+  }
+  return definition;
+}
+
+// src/shortcuts/project/manifest.ts
+function buildOperations() {
+  return projectOperationDefinitions().map((definition) => ({
+    name: definition.name,
+    resource: definition.resource,
+    summary: definition.summary,
+    risk: definition.risk,
+    ...definition.requiresConfirmation ? { requiresConfirmation: true } : {},
+    inputSchema: definition.inputSchema
+  }));
+}
+var projectManifest = {
+  schemaVersion: 1,
+  name: "project",
+  title: "\u6CDB\u5FAEE10\u4E8B\u4E95\u7136\u9879\u76EE\u7BA1\u7406",
+  version: "0.1.0",
+  host: "e10-project",
+  status: "builtin",
+  sourceSkill: "weaver-e10-shijingran",
+  capabilities: ["project", "task"],
+  fixed: {
+    appTag: "weaver-project-eb",
+    minimumAppVersion: "20.6.11"
+  },
+  operations: buildOperations(),
+  withheldOperations: [
+    {
+      name: "project.attachment.upload",
+      reason: "\u6E90\u8D44\u6599\u4EC5\u8BF4\u660E attachment \u5B57\u6BB5\u63A5\u53D7\u5DF2\u4E0A\u4F20\u6587\u4EF6 ID\uFF0C\u672A\u63D0\u4F9B\u4E8B\u4E95\u7136\u6A21\u5757\u81EA\u5DF1\u7684\u4E0A\u4F20\u63A5\u53E3\u4E0E\u6587\u4EF6\u5B89\u5168\u786E\u8BA4\u94FE\u3002"
+    },
+    {
+      name: "project.field.auto-resolve",
+      reason: "\u6E90\u8D44\u6599\u8981\u6C42\u6309\u5B57\u6BB5\u7C7B\u578B\u7EC4\u5408\u591A\u4E2A\u63A5\u53E3\u89E3\u6790\u540D\u79F0\u5230 ID\uFF1B\u5F53\u524D CLI \u66B4\u9732\u5206\u6B65\u89E3\u6790 operation\uFF0C\u7531 Agent \u6309\u5B57\u6BB5\u7C7B\u578B\u663E\u5F0F\u7F16\u6392\uFF0C\u907F\u514D\u66FF\u7528\u6237\u731C\u6D4B\u5173\u8054\u5BF9\u8C61\u3002"
+    }
+  ]
+};
+
+// src/shortcuts/project/operations.ts
+async function executeProjectOperation(operation, rawInput, context) {
+  const definition = getProjectOperation(operation);
+  const input = asObject(rawInput);
+  assertNoForbiddenKeys(input);
+  return definition.handler(input, context);
+}
+
+// src/shortcuts/project/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+/u, "");
+}
+async function inputFrom(options) {
+  const opts = asOptions(options);
+  let input = {};
+  if (opts.input && opts.inputJson) {
+    throw projectValidationError("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 = opts.input === "-" ? await readStdin() : await readFile2(String(opts.input), "utf8");
+    } catch {
+      throw projectValidationError("input_unreadable", `\u65E0\u6CD5\u8BFB\u53D6 --input\uFF1A${String(opts.input)}`);
+    }
+    input = parseJsonInput(raw, "--input");
+  }
+  return input;
+}
+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 projectValidationError("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 executeProjectOperation(operation, input, {
+      host: createProjectHost(ctx),
+      continuation: createProjectContinuationSigner(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 projectShortcut = {
+  name: "project",
+  description: "\u6CDB\u5FAEE10\u4E8B\u4E95\u7136\u9879\u76EE\u7BA1\u7406 CLI\uFF08\u9879\u76EE/\u4EFB\u52A1\u67E5\u8BE2\u4E0E\u786E\u8BA4\u5199\u5165\uFF09",
+  category: "shortcut",
+  register({ program, action }) {
+    const project = program.command("project").description("\u6CDB\u5FAEE10\u4E8B\u4E95\u7136\u9879\u76EE\u7BA1\u7406\uFF08\u9879\u76EE/\u4EFB\u52A1\u67E5\u8BE2\u4E0E\u786E\u8BA4\u5199\u5165\uFF09");
+    project.command("schema").description("Print project operation manifest for agents").action(action((ctx) => {
+      ctx.output.write(projectManifest, { json: true });
+    }));
+    project.command("run").description("Run a project operation with JSON input").argument("<operation>", "operation name, e.g. project.task.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));
+    }));
+  }
+};
+export {
+  inputFrom,
+  projectShortcut
+};