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

package/chunk-ELRRLDWI.js

@@ -0,0 +1,478 @@
+import {
+  getRuntimeServerContext,
+  partitionReadServers,
+  pickBestSettledRemoteRecord,
+  planAuthorityReadServers,
+  resolveRecordAuthority,
+  scheduleExistingRecordReplication,
+  shouldReplaceLocalWithRemoteRecord,
+  shouldReplicateLocalRecord
+} from "./chunk-EYEEHCU4.js";
+import {
+  fetchFromClientDb,
+  fetchFromServer,
+  isAbortError,
+  isReadTimeoutError,
+  logger
+} from "./chunk-QYXLLLGL.js";
+import {
+  shouldReplaceWithNextRecord
+} from "./chunk-GBRG75BQ.js";
+import {
+  NOLO_CLUSTER_SERVERS,
+  normalizeKnownServerOrigin
+} from "./chunk-LCBAMY2M.js";
+import {
+  normalizeServerOrigin
+} from "./chunk-CF7PE763.js";
+
+// packages/core/builtinAgents.ts
+var BUILTIN_NOLO_AGENT_KEY = "agent-pub-01NOLOAPPBLD000000019KCKT0";
+var BUILTIN_APP_BUILDER_AGENT_KEY = "agent-pub-01APPBUILDER00000001YAII3I";
+var BUILTIN_ECOMMERCE_AGENT_KEY = "agent-pub-01ECOMMERCEAG00000001PYQ2J";
+var BUILTIN_AGENT_CREATOR_AGENT_KEY = "agent-pub-01NOLOAGENTCRT000000000001";
+var BUILTIN_FEEDBACK_AGENT_KEY = "agent-pub-01NOLOFEEDBACKA000000000R2";
+var BUILTIN_CHROME_OPERATOR_AGENT_KEY = "agent-pub-01CHROMEOPR000000000001";
+var PUBLIC_DEEPSEEK_V4_FLASH_AGENT_ID = "01DSV4FLASHPB00000000JFPFD";
+var PUBLIC_DEEPSEEK_V4_FLASH_AGENT_KEY = `agent-pub-${PUBLIC_DEEPSEEK_V4_FLASH_AGENT_ID}`;
+var PUBLIC_DEEPSEEK_V4_PRO_AGENT_ID = "01DSV4PROPUB00000001A9OLZN";
+var PUBLIC_DEEPSEEK_V4_PRO_AGENT_KEY = `agent-pub-${PUBLIC_DEEPSEEK_V4_PRO_AGENT_ID}`;
+var PUBLIC_KIMI_K27_CODING_AGENT_ID = "01KIMIK27CODEOL000000001";
+var PUBLIC_KIMI_K27_CODING_AGENT_KEY = `agent-pub-${PUBLIC_KIMI_K27_CODING_AGENT_ID}`;
+var PUBLIC_GLM_52_AGENT_ID = "01GLM52CHAT00000000001U721";
+var PUBLIC_GLM_52_AGENT_KEY = `agent-pub-${PUBLIC_GLM_52_AGENT_ID}`;
+var PUBLIC_KIMI_K26_IMAGE_AGENT_ID = "01KIMIK26OLLAMA0000000001";
+var PUBLIC_KIMI_K26_IMAGE_AGENT_KEY = `agent-pub-${PUBLIC_KIMI_K26_IMAGE_AGENT_ID}`;
+var BUILTIN_PLATFORM_AGENT_KEYS = [
+  BUILTIN_NOLO_AGENT_KEY,
+  BUILTIN_APP_BUILDER_AGENT_KEY,
+  BUILTIN_ECOMMERCE_AGENT_KEY,
+  BUILTIN_AGENT_CREATOR_AGENT_KEY,
+  BUILTIN_FEEDBACK_AGENT_KEY,
+  BUILTIN_CHROME_OPERATOR_AGENT_KEY
+];
+var BUILTIN_PLATFORM_AGENT_KEY_SET = new Set(BUILTIN_PLATFORM_AGENT_KEYS);
+
+// packages/database/actions/agentReadResolution.ts
+var BUILTIN_PLATFORM_AGENT_KEYS2 = [
+  ...BUILTIN_PLATFORM_AGENT_KEYS
+];
+var BUILTIN_PLATFORM_AGENT_KEY_SET2 = new Set(
+  BUILTIN_PLATFORM_AGENT_KEYS2
+);
+var normalizeServer = (server) => normalizeKnownServerOrigin(server) ?? normalizeServerOrigin(server);
+var isBuiltinPlatformAgentKey = (dbKey) => typeof dbKey === "string" && BUILTIN_PLATFORM_AGENT_KEY_SET2.has(dbKey);
+var resolveAgentReadServers = ({
+  dbKey,
+  configuredServers
+}) => {
+  const normalized = configuredServers.map(normalizeServer);
+  if (!isBuiltinPlatformAgentKey(dbKey)) {
+    return Array.from(new Set(normalized));
+  }
+  return Array.from(/* @__PURE__ */ new Set([...normalized, ...NOLO_CLUSTER_SERVERS]));
+};
+
+// packages/database/actions/readRequestManager.ts
+var DEFAULT_MISS_COOLDOWN_MS = 2e3;
+var DEFAULT_LOCAL_HIT_REVALIDATE_COOLDOWN_MS = 1500;
+var DEFAULT_MISS_CACHE_MAX_SIZE = 1e3;
+var ReadRequestManager = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  inFlightReads = /* @__PURE__ */ new Map();
+  recentMisses = /* @__PURE__ */ new Map();
+  recentLocalHitRevalidations = /* @__PURE__ */ new Map();
+  get missCooldownMs() {
+    return this.options.missCooldownMs ?? DEFAULT_MISS_COOLDOWN_MS;
+  }
+  get missCacheMaxSize() {
+    return this.options.missCacheMaxSize ?? DEFAULT_MISS_CACHE_MAX_SIZE;
+  }
+  get localHitRevalidateCooldownMs() {
+    return this.options.localHitRevalidateCooldownMs ?? DEFAULT_LOCAL_HIT_REVALIDATE_COOLDOWN_MS;
+  }
+  getInFlight(dbKey) {
+    return this.inFlightReads.get(dbKey);
+  }
+  setInFlight(dbKey, promise) {
+    this.inFlightReads.set(dbKey, promise);
+  }
+  clearInFlight(dbKey, promise) {
+    if (this.inFlightReads.get(dbKey) === promise) {
+      this.inFlightReads.delete(dbKey);
+    }
+  }
+  clearMiss(dbKey) {
+    this.recentMisses.delete(dbKey);
+  }
+  getRetryInMs(dbKey, now) {
+    const missUntil = this.recentMisses.get(dbKey);
+    if (typeof missUntil !== "number") return null;
+    if (missUntil <= now) {
+      this.recentMisses.delete(dbKey);
+      return null;
+    }
+    return missUntil - now;
+  }
+  markMiss(dbKey, now, cooldownMs = this.missCooldownMs) {
+    this.recentMisses.set(dbKey, now + cooldownMs);
+    this.cleanupMisses(now);
+  }
+  getLocalHitRevalidateInMs(dbKey, now) {
+    const nextAllowedAt = this.recentLocalHitRevalidations.get(dbKey);
+    if (typeof nextAllowedAt !== "number") return null;
+    if (nextAllowedAt <= now) {
+      this.recentLocalHitRevalidations.delete(dbKey);
+      return null;
+    }
+    return nextAllowedAt - now;
+  }
+  markLocalHitRevalidated(dbKey, now, cooldownMs = this.localHitRevalidateCooldownMs) {
+    this.recentLocalHitRevalidations.set(dbKey, now + cooldownMs);
+    this.cleanupLocalHitRevalidations(now);
+  }
+  cleanupExpiringMap(map, now) {
+    for (const [key, expiresAt] of Array.from(map.entries())) {
+      if (expiresAt <= now) {
+        map.delete(key);
+      }
+    }
+    if (map.size <= this.missCacheMaxSize) return;
+    const overflow = map.size - this.missCacheMaxSize;
+    const keys = Array.from(map.keys());
+    for (let i = 0; i < overflow; i += 1) {
+      const key = keys[i];
+      if (key) map.delete(key);
+    }
+  }
+  cleanupMisses(now) {
+    this.cleanupExpiringMap(this.recentMisses, now);
+  }
+  cleanupLocalHitRevalidations(now) {
+    this.cleanupExpiringMap(this.recentLocalHitRevalidations, now);
+  }
+  // test helper
+  getMissCacheSize() {
+    return this.recentMisses.size;
+  }
+  // test helper
+  getLocalHitRevalidationCacheSize() {
+    return this.recentLocalHitRevalidations.size;
+  }
+};
+var readRequestManager = new ReadRequestManager();
+
+// packages/database/actions/read.ts
+var updateClientDbIfNewer = async (clientDb, dbKey, remoteData, localData) => {
+  if (!clientDb) return;
+  try {
+    if (isRemoteDataNewer(remoteData, localData)) {
+      await clientDb.put(
+        dbKey,
+        normalizeReadRecord(dbKey, remoteData, { forCache: true })
+      );
+    }
+  } catch (err) {
+    throw err;
+  }
+};
+var normalizeReadRecord = (dbKey, data, options = {}) => {
+  if (!data || typeof data !== "object") return data;
+  const baseRecord = options.forCache ? data : { ...data, dbKey };
+  return baseRecord;
+};
+var isRemoteDataNewer = (remoteData, localData) => {
+  if (!remoteData || typeof remoteData !== "object") return false;
+  if (!localData || typeof localData !== "object") return true;
+  return shouldReplaceWithNextRecord(remoteData, localData);
+};
+var syncLocalDataToServer = async (replicationContext, dbKey, localData) => {
+  try {
+    scheduleExistingRecordReplication({
+      currentServer: replicationContext.currentServer,
+      syncServers: replicationContext.syncServers,
+      dbKey,
+      localData,
+      state: replicationContext.state
+    });
+  } catch (err) {
+  }
+};
+var saveRemoteDataToClientDb = async (clientDb, dbKey, remoteData, serverOrigin) => {
+  if (!clientDb) return;
+  try {
+    const normalizedRemoteData = normalizeReadRecord(dbKey, remoteData, {
+      forCache: true
+    });
+    await clientDb.put(
+      dbKey,
+      serverOrigin ? {
+        ...normalizedRemoteData,
+        serverOrigin
+      } : normalizedRemoteData
+    );
+  } catch (err) {
+  }
+};
+var processRemoteDataInBackground = async (clientDb, dbKey, remotePromises, remoteServers, localData, replicationContext) => {
+  if (!clientDb) return;
+  try {
+    const settledResults = await Promise.allSettled(remotePromises);
+    const remoteResult = pickBestSettledRemoteRecord({
+      settledResults,
+      isBetterCandidate: (current, latest) => shouldReplaceWithNextRecord(current, latest)
+    });
+    const validRemoteData = remoteResult ? remoteResult.data : null;
+    const serverOrigin = remoteResult && remoteServers[remoteResult.index] ? remoteServers[remoteResult.index] : void 0;
+    if (shouldReplaceLocalWithRemoteRecord({
+      localData,
+      remoteData: validRemoteData,
+      isRemoteNewer: isRemoteDataNewer
+    })) {
+      await updateClientDbIfNewer(
+        clientDb,
+        dbKey,
+        serverOrigin ? { ...validRemoteData, serverOrigin } : validRemoteData,
+        localData
+      );
+    }
+    if (shouldReplicateLocalRecord({
+      localData,
+      remoteData: validRemoteData,
+      remoteTargetCount: remotePromises.length
+    })) {
+      await syncLocalDataToServer(replicationContext, dbKey, localData);
+    }
+  } catch (err) {
+  }
+};
+var readAction = async (payload, thunkApi) => {
+  const dbKey = payload.dbKey;
+  const signal = payload.signal;
+  const preferredServerOrigin = payload.preferredServerOrigin;
+  if (!dbKey || typeof dbKey !== "string") {
+    throw new Error("readAction requires a non-empty dbKey.");
+  }
+  if (signal?.aborted) {
+    throw new DOMException("Aborted", "AbortError");
+  }
+  const { db: clientDb } = thunkApi.extra;
+  if (!clientDb) {
+    throw new Error("Client database is not available.");
+  }
+  const executeRead = async () => {
+    const isDialogKey = dbKey.startsWith("dialog-") && !dbKey.includes("-msg-");
+    const readStartedAt = isDialogKey ? Date.now() : 0;
+    const state = thunkApi.getState();
+    const {
+      currentToken,
+      remoteServers: configuredServers,
+      currentServer,
+      currentUserId,
+      syncServers,
+      userAuthorityRegistry
+    } = getRuntimeServerContext(state, preferredServerOrigin);
+    const allServers = resolveAgentReadServers({ dbKey, configuredServers });
+    const isLoggedIn = !!currentToken;
+    const now = Date.now();
+    const localData = await fetchFromClientDb(clientDb, dbKey);
+    if (isDialogKey) {
+      console.info("[readAction-perf] dialog local-read", {
+        dbKey,
+        localHit: !!localData,
+        localReadMs: Date.now() - readStartedAt,
+        serverCount: allServers.length
+      });
+    }
+    const authority = resolveRecordAuthority({
+      dbKey,
+      record: localData,
+      currentUserId,
+      currentServer,
+      userAuthorityRegistry
+    });
+    const authorityPlannedServers = planAuthorityReadServers({
+      allServers,
+      authorityServer: preferredServerOrigin ?? authority.authorityServer,
+      serverOrigin: authority.serverOrigin
+    });
+    const { preferredServer, fallbackServers, orderedServersForLocalHit } = partitionReadServers({
+      allServers: authorityPlannedServers,
+      preferredServerOrigin: preferredServerOrigin ?? authority.authorityServer
+    });
+    readRequestManager.cleanupMisses(now);
+    readRequestManager.cleanupLocalHitRevalidations(now);
+    if (localData) {
+      readRequestManager.clearMiss(dbKey);
+    } else {
+      const retryInMs = readRequestManager.getRetryInMs(dbKey, now);
+      if (typeof retryInMs === "number" && retryInMs > 0) {
+        logger.debug(
+          { dbKey, retryInMs },
+          "[readAction] Suppressing repeated miss read"
+        );
+        throw new Error(
+          `Read temporarily suppressed for missing key "${dbKey}".`
+        );
+      }
+    }
+    if (authorityPlannedServers.length === 0) {
+      if (localData) {
+        if (isDialogKey) {
+          console.info("[readAction-perf] dialog offline-local-hit", {
+            dbKey,
+            totalMs: Date.now() - readStartedAt
+          });
+        }
+        return normalizeReadRecord(dbKey, localData);
+      }
+      readRequestManager.markMiss(dbKey, now);
+      throw new Error(
+        `Failed to fetch data for key "${dbKey}" because network is offline and no local data is available.`
+      );
+    }
+    if (localData) {
+      const retryInMs = signal?.aborted ? void 0 : readRequestManager.getLocalHitRevalidateInMs(dbKey, now);
+      if (!signal?.aborted) {
+        if (retryInMs === null) {
+          readRequestManager.markLocalHitRevalidated(dbKey, now);
+          const remotePromises2 = orderedServersForLocalHit.map(
+            (server) => fetchFromServer(
+              server,
+              dbKey,
+              isLoggedIn ? currentToken : void 0,
+              signal
+            )
+          );
+          void processRemoteDataInBackground(
+            clientDb,
+            dbKey,
+            remotePromises2,
+            orderedServersForLocalHit,
+            localData,
+            { currentServer, syncServers, state }
+          );
+        } else {
+          logger.debug(
+            { dbKey, retryInMs },
+            "[readAction] Skipping frequent local-hit revalidation"
+          );
+        }
+      }
+      if (isDialogKey) {
+        console.info("[readAction-perf] dialog local-hit-return", {
+          dbKey,
+          totalMs: Date.now() - readStartedAt,
+          revalidating: retryInMs === null
+        });
+      }
+      return normalizeReadRecord(dbKey, localData);
+    }
+    if (preferredServer) {
+      try {
+        const preferredRemoteData = await fetchFromServer(
+          preferredServer,
+          dbKey,
+          isLoggedIn ? currentToken : void 0,
+          signal
+        );
+        if (preferredRemoteData) {
+          await saveRemoteDataToClientDb(
+            clientDb,
+            dbKey,
+            preferredRemoteData,
+            preferredServer
+          );
+          readRequestManager.clearMiss(dbKey);
+          if (isDialogKey) {
+            console.info("[readAction-perf] dialog preferred-remote-hit", {
+              dbKey,
+              totalMs: Date.now() - readStartedAt,
+              server: preferredServer
+            });
+          }
+          return normalizeReadRecord(dbKey, {
+            ...preferredRemoteData,
+            serverOrigin: preferredServer
+          });
+        }
+      } catch (error) {
+        if (signal?.aborted || isAbortError(error)) {
+          throw error;
+        }
+        if (isReadTimeoutError(error)) {
+          logger.warn(
+            { dbKey, preferredServer, error: String(error.message) },
+            "[readAction] Preferred server timed out; falling back to remaining servers"
+          );
+        } else {
+          logger.warn(
+            { dbKey, preferredServer, error: String(error) },
+            "[readAction] Preferred server read failed; falling back to remaining servers"
+          );
+        }
+      }
+    }
+    const remotePromises = fallbackServers.map(
+      (server) => fetchFromServer(
+        server,
+        dbKey,
+        isLoggedIn ? currentToken : void 0,
+        signal
+      )
+    );
+    const settledResults = await Promise.allSettled(remotePromises);
+    if (signal?.aborted) {
+      throw new DOMException("Aborted", "AbortError");
+    }
+    const remoteResult = pickBestSettledRemoteRecord({
+      settledResults,
+      isBetterCandidate: (current, latest) => shouldReplaceWithNextRecord(current, latest)
+    });
+    if (remoteResult) {
+      const { data: validRemoteData } = remoteResult;
+      const serverOrigin = fallbackServers[remoteResult.index];
+      if (!signal?.aborted) {
+        await saveRemoteDataToClientDb(
+          clientDb,
+          dbKey,
+          validRemoteData,
+          serverOrigin
+        );
+      }
+      readRequestManager.clearMiss(dbKey);
+      const remoteData = serverOrigin ? { ...validRemoteData, dbKey, serverOrigin } : { ...validRemoteData, dbKey };
+      return normalizeReadRecord(dbKey, remoteData);
+    }
+    readRequestManager.markMiss(dbKey, Date.now());
+    throw new Error(
+      `Failed to fetch data for key "${dbKey}" from all sources.`
+    );
+  };
+  const canDedup = !signal;
+  if (canDedup) {
+    const existing = readRequestManager.getInFlight(dbKey);
+    if (existing) return existing;
+    let inFlightPromise;
+    inFlightPromise = executeRead().finally(() => {
+      readRequestManager.clearInFlight(dbKey, inFlightPromise);
+    });
+    readRequestManager.setInFlight(dbKey, inFlightPromise);
+    return inFlightPromise;
+  }
+  return executeRead();
+};
+
+export {
+  BUILTIN_NOLO_AGENT_KEY,
+  PUBLIC_DEEPSEEK_V4_FLASH_AGENT_KEY,
+  PUBLIC_DEEPSEEK_V4_PRO_AGENT_KEY,
+  PUBLIC_KIMI_K27_CODING_AGENT_KEY,
+  PUBLIC_GLM_52_AGENT_KEY,
+  PUBLIC_KIMI_K26_IMAGE_AGENT_KEY,
+  readRequestManager,
+  resolveAgentReadServers,
+  readAction
+};