@hasna/connectors 1.3.11 → 1.3.12

package/bin/index.js

@@ -1905,6 +1905,75 @@ var require_commander = __commonJS((exports) => {
 });
 
 // node_modules/@hasna/cloud/dist/index.js
+var exports_dist = {};
+__export(exports_dist, {
+  translateSql: () => translateSql,
+  translateParams: () => translateParams,
+  translateDdl: () => translateDdl,
+  syncPush: () => syncPush,
+  syncPull: () => syncPull,
+  storeConflicts: () => storeConflicts,
+  setupAutoSync: () => setupAutoSync,
+  sendFeedback: () => sendFeedback,
+  saveFeedback: () => saveFeedback,
+  saveCloudConfig: () => saveCloudConfig,
+  runScheduledSync: () => runScheduledSync,
+  resolveConflicts: () => resolveConflicts,
+  resolveConflict: () => resolveConflict,
+  resetSyncMeta: () => resetSyncMeta,
+  resetAllSyncMeta: () => resetAllSyncMeta,
+  removeSyncSchedule: () => removeSyncSchedule,
+  registerSyncSchedule: () => registerSyncSchedule,
+  registerCloudTools: () => registerCloudTools,
+  registerCloudCommands: () => registerCloudCommands,
+  purgeResolvedConflicts: () => purgeResolvedConflicts,
+  parseInterval: () => parseInterval,
+  minutesToCron: () => minutesToCron,
+  migrateService: () => migrateService,
+  migrateDotfile: () => migrateDotfile,
+  migrateAllServices: () => migrateAllServices,
+  listSqliteTables: () => listSqliteTables,
+  listPgTables: () => listPgTables,
+  listFeedback: () => listFeedback,
+  listConflicts: () => listConflicts,
+  isSyncExcludedTable: () => isSyncExcludedTable,
+  incrementalSyncPush: () => incrementalSyncPush,
+  incrementalSyncPull: () => incrementalSyncPull,
+  hasLegacyDotfile: () => hasLegacyDotfile,
+  getWinningData: () => getWinningData,
+  getSyncScheduleStatus: () => getSyncScheduleStatus,
+  getSyncMetaForTable: () => getSyncMetaForTable,
+  getSyncMetaAll: () => getSyncMetaAll,
+  getServiceDbPath: () => getServiceDbPath,
+  getHasnaDir: () => getHasnaDir,
+  getDbPath: () => getDbPath,
+  getDataDir: () => getDataDir,
+  getConnectionString: () => getConnectionString,
+  getConflict: () => getConflict,
+  getConfigPath: () => getConfigPath,
+  getConfigDir: () => getConfigDir,
+  getCloudConfig: () => getCloudConfig,
+  getAutoSyncConfig: () => getAutoSyncConfig,
+  ensureSyncMetaTable: () => ensureSyncMetaTable,
+  ensurePgDatabase: () => ensurePgDatabase,
+  ensureFeedbackTable: () => ensureFeedbackTable,
+  ensureConflictsTable: () => ensureConflictsTable,
+  ensureAllPgDatabases: () => ensureAllPgDatabases,
+  enableAutoSync: () => enableAutoSync,
+  discoverSyncableServicesV2: () => discoverSyncableServices,
+  discoverSyncableServices: () => discoverSyncableServices2,
+  discoverServices: () => discoverServices,
+  detectConflicts: () => detectConflicts,
+  createDatabase: () => createDatabase,
+  applyPgMigrations: () => applyPgMigrations,
+  SyncProgressTracker: () => SyncProgressTracker,
+  SqliteAdapter: () => SqliteAdapter,
+  SYNC_EXCLUDED_TABLE_PATTERNS: () => SYNC_EXCLUDED_TABLE_PATTERNS,
+  PgAdapterAsync: () => PgAdapterAsync,
+  PgAdapter: () => PgAdapter,
+  KNOWN_PG_SERVICES: () => KNOWN_PG_SERVICES,
+  CloudConfigSchema: () => CloudConfigSchema
+});
 import { createRequire } from "module";
 import { Database } from "bun:sqlite";
 import {
@@ -1922,9 +1991,13 @@ import { readdirSync as readdirSync2, existsSync as existsSync3 } from "fs";
 import { join as join3 } from "path";
 import { homedir as homedir3 } from "os";
 import { hostname } from "os";
+import { existsSync as existsSync4, readFileSync as readFileSync2 } from "fs";
 import { homedir as homedir4 } from "os";
 import { join as join4 } from "path";
+import { existsSync as existsSync5, readdirSync as readdirSync3 } from "fs";
+import { join as join5 } from "path";
 import { join as join6, dirname } from "path";
+import { existsSync as existsSync6, writeFileSync as writeFileSync2, unlinkSync, mkdirSync as mkdirSync3 } from "fs";
 import { homedir as homedir5, platform } from "os";
 function __accessProp2(key) {
   return this[key];
@@ -1979,6 +2052,17 @@ function sqliteToPostgres(sql) {
   }
   return out;
 }
+function translateDdl(ddl, dialect) {
+  if (dialect === "sqlite")
+    return ddl;
+  let out = ddl;
+  out = out.replace(/\bINTEGER\s+PRIMARY\s+KEY\s+AUTOINCREMENT\b/gi, "BIGSERIAL PRIMARY KEY");
+  out = out.replace(/\bAUTOINCREMENT\b/gi, "");
+  out = out.replace(/\bREAL\b/gi, "DOUBLE PRECISION");
+  out = out.replace(/\bBLOB\b/gi, "BYTEA");
+  out = sqliteToPostgres(out);
+  return out;
+}
 
 class SqliteAdapter {
   db;
@@ -2804,6 +2888,39 @@ function getDbPath(serviceName) {
   const dir = getDataDir(serviceName);
   return join(dir, `${serviceName}.db`);
 }
+function migrateDotfile(serviceName) {
+  const legacyDir = join(homedir(), `.${serviceName}`);
+  const newDir = join(HASNA_DIR, serviceName);
+  if (!existsSync(legacyDir))
+    return [];
+  if (existsSync(newDir))
+    return [];
+  mkdirSync(newDir, { recursive: true });
+  const migrated = [];
+  copyDirRecursive(legacyDir, newDir, legacyDir, migrated);
+  return migrated;
+}
+function copyDirRecursive(src, dest, root, migrated) {
+  const entries = readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = join(src, entry.name);
+    const destPath = join(dest, entry.name);
+    if (entry.isDirectory()) {
+      mkdirSync(destPath, { recursive: true });
+      copyDirRecursive(srcPath, destPath, root, migrated);
+    } else {
+      copyFileSync(srcPath, destPath);
+      migrated.push(relative(root, srcPath));
+    }
+  }
+}
+function hasLegacyDotfile(serviceName) {
+  return existsSync(join(homedir(), `.${serviceName}`));
+}
+function getHasnaDir() {
+  mkdirSync(HASNA_DIR, { recursive: true });
+  return HASNA_DIR;
+}
 function getConfigDir() {
   return CONFIG_DIR;
 }
@@ -3376,6 +3493,10 @@ async function sendFeedback(feedback, db) {
     return { sent: false, id, error: errorMsg };
   }
 }
