@hasna/connectors 1.4.5 → 1.4.6

package/bin/mcp.js

@@ -4999,87 +4999,72 @@ Commands:
   });
 });
 
-// ../../node_modules/.bun/@hasna+paths@0.1.0/node_modules/@hasna/paths/dist/index.js
+// src/lib/paths.ts
+import { existsSync as existsSync2 } from "fs";
 import { homedir } from "os";
-import { join as join2 } from "path";
-function assertApp(app) {
+import { join as join2, resolve } from "path";
+import { homedir as pathsResolverHomedir } from "os";
+import { join as pathsResolverJoin } from "path";
+function pathsResolverAssertApp(app) {
   if (typeof app !== "string" || app.length === 0) {
     throw new TypeError("paths: app must be a non-empty string");
   }
-  if (!APP_SLUG_RE.test(app)) {
+  if (!PATHS_RESOLVER_APP_SLUG_RE.test(app)) {
     throw new TypeError(`paths: invalid app slug "${app}" \u2014 expected lowercase kebab-case ([a-z0-9]+(-[a-z0-9]+)*)`);
   }
 }
-function envOf(options) {
-  return options.env ?? process.env;
-}
-function envValue(options, kind) {
-  const value = envOf(options)[KIND_ENV[kind]];
-  return typeof value === "string" && value.length > 0 ? value : undefined;
-}
-function isMacOS(platform) {
-  return platform === "darwin";
+function pathsResolverAssertKind(kind) {
+  if (!Object.keys(PATHS_RESOLVER_KIND_ENV).includes(kind)) {
+    throw new TypeError(`paths: invalid path kind "${kind}" \u2014 expected one of ${Object.keys(PATHS_RESOLVER_KIND_ENV).join(", ")}`);
+  }
 }
-function baseDir(kind, options) {
-  const override = envValue(options, kind);
-  if (override)
+function pathsResolverBaseDir(kind, options) {
+  pathsResolverAssertKind(kind);
+  const env = options.env ?? process.env;
+  const override = env[PATHS_RESOLVER_KIND_ENV[kind]];
+  if (typeof override === "string" && override.length > 0)
     return override;
-  const home = options.home ?? homedir();
+  const home = options.home ?? pathsResolverHomedir();
   const platform = options.platform ?? process.platform;
-  if (isMacOS(platform)) {
+  if (platform === "darwin") {
     switch (kind) {
       case "config":
       case "data":
-        return join2(home, "Library", "Application Support", "Hasna");
+        return pathsResolverJoin(home, "Library", "Application Support", "Hasna");
       case "cache":
-        return join2(home, "Library", "Caches", "Hasna");
+        return pathsResolverJoin(home, "Library", "Caches", "Hasna");
       case "state":
-        return join2(home, "Library", "Logs", "Hasna");
+        return pathsResolverJoin(home, "Library", "Logs", "Hasna");
     }
   }
   switch (kind) {
     case "config":
-      return join2(home, ".config", "hasna");
+      return pathsResolverJoin(home, ".config", "hasna");
     case "data":
-      return join2(home, ".local", "share", "hasna");
+      return pathsResolverJoin(home, ".local", "share", "hasna");
     case "state":
-      return join2(home, ".local", "state", "hasna");
+      return pathsResolverJoin(home, ".local", "state", "hasna");
     case "cache":
-      return join2(home, ".cache", "hasna");
+      return pathsResolverJoin(home, ".cache", "hasna");
   }
 }
-function resolvePath(kind, options) {
-  assertApp(options.app);
-  const appSegment = options.internal === true ? join2("internal", options.app) : options.app;
-  return join2(baseDir(kind, options), appSegment);
+function pathsResolverResolve(kind, options) {
+  pathsResolverAssertApp(options.app);
+  const appSegment = options.internal === true ? pathsResolverJoin("internal", options.app) : options.app;
+  return pathsResolverJoin(pathsResolverBaseDir(kind, options), appSegment);
 }
 function dataDir(options) {
-  return resolvePath("data", options);
+  return pathsResolverResolve("data", options);
 }
-var KIND_ENV, APP_SLUG_RE;
-var init_dist = __esm(() => {
-  KIND_ENV = {
-    config: "HASNA_CONFIG_HOME",
-    data: "HASNA_DATA_HOME",
-    state: "HASNA_STATE_HOME",
-    cache: "HASNA_CACHE_HOME"
-  };
-  APP_SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-});
-
-// src/lib/paths.ts
-import { existsSync as existsSync2 } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join3, resolve } from "path";
 function envOr(name, fallback) {
   const value = process.env[name]?.trim();
   return value ? value : fallback;
 }
 function effectiveHome() {
-  return process.env["HOME"] || process.env["USERPROFILE"] || homedir2();
+  return process.env["HOME"] || process.env["USERPROFILE"] || homedir();
 }
 function legacyHomeDir() {
-  return join3(effectiveHome(), ".hasna", "connectors");
+  return join2(effectiveHome(), ".hasna", "connectors");
 }
 function resolverHome() {
   return dataDir({
@@ -5091,7 +5076,7 @@ function adoptResolverHome(resolved, env = process.env) {
   const dataOverride = env.HASNA_DATA_HOME;
   if (typeof dataOverride === "string" && dataOverride.trim().length > 0)
     return true;
-  return existsSync2(join3(resolved, "connectors.db"));
+  return existsSync2(join2(resolved, "connectors.db"));
 }
 function exactConnectorsHome() {
   const home = envOr("HASNA_CONNECTORS_DIR", "");
@@ -5104,13 +5089,20 @@ function connectorsHome() {
   const resolved = resolverHome();
   return adoptResolverHome(resolved) ? resolve(resolved) : resolve(legacyHomeDir());
 }
+var PATHS_RESOLVER_KIND_ENV, PATHS_RESOLVER_APP_SLUG_RE;
 var init_paths = __esm(() => {
-  init_dist();
+  PATHS_RESOLVER_KIND_ENV = {
+    config: "HASNA_CONFIG_HOME",
+    data: "HASNA_DATA_HOME",
+    state: "HASNA_STATE_HOME",
+    cache: "HASNA_CACHE_HOME"
+  };
+  PATHS_RESOLVER_APP_SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 });
 
 // src/core/connectors/gmail.ts
 import { existsSync as existsSync3, mkdirSync, readFileSync, readdirSync, writeFileSync } from "fs";
-import { basename, join as join4 } from "path";
+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",
@@ -5147,7 +5139,7 @@ async function replyToMessage(profile, messageId, input) {
 }
 async function downloadAttachments(profile, input) {
   const messageId = getMessageId(input);
-  const outputDir = input.dir ?? input.outputDir ?? join4(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,
@@ -5159,7 +5151,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 = join4(outputDir, filename);
+    const path = join3(outputDir, filename);
     const buffer = Buffer.from(data.data, "base64url");
     writeFileSync(path, buffer);
     downloaded.push({
@@ -5275,8 +5267,8 @@ async function refreshAccessToken(profile, currentTokens) {
 }
 function listProfiles() {
   const profiles = new Set;
-  for (const baseDir2 of configDirs()) {
-    const profilesDir = join4(baseDir2, "profiles");
+  for (const baseDir of configDirs()) {
+    const profilesDir = join3(baseDir, "profiles");
     if (!existsSync3(profilesDir))
       continue;
     for (const entry of readdirSync(profilesDir, { withFileTypes: true })) {
@@ -5293,10 +5285,10 @@ function loadCredentials(profile) {
   const envClientSecret = process.env.GMAIL_CLIENT_SECRET ?? process.env.GOOGLE_CLIENT_SECRET;
   if (envClientId && envClientSecret)
     return { clientId: envClientId, clientSecret: envClientSecret };
-  for (const baseDir2 of configDirs()) {
+  for (const baseDir of configDirs()) {
     const credentials = {
-      ...readJson(join4(baseDir2, "credentials.json")),
-      ...readJson(join4(baseDir2, "profiles", profile, "config.json"))
+      ...readJson(join3(baseDir, "credentials.json")),
+      ...readJson(join3(baseDir, "profiles", profile, "config.json"))
     };
     if (credentials.clientId || credentials.clientSecret)
       return credentials;
@@ -5304,28 +5296,28 @@ function loadCredentials(profile) {
   return {};
 }
 function loadTokens(profile) {
-  for (const baseDir2 of configDirs()) {
-    const fromProfile = readJson(join4(baseDir2, "profiles", profile, "tokens.json"));
+  for (const baseDir of configDirs()) {
+    const fromProfile = readJson(join3(baseDir, "profiles", profile, "tokens.json"));
     if (fromProfile)
       return fromProfile;
-    const flat = readJson(join4(baseDir2, "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 baseDir2 = configDirs().find((dir) => existsSync3(dir)) ?? configDirs()[0];
-  const profileDir = join4(baseDir2, "profiles", profile);
+  const baseDir = configDirs().find((dir) => existsSync3(dir)) ?? configDirs()[0];
+  const profileDir = join3(baseDir, "profiles", profile);
   mkdirSync(profileDir, { recursive: true });
-  writeFileSync(join4(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 baseDir2 = connectorsHome();
-  return [join4(baseDir2, "gmail"), join4(baseDir2, "connect-gmail")];
+  const baseDir = connectorsHome();
+  return [join3(baseDir, "gmail"), join3(baseDir, "connect-gmail")];
 }
 function readJson(path) {
   if (!existsSync3(path))
@@ -5580,7 +5572,7 @@ var init_gmail = __esm(() => {
 
 // src/core/connectors/googledrive.ts
 import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync2, readdirSync as readdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import { basename as basename2, join as join5 } from "path";
+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();
@@ -5647,8 +5639,8 @@ async function refreshAccessToken2(profile, currentTokens) {
 }
 function listProfiles2() {
   const profiles = new Set;
-  for (const baseDir2 of configDirs2()) {
-    const profilesDir = join5(baseDir2, "profiles");
+  for (const baseDir of configDirs2()) {
+    const profilesDir = join4(baseDir, "profiles");
     if (!existsSync4(profilesDir))
       continue;
     for (const entry of readdirSync2(profilesDir, { withFileTypes: true })) {
@@ -5694,10 +5686,10 @@ function loadCredentials2(profile) {
   const envClientSecret = process.env.GOOGLE_CLIENT_SECRET;
   if (envClientId && envClientSecret)
     return { clientId: envClientId, clientSecret: envClientSecret };
-  for (const baseDir2 of configDirs2()) {
+  for (const baseDir of configDirs2()) {
     const credentials = {
-      ...readJson2(join5(baseDir2, "credentials.json")),
-      ...readJson2(join5(baseDir2, "profiles", profile, "config.json"))
+      ...readJson2(join4(baseDir, "credentials.json")),
+      ...readJson2(join4(baseDir, "profiles", profile, "config.json"))
     };
     if (credentials.clientId || credentials.clientSecret)
       return credentials;
@@ -5705,28 +5697,28 @@ function loadCredentials2(profile) {
   return {};
 }
 function loadTokens2(profile) {
-  for (const baseDir2 of configDirs2()) {
-    const fromProfile = readJson2(join5(baseDir2, "profiles", profile, "tokens.json"));
+  for (const baseDir of configDirs2()) {
+    const fromProfile = readJson2(join4(baseDir, "profiles", profile, "tokens.json"));
     if (fromProfile)
       return fromProfile;
-    const flat = readJson2(join5(baseDir2, "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 baseDir2 = configDirs2().find((dir) => existsSync4(dir)) ?? configDirs2()[0];
-  const profileDir = join5(baseDir2, "profiles", profile);
+  const baseDir = configDirs2().find((dir) => existsSync4(dir)) ?? configDirs2()[0];
+  const profileDir = join4(baseDir, "profiles", profile);
   mkdirSync2(profileDir, { recursive: true });
-  writeFileSync2(join5(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 baseDir2 = connectorsHome();
-  return [join5(baseDir2, "googledrive"), join5(baseDir2, "connect-googledrive")];
+  const baseDir = connectorsHome();
+  return [join4(baseDir, "googledrive"), join4(baseDir, "connect-googledrive")];
 }
 function readJson2(path) {
   if (!existsSync4(path))
@@ -5913,7 +5905,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/connectors",
-    version: "1.4.5",
+    version: "1.4.6",
     description: "Open source connector library - Install API connectors with a single command",
     type: "module",
     bin: {
@@ -5924,7 +5916,6 @@ var init_package = __esm(() => {
     files: [
       "bin/",
       "dist/",
-      "dashboard/dist/",
       "connectors/",
       "README.md",
       "!connectors/**/.test-home/**",
@@ -5944,20 +5935,23 @@ var init_package = __esm(() => {
       "./social": {
         import: "./dist/social/index.js",
         types: "./dist/.types/src/social/index.d.ts"
+      },
+      "./sdk": {
+        types: "./dist/sdk/index.d.ts",
+        import: "./dist/sdk/index.js",
+        default: "./dist/sdk/index.js"
       }
     },
     main: "./dist/index.js",
     types: "./dist/index.d.ts",
     scripts: {
-      build: "cd dashboard && bun run build && cd .. && bun build ./src/cli/index.tsx --outdir ./bin --target bun --external ink --external react --external chalk --external conf --external @hasna/events && bun build ./src/mcp/index.ts --outfile ./bin/mcp.js --target bun && bun build ./src/server/index.ts --outfile ./bin/serve.js --target bun && bun build ./src/index.ts --outdir ./dist --target bun && bun build ./src/social/index.ts --outfile ./dist/social/index.js --target bun && tsc --emitDeclarationOnly --outDir ./dist && tsc -p tsconfig.social.json",
-      "build:dashboard": "cd dashboard && bun run build",
-      postinstall: 'mkdir -p $HOME/.hasna/connectors 2>/dev/null || true; [ "$SKIP_DASHBOARD" = "1" ] || [ ! -f dashboard/package.json ] || [ -d dashboard/node_modules ] || (cd dashboard && bun install)',
+      build: "bun build ./src/cli/index.tsx --outdir ./bin --target bun --external ink --external react --external chalk --external conf --external @hasna/events && bun build ./src/mcp/index.ts --outfile ./bin/mcp.js --target bun && bun build ./src/server/index.ts --outfile ./bin/serve.js --target bun && bun build ./src/index.ts --outdir ./dist --target bun && bun build ./src/social/index.ts --outfile ./dist/social/index.js --target bun && bun build ./src/sdk/index.ts --outfile ./dist/sdk/index.js --target bun && tsc --emitDeclarationOnly --outDir ./dist && tsc -p tsconfig.social.json",
+      postinstall: "mkdir -p $HOME/.hasna/connectors 2>/dev/null || true",
       dev: "bun run ./src/cli/index.tsx",
       "check:package-secrets": "bun run scripts/check-package-secrets.ts",
       typecheck: "tsc --noEmit && tsc -p tsconfig.social.json --noEmit",
       test: "bun run build && bun test",
       "secrets:scan:npmrc": "bun run scripts/scan-npmrc-auth.mjs",
-      "sdk:build": "cd sdk && bun run build",
       prepublishOnly: "bun run secrets:scan:npmrc && bun run build && bun run check:package-secrets && bun test",
       prepack: "bun run build && bun run check:package-secrets"
     },
@@ -5977,7 +5971,7 @@ var init_package = __esm(() => {
     author: "Hasna",
     license: "Apache-2.0",
     devDependencies: {
-      "@types/bun": "latest",
+      "@types/bun": "1.3.14",
       "@types/react": "^18.2.0",
       "ink-testing-library": "^4.0.0",
       typescript: "^5",
@@ -5985,7 +5979,6 @@ var init_package = __esm(() => {
     },
     dependencies: {
       "@hasna/events": "0.1.8",
-      "@hasna/paths": "0.1.0",
       "@modelcontextprotocol/sdk": "^1.26.0",
       chalk: "^5.3.0",
       commander: "^12.1.0",
@@ -6008,11 +6001,12 @@ var init_package = __esm(() => {
     },
     repository: {
       type: "git",
-      url: "git+https://github.com/hasna/connectors.git"
+      url: "https://github.com/hasna/apps.git",
+      directory: "apps/connectors"
     },
-    homepage: "https://github.com/hasna/connectors#readme",
+    homepage: "https://github.com/hasna/apps/tree/main/apps/connectors#readme",
     bugs: {
-      url: "https://github.com/hasna/connectors/issues"
+      url: "https://github.com/hasna/apps/issues"
     }
   };
 });
@@ -6086,7 +6080,7 @@ __export(exports_database, {
   closeDatabase: () => closeDatabase,
   SqliteAdapter: () => SqliteAdapter
 });
-import { dirname as dirname2, join as join6 } from "path";
+import { dirname as dirname2, join as join5 } from "path";
 import { mkdirSync as mkdirSync3, existsSync as existsSync5, readdirSync as readdirSync3, copyFileSync, statSync } from "fs";
 function mergeDirectoryContents(sourceDir, targetDir) {
   if (!existsSync5(sourceDir)) {
@@ -6094,8 +6088,8 @@ function mergeDirectoryContents(sourceDir, targetDir) {
   }
   mkdirSync3(targetDir, { recursive: true });
   for (const entry of readdirSync3(sourceDir)) {
-    const sourcePath = join6(sourceDir, entry);
-    const targetPath = join6(targetDir, entry);
+    const sourcePath = join5(sourceDir, entry);
+    const targetPath = join5(targetDir, entry);
     try {
       const sourceStat = statSync(sourcePath);
       if (sourceStat.isDirectory()) {
@@ -6111,7 +6105,7 @@ function mergeDirectoryContents(sourceDir, targetDir) {
 function getConnectorsHome() {
   const newDir = connectorsHome();
   const home = effectiveHome();
-  const legacyDirs = [join6(home, ".connectors"), join6(home, ".connect")];
+  const legacyDirs = [join5(home, ".connectors"), join5(home, ".connect")];
   mkdirSync3(newDir, { recursive: true });
   for (const legacyDir of legacyDirs) {
     try {
@@ -6261,12 +6255,12 @@ var init_database = __esm(() => {
   init_sqlite_adapter();
   init_paths();
   DB_DIR = getConnectorsHome();
-  DB_PATH = join6(DB_DIR, "connectors.db");
+  DB_PATH = join5(DB_DIR, "connectors.db");
 });
 
 // src/lib/connector-resolver.ts
 import { existsSync as existsSync6, readdirSync as readdirSync4, statSync as statSync2 } from "fs";
-import { join as join7 } from "path";
+import { join as join6 } from "path";
 function stripLegacyPrefix(name) {
   return name.startsWith(LEGACY_CONNECTOR_PREFIX) ? name.slice(LEGACY_CONNECTOR_PREFIX.length) : name;
 }
@@ -6309,7 +6303,7 @@ function connectorPackageDirNames(name) {
 function resolveConnectorPackagePath(connectorsDir, name) {
   const resolution = resolveConnectorName(name);
   const dirNames = connectorPackageDirNames(name);
-  const checkedPaths = dirNames.map((dirName) => join7(connectorsDir, dirName));
+  const checkedPaths = dirNames.map((dirName) => join6(connectorsDir, dirName));
   const existingPath = checkedPaths.find((path) => existsSync6(path)) ?? null;
   const existingDirName = existingPath ? dirNames[checkedPaths.indexOf(existingPath)] : null;
   return {
@@ -6329,8 +6323,8 @@ function getConnectorPackagePath(connectorsDir, name) {
 function resolveConnectorConfigPaths(name, connectorsHome2 = getConnectorsHome()) {
   const resolution = resolveConnectorName(name);
   const preferredDirName = resolution.canonicalName || resolution.legacyName;
-  const preferredPath = join7(connectorsHome2, preferredDirName);
-  const legacyPath = join7(connectorsHome2, resolution.legacyName);
+  const preferredPath = join6(connectorsHome2, preferredDirName);
+  const legacyPath = join6(connectorsHome2, resolution.legacyName);
   const paths = preferredPath === legacyPath ? [preferredPath] : [preferredPath, legacyPath];
   const existingPaths = paths.filter((path) => existsSync6(path));
   return {
@@ -6369,7 +6363,7 @@ import {
   statSync as statSync3,
   writeFileSync as writeFileSync3
 } from "fs";
-import { join as join8 } from "path";
+import { join as join7 } from "path";
 function buildRootHelp(specs) {
   const lines = [
     "Usage: connect-imessage [options] [command]",
@@ -6420,11 +6414,11 @@ function getConfigReadDirs() {
   return getConnectorConfigReadDirs(CONNECTOR_NAME);
 }
 function getProfilesDir() {
-  return join8(getConfigDir(), "profiles");
+  return join7(getConfigDir(), "profiles");
 }
 function getCurrentProfile() {
   for (const configDir of getConfigReadDirs()) {
-    const currentProfileFile = join8(configDir, "current_profile");
+    const currentProfileFile = join7(configDir, "current_profile");
     if (!existsSync7(currentProfileFile))
       continue;
     try {
@@ -6438,16 +6432,16 @@ function getCurrentProfile() {
 function setCurrentProfile(profile) {
   const configDir = getConfigDir();
   mkdirSync4(configDir, { recursive: true });
-  writeFileSync3(join8(configDir, "current_profile"), profile);
+  writeFileSync3(join7(configDir, "current_profile"), profile);
 }
 function getFlatProfilePath(profile) {
-  return join8(getProfilesDir(), `${profile}.json`);
+  return join7(getProfilesDir(), `${profile}.json`);
 }
 function getFlatProfileReadPaths(profile) {
-  return getConfigReadDirs().map((dir) => join8(dir, "profiles", `${profile}.json`));
+  return getConfigReadDirs().map((dir) => join7(dir, "profiles", `${profile}.json`));
 }
 function getDirectoryProfileReadPaths(profile) {
-  return getConfigReadDirs().map((dir) => join8(dir, "profiles", profile, "config.json"));
+  return getConfigReadDirs().map((dir) => join7(dir, "profiles", profile, "config.json"));
 }
 function loadJsonFile(path) {
   try {
@@ -6484,17 +6478,17 @@ function profileExists(profile) {
   if (profile === "default") {
     return true;
   }
-  return getFlatProfileReadPaths(profile).some((path) => existsSync7(path)) || getConfigReadDirs().some((dir) => existsSync7(join8(dir, "profiles", profile)));
+  return getFlatProfileReadPaths(profile).some((path) => existsSync7(path)) || getConfigReadDirs().some((dir) => existsSync7(join7(dir, "profiles", profile)));
 }
 function listProfiles3() {
   const seen = new Set(["default"]);
   for (const configDir of getConfigReadDirs()) {
-    const profilesDir = join8(configDir, "profiles");
+    const profilesDir = join7(configDir, "profiles");
     if (!existsSync7(profilesDir))
       continue;
     try {
       for (const entry of readdirSync5(profilesDir)) {
-        const fullPath = join8(profilesDir, entry);
+        const fullPath = join7(profilesDir, entry);
         const stat = statSync3(fullPath);
         if (stat.isDirectory()) {
           seen.add(entry);
@@ -6516,7 +6510,7 @@ function createProfile(profile, config2 = {}) {
 }
 function clearProfile(profile = getCurrentProfile()) {
   const flatPath = getFlatProfilePath(profile);
-  const directoryPath = join8(getProfilesDir(), profile);
+  const directoryPath = join7(getProfilesDir(), profile);
   if (existsSync7(flatPath)) {
     rmSync(flatPath);
   }
@@ -7153,7 +7147,7 @@ API Key authentication is optional and depends on the bridge deployment. A bridg
 
 ## Data Storage
 
-Connector state is stored under \`~/.hasna/connectors/imessage/\`. Profiles are read from both \`profiles/<name>.json\` and \`profiles/<name>/config.json\` so the connector stays compatible with the shared dashboard auth helpers while remaining fully internal to the one-product repo.
+Connector state is stored under \`~/.hasna/connectors/imessage/\`. Profiles are read from both \`profiles/<name>.json\` and \`profiles/<name>/config.json\` so the connector stays compatible with the shared auth helpers while remaining fully internal to the one-product repo.
 `, commandInputSchema, conversationListInputSchema, conversationGetInputSchema, messageListInputSchema, messageSendInputSchema, messageReplyInputSchema, imessageConnector;
 var init_imessage = __esm(() => {
   init_package();
@@ -7447,14 +7441,14 @@ var init_imessage = __esm(() => {
 
 // src/core/connectors/stripe.ts
 import { existsSync as existsSync8 } from "fs";
-import { dirname as dirname3, join as join9 } from "path";
+import { dirname as dirname3, join as join8 } from "path";
 import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL2 } from "url";
 function resolveStripeConnectorDir() {
   const candidates = [
-    join9(__dirname3, "..", "..", "..", "connectors", "stripe"),
-    join9(__dirname3, "..", "..", "connectors", "stripe"),
-    join9(__dirname3, "..", "connectors", "stripe"),
-    join9(process.cwd(), "connectors", "stripe")
+    join8(__dirname3, "..", "..", "..", "connectors", "stripe"),
+    join8(__dirname3, "..", "..", "connectors", "stripe"),
+    join8(__dirname3, "..", "connectors", "stripe"),
+    join8(process.cwd(), "connectors", "stripe")
   ];
   for (const candidate of candidates) {
     if (existsSync8(candidate)) {
@@ -7505,10 +7499,10 @@ function buildCommandHelp2(spec) {
 `);
 }
 async function loadStripeApiModule() {
-  return await import(pathToFileURL2(join9(CONNECTOR_DIR2, "src", "api", "index.ts")).href);
+  return await import(pathToFileURL2(join8(CONNECTOR_DIR2, "src", "api", "index.ts")).href);
 }
 async function loadStripeConfigModule() {
-  return await import(pathToFileURL2(join9(CONNECTOR_DIR2, "src", "utils", "config.ts")).href);
+  return await import(pathToFileURL2(join8(CONNECTOR_DIR2, "src", "utils", "config.ts")).href);
 }
 function extractGlobalArgs3(args) {
   const remaining = [];
@@ -11345,13 +11339,32 @@ var require_data = __commonJS((exports, module) => {
   };
 });
 
-// ../../node_modules/.bun/fast-uri@3.1.5/node_modules/fast-uri/lib/utils.js
+// ../../node_modules/.bun/fast-uri@3.1.7/node_modules/fast-uri/lib/utils.js
 var require_utils = __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 isPort = RegExp.prototype.test.bind(/^\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);
+  var isPathCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:@/]$/u);
+  var isQueryFragmentCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:@/?]$/u);
+  var isUserinfoCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:]$/u);
+  var BYTE_HEX = new Array(256);
+  {
+    const HEX_DIGITS = "0123456789ABCDEF";
+    for (let i = 0;i < 256; i++) {
+      BYTE_HEX[i] = "%" + HEX_DIGITS[i >> 4] + HEX_DIGITS[i & 15];
+    }
+  }
+  function percentEncodeNonAscii(cp) {
+    if (cp < 2048) {
+      return BYTE_HEX[192 | cp >> 6] + BYTE_HEX[128 | cp & 63];
+    }
+    if (cp < 65536) {
+      return BYTE_HEX[224 | cp >> 12] + BYTE_HEX[128 | cp >> 6 & 63] + BYTE_HEX[128 | cp & 63];
+    }
+    return BYTE_HEX[240 | cp >> 18] + BYTE_HEX[128 | cp >> 12 & 63] + BYTE_HEX[128 | cp >> 6 & 63] + BYTE_HEX[128 | cp & 63];
+  }
   function stringArrayToHexStripped(input) {
     let acc = "";
     let code = 0;
@@ -11376,91 +11389,122 @@ var require_utils = __commonJS((exports, module) => {
     }
     return acc;
   }
+  var isHextet = RegExp.prototype.test.bind(/^[\dA-Fa-f]{1,4}$/);
+  var isIPvFuture = RegExp.prototype.test.bind(/^[vV][\dA-Fa-f]+\.[A-Za-z\d\-._~!$&'()*+,;=:]+$/);
+  var isZoneCharacter = RegExp.prototype.test.bind(/^[A-Za-z\d\-._~]$/);
   var nonSimpleDomain = RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u);
-  function consumeIsZone(buffer) {
-    buffer.length = 0;
-    return true;
-  }
-  function consumeHextets(buffer, address, output) {
-    if (buffer.length) {
-      const hex = stringArrayToHexStripped(buffer);
-      if (hex !== "") {
-        address.push(hex);
-      } else {
-        output.error = true;
-        return false;
+  function isZoneIdentifier(zone) {
+    if (zone.length === 0)
+      return false;
+    for (let i = 0;i < zone.length; i++) {
+      if (isZoneCharacter(zone[i]))
+        continue;
+      if (zone[i] === "%" && i + 2 < zone.length && isHexPair(zone.slice(i + 1, i + 3))) {
+        i += 2;
+        continue;
       }
-      buffer.length = 0;
+      return false;
     }
     return true;
   }
-  function getIPV6(input) {
-    let tokenCount = 0;
-    const output = { error: false, address: "", zone: "" };
-    const address = [];
-    const buffer = [];
-    let endipv6Encountered = false;
-    let endIpv6 = false;
-    let consume = consumeHextets;
-    for (let i = 0;i < input.length; i++) {
-      const cursor = input[i];
-      if (cursor === "[" || cursor === "]") {
-        continue;
-      }
-      if (cursor === ":") {
-        if (endipv6Encountered === true) {
-          endIpv6 = true;
-        }
-        if (!consume(buffer, address, output)) {
-          break;
+  function compressIPv6ZeroRun(hextets) {
+    let bestStart = -1;
+    let bestLength = 0;
+    let runStart = -1;
+    let runLength = 0;
+    for (let i = 0;i < hextets.length; i++) {
+      if (hextets[i] === "0") {
+        if (runStart === -1)
+          runStart = i;
+        runLength++;
+        if (runLength > bestLength) {
+          bestLength = runLength;
+          bestStart = runStart;
         }
-        if (++tokenCount > 7) {
-          output.error = true;
-          break;
-        }
-        if (i > 0 && input[i - 1] === ":") {
-          endipv6Encountered = true;
-        }
-        address.push(":");
-        continue;
-      } else if (cursor === "%") {
-        if (!consume(buffer, address, output)) {
-          break;
-        }
-        consume = consumeIsZone;
       } else {
-        buffer.push(cursor);
-        continue;
+        runStart = -1;
+        runLength = 0;
       }
     }
-    if (buffer.length) {
-      if (consume === consumeIsZone) {
-        output.zone = buffer.join("");
-      } else if (endIpv6) {
-        address.push(buffer.join(""));
-      } else {
-        address.push(stringArrayToHexStripped(buffer));
+    if (bestLength < 2)
+      return hextets.join(":");
+    const head = hextets.slice(0, bestStart).join(":");
+    const tail = hextets.slice(bestStart + bestLength).join(":");
+    return head + "::" + tail;
+  }
+  function normalizeIPv6Address(input) {
+    const compression = input.indexOf("::");
+    if (compression !== -1 && input.indexOf("::", compression + 1) !== -1)
+      return;
+    const left = compression === -1 ? input.split(":") : input.slice(0, compression).split(":");
+    const right = compression === -1 ? [] : input.slice(compression + 2).split(":");
+    if (compression !== -1) {
+      if (left.length === 1 && left[0] === "")
+        left.length = 0;
+      if (right.length === 1 && right[0] === "")
+        right.length = 0;
+    }
+    const parts = left.concat(right);
+    let hextetCount = 0;
+    for (let i = 0;i < parts.length; i++) {
+      const part = parts[i];
+      if (part === "")
+        return;
+      if (part.indexOf(".") !== -1) {
+        if (i !== parts.length - 1 || compression !== -1 && right.length === 0 || !isIPv4(part))
+          return;
+        hextetCount += 2;
+        continue;
       }
+      if (!isHextet(part))
+        return;
+      parts[i] = parseInt(part, 16).toString(16);
+      hextetCount++;
     }
-    output.address = address.join("");
-    return output;
+    if (compression === -1) {
+      if (hextetCount !== 8)
+        return;
+      return compressIPv6ZeroRun(parts);
+    }
+    if (hextetCount >= 8)
+      return;
+    const expanded = parts.slice(0, left.length);
+    for (let i = hextetCount;i < 8; i++)
+      expanded.push("0");
+    for (let i = left.length;i < parts.length; i++)
+      expanded.push(parts[i]);
+    return compressIPv6ZeroRun(expanded);
   }
   function normalizeIPv6(host) {
-    if (findToken(host, ":") < 2) {
-      return { host, isIPV6: false };
-    }
-    const ipv62 = getIPV6(host);
-    if (!ipv62.error) {
-      let newHost = ipv62.address;
-      let escapedHost = ipv62.address;
-      if (ipv62.zone) {
-        newHost += "%" + ipv62.zone;
-        escapedHost += "%25" + ipv62.zone;
-      }
-      return { host: newHost, isIPV6: true, escapedHost };
-    } else {
-      return { host, isIPV6: false };
-    }
+    const bracketed = host[0] === "[" && host[host.length - 1] === "]";
+    const hasBracket = host[0] === "[" || host[host.length - 1] === "]";
+    if (hasBracket && !bracketed)
+      return { host, isIPV6: false, error: true };
+    let input = bracketed ? host.slice(1, -1) : host;
+    if (bracketed && isIPvFuture(input)) {
+      input = input.toLowerCase();
+      return { host: `[${input}]`, escapedHost: input, isIPV6: false, isIPVFuture: true };
+    }
+    if (findToken(input, ":") < 2) {
+      return { host, isIPV6: false, error: bracketed };
+    }
+    let zoneIdentifier = "";
+    const zoneSeparator = input.indexOf("%");
+    if (zoneSeparator !== -1) {
+      const separatorLength = input.slice(zoneSeparator, zoneSeparator + 3).toLowerCase() === "%25" ? 3 : 1;
+      zoneIdentifier = input.slice(zoneSeparator + separatorLength);
+      if (!isZoneIdentifier(zoneIdentifier))
+        return { host, isIPV6: false, error: true };
+      input = input.slice(0, zoneSeparator);
+    }
+    const address = normalizeIPv6Address(input);
+    if (address === undefined)
+      return { host, isIPV6: false, error: true };
+    return {
+      host: address + (zoneIdentifier ? "%" + zoneIdentifier : ""),
+      escapedHost: address + (zoneIdentifier ? "%25" + zoneIdentifier : ""),
+      isIPV6: true
+    };
   }
   function findToken(str, token) {
     let ind = 0;
@@ -11580,7 +11624,8 @@ var require_utils = __commonJS((exports, module) => {
   function normalizePathEncoding(input) {
     let output = "";
     for (let i = 0;i < input.length; i++) {
-      if (input[i] === "%" && i + 2 < input.length) {
+      const ch = input[i];
+      if (ch === "%" && i + 2 < input.length) {
         const hex = input.slice(i + 1, i + 3);
         if (isHexPair(hex)) {
           const normalizedHex = hex.toUpperCase();
@@ -11594,10 +11639,152 @@ var require_utils = __commonJS((exports, module) => {
           continue;
         }
       }
-      if (isPathCharacter(input[i])) {
-        output += input[i];
+      if (isPathCharacter(ch)) {
+        output += ch;
       } else {
-        output += escape(input[i]);
+        const code = input.charCodeAt(i);
+        if (code < 128) {
+          output += isEscapeSafe(code) ? ch : BYTE_HEX[code];
+        } else if (code < 55296 || code > 57343) {
+          output += percentEncodeNonAscii(code);
+        } else if (code <= 56319 && i + 1 < input.length) {
+          const low = input.charCodeAt(i + 1);
+          if (low >= 56320 && low <= 57343) {
+            output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+            i++;
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
+        } else {
+          output += percentEncodeNonAscii(65533);
+        }
+      }
+    }
+    return output;
+  }
+  function serializePathEncoding(input, pathNoScheme = false) {
+    let output = "";
+    let firstSegment = pathNoScheme && input[0] !== "/";
+    for (let i = 0;i < input.length; i++) {
+      const ch = input[i];
+      if (ch === "%" && i + 2 < input.length) {
+        const hex = input.slice(i + 1, i + 3);
+        if (isHexPair(hex)) {
+          output += "%" + hex.toUpperCase();
+          i += 2;
+          continue;
+        }
+      }
+      if (ch === "/") {
+        firstSegment = false;
+      }
+      if (isPathCharacter(ch) && (ch !== ":" || !firstSegment)) {
+        output += ch;
+      } else {
+        const code = input.charCodeAt(i);
+        if (code < 128) {
+          output += BYTE_HEX[code];
+        } else if (code < 55296 || code > 57343) {
+          output += percentEncodeNonAscii(code);
+        } else if (code <= 56319 && i + 1 < input.length) {
+          const low = input.charCodeAt(i + 1);
+          if (low >= 56320 && low <= 57343) {
+            output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+            i++;
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
+        } else {
+          output += percentEncodeNonAscii(65533);
+        }
+      }
+    }
+    return output;
+  }
+  function encodeComponent(input, isAllowed) {
+    let output = "";
+    for (let i = 0;i < input.length; i++) {
+      const ch = input[i];
+      if (ch === "%" && i + 2 < input.length) {
+        const hex = input.slice(i + 1, i + 3);
+        if (isHexPair(hex)) {
+          output += "%" + hex.toUpperCase();
+          i += 2;
+          continue;
+        }
+      }
+      if (isAllowed(ch)) {
+        output += ch;
+      } else {
+        const code = input.charCodeAt(i);
+        if (code < 128) {
+          output += BYTE_HEX[code];
+        } else if (code < 55296 || code > 57343) {
+          output += percentEncodeNonAscii(code);
+        } else if (code <= 56319 && i + 1 < input.length) {
+          const low = input.charCodeAt(i + 1);
+          if (low >= 56320 && low <= 57343) {
+            output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+            i++;
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
+        } else {
+          output += percentEncodeNonAscii(65533);
+        }
+      }
+    }
+    return output;
+  }
+  function encodeUserinfo(input) {
+    return encodeComponent(input, isUserinfoCharacter);
+  }
+  function encodeQuery(input) {
+    return encodeComponent(input, isQueryFragmentCharacter);
+  }
+  function encodeFragment(input) {
+    return encodeComponent(input, isQueryFragmentCharacter);
+  }
+  function isEscapeSafe(cp) {
+    return cp >= 48 && cp <= 57 || cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122 || cp === 42 || cp === 43 || cp === 45 || cp === 46 || cp === 47 || cp === 64 || cp === 95;
+  }
+  function normalizeQueryFragmentEncoding(input) {
+    let output = "";
+    for (let i = 0;i < input.length; i++) {
+      const ch = input[i];
+      if (ch === "%" && 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 (isUnreserved(decoded)) {
+            output += decoded;
+          } else {
+            output += "%" + normalizedHex;
+          }
+          i += 2;
+          continue;
+        }
+      }
+      if (isQueryFragmentCharacter(ch)) {
+        output += ch;
+      } else {
+        const code = input.charCodeAt(i);
+        if (code < 128) {
+          output += isEscapeSafe(code) ? ch : BYTE_HEX[code];
+        } else if (code < 55296 || code > 57343) {
+          output += percentEncodeNonAscii(code);
+        } else if (code <= 56319 && i + 1 < input.length) {
+          const low = input.charCodeAt(i + 1);
+          if (low >= 56320 && low <= 57343) {
+            output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+            i++;
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
+        } else {
+          output += percentEncodeNonAscii(65533);
+        }
       }
     }
     return output;
@@ -11620,14 +11807,18 @@ var require_utils = __commonJS((exports, module) => {
   function recomposeAuthority(component) {
     const uriTokens = [];
     if (component.userinfo !== undefined) {
-      uriTokens.push(component.userinfo);
+      uriTokens.push(encodeUserinfo(component.userinfo));
       uriTokens.push("@");
     }
     if (component.host !== undefined) {
-      let host = unescape(component.host);
+      let host = component.host;
       if (!isIPv4(host)) {
-        const ipV6res = normalizeIPv6(host);
-        if (ipV6res.isIPV6 === true) {
+        let ipV6res = normalizeIPv6(host);
+        if (ipV6res.isIPV6 !== true && ipV6res.isIPVFuture !== true) {
+          host = normalizePercentEncoding(host, true);
+          ipV6res = normalizeIPv6(host);
+        }
+        if (ipV6res.isIPV6 === true || ipV6res.isIPVFuture === true) {
           host = `[${ipV6res.escapedHost}]`;
         } else {
           host = reescapeHostDelimiters(host, false);
@@ -11636,8 +11827,12 @@ var require_utils = __commonJS((exports, module) => {
       uriTokens.push(host);
     }
     if (typeof component.port === "number" || typeof component.port === "string") {
+      const port = String(component.port);
+      if (!isPort(port)) {
+        throw new TypeError("URI port is malformed.");
+      }
       uriTokens.push(":");
-      uriTokens.push(String(component.port));
+      uriTokens.push(port);
     }
     return uriTokens.length ? uriTokens.join("") : undefined;
   }
@@ -11647,6 +11842,11 @@ var require_utils = __commonJS((exports, module) => {
     reescapeHostDelimiters,
     normalizePercentEncoding,
     normalizePathEncoding,
+    serializePathEncoding,
+    normalizeQueryFragmentEncoding,
+    encodeUserinfo,
+    encodeQuery,
+    encodeFragment,
     escapePreservingEscapes,
     removeDotSegments,
     isIPv4,
@@ -11656,10 +11856,10 @@ var require_utils = __commonJS((exports, module) => {
   };
 });
 
-// ../../node_modules/.bun/fast-uri@3.1.5/node_modules/fast-uri/lib/schemes.js
+// ../../node_modules/.bun/fast-uri@3.1.7/node_modules/fast-uri/lib/schemes.js
 var require_schemes = __commonJS((exports, module) => {
   var { isUUID } = require_utils();
-  var URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu;
+  var URN_REG = /^([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-./:;=@]|%[\da-f]{2})+)$/iu;
   var supportedSchemeNames = [
     "http",
     "https",
@@ -11714,9 +11914,10 @@ var require_schemes = __commonJS((exports, module) => {
       wsComponent.secure = undefined;
     }
     if (wsComponent.resourceName) {
-      const [path, query] = wsComponent.resourceName.split("?");
+      const queryIndex = wsComponent.resourceName.indexOf("?");
+      const path = queryIndex === -1 ? wsComponent.resourceName : wsComponent.resourceName.slice(0, queryIndex);
       wsComponent.path = path && path !== "/" ? path : undefined;
-      wsComponent.query = query;
+      wsComponent.query = queryIndex === -1 ? undefined : wsComponent.resourceName.slice(queryIndex + 1);
       wsComponent.resourceName = undefined;
     }
     wsComponent.fragment = undefined;
@@ -11728,7 +11929,7 @@ var require_schemes = __commonJS((exports, module) => {
       return urnComponent;
     }
     const matches = urnComponent.path.match(URN_REG);
-    if (matches) {
+    if (matches && matches[0] === urnComponent.path) {
       const scheme = options.scheme || urnComponent.scheme || "urn";
       urnComponent.nid = matches[1].toLowerCase();
       urnComponent.nss = matches[2];
@@ -11830,10 +12031,19 @@ var require_schemes = __commonJS((exports, module) => {
   };
 });
 
-// ../../node_modules/.bun/fast-uri@3.1.5/node_modules/fast-uri/index.js
+// ../../node_modules/.bun/fast-uri@3.1.7/node_modules/fast-uri/index.js
 var require_fast_uri = __commonJS((exports, module) => {
-  var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
+  var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, serializePathEncoding, normalizeQueryFragmentEncoding, encodeQuery, encodeFragment, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
   var { SCHEMES, getSchemeHandler } = require_schemes();
+  var VALID_SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*$/u;
+  var MALFORMED_SCHEME_ERROR = "URI scheme is malformed.";
+  function decodeValidScheme(scheme) {
+    const decodedScheme = unescape(String(scheme));
+    if (!VALID_SCHEME.test(decodedScheme)) {
+      throw new TypeError(MALFORMED_SCHEME_ERROR);
+    }
+    return decodedScheme;
+  }
   function normalize(uri, options) {
     if (typeof uri === "string") {
       uri = normalizeString(uri, options);
@@ -11844,12 +12054,34 @@ var require_fast_uri = __commonJS((exports, module) => {
   }
   function resolve2(baseURI, relativeURI, options) {
     const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
-    const { parsed: baseParsed, malformedAuthorityOrPort: baseMalformed } = parseWithStatus(baseURI, schemelessOptions);
-    const { parsed: relativeParsed, malformedAuthorityOrPort: relativeMalformed } = parseWithStatus(relativeURI, schemelessOptions);
-    if (baseMalformed || relativeMalformed) {
+    const {
+      parsed: baseParsed,
+      malformedAuthorityOrPort: baseMalformed,
+      malformedPercentEncoding: baseMalformedPercentEncoding,
+      malformedSchemeSpecific: baseMalformedSchemeSpecific,
+      malformedHost: baseMalformedHost,
+      malformedScheme: baseMalformedScheme
+    } = parseWithStatus(baseURI, schemelessOptions);
+    const {
+      parsed: relativeParsed,
+      malformedAuthorityOrPort: relativeMalformed,
+      malformedPercentEncoding: relativeMalformedPercentEncoding,
+      malformedSchemeSpecific: relativeMalformedSchemeSpecific,
+      malformedHost: relativeMalformedHost,
+      malformedScheme: relativeMalformedScheme
+    } = parseWithStatus(relativeURI, schemelessOptions);
+    if (baseMalformed || relativeMalformed || baseMalformedPercentEncoding || relativeMalformedPercentEncoding || baseMalformedSchemeSpecific || relativeMalformedSchemeSpecific || baseMalformedHost || relativeMalformedHost || baseMalformedScheme || relativeMalformedScheme) {
       throw new Error(baseParsed.error || relativeParsed.error || "URI is malformed.");
     }
     const resolved = resolveComponent(baseParsed, relativeParsed, schemelessOptions, true);
+    const resolvedSchemeHandler = getSchemeHandler(options && options.scheme || resolved.scheme);
+    const resolvedHost = resolved.host;
+    const resolvedHostIsIP = resolvedHost !== undefined && resolvedHost !== "" && (isIPv4(resolvedHost) || normalizeIPv6(resolvedHost).isIPV6);
+    canonicalizeHost(resolved, options || {}, resolvedSchemeHandler, resolvedHostIsIP);
+    const encodedASCIIHost = resolvedHost && resolvedHost.indexOf("%") !== -1 && !/\P{ASCII}/u.test(resolvedHost);
+    if (resolved.error && !encodedASCIIHost) {
+      throw new Error(resolved.error);
+    }
     schemelessOptions.skipEscape = true;
     return serialize(resolved, schemelessOptions);
   }
@@ -11909,7 +12141,7 @@ var require_fast_uri = __commonJS((exports, module) => {
   function equal(uriA, uriB, options) {
     const normalizedA = normalizeComparableURI(uriA, options);
     const normalizedB = normalizeComparableURI(uriB, options);
-    return normalizedA !== undefined && normalizedB !== undefined && normalizedA.toLowerCase() === normalizedB.toLowerCase();
+    return normalizedA !== undefined && normalizedB !== undefined && normalizedA === normalizedB;
   }
   function serialize(cmpts, opts) {
     const component = {
@@ -11930,20 +12162,23 @@ var require_fast_uri = __commonJS((exports, module) => {
     };
     const options = Object.assign({}, opts);
     const uriTokens = [];
+    if (component.scheme) {
+      component.scheme = decodeValidScheme(component.scheme);
+    }
     const schemeHandler = getSchemeHandler(options.scheme || component.scheme);
     if (schemeHandler && schemeHandler.serialize)
       schemeHandler.serialize(component, options);
+    const hasAuthority = component.userinfo !== undefined || component.host !== undefined || component.port !== undefined;
+    const pathNoScheme = !options.skipEscape && component.scheme === undefined && !hasAuthority;
     if (component.path !== undefined) {
       if (!options.skipEscape) {
-        component.path = escapePreservingEscapes(component.path);
-        if (component.scheme !== undefined) {
-          component.path = component.path.split("%3A").join(":");
-        }
+        component.path = serializePathEncoding(component.path, pathNoScheme);
       } else {
         component.path = normalizePercentEncoding(component.path);
       }
     }
     if (options.reference !== "suffix" && component.scheme) {
+      component.scheme = decodeValidScheme(component.scheme);
       uriTokens.push(component.scheme, ":");
     }
     const authority = recomposeAuthority(component);
@@ -11961,16 +12196,19 @@ var require_fast_uri = __commonJS((exports, module) => {
       if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {
         s = removeDotSegments(s);
       }
+      if (pathNoScheme) {
+        s = serializePathEncoding(s, true);
+      }
       if (authority === undefined && s[0] === "/" && s[1] === "/") {
         s = "/%2F" + s.slice(2);
       }
       uriTokens.push(s);
     }
     if (component.query !== undefined) {
-      uriTokens.push("?", component.query);
+      uriTokens.push("?", encodeQuery(component.query));
     }
     if (component.fragment !== undefined) {
-      uriTokens.push("#", component.fragment);
+      uriTokens.push("#", encodeFragment(component.fragment));
     }
     return uriTokens.join("");
   }
@@ -11986,6 +12224,36 @@ var require_fast_uri = __commonJS((exports, module) => {
     }
     return;
   }
+  function hasMalformedPercentEncoding(component) {
+    if (component === undefined)
+      return false;
+    let percent = component.indexOf("%");
+    while (percent !== -1) {
+      if (percent + 2 >= component.length || !/^[\da-f]{2}$/iu.test(component.slice(percent + 1, percent + 3))) {
+        return true;
+      }
+      percent = component.indexOf("%", percent + 3);
+    }
+    return false;
+  }
+  function isIPLiteral(host) {
+    return host[0] === "[" && host[host.length - 1] === "]";
+  }
+  function hasMalformedComponentPercentEncoding(matches) {
+    const host = matches[4];
+    return hasMalformedPercentEncoding(matches[3]) || host !== undefined && !isIPLiteral(host) && hasMalformedPercentEncoding(host) || hasMalformedPercentEncoding(matches[6]) || hasMalformedPercentEncoding(matches[7]) || hasMalformedPercentEncoding(matches[8]);
+  }
+  function canonicalizeHost(parsed, options, schemeHandler, isIP) {
+    if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport) && parsed.host && !isIPLiteral(parsed.host) && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
+      try {
+        parsed.host = new URL("http://" + parsed.host).hostname;
+      } catch (e) {
+        parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
+        return true;
+      }
+    }
+    return false;
+  }
   function parseWithStatus(uri, opts) {
     const options = Object.assign({}, opts);
     const parsed = {
@@ -11998,6 +12266,11 @@ var require_fast_uri = __commonJS((exports, module) => {
       fragment: undefined
     };
     let malformedAuthorityOrPort = false;
+    let malformedPercentEncoding = false;
+    let malformedSchemeSpecific = false;
+    let malformedHost = false;
+    let malformedIPLiteral = false;
+    let malformedScheme = false;
     let isIP = false;
     if (options.reference === "suffix") {
       if (options.scheme) {
@@ -12034,6 +12307,19 @@ var require_fast_uri = __commonJS((exports, module) => {
       parsed.path = matches[6] || "";
       parsed.query = matches[7];
       parsed.fragment = matches[8];
+      if (parsed.scheme !== undefined) {
+        const decodedScheme = unescape(parsed.scheme);
+        if (VALID_SCHEME.test(decodedScheme)) {
+          parsed.scheme = decodedScheme.toLowerCase();
+        } else {
+          parsed.error = parsed.error || MALFORMED_SCHEME_ERROR;
+          malformedScheme = true;
+        }
+      }
+      malformedPercentEncoding = hasMalformedComponentPercentEncoding(matches);
+      if (malformedPercentEncoding) {
+        parsed.error = parsed.error || "URI contains malformed percent-encoding.";
+      }
       if (isNaN(parsed.port)) {
         parsed.port = matches[5];
       }
@@ -12045,9 +12331,16 @@ var require_fast_uri = __commonJS((exports, module) => {
       if (parsed.host) {
         const ipv4result = isIPv4(parsed.host);
         if (ipv4result === false) {
+          const bracketedIPLiteral = isIPLiteral(parsed.host);
+          const hasIPLiteralBracket = parsed.host.indexOf("[") !== -1 || parsed.host.indexOf("]") !== -1;
           const ipv6result = normalizeIPv6(parsed.host);
-          parsed.host = ipv6result.host.toLowerCase();
-          isIP = ipv6result.isIPV6;
+          isIP = ipv6result.isIPV6 || ipv6result.isIPVFuture === true;
+          malformedIPLiteral = hasIPLiteralBracket && (!bracketedIPLiteral || ipv6result.error === true);
+          parsed.host = isIP ? ipv6result.host : ipv6result.host.toLowerCase();
+          if (malformedIPLiteral) {
+            parsed.error = parsed.error || "URI host is malformed.";
+            malformedAuthorityOrPort = true;
+          }
         } else {
           isIP = true;
         }
@@ -12065,42 +12358,36 @@ var require_fast_uri = __commonJS((exports, module) => {
         parsed.error = parsed.error || "URI is not a " + options.reference + " reference.";
       }
       const schemeHandler = getSchemeHandler(options.scheme || parsed.scheme);
-      if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
-        if (parsed.host && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
-          try {
-            parsed.host = new URL("http://" + parsed.host).hostname;
-          } catch (e) {
-            parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
-          }
-        }
+      if (!malformedIPLiteral) {
+        malformedHost = canonicalizeHost(parsed, options, schemeHandler, isIP);
       }
       if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
         if (uri.indexOf("%") !== -1) {
-          if (parsed.scheme !== undefined) {
-            parsed.scheme = unescape(parsed.scheme);
-          }
-          if (parsed.host !== undefined) {
-            parsed.host = reescapeHostDelimiters(unescape(parsed.host), isIP);
+          if (parsed.host !== undefined && !malformedIPLiteral) {
+            const host = isIP ? parsed.host : normalizePercentEncoding(parsed.host, true);
+            parsed.host = reescapeHostDelimiters(host, isIP);
           }
         }
         if (parsed.path) {
           parsed.path = normalizePathEncoding(parsed.path);
         }
+        if (parsed.query) {
+          parsed.query = normalizeQueryFragmentEncoding(parsed.query);
+        }
         if (parsed.fragment) {
-          try {
-            parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
-          } catch {
-            parsed.error = parsed.error || "URI malformed";
-          }
+          parsed.fragment = normalizeQueryFragmentEncoding(parsed.fragment);
         }
       }
       if (schemeHandler && schemeHandler.parse) {
         schemeHandler.parse(parsed, options);
+        if (schemeHandler === SCHEMES.urn && parsed.nid === undefined) {
+          malformedSchemeSpecific = true;
+        }
       }
     } else {
       parsed.error = parsed.error || "URI can not be parsed.";
     }
-    return { parsed, malformedAuthorityOrPort };
+    return { parsed, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme };
   }
   function parse6(uri, opts) {
     return parseWithStatus(uri, opts).parsed;
@@ -12109,20 +12396,28 @@ var require_fast_uri = __commonJS((exports, module) => {
     return normalizeStringWithStatus(uri, opts).normalized;
   }
   function normalizeStringWithStatus(uri, opts) {
-    const { parsed, malformedAuthorityOrPort } = parseWithStatus(uri, opts);
+    const { parsed, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme } = parseWithStatus(uri, opts);
     return {
-      normalized: malformedAuthorityOrPort ? uri : serialize(parsed, opts),
-      malformedAuthorityOrPort
+      normalized: malformedAuthorityOrPort || malformedPercentEncoding || malformedSchemeSpecific || malformedHost || malformedScheme ? uri : serialize(parsed, opts),
+      malformedAuthorityOrPort,
+      malformedPercentEncoding,
+      malformedSchemeSpecific,
+      malformedHost,
+      malformedScheme
     };
   }
   function normalizeComparableURI(uri, opts) {
-    if (typeof uri === "string") {
-      const { normalized, malformedAuthorityOrPort } = normalizeStringWithStatus(uri, opts);
-      return malformedAuthorityOrPort ? undefined : normalized;
+    if (typeof uri !== "string" && typeof uri !== "object") {
+      return;
     }
-    if (typeof uri === "object") {
-      return serialize(uri, opts);
+    let value;
+    try {
+      value = typeof uri === "string" ? uri : serialize(uri, opts);
+    } catch {
+      return;
     }
+    const { normalized, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme } = normalizeStringWithStatus(value, opts);
+    return malformedAuthorityOrPort || malformedPercentEncoding || malformedSchemeSpecific || malformedHost || malformedScheme ? undefined : normalized;
   }
   var fastUri = {
     SCHEMES,
@@ -14940,9 +15235,9 @@ __export(exports_llm, {
   LLMClient: () => LLMClient
 });
 import { existsSync as existsSync10, readFileSync as readFileSync5, writeFileSync as writeFileSync4, mkdirSync as mkdirSync5 } from "fs";
-import { join as join11 } from "path";
+import { join as join10 } from "path";
 function getLlmConfigPath() {
-  return join11(getConnectorsHome(), "llm.json");
+  return join10(getConnectorsHome(), "llm.json");
 }
 function getLlmConfig() {
   const path = getLlmConfigPath();
@@ -15077,25 +15372,25 @@ __export(exports_installer, {
   connectorExists: () => connectorExists
 });
 import { existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync5, readdirSync as readdirSync6, statSync as statSync4, rmSync as rmSync2 } from "fs";
-import { join as join12, dirname as dirname5 } from "path";
+import { join as join11, dirname as dirname5 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 function resolveConnectorsDir() {
-  const fromBin = join12(__dirname4, "..", "connectors");
+  const fromBin = join11(__dirname4, "..", "connectors");
   if (existsSync11(fromBin))
     return fromBin;
-  const fromSrc = join12(__dirname4, "..", "..", "connectors");
+  const fromSrc = join11(__dirname4, "..", "..", "connectors");
   if (existsSync11(fromSrc))
     return fromSrc;
   return fromBin;
 }
 function getProjectConnectorsDir(targetDir) {
-  return join12(targetDir, PROJECT_CONNECTORS_DIRNAME);
+  return join11(targetDir, PROJECT_CONNECTORS_DIRNAME);
 }
 function getEnablementManifestPath(targetDir) {
-  return join12(getProjectConnectorsDir(targetDir), ENABLEMENT_MANIFEST_FILENAME);
+  return join11(getProjectConnectorsDir(targetDir), ENABLEMENT_MANIFEST_FILENAME);
 }
 function getLegacyInstallPath(targetDir, name) {
-  return join12(getProjectConnectorsDir(targetDir), legacyConnectorName(name));
+  return join11(getProjectConnectorsDir(targetDir), legacyConnectorName(name));
 }
 function loadEnablementManifest(targetDir) {
   const manifestPath = getEnablementManifestPath(targetDir);
@@ -15123,7 +15418,7 @@ function getLegacyInstalledConnectors(targetDir) {
     return [];
   }
   return readdirSync6(connectorsDir).filter((entry) => {
-    const fullPath = join12(connectorsDir, entry);
+    const fullPath = join11(connectorsDir, entry);
     return entry.startsWith("connect-") && statSync4(fullPath).isDirectory();
   }).map((entry) => entry.replace("connect-", "")).sort();
 }
@@ -15132,7 +15427,7 @@ function getEnabledConnectors(targetDir) {
   return [...new Set([...manifestConnectors, ...getLegacyInstalledConnectors(targetDir)])].sort();
 }
 function updateConnectorsIndex(connectorsDir, connectors18) {
-  const indexPath = join12(connectorsDir, ENABLEMENT_INDEX_FILENAME);
+  const indexPath = join11(connectorsDir, ENABLEMENT_INDEX_FILENAME);
   const connectorList = connectors18.map((connector) => `  "${connector}",`).join(`
 `);
   const content = `/**
@@ -15236,7 +15531,7 @@ function parseConnectorDocs(raw) {
 function getConnectorDocs(name) {
   const normalizedName = normalizeConnectorName(name);
   const connectorPath = getConnectorPath(normalizedName);
-  const claudeMdPath = join12(connectorPath, "CLAUDE.md");
+  const claudeMdPath = join11(connectorPath, "CLAUDE.md");
   if (existsSync11(claudeMdPath)) {
     return parseConnectorDocs(readFileSync6(claudeMdPath, "utf-8"));
   }
@@ -15432,7 +15727,7 @@ var init_lock = __esm(() => {
 
 // src/server/auth.ts
 import { chmodSync, existsSync as existsSync13, readFileSync as readFileSync7, writeFileSync as writeFileSync6, mkdirSync as mkdirSync8, readdirSync as readdirSync7, rmSync as rmSync3, statSync as statSync6 } from "fs";
-import { join as join13 } from "path";
+import { join as join12 } from "path";
 function getAuthType(name) {
   name = normalizeConnectorName(name);
   const docs = getConnectorDocs(name);
@@ -15469,7 +15764,7 @@ function writePrivateJson(path, data) {
 function getCurrentProfile2(name) {
   name = normalizeConnectorName(name);
   for (const configDir of getConnectorConfigReadDirs2(name)) {
-    const currentProfileFile = join13(configDir, "current_profile");
+    const currentProfileFile = join12(configDir, "current_profile");
     if (existsSync13(currentProfileFile)) {
       try {
         return readFileSync7(currentProfileFile, "utf-8").trim() || "default";
@@ -15483,13 +15778,13 @@ function getCurrentProfile2(name) {
 function loadProfileConfigFromDir(configDir, profile) {
   let flatConfig = {};
   let dirConfig = {};
-  const profileFile = join13(configDir, "profiles", `${profile}.json`);
+  const profileFile = join12(configDir, "profiles", `${profile}.json`);
   if (existsSync13(profileFile)) {
     try {
       flatConfig = JSON.parse(readFileSync7(profileFile, "utf-8"));
     } catch {}
   }
-  const profileDirConfig = join13(configDir, "profiles", profile, "config.json");
+  const profileDirConfig = join12(configDir, "profiles", profile, "config.json");
   if (existsSync13(profileDirConfig)) {
     try {
       dirConfig = JSON.parse(readFileSync7(profileDirConfig, "utf-8"));
@@ -15510,7 +15805,7 @@ function loadTokens3(name) {
   name = normalizeConnectorName(name);
   const profile = getCurrentProfile2(name);
   for (const configDir of getConnectorConfigReadDirs2(name)) {
-    const tokensFile = join13(configDir, "profiles", profile, "tokens.json");
+    const tokensFile = join12(configDir, "profiles", profile, "tokens.json");
     if (existsSync13(tokensFile)) {
       try {
         return JSON.parse(readFileSync7(tokensFile, "utf-8"));
@@ -15644,7 +15939,7 @@ function _saveApiKey(name, key, field) {
   const profile = getCurrentProfile2(name);
   const keyField = field || guessKeyField(name);
   if (keyField === "clientId" || keyField === "clientSecret") {
-    const credentialsFile = join13(configDir, "credentials.json");
+    const credentialsFile = join12(configDir, "credentials.json");
     ensurePrivateDir(configDir);
     let creds = {};
     if (existsSync13(credentialsFile)) {
@@ -15656,9 +15951,9 @@ function _saveApiKey(name, key, field) {
     writePrivateJson(credentialsFile, creds);
     return;
   }
-  const profilesDir = join13(configDir, "profiles");
-  const profileFile = join13(profilesDir, `${profile}.json`);
-  const profileDir = join13(profilesDir, profile);
+  const profilesDir = join12(configDir, "profiles");
+  const profileFile = join12(profilesDir, `${profile}.json`);
+  const profileDir = join12(profilesDir, profile);
   if (existsSync13(profileFile)) {
     let config2 = {};
     try {
@@ -15671,7 +15966,7 @@ function _saveApiKey(name, key, field) {
     return;
   }
   if (existsSync13(profileDir)) {
-    const configFile = join13(profileDir, "config.json");
+    const configFile = join12(profileDir, "config.json");
     let config2 = {};
     if (existsSync13(configFile)) {
       try {
@@ -15688,7 +15983,7 @@ function _saveApiKey(name, key, field) {
   ensurePrivateDir(configDir);
   ensurePrivateDir(profilesDir);
   ensurePrivateDir(profileDir);
-  writePrivateJson(join13(profileDir, "config.json"), { [keyField]: key });
+  writePrivateJson(join12(profileDir, "config.json"), { [keyField]: key });
 }
 function guessKeyField(name) {
   name = normalizeConnectorName(name);
@@ -15710,7 +16005,7 @@ function guessKeyField(name) {
 function getOAuthConfig(name) {
   name = normalizeConnectorName(name);
   for (const configDir of getConnectorConfigReadDirs2(name)) {
-    const credentialsFile = join13(configDir, "credentials.json");
+    const credentialsFile = join12(configDir, "credentials.json");
     if (existsSync13(credentialsFile)) {
       try {
         const creds = JSON.parse(readFileSync7(credentialsFile, "utf-8"));
@@ -15728,12 +16023,12 @@ function saveOAuthTokens(name, tokens) {
   name = normalizeConnectorName(name);
   const configDir = getConnectorConfigDir2(name);
   const profile = getCurrentProfile2(name);
-  const profilesDir = join13(configDir, "profiles");
-  const profileDir = join13(profilesDir, profile);
+  const profilesDir = join12(configDir, "profiles");
+  const profileDir = join12(profilesDir, profile);
   ensurePrivateDir(configDir);
   ensurePrivateDir(profilesDir);
   ensurePrivateDir(profileDir);
-  const tokensFile = join13(profileDir, "tokens.json");
+  const tokensFile = join12(profileDir, "tokens.json");
   writePrivateJson(tokensFile, tokens);
 }
 async function refreshOAuthToken(name) {
@@ -15842,14 +16137,14 @@ __export(exports_runner, {
   buildConnectorOperationArgs: () => buildConnectorOperationArgs
 });
 import { existsSync as existsSync15, readdirSync as readdirSync8 } from "fs";
-import { join as join15, dirname as dirname6 } from "path";
+import { join as join14, dirname as dirname6 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 import { spawn as spawn2 } from "child_process";
 function resolveConnectorsDir2() {
-  const fromBin = join15(__dirname5, "..", "connectors");
+  const fromBin = join14(__dirname5, "..", "connectors");
   if (existsSync15(fromBin))
     return fromBin;
-  const fromSrc = join15(__dirname5, "..", "..", "connectors");
+  const fromSrc = join14(__dirname5, "..", "..", "connectors");
   if (existsSync15(fromSrc))
     return fromSrc;
   return fromBin;
@@ -15918,7 +16213,7 @@ function buildEnvWithCredentials(connectorName, baseEnv) {
 function getConnectorCliPath(name) {
   const safeName = normalizeConnectorName(name).replace(/[^a-z0-9-]/g, "");
   const connectorDir = getConnectorPackagePath(CONNECTORS_DIR2, safeName);
-  const cliPath = join15(connectorDir, "src", "cli", "index.ts");
+  const cliPath = join14(connectorDir, "src", "cli", "index.ts");
   if (existsSync15(cliPath))
     return cliPath;
   return null;
@@ -16335,7 +16630,7 @@ var require_content_type = __commonJS((exports) => {
   }
 });
 
-// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0/node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
+// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0+2b91fc17bf64bdfd/node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
 import process2 from "process";
 
 // ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v4/core/core.js
@@ -20793,7 +21088,7 @@ function preprocess(fn, schema) {
 // ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v4/classic/external.js
 config(en_default());
 
-// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0/node_modules/@modelcontextprotocol/sdk/dist/esm/types.js
+// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0+2b91fc17bf64bdfd/node_modules/@modelcontextprotocol/sdk/dist/esm/types.js
 var LATEST_PROTOCOL_VERSION = "2025-11-25";
 var DEFAULT_NEGOTIATED_PROTOCOL_VERSION = "2025-03-26";
 var SUPPORTED_PROTOCOL_VERSIONS = [LATEST_PROTOCOL_VERSION, "2025-06-18", "2025-03-26", "2024-11-05", "2024-10-07"];
@@ -21640,7 +21935,7 @@ class UrlElicitationRequiredError extends McpError {
   }
 }
 
-// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/stdio.js
+// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0+2b91fc17bf64bdfd/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/stdio.js
 var STDIO_DEFAULT_MAX_BUFFER_SIZE = 10 * 1024 * 1024;
 
 class ReadBuffer {
@@ -21680,7 +21975,7 @@ function serializeMessage(message) {
 `;
 }
 
-// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0/node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
+// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0+2b91fc17bf64bdfd/node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
 class StdioServerTransport {
   constructor(_stdin = process2.stdin, _stdout = process2.stdout, options) {
     this._stdin = _stdin;
@@ -21746,7 +22041,7 @@ class StdioServerTransport {
 // src/lib/registry.ts
 init_builtins();
 import { existsSync as existsSync9, readFileSync as readFileSync4 } from "fs";
-import { join as join10, dirname as dirname4 } from "path";
+import { join as join9, dirname as dirname4 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/lib/fuzzy.ts
@@ -30179,15 +30474,15 @@ function loadConnectorVersions() {
   versionsLoaded = true;
   const thisDir = dirname4(fileURLToPath3(import.meta.url));
   const candidates = [
-    join10(thisDir, "..", "connectors"),
-    join10(thisDir, "..", "..", "connectors")
+    join9(thisDir, "..", "connectors"),
+    join9(thisDir, "..", "..", "connectors")
   ];
   const connectorsDir = candidates.find((d) => existsSync9(d));
   if (!connectorsDir)
     return;
   for (const connector of CONNECTORS) {
     try {
-      const pkgPath = join10(getConnectorPackagePath(connectorsDir, connector.name), "package.json");
+      const pkgPath = join9(getConnectorPackagePath(connectorsDir, connector.name), "package.json");
       if (existsSync9(pkgPath)) {
         const pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
         connector.version = pkg.version || "0.0.0";
@@ -30245,7 +30540,7 @@ function object2(shape, params) {
   };
   return new ZodMiniObject(def);
 }
-// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0/node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-compat.js
+// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0+2b91fc17bf64bdfd/node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-compat.js
 function isZ4Schema(s) {
   const schema = s;
   return !!schema._zod;
@@ -30406,7 +30701,7 @@ function getLiteralValue(schema) {
   return;
 }
 
-// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/interfaces.js
+// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0+2b91fc17bf64bdfd/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/interfaces.js
 function isTerminal(status) {
   return status === "completed" || status === "failed" || status === "cancelled";
 }
@@ -31647,7 +31942,7 @@ var zodToJsonSchema = (schema, options) => {
   }
   return combined;
 };
-// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0/node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-json-schema-compat.js
+// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0+2b91fc17bf64bdfd/node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-json-schema-compat.js
 function mapMiniTarget(t) {
   if (!t)
     return "draft-7";
@@ -31689,7 +31984,7 @@ function parseWithCompat(schema, data) {
   return result.data;
 }
 
-// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/protocol.js
+// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0+2b91fc17bf64bdfd/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/protocol.js
 var DEFAULT_REQUEST_TIMEOUT_MSEC = 60000;
 
 class Protocol {
@@ -32530,7 +32825,7 @@ function mergeCapabilities(base, additional) {
   return result;
 }
 
-// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0/node_modules/@modelcontextprotocol/sdk/dist/esm/validation/ajv-provider.js
+// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0+2b91fc17bf64bdfd/node_modules/@modelcontextprotocol/sdk/dist/esm/validation/ajv-provider.js
 var import_ajv = __toESM(require_ajv(), 1);
 var import_ajv_formats = __toESM(require_dist(), 1);
 function createDefaultAjvInstance() {
@@ -32570,7 +32865,7 @@ class AjvJsonSchemaValidator {
   }
 }
 
-// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/server.js
+// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0+2b91fc17bf64bdfd/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/server.js
 class ExperimentalServerTasks {
   constructor(_server) {
     this._server = _server;
@@ -32648,7 +32943,7 @@ class ExperimentalServerTasks {
   }
 }
 
-// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/helpers.js
+// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0+2b91fc17bf64bdfd/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/helpers.js
 function assertToolsCallTaskCapability(requests, method, entityName) {
   if (!requests) {
     throw new Error(`${entityName} does not support task creation (required for ${method})`);
@@ -32683,7 +32978,7 @@ function assertClientRequestTaskCapability(requests, method, entityName) {
   }
 }
 
-// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0/node_modules/@modelcontextprotocol/sdk/dist/esm/server/index.js
+// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0+2b91fc17bf64bdfd/node_modules/@modelcontextprotocol/sdk/dist/esm/server/index.js
 class Server extends Protocol {
   constructor(_serverInfo, options) {
     super(options);
@@ -33007,7 +33302,7 @@ class Server extends Protocol {
   }
 }
 
-// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0/node_modules/@modelcontextprotocol/sdk/dist/esm/server/completable.js
+// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0+2b91fc17bf64bdfd/node_modules/@modelcontextprotocol/sdk/dist/esm/server/completable.js
 var COMPLETABLE_SYMBOL = Symbol.for("mcp.completable");
 function isCompletable(schema) {
   return !!schema && typeof schema === "object" && COMPLETABLE_SYMBOL in schema;
@@ -33021,7 +33316,7 @@ var McpZodTypeKind;
   McpZodTypeKind2["Completable"] = "McpCompletable";
 })(McpZodTypeKind || (McpZodTypeKind = {}));
 
-// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/toolNameValidation.js
+// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0+2b91fc17bf64bdfd/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/toolNameValidation.js
 var TOOL_NAME_REGEX = /^[A-Za-z0-9._-]{1,128}$/;
 function validateToolName(name) {
   const warnings = [];
@@ -33079,7 +33374,7 @@ function validateAndWarnToolName(name) {
   return result.isValid;
 }
 
-// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/mcp-server.js
+// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0+2b91fc17bf64bdfd/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/mcp-server.js
 class ExperimentalMcpServerTasks {
   constructor(_mcpServer) {
     this._mcpServer = _mcpServer;
@@ -33094,7 +33389,7 @@ class ExperimentalMcpServerTasks {
   }
 }
 
-// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0/node_modules/@modelcontextprotocol/sdk/dist/esm/server/mcp.js
+// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0+2b91fc17bf64bdfd/node_modules/@modelcontextprotocol/sdk/dist/esm/server/mcp.js
 init_zod();
 
 class McpServer {
@@ -33828,7 +34123,8 @@ var STRIP_PROMPT = `You are a data extraction assistant. Your job is to take raw
 
 Rules:
 - Return valid JSON only (no markdown, no explanation)
-- Remove pagination metadata, rate limit headers, empty fields, null values
+- Preserve pagination and continuation metadata exactly (count, total, limit, cursor, nextCursor, next_cursor, hasMore, has_more, complete)
+- Remove rate limit headers, empty fields, and null values that are not continuation markers
 - Keep all meaningful data fields
 - If the input is already minimal, return it unchanged
 - If input is not JSON, extract key facts as a JSON object
@@ -33855,6 +34151,7 @@ init_package();
 
 // src/mcp/tools/discovery.ts
 init_zod();
+init_package();
 
 // src/lib/compact-output.ts
 var DEFAULT_MCP_LIMIT = 20;
@@ -33939,7 +34236,7 @@ function registerDiscoveryTools(server, stripped) {
     description: "Search connectors by name or keyword.",
     inputSchema: {
       query: exports_external.string(),
-      limit: exports_external.number().optional(),
+      limit: exports_external.number().int().min(1).max(100).optional(),
       verbose: exports_external.boolean().optional()
     }
   }, async ({ query, limit, verbose }) => {
@@ -34010,13 +34307,19 @@ function registerDiscoveryTools(server, stripped) {
       description: c.description,
       tags: c.tags
     })) : page.items.map((c) => compactConnector(c, 120));
-    return stripped(JSON.stringify({
+    const compactMode = compact === true || !verbose && compact !== false;
+    return { content: [{ type: "text", text: JSON.stringify({
       connectors: data,
       total: connectors18.length,
       count: data.length,
+      limit: page.limit,
+      cursor: String(page.offset),
       nextCursor: page.nextOffset === null ? null : String(page.nextOffset),
+      hasMore: page.nextOffset !== null,
+      compact: compactMode,
+      catalogVersion: package_default.version,
       hint: page.nextOffset === null ? "Use verbose=true or compact=false for full connector metadata." : `Call again with cursor="${page.nextOffset}", or use verbose=true / compact=false for full connector metadata.`
-    }, null, 2));
+    }) }] };
   });
   server.registerTool("connector_docs", {
     title: "Connector Documentation",
@@ -34263,7 +34566,7 @@ init_auth();
 init_database();
 init_connector_resolver();
 import { existsSync as existsSync14, readFileSync as readFileSync8 } from "fs";
-import { join as join14 } from "path";
+import { join as join13 } from "path";
 import { spawn } from "child_process";
 function registerAuthTools(server, stripped) {
   server.registerTool("connector_auth_status", {
@@ -34399,10 +34702,10 @@ function registerAuthTools(server, stripped) {
     const oauthUrl = `http://localhost:${serverPort}/oauth/${name}/start`;
     if (noBrowser) {
       const connectorsHome2 = getConnectorsHome();
-      const tokenPaths = getConnectorConfigReadDirs(name, connectorsHome2).map((dir) => join14(dir, "profiles", "default", "tokens.json"));
+      const tokenPaths = getConnectorConfigReadDirs(name, connectorsHome2).map((dir) => join13(dir, "profiles", "default", "tokens.json"));
       let serverRunning = false;
       try {
-        await fetch(`http://localhost:${serverPort}/api/connectors`);
+        await fetch(`http://localhost:${serverPort}/health`);
         serverRunning = true;
       } catch {}
       if (!serverRunning) {
@@ -35419,7 +35722,7 @@ function buildServer() {
   return server;
 }
 
-// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/mediaType.js
+// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0+2b91fc17bf64bdfd/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/mediaType.js
 var import_content_type = __toESM(require_content_type(), 1);
 function mediaTypeEssence(header) {
   if (!header) {
@@ -35442,7 +35745,7 @@ function isJsonContentType(header) {
   return mediaTypeEssence(header) === "application/json";
 }
 
-// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0/node_modules/@modelcontextprotocol/sdk/dist/esm/server/sseKeepAlive.js
+// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0+2b91fc17bf64bdfd/node_modules/@modelcontextprotocol/sdk/dist/esm/server/sseKeepAlive.js
 var DEFAULT_SSE_KEEP_ALIVE_MS = 15000;
 var MAX_TIMER_DELAY_MS = 2 ** 31 - 1;
 function armSseKeepAlive(intervalMs, onTick) {
@@ -35454,7 +35757,7 @@ function armSseKeepAlive(intervalMs, onTick) {
   return timer;
 }
 
-// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0/node_modules/@modelcontextprotocol/sdk/dist/esm/server/webStandardStreamableHttp.js
+// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0+2b91fc17bf64bdfd/node_modules/@modelcontextprotocol/sdk/dist/esm/server/webStandardStreamableHttp.js
 class WebStandardStreamableHTTPServerTransport {
   constructor(options = {}) {
     this._started = false;