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

package/chunk-GAKEBQD6.js

@@ -0,0 +1,30 @@
+// packages/core/retryAfterMs.ts
+function normalizeNonNegativeMs(value, fallbackMs) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed >= 0 ? Math.round(parsed) : Math.round(Number(fallbackMs)) || 0;
+}
+function parseRetryAfterHeaderMs(value, nowMs = Date.now()) {
+  if (typeof value !== "string" || !value.trim()) return null;
+  const trimmed = value.trim();
+  const seconds = Number(trimmed);
+  if (Number.isFinite(seconds)) {
+    if (seconds < 0) return null;
+    return Math.round(seconds * 1e3);
+  }
+  const parsedDateMs = Date.parse(trimmed);
+  if (Number.isFinite(parsedDateMs)) {
+    return Math.max(0, parsedDateMs - nowMs);
+  }
+  return null;
+}
+
+// packages/core/gatewayHttpStatus.ts
+function isGatewayHttpStatus(status) {
+  return status === 502 || status === 503 || status === 504;
+}
+
+export {
+  normalizeNonNegativeMs,
+  parseRetryAfterHeaderMs,
+  isGatewayHttpStatus
+};

package/chunk-GBRG75BQ.js

@@ -0,0 +1,86 @@
+import {
+  asOptionalPositiveFiniteNumber
+} from "./chunk-U6VC4MU4.js";
+
+// packages/database/tombstones.ts
+var TOMBSTONE_DETAIL_RETENTION_MS = 90 * 24 * 60 * 60 * 1e3;
+var isRecord = (value) => value !== null && typeof value === "object";
+var readRecord = (value) => isRecord(value) ? value : null;
+var parseTimestamp = (value) => {
+  const asNumber = asOptionalPositiveFiniteNumber(value);
+  if (asNumber !== void 0) return asNumber;
+  if (typeof value === "string" && value.trim()) {
+    return asOptionalPositiveFiniteNumber(Date.parse(value)) ?? 0;
+  }
+  return 0;
+};
+var getRecordTimestamp = (record) => {
+  const value = readRecord(record);
+  if (!value) return 0;
+  const candidates = [
+    value.updatedAt,
+    value.updated_at,
+    value.createdAt,
+    value.created,
+    isRecord(value.meta) ? value.meta.createdAt : void 0
+  ];
+  for (const candidate of candidates) {
+    const timestamp = parseTimestamp(candidate);
+    if (timestamp > 0) return timestamp;
+  }
+  return 0;
+};
+var getTombstoneTimestamp = (record) => {
+  const value = readRecord(record);
+  if (!value) return 0;
+  return parseTimestamp(value.deletedAt) || getRecordTimestamp(value);
+};
+var getRestoreTimestamp = (record) => {
+  const value = readRecord(record);
+  if (!value) return 0;
+  return parseTimestamp(value.restoredAt);
+};
+var isTombstoneRecord = (record) => {
+  const value = readRecord(record);
+  if (!value) return false;
+  const deletedAt = value.deletedAt;
+  if (typeof deletedAt === "string") return deletedAt.trim().length > 0;
+  return Boolean(deletedAt);
+};
+var isRestoredAfterTombstone = (activeRecord, tombstoneRecord) => {
+  if (isTombstoneRecord(activeRecord) || !isTombstoneRecord(tombstoneRecord)) {
+    return false;
+  }
+  const restoreTs = getRestoreTimestamp(activeRecord);
+  const tombstoneTs = getTombstoneTimestamp(tombstoneRecord);
+  return restoreTs > 0 && tombstoneTs > 0 && restoreTs > tombstoneTs;
+};
+var shouldReplaceWithNextRecord = (nextRecord, currentRecord) => {
+  const nextIsTombstone = isTombstoneRecord(nextRecord);
+  const currentIsTombstone = isTombstoneRecord(currentRecord);
+  if (currentIsTombstone && !nextIsTombstone) {
+    return isRestoredAfterTombstone(nextRecord, currentRecord);
+  }
+  if (nextIsTombstone && !currentIsTombstone) {
+    return !isRestoredAfterTombstone(currentRecord, nextRecord);
+  }
+  const nextTs = nextIsTombstone ? getTombstoneTimestamp(nextRecord) : getRecordTimestamp(nextRecord);
+  const currentTs = currentIsTombstone ? getTombstoneTimestamp(currentRecord) : getRecordTimestamp(currentRecord);
+  if (nextTs !== currentTs) return nextTs > currentTs;
+  return nextIsTombstone && !currentIsTombstone;
+};
+var buildTombstoneRecord = (record, nowIso) => {
+  const { restoredAt: _restoredAt, ...baseRecord } = record;
+  return {
+    ...baseRecord,
+    deletedAt: nowIso,
+    updatedAt: nowIso
+  };
+};
+
+export {
+  getRecordTimestamp,
+  isTombstoneRecord,
+  shouldReplaceWithNextRecord,
+  buildTombstoneRecord
+};

