codex-market-app/electron/lib/codex_desktop.js

"use strict";

const fs = require("fs");
const os = require("os");
const path = require("path");
const { execFile, execFileSync } = require("child_process");

const EXE_NAMES = process.platform === "win32"
  ? ["ChatGPT.exe", "Codex.exe", "OpenAI ChatGPT.exe", "ChatGPT Desktop.exe", "Codex Desktop.exe"]
  : ["ChatGPT", "Codex"];

const WIN_PROCESS_NAMES = EXE_NAMES.filter((n) => /\.exe$/i.test(n));
let lastDiscovery = null;

const GLOBAL_DICTATION_HIDE_SCRIPT = `
set hiddenCount to 0
tell application "System Events"
  set targetProcesses to every process whose name is "ChatGPT" or name is "Codex"
  repeat with p in targetProcesses
    tell p
      repeat with w in windows
        try
          set titleText to title of w as text
          set roleText to role of w as text
          set subroleText to subrole of w as text
          set windowSize to size of w
          set widthValue to item 1 of windowSize as integer
          set heightValue to item 2 of windowSize as integer
          if titleText is "Codex" and roleText is "AXWindow" and subroleText is "AXDialog" and widthValue >= 500 and widthValue <= 900 and heightValue >= 60 and heightValue <= 120 then
            set position of w to {-10000, -10000}
            set hiddenCount to hiddenCount + 1
          end if
        end try
      end repeat
    end tell
  end repeat
end tell
return hiddenCount
`;

function existsFile(p) {
  try {
    return !!p && fs.statSync(p).isFile();
  } catch {
    return false;
  }
}

function isWindowsPackagedPath(p) {
  return process.platform === "win32" && /[\\/]WindowsApps[\\/]|[\\/]Program Files[\\/]WindowsApps[\\/]/i.test(String(p || ""));
}

function isOwnWindowsAppCandidate(name, appId) {
  const hay = [name, appId].filter(Boolean).join(" ");
  return /tokendun|codexmarket|codex-market|td工具箱|td toolbox|插件市场|技能市场/i.test(hay);
}

function isOpenAiDesktopCandidate(name, appId) {
  if (isOwnWindowsAppCandidate(name, appId)) return false;
  const n = String(name || "").trim();
  const hay = [name, appId].filter(Boolean).join(" ");
  return /openai|chatgpt/i.test(hay) || /(^|[^a-z])codex([^a-z]|$)/i.test(n);
}

function addCandidate(out, seen, label, p, opts = {}) {
  if (!p) return;
  if (opts.launchType === "appId") {
    const appId = String(opts.appId || p || "").trim();
    if (!appId || isOwnWindowsAppCandidate(opts.name || "", appId)) return;
    const key = "appid:" + appId.toLowerCase();
    if (seen.has(key)) return;
    seen.add(key);
    out.push({ label, path: appId, appId, name: opts.name || "", launchType: "appId", packaged: true });
    return;
  }
  let abs = "";
  try {
    abs = path.resolve(p);
  } catch {
    return;
  }
  const key = process.platform === "win32" ? abs.toLowerCase() : abs;
  if (seen.has(key) || !existsFile(abs)) return;
  seen.add(key);
  out.push({
    label,
    path: abs,
    launchType: opts.launchType || "exe",
    packaged: !!opts.packaged || isWindowsPackagedPath(abs),
  });
}

function addChecked(report, p) {
  if (!report || !p) return;
  try {
    report.checkedPaths.push(path.resolve(p));
  } catch {}
}

function shouldScanDir(name, depth) {
  if (!name) return false;
  if (/^(programs)$/i.test(name)) return true;
  if (/codex|chatgpt|openai/i.test(name)) return true;
  return depth === 0 && process.platform !== "win32";
}

