codex-chatgpt-control 0.5.0-alpha.1 → 0.5.1-alpha.2

package/dist/src/backend/client.d.ts

@@ -6,7 +6,7 @@ import type { ChatGPTResponsesCreateArgs } from "../runner/responses.js";
 import type { ChatGPTRunStream } from "../runner/stream.js";
 import type { ChatGPTAgent, ChatGPTAgentConfig, ChatGPTResponse, ChatGPTRunInput, ChatGPTRunResult } from "../runner/types.js";
 import type { ReportRedactionOptions } from "../safety/report-redaction.js";
-import type { ArtifactDownloadArgs, ArtifactWaitArgs, ApplyConfigurationData, ApplyConfigurationArgs, BootstrapArgs, ChatGPTExperience, CommandResult, ConfigurationInspectionData, CopyResponseArgs, DetectExperienceArgs, DetectExperienceData, DownloadLatestArgs, GetModeArgs, GetModeData, InspectConfigurationArgs, ListArtifactsArgs, MessageStatusArgs, NewThreadArgs, OpenThreadArgs, OpenExperienceData, ReadLatestArgs, ReadWorkLatestArgs, ReadWorkLatestData, SearchThreadsArgs, SelectToolArgs, SequencePlan, SetModeArgs, StartWorkArgs, StartWorkData, SteerWorkArgs, SteerWorkData, WaitArgs, WorkStatusArgs, WorkStatusData, WorkWaitArgs, WorkWaitData } from "../types.js";
+import type { ArtifactDownloadArgs, ArtifactWaitArgs, ApplyConfigurationData, ApplyConfigurationArgs, BootstrapArgs, ChatGPTExperience, CommandResult, ConfigurationInspectionData, CopyResponseArgs, DetectExperienceArgs, DetectExperienceData, DownloadLatestArgs, GetModeArgs, GetModeData, InspectConfigurationArgs, ListArtifactsArgs, MessageStatusArgs, StopGenerationArgs, StopGenerationData, NewThreadArgs, OpenThreadArgs, OpenExperienceData, ReadLatestArgs, ReadWorkLatestArgs, ReadWorkLatestData, SearchThreadsArgs, SelectToolArgs, SequencePlan, SetModeArgs, StartWorkArgs, StartWorkData, SteerWorkArgs, SteerWorkData, WaitArgs, WorkStatusArgs, WorkStatusData, WorkWaitArgs, WorkWaitData } from "../types.js";
 import { type BackendEvent, type BackendRequest, type BackendResponse } from "./protocol.js";
 export type BackendTransport = {
     request(request: BackendRequest): Promise<BackendResponse>;
@@ -108,6 +108,7 @@ export type ChatGPTBackendClient = {
         wait(args?: WaitArgs): Promise<CommandResult<unknown>>;
         readLatest(args?: ReadLatestArgs): Promise<CommandResult<unknown>>;
         status(args?: MessageStatusArgs): Promise<CommandResult<unknown>>;
+        stop(args: StopGenerationArgs): Promise<CommandResult<StopGenerationData>>;
         waitAndRead(args?: WaitArgs & ReadLatestArgs): Promise<CommandResult<unknown>>;
     };
     files: {

package/dist/src/backend/client.js

@@ -95,6 +95,7 @@ export function createChatGPTBackendClient(transport) {
             wait: args => request("messages.wait", args ?? {}),
             readLatest: args => request("messages.readLatest", args ?? {}),
             status: args => request("messages.status", args ?? {}),
+            stop: args => request("messages.stop", args),
             waitAndRead: args => request("messages.waitAndRead", args)
         },
         artifacts: {

package/dist/src/backend/protocol.d.ts

@@ -1,7 +1,7 @@
 export declare const BACKEND_REQUEST_SCHEMA_VERSION: "chatgpt.browser_control.backend_request.v1";
 export declare const BACKEND_RESPONSE_SCHEMA_VERSION: "chatgpt.browser_control.backend_response.v1";
 export declare const BACKEND_EVENT_SCHEMA_VERSION: "chatgpt.browser_control.backend_event.v1";
-export declare const backendCommands: readonly ["backend.version", "backend.health", "backend.capabilities", "runner.run", "runner.plan", "runner.stream", "responses.create", "ask", "askInThread", "askWithFiles", "askAndDownload", "runMessages", "openThread", "readLatest", "copyLatest", "downloadLatest", "runPlan", "doctor", "createReport", "reports.create", "reports.redact", "reports.summarize", "commands", "describe", "help", "session.bootstrap", "experience.detect", "experience.open", "configuration.inspect", "configuration.apply", "work.start", "work.status", "work.wait", "work.steer", "work.readLatest", "threads.new", "threads.search", "threads.open", "messages.compose", "messages.submit", "messages.ask", "messages.wait", "messages.readLatest", "messages.status", "messages.waitAndRead", "artifacts.listLatest", "artifacts.wait", "artifacts.downloadLatest", "files.preflight", "files.attach", "files.downloadLatest", "projects.sources.list", "projects.sources.planAdd", "projects.sources.add", "modes.set", "modes.get", "tools.select", "response.copy"];
+export declare const backendCommands: readonly ["backend.version", "backend.health", "backend.capabilities", "runner.run", "runner.plan", "runner.stream", "responses.create", "ask", "askInThread", "askWithFiles", "askAndDownload", "runMessages", "openThread", "readLatest", "copyLatest", "downloadLatest", "runPlan", "doctor", "createReport", "reports.create", "reports.redact", "reports.summarize", "commands", "describe", "help", "session.bootstrap", "experience.detect", "experience.open", "configuration.inspect", "configuration.apply", "work.start", "work.status", "work.wait", "work.steer", "work.readLatest", "threads.new", "threads.search", "threads.open", "messages.compose", "messages.submit", "messages.ask", "messages.wait", "messages.readLatest", "messages.status", "messages.stop", "messages.waitAndRead", "artifacts.listLatest", "artifacts.wait", "artifacts.downloadLatest", "files.preflight", "files.attach", "files.downloadLatest", "projects.sources.list", "projects.sources.planAdd", "projects.sources.add", "modes.set", "modes.get", "tools.select", "response.copy"];
 export type BackendCommand = typeof backendCommands[number];
 export type BackendRequest = {
     schemaVersion: typeof BACKEND_REQUEST_SCHEMA_VERSION;

package/dist/src/backend/protocol.js

@@ -46,6 +46,7 @@ export const backendCommands = [
     "messages.wait",
     "messages.readLatest",
     "messages.status",
+    "messages.stop",
     "messages.waitAndRead",
     "artifacts.listLatest",
     "artifacts.wait",

package/dist/src/backend/session.js

@@ -159,6 +159,8 @@ async function dispatchBackendCommand(client, request) {
             return client.messages.readLatest(emptyToUndefined(payload));
         case "messages.status":
             return client.messages.status(emptyToUndefined(payload));
+        case "messages.stop":
+            return client.messages.stop(payload);
         case "messages.waitAndRead":
             return client.messages.waitAndRead(payload);
         case "artifacts.listLatest":

package/dist/src/browser/attach.d.ts

@@ -6,4 +6,5 @@ export type AttachedBrowser = {
     tabId?: string;
 };
 export declare function attachChatGPTBrowser(env: RuntimeEnv, args?: BootstrapArgs): Promise<AttachedBrowser>;
+export { isChatGPTUrl } from "./chatgpt-url.js";
 export declare function tabIdFromPage(page: PageLike): string | undefined;

package/dist/src/browser/attach.js

@@ -1,13 +1,15 @@
 import { BrowserBridgeUnavailableError, ChatGPTControlError, LoginRequiredError } from "../errors.js";
+import { CHATGPT_HOME, isChatGPTUrl } from "./chatgpt-url.js";
 import { parseConversationId, readPageState } from "./page-state.js";
-const CHATGPT_HOME = "https://chatgpt.com/";
-const CHATGPT_HOSTS = new Set(["chatgpt.com", "www.chatgpt.com", "chat.openai.com"]);
 const MAX_EXISTING_TAB_DIAGNOSTIC_CANDIDATES = 10;
 const MAX_EXISTING_TAB_DIAGNOSTIC_FIELD_LENGTH = 240;
 export async function attachChatGPTBrowser(env, args = {}) {
     const browser = await getBrowser(env);
     const page = await getOrCreateChatGPTPage(browser, env, args);
+    await assertPageOnChatGPTOrigin(page);
     const state = await readPageState(page);
+    if (!isChatGPTUrl(state.url))
+        throw unsafeChatGPTOriginError();
     if (state.blocker?.kind === "login_required") {
         throw new LoginRequiredError(state.blocker.visibleText);
     }
@@ -95,6 +97,7 @@ async function tryBrowserGetPreferredListed(browsers) {
 }
 async function getOrCreateChatGPTPage(browser, env, args) {
     const targetUrl = args.url ?? CHATGPT_HOME;
+    assertSafeChatGPTNavigation(targetUrl);
     const explicitExistingPolicy = normalizeExplicitExistingTabPolicy(args);
     if (env.page !== undefined) {
         const cached = normalizePage(env.page);
@@ -149,7 +152,7 @@ function normalizeExplicitExistingTabPolicy(args) {
     if (args.existingTab === true) {
         return {
             target: { type: "selected", host: "chatgpt" },
-            ifMissing: "create",
+            ifMissing: "block",
             ifMultiple: "first",
             requireChatGPT: true
         };
@@ -187,6 +190,21 @@ async function selectExistingTab(browser, policy) {
             }
         }
     }
+    if (typeof browser.tabs?.list === "function") {
+        const controlled = await Promise.resolve(browser.tabs.list.call(browser.tabs)).catch(() => []);
+        const matches = [];
+        for (const candidate of controlled) {
+            const page = await hydrateTab(browser, candidate);
+            if (await pageMatchesExistingTarget(page, policy))
+                matches.push(page);
+        }
+        if (matches.length === 1 || (matches.length > 1 && (policy.ifMultiple ?? "block") === "first")) {
+            return { page: matches[0] };
+        }
+        if (matches.length > 1) {
+            throw new ExistingTabSelectionError("Multiple already-controlled ChatGPT tabs matched the requested existing-tab target.", "existing_tab_ambiguous");
+        }
+    }
     return userMatch.diagnostics === undefined
         ? { diagnostics: diagnosticsForUnavailableUserTabs(policy) }
         : userMatch;
@@ -213,6 +231,7 @@ async function selectExistingUserTab(browser, policy, collectDiagnostics) {
     }
     const selected = matches[0];
     const page = normalizePage(await claimTab.call(browser.user, selected));
+    await assertPageOnChatGPTOrigin(page);
     return diagnostics === undefined ? { page } : { page, diagnostics };
 }
 function userTabMatchesTarget(tab, policy) {
@@ -340,14 +359,10 @@ async function pageMatchesExistingTarget(page, policy) {
     return userTabMatchesTarget(tab, policy);
 }
 async function findExistingChatGPTTab(browser) {
-    const userTab = await selectExistingUserTab(browser, {
-        target: { type: "selected", host: "chatgpt" },
-        ifMultiple: "first",
-        requireChatGPT: true
-    }, false).catch(() => ({ page: undefined }));
-    if (userTab.page !== undefined) {
-        return userTab.page;
-    }
+    // Reuse a tab already controlled by this browser session before attempting
+    // to claim an external user tab. Claiming a tab that is still associated
+    // with an interrupted host call can otherwise wait on a stale control lock
+    // until the next bounded browser call is killed.
     const selected = browser.tabs?.selected;
     if (typeof selected === "function") {
         try {
@@ -355,7 +370,7 @@ async function findExistingChatGPTTab(browser) {
             if (current !== undefined) {
                 const normalized = normalizePage(current);
                 try {
-                    if ((await normalized.url?.())?.includes("chatgpt.com") === true) {
+                    if (isChatGPTUrl(await normalized.url?.())) {
                         return normalized;
                     }
                 }
@@ -369,20 +384,33 @@ async function findExistingChatGPTTab(browser) {
         }
     }
     const list = browser.tabs?.list;
-    if (typeof list !== "function") {
-        return undefined;
-    }
-    const tabs = await list.call(browser.tabs);
-    const normalized = await Promise.all(tabs.map(tab => hydrateTab(browser, tab)));
-    for (const tab of normalized) {
-        try {
-            if ((await tab.url?.())?.includes("chatgpt.com") === true) {
-                return tab;
+    if (typeof list === "function") {
+        const tabs = await list.call(browser.tabs);
+        const normalized = await Promise.all(tabs.map(tab => hydrateTab(browser, tab)));
+        for (const tab of normalized) {
+            try {
+                if (isChatGPTUrl(await tab.url?.())) {
+                    return tab;
+                }
+            }
+            catch {
+                // Keep looking.
             }
         }
-        catch {
-            // Keep looking.
+    }
+    const userTab = await selectExistingUserTab(browser, {
+        target: { type: "selected", host: "chatgpt" },
+        ifMultiple: "first",
+        requireChatGPT: true
+    }, false).catch(error => {
+        if (error instanceof ChatGPTControlError
+            && error.blockerDetails.code === "unsafe_chatgpt_origin") {
+            throw error;
         }
+        return { page: undefined };
+    });
+    if (userTab.page !== undefined) {
+        return userTab.page;
     }
     return undefined;
 }
@@ -422,17 +450,7 @@ function targetRequiresChatGPT(target) {
             return true;
     }
 }
-function isChatGPTUrl(url) {
-    if (url === undefined) {
-        return false;
-    }
-    try {
-        return CHATGPT_HOSTS.has(new URL(url).hostname);
-    }
-    catch {
-        return false;
-    }
-}
+export { isChatGPTUrl } from "./chatgpt-url.js";
 function urlMatches(actual, expected) {
     if (actual === undefined) {
         return false;
@@ -485,6 +503,7 @@ function userTabCandidateLabel(tab) {
     return `tab ${tab.id} - ${tab.title ?? "Untitled"} - ${tab.url ?? "unknown URL"}`;
 }
 async function createTab(browser, url) {
+    assertSafeChatGPTNavigation(url);
     if (typeof browser.tabs?.create === "function") {
         const tab = await browser.tabs.create(url);
         const page = await hydrateTab(browser, tab);
@@ -502,18 +521,33 @@ async function createTab(browser, url) {
         if (typeof page.goto === "function") {
             await page.goto(url);
         }
+        await assertPageOnChatGPTOrigin(page);
         return page;
     }
     return undefined;
 }
+function assertSafeChatGPTNavigation(url) {
+    if (isChatGPTUrl(url))
+        return;
+    throw unsafeChatGPTOriginError("ChatGPT navigation requires HTTPS on an allowlisted ChatGPT origin with the default port.");
+}
 async function ensurePageAt(page, url) {
     const currentUrl = await Promise.resolve(page.url?.()).catch(() => "");
-    if (currentUrl?.includes("chatgpt.com") === true) {
+    if (isChatGPTUrl(currentUrl)) {
         return;
     }
     if (typeof page.goto === "function") {
         await page.goto(url);
     }
+    await assertPageOnChatGPTOrigin(page);
+}
+async function assertPageOnChatGPTOrigin(page) {
+    const actualUrl = await Promise.resolve(page.url?.()).catch(() => undefined);
+    if (!isChatGPTUrl(actualUrl))
+        throw unsafeChatGPTOriginError();
+}
+function unsafeChatGPTOriginError(message = "The browser did not remain on a supported ChatGPT origin after navigation or attachment.") {
+    return new ChatGPTControlError(message, "selector_drift", false, undefined, { code: "unsafe_chatgpt_origin" });
 }
 function normalizeBrowser(browser) {
     if (browser === undefined || browser === null || typeof browser !== "object") {

package/dist/src/browser/chatgpt-url.d.ts

@@ -0,0 +1,8 @@
+export declare const CHATGPT_HOME = "https://chatgpt.com/";
+/**
+ * Accept only the visible ChatGPT HTTPS origins supported by this SDK.
+ * URL credentials and non-default ports are rejected even when the hostname
+ * itself is allowlisted.
+ */
+export declare function isChatGPTUrl(value: string | undefined): boolean;
+export declare function requireChatGPTUrl(value: string, label: string): string;

package/dist/src/browser/chatgpt-url.js

@@ -0,0 +1,28 @@
+export const CHATGPT_HOME = "https://chatgpt.com/";
+const CHATGPT_HOSTS = new Set(["chatgpt.com", "www.chatgpt.com", "chat.openai.com"]);
+/**
+ * Accept only the visible ChatGPT HTTPS origins supported by this SDK.
+ * URL credentials and non-default ports are rejected even when the hostname
+ * itself is allowlisted.
+ */
+export function isChatGPTUrl(value) {
+    if (value === undefined)
+        return false;
+    try {
+        const url = new URL(value);
+        return url.protocol === "https:"
+            && url.port === ""
+            && url.username === ""
+            && url.password === ""
+            && CHATGPT_HOSTS.has(url.hostname);
+    }
+    catch {
+        return false;
+    }
+}
+export function requireChatGPTUrl(value, label) {
+    if (!isChatGPTUrl(value)) {
+        throw new Error(`${label} must use HTTPS on an allowlisted ChatGPT origin with the default port.`);
+    }
+    return value;
+}

package/dist/src/browser/downloads.d.ts

@@ -4,4 +4,4 @@ export type DownloadLike = {
     saveAs?: (path: string) => Promise<void>;
     path?: () => Promise<string | null>;
 };
-export declare function waitForDownloadFromClick(page: PageLike, click: () => Promise<void>, destDir: string, timeoutMs: number): Promise<DownloadedFile>;
+export declare function waitForDownloadFromClick(page: PageLike, click: () => Promise<void>, destDir: string, timeoutMs: number, filenameHint?: string): Promise<DownloadedFile>;

package/dist/src/browser/downloads.js

@@ -1,7 +1,7 @@
-import { mkdir, stat } from "node:fs/promises";
+import { copyFile, mkdir, stat } from "node:fs/promises";
 import { basename, join, resolve } from "node:path";
 import { localGuardTimeout, withTimeout } from "../commands/timeouts.js";
-export async function waitForDownloadFromClick(page, click, destDir, timeoutMs) {
+export async function waitForDownloadFromClick(page, click, destDir, timeoutMs, filenameHint) {
     const absoluteDest = resolve(destDir);
     await mkdir(absoluteDest, { recursive: true });
     const downloadPromise = page.waitForEvent?.("download", { timeout: timeoutMs, timeoutMs });
@@ -10,13 +10,22 @@ export async function waitForDownloadFromClick(page, click, destDir, timeoutMs)
     }
     await withTimeout(click(), localGuardTimeout(timeoutMs, 10000), "Download control click did not complete before the local guard timeout.");
     const download = await downloadPromise;
-    const suggestedFilename = download.suggestedFilename?.() ?? `chatgpt-download-${Date.now()}`;
+    const sourcePath = typeof download.path === "function" ? await download.path() : null;
+    const suggestedFilename = filenameHint
+        ?? download.suggestedFilename?.()
+        ?? (sourcePath === null ? undefined : basename(sourcePath))
+        ?? `chatgpt-download-${Date.now()}`;
     const targetPath = join(absoluteDest, basename(suggestedFilename));
     if (typeof download.saveAs === "function") {
         await download.saveAs(targetPath);
     }
+    else if (sourcePath !== null) {
+        if (resolve(sourcePath) !== resolve(targetPath)) {
+            await copyFile(sourcePath, targetPath);
+        }
+    }
     else {
-        throw new Error("The browser download object does not expose saveAs().");
+        throw new Error("The browser download object exposes neither saveAs() nor a completed local path().");
     }
     const saved = await stat(targetPath);
     if (saved.size <= 0) {

package/dist/src/browser/page-state.js

@@ -21,9 +21,15 @@ export async function readPageState(page) {
     const url = typeof rawUrl === "string" ? rawUrl : "";
     const rawTitle = typeof page.title === "function" ? await page.title().catch(() => undefined) : undefined;
     const title = typeof rawTitle === "string" ? rawTitle : undefined;
-    const visibleText = await readVisibleText(page);
-    const signedIn = isLikelySignedIn(visibleText);
-    const classifiedBlocker = classifyVisibleText(visibleText);
+    const surface = await readPageSurfaceSnapshot(page);
+    const visibleText = surface.visibleText;
+    const blockerSurface = surface.blockerSurface;
+    const fullPageBlocker = classifyVisibleText(visibleText);
+    const classifiedBlocker = blockerSurface.hasConversationMessages
+        ? classifyVisibleText(blockerSurface.text)
+        : (classifyVisibleText(blockerSurface.text) ?? fullPageBlocker);
+    const loginWall = classifiedBlocker?.kind === "login_required" && isLikelyLoginWall(visibleText);
+    const signedIn = isLikelySignedIn(visibleText) && !loginWall;
     const blocker = classifiedBlocker?.kind === "login_required" && signedIn
         ? undefined
         : classifiedBlocker;
@@ -64,8 +70,193 @@ export async function readVisibleText(page) {
     }
     return "";
 }
+async function readPageSurfaceSnapshot(page) {
+    if (typeof page.evaluate === "function") {
+        try {
+            const snapshot = await withTimeout(page.evaluate(() => {
+                const messageSelector = "[data-message-author-role], [data-testid^='conversation-turn']";
+                const systemSelector = [
+                    "[role='alert']",
+                    "[role='status']",
+                    "[role='dialog']",
+                    "[aria-live='assertive']",
+                    "[data-testid*='toast' i]",
+                    "[data-testid*='banner' i]",
+                    "[class*='toast' i]",
+                    "[class*='banner' i]"
+                ].join(", ");
+                const visible = (element) => {
+                    if (element.hidden || element.closest("[hidden], [inert], [aria-hidden='true']") !== null)
+                        return false;
+                    const style = window.getComputedStyle(element);
+                    if (style.display === "none"
+                        || style.visibility === "hidden"
+                        || style.opacity === "0"
+                        || style.pointerEvents === "none")
+                        return false;
+                    const rect = element.getBoundingClientRect();
+                    return rect.width > 0 || rect.height > 0;
+                };
+                const blockerText = Array.from(document.querySelectorAll(systemSelector))
+                    .filter((element) => visible(element))
+                    .filter(element => element.closest(messageSelector) === null)
+                    .map(element => `${element.textContent ?? ""} ${element.getAttribute("aria-label") ?? ""}`)
+                    .join(" ");
+                return {
+                    visibleText: document.body?.innerText ?? "",
+                    blockerText,
+                    hasConversationMessages: Array.from(document.querySelectorAll(messageSelector)).some(visible)
+                };
+            }), 1000, "Timed out while reading the visible ChatGPT page surface.");
+            if (typeof snapshot === "string") {
+                return {
+                    visibleText: snapshot,
+                    blockerSurface: { text: snapshot, hasConversationMessages: false }
+                };
+            }
+            if (typeof snapshot === "object" && snapshot !== null
+                && typeof snapshot.visibleText === "string"
+                && typeof snapshot.blockerText === "string"
+                && typeof snapshot.hasConversationMessages === "boolean") {
+                const typed = snapshot;
+                return {
+                    visibleText: typed.visibleText,
+                    blockerSurface: {
+                        text: typed.blockerText,
+                        hasConversationMessages: typed.hasConversationMessages
+                    }
+                };
+            }
+        }
+        catch {
+            // Fall through to one serialized snapshot below.
+        }
+    }
+    if (typeof page.content === "function") {
+        try {
+            const html = await withTimeout(page.content(), 1000, "Timed out while reading the serialized ChatGPT page surface.");
+            return serializedPageSurface(html);
+        }
+        catch {
+            // Return an empty fail-closed snapshot below.
+        }
+    }
+    return {
+        visibleText: "",
+        blockerSurface: { text: "", hasConversationMessages: false }
+    };
+}
+function serializedPageSurface(html) {
+    const stack = [];
+    const blockerNodes = [];
+    const voidElements = new Set([
+        "area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source", "track", "wbr"
+    ]);
+    let hasConversationMessages = false;
+    let visibleText = "";
+    const hidden = (attributes) => /(?:^|\s)(?:hidden|inert)(?:\s|=|$)/i.test(attributes)
+        || /\baria-hidden\s*=\s*["']?true/i.test(attributes)
+        || /\bstyle\s*=\s*["'][^"']*(?:display\s*:\s*none|visibility\s*:\s*hidden|opacity\s*:\s*0|pointer-events\s*:\s*none)/i.test(attributes);
+    const hiddenInChain = (node) => {
+        for (let current = node; current !== undefined; current = current.parent) {
+            if (hidden(current.attributes))
+                return true;
+        }
+        return false;
+    };
+    const messageNode = (node) => {
+        const authorRole = serializedAttribute(node.attributes, "data-message-author-role");
+        const testId = serializedAttribute(node.attributes, "data-testid");
+        return (authorRole !== undefined && authorRole.length > 0)
+            || testId?.toLowerCase().startsWith("conversation-turn") === true;
+    };
+    const insideMessage = (node) => {
+        for (let current = node; current !== undefined; current = current.parent) {
+            if (messageNode(current))
+                return true;
+        }
+        return false;
+    };
+    const systemSurface = (node) => {
+        const role = serializedAttribute(node.attributes, "role")?.toLowerCase();
+        const ariaLive = serializedAttribute(node.attributes, "aria-live")?.toLowerCase();
+        const testId = serializedAttribute(node.attributes, "data-testid")?.toLowerCase() ?? "";
+        const className = serializedAttribute(node.attributes, "class")?.toLowerCase() ?? "";
+        return role === "alert"
+            || role === "status"
+            || role === "dialog"
+            || ariaLive === "assertive"
+            || testId.includes("toast")
+            || testId.includes("banner")
+            || className.includes("toast")
+            || className.includes("banner");
+    };
+    const ignoredInChain = (node) => {
+        for (let current = node; current !== undefined; current = current.parent) {
+            if (current.tag === "script" || current.tag === "style" || current.tag === "template")
+                return true;
+        }
+        return false;
+    };
+    for (const match of html.matchAll(/<!--[\s\S]*?-->|<![^>]*>|<\/?[a-z0-9-]+\b[^>]*>|[^<]+/gi)) {
+        const token = match[0];
+        const closing = /^<\/([a-z0-9-]+)/i.exec(token);
+        if (closing?.[1] !== undefined) {
+            const tag = closing[1].toLowerCase();
+            const index = stack.map(node => node.tag).lastIndexOf(tag);
+            if (index >= 0)
+                stack.splice(index);
+            continue;
+        }
+        const opening = /^<([a-z0-9-]+)\b([^>]*)>/i.exec(token);
+        if (opening?.[1] !== undefined) {
+            const node = {
+                tag: opening[1].toLowerCase(),
+                attributes: opening[2] ?? "",
+                parent: stack.at(-1),
+                blockerText: ""
+            };
+            const ignored = ignoredInChain(node);
+            if (messageNode(node) && !hiddenInChain(node) && !ignored)
+                hasConversationMessages = true;
+            if (systemSurface(node) && !hiddenInChain(node) && !insideMessage(node) && !ignored) {
+                const ariaLabel = serializedAttribute(node.attributes, "aria-label");
+                if (ariaLabel !== undefined)
+                    node.blockerText = ` ${ariaLabel}`;
+                blockerNodes.push(node);
+            }
+            if (!voidElements.has(node.tag) && !/\/\s*>$/.test(token))
+                stack.push(node);
+            continue;
+        }
+        const currentNode = stack.at(-1);
+        if (!hiddenInChain(currentNode) && !ignoredInChain(currentNode)) {
+            visibleText += ` ${token}`;
+            for (const node of blockerNodes) {
+                for (let current = currentNode; current !== undefined; current = current.parent) {
+                    if (current === node) {
+                        node.blockerText += ` ${token}`;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    return {
+        visibleText: htmlToText(visibleText),
+        blockerSurface: {
+            text: blockerNodes.map(node => htmlToText(node.blockerText)).filter(Boolean).join(" "),
+            hasConversationMessages
+        }
+    };
+}
+function serializedAttribute(attributes, name) {
+    const escapedName = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const match = new RegExp(`\\b${escapedName}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s"'=<>` + "`" + `]+))`, "i").exec(attributes);
+    return match?.[1] ?? match?.[2] ?? match?.[3];
+}
 export function htmlToText(html) {
-    return html
+    return stripHiddenMarkup(html)
         .replace(/<script[\s\S]*?<\/script>/gi, " ")
         .replace(/<style[\s\S]*?<\/style>/gi, " ")
         .replace(/<[^>]+>/g, " ")
@@ -76,7 +267,23 @@ export function htmlToText(html) {
         .replace(/\s+/g, " ")
         .trim();
 }
+function stripHiddenMarkup(html) {
+    let visible = html;
+    const hiddenElement = /<([a-z0-9-]+)\b[^>]*(?:\bhidden\b|\binert\b|\baria-hidden\s*=\s*["']?true|\bstyle\s*=\s*["'][^"']*(?:display\s*:\s*none|visibility\s*:\s*hidden|opacity\s*:\s*0))[^>]*>[\s\S]*?<\/\1>/gi;
+    for (let pass = 0; pass < 4; pass += 1) {
+        const next = visible.replace(hiddenElement, " ");
+        if (next === visible)
+            break;
+        visible = next;
+    }
+    return visible;
+}
 function isLikelySignedIn(visibleText) {
     const markers = localeLabels.signedInMarkers.map(escapeRegExp).join("|");
     return new RegExp(`\\b(${markers})\\b`, "i").test(visibleText);
 }
+function isLikelyLoginWall(visibleText) {
+    const labels = localeLabels.loginBlocker.map(escapeRegExp).join("|");
+    const matches = visibleText.match(new RegExp(`(?:${labels})`, "gi")) ?? [];
+    return matches.length >= 2 || /\bsign\s?up\b|\bcreate (?:an )?account\b/i.test(visibleText);
+}

package/dist/src/client.d.ts

@@ -1,4 +1,4 @@
-import type { AskArgs, ArtifactDownloadArgs, ArtifactWaitArgs, ApplyConfigurationData, ApplyConfigurationArgs, AttachFilesArgs, BootstrapArgs, ChatGPTExperience, CommandResult, ConfigurationInspectionData, ConfigurationSelection, CopyResponseArgs, DetectExperienceArgs, DetectExperienceData, DownloadLatestArgs, FilePreflightArgs, FilePreflightData, GetModeArgs, GetModeData, InspectConfigurationArgs, ListArtifactsArgs, MessageStatusArgs, NewThreadArgs, OpenThreadArgs, OpenExperienceData, ProjectSourcesAddArgs, ProjectSourcesAddData, ProjectSourcesAddPlanData, ProjectSourcesListArgs, ProjectSourcesListData, ProjectSourcesPlanAddArgs, ReadLatestArgs, RuntimeEnv, ReadWorkLatestArgs, ReadWorkLatestData, SearchThreadsArgs, SelectToolArgs, SequencePlan, SetModeArgs, StartWorkArgs, StartWorkData, SteerWorkArgs, SteerWorkData, ThreadTarget, WaitArgs, WorkStatusArgs, WorkStatusData, WorkWaitArgs, WorkWaitData } from "./types.js";
+import type { AskArgs, ArtifactDownloadArgs, ArtifactWaitArgs, ApplyConfigurationData, ApplyConfigurationArgs, AttachFilesArgs, BootstrapArgs, ChatGPTExperience, CommandResult, ConfigurationInspectionData, ConfigurationSelection, CopyResponseArgs, DetectExperienceArgs, DetectExperienceData, DownloadLatestArgs, FilePreflightArgs, FilePreflightData, GetModeArgs, GetModeData, InspectConfigurationArgs, ListArtifactsArgs, MessageStatusArgs, StopGenerationArgs, StopGenerationData, NewThreadArgs, OpenThreadArgs, OpenExperienceData, ProjectSourcesAddArgs, ProjectSourcesAddData, ProjectSourcesAddPlanData, ProjectSourcesListArgs, ProjectSourcesListData, ProjectSourcesPlanAddArgs, ReadLatestArgs, RuntimeEnv, ReadWorkLatestArgs, ReadWorkLatestData, SearchThreadsArgs, SelectToolArgs, SequencePlan, SetModeArgs, StartWorkArgs, StartWorkData, SteerWorkArgs, SteerWorkData, ThreadTarget, WaitArgs, WorkStatusArgs, WorkStatusData, WorkWaitArgs, WorkWaitData } from "./types.js";
 import { type DoctorArgs, type DoctorReport } from "./commands/doctor.js";
 import { type RunReportData, type RunReportOptions } from "./commands/reports.js";
 import { type CommandDescriptor } from "./commands/registry.js";
@@ -185,6 +185,7 @@ export type ChatGPTClient = {
         wait(args?: WaitArgs): Promise<CommandResult<unknown>>;
         readLatest(args?: ReadLatestArgs): Promise<CommandResult<unknown>>;
         status(args?: MessageStatusArgs): Promise<CommandResult<unknown>>;
+        stop(args: StopGenerationArgs): Promise<CommandResult<StopGenerationData>>;
         waitAndRead(args?: WaitArgs & ReadLatestArgs): Promise<CommandResult<unknown>>;
     };
     files: {

package/dist/src/client.js

@@ -2,7 +2,7 @@ import { downloadLatestArtifact, listLatestArtifacts, waitForArtifact } from "./
 import { attachFiles, downloadLatestFile, preflightFiles } from "./commands/files.js";
 import { addProjectSources, buildProjectSourceAddPlan, listProjectSources } from "./commands/project-sources.js";
 import { doctor } from "./commands/doctor.js";
-import { askMessage, composeMessage, messageStatus, readLatest, submitMessage, waitAndRead, waitForMessage } from "./commands/messages.js";
+import { askMessage, composeMessage, messageStatus, readLatest, stopGeneration, submitMessage, waitAndRead, waitForMessage } from "./commands/messages.js";
 import { getMode, selectTool, setMode } from "./commands/modes.js";
 import { applyConfiguration, inspectConfiguration } from "./commands/configuration.js";
 import { detectExperience, openExperience } from "./commands/experience.js";
@@ -95,6 +95,7 @@ export function createChatGPT(options = {}) {
             wait: args => waitForMessage(env, args),
             readLatest: args => readLatest(env, args),
             status: args => messageStatus(env, args),
+            stop: args => stopGeneration(env, args),
             waitAndRead: args => waitAndRead(env, args)
         },
         files: {