wtagent 0.3.0 → 1.0.0

package/src/browser/cdp-browser.js

@@ -59,6 +59,12 @@ class CdpTimeoutError extends Error {
   }
 }
 
+function recoveryTargetUnavailable(message, cause = null) {
+  const error = new Error(message, cause ? { cause } : undefined);
+  error.code = "RECOVERY_TARGET_UNAVAILABLE";
+  return error;
+}
+
 async function withTimeout(promise, timeoutMs, message) {
   let timer;
   try {
@@ -192,12 +198,49 @@ function sameOriginPath(left, right) {
   }
 }
 
+async function getPageTargetId(context, page, { timeoutMs = 1_500 } = {}) {
+  if (!page || typeof context?.newCDPSession !== "function") {
+    return null;
+  }
+  let session = null;
+  const probe = (async () => {
+    session = await context.newCDPSession(page).catch(() => null);
+    if (!session) {
+      return null;
+    }
+    try {
+      const { targetInfo } = await session.send("Target.getTargetInfo");
+      return targetInfo?.targetId ?? null;
+    } catch {
+      return null;
+    } finally {
+      await settleWithin(
+        Promise.resolve().then(() => session.detach()),
+        500,
+      );
+    }
+  })();
+  try {
+    return await withTimeout(
+      probe,
+      timeoutMs,
+      `Timed out reading the Chrome target identity after ${timeoutMs}ms.`,
+    );
+  } catch {
+    // A target that cannot prove its identity is never eligible for selection.
+    // The still-running probe owns eventual session cleanup through its finally.
+    return null;
+  }
+}
+
 export async function launchAndConnectCdpChrome({
   executablePath,
   profileDir,
   url = "about:blank",
   minimized = false,
   preferredUrl = null,
+  preferredTargetId = null,
+  exactTargetOnly = false,
 }, {
   acquireProfileLock = acquireCdpProfileLock,
   connectOverCDP = (endpoint) => chromium.connectOverCDP(endpoint),
@@ -214,7 +257,19 @@ export async function launchAndConnectCdpChrome({
   waitForExit = waitForProcessExit,
   waitForReady = waitForCdp,
   connectTimeoutMs = 20_000,
+  transportCloseTimeoutMs = 1_500,
 } = {}) {
+  if (
+    exactTargetOnly
+    && (
+      typeof preferredTargetId !== "string"
+      || preferredTargetId.trim().length === 0
+    )
+  ) {
+    throw recoveryTargetUnavailable(
+      "Exact-target recovery requires a saved Chrome target ID.",
+    );
+  }
   const releaseProfileLock = await acquireProfileLock(profileDir);
   let child = null;
   let state = null;
@@ -227,9 +282,23 @@ export async function launchAndConnectCdpChrome({
   }
 
   try {
-    state = await findReusable();
+    try {
+      state = await findReusable();
+    } catch (error) {
+      if (exactTargetOnly) {
+        throw recoveryTargetUnavailable(
+          "The saved Chrome instance could not be inspected for recovery.",
+          error,
+        );
+      }
+      throw error;
+    }
     if (state) {
       reused = true;
+    } else if (exactTargetOnly) {
+      throw recoveryTargetUnavailable(
+        "The saved Chrome instance is not available for exact-target recovery.",
+      );
     } else {
       await removeState(profileDir);
       // A prior instance may have died leaving renderer children (and Chrome's
@@ -294,14 +363,28 @@ export async function launchAndConnectCdpChrome({
     // without this guard Playwright hangs ~30s and leaves a dirty CDP state.
     let context;
     try {
-      if (reused) {
+      if (reused && !exactTargetOnly) {
         await ensurePageTarget(state.endpoint);
       }
-      browser = await withTimeout(
-        connectOverCDP(state.endpoint),
-        connectTimeoutMs,
-        `Timed out connecting to Chrome CDP at ${state.endpoint} after ${connectTimeoutMs}ms.`,
-      );
+      const connectPromise = Promise.resolve().then(() => (
+        connectOverCDP(state.endpoint)
+      ));
+      try {
+        browser = await withTimeout(
+          connectPromise,
+          connectTimeoutMs,
+          `Timed out connecting to Chrome CDP at ${state.endpoint} after ${connectTimeoutMs}ms.`,
+        );
+      } catch (error) {
+        if (error instanceof CdpTimeoutError) {
+          // connectOverCDP is not cancellable. If it completes after our timeout,
+          // disconnect that late transport instead of leaking ownership of Chrome.
+          void connectPromise.then((lateBrowser) => (
+            settleWithin(lateBrowser?.close?.(), transportCloseTimeoutMs)
+          )).catch(() => null);
+        }
+        throw error;
+      }
       // contexts() forces a real protocol round-trip, so it hangs too when the
       // browser main thread is stuck — keep it inside the timeout budget.
       const contexts = await withTimeout(
@@ -311,11 +394,25 @@ export async function launchAndConnectCdpChrome({
       );
       context = contexts[0];
     } catch (error) {
+      if (exactTargetOnly) {
+        await settleWithin(
+          Promise.resolve().then(() => browser?.close()),
+          transportCloseTimeoutMs,
+        );
+        browser = null;
+        throw recoveryTargetUnavailable(
+          "The saved Chrome instance could not be attached for exact-target recovery.",
+          error,
+        );
+      }
       if (error instanceof CdpTimeoutError) {
         // The verified-but-unusable instance we launched is a dead end. Kill it
         // (only if we own it) and drop its CDP state so the next run starts
         // clean instead of trying to reuse a hung endpoint.
-        await browser?.close().catch(() => null);
+        await settleWithin(
+          Promise.resolve().then(() => browser?.close()),
+          transportCloseTimeoutMs,
+        );
         if (!reused && child?.pid) {
           await killTree(child.pid).catch(() => null);
         }
@@ -328,25 +425,85 @@ export async function launchAndConnectCdpChrome({
       throw error;
     }
     if (!context) {
-      throw new Error("Chrome CDP connection did not expose a browser context.");
+      throw exactTargetOnly
+        ? recoveryTargetUnavailable(
+          "The saved Chrome instance has no reusable browser context.",
+        )
+        : new Error("Chrome CDP connection did not expose a browser context.");
     }
 
     // A reused browser may still contain the previous conversation. Keep it
     // intact and, when a preferred URL is given, reuse an existing tab already
     // showing that conversation (origin + path) so resumed runs do not pile up
     // tabs; otherwise create a fresh target for this CLI session.
+    const targetProbeDeadline = Date.now() + connectTimeoutMs;
+    const probeTargetId = async (candidate) => {
+      const remaining = targetProbeDeadline - Date.now();
+      if (remaining <= 0) {
+        return null;
+      }
+      return await getPageTargetId(context, candidate, {
+        timeoutMs: Math.min(1_500, remaining),
+      });
+    };
+    const pages = context.pages();
+    const existingPageUrls = pages.map((candidate) => (
+      candidate.url?.() ?? ""
+    ));
     let page;
-    if (reused) {
-      const matchingTab = preferredUrl
-        ? context.pages().find((candidate) =>
+    let preferredTabMatched = false;
+    let preferredTargetMatched = false;
+    let preferredTabAmbiguous = false;
+    let targetId = null;
+    if (exactTargetOnly) {
+      const matchingTargets = [];
+      for (const candidate of pages) {
+        const candidateTargetId = await probeTargetId(candidate);
+        if (candidateTargetId === preferredTargetId) {
+          matchingTargets.push({ page: candidate, targetId: candidateTargetId });
+        }
+      }
+      if (matchingTargets.length !== 1) {
+        throw recoveryTargetUnavailable(
+          matchingTargets.length === 0
+            ? "The exact saved Chrome target is no longer available."
+            : "The saved Chrome target identity is ambiguous.",
+        );
+      }
+      page = matchingTargets[0].page;
+      targetId = matchingTargets[0].targetId;
+      preferredTargetMatched = true;
+    } else if (reused) {
+      if (preferredTargetId) {
+        for (const candidate of pages) {
+          const candidateTargetId = await probeTargetId(candidate);
+          if (candidateTargetId === preferredTargetId) {
+            page = candidate;
+            targetId = candidateTargetId;
+            preferredTargetMatched = true;
+            break;
+          }
+        }
+      }
+      if (!page && preferredUrl) {
+        const matchingTabs = pages.filter((candidate) =>
           sameOriginPath(candidate.url?.() ?? "", preferredUrl)
-        ) ?? null
-        : null;
-      page = matchingTab ?? await context.newPage();
+        );
+        // Duplicate exact-URL tabs are ambiguous. Opening a fresh page is safer
+        // than attaching a pending result or follow-up to an arbitrary copy.
+        if (matchingTabs.length === 1) {
+          page = matchingTabs[0];
+          preferredTabMatched = true;
+        } else if (matchingTabs.length > 1) {
+          preferredTabAmbiguous = true;
+        }
+      }
+      page ??= await context.newPage();
     } else {
-      page = context.pages()[0] ?? await context.newPage();
+      page = pages[0] ?? await context.newPage();
     }
-    if (minimized) {
+    targetId ??= await probeTargetId(page);
+    if (minimized && !exactTargetOnly) {
       await setWindowState(context, page, "minimized");
     }
 
@@ -358,35 +515,67 @@ export async function launchAndConnectCdpChrome({
       page,
       pid: state.pid,
       reused,
+      targetId,
+      existingPageUrls,
+      exactTargetOnly,
+      preferredTabMatched,
+      preferredTargetMatched,
+      preferredTabAmbiguous,
       // Minimize / restore the visible window on demand. The runtime restores
       // the window when it needs the user (manual login, CAPTCHA) and
       // re-minimizes afterward. Uses the live current page each time so it
       // targets the window the user is actually looking at.
       async minimize() {
-        return await setWindowState(context, page, "minimized");
+        return exactTargetOnly
+          ? false
+          : await setWindowState(context, page, "minimized");
       },
       async restore() {
-        return await setWindowState(context, page, "normal");
+        return exactTargetOnly
+          ? false
+          : await setWindowState(context, page, "normal");
       },
       // Drops only the Playwright transport. Unlike close(), never asks Chrome
       // to exit and never kills the process: used to recover from a dead CDP
       // connection (e.g. after the Mac slept) while Chrome itself is alive.
       // The profile lock stays held because the same CLI session will reconnect.
       async disconnect() {
-        await settleWithin(browser.close(), 1_500);
+        await settleWithin(
+          Promise.resolve().then(() => browser.close()),
+          transportCloseTimeoutMs,
+        );
       },
       // Leaves Chrome running (and its saved CDP state intact) but drops the
       // Playwright transport and the profile lock so a later WTAgent process
       // can reuse the window. Used after a failed run that wants the page
       // left open for inspection without blocking the next launch.
       async detach() {
-        await settleWithin(browser.close(), 1_500);
-        await releaseProfileLock();
+        try {
+          await settleWithin(
+            Promise.resolve().then(() => browser.close()),
+            transportCloseTimeoutMs,
+          );
+        } finally {
+          await releaseProfileLock();
+        }
       },
       async close() {
         if (closePromise) {
           return await closePromise;
         }
+        if (exactTargetOnly) {
+          closePromise = (async () => {
+            try {
+              await settleWithin(
+                Promise.resolve().then(() => browser.close()),
+                transportCloseTimeoutMs,
+              );
+            } finally {
+              await releaseProfileLock();
+            }
+          })();
+          return await closePromise;
+        }
         closePromise = (async () => {
           let exited = false;
           try {
@@ -396,10 +585,16 @@ export async function launchAndConnectCdpChrome({
               .catch(() => null);
             if (session) {
               await settleWithin(session.send("Browser.close"), 1_500);
-              await settleWithin(session.detach(), 500);
+              await settleWithin(
+                Promise.resolve().then(() => session.detach()),
+                500,
+              );
             }
             exited = await waitForExit(state.pid, 3_000);
-            await settleWithin(browser.close(), 1_500);
+            await settleWithin(
+              Promise.resolve().then(() => browser.close()),
+              transportCloseTimeoutMs,
+            );
 
             if (!exited) {
               const childStillOwnsPid = child?.pid === state.pid
@@ -429,7 +624,10 @@ export async function launchAndConnectCdpChrome({
       },
     };
   } catch (error) {
-    await browser?.close().catch(() => null);
+    await settleWithin(
+      Promise.resolve().then(() => browser?.close()),
+      transportCloseTimeoutMs,
+    );
     if (
       child
       && child.exitCode == null

package/src/browser/cdp-state.js

@@ -545,7 +545,7 @@ export async function inspectCdpProfileState(profileDir, {
 // live lock-holder pid from a recycled one: a process that started after the
 // lock file was written cannot own it. Returns null when it cannot be
 // determined (unknown process, platform tool unavailable).
-async function processStartTimeMs(pid, { execFileImpl = execFileAsync } = {}) {
+export async function processStartTimeMs(pid, { execFileImpl = execFileAsync } = {}) {
   if (process.platform === "win32") {
     const { stdout } = await execFileImpl(
       "powershell.exe",
@@ -555,7 +555,7 @@ async function processStartTimeMs(pid, { execFileImpl = execFileAsync } = {}) {
         "-Command",
         `(Get-CimInstance Win32_Process -Filter "ProcessId=${pid}").CreationDate`,
       ],
-      { windowsHide: true },
+      { windowsHide: true, timeout: 1_500 },
     );
     const parsed = Date.parse(String(stdout).trim());
     return Number.isFinite(parsed) ? parsed : null;
@@ -563,10 +563,13 @@ async function processStartTimeMs(pid, { execFileImpl = execFileAsync } = {}) {
 
   const { stdout } = await execFileImpl(
     "ps",
-    ["-p", String(pid), "-o", "etimes="],
+    ["-p", String(pid), "-o", "lstart="],
+    {
+      env: { ...process.env, LANG: "C", LC_ALL: "C" },
+    },
   );
-  const seconds = Number.parseInt(String(stdout), 10);
-  return Number.isFinite(seconds) ? Date.now() - seconds * 1_000 : null;
+  const parsed = Date.parse(String(stdout).trim());
+  return Number.isFinite(parsed) ? parsed : null;
 }
 
 export async function acquireCdpProfileLock(profileDir, {

package/src/browser/chatgpt-dom.js

@@ -0,0 +1,179 @@
+// All supported ChatGPT DOM shapes live here. Text and localized headings must
+// never supply a role, message identity, or ordering key.
+const legacyUser = '[data-message-author-role="user"]';
+const legacyAssistant = '[data-message-author-role="assistant"]:not([id^="request-placeholder-"])';
+const modern = (role) => `[data-chatgpt-search-unit-key$=":${role}"]:not([id^="request-placeholder-"]):not(:has([data-message-author-role])):not([data-message-author-role] *)`;
+export const CHATGPT_DOM = {
+  user: { legacy: legacyUser, modern: modern("user") },
+  assistant: { legacy: legacyAssistant, modern: modern("assistant") },
+  conversationLegacy: '[data-message-author-role="user"], [data-message-author-role="assistant"]',
+  composers: [
+    { name: "prompt-textarea", selector: "#prompt-textarea" },
+    { name: "markdown-composer", selector: '[data-composer-markdown][contenteditable="true"][role="textbox"]' },
+    { name: "message-textarea-en", selector: 'textarea[placeholder*="Message" i]' },
+    { name: "message-textarea-zh", selector: 'textarea[placeholder*="消息"]' },
+    { name: "lexical-composer", selector: 'div[contenteditable="true"][data-lexical-editor="true"]' },
+    { name: "main-contenteditable", selector: 'main div[contenteditable="true"]' },
+  ],
+  send: '[data-testid="send-button"]',
+  stop: '[data-testid="stop-button"]',
+};
+CHATGPT_DOM.messages = [legacyUser, legacyAssistant, modern("user"), modern("assistant")].join(", ");
+
+// This function is serialized into the page. Keep it self-contained, and pass
+// the registry explicitly when requesting a capability sample.
+export function readChatGPTDom(input) {
+  const options = input?.selector ? input : null;
+  const elements = typeof input === "string" || options
+    ? [...document.querySelectorAll(options?.selector ?? input)]
+    : Array.isArray(input) ? input : [input];
+  const structure = { legacy: 0, modern: 0, unknown: 0, ambiguousIds: 0 };
+  const entries = elements.map((element, domIndex) => {
+    const legacyRole = element.getAttribute("data-message-author-role");
+    const key = element.getAttribute("data-chatgpt-search-unit-key") ?? "";
+    const modern = key.match(/^fallback-turn-(\d+):(\d+):(user|assistant)$/);
+    const role = legacyRole ?? modern?.[3] ?? null;
+    structure[legacyRole ? "legacy" : modern ? "modern" : "unknown"] += 1;
+    const wrapper = element.closest('[data-testid^="conversation-turn-"]');
+    const legacyTurn = wrapper?.getAttribute("data-testid")?.match(/^conversation-turn-(\d+)$/);
+    const messageIds = [...new Set((element.getAttribute("data-chatgpt-search-message-ids") ?? "").split(/\s+/).filter(Boolean))];
+    const legacyId = element.getAttribute("data-message-id");
+    if (legacyId == null && messageIds.length > 1) structure.ambiguousIds += 1;
+    const id = legacyId ?? (messageIds.length === 1 ? messageIds[0] : null);
+    // Thinking/tool blocks occupy positions too. Only the group and role define
+    // turn order; duplicate roles within a group are rejected by validation.
+    const turn = legacyTurn ? Number(legacyTurn[1])
+      : modern ? Number(modern[1]) * 2 + (role === "user" ? 1 : 2) : null;
+    let renderedText = element.innerText ?? element.textContent ?? "";
+    if (role === "assistant" && !renderedText.includes("<agent_response")) {
+      const codeTexts = [...element.querySelectorAll("pre code")].map((node) => node.innerText ?? node.textContent ?? "");
+      const envelope = codeTexts.find((text) => text.includes("<agent_response") && text.includes("</agent_response>"))
+        ?? codeTexts.find((text) => text.includes("<agent_response"));
+      const markdown = [...element.querySelectorAll('.markdown, [data-markdown-text-style="assistant-message"]')].at(-1);
+      if (envelope) renderedText = envelope;
+      else if (markdown) renderedText = markdown.innerText ?? markdown.textContent ?? "";
+    }
+    return { domIndex, role, id, turn, renderedText };
+  });
+  const snapshot = { url: globalThis.location?.href ?? null, entries, structure };
+  if (options?.registry) {
+    const visible = (element) => element.getClientRects().length > 0
+      && getComputedStyle(element).visibility !== "hidden";
+    const count = (selector) => [...document.querySelectorAll(selector)].filter(visible).length;
+    snapshot.capabilities = {
+      readyState: document.readyState,
+      composers: options.registry.composers.filter(({ selector }) => count(selector) > 0).map(({ name }) => name),
+      sendButton: count(options.registry.send) > 0,
+      stopButton: count(options.registry.stop) > 0,
+      placeholderCount: document.querySelectorAll('[id^="request-placeholder-"]').length,
+      // Unknown suffixes are evidence of a renderer change, not valid messages.
+      unknownSearchUnits: [...document.querySelectorAll('[data-chatgpt-search-unit-key]')]
+        .filter((element) => !/^fallback-turn-\d+:\d+:(user|assistant)$/.test(element.getAttribute("data-chatgpt-search-unit-key"))).length,
+    };
+  }
+  return snapshot;
+}
+
+// Deliberately excludes message text, IDs, composer content, and raw attributes.
+// This report may be collected even when screenshots/full HTML are disabled.
+export function summarizeChatGPTDom(snapshot) {
+  if (!snapshot || !Array.isArray(snapshot.entries)) return { status: "unavailable" };
+  const entries = snapshot.entries;
+  const issues = [];
+  const countMissing = (test) => entries.filter(test).length;
+  const missing = {
+    role: countMissing((entry) => !["user", "assistant"].includes(entry.role)),
+    id: countMissing((entry) => typeof entry.id !== "string" || !entry.id.trim()),
+    turn: countMissing((entry) => !Number.isSafeInteger(entry.turn) || entry.turn < 0),
+  };
+  for (const [field, count] of Object.entries(missing)) if (count) issues.push(`missing-${field}`);
+  const ids = entries.map((entry) => entry.id).filter(Boolean);
+  if (new Set(ids).size !== ids.length) issues.push("duplicate-message-id");
+  if (entries.some((entry, index) => index > 0 && entry.turn <= entries[index - 1].turn)) issues.push("non-monotonic-turns");
+  if (snapshot.structure?.ambiguousIds) issues.push("ambiguous-message-ids");
+  if (snapshot.capabilities?.unknownSearchUnits) issues.push("unknown-search-unit-format");
+  if (snapshot.capabilities && !snapshot.capabilities.composers.length) issues.push("composer-not-found");
+  return {
+    status: issues.length ? "incomplete" : entries.length ? "recognized" : "empty",
+    structure: snapshot.structure,
+    capabilities: snapshot.capabilities,
+    counts: { total: entries.length, user: countMissing((entry) => entry.role === "user"), assistant: countMissing((entry) => entry.role === "assistant") },
+    missing,
+    issues,
+  };
+}
+
+function parseConversationTurn(value) {
+  const match = String(value ?? "").match(/^conversation-turn-(\d+)$/);
+  return match ? Number.parseInt(match[1], 10) : null;
+}
+
+export async function readChatGPTMessageIdentity(message) {
+  if (await message.getAttribute("data-chatgpt-search-unit-key").catch(() => null)) {
+    const snapshot = await message.evaluate(readChatGPTDom).catch(() => null);
+    const entry = snapshot?.entries?.[0];
+    if (!entry || !["user", "assistant"].includes(entry.role)
+      || !entry.id || !Number.isSafeInteger(entry.turn) || entry.turn < 0) {
+      return { id: null, turn: null };
+    }
+    return { id: entry.id, turn: entry.turn };
+  }
+  const [id, turn] = await Promise.all([
+    message.getAttribute("data-message-id").catch(() => null),
+    readLegacyTurn(message),
+  ]);
+  return { id, turn };
+}
+
+async function readLegacyTurn(message) {
+  if (typeof message?.evaluate !== "function") {
+    return null;
+  }
+  const testId = await message.evaluate((element) => (
+    element.closest('[data-testid^="conversation-turn-"]')
+      ?.getAttribute("data-testid") ?? null
+  )).catch(() => null);
+  return parseConversationTurn(testId);
+}
+
+
+export async function readChatGPTAssistantText(message, hasCompleteAgentEnvelope) {
+  if (await message.getAttribute("data-chatgpt-search-unit-key").catch(() => null)) {
+    const snapshot = await message.evaluate(readChatGPTDom).catch(() => null);
+    return snapshot?.entries?.[0]?.renderedText ?? "";
+  }
+  // Read the whole assistant turn first. A long XML response can contain
+  // Markdown fences inside CDATA; ChatGPT then splits the rendered response
+  // into many <pre><code> nodes and the first node contains the opening tag
+  // but not the closing tag. The parent innerText keeps the complete envelope
+  // and avoids one CDP round trip per nested code block on every poll.
+  const fullText = await message.innerText().catch(() => "");
+  if (fullText.includes("<agent_response")) {
+    return fullText;
+  }
+
+  // Rare fallback for alternate renderers where the parent text omits code
+  // contents: prefer a complete code-block envelope, but retain a partial
+  // one so streaming progress remains visible until its closing tag arrives.
+  const codeBlocks = message.locator("pre code");
+  const codeBlockCount = await codeBlocks.count();
+  let partialEnvelope = "";
+  for (let index = 0; index < codeBlockCount; index += 1) {
+    const code = await codeBlocks.nth(index).innerText().catch(() => "");
+    if (hasCompleteAgentEnvelope(code)) {
+      return code;
+    }
+    if (!partialEnvelope && code.includes("<agent_response")) {
+      partialEnvelope = code;
+    }
+  }
+  if (partialEnvelope) {
+    return partialEnvelope;
+  }
+
+  const markdown = message.locator(".markdown");
+  if (await markdown.count()) {
+    return await markdown.last().innerText().catch(() => "");
+  }
+  return fullText;
+}