function scanDirForExecutables(base, out, seen, opts = {}) {
  const maxDepth = opts.maxDepth == null ? 4 : opts.maxDepth;
  const maxEntries = opts.maxEntries == null ? 400 : opts.maxEntries;
  const maxHits = opts.maxHits == null ? 12 : opts.maxHits;
  const report = opts.report || null;
  const targetNames = new Set(EXE_NAMES.map((n) => process.platform === "win32" ? n.toLowerCase() : n));
  let visited = 0;
  if (report && base) report.scannedRoots.push(base);

  function walk(dir, depth) {
    if (!dir || depth > maxDepth || out.length >= maxHits || visited >= maxEntries) return;
    let entries;
    try {
      entries = fs.readdirSync(dir, { withFileTypes: true });
    } catch {
      return;
    }
    visited += entries.length;
    for (const ent of entries) {
      if (out.length >= maxHits) return;
      const full = path.join(dir, ent.name);
      const entName = process.platform === "win32" ? ent.name.toLowerCase() : ent.name;
      if (ent.isFile() && targetNames.has(entName)) {
        addCandidate(out, seen, "ChatGPT/Codex 桌面程序（扫描）", full);
        continue;
      }
      if (ent.isDirectory() && depth < maxDepth && shouldScanDir(ent.name, depth)) {
        walk(full, depth + 1);
      }
    }
  }

  walk(base, 0);
}

function psJson(script, timeout = 3500) {
  if (process.platform !== "win32") return null;
  const shells = ["powershell.exe", "pwsh.exe"];
  for (const shell of shells) {
    try {
      const out = execFileSync(shell, ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", script], {
        encoding: "utf-8",
        windowsHide: true,
        timeout,
      }).trim();
      if (!out) return null;
      return JSON.parse(out);
    } catch {}
  }
  return null;
}

function resolveWindowsShortcut(lnkPath) {
  if (process.platform !== "win32" || !lnkPath) return null;
  const script = [
    "$p=$env:TD_LNK_PATH",
    "$s=(New-Object -ComObject WScript.Shell).CreateShortcut($p)",
    "$o=[pscustomobject]@{TargetPath=$s.TargetPath;Arguments=$s.Arguments;WorkingDirectory=$s.WorkingDirectory}",
    "$o|ConvertTo-Json -Compress",
  ].join(";");
  const shells = ["powershell.exe", "pwsh.exe"];
  for (const shell of shells) {
    try {
      const out = execFileSync(shell, ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", script], {
        encoding: "utf-8",
        env: { ...process.env, TD_LNK_PATH: lnkPath },
        windowsHide: true,
        timeout: 2500,
      }).trim();
      if (!out) return null;
      return JSON.parse(out);
    } catch {}
  }
  return null;
}

function collectWindowsShortcuts(base, out, opts = {}) {
  if (process.platform !== "win32" || !base) return;
  const maxDepth = opts.maxDepth == null ? 5 : opts.maxDepth;
  const maxEntries = opts.maxEntries == null ? 900 : opts.maxEntries;
  const maxHits = opts.maxHits == null ? 24 : opts.maxHits;
  let visited = 0;

  function walk(dir, depth) {
    if (!dir || depth > maxDepth || out.length >= maxHits || visited >= maxEntries) return;
    let entries;
    try {
      entries = fs.readdirSync(dir, { withFileTypes: true });
    } catch {
      return;
    }
    visited += entries.length;
    for (const ent of entries) {
      if (out.length >= maxHits) return;
      const full = path.join(dir, ent.name);
      if (ent.isFile() && /\.lnk$/i.test(ent.name) && /codex|chatgpt|openai/i.test(ent.name)) {
        out.push(full);
        continue;
      }
      if (ent.isDirectory() && depth < maxDepth && shouldScanDir(ent.name, depth)) {
        walk(full, depth + 1);
      }
    }
  }

  walk(base, 0);
}

function addSquirrelShortcutTargets(out, seen, report, shortcut, targetPath, args) {
  if (!targetPath || !/update\.exe$/i.test(path.basename(targetPath || ""))) return;
  const m = String(args || "").match(/--processStart\s+(?:"([^"]+)"|([^\s]+))/i);
  const exeName = (m && (m[1] || m[2])) || "";
  if (!exeName || !/\.exe$/i.test(exeName)) return;
  const root = path.dirname(targetPath);
  let entries = [];
  try {
    entries = fs.readdirSync(root, { withFileTypes: true });
  } catch {
    return;
  }
  const appDirs = entries
    .filter((ent) => ent.isDirectory() && /^app-/i.test(ent.name))
    .map((ent) => path.join(root, ent.name))
    .sort()
    .reverse();
  for (const dir of appDirs) {
    const exe = path.join(dir, exeName);
    addChecked(report, exe);
    addCandidate(out, seen, "ChatGPT/Codex 桌面程序（开始菜单快捷方式）", exe);
  }
  if (report) report.shortcutTargets.push({ shortcut, targetPath, args: args || "", inferred: exeName });
}

