@hasna/connectors 1.3.33 → 1.3.35

package/bin/serve.js

@@ -61,14 +61,14 @@ import { join, relative } from "path";
 import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync, writeFileSync } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join2 } from "path";
-import { readdirSync as readdirSync2, existsSync as existsSync3 } from "fs";
-import { join as join3 } from "path";
-import { homedir as homedir3 } from "os";
+import { readdirSync as readdirSync3, existsSync as existsSync6 } from "fs";
+import { join as join6 } from "path";
+import { homedir as homedir5 } from "os";
 import { hostname } from "os";
-import { homedir as homedir4 } from "os";
-import { join as join4 } from "path";
-import { join as join6, dirname } from "path";
-import { homedir as homedir5, platform } from "os";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
+import { join as join5, dirname } from "path";
+import { homedir as homedir4, platform } from "os";
 function __accessProp2(key) {
   return this[key];
 }
@@ -996,11 +996,11 @@ function isSyncExcludedTable(table) {
   return SYNC_EXCLUDED_TABLE_PATTERNS.some((p) => p.test(table));
 }
 function discoverServices() {
-  const dataDir = join3(homedir3(), ".hasna");
-  if (!existsSync3(dataDir))
+  const dataDir = join6(homedir5(), ".hasna");
+  if (!existsSync6(dataDir))
     return [];
   try {
-    const entries = readdirSync2(dataDir, { withFileTypes: true });
+    const entries = readdirSync3(dataDir, { withFileTypes: true });
     return entries.filter((e) => {
       if (!e.isDirectory())
         return false;
@@ -1012,30 +1012,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 = join3(homedir3(), ".hasna", service);
-  if (!existsSync3(dataDir))
+  const dataDir = join6(homedir5(), ".hasna", service);
+  if (!existsSync6(dataDir))
     return null;
   const candidates = [
-    join3(dataDir, `${service}.db`),
-    join3(dataDir, "data.db"),
-    join3(dataDir, "database.db")
+    join6(dataDir, `${service}.db`),
+    join6(dataDir, "data.db"),
+    join6(dataDir, "database.db")
   ];
   try {
-    const files = readdirSync2(dataDir);
+    const files = readdirSync3(dataDir);
     for (const f of files) {
       if (f.endsWith(".db") && !f.endsWith("-wal") && !f.endsWith("-shm")) {
-        candidates.push(join3(dataDir, f));
+        candidates.push(join6(dataDir, f));
       }
     }
   } catch {}
   for (const p of candidates) {
-    if (existsSync3(p))
+    if (existsSync6(p))
       return p;
   }
   return null;
@@ -1342,9 +1342,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) {
@@ -1391,7 +1391,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(", ");
@@ -1401,22 +1401,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);
 }
@@ -1641,7 +1639,7 @@ class SyncProgressTracker {
     }
   }
 }
