@bitkyc08/opencodex 2.7.35 → 2.7.36

package/src/server/startup-action-control.ts

@@ -0,0 +1,41 @@
+import { execFile } from "node:child_process";
+import { join } from "node:path";
+import { durableBunPath } from "../lib/bun-runtime";
+
+export type StartupInstallAction = "install-service" | "install-shim";
+let activeInstall: StartupInstallAction | null = null;
+
+export function startupInstallArgv(action: StartupInstallAction): string[] {
+  return action === "install-service"
+    ? ["service", "install"]
+    : ["codex-shim", "install"];
+}
+
+/** Execute the existing fixed CLI installer outside the proxy event loop. */
+export function runStartupInstallAction(action: StartupInstallAction): Promise<{ message: string }> {
+  if (activeInstall) return Promise.reject(new Error(`Another startup installation is already running: ${activeInstall}`));
+  activeInstall = action;
+  const bun = durableBunPath();
+  const cli = join(import.meta.dir, "..", "cli", "index.ts");
+  const operation = new Promise<{ message: string }>((resolve, reject) => {
+    execFile(bun, [cli, ...startupInstallArgv(action)], {
+      encoding: "utf8",
+      env: process.env,
+      timeout: 60_000,
+      windowsHide: true,
+      maxBuffer: 256 * 1024,
+    }, (error, stdout, stderr) => {
+      if (error) {
+        const detail = stderr.trim() || stdout.trim() || error.message;
+        reject(new Error(detail.slice(0, 2_000)));
+        return;
+      }
+      resolve({
+        message: action === "install-service"
+          ? "Background service installed."
+          : "Codex launcher shim installed.",
+      });
+    });
+  });
+  return operation.finally(() => { activeInstall = null; });
+}

package/src/server/startup-health-cache.ts

@@ -0,0 +1,100 @@
+import { execFile } from "node:child_process";
+import { join } from "node:path";
+import { codexAutoStartEnabled } from "../config";
+import { deriveStartupHealth, type StartupHealth } from "../codex/autostart-health";
+import { getCodexRoutingKind } from "../codex/inject";
+import { diagnoseCodexShim } from "../codex/shim";
+import { durableBunPath } from "../lib/bun-runtime";
+import type { OcxConfig } from "../types";
+
+const CACHE_TTL_MS = 30_000;
+const PROBE_TIMEOUT_MS = 5_000;
+let cached: { timestamp: number; value: StartupHealth } | null = null;
+let inflight: Promise<StartupHealth> | null = null;
+let generation = 0;
+
+export function markStartupHealthDiagnosticStale(value: StartupHealth): StartupHealth {
+  if (!value.localRoutingDependency) return { ...value, diagnosticStale: true };
+  return {
+    ...value,
+    status: "at-risk",
+    rebootSafe: false,
+    protection: "none",
+    diagnosticStale: true,
+    recommendedCommand: value.routingKind === "custom-local" || value.routingKind === "unknown"
+      ? value.commands.restoreNative
+      : value.commands.installService,
+  };
+}
+
+function conservativeFallback(config: Pick<OcxConfig, "codexAutoStart">): StartupHealth {
+  const shim = diagnoseCodexShim();
+  return deriveStartupHealth({
+    routingKind: getCodexRoutingKind(),
+    autostartEnabled: codexAutoStartEnabled(config),
+    serviceInstalled: false,
+    serviceViable: false,
+    serviceEnabled: false,
+    serviceRunning: false,
+    serviceStale: false,
+    serviceConflict: false,
+    serviceSupported: process.platform === "win32" || process.platform === "darwin" || process.platform === "linux",
+    shimInstalled: shim.installed,
+    shimHealthy: shim.healthy,
+    platform: process.platform,
+    diagnosticStale: true,
+  });
+}
+
+function runProbe(config: Pick<OcxConfig, "codexAutoStart">): Promise<StartupHealth> {
+  const bun = durableBunPath();
+  const cli = join(import.meta.dir, "..", "cli", "index.ts");
+  return new Promise(resolve => {
+    execFile(bun, [cli, "__startup-health"], {
+      encoding: "utf8",
+      env: process.env,
+      timeout: PROBE_TIMEOUT_MS,
+      windowsHide: true,
+      maxBuffer: 256 * 1024,
+    }, (error, stdout) => {
+      if (!error) {
+        const lines = stdout.split(/\r?\n/).map(line => line.trim()).filter(Boolean);
+        for (let index = lines.length - 1; index >= 0; index -= 1) {
+          try {
+            const parsed = JSON.parse(lines[index]) as StartupHealth;
+            if (["native", "protected", "at-risk"].includes(parsed.status) && typeof parsed.rebootSafe === "boolean") {
+              resolve({ ...parsed, diagnosticStale: false });
+              return;
+            }
+          } catch { /* scan earlier output; config repair messages may precede JSON */ }
+        }
+      }
+      resolve(cached ? markStartupHealthDiagnosticStale(cached.value) : conservativeFallback(config));
+    });
+  });
+}
+
+function refreshInBackground(config: Pick<OcxConfig, "codexAutoStart">): void {
+  if (inflight) return;
+  const startedGeneration = generation;
+  const probe = runProbe(config).then(value => {
+    if (startedGeneration === generation) cached = { timestamp: Date.now(), value };
+    return value;
+  });
+  inflight = probe.finally(() => {
+    if (inflight === probe || startedGeneration === generation) inflight = null;
+  });
+}
+
+/** Stale-while-revalidate: service-manager probes never hold open a model/UI request. */
+export async function getCachedStartupHealth(config: Pick<OcxConfig, "codexAutoStart">): Promise<StartupHealth> {
+  if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) return cached.value;
+  refreshInBackground(config);
+  return cached ? markStartupHealthDiagnosticStale(cached.value) : conservativeFallback(config);
+}
+
+export function invalidateStartupHealthCache(): void {
+  generation += 1;
+  cached = null;
+  inflight = null;
+}

