nolo-cli 0.8.0-alpha.6 → 0.8.0-alpha.7

package/chunk-IAXBCTTE.js

@@ -0,0 +1,175 @@
+import {
+  selectCurrentServer,
+  selectRemoteServers
+} from "./chunk-VEJLAVTC.js";
+import {
+  createUserKey,
+  extractAgentInfo,
+  extractCoverImage,
+  resolveShareAuthorIdentity,
+  sanitizeShareData,
+  shareKey,
+  toNonEmptyString
+} from "./chunk-PN7AFLOK.js";
+import {
+  noloDeleteRequest,
+  noloWriteRequest,
+  selectIdentityUser,
+  selectIdentityUserId
+} from "./chunk-EYEEHCU4.js";
+import {
+  normalizeTimeFields
+} from "./chunk-QYXLLLGL.js";
+
+// packages/share/action.ts
+var generateToken = () => {
+  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+  const charsLen = chars.length;
+  const maxValid = 252;
+  let token = "";
+  while (token.length < 10) {
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    for (let i = 0; i < bytes.length && token.length < 10; i++) {
+      if (bytes[i] < maxValid) {
+        token += chars.charAt(bytes[i] % charsLen);
+      }
+    }
+  }
+  return token;
+};
+var assertDialogShareMessagesPresent = (type, data) => {
+  if (type !== "dialog") return;
+  const messages = Array.isArray(data.messages) ? data.messages : Array.isArray(data.history) ? data.history : [];
+  if (messages.length > 0) return;
+  throw new Error("Cannot share dialog without persisted messages.");
+};
+var resolveTableSharePayload = (type, data, userId, originServer) => {
+  if (type !== "table") return sanitizeShareData(data);
+  const tableDbKey = typeof data.dbKey === "string" && data.dbKey.trim().length > 0 ? data.dbKey : void 0;
+  const tableOwnerId = typeof data.tenantId === "string" && data.tenantId.trim().length > 0 ? data.tenantId : userId;
+  if (!tableDbKey) {
+    throw new Error("Table share requires a dbKey.");
+  }
+  return {
+    mode: "live",
+    tableDbKey,
+    tableOwnerId,
+    originServer
+  };
+};
+var shareResourceAction = async (config, thunkApi) => {
+  const state = thunkApi.getState();
+  const userId = selectIdentityUserId(state);
+  const currentUser = selectIdentityUser(state);
+  if (!userId) {
+    throw new Error("User must be logged in to share resources.");
+  }
+  const token = generateToken();
+  const key = shareKey.create(token);
+  const currentServer = selectCurrentServer(state);
+  assertDialogShareMessagesPresent(config.type, config.data);
+  const snapshotData = resolveTableSharePayload(
+    config.type,
+    config.data,
+    userId,
+    currentServer
+  );
+  const coverImage = extractCoverImage(config.type, snapshotData);
+  const agentInfo = extractAgentInfo(config.type, snapshotData);
+  const createdAt = Date.now();
+  const { db: clientDb } = thunkApi.extra;
+  let authorProfile = null;
+  if (clientDb) {
+    try {
+      authorProfile = await clientDb.get(createUserKey.profile(userId));
+    } catch {
+      authorProfile = null;
+    }
+  }
+  const { authorName, authorAvatar } = resolveShareAuthorIdentity({
+    user: currentUser,
+    profile: authorProfile
+  });
+  if (agentInfo.sourceAgentKey && !agentInfo.sourceAgentName) {
+    if (clientDb) {
+      try {
+        const agentData = await clientDb.get(agentInfo.sourceAgentKey);
+        const name = toNonEmptyString(agentData?.name);
+        if (name) agentInfo.sourceAgentName = name;
+      } catch {
+      }
+    }
+  }
+  const sharedObject = {
+    type: config.type,
+    version: 1,
+    data: snapshotData,
+    meta: {
+      authorId: userId,
+      ...authorName ? { authorName } : {},
+      ...authorAvatar ? { authorAvatar } : {},
+      createdAt,
+      visibility: config.visibility ?? "private",
+      title: config.title,
+      description: config.description,
+      originalId: config.data.dbKey ?? config.data.id,
+      coverImage,
+      ...agentInfo
+    }
+  };
+  const servers = [
+    currentServer,
+    ...selectRemoteServers(state).filter((server) => server !== currentServer)
+  ].filter(Boolean);
+  const replicaServers = servers.filter((server) => server !== currentServer);
+  if (servers.length === 0) {
+    throw new Error("No available server to publish share.");
+  }
+  if (config.type === "table" && sharedObject.data.mode === "live") {
+    sharedObject.data = {
+      ...sharedObject.data,
+      originServer: currentServer
+    };
+    sharedObject.meta = {
+      ...sharedObject.meta,
+      mode: "live",
+      tableDbKey: typeof sharedObject.data.tableDbKey === "string" ? sharedObject.data.tableDbKey : void 0,
+      tableOwnerId: typeof sharedObject.data.tableOwnerId === "string" ? sharedObject.data.tableOwnerId : void 0,
+      originServer: currentServer,
+      replicaServers
+    };
+  }
+  const persistedSharedObject = normalizeTimeFields({
+    ...sharedObject,
+    dbKey: key,
+    userId
+  });
+  const indexKeys = shareKey.allIndexKeysFromShare(key, persistedSharedObject);
+  const results = await Promise.all(
+    servers.map(
+      (server) => noloWriteRequest(server, { data: persistedSharedObject, customKey: key, userId, indexKeys }, state)
+    )
+  );
+  const [originPublished, ...replicaPublishResults] = results;
+  if (!originPublished) {
+    const successfulReplicaServers = replicaServers.filter(
+      (_, index) => replicaPublishResults[index]
+    );
+    await Promise.all(
+      successfulReplicaServers.map(
+        (server) => noloDeleteRequest(server, key, { type: "single" }, state)
+      )
+    );
+    throw new Error("Failed to publish share to origin server.");
+  }
+  if (!clientDb) {
+    throw new Error("Client database instance is required in shareResourceAction");
+  }
+  await clientDb.put(key, persistedSharedObject);
+  return { token, key };
+};
+
+export {
+  shareResourceAction
+};

