ccsini 0.1.59 → 0.1.61

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"],
@@ -28005,6 +28005,42 @@ var init_auth = __esm(() => {
   init_src();
 });
 
+// src/core/schema.ts
+var exports_schema = {};
+__export(exports_schema, {
+  saveDefaultSchema: () => saveDefaultSchema,
+  loadSchema: () => loadSchema,
+  getEnabledCategories: () => getEnabledCategories
+});
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { join as join2 } from "path";
+async function saveDefaultSchema(configDir) {
+  const schema = buildDefaultSchema();
+  await writeFile2(join2(configDir, "schema.yaml"), JSON.stringify(schema, null, 2));
+}
+async function loadSchema(configDir) {
+  const raw = await readFile2(join2(configDir, "schema.yaml"), "utf-8");
+  return JSON.parse(raw);
+}
+function getEnabledCategories(schema) {
+  return Object.entries(schema.categories).filter(([, config]) => config.enabled).map(([name]) => name);
+}
+function buildDefaultSchema() {
+  const categories = {};
+  for (const [cat, patterns] of Object.entries(DEFAULT_CATEGORY_PATTERNS)) {
+    const category = cat;
+    categories[category] = {
+      enabled: true,
+      patterns,
+      merge: MERGE_STRATEGIES[category]
+    };
+  }
+  return { version: 1, categories };
+}
+var init_schema = __esm(() => {
+  init_src();
+});
+
 // ../../node_modules/.bun/commander@13.1.0/node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
 var {
@@ -28022,7 +28058,7 @@ var {
 } = import__.default;
 
 // src/version.ts
-var VERSION = "0.1.59";
+var VERSION = "0.1.61";
 
 // src/commands/init.ts
 init_source();
@@ -28765,26 +28801,8 @@ async function saveSessionConfig(configDir, sessionConfig) {
   await writeFile(configPath, JSON.stringify(config, null, 2));
 }
 
-// src/core/schema.ts
-init_src();
-import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import { join as join2 } from "path";
-async function saveDefaultSchema(configDir) {
-  const schema = buildDefaultSchema();
-  await writeFile2(join2(configDir, "schema.yaml"), JSON.stringify(schema, null, 2));
-}
-function buildDefaultSchema() {
-  const categories = {};
-  for (const [cat, patterns] of Object.entries(DEFAULT_CATEGORY_PATTERNS)) {
-    const category = cat;
-    categories[category] = {
-      enabled: true,
-      patterns,
-      merge: MERGE_STRATEGIES[category]
-    };
-  }
-  return { version: 1, categories };
-}
+// src/commands/init.ts
+init_schema();
 
 // src/hooks/installer.ts
 import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
@@ -28949,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}`,
@@ -28977,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)
@@ -28988,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}`,
@@ -29000,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}`,
@@ -29012,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)
@@ -29021,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 })
@@ -29036,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)
@@ -29044,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 })
@@ -29063,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() })
@@ -29073,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",
@@ -29083,7 +29129,7 @@ class CcsiniClient {
     return res.json();
   }
   async heartbeat(mode, stats) {
-    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({
@@ -29092,13 +29138,20 @@ class CcsiniClient {
           pushCount: stats.pushCount,
           pullCount: stats.pullCount,
           lastError: stats.lastError,
-          conflicts: stats.conflicts
+          conflicts: stats.conflicts,
+          version: stats.version,
+          categories: stats.categories,
+          conflictFiles: stats.conflictFiles
         }
       })
     });
+    if (res.ok) {
+      return res.json();
+    }
+    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)
@@ -29111,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";
@@ -29377,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");
 }
@@ -29441,7 +29519,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);
@@ -29450,30 +29529,32 @@ async function pushSync(client, masterKey, deviceName, configDir, onProgress, se
       } catch {}
     }
   }
+  const pushKeys = toPush.map((d) => blobKey(d.path, d.localHash));
+  let existing = {};
+  try {
+    for (const batch of chunkArray(pushKeys, 100)) {
+      Object.assign(existing, await client.checkBlobsExist(batch));
+    }
+  } 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}`);
       }
     }));
   }
@@ -29554,56 +29635,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);
@@ -31766,25 +31875,53 @@ async function runDaemon() {
       log(configDir, `Pull error: ${e.message}`);
     }
   }
-  async function countConflicts() {
+  async function listConflictFiles() {
     try {
       const { readdir: readdir4 } = await import("fs/promises");
       const files = await readdir4(configDir);
-      return files.filter((f) => f.endsWith(".conflict")).length;
+      return files.filter((f) => f.endsWith(".conflict"));
     } catch {
-      return 0;
+      return [];
     }
   }
+  async function getCategories() {
+    try {
+      const { loadSchema: loadSchema2, getEnabledCategories: getEnabledCategories2 } = await Promise.resolve().then(() => (init_schema(), exports_schema));
+      const schema = await loadSchema2(configDir);
+      return getEnabledCategories2(schema);
+    } catch {
+      return [];
+    }
+  }
+  async function deleteConflictFiles() {
+    try {
+      const { unlink: unlink2 } = await import("fs/promises");
+      const files = await listConflictFiles();
+      for (const f of files) {
+        await unlink2(join11(configDir, f)).catch(() => {});
+      }
+      if (files.length > 0) {
+        log(configDir, `Resolved ${files.length} conflict file(s) via dashboard`);
+      }
+    } catch {}
+  }
   async function doHeartbeat() {
     try {
       const client = await getAuthenticatedClient(configDir);
-      const conflicts = await countConflicts();
-      await client.heartbeat("daemon", {
+      const conflictFiles = await listConflictFiles();
+      const categories = await getCategories();
+      const result = await client.heartbeat("daemon", {
         pushCount: status.pushCount,
         pullCount: status.pullCount,
         lastError: status.lastError,
-        conflicts
+        conflicts: conflictFiles.length,
+        version: VERSION,
+        categories,
+        conflictFiles
       });
+      if (result.resolveConflicts) {
+        await deleteConflictFiles();
+      }
     } catch (e) {
       log(configDir, `Heartbeat error: ${e.message}`);
     }

package/package.json

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