@gemini-designer/mcp-server 0.1.2 → 0.1.29

package/src/__tests__/remote-client.test.ts

@@ -0,0 +1,179 @@
+import http from 'node:http';
+import { describe, expect, it } from 'vitest';
+
+import type { Config } from '../config/index.js';
+import { checkQuota, generateWithRemote } from '../generation/remote-client.js';
+
+function getTestConfig(remoteEndpoint: string): Config {
+  return {
+    mode: 'remote',
+    localProvider: 'litellm',
+    apiKey: undefined,
+    remoteEndpoint,
+    remoteApiKey: 'test-api-key',
+    allowedPaths: [process.cwd()],
+    defaultFramework: 'react',
+    model: 'gemini-2.5-flash',
+    litellmEndpoint: undefined,
+    litellmApiKey: undefined,
+    litellmModel: undefined,
+    accessibility: 'wcag-aa',
+    breakpoints: {
+      sm: 640,
+      md: 768,
+      lg: 1024,
+      xl: 1280,
+      '2xl': 1536,
+    },
+    debug: false,
+  };
+}
+
+async function startServer(
+  handler: (req: http.IncomingMessage, res: http.ServerResponse) => void
+): Promise<{ url: string; close: () => Promise<void> }> {
+  const server = http.createServer(handler);
+
+  await new Promise<void>((resolve) => {
+    server.listen(0, '127.0.0.1', resolve);
+  });
+
+  const address = server.address();
+  if (!address || typeof address === 'string') {
+    throw new Error('Failed to bind test server');
+  }
+
+  const url = `http://127.0.0.1:${address.port}`;
+
+  return {
+    url,
+    close: async () =>
+      await new Promise<void>((resolve, reject) => {
+        server.close((err) => {
+          if (err) reject(err);
+          else resolve();
+        });
+      }),
+  };
+}
+
+async function readJsonBody(req: http.IncomingMessage): Promise<unknown> {
+  const chunks: Buffer[] = [];
+  for await (const chunk of req) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  const raw = Buffer.concat(chunks).toString('utf8');
+  return raw.length ? JSON.parse(raw) : null;
+}
+
+describe('remote-client contract', () => {
+  it('POST /generate supports userPrompt (string)', async () => {
+    const server = await startServer(async (req, res) => {
+      try {
+        expect(req.method).toBe('POST');
+        expect(req.url).toBe('/generate');
+        expect(req.headers.authorization).toBe('Bearer test-api-key');
+
+        const body = await readJsonBody(req);
+        expect(body).toEqual({
+          systemPrompt: 'sys',
+          toolName: 'my_tool',
+          userPrompt: 'hello',
+        });
+
+        res.setHeader('content-type', 'application/json');
+        res.end(JSON.stringify({ content: 'ok', tokensUsed: 3 }));
+      } catch (err) {
+        res.statusCode = 500;
+        res.end(String(err));
+      }
+    });
+
+    try {
+      const cfg = getTestConfig(server.url);
+      const out = await generateWithRemote(cfg, 'sys', 'hello', 'my_tool');
+      expect(out).toBe('ok');
+    } finally {
+      await server.close();
+    }
+  });
+
+  it('POST /generate supports userParts (multimodal)', async () => {
+    const server = await startServer(async (req, res) => {
+      try {
+        expect(req.method).toBe('POST');
+        expect(req.url).toBe('/generate');
+        expect(req.headers.authorization).toBe('Bearer test-api-key');
+
+        const body = await readJsonBody(req);
+        expect(body).toEqual({
+          systemPrompt: 'sys',
+          toolName: 'my_tool',
+          userParts: [
+            { text: 'hello' },
+            { inlineData: { mimeType: 'image/png', data: 'AA==' } },
+          ],
+        });
+
+        res.setHeader('content-type', 'application/json');
+        res.end(JSON.stringify({ content: 'ok', tokensUsed: 3 }));
+      } catch (err) {
+        res.statusCode = 500;
+        res.end(String(err));
+      }
+    });
+
+    try {
+      const cfg = getTestConfig(server.url);
+      const out = await generateWithRemote(
+        cfg,
+        'sys',
+        [{ text: 'hello' }, { inlineData: { mimeType: 'image/png', data: 'AA==' } }],
+        'my_tool'
+      );
+      expect(out).toBe('ok');
+    } finally {
+      await server.close();
+    }
+  });
+
+  it('GET /quota returns budget fields { remainingBudgetUsd, maxBudgetUsd, ... }', async () => {
+    const server = await startServer(async (req, res) => {
+      try {
+        expect(req.method).toBe('GET');
+        expect(req.url).toBe('/quota');
+        expect(req.headers.authorization).toBe('Bearer test-api-key');
+
+        res.setHeader('content-type', 'application/json');
+        res.end(
+          JSON.stringify({
+            remainingBudgetUsd: 9.87,
+            maxBudgetUsd: 10,
+            spendUsd: 0.13,
+            budgetDuration: '30d',
+            rpmLimit: 30,
+            tpmLimit: 200000,
+          })
+        );
+      } catch (err) {
+        res.statusCode = 500;
+        res.end(String(err));
+      }
+    });
+
+    try {
+      const cfg = getTestConfig(server.url);
+      const quota = await checkQuota(cfg);
+      expect(quota).toEqual({
+        remainingBudgetUsd: 9.87,
+        maxBudgetUsd: 10,
+        spendUsd: 0.13,
+        budgetDuration: '30d',
+        rpmLimit: 30,
+        tpmLimit: 200000,
+      });
+    } finally {
+      await server.close();
+    }
+  });
+});