package/chunk-GEKCOPTN.js

@@ -0,0 +1,190 @@
+import {
+  deleteDbRecord,
+  queryUserRecords,
+  readDbRecord
+} from "./chunk-6PWWWMI7.js";
+import {
+  mergeAndDedupUserData
+} from "./chunk-KQHGZWSV.js";
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
+import {
+  isTombstoneRecord
+} from "./chunk-GBRG75BQ.js";
+
+// packages/cli/globalRecordOperations.ts
+async function listUserRecordsFromServers(args) {
+  const remoteResults = [];
+  const failures = [];
+  const promises = args.serverUrls.map(async (serverUrl) => {
+    try {
+      const records = await queryUserRecords({
+        authToken: args.authToken,
+        fallbackFetchImpl: args.fallbackFetchImpl,
+        fetchImpl: args.fetchImpl,
+        includeDeleted: true,
+        limit: args.limit,
+        serverUrl,
+        summary: args.summary,
+        type: args.type,
+        userId: args.userId
+      });
+      return { ok: true, serverUrl, records };
+    } catch (error) {
+      return {
+        ok: false,
+        serverUrl,
+        error: toErrorMessage(error)
+      };
+    }
+  });
+  const results = await Promise.all(promises);
+  for (const res of results) {
+    if (res.ok) {
+      remoteResults.push({
+        data: {
+          data: res.records.map((record) => ({
+            ...record,
+            serverOrigin: typeof record?.serverOrigin === "string" && record.serverOrigin.trim() ? record.serverOrigin : res.serverUrl
+          }))
+        }
+      });
+    } else {
+      failures.push({
+        serverUrl: res.serverUrl,
+        error: res.error
+      });
+    }
+  }
+  if (remoteResults.length === 0 && failures.length > 0) {
+    const label = args.label ?? "record query";
+    throw new Error(
+      `${label} failed on all candidate servers: ${failures.map((failure) => `${failure.serverUrl}: ${failure.error}`).join("; ")}`
+    );
+  }
+  const merged = mergeAndDedupUserData([], remoteResults, { includeDeleted: true });
+  return {
+    records: merged.filter((record) => !isTombstoneRecord(record)),
+    failures
+  };
+}
+async function readDbRecordFromServers(args) {
+  const failures = [];
+  for (const serverUrl of args.serverUrls) {
+    try {
+      const record = await readDbRecord({
+        authToken: args.authToken,
+        dbKey: args.dbKey,
+        fallbackFetchImpl: args.fallbackFetchImpl,
+        fetchImpl: args.fetchImpl,
+        includeDeleted: args.includeDeleted,
+        serverUrl
+      });
+      return { record, serverUrl, failures };
+    } catch (error) {
+      failures.push({
+        serverUrl,
+        error: toErrorMessage(error)
+      });
+    }
+  }
+  const label = args.label ?? `record ${args.dbKey}`;
+  throw new Error(
+    `${label} is unreadable on all candidate servers: ${failures.map((failure) => `${failure.serverUrl}: ${failure.error}`).join("; ")}`
+  );
+}
+async function readDbRecordVersionsFromServers(args) {
+  const records = [];
+  const failures = [];
+  const promises = args.serverUrls.map(async (serverUrl) => {
+    try {
+      const record = await readDbRecord({
+        authToken: args.authToken,
+        dbKey: args.dbKey,
+        fallbackFetchImpl: args.fallbackFetchImpl,
+        fetchImpl: args.fetchImpl,
+        includeDeleted: true,
+        serverUrl
+      });
+      return { ok: true, serverUrl, record };
+    } catch (error) {
+      return {
+        ok: false,
+        serverUrl,
+        error: toErrorMessage(error)
+      };
+    }
+  });
+  const results = await Promise.all(promises);
+  for (const res of results) {
+    if (res.ok) {
+      const record = res.record;
+      records.push({
+        ...record,
+        dbKey: typeof record?.dbKey === "string" && record.dbKey.trim() ? record.dbKey : args.dbKey,
+        serverOrigin: typeof record?.serverOrigin === "string" && record.serverOrigin.trim() ? record.serverOrigin : res.serverUrl
+      });
+    } else {
+      failures.push({
+        serverUrl: res.serverUrl,
+        error: res.error
+      });
+    }
+  }
+  return { records, failures };
+}
+async function readLiveDbRecordAfterTombstoneMerge(args) {
+  const result = await readDbRecordVersionsFromServers(args);
+  const merged = mergeAndDedupUserData(
+    [],
+    [{ data: { data: result.records } }],
+    { includeDeleted: true }
+  );
+  const record = merged.find((item) => item?.dbKey === args.dbKey);
+  if (record && !isTombstoneRecord(record)) {
+    return {
+      record,
+      serverUrl: typeof record.serverOrigin === "string" ? record.serverOrigin : "",
+      failures: result.failures
+    };
+  }
+  const label = args.label ?? `record ${args.dbKey}`;
+  const failureText = result.failures.length ? ` Failures: ${result.failures.map((failure) => `${failure.serverUrl}: ${failure.error}`).join("; ")}` : "";
+  throw new Error(`${label} is deleted or unreadable after global tombstone merge.${failureText}`);
+}
+async function deleteDbRecordOnServers(args) {
+  return deleteDbRecordOnTargets({
+    ...args,
+    targets: args.serverUrls.map((serverUrl) => ({ serverUrl }))
+  });
+}
+async function deleteDbRecordOnTargets(args) {
+  const promises = args.targets.map(async (target) => {
+    try {
+      const result = await deleteDbRecord({
+        authToken: target.authToken ?? args.authToken,
+        dbKey: args.dbKey,
+        deleteOptions: args.deleteOptions,
+        fallbackFetchImpl: args.fallbackFetchImpl,
+        fetchImpl: args.fetchImpl,
+        serverUrl: target.serverUrl
+      });
+      return { serverUrl: target.serverUrl, ok: true, result };
+    } catch (error) {
+      return {
+        serverUrl: target.serverUrl,
+        ok: false,
+        error: toErrorMessage(error)
+      };
+    }
+  });
+  return Promise.all(promises);
+}
+
+export {
+  listUserRecordsFromServers,
+  readDbRecordFromServers,
+  readLiveDbRecordAfterTombstoneMerge,
+  deleteDbRecordOnServers
+};

