@hasna/economy 0.2.30 → 0.2.31

package/dist/mcp/index.js

@@ -17,6 +17,60 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
+// src/db/storage-adapter.ts
+import { Database as BunDatabase } from "bun:sqlite";
+
+class SqliteAdapter {
+  db;
+  constructor(path) {
+    this.db = new BunDatabase(path, { create: true });
+  }
+  run(sql, ...params) {
+    const result = this.db.prepare(sql).run(...params);
+    return { changes: result.changes, lastInsertRowid: result.lastInsertRowid };
+  }
+  get(sql, ...params) {
+    return this.db.prepare(sql).get(...params);
+  }
+  all(sql, ...params) {
+    return this.db.prepare(sql).all(...params);
+  }
+  exec(sql) {
+    this.db.exec(sql);
+  }
+  query(sql) {
+    return this.db.query(sql);
+  }
+  prepare(sql) {
+    const statement = this.db.prepare(sql);
+    return {
+      run(...params) {
+        const result = statement.run(...params);
+        return { changes: result.changes, lastInsertRowid: result.lastInsertRowid };
+      },
+      get(...params) {
+        return statement.get(...params);
+      },
+      all(...params) {
+        return statement.all(...params);
+      },
+      finalize() {
+        statement.finalize();
+      }
+    };
+  }
+  close() {
+    this.db.close();
+  }
+  transaction(fn) {
+    return this.db.transaction(fn)();
+  }
+  get raw() {
+    return this.db;
+  }
+}
+var init_storage_adapter = () => {};
+
 // src/lib/pricing.ts
 var exports_pricing = {};
 __export(exports_pricing, {
@@ -513,7 +567,6 @@ var init_pricing = __esm(() => {
 });
 
 // src/db/database.ts
-import { SqliteAdapter as Database } from "@hasna/cloud";
 import { copyFileSync, existsSync, mkdirSync, readdirSync, statSync } from "fs";
 import { hostname } from "os";
 import { homedir } from "os";
@@ -556,7 +609,7 @@ function openDatabase(dbPath, skipSeed = false) {
     if (dir && !existsSync(dir))
       mkdirSync(dir, { recursive: true });
   }
-  const db = new Database(path);
+  const db = new SqliteAdapter(path);
   db.exec("PRAGMA journal_mode = WAL");
   db.exec("PRAGMA busy_timeout = 5000");
   db.exec("PRAGMA foreign_keys = ON");
@@ -1544,7 +1597,10 @@ function dedupeRequests(db) {
   }
   return removed;
 }
-var init_database = () => {};
+var init_database = __esm(() => {
+  init_storage_adapter();
+  init_storage_adapter();
+});
 
 // src/db/pg-migrations.ts
 var exports_pg_migrations = {};
@@ -1755,10 +1811,8 @@ var packageMetadata = getPackageMetadata();
 
 // src/mcp/server.ts
 init_database();
-init_pg_migrations();
 import { randomUUID } from "crypto";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { registerCloudTools } from "@hasna/cloud";
 import { z } from "zod";
 
 // src/ingest/claude.ts
@@ -2237,7 +2291,7 @@ init_pricing();
 import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
 import { homedir as homedir3 } from "os";
 import { join as join3, basename as basename2 } from "path";
-import { Database as BunDatabase } from "bun:sqlite";
+import { Database as BunDatabase2 } from "bun:sqlite";
 var DEFAULT_CODEX_DB_PATH = join3(homedir3(), ".codex", "state_5.sqlite");
 var DEFAULT_CODEX_CONFIG_PATH = join3(homedir3(), ".codex", "config.toml");
 var CODEX_INGEST_VERSION = "rollout-aggregate-v3";
@@ -2275,7 +2329,7 @@ function openCodexDb(dbPath, verbose) {
   for (const readonly of [true, false]) {
     let codexDb = null;
     try {
-      codexDb = readonly ? new BunDatabase(dbPath, { readonly: true }) : new BunDatabase(dbPath);
+      codexDb = readonly ? new BunDatabase2(dbPath, { readonly: true }) : new BunDatabase2(dbPath);
       codexDb.prepare("PRAGMA schema_version").get();
       return codexDb;
     } catch (error) {
@@ -3341,6 +3395,370 @@ init_database();
 
 // src/lib/cloud-sync.ts
 init_database();
+import { homedir as homedir9, platform } from "os";
+import { dirname, join as join9 } from "path";
+
+// src/lib/remote-storage.ts
+import pg from "pg";
+function translatePlaceholders(sql) {
+  let index = 0;
+  return sql.replace(/\?/g, () => `$${++index}`);
+}
+function normalizeParams(params) {
+  const flat = params.length === 1 && Array.isArray(params[0]) ? params[0] : params;
+  return flat.map((value) => value === undefined ? null : value);
+}
+function sslConfigFor(connectionString) {
+  return connectionString.includes("sslmode=require") || connectionString.includes("ssl=true") ? { rejectUnauthorized: false } : undefined;
+}
+
+class PgAdapterAsync {
+  pool;
+  constructor(source) {
+    this.pool = typeof source === "string" ? new pg.Pool({ connectionString: source, ssl: sslConfigFor(source) }) : source;
+  }
+  async run(sql, ...params) {
+    const result = await this.pool.query(translatePlaceholders(sql), normalizeParams(params));
+    return { changes: result.rowCount ?? 0, lastInsertRowid: 0 };
+  }
+  async get(sql, ...params) {
+    const result = await this.pool.query(translatePlaceholders(sql), normalizeParams(params));
+    return result.rows[0] ?? null;
+  }
+  async all(sql, ...params) {
+    const result = await this.pool.query(translatePlaceholders(sql), normalizeParams(params));
+    return result.rows;
+  }
+  async exec(sql) {
+    await this.pool.query(translatePlaceholders(sql));
+  }
+  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 (error) {
+      await client.query("ROLLBACK");
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  get raw() {
+    return this.pool;
+  }
+}
+
+// src/lib/storage-sync.ts
+async function syncPush(local, remote, options) {
+  const tables = await getTableOrder(remote, options.tables);
+  return syncTransfer(local, remote, { ...options, tables }, "push");
+}
+async function syncPull(remote, local, options) {
+  const tables = await getTableOrder(remote, options.tables);
+  return syncTransfer(remote, local, { ...options, tables }, "pull");
+}
+function quoteIdent(identifier) {
+  return `"${identifier.replace(/"/g, '""')}"`;
+}
+async function getTableOrder(remote, tables) {
+  if (tables.length <= 1)
+    return tables;
+  try {
+    const rows = await remote.all(`
+      SELECT DISTINCT
+        tc.table_name AS source_table,
+        ccu.table_name AS referenced_table
+      FROM information_schema.table_constraints tc
+      JOIN information_schema.constraint_column_usage ccu
+        ON tc.constraint_name = ccu.constraint_name
+        AND tc.table_schema = ccu.table_schema
+      WHERE tc.constraint_type = 'FOREIGN KEY'
+        AND tc.table_schema = 'public'
+    `);
+    if (rows.length > 0)
+      return topoSort(tables, rows);
+  } catch {}
+  return tables;
+}
+function topoSort(tables, foreignKeys) {
+  const allowed = new Set(tables);
+  const deps = new Map;
+  for (const table of tables)
+    deps.set(table, new Set);
+  for (const fk of foreignKeys) {
+    if (allowed.has(fk.source_table) && allowed.has(fk.referenced_table)) {
+      deps.get(fk.source_table)?.add(fk.referenced_table);
+    }
+  }
+  const sorted = [];
+  const visited = new Set;
+  const visiting = new Set;
+  function visit(table) {
+    if (visited.has(table))
+      return;
+    if (visiting.has(table)) {
+      visited.add(table);
+      sorted.push(table);
+      return;
+    }
+    visiting.add(table);
+    for (const dep of deps.get(table) ?? [])
+      visit(dep);
+    visiting.delete(table);
+    visited.add(table);
+    sorted.push(table);
+  }
+  for (const table of tables)
+    visit(table);
+  return sorted;
+}
+async function resolvePrimaryKeys(source, target, table, option) {
+  if (option)
+    return Array.isArray(option) ? option : [option];
+  const sourceKeys = await detectPrimaryKeys(source, table);
+  if (sourceKeys.length > 0)
+    return sourceKeys;
+  return detectPrimaryKeys(target, table);
+}
+async function detectPrimaryKeys(adapter, table) {
+  if (isAsyncAdapter(adapter)) {
+    try {
+      const rows = await adapter.all(`
+        SELECT kcu.column_name, kcu.ordinal_position
+        FROM information_schema.table_constraints tc
+        JOIN information_schema.key_column_usage kcu
+          ON tc.constraint_name = kcu.constraint_name
+          AND tc.table_schema = kcu.table_schema
+        WHERE tc.constraint_type = 'PRIMARY KEY'
+          AND tc.table_schema = 'public'
+          AND tc.table_name = ?
+        ORDER BY kcu.ordinal_position
+      `, table);
+      return rows.map((row) => row.column_name);
+    } catch {
+      return [];
+    }
+  }
+  try {
+    const rows = adapter.all(`PRAGMA table_info(${quoteIdent(table)})`);
+    return rows.filter((row) => row.pk > 0).sort((a, b) => a.pk - b.pk).map((row) => row.name);
+  } catch {
+    return [];
+  }
+}
+async function ensureTablesExist(source, target, tables) {
+  if (!isAsyncAdapter(source) || isAsyncAdapter(target))
+    return;
+  for (const table of tables)
+    await ensureTableInSqliteFromPg(target, source, table);
+}
+async function ensureTableInSqliteFromPg(target, source, table) {
+  const existing = target.all(`SELECT name FROM sqlite_master WHERE type='table' AND name=?`, table);
+  if (existing.length > 0)
+    return;
+  const columns = await source.all(`
+    SELECT column_name, data_type, is_nullable
+    FROM information_schema.columns
+    WHERE table_schema = 'public' AND table_name = ?
+    ORDER BY ordinal_position
+  `, table);
+  if (columns.length === 0)
+    return;
+  const primaryKeys = new Set(await detectPrimaryKeys(source, table));
+  const definitions = columns.filter((column) => !["tsvector", "tsquery"].includes(column.data_type.toLowerCase())).map((column) => {
+    const type = pgTypeToSqlite(column.data_type);
+    const notNull = column.is_nullable === "NO" && !primaryKeys.has(column.column_name) ? " NOT NULL" : "";
+    return `${quoteIdent(column.column_name)} ${type}${notNull}`;
+  });
+  if (primaryKeys.size > 0) {
+    definitions.push(`PRIMARY KEY (${[...primaryKeys].map(quoteIdent).join(", ")})`);
+  }
+  target.exec(`CREATE TABLE IF NOT EXISTS ${quoteIdent(table)} (${definitions.join(", ")})`);
+}
+function pgTypeToSqlite(pgType) {
+  const type = pgType.toLowerCase();
+  if (type.includes("int") || ["bigint", "smallint", "serial", "bigserial"].includes(type))
+    return "INTEGER";
+  if (type.includes("bool"))
+    return "INTEGER";
+  if (type.includes("float") || type.includes("double") || ["real", "numeric", "decimal"].includes(type))
+    return "REAL";
+  if (type === "bytea")
+    return "BLOB";
+  return "TEXT";
+}
+async function filterColumnsForTarget(target, table, columns) {
+  if (columns.includes("machine_id") && table !== "machines")
+    await ensureMachineIdColumnInTarget(target, table);
+  try {
+    if (isAsyncAdapter(target)) {
+      const rows2 = await target.all(`
+        SELECT column_name
+        FROM information_schema.columns
+        WHERE table_schema = 'public' AND table_name = ?
+      `, table);
+      if (rows2.length === 0)
+        return columns;
+      const targetColumns2 = new Set(rows2.map((row) => row.column_name));
+      return columns.filter((column) => targetColumns2.has(column));
+    }
+    const rows = target.all(`PRAGMA table_info(${quoteIdent(table)})`);
+    if (rows.length === 0)
+      return columns;
+    const targetColumns = new Set(rows.map((row) => row.name));
+    return columns.filter((column) => targetColumns.has(column));
+  } catch {
+    return columns;
+  }
+}
+async function ensureMachineIdColumnInTarget(target, table) {
+  if (isAsyncAdapter(target)) {
+    const rows2 = await target.all(`
+      SELECT column_name
+      FROM information_schema.columns
+      WHERE table_schema = 'public' AND table_name = ? AND column_name = 'machine_id'
+    `, table);
+    if (rows2.length === 0)
+      await target.exec(`ALTER TABLE ${quoteIdent(table)} ADD COLUMN machine_id TEXT DEFAULT ''`);
+    return;
+  }
+  const rows = target.all(`PRAGMA table_info(${quoteIdent(table)})`);
+  if (!rows.some((row) => row.name === "machine_id")) {
+    target.exec(`ALTER TABLE ${quoteIdent(table)} ADD COLUMN machine_id TEXT DEFAULT ''`);
+  }
+}
+async function syncTransfer(source, target, options, _direction) {
+  const { tables, onProgress, batchSize = 100, conflictColumn = "updated_at", primaryKey } = options;
+  const results = [];
+  const sqliteTarget = isAsyncAdapter(target) ? null : target;
+  await ensureTablesExist(source, target, tables);
+  if (sqliteTarget) {
+    try {
+      sqliteTarget.exec("PRAGMA foreign_keys = OFF");
+    } catch {}
+  }
+  try {
+    for (let i = 0;i < tables.length; i++) {
+      const table = tables[i];
+      const result = { table, rowsRead: 0, rowsWritten: 0, rowsSkipped: 0, errors: [] };
+      try {
+        onProgress?.({ table, phase: "reading", rowsRead: 0, rowsWritten: 0, totalTables: tables.length, currentTableIndex: i });
+        const rows = await readAll(source, `SELECT * FROM ${quoteIdent(table)}`);
+        result.rowsRead = rows.length;
+        if (rows.length === 0) {
+          onProgress?.({ table, phase: "done", rowsRead: 0, rowsWritten: 0, totalTables: tables.length, currentTableIndex: i });
+          results.push(result);
+          continue;
+        }
+        const sourceColumns = Object.keys(rows[0]);
+        const columns = await filterColumnsForTarget(target, table, sourceColumns);
+        const primaryKeys = await resolvePrimaryKeys(source, target, table, primaryKey);
+        if (primaryKeys.length === 0) {
+          result.errors.push(`Table "${table}" has no primary key; inserted without conflict handling`);
+          for (const batch of batches(rows, batchSize)) {
+            await insertBatch(target, table, columns, batch);
+            result.rowsWritten += batch.length;
+          }
+          results.push(result);
+          continue;
+        }
+        const missingKeys = primaryKeys.filter((key) => !columns.includes(key));
+        if (missingKeys.length > 0) {
+          result.errors.push(`Table "${table}" missing primary key column(s): ${missingKeys.join(", ")}`);
+          results.push(result);
+          continue;
+        }
+        onProgress?.({ table, phase: "writing", rowsRead: result.rowsRead, rowsWritten: 0, totalTables: tables.length, currentTableIndex: i });
+        const updateColumns = columns.filter((column) => !primaryKeys.includes(column));
+        const newestWinsColumn = columns.includes(conflictColumn) ? conflictColumn : undefined;
+        for (const batch of batches(rows, batchSize)) {
+          await upsertBatch(target, table, columns, updateColumns, primaryKeys, batch, newestWinsColumn);
+          result.rowsWritten += batch.length;
+          onProgress?.({ table, phase: "writing", rowsRead: result.rowsRead, rowsWritten: result.rowsWritten, totalTables: tables.length, currentTableIndex: i });
+        }
+        onProgress?.({ table, phase: "done", rowsRead: result.rowsRead, rowsWritten: result.rowsWritten, totalTables: tables.length, currentTableIndex: i });
+      } catch (error) {
+        result.errors.push(error instanceof Error ? error.message : String(error));
+      }
+      results.push(result);
+    }
+  } finally {
+    if (sqliteTarget) {
+      try {
+        sqliteTarget.exec("PRAGMA foreign_keys = ON");
+      } catch {}
+    }
+  }
+  return results;
+}
+function batches(rows, size) {
+  const result = [];
+  for (let offset = 0;offset < rows.length; offset += size)
+    result.push(rows.slice(offset, offset + size));
+  return result;
+}
+async function upsertBatch(target, table, columns, updateColumns, primaryKeys, batch, conflictColumn) {
+  if (batch.length === 0 || columns.length === 0)
+    return;
+  const fallbackKey = primaryKeys[0] ?? columns[0] ?? "id";
+  const columnList = columns.map(quoteIdent).join(", ");
+  const keyList = primaryKeys.map(quoteIdent).join(", ");
+  const setClause = updateColumns.length > 0 ? updateColumns.map((column) => `${quoteIdent(column)} = EXCLUDED.${quoteIdent(column)}`).join(", ") : `${quoteIdent(fallbackKey)} = EXCLUDED.${quoteIdent(fallbackKey)}`;
+  const whereClause = conflictColumn && updateColumns.includes(conflictColumn) ? ` WHERE ${quoteIdent(table)}.${quoteIdent(conflictColumn)} IS NULL OR EXCLUDED.${quoteIdent(conflictColumn)} >= ${quoteIdent(table)}.${quoteIdent(conflictColumn)}` : "";
+  if (isAsyncAdapter(target)) {
+    const placeholders2 = batch.map((_, rowIndex) => `(${columns.map((__, columnIndex) => `$${rowIndex * columns.length + columnIndex + 1}`).join(", ")})`).join(", ");
+    const params2 = batch.flatMap((row) => columns.map((column) => row[column] ?? null));
+    await target.run(`INSERT INTO ${quoteIdent(table)} (${columnList}) VALUES ${placeholders2}
+       ON CONFLICT (${keyList}) DO UPDATE SET ${setClause}${whereClause}`, ...params2);
+    return;
+  }
+  const placeholders = batch.map(() => `(${columns.map(() => "?").join(", ")})`).join(", ");
+  const params = batch.flatMap((row) => columns.map((column) => coerceForSqlite(row[column])));
+  target.run(`INSERT INTO ${quoteIdent(table)} (${columnList}) VALUES ${placeholders}
+     ON CONFLICT (${keyList}) DO UPDATE SET ${setClause}${whereClause}`, ...params);
+}
+async function insertBatch(target, table, columns, batch) {
+  if (batch.length === 0 || columns.length === 0)
+    return;
+  const columnList = columns.map(quoteIdent).join(", ");
+  if (isAsyncAdapter(target)) {
+    const placeholders2 = batch.map((_, rowIndex) => `(${columns.map((__, columnIndex) => `$${rowIndex * columns.length + columnIndex + 1}`).join(", ")})`).join(", ");
+    const params2 = batch.flatMap((row) => columns.map((column) => row[column] ?? null));
+    await target.run(`INSERT INTO ${quoteIdent(table)} (${columnList}) VALUES ${placeholders2}`, ...params2);
+    return;
+  }
+  const placeholders = batch.map(() => `(${columns.map(() => "?").join(", ")})`).join(", ");
+  const params = batch.flatMap((row) => columns.map((column) => coerceForSqlite(row[column])));
+  target.run(`INSERT INTO ${quoteIdent(table)} (${columnList}) VALUES ${placeholders}`, ...params);
+}
+function coerceForSqlite(value) {
+  if (value === null || value === undefined)
+    return null;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean")
+    return value;
+  if (value instanceof Date)
+    return value.toISOString();
+  if (Buffer.isBuffer(value) || value instanceof Uint8Array)
+    return value;
+  if (typeof value === "object")
+    return JSON.stringify(value);
+  return String(value);
+}
+function isAsyncAdapter(adapter) {
+  return adapter instanceof PgAdapterAsync;
+}
+async function readAll(adapter, sql) {
+  const rows = adapter.all(sql);
+  return rows instanceof Promise ? await rows : rows;
+}
+
+// src/lib/cloud-sync.ts
 var CLOUD_TABLES = [
   "requests",
   "sessions",
@@ -3373,7 +3791,6 @@ async function getCloudPg() {
   if (!url) {
     throw new Error("Missing ECONOMY_CLOUD_DATABASE_URL (or HASNA_ECONOMY_CLOUD_DATABASE_URL)");
   }
-  const { PgAdapterAsync } = await import("@hasna/cloud");
   return new PgAdapterAsync(url);
 }
 async function runCloudMigrations(cloud) {
@@ -3383,40 +3800,57 @@ async function runCloudMigrations(cloud) {
   }
 }
 async function cloudPush(opts) {
-  const { syncPush, SqliteAdapter } = await import("@hasna/cloud");
   const cloud = await getCloudPg();
-  const local = new SqliteAdapter(getDbPath());
-  await runCloudMigrations(cloud);
-  const tables = opts?.tables ?? [...CLOUD_TABLES];
-  const results = await syncPush(local, cloud, { tables, conflictColumn: "updated_at" });
-  const rows = results.reduce((s, r) => s + r.rowsWritten, 0);
-  touchMachineRegistry(local, "push");
-  local.close();
-  await cloud.close();
-  return { rows, machine: getMachineId() };
+  const local = openDatabase(getDbPath(), true);
+  try {
+    await runCloudMigrations(cloud);
+    touchMachineRegistry(local, "push");
+    const tables = resolveCloudTables(opts?.tables);
+    const results = await syncPush(local, cloud, { tables, conflictColumn: "updated_at" });
+    const rows = results.reduce((sum, result) => sum + result.rowsWritten, 0);
+    return { rows, machine: getMachineId() };
+  } finally {
+    local.close();
+    await cloud.close();
+  }
 }
 async function cloudPull(opts) {
-  const { syncPull, SqliteAdapter } = await import("@hasna/cloud");
   const cloud = await getCloudPg();
-  const local = new SqliteAdapter(getDbPath());
-  await runCloudMigrations(cloud);
-  const tables = opts?.tables ?? [...CLOUD_TABLES];
-  const results = await syncPull(cloud, local, { tables, conflictColumn: "updated_at" });
-  const rows = results.reduce((s, r) => s + r.rowsWritten, 0);
-  touchMachineRegistry(local, "pull");
-  local.close();
-  await cloud.close();
-  setLastCloudPull();
-  return { rows, machine: getMachineId() };
+  const local = openDatabase(getDbPath(), true);
+  try {
+    await runCloudMigrations(cloud);
+    const tables = resolveCloudTables(opts?.tables);
+    const results = await syncPull(cloud, local, { tables, conflictColumn: "updated_at" });
+    const rows = results.reduce((sum, result) => sum + result.rowsWritten, 0);
+    touchMachineRegistry(local, "pull");
+    setLastCloudPull();
+    return { rows, machine: getMachineId() };
+  } finally {
+    local.close();
+    await cloud.close();
+  }
+}
+async function cloudSyncFull() {
+  const push = await cloudPush();
+  const pull = await cloudPull();
+  return { push: push.rows, pull: pull.rows, machine: getMachineId() };
 }
 function setLastCloudPull(at = new Date().toISOString()) {
-  const db = openDatabase();
-  db.prepare(`INSERT OR REPLACE INTO ingest_state (source, key, value) VALUES ('cloud', 'last_pull_at', ?)`).run(at);
+  const db = openDatabase(undefined, true);
+  try {
+    db.prepare(`INSERT OR REPLACE INTO ingest_state (source, key, value) VALUES ('cloud', 'last_pull_at', ?)`).run(at);
+  } finally {
+    db.close();
+  }
 }
 function getLastCloudPull() {
-  const db = openDatabase();
-  const row = db.prepare(`SELECT value FROM ingest_state WHERE source = 'cloud' AND key = 'last_pull_at'`).get();
-  return row?.value ?? null;
+  const db = openDatabase(undefined, true);
+  try {
+    const row = db.prepare(`SELECT value FROM ingest_state WHERE source = 'cloud' AND key = 'last_pull_at'`).get();
+    return row?.value ?? null;
+  } finally {
+    db.close();
+  }
 }
 function shouldPullFromCloud() {
   if (!getCloudDatabaseUrl())
@@ -3462,6 +3896,19 @@ function touchMachineRegistry(db, direction) {
       updated_at = excluded.updated_at
   `).run(machine, machine, now, direction === "push" ? now : null, direction === "pull" ? now : null, packageMetadata.version, now, direction, direction);
 }
+function resolveCloudTables(tables) {
+  if (!tables || tables.length === 0)
+    return [...CLOUD_TABLES];
+  const allowed = new Set(CLOUD_TABLES);
+  const requested = tables.map((table) => table.trim()).filter(Boolean);
+  const invalid = requested.filter((table) => !allowed.has(table));
+  if (invalid.length > 0) {
+    throw new Error(`Unknown economy sync table(s): ${invalid.join(", ")}`);
+  }
+  return requested;
+}
+var SCHEDULE_CONFIG_DIR = join9(homedir9(), ".hasna", "economy");
+var SCHEDULE_CONFIG_PATH = join9(SCHEDULE_CONFIG_DIR, "cloud-sync-schedule.json");
 
 // src/lib/sync-all.ts
 async function syncAll(db, opts = {}) {
@@ -3573,6 +4020,10 @@ function buildServer() {
     "set_subscription",
     "remove_subscription",
     "sync",
+    "cloud_status",
+    "cloud_push",
+    "cloud_pull",
+    "cloud_sync",
     "search_tools",
     "describe_tools",
     "get_goals",
@@ -3609,6 +4060,10 @@ function buildServer() {
     set_subscription: `provider, plan, monthly_fee_usd?, included_usage_usd?, agent?(${AGENTS.join("|")}) -> create/update subscription plan`,
     remove_subscription: "id -> delete subscription plan",
     sync: `sources(all|${AGENTS.join("|")}) -> ingest latest cost data`,
+    cloud_status: "no params -> check configured economy PostgreSQL remote and synced tables",
+    cloud_push: "tables?[] -> push local economy SQLite rows to remote PostgreSQL",
+    cloud_pull: "tables?[] -> pull remote PostgreSQL rows into local economy SQLite",
+    cloud_sync: "no params -> push local rows, then pull remote rows",
     search_tools: "query substring -> tool name list",
     describe_tools: "names[] -> one-line parameter hints",
     get_goals: "no params -> goal progress summary",
@@ -3866,6 +4321,31 @@ function buildServer() {
     const result = await syncAll(db, opts);
     return text(JSON.stringify(result, null, 2));
   });
+  server.tool("cloud_status", "Check configured economy PostgreSQL remote and synced tables.", {}, async () => {
+    const url = getCloudDatabaseUrl();
+    if (!url)
+      return text("cloud: not configured");
+    let cloud = null;
+    try {
+      cloud = await getCloudPg();
+      await cloud.get("SELECT 1 as ok");
+      const tables = await cloud.all("SELECT tablename FROM pg_tables WHERE schemaname = 'public' ORDER BY tablename");
+      return text([
+        "cloud: connected",
+        `database: ${url.replace(/:[^:@/]+@/, ":***@")}`,
+        `tables: ${tables.map((row) => row.tablename).join(", ") || "none"}`
+      ].join(`
+`));
+    } catch (error) {
+      return textError(`cloud: ${error instanceof Error ? error.message : String(error)}`);
+    } finally {
+      if (cloud)
+        await cloud.close().catch(() => {});
+    }
+  });
+  server.tool("cloud_push", "Push local economy SQLite rows to remote PostgreSQL.", { tables: z.array(z.string()).optional() }, async ({ tables }) => text(JSON.stringify(await cloudPush({ tables }), null, 2)));
+  server.tool("cloud_pull", "Pull remote PostgreSQL rows into local economy SQLite.", { tables: z.array(z.string()).optional() }, async ({ tables }) => text(JSON.stringify(await cloudPull({ tables }), null, 2)));
+  server.tool("cloud_sync", "Push local rows, then pull remote rows.", {}, async () => text(JSON.stringify(await cloudSyncFull(), null, 2)));
   server.tool("get_usage", "Usage snapshots and fleet summary. period: today|week|month|year|all", { period: z.enum(["today", "week", "month", "year", "all"]).optional(), agent: z.enum(AGENTS).optional() }, async ({ period, agent }) => {
     const p = period ?? "month";
     const snaps = queryUsageSnapshots(db, { agent, ...usageSnapshotFilterForPeriod(p) });
@@ -4009,10 +4489,6 @@ current machine: ${getMachineId()}`);
       return textError(String(error));
     }
   });
-  registerCloudTools(server, MCP_NAME, {
-    dbPath: getDbPath(),
-    migrations: PG_MIGRATIONS
-  });
   return server;
 }
 

package/dist/mcp/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/mcp/server.ts"],"names":[],"mappings":"AAiBA,eAAO,MAAM,QAAQ,YAAY,CAAA;AACjC,eAAO,MAAM,qBAAqB,OAAO,CAAA;AAEzC,wBAAgB,WAAW,IAAI,GAAG,CAssBjC"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/mcp/server.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,QAAQ,YAAY,CAAA;AACjC,eAAO,MAAM,qBAAqB,OAAO,CAAA;AAEzC,wBAAgB,WAAW,IAAI,GAAG,CAyvBjC"}