ask-pro 0.1.0

package/dist/src/browser/detect.js

@@ -0,0 +1,337 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { Launcher } from "chrome-launcher";
+export async function detectChromeBinary() {
+    const envPath = (process.env.CHROME_PATH ?? "").trim();
+    if (envPath) {
+        const ok = await isExecutable(envPath);
+        if (ok) {
+            return { path: envPath };
+        }
+    }
+    const launcherDetected = Launcher.getFirstInstallation();
+    if (launcherDetected) {
+        return { path: launcherDetected };
+    }
+    const candidates = platformChromeCandidates(process.platform, os.homedir());
+    for (const candidate of candidates.absolutePaths) {
+        if (await isExecutable(candidate)) {
+            return { path: candidate };
+        }
+    }
+    const fromPath = await findOnPath(candidates.binaryNames);
+    if (fromPath) {
+        return { path: fromPath };
+    }
+    return { path: null };
+}
+export async function detectChromeCookieDb({ profile, }) {
+    const profileName = profile?.trim() ? profile.trim() : "Default";
+    if (process.platform === "win32") {
+        return null;
+    }
+    const roots = resolveAttachRunningProfileRoots();
+    for (const root of roots) {
+        const dir = path.join(root.root, profileName);
+        const direct = path.join(dir, "Cookies");
+        if (await isFile(direct))
+            return direct;
+        const network = path.join(dir, "Network", "Cookies");
+        if (await isFile(network))
+            return network;
+    }
+    return null;
+}
+export function resolveAttachRunningProfileRoots(platform = process.platform, homeDir = os.homedir()) {
+    if (platform === "darwin") {
+        return [
+            {
+                family: "chrome",
+                root: path.join(homeDir, "Library", "Application Support", "Google", "Chrome"),
+            },
+            {
+                family: "chromium",
+                root: path.join(homeDir, "Library", "Application Support", "Chromium"),
+            },
+            {
+                family: "edge",
+                root: path.join(homeDir, "Library", "Application Support", "Microsoft Edge"),
+            },
+            {
+                family: "brave",
+                root: path.join(homeDir, "Library", "Application Support", "BraveSoftware", "Brave-Browser"),
+            },
+        ];
+    }
+    if (platform === "linux") {
+        return [
+            { family: "chrome", root: path.join(homeDir, ".config", "google-chrome") },
+            { family: "chromium", root: path.join(homeDir, ".config", "chromium") },
+            { family: "edge", root: path.join(homeDir, ".config", "microsoft-edge") },
+            {
+                family: "brave",
+                root: path.join(homeDir, ".config", "BraveSoftware", "Brave-Browser"),
+            },
+            { family: "chromium", root: path.join(homeDir, "snap", "chromium", "common", "chromium") },
+            { family: "chromium", root: path.join(homeDir, "snap", "chromium", "current", "chromium") },
+        ];
+    }
+    if (platform === "win32") {
+        const localAppData = process.env.LOCALAPPDATA ?? path.join(homeDir, "AppData", "Local");
+        return [
+            {
+                family: "chrome",
+                root: path.join(localAppData, "Google", "Chrome", "User Data"),
+            },
+            {
+                family: "chromium",
+                root: path.join(localAppData, "Chromium", "User Data"),
+            },
+            {
+                family: "edge",
+                root: path.join(localAppData, "Microsoft", "Edge", "User Data"),
+            },
+            {
+                family: "brave",
+                root: path.join(localAppData, "BraveSoftware", "Brave-Browser", "User Data"),
+            },
+        ];
+    }
+    return [];
+}
+export function resolveDevToolsActivePortDiscoveryRoots(platform = process.platform, homeDir = os.homedir()) {
+    if (platform === "darwin") {
+        return [path.join(homeDir, "Library", "Application Support")];
+    }
+    if (platform === "linux") {
+        return [path.join(homeDir, ".config"), path.join(homeDir, "snap")];
+    }
+    if (platform === "win32") {
+        return [process.env.LOCALAPPDATA ?? path.join(homeDir, "AppData", "Local")];
+    }
+    return [];
+}
+export function inferAttachRunningBrowserFamily(chromePath) {
+    const normalized = chromePath?.trim().toLowerCase();
+    if (!normalized) {
+        return null;
+    }
+    if (normalized.includes("microsoft edge") || normalized.includes("msedge")) {
+        return "edge";
+    }
+    if (normalized.includes("brave")) {
+        return "brave";
+    }
+    if (normalized.includes("chromium")) {
+        return "chromium";
+    }
+    if (normalized.includes("chrome")) {
+        return "chrome";
+    }
+    return null;
+}
+export function parseDevToolsActivePort(raw, options = {}) {
+    const host = formatWebSocketHost(options.host ?? "127.0.0.1");
+    const [rawPort, rawBrowserPath] = raw.split(/\r?\n/u);
+    const port = Number.parseInt(rawPort?.trim() ?? "", 10);
+    if (!Number.isFinite(port) || port <= 0 || port > 65_535) {
+        throw new Error("DevToolsActivePort did not contain a valid port.");
+    }
+    const browserPath = rawBrowserPath?.trim() || "/devtools/browser";
+    const normalizedPath = browserPath.startsWith("/") ? browserPath : `/${browserPath}`;
+    return {
+        port,
+        browserWSEndpoint: `ws://${host}:${port}${normalizedPath}`,
+    };
+}
+export async function readDevToolsActivePortInfo(profileRoot, options = {}) {
+    const candidates = [
+        path.join(profileRoot, "DevToolsActivePort"),
+        path.join(profileRoot, "Default", "DevToolsActivePort"),
+    ];
+    for (const candidate of candidates) {
+        try {
+            const raw = await fs.readFile(candidate, "utf8");
+            const parsed = parseDevToolsActivePort(raw, options);
+            return { ...parsed, path: candidate };
+        }
+        catch {
+            // ignore missing/unreadable candidates
+        }
+    }
+    return null;
+}
+export async function discoverDevToolsActivePortCandidates(options = {}) {
+    const { host, platform = process.platform, homeDir = os.homedir(), maxDepth = 6 } = options;
+    const roots = resolveDevToolsActivePortDiscoveryRoots(platform, homeDir);
+    const candidates = [];
+    const seenPaths = new Set();
+    for (const root of roots) {
+        await walkForDevToolsActivePort(root, maxDepth, async (candidatePath, stat) => {
+            if (seenPaths.has(candidatePath)) {
+                return;
+            }
+            seenPaths.add(candidatePath);
+            try {
+                const raw = await fs.readFile(candidatePath, "utf8");
+                const parsed = parseDevToolsActivePort(raw, { host });
+                candidates.push({
+                    ...parsed,
+                    path: candidatePath,
+                    profileRoot: deriveDevToolsProfileRoot(candidatePath),
+                    mtimeMs: Number(stat.mtimeMs),
+                });
+            }
+            catch {
+                // ignore unreadable or malformed DevToolsActivePort files
+            }
+        });
+    }
+    return candidates;
+}
+function platformChromeCandidates(platform = process.platform, homeDir = os.homedir()) {
+    if (platform === "linux") {
+        return {
+            binaryNames: [
+                "google-chrome",
+                "google-chrome-stable",
+                "chromium",
+                "chromium-browser",
+                "brave-browser",
+                "microsoft-edge",
+                "microsoft-edge-stable",
+            ],
+            absolutePaths: [
+                "/usr/bin/google-chrome",
+                "/usr/bin/google-chrome-stable",
+                "/usr/bin/google-chrome-beta",
+                "/usr/bin/google-chrome-unstable",
+                "/usr/bin/chromium",
+                "/usr/bin/chromium-browser",
+                "/usr/bin/brave-browser",
+                "/usr/bin/microsoft-edge",
+                "/usr/bin/microsoft-edge-stable",
+                "/snap/bin/chromium",
+                "/snap/bin/brave",
+                "/snap/bin/brave-browser",
+                "/snap/bin/microsoft-edge",
+                "/opt/google/chrome/chrome",
+            ],
+        };
+    }
+    if (platform === "darwin") {
+        return {
+            binaryNames: [],
+            absolutePaths: [
+                "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+                "/Applications/Chromium.app/Contents/MacOS/Chromium",
+                "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+                "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser",
+            ],
+        };
+    }
+    if (platform === "win32") {
+        const programFiles = process.env.ProgramFiles ?? "C:\\Program Files";
+        const programFilesX86 = process.env["ProgramFiles(x86)"] ?? "C:\\Program Files (x86)";
+        const localAppData = process.env.LOCALAPPDATA ?? path.join(homeDir, "AppData", "Local");
+        return {
+            binaryNames: [],
+            absolutePaths: [
+                path.join(programFiles, "Google", "Chrome", "Application", "chrome.exe"),
+                path.join(programFilesX86, "Google", "Chrome", "Application", "chrome.exe"),
+                path.join(localAppData, "Google", "Chrome", "Application", "chrome.exe"),
+                path.join(programFiles, "Microsoft", "Edge", "Application", "msedge.exe"),
+                path.join(programFilesX86, "Microsoft", "Edge", "Application", "msedge.exe"),
+            ],
+        };
+    }
+    return { binaryNames: [], absolutePaths: [] };
+}
+async function isExecutable(candidate) {
+    try {
+        const stat = await fs.stat(candidate);
+        if (!stat.isFile())
+            return false;
+        if (process.platform === "win32")
+            return true;
+        // eslint-disable-next-line no-bitwise
+        return (stat.mode & 0o111) !== 0;
+    }
+    catch {
+        return false;
+    }
+}
+async function isFile(candidate) {
+    try {
+        const stat = await fs.stat(candidate);
+        return stat.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function findOnPath(names) {
+    const rawPath = process.env.PATH ?? "";
+    const dirs = rawPath.split(path.delimiter).filter(Boolean);
+    for (const name of names) {
+        for (const dir of dirs) {
+            const candidate = path.join(dir, name);
+            if (await isExecutable(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    return null;
+}
+function deriveDevToolsProfileRoot(activePortPath) {
+    const parentDir = path.dirname(activePortPath);
+    if (path.basename(parentDir).toLowerCase() === "default") {
+        return path.dirname(parentDir);
+    }
+    return parentDir;
+}
+function formatWebSocketHost(host) {
+    if (host.includes(":") && !host.startsWith("[") && !host.endsWith("]")) {
+        return `[${host}]`;
+    }
+    return host;
+}
+async function walkForDevToolsActivePort(root, maxDepth, onFile) {
+    const stack = [{ dir: root, depth: 0 }];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current) {
+            continue;
+        }
+        let entries;
+        try {
+            entries = await fs.readdir(current.dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const candidatePath = path.join(current.dir, entry.name);
+            if (entry.isSymbolicLink()) {
+                continue;
+            }
+            if (entry.isFile()) {
+                if (entry.name !== "DevToolsActivePort") {
+                    continue;
+                }
+                try {
+                    const stat = await fs.stat(candidatePath);
+                    await onFile(candidatePath, stat);
+                }
+                catch {
+                    // ignore unreadable candidates
+                }
+                continue;
+            }
+            if (entry.isDirectory() && current.depth < maxDepth) {
+                stack.push({ dir: candidatePath, depth: current.depth + 1 });
+            }
+        }
+    }
+}

package/dist/src/browser/domDebug.js

@@ -0,0 +1,72 @@
+const MAX_CONTROLS = 32;
+const MAX_JSON_BYTES = 8 * 1024;
+export function buildDomControlInventoryExpression() {
+    return `(() => {
+    const selector = [
+      'button', 'input', 'select', 'textarea',
+      '[role="button"]', '[role="combobox"]', '[role="dialog"]', '[role="listbox"]',
+      '[role="menu"]', '[role="menuitem"]', '[role="option"]', '[role="radio"]',
+      '[role="switch"]', '[role="tab"]', '[aria-expanded]', '[aria-haspopup]'
+    ].join(',');
+    const allowed = (value, values) => values.includes(value) ? value : null;
+    const state = (node, name) => allowed(node.getAttribute(name), ['true', 'false', 'mixed']);
+    const nodes = Array.from(document.querySelectorAll(selector));
+    const controls = nodes.map((node, index) => {
+      const style = getComputedStyle(node);
+      const visible = node.getClientRects().length > 0 && style.display !== 'none' && style.visibility !== 'hidden';
+      const focused = document.activeElement === node;
+      const inOverlay = Boolean(node.closest('[role="dialog"], dialog, [aria-modal="true"]'));
+      let depth = 0;
+      for (let parent = node.parentElement; parent && depth < 12; parent = parent.parentElement) depth += 1;
+      const control = {
+        index,
+        tag: allowed(node.tagName.toLowerCase(), ['button', 'input', 'select', 'textarea']) ?? 'other',
+        role: allowed(node.getAttribute('role'), ['button', 'combobox', 'dialog', 'listbox', 'menu', 'menuitem', 'option', 'radio', 'switch', 'tab']),
+        type: allowed(node.getAttribute('type'), ['button', 'checkbox', 'file', 'radio', 'reset', 'submit', 'text']),
+        visible,
+        disabled: node.disabled === true || node.getAttribute('aria-disabled') === 'true',
+        focused,
+        inOverlay,
+        expanded: state(node, 'aria-expanded'),
+        pressed: state(node, 'aria-pressed'),
+        checked: state(node, 'aria-checked'),
+        selected: state(node, 'aria-selected'),
+        popup: allowed(node.getAttribute('aria-haspopup'), ['true', 'false', 'menu', 'listbox', 'tree', 'grid', 'dialog']),
+        modal: state(node, 'aria-modal'),
+        depth,
+        childControls: Math.min(node.querySelectorAll(selector).length, ${MAX_CONTROLS}),
+      };
+      return { control, score: (focused ? 4 : 0) + (inOverlay ? 2 : 0) + (visible ? 1 : 0) };
+    }).sort((a, b) => b.score - a.score || a.control.index - b.control.index)
+      .slice(0, ${MAX_CONTROLS}).map(({ control }) => control);
+    return { matchedControls: nodes.length, truncated: nodes.length > ${MAX_CONTROLS}, controls };
+  })()`;
+}
+export async function logDomFailure(Runtime, logger, context) {
+    if (!logger?.verbose)
+        return;
+    try {
+        const { result } = await Runtime.evaluate({
+            expression: buildDomControlInventoryExpression(),
+            returnByValue: true,
+        });
+        const value = result.value;
+        const inventory = {
+            context: context.slice(0, 64),
+            matchedControls: Number.isSafeInteger(value?.matchedControls) ? value.matchedControls : 0,
+            truncated: value?.truncated === true,
+            controls: Array.isArray(value?.controls) ? value.controls.slice(0, MAX_CONTROLS) : [],
+        };
+        let json = JSON.stringify(inventory);
+        while (new TextEncoder().encode(json).byteLength > MAX_JSON_BYTES &&
+            inventory.controls.length) {
+            inventory.controls.pop();
+            inventory.truncated = true;
+            json = JSON.stringify(inventory);
+        }
+        logger(json);
+    }
+    catch {
+        // Diagnostics must not replace the original browser failure.
+    }
+}

package/dist/src/browser/errors.js

@@ -0,0 +1,20 @@
+export class AssistantStoppedError extends Error {
+    turnIndex;
+    constructor(turnIndex) {
+        super("ChatGPT stopped without an answer. Choose another resume or a full retry.");
+        this.turnIndex = turnIndex;
+        this.name = "AssistantStoppedError";
+    }
+}
+export class BrowserAutomationError extends Error {
+    category = "browser-automation";
+    details;
+    constructor(message, details, cause) {
+        super(message);
+        this.name = "BrowserAutomationError";
+        this.details = details;
+        if (cause) {
+            this.cause = cause;
+        }
+    }
+}

package/dist/src/browser/format.js

@@ -0,0 +1,16 @@
+export function formatElapsed(ms) {
+    if (ms >= 60 * 60 * 1000) {
+        const hours = Math.floor(ms / (60 * 60 * 1000));
+        const minutes = Math.floor((ms % (60 * 60 * 1000)) / (60 * 1000));
+        return `${hours}h ${minutes}m`;
+    }
+    if (ms >= 60 * 1000) {
+        const minutes = Math.floor(ms / (60 * 1000));
+        const seconds = Math.floor((ms % (60 * 1000)) / 1000);
+        return `${minutes}m ${seconds}s`;
+    }
+    if (ms >= 1000) {
+        return `${Math.floor(ms / 1000)}s`;
+    }
+    return `${Math.round(ms)}ms`;
+}