ask-pro 0.1.0

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

@@ -0,0 +1,369 @@
+import { INPUT_SELECTORS, SEND_BUTTON_SELECTORS, STOP_BUTTON_SELECTOR, UPLOAD_STATUS_SELECTORS, } from "../constants.js";
+import { buildClickDispatcher } from "./domEvents.js";
+function normalizeToken(value) {
+    return value.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function normalizeExpectedName(value) {
+    const baseName = value.split("/").pop()?.split("\\").pop() ?? value;
+    return normalizeToken(baseName);
+}
+function matchesExpected(raw, expected) {
+    if (raw.includes(expected)) {
+        return true;
+    }
+    const expectedNoExt = expected.replace(/\.[a-z0-9]{1,10}$/i, "");
+    if (expectedNoExt.length >= 6 && raw.includes(expectedNoExt)) {
+        return true;
+    }
+    if (raw.includes("…") || raw.includes("...")) {
+        const marker = raw.includes("…") ? "…" : "...";
+        const [prefixRaw, suffixRaw] = raw.split(marker);
+        const prefix = prefixRaw.trim();
+        const suffix = suffixRaw.trim();
+        const target = expectedNoExt.length >= 6 ? expectedNoExt : expected;
+        const matchesPrefix = !prefix || target.includes(prefix);
+        const matchesSuffix = !suffix || target.includes(suffix);
+        return matchesPrefix && matchesSuffix;
+    }
+    return false;
+}
+function buildComposerScopeHelpersExpression() {
+    return `
+    const sendSelectors = ${JSON.stringify(SEND_BUTTON_SELECTORS)};
+    const stopSelector = ${JSON.stringify(STOP_BUTTON_SELECTOR)};
+    const promptSelectors = ${JSON.stringify(INPUT_SELECTORS)};
+    const attachmentSelectors = [
+      'input[type="file"]',
+      '[data-testid*="attachment"]',
+      '[data-testid*="upload"]',
+      '[aria-label*="Remove"]',
+      '[aria-label*="remove"]',
+    ];
+    const attachmentChipSelectors = [
+      '[data-testid*="chip"]',
+      '[data-testid*="attachment"]',
+      '[data-testid*="upload"]',
+      '[data-testid*="file"]',
+      '[aria-label*="Remove"]',
+      'button[aria-label*="Remove"]',
+    ];
+    const fileCountSelectors = [
+      'button',
+      '[role="button"]',
+      '[data-testid*="file"]',
+      '[data-testid*="upload"]',
+      '[data-testid*="attachment"]',
+      '[data-testid*="chip"]',
+      '[aria-label*="file"]',
+      '[title*="file"]',
+      '[aria-label*="attachment"]',
+      '[title*="attachment"]',
+    ].join(',');
+    const countRegex = /(?:^|\\b)(\\d+)\\s+(?:files?|attachments?)\\b/;
+    const isVisible = (node) => {
+      if (!(node instanceof HTMLElement)) return false;
+      const rect = node.getBoundingClientRect();
+      if (rect.width <= 0 || rect.height <= 0) return false;
+      const style = window.getComputedStyle(node);
+      return style.display !== 'none' && style.visibility !== 'hidden';
+    };
+    const isStopControl = (node) => {
+      if (!(node instanceof HTMLElement)) return false;
+      const label = [
+        node.getAttribute('data-testid') ?? '',
+        node.getAttribute('aria-label') ?? '',
+        node.getAttribute('title') ?? '',
+        node.textContent ?? '',
+      ].join(' ').toLowerCase();
+      return node.matches(stopSelector) || label.includes('stop') || label.includes('cancel');
+    };
+    const findPromptNode = () => {
+      for (const selector of promptSelectors) {
+        const nodes = Array.from(document.querySelectorAll(selector));
+        for (const node of nodes) {
+          if (isVisible(node)) return node;
+        }
+      }
+      for (const selector of promptSelectors) {
+        const node = document.querySelector(selector);
+        if (node) return node;
+      }
+      return null;
+    };
+    const locateComposerRoot = () => {
+      const promptNode = findPromptNode();
+      if (promptNode) {
+        const initial =
+          promptNode.closest('[data-testid*="composer"]') ??
+          promptNode.closest('form') ??
+          promptNode.parentElement ??
+          document.body;
+        let current = initial;
+        let fallback = initial;
+        while (current && current !== document.body) {
+          const hasSend = sendSelectors.some((selector) => current.querySelector(selector));
+          if (hasSend) {
+            fallback = current;
+            const hasAttachment = attachmentSelectors.some((selector) => current.querySelector(selector));
+            if (hasAttachment) {
+              return current;
+            }
+          }
+          current = current.parentElement;
+        }
+        return fallback ?? initial;
+      }
+      return document.querySelector('form') ?? document.body;
+    };
+    const composerRoot = locateComposerRoot();
+    const composerScope = (() => {
+      if (!composerRoot) return document.body;
+      const parent = composerRoot.parentElement;
+      const parentHasSend = parent && sendSelectors.some((selector) => parent.querySelector(selector));
+      return parentHasSend ? parent : composerRoot;
+    })();
+    const findSendButton = () => {
+      const seen = new Set();
+      const candidates = [];
+      const scopes = [composerScope, composerRoot, document.body];
+      for (const scope of scopes) {
+        if (!scope || typeof scope.querySelectorAll !== 'function') continue;
+        for (const selector of sendSelectors) {
+          for (const node of Array.from(scope.querySelectorAll(selector))) {
+            if (!(node instanceof HTMLElement) || seen.has(node)) continue;
+            seen.add(node);
+            candidates.push(node);
+          }
+        }
+        if (candidates.length > 0) break;
+      }
+      const sendCandidates = candidates.filter((node) => !isStopControl(node));
+      return sendCandidates.find((node) => isVisible(node)) ?? sendCandidates[0] ?? null;
+    };
+    const collectAttachmentNodes = () => {
+      const nodes = [];
+      const seen = new Set();
+      for (const selector of attachmentChipSelectors) {
+        for (const node of Array.from(composerScope.querySelectorAll(selector))) {
+          if (!node || seen.has(node)) continue;
+          seen.add(node);
+          nodes.push(node);
+        }
+      }
+      return nodes;
+    };
+    const collectFileCount = (nodes) => {
+      let count = 0;
+      for (const node of nodes) {
+        if (!(node instanceof HTMLElement)) continue;
+        if (node.matches('textarea,input,[contenteditable="true"]')) continue;
+        const dataTestId = node.getAttribute?.('data-testid') ?? '';
+        const aria = node.getAttribute?.('aria-label') ?? '';
+        const title = node.getAttribute?.('title') ?? '';
+        const tooltip =
+          node.getAttribute?.('data-tooltip') ?? node.getAttribute?.('data-tooltip-content') ?? '';
+        const text = node.textContent ?? '';
+        const parent = node.parentElement;
+        const parentText = parent?.textContent ?? '';
+        const parentAria = parent?.getAttribute?.('aria-label') ?? '';
+        const parentTitle = parent?.getAttribute?.('title') ?? '';
+        const parentTooltip =
+          parent?.getAttribute?.('data-tooltip') ?? parent?.getAttribute?.('data-tooltip-content') ?? '';
+        const parentTestId = parent?.getAttribute?.('data-testid') ?? '';
+        const candidates = [
+          text,
+          aria,
+          title,
+          tooltip,
+          dataTestId,
+          parentText,
+          parentAria,
+          parentTitle,
+          parentTooltip,
+          parentTestId,
+        ];
+        let hasFileHint = false;
+        for (const raw of candidates) {
+          if (!raw) continue;
+          const lowered = String(raw).toLowerCase();
+          if (lowered.includes('file') || lowered.includes('attachment')) {
+            hasFileHint = true;
+            break;
+          }
+        }
+        if (!hasFileHint) continue;
+        for (const raw of candidates) {
+          if (!raw) continue;
+          const match = String(raw).toLowerCase().match(countRegex);
+          if (match) {
+            const parsed = Number(match[1]);
+            if (Number.isFinite(parsed)) {
+              count = Math.max(count, parsed);
+            }
+          }
+        }
+      }
+      return count;
+    };
+  `;
+}
+export function buildComposerSendReadinessExpression() {
+    return `(() => {
+    ${buildComposerScopeHelpersExpression()}
+    const button = findSendButton();
+    const style = button ? window.getComputedStyle(button) : null;
+    const disabled = button
+      ? button.hasAttribute('disabled') ||
+        button.getAttribute('aria-disabled') === 'true' ||
+        button.getAttribute('data-disabled') === 'true' ||
+        style.pointerEvents === 'none' ||
+        style.display === 'none' ||
+        style.visibility === 'hidden'
+      : null;
+    const uploadingSelectors = ${JSON.stringify(UPLOAD_STATUS_SELECTORS)};
+    const uploading = uploadingSelectors.some((selector) => {
+      return Array.from(composerScope.querySelectorAll(selector)).some((node) => {
+        const ariaBusy = node.getAttribute?.('aria-busy');
+        const dataState = node.getAttribute?.('data-state');
+        if (
+          ariaBusy === 'true' ||
+          dataState === 'loading' ||
+          dataState === 'uploading' ||
+          dataState === 'pending'
+        ) {
+          return true;
+        }
+        const text = node.textContent?.toLowerCase?.() ?? '';
+        return /\\buploading\\b/.test(text) || /\\bprocessing\\b/.test(text);
+      });
+    });
+    const attachmentNodes = collectAttachmentNodes();
+    const attachedNames = [];
+    for (const node of attachmentNodes) {
+      const text = node.textContent ?? '';
+      const aria = node.getAttribute?.('aria-label') ?? '';
+      const title = node.getAttribute?.('title') ?? '';
+      const parentText = node.parentElement?.parentElement?.innerText ?? '';
+      for (const value of [text, aria, title, parentText]) {
+        const normalized = value?.toLowerCase?.();
+        if (normalized) attachedNames.push(normalized);
+      }
+    }
+    const cardTexts = Array.from(composerScope.querySelectorAll('[aria-label*="Remove"]')).map((btn) =>
+      btn?.parentElement?.parentElement?.innerText?.toLowerCase?.() ?? '',
+    );
+    attachedNames.push(...cardTexts.filter(Boolean));
+    const inputNames = [];
+    const inputScope = Array.from(composerScope.querySelectorAll('input[type="file"]'));
+    const inputNodes = [];
+    const inputSeen = new Set();
+    for (const el of [...inputScope, ...Array.from(document.querySelectorAll('input[type="file"]'))]) {
+      if (!inputSeen.has(el)) {
+        inputSeen.add(el);
+        inputNodes.push(el);
+      }
+    }
+    for (const input of inputNodes) {
+      if (!(input instanceof HTMLInputElement) || !input.files?.length) continue;
+      for (const file of Array.from(input.files)) {
+        if (file?.name) inputNames.push(file.name.toLowerCase());
+      }
+    }
+    const localFileCountNodes = Array.from(composerScope.querySelectorAll(fileCountSelectors));
+    let fileCount = collectFileCount(localFileCountNodes);
+    if (!fileCount) {
+      fileCount = collectFileCount(Array.from(document.querySelectorAll(fileCountSelectors)));
+    }
+    const attachmentUiCount = attachmentNodes.length;
+    const filesAttached = attachedNames.length > 0 || fileCount > 0 || attachmentUiCount > 0;
+    return {
+      state: button ? (disabled ? 'disabled' : 'ready') : 'missing',
+      uploading,
+      filesAttached,
+      attachedNames,
+      inputNames,
+      fileCount,
+      attachmentUiCount,
+    };
+  })()`;
+}
+export function buildComposerSendClickExpression() {
+    return `(() => {
+    ${buildClickDispatcher()}
+    ${buildComposerScopeHelpersExpression()}
+    const button = findSendButton();
+    if (!button) return 'missing';
+    if (isStopControl(button)) return 'stop-button';
+    const style = window.getComputedStyle(button);
+    const disabled =
+      button.hasAttribute('disabled') ||
+      button.getAttribute('aria-disabled') === 'true' ||
+      button.getAttribute('data-disabled') === 'true' ||
+      style.pointerEvents === 'none' ||
+      style.display === 'none' ||
+      style.visibility === 'hidden';
+    if (disabled) return 'disabled';
+    dispatchClickSequence(button);
+    return 'clicked';
+  })()`;
+}
+export async function readComposerSendReadiness(Runtime) {
+    const response = await Runtime.evaluate({
+        expression: buildComposerSendReadinessExpression(),
+        returnByValue: true,
+    });
+    return response.result?.value ?? null;
+}
+export function evaluateComposerAttachmentEvidence(state, expectedNames = []) {
+    const expectedNormalized = expectedNames.map(normalizeExpectedName).filter(Boolean);
+    const attachedNames = (state.attachedNames ?? []).map(normalizeToken).filter(Boolean);
+    const inputNames = (state.inputNames ?? []).map(normalizeToken).filter(Boolean);
+    if (expectedNormalized.length === 0) {
+        const attached = Boolean(state.filesAttached || state.fileCount > 0 || state.attachmentUiCount > 0);
+        const input = inputNames.length > 0;
+        return {
+            expectedNormalized,
+            attachedNames,
+            inputNames,
+            attachedMatch: attached,
+            inputMatch: input,
+            fileCountSatisfied: attached,
+            attachmentUiSatisfied: attached,
+        };
+    }
+    return {
+        expectedNormalized,
+        attachedNames,
+        inputNames,
+        attachedMatch: expectedNormalized.every((expected) => attachedNames.some((raw) => matchesExpected(raw, expected))),
+        inputMatch: expectedNormalized.every((expected) => inputNames.some((raw) => matchesExpected(raw, expected))),
+        fileCountSatisfied: state.fileCount >= expectedNormalized.length,
+        attachmentUiSatisfied: state.attachmentUiCount >= expectedNormalized.length,
+    };
+}
+export function hasAttachmentCompletionEvidence(state, expectedNames = []) {
+    const evidence = evaluateComposerAttachmentEvidence(state, expectedNames);
+    return (evidence.attachedMatch ||
+        evidence.inputMatch ||
+        evidence.fileCountSatisfied ||
+        evidence.attachmentUiSatisfied);
+}
+export function summarizeComposerSendReadiness(state, expectedNames = []) {
+    if (!state) {
+        return { state: "unavailable" };
+    }
+    const evidence = evaluateComposerAttachmentEvidence(state, expectedNames);
+    return {
+        state: state.state,
+        uploading: state.uploading,
+        filesAttached: state.filesAttached,
+        fileCount: state.fileCount,
+        attachmentUiCount: state.attachmentUiCount,
+        attachedNames: evidence.attachedNames.slice(0, 3),
+        inputNames: evidence.inputNames.slice(0, 3),
+        attachedMatch: evidence.attachedMatch,
+        inputMatch: evidence.inputMatch,
+        fileCountSatisfied: evidence.fileCountSatisfied,
+        attachmentUiSatisfied: evidence.attachmentUiSatisfied,
+    };
+}

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

@@ -0,0 +1,31 @@
+const CLICK_TYPES = [
+    "pointerover",
+    "pointerenter",
+    "mouseover",
+    "mouseenter",
+    "pointermove",
+    "mousemove",
+    "pointerdown",
+    "mousedown",
+    "pointerup",
+    "mouseup",
+    "click",
+];
+export function buildClickDispatcher(functionName = "dispatchClickSequence") {
+    const typesLiteral = JSON.stringify(CLICK_TYPES);
+    return `function ${functionName}(target){
+    if(!target || !(target instanceof EventTarget)) return false;
+    const types = ${typesLiteral};
+    for (const type of types) {
+      const common = { bubbles: true, cancelable: true, view: window };
+      let event;
+      if (type.startsWith('pointer') && 'PointerEvent' in window) {
+        event = new PointerEvent(type, { ...common, pointerId: 1, pointerType: 'mouse' });
+      } else {
+        event = new MouseEvent(type, common);
+      }
+      target.dispatchEvent(event);
+    }
+    return true;
+  }`;
+}

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

@@ -0,0 +1,52 @@
+export function createPostSubmitInputGuard(Input, logger) {
+    const input = Input;
+    let enabled = false;
+    const setIgnored = async (ignore) => {
+        if (typeof input.setIgnoreInputEvents !== "function") {
+            if (ignore) {
+                logger("[browser] CDP input guard unavailable; continuing with focus-only stop protection.");
+            }
+            return;
+        }
+        await input.setIgnoreInputEvents({ ignore });
+        enabled = ignore;
+        logger(ignore
+            ? "[browser] Enabled post-submit input guard"
+            : "[browser] Disabled post-submit input guard");
+    };
+    return {
+        get enabled() {
+            return enabled;
+        },
+        async enable() {
+            if (enabled)
+                return;
+            try {
+                await setIgnored(true);
+            }
+            catch (error) {
+                enabled = false;
+                logger(`[browser] Failed to enable post-submit input guard: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        },
+        async disable() {
+            if (!enabled)
+                return true;
+            let lastError;
+            for (let attempt = 1; attempt <= 3; attempt += 1) {
+                try {
+                    await setIgnored(false);
+                    return true;
+                }
+                catch (error) {
+                    lastError = error;
+                    if (attempt < 3) {
+                        await new Promise((resolve) => setTimeout(resolve, 100 * attempt));
+                    }
+                }
+            }
+            logger(`[browser] Failed to disable post-submit input guard after retries: ${lastError instanceof Error ? lastError.message : String(lastError)}`);
+            return false;
+        },
+    };
+}

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

@@ -0,0 +1,68 @@
+import { getChatGptModelKindTestIdTokens } from "../chatgptModelCatalog.js";
+export function buildModelPickerDomHelpers() {
+    const kindTokensLiteral = JSON.stringify(getChatGptModelKindTestIdTokens());
+    return `
+    const EFFORT_LABELS = new Set([
+      'light',
+      'standard',
+      'extended',
+      'heavy',
+      'instant',
+      'medium',
+      'high',
+      'langer',
+      'sofort',
+      'mittel',
+      'hoch',
+    ]);
+    const MODEL_KIND_TEST_ID_TOKENS = ${kindTokensLiteral};
+    const findModelButton = () => {
+      const candidates = Array.from(document.querySelectorAll(MODEL_BUTTON_SELECTOR));
+      if (candidates.length === 0) return null;
+      let best = null;
+      for (const candidate of candidates) {
+        const rawText = [
+          candidate.textContent ?? '',
+          candidate.getAttribute?.('aria-label') ?? '',
+          candidate.getAttribute?.('data-testid') ?? '',
+        ].join(' ');
+        const label = normalize(rawText);
+        const testId = candidate.getAttribute?.('data-testid') ?? '';
+        const className = candidate.getAttribute?.('class') ?? '';
+        const hasMenu = candidate.getAttribute?.('aria-haspopup') === 'menu';
+        const isEffortOnly = label === 'pro' || label === 'thinking' || EFFORT_LABELS.has(label);
+        const rect = candidate.getBoundingClientRect?.();
+        if (!rect || rect.width <= 0 || rect.height <= 0) continue;
+        let score = 0;
+        if (testId.includes('model-switcher')) score += 1000;
+        if (label.includes('model')) score += 300;
+        if (label.includes('gpt') || label.includes('chatgpt')) score += 200;
+        if (label.includes('auto')) score += 250;
+        if (label.includes('instant')) score += 250;
+        if (/\\b5\\b/.test(label) || /\\b5\\s+[0-9]\\b/.test(label)) score += 150;
+        if ((label.includes('thinking') || label.includes('pro')) && !isEffortOnly) score += 100;
+        if (className.includes('__composer-pill') && (label.includes('instant') || label.includes('medium') || label.includes('high'))) score += 120;
+        if (className.includes('__composer-pill') && hasMenu && isEffortOnly) score += 120;
+        if (isEffortOnly) score += 20;
+        score += 10;
+        if (!best || score > best.score) best = { candidate, score };
+      }
+      return best && best.score >= 100 ? best.candidate : null;
+    };
+    const modelKindFromLabel = (value) => {
+      const label = normalize(value);
+      if (label.includes('pro') && !label.includes('thinking')) return 'pro';
+      if (label.includes('thinking') && !label.includes('pro')) return 'thinking';
+      return null;
+    };
+    const modelKindFromTestId = (value) => {
+      const testId = String(value || '').toLowerCase();
+      for (const token of MODEL_KIND_TEST_ID_TOKENS.pro) {
+        if (testId.includes(token)) return 'pro';
+      }
+      for (const token of MODEL_KIND_TEST_ID_TOKENS.thinking) {
+        if (testId.includes(token)) return 'thinking';
+      }
+      return null;
+    };`;
+}