@hasna/cloud 0.1.31 → 0.1.33

package/dist/index.js

@@ -156,7 +156,7 @@ var require_arrayParser = __commonJS((exports, module) => {
   };
 });
 
-// node_modules/pg-types/node_modules/postgres-date/index.js
+// node_modules/postgres-date/index.js
 var require_postgres_date = __commonJS((exports, module) => {
   var DATE_TIME = /(\d{1,})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})(\.\d{1,})?.*?( BC)?$/;
   var DATE = /^(\d{1,})-(\d{2})-(\d{2})( BC)?$/;
@@ -258,7 +258,7 @@ var require_mutable = __commonJS((exports, module) => {
   }
 });
 
-// node_modules/pg-types/node_modules/postgres-interval/index.js
+// node_modules/postgres-interval/index.js
 var require_postgres_interval = __commonJS((exports, module) => {
   var extend = require_mutable();
   module.exports = PostgresInterval;
@@ -350,7 +350,7 @@ var require_postgres_interval = __commonJS((exports, module) => {
   }
 });
 
-// node_modules/pg-types/node_modules/postgres-bytea/index.js
+// node_modules/postgres-bytea/index.js
 var require_postgres_bytea = __commonJS((exports, module) => {
   var bufferFrom = Buffer.from || Buffer;
   module.exports = function parseBytea(input) {
@@ -9267,89 +9267,6 @@ var init_dotfile = __esm(() => {
   HASNA_DIR = join(homedir(), ".hasna");
 });
 
-// src/config.ts
-var exports_config = {};
-__export(exports_config, {
-  saveCloudConfig: () => saveCloudConfig,
-  getConnectionString: () => getConnectionString,
-  getConfigPath: () => getConfigPath,
-  getConfigDir: () => getConfigDir,
-  getCloudConfig: () => getCloudConfig,
-  createDatabase: () => createDatabase,
-  CloudConfigSchema: () => CloudConfigSchema
-});
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync, writeFileSync } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
-function getConfigDir() {
-  return CONFIG_DIR;
-}
-function getConfigPath() {
-  return CONFIG_PATH;
-}
-function getCloudConfig() {
-  if (!existsSync2(CONFIG_PATH)) {
-    return CloudConfigSchema.parse({});
-  }
-  try {
-    const raw = readFileSync(CONFIG_PATH, "utf-8");
-    return CloudConfigSchema.parse(JSON.parse(raw));
-  } catch {
-    return CloudConfigSchema.parse({});
-  }
-}
-function saveCloudConfig(config) {
-  mkdirSync2(CONFIG_DIR, { recursive: true });
-  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + `
-`, "utf-8");
-}
-function getConnectionString(dbName) {
-  const config = getCloudConfig();
-  const { host, port, username, password_env, ssl } = config.rds;
-  if (!host || !username) {
-    throw new Error("Cloud RDS not configured. Run `cloud setup` to configure.");
-  }
-  const password = process.env[password_env];
-  if (password === undefined || password === "") {
-    throw new Error(`RDS password not set. Export ${password_env} in your shell or add it to ~/.secrets/hasna/rds/live.env`);
-  }
-  const sslParam = ssl ? "?sslmode=require" : "";
-  return `postgres://${username}:${encodeURIComponent(password)}@${host}:${port}/${dbName}${sslParam}`;
-}
-function createDatabase(options) {
-  const config = getCloudConfig();
-  const mode = options.mode ?? config.mode;
-  if (mode === "cloud") {
-    const connStr = options.pgConnectionString ?? getConnectionString(options.service);
-    return new PgAdapter(connStr);
-  }
-  const dbPath = options.sqlitePath ?? getDbPath(options.service);
-  return new SqliteAdapter(dbPath);
-}
-var CloudConfigSchema, CONFIG_DIR, CONFIG_PATH;
-var init_config = __esm(() => {
-  init_zod();
-  init_adapter();
-  init_dotfile();
-  CloudConfigSchema = exports_external.object({
-    rds: exports_external.object({
-      host: exports_external.string().default(""),
-      port: exports_external.number().default(5432),
-      username: exports_external.string().default(""),
-      password_env: exports_external.string().default("HASNA_RDS_PASSWORD"),
-      ssl: exports_external.boolean().default(true)
-    }).default({}),
-    mode: exports_external.enum(["local", "cloud", "hybrid"]).default("hybrid"),
-    auto_sync_interval_minutes: exports_external.number().default(0),
-    feedback_endpoint: exports_external.string().default("https://feedback.hasna.com/api/v1/feedback"),
-    sync: exports_external.object({
-      schedule_minutes: exports_external.number().default(0)
-    }).default({})
-  });
-  CONFIG_DIR = join2(homedir2(), ".hasna", "cloud");
-  CONFIG_PATH = join2(CONFIG_DIR, "config.json");
-});
-
 // src/discover.ts
 var exports_discover = {};
 __export(exports_discover, {
@@ -9360,15 +9277,15 @@ __export(exports_discover, {
   SYNC_EXCLUDED_TABLE_PATTERNS: () => SYNC_EXCLUDED_TABLE_PATTERNS,
   KNOWN_PG_SERVICES: () => KNOWN_PG_SERVICES
 });
-import { readdirSync as readdirSync2, existsSync as existsSync3 } from "fs";
-import { join as join3 } from "path";
-import { homedir as homedir3 } from "os";
+import { readdirSync as readdirSync2, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
 function isSyncExcludedTable(table) {
   return SYNC_EXCLUDED_TABLE_PATTERNS.some((p) => p.test(table));
 }
 function discoverServices() {
-  const dataDir = join3(homedir3(), ".hasna");
-  if (!existsSync3(dataDir))
+  const dataDir = join2(homedir2(), ".hasna");
+  if (!existsSync2(dataDir))
     return [];
   try {
     const entries = readdirSync2(dataDir, { withFileTypes: true });
@@ -9389,24 +9306,24 @@ function discoverSyncableServices() {
   return local.filter((s) => pgSet.has(s));
 }
 function getServiceDbPath(service) {
-  const dataDir = join3(homedir3(), ".hasna", service);
-  if (!existsSync3(dataDir))
+  const dataDir = join2(homedir2(), ".hasna", service);
+  if (!existsSync2(dataDir))
     return null;
   const candidates = [
-    join3(dataDir, `${service}.db`),
-    join3(dataDir, "data.db"),
-    join3(dataDir, "database.db")
+    join2(dataDir, `${service}.db`),
+    join2(dataDir, "data.db"),
+    join2(dataDir, "database.db")
   ];
   try {
     const files = readdirSync2(dataDir);
     for (const f of files) {
       if (f.endsWith(".db") && !f.endsWith("-wal") && !f.endsWith("-shm")) {
-        candidates.push(join3(dataDir, f));
+        candidates.push(join2(dataDir, f));
       }
     }
   } catch {}
   for (const p of candidates) {
-    if (existsSync3(p))
+    if (existsSync2(p))
       return p;
   }
   return null;
@@ -9459,9 +9376,515 @@ var init_discover = __esm(() => {
   ];
 });
 
+// src/machines.ts
+import { spawnSync } from "child_process";
+import { existsSync as existsSync3 } from "fs";
+import { homedir as homedir3, hostname, platform, arch, userInfo } from "os";
+import { dirname, join as join3 } from "path";
+function quoteSqlString(value) {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+function normalizePlatform(value) {
+  if (value === "darwin")
+    return "macos";
+  if (value === "win32")
+    return "windows";
+  return value;
+}
+function detectWorkspacePath() {
+  const home = homedir3();
+  const candidates = [join3(home, "workspace"), join3(home, "Workspace")];
+  for (const candidate of candidates) {
+    if (existsSync3(candidate))
+      return candidate;
+  }
+  const cwd = process.cwd();
+  const workspaceIdx = cwd.indexOf("/workspace/");
+  if (workspaceIdx >= 0) {
+    return cwd.slice(0, workspaceIdx + "/workspace".length);
+  }
+  const workspaceUpperIdx = cwd.indexOf("/Workspace/");
+  if (workspaceUpperIdx >= 0) {
+    return cwd.slice(0, workspaceUpperIdx + "/Workspace".length);
+  }
+  return cwd;
+}
+function detectBunPath() {
+  return dirname(process.execPath);
+}
+function toFlag(value, fallback = 0) {
+  if (value === undefined)
+    return fallback;
+  return value ? 1 : 0;
+}
+function getCurrentMachineId() {
+  return hostname();
+}
+function detectCurrentMachine(opts = {}) {
+  const id = opts.id ?? getCurrentMachineId();
+  const username = userInfo().username;
+  return {
+    id,
+    ssh_address: opts.ssh_address ?? `${username}@${id}`,
+    arch: opts.arch ?? `${normalizePlatform(platform())}-${arch()}`,
+    workspace_path: opts.workspace_path ?? detectWorkspacePath(),
+    bun_path: opts.bun_path ?? detectBunPath(),
+    is_primary: opts.is_primary,
+    archived: opts.archived,
+    last_seen_at: opts.last_seen_at,
+    registered_at: opts.registered_at
+  };
+}
+function ensureMachinesTable(db) {
+  db.exec(MACHINES_TABLE_SQL);
+}
+function getMachineRecord(db, id) {
+  ensureMachinesTable(db);
+  return db.get(`SELECT id, ssh_address, arch, workspace_path, bun_path, is_primary, last_seen_at, registered_at, archived
+       FROM machines
+       WHERE id = ?`, id) ?? null;
+}
+function registerMachine(db, opts = {}) {
+  ensureMachinesTable(db);
+  const detected = detectCurrentMachine(opts);
+  const id = detected.id ?? getCurrentMachineId();
+  const now = new Date().toISOString();
+  const existing = getMachineRecord(db, id);
+  const isPrimary = toFlag(detected.is_primary, existing?.is_primary ?? 0);
+  const archived = toFlag(detected.archived, existing?.archived ?? 0);
+  if (isPrimary === 1 && archived === 1) {
+    throw new Error(`Primary machine "${id}" cannot be archived.`);
+  }
+  const record = {
+    id,
+    ssh_address: detected.ssh_address ?? existing?.ssh_address ?? "",
+    arch: detected.arch ?? existing?.arch ?? "",
+    workspace_path: detected.workspace_path ?? existing?.workspace_path ?? "",
+    bun_path: detected.bun_path ?? existing?.bun_path ?? "",
+    is_primary: isPrimary,
+    last_seen_at: detected.last_seen_at ?? now,
+    registered_at: existing?.registered_at ?? detected.registered_at ?? now,
+    archived
+  };
+  db.run(`INSERT INTO machines (
+      id,
+      ssh_address,
+      arch,
+      workspace_path,
+      bun_path,
+      is_primary,
+      last_seen_at,
+      registered_at,
+      archived
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(id) DO UPDATE SET
+      ssh_address = excluded.ssh_address,
+      arch = excluded.arch,
+      workspace_path = excluded.workspace_path,
+      bun_path = excluded.bun_path,
+      is_primary = excluded.is_primary,
+      last_seen_at = excluded.last_seen_at,
+      registered_at = excluded.registered_at,
+      archived = excluded.archived`, record.id, record.ssh_address, record.arch, record.workspace_path, record.bun_path, record.is_primary, record.last_seen_at, record.registered_at, record.archived);
+  return getMachineRecord(db, record.id) ?? record;
+}
+function listMachines(db, opts = {}) {
+  ensureMachinesTable(db);
+  const includeArchived = opts.includeArchived ?? false;
+  const whereClause = includeArchived ? "" : "WHERE archived = 0";
+  return db.all(`SELECT id, ssh_address, arch, workspace_path, bun_path, is_primary, last_seen_at, registered_at, archived
+     FROM machines
+     ${whereClause}
+     ORDER BY is_primary DESC, id ASC`);
+}
+function pingMachine(machine) {
+  const record = typeof machine === "string" ? {
+    id: machine,
+    ssh_address: machine
+  } : machine;
+  const startedAt = Date.now();
+  const checkedAt = new Date().toISOString();
+  const currentId = getCurrentMachineId();
+  if (record.id === currentId) {
+    return {
+      id: record.id,
+      online: true,
+      checked_at: checkedAt,
+      latency_ms: Date.now() - startedAt
+    };
+  }
+  const target = record.ssh_address || record.id;
+  if (!target) {
+    return {
+      id: record.id,
+      online: false,
+      error: "Machine has no ssh target.",
+      checked_at: checkedAt,
+      latency_ms: Date.now() - startedAt
+    };
+  }
+  const result = spawnSync("ssh", ["-o", "BatchMode=yes", "-o", "ConnectTimeout=5", target, "true"], {
+    encoding: "utf-8",
+    timeout: 6000
+  });
+  return {
+    id: record.id,
+    online: result.status === 0,
+    error: result.status === 0 ? undefined : (result.stderr || result.error?.message || "SSH health check failed").trim(),
+    checked_at: checkedAt,
+    latency_ms: Date.now() - startedAt
+  };
+}
+function getMachineStatus(db, opts = {}) {
+  return listMachines(db, opts).map((machine) => pingMachine(machine));
+}
+function tableExists(db, table) {
+  try {
+    if (typeof db.query === "function") {
+      const rows2 = db.all(`SELECT name FROM sqlite_master WHERE type='table' AND name = ?`, table);
+      return rows2.length > 0;
+    }
+    const rows = db.all(`SELECT table_name
+       FROM information_schema.tables
+       WHERE table_schema = 'public' AND table_name = ?`, table);
+    return rows.length > 0;
+  } catch {
+    return false;
+  }
+}
+function hasMachineIdColumn(db, table) {
+  try {
+    if (typeof db.query === "function") {
+      const rows2 = db.all(`PRAGMA table_info("${table}")`);
+      return rows2.some((row) => row.name === "machine_id");
+    }
+    const rows = db.all(`SELECT column_name
+       FROM information_schema.columns
+       WHERE table_schema = 'public' AND table_name = ? AND column_name = 'machine_id'`, table);
+    return rows.length > 0;
+  } catch {
+    return false;
+  }
+}
+function shouldTrackMachineId(table) {
+  return table !== "machines" && !isSyncExcludedTable(table);
+}
+function ensureMachineIdColumn(db, table) {
+  if (!shouldTrackMachineId(table) || !tableExists(db, table)) {
+    return false;
+  }
+  if (hasMachineIdColumn(db, table)) {
+    return false;
+  }
+  db.exec(`ALTER TABLE "${table}" ADD COLUMN machine_id TEXT DEFAULT ''`);
+  return true;
+}
+function extractTableName(sql, pattern) {
+  const match = sql.match(pattern);
+  if (!match)
+    return null;
+  return match[2] ?? match[3] ?? null;
+}
+function appendLiteralToValueTuples(sql, literal) {
+  let output = "";
+  let depth = 0;
+  let inSingle = false;
+  let inDouble = false;
+  let sawTuple = false;
+  let inValues = true;
+  for (let i = 0;i < sql.length; i++) {
+    const char = sql[i];
+    const prev = sql[i - 1];
+    if (!inDouble && char === "'" && prev !== "\\") {
+      inSingle = !inSingle;
+      output += char;
+      continue;
+    }
+    if (!inSingle && char === `"` && prev !== "\\") {
+      inDouble = !inDouble;
+      output += char;
+      continue;
+    }
+    if (inSingle || inDouble) {
+      output += char;
+      continue;
+    }
+    if (inValues && char === "(") {
+      depth += 1;
+      if (depth === 1)
+        sawTuple = true;
+      output += char;
+      continue;
+    }
+    if (inValues && char === ")" && depth === 1) {
+      output += `, ${literal})`;
+      depth = 0;
+      continue;
+    }
+    if (inValues && char === ")" && depth > 1) {
+      depth -= 1;
+      output += char;
+      continue;
+    }
+    if (inValues && depth === 0 && sawTuple && /[A-Za-z]/.test(char)) {
+      inValues = false;
+    }
+    output += char;
+  }
+  return sawTuple ? output : null;
+}
+function rewriteInsertSql(sql, machineId) {
+  const match = sql.match(/^\s*(insert(?:\s+or\s+\w+)?\s+into\s+((?:"([^"]+)")|([A-Za-z_][\w$]*))\s*)\(([^)]*)\)(\s*values\s*)([\s\S]*)$/i);
+  if (!match)
+    return null;
+  const table = match[3] ?? match[4];
+  if (!table || !shouldTrackMachineId(table))
+    return null;
+  const columns = match[5].split(",").map((column) => column.trim().replace(/^"|"$/g, ""));
+  if (columns.some((column) => column.toLowerCase() === "machine_id")) {
+    return { table, sql };
+  }
+  const rewrittenValues = appendLiteralToValueTuples(match[7], quoteSqlString(machineId));
+  if (!rewrittenValues)
+    return { table, sql };
+  const nextColumns = `${match[5].trim()}, "machine_id"`;
+  return {
+    table,
+    sql: `${match[1]}(${nextColumns})${match[6]}${rewrittenValues}`
+  };
+}
+function rewriteUpdateSql(sql, machineId) {
+  const match = sql.match(/^\s*(update\s+((?:"([^"]+)")|([A-Za-z_][\w$]*))\s+set\s*)([\s\S]*?)(\s+(?:where|returning)\b[\s\S]*|\s*)$/i);
+  if (!match)
+    return null;
+  const table = match[3] ?? match[4];
+  if (!table || !shouldTrackMachineId(table))
+    return null;
+  if (/\bmachine_id\b/i.test(match[5])) {
+    return { table, sql };
+  }
+  return {
+    table,
+    sql: `${match[1]}${match[5].trimEnd()}, "machine_id" = ${quoteSqlString(machineId)}${match[6]}`
+  };
+}
+function maybeRewriteMachineSql(db, sql, machineId) {
+  const trimmed = sql.trimStart();
+  if (/^insert\b/i.test(trimmed)) {
+    const rewritten = rewriteInsertSql(sql, machineId);
+    if (rewritten?.table) {
+      ensureMachineIdColumn(db, rewritten.table);
+      return rewritten.sql;
+    }
+    return sql;
+  }
+  if (/^update\b/i.test(trimmed)) {
+    const rewritten = rewriteUpdateSql(sql, machineId);
+    if (rewritten?.table) {
+      ensureMachineIdColumn(db, rewritten.table);
+      return rewritten.sql;
+    }
+    return sql;
+  }
+  return sql;
+}
+function maybeEnsureCreatedTableHasMachineId(db, sql) {
+  const table = extractTableName(sql, /^\s*(create\s+table(?:\s+if\s+not\s+exists)?\s+((?:"([^"]+)")|([A-Za-z_][\w$]*)))/i);
+  if (table) {
+    ensureMachineIdColumn(db, table);
+  }
+}
+function createMachineRegistry(db, machineId = getCurrentMachineId()) {
+  return {
+    register(opts = {}) {
+      return registerMachine(db, { ...opts, id: opts.id ?? machineId });
+    },
+    list(opts = {}) {
+      return listMachines(db, opts);
+    },
+    ping(machine) {
+      if (!machine) {
+        return pingMachine(registerMachine(db, { id: machineId }));
+      }
+      return pingMachine(typeof machine === "string" ? getMachineRecord(db, machine) ?? machine : machine);
+    },
+    status(opts = {}) {
+      return getMachineStatus(db, opts);
+    },
+    currentMachine() {
+      return registerMachine(db, { id: machineId });
+    }
+  };
+}
+function createMachineAwareAdapter(db) {
+  ensureMachinesTable(db);
+  const machineId = registerMachine(db).id;
+  const machines = createMachineRegistry(db, machineId);
+  const wrapped = {
+    machine_id: machineId,
+    machines,
+    run(sql, ...params) {
+      return db.run(maybeRewriteMachineSql(db, sql, machineId), ...params);
+    },
+    get(sql, ...params) {
+      return db.get(sql, ...params);
+    },
+    all(sql, ...params) {
+      return db.all(sql, ...params);
+    },
+    exec(sql) {
+      db.exec(sql);
+      maybeEnsureCreatedTableHasMachineId(db, sql);
+    },
+    prepare(sql) {
+      const statement = db.prepare(maybeRewriteMachineSql(db, sql, machineId));
+      return {
+        run(...params) {
+          return statement.run(...params);
+        },
+        get(...params) {
+          return statement.get(...params);
+        },
+        all(...params) {
+          return statement.all(...params);
+        },
+        finalize() {
+          statement.finalize();
+        }
+      };
+    },
+    close() {
+      db.close();
+    },
+    transaction(fn) {
+      return db.transaction(fn);
+    },
+    raw: db.raw,
+    query: typeof db.query === "function" ? db.query.bind(db) : undefined
+  };
+  return wrapped;
+}
+var MACHINES_TABLE_SQL = `
+CREATE TABLE IF NOT EXISTS machines (
+  id TEXT PRIMARY KEY,
+  ssh_address TEXT DEFAULT '',
+  arch TEXT DEFAULT '',
+  workspace_path TEXT DEFAULT '',
+  bun_path TEXT DEFAULT '',
+  is_primary INTEGER DEFAULT 0 CHECK (is_primary IN (0, 1)),
+  last_seen_at TEXT,
+  registered_at TEXT,
+  archived INTEGER DEFAULT 0 CHECK (archived IN (0, 1)),
+  CHECK (NOT (is_primary = 1 AND archived = 1))
+)`;
+var init_machines = __esm(() => {
+  init_discover();
+});
+
+// src/config.ts
+var exports_config = {};
+__export(exports_config, {
+  saveCloudConfig: () => saveCloudConfig,
+  getConnectionString: () => getConnectionString,
+  getConfigPath: () => getConfigPath,
+  getConfigDir: () => getConfigDir,
+  getCloudConfig: () => getCloudConfig,
+  createDatabase: () => createDatabase,
+  CloudConfigSchema: () => CloudConfigSchema
+});
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync, writeFileSync } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join4 } from "path";
+function getConfigDir() {
+  return CONFIG_DIR;
+}
+function getConfigPath() {
+  return CONFIG_PATH;
+}
+function getCloudConfig() {
+  if (!existsSync4(CONFIG_PATH)) {
+    return CloudConfigSchema.parse({});
+  }
+  try {
+    const raw = readFileSync(CONFIG_PATH, "utf-8");
+    return CloudConfigSchema.parse(JSON.parse(raw));
+  } catch {
+    return CloudConfigSchema.parse({});
+  }
+}
+function saveCloudConfig(config) {
+  mkdirSync2(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + `
+`, "utf-8");
+}
+function getConnectionString(dbName) {
+  const config = getCloudConfig();
+  const { host, port, username, password_env, ssl } = config.rds;
+  if (!host || !username) {
+    throw new Error("Cloud RDS not configured. Run `cloud setup` to configure.");
+  }
+  const password = process.env[password_env];
+  if (password === undefined || password === "") {
+    throw new Error(`RDS password not set. Export ${password_env} in your shell or add it to ~/.secrets/hasna/rds/live.env`);
+  }
+  const sslParam = ssl ? "?sslmode=require" : "";
+  return `postgres://${username}:${encodeURIComponent(password)}@${host}:${port}/${dbName}${sslParam}`;
+}
+function createDatabase(options) {
+  const config = getCloudConfig();
+  const mode = options.mode ?? config.mode;
+  if (mode === "cloud") {
+    const connStr = options.pgConnectionString ?? getConnectionString(options.service);
+    return createMachineAwareAdapter(new PgAdapter(connStr));
+  }
+  const dbPath = options.sqlitePath ?? getDbPath(options.service);
+  return createMachineAwareAdapter(new SqliteAdapter(dbPath));
+}
+var DaemonConfigSchema, CloudConfigSchema, CONFIG_DIR, CONFIG_PATH;
+var init_config = __esm(() => {
+  init_zod();
+  init_adapter();
+  init_dotfile();
+  init_machines();
+  DaemonConfigSchema = exports_external.object({
+    enabled: exports_external.boolean().default(false),
+    paused: exports_external.boolean().default(false),
+    watch_interval_seconds: exports_external.number().int().positive().default(5),
+    pull_interval_seconds: exports_external.number().int().positive().default(60),
+    push_debounce_seconds: exports_external.number().int().positive().default(5),
+    conflict_strategy: exports_external.enum(["newest-wins", "local-wins", "remote-wins"]).default("newest-wins"),
+    services: exports_external.array(exports_external.string()).default([]),
+    table_intervals: exports_external.record(exports_external.string(), exports_external.record(exports_external.string(), exports_external.number().int().positive())).default({}),
+    file_rules: exports_external.array(exports_external.object({
+      path: exports_external.string(),
+      interval_seconds: exports_external.number().int().positive().default(30),
+      enabled: exports_external.boolean().default(true)
+    })).default([])
+  }).default({});
+  CloudConfigSchema = exports_external.object({
+    rds: exports_external.object({
+      host: exports_external.string().default(""),
+      port: exports_external.number().default(5432),
+      username: exports_external.string().default(""),
+      password_env: exports_external.string().default("HASNA_RDS_PASSWORD"),
+      ssl: exports_external.boolean().default(true)
+    }).default({}),
+    mode: exports_external.enum(["local", "cloud", "hybrid"]).default("hybrid"),
+    auto_sync_interval_minutes: exports_external.number().default(0),
+    feedback_endpoint: exports_external.string().default("https://feedback.hasna.com/api/v1/feedback"),
+    sync: exports_external.object({
+      schedule_minutes: exports_external.number().default(0)
+    }).default({}),
+    daemon: DaemonConfigSchema
+  });
+  CONFIG_DIR = join4(homedir4(), ".hasna", "cloud");
+  CONFIG_PATH = join4(CONFIG_DIR, "config.json");
+});
+
 // src/index.ts
 init_adapter();
 init_config();
+init_machines();
 
 // src/sync.ts
 async function syncPush(local, remote, options) {
@@ -9639,6 +10062,9 @@ async function ensureTablesExist(source, target, tables) {
 }
 async function filterColumnsForTarget(target, table, sourceColumns) {
   try {
+    if (sourceColumns.includes("machine_id") && table !== "machines") {
+      await ensureMachineIdColumnInTarget(target, table);
+    }
     if (!isAsyncAdapter(target)) {
       const colInfo = target.all(`PRAGMA table_info("${table}")`);
       if (Array.isArray(colInfo) && colInfo.length > 0) {
@@ -9661,6 +10087,22 @@ async function filterColumnsForTarget(target, table, sourceColumns) {
   } catch {}
   return sourceColumns;
 }
+async function ensureMachineIdColumnInTarget(target, table) {
+  if (!isAsyncAdapter(target)) {
+    const colInfo2 = target.all(`PRAGMA table_info("${table}")`);
+    const hasMachineId = Array.isArray(colInfo2) ? colInfo2.some((column) => column.name === "machine_id") : false;
+    if (!hasMachineId) {
+      target.exec(`ALTER TABLE "${table}" ADD COLUMN machine_id TEXT DEFAULT ''`);
+    }
+    return;
+  }
+  const colInfo = await target.all(`SELECT column_name
+     FROM information_schema.columns
+     WHERE table_schema = 'public' AND table_name = '${table}' AND column_name = 'machine_id'`);
+  if (colInfo.length === 0) {
+    await target.exec(`ALTER TABLE "${table}" ADD COLUMN machine_id TEXT DEFAULT ''`);
+  }
+}
 async function syncTransfer(source, target, options, _direction) {
   const {
     tables,
@@ -9895,7 +10337,7 @@ async function listPgTables(db) {
 }
 // src/feedback.ts
 init_config();
-import { hostname } from "os";
+import { hostname as hostname2 } from "os";
 var FEEDBACK_TABLE_SQL = `
 CREATE TABLE IF NOT EXISTS feedback (
   id TEXT PRIMARY KEY,
@@ -9913,7 +10355,7 @@ function saveFeedback(db, feedback) {
   ensureFeedbackTable(db);
   const id = feedback.id ?? Math.random().toString(36).slice(2) + Date.now().toString(36);
   const now = new Date().toISOString();
-  const machineId = feedback.machine_id ?? hostname();
+  const machineId = feedback.machine_id ?? hostname2();
   db.run(`INSERT INTO feedback (id, service, version, message, email, machine_id, created_at)
      VALUES (?, ?, ?, ?, ?, ?, ?)`, id, feedback.service, feedback.version ?? "", feedback.message, feedback.email ?? "", machineId, feedback.created_at ?? now);
   return id;
@@ -9921,7 +10363,7 @@ function saveFeedback(db, feedback) {
 async function sendFeedback(feedback, db) {
   const config = getCloudConfig();
   const id = feedback.id ?? Math.random().toString(36).slice(2) + Date.now().toString(36);
-  const machineId = feedback.machine_id ?? hostname();
+  const machineId = feedback.machine_id ?? hostname2();
   const now = new Date().toISOString();
   const payload = {
     id,
@@ -10217,6 +10659,7 @@ function purgeResolvedConflicts(db) {
   return result.changes;
 }
 // src/sync-incremental.ts
+init_machines();
 var SYNC_META_TABLE_SQL = `
 CREATE TABLE IF NOT EXISTS _sync_meta (
   table_name TEXT PRIMARY KEY,
@@ -10248,6 +10691,11 @@ function transferRows(source, target, table, rows, options) {
   if (rows.length === 0)
     return { written, skipped, errors: errors2 };
   const columns = Object.keys(rows[0]);
+  if (columns.includes("machine_id") && table !== "machines") {
+    try {
+      ensureMachineIdColumn(target, table);
+    } catch {}
+  }
   const hasConflictCol = columns.includes(conflictColumn);
   const hasPrimaryKey = columns.includes(primaryKey);
   if (!hasPrimaryKey) {
@@ -10258,12 +10706,21 @@ function transferRows(source, target, table, rows, options) {
     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 conflictStrategy = options.conflictStrategy ?? "newest-wins";
+        const sourceRole = options.sourceRole ?? "local";
+        const sourceWins = conflictStrategy === "local-wins" && sourceRole === "local" || conflictStrategy === "remote-wins" && sourceRole === "remote";
+        if (!sourceWins && conflictStrategy !== "newest-wins") {
+          skipped++;
+          continue;
+        }
+        if (conflictStrategy === "newest-wins") {
+          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(", ");
@@ -10314,7 +10771,10 @@ function incrementalSyncPush(local, remote, tables, options = {}) {
       }
       for (let offset = 0;offset < rows.length; offset += batchSize) {
         const batch = rows.slice(offset, offset + batchSize);
-        const result = transferRows(local, remote, table, batch, options);
+        const result = transferRows(local, remote, table, batch, {
+          ...options,
+          sourceRole: "local"
+        });
         stat.synced_rows += result.written;
         stat.skipped_rows += result.skipped;
         stat.errors.push(...result.errors);
@@ -10367,7 +10827,10 @@ function incrementalSyncPull(remote, local, tables, options = {}) {
       }
       for (let offset = 0;offset < rows.length; offset += batchSize) {
         const batch = rows.slice(offset, offset + batchSize);
-        const result = transferRows(remote, local, table, batch, options);
+        const result = transferRows(remote, local, table, batch, {
+          ...options,
+          sourceRole: "remote"
+        });
         stat.synced_rows += result.written;
         stat.skipped_rows += result.skipped;
         stat.errors.push(...result.errors);
@@ -10407,18 +10870,18 @@ function resetAllSyncMeta(db) {
 // src/auto-sync.ts
 init_adapter();
 init_config();
-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, readFileSync as readFileSync2 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join5 } from "path";
 init_discover();
-var AUTO_SYNC_CONFIG_PATH = join4(homedir4(), ".hasna", "cloud", "config.json");
+var AUTO_SYNC_CONFIG_PATH = join5(homedir5(), ".hasna", "cloud", "config.json");
 var DEFAULT_AUTO_SYNC_CONFIG = {
   auto_sync_on_start: true,
   auto_sync_on_stop: true
 };
 function getAutoSyncConfig() {
   try {
-    if (!existsSync4(AUTO_SYNC_CONFIG_PATH)) {
+    if (!existsSync5(AUTO_SYNC_CONFIG_PATH)) {
       return { ...DEFAULT_AUTO_SYNC_CONFIG };
     }
     const raw = JSON.parse(readFileSync2(AUTO_SYNC_CONFIG_PATH, "utf-8"));
@@ -10510,20 +10973,24 @@ function setupAutoSync(serviceName, server, local, remote, tables) {
   if (server && typeof server.onconnect === "function") {
     const origOnConnect = server.onconnect;
     server.onconnect = async (...args) => {
-      await syncOnStart();
+      syncOnStart();
       return origOnConnect.apply(server, args);
     };
   } else if (server && typeof server.on === "function") {
-    server.on("connect", () => syncOnStart());
+    server.on("connect", () => {
+      syncOnStart();
+    });
   }
   if (server && typeof server.ondisconnect === "function") {
     const origOnDisconnect = server.ondisconnect;
     server.ondisconnect = async (...args) => {
-      await syncOnStop();
+      syncOnStop();
       return origOnDisconnect.apply(server, args);
     };
   } else if (server && typeof server.on === "function") {
-    server.on("disconnect", () => syncOnStop());
+    server.on("disconnect", () => {
+      syncOnStop();
+    });
   }
   installSignalHandlers();
   cleanupHandlers.push(async () => {
@@ -10537,8 +11004,8 @@ function enableAutoSync(serviceName, mcpServer, local, remote, tables) {
 // src/scheduled-sync.ts
 init_config();
 init_adapter();
-import { existsSync as existsSync5, readdirSync as readdirSync3 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync6, readdirSync as readdirSync3 } from "fs";
+import { join as join6 } from "path";
 init_dotfile();
 function discoverSyncableServices2() {
   const hasnaDir = getHasnaDir();
@@ -10548,8 +11015,8 @@ function discoverSyncableServices2() {
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const dbPath = join5(hasnaDir, entry.name, `${entry.name}.db`);
-      if (existsSync5(dbPath)) {
+      const dbPath = join6(hasnaDir, entry.name, `${entry.name}.db`);
+      if (existsSync6(dbPath)) {
         services.push(entry.name);
       }
     }
@@ -10571,8 +11038,8 @@ async function runScheduledSync() {
       errors: []
     };
     try {
-      const dbPath = join5(getDataDir(service), `${service}.db`);
-      if (!existsSync5(dbPath)) {
+      const dbPath = join6(getDataDir(service), `${service}.db`);
+      if (!existsSync6(dbPath)) {
         continue;
       }
       const local = new SqliteAdapter(dbPath);
@@ -10583,7 +11050,7 @@ async function runScheduledSync() {
       }
       try {
         const connStr = getConnectionString(service);
-        remote = new PgAdapterAsync(connStr);
+        remote = new PgAdapter(connStr);
       } catch (err) {
         result.errors.push(`Connection failed: ${err?.message ?? String(err)}`);
         local.close();
@@ -10599,7 +11066,7 @@ async function runScheduledSync() {
         result.errors.push(...s.errors);
       }
       local.close();
-      await remote.close();
+      remote.close();
       remote = null;
     } catch (err) {
       result.errors.push(err?.message ?? String(err));
@@ -10608,18 +11075,18 @@ async function runScheduledSync() {
   }
   if (remote) {
     try {
-      await remote.close();
+      remote.close();
     } catch {}
   }
   return results;
 }
 // src/sync-schedule.ts
 init_config();
-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";
+import { join as join7, dirname as dirname2 } from "path";
+import { existsSync as existsSync7, writeFileSync as writeFileSync2, unlinkSync, mkdirSync as mkdirSync3 } from "fs";
+import { homedir as homedir6, platform as platform2 } from "os";
 var SERVICE_NAME = "hasna-cloud-sync";
-var CONFIG_DIR2 = join6(homedir5(), ".hasna", "cloud");
+var CONFIG_DIR2 = join7(homedir6(), ".hasna", "cloud");
 function parseInterval(input) {
   const trimmed = input.trim().toLowerCase();
   const hourMatch = trimmed.match(/^(\d+)\s*h$/);
@@ -10659,35 +11126,35 @@ function minutesToCron(minutes) {
   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");
+  const dir = typeof import.meta.dir === "string" ? import.meta.dir : dirname2(import.meta.url.replace("file://", ""));
+  const tsPath = join7(dir, "scheduled-sync.ts");
+  const jsPath = join7(dir, "scheduled-sync.js");
   try {
-    if (existsSync6(tsPath))
+    if (existsSync7(tsPath))
       return tsPath;
   } catch {}
   return jsPath;
 }
 function getBunPath() {
   const candidates = [
-    join6(homedir5(), ".bun", "bin", "bun"),
+    join7(homedir6(), ".bun", "bin", "bun"),
     "/usr/local/bin/bun",
     "/usr/bin/bun"
   ];
   for (const p of candidates) {
-    if (existsSync6(p))
+    if (existsSync7(p))
       return p;
   }
   return "bun";
 }
 function getLaunchdPlistPath() {
-  return join6(homedir5(), "Library", "LaunchAgents", `com.hasna.cloud-sync.plist`);
+  return join7(homedir6(), "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");
+  const logPath = join7(CONFIG_DIR2, "sync.log");
+  const errorLogPath = join7(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">
@@ -10713,14 +11180,14 @@ function createLaunchdPlist(intervalMinutes) {
     <key>PATH</key>
     <string>${process.env.PATH || "/usr/local/bin:/usr/bin:/bin"}</string>
     <key>HOME</key>
-    <string>${homedir5()}</string>
+    <string>${homedir6()}</string>
   </dict>
 </dict>
 </plist>`;
 }
 async function registerLaunchd(intervalMinutes) {
   const plistPath = getLaunchdPlistPath();
-  const plistDir = dirname(plistPath);
+  const plistDir = dirname2(plistPath);
   mkdirSync3(plistDir, { recursive: true });
   try {
     await Bun.spawn(["launchctl", "unload", plistPath]).exited;
@@ -10738,7 +11205,7 @@ async function removeLaunchd() {
   } catch {}
 }
 function getSystemdDir() {
-  return join6(homedir5(), ".config", "systemd", "user");
+  return join7(homedir6(), ".config", "systemd", "user");
 }
 function createSystemdService() {
   const workerPath = getWorkerPath();
@@ -10750,7 +11217,7 @@ After=network.target
 [Service]
 Type=oneshot
 ExecStart=${bunPath} run ${workerPath}
-Environment=HOME=${homedir5()}
+Environment=HOME=${homedir6()}
 Environment=PATH=${process.env.PATH || "/usr/local/bin:/usr/bin:/bin"}
 
 [Install]
@@ -10773,8 +11240,8 @@ 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));
+  writeFileSync2(join7(dir, `${SERVICE_NAME}.service`), createSystemdService());
+  writeFileSync2(join7(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;
 }
@@ -10784,10 +11251,10 @@ async function removeSystemd() {
   } catch {}
   const dir = getSystemdDir();
   try {
-    unlinkSync(join6(dir, `${SERVICE_NAME}.service`));
+    unlinkSync(join7(dir, `${SERVICE_NAME}.service`));
   } catch {}
   try {
-    unlinkSync(join6(dir, `${SERVICE_NAME}.timer`));
+    unlinkSync(join7(dir, `${SERVICE_NAME}.timer`));
   } catch {}
   try {
     await Bun.spawn(["systemctl", "--user", "daemon-reload"]).exited;
@@ -10798,7 +11265,7 @@ async function registerSyncSchedule(intervalMinutes) {
     throw new Error("Interval must be a positive number of minutes.");
   }
   mkdirSync3(CONFIG_DIR2, { recursive: true });
-  if (platform() === "darwin") {
+  if (platform2() === "darwin") {
     await registerLaunchd(intervalMinutes);
   } else {
     await registerSystemd(intervalMinutes);
@@ -10808,7 +11275,7 @@ async function registerSyncSchedule(intervalMinutes) {
   saveCloudConfig(config);
 }
 async function removeSyncSchedule() {
-  if (platform() === "darwin") {
+  if (platform2() === "darwin") {
     await removeLaunchd();
   } else {
     await removeSystemd();
@@ -10823,10 +11290,10 @@ function getSyncScheduleStatus() {
   const registered = minutes > 0;
   let mechanism = "none";
   if (registered) {
-    if (platform() === "darwin") {
-      mechanism = existsSync6(getLaunchdPlistPath()) ? "launchd" : "none";
+    if (platform2() === "darwin") {
+      mechanism = existsSync7(getLaunchdPlistPath()) ? "launchd" : "none";
     } else {
-      mechanism = existsSync6(join6(getSystemdDir(), `${SERVICE_NAME}.timer`)) ? "systemd" : "none";
+      mechanism = existsSync7(join7(getSystemdDir(), `${SERVICE_NAME}.timer`)) ? "systemd" : "none";
     }
   }
   return {
@@ -10836,6 +11303,497 @@ function getSyncScheduleStatus() {
     mechanism
   };
 }
+// src/daemon-sync.ts
+init_adapter();
+init_config();
+init_discover();
+init_dotfile();
+import { spawn } from "child_process";
+import {
+  existsSync as existsSync8,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync4,
+  statSync as statSync4,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { homedir as homedir7 } from "os";
+import { join as join8 } from "path";
+var DAEMON_STATE_PATH = join8(homedir7(), ".hasna", "cloud", "daemon-state.json");
+var defaultDaemonAdapterFactory = {
+  getLocalDbPath: (service) => getDbPath(service),
+  openLocal: (service) => new SqliteAdapter(getDbPath(service)),
+  openRemote: (service) => new PgAdapter(getConnectionString(service)),
+  listRemoteTables: (remote) => remote.all(`SELECT tablename FROM pg_tables WHERE schemaname = 'public' ORDER BY tablename`).map((row) => row.tablename)
+};
+function nowIso() {
+  return new Date().toISOString();
+}
+function sleepSync(ms) {
+  if (ms <= 0)
+    return;
+  const sleeper = new Int32Array(new SharedArrayBuffer(4));
+  Atomics.wait(sleeper, 0, 0, ms);
+}
+function cloneState(state) {
+  return JSON.parse(JSON.stringify(state));
+}
+function getDefaultDaemonConfig() {
+  return {
+    enabled: false,
+    paused: false,
+    watch_interval_seconds: 5,
+    pull_interval_seconds: 60,
+    push_debounce_seconds: 5,
+    conflict_strategy: "newest-wins",
+    services: [],
+    table_intervals: {},
+    file_rules: []
+  };
+}
+function getDaemonConfig(config = getCloudConfig()) {
+  const defaults2 = getDefaultDaemonConfig();
+  return {
+    ...defaults2,
+    ...config.daemon,
+    services: [...config.daemon?.services ?? defaults2.services],
+    table_intervals: { ...config.daemon?.table_intervals ?? defaults2.table_intervals },
+    file_rules: [...config.daemon?.file_rules ?? defaults2.file_rules]
+  };
+}
+function saveDaemonConfig(config) {
+  const cloudConfig = getCloudConfig();
+  cloudConfig.daemon = {
+    ...getDefaultDaemonConfig(),
+    ...config,
+    services: [...config.services],
+    table_intervals: { ...config.table_intervals },
+    file_rules: [...config.file_rules]
+  };
+  saveCloudConfig(cloudConfig);
+  return getDaemonConfig(cloudConfig);
+}
+function getDaemonStatePath() {
+  return DAEMON_STATE_PATH;
+}
+function createDefaultDaemonState() {
+  return {
+    pid: null,
+    status: "stopped",
+    started_at: null,
+    updated_at: null,
+    last_push_at: null,
+    last_pull_at: null,
+    last_error: null,
+    services: {},
+    files: {}
+  };
+}
+function readDaemonState() {
+  if (!existsSync8(DAEMON_STATE_PATH)) {
+    return createDefaultDaemonState();
+  }
+  try {
+    const raw = JSON.parse(readFileSync4(DAEMON_STATE_PATH, "utf-8"));
+    const defaults2 = createDefaultDaemonState();
+    return {
+      ...defaults2,
+      ...raw,
+      services: raw?.services ?? defaults2.services,
+      files: raw?.files ?? defaults2.files
+    };
+  } catch {
+    return createDefaultDaemonState();
+  }
+}
+function writeDaemonState(state) {
+  mkdirSync4(join8(homedir7(), ".hasna", "cloud"), { recursive: true });
+  writeFileSync3(DAEMON_STATE_PATH, JSON.stringify(state, null, 2) + `
+`, "utf-8");
+}
+function getServiceState(state, service) {
+  return state.services[service] ?? {
+    last_local_db_mtime_ms: 0,
+    last_push_at: null,
+    last_pull_at: null,
+    last_error: null,
+    tables: {}
+  };
+}
+function isProcessRunning(pid) {
+  if (!pid || pid <= 0)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolveDaemonServices(config) {
+  if (config.services.length > 0) {
+    return [...new Set(config.services)].sort();
+  }
+  return discoverSyncableServices();
+}
+function parseTableIntervalRule(raw) {
+  const match = raw.match(/^([^.:=]+)[.:]([^=]+)=(\d+)$/);
+  if (!match) {
+    throw new Error(`Invalid table interval "${raw}". Use service.table=seconds or service:table=seconds.`);
+  }
+  const intervalSeconds = parseInt(match[3], 10);
+  if (intervalSeconds <= 0) {
+    throw new Error(`Invalid table interval "${raw}". Seconds must be > 0.`);
+  }
+  return {
+    service: match[1],
+    table: match[2],
+    interval_seconds: intervalSeconds
+  };
+}
+function applyTableIntervalRules(existing, rules) {
+  const next = { ...existing };
+  for (const raw of rules) {
+    const parsed = parseTableIntervalRule(raw);
+    next[parsed.service] = {
+      ...next[parsed.service] ?? {},
+      [parsed.table]: parsed.interval_seconds
+    };
+  }
+  return next;
+}
+function parseFileRule(raw) {
+  const [pathPart, intervalPart] = raw.split("=", 2);
+  const path = pathPart?.trim();
+  if (!path) {
+    throw new Error(`Invalid file rule "${raw}". Use /path/to/file=seconds.`);
+  }
+  const intervalSeconds = intervalPart ? parseInt(intervalPart, 10) : 30;
+  if (!Number.isFinite(intervalSeconds) || intervalSeconds <= 0) {
+    throw new Error(`Invalid file rule "${raw}". Seconds must be > 0.`);
+  }
+  return {
+    path,
+    interval_seconds: intervalSeconds,
+    enabled: true
+  };
+}
+function applyFileRules(existing, rules) {
+  const next = [...existing];
+  for (const raw of rules) {
+    next.push(parseFileRule(raw));
+  }
+  return next;
+}
+function isIntervalDue(lastAt, intervalSeconds, nowMs) {
+  if (!intervalSeconds)
+    return true;
+  if (!lastAt)
+    return true;
+  return nowMs - Date.parse(lastAt) >= intervalSeconds * 1000;
+}
+function scanConfiguredFiles(config, state) {
+  for (const rule of config.file_rules) {
+    const key = rule.path;
+    let lastMtime = 0;
+    let exists = false;
+    try {
+      const stats = statSync4(rule.path);
+      lastMtime = stats.mtimeMs;
+      exists = true;
+    } catch {
+      exists = false;
+    }
+    state.files[key] = {
+      path: key,
+      enabled: rule.enabled,
+      interval_seconds: rule.interval_seconds,
+      exists,
+      last_mtime_ms: lastMtime
+    };
+  }
+}
+function filterDueTables(service, tables, direction, serviceState, config, nowMs) {
+  const serviceIntervals = config.table_intervals[service] ?? {};
+  return tables.filter((table) => {
+    const tableState = serviceState.tables[table];
+    const lastAt = direction === "push" ? tableState?.last_push_at ?? null : tableState?.last_pull_at ?? null;
+    return isIntervalDue(lastAt, serviceIntervals[table], nowMs);
+  });
+}
+function recordTableRuns(serviceState, tables, direction, at) {
+  for (const table of tables) {
+    const current = serviceState.tables[table] ?? {
+      last_push_at: null,
+      last_pull_at: null
+    };
+    if (direction === "push") {
+      current.last_push_at = at;
+    } else {
+      current.last_pull_at = at;
+    }
+    serviceState.tables[table] = current;
+  }
+}
+function summarizeStats(stats) {
+  return {
+    rows: stats.reduce((sum, stat) => sum + stat.synced_rows, 0),
+    errors: stats.flatMap((stat) => stat.errors.map((error) => `${stat.table}: ${error}`))
+  };
+}
+function runDaemonPass(config, state = createDefaultDaemonState(), options = {}) {
+  const nextState = cloneState(state);
+  const adapterFactory = options.adapterFactory ?? defaultDaemonAdapterFactory;
+  const services = options.services ?? resolveDaemonServices(config);
+  const now = nowIso();
+  const nowMs = Date.parse(now);
+  const summary = {
+    services,
+    pushed_services: 0,
+    pulled_services: 0,
+    pushed_rows: 0,
+    pulled_rows: 0,
+    errors: []
+  };
+  nextState.updated_at = now;
+  nextState.status = config.paused ? "paused" : "running";
+  if (config.paused) {
+    scanConfiguredFiles(config, nextState);
+    return { state: nextState, summary };
+  }
+  for (const service of services) {
+    const dbPath = adapterFactory.getLocalDbPath(service);
+    if (!existsSync8(dbPath))
+      continue;
+    const serviceState = getServiceState(nextState, service);
+    let local = null;
+    let remote = null;
+    try {
+      const localStats = statSync4(dbPath);
+      local = adapterFactory.openLocal(service);
+      remote = adapterFactory.openRemote(service);
+      const localTables = listSqliteTables(local).filter((table) => !isSyncExcludedTable(table));
+      const duePushTables = filterDueTables(service, localTables, "push", serviceState, config, nowMs);
+      const pushDebounceDue = !serviceState.last_push_at || nowMs - Date.parse(serviceState.last_push_at) >= config.push_debounce_seconds * 1000;
+      const localChanged = localStats.mtimeMs > serviceState.last_local_db_mtime_ms;
+      const shouldPush = duePushTables.length > 0 && (options.forcePush || localChanged && pushDebounceDue);
+      if (shouldPush) {
+        const pushStats = incrementalSyncPush(local, remote, duePushTables, {
+          conflictStrategy: config.conflict_strategy
+        });
+        const pushSummary = summarizeStats(pushStats);
+        serviceState.last_local_db_mtime_ms = localStats.mtimeMs;
+        serviceState.last_push_at = now;
+        serviceState.last_error = pushSummary.errors[0] ?? null;
+        recordTableRuns(serviceState, duePushTables, "push", now);
+        nextState.last_push_at = now;
+        summary.pushed_services++;
+        summary.pushed_rows += pushSummary.rows;
+        summary.errors.push(...pushSummary.errors.map((error) => `[${service}] ${error}`));
+      } else if (serviceState.last_local_db_mtime_ms === 0) {
+        serviceState.last_local_db_mtime_ms = localStats.mtimeMs;
+      }
+      const remoteTables = adapterFactory.listRemoteTables(remote).filter((table) => !isSyncExcludedTable(table));
+      const duePullTables = filterDueTables(service, remoteTables, "pull", serviceState, config, nowMs);
+      const shouldPull = duePullTables.length > 0 && (options.forcePull || isIntervalDue(serviceState.last_pull_at, config.pull_interval_seconds, nowMs));
+      if (shouldPull) {
+        const pullStats = incrementalSyncPull(remote, local, duePullTables, {
+          conflictStrategy: config.conflict_strategy
+        });
+        const pullSummary = summarizeStats(pullStats);
+        serviceState.last_pull_at = now;
+        serviceState.last_error = pullSummary.errors[0] ?? null;
+        recordTableRuns(serviceState, duePullTables, "pull", now);
+        nextState.last_pull_at = now;
+        summary.pulled_services++;
+        summary.pulled_rows += pullSummary.rows;
+        summary.errors.push(...pullSummary.errors.map((error) => `[${service}] ${error}`));
+      }
+    } catch (err) {
+      const message = err?.message ?? String(err);
+      serviceState.last_error = message;
+      nextState.last_error = message;
+      summary.errors.push(`[${service}] ${message}`);
+    } finally {
+      nextState.services[service] = serviceState;
+      try {
+        local?.close();
+      } catch {}
+      try {
+        remote?.close();
+      } catch {}
+    }
+  }
+  if (summary.errors.length > 0) {
+    nextState.last_error = summary.errors[0];
+  }
+  scanConfiguredFiles(config, nextState);
+  return { state: nextState, summary };
+}
+function getDaemonStatus() {
+  const config = getDaemonConfig();
+  const state = readDaemonState();
+  const running = isProcessRunning(state.pid);
+  const status = running ? config.paused ? "paused" : state.status : "stopped";
+  return {
+    running,
+    pid: running ? state.pid : null,
+    status,
+    config,
+    state: {
+      ...state,
+      status,
+      pid: running ? state.pid : null
+    },
+    services: resolveDaemonServices(config)
+  };
+}
+function getDaemonArgs() {
+  const script = process.argv[1];
+  if (!script) {
+    throw new Error("Unable to determine the current CLI entrypoint.");
+  }
+  return [script, "sync", "daemon", "--run"];
+}
+function startDaemon(overrides = {}) {
+  const current = getDaemonConfig();
+  const nextConfig = saveDaemonConfig({
+    ...current,
+    ...overrides,
+    enabled: true,
+    paused: false,
+    services: overrides.services ?? current.services,
+    table_intervals: overrides.table_intervals ?? current.table_intervals,
+    file_rules: overrides.file_rules ?? current.file_rules
+  });
+  const currentStatus = getDaemonStatus();
+  if (currentStatus.running) {
+    return currentStatus;
+  }
+  const child = spawn(process.execPath, getDaemonArgs(), {
+    detached: true,
+    stdio: "ignore",
+    env: {
+      ...process.env,
+      HASNA_CLOUD_DAEMON_CHILD: "1"
+    }
+  });
+  child.unref();
+  const state = readDaemonState();
+  const startedAt = nowIso();
+  state.pid = child.pid ?? null;
+  state.status = "running";
+  state.started_at = startedAt;
+  state.updated_at = startedAt;
+  writeDaemonState(state);
+  return {
+    running: true,
+    pid: child.pid ?? null,
+    status: "running",
+    config: nextConfig,
+    state,
+    services: resolveDaemonServices(nextConfig)
+  };
+}
+function stopDaemon() {
+  const current = getDaemonConfig();
+  saveDaemonConfig({ ...current, enabled: false });
+  const status = getDaemonStatus();
+  if (status.pid) {
+    try {
+      process.kill(status.pid, "SIGTERM");
+    } catch {}
+  }
+  const state = readDaemonState();
+  state.pid = null;
+  state.status = "stopped";
+  state.updated_at = nowIso();
+  writeDaemonState(state);
+  return getDaemonStatus();
+}
+function pauseDaemon() {
+  const current = getDaemonConfig();
+  saveDaemonConfig({ ...current, paused: true });
+  const state = readDaemonState();
+  if (state.pid) {
+    state.status = "paused";
+    state.updated_at = nowIso();
+    writeDaemonState(state);
+  }
+  return getDaemonStatus();
+}
+function resumeDaemon() {
+  const current = getDaemonConfig();
+  saveDaemonConfig({ ...current, enabled: true, paused: false });
+  const state = readDaemonState();
+  if (state.pid) {
+    state.status = "running";
+    state.updated_at = nowIso();
+    writeDaemonState(state);
+  }
+  return getDaemonStatus();
+}
+function runDaemonOnce(options = {}) {
+  const config = options.config ?? getDaemonConfig();
+  const state = options.state ?? readDaemonState();
+  const result = runDaemonPass(config, state, {
+    adapterFactory: options.adapterFactory,
+    forcePull: options.forcePull,
+    forcePush: options.forcePush,
+    services: options.services
+  });
+  writeDaemonState(result.state);
+  return result;
+}
+function runDaemonLoop(options = {}) {
+  let stopping = false;
+  const stop = () => {
+    stopping = true;
+  };
+  process.on("SIGTERM", stop);
+  process.on("SIGINT", stop);
+  let passes = 0;
+  const startedAt = nowIso();
+  try {
+    while (!stopping) {
+      const config = getDaemonConfig();
+      const state = readDaemonState();
+      if (!config.enabled) {
+        break;
+      }
+      state.pid = process.pid;
+      state.started_at = state.started_at ?? startedAt;
+      state.updated_at = nowIso();
+      writeDaemonState(state);
+      const result = runDaemonPass(config, state, {
+        adapterFactory: options.adapterFactory
+      });
+      result.state.pid = process.pid;
+      result.state.started_at = state.started_at ?? startedAt;
+      result.state.status = config.paused ? "paused" : "running";
+      result.state.updated_at = nowIso();
+      writeDaemonState(result.state);
+      passes++;
+      if (options.max_passes && passes >= options.max_passes) {
+        break;
+      }
+      sleepSync(config.watch_interval_seconds * 1000);
+    }
+  } finally {
+    const finalState = readDaemonState();
+    finalState.pid = null;
+    finalState.status = "stopped";
+    finalState.updated_at = nowIso();
+    writeDaemonState(finalState);
+  }
+}
+function normalizeConflictStrategy(strategy) {
+  if (!strategy)
+    return "newest-wins";
+  if (strategy !== "newest-wins" && strategy !== "local-wins" && strategy !== "remote-wins") {
+    throw new Error(`Invalid conflict strategy "${strategy}". Use newest-wins, local-wins, or remote-wins.`);
+  }
+  return strategy;
+}
 // src/pg-migrate.ts
 init_adapter();
 init_config();
@@ -11164,33 +12122,50 @@ function registerCloudCommands(program, serviceName) {
   });
 }
 export {
+  writeDaemonState,
   translateSql,
   translateParams,
   translateDdl,
   syncPush,
   syncPull,
   storeConflicts,
+  stopDaemon,
+  startDaemon,
   setupAutoSync,
   sendFeedback,
   saveFeedback,
+  saveDaemonConfig,
   saveCloudConfig,
   runScheduledSync,
+  runDaemonPass,
+  runDaemonOnce,
+  runDaemonLoop,
+  resumeDaemon,
+  resolveDaemonServices,
   resolveConflicts,
   resolveConflict,
   resetSyncMeta,
   resetAllSyncMeta,
   removeSyncSchedule,
   registerSyncSchedule,
+  registerMachine,
   registerCloudTools,
   registerCloudCommands,
+  readDaemonState,
   purgeResolvedConflicts,
+  pingMachine,
+  pauseDaemon,
+  parseTableIntervalRule,
   parseInterval,
+  parseFileRule,
+  normalizeConflictStrategy,
   minutesToCron,
   migrateService,
   migrateDotfile,
   migrateAllServices,
   listSqliteTables,
   listPgTables,
+  listMachines,
   listFeedback,
   listConflicts,
   isSyncExcludedTable,
@@ -11202,9 +12177,16 @@ export {
   getSyncMetaForTable,
   getSyncMetaAll,
   getServiceDbPath,
+  getMachineStatus,
+  getMachineRecord,
   getHasnaDir,
+  getDefaultDaemonConfig,
   getDbPath,
   getDataDir,
+  getDaemonStatus,
+  getDaemonStatePath,
+  getDaemonConfig,
+  getCurrentMachineId,
   getConnectionString,
   getConflict,
   getConfigPath,
@@ -11213,6 +12195,8 @@ export {
   getAutoSyncConfig,
   ensureSyncMetaTable,
   ensurePgDatabase,
+  ensureMachinesTable,
+  ensureMachineIdColumn,
   ensureFeedbackTable,
   ensureConflictsTable,
   ensureAllPgDatabases,
@@ -11220,9 +12204,15 @@ export {
   discoverSyncableServices as discoverSyncableServicesV2,
   discoverSyncableServices2 as discoverSyncableServices,
   discoverServices,
+  detectCurrentMachine,
   detectConflicts,
+  createMachineRegistry,
+  createMachineAwareAdapter,
+  createDefaultDaemonState,
   createDatabase,
+  applyTableIntervalRules,
   applyPgMigrations,
+  applyFileRules,
   SyncProgressTracker,
   SqliteAdapter,
   SYNC_EXCLUDED_TABLE_PATTERNS,