function addWindowsShortcutCandidates(out, seen, report, roots) {
  const shortcuts = [];
  for (const root of roots.filter(Boolean)) collectWindowsShortcuts(root, shortcuts);
  for (const lnk of shortcuts) {
    if (report) report.shortcuts.push(lnk);
    const resolved = resolveWindowsShortcut(lnk);
    if (!resolved) continue;
    const targetPath = resolved.TargetPath || resolved.targetPath || "";
    const args = resolved.Arguments || resolved.arguments || "";
    if (report) report.shortcutTargets.push({ shortcut: lnk, targetPath, args });
    if (targetPath && /\.exe$/i.test(targetPath) && !/update\.exe$/i.test(path.basename(targetPath))) {
      addChecked(report, targetPath);
      addCandidate(out, seen, "ChatGPT/Codex 桌面程序（开始菜单快捷方式）", targetPath);
      continue;
    }
    addSquirrelShortcutTargets(out, seen, report, lnk, targetPath, args);
  }
}

function addWindowsAppxCandidates(out, seen, report) {
  const script = [
    "$startApps=Get-StartApps | Where-Object { $_.Name -match 'ChatGPT|Codex|OpenAI' -or $_.AppID -match 'ChatGPT|Codex|OpenAI' }",
    "$startRows=@()",
    "foreach($a in $startApps){ $startRows += [pscustomobject]@{Name=$a.Name;AppID=$a.AppID} }",
    "$pkgs=Get-AppxPackage | Where-Object { $_.Name -match 'ChatGPT|Codex|OpenAI' -or $_.PackageFullName -match 'ChatGPT|Codex|OpenAI' }",
    "$rows=@()",
    "$appIds=@()",
    "foreach($p in $pkgs){",
    "  $loc=$p.InstallLocation",
    "  if($loc){",
    "    $manifestPath=Join-Path $loc 'AppxManifest.xml'",
    "    if(Test-Path -LiteralPath $manifestPath){",
    "      try{",
    "        [xml]$manifest=Get-Content -LiteralPath $manifestPath -ErrorAction Stop",
    "        foreach($app in @($manifest.Package.Applications.Application)){",
    "          $id=[string]$app.Id",
    "          if($id){ $appIds += [pscustomobject]@{Package=$p.Name;Family=$p.PackageFamilyName;AppID=($p.PackageFamilyName + '!' + $id);InstallLocation=$loc} }",
    "        }",
    "      }catch{}",
    "    }",
    "    $exes=Get-ChildItem -LiteralPath $loc -Recurse -Filter *.exe -ErrorAction SilentlyContinue | Where-Object { $_.Name -match 'ChatGPT|Codex|OpenAI' } | Select-Object -First 8",
    "    foreach($e in $exes){ $rows += [pscustomobject]@{Package=$p.Name;Path=$e.FullName} }",
    "  }",
    "}",
    "[pscustomobject]@{StartApps=$startRows;Packages=$rows;AppIds=$appIds}|ConvertTo-Json -Depth 5 -Compress",
  ].join(";");
  const data = psJson(script, 6500);
  const startApps = data && data.StartApps ? (Array.isArray(data.StartApps) ? data.StartApps : [data.StartApps]) : [];
  const arr = data && data.Packages ? (Array.isArray(data.Packages) ? data.Packages : [data.Packages]) : [];
  const appIds = data && data.AppIds ? (Array.isArray(data.AppIds) ? data.AppIds : [data.AppIds]) : [];
  for (const app of startApps) {
    const appId = app && app.AppID ? String(app.AppID) : "";
    const name = app && app.Name ? String(app.Name) : "";
    if (!appId || !isOpenAiDesktopCandidate(name, appId)) continue;
    if (report) report.appx.push({ package: "StartApps", name: app.Name || "", appId });
    addCandidate(out, seen, "ChatGPT/Codex 桌面程序（开始菜单 AppID）", appId, {
      launchType: "appId",
      appId,
      name,
      packaged: true,
    });
  }
  for (const app of appIds) {
    const appId = app && app.AppID ? String(app.AppID) : "";
    const name = app && app.Package ? String(app.Package) : "";
    if (!appId || !isOpenAiDesktopCandidate(name, appId)) continue;
    if (report) report.appx.push({ package: name, family: app.Family || "", appId, manifest: true });
    addCandidate(out, seen, "ChatGPT/Codex 桌面程序（MSIX AppID）", appId, {
      launchType: "appId",
      appId,
      name,
      packaged: true,
    });
  }
  for (const row of arr) {
    const p = row && row.Path ? String(row.Path) : "";
    if (report && row) report.appx.push({ package: row.Package || "", path: p });
    addChecked(report, p);
    // Program Files\WindowsApps 里的包内 exe 通常不能被普通进程直接启动；
    // 只记录诊断，不当作启动候选，避免弹系统错误框。
    if (p && !isWindowsPackagedPath(p)) {
      addCandidate(out, seen, "ChatGPT/Codex 桌面程序（Microsoft Store/MSIX）", p);
    }
  }
}

