@duanluan/codex-plus-plus-launcher 1.2.14 → 1.2.18

package/codex_plus_plus_launcher/__init__.py

@@ -1 +1,3 @@
-__version__ = "1.2.14"
+__version__ = "1.2.18"
+
+

package/codex_plus_plus_launcher/doctor.py

@@ -14,6 +14,8 @@ from codex_plus_plus_launcher.runtime import (
     legacy_auto_inject_state,
     load_install_state,
     runtime_paths,
+    shortcut_sidecar_install_root,
+    shortcut_sidecar_version,
 )
 
 
@@ -31,15 +33,34 @@ def find_codex_binary() -> str | None:
     return None
 
 
+def _sidecar_drift_value(installed: str | None, bundled: str | None) -> str:
+    """Compute the sidecar_drift status surfaced by doctor.
+
+    - "none": both versions are known and equal
+    - "mismatch:installed=X,bundled=Y": both known but different
+    - "unknown": either version is missing (older install / preflight running
+      from source tree without bundled sidecar)
+    """
+    if not installed or not bundled:
+        return "unknown"
+    if installed == bundled:
+        return "none"
+    return f"mismatch:installed={installed},bundled={bundled}"
+
+
 def doctor_report(paths: RuntimePaths | None = None) -> dict[str, str]:
     resolved_paths = paths or runtime_paths()
     installation = detect_codex_installation()
     state = load_install_state(resolved_paths)
 
+    bundled_version = bundled_upstream_version()
+    installed_sidecar_version = shortcut_sidecar_version()
+    sidecar_root = shortcut_sidecar_install_root()
+
     report = {
         "platform": sys.platform,
         "package_version": installed_package_version(),
-        "bundled_upstream_version": bundled_upstream_version() or "missing",
+        "bundled_upstream_version": bundled_version or "missing",
         "global_command_version": global_command_version() or "missing",
         "host_python": find_host_python() or "missing",
         "codex_binary": find_codex_binary() or "missing",
@@ -50,6 +71,9 @@ def doctor_report(paths: RuntimePaths | None = None) -> dict[str, str]:
         "shortcut_state": str(state.get("shortcut_state") or "missing"),
         "start_menu_state": str(state.get("start_menu_state") or "missing"),
         "legacy_auto_inject": str(state.get("legacy_auto_inject_state") or legacy_auto_inject_state()),
+        "shortcut_sidecar_root": str(sidecar_root) if sidecar_root is not None else "missing",
+        "shortcut_sidecar_version": installed_sidecar_version or "unknown",
+        "sidecar_drift": _sidecar_drift_value(installed_sidecar_version, bundled_version),
     }
     if sys.platform == "win32":
         report["windows_app_dir"] = find_windows_codex_app_dir() or "missing"

package/codex_plus_plus_launcher/runtime.py

@@ -590,6 +590,112 @@ def binary_version_from_path(path: Path | None) -> str | None:
     return None
 
 
+SIDECAR_VERSION_STAMP_NAME = ".codexpp-sidecar-version"
+
+
+def shortcut_sidecar_install_root() -> Path | None:
+    """Return the directory where the npm postinstall copied the sidecar.
+
+    Mirrors `installSidecarRoot` in npm/launcher.js. Used by doctor() to read
+    the stamp file written alongside the sidecar binary.
+    """
+    if sys.platform == "win32":
+        local = os.environ.get("LOCALAPPDATA")
+        if not local:
+            return None
+        return Path(local) / "Programs" / "Codex++"
+    if sys.platform == "darwin":
+        primary = Path("/Applications")
+        if (primary / SIDECAR_VERSION_STAMP_NAME).is_file() or (primary / "codex-plus-plus").is_file():
+            return primary
+        fallback = Path.home() / "Applications"
+        if (fallback / SIDECAR_VERSION_STAMP_NAME).is_file() or (fallback / "codex-plus-plus").is_file():
+            return fallback
+        return primary
+    xdg = os.environ.get("XDG_DATA_HOME") or str(Path.home() / ".local" / "share")
+    return Path(xdg) / "Codex++"
+
+
+def shortcut_sidecar_binary(root: Path | None = None) -> Path | None:
+    base = root if root is not None else shortcut_sidecar_install_root()
+    if base is None:
+        return None
+    name = "codex-plus-plus.exe" if sys.platform == "win32" else "codex-plus-plus"
+    candidate = base / name
+    return candidate if candidate.is_file() else None
+
+
+def _read_sidecar_version_stamp(root: Path) -> str | None:
+    stamp = root / SIDECAR_VERSION_STAMP_NAME
+    try:
+        text = stamp.read_text(encoding="utf-8")
+    except (OSError, UnicodeDecodeError):
+        return None
+    value = text.strip()
+    return value or None
+
+
+def _read_pe_file_version(path: Path) -> str | None:
+    """Windows-only fallback: read FileVersion from the PE VS_FIXEDFILEINFO block.
+
+    Used when an older npm install root predates the stamp file. No new
+    dependencies — calls into version.dll via ctypes.
+    """
+    if sys.platform != "win32":
+        return None
+    try:
+        import ctypes
+        from ctypes import wintypes
+    except Exception:
+        return None
+    try:
+        version_dll = ctypes.WinDLL("version", use_last_error=True)
+    except OSError:
+        return None
+    target = str(path)
+    try:
+        size = version_dll.GetFileVersionInfoSizeW(target, None)
+        if not size:
+            return None
+        buffer = ctypes.create_string_buffer(size)
+        if not version_dll.GetFileVersionInfoW(target, 0, size, buffer):
+            return None
+        block_ptr = ctypes.c_void_p()
+        block_size = wintypes.UINT()
+        if not version_dll.VerQueryValueW(buffer, "\\", ctypes.byref(block_ptr), ctypes.byref(block_size)):
+            return None
+        if block_size.value < 16:
+            return None
+        raw = ctypes.string_at(block_ptr, block_size.value)
+        ms = int.from_bytes(raw[8:12], "little")
+        ls = int.from_bytes(raw[12:16], "little")
+    except Exception:
+        return None
+    parts = [ms >> 16, ms & 0xFFFF, ls >> 16, ls & 0xFFFF]
+    while len(parts) > 1 and parts[-1] == 0:
+        parts.pop()
+    return ".".join(str(part) for part in parts) or None
+
+
+def shortcut_sidecar_version() -> str | None:
+    """Return the version of the installed sidecar copy, or None when unknown.
+
+    Prefers a stamp file written by npm postinstall (cross-platform). Falls
+    back to the PE VersionInfo on Windows for installs that predate the stamp.
+    """
+    root = shortcut_sidecar_install_root()
+    if root is None:
+        return None
+    stamp_version = _read_sidecar_version_stamp(root)
+    if stamp_version:
+        return stamp_version
+    if sys.platform == "win32":
+        binary = shortcut_sidecar_binary(root)
+        if binary is not None:
+            return _read_pe_file_version(binary)
+    return None
+
+
 def global_binary_candidate_dirs(current_binary: Path | None = None) -> list[Path]:
     candidate_dirs: list[Path] = []
     if current_binary is not None:

