@claude-sync/cli 0.1.13 → 0.1.15

package/dist/bin/claude-sync.js

@@ -4697,16 +4697,49 @@ function formatBytes(bytes) {
   const i = Math.floor(Math.log(bytes) / Math.log(k));
   return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
 }
-function formatProgress(current, total) {
-  const percentage = total > 0 ? Math.round(current / total * 100) : 0;
-  return `${current}/${total} (${percentage}%)`;
+function createBar(percent, width = 20) {
+  const filled = Math.round(percent / 100 * width);
+  const empty = width - filled;
+  return dimColor("[") + successColor("\u2588".repeat(filled)) + dimColor("\u2591".repeat(empty) + "]");
 }
-var brandColor;
+function formatSpeed(bytesPerSecond) {
+  return `${formatBytes(bytesPerSecond)}/s`;
+}
+function createTransferProgress(initialLabel, totalBytes, spinner) {
+  const startTime = Date.now();
+  let lastUpdate = 0;
+  let currentLabel = initialLabel;
+  return {
+    update(bytesTransferred) {
+      const now = Date.now();
+      if (now - lastUpdate < 50) return;
+      lastUpdate = now;
+      const percent = Math.round(bytesTransferred / totalBytes * 100);
+      const elapsed = (now - startTime) / 1e3;
+      const speed = elapsed > 0 ? bytesTransferred / elapsed : 0;
+      const bar = createBar(percent);
+      spinner.text = `${currentLabel}  ${bar} ${dimColor(`${percent}%`)} ${dimColor("\u2022")} ${formatBytes(bytesTransferred)}/${formatBytes(totalBytes)} ${dimColor("\u2022")} ${formatSpeed(speed)}`;
+    },
+    setLabel(label) {
+      currentLabel = label;
+    },
+    finish(message) {
+      if (message) {
+        spinner.succeed(message);
+      } else {
+        spinner.stop();
+      }
+    }
+  };
+}
+var brandColor, dimColor, successColor;
 var init_progress = __esm({
   "src/lib/progress.ts"() {
     "use strict";
     init_esm_shims();
     brandColor = chalk.hex("#8a8cdd");
+    dimColor = chalk.dim;
+    successColor = chalk.hex("#22c55e");
   }
 });
 
@@ -5127,32 +5160,105 @@ var init_sync_engine = __esm({
   }
 });
 
-// src/lib/compress.ts
+// src/lib/bundle.ts
 import { createGzip, createGunzip } from "zlib";
 import { createReadStream, createWriteStream } from "fs";
+import { readFile as readFile2, stat as stat2, mkdir as mkdir2 } from "fs/promises";
+import { join as join3, dirname as dirname2 } from "path";
 import { pipeline } from "stream/promises";
