@arvoretech/runtime-lens-mcp 1.0.0

package/extension/runtime-bridge.ts

@@ -0,0 +1,206 @@
+import * as vscode from "vscode";
+import { request } from "node:http";
+import { randomBytes } from "node:crypto";
+import type { Socket } from "node:net";
+import { InlineDecorator } from "./decorator.js";
+
+interface AgentMessage {
+  type: "log" | "error" | "warn" | "info" | "debug" | "result";
+  file: string;
+  line: number;
+  column: number;
+  values: string[];
+  timestamp: number;
+  expression?: string;
+}
+
+export class RuntimeBridge {
+  private socket: Socket | null = null;
+  private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+  private readonly decorator: InlineDecorator;
+  private readonly port: number;
+  private connected = false;
+  private readonly outputChannel: vscode.OutputChannel;
+  private dataBuffer: Buffer = Buffer.alloc(0);
+
+  constructor(decorator: InlineDecorator, outputChannel: vscode.OutputChannel) {
+    this.decorator = decorator;
+    this.port = vscode.workspace.getConfiguration("runtimeLens").get("port", 9500);
+    this.outputChannel = outputChannel;
+  }
+
+  connect(): void {
+    if (this.socket) return;
+
+    const key = randomBytes(16).toString("base64");
+
+    const req = request({
+      hostname: "localhost",
+      port: this.port,
+      path: "/",
+      method: "GET",
+      headers: {
+        Upgrade: "websocket",
+        Connection: "Upgrade",
+        "Sec-WebSocket-Key": key,
+        "Sec-WebSocket-Version": "13",
+      },
+    });
+
+    req.on("upgrade", (_res, socket) => {
+      this.socket = socket;
+      this.connected = true;
+      this.dataBuffer = Buffer.alloc(0);
+      this.outputChannel.appendLine(`[runtime-lens] Connected to agent on port ${this.port}`);
+      vscode.window.setStatusBarMessage("$(eye) Runtime Lens: Connected", 3000);
+
+      socket.on("data", (data: Buffer) => {
+        this.dataBuffer = Buffer.concat([this.dataBuffer, data]);
+        this.processFrames();
+      });
+
+      socket.on("close", () => {
+        this.connected = false;
+        this.socket = null;
+        this.scheduleReconnect();
+      });
+
+      socket.on("error", () => {
+        this.connected = false;
+        this.socket = null;
+      });
+    });
+
+    req.on("error", () => {
+      this.scheduleReconnect();
+    });
+
+    req.end();
+  }
+
+  disconnect(): void {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.socket) {
+      this.socket.end();
+      this.socket = null;
+    }
+    this.connected = false;
+  }
+
+  isConnected(): boolean {
+    return this.connected;
+  }
+
+  evaluate(expression: string, file: string, line: number): void {
+    if (!this.socket || !this.connected) return;
+    const payload = JSON.stringify({ type: "eval", expression, file, line });
+    this.sendFrame(payload);
+  }
+
+  private processFrames(): void {
+    while (this.dataBuffer.length >= 2) {
+      const firstByte = this.dataBuffer[0];
+      const secondByte = this.dataBuffer[1];
+      const isFin = (firstByte & 0x80) !== 0;
+      const opcode = firstByte & 0x0f;
+
+      if (opcode === 0x08) {
+        this.socket?.end();
+        return;
+      }
+
+      let payloadLen = secondByte & 0x7f;
+      let headerLen = 2;
+
+      if (payloadLen === 126) {
+        if (this.dataBuffer.length < 4) return;
+        payloadLen = this.dataBuffer.readUInt16BE(2);
+        headerLen = 4;
+      } else if (payloadLen === 127) {
+        if (this.dataBuffer.length < 10) return;
+        payloadLen = Number(this.dataBuffer.readBigUInt64BE(2));
+        headerLen = 10;
+      }
+
+      const totalLen = headerLen + payloadLen;
+      if (this.dataBuffer.length < totalLen) return;
+
+      const payload = this.dataBuffer.subarray(headerLen, totalLen);
+      this.dataBuffer = this.dataBuffer.subarray(totalLen);
+
+      if (isFin && (opcode === 0x01 || opcode === 0x02)) {
+        const text = payload.toString("utf-8");
+        try {
+          const msg: AgentMessage = JSON.parse(text);
+          this.handleMessage(msg);
+        } catch {
+          // invalid JSON
+        }
+      }
+    }
+  }
+
+  private sendFrame(text: string): void {
+    if (!this.socket) return;
+    const data = Buffer.from(text, "utf-8");
+    const len = data.length;
+    let header: Buffer;
+
+    if (len < 126) {
+      header = Buffer.alloc(2);
+      header[0] = 0x81;
+      header[1] = len;
+    } else if (len < 65536) {
+      header = Buffer.alloc(4);
+      header[0] = 0x81;
+      header[1] = 126;
+      header.writeUInt16BE(len, 2);
+    } else {
+      header = Buffer.alloc(10);
+      header[0] = 0x81;
+      header[1] = 127;
+      header.writeBigUInt64BE(BigInt(len), 2);
+    }
+
+    this.socket.write(Buffer.concat([header, data]));
+  }
+
+  private handleMessage(msg: AgentMessage): void {
+    const workspaceFolders = vscode.workspace.workspaceFolders;
+    if (!workspaceFolders) return;
+
+    let resolvedFile = msg.file;
+    for (const folder of workspaceFolders) {
+      if (msg.file.startsWith(folder.uri.fsPath)) {
+        resolvedFile = msg.file;
+        break;
+      }
+    }
+
+    const text = msg.values.join(", ");
+
+    this.decorator.addValue({
+      file: resolvedFile,
+      line: msg.line,
+      column: msg.column,
+      text,
+      type: msg.type,
+      timestamp: msg.timestamp,
+    });
+
+    this.outputChannel.appendLine(
+      `[${msg.type}] ${resolvedFile}:${msg.line} → ${text}`
+    );
+  }
+
+  private scheduleReconnect(): void {
+    if (this.reconnectTimer) return;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.connect();
+    }, 3000);
+  }
+}