package/npm/build-local-binary.cjs

@@ -13,8 +13,30 @@ function packageVersion(root = packageRoot()) {
   return JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8')).version;
 }
 
+function upstreamRefFromMetadata(root = packageRoot()) {
+  for (const relativePath of [
+    path.join('upstream-bin', 'upstream-release.json'),
+    path.join('.github', 'upstream-sync', 'latest.json'),
+  ]) {
+    const metadataPath = path.join(root, relativePath);
+    if (!fs.existsSync(metadataPath)) {
+      continue;
+    }
+    try {
+      const payload = JSON.parse(fs.readFileSync(metadataPath, 'utf8'));
+      const ref = payload.ref || payload.version || payload.tag || payload.upstream_version;
+      if (ref) {
+        return String(ref);
+      }
+    } catch (_error) {
+      // Ignore malformed local metadata and fall back to the package version.
+    }
+  }
+  return null;
+}
+
 function defaultUpstreamRef(root = packageRoot()) {
-  return `v${packageVersion(root)}`;
+  return upstreamRefFromMetadata(root) || `v${packageVersion(root)}`;
 }
 
 function run(command, args, options = {}) {
@@ -125,4 +147,4 @@ if (require.main === module) {
   }
 }
 
-module.exports = { applyPluginUnlockPatch, buildTargetArgs, cargoTargetForKey, defaultUpstreamRef, main, packageBuildArgs, platformKey };
+module.exports = { applyPluginUnlockPatch, buildTargetArgs, cargoTargetForKey, defaultUpstreamRef, main, packageBuildArgs, platformKey, upstreamRefFromMetadata };

package/npm/i18n.js

@@ -18,6 +18,9 @@ const messages = {
     shortcutInstallFailed: '创建 Codex++ 快捷方式失败',
     retryingMirror: '直连失败，正在尝试 GitHub 镜像',
     retryingForceReinstall: '检测到损坏的 pip 安装记录，正在尝试跳过卸载直接覆盖安装',
+    sidecarSelfHealOk: 'Codex++: 已自动更新本地 sidecar',
+    sidecarSelfHealLocked: 'Codex++: 检测到本地 sidecar 与 npm 版本不一致，但当前正在运行；本次仍使用旧版启动。请退出 Codex 后重新执行 cxpp launch 完成升级。',
+    sidecarSelfHealFailed: 'Codex++: sidecar 自愈失败，仍使用旧版启动',
   },
   en: {
     missingPython: 'missing command: python3, python, or py',
@@ -38,6 +41,9 @@ const messages = {
     shortcutInstallFailed: 'failed to create Codex++ shortcuts',
     retryingMirror: 'direct GitHub download failed, retrying with mirrors',
     retryingForceReinstall: 'detected a broken pip installation record, retrying without uninstall',
+    sidecarSelfHealOk: 'Codex++: refreshed the local sidecar to match the npm package',
+    sidecarSelfHealLocked: 'Codex++: the local sidecar is out of date but is currently running; using the old version for this launch. Quit Codex and re-run cxpp launch to finish the upgrade.',
+    sidecarSelfHealFailed: 'Codex++: sidecar self-heal failed, falling back to the old version',
   },
 };
 

package/npm/launcher.js

@@ -8,6 +8,7 @@ const { t } = require('./i18n.js');
 const SUPPORTED_PLATFORMS = new Set(['win32-x64', 'darwin-x64', 'darwin-arm64', 'linux-x64']);
 const SILENT_BINARY = 'codex-plus-plus';
 const MANAGER_BINARY = 'codex-plus-plus-manager';
+const SIDECAR_VERSION_STAMP = '.codexpp-sidecar-version';
 const SILENT_NAME = 'Codex++';
 const MANAGER_NAME = 'Codex++ 管理工具';
 const LINUX_SHIM_DIR_NAME = 'codex-desktop-linux-shim';
@@ -15,6 +16,8 @@ const LINUX_SHIM_BINARY = 'codex.exe';
 const LINUX_DESKTOP_ENTRY = 'codex-plus-plus.desktop';
 const PLUGIN_AUTH_UNLOCK_FILE = 'plugin-auth-unlocked.js';
 const PLUGIN_AUTH_UNLOCK_CONTENT = 'function e(e){return false}export{e as t};\n';
+const WINDOWS_LAUNCH_SCRIPT = 'launch-codexpp.vbs';
+const CODEX_PLUS_MENU_SELECTOR = '#codex-plus-menu, [data-codex-plus-menu="true"]';
 
 function optionValue(options, key, fallback) {
   const value = options[key];
@@ -303,6 +306,532 @@ function terminateProcesses(processes, options = {}) {
     stdio: 'ignore',
     windowsHide: true,
   });