-function compressBuffer(data) {
-  return new Promise((resolve, reject) => {
-    const gzip = createGzip();
-    const chunks = [];
-    gzip.on("data", (chunk) => chunks.push(chunk));
-    gzip.on("end", () => resolve(Buffer.concat(chunks)));
-    gzip.on("error", reject);
-    gzip.end(data);
+import { pack, extract } from "tar-stream";
+async function createBundle(sourceDir, files, outputPath, onProgress) {
+  const totalBytes = files.reduce((sum, f) => sum + f.size, 0);
+  let processedBytes = 0;
+  const archive = pack();
+  const gzip = createGzip({ level: 6 });
+  const output = createWriteStream(outputPath);
+  const pipelinePromise = pipeline(archive, gzip, output);
+  for (const file of files) {
+    const filePath = join3(sourceDir, file.path);
+    const content = await readFile2(filePath);
+    archive.entry({ name: file.path, size: content.length }, content);
+    processedBytes += file.size;
+    onProgress?.(processedBytes, totalBytes, "compressing");
+  }
+  archive.finalize();
+  await pipelinePromise;
+  const outputStat = await stat2(outputPath);
+  return {
+    size: outputStat.size,
+    fileCount: files.length,
+    originalSize: totalBytes
+  };
+}
+async function extractBundle(bundlePath, targetDir, onProgress) {
+  await mkdir2(targetDir, { recursive: true });
+  const extractor = extract();
+  const gunzip = createGunzip();
+  const input = createReadStream(bundlePath);
+  let count = 0;
+  extractor.on("entry", (header, stream, next) => {
+    count++;
+    onProgress?.(count, header.name);
+    const outputPath = join3(targetDir, header.name);
+    const dir = dirname2(outputPath);
+    mkdir2(dir, { recursive: true }).then(() => {
+      const fileOutput = createWriteStream(outputPath);
+      stream.pipe(fileOutput);
+      fileOutput.on("finish", next);
+      fileOutput.on("error", next);
+    }).catch(next);
   });
+  await pipeline(input, gunzip, extractor);
+  return count;
 }
-function decompressBuffer(data) {
-  return new Promise((resolve, reject) => {
-    const gunzip = createGunzip();
-    const chunks = [];
-    gunzip.on("data", (chunk) => chunks.push(chunk));
-    gunzip.on("end", () => resolve(Buffer.concat(chunks)));
-    gunzip.on("error", reject);
-    gunzip.end(data);
+async function streamUpload(url, filePath, onProgress) {
+  const fileStat = await stat2(filePath);
+  const totalSize = fileStat.size;
+  const fileStream = createReadStream(filePath);
+  let uploaded = 0;
+  const chunks = [];
+  for await (const chunk of fileStream) {
+    chunks.push(chunk);
+    uploaded += chunk.length;
+    onProgress?.(uploaded, totalSize);
+  }
+  const body = Buffer.concat(chunks);
+  const response = await fetch(url, {
+    method: "PUT",
+    body,
+    headers: {
+      "Content-Type": "application/gzip",
+      "Content-Length": String(totalSize)
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`Upload failed: ${response.status} ${response.statusText}`);
+  }
+}
+async function streamDownload(url, outputPath, expectedSize, onProgress) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Download failed: ${response.status} ${response.statusText}`);
+  }
+  const reader = response.body?.getReader();
+  if (!reader) throw new Error("No response body");
+  const output = createWriteStream(outputPath);
+  let downloaded = 0;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    output.write(value);
+    downloaded += value.length;
+    onProgress?.(downloaded, expectedSize);
+  }
+  await new Promise((resolve, reject) => {
+    output.end();
+    output.on("finish", resolve);
+    output.on("error", reject);
   });
 }
-var init_compress = __esm({
-  "src/lib/compress.ts"() {
+var init_bundle = __esm({
+  "src/lib/bundle.ts"() {
     "use strict";
     init_esm_shims();
   }
@@ -5166,9 +5272,9 @@ __export(sync_exports, {
 });
 import { Command as Command4 } from "commander";
 import { select as select2, isCancel as isCancel3 } from "@clack/prompts";
-import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, lstat as lstat2, symlink, unlink, rename } from "fs/promises";
-import { join as join3, dirname as dirname2 } from "path";
-import { homedir as homedir4 } from "os";
+import { mkdir as mkdir3, lstat as lstat2, symlink, unlink, rename, rm } from "fs/promises";
+import { join as join4 } from "path";
+import { homedir as homedir4, tmpdir } from "os";
 async function runSync(options) {
   printIntro("Sync");
   const config = await loadConfig();
@@ -5183,11 +5289,11 @@ async function runSync(options) {
   const cwd = process.cwd();
   const ctx = await resolveProjectState(cwd);
   const client = new ApiClient(config.apiUrl);
-  const projectsDir = join3(homedir4(), import_utils3.CLAUDE_DIR, import_utils3.PROJECTS_DIR);
+  const projectsDir = join4(homedir4(), import_utils3.CLAUDE_DIR, import_utils3.PROJECTS_DIR);
   const projectLink = await loadProjectLink(cwd);
   let projectDir = ctx.projectDir;
   if (ctx.state === "symlink" && ctx.symlinkTarget) {
-    projectDir = join3(projectsDir, ctx.symlinkTarget);
+    projectDir = join4(projectsDir, ctx.symlinkTarget);
   }
   printInfo(`Project: ${brand(cwd)}`);
   if (ctx.state === "symlink") {
@@ -5203,7 +5309,6 @@ async function runSync(options) {
     if (result === "pulled") {
       const finalManifest2 = await buildProjectManifest(cwd);
       await saveProjectManifest(cwd, finalManifest2);
-      printSuccess("Sessions synced from remote device.");
       printOutro("Done");
       return;
     }
@@ -5216,13 +5321,13 @@ async function runSync(options) {
     printOutro("Done");
     return;
   }
-  let pushResult = { uploaded: 0, projectId: projectLink.projectId, failed: false };
-  let pullResult = { downloaded: 0, failed: false };
+  let pushResult = { fileCount: 0, projectId: projectLink.projectId, failed: false };
+  let pullResult = { fileCount: 0, failed: false };
   if (manifest.length > 0) {
-    pushResult = await pushPhase(client, config.deviceId, cwd, manifest, projectDir, projectLink.projectId, options);
+    pushResult = await bundlePushPhase(client, config.deviceId, cwd, manifest, projectDir, projectLink.projectId, options);
   }
   if (!pushResult.failed) {
-    pullResult = await pullPhase(client, config.deviceId, cwd, projectDir, projectLink.projectId, options);
+    pullResult = await bundlePullPhase(client, config.deviceId, cwd, projectDir, projectLink.projectId, options);
   }
   if (pushResult.failed && pullResult.failed) {
     printOutro("Sync failed.");
@@ -5230,11 +5335,11 @@ async function runSync(options) {
   }
   const finalManifest = await buildProjectManifest(cwd);
   await saveProjectManifest(cwd, finalManifest);
-  if (pushResult.uploaded > 0 || pullResult.downloaded > 0) {
+  if (pushResult.fileCount > 0 || pullResult.fileCount > 0) {
     const parts = [];
-    if (pushResult.uploaded > 0) parts.push(`${success(`+${pushResult.uploaded}`)} pushed`);
-    if (pullResult.downloaded > 0) parts.push(`${success(`+${pullResult.downloaded}`)} pulled`);
-    printSuccess(`Synced: ${parts.join(", ")}`);
+    if (pushResult.fileCount > 0) parts.push(`${success(`${pushResult.fileCount}`)} pushed`);
+    if (pullResult.fileCount > 0) parts.push(`${success(`${pullResult.fileCount}`)} pulled`);
+    printSuccess(`Synced: ${parts.join(", ")} files`);
   } else if (!pushResult.failed && !pullResult.failed) {
     printSuccess("Everything is up to date.");
   }
@@ -5282,15 +5387,12 @@ async function handleFirstRun(client, config, cwd, ctx, manifest, projectDir, pr
   });
   if (isCancel3(choice)) return "cancelled";
   if (choice === "push") {
-    const result = await pushPhase(client, config.deviceId, cwd, manifest, projectDir, void 0, options);
-    if (result.failed) {
+    const result2 = await bundlePushPhase(client, config.deviceId, cwd, manifest, projectDir, void 0, options);
+    if (result2.failed) {
       return "cancelled";
     }
-    if (result.uploaded > 0) {
-      printSuccess(`${success(`+${result.uploaded}`)} files pushed`);
-    }
     await saveProjectLink(cwd, {
-      projectId: result.projectId,
+      projectId: result2.projectId,
       foreignEncodedDir: ctx.encodedPath,
       linkedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
@@ -5334,7 +5436,7 @@ async function handleFirstRun(client, config, cwd, ctx, manifest, projectDir, pr
   if (existingCheck === "cancelled") {
     return "cancelled";
   }
-  const downloaded = await crossMachinePull(
+  const result = await crossMachineBundlePull(
     client,
     config.deviceId,
     cwd,
@@ -5344,7 +5446,7 @@ async function handleFirstRun(client, config, cwd, ctx, manifest, projectDir, pr
     projectsDir,
     options
   );
-  if (downloaded === 0 && !options.dryRun) {
+  if (result.fileCount === 0 && !options.dryRun) {
     printInfo("No files to download.");
     return "cancelled";
   }
@@ -5355,13 +5457,12 @@ async function handleFirstRun(client, config, cwd, ctx, manifest, projectDir, pr
       foreignEncodedDir: selectedProject.encodedDir,
       linkedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
-    printSuccess(`${success(`+${downloaded}`)} files pulled`);
     printInfo(`Symlink: ${dim(ctx.encodedPath)} \u2192 ${dim(selectedProject.encodedDir)}`);
   }
   return "pulled";
 }
 async function handleExistingSessionDir(projectsDir, localEncoded) {
-  const symlinkPath = join3(projectsDir, localEncoded);
+  const symlinkPath = join4(projectsDir, localEncoded);
   try {
     const stats = await lstat2(symlinkPath);
     if (stats.isSymbolicLink()) {
@@ -5398,8 +5499,8 @@ async function handleExistingSessionDir(projectsDir, localEncoded) {
   return "continue";
 }
 async function createProjectSymlink(projectsDir, localEncoded, foreignEncoded) {
-  const symlinkPath = join3(projectsDir, localEncoded);
-  await mkdir2(projectsDir, { recursive: true });
+  const symlinkPath = join4(projectsDir, localEncoded);
+  await mkdir3(projectsDir, { recursive: true });
   try {
     const stats = await lstat2(symlinkPath);
     if (stats.isSymbolicLink()) {
@@ -5409,188 +5510,177 @@ async function createProjectSymlink(projectsDir, localEncoded, foreignEncoded) {
   }
   await symlink(foreignEncoded, symlinkPath);
 }
-async function crossMachinePull(client, deviceId, projectPath, fromDeviceId, projectId, foreignEncodedDir, projectsDir, options) {
-  const spinner = createSpinner("Preparing pull from remote device...").start();
-  let prepareResponse;
-  try {
-    prepareResponse = await client.post("/api/sync/pull/prepare", {
-      deviceId,
-      projectPath,
-      fromDeviceId,
-      projectId
-    });
-  } catch (err) {
-    spinner.stop();
-    if (err instanceof AuthExpiredError) throw err;
-    printError(`Pull failed: ${err instanceof Error ? err.message : "Unknown error"}`);
-    return 0;
+async function bundlePushPhase(client, deviceId, projectPath, manifest, projectDir, projectId, options) {
+  if (manifest.length === 0) {
+    return { fileCount: 0, projectId: projectId || "", failed: false };
   }
-  spinner.stop();
-  const filesToDownload = prepareResponse.filesToDownload;
-  if (filesToDownload.length === 0) return 0;
-  printInfo(`${brand(String(filesToDownload.length))} files to pull`);
+  const totalBytes = manifest.reduce((sum, f) => sum + f.size, 0);
+  printInfo(`${brand(String(manifest.length))} files ${dim(`(${formatBytes(totalBytes)})`)} to push`);
   if (options.dryRun) {
     if (options.verbose) {
-      for (const entry of filesToDownload) {
-        console.log(`    ${brand("\u25CB")} ${entry.path} ${dim(`(${formatBytes(entry.size)})`)}`);
+      for (const entry of manifest) {
+        console.log(`    ${success("+")} ${entry.path} ${dim(`(${formatBytes(entry.size)})`)}`);
       }
     }
-    return filesToDownload.length;
+    return { fileCount: manifest.length, projectId: projectId || "", failed: false };
   }
-  const targetDir = join3(projectsDir, foreignEncodedDir);
-  let downloaded = 0;
-  for (const entry of filesToDownload) {
-    const dlSpinner = createSpinner(
-      `${formatProgress(downloaded + 1, filesToDownload.length)} ${entry.path}`
-    ).start();
+  const tempBundle = join4(tmpdir(), `claude-sync-bundle-${Date.now()}.tar.gz`);
+  try {
+    const spinner = createSpinner("Syncing...").start();
+    const bundleResult = await createBundle(projectDir, manifest, tempBundle, (bytes, total, phase) => {
+      if (phase === "compressing") {
+        const percent = Math.round(bytes / total * 100);
+        spinner.text = `Compressing files... ${dim(`${percent}%`)}`;
+      }
+    });
+    const progress = createTransferProgress("Uploading", bundleResult.size, spinner);
+    let prepareResponse;
     try {
-      const urlResponse = await client.post("/api/sync/pull/download-url", {
+      prepareResponse = await client.post("/api/sync/push/bundle/prepare", {
+        deviceId,
+        projectPath,
+        projectId,
+        manifest,
+        bundleSize: bundleResult.size
+      });
+    } catch (err) {
+      spinner.stop();
+      if (err instanceof AuthExpiredError) throw err;
+      printError(`Push failed: ${err instanceof Error ? err.message : "Unknown error"}`);
+      return { fileCount: 0, projectId: projectId || "", failed: true };
+    }
+    await streamUpload(prepareResponse.uploadUrl, tempBundle, (bytes, total) => {
+      progress.update(bytes);
+    });
+    try {
+      await client.post("/api/sync/push/bundle/complete", {
         syncEventId: prepareResponse.syncEventId,
-        key: entry.path
+        manifest
       });
-      const response = await fetch(urlResponse.url);
-      let data = Buffer.from(await response.arrayBuffer());
-      if (entry.isCompressed) {
-        data = await decompressBuffer(data);
-      }
-      const outputPath = join3(targetDir, entry.path);
-      await mkdir2(dirname2(outputPath), { recursive: true });
-      await writeFile2(outputPath, data);
-      downloaded++;
     } catch {
     }
-    dlSpinner.stop();
-  }
-  try {
-    await client.post("/api/sync/pull/complete", {
-      syncEventId: prepareResponse.syncEventId,
-      manifest: filesToDownload
-    });
-  } catch {
+    const compressionRatio = Math.round((1 - bundleResult.size / bundleResult.originalSize) * 100);
+    progress.finish(`Pushed ${manifest.length} files ${dim(`(${formatBytes(bundleResult.size)}, ${compressionRatio}% smaller)`)}`);
+    return { fileCount: manifest.length, projectId: prepareResponse.projectId, failed: false };
+  } finally {
+    try {
+      await rm(tempBundle, { force: true });
+    } catch {
+    }
   }
-  return downloaded;
 }
-async function pushPhase(client, deviceId, projectPath, manifest, projectDir, projectId, options) {
-  const spinner = createSpinner("Preparing push...").start();
+async function bundlePullPhase(client, deviceId, projectPath, projectDir, projectId, options) {
+  const spinner = createSpinner("Checking for updates...").start();
   let prepareResponse;
   try {
-    prepareResponse = await client.post("/api/sync/push/prepare", {
+    prepareResponse = await client.post("/api/sync/pull/bundle/prepare", {
       deviceId,
       projectPath,
-      projectId,
-      manifest
+      projectId
     });
   } catch (err) {
     spinner.stop();
     if (err instanceof AuthExpiredError) throw err;
-    printError(`Push failed: ${err instanceof Error ? err.message : "Unknown error"}`);
-    return { uploaded: 0, projectId: projectId || "", failed: true };
+    printError(`Pull failed: ${err instanceof Error ? err.message : "Unknown error"}`);
+    return { fileCount: 0, failed: true };
   }
-  spinner.stop();
-  const resolvedProjectId = prepareResponse.projectId;
-  const filesToUpload = prepareResponse.filesToUpload;
-  if (filesToUpload.length === 0) return { uploaded: 0, projectId: resolvedProjectId, failed: false };
-  printInfo(`${brand(String(filesToUpload.length))} files to push`);
+  if (!prepareResponse.downloadUrl || !prepareResponse.bundleSize) {
+    spinner.stop();
+    return { fileCount: 0, failed: false };
+  }
+  const fileCount = prepareResponse.manifest.length;
   if (options.dryRun) {
+    spinner.stop();
+    printInfo(`${brand(String(fileCount))} files to pull`);
     if (options.verbose) {
-      for (const entry of filesToUpload) {
-        console.log(`    ${success("+")} ${entry.path} ${dim(`(${formatBytes(entry.size)})`)}`);
+      for (const entry of prepareResponse.manifest) {
+        console.log(`    ${brand("\u25CB")} ${entry.path} ${dim(`(${formatBytes(entry.size)})`)}`);
       }
     }
-    return { uploaded: filesToUpload.length, projectId: resolvedProjectId, failed: false };
+    return { fileCount, failed: false };
   }
-  let uploaded = 0;
-  for (const entry of filesToUpload) {
-    const uploadSpinner = createSpinner(
-      `${formatProgress(uploaded + 1, filesToUpload.length)} ${entry.path}`
-    ).start();
+  const tempBundle = join4(tmpdir(), `claude-sync-bundle-${Date.now()}.tar.gz`);
+  try {
+    const progress = createTransferProgress("Downloading", prepareResponse.bundleSize, spinner);
+    await streamDownload(prepareResponse.downloadUrl, tempBundle, prepareResponse.bundleSize, (bytes) => {
+      progress.update(bytes);
+    });
+    spinner.text = "Extracting files...";
+    const extractedCount = await extractBundle(tempBundle, projectDir);
     try {
-      const urlResponse = await client.post("/api/sync/push/upload-url", {
+      const completeManifest = await walkDirectory(projectDir);
+      await client.post("/api/sync/pull/bundle/complete", {
         syncEventId: prepareResponse.syncEventId,
-        key: entry.path
-      });
-      const filePath = join3(projectDir, entry.path);
-      let body = await readFile2(filePath);
-      if (entry.isCompressed) {
-        body = await compressBuffer(body);
-      }
-      await fetch(urlResponse.url, {
-        method: "PUT",
-        body,
-        headers: { "Content-Type": "application/octet-stream" }
+        manifest: completeManifest
       });
-      uploaded++;
     } catch {
     }
-    uploadSpinner.stop();
-  }
-  try {
-    await client.post("/api/sync/push/complete", {
-      syncEventId: prepareResponse.syncEventId,
-      manifest
-    });
-  } catch {
+    progress.finish(`Pulled ${extractedCount} files ${dim(`(${formatBytes(prepareResponse.bundleSize)})`)}`);
+    return { fileCount: extractedCount, failed: false };
+  } finally {
+    try {
+      await rm(tempBundle, { force: true });
+    } catch {
+    }
   }
-  return { uploaded, projectId: resolvedProjectId, failed: false };
 }
-async function pullPhase(client, deviceId, projectPath, projectDir, projectId, options) {
-  const spinner = createSpinner("Preparing pull...").start();
+async function crossMachineBundlePull(client, deviceId, projectPath, fromDeviceId, projectId, foreignEncodedDir, projectsDir, options) {
+  const spinner = createSpinner("Preparing download...").start();
   let prepareResponse;
   try {
-    prepareResponse = await client.post("/api/sync/pull/prepare", {
+    prepareResponse = await client.post("/api/sync/pull/bundle/prepare", {
       deviceId,
       projectPath,
+      fromDeviceId,
       projectId
     });
   } catch (err) {
     spinner.stop();
     if (err instanceof AuthExpiredError) throw err;
     printError(`Pull failed: ${err instanceof Error ? err.message : "Unknown error"}`);
-    return { downloaded: 0, failed: true };
+    return { fileCount: 0, failed: true };
   }
-  spinner.stop();
-  const filesToDownload = prepareResponse.filesToDownload;
-  if (filesToDownload.length === 0) return { downloaded: 0, failed: false };
-  printInfo(`${brand(String(filesToDownload.length))} files to pull`);
+  if (!prepareResponse.downloadUrl || !prepareResponse.bundleSize) {
+    spinner.stop();
+    return { fileCount: 0, failed: false };
+  }
+  const fileCount = prepareResponse.manifest.length;
   if (options.dryRun) {
+    spinner.stop();
+    printInfo(`${brand(String(fileCount))} files to pull`);
     if (options.verbose) {
-      for (const entry of filesToDownload) {
+      for (const entry of prepareResponse.manifest) {
         console.log(`    ${brand("\u25CB")} ${entry.path} ${dim(`(${formatBytes(entry.size)})`)}`);
       }
     }
-    return { downloaded: filesToDownload.length, failed: false };
+    return { fileCount, failed: false };
   }
-  let downloaded = 0;
-  for (const entry of filesToDownload) {
-    const dlSpinner = createSpinner(
-      `${formatProgress(downloaded + 1, filesToDownload.length)} ${entry.path}`
-    ).start();
+  const targetDir = join4(projectsDir, foreignEncodedDir);
+  const tempBundle = join4(tmpdir(), `claude-sync-bundle-${Date.now()}.tar.gz`);
+  try {
+    const progress = createTransferProgress("Downloading", prepareResponse.bundleSize, spinner);
+    await streamDownload(prepareResponse.downloadUrl, tempBundle, prepareResponse.bundleSize, (bytes) => {
+      progress.update(bytes);
+    });
+    spinner.text = "Extracting files...";
+    await mkdir3(targetDir, { recursive: true });
+    const extractedCount = await extractBundle(tempBundle, targetDir);
     try {
-      const urlResponse = await client.post("/api/sync/pull/download-url", {
+      const completeManifest = await walkDirectory(targetDir);
+      await client.post("/api/sync/pull/bundle/complete", {
         syncEventId: prepareResponse.syncEventId,
-        key: entry.path
+        manifest: completeManifest
       });
-      const response = await fetch(urlResponse.url);
-      let data = Buffer.from(await response.arrayBuffer());
-      if (entry.isCompressed) {
-        data = await decompressBuffer(data);
-      }
-      const outputPath = join3(projectDir, entry.path);
-      await mkdir2(dirname2(outputPath), { recursive: true });
-      await writeFile2(outputPath, data);
-      downloaded++;
     } catch {
     }
-    dlSpinner.stop();
-  }
-  try {
-    await client.post("/api/sync/pull/complete", {
-      syncEventId: prepareResponse.syncEventId,
-      manifest: filesToDownload
-    });
-  } catch {
+    progress.finish(`Pulled ${extractedCount} files ${dim(`(${formatBytes(prepareResponse.bundleSize)})`)}`);
+    return { fileCount: extractedCount, failed: false };
+  } finally {
+    try {
+      await rm(tempBundle, { force: true });
+    } catch {
+    }
   }
-  return { downloaded, failed: false };
 }
 function syncCommand() {
   return new Command4("sync").description("Sync current project sessions with cloud").option("--dry-run", "Show what would be synced without syncing").option("--verbose", "Show detailed output").action(async (options) => {
@@ -5606,7 +5696,7 @@ var init_sync = __esm({
     init_api_client();
     init_sync_engine();
     init_progress();
-    init_compress();
+    init_bundle();
     import_utils3 = __toESM(require_dist(), 1);
     init_theme();
   }