@hasna/cloud 0.1.7 → 0.1.9

package/dist/cli/index.js

@@ -11187,6 +11187,62 @@ class PgAdapter {
   }
 }
 
+class PgAdapterAsync {
+  pool;
+  constructor(arg) {
+    if (typeof arg === "string") {
+      this.pool = new esm_default.Pool({ connectionString: arg });
+    } else {
+      this.pool = arg;
+    }
+  }
+  async run(sql, ...params) {
+    const pgSql = translateSql(sql, "pg");
+    const pgParams = translateParams(params);
+    const res = await this.pool.query(pgSql, pgParams);
+    return {
+      changes: res.rowCount ?? 0,
+      lastInsertRowid: res.rows?.[0]?.id ?? 0
+    };
+  }
+  async get(sql, ...params) {
+    const pgSql = translateSql(sql, "pg");
+    const pgParams = translateParams(params);
+    const res = await this.pool.query(pgSql, pgParams);
+    return res.rows[0] ?? null;
+  }
+  async all(sql, ...params) {
+    const pgSql = translateSql(sql, "pg");
+    const pgParams = translateParams(params);
+    const res = await this.pool.query(pgSql, pgParams);
+    return res.rows;
+  }
+  async exec(sql) {
+    const pgSql = translateSql(sql, "pg");
+    await this.pool.query(pgSql);
+  }
+  async close() {
+    await this.pool.end();
+  }
+  async transaction(fn) {
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      const result = await fn(client);
+      await client.query("COMMIT");
+      return result;
+    } catch (err) {
+      await client.query("ROLLBACK");
+      throw err;
+    } finally {
+      client.release();
+    }
+  }
+  get raw() {
+    return this.pool;
+  }
+}
+
 // src/dotfile.ts
 import {
   existsSync,
@@ -11206,6 +11262,10 @@ function getDbPath(serviceName) {
   const dir = getDataDir(serviceName);
   return join(dir, `${serviceName}.db`);
 }
+function getHasnaDir() {
+  mkdirSync(HASNA_DIR, { recursive: true });
+  return HASNA_DIR;
+}
 
 // src/config.ts
 var CloudConfigSchema = exports_external.object({
@@ -11218,7 +11278,10 @@ var CloudConfigSchema = exports_external.object({
   }).default({}),
   mode: exports_external.enum(["local", "cloud", "hybrid"]).default("local"),
   auto_sync_interval_minutes: exports_external.number().default(0),
-  feedback_endpoint: exports_external.string().default("https://feedback.hasna.com/api/v1/feedback")
+  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({})
 });
 var CONFIG_DIR = join2(homedir2(), ".hasna", "cloud");
 var CONFIG_PATH = join2(CONFIG_DIR, "config.json");
@@ -11389,6 +11452,11 @@ async function syncTransfer(source, target, options, _direction) {
     primaryKey: pkOption
   } = options;
   const results = [];
+  if (!isAsyncAdapter(target)) {
+    try {
+      target.run("PRAGMA foreign_keys = OFF");
+    } catch {}
+  }
   for (let i = 0;i < tables.length; i++) {
     const table = tables[i];
     const result = {
@@ -11506,6 +11574,11 @@ async function syncTransfer(source, target, options, _direction) {
     }
     results.push(result);
   }
+  if (!isAsyncAdapter(target)) {
+    try {
+      target.run("PRAGMA foreign_keys = ON");
+    } catch {}
+  }
   return results;
 }
 async function batchUpsertPg(target, table, columns, updateCols, primaryKeys, batch) {
@@ -11589,7 +11662,10 @@ var CloudConfigSchema2 = exports_external.object({
   }).default({}),
   mode: exports_external.enum(["local", "cloud", "hybrid"]).default("local"),
   auto_sync_interval_minutes: exports_external.number().default(0),
-  feedback_endpoint: exports_external.string().default("https://feedback.hasna.com/api/v1/feedback")
+  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({})
 });
 var CONFIG_DIR2 = join3(homedir3(), ".hasna", "cloud");
 var CONFIG_PATH2 = join3(CONFIG_DIR2, "config.json");
