@hasna/connectors 1.3.20 → 1.3.22

package/bin/index.js

@@ -1909,7 +1909,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/connectors",
-    version: "1.3.20",
+    version: "1.3.21",
     description: "Open source connector library - Install API connectors with a single command",
     type: "module",
     bin: {
@@ -33029,8 +33029,29 @@ function redactSecrets(obj) {
   }
   return obj;
 }
+function getOAuthTokenState(name) {
+  const tokens = loadTokens(name);
+  if (!tokens?.accessToken && !tokens?.refreshToken) {
+    return { hasTokens: false, expired: false };
+  }
+  if (!tokens.expiresAt) {
+    return { hasTokens: true, expired: false };
+  }
+  const now3 = Date.now();
+  const isExpired = now3 >= tokens.expiresAt - 60000;
+  const expiresIn = isExpired ? undefined : (() => {
+    const ms = tokens.expiresAt - now3;
+    const mins = Math.floor(ms / 60000);
+    if (mins < 1)
+      return "less than a minute";
+    if (mins < 60)
+      return `${mins}m`;
+    return `${Math.floor(mins / 60)}h ${mins % 60}m`;
+  })();
+  return { hasTokens: true, expired: isExpired, expiresIn };
+}
 function registerCommands4(program2) {
-  program2.command("auth").argument("<connector>", "Connector name to configure auth for").option("-k, --key <value>", "API key or bearer token value (non-interactive)").option("-f, --field <field>", "Which field to set (for multi-field connectors)").option("--json", "Output as JSON", false).description("Configure authentication for a connector").action(async (connector, options) => {
+  program2.command("auth").argument("<connector>", "Connector name to configure auth for").option("-k, --key <value>", "API key or bearer token value (non-interactive)").option("-f, --field <field>", "Which field to set (for multi-field connectors)").option("--json", "Output as JSON", false).option("--no-browser", "Print OAuth URL without opening a browser (agent-friendly)", false).option("--refresh", "Refresh expired OAuth tokens", false).option("--port <port>", "OAuth server port (default: 9876)", "9876").description("Configure authentication for a connector").action(async (connector, options) => {
     const meta = getConnector(connector);
     if (!meta) {
       if (options.json) {
@@ -33044,6 +33065,39 @@ function registerCommands4(program2) {
     }
     const authType = getAuthType(connector);
     const statusBefore = getAuthStatus(connector);
+    if (options.refresh) {
+      if (authType !== "oauth") {
+        if (options.json) {
+          console.log(JSON.stringify({ error: `${connector} does not use OAuth. Refresh is only available for OAuth connectors.` }));
+        } else {
+          console.log(chalk5.red(`${meta.displayName} does not use OAuth. Refresh is only available for OAuth connectors.`));
+        }
+        process.exit(1);
+        return;
+      }
+      try {
+        const tokens = await refreshOAuthToken(connector);
+        if (options.json) {
+          console.log(JSON.stringify({ success: true, connector, tokenType: tokens.tokenType, scope: tokens.scope, expiresAt: tokens.expiresAt }));
+        } else {
+          console.log(chalk5.green(`
+\u2713 Refreshed ${meta.displayName} tokens.`));
+          console.log(chalk5.dim(`  Expires: ${new Date(tokens.expiresAt).toLocaleString()}`));
+        }
+        process.exit(0);
+        return;
+      } catch (err) {
+        if (options.json) {
+          console.log(JSON.stringify({ error: `Refresh failed: ${err instanceof Error ? err.message : String(err)}` }));
+        } else {
+          console.log(chalk5.red(`
+\u2717 Refresh failed: ${err instanceof Error ? err.message : String(err)}`));
+          console.log(chalk5.dim("You may need to re-authenticate."));
+        }
+        process.exit(1);
+        return;
+      }
+    }
     if (!options.json) {
       const statusLabel = statusBefore.configured ? chalk5.green("configured") : chalk5.red("not configured");
       console.log(chalk5.bold(`
@@ -33051,6 +33105,14 @@ ${meta.displayName} \u2014 Auth Configuration
 `));
       console.log(`  Auth type: ${authType === "oauth" ? "OAuth" : authType === "apikey" ? "API Key" : "Bearer Token"}`);
       console.log(`  Status:    ${statusLabel}`);
+      if (authType === "oauth" && statusBefore.configured) {
+        const tokenState = getOAuthTokenState(connector);
+        if (tokenState.hasTokens && !tokenState.expired) {
+          console.log(`  Token:     ${chalk5.green("valid")} (expires in ${tokenState.expiresIn})`);
+        } else if (tokenState.hasTokens && tokenState.expired) {
+          console.log(`  Token:     ${chalk5.yellow("expired")} (run 'connectors auth ${connector} --refresh' or re-authenticate)`);
+        }
+      }
       const envVars2 = getEnvVars(connector);
       if (envVars2.length > 0) {
         console.log(`  Fields:    ${envVars2.map((v) => v.variable).join(", ")}`);
@@ -33058,23 +33120,115 @@ ${meta.displayName} \u2014 Auth Configuration
       console.log();
     }
     if (authType === "oauth") {
+      const tokenState = getOAuthTokenState(connector);
+      if (tokenState.hasTokens && !tokenState.expired) {
+        if (options.json) {
+          console.log(JSON.stringify({ connector, authType: "oauth", status: "authenticated", message: `Tokens are valid and not expired.` }));
+        } else {
+          console.log(chalk5.green(`
+\u2713 ${meta.displayName} is already authenticated (tokens valid, expires in ${tokenState.expiresIn}).`));
+          console.log(chalk5.dim(`Use --refresh to renew tokens, or re-run auth to re-authenticate.`));
+        }
+        process.exit(0);
+        return;
+      }
+      if (tokenState.hasTokens && tokenState.expired) {
+        if (!options.json) {
+          console.log(chalk5.dim("Tokens expired \u2014 attempting auto-refresh..."));
+        }
+        try {
+          const tokens = await refreshOAuthToken(connector);
+          if (options.json) {
+            console.log(JSON.stringify({ connector, authType: "oauth", status: "refreshed", expiresAt: tokens.expiresAt }));
+          } else {
+            console.log(chalk5.green(`
+\u2713 Refreshed ${meta.displayName} tokens.`));
+            console.log(chalk5.dim(`  Expires: ${new Date(tokens.expiresAt).toLocaleString()}`));
+          }
+          process.exit(0);
+          return;
+        } catch {
+          if (!options.json) {
+            console.log(chalk5.yellow("Auto-refresh failed. Proceeding with OAuth flow..."));
+            console.log();
+          }
+        }
+      }
       if (options.json) {
+        const port2 = parseInt(options.port, 10) || 9876;
+        const oauthUrl2 = `http://localhost:${port2}/oauth/${connector}/start`;
         console.log(JSON.stringify({
           connector,
           authType: "oauth",
-          message: "OAuth connectors require browser-based authentication. Use 'connectors serve' or pass --key to set tokens manually."
+          message: "OAuth connectors require browser-based authentication. Use 'connectors serve' or pass --key to set tokens manually.",
+          oauthUrl: oauthUrl2
         }));
         process.exit(0);
         return;
       }
       console.log(chalk5.yellow("OAuth connectors require browser-based authentication."));
       console.log();
+      const port = parseInt(options.port, 10) || 9876;
+      const oauthUrl = `http://localhost:${port}/oauth/${connector}/start`;
       try {
-        const port = 9876;
+        if (!options.browser) {
+          console.log(chalk5.dim(`Starting OAuth server on port ${port}...`));
+          const { spawn: spawn4 } = await import("child_process");
+          const scriptPath = process.argv[1];
+          const serverProc = spawn4("node", [scriptPath, "serve", "--port", String(port)], {
+            detached: true,
+            stdio: "ignore"
+          });
+          serverProc.unref();
+          await new Promise((resolve) => setTimeout(resolve, 2000));
+          try {
+            await fetch(`http://localhost:${port}/api/connectors`);
+          } catch {
+            console.log(chalk5.red(`OAuth server failed to start on port ${port}. Is the port already in use?`));
+            console.log(chalk5.dim("Free the port and try again, or use 'connectors serve' for the full dashboard."));
+            process.exit(1);
+            return;
+          }
+          console.log(chalk5.bold(`Open this URL to authenticate:
+`));
+          console.log(`  ${chalk5.cyan(oauthUrl)}
+`);
+          console.log(chalk5.dim("Waiting for authentication to complete..."));
+          const connectorsHome = getConnectorsHome();
+          const connectorDirName = connector.startsWith("connect-") ? connector : `connect-${connector}`;
+          const tokensPath = join20(connectorsHome, connectorDirName, "profiles", "default", "tokens.json");
+          let attempts = 0;
+          const maxAttempts = 360;
+          while (attempts < maxAttempts) {
+            await new Promise((resolve) => setTimeout(resolve, 500));
+            if (existsSync19(tokensPath)) {
+              break;
+            }
+            attempts++;
+            if (attempts % 6 === 0) {
+              process.stdout.write(".");
+            }
+          }
+          try {
+            serverProc.kill("SIGTERM");
+          } catch {}
+          if (attempts >= maxAttempts) {
+            console.log();
+            console.log(chalk5.yellow("Timed out waiting for OAuth callback. The auth may still be in progress."));
+            console.log(chalk5.dim(`Check ${tokensPath} for tokens.`));
+            console.log(chalk5.dim("You can stop the server manually: lsof -ti :${port} | xargs kill"));
+            process.exit(1);
+            return;
+          }
+          console.log();
+          console.log(chalk5.green(`
+\u2713 Connected! ${meta.displayName} is now authenticated.`));
+          process.exit(0);
+          return;
+        }
         const { startServer: startServer2 } = await Promise.resolve().then(() => (init_serve(), exports_serve));
         console.log(chalk5.dim(`Starting temporary server on port ${port}...`));
         await startServer2(port, { open: false, strict: true });
-        const oauthUrl = `http://localhost:${port}/oauth/${connector}/start`;
         console.log(chalk5.bold(`
 Open this URL to authenticate:
 `));
@@ -34271,7 +34425,7 @@ ${meta.displayName} operations:
     }
     process.exit(result.exitCode);
   });
-  program2.command("setup").argument("<name>", "Connector name to set up").option("-k, --key <value>", "API key or bearer token value").option("-f, --field <field>", "Which field to set (for multi-field connectors)").option("-o, --overwrite", "Overwrite existing installation", false).option("--json", "Output as JSON", false).description("Install, configure auth, and verify a connector in one step").action(async (name, options) => {
+  program2.command("setup").argument("<name>", "Connector name to set up").option("-k, --key <value>", "API key or bearer token value").option("-f, --field <field>", "Which field to set (for multi-field connectors)").option("-o, --overwrite", "Overwrite existing installation", false).option("--json", "Output as JSON", false).option("--no-browser", "Print OAuth URL without opening a browser (agent-friendly)", false).description("Install, configure auth, and verify a connector in one step").action(async (name, options) => {
     const meta = getConnector(name);
     if (!meta) {
       if (options.json) {
@@ -34346,11 +34500,63 @@ Setting up ${meta.displayName}...
             return;
           }
           console.log(`  ${chalk7.yellow("\u27F3")} OAuth authentication required \u2014 starting server...`);
+          const port = 9876;
+          const oauthUrl = `http://localhost:${port}/oauth/${name}/start`;
+          if (!options.browser) {
+            console.log(`
+  ${chalk7.bold("Open this URL to authenticate:")}`);
+            console.log(`  ${chalk7.cyan(oauthUrl)}
+`);
+            const { spawn: spawn4 } = await import("child_process");
+            const { getConnectorsHome: getConnectorsHome2 } = await Promise.resolve().then(() => (init_database(), exports_database));
+            const { existsSync: existsSync8 } = await import("fs");
+            const { join: join8 } = await import("path");
+            const scriptPath = process.argv[1];
+            const serverProc = spawn4("node", [scriptPath, "serve", "--port", String(port)], {
+              detached: true,
+              stdio: "ignore"
+            });
+            serverProc.unref();
+            await new Promise((resolve) => setTimeout(resolve, 2000));
+            try {
+              await fetch(`http://localhost:${port}/api/connectors`);
+            } catch {
+              console.log(`  ${chalk7.red("\u2717")} OAuth server failed to start on port ${port}.`);
+              process.exit(1);
+              return;
+            }
+            console.log(chalk7.dim("  Waiting for authentication to complete..."));
+            const connectorsHome = getConnectorsHome2();
+            const connectorDirName = name.startsWith("connect-") ? name : `connect-${name}`;
+            const tokensPath = join8(connectorsHome, connectorDirName, "profiles", "default", "tokens.json");
+            let attempts = 0;
+            const maxAttempts = 360;
+            while (attempts < maxAttempts) {
+              await new Promise((resolve) => setTimeout(resolve, 500));
+              if (existsSync8(tokensPath))
+                break;
+              attempts++;
+              if (attempts % 6 === 0)
+                process.stdout.write(".");
+            }
+            try {
+              serverProc.kill("SIGTERM");
+            } catch {}
+            if (attempts >= maxAttempts) {
+              console.log();
+              console.log(chalk7.yellow("  Timed out waiting for OAuth callback."));
+              process.exit(1);
+              return;
+            }
+            console.log();
+            console.log(`  ${chalk7.green("\u2713")} ${meta.displayName} is now authenticated.`);
+            authConfigured = true;
+            process.exit(0);
+            return;
+          }
           try {
-            const port = 9876;
             const { startServer: startServer2 } = await Promise.resolve().then(() => (init_serve(), exports_serve));
             await startServer2(port, { open: false, strict: true });
-            const oauthUrl = `http://localhost:${port}/oauth/${name}/start`;
             console.log(`
   ${chalk7.bold("Open this URL to authenticate:")}`);
             console.log(`  ${chalk7.cyan(oauthUrl)}

package/bin/mcp.js

@@ -11443,7 +11443,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/connectors",
-    version: "1.3.20",
+    version: "1.3.21",
     description: "Open source connector library - Install API connectors with a single command",
     type: "module",
     bin: {
@@ -24166,16 +24166,16 @@ __export(exports_runner, {
   getConnectorCliPath: () => getConnectorCliPath,
   buildEnvWithCredentials: () => buildEnvWithCredentials
 });
-import { existsSync as existsSync13, readdirSync as readdirSync8 } from "fs";
-import { join as join14, dirname as dirname7 } from "path";
+import { existsSync as existsSync14, readdirSync as readdirSync8 } from "fs";
+import { join as join15, dirname as dirname7 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 function resolveConnectorsDir2() {
-  const fromBin = join14(__dirname5, "..", "connectors");
-  if (existsSync13(fromBin))
+  const fromBin = join15(__dirname5, "..", "connectors");
+  if (existsSync14(fromBin))
     return fromBin;
-  const fromSrc = join14(__dirname5, "..", "..", "connectors");
-  if (existsSync13(fromSrc))
+  const fromSrc = join15(__dirname5, "..", "..", "connectors");
+  if (existsSync14(fromSrc))
     return fromSrc;
   return fromBin;
 }
@@ -24222,9 +24222,9 @@ function buildEnvWithCredentials(connectorName, baseEnv) {
 }
 function getConnectorCliPath(name) {
   const safeName = name.replace(/[^a-z0-9-]/g, "");
-  const connectorDir = join14(CONNECTORS_DIR2, `connect-${safeName}`);
-  const cliPath = join14(connectorDir, "src", "cli", "index.ts");
-  if (existsSync13(cliPath))
+  const connectorDir = join15(CONNECTORS_DIR2, `connect-${safeName}`);
+  const cliPath = join15(connectorDir, "src", "cli", "index.ts");
+  if (existsSync14(cliPath))
     return cliPath;
   return null;
 }
@@ -24263,7 +24263,7 @@ function runLegacyConnectorCommand(name, args, timeoutMs = 30000) {
     });
   }
   return new Promise((resolve) => {
-    const proc = spawn("bun", ["run", cliPath, ...args], {
+    const proc = spawn2("bun", ["run", cliPath, ...args], {
       timeout: timeoutMs,
       env: buildEnvWithCredentials(name, process.env),
       stdio: ["pipe", "pipe", "pipe"]
@@ -39916,7 +39916,9 @@ async function withWriteLock(connector, fn) {
 
 // src/server/auth.ts
 init_database();
+var FETCH_TIMEOUT = 1e4;
 var oauthStateStore = new Map;
+var GOOGLE_TOKEN_URL = "https://oauth2.googleapis.com/token";
 var GOOGLE_SCOPES = {
   gmail: [
     "https://www.googleapis.com/auth/gmail.readonly",
@@ -40125,6 +40127,67 @@ function guessKeyField(name) {
   }
   return "apiKey";
 }
+function getOAuthConfig(name) {
+  const configDir = getConnectorConfigDir(name);
+  const credentialsFile = join13(configDir, "credentials.json");
+  if (existsSync12(credentialsFile)) {
+    try {
+      const creds = JSON.parse(readFileSync6(credentialsFile, "utf-8"));
+      return { clientId: creds.clientId, clientSecret: creds.clientSecret };
+    } catch {}
+  }
+  const config2 = loadProfileConfig(name);
+  return {
+    clientId: config2.clientId,
+    clientSecret: config2.clientSecret
+  };
+}
+function saveOAuthTokens(name, tokens) {
+  const configDir = getConnectorConfigDir(name);
+  const profile = getCurrentProfile2(name);
+  const profileDir = join13(configDir, "profiles", profile);
+  mkdirSync9(profileDir, { recursive: true });
+  const tokensFile = join13(profileDir, "tokens.json");
+  writeFileSync5(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);
+  if (!oauthConfig.clientId || !oauthConfig.clientSecret) {
+    throw new Error("OAuth credentials not configured for " + name);
+  }
+  if (!currentTokens?.refreshToken) {
+    throw new Error("No refresh token available. Please re-authenticate.");
+  }
+  const response = await fetch(GOOGLE_TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      client_id: oauthConfig.clientId,
+      client_secret: oauthConfig.clientSecret,
+      refresh_token: currentTokens.refreshToken,
+      grant_type: "refresh_token"
+    }),
+    signal: AbortSignal.timeout(FETCH_TIMEOUT)
+  });
+  if (!response.ok) {
+    const error2 = await response.json().catch(() => ({ error: response.statusText }));
+    throw new Error(`Token refresh failed: ${error2.error_description || error2.error}`);
+  }
+  const data = await response.json();
+  const tokens = {
+    accessToken: data.access_token,
+    refreshToken: currentTokens.refreshToken,
+    expiresAt: Date.now() + data.expires_in * 1000,
+    tokenType: data.token_type,
+    scope: data.scope || currentTokens.scope
+  };
+  saveOAuthTokens(name, tokens);
+  return tokens;
+}
 
 // src/mcp/tools/management.ts
 function registerManagementTools(server, stripped) {
@@ -40269,6 +40332,10 @@ function registerManagementTools(server, stripped) {
 }
 // src/mcp/tools/auth.ts
 init_zod();
+init_database();
+import { existsSync as existsSync13, readFileSync as readFileSync7 } from "fs";
+import { join as join14 } from "path";
+import { spawn } from "child_process";
 function registerAuthTools(server, stripped) {
   server.registerTool("connector_auth_status", {
     title: "Connector Auth Status",
@@ -40343,6 +40410,146 @@ function registerAuthTools(server, stripped) {
       };
     }
   });
+  server.registerTool("connector_oauth", {
+    title: "Connector OAuth Flow",
+    description: "Start an OAuth authentication flow for a connector. Returns an authorization URL to open in a browser. For non-interactive/agent use, pass noBrowser: true to start a temporary server and wait for tokens automatically.",
+    inputSchema: {
+      name: exports_external.string(),
+      noBrowser: exports_external.boolean().optional().describe("If true, starts a temporary OAuth server and waits for tokens. If false/omitted, returns the URL for browser-based auth."),
+      port: exports_external.number().optional().describe("OAuth server port (default: 9876)"),
+      refresh: exports_external.boolean().optional().describe("If true, attempt to refresh existing OAuth tokens instead of starting a new flow.")
+    }
+  }, async ({ name, noBrowser, port, refresh }) => {
+    const meta = getConnector(name);
+    if (!meta) {
+      return {
+        content: [{ type: "text", text: `Connector '${name}' not found. Use search_connectors or list_connectors to find available connectors.` }],
+        isError: true
+      };
+    }
+    const authType = getAuthType(name);
+    if (authType !== "oauth") {
+      return {
+        content: [{ type: "text", text: `${meta.displayName} does not use OAuth. Use configure_auth instead to set an API key.` }],
+        isError: true
+      };
+    }
+    if (refresh) {
+      try {
+        const tokens2 = await refreshOAuthToken(name);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ success: true, connector: name, action: "refreshed", expiresAt: tokens2.expiresAt, scope: tokens2.scope }, null, 2)
+          }]
+        };
+      } catch (err) {
+        return {
+          content: [{
+            type: "text",
+            text: `Refresh failed: ${err instanceof Error ? err.message : String(err)}. You may need to re-authenticate with a new OAuth flow.`
+          }],
+          isError: true
+        };
+      }
+    }
+    const tokens = loadTokens(name);
+    if (tokens?.accessToken && tokens?.refreshToken) {
+      if (tokens.expiresAt && Date.now() < tokens.expiresAt - 60000) {
+        const mins = Math.floor((tokens.expiresAt - Date.now()) / 60000);
+        const expiresIn = mins < 60 ? `${mins}m` : `${Math.floor(mins / 60)}h ${mins % 60}m`;
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ connector: name, status: "already_authenticated", expiresIn, message: "Tokens are valid. Use refresh: true to renew or re-authenticate to get new tokens." }, null, 2)
+          }]
+        };
+      }
+    }
+    const serverPort = port || 9876;
+    const oauthUrl = `http://localhost:${serverPort}/oauth/${name}/start`;
+    if (noBrowser) {
+      const connectorsHome = getConnectorsHome();
+      const connectorDirName = name.startsWith("connect-") ? name : `connect-${name}`;
+      const tokensPath = join14(connectorsHome, connectorDirName, "profiles", "default", "tokens.json");
+      let serverRunning = false;
+      try {
+        await fetch(`http://localhost:${serverPort}/api/connectors`);
+        serverRunning = true;
+      } catch {}
+      if (!serverRunning) {
+        const scriptPath = process.argv[1];
+        const serverProc = spawn("node", [scriptPath, "serve", "--port", String(serverPort)], {
+          detached: true,
+          stdio: "ignore"
+        });
+        serverProc.unref();
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+      }
+      let attempts = 0;
+      const maxAttempts = 120;
+      while (attempts < maxAttempts) {
+        await new Promise((resolve) => setTimeout(resolve, 500));
+        if (existsSync13(tokensPath)) {
+          break;
+        }
+        attempts++;
+      }
+      if (attempts >= maxAttempts) {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              connector: name,
+              status: "waiting",
+              oauthUrl,
+              message: `OAuth server is running on port ${serverPort}. Open the URL to authenticate. Tokens will be saved to ${tokensPath}.`
+            }, null, 2)
+          }]
+        };
+      }
+      try {
+        const tokenData = JSON.parse(readFileSync7(tokensPath, "utf-8"));
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              success: true,
+              connector: name,
+              status: "authenticated",
+              tokenType: tokenData.tokenType || "Bearer",
+              scope: tokenData.scope
+            }, null, 2)
+          }]
+        };
+      } catch {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              connector: name,
+              status: "tokens_file_found",
+              message: "Token file was created but could not be parsed."
+            }, null, 2)
+          }],
+          isError: true
+        };
+      }
+    } else {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            connector: name,
+            status: "auth_required",
+            authType: "oauth",
+            oauthUrl,
+            message: `Open this URL in a browser to authenticate. After completing the OAuth flow, tokens will be saved automatically.`
+          }, null, 2)
+        }]
+      };
+    }
+  });
 }
 // src/mcp/tools/operations.ts
 init_zod();