-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 = [
@@ -1674,13 +1672,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();
@@ -1702,7 +1695,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) {
@@ -10007,7 +10000,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
@@ -10062,15 +10055,13 @@ 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 = join4(homedir4(), ".hasna", "cloud", "config.json");
+  AUTO_SYNC_CONFIG_PATH = join3(homedir3(), ".hasna", "cloud", "config.json");
   init_config();
   init_adapter();
   init_dotfile();
   init_config();
-  CONFIG_DIR2 = join6(homedir5(), ".hasna", "cloud");
+  CONFIG_DIR2 = join5(homedir4(), ".hasna", "cloud");
   init_adapter();
   init_config();
   init_discover();
@@ -10092,24 +10083,24 @@ __export(exports_database, {
   getConnectorsHome: () => getConnectorsHome,
   closeDatabase: () => closeDatabase
 });
-import { dirname as dirname2, join as join5 } from "path";
+import { dirname as dirname2, join as join4 } from "path";
 import { homedir as homedir6 } from "os";
-import { mkdirSync as mkdirSync3, existsSync as existsSync4, readdirSync as readdirSync3, copyFileSync as copyFileSync2, statSync } from "fs";
+import { mkdirSync as mkdirSync3, existsSync as existsSync3, readdirSync as readdirSync2, copyFileSync as copyFileSync2, statSync } from "fs";
 function mergeDirectoryContents(sourceDir, targetDir) {
-  if (!existsSync4(sourceDir)) {
+  if (!existsSync3(sourceDir)) {
     return;
   }
   mkdirSync3(targetDir, { recursive: true });
-  for (const entry of readdirSync3(sourceDir)) {
-    const sourcePath = join5(sourceDir, entry);
-    const targetPath = join5(targetDir, entry);
+  for (const entry of readdirSync2(sourceDir)) {
+    const sourcePath = join4(sourceDir, entry);
+    const targetPath = join4(targetDir, entry);
     try {
       const sourceStat = statSync(sourcePath);
       if (sourceStat.isDirectory()) {
         mergeDirectoryContents(sourcePath, targetPath);
         continue;
       }
-      if (!existsSync4(targetPath)) {
+      if (!existsSync3(targetPath)) {
         copyFileSync2(sourcePath, targetPath);
       }
     } catch {}
@@ -10117,8 +10108,8 @@ function mergeDirectoryContents(sourceDir, targetDir) {
 }
 function getConnectorsHome() {
   const home = process.env["HOME"] || process.env["USERPROFILE"] || homedir6();
-  const newDir = join5(home, ".hasna", "connectors");
-  const legacyDirs = [join5(home, ".connectors"), join5(home, ".connect")];
+  const newDir = join4(home, ".hasna", "connectors");
+  const legacyDirs = [join4(home, ".connectors"), join4(home, ".connect")];
   mkdirSync3(newDir, { recursive: true });
   for (const legacyDir of legacyDirs) {
     try {
@@ -10266,7 +10257,7 @@ var DB_DIR, DB_PATH, _db = null, _dbPath = null;
 var init_database = __esm(() => {
   init_dist();
   DB_DIR = getConnectorsHome();
-  DB_PATH = join5(DB_DIR, "connectors.db");
+  DB_PATH = join4(DB_DIR, "connectors.db");
 });
 
 // src/lib/llm.ts
@@ -10280,14 +10271,14 @@ __export(exports_llm, {
   PROVIDER_DEFAULTS: () => PROVIDER_DEFAULTS,
   LLMClient: () => LLMClient
 });
-import { existsSync as existsSync6, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync5 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync5 } from "fs";
 import { join as join7 } from "path";
 function getLlmConfigPath() {
   return join7(getConnectorsHome(), "llm.json");
 }
 function getLlmConfig() {
   const path = getLlmConfigPath();
-  if (!existsSync6(path))
+  if (!existsSync5(path))
     return null;
   try {
     return JSON.parse(readFileSync2(path, "utf-8"));
@@ -14741,14 +14732,14 @@ var init_zod2 = __esm(() => {
 // src/core/connectors/github.ts
 import { Buffer as Buffer2 } from "buffer";
 import { existsSync as existsSync7 } from "fs";
-import { dirname as dirname3, join as join8 } from "path";
+import { dirname as dirname3, join as join9 } from "path";
 import { fileURLToPath, pathToFileURL } from "url";
 function resolveGithubConnectorDir() {
   const candidates = [
-    join8(__dirname2, "..", "..", "..", "connectors", "github"),
-    join8(__dirname2, "..", "..", "connectors", "github"),
-    join8(__dirname2, "..", "connectors", "github"),
-    join8(process.cwd(), "connectors", "github")
+    join9(__dirname2, "..", "..", "..", "connectors", "github"),
+    join9(__dirname2, "..", "..", "connectors", "github"),
+    join9(__dirname2, "..", "connectors", "github"),
+    join9(process.cwd(), "connectors", "github")
   ];
   for (const candidate of candidates) {
     if (existsSync7(candidate)) {
@@ -14758,10 +14749,10 @@ function resolveGithubConnectorDir() {
   return candidates[0];
 }
 async function loadGitHubApiModule() {
-  return await import(pathToFileURL(join8(CONNECTOR_DIR, "src", "api", "index.ts")).href);
+  return await import(pathToFileURL(join9(CONNECTOR_DIR, "src", "api", "index.ts")).href);
 }
 async function loadGitHubConfigModule() {
-  return await import(pathToFileURL(join8(CONNECTOR_DIR, "src", "utils", "config.ts")).href);
+  return await import(pathToFileURL(join9(CONNECTOR_DIR, "src", "utils", "config.ts")).href);
 }
 function extractGlobalArgs(args) {
   const remaining = [];
@@ -15605,9 +15596,9 @@ Commands:
 });
 
 // src/core/connectors/gmail.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync6, readFileSync as readFileSync3, readdirSync as readdirSync5, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync3, readdirSync as readdirSync4, writeFileSync as writeFileSync3 } from "fs";
 import { homedir as homedir8 } from "os";
-import { basename, join as join9 } from "path";
+import { basename, join as join10 } from "path";
 async function modifyMessage(profile, messageId, addLabelIds, removeLabelIds) {
   return requestJson(profile, `/users/me/messages/${encodeURIComponent(messageId)}/modify`, {}, {
     method: "POST",
@@ -15644,7 +15635,7 @@ async function replyToMessage(profile, messageId, input) {
 }
 async function downloadAttachments(profile, input) {
   const messageId = getMessageId(input);
-  const outputDir = input.dir ?? input.outputDir ?? join9(configDirs()[0], "attachments", messageId);
+  const outputDir = input.dir ?? input.outputDir ?? join10(configDirs()[0], "attachments", messageId);
   mkdirSync6(outputDir, { recursive: true });
   const attachments = input.attachmentId && input.filename ? [{
     attachmentId: input.attachmentId,
@@ -15656,7 +15647,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 = join9(outputDir, filename);
+    const path = join10(outputDir, filename);
     const buffer = Buffer.from(data.data, "base64url");
     writeFileSync3(path, buffer);
     downloaded.push({
@@ -15773,10 +15764,10 @@ async function refreshAccessToken(profile, currentTokens) {
 function listProfiles() {
   const profiles = new Set;
   for (const baseDir of configDirs()) {
-    const profilesDir = join9(baseDir, "profiles");
-    if (!existsSync8(profilesDir))
+    const profilesDir = join10(baseDir, "profiles");
+    if (!existsSync9(profilesDir))
       continue;
-    for (const entry of readdirSync5(profilesDir, { withFileTypes: true })) {
+    for (const entry of readdirSync4(profilesDir, { withFileTypes: true })) {
       if (entry.isDirectory())
         profiles.add(entry.name);
       if (entry.isFile() && entry.name.endsWith(".json"))
@@ -15792,8 +15783,8 @@ function loadCredentials(profile) {
     return { clientId: envClientId, clientSecret: envClientSecret };
   for (const baseDir of configDirs()) {
     const credentials = {
-      ...readJson(join9(baseDir, "credentials.json")),
-      ...readJson(join9(baseDir, "profiles", profile, "config.json"))
+      ...readJson(join10(baseDir, "credentials.json")),
+      ...readJson(join10(baseDir, "profiles", profile, "config.json"))
     };
     if (credentials.clientId || credentials.clientSecret)
       return credentials;
@@ -15802,30 +15793,30 @@ function loadCredentials(profile) {
 }
 function loadTokens(profile) {
   for (const baseDir of configDirs()) {
-    const fromProfile = readJson(join9(baseDir, "profiles", profile, "tokens.json"));
+    const fromProfile = readJson(join10(baseDir, "profiles", profile, "tokens.json"));
     if (fromProfile)
       return fromProfile;
-    const flat = readJson(join9(baseDir, "profiles", `${profile}.json`));
+    const flat = readJson(join10(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) => existsSync8(dir)) ?? configDirs()[0];
-  const profileDir = join9(baseDir, "profiles", profile);
+  const baseDir = configDirs().find((dir) => existsSync9(dir)) ?? configDirs()[0];
+  const profileDir = join10(baseDir, "profiles", profile);
   mkdirSync6(profileDir, { recursive: true });
-  writeFileSync3(join9(profileDir, "tokens.json"), JSON.stringify(tokens, null, 2), { mode: 384 });
+  writeFileSync3(join10(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 ?? join9(homedir8(), ".hasna", "connectors");
-  return [join9(baseDir, "gmail"), join9(baseDir, "connect-gmail")];
+  const baseDir = process.env.HASNA_CONNECTORS_DIR ?? join10(homedir8(), ".hasna", "connectors");
+  return [join10(baseDir, "gmail"), join10(baseDir, "connect-gmail")];
 }
 function readJson(path) {
-  if (!existsSync8(path))
+  if (!existsSync9(path))
     return null;
   try {
     return JSON.parse(readFileSync3(path, "utf8"));
@@ -16075,9 +16066,9 @@ var init_gmail = __esm(() => {
 });
 
 // src/core/connectors/googledrive.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync7, readFileSync as readFileSync4, readdirSync as readdirSync6, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync10, mkdirSync as mkdirSync7, readFileSync as readFileSync4, readdirSync as readdirSync6, writeFileSync as writeFileSync4 } from "fs";
 import { homedir as homedir9 } from "os";
-import { basename as basename2, join as join10 } from "path";
+import { basename as basename2, join as join11 } from "path";
 async function requestJson2(profile, path, params) {
   const response = await request(profile, path, params);
   const text = await response.text();
@@ -16145,8 +16136,8 @@ async function refreshAccessToken2(profile, currentTokens) {
 function listProfiles2() {
   const profiles = new Set;
   for (const baseDir of configDirs2()) {
-    const profilesDir = join10(baseDir, "profiles");
-    if (!existsSync9(profilesDir))
+    const profilesDir = join11(baseDir, "profiles");
+    if (!existsSync10(profilesDir))
       continue;
     for (const entry of readdirSync6(profilesDir, { withFileTypes: true })) {
       if (entry.isDirectory())
@@ -16193,8 +16184,8 @@ function loadCredentials2(profile) {
     return { clientId: envClientId, clientSecret: envClientSecret };
   for (const baseDir of configDirs2()) {
     const credentials = {
-      ...readJson2(join10(baseDir, "credentials.json")),
-      ...readJson2(join10(baseDir, "profiles", profile, "config.json"))
+      ...readJson2(join11(baseDir, "credentials.json")),
+      ...readJson2(join11(baseDir, "profiles", profile, "config.json"))
     };
     if (credentials.clientId || credentials.clientSecret)
       return credentials;
@@ -16203,30 +16194,30 @@ function loadCredentials2(profile) {
 }
 function loadTokens2(profile) {
   for (const baseDir of configDirs2()) {
-    const fromProfile = readJson2(join10(baseDir, "profiles", profile, "tokens.json"));
+    const fromProfile = readJson2(join11(baseDir, "profiles", profile, "tokens.json"));
     if (fromProfile)
       return fromProfile;
-    const flat = readJson2(join10(baseDir, "profiles", `${profile}.json`));
+    const flat = readJson2(join11(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) => existsSync9(dir)) ?? configDirs2()[0];
-  const profileDir = join10(baseDir, "profiles", profile);
+  const baseDir = configDirs2().find((dir) => existsSync10(dir)) ?? configDirs2()[0];
+  const profileDir = join11(baseDir, "profiles", profile);
   mkdirSync7(profileDir, { recursive: true });
-  writeFileSync4(join10(profileDir, "tokens.json"), JSON.stringify(tokens, null, 2), { mode: 384 });
+  writeFileSync4(join11(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 ?? join10(homedir9(), ".hasna", "connectors");
-  return [join10(baseDir, "googledrive"), join10(baseDir, "connect-googledrive")];
+  const baseDir = process.env.HASNA_CONNECTORS_DIR ?? join11(homedir9(), ".hasna", "connectors");
+  return [join11(baseDir, "googledrive"), join11(baseDir, "connect-googledrive")];
 }
 function readJson2(path) {
-  if (!existsSync9(path))
+  if (!existsSync10(path))
     return null;
   try {
     return JSON.parse(readFileSync4(path, "utf8"));
@@ -16409,7 +16400,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: {
@@ -16464,7 +16455,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",
@@ -16497,8 +16489,8 @@ var init_package = __esm(() => {
 });
 
 // src/lib/connector-resolver.ts
-import { existsSync as existsSync10, readdirSync as readdirSync7, statSync as statSync2 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync11, readdirSync as readdirSync7, statSync as statSync2 } from "fs";
+import { join as join12 } from "path";
 function normalizeConnectorName(name) {
   const trimmed = name.trim().toLowerCase();
   return trimmed.startsWith(LEGACY_CONNECTOR_PREFIX) ? trimmed.slice(LEGACY_CONNECTOR_PREFIX.length) : trimmed;
@@ -16532,8 +16524,8 @@ function connectorPackageDirNames(name) {
 function resolveConnectorPackagePath(connectorsDir, name) {
   const resolution = resolveConnectorName(name);
   const dirNames = connectorPackageDirNames(name);
-  const checkedPaths = dirNames.map((dirName) => join11(connectorsDir, dirName));
-  const existingPath = checkedPaths.find((path) => existsSync10(path)) ?? null;
+  const checkedPaths = dirNames.map((dirName) => join12(connectorsDir, dirName));
+  const existingPath = checkedPaths.find((path) => existsSync11(path)) ?? null;
   const existingDirName = existingPath ? dirNames[checkedPaths.indexOf(existingPath)] : null;
   return {
     ...resolution,
@@ -16552,10 +16544,10 @@ function getConnectorPackagePath(connectorsDir, name) {
 function resolveConnectorConfigPaths(name, connectorsHome = getConnectorsHome()) {
   const resolution = resolveConnectorName(name);
   const preferredDirName = resolution.canonicalName || resolution.legacyName;
-  const preferredPath = join11(connectorsHome, preferredDirName);
-  const legacyPath = join11(connectorsHome, resolution.legacyName);
+  const preferredPath = join12(connectorsHome, preferredDirName);
+  const legacyPath = join12(connectorsHome, resolution.legacyName);
   const paths = preferredPath === legacyPath ? [preferredPath] : [preferredPath, legacyPath];
-  const existingPaths = paths.filter((path) => existsSync10(path));
+  const existingPaths = paths.filter((path) => existsSync11(path));
   return {
     ...resolution,
     connectorsHome,
@@ -16573,11 +16565,11 @@ function getConnectorConfigReadDirs(name, connectorsHome = getConnectorsHome())
   return resolveConnectorConfigPaths(name, connectorsHome).readPaths;
 }
 function listConfiguredConnectorNames(connectorsHome = getConnectorsHome()) {
-  if (!existsSync10(connectorsHome))
+  if (!existsSync11(connectorsHome))
     return [];
   const names = new Set;
   for (const entry of readdirSync7(connectorsHome)) {
-    const fullPath = join11(connectorsHome, entry);
+    const fullPath = join12(connectorsHome, entry);
     try {
       if (!statSync2(fullPath).isDirectory())
         continue;
@@ -16596,7 +16588,7 @@ var init_connector_resolver = __esm(() => {
 
 // src/core/connectors/imessage.ts
 import {
-  existsSync as existsSync11,
+  existsSync as existsSync12,
   mkdirSync as mkdirSync8,
   readFileSync as readFileSync5,
   readdirSync as readdirSync8,
@@ -16604,7 +16596,7 @@ import {
   statSync as statSync3,
   writeFileSync as writeFileSync5
 } from "fs";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 function buildRootHelp(specs) {
   const lines = [
     "Usage: connect-imessage [options] [command]",
@@ -16655,12 +16647,12 @@ function getConfigReadDirs() {
   return getConnectorConfigReadDirs(CONNECTOR_NAME);
 }
 function getProfilesDir() {
-  return join12(getConfigDir2(), "profiles");
+  return join13(getConfigDir2(), "profiles");
 }
 function getCurrentProfile() {
   for (const configDir of getConfigReadDirs()) {
-    const currentProfileFile = join12(configDir, "current_profile");
-    if (!existsSync11(currentProfileFile))
+    const currentProfileFile = join13(configDir, "current_profile");
+    if (!existsSync12(currentProfileFile))
       continue;
     try {
       return readFileSync5(currentProfileFile, "utf-8").trim() || "default";
@@ -16673,16 +16665,16 @@ function getCurrentProfile() {
 function setCurrentProfile(profile) {
   const configDir = getConfigDir2();
   mkdirSync8(configDir, { recursive: true });
-  writeFileSync5(join12(configDir, "current_profile"), profile);
+  writeFileSync5(join13(configDir, "current_profile"), profile);
 }
 function getFlatProfilePath(profile) {
-  return join12(getProfilesDir(), `${profile}.json`);
+  return join13(getProfilesDir(), `${profile}.json`);
 }
 function getFlatProfileReadPaths(profile) {
-  return getConfigReadDirs().map((dir) => join12(dir, "profiles", `${profile}.json`));
+  return getConfigReadDirs().map((dir) => join13(dir, "profiles", `${profile}.json`));
 }
 function getDirectoryProfileReadPaths(profile) {
-  return getConfigReadDirs().map((dir) => join12(dir, "profiles", profile, "config.json"));
+  return getConfigReadDirs().map((dir) => join13(dir, "profiles", profile, "config.json"));
 }
 function loadJsonFile(path) {
   try {
@@ -16702,8 +16694,8 @@ function sanitizeProfileConfig(config) {
   };
 }
 function loadProfile(profile = getCurrentProfile()) {
-  const flatConfig = getFlatProfileReadPaths(profile).reverse().reduce((config, path) => ({ ...config, ...existsSync11(path) ? loadJsonFile(path) : {} }), {});
-  const directoryConfig = getDirectoryProfileReadPaths(profile).reverse().reduce((config, path) => ({ ...config, ...existsSync11(path) ? loadJsonFile(path) : {} }), {});
+  const flatConfig = getFlatProfileReadPaths(profile).reverse().reduce((config, path) => ({ ...config, ...existsSync12(path) ? loadJsonFile(path) : {} }), {});
+  const directoryConfig = getDirectoryProfileReadPaths(profile).reverse().reduce((config, path) => ({ ...config, ...existsSync12(path) ? loadJsonFile(path) : {} }), {});
   return sanitizeProfileConfig({
     ...flatConfig,
     ...directoryConfig
@@ -16719,17 +16711,17 @@ function profileExists(profile) {
   if (profile === "default") {
     return true;
   }
-  return getFlatProfileReadPaths(profile).some((path) => existsSync11(path)) || getConfigReadDirs().some((dir) => existsSync11(join12(dir, "profiles", profile)));
+  return getFlatProfileReadPaths(profile).some((path) => existsSync12(path)) || getConfigReadDirs().some((dir) => existsSync12(join13(dir, "profiles", profile)));
 }
 function listProfiles3() {
   const seen = new Set(["default"]);
   for (const configDir of getConfigReadDirs()) {
-    const profilesDir = join12(configDir, "profiles");
-    if (!existsSync11(profilesDir))
+    const profilesDir = join13(configDir, "profiles");
+    if (!existsSync12(profilesDir))
       continue;
     try {
       for (const entry of readdirSync8(profilesDir)) {
-        const fullPath = join12(profilesDir, entry);
+        const fullPath = join13(profilesDir, entry);
         const stat = statSync3(fullPath);
         if (stat.isDirectory()) {
           seen.add(entry);
@@ -16751,11 +16743,11 @@ function createProfile(profile, config = {}) {
 }
 function clearProfile(profile = getCurrentProfile()) {
   const flatPath = getFlatProfilePath(profile);
-  const directoryPath = join12(getProfilesDir(), profile);
-  if (existsSync11(flatPath)) {
+  const directoryPath = join13(getProfilesDir(), profile);
+  if (existsSync12(flatPath)) {
     rmSync(flatPath);
   }
-  if (existsSync11(directoryPath)) {
+  if (existsSync12(directoryPath)) {
     rmSync(directoryPath, { recursive: true, force: true });
   }
 }
@@ -17681,18 +17673,18 @@ var init_imessage = __esm(() => {
 });
 
 // src/core/connectors/stripe.ts
-import { existsSync as existsSync12 } from "fs";
-import { dirname as dirname4, join as join13 } from "path";
+import { existsSync as existsSync13 } from "fs";
+import { dirname as dirname4, join as join14 } from "path";
 import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL2 } from "url";
 function resolveStripeConnectorDir() {
   const candidates = [
-    join13(__dirname3, "..", "..", "..", "connectors", "stripe"),
-    join13(__dirname3, "..", "..", "connectors", "stripe"),
-    join13(__dirname3, "..", "connectors", "stripe"),
-    join13(process.cwd(), "connectors", "stripe")
+    join14(__dirname3, "..", "..", "..", "connectors", "stripe"),
+    join14(__dirname3, "..", "..", "connectors", "stripe"),
+    join14(__dirname3, "..", "connectors", "stripe"),
+    join14(process.cwd(), "connectors", "stripe")
   ];
   for (const candidate of candidates) {
-    if (existsSync12(candidate)) {
+    if (existsSync13(candidate)) {
       return candidate;
     }
   }
@@ -17740,10 +17732,10 @@ function buildCommandHelp2(spec) {
 `);
 }
 async function loadStripeApiModule() {
-  return await import(pathToFileURL2(join13(CONNECTOR_DIR2, "src", "api", "index.ts")).href);
+  return await import(pathToFileURL2(join14(CONNECTOR_DIR2, "src", "api", "index.ts")).href);
 }
 async function loadStripeConfigModule() {
-  return await import(pathToFileURL2(join13(CONNECTOR_DIR2, "src", "utils", "config.ts")).href);
+  return await import(pathToFileURL2(join14(CONNECTOR_DIR2, "src", "utils", "config.ts")).href);
 }
 function extractGlobalArgs3(args) {
   const remaining = [];
@@ -18589,30 +18581,30 @@ __export(exports_installer, {
   getConnectorDocs: () => getConnectorDocs,
   connectorExists: () => connectorExists
 });
-import { existsSync as existsSync14, mkdirSync as mkdirSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync6, readdirSync as readdirSync9, statSync as statSync4, rmSync as rmSync2 } from "fs";
-import { join as join15, dirname as dirname6 } from "path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync6, readdirSync as readdirSync9, statSync as statSync4, rmSync as rmSync2 } from "fs";
+import { join as join16, dirname as dirname6 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 function resolveConnectorsDir() {
-  const fromBin = join15(__dirname4, "..", "connectors");
-  if (existsSync14(fromBin))
+  const fromBin = join16(__dirname4, "..", "connectors");
+  if (existsSync15(fromBin))
     return fromBin;
-  const fromSrc = join15(__dirname4, "..", "..", "connectors");
-  if (existsSync14(fromSrc))
+  const fromSrc = join16(__dirname4, "..", "..", "connectors");
+  if (existsSync15(fromSrc))
     return fromSrc;
   return fromBin;
 }
 function getProjectConnectorsDir(targetDir) {
-  return join15(targetDir, PROJECT_CONNECTORS_DIRNAME);
+  return join16(targetDir, PROJECT_CONNECTORS_DIRNAME);
 }
 function getEnablementManifestPath(targetDir) {
-  return join15(getProjectConnectorsDir(targetDir), ENABLEMENT_MANIFEST_FILENAME);
+  return join16(getProjectConnectorsDir(targetDir), ENABLEMENT_MANIFEST_FILENAME);
 }
 function getLegacyInstallPath(targetDir, name) {
-  return join15(getProjectConnectorsDir(targetDir), legacyConnectorName(name));
+  return join16(getProjectConnectorsDir(targetDir), legacyConnectorName(name));
 }
 function loadEnablementManifest(targetDir) {
   const manifestPath = getEnablementManifestPath(targetDir);
-  if (!existsSync14(manifestPath)) {
+  if (!existsSync15(manifestPath)) {
     return null;
   }
   try {
@@ -18632,11 +18624,11 @@ function loadEnablementManifest(targetDir) {
 }
 function getLegacyInstalledConnectors(targetDir) {
   const connectorsDir = getProjectConnectorsDir(targetDir);
-  if (!existsSync14(connectorsDir)) {
+  if (!existsSync15(connectorsDir)) {
     return [];
   }
   return readdirSync9(connectorsDir).filter((entry) => {
-    const fullPath = join15(connectorsDir, entry);
+    const fullPath = join16(connectorsDir, entry);
     return entry.startsWith("connect-") && statSync4(fullPath).isDirectory();
   }).map((entry) => entry.replace("connect-", "")).sort();
 }
@@ -18645,7 +18637,7 @@ function getEnabledConnectors(targetDir) {
   return [...new Set([...manifestConnectors, ...getLegacyInstalledConnectors(targetDir)])].sort();
 }
 function updateConnectorsIndex(connectorsDir, connectors18) {
-  const indexPath = join15(connectorsDir, ENABLEMENT_INDEX_FILENAME);
+  const indexPath = join16(connectorsDir, ENABLEMENT_INDEX_FILENAME);
   const connectorList = connectors18.map((connector) => `  "${connector}",`).join(`
 `);
   const content = `/**
@@ -18681,7 +18673,7 @@ function getConnectorPath(name) {
 }
 function connectorExists(name) {
   const normalizedName = normalizeConnectorName(name);
-  return hasInternalConnectorDefinition(normalizedName) || existsSync14(getConnectorPath(normalizedName));
+  return hasInternalConnectorDefinition(normalizedName) || existsSync15(getConnectorPath(normalizedName));
 }
 function installConnector(name, options = {}) {
   const { targetDir = process.cwd(), overwrite = false } = options;
@@ -18714,7 +18706,7 @@ function installConnector(name, options = {}) {
   try {
     const nextEnabled = [...new Set([...installed, normalizedName])].sort();
     writeEnablementManifest(targetDir, nextEnabled);
-    if (overwrite && existsSync14(legacyInstallPath)) {
+    if (overwrite && existsSync15(legacyInstallPath)) {
       rmSync2(legacyInstallPath, { recursive: true });
     }
     return {
@@ -18749,8 +18741,8 @@ function parseConnectorDocs(raw) {
 function getConnectorDocs(name) {
   const normalizedName = normalizeConnectorName(name);
   const connectorPath = getConnectorPath(normalizedName);
-  const claudeMdPath = join15(connectorPath, "CLAUDE.md");
-  if (existsSync14(claudeMdPath)) {
+  const claudeMdPath = join16(connectorPath, "CLAUDE.md");
+  if (existsSync15(claudeMdPath)) {
     return parseConnectorDocs(readFileSync7(claudeMdPath, "utf-8"));
   }
   const internalDocs = getInternalConnectorDefinition(normalizedName)?.docsMarkdown;
@@ -18795,7 +18787,7 @@ function removeConnector(name, targetDir = process.cwd()) {
   const nextEnabled = installed.filter((connector) => connector !== normalizedName);
   writeEnablementManifest(targetDir, nextEnabled);
   const legacyInstallPath = getLegacyInstallPath(targetDir, normalizedName);
-  if (existsSync14(legacyInstallPath)) {
+  if (existsSync15(legacyInstallPath)) {
     rmSync2(legacyInstallPath, { recursive: true });
   }
   return true;
@@ -18809,7 +18801,7 @@ var init_installer = __esm(() => {
 });
 
 // src/lib/lock.ts
-import { openSync, closeSync, unlinkSync, existsSync as existsSync15, statSync as statSync5 } from "fs";
+import { openSync, closeSync, unlinkSync, existsSync as existsSync16, statSync as statSync5 } from "fs";
 import { mkdirSync as mkdirSync10 } from "fs";
 function lockPath(connector) {
   const dir = getConnectorConfigDir(connector);
@@ -18825,7 +18817,7 @@ function isStale(path) {
   }
 }
 function tryAcquire(path) {
-  if (existsSync15(path) && isStale(path)) {
+  if (existsSync16(path) && isStale(path)) {
     try {
       unlinkSync(path);
     } catch {}
@@ -18875,9 +18867,9 @@ var init_lock = __esm(() => {
 });
 
 // src/server/auth.ts
-import { existsSync as existsSync16, readFileSync as readFileSync8, writeFileSync as writeFileSync7, mkdirSync as mkdirSync11, readdirSync as readdirSync10, rmSync as rmSync3, statSync as statSync6 } from "fs";
+import { existsSync as existsSync17, readFileSync as readFileSync8, writeFileSync as writeFileSync7, mkdirSync as mkdirSync11, readdirSync as readdirSync10, rmSync as rmSync3, statSync as statSync6 } from "fs";
 import { randomBytes } from "crypto";
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 function getAuthType(name) {
   name = normalizeConnectorName(name);
   const docs = getConnectorDocs(name);
@@ -18901,8 +18893,8 @@ function getConnectorConfigReadDirs2(name) {
 function getCurrentProfile2(name) {
   name = normalizeConnectorName(name);
   for (const configDir of getConnectorConfigReadDirs2(name)) {
-    const currentProfileFile = join16(configDir, "current_profile");
-    if (existsSync16(currentProfileFile)) {
+    const currentProfileFile = join17(configDir, "current_profile");
+    if (existsSync17(currentProfileFile)) {
       try {
         return readFileSync8(currentProfileFile, "utf-8").trim() || "default";
       } catch {
@@ -18915,14 +18907,14 @@ function getCurrentProfile2(name) {
 function loadProfileConfigFromDir(configDir, profile) {
   let flatConfig = {};
   let dirConfig = {};
-  const profileFile = join16(configDir, "profiles", `${profile}.json`);
-  if (existsSync16(profileFile)) {
+  const profileFile = join17(configDir, "profiles", `${profile}.json`);
+  if (existsSync17(profileFile)) {
     try {
       flatConfig = JSON.parse(readFileSync8(profileFile, "utf-8"));
     } catch {}
   }
-  const profileDirConfig = join16(configDir, "profiles", profile, "config.json");
-  if (existsSync16(profileDirConfig)) {
+  const profileDirConfig = join17(configDir, "profiles", profile, "config.json");
+  if (existsSync17(profileDirConfig)) {
     try {
       dirConfig = JSON.parse(readFileSync8(profileDirConfig, "utf-8"));
     } catch {}
@@ -18942,8 +18934,8 @@ function loadTokens3(name) {
   name = normalizeConnectorName(name);
   const profile = getCurrentProfile2(name);
   for (const configDir of getConnectorConfigReadDirs2(name)) {
-    const tokensFile = join16(configDir, "profiles", profile, "tokens.json");
-    if (existsSync16(tokensFile)) {
+    const tokensFile = join17(configDir, "profiles", profile, "tokens.json");
+    if (existsSync17(tokensFile)) {
       try {
         return JSON.parse(readFileSync8(tokensFile, "utf-8"));
       } catch {
@@ -19038,10 +19030,10 @@ function _saveApiKey(name, key, field) {
   const profile = getCurrentProfile2(name);
   const keyField = field || guessKeyField(name);
   if (keyField === "clientId" || keyField === "clientSecret") {
-    const credentialsFile = join16(configDir, "credentials.json");
+    const credentialsFile = join17(configDir, "credentials.json");
     mkdirSync11(configDir, { recursive: true });
     let creds = {};
-    if (existsSync16(credentialsFile)) {
+    if (existsSync17(credentialsFile)) {
       try {
         creds = JSON.parse(readFileSync8(credentialsFile, "utf-8"));
       } catch {}
@@ -19050,9 +19042,9 @@ function _saveApiKey(name, key, field) {
     writeFileSync7(credentialsFile, JSON.stringify(creds, null, 2));
     return;
   }
-  const profileFile = join16(configDir, "profiles", `${profile}.json`);
-  const profileDir = join16(configDir, "profiles", profile);
-  if (existsSync16(profileFile)) {
+  const profileFile = join17(configDir, "profiles", `${profile}.json`);
+  const profileDir = join17(configDir, "profiles", profile);
+  if (existsSync17(profileFile)) {
     let config = {};
     try {
       config = JSON.parse(readFileSync8(profileFile, "utf-8"));
@@ -19061,10 +19053,10 @@ function _saveApiKey(name, key, field) {
     writeFileSync7(profileFile, JSON.stringify(config, null, 2));
     return;
   }
-  if (existsSync16(profileDir)) {
-    const configFile = join16(profileDir, "config.json");
+  if (existsSync17(profileDir)) {
+    const configFile = join17(profileDir, "config.json");
     let config = {};
-    if (existsSync16(configFile)) {
+    if (existsSync17(configFile)) {
       try {
         config = JSON.parse(readFileSync8(configFile, "utf-8"));
       } catch {}
@@ -19074,7 +19066,7 @@ function _saveApiKey(name, key, field) {
     return;
   }
   mkdirSync11(profileDir, { recursive: true });
-  writeFileSync7(join16(profileDir, "config.json"), JSON.stringify({ [keyField]: key }, null, 2));
+  writeFileSync7(join17(profileDir, "config.json"), JSON.stringify({ [keyField]: key }, null, 2));
 }
 function guessKeyField(name) {
   name = normalizeConnectorName(name);
@@ -19094,8 +19086,8 @@ function guessKeyField(name) {
 function getOAuthConfig(name) {
   name = normalizeConnectorName(name);
   for (const configDir of getConnectorConfigReadDirs2(name)) {
-    const credentialsFile = join16(configDir, "credentials.json");
-    if (existsSync16(credentialsFile)) {
+    const credentialsFile = join17(configDir, "credentials.json");
+    if (existsSync17(credentialsFile)) {
       try {
         const creds = JSON.parse(readFileSync8(credentialsFile, "utf-8"));
         return { clientId: creds.clientId, clientSecret: creds.clientSecret };
@@ -19181,9 +19173,9 @@ function saveOAuthTokens(name, tokens) {
   name = normalizeConnectorName(name);
   const configDir = getConnectorConfigDir2(name);
   const profile = getCurrentProfile2(name);
-  const profileDir = join16(configDir, "profiles", profile);
+  const profileDir = join17(configDir, "profiles", profile);
   mkdirSync11(profileDir, { recursive: true });
-  const tokensFile = join16(profileDir, "tokens.json");
+  const tokensFile = join17(profileDir, "tokens.json");
   writeFileSync7(tokensFile, JSON.stringify(tokens, null, 2), { mode: 384 });
 }
 async function refreshOAuthToken(name) {
@@ -19230,13 +19222,13 @@ function listProfiles4(name) {
   name = normalizeConnectorName(name);
   const seen = new Set;
   for (const configDir of getConnectorConfigReadDirs2(name)) {
-    const profilesDir = join16(configDir, "profiles");
-    if (!existsSync16(profilesDir))
+    const profilesDir = join17(configDir, "profiles");
+    if (!existsSync17(profilesDir))
       continue;
     try {
       const entries = readdirSync10(profilesDir);
       for (const entry of entries) {
-        const fullPath = join16(profilesDir, entry);
+        const fullPath = join17(profilesDir, entry);
         const stat = statSync6(fullPath);
         if (stat.isDirectory()) {
           seen.add(entry);
@@ -19253,24 +19245,24 @@ function switchProfile(name, profile) {
   name = normalizeConnectorName(name);
   const configDir = getConnectorConfigDir2(name);
   mkdirSync11(configDir, { recursive: true });
-  writeFileSync7(join16(configDir, "current_profile"), profile);
+  writeFileSync7(join17(configDir, "current_profile"), profile);
 }
 function deleteProfile2(name, profile) {
   name = normalizeConnectorName(name);
   if (profile === "default")
     return false;
   const configDir = getConnectorConfigDir2(name);
-  const profilesDir = join16(configDir, "profiles");
-  const profileFile = join16(profilesDir, `${profile}.json`);
-  if (existsSync16(profileFile)) {
+  const profilesDir = join17(configDir, "profiles");
+  const profileFile = join17(profilesDir, `${profile}.json`);
+  if (existsSync17(profileFile)) {
     rmSync3(profileFile);
     if (getCurrentProfile2(name) === profile) {
       switchProfile(name, "default");
     }
     return true;
   }
-  const profileDir = join16(profilesDir, profile);
-  if (existsSync16(profileDir)) {
+  const profileDir = join17(profilesDir, profile);
+  if (existsSync17(profileDir)) {
     rmSync3(profileDir, { recursive: true });
     if (getCurrentProfile2(name) === profile) {
       switchProfile(name, "default");
@@ -19339,16 +19331,16 @@ __export(exports_runner, {
   buildEnvWithCredentials: () => buildEnvWithCredentials,
   buildConnectorOperationArgs: () => buildConnectorOperationArgs
 });
-import { existsSync as existsSync17, readdirSync as readdirSync11 } from "fs";
-import { join as join17, dirname as dirname7 } from "path";
+import { existsSync as existsSync18, readdirSync as readdirSync11 } from "fs";
+import { join as join18, dirname as dirname7 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 import { spawn as spawn2 } from "child_process";
 function resolveConnectorsDir2() {
-  const fromBin = join17(__dirname5, "..", "connectors");
-  if (existsSync17(fromBin))
+  const fromBin = join18(__dirname5, "..", "connectors");
+  if (existsSync18(fromBin))
     return fromBin;
-  const fromSrc = join17(__dirname5, "..", "..", "connectors");
-  if (existsSync17(fromSrc))
+  const fromSrc = join18(__dirname5, "..", "..", "connectors");
+  if (existsSync18(fromSrc))
     return fromSrc;
   return fromBin;
 }
@@ -19416,8 +19408,8 @@ function buildEnvWithCredentials(connectorName, baseEnv) {
 function getConnectorCliPath(name) {
   const safeName = normalizeConnectorName(name).replace(/[^a-z0-9-]/g, "");
   const connectorDir = getConnectorPackagePath(CONNECTORS_DIR2, safeName);
-  const cliPath = join17(connectorDir, "src", "cli", "index.ts");
-  if (existsSync17(cliPath))
+  const cliPath = join18(connectorDir, "src", "cli", "index.ts");
+  if (existsSync18(cliPath))
     return cliPath;
   return null;
 }
@@ -22733,6 +22725,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;
@@ -22926,27 +22921,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 = [];
@@ -22961,7 +23006,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);
@@ -22975,7 +23020,10 @@ var require_utils3 = __commonJS((exports, module) => {
   module.exports = {
     nonSimpleDomain,
     recomposeAuthority,
-    normalizeComponentEncoding,
+    reescapeHostDelimiters,
+    normalizePercentEncoding,
+    normalizePathEncoding,
+    escapePreservingEscapes,
     removeDotSegments,
     isIPv4,
     isUUID,
@@ -23160,11 +23208,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);
     }
@@ -23230,19 +23278,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 = {
@@ -23268,12 +23306,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) {
@@ -23308,7 +23346,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,
@@ -23319,6 +23366,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) {
@@ -23339,6 +23387,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) {
@@ -23377,14 +23430,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) {
@@ -23393,7 +23450,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,
@@ -23528,7 +23607,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;
@@ -24269,6 +24348,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}"`,
@@ -24281,10 +24361,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;
@@ -26260,7 +26348,7 @@ var init_usage = __esm(() => {
 });
 
 // src/server/serve.ts
-import { existsSync as existsSync19, readdirSync as readdirSync12, readFileSync as readFileSync10, writeFileSync as writeFileSync8, mkdirSync as mkdirSync12 } from "fs";
+import { existsSync as existsSync20, readdirSync as readdirSync12, readFileSync as readFileSync10, writeFileSync as writeFileSync8, mkdirSync as mkdirSync12 } from "fs";
 
 // src/db/agents.ts
 init_database();
@@ -26501,13 +26589,13 @@ async function runWorkflow(workflow) {
 
 // src/server/serve.ts
 init_database();
-import { join as join19, dirname as dirname8, extname, basename as basename3 } from "path";
+import { join as join20, dirname as dirname8, extname, basename as basename3 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 
 // src/lib/registry.ts
 init_builtins();
-import { existsSync as existsSync13, readFileSync as readFileSync6 } from "fs";
-import { join as join14, dirname as dirname5 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync6 } from "fs";
+import { join as join15, dirname as dirname5 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/lib/fuzzy.ts
@@ -32784,16 +32872,16 @@ function loadConnectorVersions() {
   versionsLoaded = true;
   const thisDir = dirname5(fileURLToPath3(import.meta.url));
   const candidates = [
-    join14(thisDir, "..", "connectors"),
-    join14(thisDir, "..", "..", "connectors")
+    join15(thisDir, "..", "connectors"),
+    join15(thisDir, "..", "..", "connectors")
   ];
-  const connectorsDir = candidates.find((d) => existsSync13(d));
+  const connectorsDir = candidates.find((d) => existsSync14(d));
   if (!connectorsDir)
     return;
   for (const connector of CONNECTORS) {
     try {
-      const pkgPath = join14(getConnectorPackagePath(connectorsDir, connector.name), "package.json");
-      if (existsSync13(pkgPath)) {
+      const pkgPath = join15(getConnectorPackagePath(connectorsDir, connector.name), "package.json");
+      if (existsSync14(pkgPath)) {
         const pkg = JSON.parse(readFileSync6(pkgPath, "utf-8"));
         connector.version = pkg.version || "0.0.0";
         continue;
@@ -36211,7 +36299,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");
@@ -37351,7 +37439,7 @@ var AssertObjectSchema = custom3((v) => v !== null && (typeof v === "object" ||
 var ProgressTokenSchema = union([string2(), number2().int()]);
 var CursorSchema = string2();
 var TaskCreationParamsSchema = looseObject({
-  ttl: union([number2(), _null3()]).optional(),
+  ttl: number2().optional(),
   pollInterval: number2().optional()
 });
 var TaskMetadataSchema = object({
@@ -37505,7 +37593,8 @@ var ClientCapabilitiesSchema = object({
   roots: object({
     listChanged: boolean2().optional()
   }).optional(),
-  tasks: ClientTasksCapabilitySchema.optional()
+  tasks: ClientTasksCapabilitySchema.optional(),
+  extensions: record(string2(), AssertObjectSchema).optional()
 });
 var InitializeRequestParamsSchema = BaseRequestParamsSchema.extend({
   protocolVersion: string2(),
@@ -37531,7 +37620,8 @@ var ServerCapabilitiesSchema = object({
   tools: object({
     listChanged: boolean2().optional()
   }).optional(),
-  tasks: ServerTasksCapabilitySchema.optional()
+  tasks: ServerTasksCapabilitySchema.optional(),
+  extensions: record(string2(), AssertObjectSchema).optional()
 });
 var InitializeResultSchema = ResultSchema.extend({
   protocolVersion: string2(),
@@ -37646,6 +37736,7 @@ var ResourceSchema = object({
   uri: string2(),
   description: optional(string2()),
   mimeType: optional(string2()),
+  size: optional(number2()),
   annotations: AnnotationsSchema.optional(),
   _meta: optional(looseObject({}))
 });
@@ -38295,6 +38386,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);
@@ -38312,6 +38404,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;
@@ -38346,6 +38439,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 {
@@ -38353,9 +38447,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");
         }
       }
@@ -38415,11 +38511,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: {
@@ -38439,14 +38537,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) {
@@ -38455,6 +38556,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");
         }
       }
@@ -38466,14 +38568,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?.();
@@ -38591,13 +38696,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;
@@ -38605,6 +38713,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;
@@ -40371,6 +40480,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();
     }
@@ -40501,7 +40614,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) {
@@ -41050,6 +41165,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);
   }
@@ -42105,6 +42276,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();
       }
     }
@@ -42197,6 +42371,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) {
@@ -42527,8 +42704,8 @@ init_zod2();
 init_auth();
 init_database();
 init_connector_resolver();
-import { existsSync as existsSync18, readFileSync as readFileSync9 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync19, readFileSync as readFileSync9 } from "fs";
+import { join as join19 } from "path";
 import { spawn as spawn3 } from "child_process";
 function registerAuthTools(server, stripped) {
   server.registerTool("connector_auth_status", {
@@ -42664,7 +42841,7 @@ function registerAuthTools(server, stripped) {
     const oauthUrl = `http://localhost:${serverPort}/oauth/${name}/start`;
     if (noBrowser) {
       const connectorsHome = getConnectorsHome();
-      const tokenPaths = getConnectorConfigReadDirs(name, connectorsHome).map((dir) => join18(dir, "profiles", "default", "tokens.json"));
+      const tokenPaths = getConnectorConfigReadDirs(name, connectorsHome).map((dir) => join19(dir, "profiles", "default", "tokens.json"));
       let serverRunning = false;
       try {
         await fetch(`http://localhost:${serverPort}/api/connectors`);
@@ -42683,7 +42860,7 @@ function registerAuthTools(server, stripped) {
       const maxAttempts = 120;
       while (attempts < maxAttempts) {
         await new Promise((resolve) => setTimeout(resolve, 500));
-        if (tokenPaths.some((tokensPath) => existsSync18(tokensPath))) {
+        if (tokenPaths.some((tokensPath) => existsSync19(tokensPath))) {
           break;
         }
         attempts++;
@@ -42702,7 +42879,7 @@ function registerAuthTools(server, stripped) {
         };
       }
       try {
-        const tokensPath = tokenPaths.find((path) => existsSync18(path)) ?? tokenPaths[0];
+        const tokensPath = tokenPaths.find((path) => existsSync19(path)) ?? tokenPaths[0];
         const tokenData = JSON.parse(readFileSync9(tokensPath, "utf-8"));
         return {
           content: [{
@@ -43225,20 +43402,20 @@ function resolveDashboardDir() {
   const candidates = [];
   try {
     const scriptDir = dirname8(fileURLToPath6(import.meta.url));
-    candidates.push(join19(scriptDir, "..", "dashboard", "dist"));
-    candidates.push(join19(scriptDir, "..", "..", "dashboard", "dist"));
+    candidates.push(join20(scriptDir, "..", "dashboard", "dist"));
+    candidates.push(join20(scriptDir, "..", "..", "dashboard", "dist"));
   } catch {}
   if (process.argv[1]) {
     const mainDir = dirname8(process.argv[1]);
-    candidates.push(join19(mainDir, "..", "dashboard", "dist"));
-    candidates.push(join19(mainDir, "..", "..", "dashboard", "dist"));
+    candidates.push(join20(mainDir, "..", "dashboard", "dist"));
+    candidates.push(join20(mainDir, "..", "..", "dashboard", "dist"));
   }
-  candidates.push(join19(process.cwd(), "dashboard", "dist"));
+  candidates.push(join20(process.cwd(), "dashboard", "dist"));
   for (const candidate of candidates) {
-    if (existsSync19(candidate))
+    if (existsSync20(candidate))
       return candidate;
   }
-  return join19(process.cwd(), "dashboard", "dist");
+  return join20(process.cwd(), "dashboard", "dist");
 }
 var MIME_TYPES = {
   ".html": "text/html; charset=utf-8",
@@ -43337,7 +43514,7 @@ function oauthPage(type, title, message, hint, extra) {
   </body></html>`;
 }
 function serveStaticFile(filePath) {
-  if (!existsSync19(filePath))
+  if (!existsSync20(filePath))
     return null;
   const ext = extname(filePath);
   const contentType = MIME_TYPES[ext] || "application/octet-stream";
@@ -43374,7 +43551,7 @@ async function startServer(requestedPort, options) {
   const strict = options?.strict ?? false;
   loadConnectorVersions();
   const dashboardDir = resolveDashboardDir();
-  const dashboardExists = existsSync19(dashboardDir);
+  const dashboardExists = existsSync20(dashboardDir);
   if (!dashboardExists) {
     console.error(`
 Dashboard not found at: ${dashboardDir}`);
@@ -43805,8 +43982,8 @@ ${result.stderr}`;
           const profiles = listProfiles4(name);
           let current = "default";
           for (const configDir of getConnectorConfigReadDirs(name)) {
-            const currentProfileFile = join19(configDir, "current_profile");
-            if (existsSync19(currentProfileFile)) {
+            const currentProfileFile = join20(configDir, "current_profile");
+            if (existsSync20(currentProfileFile)) {
               try {
                 current = readFileSync10(currentProfileFile, "utf-8").trim() || "default";
               } catch {}
@@ -43859,25 +44036,25 @@ ${result.stderr}`;
         try {
           const connectDir = getConnectorsHome();
           const result = {};
-          if (existsSync19(connectDir)) {
+          if (existsSync20(connectDir)) {
             for (const connectorName of listConfiguredConnectorNames(connectDir)) {
               const profiles = {};
               for (const configDir of [...getConnectorConfigReadDirs(connectorName, connectDir)].reverse()) {
-                const profilesDir = join19(configDir, "profiles");
-                if (!existsSync19(profilesDir))
+                const profilesDir = join20(configDir, "profiles");
+                if (!existsSync20(profilesDir))
                   continue;
                 const profileEntries = readdirSync12(profilesDir, { withFileTypes: true });
                 for (const pEntry of profileEntries) {
                   if (pEntry.isFile() && pEntry.name.endsWith(".json")) {
                     const profileName = basename3(pEntry.name, ".json");
                     try {
-                      const config2 = JSON.parse(readFileSync10(join19(profilesDir, pEntry.name), "utf-8"));
+                      const config2 = JSON.parse(readFileSync10(join20(profilesDir, pEntry.name), "utf-8"));
                       profiles[profileName] = config2;
                     } catch {}
                   }
                   if (pEntry.isDirectory()) {
-                    const configPath = join19(profilesDir, pEntry.name, "config.json");
-                    if (existsSync19(configPath)) {
+                    const configPath = join20(profilesDir, pEntry.name, "config.json");
+                    if (existsSync20(configPath)) {
                       try {
                         const config2 = JSON.parse(readFileSync10(configPath, "utf-8"));
                         profiles[pEntry.name] = config2;
@@ -43922,12 +44099,12 @@ ${result.stderr}`;
             if (!data.profiles || typeof data.profiles !== "object")
               continue;
             const connectorDir = getConnectorConfigDir(connectorName, connectDir);
-            const profilesDir = join19(connectorDir, "profiles");
+            const profilesDir = join20(connectorDir, "profiles");
             for (const [profileName, config2] of Object.entries(data.profiles)) {
               if (!config2 || typeof config2 !== "object")
                 continue;
               mkdirSync12(profilesDir, { recursive: true });
-              const profileFile = join19(profilesDir, `${profileName}.json`);
+              const profileFile = join20(profilesDir, `${profileName}.json`);
               writeFileSync8(profileFile, JSON.stringify(config2, null, 2));
               imported++;
             }
@@ -43983,12 +44160,12 @@ ${result.stderr}`;
       }
       if (dashboardExists && (method === "GET" || method === "HEAD")) {
         if (path !== "/") {
-          const filePath = join19(dashboardDir, path);
+          const filePath = join20(dashboardDir, path);
           const res2 = serveStaticFile(filePath);
           if (res2)
             return res2;
         }
-        const indexPath = join19(dashboardDir, "index.html");
+        const indexPath = join20(dashboardDir, "index.html");
         const res = serveStaticFile(indexPath);
         if (res)
           return res;