+  const taskkillArgs = ['/F'];
+  for (const id of ids) {
+    taskkillArgs.push('/PID', String(id));
+  }
+  run('taskkill.exe', taskkillArgs, {
+    encoding: 'utf8',
+    env,
+    stdio: 'ignore',
+    windowsHide: true,
+  });
+}
+
+function terminateSidecarsByImageName(options = {}) {
+  const platform = optionValue(options, 'platform', process.platform);
+  if (platform !== 'win32') {
+    return false;
+  }
+  if (typeof options.terminateSidecarsByImageName === 'function') {
+    return Boolean(options.terminateSidecarsByImageName(options));
+  }
+  const run = options.spawnSync || spawnSync;
+  const result = run('taskkill.exe', ['/F', '/IM', 'codex-plus-plus.exe'], {
+    encoding: 'utf8',
+    env: options.env || process.env,
+    stdio: 'ignore',
+    windowsHide: true,
+  });
+  return Boolean(result && result.status === 0);
+}
+
+function findRunningCodexProcesses(options = {}) {
+  const platform = optionValue(options, 'platform', process.platform);
+  if (platform !== 'win32') {
+    return [];
+  }
+  if (typeof options.findRunningCodexProcesses === 'function') {
+    return options.findRunningCodexProcesses(options) || [];
+  }
+
+  const run = options.processSpawnSync || (options.spawnSync ? null : spawnSync);
+  if (!run) {
+    return [];
+  }
+  const script = [
+    '$ErrorActionPreference = "SilentlyContinue"',
+    'Get-CimInstance Win32_Process | Where-Object {',
+    '  $_.Name -ieq "Codex.exe"',
+    '} | Select-Object ProcessId,Name,ExecutablePath,CommandLine | ConvertTo-Json -Compress',
+  ].join('\n');
+  const result = run('powershell.exe', ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-Command', script], {
+    encoding: 'utf8',
+    windowsHide: true,
+  });
+  if (!result || result.status !== 0) {
+    return [];
+  }
+  try {
+    return parsePowerShellJson(result.stdout);
+  } catch (_error) {
+    return [];
+  }
+}
+
+function findRunningSidecarProcesses(options = {}) {
+  const platform = optionValue(options, 'platform', process.platform);
+  if (platform !== 'win32') {
+    return [];
+  }
+  if (typeof options.findRunningSidecarProcesses === 'function') {
+    return options.findRunningSidecarProcesses(options) || [];
+  }
+
+  const run = options.processSpawnSync || (options.spawnSync ? null : spawnSync);
+  if (!run) {
+    return [];
+  }
+  const script = [
+    '$ErrorActionPreference = "SilentlyContinue"',
+    'Get-CimInstance Win32_Process | Where-Object {',
+    '  $_.Name -ieq "codex-plus-plus.exe"',
+    '} | Select-Object ProcessId,Name,ExecutablePath,CommandLine | ConvertTo-Json -Compress',
+  ].join('\n');
+  const result = run('powershell.exe', ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-Command', script], {
+    encoding: 'utf8',
+    windowsHide: true,
+  });
+  if (!result || result.status !== 0) {
+    return [];
+  }
+  try {
+    return parsePowerShellJson(result.stdout);
+  } catch (_error) {
+    return [];
+  }
+}
+
+function cdpTargetsAvailable(debugPort, options = {}) {
+  if (typeof options.cdpTargetsAvailable === 'function') {
+    return options.cdpTargetsAvailable(debugPort, options);
+  }
+  const run = options.processSpawnSync || (options.spawnSync ? null : spawnSync);
+  if (!run) {
+    return true;
+  }
+  const env = { ...(options.env || process.env), CODEXPP_DEBUG_PORT: String(debugPort) };
+  const script = [
+    '$ErrorActionPreference = "SilentlyContinue"',
+    '$port = [int]$env:CODEXPP_DEBUG_PORT',
+    'foreach ($hostName in @("127.0.0.1", "[::1]")) {',
+    '  try {',
+    '    $response = Invoke-WebRequest -UseBasicParsing -Uri "http://$hostName`:$port/json" -TimeoutSec 2',
+    '    if ($response.StatusCode -eq 200 -and $response.Content -match "webSocketDebuggerUrl") { exit 0 }',
+    '  } catch {}',
+    '}',
+    'exit 1',
+  ].join('\n');
+  const result = run('powershell.exe', ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-Command', script], {
+    encoding: 'utf8',
+    env,
+    windowsHide: true,
+  });
+  return Boolean(result && result.status === 0);
+}
+
+function codexPlusUiInjectionProbeScript() {
+  return String.raw`
+const http = require('node:http');
+const net = require('node:net');
+const crypto = require('node:crypto');
+
+const debugPort = Number(process.env.CODEXPP_DEBUG_PORT || '0');
+const selector = process.env.CODEXPP_MENU_SELECTOR || '#codex-plus-menu, [data-codex-plus-menu="true"]';
+
+function exitSoon(code) {
+  try {
+    process.exitCode = code;
+  } finally {
+    process.exit(code);
+  }
+}
+
+function readJson(pathname) {
+  return new Promise((resolve, reject) => {
+    const request = http.get({
+      host: '127.0.0.1',
+      port: debugPort,
+      path: pathname,
+      timeout: 1500,
+    }, (response) => {
+      const chunks = [];
+      response.setEncoding('utf8');
+      response.on('data', (chunk) => chunks.push(chunk));
+      response.on('end', () => {
+        try {
+          resolve(JSON.parse(chunks.join('')));
+        } catch (error) {
+          reject(error);
+        }
+      });
+    });
+    request.on('timeout', () => request.destroy(new Error('timeout')));
+    request.on('error', reject);
+  });
+}
+
+function parseWebSocketTarget(webSocketDebuggerUrl) {
+  const parsed = new URL(webSocketDebuggerUrl);
+  if (parsed.protocol !== 'ws:') {
+    throw new Error('unsupported websocket protocol');
+  }
+  return {
+    host: parsed.hostname,
+    port: Number(parsed.port || 80),
+    path: (parsed.pathname || '/') + (parsed.search || ''),
+  };
+}
+
+function encodeClientTextFrame(text) {
+  const payload = Buffer.from(text, 'utf8');
+  if (payload.length > 65535) {
+    throw new Error('websocket payload too large');
+  }
+  const headerLength = payload.length < 126 ? 2 : 4;
+  const frame = Buffer.alloc(headerLength + 4 + payload.length);
+  frame[0] = 0x81;
+  let offset = 2;
+  if (payload.length < 126) {
+    frame[1] = 0x80 | payload.length;
+  } else {
+    frame[1] = 0x80 | 126;
+    frame.writeUInt16BE(payload.length, 2);
+    offset = 4;
+  }
+  const mask = crypto.randomBytes(4);
+  mask.copy(frame, offset);
+  for (let index = 0; index < payload.length; index += 1) {
+    frame[offset + 4 + index] = payload[index] ^ mask[index % 4];
+  }
+  return frame;
+}
+
+function evaluateMenuState(webSocketDebuggerUrl) {
+  return new Promise((resolve, reject) => {
+    let target;
+    try {
+      target = parseWebSocketTarget(webSocketDebuggerUrl);
+    } catch (error) {
+      reject(error);
+      return;
+    }
+    const socket = net.createConnection({ host: target.host, port: target.port });
+    let buffer = Buffer.alloc(0);
+    let upgraded = false;
+    let settled = false;
+    const timer = setTimeout(() => {
+      finish(new Error('CDP evaluate timed out'));
+    }, 2500);
+
+    function finish(error, value) {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      socket.destroy();
+      if (error) {
+        reject(error);
+      } else {
+        resolve(value);
+      }
+    }
+
+    function sendEvaluateRequest() {
+      socket.write(encodeClientTextFrame(JSON.stringify({
+        id: 1,
+        method: 'Runtime.evaluate',
+        params: {
+          expression: '(() => Boolean(document.querySelector(' + JSON.stringify(selector) + ')))()',
+          returnByValue: true,
+          awaitPromise: true,
+          allowUnsafeEvalBlockedByCSP: true,
+        },
+      })));
+    }
+
+    function readFrames() {
+      while (buffer.length >= 2) {
+        const first = buffer[0];
+        const second = buffer[1];
+        const opcode = first & 0x0f;
+        let length = second & 0x7f;
+        let offset = 2;
+        if (length === 126) {
+          if (buffer.length < offset + 2) return;
+          length = buffer.readUInt16BE(offset);
+          offset += 2;
+        } else if (length === 127) {
+          if (buffer.length < offset + 8) return;
+          const high = buffer.readUInt32BE(offset);
+          const low = buffer.readUInt32BE(offset + 4);
+          if (high !== 0) {
+            finish(new Error('websocket frame too large'));
+            return;
+          }
+          length = low;
+          offset += 8;
+        }
+        const masked = Boolean(second & 0x80);
+        let mask = null;
+        if (masked) {
+          if (buffer.length < offset + 4) return;
+          mask = buffer.subarray(offset, offset + 4);
+          offset += 4;
+        }
+        if (buffer.length < offset + length) return;
+        const payload = Buffer.from(buffer.subarray(offset, offset + length));
+        buffer = buffer.subarray(offset + length);
+        if (mask) {
+          for (let index = 0; index < payload.length; index += 1) {
+            payload[index] ^= mask[index % 4];
+          }
+        }
+        if (opcode === 0x8) {
+          finish(new Error('CDP websocket closed'));
+          return;
+        }
+        if (opcode !== 0x1 && opcode !== 0x0) {
+          continue;
+        }
+        let payloadJson;
+        try {
+          payloadJson = JSON.parse(payload.toString('utf8'));
+        } catch (_error) {
+          continue;
+        }
+        if (payloadJson.id !== 1) {
+          continue;
+        }
+        if (payloadJson.error) {
+          finish(new Error(payloadJson.error.message || 'CDP evaluate failed'));
+          return;
+        }
+        finish(null, Boolean(payloadJson.result && payloadJson.result.result && payloadJson.result.result.value));
+        return;
+      }
+    }
+
+    socket.on('connect', () => {
+      const key = crypto.randomBytes(16).toString('base64');
+      socket.write([
+        'GET ' + target.path + ' HTTP/1.1',
+        'Host: ' + target.host + ':' + target.port,
+        'Upgrade: websocket',
+        'Connection: Upgrade',
+        'Sec-WebSocket-Key: ' + key,
+        'Sec-WebSocket-Version: 13',
+        '',
+        '',
+      ].join('\r\n'));
+    });
+
+    socket.on('data', (chunk) => {
+      buffer = Buffer.concat([buffer, chunk]);
+      if (!upgraded) {
+        const headerEnd = buffer.indexOf('\r\n\r\n');
+        if (headerEnd === -1) {
+          return;
+        }
+        const header = buffer.subarray(0, headerEnd).toString('latin1');
+        buffer = buffer.subarray(headerEnd + 4);
+        if (!/^HTTP\/1\.[01] 101\b/.test(header)) {
+          finish(new Error('CDP websocket upgrade failed'));
+          return;
+        }
+        upgraded = true;
+        sendEvaluateRequest();
+      }
+      readFrames();
+    });
+
+    socket.on('error', (error) => {
+      finish(error);
+    });
+
+    socket.on('close', () => {
+      if (!settled) {
+        finish(new Error('CDP websocket closed'));
+        return;
+      }
+    });
+  });
+}
+
+(async () => {
+  if (!Number.isInteger(debugPort) || debugPort <= 0) {
+    exitSoon(3);
+  }
+  const targets = await readJson('/json/list').catch(() => readJson('/json'));
+  const list = Array.isArray(targets) ? targets : [];
+  const target = list.find((candidate) => candidate.type === 'page' && candidate.webSocketDebuggerUrl)
+    || list.find((candidate) => candidate.webSocketDebuggerUrl);
+  if (!target) {
+    exitSoon(3);
+  }
+  const present = await evaluateMenuState(target.webSocketDebuggerUrl);
+  exitSoon(present ? 0 : 2);
+})().catch(() => exitSoon(3));
+`;
+}
+
+function codexPlusUiInjectionState(debugPort, options = {}) {
+  if (typeof options.codexPlusUiInjectionState === 'function') {
+    return options.codexPlusUiInjectionState(debugPort, options);
+  }
+  const run = options.processSpawnSync || (options.spawnSync || options.spawn ? null : spawnSync);
+  if (!run) {
+    return 'unknown';
+  }
+  const env = {
+    ...(options.env || process.env),
+    CODEXPP_DEBUG_PORT: String(debugPort),
+    CODEXPP_MENU_SELECTOR: CODEX_PLUS_MENU_SELECTOR,
+  };
+  const result = run(process.execPath, ['-e', codexPlusUiInjectionProbeScript()], {
+    encoding: 'utf8',
+    env,
+    timeout: optionValue(options, 'uiInjectionProbeTimeoutMs', 4000),
+    windowsHide: true,
+  });
+  if (!result) {
+    return 'unknown';
+  }
+  if (result.status === 0) {
+    return 'present';
+  }
+  if (result.status === 2) {
+    return 'missing';
+  }
+  return 'unknown';
+}
+
+function launchDebugPort(args = [], fallback = 9229) {
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = String(args[index] || '');
+    if (arg === '--debug-port' && args[index + 1]) {
+      const parsed = Number(args[index + 1]);
+      if (Number.isInteger(parsed) && parsed > 0 && parsed <= 65535) {
+        return parsed;
+      }
+    }
+    const match = arg.match(/^--remote-debugging-port=(\d+)$/) || arg.match(/^--debug-port=(\d+)$/);
+    if (match) {
+      const parsed = Number(match[1]);
+      if (Number.isInteger(parsed) && parsed > 0 && parsed <= 65535) {
+        return parsed;
+      }
+    }
+  }
+  return fallback;
+}
+
+function codexProcessDebugPorts(processes = []) {
+  const ports = [];
+  for (const processInfo of processes) {
+    const commandLine = String(processInfo.CommandLine || '');
+    const match = commandLine.match(/--remote-debugging-port=(\d+)/);
+    if (!match) {
+      continue;
+    }
+    const parsed = Number(match[1]);
+    if (Number.isInteger(parsed) && parsed > 0 && parsed <= 65535 && !ports.includes(parsed)) {
+      ports.push(parsed);
+    }
+  }
+  return ports;
+}
+
+function preflightWindowsCodexLaunch(args = [], options = {}) {
+  const platform = optionValue(options, 'platform', process.platform);
+  const env = options.env || process.env;
+  if (platform !== 'win32' || isTruthyEnv(env.CODEXPP_DISABLE_CDP_PREFLIGHT)) {
+    return { action: 'noop' };
+  }
+
+  const processes = findRunningCodexProcesses(options);
+  if (processes.length === 0) {
+    return { action: 'noop' };
+  }
+
+  const requestedDebugPort = launchDebugPort(args);
+  const runningDebugPorts = codexProcessDebugPorts(processes);
+  const portsToCheck = runningDebugPorts.length > 0 ? runningDebugPorts : [requestedDebugPort];
+  if (runningDebugPorts.length > 0) {
+    const availableDebugPort = portsToCheck.find((debugPort) => cdpTargetsAvailable(debugPort, options));
+    if (availableDebugPort) {
+      const uiState = codexPlusUiInjectionState(availableDebugPort, options);
+      if (uiState !== 'missing') {
+        return { action: 'noop', debugPort: availableDebugPort, processCount: processes.length, uiState };
+      }
+
+      const sidecars = findRunningSidecarProcesses(options);
+      if (sidecars.length > 0) {
+        const terminate = options.terminateProcesses || terminateProcesses;
+        terminate(sidecars, options);
+        return {
+          action: 'terminated_stale_sidecar',
+          debugPort: availableDebugPort,
+          processCount: processes.length,
+          sidecarCount: sidecars.length,
+          uiState,
+        };
+      }
+
+      terminateSidecarsByImageName(options);
+      return {
+        action: 'terminated_stale_sidecar_by_name',
+        debugPort: availableDebugPort,
+        processCount: processes.length,
+        sidecarCount: 0,
+        uiState,
+      };
+    }
+  }
+
+  const sidecars = findRunningSidecarProcesses(options);
+  if (sidecars.length > 0) {
+    const terminate = options.terminateProcesses || terminateProcesses;
+    terminate(sidecars, options);
+    return {
+      action: 'terminated_sidecar_for_unavailable_cdp',
+      debugPort: portsToCheck[0],
+      processCount: processes.length,
+      sidecarCount: sidecars.length,
+    };
+  }
+
+  return { action: 'cdp_unavailable', debugPort: portsToCheck[0], processCount: processes.length };
+}
+
+function shouldPassPreflightDebugPort(preflight) {
+  return Boolean(
+    preflight
+      && preflight.uiState === 'missing'
+      && Number.isInteger(preflight.debugPort)
+      && preflight.debugPort > 0
+      && preflight.debugPort <= 65535,
+  );
+}
+
+function sidecarArgsWithDebugPort(args = [], debugPort) {
+  if (!Number.isInteger(debugPort) || debugPort <= 0 || debugPort > 65535) {
+    return args;
+  }
+  const filtered = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = String(args[index] || '');
+    if (arg === '--debug-port') {
+      index += 1;
+      continue;
+    }
+    if (/^--debug-port=\d+$/.test(arg) || /^--remote-debugging-port=\d+$/.test(arg)) {
+      continue;
+    }
+    filtered.push(args[index]);
+  }
+  return ['--debug-port', String(debugPort), ...filtered];
 }
 
 function isTruthyEnv(value) {
@@ -478,10 +1007,106 @@ async function installSidecars(options = {}) {
     fsImpl.copyFileSync(icon, iconTarget);
     installed.icon = iconTarget;
   }
+  try {
+    fsImpl.writeFileSync(
+      path.join(installRoot, SIDECAR_VERSION_STAMP),
+      packageVersion(options) + '\n',
+    );
+  } catch (_error) {
+    // Stamp is best-effort; doctor will fall back to platform probes.
+  }
   installed.installRoot = installRoot;
   return installed;
 }
 
