@hasna/evals 0.1.24 → 0.1.26

package/dist/cli/index.js

@@ -1019,7 +1019,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         this._exitCallback = (err) => {
           if (err.code !== "commander.executeSubCommandAsync") {
             throw err;
-          } else {}
+          }
         };
       }
       return this;
@@ -8559,17 +8559,17 @@ __export(exports_store, {
 });
 import { Database } from "bun:sqlite";
 import { mkdirSync } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
 function getDbPath() {
-  return process.env["EVALS_DB_PATH"] ?? join2(homedir2(), ".hasna", "evals", "evals.db");
+  return process.env["EVALS_DB_PATH"] ?? join3(homedir3(), ".hasna", "evals", "evals.db");
 }
 function getDatabase() {
   if (_db)
     return _db;
   const path3 = getDbPath();
   if (path3 !== ":memory:") {
-    mkdirSync(join2(path3, ".."), { recursive: true });
+    mkdirSync(join3(path3, ".."), { recursive: true });
   }
   _db = new Database(path3);
   _db.exec("PRAGMA journal_mode=WAL; PRAGMA foreign_keys=ON;");
@@ -8700,8 +8700,8 @@ __export(exports_dist, {
   ensureConflictsTable: () => ensureConflictsTable,
   ensureAllPgDatabases: () => ensureAllPgDatabases,
   enableAutoSync: () => enableAutoSync,
-  discoverSyncableServicesV2: () => discoverSyncableServices,
-  discoverSyncableServices: () => discoverSyncableServices2,
+  discoverSyncableServicesV2: () => discoverSyncableServices2,
+  discoverSyncableServices: () => discoverSyncableServices,
   discoverServices: () => discoverServices,
   detectConflicts: () => detectConflicts,
   createDatabase: () => createDatabase,
@@ -8717,28 +8717,28 @@ __export(exports_dist, {
 import { createRequire } from "module";
 import { Database as Database2 } from "bun:sqlite";
 import {
-  existsSync as existsSync4,
+  existsSync as existsSync5,
   mkdirSync as mkdirSync2,
   readdirSync,
   copyFileSync
 } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join5, relative } from "path";
+import { homedir as homedir6 } from "os";
+import { join as join6, relative } from "path";
 import { existsSync as existsSync22, mkdirSync as mkdirSync22, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
 import { homedir as homedir22 } from "os";
 import { join as join22 } from "path";
-import { readdirSync as readdirSync2, existsSync as existsSync32 } from "fs";
-import { join as join32 } from "path";
-import { homedir as homedir32 } from "os";
+import { readdirSync as readdirSync3, existsSync as existsSync6 } from "fs";
+import { join as join62 } from "path";
+import { homedir as homedir52 } from "os";
 import { hostname } from "os";
-import { existsSync as existsSync42, readFileSync as readFileSync22 } from "fs";
-import { homedir as homedir42 } from "os";
+import { existsSync as existsSync32, readFileSync as readFileSync22 } from "fs";
+import { homedir as homedir32 } from "os";
+import { join as join32 } from "path";
+import { existsSync as existsSync42, readdirSync as readdirSync2 } from "fs";
 import { join as join42 } from "path";
-import { existsSync as existsSync5, readdirSync as readdirSync3 } from "fs";
-import { join as join52 } from "path";
-import { join as join6, dirname } from "path";
-import { existsSync as existsSync6, writeFileSync as writeFileSync22, unlinkSync, mkdirSync as mkdirSync3 } from "fs";
-import { homedir as homedir52, platform } from "os";
+import { join as join52, dirname } from "path";
+import { existsSync as existsSync52, writeFileSync as writeFileSync22, unlinkSync, mkdirSync as mkdirSync3 } from "fs";
+import { homedir as homedir42, platform } from "os";
 function __accessProp2(key) {
   return this[key];
 }
@@ -9620,20 +9620,20 @@ function custom(check, _params = {}, fatal) {
   return ZodAny.create();
 }
 function getDataDir(serviceName) {
-  const dir = join5(HASNA_DIR, serviceName);
+  const dir = join6(HASNA_DIR, serviceName);
   mkdirSync2(dir, { recursive: true });
   return dir;
 }
 function getDbPath2(serviceName) {
   const dir = getDataDir(serviceName);
-  return join5(dir, `${serviceName}.db`);
+  return join6(dir, `${serviceName}.db`);
 }
 function migrateDotfile(serviceName) {
-  const legacyDir = join5(homedir5(), `.${serviceName}`);
-  const newDir = join5(HASNA_DIR, serviceName);
-  if (!existsSync4(legacyDir))
+  const legacyDir = join6(homedir6(), `.${serviceName}`);
+  const newDir = join6(HASNA_DIR, serviceName);
+  if (!existsSync5(legacyDir))
     return [];
-  if (existsSync4(newDir))
+  if (existsSync5(newDir))
     return [];
   mkdirSync2(newDir, { recursive: true });
   const migrated = [];
@@ -9643,8 +9643,8 @@ function migrateDotfile(serviceName) {
 function copyDirRecursive(src, dest, root, migrated) {
   const entries = readdirSync(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = join5(src, entry.name);
-    const destPath = join5(dest, entry.name);
+    const srcPath = join6(src, entry.name);
+    const destPath = join6(dest, entry.name);
     if (entry.isDirectory()) {
       mkdirSync2(destPath, { recursive: true });
       copyDirRecursive(srcPath, destPath, root, migrated);
@@ -9655,7 +9655,7 @@ function copyDirRecursive(src, dest, root, migrated) {
   }
 }
 function hasLegacyDotfile(serviceName) {
-  return existsSync4(join5(homedir5(), `.${serviceName}`));
+  return existsSync5(join6(homedir6(), `.${serviceName}`));
 }
 function getHasnaDir() {
   mkdirSync2(HASNA_DIR, { recursive: true });
@@ -9710,11 +9710,11 @@ function isSyncExcludedTable(table) {
   return SYNC_EXCLUDED_TABLE_PATTERNS.some((p) => p.test(table));
 }
 function discoverServices() {
-  const dataDir = join32(homedir32(), ".hasna");
-  if (!existsSync32(dataDir))
+  const dataDir = join62(homedir52(), ".hasna");
+  if (!existsSync6(dataDir))
     return [];
   try {
-    const entries = readdirSync2(dataDir, { withFileTypes: true });
+    const entries = readdirSync3(dataDir, { withFileTypes: true });
     return entries.filter((e) => {
       if (!e.isDirectory())
         return false;
@@ -9726,30 +9726,30 @@ function discoverServices() {
     return [];
   }
 }
-function discoverSyncableServices() {
+function discoverSyncableServices2() {
   const local = discoverServices();
   const pgSet = new Set(KNOWN_PG_SERVICES);
   return local.filter((s) => pgSet.has(s));
 }
 function getServiceDbPath(service) {
-  const dataDir = join32(homedir32(), ".hasna", service);
-  if (!existsSync32(dataDir))
+  const dataDir = join62(homedir52(), ".hasna", service);
+  if (!existsSync6(dataDir))
     return null;
   const candidates = [
-    join32(dataDir, `${service}.db`),
-    join32(dataDir, "data.db"),
-    join32(dataDir, "database.db")
+    join62(dataDir, `${service}.db`),
+    join62(dataDir, "data.db"),
+    join62(dataDir, "database.db")
   ];
   try {
-    const files = readdirSync2(dataDir);
+    const files = readdirSync3(dataDir);
     for (const f of files) {
       if (f.endsWith(".db") && !f.endsWith("-wal") && !f.endsWith("-shm")) {
-        candidates.push(join32(dataDir, f));
+        candidates.push(join62(dataDir, f));
       }
     }
   } catch {}
   for (const p of candidates) {
-    if (existsSync32(p))
+    if (existsSync6(p))
       return p;
   }
   return null;
@@ -10056,9 +10056,9 @@ async function syncTransfer(source, target, options, _direction) {
           const batch = rows.slice(offset, offset + batchSize);
           try {
             if (isAsyncAdapter(target)) {
-              await batchUpsertPg(target, table, columns, updateCols, pkColumns, batch, columns.includes(conflictColumn) ? conflictColumn : undefined);
+              await batchUpsertPg(target, table, columns, updateCols, pkColumns, batch);
             } else {
-              batchUpsertSqlite(target, table, columns, updateCols, pkColumns, batch, columns.includes(conflictColumn) ? conflictColumn : undefined);
+              batchUpsertSqlite(target, table, columns, updateCols, pkColumns, batch);
             }
             result.rowsWritten += batch.length;
           } catch (err) {
@@ -10105,7 +10105,7 @@ async function syncTransfer(source, target, options, _direction) {
   }
   return results;
 }
-async function batchUpsertPg(target, table, columns, updateCols, primaryKeys, batch, conflictColumn) {
+async function batchUpsertPg(target, table, columns, updateCols, primaryKeys, batch) {
   if (batch.length === 0)
     return;
   const colList = columns.map((c) => `"${c}"`).join(", ");
@@ -10115,22 +10115,20 @@ async function batchUpsertPg(target, table, columns, updateCols, primaryKeys, ba
   }).join(", ");
   const pkList = primaryKeys.map((c) => `"${c}"`).join(", ");
   const setClause = updateCols.length > 0 ? updateCols.map((c) => `"${c}" = EXCLUDED."${c}"`).join(", ") : `"${primaryKeys[0]}" = EXCLUDED."${primaryKeys[0]}"`;
-  const whereClause = conflictColumn && updateCols.includes(conflictColumn) ? ` WHERE "${table}"."${conflictColumn}" IS NULL OR EXCLUDED."${conflictColumn}" >= "${table}"."${conflictColumn}"` : "";
   const sql = `INSERT INTO "${table}" (${colList}) VALUES ${valuePlaceholders}
-    ON CONFLICT (${pkList}) DO UPDATE SET ${setClause}${whereClause}`;
+    ON CONFLICT (${pkList}) DO UPDATE SET ${setClause}`;
   const params = batch.flatMap((row) => columns.map((c) => row[c] ?? null));
   await target.run(sql, ...params);
 }
-function batchUpsertSqlite(target, table, columns, updateCols, primaryKeys, batch, conflictColumn) {
+function batchUpsertSqlite(target, table, columns, updateCols, primaryKeys, batch) {
   if (batch.length === 0)
     return;
   const colList = columns.map((c) => `"${c}"`).join(", ");
   const valuePlaceholders = batch.map(() => `(${columns.map(() => "?").join(", ")})`).join(", ");
   const pkList = primaryKeys.map((c) => `"${c}"`).join(", ");
   const setClause = updateCols.length > 0 ? updateCols.map((c) => `"${c}" = EXCLUDED."${c}"`).join(", ") : `"${primaryKeys[0]}" = EXCLUDED."${primaryKeys[0]}"`;
-  const whereClause = conflictColumn && updateCols.includes(conflictColumn) ? ` WHERE "${table}"."${conflictColumn}" IS NULL OR EXCLUDED."${conflictColumn}" >= "${table}"."${conflictColumn}"` : "";
   const sql = `INSERT INTO "${table}" (${colList}) VALUES ${valuePlaceholders}
-    ON CONFLICT (${pkList}) DO UPDATE SET ${setClause}${whereClause}`;
+    ON CONFLICT (${pkList}) DO UPDATE SET ${setClause}`;
   const params = batch.flatMap((row) => columns.map((c) => coerceForSqlite(row[c])));
   target.run(sql, ...params);
 }
@@ -10189,17 +10187,17 @@ function ensureFeedbackTable(db) {
 function saveFeedback(db, feedback) {
   ensureFeedbackTable(db);
   const id = feedback.id ?? Math.random().toString(36).slice(2) + Date.now().toString(36);
-  const now = new Date().toISOString();
+  const now2 = new Date().toISOString();
   const machineId = feedback.machine_id ?? hostname();
   db.run(`INSERT INTO feedback (id, service, version, message, email, machine_id, created_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?)`, id, feedback.service, feedback.version ?? "", feedback.message, feedback.email ?? "", machineId, feedback.created_at ?? now);
+     VALUES (?, ?, ?, ?, ?, ?, ?)`, id, feedback.service, feedback.version ?? "", feedback.message, feedback.email ?? "", machineId, feedback.created_at ?? now2);
   return id;
 }
 async function sendFeedback(feedback, db) {
   const config = getCloudConfig();
   const id = feedback.id ?? Math.random().toString(36).slice(2) + Date.now().toString(36);
   const machineId = feedback.machine_id ?? hostname();
-  const now = new Date().toISOString();
+  const now2 = new Date().toISOString();
   const payload = {
     id,
     service: feedback.service,
@@ -10207,7 +10205,7 @@ async function sendFeedback(feedback, db) {
     message: feedback.message,
     email: feedback.email ?? "",
     machine_id: machineId,
-    created_at: feedback.created_at ?? now
+    created_at: feedback.created_at ?? now2
   };
   try {
     const res = await fetch(config.feedback_endpoint, {
@@ -10263,8 +10261,8 @@ class SyncProgressTracker {
   }
   start(table, total, direction) {
     const resumed = this.canResume(table);
-    const now = Date.now();
-    this.startTimes.set(table, now);
+    const now2 = Date.now();
+    this.startTimes.set(table, now2);
     const status = resumed ? "resumed" : "in_progress";
     const info = {
       table,
@@ -10586,10 +10584,10 @@ function incrementalSyncPush(local, remote, tables, options = {}) {
       if (rows.length === 0) {
         stat.skipped_rows = stat.total_rows;
       }
-      const now = new Date().toISOString();
+      const now2 = new Date().toISOString();
       upsertSyncMeta(local, {
         table_name: table,
-        last_synced_at: now,
+        last_synced_at: now2,
         last_synced_row_count: stat.synced_rows,
         direction: "push"
       });
@@ -10639,10 +10637,10 @@ function incrementalSyncPull(remote, local, tables, options = {}) {
       if (rows.length === 0) {
         stat.skipped_rows = stat.total_rows;
       }
-      const now = new Date().toISOString();
+      const now2 = new Date().toISOString();
       upsertSyncMeta(local, {
         table_name: table,
-        last_synced_at: now,
+        last_synced_at: now2,
         last_synced_row_count: stat.synced_rows,
         direction: "pull"
       });
@@ -10670,7 +10668,7 @@ function resetAllSyncMeta(db) {
 }
 function getAutoSyncConfig() {
   try {
-    if (!existsSync42(AUTO_SYNC_CONFIG_PATH)) {
+    if (!existsSync32(AUTO_SYNC_CONFIG_PATH)) {
       return { ...DEFAULT_AUTO_SYNC_CONFIG };
     }
     const raw = JSON.parse(readFileSync22(AUTO_SYNC_CONFIG_PATH, "utf-8"));
@@ -10682,7 +10680,7 @@ function getAutoSyncConfig() {
     return { ...DEFAULT_AUTO_SYNC_CONFIG };
   }
 }
-async function executeAutoSync(event, serviceName, local, tables) {
+function executeAutoSync(event, local, remote, tables) {
   const direction = event === "start" ? "pull" : "push";
   const result = {
     event,
@@ -10692,31 +10690,18 @@ async function executeAutoSync(event, serviceName, local, tables) {
     total_rows_synced: 0,
     errors: []
   };
-  let remote = null;
   try {
-    const connStr = getConnectionString(serviceName);
-    remote = new PgAdapterAsync(connStr);
-    const syncTables = tables.length > 0 ? tables.filter((t) => !isSyncExcludedTable(t)) : direction === "push" ? listSqliteTables(local).filter((t) => !isSyncExcludedTable(t)) : (await listPgTables(remote)).filter((t) => !isSyncExcludedTable(t));
-    if (syncTables.length === 0) {
-      result.success = true;
-      return result;
-    }
-    const results = direction === "pull" ? await syncPull(remote, local, { tables: syncTables }) : await syncPush(local, remote, { tables: syncTables });
-    for (const r of results) {
-      if (r.errors.length === 0)
+    const stats = direction === "pull" ? incrementalSyncPull(remote, local, tables) : incrementalSyncPush(local, remote, tables);
+    for (const s of stats) {
+      if (s.errors.length === 0) {
         result.tables_synced++;
-      result.total_rows_synced += r.rowsWritten;
-      result.errors.push(...r.errors);
+      }
+      result.total_rows_synced += s.synced_rows;
+      result.errors.push(...s.errors);
     }
     result.success = result.errors.length === 0;
   } catch (err) {
     result.errors.push(err?.message ?? String(err));
-  } finally {
-    if (remote) {
-      try {
-        await remote.close();
-      } catch {}
-    }
   }
   return result;
 }
@@ -10724,76 +10709,80 @@ function installSignalHandlers() {
   if (signalHandlersInstalled)
     return;
   signalHandlersInstalled = true;
-  const handleExit = async () => {
+  const handleExit = () => {
     for (const fn of cleanupHandlers) {
       try {
-        await fn();
+        fn();
       } catch {}
     }
   };
-  process.on("SIGTERM", async () => {
-    await handleExit();
+  process.on("SIGTERM", () => {
+    handleExit();
     process.exit(0);
   });
-  process.on("SIGINT", async () => {
-    await handleExit();
+  process.on("SIGINT", () => {
+    handleExit();
     process.exit(0);
   });
-  process.on("beforeExit", async () => {
-    await handleExit();
+  process.on("beforeExit", () => {
+    handleExit();
   });
 }
 function setupAutoSync(serviceName, server, local, remote, tables) {
   const config = getAutoSyncConfig();
   const cloudConfig = getCloudConfig();
   const isSyncEnabled = cloudConfig.mode === "hybrid" || cloudConfig.mode === "cloud";
-  const syncOnStart = async () => {
+  const syncOnStart = () => {
     if (!config.auto_sync_on_start || !isSyncEnabled)
       return null;
-    return executeAutoSync("start", serviceName, local, tables);
+    return executeAutoSync("start", local, remote, tables);
   };
-  const syncOnStop = async () => {
+  const syncOnStop = () => {
     if (!config.auto_sync_on_stop || !isSyncEnabled)
       return null;
-    return executeAutoSync("stop", serviceName, local, tables);
+    return executeAutoSync("stop", local, remote, tables);
   };
   if (server && typeof server.onconnect === "function") {
     const origOnConnect = server.onconnect;
-    server.onconnect = async (...args) => {
-      await syncOnStart();
+    server.onconnect = (...args) => {
+      syncOnStart();
       return origOnConnect.apply(server, args);
     };
   } else if (server && typeof server.on === "function") {
-    server.on("connect", () => syncOnStart());
+    server.on("connect", () => {
+      syncOnStart();
+    });
   }
   if (server && typeof server.ondisconnect === "function") {
     const origOnDisconnect = server.ondisconnect;
-    server.ondisconnect = async (...args) => {
-      await syncOnStop();
+    server.ondisconnect = (...args) => {
+      syncOnStop();
       return origOnDisconnect.apply(server, args);
     };
   } else if (server && typeof server.on === "function") {
-    server.on("disconnect", () => syncOnStop());
+    server.on("disconnect", () => {
+      syncOnStop();
+    });
   }
   installSignalHandlers();
-  cleanupHandlers.push(async () => {
-    await syncOnStop();
+  cleanupHandlers.push(() => {
+    syncOnStop();
   });
   return { syncOnStart, syncOnStop, config };
 }
 function enableAutoSync(serviceName, mcpServer, local, remote, tables) {
   setupAutoSync(serviceName, mcpServer, local, remote, tables);
 }
-function discoverSyncableServices2() {
+function discoverSyncableServices() {
   const hasnaDir = getHasnaDir();
   const services = [];
   try {
-    const entries = readdirSync3(hasnaDir, { withFileTypes: true });
+    const entries = readdirSync2(hasnaDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const dbPath = join52(hasnaDir, entry.name, `${entry.name}.db`);
-      if (existsSync5(dbPath)) {
+      const dbPath = join42(hasnaDir, entry.name, `${entry.name}.db`);
+      if (existsSync42(dbPath)) {
         services.push(entry.name);
       }
     }
@@ -10804,7 +10793,7 @@ async function runScheduledSync() {
   const config = getCloudConfig();
   if (config.mode === "local")
     return [];
-  const services = discoverSyncableServices2();
+  const services = discoverSyncableServices();
   const results = [];
   let remote = null;
   for (const service of services) {
@@ -10815,8 +10804,8 @@ async function runScheduledSync() {
       errors: []
     };
     try {
-      const dbPath = join52(getDataDir(service), `${service}.db`);
-      if (!existsSync5(dbPath)) {
+      const dbPath = join42(getDataDir(service), `${service}.db`);
+      if (!existsSync42(dbPath)) {
         continue;
       }
       const local = new SqliteAdapter(dbPath);
@@ -10897,34 +10886,34 @@ function minutesToCron(minutes) {
 }
 function getWorkerPath() {
   const dir = typeof import.meta.dir === "string" ? import.meta.dir : dirname(import.meta.url.replace("file://", ""));
-  const tsPath = join6(dir, "scheduled-sync.ts");
-  const jsPath = join6(dir, "scheduled-sync.js");
+  const tsPath = join52(dir, "scheduled-sync.ts");
+  const jsPath = join52(dir, "scheduled-sync.js");
   try {
-    if (existsSync6(tsPath))
+    if (existsSync52(tsPath))
       return tsPath;
   } catch {}
   return jsPath;
 }
 function getBunPath() {
   const candidates = [
-    join6(homedir52(), ".bun", "bin", "bun"),
+    join52(homedir42(), ".bun", "bin", "bun"),
     "/usr/local/bin/bun",
     "/usr/bin/bun"
   ];
   for (const p of candidates) {
-    if (existsSync6(p))
+    if (existsSync52(p))
       return p;
   }
   return "bun";
 }
 function getLaunchdPlistPath() {
-  return join6(homedir52(), "Library", "LaunchAgents", `com.hasna.cloud-sync.plist`);
+  return join52(homedir42(), "Library", "LaunchAgents", `com.hasna.cloud-sync.plist`);
 }
 function createLaunchdPlist(intervalMinutes) {
   const workerPath = getWorkerPath();
   const bunPath = getBunPath();
-  const logPath = join6(CONFIG_DIR2, "sync.log");
-  const errorLogPath = join6(CONFIG_DIR2, "sync-error.log");
+  const logPath = join52(CONFIG_DIR2, "sync.log");
+  const errorLogPath = join52(CONFIG_DIR2, "sync-error.log");
   return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -10950,7 +10939,7 @@ function createLaunchdPlist(intervalMinutes) {
     <key>PATH</key>
     <string>${process.env.PATH || "/usr/local/bin:/usr/bin:/bin"}</string>
     <key>HOME</key>
-    <string>${homedir52()}</string>
+    <string>${homedir42()}</string>
   </dict>
 </dict>
 </plist>`;
@@ -10975,7 +10964,7 @@ async function removeLaunchd() {
   } catch {}
 }
 function getSystemdDir() {
-  return join6(homedir52(), ".config", "systemd", "user");
+  return join52(homedir42(), ".config", "systemd", "user");
 }
 function createSystemdService() {
   const workerPath = getWorkerPath();
@@ -10987,7 +10976,7 @@ After=network.target
 [Service]
 Type=oneshot
 ExecStart=${bunPath} run ${workerPath}
-Environment=HOME=${homedir52()}
+Environment=HOME=${homedir42()}
 Environment=PATH=${process.env.PATH || "/usr/local/bin:/usr/bin:/bin"}
 
 [Install]
@@ -11010,8 +10999,8 @@ WantedBy=timers.target
 async function registerSystemd(intervalMinutes) {
   const dir = getSystemdDir();
   mkdirSync3(dir, { recursive: true });
-  writeFileSync22(join6(dir, `${SERVICE_NAME}.service`), createSystemdService());
-  writeFileSync22(join6(dir, `${SERVICE_NAME}.timer`), createSystemdTimer(intervalMinutes));
+  writeFileSync22(join52(dir, `${SERVICE_NAME}.service`), createSystemdService());
+  writeFileSync22(join52(dir, `${SERVICE_NAME}.timer`), createSystemdTimer(intervalMinutes));
   await Bun.spawn(["systemctl", "--user", "daemon-reload"]).exited;
   await Bun.spawn(["systemctl", "--user", "enable", "--now", `${SERVICE_NAME}.timer`]).exited;
 }
@@ -11021,10 +11010,10 @@ async function removeSystemd() {
   } catch {}
   const dir = getSystemdDir();
   try {
-    unlinkSync(join6(dir, `${SERVICE_NAME}.service`));
+    unlinkSync(join52(dir, `${SERVICE_NAME}.service`));
   } catch {}
   try {
-    unlinkSync(join6(dir, `${SERVICE_NAME}.timer`));
+    unlinkSync(join52(dir, `${SERVICE_NAME}.timer`));
   } catch {}
   try {
     await Bun.spawn(["systemctl", "--user", "daemon-reload"]).exited;
@@ -11061,9 +11050,9 @@ function getSyncScheduleStatus() {
   let mechanism = "none";
   if (registered) {
     if (platform() === "darwin") {
-      mechanism = existsSync6(getLaunchdPlistPath()) ? "launchd" : "none";
+      mechanism = existsSync52(getLaunchdPlistPath()) ? "launchd" : "none";
     } else {
-      mechanism = existsSync6(join6(getSystemdDir(), `${SERVICE_NAME}.timer`)) ? "systemd" : "none";
+      mechanism = existsSync52(join52(getSystemdDir(), `${SERVICE_NAME}.timer`)) ? "systemd" : "none";
     }
   }
   return {
@@ -11200,7 +11189,7 @@ async function ensureAllPgDatabases() {
   }
   return results;
 }
-function registerCloudTools(server, serviceName, opts = {}) {
+function registerCloudTools(server, serviceName) {
   server.tool(`${serviceName}_cloud_status`, "Show cloud configuration and connection health", {}, async () => {
     const config = getCloudConfig();
     const lines = [
@@ -11233,13 +11222,8 @@ function registerCloudTools(server, serviceName, opts = {}) {
         isError: true
       };
     }
-    const local = new SqliteAdapter(opts.dbPath ?? getDbPath2(serviceName));
+    const local = new SqliteAdapter(getDbPath2(serviceName));
     const cloud = new PgAdapterAsync(getConnectionString(serviceName));
-    if (opts.migrations?.length) {
-      for (const sql of opts.migrations) {
-        await cloud.run(sql);
-      }
-    }
     const tableList = tablesStr ? tablesStr.split(",").map((t) => t.trim()) : listSqliteTables(local);
     const results = await syncPush(local, cloud, { tables: tableList });
     local.close();
@@ -11261,7 +11245,7 @@ function registerCloudTools(server, serviceName, opts = {}) {
         isError: true
       };
     }
-    const local = new SqliteAdapter(opts.dbPath ?? getDbPath2(serviceName));
+    const local = new SqliteAdapter(getDbPath2(serviceName));
     const cloud = new PgAdapterAsync(getConnectionString(serviceName));
     let tableList;
     if (tablesStr) {
@@ -19613,7 +19597,7 @@ See https://www.postgresql.org/docs/current/libpq-ssl.html for libpq SSL mode de
     init_external();
   });
   init_dotfile = __esm2(() => {
-    HASNA_DIR = join5(homedir5(), ".hasna");
+    HASNA_DIR = join6(homedir6(), ".hasna");
   });
   exports_config = {};
   __export2(exports_config, {
@@ -19651,7 +19635,7 @@ See https://www.postgresql.org/docs/current/libpq-ssl.html for libpq SSL mode de
   __export2(exports_discover, {
     isSyncExcludedTable: () => isSyncExcludedTable,
     getServiceDbPath: () => getServiceDbPath,
-    discoverSyncableServices: () => discoverSyncableServices,
+    discoverSyncableServices: () => discoverSyncableServices2,
     discoverServices: () => discoverServices,
     SYNC_EXCLUDED_TABLE_PATTERNS: () => SYNC_EXCLUDED_TABLE_PATTERNS,
     KNOWN_PG_SERVICES: () => KNOWN_PG_SERVICES
@@ -19706,10 +19690,8 @@ See https://www.postgresql.org/docs/current/libpq-ssl.html for libpq SSL mode de
   init_config();
   init_config();
   init_dotfile();
-  init_adapter();
   init_config();
-  init_discover();
-  AUTO_SYNC_CONFIG_PATH = join42(homedir42(), ".hasna", "cloud", "config.json");
+  AUTO_SYNC_CONFIG_PATH = join32(homedir32(), ".hasna", "cloud", "config.json");
   DEFAULT_AUTO_SYNC_CONFIG = {
     auto_sync_on_start: true,
     auto_sync_on_stop: true
@@ -19719,7 +19701,7 @@ See https://www.postgresql.org/docs/current/libpq-ssl.html for libpq SSL mode de
   init_adapter();
   init_dotfile();
   init_config();
-  CONFIG_DIR2 = join6(homedir52(), ".hasna", "cloud");
+  CONFIG_DIR2 = join52(homedir42(), ".hasna", "cloud");
   init_adapter();
   init_config();
   init_discover();
@@ -19732,6 +19714,690 @@ See https://www.postgresql.org/docs/current/libpq-ssl.html for libpq SSL mode de
   init_adapter();
 });
 
+// node_modules/@hasna/events/dist/commander.js
+import { chmod, mkdir, readFile, rename, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { createHmac, timingSafeEqual } from "crypto";
+import { randomUUID } from "crypto";
+import { spawn } from "child_process";
+import { randomUUID as randomUUID2 } from "crypto";
+function getPathValue(input, path) {
+  return path.split(".").reduce((value, part) => {
+    if (value && typeof value === "object" && part in value) {
+      return value[part];
+    }
+    return;
+  }, input);
+}
+function wildcardToRegExp(pattern) {
+  const escaped = pattern.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${escaped}$`);
+}
+function matchString(value, matcher) {
+  if (matcher === undefined)
+    return true;
+  if (value === undefined)
+    return false;
+  const matchers = Array.isArray(matcher) ? matcher : [matcher];
+  return matchers.some((item) => wildcardToRegExp(item).test(value));
+}
+function matchRecord(input, matcher) {
+  if (!matcher)
+    return true;
+  return Object.entries(matcher).every(([path, expected]) => {
+    const actual = getPathValue(input, path);
+    if (typeof expected === "string" || Array.isArray(expected)) {
+      return matchString(actual === undefined ? undefined : String(actual), expected);
+    }
+    return actual === expected;
+  });
+}
+function eventMatchesFilter(event, filter) {
+  return matchString(event.source, filter.source) && matchString(event.type, filter.type) && matchString(event.subject, filter.subject) && matchString(event.severity, filter.severity) && matchRecord(event.data, filter.data) && matchRecord(event.metadata, filter.metadata);
+}
+function channelMatchesEvent(channel, event) {
+  if (!channel.enabled)
+    return false;
+  if (!channel.filters || channel.filters.length === 0)
+    return true;
+  return channel.filters.some((filter) => eventMatchesFilter(event, filter));
+}
+var HASNA_EVENTS_DIR_ENV = "HASNA_EVENTS_DIR";
+var HASNA_EVENTS_HOME_ENV = "HASNA_EVENTS_HOME";
+function getEventsDataDir(override) {
+  return override || process.env[HASNA_EVENTS_DIR_ENV] || process.env[HASNA_EVENTS_HOME_ENV] || join(homedir(), ".hasna", "events");
+}
+
+class JsonEventsStore {
+  dataDir;
+  channelsPath;
+  eventsPath;
+  deliveriesPath;
+  constructor(dataDir = getEventsDataDir()) {
+    this.dataDir = dataDir;
+    this.channelsPath = join(dataDir, "channels.json");
+    this.eventsPath = join(dataDir, "events.json");
+    this.deliveriesPath = join(dataDir, "deliveries.json");
+  }
+  async init() {
+    await mkdir(this.dataDir, { recursive: true, mode: 448 });
+    await chmod(this.dataDir, 448).catch(() => {
+      return;
+    });
+    await this.ensureArrayFile(this.channelsPath);
+    await this.ensureArrayFile(this.eventsPath);
+    await this.ensureArrayFile(this.deliveriesPath);
+  }
+  async addChannel(channel) {
+    await this.init();
+    const channels = await this.readJson(this.channelsPath, []);
+    const index = channels.findIndex((item) => item.id === channel.id);
+    if (index >= 0) {
+      channels[index] = { ...channel, createdAt: channels[index].createdAt, updatedAt: new Date().toISOString() };
+    } else {
+      channels.push(channel);
+    }
+    await this.writeJson(this.channelsPath, channels);
+    return index >= 0 ? channels[index] : channel;
+  }
+  async listChannels() {
+    await this.init();
+    return this.readJson(this.channelsPath, []);
+  }
+  async getChannel(id) {
+    const channels = await this.listChannels();
+    return channels.find((channel) => channel.id === id);
+  }
+  async removeChannel(id) {
+    await this.init();
+    const channels = await this.readJson(this.channelsPath, []);
+    const next = channels.filter((channel) => channel.id !== id);
+    await this.writeJson(this.channelsPath, next);
+    return next.length !== channels.length;
+  }
+  async appendEvent(event) {
+    await this.init();
+    const events = await this.readJson(this.eventsPath, []);
+    events.push(event);
+    await this.writeJson(this.eventsPath, events);
+    return event;
+  }
+  async listEvents() {
+    await this.init();
+    return this.readJson(this.eventsPath, []);
+  }
+  async findEventByIdentity(identity) {
+    const events = await this.listEvents();
+    return events.find((event) => identity.id !== undefined && event.id === identity.id || identity.dedupeKey !== undefined && event.dedupeKey === identity.dedupeKey);
+  }
+  async appendDelivery(result) {
+    await this.init();
+    const deliveries = await this.readJson(this.deliveriesPath, []);
+    deliveries.push(result);
+    await this.writeJson(this.deliveriesPath, deliveries);
+    return result;
+  }
+  async listDeliveries() {
+    await this.init();
+    return this.readJson(this.deliveriesPath, []);
+  }
+  async exportData() {
+    return {
+      channels: await this.listChannels(),
+      events: await this.listEvents(),
+      deliveries: await this.listDeliveries()
+    };
+  }
+  async ensureArrayFile(path) {
+    if (!existsSync(path)) {
+      await writeFile(path, `[]
+`, { encoding: "utf-8", mode: 384 });
+    }
+    await chmod(path, 384).catch(() => {
+      return;
+    });
+  }
+  async readJson(path, fallback) {
+    try {
+      const raw = await readFile(path, "utf-8");
+      if (!raw.trim())
+        return fallback;
+      return JSON.parse(raw);
+    } catch (error) {
+      if (error.code === "ENOENT")
+        return fallback;
+      throw error;
+    }
+  }
+  async writeJson(path, value) {
+    const tempPath = `${path}.${process.pid}.${Date.now()}.tmp`;
+    await writeFile(tempPath, `${JSON.stringify(value, null, 2)}
+`, { encoding: "utf-8", mode: 384 });
+    await rename(tempPath, path);
+    await chmod(path, 384).catch(() => {
+      return;
+    });
+  }
+}
+var DEFAULT_SIGNATURE_TOLERANCE_MS = 5 * 60 * 1000;
+function buildSignatureBase(timestamp, body) {
+  return `${timestamp}.${body}`;
+}
+function signPayload(secret, timestamp, body) {
+  const digest = createHmac("sha256", secret).update(buildSignatureBase(timestamp, body)).digest("hex");
+  return `sha256=${digest}`;
+}
+function now() {
+  return new Date().toISOString();
+}
+function truncate(value, max = 4096) {
+  return value.length > max ? `${value.slice(0, max)}...` : value;
+}
+function buildWebhookRequest(event, channel) {
+  if (!channel.webhook)
+    throw new Error(`Channel ${channel.id} has no webhook config`);
+  const body = JSON.stringify(event);
+  const timestamp = event.time;
+  const headers = {
+    "Content-Type": "application/json",
+    "User-Agent": "@hasna/events",
+    "X-Hasna-Event-Id": event.id,
+    "X-Hasna-Event-Type": event.type,
+    "X-Hasna-Timestamp": timestamp,
+    ...channel.webhook.headers
+  };
+  if (channel.webhook.secret) {
+    headers["X-Hasna-Signature"] = signPayload(channel.webhook.secret, timestamp, body);
+  }
+  return { body, headers };
+}
+async function dispatchWebhook(event, channel, options = {}) {
+  if (!channel.webhook)
+    throw new Error(`Channel ${channel.id} has no webhook config`);
+  const startedAt = now();
+  const { body, headers } = buildWebhookRequest(event, channel);
+  const controller = new AbortController;
+  const timeout = setTimeout(() => controller.abort(), channel.webhook.timeoutMs ?? 15000);
+  try {
+    const response = await (options.fetchImpl ?? fetch)(channel.webhook.url, {
+      method: "POST",
+      headers,
+      body,
+      signal: controller.signal
+    });
+    const responseBody = truncate(await response.text());
+    return {
+      attempt: 1,
+      status: response.ok ? "success" : "failed",
+      startedAt,
+      completedAt: now(),
+      responseStatus: response.status,
+      responseBody,
+      error: response.ok ? undefined : `Webhook returned HTTP ${response.status}`
+    };
+  } catch (error) {
+    return {
+      attempt: 1,
+      status: "failed",
+      startedAt,
+      completedAt: now(),
+      error: error instanceof Error ? error.message : String(error)
+    };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function dispatchCommand(event, channel) {
+  if (!channel.command)
+    throw new Error(`Channel ${channel.id} has no command config`);
+  const startedAt = now();
+  const eventJson = JSON.stringify(event);
+  const env = {
+    ...process.env,
+    ...channel.command.env,
+    HASNA_CHANNEL_ID: channel.id,
+    HASNA_EVENT_ID: event.id,
+    HASNA_EVENT_TYPE: event.type,
+    HASNA_EVENT_SOURCE: event.source,
+    HASNA_EVENT_SUBJECT: event.subject ?? "",
+    HASNA_EVENT_SEVERITY: event.severity,
+    HASNA_EVENT_TIME: event.time,
+    HASNA_EVENT_DEDUPE_KEY: event.dedupeKey ?? "",
+    HASNA_EVENT_SCHEMA_VERSION: event.schemaVersion,
+    HASNA_EVENT_JSON: eventJson
+  };
+  return new Promise((resolve) => {
+    const child = spawn(channel.command.command, channel.command.args ?? [], {
+      cwd: channel.command.cwd,
+      env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    const timeout = setTimeout(() => child.kill("SIGTERM"), channel.command.timeoutMs ?? 15000);
+    child.stdin.end(eventJson);
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", (error) => {
+      clearTimeout(timeout);
+      resolve({
+        attempt: 1,
+        status: "failed",
+        startedAt,
+        completedAt: now(),
+        stdout: truncate(stdout),
+        stderr: truncate(stderr),
+        error: error.message
+      });
+    });
+    child.on("close", (code, signal) => {
+      clearTimeout(timeout);
+      const success = code === 0;
+      resolve({
+        attempt: 1,
+        status: success ? "success" : "failed",
+        startedAt,
+        completedAt: now(),
+        stdout: truncate(stdout),
+        stderr: truncate(stderr),
+        error: success ? undefined : `Command exited with ${signal ? `signal ${signal}` : `code ${code}`}`
+      });
+    });
+  });
+}
+async function dispatchChannel(event, channel, options = {}) {
+  if (channel.transport === "webhook")
+    return dispatchWebhook(event, channel, options);
+  if (channel.transport === "command")
+    return dispatchCommand(event, channel);
+  return {
+    attempt: 1,
+    status: "skipped",
+    startedAt: now(),
+    completedAt: now(),
+    error: `Unsupported transport: ${channel.transport}`
+  };
+}
+function createDeliveryResult(event, channel, attempts) {
+  const status = attempts.some((attempt) => attempt.status === "success") ? "success" : attempts.every((attempt) => attempt.status === "skipped") ? "skipped" : "failed";
+  return {
+    id: randomUUID(),
+    eventId: event.id,
+    channelId: channel.id,
+    transport: channel.transport,
+    status,
+    attempts,
+    createdAt: attempts[0]?.startedAt ?? now(),
+    completedAt: attempts.at(-1)?.completedAt ?? now()
+  };
+}
+function createEvent(input) {
+  return {
+    id: input.id ?? randomUUID2(),
+    source: input.source,
+    type: input.type,
+    time: normalizeTime(input.time),
+    subject: input.subject,
+    severity: input.severity ?? "info",
+    data: input.data ?? {},
+    message: input.message,
+    dedupeKey: input.dedupeKey,
+    schemaVersion: input.schemaVersion ?? "1.0",
+    metadata: input.metadata ?? {}
+  };
+}
+
+class EventsClient {
+  store;
+  redactors;
+  transportOptions;
+  constructor(options = {}) {
+    this.store = options.store ?? new JsonEventsStore(options.dataDir);
+    this.redactors = options.redactors ?? [];
+    this.transportOptions = { fetchImpl: options.fetchImpl };
+  }
+  async addChannel(input) {
+    const timestamp = new Date().toISOString();
+    return this.store.addChannel({
+      ...input,
+      createdAt: input.createdAt ?? timestamp,
+      updatedAt: input.updatedAt ?? timestamp
+    });
+  }
+  async listChannels() {
+    return this.store.listChannels();
+  }
+  async removeChannel(id) {
+    return this.store.removeChannel(id);
+  }
+  async emit(input, options = {}) {
+    const event = options.redactSensitiveData === false ? createEvent(input) : redactSensitiveKeys(createEvent(input));
+    if (options.dedupe !== false) {
+      const existing = await this.store.findEventByIdentity({ id: input.id, dedupeKey: event.dedupeKey });
+      if (existing) {
+        return { event: existing, deliveries: [], deduped: true };
+      }
+    }
+    await this.store.appendEvent(event);
+    const deliveries = options.deliver === false ? [] : await this.deliver(event);
+    return { event, deliveries, deduped: false };
+  }
+  async listEvents() {
+    return this.store.listEvents();
+  }
+  async listDeliveries() {
+    return this.store.listDeliveries();
+  }
+  async deliver(event) {
+    const channels = await this.store.listChannels();
+    const selected = channels.filter((channel) => channelMatchesEvent(channel, event));
+    const deliveries = [];
+    for (const channel of selected) {
+      const eventForChannel = await this.applyRedaction(event, channel);
+      const result = await this.deliverWithRetry(eventForChannel, channel);
+      await this.store.appendDelivery(result);
+      deliveries.push(result);
+    }
+    return deliveries;
+  }
+  async testChannel(id, input = {}) {
+    const channel = await this.store.getChannel(id);
+    if (!channel)
+      throw new Error(`Channel not found: ${id}`);
+    const event = createEvent({
+      source: input.source ?? "hasna.events",
+      type: input.type ?? "events.test",
+      subject: input.subject ?? id,
+      severity: input.severity ?? "info",
+      data: input.data ?? { test: true },
+      message: input.message ?? "Hasna events test delivery",
+      dedupeKey: input.dedupeKey,
+      schemaVersion: input.schemaVersion,
+      metadata: input.metadata,
+      time: input.time,
+      id: input.id
+    });
+    const eventForChannel = await this.applyRedaction(event, channel);
+    const result = await this.deliverWithRetry(eventForChannel, channel);
+    await this.store.appendDelivery(result);
+    return result;
+  }
+  async replay(options = {}) {
+    const events = (await this.store.listEvents()).filter((event) => {
+      if (options.eventId && event.id !== options.eventId)
+        return false;
+      if (options.source && event.source !== options.source)
+        return false;
+      if (options.type && event.type !== options.type)
+        return false;
+      return true;
+    });
+    if (options.dryRun)
+      return { events, deliveries: [] };
+    const deliveries = [];
+    for (const event of events) {
+      deliveries.push(...await this.deliver(event));
+    }
+    return { events, deliveries };
+  }
+  async applyRedaction(event, channel) {
+    let next = redactPaths(event, channel.redact?.paths ?? [], channel.redact?.replacement ?? "[REDACTED]");
+    for (const redactor of this.redactors) {
+      next = await redactor(next, channel);
+    }
+    return next;
+  }
+  async deliverWithRetry(event, channel) {
+    const policy = normalizeRetryPolicy(channel.retry);
+    const attempts = [];
+    for (let index = 0;index < policy.maxAttempts; index += 1) {
+      const attempt = await dispatchChannel(event, channel, this.transportOptions);
+      attempt.attempt = index + 1;
+      if (attempt.status === "failed" && index + 1 < policy.maxAttempts) {
+        attempt.nextBackoffMs = Math.round(policy.backoffMs * policy.multiplier ** index);
+      }
+      attempts.push(attempt);
+      if (attempt.status !== "failed")
+        break;
+      if (attempt.nextBackoffMs)
+        await Bun.sleep(attempt.nextBackoffMs);
+    }
+    return createDeliveryResult(event, channel, attempts);
+  }
+}
+function redactPaths(event, paths, replacement = "[REDACTED]") {
+  if (paths.length === 0)
+    return event;
+  const copy = structuredClone(event);
+  for (const path of paths) {
+    setPath(copy, path, replacement);
+  }
+  return copy;
+}
+function sanitizeChannelForOutput(channel) {
+  const copy = structuredClone(channel);
+  if (copy.webhook?.secret)
+    copy.webhook.secret = "[REDACTED]";
+  if (copy.command?.env) {
+    copy.command.env = Object.fromEntries(Object.entries(copy.command.env).map(([key, value]) => [key, shouldRedactKey(key) ? "[REDACTED]" : value]));
+  }
+  return copy;
+}
+function sanitizeChannelsForOutput(channels) {
+  return channels.map(sanitizeChannelForOutput);
+}
+function redactSensitiveKeys(event, replacement = "[REDACTED]") {
+  return redactValue(event, replacement);
+}
+function shouldRedactKey(key) {
+  return /secret|token|password|api[_-]?key|authorization/i.test(key);
+}
+function redactValue(value, replacement) {
+  if (Array.isArray(value))
+    return value.map((item) => redactValue(item, replacement));
+  if (!value || typeof value !== "object")
+    return value;
+  return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+    key,
+    shouldRedactKey(key) ? replacement : redactValue(item, replacement)
+  ]));
+}
+function setPath(input, path, replacement) {
+  const parts = path.split(".");
+  let cursor = input;
+  for (const part of parts.slice(0, -1)) {
+    const next = cursor[part];
+    if (!next || typeof next !== "object")
+      return;
+    cursor = next;
+  }
+  const last = parts.at(-1);
+  if (last && last in cursor)
+    cursor[last] = replacement;
+}
+function normalizeTime(value) {
+  if (!value)
+    return new Date().toISOString();
+  return value instanceof Date ? value.toISOString() : value;
+}
+function normalizeRetryPolicy(policy) {
+  return {
+    maxAttempts: Math.max(1, policy?.maxAttempts ?? 1),
+    backoffMs: Math.max(0, policy?.backoffMs ?? 250),
+    multiplier: Math.max(1, policy?.multiplier ?? 2)
+  };
+}
+function parseJsonObject(value, fallback) {
+  if (!value)
+    return fallback;
+  const parsed = JSON.parse(value);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("Expected a JSON object");
+  }
+  return parsed;
+}
+function parseHeaders(values) {
+  if (!values?.length)
+    return;
+  const headers = {};
+  for (const value of values) {
+    const separator = value.indexOf("=");
+    if (separator === -1)
+      throw new Error(`Invalid header, expected name=value: ${value}`);
+    headers[value.slice(0, separator)] = value.slice(separator + 1);
+  }
+  return headers;
+}
+function parseFilter(options) {
+  const filter2 = {};
+  if (options.source)
+    filter2.source = options.source;
+  if (options.type)
+    filter2.type = options.type;
+  if (options.subject)
+    filter2.subject = options.subject;
+  if (options.severity)
+    filter2.severity = options.severity;
+  return Object.keys(filter2).length > 0 ? [filter2] : undefined;
+}
+function createClient(options) {
+  if (options.createClient)
+    return options.createClient();
+  return new EventsClient({ store: new JsonEventsStore(options.dataDir) });
+}
+function print(value, json, text) {
+  if (json)
+    console.log(JSON.stringify(value, null, 2));
+  else
+    console.log(text);
+}
+function hasJsonOption(options) {
+  return Boolean(options?.json || options?.opts?.().json || options?.optsWithGlobals?.().json || options?.parent?.opts?.().json || options?.parent?.optsWithGlobals?.().json);
+}
+function wantsJson(actionOptions, command) {
+  return hasJsonOption(actionOptions) || hasJsonOption(command);
+}
+function registerWebhookCommands(program, options) {
+  const webhooks = program.command(options.webhooksCommandName ?? "webhooks").description("Manage Hasna event webhook subscriptions");
+  webhooks.command("add").description("Add or replace a webhook or command subscription").argument("<target>", "Webhook URL or command binary").requiredOption("--id <id>", "Subscription/channel identifier").option("--transport <kind>", "Transport kind: webhook or command", "webhook").option("--name <name>", "Display name").option("--type <pattern>", "Event type filter, e.g. todos.task.*").option("--source <pattern>", "Event source filter").option("--subject <pattern>", "Event subject filter").option("--severity <pattern>", "Event severity filter").option("--secret <secret>", "Webhook HMAC secret").option("--header <name=value...>", "Webhook header", collectValues, []).option("--arg <arg...>", "Command argument", collectValues, []).option("--timeout-ms <ms>", "Transport timeout in milliseconds", parseNumber).option("--retry-attempts <n>", "Maximum delivery attempts", parseNumber).option("--retry-backoff-ms <ms>", "Initial retry backoff in milliseconds", parseNumber).option("--redact <path...>", "Event field path to redact before delivery", collectValues, []).option("--disabled", "Create channel disabled", false).option("-j, --json", "Print JSON output", false).action(async (target, actionOptions, command) => {
+    const timestamp = new Date().toISOString();
+    const channel = {
+      id: actionOptions.id,
+      name: actionOptions.name,
+      enabled: !actionOptions.disabled,
+      transport: actionOptions.transport,
+      filters: parseFilter(actionOptions),
+      retry: actionOptions.retryAttempts || actionOptions.retryBackoffMs ? { maxAttempts: actionOptions.retryAttempts, backoffMs: actionOptions.retryBackoffMs } : undefined,
+      redact: actionOptions.redact?.length ? { paths: actionOptions.redact } : undefined,
+      createdAt: timestamp,
+      updatedAt: timestamp
+    };
+    if (actionOptions.transport === "webhook") {
+      channel.webhook = { url: target, secret: actionOptions.secret, headers: parseHeaders(actionOptions.header), timeoutMs: actionOptions.timeoutMs };
+    } else if (actionOptions.transport === "command") {
+      channel.command = { command: target, args: actionOptions.arg ?? [], timeoutMs: actionOptions.timeoutMs };
+    } else {
+      throw new Error(`Transport ${actionOptions.transport} is reserved for future use and cannot be added yet`);
+    }
+    const saved = await createClient(options).addChannel(channel);
+    print(sanitizeChannelForOutput(saved), wantsJson(actionOptions, command), `Added ${saved.transport} channel ${saved.id}`);
+  });
+  webhooks.command("list").description("List configured subscriptions").option("-j, --json", "Print JSON output", false).action(async (actionOptions, command) => {
+    const channels = await createClient(options).listChannels();
+    if (wantsJson(actionOptions, command)) {
+      console.log(JSON.stringify(sanitizeChannelsForOutput(channels), null, 2));
+      return;
+    }
+    if (!channels.length) {
+      console.log("No channels configured.");
+      return;
+    }
+    for (const channel of channels) {
+      console.log(`${channel.id}	${channel.enabled ? "enabled" : "disabled"}	${channel.transport}	${channel.webhook?.url ?? channel.command?.command ?? channel.transport}`);
+    }
+  });
+  webhooks.command("remove").description("Remove a subscription").argument("<id>", "Subscription/channel identifier").option("-j, --json", "Print JSON output", false).action(async (id, actionOptions, command) => {
+    const removed = await createClient(options).removeChannel(id);
+    print({ removed }, wantsJson(actionOptions, command), removed ? `Removed ${id}` : `Channel not found: ${id}`);
+  });
+  webhooks.command("test").description("Send a test event to one subscription").argument("<id>", "Subscription/channel identifier").option("--type <type>", "Event type", "events.test").option("--subject <subject>", "Event subject").option("--message <message>", "Event message", "Hasna events test delivery").option("--data <json>", "Event data JSON object").option("-j, --json", "Print JSON output", false).action(async (id, actionOptions, command) => {
+    const result = await createClient(options).testChannel(id, {
+      source: options.source,
+      type: actionOptions.type,
+      subject: actionOptions.subject ?? id,
+      message: actionOptions.message,
+      data: parseJsonObject(actionOptions.data, { test: true })
+    });
+    print(result, wantsJson(actionOptions, command), `${result.status}: ${result.channelId}`);
+  });
+  return webhooks;
+}
+function registerEventCommands(program, options) {
+  const events = program.command(options.eventsCommandName ?? "events").description("Emit, list, and replay Hasna events");
+  events.command("emit").description("Emit an event from this app").argument("<type>", "Event type").option("--source <source>", "Event source override").option("--subject <subject>", "Event subject").option("--severity <severity>", "Event severity", "info").option("--message <message>", "Event message").option("--dedupe-key <key>", "Dedupe key").option("--data <json>", "Event data JSON object").option("--metadata <json>", "Event metadata JSON object").option("--no-deliver", "Record without delivering").option("--no-dedupe", "Allow duplicate id/dedupeKey events").option("-j, --json", "Print JSON output", false).action(async (type, actionOptions, command) => {
+    const result = await createClient(options).emit({
+      source: actionOptions.source ?? options.source,
+      type,
+      subject: actionOptions.subject,
+      severity: actionOptions.severity,
+      message: actionOptions.message,
+      dedupeKey: actionOptions.dedupeKey,
+      data: parseJsonObject(actionOptions.data, {}),
+      metadata: parseJsonObject(actionOptions.metadata, {})
+    }, { deliver: actionOptions.deliver, dedupe: actionOptions.dedupe });
+    print(result, wantsJson(actionOptions, command), `${result.deduped ? "Deduped" : "Emitted"} ${result.event.id} to ${result.deliveries.length} channel(s)`);
+  });
+  events.command("list").description("List recorded events").option("--source <source>", "Filter by source").option("--type <type>", "Filter by type").option("--limit <n>", "Limit results", parseNumber).option("-j, --json", "Print JSON output", false).action(async (actionOptions, command) => {
+    let rows = await createClient(options).listEvents();
+    if (actionOptions.source)
+      rows = rows.filter((event) => event.source === actionOptions.source);
+    if (actionOptions.type)
+      rows = rows.filter((event) => event.type === actionOptions.type);
+    if (actionOptions.limit)
+      rows = rows.slice(-actionOptions.limit);
+    if (wantsJson(actionOptions, command)) {
+      console.log(JSON.stringify(rows, null, 2));
+      return;
+    }
+    if (!rows.length) {
+      console.log("No events recorded.");
+      return;
+    }
+    for (const event of rows)
+      console.log(`${event.time}	${event.id}	${event.source}	${event.type}	${event.severity}`);
+  });
+  events.command("replay").description("Replay recorded events").option("--id <id>", "Replay one event id").option("--source <source>", "Filter by source").option("--type <type>", "Filter by type").option("--dry-run", "Preview without delivery", false).option("-j, --json", "Print JSON output", false).action(async (actionOptions, command) => {
+    const result = await createClient(options).replay({
+      eventId: actionOptions.id,
+      source: actionOptions.source,
+      type: actionOptions.type,
+      dryRun: actionOptions.dryRun
+    });
+    print(result, wantsJson(actionOptions, command), `Replayed ${result.events.length} event(s), ${result.deliveries.length} delivery result(s)`);
+  });
+  return events;
+}
+function registerEventsCommands(program, options) {
+  registerWebhookCommands(program, options);
+  registerEventCommands(program, options);
+}
+function parseNumber(value) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed))
+    throw new Error(`Expected a number, got ${value}`);
+  return parsed;
+}
+function collectValues(value, previous) {
+  previous.push(value);
+  return previous;
+}
+
 // node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
 var {
@@ -19752,7 +20418,7 @@ var {
 init_loader();
 
 // src/core/runner.ts
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 
 // src/core/assertions.ts
 var import_ajv = __toESM(require_ajv(), 1);
@@ -24356,7 +25022,7 @@ var safeJSON2 = (text) => {
 var sleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
 // node_modules/openai/version.mjs
-var VERSION2 = "6.39.0";
+var VERSION2 = "6.42.0";
 
 // node_modules/openai/internal/detect-platform.mjs
 var isRunningInBrowser2 = () => {
@@ -30942,7 +31608,10 @@ https://help.openai.com/en/articles/5112595-best-practices-for-api-key-safety
       if (isTimeout) {
         throw new APIConnectionTimeoutError2;
       }
-      throw new APIConnectionError2({ cause: response });
+      throw new APIConnectionError2({
+        message: getConnectionErrorMessage(response),
+        cause: response
+      });
     }
     const specialHeaders = [...response.headers.entries()].filter(([name]) => name === "x-request-id").map(([name, value]) => ", " + name + ": " + JSON.stringify(value)).join("");
     const responseInfo = `[${requestLogID}${retryLogStr}${specialHeaders}] ${req.method} ${url} ${response.ok ? "succeeded" : "failed"} with status ${response.status} in ${headersTime - startTime}ms`;
@@ -31215,6 +31884,23 @@ OpenAI.Evals = Evals;
 OpenAI.Containers = Containers;
 OpenAI.Skills = Skills2;
 OpenAI.Videos = Videos;
+function getConnectionErrorMessage(error3) {
+  if (isUndiciDispatcherVersionMismatchError(error3)) {
+    return `Connection error. This may be caused by passing an undici dispatcher, such as ProxyAgent, that is incompatible with the fetch implementation. If you are using undici's ProxyAgent, pass the fetch implementation from the same undici package: import { fetch, ProxyAgent } from 'undici'; new OpenAI({ fetch, fetchOptions: { dispatcher: new ProxyAgent(...) } });`;
+  }
+  return;
+}
+function isUndiciDispatcherVersionMismatchError(error3) {
+  let current = error3;
+  for (let i = 0;i < 8 && current && typeof current === "object"; i++) {
+    const err = current;
+    if (err.code === "UND_ERR_INVALID_ARG" && typeof err.message === "string" && err.message.includes("invalid onRequestStart method")) {
+      return true;
+    }
+    current = err.cause;
+  }
+  return false;
+}
 // node_modules/openai/azure.mjs
 var _deployments_endpoints = new Set([
   "/completions",
@@ -31228,14 +31914,14 @@ var _deployments_endpoints = new Set([
   "/images/edits"
 ]);
 // src/core/judge.ts
-import { existsSync, readFileSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
 function resolveKey(envVar, secretsRelPath, secretsKey) {
   if (process.env[envVar])
     return process.env[envVar];
-  const p = join(homedir(), ".secrets", secretsRelPath);
-  if (existsSync(p)) {
+  const p = join2(homedir2(), ".secrets", secretsRelPath);
+  if (existsSync2(p)) {
     for (const line of readFileSync(p, "utf8").split(`
 `)) {
       if (line.trim().startsWith(secretsKey + "=")) {
@@ -31754,7 +32440,7 @@ async function runEvals(cases, options) {
   }
   const stats = computeStats(results);
   return {
-    id: randomUUID(),
+    id: randomUUID3(),
     createdAt: new Date().toISOString(),
     dataset: options.dataset,
     adapterConfig: options.adapter,
@@ -32304,14 +32990,14 @@ function kappaLabel(k) {
 }
 
 // src/cli/commands/doctor.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join3 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join4 } from "path";
 function resolveApiKey(envVar, secretsPath, secretsKey) {
   if (process.env[envVar])
     return process.env[envVar];
-  const fullPath = join3(homedir3(), ".secrets", secretsPath);
-  if (existsSync2(fullPath)) {
+  const fullPath = join4(homedir4(), ".secrets", secretsPath);
+  if (existsSync3(fullPath)) {
     try {
       const content = readFileSync2(fullPath, "utf8");
       for (const line of content.split(`
@@ -32356,17 +33042,17 @@ function doctorCommand() {
     }
     try {
       const { loadDataset: loadDataset2 } = await Promise.resolve().then(() => (init_loader(), exports_loader));
-      const { existsSync: existsSync3 } = await import("fs");
-      const { join: join4 } = await import("path");
-      const { homedir: homedir4 } = await import("os");
+      const { existsSync: existsSync4 } = await import("fs");
+      const { join: join5 } = await import("path");
+      const { homedir: homedir5 } = await import("os");
       const candidates = [
         new URL("../../../datasets/examples/smoke.jsonl", import.meta.url).pathname,
-        join4(import.meta.dir, "../../../datasets/examples/smoke.jsonl"),
-        join4(import.meta.dir, "../../datasets/examples/smoke.jsonl"),
-        join4(import.meta.dir, "../datasets/examples/smoke.jsonl"),
-        join4(homedir4(), ".hasna", "evals", "examples", "smoke.jsonl")
+        join5(import.meta.dir, "../../../datasets/examples/smoke.jsonl"),
+        join5(import.meta.dir, "../../datasets/examples/smoke.jsonl"),
+        join5(import.meta.dir, "../datasets/examples/smoke.jsonl"),
+        join5(homedir5(), ".hasna", "evals", "examples", "smoke.jsonl")
       ];
-      const found = candidates.find((p) => existsSync3(p));
+      const found = candidates.find((p) => existsSync4(p));
       if (!found)
         throw new Error("not found");
       const { cases } = await loadDataset2(found);
@@ -32401,9 +33087,9 @@ function doctorCommand() {
 }
 
 // src/cli/commands/mcp.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, existsSync as existsSync3 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join4 } from "path";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, existsSync as existsSync4 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join5 } from "path";
 function mcpCommand() {
   const cmd = new Command("mcp").description("MCP server management");
   cmd.addCommand(new Command("register").description("Register evals-mcp with an agent (Claude Code, Codex, Gemini)").option("--claude", "Register with Claude Code (~/.claude/mcp.json)").option("--codex", "Register with Codex (~/.codex/config.json)").option("--gemini", "Register with Gemini (~/.gemini/settings.json)").option("--all", "Register with all agents").action((opts) => {
@@ -32419,15 +33105,15 @@ function mcpCommand() {
   }));
   cmd.addCommand(new Command("start").description("Start MCP server (stdio)").action(() => {
     const { spawnSync } = __require("child_process");
-    spawnSync(process.execPath, [join4(import.meta.dir, "../../mcp/index.js")], { stdio: "inherit" });
+    spawnSync(process.execPath, [join5(import.meta.dir, "../../mcp/index.js")], { stdio: "inherit" });
   }));
   return cmd;
 }
 var ENTRY = { command: "/home/hasna/.bun/bin/evals-mcp", args: [] };
 function registerClaude() {
-  const mcpPath = join4(homedir4(), ".claude", "mcp.json");
+  const mcpPath = join5(homedir5(), ".claude", "mcp.json");
   let config = {};
-  if (existsSync3(mcpPath)) {
+  if (existsSync4(mcpPath)) {
     config = JSON.parse(readFileSync3(mcpPath, "utf8"));
   }
   config.mcpServers = { ...config.mcpServers ?? {}, evals: ENTRY };
@@ -32437,9 +33123,9 @@ function registerClaude() {
   console.log("  Restart Claude Code to load the new MCP server.");
 }
 function registerCodex() {
-  const cfgPath = join4(homedir4(), ".codex", "config.json");
+  const cfgPath = join5(homedir5(), ".codex", "config.json");
   let config = {};
-  if (existsSync3(cfgPath)) {
+  if (existsSync4(cfgPath)) {
     config = JSON.parse(readFileSync3(cfgPath, "utf8"));
   }
   config.mcpServers = { ...config.mcpServers ?? {}, evals: { type: "stdio", ...ENTRY, env: {} } };
@@ -32448,9 +33134,9 @@ function registerCodex() {
   console.log("\x1B[32m\u2713 Registered evals-mcp in ~/.codex/config.json\x1B[0m");
 }
 function registerGemini() {
-  const cfgPath = join4(homedir4(), ".gemini", "settings.json");
+  const cfgPath = join5(homedir5(), ".gemini", "settings.json");
   let config = {};
-  if (existsSync3(cfgPath)) {
+  if (existsSync4(cfgPath)) {
     config = JSON.parse(readFileSync3(cfgPath, "utf8"));
   }
   config.mcpServers = { ...config.mcpServers ?? {}, evals: ENTRY };
@@ -32703,4 +33389,5 @@ program2.addCommand(mcpCommand());
 program2.addCommand(captureCommand());
 program2.addCommand(completionCommand());
 program2.addCommand(syncCommand());
+registerEventsCommands(program2, { source: "evals" });
 program2.parse(process.argv);