@gakim-digital/dexter-bridge 0.11.1 → 0.11.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gakim-digital/dexter-bridge",
-  "version": "0.11.1",
+  "version": "0.11.2",
   "description": "Local bridge for InstaWebAI and Dexter — runs Codex, Claude Code, or OpenCode on your machine.",
   "type": "module",
   "bin": {

package/src/agent.js

@@ -64,15 +64,15 @@ const HARNESS_MCP_SERVER_PATH = fileURLToPath(
 export function harnessMcpProcessEnvironment(
   gateway,
   versions = process.versions,
-  allowedToolNames,
+  toolDefinitions,
 ) {
   return {
     INSTAWEB_HARNESS_GATEWAY_URL: gateway.url,
     INSTAWEB_HARNESS_GATEWAY_TOKEN: gateway.token,
-    ...(Array.isArray(allowedToolNames)
+    ...(Array.isArray(toolDefinitions)
       ? {
-          INSTAWEB_HARNESS_ALLOWED_TOOLS:
-            JSON.stringify(allowedToolNames),
+          INSTAWEB_HARNESS_TOOL_DEFINITIONS:
+            JSON.stringify(toolDefinitions),
         }
       : {}),
     ...(versions?.electron ? { ELECTRON_RUN_AS_NODE: '1' } : {}),
@@ -2461,7 +2461,7 @@ async function executeOutcomeRun(run, send, agent, options = {}) {
           environment: harnessMcpProcessEnvironment(
             gateway,
             process.versions,
-            harnessTools.toolNames,
+            harnessTools.definitions,
           ),
         }
       : null;

package/src/framerAgentTools.js

@@ -1029,6 +1029,18 @@ export function createFramerAgentToolRuntime({
     allowedToolNames,
     workingPreferences,
   );
+  const exposedToolNames = new Set(
+    definitions.map((definition) => definition.name),
+  );
+  const missingToolNames = uniqueStrings(requestedTools)
+    .filter((name) => !exposedToolNames.has(name));
+  if (missingToolNames.length > 0) {
+    throw toolError(
+      'FRAMER_HARNESS_TOOL_CATALOG_INCOMPLETE',
+      `Dexter could not start because this bridge does not expose the required Framer tools: ${missingToolNames.join(', ')}.`,
+      500,
+    );
+  }
   const allowPublishing = assignment?.context?.permissions?.publish === true;
   const inheritedRejectedMechanisms =
     assignment?.context?.repairContext?.rejectedMechanisms

package/src/harnessMcpServer.js

@@ -1,31 +1,68 @@
 #!/usr/bin/env node
 
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { z } from 'zod';
+import {
+  CallToolRequestSchema,
+  ErrorCode,
+  ListToolsRequestSchema,
+  McpError,
+} from '@modelcontextprotocol/sdk/types.js';
+import { AjvJsonSchemaValidator } from '@modelcontextprotocol/sdk/validation/ajv';
 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;
+
+function configuredToolDefinitions() {
+  let parsed;
   try {
-    const parsed = JSON.parse(value);
-    return Array.isArray(parsed)
-      ? new Set(parsed.filter((name) => typeof name === 'string'))
-      : null;
+    parsed = JSON.parse(
+      String(process.env.INSTAWEB_HARNESS_TOOL_DEFINITIONS || ''),
+    );
   } catch {
-    return null;
+    throw new Error('The InstaWebAI harness tool definitions are invalid.');
+  }
+  if (!Array.isArray(parsed) || parsed.length === 0) {
+    throw new Error('The InstaWebAI harness tool definitions are missing.');
   }
-})();
-const toolAllowed = (name) =>
-  !configuredAllowedTools || configuredAllowedTools.has(name);
+  const names = new Set();
+  return parsed.map((definition) => {
+    const name = String(definition?.name || '').trim();
+    const description = String(definition?.description || '').trim();
+    const inputSchema = definition?.inputSchema;
+    if (
+      !/^[A-Za-z0-9_.-]+$/.test(name)
+      || names.has(name)
+      || !description
+      || !inputSchema
+      || typeof inputSchema !== 'object'
+      || Array.isArray(inputSchema)
+      || inputSchema.type !== 'object'
+    ) {
+      throw new Error('The InstaWebAI harness tool definitions are invalid.');
+    }
+    names.add(name);
+    return { name, description, inputSchema };
+  });
+}
 
 if (!gatewayUrl || !gatewayToken) {
   throw new Error('The InstaWebAI harness gateway is not configured.');
 }
 
+const toolDefinitions = configuredToolDefinitions();
+const toolsByName = new Map(
+  toolDefinitions.map((definition) => [definition.name, definition]),
+);
+const schemaValidator = new AjvJsonSchemaValidator();
+const argumentValidators = new Map(
+  toolDefinitions.map((definition) => [
+    definition.name,
+    schemaValidator.getValidator(definition.inputSchema),
+  ]),
+);
+
 async function callGateway(name, args) {
   const response = await fetch(gatewayUrl, {
     method: 'POST',
@@ -47,194 +84,59 @@ async function callGateway(name, args) {
 function resultContent(result) {
   return {
     content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-    structuredContent: result && typeof result === 'object' && !Array.isArray(result) ? result : { result },
+    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', {})),
-);
+function errorContent(error) {
+  return {
+    content: [
+      {
+        type: 'text',
+        text: error instanceof Error ? error.message : String(error),
+      },
+    ],
+    isError: true,
+  };
+}
 
-if (toolAllowed('framer_read_project')) server.registerTool(
-  'framer_read_project',
+const server = new Server(
   {
-    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('/'),
-    },
+    name: 'instawebai-harness',
+    version: BRIDGE_VERSION,
   },
-  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('/'),
+    capabilities: {
+      tools: {},
     },
   },
-  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)),
-);
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: toolDefinitions,
+}));
 
-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)),
-);
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: rawArguments = {} } = request.params;
+  if (!toolsByName.has(name)) {
+    throw new McpError(ErrorCode.InvalidParams, `Tool ${name} not found.`);
+  }
+  const validated = argumentValidators.get(name)(rawArguments);
+  if (!validated.valid) {
+    throw new McpError(
+      ErrorCode.InvalidParams,
+      `Invalid arguments for ${name}: ${validated.errorMessage}`,
+    );
+  }
+  try {
+    return resultContent(await callGateway(name, validated.data));
+  } catch (error) {
+    return errorContent(error);
+  }
+});
 
 const transport = new StdioServerTransport();
 await server.connect(transport);