package/chunk-H2RMRZJE.js

@@ -0,0 +1,113 @@
+import {
+  createSpaceKey
+} from "./chunk-UAD2WT54.js";
+import {
+  patch,
+  read
+} from "./chunk-G5H7RNFL.js";
+import {
+  DEVICE_LOCAL_OWNER_ID,
+  isDeviceLocalSpaceBody,
+  selectIdentityUserId
+} from "./chunk-EYEEHCU4.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 localSpaceAuthorityPatchStamp = (spaceData) => isDeviceLocalSpaceBody(spaceData) ? { userId: DEVICE_LOCAL_OWNER_ID } : {};
+
+// packages/create/space/constants.ts
+var UNCATEGORIZED_ID = "__uncategorized_container__";
+
+// 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);
+  if (spaceData.contents && spaceData.contents[contentKey]) {
+    throw new Error(`\u5185\u5BB9\u952E "${contentKey}" \u5DF2\u5B58\u5728\u3002`);
+  }
+  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 changes = {
+    contents: { [contentKey]: newSpaceContent },
+    updatedAt: now,
+    ...localSpaceAuthorityPatchStamp(spaceData)
+  };
+  const updatedSpaceData = await dispatch(
+    patch({ dbKey: spaceKey, changes })
+  ).unwrap();
+  return { spaceId, updatedSpaceData };
+};
+
+export {
+  checkSpaceMembership,
+  localSpaceAuthorityPatchStamp,
+  UNCATEGORIZED_ID,
+  addContentAction
+};

package/chunk-H33743XH.js

@@ -0,0 +1,25 @@
+import {
+  resolveNoloHome
+} from "./chunk-LM6IYQ3F.js";
+
+// packages/cli/localRuntimeDb.ts
+import path from "node:path";
+function resolveCliLocalRuntimeDbPath(options = {}) {
+  return path.join(resolveNoloHome(options), "data", "leveldb");
+}
+function buildCliLocalRuntimeDbEnv(env = process.env) {
+  return {
+    ...env,
+    NOLO_SERVER_DB_PATH: env.NOLO_SERVER_DB_PATH?.trim() || resolveCliLocalRuntimeDbPath({ env })
+  };
+}
+async function getDefaultCliLocalRuntimeDb(options = {}) {
+  const { getDefaultCliLocalRuntimeDb: getAuthorityBackedDb } = await import("./localRuntimeAuthority-TEGCOWX4.js");
+  return getAuthorityBackedDb(options);
+}
+
+export {
+  resolveCliLocalRuntimeDbPath,
+  buildCliLocalRuntimeDbEnv,
+  getDefaultCliLocalRuntimeDb
+};

