@inspecto-dev/plugin 0.3.8 → 0.3.9

package/dist/legacy/rspack/index.cjs

@@ -537,7 +537,6 @@ function dispatchPromptThroughIde(runtime, payload) {
     line: payload.line,
     column: payload.column,
     snippet: payload.snippet,
-    ...payload.screenshotContext ? { screenshotContext: payload.screenshotContext } : {},
     overrides: runtime.overrides,
     autoSend: runtime.autoSend
   });
@@ -671,6 +670,188 @@ function assertPathWithinIdeOpenScope(file, projectRoot) {
   }
 }
 
+// src/server/session-store.ts
+var DEFAULT_STATUS = "pending";
+function createAnnotationSessionStore(options = {}) {
+  const sessions = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  const now = options.now ?? (() => Date.now());
+  const createId = options.createId ?? createRandomId;
+  function findNewestMatchingSession(statuses) {
+    return [...sessions.values()].filter((session) => statuses ? statuses.has(session.status) : true).sort((left, right) => right.updatedAt - left.updatedAt)[0] ?? null;
+  }
+  function updateSessionStatus(id, status) {
+    const session = sessions.get(id);
+    if (!session) return null;
+    const timestamp = now();
+    session.status = status;
+    session.updatedAt = timestamp;
+    if (status === "acknowledged") {
+      session.acknowledgedAt = timestamp;
+    }
+    if (status === "resolved") {
+      session.resolvedAt = timestamp;
+    }
+    emit({ type: "session-status-updated", session });
+    return cloneSession(session);
+  }
+  function claimSession(id, statuses) {
+    const session = sessions.get(id);
+    if (!session || statuses && !statuses.has(session.status)) return null;
+    if (session.status === "acknowledged") return cloneSession(session);
+    return updateSessionStatus(id, "acknowledged");
+  }
+  function emit(event) {
+    const snapshot = cloneSession(event.session);
+    for (const listener of listeners) {
+      listener({ type: event.type, session: snapshot });
+    }
+  }
+  const store = {
+    createSession(input) {
+      const timestamp = now();
+      const session = {
+        id: createId(),
+        instruction: input.instruction?.trim() ?? "",
+        annotations: cloneArray(input.annotations),
+        ...input.deliveryMode ? { deliveryMode: input.deliveryMode } : {},
+        status: DEFAULT_STATUS,
+        messages: cloneArray(input.messages ?? []),
+        createdAt: timestamp,
+        updatedAt: timestamp,
+        ...input.runtimeContext ? { runtimeContext: cloneValue(input.runtimeContext) } : {},
+        ...input.cssContextPrompt?.trim() ? { cssContextPrompt: input.cssContextPrompt.trim() } : {},
+        ...input.pageUrl ? { pageUrl: input.pageUrl } : {},
+        ...input.route ? { route: input.route } : {}
+      };
+      sessions.set(session.id, session);
+      emit({ type: "session-created", session });
+      return cloneSession(session);
+    },
+    getSession(id) {
+      const session = sessions.get(id);
+      return session ? cloneSession(session) : null;
+    },
+    listSessions(options2 = {}) {
+      const statuses = normalizeStatuses(options2.status);
+      return [...sessions.values()].filter((session) => statuses ? statuses.has(session.status) : true).sort((left, right) => right.updatedAt - left.updatedAt).map((session) => cloneSession(session));
+    },
+    async claimNextSession(options2 = {}) {
+      const statuses = normalizeStatuses(DEFAULT_STATUS);
+      const existingSession = findNewestMatchingSession(statuses);
+      if (existingSession) {
+        return {
+          session: claimSession(existingSession.id, statuses),
+          timedOut: false,
+          matchedExisting: true
+        };
+      }
+      const timeoutMs = normalizeTimeoutMs(options2.timeoutMs);
+      if (timeoutMs === 0) {
+        return {
+          session: null,
+          timedOut: true,
+          matchedExisting: false
+        };
+      }
+      return await new Promise((resolve2) => {
+        let settled = false;
+        let timeout = null;
+        const finish = (result) => {
+          if (settled) return;
+          settled = true;
+          unsubscribe();
+          if (timeout) {
+            clearTimeout(timeout);
+          }
+          resolve2(result);
+        };
+        const unsubscribe = this.subscribe((event) => {
+          const session = claimSession(event.session.id, statuses);
+          if (!session) return;
+          finish({
+            session,
+            timedOut: false,
+            matchedExisting: false,
+            event: event.type
+          });
+        });
+        if (timeoutMs !== null) {
+          timeout = setTimeout(() => {
+            finish({
+              session: null,
+              timedOut: true,
+              matchedExisting: false
+            });
+          }, timeoutMs);
+        }
+      });
+    },
+    appendMessage(id, input) {
+      const session = sessions.get(id);
+      if (!session) return null;
+      const timestamp = now();
+      session.messages.push({
+        id: createId(),
+        role: input.role,
+        text: input.text,
+        createdAt: timestamp
+      });
+      session.updatedAt = timestamp;
+      if (input.role === "agent" && isPendingLikeStatus(session.status)) {
+        session.status = "in_progress";
+      }
+      emit({ type: "session-message-appended", session });
+      return cloneSession(session);
+    },
+    updateStatus(id, status) {
+      return updateSessionStatus(id, status);
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    clear() {
+      sessions.clear();
+      listeners.clear();
+    }
+  };
+  return store;
+}
+var annotationSessionStore = createAnnotationSessionStore();
+function normalizeStatuses(status) {
+  if (!status) return null;
+  return new Set(Array.isArray(status) ? status : [status]);
+}
+function normalizeTimeoutMs(value) {
+  if (value === void 0) return null;
+  if (!Number.isFinite(value)) return 0;
+  return Math.max(0, Math.floor(value));
+}
+function isPendingLikeStatus(status) {
+  return status === "pending" || status === "acknowledged";
+}
+function hasAgentReply(session) {
+  return session.messages.some((message) => message.role === "agent" && Boolean(message.text?.trim()));
+}
+function createRandomId() {
+  return `annotation-session-${Math.random().toString(36).slice(2, 10)}`;
+}
+function cloneSession(session) {
+  return cloneValue(session);
+}
+function cloneArray(value) {
+  return cloneValue(value);
+}
+function cloneValue(value) {
+  if (typeof structuredClone === "function") {
+    return structuredClone(value);
+  }
+  return JSON.parse(JSON.stringify(value));
+}
+
 // src/server/annotation-dispatch.ts
 var AnnotationDispatchError = class extends Error {
   constructor(message, errorCode) {
@@ -679,20 +860,30 @@ var AnnotationDispatchError = class extends Error {
     this.errorCode = errorCode;
   }
 };
-async function dispatchAnnotationsToAi(req, state) {
+async function dispatchAnnotationsToAi(req, state, store = annotationSessionStore) {
   try {
     validateAnnotationDispatchRequest(req, state);
     const batch = normalizeAnnotationBatch(req);
     const prompt = buildAnnotationBatchPrompt(batch);
+    const deliveryMode = normalizeDeliveryMode(req.deliveryMode);
+    const session = store.createSession({
+      instruction: batch.instruction,
+      annotations: toSessionAnnotations(batch.annotations),
+      deliveryMode,
+      ...batch.runtimeContext ? { runtimeContext: batch.runtimeContext } : {},
+      ...batch.cssContextPrompt ? { cssContextPrompt: batch.cssContextPrompt } : {}
+    });
     const representativeTarget = batch.annotations[0]?.targets[0];
-    const runtime = resolvePromptDispatchRuntime(state);
-    return dispatchPromptThroughIde(runtime, {
+    const dispatchResult = deliveryMode === "ide" ? dispatchPromptThroughIde(resolvePromptDispatchRuntime(state), {
       prompt,
       ...representativeTarget?.file ? { filePath: representativeTarget.file } : {},
       ...representativeTarget?.line ? { line: representativeTarget.line } : {},
-      ...representativeTarget?.column ? { column: representativeTarget.column } : {},
-      ...batch.screenshotContext ? { screenshotContext: batch.screenshotContext } : {}
-    });
+      ...representativeTarget?.column ? { column: representativeTarget.column } : {}
+    }) : { success: true };
+    return {
+      ...dispatchResult,
+      session: toSessionSummary(session)
+    };
   } catch (error) {
     return {
       success: false,
@@ -701,6 +892,41 @@ async function dispatchAnnotationsToAi(req, state) {
     };
   }
 }
+function normalizeDeliveryMode(input) {
+  return input === "agent" ? "agent" : "ide";
+}
+function toSessionAnnotations(annotations) {
+  return annotations.map((annotation) => ({
+    id: `annotation-${annotation.index}`,
+    note: annotation.note,
+    intent: annotation.intent,
+    targets: annotation.targets.map((target, targetIndex) => ({
+      id: `annotation-${annotation.index}-target-${targetIndex + 1}`,
+      label: target.label ?? "Unknown target",
+      location: {
+        file: target.file,
+        line: target.line,
+        column: target.column
+      },
+      ...target.selector ? { selector: target.selector } : {},
+      ...target.snippet ? { snippet: target.snippet } : {},
+      rect: {
+        x: 0,
+        y: 0,
+        width: 0,
+        height: 0
+      }
+    }))
+  }));
+}
+function toSessionSummary(session) {
+  return {
+    id: session.id,
+    status: session.status,
+    createdAt: session.createdAt,
+    updatedAt: session.updatedAt
+  };
+}
 function validateAnnotationDispatchRequest(req, state) {
   if (!req.annotations.length) {
     throw new AnnotationDispatchError("At least one annotation is required.", "INVALID_REQUEST");
@@ -721,9 +947,7 @@ function validateAnnotationDispatchRequest(req, state) {
 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,
@@ -745,12 +969,9 @@ function buildAnnotationBatchPrompt(batch) {
   const prompt = batch.instruction ? `${batch.instruction}
 
 ${body}` : body;
-  return appendScreenshotContextSection(
-    appendCssContextSection(
-      appendRuntimeContextSection(prompt, batch.runtimeContext),
-      batch.cssContextPrompt
-    ),
-    batch.screenshotContext
+  return appendCssContextSection(
+    appendRuntimeContextSection(prompt, batch.runtimeContext),
+    batch.cssContextPrompt
   );
 }
 function appendCssContextSection(prompt, cssContextPrompt) {
@@ -777,20 +998,6 @@ function buildSelectedElementsPrompt(annotations) {
   }
   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;
@@ -838,7 +1045,7 @@ async function buildClientConfig(serverState2) {
     ...info,
     prompts: resolveIntents(promptsConfig),
     hotKeys: userConfig["inspector.hotKey"] ?? "alt",
-    theme: userConfig["inspector.theme"] ?? "auto",
+    annotateDeliveryMode: userConfig["annotate.deliveryMode"] ?? "both",
     includeSnippet: userConfig["prompt.includeSnippet"] ?? false,
     runtimeContext: {
       enabled: true,
@@ -846,10 +1053,6 @@ async function buildClientConfig(serverState2) {
       maxRuntimeErrors: 3,
       maxFailedRequests: 2
     },
-    screenshotContext: {
-      enabled: false
-    },
-    annotationResponseMode: userConfig["prompt.annotationResponseMode"] ?? "unified",
     autoSend: userConfig["prompt.autoSend"] ?? false
   };
 }
@@ -894,7 +1097,7 @@ function handleOpenFileRequest(body, serverState2) {
   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}`
+    `SOURCE_OPEN: activeIde=${activeIde}, activeIdeScheme=${activeIdeScheme}, configuredIde=${configuredIde} -> rawEditorHint=${rawEditorHint}, finalEditorHint=${editorHint}`
   );
   if (VSCODE_FAMILY_SCHEMES.includes(rawEditorHint)) {
     let normalizedPath = absolutePath.replace(/\\/g, "/");
@@ -903,7 +1106,7 @@ function handleOpenFileRequest(body, serverState2) {
     }
     const encodedPath = encodeURI(normalizedPath);
     const uri = `${rawEditorHint}://file${encodedPath}:${body.line}:${body.column}`;
-    serverLogger2.debug(`IDE_OPEN: Bypassing launchIDE, using URI scheme directly: ${uri}`);
+    serverLogger2.debug(`SOURCE_OPEN: Bypassing launchIDE, using URI scheme directly: ${uri}`);
     try {
       if (process.platform === "darwin") {
         (0, import_node_child_process2.execFileSync)("open", [uri]);
@@ -913,7 +1116,7 @@ function handleOpenFileRequest(body, serverState2) {
         (0, import_node_child_process2.execFileSync)("xdg-open", [uri]);
       }
     } catch (e) {
-      serverLogger2.error(`Failed to launch URI for IDE_OPEN (${uri}):`, e);
+      serverLogger2.error(`Failed to launch URI for SOURCE_OPEN (${uri}):`, e);
       (0, import_launch_ide2.launchIDE)({
         file: absolutePath,
         line: body.line,
@@ -970,6 +1173,7 @@ function resolveProjectRoot() {
 
 // src/server/index.ts
 var serverLogger4 = createLogger("inspecto:server", { logLevel: getGlobalLogLevel() });
+var PORT_FILE_NAME = "inspecto.port.json";
 var serverState = {
   port: null,
   running: false,
@@ -978,6 +1182,42 @@ var serverState = {
   cwd: process.cwd()
 };
 var serverInstance = null;
+function getPortFilePath() {
+  return import_node_path4.default.join(import_node_os2.default.tmpdir(), PORT_FILE_NAME);
+}
+function getProjectRootHash() {
+  if (!serverState.projectRoot) return null;
+  return import_node_crypto2.default.createHash("md5").update(serverState.projectRoot).digest("hex");
+}
+function readPortData(portFile) {
+  if (!import_node_fs4.default.existsSync(portFile)) return {};
+  try {
+    return JSON.parse(import_node_fs4.default.readFileSync(portFile, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeProjectPort(port) {
+  const rootHash = getProjectRootHash();
+  if (!rootHash) return;
+  const portFile = getPortFilePath();
+  const portData = readPortData(portFile);
+  portData[rootHash] = port;
+  import_node_fs4.default.writeFileSync(portFile, JSON.stringify(portData, null, 2), "utf-8");
+}
+function removeProjectPort() {
+  const rootHash = getProjectRootHash();
+  if (!rootHash) return;
+  const portFile = getPortFilePath();
+  if (!import_node_fs4.default.existsSync(portFile)) return;
+  const portData = readPortData(portFile);
+  delete portData[rootHash];
+  if (Object.keys(portData).length === 0) {
+    import_node_fs4.default.unlinkSync(portFile);
+  } else {
+    import_node_fs4.default.writeFileSync(portFile, JSON.stringify(portData, null, 2), "utf-8");
+  }
+}
 async function startServer() {
   if (serverState.running && serverState.port !== null) {
     return serverState.port;
@@ -1011,7 +1251,7 @@ async function startServer() {
     });
   });
   await new Promise((resolve2, reject) => {
-    serverInstance.listen(port, "127.0.0.1", () => {
+    serverInstance.listen(port, "0.0.0.0", () => {
       serverInstance.unref();
       resolve2();
     });
@@ -1022,37 +1262,18 @@ async function startServer() {
   });
   serverState.port = port;
   serverState.running = true;
-  const portFile = import_node_path4.default.join(import_node_os2.default.tmpdir(), "inspecto.port.json");
   try {
-    let portData = {};
-    if (import_node_fs4.default.existsSync(portFile)) {
-      try {
-        portData = JSON.parse(import_node_fs4.default.readFileSync(portFile, "utf-8"));
-      } catch (_e) {
-      }
-    }
-    const rootHash = import_node_crypto2.default.createHash("md5").update(serverState.projectRoot).digest("hex");
-    portData[rootHash] = port;
-    import_node_fs4.default.writeFileSync(portFile, JSON.stringify(portData, null, 2), "utf-8");
+    writeProjectPort(port);
   } catch (_e) {
     serverLogger4.warn("Failed to write port file:", _e);
   }
   process.once("exit", () => {
     try {
-      if (import_node_fs4.default.existsSync(portFile)) {
-        const portData = JSON.parse(import_node_fs4.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_fs4.default.unlinkSync(portFile);
-        } else {
-          import_node_fs4.default.writeFileSync(portFile, JSON.stringify(portData, null, 2), "utf-8");
-        }
-      }
+      removeProjectPort();
     } catch {
     }
   });
-  serverLogger4.info(`server running at http://127.0.0.1:${port}`);
+  serverLogger4.info(`server running at http://0.0.0.0:${port}`);
   return port;
 }
 async function readBody(req) {
@@ -1104,7 +1325,7 @@ async function handleRequest(url, req, res) {
     }
     return;
   }
-  if (pathname === import_types2.INSPECTO_API_PATHS.IDE_OPEN && req.method === "POST") {
+  if ((pathname === import_types2.INSPECTO_API_PATHS.SOURCE_OPEN || pathname === import_types2.INSPECTO_API_PATHS.IDE_OPEN) && req.method === "POST") {
     let body;
     try {
       body = JSON.parse(await readBody(req));
@@ -1117,7 +1338,7 @@ async function handleRequest(url, req, res) {
       handleOpenFileRequest(body, serverState);
     } catch (err) {
       serverLogger4.warn(
-        `Security: Blocked path traversal attempt in IDE_OPEN: ${body.file}. Reason: ${err.message}`
+        `Security: Blocked path traversal attempt in SOURCE_OPEN: ${body.file}. Reason: ${err.message}`
       );
       res.writeHead(403, { "Content-Type": "application/json" });
       res.end(JSON.stringify({ error: "Access denied: File is outside of project workspace" }));
@@ -1191,6 +1412,212 @@ async function handleRequest(url, req, res) {
     }
     return;
   }
+  if (pathname === import_types2.INSPECTO_API_PATHS.SESSION_CLAIM_NEXT && req.method === "POST") {
+    try {
+      const rawBody = await readBody(req);
+      const body = rawBody ? JSON.parse(rawBody) : {};
+      const timeoutMs = normalizeSessionClaimTimeout(
+        body.timeoutMs === void 0 ? null : String(body.timeoutMs)
+      );
+      const result = await annotationSessionStore.claimNextSession({
+        ...timeoutMs !== void 0 ? { timeoutMs } : {}
+      });
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({
+          success: true,
+          timedOut: result.timedOut,
+          matchedExisting: result.matchedExisting,
+          ...result.event ? { event: result.event } : {},
+          ...result.session ? { session: result.session } : {}
+        })
+      );
+    } catch (e) {
+      serverLogger4.error(`Error parsing session claim request:`, e);
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: false, error: "Invalid JSON body" }));
+    }
+    return;
+  }
+  if (pathname === import_types2.INSPECTO_API_PATHS.SESSION_EVENTS && req.method === "GET") {
+    const statusParam = url.searchParams.getAll("status");
+    const statuses = statusParam.length ? new Set(statusParam) : null;
+    const sessionId = url.searchParams.get("sessionId")?.trim() || null;
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    });
+    res.write(`event: ready
+data: ${JSON.stringify({ ok: true })}
+
+`);
+    const unsubscribe = annotationSessionStore.subscribe((event) => {
+      if (sessionId && event.session.id !== sessionId) {
+        return;
+      }
+      if (statuses && !statuses.has(event.session.status)) {
+        return;
+      }
+      res.write(formatSessionSseEvent(event));
+    });
+    req.on("close", () => {
+      unsubscribe();
+      res.end();
+    });
+    return;
+  }
+  if (pathname === import_types2.INSPECTO_API_PATHS.SESSIONS && req.method === "GET") {
+    const statusParam = url.searchParams.getAll("status");
+    const sessions = annotationSessionStore.listSessions(
+      statusParam.length ? {
+        status: statusParam
+      } : void 0
+    );
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ success: true, sessions }));
+    return;
+  }
+  if (pathname.startsWith(`${import_types2.INSPECTO_API_PATHS.SESSIONS}/`) && req.method === "GET") {
+    const sessionId = pathname.substring(import_types2.INSPECTO_API_PATHS.SESSIONS.length + 1);
+    const session = annotationSessionStore.getSession(sessionId);
+    if (!session) {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: false, error: "Session not found" }));
+      return;
+    }
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ success: true, session }));
+    return;
+  }
+  if (pathname.startsWith(`${import_types2.INSPECTO_API_PATHS.SESSIONS}/`) && pathname.endsWith(import_types2.INSPECTO_API_PATHS.SESSION_REPLY_SUFFIX) && req.method === "POST") {
+    const sessionId = pathname.slice(
+      import_types2.INSPECTO_API_PATHS.SESSIONS.length + 1,
+      -import_types2.INSPECTO_API_PATHS.SESSION_REPLY_SUFFIX.length
+    );
+    try {
+      const rawBody = await readBody(req);
+      const body = JSON.parse(rawBody);
+      if (!isAnnotationThreadRole(body.role)) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ success: false, error: "Reply role is invalid." }));
+        return;
+      }
+      if (!body.text?.trim()) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ success: false, error: "Reply text is required." }));
+        return;
+      }
+      const session = annotationSessionStore.appendMessage(sessionId, {
+        role: body.role,
+        text: body.text.trim()
+      });
+      if (!session) {
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ success: false, error: "Session not found" }));
+        return;
+      }
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: true, session }));
+    } catch (e) {
+      serverLogger4.error(`Error parsing session reply request:`, e);
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: false, error: "Invalid JSON body" }));
+    }
+    return;
+  }
+  if (pathname.startsWith(`${import_types2.INSPECTO_API_PATHS.SESSIONS}/`) && pathname.endsWith(import_types2.INSPECTO_API_PATHS.SESSION_RESOLVE_SUFFIX) && req.method === "POST") {
+    const sessionId = pathname.slice(
+      import_types2.INSPECTO_API_PATHS.SESSIONS.length + 1,
+      -import_types2.INSPECTO_API_PATHS.SESSION_RESOLVE_SUFFIX.length
+    );
+    try {
+      const rawBody = await readBody(req);
+      const body = rawBody ? JSON.parse(rawBody) : {};
+      const message = body.message?.trim();
+      const existingSession = annotationSessionStore.getSession(sessionId);
+      if (!existingSession) {
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ success: false, error: "Session not found" }));
+        return;
+      }
+      if (!message && !hasAgentReply(existingSession)) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            success: false,
+            error: "Resolve message is required until an agent reply is recorded."
+          })
+        );
+        return;
+      }
+      if (message) {
+        const repliedSession = annotationSessionStore.appendMessage(sessionId, {
+          role: "agent",
+          text: message
+        });
+        if (!repliedSession) {
+          res.writeHead(404, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ success: false, error: "Session not found" }));
+          return;
+        }
+      }
+      const session = annotationSessionStore.updateStatus(sessionId, "resolved");
+      if (!session) {
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ success: false, error: "Session not found" }));
+        return;
+      }
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: true, session }));
+    } catch (e) {
+      serverLogger4.error(`Error parsing session resolve request:`, e);
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: false, error: "Invalid JSON body" }));
+    }
+    return;
+  }
+  if (pathname.startsWith(`${import_types2.INSPECTO_API_PATHS.SESSIONS}/`) && pathname.endsWith(import_types2.INSPECTO_API_PATHS.SESSION_DISMISS_SUFFIX) && req.method === "POST") {
+    const sessionId = pathname.slice(
+      import_types2.INSPECTO_API_PATHS.SESSIONS.length + 1,
+      -import_types2.INSPECTO_API_PATHS.SESSION_DISMISS_SUFFIX.length
+    );
+    try {
+      const rawBody = await readBody(req);
+      const body = rawBody ? JSON.parse(rawBody) : {};
+      const message = body.message?.trim();
+      const existingSession = annotationSessionStore.getSession(sessionId);
+      if (!existingSession) {
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ success: false, error: "Session not found" }));
+        return;
+      }
+      if (message) {
+        const repliedSession = annotationSessionStore.appendMessage(sessionId, {
+          role: "agent",
+          text: message
+        });
+        if (!repliedSession) {
+          res.writeHead(404, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ success: false, error: "Session not found" }));
+          return;
+        }
+      }
+      const session = annotationSessionStore.updateStatus(sessionId, "dismissed");
+      if (!session) {
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ success: false, error: "Session not found" }));
+        return;
+      }
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: true, session }));
+    } catch (e) {
+      serverLogger4.error(`Error parsing session dismiss request:`, e);
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: false, error: "Invalid JSON body" }));
+    }
+    return;
+  }
   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 = readTicket(ticketId);
