@synergenius/flow-weaver 0.10.9 → 0.10.11

package/dist/cli/index.js

@@ -19,6 +19,7 @@ import { initCommand } from './commands/init.js';
 import { watchCommand } from './commands/watch.js';
 import { devCommand } from './commands/dev.js';
 import { listenCommand } from './commands/listen.js';
+import { tunnelCommand } from './commands/tunnel.js';
 import { mcpServerCommand } from '../mcp/server.js';
 import { uiFocusNode, uiAddNode, uiOpenWorkflow, uiGetState, uiBatch } from './commands/ui.js';
 import { grammarCommand } from './commands/grammar.js';
@@ -34,6 +35,7 @@ import { docsListCommand, docsReadCommand, docsSearchCommand } from './commands/
 import { statusCommand } from './commands/status.js';
 import { implementCommand } from './commands/implement.js';
 import { marketInitCommand, marketPackCommand, marketPublishCommand, marketInstallCommand, marketSearchCommand, marketListCommand, } from './commands/market.js';
+import { mcpSetupCommand } from './commands/mcp-setup.js';
 import { logger } from './utils/logger.js';
 import { getErrorMessage } from '../utils/error-utils.js';
 import { DEFAULT_SERVER_URL } from '../defaults.js';
@@ -257,8 +259,8 @@ program
 // Listen command
 program
     .command('listen')
-    .description('Connect to the editor and stream integration events as JSON lines')
-    .option('-s, --server <url>', 'Editor URL', DEFAULT_SERVER_URL)
+    .description('Connect to Studio and stream integration events as JSON lines')
+    .option('-s, --server <url>', 'Studio URL', DEFAULT_SERVER_URL)
     .action(async (options) => {
     try {
         await listenCommand(options);
@@ -268,11 +270,27 @@ program
         process.exit(1);
     }
 });
+// Tunnel command
+program
+    .command('tunnel')
+    .description('Create a tunnel from cloud Studio to your local development server')
+    .requiredOption('-k, --key <apiKey>', 'API key for cloud authentication (fw_xxxx)')
+    .option('-c, --cloud <url>', 'Cloud server URL', 'https://flowweaver.dev')
+    .option('-s, --server <url>', 'Local server URL', DEFAULT_SERVER_URL)
+    .action(async (options) => {
+    try {
+        await tunnelCommand(options);
+    }
+    catch (error) {
+        logger.error(`Command failed: ${getErrorMessage(error)}`);
+        process.exit(1);
+    }
+});
 // MCP server command
 program
     .command('mcp-server')
     .description('Start MCP server for Claude Code integration')
-    .option('-s, --server <url>', 'Editor URL', DEFAULT_SERVER_URL)
+    .option('-s, --server <url>', 'Studio URL', DEFAULT_SERVER_URL)
     .option('--stdio', 'Run in MCP stdio mode (skip interactive registration)')
     .action(async (options) => {
     try {
@@ -283,12 +301,28 @@ program
         process.exit(1);
     }
 });
-// UI command group (send commands to editor)
-const uiCmd = program.command('ui').description('Send commands to the editor');
+// MCP setup command
+program
+    .command('mcp-setup')
+    .description('Configure MCP server for AI coding tools (Claude, Cursor, VS Code, Windsurf, Codex, OpenClaw)')
+    .option('--tool <tools...>', 'Specific tools to configure (claude, cursor, vscode, windsurf, codex, openclaw)')
+    .option('--all', 'Configure all detected tools without prompting')
+    .option('--list', 'List detected tools without configuring')
+    .action(async (options) => {
+    try {
+        await mcpSetupCommand(options);
+    }
+    catch (error) {
+        logger.error(`Command failed: ${getErrorMessage(error)}`);
+        process.exit(1);
+    }
+});
+// UI command group (send commands to Studio)
+const uiCmd = program.command('ui').description('Send commands to Studio');
 uiCmd
     .command('focus-node <nodeId>')
