nolo-cli 0.213.0 → 0.223.0-alpha.1

package/{chunk-6DWMYIUY.js → chunk-IILMY4W4.js}

@@ -1,13 +1,13 @@
 import {
   require_formatISO
-} from "./chunk-WPORQFYN.js";
+} from "./chunk-UVLYNWIE.js";
 import {
   require_react
-} from "./chunk-YDH3FDFQ.js";
+} from "./chunk-5FUN7EG4.js";
 import {
   patch,
   readAndWait
-} from "./chunk-FW6YHHLI.js";
+} from "./chunk-44X52WOJ.js";
 import {
   toErrorMessage
 } from "./chunk-HNMXYYJR.js";
@@ -16,7 +16,7 @@ import {
 } from "./chunk-G3SUCT4W.js";
 import {
   __toESM
-} from "./chunk-4VNS5WPM.js";
+} from "./chunk-U67V476Y.js";
 
 // packages/render/page/docStore.ts
 var import_react = __toESM(require_react(), 1);
@@ -308,9 +308,9 @@ async function saveDocState(arg, { dispatch, getState }) {
       { slateToRenderMarkdown },
       { buildSkillSummaryMarker }
     ] = await Promise.all([
-      import("./slateUtils-NGV2NMKM.js"),
-      import("./slateToRenderMarkdown-Y5IYN73U.js"),
-      import("./skillSummaryMarker-42HKSXYY.js")
+      import("./slateUtils-ESQAJ6RN.js"),
+      import("./slateToRenderMarkdown-R3X74MCX.js"),
+      import("./skillSummaryMarker-62UW7HI7.js")
     ]);
     const title = asOptionalTrimmedString(current.title) || extractTitleFromSlate(slateData) || "\u672A\u547D\u540D\u9875\u9762";
     const tools = extractMentionsFromSlate(slateData);
