ccsini 0.1.60 → 0.1.62

package/dist/index.js

@@ -27876,7 +27876,7 @@ function decodeProjectPath(encoded) {
 }
 
 // ../shared/src/constants.ts
-var DEFAULT_CATEGORY_PATTERNS, MERGE_STRATEGIES, NEVER_SYNC_PATTERNS, SESSION_SYNC_DEFAULTS, JWT_EXPIRY_SECONDS = 900, DAEMON_DEBOUNCE_MS = 5000, DAEMON_INTERVAL_MS = 30000, MAX_CONCURRENT_TRANSFERS = 50;
+var DEFAULT_CATEGORY_PATTERNS, MERGE_STRATEGIES, NEVER_SYNC_PATTERNS, SESSION_SYNC_DEFAULTS, JWT_EXPIRY_SECONDS = 900, DAEMON_DEBOUNCE_MS = 5000, DAEMON_INTERVAL_MS = 30000, MAX_CONCURRENT_TRANSFERS = 50, BATCH_DOWNLOAD_SIZE = 20;
 var init_constants = __esm(() => {
   DEFAULT_CATEGORY_PATTERNS = {
     session: ["projects/**/*.jsonl"],
@@ -28058,7 +28058,7 @@ var {
 } = import__.default;
 
 // src/version.ts
-var VERSION = "0.1.60";
+var VERSION = "0.1.62";
 
 // src/commands/init.ts
 init_source();
@@ -28967,6 +28967,23 @@ class CcsiniClient {
     this.apiUrl = apiUrl.replace(/\/$/, "");
     this.token = token;
   }
+  async fetchWithRetry(input, init, maxRetries = 3) {
+    for (let attempt = 1;attempt <= maxRetries; attempt++) {
+      try {
+        const res = await fetch(input, init);
+        if (res.status >= 500 && attempt < maxRetries) {
+          await new Promise((r) => setTimeout(r, 500 * Math.pow(2, attempt - 1)));
+          continue;
+        }
+        return res;
+      } catch (e) {
+        if (attempt >= maxRetries)
+          throw e;
+        await new Promise((r) => setTimeout(r, 500 * Math.pow(2, attempt - 1)));
+      }
+    }
+    throw new Error("fetchWithRetry exhausted");
+  }
   getHeaders() {
     return {
       Authorization: `Bearer ${this.token}`,
@@ -28995,7 +29012,7 @@ class CcsiniClient {
       throw new Error("Failed to store salt");
   }
   async getManifest() {
-    const res = await fetch(`${this.apiUrl}/api/sync/manifest`, {
+    const res = await this.fetchWithRetry(`${this.apiUrl}/api/sync/manifest`, {
       headers: this.getHeaders()
     });
     if (!res.ok)
@@ -29006,7 +29023,7 @@ class CcsiniClient {
     return new Uint8Array(Buffer.from(data.manifest, "base64"));
   }
   async putManifest(encryptedManifest) {
-    const res = await fetch(`${this.apiUrl}/api/sync/manifest`, {
+    const res = await this.fetchWithRetry(`${this.apiUrl}/api/sync/manifest`, {
       method: "PUT",
       headers: {
         Authorization: `Bearer ${this.token}`,
@@ -29018,7 +29035,7 @@ class CcsiniClient {
       throw new Error("Failed to upload manifest");
   }
   async uploadBlob(hash, encryptedData) {
-    const res = await fetch(`${this.apiUrl}/api/sync/blob/${hash}`, {
+    const res = await this.fetchWithRetry(`${this.apiUrl}/api/sync/blob/${hash}`, {
       method: "PUT",
       headers: {
         Authorization: `Bearer ${this.token}`,
@@ -29030,7 +29047,7 @@ class CcsiniClient {
       throw new Error(`Failed to upload blob ${hash}`);
   }
   async downloadBlob(hash) {
-    const res = await fetch(`${this.apiUrl}/api/sync/blob/${hash}`, {
+    const res = await this.fetchWithRetry(`${this.apiUrl}/api/sync/blob/${hash}`, {
       headers: this.getHeaders()
     });
     if (!res.ok)
@@ -29039,7 +29056,7 @@ class CcsiniClient {
     return new Uint8Array(buffer);
   }
   async batchDownload(hashes) {
-    const res = await fetch(`${this.apiUrl}/api/sync/batch-download`, {
+    const res = await this.fetchWithRetry(`${this.apiUrl}/api/sync/batch-download`, {
       method: "POST",
       headers: this.getHeaders(),
       body: JSON.stringify({ hashes })
@@ -29054,7 +29071,7 @@ class CcsiniClient {
     return result;
   }
   async listBlobs() {
-    const res = await fetch(`${this.apiUrl}/api/sync/blobs`, {
+    const res = await this.fetchWithRetry(`${this.apiUrl}/api/sync/blobs`, {
       headers: this.getHeaders()
     });
     if (!res.ok)
@@ -29062,7 +29079,7 @@ class CcsiniClient {
     return res.json();
   }
   async deleteBlobs(hashes) {
-    const res = await fetch(`${this.apiUrl}/api/sync/blobs/delete`, {
+    const res = await this.fetchWithRetry(`${this.apiUrl}/api/sync/blobs/delete`, {
       method: "POST",
       headers: this.getHeaders(),
       body: JSON.stringify({ hashes })
@@ -29081,7 +29098,7 @@ class CcsiniClient {
       throw new Error("Failed to wipe account data");
   }
   async putProjects(projects, device) {
-    const res = await fetch(`${this.apiUrl}/api/sync/projects`, {
+    const res = await this.fetchWithRetry(`${this.apiUrl}/api/sync/projects`, {
       method: "PUT",
       headers: this.getHeaders(),
       body: JSON.stringify({ projects, device, timestamp: Date.now() })
@@ -29091,6 +29108,17 @@ class CcsiniClient {
       throw new Error(`Failed to send projects (${res.status}): ${text}`);
     }
   }
+  async checkBlobsExist(hashes) {
+    const res = await this.fetchWithRetry(`${this.apiUrl}/api/sync/blobs/exists`, {
+      method: "POST",
+      headers: this.getHeaders(),
+      body: JSON.stringify({ hashes })
+    });
+    if (!res.ok)
+      throw new Error("Failed to check blob existence");
+    const data = await res.json();
+    return data.exists;
+  }
   async resetAll() {
     const res = await fetch(`${this.apiUrl}/api/sync/reset`, {
       method: "DELETE",
@@ -29101,7 +29129,7 @@ class CcsiniClient {
     return res.json();
   }
   async heartbeat(mode, stats) {
-    const res = await fetch(`${this.apiUrl}/api/sync/heartbeat`, {
+    const res = await this.fetchWithRetry(`${this.apiUrl}/api/sync/heartbeat`, {
       method: "POST",
       headers: this.getHeaders(),
       body: JSON.stringify({
@@ -29123,7 +29151,7 @@ class CcsiniClient {
     return {};
   }
   async logSyncEvent(event) {
-    await fetch(`${this.apiUrl}/api/sync/log`, {
+    await this.fetchWithRetry(`${this.apiUrl}/api/sync/log`, {
       method: "POST",
       headers: this.getHeaders(),
       body: JSON.stringify(event)
@@ -29136,6 +29164,7 @@ import { readFile as readFile6, writeFile as writeFile5, mkdir as mkdir2 } from
 import { join as join6, dirname } from "path";
 import { homedir as homedir3 } from "os";
 import { createHash as createHash2 } from "crypto";
+import { gzipSync, gunzipSync } from "zlib";
 
 // src/core/manifest.ts
 import { readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
@@ -29402,6 +29431,30 @@ init_src();
 function blobKey(filePath, contentHash) {
   return createHash2("sha256").update(`${filePath}:${contentHash}`).digest("hex");
 }
+var COMPRESS_FLAG = 1;
+var RAW_FLAG = 0;
+function compressForUpload(plaintext) {
+  const compressed = gzipSync(plaintext);
+  if (compressed.length < plaintext.length) {
+    const result2 = new Uint8Array(1 + compressed.length);
+    result2[0] = COMPRESS_FLAG;
+    result2.set(compressed, 1);
+    return result2;
+  }
+  const result = new Uint8Array(1 + plaintext.length);
+  result[0] = RAW_FLAG;
+  result.set(plaintext, 1);
+  return result;
+}
+function decompressFromDownload(data) {
+  if (data.length === 0)
+    return data;
+  if (data[0] === COMPRESS_FLAG)
+    return gunzipSync(data.slice(1));
+  if (data[0] === RAW_FLAG)
+    return data.slice(1);
+  return data;
+}
 function getClaudeDir() {
   return join6(homedir3(), ".claude");
 }
@@ -29438,11 +29491,13 @@ async function pushSync(client, masterKey, deviceName, configDir, onProgress, se
   const conflicts = [];
   let bytesTransferred = 0;
   const progress = onProgress ?? (() => {});
-  const { manifest: localManifest, cacheStats } = await generateManifest(claudeDir, deviceName, progress, sessionOptions);
+  progress("Scanning local files & fetching remote manifest...");
+  const [{ manifest: localManifest, cacheStats }, remoteManifestEnc] = await Promise.all([
+    generateManifest(claudeDir, deviceName, progress, sessionOptions),
+    client.getManifest()
+  ]);
   const fileCount = Object.keys(localManifest.files).length;
   progress(`Scanned ${fileCount} files`);
-  progress("Fetching remote manifest...");
-  const remoteManifestEnc = await client.getManifest();
   let remoteManifest = null;
   if (remoteManifestEnc) {
     try {
@@ -29456,6 +29511,17 @@ async function pushSync(client, masterKey, deviceName, configDir, onProgress, se
   const diffs = diffManifests(localManifest, remoteManifest);
   const toPush = diffs.filter((d) => d.action === "push" || d.action === "merge");
   progress(`${toPush.length} files to push`);
+  if (toPush.length === 0) {
+    return {
+      action: "push",
+      filesChanged: 0,
+      bytesTransferred: 0,
+      durationMs: Date.now() - start,
+      errors: [],
+      conflicts: [],
+      cacheStats
+    };
+  }
   if (remoteManifest && !pushOptions?.skipConflictBackup) {
     const merges = toPush.filter((d) => d.action === "merge" && d.remoteHash);
     for (const diff of merges) {
@@ -29466,7 +29532,8 @@ async function pushSync(client, masterKey, deviceName, configDir, onProgress, se
         } catch {
           encrypted = await client.downloadBlob(diff.remoteHash);
         }
-        const decrypted = decryptFile(masterKey, diff.path, encrypted);
+        const decryptedRaw = decryptFile(masterKey, diff.path, encrypted);
+        const decrypted = decompressFromDownload(decryptedRaw);
         const conflictPath = join6(claudeDir, `${diff.path}.conflict`);
         await mkdir2(dirname(conflictPath), { recursive: true });
         await writeFile5(conflictPath, decrypted);
@@ -29475,30 +29542,32 @@ async function pushSync(client, masterKey, deviceName, configDir, onProgress, se
       } catch {}
     }
   }
+  const pushKeys = toPush.map((d) => blobKey(d.path, d.localHash));
+  let existing = {};
+  try {
+    const batchResults = await Promise.all(chunkArray(pushKeys, 100).map((batch) => client.checkBlobsExist(batch)));
+    for (const r of batchResults)
+      Object.assign(existing, r);
+  } catch {}
+  const toUpload = toPush.filter((d) => !existing[blobKey(d.path, d.localHash)]);
+  progress(`${toPush.length} changed, ${toUpload.length} to upload (${toPush.length - toUpload.length} skipped)`);
   let uploaded = 0;
   const failedPaths = new Set;
-  const chunks = chunkArray(toPush, MAX_CONCURRENT_TRANSFERS);
+  const chunks = chunkArray(toUpload, MAX_CONCURRENT_TRANSFERS);
   for (const chunk of chunks) {
     await Promise.all(chunk.map(async (diff) => {
-      const MAX_RETRIES = 3;
-      for (let attempt = 1;attempt <= MAX_RETRIES; attempt++) {
-        try {
-          const filePath = join6(claudeDir, diff.path);
-          const content = await readFile6(filePath);
-          const encrypted = encryptFile(masterKey, diff.path, content);
-          await client.uploadBlob(blobKey(diff.path, diff.localHash), encrypted);
-          bytesTransferred += encrypted.length;
-          uploaded++;
-          progress(`Uploading ${uploaded}/${toPush.length}: ${diff.path}`);
-          return;
-        } catch (e) {
-          if (attempt < MAX_RETRIES) {
-            await new Promise((r) => setTimeout(r, 500 * attempt));
-          } else {
-            failedPaths.add(diff.path);
-            errors2.push(`Push ${diff.path}: ${e.message}`);
-          }
-        }
+      try {
+        const filePath = join6(claudeDir, diff.path);
+        const content = await readFile6(filePath);
+        const compressed = compressForUpload(content);
+        const encrypted = encryptFile(masterKey, diff.path, compressed);
+        await client.uploadBlob(blobKey(diff.path, diff.localHash), encrypted);
+        bytesTransferred += encrypted.length;
+        uploaded++;
+        progress(`Uploading ${uploaded}/${toUpload.length}: ${diff.path}`);
+      } catch (e) {
+        failedPaths.add(diff.path);
+        errors2.push(`Push ${diff.path}: ${e.message}`);
       }
     }));
   }
@@ -29510,22 +29579,21 @@ async function pushSync(client, masterKey, deviceName, configDir, onProgress, se
   }
   const manifestJson = JSON.stringify(localManifest);
   const manifestEnc = encryptFile(masterKey, "__manifest__", new TextEncoder().encode(manifestJson));
-  await client.putManifest(manifestEnc);
-  await saveManifest(configDir, localManifest);
+  await Promise.all([
+    client.putManifest(manifestEnc),
+    saveManifest(configDir, localManifest)
+  ]);
   const durationMs = Date.now() - start;
   progress("Logging sync event...");
-  await client.logSyncEvent({
-    action: "push",
-    filesChanged: toPush.length,
-    bytesTransferred,
-    durationMs
-  });
-  try {
-    const projects = extractProjects(localManifest);
-    if (projects.length > 0) {
-      await client.putProjects(projects, deviceName);
-    }
-  } catch {}
+  await Promise.all([
+    client.logSyncEvent({
+      action: "push",
+      filesChanged: toPush.length,
+      bytesTransferred,
+      durationMs
+    }).catch(() => {}),
+    extractAndSendProjects(client, localManifest, deviceName).catch(() => {})
+  ]);
   return {
     action: "push",
     filesChanged: toPush.length,
@@ -29579,56 +29647,84 @@ async function pullSync(client, masterKey, deviceName, configDir, onProgress, se
   const toPull = diffs.filter((d) => (d.action === "pull" || d.action === "merge") && !isExcluded(d.path) && (sessionsEnabled || !isSessionFile(d.path)));
   progress(`${toPull.length} files to pull`);
   let downloaded = 0;
-  const chunks = chunkArray(toPull, MAX_CONCURRENT_TRANSFERS);
-  for (const chunk of chunks) {
-    await Promise.all(chunk.map(async (diff) => {
-      try {
-        let encrypted;
+  const keyToDiffs = new Map;
+  for (const diff of toPull) {
+    const key = blobKey(diff.path, diff.remoteHash);
+    const list = keyToDiffs.get(key) ?? [];
+    list.push(diff);
+    keyToDiffs.set(key, list);
+  }
+  const uniqueKeys = Array.from(keyToDiffs.keys());
+  const batches = chunkArray(uniqueKeys, BATCH_DOWNLOAD_SIZE);
+  const downloadedBlobs = new Map;
+  for (const batch of batches) {
+    try {
+      const results = await client.batchDownload(batch);
+      for (const [key, data] of Object.entries(results)) {
+        if (data)
+          downloadedBlobs.set(key, data);
+      }
+    } catch {
+      for (const key of batch) {
+        try {
+          const data = await client.downloadBlob(key);
+          downloadedBlobs.set(key, data);
+        } catch {}
+      }
+    }
+  }
+  for (const diff of toPull) {
+    try {
+      const key = blobKey(diff.path, diff.remoteHash);
+      let encrypted = downloadedBlobs.get(key);
+      if (!encrypted) {
         try {
-          encrypted = await client.downloadBlob(blobKey(diff.path, diff.remoteHash));
-        } catch {
           encrypted = await client.downloadBlob(diff.remoteHash);
+        } catch {
+          errors2.push(`Pull ${diff.path}: blob not found`);
+          continue;
         }
-        bytesTransferred += encrypted.length;
-        const decrypted = decryptFile(masterKey, diff.path, encrypted);
-        if (diff.action === "merge" && diff.localHash) {
-          const localPath2 = join6(claudeDir, diff.path);
-          const localContent = await readFile6(localPath2, "utf-8");
-          const remoteContent = new TextDecoder().decode(decrypted);
-          if (diff.category === "session") {
-            const merged = mergeSessionFiles(localContent, remoteContent);
-            await writeFile5(localPath2, merged);
-            downloaded++;
-            progress(`Downloading ${downloaded}/${toPull.length}: ${diff.path}`);
-            return;
-          }
-          const entry = remoteManifest.files[diff.path];
-          const localEntry = localManifest?.files[diff.path];
-          if (localEntry && entry) {
-            const result = mergeLastWriteWins(localContent, remoteContent, localEntry.modified, entry.modified);
-            await writeFile5(localPath2, result.content);
-            await writeFile5(`${localPath2}.conflict`, result.backupContent);
-            conflicts.push(diff.path);
-            downloaded++;
-            progress(`Downloading ${downloaded}/${toPull.length}: ${diff.path}`);
-            return;
-          }
-          await writeFile5(`${localPath2}.conflict`, localContent);
-          await writeFile5(localPath2, remoteContent);
+      }
+      bytesTransferred += encrypted.length;
+      const decryptedRaw = decryptFile(masterKey, diff.path, encrypted);
+      const decrypted = decompressFromDownload(decryptedRaw);
+      if (diff.action === "merge" && diff.localHash) {
+        const localPath2 = join6(claudeDir, diff.path);
+        const localContent = await readFile6(localPath2, "utf-8");
+        const remoteContent = new TextDecoder().decode(decrypted);
+        if (diff.category === "session") {
+          const merged = mergeSessionFiles(localContent, remoteContent);
+          await writeFile5(localPath2, merged);
+          downloaded++;
+          progress(`Downloading ${downloaded}/${toPull.length}: ${diff.path}`);
+          continue;
+        }
+        const entry = remoteManifest.files[diff.path];
+        const localEntry = localManifest?.files[diff.path];
+        if (localEntry && entry) {
+          const result = mergeLastWriteWins(localContent, remoteContent, localEntry.modified, entry.modified);
+          await writeFile5(localPath2, result.content);
+          await writeFile5(`${localPath2}.conflict`, result.backupContent);
           conflicts.push(diff.path);
           downloaded++;
-          progress(`Downloading ${downloaded}/${toPull.length}: ${diff.path} (conflict saved)`);
-          return;
+          progress(`Downloading ${downloaded}/${toPull.length}: ${diff.path}`);
+          continue;
         }
-        const localPath = join6(claudeDir, diff.path);
-        await mkdir2(dirname(localPath), { recursive: true });
-        await writeFile5(localPath, decrypted);
+        await writeFile5(`${localPath2}.conflict`, localContent);
+        await writeFile5(localPath2, remoteContent);
+        conflicts.push(diff.path);
         downloaded++;
-        progress(`Downloading ${downloaded}/${toPull.length}: ${diff.path}`);
-      } catch (e) {
-        errors2.push(`Pull ${diff.path}: ${e.message}`);
+        progress(`Downloading ${downloaded}/${toPull.length}: ${diff.path} (conflict saved)`);
+        continue;
       }
-    }));
+      const localPath = join6(claudeDir, diff.path);
+      await mkdir2(dirname(localPath), { recursive: true });
+      await writeFile5(localPath, decrypted);
+      downloaded++;
+      progress(`Downloading ${downloaded}/${toPull.length}: ${diff.path}`);
+    } catch (e) {
+      errors2.push(`Pull ${diff.path}: ${e.message}`);
+    }
   }
   progress("Saving manifest...");
   await saveManifest(configDir, remoteManifest);
@@ -29639,7 +29735,7 @@ async function pullSync(client, masterKey, deviceName, configDir, onProgress, se
     filesChanged: toPull.length,
     bytesTransferred,
     durationMs
-  });
+  }).catch(() => {});
   return {
     action: "pull",
     filesChanged: toPull.length,
@@ -29649,6 +29745,12 @@ async function pullSync(client, masterKey, deviceName, configDir, onProgress, se
     conflicts
   };
 }
+async function extractAndSendProjects(client, manifest, deviceName) {
+  const projects = extractProjects(manifest);
+  if (projects.length > 0) {
+    await client.putProjects(projects, deviceName);
+  }
+}
 function chunkArray(arr, size) {
   const chunks = [];
   for (let i = 0;i < arr.length; i += size) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccsini",
-  "version": "0.1.60",
+  "version": "0.1.62",
   "description": "Claude Code seamless sync across devices",
   "type": "module",
   "bin": {