@@ -11604,6 +11680,21 @@ function getCloudConfig2() {
     return CloudConfigSchema2.parse({});
   }
 }
+function saveCloudConfig2(config) {
+  mkdirSync3(CONFIG_DIR2, { recursive: true });
+  writeFileSync2(CONFIG_PATH2, JSON.stringify(config, null, 2) + `
+`, "utf-8");
+}
+function getConnectionString2(dbName) {
+  const config = getCloudConfig2();
+  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] ?? "";
+  const sslParam = ssl ? "?sslmode=require" : "";
+  return `postgres://${username}:${encodeURIComponent(password)}@${host}:${port}/${dbName}${sslParam}`;
+}
 
 // src/feedback.ts
 var FEEDBACK_TABLE_SQL = `
@@ -11775,7 +11866,7 @@ class SqliteAdapter2 {
     return this.db;
   }
 }
-class PgAdapterAsync {
+class PgAdapterAsync2 {
   pool;
   constructor(arg) {
     if (typeof arg === "string") {
@@ -11831,9 +11922,295 @@ class PgAdapterAsync {
   }
 }
 
+// src/sync-schedule.ts
+import { join as join5, dirname } from "path";
+var CRON_TITLE = "hasna-cloud-sync";
+function getWorkerPath() {
+  const dir = typeof import.meta.dir === "string" ? import.meta.dir : dirname(import.meta.url.replace("file://", ""));
+  const tsPath = join5(dir, "scheduled-sync.ts");
+  const jsPath = join5(dir, "scheduled-sync.js");
+  try {
+    const { existsSync: existsSync5 } = __require("fs");
+    if (existsSync5(tsPath))
+      return tsPath;
+  } catch {}
+  return jsPath;
+}
+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} * * * *`;
+}
+async function registerSyncSchedule(intervalMinutes) {
+  if (intervalMinutes <= 0) {
+    throw new Error("Interval must be a positive number of minutes.");
+  }
+  const cronExpr = minutesToCron(intervalMinutes);
+  const workerPath = getWorkerPath();
+  await Bun.cron(workerPath, cronExpr, CRON_TITLE);
+  const config = getCloudConfig2();
+  config.sync.schedule_minutes = intervalMinutes;
+  saveCloudConfig2(config);
+}
+async function removeSyncSchedule() {
+  await Bun.cron.remove(CRON_TITLE);
+  const config = getCloudConfig2();
+  config.sync.schedule_minutes = 0;
+  saveCloudConfig2(config);
+}
+function getSyncScheduleStatus() {
+  const config = getCloudConfig2();
+  const minutes = config.sync.schedule_minutes;
+  const registered = minutes > 0;
+  return {
+    registered,
+    schedule_minutes: minutes,
+    cron_expression: registered ? minutesToCron(minutes) : null
+  };
+}
+
+// src/scheduled-sync.ts
+import { existsSync as existsSync5, readdirSync as readdirSync3 } from "fs";
+import { join as join6 } from "path";
+
+// src/sync-incremental.ts
+var SYNC_META_TABLE_SQL = `
+CREATE TABLE IF NOT EXISTS _sync_meta (
+  table_name TEXT PRIMARY KEY,
+  last_synced_at TEXT,
+  last_synced_row_count INTEGER DEFAULT 0,
+  direction TEXT DEFAULT 'push'
+)`;
+function ensureSyncMetaTable(db) {
+  db.exec(SYNC_META_TABLE_SQL);
+}
+function getSyncMeta(db, table) {
+  ensureSyncMetaTable(db);
+  return db.get(`SELECT table_name, last_synced_at, last_synced_row_count, direction FROM _sync_meta WHERE table_name = ?`, table) ?? null;
+}
+function upsertSyncMeta(db, meta) {
+  ensureSyncMetaTable(db);
+  const existing = db.get(`SELECT table_name FROM _sync_meta WHERE table_name = ?`, meta.table_name);
+  if (existing) {
+    db.run(`UPDATE _sync_meta SET last_synced_at = ?, last_synced_row_count = ?, direction = ? WHERE table_name = ?`, meta.last_synced_at, meta.last_synced_row_count, meta.direction, meta.table_name);
+  } else {
+    db.run(`INSERT INTO _sync_meta (table_name, last_synced_at, last_synced_row_count, direction) VALUES (?, ?, ?, ?)`, meta.table_name, meta.last_synced_at, meta.last_synced_row_count, meta.direction);
+  }
+}
+function transferRows(source, target, table, rows, options) {
+  const { primaryKey = "id", conflictColumn = "updated_at" } = options;
+  let written = 0;
+  let skipped = 0;
+  const errors2 = [];
+  if (rows.length === 0)
+    return { written, skipped, errors: errors2 };
+  const columns = Object.keys(rows[0]);
+  const hasConflictCol = columns.includes(conflictColumn);
+  const hasPrimaryKey = columns.includes(primaryKey);
+  if (!hasPrimaryKey) {
+    errors2.push(`Table "${table}" has no "${primaryKey}" column -- skipping`);
+    return { written, skipped, errors: errors2 };
+  }
+  for (const row of rows) {
+    try {
+      const existing = target.get(`SELECT "${primaryKey}"${hasConflictCol ? `, "${conflictColumn}"` : ""} FROM "${table}" WHERE "${primaryKey}" = ?`, row[primaryKey]);
+      if (existing) {
+        if (hasConflictCol && existing[conflictColumn] && row[conflictColumn]) {
+          const existingTime = new Date(existing[conflictColumn]).getTime();
+          const incomingTime = new Date(row[conflictColumn]).getTime();
+          if (existingTime >= incomingTime) {
+            skipped++;
+            continue;
+          }
+        }
+        const setClauses = columns.filter((c) => c !== primaryKey).map((c) => `"${c}" = ?`).join(", ");
+        const values = columns.filter((c) => c !== primaryKey).map((c) => row[c]);
+        values.push(row[primaryKey]);
+        target.run(`UPDATE "${table}" SET ${setClauses} WHERE "${primaryKey}" = ?`, ...values);
+      } else {
+        const placeholders = columns.map(() => "?").join(", ");
+        const colList = columns.map((c) => `"${c}"`).join(", ");
+        const values = columns.map((c) => row[c]);
+        target.run(`INSERT INTO "${table}" (${colList}) VALUES (${placeholders})`, ...values);
+      }
+      written++;
+    } catch (err) {
+      errors2.push(`Row ${row[primaryKey]}: ${err?.message ?? String(err)}`);
+    }
+  }
+  return { written, skipped, errors: errors2 };
+}
+function incrementalSyncPush(local, remote, tables, options = {}) {
+  const { conflictColumn = "updated_at", batchSize = 500 } = options;
+  const results = [];
+  ensureSyncMetaTable(local);
+  for (const table of tables) {
+    const stat = {
+      table,
+      total_rows: 0,
+      synced_rows: 0,
+      skipped_rows: 0,
+      errors: [],
+      first_sync: false
+    };
+    try {
+      const countResult = local.get(`SELECT COUNT(*) as cnt FROM "${table}"`);
+      stat.total_rows = countResult?.cnt ?? 0;
+      const meta = getSyncMeta(local, table);
+      let rows;
+      if (meta?.last_synced_at) {
+        try {
+          rows = local.all(`SELECT * FROM "${table}" WHERE "${conflictColumn}" > ?`, meta.last_synced_at);
+        } catch {
+          rows = local.all(`SELECT * FROM "${table}"`);
+          stat.first_sync = true;
+        }
+      } else {
+        rows = local.all(`SELECT * FROM "${table}"`);
+        stat.first_sync = true;
+      }
+      for (let offset = 0;offset < rows.length; offset += batchSize) {
+        const batch = rows.slice(offset, offset + batchSize);
+        const result = transferRows(local, remote, table, batch, options);
+        stat.synced_rows += result.written;
+        stat.skipped_rows += result.skipped;
+        stat.errors.push(...result.errors);
+      }
+      if (rows.length === 0) {
+        stat.skipped_rows = stat.total_rows;
+      }
+      const now = new Date().toISOString();
+      upsertSyncMeta(local, {
+        table_name: table,
+        last_synced_at: now,
+        last_synced_row_count: stat.synced_rows,
+        direction: "push"
+      });
+    } catch (err) {
+      stat.errors.push(`Table "${table}": ${err?.message ?? String(err)}`);
+    }
+    results.push(stat);
+  }
+  return results;
+}
+
+// src/sync.ts
+function listSqliteTables2(db) {
+  const rows = db.all(`SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name`);
+  return rows.map((r) => r.name);
+}
+
+// src/scheduled-sync.ts
+function discoverSyncableServices() {
+  const hasnaDir = getHasnaDir();
+  const services = [];
+  try {
+    const entries = readdirSync3(hasnaDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory())
+        continue;
+      const dbPath = join6(hasnaDir, entry.name, `${entry.name}.db`);
+      if (existsSync5(dbPath)) {
+        services.push(entry.name);
+      }
+    }
+  } catch {}
+  return services;
+}
+async function runScheduledSync() {
+  const config = getCloudConfig2();
+  if (config.mode === "local")
+    return [];
+  const services = discoverSyncableServices();
+  const results = [];
+  let remote = null;
+  for (const service of services) {
+    const result = {
+      service,
+      tables_synced: 0,
+      total_rows_synced: 0,
+      errors: []
+    };
+    try {
+      const dbPath = join6(getDataDir(service), `${service}.db`);
+      if (!existsSync5(dbPath)) {
+        continue;
+      }
+      const local = new SqliteAdapter(dbPath);
+      const tables = listSqliteTables2(local).filter((t) => !t.startsWith("_") && !t.startsWith("sqlite_"));
+      if (tables.length === 0) {
+        local.close();
+        continue;
+      }
+      try {
+        const connStr = getConnectionString2(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;
+}
+
 // src/cli/index.ts
 var program2 = new Command;
-program2.name("cloud").description("Shared cloud infrastructure \u2014 database adapter, sync engine, feedback, dotfile migration").version("0.1.7");
+program2.name("cloud").description("Shared cloud infrastructure \u2014 database adapter, sync engine, feedback, dotfile migration").version("0.1.8");
 program2.command("setup").description("Configure cloud settings").option("--host <host>", "RDS hostname").option("--port <port>", "RDS port", "5432").option("--username <user>", "RDS username").option("--password-env <env>", "Env var for RDS password", "HASNA_RDS_PASSWORD").option("--ssl", "Enable SSL", true).option("--no-ssl", "Disable SSL").option("--mode <mode>", "Mode: local, cloud, or hybrid", "local").option("--sync-interval <minutes>", "Auto-sync interval in minutes", "0").action((opts) => {
   const config = getCloudConfig();
   if (opts.host)
@@ -11866,7 +12243,7 @@ program2.command("status").description("Show current cloud configuration and con
 Checking PostgreSQL connection...`);
     try {
       const connStr = getConnectionString("postgres");
-      const pg2 = new PgAdapterAsync(connStr);
+      const pg2 = new PgAdapterAsync2(connStr);
       const row = await pg2.get("SELECT 1 as ok");
       if (row?.ok === 1) {
         console.log("PostgreSQL: connected");
@@ -11899,7 +12276,7 @@ syncCmd.command("push").description("Push local data to cloud").requiredOption("
   }
   console.log(`Pushing ${tables.length} table(s) to cloud...`);
   const connStr = getConnectionString(opts.service);
-  const cloud = new PgAdapterAsync(connStr);
+  const cloud = new PgAdapterAsync2(connStr);
   const results = await syncPush(local, cloud, {
     tables,
     onProgress: (p) => {
@@ -11931,7 +12308,7 @@ syncCmd.command("pull").description("Pull cloud data to local").requiredOption("
   const dbPath = getDbPath2(opts.service);
   const local = new SqliteAdapter2(dbPath);
   const connStr = getConnectionString(opts.service);
-  const cloud = new PgAdapterAsync(connStr);
+  const cloud = new PgAdapterAsync2(connStr);
   let tables;
   if (opts.tables) {
     tables = opts.tables.split(",").map((t) => t.trim());
@@ -11975,6 +12352,77 @@ Done. ${totalWritten} rows pulled, ${totalErrors} errors.`);
     }
   }
 });
+syncCmd.command("schedule").description("Manage scheduled background sync").option("--every <interval>", "Set sync interval (e.g. 5m, 10m, 1h)").option("--off", "Disable scheduled sync").option("--now", "Run a one-off sync immediately").action(async (opts) => {
+  if (opts.off) {
+    try {
+      await removeSyncSchedule();
+      console.log("Scheduled sync disabled.");
+    } catch (err) {
+      console.error("Failed to remove schedule:", err?.message);
+      process.exit(1);
+    }
+    return;
+  }
+  if (opts.now) {
+    const config = getCloudConfig();
+    if (config.mode === "local") {
+      console.error("Error: mode is 'local'. Run `cloud setup --mode hybrid` or `--mode cloud` first.");
+      process.exit(1);
+    }
+    console.log("Running sync now...");
+    const services2 = discoverSyncableServices();
+    console.log(`Discovered ${services2.length} service(s): ${services2.join(", ") || "(none)"}`);
+    const results = await runScheduledSync();
+    for (const r of results) {
+      const status2 = r.errors.length === 0 ? "ok" : "errors";
+      console.log(`  ${r.service}: ${r.tables_synced} table(s), ${r.total_rows_synced} row(s) [${status2}]`);
+      for (const e of r.errors) {
+        console.error(`    ${e}`);
+      }
+    }
+    if (results.length === 0) {
+      console.log("No services synced (mode may be local or no databases found).");
+    } else {
+      const totalRows = results.reduce((s, r) => s + r.total_rows_synced, 0);
+      const totalErrors = results.reduce((s, r) => s + r.errors.length, 0);
+      console.log(`
+Done. ${totalRows} rows synced, ${totalErrors} errors.`);
+    }
+    return;
+  }
+  if (opts.every) {
+    try {
+      const minutes = parseInterval(opts.every);
+      await registerSyncSchedule(minutes);
+      console.log(`Scheduled sync registered: every ${minutes} minute(s).`);
+    } catch (err) {
+      console.error("Failed to register schedule:", err?.message);
+      process.exit(1);
+    }
+    return;
+  }
+  const status = getSyncScheduleStatus();
+  if (status.registered) {
+    console.log("Scheduled sync: enabled");
+    console.log(`  Interval: ${status.schedule_minutes} minute(s)`);
+    console.log(`  Cron expression: ${status.cron_expression}`);
+  } else {
+    console.log("Scheduled sync: disabled");
+    console.log(`
+To enable, run: cloud sync schedule --every 5m`);
+  }
+  const services = discoverSyncableServices();
+  if (services.length > 0) {
+    console.log(`
+Syncable services (${services.length}):`);
+    for (const s of services) {
+      console.log(`  - ${s}`);
+    }
+  } else {
+    console.log(`
+No syncable services found (no .db files in ~/.hasna/).`);
+  }
+});
 program2.command("feedback").description("Send feedback").requiredOption("--service <name>", "Service name").requiredOption("--message <msg>", "Feedback message").option("--email <email>", "Contact email").option("--version <ver>", "Service version").action(async (opts) => {
   const db = createDatabase({ service: "cloud" });
   const result = await sendFeedback({

package/dist/config.d.ts

@@ -22,6 +22,13 @@ export declare const CloudConfigSchema: z.ZodObject<{
     mode: z.ZodDefault<z.ZodEnum<["local", "cloud", "hybrid"]>>;
     auto_sync_interval_minutes: z.ZodDefault<z.ZodNumber>;
     feedback_endpoint: z.ZodDefault<z.ZodString>;
+    sync: z.ZodDefault<z.ZodObject<{
+        schedule_minutes: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        schedule_minutes: number;
+    }, {
+        schedule_minutes?: number | undefined;
+    }>>;
 }, "strip", z.ZodTypeAny, {
     rds: {
         host: string;
@@ -33,6 +40,9 @@ export declare const CloudConfigSchema: z.ZodObject<{
     mode: "local" | "cloud" | "hybrid";
     auto_sync_interval_minutes: number;
     feedback_endpoint: string;
+    sync: {
+        schedule_minutes: number;
+    };
 }, {
     rds?: {
         host?: string | undefined;
@@ -44,6 +54,9 @@ export declare const CloudConfigSchema: z.ZodObject<{
     mode?: "local" | "cloud" | "hybrid" | undefined;
     auto_sync_interval_minutes?: number | undefined;
     feedback_endpoint?: string | undefined;
+    sync?: {
+        schedule_minutes?: number | undefined;
+    } | undefined;
 }>;
 export type CloudConfig = z.infer<typeof CloudConfigSchema>;
 export declare function getConfigDir(): string;

package/dist/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAe5B,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAS5D,wBAAgB,YAAY,IAAI,MAAM,CAErC;AAED,wBAAgB,aAAa,IAAI,MAAM,CAEtC;AAMD,wBAAgB,cAAc,IAAI,WAAW,CAU5C;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAGzD;AAMD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAa1D;AAMD,OAAO,EAA4B,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAGxE,MAAM,WAAW,qBAAqB;IACpC,qEAAqE;IACrE,OAAO,EAAE,MAAM,CAAC;IAChB,iCAAiC;IACjC,IAAI,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,QAAQ,CAAC;IACpC,qCAAqC;IACrC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,yCAAyC;IACzC,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,SAAS,CAaxE"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoB5B,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAS5D,wBAAgB,YAAY,IAAI,MAAM,CAErC;AAED,wBAAgB,aAAa,IAAI,MAAM,CAEtC;AAMD,wBAAgB,cAAc,IAAI,WAAW,CAU5C;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAGzD;AAMD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAa1D;AAMD,OAAO,EAA4B,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAGxE,MAAM,WAAW,qBAAqB;IACpC,qEAAqE;IACrE,OAAO,EAAE,MAAM,CAAC;IAChB,iCAAiC;IACjC,IAAI,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,QAAQ,CAAC;IACpC,qCAAqC;IACrC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,yCAAyC;IACzC,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,SAAS,CAaxE"}

package/dist/index.d.ts

@@ -8,6 +8,8 @@ export { SyncProgressTracker, type SyncProgressInfo, type ProgressCallback, type
 export { detectConflicts, resolveConflicts, getWinningData, ensureConflictsTable, storeConflicts, listConflicts, resolveConflict, getConflict, purgeResolvedConflicts, type SyncConflict, type ConflictStrategy, type StoredConflict, } from "./sync-conflicts.js";
 export { incrementalSyncPush, incrementalSyncPull, ensureSyncMetaTable, getSyncMetaAll, getSyncMetaForTable, resetSyncMeta, resetAllSyncMeta, type IncrementalSyncStats, type IncrementalSyncOptions, type SyncMeta, } from "./sync-incremental.js";
 export { setupAutoSync, enableAutoSync, getAutoSyncConfig, type AutoSyncConfig, type AutoSyncContext, type AutoSyncResult, } from "./auto-sync.js";
+export { runScheduledSync, discoverSyncableServices, type ScheduledSyncResult, } from "./scheduled-sync.js";
+export { registerSyncSchedule, removeSyncSchedule, getSyncScheduleStatus, parseInterval, minutesToCron, type SyncScheduleStatus, } from "./sync-schedule.js";
 export { registerCloudTools } from "./mcp-helpers.js";
 export { registerCloudCommands } from "./cli-helpers.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,aAAa,EACb,SAAS,EACT,cAAc,EACd,KAAK,SAAS,EACd,KAAK,iBAAiB,EACtB,KAAK,SAAS,GACf,MAAM,cAAc,CAAC;AAGtB,OAAO,EACL,YAAY,EACZ,YAAY,EACZ,eAAe,EACf,KAAK,OAAO,GACb,MAAM,cAAc,CAAC;AAGtB,OAAO,EACL,cAAc,EACd,eAAe,EACf,mBAAmB,EACnB,cAAc,EACd,YAAY,EACZ,aAAa,EACb,iBAAiB,EACjB,KAAK,WAAW,EAChB,KAAK,qBAAqB,GAC3B,MAAM,aAAa,CAAC;AAGrB,OAAO,EACL,QAAQ,EACR,QAAQ,EACR,gBAAgB,EAChB,YAAY,EACZ,KAAK,WAAW,EAChB,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,oBAAoB,GAC1B,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,mBAAmB,EACnB,KAAK,QAAQ,GACd,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,cAAc,EACd,UAAU,EACV,SAAS,EACT,gBAAgB,EAChB,WAAW,GACZ,MAAM,cAAc,CAAC;AAGtB,OAAO,EACL,mBAAmB,EACnB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,WAAW,GACjB,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,cAAc,EACd,oBAAoB,EACpB,cAAc,EACd,aAAa,EACb,eAAe,EACf,WAAW,EACX,sBAAsB,EACtB,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,cAAc,GACpB,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,EACnB,cAAc,EACd,mBAAmB,EACnB,aAAa,EACb,gBAAgB,EAChB,KAAK,oBAAoB,EACzB,KAAK,sBAAsB,EAC3B,KAAK,QAAQ,GACd,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EACL,aAAa,EACb,cAAc,EACd,iBAAiB,EACjB,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,cAAc,GACpB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,aAAa,EACb,SAAS,EACT,cAAc,EACd,KAAK,SAAS,EACd,KAAK,iBAAiB,EACtB,KAAK,SAAS,GACf,MAAM,cAAc,CAAC;AAGtB,OAAO,EACL,YAAY,EACZ,YAAY,EACZ,eAAe,EACf,KAAK,OAAO,GACb,MAAM,cAAc,CAAC;AAGtB,OAAO,EACL,cAAc,EACd,eAAe,EACf,mBAAmB,EACnB,cAAc,EACd,YAAY,EACZ,aAAa,EACb,iBAAiB,EACjB,KAAK,WAAW,EAChB,KAAK,qBAAqB,GAC3B,MAAM,aAAa,CAAC;AAGrB,OAAO,EACL,QAAQ,EACR,QAAQ,EACR,gBAAgB,EAChB,YAAY,EACZ,KAAK,WAAW,EAChB,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,oBAAoB,GAC1B,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,mBAAmB,EACnB,KAAK,QAAQ,GACd,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,cAAc,EACd,UAAU,EACV,SAAS,EACT,gBAAgB,EAChB,WAAW,GACZ,MAAM,cAAc,CAAC;AAGtB,OAAO,EACL,mBAAmB,EACnB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,WAAW,GACjB,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,cAAc,EACd,oBAAoB,EACpB,cAAc,EACd,aAAa,EACb,eAAe,EACf,WAAW,EACX,sBAAsB,EACtB,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,cAAc,GACpB,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,EACnB,cAAc,EACd,mBAAmB,EACnB,aAAa,EACb,gBAAgB,EAChB,KAAK,oBAAoB,EACzB,KAAK,sBAAsB,EAC3B,KAAK,QAAQ,GACd,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EACL,aAAa,EACb,cAAc,EACd,iBAAiB,EACjB,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,cAAc,GACpB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EACL,gBAAgB,EAChB,wBAAwB,EACxB,KAAK,mBAAmB,GACzB,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EACL,oBAAoB,EACpB,kBAAkB,EAClB,qBAAqB,EACrB,aAAa,EACb,aAAa,EACb,KAAK,kBAAkB,GACxB,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC"}