package/chunk-HEIIIZBX.js

@@ -0,0 +1,104 @@
+import {
+  createMemoryKey,
+  memoryOwnerRange,
+  memorySubjectKindRange
+} from "./chunk-PN7AFLOK.js";
+
+// packages/ai/memory/queryShared.ts
+var chooseMemoryOwners = (input) => {
+  const owners = [];
+  if (input.userId) {
+    owners.push({ ownerType: "user", ownerId: input.userId });
+  }
+  if (input.spaceId) {
+    owners.push({ ownerType: "space", ownerId: input.spaceId });
+  }
+  return owners;
+};
+var loadOwnerItemsFromDb = async (db, owner, limit) => {
+  const range = memoryOwnerRange(owner.ownerType, owner.ownerId);
+  const refs = [];
+  for await (const [, value] of db.iterator({
+    gte: range.start,
+    lte: range.end,
+    reverse: true
+  })) {
+    refs.push(value ?? {});
+    if (refs.length >= limit) break;
+  }
+  const items = await Promise.all(
+    refs.map(
+      (ref) => typeof ref?.memoryId === "string" ? db.get(createMemoryKey(owner.ownerType, owner.ownerId, ref.memoryId)).catch(() => null) : Promise.resolve(null)
+    )
+  );
+  return items.filter((item) => !!item);
+};
+var loadSubjectKindItemsFromDb = async (db, subject, kind, limit) => {
+  const range = memorySubjectKindRange(subject.subjectType, subject.subjectId, kind);
+  const refs = [];
+  for await (const [, value] of db.iterator({
+    gte: range.start,
+    lte: range.end,
+    reverse: true
+  })) {
+    refs.push(value ?? {});
+    if (refs.length >= limit) break;
+  }
+  const items = await Promise.all(
+    refs.map(
+      (ref) => typeof ref?.memoryKey === "string" ? db.get(ref.memoryKey).catch(() => null) : Promise.resolve(null)
+    )
+  );
+  return items.filter((item) => !!item);
+};
+var loadMemoryCandidatesFromDb = async (db, input) => {
+  const kinds = input.kinds ?? ["episodic", "semantic", "procedural"];
+  const ownerLimit = input.ownerLimit ?? 12;
+  const ownerFallback = input.ownerFallback ?? "onSubjectMiss";
+  const ownerKeySet = new Set(
+    input.owners.filter((owner) => owner.ownerId).map((owner) => `${owner.ownerType}:${owner.ownerId}`)
+  );
+  const subjects = input.subjects.filter(
+    (subject) => !!subject.subjectId
+  );
+  const subjectResults = subjects.length > 0 ? await Promise.all(
+    subjects.flatMap(
+      (subject) => kinds.map(
+        (kind) => loadSubjectKindItemsFromDb(db, subject, kind, ownerLimit)
+      )
+    )
+  ) : [];
+  const subjectHitCount = subjectResults.reduce((sum, items) => sum + items.length, 0);
+  const shouldLoadOwnerFallback = ownerFallback !== "never" && (subjects.length === 0 || subjectHitCount === 0 || ownerFallback === "always");
+  const results = shouldLoadOwnerFallback ? await Promise.all(
+    [
+      ...subjectResults,
+      ...input.owners.map((owner) => loadOwnerItemsFromDb(db, owner, ownerLimit))
+    ]
+  ) : subjectResults;
+  const kindSet = new Set(kinds);
+  const seen = /* @__PURE__ */ new Set();
+  const merged = [];
+  for (const items of results) {
+    for (const item of items) {
+      if (seen.has(item.id)) continue;
+      if (!kindSet.has(item.kind)) continue;
+      if (ownerKeySet.size > 0 && !ownerKeySet.has(`${item.ownerType}:${item.ownerId}`)) {
+        continue;
+      }
+      if (!shouldLoadOwnerFallback && subjects.length > 0 && !subjects.some(
+        (subject) => subject.subjectType === item.subjectType && subject.subjectId === item.subjectId
+      )) {
+        continue;
+      }
+      seen.add(item.id);
+      merged.push(item);
+    }
+  }
+  return merged;
+};
+
+export {
+  chooseMemoryOwners,
+  loadMemoryCandidatesFromDb
+};

package/chunk-HNMXYYJR.js

@@ -0,0 +1,12 @@
+// packages/core/errorMessage.ts
+function toErrorMessage(error) {
+  if (error instanceof Error) return error.message;
+  if (error !== null && typeof error === "object" && "message" in error && typeof error.message === "string") {
+    return error.message;
+  }
+  return String(error);
+}
+
+export {
+  toErrorMessage
+};