tabctl 0.6.0-alpha.9 → 0.6.0-rc.10

package/dist/extension/lib/content.js

@@ -3,7 +3,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.delay = delay;
 exports.executeWithTimeout = executeWithTimeout;
+exports.executeWithTimeoutDetailed = executeWithTimeoutDetailed;
 exports.extractPageMeta = extractPageMeta;
+exports.extractPageMarkdown = extractPageMarkdown;
+exports.extractPageHtml = extractPageHtml;
+exports.probePageQuiescence = probePageQuiescence;
 exports.extractSelectorSignal = extractSelectorSignal;
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -32,6 +36,29 @@ async function executeWithTimeout(tabId, timeoutMs, func, args = []) {
         return null;
     }
 }
+async function executeWithTimeoutDetailed(tabId, timeoutMs, func, args = []) {
+    const execPromise = chrome.scripting.executeScript({
+        target: { tabId },
+        func,
+        args,
+    }).then((result) => {
+        if (!result || !Array.isArray(result)) {
+            return { kind: "ok", value: null };
+        }
+        const [{ result: value }] = result;
+        return { kind: "ok", value: value ?? null };
+    }).catch((err) => ({
+        kind: "error",
+        message: err instanceof Error ? err.message : String(err),
+    }));
+    const timeoutPromise = new Promise((resolve) => {
+        const handle = setTimeout(() => {
+            clearTimeout(handle);
+            resolve({ kind: "timeout" });
+        }, timeoutMs);
+    });
+    return Promise.race([execPromise, timeoutPromise]);
+}
 async function extractPageMeta(tabId, timeoutMs, descriptionMaxLength) {
     const result = await executeWithTimeout(tabId, timeoutMs, () => {
         const pickContent = (selector) => {
@@ -61,6 +88,186 @@ async function extractPageMeta(tabId, timeoutMs, descriptionMaxLength) {
         h1: (meta.h1 || "").slice(0, descriptionMaxLength),
     };
 }
+async function extractPageMarkdown(tabId, timeoutMs, maxHtmlChars) {
+    const result = await executeWithTimeout(tabId, timeoutMs, (cap) => {
+        const raw = document.documentElement?.outerHTML || "";
+        return raw.length > cap ? raw.slice(0, cap) : raw;
+    }, [maxHtmlChars]);
+    return typeof result === "string" ? result : "";
+}
+function injectionStatus(message) {
+    const lower = message.toLowerCase();
+    if (lower.includes("cannot access") || lower.includes("permission") || lower.includes("extensions gallery")) {
+        return "PROTECTED";
+    }
+    return "INJECTION_FAILED";
+}
+async function extractPageHtml(tabId, timeoutMs, maxHtmlChars) {
+    const result = await executeWithTimeoutDetailed(tabId, timeoutMs, (cap) => {
+        const raw = document.documentElement?.outerHTML || "";
+        const text = document.body?.innerText || document.documentElement?.textContent || "";
+        return {
+            html: raw.length > cap ? raw.slice(0, cap) : raw,
+            sourceHtmlChars: raw.length,
+            sourceTextChars: text.length,
+            documentReadyState: document.readyState,
+            truncatedHtml: raw.length > cap,
+        };
+    }, [maxHtmlChars]);
+    if (result.kind === "timeout") {
+        return {
+            status: "TIMED_OUT",
+            html: "",
+            sourceHtmlChars: 0,
+            sourceTextChars: 0,
+            documentReadyState: null,
+            truncatedHtml: false,
+            error: `Timed out after ${timeoutMs}ms`,
+        };
+    }
+    if (result.kind === "error") {
+        return {
+            status: injectionStatus(result.message),
+            html: "",
+            sourceHtmlChars: 0,
+            sourceTextChars: 0,
+            documentReadyState: null,
+            truncatedHtml: false,
+            error: result.message,
+        };
+    }
+    if (!result.value) {
+        return {
+            status: "EXTRACTION_FAILED",
+            html: "",
+            sourceHtmlChars: 0,
+            sourceTextChars: 0,
+            documentReadyState: null,
+            truncatedHtml: false,
+            error: "Content script returned no page HTML payload",
+        };
+    }
+    const status = result.value.documentReadyState === "loading" ? "NOT_LOADED" : "READ";
+    return {
+        status,
+        ...result.value,
+        error: null,
+    };
+}
+async function probePageQuiescence(tabId, timeoutMs, sampleWindowMs) {
+    const result = await executeWithTimeoutDetailed(tabId, timeoutMs, async (rawWindowMs) => {
+        const startedAt = Date.now();
+        const windowMs = Math.max(50, Math.min(Number(rawWindowMs) || 350, 1_500));
+        const htmlCap = 250_000;
+        const sample = () => {
+            const root = document.documentElement;
+            const bodyText = document.body?.innerText || root?.textContent || "";
+            const html = root?.outerHTML || "";
+            const resources = typeof performance !== "undefined" && typeof performance.getEntriesByType === "function"
+                ? performance.getEntriesByType("resource").length
+                : null;
+            return {
+                textChars: bodyText.length,
+                htmlChars: Math.min(html.length, htmlCap),
+                domElements: document.getElementsByTagName("*").length,
+                resourceCount: resources,
+            };
+        };
+        const waitForIdleWindow = () => new Promise((resolve) => {
+            const win = window;
+            const done = () => setTimeout(resolve, windowMs);
+            if (typeof win.requestIdleCallback === "function") {
+                let resolved = false;
+                const finish = () => {
+                    if (resolved) {
+                        return;
+                    }
+                    resolved = true;
+                    done();
+                };
+                const fallback = setTimeout(finish, windowMs + 100);
+                win.requestIdleCallback(() => {
+                    clearTimeout(fallback);
+                    finish();
+                }, { timeout: windowMs });
+                return;
+            }
+            setTimeout(resolve, windowMs);
+        });
+        try {
+            const readyState = document.readyState;
+            if (readyState !== "interactive" && readyState !== "complete") {
+                return {
+                    quiet: false,
+                    reason: "not-ready",
+                    documentReadyState: readyState,
+                    before: null,
+                    after: null,
+                    elapsedMs: Date.now() - startedAt,
+                    error: null,
+                };
+            }
+            const before = sample();
+            await waitForIdleWindow();
+            const after = sample();
+            const stable = before.textChars === after.textChars
+                && before.htmlChars === after.htmlChars
+                && before.domElements === after.domElements
+                && before.resourceCount === after.resourceCount;
+            return {
+                quiet: stable,
+                reason: stable ? "stable" : "changed",
+                documentReadyState: document.readyState,
+                before,
+                after,
+                elapsedMs: Date.now() - startedAt,
+                error: null,
+            };
+        }
+        catch (err) {
+            return {
+                quiet: false,
+                reason: "probe-error",
+                documentReadyState: typeof document !== "undefined" ? document.readyState : null,
+                before: null,
+                after: null,
+                elapsedMs: Date.now() - startedAt,
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }, [sampleWindowMs]);
+    if (result.kind === "timeout") {
+        return {
+            quiet: false,
+            reason: "timed-out",
+            documentReadyState: null,
+            before: null,
+            after: null,
+            elapsedMs: timeoutMs,
+            error: `Timed out after ${timeoutMs}ms`,
+        };
+    }
+    if (result.kind === "error") {
+        return {
+            quiet: false,
+            reason: "injection-error",
+            documentReadyState: null,
+            before: null,
+            after: null,
+            elapsedMs: 0,
+            error: result.message,
+        };
+    }
+    return result.value ?? {
+        quiet: false,
+        reason: "no-result",
+        documentReadyState: null,
+        before: null,
+        after: null,
+        elapsedMs: 0,
+        error: "Content script returned no quiescence probe payload",
+    };
+}
 async function extractSelectorSignal(tabId, specs, timeoutMs, selectorValueMaxLength) {
     if (!specs.length) {
         return null;
@@ -70,6 +277,9 @@ async function extractSelectorSignal(tabId, specs, timeoutMs, selectorValueMaxLe
         const missing = [];
         const errors = {};
         const hints = {};
+        const stringCap = typeof maxLen === "number" && maxLen > 0 ? maxLen : 500;
+        const htmlCap = typeof maxLen === "number" && maxLen > 0 ? maxLen : 4096;
+        const normalizeStringValue = (value, cap) => value.replace(/\s+/g, " ").trim().slice(0, cap);
         for (const raw of rawSpecs) {
             const selector = typeof raw.selector === "string" ? raw.selector : "";
             if (!selector) {
@@ -82,6 +292,9 @@ async function extractSelectorSignal(tabId, specs, timeoutMs, selectorValueMaxLe
             const textMode = typeof raw.textMode === "string" ? raw.textMode.trim().toLowerCase() : "";
             const normalizedTextMode = textMode === "includes" ? "contains" : textMode;
             const textModes = new Set(["", "contains", "exact", "starts-with"]);
+            const styleProps = Array.isArray(raw.styleProps)
+                ? raw.styleProps.filter((prop) => typeof prop === "string").map((prop) => prop.trim()).filter(Boolean)
+                : [];
             if (!textModes.has(normalizedTextMode)) {
                 errors[name] = `Unsupported textMode: ${textMode || "unknown"}`;
                 hints[name] = "Use textMode: contains | exact | starts-with";
@@ -89,16 +302,6 @@ async function extractSelectorSignal(tabId, specs, timeoutMs, selectorValueMaxLe
             }
             try {
                 const elements = Array.from(document.querySelectorAll(selector));
-                if (!elements.length) {
-                    missing.push(name);
-                    if (selector.includes(":contains(")) {
-                        hints[name] = "CSS :contains() is not supported; use selector text filters or a different selector.";
-                    }
-                    else {
-                        hints[name] = "No matches found; capture a screenshot for context or adjust the selector.";
-                    }
-                    continue;
-                }
                 const matchesText = (el) => {
                     if (!text) {
                         return true;
@@ -113,43 +316,103 @@ async function extractSelectorSignal(tabId, specs, timeoutMs, selectorValueMaxLe
                     return content.includes(text);
                 };
                 const filtered = text ? elements.filter(matchesText) : elements;
+                if (attr === "count") {
+                    values[name] = filtered.length;
+                    continue;
+                }
+                if (!elements.length) {
+                    missing.push(name);
+                    if (selector.includes(":contains(")) {
+                        hints[name] = "CSS :contains() is not supported; use selector text filters or a different selector.";
+                    }
+                    else {
+                        hints[name] = "No matches found; capture a screenshot for context or adjust the selector.";
+                    }
+                    continue;
+                }
                 if (!filtered.length) {
                     missing.push(name);
                     hints[name] = "Selector matched elements, but none matched the text filter; capture a screenshot for context or adjust text/textMode.";
                     continue;
                 }
                 const getValue = (el) => {
-                    let value = "";
                     if (attr === "text") {
-                        value = el.textContent || "";
+                        return normalizeStringValue(el.textContent || "", stringCap);
+                    }
+                    if (attr === "html") {
+                        return normalizeStringValue(el.outerHTML || "", htmlCap);
                     }
-                    else if (attr === "href-url" || attr === "src-url") {
+                    if (attr === "href-url" || attr === "src-url") {
                         const rawValue = el.getAttribute(attr === "href-url" ? "href" : "src") || "";
                         if (!rawValue) {
-                            value = "";
+                            return "";
                         }
-                        else {
-                            try {
-                                const resolved = new URL(rawValue, document.baseURI);
-                                if (resolved.protocol === "http:" || resolved.protocol === "https:") {
-                                    value = resolved.toString();
-                                }
-                                else {
-                                    value = "";
-                                }
-                            }
-                            catch {
-                                value = "";
+                        try {
+                            const resolved = new URL(rawValue, document.baseURI);
+                            if (resolved.protocol === "http:" || resolved.protocol === "https:") {
+                                return normalizeStringValue(resolved.toString(), stringCap);
                             }
+                            return "";
+                        }
+                        catch {
+                            return "";
                         }
                     }
-                    else {
-                        value = el.getAttribute(attr) || "";
+                    if (attr === "value") {
+                        if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement || el instanceof HTMLSelectElement) {
+                            return el.value;
+                        }
+                        return null;
+                    }
+                    if (attr === "box") {
+                        const rect = el.getBoundingClientRect();
+                        return {
+                            x: rect.x,
+                            y: rect.y,
+                            width: rect.width,
+                            height: rect.height,
+                            top: rect.top,
+                            right: rect.right,
+                            bottom: rect.bottom,
+                            left: rect.left,
+                        };
                     }
-                    return value.replace(/\s+/g, " ").trim().slice(0, maxLen);
+                    if (attr === "styles") {
+                        if (!styleProps.length) {
+                            return {};
+                        }
+                        const computed = window.getComputedStyle(el);
+                        const selected = {};
+                        for (const prop of styleProps) {
+                            selected[prop] = computed.getPropertyValue(prop);
+                        }
+                        return selected;
+                    }
+                    if (attr === "visible") {
+                        const computed = window.getComputedStyle(el);
+                        const rect = el.getBoundingClientRect();
+                        const styleVisible = computed.display !== "none" && computed.visibility !== "hidden" && computed.opacity !== "0";
+                        const hasRenderedBox = rect.width > 0 || rect.height > 0;
+                        return styleVisible && hasRenderedBox;
+                    }
+                    if (attr === "enabled") {
+                        const candidate = el;
+                        return candidate.disabled !== true && el.getAttribute("aria-disabled") !== "true";
+                    }
+                    if (attr === "checked") {
+                        if (el instanceof HTMLInputElement) {
+                            return el.checked;
+                        }
+                        return el.getAttribute("aria-checked") === "true";
+                    }
+                    return normalizeStringValue(el.getAttribute(attr) || "", stringCap);
                 };
+                if (attr === "box") {
+                    values[name] = getValue(filtered[0]);
+                    continue;
+                }
                 if (all) {
-                    values[name] = filtered.map(getValue).filter((val) => val.length > 0);
+                    values[name] = filtered.map(getValue).filter((val) => typeof val !== "string" || val.length > 0);
                 }
                 else {
                     values[name] = getValue(filtered[0]);

package/dist/extension/lib/screenshot.js

@@ -155,7 +155,15 @@ async function captureVisible(windowId, format, quality) {
     if (format === "jpeg") {
         options.quality = quality;
     }
-    return chrome.tabs.captureVisibleTab(windowId, options);
+    // Retry once after a short delay — headless Chrome on Windows can fail the
+    // first readback when the compositor hasn't fully initialised.
+    try {
+        return await chrome.tabs.captureVisibleTab(windowId, options);
+    }
+    catch {
+        await new Promise((r) => setTimeout(r, 500));
+        return chrome.tabs.captureVisibleTab(windowId, options);
+    }
 }
 async function getPageMetrics(tabId, timeoutMs, deps) {
     const result = await deps.executeWithTimeout(tabId, timeoutMs, () => {

package/dist/extension/manifest.json

@@ -19,5 +19,8 @@
   "background": {
     "service_worker": "background.js"
   },
-  "version_name": "0.6.0-alpha.9"
+  "action": {
+    "default_title": "Tab Control"
+  },
+  "version_name": "0.6.0-rc.10"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tabctl",
-  "version": "0.6.0-alpha.9",
+  "version": "0.6.0-rc.10",
   "description": "CLI tool to manage and analyze browser tabs",
   "license": "MIT",
   "repository": {
@@ -42,6 +42,7 @@
     "test": "npm run build && npm run rust:verify",
     "test:unit": "npm run rust:test",
     "test:integration": "cargo test --manifest-path rust/Cargo.toml --test browser_integration --test browser_coverage --test browser_primitives --test local_commands -- --ignored --nocapture --test-threads=1",
+    "test:smoke": "node scripts/smoke-test.js",
     "clean": "node -e \"fs.rmSync('dist',{recursive:true,force:true})\" ",
     "prepare": "git rev-parse --git-dir >/dev/null 2>&1 && git config core.hooksPath .githooks || true"
   },
@@ -52,7 +53,7 @@
     "typescript": "^5.4.5"
   },
   "optionalDependencies": {
-    "tabctl-win32-x64": "0.3.0"
+    "tabctl-win32-x64": "0.6.0-rc.10"
   },
   "dependencies": {
     "normalize-url": "^8.1.1"