@remnic/cli 1.0.9 → 1.0.11

package/dist/index.js

@@ -90,6 +90,7 @@ import {
   renderXray,
   applyOfflineSyncSnapshot,
   buildOfflineSyncChangeset,
+  buildOfflineSyncSnapshot,
   defaultOfflineSyncStatePath,
   offlineSyncStateFromSnapshot,
   readOfflineSyncState,
@@ -6647,11 +6648,25 @@ async function fetchOfflineSnapshot(args) {
     offlineEndpoint(args.remoteUrl, "/remnic/v1/offline-sync/snapshot", {
       namespace: args.namespace,
       include_transcripts: args.includeTranscripts ? "true" : "false",
-      content: "true"
+      content: args.includeContent === false ? "false" : "true"
     }),
     args.token
   );
 }
+async function fetchOfflineFiles(args) {
+  return fetchOfflineJson(
+    offlineEndpoint(args.remoteUrl, "/remnic/v1/offline-sync/files"),
+    args.token,
+    {
+      method: "POST",
+      body: JSON.stringify({
+        namespace: args.namespace,
+        includeTranscripts: args.includeTranscripts,
+        paths: args.paths
+      })
+    }
+  );
+}
 function resolvedOfflineSnapshotNamespace(snapshot, requestedNamespace) {
   const resolved = typeof snapshot.namespace === "string" && snapshot.namespace.trim().length > 0 ? snapshot.namespace.trim() : void 0;
   return resolved ?? requestedNamespace;
@@ -6684,6 +6699,99 @@ async function readFirstOfflineSyncState(paths) {
   }
   return null;
 }
+function offlineFileStateMap(files) {
+  return new Map(files.map((file) => [file.path, file]));
+}
+function offlineSnapshotContentPathsForApply(options) {
+  const base = offlineFileStateMap(options.baseFiles);
+  const current = options.currentFiles ? offlineFileStateMap(options.currentFiles) : null;
+  const paths = [];
+  for (const incoming of options.snapshot.files) {
+    if (current?.get(incoming.path)?.sha256 === incoming.sha256) continue;
+    if (base.get(incoming.path)?.sha256 === incoming.sha256) continue;
+    paths.push(incoming.path);
+  }
+  return paths.sort();
+}
+function chunkOfflineFilePaths(paths) {
+  const chunks = [];
+  let current = [];
+  let currentBytes = 256;
+  for (const relPath of paths) {
+    const cost = Buffer.byteLength(JSON.stringify(relPath), "utf-8") + 1;
+    if (current.length > 0 && (current.length >= 1e3 || currentBytes + cost > 96e3)) {
+      chunks.push(current);
+      current = [];
+      currentBytes = 256;
+    }
+    current.push(relPath);
+    currentBytes += cost;
+  }
+  if (current.length > 0) chunks.push(current);
+  return chunks;
+}
+function isOfflineFilesUnsupportedError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /offline sync request failed: 404\b/.test(message);
+}
+function isMissingOfflineContentError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /^missing decoded content for /.test(message);
+}
+async function hydrateOfflineSnapshotContent(args) {
+  const neededPaths = offlineSnapshotContentPathsForApply({
+    snapshot: args.snapshot,
+    baseFiles: args.baseFiles,
+    currentFiles: args.currentFiles
+  });
+  if (neededPaths.length === 0) return args.snapshot;
+  const expectedByPath = new Map(args.snapshot.files.map((file) => [file.path, file]));
+  const contentByPath = /* @__PURE__ */ new Map();
+  try {
+    for (const batch of chunkOfflineFilePaths(neededPaths)) {
+      const partial = await fetchOfflineFiles({
+        remoteUrl: args.remoteUrl,
+        token: args.token,
+        namespace: args.namespace,
+        includeTranscripts: args.includeTranscripts,
+        paths: batch
+      });
+      for (const file of partial.files) {
+        const expected = expectedByPath.get(file.path);
+        if (!expected) continue;
+        if (file.sha256 !== expected.sha256 || file.bytes !== expected.bytes) {
+          throw new Error(`remote file changed while fetching offline content: ${file.path}`);
+        }
+        if (typeof file.contentBase64 !== "string") {
+          throw new Error(`remote offline content response omitted contentBase64 for ${file.path}`);
+        }
+        contentByPath.set(file.path, file.contentBase64);
+      }
+    }
+  } catch (error) {
+    if (!isOfflineFilesUnsupportedError(error)) throw error;
+    return fetchOfflineSnapshot({
+      remoteUrl: args.remoteUrl,
+      token: args.token,
+      namespace: args.namespace,
+      includeTranscripts: args.includeTranscripts,
+      includeContent: true
+    });
+  }
+  const missing = neededPaths.filter((relPath) => !contentByPath.has(relPath));
+  if (missing.length > 0) {
+    throw new Error(
+      `remote offline content response omitted ${missing.length} changed file${missing.length === 1 ? "" : "s"}; retry sync`
+    );
+  }
+  return {
+    ...args.snapshot,
+    files: args.snapshot.files.map((file) => {
+      const contentBase64 = contentByPath.get(file.path);
+      return contentBase64 === void 0 ? file : { ...file, contentBase64 };
+    })
+  };
+}
 async function pushOfflineChanges(args) {
   return fetchOfflineJson(
     offlineEndpoint(args.remoteUrl, "/remnic/v1/offline-sync/apply"),
@@ -6746,7 +6854,8 @@ async function runOfflineSyncOnce(options) {
       remoteUrl: options.remoteUrl,
       token: options.token,
       namespace: options.namespace,
-      includeTranscripts: options.includeTranscripts
+      includeTranscripts: options.includeTranscripts,
+      includeContent: false
     });
     syncNamespace = resolvedOfflineSnapshotNamespace(namespaceProbe, options.namespace);
   }
