nolo-cli 0.8.0 → 0.9.0

package/chunk-W4NVOSFF.js

@@ -0,0 +1,37 @@
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
+
+// packages/cli/agentCommandSupport.ts
+async function getDefaultCliDb() {
+  const { getDefaultCliLocalRuntimeDb } = await import("./localRuntimeDb-LGDF6FQP.js");
+  return getDefaultCliLocalRuntimeDb();
+}
+function createNullCliDb() {
+  return {
+    get: async () => {
+      throw new Error("local cache unavailable");
+    },
+    put: async () => void 0,
+    del: async () => void 0,
+    batch: async () => void 0,
+    iterator: () => {
+      throw new Error("local cache unavailable");
+    }
+  };
+}
+async function getReadableCliDb(output) {
+  try {
+    return await getDefaultCliDb();
+  } catch (error) {
+    output.write(
+      `[nolo] local agent cache unavailable; falling back to remote reads only: ${toErrorMessage(error)}
+`
+    );
+    return createNullCliDb();
+  }
+}
+
+export {
+  getReadableCliDb
+};

package/chunk-WKM6FH35.js

@@ -0,0 +1,190 @@
+import {
+  deleteDbRecord,
+  queryUserRecords,
+  readDbRecord
+} from "./chunk-7OOXPE3N.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-WWC7I6TA.js

@@ -0,0 +1,8 @@
+// packages/core/optionalNumber.ts
+function asOptionalFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+
+export {
+  asOptionalFiniteNumber
+};