function desktopExecutableCandidates() {
  const home = os.homedir();
  const out = [];
  const seen = new Set();
  const report = {
    platform: process.platform,
    checkedPaths: [],
    scannedRoots: [],
    shortcuts: [],
    shortcutTargets: [],
    appx: [],
    candidates: [],
  };

  if (process.platform === "darwin") {
    [
      path.join(home, "Applications/ChatGPT.app/Contents/MacOS/ChatGPT"),
      "/Applications/ChatGPT.app/Contents/MacOS/ChatGPT",
      path.join(home, "Applications/Codex.app/Contents/MacOS/Codex"),
      "/Applications/Codex.app/Contents/MacOS/Codex",
    ].forEach((p) => {
      addChecked(report, p);
      addCandidate(out, seen, "ChatGPT/Codex 桌面程序", p);
    });
    const sorted = sortCandidates(out);
    lastDiscovery = { ...report, candidates: sorted };
    return sorted;
  }

  if (process.platform === "win32") {
    const local = process.env.LOCALAPPDATA || path.join(home, "AppData", "Local");
    const appdata = process.env.APPDATA || path.join(home, "AppData", "Roaming");
    const programData = process.env.ProgramData || "C:\\ProgramData";
    const pf = process.env.ProgramFiles || "C:\\Program Files";
    const pf86 = process.env["ProgramFiles(x86)"] || "";
    const windowsApps = path.join(local, "Microsoft", "WindowsApps");
    const userStartMenu = path.join(appdata, "Microsoft", "Windows", "Start Menu", "Programs");
    const systemStartMenu = path.join(programData, "Microsoft", "Windows", "Start Menu", "Programs");
    const known = [
      [local, "Programs", "ChatGPT", "ChatGPT.exe"],
      [local, "Programs", "OpenAI", "ChatGPT", "ChatGPT.exe"],
      [local, "Programs", "OpenAI ChatGPT", "ChatGPT.exe"],
      [local, "Programs", "ChatGPT Desktop", "ChatGPT.exe"],
      [local, "ChatGPT", "ChatGPT.exe"],
      [local, "OpenAI", "ChatGPT", "ChatGPT.exe"],
      [local, "OpenAI", "ChatGPT", "bin", "ChatGPT.exe"],
      [pf, "ChatGPT", "ChatGPT.exe"],
      [pf, "OpenAI", "ChatGPT", "ChatGPT.exe"],
      [pf, "OpenAI ChatGPT", "ChatGPT.exe"],
      pf86 && [pf86, "ChatGPT", "ChatGPT.exe"],
      pf86 && [pf86, "OpenAI", "ChatGPT", "ChatGPT.exe"],
      [local, "OpenAI", "Codex", "bin", "Codex.exe"],
      [local, "Programs", "Codex", "Codex.exe"],
      [local, "Programs", "codex", "Codex.exe"],
      [local, "Programs", "OpenAI Codex", "Codex.exe"],
      [local, "Programs", "Codex Desktop", "Codex.exe"],
      [local, "Codex", "Codex.exe"],
      [pf, "Codex", "Codex.exe"],
      [pf, "OpenAI Codex", "Codex.exe"],
      pf86 && [pf86, "Codex", "Codex.exe"],
    ].filter(Boolean);
    for (const parts of known) {
      const p = path.join(...parts);
      addChecked(report, p);
      addCandidate(out, seen, "ChatGPT/Codex 桌面程序", p);
    }
    for (const p of [path.join(windowsApps, "ChatGPT.exe"), path.join(windowsApps, "Codex.exe")]) {
      addChecked(report, p);
      if (existsFile(p)) {
        report.appx.push({ package: "WindowsApps alias", path: path.resolve(p) });
        addCandidate(out, seen, "ChatGPT/Codex 桌面程序（WindowsApps 别名）", p, {
          launchType: "alias",
          packaged: true,
        });
      }
    }
    addWindowsShortcutCandidates(out, seen, report, [userStartMenu, systemStartMenu]);
    addWindowsAppxCandidates(out, seen, report);
    for (const base of [path.join(local, "Programs"), local, pf, pf86, windowsApps].filter(Boolean)) {
      scanDirForExecutables(base, out, seen, { maxDepth: 5, maxEntries: 1600, maxHits: 24, report });
    }
    const sorted = sortCandidates(out);
    lastDiscovery = { ...report, candidates: sorted };
    return sorted;
  }

  lastDiscovery = { ...report, candidates: out };
  return out;
}

