@steipete/oracle 0.9.0 → 0.10.0

package/dist/src/browser/actions/assistantResponse.js

@@ -1,46 +1,51 @@
-import { ANSWER_SELECTORS, ASSISTANT_ROLE_SELECTOR, CONVERSATION_TURN_SELECTOR, COPY_BUTTON_SELECTOR, FINISHED_ACTIONS_SELECTOR, STOP_BUTTON_SELECTOR, } from '../constants.js';
-import { delay } from '../utils.js';
-import { logDomFailure, logConversationSnapshot, buildConversationDebugExpression } from '../domDebug.js';
-import { buildClickDispatcher } from './domEvents.js';
-const ASSISTANT_POLL_TIMEOUT_ERROR = 'assistant-response-watchdog-timeout';
+import { ANSWER_SELECTORS, ASSISTANT_ROLE_SELECTOR, CONVERSATION_TURN_SELECTOR, COPY_BUTTON_SELECTOR, FINISHED_ACTIONS_SELECTOR, STOP_BUTTON_SELECTOR, } from "../constants.js";
+import { delay } from "../utils.js";
+import { logDomFailure, logConversationSnapshot, buildConversationDebugExpression, } from "../domDebug.js";
+import { buildClickDispatcher } from "./domEvents.js";
+const ASSISTANT_POLL_TIMEOUT_ERROR = "assistant-response-watchdog-timeout";
 function isAnswerNowPlaceholderText(normalized) {
     const text = normalized.trim();
     if (!text)
         return false;
     // Learned: "Pro thinking" shows a placeholder turn that contains "Answer now".
     // That is not the final answer and must be ignored in browser automation.
-    if (text === 'chatgpt said:' || text === 'chatgpt said')
+    if (text === "chatgpt said:" || text === "chatgpt said")
         return true;
-    if (text.includes('file upload request') && (text.includes('pro thinking') || text.includes('chatgpt said'))) {
+    if (text.includes("file upload request") &&
+        (text.includes("pro thinking") || text.includes("chatgpt said"))) {
         return true;
     }
-    return text.includes('answer now') && (text.includes('pro thinking') || text.includes('chatgpt said'));
+    return (text.includes("answer now") && (text.includes("pro thinking") || text.includes("chatgpt said")));
 }
-export async function waitForAssistantResponse(Runtime, timeoutMs, logger, minTurnIndex) {
+export async function waitForAssistantResponse(Runtime, timeoutMs, logger, minTurnIndex, expectedConversationId) {
     const start = Date.now();
-    logger('Waiting for ChatGPT response');
+    logger("Waiting for ChatGPT response");
     // Learned: two paths are needed:
     // 1) DOM observer (fast when mutations fire),
     // 2) snapshot poller (fallback when observers miss or JS stalls).
-    const expression = buildResponseObserverExpression(timeoutMs, minTurnIndex);
-    const evaluationPromise = Runtime.evaluate({ expression, awaitPromise: true, returnByValue: true });
-    const raceReadyEvaluation = evaluationPromise.then((value) => ({ kind: 'evaluation', value }), (error) => {
-        throw { source: 'evaluation', error };
+    const expression = buildResponseObserverExpression(timeoutMs, minTurnIndex, expectedConversationId);
+    const evaluationPromise = Runtime.evaluate({
+        expression,
+        awaitPromise: true,
+        returnByValue: true,
+    });
+    const raceReadyEvaluation = evaluationPromise.then((value) => ({ kind: "evaluation", value }), (error) => {
+        throw { source: "evaluation", error };
     });
     // Use AbortController to stop the poller when the evaluation wins the race,
     // preventing abandoned polling loops from consuming resources.
     const pollerAbort = new AbortController();
-    const pollerPromise = pollAssistantCompletion(Runtime, timeoutMs, minTurnIndex, pollerAbort.signal).then((value) => ({ kind: 'poll', value }), (error) => {
-        throw { source: 'poll', error };
+    const pollerPromise = pollAssistantCompletion(Runtime, timeoutMs, minTurnIndex, expectedConversationId, pollerAbort.signal).then((value) => ({ kind: "poll", value }), (error) => {
+        throw { source: "poll", error };
     });
     let evaluation = null;
     try {
         const winner = await Promise.race([raceReadyEvaluation, pollerPromise]);
-        if (winner.kind === 'poll') {
+        if (winner.kind === "poll") {
             if (!winner.value) {
-                throw { source: 'poll', error: new Error(ASSISTANT_POLL_TIMEOUT_ERROR) };
+                throw { source: "poll", error: new Error(ASSISTANT_POLL_TIMEOUT_ERROR) };
             }
-            logger('Captured assistant response via snapshot watchdog');
+            logger("Captured assistant response via snapshot watchdog");
             evaluationPromise.catch(() => undefined);
             await terminateRuntimeExecution(Runtime);
             return winner.value;
@@ -50,21 +55,26 @@ export async function waitForAssistantResponse(Runtime, timeoutMs, logger, minTu
         evaluation = winner.value;
     }
     catch (wrappedError) {
-        if (wrappedError && typeof wrappedError === 'object' && 'source' in wrappedError && 'error' in wrappedError) {
+        if (wrappedError &&
+            typeof wrappedError === "object" &&
+            "source" in wrappedError &&
+            "error" in wrappedError) {
             const { source, error } = wrappedError;
-            if (source === 'poll' && error instanceof Error && error.message === ASSISTANT_POLL_TIMEOUT_ERROR) {
+            if (source === "poll" &&
+                error instanceof Error &&
+                error.message === ASSISTANT_POLL_TIMEOUT_ERROR) {
                 evaluation = await evaluationPromise;
             }
-            else if (source === 'poll') {
+            else if (source === "poll") {
                 throw error;
             }
-            else if (source === 'evaluation') {
-                const recovered = await recoverAssistantResponse(Runtime, timeoutMs, logger, minTurnIndex);
+            else if (source === "evaluation") {
+                const recovered = await recoverAssistantResponse(Runtime, timeoutMs, logger, minTurnIndex, expectedConversationId);
                 if (recovered) {
                     return recovered;
                 }
-                await logDomFailure(Runtime, logger, 'assistant-response');
-                throw error ?? new Error('Failed to capture assistant response');
+                await logDomFailure(Runtime, logger, "assistant-response");
+                throw error ?? new Error("Failed to capture assistant response");
             }
         }
         else {
@@ -72,14 +82,14 @@ export async function waitForAssistantResponse(Runtime, timeoutMs, logger, minTu
         }
     }
     if (!evaluation) {
-        await logDomFailure(Runtime, logger, 'assistant-response');
-        throw new Error('Failed to capture assistant response');
+        await logDomFailure(Runtime, logger, "assistant-response");
+        throw new Error("Failed to capture assistant response");
     }
     const parsed = await parseAssistantEvaluationResult(Runtime, evaluation, logger);
     if (!parsed) {
         let remainingMs = Math.max(0, timeoutMs - (Date.now() - start));
         if (remainingMs > 0) {
-            const recovered = await recoverAssistantResponse(Runtime, remainingMs, logger, minTurnIndex);
+            const recovered = await recoverAssistantResponse(Runtime, remainingMs, logger, minTurnIndex, expectedConversationId);
             if (recovered) {
                 return recovered;
             }
@@ -89,15 +99,15 @@ export async function waitForAssistantResponse(Runtime, timeoutMs, logger, minTu
                     pollerPromise.catch(() => null),
                     delay(remainingMs).then(() => null),
                 ]);
-                if (polled && polled.kind === 'poll' && polled.value) {
+                if (polled && polled.kind === "poll" && polled.value) {
                     return polled.value;
                 }
             }
         }
-        await logDomFailure(Runtime, logger, 'assistant-response');
-        throw new Error('Unable to capture assistant response');
+        await logDomFailure(Runtime, logger, "assistant-response");
+        throw new Error("Unable to capture assistant response");
     }
-    const refreshed = await refreshAssistantSnapshot(Runtime, parsed, logger, minTurnIndex);
+    const refreshed = await refreshAssistantSnapshot(Runtime, parsed, logger, minTurnIndex, expectedConversationId);
     const candidate = refreshed ?? parsed;
     // The evaluation path can race ahead of completion. If ChatGPT is still streaming, wait for the watchdog poller.
     const elapsedMs = Date.now() - start;
@@ -108,8 +118,8 @@ export async function waitForAssistantResponse(Runtime, timeoutMs, logger, minTu
             isCompletionVisible(Runtime),
         ]);
         if (stopVisible) {
-            logger('Assistant still generating; waiting for completion');
-            const completed = await pollAssistantCompletion(Runtime, remainingMs, minTurnIndex);
+            logger("Assistant still generating; waiting for completion");
+            const completed = await pollAssistantCompletion(Runtime, remainingMs, minTurnIndex, expectedConversationId);
             if (completed) {
                 return completed;
             }
@@ -120,16 +130,16 @@ export async function waitForAssistantResponse(Runtime, timeoutMs, logger, minTu
     }
     return candidate;
 }
-export async function readAssistantSnapshot(Runtime, minTurnIndex) {
+export async function readAssistantSnapshot(Runtime, minTurnIndex, expectedConversationId) {
     const { result } = await Runtime.evaluate({
-        expression: buildAssistantSnapshotExpression(minTurnIndex),
+        expression: buildAssistantSnapshotExpression(minTurnIndex, expectedConversationId),
         returnByValue: true,
     });
     const value = result?.value;
-    if (value && typeof value === 'object') {
+    if (value && typeof value === "object") {
         const snapshot = value;
-        if (typeof minTurnIndex === 'number' && Number.isFinite(minTurnIndex)) {
-            const turnIndex = typeof snapshot.turnIndex === 'number' ? snapshot.turnIndex : null;
+        if (typeof minTurnIndex === "number" && Number.isFinite(minTurnIndex)) {
+            const turnIndex = typeof snapshot.turnIndex === "number" ? snapshot.turnIndex : null;
             if (turnIndex === null) {
                 return snapshot;
             }
@@ -147,42 +157,45 @@ export async function captureAssistantMarkdown(Runtime, meta, logger) {
         returnByValue: true,
         awaitPromise: true,
     });
-    if (result?.value?.success && typeof result.value.markdown === 'string') {
+    if (result?.value?.success && typeof result.value.markdown === "string") {
         return result.value.markdown;
     }
     const status = result?.value?.status;
-    if (status && status !== 'missing-button') {
+    if (status && status !== "missing-button") {
         logger(`Copy button fallback status: ${status}`);
-        await logDomFailure(Runtime, logger, 'copy-markdown');
+        await logDomFailure(Runtime, logger, "copy-markdown");
     }
     if (!status) {
-        await logDomFailure(Runtime, logger, 'copy-markdown');
+        await logDomFailure(Runtime, logger, "copy-markdown");
     }
     return null;
 }
 export function buildAssistantExtractorForTest(name) {
     return buildAssistantExtractor(name);
 }
+export function buildAssistantSnapshotExpressionForTest(minTurnIndex, expectedConversationId) {
+    return buildAssistantSnapshotExpression(minTurnIndex, expectedConversationId);
+}
 export function buildConversationDebugExpressionForTest() {
     return buildConversationDebugExpression();
 }
-export function buildMarkdownFallbackExtractorForTest(minTurnLiteral = '0') {
+export function buildMarkdownFallbackExtractorForTest(minTurnLiteral = "0") {
     return buildMarkdownFallbackExtractor(minTurnLiteral);
 }
 export function buildCopyExpressionForTest(meta = {}) {
     return buildCopyExpression(meta);
 }
-async function recoverAssistantResponse(Runtime, timeoutMs, logger, minTurnIndex) {
+async function recoverAssistantResponse(Runtime, timeoutMs, logger, minTurnIndex, expectedConversationId) {
     const recoveryTimeoutMs = Math.max(0, timeoutMs);
     if (recoveryTimeoutMs === 0) {
         return null;
     }
     const recovered = await waitForCondition(async () => {
-        const snapshot = await readAssistantSnapshot(Runtime, minTurnIndex);
+        const snapshot = await readAssistantSnapshot(Runtime, minTurnIndex, expectedConversationId);
         return normalizeAssistantSnapshot(snapshot);
     }, recoveryTimeoutMs, 400);
     if (recovered) {
-        logger('Recovered assistant response via polling fallback');
+        logger("Recovered assistant response via polling fallback");
         return recovered;
     }
     await logConversationSnapshot(Runtime, logger).catch(() => undefined);
@@ -190,24 +203,27 @@ async function recoverAssistantResponse(Runtime, timeoutMs, logger, minTurnIndex
 }
 async function parseAssistantEvaluationResult(_Runtime, evaluation, _logger) {
     const { result } = evaluation;
-    if (result.type === 'object' && result.value && typeof result.value === 'object' && 'text' in result.value) {
-        const html = typeof result.value.html === 'string'
+    if (result.type === "object" &&
+        result.value &&
+        typeof result.value === "object" &&
+        "text" in result.value) {
+        const html = typeof result.value.html === "string"
             ? (result.value.html ?? undefined)
             : undefined;
-        const turnId = typeof result.value.turnId === 'string'
+        const turnId = typeof result.value.turnId === "string"
             ? (result.value.turnId ?? undefined)
             : undefined;
-        const messageId = typeof result.value.messageId === 'string'
+        const messageId = typeof result.value.messageId === "string"
             ? (result.value.messageId ?? undefined)
             : undefined;
-        const text = cleanAssistantText(String(result.value.text ?? ''));
+        const text = cleanAssistantText(String(result.value.text ?? ""));
         const normalized = text.toLowerCase();
         if (isAnswerNowPlaceholderText(normalized)) {
             return null;
         }
         return { text, html, meta: { turnId, messageId } };
     }
-    const fallbackText = typeof result.value === 'string' ? cleanAssistantText(result.value) : '';
+    const fallbackText = typeof result.value === "string" ? cleanAssistantText(result.value) : "";
     if (!fallbackText) {
         return null;
     }
@@ -216,14 +232,14 @@ async function parseAssistantEvaluationResult(_Runtime, evaluation, _logger) {
     }
     return { text: fallbackText, html: undefined, meta: {} };
 }
-async function refreshAssistantSnapshot(Runtime, current, logger, minTurnIndex) {
+async function refreshAssistantSnapshot(Runtime, current, logger, minTurnIndex, expectedConversationId) {
     const deadline = Date.now() + 5_000;
     let best = null;
     let stableCycles = 0;
     const stableTarget = 3;
     while (Date.now() < deadline) {
         // Learned: short/fast answers can race; poll a few extra cycles to pick up messageId + full text.
-        const latestSnapshot = await readAssistantSnapshot(Runtime, minTurnIndex).catch(() => null);
+        const latestSnapshot = await readAssistantSnapshot(Runtime, minTurnIndex, expectedConversationId).catch(() => null);
         const latest = normalizeAssistantSnapshot(latestSnapshot);
         if (latest) {
             if (!best ||
@@ -250,13 +266,13 @@ async function refreshAssistantSnapshot(Runtime, current, logger, minTurnIndex)
     const isLonger = latestLength > currentLength;
     const hasDifferentText = best.text.trim() !== current.text.trim();
     if (isLonger || hasBetterId || hasDifferentText) {
-        logger('Refreshed assistant response via latest snapshot');
+        logger("Refreshed assistant response via latest snapshot");
         return best;
     }
     return null;
 }
 async function terminateRuntimeExecution(Runtime) {
-    if (typeof Runtime.terminateExecution !== 'function') {
+    if (typeof Runtime.terminateExecution !== "function") {
         return;
     }
     try {
@@ -266,7 +282,7 @@ async function terminateRuntimeExecution(Runtime) {
         // ignore termination failures
     }
 }
-async function pollAssistantCompletion(Runtime, timeoutMs, minTurnIndex, abortSignal) {
+async function pollAssistantCompletion(Runtime, timeoutMs, minTurnIndex, expectedConversationId, abortSignal) {
     const watchdogDeadline = Date.now() + timeoutMs;
     let previousLength = 0;
     let stableCycles = 0;
@@ -276,7 +292,7 @@ async function pollAssistantCompletion(Runtime, timeoutMs, minTurnIndex, abortSi
         if (abortSignal?.aborted) {
             return null;
         }
-        const snapshot = await readAssistantSnapshot(Runtime, minTurnIndex);
+        const snapshot = await readAssistantSnapshot(Runtime, minTurnIndex, expectedConversationId);
         const normalized = normalizeAssistantSnapshot(snapshot);
         if (normalized) {
             const currentLength = normalized.text.length;
@@ -377,7 +393,7 @@ async function isCompletionVisible(Runtime) {
     }
 }
 function normalizeAssistantSnapshot(snapshot) {
-    const text = snapshot?.text ? cleanAssistantText(snapshot.text) : '';
+    const text = snapshot?.text ? cleanAssistantText(snapshot.text) : "";
     if (!text.trim()) {
         return null;
     }
@@ -388,7 +404,7 @@ function normalizeAssistantSnapshot(snapshot) {
         return null;
     }
     // Ignore user echo turns that can show up in project view fallbacks.
-    if (normalized.startsWith('you said')) {
+    if (normalized.startsWith("you said")) {
         return null;
     }
     return {
@@ -408,14 +424,27 @@ async function waitForCondition(getter, timeoutMs, pollIntervalMs = 400) {
     }
     return null;
 }
-function buildAssistantSnapshotExpression(minTurnIndex) {
-    const minTurnLiteral = typeof minTurnIndex === 'number' && Number.isFinite(minTurnIndex) && minTurnIndex >= 0
+function buildAssistantSnapshotExpression(minTurnIndex, expectedConversationId) {
+    const minTurnLiteral = typeof minTurnIndex === "number" && Number.isFinite(minTurnIndex) && minTurnIndex >= 0
         ? Math.floor(minTurnIndex)
         : -1;
+    const expectedConversationLiteral = typeof expectedConversationId === "string" && expectedConversationId.trim().length > 0
+        ? JSON.stringify(expectedConversationId.trim())
+        : "null";
     return `(() => {
     const MIN_TURN_INDEX = ${minTurnLiteral};
+    const EXPECTED_CONVERSATION_ID = ${expectedConversationLiteral};
+    const currentHref = typeof location === 'object' && location.href ? location.href : '';
+    const currentConversationId = currentHref.match(/\\/c\\/([a-zA-Z0-9-]+)/)?.[1] ?? null;
+    if (
+      EXPECTED_CONVERSATION_ID &&
+      currentConversationId &&
+      currentConversationId !== EXPECTED_CONVERSATION_ID
+    ) {
+      return null;
+    }
     // Learned: the default turn DOM misses project view; keep a fallback extractor.
-    ${buildAssistantExtractor('extractAssistantTurn')}
+    ${buildAssistantExtractor("extractAssistantTurn")}
     const extracted = extractAssistantTurn();
     const isPlaceholder = (snapshot) => {
       const normalized = String(snapshot?.text ?? '').toLowerCase().trim();
@@ -429,17 +458,20 @@ function buildAssistantSnapshotExpression(minTurnIndex) {
       return extracted;
     }
     // Fallback for ChatGPT project view: answers can live outside conversation turns.
-    const fallback = ${buildMarkdownFallbackExtractor('MIN_TURN_INDEX')};
+    const fallback = ${buildMarkdownFallbackExtractor("MIN_TURN_INDEX")};
     return fallback ?? extracted;
   })()`;
 }
-function buildResponseObserverExpression(timeoutMs, minTurnIndex) {
+function buildResponseObserverExpression(timeoutMs, minTurnIndex, expectedConversationId) {
     const selectorsLiteral = JSON.stringify(ANSWER_SELECTORS);
     const conversationLiteral = JSON.stringify(CONVERSATION_TURN_SELECTOR);
     const assistantLiteral = JSON.stringify(ASSISTANT_ROLE_SELECTOR);
-    const minTurnLiteral = typeof minTurnIndex === 'number' && Number.isFinite(minTurnIndex) && minTurnIndex >= 0
+    const minTurnLiteral = typeof minTurnIndex === "number" && Number.isFinite(minTurnIndex) && minTurnIndex >= 0
         ? Math.floor(minTurnIndex)
         : -1;
+    const expectedConversationLiteral = typeof expectedConversationId === "string" && expectedConversationId.trim().length > 0
+        ? JSON.stringify(expectedConversationId.trim())
+        : "null";
     return `(() => {
     ${buildClickDispatcher()}
     const SELECTORS = ${selectorsLiteral};
@@ -447,8 +479,18 @@ function buildResponseObserverExpression(timeoutMs, minTurnIndex) {
     const FINISHED_SELECTOR = '${FINISHED_ACTIONS_SELECTOR}';
     const CONVERSATION_SELECTOR = ${conversationLiteral};
     const ASSISTANT_SELECTOR = ${assistantLiteral};
+    const EXPECTED_CONVERSATION_ID = ${expectedConversationLiteral};
     // Learned: settling avoids capturing mid-stream HTML; keep short.
     const settleDelayMs = 800;
+    const currentConversationId = () => {
+      const href = typeof location === 'object' && location.href ? location.href : '';
+      return href.match(/\\/c\\/([a-zA-Z0-9-]+)/)?.[1] ?? null;
+    };
+    const matchesExpectedConversation = () => {
+      if (!EXPECTED_CONVERSATION_ID) return true;
+      const currentId = currentConversationId();
+      return !currentId || currentId === EXPECTED_CONVERSATION_ID;
+    };
     const isAnswerNowPlaceholder = (snapshot) => {
       const normalized = String(snapshot?.text ?? '').toLowerCase().trim();
       if (normalized === 'chatgpt said:' || normalized === 'chatgpt said') return true;
@@ -471,12 +513,13 @@ function buildResponseObserverExpression(timeoutMs, minTurnIndex) {
     };
 
     const MIN_TURN_INDEX = ${minTurnLiteral};
-    ${buildAssistantExtractor('extractFromTurns')}
+    ${buildAssistantExtractor("extractFromTurns")}
     // Learned: some layouts (project view) render markdown without assistant turn wrappers.
-    const extractFromMarkdownFallback = ${buildMarkdownFallbackExtractor('MIN_TURN_INDEX')};
+    const extractFromMarkdownFallback = ${buildMarkdownFallbackExtractor("MIN_TURN_INDEX")};
 
     const acceptSnapshot = (snapshot) => {
       if (!snapshot) return null;
+      if (!matchesExpectedConversation()) return null;
       const index = typeof snapshot.turnIndex === 'number' ? snapshot.turnIndex : -1;
       if (MIN_TURN_INDEX >= 0) {
         if (index < 0 || index < MIN_TURN_INDEX) {
@@ -719,7 +762,9 @@ function buildAssistantExtractor(functionName) {
   };`;
 }
 function buildMarkdownFallbackExtractor(minTurnLiteral) {
-    const turnIndexValue = minTurnLiteral ? `(${minTurnLiteral} >= 0 ? ${minTurnLiteral} : null)` : 'null';
+    const turnIndexValue = minTurnLiteral
+        ? `(${minTurnLiteral} >= 0 ? ${minTurnLiteral} : null)`
+        : "null";
     return `(() => {
     const __minTurn = ${turnIndexValue};
     const roots = [
@@ -1025,37 +1070,37 @@ function buildCopyExpression(meta) {
   })()`;
 }
 const LANGUAGE_TAGS = new Set([
-    'copy code',
-    'markdown',
-    'bash',
-    'sh',
-    'shell',
-    'javascript',
-    'typescript',
-    'ts',
-    'js',
-    'yaml',
-    'json',
-    'python',
-    'py',
-    'go',
-    'java',
-    'c',
-    'c++',
-    'cpp',
-    'c#',
-    'php',
-    'ruby',
-    'rust',
-    'swift',
-    'kotlin',
-    'html',
-    'css',
-    'sql',
-    'text',
+    "copy code",
+    "markdown",
+    "bash",
+    "sh",
+    "shell",
+    "javascript",
+    "typescript",
+    "ts",
+    "js",
+    "yaml",
+    "json",
+    "python",
+    "py",
+    "go",
+    "java",
+    "c",
+    "c++",
+    "cpp",
+    "c#",
+    "php",
+    "ruby",
+    "rust",
+    "swift",
+    "kotlin",
+    "html",
+    "css",
+    "sql",
+    "text",
 ].map((token) => token.toLowerCase()));
 function cleanAssistantText(text) {
-    const normalized = text.replace(/\u00a0/g, ' ');
+    const normalized = text.replace(/\u00a0/g, " ");
     const lines = normalized.split(/\r?\n/);
     const filtered = lines.filter((line) => {
         const trimmed = line.trim().toLowerCase();
@@ -1063,5 +1108,8 @@ function cleanAssistantText(text) {
             return false;
         return true;
     });
-    return filtered.join('\n').replace(/\n{3,}/g, '\n\n').trim();
+    return filtered
+        .join("\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
 }

package/dist/src/browser/actions/attachmentDataTransfer.js

@@ -1,12 +1,12 @@
-import { readFile } from 'node:fs/promises';
-import path from 'node:path';
+import { readFile } from "node:fs/promises";
+import path from "node:path";
 const MAX_DATA_TRANSFER_BYTES = 20 * 1024 * 1024;
 export async function transferAttachmentViaDataTransfer(runtime, attachment, selector) {
     const fileContent = await readFile(attachment.path);
     if (fileContent.length > MAX_DATA_TRANSFER_BYTES) {
         throw new Error(`Attachment ${path.basename(attachment.path)} is too large for data transfer (${fileContent.length} bytes). Maximum size is ${MAX_DATA_TRANSFER_BYTES} bytes.`);
     }
-    const base64Content = fileContent.toString('base64');
+    const base64Content = fileContent.toString("base64");
     const fileName = path.basename(attachment.path);
     const mimeType = guessMimeType(fileName);
     const expression = `(() => {
@@ -77,62 +77,64 @@ export async function transferAttachmentViaDataTransfer(runtime, attachment, sel
   })()`;
     const evalResult = await runtime.evaluate({ expression, returnByValue: true });
     if (evalResult.exceptionDetails) {
-        const description = evalResult.exceptionDetails.text ?? 'JS evaluation failed';
+        const description = evalResult.exceptionDetails.text ?? "JS evaluation failed";
         throw new Error(`Failed to transfer file to browser: ${description}`);
     }
-    if (!evalResult.result || typeof evalResult.result.value !== 'object' || evalResult.result.value == null) {
-        throw new Error('Failed to transfer file to browser: unexpected evaluation result');
+    if (!evalResult.result ||
+        typeof evalResult.result.value !== "object" ||
+        evalResult.result.value == null) {
+        throw new Error("Failed to transfer file to browser: unexpected evaluation result");
     }
     const uploadResult = evalResult.result.value;
     if (!uploadResult.success) {
-        throw new Error(`Failed to transfer file to browser: ${uploadResult.error || 'Unknown error'}`);
+        throw new Error(`Failed to transfer file to browser: ${uploadResult.error || "Unknown error"}`);
     }
     return {
         fileName: uploadResult.fileName ?? fileName,
-        size: typeof uploadResult.size === 'number' ? uploadResult.size : fileContent.length,
+        size: typeof uploadResult.size === "number" ? uploadResult.size : fileContent.length,
     };
 }
 export function guessMimeType(fileName) {
     const ext = path.extname(fileName).toLowerCase();
     const mimeTypes = {
-        '.txt': 'text/plain',
-        '.md': 'text/markdown',
-        '.csv': 'text/csv',
-        '.json': 'application/json',
-        '.js': 'text/javascript',
-        '.ts': 'text/typescript',
-        '.jsx': 'text/javascript',
-        '.tsx': 'text/typescript',
-        '.py': 'text/x-python',
-        '.java': 'text/x-java',
-        '.c': 'text/x-c',
-        '.cpp': 'text/x-c++',
-        '.h': 'text/x-c',
-        '.hpp': 'text/x-c++',
-        '.sh': 'text/x-sh',
-        '.bash': 'text/x-sh',
-        '.html': 'text/html',
-        '.css': 'text/css',
-        '.xml': 'text/xml',
-        '.yaml': 'text/yaml',
-        '.yml': 'text/yaml',
-        '.pdf': 'application/pdf',
-        '.doc': 'application/msword',
-        '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-        '.xls': 'application/vnd.ms-excel',
-        '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
-        '.ppt': 'application/vnd.ms-powerpoint',
-        '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
-        '.png': 'image/png',
-        '.jpg': 'image/jpeg',
-        '.jpeg': 'image/jpeg',
-        '.gif': 'image/gif',
-        '.svg': 'image/svg+xml',
-        '.webp': 'image/webp',
-        '.zip': 'application/zip',
-        '.tar': 'application/x-tar',
-        '.gz': 'application/gzip',
-        '.7z': 'application/x-7z-compressed',
+        ".txt": "text/plain",
+        ".md": "text/markdown",
+        ".csv": "text/csv",
+        ".json": "application/json",
+        ".js": "text/javascript",
+        ".ts": "text/typescript",
+        ".jsx": "text/javascript",
+        ".tsx": "text/typescript",
+        ".py": "text/x-python",
+        ".java": "text/x-java",
+        ".c": "text/x-c",
+        ".cpp": "text/x-c++",
+        ".h": "text/x-c",
+        ".hpp": "text/x-c++",
+        ".sh": "text/x-sh",
+        ".bash": "text/x-sh",
+        ".html": "text/html",
+        ".css": "text/css",
+        ".xml": "text/xml",
+        ".yaml": "text/yaml",
+        ".yml": "text/yaml",
+        ".pdf": "application/pdf",
+        ".doc": "application/msword",
+        ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+        ".xls": "application/vnd.ms-excel",
+        ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        ".ppt": "application/vnd.ms-powerpoint",
+        ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+        ".png": "image/png",
+        ".jpg": "image/jpeg",
+        ".jpeg": "image/jpeg",
+        ".gif": "image/gif",
+        ".svg": "image/svg+xml",
+        ".webp": "image/webp",
+        ".zip": "application/zip",
+        ".tar": "application/x-tar",
+        ".gz": "application/gzip",
+        ".7z": "application/x-7z-compressed",
     };
-    return mimeTypes[ext] || 'application/octet-stream';
+    return mimeTypes[ext] || "application/octet-stream";
 }