@gemini-designer/mcp-server 0.1.2 → 0.1.29

package/src/context/grounding.ts

@@ -16,134 +16,140 @@ import * as path from 'node:path';
 import { Config } from '../config/index.js';
 import { detectUiStack, type StackDetectionResult } from '../stack/detect.js';
 import { walkFiles, toPosixPath } from '../utils/walk.js';
-import { buildComponentCatalog, type CatalogResult, type ComponentExport } from '../components/catalog.js';
+import {
+  buildComponentCatalog,
+  type CatalogResult,
+  type ComponentExport,
+} from '../components/catalog.js';
 
 type Cached = {
-    ts: number;
-    stack: StackDetectionResult;
-    catalog: CatalogResult;
+  ts: number;
+  stack: StackDetectionResult;
+  catalog: CatalogResult;
 };
 
 const CACHE_TTL_MS = 60_000;
 const cache = new Map<string, Cached>();
 
 function resolveRootForFile(absFile: string | null, config: Config): string {
-    const allowed = (config.allowedPaths || []).map((p) => path.resolve(p));
-    const fallback = allowed[0] || process.cwd();
-    if (!absFile) return fallback;
+  const allowed = (config.allowedPaths || []).map((p) => path.resolve(p));
+  const fallback = allowed[0] || process.cwd();
+  if (!absFile) return fallback;
 
-    const abs = path.resolve(absFile);
+  const abs = path.resolve(absFile);
 
-    // pick the deepest allowed root that contains the file
-    const matches = allowed
-        .filter((root) => abs === root || abs.startsWith(root + path.sep))
-        .sort((a, b) => b.length - a.length);
+  // pick the deepest allowed root that contains the file
+  const matches = allowed
+    .filter((root) => abs === root || abs.startsWith(root + path.sep))
+    .sort((a, b) => b.length - a.length);
 
-    return matches[0] || fallback;
+  return matches[0] || fallback;
 }
 
 function summarizeStack(stack: StackDetectionResult): string {
-    const summary = {
-        framework: stack.framework,
-        typescript: stack.language.typescript,
-        styling: stack.styling,
-        uiLibraries: stack.uiLibraries,
-        iconLibraries: stack.iconLibraries,
-        tooling: stack.tooling,
-        conventions: {
-            srcDir: stack.conventions.srcDir,
-            hasAppDir: stack.conventions.hasAppDir,
-            hasPagesDir: stack.conventions.hasPagesDir,
-            tsconfigPaths: stack.conventions.tsconfigPaths ? Object.keys(stack.conventions.tsconfigPaths) : undefined,
-        },
-        files: {
-            tailwindConfig: stack.files.tailwindConfig,
-            componentsJson: stack.files.componentsJson,
-            storybookDir: stack.files.storybookDir,
-        },
-        warnings: stack.warnings,
-    };
-    return JSON.stringify(summary, null, 2);
+  const summary = {
+    framework: stack.framework,
+    typescript: stack.language.typescript,
+    styling: stack.styling,
+    uiLibraries: stack.uiLibraries,
+    iconLibraries: stack.iconLibraries,
+    tooling: stack.tooling,
+    conventions: {
+      srcDir: stack.conventions.srcDir,
+      hasAppDir: stack.conventions.hasAppDir,
+      hasPagesDir: stack.conventions.hasPagesDir,
+      tsconfigPaths: stack.conventions.tsconfigPaths
+        ? Object.keys(stack.conventions.tsconfigPaths)
+        : undefined,
+    },
+    files: {
+      tailwindConfig: stack.files.tailwindConfig,
+      componentsJson: stack.files.componentsJson,
+      storybookDir: stack.files.storybookDir,
+    },
+    warnings: stack.warnings,
+  };
+  return JSON.stringify(summary, null, 2);
 }
 
 function tokenizeInstruction(instruction?: string): Set<string> {
-    const set = new Set<string>();
-    if (!instruction) return set;
-    const tokens = instruction.match(/[A-Za-z_][A-Za-z0-9_]*/g) || [];
-    for (const t of tokens) set.add(t.toLowerCase());
-    return set;
+  const set = new Set<string>();
+  if (!instruction) return set;
+  const tokens = instruction.match(/[A-Za-z_][A-Za-z0-9_]*/g) || [];
+  for (const t of tokens) set.add(t.toLowerCase());
+  return set;
 }
 
 function scoreComponent(
-    c: ComponentExport,
-    focusDirRel: string | null,
-    instructionTokens: Set<string>
+  c: ComponentExport,
+  focusDirRel: string | null,
+  instructionTokens: Set<string>
 ): number {
-    let score = 0;
+  let score = 0;
 
-    // Mentioned explicitly in instruction
-    if (instructionTokens.has(c.name.toLowerCase())) score += 8;
+  // Mentioned explicitly in instruction
+  if (instructionTokens.has(c.name.toLowerCase())) score += 8;
 
-    // Same directory as focused file
-    if (focusDirRel && c.file.startsWith(focusDirRel + '/')) score += 6;
+  // Same directory as focused file
+  if (focusDirRel && c.file.startsWith(focusDirRel + '/')) score += 6;
 
-    // Common reusable directories
-    if (
-        c.file.includes('/components/') ||
-        c.file.startsWith('components/') ||
-        c.file.includes('/ui/') ||
-        c.file.includes('/shared/')
-    ) {
-        score += 3;
-    }
+  // Common reusable directories
+  if (
+    c.file.includes('/components/') ||
+    c.file.startsWith('components/') ||
+    c.file.includes('/ui/') ||
+    c.file.includes('/shared/')
+  ) {
+    score += 3;
+  }
 
-    // Prefer TSX
-    if (c.file.endsWith('.tsx')) score += 1;
+  // Prefer TSX
+  if (c.file.endsWith('.tsx')) score += 1;
 
-    return score;
+  return score;
 }
 
 function formatCatalogSubset(catalog: CatalogResult, subset: ComponentExport[]): string {
-    const lines: string[] = [];
-    const header = `scanned_files=${catalog.filesScanned}, total_exports=${catalog.components.length}`;
-    lines.push(header);
-    if (catalog.warnings.length) {
-        lines.push(`warnings: ${catalog.warnings.join(' | ')}`);
-    }
-    lines.push('');
-    lines.push('components:');
-    for (const c of subset) {
-        const extras: string[] = [];
-        if (c.exportType) extras.push(c.exportType);
-        if (c.propsType) extras.push(`props: ${c.propsType}`);
-        if (c.jsDoc) extras.push(`doc: ${c.jsDoc}`);
-        const extra = extras.length ? ` (${extras.join(', ')})` : '';
-        lines.push(`- ${c.name} — ${c.file}${extra}`);
-    }
-    return lines.join('\n');
+  const lines: string[] = [];
+  const header = `scanned_files=${catalog.filesScanned}, total_exports=${catalog.components.length}`;
+  lines.push(header);
+  if (catalog.warnings.length) {
+    lines.push(`warnings: ${catalog.warnings.join(' | ')}`);
+  }
+  lines.push('');
+  lines.push('components:');
+  for (const c of subset) {
+    const extras: string[] = [];
+    if (c.exportType) extras.push(c.exportType);
+    if (c.propsType) extras.push(`props: ${c.propsType}`);
+    if (c.jsDoc) extras.push(`doc: ${c.jsDoc}`);
+    const extra = extras.length ? ` (${extras.join(', ')})` : '';
+    lines.push(`- ${c.name} — ${c.file}${extra}`);
+  }
+  return lines.join('\n');
 }
 
 async function getOrBuildRepoData(root: string): Promise<Cached> {
-    const now = Date.now();
-    const hit = cache.get(root);
-    if (hit && now - hit.ts < CACHE_TTL_MS) return hit;
-
-    const stack = detectUiStack(root);
-    const files = walkFiles(root, {
-        includeExtensions: ['.tsx', '.jsx'],
-        maxFiles: 5000,
-    });
-    const catalog = await buildComponentCatalog(root, files);
-
-    const fresh: Cached = { ts: now, stack, catalog };
-    cache.set(root, fresh);
-    return fresh;
+  const now = Date.now();
+  const hit = cache.get(root);
+  if (hit && now - hit.ts < CACHE_TTL_MS) return hit;
+
+  const stack = detectUiStack(root);
+  const files = walkFiles(root, {
+    includeExtensions: ['.tsx', '.jsx'],
+    maxFiles: 5000,
+  });
+  const catalog = await buildComponentCatalog(root, files);
+
+  const fresh: Cached = { ts: now, stack, catalog };
+  cache.set(root, fresh);
+  return fresh;
 }
 
 export interface RepoGroundingOptions {
-    focusFileAbs?: string;
-    instruction?: string;
-    maxComponents?: number;
+  focusFileAbs?: string;
+  instruction?: string;
+  maxComponents?: number;
 }
 
 /**
@@ -152,40 +158,48 @@ export interface RepoGroundingOptions {
  * This is safe to include in prompts because it contains only local, deterministic
  * project metadata (no secrets).
  */