-    .description('Select and center a node in the editor')
-    .option('-s, --server <url>', 'Editor URL', DEFAULT_SERVER_URL)
+    .description('Select and center a node in Studio')
+    .option('-s, --server <url>', 'Studio URL', DEFAULT_SERVER_URL)
     .action(async (nodeId, options) => {
     try {
         await uiFocusNode(nodeId, options);
@@ -301,7 +335,7 @@ uiCmd
 uiCmd
     .command('add-node <nodeTypeName>')
     .description('Add a node at viewport center')
-    .option('-s, --server <url>', 'Editor URL', DEFAULT_SERVER_URL)
+    .option('-s, --server <url>', 'Studio URL', DEFAULT_SERVER_URL)
     .action(async (nodeTypeName, options) => {
     try {
         await uiAddNode(nodeTypeName, options);
@@ -313,8 +347,8 @@ uiCmd
 });
 uiCmd
     .command('open-workflow <filePath>')
-    .description('Open a workflow file in the editor')
-    .option('-s, --server <url>', 'Editor URL', DEFAULT_SERVER_URL)
+    .description('Open a workflow file in Studio')
+    .option('-s, --server <url>', 'Studio URL', DEFAULT_SERVER_URL)
     .action(async (filePath, options) => {
     try {
         await uiOpenWorkflow(filePath, options);
@@ -326,8 +360,8 @@ uiCmd
 });
 uiCmd
     .command('get-state')
-    .description('Return current workflow state from the editor')
-    .option('-s, --server <url>', 'Editor URL', DEFAULT_SERVER_URL)
+    .description('Return current workflow state from Studio')
+    .option('-s, --server <url>', 'Studio URL', DEFAULT_SERVER_URL)
     .action(async (options) => {
     try {
         await uiGetState(options);
@@ -340,7 +374,7 @@ uiCmd
 uiCmd
     .command('batch <json>')
     .description('Execute a batch of commands with auto-snapshot rollback')
-    .option('-s, --server <url>', 'Editor URL', DEFAULT_SERVER_URL)
+    .option('-s, --server <url>', 'Studio URL', DEFAULT_SERVER_URL)
     .action(async (json, options) => {
     try {
         await uiBatch(json, options);

package/dist/mcp/editor-connection.d.ts

@@ -1,7 +1,7 @@
 import type { AckResponse, EditorConnectionOptions } from './types.js';
 import type { EventBuffer } from './event-buffer.js';
 /**
- * Manages a WebSocket connection to the Flow Weaver editor via socket.io.
+ * Manages a WebSocket connection to Flow Weaver Studio via socket.io.
  * Supports sending commands and batches with request/response correlation,
  * and forwards incoming `fw:` and `integration:` events to an {@link EventBuffer}.
  */
@@ -11,40 +11,42 @@ export declare class EditorConnection {
     private buffer;
     private ioFactory;
     private ackTimeout;
+    private hasLoggedDisconnect;
+    private wasConnected;
     /**
-     * @param serverUrl - The base URL of the editor WebSocket server.
+     * @param serverUrl - The base URL of the Studio WebSocket server.
      * @param buffer - The event buffer to push incoming events into.
      * @param options - Optional connection configuration (custom io factory, ack timeout).
      */
     constructor(serverUrl: string, buffer: EventBuffer, options?: EditorConnectionOptions);
     /**
-     * Establishes a WebSocket connection to the editor's `/integrations` namespace.
+     * Establishes a WebSocket connection to Studio's `/integrations` namespace.
      * Cleans up any previous connection first. Incoming `fw:` and `integration:` events
      * are automatically forwarded to the event buffer.
      * @param log - Optional logging callback for connection lifecycle events.
      */
     connect(log?: (msg: string) => void): void;
-    /** Whether the socket is currently connected to the editor. */
+    /** Whether the socket is currently connected to Studio. */
     get isConnected(): boolean;
     /**
-     * Sends a single command to the editor and waits for an acknowledgement.
+     * Sends a single command to Studio and waits for an acknowledgement.
      * Returns an error response if not connected or if the ack times out.
      * @param action - The command action name (e.g. "get-state", "add-node").
      * @param params - Parameters for the command.
-     * @returns The editor's acknowledgement response.
+     * @returns Studio's acknowledgement response.
      */
     sendCommand(action: string, params: Record<string, unknown>): Promise<AckResponse>;
     /**
-     * Sends a batch of commands to the editor as a single request and waits for acknowledgement.
+     * Sends a batch of commands to Studio as a single request and waits for acknowledgement.
      * Returns an error response if not connected or if the ack times out.
      * @param commands - Array of commands, each with an action name and optional params.
-     * @returns The editor's acknowledgement response for the entire batch.
+     * @returns Studio's acknowledgement response for the entire batch.
      */
     sendBatch(commands: Array<{
         action: string;
         params?: Record<string, unknown>;
     }>): Promise<AckResponse>;
-    /** Disconnects from the editor and releases the socket. */
+    /** Disconnects from Studio and releases the socket. */
     disconnect(): void;
 }
 //# sourceMappingURL=editor-connection.d.ts.map

package/dist/mcp/editor-connection.js

@@ -1,6 +1,6 @@
 import { io as socketIO } from 'socket.io-client';
 /**
- * Manages a WebSocket connection to the Flow Weaver editor via socket.io.
+ * Manages a WebSocket connection to Flow Weaver Studio via socket.io.
  * Supports sending commands and batches with request/response correlation,
  * and forwards incoming `fw:` and `integration:` events to an {@link EventBuffer}.
  */
@@ -10,8 +10,10 @@ export class EditorConnection {
     buffer;
     ioFactory;
     ackTimeout;
+    hasLoggedDisconnect = false;
+    wasConnected = false;
     /**
-     * @param serverUrl - The base URL of the editor WebSocket server.
+     * @param serverUrl - The base URL of the Studio WebSocket server.
      * @param buffer - The event buffer to push incoming events into.
      * @param options - Optional connection configuration (custom io factory, ack timeout).
      */
@@ -22,7 +24,7 @@ export class EditorConnection {
         this.ackTimeout = options?.ackTimeout ?? 10_000;
     }
     /**
-     * Establishes a WebSocket connection to the editor's `/integrations` namespace.
+     * Establishes a WebSocket connection to Studio's `/integrations` namespace.
      * Cleans up any previous connection first. Incoming `fw:` and `integration:` events
      * are automatically forwarded to the event buffer.
      * @param log - Optional logging callback for connection lifecycle events.
@@ -44,12 +46,27 @@ export class EditorConnection {
             reconnectionAttempts: Infinity,
         });
         this.socket.on('connect', () => {
-            log?.(`Connected to editor at ${this.serverUrl}`);
+            const msg = this.wasConnected
+                ? `Reconnected to Studio at ${this.serverUrl}`
+                : `Connected to Studio at ${this.serverUrl}`;
+            log?.(msg);
+            this.hasLoggedDisconnect = false;
+            this.wasConnected = true;
             this.buffer.push('mcp:status', { status: 'connected', server: this.serverUrl });
         });
         if (log) {
-            this.socket.on('disconnect', (reason) => log(`Disconnected from editor: ${reason}`));
-            this.socket.on('connect_error', (err) => log(`Editor connection error: ${err.message}`));
+            this.socket.on('disconnect', () => {
+                if (!this.hasLoggedDisconnect) {
+                    log('Studio disconnected');
+                    this.hasLoggedDisconnect = true;
+                }
+            });
+            this.socket.on('connect_error', () => {
+                if (!this.hasLoggedDisconnect) {
+                    log(`Studio not reachable at ${this.serverUrl}`);
+                    this.hasLoggedDisconnect = true;
+                }
+            });
         }
         this.socket.onAny((event, data) => {
             if (event.startsWith('fw:') || event.startsWith('integration:')) {
@@ -57,16 +74,16 @@ export class EditorConnection {
             }
         });
     }
-    /** Whether the socket is currently connected to the editor. */
+    /** Whether the socket is currently connected to Studio. */
     get isConnected() {
         return this.socket?.connected ?? false;
     }
     /**
-     * Sends a single command to the editor and waits for an acknowledgement.
+     * Sends a single command to Studio and waits for an acknowledgement.
      * Returns an error response if not connected or if the ack times out.
      * @param action - The command action name (e.g. "get-state", "add-node").
      * @param params - Parameters for the command.
-     * @returns The editor's acknowledgement response.
+     * @returns Studio's acknowledgement response.
      */
     async sendCommand(action, params) {
         if (!this.socket) {
@@ -90,10 +107,10 @@ export class EditorConnection {
         });
     }
     /**
-     * Sends a batch of commands to the editor as a single request and waits for acknowledgement.
+     * Sends a batch of commands to Studio as a single request and waits for acknowledgement.
      * Returns an error response if not connected or if the ack times out.
      * @param commands - Array of commands, each with an action name and optional params.
-     * @returns The editor's acknowledgement response for the entire batch.
+     * @returns Studio's acknowledgement response for the entire batch.
      */
     async sendBatch(commands) {
         if (!this.socket) {
@@ -116,7 +133,7 @@ export class EditorConnection {
             this.socket.emit('integration:batch', { requestId, commands });
         });
     }
-    /** Disconnects from the editor and releases the socket. */
+    /** Disconnects from Studio and releases the socket. */
     disconnect() {
         this.socket?.disconnect();
         this.socket = null;

package/dist/mcp/resources.d.ts

@@ -2,12 +2,12 @@ import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { EditorConnection } from './editor-connection.js';
 import type { EventBuffer } from './event-buffer.js';
 /**
- * Registers MCP resources that expose editor state and event data.
+ * Registers MCP resources that expose Studio state and event data.
  * Registers two resources:
  * - `fw://events` - read-only peek at the event buffer.
- * - `fw://state` - current editor/workflow state fetched via the editor connection.
+ * - `fw://state` - current Studio/workflow state fetched via the Studio connection.
  * @param mcp - The MCP server instance to register resources on.
- * @param connection - The editor WebSocket connection used to query state.
+ * @param connection - The Studio WebSocket connection used to query state.
  * @param buffer - The event buffer to read events from.
  */
 export declare function registerResources(mcp: McpServer, connection: EditorConnection, buffer: EventBuffer): void;

package/dist/mcp/resources.js

@@ -1,10 +1,10 @@
 /**
- * Registers MCP resources that expose editor state and event data.
+ * Registers MCP resources that expose Studio state and event data.
  * Registers two resources:
  * - `fw://events` - read-only peek at the event buffer.
- * - `fw://state` - current editor/workflow state fetched via the editor connection.
+ * - `fw://state` - current Studio/workflow state fetched via the Studio connection.
  * @param mcp - The MCP server instance to register resources on.
- * @param connection - The editor WebSocket connection used to query state.
+ * @param connection - The Studio WebSocket connection used to query state.
  * @param buffer - The event buffer to read events from.
  */
 export function registerResources(mcp, connection, buffer) {
@@ -16,13 +16,13 @@ export function registerResources(mcp, connection, buffer) {
             },
         ],
     }));
-    mcp.resource('state', 'fw://state', { description: 'Current editor/workflow state' }, async () => {
+    mcp.resource('state', 'fw://state', { description: 'Current Studio/workflow state' }, async () => {
         if (!connection.isConnected) {
             return {
                 contents: [
                     {
                         uri: 'fw://state',
-                        text: JSON.stringify({ error: 'Not connected to editor' }),
+                        text: JSON.stringify({ error: 'Not connected to Studio' }),
                     },
                 ],
             };

package/dist/mcp/server.js

@@ -3,7 +3,6 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { DEFAULT_SERVER_URL } from '../defaults.js';
 import { EventBuffer } from './event-buffer.js';
 import { EditorConnection } from './editor-connection.js';
-import { offerClaudeRegistration } from './auto-registration.js';
 import { registerEditorTools } from './tools-editor.js';
 import { registerQueryTools } from './tools-query.js';
 import { registerTemplateTools } from './tools-template.js';
@@ -52,7 +51,7 @@ export async function startMcpServer(options) {
     // Use injected deps for testing, or create real ones
     const buffer = options._testDeps?.buffer ?? new EventBuffer(undefined, undefined, filterFromEnv);
     const connection = options._testDeps?.connection ?? new EditorConnection(serverUrl, buffer);
-    // Connect to editor (non-blocking)
+    // Connect to Studio (non-blocking)
     if (!options._testDeps) {
         const log = options.stdio
             ? (msg) => process.stderr.write(msg + '\n')
@@ -91,9 +90,8 @@ export async function mcpServerCommand(options) {
         ? (msg) => process.stderr.write(msg + '\n')
         : (msg) => process.stdout.write(msg + '\n');
     if (!options.stdio) {
-        // Interactive mode — offer registration first
-        await offerClaudeRegistration(options);
-        log(`Starting MCP server (editor: ${serverUrl})...`);
+        log('Tip: run "flow-weaver mcp-setup" to register with your AI tools.');
+        log(`Starting MCP server (Studio: ${serverUrl})...`);
     }
     await startMcpServer(options);
     if (!options.stdio) {

package/dist/mcp/tools-editor.js

@@ -4,8 +4,8 @@ import { executeWorkflowFromFile } from './workflow-executor.js';
 import { AgentChannel } from './agent-channel.js';
 import { storePendingRun, getPendingRun, removePendingRun, listPendingRuns } from './run-registry.js';
 /**
- * Unwrap editor ack responses to flatten double-nested results.
- * Editor returns { requestId, success, result: { actualData } } —
+ * Unwrap Studio ack responses to flatten double-nested results.
+ * Studio returns { requestId, success, result: { actualData } },
  * we extract the `result` field to avoid double-nesting in MCP output.
  */
 function unwrapAckResult(ack) {
@@ -15,25 +15,25 @@ function unwrapAckResult(ack) {
     return ack;
 }
 export function registerEditorTools(mcp, connection, buffer) {
-    mcp.tool('fw_check_events', 'Get buffered editor events. Returns and clears the event buffer unless peek=true.', { peek: z.boolean().optional().describe('If true, read events without clearing the buffer') }, async (args) => {
+    mcp.tool('fw_check_events', 'Get buffered Studio events. Returns and clears the event buffer unless peek=true.', { peek: z.boolean().optional().describe('If true, read events without clearing the buffer') }, async (args) => {
         const events = args.peek ? buffer.peek() : buffer.drain();
         return makeToolResult(events);
     });
-    mcp.tool('fw_get_state', 'Get the current editor/workflow state from Flow Weaver.', {}, async () => {
+    mcp.tool('fw_get_state', 'Get the current Studio/workflow state from Flow Weaver.', {}, async () => {
         if (!connection.isConnected) {
-            return makeErrorResult('EDITOR_NOT_CONNECTED', 'Not connected to the editor. Is the editor running?');
+            return makeErrorResult('EDITOR_NOT_CONNECTED', 'Not connected to Studio. Is Studio running?');
         }
         const result = await connection.sendCommand('get-state', {});
         return makeToolResult(unwrapAckResult(result));
     });
-    mcp.tool('fw_focus_node', 'Select and center a node in the Flow Weaver editor.', { nodeId: z.string().describe('The ID of the node to focus') }, async (args) => {
+    mcp.tool('fw_focus_node', 'Select and center a node in Flow Weaver Studio.', { nodeId: z.string().describe('The ID of the node to focus') }, async (args) => {
         if (!connection.isConnected) {
-            return makeErrorResult('EDITOR_NOT_CONNECTED', 'Not connected to the editor. Is the editor running?');
+            return makeErrorResult('EDITOR_NOT_CONNECTED', 'Not connected to Studio. Is Studio running?');
         }
         const result = await connection.sendCommand('focus-node', { nodeId: args.nodeId });
         return makeToolResult(unwrapAckResult(result));
     });
-    mcp.tool('fw_add_node', 'Add a new node to the workflow in the Flow Weaver editor.', {
+    mcp.tool('fw_add_node', 'Add a new node to the workflow in Flow Weaver Studio.', {
         nodeTypeName: z.string().describe('The name of the node type to add'),
         nodeTypeDefinition: z
             .record(z.unknown())
@@ -41,7 +41,7 @@ export function registerEditorTools(mcp, connection, buffer) {
             .describe('Optional node type definition object'),
     }, async (args) => {
         if (!connection.isConnected) {
-            return makeErrorResult('EDITOR_NOT_CONNECTED', 'Not connected to the editor. Is the editor running?');
+            return makeErrorResult('EDITOR_NOT_CONNECTED', 'Not connected to Studio. Is Studio running?');
         }
         const params = { nodeTypeName: args.nodeTypeName };
         if (args.nodeTypeDefinition) {
@@ -50,19 +50,19 @@ export function registerEditorTools(mcp, connection, buffer) {
         const result = await connection.sendCommand('add-node', params);
         return makeToolResult(unwrapAckResult(result));
     });
-    mcp.tool('fw_open_workflow', 'Open a workflow file in the Flow Weaver editor.', { filePath: z.string().describe('The path to the workflow file to open') }, async (args) => {
+    mcp.tool('fw_open_workflow', 'Open a workflow file in Flow Weaver Studio.', { filePath: z.string().describe('The path to the workflow file to open') }, async (args) => {
         if (!connection.isConnected) {
-            return makeErrorResult('EDITOR_NOT_CONNECTED', 'Not connected to the editor. Is the editor running?');
+            return makeErrorResult('EDITOR_NOT_CONNECTED', 'Not connected to Studio. Is Studio running?');
         }
         const result = await connection.sendCommand('open-workflow', { filePath: args.filePath });
         return makeToolResult(unwrapAckResult(result));
     });
-    mcp.tool('fw_send_command', 'Send a generic command to the Flow Weaver editor.', {
+    mcp.tool('fw_send_command', 'Send a generic command to Flow Weaver Studio.', {
         action: z.string().describe('The command action name'),
         params: z.record(z.unknown()).optional().describe('Optional parameters for the command'),
     }, async (args) => {
         if (!connection.isConnected) {
-            return makeErrorResult('EDITOR_NOT_CONNECTED', 'Not connected to the editor. Is the editor running?');
+            return makeErrorResult('EDITOR_NOT_CONNECTED', 'Not connected to Studio. Is Studio running?');
         }
         const result = await connection.sendCommand(args.action, args.params ?? {});
         return makeToolResult(unwrapAckResult(result));
@@ -76,7 +76,7 @@ export function registerEditorTools(mcp, connection, buffer) {
             .describe('Array of commands to execute as a batch'),
     }, async (args) => {
         if (!connection.isConnected) {
-            return makeErrorResult('EDITOR_NOT_CONNECTED', 'Not connected to the editor. Is the editor running?');
+            return makeErrorResult('EDITOR_NOT_CONNECTED', 'Not connected to Studio. Is Studio running?');
         }
         const result = await connection.sendBatch(args.commands);
         return makeToolResult(unwrapAckResult(result));
@@ -84,7 +84,7 @@ export function registerEditorTools(mcp, connection, buffer) {
     // --- New tools ---
     mcp.tool('fw_remove_node', 'Remove a node and its connections from the workflow.', { nodeName: z.string().describe('The name/ID of the node to remove') }, async (args) => {
         if (!connection.isConnected) {
-            return makeErrorResult('EDITOR_NOT_CONNECTED', 'Not connected to the editor. Is the editor running?');
+            return makeErrorResult('EDITOR_NOT_CONNECTED', 'Not connected to Studio. Is Studio running?');
         }
         const result = await connection.sendCommand('remove-node', { nodeName: args.nodeName });
         return makeToolResult(unwrapAckResult(result));
@@ -101,7 +101,7 @@ export function registerEditorTools(mcp, connection, buffer) {
             .describe('Connection specification'),
     }, async (args) => {
         if (!connection.isConnected) {
-            return makeErrorResult('EDITOR_NOT_CONNECTED', 'Not connected to the editor. Is the editor running?');
+            return makeErrorResult('EDITOR_NOT_CONNECTED', 'Not connected to Studio. Is Studio running?');
         }
         const bridgeAction = args.action === 'add' ? 'add-connection' : 'remove-connection';
         const result = await connection.sendCommand(bridgeAction, {
@@ -111,7 +111,7 @@ export function registerEditorTools(mcp, connection, buffer) {
     });
     mcp.tool('fw_undo_redo', 'Undo or redo the last workflow change.', { action: z.enum(['undo', 'redo']).describe('Whether to undo or redo') }, async (args) => {
         if (!connection.isConnected) {
-            return makeErrorResult('EDITOR_NOT_CONNECTED', 'Not connected to the editor. Is the editor running?');
+            return makeErrorResult('EDITOR_NOT_CONNECTED', 'Not connected to Studio. Is Studio running?');
         }
         const result = await connection.sendCommand(args.action, {});
         return makeToolResult(unwrapAckResult(result));
@@ -123,7 +123,7 @@ export function registerEditorTools(mcp, connection, buffer) {
         filePath: z
             .string()
             .optional()
-            .describe('Path to workflow file. When provided, compiles and executes directly (no editor needed)'),
+            .describe('Path to workflow file. When provided, compiles and executes directly (no Studio needed)'),
         workflowName: z
             .string()
             .optional()
@@ -134,7 +134,7 @@ export function registerEditorTools(mcp, connection, buffer) {
             .optional()
             .describe('Include execution trace events (default: true)'),
     }, async (args, extra) => {
-        // When filePath is provided, compile and execute directly (no editor needed)
+        // When filePath is provided, compile and execute directly (no Studio needed)
         if (args.filePath) {
             try {
                 const channel = new AgentChannel();
@@ -197,9 +197,9 @@ export function registerEditorTools(mcp, connection, buffer) {
                 return makeErrorResult(code, message);
             }
         }
-        // No filePath: delegate to editor via Socket.io (existing behavior)
+        // No filePath: delegate to Studio via Socket.io (existing behavior)
         if (!connection.isConnected) {
-            return makeErrorResult('EDITOR_NOT_CONNECTED', 'Not connected to the editor. Is the editor running?');
+            return makeErrorResult('EDITOR_NOT_CONNECTED', 'Not connected to Studio. Is Studio running?');
         }
         const result = await connection.sendCommand('execute-workflow', args.params ?? {});
         return makeToolResult(unwrapAckResult(result));
@@ -247,7 +247,7 @@ export function registerEditorTools(mcp, connection, buffer) {
     });
     mcp.tool('fw_get_workflow_details', 'Get full workflow structure including nodes, connections, types, and positions.', {}, async () => {
         if (!connection.isConnected) {
-            return makeErrorResult('EDITOR_NOT_CONNECTED', 'Not connected to the editor. Is the editor running?');
+            return makeErrorResult('EDITOR_NOT_CONNECTED', 'Not connected to Studio. Is Studio running?');
         }
         const result = await connection.sendCommand('get-workflow-details', {});
         return makeToolResult(unwrapAckResult(result));

package/dist/mcp/types.d.ts

@@ -3,7 +3,7 @@ import type { EventBuffer } from './event-buffer.js';
 import type { EditorConnection } from './editor-connection.js';
 /** Options for initializing the MCP server. */
 export interface McpServerOptions {
-    /** WebSocket server URL for editor connection. */
+    /** WebSocket server URL for Studio connection. */
     server?: string;
     /** Whether to use stdio transport instead of SSE. */
     stdio?: boolean;
@@ -27,7 +27,7 @@ export interface RegistrationDeps {
     /** Resolve the path to the Flow Weaver CLI executable. */
     resolveCliPath: () => string;
 }
-/** Acknowledgement response returned by the editor after processing a command. */
+/** Acknowledgement response returned by Studio after processing a command. */
 export interface AckResponse {
     /** Unique identifier correlating the response to its originating request. */
     requestId: string;
@@ -47,7 +47,7 @@ export interface BufferedEvent {
     /** ISO 8601 timestamp of when the event was buffered. */
     timestamp: string;
 }
-/** Options for configuring the editor WebSocket connection. */
+/** Options for configuring the Studio WebSocket connection. */
 export interface EditorConnectionOptions {
     /** Custom socket.io factory, primarily used for injecting mocks in tests. */
     ioFactory?: typeof socketIO;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@synergenius/flow-weaver",
-  "version": "0.10.9",
+  "version": "0.10.11",
   "description": "Deterministic workflow compiler for AI agents. Compiles to standalone TypeScript, no runtime dependencies.",
   "private": false,
   "type": "module",
@@ -139,12 +139,14 @@
     "socket.io-client": "^4.8.0",
     "source-map": "^0.7.6",
     "ts-morph": "^21.0.1",
+    "ws": "^8.19.0",
     "zod": "^3.22.4"
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^20.11.0",
     "@types/react": "^19.0.0",
+    "@types/ws": "^8.18.1",
     "@vitest/coverage-v8": "^4.0.18",
     "esbuild": "^0.27.2",
     "prettier": "^3.1.1",