@thxgg/steward 0.1.23 → 0.1.25

package/dist/server/utils/db.js

@@ -34,6 +34,47 @@ function resolveDbPath() {
     }
     return DEFAULT_DB_PATH;
 }
+function getTableColumnNames(adapter, tableName) {
+    const rows = adapter.all(`PRAGMA table_info(${tableName})`);
+    const names = new Set();
+    for (const row of rows) {
+        if (typeof row.name === 'string' && row.name.length > 0) {
+            names.add(row.name);
+        }
+    }
+    return names;
+}
+function ensurePrdStateFieldClockColumns(adapter) {
+    const columnNames = getTableColumnNames(adapter, 'prd_states');
+    const requiredColumns = ['tasks_updated_at', 'progress_updated_at', 'notes_updated_at'];
+    for (const columnName of requiredColumns) {
+        if (columnNames.has(columnName)) {
+            continue;
+        }
+        adapter.exec(`ALTER TABLE prd_states ADD COLUMN ${columnName} TEXT;`);
+        columnNames.add(columnName);
+    }
+}
+function backfillPrdStateFieldClocks(adapter) {
+    adapter.run(`
+      UPDATE prd_states
+      SET tasks_updated_at = updated_at
+      WHERE tasks_updated_at IS NULL
+        AND tasks_json IS NOT NULL
+    `);
+    adapter.run(`
+      UPDATE prd_states
+      SET progress_updated_at = updated_at
+      WHERE progress_updated_at IS NULL
+        AND progress_json IS NOT NULL
+    `);
+    adapter.run(`
+      UPDATE prd_states
+      SET notes_updated_at = updated_at
+      WHERE notes_updated_at IS NULL
+        AND notes_md IS NOT NULL
+    `);
+}
 function formatNodeRuntimeHint() {
     const nodeOptions = process.env.NODE_OPTIONS || '';
     const hasDisableFlag = process.execArgv.includes(SQLITE_DISABLE_FLAG)
@@ -177,6 +218,9 @@ async function initializeDatabase() {
       tasks_json TEXT,
       progress_json TEXT,
       notes_md TEXT,
+      tasks_updated_at TEXT,
+      progress_updated_at TEXT,
+      notes_updated_at TEXT,
       updated_at TEXT NOT NULL,
       PRIMARY KEY (repo_id, slug),
       FOREIGN KEY (repo_id) REFERENCES repos(id) ON DELETE CASCADE
@@ -196,9 +240,29 @@ async function initializeDatabase() {
       updated_at TEXT NOT NULL
     );
 
+    CREATE TABLE IF NOT EXISTS repo_sync_meta (
+      repo_id TEXT PRIMARY KEY,
+      sync_key TEXT NOT NULL UNIQUE,
+      fingerprint TEXT,
+      fingerprint_kind TEXT,
+      updated_at TEXT NOT NULL,
+      FOREIGN KEY (repo_id) REFERENCES repos(id) ON DELETE CASCADE
+    );
+
+    CREATE TABLE IF NOT EXISTS sync_bundle_log (
+      bundle_id TEXT PRIMARY KEY,
+      source_device_id TEXT,
+      applied_at TEXT NOT NULL,
+      summary_json TEXT NOT NULL
+    );
+
     CREATE INDEX IF NOT EXISTS idx_prd_states_repo_id ON prd_states(repo_id);
     CREATE INDEX IF NOT EXISTS idx_prd_archives_repo_id ON prd_archives(repo_id);
+    CREATE INDEX IF NOT EXISTS idx_repo_sync_meta_sync_key ON repo_sync_meta(sync_key);
+    CREATE INDEX IF NOT EXISTS idx_sync_bundle_log_applied_at ON sync_bundle_log(applied_at);
   `);
+    ensurePrdStateFieldClockColumns(adapter);
+    backfillPrdStateFieldClocks(adapter);
     return adapter;
 }
 async function getAdapter() {

package/dist/server/utils/prd-state.js

@@ -92,13 +92,29 @@ export async function upsertPrdState(repoId, slug, update) {
         ? null
         : update.notes;
     const updatedAt = new Date().toISOString();
+    const tasksUpdatedAt = updateTasks ? updatedAt : null;
+    const progressUpdatedAt = updateProgress ? updatedAt : null;
+    const notesUpdatedAt = updateNotes ? updatedAt : null;
     await dbRun(`
-      INSERT INTO prd_states (repo_id, slug, tasks_json, progress_json, notes_md, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?)
+      INSERT INTO prd_states (
+        repo_id,
+        slug,
+        tasks_json,
+        progress_json,
+        notes_md,
+        tasks_updated_at,
+        progress_updated_at,
+        notes_updated_at,
+        updated_at
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT(repo_id, slug) DO UPDATE SET
         tasks_json = CASE WHEN ? THEN excluded.tasks_json ELSE prd_states.tasks_json END,
         progress_json = CASE WHEN ? THEN excluded.progress_json ELSE prd_states.progress_json END,
         notes_md = CASE WHEN ? THEN excluded.notes_md ELSE prd_states.notes_md END,
+        tasks_updated_at = CASE WHEN ? THEN excluded.tasks_updated_at ELSE prd_states.tasks_updated_at END,
+        progress_updated_at = CASE WHEN ? THEN excluded.progress_updated_at ELSE prd_states.progress_updated_at END,
+        notes_updated_at = CASE WHEN ? THEN excluded.notes_updated_at ELSE prd_states.notes_updated_at END,
         updated_at = excluded.updated_at
     `, [
         repoId,
@@ -106,9 +122,15 @@ export async function upsertPrdState(repoId, slug, update) {
         tasksJson,
         progressJson,
         notesMd,
+        tasksUpdatedAt,
+        progressUpdatedAt,
+        notesUpdatedAt,
         updatedAt,
         updateTasks ? 1 : 0,
         updateProgress ? 1 : 0,
+        updateNotes ? 1 : 0,
+        updateTasks ? 1 : 0,
+        updateProgress ? 1 : 0,
         updateNotes ? 1 : 0
     ]);
     if (validatedTasks !== undefined) {

package/dist/server/utils/repos.js

@@ -3,6 +3,7 @@ import { join, basename, dirname, resolve, relative, isAbsolute } from 'node:pat
 import { randomUUID } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 import { dbAll, dbGet, dbRun } from './db.js';
+import { ensureRepoSyncMetaForRepo, ensureRepoSyncMetaForRepos } from './sync-identity.js';
 function findPackageRoot(startDir) {
     let currentDir = startDir;
     while (true) {
@@ -136,7 +137,9 @@ async function importLegacyReposIfNeeded() {
 export async function getRepos() {
     await importLegacyReposIfNeeded();
     const rows = await dbAll('SELECT id, name, path, added_at, git_repos_json FROM repos ORDER BY added_at ASC');
-    return rows.map(rowToRepo);
+    const repos = rows.map(rowToRepo);
+    await ensureRepoSyncMetaForRepos(repos);
+    return repos;
 }
 export async function saveRepos(repos) {
     await importLegacyReposIfNeeded();
@@ -158,6 +161,7 @@ export async function saveRepos(repos) {
     const repoIds = repos.map(repo => repo.id);
     const placeholders = repoIds.map(() => '?').join(', ');
     await dbRun(`DELETE FROM repos WHERE id NOT IN (${placeholders})`, repoIds);
+    await ensureRepoSyncMetaForRepos(repos);
 }
 export async function addRepo(path, name) {
     await importLegacyReposIfNeeded();
@@ -175,6 +179,7 @@ export async function addRepo(path, name) {
         ...(gitRepos.length > 0 && { gitRepos })
     };
     await dbRun('INSERT INTO repos (id, name, path, added_at, git_repos_json) VALUES (?, ?, ?, ?, ?)', [repo.id, repo.name, repo.path, repo.addedAt, serializeGitRepos(repo.gitRepos)]);
+    await ensureRepoSyncMetaForRepo(repo);
     return repo;
 }
 /**
@@ -183,7 +188,12 @@ export async function addRepo(path, name) {
 export async function getRepoById(id) {
     await importLegacyReposIfNeeded();
     const row = await dbGet('SELECT id, name, path, added_at, git_repos_json FROM repos WHERE id = ?', [id]);
-    return row ? rowToRepo(row) : undefined;
+    if (!row) {
+        return undefined;
+    }
+    const repo = rowToRepo(row);
+    await ensureRepoSyncMetaForRepo(repo);
+    return repo;
 }
 export async function updateRepoGitRepos(id, gitRepos) {
     await importLegacyReposIfNeeded();

package/dist/server/utils/state-migration.js

@@ -209,9 +209,9 @@ async function migrateProgressRows() {
                 const updatedAt = nowIso();
                 await dbRun(`
             UPDATE prd_states
-            SET progress_json = ?, updated_at = ?
+            SET progress_json = ?, progress_updated_at = ?, updated_at = ?
             WHERE repo_id = ? AND slug = ?
-          `, [JSON.stringify(normalized), updatedAt, row.repo_id, row.slug]);
+          `, [JSON.stringify(normalized), updatedAt, updatedAt, row.repo_id, row.slug]);
                 status.migratedRows += 1;
                 emitChange({
                     type: 'change',
@@ -362,7 +362,7 @@ async function migrateCommitRepoRefs() {
             const updatedAt = nowIso();
             await dbRun(`
           UPDATE prd_states
-          SET progress_json = ?, updated_at = ?
+          SET progress_json = ?, progress_updated_at = ?, updated_at = ?
           WHERE repo_id = ? AND slug = ?
         `, [
                 JSON.stringify({
@@ -370,6 +370,7 @@ async function migrateCommitRepoRefs() {
                     taskLogs: normalized.taskLogs
                 }),
                 updatedAt,
+                updatedAt,
                 row.repo_id,
                 row.slug
             ]);

package/dist/server/utils/sync-apply.js

@@ -0,0 +1,380 @@
+import { randomUUID } from 'node:crypto';
+import { promises as fs } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+import { dbExec, dbGet, dbRun, getDbPath } from './db.js';
+import { planSyncMerge } from './sync-merge.js';
+import { parseSyncBundle } from './sync-schema.js';
+const DEFAULT_BACKUP_RETENTION_DAYS = 30;
+const DEFAULT_MAX_BACKUPS = 20;
+const DEFAULT_LOG_RETENTION_DAYS = 180;
+const DEFAULT_MAX_LOG_ENTRIES = 10_000;
+function sanitizeRetentionNumber(value, fallback, min) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        return fallback;
+    }
+    return Math.max(min, Math.floor(value));
+}
+function resolveRetentionPolicy(options) {
+    return {
+        backupRetentionDays: sanitizeRetentionNumber(options.backupRetentionDays, DEFAULT_BACKUP_RETENTION_DAYS, 0),
+        maxBackups: sanitizeRetentionNumber(options.maxBackups, DEFAULT_MAX_BACKUPS, 1),
+        logRetentionDays: sanitizeRetentionNumber(options.logRetentionDays, DEFAULT_LOG_RETENTION_DAYS, 0),
+        maxLogEntries: sanitizeRetentionNumber(options.maxLogEntries, DEFAULT_MAX_LOG_ENTRIES, 1)
+    };
+}
+function toStateKey(repoSyncKey, slug) {
+    return `${repoSyncKey}:${slug}`;
+}
+function serializeJson(value) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    return JSON.stringify(value);
+}
+function parseIsoOrNow(value) {
+    if (typeof value === 'string' && value.trim().length > 0 && Number.isFinite(Date.parse(value))) {
+        return new Date(value).toISOString();
+    }
+    return new Date().toISOString();
+}
+function escapeSqliteString(value) {
+    return value.replaceAll("'", "''");
+}
+function toBackupFileTimestamp(nowIso) {
+    return nowIso
+        .replaceAll('-', '')
+        .replaceAll(':', '')
+        .replaceAll('.', '');
+}
+function toSafeFileSegment(value) {
+    const sanitized = value.replace(/[^A-Za-z0-9._-]/g, '_');
+    return sanitized.length > 0 ? sanitized : 'bundle';
+}
+function getBackupFilePrefix(dbPath) {
+    return `${basename(dbPath)}.sync-backup.`;
+}
+async function createDatabaseBackup(bundleId, nowIso) {
+    const dbPath = getDbPath();
+    const backupDir = dirname(dbPath);
+    const filePrefix = getBackupFilePrefix(dbPath);
+    const fileName = `${filePrefix}${toBackupFileTimestamp(nowIso)}-${toSafeFileSegment(bundleId)}-${randomUUID().slice(0, 8)}.db`;
+    const backupPath = join(backupDir, fileName);
+    await fs.mkdir(backupDir, { recursive: true });
+    await dbExec(`VACUUM INTO '${escapeSqliteString(backupPath)}';`);
+    return backupPath;
+}
+async function pruneDatabaseBackups(nowIso, policy) {
+    const dbPath = getDbPath();
+    const backupDir = dirname(dbPath);
+    const filePrefix = getBackupFilePrefix(dbPath);
+    const cutoffMs = Date.parse(nowIso) - (policy.backupRetentionDays * 24 * 60 * 60 * 1000);
+    let entries = [];
+    try {
+        const dirEntries = await fs.readdir(backupDir, { withFileTypes: true });
+        const candidateFiles = dirEntries
+            .filter((entry) => entry.isFile())
+            .map((entry) => entry.name)
+            .filter((name) => name.startsWith(filePrefix) && name.endsWith('.db'));
+        entries = await Promise.all(candidateFiles.map(async (name) => {
+            const filePath = join(backupDir, name);
+            const stat = await fs.stat(filePath);
+            return {
+                path: filePath,
+                mtimeMs: stat.mtimeMs
+            };
+        }));
+    }
+    catch {
+        return 0;
+    }
+    entries.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    let deleted = 0;
+    for (let index = 0; index < entries.length; index += 1) {
+        const entry = entries[index];
+        const tooOld = Number.isFinite(cutoffMs) ? entry.mtimeMs < cutoffMs : false;
+        const overLimit = index >= policy.maxBackups;
+        if (!tooOld && !overLimit) {
+            continue;
+        }
+        try {
+            await fs.unlink(entry.path);
+            deleted += 1;
+        }
+        catch {
+            // Ignore retention cleanup errors; merge apply already succeeded.
+        }
+    }
+    return deleted;
+}
+async function pruneSyncLog(nowIso, policy) {
+    const cutoffIso = new Date(Date.parse(nowIso) - (policy.logRetentionDays * 24 * 60 * 60 * 1000)).toISOString();
+    let deleted = 0;
+    const deleteOlder = await dbRun('DELETE FROM sync_bundle_log WHERE applied_at < ?', [cutoffIso]);
+    deleted += deleteOlder.changes;
+    const countRow = await dbGet('SELECT COUNT(*) as count FROM sync_bundle_log');
+    const currentCount = countRow?.count ?? 0;
+    if (currentCount <= policy.maxLogEntries) {
+        return deleted;
+    }
+    const toDeleteCount = currentCount - policy.maxLogEntries;
+    if (toDeleteCount <= 0) {
+        return deleted;
+    }
+    const deleteOverflow = await dbRun(`
+      DELETE FROM sync_bundle_log
+      WHERE bundle_id IN (
+        SELECT bundle_id
+        FROM sync_bundle_log
+        ORDER BY applied_at ASC, bundle_id ASC
+        LIMIT ?
+      )
+    `, [toDeleteCount]);
+    deleted += deleteOverflow.changes;
+    return deleted;
+}
+function assertNoUnresolvedMappings(plan) {
+    const unresolvedMappings = plan.mappings.filter((mapping) => mapping.source === 'unresolved');
+    if (unresolvedMappings.length === 0) {
+        return;
+    }
+    const unresolvedKeys = unresolvedMappings.map((mapping) => mapping.incomingRepoSyncKey).join(', ');
+    throw new Error(`Cannot apply bundle with unresolved repositories: ${unresolvedKeys}`);
+}
+async function applyStateInsert(planRow, incomingRow, appliedAt) {
+    if (!planRow.localRepoId) {
+        throw new Error(`Missing local repository mapping for ${planRow.repoSyncKey}`);
+    }
+    await dbRun(`
+      INSERT INTO prd_states (
+        repo_id,
+        slug,
+        tasks_json,
+        progress_json,
+        notes_md,
+        tasks_updated_at,
+        progress_updated_at,
+        notes_updated_at,
+        updated_at
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(repo_id, slug) DO UPDATE SET
+        tasks_json = excluded.tasks_json,
+        progress_json = excluded.progress_json,
+        notes_md = excluded.notes_md,
+        tasks_updated_at = excluded.tasks_updated_at,
+        progress_updated_at = excluded.progress_updated_at,
+        notes_updated_at = excluded.notes_updated_at,
+        updated_at = excluded.updated_at
+    `, [
+        planRow.localRepoId,
+        incomingRow.slug,
+        serializeJson(incomingRow.tasks),
+        serializeJson(incomingRow.progress),
+        incomingRow.notes,
+        incomingRow.clocks.tasksUpdatedAt,
+        incomingRow.clocks.progressUpdatedAt,
+        incomingRow.clocks.notesUpdatedAt,
+        appliedAt
+    ]);
+}
+async function applyStateUpdate(planRow, incomingRow, appliedAt) {
+    if (!planRow.localRepoId) {
+        throw new Error(`Missing local repository mapping for ${planRow.repoSyncKey}`);
+    }
+    const updateTasks = planRow.updateFields.includes('tasks');
+    const updateProgress = planRow.updateFields.includes('progress');
+    const updateNotes = planRow.updateFields.includes('notes');
+    const anyUpdate = updateTasks || updateProgress || updateNotes;
+    if (!anyUpdate) {
+        return;
+    }
+    const result = await dbRun(`
+      UPDATE prd_states
+      SET
+        tasks_json = CASE WHEN ? THEN ? ELSE tasks_json END,
+        progress_json = CASE WHEN ? THEN ? ELSE progress_json END,
+        notes_md = CASE WHEN ? THEN ? ELSE notes_md END,
+        tasks_updated_at = CASE WHEN ? THEN ? ELSE tasks_updated_at END,
+        progress_updated_at = CASE WHEN ? THEN ? ELSE progress_updated_at END,
+        notes_updated_at = CASE WHEN ? THEN ? ELSE notes_updated_at END,
+        updated_at = CASE WHEN ? THEN ? ELSE updated_at END
+      WHERE repo_id = ? AND slug = ?
+    `, [
+        updateTasks ? 1 : 0,
+        serializeJson(incomingRow.tasks),
+        updateProgress ? 1 : 0,
+        serializeJson(incomingRow.progress),
+        updateNotes ? 1 : 0,
+        incomingRow.notes,
+        updateTasks ? 1 : 0,
+        incomingRow.clocks.tasksUpdatedAt,
+        updateProgress ? 1 : 0,
+        incomingRow.clocks.progressUpdatedAt,
+        updateNotes ? 1 : 0,
+        incomingRow.clocks.notesUpdatedAt,
+        anyUpdate ? 1 : 0,
+        appliedAt,
+        planRow.localRepoId,
+        incomingRow.slug
+    ]);
+    if (result.changes > 0) {
+        return;
+    }
+    await applyStateInsert(planRow, incomingRow, appliedAt);
+}
+async function applyArchiveAction(planRow, incomingRow) {
+    if (!planRow.localRepoId) {
+        throw new Error(`Missing local repository mapping for ${planRow.repoSyncKey}`);
+    }
+    if (planRow.action === 'insert') {
+        await dbRun(`
+        INSERT INTO prd_archives (repo_id, slug, archived_at)
+        VALUES (?, ?, ?)
+        ON CONFLICT(repo_id, slug) DO UPDATE SET
+          archived_at = CASE
+            WHEN excluded.archived_at > prd_archives.archived_at THEN excluded.archived_at
+            ELSE prd_archives.archived_at
+          END
+      `, [planRow.localRepoId, incomingRow.slug, incomingRow.archivedAt]);
+        return;
+    }
+    if (planRow.action === 'update') {
+        await dbRun(`
+        UPDATE prd_archives
+        SET archived_at = ?
+        WHERE repo_id = ? AND slug = ? AND archived_at < ?
+      `, [incomingRow.archivedAt, planRow.localRepoId, incomingRow.slug, incomingRow.archivedAt]);
+    }
+}
+async function assertIntegrityCheckPasses() {
+    const row = await dbGet('PRAGMA integrity_check');
+    if (!row) {
+        throw new Error('SQLite integrity check returned no results');
+    }
+    const firstValue = Object.values(row)[0];
+    if (firstValue !== 'ok') {
+        throw new Error(`SQLite integrity check failed: ${String(firstValue)}`);
+    }
+}
+async function hasBundleBeenApplied(bundleId) {
+    return await dbGet('SELECT bundle_id, applied_at FROM sync_bundle_log WHERE bundle_id = ?', [bundleId]);
+}
+export async function executeSyncMerge(bundleInput, options = {}) {
+    const bundle = parseSyncBundle(bundleInput);
+    const nowIso = parseIsoOrNow(options.now);
+    const retentionPolicy = resolveRetentionPolicy(options);
+    const plan = await planSyncMerge(bundle, {
+        repoMap: options.repoMap
+    });
+    if (options.apply !== true) {
+        return {
+            mode: 'dry_run',
+            applied: false,
+            alreadyApplied: false,
+            bundleId: bundle.bundleId,
+            plan,
+            retention: {
+                backupsDeleted: 0,
+                logsDeleted: 0
+            }
+        };
+    }
+    const existingLog = await hasBundleBeenApplied(bundle.bundleId);
+    if (existingLog) {
+        return {
+            mode: 'apply',
+            applied: false,
+            alreadyApplied: true,
+            bundleId: bundle.bundleId,
+            plan,
+            retention: {
+                backupsDeleted: 0,
+                logsDeleted: 0
+            }
+        };
+    }
+    assertNoUnresolvedMappings(plan);
+    const backupPath = await createDatabaseBackup(bundle.bundleId, nowIso);
+    const incomingStateByKey = new Map();
+    const incomingArchiveByKey = new Map();
+    for (const row of bundle.states) {
+        incomingStateByKey.set(toStateKey(row.repoSyncKey, row.slug), row);
+    }
+    for (const row of bundle.archives) {
+        incomingArchiveByKey.set(toStateKey(row.repoSyncKey, row.slug), row);
+    }
+    let logsDeleted = 0;
+    let inTransaction = false;
+    try {
+        await dbExec('BEGIN IMMEDIATE');
+        inTransaction = true;
+        for (const planRow of plan.states) {
+            if (planRow.action === 'skip' || planRow.action === 'unresolved') {
+                continue;
+            }
+            const incoming = incomingStateByKey.get(toStateKey(planRow.repoSyncKey, planRow.slug));
+            if (!incoming) {
+                throw new Error(`Missing incoming state row for ${planRow.repoSyncKey}:${planRow.slug}`);
+            }
+            if (planRow.action === 'insert') {
+                await applyStateInsert(planRow, incoming, nowIso);
+            }
+            else {
+                await applyStateUpdate(planRow, incoming, nowIso);
+            }
+        }
+        for (const planRow of plan.archives) {
+            if (planRow.action === 'skip' || planRow.action === 'unresolved') {
+                continue;
+            }
+            const incoming = incomingArchiveByKey.get(toStateKey(planRow.repoSyncKey, planRow.slug));
+            if (!incoming) {
+                throw new Error(`Missing incoming archive row for ${planRow.repoSyncKey}:${planRow.slug}`);
+            }
+            await applyArchiveAction(planRow, incoming);
+        }
+        await assertIntegrityCheckPasses();
+        await dbRun(`
+        INSERT INTO sync_bundle_log (bundle_id, source_device_id, applied_at, summary_json)
+        VALUES (?, ?, ?, ?)
+      `, [bundle.bundleId, bundle.sourceDeviceId, nowIso, JSON.stringify(plan.summary)]);
+        logsDeleted = await pruneSyncLog(nowIso, retentionPolicy);
+        await dbExec('COMMIT');
+        inTransaction = false;
+    }
+    catch (error) {
+        if (inTransaction) {
+            try {
+                await dbExec('ROLLBACK');
+            }
+            catch {
+                // Ignore rollback failure; original error is surfaced.
+            }
+        }
+        throw error;
+    }
+    const backupsDeleted = await pruneDatabaseBackups(nowIso, retentionPolicy);
+    return {
+        mode: 'apply',
+        applied: true,
+        alreadyApplied: false,
+        bundleId: bundle.bundleId,
+        plan,
+        backupPath,
+        retention: {
+            backupsDeleted,
+            logsDeleted
+        }
+    };
+}
+export async function executeSyncMergeJson(jsonPayload, options = {}) {
+    let parsed;
+    try {
+        parsed = JSON.parse(jsonPayload);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Invalid bundle JSON: ${message}`);
+    }
+    return await executeSyncMerge(parsed, options);
+}