@moretea-labs/forge 1.7.2 → 1.8.1

package/adapters/mcp/oauth.ts

@@ -0,0 +1,464 @@
+import { randomUUID } from 'crypto';
+import {
+  chmodSync,
+  closeSync,
+  existsSync,
+  fsyncSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from 'fs';
+import { dirname } from 'path';
+import type { AuthInfo, OAuthClientInformationFull, OAuthTokenRevocationRequest, OAuthTokens } from "@modelcontextprotocol/server";
+import { InvalidGrantError, InvalidTokenError } from "@modelcontextprotocol/server-legacy/auth";
+import type { OAuthRegisteredClientsStore, AuthorizationParams, OAuthServerProvider } from "@modelcontextprotocol/server-legacy/auth";
+
+interface TokenData {
+  accessTokens?: Record<string, AuthInfo>;
+  refreshTokens?: Record<string, string>;
+  clients?: Record<string, OAuthClientInformationFull>;
+}
+
+export interface McpOAuthClientRetirementResult {
+  clientId: string;
+  clientRemoved: boolean;
+  accessTokensRevoked: number;
+  refreshTokensRevoked: number;
+  orphanRefreshTokensPruned: number;
+  changed: boolean;
+}
+
+export interface McpOAuthProviderClientRetirementResult extends McpOAuthClientRetirementResult {
+  authorizationCodesRevoked: number;
+}
+
+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;
+  }
+
+  retireClient(clientId: string): McpOAuthClientRetirementResult {
+    const normalizedClientId = clientId.trim();
+    if (!normalizedClientId) throw new Error('MCP_OAUTH_CLIENT_ID_REQUIRED');
+
+    const ownedAccessTokens = new Set<string>();
+    for (const [token, info] of this.accessTokens) {
+      if (info.clientId === normalizedClientId) ownedAccessTokens.add(token);
+    }
+
+    let refreshTokensRevoked = 0;
+    let orphanRefreshTokensPruned = 0;
+    for (const [refreshToken, accessToken] of this.refreshTokens) {
+      if (ownedAccessTokens.has(accessToken)) {
+        this.refreshTokens.delete(refreshToken);
+        refreshTokensRevoked += 1;
+        continue;
+      }
+      if (!this.accessTokens.has(accessToken)) {
+        this.refreshTokens.delete(refreshToken);
+        orphanRefreshTokensPruned += 1;
+      }
+    }
+
+    let accessTokensRevoked = 0;
+    for (const token of ownedAccessTokens) {
+      if (this.accessTokens.delete(token)) accessTokensRevoked += 1;
+    }
+    const clientRemoved = this.clients.delete(normalizedClientId);
+    const changed = clientRemoved
+      || accessTokensRevoked > 0
+      || refreshTokensRevoked > 0
+      || orphanRefreshTokensPruned > 0;
+    if (changed) this.flush();
+
+    return {
+      clientId: normalizedClientId,
+      clientRemoved,
+      accessTokensRevoked,
+      refreshTokensRevoked,
+      orphanRefreshTokensPruned,
+      changed,
+    };
+  }
+
+  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 McpOAuthAuthorizationCodeDiagnostics {
+  pending: number;
+  expired: number;
+  evicted: number;
+}
+
+export interface McpOAuthProvider extends OAuthServerProvider {
+  authorizationCodeDiagnostics(): McpOAuthAuthorizationCodeDiagnostics;
+  retireClient(clientId: string): McpOAuthProviderClientRetirementResult;
+}
+
+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 = {},
+): McpOAuthProvider {
+  const authCodes = new Map<string, PendingAuthorizationCode>();
+  let expiredAuthorizationCodes = 0;
+  let evictedAuthorizationCodes = 0;
+  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)) expiredAuthorizationCodes += 1;
+    }
+  };
+
+  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;
+    if (!authCodes.delete(oldest.code)) return false;
+    evictedAuthorizationCodes += 1;
+    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 {
+    authorizationCodeDiagnostics(): McpOAuthAuthorizationCodeDiagnostics {
+      purgeExpiredCodes();
+      return {
+        pending: authCodes.size,
+        expired: expiredAuthorizationCodes,
+        evicted: evictedAuthorizationCodes,
+      };
+    },
+
+    retireClient(clientId: string): McpOAuthProviderClientRetirementResult {
+      const normalizedClientId = clientId.trim();
+      if (!normalizedClientId) throw new Error('MCP_OAUTH_CLIENT_ID_REQUIRED');
+      let authorizationCodesRevoked = 0;
+      for (const [code, pending] of authCodes) {
+        if (pending.clientId === normalizedClientId && authCodes.delete(code)) {
+          authorizationCodesRevoked += 1;
+        }
+      }
+      return {
+        ...store.retireClient(normalizedClientId),
+        authorizationCodesRevoked,
+      };
+    },
+
+    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);
+    },
+  };
+}

package/adapters/mcp/paths.ts

@@ -0,0 +1,143 @@
+import { existsSync, lstatSync, realpathSync } from 'fs';
+import { dirname, isAbsolute, resolve, sep } from 'path';
+import { DEFAULT_PROJECT_ENGINEERING_CONTRACT_PATH } from '../../packages/kernel/work/api/index';
+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;
+  const isControllerProjectEngineeringContract = policy.profile === 'controller'
+    && relativePath === DEFAULT_PROJECT_ENGINEERING_CONTRACT_PATH;
+  if (!isControllerProjectEngineeringContract && 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 };
+}