function sortCandidates(items) {
  return [...items].sort((a, b) => scoreCandidate(b.path) - scoreCandidate(a.path));
}

function scoreCandidate(p) {
  let score = 0;
  if (/chatgpt/i.test(path.basename(p))) score += 100;
  if (/codex/i.test(path.basename(p))) score += 50;
  if (isWindowsPackagedPath(p)) score -= 1000;
  if (/localappdata|AppData[\\/]Local|Applications/i.test(p)) score += 10;
  if (/programs/i.test(p)) score += 5;
  return score;
}

function codexExecutable() {
  const first = desktopExecutableCandidates().find((item) => !item.packaged);
  return first ? first.path : "";
}

function discoveryReport() {
  return lastDiscovery || {
    platform: process.platform,
    checkedPaths: [],
    scannedRoots: [],
    shortcuts: [],
    shortcutTargets: [],
    appx: [],
    candidates: [],
  };
}

function discoverySummary() {
  const r = discoveryReport();
  const parts = [];
  if (r.checkedPaths && r.checkedPaths.length) parts.push(`固定路径 ${r.checkedPaths.length} 个`);
  if (r.scannedRoots && r.scannedRoots.length) parts.push(`目录扫描 ${r.scannedRoots.length} 处`);
  if (r.shortcuts && r.shortcuts.length) parts.push(`快捷方式 ${r.shortcuts.length} 个`);
  if (r.appx && r.appx.length) parts.push(`Store/MSIX 线索 ${r.appx.length} 个`);
  if (r.candidates && r.candidates.length) parts.push(`命中 ${r.candidates.length} 个`);
  return parts.join("，");
}

function codexRunning() {
  try {
    if (process.platform === "darwin") {
      return execFileSync("pgrep", ["-f", "(Codex.app/Contents/MacOS/Codex|ChatGPT.app/Contents/MacOS/ChatGPT)"], { encoding: "utf-8" }).trim().length > 0;
    }
    if (process.platform === "win32") {
      return windowsProcessRows().length > 0;
    }
  } catch {
    return false;
  }
  return false;
}

function execFileText(file, args, options = {}) {
  return new Promise((resolve, reject) => {
    execFile(file, args, {
      encoding: "utf-8",
      windowsHide: true,
      timeout: options.timeout === undefined
        ? 2200
        : Math.max(1, Number(options.timeout) || 1),
      signal: options.signal,
      env: options.env || process.env,
    }, (error, stdout) => {
      if (error) {
        error.stdout = stdout || error.stdout || "";
        reject(error);
        return;
      }
      resolve(String(stdout || ""));
    });
  });
}

function isCodexProcessCommand(command) {
  const text = String(command || "").replace(/\s+/g, " ").trim();
  if (!text || isOwnWindowsAppCandidate(text, "")) return false;
  return /(?:^|[\\/])(?:Codex|ChatGPT)\.app[\\/]/i.test(text) ||
    /(?:^|[\\/\s])(?:Codex|ChatGPT)(?:\.exe)?(?:\s|$)/i.test(text) ||
    /WindowsApps[\\/]OpenAI\.(?:Codex|CodexBeta|ChatGPT-Desktop)_/i.test(text);
}