package/src/components/catalog.ts

@@ -13,202 +13,206 @@ import * as path from 'node:path';
 import { toPosixPath } from '../utils/walk.js';
 
 export interface ComponentExport {
-    name: string;
-    exportType: 'named' | 'default';
-    file: string; // relative to root
-    propsType?: string;
-    jsDoc?: string;
+  name: string;
+  exportType: 'named' | 'default';
+  file: string; // relative to root
+  propsType?: string;
+  jsDoc?: string;
 }
 
 export interface CatalogResult {
-    root: string;
-    filesScanned: number;
-    components: ComponentExport[];
-    warnings: string[];
+  root: string;
+  filesScanned: number;
+  components: ComponentExport[];
+  warnings: string[];
 }
 
 function readFileSafe(filePath: string): string | null {
-    try {
-        return fs.readFileSync(filePath, 'utf-8');
-    } catch {
-        return null;
-    }
+  try {
+    return fs.readFileSync(filePath, 'utf-8');
+  } catch {
+    return null;
+  }
 }
 
 function rel(root: string, abs: string): string {
-    return toPosixPath(path.relative(root, abs));
+  return toPosixPath(path.relative(root, abs));
 }
 
 function extractJSDocFromLeadingComment(text: string): string | undefined {
-    // Simple: capture /** ... */ immediately preceding export
-    const m = text.match(/\/\*\*([\s\S]*?)\*\//);
-    if (!m) return undefined;
-    const cleaned = m[1]
-        .split('\n')
-        .map((l) => l.replace(/^\s*\*\s?/, '').trim())
-        .filter(Boolean)
-        .join(' ');
-    return cleaned || undefined;
+  // Simple: capture /** ... */ immediately preceding export
+  const m = text.match(/\/\*\*([\s\S]*?)\*\//);
+  if (!m) return undefined;
+  const cleaned = m[1]
+    .split('\n')
+    .map((l) => l.replace(/^\s*\*\s?/, '').trim())
+    .filter(Boolean)
+    .join(' ');
+  return cleaned || undefined;
 }
 
 async function scanWithTypeScript(root: string, files: string[]): Promise<CatalogResult> {
-    const warnings: string[] = [];
-    const components: ComponentExport[] = [];
-
-    const ts = await import('typescript');
-
-    const getScriptKind = (filePath: string): any => {
-        const ext = path.extname(filePath).toLowerCase();
-        if (ext === '.tsx') return ts.ScriptKind.TSX;
-        if (ext === '.jsx') return ts.ScriptKind.JSX;
-        if (ext === '.ts') return ts.ScriptKind.TS;
-        if (ext === '.js') return ts.ScriptKind.JS;
-        return ts.ScriptKind.Unknown;
+  const warnings: string[] = [];
+  const components: ComponentExport[] = [];
+
+  const ts = await import('typescript');
+
+  const getScriptKind = (filePath: string): import('typescript').ScriptKind => {
+    const ext = path.extname(filePath).toLowerCase();
+    if (ext === '.tsx') return ts.ScriptKind.TSX;
+    if (ext === '.jsx') return ts.ScriptKind.JSX;
+    if (ext === '.ts') return ts.ScriptKind.TS;
+    if (ext === '.js') return ts.ScriptKind.JS;
+    return ts.ScriptKind.Unknown;
+  };
+
+  for (const f of files) {
+    const content = readFileSafe(f);
+    if (content == null) continue;
+
+    const sf = ts.createSourceFile(f, content, ts.ScriptTarget.ES2022, true, getScriptKind(f));
+
+    const isExported = (node: import('typescript').Node): boolean => {
+      if (!ts.canHaveModifiers(node)) return false;
+      const mods = ts.getModifiers(node);
+      if (!mods) return false;
+      return mods.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
     };
 
-    for (const f of files) {
-        const content = readFileSafe(f);
-        if (content == null) continue;
-
-        const sf = ts.createSourceFile(f, content, ts.ScriptTarget.ES2022, true, getScriptKind(f));
-
-        const isExported = (node: any): boolean => {
-            const mods = node.modifiers;
-            if (!mods) return false;
-            return mods.some((m: any) => m.kind === ts.SyntaxKind.ExportKeyword);
-        };
-
-        const isDefaultExport = (node: any): boolean => {
-            const mods = node.modifiers;
-            if (!mods) return false;
-            return mods.some((m: any) => m.kind === ts.SyntaxKind.DefaultKeyword);
-        };
-
-        const textOfType = (typeNode: any): string | undefined => {
-            if (!typeNode) return undefined;
-            return content.slice(typeNode.pos, typeNode.end).trim();
-        };
-
-        // Collect import modules (optional future use)
-        // const imports = sf.statements.filter(ts.isImportDeclaration).map((i: any) => i.moduleSpecifier.text);
-
-        for (const stmt of sf.statements) {
-            if (ts.isFunctionDeclaration(stmt) && isExported(stmt)) {
-                const name = stmt.name?.text || (isDefaultExport(stmt) ? 'default' : 'anonymous');
-                const firstParam = stmt.parameters?.[0];
-                const propsType = textOfType(firstParam?.type);
-                components.push({
-                    name: name === 'default' ? path.basename(f, path.extname(f)) : name,
-                    exportType: isDefaultExport(stmt) ? 'default' : 'named',
-                    file: rel(root, f),
-                    propsType,
-                });
-                continue;
-            }
+    const isDefaultExport = (node: import('typescript').Node): boolean => {
+      if (!ts.canHaveModifiers(node)) return false;
+      const mods = ts.getModifiers(node);
+      if (!mods) return false;
+      return mods.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword);
+    };
 
-            if (ts.isVariableStatement(stmt) && isExported(stmt)) {
-                for (const decl of stmt.declarationList.declarations) {
-                    const name = decl.name && ts.isIdentifier(decl.name) ? decl.name.text : undefined;
-                    if (!name) continue;
-
-                    // Component-like initializers
-                    const init = decl.initializer;
-                    let propsType: string | undefined;
-                    if (init && (ts.isArrowFunction(init) || ts.isFunctionExpression(init))) {
-                        const firstParam = init.parameters?.[0];
-                        propsType = textOfType(firstParam?.type);
-                    }
-
-                    // React.forwardRef(...) pattern: export const X = React.forwardRef<...>((props, ref) => ...)
-                    if (init && ts.isCallExpression(init)) {
-                        const args = init.arguments;
-                        const firstArg = args?.[0];
-                        if (firstArg && (ts.isArrowFunction(firstArg) || ts.isFunctionExpression(firstArg))) {
-                            const firstParam = firstArg.parameters?.[0];
-                            propsType = textOfType(firstParam?.type);
-                        }
-                    }
-
-                    components.push({
-                        name,
-                        exportType: 'named',
-                        file: rel(root, f),
-                        propsType,
-                    });
-                }
-                continue;
-            }
+    const textOfType = (typeNode: import('typescript').Node | undefined): string | undefined => {
+      if (!typeNode) return undefined;
+      return content.slice(typeNode.pos, typeNode.end).trim();
+    };
 
-            if (ts.isExportAssignment(stmt)) {
-                const expr = stmt.expression;
-                const name = ts.isIdentifier(expr) ? expr.text : path.basename(f, path.extname(f));
-                components.push({ name, exportType: 'default', file: rel(root, f) });
-                continue;
+    // Collect import modules (optional future use)
+    // const imports = sf.statements.filter(ts.isImportDeclaration).map((i) => i.moduleSpecifier.text);
+
+    for (const stmt of sf.statements) {
+      if (ts.isFunctionDeclaration(stmt) && isExported(stmt)) {
+        const name = stmt.name?.text || (isDefaultExport(stmt) ? 'default' : 'anonymous');
+        const firstParam = stmt.parameters?.[0];
+        const propsType = textOfType(firstParam?.type);
+        components.push({
+          name: name === 'default' ? path.basename(f, path.extname(f)) : name,
+          exportType: isDefaultExport(stmt) ? 'default' : 'named',
+          file: rel(root, f),
+          propsType,
+        });
+        continue;
+      }
+
+      if (ts.isVariableStatement(stmt) && isExported(stmt)) {
+        for (const decl of stmt.declarationList.declarations) {
+          const name = decl.name && ts.isIdentifier(decl.name) ? decl.name.text : undefined;
+          if (!name) continue;
+
+          // Component-like initializers
+          const init = decl.initializer;
+          let propsType: string | undefined;
+          if (init && (ts.isArrowFunction(init) || ts.isFunctionExpression(init))) {
+            const firstParam = init.parameters?.[0];
+            propsType = textOfType(firstParam?.type);
+          }
+
+          // React.forwardRef(...) pattern: export const X = React.forwardRef<...>((props, ref) => ...)
+          if (init && ts.isCallExpression(init)) {
+            const args = init.arguments;
+            const firstArg = args?.[0];
+            if (firstArg && (ts.isArrowFunction(firstArg) || ts.isFunctionExpression(firstArg))) {
+              const firstParam = firstArg.parameters?.[0];
+              propsType = textOfType(firstParam?.type);
             }
+          }
+
+          components.push({
+            name,
+            exportType: 'named',
+            file: rel(root, f),
+            propsType,
+          });
         }
+        continue;
+      }
+
+      if (ts.isExportAssignment(stmt)) {
+        const expr = stmt.expression;
+        const name = ts.isIdentifier(expr) ? expr.text : path.basename(f, path.extname(f));
+        components.push({ name, exportType: 'default', file: rel(root, f) });
+        continue;
+      }
     }
-
-    return {
-        root,
-        filesScanned: files.length,
-        components,
-        warnings,
-    };
+  }
+
+  return {
+    root,
+    filesScanned: files.length,
+    components,
+    warnings,
+  };
 }
 
 function scanWithRegexFallback(root: string, files: string[]): CatalogResult {
-    const components: ComponentExport[] = [];
-    const warnings: string[] = ['TypeScript compiler API unavailable; using regex fallback (less accurate).'];
-
-    for (const f of files) {
-        const content = readFileSafe(f);
-        if (content == null) continue;
-
-        // export function Foo(...)
-        const fnRe = /export\s+(default\s+)?function\s+([A-Za-z0-9_]+)/g;
-        let m: RegExpExecArray | null;
-        while ((m = fnRe.exec(content))) {
-            components.push({
-                name: m[2],
-                exportType: m[1] ? 'default' : 'named',
-                file: rel(root, f),
-                jsDoc: extractJSDocFromLeadingComment(content.slice(0, m.index)),
-            });
-        }
+  const components: ComponentExport[] = [];
+  const warnings: string[] = [
+    'TypeScript compiler API unavailable; using regex fallback (less accurate).',
+  ];
+
+  for (const f of files) {
+    const content = readFileSafe(f);
+    if (content == null) continue;
+
+    // export function Foo(...)
+    const fnRe = /export\s+(default\s+)?function\s+([A-Za-z0-9_]+)/g;
+    let m: RegExpExecArray | null;
+    while ((m = fnRe.exec(content))) {
+      components.push({
+        name: m[2],
+        exportType: m[1] ? 'default' : 'named',
+        file: rel(root, f),
+        jsDoc: extractJSDocFromLeadingComment(content.slice(0, m.index)),
+      });
+    }
 
-        // export const Foo = (...)
-        const constRe = /export\s+const\s+([A-Za-z0-9_]+)/g;
-        while ((m = constRe.exec(content))) {
-            components.push({
-                name: m[1],
-                exportType: 'named',
-                file: rel(root, f),
-                jsDoc: extractJSDocFromLeadingComment(content.slice(0, m.index)),
-            });
-        }
+    // export const Foo = (...)
+    const constRe = /export\s+const\s+([A-Za-z0-9_]+)/g;
+    while ((m = constRe.exec(content))) {
+      components.push({
+        name: m[1],
+        exportType: 'named',
+        file: rel(root, f),
+        jsDoc: extractJSDocFromLeadingComment(content.slice(0, m.index)),
+      });
+    }
 
-        // export default Identifier
-        const defRe = /export\s+default\s+([A-Za-z0-9_]+)/g;
-        while ((m = defRe.exec(content))) {
-            components.push({
-                name: m[1],
-                exportType: 'default',
-                file: rel(root, f),
-                jsDoc: extractJSDocFromLeadingComment(content.slice(0, m.index)),
-            });
-        }
+    // export default Identifier
+    const defRe = /export\s+default\s+([A-Za-z0-9_]+)/g;
+    while ((m = defRe.exec(content))) {
+      components.push({
+        name: m[1],
+        exportType: 'default',
+        file: rel(root, f),
+        jsDoc: extractJSDocFromLeadingComment(content.slice(0, m.index)),
+      });
     }
+  }
 
-    return { root, filesScanned: files.length, components, warnings };
+  return { root, filesScanned: files.length, components, warnings };
 }
 
 export async function buildComponentCatalog(root: string, files: string[]): Promise<CatalogResult> {
-    try {
-        return await scanWithTypeScript(root, files);
-    } catch (error) {
-        const msg = error instanceof Error ? error.message : 'unknown error';
-        const fallback = scanWithRegexFallback(root, files);
-        fallback.warnings.push(`TypeScript scan failed: ${msg}`);
-        return fallback;
-    }
+  try {
+    return await scanWithTypeScript(root, files);
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : 'unknown error';
+    const fallback = scanWithRegexFallback(root, files);
+    fallback.warnings.push(`TypeScript scan failed: ${msg}`);
+    return fallback;
+  }
 }