@lifestreamdynamics/vault-cli 1.3.10 → 1.3.11

package/dist/commands/sync.js

@@ -9,7 +9,7 @@ import { formatUptime } from '../utils/format.js';
 import { loadSyncConfigs, createSyncConfig, deleteSyncConfig, getSyncConfig, } from '../sync/config.js';
 import { deleteSyncState, loadSyncState, saveSyncState, hashFileContent, buildRemoteFileState } from '../sync/state.js';
 import { resolveIgnorePatterns } from '../sync/ignore.js';
-import { scanLocalFiles, scanRemoteFiles, executePull, executePush, computePullDiff, computePushDiff, } from '../sync/engine.js';
+import { scanLocalFiles, scanRemoteFiles, executePull, executePush, computePullDiff, computePushDiff, resolveConcurrency, } from '../sync/engine.js';
 import { formatDiff } from '../sync/diff.js';
 import { createWatcher } from '../sync/watcher.js';
 import { createRemotePoller } from '../sync/remote-poller.js';
@@ -153,7 +153,8 @@ Sync modes:
     // sync pull <syncId>
     addGlobalFlags(sync.command('pull')
         .description('Pull remote changes to local directory')
-        .argument('<syncId>', 'Sync configuration ID'))
+        .argument('<syncId>', 'Sync configuration ID')
+        .option('--concurrency <n>', 'Max concurrent file transfers (1-16, default 4)', (v) => parseInt(v, 10)))
         .action(async (syncId, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
@@ -211,12 +212,13 @@ Sync modes:
             if (flags.verbose) {
                 out.status(formatDiff(diff));
             }
+            const concurrency = resolveConcurrency(_opts.concurrency);
             out.startSpinner(`Pulling ${totalOps} file(s)...`);
             const result = await executePull(client, config, diff, (progress) => {
                 if (progress.phase === 'transferring' && progress.currentFile) {
                     out.startSpinner(`[${progress.current}/${progress.total}] ${progress.currentFile}`);
                 }
-            });
+            }, concurrency);
             if (result.errors.length > 0) {
                 out.failSpinner(`Pull completed with ${result.errors.length} error(s)`);
                 for (const err of result.errors) {
@@ -241,7 +243,8 @@ Sync modes:
     // sync push <syncId>
     addGlobalFlags(sync.command('push')
         .description('Push local changes to remote vault')
-        .argument('<syncId>', 'Sync configuration ID'))
+        .argument('<syncId>', 'Sync configuration ID')
+        .option('--concurrency <n>', 'Max concurrent file transfers (1-16, default 4)', (v) => parseInt(v, 10)))
         .action(async (syncId, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
@@ -299,12 +302,13 @@ Sync modes:
             if (flags.verbose) {
                 out.status(formatDiff(diff));
             }
+            const concurrency = resolveConcurrency(_opts.concurrency);
             out.startSpinner(`Pushing ${totalOps} file(s)...`);
             const result = await executePush(client, config, diff, (progress) => {
                 if (progress.phase === 'transferring' && progress.currentFile) {
                     out.startSpinner(`[${progress.current}/${progress.total}] ${progress.currentFile}`);
                 }
-            });
+            }, concurrency);
             if (result.errors.length > 0) {
                 out.failSpinner(`Push completed with ${result.errors.length} error(s)`);
                 for (const err of result.errors) {

package/dist/sync/engine.d.ts

@@ -30,12 +30,17 @@ export declare function scanLocalFiles(localPath: string, ignorePatterns: string
  * Returns a map of doc paths -> FileState.
  */
 export declare function scanRemoteFiles(client: LifestreamVaultClient, vaultId: string, ignorePatterns: string[]): Promise<Record<string, FileState>>;
+/**
+ * Validates and clamps a user-supplied concurrency value. Throws on invalid
+ * values so the CLI can surface a clear error before kicking off any I/O.
+ */
+export declare function resolveConcurrency(value: number | undefined): number;
 /**
  * Execute a pull operation: download remote changes to local.
  */
-export declare function executePull(client: LifestreamVaultClient, config: SyncConfig, diff: SyncDiff, onProgress?: ProgressCallback): Promise<SyncResult>;
+export declare function executePull(client: LifestreamVaultClient, config: SyncConfig, diff: SyncDiff, onProgress?: ProgressCallback, concurrency?: number): Promise<SyncResult>;
 /**
  * Execute a push operation: upload local changes to remote.
  */
-export declare function executePush(client: LifestreamVaultClient, config: SyncConfig, diff: SyncDiff, onProgress?: ProgressCallback): Promise<SyncResult>;
+export declare function executePush(client: LifestreamVaultClient, config: SyncConfig, diff: SyncDiff, onProgress?: ProgressCallback, concurrency?: number): Promise<SyncResult>;
 export { computePullDiff, computePushDiff, type SyncDiff, type SyncDiffEntry };

package/dist/sync/engine.js

@@ -54,7 +54,7 @@ export async function scanRemoteFiles(client, vaultId, ignorePatterns) {
         if (!shouldIgnore(doc.path, ignorePatterns)) {
             files[doc.path] = {
                 path: doc.path,
-                hash: '', // We don't have content hash from list; will use mtime for comparison
+                hash: doc.contentHash,
                 mtime: doc.fileModifiedAt,
                 size: doc.sizeBytes,
             };
@@ -71,12 +71,31 @@ function atomicWriteFileSync(targetPath, content, encoding = 'utf-8') {
     fs.writeFileSync(tmpFile, content, encoding);
     fs.renameSync(tmpFile, targetPath);
 }
+/**
+ * Default in-flight transfer count. A small number flattens the load1 spike
+ * a full-vault `sync pull` causes on the API host without making single
+ * transfers measurably slower.
+ */
+const DEFAULT_TRANSFER_CONCURRENCY = 4;
+const MAX_TRANSFER_CONCURRENCY = 16;
+/**
+ * Validates and clamps a user-supplied concurrency value. Throws on invalid
+ * values so the CLI can surface a clear error before kicking off any I/O.
+ */
+export function resolveConcurrency(value) {
+    if (value === undefined)
+        return DEFAULT_TRANSFER_CONCURRENCY;
+    if (!Number.isInteger(value) || value < 1 || value > MAX_TRANSFER_CONCURRENCY) {
+        throw new Error(`--concurrency must be an integer between 1 and ${MAX_TRANSFER_CONCURRENCY} (got ${value})`);
+    }
+    return value;
+}
 /**
  * Shared sync operation executor used by both pull and push.
  * Handles result initialization, state loading, progress callbacks,
  * quota error handling, state saving, and lastSync update.
  */
-async function executeSyncOperation(config, diff, handlers, onProgress) {
+async function executeSyncOperation(config, diff, handlers, onProgress, concurrency = DEFAULT_TRANSFER_CONCURRENCY) {
     const result = {
         filesUploaded: 0,
         filesDownloaded: 0,
@@ -87,7 +106,12 @@ async function executeSyncOperation(config, diff, handlers, onProgress) {
     const state = loadSyncState(config.id);
     const allOps = [...handlers.transfers, ...handlers.deletes];
     let current = 0;
-    for (const entry of handlers.transfers) {
+    // Once a quota error is hit anywhere in the pool we stop submitting new
+    // work but let in-flight transfers drain to keep state consistent.
+    let stopSubmitting = false;
+    async function runOne(entry) {
+        if (stopSubmitting)
+            return;
         current++;
         onProgress?.({
             phase: 'transferring',
@@ -112,13 +136,25 @@ async function executeSyncOperation(config, diff, handlers, onProgress) {
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
+            result.errors.push({ path: entry.path, error: message });
             if (isQuotaError(message)) {
-                result.errors.push({ path: entry.path, error: message });
-                break; // Stop immediately on quota errors
+                stopSubmitting = true;
             }
-            result.errors.push({ path: entry.path, error: message });
         }
     }
+    // Bounded async pool. Workers race for entries off the queue tail; once
+    // the queue is empty (or stopSubmitting is set), each worker exits and
+    // Promise.all resolves only after every in-flight transfer has settled.
+    const queue = handlers.transfers.slice();
+    const poolSize = Math.min(Math.max(1, concurrency), Math.max(1, queue.length));
+    await Promise.all(Array.from({ length: poolSize }, async () => {
+        while (!stopSubmitting) {
+            const entry = queue.shift();
+            if (!entry)
+                return;
+            await runOne(entry);
+        }
+    }));
     for (const entry of handlers.deletes) {
         current++;
         onProgress?.({
@@ -154,7 +190,7 @@ async function executeSyncOperation(config, diff, handlers, onProgress) {
 /**
  * Execute a pull operation: download remote changes to local.
  */
-export async function executePull(client, config, diff, onProgress) {
+export async function executePull(client, config, diff, onProgress, concurrency) {
     return executeSyncOperation(config, diff, {
         transfers: diff.downloads,
         deletes: diff.deletes,
@@ -175,12 +211,12 @@ export async function executePull(client, config, diff, onProgress) {
                 fs.unlinkSync(localFile);
             }
         },
-    }, onProgress);
+    }, onProgress, concurrency);
 }
 /**
  * Execute a push operation: upload local changes to remote.
  */
-export async function executePush(client, config, diff, onProgress) {
+export async function executePush(client, config, diff, onProgress, concurrency) {
     return executeSyncOperation(config, diff, {
         transfers: diff.uploads,
         deletes: diff.deletes,
@@ -194,7 +230,7 @@ export async function executePush(client, config, diff, onProgress) {
         async deleteFile(entry, cfg) {
             await retryWithBackoff(() => client.documents.delete(cfg.vaultId, entry.path));
         },
-    }, onProgress);
+    }, onProgress, concurrency);
 }
 /**
  * Retry a function with exponential backoff (max 3 retries).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lifestreamdynamics/vault-cli",
-  "version": "1.3.10",
+  "version": "1.3.11",
   "description": "Command-line interface for Lifestream Vault",
   "engines": {
     "node": ">=22"