@hasna/connectors 1.3.33 → 1.3.35

package/bin/index.js

@@ -879,7 +879,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         this._exitCallback = (err) => {
           if (err.code !== "commander.executeSubCommandAsync") {
             throw err;
-          } else {}
+          }
         };
       }
       return this;
@@ -1909,7 +1909,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/connectors",
-    version: "1.3.32",
+    version: "1.3.35",
     description: "Open source connector library - Install API connectors with a single command",
     type: "module",
     bin: {
@@ -1964,7 +1964,8 @@ var init_package = __esm(() => {
       typescript: "^5"
     },
     dependencies: {
-      "@hasna/cloud": "^0.1.24",
+      "@hasna/cloud": "0.1.24",
+      "@hasna/events": "^0.1.3",
       "@modelcontextprotocol/sdk": "^1.26.0",
       chalk: "^5.3.0",
       commander: "^12.1.0",
@@ -6085,28 +6086,28 @@ var init_zod = __esm(() => {
 
 // src/core/connectors/github.ts
 import { Buffer as Buffer2 } from "buffer";
-import { existsSync } from "fs";
-import { dirname, join } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { dirname, join as join2 } from "path";
 import { fileURLToPath, pathToFileURL } from "url";
 function resolveGithubConnectorDir() {
   const candidates = [
-    join(__dirname2, "..", "..", "..", "connectors", "github"),
-    join(__dirname2, "..", "..", "connectors", "github"),
-    join(__dirname2, "..", "connectors", "github"),
-    join(process.cwd(), "connectors", "github")
+    join2(__dirname2, "..", "..", "..", "connectors", "github"),
+    join2(__dirname2, "..", "..", "connectors", "github"),
+    join2(__dirname2, "..", "connectors", "github"),
+    join2(process.cwd(), "connectors", "github")
   ];
   for (const candidate of candidates) {
-    if (existsSync(candidate)) {
+    if (existsSync2(candidate)) {
       return candidate;
     }
   }
   return candidates[0];
 }
 async function loadGitHubApiModule() {
-  return await import(pathToFileURL(join(CONNECTOR_DIR, "src", "api", "index.ts")).href);
+  return await import(pathToFileURL(join2(CONNECTOR_DIR, "src", "api", "index.ts")).href);
 }
 async function loadGitHubConfigModule() {
-  return await import(pathToFileURL(join(CONNECTOR_DIR, "src", "utils", "config.ts")).href);
+  return await import(pathToFileURL(join2(CONNECTOR_DIR, "src", "utils", "config.ts")).href);
 }
 function extractGlobalArgs(args) {
   const remaining = [];
@@ -6950,9 +6951,9 @@ Commands:
 });
 
 // src/core/connectors/gmail.ts
-import { existsSync as existsSync2, mkdirSync, readFileSync, readdirSync, writeFileSync } from "fs";
-import { homedir } from "os";
-import { basename, join as join2 } from "path";
+import { existsSync as existsSync3, mkdirSync, readFileSync, readdirSync, writeFileSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { basename, join as join3 } from "path";
 async function modifyMessage(profile, messageId, addLabelIds, removeLabelIds) {
   return requestJson(profile, `/users/me/messages/${encodeURIComponent(messageId)}/modify`, {}, {
     method: "POST",
@@ -6989,7 +6990,7 @@ async function replyToMessage(profile, messageId, input) {
 }
 async function downloadAttachments(profile, input) {
   const messageId = getMessageId(input);
-  const outputDir = input.dir ?? input.outputDir ?? join2(configDirs()[0], "attachments", messageId);
+  const outputDir = input.dir ?? input.outputDir ?? join3(configDirs()[0], "attachments", messageId);
   mkdirSync(outputDir, { recursive: true });
   const attachments = input.attachmentId && input.filename ? [{
     attachmentId: input.attachmentId,
@@ -7001,7 +7002,7 @@ async function downloadAttachments(profile, input) {
   for (const attachment of attachments) {
     const data = await requestJson(profile, `/users/me/messages/${encodeURIComponent(messageId)}/attachments/${encodeURIComponent(attachment.attachmentId)}`, {});
     const filename = safeFilename(attachment.filename);
-    const path = join2(outputDir, filename);
+    const path = join3(outputDir, filename);
     const buffer = Buffer.from(data.data, "base64url");
     writeFileSync(path, buffer);
     downloaded.push({
@@ -7118,8 +7119,8 @@ async function refreshAccessToken(profile, currentTokens) {
 function listProfiles() {
   const profiles = new Set;
   for (const baseDir of configDirs()) {
-    const profilesDir = join2(baseDir, "profiles");
-    if (!existsSync2(profilesDir))
+    const profilesDir = join3(baseDir, "profiles");
+    if (!existsSync3(profilesDir))
       continue;
     for (const entry of readdirSync(profilesDir, { withFileTypes: true })) {
       if (entry.isDirectory())
@@ -7137,8 +7138,8 @@ function loadCredentials(profile) {
     return { clientId: envClientId, clientSecret: envClientSecret };
   for (const baseDir of configDirs()) {
     const credentials = {
-      ...readJson(join2(baseDir, "credentials.json")),
-      ...readJson(join2(baseDir, "profiles", profile, "config.json"))
+      ...readJson(join3(baseDir, "credentials.json")),
+      ...readJson(join3(baseDir, "profiles", profile, "config.json"))
     };
     if (credentials.clientId || credentials.clientSecret)
       return credentials;
@@ -7147,30 +7148,30 @@ function loadCredentials(profile) {
 }
 function loadTokens(profile) {
   for (const baseDir of configDirs()) {
-    const fromProfile = readJson(join2(baseDir, "profiles", profile, "tokens.json"));
+    const fromProfile = readJson(join3(baseDir, "profiles", profile, "tokens.json"));
     if (fromProfile)
       return fromProfile;
-    const flat = readJson(join2(baseDir, "profiles", `${profile}.json`));
+    const flat = readJson(join3(baseDir, "profiles", `${profile}.json`));
     if (flat)
       return flat.tokens ?? (flat.accessToken || flat.refreshToken ? flat : null);
   }
   return null;
 }
 function saveTokens(profile, tokens) {
-  const baseDir = configDirs().find((dir) => existsSync2(dir)) ?? configDirs()[0];
-  const profileDir = join2(baseDir, "profiles", profile);
+  const baseDir = configDirs().find((dir) => existsSync3(dir)) ?? configDirs()[0];
+  const profileDir = join3(baseDir, "profiles", profile);
   mkdirSync(profileDir, { recursive: true });
-  writeFileSync(join2(profileDir, "tokens.json"), JSON.stringify(tokens, null, 2), { mode: 384 });
+  writeFileSync(join3(profileDir, "tokens.json"), JSON.stringify(tokens, null, 2), { mode: 384 });
 }
 function configDirs() {
   const explicit = process.env.HASNA_GMAIL_CONNECTOR_DIR ?? process.env.GMAIL_CONNECTOR_DIR;
   if (explicit)
     return [explicit];
-  const baseDir = process.env.HASNA_CONNECTORS_DIR ?? join2(homedir(), ".hasna", "connectors");
-  return [join2(baseDir, "gmail"), join2(baseDir, "connect-gmail")];
+  const baseDir = process.env.HASNA_CONNECTORS_DIR ?? join3(homedir2(), ".hasna", "connectors");
+  return [join3(baseDir, "gmail"), join3(baseDir, "connect-gmail")];
 }
 function readJson(path) {
-  if (!existsSync2(path))
+  if (!existsSync3(path))
     return null;
   try {
     return JSON.parse(readFileSync(path, "utf8"));
@@ -7420,9 +7421,9 @@ var init_gmail = __esm(() => {
 });
 
 // src/core/connectors/googledrive.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, readdirSync as readdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import { homedir as homedir2 } from "os";
-import { basename as basename2, join as join3 } from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync2, readdirSync as readdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { basename as basename2, join as join4 } from "path";
 async function requestJson2(profile, path, params) {
   const response = await request(profile, path, params);
   const text = await response.text();
@@ -7490,8 +7491,8 @@ async function refreshAccessToken2(profile, currentTokens) {
 function listProfiles2() {
   const profiles = new Set;
   for (const baseDir of configDirs2()) {
-    const profilesDir = join3(baseDir, "profiles");
-    if (!existsSync3(profilesDir))
+    const profilesDir = join4(baseDir, "profiles");
+    if (!existsSync4(profilesDir))
       continue;
     for (const entry of readdirSync2(profilesDir, { withFileTypes: true })) {
       if (entry.isDirectory())
@@ -7505,7 +7506,7 @@ function listProfiles2() {
 function listProfileStatuses(profile) {
   const profiles = profile ? [profile] : listProfiles2();
   const uniqueProfiles = profiles.length ? profiles : ["default"];
-  const now = Date.now();
+  const now2 = Date.now();
   return uniqueProfiles.map((name) => {
     const tokens = loadTokens2(name);
     const credentials = loadCredentials2(name);
@@ -7513,7 +7514,7 @@ function listProfileStatuses(profile) {
     const hasRefreshToken = Boolean(tokens?.refreshToken);
     const hasOAuthCredentials = Boolean(credentials.clientId && credentials.clientSecret);
     const expiresAt = tokens?.expiresAt ?? null;
-    const expired = Boolean(expiresAt && now >= expiresAt - REFRESH_BUFFER_MS2);
+    const expired = Boolean(expiresAt && now2 >= expiresAt - REFRESH_BUFFER_MS2);
     const authenticated = Boolean(process.env.GOOGLE_ACCESS_TOKEN || hasRefreshToken || hasAccessToken && !expired);
     const configured = authenticated || hasOAuthCredentials;
     const authRequired = !authenticated || expired && !hasRefreshToken;
@@ -7538,8 +7539,8 @@ function loadCredentials2(profile) {
     return { clientId: envClientId, clientSecret: envClientSecret };
   for (const baseDir of configDirs2()) {
     const credentials = {
-      ...readJson2(join3(baseDir, "credentials.json")),
-      ...readJson2(join3(baseDir, "profiles", profile, "config.json"))
+      ...readJson2(join4(baseDir, "credentials.json")),
+      ...readJson2(join4(baseDir, "profiles", profile, "config.json"))
     };
     if (credentials.clientId || credentials.clientSecret)
       return credentials;
@@ -7548,30 +7549,30 @@ function loadCredentials2(profile) {
 }
 function loadTokens2(profile) {
   for (const baseDir of configDirs2()) {
-    const fromProfile = readJson2(join3(baseDir, "profiles", profile, "tokens.json"));
+    const fromProfile = readJson2(join4(baseDir, "profiles", profile, "tokens.json"));
     if (fromProfile)
       return fromProfile;
-    const flat = readJson2(join3(baseDir, "profiles", `${profile}.json`));
+    const flat = readJson2(join4(baseDir, "profiles", `${profile}.json`));
     if (flat)
       return flat.tokens ?? (flat.accessToken || flat.refreshToken ? flat : null);
   }
   return null;
 }
 function saveTokens2(profile, tokens) {
-  const baseDir = configDirs2().find((dir) => existsSync3(dir)) ?? configDirs2()[0];
-  const profileDir = join3(baseDir, "profiles", profile);
+  const baseDir = configDirs2().find((dir) => existsSync4(dir)) ?? configDirs2()[0];
+  const profileDir = join4(baseDir, "profiles", profile);
   mkdirSync2(profileDir, { recursive: true });
-  writeFileSync2(join3(profileDir, "tokens.json"), JSON.stringify(tokens, null, 2), { mode: 384 });
+  writeFileSync2(join4(profileDir, "tokens.json"), JSON.stringify(tokens, null, 2), { mode: 384 });
 }
 function configDirs2() {
   const explicit = process.env.HASNA_GOOGLE_DRIVE_CONNECTOR_DIR ?? process.env.GOOGLE_DRIVE_CONNECTOR_DIR;
   if (explicit)
     return [explicit];
-  const baseDir = process.env.HASNA_CONNECTORS_DIR ?? join3(homedir2(), ".hasna", "connectors");
-  return [join3(baseDir, "googledrive"), join3(baseDir, "connect-googledrive")];
+  const baseDir = process.env.HASNA_CONNECTORS_DIR ?? join4(homedir3(), ".hasna", "connectors");
+  return [join4(baseDir, "googledrive"), join4(baseDir, "connect-googledrive")];
 }
 function readJson2(path) {
-  if (!existsSync3(path))
+  if (!existsSync4(path))
     return null;
   try {
     return JSON.parse(readFileSync2(path, "utf8"));
@@ -7805,8 +7806,8 @@ __export(exports_dist, {
   ensureConflictsTable: () => ensureConflictsTable,
   ensureAllPgDatabases: () => ensureAllPgDatabases,
   enableAutoSync: () => enableAutoSync,
-  discoverSyncableServicesV2: () => discoverSyncableServices,
-  discoverSyncableServices: () => discoverSyncableServices2,
+  discoverSyncableServicesV2: () => discoverSyncableServices2,
+  discoverSyncableServices: () => discoverSyncableServices,
   discoverServices: () => discoverServices,
   detectConflicts: () => detectConflicts,
   createDatabase: () => createDatabase,
@@ -7822,28 +7823,28 @@ __export(exports_dist, {
 import { createRequire } from "module";
 import { Database } from "bun:sqlite";
 import {
-  existsSync as existsSync4,
+  existsSync as existsSync5,
   mkdirSync as mkdirSync3,
   readdirSync as readdirSync3,
   copyFileSync
 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join4, relative } from "path";
+import { homedir as homedir4 } from "os";
+import { join as join5, relative } from "path";
 import { existsSync as existsSync22, mkdirSync as mkdirSync22, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
 import { homedir as homedir22 } from "os";
 import { join as join22 } from "path";
-import { readdirSync as readdirSync22, existsSync as existsSync32 } from "fs";
-import { join as join32 } from "path";
-import { homedir as homedir32 } from "os";
+import { readdirSync as readdirSync32, existsSync as existsSync6 } from "fs";
+import { join as join6 } from "path";
+import { homedir as homedir5 } from "os";
 import { hostname } from "os";
-import { existsSync as existsSync42, readFileSync as readFileSync22 } from "fs";
-import { homedir as homedir4 } 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 readdirSync22 } from "fs";
 import { join as join42 } from "path";
-import { existsSync as existsSync5, readdirSync as readdirSync32 } from "fs";
-import { join as join5 } from "path";
-import { join as join6, dirname as dirname2 } from "path";
-import { existsSync as existsSync6, writeFileSync as writeFileSync22, unlinkSync, mkdirSync as mkdirSync32 } from "fs";
-import { homedir as homedir5, platform } from "os";
+import { join as join52, dirname as dirname2 } from "path";
+import { existsSync as existsSync52, writeFileSync as writeFileSync22, unlinkSync, mkdirSync as mkdirSync32 } from "fs";
+import { homedir as homedir42, platform } from "os";
 function __accessProp2(key) {
   return this[key];
 }
@@ -8725,20 +8726,20 @@ function custom2(check, _params = {}, fatal) {
   return ZodAny2.create();
 }
 function getDataDir(serviceName) {
-  const dir = join4(HASNA_DIR, serviceName);
+  const dir = join5(HASNA_DIR, serviceName);
   mkdirSync3(dir, { recursive: true });
   return dir;
 }
 function getDbPath(serviceName) {
   const dir = getDataDir(serviceName);
-  return join4(dir, `${serviceName}.db`);
+  return join5(dir, `${serviceName}.db`);
 }
 function migrateDotfile(serviceName) {
-  const legacyDir = join4(homedir3(), `.${serviceName}`);
-  const newDir = join4(HASNA_DIR, serviceName);
-  if (!existsSync4(legacyDir))
+  const legacyDir = join5(homedir4(), `.${serviceName}`);
+  const newDir = join5(HASNA_DIR, serviceName);
+  if (!existsSync5(legacyDir))
     return [];
-  if (existsSync4(newDir))
+  if (existsSync5(newDir))
     return [];
   mkdirSync3(newDir, { recursive: true });
   const migrated = [];
@@ -8748,8 +8749,8 @@ function migrateDotfile(serviceName) {
 function copyDirRecursive(src, dest, root, migrated) {
   const entries = readdirSync3(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = join4(src, entry.name);
-    const destPath = join4(dest, entry.name);
+    const srcPath = join5(src, entry.name);
+    const destPath = join5(dest, entry.name);
     if (entry.isDirectory()) {
       mkdirSync3(destPath, { recursive: true });
       copyDirRecursive(srcPath, destPath, root, migrated);
@@ -8760,7 +8761,7 @@ function copyDirRecursive(src, dest, root, migrated) {
   }
 }
 function hasLegacyDotfile(serviceName) {
-  return existsSync4(join4(homedir3(), `.${serviceName}`));
+  return existsSync5(join5(homedir4(), `.${serviceName}`));
 }
 function getHasnaDir() {
   mkdirSync3(HASNA_DIR, { recursive: true });
@@ -8815,11 +8816,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 = join6(homedir5(), ".hasna");
+  if (!existsSync6(dataDir))
     return [];
   try {
-    const entries = readdirSync22(dataDir, { withFileTypes: true });
+    const entries = readdirSync32(dataDir, { withFileTypes: true });
     return entries.filter((e) => {
       if (!e.isDirectory())
         return false;
@@ -8831,30 +8832,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 = join6(homedir5(), ".hasna", service);
+  if (!existsSync6(dataDir))
     return null;
   const candidates = [
-    join32(dataDir, `${service}.db`),
-    join32(dataDir, "data.db"),
-    join32(dataDir, "database.db")
+    join6(dataDir, `${service}.db`),
+    join6(dataDir, "data.db"),
+    join6(dataDir, "database.db")
   ];
   try {
-    const files = readdirSync22(dataDir);
+    const files = readdirSync32(dataDir);
     for (const f of files) {
       if (f.endsWith(".db") && !f.endsWith("-wal") && !f.endsWith("-shm")) {
-        candidates.push(join32(dataDir, f));
+        candidates.push(join6(dataDir, f));
       }
     }
   } catch {}
   for (const p of candidates) {
-    if (existsSync32(p))
+    if (existsSync6(p))
       return p;
   }
   return null;
@@ -9161,9 +9162,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) {
@@ -9210,7 +9211,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(", ");
@@ -9220,22 +9221,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);
 }
@@ -9294,17 +9293,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,
@@ -9312,7 +9311,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, {
@@ -9368,8 +9367,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,
@@ -9691,10 +9690,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"
       });
@@ -9744,10 +9743,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"
       });
@@ -9775,7 +9774,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"));
@@ -9787,7 +9786,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,
@@ -9797,31 +9796,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;
 }
@@ -9829,76 +9815,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 = readdirSync32(hasnaDir, { withFileTypes: true });
+    const entries = readdirSync22(hasnaDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const dbPath = join5(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);
       }
     }
@@ -9909,7 +9899,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) {
@@ -9920,8 +9910,8 @@ async function runScheduledSync() {
       errors: []
     };
     try {
-      const dbPath = join5(getDataDir(service), `${service}.db`);
-      if (!existsSync5(dbPath)) {
+      const dbPath = join42(getDataDir(service), `${service}.db`);
+      if (!existsSync42(dbPath)) {
         continue;
       }
       const local = new SqliteAdapter(dbPath);
@@ -10002,34 +9992,34 @@ function minutesToCron(minutes) {
 }
 function getWorkerPath() {
   const dir = typeof import.meta.dir === "string" ? import.meta.dir : dirname2(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(homedir5(), ".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(homedir5(), "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">
@@ -10055,7 +10045,7 @@ function createLaunchdPlist(intervalMinutes) {
     <key>PATH</key>
     <string>${process.env.PATH || "/usr/local/bin:/usr/bin:/bin"}</string>
     <key>HOME</key>
-    <string>${homedir5()}</string>
+    <string>${homedir42()}</string>
   </dict>
 </dict>
 </plist>`;
@@ -10080,7 +10070,7 @@ async function removeLaunchd() {
   } catch {}
 }
 function getSystemdDir() {
-  return join6(homedir5(), ".config", "systemd", "user");
+  return join52(homedir42(), ".config", "systemd", "user");
 }
 function createSystemdService() {
   const workerPath = getWorkerPath();
@@ -10092,7 +10082,7 @@ After=network.target
 [Service]
 Type=oneshot
 ExecStart=${bunPath} run ${workerPath}
-Environment=HOME=${homedir5()}
+Environment=HOME=${homedir42()}
 Environment=PATH=${process.env.PATH || "/usr/local/bin:/usr/bin:/bin"}
 
 [Install]
@@ -10115,8 +10105,8 @@ WantedBy=timers.target
 async function registerSystemd(intervalMinutes) {
   const dir = getSystemdDir();
   mkdirSync32(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;
 }
@@ -10126,10 +10116,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;
@@ -10166,9 +10156,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 {
@@ -10305,7 +10295,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 = [
@@ -10338,13 +10328,8 @@ function registerCloudTools(server, serviceName, opts = {}) {
         isError: true
       };
     }
-    const local = new SqliteAdapter(opts.dbPath ?? getDbPath(serviceName));
+    const local = new SqliteAdapter(getDbPath(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();
@@ -10366,7 +10351,7 @@ function registerCloudTools(server, serviceName, opts = {}) {
         isError: true
       };
     }
-    const local = new SqliteAdapter(opts.dbPath ?? getDbPath(serviceName));
+    const local = new SqliteAdapter(getDbPath(serviceName));
     const cloud = new PgAdapterAsync(getConnectionString(serviceName));
     let tableList;
     if (tablesStr) {
@@ -18718,7 +18703,7 @@ See https://www.postgresql.org/docs/current/libpq-ssl.html for libpq SSL mode de
     init_external2();
   });
   init_dotfile = __esm2(() => {
-    HASNA_DIR = join4(homedir3(), ".hasna");
+    HASNA_DIR = join5(homedir4(), ".hasna");
   });
   exports_config = {};
   __export2(exports_config, {
@@ -18756,7 +18741,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
@@ -18811,10 +18796,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(homedir4(), ".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
@@ -18824,7 +18807,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(homedir5(), ".hasna", "cloud");
+  CONFIG_DIR2 = join52(homedir42(), ".hasna", "cloud");
   init_adapter();
   init_config();
   init_discover();
@@ -18841,7 +18824,7 @@ See https://www.postgresql.org/docs/current/libpq-ssl.html for libpq SSL mode de
 var exports_database = {};
 __export(exports_database, {
   shortUuid: () => shortUuid,
-  now: () => now,
+  now: () => now2,
   getDatabase: () => getDatabase,
   getConnectorsHome: () => getConnectorsHome,
   closeDatabase: () => closeDatabase
@@ -18904,7 +18887,7 @@ function closeDatabase() {
   _db = null;
   _dbPath = null;
 }
-function now() {
+function now2() {
   return new Date().toISOString();
 }
 function shortUuid() {
@@ -29883,7 +29866,7 @@ __export(exports_promotions, {
 });
 function promoteConnector(name, db) {
   const d = db ?? getDatabase();
-  d.run("INSERT OR REPLACE INTO connector_promotions (connector, promoted_at) VALUES (?, ?)", [name, now()]);
+  d.run("INSERT OR REPLACE INTO connector_promotions (connector, promoted_at) VALUES (?, ?)", [name, now2()]);
 }
 function demoteConnector(name, db) {
   const d = db ?? getDatabase();
@@ -29913,7 +29896,7 @@ __export(exports_usage, {
 });
 function logUsage(connector, action, agentId, db) {
   const d = db ?? getDatabase();
-  d.run("INSERT INTO connector_usage (id, connector, action, agent_id, timestamp) VALUES (?, ?, ?, ?, ?)", [shortUuid(), connector, action, agentId ?? null, now()]);
+  d.run("INSERT INTO connector_usage (id, connector, action, agent_id, timestamp) VALUES (?, ?, ?, ?, ?)", [shortUuid(), connector, action, agentId ?? null, now2()]);
 }
 function getUsageStats(connector, db) {
   const d = db ?? getDatabase();
@@ -29971,7 +29954,7 @@ function registerAgent(input, db) {
       };
     }
     const updates = ["last_seen_at = ?"];
-    const params = [now()];
+    const params = [now2()];
     if (input.session_id && !sameSession) {
       updates.push("session_id = ?");
       params.push(input.session_id);
@@ -29981,7 +29964,7 @@ function registerAgent(input, db) {
     return getAgent(existing.id, d);
   }
   const id = shortUuid2();
-  const ts = now();
+  const ts = now2();
   d.run(`INSERT INTO agents (id, name, session_id, role, last_seen_at, created_at)
      VALUES (?, ?, ?, ?, ?, ?)`, [id, normalizedName, input.session_id ?? null, input.role ?? "agent", ts, ts]);
   return getAgent(id, d);
@@ -30000,12 +29983,12 @@ function listAgents(db) {
 }
 function heartbeat(id, db) {
   const d = db ?? getDatabase();
-  d.run("UPDATE agents SET last_seen_at = ? WHERE id = ?", [now(), id]);
+  d.run("UPDATE agents SET last_seen_at = ? WHERE id = ?", [now2(), id]);
   return getAgent(id, d);
 }
 function setFocus(id, projectId, db) {
   const d = db ?? getDatabase();
-  d.run("UPDATE agents SET project_id = ?, last_seen_at = ? WHERE id = ?", [projectId, now(), id]);
+  d.run("UPDATE agents SET project_id = ?, last_seen_at = ? WHERE id = ?", [projectId, now2(), id]);
   return getAgent(id, d);
 }
 function deleteAgent(id, db) {
@@ -30037,9 +30020,9 @@ function countActiveAgents(db) {
   return Math.max(1, row?.count ?? 1);
 }
 function currentWindowStart() {
-  const now3 = Date.now();
+  const now4 = Date.now();
   const windowMs = WINDOW_SECONDS * 1000;
-  return new Date(Math.floor(now3 / windowMs) * windowMs).toISOString();
+  return new Date(Math.floor(now4 / windowMs) * windowMs).toISOString();
 }
 function checkRateBudget(agentId, connector, connectorLimit, consume = true, db) {
   const d = db ?? getDatabase();
@@ -30269,7 +30252,7 @@ function rowToJob(row) {
 function createJob(input, db) {
   const d = db ?? getDatabase();
   const id = shortUuid();
-  const ts = now();
+  const ts = now2();
   d.run("INSERT INTO connector_jobs (id, name, connector, command, args, cron, enabled, strip, created_at) VALUES (?, ?, ?, ?, ?, ?, 1, ?, ?)", [id, input.name, input.connector, input.command, JSON.stringify(input.args ?? []), input.cron, input.strip ? 1 : 0, ts]);
   return getJob(id, d);
 }
@@ -30335,18 +30318,18 @@ function deleteJob(id, db) {
 }
 function touchJobLastRun(id, db) {
   const d = db ?? getDatabase();
-  d.run("UPDATE connector_jobs SET last_run_at = ? WHERE id = ?", [now(), id]);
+  d.run("UPDATE connector_jobs SET last_run_at = ? WHERE id = ?", [now2(), id]);
 }
 function createJobRun(jobId, db) {
   const d = db ?? getDatabase();
   const id = shortUuid();
-  const ts = now();
+  const ts = now2();
   d.run("INSERT INTO connector_job_runs (id, job_id, started_at) VALUES (?, ?, ?)", [id, jobId, ts]);
   return { id, job_id: jobId, started_at: ts, finished_at: null, exit_code: null, raw_output: null, stripped_output: null };
 }
 function finishJobRun(id, result, db) {
   const d = db ?? getDatabase();
-  d.run("UPDATE connector_job_runs SET finished_at = ?, exit_code = ?, raw_output = ?, stripped_output = ? WHERE id = ?", [now(), result.exit_code, result.raw_output, result.stripped_output ?? null, id]);
+  d.run("UPDATE connector_job_runs SET finished_at = ?, exit_code = ?, raw_output = ?, stripped_output = ? WHERE id = ?", [now2(), result.exit_code, result.raw_output, result.stripped_output ?? null, id]);
 }
 function getLatestRun(jobId, db) {
   const d = db ?? getDatabase();
@@ -30371,7 +30354,7 @@ function rowToWorkflow(row) {
 function createWorkflow(input, db) {
   const d = db ?? getDatabase();
   const id = shortUuid();
-  d.run("INSERT INTO connector_workflows (id, name, steps, enabled, created_at) VALUES (?, ?, ?, 1, ?)", [id, input.name, JSON.stringify(input.steps), now()]);
+  d.run("INSERT INTO connector_workflows (id, name, steps, enabled, created_at) VALUES (?, ?, ?, 1, ?)", [id, input.name, JSON.stringify(input.steps), now2()]);
   return getWorkflow(id, d);
 }
 function getWorkflow(id, db) {
@@ -30404,7 +30387,7 @@ __export(exports_scheduler, {
   startScheduler: () => startScheduler,
   cronMatches: () => cronMatches
 });
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 function cronMatches(cron, d) {
   const parts = cron.trim().split(/\s+/);
   if (parts.length !== 5)
@@ -30431,7 +30414,7 @@ function cronMatches(cron, d) {
 async function runConnectorCommand(connector, command, args) {
   return new Promise((resolve) => {
     const cmdArgs = [connector, command, ...args, "--format", "json"];
-    const proc = spawn("connectors", ["run", ...cmdArgs], { shell: false });
+    const proc = spawn2("connectors", ["run", ...cmdArgs], { shell: false });
     let output = "";
     proc.stdout.on("data", (d) => {
       output += d.toString();
@@ -30468,14 +30451,14 @@ function startScheduler(db) {
   _interval = setInterval(() => {
     (async () => {
       try {
-        const now3 = new Date;
-        const currentMinute = now3.getMinutes() + now3.getHours() * 60;
+        const now4 = new Date;
+        const currentMinute = now4.getMinutes() + now4.getHours() * 60;
         if (currentMinute === _lastCheckedMinute)
           return;
         _lastCheckedMinute = currentMinute;
         const jobs = listEnabledJobs(db);
         for (const job of jobs) {
-          if (cronMatches(job.cron, now3)) {
+          if (cronMatches(job.cron, now4)) {
             executeJob(job, db).catch(() => {});
           }
         }
@@ -30580,7 +30563,7 @@ __export(exports_runner, {
 import { existsSync as existsSync17, readdirSync as readdirSync10 } from "fs";
 import { join as join17, dirname as dirname7 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 function resolveConnectorsDir2() {
   const fromBin = join17(__dirname5, "..", "connectors");
   if (existsSync17(fromBin))
@@ -30850,7 +30833,7 @@ function runLegacyConnectorCommand(name, args, timeoutMs = 30000) {
     });
   }
   return new Promise((resolve) => {
-    const proc = spawn2("bun", ["run", cliPath, ...args], {
+    const proc = spawn3("bun", ["run", cliPath, ...args], {
       timeout: timeoutMs,
       env: buildEnvWithCredentials(connectorName, process.env),
       stdio: ["pipe", "pipe", "pipe"]
@@ -34413,7 +34396,7 @@ class JSONSchemaGenerator {
               if (val === undefined) {
                 if (this.unrepresentable === "throw") {
                   throw new Error("Literal `undefined` cannot be represented in JSON Schema");
-                } else {}
+                }
               } else if (typeof val === "bigint") {
                 if (this.unrepresentable === "throw") {
                   throw new Error("BigInt literals cannot be represented in JSON Schema");
@@ -35645,7 +35628,7 @@ var init_types3 = __esm(() => {
   ProgressTokenSchema = union([string2(), number2().int()]);
   CursorSchema = string2();
   TaskCreationParamsSchema = looseObject({
-    ttl: union([number2(), _null3()]).optional(),
+    ttl: number2().optional(),
     pollInterval: number2().optional()
   });
   TaskMetadataSchema = object({
@@ -35793,7 +35776,8 @@ var init_types3 = __esm(() => {
     roots: object({
       listChanged: boolean2().optional()
     }).optional(),
-    tasks: ClientTasksCapabilitySchema.optional()
+    tasks: ClientTasksCapabilitySchema.optional(),
+    extensions: record(string2(), AssertObjectSchema).optional()
   });
   InitializeRequestParamsSchema = BaseRequestParamsSchema.extend({
     protocolVersion: string2(),
@@ -35818,7 +35802,8 @@ var init_types3 = __esm(() => {
     tools: object({
       listChanged: boolean2().optional()
     }).optional(),
-    tasks: ServerTasksCapabilitySchema.optional()
+    tasks: ServerTasksCapabilitySchema.optional(),
+    extensions: record(string2(), AssertObjectSchema).optional()
   });
   InitializeResultSchema = ResultSchema.extend({
     protocolVersion: string2(),
@@ -35933,6 +35918,7 @@ var init_types3 = __esm(() => {
     uri: string2(),
     description: optional(string2()),
     mimeType: optional(string2()),
+    size: optional(number2()),
     annotations: AnnotationsSchema.optional(),
     _meta: optional(looseObject({}))
   });
@@ -36571,6 +36557,7 @@ data:
   async handleGetRequest(req) {
     const acceptHeader = req.headers.get("accept");
     if (!acceptHeader?.includes("text/event-stream")) {
+      this.onerror?.(new Error("Not Acceptable: Client must accept text/event-stream"));
       return this.createJsonErrorResponse(406, -32000, "Not Acceptable: Client must accept text/event-stream");
     }
     const sessionError = this.validateSession(req);
@@ -36588,6 +36575,7 @@ data:
       }
     }
     if (this._streamMapping.get(this._standaloneSseStreamId) !== undefined) {
+      this.onerror?.(new Error("Conflict: Only one SSE stream is allowed per session"));
       return this.createJsonErrorResponse(409, -32000, "Conflict: Only one SSE stream is allowed per session");
     }
     const encoder = new TextEncoder;
@@ -36622,6 +36610,7 @@ data:
   }
   async replayEvents(lastEventId) {
     if (!this._eventStore) {
+      this.onerror?.(new Error("Event store not configured"));
       return this.createJsonErrorResponse(400, -32000, "Event store not configured");
     }
     try {
@@ -36629,9 +36618,11 @@ data:
       if (this._eventStore.getStreamIdForEventId) {
         streamId = await this._eventStore.getStreamIdForEventId(lastEventId);
         if (!streamId) {
+          this.onerror?.(new Error("Invalid event ID format"));
           return this.createJsonErrorResponse(400, -32000, "Invalid event ID format");
         }
         if (this._streamMapping.get(streamId) !== undefined) {
+          this.onerror?.(new Error("Conflict: Stream already has an active connection"));
           return this.createJsonErrorResponse(409, -32000, "Conflict: Stream already has an active connection");
         }
       }
@@ -36691,11 +36682,13 @@ data:
 `;
       controller.enqueue(encoder.encode(eventData));
       return true;
-    } catch {
+    } catch (error2) {
+      this.onerror?.(error2);
       return false;
     }
   }
   handleUnsupportedRequest() {
+    this.onerror?.(new Error("Method not allowed."));
     return new Response(JSON.stringify({
       jsonrpc: "2.0",
       error: {
@@ -36715,14 +36708,17 @@ data:
     try {
       const acceptHeader = req.headers.get("accept");
       if (!acceptHeader?.includes("application/json") || !acceptHeader.includes("text/event-stream")) {
+        this.onerror?.(new Error("Not Acceptable: Client must accept both application/json and text/event-stream"));
         return this.createJsonErrorResponse(406, -32000, "Not Acceptable: Client must accept both application/json and text/event-stream");
       }
       const ct = req.headers.get("content-type");
       if (!ct || !ct.includes("application/json")) {
+        this.onerror?.(new Error("Unsupported Media Type: Content-Type must be application/json"));
         return this.createJsonErrorResponse(415, -32000, "Unsupported Media Type: Content-Type must be application/json");
       }
       const requestInfo = {
-        headers: Object.fromEntries(req.headers.entries())
+        headers: Object.fromEntries(req.headers.entries()),
+        url: new URL(req.url)
       };
       let rawMessage;
       if (options?.parsedBody !== undefined) {
@@ -36731,6 +36727,7 @@ data:
         try {
           rawMessage = await req.json();
         } catch {
+          this.onerror?.(new Error("Parse error: Invalid JSON"));
           return this.createJsonErrorResponse(400, -32700, "Parse error: Invalid JSON");
         }
       }
@@ -36742,14 +36739,17 @@ data:
           messages = [JSONRPCMessageSchema.parse(rawMessage)];
         }
       } catch {
+        this.onerror?.(new Error("Parse error: Invalid JSON-RPC message"));
         return this.createJsonErrorResponse(400, -32700, "Parse error: Invalid JSON-RPC message");
       }
       const isInitializationRequest = messages.some(isInitializeRequest);
       if (isInitializationRequest) {
         if (this._initialized && this.sessionId !== undefined) {
+          this.onerror?.(new Error("Invalid Request: Server already initialized"));
           return this.createJsonErrorResponse(400, -32600, "Invalid Request: Server already initialized");
         }
         if (messages.length > 1) {
+          this.onerror?.(new Error("Invalid Request: Only one initialization request is allowed"));
           return this.createJsonErrorResponse(400, -32600, "Invalid Request: Only one initialization request is allowed");
         }
         this.sessionId = this.sessionIdGenerator?.();
@@ -36867,13 +36867,16 @@ data:
       return;
     }
     if (!this._initialized) {
+      this.onerror?.(new Error("Bad Request: Server not initialized"));
       return this.createJsonErrorResponse(400, -32000, "Bad Request: Server not initialized");
     }
     const sessionId = req.headers.get("mcp-session-id");
     if (!sessionId) {
+      this.onerror?.(new Error("Bad Request: Mcp-Session-Id header is required"));
       return this.createJsonErrorResponse(400, -32000, "Bad Request: Mcp-Session-Id header is required");
     }
     if (sessionId !== this.sessionId) {
+      this.onerror?.(new Error("Session not found"));
       return this.createJsonErrorResponse(404, -32001, "Session not found");
     }
     return;
@@ -36881,6 +36884,7 @@ data:
   validateProtocolVersion(req) {
     const protocolVersion = req.headers.get("mcp-protocol-version");
     if (protocolVersion !== null && !SUPPORTED_PROTOCOL_VERSIONS.includes(protocolVersion)) {
+      this.onerror?.(new Error(`Bad Request: Unsupported protocol version: ${protocolVersion}` + ` (supported versions: ${SUPPORTED_PROTOCOL_VERSIONS.join(", ")})`));
       return this.createJsonErrorResponse(400, -32000, `Bad Request: Unsupported protocol version: ${protocolVersion} (supported versions: ${SUPPORTED_PROTOCOL_VERSIONS.join(", ")})`);
     }
     return;
@@ -38869,6 +38873,10 @@ class Protocol {
     this._progressHandlers.clear();
     this._taskProgressTokens.clear();
     this._pendingDebouncedNotifications.clear();
+    for (const info of this._timeoutInfo.values()) {
+      clearTimeout(info.timeoutId);
+    }
+    this._timeoutInfo.clear();
     for (const controller of this._requestHandlerAbortControllers.values()) {
       controller.abort();
     }
@@ -38999,7 +39007,9 @@ class Protocol {
         await capturedTransport?.send(errorResponse);
       }
     }).catch((error2) => this._onerror(new Error(`Failed to send response: ${error2}`))).finally(() => {
-      this._requestHandlerAbortControllers.delete(request2.id);
+      if (this._requestHandlerAbortControllers.get(request2.id) === abortController) {
+        this._requestHandlerAbortControllers.delete(request2.id);
+      }
     });
   }
   _onprogress(notification) {
@@ -42512,6 +42522,9 @@ var require_data = __commonJS((exports, module) => {
 var require_utils3 = __commonJS((exports, module) => {
   var isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
   var isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
+  var isHexPair = RegExp.prototype.test.bind(/^[\da-f]{2}$/iu);
+  var isUnreserved = RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu);
+  var isPathCharacter = RegExp.prototype.test.bind(/^[\da-z\-._~!$&'()*+,;=:@/]$/iu);
   function stringArrayToHexStripped(input) {
     let acc = "";
     let code = 0;
@@ -42705,27 +42718,77 @@ var require_utils3 = __commonJS((exports, module) => {
     }
     return output.join("");
   }
-  function normalizeComponentEncoding(component, esc2) {
-    const func = esc2 !== true ? escape : unescape;
-    if (component.scheme !== undefined) {
-      component.scheme = func(component.scheme);
-    }
-    if (component.userinfo !== undefined) {
-      component.userinfo = func(component.userinfo);
-    }
-    if (component.host !== undefined) {
-      component.host = func(component.host);
+  var HOST_DELIMS = { "@": "%40", "/": "%2F", "?": "%3F", "#": "%23", ":": "%3A" };
+  var HOST_DELIM_RE = /[@/?#:]/g;
+  var HOST_DELIM_NO_COLON_RE = /[@/?#]/g;
+  function reescapeHostDelimiters(host, isIP) {
+    const re = isIP ? HOST_DELIM_NO_COLON_RE : HOST_DELIM_RE;
+    re.lastIndex = 0;
+    return host.replace(re, (ch) => HOST_DELIMS[ch]);
+  }
+  function normalizePercentEncoding(input, decodeUnreserved = false) {
+    if (input.indexOf("%") === -1) {
+      return input;
     }
-    if (component.path !== undefined) {
-      component.path = func(component.path);
+    let output = "";
+    for (let i = 0;i < input.length; i++) {
+      if (input[i] === "%" && i + 2 < input.length) {
+        const hex = input.slice(i + 1, i + 3);
+        if (isHexPair(hex)) {
+          const normalizedHex = hex.toUpperCase();
+          const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+          if (decodeUnreserved && isUnreserved(decoded)) {
+            output += decoded;
+          } else {
+            output += "%" + normalizedHex;
+          }
+          i += 2;
+          continue;
+        }
+      }
+      output += input[i];
     }
-    if (component.query !== undefined) {
-      component.query = func(component.query);
+    return output;
+  }
+  function normalizePathEncoding(input) {
+    let output = "";
+    for (let i = 0;i < input.length; i++) {
+      if (input[i] === "%" && i + 2 < input.length) {
+        const hex = input.slice(i + 1, i + 3);
+        if (isHexPair(hex)) {
+          const normalizedHex = hex.toUpperCase();
+          const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+          if (decoded !== "." && isUnreserved(decoded)) {
+            output += decoded;
+          } else {
+            output += "%" + normalizedHex;
+          }
+          i += 2;
+          continue;
+        }
+      }
+      if (isPathCharacter(input[i])) {
+        output += input[i];
+      } else {
+        output += escape(input[i]);
+      }
     }
-    if (component.fragment !== undefined) {
-      component.fragment = func(component.fragment);
+    return output;
+  }
+  function escapePreservingEscapes(input) {
+    let output = "";
+    for (let i = 0;i < input.length; i++) {
+      if (input[i] === "%" && i + 2 < input.length) {
+        const hex = input.slice(i + 1, i + 3);
+        if (isHexPair(hex)) {
+          output += "%" + hex.toUpperCase();
+          i += 2;
+          continue;
+        }
+      }
+      output += escape(input[i]);
     }
-    return component;
+    return output;
   }
   function recomposeAuthority(component) {
     const uriTokens = [];
@@ -42740,7 +42803,7 @@ var require_utils3 = __commonJS((exports, module) => {
         if (ipV6res.isIPV6 === true) {
           host = `[${ipV6res.escapedHost}]`;
         } else {
-          host = component.host;
+          host = reescapeHostDelimiters(host, false);
         }
       }
       uriTokens.push(host);
@@ -42754,7 +42817,10 @@ var require_utils3 = __commonJS((exports, module) => {
   module.exports = {
     nonSimpleDomain,
     recomposeAuthority,
-    normalizeComponentEncoding,
+    reescapeHostDelimiters,
+    normalizePercentEncoding,
+    normalizePathEncoding,
+    escapePreservingEscapes,
     removeDotSegments,
     isIPv4,
     isUUID,
@@ -42939,11 +43005,11 @@ var require_schemes = __commonJS((exports, module) => {
 
 // node_modules/fast-uri/index.js
 var require_fast_uri = __commonJS((exports, module) => {
-  var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require_utils3();
+  var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils3();
   var { SCHEMES, getSchemeHandler } = require_schemes();
   function normalize(uri, options) {
     if (typeof uri === "string") {
-      uri = serialize(parse6(uri, options), options);
+      uri = normalizeString(uri, options);
     } else if (typeof uri === "object") {
       uri = parse6(serialize(uri, options), options);
     }
@@ -43009,19 +43075,9 @@ var require_fast_uri = __commonJS((exports, module) => {
     return target;
   }
   function equal(uriA, uriB, options) {
-    if (typeof uriA === "string") {
-      uriA = unescape(uriA);
-      uriA = serialize(normalizeComponentEncoding(parse6(uriA, options), true), { ...options, skipEscape: true });
-    } else if (typeof uriA === "object") {
-      uriA = serialize(normalizeComponentEncoding(uriA, true), { ...options, skipEscape: true });
-    }
-    if (typeof uriB === "string") {
-      uriB = unescape(uriB);
-      uriB = serialize(normalizeComponentEncoding(parse6(uriB, options), true), { ...options, skipEscape: true });
-    } else if (typeof uriB === "object") {
-      uriB = serialize(normalizeComponentEncoding(uriB, true), { ...options, skipEscape: true });
-    }
-    return uriA.toLowerCase() === uriB.toLowerCase();
+    const normalizedA = normalizeComparableURI(uriA, options);
+    const normalizedB = normalizeComparableURI(uriB, options);
+    return normalizedA !== undefined && normalizedB !== undefined && normalizedA.toLowerCase() === normalizedB.toLowerCase();
   }
   function serialize(cmpts, opts) {
     const component = {
@@ -43047,12 +43103,12 @@ var require_fast_uri = __commonJS((exports, module) => {
       schemeHandler.serialize(component, options);
     if (component.path !== undefined) {
       if (!options.skipEscape) {
-        component.path = escape(component.path);
+        component.path = escapePreservingEscapes(component.path);
         if (component.scheme !== undefined) {
           component.path = component.path.split("%3A").join(":");
         }
       } else {
-        component.path = unescape(component.path);
+        component.path = normalizePercentEncoding(component.path);
       }
     }
     if (options.reference !== "suffix" && component.scheme) {
@@ -43087,7 +43143,16 @@ var require_fast_uri = __commonJS((exports, module) => {
     return uriTokens.join("");
   }
   var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
-  function parse6(uri, opts) {
+  function getParseError(parsed, matches) {
+    if (matches[2] !== undefined && parsed.path && parsed.path[0] !== "/") {
+      return 'URI path must start with "/" when authority is present.';
+    }
+    if (typeof parsed.port === "number" && (parsed.port < 0 || parsed.port > 65535)) {
+      return "URI port is malformed.";
+    }
+    return;
+  }
+  function parseWithStatus(uri, opts) {
     const options = Object.assign({}, opts);
     const parsed = {
       scheme: undefined,
@@ -43098,6 +43163,7 @@ var require_fast_uri = __commonJS((exports, module) => {
       query: undefined,
       fragment: undefined
     };
+    let malformedAuthorityOrPort = false;
     let isIP = false;
     if (options.reference === "suffix") {
       if (options.scheme) {
@@ -43118,6 +43184,11 @@ var require_fast_uri = __commonJS((exports, module) => {
       if (isNaN(parsed.port)) {
         parsed.port = matches[5];
       }
+      const parseError = getParseError(parsed, matches);
+      if (parseError !== undefined) {
+        parsed.error = parsed.error || parseError;
+        malformedAuthorityOrPort = true;
+      }
       if (parsed.host) {
         const ipv4result = isIPv4(parsed.host);
         if (ipv4result === false) {
@@ -43156,14 +43227,18 @@ var require_fast_uri = __commonJS((exports, module) => {
             parsed.scheme = unescape(parsed.scheme);
           }
           if (parsed.host !== undefined) {
-            parsed.host = unescape(parsed.host);
+            parsed.host = reescapeHostDelimiters(unescape(parsed.host), isIP);
           }
         }
         if (parsed.path) {
-          parsed.path = escape(unescape(parsed.path));
+          parsed.path = normalizePathEncoding(parsed.path);
         }
         if (parsed.fragment) {
-          parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
+          try {
+            parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
+          } catch {
+            parsed.error = parsed.error || "URI malformed";
+          }
         }
       }
       if (schemeHandler && schemeHandler.parse) {
@@ -43172,7 +43247,29 @@ var require_fast_uri = __commonJS((exports, module) => {
     } else {
       parsed.error = parsed.error || "URI can not be parsed.";
     }
-    return parsed;
+    return { parsed, malformedAuthorityOrPort };
+  }
+  function parse6(uri, opts) {
+    return parseWithStatus(uri, opts).parsed;
+  }
+  function normalizeString(uri, opts) {
+    return normalizeStringWithStatus(uri, opts).normalized;
+  }
+  function normalizeStringWithStatus(uri, opts) {
+    const { parsed, malformedAuthorityOrPort } = parseWithStatus(uri, opts);
+    return {
+      normalized: malformedAuthorityOrPort ? uri : serialize(parsed, opts),
+      malformedAuthorityOrPort
+    };
+  }
+  function normalizeComparableURI(uri, opts) {
+    if (typeof uri === "string") {
+      const { normalized, malformedAuthorityOrPort } = normalizeStringWithStatus(uri, opts);
+      return malformedAuthorityOrPort ? undefined : normalized;
+    }
+    if (typeof uri === "object") {
+      return serialize(uri, opts);
+    }
   }
   var fastUri = {
     SCHEMES,
@@ -43307,7 +43404,7 @@ var require_core = __commonJS((exports) => {
     constructor(opts = {}) {
       this.schemas = {};
       this.refs = {};
-      this.formats = {};
+      this.formats = Object.create(null);
       this._compilations = new Set;
       this._loading = {};
       this._cache = new Map;
@@ -44048,6 +44145,7 @@ var require_limitLength = __commonJS((exports) => {
 var require_pattern = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var code_1 = require_code2();
+  var util_1 = require_util();
   var codegen_1 = require_codegen();
   var error2 = {
     message: ({ schemaCode }) => (0, codegen_1.str)`must match pattern "${schemaCode}"`,
@@ -44060,10 +44158,18 @@ var require_pattern = __commonJS((exports) => {
     $data: true,
     error: error2,
     code(cxt) {
-      const { data, $data, schema, schemaCode, it } = cxt;
+      const { gen, data, $data, schema, schemaCode, it } = cxt;
       const u = it.opts.unicodeRegExp ? "u" : "";
-      const regExp = $data ? (0, codegen_1._)`(new RegExp(${schemaCode}, ${u}))` : (0, code_1.usePattern)(cxt, schema);
-      cxt.fail$data((0, codegen_1._)`!${regExp}.test(${data})`);
+      if ($data) {
+        const { regExp } = it.opts.code;
+        const regExpCode = regExp.code === "new RegExp" ? (0, codegen_1._)`new RegExp` : (0, util_1.useFunc)(gen, regExp);
+        const valid = gen.let("valid");
+        gen.try(() => gen.assign(valid, (0, codegen_1._)`${regExpCode}(${schemaCode}, ${u}).test(${data})`), () => gen.assign(valid, false));
+        cxt.fail$data((0, codegen_1._)`!${valid}`);
+      } else {
+        const regExp = (0, code_1.usePattern)(cxt, schema);
+        cxt.fail$data((0, codegen_1._)`!${regExp}.test(${data})`);
+      }
     }
   };
   exports.default = def;
@@ -46020,6 +46126,62 @@ class ExperimentalServerTasks {
   requestStream(request2, resultSchema, options) {
     return this._server.requestStream(request2, resultSchema, options);
   }
+  createMessageStream(params, options) {
+    const clientCapabilities = this._server.getClientCapabilities();
+    if ((params.tools || params.toolChoice) && !clientCapabilities?.sampling?.tools) {
+      throw new Error("Client does not support sampling tools capability.");
+    }
+    if (params.messages.length > 0) {
+      const lastMessage = params.messages[params.messages.length - 1];
+      const lastContent = Array.isArray(lastMessage.content) ? lastMessage.content : [lastMessage.content];
+      const hasToolResults = lastContent.some((c) => c.type === "tool_result");
+      const previousMessage = params.messages.length > 1 ? params.messages[params.messages.length - 2] : undefined;
+      const previousContent = previousMessage ? Array.isArray(previousMessage.content) ? previousMessage.content : [previousMessage.content] : [];
+      const hasPreviousToolUse = previousContent.some((c) => c.type === "tool_use");
+      if (hasToolResults) {
+        if (lastContent.some((c) => c.type !== "tool_result")) {
+          throw new Error("The last message must contain only tool_result content if any is present");
+        }
+        if (!hasPreviousToolUse) {
+          throw new Error("tool_result blocks are not matching any tool_use from the previous message");
+        }
+      }
+      if (hasPreviousToolUse) {
+        const toolUseIds = new Set(previousContent.filter((c) => c.type === "tool_use").map((c) => c.id));
+        const toolResultIds = new Set(lastContent.filter((c) => c.type === "tool_result").map((c) => c.toolUseId));
+        if (toolUseIds.size !== toolResultIds.size || ![...toolUseIds].every((id) => toolResultIds.has(id))) {
+          throw new Error("ids of tool_result blocks and tool_use blocks from previous message do not match");
+        }
+      }
+    }
+    return this.requestStream({
+      method: "sampling/createMessage",
+      params
+    }, CreateMessageResultSchema, options);
+  }
+  elicitInputStream(params, options) {
+    const clientCapabilities = this._server.getClientCapabilities();
+    const mode = params.mode ?? "form";
+    switch (mode) {
+      case "url": {
+        if (!clientCapabilities?.elicitation?.url) {
+          throw new Error("Client does not support url elicitation.");
+        }
+        break;
+      }
+      case "form": {
+        if (!clientCapabilities?.elicitation?.form) {
+          throw new Error("Client does not support form elicitation.");
+        }
+        break;
+      }
+    }
+    const normalizedParams = mode === "form" && params.mode === undefined ? { ...params, mode: "form" } : params;
+    return this.requestStream({
+      method: "elicitation/create",
+      params: normalizedParams
+    }, ElicitResultSchema, options);
+  }
   async getTask(taskId, options) {
     return this._server.getTask({ taskId }, options);
   }
@@ -46033,6 +46195,9 @@ class ExperimentalServerTasks {
     return this._server.cancelTask({ taskId }, options);
   }
 }
+var init_server = __esm(() => {
+  init_types3();
+});
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/helpers.js
 function assertToolsCallTaskCapability(requests, method, entityName) {
@@ -46071,11 +46236,12 @@ function assertClientRequestTaskCapability(requests, method, entityName) {
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/server/index.js
 var Server;
-var init_server = __esm(() => {
+var init_server2 = __esm(() => {
   init_protocol();
   init_types3();
   init_ajv_provider();
   init_zod_compat();
+  init_server();
   Server = class Server extends Protocol {
     constructor(_serverInfo, options) {
       super(options);
@@ -47084,6 +47250,9 @@ class McpServer {
           annotations = rest.shift();
         }
       } else if (typeof firstArg === "object" && firstArg !== null) {
+        if (Object.values(firstArg).some((v) => typeof v === "object" && v !== null)) {
+          throw new Error(`Tool ${name} expected a Zod schema or ToolAnnotations, but received an unrecognized object`);
+        }
         annotations = rest.shift();
       }
     }
@@ -47172,6 +47341,9 @@ function getZodSchemaObject(schema) {
   if (isZodRawShapeCompat(schema)) {
     return objectFromShape(schema);
   }
+  if (!isZodSchemaInstance(schema)) {
+    throw new Error("inputSchema must be a Zod schema or raw shape, received an unrecognized object");
+  }
   return schema;
 }
 function promptArgumentsFromSchema(schema) {
@@ -47211,7 +47383,7 @@ function createCompletionResult(suggestions) {
 }
 var EMPTY_OBJECT_JSON_SCHEMA, EMPTY_COMPLETION_RESULT;
 var init_mcp = __esm(() => {
-  init_server();
+  init_server2();
   init_zod_compat();
   init_zod_json_schema_compat();
   init_types3();
@@ -47517,7 +47689,7 @@ var init_management = __esm(() => {
 // src/mcp/tools/auth.ts
 import { existsSync as existsSync18, readFileSync as readFileSync9 } from "fs";
 import { join as join18 } from "path";
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 function registerAuthTools(server, stripped) {
   server.registerTool("connector_auth_status", {
     title: "Connector Auth Status",
@@ -47660,7 +47832,7 @@ function registerAuthTools(server, stripped) {
       } catch {}
       if (!serverRunning) {
         const scriptPath = process.argv[1];
-        const serverProc = spawn3("node", [scriptPath, "serve", "--port", String(serverPort)], {
+        const serverProc = spawn4("node", [scriptPath, "serve", "--port", String(serverPort)], {
           detached: true,
           stdio: "ignore"
         });
@@ -48228,7 +48400,7 @@ function buildServer() {
   registerCloudTools(server, "connectors");
   return server;
 }
-var init_server2 = __esm(() => {
+var init_server3 = __esm(() => {
   init_mcp();
   init_strip();
   init_dist();
@@ -48262,7 +48434,7 @@ async function handleMcpHttpRequest(req) {
 var MCP_NAME = "connectors";
 var init_http = __esm(() => {
   init_webStandardStreamableHttp();
-  init_server2();
+  init_server3();
 });
 
 // src/server/serve.ts
@@ -49113,6 +49285,684 @@ var {
   Help
 } = import__.default;
 
+// 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 registerWebhookCommands(program2, options) {
+  const webhooks = program2.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) => {
+    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), Boolean(actionOptions.json), `Added ${saved.transport} channel ${saved.id}`);
+  });
+  webhooks.command("list").description("List configured subscriptions").option("-j, --json", "Print JSON output", false).action(async (actionOptions) => {
+    const channels = await createClient(options).listChannels();
+    if (actionOptions.json) {
+      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) => {
+    const removed = await createClient(options).removeChannel(id);
+    print({ removed }, Boolean(actionOptions.json), 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) => {
+    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, Boolean(actionOptions.json), `${result.status}: ${result.channelId}`);
+  });
+  return webhooks;
+}
+function registerEventCommands(program2, options) {
+  const events = program2.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) => {
+    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, Boolean(actionOptions.json), `${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) => {
+    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 (actionOptions.json) {
+      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) => {
+    const result = await createClient(options).replay({
+      eventId: actionOptions.id,
+      source: actionOptions.source,
+      type: actionOptions.type,
+      dryRun: actionOptions.dryRun
+    });
+    print(result, Boolean(actionOptions.json), `Replayed ${result.events.length} event(s), ${result.deliveries.length} delivery result(s)`);
+  });
+  return events;
+}
+function registerEventsCommands(program2, options) {
+  registerWebhookCommands(program2, options);
+  registerEventCommands(program2, 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;
+}
+
 // src/cli/index.tsx
 init_package();
 init_registry2();
@@ -51570,7 +52420,7 @@ var SENSITIVE_FIELDS = new Set([
   "private_key",
   "privatekey"
 ]);
-function redactValue(value) {
+function redactValue2(value) {
   if (value.length <= 8)
     return "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022";
   return value.slice(0, 4) + "\u2022\u2022\u2022\u2022" + value.slice(-4);
@@ -51586,7 +52436,7 @@ function redactSecrets(obj) {
     const result = {};
     for (const [key, value] of Object.entries(obj)) {
       if (SENSITIVE_FIELDS.has(key.toLowerCase()) && typeof value === "string") {
-        result[key] = redactValue(value);
+        result[key] = redactValue2(value);
       } else if (typeof value === "object" && value !== null) {
         result[key] = redactSecrets(value);
       } else {
@@ -51605,10 +52455,10 @@ function getOAuthTokenState(name) {
   if (!tokens.expiresAt) {
     return { hasTokens: true, expired: false };
   }
-  const now3 = Date.now();
-  const isExpired = now3 >= tokens.expiresAt - 60000;
+  const now4 = Date.now();
+  const isExpired = now4 >= tokens.expiresAt - 60000;
   const expiresIn = isExpired ? undefined : (() => {
-    const ms = tokens.expiresAt - now3;
+    const ms = tokens.expiresAt - now4;
     const mins = Math.floor(ms / 60000);
     if (mins < 1)
       return "less than a minute";
@@ -51762,9 +52612,9 @@ ${meta.displayName} \u2014 Auth Configuration
       try {
         if (!options.browser) {
           console.log(chalk5.dim(`Starting OAuth server on port ${port}...`));
-          const { spawn: spawn4 } = await import("child_process");
+          const { spawn: spawn5 } = await import("child_process");
           const scriptPath = process.argv[1];
-          const serverProc = spawn4(process.execPath, [scriptPath, "serve", "--port", String(port)], {
+          const serverProc = spawn5(process.execPath, [scriptPath, "serve", "--port", String(port)], {
             detached: true,
             stdio: "ignore"
           });
@@ -53106,10 +53956,10 @@ Setting up ${meta.displayName}...
   ${chalk7.bold("Open this URL to authenticate:")}`);
             console.log(`  ${chalk7.cyan(oauthUrl)}
 `);
-            const { spawn: spawn4 } = await import("child_process");
+            const { spawn: spawn5 } = await import("child_process");
             const { getConnectorsHome: getConnectorsHome2 } = await Promise.resolve().then(() => (init_database(), exports_database));
             const scriptPath = process.argv[1];
-            const serverProc = spawn4(process.execPath, [scriptPath, "serve", "--port", String(port)], {
+            const serverProc = spawn5(process.execPath, [scriptPath, "serve", "--port", String(port)], {
               detached: true,
               stdio: "ignore"
             });
@@ -53651,4 +54501,5 @@ registerCommands5(program2);
 registerCommands6(program2);
 registerCommands7(program2);
 registerCommands8(program2);
+registerEventsCommands(program2, { source: "connectors" });
 program2.parse();