feat: ChatGPT desktop send-unblock intercept (opt-in)

src/chatgpt/desktop-unblock/launch-watcher.ts

@@ -0,0 +1,182 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { getConfigDir } from "../../config/paths";
+import { CHATGPT_INTERCEPT_HOST } from "./listener";
+import { chatgptUnblockResolverRule } from "./runtime";
+
+/**
+ * Launch integration for the ChatGPT desktop send-unblock intercept.
+ *
+ * The Chromium resolver rule only applies when the app is launched with it, so a normal
+ * Dock/Spotlight start reaches the real chatgpt.com and the composer locks again. This module
+ * installs a launchd agent that watches the app's Electron `SingletonLock` -- written on every
+ * launch -- and, exactly once per launch, restarts the app with the resolver rule if it was
+ * started without one. There is no resident polling process: launchd wakes the script on the
+ * lock event and the script exits after one check.
+ *
+ * The watcher only acts when the opencodex intercept listener is actually listening, so with
+ * the feature off the app is left completely native.
+ */
+
+export const CHATGPT_APP_PATH = "/Applications/ChatGPT.app";
+/** The desktop app is `openai-codex-electron` internally: its Electron userData dir is `Codex`. */
+export const CHATGPT_SINGLETON_LOCK_PATH = "Library/Application Support/Codex/SingletonLock";
+export const CHATGPT_UNBLOCK_WATCHER_LABEL = "com.opencodex.chatgpt-unblock-watcher";
+
+function expandHome(path: string): string {
+  return path.startsWith("~") ? join(homedir(), path.slice(1)) : path;
+}
+
+export interface ChatgptUnblockWatcherPaths {
+  scriptPath: string;
+  plistPath: string;
+  errPath: string;
+  lockPath: string;
+}
+
+export function chatgptUnblockWatcherPaths(configDir?: string): ChatgptUnblockWatcherPaths {
+  const dir = configDir ?? getConfigDir();
+  return {
+    scriptPath: join(dir, "chatgpt-unblock-watcher.sh"),
+    plistPath: expandHome(`~/Library/LaunchAgents/${CHATGPT_UNBLOCK_WATCHER_LABEL}.plist`),
+    errPath: join(dir, "chatgpt-unblock-watcher.err"),
+    lockPath: expandHome(`~/${CHATGPT_SINGLETON_LOCK_PATH}`),
+  };
+}
+
+/** The one-shot launchd script: restart the app with the rule if this launch lacked it. */
+export function buildChatgptUnblockWatcherScript(port: number): string {
+  const rule = chatgptUnblockResolverRule(port);
+  return `#!/bin/bash
+# opencodex ChatGPT send-unblock launch watcher (one-shot, launchd-triggered).
+# Fires when the ChatGPT desktop app creates its Electron SingletonLock (i.e. on every
+# launch). If the app was started WITHOUT the host-resolver rule that points ${CHATGPT_INTERCEPT_HOST} at
+# the opencodex TLS listener (normal Dock/Spotlight launch), it is restarted once with the
+# rule. Correctly-launched instances and an absent intercept are left alone.
+
+PORT=${port}
+RULE='${rule}'
+LOG="$HOME/.opencodex/chatgpt-unblock-watcher.log"
+
+log() { echo "$(date '+%F %T') $*" >> "$LOG"; }
+
+# Intercept must be listening; otherwise leave the app alone.
+if ! lsof -nP -iTCP:"$PORT" -sTCP:LISTEN >/dev/null 2>&1; then
+  exit 0
+fi
+# App running?
+if ! pgrep -f "ChatGPT.app/Contents/MacOS/ChatGPT" >/dev/null 2>&1; then
+  exit 0
+fi
+# Already launched with the rule?
+if pgrep -f "MacOS/ChatGPT $RULE" >/dev/null 2>&1; then
+  exit 0
+fi
+log "unflagged ChatGPT detected; restarting with resolver rule"
+osascript -e 'quit app "ChatGPT"' >/dev/null 2>&1
+sleep 3
+open -a ChatGPT --args "$RULE"
+log "relaunched with rule"
+`;
+}
+
+/** One-shot launchd agent: wake on the app's SingletonLock event, run the script, exit. */
+export function buildChatgptUnblockWatcherPlist(scriptPath: string, watchPath: string, errPath: string): string {
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${CHATGPT_UNBLOCK_WATCHER_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>/bin/bash</string>
+    <string>${scriptPath}</string>
+  </array>
+  <key>WatchPaths</key>
+  <array>
+    <string>${watchPath}</string>
+  </array>
+  <key>StandardErrorPath</key>
+  <string>${errPath}</string>
+</dict>
+</plist>
+`;
+}
+
+function sh(command: string, args: string[]): { ok: boolean; output: string } {
+  try {
+    const output = execFileSync(command, args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+    return { ok: true, output };
+  } catch (error) {
+    const err = error as { status?: number; stdout?: string; stderr?: string };
+    return { ok: false, output: `${err.stdout ?? ""}${err.stderr ?? ""}`.trim() };
+  }
+}
+
+export interface InstallChatgptUnblockWatcherOptions {
+  port: number;
+  configDir?: string;
+  /** Test seam: skip the macOS / app-presence guards. */
+  assumeSupported?: boolean;
+}
+
+/** Install the launch watcher: write script + agent plist and load it with launchd. */
+export function installChatgptUnblockWatcher(options: InstallChatgptUnblockWatcherOptions): void {
+  if (process.platform !== "darwin" && !options.assumeSupported) {
+    throw new Error("the ChatGPT launch watcher is only supported on macOS");
+  }
+  if (!options.assumeSupported && !existsSync(CHATGPT_APP_PATH)) {
+    throw new Error(`${CHATGPT_APP_PATH} not found; install the ChatGPT desktop app first`);
+  }
+  const paths = chatgptUnblockWatcherPaths(options.configDir);
+  mkdirSync(expandHome("~/Library/LaunchAgents"), { recursive: true });
+  writeFileSync(paths.scriptPath, buildChatgptUnblockWatcherScript(options.port), { mode: 0o700 });
+  writeFileSync(paths.plistPath, buildChatgptUnblockWatcherPlist(paths.scriptPath, paths.lockPath, paths.errPath));
+  // Idempotent load: boot out any previous generation first.
+  sh("launchctl", ["bootout", `gui/${process.getuid?.() ?? 0}/${CHATGPT_UNBLOCK_WATCHER_LABEL}`]);
+  sh("launchctl", ["bootstrap", `gui/${process.getuid?.() ?? 0}`, paths.plistPath]);
+}
+
+/** Remove the launch watcher: unload the agent and delete its files. */
+export function uninstallChatgptUnblockWatcher(configDir?: string): void {
+  const paths = chatgptUnblockWatcherPaths(configDir);
+  sh("launchctl", ["bootout", `gui/${process.getuid?.() ?? 0}/${CHATGPT_UNBLOCK_WATCHER_LABEL}`]);
+  for (const path of [paths.plistPath, paths.scriptPath]) {
+    try {
+      rmSync(path);
+    } catch {
+      /* already gone */
+    }
+  }
+}
+
+export interface ChatgptUnblockWatcherStatus {
+  scriptInstalled: boolean;
+  plistInstalled: boolean;
+  agentLoaded: boolean;
+  scriptUpToDate: boolean;
+  plistUpToDate: boolean;
+}
+
+export function chatgptUnblockWatcherStatus(port: number, configDir?: string): ChatgptUnblockWatcherStatus {
+  const paths = chatgptUnblockWatcherPaths(configDir);
+  const scriptInstalled = existsSync(paths.scriptPath);
+  const plistInstalled = existsSync(paths.plistPath);
+  const agentLoaded = sh("launchctl", ["print", `gui/${process.getuid?.() ?? 0}/${CHATGPT_UNBLOCK_WATCHER_LABEL}`]).ok;
+  const scriptUpToDate = scriptInstalled
+    && readFileSync(paths.scriptPath, "utf8") === buildChatgptUnblockWatcherScript(port);
+  const plistUpToDate = plistInstalled
+    && readFileSync(paths.plistPath, "utf8") === buildChatgptUnblockWatcherPlist(paths.scriptPath, paths.lockPath, paths.errPath);
+  return { scriptInstalled, plistInstalled, agentLoaded, scriptUpToDate, plistUpToDate };
+}
+
+/** Launch the ChatGPT desktop app with the resolver rule (macOS). */
+export function launchChatgptWithRule(port: number): void {
+  if (process.platform !== "darwin") {
+    throw new Error("launching the ChatGPT desktop app is only supported on macOS");
+  }
+  execFileSync("open", ["-a", "ChatGPT", "--args", chatgptUnblockResolverRule(port)], { stdio: "ignore" });
+}

src/chatgpt/desktop-unblock/listener.ts

@@ -0,0 +1,140 @@
+import type { Server } from "bun";
+import type { PemKeyPair } from "../../claude/intercept/local-ca";
+import { forwardHeadersForUpstream } from "../../claude/intercept/listener";
+import { stripSendBlocksFromJson, stripSendBlocksFromSseLine } from "./rewrite";
+
+/**
+ * TLS listener for the ChatGPT desktop send-unblock intercept.
+ *
+ * Launched with `--host-resolver-rules="MAP chatgpt.com 127.0.0.1:<port>"`, the desktop app
+ * dialls this listener believing it reached chatgpt.com. Requests are relayed verbatim to the
+ * real upstream with the caller's own auth headers; responses pass through untouched except
+ * that conversation payloads lose their client-side send-lock entries. Nothing is logged and
+ * no credential is persisted -- the listener is a pipe, not a store.
+ *
+ * Only the exact host `chatgpt.com` is ever presented here. Subdomains (`ab.chatgpt.com`,
+ * `codex-cloud-backend.chatgpt.com`) and `auth.openai.com` are not mapped by the launcher, so
+ * login, telemetry and cloud sessions stay native.
+ */
+
+export const CHATGPT_UNBLOCK_UPSTREAM = "https://chatgpt.com";
+export const CHATGPT_INTERCEPT_HOST = "chatgpt.com";
+
+// fetch() transparently decodes the body, so the encoding headers would describe bytes the
+// client never sees.
+const RESPONSE_STRIP_HEADERS = new Set([
+  "connection", "keep-alive", "transfer-encoding", "content-encoding", "content-length",
+]);
+
+export interface ChatgptUnblockListenerOptions {
+  leaf: PemKeyPair;
+  upstreamBase?: string;
+  idleTimeout?: number;
+  fetchImpl?: typeof fetch;
+  /** Test seam: bind a fixed port instead of an ephemeral one. */
+  port?: number;
+}
+
+function responseHeaders(source: Response): Headers {
+  const headers = new Headers();
+  source.headers.forEach((value, name) => {
+    if (!RESPONSE_STRIP_HEADERS.has(name.toLowerCase())) headers.append(name, value);
+  });
+  return headers;
+}
+
+/**
+ * Line-oriented SSE rewriter. Complete lines are checked one at a time so an untouched stream
+ * keeps its exact chunking and line endings; only `data:` lines whose JSON loses an entry are
+ * re-serialized.
+ */
+export function sseRewriteStream(debug?: (line: string, rewritten: string | null) => void): TransformStream<Uint8Array, Uint8Array> {
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  let pending = "";
+  return new TransformStream<Uint8Array, Uint8Array>({
+    transform(chunk, controller) {
+      pending += decoder.decode(chunk, { stream: true });
+      let index: number;
+      while ((index = pending.indexOf("\n")) !== -1) {
+        const line = pending.slice(0, index);
+        pending = pending.slice(index + 1);
+        const rewritten = stripSendBlocksFromSseLine(line);
+        debug?.(line, rewritten);
+        controller.enqueue(encoder.encode(`${rewritten ?? line}\n`));
+      }
+    },
+    flush(controller) {
+      if (pending.length === 0) return;
+      const rewritten = stripSendBlocksFromSseLine(pending);
+      debug?.(pending, rewritten);
+      controller.enqueue(encoder.encode(rewritten ?? pending));
+      pending = "";
+    },
+  });
+}
+
+function isJsonContentType(contentType: string): boolean {
+  return contentType.includes("application/json") || contentType.endsWith("+json");
+}
+
+function isEventStreamContentType(contentType: string): boolean {
+  return contentType.includes("text/event-stream");
+}
+
+export async function relayWithSendUnblock(
+  req: Request,
+  upstreamBase: string,
+  fetchImpl: typeof fetch = fetch,
+): Promise<Response> {
+  const url = new URL(req.url);
+  const target = `${upstreamBase.replace(/\/$/, "")}${url.pathname}${url.search}`;
+  const hasBody = req.method !== "GET" && req.method !== "HEAD";
+  let upstream: Response;
+  try {
+    upstream = await fetchImpl(target, {
+      method: req.method,
+      headers: forwardHeadersForUpstream(req.headers),
+      body: hasBody ? req.body : undefined,
+      signal: req.signal,
+      redirect: "manual",
+      // @ts-expect-error -- streaming request bodies require half duplex under the fetch spec.
+      duplex: "half",
+    });
+  } catch (error) {
+    return Response.json(
+      { error: { message: `chatgpt unblock relay failed: ${error instanceof Error ? error.message : String(error)}` } },
+      { status: 502 },
+    );
+  }
+  const headers = responseHeaders(upstream);
+  const contentType = upstream.headers.get("content-type") ?? "";
+  if (isJsonContentType(contentType)) {
+    let text: string;
+    try {
+      text = await upstream.text();
+    } catch {
+      return new Response(JSON.stringify({ error: { message: "chatgpt unblock upstream read failed" } }), { status: 502, headers });
+    }
+    const rewritten = stripSendBlocksFromJson(text);
+    return new Response(rewritten ?? text, { status: upstream.status, statusText: upstream.statusText, headers });
+  }
+  if (isEventStreamContentType(contentType) && upstream.body) {
+    return new Response(upstream.body.pipeThrough(sseRewriteStream()), { status: upstream.status, statusText: upstream.statusText, headers });
+  }
+  return new Response(upstream.body, { status: upstream.status, statusText: upstream.statusText, headers });
+}
+
+/** Bind the intercept TLS listener on an ephemeral loopback port. */
+export function startChatgptUnblockListener<T = undefined>(options: ChatgptUnblockListenerOptions): Server<T> {
+  const upstreamBase = options.upstreamBase ?? CHATGPT_UNBLOCK_UPSTREAM;
+  return Bun.serve<T>({
+    port: options.port ?? 0,
+    hostname: "127.0.0.1",
+    tls: { cert: options.leaf.certPem, key: options.leaf.keyPem },
+    idleTimeout: options.idleTimeout ?? 255,
+    async fetch(req) {
+      return relayWithSendUnblock(req, upstreamBase, options.fetchImpl);
+    },
+  });
+}