package/chunk-IDZTNRP2.js

@@ -0,0 +1,85 @@
+// packages/cli/processSpawn.ts
+import { spawn } from "node:child_process";
+function spawnProcess(options) {
+  let [command, ...args] = options.cmd;
+  if (process.platform === "win32") {
+    const lower = command.toLowerCase();
+    if ((lower === "npm" || lower === "npx" || lower === "pnpm" || lower === "yarn" || lower === "nolo") && !lower.endsWith(".cmd") && !lower.endsWith(".exe") && !lower.endsWith(".bat")) {
+      command = `${command}.cmd`;
+    }
+  }
+  let child;
+  try {
+    child = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+      stdio: [
+        options.stdin ?? "pipe",
+        options.stdout ?? "pipe",
+        options.stderr ?? "pipe"
+      ]
+    });
+  } catch {
+    return {
+      exited: Promise.resolve(127),
+      stdin: null,
+      stdout: null,
+      stderr: null
+    };
+  }
+  const exited = new Promise((resolve) => {
+    child.on("exit", (code) => resolve(code ?? 1));
+    child.on("error", () => resolve(127));
+  });
+  return {
+    exited,
+    stdin: child.stdin,
+    stdout: child.stdout,
+    stderr: child.stderr
+  };
+}
+async function readPipeText(stream) {
+  if (!stream) return "";
+  const anyStream = stream;
+  if (typeof anyStream.setEncoding !== "function" && typeof anyStream[Symbol.asyncIterator] === "function") {
+    const chunks = [];
+    for await (const chunk of anyStream) {
+      if (typeof chunk === "string") chunks.push(chunk);
+      else if (chunk instanceof Uint8Array) chunks.push(Buffer.from(chunk).toString("utf8"));
+      else if (Buffer.isBuffer(chunk)) chunks.push(chunk.toString("utf8"));
+      else chunks.push(String(chunk ?? ""));
+    }
+    return chunks.join("");
+  }
+  return new Promise((resolve) => {
+    let data = "";
+    let done = false;
+    const finish = () => {
+      if (done) return;
+      done = true;
+      resolve(data);
+    };
+    if (typeof anyStream.setEncoding === "function") {
+      anyStream.setEncoding("utf8");
+    }
+    stream.on("data", (chunk) => {
+      data += typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+    });
+    stream.on("end", finish);
+    stream.on("close", finish);
+    stream.on("error", finish);
+  });
+}
+function resolveDefaultSpawn() {
+  const bunSpawn = globalThis.Bun?.spawn;
+  if (typeof bunSpawn === "function") {
+    return bunSpawn;
+  }
+  return spawnProcess;
+}
+
+export {
+  spawnProcess,
+  readPipeText,
+  resolveDefaultSpawn
+};

package/chunk-IECI4YHR.js

