@dinoxx/dinox-cli 1.0.22 → 1.1.1

package/dist/commands/storage/repo.js

@@ -1,8 +1,7 @@
 import fs from 'node:fs';
 import fsp from 'node:fs/promises';
 import path from 'node:path';
-import { DeleteObjectCommand, PutObjectCommand, S3Client } from '@aws-sdk/client-s3';
-import sharp from 'sharp';
+import { withPowerSyncWriteTransaction } from '../../powersync/runtime.js';
 import { generateId } from '../../utils/id.js';
 import { DinoxError } from '../../utils/errors.js';
 const ACTIVE_CUSTOM_STORAGE_CONFIG_ID_KEY = 'storage:active_custom_config_id';
@@ -64,14 +63,36 @@ function finishStorageHost(value) {
         throw new DinoxError(`Invalid storage endpoint: ${trimmed}`, { cause: error });
     }
 }
+function encodeStorageKeyForUrl(key) {
+    return key
+        .split('/')
+        .map((segment) => {
+        return encodeURIComponent(segment).replace(/[!'()*]/g, (character) => {
+            return `%${character.charCodeAt(0).toString(16).toUpperCase()}`;
+        });
+    })
+        .join('/');
+}
+function assertStorageKeyUrlSafe(key) {
+    const unsafeSegment = key.split('/').find((segment) => segment === '.' || segment === '..');
+    if (!unsafeSegment) {
+        return;
+    }
+    throw new DinoxError('Storage object key must not contain "." or ".." path segments.', {
+        code: 'INVALID_STORAGE_KEY',
+        suggestion: 'Remove dot-only path segments from --key or the configured storage path prefix.',
+        details: { key },
+    });
+}
 function buildVirtualHostedStyleUrl(bucket, endpoint, key) {
     const parsed = new URL(endpoint);
     const protocol = parsed.protocol || 'https:';
     const port = parsed.port ? `:${parsed.port}` : '';
     const host = parsed.hostname || parsed.host;
     const hostWithBucket = host.startsWith(`${bucket}.`) ? host : `${bucket}.${host}`;
+    const encodedKey = encodeStorageKeyForUrl(key);
     return {
-        finalUrl: `${protocol}//${hostWithBucket}${port}/${key}`,
+        finalUrl: `${protocol}//${hostWithBucket}${port}/${encodedKey}`,
         domain: `${protocol}//${hostWithBucket}${port}`,
     };
 }
@@ -80,8 +101,9 @@ function buildPathStyleUrl(bucket, endpoint, key) {
     const protocol = parsed.protocol || 'https:';
     const port = parsed.port ? `:${parsed.port}` : '';
     const host = parsed.hostname || parsed.host;
+    const encodedKey = encodeStorageKeyForUrl(key);
     return {
-        finalUrl: `${protocol}//${host}${port}/${bucket}/${key}`,
+        finalUrl: `${protocol}//${host}${port}/${bucket}/${encodedKey}`,
         domain: `${protocol}//${host}${port}`,
     };
 }
@@ -149,11 +171,12 @@ function generateThumbnailKey(originalKey) {
     return `${dirPath}/thumb/${filenameWithoutExt}_thumbnail.webp`;
 }
 function buildStorageTarget(config, key) {
+    assertStorageKeyUrlSafe(key);
     const resolvedEndpoint = finishStorageHost(config.endpoint);
     if (config.customDomain) {
         const domain = finishStorageHost(config.customDomain);
         return {
-            storageUrl: `${domain}/${key}`,
+            storageUrl: `${domain}/${encodeStorageKeyForUrl(key)}`,
             domain,
         };
     }
@@ -364,6 +387,7 @@ function buildStorageTestPlan(args) {
     };
 }
 async function defaultUploadObject(input) {
+    const { PutObjectCommand, S3Client } = await import('@aws-sdk/client-s3');
     const client = new S3Client({
         endpoint: finishStorageHost(input.storage.endpoint),
         region: input.storage.region,
@@ -379,12 +403,56 @@ async function defaultUploadObject(input) {
         Body: fs.createReadStream(input.localPath),
         ContentType: input.contentType,
         ContentLength: input.contentLength,
+        IfNoneMatch: input.overwrite ? undefined : '*',
     }));
     return {
         etag: normalizeText(response.ETag) || null,
     };
 }