+function readInstalledSidecarVersion(options = {}) {
+  const fsImpl = options.fs || fs;
+  const platform = optionValue(options, 'platform', process.platform);
+  const installRoot = optionValue(options, 'installRoot', () => detectedInstallRoot(options));
+  const stampPath = path.join(installRoot, SIDECAR_VERSION_STAMP);
+  try {
+    const raw = fsImpl.readFileSync(stampPath, 'utf8');
+    const first = String(raw).split(/\r?\n/)[0].trim();
+    if (first) {
+      return first;
+    }
+  } catch (_error) {
+    // stamp absent or unreadable; fall through to platform probe
+  }
+  if (platform !== 'win32') {
+    return null;
+  }
+  const silent = installedSidecarPath('silent', { ...options, installRoot });
+  if (!fsImpl.existsSync(silent)) {
+    return null;
+  }
+  const run = options.spawnSync || spawnSync;
+  try {
+    const result = run(
+      'powershell',
+      ['-NoProfile', '-NonInteractive', '-Command', '(Get-Item -LiteralPath $args[0]).VersionInfo.FileVersion', '--', silent],
+      { encoding: 'utf8', windowsHide: true },
+    );
+    if (result && result.status === 0) {
+      const out = String(result.stdout || '').trim();
+      if (out) {
+        return out;
+      }
+    }
+  } catch (_error) {
+    // probe failed; treat as unknown
+  }
+  return null;
+}
+
+function computeSidecarDrift(options = {}) {
+  const platform = optionValue(options, 'platform', process.platform);
+  const arch = optionValue(options, 'arch', process.arch);
+  if (!SUPPORTED_PLATFORMS.has(platformKey(platform, arch))) {
+    return 'unsupported';
+  }
+  const fsImpl = options.fs || fs;
+  const installRoot = optionValue(options, 'installRoot', () => detectedInstallRoot(options));
+  const silent = installedSidecarPath('silent', { ...options, installRoot });
+  if (!fsImpl.existsSync(silent)) {
+    return 'mismatch';
+  }
+  const bundled = packageVersion(options);
+  const installed = readInstalledSidecarVersion({ ...options, installRoot });
+  if (!installed) {
+    return 'unknown';
+  }
+  return installed === bundled ? 'none' : 'mismatch';
+}
+
+async function ensureSidecarsFresh(options = {}) {
+  const drift = computeSidecarDrift(options);
+  if (drift === 'none' || drift === 'unsupported') {
+    return { action: 'noop', drift };
+  }
+  const env = options.env || process.env;
+  const before = readInstalledSidecarVersion(options);
+  const after = packageVersion(options);
+  const stderr = options.stderr || process.stderr;
+  try {
+    await installSidecars({
+      ...options,
+      promptYesNo: () => false,
+      promptYesNoWindowsPopup: () => false,
+    });
+    const arrow = before ? `${before} -> ${after}` : `-> ${after}`;
+    stderr.write(`${t('sidecarSelfHealOk', env)} (${arrow})\n`);
+    return { action: 'reinstalled', drift, before, after };
+  } catch (error) {
+    if (error && error.code === 'CODEXPP_LOCKED_OLD_BINARY') {
+      stderr.write(`${t('sidecarSelfHealLocked', env)}\n`);
+      return { action: 'locked', drift, error };
+    }
+    stderr.write(`${t('sidecarSelfHealFailed', env)}: ${(error && error.message) || String(error)}\n`);
+    return { action: 'failed', drift, error };
+  }
+}
+
 function normalizeExecutablePath(candidate) {
   return path.resolve(String(candidate || ''));
 }