package/src/server/windows-tray-control.ts

@@ -0,0 +1,41 @@
+import { execFile } from "node:child_process";
+import { join } from "node:path";
+import { durableBunPath } from "../lib/bun-runtime";
+import type { WindowsTrayStatus } from "../tray/windows";
+
+export type WindowsTrayAction = "install" | "start" | "stop" | "status" | "uninstall";
+
+/** Run blocking registry/PowerShell waits outside the proxy event loop. */
+export function runWindowsTrayAction(action: WindowsTrayAction): Promise<WindowsTrayStatus> {
+  if (action === "status") {
+    return import("../tray/windows").then(({ getWindowsTrayStatusAsync }) => getWindowsTrayStatusAsync());
+  }
+  const bun = durableBunPath();
+  const cli = join(import.meta.dir, "..", "cli", "index.ts");
+  return new Promise((resolve, reject) => {
+    execFile(bun, [cli, "tray", action, "--json"], {
+      encoding: "utf8",
+      env: process.env,
+      timeout: 30_000,
+      windowsHide: true,
+      maxBuffer: 256 * 1024,
+    }, (error, stdout, stderr) => {
+      const lines = stdout.split(/\r?\n/).map(line => line.trim()).filter(Boolean);
+      for (let index = lines.length - 1; index >= 0; index -= 1) {
+        try {
+          const parsed = JSON.parse(lines[index]) as WindowsTrayStatus | { error?: unknown };
+          if ("supported" in parsed && typeof parsed.supported === "boolean") {
+            resolve(parsed);
+            return;
+          }
+          const failure = parsed as { error?: unknown };
+          if (typeof failure.error === "string") {
+            reject(new Error(failure.error));
+            return;
+          }
+        } catch { /* scan earlier lines */ }
+      }
+      reject(new Error(error?.message || stderr.trim() || "Windows tray action returned no status"));
+    });
+  });
+}

package/src/service.ts

