refactor: enhance build and hot-reload process

- Updated package.json scripts for improved build and clean processes.
- Introduced a new `clean:all` script to remove the entire build directory.
- Added `build:full` script for a complete build without cleaning the build directory.
- Modified `post-build.ts` to compile chrome-devtools-frontend only when necessary.
- Implemented content hashing in `extension-watcher.ts` and `mcp-server-watcher.ts` to prevent unnecessary rebuilds.
- Removed unused output panel and reload MCP server tools.
- Added new tsconfig.build.json for optimized TypeScript compilation.

Author: AndyLiner13

package.json

@@ -6,11 +6,13 @@
   "bin": "./build/src/index.js",
   "main": "index.js",
   "scripts": {
-    "clean": "node -e \"require('fs').rmSync('build', {recursive: true, force: true})\"",
-    "bundle": "pnpm run clean && pnpm run build && rollup -c rollup.config.mjs && node -e \"require('fs').rmSync('build/node_modules', {recursive: true, force: true})\"",
-    "build": "node -e \"require('fs').rmSync('build', {recursive: true, force: true})\" && tsc && node --experimental-strip-types --no-warnings=ExperimentalWarning scripts/post-build.ts",
+    "clean": "node -e \"const fs=require('fs');if(fs.existsSync('build/src'))fs.rmSync('build/src',{recursive:true,force:true});for(const f of['build/tsconfig.tsbuildinfo','build/tsconfig.build.tsbuildinfo'])try{fs.unlinkSync(f)}catch{}\"",
+    "clean:all": "node -e \"require('fs').rmSync('build', {recursive: true, force: true})\"",
+    "bundle": "pnpm run clean:all && pnpm run build:full && rollup -c rollup.config.mjs && node -e \"require('fs').rmSync('build/node_modules', {recursive: true, force: true})\"",
+    "build": "pnpm run clean && tsc -p tsconfig.build.json && node --experimental-strip-types --no-warnings=ExperimentalWarning scripts/post-build.ts",
+    "build:full": "pnpm run clean:all && tsc && node --experimental-strip-types --no-warnings=ExperimentalWarning scripts/post-build.ts",
     "typecheck": "tsc --noEmit",
-    "dev": "pnpm run clean && tsc && node --experimental-strip-types --no-warnings=ExperimentalWarning scripts/post-build.ts && tsc --watch --preserveWatchOutput",
+    "dev": "pnpm run clean && tsc -p tsconfig.build.json && node --experimental-strip-types --no-warnings=ExperimentalWarning scripts/post-build.ts && tsc -p tsconfig.build.json --watch --preserveWatchOutput",
     "format": "eslint --cache --fix . && prettier --write --cache .",
     "check-format": "eslint --cache . && prettier --check --cache .;",
     "docs": "pnpm run build && pnpm run docs:generate && pnpm run format",

scripts/post-build.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import {execSync} from 'node:child_process';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 
@@ -15,10 +16,24 @@ const BUILD_DIR = path.join(process.cwd(), 'build');
  * @param content The content to write.
  */
 function writeFile(filePath: string, content: string): void {
+  fs.mkdirSync(path.dirname(filePath), {recursive: true});
   fs.writeFileSync(filePath, content, 'utf-8');
 }
 
 function main(): void {
+  // chrome-devtools-frontend ships as .ts source — it must be compiled to .js
+  // for runtime. These files never change between pnpm installs, so we compile
+  // them once and preserve build/node_modules/ across rebuilds (clean only
+  // deletes build/src/). If the vendor output is missing, compile it now.
+  const vendorMarker = path.join(
+    BUILD_DIR, 'node_modules', 'chrome-devtools-frontend', 'mcp', 'mcp.js',
+  );
+  if (!fs.existsSync(vendorMarker)) {
+    console.log('Vendor build not found — compiling chrome-devtools-frontend (one-time)…');
+    execSync('tsc --noCheck', {cwd: process.cwd(), stdio: 'inherit'});
+    console.log('Vendor build complete.');
+  }
+
   const devtoolsThirdPartyPath =
     'node_modules/chrome-devtools-frontend/front_end/third_party';
   const devtoolsFrontEndCorePath =

src/client-pipe.ts

@@ -96,15 +96,6 @@ export interface TerminalSessionInfo {
   command?: string;
 }
 
-export interface OutputChannelsResult {
-  channels: string[];
-}
-
-export interface OutputReadResult {
-  lines: string[];
-  warning?: string;
-}
-
 export interface CommandExecuteResult {
   result: unknown;
 }
@@ -212,28 +203,6 @@ function sendClientRequest(
   });
 }
 
