@hasna/machines 0.0.14 → 0.0.16

package/dist/index.js

@@ -6515,8 +6515,11 @@ var require_dist = __commonJS((exports, module) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.default = formatsPlugin;
 });
-// src/cross-project-types.ts
-var CROSSREFS_KEY = "_crossRefs";
+
+// src/db.ts
+import { Database } from "bun:sqlite";
+import { hostname } from "os";
+
 // src/paths.ts
 import { existsSync, mkdirSync } from "fs";
 import { dirname, join, resolve } from "path";
@@ -6554,9 +6557,8 @@ function ensureDataDir() {
   ensureParentDir(join(dir, ".keep"));
   return dir;
 }
+
 // src/db.ts
-import { Database } from "bun:sqlite";
-import { hostname } from "os";
 class SqliteAdapter {
   raw;
   constructor(path) {
@@ -6620,6 +6622,12 @@ function getAdapter(path = getDbPath()) {
 function getDb(path = getDbPath()) {
   return getAdapter(path).raw;
 }
+function closeDb() {
+  if (adapter) {
+    adapter.close();
+    adapter = null;
+  }
+}
 function upsertHeartbeat(machineId, pid = process.pid, status = "online") {
   const db = getDb();
   db.query(`INSERT INTO agent_heartbeats (machine_id, pid, status, updated_at)
@@ -6666,6 +6674,336 @@ function recordSyncRun(machineId, status, actions) {
   db.query(`INSERT INTO sync_runs (id, machine_id, status, actions_json, created_at, updated_at)
      VALUES (?, ?, ?, ?, ?, ?)`).run(crypto.randomUUID(), machineId, status, JSON.stringify(actions), now, now);
 }
+
+// src/pg-migrations.ts
+var PG_MIGRATIONS = [
+  `
+  CREATE TABLE IF NOT EXISTS agent_heartbeats (
+    machine_id TEXT NOT NULL,
+    pid INTEGER NOT NULL,
+    status TEXT NOT NULL,
+    updated_at TIMESTAMPTZ NOT NULL,
+    PRIMARY KEY (machine_id, pid)
+  );
+
+  CREATE TABLE IF NOT EXISTS setup_runs (
+    id TEXT PRIMARY KEY,
+    machine_id TEXT NOT NULL,
+    status TEXT NOT NULL,
+    details_json TEXT NOT NULL DEFAULT '[]',
+    created_at TIMESTAMPTZ NOT NULL,
+    updated_at TIMESTAMPTZ NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS sync_runs (
+    id TEXT PRIMARY KEY,
+    machine_id TEXT NOT NULL,
+    status TEXT NOT NULL,
+    actions_json TEXT NOT NULL DEFAULT '[]',
+    created_at TIMESTAMPTZ NOT NULL,
+    updated_at TIMESTAMPTZ NOT NULL
+  );
+  `
+];
+
+// src/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(connectionString) {
+    this.pool = new pg.Pool({ connectionString, ssl: sslConfigFor(connectionString) });
+  }
+  async run(sql, ...params) {
+    const result = await this.pool.query(translatePlaceholders(sql), normalizeParams(params));
+    return { changes: result.rowCount ?? 0 };
+  }
+  async all(sql, ...params) {
+    const result = await this.pool.query(translatePlaceholders(sql), normalizeParams(params));
+    return result.rows;
+  }
+  async close() {
+    await this.pool.end();
+  }
+}
+
+// src/storage-sync.ts
+var STORAGE_TABLES = [
+  "agent_heartbeats",
+  "setup_runs",
+  "sync_runs"
+];
+var MACHINES_STORAGE_TABLES = STORAGE_TABLES;
+var MACHINES_STORAGE_ENV = "HASNA_MACHINES_DATABASE_URL";
+var MACHINES_STORAGE_FALLBACK_ENV = "MACHINES_DATABASE_URL";
+var MACHINES_STORAGE_MODE_ENV = "HASNA_MACHINES_STORAGE_MODE";
+var MACHINES_STORAGE_MODE_FALLBACK_ENV = "MACHINES_STORAGE_MODE";
+var STORAGE_DATABASE_ENV = [MACHINES_STORAGE_ENV, MACHINES_STORAGE_FALLBACK_ENV];
+var STORAGE_MODE_ENV = [MACHINES_STORAGE_MODE_ENV, MACHINES_STORAGE_MODE_FALLBACK_ENV];
+var PRIMARY_KEYS = {
+  agent_heartbeats: ["machine_id", "pid"],
+  setup_runs: ["id"],
+  sync_runs: ["id"]
+};
+function readEnv(name) {
+  const value = process.env[name]?.trim();
+  return value || undefined;
+}
+function normalizeStorageMode(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (normalized === "local" || normalized === "hybrid" || normalized === "remote")
+    return normalized;
+  return;
+}
+function getStorageDatabaseEnvName() {
+  for (const name of STORAGE_DATABASE_ENV) {
+    if (readEnv(name))
+      return name;
+  }
+  return null;
+}
+function getStorageDatabaseEnv() {
+  const name = getStorageDatabaseEnvName();
+  return name ? { name } : null;
+}
+function getStorageDatabaseUrl() {
+  const env = getStorageDatabaseEnv();
+  return env ? readEnv(env.name) ?? null : null;
+}
+function getStorageMode() {
+  const mode = normalizeStorageMode(readEnv(MACHINES_STORAGE_MODE_ENV)) ?? normalizeStorageMode(readEnv(MACHINES_STORAGE_MODE_FALLBACK_ENV));
+  if (mode)
+    return mode;
+  return getStorageDatabaseUrl() ? "hybrid" : "local";
+}
+async function getStoragePg() {
+  const url = getStorageDatabaseUrl();
+  if (!url) {
+    throw new Error("Missing HASNA_MACHINES_DATABASE_URL or MACHINES_DATABASE_URL");
+  }
+  return new PgAdapterAsync(url);
+}
+async function runStorageMigrations(remote) {
+  for (const sql of PG_MIGRATIONS)
+    await remote.run(sql);
+}
+async function storagePush(options) {
+  const remote = await getStoragePg();
+  const db = getDb();
+  try {
+    await runStorageMigrations(remote);
+    const results = [];
+    for (const table of resolveTables(options?.tables)) {
+      results.push(await pushTable(db, remote, table));
+    }
+    recordSyncMeta(db, "push", results);
+    return results;
+  } finally {
+    await remote.close();
+  }
+}
+async function storagePull(options) {
+  const remote = await getStoragePg();
+  const db = getDb();
+  try {
+    await runStorageMigrations(remote);
+    const results = [];
+    for (const table of resolveTables(options?.tables)) {
+      results.push(await pullTable(remote, db, table));
+    }
+    recordSyncMeta(db, "pull", results);
+    return results;
+  } finally {
+    await remote.close();
+  }
+}
+async function storageSync(options) {
+  const pull = await storagePull(options);
+  const push = await storagePush(options);
+  return { pull, push };
+}
+function getSyncMetaAll() {
+  const db = getDb();
+  ensureSyncMetaTable(db);
+  return db.query("SELECT table_name, last_synced_at, direction FROM _machines_sync_meta ORDER BY table_name, direction").all();
+}
+function getStorageStatus() {
+  const activeEnv = getStorageDatabaseEnv();
+  return {
+    configured: Boolean(activeEnv),
+    mode: getStorageMode(),
+    env: STORAGE_DATABASE_ENV,
+    activeEnv: activeEnv?.name ?? null,
+    service: "machines",
+    tables: STORAGE_TABLES,
+    sync: getSyncMetaAll()
+  };
+}
+function resolveTables(tables) {
+  if (!tables || tables.length === 0)
+    return [...STORAGE_TABLES];
+  const allowed = new Set(STORAGE_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 machines storage table(s): ${invalid.join(", ")}`);
+  return requested;
+}
+function parseStorageTables(value) {
+  if (!value)
+    return;
+  return resolveTables(Array.isArray(value) ? value : value.split(","));
+}
+async function pushTable(db, remote, table) {
+  const result = { table, rowsRead: 0, rowsWritten: 0, errors: [] };
+  try {
+    if (!tableExists(db, table))
+      return result;
+    const rows = db.query(`SELECT * FROM ${quoteIdent(table)}`).all();
+    result.rowsRead = rows.length;
+    if (rows.length === 0)
+      return result;
+    const remoteColumns = await getRemoteColumns(remote, table);
+    const columns = filterRemoteColumns(remoteColumns, Object.keys(rows[0]));
+    result.rowsWritten = await upsertPg(remote, table, columns, rows);
+  } catch (error) {
+    result.errors.push(error instanceof Error ? error.message : String(error));
+  }
+  return result;
+}
+async function pullTable(remote, db, table) {
+  const result = { table, rowsRead: 0, rowsWritten: 0, errors: [] };
+  try {
+    if (!tableExists(db, table))
+      return result;
+    const rows = await remote.all(`SELECT * FROM ${quoteIdent(table)}`);
+    result.rowsRead = rows.length;
+    if (rows.length === 0)
+      return result;
+    const columns = filterLocalColumns(db, table, Object.keys(rows[0]));
+    result.rowsWritten = upsertSqlite(db, table, columns, rows);
+  } catch (error) {
+    result.errors.push(error instanceof Error ? error.message : String(error));
+  }
+  return result;
+}
+async function getRemoteColumns(remote, table) {
+  const rows = await remote.all("SELECT column_name FROM information_schema.columns WHERE table_schema = 'public' AND table_name = ?", table);
+  return new Set(rows.map((row) => row.column_name));
+}
+function filterRemoteColumns(remoteColumns, columns) {
+  if (remoteColumns.size === 0)
+    return columns;
+  return columns.filter((column) => remoteColumns.has(column));
+}
+function filterLocalColumns(db, table, columns) {
+  const rows = db.query(`PRAGMA table_info(${quoteIdent(table)})`).all();
+  const allowed = new Set(rows.map((row) => row.name));
+  return columns.filter((column) => allowed.has(column));
+}
+async function upsertPg(remote, table, columns, rows) {
+  if (columns.length === 0)
+    return 0;
+  const primaryKeys = PRIMARY_KEYS[table];
+  const columnList = columns.map(quoteIdent).join(", ");
+  const placeholders = columns.map(() => "?").join(", ");
+  const keyList = primaryKeys.map(quoteIdent).join(", ");
+  const updateColumns = columns.filter((column) => !primaryKeys.includes(column));
+  const fallbackKey = primaryKeys[0];
+  const setClause = updateColumns.length > 0 ? updateColumns.map((column) => `${quoteIdent(column)} = EXCLUDED.${quoteIdent(column)}`).join(", ") : `${quoteIdent(fallbackKey)} = EXCLUDED.${quoteIdent(fallbackKey)}`;
+  for (const row of rows) {
+    await remote.run(`INSERT INTO ${quoteIdent(table)} (${columnList}) VALUES (${placeholders})
+       ON CONFLICT (${keyList}) DO UPDATE SET ${setClause}`, ...columns.map((column) => coerceForPg(row[column])));
+  }
+  return rows.length;
+}
+function upsertSqlite(db, table, columns, rows) {
+  if (columns.length === 0)
+    return 0;
+  const primaryKeys = PRIMARY_KEYS[table];
+  const columnList = columns.map(quoteIdent).join(", ");
+  const placeholders = columns.map(() => "?").join(", ");
+  const keyList = primaryKeys.map(quoteIdent).join(", ");
+  const updateColumns = columns.filter((column) => !primaryKeys.includes(column));
+  const fallbackKey = primaryKeys[0];
+  const setClause = updateColumns.length > 0 ? updateColumns.map((column) => `${quoteIdent(column)} = excluded.${quoteIdent(column)}`).join(", ") : `${quoteIdent(fallbackKey)} = excluded.${quoteIdent(fallbackKey)}`;
+  const statement = db.query(`INSERT INTO ${quoteIdent(table)} (${columnList}) VALUES (${placeholders})
+     ON CONFLICT (${keyList}) DO UPDATE SET ${setClause}`);
+  const insert = db.transaction((batch) => {
+    for (const row of batch)
+      statement.run(...columns.map((column) => coerceForSqlite(row[column])));
+  });
+  insert(rows);
+  return rows.length;
+}
+function recordSyncMeta(db, direction, results) {
+  ensureSyncMetaTable(db);
+  const now = new Date().toISOString();
+  const statement = db.query(`
+    INSERT INTO _machines_sync_meta (table_name, last_synced_at, direction)
+    VALUES (?, ?, ?)
+    ON CONFLICT(table_name, direction) DO UPDATE SET last_synced_at = excluded.last_synced_at
+  `);
+  for (const result of results) {
+    if (result.errors.length > 0)
+      continue;
+    statement.run(result.table, now, direction);
+  }
+}
+function ensureSyncMetaTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS _machines_sync_meta (
+      table_name TEXT NOT NULL,
+      last_synced_at TEXT,
+      direction TEXT NOT NULL CHECK(direction IN ('push', 'pull')),
+      PRIMARY KEY (table_name, direction)
+    )
+  `);
+}
+function tableExists(db, table) {
+  const row = db.query("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?").get(table);
+  return Boolean(row);
+}
+function quoteIdent(identifier) {
+  return `"${identifier.replace(/"/g, '""')}"`;
+}
+function coerceForPg(value) {
+  if (value === undefined || value === null)
+    return null;
+  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 value;
+}
+function coerceForSqlite(value) {
+  if (value === undefined || value === null)
+    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);
+}
+// src/cross-project-types.ts
+var CROSSREFS_KEY = "_crossRefs";
 // src/manifests.ts
 import { existsSync as existsSync2, readFileSync, writeFileSync } from "fs";
 import { arch, homedir, hostname as hostname2, platform, userInfo } from "os";
