codexteer 0.16.0 → 0.18.0

package/src/update.mjs

@@ -0,0 +1,158 @@
+import { spawn, spawnSync } from "node:child_process";
+import { mkdir, lstat, readFile, writeFile, rename, rmdir, realpath } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { setTimeout as delay } from "node:timers/promises";
+import { codexHome } from "./runtime.mjs";
+import { prepareCodexHome, prepareDeployment } from "./distribution.mjs";
+import { APP_PATH, startDesktop, appServerDoctor } from "./launcher.mjs";
+
+const script = fileURLToPath(new URL("../scripts/update-desktop.applescript", import.meta.url));
+const error = (code, message) => Object.assign(new Error(message), { code });
+function run(command, args) {
+  const result = spawnSync(command, args, { encoding: "utf8", timeout: 10000 });
+  if (result.error || result.status !== 0) throw error("UPDATE_COMMAND_FAILED", result.error?.message ?? result.stderr?.trim() ?? `${command} failed`);
+  return result.stdout.trim();
+}
+export function updateUi(operation) { return run("/usr/bin/osascript", [script, operation]); }
+export function updateBuild() {
+  return run("/usr/libexec/PlistBuddy", ["-c", "Print :CFBundleVersion", `${APP_PATH}/Contents/Info.plist`]);
+}
+export function desktopPids() {
+  return run("/bin/ps", ["-axo", "pid=,comm="]).split("\n").flatMap(line => {
+    const match = line.trim().match(/^(\d+)\s+(.+)$/);
+    return match?.[2] === `${APP_PATH}/Contents/MacOS/ChatGPT` ? [Number(match[1])] : [];
+  });
+}
+
+// Separate orchestration from platform effects to exercise restarts/failures without
+// updating the developer's app. No signal-based termination or task resumption.
+export async function performUpdate({ timeoutMs = 600000, initialBuild, initialPids }, {
+  build = updateBuild, pids = desktopPids, ui = updateUi,
+  quit = () => run("/usr/bin/osascript", ["-e", 'tell application id "com.openai.codex" to quit']),
+  start = startDesktop, doctor = appServerDoctor, save = async () => {}, sleep = delay, now = Date.now,
+} = {}) {
+  const deadline = now() + timeoutMs;
+  let lastPhase = "checking", newBuild;
+  await save({ phase: lastPhase, initial_build: initialBuild });
+  await ui("check");
+  while (now() < deadline) {
+    const running = await pids();
+    try { newBuild = await build(); }
+    catch (e) {
+      // Sparkle can temporarily move the bundle away during installation.
+      if (!running.length && ["downloading", "installing"].includes(lastPhase)) { await sleep(1000); continue; }
+      throw e;
+    }
+    // Both the on-disk build and process generation must change before quitting
+    // the relaunched app. Do not interrupt Sparkle's installation or its old app.
+    if (newBuild !== initialBuild && running.length && running.every(pid => !initialPids.includes(pid))) break;
+    if (running.length && newBuild === initialBuild && lastPhase !== "installing") {
+      let phase;
+      try { phase = await ui("advance"); }
+      catch (e) {
+        // The app can exit between the process snapshot and the AX request.
+        if (!(await pids()).length) { await sleep(1000); continue; }
+        throw e;
+      }
+      if (phase === "up_to_date") return { phase, initial_build: initialBuild, final_build: newBuild, wrapper_verified: false };
+      if (["downloading", "installing"].includes(phase) && phase !== lastPhase) {
+        lastPhase = phase; await save({ phase });
+      }
+    }
+    await sleep(1000);
+  }
+  if (now() >= deadline) throw error("UPDATE_TIMEOUT", "Update/relaunch did not complete in time. Inspect Codex or its updater for dialogs. No processes were forcibly stopped.");
+  await save({ phase: "restoring_wrapper", final_build: newBuild });
+  await quit();
+  const quitDeadline = now() + 30000;
+  while ((await pids()).length) {
+    if (now() >= quitDeadline) throw error("UPDATE_QUIT_TIMEOUT", "Codex did not quit normally. Finish its work, quit it, and run codexteer desktop start.");
+    await sleep(500);
+  }
+  await start();
+  const report = await doctor();
+  if (!report.ready || report.connection?.mode !== "shared" || !report.checks?.bundled_wrapper_node || report.cli_version_status !== "matched") {
+    throw error("UPDATE_WRAPPER_UNVERIFIED", "Update installed, but wrapper verification failed. Run codexteer doctor --json.");
+  }
+  return { phase: "complete", initial_build: initialBuild, final_build: newBuild, wrapper_verified: true, doctor: report };
+}
+
+async function privateDirectory(directory) {
+  await mkdir(directory, { mode: 0o700 }).catch(e => { if (e.code !== "EEXIST") throw e; });
+  const info = await lstat(directory);
+  if (!info.isDirectory() || info.isSymbolicLink() || info.uid !== process.getuid() || (info.mode & 0o077)) throw error("UPDATE_STATE_UNSAFE", `Unsafe update state directory: ${directory}`);
+}
+async function stateRoot(requestedHome = codexHome()) {
+  const home = await prepareCodexHome(requestedHome);
+  const parent = path.join(home, "codex-steer");
+  await privateDirectory(parent);
+  const root = path.join(parent, "desktop-update");
+  await privateDirectory(root);
+  return { home, root };
+}
+async function writeStatus(root, state) {
+  const temporary = path.join(root, `status-${process.pid}.tmp`);
+  await writeFile(temporary, JSON.stringify({ ...state, updated_at: new Date().toISOString() }) + "\n", { mode: 0o600, flag: "wx" });
+  await rename(temporary, path.join(root, "status.json"));
+}
+export async function desktopUpdateStatus() {
+  const { root } = await stateRoot();
+  try {
+    const file = path.join(root, "status.json"), info = await lstat(file);
+    if (!info.isFile() || info.isSymbolicLink() || info.uid !== process.getuid() || (info.mode & 0o077)) throw error("UPDATE_STATE_UNSAFE", "Unsafe update status file.");
+    const state = JSON.parse(await readFile(file, "utf8"));
+    if (state.worker_pid && !["complete", "up_to_date", "failed"].includes(state.phase)) {
+      try { process.kill(state.worker_pid, 0); state.worker_alive = true; }
+      catch (e) { if (e.code !== "ESRCH") throw e; state.worker_alive = false; }
+    }
+    return state;
+  } catch (e) { if (e.code === "ENOENT") return { phase: "not_started" }; throw e; }
+}
+export async function launchDesktopUpdate({ dryRun = false, timeoutMs = 600000 } = {}, {
+  platform = process.platform, executablePath = process.execPath, pids = desktopPids,
+  ui = updateUi, build = updateBuild, prepare = prepareDeployment, spawnWorker = spawn,
+  home: requestedHome = codexHome(),
+} = {}) {
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 10000 || timeoutMs > 3600000) throw error("UPDATE_ARGUMENT", "--timeout-ms must be an integer between 10000 and 3600000.");
+  if (dryRun) return { dry_run: true, started: false, timeout_ms: timeoutMs, steps: ["official_update_ui", "wait_for_new_build_and_relaunch", "normal_quit", "wrapper_start", "doctor"] };
+  if (platform !== "darwin") throw error("UPDATE_PLATFORM", "Desktop update requires macOS.");
+  if (process.env.CODEX_APP_SERVER_WS_URL?.trim()) throw error("UPDATE_ENVIRONMENT", "Remove CODEX_APP_SERVER_WS_URL before updating with a shared wrapper.");
+  const executable = await realpath(executablePath);
+  if (executable.includes(".app/Contents/")) throw error("UPDATE_NODE", "Run desktop update with an external Node installation, so replacing the app cannot remove the worker runtime.");
+  const initialPids = pids();
+  if (initialPids.length !== 1) throw error("UPDATE_APP_STATE", "Exactly one running Codex Desktop is required.");
+  if (ui("preflight") !== "checking") throw error("UPDATE_UI_UNAVAILABLE", "Codex update menu is unavailable. Allow Accessibility/Automation for your terminal and retry.");
+  const initialBuild = build();
+  const { home, root } = await stateRoot(requestedHome);
+  const deployment = await prepare(home);
+  const lock = path.join(root, "lock");
+  await mkdir(lock, { mode: 0o700 }).catch(e => {
+    if (e.code === "EEXIST") throw error("UPDATE_BUSY", `An update lock exists. Check desktop update-status; if its worker has stopped, inspect the app before manually removing ${lock}.`);
+    throw e;
+  });
+  try {
+    await writeStatus(root, { phase: "starting", initial_build: initialBuild });
+    const child = spawnWorker(executable, [path.join(deployment.directory, "bin/codexteer-update.mjs"), JSON.stringify({ root, timeoutMs, initialBuild, initialPids })], {
+      detached: true, stdio: "ignore", cwd: deployment.directory, env: { ...process.env, CODEX_HOME: home },
+    });
+    await new Promise((resolve, reject) => { child.once("spawn", resolve); child.once("error", reject); });
+    child.unref();
+    return { started: true, worker_pid: child.pid, status_command: "codexteer desktop update-status --json", status_path: path.join(root, "status.json") };
+  } catch (e) { await writeStatus(root, { phase: "failed", error: e.message }); await rmdir(lock); throw e; }
+}
+export async function updateWorker(options) {
+  let state = { phase: "starting", worker_pid: process.pid, initial_build: options.initialBuild };
+  const save = async patch => { state = { ...state, ...patch }; await writeStatus(options.root, state); };
+  try {
+    await save({});
+    const running = desktopPids();
+    if (updateBuild() !== options.initialBuild || running.length !== 1 || running[0] !== options.initialPids[0]) {
+      throw error("UPDATE_APP_CHANGED", "Codex changed after preflight. Inspect its update state before retrying.");
+    }
+    await save(await performUpdate(options, { save }));
+  } catch (e) {
+    await save({ phase: "failed", error: { code: e.code ?? "UPDATE_FAILED", message: e.message }, recovery: "Inspect Codex and the updater. After installation finishes, quit normally and run codexteer desktop start, then codexteer doctor --json." });
+    process.exitCode = 1;
+  } finally { await rmdir(path.join(options.root, "lock")); }
+}