package/extension/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "CommonJS",
+    "moduleResolution": "Node",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": false,
+    "sourceMap": true,
+    "outDir": "../dist/extension",
+    "rootDir": "."
+  },
+  "include": ["./**/*.ts"],
+  "exclude": ["node_modules"]
+}

package/package.json

@@ -0,0 +1,134 @@
+{
+  "name": "@arvoretech/runtime-lens-mcp",
+  "displayName": "Runtime Lens",
+  "version": "1.0.0",
+  "description": "Runtime Lens - Runtime inspection with inline values for React, NestJS and Next.js",
+  "publisher": "arvore",
+  "main": "dist/extension/extension.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "runtime-lens-mcp": "./dist/index.js"
+  },
+  "engines": {
+    "vscode": "^1.85.0"
+  },
+  "categories": [
+    "Debuggers",
+    "Other"
+  ],
+  "activationEvents": [
+    "onStartupFinished"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "build:ext": "esbuild extension/extension.ts --bundle --outfile=dist/extension/extension.js --external:vscode --format=cjs --platform=node --sourcemap",
+    "build:agent": "esbuild agent/index.ts --bundle --outfile=dist/agent/index.js --format=cjs --platform=node --sourcemap",
+    "build:all": "pnpm build && pnpm build:ext && pnpm build:agent",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "package": "pnpm build:all && vsce package --no-dependencies",
+    "prepublishOnly": "node -e \"const p=require('./package.json');p.name='@arvoretech/runtime-lens-mcp';require('fs').writeFileSync('package.json',JSON.stringify(p,null,2)+'\\n')\"",
+    "postpublish": "node -e \"const p=require('./package.json');p.name='runtime-lens';require('fs').writeFileSync('package.json',JSON.stringify(p,null,2)+'\\n')\"",
+    "test": "vitest",
+    "test:cov": "vitest --coverage",
+    "lint": "eslint src/**/*.ts",
+    "lint:fix": "eslint src/**/*.ts --fix"
+  },
+  "contributes": {
+    "commands": [
+      {
+        "command": "runtimeLens.start",
+        "title": "Runtime Lens: Start",
+        "icon": "$(zap)"
+      },
+      {
+        "command": "runtimeLens.stop",
+        "title": "Runtime Lens: Stop"
+      },
+      {
+        "command": "runtimeLens.toggle",
+        "title": "Runtime Lens: Toggle"
+      },
+      {
+        "command": "runtimeLens.clear",
+        "title": "Runtime Lens: Clear Inline Values"
+      },
+      {
+        "command": "runtimeLens.connect",
+        "title": "Runtime Lens: Connect to Running App"
+      },
+      {
+        "command": "runtimeLens.showOutput",
+        "title": "Runtime Lens: Show Output"
+      },
+      {
+        "command": "runtimeLens.injectEnv",
+        "title": "Runtime Lens: Inject Environment into Terminal"
+      }
+    ],
+    "configuration": {
+      "title": "Runtime Lens",
+      "properties": {
+        "runtimeLens.port": {
+          "type": "number",
+          "default": 9500,
+          "description": "WebSocket port for the runtime agent"
+        },
+        "runtimeLens.autoStart": {
+          "type": "boolean",
+          "default": false,
+          "description": "Automatically start Runtime Lens when the workspace opens"
+        },
+        "runtimeLens.maxInlineLength": {
+          "type": "number",
+          "default": 80,
+          "description": "Maximum length of inline value text before truncation"
+        },
+        "runtimeLens.showTimestamp": {
+          "type": "boolean",
+          "default": false,
+          "description": "Show timestamp in inline values"
+        }
+      }
+    },
+    "menus": {
+      "editor/title": [
+        {
+          "command": "runtimeLens.toggle",
+          "group": "navigation",
+          "when": "resourceLangId == typescript || resourceLangId == javascript || resourceLangId == typescriptreact || resourceLangId == javascriptreact"
+        }
+      ]
+    }
+  },
+  "keywords": [
+    "mcp",
+    "console-ninja",
+    "runtime-lens",
+    "debugging",
+    "logging",
+    "inline-values",
+    "react",
+    "nestjs",
+    "nextjs",
+    "runtime-inspection",
+    "arvore"
+  ],
+  "author": "Arvore",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/arvoreeducacao/arvore-mcp-servers.git",
+    "directory": "packages/runtime-lens"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/vscode": "^1.85.0",
+    "esbuild": "^0.21.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+
+import { RuntimeLensMCPServer } from "./server.js";
+
+try {
+  const server = RuntimeLensMCPServer.fromEnvironment();
+  server.setupGracefulShutdown();
+  await server.start();
+} catch (error) {
+  console.error("Failed to start Runtime Lens MCP Server:", error);
+  process.exit(1);
+}
+
+export { RuntimeLensMCPServer } from "./server.js";
+export { LogCollector } from "./log-collector.js";
+export { ProcessInspector } from "./process-inspector.js";
+export { RuntimeInterceptor } from "./runtime-interceptor.js";
+export * from "./types.js";