@@ -920,6 +1545,55 @@ function psQuote(value) {
   return `'${String(value).replace(/'/g, "''")}'`;
 }
 
+function windowsCommandLineArg(value) {
+  const raw = String(value);
+  if (raw && !/[ \t"]/.test(raw)) {
+    return raw;
+  }
+  let output = '"';
+  let backslashes = 0;
+  for (const ch of raw) {
+    if (ch === '\\') {
+      backslashes += 1;
+    } else if (ch === '"') {
+      output += '\\'.repeat(backslashes * 2 + 1) + '"';
+      backslashes = 0;
+    } else {
+      output += '\\'.repeat(backslashes) + ch;
+      backslashes = 0;
+    }
+  }
+  output += '\\'.repeat(backslashes * 2) + '"';
+  return output;
+}
+
+function vbsString(value) {
+  return `"${String(value).replace(/"/g, '""')}"`;
+}
+
+function windowsWscriptPath(options = {}) {
+  const env = options.env || process.env;
+  return path.join(env.SystemRoot || env.SYSTEMROOT || 'C:\\Windows', 'System32', 'wscript.exe');
+}
+
+function writeWindowsLaunchScript(installed, options = {}) {
+  const fsImpl = options.fs || fs;
+  const installRoot = installed.installRoot || path.dirname(installed.silent);
+  const scriptPath = optionValue(options, 'windowsLaunchScriptPath', () => path.join(installRoot, WINDOWS_LAUNCH_SCRIPT));
+  const nodePath = optionValue(options, 'nodePath', process.execPath);
+  const cxppScript = path.join(optionValue(options, 'packageRoot', packageRoot), 'npm', 'cxpp.js');
+  const commandLine = [nodePath, cxppScript, 'launch'].map(windowsCommandLineArg).join(' ');
+  const contents = [
+    'Set shell = CreateObject("WScript.Shell")',
+    `shell.CurrentDirectory = ${vbsString(installRoot)}`,
+    `shell.Run ${vbsString(commandLine)}, 0, False`,
+    '',
+  ].join('\r\n');
+  fsImpl.mkdirSync(path.dirname(scriptPath), { recursive: true });
+  fsImpl.writeFileSync(scriptPath, contents, 'utf8');
+  return scriptPath;
+}
+
 function windowsEntrypointPaths(options = {}) {
   const env = options.env || process.env;
   const desktop = optionValue(options, 'desktopDir', () => path.join(os.homedir(), 'Desktop'));
@@ -940,17 +1614,39 @@ function installWindowsEntrypoints(installed, options = {}) {
   const paths = windowsEntrypointPaths(options);
   fsImpl.mkdirSync(path.dirname(paths.desktopSilent), { recursive: true });
   fsImpl.mkdirSync(paths.startMenu, { recursive: true });
+  const launchScript = writeWindowsLaunchScript(installed, options);
+  const wscript = windowsWscriptPath(options);
+  const installRoot = installed.installRoot || path.dirname(installed.silent);
   const specs = [
-    [paths.desktopSilent, installed.silent, 'Launch Codex++ silently'],
-    [paths.desktopManager, installed.manager, 'Open Codex++ management tool'],
-    [paths.startMenuSilent, installed.silent, 'Launch Codex++ silently'],
-    [paths.startMenuManager, installed.manager, 'Open Codex++ management tool'],
-  ].map(([shortcutPath, target, description]) => ({
-    path: shortcutPath,
-    target,
-    description,
-    icon: target,
-  }));
+    {
+      path: paths.desktopSilent,
+      target: wscript,
+      arguments: windowsCommandLineArg(launchScript),
+      workingDirectory: installRoot,
+      description: 'Launch Codex++ silently',
+      icon: installed.silent,
+    },
+    {
+      path: paths.desktopManager,
+      target: installed.manager,
+      description: 'Open Codex++ management tool',
+      icon: installed.manager,
+    },
+    {
+      path: paths.startMenuSilent,
+      target: wscript,
+      arguments: windowsCommandLineArg(launchScript),
+      workingDirectory: installRoot,
+      description: 'Launch Codex++ silently',
+      icon: installed.silent,
+    },
+    {
+      path: paths.startMenuManager,
+      target: installed.manager,
+      description: 'Open Codex++ management tool',
+      icon: installed.manager,
+    },
+  ];
   const result = run('powershell.exe', ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-Command', windowsShortcutScript(specs)], {
     encoding: 'utf8',
     windowsHide: true,
@@ -1284,25 +1980,37 @@ async function runLauncher(args = [], options = {}) {
     return { status: 0 };
   }
   if (command === 'launch' || command === 'run') {
+    await ensureSidecarsFresh(options);
     const passthrough = args.slice(1);
-    return spawnSidecar('silent', passthrough[0] === '--' ? passthrough.slice(1) : passthrough, options);
+    const sidecarArgs = passthrough[0] === '--' ? passthrough.slice(1) : passthrough;
+    const preflight = preflightWindowsCodexLaunch(sidecarArgs, options);
+    const launchArgs = shouldPassPreflightDebugPort(preflight)
+      ? sidecarArgsWithDebugPort(sidecarArgs, preflight.debugPort)
+      : sidecarArgs;
+    return spawnSidecar('silent', launchArgs, options);
   }
   if (command === 'manager') {
+    await ensureSidecarsFresh(options);
     return spawnSidecar('manager', args.slice(1), options);
   }
+  await ensureSidecarsFresh(options);
   return spawnSidecar('silent', args, options);
 }
 
 module.exports = {
+  SIDECAR_VERSION_STAMP,
   SUPPORTED_PLATFORMS,
   bundledSidecarPath,
   bundledUpstreamVersion,
+  computeSidecarDrift,
   copyReplacingChangedFile,
   defaultInstallRoot,
   doctorReport,
+  ensureSidecarsFresh,
   executableName,
   filesMatch,
   findRunningProcessesForPath,
+  findRunningSidecarProcesses,
   installApp,
   installEntrypoints,
   installSidecars,
@@ -1315,14 +2023,20 @@ module.exports = {
   fallbackMacInstallRoot,
   macAppRoot,
   platformKey,
+  preflightWindowsCodexLaunch,
+  codexPlusUiInjectionState,
+  sidecarArgsWithDebugPort,
   promptYesNoWindowsPopup,
+  readInstalledSidecarVersion,
   removePath,
   runLauncher,
   spawnSidecar,
   terminateProcesses,
+  terminateSidecarsByImageName,
   upstreamBinDir,
   upstreamMetadata,
   upstreamMetadataPath,
+  writeWindowsLaunchScript,
   windowsShortcutScript,
   windowsEntrypointPaths,
   writeMacAppBundle,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duanluan/codex-plus-plus-launcher",
-  "version": "1.2.14",
+  "version": "1.2.18",
   "description": "Install and launch Codex++ from npm",
   "bin": {
     "cxpp": "npm/cxpp.js",
@@ -51,3 +51,5 @@
   ],
   "license": "MIT"
 }
+
+

package/patches/codex-plus-plus-plugin-unlock.patch

@@ -1,8 +1,19 @@
+diff --git a/assets/inject/renderer-inject.js b/assets/inject/renderer-inject.js
+index fa775b1..920c25e 100644
 --- a/assets/inject/renderer-inject.js
 +++ b/assets/inject/renderer-inject.js
-@@ -67,0 +68 @@
+@@ -67,6 +67,7 @@
+   const codexServiceTierRequestOverrideVersion = "3";
+   const codexAppServerModelRequestPatchVersion = "1";
+   const codexPluginMarketplaceUnlockVersion = "10";
 +  const codexPluginNavUnlockVersion = "2";
-@@ -2701,0 +2703,154 @@
+   const codexThreadScrollMaxEntries = 120;
+   const codexThreadScrollSaveThrottleMs = 120;
+   const codexThreadScrollRestoreWindowMs = 3200;
+@@ -2702,6 +2703,160 @@
+     return true;
+   }
+ 
 +  function pluginNavButtonCandidates() {
 +    return Array.from(document.querySelectorAll(selectors.pluginNavButton))
 +      .filter((button) => button instanceof HTMLElement && isPluginNavButton(button));
@@ -157,8 +168,102 @@
 +    }, codexForcePluginInstallRefreshIntervalMs);
 +  }
 +
