aethel 0.3.3 → 0.3.5

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.3.5 (2026-04-05)
+
+- Add progress bars and spinners for all time-consuming CLI operations
+
+## 0.3.4 (2026-04-05)
+
+- Add empty folder sync support between local and Google Drive
+
 ## 0.3.3 (2026-04-05)
 
 - Persist credentials to ~/.config/aethel/ after auth for seamless init

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aethel",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "description": "Git-style Google Drive sync CLI with interactive TUI",
   "type": "module",
   "license": "MIT",

package/src/cli.js

@@ -31,6 +31,7 @@ import {
   DuplicateFoldersError,
 } from "./core/drive-api.js";
 import { createDefaultIgnoreFile, loadIgnoreRules } from "./core/ignore.js";
+import { createProgressBar, createSpinner } from "./core/progress.js";
 import { Repository } from "./core/repository.js";
 import { runTui } from "./tui/index.js";
 
@@ -42,16 +43,36 @@ function addAuthOptions(command) {
     .option("--token <path>", "Path to cached OAuth token JSON");
 }
 
-async function openRepo(options, { requireWorkspace = true } = {}) {
+async function openRepo(options, { requireWorkspace = true, silent = false } = {}) {
   const root = requireWorkspace ? requireRoot() : null;
   const repo = new Repository(root, {
     credentials: options.credentials,
     token: options.token,
   });
-  await repo.connect();
+  const spinner = silent ? null : createSpinner("Connecting to Google Drive...");
+  try {
+    await repo.connect();
+    spinner?.succeed("Connected to Google Drive");
+  } catch (err) {
+    spinner?.fail("Connection failed");
+    throw err;
+  }
   return repo;
 }
 
+async function loadStateWithProgress(repo, opts) {
+  const spinner = createSpinner("Loading workspace state...");
+  try {
+    const state = await repo.loadState(opts);
+    const n = state.diff.changes.length;
+    spinner.succeed(n ? `Loaded state — ${n} change(s) detected` : "Loaded state — everything up to date");
+    return state;
+  } catch (err) {
+    spinner.fail("Failed to load workspace state");
+    throw err;
+  }
+}
+
 function matchesPattern(targetPath, pattern) {
   if (targetPath === pattern) {
     return true;
@@ -117,7 +138,9 @@ function requireConfirmation(options) {
 
 async function handleAuth(options) {
   const repo = await openRepo(options, { requireWorkspace: false });
+  const spinner = createSpinner("Fetching account info...");
   const account = await repo.getAccountInfo();
+  spinner.succeed(`Authenticated as ${account.email}`);
 
   const credentialsPath = resolveCredentialsPath(options.credentials);
   await persistCredentials(credentialsPath);
@@ -134,7 +157,9 @@ async function handleAuth(options) {
 async function handleClean(options) {
   requireConfirmation(options);
   const repo = await openRepo(options, { requireWorkspace: false });
+  const spinner = createSpinner("Listing remote files...");
   const files = await repo.listRemoteFiles({ includeSharedDrives: Boolean(options.sharedDrives) });
+  spinner.succeed(`Found ${files.length} file(s) on Drive`);
 
   printCleanerPlan(files, options);
 
@@ -148,13 +173,15 @@ async function handleClean(options) {
     return;
   }
 
+  const bar = createProgressBar(`Cleaning ${files.length} file(s)`, files.length);
   const result = await repo.batchOperateFiles(files, {
     permanent: Boolean(options.permanent),
     includeSharedDrives: Boolean(options.sharedDrives),
-    onProgress: (done, total, verb, name) => {
-      console.log(`[${done}/${total}] ${verb}: ${name}`);
+    onProgress: (done) => {
+      bar.update(done);
     },
   });
+  bar.done(`Cleaned ${files.length} file(s)`);
 
   if (result.errors) {
     console.log(`Completed with ${result.errors} error(s) out of ${files.length} file(s).`);
@@ -171,8 +198,9 @@ async function handleInit(options) {
   // Interactive folder selection when no --drive-folder is provided
   if (!driveFolderId) {
     const repo = await openRepo(options, { requireWorkspace: false });
-    console.log("Fetching root-level Drive folders...");
+    const spinner = createSpinner("Fetching root-level Drive folders...");
     const folders = await repo.listRootFolders();
+    spinner.succeed(`Found ${folders.length} folder(s) in Drive root`);
 
     if (folders.length === 0) {
       console.log("No folders found in Drive root. Syncing entire My Drive.");
@@ -225,7 +253,7 @@ async function handleInit(options) {
 
 async function handleStatus(options) {
   const repo = await openRepo(options);
-  const { diff } = await repo.loadState();
+  const { diff } = await loadStateWithProgress(repo);
   const staged = repo.getStagedEntries();
 
   if (diff.isClean && staged.length === 0) {
@@ -264,7 +292,7 @@ async function handleStatus(options) {
 
 async function handleDiff(options) {
   const repo = await openRepo(options);
-  const { diff } = await repo.loadState();
+  const { diff } = await loadStateWithProgress(repo);
 
   if (diff.isClean) {
     console.log("No changes detected.");
@@ -298,7 +326,7 @@ async function handleDiff(options) {
 
 async function handleAdd(paths, options) {
   const repo = await openRepo(options);
-  const { diff } = await repo.loadState();
+  const { diff } = await loadStateWithProgress(repo);
 
   if (options.all) {
     const toStage = diff.changes.filter(
@@ -367,25 +395,22 @@ async function handleCommit(options, { repo: existingRepo } = {}) {
   }
 
   const message = options.message || "sync";
+  const bar = createProgressBar(`Syncing ${staged.length} change(s)`, staged.length);
 
-  console.log(`Committing ${staged.length} change(s)...`);
-
-  const result = await repo.executeStaged((done, total, verb, name) => {
-    if (done < total) {
-      console.log(`  [${done + 1}/${total}] ${verb}: ${name}`);
-    }
+  const result = await repo.executeStaged((done) => {
+    bar.update(done + 1);
   });
 
-  console.log(`\nCommit complete: ${result.summary}`);
+  bar.done(`Commit complete: ${result.summary}`);
   if (result.errors.length) {
     for (const error of result.errors) {
       console.log(`  ERROR: ${error}`);
     }
   }
 
-  console.log("Saving snapshot...");
+  const spinner = createSpinner("Saving snapshot...");
   await repo.saveSnapshot(message);
-  console.log(`Snapshot saved: "${message}"`);
+  spinner.succeed(`Snapshot saved: "${message}"`);
 }
 
 function handleLog(options) {
@@ -409,10 +434,10 @@ async function handleFetch(options) {
   const repo = await openRepo(options);
 
   repo.invalidateRemoteCache();
-  console.log("Fetching remote file list...");
+  const spinner = createSpinner("Fetching remote file list...");
   const remoteState = await repo.getRemoteState({ useCache: false });
   const remote = remoteState.files;
-  console.log(`Found ${remote.length} file(s) on Drive.`);
+  spinner.succeed(`Found ${remote.length} file(s) on Drive`);
 
   const snapshot = repo.getSnapshot();
   if (snapshot) {
@@ -445,7 +470,7 @@ async function handleFetch(options) {
 
 async function handlePull(paths, options) {
   const repo = await openRepo(options);
-  const { diff } = await repo.loadState({ useCache: false });
+  const { diff } = await loadStateWithProgress(repo, { useCache: false });
 
   let remoteChanges = diff.changes.filter((change) =>
     [
@@ -494,7 +519,7 @@ async function handlePull(paths, options) {
 
 async function handlePush(paths, options) {
   const repo = await openRepo(options);
-  const { diff } = await repo.loadState({ useCache: false });
+  const { diff } = await loadStateWithProgress(repo, { useCache: false });
 
   let localChanges = diff.changes.filter((change) =>
     [
@@ -543,7 +568,7 @@ async function handlePush(paths, options) {
 
 async function handleResolve(paths, options) {
   const repo = await openRepo(options);
-  const { diff } = await repo.loadState();
+  const { diff } = await loadStateWithProgress(repo);
   const conflicts = diff.conflicts;
 
   if (conflicts.length === 0) {
@@ -719,7 +744,7 @@ async function handleRestore(paths, options) {
     }
 
     const localDest = path.join(root, entry.localPath || entry.path);
-    console.log(`  Restoring ${targetPath} from Drive...`);
+    const spinner = createSpinner(`Restoring ${targetPath}...`);
 
     try {
       const meta = await repo.drive.files.get({
@@ -729,16 +754,16 @@ async function handleRestore(paths, options) {
 
       const { downloadFile } = await import("./core/drive-api.js");
       await downloadFile(repo.drive, { ...meta.data, id: entry.id }, localDest);
-      console.log(`  Restored: ${targetPath}`);
+      spinner.succeed(`Restored: ${targetPath}`);
     } catch (err) {
-      console.log(`  Failed to restore ${targetPath}: ${err.message}`);
+      spinner.fail(`Failed to restore ${targetPath}: ${err.message}`);
     }
   }
 }
 
 async function handleRm(paths, options) {
   const repo = await openRepo(options);
-  const { diff } = await repo.loadState();
+  const { diff } = await loadStateWithProgress(repo);
   const root = repo.root;
 
   for (const targetPath of paths) {
@@ -784,7 +809,7 @@ async function handleMv(source, dest, options) {
 }
 
 async function handleTui(options) {
-  const repo = await openRepo(options, { requireWorkspace: false });
+  const repo = await openRepo(options, { requireWorkspace: false, silent: true });
   const cliArgs = [];
   if (options.credentials) {
     cliArgs.push("--credentials", options.credentials);
@@ -819,6 +844,7 @@ async function handleDedupeFolders(options) {
   const config = repo.getConfig();
   const rootFolderId = config.drive_folder_id || null;
   const ignoreRules = loadIgnoreRules(repo.root);
+  const dedupeSpinner = createSpinner("Scanning for duplicate folders...");
   const result = await dedupeDuplicateFolders(repo.drive, rootFolderId, {
     execute: Boolean(options.execute),
     ignoreRules,
@@ -848,8 +874,9 @@ async function handleDedupeFolders(options) {
     },
   });
 
+  dedupeSpinner.succeed(`Scan complete — ${result.duplicateFolders.length} duplicate group(s) found`);
+
   if (result.duplicateFolders.length === 0) {
-    console.log("No duplicate folders detected.");
     return;
   }
 

package/src/core/diff.js

@@ -87,6 +87,11 @@ function buildDiffResult(changes) {
 }
 
 function remoteChanged(snapshotEntry, remoteEntry) {
+  // Folders don't change — only their existence matters
+  if (remoteEntry.isFolder || remoteEntry.mimeType === "application/vnd.google-apps.folder") {
+    return false;
+  }
+
   if (isWorkspaceType(remoteEntry.mimeType || "")) {
     return snapshotEntry.modifiedTime !== remoteEntry.modifiedTime;
   }
@@ -95,6 +100,8 @@ function remoteChanged(snapshotEntry, remoteEntry) {
 }
 
 function localChanged(snapshotEntry, localEntry) {
+  // Folders don't change — only their existence matters
+  if (localEntry.isFolder) return false;
   return snapshotEntry.md5 !== localEntry.md5;
 }
 
@@ -153,6 +160,21 @@ function promoteConflicts(changes) {
  * @param {object} localFiles
  * @param {{ root?: string, respectIgnore?: boolean }} options
  */
+/**
+ * Collect all implicit folder paths from a set of file paths.
+ * e.g. "a/b/c.txt" → {"a", "a/b"}
+ */
+function collectFolderPaths(filePaths) {
+  const folders = new Set();
+  for (const p of filePaths) {
+    const parts = p.split("/");
+    for (let i = 1; i < parts.length; i++) {
+      folders.add(parts.slice(0, i).join("/"));
+    }
+  }
+  return folders;
+}
+
 export function computeDiff(snapshot, remoteFiles, localFiles, { root, respectIgnore = true } = {}) {
   const ignoreRules = root && respectIgnore ? loadIgnoreRules(root) : null;
 
@@ -164,6 +186,19 @@ export function computeDiff(snapshot, remoteFiles, localFiles, { root, respectIg
   const snapshotFiles = snapshot?.files || {};
   const snapshotLocalFiles = snapshot?.localFiles || {};
 
+  // Build sets of all folder paths that implicitly exist on each side
+  // (from parent directories of files), so we can skip redundant folder additions.
+  const remoteFolderPaths = collectFolderPaths(remoteFiles.map((f) => f.path));
+  const localFolderPaths = collectFolderPaths(Object.keys(localFiles));
+
+  // Also include explicit folder entries
+  for (const f of remoteFiles) {
+    if (f.isFolder) remoteFolderPaths.add(f.path);
+  }
+  for (const [p, meta] of Object.entries(localFiles)) {
+    if (meta.isFolder) localFolderPaths.add(p);
+  }
+
   // Build remote lookup and detect additions/modifications in one pass
   const remoteById = new Map();
   for (const remoteFile of remoteFiles) {
@@ -171,6 +206,10 @@ export function computeDiff(snapshot, remoteFiles, localFiles, { root, respectIg
     const snapshotEntry = snapshotFiles[remoteFile.id];
 
     if (!snapshotEntry) {
+      // Skip remote folder if it already exists locally (as parent or explicit dir)
+      if (remoteFile.isFolder && localFolderPaths.has(remoteFile.path)) {
+        continue;
+      }
       changes.push(
         createChange({
           changeType: ChangeType.REMOTE_ADDED,
@@ -199,6 +238,11 @@ export function computeDiff(snapshot, remoteFiles, localFiles, { root, respectIg
   for (const fileId of Object.keys(snapshotFiles)) {
     if (!remoteById.has(fileId)) {
       const snapshotEntry = snapshotFiles[fileId];
+      // Skip folder deletion if the folder still implicitly exists on Drive
+      // (e.g. it became non-empty, or was recreated with a different ID)
+      if (snapshotEntry.isFolder && remoteFolderPaths.has(snapshotEntry.path || snapshotEntry.localPath || "")) {
+        continue;
+      }
       changes.push(
         createChange({
           changeType: ChangeType.REMOTE_DELETED,
@@ -214,6 +258,10 @@ export function computeDiff(snapshot, remoteFiles, localFiles, { root, respectIg
     const snapshotEntry = snapshotLocalFiles[relativePath];
 
     if (!snapshotEntry) {
+      // Skip local folder if it already exists on Drive (as parent or explicit dir)
+      if (localMeta.isFolder && remoteFolderPaths.has(relativePath)) {
+        continue;
+      }
       changes.push(
         createChange({
           changeType: ChangeType.LOCAL_ADDED,
@@ -238,6 +286,10 @@ export function computeDiff(snapshot, remoteFiles, localFiles, { root, respectIg
 
   for (const [relativePath, snapshotEntry] of Object.entries(snapshotLocalFiles)) {
     if (!(relativePath in localFiles)) {
+      // Skip folder deletion if the folder still implicitly exists locally
+      if (snapshotEntry.isFolder && localFolderPaths.has(relativePath)) {
+        continue;
+      }
       changes.push(
         createChange({
           changeType: ChangeType.LOCAL_DELETED,

package/src/core/drive-api.js

@@ -302,6 +302,10 @@ function buildRemoteFiles(folders, rawFiles, rootFolderId = null) {
   const resolve = createFolderResolver(folders, rootFolderId);
   const isOrphaned = createOrphanChecker(folders);
   const files = [];
+
+  // Track which folders have children (files or subfolders)
+  const foldersWithChildren = new Set();
+
   for (const file of rawFiles) {
     const parentId = file.parents?.[0] || "";
 
@@ -312,6 +316,9 @@ function buildRemoteFiles(folders, rawFiles, rootFolderId = null) {
 
     if (rootFolderId && parentPath === null) continue;
 
+    // Mark parent as having children
+    if (parentId) foldersWithChildren.add(parentId);
+
     files.push({
       id: file.id,
       name: file.name,
@@ -322,6 +329,34 @@ function buildRemoteFiles(folders, rawFiles, rootFolderId = null) {
       md5Checksum: file.md5Checksum || null,
     });
   }
+
+  // Mark folders that have subfolders as children
+  for (const folder of folders.values()) {
+    const parentId = folder.parents?.[0] || "";
+    if (parentId) foldersWithChildren.add(parentId);
+  }
+
+  // Include empty folders (no file children AND no subfolder children)
+  for (const folder of folders.values()) {
+    if (foldersWithChildren.has(folder.id)) continue;
+    if (isOrphaned(folder.id)) continue;
+
+    const folderPath = resolve(folder.id);
+    if (rootFolderId && folderPath === null) continue;
+    if (!folderPath) continue; // skip root-level marker
+
+    files.push({
+      id: folder.id,
+      name: folder.name,
+      path: folderPath,
+      mimeType: FOLDER_MIME,
+      size: null,
+      modifiedTime: folder.modifiedTime || null,
+      md5Checksum: null,
+      isFolder: true,
+    });
+  }
+
   return files;
 }
 

package/src/core/progress.js

@@ -0,0 +1,90 @@
+/**
+ * Lightweight terminal progress indicators (spinner + bar).
+ * Writes to stderr so stdout stays clean for piped output.
+ */
+
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const SPINNER_INTERVAL = 80;
+const BAR_WIDTH = 25;
+
+const isTTY = process.stderr.isTTY;
+
+function clearLine() {
+  if (isTTY) process.stderr.write("\r\x1b[K");
+}
+
+export function createSpinner(message) {
+  if (!isTTY) {
+    process.stderr.write(`${message}\n`);
+    return {
+      update() {},
+      succeed(msg) { if (msg) process.stderr.write(`${msg}\n`); },
+      fail(msg) { if (msg) process.stderr.write(`${msg}\n`); },
+      stop() {},
+    };
+  }
+
+  let frame = 0;
+  let currentMessage = message;
+
+  const timer = setInterval(() => {
+    clearLine();
+    process.stderr.write(`${SPINNER_FRAMES[frame % SPINNER_FRAMES.length]} ${currentMessage}`);
+    frame++;
+  }, SPINNER_INTERVAL);
+
+  return {
+    update(msg) { currentMessage = msg; },
+    succeed(msg) {
+      clearInterval(timer);
+      clearLine();
+      process.stderr.write(`✔ ${msg || currentMessage}\n`);
+    },
+    fail(msg) {
+      clearInterval(timer);
+      clearLine();
+      process.stderr.write(`✖ ${msg || currentMessage}\n`);
+    },
+    stop() {
+      clearInterval(timer);
+      clearLine();
+    },
+  };
+}
+
+export function createProgressBar(label, total) {
+  let lastRendered = -1;
+
+  function render(current) {
+    if (current === lastRendered) return;
+    lastRendered = current;
+
+    const ratio = total > 0 ? Math.min(current / total, 1) : 0;
+    const filled = Math.round(BAR_WIDTH * ratio);
+    const empty = BAR_WIDTH - filled;
+    const pct = Math.round(ratio * 100);
+    const bar = "█".repeat(filled) + "░".repeat(empty);
+    const line = `${label} [${bar}] ${current}/${total} (${pct}%)`;
+
+    if (isTTY) {
+      clearLine();
+      process.stderr.write(line);
+    }
+  }
+
+  // Initial render
+  render(0);
+
+  return {
+    update(current) { render(current); },
+    done(msg) {
+      render(total);
+      if (isTTY) {
+        clearLine();
+        process.stderr.write(`✔ ${msg || label}\n`);
+      } else {
+        process.stderr.write(`${msg || label}\n`);
+      }
+    },
+  };
+}

package/src/core/snapshot.js

@@ -52,6 +52,9 @@ export async function scanLocal(root, { respectIgnore = true } = {}) {
 
   // Phase 1: collect all file stats (fast — no hashing yet)
   const filesToHash = [];
+  // Track directories and their child counts to detect empty folders
+  const dirChildCount = new Map();
+  const dirStats = new Map();
 
   async function walk(currentPath) {
     let entries;
@@ -61,8 +64,20 @@ export async function scanLocal(root, { respectIgnore = true } = {}) {
       return;
     }
 
+    const relativeDirPath = currentPath === resolvedRoot
+      ? null
+      : path.relative(resolvedRoot, currentPath).split(path.sep).join("/");
+
+    // Register this directory (skip root itself)
+    if (relativeDirPath !== null) {
+      if (!dirChildCount.has(relativeDirPath)) {
+        dirChildCount.set(relativeDirPath, 0);
+      }
+    }
+
     const subdirs = [];
     const statPromises = [];
+    let trackedChildren = 0;
 
     for (const entry of entries) {
       const fullPath = path.join(currentPath, entry.name);
@@ -76,6 +91,7 @@ export async function scanLocal(root, { respectIgnore = true } = {}) {
       }
 
       if (entry.isDirectory()) {
+        trackedChildren++;
         subdirs.push(fullPath);
         continue;
       }
@@ -84,6 +100,7 @@ export async function scanLocal(root, { respectIgnore = true } = {}) {
         continue;
       }
 
+      trackedChildren++;
       statPromises.push(
         fs.promises.stat(fullPath).then((stat) => {
           filesToHash.push({ fullPath, relativePath, stat });
@@ -91,6 +108,16 @@ export async function scanLocal(root, { respectIgnore = true } = {}) {
       );
     }
 
+    if (relativeDirPath !== null) {
+      dirChildCount.set(relativeDirPath, trackedChildren);
+      try {
+        const stat = await fs.promises.stat(currentPath);
+        dirStats.set(relativeDirPath, stat);
+      } catch {
+        // ignore
+      }
+    }
+
     await Promise.all([
       ...statPromises,
       ...subdirs.map((dir) => walk(dir)),
@@ -121,6 +148,40 @@ export async function scanLocal(root, { respectIgnore = true } = {}) {
     }
   }
 
+  // Phase 3: detect empty folders (directories with zero tracked children)
+  // Walk bottom-up: a dir is "empty" if it has no tracked children AND
+  // all its subdirectories are also empty.
+  const emptyDirs = new Set();
+  // Sort by depth (deepest first) for bottom-up processing
+  const sortedDirs = [...dirChildCount.keys()].sort(
+    (a, b) => b.split("/").length - a.split("/").length
+  );
+
+  for (const dirPath of sortedDirs) {
+    const childCount = dirChildCount.get(dirPath);
+    if (childCount === 0) {
+      emptyDirs.add(dirPath);
+      // Propagate: decrement parent's tracked child count since this child is empty
+      const parentDir = dirPath.includes("/")
+        ? dirPath.slice(0, dirPath.lastIndexOf("/"))
+        : null;
+      if (parentDir && dirChildCount.has(parentDir)) {
+        dirChildCount.set(parentDir, dirChildCount.get(parentDir) - 1);
+      }
+    }
+  }
+
+  for (const dirPath of emptyDirs) {
+    const stat = dirStats.get(dirPath);
+    result[dirPath] = {
+      localPath: dirPath,
+      isFolder: true,
+      size: 0,
+      md5: null,
+      modifiedTime: stat ? new Date(stat.mtimeMs).toISOString() : new Date().toISOString(),
+    };
+  }
+
   // Persist updated cache
   saveHashCache(resolvedRoot, nextCache);
   return result;
@@ -158,6 +219,7 @@ export function buildSnapshot(remoteFiles, localFiles, message = "") {
       mimeType: file.mimeType || "",
       modifiedTime: file.modifiedTime ?? null,
       localPath: file.path,
+      ...(file.isFolder ? { isFolder: true } : {}),
     };
   }
 

package/src/core/staging.js

@@ -19,6 +19,11 @@ function changeToEntry(change) {
     entry.remotePath = change.remoteMeta.path;
   }
 
+  // Propagate folder flag so sync knows to create folder instead of uploading file
+  if (change.localMeta?.isFolder || change.remoteMeta?.isFolder) {
+    entry.isFolder = true;
+  }
+
   return entry;
 }
 

package/src/core/sync.js

@@ -20,6 +20,7 @@ export class CommitResult {
     this.uploaded = 0;
     this.deletedLocal = 0;
     this.deletedRemote = 0;
+    this.foldersCreated = 0;
     this.errors = [];
   }
 
@@ -28,7 +29,8 @@ export class CommitResult {
       this.downloaded +
       this.uploaded +
       this.deletedLocal +
-      this.deletedRemote
+      this.deletedRemote +
+      this.foldersCreated
     );
   }
 
@@ -41,6 +43,9 @@ export class CommitResult {
     if (this.uploaded) {
       parts.push(`${this.uploaded} uploaded`);
     }
+    if (this.foldersCreated) {
+      parts.push(`${this.foldersCreated} folders created`);
+    }
     if (this.deletedLocal) {
       parts.push(`${this.deletedLocal} deleted locally`);
     }
@@ -56,9 +61,16 @@ export class CommitResult {
 }
 
 async function downloadStagedFile(drive, entry, root) {
-  const fileId = entry.fileId;
   const localRelativePath = entry.localPath || entry.path;
   const localAbsolutePath = toLocalAbsolutePath(root, localRelativePath);
+
+  // Empty folder: just create the directory locally
+  if (entry.isFolder) {
+    fs.mkdirSync(localAbsolutePath, { recursive: true });
+    return;
+  }
+
+  const fileId = entry.fileId;
   const response = await drive.files.get({
     fileId,
     fields: "id,name,mimeType",
@@ -69,9 +81,16 @@ async function downloadStagedFile(drive, entry, root) {
 
 async function uploadStagedFile(drive, entry, root, driveFolderId) {
   const localRelativePath = entry.localPath || entry.path;
-  const localAbsolutePath = toLocalAbsolutePath(root, localRelativePath);
   const remotePath = entry.remotePath || entry.path;
 
+  // Empty folder: just ensure it exists on Drive
+  if (entry.isFolder) {
+    await ensureFolder(drive, remotePath, driveFolderId);
+    return;
+  }
+
+  const localAbsolutePath = toLocalAbsolutePath(root, localRelativePath);
+
   if (!fs.existsSync(localAbsolutePath)) {
     throw new Error(`Local file not found: ${localAbsolutePath}`);
   }
@@ -97,18 +116,25 @@ async function deleteLocalFile(entry, root) {
     return;
   }
 
-  await fs.promises.unlink(localAbsolutePath);
+  // Empty folder: remove the directory itself
+  if (entry.isFolder) {
+    await fs.promises.rmdir(localAbsolutePath).catch(() => {});
+  } else {
+    await fs.promises.unlink(localAbsolutePath);
+  }
 
-  let currentPath = path.dirname(localAbsolutePath);
+  // Clean up empty parent directories up to workspace root
+  let currentPath = entry.isFolder ? localAbsolutePath : path.dirname(localAbsolutePath);
   const resolvedRoot = path.resolve(root);
 
   while (currentPath !== resolvedRoot) {
-    const contents = await fs.promises.readdir(currentPath);
-    if (contents.length > 0) {
+    try {
+      const contents = await fs.promises.readdir(currentPath);
+      if (contents.length > 0) break;
+      await fs.promises.rmdir(currentPath);
+    } catch {
       break;
     }
-
-    await fs.promises.rmdir(currentPath);
     currentPath = path.dirname(currentPath);
   }
 }
@@ -195,10 +221,12 @@ export async function executeStaged(drive, root, progress) {
       const action = entry.action;
       if (action === "download") {
         await downloadStagedFile(drive, entry, root);
-        result.downloaded++;
+        if (entry.isFolder) result.foldersCreated++;
+        else result.downloaded++;
       } else if (action === "upload") {
         await uploadStagedFile(drive, entry, root, driveFolderId);
-        result.uploaded++;
+        if (entry.isFolder) result.foldersCreated++;
+        else result.uploaded++;
       } else if (action === "delete_remote") {
         await deleteRemoteFile(drive, entry);
         result.deletedRemote++;