nolo-cli 0.8.0-alpha.2 → 0.8.0-alpha.20

package/chunk-G3SUCT4W.js

@@ -0,0 +1,8 @@
+// packages/core/optionalString.ts
+function asOptionalTrimmedString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+
+export {
+  asOptionalTrimmedString
+};

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-GLYVN7EQ.js

@@ -0,0 +1,238 @@
+import {
+  getRuntimeServerContext,
+  scheduleDeleteReplication
+} from "./chunk-XBROXIGL.js";
+import {
+  fetchFromClientDb
+} from "./chunk-WI4XWASA.js";
+import {
+  buildTombstoneRecord
+} from "./chunk-GBRG75BQ.js";
+
+// packages/database/fileStorage.ts
+var DB_NAME = "nolo-file-storage";
+var STORE_NAME = "files";
+var DB_VERSION = 1;
+var dbPromise = null;
+var openFileDb = () => {
+  if (dbPromise) return dbPromise;
+  if (typeof indexedDB === "undefined") {
+    console.warn(
+      "[fileStorage] indexedDB is not available in this environment. File caching is disabled."
+    );
+    dbPromise = Promise.reject(
+      new Error("indexedDB is not available in this environment")
+    );
+    return dbPromise;
+  }
+  dbPromise = new Promise((resolve, reject) => {
+    const request = indexedDB.open(DB_NAME, DB_VERSION);
+    request.onerror = () => {
+      console.error("[fileStorage] Failed to open IndexedDB:", request.error);
+      reject(request.error);
+    };
+    request.onupgradeneeded = () => {
+      const db = request.result;
+      if (!db.objectStoreNames.contains(STORE_NAME)) {
+        const store = db.createObjectStore(STORE_NAME, {
+          keyPath: "id"
+        });
+        store.createIndex("createdAt", "createdAt", { unique: false });
+      }
+    };
+    request.onsuccess = () => {
+      const db = request.result;
+      db.onversionchange = () => {
+        db.close();
+        console.warn(
+          "[fileStorage] IndexedDB version change detected, closing old connection."
+        );
+      };
+      resolve(db);
+    };
+  });
+  return dbPromise;
+};
+var saveFileToIndexedDb = async (fileId, file) => {
+  try {
+    const db = await openFileDb();
+    const tx = db.transaction(STORE_NAME, "readwrite");
+    const store = tx.objectStore(STORE_NAME);
+    const blob = file instanceof Blob ? file : new Blob([file]);
+    const record = {
+      id: fileId,
+      blob,
+      size: blob.size,
+      type: blob.type || "application/octet-stream",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const request = store.put(record);
+    await new Promise((resolve, reject) => {
+      request.onsuccess = () => {
+        console.debug(
+          "[fileStorage] Saved file to IndexedDB:",
+          fileId,
+          "size=",
+          record.size,
+          "type=",
+          record.type
+        );
+        resolve();
+      };
+      request.onerror = () => {
+        console.error(
+          "[fileStorage] Failed to save file to IndexedDB:",
+          fileId,
+          request.error
+        );
+        reject(request.error);
+      };
+    });
+    await new Promise((resolve, reject) => {
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+      tx.onabort = () => reject(tx.error);
+    });
+  } catch (err) {
+    console.warn(
+      "[fileStorage] saveFileToIndexedDb error (non-fatal, caching disabled for this file):",
+      err
+    );
+  }
+};
+var loadFileFromIndexedDb = async (fileId) => {
+  try {
+    const db = await openFileDb();
+    const tx = db.transaction(STORE_NAME, "readonly");
+    const store = tx.objectStore(STORE_NAME);
+    const request = store.get(fileId);
+    const record = await new Promise(
+      (resolve, reject) => {
+        request.onsuccess = () => {
+          const result = request.result;
+          if (result) {
+            console.debug(
+              "[fileStorage] Loaded file from IndexedDB:",
+              fileId,
+              "size=",
+              result.size,
+              "type=",
+              result.type
+            );
+          } else {
+            console.debug(
+              "[fileStorage] No local file found in IndexedDB for id:",
+              fileId
+            );
+          }
+          resolve(result ?? null);
+        };
+        request.onerror = () => {
+          console.error(
+            "[fileStorage] Failed to load file from IndexedDB:",
+            fileId,
+            request.error
+          );
+          reject(request.error);
+        };
+      }
+    );
+    return record ?? null;
+  } catch (err) {
+    console.warn(
+      "[fileStorage] loadFileFromIndexedDb error, treat as cache miss:",
+      err
+    );
+    return null;
+  }
+};
+var deleteFileFromIndexedDb = async (fileId) => {
+  try {
+    const db = await openFileDb();
+    const tx = db.transaction(STORE_NAME, "readwrite");
+    const store = tx.objectStore(STORE_NAME);
+    const request = store.delete(fileId);
+    await new Promise((resolve, reject) => {
+      request.onsuccess = () => {
+        console.debug("[fileStorage] Deleted file from IndexedDB:", fileId);
+        resolve();
+      };
+      request.onerror = () => {
+        console.error(
+          "[fileStorage] Failed to delete file from IndexedDB:",
+          fileId,
+          request.error
+        );
+        reject(request.error);
+      };
+    });
+    await new Promise((resolve, reject) => {
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+      tx.onabort = () => reject(tx.error);
+    });
+  } catch (err) {
+    console.warn("[fileStorage] deleteFileFromIndexedDb error:", err);
+  }
+};
+
+// packages/database/actions/remove.ts
+var removeAction = async (payload, thunkApi) => {
+  const { db: clientDb } = thunkApi.extra;
+  const dbKey = typeof payload === "string" ? payload : payload.dbKey;
+  const preferredServerOrigin = typeof payload === "string" ? void 0 : payload.preferredServerOrigin;
+  if (!clientDb) {
+    throw new Error("Client database is undefined in removeAction");
+  }
+  const state = thunkApi.getState();
+  const { currentServer, syncServers } = getRuntimeServerContext(state);
+  console.log("[removeAction] START", {
+    dbKey,
+    preferredServerOrigin,
+    currentServer,
+    syncServers,
+    hasToken: Boolean(state?.auth?.currentToken)
+  });
+  const localData = await fetchFromClientDb(clientDb, dbKey);
+  const hadLocalData = Boolean(localData);
+  console.log("[removeAction] replication inputs", {
+    currentServer,
+    syncServers,
+    preferredServerOrigin,
+    hadLocalData
+  });
+  const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+  if (localData) {
+    if (localData.id && typeof localData.id === "string") {
+      void deleteFileFromIndexedDb(localData.id).catch((err) => {
+        console.warn("[removeAction] Failed to delete associated file:", localData.id, err);
+      });
+    }
+    await clientDb.put(dbKey, buildTombstoneRecord(localData, nowIso));
+  } else {
+    await clientDb.put(dbKey, buildTombstoneRecord({ dbKey }, nowIso));
+  }
+  scheduleDeleteReplication({
+    currentServer,
+    syncServers,
+    preferredServerOrigin,
+    dbKey,
+    state,
+    onResult: (result) => {
+      if (result.failed.length > 0) {
+        console.warn("[removeAction] Server delete failures after local tombstone:", result.failed);
+      }
+    },
+    onError: (err) => {
+      console.warn("[removeAction] Background server delete error:", err);
+    }
+  });
+  return { dbKey };
+};
+
+export {
+  saveFileToIndexedDb,
+  loadFileFromIndexedDb,
+  deleteFileFromIndexedDb,
+  removeAction
+};

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-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
+};