package/src/wrapper.mjs

@@ -1,7 +1,8 @@
 import { spawn, spawnSync } from "node:child_process";
-import { chmod, stat } from "node:fs/promises";
+import { accessSync, constants as fsConstants, readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { once } from "node:events";
 import { setTimeout as delay } from "node:timers/promises";
+import path from "node:path";
 import { claimRuntime } from "./runtime.mjs";
 import { connectSocket } from "./rpc.mjs";
 import { relay } from "./bridge.mjs";
@@ -9,8 +10,61 @@ import { DesktopSubscriptions, serveSubscriptions } from "./subscription.mjs";
 import { VERSION, PACKAGE_NAME } from "./version.mjs";
 import { RUNTIME_PROTOCOL, RUNTIME_CAPABILITIES } from "./compatibility.mjs";
 import { describeDistribution } from "./distribution.mjs";
+import { inspectAppServerSocket } from "./socket-endpoint.mjs";
 
-export const BUNDLED_CLI = "/Applications/ChatGPT.app/Contents/Resources/codex";
+const DESKTOP_RESOURCES = "/Applications/ChatGPT.app/Contents/Resources";
+const LEGACY_BUNDLED_CLI = path.join(DESKTOP_RESOURCES, "codex");
+
+function isWithinDirectory(directory, candidate) {
+  const relative = path.relative(directory, candidate);
+  return relative !== "" && relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+
+function resolveManifestCli(packageDirectory, resourcesDirectory) {
+  try {
+    const root = realpathSync(packageDirectory);
+    if (!isWithinDirectory(resourcesDirectory, root)) return null;
+    const manifest = JSON.parse(readFileSync(path.join(root, "codex-package.json"), "utf8"));
+    if ((manifest.variant != null && manifest.variant !== "codex")
+      || (manifest.layoutVersion != null && (!Number.isSafeInteger(manifest.layoutVersion) || manifest.layoutVersion < 1))
+      || typeof manifest.entrypoint !== "string" || manifest.entrypoint.length === 0
+      || manifest.entrypoint.includes("\0") || path.isAbsolute(manifest.entrypoint)
+      || manifest.entrypoint.split(/[\\/]/).some(part => part === "" || part === "." || part === "..")) return null;
+
+    const entrypoint = realpathSync(path.resolve(root, manifest.entrypoint));
+    if (!isWithinDirectory(root, entrypoint) || !statSync(entrypoint).isFile()) return null;
+    accessSync(entrypoint, fsConstants.X_OK);
+    return entrypoint;
+  } catch {
+    return null;
+  }
+}
+
+function resolveBundledCli() {
+  try {
+    const resourcesDirectory = realpathSync(DESKTOP_RESOURCES);
+    const packages = readdirSync(resourcesDirectory, { withFileTypes: true })
+      .filter(entry => entry.isDirectory() || entry.isSymbolicLink())
+      .map(entry => path.join(resourcesDirectory, entry.name))
+      .sort();
+    const manifestCli = packages.map(directory => resolveManifestCli(directory, resourcesDirectory)).find(Boolean);
+    if (manifestCli) return manifestCli;
+  } catch {
+    // Fall through to the pre-manifest app layout.
+  }
+
+  try {
+    if (statSync(LEGACY_BUNDLED_CLI).isFile()) {
+      accessSync(LEGACY_BUNDLED_CLI, fsConstants.X_OK);
+      return LEGACY_BUNDLED_CLI;
+    }
+  } catch {
+    // Preserve the legacy path for a useful ENOENT diagnostic at startup.
+  }
+  return LEGACY_BUNDLED_CLI;
+}
+
+export const BUNDLED_CLI = resolveBundledCli();
 export const BUNDLED_NODE = "/Applications/ChatGPT.app/Contents/Resources/cua_node/bin/node";
 const DESKTOP_EXECUTABLE = "/Applications/ChatGPT.app/Contents/MacOS/ChatGPT";
 
@@ -95,6 +149,7 @@ export async function runWrapper(args, { executable = BUNDLED_CLI, env = process
     codex_steer_package: PACKAGE_NAME, codex_steer_version: VERSION, codex_steer_protocol: RUNTIME_PROTOCOL,
     codex_steer_capabilities: RUNTIME_CAPABILITIES,
     distribution_sha256: distribution.sha256,
+    native_tools_pipe: env.CODEX_APP_TOOLS_PIPE_PATH ?? null,
   });
   let child;
   let socket;
@@ -110,14 +165,22 @@ export async function runWrapper(args, { executable = BUNDLED_CLI, env = process
     });
     let spawnError;
     child.on("error", error => { spawnError = error; });
+    let endpoint;
+    let socketError;
     for (let i = 0; i < 100; i++) {
       if (interrupted || spawnError || child.exitCode != null || child.signalCode != null) throw new Error("App Server exited during startup.");
-      if (await stat(lease.paths.socket).catch(() => null)) break;
+      try {
+        endpoint = await inspectAppServerSocket(lease.paths.socket);
+        break;
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+        socketError = error;
+      }
       await delay(100);
     }
-    await chmod(lease.paths.socket, 0o600);
+    if (!endpoint) throw socketError ?? new Error("App Server socket did not become ready during startup.");
     await lease.update({ server_pid: child.pid });
-    socket = await connectSocket(lease.paths.socket);
+    socket = await connectSocket(endpoint.socket);
     subscriptions = new DesktopSubscriptions(socket);
     stopSubscriptions = await serveSubscriptions(lease.paths.control, subscriptions);
     let initId;