@hasna/connectors 1.3.24 → 1.3.25

package/bin/serve.js

@@ -10009,7 +10009,7 @@ var init_promotions = __esm(() => {
 });
 
 // src/server/serve.ts
-import { existsSync as existsSync15, readdirSync as readdirSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync6, mkdirSync as mkdirSync10 } from "fs";
+import { existsSync as existsSync16, readdirSync as readdirSync10, readFileSync as readFileSync8, writeFileSync as writeFileSync7, mkdirSync as mkdirSync11 } from "fs";
 
 // src/db/agents.ts
 init_database();
@@ -10188,7 +10188,8 @@ init_scheduler();
 
 // src/lib/workflow-runner.ts
 init_strip();
-import { spawn as spawn2 } from "child_process";
+import { spawn as nodeSpawn } from "child_process";
+var spawnImpl = nodeSpawn;
 async function runStep(step, previousOutput) {
   return new Promise((resolve) => {
     const args = [...step.args ?? []];
@@ -10196,7 +10197,7 @@ async function runStep(step, previousOutput) {
       args.push("--input", previousOutput.trim().slice(0, 4096));
     }
     const cmdArgs = ["run", step.connector, step.command, ...args, "--format", "json"];
-    const proc = spawn2("connectors", cmdArgs, { shell: false });
+    const proc = spawnImpl("connectors", cmdArgs, { shell: false });
     let output = "";
     proc.stdout.on("data", (d) => {
       output += d.toString();
@@ -10239,12 +10240,12 @@ async function runWorkflow(workflow) {
 
 // src/server/serve.ts
 init_database();
-import { join as join16, dirname as dirname8, extname, basename } from "path";
+import { join as join17, dirname as dirname8, extname, basename as basename2 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 
 // src/lib/registry.ts
-import { existsSync as existsSync10, readFileSync as readFileSync4 } from "fs";
-import { join as join11, dirname as dirname5 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync5 } from "fs";
+import { join as join12, dirname as dirname5 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/core/errors.ts
@@ -10259,7 +10260,7 @@ class ConnectorDefinitionError extends Error {
 
 // src/core/connector.ts
 var CONNECTOR_NAME_RE = /^[a-z0-9-]+$/;
-var OPERATION_NAME_RE = /^[a-z0-9:_-]+$/;
+var OPERATION_NAME_RE = /^[a-z0-9:._-]+$/;
 function defineConnector(definition) {
   const { meta, auth, operations } = definition;
   if (!CONNECTOR_NAME_RE.test(meta.name)) {
@@ -15157,10 +15158,300 @@ var githubConnector = defineConnector({
     }
   }
 });
+
+// src/core/connectors/googledrive.ts
+import { existsSync as existsSync8, mkdirSync as mkdirSync6, readFileSync as readFileSync3, readdirSync as readdirSync5, writeFileSync as writeFileSync3 } from "fs";
+import { homedir as homedir8 } from "os";
+import { basename, join as join9 } from "path";
+var DRIVE_API_BASE = "https://www.googleapis.com/drive/v3";
+var TOKEN_URL = "https://oauth2.googleapis.com/token";
+var REFRESH_BUFFER_MS = 5 * 60 * 1000;
+var DEFAULT_FILE_FIELDS = [
+  "id",
+  "name",
+  "mimeType",
+  "parents",
+  "version",
+  "md5Checksum",
+  "size",
+  "modifiedTime",
+  "createdTime",
+  "trashed",
+  "webViewLink",
+  "webContentLink"
+].join(",");
+var DEFAULT_EXPORT_FORMATS = {
+  document: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  spreadsheet: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  presentation: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  drawing: "image/png"
+};
+var EXPORT_EXTENSIONS = {
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document": ".docx",
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": ".xlsx",
+  "application/vnd.openxmlformats-officedocument.presentationml.presentation": ".pptx",
+  "application/pdf": ".pdf",
+  "text/plain": ".txt",
+  "text/csv": ".csv",
+  "image/png": ".png",
+  "image/jpeg": ".jpg",
+  "image/svg+xml": ".svg"
+};
+var listFilesSchema = exports_external2.object({
+  pageSize: exports_external2.coerce.number().int().positive().max(1000).optional(),
+  pageToken: exports_external2.string().optional(),
+  q: exports_external2.string().optional(),
+  fields: exports_external2.string().optional(),
+  orderBy: exports_external2.string().optional(),
+  corpora: exports_external2.enum(["user", "drive", "allDrives"]).optional(),
+  driveId: exports_external2.string().optional(),
+  supportsAllDrives: exports_external2.boolean().optional(),
+  includeItemsFromAllDrives: exports_external2.boolean().optional()
+});
+var listDrivesSchema = exports_external2.object({
+  pageSize: exports_external2.coerce.number().int().positive().max(100).optional(),
+  pageToken: exports_external2.string().optional(),
+  q: exports_external2.string().optional()
+});
+var fileIdSchema = exports_external2.object({
+  fileId: exports_external2.string(),
+  fields: exports_external2.string().optional()
+});
+var downloadSchema = exports_external2.object({
+  fileId: exports_external2.string(),
+  file: exports_external2.object({
+    id: exports_external2.string(),
+    name: exports_external2.string(),
+    mimeType: exports_external2.string()
+  }).optional(),
+  exportMimeType: exports_external2.string().optional()
+});
+var googleDriveConnector = defineConnector({
+  meta: {
+    name: "googledrive",
+    displayName: "Google Drive",
+    description: "Profile-aware Google Drive discovery and file download operations.",
+    category: "storage",
+    tags: ["google", "drive", "files", "storage"]
+  },
+  auth: {
+    type: "oauth2",
+    supportsProfiles: true,
+    fields: [
+      { key: "clientId", env: "GOOGLE_CLIENT_ID", label: "OAuth client ID" },
+      { key: "clientSecret", env: "GOOGLE_CLIENT_SECRET", label: "OAuth client secret", secret: true }
+    ]
+  },
+  createContext: ({ profile }) => ({ profile: profile || "default" }),
+  operations: {
+    "profiles.list": {
+      summary: "List configured Google Drive profiles.",
+      execute: () => ({ profiles: listProfiles() })
+    },
+    "files.list": {
+      summary: "List Google Drive files.",
+      inputSchema: listFilesSchema,
+      execute: async ({ context }, input) => requestJson(context.profile, "/files", {
+        pageSize: input.pageSize ?? 1000,
+        pageToken: input.pageToken,
+        q: input.q,
+        fields: input.fields ?? `nextPageToken,files(${DEFAULT_FILE_FIELDS})`,
+        orderBy: input.orderBy ?? "modifiedTime desc",
+        corpora: input.corpora,
+        driveId: input.driveId,
+        supportsAllDrives: input.supportsAllDrives ?? true,
+        includeItemsFromAllDrives: input.includeItemsFromAllDrives ?? false
+      })
+    },
+    "files.get": {
+      summary: "Get Google Drive file metadata.",
+      inputSchema: fileIdSchema,
+      execute: async ({ context }, input) => requestJson(context.profile, `/files/${encodeURIComponent(input.fileId)}`, {
+        fields: input.fields ?? DEFAULT_FILE_FIELDS,
+        supportsAllDrives: true
+      })
+    },
+    "files.download": {
+      summary: "Download or export a Google Drive file as base64 content.",
+      inputSchema: downloadSchema,
+      execute: async ({ context }, input) => {
+        const file = input.file ?? await requestJson(context.profile, `/files/${encodeURIComponent(input.fileId)}`, { fields: DEFAULT_FILE_FIELDS, supportsAllDrives: true });
+        const exportMimeType = file.mimeType.startsWith("application/vnd.google-apps.") ? input.exportMimeType ?? defaultExportMimeType(file.mimeType) : undefined;
+        const data = await requestBinary(context.profile, exportMimeType ? `/files/${encodeURIComponent(file.id)}/export` : `/files/${encodeURIComponent(file.id)}`, exportMimeType ? { mimeType: exportMimeType, supportsAllDrives: true } : { alt: "media", supportsAllDrives: true });
+        const mimeType = exportMimeType ?? file.mimeType ?? "application/octet-stream";
+        return {
+          dataBase64: Buffer.from(data).toString("base64"),
+          filename: exportMimeType ? `${file.name}${extensionForMimeType(exportMimeType)}` : file.name,
+          mimeType
+        };
+      }
+    },
+    "drives.list": {
+      summary: "List Google shared drives.",
+      inputSchema: listDrivesSchema,
+      execute: async ({ context }, input) => requestJson(context.profile, "/drives", {
+        pageSize: input.pageSize ?? 100,
+        pageToken: input.pageToken,
+        q: input.q
+      })
+    }
+  }
+});
+async function requestJson(profile, path, params) {
+  const response = await request(profile, path, params);
+  const text = await response.text();
+  return text ? JSON.parse(text) : {};
+}
+async function requestBinary(profile, path, params) {
+  return (await request(profile, path, params)).arrayBuffer();
+}
+async function request(profile, path, params) {
+  const token = await getValidAccessToken(profile);
+  const url = new URL(`${DRIVE_API_BASE}${path}`);
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== undefined && value !== null && value !== "")
+      url.searchParams.set(key, String(value));
+  }
+  const response = await fetch(url, { headers: { Authorization: `Bearer ${token}`, Accept: "application/json" } });
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    throw new Error(`Google Drive request failed (${response.status}): ${extractGoogleError(body) || response.statusText}`);
+  }
+  return response;
+}
+async function getValidAccessToken(profile) {
+  if (process.env.GOOGLE_ACCESS_TOKEN)
+    return process.env.GOOGLE_ACCESS_TOKEN;
+  const tokens = loadTokens(profile);
+  if (!tokens?.accessToken && !tokens?.refreshToken) {
+    throw new Error(`Google Drive profile "${profile}" is not authenticated. Run: connectors auth googledrive`);
+  }
+  if (tokens.accessToken && (!tokens.expiresAt || Date.now() < tokens.expiresAt - REFRESH_BUFFER_MS))
+    return tokens.accessToken;
+  if (!tokens.refreshToken)
+    return tokens.accessToken ?? "";
+  return (await refreshAccessToken(profile, tokens)).accessToken ?? "";
+}
+async function refreshAccessToken(profile, currentTokens) {
+  const credentials = loadCredentials(profile);
+  if (!credentials.clientId || !credentials.clientSecret)
+    throw new Error("Google Drive OAuth credentials are not configured. Run: connectors auth googledrive");
+  if (!currentTokens.refreshToken)
+    throw new Error(`Google Drive profile "${profile}" has no refresh token. Run: connectors auth googledrive`);
+  const response = await fetch(TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      client_id: credentials.clientId,
+      client_secret: credentials.clientSecret,
+      refresh_token: currentTokens.refreshToken,
+      grant_type: "refresh_token"
+    })
+  });
+  const data = await response.json().catch(() => ({}));
+  if (!response.ok || !data.access_token)
+    throw new Error(`Google Drive token refresh failed: ${data.error_description || data.error || response.statusText}`);
+  const tokens = {
+    accessToken: data.access_token,
+    refreshToken: currentTokens.refreshToken,
+    expiresAt: Date.now() + (data.expires_in ?? 3600) * 1000,
+    tokenType: data.token_type ?? currentTokens.tokenType,
+    scope: data.scope ?? currentTokens.scope
+  };
+  saveTokens(profile, tokens);
+  return tokens;
+}
+function listProfiles() {
+  const profiles = new Set;
+  for (const baseDir of configDirs()) {
+    const profilesDir = join9(baseDir, "profiles");
+    if (!existsSync8(profilesDir))
+      continue;
+    for (const entry of readdirSync5(profilesDir, { withFileTypes: true })) {
+      if (entry.isDirectory())
+        profiles.add(entry.name);
+      if (entry.isFile() && entry.name.endsWith(".json"))
+        profiles.add(basename(entry.name, ".json"));
+    }
+  }
+  return Array.from(profiles).sort((a, b) => a.localeCompare(b));
+}
+function loadCredentials(profile) {
+  const envClientId = process.env.GOOGLE_CLIENT_ID;
+  const envClientSecret = process.env.GOOGLE_CLIENT_SECRET;
+  if (envClientId && envClientSecret)
+    return { clientId: envClientId, clientSecret: envClientSecret };
+  for (const baseDir of configDirs()) {
+    const credentials = {
+      ...readJson(join9(baseDir, "credentials.json")),
+      ...readJson(join9(baseDir, "profiles", profile, "config.json"))
+    };
+    if (credentials.clientId || credentials.clientSecret)
+      return credentials;
+  }
+  return {};
+}
+function loadTokens(profile) {
+  for (const baseDir of configDirs()) {
+    const fromProfile = readJson(join9(baseDir, "profiles", profile, "tokens.json"));
+    if (fromProfile)
+      return fromProfile;
+    const flat = readJson(join9(baseDir, "profiles", `${profile}.json`));
+    if (flat)
+      return flat.tokens ?? (flat.accessToken || flat.refreshToken ? flat : null);
+  }
+  return null;
+}
+function saveTokens(profile, tokens) {
+  const baseDir = configDirs().find((dir) => existsSync8(dir)) ?? configDirs()[0];
+  const profileDir = join9(baseDir, "profiles", profile);
+  mkdirSync6(profileDir, { recursive: true });
+  writeFileSync3(join9(profileDir, "tokens.json"), JSON.stringify(tokens, null, 2), { mode: 384 });
+}
+function configDirs() {
+  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 ?? join9(homedir8(), ".hasna", "connectors");
+  return [join9(baseDir, "connect-googledrive"), join9(baseDir, "googledrive")];
+}
+function readJson(path) {
+  if (!existsSync8(path))
+    return null;
+  try {
+    return JSON.parse(readFileSync3(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function defaultExportMimeType(googleMimeType) {
+  if (googleMimeType.endsWith(".document"))
+    return DEFAULT_EXPORT_FORMATS.document;
+  if (googleMimeType.endsWith(".spreadsheet"))
+    return DEFAULT_EXPORT_FORMATS.spreadsheet;
+  if (googleMimeType.endsWith(".presentation"))
+    return DEFAULT_EXPORT_FORMATS.presentation;
+  if (googleMimeType.endsWith(".drawing"))
+    return DEFAULT_EXPORT_FORMATS.drawing;
+  throw new Error(`Cannot export Google Workspace file type: ${googleMimeType}`);
+}
+function extensionForMimeType(mimeType) {
+  return EXPORT_EXTENSIONS[mimeType] ?? "";
+}
+function extractGoogleError(body) {
+  if (!body)
+    return "";
+  try {
+    const parsed = JSON.parse(body);
+    return parsed.error?.message ?? body;
+  } catch {
+    return body;
+  }
+}
 // package.json
 var package_default = {
   name: "@hasna/connectors",
-  version: "1.3.24",
+  version: "1.3.25",
   description: "Open source connector library - Install API connectors with a single command",
   type: "module",
   bin: {
@@ -15248,15 +15539,15 @@ var package_default = {
 
 // src/core/connectors/imessage.ts
 import {
-  existsSync as existsSync8,
-  mkdirSync as mkdirSync6,
-  readFileSync as readFileSync3,
-  readdirSync as readdirSync5,
+  existsSync as existsSync9,
+  mkdirSync as mkdirSync7,
+  readFileSync as readFileSync4,
+  readdirSync as readdirSync6,
   rmSync,
   statSync as statSync2,
-  writeFileSync as writeFileSync3
+  writeFileSync as writeFileSync4
 } from "fs";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 init_database();
 var CONNECTOR_DIRNAME = "connect-imessage";
 var COMMAND_SPECS = [
@@ -15418,36 +15709,36 @@ var messageReplyInputSchema = exports_external2.object({
   deviceId: exports_external2.string().optional()
 });
 function getConfigDir2() {
-  return join9(getConnectorsHome(), CONNECTOR_DIRNAME);
+  return join10(getConnectorsHome(), CONNECTOR_DIRNAME);
 }
 function getProfilesDir() {
-  return join9(getConfigDir2(), "profiles");
+  return join10(getConfigDir2(), "profiles");
 }
 function getCurrentProfile() {
-  const currentProfileFile = join9(getConfigDir2(), "current_profile");
-  if (!existsSync8(currentProfileFile)) {
+  const currentProfileFile = join10(getConfigDir2(), "current_profile");
+  if (!existsSync9(currentProfileFile)) {
     return "default";
   }
   try {
-    return readFileSync3(currentProfileFile, "utf-8").trim() || "default";
+    return readFileSync4(currentProfileFile, "utf-8").trim() || "default";
   } catch {
     return "default";
   }
 }
 function setCurrentProfile(profile) {
   const configDir = getConfigDir2();
-  mkdirSync6(configDir, { recursive: true });
-  writeFileSync3(join9(configDir, "current_profile"), profile);
+  mkdirSync7(configDir, { recursive: true });
+  writeFileSync4(join10(configDir, "current_profile"), profile);
 }
 function getFlatProfilePath(profile) {
-  return join9(getProfilesDir(), `${profile}.json`);
+  return join10(getProfilesDir(), `${profile}.json`);
 }
 function getDirectoryProfilePath(profile) {
-  return join9(getProfilesDir(), profile, "config.json");
+  return join10(getProfilesDir(), profile, "config.json");
 }
 function loadJsonFile(path) {
   try {
-    return JSON.parse(readFileSync3(path, "utf-8"));
+    return JSON.parse(readFileSync4(path, "utf-8"));
   } catch {
     return {};
   }
@@ -15463,8 +15754,8 @@ function sanitizeProfileConfig(config) {
   };
 }
 function loadProfile(profile = getCurrentProfile()) {
-  const flatConfig = existsSync8(getFlatProfilePath(profile)) ? loadJsonFile(getFlatProfilePath(profile)) : {};
-  const directoryConfig = existsSync8(getDirectoryProfilePath(profile)) ? loadJsonFile(getDirectoryProfilePath(profile)) : {};
+  const flatConfig = existsSync9(getFlatProfilePath(profile)) ? loadJsonFile(getFlatProfilePath(profile)) : {};
+  const directoryConfig = existsSync9(getDirectoryProfilePath(profile)) ? loadJsonFile(getDirectoryProfilePath(profile)) : {};
   return sanitizeProfileConfig({
     ...flatConfig,
     ...directoryConfig
@@ -15472,25 +15763,25 @@ function loadProfile(profile = getCurrentProfile()) {
 }
 function writeProfile(profile, config) {
   const profilesDir = getProfilesDir();
-  mkdirSync6(profilesDir, { recursive: true });
-  writeFileSync3(getFlatProfilePath(profile), JSON.stringify(config, null, 2) + `
+  mkdirSync7(profilesDir, { recursive: true });
+  writeFileSync4(getFlatProfilePath(profile), JSON.stringify(config, null, 2) + `
 `);
 }
 function profileExists(profile) {
   if (profile === "default") {
     return true;
   }
-  return existsSync8(getFlatProfilePath(profile)) || existsSync8(join9(getProfilesDir(), profile));
+  return existsSync9(getFlatProfilePath(profile)) || existsSync9(join10(getProfilesDir(), profile));
 }
-function listProfiles() {
+function listProfiles2() {
   const profilesDir = getProfilesDir();
   const seen = new Set(["default"]);
-  if (!existsSync8(profilesDir)) {
+  if (!existsSync9(profilesDir)) {
     return [...seen];
   }
   try {
-    for (const entry of readdirSync5(profilesDir)) {
-      const fullPath = join9(profilesDir, entry);
+    for (const entry of readdirSync6(profilesDir)) {
+      const fullPath = join10(profilesDir, entry);
       const stat = statSync2(fullPath);
       if (stat.isDirectory()) {
         seen.add(entry);
@@ -15511,11 +15802,11 @@ function createProfile(profile, config = {}) {
 }
 function clearProfile(profile = getCurrentProfile()) {
   const flatPath = getFlatProfilePath(profile);
-  const directoryPath = join9(getProfilesDir(), profile);
-  if (existsSync8(flatPath)) {
+  const directoryPath = join10(getProfilesDir(), profile);
+  if (existsSync9(flatPath)) {
     rmSync(flatPath);
   }
-  if (existsSync8(directoryPath)) {
+  if (existsSync9(directoryPath)) {
     rmSync(directoryPath, { recursive: true, force: true });
   }
 }
@@ -15925,7 +16216,7 @@ async function runProfileCommand2(args, context) {
   switch (subcommand) {
     case "list": {
       const current = getCurrentProfile();
-      const profiles = listProfiles();
+      const profiles = listProfiles2();
       return successOutput({ current, profiles }, context.format, () => profiles.map((profile) => `${profile}${profile === current ? " (active)" : ""}`).join(`
 `));
     }
@@ -16320,19 +16611,19 @@ var imessageConnector = defineConnector({
 });
 
 // src/core/connectors/stripe.ts
-import { existsSync as existsSync9 } from "fs";
-import { dirname as dirname4, join as join10 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { dirname as dirname4, join as join11 } from "path";
 import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL2 } from "url";
 var __dirname3 = dirname4(fileURLToPath2(import.meta.url));
 function resolveStripeConnectorDir() {
   const candidates = [
-    join10(__dirname3, "..", "..", "..", "connectors", "connect-stripe"),
-    join10(__dirname3, "..", "..", "connectors", "connect-stripe"),
-    join10(__dirname3, "..", "connectors", "connect-stripe"),
-    join10(process.cwd(), "connectors", "connect-stripe")
+    join11(__dirname3, "..", "..", "..", "connectors", "connect-stripe"),
+    join11(__dirname3, "..", "..", "connectors", "connect-stripe"),
+    join11(__dirname3, "..", "connectors", "connect-stripe"),
+    join11(process.cwd(), "connectors", "connect-stripe")
   ];
   for (const candidate of candidates) {
-    if (existsSync9(candidate)) {
+    if (existsSync10(candidate)) {
       return candidate;
     }
   }
@@ -16571,10 +16862,10 @@ function buildCommandHelp2(spec) {
 var ROOT_HELP3 = buildRootHelp2(COMMAND_SPECS2);
 var COMMAND_HELP3 = Object.fromEntries(COMMAND_SPECS2.map((spec) => [spec.name, buildCommandHelp2(spec)]));
 async function loadStripeApiModule() {
-  return await import(pathToFileURL2(join10(CONNECTOR_DIR2, "src", "api", "index.ts")).href);
+  return await import(pathToFileURL2(join11(CONNECTOR_DIR2, "src", "api", "index.ts")).href);
 }
 async function loadStripeConfigModule() {
-  return await import(pathToFileURL2(join10(CONNECTOR_DIR2, "src", "utils", "config.ts")).href);
+  return await import(pathToFileURL2(join11(CONNECTOR_DIR2, "src", "utils", "config.ts")).href);
 }
 function extractGlobalArgs3(args) {
   const remaining = [];
@@ -17187,6 +17478,7 @@ var stripeConnector = defineConnector({
 // src/core/builtins.ts
 var INTERNAL_CONNECTOR_DEFINITIONS = [
   githubConnector,
+  googleDriveConnector,
   imessageConnector,
   stripeConnector
 ];
@@ -23211,17 +23503,17 @@ function loadConnectorVersions() {
   versionsLoaded = true;
   const thisDir = dirname5(fileURLToPath3(import.meta.url));
   const candidates = [
-    join11(thisDir, "..", "connectors"),
-    join11(thisDir, "..", "..", "connectors")
+    join12(thisDir, "..", "connectors"),
+    join12(thisDir, "..", "..", "connectors")
   ];
-  const connectorsDir = candidates.find((d) => existsSync10(d));
+  const connectorsDir = candidates.find((d) => existsSync11(d));
   if (!connectorsDir)
     return;
   for (const connector of CONNECTORS) {
     try {
-      const pkgPath = join11(connectorsDir, `connect-${connector.name}`, "package.json");
-      if (existsSync10(pkgPath)) {
-        const pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
+      const pkgPath = join12(connectorsDir, `connect-${connector.name}`, "package.json");
+      if (existsSync11(pkgPath)) {
+        const pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
         connector.version = pkg.version || "0.0.0";
         continue;
       }
@@ -23234,16 +23526,16 @@ function loadConnectorVersions() {
 }
 
 // src/lib/installer.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync4, readdirSync as readdirSync6, statSync as statSync3, rmSync as rmSync2 } from "fs";
-import { join as join12, dirname as dirname6 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync5, readdirSync as readdirSync7, statSync as statSync3, rmSync as rmSync2 } from "fs";
+import { join as join13, dirname as dirname6 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var __dirname4 = dirname6(fileURLToPath4(import.meta.url));
 function resolveConnectorsDir() {
-  const fromBin = join12(__dirname4, "..", "connectors");
-  if (existsSync11(fromBin))
+  const fromBin = join13(__dirname4, "..", "connectors");
+  if (existsSync12(fromBin))
     return fromBin;
-  const fromSrc = join12(__dirname4, "..", "..", "connectors");
-  if (existsSync11(fromSrc))
+  const fromSrc = join13(__dirname4, "..", "..", "connectors");
+  if (existsSync12(fromSrc))
     return fromSrc;
   return fromBin;
 }
@@ -23255,21 +23547,21 @@ function normalizeConnectorName(name) {
   return name.startsWith("connect-") ? name.slice("connect-".length) : name;
 }
 function getProjectConnectorsDir(targetDir) {
-  return join12(targetDir, PROJECT_CONNECTORS_DIRNAME);
+  return join13(targetDir, PROJECT_CONNECTORS_DIRNAME);
 }
 function getEnablementManifestPath(targetDir) {
-  return join12(getProjectConnectorsDir(targetDir), ENABLEMENT_MANIFEST_FILENAME);
+  return join13(getProjectConnectorsDir(targetDir), ENABLEMENT_MANIFEST_FILENAME);
 }
 function getLegacyInstallPath(targetDir, name) {
-  return join12(getProjectConnectorsDir(targetDir), `connect-${normalizeConnectorName(name)}`);
+  return join13(getProjectConnectorsDir(targetDir), `connect-${normalizeConnectorName(name)}`);
 }
 function loadEnablementManifest(targetDir) {
   const manifestPath = getEnablementManifestPath(targetDir);
-  if (!existsSync11(manifestPath)) {
+  if (!existsSync12(manifestPath)) {
     return null;
   }
   try {
-    const raw = JSON.parse(readFileSync5(manifestPath, "utf-8"));
+    const raw = JSON.parse(readFileSync6(manifestPath, "utf-8"));
     if (!Array.isArray(raw.connectors)) {
       return null;
     }
@@ -23285,11 +23577,11 @@ function loadEnablementManifest(targetDir) {
 }
 function getLegacyInstalledConnectors(targetDir) {
   const connectorsDir = getProjectConnectorsDir(targetDir);
-  if (!existsSync11(connectorsDir)) {
+  if (!existsSync12(connectorsDir)) {
     return [];
   }
-  return readdirSync6(connectorsDir).filter((entry) => {
-    const fullPath = join12(connectorsDir, entry);
+  return readdirSync7(connectorsDir).filter((entry) => {
+    const fullPath = join13(connectorsDir, entry);
     return entry.startsWith("connect-") && statSync3(fullPath).isDirectory();
   }).map((entry) => entry.replace("connect-", "")).sort();
 }
@@ -23298,7 +23590,7 @@ function getEnabledConnectors(targetDir) {
   return [...new Set([...manifestConnectors, ...getLegacyInstalledConnectors(targetDir)])].sort();
 }
 function updateConnectorsIndex(connectorsDir, connectors18) {
-  const indexPath = join12(connectorsDir, ENABLEMENT_INDEX_FILENAME);
+  const indexPath = join13(connectorsDir, ENABLEMENT_INDEX_FILENAME);
   const connectorList = connectors18.map((connector) => `  "${connector}",`).join(`
 `);
   const content = `/**
@@ -23314,28 +23606,28 @@ ${connectorList}
 
 export type EnabledConnectorName = typeof enabledConnectors[number];
 `;
-  writeFileSync4(indexPath, content);
+  writeFileSync5(indexPath, content);
 }
 function writeEnablementManifest(targetDir, connectors18) {
   const connectorsDir = getProjectConnectorsDir(targetDir);
-  mkdirSync7(connectorsDir, { recursive: true });
+  mkdirSync8(connectorsDir, { recursive: true });
   const manifest = {
     version: 1,
     mode: "internal",
     updatedAt: new Date().toISOString(),
     connectors: [...new Set(connectors18.map((value) => normalizeConnectorName(value)))].sort()
   };
-  writeFileSync4(getEnablementManifestPath(targetDir), JSON.stringify(manifest, null, 2) + `
+  writeFileSync5(getEnablementManifestPath(targetDir), JSON.stringify(manifest, null, 2) + `
 `);
   updateConnectorsIndex(connectorsDir, manifest.connectors);
 }
 function getConnectorPath(name) {
   const connectorName = name.startsWith("connect-") ? name : `connect-${name}`;
-  return join12(CONNECTORS_DIR, connectorName);
+  return join13(CONNECTORS_DIR, connectorName);
 }
 function connectorExists(name) {
   const normalizedName = normalizeConnectorName(name);
-  return hasInternalConnectorDefinition(normalizedName) || existsSync11(getConnectorPath(normalizedName));
+  return hasInternalConnectorDefinition(normalizedName) || existsSync12(getConnectorPath(normalizedName));
 }
 function installConnector(name, options = {}) {
   const { targetDir = process.cwd(), overwrite = false } = options;
@@ -23368,7 +23660,7 @@ function installConnector(name, options = {}) {
   try {
     const nextEnabled = [...new Set([...installed, normalizedName])].sort();
     writeEnablementManifest(targetDir, nextEnabled);
-    if (overwrite && existsSync11(legacyInstallPath)) {
+    if (overwrite && existsSync12(legacyInstallPath)) {
       rmSync2(legacyInstallPath, { recursive: true });
     }
     return {
@@ -23400,9 +23692,9 @@ function parseConnectorDocs(raw) {
 function getConnectorDocs(name) {
   const normalizedName = normalizeConnectorName(name);
   const connectorPath = getConnectorPath(normalizedName);
-  const claudeMdPath = join12(connectorPath, "CLAUDE.md");
-  if (existsSync11(claudeMdPath)) {
-    return parseConnectorDocs(readFileSync5(claudeMdPath, "utf-8"));
+  const claudeMdPath = join13(connectorPath, "CLAUDE.md");
+  if (existsSync12(claudeMdPath)) {
+    return parseConnectorDocs(readFileSync6(claudeMdPath, "utf-8"));
   }
   const internalDocs = getInternalConnectorDefinition(normalizedName)?.docsMarkdown;
   if (internalDocs) {
@@ -23446,315 +23738,89 @@ function removeConnector(name, targetDir = process.cwd()) {
   const nextEnabled = installed.filter((connector) => connector !== normalizedName);
   writeEnablementManifest(targetDir, nextEnabled);
   const legacyInstallPath = getLegacyInstallPath(targetDir, normalizedName);
-  if (existsSync11(legacyInstallPath)) {
+  if (existsSync12(legacyInstallPath)) {
     rmSync2(legacyInstallPath, { recursive: true });
   }
   return true;
 }
 
 // src/lib/runner.ts
-import { existsSync as existsSync12, readdirSync as readdirSync7 } from "fs";
-import { join as join13, dirname as dirname7 } from "path";
+import { existsSync as existsSync15, readdirSync as readdirSync9 } from "fs";
+import { join as join16, dirname as dirname7 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn2 } from "child_process";
 init_database();
-var __dirname5 = dirname7(fileURLToPath5(import.meta.url));
-function resolveConnectorsDir2() {
-  const fromBin = join13(__dirname5, "..", "connectors");
-  if (existsSync12(fromBin))
-    return fromBin;
-  const fromSrc = join13(__dirname5, "..", "..", "connectors");
-  if (existsSync12(fromSrc))
-    return fromSrc;
-  return fromBin;
-}
-var CONNECTORS_DIR2 = resolveConnectorsDir2();
-function buildInternalHelpText(name, commands) {
-  const lines = [
-    `Usage: connect-${name} [options] [command]`,
-    "",
-    "Commands:"
-  ];
-  for (const command of commands) {
-    lines.push(`  ${command.name.padEnd(24)} ${command.summary}`);
+
+// src/server/auth.ts
+import { existsSync as existsSync14, readFileSync as readFileSync7, writeFileSync as writeFileSync6, mkdirSync as mkdirSync10, readdirSync as readdirSync8, rmSync as rmSync3, statSync as statSync5 } from "fs";
+import { randomBytes } from "crypto";
+import { join as join15 } from "path";
+
+// src/lib/lock.ts
+init_database();
+import { openSync, closeSync, unlinkSync, existsSync as existsSync13, statSync as statSync4 } from "fs";
+import { join as join14 } from "path";
+import { mkdirSync as mkdirSync9 } from "fs";
+var LOCK_TIMEOUT_MS = 5000;
+var LOCK_RETRY_MS = 100;
+var STALE_LOCK_MS = 30000;
+
+class LockTimeoutError extends Error {
+  connector;
+  constructor(connector) {
+    super(`Could not acquire write lock for connector "${connector}" within ${LOCK_TIMEOUT_MS}ms. Another agent may be writing. Try again shortly.`);
+    this.connector = connector;
+    this.name = "LockTimeoutError";
   }
-  return lines.join(`
-`);
 }
-function getInternalCommandRuntime(name) {
-  return getInternalConnectorDefinition(name)?.commandRuntime;
+function lockPath(connector) {
+  const dir = join14(getConnectorsHome(), `connect-${connector}`);
+  mkdirSync9(dir, { recursive: true });
+  return join14(dir, ".write.lock");
 }
-var ENV_VAR_NAME_OVERRIDES = {
-  googlemaps: ["GOOGLE_MAPS"],
-  googletasks: ["GOOGLE_TASKS", "GOOGLE"],
-  google: ["GOOGLE"],
-  stabilityai: ["STABILITY"],
-  openweathermap: ["OPENWEATHERMAP", "OPENWEATHER"]
-};
-function buildEnvWithCredentials(connectorName, baseEnv) {
-  const env = { ...baseEnv };
-  const prefixes = ENV_VAR_NAME_OVERRIDES[connectorName] || [
-    connectorName.toUpperCase().replace(/-/g, "_")
-  ];
-  for (const prefix of prefixes) {
-    const canonicalKey = `${prefix}_API_KEY`;
-    if (env[canonicalKey])
-      continue;
-    const alternatives = [
-      `HASNAXYZ_${prefix}_LIVE_API_KEY`,
-      `HASNA_${prefix}_LIVE_API_KEY`,
-      `${prefix}_LIVE_API_KEY`,
-      `${prefix}_KEY`,
-      `${prefix}_TOKEN`
-    ];
-    for (const alt of alternatives) {
-      const value = env[alt];
-      if (value) {
-        env[canonicalKey] = value;
-        break;
-      }
-    }
+function isStale(path) {
+  try {
+    const stat = statSync4(path);
+    return Date.now() - stat.mtimeMs > STALE_LOCK_MS;
+  } catch {
+    return false;
   }
-  return env;
-}
-function getConnectorCliPath(name) {
-  const safeName = name.replace(/[^a-z0-9-]/g, "");
-  const connectorDir = join13(CONNECTORS_DIR2, `connect-${safeName}`);
-  const cliPath = join13(connectorDir, "src", "cli", "index.ts");
-  if (existsSync12(cliPath))
-    return cliPath;
-  return null;
-}
-function hasConnectorCommandSurface(name) {
-  return Boolean(getInternalCommandRuntime(name)?.commands.length || getConnectorCliPath(name));
-}
-function normalizeCommanderUsage(usage) {
-  const commandToken = usage.trim().split(/\s+/)[0];
-  if (!commandToken || commandToken === "help")
-    return null;
-  const aliases = commandToken.split("|").filter(Boolean);
-  const [name, ...rest] = aliases;
-  if (!name)
-    return null;
-  return {
-    name,
-    aliases: rest,
-    usage: usage.trim()
-  };
 }
-function parseCommanderHelpOperations(helpText) {
-  const operations = [];
-  const lines = helpText.split(`
-`);
-  let inCommands = false;
-  for (const line of lines) {
-    if (line.trim().startsWith("Commands:")) {
-      inCommands = true;
-      continue;
-    }
-    if (!inCommands)
-      continue;
-    if (line.trim() === "") {
-      if (operations.length > 0)
-        inCommands = false;
-      continue;
-    }
-    const row = line.match(/^ {2}(\S.*?)(?: {2,}(.+))?$/);
-    if (!row)
-      continue;
-    const usage = row[1].trim();
-    const summary = (row[2] ?? "").trim();
-    const normalized = normalizeCommanderUsage(usage);
-    if (!normalized)
-      continue;
-    operations.push({
-      ...normalized,
-      summary,
-      source: "cli"
-    });
+function tryAcquire(path) {
+  if (existsSync13(path) && isStale(path)) {
+    try {
+      unlinkSync(path);
+    } catch {}
+  }
+  try {
+    const fd = openSync(path, "wx");
+    closeSync(fd);
+    return true;
+  } catch (e) {
+    if (e.code === "EEXIST")
+      return false;
+    throw e;
   }
-  return operations;
 }
-function runConnectorCommand2(name, args, timeoutMs = 30000) {
-  getConnectorsHome();
-  const internalRuntime = getInternalCommandRuntime(name);
-  if (internalRuntime?.run) {
-    return Promise.resolve(internalRuntime.run(args)).then((result) => {
-      if (result) {
-        const stdout = result.stdout.trim();
-        const stderr = (result.stderr ?? "").trim();
-        const exitCode = result.exitCode ?? (result.success === false ? 1 : 0);
-        return {
-          stdout,
-          stderr,
-          exitCode,
-          success: result.success ?? exitCode === 0
-        };
+function release(path) {
+  try {
+    unlinkSync(path);
+  } catch {}
+}
+async function withWriteLock(connector, fn) {
+  const path = lockPath(connector);
+  const deadline = Date.now() + LOCK_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    if (tryAcquire(path)) {
+      try {
+        return await fn();
+      } finally {
+        release(path);
       }
-      return runLegacyConnectorCommand(name, args, timeoutMs);
-    });
+    }
+    await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_MS));
   }
-  return runLegacyConnectorCommand(name, args, timeoutMs);
-}
-function runLegacyConnectorCommand(name, args, timeoutMs = 30000) {
-  const cliPath = getConnectorCliPath(name);
-  if (!cliPath) {
-    return Promise.resolve({
-      stdout: "",
-      stderr: `Connector '${name}' not found or has no CLI.`,
-      exitCode: 1,
-      success: false
-    });
-  }
-  return new Promise((resolve) => {
-    const proc = spawn3("bun", ["run", cliPath, ...args], {
-      timeout: timeoutMs,
-      env: buildEnvWithCredentials(name, process.env),
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    let stdout = "";
-    let stderr = "";
-    proc.stdout.on("data", (data) => {
-      stdout += data.toString();
-    });
-    proc.stderr.on("data", (data) => {
-      stderr += data.toString();
-    });
-    proc.on("close", (code) => {
-      resolve({
-        stdout: stdout.trim(),
-        stderr: stderr.trim(),
-        exitCode: code ?? 1,
-        success: code === 0
-      });
-    });
-    proc.on("error", (err) => {
-      resolve({
-        stdout: "",
-        stderr: err.message,
-        exitCode: 1,
-        success: false
-      });
-    });
-  });
-}
-async function getConnectorOperations(name) {
-  const internalRuntime = getInternalCommandRuntime(name);
-  if (internalRuntime?.commands.length) {
-    const operations2 = internalRuntime.commands.map((command) => ({
-      name: command.name,
-      aliases: [],
-      usage: command.name,
-      summary: command.summary,
-      source: "internal"
-    }));
-    return {
-      commands: operations2.map((operation) => operation.name),
-      operations: operations2,
-      helpText: internalRuntime.helpText ?? buildInternalHelpText(name, internalRuntime.commands),
-      hasCli: true
-    };
-  }
-  const cliPath = getConnectorCliPath(name);
-  if (!cliPath) {
-    return { commands: [], operations: [], helpText: "", hasCli: false };
-  }
-  const result = await runConnectorCommand2(name, ["--help"]);
-  const helpText = result.stdout || result.stderr;
-  const operations = parseCommanderHelpOperations(helpText);
-  return {
-    commands: operations.map((operation) => operation.name),
-    operations,
-    helpText,
-    hasCli: true
-  };
-}
-async function getConnectorCommandHelp(name, command) {
-  const internalRuntime = getInternalCommandRuntime(name);
-  if (internalRuntime?.getHelp) {
-    const help = await internalRuntime.getHelp(command);
-    if (help) {
-      return help;
-    }
-  }
-  const runtimeCommand = internalRuntime?.commands.find((runtimeEntry) => runtimeEntry.name === command);
-  if (runtimeCommand?.helpText) {
-    return runtimeCommand.helpText;
-  }
-  const result = await runConnectorCommand2(name, [command, "--help"]);
-  return result.stdout || result.stderr;
-}
-
-// src/server/auth.ts
-import { existsSync as existsSync14, readFileSync as readFileSync6, writeFileSync as writeFileSync5, mkdirSync as mkdirSync9, readdirSync as readdirSync8, rmSync as rmSync3, statSync as statSync5 } from "fs";
-import { randomBytes } from "crypto";
-import { join as join15 } from "path";
-
-// src/lib/lock.ts
-init_database();
-import { openSync, closeSync, unlinkSync, existsSync as existsSync13, statSync as statSync4 } from "fs";
-import { join as join14 } from "path";
-import { mkdirSync as mkdirSync8 } from "fs";
-var LOCK_TIMEOUT_MS = 5000;
-var LOCK_RETRY_MS = 100;
-var STALE_LOCK_MS = 30000;
-
-class LockTimeoutError extends Error {
-  connector;
-  constructor(connector) {
-    super(`Could not acquire write lock for connector "${connector}" within ${LOCK_TIMEOUT_MS}ms. Another agent may be writing. Try again shortly.`);
-    this.connector = connector;
-    this.name = "LockTimeoutError";
-  }
-}
-function lockPath(connector) {
-  const dir = join14(getConnectorsHome(), `connect-${connector}`);
-  mkdirSync8(dir, { recursive: true });
-  return join14(dir, ".write.lock");
-}
-function isStale(path) {
-  try {
-    const stat = statSync4(path);
-    return Date.now() - stat.mtimeMs > STALE_LOCK_MS;
-  } catch {
-    return false;
-  }
-}
-function tryAcquire(path) {
-  if (existsSync13(path) && isStale(path)) {
-    try {
-      unlinkSync(path);
-    } catch {}
-  }
-  try {
-    const fd = openSync(path, "wx");
-    closeSync(fd);
-    return true;
-  } catch (e) {
-    if (e.code === "EEXIST")
-      return false;
-    throw e;
-  }
-}
-function release(path) {
-  try {
-    unlinkSync(path);
-  } catch {}
-}
-async function withWriteLock(connector, fn) {
-  const path = lockPath(connector);
-  const deadline = Date.now() + LOCK_TIMEOUT_MS;
-  while (Date.now() < deadline) {
-    if (tryAcquire(path)) {
-      try {
-        return await fn();
-      } finally {
-        release(path);
-      }
-    }
-    await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_MS));
-  }
-  throw new LockTimeoutError(connector);
+  throw new LockTimeoutError(connector);
 }
 
 // src/server/auth.ts
@@ -23821,7 +23887,7 @@ function getCurrentProfile2(name) {
   const currentProfileFile = join15(configDir, "current_profile");
   if (existsSync14(currentProfileFile)) {
     try {
-      return readFileSync6(currentProfileFile, "utf-8").trim() || "default";
+      return readFileSync7(currentProfileFile, "utf-8").trim() || "default";
     } catch {
       return "default";
     }
@@ -23836,13 +23902,13 @@ function loadProfileConfig(name) {
   const profileFile = join15(configDir, "profiles", `${profile}.json`);
   if (existsSync14(profileFile)) {
     try {
-      flatConfig = JSON.parse(readFileSync6(profileFile, "utf-8"));
+      flatConfig = JSON.parse(readFileSync7(profileFile, "utf-8"));
     } catch {}
   }
   const profileDirConfig = join15(configDir, "profiles", profile, "config.json");
   if (existsSync14(profileDirConfig)) {
     try {
-      dirConfig = JSON.parse(readFileSync6(profileDirConfig, "utf-8"));
+      dirConfig = JSON.parse(readFileSync7(profileDirConfig, "utf-8"));
     } catch {}
   }
   if (Object.keys(flatConfig).length === 0 && Object.keys(dirConfig).length === 0) {
@@ -23850,13 +23916,13 @@ function loadProfileConfig(name) {
   }
   return { ...flatConfig, ...dirConfig };
 }
-function loadTokens(name) {
+function loadTokens2(name) {
   const configDir = getConnectorConfigDir(name);
   const profile = getCurrentProfile2(name);
   const tokensFile = join15(configDir, "profiles", profile, "tokens.json");
   if (existsSync14(tokensFile)) {
     try {
-      return JSON.parse(readFileSync6(tokensFile, "utf-8"));
+      return JSON.parse(readFileSync7(tokensFile, "utf-8"));
     } catch {
       return null;
     }
@@ -23873,28 +23939,49 @@ function loadTokens(name) {
   }
   return null;
 }
+function isStoredOAuthEnvVarSet(variable, oauthConfig, tokens, profileConfig) {
+  if (variable.endsWith("_CLIENT_ID")) {
+    return Boolean(oauthConfig.clientId || profileConfig.clientId);
+  }
+  if (variable.endsWith("_CLIENT_SECRET")) {
+    return Boolean(oauthConfig.clientSecret || profileConfig.clientSecret);
+  }
+  if (variable.endsWith("_ACCESS_TOKEN")) {
+    return Boolean(tokens?.accessToken || profileConfig.accessToken);
+  }
+  if (variable.endsWith("_REFRESH_TOKEN")) {
+    return Boolean(tokens?.refreshToken || profileConfig.refreshToken);
+  }
+  if (variable.endsWith("_TOKEN_EXPIRES_AT")) {
+    return Boolean(tokens?.expiresAt || profileConfig.expiresAt);
+  }
+  return false;
+}
 function getAuthStatus(name) {
   const authType = getAuthType(name);
   const docs = getConnectorDocs(name);
+  const oauthConfig = authType === "oauth" ? getOAuthConfig(name) : {};
+  const tokens = authType === "oauth" ? loadTokens2(name) : null;
+  const profileConfig = authType === "oauth" ? loadProfileConfig(name) : {};
   const envVars = (docs?.envVars || []).map((v) => ({
     variable: v.variable,
     description: v.description,
-    set: !!process.env[v.variable]
+    set: !!process.env[v.variable] || authType === "oauth" && isStoredOAuthEnvVarSet(v.variable, oauthConfig, tokens, profileConfig)
   }));
   const envVarTotalCount = envVars.length;
   const envVarSetCount = envVars.filter((v) => v.set).length;
   if (authType === "oauth") {
-    const tokens = loadTokens(name);
-    const config2 = loadProfileConfig(name);
-    const hasTokens = !!tokens?.accessToken || !!config2.accessToken;
-    const hasRefreshToken = !!tokens?.refreshToken || !!config2.refreshToken;
-    const tokenExpiry = tokens?.expiresAt || config2.expiresAt;
+    const hasTokens = !!tokens?.accessToken || !!profileConfig.accessToken;
+    const hasRefreshToken = !!tokens?.refreshToken || !!profileConfig.refreshToken;
+    const tokenExpiry = tokens?.expiresAt || profileConfig.expiresAt;
+    const hasOAuthCredentials = Boolean(oauthConfig.clientId && oauthConfig.clientSecret);
     const hasEnvVar2 = envVars.some((v) => v.set);
     return {
       type: "oauth",
-      configured: hasTokens || hasRefreshToken || hasEnvVar2,
+      configured: hasTokens || hasRefreshToken || hasOAuthCredentials || hasEnvVar2,
       tokenExpiry,
       hasRefreshToken,
+      hasOAuthCredentials,
       envVars,
       envVarSetCount,
       envVarTotalCount
@@ -23911,6 +23998,10 @@ function getAuthStatus(name) {
     envVarTotalCount
   };
 }
+function getEnvVars(name) {
+  const docs = getConnectorDocs(name);
+  return docs?.envVars || [];
+}
 async function saveApiKey(name, key, field) {
   return withWriteLock(name, () => _saveApiKey(name, key, field));
 }
@@ -23920,15 +24011,15 @@ function _saveApiKey(name, key, field) {
   const keyField = field || guessKeyField(name);
   if (keyField === "clientId" || keyField === "clientSecret") {
     const credentialsFile = join15(configDir, "credentials.json");
-    mkdirSync9(configDir, { recursive: true });
+    mkdirSync10(configDir, { recursive: true });
     let creds = {};
     if (existsSync14(credentialsFile)) {
       try {
-        creds = JSON.parse(readFileSync6(credentialsFile, "utf-8"));
+        creds = JSON.parse(readFileSync7(credentialsFile, "utf-8"));
       } catch {}
     }
     creds[keyField] = key;
-    writeFileSync5(credentialsFile, JSON.stringify(creds, null, 2));
+    writeFileSync6(credentialsFile, JSON.stringify(creds, null, 2));
     return;
   }
   const profileFile = join15(configDir, "profiles", `${profile}.json`);
@@ -23936,10 +24027,10 @@ function _saveApiKey(name, key, field) {
   if (existsSync14(profileFile)) {
     let config = {};
     try {
-      config = JSON.parse(readFileSync6(profileFile, "utf-8"));
+      config = JSON.parse(readFileSync7(profileFile, "utf-8"));
     } catch {}
     config[keyField] = key;
-    writeFileSync5(profileFile, JSON.stringify(config, null, 2));
+    writeFileSync6(profileFile, JSON.stringify(config, null, 2));
     return;
   }
   if (existsSync14(profileDir)) {
@@ -23947,15 +24038,15 @@ function _saveApiKey(name, key, field) {
     let config = {};
     if (existsSync14(configFile)) {
       try {
-        config = JSON.parse(readFileSync6(configFile, "utf-8"));
+        config = JSON.parse(readFileSync7(configFile, "utf-8"));
       } catch {}
     }
     config[keyField] = key;
-    writeFileSync5(configFile, JSON.stringify(config, null, 2));
+    writeFileSync6(configFile, JSON.stringify(config, null, 2));
     return;
   }
-  mkdirSync9(profileDir, { recursive: true });
-  writeFileSync5(join15(profileDir, "config.json"), JSON.stringify({ [keyField]: key }, null, 2));
+  mkdirSync10(profileDir, { recursive: true });
+  writeFileSync6(join15(profileDir, "config.json"), JSON.stringify({ [keyField]: key }, null, 2));
 }
 function guessKeyField(name) {
   const docs = getConnectorDocs(name);
@@ -23976,7 +24067,7 @@ function getOAuthConfig(name) {
   const credentialsFile = join15(configDir, "credentials.json");
   if (existsSync14(credentialsFile)) {
     try {
-      const creds = JSON.parse(readFileSync6(credentialsFile, "utf-8"));
+      const creds = JSON.parse(readFileSync7(credentialsFile, "utf-8"));
       return { clientId: creds.clientId, clientSecret: creds.clientSecret };
     } catch {}
   }
@@ -24056,16 +24147,16 @@ function saveOAuthTokens(name, tokens) {
   const configDir = getConnectorConfigDir(name);
   const profile = getCurrentProfile2(name);
   const profileDir = join15(configDir, "profiles", profile);
-  mkdirSync9(profileDir, { recursive: true });
+  mkdirSync10(profileDir, { recursive: true });
   const tokensFile = join15(profileDir, "tokens.json");
-  writeFileSync5(tokensFile, JSON.stringify(tokens, null, 2), { mode: 384 });
+  writeFileSync6(tokensFile, JSON.stringify(tokens, null, 2), { mode: 384 });
 }
 async function refreshOAuthToken(name) {
   return withWriteLock(name, () => _refreshOAuthToken(name));
 }
 async function _refreshOAuthToken(name) {
   const oauthConfig = getOAuthConfig(name);
-  const currentTokens = loadTokens(name);
+  const currentTokens = loadTokens2(name);
   if (!oauthConfig.clientId || !oauthConfig.clientSecret) {
     throw new Error("OAuth credentials not configured for " + name);
   }
@@ -24098,7 +24189,7 @@ async function _refreshOAuthToken(name) {
   saveOAuthTokens(name, tokens);
   return tokens;
 }
-function listProfiles2(name) {
+function listProfiles3(name) {
   const configDir = getConnectorConfigDir(name);
   const profilesDir = join15(configDir, "profiles");
   if (!existsSync14(profilesDir))
@@ -24121,8 +24212,8 @@ function listProfiles2(name) {
 }
 function switchProfile(name, profile) {
   const configDir = getConnectorConfigDir(name);
-  mkdirSync9(configDir, { recursive: true });
-  writeFileSync5(join15(configDir, "current_profile"), profile);
+  mkdirSync10(configDir, { recursive: true });
+  writeFileSync6(join15(configDir, "current_profile"), profile);
 }
 function deleteProfile2(name, profile) {
   if (profile === "default")
@@ -24148,6 +24239,253 @@ function deleteProfile2(name, profile) {
   return false;
 }
 
+// src/lib/runner.ts
+var __dirname5 = dirname7(fileURLToPath5(import.meta.url));
+function resolveConnectorsDir2() {
+  const fromBin = join16(__dirname5, "..", "connectors");
+  if (existsSync15(fromBin))
+    return fromBin;
+  const fromSrc = join16(__dirname5, "..", "..", "connectors");
+  if (existsSync15(fromSrc))
+    return fromSrc;
+  return fromBin;
+}
+var CONNECTORS_DIR2 = resolveConnectorsDir2();
+function buildInternalHelpText(name, commands) {
+  const lines = [
+    `Usage: connect-${name} [options] [command]`,
+    "",
+    "Commands:"
+  ];
+  for (const command of commands) {
+    lines.push(`  ${command.name.padEnd(24)} ${command.summary}`);
+  }
+  return lines.join(`
+`);
+}
+function getInternalCommandRuntime(name) {
+  return getInternalConnectorDefinition(name)?.commandRuntime;
+}
+var ENV_VAR_NAME_OVERRIDES = {
+  googlemaps: ["GOOGLE_MAPS"],
+  googletasks: ["GOOGLE_TASKS", "GOOGLE"],
+  google: ["GOOGLE"],
+  stabilityai: ["STABILITY"],
+  openweathermap: ["OPENWEATHERMAP", "OPENWEATHER"]
+};
+function buildEnvWithCredentials(connectorName, baseEnv) {
+  const env = { ...baseEnv };
+  const prefixes = ENV_VAR_NAME_OVERRIDES[connectorName] || [
+    connectorName.toUpperCase().replace(/-/g, "_")
+  ];
+  for (const prefix of prefixes) {
+    const canonicalKey = `${prefix}_API_KEY`;
+    if (env[canonicalKey])
+      continue;
+    const alternatives = [
+      `HASNAXYZ_${prefix}_LIVE_API_KEY`,
+      `HASNA_${prefix}_LIVE_API_KEY`,
+      `${prefix}_LIVE_API_KEY`,
+      `${prefix}_KEY`,
+      `${prefix}_TOKEN`
+    ];
+    for (const alt of alternatives) {
+      const value = env[alt];
+      if (value) {
+        env[canonicalKey] = value;
+        break;
+      }
+    }
+  }
+  if (getAuthType(connectorName) === "oauth") {
+    const oauthConfig = getOAuthConfig(connectorName);
+    const tokens = loadTokens2(connectorName);
+    for (const { variable } of getEnvVars(connectorName)) {
+      if (env[variable])
+        continue;
+      if (variable.endsWith("_CLIENT_ID") && oauthConfig.clientId) {
+        env[variable] = oauthConfig.clientId;
+      } else if (variable.endsWith("_CLIENT_SECRET") && oauthConfig.clientSecret) {
+        env[variable] = oauthConfig.clientSecret;
+      } else if (variable.endsWith("_ACCESS_TOKEN") && tokens?.accessToken) {
+        env[variable] = tokens.accessToken;
+      } else if (variable.endsWith("_REFRESH_TOKEN") && tokens?.refreshToken) {
+        env[variable] = tokens.refreshToken;
+      } else if (variable.endsWith("_TOKEN_EXPIRES_AT") && tokens?.expiresAt) {
+        env[variable] = String(tokens.expiresAt);
+      }
+    }
+  }
+  return env;
+}
+function getConnectorCliPath(name) {
+  const safeName = name.replace(/[^a-z0-9-]/g, "");
+  const connectorDir = join16(CONNECTORS_DIR2, `connect-${safeName}`);
+  const cliPath = join16(connectorDir, "src", "cli", "index.ts");
+  if (existsSync15(cliPath))
+    return cliPath;
+  return null;
+}
+function hasConnectorCommandSurface(name) {
+  return Boolean(getInternalCommandRuntime(name)?.commands.length || getConnectorCliPath(name));
+}
+function normalizeCommanderUsage(usage) {
+  const commandToken = usage.trim().split(/\s+/)[0];
+  if (!commandToken || commandToken === "help")
+    return null;
+  const aliases = commandToken.split("|").filter(Boolean);
+  const [name, ...rest] = aliases;
+  if (!name)
+    return null;
+  return {
+    name,
+    aliases: rest,
+    usage: usage.trim()
+  };
+}
+function parseCommanderHelpOperations(helpText) {
+  const operations = [];
+  const lines = helpText.split(`
+`);
+  let inCommands = false;
+  for (const line of lines) {
+    if (line.trim().startsWith("Commands:")) {
+      inCommands = true;
+      continue;
+    }
+    if (!inCommands)
+      continue;
+    if (line.trim() === "") {
+      if (operations.length > 0)
+        inCommands = false;
+      continue;
+    }
+    const row = line.match(/^ {2}(?! )(\S.*?)(?: {2,}(.+))?$/);
+    if (!row)
+      continue;
+    const usage = row[1].trim();
+    const summary = (row[2] ?? "").trim();
+    const normalized = normalizeCommanderUsage(usage);
+    if (!normalized)
+      continue;
+    operations.push({
+      ...normalized,
+      summary,
+      source: "cli"
+    });
+  }
+  return operations;
+}
+function runConnectorCommand2(name, args, timeoutMs = 30000) {
+  getConnectorsHome();
+  const internalRuntime = getInternalCommandRuntime(name);
+  if (internalRuntime?.run) {
+    return Promise.resolve(internalRuntime.run(args)).then((result) => {
+      if (result) {
+        const stdout = result.stdout.trim();
+        const stderr = (result.stderr ?? "").trim();
+        const exitCode = result.exitCode ?? (result.success === false ? 1 : 0);
+        return {
+          stdout,
+          stderr,
+          exitCode,
+          success: result.success ?? exitCode === 0
+        };
+      }
+      return runLegacyConnectorCommand(name, args, timeoutMs);
+    });
+  }
+  return runLegacyConnectorCommand(name, args, timeoutMs);
+}
+function runLegacyConnectorCommand(name, args, timeoutMs = 30000) {
+  const cliPath = getConnectorCliPath(name);
+  if (!cliPath) {
+    return Promise.resolve({
+      stdout: "",
+      stderr: `Connector '${name}' not found or has no CLI.`,
+      exitCode: 1,
+      success: false
+    });
+  }
+  return new Promise((resolve) => {
+    const proc = spawn2("bun", ["run", cliPath, ...args], {
+      timeout: timeoutMs,
+      env: buildEnvWithCredentials(name, process.env),
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("close", (code) => {
+      resolve({
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+        exitCode: code ?? 1,
+        success: code === 0
+      });
+    });
+    proc.on("error", (err) => {
+      resolve({
+        stdout: "",
+        stderr: err.message,
+        exitCode: 1,
+        success: false
+      });
+    });
+  });
+}
+async function getConnectorOperations(name) {
+  const internalRuntime = getInternalCommandRuntime(name);
+  if (internalRuntime?.commands.length) {
+    const operations2 = internalRuntime.commands.map((command) => ({
+      name: command.name,
+      aliases: [],
+      usage: command.name,
+      summary: command.summary,
+      source: "internal"
+    }));
+    return {
+      commands: operations2.map((operation) => operation.name),
+      operations: operations2,
+      helpText: internalRuntime.helpText ?? buildInternalHelpText(name, internalRuntime.commands),
+      hasCli: true
+    };
+  }
+  const cliPath = getConnectorCliPath(name);
+  if (!cliPath) {
+    return { commands: [], operations: [], helpText: "", hasCli: false };
+  }
+  const result = await runConnectorCommand2(name, ["--help"]);
+  const helpText = result.stdout || result.stderr;
+  const operations = parseCommanderHelpOperations(helpText);
+  return {
+    commands: operations.map((operation) => operation.name),
+    operations,
+    helpText,
+    hasCli: true
+  };
+}
+async function getConnectorCommandHelp(name, command) {
+  const internalRuntime = getInternalCommandRuntime(name);
+  if (internalRuntime?.getHelp) {
+    const help = await internalRuntime.getHelp(command);
+    if (help) {
+      return help;
+    }
+  }
+  const runtimeCommand = internalRuntime?.commands.find((runtimeEntry) => runtimeEntry.name === command);
+  if (runtimeCommand?.helpText) {
+    return runtimeCommand.helpText;
+  }
+  const result = await runConnectorCommand2(name, [command, "--help"]);
+  return result.stdout || result.stderr;
+}
+
 // src/server/serve.ts
 var activityLog = [];
 var MAX_ACTIVITY_LOG = 100;
@@ -24161,20 +24499,20 @@ function resolveDashboardDir() {
   const candidates = [];
   try {
     const scriptDir = dirname8(fileURLToPath6(import.meta.url));
-    candidates.push(join16(scriptDir, "..", "dashboard", "dist"));
-    candidates.push(join16(scriptDir, "..", "..", "dashboard", "dist"));
+    candidates.push(join17(scriptDir, "..", "dashboard", "dist"));
+    candidates.push(join17(scriptDir, "..", "..", "dashboard", "dist"));
   } catch {}
   if (process.argv[1]) {
     const mainDir = dirname8(process.argv[1]);
-    candidates.push(join16(mainDir, "..", "dashboard", "dist"));
-    candidates.push(join16(mainDir, "..", "..", "dashboard", "dist"));
+    candidates.push(join17(mainDir, "..", "dashboard", "dist"));
+    candidates.push(join17(mainDir, "..", "..", "dashboard", "dist"));
   }
-  candidates.push(join16(process.cwd(), "dashboard", "dist"));
+  candidates.push(join17(process.cwd(), "dashboard", "dist"));
   for (const candidate of candidates) {
-    if (existsSync15(candidate))
+    if (existsSync16(candidate))
       return candidate;
   }
-  return join16(process.cwd(), "dashboard", "dist");
+  return join17(process.cwd(), "dashboard", "dist");
 }
 var MIME_TYPES = {
   ".html": "text/html; charset=utf-8",
@@ -24276,7 +24614,7 @@ function oauthPage(type, title, message, hint, extra) {
   </body></html>`;
 }
 function serveStaticFile(filePath) {
-  if (!existsSync15(filePath))
+  if (!existsSync16(filePath))
     return null;
   const ext = extname(filePath);
   const contentType = MIME_TYPES[ext] || "application/octet-stream";
@@ -24313,7 +24651,7 @@ async function startServer(requestedPort, options) {
   const strict = options?.strict ?? false;
   loadConnectorVersions();
   const dashboardDir = resolveDashboardDir();
-  const dashboardExists = existsSync15(dashboardDir);
+  const dashboardExists = existsSync16(dashboardDir);
   if (!dashboardExists) {
     console.error(`
 Dashboard not found at: ${dashboardDir}`);
@@ -24715,13 +25053,13 @@ ${result.stderr}`;
         if (!isValidConnectorName(name))
           return json({ error: "Invalid connector name" }, 400, port);
         try {
-          const profiles = listProfiles2(name);
-          const configDir = join16(getConnectorsHome(), name.startsWith("connect-") ? name : `connect-${name}`);
-          const currentProfileFile = join16(configDir, "current_profile");
+          const profiles = listProfiles3(name);
+          const configDir = join17(getConnectorsHome(), name.startsWith("connect-") ? name : `connect-${name}`);
+          const currentProfileFile = join17(configDir, "current_profile");
           let current = "default";
-          if (existsSync15(currentProfileFile)) {
+          if (existsSync16(currentProfileFile)) {
             try {
-              current = readFileSync7(currentProfileFile, "utf-8").trim() || "default";
+              current = readFileSync8(currentProfileFile, "utf-8").trim() || "default";
             } catch {}
           }
           return json({ current, profiles }, 200, port);
@@ -24770,30 +25108,30 @@ ${result.stderr}`;
         try {
           const connectDir = getConnectorsHome();
           const result = {};
-          if (existsSync15(connectDir)) {
-            const entries = readdirSync9(connectDir, { withFileTypes: true });
+          if (existsSync16(connectDir)) {
+            const entries = readdirSync10(connectDir, { withFileTypes: true });
             for (const entry of entries) {
               if (!entry.isDirectory() || !entry.name.startsWith("connect-"))
                 continue;
               const connectorName = entry.name.replace(/^connect-/, "");
-              const profilesDir = join16(connectDir, entry.name, "profiles");
-              if (!existsSync15(profilesDir))
+              const profilesDir = join17(connectDir, entry.name, "profiles");
+              if (!existsSync16(profilesDir))
                 continue;
               const profiles = {};
-              const profileEntries = readdirSync9(profilesDir, { withFileTypes: true });
+              const profileEntries = readdirSync10(profilesDir, { withFileTypes: true });
               for (const pEntry of profileEntries) {
                 if (pEntry.isFile() && pEntry.name.endsWith(".json")) {
-                  const profileName = basename(pEntry.name, ".json");
+                  const profileName = basename2(pEntry.name, ".json");
                   try {
-                    const config = JSON.parse(readFileSync7(join16(profilesDir, pEntry.name), "utf-8"));
+                    const config = JSON.parse(readFileSync8(join17(profilesDir, pEntry.name), "utf-8"));
                     profiles[profileName] = config;
                   } catch {}
                 }
                 if (pEntry.isDirectory()) {
-                  const configPath = join16(profilesDir, pEntry.name, "config.json");
-                  if (existsSync15(configPath)) {
+                  const configPath = join17(profilesDir, pEntry.name, "config.json");
+                  if (existsSync16(configPath)) {
                     try {
-                      const config = JSON.parse(readFileSync7(configPath, "utf-8"));
+                      const config = JSON.parse(readFileSync8(configPath, "utf-8"));
                       profiles[pEntry.name] = config;
                     } catch {}
                   }
@@ -24834,14 +25172,14 @@ ${result.stderr}`;
               continue;
             if (!data.profiles || typeof data.profiles !== "object")
               continue;
-            const connectorDir = join16(connectDir, `connect-${connectorName}`);
-            const profilesDir = join16(connectorDir, "profiles");
+            const connectorDir = join17(connectDir, `connect-${connectorName}`);
+            const profilesDir = join17(connectorDir, "profiles");
             for (const [profileName, config] of Object.entries(data.profiles)) {
               if (!config || typeof config !== "object")
                 continue;
-              mkdirSync10(profilesDir, { recursive: true });
-              const profileFile = join16(profilesDir, `${profileName}.json`);
-              writeFileSync6(profileFile, JSON.stringify(config, null, 2));
+              mkdirSync11(profilesDir, { recursive: true });
+              const profileFile = join17(profilesDir, `${profileName}.json`);
+              writeFileSync7(profileFile, JSON.stringify(config, null, 2));
               imported++;
             }
           }
@@ -24896,12 +25234,12 @@ ${result.stderr}`;
       }
       if (dashboardExists && (method === "GET" || method === "HEAD")) {
         if (path !== "/") {
-          const filePath = join16(dashboardDir, path);
+          const filePath = join17(dashboardDir, path);
           const res2 = serveStaticFile(filePath);
           if (res2)
             return res2;
         }
-        const indexPath = join16(dashboardDir, "index.html");
+        const indexPath = join17(dashboardDir, "index.html");
         const res = serveStaticFile(indexPath);
         if (res)
           return res;