@@ -40621,7 +40828,7 @@ function listWorkflows(db) {
 }
 
 // src/lib/workflow-runner.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 async function runStep(step, previousOutput) {
   return new Promise((resolve) => {
     const args = [...step.args ?? []];
@@ -40629,7 +40836,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 = spawn3("connectors", cmdArgs, { shell: false });
     let output = "";
     proc.stdout.on("data", (d) => {
       output += d.toString();
@@ -40671,11 +40878,11 @@ async function runWorkflow(workflow) {
 }
 
 // src/lib/scheduler.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 async function runConnectorCommand2(connector, command, args) {
   return new Promise((resolve) => {
     const cmdArgs = [connector, command, ...args, "--format", "json"];
-    const proc = spawn3("connectors", ["run", ...cmdArgs], { shell: false });
+    const proc = spawn4("connectors", ["run", ...cmdArgs], { shell: false });
     let output = "";
     proc.stdout.on("data", (d) => {
       output += d.toString();

package/bin/serve.js

@@ -15160,7 +15160,7 @@ var githubConnector = defineConnector({
 // package.json
 var package_default = {
   name: "@hasna/connectors",
-  version: "1.3.20",
+  version: "1.3.21",
   description: "Open source connector library - Install API connectors with a single command",
   type: "module",
   bin: {

package/dist/index.js

@@ -4969,7 +4969,7 @@ var githubConnector = defineConnector({
 // package.json
 var package_default = {
   name: "@hasna/connectors",
-  version: "1.3.20",
+  version: "1.3.21",
   description: "Open source connector library - Install API connectors with a single command",
   type: "module",
   bin: {

package/dist/server/auth.d.ts

@@ -28,6 +28,10 @@ export interface OAuthTokens {
  * Get the auth type for a connector by parsing its CLAUDE.md
  */
 export declare function getAuthType(name: string): AuthType;
+/**
+ * Load OAuth tokens for a connector
+ */
+export declare function loadTokens(name: string): OAuthTokens | null;
 /**
  * Get the full auth status for a connector
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/connectors",
-  "version": "1.3.20",
+  "version": "1.3.22",
   "description": "Open source connector library - Install API connectors with a single command",
   "type": "module",
   "bin": {