@@ -10746,6 +11084,538 @@ function detectCurrentMachineManifest() {
     files: []
   };
 }
+// src/topology.ts
+import { existsSync as existsSync3 } from "fs";
+import { arch as arch2, hostname as hostname3, platform as platform2, userInfo as userInfo2 } from "os";
+import { spawnSync } from "child_process";
+function normalizePlatform2(value = platform2()) {
+  const normalized = value.toLowerCase();
+  if (normalized === "darwin" || normalized === "macos")
+    return "macos";
+  if (normalized === "win32" || normalized === "windows")
+    return "windows";
+  if (normalized === "linux")
+    return "linux";
+  return value;
+}
+function defaultRunner(command) {
+  const result = spawnSync("bash", ["-c", command], {
+    encoding: "utf8",
+    env: process.env
+  });
+  return {
+    stdout: result.stdout || "",
+    stderr: result.stderr || "",
+    exitCode: result.status ?? 1
+  };
+}
+function hasCommand(command, runner) {
+  return runner(`command -v ${command} >/dev/null 2>&1`).exitCode === 0;
+}
+function parseTailscaleStatus(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object")
+      return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function loadTailscalePeers(runner, warnings) {
+  const peers = new Map;
+  if (!hasCommand("tailscale", runner)) {
+    warnings.push("tailscale_not_available");
+    return peers;
+  }
+  const result = runner("tailscale status --json");
+  if (result.exitCode !== 0) {
+    warnings.push(`tailscale_status_failed:${result.stderr.trim() || result.exitCode}`);
+    return peers;
+  }
+  const status = parseTailscaleStatus(result.stdout);
+  if (!status) {
+    warnings.push("tailscale_status_invalid_json");
+    return peers;
+  }
+  const addPeer = (peer) => {
+    if (!peer)
+      return;
+    const id = peer.HostName || peer.DNSName?.split(".")[0];
+    if (id)
+      peers.set(id, peer);
+  };
+  addPeer(status.Self);
+  for (const peer of Object.values(status.Peer ?? {}))
+    addPeer(peer);
+  return peers;
+}
+function machineKeys(machine) {
+  return [
+    machine.id,
+    machine.hostname,
+    machine.tailscaleName?.split(".")[0],
+    machine.tailscaleName,
+    machine.sshAddress?.split("@").pop()
+  ].filter((value) => Boolean(value));
+}
+function findTailscalePeer(machine, machineId, peers) {
+  if (machine) {
+    for (const key of machineKeys(machine)) {
+      const peer = peers.get(key) ?? peers.get(key.replace(/\.$/, ""));
+      if (peer)
+        return peer;
+    }
+  }
+  return peers.get(machineId) ?? null;
+}
+function routeHints(input) {
+  const hints = [];
+  if (input.machineId === input.localMachineId) {
+    hints.push({ kind: "local", target: "localhost", reachable: true });
+  }
+  if (input.manifest?.sshAddress) {
+    hints.push({ kind: "ssh", target: input.manifest.sshAddress, reachable: null });
+  }
+  if (input.manifest?.hostname) {
+    hints.push({ kind: "lan", target: input.manifest.hostname, reachable: null });
+  }
+  const tailscaleTarget = input.manifest?.tailscaleName ?? input.peer?.DNSName ?? input.peer?.TailscaleIPs?.[0];
+  if (tailscaleTarget) {
+    hints.push({ kind: "tailscale", target: tailscaleTarget.replace(/\.$/, ""), reachable: input.peer?.Online ?? null });
+  }
+  return hints;
+}
+function buildEntry(input) {
+  const manifest = input.manifest;
+  const peer = input.peer;
+  const hints = routeHints({
+    machineId: input.machineId,
+    localMachineId: input.localMachineId,
+    manifest,
+    peer
+  });
+  const selectedRoute = hints.find((hint) => hint.kind === "local") ?? hints.find((hint) => hint.kind === "ssh") ?? hints.find((hint) => hint.kind === "lan") ?? hints.find((hint) => hint.kind === "tailscale");
+  const route = selectedRoute?.kind === "ssh" ? "lan" : selectedRoute?.kind ?? "unknown";
+  return {
+    machine_id: input.machineId,
+    hostname: manifest?.hostname ?? peer?.HostName ?? null,
+    platform: manifest?.platform ?? (peer?.OS ? normalizePlatform2(peer.OS) : null),
+    os: peer?.OS ?? null,
+    user: typeof manifest?.metadata?.user === "string" ? manifest.metadata.user : null,
+    workspace_path: manifest?.workspacePath ?? null,
+    manifest_declared: Boolean(manifest),
+    heartbeat_status: input.heartbeat?.status ?? "unknown",
+    last_heartbeat_at: input.heartbeat?.updated_at ?? null,
+    tailscale: {
+      dns_name: manifest?.tailscaleName ?? peer?.DNSName?.replace(/\.$/, "") ?? null,
+      ips: peer?.TailscaleIPs ?? [],
+      online: peer?.Online ?? null,
+      active: peer?.Active ?? null,
+      last_seen: peer?.LastSeen ?? null
+    },
+    ssh: {
+      address: manifest?.sshAddress ?? null,
+      route,
+      command_target: selectedRoute?.target ?? null
+    },
+    route_hints: hints,
+    tags: manifest?.tags ?? [],
+    metadata: manifest?.metadata ?? {}
+  };
+}
+function discoverMachineTopology(options = {}) {
+  const now = options.now ?? new Date;
+  const runner = options.runner ?? defaultRunner;
+  const warnings = [];
+  const manifest = readManifest();
+  const heartbeats = listHeartbeats();
+  const heartbeatByMachine = new Map(heartbeats.map((heartbeat) => [heartbeat.machine_id, heartbeat]));
+  const localMachineId = getLocalMachineId();
+  const peers = options.includeTailscale === false ? new Map : loadTailscalePeers(runner, warnings);
+  const machineIds = new Set([
+    localMachineId,
+    ...manifest.machines.map((machine) => machine.id),
+    ...heartbeats.map((heartbeat) => heartbeat.machine_id),
+    ...peers.keys()
+  ]);
+  const manifestById = new Map(manifest.machines.map((machine) => [machine.id, machine]));
+  const machines = [...machineIds].sort().map((machineId) => {
+    const manifestMachine = manifestById.get(machineId);
+    return buildEntry({
+      machineId,
+      localMachineId,
+      manifest: manifestMachine,
+      peer: findTailscalePeer(manifestMachine ?? null, machineId, peers),
+      heartbeat: heartbeatByMachine.get(machineId)
+    });
+  });
+  return {
+    generated_at: now.toISOString(),
+    local_machine_id: localMachineId,
+    local_hostname: hostname3(),
+    current_platform: normalizePlatform2(),
+    manifest_path_known: existsSync3(getManifestPath()),
+    machines,
+    warnings
+  };
+}
+function getLocalMachineTopology(options = {}) {
+  const topology = discoverMachineTopology(options);
+  return topology.machines.find((machine) => machine.machine_id === topology.local_machine_id) ?? {
+    machine_id: topology.local_machine_id,
+    hostname: hostname3(),
+    platform: normalizePlatform2(),
+    os: platform2(),
+    user: userInfo2().username,
+    workspace_path: null,
+    manifest_declared: false,
+    heartbeat_status: "unknown",
+    last_heartbeat_at: null,
+    tailscale: { dns_name: null, ips: [], online: null, active: null, last_seen: null },
+    ssh: { address: null, route: "local", command_target: "localhost" },
+    route_hints: [{ kind: "local", target: "localhost", reachable: true }],
+    tags: [`arch:${arch2()}`],
+    metadata: {}
+  };
+}
+// src/remote.ts
+import { spawnSync as spawnSync3 } from "child_process";
+import { hostname as hostname4 } from "os";
+
+// src/commands/ssh.ts
+import { spawnSync as spawnSync2 } from "child_process";
+function envReachableHosts() {
+  const raw = process.env["HASNA_MACHINES_REACHABLE_HOSTS"];
+  return new Set((raw || "").split(",").map((value) => value.trim()).filter(Boolean));
+}
+function isReachable(host) {
+  const overrides = envReachableHosts();
+  if (overrides.size > 0) {
+    return overrides.has(host);
+  }
+  const probe = spawnSync2("bash", ["-lc", `getent hosts ${host} >/dev/null 2>&1 || ping -c 1 -W 1 ${host} >/dev/null 2>&1`], {
+    stdio: "ignore"
+  });
+  return probe.status === 0;
+}
+function resolveSshTarget(machineId) {
+  const machine = getManifestMachine(machineId);
+  if (!machine) {
+    throw new Error(`Machine not found in manifest: ${machineId}`);
+  }
+  const current = detectCurrentMachineManifest();
+  if (machine.id === current.id) {
+    return {
+      machineId,
+      target: "localhost",
+      route: "local"
+    };
+  }
+  const lanTarget = machine.sshAddress || machine.hostname || machine.id;
+  const tailscaleTarget = machine.tailscaleName || machine.hostname || machine.id;
+  const route = isReachable(lanTarget) ? "lan" : "tailscale";
+  return {
+    machineId,
+    target: route === "lan" ? lanTarget : tailscaleTarget,
+    route
+  };
+}
+function buildSshCommand(machineId, remoteCommand) {
+  const resolved = resolveSshTarget(machineId);
+  return remoteCommand ? `ssh ${resolved.target} ${JSON.stringify(remoteCommand)}` : `ssh ${resolved.target}`;
+}
+
+// src/remote.ts
+function shellQuote(value) {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function machineIsLocal(machineId, localMachineId) {
+  return machineId === "local" || machineId === "localhost" || machineId === localMachineId || machineId === hostname4();
+}
+function resolveMachineCommand(machineId, command, localMachineId = getLocalMachineId()) {
+  if (machineIsLocal(machineId, localMachineId)) {
+    return { source: "local", shellCommand: command };
+  }
+  try {
+    return {
+      source: resolveSshTarget(machineId).route,
+      shellCommand: buildSshCommand(machineId, command)
+    };
+  } catch (error) {
+    if (String(error.message ?? error).includes("Machine not found in manifest")) {
+      return { source: "ssh", shellCommand: `ssh ${shellQuote(machineId)} ${shellQuote(command)}` };
+    }
+    throw error;
+  }
+}
+function runMachineCommand(machineId, command) {
+  const resolved = resolveMachineCommand(machineId, command);
+  const result = spawnSync3("bash", ["-c", resolved.shellCommand], {
+    encoding: "utf8",
+    env: process.env
+  });
+  return {
+    machineId,
+    source: resolved.source,
+    stdout: result.stdout || "",
+    stderr: result.stderr || "",
+    exitCode: result.status ?? 1
+  };
+}
+
+// src/version.ts
+import { existsSync as existsSync4, readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname3, join as join2 } from "path";
+import { fileURLToPath } from "url";
+function getPackageVersion() {
+  try {
+    const here = dirname3(fileURLToPath(import.meta.url));
+    const candidates = [join2(here, "..", "package.json"), join2(here, "..", "..", "package.json")];
+    const pkgPath = candidates.find((candidate) => existsSync4(candidate));
+    if (!pkgPath) {
+      return "0.0.0";
+    }
+    return JSON.parse(readFileSync2(pkgPath, "utf8")).version || "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+
+// src/compatibility.ts
+var DEFAULT_COMMANDS = [
+  { command: "bun", required: true },
+  { command: "machines", required: true }
+];
+function defaultPackages() {
+  return [{ name: "@hasna/machines", command: "machines", expectedVersion: getPackageVersion(), required: true }];
+}
+function shellQuote2(value) {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function commandId(value) {
+  return value.replace(/[^a-zA-Z0-9_.@/-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function packageCommand(name) {
+  if (name === "@hasna/knowledge")
+    return "knowledge";
+  if (name === "@hasna/machines")
+    return "machines";
+  return name.split("/").pop() ?? name;
+}
+function firstLine(value) {
+  return value.trim().split(/\r?\n/).find(Boolean) ?? "";
+}
+function extractVersion(value) {
+  const match = value.match(/\b\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?\b/);
+  return match?.[0] ?? null;
+}
+function statusFor(required, ok) {
+  if (ok)
+    return "ok";
+  return required === false ? "warn" : "fail";
+}
+function makeCheck(input) {
+  return {
+    id: input.id,
+    kind: input.kind,
+    status: input.status,
+    target: input.target,
+    expected: input.expected ?? null,
+    actual: input.actual ?? null,
+    detail: input.detail,
+    source: input.source
+  };
+}
+function parseKeyValue(stdout) {
+  const result = {};
+  for (const line of stdout.split(/\r?\n/)) {
+    const idx = line.indexOf("=");
+    if (idx <= 0)
+      continue;
+    result[line.slice(0, idx)] = line.slice(idx + 1);
+  }
+  return result;
+}
+function defaultRunner2(machineId, command) {
+  return runMachineCommand(machineId, command);
+}
+function inspectCommand(machineId, spec, runner) {
+  const command = shellQuote2(spec.command);
+  const versionArgs = spec.versionArgs ?? "--version";
+  const script = [
+    `cmd=${command}`,
+    'path="$(command -v "$cmd" 2>/dev/null || true)"',
+    'printf "path=%s\\n" "$path"',
+    'if [ -n "$path" ]; then version="$("$cmd" ' + versionArgs + ' 2>/dev/null || true)"; printf "version=%s\\n" "$version"; fi'
+  ].join("; ");
+  const result = runner(machineId, script);
+  const parsed = parseKeyValue(result.stdout);
+  return {
+    path: parsed.path || null,
+    version: parsed.version ? firstLine(parsed.version) : null,
+    exitCode: result.exitCode,
+    source: result.source,
+    stderr: result.stderr
+  };
+}
+function fieldCommand(field) {
+  const regex = field === "name" ? String.raw`s/.*"name"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p` : String.raw`s/.*"version"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p`;
+  return [
+    `if command -v bun >/dev/null 2>&1; then bun -e "const p=JSON.parse(await Bun.file(process.argv[1]).text()); console.log(p.${field} ?? '')" "$pkg" 2>/dev/null`,
+    `elif command -v node >/dev/null 2>&1; then node -e "const fs=require('fs'); const p=JSON.parse(fs.readFileSync(process.argv[1], 'utf8')); console.log(p.${field} || '')" "$pkg" 2>/dev/null`,
+    `else sed -n '${regex}' "$pkg" | head -n 1`,
+    "fi"
+  ].join("; ");
+}
+function inspectWorkspace(machineId, spec, runner) {
+  const script = [
+    `path=${shellQuote2(spec.path)}`,
+    'printf "exists=%s\\n" "$(test -d "$path" && printf yes || printf no)"',
+    'pkg="$path/package.json"',
+    'printf "package_json=%s\\n" "$(test -f "$pkg" && printf yes || printf no)"',
+    `if [ -f "$pkg" ]; then printf "package_name=%s\\n" "$(${fieldCommand("name")})"; printf "version=%s\\n" "$(${fieldCommand("version")})"; fi`
+  ].join("; ");
+  const result = runner(machineId, script);
+  const parsed = parseKeyValue(result.stdout);
+  return {
+    exists: parsed.exists === "yes",
+    packageJson: parsed.package_json === "yes",
+    packageName: parsed.package_name || null,
+    version: parsed.version || null,
+    source: result.source,
+    stderr: result.stderr
+  };
+}
+function commandCheck(machineId, spec, runner) {
+  const inspection = inspectCommand(machineId, spec, runner);
+  const found = Boolean(inspection.path);
+  const checks = [
+    makeCheck({
+      id: `command:${commandId(spec.command)}:path`,
+      kind: "command",
+      status: statusFor(spec.required, found),
+      target: spec.command,
+      expected: "available",
+      actual: inspection.path ?? "missing",
+      detail: found ? `found at ${inspection.path}` : inspection.stderr || "command missing",
+      source: inspection.source
+    })
+  ];
+  if (spec.expectedVersion) {
+    const actualVersion = extractVersion(inspection.version ?? "");
+    checks.push(makeCheck({
+      id: `command:${commandId(spec.command)}:version`,
+      kind: "command",
+      status: actualVersion === spec.expectedVersion ? "ok" : statusFor(spec.required, false),
+      target: spec.command,
+      expected: spec.expectedVersion,
+      actual: actualVersion ?? inspection.version ?? "missing",
+      detail: actualVersion ? `version output: ${inspection.version}` : "version unavailable",
+      source: inspection.source
+    }));
+  }
+  return checks;
+}
+function packageCheck(machineId, spec, runner) {
+  const command = spec.command ?? packageCommand(spec.name);
+  const inspection = inspectCommand(machineId, { command, expectedVersion: spec.expectedVersion, required: spec.required }, runner);
+  const found = Boolean(inspection.path);
+  const checks = [
+    makeCheck({
+      id: `package:${commandId(spec.name)}:command`,
+      kind: "package",
+      status: statusFor(spec.required, found),
+      target: spec.name,
+      expected: command,
+      actual: inspection.path ?? "missing",
+      detail: found ? `${command} found at ${inspection.path}` : `${command} command missing`,
+      source: inspection.source
+    })
+  ];
+  if (spec.expectedVersion) {
+    const actualVersion = extractVersion(inspection.version ?? "");
+    checks.push(makeCheck({
+      id: `package:${commandId(spec.name)}:version`,
+      kind: "package",
+      status: actualVersion === spec.expectedVersion ? "ok" : statusFor(spec.required, false),
+      target: spec.name,
+      expected: spec.expectedVersion,
+      actual: actualVersion ?? inspection.version ?? "missing",
+      detail: actualVersion ? `version output: ${inspection.version}` : "version unavailable",
+      source: inspection.source
+    }));
+  }
+  return checks;
+}
+function workspaceCheck(machineId, spec, runner) {
+  const inspection = inspectWorkspace(machineId, spec, runner);
+  const target = spec.label ?? spec.path;
+  const checks = [
+    makeCheck({
+      id: `workspace:${commandId(target)}:path`,
+      kind: "workspace",
+      status: statusFor(spec.required, inspection.exists),
+      target,
+      expected: spec.path,
+      actual: inspection.exists ? "exists" : "missing",
+      detail: inspection.exists ? `workspace exists at ${spec.path}` : inspection.stderr || `workspace missing at ${spec.path}`,
+      source: inspection.source
+    })
+  ];
+  if (spec.expectedPackageName) {
+    checks.push(makeCheck({
+      id: `workspace:${commandId(target)}:package-name`,
+      kind: "workspace",
+      status: inspection.packageName === spec.expectedPackageName ? "ok" : statusFor(spec.required, false),
+      target,
+      expected: spec.expectedPackageName,
+      actual: inspection.packageName ?? (inspection.packageJson ? "missing-name" : "missing-package-json"),
+      detail: inspection.packageJson ? "package.json inspected" : "package.json missing",
+      source: inspection.source
+    }));
+  }
+  if (spec.expectedVersion) {
+    checks.push(makeCheck({
+      id: `workspace:${commandId(target)}:version`,
+      kind: "workspace",
+      status: inspection.version === spec.expectedVersion ? "ok" : statusFor(spec.required, false),
+      target,
+      expected: spec.expectedVersion,
+      actual: inspection.version ?? (inspection.packageJson ? "missing-version" : "missing-package-json"),
+      detail: inspection.packageJson ? "package.json inspected" : "package.json missing",
+      source: inspection.source
+    }));
+  }
+  return checks;
+}
+function checkMachineCompatibility(options = {}) {
+  const machineId = options.machineId ?? getLocalMachineId();
+  const runner = options.runner ?? defaultRunner2;
+  const commands = options.commands ?? DEFAULT_COMMANDS;
+  const packages = options.packages ?? defaultPackages();
+  const workspaces = options.workspaces ?? [];
+  const checks = [];
+  for (const spec of commands)
+    checks.push(...commandCheck(machineId, spec, runner));
+  for (const spec of packages)
+    checks.push(...packageCheck(machineId, spec, runner));
+  for (const spec of workspaces)
+    checks.push(...workspaceCheck(machineId, spec, runner));
+  const summary = {
+    ok: checks.filter((check) => check.status === "ok").length,
+    warn: checks.filter((check) => check.status === "warn").length,
+    fail: checks.filter((check) => check.status === "fail").length
+  };
+  return {
+    ok: summary.fail === 0,
+    machine_id: machineId,
+    source: checks[0]?.source ?? "local",
+    generated_at: (options.now ?? new Date).toISOString(),
+    checks,
+    summary
+  };
+}
 // src/agent/runtime.ts
 function writeHeartbeat(status = "online") {
   const machineId = getLocalMachineId();
@@ -10770,20 +11640,20 @@ function getAgentStatus(machineId = getLocalMachineId()) {
 }
 // src/commands/backup.ts
 import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 function quote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
 function defaultBackupSources() {
   const home = homedir2();
   return [
-    join2(home, ".hasna"),
-    join2(home, ".ssh"),
-    join2(home, ".secrets")
+    join3(home, ".hasna"),
+    join3(home, ".ssh"),
+    join3(home, ".secrets")
   ];
 }
 function buildBackupPlan(bucket, prefix = "machines") {
-  const archivePath = join2(homedir2(), ".hasna", "machines", "backup.tgz");
+  const archivePath = join3(homedir2(), ".hasna", "machines", "backup.tgz");
   const sources = defaultBackupSources();
   const steps = [
     {
@@ -10832,71 +11702,6 @@ function runBackup(bucket, prefix = "machines", options = {}) {
     executed
   };
 }
-// src/remote.ts
-import { spawnSync as spawnSync2 } from "child_process";
-
-// src/commands/ssh.ts
-import { spawnSync } from "child_process";
-function envReachableHosts() {
-  const raw = process.env["HASNA_MACHINES_REACHABLE_HOSTS"];
-  return new Set((raw || "").split(",").map((value) => value.trim()).filter(Boolean));
-}
-function isReachable(host) {
-  const overrides = envReachableHosts();
-  if (overrides.size > 0) {
-    return overrides.has(host);
-  }
-  const probe = spawnSync("bash", ["-lc", `getent hosts ${host} >/dev/null 2>&1 || ping -c 1 -W 1 ${host} >/dev/null 2>&1`], {
-    stdio: "ignore"
-  });
-  return probe.status === 0;
-}
-function resolveSshTarget(machineId) {
-  const machine = getManifestMachine(machineId);
-  if (!machine) {
-    throw new Error(`Machine not found in manifest: ${machineId}`);
-  }
-  const current = detectCurrentMachineManifest();
-  if (machine.id === current.id) {
-    return {
-      machineId,
-      target: "localhost",
-      route: "local"
-    };
-  }
-  const lanTarget = machine.sshAddress || machine.hostname || machine.id;
-  const tailscaleTarget = machine.tailscaleName || machine.hostname || machine.id;
-  const route = isReachable(lanTarget) ? "lan" : "tailscale";
-  return {
-    machineId,
-    target: route === "lan" ? lanTarget : tailscaleTarget,
-    route
-  };
-}
-function buildSshCommand(machineId, remoteCommand) {
-  const resolved = resolveSshTarget(machineId);
-  return remoteCommand ? `ssh ${resolved.target} ${JSON.stringify(remoteCommand)}` : `ssh ${resolved.target}`;
-}
-
-// src/remote.ts
-function runMachineCommand(machineId, command) {
-  const localMachineId = getLocalMachineId();
-  const isLocal = machineId === localMachineId;
-  const route = isLocal ? "local" : resolveSshTarget(machineId).route;
-  const shellCommand = isLocal ? command : buildSshCommand(machineId, command);
-  const result = spawnSync2("bash", ["-lc", shellCommand], {
-    encoding: "utf8",
-    env: process.env
-  });
-  return {
-    machineId,
-    source: route,
-    stdout: result.stdout || "",
-    stderr: result.stderr || "",
-    exitCode: result.status ?? 1
-  };
-}
-
 // src/commands/apps.ts
 function getPackageName(app) {
   return app.packageName || app.name;
@@ -10910,7 +11715,7 @@ function getAppManager(machine, app) {
     return "winget";
   return "apt";
 }
-function shellQuote(value) {
+function shellQuote3(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
 function buildAppCommand(machine, app) {
@@ -10931,7 +11736,7 @@ function buildAppCommand(machine, app) {
   return `sudo apt-get install -y ${packageName}`;
 }
 function buildAppProbeCommand(machine, app) {
-  const packageName = shellQuote(getPackageName(app));
+  const packageName = shellQuote3(getPackageName(app));
   const manager = getAppManager(machine, app);
   if (manager === "custom") {
     return `if command -v ${packageName} >/dev/null 2>&1; then printf 'installed=1\\nversion=custom\\n'; else printf 'installed=0\\n'; fi`;
@@ -11035,23 +11840,23 @@ function runAppsInstall(machineId, options = {}) {
   };
 }
 // src/commands/cert.ts
-import { homedir as homedir3, platform as platform2 } from "os";
-import { join as join3 } from "path";
+import { homedir as homedir3, platform as platform3 } from "os";
+import { join as join4 } from "path";
 function quote2(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
 function certDir() {
-  return join3(homedir3(), ".hasna", "machines", "certs");
+  return join4(homedir3(), ".hasna", "machines", "certs");
 }
 function buildCertPlan(domains) {
   if (domains.length === 0) {
     throw new Error("At least one domain is required.");
   }
   const primary = domains[0];
-  const certPath = join3(certDir(), `${primary}.pem`);
-  const keyPath = join3(certDir(), `${primary}-key.pem`);
+  const certPath = join4(certDir(), `${primary}.pem`);
+  const keyPath = join4(certDir(), `${primary}-key.pem`);
   const steps = [];
-  if (platform2() === "darwin") {
+  if (platform3() === "darwin") {
     steps.push({
       id: "mkcert-install-macos",
       title: "Install mkcert on macOS",
@@ -11112,16 +11917,16 @@ function runCertPlan(domains, options = {}) {
   };
 }
 // src/commands/dns.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { join as join5 } from "path";
 function getDnsPath() {
-  return join4(getDataDir(), "dns.json");
+  return join5(getDataDir(), "dns.json");
 }
 function readMappings() {
   const path = getDnsPath();
-  if (!existsSync3(path))
+  if (!existsSync5(path))
     return [];
-  return JSON.parse(readFileSync2(path, "utf8"));
+  return JSON.parse(readFileSync3(path, "utf8"));
 }
 function writeMappings(mappings) {
   const path = getDnsPath();
@@ -11148,14 +11953,14 @@ function renderDomainMapping(domain) {
     hostsEntry: `${entry.targetHost} ${entry.domain}`,
     caddySnippet: `${entry.domain} {
   reverse_proxy 127.0.0.1:${entry.port}
-  tls ${join4(getDataDir(), "certs", `${entry.domain}.pem`)} ${join4(getDataDir(), "certs", `${entry.domain}-key.pem`)}
+  tls ${join5(getDataDir(), "certs", `${entry.domain}.pem`)} ${join5(getDataDir(), "certs", `${entry.domain}-key.pem`)}
 }`,
-    certPath: join4(getDataDir(), "certs", `${entry.domain}.pem`),
-    keyPath: join4(getDataDir(), "certs", `${entry.domain}-key.pem`)
+    certPath: join5(getDataDir(), "certs", `${entry.domain}.pem`),
+    keyPath: join5(getDataDir(), "certs", `${entry.domain}-key.pem`)
   };
 }
 // src/commands/doctor.ts
-function makeCheck(id, status, summary, detail) {
+function makeCheck2(id, status, summary, detail) {
   return { id, status, summary, detail };
 }
 function parseKeyValueOutput(stdout) {
@@ -11187,15 +11992,15 @@ function runDoctor(machineId = getLocalMachineId()) {
   const details = parseKeyValueOutput(commandChecks.stdout);
   const machineInManifest = manifest.machines.find((machine) => machine.id === machineId);
   const checks = [
-    makeCheck("manifest-entry", machineInManifest ? "ok" : "warn", machineInManifest ? "Machine exists in manifest" : "Machine missing from manifest", machineInManifest ? JSON.stringify(machineInManifest) : `No manifest entry for ${machineId}`),
-    makeCheck("manifest-path", details["manifest_exists"] === "yes" ? "ok" : "warn", "Manifest path check", `${details["manifest_path"] || "unknown"} ${details["manifest_exists"] === "yes" ? "exists" : "missing"}`),
-    makeCheck("db-path", details["db_exists"] === "yes" ? "ok" : "warn", "DB path check", `${details["db_path"] || "unknown"} ${details["db_exists"] === "yes" ? "exists" : "missing"}`),
-    makeCheck("notifications-path", details["notifications_exists"] === "yes" ? "ok" : "warn", "Notifications path check", `${details["notifications_path"] || "unknown"} ${details["notifications_exists"] === "yes" ? "exists" : "missing"}`),
-    makeCheck("bun", details["bun"] && details["bun"] !== "missing" ? "ok" : "fail", "Bun availability", details["bun"] || "missing"),
-    makeCheck("machines-cli", details["machines"] && details["machines"] !== "missing" ? "ok" : "warn", "machines CLI availability", details["machines"] || "missing"),
-    makeCheck("machines-agent-cli", details["machines_agent"] && details["machines_agent"] !== "missing" ? "ok" : "warn", "machines-agent availability", details["machines_agent"] || "missing"),
-    makeCheck("machines-mcp-cli", details["machines_mcp"] && details["machines_mcp"] !== "missing" ? "ok" : "warn", "machines-mcp availability", details["machines_mcp"] || "missing"),
-    makeCheck("ssh", details["ssh"] === "ok" ? "ok" : "warn", "SSH availability", details["ssh"] || "missing")
+    makeCheck2("manifest-entry", machineInManifest ? "ok" : "warn", machineInManifest ? "Machine exists in manifest" : "Machine missing from manifest", machineInManifest ? JSON.stringify(machineInManifest) : `No manifest entry for ${machineId}`),
+    makeCheck2("manifest-path", details["manifest_exists"] === "yes" ? "ok" : "warn", "Manifest path check", `${details["manifest_path"] || "unknown"} ${details["manifest_exists"] === "yes" ? "exists" : "missing"}`),
+    makeCheck2("db-path", details["db_exists"] === "yes" ? "ok" : "warn", "DB path check", `${details["db_path"] || "unknown"} ${details["db_exists"] === "yes" ? "exists" : "missing"}`),
+    makeCheck2("notifications-path", details["notifications_exists"] === "yes" ? "ok" : "warn", "Notifications path check", `${details["notifications_path"] || "unknown"} ${details["notifications_exists"] === "yes" ? "exists" : "missing"}`),
+    makeCheck2("bun", details["bun"] && details["bun"] !== "missing" ? "ok" : "fail", "Bun availability", details["bun"] || "missing"),
+    makeCheck2("machines-cli", details["machines"] && details["machines"] !== "missing" ? "ok" : "warn", "machines CLI availability", details["machines"] || "missing"),
+    makeCheck2("machines-agent-cli", details["machines_agent"] && details["machines_agent"] !== "missing" ? "ok" : "warn", "machines-agent availability", details["machines_agent"] || "missing"),
+    makeCheck2("machines-mcp-cli", details["machines_mcp"] && details["machines_mcp"] !== "missing" ? "ok" : "warn", "machines-mcp availability", details["machines_mcp"] || "missing"),
+    makeCheck2("ssh", details["ssh"] === "ok" ? "ok" : "warn", "SSH availability", details["ssh"] || "missing")
   ];
   return {
     machineId,
@@ -11451,7 +12256,7 @@ function runTailscaleInstall(machineId, options = {}) {
   };
 }
 // src/commands/notifications.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
 var notificationChannelSchema = exports_external.object({
   id: exports_external.string(),
   type: exports_external.enum(["email", "webhook", "command"]),
@@ -11467,10 +12272,10 @@ var notificationConfigSchema = exports_external.object({
 function sortChannels(channels) {
   return [...channels].sort((left, right) => left.id.localeCompare(right.id));
 }
-function shellQuote2(value) {
+function shellQuote4(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
-function hasCommand(binary) {
+function hasCommand2(binary) {
   const result = Bun.spawnSync(["bash", "-lc", `command -v ${binary} >/dev/null 2>&1`], {
     stdout: "ignore",
     stderr: "ignore",
@@ -11495,7 +12300,7 @@ Content-Type: text/plain; charset=utf-8
 
 ${message}
 `;
-  if (hasCommand("sendmail")) {
+  if (hasCommand2("sendmail")) {
     const result = Bun.spawnSync(["bash", "-lc", "sendmail -t"], {
       stdin: new TextEncoder().encode(body),
       stdout: "pipe",
@@ -11513,8 +12318,8 @@ ${message}
       detail: `Delivered via sendmail to ${channel.target}`
     };
   }
-  if (hasCommand("mail")) {
-    const command = `printf %s ${shellQuote2(message)} | mail -s ${shellQuote2(subject)} ${shellQuote2(channel.target)}`;
+  if (hasCommand2("mail")) {
+    const command = `printf %s ${shellQuote4(message)} | mail -s ${shellQuote4(subject)} ${shellQuote4(channel.target)}`;
     const result = Bun.spawnSync(["bash", "-lc", command], {
       stdout: "pipe",
       stderr: "pipe",
@@ -11607,10 +12412,10 @@ function getDefaultNotificationConfig() {
   };
 }
 function readNotificationConfig(path = getNotificationsPath()) {
-  if (!existsSync4(path)) {
+  if (!existsSync6(path)) {
     return getDefaultNotificationConfig();
   }
-  return notificationConfigSchema.parse(JSON.parse(readFileSync3(path, "utf8")));
+  return notificationConfigSchema.parse(JSON.parse(readFileSync4(path, "utf8")));
 }
 function writeNotificationConfig(config, path = getNotificationsPath()) {
   ensureParentDir(path);
@@ -11697,7 +12502,7 @@ async function testNotificationChannel(channelId, event = "manual.test", message
   };
 }
 // src/commands/ports.ts
-import { spawnSync as spawnSync3 } from "child_process";
+import { spawnSync as spawnSync4 } from "child_process";
 function parseSsOutput(output) {
   return output.trim().split(`
 `).map((line) => line.trim()).filter(Boolean).map((line) => {
@@ -11739,7 +12544,7 @@ function listPorts(machineId) {
   const isLocal = targetMachineId === getLocalMachineId();
   const localCommand = "if command -v ss >/dev/null 2>&1; then ss -ltnpH; else lsof -nP -iTCP -sTCP:LISTEN; fi";
   const command = isLocal ? localCommand : buildSshCommand(targetMachineId, localCommand);
-  const result = spawnSync3("bash", ["-lc", command], { encoding: "utf8" });
+  const result = spawnSync4("bash", ["-lc", command], { encoding: "utf8" });
   if (result.status !== 0) {
     throw new Error(result.stderr || `Failed to list ports for ${targetMachineId}`);
   }
@@ -11749,24 +12554,6 @@ function listPorts(machineId) {
     listeners: parsePortOutput(result.stdout, format)
   };
 }
-// src/version.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
-import { dirname as dirname3, join as join5 } from "path";
-import { fileURLToPath } from "url";
-function getPackageVersion() {
-  try {
-    const here = dirname3(fileURLToPath(import.meta.url));
-    const candidates = [join5(here, "..", "package.json"), join5(here, "..", "..", "package.json")];
-    const pkgPath = candidates.find((candidate) => existsSync5(candidate));
-    if (!pkgPath) {
-      return "0.0.0";
-    }
-    return JSON.parse(readFileSync4(pkgPath, "utf8")).version || "0.0.0";
-  } catch {
-    return "0.0.0";
-  }
-}
-
 // src/commands/status.ts
 function getStatus() {
   const manifest = readManifest();
@@ -12198,7 +12985,7 @@ function runSetup(machineId, options = {}) {
   return summary;
 }
 // src/commands/sync.ts
-import { existsSync as existsSync6, lstatSync, readFileSync as readFileSync5, symlinkSync, copyFileSync } from "fs";
+import { existsSync as existsSync7, lstatSync, readFileSync as readFileSync5, symlinkSync, copyFileSync } from "fs";
 function quote4(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
@@ -12246,8 +13033,8 @@ function detectPackageActions(machine) {
 }
 function detectFileActions(machine) {
   return (machine.files || []).map((file, index) => {
-    const sourceExists = existsSync6(file.source);
-    const targetExists = existsSync6(file.target);
+    const sourceExists = existsSync7(file.source);
+    const targetExists = existsSync7(file.target);
     let status = "missing";
     if (sourceExists && targetExists) {
       if (file.mode === "symlink") {
@@ -12425,7 +13212,7 @@ __export(exports_util, {
   omit: () => omit,
   numKeys: () => numKeys,
   nullish: () => nullish,
-  normalizeParams: () => normalizeParams,
+  normalizeParams: () => normalizeParams2,
   merge: () => merge,
   jsonStringifyReplacer: () => jsonStringifyReplacer,
   joinValues: () => joinValues,
@@ -12662,7 +13449,7 @@ function clone(inst, def, params) {
     cl._zod.parent = inst;
   return cl;
 }
-function normalizeParams(_params) {
+function normalizeParams2(_params) {
   const params = _params;
   if (!params)
     return {};
@@ -13072,7 +13859,7 @@ var cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]
 var cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
 var base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
 var base64url = /^[A-Za-z0-9_-]*$/;
-var hostname3 = /^([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+$/;
+var hostname5 = /^([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+$/;
 var e164 = /^\+(?:[0-9]){6,14}[0-9]$/;
 var dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
 var date = /* @__PURE__ */ new RegExp(`^${dateSource}$`);
@@ -13684,7 +14471,7 @@ var $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (inst, def) => {
             code: "invalid_format",
             format: "url",
             note: "Invalid hostname",
-            pattern: hostname3.source,
+            pattern: hostname5.source,
             input: payload.value,
             inst,
             continue: !def.abort
@@ -14936,7 +15723,7 @@ var globalRegistry = /* @__PURE__ */ registry();
 function _string(Class2, params) {
   return new Class2({
     type: "string",
-    ...normalizeParams(params)
+    ...normalizeParams2(params)
   });
 }
 function _email(Class2, params) {
@@ -14945,7 +15732,7 @@ function _email(Class2, params) {
     format: "email",
     check: "string_format",
     abort: false,
-    ...normalizeParams(params)
+    ...normalizeParams2(params)
   });
 }
 function _guid(Class2, params) {
@@ -14954,7 +15741,7 @@ function _guid(Class2, params) {
     format: "guid",
     check: "string_format",
     abort: false,
-    ...normalizeParams(params)
+    ...normalizeParams2(params)
   });
 }
 function _uuid(Class2, params) {
@@ -14963,7 +15750,7 @@ function _uuid(Class2, params) {
     format: "uuid",
     check: "string_format",
     abort: false,
-    ...normalizeParams(params)
+    ...normalizeParams2(params)
   });
 }
 function _uuidv4(Class2, params) {
@@ -14973,7 +15760,7 @@ function _uuidv4(Class2, params) {
     check: "string_format",
     abort: false,
     version: "v4",
-    ...normalizeParams(params)
+    ...normalizeParams2(params)
   });
 }
 function _uuidv6(Class2, params) {
@@ -14983,7 +15770,7 @@ function _uuidv6(Class2, params) {
     check: "string_format",
     abort: false,
     version: "v6",
-    ...normalizeParams(params)
+    ...normalizeParams2(params)
   });
 }
 function _uuidv7(Class2, params) {
@@ -14993,7 +15780,7 @@ function _uuidv7(Class2, params) {
     check: "string_format",
     abort: false,
     version: "v7",
-    ...normalizeParams(params)
+    ...normalizeParams2(params)
   });
 }
 function _url(Class2, params) {
@@ -15002,7 +15789,7 @@ function _url(Class2, params) {
     format: "url",
     check: "string_format",
     abort: false,
-    ...normalizeParams(params)
+    ...normalizeParams2(params)
   });
 }
 function _emoji2(Class2, params) {
@@ -15011,7 +15798,7 @@ function _emoji2(Class2, params) {
     format: "emoji",
     check: "string_format",
     abort: false,
-    ...normalizeParams(params)
+    ...normalizeParams2(params)
   });
 }
 function _nanoid(Class2, params) {
@@ -15020,7 +15807,7 @@ function _nanoid(Class2, params) {
     format: "nanoid",
     check: "string_format",
     abort: false,
-    ...normalizeParams(params)
+    ...normalizeParams2(params)
   });
 }
 function _cuid(Class2, params) {
@@ -15029,7 +15816,7 @@ function _cuid(Class2, params) {
     format: "cuid",
     check: "string_format",
     abort: false,
-    ...normalizeParams(params)
+    ...normalizeParams2(params)
   });
 }
 function _cuid2(Class2, params) {
@@ -15038,7 +15825,7 @@ function _cuid2(Class2, params) {
     format: "cuid2",
     check: "string_format",
     abort: false,
-    ...normalizeParams(params)
+    ...normalizeParams2(params)
   });
 }
 function _ulid(Class2, params) {
@@ -15047,7 +15834,7 @@ function _ulid(Class2, params) {
     format: "ulid",
     check: "string_format",
     abort: false,
-    ...normalizeParams(params)
+    ...normalizeParams2(params)
   });
 }
 function _xid(Class2, params) {
@@ -15056,7 +15843,7 @@ function _xid(Class2, params) {
     format: "xid",
     check: "string_format",
     abort: false,
-    ...normalizeParams(params)
+    ...normalizeParams2(params)
   });
 }
 function _ksuid(Class2, params) {
@@ -15065,7 +15852,7 @@ function _ksuid(Class2, params) {
     format: "ksuid",
     check: "string_format",
     abort: false,
-    ...normalizeParams(params)
+    ...normalizeParams2(params)
   });
 }
 function _ipv4(Class2, params) {
@@ -15074,7 +15861,7 @@ function _ipv4(Class2, params) {
     format: "ipv4",
     check: "string_format",
     abort: false,
-    ...normalizeParams(params)
+    ...normalizeParams2(params)
   });
 }
 function _ipv6(Class2, params) {
@@ -15083,7 +15870,7 @@ function _ipv6(Class2, params) {
     format: "ipv6",
     check: "string_format",
     abort: false,
-    ...normalizeParams(params)
+    ...normalizeParams2(params)
   });
 }
 function _cidrv4(Class2, params) {
@@ -15092,7 +15879,7 @@ function _cidrv4(Class2, params) {
     format: "cidrv4",
     check: "string_format",
     abort: false,
-    ...normalizeParams(params)
+    ...normalizeParams2(params)
   });
 }
 function _cidrv6(Class2, params) {
@@ -15101,7 +15888,7 @@ function _cidrv6(Class2, params) {
     format: "cidrv6",
     check: "string_format",
     abort: false,
-    ...normalizeParams(params)
+    ...normalizeParams2(params)
   });
 }
 function _base64(Class2, params) {
@@ -15110,7 +15897,7 @@ function _base64(Class2, params) {
     format: "base64",
     check: "string_format",
     abort: false,
-    ...normalizeParams(params)
+    ...normalizeParams2(params)
   });
 }
 function _base64url(Class2, params) {
@@ -15119,7 +15906,7 @@ function _base64url(Class2, params) {
     format: "base64url",
     check: "string_format",
     abort: false,
-    ...normalizeParams(params)
+    ...normalizeParams2(params)
   });
 }
 function _e164(Class2, params) {
@@ -15128,7 +15915,7 @@ function _e164(Class2, params) {
     format: "e164",
     check: "string_format",
     abort: false,
-    ...normalizeParams(params)
+    ...normalizeParams2(params)
   });
 }
 function _jwt(Class2, params) {
@@ -15137,7 +15924,7 @@ function _jwt(Class2, params) {
     format: "jwt",
     check: "string_format",
     abort: false,
-    ...normalizeParams(params)
+    ...normalizeParams2(params)
   });
 }
 function _isoDateTime(Class2, params) {
@@ -15148,7 +15935,7 @@ function _isoDateTime(Class2, params) {
     offset: false,
     local: false,
     precision: null,
-    ...normalizeParams(params)
+    ...normalizeParams2(params)
   });
 }
 function _isoDate(Class2, params) {
@@ -15156,7 +15943,7 @@ function _isoDate(Class2, params) {
     type: "string",
     format: "date",
     check: "string_format",
-    ...normalizeParams(params)
+    ...normalizeParams2(params)
   });
 }
 function _isoTime(Class2, params) {
@@ -15165,7 +15952,7 @@ function _isoTime(Class2, params) {
     format: "time",
     check: "string_format",
     precision: null,
-    ...normalizeParams(params)
+    ...normalizeParams2(params)
   });
 }
 function _isoDuration(Class2, params) {
@@ -15173,14 +15960,14 @@ function _isoDuration(Class2, params) {
     type: "string",
     format: "duration",
     check: "string_format",
-    ...normalizeParams(params)
+    ...normalizeParams2(params)
   });
 }
 function _number(Class2, params) {
   return new Class2({
     type: "number",
     checks: [],
-    ...normalizeParams(params)
+    ...normalizeParams2(params)
   });
 }
 function _int(Class2, params) {
@@ -15189,19 +15976,19 @@ function _int(Class2, params) {
     check: "number_format",
     abort: false,
     format: "safeint",
-    ...normalizeParams(params)
+    ...normalizeParams2(params)
   });
 }
 function _boolean(Class2, params) {
   return new Class2({
     type: "boolean",
-    ...normalizeParams(params)
+    ...normalizeParams2(params)
   });
 }
 function _null2(Class2, params) {
   return new Class2({
     type: "null",
-    ...normalizeParams(params)
+    ...normalizeParams2(params)
   });
 }
 function _unknown(Class2) {
@@ -15212,13 +15999,13 @@ function _unknown(Class2) {
 function _never(Class2, params) {
   return new Class2({
     type: "never",
-    ...normalizeParams(params)
+    ...normalizeParams2(params)
   });
 }
 function _lt(value, params) {
   return new $ZodCheckLessThan({
     check: "less_than",
-    ...normalizeParams(params),
+    ...normalizeParams2(params),
     value,
     inclusive: false
   });
@@ -15226,7 +16013,7 @@ function _lt(value, params) {
 function _lte(value, params) {
   return new $ZodCheckLessThan({
     check: "less_than",
-    ...normalizeParams(params),
+    ...normalizeParams2(params),
     value,
     inclusive: true
   });
@@ -15234,7 +16021,7 @@ function _lte(value, params) {
 function _gt(value, params) {
   return new $ZodCheckGreaterThan({
     check: "greater_than",
-    ...normalizeParams(params),
+    ...normalizeParams2(params),
     value,
     inclusive: false
   });
@@ -15242,7 +16029,7 @@ function _gt(value, params) {
 function _gte(value, params) {
   return new $ZodCheckGreaterThan({
     check: "greater_than",
-    ...normalizeParams(params),
+    ...normalizeParams2(params),
     value,
     inclusive: true
   });
@@ -15250,14 +16037,14 @@ function _gte(value, params) {
 function _multipleOf(value, params) {
   return new $ZodCheckMultipleOf({
     check: "multiple_of",
-    ...normalizeParams(params),
+    ...normalizeParams2(params),
     value
   });
 }
 function _maxLength(maximum, params) {
   const ch = new $ZodCheckMaxLength({
     check: "max_length",
-    ...normalizeParams(params),
+    ...normalizeParams2(params),
     maximum
   });
   return ch;
@@ -15265,14 +16052,14 @@ function _maxLength(maximum, params) {
 function _minLength(minimum, params) {
   return new $ZodCheckMinLength({
     check: "min_length",
-    ...normalizeParams(params),
+    ...normalizeParams2(params),
     minimum
   });
 }
 function _length(length, params) {
   return new $ZodCheckLengthEquals({
     check: "length_equals",
-    ...normalizeParams(params),
+    ...normalizeParams2(params),
     length
   });
 }
@@ -15280,7 +16067,7 @@ function _regex(pattern, params) {
   return new $ZodCheckRegex({
     check: "string_format",
     format: "regex",
-    ...normalizeParams(params),
+    ...normalizeParams2(params),
     pattern
   });
 }
@@ -15288,21 +16075,21 @@ function _lowercase(params) {
   return new $ZodCheckLowerCase({
     check: "string_format",
     format: "lowercase",
-    ...normalizeParams(params)
+    ...normalizeParams2(params)
   });
 }
 function _uppercase(params) {
   return new $ZodCheckUpperCase({
     check: "string_format",
     format: "uppercase",
-    ...normalizeParams(params)
+    ...normalizeParams2(params)
   });
 }
 function _includes(includes, params) {
   return new $ZodCheckIncludes({
     check: "string_format",
     format: "includes",
-    ...normalizeParams(params),
+    ...normalizeParams2(params),
     includes
   });
 }
@@ -15310,7 +16097,7 @@ function _startsWith(prefix, params) {
   return new $ZodCheckStartsWith({
     check: "string_format",
     format: "starts_with",
-    ...normalizeParams(params),
+    ...normalizeParams2(params),
     prefix
   });
 }
@@ -15318,7 +16105,7 @@ function _endsWith(suffix, params) {
   return new $ZodCheckEndsWith({
     check: "string_format",
     format: "ends_with",
-    ...normalizeParams(params),
+    ...normalizeParams2(params),
     suffix
   });
 }
@@ -15344,11 +16131,11 @@ function _array(Class2, element, params) {
   return new Class2({
     type: "array",
     element,
-    ...normalizeParams(params)
+    ...normalizeParams2(params)
   });
 }
 function _custom(Class2, fn, _params) {
-  const norm = normalizeParams(_params);
+  const norm = normalizeParams2(_params);
   norm.abort ?? (norm.abort = true);
   const schema = new Class2({
     type: "custom",
@@ -15363,7 +16150,7 @@ function _refine(Class2, fn, _params) {
     type: "custom",
     check: "custom",
     fn,
-    ...normalizeParams(_params)
+    ...normalizeParams2(_params)
   });
   return schema;
 }
@@ -21276,6 +22063,8 @@ var MACHINE_MCP_TOOL_NAMES = [
   "machines_setup_apply",
   "machines_sync_preview",
   "machines_sync_apply",
+  "machines_topology",
+  "machines_compatibility",
   "machines_diff",
   "machines_install_tailscale_preview",
   "machines_install_tailscale_apply",
@@ -21298,8 +22087,15 @@ var MACHINE_MCP_TOOL_NAMES = [
   "machines_notifications_dispatch",
   "machines_notifications_remove",
   "machines_serve_info",
-  "machines_serve_dashboard"
+  "machines_serve_dashboard",
+  "storage_status",
+  "storage_push",
+  "storage_pull",
+  "storage_sync"
 ];
+function buildServer(version2 = getPackageVersion()) {
+  return createMcpServer(version2);
+}
 function createMcpServer(version2) {
   const server = new McpServer({ name: "machines", version: version2 });
   server.tool("machines_status", "Return local machine fleet status paths and machine identity.", {}, async () => ({
@@ -21332,6 +22128,33 @@ function createMcpServer(version2) {
   server.tool("machines_setup_apply", "Execute setup actions for a machine.", { machine_id: exports_external.string().optional().describe("Machine identifier"), yes: exports_external.boolean().describe("Confirmation flag for execution") }, async ({ machine_id, yes }) => ({ content: [{ type: "text", text: JSON.stringify(runSetup(machine_id, { apply: true, yes }), null, 2) }] }));
   server.tool("machines_sync_preview", "Preview sync actions for a machine.", { machine_id: exports_external.string().optional().describe("Machine identifier") }, async ({ machine_id }) => ({ content: [{ type: "text", text: JSON.stringify(buildSyncPlan(machine_id), null, 2) }] }));
   server.tool("machines_sync_apply", "Execute sync actions for a machine.", { machine_id: exports_external.string().optional().describe("Machine identifier"), yes: exports_external.boolean().describe("Confirmation flag for execution") }, async ({ machine_id, yes }) => ({ content: [{ type: "text", text: JSON.stringify(runSync(machine_id, { apply: true, yes }), null, 2) }] }));
+  server.tool("machines_topology", "Discover local, manifest, heartbeat, SSH, and Tailscale machine topology.", { include_tailscale: exports_external.boolean().optional().describe("Whether to probe tailscale status --json") }, async ({ include_tailscale }) => ({
+    content: [{ type: "text", text: JSON.stringify(discoverMachineTopology({ includeTailscale: include_tailscale !== false }), null, 2) }]
+  }));
+  server.tool("machines_compatibility", "Check remote package, command, and workspace compatibility for open-* consumers.", {
+    machine_id: exports_external.string().optional().describe("Machine identifier"),
+    commands: exports_external.array(exports_external.object({
+      command: exports_external.string(),
+      expectedVersion: exports_external.string().optional(),
+      versionArgs: exports_external.string().optional(),
+      required: exports_external.boolean().optional()
+    })).optional().describe("Commands to check"),
+    packages: exports_external.array(exports_external.object({
+      name: exports_external.string(),
+      command: exports_external.string().optional(),
+      expectedVersion: exports_external.string().optional(),
+      required: exports_external.boolean().optional()
+    })).optional().describe("Package-backed CLI checks"),
+    workspaces: exports_external.array(exports_external.object({
+      path: exports_external.string(),
+      label: exports_external.string().optional(),
+      expectedPackageName: exports_external.string().optional(),
+      expectedVersion: exports_external.string().optional(),
+      required: exports_external.boolean().optional()
+    })).optional().describe("Workspace paths and package metadata to check")
+  }, async ({ machine_id, commands, packages, workspaces }) => ({
+    content: [{ type: "text", text: JSON.stringify(checkMachineCompatibility({ machineId: machine_id, commands, packages, workspaces }), null, 2) }]
+  }));
   server.tool("machines_diff", "Show manifest differences between two machines.", {
     left_machine_id: exports_external.string().describe("Left machine identifier"),
     right_machine_id: exports_external.string().optional().describe("Right machine identifier")
@@ -21393,6 +22216,12 @@ function createMcpServer(version2) {
   server.tool("machines_serve_dashboard", "Render the current dashboard HTML.", {}, async () => ({
     content: [{ type: "text", text: renderDashboardHtml() }]
   }));
+  server.tool("storage_status", "Show machines storage sync configuration and local sync history.", {}, async () => ({
+    content: [{ type: "text", text: JSON.stringify(getStorageStatus(), null, 2) }]
+  }));
+  server.tool("storage_push", "Push local machine runtime data to storage PostgreSQL.", { tables: exports_external.array(exports_external.string()).optional().describe("Optional table list to push") }, async ({ tables }) => ({ content: [{ type: "text", text: JSON.stringify(await storagePush(tables ? { tables } : undefined), null, 2) }] }));
+  server.tool("storage_pull", "Pull machine runtime data from storage PostgreSQL to local SQLite.", { tables: exports_external.array(exports_external.string()).optional().describe("Optional table list to pull") }, async ({ tables }) => ({ content: [{ type: "text", text: JSON.stringify(await storagePull(tables ? { tables } : undefined), null, 2) }] }));
+  server.tool("storage_sync", "Bidirectional machines storage sync: pull then push.", { tables: exports_external.array(exports_external.string()).optional().describe("Optional table list to sync") }, async ({ tables }) => ({ content: [{ type: "text", text: JSON.stringify(await storageSync(tables ? { tables } : undefined), null, 2) }] }));
   return server;
 }
 export {
@@ -21402,10 +22231,14 @@ export {
   validateManifest,
   upsertHeartbeat,
   testNotificationChannel,
+  storageSync,
+  storagePush,
+  storagePull,
   startDashboardServer,
   setHeartbeatStatus,
   runTailscaleInstall,
   runSync,
+  runStorageMigrations,
   runSetup,
   runSelfTest,
   runDoctor,
@@ -21413,6 +22246,7 @@ export {
   runCertPlan,
   runBackup,
   runAppsInstall,
+  resolveTables,
   resolveSshTarget,
   renderDomainMapping,
   renderDashboardHtml,
@@ -21421,6 +22255,7 @@ export {
   recordSetupRun,
   readNotificationConfig,
   readManifest,
+  parseStorageTables,
   parsePortOutput,
   markOffline,
   manifestValidate,
@@ -21436,12 +22271,20 @@ export {
   listHeartbeats,
   listDomainMappings,
   listApps,
+  getSyncMetaAll,
+  getStorageStatus,
+  getStoragePg,
+  getStorageMode,
+  getStorageDatabaseUrl,
+  getStorageDatabaseEnvName,
+  getStorageDatabaseEnv,
   getStatus,
   getServeInfo,
   getPackageVersion,
   getNotificationsPath,
   getManifestPath,
   getManifestMachine,
+  getLocalMachineTopology,
   getLocalMachineId,
   getDefaultNotificationConfig,
   getDefaultManifest,
@@ -21458,16 +22301,20 @@ export {
   ensureParentDir,
   ensureDataDir,
   dispatchNotificationEvent,
+  discoverMachineTopology,
   diffMachines,
   diffClaudeCli,
   diffApps,
   detectCurrentMachineManifest,
   createMcpServer,
   countRuns,
+  closeDb,
+  checkMachineCompatibility,
   buildTailscaleInstallPlan,
   buildSyncPlan,
   buildSshCommand,
   buildSetupPlan,
+  buildServer,
   buildClaudeInstallPlan,
   buildCertPlan,
   buildBackupPlan,
@@ -21475,6 +22322,14 @@ export {
   addNotificationChannel,
   addDomainMapping,
   SqliteAdapter,
+  STORAGE_TABLES,
+  STORAGE_MODE_ENV,
+  STORAGE_DATABASE_ENV,
   MACHINE_MCP_TOOL_NAMES,
+  MACHINES_STORAGE_TABLES,
+  MACHINES_STORAGE_MODE_FALLBACK_ENV,
+  MACHINES_STORAGE_MODE_ENV,
+  MACHINES_STORAGE_FALLBACK_ENV,
+  MACHINES_STORAGE_ENV,
   CROSSREFS_KEY
 };