@bitkyc08/opencodex 2.7.25 → 2.7.26

package/src/update/job.ts

@@ -2,8 +2,9 @@ import { spawn, spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { atomicWriteFile, getConfigDir, readPid } from "../config";
+import { atomicWriteFile, getConfigDir, loadConfig, readPid, readRuntimePort } from "../config";
 import { killProxy } from "../lib/process-control";
+import { waitForPortAvailable } from "../server/ports";
 import { isServiceInstalled } from "../service";
 import {
   type Channel,
@@ -158,18 +159,23 @@ export function restartCommand(
   serviceInstalled: boolean,
   installer: Installer,
   launcher = packageLauncherPath(),
+  port?: number,
 ): { mode: "service" | "proxy"; bin: string; args: string[]; display: string } {
   const mode = serviceInstalled ? "service" : "proxy";
+  const pinPort = !serviceInstalled && typeof port === "number" && Number.isFinite(port) && port > 0;
+  const startArgs = pinPort
+    ? [launcher, "start", "--port", String(Math.trunc(port))]
+    : [launcher, "start"];
   if (installer === "npm") {
     const bin = nodeBin();
-    const args = serviceInstalled ? [launcher, "service", "install"] : [launcher, "start"];
+    const args = serviceInstalled ? [launcher, "service", "install"] : startArgs;
     return { mode, bin, args, display: formatCommand(bin, args) };
   }
   // bun/source installs: restart via the current runtime executable + package launcher (both real
   // .exe files), NOT the `ocx.cmd` shim. Spawning a `.cmd` shell-less throws EINVAL on Windows
   // Node/Bun ≥18.20/20.12 (CVE-2024-27980 hardening) — the same class the npm path (nodeBin) avoids.
   const bin = process.execPath;
-  const args = serviceInstalled ? [launcher, "service", "install"] : [launcher, "start"];
+  const args = serviceInstalled ? [launcher, "service", "install"] : startArgs;
   return { mode, bin, args, display: formatCommand(bin, args) };
 }
 
@@ -264,8 +270,8 @@ function runLoggedCommand(job: UpdateJobState, bin: string, args: string[], time
   return { status: result.status, signal: result.signal };
 }
 
-function spawnDetachedStart(job: UpdateJobState, installer: Installer): void {
-  const cmd = restartCommand(false, installer);
+function spawnDetachedStart(job: UpdateJobState, installer: Installer, port?: number): void {
+  const cmd = restartCommand(false, installer, packageLauncherPath(), port);
   const env = { ...process.env };
   delete env.OCX_SERVICE;
   updateJob(job, {}, `$ ${cmd.display}`);
@@ -278,9 +284,26 @@ function spawnDetachedStart(job: UpdateJobState, installer: Installer): void {
   child.unref();
 }
 
-function restartAfterUpdate(job: UpdateJobState): void {
-  const serviceInstalled = isServiceInstalled();
-  const cmd = restartCommand(serviceInstalled, job.installer);
+/** Test seam: the wait/spawn pair is injectable so the restart path is verifiable. */
+export interface RestartIo {
+  waitForPort?: typeof waitForPortAvailable;
+  spawnStart?: (job: UpdateJobState, installer: Installer, port?: number) => void;
+  serviceInstalledFn?: () => boolean;
+}
+
+async function restartAfterUpdate(
+  job: UpdateJobState,
+  captured?: { port: number; hostname: string },
+  io: RestartIo = {},
+): Promise<void> {
+  const serviceInstalled = (io.serviceInstalledFn ?? isServiceInstalled)();
+  const config = loadConfig();
+  // The stop-first update flow has already cleared pid/runtime state by the time we run,
+  // so the pre-update capture (taken before the update command) is the authoritative
+  // port to wait on; config is only the cold-start fallback.
+  const port = captured?.port ?? config.port ?? 10100;
+  const hostname = captured?.hostname ?? config.hostname ?? "127.0.0.1";
+  const cmd = restartCommand(serviceInstalled, job.installer, packageLauncherPath(), port);
   if (serviceInstalled) {
     const result = runLoggedCommand(job, cmd.bin, cmd.args, RESTART_TIMEOUT_MS);
     if (result.status !== 0) {
@@ -294,13 +317,38 @@ function restartAfterUpdate(job: UpdateJobState): void {
     updateJob(job, {}, `Stopping current proxy PID ${pid}.`);
     killProxy(pid);
   }
-  spawnDetachedStart(job, job.installer);
+  // The old socket can stay busy briefly after stop (Windows taskkill drain, or the
+  // stop-first update path that already killed the proxy before we got here) — wait
+  // unconditionally on the captured port so the pinned start does not race the drain.
+  const waitFn = io.waitForPort ?? waitForPortAvailable;
+  const freed = await waitFn(port, hostname, { timeoutMs: 2000, intervalMs: 25 });
+  if (!freed) {
+    updateJob(job, {}, `Port ${port} still busy after stop; starting with --port ${port} anyway.`);
+  }
+  (io.spawnStart ?? spawnDetachedStart)(job, job.installer, port);
 }
 
-export function runGuiUpdateWorker(jobId: string, channel: Channel, restart: boolean): void {
+/** Exposed for tests: drives the non-service restart path with injected io. */
+export function restartAfterUpdateForTests(
+  job: UpdateJobState,
+  captured: { port: number; hostname: string },
+  io: RestartIo,
+): Promise<void> {
+  return restartAfterUpdate(job, captured, io);
+}
+
+export async function runGuiUpdateWorker(jobId: string, channel: Channel, restart: boolean): Promise<void> {
   let job = readUpdateJob(jobId);
   const check = checkForUpdate(channel);
   const now = new Date().toISOString();
+  // Capture the live listen target BEFORE the update command runs: the stop-first update
+  // flow clears pid/runtime state, so this is the last moment the real port is knowable.
+  const rt = readRuntimePort();
+  const preUpdateConfig = loadConfig();
+  const captured = {
+    port: rt?.port ?? preUpdateConfig.port ?? 10100,
+    hostname: rt?.hostname ?? preUpdateConfig.hostname ?? "127.0.0.1",
+  };
   if (!job) {
     job = {
       id: jobId,
@@ -362,7 +410,7 @@ export function runGuiUpdateWorker(jobId: string, channel: Channel, restart: boo
 
     if (restart) {
       job = updateJob(job, { status: "restarting" }, "Update installed. Restarting proxy...");
-      restartAfterUpdate(job);
+      await restartAfterUpdate(job, captured);
       updateJob(job, { status: "succeeded", restarted: true }, "Restart requested.");
       return;
     }