-// ── Output Methods ───────────────────────────────────────
-
-/**
- * List available output channels.
- */
-export async function outputListChannels(): Promise<OutputChannelsResult> {
-  const result = await sendClientRequest('output.listChannels', {});
-  assertResult<OutputChannelsResult>(result, 'output.listChannels');
-  return result;
-}
-
-/**
- * Read content from an output channel.
- */
-export async function outputRead(
-  channel: string,
-): Promise<OutputReadResult> {
-  const result = await sendClientRequest('output.read', {channel});
-  assertResult<OutputReadResult>(result, 'output.read');
-  return result;
-}
-
 // ── Command Methods ──────────────────────────────────────
 
 /**

src/extension-watcher.ts

@@ -8,24 +8,29 @@
 /**
  * Extension folder change detection for hot-reload.
  *
- * Timestamp strategy:
- * - Read the most recent mtimeMs across all tracked extension files.
- * - Compare it against the debug window session start time.
- * - If newest mtimeMs > sessionStartMs, trigger extension hot-reload.
+ * Two-phase detection strategy:
+ * 1. Fast mtime check: compares newest source mtime against newest dist/ mtime.
+ * 2. Content hash verification: when mtime suggests staleness, computes a
+ *    SHA-256 fingerprint of all source file contents and compares against
+ *    the stored fingerprint. This prevents false positives from operations
+ *    that update file metadata without changing content (e.g. `git add`).
  *
  * Tracked files are filtered by:
  * 1. Built-in ignore defaults (node_modules, dist, .git, *.vsix)
  * 2. Optional `<extensionRoot>/.devtoolsignore` patterns
  */
 
-import {existsSync, readdirSync, readFileSync, statSync} from 'node:fs';
+import {createHash} from 'node:crypto';
+import {existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync} from 'node:fs';
 import path, {extname, join, relative} from 'node:path';
 
 import {logger} from './logger.js';
 
 const IGNORE_DIRS = new Set(['node_modules', 'dist', '.git']);
 const IGNORE_EXTENSIONS = new Set(['.vsix']);
 const DEVTOOLS_IGNORE_FILENAME = '.devtoolsignore';