function hideGlobalDictationWindows(options = {}) {
  if (process.platform !== "darwin") {
    return Promise.resolve({
      ok: false,
      status: "unsupported-platform",
      hidden: 0,
      error: "native global dictation window cleanup is only available on macOS",
    });
  }

  const run = options.execFile || execFile;
  return new Promise((resolve) => {
    run("osascript", ["-e", GLOBAL_DICTATION_HIDE_SCRIPT], {
      encoding: "utf-8",
      windowsHide: true,
      timeout: Math.max(500, Number(options.timeoutMs) || 5000),
      signal: options.signal,
    }, (error, stdout, stderr) => {
      const output = String(stdout || "").trim();
      const hidden = /^\d+$/.test(output) ? Number(output) : 0;
      if (error) {
        resolve({
          ok: false,
          status: "native-command-failed",
          hidden,
          error: String((error && error.message) || stderr || error),
        });
        return;
      }
      resolve({
        ok: true,
        status: hidden ? "hidden" : "not-found",
        hidden,
        error: "",
      });
    });
  });
}

async function debugPortOwner(port, options = {}) {
  const value = Number(port);
  if (!Number.isInteger(value) || value < 1 || value > 65535) {
    return { verified: false, owned: false, reason: "invalid-port", processes: [] };
  }
  const signal = options.signal;
  const totalTimeoutMs = Math.max(1, Number(options.timeoutMs) || 5000);
  const deadline = Date.now() + totalTimeoutMs;
  const commandOptions = (maxMs) => {
    if (signal && signal.aborted) {
      throw signal.reason instanceof Error ? signal.reason : new Error("debug port owner check aborted");
    }
    const remaining = deadline - Date.now();
    if (remaining <= 0) {
      const error = new Error("debug port owner check timed out");
      error.code = "ETIMEDOUT";
      throw error;
    }
    return {
      timeout: Math.max(1, Math.min(maxMs, remaining)),
      signal,
    };
  };

  if (process.platform === "darwin") {
    try {
      const output = await execFileText("lsof", [
        "-nP",
        "-a",
        `-iTCP:${value}`,
        "-sTCP:LISTEN",
        "-Fp",
      ], commandOptions(2200));
      const pids = [...new Set(
        output.split(/\r?\n/).filter((line) => /^p\d+$/.test(line)).map((line) => line.slice(1)),
      )];
      const processes = [];
      for (const pid of pids) {
        try {
          const command = (await execFileText(
            "ps",
            ["-p", pid, "-o", "command="],
            commandOptions(2200),
          )).trim();
          processes.push({ pid: Number(pid), command });
        } catch {}
      }
      return {
        verified: true,
        owned: processes.some((item) => isCodexProcessCommand(item.command)),
        reason: processes.length ? "process-inspected" : "listener-not-found",
        processes,
      };
    } catch (e) {
      return {
        verified: false,
        owned: false,
        reason: String((e && e.message) || e),
        processes: [],
      };
    }
  }

  if (process.platform === "win32") {
    const script = [
      "$port=[int]$env:TD_CODEX_DEBUG_PORT",
      "$rows=@()",
      "Get-NetTCPConnection -State Listen -LocalPort $port -ErrorAction SilentlyContinue | ForEach-Object {",
      "  $p=Get-CimInstance Win32_Process -Filter ('ProcessId=' + $_.OwningProcess) -ErrorAction SilentlyContinue",
      "  if($p){ $rows += [pscustomobject]@{ProcessId=$p.ProcessId;Name=$p.Name;ExecutablePath=$p.ExecutablePath;CommandLine=$p.CommandLine} }",
      "}",
      "$rows|ConvertTo-Json -Depth 4 -Compress",
    ].join(";");
    for (const shell of ["powershell.exe", "pwsh.exe"]) {
      try {
        const output = (await execFileText(shell, [
          "-NoProfile",
          "-ExecutionPolicy",
          "Bypass",
          "-Command",
          script,
        ], {
          ...commandOptions(3500),
          env: { ...process.env, TD_CODEX_DEBUG_PORT: String(value) },
        })).trim();
        const parsed = output ? JSON.parse(output) : [];
        const rows = Array.isArray(parsed) ? parsed : [parsed];
        const processes = rows.map((row) => ({
          pid: Number(row.ProcessId) || 0,
          command: [row.Name, row.ExecutablePath, row.CommandLine].filter(Boolean).join(" "),
        }));
        return {
          verified: true,
          owned: processes.some((item) => isCodexProcessCommand(item.command)),
          reason: processes.length ? "process-inspected" : "listener-not-found",
          processes,
        };
      } catch {}
    }
    return { verified: false, owned: false, reason: "process-inspection-failed", processes: [] };
  }

  return { verified: false, owned: false, reason: "unsupported-platform", processes: [] };
}