+function isObjectCollisionError(error) {
+    if (!error || typeof error !== 'object') {
+        return false;
+    }
+    const record = error;
+    return record.$metadata?.httpStatusCode === 409
+        || record.$metadata?.httpStatusCode === 412
+        || record.name === 'ConditionalRequestConflict'
+        || record.name === 'PreconditionFailed'
+        || record.Code === 'PreconditionFailed'
+        || record.code === 'PreconditionFailed';
+}
+function createStorageCollisionError(bucket, keys, failureDetails = {}) {
+    return new DinoxError(`Storage object already exists: ${keys.join(', ')}`, {
+        code: 'STORAGE_OBJECT_ALREADY_EXISTS',
+        suggestion: 'Choose a different --key, or pass --overwrite to replace the existing object.',
+        recoverable: true,
+        details: {
+            bucket,
+            keys,
+            ...failureDetails,
+        },
+    });
+}
+function createStorageUploadOutcomeUnknownError(input) {
+    return new DinoxError(input.message, {
+        cause: input.cause,
+        code: 'STORAGE_UPLOAD_OUTCOME_UNKNOWN',
+        recoverable: true,
+        suggestion: 'Inspect the reported object key in remote storage before retrying; do not assume the failed request left the object unchanged.',
+        details: {
+            bucket: input.bucket,
+            storageKey: input.storageKey,
+            operation: input.operation,
+            overwrite: input.overwrite,
+            remoteOutcome: 'unknown',
+            remoteObjectChanged: null,
+            affectedKeys: [],
+            possiblyAffectedKeys: [...new Set(input.possiblyAffectedKeys)],
+        },
+    });
+}
 async function defaultDeleteObject(input) {
+    const { DeleteObjectCommand, S3Client } = await import('@aws-sdk/client-s3');
     const client = new S3Client({
         endpoint: finishStorageHost(input.storage.endpoint),
         region: input.storage.region,
@@ -397,9 +465,11 @@ async function defaultDeleteObject(input) {
     await client.send(new DeleteObjectCommand({
         Bucket: input.bucket,
         Key: input.key,
+        IfMatch: normalizeText(input.etag) || undefined,
     }));
 }
 async function defaultUploadBytes(input) {
+    const { PutObjectCommand, S3Client } = await import('@aws-sdk/client-s3');
     const client = new S3Client({
         endpoint: finishStorageHost(input.storage.endpoint),
         region: input.storage.region,
@@ -415,18 +485,64 @@ async function defaultUploadBytes(input) {
         Body: input.body,
         ContentType: input.contentType,
         ContentLength: input.body.byteLength,
+        IfNoneMatch: input.overwrite ? undefined : '*',
     }));
     return {
         etag: normalizeText(response.ETag) || null,
     };
 }
 async function generateThumbnailBuffer(localPath) {
+    const { default: sharp } = await import('sharp');
     return sharp(localPath)
         .resize({ width: 400, withoutEnlargement: true })
         .webp({ quality: 50 })
         .toBuffer();
 }
-async function insertUploadedResource(db, args) {
+function buildUploadedResourceEntries(columns, args, id, now) {
+    const entries = [];
+    const push = (column, value) => {
+        if (columns.has(column)) {
+            entries.push([column, value]);
+        }
+    };
+    push('id', id);
+    push('user_id', args.userId);
+    push('name', args.plan.fileName);
+    push('mime_type', args.plan.contentType);
+    push('size_bytes', args.plan.sizeBytes);
+    push('storage_config_id', args.storage.id);
+    push('storage_key', args.plan.storageKey);
+    push('storage_url', args.plan.storageUrl);
+    push('storage_provider', args.storage.provider);
+    push('bucket', args.storage.bucket);
+    push('is_public', args.storage.isPrivate ? 0 : 1);
+    push('created_at', now);
+    push('updated_at', now);
+    push('is_del', 0);
+    push('status', 'uploaded');
+    push('uploaded_at', now);
+    push('etag', args.etag);
+    push('checksum', null);
+    push('category', args.plan.category);
+    push('endpoint', args.storage.endpoint);
+    push('domain', args.plan.domain);
+    push('extra_data', '{}');
+    push('deleted_at', null);
+    push('content_sha256', null);
+    push('content', null);
+    push('content_md', null);
+    push('summary', null);
+    return entries;
+}
+async function insertResourceRow(db, entries) {
+    const insertColumns = entries.map(([column]) => column);
+    const placeholders = insertColumns.map(() => '?').join(', ');
+    await db.execute(`
+    INSERT INTO c_resource (${insertColumns.join(', ')})
+    VALUES (${placeholders})
+    `, entries.map(([, value]) => value));
+}
+async function persistUploadedResource(db, args) {
     const columns = await getTableColumns(db, 'c_resource');
     const requiredColumns = [
         'id',
@@ -448,47 +564,67 @@ async function insertUploadedResource(db, args) {
     }
     const id = generateId();
     const now = new Date().toISOString();
-    const insertEntries = [];
-    const pushInsert = (column, value) => {
-        if (columns.has(column)) {
-            insertEntries.push([column, value]);
+    const entries = buildUploadedResourceEntries(columns, args, id, now);
+    if (!args.overwrite) {
+        await insertResourceRow(db, entries);
+        return id;
+    }
+    return withPowerSyncWriteTransaction(db, async (tx) => {
+        const identityClauses = [
+            'user_id = ?',
+            'storage_key = ?',
+            'COALESCE(is_del, 0) = 0',
+        ];
+        const identityParams = [args.userId, args.plan.storageKey];
+        if (columns.has('storage_config_id')) {
+            identityClauses.push('storage_config_id = ?');
+            identityParams.push(args.storage.id);
         }
-    };
-    pushInsert('id', id);
-    pushInsert('user_id', args.userId);
-    pushInsert('name', args.plan.fileName);
-    pushInsert('mime_type', args.plan.contentType);
-    pushInsert('size_bytes', args.plan.sizeBytes);
-    pushInsert('storage_config_id', args.storage.id);
-    pushInsert('storage_key', args.plan.storageKey);
-    pushInsert('storage_url', args.plan.storageUrl);
-    pushInsert('storage_provider', args.storage.provider);
-    pushInsert('bucket', args.storage.bucket);
-    pushInsert('is_public', args.storage.isPrivate ? 0 : 1);
-    pushInsert('created_at', now);
-    pushInsert('updated_at', now);
-    pushInsert('is_del', 0);
-    pushInsert('status', 'uploaded');
-    pushInsert('uploaded_at', now);
-    pushInsert('etag', args.etag);
-    pushInsert('checksum', args.thumbnailUrl);
-    pushInsert('category', args.plan.category);
-    pushInsert('endpoint', args.storage.endpoint);
-    pushInsert('domain', args.plan.domain);
-    pushInsert('extra_data', '{}');
-    pushInsert('deleted_at', null);
-    pushInsert('content_sha256', null);
-    pushInsert('content', null);
-    pushInsert('content_md', null);
-    pushInsert('summary', null);
-    const insertColumns = insertEntries.map(([column]) => column);
-    const placeholders = insertColumns.map(() => '?').join(', ');
-    const params = insertEntries.map(([, value]) => value);
-    await db.execute(`
-    INSERT INTO c_resource (${insertColumns.join(', ')})
-    VALUES (${placeholders})
-    `, params);
-    return id;
+        else {
+            identityClauses.push('storage_provider = ?', 'bucket = ?');
+            identityParams.push(args.storage.provider, args.storage.bucket);
+            if (columns.has('endpoint')) {
+                identityClauses.push('endpoint = ?');
+                identityParams.push(args.storage.endpoint);
+            }
+        }
+        const existingRows = await tx.getAll(`
+      SELECT id
+      FROM c_resource
+      WHERE ${identityClauses.join('\n        AND ')}
+      ORDER BY created_at ASC, id ASC
+      `, identityParams);
+        const existingIds = [...new Set(existingRows.map((row) => normalizeText(row.id)).filter(Boolean))];
+        const existingId = existingIds[0];
+        if (!existingId) {
+            await insertResourceRow(tx, entries);
+            return id;
+        }
+        const updateEntries = entries.filter(([column]) => (column !== 'id' && column !== 'user_id' && column !== 'created_at'));
+        await tx.execute(`
+      UPDATE c_resource
+      SET ${updateEntries.map(([column]) => `${column} = ?`).join(', ')}
+      WHERE id = ?
+        AND user_id = ?
+        AND COALESCE(is_del, 0) = 0
+      `, [...updateEntries.map(([, value]) => value), existingId, args.userId]);
+        const duplicateIds = existingIds.slice(1);
+        if (duplicateIds.length > 0) {
+            const duplicateUpdates = [
+                ['updated_at', now],
+                ['is_del', 1],
+                ...(columns.has('deleted_at') ? [['deleted_at', now]] : []),
+            ];
+            await tx.execute(`
+        UPDATE c_resource
+        SET ${duplicateUpdates.map(([column]) => `${column} = ?`).join(', ')}
+        WHERE user_id = ?
+          AND COALESCE(is_del, 0) = 0
+          AND id IN (${duplicateIds.map(() => '?').join(', ')})
+        `, [...duplicateUpdates.map(([, value]) => value), args.userId, ...duplicateIds]);
+        }
+        return existingId;
+    });
 }
 export function parseStorageUploadCategory(value) {
     const normalized = typeof value === 'string' ? value.trim().toLowerCase() : '';
@@ -642,17 +778,50 @@ export async function testStorageUpload(db, input, deps) {
     const uploadBytes = deps?.uploadBytes ?? defaultUploadBytes;
     const deleteObject = deps?.deleteObject ?? defaultDeleteObject;
     const payload = Buffer.from(`dinox-cli storage test\nprovider=${storage.provider}\nuser=${input.userId}\ncreated_at=${new Date().toISOString()}\n`, 'utf8');
-    await uploadBytes({
-        body: payload,
-        bucket: storage.bucket,
-        key: plan.storageKey,
-        contentType: plan.contentType,
-        storage,
-    });
+    let uploaded;
+    try {
+        uploaded = await uploadBytes({
+            body: payload,
+            bucket: storage.bucket,
+            key: plan.storageKey,
+            contentType: plan.contentType,
+            storage,
+        });
+    }
+    catch (error) {
+        if (isObjectCollisionError(error)) {
+            throw error;
+        }
+        throw createStorageUploadOutcomeUnknownError({
+            message: 'Storage test upload outcome could not be confirmed.',
+            cause: error,
+            bucket: storage.bucket,
+            storageKey: plan.storageKey,
+            possiblyAffectedKeys: [plan.storageKey],
+            overwrite: false,
+            operation: 'storage_test',
+        });
+    }
+    const cleanupEtag = normalizeText(uploaded.etag);
+    if (!cleanupEtag) {
+        throw new DinoxError('Storage test uploaded the temporary object but could not clean it up safely.', {
+            code: 'STORAGE_TEST_CLEANUP_FAILED',
+            details: {
+                storageKey: plan.storageKey,
+                bucket: storage.bucket,
+                remoteObjectChanged: true,
+                affectedKeys: [plan.storageKey],
+                cleanupErrors: [
+                    `${plan.storageKey} cleanup skipped: upload response did not include an ETag required for safe conditional deletion`,
+                ],
+            },
+        });
+    }
     try {
         await deleteObject({
             bucket: storage.bucket,
             key: plan.storageKey,
+            etag: cleanupEtag,
             storage,
         });
     }
@@ -663,6 +832,11 @@ export async function testStorageUpload(db, input, deps) {
             details: {
                 storageKey: plan.storageKey,
                 bucket: storage.bucket,
+                remoteObjectChanged: true,
+                affectedKeys: [plan.storageKey],
+                cleanupErrors: [
+                    `${plan.storageKey} cleanup failed: ${error instanceof Error ? error.message : String(error)}`,
+                ],
             },
         });
     }
@@ -682,46 +856,152 @@ export async function testStorageUpload(db, input, deps) {
     };
 }
 export async function uploadFileToStorage(db, input, deps) {
+    if (input.overwrite && !normalizeText(input.key)) {
+        throw new DinoxError('--overwrite requires an explicit --key.', {
+            code: 'USAGE_ERROR',
+        });
+    }
     const plan = await inspectStorageUpload(db, input, { statFile: deps?.statFile });
     const configs = await listStoredCustomStorageConfigs(db, input.userId);
     const storage = configs.find((item) => item.id === plan.storage.id);
     if (!storage) {
         throw new DinoxError(`Storage config not found: ${plan.storage.id}`);
     }
+    const overwrite = input.overwrite === true;
     const uploadObject = deps?.uploadObject ?? defaultUploadObject;
     const uploadBytes = deps?.uploadBytes ?? defaultUploadBytes;
     const deleteObject = deps?.deleteObject ?? defaultDeleteObject;
-    const uploaded = await uploadObject({
-        localPath: plan.filePath,
-        bucket: storage.bucket,
-        key: plan.storageKey,
-        contentType: plan.contentType,
-        contentLength: plan.sizeBytes,
-        storage,
-    });
-    let thumbnailUrl = null;
-    let uploadedThumbnailKey = null;
+    const thumbnailKey = plan.contentType.startsWith('image/')
+        ? generateThumbnailKey(plan.storageKey)
+        : null;
+    let uploaded;
     try {
-        if (plan.contentType.startsWith('image/')) {
-            const thumbnailKey = generateThumbnailKey(plan.storageKey);
+        uploaded = await uploadObject({
+            localPath: plan.filePath,
+            bucket: storage.bucket,
+            key: plan.storageKey,
+            contentType: plan.contentType,
+            contentLength: plan.sizeBytes,
+            overwrite,
+            storage,
+        });
+    }
+    catch (error) {
+        if (!overwrite && isObjectCollisionError(error)) {
+            throw createStorageCollisionError(storage.bucket, [plan.storageKey]);
+        }
+        throw createStorageUploadOutcomeUnknownError({
+            message: 'Storage upload outcome could not be confirmed.',
+            cause: error,
+            bucket: storage.bucket,
+            storageKey: plan.storageKey,
+            possiblyAffectedKeys: [plan.storageKey],
+            overwrite,
+            operation: 'upload',
+        });
+    }
+    let thumbnailUrl = null;
+    const possiblyAffectedKeys = new Set();
+    const remoteWrites = [{
+            key: plan.storageKey,
+            etag: uploaded.etag,
+            cleanupAllowed: !overwrite,
+            cleaned: false,
+        }];
+    const cleanupUploadedObjects = async () => {
+        const cleanupErrors = [];
+        for (const remoteWrite of [...remoteWrites].reverse()) {
+            if (!remoteWrite.cleanupAllowed || remoteWrite.cleaned) {
+                continue;
+            }
+            const cleanupEtag = normalizeText(remoteWrite.etag);
+            if (!cleanupEtag) {
+                cleanupErrors.push(`${remoteWrite.key} cleanup skipped: upload response did not include an ETag required for safe conditional deletion`);
+                continue;
+            }
+            await deleteObject({
+                bucket: storage.bucket,
+                key: remoteWrite.key,
+                etag: cleanupEtag,
+                storage,
+            }).then(() => {
+                remoteWrite.cleaned = true;
+            }, (cleanupError) => {
+                cleanupErrors.push(`${remoteWrite.key} cleanup failed: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
+            });
+        }
+        return cleanupErrors;
+    };
+    const buildRemoteFailureDetails = (cleanupErrors) => {
+        const affectedKeys = remoteWrites
+            .filter((remoteWrite) => !remoteWrite.cleaned)
+            .map((remoteWrite) => remoteWrite.key);
+        const possibleKeys = [...possiblyAffectedKeys];
+        return {
+            bucket: storage.bucket,
+            storageKey: plan.storageKey,
+            remoteObjectChanged: possibleKeys.length > 0
+                ? (affectedKeys.length > 0 ? true : null)
+                : affectedKeys.length > 0,
+            affectedKeys,
+            ...(possibleKeys.length > 0
+                ? { remoteOutcome: 'unknown', possiblyAffectedKeys: possibleKeys }
+                : {}),
+            ...(cleanupErrors.length > 0 ? { cleanupErrors } : {}),
+        };
+    };
+    if (plan.contentType.startsWith('image/')) {
+        try {
+            if (!thumbnailKey) {
+                throw new Error('Thumbnail key could not be generated.');
+            }
             const thumbnailBuffer = await generateThumbnailBuffer(plan.filePath);
             const thumbnailTarget = buildStorageTarget(storage, thumbnailKey);
-            await uploadBytes({
-                body: thumbnailBuffer,
-                bucket: storage.bucket,
+            let uploadedThumbnail;
+            try {
+                uploadedThumbnail = await uploadBytes({
+                    body: thumbnailBuffer,
+                    bucket: storage.bucket,
+                    key: thumbnailKey,
+                    contentType: 'image/webp',
+                    overwrite,
+                    storage,
+                });
+            }
+            catch (error) {
+                if (!isObjectCollisionError(error)) {
+                    possiblyAffectedKeys.add(thumbnailKey);
+                }
+                throw error;
+            }
+            remoteWrites.push({
                 key: thumbnailKey,
-                contentType: 'image/webp',
-                storage,
+                etag: uploadedThumbnail.etag,
+                cleanupAllowed: !overwrite,
+                cleaned: false,
             });
-            uploadedThumbnailKey = thumbnailKey;
             thumbnailUrl = thumbnailTarget.storageUrl;
         }
-        const resourceId = await insertUploadedResource(db, {
+        catch (error) {
+            const cleanupErrors = await cleanupUploadedObjects();
+            if (!overwrite && isObjectCollisionError(error) && thumbnailKey) {
+                throw createStorageCollisionError(storage.bucket, [thumbnailKey], buildRemoteFailureDetails(cleanupErrors));
+            }
+            throw new DinoxError('Storage upload failed while generating the required thumbnail.', {
+                cause: error,
+                code: 'STORAGE_THUMBNAIL_UPLOAD_FAILED',
+                details: buildRemoteFailureDetails(cleanupErrors),
+            });
+        }
+    }
+    try {
+        const resourceId = await persistUploadedResource(db, {
             userId: input.userId,
             storage,
             plan,
             etag: uploaded.etag,
             thumbnailUrl,
+            overwrite,
         });
         return {
             resourceId,
@@ -744,27 +1024,11 @@ export async function uploadFileToStorage(db, input, deps) {
         };
     }
     catch (error) {
-        const cleanupErrors = [];
-        if (uploadedThumbnailKey) {
-            await deleteObject({
-                bucket: storage.bucket,
-                key: uploadedThumbnailKey,
-                storage,
-            }).catch((cleanupError) => {
-                cleanupErrors.push(`thumbnail cleanup failed: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
-            });
-        }
-        await deleteObject({
-            bucket: storage.bucket,
-            key: plan.storageKey,
-            storage,
-        }).catch((cleanupError) => {
-            cleanupErrors.push(`main object cleanup failed: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
-        });
-        throw new DinoxError('Storage upload failed while generating the required thumbnail.', {
+        const cleanupErrors = await cleanupUploadedObjects();
+        throw new DinoxError('Storage upload failed while recording resource metadata.', {
             cause: error,
-            code: 'STORAGE_THUMBNAIL_UPLOAD_FAILED',
-            ...(cleanupErrors.length > 0 ? { details: { cleanupErrors } } : {}),
+            code: 'STORAGE_RESOURCE_INSERT_FAILED',
+            details: buildRemoteFailureDetails(cleanupErrors),
         });
     }
 }

package/dist/commands/sync.d.ts

@@ -1,4 +1,26 @@
 import { Command } from 'commander';
-import type { CommandDescriptor } from './descriptor/types.js';
+import { loadConfig } from '../config/store.js';
+import { resolveConfig } from '../config/resolve.js';
+import { hydrateResolvedAuthIdentity } from '../auth/userInfo.js';
+import { withExclusivePowerSync } from '../powersync/exclusiveRuntime.js';
+import type { CommandDescriptor, CommandExecutionContext } from './descriptor/types.js';
+import { getRequestedStructuredOutputFormat, printHumanReadableLine, printSuccess } from '../utils/output.js';
+import { getStatusSnapshot, waitForLastSyncedAfter } from '../powersync/runtime.js';
+import { runSingleSyncPass } from '../powersync/syncPass.js';
+type SyncCommandDependencies = {
+    loadConfig: typeof loadConfig;
+    resolveConfig: typeof resolveConfig;
+    hydrateResolvedAuthIdentity: typeof hydrateResolvedAuthIdentity;
+    withExclusivePowerSync: typeof withExclusivePowerSync;
+    getRequestedStructuredOutputFormat: typeof getRequestedStructuredOutputFormat;
+    getStatusSnapshot: typeof getStatusSnapshot;
+    waitForLastSyncedAfter: typeof waitForLastSyncedAfter;
+    runSingleSyncPass: typeof runSingleSyncPass;
+    printHumanReadableLine: typeof printHumanReadableLine;
+    printSuccess: typeof printSuccess;
+    now: () => number;
+};
+export declare function executeSyncCommand(context: CommandExecutionContext, overrides?: Partial<SyncCommandDependencies>): Promise<void>;
 export declare const syncCommandDescriptor: CommandDescriptor;
 export declare function registerSyncCommand(program: Command): void;
+export {};