@gakim-digital/dexter-bridge 0.5.21 → 0.11.0

package/src/harnessMcpServer.js

@@ -0,0 +1,240 @@
+#!/usr/bin/env node
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { BRIDGE_VERSION } from './config.js';
+
+const gatewayUrl = String(process.env.INSTAWEB_HARNESS_GATEWAY_URL || '');
+const gatewayToken = String(process.env.INSTAWEB_HARNESS_GATEWAY_TOKEN || '');
+const configuredAllowedTools = (() => {
+  const value = String(process.env.INSTAWEB_HARNESS_ALLOWED_TOOLS || '').trim();
+  if (!value) return null;
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed)
+      ? new Set(parsed.filter((name) => typeof name === 'string'))
+      : null;
+  } catch {
+    return null;
+  }
+})();
+const toolAllowed = (name) =>
+  !configuredAllowedTools || configuredAllowedTools.has(name);
+
+if (!gatewayUrl || !gatewayToken) {
+  throw new Error('The InstaWebAI harness gateway is not configured.');
+}
+
+async function callGateway(name, args) {
+  const response = await fetch(gatewayUrl, {
+    method: 'POST',
+    headers: {
+      authorization: `Bearer ${gatewayToken}`,
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify({ name, arguments: args }),
+  });
+  const payload = await response.json().catch(() => null);
+  if (!response.ok || payload?.ok !== true) {
+    throw Object.assign(new Error(payload?.error?.message || `${name} failed.`), {
+      code: payload?.error?.code || 'APP_HARNESS_TOOL_FAILED',
+    });
+  }
+  return payload.result;
+}
+
+function resultContent(result) {
+  return {
+    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    structuredContent: result && typeof result === 'object' && !Array.isArray(result) ? result : { result },
+  };
+}
+
+const server = new McpServer({
+  name: 'instawebai-harness',
+  version: BRIDGE_VERSION,
+});
+
+if (toolAllowed('workspace_inspect')) server.registerTool(
+  'workspace_inspect',
+  {
+    description: 'Inspect workspace changes relative to the last synchronized InstaWebAI revision.',
+    inputSchema: {},
+  },
+  async () => resultContent(await callGateway('workspace_inspect', {})),
+);
+
+if (toolAllowed('workspace_sync')) server.registerTool(
+  'workspace_sync',
+  {
+    description: 'Synchronize all current workspace changes to the protected InstaWebAI build workspace.',
+    inputSchema: {},
+  },
+  async () => resultContent(await callGateway('workspace_sync', {})),
+);
+
+if (toolAllowed('shell_run')) server.registerTool(
+  'shell_run',
+  {
+    description:
+      'Run a project command in InstaWebAI’s isolated build workspace. Use it for package installation, code generation, tests, and builds.',
+    inputSchema: {
+      command: z.string().trim().min(1).max(8_192),
+      cwd: z
+        .string()
+        .regex(/^(?:\.|[A-Za-z0-9][A-Za-z0-9._-]*(?:\/[A-Za-z0-9][A-Za-z0-9._-]*)*)$/)
+        .max(500)
+        .default('.'),
+      timeoutMs: z.number().int().min(1_000).max(600_000).default(300_000),
+    },
+  },
+  async (args) => resultContent(await callGateway('shell_run', args)),
+);
+
+if (toolAllowed('preview_control')) server.registerTool(
+  'preview_control',
+  {
+    description: 'Start, restart, or inspect the server-managed preview for the current synchronized workspace.',
+    inputSchema: {
+      action: z.enum(['start', 'restart', 'status']),
+    },
+  },
+  async (args) => resultContent(await callGateway('preview_control', args)),
+);
+
+if (toolAllowed('browser_control')) server.registerTool(
+  'browser_control',
+  {
+    description:
+      'Drive an isolated browser against the current preview. Prefer batch for consecutive interactions and receive one compact final snapshot.',
+    inputSchema: {
+      action: z.enum(['open', 'snapshot', 'click', 'fill', 'select', 'press', 'batch', 'close']),
+      path: z.string().max(1_000).optional(),
+      selector: z.string().max(1_000).optional(),
+      value: z.string().max(10_000).optional(),
+      key: z.string().max(80).optional(),
+      actions: z.array(z.object({
+        action: z.enum(['open', 'snapshot', 'click', 'fill', 'select', 'press']),
+        path: z.string().max(1_000).optional(),
+        selector: z.string().max(1_000).optional(),
+        value: z.string().max(10_000).optional(),
+        key: z.string().max(80).optional(),
+      }).strict()).min(1).max(25).optional(),
+    },
+  },
+  async (args) => resultContent(await callGateway('browser_control', args)),
+);
+
+if (toolAllowed('data_inspect')) server.registerTool(
+  'data_inspect',
+  {
+    description:
+      'Read the application data contract or redacted development records without exposing database credentials.',
+    inputSchema: {
+      action: z.enum(['overview', 'list_records']),
+      entityId: z.string().max(180).optional(),
+      limit: z.number().int().min(1).max(100).default(50),
+      offset: z.number().int().min(0).max(100_000).default(0),
+      search: z.string().max(500).default(''),
+    },
+  },
+  async (args) => resultContent(await callGateway('data_inspect', args)),
+);
+
+if (toolAllowed('verification_run')) server.registerTool(
+  'verification_run',
+  {
+    description: 'Synchronize the workspace and run InstaWebAI deterministic and browser verification.',
+    inputSchema: {
+      level: z.enum(['fast', 'visual']),
+      workflowIds: z.array(z.string().max(180)).max(20).default([]),
+    },
+  },
+  async (args) => resultContent(await callGateway('verification_run', args)),
+);
+
+if (toolAllowed('progress_update')) server.registerTool(
+  'progress_update',
+  {
+    description:
+      'Send a brief user-facing progress update before the first inspection or edit and at meaningful phase changes.',
+    inputSchema: {
+      message: z.string().trim().min(1).max(500),
+    },
+  },
+  async (args) => resultContent(await callGateway('progress_update', args)),
+);
+
+if (toolAllowed('framer_instructions')) server.registerTool(
+  'framer_instructions',
+  {
+    description:
+      'Load Framer’s official agent command reference before making canvas changes.',
+    inputSchema: {},
+  },
+  async () => resultContent(await callGateway('framer_instructions', {})),
+);
+
+if (toolAllowed('framer_context')) server.registerTool(
+  'framer_context',
+  {
+    description:
+      'Read the connected Framer project context, including pages, components, styles, CMS, and the active branch.',
+    inputSchema: {},
+  },
+  async () => resultContent(await callGateway('framer_context', {})),
+);
+
+if (toolAllowed('framer_read_project')) server.registerTool(
+  'framer_read_project',
+  {
+    description:
+      'Run focused Framer Agent readProject queries against the connected project.',
+    inputSchema: {
+      queries: z.array(z.record(z.string(), z.unknown())).min(1).max(50),
+      pagePath: z.string().max(500).default('/'),
+    },
+  },
+  async (args) => resultContent(await callGateway('framer_read_project', args)),
+);
+
+if (toolAllowed('framer_apply_changes')) server.registerTool(
+  'framer_apply_changes',
+  {
+    description:
+      'Apply Framer Agent DSL changes directly to the connected project.',
+    inputSchema: {
+      changes: z.string().trim().min(1).max(250_000),
+      pagePath: z.string().max(500).default('/'),
+    },
+  },
+  async (args) => resultContent(await callGateway('framer_apply_changes', args)),
+);
+
+if (toolAllowed('framer_read')) server.registerTool(
+  'framer_read',
+  {
+    description:
+      'Execute read-only JavaScript with the official Framer Agent connection.',
+    inputSchema: {
+      code: z.string().trim().min(1).max(200_000),
+    },
+  },
+  async (args) => resultContent(await callGateway('framer_read', args)),
+);
+
+if (toolAllowed('framer_write')) server.registerTool(
+  'framer_write',
+  {
+    description:
+      'Execute project-scoped JavaScript with the official Framer Agent connection for mutations not covered by applyChanges.',
+    inputSchema: {
+      code: z.string().trim().min(1).max(200_000),
+    },
+  },
+  async (args) => resultContent(await callGateway('framer_write', args)),
+);
+
+const transport = new StdioServerTransport();
+await server.connect(transport);