function windowsProcessRows() {
  if (process.platform !== "win32") return [];
  const escapedNames = WIN_PROCESS_NAMES.map((name) => "'" + name.replace(/'/g, "''") + "'").join(",");
  const script = [
    `$names=@(${escapedNames})`,
    "$pkg='WindowsApps\\\\OpenAI\\.(Codex|CodexBeta|ChatGPT-Desktop)_'",
    "$rows=Get-CimInstance Win32_Process | Where-Object { $names -contains $_.Name -or ($_.ExecutablePath -match $pkg) -or ($_.CommandLine -match $pkg) } | ForEach-Object {",
    "  [pscustomobject]@{Name=$_.Name;ProcessId=$_.ProcessId;ExecutablePath=$_.ExecutablePath;CommandLine=$_.CommandLine}",
    "}",
    "$rows|ConvertTo-Json -Depth 4 -Compress",
  ].join(";");
  const data = psJson(script, 4500);
  if (!data) return [];
  return Array.isArray(data) ? data : [data];
}

function windowsProcessDiagnostics(port) {
  const rows = windowsProcessRows();
  const portRe = new RegExp("--remote-debugging-port(?:=|\\s+)" + String(port || ""), "i");
  const hasDebugArg = rows.some((row) => portRe.test(String((row && row.CommandLine) || "")));
  const summary = rows.map((row) => {
    const cmd = String((row && row.CommandLine) || "").replace(/\s+/g, " ").slice(0, 260);
    const name = (row && row.Name) || "process";
    const pid = (row && row.ProcessId) || "?";
    return `${name}#${pid}${cmd ? " " + cmd : ""}`;
  }).join(" | ");
  return { rows, hasDebugArg, summary };
}

function waitForCodexExit(maxMs = 9000) {
  return new Promise((resolve) => {
    const t0 = Date.now();
    const tick = () => {
      if (!codexRunning()) {
        resolve(true);
        return;
      }
      if (Date.now() - t0 >= maxMs) {
        resolve(false);
        return;
      }
      setTimeout(tick, 300);
    };
    tick();
  });
}

function killCodex() {
  return new Promise((resolve) => {
    if (process.platform === "darwin") {
      execFile("osascript", ["-e", 'tell application "Codex" to quit', "-e", 'tell application "ChatGPT" to quit'], () => {
        execFile("pkill", ["-f", "(Codex.app/Contents/MacOS/Codex|ChatGPT.app/Contents/MacOS/ChatGPT)"], () => {
          waitForCodexExit(12000).then((exited) => resolve({ exited }));
        });
      });
      return;
    }
    if (process.platform === "win32") {
      let pending = WIN_PROCESS_NAMES.length;
      const done = () => {
        pending -= 1;
        if (pending <= 0) {
          waitForCodexExit(9000).then((ok) => {
            if (!ok) {
              try {
                execFileSync("powershell.exe", [
                  "-NoProfile", "-ExecutionPolicy", "Bypass", "-Command",
                  "$pkg='WindowsApps\\\\OpenAI\\.(Codex|CodexBeta|ChatGPT-Desktop)_'; Get-CimInstance Win32_Process | Where-Object { @('ChatGPT.exe','Codex.exe','OpenAI ChatGPT.exe','ChatGPT Desktop.exe','Codex Desktop.exe') -contains $_.Name -or ($_.ExecutablePath -match $pkg) -or ($_.CommandLine -match $pkg) } | ForEach-Object { Stop-Process -Id $_.ProcessId -Force -ErrorAction SilentlyContinue }",
                ], { windowsHide: true, timeout: 3500 });
              } catch {}
            }
            waitForCodexExit(5000).then((exited) => resolve({ exited }));
          });
        }
      };
      for (const name of WIN_PROCESS_NAMES) execFile("taskkill", ["/IM", name, "/T", "/F"], done);
      return;
    }
    resolve({ exited: true });
  });
}

module.exports = {
  desktopExecutableCandidates,
  codexExecutable,
  isWindowsPackagedPath,
  discoveryReport,
  discoverySummary,
  codexRunning,
  debugPortOwner,
  hideGlobalDictationWindows,
  windowsProcessDiagnostics,
  killCodex,
};