-@@ -7592,0 +7748,2 @@
+   function restorePluginMarketplaceName(name) {
+     if (name === "codex-plus-openai-bundled") return "openai-bundled";
+     if (name === "codex-plus-openai-curated") return "openai-curated";
+@@ -7659,6 +7814,8 @@
+     installStyle();
+     installCodexServiceTierDispatcherPatch();
+     installCodexPlusMenu();
 +    unlockPluginNavButtons();
 +    refreshPluginNavUnlockLoop();
-@@ -7647,0 +7805 @@
+     scheduleBackendHeartbeat();
+     installDeleteButtonEventDelegation();
+     updateThreadScrollHandlers();
+@@ -8322,6 +8479,7 @@
+       ".composer-footer",
+       selectors.appHeader,
+       selectors.archiveNav,
 +      selectors.pluginNavButton,
+       ...(pluginPatchDisabledInRelayMode() ? [] : [selectors.disabledInstallButton]),
+     ].join(", ");
+   }
+diff --git a/crates/codex-plus-core/src/bridge.rs b/crates/codex-plus-core/src/bridge.rs
+index 52ea388..b903025 100644
+--- a/crates/codex-plus-core/src/bridge.rs
++++ b/crates/codex-plus-core/src/bridge.rs
+@@ -57,6 +57,8 @@ pub fn bridge_health_check_script() -> &'static str {
+ (() => {
+   const bridge = window.__codexSessionDeleteBridge;
+   if (typeof bridge !== "function") return false;
++  if (!window.__CODEX_PLUS_VERSION__) return false;
++  if (!document.querySelector('#codex-plus-menu, [data-codex-plus-menu="true"]')) return false;
+   try {
+     return Promise.race([
+       Promise.resolve(bridge("/backend/status", {})).then((result) => !!result && result.status === "ok"),
+diff --git a/crates/codex-plus-core/src/ports.rs b/crates/codex-plus-core/src/ports.rs
+index cfa4933..5d33223 100644
+--- a/crates/codex-plus-core/src/ports.rs
++++ b/crates/codex-plus-core/src/ports.rs
+@@ -27,11 +27,11 @@ pub fn select_packaged_codex_debug_port(requested: u16) -> u16 {
+ 
+ pub fn select_packaged_codex_debug_port_with(
+     requested: u16,
+-    is_windows: bool,
+-    can_bind: impl Fn(u16) -> bool,
+-    find_available: impl Fn() -> u16,
++    _is_windows: bool,
++    _can_bind: impl Fn(u16) -> bool,
++    _find_available: impl Fn() -> u16,
+ ) -> u16 {
+-    select_platform_loopback_port_with(requested, is_windows, can_bind, find_available)
++    requested
+ }
+ 
+ pub fn select_platform_loopback_port_with(
+diff --git a/crates/codex-plus-core/tests/cdp_bridge.rs b/crates/codex-plus-core/tests/cdp_bridge.rs
+index c8fe983..c2f918e 100644
+--- a/crates/codex-plus-core/tests/cdp_bridge.rs
++++ b/crates/codex-plus-core/tests/cdp_bridge.rs
+@@ -830,11 +830,24 @@ fn bridge_health_check_script_uses_real_backend_round_trip() {
+     let script = bridge::bridge_health_check_script();
+ 
+     assert!(script.contains("__codexSessionDeleteBridge"));
++    assert!(script.contains("__CODEX_PLUS_VERSION__"));
++    assert!(script.contains("#codex-plus-menu"));
++    assert!(script.contains("[data-codex-plus-menu=\"true\"]"));
+     assert!(script.contains("/backend/status"));
+     assert!(script.contains("Promise.race"));
+     assert!(script.contains("setTimeout"));
+ }
+ 
++#[test]
++fn bridge_health_check_script_rejects_bridge_only_renderer_state() {
++    let script = bridge::bridge_health_check_script();
++
++    assert!(script.contains("if (!window.__CODEX_PLUS_VERSION__) return false;"));
++    assert!(script.contains(
++        "if (!document.querySelector('#codex-plus-menu, [data-codex-plus-menu=\"true\"]')) return false;"
++    ));
++}
++
+ #[test]
+ fn bridge_result_expressions_json_escape_inputs() {
+     let resolve = bridge::resolve_bridge_expression("request\"1", &json!({"status": "ok"}))
+diff --git a/crates/codex-plus-core/tests/launcher.rs b/crates/codex-plus-core/tests/launcher.rs
+index 5c13508..9f7319e 100644
+--- a/crates/codex-plus-core/tests/launcher.rs
++++ b/crates/codex-plus-core/tests/launcher.rs
+@@ -372,10 +372,10 @@ fn ports_windows_falls_back_to_ephemeral_when_requested_is_busy() {
+ }
+ 
+ #[test]
+-fn ports_windows_packaged_debug_falls_back_to_ephemeral_when_requested_is_busy() {
++fn ports_windows_packaged_debug_keeps_requested_when_requested_is_busy() {
+     let selected = select_packaged_codex_debug_port_with(9229, true, |_| false, || 43001);
+ 
+-    assert_eq!(selected, 43001);
++    assert_eq!(selected, 9229);
+ }
+ 
+ #[test]

package/upstream-bin/upstream-release.json

@@ -1,16 +1,8 @@
 {
-  "version": "v1.2.14",
-  "html_url": "https://github.com/BigPizzaV3/CodexPlusPlus/releases/tag/v1.2.14",
-  "asset_name": "CodexPlusPlus-1.2.14-macos-arm64.dmg",
-  "asset_url": "https://github.com/BigPizzaV3/CodexPlusPlus/releases/download/v1.2.14/CodexPlusPlus-1.2.14-macos-arm64.dmg",
-  "windows_asset_name": "CodexPlusPlus-1.2.14-windows-x64-setup.exe",
-  "windows_asset_url": "https://github.com/BigPizzaV3/CodexPlusPlus/releases/download/v1.2.14/CodexPlusPlus-1.2.14-windows-x64-setup.exe",
-  "macos_x64_asset_name": "CodexPlusPlus-1.2.14-macos-x64.dmg",
-  "macos_x64_asset_url": "https://github.com/BigPizzaV3/CodexPlusPlus/releases/download/v1.2.14/CodexPlusPlus-1.2.14-macos-x64.dmg",
-  "macos_arm64_asset_name": "CodexPlusPlus-1.2.14-macos-arm64.dmg",
-  "macos_arm64_asset_url": "https://github.com/BigPizzaV3/CodexPlusPlus/releases/download/v1.2.14/CodexPlusPlus-1.2.14-macos-arm64.dmg",
-  "source_zip_url": "https://github.com/BigPizzaV3/CodexPlusPlus/archive/refs/tags/v1.2.14.zip",
-  "install_spec": "https://github.com/BigPizzaV3/CodexPlusPlus/releases/download/v1.2.14/CodexPlusPlus-1.2.14-macos-arm64.dmg",
-  "commit": "76686f03cf7b2e8acd3f7894323989e02fa104d3",
+  "upstream_version": "v1.2.15",
+  "package_version": "1.2.18",
+  "ref": "v1.2.15",
+  "version": "v1.2.15",
+  "commit": "324a350d00376d4f9565aeeae3c8820b0cbbbe2a",
   "repository": "BigPizzaV3/CodexPlusPlus"
 }