nolo-cli 0.49.1 → 0.50.0

package/{chunk-HCMFFI2G.js → chunk-S3JNURSO.js}

@@ -1,13 +1,13 @@
 import {
   i18n_default,
   toolRegistry
-} from "./chunk-WKOEOQCI.js";
+} from "./chunk-OSUZKICS.js";
 import {
   canonicalizeToolNames
 } from "./chunk-O6OSWFZQ.js";
 import {
   isNoloHostedProvider
-} from "./chunk-WL3UOGYO.js";
+} from "./chunk-G4WSLTQF.js";
 import {
   asTrimmedLowercaseString
 } from "./chunk-QSJ3HFEF.js";

package/{chunk-YZ2WE6CW.js → chunk-SAJSBPI2.js}

@@ -1,10 +1,10 @@
 import {
   getRuntimeServerContext,
   scheduleDeleteReplication
-} from "./chunk-HHBXCRJS.js";
+} from "./chunk-XOJRZUPF.js";
 import {
   fetchFromClientDb
-} from "./chunk-L3JWI7WX.js";
+} from "./chunk-QOKAKDPE.js";
 import {
   buildTombstoneRecord
 } from "./chunk-GBRG75BQ.js";

package/{chunk-WHVQA7PJ.js → chunk-SCBBGS2N.js}

@@ -432,11 +432,18 @@ function createRunActivityTracker(runId, deps = {}, options = {}) {
   }
   function doWrite() {
     writeTimer = void 0;
-    const record = readRunRecord(runId, deps);
-    if (!record) return;
-    const activity = serializeActivity();
-    writeRunRecord({ ...record, activity }, deps);
-    lastWriteAt = now().getTime();
+    withRunRecordLock(
+      runId,
+      deps,
+      () => {
+        const record = readRunRecord(runId, deps);
+        if (!record) return;
+        const activity = serializeActivity();
+        writeRunRecord({ ...record, activity }, deps);
+        lastWriteAt = now().getTime();
+      },
+      { strict: true }
+    );
   }
   function scheduleWrite() {
     if (writeTimer !== void 0) return;
@@ -498,6 +505,16 @@ function readRunRecord(runId, deps = {}) {
   }
   return null;
 }
