tabctl 0.1.4 → 0.2.1

package/dist/extension/lib/content.js

@@ -0,0 +1,320 @@
+"use strict";
+// Content script execution utilities — extracted from background.ts (pure structural refactor).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SETTLE_POLL_INTERVAL_MS = exports.SETTLE_STABILITY_MS = void 0;
+exports.isScriptableUrl = isScriptableUrl;
+exports.delay = delay;
+exports.executeWithTimeout = executeWithTimeout;
+exports.isGitHubIssueOrPr = isGitHubIssueOrPr;
+exports.detectGitHubState = detectGitHubState;
+exports.extractPageMeta = extractPageMeta;
+exports.extractSelectorSignal = extractSelectorSignal;
+exports.waitForTabLoad = waitForTabLoad;
+exports.waitForDomReady = waitForDomReady;
+exports.waitForSettle = waitForSettle;
+exports.waitForTabReady = waitForTabReady;
+exports.SETTLE_STABILITY_MS = 500;
+exports.SETTLE_POLL_INTERVAL_MS = 50;
+function isScriptableUrl(url) {
+    return typeof url === "string" && (url.startsWith("http://") || url.startsWith("https://"));
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function executeWithTimeout(tabId, timeoutMs, func, args = []) {
+    const execPromise = chrome.scripting.executeScript({
+        target: { tabId },
+        func,
+        args,
+    });
+    const timeoutPromise = new Promise((resolve) => {
+        const handle = setTimeout(() => {
+            clearTimeout(handle);
+            resolve(null);
+        }, timeoutMs);
+    });
+    try {
+        const result = await Promise.race([execPromise, timeoutPromise]);
+        if (!result || !Array.isArray(result)) {
+            return null;
+        }
+        const [{ result: value }] = result;
+        return value ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function isGitHubIssueOrPr(url) {
+    if (!url) {
+        return false;
+    }
+    return /^https:\/\/github\.com\/[^/]+\/[^/]+\/(issues|pull)\/\d+/.test(url);
+}
+async function detectGitHubState(tabId, timeoutMs) {
+    const result = await executeWithTimeout(tabId, timeoutMs, () => {
+        const stateEl = document.querySelector(".gh-header-meta .State") ||
+            document.querySelector(".State") ||
+            document.querySelector(".js-issue-state");
+        if (!stateEl) {
+            return null;
+        }
+        const text = (stateEl.textContent || "").trim().toLowerCase();
+        if (text.includes("merged")) {
+            return "merged";
+        }
+        if (text.includes("closed")) {
+            return "closed";
+        }
+        if (text.includes("open")) {
+            return "open";
+        }
+        return null;
+    });
+    return typeof result === "string" ? result : null;
+}
+async function extractPageMeta(tabId, timeoutMs, descriptionMaxLength) {
+    const result = await executeWithTimeout(tabId, timeoutMs, () => {
+        const pickContent = (selector) => {
+            const el = document.querySelector(selector);
+            if (!el) {
+                return "";
+            }
+            const content = el.getAttribute("content") || el.textContent || "";
+            return content.trim();
+        };
+        const description = pickContent("meta[name='description']") ||
+            pickContent("meta[property='og:description']") ||
+            pickContent("meta[name='twitter:description']");
+        const h1 = document.querySelector("h1");
+        const h1Text = h1 ? h1.textContent?.trim() : "";
+        return {
+            description: description.replace(/\s+/g, " ").trim(),
+            h1: (h1Text || "").replace(/\s+/g, " ").trim(),
+        };
+    });
+    if (!result || typeof result !== "object") {
+        return null;
+    }
+    const meta = result;
+    return {
+        description: (meta.description || "").slice(0, descriptionMaxLength),
+        h1: (meta.h1 || "").slice(0, descriptionMaxLength),
+    };
+}
+async function extractSelectorSignal(tabId, specs, timeoutMs, selectorValueMaxLength) {
+    if (!specs.length) {
+        return null;
+    }
+    const result = await executeWithTimeout(tabId, timeoutMs, (rawSpecs, maxLen) => {
+        const values = {};
+        const missing = [];
+        const errors = {};
+        const hints = {};
+        for (const raw of rawSpecs) {
+            const selector = typeof raw.selector === "string" ? raw.selector : "";
+            if (!selector) {
+                continue;
+            }
+            const name = typeof raw.name === "string" && raw.name ? raw.name : selector;
+            const attr = typeof raw.attr === "string" ? raw.attr : "text";
+            const all = Boolean(raw.all);
+            const text = typeof raw.text === "string" ? raw.text.trim() : "";
+            const textMode = typeof raw.textMode === "string" ? raw.textMode.trim().toLowerCase() : "";
+            const normalizedTextMode = textMode === "includes" ? "contains" : textMode;
+            const textModes = new Set(["", "contains", "exact", "starts-with"]);
+            if (!textModes.has(normalizedTextMode)) {
+                errors[name] = `Unsupported textMode: ${textMode || "unknown"}`;
+                hints[name] = "Use textMode: contains | exact | starts-with";
+                continue;
+            }
+            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;
+                    }
+                    const content = (el.textContent || "").replace(/\s+/g, " ").trim();
+                    if (normalizedTextMode === "exact") {
+                        return content === text;
+                    }
+                    if (normalizedTextMode === "starts-with") {
+                        return content.startsWith(text);
+                    }
+                    return content.includes(text);
+                };
+                const filtered = text ? elements.filter(matchesText) : elements;
+                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 || "";
+                    }
+                    else if (attr === "href-url" || attr === "src-url") {
+                        const rawValue = el.getAttribute(attr === "href-url" ? "href" : "src") || "";
+                        if (!rawValue) {
+                            value = "";
+                        }
+                        else {
+                            try {
+                                const resolved = new URL(rawValue, document.baseURI);
+                                if (resolved.protocol === "http:" || resolved.protocol === "https:") {
+                                    value = resolved.toString();
+                                }
+                                else {
+                                    value = "";
+                                }
+                            }
+                            catch {
+                                value = "";
+                            }
+                        }
+                    }
+                    else {
+                        value = el.getAttribute(attr) || "";
+                    }
+                    return value.replace(/\s+/g, " ").trim().slice(0, maxLen);
+                };
+                if (all) {
+                    values[name] = filtered.map(getValue).filter((val) => val.length > 0);
+                }
+                else {
+                    values[name] = getValue(filtered[0]);
+                }
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : "selector_error";
+                errors[name] = message;
+                if (selector.includes(":contains(")) {
+                    hints[name] = "CSS :contains() is not supported; use selector text filters or a different selector.";
+                }
+                else {
+                    hints[name] = "Selector failed to evaluate; capture a screenshot for context or adjust the selector.";
+                }
+            }
+        }
+        return { values, missing, errors, hints };
+    }, [specs, selectorValueMaxLength]);
+    if (!result || typeof result !== "object") {
+        return null;
+    }
+    return result;
+}
+function waitForTabLoad(tabId, timeoutMs) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const done = () => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            chrome.tabs.onUpdated.removeListener(onUpdated);
+            resolve();
+        };
+        const onUpdated = (updatedTabId, info) => {
+            if (updatedTabId === tabId && info.status === "complete") {
+                done();
+            }
+        };
+        chrome.tabs.onUpdated.addListener(onUpdated);
+        chrome.tabs.get(tabId).then((tab) => {
+            if (tab.status === "complete") {
+                done();
+            }
+        }).catch(() => {
+            done();
+        });
+        setTimeout(done, timeoutMs);
+    });
+}
+async function waitForDomReady(tabId, timeoutMs) {
+    const result = await executeWithTimeout(tabId, timeoutMs, () => {
+        if (document.readyState === "interactive" || document.readyState === "complete") {
+            return true;
+        }
+        return new Promise((resolve) => {
+            const onReady = () => {
+                document.removeEventListener("DOMContentLoaded", onReady);
+                resolve(true);
+            };
+            document.addEventListener("DOMContentLoaded", onReady, { once: true });
+            setTimeout(() => {
+                document.removeEventListener("DOMContentLoaded", onReady);
+                resolve(false);
+            }, Math.max(0, timeoutMs - 50));
+        });
+    });
+    if (result === null) {
+        await delay(Math.min(200, Math.max(50, Math.floor(timeoutMs / 10))));
+    }
+}
+async function waitForSettle(tabId, timeoutMs) {
+    const startTime = Date.now();
+    let lastUrl = "";
+    let lastTitle = "";
+    let stableStart = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+        const tab = await chrome.tabs.get(tabId).catch(() => null);
+        if (!tab)
+            return;
+        const currentUrl = tab.url || "";
+        const currentTitle = tab.title || "";
+        // Reset stability timer if URL or title changed
+        if (currentUrl !== lastUrl || currentTitle !== lastTitle) {
+            lastUrl = currentUrl;
+            lastTitle = currentTitle;
+            stableStart = Date.now();
+        }
+        else if (isScriptableUrl(currentUrl) &&
+            tab.status === "complete" &&
+            Date.now() - stableStart >= exports.SETTLE_STABILITY_MS) {
+            // Page is loaded, URL is valid, and stable for long enough
+            return;
+        }
+        await delay(exports.SETTLE_POLL_INTERVAL_MS);
+    }
+    // Timeout reached, continue anyway
+}
+async function waitForTabReady(tabId, params, fallbackTimeoutMs) {
+    const waitFor = typeof params.waitFor === "string" ? params.waitFor.trim().toLowerCase() : "";
+    if (!waitFor || waitFor === "none") {
+        return;
+    }
+    const timeoutRaw = Number(params.waitTimeoutMs);
+    const timeoutMs = Number.isFinite(timeoutRaw) && timeoutRaw > 0 ? Math.floor(timeoutRaw) : fallbackTimeoutMs;
+    // settle mode handles its own URL checking, so skip the early return
+    if (waitFor === "settle") {
+        await waitForSettle(tabId, timeoutMs);
+        return;
+    }
+    try {
+        const tab = await chrome.tabs.get(tabId);
+        if (!isScriptableUrl(tab.url)) {
+            return;
+        }
+    }
+    catch {
+        return;
+    }
+    if (waitFor === "load") {
+        await waitForTabLoad(tabId, timeoutMs);
+        return;
+    }
+    if (waitFor === "dom") {
+        await waitForDomReady(tabId, timeoutMs);
+    }
+}

package/dist/extension/lib/deps.js

@@ -0,0 +1,4 @@
+"use strict";
+// Shared dependency interface for extension modules.
+// Each module uses Pick<ExtensionDeps, ...> to declare its actual requirements.
+Object.defineProperty(exports, "__esModule", { value: true });