@adrata/adrata-mcp 1.0.0

package/access/auth.js

@@ -0,0 +1,289 @@
+/**
+ * Authentication and tier detection for Adrata MCP Server.
+ *
+ * Five auth modes (checked in priority order):
+ *   1. ADRATA_OAUTH_TOKEN env var                    -> enterprise tier
+ *   2. Shared agent session (~/.config/adrata/agent.json,
+ *      written by `adrata login` / `@adrata login`)  -> enterprise tier
+ *   3. Stored OAuth tokens (~/.adrata/tokens.json)   -> enterprise tier
+ *   4. ADRATA_API_KEY env var / legacy cli.json      -> pro tier
+ *   5. No credentials                                -> free tier
+ *
+ * The agent store is the primary on-disk session: the Adrata CLI, the @adrata
+ * terminal agent, and this MCP server all read the same file, so one device-flow
+ * sign-in serves all three surfaces. The MCP's own tokens.json (written by
+ * connect_workspace) and the legacy cli.json keep working unchanged.
+ */
+
+import { TIERS, getToolTier, tierSatisfies } from './tiers.js';
+import { loadTokens, getValidToken, OAUTH_SCOPE, describeOAuthScopeCapabilities } from './oauth.js';
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { isAbsolute, resolve, join } from 'node:path';
+
+const DEFAULT_CLI_CONFIG_PATH = join(homedir(), '.config', 'adrata', 'cli.json');
+const DEFAULT_AGENT_CONFIG_PATH = join(homedir(), '.config', 'adrata', 'agent.json');
+
+/**
+ * A relative ADRATA_CONFIG_FILE resolves against $HOME, never the process cwd:
+ * the MCP server's cwd is whatever directory the MCP client launched it from,
+ * so cwd-relative resolution made the same value name a different file than
+ * the CLI saw. (packages/adrata-cli/src/auth.js implements the identical rule.)
+ */
+export function getCliConfigPath() {
+  const override = process.env.ADRATA_CONFIG_FILE?.trim();
+  if (!override) return DEFAULT_CLI_CONFIG_PATH;
+  return isAbsolute(override) ? override : resolve(homedir(), override);
+}
+
+/** Path to the shared agent session store ($ADRATA_AGENT_CONFIG overrides, as in @adrata/agent). */
+export function getAgentConfigPath() {
+  return process.env.ADRATA_AGENT_CONFIG?.trim() || DEFAULT_AGENT_CONFIG_PATH;
+}
+
+export function loadCliConfig() {
+  try {
+    const configPath = getCliConfigPath();
+    if (!existsSync(configPath)) return {};
+    return JSON.parse(readFileSync(configPath, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Read the shared agent session (device-flow OAuth, written by `adrata login`).
+ * Returns { accessToken, apiBase, workspaceId } or null when absent/unusable.
+ */
+export function loadAgentSession() {
+  try {
+    const path = getAgentConfigPath();
+    if (!existsSync(path)) return null;
+    const parsed = JSON.parse(readFileSync(path, 'utf8'));
+    if (!parsed || typeof parsed !== 'object') return null;
+    const str = (key) => (typeof parsed[key] === 'string' && parsed[key] ? parsed[key] : null);
+    const accessToken = str('accessToken');
+    if (!accessToken) return null;
+    return {
+      accessToken,
+      apiBase: str('apiBase')?.replace(/\/+$/, '') ?? null,
+      workspaceId: str('workspaceId'),
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Determine the user's tier from environment / stored tokens / API key.
+ *
+ * Checks (in priority order):
+ *   1. ADRATA_OAUTH_TOKEN env var (enterprise)
+ *   2. Shared agent session — agent.json from `adrata login` (enterprise)
+ *   3. Stored OAuth tokens from connect_workspace flow (enterprise)
+ *   4. ADRATA_API_KEY env var / legacy cli.json token (pro)
+ *   5. No credentials (free)
+ */
+export function authenticate() {
+  const oauthToken = process.env.ADRATA_OAUTH_TOKEN || '';
+  const cliConfig = loadCliConfig();
+  const apiKey = process.env.ADRATA_API_KEY || process.env.ADRATA_API_TOKEN || cliConfig.token || '';
+  const apiUrl = process.env.ADRATA_API_URL || cliConfig.apiUrl || null;
+  const workspaceId = process.env.ADRATA_WORKSPACE_ID || cliConfig.workspaceId || null;
+
+  if (oauthToken) {
+    return {
+      tier: TIERS.ENTERPRISE,
+      token: oauthToken,
+      apiKey,
+      apiUrl,
+      workspaceId,
+      authenticated: true,
+      source: 'env',
+    };
+  }
+
+  // Shared agent session (device-flow OAuth) — the primary on-disk store,
+  // shared with the Adrata CLI and the @adrata terminal agent.
+  const agentSession = loadAgentSession();
+  if (agentSession) {
+    return {
+      tier: TIERS.ENTERPRISE,
+      token: agentSession.accessToken,
+      apiKey,
+      // The agent session is bound to the API that issued it, so its apiBase
+      // outranks a legacy cli.json apiUrl. An explicit ADRATA_API_URL still
+      // wins so the issuer guard can fail closed on a mismatch.
+      apiUrl: process.env.ADRATA_API_URL || agentSession.apiBase || apiUrl || null,
+      workspaceId: agentSession.workspaceId || workspaceId,
+      authenticated: true,
+      source: 'agent_config',
+      issuerApiBase: agentSession.apiBase || null,
+    };
+  }
+
+  // Check for stored OAuth tokens from connect_workspace flow
+  const storedTokens = loadTokens();
+  if (storedTokens && storedTokens.accessToken) {
+    return {
+      tier: TIERS.ENTERPRISE,
+      token: storedTokens.accessToken,
+      apiKey,
+      // A stored session remains bound to the API that issued it. An explicit
+      // configured URL still wins so the existing issuer guard can fail closed
+      // on a mismatch; otherwise persist the connected environment across MCP
+      // process restarts.
+      apiUrl: apiUrl || storedTokens.apiBase || null,
+      workspaceId: storedTokens.workspaceId || workspaceId,
+      authenticated: true,
+      source: 'stored',
+      issuerApiBase: storedTokens.apiBase || null,
+      _storedTokens: storedTokens,
+    };
+  }
+
+  if (apiKey) {
+    return {
+      tier: TIERS.PRO,
+      token: null,
+      apiKey,
+      apiUrl,
+      workspaceId,
+      authenticated: true,
+      source: process.env.ADRATA_API_KEY || process.env.ADRATA_API_TOKEN ? 'api_key' : 'cli_config',
+    };
+  }
+
+  return {
+    tier: TIERS.FREE,
+    token: null,
+    apiKey: null,
+    apiUrl,
+    workspaceId,
+    authenticated: false,
+    source: 'none',
+  };
+}
+
+/**
+ * Re-authenticate after a connect/disconnect event.
+ * Returns a fresh auth context.
+ */
+export function reauthenticate() {
+  return authenticate();
+}
+
+export function assertOAuthIssuerMatchesTarget(authContext, apiBase) {
+  const issuerBound = authContext.source === 'stored' || authContext.source === 'agent_config';
+  if (!issuerBound || !authContext.issuerApiBase) return;
+  const issuer = new URL(authContext.issuerApiBase).origin;
+  const target = new URL(apiBase).origin;
+  if (issuer !== target) {
+    throw new Error(
+      `OAuth session/API mismatch: this session was issued by ${issuer}, but MCP is targeting ${target}. Reconnect to the target workspace or correct ADRATA_API_URL.`,
+    );
+  }
+}
+
+/**
+ * Check whether the current auth context can call a given tool.
+ * Returns { allowed: true } or { allowed: false, response: <MCP response> }.
+ */
+export function checkToolAccess(toolName, authContext) {
+  const requiredTier = getToolTier(toolName);
+
+  if (tierSatisfies(authContext.tier, requiredTier)) {
+    return { allowed: true };
+  }
+
+  // Build a gated response depending on what tier is required
+  if (requiredTier === TIERS.PRO) {
+    return {
+      allowed: false,
+      response: proTeaserResponse(toolName),
+    };
+  }
+
+  if (requiredTier === TIERS.ENTERPRISE) {
+    if (authContext.tier === TIERS.PRO) {
+      return {
+        allowed: false,
+        response: enterprisePromptResponse(toolName),
+      };
+    }
+    // Free tier trying enterprise tool
+    return {
+      allowed: false,
+      response: enterprisePromptResponse(toolName),
+    };
+  }
+
+  // Fallback
+  return {
+    allowed: false,
+    response: proTeaserResponse(toolName),
+  };
+}
+
+/**
+ * Generate a teaser + upgrade CTA for pro-locked tools called from free tier.
+ */
+function proTeaserResponse(toolName) {
+  return {
+    content: [{
+      type: 'text',
+      text: JSON.stringify({
+        tool: toolName,
+        tier_required: 'pro',
+        teaser: `The "${toolName}" tool provides deep intelligence and analytics powered by Adrata's AI engine. This is a preview of what's available with Adrata Pro.`,
+        sample_capabilities: [
+          'Full company and contact intelligence',
+          'Buying intent signals and deal authority mapping',
+          'Pipeline analytics and revenue forecasting',
+          'Competitive intelligence briefs',
+          'Priority Pursuits ranked daily action lists',
+          'Meeting summaries and action items',
+        ],
+        upgrade: {
+          message: 'Upgrade to Adrata Pro to unlock all intelligence tools.',
+          url: 'https://adrata.com/pricing',
+          action: 'Set the ADRATA_API_KEY environment variable to activate Pro features.',
+        },
+      }, null, 2),
+    }],
+  };
+}
+
+/**
+ * Generate a workspace connection prompt for enterprise-locked tools.
+ *
+ * `connect_workspace` requests OAUTH_SCOPE, which is deliberately read-only
+ * (no write or admin scopes) — a machine/OAuth principal cannot complete a
+ * governed write, so the API's scope_guard middleware 403s any write from
+ * this token regardless of the MCP tool tier. This prompt must not promise
+ * "full CRM read/write access" or "administration": that contradicts the
+ * scope connect_workspace is about to request, in the same message that
+ * tells the caller to go run it.
+ */
+function enterprisePromptResponse(toolName) {
+  const grantedAccess = describeOAuthScopeCapabilities(OAUTH_SCOPE);
+  return {
+    content: [{
+      type: 'text',
+      text: JSON.stringify({
+        tool: toolName,
+        tier_required: 'enterprise',
+        message: `The "${toolName}" tool requires a connected Adrata workspace with OAuth authentication.`,
+        grantedByConnecting: grantedAccess.summary,
+        note: grantedAccess.canWrite
+          ? undefined
+          : `Connecting with the default (read-only) grant unlocks this tool's read paths. If "${toolName}" performs a write, the Adrata API rejects it with 403 insufficient_scope until the connection also holds the matching write:* scope. Run connect_workspace with writeAccess:true to request the CRM write scopes; workspace administration still requires a signed-in human session.`,
+        connect: {
+          message: 'Connect your Adrata workspace to unlock enterprise-tier read access.',
+          action: 'Run the connect_workspace tool to authenticate via OAuth, or set the ADRATA_OAUTH_TOKEN environment variable manually.',
+          forWrites: 'Run connect_workspace with writeAccess:true to additionally request CRM write scopes (companies, people, buyer groups, opportunities, actions, tasks).',
+        },
+      }, null, 2),
+    }],
+  };
+}