@moretea-labs/forge 1.7.1 → 1.8.0

package/src/cli/mcp/oauth.ts

@@ -1,375 +1,2 @@
-import { randomUUID } from 'crypto';
-import {
-  chmodSync,
-  closeSync,
-  existsSync,
-  fsyncSync,
-  mkdirSync,
-  openSync,
-  readFileSync,
-  renameSync,
-  rmSync,
-  writeFileSync,
-} from 'fs';
-import { dirname } from 'path';
-import type { OAuthRegisteredClientsStore } from '@modelcontextprotocol/sdk/server/auth/clients.js';
-import { InvalidGrantError, InvalidTokenError } from '@modelcontextprotocol/sdk/server/auth/errors.js';
-import type { AuthorizationParams, OAuthServerProvider } from '@modelcontextprotocol/sdk/server/auth/provider.js';
-import type { AuthInfo } from '@modelcontextprotocol/sdk/server/auth/types.js';
-import type {
-  OAuthClientInformationFull,
-  OAuthTokenRevocationRequest,
-  OAuthTokens,
-} from '@modelcontextprotocol/sdk/shared/auth.js';
-
-interface TokenData {
-  accessTokens?: Record<string, AuthInfo>;
-  refreshTokens?: Record<string, string>;
-  clients?: Record<string, OAuthClientInformationFull>;
-}
-
-function nowSeconds(): number {
-  return Math.floor(Date.now() / 1000);
-}
-
-function issueToken(): string {
-  return randomUUID();
-}
-
-function fsyncFile(path: string): void {
-  const fd = openSync(path, 'r');
-  try { fsyncSync(fd); } finally { closeSync(fd); }
-}
-
-function fsyncDirectory(path: string): void {
-  try {
-    const fd = openSync(path, 'r');
-    try { fsyncSync(fd); } finally { closeSync(fd); }
-  } catch {
-    // Directory fsync is unavailable on some supported platforms/filesystems.
-  }
-}
-
-export class McpOAuthTokenStore implements OAuthRegisteredClientsStore {
-  private accessTokens = new Map<string, AuthInfo>();
-  private refreshTokens = new Map<string, string>();
-  private clients = new Map<string, OAuthClientInformationFull>();
-
-  constructor(private readonly path: string, private readonly fallbackPaths: string[] = []) {}
-
-  load(): void {
-    this.accessTokens.clear();
-    this.refreshTokens.clear();
-    this.clients.clear();
-    let loaded = false;
-    let mergedFallback = false;
-    let primaryCorrupt = false;
-    for (const [index, path] of [this.path, ...this.fallbackPaths].entries()) {
-      if (!existsSync(path)) continue;
-      try {
-        const data = JSON.parse(readFileSync(path, 'utf-8')) as TokenData;
-        const refreshTargets = new Set(Object.values(data.refreshTokens ?? {}));
-        for (const [token, info] of Object.entries(data.accessTokens ?? {})) {
-          if (!info.expiresAt || info.expiresAt > nowSeconds() || refreshTargets.has(token)) {
-            if (index > 0 && !this.accessTokens.has(token)) mergedFallback = true;
-            if (index > 0 && this.accessTokens.has(token)) continue;
-            this.accessTokens.set(token, info);
-          }
-        }
-        for (const [token, accessToken] of Object.entries(data.refreshTokens ?? {})) {
-          if (index > 0 && !this.refreshTokens.has(token)) mergedFallback = true;
-          if (index > 0 && this.refreshTokens.has(token)) continue;
-          this.refreshTokens.set(token, accessToken);
-        }
-        for (const [clientId, client] of Object.entries(data.clients ?? {})) {
-          if (index > 0 && !this.clients.has(clientId)) mergedFallback = true;
-          if (index > 0 && this.clients.has(clientId)) continue;
-          this.clients.set(clientId, client);
-        }
-        loaded = true;
-      } catch (_error) {
-        if (index === 0) primaryCorrupt = true;
-      }
-    }
-    if (primaryCorrupt && !loaded) {
-      throw new Error('MCP_OAUTH_STORE_CORRUPT: primary OAuth state is unreadable and no valid fallback is available');
-    }
-    if (loaded && (mergedFallback || primaryCorrupt)) this.flush();
-  }
-
-  flush(): void {
-    const directory = dirname(this.path);
-    mkdirSync(directory, { recursive: true, mode: 0o700 });
-    chmodSync(directory, 0o700);
-    const data: TokenData = {
-      accessTokens: Object.fromEntries(this.accessTokens),
-      refreshTokens: Object.fromEntries(this.refreshTokens),
-      clients: Object.fromEntries(this.clients),
-    };
-    const temporary = `${this.path}.${process.pid}.${randomUUID()}.tmp`;
-    try {
-      writeFileSync(temporary, `${JSON.stringify(data, null, 2)}\n`, { encoding: 'utf-8', mode: 0o600 });
-      chmodSync(temporary, 0o600);
-      fsyncFile(temporary);
-      renameSync(temporary, this.path);
-      chmodSync(this.path, 0o600);
-      fsyncDirectory(directory);
-    } finally {
-      rmSync(temporary, { force: true });
-    }
-  }
-
-  getClient(clientId: string): OAuthClientInformationFull | undefined {
-    return this.clients.get(clientId);
-  }
-
-  registerClient(client: Omit<OAuthClientInformationFull, 'client_id' | 'client_id_issued_at'>): OAuthClientInformationFull {
-    const candidate = client as Partial<OAuthClientInformationFull>;
-    const full: OAuthClientInformationFull = {
-      ...client,
-      client_id: candidate.client_id ?? randomUUID(),
-      client_id_issued_at: candidate.client_id_issued_at ?? nowSeconds(),
-    };
-    this.clients.set(full.client_id, full);
-    this.flush();
-    return full;
-  }
-
-  getAccessToken(token: string): AuthInfo | undefined {
-    return this.accessTokens.get(token);
-  }
-
-  setAccessToken(token: string, info: AuthInfo): void {
-    this.accessTokens.set(token, info);
-    this.flush();
-  }
-
-  deleteAccessToken(token: string): void {
-    this.accessTokens.delete(token);
-    this.flush();
-  }
-
-  getRefreshToken(token: string): string | undefined {
-    return this.refreshTokens.get(token);
-  }
-
-  setRefreshToken(token: string, accessToken: string): void {
-    this.refreshTokens.set(token, accessToken);
-    this.flush();
-  }
-
-  deleteRefreshToken(token: string): void {
-    this.refreshTokens.delete(token);
-    this.flush();
-  }
-
-  findRefreshTokenByAccessToken(accessToken: string): string | undefined {
-    for (const [refreshToken, storedAccessToken] of this.refreshTokens) {
-      if (storedAccessToken === accessToken) return refreshToken;
-    }
-    return undefined;
-  }
-
-  setTokenPair(accessToken: string, info: AuthInfo, refreshToken: string): void {
-    this.accessTokens.set(accessToken, info);
-    this.refreshTokens.set(refreshToken, accessToken);
-    this.flush();
-  }
-
-  rotateRefreshToken(
-    previousRefreshToken: string,
-    nextRefreshToken: string,
-    accessToken: string,
-    info: AuthInfo,
-  ): void {
-    this.refreshTokens.delete(previousRefreshToken);
-    this.accessTokens.set(accessToken, info);
-    this.refreshTokens.set(nextRefreshToken, accessToken);
-    this.flush();
-  }
-
-  revokeToken(token: string): void {
-    const linkedAccessToken = this.refreshTokens.get(token);
-    if (linkedAccessToken) {
-      this.refreshTokens.delete(token);
-      this.accessTokens.delete(linkedAccessToken);
-      for (const [refreshToken, accessToken] of this.refreshTokens) {
-        if (accessToken === linkedAccessToken) this.refreshTokens.delete(refreshToken);
-      }
-      this.flush();
-      return;
-    }
-
-    this.accessTokens.delete(token);
-    for (const [refreshToken, accessToken] of this.refreshTokens) {
-      if (accessToken === token) this.refreshTokens.delete(refreshToken);
-    }
-    this.flush();
-  }
-}
-
-interface PendingAuthorizationCode {
-  challenge: string;
-  clientId: string;
-  issuedAt: number;
-  expiresAt: number;
-}
-
-export interface McpOAuthProviderOptions {
-  now?: () => number;
-  authorizationCodeTtlSeconds?: number;
-  maxPendingAuthorizationCodes?: number;
-  maxPendingAuthorizationCodesPerClient?: number;
-}
-
-const DEFAULT_AUTHORIZATION_CODE_TTL_SECONDS = 10 * 60;
-const DEFAULT_MAX_PENDING_AUTHORIZATION_CODES = 512;
-const DEFAULT_MAX_PENDING_AUTHORIZATION_CODES_PER_CLIENT = 32;
-
-export function createMcpOAuthProvider(
-  store: McpOAuthTokenStore,
-  options: McpOAuthProviderOptions = {},
-): OAuthServerProvider {
-  const authCodes = new Map<string, PendingAuthorizationCode>();
-  const currentTime = options.now ?? nowSeconds;
-  const ttlSeconds = Math.max(30, Math.trunc(options.authorizationCodeTtlSeconds ?? DEFAULT_AUTHORIZATION_CODE_TTL_SECONDS));
-  const globalLimit = Math.max(8, Math.trunc(options.maxPendingAuthorizationCodes ?? DEFAULT_MAX_PENDING_AUTHORIZATION_CODES));
-  const clientLimit = Math.max(2, Math.min(globalLimit, Math.trunc(
-    options.maxPendingAuthorizationCodesPerClient ?? DEFAULT_MAX_PENDING_AUTHORIZATION_CODES_PER_CLIENT,
-  )));
-
-  const purgeExpiredCodes = (now = currentTime()): void => {
-    for (const [code, pending] of authCodes) {
-      if (pending.expiresAt <= now) authCodes.delete(code);
-    }
-  };
-
-  const evictOldest = (predicate: (entry: PendingAuthorizationCode) => boolean): boolean => {
-    let oldest: { code: string; issuedAt: number } | undefined;
-    for (const [code, pending] of authCodes) {
-      if (!predicate(pending)) continue;
-      if (!oldest || pending.issuedAt < oldest.issuedAt) oldest = { code, issuedAt: pending.issuedAt };
-    }
-    if (!oldest) return false;
-    authCodes.delete(oldest.code);
-    return true;
-  };
-
-  const reserveAuthorizationCodeCapacity = (clientId: string, now: number): void => {
-    purgeExpiredCodes(now);
-    while ([...authCodes.values()].filter((pending) => pending.clientId === clientId).length >= clientLimit) {
-      if (!evictOldest((pending) => pending.clientId === clientId)) break;
-    }
-    while (authCodes.size >= globalLimit) {
-      if (!evictOldest(() => true)) break;
-    }
-  };
-
-  const pendingAuthorizationCode = (
-    client: OAuthClientInformationFull,
-    authorizationCode: string,
-  ): PendingAuthorizationCode => {
-    const now = currentTime();
-    purgeExpiredCodes(now);
-    const stored = authCodes.get(authorizationCode);
-    if (!stored || stored.clientId !== client.client_id || stored.expiresAt <= now) {
-      if (stored?.expiresAt !== undefined && stored.expiresAt <= now) authCodes.delete(authorizationCode);
-      throw new InvalidGrantError('Invalid authorization code');
-    }
-    return stored;
-  };
-
-  return {
-    get clientsStore(): OAuthRegisteredClientsStore {
-      return store;
-    },
-
-    async authorize(client: OAuthClientInformationFull, params: AuthorizationParams, res): Promise<void> {
-      const now = currentTime();
-      reserveAuthorizationCodeCapacity(client.client_id, now);
-      const code = issueToken();
-      authCodes.set(code, {
-        challenge: params.codeChallenge,
-        clientId: client.client_id,
-        issuedAt: now,
-        expiresAt: now + ttlSeconds,
-      });
-      const redirectUrl = new URL(params.redirectUri);
-      redirectUrl.searchParams.set('code', code);
-      if (params.state) redirectUrl.searchParams.set('state', params.state);
-      res.redirect(302, redirectUrl.toString());
-    },
-
-    async challengeForAuthorizationCode(client: OAuthClientInformationFull, authorizationCode: string): Promise<string> {
-      return pendingAuthorizationCode(client, authorizationCode).challenge;
-    },
-
-    async exchangeAuthorizationCode(
-      client: OAuthClientInformationFull,
-      authorizationCode: string,
-      _codeVerifier?: string,
-    ): Promise<OAuthTokens> {
-      pendingAuthorizationCode(client, authorizationCode);
-      // Delete before issuing credentials. A failed downstream persistence is
-      // retried as a new OAuth flow rather than making an authorization code
-      // replayable after a partial token response.
-      authCodes.delete(authorizationCode);
-      const accessToken = issueToken();
-      const refreshToken = issueToken();
-      const expiresIn = 30 * 24 * 60 * 60;
-      const expiresAt = nowSeconds() + expiresIn;
-      store.setTokenPair(accessToken, {
-        token: accessToken,
-        clientId: client.client_id,
-        scopes: ['forge'],
-        expiresAt,
-      }, refreshToken);
-      return {
-        access_token: accessToken,
-        token_type: 'Bearer',
-        expires_in: expiresIn,
-        refresh_token: refreshToken,
-        scope: 'forge',
-      };
-    },
-
-    async exchangeRefreshToken(client: OAuthClientInformationFull, refreshToken: string): Promise<OAuthTokens> {
-      const accessToken = store.getRefreshToken(refreshToken);
-      const existing = accessToken ? store.getAccessToken(accessToken) : undefined;
-      if (!accessToken || !existing || existing.clientId !== client.client_id) {
-        throw new InvalidGrantError('Invalid refresh token');
-      }
-      const nextRefreshToken = issueToken();
-      const expiresIn = 30 * 24 * 60 * 60;
-      store.rotateRefreshToken(
-        refreshToken,
-        nextRefreshToken,
-        accessToken,
-        { ...existing, expiresAt: nowSeconds() + expiresIn },
-      );
-      return {
-        access_token: accessToken,
-        token_type: 'Bearer',
-        expires_in: expiresIn,
-        refresh_token: nextRefreshToken,
-        scope: existing.scopes.join(' '),
-      };
-    },
-
-    async verifyAccessToken(token: string): Promise<AuthInfo> {
-      const info = store.getAccessToken(token);
-      if (!info) throw new InvalidTokenError('Token not found');
-      if (info.expiresAt && info.expiresAt < nowSeconds()) {
-        if (!store.findRefreshTokenByAccessToken(token)) {
-          store.deleteAccessToken(token);
-        }
-        throw new InvalidTokenError('Token has expired');
-      }
-      return info;
-    },
-
-    async revokeToken(_client: OAuthClientInformationFull, request: OAuthTokenRevocationRequest): Promise<void> {
-      store.revokeToken(request.token);
-    },
-  };
-}
+/** @deprecated Kernel V2 compatibility shim. MCP OAuth transport authority lives in adapters/mcp. */
+export * from '../../../adapters/mcp/oauth';