-export async function buildRepoGrounding(config: Config, options: RepoGroundingOptions = {}): Promise<string> {
-    const maxComponents = typeof options.maxComponents === 'number' ? options.maxComponents : 120;
-
-    const root = resolveRootForFile(options.focusFileAbs ? path.resolve(options.focusFileAbs) : null, config);
-    const data = await getOrBuildRepoData(root);
-
-    const focusRel = options.focusFileAbs ? toPosixPath(path.relative(root, path.resolve(options.focusFileAbs))) : null;
-    const focusDirRel = focusRel ? toPosixPath(path.posix.dirname(focusRel)) : null;
-    const instructionTokens = tokenizeInstruction(options.instruction);
-
-    // Score and select a small subset for reuse.
-    const scored = data.catalog.components
-        .map((c) => ({ c, s: scoreComponent(c, focusDirRel, instructionTokens) }))
-        .sort((a, b) => b.s - a.s);
-
-    const subset: ComponentExport[] = [];
-    const seen = new Set<string>();
-    for (const item of scored) {
-        if (subset.length >= maxComponents) break;
-        const key = `${item.c.name}|${item.c.file}|${item.c.exportType}`;
-        if (seen.has(key)) continue;
-        // Skip ultra-low relevance if we already have enough
-        if (subset.length > 30 && item.s <= 0) break;
-        subset.push(item.c);
-        seen.add(key);
-    }
-
-    return [
-        'AUTO PROJECT CONTEXT (deterministic):',
-        '',
-        'STACK (json):',
-        summarizeStack(data.stack),
-        '',
-        'COMPONENT CATALOG (subset for reuse):',
-        formatCatalogSubset(data.catalog, subset),
-    ].join('\n');
+export async function buildRepoGrounding(
+  config: Config,
+  options: RepoGroundingOptions = {}
+): Promise<string> {
+  const maxComponents = typeof options.maxComponents === 'number' ? options.maxComponents : 120;
+
+  const root = resolveRootForFile(
+    options.focusFileAbs ? path.resolve(options.focusFileAbs) : null,
+    config
+  );
+  const data = await getOrBuildRepoData(root);
+
+  const focusRel = options.focusFileAbs
+    ? toPosixPath(path.relative(root, path.resolve(options.focusFileAbs)))
+    : null;
+  const focusDirRel = focusRel ? toPosixPath(path.posix.dirname(focusRel)) : null;
+  const instructionTokens = tokenizeInstruction(options.instruction);
+
+  // Score and select a small subset for reuse.
+  const scored = data.catalog.components
+    .map((c) => ({ c, s: scoreComponent(c, focusDirRel, instructionTokens) }))
+    .sort((a, b) => b.s - a.s);
+
+  const subset: ComponentExport[] = [];
+  const seen = new Set<string>();
+  for (const item of scored) {
+    if (subset.length >= maxComponents) break;
+    const key = `${item.c.name}|${item.c.file}|${item.c.exportType}`;
+    if (seen.has(key)) continue;
+    // Skip ultra-low relevance if we already have enough
+    if (subset.length > 30 && item.s <= 0) break;
+    subset.push(item.c);
+    seen.add(key);
+  }
+
+  return [
+    'AUTO PROJECT CONTEXT (deterministic):',
+    '',
+    'STACK (json):',
+    summarizeStack(data.stack),
+    '',
+    'COMPONENT CATALOG (subset for reuse):',
+    formatCatalogSubset(data.catalog, subset),
+  ].join('\n');
 }

package/src/context/guards.ts

@@ -14,11 +14,36 @@ import * as path from 'node:path';
 import { Config } from '../config/index.js';
 import { isPathAllowed, isSensitiveFile } from './filter.js';
 
+function isRealPathAllowed(filePath: string, allowedPaths: string[]): boolean {
+  let absPath: string;
+  try {
+    absPath = fs.realpathSync(filePath);
+  } catch {
+    absPath = path.resolve(filePath);
+  }
+
+  for (const allowed of allowedPaths) {
+    let absAllowed: string;
+    try {
+      absAllowed = fs.realpathSync(allowed);
+    } catch {
+      absAllowed = path.resolve(allowed);
+    }
+
+    const rel = path.relative(absAllowed, absPath);
+    if (rel === '' || (!rel.startsWith(`..${path.sep}`) && rel !== '..' && !path.isAbsolute(rel))) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
 /**
  * Resolve a path to an absolute path (relative paths are resolved from process.cwd()).
  */
 export function resolveToAbs(filePath: string): string {
-    return path.isAbsolute(filePath) ? filePath : path.resolve(process.cwd(), filePath);
+  return path.isAbsolute(filePath) ? filePath : path.resolve(process.cwd(), filePath);
 }
 
 /**
@@ -26,26 +51,31 @@ export function resolveToAbs(filePath: string): string {
  * Returns the resolved absolute path.
  */
 export function assertReadablePath(filePath: string, config: Config): string {
-    const absPath = resolveToAbs(filePath);
+  const absPath = resolveToAbs(filePath);
 
-    if (!isPathAllowed(absPath, config.allowedPaths)) {
-        throw new Error(`Path is outside allowedPaths: ${filePath}`);
-    }
+  if (!isPathAllowed(absPath, config.allowedPaths)) {
+    throw new Error(`Path is outside allowedPaths: ${filePath}`);
+  }
 
-    if (isSensitiveFile(absPath)) {
-        throw new Error(`Refusing to read sensitive file: ${filePath}`);
-    }
+  if (isSensitiveFile(absPath)) {
+    throw new Error(`Refusing to read sensitive file: ${filePath}`);
+  }
 
-    if (!fs.existsSync(absPath)) {
-        throw new Error(`File not found: ${filePath}`);
-    }
+  if (!fs.existsSync(absPath)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
 
-    const stat = fs.statSync(absPath);
-    if (!stat.isFile()) {
-        throw new Error(`Not a file: ${filePath}`);
-    }
+  // Prevent symlink escapes (resolve real path and re-check allowedPaths).
+  if (!isRealPathAllowed(absPath, config.allowedPaths)) {
+    throw new Error(`Path resolves outside allowedPaths: ${filePath}`);
+  }
 
-    return absPath;
+  const stat = fs.statSync(absPath);
+  if (!stat.isFile()) {
+    throw new Error(`Not a file: ${filePath}`);
+  }
+
+  return absPath;
 }
 
 /**
@@ -53,17 +83,41 @@ export function assertReadablePath(filePath: string, config: Config): string {
  * Returns the resolved absolute path.
  */
 export function assertWritablePath(filePath: string, config: Config): string {
-    const absPath = resolveToAbs(filePath);
+  const absPath = resolveToAbs(filePath);
 
-    if (!isPathAllowed(absPath, config.allowedPaths)) {
-        throw new Error(`Path is outside allowedPaths: ${filePath}`);
-    }
+  if (!isPathAllowed(absPath, config.allowedPaths)) {
+    throw new Error(`Path is outside allowedPaths: ${filePath}`);
+  }
 
-    if (isSensitiveFile(absPath)) {
-        throw new Error(`Refusing to write to sensitive path: ${filePath}`);
-    }
+  if (isSensitiveFile(absPath)) {
+    throw new Error(`Refusing to write to sensitive path: ${filePath}`);
+  }
 
+  // If the target already exists, disallow writing through symlinks.
+  if (fs.existsSync(absPath)) {
+    const st = fs.lstatSync(absPath);
+    if (st.isSymbolicLink()) {
+      throw new Error(`Refusing to write through symlink: ${filePath}`);
+    }
+    if (!isRealPathAllowed(absPath, config.allowedPaths)) {
+      throw new Error(`Path resolves outside allowedPaths: ${filePath}`);
+    }
     return absPath;
+  }
+
+  // If the file doesn't exist yet, validate the closest existing parent directory.
+  let parent = path.dirname(absPath);
+  while (parent !== path.dirname(parent) && !fs.existsSync(parent)) {
+    parent = path.dirname(parent);
+  }
+  if (!fs.existsSync(parent)) {
+    throw new Error(`Parent directory not found for path: ${filePath}`);
+  }
+  if (!isRealPathAllowed(parent, config.allowedPaths)) {
+    throw new Error(`Parent directory resolves outside allowedPaths: ${filePath}`);
+  }
+
+  return absPath;
 }
 
 /**
@@ -71,24 +125,29 @@ export function assertWritablePath(filePath: string, config: Config): string {
  * Returns the resolved absolute path.
  */
 export function assertReadableDir(dirPath: string, config: Config): string {
-    const absPath = resolveToAbs(dirPath);
+  const absPath = resolveToAbs(dirPath);
 
-    if (!isPathAllowed(absPath, config.allowedPaths)) {
-        throw new Error(`Path is outside allowedPaths: ${dirPath}`);
-    }
+  if (!isPathAllowed(absPath, config.allowedPaths)) {
+    throw new Error(`Path is outside allowedPaths: ${dirPath}`);
+  }
 
-    if (isSensitiveFile(absPath)) {
-        throw new Error(`Refusing to read sensitive directory: ${dirPath}`);
-    }
+  if (isSensitiveFile(absPath)) {
+    throw new Error(`Refusing to read sensitive directory: ${dirPath}`);
+  }
 
-    if (!fs.existsSync(absPath)) {
-        throw new Error(`Directory not found: ${dirPath}`);
-    }
+  if (!fs.existsSync(absPath)) {
+    throw new Error(`Directory not found: ${dirPath}`);
+  }
 
-    const stat = fs.statSync(absPath);
-    if (!stat.isDirectory()) {
-        throw new Error(`Not a directory: ${dirPath}`);
-    }
+  // Prevent symlink escapes.
+  if (!isRealPathAllowed(absPath, config.allowedPaths)) {
+    throw new Error(`Path resolves outside allowedPaths: ${dirPath}`);
+  }
 
-    return absPath;
+  const stat = fs.statSync(absPath);
+  if (!stat.isDirectory()) {
+    throw new Error(`Not a directory: ${dirPath}`);
+  }
+
+  return absPath;
 }

package/src/context/repo-hints.ts

@@ -13,31 +13,31 @@ import { Config } from '../config/index.js';
 import { detectUiStack } from '../stack/detect.js';
 
 export function buildRepoHints(config: Config, rootDir: string = process.cwd()): string {
-    try {
-        const stack = detectUiStack(rootDir);
+  try {
+    const stack = detectUiStack(rootDir);
 
-        const hints = {
-            root: path.basename(stack.root),
-            framework: stack.framework,
-            typescript: stack.language.typescript,
-            styling: stack.styling,
-            uiLibraries: stack.uiLibraries,
-            iconLibraries: stack.iconLibraries,
-            tooling: stack.tooling,
-            conventions: {
-                srcDir: stack.conventions.srcDir,
-                hasAppDir: stack.conventions.hasAppDir,
-                hasPagesDir: stack.conventions.hasPagesDir,
-                tsconfigPaths: stack.conventions.tsconfigPaths,
-            },
-        };
+    const hints = {
+      root: path.basename(stack.root),
+      framework: stack.framework,
+      typescript: stack.language.typescript,
+      styling: stack.styling,
+      uiLibraries: stack.uiLibraries,
+      iconLibraries: stack.iconLibraries,
+      tooling: stack.tooling,
+      conventions: {
+        srcDir: stack.conventions.srcDir,
+        hasAppDir: stack.conventions.hasAppDir,
+        hasPagesDir: stack.conventions.hasPagesDir,
+        tsconfigPaths: stack.conventions.tsconfigPaths,
+      },
+    };
 
-        return `REPO_HINTS (deterministic):\n${JSON.stringify(hints, null, 2)}`;
-    } catch (error) {
-        if (config.debug) {
-            const msg = error instanceof Error ? error.message : 'unknown error';
-            console.error('[repo-hints] Failed to detect stack:', msg);
-        }
-        return '';
+    return `REPO_HINTS (deterministic):\n${JSON.stringify(hints, null, 2)}`;
+  } catch (error) {
+    if (config.debug) {
+      const msg = error instanceof Error ? error.message : 'unknown error';
+      console.error('[repo-hints] Failed to detect stack:', msg);
     }
+    return '';
+  }
 }