package/chunk-HNW7IJSK.js

@@ -0,0 +1,71 @@
+import {
+  createMemoryKey,
+  createMemoryOwnerIndexKey,
+  createMemorySubjectKindIndexKey,
+  ulid
+} from "./chunk-O4BU24WZ.js";
+
+// packages/ai/memory/storeShared.ts
+var createMemoryItem = (input) => {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: ulid(),
+    createdAt: now,
+    lastActivatedAt: now,
+    activationCount: 0,
+    ...input
+  };
+};
+var writeMemoryItemWithIndexesToDb = async (db, item) => {
+  const batch = db.batch();
+  batch.put(createMemoryKey(item.ownerType, item.ownerId, item.id), item);
+  batch.put(
+    createMemoryOwnerIndexKey(
+      item.ownerType,
+      item.ownerId,
+      item.createdAt,
+      item.id
+    ),
+    {
+      memoryKey: createMemoryKey(item.ownerType, item.ownerId, item.id),
+      ownerType: item.ownerType,
+      ownerId: item.ownerId,
+      memoryId: item.id
+    }
+  );
+  batch.put(
+    createMemorySubjectKindIndexKey(
+      item.subjectType,
+      item.subjectId,
+      item.kind,
+      item.createdAt,
+      item.id
+    ),
+    {
+      memoryKey: createMemoryKey(item.ownerType, item.ownerId, item.id),
+      subjectType: item.subjectType,
+      subjectId: item.subjectId,
+      kind: item.kind,
+      memoryId: item.id
+    }
+  );
+  await batch.write();
+};
+var touchMemoryItemsInDb = async (db, items, now = (/* @__PURE__ */ new Date()).toISOString()) => {
+  if (items.length === 0) return;
+  const batch = db.batch();
+  for (const item of items) {
+    batch.put(createMemoryKey(item.ownerType, item.ownerId, item.id), {
+      ...item,
+      lastActivatedAt: now,
+      activationCount: (item.activationCount ?? 0) + 1
+    });
+  }
+  await batch.write();
+};
+
+export {
+  createMemoryItem,
+  writeMemoryItemWithIndexesToDb,
+  touchMemoryItemsInDb
+};

package/chunk-I42VC5KR.js

@@ -0,0 +1,15 @@
+// packages/core/stringArray.ts
+function asNonEmptyStringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter(
+    (item) => typeof item === "string" && !!item.trim()
+  );
+}
+function asTrimmedNonEmptyStringArray(value) {
+  return asNonEmptyStringArray(value).map((item) => item.trim());
+}
+
+export {
+  asNonEmptyStringArray,
+  asTrimmedNonEmptyStringArray
+};

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
+};