+function backfillRunRecordParentDialog(runId, parentDialogId, deps = {}) {
+  if (!parentDialogId) return false;
+  const updated = withRunRecordLock(runId, deps, () => {
+    const record = readRunRecord(runId, deps);
+    if (!record || record.parentDialogId) return false;
+    writeRunRecord({ ...record, parentDialogId }, deps);
+    return true;
+  });
+  return updated === true;
+}
 function listRunRecords(deps = {}) {
   const fs = deps.fs ?? nodeFs;
   const dir = resolveRunsDir(deps.env, deps.homedir);
@@ -1391,6 +1408,7 @@ export {
   writeRunRecord,
   createRunActivityTracker,
   readRunRecord,
+  backfillRunRecordParentDialog,
   listRunRecords,
   findRunRecordByPid,
   findRunRecord,

package/chunk-SGSJBBKP.js

@@ -0,0 +1,297 @@
+import {
+  require_react
+} from "./chunk-YDH3FDFQ.js";
+import {
+  createSpaceKey,
+  normalizeSpaceId
+} from "./chunk-UAD2WT54.js";
+import {
+  toTimestampMs
+} from "./chunk-273FJUYI.js";
+import {
+  fetchFromServer,
+  getAllServers
+} from "./chunk-QOKAKDPE.js";
+import {
+  isTombstoneRecord
+} from "./chunk-GBRG75BQ.js";
+import {
+  __toESM
+} from "./chunk-4VNS5WPM.js";
+
+// packages/create/space/spaceMembershipStore.ts
+var import_react = __toESM(require_react(), 1);
+var createInitialState = () => ({
+  memberSpaces: null,
+  loading: false,
+  membershipStatus: "idle",
+  initialized: false
+});
+var state = createInitialState();
+var listeners = /* @__PURE__ */ new Set();
+var version = 0;
+var notify = () => {
+  version += 1;
+  for (const listener of listeners) {
+    try {
+      listener();
+    } catch {
+    }
+  }
+};
+var getMembershipUpdatedAt = (space) => {
+  if (!space) return 0;
+  return toTimestampMs(
+    space.spaceUpdatedAt ?? space.memberUpdatedAt ?? space.updatedAt ?? space.createdAt ?? space.joinedAt
+  );
+};
+function dedupeMemberSpacesById(memberSpaces) {
+  const membershipMap = /* @__PURE__ */ new Map();
+  memberSpaces.forEach((space) => {
+    const prev = membershipMap.get(space.spaceId);
+    if (!prev || getMembershipUpdatedAt(space) >= getMembershipUpdatedAt(prev)) {
+      membershipMap.set(space.spaceId, space);
+    }
+  });
+  return Array.from(membershipMap.values());
+}
+function getMemberSpaces() {
+  return state.memberSpaces;
+}
+function getAllMemberSpaces() {
+  const memberSpaces = dedupeMemberSpacesById(state.memberSpaces || []);
+  return [...memberSpaces].sort((a, b) => {
+    return getMembershipUpdatedAt(b) - getMembershipUpdatedAt(a);
+  });
+}
+function setMemberSpaces(spaces) {
+  state = {
+    ...state,
+    memberSpaces: spaces,
+    loading: false,
+    error: void 0,
+    membershipStatus: "fresh",
+    initialized: true
+  };
+  notify();
+}
+function setMembershipLoading() {
+  state = { ...state, loading: true, membershipStatus: "loading" };
+  notify();
+}
+function setMembershipRejected(errorMessage, isRemoteUnavailable) {
+  const membershipStatus = isRemoteUnavailable ? "offline" : state.membershipStatus === "loading" ? "idle" : state.membershipStatus;
+  state = {
+    ...state,
+    loading: false,
+    error: errorMessage,
+    membershipStatus
+  };
+  notify();
+}
+function hydrateMemberSpacesFromLocal(spaces) {
+  if (state.memberSpaces !== null || spaces.length === 0) return;
+  state = {
+    ...state,
+    memberSpaces: dedupeMemberSpacesById(spaces),
+    loading: false
+  };
+  notify();
+}
+function appendRecoveredMemberships(recovered) {
+  if (!recovered || recovered.length === 0) return;
+  if (state.memberSpaces === null) {
+    state = {
+      ...state,
+      memberSpaces: dedupeMemberSpacesById(recovered)
+    };
+    notify();
+    return;
+  }
+  state = {
+    ...state,
+    memberSpaces: dedupeMemberSpacesById([
+      ...state.memberSpaces,
+      ...recovered
+    ]).sort((a, b) => toTimestampMs(b.joinedAt) - toTimestampMs(a.joinedAt))
+  };
+  notify();
+}
+function setSpaceInitialized() {
+  state = { ...state, initialized: true };
+  notify();
+}
+function setMembershipLoaded() {
+  state = { ...state, loading: false, error: void 0 };
+  notify();
+}
+function addMemberSpace(space) {
+  const existing = state.memberSpaces || [];
+  state = {
+    ...state,
+    memberSpaces: dedupeMemberSpacesById([...existing, space])
+  };
+  notify();
+}
+function removeMemberSpace(spaceId) {
+  if (!state.memberSpaces) return;
+  const normalized = normalizeSpaceId(spaceId);
+  state = {
+    ...state,
+    memberSpaces: state.memberSpaces.filter(
+      (s) => normalizeSpaceId(s.spaceId) !== normalized
+    )
+  };
+  notify();
+}
+function updateMemberSpaceName(spaceId, name) {
+  if (!state.memberSpaces || !name) return;
+  state = {
+    ...state,
+    memberSpaces: state.memberSpaces.map(
+      (space) => space.spaceId === spaceId ? { ...space, spaceName: name } : space
+    )
+  };
+  notify();
+}
+
+// packages/create/space/spaceAccess.ts
+var resolveSpaceRemoteServers = (state2) => {
+  const currentServer = typeof state2?.settings?.currentServer === "string" ? state2.settings.currentServer : void 0;
+  const syncServers = Array.isArray(state2?.settings?.syncServers) ? state2.settings.syncServers : void 0;
+  return getAllServers(currentServer, syncServers);
+};
+var selectSpaceRemoteAuth = (state2) => ({
+  token: state2?.auth?.currentToken ?? null,
+  userId: state2?.auth?.currentUser?.userId ?? null,
+  servers: resolveSpaceRemoteServers(state2)
+});
+var spaceListsUser = (spaceData, userId) => {
+  if (!spaceData || isTombstoneRecord(spaceData)) return false;
+  if (spaceData.ownerId === userId) return true;
+  return Array.isArray(spaceData.members) && spaceData.members.includes(userId);
+};
+var membershipBelongsToUser = (membership, userId) => !membership.userId || membership.userId === userId;
+var membershipFetchCache = /* @__PURE__ */ new Map();
+var MEMBERSHIP_FETCH_CACHE_TTL_MS = 3e4;
+async function fetchMembershipsFromServer(server, token, userId, timeoutMs) {
+  if (!token) return { ok: false, memberships: [] };
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(`${server}/rpc/getUserSpaceMemberships`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ userId }),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      console.error(
+        `Failed to fetch memberships from ${server}: ${response.statusText}`
+      );
+      return { ok: false, memberships: [] };
+    }
+    const data = await response.json();
+    return {
+      ok: true,
+      server,
+      memberships: Array.isArray(data) ? data : []
+    };
+  } catch (error) {
+    clearTimeout(timeoutId);
+    console.error(`Error fetching memberships from ${server}:`, error);
+    return { ok: false, memberships: [] };
+  }
+}
+var fetchRemoteUserSpaceMemberships = (server, token, userId, timeoutMs = 5e3) => {
+  const cacheKey = `${server}|${userId}`;
+  const cached = membershipFetchCache.get(cacheKey);
+  if (cached) return cached;
+  const promise = fetchMembershipsFromServer(server, token, userId, timeoutMs);
+  membershipFetchCache.set(cacheKey, promise);
+  promise.catch(() => {
+  }).finally(() => {
+    setTimeout(() => {
+      if (membershipFetchCache.get(cacheKey) === promise) {
+        membershipFetchCache.delete(cacheKey);
+      }
+    }, MEMBERSHIP_FETCH_CACHE_TTL_MS);
+  });
+  return promise;
+};
+var fetchRemoteSpace = async (server, token, spaceId) => {
+  try {
+    const space = await fetchFromServer(
+      server,
+      createSpaceKey.space(normalizeSpaceId(spaceId)),
+      token ?? void 0
+    );
+    return space && typeof space === "object" ? space : null;
+  } catch {
+    return null;
+  }
+};
+var hasActiveRemoteMembership = async (server, token, userId, spaceId) => {
+  const result = await fetchRemoteUserSpaceMemberships(server, token, userId);
+  if (!result.ok) return false;
+  const normalizedSpaceId = normalizeSpaceId(spaceId);
+  return result.memberships.some((membership) => {
+    const membershipSpaceId = typeof membership?.spaceId === "string" ? normalizeSpaceId(membership.spaceId) : "";
+    return membershipSpaceId === normalizedSpaceId && membershipBelongsToUser(membership, userId) && !isTombstoneRecord(membership);
+  });
+};
+var fetchAuthoritativeRemoteSpace = async ({
+  servers,
+  token,
+  userId,
+  spaceId
+}) => {
+  const normalizedSpaceId = normalizeSpaceId(spaceId);
+  for (const server of servers) {
+    const space = await fetchRemoteSpace(server, token, normalizedSpaceId);
+    if (!space) continue;
+    if (!spaceListsUser(space, userId)) {
+      throw new Error(`Current user is not a member of space: ${normalizedSpaceId}`);
+    }
+    if (space.ownerId !== userId) {
+      const hasMembership = await hasActiveRemoteMembership(
+        server,
+        token,
+        userId,
+        normalizedSpaceId
+      );
+      if (!hasMembership) {
+        throw new Error(
+          `Current user has no active membership for space: ${normalizedSpaceId}`
+        );
+      }
+    }
+    return space;
+  }
+  return null;
+};
+
+export {
+  selectSpaceRemoteAuth,
+  spaceListsUser,
+  membershipBelongsToUser,
+  fetchRemoteUserSpaceMemberships,
+  fetchRemoteSpace,
+  fetchAuthoritativeRemoteSpace,
+  getMemberSpaces,
+  getAllMemberSpaces,
+  setMemberSpaces,
+  setMembershipLoading,
+  setMembershipRejected,
+  hydrateMemberSpacesFromLocal,
+  appendRecoveredMemberships,
+  setSpaceInitialized,
+  setMembershipLoaded,
+  addMemberSpace,
+  removeMemberSpace,
+  updateMemberSpaceName
+};