+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`);
+}
 
 class SyncProgressTracker {
   db;
@@ -3496,6 +3617,947 @@ class SyncProgressTracker {
     }
   }
 }
+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;
+}
+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`);
+}
+function getAutoSyncConfig() {
+  try {
+    if (!existsSync4(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 };
+  }
+}
+async function executeAutoSync(event, serviceName, local, tables) {
+  const direction = event === "start" ? "pull" : "push";
+  const result = {
+    event,
+    direction,
+    success: false,
+    tables_synced: 0,
+    total_rows_synced: 0,
+    errors: []
+  };
+  let remote = null;
+  try {
+    const connStr = getConnectionString(serviceName);
+    remote = new PgAdapterAsync(connStr);
+    const syncTables = tables.length > 0 ? tables.filter((t) => !isSyncExcludedTable(t)) : direction === "push" ? listSqliteTables(local).filter((t) => !isSyncExcludedTable(t)) : (await listPgTables(remote)).filter((t) => !isSyncExcludedTable(t));
+    if (syncTables.length === 0) {
+      result.success = true;
+      return result;
+    }
+    const results = direction === "pull" ? await syncPull(remote, local, { tables: syncTables }) : await syncPush(local, remote, { tables: syncTables });
+    for (const r of results) {
+      if (r.errors.length === 0)
+        result.tables_synced++;
+      result.total_rows_synced += r.rowsWritten;
+      result.errors.push(...r.errors);
+    }
+    result.success = result.errors.length === 0;
+  } catch (err) {
+    result.errors.push(err?.message ?? String(err));
+  } finally {
+    if (remote) {
+      try {
+        await remote.close();
+      } catch {}
+    }
+  }
+  return result;
+}
+function installSignalHandlers() {
+  if (signalHandlersInstalled)
+    return;
+  signalHandlersInstalled = true;
+  const handleExit = async () => {
+    for (const fn of cleanupHandlers) {
+      try {
+        await fn();
+      } catch {}
+    }
+  };
+  process.on("SIGTERM", async () => {
+    await handleExit();
+    process.exit(0);
+  });
+  process.on("SIGINT", async () => {
+    await handleExit();
+    process.exit(0);
+  });
+  process.on("beforeExit", async () => {
+    await handleExit();
+  });
+}
+function setupAutoSync(serviceName, server, local, remote, tables) {
+  const config = getAutoSyncConfig();
+  const cloudConfig = getCloudConfig();
+  const isSyncEnabled = cloudConfig.mode === "hybrid" || cloudConfig.mode === "cloud";
+  const syncOnStart = async () => {
+    if (!config.auto_sync_on_start || !isSyncEnabled)
+      return null;
+    return executeAutoSync("start", serviceName, local, tables);
+  };
+  const syncOnStop = async () => {
+    if (!config.auto_sync_on_stop || !isSyncEnabled)
+      return null;
+    return executeAutoSync("stop", serviceName, local, tables);
+  };
+  if (server && typeof server.onconnect === "function") {
+    const origOnConnect = server.onconnect;
+    server.onconnect = async (...args) => {
+      await 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 = async (...args) => {
+      await syncOnStop();
+      return origOnDisconnect.apply(server, args);
+    };
+  } else if (server && typeof server.on === "function") {
+    server.on("disconnect", () => syncOnStop());
+  }
+  installSignalHandlers();
+  cleanupHandlers.push(async () => {
+    await syncOnStop();
+  });
+  return { syncOnStart, syncOnStop, config };
+}
+function enableAutoSync(serviceName, mcpServer, local, remote, tables) {
+  setupAutoSync(serviceName, mcpServer, local, remote, tables);
+}
+function discoverSyncableServices2() {
+  const hasnaDir = getHasnaDir();
+  const services = [];
+  try {
+    const entries = readdirSync3(hasnaDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory())
+        continue;
+      const dbPath = join5(hasnaDir, entry.name, `${entry.name}.db`);
+      if (existsSync5(dbPath)) {
+        services.push(entry.name);
+      }
+    }
+  } catch {}
+  return services;
+}
+async function runScheduledSync() {
+  const config = getCloudConfig();
+  if (config.mode === "local")
+    return [];
+  const services = discoverSyncableServices2();
+  const results = [];
+  let remote = null;
+  for (const service of services) {
+    const result = {
+      service,
+      tables_synced: 0,
+      total_rows_synced: 0,
+      errors: []
+    };
+    try {
+      const dbPath = join5(getDataDir(service), `${service}.db`);
+      if (!existsSync5(dbPath)) {
+        continue;
+      }
+      const local = new SqliteAdapter(dbPath);
+      const tables = listSqliteTables(local).filter((t) => !t.startsWith("_") && !t.startsWith("sqlite_"));
+      if (tables.length === 0) {
+        local.close();
+        continue;
+      }
+      try {
+        const connStr = getConnectionString(service);
+        remote = new PgAdapterAsync(connStr);
+      } catch (err) {
+        result.errors.push(`Connection failed: ${err?.message ?? String(err)}`);
+        local.close();
+        results.push(result);
+        continue;
+      }
+      const stats = 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);
+      }
+      local.close();
+      await remote.close();
+      remote = null;
+    } catch (err) {
+      result.errors.push(err?.message ?? String(err));
+    }
+    results.push(result);
+  }
+  if (remote) {
+    try {
+      await remote.close();
+    } catch {}
+  }
+  return results;
+}
+function parseInterval(input) {
+  const trimmed = input.trim().toLowerCase();
+  const hourMatch = trimmed.match(/^(\d+)\s*h$/);
+  if (hourMatch) {
+    const hours = parseInt(hourMatch[1], 10);
+    if (hours <= 0) {
+      throw new Error(`Invalid interval "${input}". Value must be greater than 0.`);
+    }
+    return hours * 60;
+  }
+  const minMatch = trimmed.match(/^(\d+)\s*m$/);
+  if (minMatch) {
+    const mins = parseInt(minMatch[1], 10);
+    if (mins <= 0) {
+      throw new Error(`Invalid interval "${input}". Value must be greater than 0.`);
+    }
+    return mins;
+  }
+  const plain = parseInt(trimmed, 10);
+  if (!isNaN(plain) && plain > 0) {
+    return plain;
+  }
+  throw new Error(`Invalid interval "${input}". Use formats like: 5m, 10m, 1h, or a plain number of minutes.`);
+}
+function minutesToCron(minutes) {
+  if (minutes <= 0) {
+    throw new Error("Interval must be greater than 0 minutes.");
+  }
+  if (minutes < 60) {
+    return `*/${minutes} * * * *`;
+  }
+  const hours = Math.floor(minutes / 60);
+  const remainderMins = minutes % 60;
+  if (remainderMins === 0 && hours <= 24) {
+    return `0 */${hours} * * *`;
+  }
+  return `*/${minutes} * * * *`;
+}
+function getWorkerPath() {
+  const dir = typeof import.meta.dir === "string" ? import.meta.dir : dirname(import.meta.url.replace("file://", ""));
+  const tsPath = join6(dir, "scheduled-sync.ts");
+  const jsPath = join6(dir, "scheduled-sync.js");
+  try {
+    if (existsSync6(tsPath))
+      return tsPath;
+  } catch {}
+  return jsPath;
+}
+function getBunPath() {
+  const candidates = [
+    join6(homedir5(), ".bun", "bin", "bun"),
+    "/usr/local/bin/bun",
+    "/usr/bin/bun"
+  ];
+  for (const p of candidates) {
+    if (existsSync6(p))
+      return p;
+  }
+  return "bun";
+}
+function getLaunchdPlistPath() {
+  return join6(homedir5(), "Library", "LaunchAgents", `com.hasna.cloud-sync.plist`);
+}
+function createLaunchdPlist(intervalMinutes) {
+  const workerPath = getWorkerPath();
+  const bunPath = getBunPath();
+  const logPath = join6(CONFIG_DIR2, "sync.log");
+  const errorLogPath = join6(CONFIG_DIR2, "sync-error.log");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>com.hasna.cloud-sync</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${bunPath}</string>
+    <string>run</string>
+    <string>${workerPath}</string>
+  </array>
+  <key>StartInterval</key>
+  <integer>${intervalMinutes * 60}</integer>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${logPath}</string>
+  <key>StandardErrorPath</key>
+  <string>${errorLogPath}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>${process.env.PATH || "/usr/local/bin:/usr/bin:/bin"}</string>
+    <key>HOME</key>
+    <string>${homedir5()}</string>
+  </dict>
+</dict>
+</plist>`;
+}
+async function registerLaunchd(intervalMinutes) {
+  const plistPath = getLaunchdPlistPath();
+  const plistDir = dirname(plistPath);
+  mkdirSync3(plistDir, { recursive: true });
+  try {
+    await Bun.spawn(["launchctl", "unload", plistPath]).exited;
+  } catch {}
+  writeFileSync2(plistPath, createLaunchdPlist(intervalMinutes));
+  await Bun.spawn(["launchctl", "load", plistPath]).exited;
+}
+async function removeLaunchd() {
+  const plistPath = getLaunchdPlistPath();
+  try {
+    await Bun.spawn(["launchctl", "unload", plistPath]).exited;
+  } catch {}
+  try {
+    unlinkSync(plistPath);
+  } catch {}
+}
+function getSystemdDir() {
+  return join6(homedir5(), ".config", "systemd", "user");
+}
+function createSystemdService() {
+  const workerPath = getWorkerPath();
+  const bunPath = getBunPath();
+  return `[Unit]
+Description=Hasna Cloud Sync
+After=network.target
+
+[Service]
+Type=oneshot
+ExecStart=${bunPath} run ${workerPath}
+Environment=HOME=${homedir5()}
+Environment=PATH=${process.env.PATH || "/usr/local/bin:/usr/bin:/bin"}
+
+[Install]
+WantedBy=default.target
+`;
+}
+function createSystemdTimer(intervalMinutes) {
+  return `[Unit]
+Description=Hasna Cloud Sync Timer
+
+[Timer]
+OnBootSec=${intervalMinutes}min
+OnUnitActiveSec=${intervalMinutes}min
+Persistent=true
+
+[Install]
+WantedBy=timers.target
+`;
+}
+async function registerSystemd(intervalMinutes) {
+  const dir = getSystemdDir();
+  mkdirSync3(dir, { recursive: true });
+  writeFileSync2(join6(dir, `${SERVICE_NAME}.service`), createSystemdService());
+  writeFileSync2(join6(dir, `${SERVICE_NAME}.timer`), createSystemdTimer(intervalMinutes));
+  await Bun.spawn(["systemctl", "--user", "daemon-reload"]).exited;
+  await Bun.spawn(["systemctl", "--user", "enable", "--now", `${SERVICE_NAME}.timer`]).exited;
+}
+async function removeSystemd() {
+  try {
+    await Bun.spawn(["systemctl", "--user", "disable", "--now", `${SERVICE_NAME}.timer`]).exited;
+  } catch {}
+  const dir = getSystemdDir();
+  try {
+    unlinkSync(join6(dir, `${SERVICE_NAME}.service`));
+  } catch {}
+  try {
+    unlinkSync(join6(dir, `${SERVICE_NAME}.timer`));
+  } catch {}
+  try {
+    await Bun.spawn(["systemctl", "--user", "daemon-reload"]).exited;
+  } catch {}
+}
+async function registerSyncSchedule(intervalMinutes) {
+  if (intervalMinutes <= 0) {
+    throw new Error("Interval must be a positive number of minutes.");
+  }
+  mkdirSync3(CONFIG_DIR2, { recursive: true });
+  if (platform() === "darwin") {
+    await registerLaunchd(intervalMinutes);
+  } else {
+    await registerSystemd(intervalMinutes);
+  }
+  const config = getCloudConfig();
+  config.sync.schedule_minutes = intervalMinutes;
+  saveCloudConfig(config);
+}
+async function removeSyncSchedule() {
+  if (platform() === "darwin") {
+    await removeLaunchd();
+  } else {
+    await removeSystemd();
+  }
+  const config = getCloudConfig();
+  config.sync.schedule_minutes = 0;
+  saveCloudConfig(config);
+}
+function getSyncScheduleStatus() {
+  const config = getCloudConfig();
+  const minutes = config.sync.schedule_minutes;
+  const registered = minutes > 0;
+  let mechanism = "none";
+  if (registered) {
+    if (platform() === "darwin") {
+      mechanism = existsSync6(getLaunchdPlistPath()) ? "launchd" : "none";
+    } else {
+      mechanism = existsSync6(join6(getSystemdDir(), `${SERVICE_NAME}.timer`)) ? "systemd" : "none";
+    }
+  }
+  return {
+    registered,
+    schedule_minutes: minutes,
+    cron_expression: registered ? minutesToCron(minutes) : null,
+    mechanism
+  };
+}
+async function applyPgMigrations(connectionString, migrations, service = "unknown") {
+  const pg2 = new PgAdapterAsync(connectionString);
+  const result = {
+    service,
+    applied: [],
+    alreadyApplied: [],
+    errors: [],
+    totalMigrations: migrations.length
+  };
+  try {
+    await pg2.run(`CREATE TABLE IF NOT EXISTS _pg_migrations (
+        id SERIAL PRIMARY KEY,
+        version INT UNIQUE NOT NULL,
+        applied_at TIMESTAMPTZ DEFAULT NOW()
+      )`);
+    const applied = await pg2.all("SELECT version FROM _pg_migrations ORDER BY version");
+    const appliedSet = new Set(applied.map((r) => r.version));
+    for (let i = 0;i < migrations.length; i++) {
+      if (appliedSet.has(i)) {
+        result.alreadyApplied.push(i);
+        continue;
+      }
+      try {
+        await pg2.exec(migrations[i]);
+        await pg2.run("INSERT INTO _pg_migrations (version) VALUES ($1) ON CONFLICT DO NOTHING", i);
+        result.applied.push(i);
+      } catch (err) {
+        result.errors.push(`Migration ${i}: ${err?.message ?? String(err)}`);
+        break;
+      }
+    }
+  } finally {
+    await pg2.close();
+  }
+  return result;
+}
+function getServicePackage(service) {
+  return `@hasna/${service}`;
+}
+async function loadServiceMigrations(service) {
+  const pkg = getServicePackage(service);
+  const paths = [
+    `${pkg}/pg-migrations`,
+    `${pkg}/dist/db/pg-migrations.js`,
+    `${pkg}/dist/db/pg-migrations`
+  ];
+  for (const path of paths) {
+    try {
+      const mod = await import(path);
+      if (Array.isArray(mod.PG_MIGRATIONS)) {
+        return mod.PG_MIGRATIONS;
+      }
+      if (mod.default && Array.isArray(mod.default.PG_MIGRATIONS)) {
+        return mod.default.PG_MIGRATIONS;
+      }
+    } catch {}
+  }
+  return null;
+}
+async function migrateService(service, connectionString) {
+  const connStr = connectionString ?? getConnectionString(service);
+  const migrations = await loadServiceMigrations(service);
+  if (!migrations) {
+    return {
+      service,
+      applied: [],
+      alreadyApplied: [],
+      errors: [`No PG migrations found for service "${service}"`],
+      totalMigrations: 0
+    };
+  }
+  return applyPgMigrations(connStr, migrations, service);
+}
+async function migrateAllServices() {
+  const { discoverServices: discoverServices2 } = await Promise.resolve().then(() => (init_discover(), exports_discover));
+  const services = discoverServices2();
+  const results = [];
+  for (const service of services) {
+    try {
+      const result = await migrateService(service);
+      results.push(result);
+    } catch (err) {
+      results.push({
+        service,
+        applied: [],
+        alreadyApplied: [],
+        errors: [err?.message ?? String(err)],
+        totalMigrations: 0
+      });
+    }
+  }
+  return results;
+}
+async function ensurePgDatabase(service) {
+  const config = (await Promise.resolve().then(() => (init_config(), exports_config))).getCloudConfig();
+  const { host, port, username, password_env, ssl } = config.rds;
+  if (!host || !username)
+    return false;
+  const password = process.env[password_env] ?? "";
+  const sslParam = ssl ? "?sslmode=require" : "";
+  const adminConnStr = `postgres://${username}:${encodeURIComponent(password)}@${host}:${port}/postgres${sslParam}`;
+  const pg2 = new PgAdapterAsync(adminConnStr);
+  try {
+    const existing = await pg2.all(`SELECT 1 FROM pg_database WHERE datname = $1`, service);
+    if (existing.length === 0) {
+      await pg2.exec(`CREATE DATABASE "${service}"`);
+      return true;
+    }
+    return false;
+  } finally {
+    await pg2.close();
+  }
+}
+async function ensureAllPgDatabases() {
+  const { discoverServices: discoverServices2 } = await Promise.resolve().then(() => (init_discover(), exports_discover));
+  const services = discoverServices2();
+  const results = [];
+  for (const service of services) {
+    try {
+      const created = await ensurePgDatabase(service);
+      results.push({ service, created });
+    } catch (err) {
+      results.push({ service, created: false, error: err?.message ?? String(err) });
+    }
+  }
+  return results;
+}
+function registerCloudTools(server, serviceName) {
+  server.tool(`${serviceName}_cloud_status`, "Show cloud configuration and connection health", {}, async () => {
+    const config = getCloudConfig();
+    const lines = [
+      `Mode: ${config.mode}`,
+      `Service: ${serviceName}`,
+      `RDS Host: ${config.rds.host || "(not configured)"}`
+    ];
+    if (config.rds.host && config.rds.username) {
+      try {
+        const pg2 = new PgAdapterAsync(getConnectionString("postgres"));
+        await pg2.get("SELECT 1 as ok");
+        lines.push("PostgreSQL: connected");
+        await pg2.close();
+      } catch (err) {
+        lines.push(`PostgreSQL: failed \u2014 ${err?.message}`);
+      }
+    }
+    return { content: [{ type: "text", text: lines.join(`
+`) }] };
+  });
+  server.tool(`${serviceName}_cloud_push`, "Push local data to cloud PostgreSQL", {
+    tables: exports_external.string().optional().describe("Comma-separated table names (default: all)")
+  }, async ({ tables: tablesStr }) => {
+    const config = getCloudConfig();
+    if (config.mode === "local") {
+      return {
+        content: [
+          { type: "text", text: "Error: cloud mode not configured." }
+        ],
+        isError: true
+      };
+    }
+    const local = new SqliteAdapter(getDbPath(serviceName));
+    const cloud = new PgAdapterAsync(getConnectionString(serviceName));
+    const tableList = tablesStr ? tablesStr.split(",").map((t) => t.trim()) : listSqliteTables(local);
+    const results = await syncPush(local, cloud, { tables: tableList });
+    local.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).` }]
+    };
+  });
+  server.tool(`${serviceName}_cloud_pull`, "Pull cloud PostgreSQL data to local", {
+    tables: exports_external.string().optional().describe("Comma-separated table names (default: all)")
+  }, async ({ tables: tablesStr }) => {
+    const config = getCloudConfig();
+    if (config.mode === "local") {
+      return {
+        content: [
+          { type: "text", text: "Error: cloud mode not configured." }
+        ],
+        isError: true
+      };
+    }
+    const local = new SqliteAdapter(getDbPath(serviceName));
+    const cloud = new PgAdapterAsync(getConnectionString(serviceName));
+    let tableList;
+    if (tablesStr) {
+      tableList = tablesStr.split(",").map((t) => t.trim());
+    } else {
+      try {
+        tableList = await listPgTables(cloud);
+      } catch {
+        local.close();
+        await cloud.close();
+        return {
+          content: [
+            { type: "text", text: "Error: failed to list cloud tables." }
+          ],
+          isError: true
+        };
+      }
+    }
+    const results = await syncPull(cloud, local, { tables: tableList });
+    local.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).` }]
+    };
+  });
+  server.tool(`${serviceName}_cloud_feedback`, "Send feedback for this service", {
+    message: exports_external.string().describe("Feedback message"),
+    email: exports_external.string().optional().describe("Contact email")
+  }, async ({ message, email }) => {
+    const db = createDatabase({ service: "cloud" });
+    const result = await sendFeedback({ service: serviceName, message, email }, db);
+    db.close();
+    return {
+      content: [
+        {
+          type: "text",
+          text: result.sent ? `Feedback sent (id: ${result.id})` : `Saved locally (id: ${result.id}): ${result.error}`
+        }
+      ]
+    };
+  });
+}
 function registerCloudCommands(program2, serviceName) {
   const cloudCmd = program2.command("cloud").description("Cloud sync and feedback commands");
   cloudCmd.command("status").description("Show cloud config and connection health").action(async () => {
@@ -3827,7 +4889,13 @@ CREATE TABLE IF NOT EXISTS feedback (
   email TEXT DEFAULT '',
   machine_id TEXT DEFAULT '',
   created_at TEXT DEFAULT (datetime('now'))
-)`, AUTO_SYNC_CONFIG_PATH, CONFIG_DIR2;
+)`, 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'
+)`, AUTO_SYNC_CONFIG_PATH, DEFAULT_AUTO_SYNC_CONFIG, cleanupHandlers, signalHandlersInstalled = false, SERVICE_NAME = "hasna-cloud-sync", CONFIG_DIR2;
 var init_dist = __esm(() => {
   __create2 = Object.create;
   __getProtoOf2 = Object.getPrototypeOf;
@@ -11895,6 +12963,11 @@ See https://www.postgresql.org/docs/current/libpq-ssl.html for libpq SSL mode de
   init_config();
   init_discover();
   AUTO_SYNC_CONFIG_PATH = join4(homedir4(), ".hasna", "cloud", "config.json");
+  DEFAULT_AUTO_SYNC_CONFIG = {
+    auto_sync_on_start: true,
+    auto_sync_on_stop: true
+  };
+  cleanupHandlers = [];
   init_config();
   init_adapter();
   init_dotfile();
@@ -11921,19 +12994,19 @@ __export(exports_database, {
   getConnectorsHome: () => getConnectorsHome,
   closeDatabase: () => closeDatabase
 });
-import { join as join5 } from "path";
+import { join as join7 } from "path";
 import { homedir as homedir6 } from "os";
-import { mkdirSync as mkdirSync3, existsSync as existsSync4, readdirSync as readdirSync3, copyFileSync as copyFileSync2, statSync } from "fs";
+import { mkdirSync as mkdirSync4, existsSync as existsSync7, readdirSync as readdirSync4, copyFileSync as copyFileSync2, statSync } from "fs";
 function getConnectorsHome() {
   const home = process.env["HOME"] || process.env["USERPROFILE"] || homedir6();
-  const newDir = join5(home, ".hasna", "connectors");
-  const oldDir = join5(home, ".connectors");
-  if (existsSync4(oldDir) && !existsSync4(newDir)) {
-    mkdirSync3(newDir, { recursive: true });
+  const newDir = join7(home, ".hasna", "connectors");
+  const oldDir = join7(home, ".connectors");
+  if (existsSync7(oldDir) && !existsSync7(newDir)) {
+    mkdirSync4(newDir, { recursive: true });
     try {
-      for (const file of readdirSync3(oldDir)) {
-        const oldPath = join5(oldDir, file);
-        const newPath = join5(newDir, file);
+      for (const file of readdirSync4(oldDir)) {
+        const oldPath = join7(oldDir, file);
+        const newPath = join7(newDir, file);
         try {
           if (statSync(oldPath).isFile()) {
             copyFileSync2(oldPath, newPath);
@@ -11942,14 +13015,14 @@ function getConnectorsHome() {
       }
     } catch {}
   }
-  mkdirSync3(newDir, { recursive: true });
+  mkdirSync4(newDir, { recursive: true });
   return newDir;
 }
 function getDatabase(path) {
   if (_db)
     return _db;
   const dbPath = path ?? DB_PATH;
-  mkdirSync3(join5(dbPath, ".."), { recursive: true });
+  mkdirSync4(join7(dbPath, ".."), { recursive: true });
   _db = new SqliteAdapter(dbPath);
   _db.run("PRAGMA journal_mode = WAL");
   migrate(_db);
@@ -12075,29 +13148,29 @@ var DB_DIR, DB_PATH, _db = null;
 var init_database = __esm(() => {
   init_dist();
   DB_DIR = getConnectorsHome();
-  DB_PATH = join5(DB_DIR, "connectors.db");
+  DB_PATH = join7(DB_DIR, "connectors.db");
 });
 
 // src/lib/llm.ts
-import { existsSync as existsSync6, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync5 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync6 } from "fs";
+import { join as join9 } from "path";
 function getLlmConfigPath() {
-  return join7(getConnectorsHome(), "llm.json");
+  return join9(getConnectorsHome(), "llm.json");
 }
 function getLlmConfig() {
   const path = getLlmConfigPath();
-  if (!existsSync6(path))
+  if (!existsSync9(path))
     return null;
   try {
-    return JSON.parse(readFileSync2(path, "utf-8"));
+    return JSON.parse(readFileSync3(path, "utf-8"));
   } catch {
     return null;
   }
 }
 function saveLlmConfig(config) {
   const dir = getConnectorsHome();
-  mkdirSync5(dir, { recursive: true });
-  writeFileSync2(getLlmConfigPath(), JSON.stringify(config, null, 2));
+  mkdirSync6(dir, { recursive: true });
+  writeFileSync3(getLlmConfigPath(), JSON.stringify(config, null, 2));
 }
 function setLlmStrip(enabled) {
   const config = getLlmConfig();
@@ -12372,7 +13445,8 @@ var exports_scheduler = {};
 __export(exports_scheduler, {
   triggerJob: () => triggerJob,
   stopScheduler: () => stopScheduler,
-  startScheduler: () => startScheduler
+  startScheduler: () => startScheduler,
+  cronMatches: () => cronMatches
 });
 import { spawn } from "child_process";
 function cronMatches(cron, d) {
@@ -12610,8 +13684,8 @@ var init_synonyms = __esm(() => {
 });
 
 // src/lib/registry.ts
-import { existsSync as existsSync7, readFileSync as readFileSync3 } from "fs";
-import { join as join8, dirname as dirname2 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync5 } from "fs";
+import { join as join10, dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
 function getConnectorsByCategory(category) {
   return CONNECTORS.filter((c) => c.category === category);
@@ -12772,17 +13846,17 @@ function loadConnectorVersions() {
   versionsLoaded = true;
   const thisDir = dirname2(fileURLToPath(import.meta.url));
   const candidates = [
-    join8(thisDir, "..", "connectors"),
-    join8(thisDir, "..", "..", "connectors")
+    join10(thisDir, "..", "connectors"),
+    join10(thisDir, "..", "..", "connectors")
   ];
-  const connectorsDir = candidates.find((d) => existsSync7(d));
+  const connectorsDir = candidates.find((d) => existsSync10(d));
   if (!connectorsDir)
     return;
   for (const connector of CONNECTORS) {
     try {
-      const pkgPath = join8(connectorsDir, `connect-${connector.name}`, "package.json");
-      if (existsSync7(pkgPath)) {
-        const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
+      const pkgPath = join10(connectorsDir, `connect-${connector.name}`, "package.json");
+      if (existsSync10(pkgPath)) {
+        const pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
         connector.version = pkg.version || "0.0.0";
       }
     } catch {}
@@ -20356,24 +21430,24 @@ var require_cli_spinners = __commonJS((exports, module) => {
 });
 
 // src/lib/installer.ts
-import { existsSync as existsSync8, cpSync, mkdirSync as mkdirSync6, readFileSync as readFileSync4, writeFileSync as writeFileSync3, readdirSync as readdirSync5, statSync as statSync2, rmSync } from "fs";
-import { join as join9, dirname as dirname3 } from "path";
+import { existsSync as existsSync11, cpSync, mkdirSync as mkdirSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync5, readdirSync as readdirSync6, statSync as statSync2, rmSync } from "fs";
+import { join as join11, dirname as dirname3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function resolveConnectorsDir() {
-  const fromBin = join9(__dirname2, "..", "connectors");
-  if (existsSync8(fromBin))
+  const fromBin = join11(__dirname2, "..", "connectors");
+  if (existsSync11(fromBin))
     return fromBin;
-  const fromSrc = join9(__dirname2, "..", "..", "connectors");
-  if (existsSync8(fromSrc))
+  const fromSrc = join11(__dirname2, "..", "..", "connectors");
+  if (existsSync11(fromSrc))
     return fromSrc;
   return fromBin;
 }
 function getConnectorPath(name) {
   const connectorName = name.startsWith("connect-") ? name : `connect-${name}`;
-  return join9(CONNECTORS_DIR, connectorName);
+  return join11(CONNECTORS_DIR, connectorName);
 }
 function connectorExists(name) {
-  return existsSync8(getConnectorPath(name));
+  return existsSync11(getConnectorPath(name));
 }
 function installConnector(name, options = {}) {
   const { targetDir = process.cwd(), overwrite = false } = options;
@@ -20386,16 +21460,16 @@ function installConnector(name, options = {}) {
   }
   const connectorName = name.startsWith("connect-") ? name : `connect-${name}`;
   const sourcePath = getConnectorPath(name);
-  const destDir = join9(targetDir, ".connectors");
-  const destPath = join9(destDir, connectorName);
-  if (!existsSync8(sourcePath)) {
+  const destDir = join11(targetDir, ".connectors");
+  const destPath = join11(destDir, connectorName);
+  if (!existsSync11(sourcePath)) {
     return {
       connector: name,
       success: false,
       error: `Connector '${name}' not found`
     };
   }
-  if (existsSync8(destPath) && !overwrite) {
+  if (existsSync11(destPath) && !overwrite) {
     return {
       connector: name,
       success: false,
@@ -20404,22 +21478,22 @@ function installConnector(name, options = {}) {
     };
   }
   try {
-    if (!existsSync8(destDir)) {
-      mkdirSync6(destDir, { recursive: true });
+    if (!existsSync11(destDir)) {
+      mkdirSync7(destDir, { recursive: true });
     }
     cpSync(sourcePath, destPath, { recursive: true });
-    const homeCredDir = join9(getConnectorsHome(), connectorName);
-    if (existsSync8(homeCredDir)) {
+    const homeCredDir = join11(getConnectorsHome(), connectorName);
+    if (existsSync11(homeCredDir)) {
       const filesToCopy = ["credentials.json", "current_profile"];
       for (const file of filesToCopy) {
-        const src = join9(homeCredDir, file);
-        if (existsSync8(src)) {
-          cpSync(src, join9(destPath, file));
+        const src = join11(homeCredDir, file);
+        if (existsSync11(src)) {
+          cpSync(src, join11(destPath, file));
         }
       }
-      const profilesDir = join9(homeCredDir, "profiles");
-      if (existsSync8(profilesDir)) {
-        cpSync(profilesDir, join9(destPath, "profiles"), { recursive: true });
+      const profilesDir = join11(homeCredDir, "profiles");
+      if (existsSync11(profilesDir)) {
+        cpSync(profilesDir, join11(destPath, "profiles"), { recursive: true });
       }
     }
     updateConnectorsIndex(destDir);
@@ -20437,8 +21511,8 @@ function installConnector(name, options = {}) {
   }
 }
 function updateConnectorsIndex(connectorsDir) {
-  const indexPath = join9(connectorsDir, "index.ts");
-  const connectors = readdirSync5(connectorsDir).filter((f) => f.startsWith("connect-") && !f.includes("."));
+  const indexPath = join11(connectorsDir, "index.ts");
+  const connectors = readdirSync6(connectorsDir).filter((f) => f.startsWith("connect-") && !f.includes("."));
   const exports = connectors.map((c) => {
     const name = c.replace("connect-", "");
     return `export * as ${name} from './${c}/src/index.js';`;
@@ -20451,24 +21525,24 @@ function updateConnectorsIndex(connectorsDir) {
 
 ${exports}
 `;
-  writeFileSync3(indexPath, content);
+  writeFileSync5(indexPath, content);
 }
 function getInstalledConnectors(targetDir = process.cwd()) {
-  const connectorsDir = join9(targetDir, ".connectors");
-  if (!existsSync8(connectorsDir)) {
+  const connectorsDir = join11(targetDir, ".connectors");
+  if (!existsSync11(connectorsDir)) {
     return [];
   }
-  return readdirSync5(connectorsDir).filter((f) => {
-    const fullPath = join9(connectorsDir, f);
+  return readdirSync6(connectorsDir).filter((f) => {
+    const fullPath = join11(connectorsDir, f);
     return f.startsWith("connect-") && statSync2(fullPath).isDirectory();
   }).map((f) => f.replace("connect-", ""));
 }
 function getConnectorDocs(name) {
   const connectorPath = getConnectorPath(name);
-  const claudeMdPath = join9(connectorPath, "CLAUDE.md");
-  if (!existsSync8(claudeMdPath))
+  const claudeMdPath = join11(connectorPath, "CLAUDE.md");
+  if (!existsSync11(claudeMdPath))
     return null;
-  const raw = readFileSync4(claudeMdPath, "utf-8");
+  const raw = readFileSync6(claudeMdPath, "utf-8");
   return {
     overview: extractSection(raw, "Project Overview"),
     auth: extractSection(raw, "Authentication"),
@@ -20507,9 +21581,9 @@ function parseEnvVarsTable(section) {
 }
 function removeConnector(name, targetDir = process.cwd()) {
   const connectorName = name.startsWith("connect-") ? name : `connect-${name}`;
-  const connectorsDir = join9(targetDir, ".connectors");
-  const connectorPath = join9(connectorsDir, connectorName);
-  if (!existsSync8(connectorPath)) {
+  const connectorsDir = join11(targetDir, ".connectors");
+  const connectorPath = join11(connectorsDir, connectorName);
+  if (!existsSync11(connectorPath)) {
     return false;
   }
   rmSync(connectorPath, { recursive: true });
@@ -20524,13 +21598,13 @@ var init_installer = __esm(() => {
 });
 
 // src/lib/lock.ts
-import { openSync, closeSync, unlinkSync, existsSync as existsSync9, statSync as statSync3 } from "fs";
-import { join as join10 } from "path";
-import { mkdirSync as mkdirSync7 } from "fs";
+import { openSync, closeSync, unlinkSync as unlinkSync2, existsSync as existsSync12, statSync as statSync3 } from "fs";
+import { join as join12 } from "path";
+import { mkdirSync as mkdirSync8 } from "fs";
 function lockPath(connector) {
-  const dir = join10(getConnectorsHome(), `connect-${connector}`);
-  mkdirSync7(dir, { recursive: true });
-  return join10(dir, ".write.lock");
+  const dir = join12(getConnectorsHome(), `connect-${connector}`);
+  mkdirSync8(dir, { recursive: true });
+  return join12(dir, ".write.lock");
 }
 function isStale(path) {
   try {
@@ -20541,9 +21615,9 @@ function isStale(path) {
   }
 }
 function tryAcquire(path) {
-  if (existsSync9(path) && isStale(path)) {
+  if (existsSync12(path) && isStale(path)) {
     try {
-      unlinkSync(path);
+      unlinkSync2(path);
     } catch {}
   }
   try {
@@ -20558,7 +21632,7 @@ function tryAcquire(path) {
 }
 function release(path) {
   try {
-    unlinkSync(path);
+    unlinkSync2(path);
   } catch {}
 }
 async function withWriteLock(connector, fn) {
@@ -20590,9 +21664,9 @@ var init_lock = __esm(() => {
 });
 
 // src/server/auth.ts
-import { existsSync as existsSync10, readFileSync as readFileSync5, writeFileSync as writeFileSync4, mkdirSync as mkdirSync8, readdirSync as readdirSync6, rmSync as rmSync2, statSync as statSync4 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync7, writeFileSync as writeFileSync6, mkdirSync as mkdirSync9, readdirSync as readdirSync7, rmSync as rmSync2, statSync as statSync4 } from "fs";
 import { randomBytes } from "crypto";
-import { join as join11 } from "path";
+import { join as join13 } from "path";
 function getAuthType(name) {
   const docs = getConnectorDocs(name);
   if (!docs?.auth)
@@ -20606,14 +21680,14 @@ function getAuthType(name) {
 }
 function getConnectorConfigDir(name) {
   const connectorName = name.startsWith("connect-") ? name : `connect-${name}`;
-  return join11(getConnectorsHome(), connectorName);
+  return join13(getConnectorsHome(), connectorName);
 }
 function getCurrentProfile(name) {
   const configDir = getConnectorConfigDir(name);
-  const currentProfileFile = join11(configDir, "current_profile");
-  if (existsSync10(currentProfileFile)) {
+  const currentProfileFile = join13(configDir, "current_profile");
+  if (existsSync13(currentProfileFile)) {
     try {
-      return readFileSync5(currentProfileFile, "utf-8").trim() || "default";
+      return readFileSync7(currentProfileFile, "utf-8").trim() || "default";
     } catch {
       return "default";
     }
@@ -20625,16 +21699,16 @@ function loadProfileConfig(name) {
   const profile = getCurrentProfile(name);
   let flatConfig = {};
   let dirConfig = {};
-  const profileFile = join11(configDir, "profiles", `${profile}.json`);
-  if (existsSync10(profileFile)) {
+  const profileFile = join13(configDir, "profiles", `${profile}.json`);
+  if (existsSync13(profileFile)) {
     try {
-      flatConfig = JSON.parse(readFileSync5(profileFile, "utf-8"));
+      flatConfig = JSON.parse(readFileSync7(profileFile, "utf-8"));
     } catch {}
   }
-  const profileDirConfig = join11(configDir, "profiles", profile, "config.json");
-  if (existsSync10(profileDirConfig)) {
+  const profileDirConfig = join13(configDir, "profiles", profile, "config.json");
+  if (existsSync13(profileDirConfig)) {
     try {
-      dirConfig = JSON.parse(readFileSync5(profileDirConfig, "utf-8"));
+      dirConfig = JSON.parse(readFileSync7(profileDirConfig, "utf-8"));
     } catch {}
   }
   if (Object.keys(flatConfig).length === 0 && Object.keys(dirConfig).length === 0) {
@@ -20645,10 +21719,10 @@ function loadProfileConfig(name) {
 function loadTokens(name) {
   const configDir = getConnectorConfigDir(name);
   const profile = getCurrentProfile(name);
-  const tokensFile = join11(configDir, "profiles", profile, "tokens.json");
-  if (existsSync10(tokensFile)) {
+  const tokensFile = join13(configDir, "profiles", profile, "tokens.json");
+  if (existsSync13(tokensFile)) {
     try {
-      return JSON.parse(readFileSync5(tokensFile, "utf-8"));
+      return JSON.parse(readFileSync7(tokensFile, "utf-8"));
     } catch {
       return null;
     }
@@ -20715,43 +21789,43 @@ function _saveApiKey(name, key, field) {
   const profile = getCurrentProfile(name);
   const keyField = field || guessKeyField(name);
   if (keyField === "clientId" || keyField === "clientSecret") {
-    const credentialsFile = join11(configDir, "credentials.json");
-    mkdirSync8(configDir, { recursive: true });
+    const credentialsFile = join13(configDir, "credentials.json");
+    mkdirSync9(configDir, { recursive: true });
     let creds = {};
-    if (existsSync10(credentialsFile)) {
+    if (existsSync13(credentialsFile)) {
       try {
-        creds = JSON.parse(readFileSync5(credentialsFile, "utf-8"));
+        creds = JSON.parse(readFileSync7(credentialsFile, "utf-8"));
       } catch {}
     }
     creds[keyField] = key;
-    writeFileSync4(credentialsFile, JSON.stringify(creds, null, 2));
+    writeFileSync6(credentialsFile, JSON.stringify(creds, null, 2));
     return;
   }
-  const profileFile = join11(configDir, "profiles", `${profile}.json`);
-  const profileDir = join11(configDir, "profiles", profile);
-  if (existsSync10(profileFile)) {
+  const profileFile = join13(configDir, "profiles", `${profile}.json`);
+  const profileDir = join13(configDir, "profiles", profile);
+  if (existsSync13(profileFile)) {
     let config = {};
     try {
-      config = JSON.parse(readFileSync5(profileFile, "utf-8"));
+      config = JSON.parse(readFileSync7(profileFile, "utf-8"));
     } catch {}
     config[keyField] = key;
-    writeFileSync4(profileFile, JSON.stringify(config, null, 2));
+    writeFileSync6(profileFile, JSON.stringify(config, null, 2));
     return;
   }
-  if (existsSync10(profileDir)) {
-    const configFile = join11(profileDir, "config.json");
+  if (existsSync13(profileDir)) {
+    const configFile = join13(profileDir, "config.json");
     let config = {};
-    if (existsSync10(configFile)) {
+    if (existsSync13(configFile)) {
       try {
-        config = JSON.parse(readFileSync5(configFile, "utf-8"));
+        config = JSON.parse(readFileSync7(configFile, "utf-8"));
       } catch {}
     }
     config[keyField] = key;
-    writeFileSync4(configFile, JSON.stringify(config, null, 2));
+    writeFileSync6(configFile, JSON.stringify(config, null, 2));
     return;
   }
-  mkdirSync8(profileDir, { recursive: true });
-  writeFileSync4(join11(profileDir, "config.json"), JSON.stringify({ [keyField]: key }, null, 2));
+  mkdirSync9(profileDir, { recursive: true });
+  writeFileSync6(join13(profileDir, "config.json"), JSON.stringify({ [keyField]: key }, null, 2));
 }
 function guessKeyField(name) {
   const docs = getConnectorDocs(name);
@@ -20769,10 +21843,10 @@ function guessKeyField(name) {
 }
 function getOAuthConfig(name) {
   const configDir = getConnectorConfigDir(name);
-  const credentialsFile = join11(configDir, "credentials.json");
-  if (existsSync10(credentialsFile)) {
+  const credentialsFile = join13(configDir, "credentials.json");
+  if (existsSync13(credentialsFile)) {
     try {
-      const creds = JSON.parse(readFileSync5(credentialsFile, "utf-8"));
+      const creds = JSON.parse(readFileSync7(credentialsFile, "utf-8"));
       return { clientId: creds.clientId, clientSecret: creds.clientSecret };
     } catch {}
   }
@@ -20851,10 +21925,10 @@ async function exchangeOAuthCode(name, code, redirectUri) {
 function saveOAuthTokens(name, tokens) {
   const configDir = getConnectorConfigDir(name);
   const profile = getCurrentProfile(name);
-  const profileDir = join11(configDir, "profiles", profile);
-  mkdirSync8(profileDir, { recursive: true });
-  const tokensFile = join11(profileDir, "tokens.json");
-  writeFileSync4(tokensFile, JSON.stringify(tokens, null, 2), { mode: 384 });
+  const profileDir = join13(configDir, "profiles", profile);
+  mkdirSync9(profileDir, { recursive: true });
+  const tokensFile = join13(profileDir, "tokens.json");
+  writeFileSync6(tokensFile, JSON.stringify(tokens, null, 2), { mode: 384 });
 }
 async function refreshOAuthToken(name) {
   return withWriteLock(name, () => _refreshOAuthToken(name));
@@ -20896,14 +21970,14 @@ async function _refreshOAuthToken(name) {
 }
 function listProfiles(name) {
   const configDir = getConnectorConfigDir(name);
-  const profilesDir = join11(configDir, "profiles");
-  if (!existsSync10(profilesDir))
+  const profilesDir = join13(configDir, "profiles");
+  if (!existsSync13(profilesDir))
     return ["default"];
   const seen = new Set;
   try {
-    const entries = readdirSync6(profilesDir);
+    const entries = readdirSync7(profilesDir);
     for (const entry of entries) {
-      const fullPath = join11(profilesDir, entry);
+      const fullPath = join13(profilesDir, entry);
       const stat = statSync4(fullPath);
       if (stat.isDirectory()) {
         seen.add(entry);
@@ -20917,24 +21991,24 @@ function listProfiles(name) {
 }
 function switchProfile(name, profile) {
   const configDir = getConnectorConfigDir(name);
-  mkdirSync8(configDir, { recursive: true });
-  writeFileSync4(join11(configDir, "current_profile"), profile);
+  mkdirSync9(configDir, { recursive: true });
+  writeFileSync6(join13(configDir, "current_profile"), profile);
 }
 function deleteProfile(name, profile) {
   if (profile === "default")
     return false;
   const configDir = getConnectorConfigDir(name);
-  const profilesDir = join11(configDir, "profiles");
-  const profileFile = join11(profilesDir, `${profile}.json`);
-  if (existsSync10(profileFile)) {
+  const profilesDir = join13(configDir, "profiles");
+  const profileFile = join13(profilesDir, `${profile}.json`);
+  if (existsSync13(profileFile)) {
     rmSync2(profileFile);
     if (getCurrentProfile(name) === profile) {
       switchProfile(name, "default");
     }
     return true;
   }
-  const profileDir = join11(profilesDir, profile);
-  if (existsSync10(profileDir)) {
+  const profileDir = join13(profilesDir, profile);
+  if (existsSync13(profileDir)) {
     rmSync2(profileDir, { recursive: true });
     if (getCurrentProfile(name) === profile) {
       switchProfile(name, "default");
@@ -21201,8 +22275,8 @@ var exports_serve = {};
 __export(exports_serve, {
   startServer: () => startServer
 });
-import { existsSync as existsSync12, readdirSync as readdirSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync5, mkdirSync as mkdirSync9 } from "fs";
-import { join as join13, dirname as dirname5, extname, basename } from "path";
+import { existsSync as existsSync15, readdirSync as readdirSync8, readFileSync as readFileSync8, writeFileSync as writeFileSync7, mkdirSync as mkdirSync10 } from "fs";
+import { join as join15, dirname as dirname5, extname, basename } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 function logActivity(action, connector, detail) {
   activityLog.unshift({ action, connector, timestamp: Date.now(), detail });
@@ -21214,20 +22288,20 @@ function resolveDashboardDir() {
   const candidates = [];
   try {
     const scriptDir = dirname5(fileURLToPath4(import.meta.url));
-    candidates.push(join13(scriptDir, "..", "dashboard", "dist"));
-    candidates.push(join13(scriptDir, "..", "..", "dashboard", "dist"));
+    candidates.push(join15(scriptDir, "..", "dashboard", "dist"));
+    candidates.push(join15(scriptDir, "..", "..", "dashboard", "dist"));
   } catch {}
   if (process.argv[1]) {
     const mainDir = dirname5(process.argv[1]);
-    candidates.push(join13(mainDir, "..", "dashboard", "dist"));
-    candidates.push(join13(mainDir, "..", "..", "dashboard", "dist"));
+    candidates.push(join15(mainDir, "..", "dashboard", "dist"));
+    candidates.push(join15(mainDir, "..", "..", "dashboard", "dist"));
   }
-  candidates.push(join13(process.cwd(), "dashboard", "dist"));
+  candidates.push(join15(process.cwd(), "dashboard", "dist"));
   for (const candidate of candidates) {
-    if (existsSync12(candidate))
+    if (existsSync15(candidate))
       return candidate;
   }
-  return join13(process.cwd(), "dashboard", "dist");
+  return join15(process.cwd(), "dashboard", "dist");
 }
 function json(data, status = 200, port) {
   return new Response(JSON.stringify(data), {
@@ -21312,7 +22386,7 @@ function oauthPage(type, title, message, hint, extra) {
   </body></html>`;
 }
 function serveStaticFile(filePath) {
-  if (!existsSync12(filePath))
+  if (!existsSync15(filePath))
     return null;
   const ext = extname(filePath);
   const contentType = MIME_TYPES[ext] || "application/octet-stream";
@@ -21336,7 +22410,7 @@ async function startServer(requestedPort, options) {
   const shouldOpen = options?.open ?? true;
   loadConnectorVersions();
   const dashboardDir = resolveDashboardDir();
-  const dashboardExists = existsSync12(dashboardDir);
+  const dashboardExists = existsSync15(dashboardDir);
   if (!dashboardExists) {
     console.error(`
 Dashboard not found at: ${dashboardDir}`);
@@ -21653,12 +22727,12 @@ Dashboard not found at: ${dashboardDir}`);
           return json({ error: "Invalid connector name" }, 400, port);
         try {
           const profiles = listProfiles(name);
-          const configDir = join13(getConnectorsHome(), name.startsWith("connect-") ? name : `connect-${name}`);
-          const currentProfileFile = join13(configDir, "current_profile");
+          const configDir = join15(getConnectorsHome(), name.startsWith("connect-") ? name : `connect-${name}`);
+          const currentProfileFile = join15(configDir, "current_profile");
           let current = "default";
-          if (existsSync12(currentProfileFile)) {
+          if (existsSync15(currentProfileFile)) {
             try {
-              current = readFileSync6(currentProfileFile, "utf-8").trim() || "default";
+              current = readFileSync8(currentProfileFile, "utf-8").trim() || "default";
             } catch {}
           }
           return json({ current, profiles }, 200, port);
@@ -21707,30 +22781,30 @@ Dashboard not found at: ${dashboardDir}`);
         try {
           const connectDir = getConnectorsHome();
           const result = {};
-          if (existsSync12(connectDir)) {
-            const entries = readdirSync7(connectDir, { withFileTypes: true });
+          if (existsSync15(connectDir)) {
+            const entries = readdirSync8(connectDir, { withFileTypes: true });
             for (const entry of entries) {
               if (!entry.isDirectory() || !entry.name.startsWith("connect-"))
                 continue;
               const connectorName = entry.name.replace(/^connect-/, "");
-              const profilesDir = join13(connectDir, entry.name, "profiles");
-              if (!existsSync12(profilesDir))
+              const profilesDir = join15(connectDir, entry.name, "profiles");
+              if (!existsSync15(profilesDir))
                 continue;
               const profiles = {};
-              const profileEntries = readdirSync7(profilesDir, { withFileTypes: true });
+              const profileEntries = readdirSync8(profilesDir, { withFileTypes: true });
               for (const pEntry of profileEntries) {
                 if (pEntry.isFile() && pEntry.name.endsWith(".json")) {
                   const profileName = basename(pEntry.name, ".json");
                   try {
-                    const config = JSON.parse(readFileSync6(join13(profilesDir, pEntry.name), "utf-8"));
+                    const config = JSON.parse(readFileSync8(join15(profilesDir, pEntry.name), "utf-8"));
                     profiles[profileName] = config;
                   } catch {}
                 }
                 if (pEntry.isDirectory()) {
-                  const configPath = join13(profilesDir, pEntry.name, "config.json");
-                  if (existsSync12(configPath)) {
+                  const configPath = join15(profilesDir, pEntry.name, "config.json");
+                  if (existsSync15(configPath)) {
                     try {
-                      const config = JSON.parse(readFileSync6(configPath, "utf-8"));
+                      const config = JSON.parse(readFileSync8(configPath, "utf-8"));
                       profiles[pEntry.name] = config;
                     } catch {}
                   }
@@ -21771,14 +22845,14 @@ Dashboard not found at: ${dashboardDir}`);
               continue;
             if (!data.profiles || typeof data.profiles !== "object")
               continue;
-            const connectorDir = join13(connectDir, `connect-${connectorName}`);
-            const profilesDir = join13(connectorDir, "profiles");
+            const connectorDir = join15(connectDir, `connect-${connectorName}`);
+            const profilesDir = join15(connectorDir, "profiles");
             for (const [profileName, config] of Object.entries(data.profiles)) {
               if (!config || typeof config !== "object")
                 continue;
-              mkdirSync9(profilesDir, { recursive: true });
-              const profileFile = join13(profilesDir, `${profileName}.json`);
-              writeFileSync5(profileFile, JSON.stringify(config, null, 2));
+              mkdirSync10(profilesDir, { recursive: true });
+              const profileFile = join15(profilesDir, `${profileName}.json`);
+              writeFileSync7(profileFile, JSON.stringify(config, null, 2));
               imported++;
             }
           }
@@ -21833,12 +22907,12 @@ Dashboard not found at: ${dashboardDir}`);
       }
       if (dashboardExists && (method === "GET" || method === "HEAD")) {
         if (path !== "/") {
-          const filePath = join13(dashboardDir, path);
+          const filePath = join15(dashboardDir, path);
           const res2 = serveStaticFile(filePath);
           if (res2)
             return res2;
         }
-        const indexPath = join13(dashboardDir, "index.html");
+        const indexPath = join15(dashboardDir, "index.html");
         const res = serveStaticFile(indexPath);
         if (res)
           return res;
@@ -21923,7 +22997,7 @@ import chalk2 from "chalk";
 // package.json
 var package_default = {
   name: "@hasna/connectors",
-  version: "1.3.11",
+  version: "1.3.12",
   description: "Open source connector library - Install API connectors with a single command",
   type: "module",
   bin: {
@@ -23490,9 +24564,9 @@ init_registry();
 init_installer();
 init_auth();
 init_database();
-import { readdirSync as readdirSync8, existsSync as existsSync13, statSync as statSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync6, mkdirSync as mkdirSync10 } from "fs";
+import { readdirSync as readdirSync9, existsSync as existsSync16, statSync as statSync5, readFileSync as readFileSync9, writeFileSync as writeFileSync8, mkdirSync as mkdirSync11 } from "fs";
 import { homedir as homedir8 } from "os";
-import { join as join14, relative as relative2 } from "path";
+import { join as join16, relative as relative2 } from "path";
 
 // src/lib/test-endpoints.ts
 var TEST_ENDPOINTS = {
@@ -23693,17 +24767,17 @@ var TEST_ENDPOINTS = {
 import { createInterface } from "readline";
 
 // src/lib/runner.ts
-import { existsSync as existsSync11 } from "fs";
-import { join as join12, dirname as dirname4 } from "path";
+import { existsSync as existsSync14 } from "fs";
+import { join as join14, dirname as dirname4 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { spawn as spawn3 } from "child_process";
 var __dirname3 = dirname4(fileURLToPath3(import.meta.url));
 function resolveConnectorsDir2() {
-  const fromBin = join12(__dirname3, "..", "connectors");
-  if (existsSync11(fromBin))
+  const fromBin = join14(__dirname3, "..", "connectors");
+  if (existsSync14(fromBin))
     return fromBin;
-  const fromSrc = join12(__dirname3, "..", "..", "connectors");
-  if (existsSync11(fromSrc))
+  const fromSrc = join14(__dirname3, "..", "..", "connectors");
+  if (existsSync14(fromSrc))
     return fromSrc;
   return fromBin;
 }
@@ -23743,9 +24817,9 @@ function buildEnvWithCredentials(connectorName, baseEnv) {
 }
 function getConnectorCliPath(name) {
   const safeName = name.replace(/[^a-z0-9-]/g, "");
-  const connectorDir = join12(CONNECTORS_DIR2, `connect-${safeName}`);
-  const cliPath = join12(connectorDir, "src", "cli", "index.ts");
-  if (existsSync11(cliPath))
+  const connectorDir = join14(CONNECTORS_DIR2, `connect-${safeName}`);
+  const cliPath = join14(connectorDir, "src", "cli", "index.ts");
+  if (existsSync14(cliPath))
     return cliPath;
   return null;
 }
@@ -23858,8 +24932,8 @@ Run 'connectors --help' for full usage.`);
 });
 function listFilesRecursive(dir, base = dir) {
   const files = [];
-  for (const entry of readdirSync8(dir)) {
-    const fullPath = join14(dir, entry);
+  for (const entry of readdirSync9(dir)) {
+    const fullPath = join16(dir, entry);
     if (statSync5(fullPath).isDirectory()) {
       files.push(...listFilesRecursive(fullPath, base));
     } else {
@@ -23908,7 +24982,7 @@ program2.command("install").alias("add").argument("[connectors...]", "Connectors
   }
   if (options.dryRun) {
     const installed = getInstalledConnectors();
-    const destDir = join14(process.cwd(), ".connectors");
+    const destDir = join16(process.cwd(), ".connectors");
     const actions = [];
     for (const name of connectors) {
       if (!/^[a-z0-9-]+$/.test(name)) {
@@ -23926,7 +25000,7 @@ program2.command("install").alias("add").argument("[connectors...]", "Connectors
       }
       const connectorDirName = name.startsWith("connect-") ? name : `connect-${name}`;
       const sourcePath = getConnectorPath(name);
-      const destPath = join14(destDir, connectorDirName);
+      const destPath = join16(destDir, connectorDirName);
       const alreadyInstalled = installed.includes(name);
       const files = listFilesRecursive(sourcePath);
       const importLine = `export * as ${name} from './${connectorDirName}/src/index.js';`;
@@ -24446,11 +25520,11 @@ program2.command("status").option("--json", "Output as JSON", false).description
   function buildStatusEntry(name, source) {
     const auth = getAuthStatus(name);
     const connectorName = name.startsWith("connect-") ? name : `connect-${name}`;
-    const currentProfileFile = join14(configDir, connectorName, "current_profile");
+    const currentProfileFile = join16(configDir, connectorName, "current_profile");
     let profile = "default";
-    if (existsSync13(currentProfileFile)) {
+    if (existsSync16(currentProfileFile)) {
       try {
-        profile = readFileSync7(currentProfileFile, "utf-8").trim() || "default";
+        profile = readFileSync9(currentProfileFile, "utf-8").trim() || "default";
       } catch {}
     }
     let expiryLabel = null;
@@ -24486,13 +25560,13 @@ program2.command("status").option("--json", "Output as JSON", false).description
     seen.add(name);
     allStatuses.push(buildStatusEntry(name, "project"));
   }
-  if (existsSync13(configDir)) {
+  if (existsSync16(configDir)) {
     try {
-      const globalDirs = readdirSync8(configDir).filter((f) => {
+      const globalDirs = readdirSync9(configDir).filter((f) => {
         if (!f.startsWith("connect-"))
           return false;
         try {
-          return statSync5(join14(configDir, f)).isDirectory();
+          return statSync5(join16(configDir, f)).isDirectory();
         } catch {
           return false;
         }
@@ -24861,11 +25935,11 @@ program2.command("init").option("--json", "Output presets and suggestions as JSO
   let configuredCount = 0;
   const configuredNames = [];
   try {
-    if (existsSync13(connectorsHome)) {
-      const entries = readdirSync8(connectorsHome).filter((e) => e.startsWith("connect-") && statSync5(join14(connectorsHome, e)).isDirectory());
+    if (existsSync16(connectorsHome)) {
+      const entries = readdirSync9(connectorsHome).filter((e) => e.startsWith("connect-") && statSync5(join16(connectorsHome, e)).isDirectory());
       for (const entry of entries) {
-        const profilesDir = join14(connectorsHome, entry, "profiles");
-        if (existsSync13(profilesDir)) {
+        const profilesDir = join16(connectorsHome, entry, "profiles");
+        if (existsSync16(profilesDir)) {
           configuredCount++;
           configuredNames.push(entry.replace(/^connect-/, ""));
         }
@@ -24965,42 +26039,42 @@ function redactSecrets(obj) {
 program2.command("export").option("-o, --output <file>", "Write to file instead of stdout").option("--include-secrets", "Include secrets in plaintext (dangerous \u2014 use only for backup/restore)").description("Export all connector credentials as JSON backup").action((options) => {
   const connectDir = getConnectorsHome();
   const result = {};
-  if (existsSync13(connectDir)) {
-    for (const entry of readdirSync8(connectDir)) {
-      const entryPath = join14(connectDir, entry);
+  if (existsSync16(connectDir)) {
+    for (const entry of readdirSync9(connectDir)) {
+      const entryPath = join16(connectDir, entry);
       if (!statSync5(entryPath).isDirectory() || !entry.startsWith("connect-"))
         continue;
       const connectorName = entry.replace(/^connect-/, "");
       let credentials = undefined;
-      const credentialsPath = join14(entryPath, "credentials.json");
-      if (existsSync13(credentialsPath)) {
+      const credentialsPath = join16(entryPath, "credentials.json");
+      if (existsSync16(credentialsPath)) {
         try {
-          credentials = JSON.parse(readFileSync7(credentialsPath, "utf-8"));
+          credentials = JSON.parse(readFileSync9(credentialsPath, "utf-8"));
         } catch {}
       }
-      const profilesDir = join14(entryPath, "profiles");
-      if (!existsSync13(profilesDir) && !credentials)
+      const profilesDir = join16(entryPath, "profiles");
+      if (!existsSync16(profilesDir) && !credentials)
         continue;
       const profiles = {};
-      if (existsSync13(profilesDir)) {
-        for (const pEntry of readdirSync8(profilesDir)) {
-          const pPath = join14(profilesDir, pEntry);
+      if (existsSync16(profilesDir)) {
+        for (const pEntry of readdirSync9(profilesDir)) {
+          const pPath = join16(profilesDir, pEntry);
           if (statSync5(pPath).isFile() && pEntry.endsWith(".json")) {
             try {
-              profiles[pEntry.replace(/\.json$/, "")] = JSON.parse(readFileSync7(pPath, "utf-8"));
+              profiles[pEntry.replace(/\.json$/, "")] = JSON.parse(readFileSync9(pPath, "utf-8"));
             } catch {}
           } else if (statSync5(pPath).isDirectory()) {
-            const configPath = join14(pPath, "config.json");
-            const tokensPath = join14(pPath, "tokens.json");
+            const configPath = join16(pPath, "config.json");
+            const tokensPath = join16(pPath, "tokens.json");
             let merged = {};
-            if (existsSync13(configPath)) {
+            if (existsSync16(configPath)) {
               try {
-                merged = { ...merged, ...JSON.parse(readFileSync7(configPath, "utf-8")) };
+                merged = { ...merged, ...JSON.parse(readFileSync9(configPath, "utf-8")) };
               } catch {}
             }
-            if (existsSync13(tokensPath)) {
+            if (existsSync16(tokensPath)) {
               try {
-                merged = { ...merged, ...JSON.parse(readFileSync7(tokensPath, "utf-8")) };
+                merged = { ...merged, ...JSON.parse(readFileSync9(tokensPath, "utf-8")) };
               } catch {}
             }
             if (Object.keys(merged).length > 0)
@@ -25021,7 +26095,7 @@ program2.command("export").option("-o, --output <file>", "Write to file instead
   }
   const exportData = JSON.stringify(exportPayload, null, 2);
   if (options.output) {
-    writeFileSync6(options.output, exportData);
+    writeFileSync8(options.output, exportData);
     console.log(chalk2.green(`\u2713 Exported to ${options.output}`));
   } else {
     console.log(exportData);
@@ -25035,7 +26109,7 @@ program2.command("import").argument("<file>", "JSON backup file to import (use -
       chunks.push(chunk.toString());
     raw = chunks.join("");
   } else {
-    if (!existsSync13(file)) {
+    if (!existsSync16(file)) {
       if (options.json) {
         console.log(JSON.stringify({ error: `File not found: ${file}` }));
       } else {
@@ -25044,7 +26118,7 @@ program2.command("import").argument("<file>", "JSON backup file to import (use -
       process.exit(1);
       return;
     }
-    raw = readFileSync7(file, "utf-8");
+    raw = readFileSync9(file, "utf-8");
   }
   let data;
   try {
@@ -25072,20 +26146,20 @@ program2.command("import").argument("<file>", "JSON backup file to import (use -
   for (const [connectorName, connData] of Object.entries(data.connectors)) {
     if (!/^[a-z0-9-]+$/.test(connectorName))
       continue;
-    const connectorDir = join14(connectDir, `connect-${connectorName}`);
+    const connectorDir = join16(connectDir, `connect-${connectorName}`);
     if (connData.credentials && typeof connData.credentials === "object") {
-      mkdirSync10(connectorDir, { recursive: true });
-      writeFileSync6(join14(connectorDir, "credentials.json"), JSON.stringify(connData.credentials, null, 2));
+      mkdirSync11(connectorDir, { recursive: true });
+      writeFileSync8(join16(connectorDir, "credentials.json"), JSON.stringify(connData.credentials, null, 2));
       imported++;
     }
     if (!connData.profiles || typeof connData.profiles !== "object")
       continue;
-    const profilesDir = join14(connectorDir, "profiles");
+    const profilesDir = join16(connectorDir, "profiles");
     for (const [profileName, config] of Object.entries(connData.profiles)) {
       if (!config || typeof config !== "object")
         continue;
-      mkdirSync10(profilesDir, { recursive: true });
-      writeFileSync6(join14(profilesDir, `${profileName}.json`), JSON.stringify(config, null, 2));
+      mkdirSync11(profilesDir, { recursive: true });
+      writeFileSync8(join16(profilesDir, `${profileName}.json`), JSON.stringify(config, null, 2));
       imported++;
     }
   }
@@ -25096,9 +26170,9 @@ program2.command("import").argument("<file>", "JSON backup file to import (use -
   }
 });
 program2.command("auth-import").option("--json", "Output as JSON", false).option("-d, --dry-run", "Preview what would be imported without copying", false).option("--force", "Overwrite existing files in ~/.hasna/connectors/", false).description("Migrate auth tokens from ~/.connect/ to ~/.hasna/connectors/").action((options) => {
-  const oldBase = join14(homedir8(), ".connect");
+  const oldBase = join16(homedir8(), ".connect");
   const newBase = getConnectorsHome();
-  if (!existsSync13(oldBase)) {
+  if (!existsSync16(oldBase)) {
     if (options.json) {
       console.log(JSON.stringify({ imported: [], skipped: [], error: null, message: "No ~/.connect/ directory found" }));
     } else {
@@ -25106,11 +26180,11 @@ program2.command("auth-import").option("--json", "Output as JSON", false).option
     }
     return;
   }
-  const entries = readdirSync8(oldBase).filter((name) => {
+  const entries = readdirSync9(oldBase).filter((name) => {
     if (!name.startsWith("connect-"))
       return false;
     try {
-      return statSync5(join14(oldBase, name)).isDirectory();
+      return statSync5(join16(oldBase, name)).isDirectory();
     } catch {
       return false;
     }
@@ -25126,8 +26200,8 @@ program2.command("auth-import").option("--json", "Output as JSON", false).option
   const imported = [];
   const skipped = [];
   for (const dirName of entries) {
-    const oldDir = join14(oldBase, dirName);
-    const newDir = join14(newBase, dirName);
+    const oldDir = join16(oldBase, dirName);
+    const newDir = join16(newBase, dirName);
     const connectorName = dirName.replace(/^connect-/, "");
     const allFiles = listFilesRecursive(oldDir);
     const authFiles = allFiles.filter((f) => {
@@ -25138,17 +26212,17 @@ program2.command("auth-import").option("--json", "Output as JSON", false).option
     const copiedFiles = [];
     const skippedFiles = [];
     for (const relFile of authFiles) {
-      const srcPath = join14(oldDir, relFile);
-      const destPath = join14(newDir, relFile);
-      if (existsSync13(destPath) && !options.force) {
+      const srcPath = join16(oldDir, relFile);
+      const destPath = join16(newDir, relFile);
+      if (existsSync16(destPath) && !options.force) {
         skippedFiles.push(relFile);
         continue;
       }
       if (!options.dryRun) {
-        const parentDir = join14(destPath, "..");
-        mkdirSync10(parentDir, { recursive: true });
-        const content = readFileSync7(srcPath);
-        writeFileSync6(destPath, content);
+        const parentDir = join16(destPath, "..");
+        mkdirSync11(parentDir, { recursive: true });
+        const content = readFileSync9(srcPath);
+        writeFileSync8(destPath, content);
       }
       copiedFiles.push(relFile);
     }
@@ -25393,7 +26467,7 @@ program2.command("env").option("-o, --output <file>", "Write to file instead of
 `) + `
 `;
   if (options.output) {
-    writeFileSync6(options.output, output);
+    writeFileSync8(options.output, output);
     console.log(chalk2.green(`\u2713 Written to ${options.output} (${vars.length} variables)`));
   } else {
     console.log(output);
@@ -25435,23 +26509,23 @@ program2.command("whoami").option("--json", "Output as JSON", false).description
       configured++;
     else
       unconfigured++;
-    const connectorConfigDir = join14(configDir, name.startsWith("connect-") ? name : `connect-${name}`);
-    const currentProfileFile = join14(connectorConfigDir, "current_profile");
+    const connectorConfigDir = join16(configDir, name.startsWith("connect-") ? name : `connect-${name}`);
+    const currentProfileFile = join16(connectorConfigDir, "current_profile");
     let profile = "default";
-    if (existsSync13(currentProfileFile)) {
+    if (existsSync16(currentProfileFile)) {
       try {
-        profile = readFileSync7(currentProfileFile, "utf-8").trim() || "default";
+        profile = readFileSync9(currentProfileFile, "utf-8").trim() || "default";
       } catch {}
     }
     connectorDetails.push({ name, configured: auth.configured, authType: auth.type, profile, source: "project" });
   }
-  if (existsSync13(configDir)) {
+  if (existsSync16(configDir)) {
     try {
-      const globalDirs = readdirSync8(configDir).filter((f) => {
+      const globalDirs = readdirSync9(configDir).filter((f) => {
         if (!f.startsWith("connect-"))
           return false;
         try {
-          return statSync5(join14(configDir, f)).isDirectory();
+          return statSync5(join16(configDir, f)).isDirectory();
         } catch {
           return false;
         }
@@ -25465,11 +26539,11 @@ program2.command("whoami").option("--json", "Output as JSON", false).description
           continue;
         seen.add(name);
         configured++;
-        const currentProfileFile = join14(configDir, dir, "current_profile");
+        const currentProfileFile = join16(configDir, dir, "current_profile");
         let profile = "default";
-        if (existsSync13(currentProfileFile)) {
+        if (existsSync16(currentProfileFile)) {
           try {
-            profile = readFileSync7(currentProfileFile, "utf-8").trim() || "default";
+            profile = readFileSync9(currentProfileFile, "utf-8").trim() || "default";
           } catch {}
         }
         connectorDetails.push({ name, configured: true, authType: auth.type, profile, source: "global" });
@@ -25480,7 +26554,7 @@ program2.command("whoami").option("--json", "Output as JSON", false).description
     console.log(JSON.stringify({
       version,
       configDir,
-      configDirExists: existsSync13(configDir),
+      configDirExists: existsSync16(configDir),
       installed: installed.length,
       configured,
       unconfigured,
@@ -25492,7 +26566,7 @@ program2.command("whoami").option("--json", "Output as JSON", false).description
 Connectors Setup
 `));
   console.log(`  Version:      ${chalk2.cyan(version)}`);
-  console.log(`  Config:       ${configDir}${existsSync13(configDir) ? "" : chalk2.dim(" (not created yet)")}`);
+  console.log(`  Config:       ${configDir}${existsSync16(configDir) ? "" : chalk2.dim(" (not created yet)")}`);
   console.log(`  Installed:    ${installed.length} connector${installed.length !== 1 ? "s" : ""}`);
   console.log(`  Configured:   ${chalk2.green(String(configured))} ready, ${unconfigured > 0 ? chalk2.red(String(unconfigured)) : chalk2.dim("0")} need auth`);
   const projectConnectors = connectorDetails.filter((c) => c.source === "project");
@@ -25582,18 +26656,18 @@ Testing connector credentials...
       }
     }
     if (!apiKey) {
-      const connectorConfigDir = join14(getConnectorsHome(), name.startsWith("connect-") ? name : `connect-${name}`);
+      const connectorConfigDir = join16(getConnectorsHome(), name.startsWith("connect-") ? name : `connect-${name}`);
       let currentProfile = "default";
-      const currentProfileFile = join14(connectorConfigDir, "current_profile");
-      if (existsSync13(currentProfileFile)) {
+      const currentProfileFile = join16(connectorConfigDir, "current_profile");
+      if (existsSync16(currentProfileFile)) {
         try {
-          currentProfile = readFileSync7(currentProfileFile, "utf-8").trim() || "default";
+          currentProfile = readFileSync9(currentProfileFile, "utf-8").trim() || "default";
         } catch {}
       }
-      const tokensFile = join14(connectorConfigDir, "profiles", currentProfile, "tokens.json");
-      if (existsSync13(tokensFile)) {
+      const tokensFile = join16(connectorConfigDir, "profiles", currentProfile, "tokens.json");
+      if (existsSync16(tokensFile)) {
         try {
-          const tokens = JSON.parse(readFileSync7(tokensFile, "utf-8"));
+          const tokens = JSON.parse(readFileSync9(tokensFile, "utf-8"));
           const isExpired = tokens.expiresAt && Date.now() >= tokens.expiresAt - 60000;
           if (isExpired && tokens.refreshToken) {
             try {
@@ -25611,19 +26685,19 @@ Testing connector credentials...
         } catch {}
       }
       if (!apiKey) {
-        const profileFile = join14(connectorConfigDir, "profiles", `${currentProfile}.json`);
-        if (existsSync13(profileFile)) {
+        const profileFile = join16(connectorConfigDir, "profiles", `${currentProfile}.json`);
+        if (existsSync16(profileFile)) {
           try {
-            const config = JSON.parse(readFileSync7(profileFile, "utf-8"));
+            const config = JSON.parse(readFileSync9(profileFile, "utf-8"));
             apiKey = Object.values(config).find((v) => typeof v === "string" && v.length > 0);
           } catch {}
         }
       }
       if (!apiKey) {
-        const profileDirConfig = join14(connectorConfigDir, "profiles", currentProfile, "config.json");
-        if (existsSync13(profileDirConfig)) {
+        const profileDirConfig = join16(connectorConfigDir, "profiles", currentProfile, "config.json");
+        if (existsSync16(profileDirConfig)) {
           try {
-            const config = JSON.parse(readFileSync7(profileDirConfig, "utf-8"));
+            const config = JSON.parse(readFileSync9(profileDirConfig, "utf-8"));
             apiKey = Object.values(config).find((v) => typeof v === "string" && v.length > 0);
           } catch {}
         }
@@ -25790,7 +26864,7 @@ Setting up ${meta.displayName}...
   const alreadyInstalled = installed.includes(meta.name);
   let installResult;
   if (alreadyInstalled && !options.overwrite) {
-    installResult = { success: true, path: join14(process.cwd(), ".connectors", `connect-${meta.name}`) };
+    installResult = { success: true, path: join16(process.cwd(), ".connectors", `connect-${meta.name}`) };
     if (!options.json) {
       console.log(`  ${chalk2.green("\u2713")} Already installed`);
     }
@@ -26212,4 +27286,88 @@ llmCmd.command("providers").description("List supported LLM providers").option("
   }
 });
 registerCloudCommands(program2, "connectors");
+{
+  const cloudCmd = program2.commands.find((c) => c.name() === "cloud");
+  if (cloudCmd) {
+    const syncCmd = cloudCmd.command("sync").description("Incremental (delta) sync \u2014 only rows changed since last sync");
+    syncCmd.command("push").description("Push local changes to cloud (incremental by default)").option("--tables <tables>", "Comma-separated table names").option("--full", "Full resync instead of incremental delta", false).action(async (opts) => {
+      const local = new SqliteAdapter(getDbPath("connectors"));
+      const tables = opts.tables ? opts.tables.split(",").map((t) => t.trim()) : listSqliteTables(local);
+      if (opts.full) {
+        const cloud = new PgAdapterAsync(getConnectionString("connectors"));
+        const { syncPush: syncPush2 } = await Promise.resolve().then(() => (init_dist(), exports_dist));
+        const results = await syncPush2(local, cloud, {
+          tables,
+          onProgress: (p) => {
+            if (p.phase === "done")
+              console.log(`  ${p.table}: ${p.rowsWritten} rows pushed (full)`);
+          }
+        });
+        local.close();
+        await cloud.close();
+        const total = results.reduce((s, r) => s + r.rowsWritten, 0);
+        console.log(`Done. ${total} rows pushed (full sync).`);
+      } else {
+        const cloud = new PgAdapter(getConnectionString("connectors"));
+        const results = incrementalSyncPush(local, cloud, tables);
+        local.close();
+        cloud.close();
+        const total = results.reduce((s, r) => s + r.synced_rows, 0);
+        const firstSync = results.filter((r) => r.first_sync).length;
+        console.log(`Done. ${total} rows pushed (incremental).${firstSync ? ` ${firstSync} table(s) had first-sync.` : ""}`);
+        for (const r of results) {
+          if (r.errors.length)
+            console.warn(`  ${r.table}: ${r.errors.join(", ")}`);
+        }
+      }
+    });
+    syncCmd.command("pull").description("Pull cloud changes to local (incremental by default)").option("--tables <tables>", "Comma-separated table names").option("--full", "Full resync instead of incremental delta", false).action(async (opts) => {
+      const local = new SqliteAdapter(getDbPath("connectors"));
+      if (opts.full) {
+        const cloud = new PgAdapterAsync(getConnectionString("connectors"));
+        const tables = opts.tables ? opts.tables.split(",").map((t) => t.trim()) : await listPgTables(cloud);
+        const { syncPull: syncPull2 } = await Promise.resolve().then(() => (init_dist(), exports_dist));
+        const results = await syncPull2(cloud, local, {
+          tables,
+          onProgress: (p) => {
+            if (p.phase === "done")
+              console.log(`  ${p.table}: ${p.rowsWritten} rows pulled (full)`);
+          }
+        });
+        local.close();
+        await cloud.close();
+        const total = results.reduce((s, r) => s + r.rowsWritten, 0);
+        console.log(`Done. ${total} rows pulled (full sync).`);
+      } else {
+        const cloud = new PgAdapter(getConnectionString("connectors"));
+        const tables = opts.tables ? opts.tables.split(",").map((t) => t.trim()) : listSqliteTables(local);
+        const results = incrementalSyncPull(cloud, local, tables);
+        local.close();
+        cloud.close();
+        const total = results.reduce((s, r) => s + r.synced_rows, 0);
+        console.log(`Done. ${total} rows pulled (incremental).`);
+        for (const r of results) {
+          if (r.errors.length)
+            console.warn(`  ${r.table}: ${r.errors.join(", ")}`);
+        }
+      }
+    });
+    syncCmd.command("status").description("Show last-synced timestamps per table").action(() => {
+      const local = new SqliteAdapter(getDbPath("connectors"));
+      const meta = getSyncMetaAll(local);
+      local.close();
+      if (!meta.length) {
+        console.log("No sync history found. Run: connectors cloud sync push");
+        return;
+      }
+      console.log(chalk2.bold(`
+Sync status:
+`));
+      for (const m of meta) {
+        console.log(`  ${chalk2.cyan(m.table_name.padEnd(32))} last synced: ${m.last_synced_at ?? "never"} (${m.direction})`);
+      }
+      console.log();
+    });
+  }
+}
 program2.parse();