@remnic/cli 9.3.515 → 9.3.518

package/dist/index.js

@@ -6704,7 +6704,7 @@ function normalizeOfflineRemoteUrl(raw) {
   return parsed.toString().replace(/\/$/, "");
 }
 function resolveOptionalOfflineRemoteUrl(args) {
-  const raw = resolveRequiredValueFlag(args, "--remote-url") ?? process.env.REMNIC_OFFLINE_REMOTE_URL ?? process.env.ENGRAM_OFFLINE_REMOTE_URL;
+  const raw = resolveRequiredValueFlag(args, "--remote-url") ?? resolveRequiredValueFlag(args, "--remote") ?? process.env.REMNIC_OFFLINE_REMOTE_URL ?? process.env.ENGRAM_OFFLINE_REMOTE_URL;
   if (!raw || raw.trim().length === 0) return void 0;
   return normalizeOfflineRemoteUrl(raw);
 }
@@ -6762,6 +6762,12 @@ function offlineRequestTimeoutMs() {
     process.env.REMNIC_OFFLINE_REQUEST_TIMEOUT_MS ?? process.env.ENGRAM_OFFLINE_REQUEST_TIMEOUT_MS
   );
 }
+function offlineSnapshotPostTimeoutMs() {
+  return parseOfflineSyncRequestTimeoutMs(
+    process.env.REMNIC_OFFLINE_SNAPSHOT_POST_TIMEOUT_MS ?? process.env.ENGRAM_OFFLINE_SNAPSHOT_POST_TIMEOUT_MS,
+    Math.min(offlineRequestTimeoutMs(), 6e4)
+  );
+}
 function offlineFetchHeaders(token, initHeaders, defaultContentType) {
   const headers = new Headers(initHeaders);
   headers.set("authorization", `Bearer ${token}`);
@@ -6932,18 +6938,23 @@ async function fetchOfflineSnapshot(args) {
       const postRequest = offlineSnapshotBasePostRequest(postBody);
       if (postRequest) {
         const postRequestUsesGzip = new Headers(postRequest.headers).get("content-encoding")?.toLowerCase() === "gzip";
+        const postAbort = new AbortController();
+        const postTimeout = setTimeout(() => postAbort.abort(), offlineSnapshotPostTimeoutMs());
         try {
           return await fetchOfflineJson(
             offlineEndpoint(args.remoteUrl, "/remnic/v1/offline-sync/snapshot"),
             args.token,
             {
               method: "POST",
+              signal: postAbort.signal,
               ...postRequest
             }
           );
         } catch (error) {
           if (!isOfflineSnapshotPostFallbackError(error, { compressed: postRequestUsesGzip })) throw error;
           tryStreamSnapshot = true;
+        } finally {
+          clearTimeout(postTimeout);
         }
       } else {
         tryStreamSnapshot = true;
@@ -7005,6 +7016,9 @@ function offlineSnapshotBasePostRequest(body) {
 function isOfflineSnapshotPostFallbackError(error, options = {}) {
   const message = error instanceof Error ? error.message : String(error);
   if (/offline-sync\/snapshot\b.* returned (404|405|413)\b/.test(message)) return true;
+  if (/^offline sync request timed out after \d+ms: POST .*\/offline-sync\/snapshot\b/.test(message) || /^offline sync request failed before response: POST .*\/offline-sync\/snapshot\b/.test(message) || /^(This operation was aborted|The operation was aborted|AbortError)/i.test(message)) {
+    return true;
+  }
   if (!options.compressed) return false;
   return /offline-sync\/snapshot\b.* returned (400|415)\b/.test(message) && /\b(unsupported_content_encoding|invalid_gzip_body|invalid_json)\b/.test(message);
 }
@@ -7026,6 +7040,29 @@ async function fetchOfflineFiles(args) {
     }
   );
 }
+var APPEND_TOLERANT_RUNTIME_STATE_FILES = /* @__PURE__ */ new Set([
+  "memory-lifecycle-ledger.jsonl",
+  "recall_impressions.jsonl"
+]);
+function isAppendTolerantOfflineRuntimeFile(relPath) {
+  if (!shouldPreferIncomingOfflineRuntimeFile(relPath)) return false;
+  const parts = relPath.split("/");
+  const basename = parts[parts.length - 1] ?? "";
+  return APPEND_TOLERANT_RUNTIME_STATE_FILES.has(basename);
+}
+function offlineFileContentChunkMatchesExpected(options) {
+  const { chunk, expected, offset } = options;
+  if (chunk.path !== expected.path) return false;
+  if (chunk.offset !== offset) return false;
+  if (chunk.chunkBytes !== chunk.content.length) return false;
+  if (offset + chunk.chunkBytes > expected.bytes) return false;
+  if (chunk.bytes === expected.bytes && chunk.mtimeMs === expected.mtimeMs && (chunk.sha256 === void 0 || chunk.sha256 === expected.sha256)) {
+    return true;
+  }
+  if (!isAppendTolerantOfflineRuntimeFile(expected.path)) return false;
+  if (chunk.bytes < expected.bytes) return false;
+  return true;
+}
 var OFFLINE_SYNC_DIRECT_DEFAULT_MIN_BYTES = 16 * 1024 * 1024;
 var OFFLINE_SYNC_FILES_CONTENT_MAX_BATCH_BYTES = 8 * 1024 * 1024;
 var OFFLINE_SYNC_APPLY_MAX_REQUEST_BYTES = Math.floor(OFFLINE_SYNC_APPLY_MAX_BODY_BYTES / 2);
@@ -7040,6 +7077,8 @@ var OFFLINE_SYNC_DIRECT_PUSH_MIN_BYTES = Math.min(
 );
 var OFFLINE_SYNC_DIRECT_HYDRATE_MIN_BYTES = OFFLINE_SYNC_DIRECT_PUSH_MIN_BYTES;
 var OFFLINE_SYNC_CHANGESET_RETRY_MAX = 1024;
+var OFFLINE_SYNC_CONTENT_MISSING_RETRY_MAX = 3;
+var OFFLINE_SYNC_CONTENT_MISSING_RETRY_DELAY_MS = 250;
 var OfflineRemoteFileChangedError = class extends Error {
   path;
   constructor(path12) {
@@ -7051,6 +7090,9 @@ var OfflineRemoteFileChangedError = class extends Error {
 function isOfflineRemoteFileChangedError(error) {
   return error instanceof OfflineRemoteFileChangedError || error instanceof Error && error.message.startsWith("remote file changed while fetching offline content: ");
 }
+function isOfflineHydrateChecksumMismatch(error, relPath) {
+  return error instanceof Error && error.message === `offline sync upload checksum mismatch for ${relPath}`;
+}
 function isOfflineLocalFileChangedError(error) {
   return error instanceof Error && error.message.startsWith("local file changed while pushing offline content: ");
 }
@@ -7413,29 +7455,36 @@ async function hydrateOfflineFileContent(args) {
         Math.max(1, args.expected.bytes - offset)
       )
     });
-    if (chunk.path !== args.expected.path || chunk.sha256 !== void 0 && chunk.sha256 !== args.expected.sha256 || chunk.bytes !== args.expected.bytes || chunk.mtimeMs !== args.expected.mtimeMs || chunk.offset !== offset || chunk.chunkBytes !== chunk.content.length) {
+    if (!offlineFileContentChunkMatchesExpected({ chunk, expected: args.expected, offset })) {
       throw new OfflineRemoteFileChangedError(args.expected.path);
     }
     if (chunk.chunkBytes === 0 && args.expected.bytes > 0) {
       throw new Error(`remote offline content chunk was empty before EOF: ${args.expected.path}`);
     }
-    finalResult = await applyOfflineSyncFileContentChunk({
-      root: args.memoryDir,
-      sourceId: args.sourceId,
-      path: args.expected.path,
-      sha256: args.expected.sha256,
-      bytes: args.expected.bytes,
-      mtimeMs: args.expected.mtimeMs,
-      offset,
-      content: chunk.content,
-      ...args.baseSha256 ? { baseSha256: args.baseSha256 } : {},
-      includeTranscripts: args.includeTranscripts,
-      readFile: args.readFile,
-      readFileDigest: args.readFileDigest,
-      writeFile: args.writeFile,
-      writeStagingFile: args.writeStagingFile,
-      writeFileChunks: args.writeFileChunks
-    });
+    try {
+      finalResult = await applyOfflineSyncFileContentChunk({
+        root: args.memoryDir,
+        sourceId: args.sourceId,
+        path: args.expected.path,
+        sha256: args.expected.sha256,
+        bytes: args.expected.bytes,
+        mtimeMs: args.expected.mtimeMs,
+        offset,
+        content: chunk.content,
+        ...args.baseSha256 ? { baseSha256: args.baseSha256 } : {},
+        includeTranscripts: args.includeTranscripts,
+        readFile: args.readFile,
+        readFileDigest: args.readFileDigest,
+        writeFile: args.writeFile,
+        writeStagingFile: args.writeStagingFile,
+        writeFileChunks: args.writeFileChunks
+      });
+    } catch (error) {
+      if (isAppendTolerantOfflineRuntimeFile(args.expected.path) && isOfflineHydrateChecksumMismatch(error, args.expected.path)) {
+        throw new OfflineRemoteFileChangedError(args.expected.path);
+      }
+      throw error;
+    }
     if (finalResult.conflict) {
       return finalResult;
     }
@@ -7521,10 +7570,53 @@ function isOfflineFilesUnsupportedError(error) {
   const message = error instanceof Error ? error.message : String(error);
   return /offline sync request failed: .* returned 404\b/.test(message);
 }
+var OfflineMissingContentError = class extends Error {
+  missing;
+  constructor(missing) {
+    const preview = missing.slice(0, 8).map((file) => file.path).join(", ");
+    const suffix = missing.length > 8 ? `, ... +${missing.length - 8} more` : "";
+    super(
+      `remote offline content response omitted ${missing.length} changed file${missing.length === 1 ? "" : "s"}: ${preview}${suffix}; retry sync`
+    );
+    this.name = "OfflineMissingContentError";
+    this.missing = missing;
+  }
+};
 function isMissingOfflineContentError(error) {
+  if (error instanceof OfflineMissingContentError) return true;
   const message = error instanceof Error ? error.message : String(error);
   return /^missing decoded content for /.test(message);
 }
+function formatMissingOfflineContentError(missing) {
+  return new OfflineMissingContentError(missing);
+}
+function isOfflineMissingContentDeferrablePath(relPath) {
+  const parts = relPath.split("/");
+  return parts[0] === "profiling" || parts[0] === "namespaces" && parts[2] === "profiling";
+}
+function deferMissingOfflineContent(missing, deferredPaths) {
+  if (!deferredPaths) return [...missing];
+  const stillMissing = [];
+  for (const file of missing) {
+    if (isOfflineMissingContentDeferrablePath(file.path)) {
+      deferredPaths.add(file.path);
+    } else {
+      stillMissing.push(file);
+    }
+  }
+  return stillMissing;
+}
+function formatMissingDecodedContentError(missing) {
+  const preview = missing.slice(0, 8).map((file) => file.path).join(", ");
+  const suffix = missing.length > 8 ? `, ... +${missing.length - 8} more` : "";
+  return new Error(
+    `remote offline content response omitted ${missing.length} changed file${missing.length === 1 ? "" : "s"}: ${preview}${suffix}; retry sync`
+  );
+}
+async function waitForMissingOfflineContentRetry(delayMs) {
+  if (delayMs <= 0) return;
+  await new Promise((resolve) => setTimeout(resolve, delayMs));
+}
 async function hydrateOfflineSnapshotContent(args) {
   const snapshot = normalizeOfflineSyncSnapshot(args.snapshot);
   const neededFiles = offlineSnapshotContentFilesForApply({
@@ -7538,26 +7630,47 @@ async function hydrateOfflineSnapshotContent(args) {
   const expectedByPath = new Map(snapshot.files.map((file) => [file.path, file]));
   const contentByPath = /* @__PURE__ */ new Map();
   const updatedByPath = /* @__PURE__ */ new Map();
+  const fetchFiles = args.fetchFiles ?? fetchOfflineFiles;
+  const retryMax = args.missingContentRetryMax ?? OFFLINE_SYNC_CONTENT_MISSING_RETRY_MAX;
+  const retryDelayMs = args.missingContentRetryDelayMs ?? OFFLINE_SYNC_CONTENT_MISSING_RETRY_DELAY_MS;
+  if (!Number.isInteger(retryMax) || retryMax < 0) {
+    throw new Error("offline sync missing content retry max must be an integer >= 0");
+  }
+  if (!Number.isInteger(retryDelayMs) || retryDelayMs < 0) {
+    throw new Error("offline sync missing content retry delay must be an integer >= 0");
+  }
   try {
-    for (const batch of chunkOfflineFileContentBatches(neededFiles)) {
-      const partial = await fetchOfflineFiles({
-        remoteUrl: args.remoteUrl,
-        token: args.token,
-        namespace: args.namespace,
-        includeTranscripts: args.includeTranscripts,
-        paths: batch.map((file) => file.path)
-      });
-      for (const file of partial.files) {
-        const expected = expectedByPath.get(file.path);
-        if (!expected) continue;
-        if (typeof file.contentBase64 !== "string") {
-          throw new Error(`remote offline content response omitted contentBase64 for ${file.path}`);
-        }
-        if (file.sha256 !== expected.sha256 || file.bytes !== expected.bytes || file.mtimeMs !== expected.mtimeMs) {
-          updatedByPath.set(file.path, file);
+    let pendingFiles = neededFiles;
+    for (let attempt = 0; ; attempt += 1) {
+      for (const batch of chunkOfflineFileContentBatches(pendingFiles)) {
+        const partial = await fetchFiles({
+          remoteUrl: args.remoteUrl,
+          token: args.token,
+          namespace: args.namespace,
+          includeTranscripts: args.includeTranscripts,
+          paths: batch.map((file) => file.path)
+        });
+        for (const file of partial.files) {
+          const expected = expectedByPath.get(file.path);
+          if (!expected) continue;
+          if (typeof file.contentBase64 !== "string") {
+            throw new Error(`remote offline content response omitted contentBase64 for ${file.path}`);
+          }
+          if (file.sha256 !== expected.sha256 || file.bytes !== expected.bytes || file.mtimeMs !== expected.mtimeMs) {
+            updatedByPath.set(file.path, file);
+          }
+          contentByPath.set(file.path, file.contentBase64);
         }
-        contentByPath.set(file.path, file.contentBase64);
       }
+      const missing2 = pendingFiles.filter((file) => !contentByPath.has(file.path));
+      if (missing2.length === 0) break;
+      if (attempt >= retryMax) {
+        const stillMissing = deferMissingOfflineContent(missing2, args.missingContentDeferredPaths);
+        if (stillMissing.length > 0) throw formatMissingOfflineContentError(stillMissing);
+        break;
+      }
+      pendingFiles = missing2;
+      await waitForMissingOfflineContentRetry(retryDelayMs);
     }
   } catch (error) {
     if (!isOfflineFilesUnsupportedError(error)) throw error;
@@ -7569,10 +7682,10 @@ async function hydrateOfflineSnapshotContent(args) {
       includeContent: true
     });
   }
-  const missing = neededFiles.map((file) => file.path).filter((relPath) => !contentByPath.has(relPath));
+  const missing = neededFiles.map((file) => file.path).filter((relPath) => !contentByPath.has(relPath) && !args.missingContentDeferredPaths?.has(relPath));
   if (missing.length > 0) {
-    throw new Error(
-      `remote offline content response omitted ${missing.length} changed file${missing.length === 1 ? "" : "s"}; retry sync`
+    throw formatMissingDecodedContentError(
+      neededFiles.filter((file) => missing.includes(file.path))
     );
   }
   return {
@@ -8231,7 +8344,8 @@ async function runOfflineSyncOnce(options) {
       snapshot: remoteSnapshotMetadata,
       baseFiles,
       currentFiles: applyCurrentSnapshot.files,
-      deferredPaths: [...remoteDeferredPaths]
+      deferredPaths: [...remoteDeferredPaths],
+      missingContentDeferredPaths: remoteDeferredPaths
     });
   } catch (error) {
     if (pushed || partialHydration.hydratedFiles.length > 0) {
@@ -8275,7 +8389,8 @@ async function runOfflineSyncOnce(options) {
         snapshot: remoteSnapshotMetadata,
         baseFiles,
         currentFiles: applyCurrentSnapshot.files,
-        deferredPaths: [...remoteDeferredPaths]
+        deferredPaths: [...remoteDeferredPaths],
+        missingContentDeferredPaths: remoteDeferredPaths
       });
     } catch (retryError) {
       if (pushed || partialHydration.hydratedFiles.length > 0) {
@@ -8397,7 +8512,7 @@ async function cmdOffline(action, rest, json) {
     console.log(`Usage: remnic offline <prepare|sync|status|watch> [options]
 
 Options:
-  --remote-url <url>       Remote Remnic server URL, e.g. http://home:4242
+  --remote-url <url>       Remote Remnic server URL, e.g. http://home:4242 (--remote alias accepted)
   --token <token>          Bearer token for the remote server
   --namespace <name>       Namespace to sync
   --memory-dir <dir>       Local memory dir (defaults to resolved memoryDir)
@@ -11538,6 +11653,8 @@ export {
   BENCHMARK_CATALOG,
   OFFLINE_SYNC_APPLY_MAX_REQUEST_BYTES,
   OFFLINE_SYNC_CHANGESET_RETRY_MAX,
+  OFFLINE_SYNC_CONTENT_MISSING_RETRY_DELAY_MS,
+  OFFLINE_SYNC_CONTENT_MISSING_RETRY_MAX,
   OFFLINE_SYNC_DIRECT_HYDRATE_MIN_BYTES,
   OFFLINE_SYNC_DIRECT_PUSH_MIN_BYTES,
   OFFLINE_SYNC_FILE_CONTENT_UPLOAD_CHUNK_BYTES,
@@ -11560,6 +11677,8 @@ export {
   formatOfflineRequestForError,
   getBenchUsageText,
   hasFlag,
+  hydrateOfflineSnapshotContent,
+  isOfflineMissingContentDeferrablePath,
   isOfflineSnapshotPostFallbackError,
   main,
   offlinePartialHydrationForPaths,
@@ -11579,6 +11698,7 @@ export {
   resolveConfigPath,
   resolveFlag,
   resolveMemoryDir,
+  resolveOptionalOfflineRemoteUrl,
   resolveSyncSourceDir,
   runOfflineSyncOnce,
   runTrainingExport,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/cli",
-  "version": "9.3.515",
+  "version": "9.3.518",
   "description": "CLI for Remnic memory — init, query, doctor, daemon management",
   "type": "module",
   "main": "dist/index.js",
@@ -26,20 +26,20 @@
   },
   "dependencies": {
     "yaml": "^2.4.2",
-    "@remnic/plugin-pi": "^9.3.515",
-    "@remnic/server": "^9.3.515",
-    "@remnic/core": "^9.3.515"
+    "@remnic/plugin-pi": "^9.3.518",
+    "@remnic/server": "^9.3.518",
+    "@remnic/core": "^9.3.518"
   },
   "peerDependencies": {
-    "@remnic/bench": "^9.3.515",
-    "@remnic/export-weclone": "^9.3.515",
-    "@remnic/import-weclone": "^9.3.515",
-    "@remnic/import-chatgpt": "^9.3.515",
-    "@remnic/import-claude": "^9.3.515",
-    "@remnic/import-gemini": "^9.3.515",
-    "@remnic/import-lossless-claw": "^9.3.515",
-    "@remnic/import-mem0": "^9.3.515",
-    "@remnic/import-supermemory": "^9.3.515"
+    "@remnic/bench": "^9.3.518",
+    "@remnic/export-weclone": "^9.3.518",
+    "@remnic/import-weclone": "^9.3.518",
+    "@remnic/import-chatgpt": "^9.3.518",
+    "@remnic/import-claude": "^9.3.518",
+    "@remnic/import-gemini": "^9.3.518",
+    "@remnic/import-lossless-claw": "^9.3.518",
+    "@remnic/import-mem0": "^9.3.518",
+    "@remnic/import-supermemory": "^9.3.518"
   },
   "peerDependenciesMeta": {
     "@remnic/bench": {
@@ -73,15 +73,15 @@
   "devDependencies": {
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",
-    "@remnic/bench": "9.3.515",
-    "@remnic/export-weclone": "9.3.515",
-    "@remnic/import-weclone": "9.3.515",
-    "@remnic/import-claude": "9.3.515",
-    "@remnic/import-gemini": "9.3.515",
-    "@remnic/import-mem0": "9.3.515",
-    "@remnic/import-lossless-claw": "9.3.515",
-    "@remnic/import-chatgpt": "9.3.515",
-    "@remnic/import-supermemory": "9.3.515"
+    "@remnic/export-weclone": "9.3.518",
+    "@remnic/bench": "9.3.518",
+    "@remnic/import-weclone": "9.3.518",
+    "@remnic/import-chatgpt": "9.3.518",
+    "@remnic/import-claude": "9.3.518",
+    "@remnic/import-gemini": "9.3.518",
+    "@remnic/import-mem0": "9.3.518",
+    "@remnic/import-lossless-claw": "9.3.518",
+    "@remnic/import-supermemory": "9.3.518"
   },
   "license": "MIT",
   "repository": {