@@ -1207,7 +1634,7 @@ async function handleRequest(url, req, res) {
   res.end(JSON.stringify({ error: "not found" }));
 }
 async function dispatchToAi(req) {
-  const { location, snippet, prompt, screenshotContext } = req;
+  const { location, snippet, prompt } = req;
   const formattedPrompt = prompt ?? `Please help me with this code from \`${location.file}\` (line ${location.line}):
 
 \`\`\`
@@ -1220,8 +1647,7 @@ ${snippet}
     filePath: location.file,
     line: location.line,
     column: location.column,
-    snippet,
-    ...screenshotContext ? { screenshotContext } : {}
+    snippet
   });
 }
 function getBatchDispatchStatusCode(errorCode, success) {
@@ -1230,6 +1656,21 @@ function getBatchDispatchStatusCode(errorCode, success) {
   if (errorCode === "FORBIDDEN_PATH") return 403;
   return 500;
 }
+function isAnnotationThreadRole(value) {
+  return value === "user" || value === "agent" || value === "system";
+}
+function formatSessionSseEvent(event) {
+  return `event: ${event.type}
+data: ${JSON.stringify(event)}
+
+`;
+}
+function normalizeSessionClaimTimeout(value) {
+  if (!value?.trim()) return 3e4;
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed)) return 3e4;
+  return Math.max(0, Math.min(parsed, 3e5));
+}
 
 // src/injectors/utils.ts
 var import_node_module = require("module");
@@ -1252,13 +1693,13 @@ var resolveClientModule = () => {
 function getWebpackHtmlScript(serverPort2) {
   return `
 window.__AI_INSPECTOR_PORT__ = ${serverPort2};
-window.addEventListener('load', () => {
-  if (window.InspectoClient) {
-    window.InspectoClient.mountInspector({
-      serverUrl: 'http://127.0.0.1:' + window.__AI_INSPECTOR_PORT__,
-    });
-  }
-});
+  window.addEventListener('load', () => {
+    if (window.InspectoClient) {
+      window.InspectoClient.mountInspector({
+        serverUrl: 'http://0.0.0.0:' + window.__AI_INSPECTOR_PORT__,
+      });
+    }
+  });
 `;
 }