@@ -321,6 +321,7 @@ async function saveDocState(arg, { dispatch, getState }) {
     await dispatch(
       patch({
         dbKey: pageKey,
+        requireServerConfirmation: true,
         changes: {
           updatedAt,
           slateData,
@@ -334,7 +335,7 @@ async function saveDocState(arg, { dispatch, getState }) {
     ).unwrap();
     if (dbSpaceId) {
       try {
-        const { updateContentTitle } = await import("./contentThunks-U7PL5MQD.js");
+        const { updateContentTitle } = await import("./contentThunks-5GUQ7FWJ.js");
         await dispatch(
           updateContentTitle({
             spaceId: dbSpaceId,
@@ -352,6 +353,10 @@ async function saveDocState(arg, { dispatch, getState }) {
     if (typeof window !== "undefined") {
       window.dispatchEvent(new Event("nolo-user-data-updated"));
     }
+    if (state.pageKey !== pageKey || state.slateData !== slateData || state.title !== current.title || state.icon !== icon) {
+      if (state.pageKey === pageKey) setState((prev) => ({ ...prev, isSaving: false, justSaved: false }));
+      return;
+    }
     setState((prev) => ({
       ...prev,
       isSaving: false,
@@ -373,7 +378,7 @@ async function saveDocState(arg, { dispatch, getState }) {
   }
 }
 async function createDocState(args, thunkApi) {
-  const { createPageAction } = await import("./createPageAction-F4DIWZ2Z.js");
+  const { createPageAction } = await import("./createPageAction-JRQ2TA4O.js");
   return createPageAction(args, thunkApi);
 }
 function subscribe(listener) {

package/chunk-JA3ICVJY.js

@@ -0,0 +1,271 @@
+import {
+  createSpaceKey,
+  normalizeSpaceId
+} from "./chunk-UAD2WT54.js";
+import {
+  patch,
+  read
+} from "./chunk-44X52WOJ.js";
+import {
+  DEVICE_LOCAL_OWNER_ID,
+  isDeviceLocalSpaceBody
+} from "./chunk-2VUZSVAS.js";
+import {
+  selectIdentityUserId
+} from "./chunk-PXYBUFDB.js";
+
+// packages/create/space/utils/permissions.ts
+var checkSpaceMembership = (spaceData, userId) => {
+  if (!spaceData) {
+    console.error("[Permission Check] Space data is missing.");
+    throw new Error("\u65E0\u6CD5\u6267\u884C\u6743\u9650\u68C0\u67E5\uFF1A\u7A7A\u95F4\u6570\u636E\u7F3A\u5931\u3002");
+  }
+  if (isDeviceLocalSpaceBody(spaceData)) {
+    return;
+  }
+  if (!userId) {
+    console.error("[Permission Check] User ID is missing.");
+    throw new Error("\u65E0\u6CD5\u6267\u884C\u6743\u9650\u68C0\u67E5\uFF1A\u7528\u6237 ID \u7F3A\u5931\u3002");
+  }
+  if (!spaceData.members || !Array.isArray(spaceData.members) || !spaceData.members.includes(userId)) {
+    console.warn(
+      `[Permission Check] User ${userId} attempt to operate on space ${spaceData.id} without membership.`
+    );
+    throw new Error("\u5F53\u524D\u7528\u6237\u4E0D\u662F\u7A7A\u95F4\u6210\u5458");
+  }
+};
+var canManageSpaceContent = (spaceData, userId, membership) => {
+  if (!spaceData) return false;
+  if (isDeviceLocalSpaceBody(spaceData)) return true;
+  const actor = typeof userId === "string" ? userId.trim() : "";
+  if (!actor) return false;
+  const ownerValues = [spaceData.ownerId, spaceData.userId].map((value) => typeof value === "string" ? value.trim() : "").filter(Boolean);
+  if (ownerValues.includes(actor)) return true;
+  const role = typeof membership?.role === "string" ? membership.role.trim() : "";
+  return role === "owner" || role === "admin";
+};
+var localSpaceAuthorityPatchStamp = (spaceData) => isDeviceLocalSpaceBody(spaceData) ? { userId: DEVICE_LOCAL_OWNER_ID } : {};
+
+// packages/create/space/constants.ts
+var UNCATEGORIZED_ID = "__uncategorized_container__";
+
+// packages/create/space/content/spaceContentPatch.ts
+var notifyUserDataUpdated = () => {
+  if (typeof window !== "undefined" && typeof window.dispatchEvent === "function" && typeof window.Event === "function") {
+    window.dispatchEvent(new window.Event("nolo-user-data-updated"));
+  }
+};
+var loadSpaceContentOrThrow = async (dispatch, spaceId, contentKey, sourceServerOrigin) => {
+  if (!contentKey || typeof contentKey !== "string" || contentKey.trim() === "") {
+    throw new Error("Invalid contentKey provided.");
+  }
+  const spaceKey = createSpaceKey.space(spaceId);
+  let spaceData = null;
+  try {
+    spaceData = await dispatch(
+      read({ dbKey: spaceKey, preferredServerOrigin: sourceServerOrigin })
+    ).unwrap();
+  } catch (readError) {
+    throw new Error(`\u65E0\u6CD5\u52A0\u8F7D\u7A7A\u95F4\u6570\u636E: ${spaceId}`);
+  }
+  if (!spaceData) {
+    throw new Error("Space not found");
+  }
+  const content = spaceData.contents?.[contentKey];
+  if (!content) {
+    throw new Error("Content not found in space");
+  }
+  return { spaceKey, spaceData, content };
+};
+function resolveContentSpaceWriteAuthority(input) {
+  const owner = typeof input.ownerId === "string" ? input.ownerId.trim() : "";
+  const actor = typeof input.actorUserId === "string" ? input.actorUserId.trim() : "";
+  if (owner && owner !== DEVICE_LOCAL_OWNER_ID && owner !== actor) return "deny";
+  if (input.targetSpaceIsDeviceLocal) return "allow";
+  if (owner === DEVICE_LOCAL_OWNER_ID) return "allow";
+  if (!owner) return "unverified";
+  if (actor && owner === actor) return "allow";
+  return actor ? "deny" : "unverified";
+}
+var readContentRecordForSpaceSync = async (dispatch, contentKey) => {
+  try {
+    const existing = await dispatch(read({ dbKey: contentKey })).unwrap();
+    if (!existing || typeof existing !== "object") return { status: "missing" };
+    return { status: "ok", record: existing };
+  } catch {
+    return { status: "unreadable" };
+  }
+};
+var applyContentRecordSpaceId = async (dispatch, contentKey, record, targetSpaceId, failMessagePrefix, options = {}) => {
+  const normalizedTarget = normalizeSpaceId(targetSpaceId) || targetSpaceId;
+  const authority = resolveContentSpaceWriteAuthority({
+    ownerId: record.userId ?? record.ownerId,
+    actorUserId: options.actorUserId,
+    targetSpaceIsDeviceLocal: options.targetSpaceIsDeviceLocal
+  });
+  if (authority === "deny") return "not-owner";
+  if (authority === "unverified") return "unverified";
+  const rawCurrentSpaceId = record.spaceId;
+  const currentSpaceId = typeof rawCurrentSpaceId === "string" ? normalizeSpaceId(rawCurrentSpaceId) : null;
+  if (currentSpaceId === normalizedTarget) return "unchanged";
+  if (options.onlyWhenUnset && currentSpaceId) return "unchanged";
+  try {
+    await dispatch(
+      patch({ dbKey: contentKey, changes: { spaceId: normalizedTarget } })
+    ).unwrap();
+  } catch (contentPatchError) {
+    throw new Error(
+      `${failMessagePrefix}: ${contentPatchError?.message || "\u672A\u77E5\u9519\u8BEF"}`
+    );
+  }
+  notifyUserDataUpdated();
+  return "patched";
+};
+var syncContentRecordSpaceId = async (dispatch, contentKey, targetSpaceId, failMessagePrefix, options = {}) => {
+  const readResult = await readContentRecordForSpaceSync(dispatch, contentKey);
+  if (readResult.status === "unreadable") return "unreadable";
+  if (readResult.status === "missing") return "missing";
+  return applyContentRecordSpaceId(
+    dispatch,
+    contentKey,
+    readResult.record,
+    targetSpaceId,
+    failMessagePrefix,
+    options
+  );
+};
+var patchIndividualContentRecord = async (dispatch, contentKey, changes, sourceServerOrigin, failMessagePrefix) => {
+  let hasIndividualRecord = false;
+  try {
+    const existing = await dispatch(
+      read({ dbKey: contentKey, preferredServerOrigin: sourceServerOrigin })
+    ).unwrap();
+    hasIndividualRecord = Boolean(existing);
+  } catch {
+    hasIndividualRecord = false;
+  }
+  if (hasIndividualRecord) {
+    try {
+      await dispatch(
+        patch({
+          dbKey: contentKey,
+          changes,
+          preferredServerOrigin: sourceServerOrigin
+        })
+      ).unwrap();
+      notifyUserDataUpdated();
+    } catch (contentPatchError) {
+      throw new Error(
+        `${failMessagePrefix}: ${contentPatchError?.message || "\u672A\u77E5\u9519\u8BEF"}`
+      );
+    }
+  }
+};
+
+// packages/create/space/content/addContentAction.ts
+var addContentAction = async (input, thunkAPI) => {
+  const {
+    spaceId,
+    title,
+    type,
+    contentKey,
+    fileCategory,
+    mimeType,
+    fileSize,
+    originalName,
+    categoryId: rawCategoryId,
+    pinned = false,
+    order,
+    triggerType,
+    skillSummary
+  } = input;
+  const { dispatch, getState } = thunkAPI;
+  const userId = selectIdentityUserId(getState());
+  if (!contentKey || typeof contentKey !== "string" || contentKey.trim() === "")
+    throw new Error("Invalid contentKey provided.");
+  if (!title || typeof title !== "string" || title.trim() === "")
+    throw new Error("Invalid or empty title provided.");
+  if (!type || typeof type !== "string")
+    throw new Error("Invalid content type provided.");
+  const spaceKey = createSpaceKey.space(spaceId);
+  const spaceData = await dispatch(read({
+    dbKey: spaceKey
+  })).unwrap();
+  checkSpaceMembership(spaceData, userId);
+  const alreadyPresent = Boolean(spaceData.contents?.[contentKey]);
+  let categoryIdForStorage;
+  if (rawCategoryId && rawCategoryId !== "" && rawCategoryId !== UNCATEGORIZED_ID) {
+    if (spaceData.categories?.[rawCategoryId]) {
+      categoryIdForStorage = rawCategoryId;
+    }
+  }
+  const now = Date.now();
+  const newSpaceContent = {
+    title: title.trim(),
+    type,
+    contentKey,
+    ...fileCategory !== void 0 ? { fileCategory } : {},
+    ...mimeType !== void 0 ? { mimeType } : {},
+    ...fileSize !== void 0 ? { fileSize } : {},
+    ...originalName !== void 0 ? { originalName } : {},
+    ...categoryIdForStorage !== void 0 && {
+      categoryId: categoryIdForStorage
+    },
+    pinned,
+    createdAt: now,
+    updatedAt: now,
+    ...order !== void 0 && typeof order === "number" && { order },
+    ...triggerType !== void 0 && { triggerType },
+    ...skillSummary !== void 0 ? { skillSummary } : {}
+  };
+  const entityRead = await readContentRecordForSpaceSync(dispatch, contentKey);
+  if (entityRead.status === "unreadable") {
+    throw new Error("\u65E0\u6CD5\u8BFB\u53D6\u5185\u5BB9\u8BB0\u5F55\uFF0C\u672A\u52A0\u5165\u7A7A\u95F4\uFF08\u53EF\u91CD\u8BD5\uFF09");
+  }
+  let updatedSpaceData;
+  if (alreadyPresent) {
+    updatedSpaceData = spaceData;
+  } else {
+    const changes = {
+      contents: { [contentKey]: newSpaceContent },
+      updatedAt: now,
+      ...localSpaceAuthorityPatchStamp(spaceData)
+    };
+    updatedSpaceData = await dispatch(
+      patch({ dbKey: spaceKey, changes })
+    ).unwrap();
+  }
+  let contentSpaceSync;
+  try {
+    contentSpaceSync = entityRead.status === "ok" ? await applyContentRecordSpaceId(
+      dispatch,
+      contentKey,
+      entityRead.record,
+      spaceId,
+      "\u5185\u5BB9\u5DF2\u52A0\u5165\u7A7A\u95F4\uFF0C\u4F46\u540C\u6B65\u5185\u5BB9\u8BB0\u5F55\u7684\u5F52\u5C5E\u7A7A\u95F4\u5931\u8D25",
+      {
+        onlyWhenUnset: true,
+        actorUserId: userId,
+        targetSpaceIsDeviceLocal: isDeviceLocalSpaceBody(spaceData)
+      }
+    ) : "missing";
+  } catch (entitySyncError) {
+    throw new Error(
+      `${entitySyncError?.message || "\u540C\u6B65\u5185\u5BB9\u8BB0\u5F55\u5931\u8D25"}\uFF08\u7A7A\u95F4\u94FE\u63A5\u5DF2\u5199\u5165\uFF1B\u518D\u6B21\u52A0\u5165\u4F1A\u5E42\u7B49\u6536\u655B\uFF09`
+    );
+  }
+  return { spaceId, updatedSpaceData, contentSpaceSync, alreadyPresent };
+};
+
+export {
+  checkSpaceMembership,
+  canManageSpaceContent,
+  localSpaceAuthorityPatchStamp,
+  UNCATEGORIZED_ID,
+  notifyUserDataUpdated,
+  loadSpaceContentOrThrow,
+  readContentRecordForSpaceSync,
+  syncContentRecordSpaceId,
+  patchIndividualContentRecord,
+  addContentAction
+};

package/{chunk-ZRSNONOB.js → chunk-JWXITTQB.js}

@@ -1,7 +1,7 @@
 import {
   MEMORY_USE_GUIDANCE,
   wrapHistoricalSummaryWithReplayGuard
-} from "./chunk-4VJAC32I.js";
+} from "./chunk-L5I543VB.js";
 
 // packages/agent-runtime/skillCatalog.ts
 var SKILL_CATALOG_PRIORITY = Object.freeze([
@@ -269,13 +269,18 @@ var buildSkillDiscoveryCatalogLayer = (catalog) => {
   const multiSource = sources.length > 1;
   const lines = [
     "--- \u53EF\u7528\u6280\u80FD\uFF08Skills\uFF09---",
-    multiSource ? `\u5171\u53D1\u73B0 ${catalog.entries.length} \u4E2A\u6280\u80FD\uFF08\u6765\u6E90\uFF1A${sources.join(", ")}\uFF09\uFF0C\u6A21\u578B\u53EF\u6309\u9700\u7528 loadSkill \u6309\u540D\u52A0\u8F7D\u6216 readFile \u76F4\u63A5\u8BFB\u53D6\uFF08\u8DEF\u5F84\u89C4\u5219 .agents/skills/<name>/SKILL.md\uFF09\uFF1A` : `\u5DE5\u4F5C\u533A\u4E2D\u53D1\u73B0\u4E86 ${catalog.entries.length} \u4E2A\u6280\u80FD\uFF08SKILL.md\uFF09\uFF0C\u6A21\u578B\u53EF\u6309\u9700\u7528 loadSkill \u6309\u540D\u52A0\u8F7D\u6216 readFile \u76F4\u63A5\u8BFB\u53D6\uFF08\u8DEF\u5F84\u89C4\u5219 .agents/skills/<name>/SKILL.md\uFF09\uFF1A`,
+    `${catalog.entries.length} \u6280\u80FD\uFF1B\u6765\u6E90\uFF1A${sources.join(", ")}\u3002loadSkill \u6309\u540D\u52A0\u8F7D\uFF1B\u672C\u5730 readFile\uFF1A.agents/skills/<name>/SKILL.md\uFF08\u5F02\u8DEF\u5F84\u53E6\u5217\uFF09\u3002\u2192=\u89E6\u53D1\u8BCD\uFF1A`,
     ...catalog.entries.map((entry) => {
       const marks = [
         multiSource ? ` [${entry.source}]` : "",
         entry.available ? "" : ` [\u4E0D\u53EF\u7528\uFF1A${entry.unavailableReason ?? "unknown"}]`
       ].join("");
-      return `- ${entry.name}${marks}: ${entry.description}`;
+      const location = [
+        entry.relativePath && entry.relativePath !== `.agents/skills/${entry.name}/SKILL.md` ? `path=${entry.relativePath}` : "",
+        entry.contentRef && entry.contentRef !== entry.relativePath ? `ref=${entry.contentRef}` : ""
+      ].filter(Boolean).join("; ");
+      const description = entry.description.replace(/^触发词：/, "\u2192");
+      return `- ${entry.name}${marks}: ${description}${location ? ` [${location}]` : ""}`;
     })
   ];
   if (catalog.droppedEntries.length > 0) {