@@ -0,0 +1,421 @@
+import {
+  updateContentTitle
+} from "./chunk-KTI2WDDG.js";
+import {
+  require_date_fns
+} from "./chunk-M76ECQRD.js";
+import {
+  require_react
+} from "./chunk-3ASDTTEI.js";
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
+import {
+  patch,
+  readAndWait
+} from "./chunk-G5H7RNFL.js";
+import {
+  asOptionalTrimmedString
+} from "./chunk-G3SUCT4W.js";
+import {
+  __toESM
+} from "./chunk-4VNS5WPM.js";
+
+// packages/render/page/docStore.ts
+var import_react = __toESM(require_react(), 1);
+var import_date_fns = __toESM(require_date_fns(), 1);
+var createInitialState = () => ({
+  content: null,
+  slateData: null,
+  title: null,
+  dbSpaceId: null,
+  tags: null,
+  icon: null,
+  isReadOnly: true,
+  isLoading: false,
+  isInitialized: false,
+  error: null,
+  pageKey: null,
+  isSaving: false,
+  saveError: null,
+  lastSavedAt: null,
+  createdAt: null,
+  lastSavedSlateData: null,
+  lastSavedTitle: null,
+  lastSavedIcon: null,
+  justSaved: false,
+  tools: null,
+  meta: null,
+  id: null,
+  type: null,
+  creator: null,
+  focusContext: null,
+  externalUpdateSeq: 0
+});
+var listeners = /* @__PURE__ */ new Set();
+var version = 0;
+var state = createInitialState();
+var notify = () => {
+  for (const listener of listeners) {
+    try {
+      listener();
+    } catch {
+    }
+  }
+};
+var bump = () => {
+  version += 1;
+  notify();
+};
+var setState = (updater) => {
+  state = typeof updater === "function" ? updater(state) : updater;
+  bump();
+};
+var deepEqualEditorContent = (a, b) => {
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  if (typeof a !== "object" || typeof b !== "object") return false;
+  const isArrayA = Array.isArray(a);
+  const isArrayB = Array.isArray(b);
+  if (isArrayA || isArrayB) {
+    if (!isArrayA || !isArrayB || a.length !== b.length) return false;
+    return a.every(
+      (item, index) => deepEqualEditorContent(item, b[index])
+    );
+  }
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  return keysA.every(
+    (key) => Object.prototype.hasOwnProperty.call(b, key) && deepEqualEditorContent(a[key], b[key])
+  );
+};
+var hasSlateContentChanged = (newContent, oldContent) => {
+  if (newContent === oldContent) return false;
+  if (!newContent || !oldContent) return true;
+  if (newContent.length !== oldContent.length) return true;
+  return !deepEqualEditorContent(newContent, oldContent);
+};
+function getDocState() {
+  return state;
+}
+function getDocField(selector) {
+  return selector(state);
+}
+function getDocPageKey() {
+  return state.pageKey;
+}
+function getDocIsInitialized() {
+  return state.isInitialized;
+}
+function getDocIsReadOnly() {
+  return state.isReadOnly;
+}
+function getDocHasPendingChanges() {
+  if (!state.isInitialized || state.isReadOnly) return false;
+  return hasSlateContentChanged(state.slateData, state.lastSavedSlateData) || (state.title || "") !== (state.lastSavedTitle || "") || JSON.stringify(state.icon ?? null) !== JSON.stringify(state.lastSavedIcon ?? null);
+}
+function updateSlateDoc(value) {
+  if (!state.isInitialized || state.isReadOnly) return;
+  if (state.slateData === value) return;
+  setState((prev) => ({ ...prev, slateData: value, justSaved: false }));
+}
+function updateTitleDoc(title) {
+  if (!state.isInitialized || state.isReadOnly) return;
+  setState((prev) => ({ ...prev, title, justSaved: false }));
+}
+function updateIconDoc(icon) {
+  if (!state.isInitialized || state.isReadOnly) return;
+  setState((prev) => ({ ...prev, icon, justSaved: false }));
+}
+function resetJustSavedStatus() {
+  if (state.justSaved === false) return;
+  setState((prev) => ({ ...prev, justSaved: false }));
+}
+function setDocFocusContext(focusContext) {
+  setState((prev) => ({ ...prev, focusContext }));
+}
+function toggleReadOnlyDoc() {
+  setState((prev) => ({ ...prev, isReadOnly: !prev.isReadOnly }));
+}
+function setReadOnlyDoc(isReadOnly) {
+  setState((prev) => ({ ...prev, isReadOnly }));
+}
+function updateDocTags(tags) {
+  if (!state.isInitialized) return;
+  setState((prev) => ({ ...prev, tags }));
+}
+function resetDocState() {
+  setState(createInitialState());
+}
+function previewDocState(payload) {
+  const next = createInitialState();
+  next.isInitialized = true;
+  next.isLoading = false;
+  next.isReadOnly = true;
+  next.slateData = payload.slateData;
+  next.title = payload.title;
+  next.lastSavedTitle = payload.title;
+  next.pageKey = payload.dbKey;
+  next.id = payload.id;
+  next.type = payload.type || "page" /* DOC */;
+  next.lastSavedSlateData = payload.slateData;
+  next.tags = payload.tags || null;
+  next.icon = payload.icon || null;
+  next.lastSavedIcon = payload.icon || null;
+  next.dbSpaceId = payload.spaceId;
+  next.content = payload.content || null;
+  next.meta = payload.meta || null;
+  setState(next);
+}
+function applyExternalDocUpdate(payload) {
+  if (!state.isInitialized) return;
+  const { slateData, content, title, tools, meta, savedAt } = payload;
+  setState((prev) => {
+    const next = {
+      ...prev,
+      slateData,
+      lastSavedSlateData: slateData,
+      lastSavedAt: savedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+      justSaved: true,
+      saveError: null,
+      externalUpdateSeq: prev.externalUpdateSeq + 1
+    };
+    if (content !== void 0) next.content = content;
+    if (title != null) {
+      next.title = title;
+      next.lastSavedTitle = title;
+    }
+    if (tools !== void 0) next.tools = tools;
+    if (meta !== void 0) next.meta = meta;
+    return next;
+  });
+}
+async function initDocState(args, { dispatch }) {
+  const { pageKey, isReadOnly } = args;
+  setState((prev) => ({
+    ...createInitialState(),
+    isLoading: true,
+    pageKey,
+    isReadOnly
+  }));
+  try {
+    const readAction = await dispatch(readAndWait(pageKey));
+    if (readAndWait.fulfilled.match(readAction) && readAction.payload) {
+      const data = readAction.payload;
+      if (data.type !== "page" /* DOC */) {
+        const msg = `\u52A0\u8F7D\u7684\u5185\u5BB9 ${pageKey} \u4E0D\u662F\u6587\u6863\u7C7B\u578B (${data.type})`;
+        setState((prev) => ({
+          ...prev,
+          isLoading: false,
+          isInitialized: true,
+          error: msg
+        }));
+        return;
+      }
+      const payload = data;
+      const lastSavedAt = payload.updatedAt || payload.updated_at || null;
+      const createdAt = typeof payload.created === "string" && payload.created || typeof payload.createdAt === "string" && payload.createdAt || lastSavedAt;
+      setState((prev) => ({
+        ...prev,
+        isLoading: false,
+        isInitialized: true,
+        error: null,
+        externalUpdateSeq: prev.externalUpdateSeq + 1,
+        content: payload.content || null,
+        slateData: payload.slateData || null,
+        lastSavedSlateData: payload.slateData || null,
+        title: payload.title || null,
+        lastSavedTitle: payload.title || null,
+        dbSpaceId: payload.spaceId || null,
+        tags: payload.tags || null,
+        icon: payload.icon || null,
+        lastSavedIcon: payload.icon || null,
+        isReadOnly: payload.isReadOnly,
+        pageKey: payload.dbKey,
+        id: payload.id,
+        type: payload.type,
+        lastSavedAt,
+        createdAt,
+        tools: payload.tools || null,
+        meta: payload.meta || null
+      }));
+    } else {
+      const msg = readAction.payload?.message || `\u65E0\u6CD5\u52A0\u8F7D\u6587\u6863 ${pageKey}`;
+      setState((prev) => ({
+        ...prev,
+        isLoading: false,
+        isInitialized: true,
+        error: msg
+      }));
+    }
+  } catch (e) {
+    setState((prev) => ({
+      ...prev,
+      isLoading: false,
+      isInitialized: true,
+      error: e?.message || `\u521D\u59CB\u5316\u6587\u6863 ${pageKey} \u65F6\u51FA\u9519`
+    }));
+  }
+}
+async function saveDocState(arg, { dispatch, getState }) {
+  const requestedPageKey = arg.pageKey;
+  const current = state;
+  const { pageKey, slateData, dbSpaceId, meta, icon } = current;
+  const triggerSource = arg.triggerSource ?? "unknown";
+  const hasPending = getDocHasPendingChanges();
+  if (typeof console !== "undefined") {
+    console.info("[saveDocState] triggered", {
+      triggerSource,
+      pageKey,
+      hasPendingChanges: hasPending,
+      lastSavedAt: current.lastSavedAt,
+      externalUpdateSeq: current.externalUpdateSeq
+      // 若 hasPending=false，说明 slateData===lastSavedSlateData，
+      // 此刻 save 仍被无条件触发 → 会用旧内容覆盖数据库（若数据库已有更新）
+    });
+  }
+  if (!pageKey || pageKey !== requestedPageKey) {
+    return;
+  }
+  if (!slateData) {
+    return;
+  }
+  if (!hasPending) {
+    if (typeof console !== "undefined") {
+      console.info("[saveDocState] skipped \u2014 no pending changes (protects external writes)", {
+        triggerSource,
+        pageKey,
+        externalUpdateSeq: current.externalUpdateSeq
+      });
+    }
+    return;
+  }
+  setState((prev) => ({
+    ...prev,
+    isSaving: true,
+    saveError: null,
+    justSaved: false
+  }));
+  try {
+    const [
+      { extractTitleFromSlate, extractMentionsFromSlate },
+      { slateToRenderMarkdown },
+      { buildSkillSummaryMarker }
+    ] = await Promise.all([
+      import("./slateUtils-2M7MUTWX.js"),
+      import("./slateToRenderMarkdown-Y5IYN73U.js"),
+      import("./skillSummaryMarker-42HKSXYY.js")
+    ]);
+    const title = asOptionalTrimmedString(current.title) || extractTitleFromSlate(slateData) || "\u672A\u547D\u540D\u9875\u9762";
+    const tools = extractMentionsFromSlate(slateData);
+    const skillSummary = buildSkillSummaryMarker(meta);
+    const content = slateToRenderMarkdown(slateData);
+    const now = /* @__PURE__ */ new Date();
+    const updatedAt = (0, import_date_fns.formatISO)(now);
+    await dispatch(
+      patch({
+        dbKey: pageKey,
+        changes: {
+          updatedAt,
+          slateData,
+          title,
+          tools,
+          content,
+          icon: icon ?? null,
+          ...meta ? { meta } : {}
+        }
+      })
+    ).unwrap();
+    if (dbSpaceId) {
+      try {
+        await dispatch(
+          updateContentTitle({
+            spaceId: dbSpaceId,
+            contentKey: pageKey,
+            title,
+            skillSummary
+          })
+        ).unwrap();
+      } catch (spaceSyncError) {
+        console.warn(
+          `[saveDoc] \u7A7A\u95F4\u6807\u9898\u540C\u6B65\u5931\u8D25\uFF08\u9875\u9762\u5DF2\u4FDD\u5B58\uFF09: ${toErrorMessage(spaceSyncError)}`
+        );
+      }
+    }
+    if (typeof window !== "undefined") {
+      window.dispatchEvent(new Event("nolo-user-data-updated"));
+    }
+    setState((prev) => ({
+      ...prev,
+      isSaving: false,
+      lastSavedAt: updatedAt,
+      title,
+      content,
+      lastSavedSlateData: slateData,
+      lastSavedTitle: title,
+      lastSavedIcon: prev.icon,
+      justSaved: true
+    }));
+  } catch (e) {
+    setState((prev) => ({
+      ...prev,
+      isSaving: false,
+      saveError: e?.message || "\u4FDD\u5B58\u5931\u8D25",
+      justSaved: false
+    }));
+  }
+}
+async function createDocState(args, thunkApi) {
+  const { createPageAction } = await import("./createPageAction-EQNQQRCW.js");
+  return createPageAction(args, thunkApi);
+}
+function subscribe(listener) {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+function getSnapshot() {
+  return version;
+}
+function useDocState() {
+  (0, import_react.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
+  return getDocState();
+}
+function useDocField(selector) {
+  (0, import_react.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
+  return selector(state);
+}
+function resetDocStoreForTests() {
+  state = createInitialState();
+  bump();
+}
+
+export {
+  getDocState,
+  getDocField,
+  getDocPageKey,
+  getDocIsInitialized,
+  getDocIsReadOnly,
+  getDocHasPendingChanges,
+  updateSlateDoc,
+  updateTitleDoc,
+  updateIconDoc,
+  resetJustSavedStatus,
+  setDocFocusContext,
+  toggleReadOnlyDoc,
+  setReadOnlyDoc,
+  updateDocTags,
+  resetDocState,
+  previewDocState,
+  applyExternalDocUpdate,
+  initDocState,
+  saveDocState,
+  createDocState,
+  subscribe,
+  getSnapshot,
+  useDocState,
+  useDocField,
+  resetDocStoreForTests
+};