retrocode-mcp 1.3.0

package/mcp-server.js

@@ -0,0 +1,572 @@
+#!/usr/bin/env node
+// RETROCODE_MCP_VERSION=1.3.0
+/**
+ * RetroCode MCP Server + Channel
+ *
+ * Connects Claude to the RetroCode editor via the local HTTP API.
+ * Supports both MCP tools (23 tools) AND Channel push notifications.
+ *
+ * As MCP server (tools only):
+ *   claude mcp add retrocode node ~/mcp-server.js
+ *
+ * As Channel (push + tools — recommended):
+ *   claude --dangerously-load-development-channels server:retrocode
+ *   (or add to channels config once published)
+ *
+ * When running as a Channel, RetroCode chat messages are pushed directly
+ * into Claude's session — no polling needed, instant response.
+ */
+
+const http = require('http');
+
+const API_BASE = 'http://127.0.0.1:21580';
+
+// ── HTTP helpers ──────────────────────────────────────
+
+// Track last content written via set_editor so save_file can use it
+let lastWrittenContent = '';
+let lastWrittenLanguage = '';
+
+function apiGet(path) {
+  return new Promise((resolve, reject) => {
+    http.get(`${API_BASE}${path}`, (res) => {
+      let data = '';
+      res.on('data', (chunk) => data += chunk);
+      res.on('end', () => {
+        try { resolve(JSON.parse(data)); }
+        catch { resolve(data); }
+      });
+    }).on('error', reject);
+  });
+}
+
+function apiPost(path, body) {
+  return new Promise((resolve, reject) => {
+    const data = JSON.stringify(body);
+    const req = http.request(`${API_BASE}${path}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(data) },
+    }, (res) => {
+      let result = '';
+      res.on('data', (chunk) => result += chunk);
+      res.on('end', () => {
+        try { resolve(JSON.parse(result)); }
+        catch { resolve(result); }
+      });
+    });
+    req.on('error', reject);
+    req.write(data);
+    req.end();
+  });
+}
+
+function apiPut(path, body) {
+  return new Promise((resolve, reject) => {
+    const data = JSON.stringify(body);
+    const req = http.request(`${API_BASE}${path}`, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(data) },
+    }, (res) => {
+      let result = '';
+      res.on('data', (chunk) => result += chunk);
+      res.on('end', () => {
+        try { resolve(JSON.parse(result)); }
+        catch { resolve(result); }
+      });
+    });
+    req.on('error', reject);
+    req.write(data);
+    req.end();
+  });
+}
+
+// ── MCP Protocol (JSON-RPC over stdio) ────────────────
+
+const tools = [
+  {
+    name: 'retrocode_get_editor',
+    description: 'Get the current content of the RetroCode editor, including the mode (asm/basic/text), language, file path, and full editor text.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+  },
+  {
+    name: 'retrocode_set_editor',
+    description: 'Set the content of the RetroCode editor. Always specify the language so syntax highlighting and file saving work correctly. This replaces the current editor content.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        content: { type: 'string', description: 'The new editor content' },
+        language: { type: 'string', description: 'Programming language (required for correct highlighting and save). Use: python, javascript, typescript, bash, powershell, c, cpp, csharp, rust, go, ruby, swift, kotlin, java, lua, perl, r, html, css, yaml, json, sql, toml, markdown, dockerfile' },
+        mode: { type: 'string', description: 'Optional: switch mode (asm, basic, text). Defaults to text for code.', enum: ['asm', 'basic', 'text'] },
+      },
+      required: ['content', 'language'],
+    },
+  },
+  {
+    name: 'retrocode_get_mode',
+    description: 'Get the current RetroCode mode: asm (assembly), basic (BASIC programming), or text (code editor).',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+  },
+  {
+    name: 'retrocode_append_editor',
+    description: 'Append text to the current editor content (adds to the end instead of replacing).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        content: { type: 'string', description: 'Text to append to the editor' },
+      },
+      required: ['content'],
+    },
+  },
+  {
+    name: 'retrocode_read_file',
+    description: 'Read a file from disk into the RetroCode editor. Specify the full path.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Full file path to read' },
+      },
+      required: ['path'],
+    },
+  },
+  {
+    name: 'retrocode_save_file',
+    description: 'Save content to a file on disk. If content is not provided, saves the last content that was written via retrocode_set_editor.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Full file path to save to' },
+        content: { type: 'string', description: 'Content to save. If omitted, uses the last content from retrocode_set_editor.' },
+      },
+      required: ['path'],
+    },
+  },
+  {
+    name: 'retrocode_list_tabs',
+    description: 'List all open editor tabs in the current mode. Returns tab index, filename, language, and modified status.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+  },
+  {
+    name: 'retrocode_switch_tab',
+    description: 'Switch to a specific editor tab by index (0-based) in the current mode.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        index: { type: 'number', description: 'Tab index (0-based)' },
+      },
+      required: ['index'],
+    },
+  },
+  {
+    name: 'retrocode_new_tab',
+    description: 'Open a new editor tab in the current mode (max 5). Optionally provide content and language.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        content: { type: 'string', description: 'Initial content for the new tab' },
+        language: { type: 'string', description: 'Language for syntax highlighting' },
+      },
+    },
+  },
+  {
+    name: 'retrocode_list_languages',
+    description: 'List all supported programming languages with their file extensions.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+  },
+  {
+    name: 'retrocode_switch_mode',
+    description: 'Switch RetroCode mode. Modes: asm (Assembly), basic (BASIC), text (Code editor).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        mode: { type: 'string', description: 'Mode to switch to', enum: ['asm', 'basic', 'text'] },
+      },
+      required: ['mode'],
+    },
+  },
+  {
+    name: 'retrocode_run',
+    description: 'Execute the current program. In ASM mode: assembles and runs. In BASIC mode: runs the program. Returns status.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+  },
+  {
+    name: 'retrocode_stop',
+    description: 'Stop the currently running program (ASM or BASIC).',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+  },
+  {
+    name: 'retrocode_chat',
+    description: 'Send a message to the user via the RetroCode chat panel. Use this to explain what you are doing, ask questions, provide guidance, or coach the user. Messages appear in a chat panel inside RetroCode.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        text: { type: 'string', description: 'Message to display to the user' },
+      },
+      required: ['text'],
+    },
+  },
+  {
+    name: 'retrocode_open_terminal',
+    description: 'Open the RetroCode terminal with the appropriate shell for the platform.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+  },
+  {
+    name: 'retrocode_close_terminal',
+    description: 'Close the RetroCode terminal.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+  },
+  {
+    name: 'retrocode_get_chat',
+    description: 'Read all chat messages from the RetroCode chat panel. Use this to check if the user has responded to your messages.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+  },
+  {
+    name: 'retrocode_terminal',
+    description: 'Send a command to a RetroCode terminal. The terminal must be open. Use this to run scripts, execute commands, show output to the user. The command runs in the user\'s actual shell (zsh/bash/PowerShell).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        command: { type: 'string', description: 'Shell command to execute (e.g., "python3 script.py", "ls -la", "echo hello")' },
+        terminal_id: { type: 'string', description: 'Terminal ID (e.g., "term-1"). Defaults to active terminal.' },
+      },
+      required: ['command'],
+    },
+  },
+  {
+    name: 'retrocode_terminal_output',
+    description: 'Read the last 5KB of terminal output. Use this to see the result of commands you sent to the terminal.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        terminal_id: { type: 'string', description: 'Terminal ID (e.g., "term-1"). Defaults to active terminal.' },
+      },
+    },
+  },
+  {
+    name: 'retrocode_heartbeat',
+    description: 'Send a heartbeat to RetroCode to keep the connection status green. Call this periodically (every 30s) during long operations to show the user you are still working.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+  },
+  {
+    name: 'retrocode_asm_reference',
+    description: 'Get the complete RetroCode assembly language reference — all 36 opcodes, registers, memory map, label syntax, and graphics commands. Call this before writing assembly code.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+  },
+  {
+    name: 'retrocode_basic_reference',
+    description: 'Get the complete RetroCode BASIC V2.0 reference — all commands, math/string functions, graphics commands, and syntax. Call this before writing BASIC code.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+  },
+  {
+    name: 'retrocode_health',
+    description: 'Check if RetroCode is running and the MCP API is available. RetroCode must be running for all tools to work. If not running, tell the user to launch RetroCode first.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+  },
+];
+
+async function handleToolCall(name, args) {
+  switch (name) {
+    case 'retrocode_get_editor': {
+      const state = await apiGet('/api/editor');
+      return { content: [{ type: 'text', text: JSON.stringify(state, null, 2) }] };
+    }
+    case 'retrocode_set_editor': {
+      lastWrittenContent = args.content || '';
+      lastWrittenLanguage = args.language || '';
+      const body = {
+        content: lastWrittenContent,
+        language: lastWrittenLanguage,
+        mode: args.mode || 'text',
+      };
+      await apiPut('/api/editor', body);
+      return { content: [{ type: 'text', text: `Editor updated (${args.language || 'text'}).` }] };
+    }
+    case 'retrocode_append_editor': {
+      await apiPost('/api/editor/append', { content: args.content || '' });
+      return { content: [{ type: 'text', text: 'Content appended to editor.' }] };
+    }
+    case 'retrocode_get_mode': {
+      const state = await apiGet('/api/editor');
+      return { content: [{ type: 'text', text: `Current mode: ${state.mode || 'unknown'}` }] };
+    }
+    case 'retrocode_read_file': {
+      const http2 = require('http');
+      const readData = JSON.stringify({ path: args.path });
+      // Use the Tauri backend to read the file
+      const content = await new Promise((resolve, reject) => {
+        const req = http2.request(`${API_BASE}/api/readfile?path=${encodeURIComponent(args.path)}`, (res) => {
+          let body = '';
+          res.on('data', c => body += c);
+          res.on('end', () => resolve(body));
+        });
+        req.on('error', reject);
+        req.end();
+      });
+      return { content: [{ type: 'text', text: content }] };
+    }
+    case 'retrocode_save_file': {
+      // Use provided content, or last written content, or try API state as fallback
+      let fileContent = args.content || lastWrittenContent;
+      if (!fileContent) {
+        const editor = await apiGet('/api/editor');
+        fileContent = editor.content || '';
+      }
+      if (!fileContent) {
+        return { content: [{ type: 'text', text: 'Error: No content to save. Write to the editor first with retrocode_set_editor.' }], isError: true };
+      }
+      const saveData = JSON.stringify({ path: args.path, content: fileContent });
+      await new Promise((resolve, reject) => {
+        const req = http.request(`${API_BASE}/api/savefile`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(saveData) },
+        }, (res) => {
+          let body = '';
+          res.on('data', c => body += c);
+          res.on('end', () => resolve(body));
+        });
+        req.on('error', reject);
+        req.write(saveData);
+        req.end();
+      });
+      return { content: [{ type: 'text', text: `File saved to: ${args.path}` }] };
+    }
+    case 'retrocode_list_tabs': {
+      const state = await apiGet('/api/editor');
+      const tabs = state.tabs || [{ index: 0, name: state.file_path || 'untitled', language: state.language, modified: false }];
+      return { content: [{ type: 'text', text: JSON.stringify(tabs, null, 2) }] };
+    }
+    case 'retrocode_switch_tab': {
+      await apiPut('/api/editor', { tab_index: args.index });
+      return { content: [{ type: 'text', text: `Switched to tab ${args.index}` }] };
+    }
+    case 'retrocode_new_tab': {
+      await apiPost('/api/editor/newtab', { content: args.content || '', language: args.language || '' });
+      return { content: [{ type: 'text', text: 'New tab opened.' }] };
+    }
+    case 'retrocode_list_languages': {
+      const langs = [
+        'bash (.sh)', 'c (.c)', 'cpp (.cpp)', 'csharp (.cs)', 'css (.css)',
+        'dockerfile (Dockerfile)', 'go (.go)', 'html (.html)', 'json (.json)',
+        'javascript (.js)', 'kotlin (.kt)', 'lua (.lua)', 'markdown (.md)',
+        'perl (.pl)', 'powershell (.ps1)', 'python (.py)', 'r (.r)',
+        'ruby (.rb)', 'rust (.rs)', 'sql (.sql)', 'swift (.swift)',
+        'toml (.toml)', 'typescript (.ts)', 'yaml (.yml)'
+      ];
+      return { content: [{ type: 'text', text: 'Supported languages:\n' + langs.join('\n') }] };
+    }
+    case 'retrocode_switch_mode': {
+      await apiPut('/api/editor', { mode: args.mode });
+      return { content: [{ type: 'text', text: `Switched to ${args.mode} mode.` }] };
+    }
+    case 'retrocode_run': {
+      await apiPost('/api/action', { action: 'run' });
+      return { content: [{ type: 'text', text: 'Program running.' }] };
+    }
+    case 'retrocode_stop': {
+      await apiPost('/api/action', { action: 'stop' });
+      return { content: [{ type: 'text', text: 'Program stopped.' }] };
+    }
+    case 'retrocode_chat': {
+      const ts = Math.floor(Date.now() / 1000);
+      await apiPost('/api/chat', { role: 'claude', text: args.text, timestamp: ts });
+      return { content: [{ type: 'text', text: 'Message sent to chat panel.' }] };
+    }
+    case 'retrocode_open_terminal': {
+      await apiPost('/api/action', { action: 'open_terminal' });
+      return { content: [{ type: 'text', text: 'Terminal opened.' }] };
+    }
+    case 'retrocode_close_terminal': {
+      await apiPost('/api/action', { action: 'close_terminal' });
+      return { content: [{ type: 'text', text: 'Terminal closed.' }] };
+    }
+    case 'retrocode_get_chat': {
+      const msgs = await apiGet('/api/chat');
+      return { content: [{ type: 'text', text: JSON.stringify(msgs, null, 2) }] };
+    }
+    case 'retrocode_terminal': {
+      const body = { command: args.command };
+      if (args.terminal_id) body.terminal_id = args.terminal_id;
+      await apiPost('/api/terminal', body);
+      return { content: [{ type: 'text', text: `Terminal command sent: ${args.command}` }] };
+    }
+    case 'retrocode_terminal_output': {
+      // Try dedicated endpoint first, fall back to editor state
+      let output = '';
+      try { output = await apiGet('/api/terminal/output'); } catch {}
+      if (!output || output === '{}') {
+        const state = await apiGet('/api/editor');
+        output = state.terminal_output || '';
+      }
+      // Strip ANSI codes for readability
+      output = String(output).replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '').replace(/[\x00-\x08\x0e-\x1f]/g, '');
+      return { content: [{ type: 'text', text: output || '(no output yet — terminal may still be running)' }] };
+    }
+    case 'retrocode_heartbeat': {
+      await apiPost('/api/heartbeat', {});
+      return { content: [{ type: 'text', text: 'Heartbeat sent.' }] };
+    }
+    case 'retrocode_asm_reference': {
+      const ref = await apiGet('/api/reference/asm');
+      return { content: [{ type: 'text', text: JSON.stringify(ref, null, 2) }] };
+    }
+    case 'retrocode_basic_reference': {
+      const ref = await apiGet('/api/reference/basic');
+      return { content: [{ type: 'text', text: JSON.stringify(ref, null, 2) }] };
+    }
+    case 'retrocode_health': {
+      const health = await apiGet('/api/health');
+      return { content: [{ type: 'text', text: JSON.stringify(health) }] };
+    }
+    default:
+      throw new Error(`Unknown tool: ${name}`);
+  }
+}
+
+// ── JSON-RPC message handling ─────────────────────────
+
+let buffer = '';
+
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (chunk) => {
+  buffer += chunk;
+
+  // Process complete messages (newline-delimited JSON)
+  const lines = buffer.split('\n');
+  buffer = lines.pop() || '';
+
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    try {
+      const msg = JSON.parse(line);
+      handleMessage(msg);
+    } catch (e) {
+      // Skip malformed messages
+    }
+  }
+});
+
+function sendResponse(id, result) {
+  const response = { jsonrpc: '2.0', id, result };
+  process.stdout.write(JSON.stringify(response) + '\n');
+}
+
+function sendError(id, code, message) {
+  const response = { jsonrpc: '2.0', id, error: { code, message } };
+  process.stdout.write(JSON.stringify(response) + '\n');
+}
+
+// ── Channel push notifications ───────────────────────
+
+let channelEnabled = false;
+let lastSeenUserMsgCount = 0;
+let channelPollTimer = null;
+
+function sendNotification(method, params) {
+  const msg = { jsonrpc: '2.0', method, params };
+  process.stdout.write(JSON.stringify(msg) + '\n');
+}
+
+function pushChannelMessage(content, meta) {
+  if (!channelEnabled) return;
+  sendNotification('notifications/claude/channel', { content, meta: meta || {} });
+}
+
+async function startChannelPolling() {
+  // Initialize message count
+  try {
+    const msgs = await apiGet('/api/chat');
+    const userMsgs = Array.isArray(msgs) ? msgs.filter(m => m.role === 'user') : [];
+    lastSeenUserMsgCount = userMsgs.length;
+  } catch {}
+
+  // Send heartbeat to RetroCode
+  apiPost('/api/heartbeat', {}).catch(() => {});
+
+  // Poll for new messages every 1 second
+  channelPollTimer = setInterval(async () => {
+    try {
+      // Heartbeat
+      apiPost('/api/heartbeat', {}).catch(() => {});
+
+      // Check for new user messages
+      const msgs = await apiGet('/api/chat');
+      const userMsgs = Array.isArray(msgs) ? msgs.filter(m => m.role === 'user') : [];
+
+      if (userMsgs.length > lastSeenUserMsgCount) {
+        const newMsgs = userMsgs.slice(lastSeenUserMsgCount);
+        lastSeenUserMsgCount = userMsgs.length;
+
+        for (const msg of newMsgs) {
+          // Get editor context for richer push
+          let context = '';
+          try {
+            const editor = await apiGet('/api/editor');
+            if (editor.mode) context = ` [mode: ${editor.mode}]`;
+            if (editor.language) context += ` [lang: ${editor.language}]`;
+          } catch {}
+
+          process.stderr.write(`[channel] New message: ${msg.text}\n`);
+          pushChannelMessage(
+            `RetroCode chat message from user${context}: ${msg.text}`,
+            { source: 'retrocode-chat', mode: 'user-message' }
+          );
+        }
+      }
+    } catch (e) {
+      // Connection lost — keep trying
+    }
+  }, 1000);
+}
+
+// ── JSON-RPC message handling ─────────────────────────
+
+async function handleMessage(msg) {
+  const { id, method, params } = msg;
+
+  switch (method) {
+    case 'initialize':
+      sendResponse(id, {
+        protocolVersion: '2024-11-05',
+        capabilities: {
+          tools: {},
+          experimental: { 'claude/channel': {} },
+        },
+        serverInfo: { name: 'retrocode', version: '1.3.0' },
+      });
+      break;
+
+    case 'notifications/initialized':
+      // Start channel polling after initialization
+      channelEnabled = true;
+      process.stderr.write('[channel] Channel mode active — pushing RetroCode events to Claude\n');
+      startChannelPolling();
+      break;
+
+    case 'tools/list':
+      sendResponse(id, { tools });
+      break;
+
+    case 'tools/call':
+      try {
+        const result = await handleToolCall(params.name, params.arguments || {});
+        sendResponse(id, result);
+      } catch (e) {
+        sendResponse(id, {
+          content: [{ type: 'text', text: `Error: ${e.message}. Is RetroCode running?` }],
+          isError: true,
+        });
+      }
+      break;
+
+    case 'ping':
+      sendResponse(id, {});
+      break;
+
+    default:
+      if (id) sendError(id, -32601, `Method not found: ${method}`);
+      break;
+  }
+}
+
+// Keep the process alive
+process.stdin.resume();
+process.stderr.write('RetroCode MCP server started (with Channel support). Waiting for Claude...\n');

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "retrocode-mcp",
+  "version": "1.3.0",
+  "description": "RetroCode MCP server — connects Claude to the RetroCode editor with 23 tools and Channel push notifications",
+  "main": "mcp-server.js",
+  "bin": {
+    "retrocode-mcp": "mcp-server.js"
+  },
+  "scripts": {
+    "start": "node mcp-server.js"
+  },
+  "keywords": ["mcp", "retrocode", "claude", "anthropic", "assembly", "basic"],
+  "author": "senzall",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  }
+}