@arvoretech/runtime-lens-mcp 1.0.0 → 1.2.0

package/.vscodeignore

@@ -1,21 +0,0 @@
-src/**
-extension/**/*.ts
-agent/**/*.ts
-node_modules/**
-coverage/**
-examples/**
-.gitignore
-*.tsbuildinfo
-tsconfig.json
-**/tsconfig.json
-vitest.config.ts
-eslint.config.js
-pnpm-lock.yaml
-**/*.map
-dist/index.d.ts
-dist/log-collector.d.ts
-dist/process-inspector.d.ts
-dist/runtime-interceptor.d.ts
-dist/server.d.ts
-dist/types.d.ts
-dist/agent/index.debug.js

package/agent/tsconfig.json

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

package/eslint.config.js

@@ -1,41 +0,0 @@
-import eslint from '@eslint/js';
-import tseslint from '@typescript-eslint/eslint-plugin';
-import tsparser from '@typescript-eslint/parser';
-
-export default [
-  eslint.configs.recommended,
-  {
-    files: ['src/**/*.ts'],
-    languageOptions: {
-      parser: tsparser,
-      parserOptions: {
-        ecmaVersion: 2022,
-        sourceType: 'module',
-      },
-      globals: {
-        console: 'readonly',
-        process: 'readonly',
-        Buffer: 'readonly',
-        BufferEncoding: 'readonly',
-        __dirname: 'readonly',
-        __filename: 'readonly',
-        global: 'readonly',
-        setTimeout: 'readonly',
-        clearTimeout: 'readonly',
-        setInterval: 'readonly',
-        clearInterval: 'readonly',
-        require: 'readonly',
-      },
-    },
-    plugins: {
-      '@typescript-eslint': tseslint,
-    },
-    rules: {
-      ...tseslint.configs.recommended.rules,
-      'no-redeclare': 'off',
-      '@typescript-eslint/no-unused-vars': 'error',
-      '@typescript-eslint/explicit-function-return-type': 'warn',
-      '@typescript-eslint/no-explicit-any': 'warn',
-    },
-  },
-];

package/extension/decorator.ts

@@ -1,144 +0,0 @@
-import * as vscode from "vscode";
-
-interface InlineValue {
-  file: string;
-  line: number;
-  column: number;
-  text: string;
-  type: "log" | "error" | "warn" | "info" | "debug" | "result";
-  timestamp: number;
-}
-
-const TYPE_COLORS: Record<string, string> = {
-  log: "#6A9955",
-  info: "#569CD6",
-  warn: "#CE9178",
-  error: "#F44747",
-  debug: "#9CDCFE",
-  result: "#DCDCAA",
-};
-
-export class InlineDecorator {
-  private decorationTypes: Map<string, vscode.TextEditorDecorationType> = new Map();
-  private values: Map<string, InlineValue[]> = new Map();
-  private disposables: vscode.Disposable[] = [];
-
-  activate(context: vscode.ExtensionContext): void {
-    this.disposables.push(
-      vscode.window.onDidChangeActiveTextEditor(() => this.refresh()),
-      vscode.workspace.onDidChangeTextDocument((e) => {
-        if (e.document === vscode.window.activeTextEditor?.document) {
-          this.refresh();
-        }
-      })
-    );
-    context.subscriptions.push(...this.disposables);
-  }
-
-  addValue(value: InlineValue): void {
-    const key = value.file;
-    if (!this.values.has(key)) {
-      this.values.set(key, []);
-    }
-
-    const existing = this.values.get(key)!;
-    const idx = existing.findIndex((v) => v.line === value.line);
-    if (idx >= 0) {
-      existing[idx] = value;
-    } else {
-      existing.push(value);
-    }
-
-    if (existing.length > 1000) {
-      existing.splice(0, existing.length - 1000);
-    }
-
-    this.refresh();
-  }
-
-  clearFile(file: string): void {
-    this.values.delete(file);
-    this.refresh();
-  }
-
-  clearAll(): void {
-    this.values.clear();
-    this.clearDecorations();
-  }
-
-  refresh(): void {
-    const editor = vscode.window.activeTextEditor;
-    if (!editor) return;
-
-    this.clearDecorations();
-
-    const filePath = editor.document.uri.fsPath;
-    const fileValues = this.values.get(filePath);
-    if (!fileValues || fileValues.length === 0) return;
-
-    const decorationsByType = new Map<string, vscode.DecorationOptions[]>();
-
-    for (const value of fileValues) {
-      const lineIndex = value.line - 1;
-      if (lineIndex < 0 || lineIndex >= editor.document.lineCount) continue;
-
-      const lineText = editor.document.lineAt(lineIndex).text;
-      const range = new vscode.Range(
-        new vscode.Position(lineIndex, lineText.length),
-        new vscode.Position(lineIndex, lineText.length)
-      );
-
-      const truncated = value.text.length > 80
-        ? value.text.slice(0, 80) + "…"
-        : value.text;
-
-      const decoration: vscode.DecorationOptions = {
-        range,
-        hoverMessage: new vscode.MarkdownString(
-          `**Runtime Lens** (${value.type})\n\n\`\`\`\n${value.text}\n\`\`\`\n\n*${new Date(value.timestamp).toLocaleTimeString()}*`
-        ),
-        renderOptions: {
-          after: {
-            contentText: `  // → ${truncated}`,
-            color: TYPE_COLORS[value.type] || "#6A9955",
-            fontStyle: "italic",
-            margin: "0 0 0 1em",
-          },
-        },
-      };
-
-      const typeKey = value.type;
-      if (!decorationsByType.has(typeKey)) {
-        decorationsByType.set(typeKey, []);
-      }
-      decorationsByType.get(typeKey)!.push(decoration);
-    }
-
-    for (const [typeKey, decorations] of decorationsByType) {
-      const decorationType = vscode.window.createTextEditorDecorationType({
-        after: {
-          color: TYPE_COLORS[typeKey] || "#6A9955",
-          fontStyle: "italic",
-        },
-        isWholeLine: false,
-      });
-
-      this.decorationTypes.set(typeKey, decorationType);
-      editor.setDecorations(decorationType, decorations);
-    }
-  }
-
-  private clearDecorations(): void {
-    for (const decorationType of this.decorationTypes.values()) {
-      decorationType.dispose();
-    }
-    this.decorationTypes.clear();
-  }
-
-  dispose(): void {
-    this.clearDecorations();
-    for (const d of this.disposables) {
-      d.dispose();
-    }
-  }
-}