@@ -88,7 +88,7 @@ function normalizePathForCompare(path: string): string {
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 
-interface ServiceInstallState {
+export interface ServiceInstallState {
   version: 1 | 2;
   codexHome: string;
   opencodexHome: string;
@@ -101,6 +101,23 @@ interface ServiceInstallState {
   winswSha256?: string;
 }
 
+export function parseServiceInstallState(value: unknown): ServiceInstallState | null {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const state = value as Record<string, unknown>;
+  if (state.version !== 1 && state.version !== 2) return null;
+  if (typeof state.codexHome !== "string" || state.codexHome.length === 0) return null;
+  if (typeof state.opencodexHome !== "string" || state.opencodexHome.length === 0) return null;
+  for (const key of ["bunPath", "cliPath", "winswVersion", "winswSha256"] as const) {
+    if (state[key] !== undefined && (typeof state[key] !== "string" || state[key].length === 0)) return null;
+  }
+  if (state.version === 1) {
+    if (state.backend !== undefined) return null;
+  } else if (state.backend !== "scheduler" && state.backend !== "native") {
+    return null;
+  }
+  return state as unknown as ServiceInstallState;
+}
+
 function writeServiceInstallState(backend: ServiceBackend = "scheduler"): void {
   const { bun, cli } = cliEntry();
   const state: ServiceInstallState = {
@@ -124,8 +141,8 @@ function writeServiceInstallState(backend: ServiceBackend = "scheduler"): void {
 function readServiceInstallState(): ServiceInstallState | null {
   for (const path of serviceStatePaths()) {
     try {
-      const parsed = JSON.parse(readFileSync(path, "utf8")) as ServiceInstallState;
-      if (parsed.version === 1 || parsed.version === 2) return parsed;
+      const parsed = parseServiceInstallState(JSON.parse(readFileSync(path, "utf8")));
+      if (parsed) return parsed;
     } catch {
       /* try the next known state path */
     }
@@ -451,6 +468,30 @@ export function buildWindowsTaskXml(script = windowsServiceScriptPath(), launche
 `;
 }
 
+function taskXmlSection(xml: string, tag: string): string {
+  return new RegExp(`<${tag}(?:\\s[^>]*)?>([\\s\\S]*?)<\\/${tag}>`, "i").exec(xml)?.[1] ?? "";
+}
+
+/** Validate the security/lifecycle-critical fields of the registered scheduler task. */
+export function windowsTaskRegistrationHealthy(
+  xml: string,
+  wscript = windowsWscript(),
+  launcher = windowsLauncherVbsPath(),
+): boolean {
+  const trigger = taskXmlSection(xml, "LogonTrigger");
+  const principal = taskXmlSection(xml, "Principal");
+  const settings = taskXmlSection(xml, "Settings");
+  const action = taskXmlSection(xml, "Exec");
+  return /<Enabled>\s*true\s*<\/Enabled>/i.test(trigger)
+    && /<LogonType>\s*InteractiveToken\s*<\/LogonType>/i.test(principal)
+    && /<RunLevel>\s*LeastPrivilege\s*<\/RunLevel>/i.test(principal)
+    && /<Enabled>\s*true\s*<\/Enabled>/i.test(settings)
+    && /<MultipleInstancesPolicy>\s*IgnoreNew\s*<\/MultipleInstancesPolicy>/i.test(settings)
+    && /<ExecutionTimeLimit>\s*PT0S\s*<\/ExecutionTimeLimit>/i.test(settings)
+    && action.includes(`<Command>${taskXmlString(wscript)}</Command>`)
+    && action.includes(`<Arguments>${taskXmlString(`/b /nologo "${launcher}"`)}</Arguments>`);
+}
+
 // ── macOS (launchd) ──
 function installLaunchd(): void {
   const dir = join(homedir(), "Library", "LaunchAgents");
@@ -561,6 +602,7 @@ async function installWindowsNative(): Promise<void> {
 function startWindows(): void { schtasks(["/run", "/tn", TASK]); }
 function stopWindows(): void { try { schtasks(["/end", "/tn", TASK]); } catch { /* not running */ } }
 function statusWindows(): string { try { return schtasks(["/query", "/tn", TASK]); } catch { return ""; } }
+function statusWindowsXml(): string { try { return schtasks(["/query", "/tn", TASK, "/xml"]); } catch { return ""; } }
 function uninstallWindows(): void {
   try { schtasks(["/delete", "/tn", TASK, "/f"]); } catch { /* absent */ }
   if (existsSync(windowsServiceScriptPath())) unlinkSync(windowsServiceScriptPath());
@@ -814,31 +856,141 @@ export function uninstallServiceIfInstalled(): boolean {
 
 /** True if a background service (launchd/systemd/Task Scheduler) is installed. */
 export function isServiceInstalled(): boolean {
-  return serviceStatusSummary().startsWith("installed");
+  return diagnoseService().installed;
+}
+
+export interface ServiceDiagnostic {
+  supported: boolean;
+  installed: boolean;
+  enabled: boolean;
+  running: boolean;
+  viable: boolean;
+  startable: boolean;
+  stale: boolean;
+  conflict: boolean;
+  backend: ServiceBackend | "launchd" | "systemd" | null;
+  summary: string;
+}
+
+/** Windows tray may restart a healthy-but-stopped native service; stale/conflicting installs remain blocked. */
+export function serviceStartableFromTray(service: ServiceDiagnostic): boolean {
+  return service.startable && !service.stale && !service.conflict;
+}
+
+export interface WindowsServiceDiagnosticInputs {
+  schedulerInstalled: boolean;
+  schedulerEnabled: boolean;
+  schedulerAssetsHealthy: boolean;
+  nativeStatus: "started" | "stopped" | "nonexistent" | "unknown";
+  recordedBackend: ServiceBackend | null;
+  staleBakedPaths: boolean;
+  nativeRepairAssetsOnly: boolean;
+  diagnostics: string;
+}
+
+export function deriveWindowsServiceDiagnostic(inputs: WindowsServiceDiagnosticInputs): ServiceDiagnostic {
+  const nativeInstalled = inputs.nativeStatus !== "nonexistent";
+  const conflict = inputs.schedulerInstalled && nativeInstalled;
+  const backendStateMismatch = inputs.schedulerInstalled
+    ? inputs.recordedBackend !== "scheduler"
+    : nativeInstalled && inputs.recordedBackend !== "native";
+  const stale = inputs.staleBakedPaths
+    || (inputs.schedulerInstalled && !inputs.schedulerAssetsHealthy)
+    || backendStateMismatch
+    || (inputs.nativeStatus === "nonexistent" && inputs.nativeRepairAssetsOnly);
+  const backend = inputs.schedulerInstalled ? "scheduler" : nativeInstalled ? "native" : null;
+  const enabled = inputs.schedulerInstalled ? inputs.schedulerEnabled : inputs.nativeStatus === "started";
+  const running = nativeInstalled ? inputs.nativeStatus === "started" : inputs.schedulerInstalled && inputs.schedulerEnabled;
+  const viable = !conflict && !stale
+    && (inputs.schedulerInstalled ? inputs.schedulerEnabled && inputs.schedulerAssetsHealthy : inputs.nativeStatus === "started");
+  const startable = !conflict && !stale
+    && (inputs.schedulerInstalled
+      ? inputs.schedulerEnabled && inputs.schedulerAssetsHealthy
+      : inputs.nativeStatus === "started" || inputs.nativeStatus === "stopped");
+  const detail = conflict
+    ? "CONFLICT: Task Scheduler and native WinSW are both present — run 'ocx service uninstall' then reinstall one"
+    : stale
+      ? "stale or missing service assets — run 'ocx service install' to repair"
+      : inputs.schedulerInstalled
+        ? inputs.schedulerEnabled ? "Task Scheduler enabled" : "Task Scheduler disabled"
+        : nativeInstalled
+          ? `native (WinSW ${WINSW_VERSION}): ${inputs.nativeStatus}`
+          : "not installed";
+  const summary = backend ? `installed, ${detail} (${inputs.diagnostics})` : `not installed (${inputs.diagnostics})`;
+  return {
+    supported: true,
+    installed: inputs.schedulerInstalled || nativeInstalled,
+    enabled,
+    running,
+    viable,
+    startable,
+    stale,
+    conflict,
+    backend,
+    summary,
+  };
 }
 
-export function serviceStatusSummary(): string {
+/**
+ * Fail-closed restart diagnostic. Presence alone is never enough: conflicting
+ * managers, stale baked paths, disabled registrations, and unknown/stopped
+ * native managers cannot claim that Codex will reconnect after a reboot.
+ */
+export function diagnoseService(): ServiceDiagnostic {
   const diagnostics = serviceDiagnosticsSummary();
   if (process.platform === "darwin") {
-    if (!existsSync(plistPath())) return `not installed (${diagnostics})`;
-    const status = statusLaunchd();
-    return status ? `installed (launchd; ${diagnostics})` : `installed, not loaded (${diagnostics})`;
+    const installed = existsSync(plistPath());
+    const running = installed && Boolean(statusLaunchd());
+    const stale = installed && bakedServicePathsDiagnostic() !== null;
+    const viable = installed && running && !stale;
+    const summary = !installed ? `not installed (${diagnostics})`
+      : stale ? `installed, but stale (launchd; ${diagnostics})`
+        : running ? `installed and loaded (launchd; ${diagnostics})`
+          : `installed, not loaded (launchd; ${diagnostics})`;
+    return { supported: true, installed, enabled: running, running, viable, startable: installed && !stale, stale, conflict: false, backend: "launchd", summary };
   }
   if (process.platform === "win32") {
-    const scheduler = statusWindows();
-    const native = winswStatusSummary();
-    if (scheduler && native) return `installed (CONFLICT: Task Scheduler AND native WinSW both present — run 'ocx service uninstall' then reinstall one; ${diagnostics})`;
-    if (native) return `installed (${native}; ${diagnostics})`;
-    return scheduler ? `installed (Task Scheduler; ${diagnostics})` : `not installed (${diagnostics})`;
+    const schedulerXml = statusWindowsXml();
+    const schedulerInstalled = schedulerXml.length > 0;
+    const schedulerSettings = taskXmlSection(schedulerXml, "Settings");
+    const schedulerEnabled = schedulerInstalled && /<Enabled>\s*true\s*<\/Enabled>/i.test(schedulerSettings);
+    const schedulerAssets = [windowsServiceScriptPath(), windowsLauncherVbsPath(), windowsTaskXmlPath()].every(existsSync)
+      && windowsTaskRegistrationHealthy(schedulerXml);
+    const nativeStatus = statusWinswRaw();
+    const installState = readServiceInstallState();
+    const recordedBackend: ServiceBackend | null = !installState
+      ? null
+      : installState.backend === "native" ? "native" : "scheduler";
+    return deriveWindowsServiceDiagnostic({
+      schedulerInstalled,
+      schedulerEnabled,
+      schedulerAssetsHealthy: schedulerAssets,
+      nativeStatus,
+      recordedBackend,
+      staleBakedPaths: bakedServicePathsDiagnostic() !== null,
+      nativeRepairAssetsOnly: Boolean(winswStatusSummary()),
+      diagnostics,
+    });
   }
   if (process.platform === "linux") {
-    if (existsSync("/.dockerenv")) return "unsupported in Docker";
-    if (!isSystemd()) return "unsupported: systemd not found";
-    if (!existsSync(unitPath())) return `not installed (${diagnostics})`;
-    const status = statusSystemd();
-    return status ? `installed (systemd user; ${diagnostics})` : `installed, not running (${diagnostics})`;
+    if (existsSync("/.dockerenv")) return { supported: false, installed: false, enabled: false, running: false, viable: false, startable: false, stale: false, conflict: false, backend: null, summary: "unsupported in Docker" };
+    if (!isSystemd()) return { supported: false, installed: false, enabled: false, running: false, viable: false, startable: false, stale: false, conflict: false, backend: null, summary: "unsupported: systemd not found" };
+    const installed = existsSync(unitPath());
+    const enabled = installed && (() => { try { return sh(`systemctl --user is-enabled ${TASK}`) === "enabled"; } catch { return false; } })();
+    const running = installed && (() => { try { return sh(`systemctl --user is-active ${TASK}`) === "active"; } catch { return false; } })();
+    const stale = installed && bakedServicePathsDiagnostic() !== null;
+    const viable = installed && enabled && running && !stale;
+    const summary = !installed ? `not installed (${diagnostics})`
+      : stale ? `installed, but stale (systemd user; ${diagnostics})`
+        : viable ? `installed, enabled and running (systemd user; ${diagnostics})`
+          : `installed, but ${!enabled ? "disabled" : "not running"} (systemd user; ${diagnostics})`;
+    return { supported: true, installed, enabled, running, viable, startable: installed && !stale, stale, conflict: false, backend: "systemd", summary };
   }
-  return `unsupported on ${process.platform}`;
+  return { supported: false, installed: false, enabled: false, running: false, viable: false, startable: false, stale: false, conflict: false, backend: null, summary: `unsupported on ${process.platform}` };
+}
+
+export function serviceStatusSummary(): string {
+  return diagnoseService().summary;
 }
 
 export function normalizeServiceSubcommand(sub?: string): string {