+const EXT_FINGERPRINT_DIR = '.devtools';
+const EXT_FINGERPRINT_FILE = 'ext-source-fingerprint.json';
 
 interface IgnoreRule {
   pattern: string;
@@ -191,6 +196,89 @@ export function getNewestTrackedChangeTime(extensionDir: string): number {
   return result.newestMtimeMs;
 }
 
+// ── Content Hashing ──────────────────────────────────────
+
+function hashDirectoryContents(
+  dir: string,
+  rootDir: string,
+  rules: IgnoreRule[],
+  hash: ReturnType<typeof createHash>,
+): void {
+  let entries: string[];
+  try {
+    entries = readdirSync(dir, {encoding: 'utf8'});
+  } catch {
+    return;
+  }
+  entries.sort();
+
+  for (const name of entries) {
+    const fullPath = join(dir, name);
+    let stat: ReturnType<typeof statSync>;
+    try {
+      stat = statSync(fullPath);
+    } catch {
+      continue;
+    }
+
+    if (stat.isDirectory()) {
+      if (shouldIgnorePath(rootDir, fullPath, true, rules)) continue;
+      hashDirectoryContents(fullPath, rootDir, rules, hash);
+    } else if (stat.isFile()) {
+      if (shouldIgnorePath(rootDir, fullPath, false, rules)) continue;
+      const rel = path.posix.normalize(relative(rootDir, fullPath).replaceAll('\\', '/'));
+      hash.update(rel);
+      try {
+        hash.update(readFileSync(fullPath));
+      } catch {
+        // skip unreadable files
+      }
+    }
+  }
+}
+
+function computeExtSourceFingerprint(extensionDir: string, rules: IgnoreRule[]): string {
+  const hash = createHash('sha256');
+  hashDirectoryContents(extensionDir, extensionDir, rules, hash);
+  return hash.digest('hex');
+}
+
+function readExtFingerprint(extensionDir: string): string | null {
+  const fp = join(extensionDir, EXT_FINGERPRINT_DIR, EXT_FINGERPRINT_FILE);
+  if (!existsSync(fp)) return null;
+  try {
+    const raw = readFileSync(fp, 'utf8');
+    const data: unknown = JSON.parse(raw);
+    if (typeof data === 'object' && data !== null && 'hash' in data) {
+      const hash = (data as Record<string, unknown>).hash;
+      if (typeof hash === 'string') return hash;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Persist the current extension source fingerprint so future checks can skip
+ * rebuilds when only file metadata (not content) changed.
+ */
+export function writeExtSourceFingerprint(extensionDir: string): void {
+  const rules = parseIgnoreRules(extensionDir);
+  const hash = computeExtSourceFingerprint(extensionDir, rules);
+  const dir = join(extensionDir, EXT_FINGERPRINT_DIR);
+  try {
+    mkdirSync(dir, {recursive: true});
+    writeFileSync(
+      join(dir, EXT_FINGERPRINT_FILE),
+      JSON.stringify({hash, computedAt: Date.now()}),
+    );
+    logger(`[hot-reload] Extension fingerprint written: ${hash.slice(0, 12)}…`);
+  } catch (err) {
+    logger(`[hot-reload] Failed to write extension fingerprint: ${err}`);
+  }
+}
+
 /**
  * Check whether extension files changed after the debug window started.
  *
@@ -269,35 +357,50 @@ export function getNewestBuildMtime(extensionDir: string): number {
 /**
  * Check if the extension build is stale (source files newer than build output).
  *
- * This compares the newest source file mtime against the newest dist/ file mtime.
- * If source is newer, the build is stale and needs hot-reload.
+ * Uses a two-phase approach:
+ * 1. Fast mtime comparison of source vs dist/ output.
+ * 2. Content hash verification when mtime suggests staleness, to filter
+ *    out metadata-only changes (e.g. git staging).
  *
  * @param extensionDir Extension root directory
- * @returns true if source files are newer than build output (needs rebuild)
+ * @returns true if source content has actually changed since last build
  */
 export function isBuildStale(extensionDir: string): boolean {
   const sourceNewest = getNewestTrackedChangeTime(extensionDir);
   const buildNewest = getNewestBuildMtime(extensionDir);
 
-  // If no build exists, definitely stale
   if (buildNewest === 0) {
     logger(`[hot-reload] No build found in dist/ — build is stale`);
     return true;
   }
 
-  const stale = sourceNewest > buildNewest;
-
-  if (stale) {
+  if (sourceNewest <= buildNewest) {
     logger(
-      `[hot-reload] Build STALE: source=${new Date(sourceNewest).toISOString()} > build=${new Date(buildNewest).toISOString()}`,
+      `[hot-reload] Build up-to-date: source=${new Date(sourceNewest).toISOString()} <= build=${new Date(buildNewest).toISOString()}`,
     );
-  } else {
+    return false;
+  }
+
+  // Mtime says stale — verify with content hash
+  logger(
+    `[hot-reload] Mtime suggests stale: source=${new Date(sourceNewest).toISOString()} > build=${new Date(buildNewest).toISOString()} — verifying content…`,
+  );
+
+  const rules = parseIgnoreRules(extensionDir);
+  const currentHash = computeExtSourceFingerprint(extensionDir, rules);
+  const storedHash = readExtFingerprint(extensionDir);
+
+  if (storedHash && currentHash === storedHash) {
     logger(
-      `[hot-reload] Build up-to-date: source=${new Date(sourceNewest).toISOString()} <= build=${new Date(buildNewest).toISOString()}`,
+      `[hot-reload] Content unchanged (fingerprint=${currentHash.slice(0, 12)}…) — metadata-only change, skipping rebuild`,
     );
+    return false;
   }
 
-  return stale;
+  logger(
+    `[hot-reload] Content changed: ${storedHash ? `${storedHash.slice(0, 12)}… → ${currentHash.slice(0, 12)}…` : `new fingerprint ${currentHash.slice(0, 12)}…`}`,
+  );
+  return true;
 }
 
 /**

src/logger.ts

@@ -31,7 +31,7 @@ function formatLogChunks(chunks: unknown[]): string {
 // Always enable the mcp:log namespace so output is visible.
 // By default, write to stderr in a clean timestamped format.
 // stderr output appears in the host VS Code's MCP output channel
-// as "[server stderr]" entries, giving full visibility via read_host_output.
+// as "[server stderr]" entries, giving full visibility via read_output_channels.
 debug.enable(namespacesToEnable.join(','));
 debug.log = function (...chunks: unknown[]) {
   const ts = new Date().toISOString();

src/main.ts

@@ -7,11 +7,12 @@
 import './polyfill.js';
 
 import {exec} from 'node:child_process';
+import path from 'node:path';
 import process from 'node:process';
 
 import {parseArguments} from './cli.js';
 import {loadConfig, type ResolvedConfig} from './config.js';
-import {hasBuildChangedSinceWindowStart, isBuildStale} from './extension-watcher.js';
+import {hasBuildChangedSinceWindowStart, isBuildStale, writeExtSourceFingerprint} from './extension-watcher.js';
 import {restartMcpServer, showHostNotification} from './host-pipe.js';
 import {loadIssueDescriptions} from './issue-descriptions.js';
 import {logger, saveLogsToFile} from './logger.js';
@@ -22,6 +23,7 @@ import {
   hasBuildChangedSinceProcessStart,
   hasMcpServerSourceChanged,
   writeHotReloadMarker,
+  writeSourceFingerprint,
 } from './mcp-server-watcher.js';
 import {startMcpSocketServer} from './mcp-socket-server.js';
 import {Mutex} from './Mutex.js';
@@ -59,21 +61,24 @@ let mcpServerRestartScheduled = false;
 let extensionHotReloadInfo: {builtAt: number} | null = null;
 
 /**
- * Run an incremental build for hot-reload: `tsc` + `post-build` WITHOUT
- * `rmSync('build')`. The full `pnpm run build` cleans the build dir first,
- * but the running MCP server process IS loaded from `build/src/` — on
- * Windows the running process holds file locks, causing EPERM.
+ * Run an incremental build for hot-reload using the fast tsconfig.build.json
+ * (src-only, noCheck) WITHOUT `rmSync('build')`.
+ *
+ * Uses tsconfig.build.json which only compiles src/ files with noCheck,
+ * skipping the 800+ chrome-devtools-frontend files and type-checking.
+ * This reduces build time from ~18s to ~2s.
  *
  * Incremental tsc overwrites files in-place, which works fine even while
  * the old code is loaded (Node.js has already read them into memory).
  */
 function runMcpServerBuild(): Promise<{stdout: string; stderr: string}> {
   return new Promise((resolve, reject) => {
     logger(`[mcp-hot-reload] Running incremental build in ${mcpServerDir}`);
-    const cmd = 'npx tsc && node --experimental-strip-types --no-warnings=ExperimentalWarning scripts/post-build.ts';
+    const tscBin = path.join(mcpServerDir, 'node_modules', '.bin', process.platform === 'win32' ? 'tsc.cmd' : 'tsc');
+    const cmd = `"${tscBin}" -p tsconfig.build.json && node --experimental-strip-types --no-warnings=ExperimentalWarning scripts/post-build.ts`;
     exec(
       cmd,
-      {cwd: mcpServerDir, timeout: 120_000},
+      {cwd: mcpServerDir, timeout: 30_000, shell: process.platform === 'win32' ? 'cmd.exe' : '/bin/sh'},
       (err, stdout, stderr) => {
         if (err) {
           const output = [stdout, stderr].filter(Boolean).join('\n').trim();
@@ -392,6 +397,7 @@ function registerTool(tool: ToolDefinition): void {
 
               try {
                 await runMcpServerBuild();
+                writeSourceFingerprint(mcpServerDir);
                 writeHotReloadMarker(mcpServerDir);
                 scheduleMcpServerRestart();
 
@@ -487,6 +493,7 @@ function registerTool(tool: ToolDefinition): void {
             const reason = stale ? 'source stale' : 'manual build detected';
             logger(`[tool:${tool.name}] Extension needs hot-reload (${reason}) — reloading…`);
             await lifecycleService.handleHotReload();
+            writeExtSourceFingerprint(config.extensionBridgePath);
             extensionHotReloadInfo = {builtAt: Date.now()};
             logger(`[tool:${tool.name}] Hot-reload complete — reconnected`);
           }