@hasna/connectors 1.4.0 → 1.4.1

package/bin/index.js

@@ -1909,7 +1909,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/connectors",
-    version: "1.4.0",
+    version: "1.4.1",
     description: "Open source connector library - Install API connectors with a single command",
     type: "module",
     bin: {
@@ -1922,7 +1922,15 @@ var init_package = __esm(() => {
       "dist/",
       "dashboard/dist/",
       "connectors/",
-      "README.md"
+      "README.md",
+      "!connectors/**/.test-home/**",
+      "!connectors/**/node_modules/**",
+      "!connectors/**/bun.lock",
+      "!connectors/**/package-lock.json",
+      "!connectors/**/yarn.lock",
+      "!connectors/**/pnpm-lock.yaml",
+      "!connectors/**/.env",
+      "!connectors/**/.env.local"
     ],
     exports: {
       ".": {
@@ -1937,7 +1945,7 @@ var init_package = __esm(() => {
     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 && 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: "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)',
       dev: "bun run ./src/cli/index.tsx",
@@ -6091,28 +6099,28 @@ var init_zod = __esm(() => {
 
 // src/core/connectors/github.ts
 import { Buffer as Buffer2 } from "buffer";
-import { existsSync as existsSync2 } from "fs";
-import { dirname, join as join2 } from "path";
+import { existsSync } from "fs";
+import { dirname, join } from "path";
 import { fileURLToPath, pathToFileURL } from "url";
 function resolveGithubConnectorDir() {
   const candidates = [
-    join2(__dirname2, "..", "..", "..", "connectors", "github"),
-    join2(__dirname2, "..", "..", "connectors", "github"),
-    join2(__dirname2, "..", "connectors", "github"),
-    join2(process.cwd(), "connectors", "github")
+    join(__dirname2, "..", "..", "..", "connectors", "github"),
+    join(__dirname2, "..", "..", "connectors", "github"),
+    join(__dirname2, "..", "connectors", "github"),
+    join(process.cwd(), "connectors", "github")
   ];
   for (const candidate of candidates) {
-    if (existsSync2(candidate)) {
+    if (existsSync(candidate)) {
       return candidate;
     }
   }
   return candidates[0];
 }
 async function loadGitHubApiModule() {
-  return await import(pathToFileURL(join2(CONNECTOR_DIR, "src", "api", "index.ts")).href);
+  return await import(pathToFileURL(join(CONNECTOR_DIR, "src", "api", "index.ts")).href);
 }
 async function loadGitHubConfigModule() {
-  return await import(pathToFileURL(join2(CONNECTOR_DIR, "src", "utils", "config.ts")).href);
+  return await import(pathToFileURL(join(CONNECTOR_DIR, "src", "utils", "config.ts")).href);
 }
 function extractGlobalArgs(args) {
   const remaining = [];
@@ -6956,9 +6964,9 @@ Commands:
 });
 
 // src/core/connectors/gmail.ts
-import { existsSync as existsSync3, mkdirSync, readFileSync, readdirSync, writeFileSync } from "fs";
-import { homedir as homedir2 } from "os";
-import { basename, join as join3 } from "path";
+import { existsSync as existsSync2, mkdirSync, readFileSync, readdirSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { basename, join as join2 } from "path";
 async function modifyMessage(profile, messageId, addLabelIds, removeLabelIds) {
   return requestJson(profile, `/users/me/messages/${encodeURIComponent(messageId)}/modify`, {}, {
     method: "POST",
@@ -6995,7 +7003,7 @@ async function replyToMessage(profile, messageId, input) {
 }
 async function downloadAttachments(profile, input) {
   const messageId = getMessageId(input);
-  const outputDir = input.dir ?? input.outputDir ?? join3(configDirs()[0], "attachments", messageId);
+  const outputDir = input.dir ?? input.outputDir ?? join2(configDirs()[0], "attachments", messageId);
   mkdirSync(outputDir, { recursive: true });
   const attachments = input.attachmentId && input.filename ? [{
     attachmentId: input.attachmentId,
@@ -7007,7 +7015,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 = join3(outputDir, filename);
+    const path = join2(outputDir, filename);
     const buffer = Buffer.from(data.data, "base64url");
     writeFileSync(path, buffer);
     downloaded.push({
@@ -7124,8 +7132,8 @@ async function refreshAccessToken(profile, currentTokens) {
 function listProfiles() {
   const profiles = new Set;
   for (const baseDir of configDirs()) {
-    const profilesDir = join3(baseDir, "profiles");
-    if (!existsSync3(profilesDir))
+    const profilesDir = join2(baseDir, "profiles");
+    if (!existsSync2(profilesDir))
       continue;
     for (const entry of readdirSync(profilesDir, { withFileTypes: true })) {
       if (entry.isDirectory())
@@ -7143,8 +7151,8 @@ function loadCredentials(profile) {
     return { clientId: envClientId, clientSecret: envClientSecret };
   for (const baseDir of configDirs()) {
     const credentials = {
-      ...readJson(join3(baseDir, "credentials.json")),
-      ...readJson(join3(baseDir, "profiles", profile, "config.json"))
+      ...readJson(join2(baseDir, "credentials.json")),
+      ...readJson(join2(baseDir, "profiles", profile, "config.json"))
     };
     if (credentials.clientId || credentials.clientSecret)
       return credentials;
@@ -7153,30 +7161,30 @@ function loadCredentials(profile) {
 }
 function loadTokens(profile) {
   for (const baseDir of configDirs()) {
-    const fromProfile = readJson(join3(baseDir, "profiles", profile, "tokens.json"));
+    const fromProfile = readJson(join2(baseDir, "profiles", profile, "tokens.json"));
     if (fromProfile)
       return fromProfile;
-    const flat = readJson(join3(baseDir, "profiles", `${profile}.json`));
+    const flat = readJson(join2(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) => existsSync3(dir)) ?? configDirs()[0];
-  const profileDir = join3(baseDir, "profiles", profile);
+  const baseDir = configDirs().find((dir) => existsSync2(dir)) ?? configDirs()[0];
+  const profileDir = join2(baseDir, "profiles", profile);
   mkdirSync(profileDir, { recursive: true });
-  writeFileSync(join3(profileDir, "tokens.json"), JSON.stringify(tokens, null, 2), { mode: 384 });
+  writeFileSync(join2(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 ?? join3(homedir2(), ".hasna", "connectors");
-  return [join3(baseDir, "gmail"), join3(baseDir, "connect-gmail")];
+  const baseDir = process.env.HASNA_CONNECTORS_DIR ?? join2(homedir(), ".hasna", "connectors");
+  return [join2(baseDir, "gmail"), join2(baseDir, "connect-gmail")];
 }
 function readJson(path) {
-  if (!existsSync3(path))
+  if (!existsSync2(path))
     return null;
   try {
     return JSON.parse(readFileSync(path, "utf8"));
@@ -7426,9 +7434,9 @@ var init_gmail = __esm(() => {
 });
 
 // src/core/connectors/googledrive.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync2, readdirSync as readdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import { homedir as homedir3 } from "os";
-import { basename as basename2, join as join4 } from "path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, readdirSync as readdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { basename as basename2, join as join3 } from "path";
 async function requestJson2(profile, path, params) {
   const response = await request(profile, path, params);
   const text = await response.text();
@@ -7496,8 +7504,8 @@ async function refreshAccessToken2(profile, currentTokens) {
 function listProfiles2() {
   const profiles = new Set;
   for (const baseDir of configDirs2()) {
-    const profilesDir = join4(baseDir, "profiles");
-    if (!existsSync4(profilesDir))
+    const profilesDir = join3(baseDir, "profiles");
+    if (!existsSync3(profilesDir))
       continue;
     for (const entry of readdirSync2(profilesDir, { withFileTypes: true })) {
       if (entry.isDirectory())
@@ -7511,7 +7519,7 @@ function listProfiles2() {
 function listProfileStatuses(profile) {
   const profiles = profile ? [profile] : listProfiles2();
   const uniqueProfiles = profiles.length ? profiles : ["default"];
-  const now2 = Date.now();
+  const now = Date.now();
   return uniqueProfiles.map((name) => {
     const tokens = loadTokens2(name);
     const credentials = loadCredentials2(name);
@@ -7519,7 +7527,7 @@ function listProfileStatuses(profile) {
     const hasRefreshToken = Boolean(tokens?.refreshToken);
     const hasOAuthCredentials = Boolean(credentials.clientId && credentials.clientSecret);
     const expiresAt = tokens?.expiresAt ?? null;
-    const expired = Boolean(expiresAt && now2 >= expiresAt - REFRESH_BUFFER_MS2);
+    const expired = Boolean(expiresAt && now >= expiresAt - REFRESH_BUFFER_MS2);
     const authenticated = Boolean(process.env.GOOGLE_ACCESS_TOKEN || hasRefreshToken || hasAccessToken && !expired);
     const configured = authenticated || hasOAuthCredentials;
     const authRequired = !authenticated || expired && !hasRefreshToken;
@@ -7544,8 +7552,8 @@ function loadCredentials2(profile) {
     return { clientId: envClientId, clientSecret: envClientSecret };
   for (const baseDir of configDirs2()) {
     const credentials = {
-      ...readJson2(join4(baseDir, "credentials.json")),
-      ...readJson2(join4(baseDir, "profiles", profile, "config.json"))
+      ...readJson2(join3(baseDir, "credentials.json")),
+      ...readJson2(join3(baseDir, "profiles", profile, "config.json"))
     };
     if (credentials.clientId || credentials.clientSecret)
       return credentials;
@@ -7554,30 +7562,30 @@ function loadCredentials2(profile) {
 }
 function loadTokens2(profile) {
   for (const baseDir of configDirs2()) {
-    const fromProfile = readJson2(join4(baseDir, "profiles", profile, "tokens.json"));
+    const fromProfile = readJson2(join3(baseDir, "profiles", profile, "tokens.json"));
     if (fromProfile)
       return fromProfile;
-    const flat = readJson2(join4(baseDir, "profiles", `${profile}.json`));
+    const flat = readJson2(join3(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) => existsSync4(dir)) ?? configDirs2()[0];
-  const profileDir = join4(baseDir, "profiles", profile);
+  const baseDir = configDirs2().find((dir) => existsSync3(dir)) ?? configDirs2()[0];
+  const profileDir = join3(baseDir, "profiles", profile);
   mkdirSync2(profileDir, { recursive: true });
-  writeFileSync2(join4(profileDir, "tokens.json"), JSON.stringify(tokens, null, 2), { mode: 384 });
+  writeFileSync2(join3(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 ?? join4(homedir3(), ".hasna", "connectors");
-  return [join4(baseDir, "googledrive"), join4(baseDir, "connect-googledrive")];
+  const baseDir = process.env.HASNA_CONNECTORS_DIR ?? join3(homedir2(), ".hasna", "connectors");
+  return [join3(baseDir, "googledrive"), join3(baseDir, "connect-googledrive")];
 }
 function readJson2(path) {
-  if (!existsSync4(path))
+  if (!existsSync3(path))
     return null;
   try {
     return JSON.parse(readFileSync2(path, "utf8"));
@@ -7818,39 +7826,39 @@ var init_sqlite_adapter = () => {};
 var exports_database = {};
 __export(exports_database, {
   shortUuid: () => shortUuid,
-  now: () => now2,
+  now: () => now,
   getDatabase: () => getDatabase,
   getConnectorsHome: () => getConnectorsHome,
   closeDatabase: () => closeDatabase,
   SqliteAdapter: () => SqliteAdapter
 });
-import { dirname as dirname2, join as join5 } from "path";
-import { homedir as homedir4 } from "os";
-import { mkdirSync as mkdirSync3, existsSync as existsSync5, readdirSync as readdirSync3, copyFileSync, statSync } from "fs";
+import { dirname as dirname2, join as join4 } from "path";
+import { homedir as homedir3 } from "os";
+import { mkdirSync as mkdirSync3, existsSync as existsSync4, readdirSync as readdirSync3, copyFileSync, statSync } from "fs";
 function mergeDirectoryContents(sourceDir, targetDir) {
-  if (!existsSync5(sourceDir)) {
+  if (!existsSync4(sourceDir)) {
     return;
   }
   mkdirSync3(targetDir, { recursive: true });
   for (const entry of readdirSync3(sourceDir)) {
-    const sourcePath = join5(sourceDir, entry);
-    const targetPath = join5(targetDir, entry);
+    const sourcePath = join4(sourceDir, entry);
+    const targetPath = join4(targetDir, entry);
     try {
       const sourceStat = statSync(sourcePath);
       if (sourceStat.isDirectory()) {
         mergeDirectoryContents(sourcePath, targetPath);
         continue;
       }
-      if (!existsSync5(targetPath)) {
+      if (!existsSync4(targetPath)) {
         copyFileSync(sourcePath, targetPath);
       }
     } catch {}
   }
 }
 function getConnectorsHome() {
-  const home = process.env["HOME"] || process.env["USERPROFILE"] || homedir4();
-  const newDir = join5(home, ".hasna", "connectors");
-  const legacyDirs = [join5(home, ".connectors"), join5(home, ".connect")];
+  const home = process.env["HOME"] || process.env["USERPROFILE"] || homedir3();
+  const newDir = join4(home, ".hasna", "connectors");
+  const legacyDirs = [join4(home, ".connectors"), join4(home, ".connect")];
   mkdirSync3(newDir, { recursive: true });
   for (const legacyDir of legacyDirs) {
     try {
@@ -7882,7 +7890,7 @@ function closeDatabase() {
   _db = null;
   _dbPath = null;
 }
-function now2() {
+function now() {
   return new Date().toISOString();
 }
 function shortUuid() {
@@ -7999,12 +8007,12 @@ var init_database = __esm(() => {
   init_sqlite_adapter();
   init_sqlite_adapter();
   DB_DIR = getConnectorsHome();
-  DB_PATH = join5(DB_DIR, "connectors.db");
+  DB_PATH = join4(DB_DIR, "connectors.db");
 });
 
 // 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 existsSync5, readdirSync as readdirSync4, statSync as statSync2 } from "fs";
+import { join as join5 } from "path";
 function stripLegacyPrefix(name) {
   return name.startsWith(LEGACY_CONNECTOR_PREFIX) ? name.slice(LEGACY_CONNECTOR_PREFIX.length) : name;
 }
@@ -8047,8 +8055,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) => join5(connectorsDir, dirName));
+  const existingPath = checkedPaths.find((path) => existsSync5(path)) ?? null;
   const existingDirName = existingPath ? dirNames[checkedPaths.indexOf(existingPath)] : null;
   return {
     ...resolution,
@@ -8067,10 +8075,10 @@ function getConnectorPackagePath(connectorsDir, name) {
 function resolveConnectorConfigPaths(name, connectorsHome = getConnectorsHome()) {
   const resolution = resolveConnectorName(name);
   const preferredDirName = resolution.canonicalName || resolution.legacyName;
-  const preferredPath = join6(connectorsHome, preferredDirName);
-  const legacyPath = join6(connectorsHome, resolution.legacyName);
+  const preferredPath = join5(connectorsHome, preferredDirName);
+  const legacyPath = join5(connectorsHome, resolution.legacyName);
   const paths = preferredPath === legacyPath ? [preferredPath] : [preferredPath, legacyPath];
-  const existingPaths = paths.filter((path) => existsSync6(path));
+  const existingPaths = paths.filter((path) => existsSync5(path));
   return {
     ...resolution,
     connectorsHome,
@@ -8088,11 +8096,11 @@ function getConnectorConfigReadDirs(name, connectorsHome = getConnectorsHome())
   return resolveConnectorConfigPaths(name, connectorsHome).readPaths;
 }
 function listConfiguredConnectorNames(connectorsHome = getConnectorsHome()) {
-  if (!existsSync6(connectorsHome))
+  if (!existsSync5(connectorsHome))
     return [];
   const names = new Set;
   for (const entry of readdirSync4(connectorsHome)) {
-    const fullPath = join6(connectorsHome, entry);
+    const fullPath = join5(connectorsHome, entry);
     try {
       if (!statSync2(fullPath).isDirectory())
         continue;
@@ -8115,7 +8123,7 @@ var init_connector_resolver = __esm(() => {
 
 // src/core/connectors/imessage.ts
 import {
-  existsSync as existsSync7,
+  existsSync as existsSync6,
   mkdirSync as mkdirSync4,
   readFileSync as readFileSync3,
   readdirSync as readdirSync5,
@@ -8123,7 +8131,7 @@ import {
   statSync as statSync3,
   writeFileSync as writeFileSync3
 } from "fs";
-import { join as join7 } from "path";
+import { join as join6 } from "path";
 function buildRootHelp(specs) {
   const lines = [
     "Usage: connect-imessage [options] [command]",
@@ -8174,12 +8182,12 @@ function getConfigReadDirs() {
   return getConnectorConfigReadDirs(CONNECTOR_NAME);
 }
 function getProfilesDir() {
-  return join7(getConfigDir(), "profiles");
+  return join6(getConfigDir(), "profiles");
 }
 function getCurrentProfile() {
   for (const configDir of getConfigReadDirs()) {
-    const currentProfileFile = join7(configDir, "current_profile");
-    if (!existsSync7(currentProfileFile))
+    const currentProfileFile = join6(configDir, "current_profile");
+    if (!existsSync6(currentProfileFile))
       continue;
     try {
       return readFileSync3(currentProfileFile, "utf-8").trim() || "default";
@@ -8192,16 +8200,16 @@ function getCurrentProfile() {
 function setCurrentProfile(profile) {
   const configDir = getConfigDir();
   mkdirSync4(configDir, { recursive: true });
-  writeFileSync3(join7(configDir, "current_profile"), profile);
+  writeFileSync3(join6(configDir, "current_profile"), profile);
 }
 function getFlatProfilePath(profile) {
-  return join7(getProfilesDir(), `${profile}.json`);
+  return join6(getProfilesDir(), `${profile}.json`);
 }
 function getFlatProfileReadPaths(profile) {
-  return getConfigReadDirs().map((dir) => join7(dir, "profiles", `${profile}.json`));
+  return getConfigReadDirs().map((dir) => join6(dir, "profiles", `${profile}.json`));
 }
 function getDirectoryProfileReadPaths(profile) {
-  return getConfigReadDirs().map((dir) => join7(dir, "profiles", profile, "config.json"));
+  return getConfigReadDirs().map((dir) => join6(dir, "profiles", profile, "config.json"));
 }
 function loadJsonFile(path) {
   try {
@@ -8221,8 +8229,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, ...existsSync6(path) ? loadJsonFile(path) : {} }), {});
+  const directoryConfig = getDirectoryProfileReadPaths(profile).reverse().reduce((config, path) => ({ ...config, ...existsSync6(path) ? loadJsonFile(path) : {} }), {});
   return sanitizeProfileConfig({
     ...flatConfig,
     ...directoryConfig
@@ -8238,17 +8246,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) => existsSync6(path)) || getConfigReadDirs().some((dir) => existsSync6(join6(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 = join6(configDir, "profiles");
+    if (!existsSync6(profilesDir))
       continue;
     try {
       for (const entry of readdirSync5(profilesDir)) {
-        const fullPath = join7(profilesDir, entry);
+        const fullPath = join6(profilesDir, entry);
         const stat = statSync3(fullPath);
         if (stat.isDirectory()) {
           seen.add(entry);
@@ -8270,11 +8278,11 @@ function createProfile(profile, config = {}) {
 }
 function clearProfile(profile = getCurrentProfile()) {
   const flatPath = getFlatProfilePath(profile);
-  const directoryPath = join7(getProfilesDir(), profile);
-  if (existsSync7(flatPath)) {
+  const directoryPath = join6(getProfilesDir(), profile);
+  if (existsSync6(flatPath)) {
     rmSync(flatPath);
   }
-  if (existsSync7(directoryPath)) {
+  if (existsSync6(directoryPath)) {
     rmSync(directoryPath, { recursive: true, force: true });
   }
 }
@@ -9200,18 +9208,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 existsSync7 } from "fs";
+import { dirname as dirname3, join as join7 } 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")
+    join7(__dirname3, "..", "..", "..", "connectors", "stripe"),
+    join7(__dirname3, "..", "..", "connectors", "stripe"),
+    join7(__dirname3, "..", "connectors", "stripe"),
+    join7(process.cwd(), "connectors", "stripe")
   ];
   for (const candidate of candidates) {
-    if (existsSync8(candidate)) {
+    if (existsSync7(candidate)) {
       return candidate;
     }
   }
@@ -9259,10 +9267,10 @@ function buildCommandHelp2(spec) {
 `);
 }
 async function loadStripeApiModule() {
-  return await import(pathToFileURL2(join8(CONNECTOR_DIR2, "src", "api", "index.ts")).href);
+  return await import(pathToFileURL2(join7(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(join7(CONNECTOR_DIR2, "src", "utils", "config.ts")).href);
 }
 function extractGlobalArgs3(args) {
   const remaining = [];
@@ -18386,8 +18394,8 @@ __export(exports_registry, {
   CONNECTORS: () => CONNECTORS,
   CATEGORIES: () => CATEGORIES
 });
-import { existsSync as existsSync9, readFileSync as readFileSync4 } from "fs";
-import { join as join9, dirname as dirname4 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync4 } from "fs";
+import { join as join8, dirname as dirname4 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function getConnectorsByCategory(category) {
   return CONNECTORS.filter((c) => c.category === category);
@@ -18551,16 +18559,16 @@ function loadConnectorVersions() {
   versionsLoaded = true;
   const thisDir = dirname4(fileURLToPath3(import.meta.url));
   const candidates = [
-    join9(thisDir, "..", "connectors"),
-    join9(thisDir, "..", "..", "connectors")
+    join8(thisDir, "..", "connectors"),
+    join8(thisDir, "..", "..", "connectors")
   ];
-  const connectorsDir = candidates.find((d) => existsSync9(d));
+  const connectorsDir = candidates.find((d) => existsSync8(d));
   if (!connectorsDir)
     return;
   for (const connector of CONNECTORS) {
     try {
-      const pkgPath = join9(getConnectorPackagePath(connectorsDir, connector.name), "package.json");
-      if (existsSync9(pkgPath)) {
+      const pkgPath = join8(getConnectorPackagePath(connectorsDir, connector.name), "package.json");
+      if (existsSync8(pkgPath)) {
         const pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
         connector.version = pkg.version || "0.0.0";
         continue;
@@ -20285,30 +20293,30 @@ __export(exports_installer, {
   getConnectorDocs: () => getConnectorDocs,
   connectorExists: () => connectorExists
 });
-import { existsSync as existsSync10, mkdirSync as mkdirSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync4, readdirSync as readdirSync6, statSync as statSync4, rmSync as rmSync2 } from "fs";
-import { join as join10, dirname as dirname5 } from "path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync4, readdirSync as readdirSync6, statSync as statSync4, rmSync as rmSync2 } from "fs";
+import { join as join9, dirname as dirname5 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 function resolveConnectorsDir() {
-  const fromBin = join10(__dirname4, "..", "connectors");
-  if (existsSync10(fromBin))
+  const fromBin = join9(__dirname4, "..", "connectors");
+  if (existsSync9(fromBin))
     return fromBin;
-  const fromSrc = join10(__dirname4, "..", "..", "connectors");
-  if (existsSync10(fromSrc))
+  const fromSrc = join9(__dirname4, "..", "..", "connectors");
+  if (existsSync9(fromSrc))
     return fromSrc;
   return fromBin;
 }
 function getProjectConnectorsDir(targetDir) {
-  return join10(targetDir, PROJECT_CONNECTORS_DIRNAME);
+  return join9(targetDir, PROJECT_CONNECTORS_DIRNAME);
 }
 function getEnablementManifestPath(targetDir) {
-  return join10(getProjectConnectorsDir(targetDir), ENABLEMENT_MANIFEST_FILENAME);
+  return join9(getProjectConnectorsDir(targetDir), ENABLEMENT_MANIFEST_FILENAME);
 }
 function getLegacyInstallPath(targetDir, name) {
-  return join10(getProjectConnectorsDir(targetDir), legacyConnectorName(name));
+  return join9(getProjectConnectorsDir(targetDir), legacyConnectorName(name));
 }
 function loadEnablementManifest(targetDir) {
   const manifestPath = getEnablementManifestPath(targetDir);
-  if (!existsSync10(manifestPath)) {
+  if (!existsSync9(manifestPath)) {
     return null;
   }
   try {
@@ -20328,11 +20336,11 @@ function loadEnablementManifest(targetDir) {
 }
 function getLegacyInstalledConnectors(targetDir) {
   const connectorsDir = getProjectConnectorsDir(targetDir);
-  if (!existsSync10(connectorsDir)) {
+  if (!existsSync9(connectorsDir)) {
     return [];
   }
   return readdirSync6(connectorsDir).filter((entry) => {
-    const fullPath = join10(connectorsDir, entry);
+    const fullPath = join9(connectorsDir, entry);
     return entry.startsWith("connect-") && statSync4(fullPath).isDirectory();
   }).map((entry) => entry.replace("connect-", "")).sort();
 }
@@ -20341,7 +20349,7 @@ function getEnabledConnectors(targetDir) {
   return [...new Set([...manifestConnectors, ...getLegacyInstalledConnectors(targetDir)])].sort();
 }
 function updateConnectorsIndex(connectorsDir, connectors18) {
-  const indexPath = join10(connectorsDir, ENABLEMENT_INDEX_FILENAME);
+  const indexPath = join9(connectorsDir, ENABLEMENT_INDEX_FILENAME);
   const connectorList = connectors18.map((connector) => `  "${connector}",`).join(`
 `);
   const content = `/**
@@ -20377,7 +20385,7 @@ function getConnectorPath(name) {
 }
 function connectorExists(name) {
   const normalizedName = normalizeConnectorName(name);
-  return hasInternalConnectorDefinition(normalizedName) || existsSync10(getConnectorPath(normalizedName));
+  return hasInternalConnectorDefinition(normalizedName) || existsSync9(getConnectorPath(normalizedName));
 }
 function installConnector(name, options = {}) {
   const { targetDir = process.cwd(), overwrite = false } = options;
@@ -20410,7 +20418,7 @@ function installConnector(name, options = {}) {
   try {
     const nextEnabled = [...new Set([...installed, normalizedName])].sort();
     writeEnablementManifest(targetDir, nextEnabled);
-    if (overwrite && existsSync10(legacyInstallPath)) {
+    if (overwrite && existsSync9(legacyInstallPath)) {
       rmSync2(legacyInstallPath, { recursive: true });
     }
     return {
@@ -20445,8 +20453,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 = join9(connectorPath, "CLAUDE.md");
+  if (existsSync9(claudeMdPath)) {
     return parseConnectorDocs(readFileSync5(claudeMdPath, "utf-8"));
   }
   const internalDocs = getInternalConnectorDefinition(normalizedName)?.docsMarkdown;
@@ -20491,7 +20499,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 (existsSync9(legacyInstallPath)) {
     rmSync2(legacyInstallPath, { recursive: true });
   }
   return true;
@@ -20578,7 +20586,7 @@ function maybeTruncateOutput(text, options = {}) {
 var DEFAULT_COMPACT_LIMIT = 20, DEFAULT_MCP_LIMIT = 20, MAX_COMPACT_LIMIT = 100, DEFAULT_TEXT_WIDTH = 96, DEFAULT_OUTPUT_CHARS = 6000;
 
 // src/lib/lock.ts
-import { openSync, closeSync, unlinkSync, existsSync as existsSync11, statSync as statSync6 } from "fs";
+import { openSync, closeSync, unlinkSync, existsSync as existsSync10, statSync as statSync6 } from "fs";
 import { mkdirSync as mkdirSync6 } from "fs";
 function lockPath(connector) {
   const dir = getConnectorConfigDir(connector);
@@ -20594,7 +20602,7 @@ function isStale(path) {
   }
 }
 function tryAcquire(path) {
-  if (existsSync11(path) && isStale(path)) {
+  if (existsSync10(path) && isStale(path)) {
     try {
       unlinkSync(path);
     } catch {}
@@ -20644,9 +20652,9 @@ var init_lock = __esm(() => {
 });
 
 // src/server/auth.ts
-import { chmodSync, existsSync as existsSync12, readFileSync as readFileSync6, writeFileSync as writeFileSync5, mkdirSync as mkdirSync7, readdirSync as readdirSync8, rmSync as rmSync3, statSync as statSync7 } from "fs";
+import { chmodSync, existsSync as existsSync11, readFileSync as readFileSync6, writeFileSync as writeFileSync5, mkdirSync as mkdirSync7, readdirSync as readdirSync8, rmSync as rmSync3, statSync as statSync7 } from "fs";
 import { randomBytes } from "crypto";
-import { join as join12 } from "path";
+import { join as join11 } from "path";
 function getAuthType(name) {
   name = normalizeConnectorName(name);
   const docs = getConnectorDocs(name);
@@ -20687,8 +20695,8 @@ function writePrivateText(path, data) {
 function getCurrentProfile2(name) {
   name = normalizeConnectorName(name);
   for (const configDir of getConnectorConfigReadDirs2(name)) {
-    const currentProfileFile = join12(configDir, "current_profile");
-    if (existsSync12(currentProfileFile)) {
+    const currentProfileFile = join11(configDir, "current_profile");
+    if (existsSync11(currentProfileFile)) {
       try {
         return readFileSync6(currentProfileFile, "utf-8").trim() || "default";
       } catch {
@@ -20701,14 +20709,14 @@ function getCurrentProfile2(name) {
 function loadProfileConfigFromDir(configDir, profile) {
   let flatConfig = {};
   let dirConfig = {};
-  const profileFile = join12(configDir, "profiles", `${profile}.json`);
-  if (existsSync12(profileFile)) {
+  const profileFile = join11(configDir, "profiles", `${profile}.json`);
+  if (existsSync11(profileFile)) {
     try {
       flatConfig = JSON.parse(readFileSync6(profileFile, "utf-8"));
     } catch {}
   }
-  const profileDirConfig = join12(configDir, "profiles", profile, "config.json");
-  if (existsSync12(profileDirConfig)) {
+  const profileDirConfig = join11(configDir, "profiles", profile, "config.json");
+  if (existsSync11(profileDirConfig)) {
     try {
       dirConfig = JSON.parse(readFileSync6(profileDirConfig, "utf-8"));
     } catch {}
@@ -20728,8 +20736,8 @@ function loadTokens3(name) {
   name = normalizeConnectorName(name);
   const profile = getCurrentProfile2(name);
   for (const configDir of getConnectorConfigReadDirs2(name)) {
-    const tokensFile = join12(configDir, "profiles", profile, "tokens.json");
-    if (existsSync12(tokensFile)) {
+    const tokensFile = join11(configDir, "profiles", profile, "tokens.json");
+    if (existsSync11(tokensFile)) {
       try {
         return JSON.parse(readFileSync6(tokensFile, "utf-8"));
       } catch {
@@ -20862,10 +20870,10 @@ function _saveApiKey(name, key, field) {
   const profile = getCurrentProfile2(name);
   const keyField = field || guessKeyField(name);
   if (keyField === "clientId" || keyField === "clientSecret") {
-    const credentialsFile = join12(configDir, "credentials.json");
+    const credentialsFile = join11(configDir, "credentials.json");
     ensurePrivateDir(configDir);
     let creds = {};
-    if (existsSync12(credentialsFile)) {
+    if (existsSync11(credentialsFile)) {
       try {
         creds = JSON.parse(readFileSync6(credentialsFile, "utf-8"));
       } catch {}
@@ -20874,10 +20882,10 @@ function _saveApiKey(name, key, field) {
     writePrivateJson(credentialsFile, creds);
     return;
   }
-  const profilesDir = join12(configDir, "profiles");
-  const profileFile = join12(profilesDir, `${profile}.json`);
-  const profileDir = join12(profilesDir, profile);
-  if (existsSync12(profileFile)) {
+  const profilesDir = join11(configDir, "profiles");
+  const profileFile = join11(profilesDir, `${profile}.json`);
+  const profileDir = join11(profilesDir, profile);
+  if (existsSync11(profileFile)) {
     let config = {};
     try {
       config = JSON.parse(readFileSync6(profileFile, "utf-8"));
@@ -20888,10 +20896,10 @@ function _saveApiKey(name, key, field) {
     writePrivateJson(profileFile, config);
     return;
   }
-  if (existsSync12(profileDir)) {
-    const configFile = join12(profileDir, "config.json");
+  if (existsSync11(profileDir)) {
+    const configFile = join11(profileDir, "config.json");
     let config = {};
-    if (existsSync12(configFile)) {
+    if (existsSync11(configFile)) {
       try {
         config = JSON.parse(readFileSync6(configFile, "utf-8"));
       } catch {}
@@ -20906,7 +20914,7 @@ function _saveApiKey(name, key, field) {
   ensurePrivateDir(configDir);
   ensurePrivateDir(profilesDir);
   ensurePrivateDir(profileDir);
-  writePrivateJson(join12(profileDir, "config.json"), { [keyField]: key });
+  writePrivateJson(join11(profileDir, "config.json"), { [keyField]: key });
 }
 function guessKeyField(name) {
   name = normalizeConnectorName(name);
@@ -20926,8 +20934,8 @@ function guessKeyField(name) {
 function getOAuthConfig(name) {
   name = normalizeConnectorName(name);
   for (const configDir of getConnectorConfigReadDirs2(name)) {
-    const credentialsFile = join12(configDir, "credentials.json");
-    if (existsSync12(credentialsFile)) {
+    const credentialsFile = join11(configDir, "credentials.json");
+    if (existsSync11(credentialsFile)) {
       try {
         const creds = JSON.parse(readFileSync6(credentialsFile, "utf-8"));
         return { clientId: creds.clientId, clientSecret: creds.clientSecret };
@@ -21013,12 +21021,12 @@ function saveOAuthTokens(name, tokens) {
   name = normalizeConnectorName(name);
   const configDir = getConnectorConfigDir2(name);
   const profile = getCurrentProfile2(name);
-  const profilesDir = join12(configDir, "profiles");
-  const profileDir = join12(profilesDir, profile);
+  const profilesDir = join11(configDir, "profiles");
+  const profileDir = join11(profilesDir, profile);
   ensurePrivateDir(configDir);
   ensurePrivateDir(profilesDir);
   ensurePrivateDir(profileDir);
-  const tokensFile = join12(profileDir, "tokens.json");
+  const tokensFile = join11(profileDir, "tokens.json");
   writePrivateJson(tokensFile, tokens);
 }
 async function refreshOAuthToken(name) {
@@ -21065,13 +21073,13 @@ function listProfiles4(name) {
   name = normalizeConnectorName(name);
   const seen = new Set;
   for (const configDir of getConnectorConfigReadDirs2(name)) {
-    const profilesDir = join12(configDir, "profiles");
-    if (!existsSync12(profilesDir))
+    const profilesDir = join11(configDir, "profiles");
+    if (!existsSync11(profilesDir))
       continue;
     try {
       const entries = readdirSync8(profilesDir);
       for (const entry of entries) {
-        const fullPath = join12(profilesDir, entry);
+        const fullPath = join11(profilesDir, entry);
         const stat = statSync7(fullPath);
         if (stat.isDirectory()) {
           seen.add(entry);
@@ -21088,24 +21096,24 @@ function switchProfile(name, profile) {
   name = normalizeConnectorName(name);
   const configDir = getConnectorConfigDir2(name);
   ensurePrivateDir(configDir);
-  writePrivateText(join12(configDir, "current_profile"), profile);
+  writePrivateText(join11(configDir, "current_profile"), profile);
 }
 function deleteProfile2(name, profile) {
   name = normalizeConnectorName(name);
   if (profile === "default")
     return false;
   const configDir = getConnectorConfigDir2(name);
-  const profilesDir = join12(configDir, "profiles");
-  const profileFile = join12(profilesDir, `${profile}.json`);
-  if (existsSync12(profileFile)) {
+  const profilesDir = join11(configDir, "profiles");
+  const profileFile = join11(profilesDir, `${profile}.json`);
+  if (existsSync11(profileFile)) {
     rmSync3(profileFile);
     if (getCurrentProfile2(name) === profile) {
       switchProfile(name, "default");
     }
     return true;
   }
-  const profileDir = join12(profilesDir, profile);
-  if (existsSync12(profileDir)) {
+  const profileDir = join11(profilesDir, profile);
+  if (existsSync11(profileDir)) {
     rmSync3(profileDir, { recursive: true });
     if (getCurrentProfile2(name) === profile) {
       switchProfile(name, "default");
@@ -21175,7 +21183,7 @@ __export(exports_promotions, {
 });
 function promoteConnector(name, db) {
   const d = db ?? getDatabase();
-  d.run("INSERT OR REPLACE INTO connector_promotions (connector, promoted_at) VALUES (?, ?)", [name, now2()]);
+  d.run("INSERT OR REPLACE INTO connector_promotions (connector, promoted_at) VALUES (?, ?)", [name, now()]);
 }
 function demoteConnector(name, db) {
   const d = db ?? getDatabase();
@@ -21205,7 +21213,7 @@ __export(exports_usage, {
 });
 function logUsage(connector, action, agentId, db) {
   const d = db ?? getDatabase();
-  d.run("INSERT INTO connector_usage (id, connector, action, agent_id, timestamp) VALUES (?, ?, ?, ?, ?)", [shortUuid(), connector, action, agentId ?? null, now2()]);
+  d.run("INSERT INTO connector_usage (id, connector, action, agent_id, timestamp) VALUES (?, ?, ?, ?, ?)", [shortUuid(), connector, action, agentId ?? null, now()]);
 }
 function getUsageStats(connector, db) {
   const d = db ?? getDatabase();
@@ -21263,7 +21271,7 @@ function registerAgent(input, db) {
       };
     }
     const updates = ["last_seen_at = ?"];
-    const params = [now2()];
+    const params = [now()];
     if (input.session_id && !sameSession) {
       updates.push("session_id = ?");
       params.push(input.session_id);
@@ -21273,7 +21281,7 @@ function registerAgent(input, db) {
     return getAgent(existing.id, d);
   }
   const id = shortUuid2();
-  const ts = now2();
+  const ts = now();
   d.run(`INSERT INTO agents (id, name, session_id, role, last_seen_at, created_at)
      VALUES (?, ?, ?, ?, ?, ?)`, [id, normalizedName, input.session_id ?? null, input.role ?? "agent", ts, ts]);
   return getAgent(id, d);
@@ -21292,12 +21300,12 @@ function listAgents(db) {
 }
 function heartbeat(id, db) {
   const d = db ?? getDatabase();
-  d.run("UPDATE agents SET last_seen_at = ? WHERE id = ?", [now2(), id]);
+  d.run("UPDATE agents SET last_seen_at = ? WHERE id = ?", [now(), id]);
   return getAgent(id, d);
 }
 function setFocus(id, projectId, db) {
   const d = db ?? getDatabase();
-  d.run("UPDATE agents SET project_id = ?, last_seen_at = ? WHERE id = ?", [projectId, now2(), id]);
+  d.run("UPDATE agents SET project_id = ?, last_seen_at = ? WHERE id = ?", [projectId, now(), id]);
   return getAgent(id, d);
 }
 function deleteAgent(id, db) {
@@ -21329,9 +21337,9 @@ function countActiveAgents(db) {
   return Math.max(1, row?.count ?? 1);
 }
 function currentWindowStart() {
-  const now4 = Date.now();
+  const now3 = Date.now();
   const windowMs = WINDOW_SECONDS * 1000;
-  return new Date(Math.floor(now4 / windowMs) * windowMs).toISOString();
+  return new Date(Math.floor(now3 / windowMs) * windowMs).toISOString();
 }
 function checkRateBudget(agentId, connector, connectorLimit, consume = true, db) {
   const d = db ?? getDatabase();
@@ -21393,14 +21401,14 @@ __export(exports_llm, {
   PROVIDER_DEFAULTS: () => PROVIDER_DEFAULTS,
   LLMClient: () => LLMClient
 });
-import { existsSync as existsSync13, readFileSync as readFileSync7, writeFileSync as writeFileSync6, mkdirSync as mkdirSync8 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync7, writeFileSync as writeFileSync6, mkdirSync as mkdirSync8 } from "fs";
+import { join as join12 } from "path";
 function getLlmConfigPath() {
-  return join13(getConnectorsHome(), "llm.json");
+  return join12(getConnectorsHome(), "llm.json");
 }
 function getLlmConfig() {
   const path = getLlmConfigPath();
-  if (!existsSync13(path))
+  if (!existsSync12(path))
     return null;
   try {
     return JSON.parse(readFileSync7(path, "utf-8"));
@@ -21561,7 +21569,7 @@ function rowToJob(row) {
 function createJob(input, db) {
   const d = db ?? getDatabase();
   const id = shortUuid();
-  const ts = now2();
+  const ts = now();
   d.run("INSERT INTO connector_jobs (id, name, connector, command, args, cron, enabled, strip, created_at) VALUES (?, ?, ?, ?, ?, ?, 1, ?, ?)", [id, input.name, input.connector, input.command, JSON.stringify(input.args ?? []), input.cron, input.strip ? 1 : 0, ts]);
   return getJob(id, d);
 }
@@ -21627,18 +21635,18 @@ function deleteJob(id, db) {
 }
 function touchJobLastRun(id, db) {
   const d = db ?? getDatabase();
-  d.run("UPDATE connector_jobs SET last_run_at = ? WHERE id = ?", [now2(), id]);
+  d.run("UPDATE connector_jobs SET last_run_at = ? WHERE id = ?", [now(), id]);
 }
 function createJobRun(jobId, db) {
   const d = db ?? getDatabase();
   const id = shortUuid();
-  const ts = now2();
+  const ts = now();
   d.run("INSERT INTO connector_job_runs (id, job_id, started_at) VALUES (?, ?, ?)", [id, jobId, ts]);
   return { id, job_id: jobId, started_at: ts, finished_at: null, exit_code: null, raw_output: null, stripped_output: null };
 }
 function finishJobRun(id, result, db) {
   const d = db ?? getDatabase();
-  d.run("UPDATE connector_job_runs SET finished_at = ?, exit_code = ?, raw_output = ?, stripped_output = ? WHERE id = ?", [now2(), result.exit_code, result.raw_output, result.stripped_output ?? null, id]);
+  d.run("UPDATE connector_job_runs SET finished_at = ?, exit_code = ?, raw_output = ?, stripped_output = ? WHERE id = ?", [now(), result.exit_code, result.raw_output, result.stripped_output ?? null, id]);
 }
 function getLatestRun(jobId, db) {
   const d = db ?? getDatabase();
@@ -21663,7 +21671,7 @@ function rowToWorkflow(row) {
 function createWorkflow(input, db) {
   const d = db ?? getDatabase();
   const id = shortUuid();
-  d.run("INSERT INTO connector_workflows (id, name, steps, enabled, created_at) VALUES (?, ?, ?, 1, ?)", [id, input.name, JSON.stringify(input.steps), now2()]);
+  d.run("INSERT INTO connector_workflows (id, name, steps, enabled, created_at) VALUES (?, ?, ?, 1, ?)", [id, input.name, JSON.stringify(input.steps), now()]);
   return getWorkflow(id, d);
 }
 function getWorkflow(id, db) {
@@ -21696,7 +21704,7 @@ __export(exports_scheduler, {
   startScheduler: () => startScheduler,
   cronMatches: () => cronMatches
 });
-import { spawn as spawn2 } from "child_process";
+import { spawn } from "child_process";
 function cronMatches(cron, d) {
   const parts = cron.trim().split(/\s+/);
   if (parts.length !== 5)
@@ -21723,7 +21731,7 @@ function cronMatches(cron, d) {
 async function runConnectorCommand(connector, command, args) {
   return new Promise((resolve) => {
     const cmdArgs = [connector, command, ...args, "--format", "json"];
-    const proc = spawn2("connectors", ["run", ...cmdArgs], { shell: false });
+    const proc = spawn("connectors", ["run", ...cmdArgs], { shell: false });
     let output = "";
     proc.stdout.on("data", (d) => {
       output += d.toString();
@@ -21760,14 +21768,14 @@ function startScheduler(db) {
   _interval = setInterval(() => {
     (async () => {
       try {
-        const now4 = new Date;
-        const currentMinute = now4.getMinutes() + now4.getHours() * 60;
+        const now3 = new Date;
+        const currentMinute = now3.getMinutes() + now3.getHours() * 60;
         if (currentMinute === _lastCheckedMinute)
           return;
         _lastCheckedMinute = currentMinute;
         const jobs = listEnabledJobs(db);
         for (const job of jobs) {
-          if (cronMatches(job.cron, now4)) {
+          if (cronMatches(job.cron, now3)) {
             executeJob(job, db).catch(() => {});
           }
         }
@@ -21869,16 +21877,16 @@ __export(exports_runner, {
   buildEnvWithCredentials: () => buildEnvWithCredentials,
   buildConnectorOperationArgs: () => buildConnectorOperationArgs
 });
-import { existsSync as existsSync14, readdirSync as readdirSync9 } from "fs";
-import { join as join14, dirname as dirname6 } from "path";
+import { existsSync as existsSync13, readdirSync as readdirSync9 } from "fs";
+import { join as join13, dirname as dirname6 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn2 } from "child_process";
 function resolveConnectorsDir2() {
-  const fromBin = join14(__dirname5, "..", "connectors");
-  if (existsSync14(fromBin))
+  const fromBin = join13(__dirname5, "..", "connectors");
+  if (existsSync13(fromBin))
     return fromBin;
-  const fromSrc = join14(__dirname5, "..", "..", "connectors");
-  if (existsSync14(fromSrc))
+  const fromSrc = join13(__dirname5, "..", "..", "connectors");
+  if (existsSync13(fromSrc))
     return fromSrc;
   return fromBin;
 }
@@ -21946,8 +21954,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 = join14(connectorDir, "src", "cli", "index.ts");
-  if (existsSync14(cliPath))
+  const cliPath = join13(connectorDir, "src", "cli", "index.ts");
+  if (existsSync13(cliPath))
     return cliPath;
   return null;
 }
@@ -22142,7 +22150,7 @@ function runLegacyConnectorCommand(name, args, timeoutMs = 30000) {
     });
   }
   return new Promise((resolve) => {
-    const proc = spawn3("bun", ["run", cliPath, ...args], {
+    const proc = spawn2("bun", ["run", cliPath, ...args], {
       timeout: timeoutMs,
       env: buildEnvWithCredentials(connectorName, process.env),
       stdio: ["pipe", "pipe", "pipe"]
@@ -39054,9 +39062,9 @@ var init_management = __esm(() => {
 });
 
 // src/mcp/tools/auth.ts
-import { existsSync as existsSync15, readFileSync as readFileSync8 } from "fs";
-import { join as join15 } from "path";
-import { spawn as spawn4 } from "child_process";
+import { existsSync as existsSync14, 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", {
     title: "Connector Auth Status",
@@ -39191,7 +39199,7 @@ function registerAuthTools(server, stripped) {
     const oauthUrl = `http://localhost:${serverPort}/oauth/${name}/start`;
     if (noBrowser) {
       const connectorsHome = getConnectorsHome();
-      const tokenPaths = getConnectorConfigReadDirs(name, connectorsHome).map((dir) => join15(dir, "profiles", "default", "tokens.json"));
+      const tokenPaths = getConnectorConfigReadDirs(name, connectorsHome).map((dir) => join14(dir, "profiles", "default", "tokens.json"));
       let serverRunning = false;
       try {
         await fetch(`http://localhost:${serverPort}/api/connectors`);
@@ -39199,7 +39207,7 @@ function registerAuthTools(server, stripped) {
       } catch {}
       if (!serverRunning) {
         const scriptPath = process.argv[1];
-        const serverProc = spawn4("node", [scriptPath, "serve", "--port", String(serverPort)], {
+        const serverProc = spawn3("node", [scriptPath, "serve", "--port", String(serverPort)], {
           detached: true,
           stdio: "ignore"
         });
@@ -39210,7 +39218,7 @@ function registerAuthTools(server, stripped) {
       const maxAttempts = 120;
       while (attempts < maxAttempts) {
         await new Promise((resolve) => setTimeout(resolve, 500));
-        if (tokenPaths.some((tokensPath) => existsSync15(tokensPath))) {
+        if (tokenPaths.some((tokensPath) => existsSync14(tokensPath))) {
           break;
         }
         attempts++;
@@ -39229,7 +39237,7 @@ function registerAuthTools(server, stripped) {
         };
       }
       try {
-        const tokensPath = tokenPaths.find((path) => existsSync15(path)) ?? tokenPaths[0];
+        const tokensPath = tokenPaths.find((path) => existsSync14(path)) ?? tokenPaths[0];
         const tokenData = JSON.parse(readFileSync8(tokensPath, "utf-8"));
         return {
           content: [{
@@ -40021,8 +40029,8 @@ var exports_serve = {};
 __export(exports_serve, {
   startServer: () => startServer
 });
-import { existsSync as existsSync16, readdirSync as readdirSync10, readFileSync as readFileSync9, writeFileSync as writeFileSync7, mkdirSync as mkdirSync9 } from "fs";
-import { join as join16, dirname as dirname7, extname, basename as basename3 } from "path";
+import { existsSync as existsSync15, readdirSync as readdirSync10, readFileSync as readFileSync9, writeFileSync as writeFileSync7, mkdirSync as mkdirSync9 } from "fs";
+import { join as join15, dirname as dirname7, extname, basename as basename3 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 function logActivity(action, connector, detail) {
   activityLog.unshift({ action, connector, timestamp: Date.now(), detail });
@@ -40034,20 +40042,20 @@ function resolveDashboardDir() {
   const candidates = [];
   try {
     const scriptDir = dirname7(fileURLToPath6(import.meta.url));
-    candidates.push(join16(scriptDir, "..", "dashboard", "dist"));
-    candidates.push(join16(scriptDir, "..", "..", "dashboard", "dist"));
+    candidates.push(join15(scriptDir, "..", "dashboard", "dist"));
+    candidates.push(join15(scriptDir, "..", "..", "dashboard", "dist"));
   } catch {}
   if (process.argv[1]) {
     const mainDir = dirname7(process.argv[1]);
-    candidates.push(join16(mainDir, "..", "dashboard", "dist"));
-    candidates.push(join16(mainDir, "..", "..", "dashboard", "dist"));
+    candidates.push(join15(mainDir, "..", "dashboard", "dist"));
+    candidates.push(join15(mainDir, "..", "..", "dashboard", "dist"));
   }
-  candidates.push(join16(process.cwd(), "dashboard", "dist"));
+  candidates.push(join15(process.cwd(), "dashboard", "dist"));
   for (const candidate of candidates) {
-    if (existsSync16(candidate))
+    if (existsSync15(candidate))
       return candidate;
   }
-  return join16(process.cwd(), "dashboard", "dist");
+  return join15(process.cwd(), "dashboard", "dist");
 }
 function json(data, status = 200, port) {
   return new Response(JSON.stringify(data), {
@@ -40129,7 +40137,7 @@ function oauthPage(type, title, message, hint, extra) {
   </body></html>`;
 }
 function serveStaticFile(filePath) {
-  if (!existsSync16(filePath))
+  if (!existsSync15(filePath))
     return null;
   const ext = extname(filePath);
   const contentType = MIME_TYPES[ext] || "application/octet-stream";
@@ -40166,7 +40174,7 @@ async function startServer(requestedPort, options) {
   const strict = options?.strict ?? false;
   loadConnectorVersions();
   const dashboardDir = resolveDashboardDir();
-  const dashboardExists = existsSync16(dashboardDir);
+  const dashboardExists = existsSync15(dashboardDir);
   if (!dashboardExists) {
     console.error(`
 Dashboard not found at: ${dashboardDir}`);
@@ -40597,8 +40605,8 @@ ${result.stderr}`;
           const profiles = listProfiles4(name);
           let current = "default";
           for (const configDir of getConnectorConfigReadDirs(name)) {
-            const currentProfileFile = join16(configDir, "current_profile");
-            if (existsSync16(currentProfileFile)) {
+            const currentProfileFile = join15(configDir, "current_profile");
+            if (existsSync15(currentProfileFile)) {
               try {
                 current = readFileSync9(currentProfileFile, "utf-8").trim() || "default";
               } catch {}
@@ -40651,25 +40659,25 @@ ${result.stderr}`;
         try {
           const connectDir = getConnectorsHome();
           const result = {};
-          if (existsSync16(connectDir)) {
+          if (existsSync15(connectDir)) {
             for (const connectorName of listConfiguredConnectorNames(connectDir)) {
               const profiles = {};
               for (const configDir of [...getConnectorConfigReadDirs(connectorName, connectDir)].reverse()) {
-                const profilesDir = join16(configDir, "profiles");
-                if (!existsSync16(profilesDir))
+                const profilesDir = join15(configDir, "profiles");
+                if (!existsSync15(profilesDir))
                   continue;
                 const profileEntries = readdirSync10(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(join16(profilesDir, pEntry.name), "utf-8"));
+                      const config2 = JSON.parse(readFileSync9(join15(profilesDir, pEntry.name), "utf-8"));
                       profiles[profileName] = config2;
                     } catch {}
                   }
                   if (pEntry.isDirectory()) {
-                    const configPath = join16(profilesDir, pEntry.name, "config.json");
-                    if (existsSync16(configPath)) {
+                    const configPath = join15(profilesDir, pEntry.name, "config.json");
+                    if (existsSync15(configPath)) {
                       try {
                         const config2 = JSON.parse(readFileSync9(configPath, "utf-8"));
                         profiles[pEntry.name] = config2;
@@ -40714,12 +40722,12 @@ ${result.stderr}`;
             if (!data.profiles || typeof data.profiles !== "object")
               continue;
             const connectorDir = getConnectorConfigDir(connectorName, connectDir);
-            const profilesDir = join16(connectorDir, "profiles");
+            const profilesDir = join15(connectorDir, "profiles");
             for (const [profileName, config2] of Object.entries(data.profiles)) {
               if (!config2 || typeof config2 !== "object")
                 continue;
               mkdirSync9(profilesDir, { recursive: true });
-              const profileFile = join16(profilesDir, `${profileName}.json`);
+              const profileFile = join15(profilesDir, `${profileName}.json`);
               writeFileSync7(profileFile, JSON.stringify(config2, null, 2));
               imported++;
             }
@@ -40775,12 +40783,12 @@ ${result.stderr}`;
       }
       if (dashboardExists && (method === "GET" || method === "HEAD")) {
         if (path !== "/") {
-          const filePath = join16(dashboardDir, path);
+          const filePath = join15(dashboardDir, path);
           const res2 = serveStaticFile(filePath);
           if (res2)
             return res2;
         }
-        const indexPath = join16(dashboardDir, "index.html");
+        const indexPath = join15(dashboardDir, "index.html");
         const res = serveStaticFile(indexPath);
         if (res)
           return res;
@@ -40865,692 +40873,10 @@ var {
   Help
 } = import__.default;
 
-// node_modules/@hasna/events/dist/commander.js
-import { chmod, mkdir, readFile, rename, writeFile } from "fs/promises";
-import { existsSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-import { createHmac, timingSafeEqual } from "crypto";
-import { randomUUID } from "crypto";
-import { spawn } from "child_process";
-import { randomUUID as randomUUID2 } from "crypto";
-function getPathValue(input, path) {
-  return path.split(".").reduce((value, part) => {
-    if (value && typeof value === "object" && part in value) {
-      return value[part];
-    }
-    return;
-  }, input);
-}
-function wildcardToRegExp(pattern) {
-  const escaped = pattern.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replace(/\*/g, ".*");
-  return new RegExp(`^${escaped}$`);
-}
-function matchString(value, matcher) {
-  if (matcher === undefined)
-    return true;
-  if (value === undefined)
-    return false;
-  const matchers = Array.isArray(matcher) ? matcher : [matcher];
-  return matchers.some((item) => wildcardToRegExp(item).test(value));
-}
-function matchRecord(input, matcher) {
-  if (!matcher)
-    return true;
-  return Object.entries(matcher).every(([path, expected]) => {
-    const actual = getPathValue(input, path);
-    if (typeof expected === "string" || Array.isArray(expected)) {
-      return matchString(actual === undefined ? undefined : String(actual), expected);
-    }
-    return actual === expected;
-  });
-}
-function eventMatchesFilter(event, filter) {
-  return matchString(event.source, filter.source) && matchString(event.type, filter.type) && matchString(event.subject, filter.subject) && matchString(event.severity, filter.severity) && matchRecord(event.data, filter.data) && matchRecord(event.metadata, filter.metadata);
-}
-function channelMatchesEvent(channel, event) {
-  if (!channel.enabled)
-    return false;
-  if (!channel.filters || channel.filters.length === 0)
-    return true;
-  return channel.filters.some((filter) => eventMatchesFilter(event, filter));
-}
-var HASNA_EVENTS_DIR_ENV = "HASNA_EVENTS_DIR";
-var HASNA_EVENTS_HOME_ENV = "HASNA_EVENTS_HOME";
-function getEventsDataDir(override) {
-  return override || process.env[HASNA_EVENTS_DIR_ENV] || process.env[HASNA_EVENTS_HOME_ENV] || join(homedir(), ".hasna", "events");
-}
-class JsonEventsStore {
-  dataDir;
-  channelsPath;
-  eventsPath;
-  deliveriesPath;
-  constructor(dataDir = getEventsDataDir()) {
-    this.dataDir = dataDir;
-    this.channelsPath = join(dataDir, "channels.json");
-    this.eventsPath = join(dataDir, "events.json");
-    this.deliveriesPath = join(dataDir, "deliveries.json");
-  }
-  async init() {
-    await mkdir(this.dataDir, { recursive: true, mode: 448 });
-    await chmod(this.dataDir, 448).catch(() => {
-      return;
-    });
-    await this.ensureArrayFile(this.channelsPath);
-    await this.ensureArrayFile(this.eventsPath);
-    await this.ensureArrayFile(this.deliveriesPath);
-  }
-  async addChannel(channel) {
-    await this.init();
-    const channels = await this.readJson(this.channelsPath, []);
-    const index = channels.findIndex((item) => item.id === channel.id);
-    if (index >= 0) {
-      channels[index] = { ...channel, createdAt: channels[index].createdAt, updatedAt: new Date().toISOString() };
-    } else {
-      channels.push(channel);
-    }
-    await this.writeJson(this.channelsPath, channels);
-    return index >= 0 ? channels[index] : channel;
-  }
-  async listChannels() {
-    await this.init();
-    return this.readJson(this.channelsPath, []);
-  }
-  async getChannel(id) {
-    const channels = await this.listChannels();
-    return channels.find((channel) => channel.id === id);
-  }
-  async removeChannel(id) {
-    await this.init();
-    const channels = await this.readJson(this.channelsPath, []);
-    const next = channels.filter((channel) => channel.id !== id);
-    await this.writeJson(this.channelsPath, next);
-    return next.length !== channels.length;
-  }
-  async appendEvent(event) {
-    await this.init();
-    const events = await this.readJson(this.eventsPath, []);
-    events.push(event);
-    await this.writeJson(this.eventsPath, events);
-    return event;
-  }
-  async listEvents() {
-    await this.init();
-    return this.readJson(this.eventsPath, []);
-  }
-  async findEventByIdentity(identity) {
-    const events = await this.listEvents();
-    return events.find((event) => identity.id !== undefined && event.id === identity.id || identity.dedupeKey !== undefined && event.dedupeKey === identity.dedupeKey);
-  }
-  async appendDelivery(result) {
-    await this.init();
-    const deliveries = await this.readJson(this.deliveriesPath, []);
-    deliveries.push(result);
-    await this.writeJson(this.deliveriesPath, deliveries);
-    return result;
-  }
-  async listDeliveries() {
-    await this.init();
-    return this.readJson(this.deliveriesPath, []);
-  }
-  async exportData() {
-    return {
-      channels: await this.listChannels(),
-      events: await this.listEvents(),
-      deliveries: await this.listDeliveries()
-    };
-  }
-  async ensureArrayFile(path) {
-    if (!existsSync(path)) {
-      await writeFile(path, `[]
-`, { encoding: "utf-8", mode: 384 });
-    }
-    await chmod(path, 384).catch(() => {
-      return;
-    });
-  }
-  async readJson(path, fallback) {
-    try {
-      const raw = await readFile(path, "utf-8");
-      if (!raw.trim())
-        return fallback;
-      return JSON.parse(raw);
-    } catch (error) {
-      if (error.code === "ENOENT")
-        return fallback;
-      throw error;
-    }
-  }
-  async writeJson(path, value) {
-    const tempPath = `${path}.${process.pid}.${Date.now()}.tmp`;
-    await writeFile(tempPath, `${JSON.stringify(value, null, 2)}
-`, { encoding: "utf-8", mode: 384 });
-    await rename(tempPath, path);
-    await chmod(path, 384).catch(() => {
-      return;
-    });
-  }
-}
-var DEFAULT_SIGNATURE_TOLERANCE_MS = 5 * 60 * 1000;
-function buildSignatureBase(timestamp, body) {
-  return `${timestamp}.${body}`;
-}
-function signPayload(secret, timestamp, body) {
-  const digest = createHmac("sha256", secret).update(buildSignatureBase(timestamp, body)).digest("hex");
-  return `sha256=${digest}`;
-}
-function now() {
-  return new Date().toISOString();
-}
-function truncate(value, max = 4096) {
-  return value.length > max ? `${value.slice(0, max)}...` : value;
-}
-function buildWebhookRequest(event, channel) {
-  if (!channel.webhook)
-    throw new Error(`Channel ${channel.id} has no webhook config`);
-  const body = JSON.stringify(event);
-  const timestamp = event.time;
-  const headers = {
-    "Content-Type": "application/json",
-    "User-Agent": "@hasna/events",
-    "X-Hasna-Event-Id": event.id,
-    "X-Hasna-Event-Type": event.type,
-    "X-Hasna-Timestamp": timestamp,
-    ...channel.webhook.headers
-  };
-  if (channel.webhook.secret) {
-    headers["X-Hasna-Signature"] = signPayload(channel.webhook.secret, timestamp, body);
-  }
-  return { body, headers };
-}
-async function dispatchWebhook(event, channel, options = {}) {
-  if (!channel.webhook)
-    throw new Error(`Channel ${channel.id} has no webhook config`);
-  const startedAt = now();
-  const { body, headers } = buildWebhookRequest(event, channel);
-  const controller = new AbortController;
-  const timeout = setTimeout(() => controller.abort(), channel.webhook.timeoutMs ?? 15000);
-  try {
-    const response = await (options.fetchImpl ?? fetch)(channel.webhook.url, {
-      method: "POST",
-      headers,
-      body,
-      signal: controller.signal
-    });
-    const responseBody = truncate(await response.text());
-    return {
-      attempt: 1,
-      status: response.ok ? "success" : "failed",
-      startedAt,
-      completedAt: now(),
-      responseStatus: response.status,
-      responseBody,
-      error: response.ok ? undefined : `Webhook returned HTTP ${response.status}`
-    };
-  } catch (error) {
-    return {
-      attempt: 1,
-      status: "failed",
-      startedAt,
-      completedAt: now(),
-      error: error instanceof Error ? error.message : String(error)
-    };
-  } finally {
-    clearTimeout(timeout);
-  }
-}
-async function dispatchCommand(event, channel) {
-  if (!channel.command)
-    throw new Error(`Channel ${channel.id} has no command config`);
-  const startedAt = now();
-  const eventJson = JSON.stringify(event);
-  const env = {
-    ...process.env,
-    ...channel.command.env,
-    HASNA_CHANNEL_ID: channel.id,
-    HASNA_EVENT_ID: event.id,
-    HASNA_EVENT_TYPE: event.type,
-    HASNA_EVENT_SOURCE: event.source,
-    HASNA_EVENT_SUBJECT: event.subject ?? "",
-    HASNA_EVENT_SEVERITY: event.severity,
-    HASNA_EVENT_TIME: event.time,
-    HASNA_EVENT_DEDUPE_KEY: event.dedupeKey ?? "",
-    HASNA_EVENT_SCHEMA_VERSION: event.schemaVersion,
-    HASNA_EVENT_JSON: eventJson
-  };
-  return new Promise((resolve) => {
-    const child = spawn(channel.command.command, channel.command.args ?? [], {
-      cwd: channel.command.cwd,
-      env,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    let stdout = "";
-    let stderr = "";
-    const timeout = setTimeout(() => child.kill("SIGTERM"), channel.command.timeoutMs ?? 15000);
-    child.stdin.end(eventJson);
-    child.stdout.on("data", (chunk) => {
-      stdout += chunk.toString();
-    });
-    child.stderr.on("data", (chunk) => {
-      stderr += chunk.toString();
-    });
-    child.on("error", (error) => {
-      clearTimeout(timeout);
-      resolve({
-        attempt: 1,
-        status: "failed",
-        startedAt,
-        completedAt: now(),
-        stdout: truncate(stdout),
-        stderr: truncate(stderr),
-        error: error.message
-      });
-    });
-    child.on("close", (code, signal) => {
-      clearTimeout(timeout);
-      const success = code === 0;
-      resolve({
-        attempt: 1,
-        status: success ? "success" : "failed",
-        startedAt,
-        completedAt: now(),
-        stdout: truncate(stdout),
-        stderr: truncate(stderr),
-        error: success ? undefined : `Command exited with ${signal ? `signal ${signal}` : `code ${code}`}`
-      });
-    });
-  });
-}
-async function dispatchChannel(event, channel, options = {}) {
-  if (channel.transport === "webhook")
-    return dispatchWebhook(event, channel, options);
-  if (channel.transport === "command")
-    return dispatchCommand(event, channel);
-  return {
-    attempt: 1,
-    status: "skipped",
-    startedAt: now(),
-    completedAt: now(),
-    error: `Unsupported transport: ${channel.transport}`
-  };
-}
-function createDeliveryResult(event, channel, attempts) {
-  const status = attempts.some((attempt) => attempt.status === "success") ? "success" : attempts.every((attempt) => attempt.status === "skipped") ? "skipped" : "failed";
-  return {
-    id: randomUUID(),
-    eventId: event.id,
-    channelId: channel.id,
-    transport: channel.transport,
-    status,
-    attempts,
-    createdAt: attempts[0]?.startedAt ?? now(),
-    completedAt: attempts.at(-1)?.completedAt ?? now()
-  };
-}
-function createEvent(input) {
-  return {
-    id: input.id ?? randomUUID2(),
-    source: input.source,
-    type: input.type,
-    time: normalizeTime(input.time),
-    subject: input.subject,
-    severity: input.severity ?? "info",
-    data: input.data ?? {},
-    message: input.message,
-    dedupeKey: input.dedupeKey,
-    schemaVersion: input.schemaVersion ?? "1.0",
-    metadata: input.metadata ?? {}
-  };
-}
-
-class EventsClient {
-  store;
-  redactors;
-  transportOptions;
-  constructor(options = {}) {
-    this.store = options.store ?? new JsonEventsStore(options.dataDir);
-    this.redactors = options.redactors ?? [];
-    this.transportOptions = { fetchImpl: options.fetchImpl };
-  }
-  async addChannel(input) {
-    const timestamp = new Date().toISOString();
-    return this.store.addChannel({
-      ...input,
-      createdAt: input.createdAt ?? timestamp,
-      updatedAt: input.updatedAt ?? timestamp
-    });
-  }
-  async listChannels() {
-    return this.store.listChannels();
-  }
-  async removeChannel(id) {
-    return this.store.removeChannel(id);
-  }
-  async emit(input, options = {}) {
-    const event = options.redactSensitiveData === false ? createEvent(input) : redactSensitiveKeys(createEvent(input));
-    if (options.dedupe !== false) {
-      const existing = await this.store.findEventByIdentity({ id: input.id, dedupeKey: event.dedupeKey });
-      if (existing) {
-        return { event: existing, deliveries: [], deduped: true };
-      }
-    }
-    await this.store.appendEvent(event);
-    const deliveries = options.deliver === false ? [] : await this.deliver(event);
-    return { event, deliveries, deduped: false };
-  }
-  async listEvents() {
-    return this.store.listEvents();
-  }
-  async listDeliveries() {
-    return this.store.listDeliveries();
-  }
-  async deliver(event) {
-    const channels = await this.store.listChannels();
-    const selected = channels.filter((channel) => channelMatchesEvent(channel, event));
-    const deliveries = [];
-    for (const channel of selected) {
-      const eventForChannel = await this.applyRedaction(event, channel);
-      const result = await this.deliverWithRetry(eventForChannel, channel);
-      await this.store.appendDelivery(result);
-      deliveries.push(result);
-    }
-    return deliveries;
-  }
-  async testChannel(id, input = {}) {
-    const channel = await this.store.getChannel(id);
-    if (!channel)
-      throw new Error(`Channel not found: ${id}`);
-    const event = createEvent({
-      source: input.source ?? "hasna.events",
-      type: input.type ?? "events.test",
-      subject: input.subject ?? id,
-      severity: input.severity ?? "info",
-      data: input.data ?? { test: true },
-      message: input.message ?? "Hasna events test delivery",
-      dedupeKey: input.dedupeKey,
-      schemaVersion: input.schemaVersion,
-      metadata: input.metadata,
-      time: input.time,
-      id: input.id
-    });
-    const eventForChannel = await this.applyRedaction(event, channel);
-    const result = await this.deliverWithRetry(eventForChannel, channel);
-    await this.store.appendDelivery(result);
-    return result;
-  }
-  async replay(options = {}) {
-    const events = (await this.store.listEvents()).filter((event) => {
-      if (options.eventId && event.id !== options.eventId)
-        return false;
-      if (options.source && event.source !== options.source)
-        return false;
-      if (options.type && event.type !== options.type)
-        return false;
-      return true;
-    });
-    if (options.dryRun)
-      return { events, deliveries: [] };
-    const deliveries = [];
-    for (const event of events) {
-      deliveries.push(...await this.deliver(event));
-    }
-    return { events, deliveries };
-  }
-  async applyRedaction(event, channel) {
-    let next = redactPaths(event, channel.redact?.paths ?? [], channel.redact?.replacement ?? "[REDACTED]");
-    for (const redactor of this.redactors) {
-      next = await redactor(next, channel);
-    }
-    return next;
-  }
-  async deliverWithRetry(event, channel) {
-    const policy = normalizeRetryPolicy(channel.retry);
-    const attempts = [];
-    for (let index = 0;index < policy.maxAttempts; index += 1) {
-      const attempt = await dispatchChannel(event, channel, this.transportOptions);
-      attempt.attempt = index + 1;
-      if (attempt.status === "failed" && index + 1 < policy.maxAttempts) {
-        attempt.nextBackoffMs = Math.round(policy.backoffMs * policy.multiplier ** index);
-      }
-      attempts.push(attempt);
-      if (attempt.status !== "failed")
-        break;
-      if (attempt.nextBackoffMs)
-        await Bun.sleep(attempt.nextBackoffMs);
-    }
-    return createDeliveryResult(event, channel, attempts);
-  }
-}
-function redactPaths(event, paths, replacement = "[REDACTED]") {
-  if (paths.length === 0)
-    return event;
-  const copy = structuredClone(event);
-  for (const path of paths) {
-    setPath(copy, path, replacement);
-  }
-  return copy;
-}
-function sanitizeChannelForOutput(channel) {
-  const copy = structuredClone(channel);
-  if (copy.webhook?.secret)
-    copy.webhook.secret = "[REDACTED]";
-  if (copy.command?.env) {
-    copy.command.env = Object.fromEntries(Object.entries(copy.command.env).map(([key, value]) => [key, shouldRedactKey(key) ? "[REDACTED]" : value]));
-  }
-  return copy;
-}
-function sanitizeChannelsForOutput(channels) {
-  return channels.map(sanitizeChannelForOutput);
-}
-function redactSensitiveKeys(event, replacement = "[REDACTED]") {
-  return redactValue(event, replacement);
-}
-function shouldRedactKey(key) {
-  return /secret|token|password|api[_-]?key|authorization/i.test(key);
-}
-function redactValue(value, replacement) {
-  if (Array.isArray(value))
-    return value.map((item) => redactValue(item, replacement));
-  if (!value || typeof value !== "object")
-    return value;
-  return Object.fromEntries(Object.entries(value).map(([key, item]) => [
-    key,
-    shouldRedactKey(key) ? replacement : redactValue(item, replacement)
-  ]));
-}
-function setPath(input, path, replacement) {
-  const parts = path.split(".");
-  let cursor = input;
-  for (const part of parts.slice(0, -1)) {
-    const next = cursor[part];
-    if (!next || typeof next !== "object")
-      return;
-    cursor = next;
-  }
-  const last = parts.at(-1);
-  if (last && last in cursor)
-    cursor[last] = replacement;
-}
-function normalizeTime(value) {
-  if (!value)
-    return new Date().toISOString();
-  return value instanceof Date ? value.toISOString() : value;
-}
-function normalizeRetryPolicy(policy) {
-  return {
-    maxAttempts: Math.max(1, policy?.maxAttempts ?? 1),
-    backoffMs: Math.max(0, policy?.backoffMs ?? 250),
-    multiplier: Math.max(1, policy?.multiplier ?? 2)
-  };
-}
-function parseJsonObject(value, fallback) {
-  if (!value)
-    return fallback;
-  const parsed = JSON.parse(value);
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new Error("Expected a JSON object");
-  }
-  return parsed;
-}
-function parseHeaders(values) {
-  if (!values?.length)
-    return;
-  const headers = {};
-  for (const value of values) {
-    const separator = value.indexOf("=");
-    if (separator === -1)
-      throw new Error(`Invalid header, expected name=value: ${value}`);
-    headers[value.slice(0, separator)] = value.slice(separator + 1);
-  }
-  return headers;
-}
-function parseFilter(options) {
-  const filter2 = {};
-  if (options.source)
-    filter2.source = options.source;
-  if (options.type)
-    filter2.type = options.type;
-  if (options.subject)
-    filter2.subject = options.subject;
-  if (options.severity)
-    filter2.severity = options.severity;
-  return Object.keys(filter2).length > 0 ? [filter2] : undefined;
-}
-function createClient(options) {
-  if (options.createClient)
-    return options.createClient();
-  return new EventsClient({ store: new JsonEventsStore(options.dataDir) });
-}
-function print(value, json, text) {
-  if (json)
-    console.log(JSON.stringify(value, null, 2));
-  else
-    console.log(text);
-}
-function hasJsonOption(options) {
-  return Boolean(options?.json || options?.opts?.().json || options?.optsWithGlobals?.().json || options?.parent?.opts?.().json || options?.parent?.optsWithGlobals?.().json);
-}
-function wantsJson(actionOptions, command) {
-  return hasJsonOption(actionOptions) || hasJsonOption(command);
-}
-function registerWebhookCommands(program2, options) {
-  const webhooks = program2.command(options.webhooksCommandName ?? "webhooks").description("Manage Hasna event webhook subscriptions");
-  webhooks.command("add").description("Add or replace a webhook or command subscription").argument("<target>", "Webhook URL or command binary").requiredOption("--id <id>", "Subscription/channel identifier").option("--transport <kind>", "Transport kind: webhook or command", "webhook").option("--name <name>", "Display name").option("--type <pattern>", "Event type filter, e.g. todos.task.*").option("--source <pattern>", "Event source filter").option("--subject <pattern>", "Event subject filter").option("--severity <pattern>", "Event severity filter").option("--secret <secret>", "Webhook HMAC secret").option("--header <name=value...>", "Webhook header", collectValues, []).option("--arg <arg...>", "Command argument", collectValues, []).option("--timeout-ms <ms>", "Transport timeout in milliseconds", parseNumber).option("--retry-attempts <n>", "Maximum delivery attempts", parseNumber).option("--retry-backoff-ms <ms>", "Initial retry backoff in milliseconds", parseNumber).option("--redact <path...>", "Event field path to redact before delivery", collectValues, []).option("--disabled", "Create channel disabled", false).option("-j, --json", "Print JSON output", false).action(async (target, actionOptions, command) => {
-    const timestamp = new Date().toISOString();
-    const channel = {
-      id: actionOptions.id,
-      name: actionOptions.name,
-      enabled: !actionOptions.disabled,
-      transport: actionOptions.transport,
-      filters: parseFilter(actionOptions),
-      retry: actionOptions.retryAttempts || actionOptions.retryBackoffMs ? { maxAttempts: actionOptions.retryAttempts, backoffMs: actionOptions.retryBackoffMs } : undefined,
-      redact: actionOptions.redact?.length ? { paths: actionOptions.redact } : undefined,
-      createdAt: timestamp,
-      updatedAt: timestamp
-    };
-    if (actionOptions.transport === "webhook") {
-      channel.webhook = { url: target, secret: actionOptions.secret, headers: parseHeaders(actionOptions.header), timeoutMs: actionOptions.timeoutMs };
-    } else if (actionOptions.transport === "command") {
-      channel.command = { command: target, args: actionOptions.arg ?? [], timeoutMs: actionOptions.timeoutMs };
-    } else {
-      throw new Error(`Transport ${actionOptions.transport} is reserved for future use and cannot be added yet`);
-    }
-    const saved = await createClient(options).addChannel(channel);
-    print(sanitizeChannelForOutput(saved), wantsJson(actionOptions, command), `Added ${saved.transport} channel ${saved.id}`);
-  });
-  webhooks.command("list").description("List configured subscriptions").option("-j, --json", "Print JSON output", false).action(async (actionOptions, command) => {
-    const channels = await createClient(options).listChannels();
-    if (wantsJson(actionOptions, command)) {
-      console.log(JSON.stringify(sanitizeChannelsForOutput(channels), null, 2));
-      return;
-    }
-    if (!channels.length) {
-      console.log("No channels configured.");
-      return;
-    }
-    for (const channel of channels) {
-      console.log(`${channel.id}	${channel.enabled ? "enabled" : "disabled"}	${channel.transport}	${channel.webhook?.url ?? channel.command?.command ?? channel.transport}`);
-    }
-  });
-  webhooks.command("remove").description("Remove a subscription").argument("<id>", "Subscription/channel identifier").option("-j, --json", "Print JSON output", false).action(async (id, actionOptions, command) => {
-    const removed = await createClient(options).removeChannel(id);
-    print({ removed }, wantsJson(actionOptions, command), removed ? `Removed ${id}` : `Channel not found: ${id}`);
-  });
-  webhooks.command("test").description("Send a test event to one subscription").argument("<id>", "Subscription/channel identifier").option("--type <type>", "Event type", "events.test").option("--subject <subject>", "Event subject").option("--message <message>", "Event message", "Hasna events test delivery").option("--data <json>", "Event data JSON object").option("-j, --json", "Print JSON output", false).action(async (id, actionOptions, command) => {
-    const result = await createClient(options).testChannel(id, {
-      source: options.source,
-      type: actionOptions.type,
-      subject: actionOptions.subject ?? id,
-      message: actionOptions.message,
-      data: parseJsonObject(actionOptions.data, { test: true })
-    });
-    print(result, wantsJson(actionOptions, command), `${result.status}: ${result.channelId}`);
-  });
-  return webhooks;
-}
-function registerEventCommands(program2, options) {
-  const events = program2.command(options.eventsCommandName ?? "events").description("Emit, list, and replay Hasna events");
-  events.command("emit").description("Emit an event from this app").argument("<type>", "Event type").option("--source <source>", "Event source override").option("--subject <subject>", "Event subject").option("--severity <severity>", "Event severity", "info").option("--message <message>", "Event message").option("--dedupe-key <key>", "Dedupe key").option("--data <json>", "Event data JSON object").option("--metadata <json>", "Event metadata JSON object").option("--no-deliver", "Record without delivering").option("--no-dedupe", "Allow duplicate id/dedupeKey events").option("-j, --json", "Print JSON output", false).action(async (type, actionOptions, command) => {
-    const result = await createClient(options).emit({
-      source: actionOptions.source ?? options.source,
-      type,
-      subject: actionOptions.subject,
-      severity: actionOptions.severity,
-      message: actionOptions.message,
-      dedupeKey: actionOptions.dedupeKey,
-      data: parseJsonObject(actionOptions.data, {}),
-      metadata: parseJsonObject(actionOptions.metadata, {})
-    }, { deliver: actionOptions.deliver, dedupe: actionOptions.dedupe });
-    print(result, wantsJson(actionOptions, command), `${result.deduped ? "Deduped" : "Emitted"} ${result.event.id} to ${result.deliveries.length} channel(s)`);
-  });
-  events.command("list").description("List recorded events").option("--source <source>", "Filter by source").option("--type <type>", "Filter by type").option("--limit <n>", "Limit results", parseNumber).option("-j, --json", "Print JSON output", false).action(async (actionOptions, command) => {
-    let rows = await createClient(options).listEvents();
-    if (actionOptions.source)
-      rows = rows.filter((event) => event.source === actionOptions.source);
-    if (actionOptions.type)
-      rows = rows.filter((event) => event.type === actionOptions.type);
-    if (actionOptions.limit)
-      rows = rows.slice(-actionOptions.limit);
-    if (wantsJson(actionOptions, command)) {
-      console.log(JSON.stringify(rows, null, 2));
-      return;
-    }
-    if (!rows.length) {
-      console.log("No events recorded.");
-      return;
-    }
-    for (const event of rows)
-      console.log(`${event.time}	${event.id}	${event.source}	${event.type}	${event.severity}`);
-  });
-  events.command("replay").description("Replay recorded events").option("--id <id>", "Replay one event id").option("--source <source>", "Filter by source").option("--type <type>", "Filter by type").option("--dry-run", "Preview without delivery", false).option("-j, --json", "Print JSON output", false).action(async (actionOptions, command) => {
-    const result = await createClient(options).replay({
-      eventId: actionOptions.id,
-      source: actionOptions.source,
-      type: actionOptions.type,
-      dryRun: actionOptions.dryRun
-    });
-    print(result, wantsJson(actionOptions, command), `Replayed ${result.events.length} event(s), ${result.deliveries.length} delivery result(s)`);
-  });
-  return events;
-}
-function registerEventsCommands(program2, options) {
-  registerWebhookCommands(program2, options);
-  registerEventCommands(program2, options);
-}
-function parseNumber(value) {
-  const parsed = Number(value);
-  if (!Number.isFinite(parsed))
-    throw new Error(`Expected a number, got ${value}`);
-  return parsed;
-}
-function collectValues(value, previous) {
-  previous.push(value);
-  return previous;
-}
-
 // src/cli/index.tsx
 init_package();
 init_registry2();
+import { registerEventsCommands } from "@hasna/events/commander";
 
 // src/cli/components/App.tsx
 import { useState as useState7 } from "react";
@@ -43028,7 +42354,7 @@ init_installer();
 import { render } from "ink";
 import chalk2 from "chalk";
 import { readdirSync as readdirSync7, statSync as statSync5 } from "fs";
-import { join as join11, relative } from "path";
+import { join as join10, relative } from "path";
 import { createInterface } from "readline";
 import { jsxDEV as jsxDEV7 } from "react/jsx-dev-runtime";
 var isTTY = process.stdout.isTTY ?? false;
@@ -43043,7 +42369,7 @@ var PRESETS = {
 function listFilesRecursive(dir, base = dir) {
   const files = [];
   for (const entry of readdirSync7(dir)) {
-    const fullPath = join11(dir, entry);
+    const fullPath = join10(dir, entry);
     if (statSync5(fullPath).isDirectory()) {
       files.push(...listFilesRecursive(fullPath, base));
     } else {
@@ -43093,9 +42419,9 @@ function registerCommands(program2) {
     }
     if (options.dryRun) {
       const installed = getInstalledConnectors();
-      const connectorsDir = join11(process.cwd(), ".connectors");
-      const manifestPath = join11(connectorsDir, "manifest.json");
-      const indexPath = join11(connectorsDir, "index.ts");
+      const connectorsDir = join10(process.cwd(), ".connectors");
+      const manifestPath = join10(connectorsDir, "manifest.json");
+      const indexPath = join10(connectorsDir, "index.ts");
       const actions = [];
       for (const name of connectors18) {
         if (!/^[a-z0-9-]+$/.test(name)) {
@@ -43805,8 +43131,8 @@ init_auth();
 init_database();
 init_connector_resolver();
 import chalk4 from "chalk";
-import { existsSync as existsSync17, readFileSync as readFileSync10 } from "fs";
-import { join as join17 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync10 } from "fs";
+import { join as join16 } from "path";
 function registerCommands3(program2) {
   program2.command("status").option("--json", "Output as JSON", false).option("--limit <n>", "Limit rows per section in human output").option("--offset <n>", "Skip first N rows per section in human output").option("-v, --verbose", "Show all human rows", false).description("Show auth status of all configured connectors (project + global)").action((options) => {
     const parsedLimit = parseNonNegativeInt(options.limit, "--limit");
@@ -43828,8 +43154,8 @@ function registerCommands3(program2) {
       const auth = getAuthStatus(name);
       let profile = "default";
       for (const connectorConfigDir of getConnectorConfigReadDirs(name, configDir)) {
-        const currentProfileFile = join17(connectorConfigDir, "current_profile");
-        if (existsSync17(currentProfileFile)) {
+        const currentProfileFile = join16(connectorConfigDir, "current_profile");
+        if (existsSync16(currentProfileFile)) {
           try {
             profile = readFileSync10(currentProfileFile, "utf-8").trim() || "default";
           } catch {}
@@ -43869,7 +43195,7 @@ function registerCommands3(program2) {
       seen.add(name);
       allStatuses.push(buildStatusEntry(name, "project"));
     }
-    if (existsSync17(configDir)) {
+    if (existsSync16(configDir)) {
       try {
         for (const name of listConfiguredConnectorNames(configDir)) {
           if (name.startsWith("zzztest"))
@@ -44116,9 +43442,9 @@ init_registry2();
 init_auth();
 init_database();
 import chalk5 from "chalk";
-import { existsSync as existsSync18, readdirSync as readdirSync11, statSync as statSync8, readFileSync as readFileSync11, writeFileSync as writeFileSync8, mkdirSync as mkdirSync10 } from "fs";
-import { join as join18 } from "path";
-import { homedir as homedir5 } from "os";
+import { existsSync as existsSync17, readdirSync as readdirSync11, statSync as statSync8, readFileSync as readFileSync11, writeFileSync as writeFileSync8, mkdirSync as mkdirSync10 } from "fs";
+import { join as join17 } from "path";
+import { homedir as homedir4 } from "os";
 import { createInterface as createInterface2 } from "readline";
 init_connector_resolver();
 var SENSITIVE_FIELDS = new Set([
@@ -44143,7 +43469,7 @@ var SENSITIVE_FIELDS = new Set([
   "private_key",
   "privatekey"
 ]);
-function redactValue2(value) {
+function redactValue(value) {
   if (value.length <= 8)
     return "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022";
   return value.slice(0, 4) + "\u2022\u2022\u2022\u2022" + value.slice(-4);
@@ -44159,7 +43485,7 @@ function redactSecrets(obj) {
     const result = {};
     for (const [key, value] of Object.entries(obj)) {
       if (SENSITIVE_FIELDS.has(key.toLowerCase()) && typeof value === "string") {
-        result[key] = redactValue2(value);
+        result[key] = redactValue(value);
       } else if (typeof value === "object" && value !== null) {
         result[key] = redactSecrets(value);
       } else {
@@ -44178,10 +43504,10 @@ function getOAuthTokenState(name) {
   if (!tokens.expiresAt) {
     return { hasTokens: true, expired: false };
   }
-  const now4 = Date.now();
-  const isExpired = now4 >= tokens.expiresAt - 60000;
+  const now3 = Date.now();
+  const isExpired = now3 >= tokens.expiresAt - 60000;
   const expiresIn = isExpired ? undefined : (() => {
-    const ms = tokens.expiresAt - now4;
+    const ms = tokens.expiresAt - now3;
     const mins = Math.floor(ms / 60000);
     if (mins < 1)
       return "less than a minute";
@@ -44193,8 +43519,8 @@ function getOAuthTokenState(name) {
 }
 function getCurrentOAuthProfile(name, connectorsHome = getConnectorsHome()) {
   for (const dir of getConnectorConfigReadDirs(name, connectorsHome)) {
-    const currentProfilePath = join18(dir, "current_profile");
-    if (!existsSync18(currentProfilePath))
+    const currentProfilePath = join17(dir, "current_profile");
+    if (!existsSync17(currentProfilePath))
       continue;
     const profile = readFileSync11(currentProfilePath, "utf8").trim();
     if (profile)
@@ -44203,11 +43529,11 @@ function getCurrentOAuthProfile(name, connectorsHome = getConnectorsHome()) {
   return "default";
 }
 function getOAuthTokenPathsForProfile(name, connectorsHome = getConnectorsHome(), profile = getCurrentOAuthProfile(name, connectorsHome)) {
-  return getConnectorConfigReadDirs(name, connectorsHome).map((dir) => join18(dir, "profiles", profile, "tokens.json"));
+  return getConnectorConfigReadDirs(name, connectorsHome).map((dir) => join17(dir, "profiles", profile, "tokens.json"));
 }
 function hasOAuthTokenFileUpdatedSince(tokenPaths, sinceMs) {
   return tokenPaths.some((tokensPath) => {
-    if (!existsSync18(tokensPath))
+    if (!existsSync17(tokensPath))
       return false;
     return statSync8(tokensPath).mtimeMs >= sinceMs;
   });
@@ -44335,9 +43661,9 @@ ${meta.displayName} \u2014 Auth Configuration
       try {
         if (!options.browser) {
           console.log(chalk5.dim(`Starting OAuth server on port ${port}...`));
-          const { spawn: spawn5 } = await import("child_process");
+          const { spawn: spawn4 } = await import("child_process");
           const scriptPath = process.argv[1];
-          const serverProc = spawn5(process.execPath, [scriptPath, "serve", "--port", String(port)], {
+          const serverProc = spawn4(process.execPath, [scriptPath, "serve", "--port", String(port)], {
             detached: true,
             stdio: "ignore"
           });
@@ -44511,9 +43837,9 @@ Open this URL to authenticate:
     let configuredCount = 0;
     const configuredNames = [];
     try {
-      if (existsSync18(connectorsHome)) {
+      if (existsSync17(connectorsHome)) {
         for (const name of listConfiguredConnectorNames(connectorsHome)) {
-          const hasProfiles = getConnectorConfigReadDirs(name, connectorsHome).some((dir) => existsSync18(join18(dir, "profiles")));
+          const hasProfiles = getConnectorConfigReadDirs(name, connectorsHome).some((dir) => existsSync17(join17(dir, "profiles")));
           if (hasProfiles) {
             configuredCount++;
             configuredNames.push(name);
@@ -44565,13 +43891,13 @@ Open this URL to authenticate:
   program2.command("export").option("-o, --output <file>", "Write to file instead of stdout").option("--include-secrets", "Include secrets in plaintext (dangerous \u2014 use only for backup/restore)").description("Export all connector credentials as JSON backup").action((options) => {
     const connectDir = getConnectorsHome();
     const result = {};
-    if (existsSync18(connectDir)) {
+    if (existsSync17(connectDir)) {
       for (const connectorName of listConfiguredConnectorNames(connectDir)) {
         const connectorDirs = [...getConnectorConfigReadDirs(connectorName, connectDir)].reverse();
         let credentials = undefined;
         for (const connectorDir of connectorDirs) {
-          const credentialsPath = join18(connectorDir, "credentials.json");
-          if (existsSync18(credentialsPath)) {
+          const credentialsPath = join17(connectorDir, "credentials.json");
+          if (existsSync17(credentialsPath)) {
             try {
               credentials = JSON.parse(readFileSync11(credentialsPath, "utf-8"));
             } catch {}
@@ -44579,24 +43905,24 @@ Open this URL to authenticate:
         }
         const profiles = {};
         for (const connectorDir of connectorDirs) {
-          const profilesDir = join18(connectorDir, "profiles");
-          if (existsSync18(profilesDir)) {
+          const profilesDir = join17(connectorDir, "profiles");
+          if (existsSync17(profilesDir)) {
             for (const pEntry of readdirSync11(profilesDir)) {
-              const pPath = join18(profilesDir, pEntry);
+              const pPath = join17(profilesDir, pEntry);
               if (statSync8(pPath).isFile() && pEntry.endsWith(".json")) {
                 try {
                   profiles[pEntry.replace(/\.json$/, "")] = JSON.parse(readFileSync11(pPath, "utf-8"));
                 } catch {}
               } else if (statSync8(pPath).isDirectory()) {
-                const configPath = join18(pPath, "config.json");
-                const tokensPath = join18(pPath, "tokens.json");
+                const configPath = join17(pPath, "config.json");
+                const tokensPath = join17(pPath, "tokens.json");
                 let merged = {};
-                if (existsSync18(configPath)) {
+                if (existsSync17(configPath)) {
                   try {
                     merged = { ...merged, ...JSON.parse(readFileSync11(configPath, "utf-8")) };
                   } catch {}
                 }
-                if (existsSync18(tokensPath)) {
+                if (existsSync17(tokensPath)) {
                   try {
                     merged = { ...merged, ...JSON.parse(readFileSync11(tokensPath, "utf-8")) };
                   } catch {}
@@ -44634,7 +43960,7 @@ Open this URL to authenticate:
         chunks.push(chunk.toString());
       raw = chunks.join("");
     } else {
-      if (!existsSync18(file)) {
+      if (!existsSync17(file)) {
         if (options.json) {
           console.log(JSON.stringify({ error: `File not found: ${file}` }));
         } else {
@@ -44674,17 +44000,17 @@ Open this URL to authenticate:
       const connectorDir = getConnectorConfigDir(connectorName, connectDir);
       if (connData.credentials && typeof connData.credentials === "object") {
         mkdirSync10(connectorDir, { recursive: true });
-        writeFileSync8(join18(connectorDir, "credentials.json"), JSON.stringify(connData.credentials, null, 2));
+        writeFileSync8(join17(connectorDir, "credentials.json"), JSON.stringify(connData.credentials, null, 2));
         imported++;
       }
       if (!connData.profiles || typeof connData.profiles !== "object")
         continue;
-      const profilesDir = join18(connectorDir, "profiles");
+      const profilesDir = join17(connectorDir, "profiles");
       for (const [profileName, config2] of Object.entries(connData.profiles)) {
         if (!config2 || typeof config2 !== "object")
           continue;
         mkdirSync10(profilesDir, { recursive: true });
-        writeFileSync8(join18(profilesDir, `${profileName}.json`), JSON.stringify(config2, null, 2));
+        writeFileSync8(join17(profilesDir, `${profileName}.json`), JSON.stringify(config2, null, 2));
         imported++;
       }
     }
@@ -44695,9 +44021,9 @@ Open this URL to authenticate:
     }
   });
   program2.command("auth-import").option("--json", "Output as JSON", false).option("-d, --dry-run", "Preview what would be imported without copying", false).option("--force", "Overwrite existing files in ~/.hasna/connectors/", false).description("Migrate auth tokens from ~/.connect/ to ~/.hasna/connectors/").action((options) => {
-    const oldBase = join18(homedir5(), ".connect");
+    const oldBase = join17(homedir4(), ".connect");
     const newBase = getConnectorsHome();
-    if (!existsSync18(oldBase)) {
+    if (!existsSync17(oldBase)) {
       if (options.json) {
         console.log(JSON.stringify({ imported: [], skipped: [], error: null, message: "No ~/.connect/ directory found" }));
       } else {
@@ -44709,7 +44035,7 @@ Open this URL to authenticate:
       if (!name.startsWith("connect-"))
         return false;
       try {
-        return statSync8(join18(oldBase, name)).isDirectory();
+        return statSync8(join17(oldBase, name)).isDirectory();
       } catch {
         return false;
       }
@@ -44725,7 +44051,7 @@ Open this URL to authenticate:
     const imported = [];
     const skipped = [];
     for (const dirName of entries) {
-      const oldDir = join18(oldBase, dirName);
+      const oldDir = join17(oldBase, dirName);
       const connectorName = dirName.replace(/^connect-/, "");
       const newDir = getConnectorConfigDir(connectorName, newBase);
       const allFiles = listFilesRecursive(oldDir);
@@ -44737,14 +44063,14 @@ Open this URL to authenticate:
       const copiedFiles = [];
       const skippedFiles = [];
       for (const relFile of authFiles) {
-        const srcPath = join18(oldDir, relFile);
-        const destPath = join18(newDir, relFile);
-        if (existsSync18(destPath) && !options.force) {
+        const srcPath = join17(oldDir, relFile);
+        const destPath = join17(newDir, relFile);
+        if (existsSync17(destPath) && !options.force) {
           skippedFiles.push(relFile);
           continue;
         }
         if (!options.dryRun) {
-          const parentDir = join18(destPath, "..");
+          const parentDir = join17(destPath, "..");
           mkdirSync10(parentDir, { recursive: true });
           const content = readFileSync11(srcPath);
           writeFileSync8(destPath, content);
@@ -44813,8 +44139,8 @@ init_installer();
 init_auth();
 init_database();
 import chalk6 from "chalk";
-import { existsSync as existsSync19, readFileSync as readFileSync12, writeFileSync as writeFileSync9 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync12, writeFileSync as writeFileSync9 } from "fs";
+import { join as join18 } from "path";
 
 // src/lib/test-endpoints.ts
 var TEST_ENDPOINTS = {
@@ -45299,8 +44625,8 @@ Available presets:
         unconfigured++;
       let profile = "default";
       for (const connectorConfigDir of getConnectorConfigReadDirs(name, configDir)) {
-        const currentProfileFile = join19(connectorConfigDir, "current_profile");
-        if (existsSync19(currentProfileFile)) {
+        const currentProfileFile = join18(connectorConfigDir, "current_profile");
+        if (existsSync18(currentProfileFile)) {
           try {
             profile = readFileSync12(currentProfileFile, "utf-8").trim() || "default";
           } catch {}
@@ -45309,7 +44635,7 @@ Available presets:
       }
       connectorDetails.push({ name, configured: auth.configured, authType: auth.type, profile, source: "project" });
     }
-    if (existsSync19(configDir)) {
+    if (existsSync18(configDir)) {
       try {
         for (const name of listConfiguredConnectorNames(configDir)) {
           if (seen.has(name))
@@ -45321,8 +44647,8 @@ Available presets:
           configured++;
           let profile = "default";
           for (const connectorConfigDir of getConnectorConfigReadDirs(name, configDir)) {
-            const currentProfileFile = join19(connectorConfigDir, "current_profile");
-            if (existsSync19(currentProfileFile)) {
+            const currentProfileFile = join18(connectorConfigDir, "current_profile");
+            if (existsSync18(currentProfileFile)) {
               try {
                 profile = readFileSync12(currentProfileFile, "utf-8").trim() || "default";
               } catch {}
@@ -45337,7 +44663,7 @@ Available presets:
       console.log(JSON.stringify({
         version: version2,
         configDir,
-        configDirExists: existsSync19(configDir),
+        configDirExists: existsSync18(configDir),
         installed: installed.length,
         configured,
         unconfigured,
@@ -45349,7 +44675,7 @@ Available presets:
 Connectors Setup
 `));
     console.log(`  Version:      ${chalk6.cyan(version2)}`);
-    console.log(`  Config:       ${configDir}${existsSync19(configDir) ? "" : chalk6.dim(" (not created yet)")}`);
+    console.log(`  Config:       ${configDir}${existsSync18(configDir) ? "" : chalk6.dim(" (not created yet)")}`);
     console.log(`  Installed:    ${installed.length} connector${installed.length !== 1 ? "s" : ""}`);
     console.log(`  Configured:   ${chalk6.green(String(configured))} ready, ${unconfigured > 0 ? chalk6.red(String(unconfigured)) : chalk6.dim("0")} need auth`);
     const projectConnectors = connectorDetails.filter((c) => c.source === "project");
@@ -45457,15 +44783,15 @@ Testing connector credentials...
         const connectorConfigDirs = getConnectorConfigReadDirs(name);
         let currentProfile = "default";
         for (const connectorConfigDir of connectorConfigDirs) {
-          const currentProfileFile = join19(connectorConfigDir, "current_profile");
-          if (existsSync19(currentProfileFile)) {
+          const currentProfileFile = join18(connectorConfigDir, "current_profile");
+          if (existsSync18(currentProfileFile)) {
             try {
               currentProfile = readFileSync12(currentProfileFile, "utf-8").trim() || "default";
             } catch {}
             break;
           }
         }
-        const tokensFile = connectorConfigDirs.map((dir) => join19(dir, "profiles", currentProfile, "tokens.json")).find((path) => existsSync19(path));
+        const tokensFile = connectorConfigDirs.map((dir) => join18(dir, "profiles", currentProfile, "tokens.json")).find((path) => existsSync18(path));
         if (tokensFile) {
           try {
             const tokens = JSON.parse(readFileSync12(tokensFile, "utf-8"));
@@ -45487,8 +44813,8 @@ Testing connector credentials...
         }
         if (!apiKey) {
           for (const connectorConfigDir of connectorConfigDirs) {
-            const profileFile = join19(connectorConfigDir, "profiles", `${currentProfile}.json`);
-            if (existsSync19(profileFile)) {
+            const profileFile = join18(connectorConfigDir, "profiles", `${currentProfile}.json`);
+            if (existsSync18(profileFile)) {
               try {
                 const config2 = JSON.parse(readFileSync12(profileFile, "utf-8"));
                 apiKey = Object.values(config2).find((v) => typeof v === "string" && v.length > 0);
@@ -45500,8 +44826,8 @@ Testing connector credentials...
         }
         if (!apiKey) {
           for (const connectorConfigDir of connectorConfigDirs) {
-            const profileDirConfig = join19(connectorConfigDir, "profiles", currentProfile, "config.json");
-            if (existsSync19(profileDirConfig)) {
+            const profileDirConfig = join18(connectorConfigDir, "profiles", currentProfile, "config.json");
+            if (existsSync18(profileDirConfig)) {
               try {
                 const config2 = JSON.parse(readFileSync12(profileDirConfig, "utf-8"));
                 apiKey = Object.values(config2).find((v) => typeof v === "string" && v.length > 0);
@@ -45764,10 +45090,10 @@ Setting up ${meta.displayName}...
   ${chalk7.bold("Open this URL to authenticate:")}`);
             console.log(`  ${chalk7.cyan(oauthUrl)}
 `);
-            const { spawn: spawn5 } = await import("child_process");
+            const { spawn: spawn4 } = await import("child_process");
             const { getConnectorsHome: getConnectorsHome2 } = await Promise.resolve().then(() => (init_database(), exports_database));
             const scriptPath = process.argv[1];
-            const serverProc = spawn5(process.execPath, [scriptPath, "serve", "--port", String(port)], {
+            const serverProc = spawn4(process.execPath, [scriptPath, "serve", "--port", String(port)], {
               detached: true,
               stdio: "ignore"
             });