package/extension/extension.ts

@@ -1,98 +0,0 @@
-import * as vscode from "vscode";
-import { join } from "node:path";
-import { InlineDecorator } from "./decorator.js";
-import { RuntimeBridge } from "./runtime-bridge.js";
-
-let decorator: InlineDecorator;
-let bridge: RuntimeBridge;
-let statusBarItem: vscode.StatusBarItem;
-
-export function activate(context: vscode.ExtensionContext): void {
-  const outputChannel = vscode.window.createOutputChannel("Runtime Lens");
-  const agentPath = join(context.extensionPath, "dist", "agent", "index.js");
-
-  decorator = new InlineDecorator();
-  decorator.activate(context);
-
-  bridge = new RuntimeBridge(decorator, outputChannel);
-
-  statusBarItem = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 100);
-  statusBarItem.text = "$(eye) Lens";
-  statusBarItem.tooltip = "Runtime Lens - Click to toggle";
-  statusBarItem.command = "runtimeLens.toggle";
-  statusBarItem.show();
-  context.subscriptions.push(statusBarItem);
-
-  const port = vscode.workspace.getConfiguration("runtimeLens").get("port", 9500);
-
-  context.subscriptions.push(
-    vscode.commands.registerCommand("runtimeLens.start", () => {
-      bridge.connect();
-      updateStatusBar(true);
-      vscode.window.showInformationMessage("Runtime Lens: Listening for logs...");
-    }),
-
-    vscode.commands.registerCommand("runtimeLens.stop", () => {
-      bridge.disconnect();
-      decorator.clearAll();
-      updateStatusBar(false);
-      vscode.window.showInformationMessage("Runtime Lens: Stopped");
-    }),
-
-    vscode.commands.registerCommand("runtimeLens.toggle", () => {
-      if (bridge.isConnected()) {
-        vscode.commands.executeCommand("runtimeLens.stop");
-      } else {
-        vscode.commands.executeCommand("runtimeLens.start");
-      }
-    }),
-
-    vscode.commands.registerCommand("runtimeLens.clear", () => {
-      decorator.clearAll();
-      vscode.window.showInformationMessage("Runtime Lens: Cleared");
-    }),
-
-    vscode.commands.registerCommand("runtimeLens.connect", () => {
-      bridge.connect();
-      updateStatusBar(true);
-    }),
-
-    vscode.commands.registerCommand("runtimeLens.showOutput", () => {
-      outputChannel.show();
-    }),
-
-    vscode.commands.registerCommand("runtimeLens.injectEnv", () => {
-      const terminal = vscode.window.activeTerminal;
-      if (!terminal) {
-        vscode.window.showWarningMessage("Runtime Lens: No active terminal");
-        return;
-      }
-      terminal.sendText(`export NODE_OPTIONS="--require ${agentPath}"`, true);
-      terminal.sendText(`export RUNTIME_LENS_PORT="${port}"`, true);
-      vscode.window.showInformationMessage("Runtime Lens: Environment injected. Run your app now.");
-    })
-  );
-
-  const autoStart = vscode.workspace.getConfiguration("runtimeLens").get("autoStart", false);
-  if (autoStart) {
-    vscode.commands.executeCommand("runtimeLens.start");
-  }
-
-  outputChannel.appendLine(`[runtime-lens] Extension activated`);
-  outputChannel.appendLine(`[runtime-lens] Agent path: ${agentPath}`);
-}
-
-function updateStatusBar(active: boolean): void {
-  if (active) {
-    statusBarItem.text = "$(eye) Lens ●";
-    statusBarItem.backgroundColor = new vscode.ThemeColor("statusBarItem.warningBackground");
-  } else {
-    statusBarItem.text = "$(eye) Lens";
-    statusBarItem.backgroundColor = undefined;
-  }
-}
-
-export function deactivate(): void {
-  bridge?.disconnect();
-  decorator?.dispose();
-}

package/extension/runtime-bridge.ts

@@ -1,206 +0,0 @@
-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

@@ -1,17 +0,0 @@
-{
-  "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/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "Node",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "resolveJsonModule": true,
-    "allowSyntheticDefaultImports": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}

package/vitest.config.ts

@@ -1,13 +0,0 @@
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: {
-    globals: true,
-    environment: "node",
-    passWithNoTests: true,
-    coverage: {
-      provider: "v8",
-      reporter: ["text", "json", "html"],
-    },
-  },
-});