@hasna/connectors 1.4.4 → 1.4.6

package/bin/serve.js

@@ -105,6 +105,107 @@ class SqliteAdapter {
 }
 var init_sqlite_adapter = () => {};
 
+// src/lib/paths.ts
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { join, 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 (!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 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 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 ?? pathsResolverHomedir();
+  const platform = options.platform ?? process.platform;
+  if (platform === "darwin") {
+    switch (kind) {
+      case "config":
+      case "data":
+        return pathsResolverJoin(home, "Library", "Application Support", "Hasna");
+      case "cache":
+        return pathsResolverJoin(home, "Library", "Caches", "Hasna");
+      case "state":
+        return pathsResolverJoin(home, "Library", "Logs", "Hasna");
+    }
+  }
+  switch (kind) {
+    case "config":
+      return pathsResolverJoin(home, ".config", "hasna");
+    case "data":
+      return pathsResolverJoin(home, ".local", "share", "hasna");
+    case "state":
+      return pathsResolverJoin(home, ".local", "state", "hasna");
+    case "cache":
+      return pathsResolverJoin(home, ".cache", "hasna");
+  }
+}
+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 pathsResolverResolve("data", options);
+}
+function envOr(name, fallback) {
+  const value = process.env[name]?.trim();
+  return value ? value : fallback;
+}
+function effectiveHome() {
+  return process.env["HOME"] || process.env["USERPROFILE"] || homedir();
+}
+function legacyHomeDir() {
+  return join(effectiveHome(), ".hasna", "connectors");
+}
+function resolverHome() {
+  return dataDir({
+    app: "connectors",
+    home: process.env["HOME"] || process.env["USERPROFILE"] || undefined
+  });
+}
+function adoptResolverHome(resolved, env = process.env) {
+  const dataOverride = env.HASNA_DATA_HOME;
+  if (typeof dataOverride === "string" && dataOverride.trim().length > 0)
+    return true;
+  return existsSync(join(resolved, "connectors.db"));
+}
+function exactConnectorsHome() {
+  const home = envOr("HASNA_CONNECTORS_DIR", "");
+  return home ? home : undefined;
+}
+function connectorsHome() {
+  const exact = exactConnectorsHome();
+  if (exact)
+    return resolve(exact);
+  const resolved = resolverHome();
+  return adoptResolverHome(resolved) ? resolve(resolved) : resolve(legacyHomeDir());
+}
+var PATHS_RESOLVER_KIND_ENV, PATHS_RESOLVER_APP_SLUG_RE;
+var init_paths = __esm(() => {
+  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/db/database.ts
 var exports_database = {};
 __export(exports_database, {
@@ -115,33 +216,32 @@ __export(exports_database, {
   closeDatabase: () => closeDatabase,
   SqliteAdapter: () => SqliteAdapter
 });
-import { dirname, join } from "path";
-import { homedir } from "os";
-import { mkdirSync, existsSync, readdirSync, copyFileSync, statSync } from "fs";
+import { dirname, join as join2 } from "path";
+import { mkdirSync, existsSync as existsSync2, readdirSync, copyFileSync, statSync } from "fs";
 function mergeDirectoryContents(sourceDir, targetDir) {
-  if (!existsSync(sourceDir)) {
+  if (!existsSync2(sourceDir)) {
     return;
   }
   mkdirSync(targetDir, { recursive: true });
   for (const entry of readdirSync(sourceDir)) {
-    const sourcePath = join(sourceDir, entry);
-    const targetPath = join(targetDir, entry);
+    const sourcePath = join2(sourceDir, entry);
+    const targetPath = join2(targetDir, entry);
     try {
       const sourceStat = statSync(sourcePath);
       if (sourceStat.isDirectory()) {
         mergeDirectoryContents(sourcePath, targetPath);
         continue;
       }
-      if (!existsSync(targetPath)) {
+      if (!existsSync2(targetPath)) {
         copyFileSync(sourcePath, targetPath);
       }
     } catch {}
   }
 }
 function getConnectorsHome() {
-  const home = process.env["HOME"] || process.env["USERPROFILE"] || homedir();
-  const newDir = join(home, ".hasna", "connectors");
-  const legacyDirs = [join(home, ".connectors"), join(home, ".connect")];
+  const newDir = connectorsHome();
+  const home = effectiveHome();
+  const legacyDirs = [join2(home, ".connectors"), join2(home, ".connect")];
   mkdirSync(newDir, { recursive: true });
   for (const legacyDir of legacyDirs) {
     try {
@@ -289,8 +389,9 @@ var DB_DIR, DB_PATH, _db = null, _dbPath = null;
 var init_database = __esm(() => {
   init_sqlite_adapter();
   init_sqlite_adapter();
+  init_paths();
   DB_DIR = getConnectorsHome();
-  DB_PATH = join(DB_DIR, "connectors.db");
+  DB_PATH = join2(DB_DIR, "connectors.db");
 });
 
 // src/lib/llm.ts
@@ -304,14 +405,14 @@ __export(exports_llm, {
   PROVIDER_DEFAULTS: () => PROVIDER_DEFAULTS,
   LLMClient: () => LLMClient
 });
-import { existsSync as existsSync2, readFileSync, writeFileSync, mkdirSync as mkdirSync2 } from "fs";
-import { join as join2 } from "path";
+import { existsSync as existsSync3, readFileSync, writeFileSync, mkdirSync as mkdirSync2 } from "fs";
+import { join as join3 } from "path";
 function getLlmConfigPath() {
-  return join2(getConnectorsHome(), "llm.json");
+  return join3(getConnectorsHome(), "llm.json");
 }
 function getLlmConfig() {
   const path = getLlmConfigPath();
-  if (!existsSync2(path))
+  if (!existsSync3(path))
     return null;
   try {
     return JSON.parse(readFileSync(path, "utf-8"));
@@ -451,7 +552,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
@@ -596,7 +698,7 @@ function cronMatches(cron, d) {
   return matches(min, d.getMinutes(), 0, 59) && matches(hour, d.getHours(), 0, 23) && matches(dom, d.getDate(), 1, 31) && matches(mon, d.getMonth() + 1, 1, 12) && matches(dow, d.getDay(), 0, 6);
 }
 async function runConnectorCommand(connector, command, args) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const cmdArgs = [connector, command, ...args, "--format", "json"];
     const proc = spawn("connectors", ["run", ...cmdArgs], { shell: false });
     let output = "";
@@ -606,11 +708,11 @@ async function runConnectorCommand(connector, command, args) {
     proc.stderr.on("data", (d) => {
       output += d.toString();
     });
-    proc.on("close", (code) => resolve({ exitCode: code ?? 1, output }));
-    proc.on("error", () => resolve({ exitCode: 1, output: `Failed to spawn connectors run` }));
+    proc.on("close", (code) => resolve2({ exitCode: code ?? 1, output }));
+    proc.on("error", () => resolve2({ exitCode: 1, output: `Failed to spawn connectors run` }));
     setTimeout(() => {
       proc.kill();
-      resolve({ exitCode: 124, output: output + `
+      resolve2({ exitCode: 124, output: output + `
 [timeout]` });
     }, 60000);
   });
@@ -4764,28 +4866,28 @@ var init_zod = __esm(() => {
 
 // src/core/connectors/github.ts
 import { Buffer as Buffer2 } from "buffer";
-import { existsSync as existsSync3 } from "fs";
-import { dirname as dirname2, join as join3 } from "path";
+import { existsSync as existsSync4 } from "fs";
+import { dirname as dirname2, join as join4 } from "path";
 import { fileURLToPath, pathToFileURL } from "url";
 function resolveGithubConnectorDir() {
   const candidates = [
-    join3(__dirname2, "..", "..", "..", "connectors", "github"),
-    join3(__dirname2, "..", "..", "connectors", "github"),
-    join3(__dirname2, "..", "connectors", "github"),
-    join3(process.cwd(), "connectors", "github")
+    join4(__dirname2, "..", "..", "..", "connectors", "github"),
+    join4(__dirname2, "..", "..", "connectors", "github"),
+    join4(__dirname2, "..", "connectors", "github"),
+    join4(process.cwd(), "connectors", "github")
   ];
   for (const candidate of candidates) {
-    if (existsSync3(candidate)) {
+    if (existsSync4(candidate)) {
       return candidate;
     }
   }
   return candidates[0];
 }
 async function loadGitHubApiModule() {
-  return await import(pathToFileURL(join3(CONNECTOR_DIR, "src", "api", "index.ts")).href);
+  return await import(pathToFileURL(join4(CONNECTOR_DIR, "src", "api", "index.ts")).href);
 }
 async function loadGitHubConfigModule() {
-  return await import(pathToFileURL(join3(CONNECTOR_DIR, "src", "utils", "config.ts")).href);
+  return await import(pathToFileURL(join4(CONNECTOR_DIR, "src", "utils", "config.ts")).href);
 }
 function extractGlobalArgs(args) {
   const remaining = [];
@@ -5629,9 +5731,8 @@ Commands:
 });
 
 // src/core/connectors/gmail.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync2, readdirSync as readdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import { homedir as homedir2 } from "os";
-import { basename, join as join4 } from "path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync2, readdirSync as readdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { basename, join as join5 } from "path";
 async function modifyMessage(profile, messageId, addLabelIds, removeLabelIds) {
   return requestJson(profile, `/users/me/messages/${encodeURIComponent(messageId)}/modify`, {}, {
     method: "POST",
@@ -5668,7 +5769,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 ?? join5(configDirs()[0], "attachments", messageId);
   mkdirSync3(outputDir, { recursive: true });
   const attachments = input.attachmentId && input.filename ? [{
     attachmentId: input.attachmentId,
@@ -5680,7 +5781,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 = join5(outputDir, filename);
     const buffer = Buffer.from(data.data, "base64url");
     writeFileSync2(path, buffer);
     downloaded.push({
@@ -5750,7 +5851,7 @@ function gmailBackoffDelayMs(attempt, retryAfter = null) {
   return Math.min(2 ** attempt * baseMs + jitterMs, 64000);
 }
 function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 async function getValidAccessToken(profile) {
   if (process.env.GMAIL_ACCESS_TOKEN)
@@ -5797,8 +5898,8 @@ async function refreshAccessToken(profile, currentTokens) {
 function listProfiles() {
   const profiles = new Set;
   for (const baseDir of configDirs()) {
-    const profilesDir = join4(baseDir, "profiles");
-    if (!existsSync4(profilesDir))
+    const profilesDir = join5(baseDir, "profiles");
+    if (!existsSync5(profilesDir))
       continue;
     for (const entry of readdirSync2(profilesDir, { withFileTypes: true })) {
       if (entry.isDirectory())
@@ -5816,8 +5917,8 @@ function loadCredentials(profile) {
     return { clientId: envClientId, clientSecret: envClientSecret };
   for (const baseDir of configDirs()) {
     const credentials = {
-      ...readJson(join4(baseDir, "credentials.json")),
-      ...readJson(join4(baseDir, "profiles", profile, "config.json"))
+      ...readJson(join5(baseDir, "credentials.json")),
+      ...readJson(join5(baseDir, "profiles", profile, "config.json"))
     };
     if (credentials.clientId || credentials.clientSecret)
       return credentials;
@@ -5826,30 +5927,30 @@ function loadCredentials(profile) {
 }
 function loadTokens(profile) {
   for (const baseDir of configDirs()) {
-    const fromProfile = readJson(join4(baseDir, "profiles", profile, "tokens.json"));
+    const fromProfile = readJson(join5(baseDir, "profiles", profile, "tokens.json"));
     if (fromProfile)
       return fromProfile;
-    const flat = readJson(join4(baseDir, "profiles", `${profile}.json`));
+    const flat = readJson(join5(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) => existsSync4(dir)) ?? configDirs()[0];
-  const profileDir = join4(baseDir, "profiles", profile);
+  const baseDir = configDirs().find((dir) => existsSync5(dir)) ?? configDirs()[0];
+  const profileDir = join5(baseDir, "profiles", profile);
   mkdirSync3(profileDir, { recursive: true });
-  writeFileSync2(join4(profileDir, "tokens.json"), JSON.stringify(tokens, null, 2), { mode: 384 });
+  writeFileSync2(join5(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 ?? join4(homedir2(), ".hasna", "connectors");
-  return [join4(baseDir, "gmail"), join4(baseDir, "connect-gmail")];
+  const baseDir = connectorsHome();
+  return [join5(baseDir, "gmail"), join5(baseDir, "connect-gmail")];
 }
 function readJson(path) {
-  if (!existsSync4(path))
+  if (!existsSync5(path))
     return null;
   try {
     return JSON.parse(readFileSync2(path, "utf8"));
@@ -5930,6 +6031,7 @@ function safeFilename(filename) {
 }
 var GMAIL_API_BASE = "https://gmail.googleapis.com/gmail/v1", TOKEN_URL = "https://oauth2.googleapis.com/token", REFRESH_BUFFER_MS, MAX_GMAIL_RETRIES = 5, listMessagesSchema, messageIdSchema, readMessageSchema, attachmentListSchema, attachmentDownloadSchema, historyListSchema, replySchema, gmailConnector;
 var init_gmail = __esm(() => {
+  init_paths();
   init_zod();
   init_connector();
   REFRESH_BUFFER_MS = 5 * 60 * 1000;
@@ -6099,9 +6201,8 @@ var init_gmail = __esm(() => {
 });
 
 // src/core/connectors/googledrive.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync3, readdirSync as readdirSync3, writeFileSync as writeFileSync3 } from "fs";
-import { homedir as homedir3 } from "os";
-import { basename as basename2, join as join5 } from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync3, readdirSync as readdirSync3, writeFileSync as writeFileSync3 } from "fs";
+import { basename as basename2, join as join6 } from "path";
 async function requestJson2(profile, path, params) {
   const response = await request(profile, path, params);
   const text = await response.text();
@@ -6169,8 +6270,8 @@ async function refreshAccessToken2(profile, currentTokens) {
 function listProfiles2() {
   const profiles = new Set;
   for (const baseDir of configDirs2()) {
-    const profilesDir = join5(baseDir, "profiles");
-    if (!existsSync5(profilesDir))
+    const profilesDir = join6(baseDir, "profiles");
+    if (!existsSync6(profilesDir))
       continue;
     for (const entry of readdirSync3(profilesDir, { withFileTypes: true })) {
       if (entry.isDirectory())
@@ -6217,8 +6318,8 @@ function loadCredentials2(profile) {
     return { clientId: envClientId, clientSecret: envClientSecret };
   for (const baseDir of configDirs2()) {
     const credentials = {
-      ...readJson2(join5(baseDir, "credentials.json")),
-      ...readJson2(join5(baseDir, "profiles", profile, "config.json"))
+      ...readJson2(join6(baseDir, "credentials.json")),
+      ...readJson2(join6(baseDir, "profiles", profile, "config.json"))
     };
     if (credentials.clientId || credentials.clientSecret)
       return credentials;
@@ -6227,30 +6328,30 @@ function loadCredentials2(profile) {
 }
 function loadTokens2(profile) {
   for (const baseDir of configDirs2()) {
-    const fromProfile = readJson2(join5(baseDir, "profiles", profile, "tokens.json"));
+    const fromProfile = readJson2(join6(baseDir, "profiles", profile, "tokens.json"));
     if (fromProfile)
       return fromProfile;
-    const flat = readJson2(join5(baseDir, "profiles", `${profile}.json`));
+    const flat = readJson2(join6(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) => existsSync5(dir)) ?? configDirs2()[0];
-  const profileDir = join5(baseDir, "profiles", profile);
+  const baseDir = configDirs2().find((dir) => existsSync6(dir)) ?? configDirs2()[0];
+  const profileDir = join6(baseDir, "profiles", profile);
   mkdirSync4(profileDir, { recursive: true });
-  writeFileSync3(join5(profileDir, "tokens.json"), JSON.stringify(tokens, null, 2), { mode: 384 });
+  writeFileSync3(join6(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 ?? join5(homedir3(), ".hasna", "connectors");
-  return [join5(baseDir, "googledrive"), join5(baseDir, "connect-googledrive")];
+  const baseDir = connectorsHome();
+  return [join6(baseDir, "googledrive"), join6(baseDir, "connect-googledrive")];
 }
 function readJson2(path) {
-  if (!existsSync5(path))
+  if (!existsSync6(path))
     return null;
   try {
     return JSON.parse(readFileSync3(path, "utf8"));
@@ -6284,6 +6385,7 @@ function extractGoogleError(body) {
 }
 var DRIVE_API_BASE = "https://www.googleapis.com/drive/v3", TOKEN_URL2 = "https://oauth2.googleapis.com/token", REFRESH_BUFFER_MS2, DEFAULT_FILE_FIELDS, DEFAULT_EXPORT_FORMATS, EXPORT_EXTENSIONS, listFilesSchema, listDrivesSchema, fileIdSchema, downloadSchema, profilesStatusSchema, googleDriveConnector;
 var init_googledrive = __esm(() => {
+  init_paths();
   init_zod();
   init_connector();
   REFRESH_BUFFER_MS2 = 5 * 60 * 1000;
@@ -6433,7 +6535,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/connectors",
-    version: "1.4.4",
+    version: "1.4.6",
     description: "Open source connector library - Install API connectors with a single command",
     type: "module",
     bin: {
@@ -6444,7 +6546,6 @@ var init_package = __esm(() => {
     files: [
       "bin/",
       "dist/",
-      "dashboard/dist/",
       "connectors/",
       "README.md",
       "!connectors/**/.test-home/**",
@@ -6464,20 +6565,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"
     },
@@ -6497,7 +6601,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",
@@ -6527,18 +6631,19 @@ 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"
     }
   };
 });
 
 // src/lib/connector-resolver.ts
-import { existsSync as existsSync6, readdirSync as readdirSync4, statSync as statSync2 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync7, readdirSync as readdirSync4, statSync as statSync2 } from "fs";
+import { join as join7 } from "path";
 function stripLegacyPrefix(name) {
   return name.startsWith(LEGACY_CONNECTOR_PREFIX) ? name.slice(LEGACY_CONNECTOR_PREFIX.length) : name;
 }
@@ -6581,8 +6686,8 @@ function connectorPackageDirNames(name) {
 function resolveConnectorPackagePath(connectorsDir, name) {
   const resolution = resolveConnectorName(name);
   const dirNames = connectorPackageDirNames(name);
-  const checkedPaths = dirNames.map((dirName) => join6(connectorsDir, dirName));
-  const existingPath = checkedPaths.find((path) => existsSync6(path)) ?? null;
+  const checkedPaths = dirNames.map((dirName) => join7(connectorsDir, dirName));
+  const existingPath = checkedPaths.find((path) => existsSync7(path)) ?? null;
   const existingDirName = existingPath ? dirNames[checkedPaths.indexOf(existingPath)] : null;
   return {
     ...resolution,
@@ -6598,16 +6703,16 @@ function getConnectorPackagePath(connectorsDir, name) {
   const resolved = resolveConnectorPackagePath(connectorsDir, name);
   return resolved.existingPath ?? resolved.preferredPath;
 }
-function resolveConnectorConfigPaths(name, connectorsHome = getConnectorsHome()) {
+function resolveConnectorConfigPaths(name, connectorsHome2 = getConnectorsHome()) {
   const resolution = resolveConnectorName(name);
   const preferredDirName = resolution.canonicalName || resolution.legacyName;
-  const preferredPath = join6(connectorsHome, preferredDirName);
-  const legacyPath = join6(connectorsHome, resolution.legacyName);
+  const preferredPath = join7(connectorsHome2, preferredDirName);
+  const legacyPath = join7(connectorsHome2, resolution.legacyName);
   const paths = preferredPath === legacyPath ? [preferredPath] : [preferredPath, legacyPath];
-  const existingPaths = paths.filter((path) => existsSync6(path));
+  const existingPaths = paths.filter((path) => existsSync7(path));
   return {
     ...resolution,
-    connectorsHome,
+    connectorsHome: connectorsHome2,
     preferredDirName,
     preferredPath,
     legacyPath,
@@ -6615,18 +6720,18 @@ function resolveConnectorConfigPaths(name, connectorsHome = getConnectorsHome())
     readPaths: paths
   };
 }
-function getConnectorConfigDir(name, connectorsHome = getConnectorsHome()) {
-  return resolveConnectorConfigPaths(name, connectorsHome).preferredPath;
+function getConnectorConfigDir(name, connectorsHome2 = getConnectorsHome()) {
+  return resolveConnectorConfigPaths(name, connectorsHome2).preferredPath;
 }
-function getConnectorConfigReadDirs(name, connectorsHome = getConnectorsHome()) {
-  return resolveConnectorConfigPaths(name, connectorsHome).readPaths;
+function getConnectorConfigReadDirs(name, connectorsHome2 = getConnectorsHome()) {
+  return resolveConnectorConfigPaths(name, connectorsHome2).readPaths;
 }
-function listConfiguredConnectorNames(connectorsHome = getConnectorsHome()) {
-  if (!existsSync6(connectorsHome))
+function listConfiguredConnectorNames(connectorsHome2 = getConnectorsHome()) {
+  if (!existsSync7(connectorsHome2))
     return [];
   const names = new Set;
-  for (const entry of readdirSync4(connectorsHome)) {
-    const fullPath = join6(connectorsHome, entry);
+  for (const entry of readdirSync4(connectorsHome2)) {
+    const fullPath = join7(connectorsHome2, entry);
     try {
       if (!statSync2(fullPath).isDirectory())
         continue;
@@ -6649,7 +6754,7 @@ var init_connector_resolver = __esm(() => {
 
 // src/core/connectors/imessage.ts
 import {
-  existsSync as existsSync7,
+  existsSync as existsSync8,
   mkdirSync as mkdirSync5,
   readFileSync as readFileSync4,
   readdirSync as readdirSync5,
@@ -6657,7 +6762,7 @@ import {
   statSync as statSync3,
   writeFileSync as writeFileSync4
 } from "fs";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 function buildRootHelp(specs) {
   const lines = [
     "Usage: connect-imessage [options] [command]",
@@ -6708,12 +6813,12 @@ function getConfigReadDirs() {
   return getConnectorConfigReadDirs(CONNECTOR_NAME);
 }
 function getProfilesDir() {
-  return join7(getConfigDir(), "profiles");
+  return join8(getConfigDir(), "profiles");
 }
 function getCurrentProfile() {
   for (const configDir of getConfigReadDirs()) {
-    const currentProfileFile = join7(configDir, "current_profile");
-    if (!existsSync7(currentProfileFile))
+    const currentProfileFile = join8(configDir, "current_profile");
+    if (!existsSync8(currentProfileFile))
       continue;
     try {
       return readFileSync4(currentProfileFile, "utf-8").trim() || "default";
@@ -6726,16 +6831,16 @@ function getCurrentProfile() {
 function setCurrentProfile(profile) {
   const configDir = getConfigDir();
   mkdirSync5(configDir, { recursive: true });
-  writeFileSync4(join7(configDir, "current_profile"), profile);
+  writeFileSync4(join8(configDir, "current_profile"), profile);
 }
 function getFlatProfilePath(profile) {
-  return join7(getProfilesDir(), `${profile}.json`);
+  return join8(getProfilesDir(), `${profile}.json`);
 }
 function getFlatProfileReadPaths(profile) {
-  return getConfigReadDirs().map((dir) => join7(dir, "profiles", `${profile}.json`));
+  return getConfigReadDirs().map((dir) => join8(dir, "profiles", `${profile}.json`));
 }
 function getDirectoryProfileReadPaths(profile) {
-  return getConfigReadDirs().map((dir) => join7(dir, "profiles", profile, "config.json"));
+  return getConfigReadDirs().map((dir) => join8(dir, "profiles", profile, "config.json"));
 }
 function loadJsonFile(path) {
   try {
@@ -6755,8 +6860,8 @@ function sanitizeProfileConfig(config) {
   };
 }
 function loadProfile(profile = getCurrentProfile()) {
-  const flatConfig = getFlatProfileReadPaths(profile).reverse().reduce((config, path) => ({ ...config, ...existsSync7(path) ? loadJsonFile(path) : {} }), {});
-  const directoryConfig = getDirectoryProfileReadPaths(profile).reverse().reduce((config, path) => ({ ...config, ...existsSync7(path) ? loadJsonFile(path) : {} }), {});
+  const flatConfig = getFlatProfileReadPaths(profile).reverse().reduce((config, path) => ({ ...config, ...existsSync8(path) ? loadJsonFile(path) : {} }), {});
+  const directoryConfig = getDirectoryProfileReadPaths(profile).reverse().reduce((config, path) => ({ ...config, ...existsSync8(path) ? loadJsonFile(path) : {} }), {});
   return sanitizeProfileConfig({
     ...flatConfig,
     ...directoryConfig
@@ -6772,17 +6877,17 @@ function profileExists(profile) {
   if (profile === "default") {
     return true;
   }
-  return getFlatProfileReadPaths(profile).some((path) => existsSync7(path)) || getConfigReadDirs().some((dir) => existsSync7(join7(dir, "profiles", profile)));
+  return getFlatProfileReadPaths(profile).some((path) => existsSync8(path)) || getConfigReadDirs().some((dir) => existsSync8(join8(dir, "profiles", profile)));
 }
 function listProfiles3() {
   const seen = new Set(["default"]);
   for (const configDir of getConfigReadDirs()) {
-    const profilesDir = join7(configDir, "profiles");
-    if (!existsSync7(profilesDir))
+    const profilesDir = join8(configDir, "profiles");
+    if (!existsSync8(profilesDir))
       continue;
     try {
       for (const entry of readdirSync5(profilesDir)) {
-        const fullPath = join7(profilesDir, entry);
+        const fullPath = join8(profilesDir, entry);
         const stat = statSync3(fullPath);
         if (stat.isDirectory()) {
           seen.add(entry);
@@ -6804,11 +6909,11 @@ function createProfile(profile, config = {}) {
 }
 function clearProfile(profile = getCurrentProfile()) {
   const flatPath = getFlatProfilePath(profile);
-  const directoryPath = join7(getProfilesDir(), profile);
-  if (existsSync7(flatPath)) {
+  const directoryPath = join8(getProfilesDir(), profile);
+  if (existsSync8(flatPath)) {
     rmSync(flatPath);
   }
-  if (existsSync7(directoryPath)) {
+  if (existsSync8(directoryPath)) {
     rmSync(directoryPath, { recursive: true, force: true });
   }
 }
@@ -7441,7 +7546,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();
@@ -7734,18 +7839,18 @@ var init_imessage = __esm(() => {
 });
 
 // src/core/connectors/stripe.ts
-import { existsSync as existsSync8 } from "fs";
-import { dirname as dirname3, join as join8 } from "path";
+import { existsSync as existsSync9 } from "fs";
+import { dirname as dirname3, join as join9 } from "path";
 import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL2 } from "url";
 function resolveStripeConnectorDir() {
   const candidates = [
-    join8(__dirname3, "..", "..", "..", "connectors", "stripe"),
-    join8(__dirname3, "..", "..", "connectors", "stripe"),
-    join8(__dirname3, "..", "connectors", "stripe"),
-    join8(process.cwd(), "connectors", "stripe")
+    join9(__dirname3, "..", "..", "..", "connectors", "stripe"),
+    join9(__dirname3, "..", "..", "connectors", "stripe"),
+    join9(__dirname3, "..", "connectors", "stripe"),
+    join9(process.cwd(), "connectors", "stripe")
   ];
   for (const candidate of candidates) {
-    if (existsSync8(candidate)) {
+    if (existsSync9(candidate)) {
       return candidate;
     }
   }
@@ -7793,10 +7898,10 @@ function buildCommandHelp2(spec) {
 `);
 }
 async function loadStripeApiModule() {
-  return await import(pathToFileURL2(join8(CONNECTOR_DIR2, "src", "api", "index.ts")).href);
+  return await import(pathToFileURL2(join9(CONNECTOR_DIR2, "src", "api", "index.ts")).href);
 }
 async function loadStripeConfigModule() {
-  return await import(pathToFileURL2(join8(CONNECTOR_DIR2, "src", "utils", "config.ts")).href);
+  return await import(pathToFileURL2(join9(CONNECTOR_DIR2, "src", "utils", "config.ts")).href);
 }
 function extractGlobalArgs3(args) {
   const remaining = [];
@@ -8642,30 +8747,30 @@ __export(exports_installer, {
   getConnectorDocs: () => getConnectorDocs,
   connectorExists: () => connectorExists
 });
-import { existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync5, readdirSync as readdirSync6, statSync as statSync4, rmSync as rmSync2 } from "fs";
-import { join as join10, dirname as dirname5 } from "path";
+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 join11, dirname as dirname5 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 function resolveConnectorsDir() {
-  const fromBin = join10(__dirname4, "..", "connectors");
-  if (existsSync10(fromBin))
+  const fromBin = join11(__dirname4, "..", "connectors");
+  if (existsSync11(fromBin))
     return fromBin;
-  const fromSrc = join10(__dirname4, "..", "..", "connectors");
-  if (existsSync10(fromSrc))
+  const fromSrc = join11(__dirname4, "..", "..", "connectors");
+  if (existsSync11(fromSrc))
     return fromSrc;
   return fromBin;
 }
 function getProjectConnectorsDir(targetDir) {
-  return join10(targetDir, PROJECT_CONNECTORS_DIRNAME);
+  return join11(targetDir, PROJECT_CONNECTORS_DIRNAME);
 }
 function getEnablementManifestPath(targetDir) {
-  return join10(getProjectConnectorsDir(targetDir), ENABLEMENT_MANIFEST_FILENAME);
+  return join11(getProjectConnectorsDir(targetDir), ENABLEMENT_MANIFEST_FILENAME);
 }
 function getLegacyInstallPath(targetDir, name) {
-  return join10(getProjectConnectorsDir(targetDir), legacyConnectorName(name));
+  return join11(getProjectConnectorsDir(targetDir), legacyConnectorName(name));
 }
 function loadEnablementManifest(targetDir) {
   const manifestPath = getEnablementManifestPath(targetDir);
-  if (!existsSync10(manifestPath)) {
+  if (!existsSync11(manifestPath)) {
     return null;
   }
   try {
@@ -8685,11 +8790,11 @@ function loadEnablementManifest(targetDir) {
 }
 function getLegacyInstalledConnectors(targetDir) {
   const connectorsDir = getProjectConnectorsDir(targetDir);
-  if (!existsSync10(connectorsDir)) {
+  if (!existsSync11(connectorsDir)) {
     return [];
   }
   return readdirSync6(connectorsDir).filter((entry) => {
-    const fullPath = join10(connectorsDir, entry);
+    const fullPath = join11(connectorsDir, entry);
     return entry.startsWith("connect-") && statSync4(fullPath).isDirectory();
   }).map((entry) => entry.replace("connect-", "")).sort();
 }
@@ -8698,7 +8803,7 @@ function getEnabledConnectors(targetDir) {
   return [...new Set([...manifestConnectors, ...getLegacyInstalledConnectors(targetDir)])].sort();
 }
 function updateConnectorsIndex(connectorsDir, connectors18) {
-  const indexPath = join10(connectorsDir, ENABLEMENT_INDEX_FILENAME);
+  const indexPath = join11(connectorsDir, ENABLEMENT_INDEX_FILENAME);
   const connectorList = connectors18.map((connector) => `  "${connector}",`).join(`
 `);
   const content = `/**
@@ -8734,7 +8839,7 @@ function getConnectorPath(name) {
 }
 function connectorExists(name) {
   const normalizedName = normalizeConnectorName(name);
-  return hasInternalConnectorDefinition(normalizedName) || existsSync10(getConnectorPath(normalizedName));
+  return hasInternalConnectorDefinition(normalizedName) || existsSync11(getConnectorPath(normalizedName));
 }
 function installConnector(name, options = {}) {
   const { targetDir = process.cwd(), overwrite = false } = options;
@@ -8767,7 +8872,7 @@ function installConnector(name, options = {}) {
   try {
     const nextEnabled = [...new Set([...installed, normalizedName])].sort();
     writeEnablementManifest(targetDir, nextEnabled);
-    if (overwrite && existsSync10(legacyInstallPath)) {
+    if (overwrite && existsSync11(legacyInstallPath)) {
       rmSync2(legacyInstallPath, { recursive: true });
     }
     return {
@@ -8802,8 +8907,8 @@ function parseConnectorDocs(raw) {
 function getConnectorDocs(name) {
   const normalizedName = normalizeConnectorName(name);
   const connectorPath = getConnectorPath(normalizedName);
-  const claudeMdPath = join10(connectorPath, "CLAUDE.md");
-  if (existsSync10(claudeMdPath)) {
+  const claudeMdPath = join11(connectorPath, "CLAUDE.md");
+  if (existsSync11(claudeMdPath)) {
     return parseConnectorDocs(readFileSync6(claudeMdPath, "utf-8"));
   }
   const internalDocs = getInternalConnectorDefinition(normalizedName)?.docsMarkdown;
@@ -8848,7 +8953,7 @@ function removeConnector(name, targetDir = process.cwd()) {
   const nextEnabled = installed.filter((connector) => connector !== normalizedName);
   writeEnablementManifest(targetDir, nextEnabled);
   const legacyInstallPath = getLegacyInstallPath(targetDir, normalizedName);
-  if (existsSync10(legacyInstallPath)) {
+  if (existsSync11(legacyInstallPath)) {
     rmSync2(legacyInstallPath, { recursive: true });
   }
   return true;
@@ -8862,7 +8967,7 @@ var init_installer = __esm(() => {
 });
 
 // src/lib/lock.ts
-import { openSync, closeSync, unlinkSync, existsSync as existsSync11, statSync as statSync5 } from "fs";
+import { openSync, closeSync, unlinkSync, existsSync as existsSync12, statSync as statSync5 } from "fs";
 import { mkdirSync as mkdirSync7 } from "fs";
 function lockPath(connector) {
   const dir = getConnectorConfigDir(connector);
@@ -8878,7 +8983,7 @@ function isStale(path) {
   }
 }
 function tryAcquire(path) {
-  if (existsSync11(path) && isStale(path)) {
+  if (existsSync12(path) && isStale(path)) {
     try {
       unlinkSync(path);
     } catch {}
@@ -8910,7 +9015,7 @@ async function withWriteLock(connector, fn) {
         release(path);
       }
     }
-    await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_MS));
+    await new Promise((resolve2) => setTimeout(resolve2, LOCK_RETRY_MS));
   }
   throw new LockTimeoutError(connector);
 }
@@ -8928,9 +9033,9 @@ var init_lock = __esm(() => {
 });
 
 // src/server/auth.ts
-import { chmodSync, existsSync as existsSync12, readFileSync as readFileSync7, writeFileSync as writeFileSync6, mkdirSync as mkdirSync8, readdirSync as readdirSync7, rmSync as rmSync3, statSync as statSync6 } from "fs";
+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 { randomBytes } from "crypto";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 function getAuthType(name) {
   name = normalizeConnectorName(name);
   const docs = getConnectorDocs(name);
@@ -8971,8 +9076,8 @@ function writePrivateText(path, data) {
 function getCurrentProfile2(name) {
   name = normalizeConnectorName(name);
   for (const configDir of getConnectorConfigReadDirs2(name)) {
-    const currentProfileFile = join11(configDir, "current_profile");
-    if (existsSync12(currentProfileFile)) {
+    const currentProfileFile = join12(configDir, "current_profile");
+    if (existsSync13(currentProfileFile)) {
       try {
         return readFileSync7(currentProfileFile, "utf-8").trim() || "default";
       } catch {
@@ -8985,14 +9090,14 @@ function getCurrentProfile2(name) {
 function loadProfileConfigFromDir(configDir, profile) {
   let flatConfig = {};
   let dirConfig = {};
-  const profileFile = join11(configDir, "profiles", `${profile}.json`);
-  if (existsSync12(profileFile)) {
+  const profileFile = join12(configDir, "profiles", `${profile}.json`);
+  if (existsSync13(profileFile)) {
     try {
       flatConfig = JSON.parse(readFileSync7(profileFile, "utf-8"));
     } catch {}
   }
-  const profileDirConfig = join11(configDir, "profiles", profile, "config.json");
-  if (existsSync12(profileDirConfig)) {
+  const profileDirConfig = join12(configDir, "profiles", profile, "config.json");
+  if (existsSync13(profileDirConfig)) {
     try {
       dirConfig = JSON.parse(readFileSync7(profileDirConfig, "utf-8"));
     } catch {}
@@ -9012,8 +9117,8 @@ function loadTokens3(name) {
   name = normalizeConnectorName(name);
   const profile = getCurrentProfile2(name);
   for (const configDir of getConnectorConfigReadDirs2(name)) {
-    const tokensFile = join11(configDir, "profiles", profile, "tokens.json");
-    if (existsSync12(tokensFile)) {
+    const tokensFile = join12(configDir, "profiles", profile, "tokens.json");
+    if (existsSync13(tokensFile)) {
       try {
         return JSON.parse(readFileSync7(tokensFile, "utf-8"));
       } catch {
@@ -9146,10 +9251,10 @@ function _saveApiKey(name, key, field) {
   const profile = getCurrentProfile2(name);
   const keyField = field || guessKeyField(name);
   if (keyField === "clientId" || keyField === "clientSecret") {
-    const credentialsFile = join11(configDir, "credentials.json");
+    const credentialsFile = join12(configDir, "credentials.json");
     ensurePrivateDir(configDir);
     let creds = {};
-    if (existsSync12(credentialsFile)) {
+    if (existsSync13(credentialsFile)) {
       try {
         creds = JSON.parse(readFileSync7(credentialsFile, "utf-8"));
       } catch {}
@@ -9158,10 +9263,10 @@ function _saveApiKey(name, key, field) {
     writePrivateJson(credentialsFile, creds);
     return;
   }
-  const profilesDir = join11(configDir, "profiles");
-  const profileFile = join11(profilesDir, `${profile}.json`);
-  const profileDir = join11(profilesDir, profile);
-  if (existsSync12(profileFile)) {
+  const profilesDir = join12(configDir, "profiles");
+  const profileFile = join12(profilesDir, `${profile}.json`);
+  const profileDir = join12(profilesDir, profile);
+  if (existsSync13(profileFile)) {
     let config = {};
     try {
       config = JSON.parse(readFileSync7(profileFile, "utf-8"));
@@ -9172,10 +9277,10 @@ function _saveApiKey(name, key, field) {
     writePrivateJson(profileFile, config);
     return;
   }
-  if (existsSync12(profileDir)) {
-    const configFile = join11(profileDir, "config.json");
+  if (existsSync13(profileDir)) {
+    const configFile = join12(profileDir, "config.json");
     let config = {};
-    if (existsSync12(configFile)) {
+    if (existsSync13(configFile)) {
       try {
         config = JSON.parse(readFileSync7(configFile, "utf-8"));
       } catch {}
@@ -9190,7 +9295,7 @@ function _saveApiKey(name, key, field) {
   ensurePrivateDir(configDir);
   ensurePrivateDir(profilesDir);
   ensurePrivateDir(profileDir);
-  writePrivateJson(join11(profileDir, "config.json"), { [keyField]: key });
+  writePrivateJson(join12(profileDir, "config.json"), { [keyField]: key });
 }
 function guessKeyField(name) {
   name = normalizeConnectorName(name);
@@ -9212,8 +9317,8 @@ function guessKeyField(name) {
 function getOAuthConfig(name) {
   name = normalizeConnectorName(name);
   for (const configDir of getConnectorConfigReadDirs2(name)) {
-    const credentialsFile = join11(configDir, "credentials.json");
-    if (existsSync12(credentialsFile)) {
+    const credentialsFile = join12(configDir, "credentials.json");
+    if (existsSync13(credentialsFile)) {
       try {
         const creds = JSON.parse(readFileSync7(credentialsFile, "utf-8"));
         return { clientId: creds.clientId, clientSecret: creds.clientSecret };
@@ -9299,12 +9404,12 @@ function saveOAuthTokens(name, tokens) {
   name = normalizeConnectorName(name);
   const configDir = getConnectorConfigDir2(name);
   const profile = getCurrentProfile2(name);
-  const profilesDir = join11(configDir, "profiles");
-  const profileDir = join11(profilesDir, profile);
+  const profilesDir = join12(configDir, "profiles");
+  const profileDir = join12(profilesDir, profile);
   ensurePrivateDir(configDir);
   ensurePrivateDir(profilesDir);
   ensurePrivateDir(profileDir);
-  const tokensFile = join11(profileDir, "tokens.json");
+  const tokensFile = join12(profileDir, "tokens.json");
   writePrivateJson(tokensFile, tokens);
 }
 async function refreshOAuthToken(name) {
@@ -9351,13 +9456,13 @@ function listProfiles4(name) {
   name = normalizeConnectorName(name);
   const seen = new Set;
   for (const configDir of getConnectorConfigReadDirs2(name)) {
-    const profilesDir = join11(configDir, "profiles");
-    if (!existsSync12(profilesDir))
+    const profilesDir = join12(configDir, "profiles");
+    if (!existsSync13(profilesDir))
       continue;
     try {
       const entries = readdirSync7(profilesDir);
       for (const entry of entries) {
-        const fullPath = join11(profilesDir, entry);
+        const fullPath = join12(profilesDir, entry);
         const stat = statSync6(fullPath);
         if (stat.isDirectory()) {
           seen.add(entry);
@@ -9374,24 +9479,24 @@ function switchProfile(name, profile) {
   name = normalizeConnectorName(name);
   const configDir = getConnectorConfigDir2(name);
   ensurePrivateDir(configDir);
-  writePrivateText(join11(configDir, "current_profile"), profile);
+  writePrivateText(join12(configDir, "current_profile"), profile);
 }
 function deleteProfile2(name, profile) {
   name = normalizeConnectorName(name);
   if (profile === "default")
     return false;
   const configDir = getConnectorConfigDir2(name);
-  const profilesDir = join11(configDir, "profiles");
-  const profileFile = join11(profilesDir, `${profile}.json`);
-  if (existsSync12(profileFile)) {
+  const profilesDir = join12(configDir, "profiles");
+  const profileFile = join12(profilesDir, `${profile}.json`);
+  if (existsSync13(profileFile)) {
     rmSync3(profileFile);
     if (getCurrentProfile2(name) === profile) {
       switchProfile(name, "default");
     }
     return true;
   }
-  const profileDir = join11(profilesDir, profile);
-  if (existsSync12(profileDir)) {
+  const profileDir = join12(profilesDir, profile);
+  if (existsSync13(profileDir)) {
     rmSync3(profileDir, { recursive: true });
     if (getCurrentProfile2(name) === profile) {
       switchProfile(name, "default");
@@ -9465,16 +9570,16 @@ __export(exports_runner, {
   buildEnvWithCredentials: () => buildEnvWithCredentials,
   buildConnectorOperationArgs: () => buildConnectorOperationArgs
 });
-import { existsSync as existsSync13, readdirSync as readdirSync8 } from "fs";
-import { join as join12, dirname as dirname6 } from "path";
+import { existsSync as existsSync14, readdirSync as readdirSync8 } from "fs";
+import { join as join13, dirname as dirname6 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 import { spawn as spawn2 } from "child_process";
 function resolveConnectorsDir2() {
-  const fromBin = join12(__dirname5, "..", "connectors");
-  if (existsSync13(fromBin))
+  const fromBin = join13(__dirname5, "..", "connectors");
+  if (existsSync14(fromBin))
     return fromBin;
-  const fromSrc = join12(__dirname5, "..", "..", "connectors");
-  if (existsSync13(fromSrc))
+  const fromSrc = join13(__dirname5, "..", "..", "connectors");
+  if (existsSync14(fromSrc))
     return fromSrc;
   return fromBin;
 }
@@ -9542,8 +9647,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 = join12(connectorDir, "src", "cli", "index.ts");
-  if (existsSync13(cliPath))
+  const cliPath = join13(connectorDir, "src", "cli", "index.ts");
+  if (existsSync14(cliPath))
     return cliPath;
   return null;
 }
@@ -9737,7 +9842,7 @@ function runLegacyConnectorCommand(name, args, timeoutMs = 30000) {
       success: false
     });
   }
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const proc = spawn2("bun", ["run", cliPath, ...args], {
       timeout: timeoutMs,
       env: buildEnvWithCredentials(connectorName, process.env),
@@ -9752,7 +9857,7 @@ function runLegacyConnectorCommand(name, args, timeoutMs = 30000) {
       stderr += data.toString();
     });
     proc.on("close", (code) => {
-      resolve({
+      resolve2({
         stdout: stdout.trim(),
         stderr: stderr.trim(),
         exitCode: code ?? 1,
@@ -9760,7 +9865,7 @@ function runLegacyConnectorCommand(name, args, timeoutMs = 30000) {
       });
     });
     proc.on("error", (err) => {
-      resolve({
+      resolve2({
         stdout: "",
         stderr: err.message,
         exitCode: 1,
@@ -12845,7 +12950,7 @@ var require_compile = __commonJS((exports) => {
     const schOrFunc = root.refs[ref];
     if (schOrFunc)
       return schOrFunc;
-    let _sch = resolve.call(this, root, ref);
+    let _sch = resolve2.call(this, root, ref);
     if (_sch === undefined) {
       const schema = (_a = root.localRefs) === null || _a === undefined ? undefined : _a[ref];
       const { schemaId } = this.opts;
@@ -12872,7 +12977,7 @@ var require_compile = __commonJS((exports) => {
   function sameSchemaEnv(s1, s2) {
     return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
   }
-  function resolve(root, ref) {
+  function resolve2(root, ref) {
     let sch;
     while (typeof (sch = this.refs[ref]) == "string")
       ref = sch;
@@ -12961,13 +13066,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;
@@ -12992,91 +13116,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;
-        }
-        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;
+  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;
         }
-        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;
@@ -13196,7 +13351,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();
@@ -13210,10 +13366,152 @@ var require_utils = __commonJS((exports, module) => {
           continue;
         }
       }
-      if (isPathCharacter(input[i])) {
-        output += input[i];
+      if (isPathCharacter(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;
+  }
+  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 {
-        output += escape(input[i]);
+        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;
@@ -13236,14 +13534,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);
@@ -13252,8 +13554,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;
   }
@@ -13263,6 +13569,11 @@ var require_utils = __commonJS((exports, module) => {
     reescapeHostDelimiters,
     normalizePercentEncoding,
     normalizePathEncoding,
+    serializePathEncoding,
+    normalizeQueryFragmentEncoding,
+    encodeUserinfo,
+    encodeQuery,
+    encodeFragment,
     escapePreservingEscapes,
     removeDotSegments,
     isIPv4,
@@ -13272,10 +13583,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",
@@ -13330,9 +13641,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;
@@ -13344,7 +13656,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];
@@ -13446,10 +13758,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);
@@ -13458,14 +13779,36 @@ var require_fast_uri = __commonJS((exports, module) => {
     }
     return uri;
   }
-  function resolve(baseURI, relativeURI, options) {
+  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);
   }
@@ -13525,7 +13868,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 = {
@@ -13546,20 +13889,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);
@@ -13577,16 +13923,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("");
   }
@@ -13602,6 +13951,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 = {
@@ -13614,6 +13993,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) {
@@ -13650,6 +14034,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];
       }
@@ -13661,9 +14058,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;
         }
@@ -13681,42 +14085,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;
@@ -13725,25 +14123,33 @@ 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,
     normalize,
-    resolve,
+    resolve: resolve2,
     resolveComponent,
     equal,
     serialize,
@@ -16613,709 +17019,8 @@ var init_usage = __esm(() => {
   init_database();
 });
 
-// ../../node_modules/.bun/is-docker@3.0.0/node_modules/is-docker/index.js
-import fs from "fs";
-function hasDockerEnv() {
-  try {
-    fs.statSync("/.dockerenv");
-    return true;
-  } catch {
-    return false;
-  }
-}
-function hasDockerCGroup() {
-  try {
-    return fs.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
-  } catch {
-    return false;
-  }
-}
-function isDocker() {
-  if (isDockerCached === undefined) {
-    isDockerCached = hasDockerEnv() || hasDockerCGroup();
-  }
-  return isDockerCached;
-}
-var isDockerCached;
-var init_is_docker = () => {};
-
-// ../../node_modules/.bun/is-inside-container@1.0.0/node_modules/is-inside-container/index.js
-import fs2 from "fs";
-function isInsideContainer() {
-  if (cachedResult === undefined) {
-    cachedResult = hasContainerEnv() || isDocker();
-  }
-  return cachedResult;
-}
-var cachedResult, hasContainerEnv = () => {
-  try {
-    fs2.statSync("/run/.containerenv");
-    return true;
-  } catch {
-    return false;
-  }
-};
-var init_is_inside_container = __esm(() => {
-  init_is_docker();
-});
-
-// ../../node_modules/.bun/is-wsl@3.1.1/node_modules/is-wsl/index.js
-import process2 from "process";
-import os from "os";
-import fs3 from "fs";
-var isWsl = () => {
-  if (process2.platform !== "linux") {
-    return false;
-  }
-  if (os.release().toLowerCase().includes("microsoft")) {
-    if (isInsideContainer()) {
-      return false;
-    }
-    return true;
-  }
-  try {
-    if (fs3.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft")) {
-      return !isInsideContainer();
-    }
-  } catch {}
-  if (fs3.existsSync("/proc/sys/fs/binfmt_misc/WSLInterop") || fs3.existsSync("/run/WSL")) {
-    return !isInsideContainer();
-  }
-  return false;
-}, is_wsl_default;
-var init_is_wsl = __esm(() => {
-  init_is_inside_container();
-  is_wsl_default = process2.env.__IS_WSL_TEST__ ? isWsl : isWsl();
-});
-
-// ../../node_modules/.bun/powershell-utils@0.1.0/node_modules/powershell-utils/index.js
-import process3 from "process";
-import { Buffer as Buffer3 } from "buffer";
-import { promisify } from "util";
-import childProcess from "child_process";
-var execFile, powerShellPath = () => `${process3.env.SYSTEMROOT || process3.env.windir || String.raw`C:\Windows`}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`, executePowerShell = async (command, options = {}) => {
-  const {
-    powerShellPath: psPath,
-    ...execFileOptions
-  } = options;
-  const encodedCommand = executePowerShell.encodeCommand(command);
-  return execFile(psPath ?? powerShellPath(), [
-    ...executePowerShell.argumentsPrefix,
-    encodedCommand
-  ], {
-    encoding: "utf8",
-    ...execFileOptions
-  });
-};
-var init_powershell_utils = __esm(() => {
-  execFile = promisify(childProcess.execFile);
-  executePowerShell.argumentsPrefix = [
-    "-NoProfile",
-    "-NonInteractive",
-    "-ExecutionPolicy",
-    "Bypass",
-    "-EncodedCommand"
-  ];
-  executePowerShell.encodeCommand = (command) => Buffer3.from(command, "utf16le").toString("base64");
-  executePowerShell.escapeArgument = (value) => `'${String(value).replaceAll("'", "''")}'`;
-});
-
-// ../../node_modules/.bun/wsl-utils@1.0.0/node_modules/wsl-utils/utilities.js
-function parseMountPointFromConfig(content) {
-  for (const line of content.split(`
-`)) {
-    if (/^\s*#/.test(line)) {
-      continue;
-    }
-    const match = /^\s*root\s*=\s*(?<mountPoint>"[^"]*"|'[^']*'|[^#]*)/.exec(line);
-    if (!match) {
-      continue;
-    }
-    return match.groups.mountPoint.trim().replaceAll(/^["']|["']$/g, "");
-  }
-}
-
-// ../../node_modules/.bun/wsl-utils@1.0.0/node_modules/wsl-utils/index.js
-import path from "path";
-import { promisify as promisify2 } from "util";
-import childProcess2 from "child_process";
-import fs4, { constants as fsConstants } from "fs/promises";
-var execFile2, wslDrivesMountPoint, powerShellPathFromWsl = async () => {
-  const mountPoint = await wslDrivesMountPoint();
-  return `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe`;
-}, powerShellPath2, canAccessPowerShellPromise, canAccessPowerShell = async () => {
-  canAccessPowerShellPromise ??= (async () => {
-    try {
-      const psPath = await powerShellPath2();
-      await fs4.access(psPath, fsConstants.X_OK);
-      return true;
-    } catch {
-      return false;
-    }
-  })();
-  return canAccessPowerShellPromise;
-}, wslDefaultBrowser = async () => {
-  const psPath = await powerShellPath2();
-  const command = String.raw`(Get-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice").ProgId`;
-  const { stdout } = await executePowerShell(command, {
-    powerShellPath: psPath,
-    cwd: path.dirname(psPath)
-  });
-  return stdout.trim();
-}, isUrl = (path2) => /^[a-z]+:\/\//i.test(path2), convertWslPathToWindows = async (paths) => {
-  const isBatch = Array.isArray(paths);
-  const pathArray = isBatch ? paths : [paths];
-  const indicesToConvert = [];
-  const pathsToConvert = [];
-  for (const [index, path2] of pathArray.entries()) {
-    if (!isUrl(path2)) {
-      indicesToConvert.push(index);
-      pathsToConvert.push(path2);
-    }
-  }
-  const results = [...pathArray];
-  if (pathsToConvert.length > 0) {
-    try {
-      const { stdout } = await execFile2("wslpath", ["-aw", ...pathsToConvert], { encoding: "utf8" });
-      const convertedPaths = stdout.split(/\r?\n/).filter(Boolean);
-      for (const [index, originalIndex] of indicesToConvert.entries()) {
-        results[originalIndex] = convertedPaths[index] ?? pathArray[originalIndex];
-      }
-    } catch {}
-  }
-  return isBatch ? results : results[0];
-};
-var init_wsl_utils = __esm(() => {
-  init_is_wsl();
-  init_powershell_utils();
-  init_is_wsl();
-  execFile2 = promisify2(childProcess2.execFile);
-  wslDrivesMountPoint = (() => {
-    const defaultMountPoint = "/mnt/";
-    let mountPoint;
-    return async function() {
-      if (mountPoint) {
-        return mountPoint;
-      }
-      const configFilePath = "/etc/wsl.conf";
-      let isConfigFileExists = false;
-      try {
-        await fs4.access(configFilePath, fsConstants.F_OK);
-        isConfigFileExists = true;
-      } catch {}
-      if (!isConfigFileExists) {
-        return defaultMountPoint;
-      }
-      const configContent = await fs4.readFile(configFilePath, { encoding: "utf8" });
-      const parsedMountPoint = parseMountPointFromConfig(configContent);
-      if (parsedMountPoint === undefined) {
-        return defaultMountPoint;
-      }
-      mountPoint = parsedMountPoint;
-      mountPoint = mountPoint.endsWith("/") ? mountPoint : `${mountPoint}/`;
-      return mountPoint;
-    };
-  })();
-  powerShellPath2 = is_wsl_default ? powerShellPathFromWsl : powerShellPath;
-});
-
-// ../../node_modules/.bun/powershell-utils@0.2.0/node_modules/powershell-utils/index.js
-import process4 from "process";
-import { Buffer as Buffer4 } from "buffer";
-import { promisify as promisify3 } from "util";
-import childProcess3 from "child_process";
-var execFile3, powerShellPath3 = () => `${process4.env.SYSTEMROOT || process4.env.windir || String.raw`C:\Windows`}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`, argumentsPrefix, encodeCommand = (command) => Buffer4.from(command, "utf16le").toString("base64"), escapeArgument = (value) => `'${String(value).replaceAll("'", "''")}'`, createArguments = (command) => [...argumentsPrefix, encodeCommand(command)], executePowerShell2 = async (command, options = {}) => {
-  const {
-    powerShellPath: psPath,
-    ...execFileOptions
-  } = options;
-  return execFile3(psPath ?? powerShellPath3(), createArguments(command), {
-    encoding: "utf8",
-    ...execFileOptions
-  });
-};
-var init_powershell_utils2 = __esm(() => {
-  execFile3 = promisify3(childProcess3.execFile);
-  argumentsPrefix = [
-    "-NoProfile",
-    "-NonInteractive",
-    "-ExecutionPolicy",
-    "Bypass",
-    "-EncodedCommand"
-  ];
-  executePowerShell2.argumentsPrefix = argumentsPrefix;
-  executePowerShell2.encodeCommand = encodeCommand;
-  executePowerShell2.escapeArgument = escapeArgument;
-  executePowerShell2.createArguments = createArguments;
-});
-
-// ../../node_modules/.bun/define-lazy-prop@3.0.0/node_modules/define-lazy-prop/index.js
-function defineLazyProperty(object4, propertyName, valueGetter) {
-  const define = (value) => Object.defineProperty(object4, propertyName, { value, enumerable: true, writable: true });
-  Object.defineProperty(object4, propertyName, {
-    configurable: true,
-    enumerable: true,
-    get() {
-      const result = valueGetter();
-      define(result);
-      return result;
-    },
-    set(value) {
-      define(value);
-    }
-  });
-  return object4;
-}
-
-// ../../node_modules/.bun/default-browser-id@5.0.1/node_modules/default-browser-id/index.js
-import { promisify as promisify4 } from "util";
-import process5 from "process";
-import { execFile as execFile4 } from "child_process";
-async function defaultBrowserId() {
-  if (process5.platform !== "darwin") {
-    throw new Error("macOS only");
-  }
-  const { stdout } = await execFileAsync("defaults", ["read", "com.apple.LaunchServices/com.apple.launchservices.secure", "LSHandlers"]);
-  const match = /LSHandlerRoleAll = "(?!-)(?<id>[^"]+?)";\s+?LSHandlerURLScheme = (?:http|https);/.exec(stdout);
-  const browserId = match?.groups.id ?? "com.apple.Safari";
-  if (browserId === "com.apple.safari") {
-    return "com.apple.Safari";
-  }
-  return browserId;
-}
-var execFileAsync;
-var init_default_browser_id = __esm(() => {
-  execFileAsync = promisify4(execFile4);
-});
-
-// ../../node_modules/.bun/run-applescript@7.1.0/node_modules/run-applescript/index.js
-import process6 from "process";
-import { promisify as promisify5 } from "util";
-import { execFile as execFile5, execFileSync } from "child_process";
-async function runAppleScript(script, { humanReadableOutput = true, signal } = {}) {
-  if (process6.platform !== "darwin") {
-    throw new Error("macOS only");
-  }
-  const outputArguments = humanReadableOutput ? [] : ["-ss"];
-  const execOptions = {};
-  if (signal) {
-    execOptions.signal = signal;
-  }
-  const { stdout } = await execFileAsync2("osascript", ["-e", script, outputArguments], execOptions);
-  return stdout.trim();
-}
-var execFileAsync2;
-var init_run_applescript = __esm(() => {
-  execFileAsync2 = promisify5(execFile5);
-});
-
-// ../../node_modules/.bun/bundle-name@4.1.0/node_modules/bundle-name/index.js
-async function bundleName(bundleId) {
-  return runAppleScript(`tell application "Finder" to set app_path to application file id "${bundleId}" as string
-tell application "System Events" to get value of property list item "CFBundleName" of property list file (app_path & ":Contents:Info.plist")`);
-}
-var init_bundle_name = __esm(() => {
-  init_run_applescript();
-});
-
-// ../../node_modules/.bun/default-browser@5.5.1/node_modules/default-browser/windows.js
-import process7 from "process";
-import { promisify as promisify6 } from "util";
-import { execFile as execFile6 } from "child_process";
-async function defaultBrowser(_execFileAsync = execFileAsync3) {
-  const regPath = `${process7.env.SYSTEMROOT ?? process7.env.windir ?? "C:\\Windows"}\\System32\\reg.exe`;
-  const { stdout } = await _execFileAsync(regPath, [
-    "QUERY",
-    " HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\http\\UserChoice",
-    "/v",
-    "ProgId"
-  ]);
-  const match = /ProgId\s*REG_SZ\s*(?<id>\S+)/.exec(stdout);
-  if (!match) {
-    throw new UnknownBrowserError(`Cannot find Windows browser in stdout: ${JSON.stringify(stdout)}`);
-  }
-  const { id } = match.groups;
-  const dotIndex = id.lastIndexOf(".");
-  const hyphenIndex = id.lastIndexOf("-");
-  const baseIdByDot = dotIndex === -1 ? undefined : id.slice(0, dotIndex);
-  const baseIdByHyphen = hyphenIndex === -1 ? undefined : id.slice(0, hyphenIndex);
-  return windowsBrowserProgIds[id] ?? windowsBrowserProgIds[baseIdByDot] ?? windowsBrowserProgIds[baseIdByHyphen] ?? { name: id, id };
-}
-var execFileAsync3, windowsBrowserProgIds, _windowsBrowserProgIdMap, UnknownBrowserError;
-var init_windows = __esm(() => {
-  execFileAsync3 = promisify6(execFile6);
-  windowsBrowserProgIds = {
-    MSEdgeHTM: { name: "Edge", id: "com.microsoft.edge" },
-    MSEdgeBHTML: { name: "Edge Beta", id: "com.microsoft.edge.beta" },
-    MSEdgeDHTML: { name: "Edge Dev", id: "com.microsoft.edge.dev" },
-    AppXq0fevzme2pys62n3e0fbqa7peapykr8v: { name: "Edge", id: "com.microsoft.edge.old" },
-    ChromeHTML: { name: "Chrome", id: "com.google.chrome" },
-    ChromeBHTML: { name: "Chrome Beta", id: "com.google.chrome.beta" },
-    ChromeDHTML: { name: "Chrome Dev", id: "com.google.chrome.dev" },
-    ChromiumHTM: { name: "Chromium", id: "org.chromium.Chromium" },
-    BraveHTML: { name: "Brave", id: "com.brave.Browser" },
-    BraveBHTML: { name: "Brave Beta", id: "com.brave.Browser.beta" },
-    BraveDHTML: { name: "Brave Dev", id: "com.brave.Browser.dev" },
-    BraveSSHTM: { name: "Brave Nightly", id: "com.brave.Browser.nightly" },
-    FirefoxURL: { name: "Firefox", id: "org.mozilla.firefox" },
-    OperaStable: { name: "Opera", id: "com.operasoftware.Opera" },
-    VivaldiHTM: { name: "Vivaldi", id: "com.vivaldi.Vivaldi" },
-    "IE.HTTP": { name: "Internet Explorer", id: "com.microsoft.ie" }
-  };
-  _windowsBrowserProgIdMap = new Map(Object.entries(windowsBrowserProgIds));
-  UnknownBrowserError = class UnknownBrowserError extends Error {
-  };
-});
-
-// ../../node_modules/.bun/default-browser@5.5.1/node_modules/default-browser/index.js
-import { promisify as promisify7 } from "util";
-import process8 from "process";
-import { execFile as execFile7 } from "child_process";
-async function defaultBrowser2() {
-  if (process8.platform === "darwin") {
-    const id = await defaultBrowserId();
-    const name = await bundleName(id);
-    return { name, id };
-  }
-  if (process8.platform === "linux") {
-    const { stdout } = await execFileAsync4("xdg-mime", ["query", "default", "x-scheme-handler/http"]);
-    const id = stdout.trim();
-    const name = titleize(id.replace(/.desktop$/, "").replace("-", " "));
-    return { name, id };
-  }
-  if (process8.platform === "win32") {
-    return defaultBrowser();
-  }
-  throw new Error("Only macOS, Linux, and Windows are supported");
-}
-var execFileAsync4, titleize = (string4) => string4.toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x) => x.toUpperCase());
-var init_default_browser = __esm(() => {
-  init_default_browser_id();
-  init_bundle_name();
-  init_windows();
-  init_windows();
-  execFileAsync4 = promisify7(execFile7);
-});
-
-// ../../node_modules/.bun/is-in-ssh@1.0.0/node_modules/is-in-ssh/index.js
-import process9 from "process";
-var isInSsh, is_in_ssh_default;
-var init_is_in_ssh = __esm(() => {
-  isInSsh = Boolean(process9.env.SSH_CONNECTION || process9.env.SSH_CLIENT || process9.env.SSH_TTY);
-  is_in_ssh_default = isInSsh;
-});
-
-// ../../node_modules/.bun/open@11.0.1/node_modules/open/index.js
-import process10 from "process";
-import path2 from "path";
-import { fileURLToPath as fileURLToPath6 } from "url";
-import childProcess4 from "child_process";
-import fs5, { constants as fsConstants2 } from "fs/promises";
-function detectArchBinary(binary) {
-  if (typeof binary === "string" || Array.isArray(binary)) {
-    return binary;
-  }
-  const { [arch]: archBinary } = binary;
-  if (!archBinary) {
-    throw new Error(`${arch} is not supported`);
-  }
-  return archBinary;
-}
-function detectPlatformBinary({ [platform]: platformBinary }, { wsl } = {}) {
-  if (wsl && is_wsl_default) {
-    return detectArchBinary(wsl);
-  }
-  if (!platformBinary) {
-    throw new Error(`${platform} is not supported`);
-  }
-  return detectArchBinary(platformBinary);
-}
-var fallbackAttemptSymbol, __dirname6, localXdgOpenPath, platform, arch, tryEachApp = async (apps, opener) => {
-  if (apps.length === 0) {
-    return;
-  }
-  const errors4 = [];
-  for (const app of apps) {
-    try {
-      return await opener(app);
-    } catch (error2) {
-      errors4.push(error2);
-    }
-  }
-  throw new AggregateError(errors4, "Failed to open in all supported apps");
-}, baseOpen = async (options) => {
-  options = {
-    wait: false,
-    background: false,
-    newInstance: false,
-    allowNonzeroExitCode: false,
-    ...options
-  };
-  const isFallbackAttempt = options[fallbackAttemptSymbol] === true;
-  delete options[fallbackAttemptSymbol];
-  if (Array.isArray(options.app)) {
-    return tryEachApp(options.app, (singleApp) => baseOpen({
-      ...options,
-      app: singleApp,
-      [fallbackAttemptSymbol]: true
-    }));
-  }
-  let { name: app, arguments: appArguments = [] } = options.app ?? {};
-  appArguments = [...appArguments];
-  if (Array.isArray(app)) {
-    return tryEachApp(app, (appName) => baseOpen({
-      ...options,
-      app: {
-        name: appName,
-        arguments: appArguments
-      },
-      [fallbackAttemptSymbol]: true
-    }));
-  }
-  if (app === "browser" || app === "browserPrivate") {
-    const ids = {
-      "com.google.chrome": "chrome",
-      "google-chrome.desktop": "chrome",
-      "com.brave.browser": "brave",
-      "org.mozilla.firefox": "firefox",
-      "firefox.desktop": "firefox",
-      "com.microsoft.msedge": "edge",
-      "com.microsoft.edge": "edge",
-      "com.microsoft.edgemac": "edge",
-      "microsoft-edge.desktop": "edge",
-      "com.apple.safari": "safari"
-    };
-    const flags = {
-      chrome: "--incognito",
-      brave: "--incognito",
-      firefox: "--private-window",
-      edge: "--inPrivate"
-    };
-    let browser;
-    if (is_wsl_default) {
-      const progId = await wslDefaultBrowser();
-      const browserInfo = _windowsBrowserProgIdMap.get(progId);
-      browser = browserInfo ?? {};
-    } else {
-      browser = await defaultBrowser2();
-    }
-    if (browser.id in ids) {
-      const browserName = ids[browser.id.toLowerCase()];
-      if (app === "browserPrivate") {
-        if (browserName === "safari") {
-          throw new Error("Safari doesn't support opening in private mode via command line");
-        }
-        appArguments.push(flags[browserName]);
-      }
-      return baseOpen({
-        ...options,
-        app: {
-          name: apps[browserName],
-          arguments: appArguments
-        }
-      });
-    }
-    throw new Error(`${browser.name} is not supported as a default browser`);
-  }
-  let command;
-  const cliArguments = [];
-  const childProcessOptions = {};
-  let shouldUseWindowsInWsl = false;
-  if (is_wsl_default && !isInsideContainer() && !is_in_ssh_default && !app) {
-    shouldUseWindowsInWsl = await canAccessPowerShell();
-  }
-  if (platform === "darwin") {
-    command = "open";
-    if (options.wait) {
-      cliArguments.push("--wait-apps");
-    }
-    if (options.background) {
-      cliArguments.push("--background");
-    }
-    if (options.newInstance) {
-      cliArguments.push("--new");
-    }
-    if (app) {
-      cliArguments.push("-a", app);
-    }
-  } else if (platform === "win32" || shouldUseWindowsInWsl) {
-    command = await powerShellPath2();
-    cliArguments.push(...executePowerShell2.argumentsPrefix);
-    if (!is_wsl_default) {
-      childProcessOptions.windowsVerbatimArguments = true;
-    }
-    if (is_wsl_default && options.target) {
-      options.target = await convertWslPathToWindows(options.target);
-    }
-    const encodedArguments = ["$ProgressPreference = 'SilentlyContinue';", "Start"];
-    if (options.wait) {
-      encodedArguments.push("-Wait");
-    }
-    if (app) {
-      encodedArguments.push(executePowerShell2.escapeArgument(app));
-      if (options.target) {
-        appArguments.push(options.target);
-      }
-    } else if (options.target) {
-      encodedArguments.push(executePowerShell2.escapeArgument(options.target));
-    }
-    if (appArguments.length > 0) {
-      appArguments = appArguments.map((argument) => executePowerShell2.escapeArgument(argument));
-      encodedArguments.push("-ArgumentList", appArguments.join(","));
-    }
-    options.target = executePowerShell2.encodeCommand(encodedArguments.join(" "));
-    if (!options.wait) {
-      childProcessOptions.stdio = "ignore";
-    }
-    if (is_wsl_default) {
-      childProcessOptions.cwd = path2.dirname(command);
-    }
-  } else {
-    if (app) {
-      command = app;
-    } else {
-      const isBundled = !__dirname6 || __dirname6 === "/";
-      let exeLocalXdgOpen = false;
-      try {
-        await fs5.access(localXdgOpenPath, fsConstants2.X_OK);
-        exeLocalXdgOpen = true;
-      } catch {}
-      const useSystemXdgOpen = process10.versions.electron ?? (platform === "android" || isBundled || !exeLocalXdgOpen);
-      command = useSystemXdgOpen ? "xdg-open" : localXdgOpenPath;
-    }
-    if (appArguments.length > 0) {
-      cliArguments.push(...appArguments);
-    }
-    if (!options.wait) {
-      childProcessOptions.stdio = "ignore";
-      childProcessOptions.detached = true;
-    }
-  }
-  if (platform === "darwin" && appArguments.length > 0) {
-    cliArguments.push("--args", ...appArguments);
-  }
-  if (options.target) {
-    cliArguments.push(options.target);
-  }
-  const subprocess = childProcess4.spawn(command, cliArguments, childProcessOptions);
-  if (options.wait) {
-    return new Promise((resolve, reject) => {
-      subprocess.once("error", reject);
-      subprocess.once("close", (exitCode) => {
-        if (!options.allowNonzeroExitCode && exitCode !== 0) {
-          reject(new Error(`Exited with code ${exitCode}`));
-          return;
-        }
-        resolve(subprocess);
-      });
-    });
-  }
-  if (isFallbackAttempt) {
-    return new Promise((resolve, reject) => {
-      subprocess.once("error", reject);
-      subprocess.once("spawn", () => {
-        subprocess.once("close", (exitCode) => {
-          subprocess.off("error", reject);
-          if (exitCode !== 0) {
-            reject(new Error(`Exited with code ${exitCode}`));
-            return;
-          }
-          subprocess.unref();
-          resolve(subprocess);
-        });
-      });
-    });
-  }
-  subprocess.unref();
-  return new Promise((resolve, reject) => {
-    subprocess.once("error", reject);
-    subprocess.once("spawn", () => {
-      subprocess.off("error", reject);
-      resolve(subprocess);
-    });
-  });
-}, open = (target, options) => {
-  if (typeof target !== "string") {
-    throw new TypeError("Expected a `target`");
-  }
-  return baseOpen({
-    ...options,
-    target
-  });
-}, apps, open_default;
-var init_open = __esm(() => {
-  init_wsl_utils();
-  init_powershell_utils2();
-  init_default_browser();
-  init_is_inside_container();
-  init_is_in_ssh();
-  fallbackAttemptSymbol = Symbol("fallbackAttempt");
-  __dirname6 = import.meta.url ? path2.dirname(fileURLToPath6(import.meta.url)) : "";
-  localXdgOpenPath = path2.join(__dirname6, "xdg-open");
-  ({ platform, arch } = process10);
-  apps = {
-    browser: "browser",
-    browserPrivate: "browserPrivate"
-  };
-  defineLazyProperty(apps, "chrome", () => detectPlatformBinary({
-    darwin: "google chrome",
-    win32: "chrome",
-    linux: ["google-chrome", "google-chrome-stable", "chromium", "chromium-browser"]
-  }, {
-    wsl: {
-      ia32: "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe",
-      x64: ["/mnt/c/Program Files/Google/Chrome/Application/chrome.exe", "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe"]
-    }
-  }));
-  defineLazyProperty(apps, "brave", () => detectPlatformBinary({
-    darwin: "brave browser",
-    win32: "brave",
-    linux: ["brave-browser", "brave"]
-  }, {
-    wsl: {
-      ia32: "/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe",
-      x64: ["/mnt/c/Program Files/BraveSoftware/Brave-Browser/Application/brave.exe", "/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe"]
-    }
-  }));
-  defineLazyProperty(apps, "firefox", () => detectPlatformBinary({
-    darwin: "firefox",
-    win32: String.raw`C:\Program Files\Mozilla Firefox\firefox.exe`,
-    linux: "firefox"
-  }, {
-    wsl: "/mnt/c/Program Files/Mozilla Firefox/firefox.exe"
-  }));
-  defineLazyProperty(apps, "edge", () => detectPlatformBinary({
-    darwin: "microsoft edge",
-    win32: "msedge",
-    linux: ["microsoft-edge", "microsoft-edge-dev"]
-  }, {
-    wsl: "/mnt/c/Program Files (x86)/Microsoft/Edge/Application/msedge.exe"
-  }));
-  defineLazyProperty(apps, "safari", () => detectPlatformBinary({
-    darwin: "Safari"
-  }));
-  open_default = open;
-});
-
-// src/lib/open-browser.ts
-var exports_open_browser = {};
-__export(exports_open_browser, {
-  openBrowser: () => openBrowser
-});
-async function openBrowser(url) {
-  try {
-    await open_default(url);
-    return { ok: true };
-  } catch (error2) {
-    return { ok: false, error: error2 };
-  }
-}
-var init_open_browser = __esm(() => {
-  init_open();
-});
-
 // src/server/serve.ts
-import { existsSync as existsSync15, readdirSync as readdirSync9, readFileSync as readFileSync9, writeFileSync as writeFileSync7, mkdirSync as mkdirSync9 } from "fs";
+import { existsSync as existsSync17, readdirSync as readdirSync9, readFileSync as readFileSync10, writeFileSync as writeFileSync8, mkdirSync as mkdirSync10 } from "fs";
 
 // src/db/agents.ts
 init_database();
@@ -17507,7 +17212,7 @@ init_strip();
 import { spawn as nodeSpawn } from "child_process";
 var spawnImpl = nodeSpawn;
 async function runStep(step, previousOutput) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const args = [...step.args ?? []];
     if (previousOutput && previousOutput.trim()) {
       args.push("--input", previousOutput.trim().slice(0, 4096));
@@ -17521,11 +17226,11 @@ async function runStep(step, previousOutput) {
     proc.stderr.on("data", (d) => {
       output += d.toString();
     });
-    proc.on("close", (code) => resolve({ exitCode: code ?? 1, output }));
-    proc.on("error", () => resolve({ exitCode: 1, output: "Failed to spawn connectors" }));
+    proc.on("close", (code) => resolve2({ exitCode: code ?? 1, output }));
+    proc.on("error", () => resolve2({ exitCode: 1, output: "Failed to spawn connectors" }));
     setTimeout(() => {
       proc.kill();
-      resolve({ exitCode: 124, output: output + `
+      resolve2({ exitCode: 124, output: output + `
 [timeout]` });
     }, 60000);
   });
@@ -17556,13 +17261,12 @@ async function runWorkflow(workflow) {
 
 // src/server/serve.ts
 init_database();
-import { join as join14, dirname as dirname7, extname, basename as basename3, relative, resolve, sep } from "path";
-import { fileURLToPath as fileURLToPath7 } from "url";
+import { join as join16, basename as basename3 } from "path";
 
 // src/lib/registry.ts
 init_builtins();
-import { existsSync as existsSync9, readFileSync as readFileSync5 } from "fs";
-import { join as join9, dirname as dirname4 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync5 } from "fs";
+import { join as join10, dirname as dirname4 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/lib/fuzzy.ts
@@ -25995,16 +25699,16 @@ function loadConnectorVersions() {
   versionsLoaded = true;
   const thisDir = dirname4(fileURLToPath3(import.meta.url));
   const candidates = [
-    join9(thisDir, "..", "connectors"),
-    join9(thisDir, "..", "..", "connectors")
+    join10(thisDir, "..", "connectors"),
+    join10(thisDir, "..", "..", "connectors")
   ];
-  const connectorsDir = candidates.find((d) => existsSync9(d));
+  const connectorsDir = candidates.find((d) => existsSync10(d));
   if (!connectorsDir)
     return;
   for (const connector of CONNECTORS) {
     try {
-      const pkgPath = join9(getConnectorPackagePath(connectorsDir, connector.name), "package.json");
-      if (existsSync9(pkgPath)) {
+      const pkgPath = join10(getConnectorPackagePath(connectorsDir, connector.name), "package.json");
+      if (existsSync10(pkgPath)) {
         const pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
         connector.version = pkg.version || "0.0.0";
         continue;
@@ -26099,7 +25803,7 @@ async function getConnectorCapabilityManifest(options = {}) {
 // src/server/serve.ts
 init_auth();
 
-// ../../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) {
@@ -26122,7 +25826,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) {
@@ -30589,7 +30293,7 @@ function preprocess(fn, schema) {
 // ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v4/classic/external.js
 config(en_default2());
 
-// ../../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"];
@@ -31436,7 +31140,7 @@ class UrlElicitationRequiredError extends McpError {
   }
 }
 
-// ../../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;
@@ -31835,9 +31539,9 @@ data:
       const initRequest = messages.find((m) => isInitializeRequest(m));
       const clientProtocolVersion = initRequest ? initRequest.params.protocolVersion : req.headers.get("mcp-protocol-version") ?? DEFAULT_NEGOTIATED_PROTOCOL_VERSION;
       if (this._enableJsonResponse) {
-        return new Promise((resolve) => {
+        return new Promise((resolve2) => {
           this._streamMapping.set(streamId, {
-            resolveJson: resolve,
+            resolveJson: resolve2,
             cleanup: () => {
               this._streamMapping.delete(streamId);
             }
@@ -32134,7 +31838,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;
@@ -32295,7 +31999,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";
 }
@@ -33536,7 +33240,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";
@@ -33578,7 +33282,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 {
@@ -34040,7 +33744,7 @@ class Protocol {
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1000;
-        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+        await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
         options?.signal?.throwIfAborted();
       }
     } catch (error2) {
@@ -34052,7 +33756,7 @@ class Protocol {
   }
   request(request2, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const earlyReject = (error2) => {
         reject(error2);
       };
@@ -34130,7 +33834,7 @@ class Protocol {
           if (!parseResult.success) {
             reject(parseResult.error);
           } else {
-            resolve(parseResult.data);
+            resolve2(parseResult.data);
           }
         } catch (error2) {
           reject(error2);
@@ -34321,12 +34025,12 @@ class Protocol {
         interval = task.pollInterval;
       }
     } catch {}
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       if (signal.aborted) {
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve, interval);
+      const timeoutId = setTimeout(resolve2, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -34419,7 +34123,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() {
@@ -34459,7 +34163,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;
@@ -34537,7 +34241,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})`);
@@ -34572,7 +34276,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);
@@ -34896,7 +34600,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;
@@ -34910,7 +34614,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 = [];
@@ -34968,7 +34672,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;
@@ -34983,7 +34687,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 {
@@ -35173,7 +34877,7 @@ class McpServer {
     let task = createTaskResult.task;
     const pollInterval = task.pollInterval ?? 5000;
     while (task.status !== "completed" && task.status !== "failed" && task.status !== "cancelled") {
-      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+      await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
       const updatedTask = await extra.taskStore.getTask(taskId);
       if (!updatedTask) {
         throw new McpError(ErrorCode.InternalError, `Task ${taskId} not found during polling`);
@@ -35717,6 +35421,7 @@ init_package();
 
 // src/mcp/tools/discovery.ts
 init_zod();
+init_package();
 
 // src/lib/compact-output.ts
 var DEFAULT_MCP_LIMIT = 20;
@@ -35801,7 +35506,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 }) => {
@@ -35872,13 +35577,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",
@@ -36124,8 +35835,8 @@ init_zod();
 init_auth();
 init_database();
 init_connector_resolver();
-import { existsSync as existsSync14, readFileSync as readFileSync8 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync8 } from "fs";
+import { join as join14 } from "path";
 import { spawn as spawn3 } from "child_process";
 function registerAuthTools(server, stripped) {
   server.registerTool("connector_auth_status", {
@@ -36260,11 +35971,11 @@ function registerAuthTools(server, stripped) {
     const serverPort = port || 9876;
     const oauthUrl = `http://localhost:${serverPort}/oauth/${name}/start`;
     if (noBrowser) {
-      const connectorsHome = getConnectorsHome();
-      const tokenPaths = getConnectorConfigReadDirs(name, connectorsHome).map((dir) => join13(dir, "profiles", "default", "tokens.json"));
+      const connectorsHome2 = getConnectorsHome();
+      const tokenPaths = getConnectorConfigReadDirs(name, connectorsHome2).map((dir) => join14(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) {
@@ -36274,13 +35985,13 @@ function registerAuthTools(server, stripped) {
           stdio: "ignore"
         });
         serverProc.unref();
-        await new Promise((resolve) => setTimeout(resolve, 2000));
+        await new Promise((resolve2) => setTimeout(resolve2, 2000));
       }
       let attempts = 0;
       const maxAttempts = 120;
       while (attempts < maxAttempts) {
-        await new Promise((resolve) => setTimeout(resolve, 500));
-        if (tokenPaths.some((tokensPath) => existsSync14(tokensPath))) {
+        await new Promise((resolve2) => setTimeout(resolve2, 500));
+        if (tokenPaths.some((tokensPath) => existsSync15(tokensPath))) {
           break;
         }
         attempts++;
@@ -36299,7 +36010,7 @@ function registerAuthTools(server, stripped) {
         };
       }
       try {
-        const tokensPath = tokenPaths.find((path) => existsSync14(path)) ?? tokenPaths[0];
+        const tokensPath = tokenPaths.find((path) => existsSync15(path)) ?? tokenPaths[0];
         const tokenData = JSON.parse(readFileSync8(tokensPath, "utf-8"));
         return {
           content: [{
@@ -37023,6 +36734,114 @@ async function handleMcpHttpRequest(req) {
   return null;
 }
 
+// src/server/serve-auth.ts
+init_paths();
+import { chmodSync as chmodSync2, existsSync as existsSync16, mkdirSync as mkdirSync9, readFileSync as readFileSync9, writeFileSync as writeFileSync7 } from "fs";
+import { randomBytes as randomBytes2, timingSafeEqual } from "crypto";
+import { dirname as dirname7, join as join15 } from "path";
+var SERVE_TOKEN_ENV = "HASNA_CONNECTORS_SERVE_TOKEN";
+var SERVE_TOKEN_FILE = "serve-token";
+var SERVE_UNAUTHORIZED_CODE = "CONNECTORS_SERVE_UNAUTHORIZED";
+var SERVE_DEFAULT_HOSTNAME = "127.0.0.1";
+var PRIVATE_FILE_MODE2 = 384;
+function serveTokenPath(home = connectorsHome()) {
+  return join15(home, SERVE_TOKEN_FILE);
+}
+function readTokenFile(path) {
+  if (!existsSync16(path))
+    return null;
+  try {
+    const value = readFileSync9(path, "utf-8").trim();
+    return value.length > 0 ? value : null;
+  } catch {
+    return null;
+  }
+}
+function writeTokenFile(path, token) {
+  mkdirSync9(dirname7(path), { recursive: true });
+  writeFileSync7(path, `${token}
+`, { mode: PRIVATE_FILE_MODE2 });
+  try {
+    chmodSync2(path, PRIVATE_FILE_MODE2);
+  } catch {}
+}
+function readServeToken(env = process.env, home) {
+  const fromEnv = env[SERVE_TOKEN_ENV]?.trim();
+  if (fromEnv)
+    return { token: fromEnv, source: "env", path: null };
+  const path = serveTokenPath(home);
+  const fromFile = readTokenFile(path);
+  if (fromFile)
+    return { token: fromFile, source: "file", path };
+  return null;
+}
+function resolveServeToken(options = {}) {
+  const explicit = options.token?.trim();
+  if (explicit)
+    return { token: explicit, source: "explicit", path: null };
+  const existing = readServeToken(options.env ?? process.env, options.home);
+  if (existing)
+    return existing;
+  const path = serveTokenPath(options.home);
+  const token = randomBytes2(32).toString("hex");
+  writeTokenFile(path, token);
+  return { token, source: "generated", path };
+}
+function presentedToken(req) {
+  const authorization = req.headers.get("authorization");
+  if (authorization) {
+    const match = /^Bearer\s+(.+)$/i.exec(authorization.trim());
+    if (match)
+      return match[1].trim();
+  }
+  const header = req.headers.get("x-connectors-token");
+  if (header && header.trim().length > 0)
+    return header.trim();
+  return null;
+}
+function tokenMatches(presented, expected) {
+  if (!presented)
+    return false;
+  const a = Buffer.from(presented, "utf-8");
+  const b = Buffer.from(expected, "utf-8");
+  if (a.length !== b.length)
+    return false;
+  return timingSafeEqual(a, b);
+}
+function requiresServeAuth(pathname, method) {
+  if (method === "OPTIONS")
+    return false;
+  if (pathname === "/health")
+    return false;
+  if (/^\/oauth\/[^/]+\/(start|callback)$/.test(pathname))
+    return false;
+  return true;
+}
+function isServeAuthorized(req, token) {
+  const url = new URL(req.url);
+  if (!requiresServeAuth(url.pathname, req.method))
+    return true;
+  return tokenMatches(presentedToken(req), token);
+}
+function unauthorizedPayload() {
+  return {
+    error: `${SERVE_UNAUTHORIZED_CODE}: this connectors-serve route requires ` + "`Authorization: Bearer <token>` (or `X-Connectors-Token`).",
+    hint: `The token is ${SERVE_TOKEN_ENV} when set, otherwise the owner-only file ` + `<connectors home>/${SERVE_TOKEN_FILE} (default ~/.hasna/connectors/${SERVE_TOKEN_FILE}) ` + "the server generates on first start. Same-user CLI, MCP and `@hasna/connectors/sdk` clients read it automatically."
+  };
+}
+function describeServeTokenSource(resolved) {
+  switch (resolved.source) {
+    case "env":
+      return `bearer token from ${SERVE_TOKEN_ENV}`;
+    case "explicit":
+      return "bearer token supplied by the caller";
+    case "file":
+      return `bearer token from ${resolved.path}`;
+    case "generated":
+      return `bearer token generated and written owner-only to ${resolved.path}`;
+  }
+}
+
 // src/server/serve.ts
 var activityLog = [];
 var MAX_ACTIVITY_LOG = 100;
@@ -37032,37 +36851,6 @@ function logActivity(action, connector, detail) {
     activityLog.length = MAX_ACTIVITY_LOG;
   }
 }
-function resolveDashboardDir() {
-  const candidates = [];
-  try {
-    const scriptDir = dirname7(fileURLToPath7(import.meta.url));
-    candidates.push(join14(scriptDir, "..", "dashboard", "dist"));
-    candidates.push(join14(scriptDir, "..", "..", "dashboard", "dist"));
-  } catch {}
-  if (process.argv[1]) {
-    const mainDir = dirname7(process.argv[1]);
-    candidates.push(join14(mainDir, "..", "dashboard", "dist"));
-    candidates.push(join14(mainDir, "..", "..", "dashboard", "dist"));
-  }
-  candidates.push(join14(process.cwd(), "dashboard", "dist"));
-  for (const candidate of candidates) {
-    if (existsSync15(candidate))
-      return candidate;
-  }
-  return join14(process.cwd(), "dashboard", "dist");
-}
-var MIME_TYPES = {
-  ".html": "text/html; charset=utf-8",
-  ".js": "application/javascript",
-  ".css": "text/css",
-  ".json": "application/json",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".svg": "image/svg+xml",
-  ".ico": "image/x-icon",
-  ".woff": "font/woff",
-  ".woff2": "font/woff2"
-};
 var SECURITY_HEADERS = {
   "X-Content-Type-Options": "nosniff",
   "X-Frame-Options": "DENY"
@@ -37147,15 +36935,6 @@ function oauthPage(type, title, message, hint, extra) {
     </div>
   </body></html>`;
 }
-function serveStaticFile(filePath) {
-  if (!existsSync15(filePath))
-    return null;
-  const ext = extname(filePath);
-  const contentType2 = MIME_TYPES[ext] || "application/octet-stream";
-  return new Response(Bun.file(filePath), {
-    headers: { "Content-Type": contentType2 }
-  });
-}
 async function findAvailablePort(preferred, strict = false) {
   if (strict) {
     try {
@@ -37181,37 +36960,37 @@ async function findAvailablePort(preferred, strict = false) {
   throw new Error(`No available port found in range ${preferred}-${preferred + 99}`);
 }
 async function startServer(requestedPort, options) {
-  const shouldOpen = options?.open ?? true;
   const strict = options?.strict ?? false;
+  const hostname2 = options?.hostname ?? SERVE_DEFAULT_HOSTNAME;
   loadConnectorVersions();
-  const dashboardDir = resolveDashboardDir();
-  const dashboardExists = existsSync15(dashboardDir);
-  if (!dashboardExists) {
-    console.error(`
-Dashboard not found at: ${dashboardDir}`);
-    console.error(`Run this to build it:
-`);
-    console.error(`  cd dashboard && bun install && bun run build
-`);
-    console.error(`Or from the project root:
-`);
-    console.error(`  bun run build:dashboard
-`);
-  }
+  const serveToken = resolveServeToken({ token: options?.token });
   const port = await findAvailablePort(requestedPort, strict);
   if (port !== requestedPort) {
     console.log(`Port ${requestedPort} is in use, using port ${port} instead`);
   }
   const server = Bun.serve({
+    hostname: hostname2,
     port,
     async fetch(req) {
       const url2 = new URL(req.url);
-      const path3 = url2.pathname;
+      const path = url2.pathname;
       const method = req.method;
+      if (!isServeAuthorized(req, serveToken.token)) {
+        const body = unauthorizedPayload();
+        return new Response(JSON.stringify(body), {
+          status: 401,
+          headers: {
+            "Content-Type": "application/json",
+            "WWW-Authenticate": 'Bearer realm="connectors-serve"',
+            "Access-Control-Allow-Origin": `http://localhost:${port}`,
+            ...SECURITY_HEADERS
+          }
+        });
+      }
       const mcpResponse = await handleMcpHttpRequest(req);
       if (mcpResponse)
         return mcpResponse;
-      if (path3 === "/api/connectors" && method === "GET") {
+      if (path === "/api/connectors" && method === "GET") {
         const compact = url2.searchParams.get("compact") === "true";
         const fieldsParam = url2.searchParams.get("fields");
         const fields = fieldsParam ? new Set(fieldsParam.split(",").map((f) => f.trim())) : null;
@@ -37231,7 +37010,7 @@ Dashboard not found at: ${dashboardDir}`);
         }
         return jsonStripped(data, 200, port);
       }
-      if (path3 === "/api/connectors/manifest" && method === "GET") {
+      if (path === "/api/connectors/manifest" && method === "GET") {
         const connectorNames = url2.searchParams.get("connectors")?.split(",").map((name) => name.trim()).filter(Boolean);
         const includeOperations = url2.searchParams.get("includeOperations") === "true";
         const manifest = await getConnectorCapabilityManifest({
@@ -37240,7 +37019,7 @@ Dashboard not found at: ${dashboardDir}`);
         });
         return json(manifest, 200, port);
       }
-      const singleMatch = path3.match(/^\/api\/connectors\/([^/]+)$/);
+      const singleMatch = path.match(/^\/api\/connectors\/([^/]+)$/);
       if (singleMatch && method === "GET") {
         const name = singleMatch[1];
         if (!isValidConnectorName(name))
@@ -37260,7 +37039,7 @@ Dashboard not found at: ${dashboardDir}`);
           overview: docs?.overview || null
         }, 200, port);
       }
-      const operationsMatch = path3.match(/^\/api\/connectors\/([^/]+)\/operations$/);
+      const operationsMatch = path.match(/^\/api\/connectors\/([^/]+)\/operations$/);
       if (operationsMatch && method === "GET") {
         const name = operationsMatch[1];
         if (!isValidConnectorName(name))
@@ -37281,7 +37060,7 @@ Dashboard not found at: ${dashboardDir}`);
           helpText: ops.helpText
         }, 200, port);
       }
-      const operationHelpMatch = path3.match(/^\/api\/connectors\/([^/]+)\/operations\/([^/]+)$/);
+      const operationHelpMatch = path.match(/^\/api\/connectors\/([^/]+)\/operations\/([^/]+)$/);
       if (operationHelpMatch && method === "GET") {
         const name = operationHelpMatch[1];
         const command = decodeURIComponent(operationHelpMatch[2]);
@@ -37296,7 +37075,7 @@ Dashboard not found at: ${dashboardDir}`);
         const help = await getConnectorCommandHelp(name, command);
         return json({ connector: name, displayName: meta.displayName, command, help }, 200, port);
       }
-      const operationRunMatch = path3.match(/^\/api\/connectors\/([^/]+)\/operations\/run$/);
+      const operationRunMatch = path.match(/^\/api\/connectors\/([^/]+)\/operations\/run$/);
       if (operationRunMatch && method === "POST") {
         const name = operationRunMatch[1];
         if (!isValidConnectorName(name))
@@ -37360,7 +37139,7 @@ ${result.stderr}`;
           }, 500, port);
         }
       }
-      const keyMatch = path3.match(/^\/api\/connectors\/([^/]+)\/key$/);
+      const keyMatch = path.match(/^\/api\/connectors\/([^/]+)\/key$/);
       if (keyMatch && method === "POST") {
         const name = keyMatch[1];
         if (!isValidConnectorName(name))
@@ -37379,7 +37158,7 @@ ${result.stderr}`;
           return json({ error: e instanceof Error ? e.message : "Failed to save key" }, 500, port);
         }
       }
-      const refreshMatch = path3.match(/^\/api\/connectors\/([^/]+)\/refresh$/);
+      const refreshMatch = path.match(/^\/api\/connectors\/([^/]+)\/refresh$/);
       if (refreshMatch && method === "POST") {
         const name = refreshMatch[1];
         if (!isValidConnectorName(name))
@@ -37392,7 +37171,7 @@ ${result.stderr}`;
           return json({ success: false, error: e instanceof Error ? e.message : "Failed to refresh" }, 500, port);
         }
       }
-      const installMatch = path3.match(/^\/api\/connectors\/([^/]+)\/install$/);
+      const installMatch = path.match(/^\/api\/connectors\/([^/]+)\/install$/);
       if (installMatch && method === "POST") {
         const name = installMatch[1];
         if (!isValidConnectorName(name))
@@ -37411,7 +37190,7 @@ ${result.stderr}`;
           return json({ error: e instanceof Error ? e.message : "Failed to install connector" }, 500, port);
         }
       }
-      const uninstallMatch = path3.match(/^\/api\/connectors\/([^/]+)\/uninstall$/);
+      const uninstallMatch = path.match(/^\/api\/connectors\/([^/]+)\/uninstall$/);
       if (uninstallMatch && method === "POST") {
         const name = uninstallMatch[1];
         if (!isValidConnectorName(name))
@@ -37427,7 +37206,7 @@ ${result.stderr}`;
           return json({ error: e instanceof Error ? e.message : "Failed to uninstall connector" }, 500, port);
         }
       }
-      if (path3 === "/api/update" && method === "POST") {
+      if (path === "/api/update" && method === "POST") {
         try {
           const installed = getInstalledConnectors();
           if (installed.length === 0) {
@@ -37443,10 +37222,10 @@ ${result.stderr}`;
           return json({ error: e instanceof Error ? e.message : "Failed to update" }, 500, port);
         }
       }
-      if (path3 === "/api/activity" && method === "GET") {
+      if (path === "/api/activity" && method === "GET") {
         return json(activityLog, 200, port);
       }
-      if (path3 === "/api/hot" && method === "GET") {
+      if (path === "/api/hot" && method === "GET") {
         const { getTopConnectors: getTopConnectors2 } = await Promise.resolve().then(() => (init_usage(), exports_usage));
         const { getPromotedConnectors: getPromotedConnectors2 } = await Promise.resolve().then(() => (init_promotions(), exports_promotions));
         const limit = parseInt(url2.searchParams.get("limit") || "10", 10);
@@ -37456,7 +37235,7 @@ ${result.stderr}`;
         const promoted = new Set(getPromotedConnectors2(db));
         return json(top.map((t) => ({ ...t, promoted: promoted.has(t.connector) })), 200, port);
       }
-      const promoteMatch = path3.match(/^\/api\/connectors\/([^/]+)\/promote$/);
+      const promoteMatch = path.match(/^\/api\/connectors\/([^/]+)\/promote$/);
       if (promoteMatch && method === "POST") {
         const name = promoteMatch[1];
         if (!getConnector(name))
@@ -37470,13 +37249,13 @@ ${result.stderr}`;
         const removed = demoteConnector2(promoteMatch[1], getDatabase3());
         return json({ success: removed, connector: promoteMatch[1] }, 200, port);
       }
-      if (path3 === "/api/llm" && method === "GET") {
+      if (path === "/api/llm" && method === "GET") {
         const config2 = getLlmConfig();
         if (!config2)
           return json({ configured: false }, 200, port);
         return json({ configured: true, provider: config2.provider, model: config2.model, key: maskKey(config2.api_key), strip: config2.strip }, 200, port);
       }
-      if (path3 === "/api/llm" && method === "POST") {
+      if (path === "/api/llm" && method === "POST") {
         const body = await req.json().catch(() => ({}));
         const validProviders = ["cerebras", "groq", "openai", "anthropic"];
         const provider = body.provider;
@@ -37490,7 +37269,7 @@ ${result.stderr}`;
         saveLlmConfig({ provider, model, api_key, strip });
         return json({ success: true, provider, model, strip }, 200, port);
       }
-      if (path3 === "/api/llm/test" && method === "POST") {
+      if (path === "/api/llm/test" && method === "POST") {
         const config2 = getLlmConfig();
         if (!config2)
           return json({ error: "No LLM configured" }, 400, port);
@@ -37502,17 +37281,17 @@ ${result.stderr}`;
           return json({ success: false, error: e instanceof Error ? e.message : String(e) }, 500, port);
         }
       }
-      if (path3 === "/api/jobs" && method === "GET") {
+      if (path === "/api/jobs" && method === "GET") {
         return json(listJobs(getDatabase3()), 200, port);
       }
-      if (path3 === "/api/jobs" && method === "POST") {
+      if (path === "/api/jobs" && method === "POST") {
         const body = await req.json().catch(() => ({}));
         if (!body.name || !body.connector || !body.command || !body.cron)
           return json({ error: "name, connector, command, cron required" }, 400, port);
         const job = createJob({ name: body.name, connector: body.connector, command: body.command, args: body.args ?? [], cron: body.cron, strip: !!body.strip }, getDatabase3());
         return json(job, 201, port);
       }
-      const jobMatch = path3.match(/^\/api\/jobs\/([^/]+)$/);
+      const jobMatch = path.match(/^\/api\/jobs\/([^/]+)$/);
       if (jobMatch) {
         const db = getDatabase3();
         const job = getJobByName(jobMatch[1]) ?? getDatabase3().query("SELECT * FROM connector_jobs WHERE id = ?").get(jobMatch[1]);
@@ -37534,7 +37313,7 @@ ${result.stderr}`;
           return json(updated, 200, port);
         }
       }
-      const jobRunMatch = path3.match(/^\/api\/jobs\/([^/]+)\/run$/);
+      const jobRunMatch = path.match(/^\/api\/jobs\/([^/]+)\/run$/);
       if (jobRunMatch && method === "POST") {
         const db = getDatabase3();
         const job = getJobByName(jobRunMatch[1], db);
@@ -37543,17 +37322,17 @@ ${result.stderr}`;
         const result = await triggerJob(job, db);
         return json(result, 200, port);
       }
-      if (path3 === "/api/workflows" && method === "GET") {
+      if (path === "/api/workflows" && method === "GET") {
         return json(listWorkflows(getDatabase3()), 200, port);
       }
-      if (path3 === "/api/workflows" && method === "POST") {
+      if (path === "/api/workflows" && method === "POST") {
         const body = await req.json().catch(() => ({}));
         if (!body.name || !body.steps)
           return json({ error: "name and steps required" }, 400, port);
         const wf = createWorkflow({ name: body.name, steps: body.steps }, getDatabase3());
         return json(wf, 201, port);
       }
-      const wfMatch = path3.match(/^\/api\/workflows\/([^/]+)$/);
+      const wfMatch = path.match(/^\/api\/workflows\/([^/]+)$/);
       if (wfMatch) {
         const db = getDatabase3();
         const wf = getWorkflowByName(wfMatch[1], db);
@@ -37566,7 +37345,7 @@ ${result.stderr}`;
           return json({ success: true }, 200, port);
         }
       }
-      const wfRunMatch = path3.match(/^\/api\/workflows\/([^/]+)\/run$/);
+      const wfRunMatch = path.match(/^\/api\/workflows\/([^/]+)\/run$/);
       if (wfRunMatch && method === "POST") {
         const wf = getWorkflowByName(wfRunMatch[1], getDatabase3());
         if (!wf)
@@ -37574,10 +37353,10 @@ ${result.stderr}`;
         const result = await runWorkflow(wf);
         return json(result, 200, port);
       }
-      if (path3 === "/api/agents" && method === "GET") {
+      if (path === "/api/agents" && method === "GET") {
         return json(listAgents(), 200, port);
       }
-      if (path3 === "/api/agents/register" && method === "POST") {
+      if (path === "/api/agents/register" && method === "POST") {
         const body = await req.json().catch(() => ({}));
         const name = typeof body.name === "string" ? body.name : null;
         if (!name)
@@ -37591,15 +37370,15 @@ ${result.stderr}`;
           return json(result, 409, port);
         return json(result, 200, port);
       }
-      if (path3.startsWith("/api/agents/") && method === "DELETE") {
-        const agentName = path3.slice("/api/agents/".length);
+      if (path.startsWith("/api/agents/") && method === "DELETE") {
+        const agentName = path.slice("/api/agents/".length);
         const agent = getAgentByName(agentName);
         if (!agent)
           return json({ error: "Agent not found" }, 404, port);
         deleteAgent(agent.id);
         return json({ success: true }, 200, port);
       }
-      const rateMatch = path3.match(/^\/api\/rate\/([^/]+)\/([^/]+)$/);
+      const rateMatch = path.match(/^\/api\/rate\/([^/]+)\/([^/]+)$/);
       if (rateMatch && method === "GET") {
         const [, agentId, connector] = rateMatch;
         const limit = parseInt(url2.searchParams.get("limit") || "60", 10);
@@ -37607,7 +37386,7 @@ ${result.stderr}`;
         const result = consume ? checkRateBudget(agentId, connector, limit) : getRateBudget(agentId, connector, limit);
         return json(result, 200, port);
       }
-      const profilesMatch = path3.match(/^\/api\/connectors\/([^/]+)\/profiles$/);
+      const profilesMatch = path.match(/^\/api\/connectors\/([^/]+)\/profiles$/);
       if (profilesMatch && method === "GET") {
         const name = profilesMatch[1];
         if (!isValidConnectorName(name))
@@ -37616,10 +37395,10 @@ ${result.stderr}`;
           const profiles = listProfiles4(name);
           let current = "default";
           for (const configDir of getConnectorConfigReadDirs(name)) {
-            const currentProfileFile = join14(configDir, "current_profile");
-            if (existsSync15(currentProfileFile)) {
+            const currentProfileFile = join16(configDir, "current_profile");
+            if (existsSync17(currentProfileFile)) {
               try {
-                current = readFileSync9(currentProfileFile, "utf-8").trim() || "default";
+                current = readFileSync10(currentProfileFile, "utf-8").trim() || "default";
               } catch {}
               break;
             }
@@ -37629,7 +37408,7 @@ ${result.stderr}`;
           return json({ error: e instanceof Error ? e.message : "Failed to list profiles" }, 500, port);
         }
       }
-      const profileSwitchMatch = path3.match(/^\/api\/connectors\/([^/]+)\/profiles\/switch$/);
+      const profileSwitchMatch = path.match(/^\/api\/connectors\/([^/]+)\/profiles\/switch$/);
       if (profileSwitchMatch && method === "POST") {
         const name = profileSwitchMatch[1];
         if (!isValidConnectorName(name))
@@ -37648,7 +37427,7 @@ ${result.stderr}`;
           return json({ error: e instanceof Error ? e.message : "Failed to switch profile" }, 500, port);
         }
       }
-      const profileDeleteMatch = path3.match(/^\/api\/connectors\/([^/]+)\/profiles\/([^/]+)$/);
+      const profileDeleteMatch = path.match(/^\/api\/connectors\/([^/]+)\/profiles\/([^/]+)$/);
       if (profileDeleteMatch && method === "DELETE") {
         const name = profileDeleteMatch[1];
         const profile = profileDeleteMatch[2];
@@ -37666,31 +37445,31 @@ ${result.stderr}`;
           return json({ error: e instanceof Error ? e.message : "Failed to delete profile" }, 500, port);
         }
       }
-      if (path3 === "/api/export" && method === "GET") {
+      if (path === "/api/export" && method === "GET") {
         try {
           const connectDir = getConnectorsHome();
           const result = {};
-          if (existsSync15(connectDir)) {
+          if (existsSync17(connectDir)) {
             for (const connectorName of listConfiguredConnectorNames(connectDir)) {
               const profiles = {};
               for (const configDir of [...getConnectorConfigReadDirs(connectorName, connectDir)].reverse()) {
-                const profilesDir = join14(configDir, "profiles");
-                if (!existsSync15(profilesDir))
+                const profilesDir = join16(configDir, "profiles");
+                if (!existsSync17(profilesDir))
                   continue;
                 const profileEntries = readdirSync9(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(readFileSync9(join14(profilesDir, pEntry.name), "utf-8"));
+                      const config2 = JSON.parse(readFileSync10(join16(profilesDir, pEntry.name), "utf-8"));
                       profiles[profileName] = config2;
                     } catch {}
                   }
                   if (pEntry.isDirectory()) {
-                    const configPath = join14(profilesDir, pEntry.name, "config.json");
-                    if (existsSync15(configPath)) {
+                    const configPath = join16(profilesDir, pEntry.name, "config.json");
+                    if (existsSync17(configPath)) {
                       try {
-                        const config2 = JSON.parse(readFileSync9(configPath, "utf-8"));
+                        const config2 = JSON.parse(readFileSync10(configPath, "utf-8"));
                         profiles[pEntry.name] = config2;
                       } catch {}
                     }
@@ -37716,7 +37495,7 @@ ${result.stderr}`;
           return json({ error: e instanceof Error ? e.message : "Failed to export credentials" }, 500, port);
         }
       }
-      if (path3 === "/api/import" && method === "POST") {
+      if (path === "/api/import" && method === "POST") {
         try {
           const contentLength = parseInt(req.headers.get("content-length") || "0", 10);
           if (contentLength > MAX_BODY_SIZE)
@@ -37733,13 +37512,13 @@ ${result.stderr}`;
             if (!data.profiles || typeof data.profiles !== "object")
               continue;
             const connectorDir = getConnectorConfigDir(connectorName, connectDir);
-            const profilesDir = join14(connectorDir, "profiles");
+            const profilesDir = join16(connectorDir, "profiles");
             for (const [profileName, config2] of Object.entries(data.profiles)) {
               if (!config2 || typeof config2 !== "object")
                 continue;
-              mkdirSync9(profilesDir, { recursive: true });
-              const profileFile = join14(profilesDir, `${profileName}.json`);
-              writeFileSync7(profileFile, JSON.stringify(config2, null, 2));
+              mkdirSync10(profilesDir, { recursive: true });
+              const profileFile = join16(profilesDir, `${profileName}.json`);
+              writeFileSync8(profileFile, JSON.stringify(config2, null, 2));
               imported++;
             }
           }
@@ -37749,7 +37528,7 @@ ${result.stderr}`;
           return json({ error: e instanceof Error ? e.message : "Failed to import credentials" }, 500, port);
         }
       }
-      const oauthStartMatch = path3.match(/^\/oauth\/([^/]+)\/start$/);
+      const oauthStartMatch = path.match(/^\/oauth\/([^/]+)\/start$/);
       if (oauthStartMatch && method === "GET") {
         const name = oauthStartMatch[1];
         const redirectUri = `http://localhost:${port}/oauth/${name}/callback`;
@@ -37759,7 +37538,7 @@ ${result.stderr}`;
         }
         return Response.redirect(authUrl, 302);
       }
-      const oauthCallbackMatch = path3.match(/^\/oauth\/([^/]+)\/callback$/);
+      const oauthCallbackMatch = path.match(/^\/oauth\/([^/]+)\/callback$/);
       if (oauthCallbackMatch && method === "GET") {
         const name = oauthCallbackMatch[1];
         const code = url2.searchParams.get("code");
@@ -37769,7 +37548,7 @@ ${result.stderr}`;
           return htmlResponse(oauthPage("error", "Authentication Failed", error2, "You can close this window."));
         }
         if (!validateOAuthState(state, name)) {
-          return htmlResponse(oauthPage("error", "Invalid State", "CSRF validation failed. The OAuth state parameter is missing or invalid.", "Please try again from the dashboard."));
+          return htmlResponse(oauthPage("error", "Invalid State", "CSRF validation failed. The OAuth state parameter is missing or invalid.", "Please try again."));
         }
         if (!code) {
           return htmlResponse(oauthPage("error", "Missing Authorization Code", "No code received from the OAuth provider.", "You can close this window and try again."));
@@ -37788,25 +37567,10 @@ ${result.stderr}`;
           headers: {
             "Access-Control-Allow-Origin": `http://localhost:${port}`,
             "Access-Control-Allow-Methods": "GET, POST, DELETE, OPTIONS",
-            "Access-Control-Allow-Headers": "Content-Type"
+            "Access-Control-Allow-Headers": "Content-Type, Authorization, X-Connectors-Token"
           }
         });
       }
-      if (dashboardExists && (method === "GET" || method === "HEAD")) {
-        if (path3 !== "/") {
-          const filePath = join14(dashboardDir, path3);
-          const rel = relative(dashboardDir, resolve(filePath));
-          if (!rel.startsWith("..") && !rel.includes(`..${sep}`) && rel !== "") {
-            const res2 = serveStaticFile(filePath);
-            if (res2)
-              return res2;
-          }
-        }
-        const indexPath = join14(dashboardDir, "index.html");
-        const res = serveStaticFile(indexPath);
-        if (res)
-          return res;
-      }
       return json({ error: "Not found" }, 404, port);
     }
   });
@@ -37819,17 +37583,9 @@ ${result.stderr}`;
   const { startScheduler: startScheduler2 } = await Promise.resolve().then(() => (init_scheduler(), exports_scheduler));
   const { getDatabase: getDatabase3 } = await Promise.resolve().then(() => (init_database(), exports_database));
   startScheduler2(getDatabase3());
-  const url = `http://localhost:${port}`;
-  console.log(`Connectors Dashboard running at ${url}`);
-  if (shouldOpen) {
-    try {
-      const { openBrowser: openBrowser2 } = await Promise.resolve().then(() => (init_open_browser(), exports_open_browser));
-      const opened = await openBrowser2(url);
-      if (!opened.ok) {
-        console.log(`If the browser did not open, visit ${url} manually.`);
-      }
-    } catch {}
-  }
+  const url = `http://${hostname2}:${port}`;
+  console.log(`Connectors API + OAuth server running at ${url}`);
+  console.log(`  /api/* and /mcp require ${describeServeTokenSource(serveToken)}; /health and /oauth/* are public`);
   return port;
 }
 
@@ -37842,12 +37598,11 @@ function hasFlag(flag) {
 function printHelp() {
   console.log(`Usage: connectors-serve [options]
 
-Start the Connectors dashboard server
+Start the Connectors API + OAuth server
 
 Options:
   --port <port>     Port to bind (default: ${DEFAULT_PORT})
   --port=<port>     Port to bind (default: ${DEFAULT_PORT})
-  --no-open         Do not open the dashboard in a browser
   -V, --version     Output the version number
   -h, --help        Display help for command`);
 }
@@ -37870,5 +37625,4 @@ if (hasFlag("--version") || hasFlag("-V")) {
   console.log(package_default.version);
   process.exit(0);
 }
-var shouldOpen = !process.argv.includes("--no-open");
-startServer(parsePort(), { open: shouldOpen });
+startServer(parsePort());