@panorama-ai/gateway 2.30.207 → 2.30.279

package/dist/managed-runtime/drive-sync.js

@@ -0,0 +1,1641 @@
+import { DRIVE_TRANSFER_POLICY, getDriveLocalSyncFileTooLargeMessage, } from '@panorama/shared/drive-transfer-policy';
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, rename, rm } from 'node:fs/promises';
+import { hostname } from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+import { assertLocalPathIsNotSymlink, assertNoSymlinkInExistingPath, assertPathExists, buildSubtreeConflictRootPath, normalizeDrivePath, parkStaleDriveLocalFolder, readLocalDriveEntryAtPath, resolveDirtyDrivePathsForDrive, resolveDriveLocalPath, resolveDriveLocalRoot, scanLocalDriveEntries, writeLocalConflictCopy, } from './drive-sync-filesystem.js';
+import { drivePathIsInSubtree, localEntryMatchesBaseline, planLocalDriveSync, } from './drive-sync-planner.js';
+import { planRemoteDriveBatch } from './drive-sync-remote-planner.js';
+import { applyAppliedLocalDriveMutationState, applyLocalDriveConflictActions, applyRemoteDriveDeleteState, applyRemoteDriveDirectoryState, applyRemoteDriveFileState, applyRemoteDriveMoveState, applyUnsupportedLocalDriveMutationState, recordLocalUploadConflict, recordRemoteApplyConflict, resolveLocalMutationResultPath, } from './drive-sync-state-applier.js';
+import { downloadDriveVersionToLocalFile, prepareLocalMutationUploads, } from './drive-sync-transfer.js';
+import { MANAGED_GATEWAY_LOG_PREFIX } from './runtime-utils.js';
+export { resolveDriveLocalPath, resolveDriveLocalRoot } from './drive-sync-filesystem.js';
+const MAX_LOCAL_BATCH_CHANGES = DRIVE_TRANSFER_POLICY.localBatchMaxChanges;
+const MAX_LOCAL_BATCH_UPLOAD_BYTES = DRIVE_TRANSFER_POLICY.localSyncBatchUploadMaxBytes;
+const MAX_LOCAL_FILE_UPLOAD_BYTES = DRIVE_TRANSFER_POLICY.objectFileMaxBytes;
+const DEFAULT_DRIVE_SYNC_NETWORK_TIMEOUT_MS = DRIVE_TRANSFER_POLICY.networkRequestTimeoutMs;
+const DRIVE_SYNC_STATUS_CONFLICT_SAMPLE_LIMIT = 10;
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function mapDriveSyncEntryRow(row) {
+    return {
+        driveId: row.drive_id,
+        path: row.path,
+        entryType: row.entry_type,
+        versionId: row.version_id,
+        contentSha256: row.content_sha256,
+        sizeBytes: row.size_bytes,
+        mimeType: row.mime_type,
+    };
+}
+function mapDriveSyncConflictRow(row) {
+    return {
+        driveId: row.drive_id,
+        path: row.path,
+        conflictType: row.conflict_type,
+        reason: row.reason,
+        localContentSha256: row.local_content_sha256,
+        localSizeBytes: row.local_size_bytes,
+        localVersionId: row.local_version_id,
+        conflictId: row.conflict_id,
+        conflictPath: row.conflict_path,
+        remoteBatchId: row.remote_batch_id,
+        remoteSequence: row.remote_sequence,
+    };
+}
+export class DriveSyncStateStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    static async open(stateDir) {
+        await mkdir(stateDir, { recursive: true });
+        const sqlite = await import('node:sqlite');
+        const db = new sqlite.DatabaseSync(path.join(stateDir, 'drive-sync.sqlite'));
+        const store = new DriveSyncStateStore(db);
+        store.ensureSchema();
+        return store;
+    }
+    close() {
+        this.db.close();
+    }
+    getOrCreateClientKey(prefix) {
+        const key = 'client_instance_id';
+        const rows = this.db
+            .prepare('SELECT value FROM drive_sync_metadata WHERE key = ?')
+            .all(key);
+        const existing = rows[0]?.value;
+        if (existing) {
+            return `${prefix}:${existing}`;
+        }
+        const clientInstanceId = randomUUID();
+        this.db
+            .prepare(`
+        INSERT INTO drive_sync_metadata (key, value, updated_at)
+        VALUES (?, ?, datetime('now'))
+        ON CONFLICT(key) DO UPDATE SET
+          value = excluded.value,
+          updated_at = excluded.updated_at
+        `)
+            .run(key, clientInstanceId);
+        return `${prefix}:${clientInstanceId}`;
+    }
+    getEntry(driveId, drivePath) {
+        const normalizedPath = normalizeDrivePath(drivePath);
+        const rows = this.db
+            .prepare(`
+        SELECT drive_id, path, entry_type, version_id, content_sha256, size_bytes, mime_type
+        FROM drive_sync_entries
+        WHERE drive_id = ? AND path = ?
+        `)
+            .all(driveId, normalizedPath);
+        return rows[0] ? mapDriveSyncEntryRow(rows[0]) : null;
+    }
+    listEntries(driveId) {
+        const rows = this.db
+            .prepare(`
+        SELECT drive_id, path, entry_type, version_id, content_sha256, size_bytes, mime_type
+        FROM drive_sync_entries
+        WHERE drive_id = ?
+        ORDER BY path ASC
+        `)
+            .all(driveId);
+        return rows.map(mapDriveSyncEntryRow);
+    }
+    listDrives() {
+        const rows = this.db
+            .prepare(`
+        SELECT drive_id, title, root_path
+        FROM drive_sync_drives
+        ORDER BY drive_id ASC
+        `)
+            .all();
+        return rows.map((row) => ({
+            id: row.drive_id,
+            title: row.title,
+            rootPath: row.root_path,
+        }));
+    }
+    getConflict(driveId, drivePath) {
+        const normalizedPath = normalizeDrivePath(drivePath);
+        const rows = this.db
+            .prepare(`
+        SELECT
+          drive_id,
+          path,
+          conflict_type,
+          reason,
+          local_content_sha256,
+          local_size_bytes,
+          local_version_id,
+          conflict_id,
+          conflict_path,
+          remote_batch_id,
+          remote_sequence
+        FROM drive_sync_conflicts
+        WHERE drive_id = ? AND path = ?
+        `)
+            .all(driveId, normalizedPath);
+        return rows[0] ? mapDriveSyncConflictRow(rows[0]) : null;
+    }
+    listConflicts(driveId) {
+        const rows = this.db
+            .prepare(`
+        SELECT
+          drive_id,
+          path,
+          conflict_type,
+          reason,
+          local_content_sha256,
+          local_size_bytes,
+          local_version_id,
+          conflict_id,
+          conflict_path,
+          remote_batch_id,
+          remote_sequence
+        FROM drive_sync_conflicts
+        WHERE drive_id = ?
+        ORDER BY path ASC
+        `)
+            .all(driveId);
+        return rows.map(mapDriveSyncConflictRow);
+    }
+    setSyncClient(client) {
+        this.db
+            .prepare(`
+        INSERT INTO drive_sync_clients (id, team_id, agent_id, host_id, display_name, status, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, datetime('now'))
+        ON CONFLICT(id) DO UPDATE SET
+          team_id = excluded.team_id,
+          agent_id = excluded.agent_id,
+          host_id = excluded.host_id,
+          display_name = excluded.display_name,
+          status = excluded.status,
+          updated_at = excluded.updated_at
+        `)
+            .run(client.id, client.team_id, client.agent_id, client.host_id, client.display_name, client.status);
+    }
+    upsertDrive(drive) {
+        this.db
+            .prepare(`
+        INSERT INTO drive_sync_drives (drive_id, title, root_path, updated_at)
+        VALUES (?, ?, ?, datetime('now'))
+        ON CONFLICT(drive_id) DO UPDATE SET
+          title = excluded.title,
+          root_path = excluded.root_path,
+          updated_at = excluded.updated_at
+        `)
+            .run(drive.id, drive.title, drive.rootPath);
+    }
+    removeDrive(driveId) {
+        this.db.prepare('DELETE FROM drive_sync_conflicts WHERE drive_id = ?').run(driveId);
+        this.db.prepare('DELETE FROM drive_sync_entries WHERE drive_id = ?').run(driveId);
+        this.db.prepare('DELETE FROM drive_sync_cursors WHERE drive_id = ?').run(driveId);
+        this.db.prepare('DELETE FROM drive_sync_drives WHERE drive_id = ?').run(driveId);
+    }
+    setCursor(driveId, lastBatchSequence) {
+        this.db
+            .prepare(`
+        INSERT INTO drive_sync_cursors (drive_id, last_batch_sequence, updated_at)
+        VALUES (?, ?, datetime('now'))
+        ON CONFLICT(drive_id) DO UPDATE SET
+          last_batch_sequence = excluded.last_batch_sequence,
+          updated_at = excluded.updated_at
+        `)
+            .run(driveId, lastBatchSequence);
+    }
+    upsertEntry(entry) {
+        this.db
+            .prepare(`
+        INSERT INTO drive_sync_entries (
+          drive_id,
+          path,
+          entry_type,
+          version_id,
+          content_sha256,
+          size_bytes,
+          mime_type,
+          updated_at
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, datetime('now'))
+        ON CONFLICT(drive_id, path) DO UPDATE SET
+          entry_type = excluded.entry_type,
+          version_id = excluded.version_id,
+          content_sha256 = excluded.content_sha256,
+          size_bytes = excluded.size_bytes,
+          mime_type = excluded.mime_type,
+          updated_at = excluded.updated_at
+        `)
+            .run(entry.driveId, entry.path, entry.entryType, entry.versionId, entry.contentSha256, entry.sizeBytes, entry.mimeType);
+    }
+    upsertConflict(conflict) {
+        this.db
+            .prepare(`
+        INSERT INTO drive_sync_conflicts (
+          drive_id,
+          path,
+          conflict_type,
+          reason,
+          local_content_sha256,
+          local_size_bytes,
+          local_version_id,
+          conflict_id,
+          conflict_path,
+          remote_batch_id,
+          remote_sequence,
+          updated_at
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))
+        ON CONFLICT(drive_id, path) DO UPDATE SET
+          conflict_type = excluded.conflict_type,
+          reason = excluded.reason,
+          local_content_sha256 = excluded.local_content_sha256,
+          local_size_bytes = excluded.local_size_bytes,
+          local_version_id = excluded.local_version_id,
+          conflict_id = excluded.conflict_id,
+          conflict_path = excluded.conflict_path,
+          remote_batch_id = excluded.remote_batch_id,
+          remote_sequence = excluded.remote_sequence,
+          updated_at = excluded.updated_at
+        `)
+            .run(conflict.driveId, conflict.path, conflict.conflictType, conflict.reason, conflict.localContentSha256, conflict.localSizeBytes, conflict.localVersionId, conflict.conflictId, conflict.conflictPath, conflict.remoteBatchId, conflict.remoteSequence);
+    }
+    deleteConflict(driveId, drivePath) {
+        this.db
+            .prepare('DELETE FROM drive_sync_conflicts WHERE drive_id = ? AND path = ?')
+            .run(driveId, normalizeDrivePath(drivePath));
+    }
+    deleteConflictTree(driveId, drivePath) {
+        const normalizedPath = normalizeDrivePath(drivePath);
+        if (normalizedPath === '/') {
+            this.db.prepare('DELETE FROM drive_sync_conflicts WHERE drive_id = ?').run(driveId);
+            return;
+        }
+        const prefix = `${normalizedPath}/`;
+        this.db
+            .prepare(`
+        DELETE FROM drive_sync_conflicts
+        WHERE drive_id = ?
+          AND (path = ? OR substr(path, 1, ?) = ?)
+        `)
+            .run(driveId, normalizedPath, prefix.length, prefix);
+    }
+    deleteEntryTree(driveId, drivePath) {
+        const normalizedPath = normalizeDrivePath(drivePath);
+        if (normalizedPath === '/') {
+            this.db.prepare('DELETE FROM drive_sync_entries WHERE drive_id = ?').run(driveId);
+            return;
+        }
+        const prefix = `${normalizedPath}/`;
+        this.db
+            .prepare(`
+        DELETE FROM drive_sync_entries
+        WHERE drive_id = ?
+          AND (path = ? OR substr(path, 1, ?) = ?)
+        `)
+            .run(driveId, normalizedPath, prefix.length, prefix);
+    }
+    moveEntryTree(driveId, fromPath, toPath) {
+        const normalizedFromPath = normalizeDrivePath(fromPath);
+        const normalizedToPath = normalizeDrivePath(toPath);
+        const prefix = normalizedFromPath === '/' ? '/' : `${normalizedFromPath}/`;
+        const rows = this.db
+            .prepare(`
+        SELECT path, entry_type, version_id, content_sha256, size_bytes, mime_type
+        FROM drive_sync_entries
+        WHERE drive_id = ?
+          AND (path = ? OR substr(path, 1, ?) = ?)
+        `)
+            .all(driveId, normalizedFromPath, prefix.length, prefix);
+        this.deleteEntryTree(driveId, normalizedFromPath);
+        for (const row of rows) {
+            const suffix = row.path === normalizedFromPath ? '' : row.path.slice(normalizedFromPath.length);
+            this.upsertEntry({
+                driveId,
+                path: `${normalizedToPath}${suffix}`,
+                entryType: row.entry_type,
+                versionId: row.version_id,
+                contentSha256: row.content_sha256,
+                sizeBytes: row.size_bytes,
+                mimeType: row.mime_type,
+            });
+        }
+    }
+    ensureSchema() {
+        this.db.exec(`
+      PRAGMA journal_mode = WAL;
+      CREATE TABLE IF NOT EXISTS drive_sync_metadata (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS drive_sync_clients (
+        id TEXT PRIMARY KEY,
+        team_id TEXT NOT NULL,
+        agent_id TEXT,
+        host_id TEXT,
+        display_name TEXT,
+        status TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS drive_sync_drives (
+        drive_id TEXT PRIMARY KEY,
+        title TEXT,
+        root_path TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS drive_sync_cursors (
+        drive_id TEXT PRIMARY KEY,
+        last_batch_sequence INTEGER NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS drive_sync_entries (
+        drive_id TEXT NOT NULL,
+        path TEXT NOT NULL,
+        entry_type TEXT NOT NULL,
+        version_id TEXT,
+        content_sha256 TEXT,
+        size_bytes INTEGER,
+        mime_type TEXT,
+        updated_at TEXT NOT NULL,
+        PRIMARY KEY (drive_id, path)
+      );
+      CREATE TABLE IF NOT EXISTS drive_sync_conflicts (
+        drive_id TEXT NOT NULL,
+        path TEXT NOT NULL,
+        conflict_type TEXT NOT NULL,
+        reason TEXT,
+        local_content_sha256 TEXT,
+        local_size_bytes INTEGER,
+        local_version_id TEXT,
+        conflict_id TEXT,
+        conflict_path TEXT,
+        remote_batch_id TEXT,
+        remote_sequence INTEGER,
+        updated_at TEXT NOT NULL,
+        PRIMARY KEY (drive_id, path)
+      );
+    `);
+    }
+}
+export async function createManagedDriveSyncService(params) {
+    const stateStore = params.stateStore ?? (await DriveSyncStateStore.open(params.config.driveSync.stateDir));
+    const api = params.api ??
+        createSupabaseDriveSyncApi(params.supabase, {
+            timeoutMs: params.config.driveSync.networkTimeoutMs,
+        });
+    const service = new ManagedDrivePullSyncService({
+        config: params.config,
+        api,
+        stateStore,
+    });
+    await mkdir(params.config.driveSync.rootDir, { recursive: true });
+    return service;
+}
+export function createSupabaseDriveSyncApi(supabase, options = {}) {
+    const timeoutMs = options.timeoutMs ?? DEFAULT_DRIVE_SYNC_NETWORK_TIMEOUT_MS;
+    return {
+        registerClient: (body) => invokeDriveSyncFunction(supabase, 'register-drive-sync-client', body, timeoutMs),
+        listDrives: (body) => invokeDriveSyncFunction(supabase, 'list-sync-drives', body, timeoutMs),
+        getChanges: (body) => invokeDriveSyncFunction(supabase, 'get-drive-changes', body, timeoutMs),
+        downloadFileVersion: (body) => invokeDriveSyncFunction(supabase, 'download-drive-file-version', body, timeoutMs),
+        prepareFileUpload: (body) => invokeDriveSyncFunction(supabase, 'prepare-drive-file-upload', body, timeoutMs),
+        ackChanges: (body) => invokeDriveSyncFunction(supabase, 'ack-drive-changes', body, timeoutMs),
+        applyLocalChangeBatch: (body) => invokeDriveSyncFunction(supabase, 'apply-local-drive-change-batch', body, timeoutMs),
+        applyConflictActions: (body) => invokeDriveSyncFunction(supabase, 'apply-drive-conflict-actions', body, timeoutMs),
+        reportStatus: (body) => invokeDriveSyncFunction(supabase, 'report-drive-sync-status', body, timeoutMs),
+    };
+}
+export async function applyDriveChangeBatchToLocalFilesystem(params) {
+    let appliedPathCount = 0;
+    let remoteConflictCount = 0;
+    const remoteConflicts = [];
+    const operations = planRemoteDriveBatch(params.batch);
+    for (const operation of operations) {
+        if (operation.type === 'move') {
+            const sourcePath = resolveDriveLocalPath(params.driveRoot, operation.fromPath);
+            const targetPath = resolveDriveLocalPath(params.driveRoot, operation.toPath);
+            await assertNoSymlinkInExistingPath(params.driveRoot, path.dirname(sourcePath));
+            const alreadyAppliedMove = await classifyRemoteMoveAlreadyApplied({
+                driveId: params.batch.drive_id,
+                driveRoot: params.driveRoot,
+                stateStore: params.stateStore,
+                fromPath: operation.fromPath,
+                toPath: operation.toPath,
+            });
+            if (alreadyAppliedMove) {
+                if (alreadyAppliedMove === 'advance_state') {
+                    applyRemoteDriveMoveState({
+                        stateStore: params.stateStore,
+                        driveId: params.batch.drive_id,
+                        fromPath: operation.fromPath,
+                        toPath: operation.toPath,
+                    });
+                }
+                appliedPathCount += 1;
+                continue;
+            }
+            const preserved = await preserveRemoteApplySteps({
+                driveId: params.batch.drive_id,
+                driveRoot: params.driveRoot,
+                stateStore: params.stateStore,
+                batch: params.batch,
+                steps: operation.preserve,
+            });
+            remoteConflictCount += preserved.conflictCount;
+            remoteConflicts.push(...preserved.conflicts);
+            await assertPathExists(sourcePath, `Drive move source is missing: ${operation.fromPath}`);
+            await assertLocalPathIsNotSymlink(sourcePath, `Drive move source is a symlink: ${operation.fromPath}`);
+            await assertNoSymlinkInExistingPath(params.driveRoot, path.dirname(targetPath));
+            await mkdir(path.dirname(targetPath), { recursive: true });
+            await rm(targetPath, { recursive: true, force: true });
+            await rename(sourcePath, targetPath);
+            applyRemoteDriveMoveState({
+                stateStore: params.stateStore,
+                driveId: params.batch.drive_id,
+                fromPath: operation.fromPath,
+                toPath: operation.toPath,
+            });
+            appliedPathCount += 1;
+            continue;
+        }
+        const localPath = resolveDriveLocalPath(params.driveRoot, operation.path);
+        if (operation.type === 'delete') {
+            if (await remoteDeleteAlreadyApplied({
+                driveId: params.batch.drive_id,
+                driveRoot: params.driveRoot,
+                path: operation.path,
+            })) {
+                applyRemoteDriveDeleteState({
+                    stateStore: params.stateStore,
+                    driveId: params.batch.drive_id,
+                    path: operation.path,
+                });
+                appliedPathCount += 1;
+                continue;
+            }
+            const preserved = await preserveRemoteApplySteps({
+                driveId: params.batch.drive_id,
+                driveRoot: params.driveRoot,
+                stateStore: params.stateStore,
+                batch: params.batch,
+                steps: operation.preserve,
+            });
+            remoteConflictCount += preserved.conflictCount;
+            remoteConflicts.push(...preserved.conflicts);
+            await assertNoSymlinkInExistingPath(params.driveRoot, path.dirname(localPath));
+            await rm(localPath, { recursive: true, force: true });
+            applyRemoteDriveDeleteState({
+                stateStore: params.stateStore,
+                driveId: params.batch.drive_id,
+                path: operation.path,
+            });
+            appliedPathCount += 1;
+            continue;
+        }
+        if (operation.type === 'mkdir') {
+            await assertNoSymlinkInExistingPath(params.driveRoot, path.dirname(localPath));
+            await assertLocalPathIsNotSymlink(localPath, `Drive directory target is a symlink: ${operation.path}`);
+            await mkdir(localPath, { recursive: true });
+            applyRemoteDriveDirectoryState({
+                stateStore: params.stateStore,
+                driveId: params.batch.drive_id,
+                path: operation.path,
+            });
+            appliedPathCount += 1;
+            continue;
+        }
+        const alreadyAppliedFile = await remoteFileAlreadyApplied({
+            driveId: params.batch.drive_id,
+            driveRoot: params.driveRoot,
+            path: operation.path,
+            version: operation.change.version,
+        });
+        if (alreadyAppliedFile) {
+            applyRemoteDriveFileState({
+                stateStore: params.stateStore,
+                driveId: params.batch.drive_id,
+                path: operation.path,
+                versionId: operation.versionId,
+                version: operation.change.version,
+                downloadedSizeBytes: alreadyAppliedFile.sizeBytes,
+            });
+            appliedPathCount += 1;
+            continue;
+        }
+        const preserved = await preserveRemoteApplySteps({
+            driveId: params.batch.drive_id,
+            driveRoot: params.driveRoot,
+            stateStore: params.stateStore,
+            batch: params.batch,
+            steps: operation.preserve,
+        });
+        remoteConflictCount += preserved.conflictCount;
+        remoteConflicts.push(...preserved.conflicts);
+        await assertNoSymlinkInExistingPath(params.driveRoot, path.dirname(localPath));
+        await assertLocalPathIsNotSymlink(localPath, `Drive file target is a symlink: ${operation.path}`);
+        if (preserved.overwriteResults.get(operation.path)?.localEntry?.entryType === 'directory') {
+            await rm(localPath, { recursive: true, force: true });
+        }
+        const version = operation.change.version;
+        const downloaded = await downloadDriveVersionToLocalFile({
+            api: params.api,
+            syncClientId: params.syncClientId,
+            driveId: params.batch.drive_id,
+            versionId: operation.versionId,
+            targetPath: localPath,
+            expectedSizeBytes: version?.size_bytes ?? null,
+            expectedSha256: version?.content_sha256 ?? null,
+        });
+        applyRemoteDriveFileState({
+            stateStore: params.stateStore,
+            driveId: params.batch.drive_id,
+            path: operation.path,
+            versionId: operation.versionId,
+            version,
+            downloadedSizeBytes: downloaded.sizeBytes,
+        });
+        appliedPathCount += 1;
+    }
+    return { appliedPathCount, remoteConflictCount, remoteConflicts };
+}
+async function classifyRemoteMoveAlreadyApplied(params) {
+    const normalizedFromPath = normalizeDrivePath(params.fromPath);
+    const normalizedToPath = normalizeDrivePath(params.toPath);
+    const localSource = await readLocalDriveEntryAtPath({
+        driveId: params.driveId,
+        driveRoot: params.driveRoot,
+        drivePath: normalizedFromPath,
+    });
+    if (localSource) {
+        return null;
+    }
+    const baselineSource = params.stateStore.getEntry?.(params.driveId, normalizedFromPath) ?? null;
+    const baselineTarget = params.stateStore.getEntry?.(params.driveId, normalizedToPath) ?? null;
+    const localTarget = await readLocalDriveEntryAtPath({
+        driveId: params.driveId,
+        driveRoot: params.driveRoot,
+        drivePath: normalizedToPath,
+    });
+    if (!localTarget) {
+        return null;
+    }
+    if (baselineTarget && localEntryMatchesBaseline(localTarget, baselineTarget)) {
+        return 'already_applied';
+    }
+    if (baselineSource?.entryType === 'file' &&
+        localEntryMatchesBaseline(localTarget, baselineSource)) {
+        return 'advance_state';
+    }
+    return null;
+}
+async function remoteDeleteAlreadyApplied(params) {
+    const localEntry = await readLocalDriveEntryAtPath({
+        driveId: params.driveId,
+        driveRoot: params.driveRoot,
+        drivePath: params.path,
+    });
+    return localEntry === null;
+}
+async function remoteFileAlreadyApplied(params) {
+    if (!params.version) {
+        return null;
+    }
+    const localEntry = await readLocalDriveEntryAtPath({
+        driveId: params.driveId,
+        driveRoot: params.driveRoot,
+        drivePath: params.path,
+    });
+    if (localEntry?.entryType !== 'file' ||
+        localEntry.contentSha256 !== params.version.content_sha256 ||
+        localEntry.sizeBytes !== params.version.size_bytes) {
+        return null;
+    }
+    return { sizeBytes: localEntry.sizeBytes ?? params.version.size_bytes };
+}
+async function preserveRemoteApplySteps(params) {
+    let conflictCount = 0;
+    const conflicts = [];
+    const overwriteResults = new Map();
+    for (const step of params.steps) {
+        if (step.type === 'path_conflict_candidate') {
+            const result = await preserveRemoteApplyConflictCandidate({
+                driveId: params.driveId,
+                driveRoot: params.driveRoot,
+                drivePath: step.path,
+                stateStore: params.stateStore,
+                batch: params.batch,
+                reason: step.reason,
+            });
+            conflictCount += result.conflictCount;
+            conflicts.push(...result.conflicts);
+            continue;
+        }
+        const result = await preserveRemoteApplyOverwriteCandidates({
+            driveId: params.driveId,
+            driveRoot: params.driveRoot,
+            drivePath: step.path,
+            stateStore: params.stateStore,
+            batch: params.batch,
+            reason: step.reason,
+            subtreeReason: step.subtreeReason,
+        });
+        conflictCount += result.conflictCount;
+        conflicts.push(...result.conflicts);
+        overwriteResults.set(step.path, {
+            localEntry: result.localEntry,
+            baselineEntry: result.baselineEntry,
+        });
+    }
+    return { conflictCount, conflicts, overwriteResults };
+}
+async function preserveRemoteApplyConflictCandidate(params) {
+    const normalizedPath = normalizeDrivePath(params.drivePath);
+    const baselineEntry = params.stateStore.getEntry?.(params.driveId, normalizedPath) ?? null;
+    const localEntry = await readLocalDriveEntryAtPath({
+        driveId: params.driveId,
+        driveRoot: params.driveRoot,
+        drivePath: normalizedPath,
+    });
+    if (!baselineEntry && !localEntry) {
+        return { conflictCount: 0, conflicts: [] };
+    }
+    if (baselineEntry && localEntry && localEntryMatchesBaseline(localEntry, baselineEntry)) {
+        return { conflictCount: 0, conflicts: [] };
+    }
+    if (!baselineEntry && localEntry?.entryType === 'directory') {
+        return { conflictCount: 0, conflicts: [] };
+    }
+    const conflictPath = localEntry?.entryType === 'file'
+        ? await writeLocalConflictCopy({
+            driveRoot: params.driveRoot,
+            source: localEntry,
+            sourceRootPath: normalizedPath,
+            conflictRootPath: normalizedPath,
+        })
+        : null;
+    const conflict = recordRemoteApplyConflict({
+        stateStore: params.stateStore,
+        driveId: params.driveId,
+        path: normalizedPath,
+        reason: params.reason,
+        localEntry,
+        baselineEntry,
+        conflictPath,
+        remoteBatchId: params.batch.id,
+        remoteSequence: params.batch.sequence,
+    });
+    return { conflictCount: 1, conflicts: [conflict] };
+}
+async function preserveRemoteApplyOverwriteCandidates(params) {
+    const normalizedPath = normalizeDrivePath(params.drivePath);
+    const baselineEntry = params.stateStore.getEntry?.(params.driveId, normalizedPath) ?? null;
+    const localEntry = await readLocalDriveEntryAtPath({
+        driveId: params.driveId,
+        driveRoot: params.driveRoot,
+        drivePath: normalizedPath,
+    });
+    if (baselineEntry?.entryType === 'directory' || localEntry?.entryType === 'directory') {
+        const conflictCount = await preserveRemoteApplySubtreeConflictCandidates({
+            driveId: params.driveId,
+            driveRoot: params.driveRoot,
+            drivePath: normalizedPath,
+            stateStore: params.stateStore,
+            batch: params.batch,
+            reason: params.subtreeReason ?? params.reason,
+        });
+        return { ...conflictCount, localEntry, baselineEntry };
+    }
+    const conflictResult = await preserveRemoteApplyConflictCandidate({
+        driveId: params.driveId,
+        driveRoot: params.driveRoot,
+        drivePath: normalizedPath,
+        stateStore: params.stateStore,
+        batch: params.batch,
+        reason: params.reason,
+    });
+    return { ...conflictResult, localEntry, baselineEntry };
+}
+async function preserveRemoteApplySubtreeConflictCandidates(params) {
+    const normalizedPath = normalizeDrivePath(params.drivePath);
+    const baselineEntries = (params.stateStore.listEntries?.(params.driveId) ?? []).filter((entry) => drivePathIsInSubtree(entry.path, normalizedPath));
+    const baselineByPath = new Map(baselineEntries.map((entry) => [entry.path, entry]));
+    const localScan = await scanLocalDriveEntries({
+        driveId: params.driveId,
+        driveRoot: params.driveRoot,
+    });
+    for (const deferredPath of localScan.deferredPaths) {
+        if (drivePathIsInSubtree(deferredPath, normalizedPath)) {
+            throw new Error(`Local drive subtree has an unstable file; refusing to delete ${params.drivePath}`);
+        }
+    }
+    let conflictCount = 0;
+    const conflicts = [];
+    for (const [drivePath, localEntry] of localScan.entries) {
+        if (!drivePathIsInSubtree(drivePath, normalizedPath)) {
+            continue;
+        }
+        const baselineEntry = baselineByPath.get(drivePath) ?? null;
+        if (baselineEntry && localEntryMatchesBaseline(localEntry, baselineEntry)) {
+            continue;
+        }
+        if (localEntry.entryType === 'directory') {
+            continue;
+        }
+        const conflictPath = localEntry.entryType === 'file'
+            ? await writeLocalConflictCopy({
+                driveRoot: params.driveRoot,
+                source: localEntry,
+                sourceRootPath: normalizedPath,
+                conflictRootPath: buildSubtreeConflictRootPath(normalizedPath),
+            })
+            : null;
+        const conflict = recordRemoteApplyConflict({
+            stateStore: params.stateStore,
+            driveId: params.driveId,
+            path: drivePath,
+            reason: params.reason,
+            localEntry,
+            baselineEntry,
+            conflictPath,
+            remoteBatchId: params.batch.id,
+            remoteSequence: params.batch.sequence,
+        });
+        conflicts.push(conflict);
+        conflictCount += 1;
+    }
+    return { conflictCount, conflicts };
+}
+export async function reconcileLocalDriveToCloud(params) {
+    const fullBaseline = new Map((params.stateStore.listEntries?.(params.driveId) ?? []).map((entry) => [entry.path, entry]));
+    const baseline = params.dirtyDrivePaths
+        ? filterBaselineForDirtyDrivePaths(fullBaseline, params.dirtyDrivePaths)
+        : fullBaseline;
+    const localScan = await scanLocalDriveEntries({
+        driveId: params.driveId,
+        driveRoot: params.driveRoot,
+        rootDrivePaths: params.dirtyDrivePaths ?? undefined,
+    });
+    const conflicts = new Map((params.stateStore.listConflicts?.(params.driveId) ?? []).map((conflict) => [
+        conflict.path,
+        conflict,
+    ]));
+    const scopedConflicts = params.dirtyDrivePaths
+        ? filterConflictsForDirtyDrivePaths(conflicts, params.dirtyDrivePaths)
+        : conflicts;
+    const localPlan = planLocalDriveSync({
+        baseline,
+        local: localScan.entries,
+        deferredPaths: localScan.deferredPaths,
+        conflicts: scopedConflicts,
+    });
+    const confirmedConflictActions = await applyCloudDriveConflictLifecycleActions({
+        syncClientId: params.syncClientId,
+        driveId: params.driveId,
+        api: params.api,
+        conflicts: scopedConflicts,
+        actions: localPlan.conflictActions,
+    });
+    applyLocalDriveConflictActions({
+        stateStore: params.stateStore,
+        actions: confirmedConflictActions,
+    });
+    const mutations = localPlan.mutations;
+    if (mutations.length === 0) {
+        return {
+            ...emptyLocalReconcileSummary(),
+            deferredFileCount: localScan.deferredFileCount,
+        };
+    }
+    let uploadedBatchCount = 0;
+    let uploadedChangeCount = 0;
+    let uploadedAppliedCount = 0;
+    let uploadedConflictCount = 0;
+    let uploadedUnsupportedCount = 0;
+    let uploadedRejectedCount = 0;
+    let deferredFileCount = localScan.deferredFileCount;
+    const uploadResult = await prepareLocalMutationUploads({
+        syncClientId: params.syncClientId,
+        driveId: params.driveId,
+        api: params.api,
+        mutations,
+    });
+    deferredFileCount += uploadResult.deferredPaths.length;
+    const preparedMutations = uploadResult.preparedMutations;
+    if (preparedMutations.length === 0) {
+        return {
+            ...emptyLocalReconcileSummary(),
+            deferredFileCount,
+        };
+    }
+    const mutationChunks = chunkLocalDriveMutations(preparedMutations);
+    const resourceOperationChunkFingerprints = mutationChunks.map((chunk, chunkIndex) => buildLocalResourceOperationChunkFingerprint({
+        driveId: params.driveId,
+        baseCursorSequence: params.baseCursorSequence,
+        chunkIndex: chunkIndex + 1,
+        chunkCount: mutationChunks.length,
+        mutations: chunk,
+    }));
+    const resourceOperationFingerprint = buildLocalResourceOperationFingerprint({
+        driveId: params.driveId,
+        baseCursorSequence: params.baseCursorSequence,
+        chunkFingerprints: resourceOperationChunkFingerprints,
+    });
+    const resourceOperationId = `local-reconcile:${resourceOperationFingerprint}`;
+    let finalizedOperationResponse = null;
+    for (const [chunkIndex, chunk] of mutationChunks.entries()) {
+        const response = await params.api.applyLocalChangeBatch({
+            sync_client_id: params.syncClientId,
+            drive_id: params.driveId,
+            resource_operation_id: resourceOperationId,
+            resource_operation_fingerprint: resourceOperationFingerprint,
+            resource_operation_chunk_fingerprint: resourceOperationChunkFingerprints[chunkIndex],
+            resource_operation_chunk_fingerprints: resourceOperationChunkFingerprints,
+            resource_operation_chunk_index: chunkIndex + 1,
+            resource_operation_chunk_count: mutationChunks.length,
+            base_cursor_sequence: params.baseCursorSequence,
+            changes: chunk.map((mutation) => mutation.request),
+        });
+        uploadedBatchCount += 1;
+        uploadedChangeCount += chunk.length;
+        if (isStagedLocalOperationResponse(response)) {
+            continue;
+        }
+        if (isFinalizedFullLocalOperationResponse(response, preparedMutations.length)) {
+            finalizedOperationResponse = response;
+            continue;
+        }
+        await applyAcceptedLocalChangeResults({
+            driveId: params.driveId,
+            driveRoot: params.driveRoot,
+            mutations: chunk,
+            results: response.results,
+            stateStore: params.stateStore,
+        });
+        uploadedAppliedCount += response.applied_count;
+        uploadedConflictCount += response.conflict_count;
+        uploadedUnsupportedCount += response.unsupported_count;
+        uploadedRejectedCount += response.rejected_count;
+    }
+    if (finalizedOperationResponse) {
+        await applyAcceptedLocalChangeResults({
+            driveId: params.driveId,
+            driveRoot: params.driveRoot,
+            mutations: preparedMutations,
+            results: finalizedOperationResponse.results,
+            stateStore: params.stateStore,
+        });
+        uploadedAppliedCount += finalizedOperationResponse.applied_count;
+        uploadedConflictCount += finalizedOperationResponse.conflict_count;
+        uploadedUnsupportedCount += finalizedOperationResponse.unsupported_count;
+        uploadedRejectedCount += finalizedOperationResponse.rejected_count;
+    }
+    return {
+        uploadedBatchCount,
+        uploadedChangeCount,
+        uploadedAppliedCount,
+        uploadedConflictCount,
+        uploadedUnsupportedCount,
+        uploadedRejectedCount,
+        deferredFileCount,
+    };
+}
+function emptyLocalReconcileSummary() {
+    return {
+        uploadedBatchCount: 0,
+        uploadedChangeCount: 0,
+        uploadedAppliedCount: 0,
+        uploadedConflictCount: 0,
+        uploadedUnsupportedCount: 0,
+        uploadedRejectedCount: 0,
+        deferredFileCount: 0,
+    };
+}
+function filterBaselineForDirtyDrivePaths(baseline, dirtyDrivePaths) {
+    if (dirtyDrivePaths.size === 0) {
+        return new Map();
+    }
+    const normalizedDirtyPaths = [...dirtyDrivePaths].map(normalizeDrivePath);
+    return new Map([...baseline].filter(([baselinePath]) => normalizedDirtyPaths.some((dirtyPath) => drivePathIsInSubtree(baselinePath, dirtyPath) ||
+        drivePathIsInSubtree(dirtyPath, baselinePath))));
+}
+function filterConflictsForDirtyDrivePaths(conflicts, dirtyDrivePaths) {
+    if (dirtyDrivePaths.size === 0) {
+        return new Map();
+    }
+    const normalizedDirtyPaths = [...dirtyDrivePaths].map(normalizeDrivePath);
+    return new Map([...conflicts].filter(([, conflict]) => normalizedDirtyPaths.some((dirtyPath) => drivePathsIntersect(conflict.path, dirtyPath) ||
+        (conflict.conflictPath ? drivePathsIntersect(conflict.conflictPath, dirtyPath) : false))));
+}
+function drivePathsIntersect(leftPath, rightPath) {
+    return drivePathIsInSubtree(leftPath, rightPath) || drivePathIsInSubtree(rightPath, leftPath);
+}
+async function applyCloudDriveConflictLifecycleActions(params) {
+    if (params.actions.length === 0 || !params.api.applyConflictActions) {
+        return [];
+    }
+    const response = await params.api.applyConflictActions({
+        sync_client_id: params.syncClientId,
+        drive_id: params.driveId,
+        operation_id: buildConflictLifecycleOperationId({
+            driveId: params.driveId,
+            actions: params.actions,
+            conflicts: params.conflicts,
+        }),
+        actions: params.actions.map((action) => {
+            const conflict = params.conflicts.get(action.path) ?? null;
+            const payload = {
+                type: action.type,
+                path: action.path,
+                reason: action.reason,
+            };
+            if (conflict?.conflictId) {
+                payload.conflict_id = conflict.conflictId;
+            }
+            if (action.type === 'update_conflict_path') {
+                payload.conflict_path = action.conflictPath;
+            }
+            return payload;
+        }),
+    });
+    return collectConfirmedConflictActions(params.actions, response.results);
+}
+function collectConfirmedConflictActions(actions, results) {
+    const confirmedActions = [];
+    for (const result of results) {
+        if (!isConfirmedConflictActionResult(result)) {
+            continue;
+        }
+        const action = actions[result.index];
+        if (!action || result.type !== action.type) {
+            continue;
+        }
+        if (typeof result.path === 'string' && normalizeDrivePath(result.path) !== action.path) {
+            continue;
+        }
+        if (action.type === 'clear_conflict') {
+            if (result.status === 'resolved' || result.status === 'ignored') {
+                confirmedActions.push(action);
+            }
+            continue;
+        }
+        if (result.status !== 'updated') {
+            continue;
+        }
+        confirmedActions.push({
+            ...action,
+            conflictPath: typeof result.conflict_path === 'string'
+                ? normalizeDrivePath(result.conflict_path)
+                : action.conflictPath,
+        });
+    }
+    return confirmedActions;
+}
+function isConfirmedConflictActionResult(result) {
+    return (Number.isInteger(result.index) &&
+        typeof result.type === 'string' &&
+        typeof result.status === 'string');
+}
+function buildConflictLifecycleOperationId(params) {
+    const stablePayload = params.actions.map((action) => {
+        const conflict = params.conflicts.get(action.path) ?? null;
+        return {
+            type: action.type,
+            path: action.path,
+            reason: action.reason,
+            conflict_id: conflict?.conflictId ?? null,
+            conflict_path: action.type === 'update_conflict_path' ? action.conflictPath : null,
+        };
+    });
+    const digest = sha256Hex(Buffer.from(JSON.stringify({
+        driveId: params.driveId,
+        actions: stablePayload,
+    })));
+    return `conflict-lifecycle:${digest}`;
+}
+function collectRemoteConflictsForAck(params) {
+    const byPath = new Map();
+    for (const conflict of params.newConflicts) {
+        if (conflict.conflictType === 'remote_apply') {
+            byPath.set(conflict.path, conflict);
+        }
+    }
+    for (const conflict of params.stateStore.listConflicts?.(params.driveId) ?? []) {
+        if (conflict.conflictType !== 'remote_apply') {
+            continue;
+        }
+        if (conflict.remoteBatchId === params.batch.id ||
+            conflict.remoteSequence === params.batch.sequence) {
+            byPath.set(conflict.path, conflict);
+        }
+    }
+    return [...byPath.values()].sort((left, right) => left.path.localeCompare(right.path));
+}
+function toRemoteConflictAckPayload(conflict) {
+    return {
+        path: conflict.path,
+        reason: conflict.reason,
+        conflict_path: conflict.conflictPath,
+        local_content_sha256: conflict.localContentSha256,
+        local_size_bytes: conflict.localSizeBytes,
+        local_version_id: isUuid(conflict.localVersionId) ? conflict.localVersionId : null,
+        remote_batch_id: isUuid(conflict.remoteBatchId) ? conflict.remoteBatchId : null,
+        remote_sequence: conflict.remoteSequence,
+    };
+}
+function buildRemoteConflictAckOperationId(params) {
+    const stablePayload = params.conflicts.map((conflict) => ({
+        path: conflict.path,
+        reason: conflict.reason,
+        conflict_path: conflict.conflictPath,
+        local_content_sha256: conflict.localContentSha256,
+        local_size_bytes: conflict.localSizeBytes,
+        local_version_id: isUuid(conflict.localVersionId) ? conflict.localVersionId : null,
+        remote_batch_id: isUuid(conflict.remoteBatchId) ? conflict.remoteBatchId : null,
+        remote_sequence: conflict.remoteSequence,
+    }));
+    const digest = sha256Hex(Buffer.from(JSON.stringify({
+        driveId: params.driveId,
+        batchId: params.batch.id,
+        batchSequence: params.batch.sequence,
+        conflicts: stablePayload,
+    })));
+    return `remote-conflict-ack:${digest}`;
+}
+function applyRemoteConflictAckResults(params) {
+    if (!params.results || !params.stateStore.getConflict || !params.stateStore.upsertConflict) {
+        return;
+    }
+    for (const result of params.results) {
+        if (typeof result.path !== 'string' || typeof result.conflict_id !== 'string') {
+            continue;
+        }
+        const drivePath = normalizeDrivePath(result.path);
+        const existing = params.stateStore.getConflict(params.driveId, drivePath);
+        if (!existing) {
+            continue;
+        }
+        params.stateStore.upsertConflict({
+            ...existing,
+            conflictId: result.conflict_id,
+            conflictPath: typeof result.conflict_path === 'string' ? result.conflict_path : existing.conflictPath,
+        });
+    }
+}
+function isUuid(value) {
+    return (typeof value === 'string' &&
+        /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value));
+}
+function isStagedLocalOperationResponse(response) {
+    return response.resource_operation_status === 'applying' && response.batch === null;
+}
+function isFinalizedFullLocalOperationResponse(response, preparedMutationCount) {
+    return (response.resource_operation_status === 'finalized' &&
+        response.results.length >= preparedMutationCount);
+}
+function chunkLocalDriveMutations(mutations) {
+    const chunks = [];
+    let currentChunk = [];
+    let currentUploadBytes = 0;
+    for (const mutation of mutations) {
+        if (mutation.uploadBytes > MAX_LOCAL_BATCH_UPLOAD_BYTES) {
+            throw new Error(getDriveLocalSyncFileTooLargeMessage(mutation.uploadBytes));
+        }
+        const nextUploadBytes = currentUploadBytes + mutation.uploadBytes;
+        if (currentChunk.length > 0 &&
+            (currentChunk.length >= MAX_LOCAL_BATCH_CHANGES ||
+                nextUploadBytes > MAX_LOCAL_BATCH_UPLOAD_BYTES)) {
+            chunks.push(currentChunk);
+            currentChunk = [];
+            currentUploadBytes = 0;
+        }
+        currentChunk.push(mutation);
+        currentUploadBytes += mutation.uploadBytes;
+    }
+    if (currentChunk.length > 0) {
+        chunks.push(currentChunk);
+    }
+    return chunks;
+}
+function buildLocalResourceOperationChunkFingerprint(params) {
+    return sha256Hex(Buffer.from(stableJsonStringify({
+        drive_id: params.driveId,
+        base_cursor_sequence: params.baseCursorSequence,
+        chunk_index: params.chunkIndex,
+        chunk_count: params.chunkCount,
+        changes: params.mutations.map((mutation) => mutation.request),
+    })));
+}
+function buildLocalResourceOperationFingerprint(params) {
+    return sha256Hex(Buffer.from(stableJsonStringify({
+        drive_id: params.driveId,
+        base_cursor_sequence: params.baseCursorSequence,
+        chunk_fingerprints: params.chunkFingerprints,
+    })));
+}
+async function applyAcceptedLocalChangeResults(params) {
+    for (const result of params.results) {
+        const mutation = params.mutations[result.index];
+        if (!mutation) {
+            continue;
+        }
+        if (result.status === 'applied') {
+            applyAppliedLocalDriveMutationState({
+                stateStore: params.stateStore,
+                driveId: params.driveId,
+                mutation,
+                result,
+            });
+            continue;
+        }
+        if (result.status === 'conflicted') {
+            const conflictPath = resolveLocalMutationResultPath(result, mutation);
+            const localConflictPath = await preserveLocalUploadConflictCandidate({
+                driveRoot: params.driveRoot,
+                mutation,
+                conflictPath,
+            });
+            recordLocalUploadConflict({
+                stateStore: params.stateStore,
+                driveId: params.driveId,
+                mutation,
+                result,
+                conflictPath,
+                localConflictPath,
+            });
+            continue;
+        }
+        if (result.status === 'unsupported' && mutation.stateEntry) {
+            applyUnsupportedLocalDriveMutationState({
+                stateStore: params.stateStore,
+                driveId: params.driveId,
+                mutation,
+            });
+        }
+    }
+}
+async function preserveLocalUploadConflictCandidate(params) {
+    if (params.mutation.request.type !== 'write_file' ||
+        !params.mutation.localFilePath ||
+        params.mutation.stateEntry?.entryType !== 'file') {
+        return null;
+    }
+    try {
+        return await writeLocalConflictCopy({
+            driveRoot: params.driveRoot,
+            source: {
+                driveId: params.mutation.stateEntry.driveId,
+                path: params.mutation.stateEntry.path,
+                entryType: 'file',
+                contentSha256: params.mutation.stateEntry.contentSha256,
+                sizeBytes: params.mutation.stateEntry.sizeBytes,
+                mimeType: params.mutation.stateEntry.mimeType,
+                absolutePath: params.mutation.localFilePath,
+            },
+            sourceRootPath: params.conflictPath,
+            conflictRootPath: params.conflictPath,
+        });
+    }
+    catch (error) {
+        console.warn(`${MANAGED_GATEWAY_LOG_PREFIX} failed to preserve local upload conflict copy`, {
+            path: params.conflictPath,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return null;
+    }
+}
+function emptyDriveSyncRunSummary(driveCount = 0) {
+    return {
+        driveCount,
+        failedDriveCount: 0,
+        appliedBatchCount: 0,
+        appliedPathCount: 0,
+        remoteConflictCount: 0,
+        uploadedBatchCount: 0,
+        uploadedChangeCount: 0,
+        uploadedAppliedCount: 0,
+        uploadedConflictCount: 0,
+        uploadedUnsupportedCount: 0,
+        uploadedRejectedCount: 0,
+        deferredFileCount: 0,
+    };
+}
+function toDriveSyncStatusSummary(summary) {
+    return {
+        applied_batch_count: summary.appliedBatchCount,
+        applied_path_count: summary.appliedPathCount,
+        remote_conflict_count: summary.remoteConflictCount,
+        uploaded_batch_count: summary.uploadedBatchCount,
+        uploaded_change_count: summary.uploadedChangeCount,
+        uploaded_applied_count: summary.uploadedAppliedCount,
+        uploaded_conflict_count: summary.uploadedConflictCount,
+        uploaded_unsupported_count: summary.uploadedUnsupportedCount,
+        uploaded_rejected_count: summary.uploadedRejectedCount,
+        deferred_file_count: summary.deferredFileCount,
+    };
+}
+function truncateDriveSyncStatusError(error) {
+    if (!error || error.length <= 2000) {
+        return error;
+    }
+    return `${error.slice(0, 1997)}...`;
+}
+function deriveDriveSyncStatus(schedulerStatus) {
+    if (!schedulerStatus) {
+        return 'active';
+    }
+    return schedulerStatus.watchStatus === 'active' ? 'active' : 'degraded';
+}
+function driveSummaryRequiresDegradedStatus(summary) {
+    return (summary.remoteConflictCount > 0 ||
+        summary.uploadedConflictCount > 0 ||
+        summary.uploadedUnsupportedCount > 0 ||
+        summary.uploadedRejectedCount > 0 ||
+        summary.deferredFileCount > 0 ||
+        summary.failedDriveCount > 0);
+}
+function summarizeDriveSyncConflicts(conflicts) {
+    return {
+        unresolvedConflictCount: conflicts.length,
+        unresolvedConflictSamples: conflicts
+            .slice(0, DRIVE_SYNC_STATUS_CONFLICT_SAMPLE_LIMIT)
+            .map((conflict) => ({
+            path: conflict.path,
+            conflict_type: conflict.conflictType,
+            reason: conflict.reason,
+            conflict_path: conflict.conflictPath,
+            conflict_id: conflict.conflictId,
+            remote_sequence: conflict.remoteSequence,
+        })),
+    };
+}
+class ManagedDrivePullSyncService {
+    params;
+    constructor(params) {
+        this.params = params;
+    }
+    close() {
+        this.params.stateStore.close?.();
+    }
+    async syncOnce(options = {}) {
+        const includeLocalWrites = options.includeLocalWrites !== false;
+        const syncStatus = deriveDriveSyncStatus(options.schedulerStatus);
+        const syncClient = await this.ensureSyncClient();
+        const drivesResponse = await this.params.api.listDrives({ sync_client_id: syncClient.id });
+        this.params.stateStore.setSyncClient(drivesResponse.sync_client);
+        await this.parkStaleDrives(new Set(drivesResponse.drives.map((drive) => drive.resource.id)));
+        let appliedBatchCount = 0;
+        let appliedPathCount = 0;
+        let remoteConflictCount = 0;
+        let uploadedBatchCount = 0;
+        let uploadedChangeCount = 0;
+        let uploadedAppliedCount = 0;
+        let uploadedConflictCount = 0;
+        let uploadedUnsupportedCount = 0;
+        let uploadedRejectedCount = 0;
+        let deferredFileCount = 0;
+        let failedDriveCount = 0;
+        for (const drive of drivesResponse.drives) {
+            const driveRoot = resolveDriveLocalRoot(this.params.config.driveSync.rootDir, drive.resource.id);
+            const dirtyDrivePaths = resolveDirtyDrivePathsForDrive(driveRoot, options.dirtyLocalPaths);
+            const driveSummary = emptyDriveSyncRunSummary(1);
+            let lastBatchSequence = drive.cursor?.last_batch_sequence ?? 0;
+            try {
+                await mkdir(driveRoot, { recursive: true });
+                this.params.stateStore.upsertDrive({
+                    id: drive.resource.id,
+                    title: drive.resource.title,
+                    rootPath: driveRoot,
+                });
+                const result = await this.syncDrive({
+                    syncClientId: syncClient.id,
+                    driveId: drive.resource.id,
+                    driveRoot,
+                });
+                lastBatchSequence = result.lastBatchSequence;
+                driveSummary.appliedBatchCount += result.appliedBatchCount;
+                driveSummary.appliedPathCount += result.appliedPathCount;
+                driveSummary.remoteConflictCount += result.remoteConflictCount;
+                if (includeLocalWrites && (!dirtyDrivePaths || dirtyDrivePaths.size > 0)) {
+                    const localResult = await reconcileLocalDriveToCloud({
+                        syncClientId: syncClient.id,
+                        driveId: drive.resource.id,
+                        driveRoot,
+                        baseCursorSequence: result.lastBatchSequence,
+                        api: this.params.api,
+                        stateStore: this.params.stateStore,
+                        dirtyDrivePaths,
+                    });
+                    driveSummary.uploadedBatchCount += localResult.uploadedBatchCount;
+                    driveSummary.uploadedChangeCount += localResult.uploadedChangeCount;
+                    driveSummary.uploadedAppliedCount += localResult.uploadedAppliedCount;
+                    driveSummary.uploadedConflictCount += localResult.uploadedConflictCount;
+                    driveSummary.uploadedUnsupportedCount += localResult.uploadedUnsupportedCount;
+                    driveSummary.uploadedRejectedCount += localResult.uploadedRejectedCount;
+                    driveSummary.deferredFileCount += localResult.deferredFileCount;
+                    if (localResult.uploadedBatchCount > 0) {
+                        const followUpResult = await this.syncDrive({
+                            syncClientId: syncClient.id,
+                            driveId: drive.resource.id,
+                            driveRoot,
+                        });
+                        lastBatchSequence = followUpResult.lastBatchSequence;
+                        driveSummary.appliedBatchCount += followUpResult.appliedBatchCount;
+                        driveSummary.appliedPathCount += followUpResult.appliedPathCount;
+                        driveSummary.remoteConflictCount += followUpResult.remoteConflictCount;
+                    }
+                }
+                appliedBatchCount += driveSummary.appliedBatchCount;
+                appliedPathCount += driveSummary.appliedPathCount;
+                remoteConflictCount += driveSummary.remoteConflictCount;
+                uploadedBatchCount += driveSummary.uploadedBatchCount;
+                uploadedChangeCount += driveSummary.uploadedChangeCount;
+                uploadedAppliedCount += driveSummary.uploadedAppliedCount;
+                uploadedConflictCount += driveSummary.uploadedConflictCount;
+                uploadedUnsupportedCount += driveSummary.uploadedUnsupportedCount;
+                uploadedRejectedCount += driveSummary.uploadedRejectedCount;
+                deferredFileCount += driveSummary.deferredFileCount;
+                await this.reportDriveSyncStatus({
+                    syncClientId: syncClient.id,
+                    driveId: drive.resource.id,
+                    driveRoot,
+                    status: syncStatus,
+                    lastBatchSequence,
+                    summary: driveSummary,
+                    lastReason: includeLocalWrites ? 'sync_once' : 'sync_once_remote_only',
+                    lastError: null,
+                    schedulerStatus: options.schedulerStatus,
+                });
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                failedDriveCount += 1;
+                await this.reportDriveSyncStatus({
+                    syncClientId: syncClient.id,
+                    driveId: drive.resource.id,
+                    driveRoot,
+                    status: 'error',
+                    lastBatchSequence,
+                    summary: driveSummary,
+                    lastReason: 'sync_error',
+                    lastError: errorMessage,
+                    schedulerStatus: options.schedulerStatus,
+                });
+                console.error(`${MANAGED_GATEWAY_LOG_PREFIX} failed to sync drive`, {
+                    driveId: drive.resource.id,
+                    error: errorMessage,
+                });
+            }
+        }
+        return {
+            driveCount: drivesResponse.drives.length,
+            failedDriveCount,
+            appliedBatchCount,
+            appliedPathCount,
+            remoteConflictCount,
+            uploadedBatchCount,
+            uploadedChangeCount,
+            uploadedAppliedCount,
+            uploadedConflictCount,
+            uploadedUnsupportedCount,
+            uploadedRejectedCount,
+            deferredFileCount,
+        };
+    }
+    async reportDriveSyncStatus(params) {
+        try {
+            const unresolvedConflictSummary = summarizeDriveSyncConflicts(this.params.stateStore.listConflicts?.(params.driveId) ?? []);
+            const status = params.status === 'active' &&
+                (unresolvedConflictSummary.unresolvedConflictCount > 0 ||
+                    driveSummaryRequiresDegradedStatus(params.summary))
+                ? 'degraded'
+                : params.status;
+            await this.params.api.reportStatus({
+                sync_client_id: params.syncClientId,
+                drive_id: params.driveId,
+                status,
+                last_reason: params.lastReason,
+                last_error: truncateDriveSyncStatusError(params.lastError),
+                last_batch_sequence: params.lastBatchSequence,
+                summary: toDriveSyncStatusSummary(params.summary),
+                metadata: {
+                    root_path: params.driveRoot,
+                    runtime_id: this.params.config.runtimeId,
+                    host_id: this.params.config.hostId,
+                    agent_id: this.params.config.agentId,
+                    watcher_status: params.schedulerStatus?.watchStatus ?? null,
+                    watcher_degraded: params.schedulerStatus
+                        ? params.schedulerStatus.watchStatus !== 'active'
+                        : null,
+                    watcher_error: truncateDriveSyncStatusError(params.schedulerStatus?.watchError ?? null),
+                    unresolved_conflict_count: unresolvedConflictSummary.unresolvedConflictCount,
+                    unresolved_conflicts: unresolvedConflictSummary.unresolvedConflictSamples,
+                },
+            });
+        }
+        catch (error) {
+            console.warn(`${MANAGED_GATEWAY_LOG_PREFIX} failed to report drive sync status`, {
+                driveId: params.driveId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    async parkStaleDrives(accessibleDriveIds) {
+        const knownDrives = this.params.stateStore.listDrives?.() ?? [];
+        for (const knownDrive of knownDrives) {
+            if (accessibleDriveIds.has(knownDrive.id)) {
+                continue;
+            }
+            const parkedPath = await parkStaleDriveLocalFolder(this.params.config.driveSync.rootDir, knownDrive.id);
+            this.params.stateStore.removeDrive?.(knownDrive.id);
+            console.warn(`${MANAGED_GATEWAY_LOG_PREFIX} parked stale drive folder`, {
+                driveId: knownDrive.id,
+                parkedPath,
+            });
+        }
+    }
+    async ensureSyncClient() {
+        const clientKey = this.params.config.driveSync.clientKey ??
+            this.params.stateStore.getOrCreateClientKey?.(`managed:${this.params.config.hostId}:${this.params.config.agentId}`) ??
+            `managed:${this.params.config.hostId}:${this.params.config.agentId}`;
+        const response = await this.params.api.registerClient({
+            agent_id: this.params.config.agentId,
+            host_id: this.params.config.hostId,
+            client_key: clientKey,
+            display_name: `${hostname()} managed drive sync`,
+            metadata: {
+                mode: 'managed_gateway_pull',
+                runtime_id: this.params.config.runtimeId,
+                process_id: process.pid,
+            },
+        });
+        this.params.stateStore.setSyncClient(response.sync_client);
+        return response.sync_client;
+    }
+    async syncDrive(params) {
+        let appliedBatchCount = 0;
+        let appliedPathCount = 0;
+        let remoteConflictCount = 0;
+        let lastAckedSequence = 0;
+        while (appliedBatchCount < this.params.config.driveSync.maxBatchesPerTick) {
+            const remainingBatchCapacity = this.params.config.driveSync.maxBatchesPerTick - appliedBatchCount;
+            const response = await this.params.api.getChanges({
+                sync_client_id: params.syncClientId,
+                drive_id: params.driveId,
+                limit: Math.min(this.params.config.driveSync.changeLimit, remainingBatchCapacity),
+            });
+            lastAckedSequence = response.cursor.last_batch_sequence;
+            if (response.changes.length === 0) {
+                this.params.stateStore.setCursor(params.driveId, lastAckedSequence);
+                break;
+            }
+            for (const batch of response.changes) {
+                try {
+                    const result = await applyDriveChangeBatchToLocalFilesystem({
+                        syncClientId: params.syncClientId,
+                        driveRoot: params.driveRoot,
+                        batch,
+                        api: this.params.api,
+                        stateStore: this.params.stateStore,
+                    });
+                    const remoteConflicts = collectRemoteConflictsForAck({
+                        driveId: params.driveId,
+                        batch,
+                        newConflicts: result.remoteConflicts,
+                        stateStore: this.params.stateStore,
+                    });
+                    const ackResponse = await this.params.api.ackChanges({
+                        sync_client_id: params.syncClientId,
+                        drive_id: params.driveId,
+                        operation_id: remoteConflicts.length > 0
+                            ? buildRemoteConflictAckOperationId({
+                                driveId: params.driveId,
+                                batch,
+                                conflicts: remoteConflicts,
+                            })
+                            : undefined,
+                        last_batch_sequence: batch.sequence,
+                        last_error: null,
+                        remote_conflicts: remoteConflicts.length > 0
+                            ? remoteConflicts.map(toRemoteConflictAckPayload)
+                            : undefined,
+                    });
+                    applyRemoteConflictAckResults({
+                        driveId: params.driveId,
+                        stateStore: this.params.stateStore,
+                        results: ackResponse.remote_conflicts,
+                    });
+                    lastAckedSequence = ackResponse.cursor.last_batch_sequence;
+                    this.params.stateStore.setCursor(params.driveId, lastAckedSequence);
+                    appliedBatchCount += 1;
+                    appliedPathCount += result.appliedPathCount;
+                    remoteConflictCount += result.remoteConflictCount;
+                }
+                catch (error) {
+                    await this.params.api.ackChanges({
+                        sync_client_id: params.syncClientId,
+                        drive_id: params.driveId,
+                        last_batch_sequence: lastAckedSequence,
+                        last_error: error instanceof Error ? error.message : String(error),
+                    });
+                    throw error;
+                }
+            }
+            if (!response.has_more) {
+                break;
+            }
+        }
+        return {
+            appliedBatchCount,
+            appliedPathCount,
+            remoteConflictCount,
+            lastBatchSequence: lastAckedSequence,
+        };
+    }
+}
+async function invokeDriveSyncFunction(supabase, functionName, body, timeoutMs) {
+    const { data, error } = await withTimeout(supabase.functions.invoke(functionName, { body }), timeoutMs, `${functionName} invocation`);
+    if (error) {
+        throw new Error(`${functionName} failed: ${await formatSupabaseFunctionError(error)}`);
+    }
+    if (!data?.success) {
+        throw new Error(`${functionName} returned an invalid response`);
+    }
+    return data;
+}
+async function withTimeout(promise, timeoutMs, label) {
+    let timer = null;
+    const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => {
+            reject(new Error(`${label} timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        timer.unref?.();
+    });
+    try {
+        return await Promise.race([promise, timeout]);
+    }
+    finally {
+        if (timer) {
+            clearTimeout(timer);
+        }
+    }
+}
+async function formatSupabaseFunctionError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const context = isRecord(error) ? error.context : null;
+    if (!(context instanceof Response)) {
+        return message;
+    }
+    const responseBody = await context.text().catch(() => null);
+    const bodySuffix = responseBody && responseBody.trim().length > 0
+        ? ` body=${responseBody.trim().slice(0, 1000)}`
+        : '';
+    return `${message} (status=${context.status}${bodySuffix})`;
+}
+function sha256Hex(bytes) {
+    return createHash('sha256').update(bytes).digest('hex');
+}
+function stableJsonStringify(input) {
+    if (input === undefined) {
+        return 'null';
+    }
+    if (input === null || typeof input !== 'object') {
+        return JSON.stringify(input);
+    }
+    if (Array.isArray(input)) {
+        return `[${input.map((value) => stableJsonStringify(value)).join(',')}]`;
+    }
+    const record = input;
+    return `{${Object.keys(record)
+        .filter((key) => record[key] !== undefined)
+        .sort()
+        .map((key) => `${JSON.stringify(key)}:${stableJsonStringify(record[key])}`)
+        .join(',')}}`;
+}
+export function logDriveSyncRunSummary(summary) {
+    if (summary.driveCount === 0 ||
+        (summary.appliedBatchCount === 0 &&
+            summary.uploadedBatchCount === 0 &&
+            summary.remoteConflictCount === 0 &&
+            summary.deferredFileCount === 0 &&
+            summary.failedDriveCount === 0)) {
+        return;
+    }
+    console.log(`${MANAGED_GATEWAY_LOG_PREFIX} applied drive sync changes`, {
+        driveCount: summary.driveCount,
+        failedDriveCount: summary.failedDriveCount,
+        appliedBatchCount: summary.appliedBatchCount,
+        appliedPathCount: summary.appliedPathCount,
+        remoteConflictCount: summary.remoteConflictCount,
+        uploadedBatchCount: summary.uploadedBatchCount,
+        uploadedChangeCount: summary.uploadedChangeCount,
+        uploadedAppliedCount: summary.uploadedAppliedCount,
+        uploadedConflictCount: summary.uploadedConflictCount,
+        uploadedUnsupportedCount: summary.uploadedUnsupportedCount,
+        uploadedRejectedCount: summary.uploadedRejectedCount,
+        deferredFileCount: summary.deferredFileCount,
+    });
+}
+//# sourceMappingURL=drive-sync.js.map