package/{chunk-GFUOVFQA.js → chunk-TUBNQ3OF.js}

@@ -1,6 +1,6 @@
 import {
   clearCliLocalRuntimePreparedAgentCache
-} from "./chunk-QUCSAM43.js";
+} from "./chunk-EAYBPWHX.js";
 import {
   getReadableCliDb
 } from "./chunk-43CXXVJD.js";
@@ -12,7 +12,7 @@ import {
   resolveAgentRecordFromHybridStore,
   sanitizeAgentRecordForCliOutput,
   writeAgentRecord
-} from "./chunk-DQLYEGP7.js";
+} from "./chunk-EGVY3GMT.js";
 import {
   resolveCliAgentKeyInput
 } from "./chunk-EKLRRZIN.js";

package/{chunk-BANYWEYY.js → chunk-TY3ADTX5.js}

@@ -1,6 +1,6 @@
 import {
   getActiveDialogKey
-} from "./chunk-MRWGHF56.js";
+} from "./chunk-6YTOJY35.js";
 import {
   compactWhitespace
 } from "./chunk-DWLEOOGR.js";

package/chunk-UAD2WT54.js

@@ -0,0 +1,64 @@
+// packages/create/space/spaceKeys.ts
+var SEPARATOR = "-";
+var SPACE_PREFIX = "space";
+var SPACE_PREFIX_WITH_SEPARATOR = `${SPACE_PREFIX}${SEPARATOR}`;
+var normalizeSpaceId = (spaceId) => {
+  if (!spaceId) return spaceId;
+  return spaceId.startsWith(SPACE_PREFIX_WITH_SEPARATOR) ? spaceId.slice(SPACE_PREFIX_WITH_SEPARATOR.length) : spaceId;
+};
+var createSpaceKey = {
+  // 空间基础信息的key
+  space: (spaceId) => {
+    return [SPACE_PREFIX, normalizeSpaceId(spaceId)].join(SEPARATOR);
+  },
+  // 空间成员的key
+  member: (userId, spaceId) => {
+    return [SPACE_PREFIX, "member", userId, normalizeSpaceId(spaceId)].join(
+      SEPARATOR
+    );
+  },
+  // 查询用户所在的所有空间的范围
+  memberRange: (userId) => {
+    return {
+      start: [SPACE_PREFIX, "member", userId, ""].join(SEPARATOR),
+      end: [SPACE_PREFIX, "member", userId, "\uFFFF"].join(SEPARATOR)
+    };
+  },
+  /**
+   * 预留：未来若出现“按用户、按空间、且必须跨设备同步”的空间级偏好，
+   * 统一使用这个 key family。当前产品主链不要依赖它。
+   */
+  setting: (userId, spaceId) => {
+    return [SPACE_PREFIX, "setting", userId, normalizeSpaceId(spaceId)].join(
+      SEPARATOR
+    );
+  },
+  /**
+   * 预留：未来如确实需要批量读取空间级远端偏好，再使用这个范围。
+   */
+  settingRange: (userId) => {
+    return {
+      start: [SPACE_PREFIX, "setting", userId, ""].join(SEPARATOR),
+      end: [SPACE_PREFIX, "setting", userId, "\uFFFF"].join(SEPARATOR)
+    };
+  },
+  // 从成员key中提取空间key
+  // 成员 key 格式: space-member-{userId}-{spaceId}
+  // userId 是单段（无连字符），spaceId 是 ULID（无连字符）
+  spaceFromMember: (memberKey) => {
+    const parts = memberKey.split(SEPARATOR);
+    if (parts.length < 4) return "";
+    const spaceId = parts[parts.length - 1];
+    return [SPACE_PREFIX, spaceId].join(SEPARATOR);
+  },
+  // 从成员key中提取空间ID
+  spaceIdFromMember: (memberKey) => {
+    const parts = memberKey.split(SEPARATOR);
+    return parts.length >= 4 ? parts[parts.length - 1] : "";
+  }
+};
+
+export {
+  normalizeSpaceId,
+  createSpaceKey
+};

package/{chunk-SW7RCUGA.js → chunk-UEV5WVQV.js}

@@ -1,12 +1,12 @@
 import {
   MODEL_LOOKUP_MAP
-} from "./chunk-QDHZCAH3.js";
+} from "./chunk-KNQ5LYVZ.js";
 import {
   ALL_MODELS
-} from "./chunk-56W233KG.js";
+} from "./chunk-YWY25N4V.js";
 import {
   PUBLIC_DEEPSEEK_V4_FLASH_AGENT_KEY
-} from "./chunk-2JYSSXLY.js";
+} from "./chunk-EJFW7TRP.js";
 
 // packages/ai/llm/getModelContextWindow.ts
 var DEFAULT_CONTEXT_WINDOW = 256e3;