@inspecto-dev/plugin 0.2.0-alpha.4 → 0.3.0

package/dist/legacy/webpack4/index.cjs

@@ -72,13 +72,11 @@ var resolveClientModule = () => {
 
 // src/server/index.ts
 var import_node_http = __toESM(require("http"), 1);
-var import_node_fs2 = __toESM(require("fs"), 1);
-var import_node_path2 = __toESM(require("path"), 1);
+var import_node_fs3 = __toESM(require("fs"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
 var import_node_os2 = __toESM(require("os"), 1);
-var import_node_crypto = __toESM(require("crypto"), 1);
-var import_node_child_process = require("child_process");
+var import_node_crypto2 = __toESM(require("crypto"), 1);
 var import_portfinder = __toESM(require("portfinder"), 1);
-var import_launch_ide = require("launch-ide");
 var import_types2 = require("@inspecto-dev/types");
 
 // src/server/snippet.ts
@@ -398,9 +396,9 @@ function extractToolOverrides(ide, config) {
 function resolveIntents(serverPrompts) {
   const baseMap = /* @__PURE__ */ new Map();
   for (const intent of import_types.DEFAULT_INTENTS) {
-    if (intent.id) baseMap.set(intent.id, { ...intent });
+    baseMap.set(intent.id, { ...intent });
   }
-  const defaults = () => ensureOpenInEditorLast(Array.from(baseMap.values()));
+  const defaults = () => 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 : [];
@@ -427,16 +425,18 @@ function resolveIntents(serverPrompts) {
           );
           continue;
         }
-        if (item.isAction && item.id !== "open-in-editor") {
+        if (!item.aiIntent) {
           configLogger.warn(
-            `isAction is reserved for built-in actions. Ignoring intent "${item.id}".`
+            `Intent "${item.id}" is missing required "aiIntent".`
           );
           continue;
         }
-        result.push(baseMap.has(item.id) ? { ...baseMap.get(item.id), ...item } : item);
+        result.push(
+          baseMap.has(item.id) ? { ...baseMap.get(item.id), ...item } : item
+        );
       }
     }
-    return ensureOpenInEditorLast(result);
+    return result;
   }
   const merged = Array.from(baseMap.values());
   for (const item of promptsArray) {
@@ -453,9 +453,9 @@ function resolveIntents(serverPrompts) {
         configLogger.warn('Intent object missing required "id" field, skipping.');
         continue;
       }
-      if (item.isAction && item.id !== "open-in-editor") {
+      if (!item.aiIntent) {
         configLogger.warn(
-          `isAction is reserved for built-in actions. Ignoring intent "${item.id}".`
+          `Intent "${item.id}" is missing required "aiIntent".`
         );
         continue;
       }
@@ -473,15 +473,7 @@ function resolveIntents(serverPrompts) {
       }
     }
   }
-  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;
+  return merged;
 }
 var watchers = [];
 function watchConfig(onReload, cwd = process.cwd(), gitRoot) {
@@ -516,7 +508,10 @@ function watchConfig(onReload, cwd = process.cwd(), gitRoot) {
   }
 }
 
-// src/server/index.ts
+// src/server/dispatch-transport.ts
+var import_node_crypto = __toESM(require("crypto"), 1);
+var import_node_child_process = require("child_process");
+var import_launch_ide = require("launch-ide");
 var serverLogger = createLogger("inspecto:server", { logLevel: getGlobalLogLevel() });
 var payloadTickets = /* @__PURE__ */ new Map();
 function createTicket(payload) {
@@ -530,21 +525,363 @@ function createTicket(payload) {
   );
   return ticketId;
 }
-var serverState = {
-  port: null,
-  running: false,
-  projectRoot: "",
-  configRoot: "",
-  cwd: process.cwd()
+function readTicket(ticketId) {
+  return payloadTickets.get(ticketId);
+}
+function launchURI(uri) {
+  try {
+    if (process.platform === "darwin") {
+      (0, import_node_child_process.execFileSync)("open", [uri]);
+    } else if (process.platform === "win32") {
+      (0, import_node_child_process.execFileSync)("cmd", ["/c", "start", '""', uri]);
+    } else {
+      (0, import_node_child_process.execFileSync)("xdg-open", [uri]);
+    }
+  } catch (e) {
+    serverLogger.error("Failed to launch URI via execFileSync, falling back to launchIDE:", e);
+    (0, import_launch_ide.launchIDE)({ file: uri });
+  }
+}
+
+// src/server/dispatch-runtime.ts
+function resolvePromptDispatchRuntime(state) {
+  const userConfig = loadUserConfigSync(false, state.cwd, state.projectRoot);
+  const resolvedTarget = resolveTargetTool(userConfig);
+  const finalIde = resolveFinalIde(userConfig.ide, state.ideInfo?.ide, state.ideInfo?.scheme);
+  const mode = resolveProviderMode(resolvedTarget, finalIde, userConfig);
+  const overrides = extractToolOverrides(finalIde, userConfig)[resolvedTarget] || void 0;
+  return {
+    resolvedTarget,
+    finalIde,
+    mode,
+    ...hasOverrides(overrides) ? { overrides } : {},
+    ...userConfig["prompt.autoSend"] !== void 0 ? { autoSend: Boolean(userConfig["prompt.autoSend"]) } : {}
+  };
+}
+function dispatchPromptThroughIde(runtime, payload) {
+  const ticketId = createTicket({
+    ide: runtime.finalIde,
+    target: runtime.resolvedTarget,
+    targetType: runtime.mode,
+    prompt: payload.prompt,
+    filePath: payload.filePath,
+    line: payload.line,
+    column: payload.column,
+    snippet: payload.snippet,
+    ...payload.screenshotContext ? { screenshotContext: payload.screenshotContext } : {},
+    overrides: runtime.overrides,
+    autoSend: runtime.autoSend
+  });
+  const params = new URLSearchParams();
+  params.set("ticket", ticketId);
+  params.set("target", runtime.resolvedTarget);
+  launchURI(`${runtime.finalIde}://inspecto.inspecto/send?${params.toString()}`);
+  return {
+    success: true,
+    fallbackPayload: {
+      prompt: payload.prompt,
+      ...payload.filePath ? { file: payload.filePath } : {}
+    }
+  };
+}
+function resolveFinalIde(configuredIde, activeIde, activeIdeScheme) {
+  if (configuredIde && activeIdeScheme && !activeIdeScheme.includes(configuredIde)) {
+    return configuredIde;
+  }
+  return configuredIde || activeIdeScheme || activeIde || "vscode";
+}
+function hasOverrides(overrides) {
+  return Boolean(overrides && Object.keys(overrides).length > 0);
+}
+
+// src/server/path-guards.ts
+var import_node_path2 = __toESM(require("path"), 1);
+function isWindowsAbsolutePath(file) {
+  return /^[a-zA-Z]:[\\/]/.test(file) || /^\\\\[^\\]+\\[^\\]+/.test(file);
+}
+function resolveWorkspacePath(file, cwd) {
+  if (isWindowsAbsolutePath(file)) {
+    return import_node_path2.default.win32.normalize(file);
+  }
+  return import_node_path2.default.isAbsolute(file) ? import_node_path2.default.resolve(file) : import_node_path2.default.resolve(cwd, file);
+}
+function assertPathWithinProject(file, projectRoot) {
+  const relativeToRoot = isWindowsAbsolutePath(file) || isWindowsAbsolutePath(projectRoot) ? import_node_path2.default.win32.relative(import_node_path2.default.win32.normalize(projectRoot), import_node_path2.default.win32.normalize(file)) : import_node_path2.default.relative(projectRoot, file);
+  if (relativeToRoot.startsWith("..") || import_node_path2.default.isAbsolute(relativeToRoot)) {
+    throw new Error("Access denied: File is outside of project workspace");
+  }
+}
+
+// src/server/annotation-dispatch.ts
+var AnnotationDispatchError = class extends Error {
+  constructor(message, errorCode) {
+    super(message);
+    this.name = "AnnotationDispatchError";
+    this.errorCode = errorCode;
+  }
 };
-var serverInstance = null;
+async function dispatchAnnotationsToAi(req, state) {
+  try {
+    validateAnnotationDispatchRequest(req, state);
+    const batch = normalizeAnnotationBatch(req);
+    const prompt = buildAnnotationBatchPrompt(batch);
+    const representativeTarget = batch.annotations[0]?.targets[0];
+    const runtime = resolvePromptDispatchRuntime(state);
+    return dispatchPromptThroughIde(runtime, {
+      prompt,
+      ...representativeTarget?.file ? { filePath: representativeTarget.file } : {},
+      ...representativeTarget?.line ? { line: representativeTarget.line } : {},
+      ...representativeTarget?.column ? { column: representativeTarget.column } : {},
+      ...batch.screenshotContext ? { screenshotContext: batch.screenshotContext } : {}
+    });
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+      errorCode: getAnnotationDispatchErrorCode(error)
+    };
+  }
+}
+function validateAnnotationDispatchRequest(req, state) {
+  if (!req.annotations.length) {
+    throw new AnnotationDispatchError("At least one annotation is required.", "INVALID_REQUEST");
+  }
+  for (const annotation of req.annotations) {
+    if (!annotation.targets.length) {
+      throw new AnnotationDispatchError(
+        "Each annotation must include at least one target.",
+        "INVALID_REQUEST"
+      );
+    }
+    for (const target of annotation.targets) {
+      const absolutePath = resolveWorkspacePath(target.location.file, state.cwd);
+      assertPathWithinProject(absolutePath, state.projectRoot);
+    }
+  }
+}
+function normalizeAnnotationBatch(req) {
+  return {
+    instruction: req.instruction?.trim() ?? "",
+    responseMode: req.responseMode ?? "unified",
+    ...req.runtimeContext ? { runtimeContext: req.runtimeContext } : {},
+    ...req.screenshotContext ? { screenshotContext: req.screenshotContext } : {},
+    ...req.cssContextPrompt?.trim() ? { cssContextPrompt: req.cssContextPrompt.trim() } : {},
+    annotations: req.annotations.map((annotation, index) => ({
+      index: index + 1,
+      note: annotation.note.trim(),
+      intent: annotation.intent,
+      targets: annotation.targets.map((target) => ({
+        file: target.location.file,
+        line: target.location.line,
+        column: target.location.column,
+        ...target.label ? { label: target.label } : {},
+        ...target.selector ? { selector: target.selector } : {},
+        ...target.snippet ? { snippet: target.snippet } : {}
+      }))
+    }))
+  };
+}
+function buildAnnotationBatchPrompt(batch) {
+  const body = buildSelectedElementsPrompt(batch.annotations);
+  const prompt = batch.instruction ? `${batch.instruction}
+
+${body}` : body;
+  return appendScreenshotContextSection(
+    appendCssContextSection(
+      appendRuntimeContextSection(prompt, batch.runtimeContext),
+      batch.cssContextPrompt
+    ),
+    batch.screenshotContext
+  );
+}
+function appendCssContextSection(prompt, cssContextPrompt) {
+  if (!cssContextPrompt) return prompt;
+  return `${prompt}
+
+${cssContextPrompt}`;
+}
+function buildSelectedElementsPrompt(annotations) {
+  const lines = ["Selected elements:"];
+  for (const annotation of annotations) {
+    const trimmedNote = annotation.note.trim();
+    for (const target of annotation.targets) {
+      const targetLabel = (target.label || "Unknown target").trim() || "Unknown target";
+      lines.push(`- ${targetLabel}`);
+      lines.push(`file=${target.file}:${target.line}:${target.column}`);
+      if (trimmedNote) {
+        lines.push(`note=${trimmedNote}`);
+      }
+    }
+  }
+  if (lines.length === 1) {
+    lines.push("- None");
+  }
+  return lines.join("\n");
+}
+function appendScreenshotContextSection(prompt, screenshotContext) {
+  if (!screenshotContext || !screenshotContext.imageDataUrl && !screenshotContext.imageAssetId) {
+    return prompt;
+  }
+  const lines = [
+    "Visual screenshot context attached:",
+    `- capturedAt=${screenshotContext.capturedAt}`,
+    `- mimeType=${screenshotContext.mimeType}`,
+    ...screenshotContext.imageAssetId ? [`- imageAssetId=${screenshotContext.imageAssetId}`] : []
+  ];
+  return `${prompt}
+
+${lines.join("\n")}`;
+}
+function appendRuntimeContextSection(prompt, runtimeContext) {
+  if (!runtimeContext?.records.length) {
+    return prompt;
+  }
+  return `${prompt}
+
+${buildRuntimeContextSection(runtimeContext.records)}`;
+}
+function buildRuntimeContextSection(records) {
+  return ["Relevant runtime context:", ...records.map(formatRuntimeRecord)].join("\n");
+}
+function formatRuntimeRecord(record) {
+  const requestSummary = record.kind === "failed-request" ? `request=${record.request?.method ?? "GET"} ${record.request?.pathname ?? record.request?.url ?? "unknown"} status=${record.request?.status ?? "unknown"}` : `occurrences=${record.occurrenceCount}`;
+  const reasonSummary = record.relevanceReasons.length ? record.relevanceReasons.join("; ") : "timing-based";
+  const stackSummary = record.stack ? `
+  stack=${record.stack.split("\n").slice(0, 5).join(" | ")}` : "";
+  return [
+    `- [${record.kind}] ${record.message}`,
+    `  relevance=${record.relevanceLevel} (${reasonSummary})`,
+    `  ${requestSummary}`,
+    stackSummary
+  ].filter(Boolean).join("\n");
+}
+function getAnnotationDispatchErrorCode(error) {
+  if (error instanceof AnnotationDispatchError) return error.errorCode;
+  if (error instanceof Error && error.message.includes("outside of project workspace")) {
+    return "FORBIDDEN_PATH";
+  }
+  return "UNKNOWN";
+}
+
+// src/server/client-config.ts
+async function buildClientConfig(serverState2) {
+  const userConfig = loadUserConfigSync(false, serverState2.cwd, serverState2.configRoot);
+  const promptsConfig = await loadPromptsConfig(false, serverState2.cwd, serverState2.configRoot);
+  const effectiveIde = userConfig.ide ?? "vscode";
+  let info;
+  if (!serverState2.ideInfo) {
+    info = { ide: effectiveIde };
+  } else {
+    const { scheme: _scheme, ...rest } = serverState2.ideInfo;
+    info = rest;
+  }
+  return {
+    ...info,
+    prompts: resolveIntents(promptsConfig),
+    hotKeys: userConfig["inspector.hotKey"] ?? "alt",
+    theme: userConfig["inspector.theme"] ?? "auto",
+    includeSnippet: userConfig["prompt.includeSnippet"] ?? false,
+    runtimeContext: {
+      enabled: true,
+      preview: true,
+      maxRuntimeErrors: 3,
+      maxFailedRequests: 2
+    },
+    screenshotContext: {
+      enabled: false
+    },
+    annotationResponseMode: userConfig["prompt.annotationResponseMode"] ?? "unified",
+    autoSend: userConfig["prompt.autoSend"] ?? false
+  };
+}
+
+// src/server/open-file.ts
+var import_node_child_process2 = require("child_process");
+var import_launch_ide2 = require("launch-ide");
+var serverLogger2 = createLogger("inspecto:server", { logLevel: getGlobalLogLevel() });
+var VSCODE_FAMILY_SCHEMES = [
+  "vscode",
+  "vscode-insiders",
+  "cursor",
+  "windsurf",
+  "trae",
+  "trae-cn",
+  "vscodium",
+  "codebuddy",
+  "codebuddy-cn",
+  "antigravity"
+];
+function handleOpenFileRequest(body, serverState2) {
+  const absolutePath = resolveWorkspacePath(body.file, serverState2.cwd);
+  assertPathWithinProject(absolutePath, serverState2.projectRoot);
+  const userConfig = loadUserConfigSync(false, serverState2.cwd, serverState2.configRoot);
+  const configuredIde = userConfig.ide;
+  const activeIde = serverState2.ideInfo?.ide;
+  const activeIdeScheme = serverState2.ideInfo?.scheme;
+  const rawEditorHint = configuredIde || activeIde || activeIdeScheme || "code";
+  if (configuredIde && activeIdeScheme && !activeIdeScheme.includes(configuredIde)) {
+    serverLogger2.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";
+  serverLogger2.debug(
+    `IDE_OPEN: activeIde=${activeIde}, activeIdeScheme=${activeIdeScheme}, configuredIde=${configuredIde} -> rawEditorHint=${rawEditorHint}, finalEditorHint=${editorHint}`
+  );
+  if (VSCODE_FAMILY_SCHEMES.includes(rawEditorHint)) {
+    let normalizedPath = absolutePath.replace(/\\/g, "/");
+    if (!normalizedPath.startsWith("/")) {
+      normalizedPath = "/" + normalizedPath;
+    }
+    const encodedPath = encodeURI(normalizedPath);
+    const uri = `${rawEditorHint}://file${encodedPath}:${body.line}:${body.column}`;
+    serverLogger2.debug(`IDE_OPEN: Bypassing launchIDE, using URI scheme directly: ${uri}`);
+    try {
+      if (process.platform === "darwin") {
+        (0, import_node_child_process2.execFileSync)("open", [uri]);
+      } else if (process.platform === "win32") {
+        (0, import_node_child_process2.execFileSync)("cmd", ["/c", "start", '""', uri]);
+      } else {
+        (0, import_node_child_process2.execFileSync)("xdg-open", [uri]);
+      }
+    } catch (e) {
+      serverLogger2.error(`Failed to launch URI for IDE_OPEN (${uri}):`, e);
+      (0, import_launch_ide2.launchIDE)({
+        file: absolutePath,
+        line: body.line,
+        column: body.column,
+        editor: editorHint,
+        type: process.platform === "darwin" ? "open" : "exec"
+      });
+    }
+  } else {
+    (0, import_launch_ide2.launchIDE)({
+      file: absolutePath,
+      line: body.line,
+      column: body.column,
+      editor: editorHint,
+      type: process.platform === "darwin" ? "open" : "exec"
+    });
+  }
+  return { success: true };
+}
+
+// src/server/project-root.ts
+var import_node_fs2 = __toESM(require("fs"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+var import_node_child_process3 = require("child_process");
+var serverLogger3 = createLogger("inspecto:server", { logLevel: getGlobalLogLevel() });
 function resolveProjectRoot() {
   const cwd = process.cwd();
   let gitRoot;
   try {
-    gitRoot = (0, import_node_child_process.execSync)("git rev-parse --show-toplevel", { encoding: "utf-8" }).trim();
+    gitRoot = (0, import_node_child_process3.execSync)("git rev-parse --show-toplevel", { encoding: "utf-8" }).trim();
   } catch (e) {
-    serverLogger.warn("Failed to resolve git root via git rev-parse:", e);
+    serverLogger3.warn("Failed to resolve git root via git rev-parse:", e);
     gitRoot = cwd;
   }
   const visited = /* @__PURE__ */ new Set();
@@ -552,34 +889,31 @@ function resolveProjectRoot() {
     let current = start;
     while (!visited.has(current)) {
       visited.add(current);
-      if (import_node_fs2.default.existsSync(import_node_path2.default.join(current, ".inspecto"))) return current;
+      if (import_node_fs2.default.existsSync(import_node_path3.default.join(current, ".inspecto"))) return current;
       if (current === stop) break;
-      const parent = import_node_path2.default.dirname(current);
+      const parent = import_node_path3.default.dirname(current);
       if (parent === current) break;
       current = parent;
     }
     return null;
   };
-  const cwdMatch = search(cwd, import_node_path2.default.parse(cwd).root);
+  const cwdMatch = search(cwd, import_node_path3.default.parse(cwd).root);
   if (cwdMatch) return cwdMatch;
-  const repoMatch = search(gitRoot, import_node_path2.default.parse(gitRoot).root);
+  const repoMatch = search(gitRoot, import_node_path3.default.parse(gitRoot).root);
   if (repoMatch) return repoMatch;
   return gitRoot;
 }
-function launchURI(uri) {
-  try {
-    if (process.platform === "darwin") {
-      (0, import_node_child_process.execFileSync)("open", [uri]);
-    } else if (process.platform === "win32") {
-      (0, import_node_child_process.execFileSync)("cmd", ["/c", "start", '""', uri]);
-    } else {
-      (0, import_node_child_process.execFileSync)("xdg-open", [uri]);
-    }
-  } catch (e) {
-    serverLogger.error("Failed to launch URI via execFileSync, falling back to launchIDE:", e);
-    (0, import_launch_ide.launchIDE)({ file: uri });
-  }
-}
+
+// src/server/index.ts
+var serverLogger4 = createLogger("inspecto:server", { logLevel: getGlobalLogLevel() });
+var serverState = {
+  port: null,
+  running: false,
+  projectRoot: "",
+  configRoot: "",
+  cwd: process.cwd()
+};
+var serverInstance = null;
 async function startServer() {
   if (serverState.running && serverState.port !== null) {
     return serverState.port;
@@ -591,7 +925,7 @@ async function startServer() {
   const port = await import_portfinder.default.getPortPromise();
   watchConfig(
     () => {
-      serverLogger.info("user config reloaded.");
+      serverLogger4.info("user config reloaded.");
     },
     serverState.cwd,
     serverState.configRoot
@@ -607,7 +941,7 @@ async function startServer() {
     }
     const url = new URL(req.url ?? "/", `http://localhost:${port}`);
     handleRequest(url, req, res).catch((err) => {
-      serverLogger.error("server error:", err);
+      serverLogger4.error("server error:", err);
       res.writeHead(500, { "Content-Type": "application/json" });
       res.end(JSON.stringify({ success: false, error: String(err) }));
     });
@@ -620,41 +954,41 @@ async function startServer() {
     serverInstance.once("error", reject);
   });
   serverInstance.on("error", (err) => {
-    serverLogger.error("persistent server error:", err);
+    serverLogger4.error("persistent server error:", err);
   });
   serverState.port = port;
   serverState.running = true;
-  const portFile = import_node_path2.default.join(import_node_os2.default.tmpdir(), "inspecto.port.json");
+  const portFile = import_node_path4.default.join(import_node_os2.default.tmpdir(), "inspecto.port.json");
   try {
     let portData = {};
-    if (import_node_fs2.default.existsSync(portFile)) {
+    if (import_node_fs3.default.existsSync(portFile)) {
       try {
-        portData = JSON.parse(import_node_fs2.default.readFileSync(portFile, "utf-8"));
+        portData = JSON.parse(import_node_fs3.default.readFileSync(portFile, "utf-8"));
       } catch (e) {
       }
     }
-    const rootHash = import_node_crypto.default.createHash("md5").update(serverState.projectRoot).digest("hex");
+    const rootHash = import_node_crypto2.default.createHash("md5").update(serverState.projectRoot).digest("hex");
     portData[rootHash] = port;
-    import_node_fs2.default.writeFileSync(portFile, JSON.stringify(portData, null, 2), "utf-8");
+    import_node_fs3.default.writeFileSync(portFile, JSON.stringify(portData, null, 2), "utf-8");
   } catch (e) {
-    serverLogger.warn("Failed to write port file:", e);
+    serverLogger4.warn("Failed to write port file:", e);
   }
   process.once("exit", () => {
     try {
-      if (import_node_fs2.default.existsSync(portFile)) {
-        const portData = JSON.parse(import_node_fs2.default.readFileSync(portFile, "utf-8"));
-        const rootHash = import_node_crypto.default.createHash("md5").update(serverState.projectRoot).digest("hex");
+      if (import_node_fs3.default.existsSync(portFile)) {
+        const portData = JSON.parse(import_node_fs3.default.readFileSync(portFile, "utf-8"));
+        const rootHash = import_node_crypto2.default.createHash("md5").update(serverState.projectRoot).digest("hex");
         delete portData[rootHash];
         if (Object.keys(portData).length === 0) {
-          import_node_fs2.default.unlinkSync(portFile);
+          import_node_fs3.default.unlinkSync(portFile);
         } else {
-          import_node_fs2.default.writeFileSync(portFile, JSON.stringify(portData, null, 2), "utf-8");
+          import_node_fs3.default.writeFileSync(portFile, JSON.stringify(portData, null, 2), "utf-8");
         }
       }
     } catch {
     }
   });
-  serverLogger.info(`server running at http://127.0.0.1:${port}`);
+  serverLogger4.info(`server running at http://127.0.0.1:${port}`);
   return port;
 }
 async function readBody(req) {
@@ -673,26 +1007,7 @@ async function handleRequest(url, req, res) {
     return;
   }
   if (pathname === import_types2.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
-    };
+    const config = await buildClientConfig(serverState);
     delete config.providers;
     res.writeHead(200, { "Content-Type": "application/json" });
     res.end(JSON.stringify(config));
@@ -703,23 +1018,23 @@ async function handleRequest(url, req, res) {
       const body = JSON.parse(await readBody(req));
       const ideWorkspace = body.workspaceRoot || "";
       const serverProjectRoot = serverState.projectRoot || "";
-      const normalizedIdeRoot = ideWorkspace ? import_node_path2.default.resolve(ideWorkspace) : "";
-      const normalizedServerRoot = serverProjectRoot ? import_node_path2.default.resolve(serverProjectRoot) : "";
-      const isSameProject = !normalizedIdeRoot || !normalizedServerRoot || normalizedIdeRoot === normalizedServerRoot || normalizedServerRoot.startsWith(normalizedIdeRoot + import_node_path2.default.sep) || normalizedIdeRoot.startsWith(normalizedServerRoot + import_node_path2.default.sep);
+      const normalizedIdeRoot = ideWorkspace ? import_node_path4.default.resolve(ideWorkspace) : "";
+      const normalizedServerRoot = serverProjectRoot ? import_node_path4.default.resolve(serverProjectRoot) : "";
+      const isSameProject = !normalizedIdeRoot || !normalizedServerRoot || normalizedIdeRoot === normalizedServerRoot || normalizedServerRoot.startsWith(normalizedIdeRoot + import_node_path4.default.sep) || normalizedIdeRoot.startsWith(normalizedServerRoot + import_node_path4.default.sep);
       if (isSameProject) {
         serverState.ideInfo = body;
-        serverLogger.debug(
+        serverLogger4.debug(
           `Accepted IDE info from matched workspace (ide-${body.ide} / schema-${body.scheme})`
         );
       } else {
-        serverLogger.debug(
+        serverLogger4.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 ${import_types2.INSPECTO_API_PATHS.IDE_INFO} POST request:`, e);
+      serverLogger4.error(`Error parsing ${import_types2.INSPECTO_API_PATHS.IDE_INFO} POST request:`, e);
       res.writeHead(400, { "Content-Type": "application/json" });
       res.end(JSON.stringify({ error: "Invalid JSON body" }));
     }
@@ -734,79 +1049,14 @@ async function handleRequest(url, req, res) {
       res.end(JSON.stringify({ error: "Invalid JSON body" }));
       return;
     }
-    const absolutePath = import_node_path2.default.isAbsolute(body.file) ? import_node_path2.default.resolve(body.file) : import_node_path2.default.resolve(serverState.cwd, body.file);
-    const relativeToRoot = import_node_path2.default.relative(serverState.projectRoot, absolutePath);
-    if (relativeToRoot.startsWith("..") || import_node_path2.default.isAbsolute(relativeToRoot)) {
-      serverLogger.warn(`Security: Blocked path traversal attempt in IDE_OPEN: ${body.file}`);
+    try {
+      handleOpenFileRequest(body, serverState);
+    } catch {
+      serverLogger4.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)) {
-      let normalizedPath = absolutePath.replace(/\\/g, "/");
-      if (!normalizedPath.startsWith("/")) {
-        normalizedPath = "/" + normalizedPath;
-      }
-      const encodedPath = encodeURI(normalizedPath);
-      const uri = `${rawEditorHint}://file${encodedPath}:${body.line}:${body.column}`;
-      serverLogger.debug(`IDE_OPEN: Bypassing launchIDE, using URI scheme directly: ${uri}`);
-      try {
-        if (process.platform === "darwin") {
-          (0, import_node_child_process.execFileSync)("open", [uri]);
-        } else if (process.platform === "win32") {
-          (0, import_node_child_process.execFileSync)("cmd", ["/c", "start", '""', uri]);
-        } else {
-          (0, import_node_child_process.execFileSync)("xdg-open", [uri]);
-        }
-      } catch (e) {
-        serverLogger.error(`Failed to launch URI for IDE_OPEN (${uri}):`, e);
-        (0, import_launch_ide.launchIDE)({
-          file: absolutePath,
-          line: body.line,
-          column: body.column,
-          editor: editorHint,
-          type: process.platform === "darwin" ? "open" : "exec"
-        });
-      }
-    } else {
-      (0, import_launch_ide.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;
@@ -817,10 +1067,11 @@ async function handleRequest(url, req, res) {
     const column = parseInt(url.searchParams.get("column") ?? "1", 10);
     const maxLines = parseInt(url.searchParams.get("maxLines") ?? "100", 10);
     try {
-      const absolutePath = import_node_path2.default.isAbsolute(file) ? import_node_path2.default.resolve(file) : import_node_path2.default.resolve(serverState.cwd, file);
-      const relativeToRoot = import_node_path2.default.relative(serverState.projectRoot, absolutePath);
-      if (relativeToRoot.startsWith("..") || import_node_path2.default.isAbsolute(relativeToRoot)) {
-        serverLogger.warn(`Security: Blocked path traversal attempt in PROJECT_SNIPPET: ${file}`);
+      const absolutePath = resolveWorkspacePath(file, serverState.cwd);
+      try {
+        assertPathWithinProject(absolutePath, serverState.projectRoot);
+      } catch {
+        serverLogger4.warn(`Security: Blocked path traversal attempt in PROJECT_SNIPPET: ${file}`);
         res.writeHead(403, { "Content-Type": "application/json" });
         res.end(
           JSON.stringify({
@@ -850,7 +1101,23 @@ async function handleRequest(url, req, res) {
       res.writeHead(result.success ? 200 : 500, { "Content-Type": "application/json" });
       res.end(JSON.stringify(result));
     } catch (e) {
-      serverLogger.error(`Error parsing ${import_types2.INSPECTO_API_PATHS.AI_DISPATCH} request:`, e);
+      serverLogger4.error(`Error parsing ${import_types2.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 === import_types2.INSPECTO_API_PATHS.AI_BATCH_DISPATCH && req.method === "POST") {
+    try {
+      const rawBody = await readBody(req);
+      const body = JSON.parse(rawBody);
+      const result = await dispatchAnnotationsToAi(body, serverState);
+      res.writeHead(getBatchDispatchStatusCode(result.errorCode, result.success), {
+        "Content-Type": "application/json"
+      });
+      res.end(JSON.stringify(result));
+    } catch (e) {
+      serverLogger4.error(`Error parsing ${import_types2.INSPECTO_API_PATHS.AI_BATCH_DISPATCH} request:`, e);
       res.writeHead(500, { "Content-Type": "application/json" });
       res.end(JSON.stringify({ success: false, error: String(e), errorCode: "INTERNAL_ERROR" }));
     }
@@ -858,7 +1125,7 @@ async function handleRequest(url, req, res) {
   }
   if (pathname.startsWith(`${import_types2.INSPECTO_API_PATHS.AI_TICKET}/`) && req.method === "GET") {
     const ticketId = pathname.substring(import_types2.INSPECTO_API_PATHS.AI_TICKET.length + 1);
-    const payloadStr = payloadTickets.get(ticketId);
+    const payloadStr = readTicket(ticketId);
     if (!payloadStr) {
       res.writeHead(404, { "Content-Type": "application/json" });
       res.end(JSON.stringify({ success: false, error: "Ticket not found or expired" }));
@@ -872,58 +1139,32 @@ async function handleRequest(url, req, res) {
   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 { location, snippet, prompt, screenshotContext } = req;
   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,
+  const runtime = resolvePromptDispatchRuntime(serverState);
+  return dispatchPromptThroughIde(runtime, {
     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
-    }
-  };
+    ...screenshotContext ? { screenshotContext } : {}
+  });
+}
+function getBatchDispatchStatusCode(errorCode, success) {
+  if (success) return 200;
+  if (errorCode === "INVALID_REQUEST") return 400;
+  if (errorCode === "FORBIDDEN_PATH") return 403;
+  return 500;
 }
 
 // src/legacy/webpack4/index.ts
-var import_node_path3 = __toESM(require("path"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
 var InspectoWebpack4Plugin = class {
   constructor(options = {}) {
     this.options = options;
@@ -931,7 +1172,7 @@ var InspectoWebpack4Plugin = class {
   apply(compiler) {
     const clientPath = resolveClientModule();
     compiler.hooks.afterEnvironment.tap("InspectoWebpack4Plugin", () => {
-      const inspectoLoader = import_node_path3.default.resolve(__dirname, "loader.cjs");
+      const inspectoLoader = import_node_path5.default.resolve(__dirname, "loader.cjs");
       compiler.options.module.rules.push({
         test: /\.[jt]sx?$/,
         enforce: "pre",