@inspecto-dev/plugin 0.2.0-alpha.0 → 0.2.0-alpha.2

package/dist/legacy/webpack4/index.js

@@ -0,0 +1,953 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// ../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.8_typescript@5.9.3_yaml@2.8.3/node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var getFilename = () => fileURLToPath(import.meta.url);
+var getDirname = () => path.dirname(getFilename());
+var __dirname = /* @__PURE__ */ getDirname();
+
+// src/injectors/webpack.ts
+function getWebpackHtmlScript(serverPort) {
+  return `
+window.__AI_INSPECTOR_PORT__ = ${serverPort};
+window.addEventListener('load', () => {
+  if (window.InspectoClient) {
+    window.InspectoClient.mountInspector({
+      serverUrl: 'http://127.0.0.1:' + window.__AI_INSPECTOR_PORT__,
+    });
+  }
+});
+`;
+}
+
+// src/injectors/utils.ts
+import { createRequire } from "module";
+var resolveClientModule = () => {
+  try {
+    return createRequire(import.meta.url).resolve("@inspecto-dev/core");
+  } catch {
+    try {
+      return __require.resolve("@inspecto-dev/core");
+    } catch {
+      console.warn(
+        "[inspecto] Could not resolve @inspecto-dev/core \u2014 falling back to bare specifier"
+      );
+      return "@inspecto-dev/core";
+    }
+  }
+};
+
+// src/server/index.ts
+import http from "http";
+import fs3 from "fs";
+import path4 from "path";
+import os2 from "os";
+import crypto from "crypto";
+import { execSync, execFileSync } from "child_process";
+import portfinder from "portfinder";
+import { launchIDE } from "launch-ide";
+import { INSPECTO_API_PATHS } from "@inspecto-dev/types";
+
+// src/server/snippet.ts
+import * as fs from "fs";
+import * as path2 from "path";
+import * as parser from "@babel/parser";
+import traverse_ from "@babel/traverse";
+var traverse = typeof traverse_ === "function" ? traverse_ : traverse_.default || traverse_;
+var snippetCache = /* @__PURE__ */ new Map();
+var DEFAULT_MAX_LINES = 100;
+var DEFAULT_CONTEXT_LINES_BEFORE = 5;
+async function extractSnippet(req) {
+  const { file, line, column, maxLines = DEFAULT_MAX_LINES } = req;
+  const absolutePath = path2.resolve(file);
+  let stat;
+  try {
+    stat = await fs.promises.stat(absolutePath);
+  } catch {
+    throw new Error(`FILE_NOT_FOUND: ${absolutePath}`);
+  }
+  const mtime = stat.mtimeMs;
+  let lines;
+  const cached = snippetCache.get(absolutePath);
+  if (cached && cached.mtime === mtime) {
+    lines = cached.lines;
+  } else {
+    const source = await fs.promises.readFile(absolutePath, "utf-8");
+    lines = source.split("\n");
+    snippetCache.set(absolutePath, { mtime, lines });
+  }
+  let snippetLines;
+  let startLine;
+  let componentName;
+  try {
+    const result = extractComponentBoundary(lines.join("\n"), line, column, maxLines);
+    snippetLines = result.lines;
+    startLine = result.startLine;
+    componentName = result.name;
+  } catch {
+    const before = Math.max(0, line - 1 - DEFAULT_CONTEXT_LINES_BEFORE);
+    const after = Math.min(lines.length, before + maxLines);
+    snippetLines = lines.slice(before, after);
+    startLine = before + 1;
+  }
+  if (snippetLines.length > maxLines) {
+    snippetLines = snippetLines.slice(0, maxLines);
+  }
+  return {
+    snippet: snippetLines.join("\n"),
+    startLine,
+    file: absolutePath,
+    ...componentName ? { name: componentName } : {}
+  };
+}
+function extractComponentBoundary(source, targetLine, _targetColumn, maxLines) {
+  const ast = parser.parse(source, {
+    sourceType: "module",
+    plugins: ["jsx", "typescript", "decorators-legacy", "classProperties"],
+    errorRecovery: true
+  });
+  const allLines = source.split("\n");
+  let bestStart = 0;
+  let bestEnd = allLines.length - 1;
+  let bestName;
+  traverse(ast, {
+    "FunctionDeclaration|FunctionExpression|ArrowFunctionExpression|ClassMethod"(nodePath) {
+      const node = nodePath.node;
+      if (!node.loc) return;
+      const nodeStart = node.loc.start.line;
+      const nodeEnd = node.loc.end.line;
+      if (targetLine < nodeStart || targetLine > nodeEnd) return;
+      if (nodeEnd - nodeStart < bestEnd - bestStart) {
+        bestStart = nodeStart - 1;
+        bestEnd = nodeEnd - 1;
+        bestName = extractFunctionName(nodePath);
+      }
+    }
+  });
+  let sliceStart = bestStart;
+  let sliceEnd = bestEnd + 1;
+  if (sliceEnd - sliceStart > maxLines) {
+    const targetIdx = targetLine - 1;
+    sliceStart = Math.max(bestStart, targetIdx - Math.floor(maxLines / 3));
+    sliceEnd = sliceStart + maxLines;
+    if (sliceEnd > bestEnd + 1) {
+      sliceEnd = bestEnd + 1;
+      sliceStart = Math.max(0, sliceEnd - maxLines);
+    }
+  }
+  return {
+    lines: allLines.slice(sliceStart, sliceEnd),
+    startLine: sliceStart + 1,
+    ...bestName ? { name: bestName } : {}
+  };
+}
+function extractFunctionName(nodePath) {
+  const node = nodePath.node;
+  if (node.type === "FunctionDeclaration" && node.id) {
+    return node.id.name;
+  }
+  const parent = nodePath.parent;
+  if ((node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") && parent.type === "VariableDeclarator" && parent.id.type === "Identifier") {
+    return parent.id.name;
+  }
+  if (node.type === "ClassMethod" && node.key.type === "Identifier") {
+    return node.key.name;
+  }
+  return void 0;
+}
+
+// src/config.ts
+import fs2 from "fs";
+import path3 from "path";
+import os from "os";
+import { createDefu } from "defu";
+import {
+  DEFAULT_PROVIDER_MODE,
+  VALID_MODES,
+  DEFAULT_INTENTS
+} from "@inspecto-dev/types";
+
+// src/utils/logger.ts
+var LOG_LEVELS = {
+  silent: 0,
+  error: 1,
+  warn: 2,
+  info: 3
+};
+function isDebugEnabled(namespace) {
+  if (typeof process === "undefined" || !process.env) return false;
+  const debugEnv = process.env.DEBUG;
+  if (!debugEnv) return false;
+  const namespaces = debugEnv.split(",").map((s) => s.trim());
+  for (const ns of namespaces) {
+    if (ns === "*") return true;
+    if (ns.endsWith("*")) {
+      const prefix = ns.slice(0, -1);
+      if (namespace.startsWith(prefix)) return true;
+    } else if (ns === namespace) {
+      return true;
+    }
+  }
+  return false;
+}
+var globalLevel = "warn";
+var registeredLoggers = /* @__PURE__ */ new Set();
+function createLogger(namespace, options) {
+  let currentLevel = options?.logLevel ?? globalLevel;
+  let numericLevel = LOG_LEVELS[currentLevel] ?? 2;
+  const debugEnabled = isDebugEnabled(namespace);
+  const logger = {
+    setLevel(level) {
+      currentLevel = level;
+      numericLevel = LOG_LEVELS[level] ?? 2;
+    },
+    info(msg, ...args) {
+      if (numericLevel >= LOG_LEVELS.info) {
+        console.log(`\x1B[36m[inspecto]\x1B[0m ${msg}`, ...args);
+      }
+    },
+    warn(msg, ...args) {
+      if (numericLevel >= LOG_LEVELS.warn) {
+        console.warn(`\x1B[33m[inspecto] WARN:\x1B[0m ${msg}`, ...args);
+      }
+    },
+    error(msg, ...args) {
+      if (numericLevel >= LOG_LEVELS.error) {
+        console.error(`\x1B[31m[inspecto] ERROR:\x1B[0m ${msg}`, ...args);
+      }
+    },
+    debug(msg, ...args) {
+      if (debugEnabled) {
+        console.log(`\x1B[90m[${namespace}]\x1B[0m ${msg}`, ...args);
+      }
+    }
+  };
+  registeredLoggers.add(logger);
+  return logger;
+}
+
+// src/config.ts
+var configLogger = createLogger("inspecto:config");
+var loadedConfig = null;
+var loadedPrompts = null;
+var globalLogLevel = "warn";
+var isWatching = false;
+var arrayReplaceMerge = createDefu((obj, key, val) => {
+  if (Array.isArray(val)) {
+    obj[key] = val;
+    return true;
+  }
+});
+function getGlobalLogLevel() {
+  return globalLogLevel;
+}
+function resolveConfigRoots(cwd, gitRoot) {
+  const roots = [];
+  let current = cwd;
+  const isUnderOrEqual = current === gitRoot || current.startsWith(gitRoot + path3.sep);
+  if (!isUnderOrEqual) {
+    if (fs2.existsSync(path3.join(cwd, ".inspecto"))) roots.push(cwd);
+    return roots;
+  }
+  while (true) {
+    if (fs2.existsSync(path3.join(current, ".inspecto"))) {
+      roots.push(current);
+    }
+    if (current === gitRoot) break;
+    const parent = path3.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return roots;
+}
+function loadUserConfigSync(force = false, cwd = process.cwd(), gitRoot) {
+  if (loadedConfig && !force) return loadedConfig;
+  loadedConfig = null;
+  const layers = [];
+  const roots = resolveConfigRoots(cwd, gitRoot ?? cwd);
+  for (const root of roots) {
+    layers.push(readJsonSafely(path3.join(root, ".inspecto", "settings.local.json")));
+    layers.push(readJsonSafely(path3.join(root, ".inspecto", "settings.json")));
+  }
+  layers.push(readJsonSafely(path3.join(os.homedir(), ".inspecto", "settings.json")));
+  layers.push({});
+  const validLayers = layers.filter((l) => l !== null);
+  loadedConfig = arrayReplaceMerge(...validLayers);
+  return loadedConfig;
+}
+async function loadPromptsConfig(force = false, cwd = process.cwd(), gitRoot) {
+  if (loadedPrompts && !force) return loadedPrompts;
+  const layers = [];
+  const roots = resolveConfigRoots(cwd, gitRoot ?? cwd);
+  for (const root of roots) {
+    const localPath = path3.join(root, ".inspecto", "prompts.local.json");
+    const jsonPath = path3.join(root, ".inspecto", "prompts.json");
+    layers.push(readJsonSafely(localPath));
+    layers.push(readJsonSafely(jsonPath));
+  }
+  layers.push(readJsonSafely(path3.join(os.homedir(), ".inspecto", "prompts.json")));
+  let finalPrompts = [];
+  for (const layer of layers) {
+    if (Array.isArray(layer) && layer.length > 0) {
+      finalPrompts = layer;
+      break;
+    }
+    if (layer && typeof layer === "object" && layer.$replace === true && Array.isArray(layer.items)) {
+      finalPrompts = layer;
+      break;
+    }
+  }
+  loadedPrompts = finalPrompts;
+  return loadedPrompts;
+}
+function readJsonSafely(filePath) {
+  try {
+    if (fs2.existsSync(filePath)) {
+      const content = fs2.readFileSync(filePath, "utf-8").trim();
+      if (!content) return null;
+      const parsed = JSON.parse(content);
+      if (!Array.isArray(parsed) && parsed.prompts && Array.isArray(parsed.prompts)) {
+        return parsed.prompts;
+      }
+      return parsed;
+    }
+  } catch (e) {
+    if (e instanceof SyntaxError) {
+      configLogger.warn(`Failed to parse config at ${filePath}: Invalid JSON`);
+    } else {
+      configLogger.warn(`Failed to read config at ${filePath}:`, e);
+    }
+  }
+  return null;
+}
+function resolveTargetTool(config, ide = "vscode") {
+  const defaultProvider = config["provider.default"];
+  if (defaultProvider) {
+    const tool = defaultProvider.split(".")[0];
+    return tool;
+  }
+  return "copilot";
+}
+function resolveProviderMode(tool, ide, config) {
+  let requestedType = void 0;
+  const defaultProvider = config["provider.default"];
+  if (defaultProvider && defaultProvider.startsWith(`${tool}.`)) {
+    const mode = defaultProvider.split(".")[1];
+    if (mode === "extension") requestedType = "extension";
+    if (mode === "cli") requestedType = "cli";
+  }
+  requestedType = requestedType ?? DEFAULT_PROVIDER_MODE[tool];
+  const valid = VALID_MODES[tool] || [DEFAULT_PROVIDER_MODE[tool]];
+  return requestedType && valid.includes(requestedType) ? requestedType : valid[0];
+}
+function extractToolOverrides(ide, config) {
+  const result = {};
+  if (!config) return result;
+  for (const [key, value] of Object.entries(config)) {
+    if (!key.startsWith("provider.")) continue;
+    if (key === "provider.default") continue;
+    const toolIndex = 1;
+    const modeIndex = 2;
+    const propIndex = 3;
+    const parts = key.split(".");
+    if (parts.length >= propIndex + 1) {
+      const tool = parts[toolIndex];
+      const mode = parts[modeIndex];
+      const prop = parts[propIndex];
+      if (!result[tool]) {
+        result[tool] = { type: mode };
+      }
+      const overrides = result[tool];
+      if (prop === "bin") overrides.binaryPath = value;
+      if (prop === "args") overrides.args = value;
+      if (prop === "cwd") overrides.cwd = value;
+      if (prop === "coldStartDelay") overrides.coldStartDelay = value;
+    }
+  }
+  return result;
+}
+function resolveIntents(serverPrompts) {
+  const baseMap = /* @__PURE__ */ new Map();
+  for (const intent of DEFAULT_INTENTS) {
+    if (intent.id) baseMap.set(intent.id, { ...intent });
+  }
+  const defaults = () => ensureOpenInEditorLast(Array.from(baseMap.values()));
+  if (!serverPrompts) return defaults();
+  const isReplace = !Array.isArray(serverPrompts) && typeof serverPrompts === "object" && serverPrompts.$replace === true;
+  const promptsArray = Array.isArray(serverPrompts) ? serverPrompts : isReplace ? serverPrompts.items : [];
+  if (!promptsArray || promptsArray.length === 0) return defaults();
+  if (isReplace) {
+    const result = [];
+    for (const item of promptsArray) {
+      if (typeof item === "string") {
+        if (baseMap.has(item)) {
+          result.push(baseMap.get(item));
+        } else {
+          configLogger.warn(
+            `Unknown built-in intent id: "${item}". Available: ${[...baseMap.keys()].join(", ")}`
+          );
+        }
+      } else if (typeof item === "object") {
+        if (!item.id) {
+          configLogger.warn('Intent object missing required "id" field, skipping.');
+          continue;
+        }
+        if (item.enabled === false) {
+          configLogger.warn(
+            `Intent "${item.id}" is listed in $replace but has enabled:false \u2014 it will be excluded.`
+          );
+          continue;
+        }
+        if (item.isAction && item.id !== "open-in-editor") {
+          configLogger.warn(
+            `isAction is reserved for built-in actions. Ignoring intent "${item.id}".`
+          );
+          continue;
+        }
+        result.push(baseMap.has(item.id) ? { ...baseMap.get(item.id), ...item } : item);
+      }
+    }
+    return ensureOpenInEditorLast(result);
+  }
+  const merged = Array.from(baseMap.values());
+  for (const item of promptsArray) {
+    if (typeof item === "string") {
+      if (!baseMap.has(item)) {
+        configLogger.warn(
+          `Unknown built-in intent id: "${item}". In append mode, strings have no effect on ordering \u2014 use $replace to control order.`
+        );
+      }
+      continue;
+    }
+    if (typeof item === "object") {
+      if (!item.id) {
+        configLogger.warn('Intent object missing required "id" field, skipping.');
+        continue;
+      }
+      if (item.isAction && item.id !== "open-in-editor") {
+        configLogger.warn(
+          `isAction is reserved for built-in actions. Ignoring intent "${item.id}".`
+        );
+        continue;
+      }
+      const existingIdx = merged.findIndex((i) => i.id === item.id);
+      if (existingIdx !== -1) {
+        if (item.enabled === false) {
+          merged.splice(existingIdx, 1);
+        } else {
+          merged[existingIdx] = { ...merged[existingIdx], ...item };
+        }
+      } else {
+        if (item.enabled !== false) {
+          merged.push(item);
+        }
+      }
+    }
+  }
+  return ensureOpenInEditorLast(merged);
+}
+function ensureOpenInEditorLast(intents) {
+  const idx = intents.findIndex((i) => i.id === "open-in-editor");
+  if (idx === -1 || idx === intents.length - 1) return intents;
+  const result = [...intents];
+  const item = result.splice(idx, 1)[0];
+  result.push(item);
+  return result;
+}
+var watchers = [];
+function watchConfig(onReload, cwd = process.cwd(), gitRoot) {
+  if (isWatching) return;
+  isWatching = true;
+  const watchDirs = [path3.join(os.homedir(), ".inspecto")];
+  const roots = resolveConfigRoots(cwd, gitRoot ?? cwd);
+  for (const root of roots) {
+    watchDirs.push(path3.join(root, ".inspecto"));
+  }
+  const CONFIG_FILES = /* @__PURE__ */ new Set([
+    "settings.json",
+    "settings.local.json",
+    "prompts.json",
+    "prompts.local.json"
+  ]);
+  for (const dir of watchDirs) {
+    if (!fs2.existsSync(dir)) continue;
+    try {
+      const watcher = fs2.watch(dir, async (eventType, filename) => {
+        if (!filename || !CONFIG_FILES.has(filename)) return;
+        loadedConfig = null;
+        loadedPrompts = null;
+        loadUserConfigSync(true, cwd, gitRoot);
+        await loadPromptsConfig(true, cwd, gitRoot);
+        onReload();
+      });
+      watcher.unref();
+      watchers.push(watcher);
+    } catch (e) {
+    }
+  }
+}
+
+// src/server/index.ts
+var serverLogger = createLogger("inspecto:server", { logLevel: getGlobalLogLevel() });
+var payloadTickets = /* @__PURE__ */ new Map();
+function createTicket(payload) {
+  const ticketId = crypto.randomUUID();
+  payloadTickets.set(ticketId, JSON.stringify(payload));
+  setTimeout(
+    () => {
+      payloadTickets.delete(ticketId);
+    },
+    5 * 60 * 1e3
+  );
+  return ticketId;
+}
+var serverState = {
+  port: null,
+  running: false,
+  projectRoot: "",
+  configRoot: "",
+  cwd: process.cwd()
+};
+var serverInstance = null;
+function resolveProjectRoot() {
+  let gitRoot;
+  try {
+    serverLogger.info("Resolving project root...");
+    gitRoot = execSync("git rev-parse --show-toplevel", { encoding: "utf-8" }).trim();
+    serverLogger.info("Resolved project root: " + gitRoot);
+  } catch (e) {
+    serverLogger.error("Failed to resolve project root:", e);
+    gitRoot = process.cwd();
+  }
+  let current = gitRoot;
+  while (true) {
+    if (fs3.existsSync(path4.join(current, ".inspecto"))) return current;
+    const parent = path4.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return gitRoot;
+}
+function launchURI(uri) {
+  try {
+    if (process.platform === "darwin") {
+      execFileSync("open", [uri]);
+    } else if (process.platform === "win32") {
+      execFileSync("cmd", ["/c", "start", '""', uri]);
+    } else {
+      execFileSync("xdg-open", [uri]);
+    }
+  } catch (e) {
+    serverLogger.error("Failed to launch URI via execFileSync, falling back to launchIDE:", e);
+    launchIDE({ file: uri });
+  }
+}
+async function startServer() {
+  if (serverState.running && serverState.port !== null) {
+    return serverState.port;
+  }
+  serverState.projectRoot = resolveProjectRoot();
+  serverState.configRoot = serverState.projectRoot;
+  serverState.cwd = process.cwd();
+  portfinder.basePort = 5678;
+  const port = await portfinder.getPortPromise();
+  watchConfig(
+    () => {
+      serverLogger.info("user config reloaded.");
+    },
+    serverState.cwd,
+    serverState.configRoot
+  );
+  serverInstance = http.createServer((req, res) => {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    const url = new URL(req.url ?? "/", `http://localhost:${port}`);
+    handleRequest(url, req, res).catch((err) => {
+      serverLogger.error("server error:", err);
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: false, error: String(err) }));
+    });
+  });
+  await new Promise((resolve2, reject) => {
+    serverInstance.listen(port, "127.0.0.1", () => {
+      serverInstance.unref();
+      resolve2();
+    });
+    serverInstance.once("error", reject);
+  });
+  serverInstance.on("error", (err) => {
+    serverLogger.error("persistent server error:", err);
+  });
+  serverState.port = port;
+  serverState.running = true;
+  const portFile = path4.join(os2.tmpdir(), "inspecto.port.json");
+  try {
+    let portData = {};
+    if (fs3.existsSync(portFile)) {
+      try {
+        portData = JSON.parse(fs3.readFileSync(portFile, "utf-8"));
+      } catch (e) {
+      }
+    }
+    const rootHash = crypto.createHash("md5").update(serverState.projectRoot).digest("hex");
+    portData[rootHash] = port;
+    fs3.writeFileSync(portFile, JSON.stringify(portData, null, 2), "utf-8");
+  } catch (e) {
+    serverLogger.warn("Failed to write port file:", e);
+  }
+  process.once("exit", () => {
+    try {
+      if (fs3.existsSync(portFile)) {
+        const portData = JSON.parse(fs3.readFileSync(portFile, "utf-8"));
+        const rootHash = crypto.createHash("md5").update(serverState.projectRoot).digest("hex");
+        delete portData[rootHash];
+        if (Object.keys(portData).length === 0) {
+          fs3.unlinkSync(portFile);
+        } else {
+          fs3.writeFileSync(portFile, JSON.stringify(portData, null, 2), "utf-8");
+        }
+      }
+    } catch {
+    }
+  });
+  serverLogger.info(`server running at http://127.0.0.1:${port}`);
+  return port;
+}
+async function readBody(req) {
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve2(Buffer.concat(chunks).toString("utf-8")));
+    req.on("error", reject);
+  });
+}
+async function handleRequest(url, req, res) {
+  const pathname = url.pathname;
+  if ((pathname === "/health" || pathname === INSPECTO_API_PATHS.HEALTH) && req.method === "GET") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ ok: true, port: serverState.port }));
+    return;
+  }
+  if (pathname === INSPECTO_API_PATHS.CLIENT_CONFIG && req.method === "GET") {
+    const userConfig = loadUserConfigSync(false, serverState.cwd, serverState.configRoot);
+    const promptsConfig = await loadPromptsConfig(false, serverState.cwd, serverState.configRoot);
+    const effectiveIde = userConfig.ide ?? "vscode";
+    let info;
+    if (!serverState.ideInfo) {
+      info = {
+        ide: effectiveIde
+      };
+    } else {
+      const { scheme: _scheme, ...rest } = serverState.ideInfo;
+      info = rest;
+    }
+    const config = {
+      ...info,
+      prompts: resolveIntents(promptsConfig),
+      hotKeys: userConfig["inspector.hotKey"] ?? "alt",
+      theme: userConfig["inspector.theme"] ?? "auto",
+      includeSnippet: userConfig["prompt.includeSnippet"] ?? false,
+      autoSend: userConfig["prompt.autoSend"] ?? false
+    };
+    delete config.providers;
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(config));
+    return;
+  }
+  if (pathname === INSPECTO_API_PATHS.IDE_INFO && req.method === "POST") {
+    try {
+      const body = JSON.parse(await readBody(req));
+      const ideWorkspace = body.workspaceRoot || "";
+      const serverProjectRoot = serverState.projectRoot || "";
+      const isSameProject = !ideWorkspace || !serverProjectRoot || ideWorkspace === serverProjectRoot || serverProjectRoot.startsWith(ideWorkspace);
+      if (isSameProject) {
+        serverState.ideInfo = body;
+        serverLogger.debug(
+          `Accepted IDE info from matched workspace (ide-${body.ide} / schema-${body.scheme})`
+        );
+      } else {
+        serverLogger.debug(
+          `Ignored IDE info from unrelated workspace (IDE Workspace: ${ideWorkspace}, Server: ${serverProjectRoot}, Scheme: ${body.scheme}, IDE: ${body.ide})`
+        );
+      }
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: true }));
+    } catch (e) {
+      serverLogger.error(`Error parsing ${INSPECTO_API_PATHS.IDE_INFO} POST request:`, e);
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Invalid JSON body" }));
+    }
+    return;
+  }
+  if (pathname === INSPECTO_API_PATHS.IDE_OPEN && req.method === "POST") {
+    let body;
+    try {
+      body = JSON.parse(await readBody(req));
+    } catch (e) {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Invalid JSON body" }));
+      return;
+    }
+    const absolutePath = path4.isAbsolute(body.file) ? path4.resolve(body.file) : path4.resolve(serverState.cwd, body.file);
+    const relativeToRoot = path4.relative(serverState.projectRoot, absolutePath);
+    if (relativeToRoot.startsWith("..") || path4.isAbsolute(relativeToRoot)) {
+      serverLogger.warn(`Security: Blocked path traversal attempt in IDE_OPEN: ${body.file}`);
+      res.writeHead(403, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Access denied: File is outside of project workspace" }));
+      return;
+    }
+    const userConfig = loadUserConfigSync(false, serverState.cwd, serverState.configRoot);
+    const configuredIde = userConfig.ide;
+    const activeIde = serverState.ideInfo?.ide;
+    const activeIdeScheme = serverState.ideInfo?.scheme;
+    const rawEditorHint = configuredIde || activeIde || activeIdeScheme || "code";
+    if (configuredIde && activeIdeScheme && !activeIdeScheme.includes(configuredIde)) {
+      serverLogger.warn(
+        `Active IDE is ${activeIdeScheme}, but config forces ${configuredIde}. Using configured IDE.`
+      );
+    }
+    let editorHint = rawEditorHint;
+    if (rawEditorHint === "vscode") editorHint = "code";
+    else if (rawEditorHint === "vscode-insiders") editorHint = "code-insiders";
+    else if (rawEditorHint === "vscodium") editorHint = "codium";
+    else if (rawEditorHint === "trae-cn" || rawEditorHint === "trae") editorHint = "trae";
+    serverLogger.debug(
+      `IDE_OPEN: activeIde=${activeIde}, activeIdeScheme=${activeIdeScheme}, configuredIde=${configuredIde} -> rawEditorHint=${rawEditorHint}, finalEditorHint=${editorHint}`
+    );
+    const VSCODE_FAMILY_SCHEMES = [
+      "vscode",
+      "vscode-insiders",
+      "cursor",
+      "windsurf",
+      "trae",
+      "trae-cn",
+      "vscodium",
+      "codebuddy",
+      "codebuddy-cn",
+      "antigravity"
+    ];
+    if (VSCODE_FAMILY_SCHEMES.includes(rawEditorHint)) {
+      const uri = `${rawEditorHint}://file${absolutePath}:${body.line}:${body.column}`;
+      serverLogger.debug(`IDE_OPEN: Bypassing launchIDE, using URI scheme directly: ${uri}`);
+      try {
+        if (process.platform === "darwin") {
+          execFileSync("open", [uri]);
+        } else if (process.platform === "win32") {
+          execFileSync("cmd", ["/c", "start", '""', uri]);
+        } else {
+          execFileSync("xdg-open", [uri]);
+        }
+      } catch (e) {
+        serverLogger.error(`Failed to launch URI for IDE_OPEN (${uri}):`, e);
+        launchIDE({
+          file: absolutePath,
+          line: body.line,
+          column: body.column,
+          editor: editorHint,
+          type: process.platform === "darwin" ? "open" : "exec"
+        });
+      }
+    } else {
+      launchIDE({
+        file: absolutePath,
+        line: body.line,
+        column: body.column,
+        editor: editorHint,
+        type: process.platform === "darwin" ? "open" : "exec"
+      });
+    }
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ success: true }));
+    return;
+  }
+  if (pathname === INSPECTO_API_PATHS.PROJECT_SNIPPET && req.method === "GET") {
+    const file = url.searchParams.get("file") ?? "";
+    const line = parseInt(url.searchParams.get("line") ?? "1", 10);
+    const column = parseInt(url.searchParams.get("column") ?? "1", 10);
+    const maxLines = parseInt(url.searchParams.get("maxLines") ?? "100", 10);
+    try {
+      const absolutePath = path4.isAbsolute(file) ? path4.resolve(file) : path4.resolve(serverState.cwd, file);
+      const relativeToRoot = path4.relative(serverState.projectRoot, absolutePath);
+      if (relativeToRoot.startsWith("..") || path4.isAbsolute(relativeToRoot)) {
+        serverLogger.warn(`Security: Blocked path traversal attempt in PROJECT_SNIPPET: ${file}`);
+        res.writeHead(403, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            success: false,
+            error: "Access denied: File is outside of project workspace",
+            errorCode: "FORBIDDEN"
+          })
+        );
+        return;
+      }
+      const result = await extractSnippet({ file: absolutePath, line, column, maxLines });
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(result));
+    } catch (err) {
+      const message = String(err.message || err);
+      const errorCode = message.startsWith("FILE_NOT_FOUND") ? "FILE_NOT_FOUND" : "UNKNOWN";
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: false, error: message, errorCode }));
+    }
+    return;
+  }
+  if (pathname === INSPECTO_API_PATHS.AI_DISPATCH && req.method === "POST") {
+    try {
+      const rawBody = await readBody(req);
+      const body = JSON.parse(rawBody);
+      const result = await dispatchToAi(body);
+      res.writeHead(result.success ? 200 : 500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(result));
+    } catch (e) {
+      serverLogger.error(`Error parsing ${INSPECTO_API_PATHS.AI_DISPATCH} request:`, e);
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: false, error: String(e), errorCode: "INTERNAL_ERROR" }));
+    }
+    return;
+  }
+  if (pathname.startsWith(`${INSPECTO_API_PATHS.AI_TICKET}/`) && req.method === "GET") {
+    const ticketId = pathname.substring(INSPECTO_API_PATHS.AI_TICKET.length + 1);
+    const payloadStr = payloadTickets.get(ticketId);
+    if (!payloadStr) {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: false, error: "Ticket not found or expired" }));
+      return;
+    }
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(payloadStr);
+    return;
+  }
+  res.writeHead(404, { "Content-Type": "application/json" });
+  res.end(JSON.stringify({ error: "not found" }));
+}
+async function dispatchToAi(req) {
+  const { location, snippet, prompt } = req;
+  const userConfig = loadUserConfigSync(false, serverState.cwd, serverState.configRoot);
+  const resolvedTarget = resolveTargetTool(userConfig);
+  const formattedPrompt = prompt ?? `Please help me with this code from \`${location.file}\` (line ${location.line}):
+
+\`\`\`
+${snippet}
+\`\`\`
+`;
+  const ideReportedMode = serverState.ideInfo?.providers[resolvedTarget]?.mode;
+  const configuredIde = userConfig.ide;
+  const activeIde = serverState.ideInfo?.ide;
+  const activeIdeScheme = serverState.ideInfo?.scheme;
+  const finalIde = configuredIde || activeIdeScheme || activeIde || "vscode";
+  if (configuredIde && activeIdeScheme && !activeIdeScheme.includes(configuredIde)) {
+    serverLogger.warn(
+      `dispatchToAi: Active IDE is ${activeIdeScheme}, but config forces ${configuredIde}. Using configured IDE.`
+    );
+  }
+  const mode = resolveProviderMode(resolvedTarget, finalIde, userConfig);
+  const overrides = extractToolOverrides(finalIde, userConfig)[resolvedTarget] || {};
+  overrides.type = mode;
+  const fullPayload = {
+    ide: finalIde,
+    target: resolvedTarget,
+    targetType: mode,
+    prompt: formattedPrompt,
+    filePath: location.file,
+    line: location.line,
+    column: location.column,
+    snippet,
+    overrides: Object.keys(overrides).length > 0 ? overrides : void 0,
+    autoSend: userConfig["prompt.autoSend"] !== void 0 ? Boolean(userConfig["prompt.autoSend"]) : void 0
+  };
+  const ticketId = createTicket(fullPayload);
+  const params = new URLSearchParams();
+  params.set("ticket", ticketId);
+  params.set("target", resolvedTarget);
+  const uri = `${finalIde}://inspecto.inspecto/send?${params.toString()}`;
+  serverLogger.debug(`dispatchToAi: Generated URI: ${uri}`);
+  launchURI(uri);
+  return {
+    success: true,
+    fallbackPayload: {
+      prompt: formattedPrompt,
+      file: location.file
+    }
+  };
+}
+
+// src/legacy/webpack4/index.ts
+import path5 from "path";
+var InspectoWebpack4Plugin = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  apply(compiler) {
+    const clientPath = resolveClientModule();
+    compiler.hooks.afterEnvironment.tap("InspectoWebpack4Plugin", () => {
+      const inspectoLoader = path5.resolve(__dirname, "loader.cjs");
+      compiler.options.module.rules.push({
+        test: /\.[jt]sx?$/,
+        enforce: "pre",
+        exclude: /node_modules/,
+        use: [
+          {
+            loader: inspectoLoader,
+            options: {
+              ...this.options,
+              clientPath
+            }
+          }
+        ]
+      });
+    });
+    compiler.hooks.compilation.tap("InspectoWebpack4Plugin", (compilation) => {
+      const htmlPlugin = compiler.options.plugins.find(
+        (p) => p && p.constructor && p.constructor.name === "HtmlWebpackPlugin"
+      );
+      const HtmlWebpackPlugin = htmlPlugin ? htmlPlugin.constructor : null;
+      if (HtmlWebpackPlugin && HtmlWebpackPlugin.getHooks) {
+        HtmlWebpackPlugin.getHooks(compilation).alterAssetTagGroups.tapAsync(
+          "InspectoWebpack4Plugin",
+          async (data, cb) => {
+            const port = await startServer();
+            data.headTags.unshift({
+              tagName: "script",
+              voidTag: false,
+              attributes: { "data-plugin": "inspecto-overlay" },
+              innerHTML: getWebpackHtmlScript(port)
+            });
+            cb(null, data);
+          }
+        );
+      } else if (compilation.hooks.htmlWebpackPluginAlterAssetTags) {
+        compilation.hooks.htmlWebpackPluginAlterAssetTags.tapAsync(
+          "InspectoWebpack4Plugin",
+          async (data, cb) => {
+            const port = await startServer();
+            data.head.unshift({
+              tagName: "script",
+              voidTag: false,
+              attributes: { "data-plugin": "inspecto-overlay" },
+              innerHTML: getWebpackHtmlScript(port)
+            });
+            cb(null, data);
+          }
+        );
+      }
+    });
+  }
+};
+var webpack4Plugin = (options) => new InspectoWebpack4Plugin(options);
+export {
+  InspectoWebpack4Plugin,
+  webpack4Plugin
+};
+//# sourceMappingURL=index.js.map