mcpmake 0.1.0

package/dist/emitter/site-templates/tool-handler-action.ts.hbs

@@ -0,0 +1,86 @@
+import { z } from 'zod';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+{{#if button}}
+import { getOrCreateSession, takeScreenshot, resolveSelector } from '../browser-manager.js';
+{{else}}
+import { getOrCreateSession, takeScreenshot } from '../browser-manager.js';
+{{/if}}
+import type { AppConfig } from '../config.js';
+
+const inputSchema = {{{inputSchemaCode}}};
+
+export function register(server: McpServer, config: AppConfig): void {
+  server.registerTool(
+    '{{name}}',
+    {
+      title: '{{jsString title}}',
+      description: `{{{description}}}`,
+      inputSchema,
+{{#if annotations}}
+      annotations: {
+{{#if annotations.readOnlyHint}}
+        readOnlyHint: true,
+{{/if}}
+{{#if annotations.destructiveHint}}
+        destructiveHint: true,
+{{/if}}
+{{#if annotations.idempotentHint}}
+        idempotentHint: true,
+{{/if}}
+      },
+{{/if}}
+    },
+    async (input) => {
+      try {
+        const { page, sessionId } = await getOrCreateSession(
+          (input as Record<string, unknown>).sessionId as string | undefined,
+        );
+
+{{#if pageUrl}}
+        // Navigate to the page if not already there
+        const targetUrl = '{{jsString pageUrl}}';
+        if (!page.url().startsWith(targetUrl.split('?')[0])) {
+          await page.goto(targetUrl, { waitUntil: 'domcontentloaded' });
+          await page.waitForTimeout(500);
+        }
+{{/if}}
+
+{{#if link}}
+        // Navigate to link
+        await page.goto('{{jsString link.href}}', { waitUntil: 'domcontentloaded' });
+        await page.waitForTimeout(500);
+{{else if button}}
+        // Click button
+        const buttonSelector = await resolveSelector(page, ['{{jsString button.selector.primary}}'{{#each button.selector.fallbacks}}, '{{jsString this}}'{{/each}}]);
+        await page.click(buttonSelector);
+        await page.waitForLoadState('networkidle', { timeout: 5000 }).catch(() => {});
+{{/if}}
+
+        // Capture result
+        const pageTitle = await page.title();
+        const pageUrl = page.url();
+        const screenshot = await takeScreenshot(sessionId);
+
+        return {
+          content: [
+            {
+              type: 'text' as const,
+              text: JSON.stringify({ sessionId, pageTitle, url: pageUrl, success: true }, null, 2),
+            },
+            {
+              type: 'image' as const,
+              data: screenshot.toString('base64'),
+              mimeType: 'image/png',
+            },
+          ],
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: 'text' as const, text: `Error: ${message}` }],
+          isError: true,
+        };
+      }
+    },
+  );
+}

package/dist/emitter/site-templates/tool-handler-form.ts.hbs

@@ -0,0 +1,116 @@
+import { z } from 'zod';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { getOrCreateSession, takeScreenshot, resolveSelector } from '../browser-manager.js';
+import type { AppConfig } from '../config.js';
+
+const inputSchema = {{{inputSchemaCode}}};
+
+export function register(server: McpServer, config: AppConfig): void {
+  server.registerTool(
+    '{{name}}',
+    {
+      title: '{{jsString title}}',
+      description: `{{{description}}}`,
+      inputSchema,
+{{#if annotations}}
+      annotations: {
+{{#if annotations.readOnlyHint}}
+        readOnlyHint: true,
+{{/if}}
+{{#if annotations.destructiveHint}}
+        destructiveHint: true,
+{{/if}}
+{{#if annotations.idempotentHint}}
+        idempotentHint: true,
+{{/if}}
+      },
+{{/if}}
+    },
+    async (input) => {
+      try {
+        const { page, sessionId } = await getOrCreateSession(
+          (input as Record<string, unknown>).sessionId as string | undefined,
+        );
+
+        // Navigate to the page if not already there
+{{#if pageUrl}}
+        const targetUrl = '{{jsString pageUrl}}';
+        if (!page.url().startsWith(targetUrl.split('?')[0])) {
+          await page.goto(targetUrl, { waitUntil: 'domcontentloaded' });
+          await page.waitForTimeout(500);
+        }
+{{/if}}
+
+        // Fill form fields
+{{#each form.fields}}
+{{#unless (eq fieldType "hidden")}}
+{{#if (eq fieldType "checkbox")}}
+        if ((input as Record<string, unknown>)['{{jsString name}}'] !== undefined) {
+          const checked = Boolean((input as Record<string, unknown>)['{{jsString name}}']);
+          const fieldSelector = await resolveSelector(page, ['{{jsString selector.primary}}'{{#each selector.fallbacks}}, '{{jsString this}}'{{/each}}]);
+          if (checked) {
+            await page.check(fieldSelector);
+          } else {
+            await page.uncheck(fieldSelector);
+          }
+        }
+{{else if (eq fieldType "select")}}
+        if ((input as Record<string, unknown>)['{{jsString name}}'] !== undefined) {
+          const fieldSelector = await resolveSelector(page, ['{{jsString selector.primary}}'{{#each selector.fallbacks}}, '{{jsString this}}'{{/each}}]);
+          await page.selectOption(fieldSelector, String((input as Record<string, unknown>)['{{jsString name}}']));
+        }
+{{else if (eq fieldType "radio")}}
+        if ((input as Record<string, unknown>)['{{jsString name}}'] !== undefined) {
+          const radioName = '{{jsString name}}';
+          const radioValue = String((input as Record<string, unknown>)['{{jsString name}}']).replace(/["\\[\]()]/g, '\\$&');
+          const radioNameSel = radioName.replace(/["\\]/g, '\\$&');
+          await page.check(`input[name="${radioNameSel}"][value="${radioValue}"]`);
+        }
+{{else}}
+        if ((input as Record<string, unknown>)['{{jsString name}}'] !== undefined) {
+          const fieldSelector = await resolveSelector(page, ['{{jsString selector.primary}}'{{#each selector.fallbacks}}, '{{jsString this}}'{{/each}}]);
+          await page.fill(fieldSelector, String((input as Record<string, unknown>)['{{jsString name}}']));
+        }
+{{/if}}
+{{/unless}}
+{{/each}}
+
+        // Submit the form
+{{#if form.submitButton}}
+        const submitSelector = await resolveSelector(page, ['{{jsString form.submitButton.primary}}'{{#each form.submitButton.fallbacks}}, '{{jsString this}}'{{/each}}]);
+        await page.click(submitSelector);
+{{else}}
+        await page.keyboard.press('Enter');
+{{/if}}
+
+        // Wait for navigation or response
+        await page.waitForLoadState('networkidle', { timeout: 10000 }).catch(() => {});
+
+        // Capture result
+        const pageTitle = await page.title();
+        const pageUrl = page.url();
+        const screenshot = await takeScreenshot(sessionId);
+
+        return {
+          content: [
+            {
+              type: 'text' as const,
+              text: JSON.stringify({ sessionId, pageTitle, url: pageUrl, success: true }, null, 2),
+            },
+            {
+              type: 'image' as const,
+              data: screenshot.toString('base64'),
+              mimeType: 'image/png',
+            },
+          ],
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: 'text' as const, text: `Error: ${message}` }],
+          isError: true,
+        };
+      }
+    },
+  );
+}

package/dist/emitter/site-templates/tool-handler-lifecycle.ts.hbs

@@ -0,0 +1,146 @@
+import { z } from 'zod';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import {
+  getOrCreateSession,
+  closeSession,
+  closeBrowser,
+  takeScreenshot as doScreenshot,
+  listSessions,
+  isBrowserRunning,
+} from '../browser-manager.js';
+import type { AppConfig } from '../config.js';
+
+{{#if (eq name "start_browser")}}
+const inputSchema = z.object({
+  sessionId: z.string().optional().describe('Reuse an existing session instead of starting a new one'),
+  headless: z.boolean().optional().describe('Run in headless mode (default: from server config)'),
+});
+
+export function register(server: McpServer, config: AppConfig): void {
+  server.registerTool(
+    'start_browser',
+    {
+      title: 'Start Browser',
+      description: 'Launch a browser session. Returns a sessionId for subsequent tool calls.',
+      inputSchema,
+      annotations: { idempotentHint: true },
+    },
+    async (input) => {
+      try {
+        const { sessionId } = await getOrCreateSession(
+          (input as Record<string, unknown>).sessionId as string | undefined,
+        );
+
+        return {
+          content: [
+            {
+              type: 'text' as const,
+              text: JSON.stringify({
+                sessionId,
+                status: 'started',
+                activeSessions: listSessions().length,
+              }, null, 2),
+            },
+          ],
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: 'text' as const, text: `Error: ${message}` }],
+          isError: true,
+        };
+      }
+    },
+  );
+}
+{{/if}}
+
+{{#if (eq name "stop_browser")}}
+const inputSchema = z.object({
+  sessionId: z.string().optional().describe('Session to close. If omitted, closes all sessions'),
+});
+
+export function register(server: McpServer, config: AppConfig): void {
+  server.registerTool(
+    'stop_browser',
+    {
+      title: 'Stop Browser',
+      description: 'Close a browser session and free resources.',
+      inputSchema,
+      annotations: { destructiveHint: true },
+    },
+    async (input) => {
+      try {
+        const sessionId = (input as Record<string, unknown>).sessionId as string | undefined;
+
+        if (sessionId) {
+          await closeSession(sessionId);
+        } else {
+          await closeBrowser();
+        }
+
+        return {
+          content: [
+            {
+              type: 'text' as const,
+              text: JSON.stringify({
+                status: 'stopped',
+                activeSessions: listSessions().length,
+              }, null, 2),
+            },
+          ],
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: 'text' as const, text: `Error: ${message}` }],
+          isError: true,
+        };
+      }
+    },
+  );
+}
+{{/if}}
+
+{{#if (eq name "take_screenshot")}}
+const inputSchema = z.object({
+  sessionId: z.string().optional().describe('Session to screenshot. If omitted, uses default session'),
+  fullPage: z.boolean().optional().describe('Capture the full scrollable page (default: false)'),
+});
+
+export function register(server: McpServer, config: AppConfig): void {
+  server.registerTool(
+    'take_screenshot',
+    {
+      title: 'Take Screenshot',
+      description: 'Capture a screenshot of the current page.',
+      inputSchema,
+      annotations: { readOnlyHint: true },
+    },
+    async (input) => {
+      try {
+        const sessionId = (input as Record<string, unknown>).sessionId as string | undefined;
+        const fullPage = (input as Record<string, unknown>).fullPage as boolean | undefined;
+
+        const screenshot = await doScreenshot(sessionId, fullPage ?? false);
+
+        return {
+          content: [
+            {
+              type: 'image' as const,
+              data: screenshot.toString('base64'),
+              mimeType: 'image/png',
+            },
+          ],
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: 'text' as const, text: `Error: ${message}` }],
+          isError: true,
+        };
+      }
+    },
+  );
+}
+{{/if}}

package/dist/emitter/site-templates/tool-index.ts.hbs

@@ -0,0 +1,11 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { AppConfig } from '../config.js';
+{{#each tools}}
+import { register as register{{capitalize functionName}} } from './{{fileName}}.js';
+{{/each}}
+
+export function registerAllTools(server: McpServer, config: AppConfig): void {
+{{#each tools}}
+  register{{capitalize functionName}}(server, config);
+{{/each}}
+}

package/dist/emitter/template-loader.d.ts

@@ -0,0 +1 @@
+export declare function renderTemplate(name: string, data: any): string;

package/dist/emitter/template-loader.js

@@ -0,0 +1,27 @@
+import { readFileSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import Handlebars from 'handlebars';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const TEMPLATE_DIR = resolve(__dirname, 'templates');
+const templateCache = new Map();
+Handlebars.registerHelper('eq', function (a, b) {
+    return a === b;
+});
+Handlebars.registerHelper('capitalize', function (str) {
+    if (!str)
+        return str;
+    return str.charAt(0).toUpperCase() + str.slice(1);
+});
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function renderTemplate(name, data) {
+    if (!templateCache.has(name)) {
+        const templatePath = resolve(TEMPLATE_DIR, `${name}.hbs`);
+        if (!templatePath.startsWith(TEMPLATE_DIR + '/')) {
+            throw new Error(`Invalid template name: ${name}`);
+        }
+        const raw = readFileSync(templatePath, 'utf-8');
+        templateCache.set(name, Handlebars.compile(raw, { noEscape: true }));
+    }
+    return templateCache.get(name)(data);
+}

package/dist/emitter/templates/auth-provider.ts.hbs

@@ -0,0 +1,57 @@
+import type { AppConfig } from './config.js';
+{{#if hasOAuth}}
+import { getAccessToken } from './oauth.js';
+{{/if}}
+
+{{#if hasOAuth}}
+export async function getAuthHeaders(config: AppConfig): Promise<Record<string, string>> {
+{{else}}
+export function getAuthHeaders(config: AppConfig): Record<string, string> {
+{{/if}}
+  const headers: Record<string, string> = {};
+
+{{#each authSchemes}}
+{{#if (eq type "apiKey")}}
+{{#if (eq in "header")}}
+  if (config.apiKey) {
+    headers['{{headerName}}'] = config.apiKey;
+  }
+{{/if}}
+{{#if (eq in "query")}}
+  // API key sent as query parameter — handled in request URL construction
+{{/if}}
+{{/if}}
+{{#if (eq type "http-bearer")}}
+  if (config.bearerToken) {
+    headers['Authorization'] = `Bearer ${config.bearerToken}`;
+  }
+{{/if}}
+{{#if (eq type "http-basic")}}
+  if (config.basicUsername && config.basicPassword) {
+    const encoded = Buffer.from(`${config.basicUsername}:${config.basicPassword}`).toString('base64');
+    headers['Authorization'] = `Basic ${encoded}`;
+  }
+{{/if}}
+{{#if (eq type "oauth2")}}
+  // OAuth2 — use token management with refresh
+  try {
+    const token = await getAccessToken({
+      clientId: config.oauth2ClientId ?? '',
+      clientSecret: config.oauth2ClientSecret,
+      authorizationUrl: config.oauth2AuthorizationUrl ?? '',
+      tokenUrl: config.oauth2TokenUrl ?? '',
+      scopes: [],
+      redirectUri: config.oauth2RedirectUri ?? 'http://localhost:3000/callback',
+    });
+    headers['Authorization'] = `Bearer ${token}`;
+  } catch {
+    // Fallback to pre-obtained token
+    if (config.oauth2Token) {
+      headers['Authorization'] = `Bearer ${config.oauth2Token}`;
+    }
+  }
+{{/if}}
+{{/each}}
+
+  return headers;
+}

package/dist/emitter/templates/config.ts.hbs

@@ -0,0 +1,63 @@
+export interface AppConfig {
+  baseUrl: string;
+{{#each authSchemes}}
+{{#if (eq type "apiKey")}}
+  apiKey?: string;
+{{/if}}
+{{#if (eq type "http-bearer")}}
+  bearerToken?: string;
+{{/if}}
+{{#if (eq type "http-basic")}}
+  basicUsername?: string;
+  basicPassword?: string;
+{{/if}}
+{{#if (eq type "oauth2")}}
+  oauth2Token?: string;
+  oauth2ClientId?: string;
+  oauth2ClientSecret?: string;
+  oauth2AuthorizationUrl?: string;
+  oauth2TokenUrl?: string;
+  oauth2RedirectUri?: string;
+{{/if}}
+{{/each}}
+  maxRetries: number;
+  requestIntervalMs: number;
+}
+
+export function loadConfig(): AppConfig {
+  const baseUrl = requireEnv('BASE_URL');
+
+  return {
+    baseUrl: baseUrl.replace(/\/$/, ''),
+{{#each authSchemes}}
+{{#if (eq type "apiKey")}}
+    apiKey: process.env.API_KEY,
+{{/if}}
+{{#if (eq type "http-bearer")}}
+    bearerToken: process.env.BEARER_TOKEN,
+{{/if}}
+{{#if (eq type "http-basic")}}
+    basicUsername: process.env.BASIC_USERNAME,
+    basicPassword: process.env.BASIC_PASSWORD,
+{{/if}}
+{{#if (eq type "oauth2")}}
+    oauth2Token: process.env.OAUTH2_TOKEN,
+    oauth2ClientId: process.env.OAUTH2_CLIENT_ID,
+    oauth2ClientSecret: process.env.OAUTH2_CLIENT_SECRET,
+    oauth2AuthorizationUrl: process.env.OAUTH2_AUTHORIZATION_URL,
+    oauth2TokenUrl: process.env.OAUTH2_TOKEN_URL,
+    oauth2RedirectUri: process.env.OAUTH2_REDIRECT_URI,
+{{/if}}
+{{/each}}
+    maxRetries: parseInt(process.env.MAX_RETRIES ?? '3', 10),
+    requestIntervalMs: parseInt(process.env.REQUEST_INTERVAL_MS ?? '100', 10),
+  };
+}
+
+function requireEnv(name: string): string {
+  const value = process.env[name];
+  if (!value) {
+    throw new Error(`Missing required environment variable: ${name}`);
+  }
+  return value;
+}