@@ -6787,21 +6896,59 @@ async function runOfflineSyncOnce(options) {
     namespace: syncNamespace,
     changeset
   }) : null;
-  const remoteSnapshot = await fetchOfflineSnapshot({
+  const remoteSnapshotMetadata = await fetchOfflineSnapshot({
     remoteUrl: options.remoteUrl,
     token: options.token,
     namespace: syncNamespace,
-    includeTranscripts: options.includeTranscripts
+    includeTranscripts: options.includeTranscripts,
+    includeContent: false
   });
-  const resolvedNamespace = resolvedOfflineSnapshotNamespace(remoteSnapshot, syncNamespace);
-  const pull = await applyOfflineSyncSnapshot({
+  const currentSnapshot = await buildOfflineSyncSnapshot({
     root: options.memoryDir,
-    snapshot: remoteSnapshot,
+    sourceId: localOfflineSourceId(options.memoryDir),
+    includeContent: false,
+    includeTranscripts: options.includeTranscripts,
+    readFile: storageIo.readFile
+  });
+  const remoteSnapshot = await hydrateOfflineSnapshotContent({
+    remoteUrl: options.remoteUrl,
+    token: options.token,
+    namespace: syncNamespace,
+    includeTranscripts: options.includeTranscripts,
+    snapshot: remoteSnapshotMetadata,
     baseFiles,
-    readFile: storageIo.readFile,
-    writeFile: storageIo.writeFile,
-    deleteFile: storageIo.deleteFile
+    currentFiles: currentSnapshot.files
   });
+  const resolvedNamespace = resolvedOfflineSnapshotNamespace(remoteSnapshot, syncNamespace);
+  let pull;
+  try {
+    pull = await applyOfflineSyncSnapshot({
+      root: options.memoryDir,
+      snapshot: remoteSnapshot,
+      baseFiles,
+      readFile: storageIo.readFile,
+      writeFile: storageIo.writeFile,
+      deleteFile: storageIo.deleteFile
+    });
+  } catch (error) {
+    if (!isMissingOfflineContentError(error)) throw error;
+    const retrySnapshot = await hydrateOfflineSnapshotContent({
+      remoteUrl: options.remoteUrl,
+      token: options.token,
+      namespace: syncNamespace,
+      includeTranscripts: options.includeTranscripts,
+      snapshot: remoteSnapshotMetadata,
+      baseFiles
+    });
+    pull = await applyOfflineSyncSnapshot({
+      root: options.memoryDir,
+      snapshot: retrySnapshot,
+      baseFiles,
+      readFile: storageIo.readFile,
+      writeFile: storageIo.writeFile,
+      deleteFile: storageIo.deleteFile
+    });
+  }
   const state = offlineSyncStateFromSnapshot({
     remoteId: options.remoteUrl,
     namespace: resolvedNamespace,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/cli",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "CLI for Remnic memory — init, query, doctor, daemon management",
   "type": "module",
   "main": "dist/index.js",
@@ -26,9 +26,9 @@
   },
   "dependencies": {
     "yaml": "^2.4.2",
-    "@remnic/plugin-pi": "^1.0.0",
+    "@remnic/core": "^1.1.17",
     "@remnic/server": "^1.0.5",
-    "@remnic/core": "^1.1.15"
+    "@remnic/plugin-pi": "^1.0.0"
   },
   "peerDependencies": {
     "@remnic/bench": "^1.0.0",
@@ -76,12 +76,12 @@
     "@remnic/bench": "1.0.1",
     "@remnic/export-weclone": "1.0.1",
     "@remnic/import-weclone": "1.0.1",
-    "@remnic/import-mem0": "0.1.0",
-    "@remnic/import-lossless-claw": "0.1.1",
     "@remnic/import-chatgpt": "0.1.0",
-    "@remnic/import-supermemory": "0.1.2",
+    "@remnic/import-claude": "0.1.0",
+    "@remnic/import-lossless-claw": "0.1.1",
+    "@remnic/import-mem0": "0.1.0",
     "@remnic/import-gemini": "0.1.0",
-    "@remnic/import-claude": "0.1.0"
+    "@remnic/import-supermemory": "0.1.2"
   },
   "license": "MIT",
   "repository": {