@hasna/cloud 0.1.2 → 0.1.4

package/dist/index.js

@@ -155,7 +155,7 @@ var require_arrayParser = __commonJS((exports, module) => {
   };
 });
 
-// node_modules/postgres-date/index.js
+// node_modules/pg-types/node_modules/postgres-date/index.js
 var require_postgres_date = __commonJS((exports, module) => {
   var DATE_TIME = /(\d{1,})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})(\.\d{1,})?.*?( BC)?$/;
   var DATE = /^(\d{1,})-(\d{2})-(\d{2})( BC)?$/;
@@ -257,7 +257,7 @@ var require_mutable = __commonJS((exports, module) => {
   }
 });
 
-// node_modules/postgres-interval/index.js
+// node_modules/pg-types/node_modules/postgres-interval/index.js
 var require_postgres_interval = __commonJS((exports, module) => {
   var extend = require_mutable();
   module.exports = PostgresInterval;
@@ -349,7 +349,7 @@ var require_postgres_interval = __commonJS((exports, module) => {
   }
 });
 
-// node_modules/postgres-bytea/index.js
+// node_modules/pg-types/node_modules/postgres-bytea/index.js
 var require_postgres_bytea = __commonJS((exports, module) => {
   var bufferFrom = Buffer.from || Buffer;
   module.exports = function parseBytea(input) {
@@ -9309,17 +9309,88 @@ function createDatabase(options) {
   return new SqliteAdapter(dbPath);
 }
 // src/sync.ts
-function syncPush(local, cloud, options) {
-  return syncTransfer(local, cloud, options, "push");
+async function syncPush(local, remote, options) {
+  const orderedTables = await getTableOrder(remote, options.tables);
+  return syncTransfer(local, remote, { ...options, tables: orderedTables }, "push");
 }
-function syncPull(local, cloud, options) {
-  return syncTransfer(cloud, local, options, "pull");
+async function syncPull(remote, local, options) {
+  const orderedTables = await getTableOrder(remote, options.tables);
+  return syncTransfer(remote, local, { ...options, tables: orderedTables }, "pull");
 }
-function syncTransfer(source, target, options, _direction) {
+async function getTableOrder(remote, tables) {
+  if (tables.length <= 1)
+    return tables;
+  try {
+    const fks = await remote.all(`
+      SELECT DISTINCT
+        tc.table_name AS source_table,
+        ccu.table_name AS referenced_table
+      FROM information_schema.table_constraints tc
+      JOIN information_schema.constraint_column_usage ccu
+        ON tc.constraint_name = ccu.constraint_name
+        AND tc.table_schema = ccu.table_schema
+      WHERE tc.constraint_type = 'FOREIGN KEY'
+        AND tc.table_schema = 'public'
+    `);
+    if (fks.length > 0) {
+      return topoSort(tables, fks);
+    }
+  } catch {}
+  return heuristicOrder(tables);
+}
+function topoSort(tables, fks) {
+  const tableSet = new Set(tables);
+  const deps = new Map;
+  for (const t of tables) {
+    deps.set(t, new Set);
+  }
+  for (const fk of fks) {
+    if (tableSet.has(fk.source_table) && tableSet.has(fk.referenced_table)) {
+      deps.get(fk.source_table).add(fk.referenced_table);
+    }
+  }
+  const sorted = [];
+  const visited = new Set;
+  const visiting = new Set;
+  function visit(table) {
+    if (visited.has(table))
+      return;
+    if (visiting.has(table)) {
+      sorted.push(table);
+      visited.add(table);
+      return;
+    }
+    visiting.add(table);
+    const tableDeps = deps.get(table) ?? new Set;
+    for (const dep of tableDeps) {
+      visit(dep);
+    }
+    visiting.delete(table);
+    visited.add(table);
+    sorted.push(table);
+  }
+  for (const t of tables) {
+    visit(t);
+  }
+  return sorted;
+}
+function heuristicOrder(tables) {
+  const sorted = [...tables].sort((a, b) => {
+    const aIsChild = a.includes("_") && tables.some((t) => a.startsWith(t + "_") || a.endsWith("_" + t));
+    const bIsChild = b.includes("_") && tables.some((t) => b.startsWith(t + "_") || b.endsWith("_" + t));
+    if (aIsChild && !bIsChild)
+      return 1;
+    if (!aIsChild && bIsChild)
+      return -1;
+    return a.localeCompare(b);
+  });
+  return sorted;
+}
+async function syncTransfer(source, target, options, _direction) {
   const {
     tables,
     onProgress,
-    batchSize = 500,
+    batchSize = 100,
     conflictColumn = "updated_at",
     primaryKey = "id"
   } = options;
@@ -9342,7 +9413,7 @@ function syncTransfer(source, target, options, _direction) {
         totalTables: tables.length,
         currentTableIndex: i
       });
-      const rows = source.all(`SELECT * FROM "${table}"`);
+      const rows = await readAll(source, `SELECT * FROM "${table}"`);
       result.rowsRead = rows.length;
       if (rows.length === 0) {
         onProgress?.({
@@ -9357,7 +9428,6 @@ function syncTransfer(source, target, options, _direction) {
         continue;
       }
       const columns = Object.keys(rows[0]);
-      const hasConflictCol = columns.includes(conflictColumn);
       const hasPrimaryKey = columns.includes(primaryKey);
       if (!hasPrimaryKey) {
         result.errors.push(`Table "${table}" has no "${primaryKey}" column — skipping`);
@@ -9372,34 +9442,18 @@ function syncTransfer(source, target, options, _direction) {
         totalTables: tables.length,
         currentTableIndex: i
       });
+      const updateCols = columns.filter((c) => c !== primaryKey);
       for (let offset = 0;offset < rows.length; offset += batchSize) {
         const batch = rows.slice(offset, offset + batchSize);
-        for (const row of batch) {
-          try {
-            const existing = target.get(`SELECT "${primaryKey}"${hasConflictCol ? `, "${conflictColumn}"` : ""} FROM "${table}" WHERE "${primaryKey}" = ?`, row[primaryKey]);
-            if (existing) {
-              if (hasConflictCol && existing[conflictColumn] && row[conflictColumn]) {
-                const existingTime = new Date(existing[conflictColumn]).getTime();
-                const incomingTime = new Date(row[conflictColumn]).getTime();
-                if (existingTime >= incomingTime) {
-                  result.rowsSkipped++;
-                  continue;
-                }
-              }
-              const setClauses = columns.filter((c) => c !== primaryKey).map((c) => `"${c}" = ?`).join(", ");
-              const values = columns.filter((c) => c !== primaryKey).map((c) => row[c]);
-              values.push(row[primaryKey]);
-              target.run(`UPDATE "${table}" SET ${setClauses} WHERE "${primaryKey}" = ?`, ...values);
-            } else {
-              const placeholders = columns.map(() => "?").join(", ");
-              const colList = columns.map((c) => `"${c}"`).join(", ");
-              const values = columns.map((c) => row[c]);
-              target.run(`INSERT INTO "${table}" (${colList}) VALUES (${placeholders})`, ...values);
-            }
-            result.rowsWritten++;
-          } catch (err) {
-            result.errors.push(`Row ${row[primaryKey]}: ${err?.message ?? String(err)}`);
+        try {
+          if (isAsyncAdapter(target)) {
+            await batchUpsertPg(target, table, columns, updateCols, primaryKey, batch);
+          } else {
+            batchUpsertSqlite(target, table, columns, updateCols, primaryKey, batch);
           }
+          result.rowsWritten += batch.length;
+        } catch (err) {
+          result.errors.push(`Batch at offset ${offset}: ${err?.message ?? String(err)}`);
         }
         onProgress?.({
           table,
@@ -9425,12 +9479,44 @@ function syncTransfer(source, target, options, _direction) {
   }
   return results;
 }
+async function batchUpsertPg(target, table, columns, updateCols, primaryKey, batch) {
+  if (batch.length === 0)
+    return;
+  const colList = columns.map((c) => `"${c}"`).join(", ");
+  const valuePlaceholders = batch.map((_, rowIdx) => {
+    const offset = rowIdx * columns.length;
+    return `(${columns.map((_2, colIdx) => `$${offset + colIdx + 1}`).join(", ")})`;
+  }).join(", ");
+  const setClause = updateCols.length > 0 ? updateCols.map((c) => `"${c}" = EXCLUDED."${c}"`).join(", ") : `"${primaryKey}" = EXCLUDED."${primaryKey}"`;
+  const sql = `INSERT INTO "${table}" (${colList}) VALUES ${valuePlaceholders}
+    ON CONFLICT ("${primaryKey}") DO UPDATE SET ${setClause}`;
+  const params = batch.flatMap((row) => columns.map((c) => row[c] ?? null));
+  await target.run(sql, ...params);
+}
+function batchUpsertSqlite(target, table, columns, updateCols, primaryKey, batch) {
+  if (batch.length === 0)
+    return;
+  const colList = columns.map((c) => `"${c}"`).join(", ");
+  const valuePlaceholders = batch.map(() => `(${columns.map(() => "?").join(", ")})`).join(", ");
+  const setClause = updateCols.length > 0 ? updateCols.map((c) => `"${c}" = EXCLUDED."${c}"`).join(", ") : `"${primaryKey}" = EXCLUDED."${primaryKey}"`;
+  const sql = `INSERT INTO "${table}" (${colList}) VALUES ${valuePlaceholders}
+    ON CONFLICT ("${primaryKey}") DO UPDATE SET ${setClause}`;
+  const params = batch.flatMap((row) => columns.map((c) => row[c] ?? null));
+  target.run(sql, ...params);
+}
+function isAsyncAdapter(adapter) {
+  return adapter.constructor.name === "PgAdapterAsync" || typeof adapter.raw?.connect === "function";
+}
+async function readAll(adapter, sql) {
+  const result = adapter.all(sql);
+  return result instanceof Promise ? await result : result;
+}
 function listSqliteTables(db) {
   const rows = db.all(`SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name`);
   return rows.map((r) => r.name);
 }
-function listPgTables(db) {
-  const rows = db.all(`SELECT tablename FROM pg_tables WHERE schemaname = 'public' ORDER BY tablename`);
+async function listPgTables(db) {
+  const rows = await db.all(`SELECT tablename FROM pg_tables WHERE schemaname = 'public' ORDER BY tablename`);
   return rows.map((r) => r.tablename);
 }
 // src/feedback.ts
@@ -9501,6 +9587,562 @@ function listFeedback(db) {
   ensureFeedbackTable(db);
   return db.all(`SELECT id, service, version, message, email, machine_id, created_at FROM feedback ORDER BY created_at DESC`);
 }
+// src/sync-progress.ts
+class SyncProgressTracker {
+  db;
+  progress = new Map;
+  startTimes = new Map;
+  callback;
+  constructor(db, callback) {
+    this.db = db;
+    this.callback = callback;
+    this.ensureResumeTable();
+  }
+  ensureResumeTable() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS _sync_resume (
+        table_name TEXT PRIMARY KEY,
+        last_row_id TEXT,
+        direction TEXT,
+        started_at TEXT,
+        status TEXT DEFAULT 'in_progress'
+      )
+    `);
+  }
+  start(table, total, direction) {
+    const resumed = this.canResume(table);
+    const now = Date.now();
+    this.startTimes.set(table, now);
+    const status = resumed ? "resumed" : "in_progress";
+    const info = {
+      table,
+      total,
+      done: 0,
+      percent: 0,
+      elapsed_ms: 0,
+      eta_ms: 0,
+      status
+    };
+    this.progress.set(table, info);
+    this.db.run(`INSERT INTO _sync_resume (table_name, last_row_id, direction, started_at, status)
+       VALUES (?, ?, ?, datetime('now'), ?)
+       ON CONFLICT (table_name) DO UPDATE SET
+         direction = excluded.direction,
+         started_at = datetime('now'),
+         status = excluded.status`, table, "", direction, status);
+    this.notify(table);
+  }
+  update(table, done, lastRowId) {
+    const info = this.progress.get(table);
+    if (!info)
+      return;
+    const startTime = this.startTimes.get(table) ?? Date.now();
+    const elapsed = Date.now() - startTime;
+    const rate = done > 0 ? elapsed / done : 0;
+    const remaining = info.total - done;
+    const eta = remaining > 0 ? Math.round(rate * remaining) : 0;
+    info.done = done;
+    info.percent = info.total > 0 ? Math.round(done / info.total * 100) : 0;
+    info.elapsed_ms = elapsed;
+    info.eta_ms = eta;
+    info.status = "in_progress";
+    this.db.run(`UPDATE _sync_resume SET last_row_id = ?, status = 'in_progress' WHERE table_name = ?`, lastRowId, table);
+    this.notify(table);
+  }
+  markComplete(table) {
+    const info = this.progress.get(table);
+    if (info) {
+      const startTime = this.startTimes.get(table) ?? Date.now();
+      info.elapsed_ms = Date.now() - startTime;
+      info.done = info.total;
+      info.percent = 100;
+      info.eta_ms = 0;
+      info.status = "completed";
+      this.notify(table);
+    }
+    this.db.run(`UPDATE _sync_resume SET status = 'completed' WHERE table_name = ?`, table);
+  }
+  markFailed(table, _error) {
+    const info = this.progress.get(table);
+    if (info) {
+      const startTime = this.startTimes.get(table) ?? Date.now();
+      info.elapsed_ms = Date.now() - startTime;
+      info.status = "failed";
+      this.notify(table);
+    }
+    this.db.run(`UPDATE _sync_resume SET status = 'failed' WHERE table_name = ?`, table);
+  }
+  canResume(table) {
+    const row = this.db.get(`SELECT status FROM _sync_resume WHERE table_name = ?`, table);
+    if (!row)
+      return false;
+    return row.status === "in_progress" || row.status === "resumed";
+  }
+  getResumePoint(table) {
+    const row = this.db.get(`SELECT table_name, last_row_id, direction, started_at, status FROM _sync_resume WHERE table_name = ?`, table);
+    if (!row)
+      return null;
+    if (row.status !== "in_progress" && row.status !== "resumed")
+      return null;
+    return row;
+  }
+  clearResume(table) {
+    this.db.run(`DELETE FROM _sync_resume WHERE table_name = ?`, table);
+    this.progress.delete(table);
+    this.startTimes.delete(table);
+  }
+  getProgress(table) {
+    return this.progress.get(table) ?? null;
+  }
+  getAllProgress() {
+    return Array.from(this.progress.values());
+  }
+  listResumeRecords() {
+    return this.db.all(`SELECT table_name, last_row_id, direction, started_at, status FROM _sync_resume ORDER BY started_at DESC`);
+  }
+  notify(table) {
+    const info = this.progress.get(table);
+    if (info && this.callback) {
+      this.callback({ ...info });
+    }
+  }
+}
+// src/sync-conflicts.ts
+function detectConflicts(local, remote, table, primaryKey = "id", conflictColumn = "updated_at") {
+  const conflicts = [];
+  const remoteMap = new Map;
+  for (const row of remote) {
+    const key = String(row[primaryKey]);
+    remoteMap.set(key, row);
+  }
+  for (const localRow of local) {
+    const key = String(localRow[primaryKey]);
+    const remoteRow = remoteMap.get(key);
+    if (!remoteRow)
+      continue;
+    const localTs = localRow[conflictColumn];
+    const remoteTs = remoteRow[conflictColumn];
+    if (localTs !== remoteTs) {
+      conflicts.push({
+        table,
+        row_id: key,
+        local_updated_at: String(localTs ?? ""),
+        remote_updated_at: String(remoteTs ?? ""),
+        local_data: { ...localRow },
+        remote_data: { ...remoteRow },
+        resolved: false
+      });
+    }
+  }
+  return conflicts;
+}
+function resolveConflicts(conflicts, strategy = "newest-wins") {
+  return conflicts.map((conflict) => {
+    const resolved = { ...conflict, resolved: true, resolution: strategy };
+    switch (strategy) {
+      case "local-wins":
+        break;
+      case "remote-wins":
+        break;
+      case "newest-wins": {
+        const localTime = new Date(conflict.local_updated_at).getTime();
+        const remoteTime = new Date(conflict.remote_updated_at).getTime();
+        if (remoteTime > localTime) {
+          resolved.resolution = "newest-wins";
+        } else {
+          resolved.resolution = "newest-wins";
+        }
+        break;
+      }
+    }
+    return resolved;
+  });
+}
+function getWinningData(conflict) {
+  if (!conflict.resolved || !conflict.resolution) {
+    throw new Error(`Conflict for row ${conflict.row_id} is not resolved`);
+  }
+  switch (conflict.resolution) {
+    case "local-wins":
+      return conflict.local_data;
+    case "remote-wins":
+      return conflict.remote_data;
+    case "newest-wins": {
+      const localTime = new Date(conflict.local_updated_at).getTime();
+      const remoteTime = new Date(conflict.remote_updated_at).getTime();
+      return remoteTime >= localTime ? conflict.remote_data : conflict.local_data;
+    }
+    case "manual":
+      return conflict.local_data;
+    default:
+      return conflict.local_data;
+  }
+}
+function ensureConflictsTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS _sync_conflicts (
+      id TEXT PRIMARY KEY,
+      table_name TEXT,
+      row_id TEXT,
+      local_data TEXT,
+      remote_data TEXT,
+      local_updated_at TEXT,
+      remote_updated_at TEXT,
+      resolution TEXT,
+      resolved_at TEXT,
+      created_at TEXT DEFAULT (datetime('now'))
+    )
+  `);
+}
+function storeConflicts(db, conflicts) {
+  ensureConflictsTable(db);
+  for (const conflict of conflicts) {
+    const id = `${conflict.table}:${conflict.row_id}:${Date.now()}`;
+    db.run(`INSERT INTO _sync_conflicts (id, table_name, row_id, local_data, remote_data, local_updated_at, remote_updated_at, resolution, resolved_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, id, conflict.table, conflict.row_id, JSON.stringify(conflict.local_data), JSON.stringify(conflict.remote_data), conflict.local_updated_at, conflict.remote_updated_at, conflict.resolution ?? null, conflict.resolved ? new Date().toISOString() : null);
+  }
+}
+function listConflicts(db, opts) {
+  ensureConflictsTable(db);
+  let sql = `SELECT * FROM _sync_conflicts WHERE 1=1`;
+  const params = [];
+  if (opts?.resolved !== undefined) {
+    if (opts.resolved) {
+      sql += ` AND resolution IS NOT NULL AND resolved_at IS NOT NULL`;
+    } else {
+      sql += ` AND (resolution IS NULL OR resolved_at IS NULL)`;
+    }
+  }
+  if (opts?.table) {
+    sql += ` AND table_name = ?`;
+    params.push(opts.table);
+  }
+  sql += ` ORDER BY created_at DESC`;
+  return db.all(sql, ...params);
+}
+function resolveConflict(db, conflictId, strategy) {
+  ensureConflictsTable(db);
+  const row = db.get(`SELECT * FROM _sync_conflicts WHERE id = ?`, conflictId);
+  if (!row)
+    return null;
+  db.run(`UPDATE _sync_conflicts SET resolution = ?, resolved_at = datetime('now') WHERE id = ?`, strategy, conflictId);
+  return db.get(`SELECT * FROM _sync_conflicts WHERE id = ?`, conflictId);
+}
+function getConflict(db, conflictId) {
+  ensureConflictsTable(db);
+  return db.get(`SELECT * FROM _sync_conflicts WHERE id = ?`, conflictId);
+}
+function purgeResolvedConflicts(db) {
+  ensureConflictsTable(db);
+  const result = db.run(`DELETE FROM _sync_conflicts WHERE resolution IS NOT NULL AND resolved_at IS NOT NULL`);
+  return result.changes;
+}
+// src/sync-incremental.ts
+var SYNC_META_TABLE_SQL = `
+CREATE TABLE IF NOT EXISTS _sync_meta (
+  table_name TEXT PRIMARY KEY,
+  last_synced_at TEXT,
+  last_synced_row_count INTEGER DEFAULT 0,
+  direction TEXT DEFAULT 'push'
+)`;
+function ensureSyncMetaTable(db) {
+  db.exec(SYNC_META_TABLE_SQL);
+}
+function getSyncMeta(db, table) {
+  ensureSyncMetaTable(db);
+  return db.get(`SELECT table_name, last_synced_at, last_synced_row_count, direction FROM _sync_meta WHERE table_name = ?`, table) ?? null;
+}
+function upsertSyncMeta(db, meta) {
+  ensureSyncMetaTable(db);
+  const existing = db.get(`SELECT table_name FROM _sync_meta WHERE table_name = ?`, meta.table_name);
+  if (existing) {
+    db.run(`UPDATE _sync_meta SET last_synced_at = ?, last_synced_row_count = ?, direction = ? WHERE table_name = ?`, meta.last_synced_at, meta.last_synced_row_count, meta.direction, meta.table_name);
+  } else {
+    db.run(`INSERT INTO _sync_meta (table_name, last_synced_at, last_synced_row_count, direction) VALUES (?, ?, ?, ?)`, meta.table_name, meta.last_synced_at, meta.last_synced_row_count, meta.direction);
+  }
+}
+function transferRows(source, target, table, rows, options) {
+  const { primaryKey = "id", conflictColumn = "updated_at" } = options;
+  let written = 0;
+  let skipped = 0;
+  const errors2 = [];
+  if (rows.length === 0)
+    return { written, skipped, errors: errors2 };
+  const columns = Object.keys(rows[0]);
+  const hasConflictCol = columns.includes(conflictColumn);
+  const hasPrimaryKey = columns.includes(primaryKey);
+  if (!hasPrimaryKey) {
+    errors2.push(`Table "${table}" has no "${primaryKey}" column -- skipping`);
+    return { written, skipped, errors: errors2 };
+  }
+  for (const row of rows) {
+    try {
+      const existing = target.get(`SELECT "${primaryKey}"${hasConflictCol ? `, "${conflictColumn}"` : ""} FROM "${table}" WHERE "${primaryKey}" = ?`, row[primaryKey]);
+      if (existing) {
+        if (hasConflictCol && existing[conflictColumn] && row[conflictColumn]) {
+          const existingTime = new Date(existing[conflictColumn]).getTime();
+          const incomingTime = new Date(row[conflictColumn]).getTime();
+          if (existingTime >= incomingTime) {
+            skipped++;
+            continue;
+          }
+        }
+        const setClauses = columns.filter((c) => c !== primaryKey).map((c) => `"${c}" = ?`).join(", ");
+        const values = columns.filter((c) => c !== primaryKey).map((c) => row[c]);
+        values.push(row[primaryKey]);
+        target.run(`UPDATE "${table}" SET ${setClauses} WHERE "${primaryKey}" = ?`, ...values);
+      } else {
+        const placeholders = columns.map(() => "?").join(", ");
+        const colList = columns.map((c) => `"${c}"`).join(", ");
+        const values = columns.map((c) => row[c]);
+        target.run(`INSERT INTO "${table}" (${colList}) VALUES (${placeholders})`, ...values);
+      }
+      written++;
+    } catch (err) {
+      errors2.push(`Row ${row[primaryKey]}: ${err?.message ?? String(err)}`);
+    }
+  }
+  return { written, skipped, errors: errors2 };
+}
+function incrementalSyncPush(local, remote, tables, options = {}) {
+  const { conflictColumn = "updated_at", batchSize = 500 } = options;
+  const results = [];
+  ensureSyncMetaTable(local);
+  for (const table of tables) {
+    const stat = {
+      table,
+      total_rows: 0,
+      synced_rows: 0,
+      skipped_rows: 0,
+      errors: [],
+      first_sync: false
+    };
+    try {
+      const countResult = local.get(`SELECT COUNT(*) as cnt FROM "${table}"`);
+      stat.total_rows = countResult?.cnt ?? 0;
+      const meta = getSyncMeta(local, table);
+      let rows;
+      if (meta?.last_synced_at) {
+        try {
+          rows = local.all(`SELECT * FROM "${table}" WHERE "${conflictColumn}" > ?`, meta.last_synced_at);
+        } catch {
+          rows = local.all(`SELECT * FROM "${table}"`);
+          stat.first_sync = true;
+        }
+      } else {
+        rows = local.all(`SELECT * FROM "${table}"`);
+        stat.first_sync = true;
+      }
+      for (let offset = 0;offset < rows.length; offset += batchSize) {
+        const batch = rows.slice(offset, offset + batchSize);
+        const result = transferRows(local, remote, table, batch, options);
+        stat.synced_rows += result.written;
+        stat.skipped_rows += result.skipped;
+        stat.errors.push(...result.errors);
+      }
+      if (rows.length === 0) {
+        stat.skipped_rows = stat.total_rows;
+      }
+      const now = new Date().toISOString();
+      upsertSyncMeta(local, {
+        table_name: table,
+        last_synced_at: now,
+        last_synced_row_count: stat.synced_rows,
+        direction: "push"
+      });
+    } catch (err) {
+      stat.errors.push(`Table "${table}": ${err?.message ?? String(err)}`);
+    }
+    results.push(stat);
+  }
+  return results;
+}
+function incrementalSyncPull(remote, local, tables, options = {}) {
+  const { conflictColumn = "updated_at", batchSize = 500 } = options;
+  const results = [];
+  ensureSyncMetaTable(local);
+  for (const table of tables) {
+    const stat = {
+      table,
+      total_rows: 0,
+      synced_rows: 0,
+      skipped_rows: 0,
+      errors: [],
+      first_sync: false
+    };
+    try {
+      const countResult = remote.get(`SELECT COUNT(*) as cnt FROM "${table}"`);
+      stat.total_rows = countResult?.cnt ?? 0;
+      const meta = getSyncMeta(local, table);
+      let rows;
+      if (meta?.last_synced_at) {
+        try {
+          rows = remote.all(`SELECT * FROM "${table}" WHERE "${conflictColumn}" > ?`, meta.last_synced_at);
+        } catch {
+          rows = remote.all(`SELECT * FROM "${table}"`);
+          stat.first_sync = true;
+        }
+      } else {
+        rows = remote.all(`SELECT * FROM "${table}"`);
+        stat.first_sync = true;
+      }
+      for (let offset = 0;offset < rows.length; offset += batchSize) {
+        const batch = rows.slice(offset, offset + batchSize);
+        const result = transferRows(remote, local, table, batch, options);
+        stat.synced_rows += result.written;
+        stat.skipped_rows += result.skipped;
+        stat.errors.push(...result.errors);
+      }
+      if (rows.length === 0) {
+        stat.skipped_rows = stat.total_rows;
+      }
+      const now = new Date().toISOString();
+      upsertSyncMeta(local, {
+        table_name: table,
+        last_synced_at: now,
+        last_synced_row_count: stat.synced_rows,
+        direction: "pull"
+      });
+    } catch (err) {
+      stat.errors.push(`Table "${table}": ${err?.message ?? String(err)}`);
+    }
+    results.push(stat);
+  }
+  return results;
+}
+function getSyncMetaAll(db) {
+  ensureSyncMetaTable(db);
+  return db.all(`SELECT table_name, last_synced_at, last_synced_row_count, direction FROM _sync_meta ORDER BY table_name`);
+}
+function getSyncMetaForTable(db, table) {
+  return getSyncMeta(db, table);
+}
+function resetSyncMeta(db, table) {
+  ensureSyncMetaTable(db);
+  db.run(`DELETE FROM _sync_meta WHERE table_name = ?`, table);
+}
+function resetAllSyncMeta(db) {
+  ensureSyncMetaTable(db);
+  db.run(`DELETE FROM _sync_meta`);
+}
+// src/auto-sync.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
+var AUTO_SYNC_CONFIG_PATH = join3(homedir3(), ".hasna", "cloud", "config.json");
+var DEFAULT_AUTO_SYNC_CONFIG = {
+  auto_sync_on_start: true,
+  auto_sync_on_stop: true
+};
+function getAutoSyncConfig() {
+  try {
+    if (!existsSync3(AUTO_SYNC_CONFIG_PATH)) {
+      return { ...DEFAULT_AUTO_SYNC_CONFIG };
+    }
+    const raw = JSON.parse(readFileSync2(AUTO_SYNC_CONFIG_PATH, "utf-8"));
+    return {
+      auto_sync_on_start: typeof raw.auto_sync_on_start === "boolean" ? raw.auto_sync_on_start : DEFAULT_AUTO_SYNC_CONFIG.auto_sync_on_start,
+      auto_sync_on_stop: typeof raw.auto_sync_on_stop === "boolean" ? raw.auto_sync_on_stop : DEFAULT_AUTO_SYNC_CONFIG.auto_sync_on_stop
+    };
+  } catch {
+    return { ...DEFAULT_AUTO_SYNC_CONFIG };
+  }
+}
+function executeAutoSync(event, local, remote, tables) {
+  const direction = event === "start" ? "pull" : "push";
+  const result = {
+    event,
+    direction,
+    success: false,
+    tables_synced: 0,
+    total_rows_synced: 0,
+    errors: []
+  };
+  try {
+    const stats = direction === "pull" ? incrementalSyncPull(remote, local, tables) : incrementalSyncPush(local, remote, tables);
+    for (const s of stats) {
+      if (s.errors.length === 0) {
+        result.tables_synced++;
+      }
+      result.total_rows_synced += s.synced_rows;
+      result.errors.push(...s.errors);
+    }
+    result.success = result.errors.length === 0;
+  } catch (err) {
+    result.errors.push(err?.message ?? String(err));
+  }
+  return result;
+}
+var cleanupHandlers = [];
+var signalHandlersInstalled = false;
+function installSignalHandlers() {
+  if (signalHandlersInstalled)
+    return;
+  signalHandlersInstalled = true;
+  const handleExit = () => {
+    for (const fn of cleanupHandlers) {
+      try {
+        fn();
+      } catch {}
+    }
+  };
+  process.on("SIGTERM", () => {
+    handleExit();
+    process.exit(0);
+  });
+  process.on("SIGINT", () => {
+    handleExit();
+    process.exit(0);
+  });
+  process.on("beforeExit", () => {
+    handleExit();
+  });
+}
+function setupAutoSync(serviceName, server, local, remote, tables) {
+  const config = getAutoSyncConfig();
+  const cloudConfig = getCloudConfig();
+  const isSyncEnabled = cloudConfig.mode === "hybrid" || cloudConfig.mode === "cloud";
+  const syncOnStart = () => {
+    if (!config.auto_sync_on_start || !isSyncEnabled)
+      return null;
+    return executeAutoSync("start", local, remote, tables);
+  };
+  const syncOnStop = () => {
+    if (!config.auto_sync_on_stop || !isSyncEnabled)
+      return null;
+    return executeAutoSync("stop", local, remote, tables);
+  };
+  if (server && typeof server.onconnect === "function") {
+    const origOnConnect = server.onconnect;
+    server.onconnect = (...args) => {
+      syncOnStart();
+      return origOnConnect.apply(server, args);
+    };
+  } else if (server && typeof server.on === "function") {
+    server.on("connect", () => {
+      syncOnStart();
+    });
+  }
+  if (server && typeof server.ondisconnect === "function") {
+    const origOnDisconnect = server.ondisconnect;
+    server.ondisconnect = (...args) => {
+      syncOnStop();
+      return origOnDisconnect.apply(server, args);
+    };
+  } else if (server && typeof server.on === "function") {
+    server.on("disconnect", () => {
+      syncOnStop();
+    });
+  }
+  installSignalHandlers();
+  cleanupHandlers.push(() => {
+    syncOnStop();
+  });
+  return { syncOnStart, syncOnStop, config };
+}
+function enableAutoSync(serviceName, mcpServer, local, remote, tables) {
+  setupAutoSync(serviceName, mcpServer, local, remote, tables);
+}
 // src/mcp-helpers.ts
 function registerCloudTools(server, serviceName) {
   server.tool(`${serviceName}_cloud_status`, "Show cloud configuration and connection health", {}, async () => {
@@ -9512,10 +10154,10 @@ function registerCloudTools(server, serviceName) {
     ];
     if (config.rds.host && config.rds.username) {
       try {
-        const pg2 = new PgAdapter(getConnectionString("postgres"));
-        pg2.get("SELECT 1 as ok");
+        const pg2 = new PgAdapterAsync(getConnectionString("postgres"));
+        await pg2.get("SELECT 1 as ok");
         lines.push("PostgreSQL: connected");
-        pg2.close();
+        await pg2.close();
       } catch (err) {
         lines.push(`PostgreSQL: failed — ${err?.message}`);
       }
@@ -9536,11 +10178,11 @@ function registerCloudTools(server, serviceName) {
       };
     }
     const local = new SqliteAdapter(getDbPath(serviceName));
-    const cloud = new PgAdapter(getConnectionString(serviceName));
+    const cloud = new PgAdapterAsync(getConnectionString(serviceName));
     const tableList = tablesStr ? tablesStr.split(",").map((t) => t.trim()) : listSqliteTables(local);
-    const results = syncPush(local, cloud, { tables: tableList });
+    const results = await syncPush(local, cloud, { tables: tableList });
     local.close();
-    cloud.close();
+    await cloud.close();
     const total = results.reduce((s, r) => s + r.rowsWritten, 0);
     return {
       content: [{ type: "text", text: `Pushed ${total} rows across ${tableList.length} table(s).` }]
@@ -9559,17 +10201,16 @@ function registerCloudTools(server, serviceName) {
       };
     }
     const local = new SqliteAdapter(getDbPath(serviceName));
-    const cloud = new PgAdapter(getConnectionString(serviceName));
+    const cloud = new PgAdapterAsync(getConnectionString(serviceName));
     let tableList;
     if (tablesStr) {
       tableList = tablesStr.split(",").map((t) => t.trim());
     } else {
       try {
-        const rows = cloud.all(`SELECT tablename FROM pg_tables WHERE schemaname = 'public'`);
-        tableList = rows.map((r) => r.tablename);
+        tableList = await listPgTables(cloud);
       } catch {
         local.close();
-        cloud.close();
+        await cloud.close();
         return {
           content: [
             { type: "text", text: "Error: failed to list cloud tables." }
@@ -9578,9 +10219,9 @@ function registerCloudTools(server, serviceName) {
         };
       }
     }
-    const results = syncPull(local, cloud, { tables: tableList });
+    const results = await syncPull(cloud, local, { tables: tableList });
     local.close();
-    cloud.close();
+    await cloud.close();
     const total = results.reduce((s, r) => s + r.rowsWritten, 0);
     return {
       content: [{ type: "text", text: `Pulled ${total} rows across ${tableList.length} table(s).` }]
@@ -9614,25 +10255,25 @@ function registerCloudCommands(program, serviceName) {
     if (config.rds.host && config.rds.username) {
       try {
         const connStr = getConnectionString("postgres");
-        const pg2 = new PgAdapter(connStr);
-        pg2.get("SELECT 1 as ok");
+        const pg2 = new PgAdapterAsync(connStr);
+        await pg2.get("SELECT 1 as ok");
         console.log("PostgreSQL: connected");
-        pg2.close();
+        await pg2.close();
       } catch (err) {
         console.log("PostgreSQL: connection failed —", err?.message);
       }
     }
   });
-  cloudCmd.command("push").description("Push local data to cloud").option("--tables <tables>", "Comma-separated table names").action((opts) => {
+  cloudCmd.command("push").description("Push local data to cloud").option("--tables <tables>", "Comma-separated table names").action(async (opts) => {
     const config = getCloudConfig();
     if (config.mode === "local") {
       console.error("Error: mode is 'local'. Run `cloud setup` first.");
       process.exit(1);
     }
     const local = new SqliteAdapter(getDbPath(serviceName));
-    const cloud = new PgAdapter(getConnectionString(serviceName));
+    const cloud = new PgAdapterAsync(getConnectionString(serviceName));
     const tables = opts.tables ? opts.tables.split(",").map((t) => t.trim()) : listSqliteTables(local);
-    const results = syncPush(local, cloud, {
+    const results = await syncPush(local, cloud, {
       tables,
       onProgress: (p) => {
         if (p.phase === "done") {
@@ -9641,26 +10282,25 @@ function registerCloudCommands(program, serviceName) {
       }
     });
     local.close();
-    cloud.close();
+    await cloud.close();
     const total = results.reduce((s, r) => s + r.rowsWritten, 0);
     console.log(`Done. ${total} rows pushed.`);
   });
-  cloudCmd.command("pull").description("Pull cloud data to local").option("--tables <tables>", "Comma-separated table names").action((opts) => {
+  cloudCmd.command("pull").description("Pull cloud data to local").option("--tables <tables>", "Comma-separated table names").action(async (opts) => {
     const config = getCloudConfig();
     if (config.mode === "local") {
       console.error("Error: mode is 'local'. Run `cloud setup` first.");
       process.exit(1);
     }
     const local = new SqliteAdapter(getDbPath(serviceName));
-    const cloud = new PgAdapter(getConnectionString(serviceName));
+    const cloud = new PgAdapterAsync(getConnectionString(serviceName));
     let tables;
     if (opts.tables) {
       tables = opts.tables.split(",").map((t) => t.trim());
     } else {
-      const rows = cloud.all(`SELECT tablename FROM pg_tables WHERE schemaname = 'public' ORDER BY tablename`);
-      tables = rows.map((r) => r.tablename);
+      tables = await listPgTables(cloud);
     }
-    const results = syncPull(local, cloud, {
+    const results = await syncPull(cloud, local, {
       tables,
       onProgress: (p) => {
         if (p.phase === "done") {
@@ -9669,7 +10309,7 @@ function registerCloudCommands(program, serviceName) {
       }
     });
     local.close();
-    cloud.close();
+    await cloud.close();
     const total = results.reduce((s, r) => s + r.rowsWritten, 0);
     console.log(`Done. ${total} rows pulled.`);
   });
@@ -9690,25 +10330,45 @@ export {
   translateDdl,
   syncPush,
   syncPull,
+  storeConflicts,
+  setupAutoSync,
   sendFeedback,
   saveFeedback,
   saveCloudConfig,
+  resolveConflicts,
+  resolveConflict,
+  resetSyncMeta,
+  resetAllSyncMeta,
   registerCloudTools,
   registerCloudCommands,
+  purgeResolvedConflicts,
   migrateDotfile,
   listSqliteTables,
   listPgTables,
   listFeedback,
+  listConflicts,
+  incrementalSyncPush,
+  incrementalSyncPull,
   hasLegacyDotfile,
+  getWinningData,
+  getSyncMetaForTable,
+  getSyncMetaAll,
   getHasnaDir,
   getDbPath,
   getDataDir,
   getConnectionString,
+  getConflict,
   getConfigPath,
   getConfigDir,
   getCloudConfig,
+  getAutoSyncConfig,
+  ensureSyncMetaTable,
   ensureFeedbackTable,
+  ensureConflictsTable,
+  enableAutoSync,
+  detectConflicts,
   createDatabase,
+  SyncProgressTracker,
   SqliteAdapter,
   PgAdapterAsync,
   PgAdapter,