package/src/cli/mcp/openai-secure-tunnel.ts

@@ -0,0 +1,2 @@
+/** @deprecated Kernel V2 compatibility shim. MCP auth/setup transport details live in adapters/mcp. */
+export * from '../../../adapters/mcp/tunnels/openai-secure-tunnel';

package/src/cli/mcp/paths.ts

@@ -1,140 +1,2 @@
-import { existsSync, lstatSync, realpathSync } from 'fs';
-import { dirname, isAbsolute, resolve, sep } from 'path';
-import type { McpPathDecision, McpPathIntent, McpPolicy } from './types';
-
-function toPosixPath(value: string): string {
-  return value.split(sep).join('/').replace(/\\+/g, '/');
-}
-
-export function normalizeMcpRelativePath(input: string): McpPathDecision {
-  const trimmed = input.trim();
-  if (trimmed.length === 0) return { ok: false, reason: 'path is required' };
-  if (isAbsolute(trimmed)) return { ok: false, reason: 'absolute paths are not allowed' };
-  const normalized = toPosixPath(trimmed).replace(/^\.\/+/, '');
-  if (normalized === '' || normalized === '.') return { ok: false, reason: 'path must target a file' };
-  if (normalized.split('/').some((part) => part === '..')) {
-    return { ok: false, reason: 'path traversal is not allowed' };
-  }
-  return { ok: true, relativePath: normalized };
-}
-
-function escapeRegex(value: string): string {
-  return value.replace(/[.+^${}()|[\]\\]/g, '\\$&');
-}
-
-export function globMatches(pattern: string, relativePath: string): boolean {
-  const normalizedPattern = toPosixPath(pattern.trim()).replace(/^\.\/+/, '').replace(/\/{2,}/g, '/');
-  const normalizedPath = toPosixPath(relativePath).replace(/^\.\/+/, '').replace(/\/{2,}/g, '/').replace(/\/$/, '');
-  if (normalizedPattern === '**' || normalizedPattern === '**/*') return true;
-  let expression = '';
-  for (let index = 0; index < normalizedPattern.length; index += 1) {
-    const char = normalizedPattern[index];
-    const next = normalizedPattern[index + 1];
-    if (char === '*' && next === '*') {
-      const after = normalizedPattern[index + 2];
-      if (after === '/') {
-        // Globstar directory prefixes match zero or more path segments.
-        expression += '(?:.*/)?';
-        index += 2;
-      } else {
-        expression += '.*';
-        index += 1;
-      }
-    } else if (char === '*') {
-      expression += '[^/]*';
-    } else if (char === '?') {
-      expression += '[^/]';
-    } else if (char === '{') {
-      const close = normalizedPattern.indexOf('}', index + 1);
-      if (close > index) {
-        const alternatives = normalizedPattern.slice(index + 1, close).split(',').map((part) => escapeRegex(part));
-        expression += `(?:${alternatives.join('|')})`;
-        index = close;
-      } else {
-        expression += '\\{';
-      }
-    } else {
-      expression += escapeRegex(char);
-    }
-  }
-  return new RegExp(`^${expression}/?$`).test(normalizedPath);
-}
-function anyGlobMatches(patterns: string[], relativePath: string): boolean {
-  return patterns.some((pattern) => globMatches(pattern, relativePath));
-}
-
-function denyGlobMatches(pattern: string, relativePath: string): boolean {
-  if (globMatches(pattern, relativePath)) return true;
-  if (!pattern.includes('/')) {
-    return relativePath.split('/').some((segment) => globMatches(pattern, segment));
-  }
-  if (!pattern.startsWith('**/')) {
-    return globMatches(`**/${pattern}`, relativePath);
-  }
-  return false;
-}
-
-function anyDenyGlobMatches(patterns: string[], relativePath: string): boolean {
-  return patterns.some((pattern) => denyGlobMatches(pattern, relativePath));
-}
-
-function realpathInside(child: string, parent: string): boolean {
-  const normalizedParent = parent.endsWith(sep) ? parent : `${parent}${sep}`;
-  return child === parent || child.startsWith(normalizedParent);
-}
-
-function nearestExistingPath(path: string): string | undefined {
-  let current = path;
-  while (!existsSync(current)) {
-    const parent = dirname(current);
-    if (parent === current) return undefined;
-    current = parent;
-  }
-  return current;
-}
-
-export function resolveMcpPath(
-  repoRoot: string,
-  inputPath: string,
-  policy: McpPolicy,
-  intent: McpPathIntent,
-  canonicalRepoRoot?: string,
-): McpPathDecision {
-  const normalized = normalizeMcpRelativePath(inputPath);
-  if (!normalized.ok || !normalized.relativePath) return normalized;
-
-  const relativePath = normalized.relativePath;
-  if (anyDenyGlobMatches(policy.denyGlobs, relativePath)) {
-    return { ok: false, relativePath, reason: `path is denied by MCP policy: ${relativePath}` };
-  }
-
-  const allowGlobs = intent === 'read' ? policy.readGlobs : policy.writeGlobs;
-  if (!anyGlobMatches(allowGlobs, relativePath)) {
-    return { ok: false, relativePath, reason: `path is not allowed for ${intent}: ${relativePath}` };
-  }
-
-  const repoRealpath = canonicalRepoRoot ?? realpathSync(repoRoot);
-  const absolutePath = resolve(repoRealpath, relativePath);
-  if (intent === 'read' && !existsSync(absolutePath)) {
-    return { ok: false, relativePath, reason: `path does not exist: ${relativePath}` };
-  }
-
-  const existingPath = existsSync(absolutePath) ? absolutePath : nearestExistingPath(dirname(absolutePath));
-  if (!existingPath) {
-    return { ok: false, relativePath, reason: `path cannot be resolved: ${relativePath}` };
-  }
-
-  const realExistingPath = realpathSync(existingPath);
-  if (!realpathInside(realExistingPath, repoRealpath)) {
-    return { ok: false, relativePath, reason: `path escapes repository root: ${relativePath}` };
-  }
-
-  if (existsSync(absolutePath) && lstatSync(absolutePath).isSymbolicLink()) {
-    const realTarget = realpathSync(absolutePath);
-    if (!realpathInside(realTarget, repoRealpath)) {
-      return { ok: false, relativePath, reason: `symlink escapes repository root: ${relativePath}` };
-    }
-  }
-
-  return { ok: true, relativePath, absolutePath };
-}
+/** @deprecated Kernel V2 compatibility shim. MCP adapter owns this surface. */
+export * from '../../../adapters/mcp/paths';