codex-copilot-dx 0.4.16 → 0.4.17

package/README.md

@@ -36,6 +36,8 @@ On first run, it will:
 
 Claude Code picks up the new `ANTHROPIC_BASE_URL` on its next launch.
 
+If an existing `codex-copilot-dx` adapter is already running on the configured host and port, a second launch reuses it instead of starting another proxy. The second launch still refreshes Codex and Claude Code config, then exits.
+
 Do not set Claude Code by manually exporting `ANTHROPIC_BASE_URL` or `ANTHROPIC_AUTH_TOKEN` in your shell. Let `codex-copilot-dx` write the local config files instead. If you previously exported those variables, remove them from shell startup files and restart the terminal before launching Claude Code.
 
 ### Diagnostics
@@ -73,6 +75,8 @@ CCDX_CONFIGURE_CLAUDE_DESKTOP=1 npx codex-copilot-dx@latest
 
 This writes a local Claude App 3P gateway profile that points to the adapter root URL, such as `http://127.0.0.1:2026`. The profile uses a generated local bearer key unless `CCDX_CLAUDE_DESKTOP_API_KEY` is set. Restart Claude App after running the command.
 
+When reusing an already-running adapter, Claude App profile updates require `CCDX_CLAUDE_DESKTOP_API_KEY` or `CCDX_PROXY_API_KEY` so the profile key matches the running process. Otherwise the existing adapter is left untouched.
+
 ## Configuration
 
 Environment variables:
@@ -96,6 +100,9 @@ Environment variables:
 | `CCDX_GITHUB_TOKEN_PATH` | unset | Explicit file containing a GitHub Copilot OAuth token to validate and import before device login |
 | `CCDX_GITHUB_TOKEN_PATHS` | unset | Multiple token files separated by the platform path delimiter (`:` on macOS/Linux, `;` on Windows) |
 | `CCDX_DISABLE_TOKEN_DISCOVERY` | unset | Set to `1` to skip local token discovery and go straight to the saved token or device flow |
+| `CCDX_TOKEN_LOCK_TIMEOUT_MS` | `600000` | Maximum time to wait for another local process to finish GitHub token login/import |
+| `CCDX_TOKEN_LOCK_STALE_MS` | `900000` | Age after which a stale GitHub token lock file can be removed |
+| `CCDX_EXISTING_ADAPTER_TIMEOUT_MS` | `500` | Timeout for detecting an already-running local adapter during startup |
 | `CCDX_USAGE_PATH` | `~/.local/share/codex-copilot-dx/usage.jsonl` | Local JSONL token usage log |
 | `CCDX_DISABLE_USAGE` | unset | Set to `1` to disable usage logging |
 

package/bin/cli.mjs

@@ -11,10 +11,12 @@ import { status } from "../src/status.mjs";
 import { printUsageSummary } from "../src/usage.mjs";
 import { checkForUpdate, localPackageVersion } from "../src/version.mjs";
 import { runDoctor } from "../src/doctor.mjs";
+import { checkRunningAdapter } from "../src/running-adapter.mjs";
 
 const ADAPTER_PORT = parseInt(process.env.ADAPTER_PORT || "2026");
 const ADAPTER_HOST = process.env.ADAPTER_HOST || "127.0.0.1";
 const MODEL_REFRESH_TIMEOUT_MS = parseInt(process.env.CCDX_MODEL_REFRESH_TIMEOUT_MS || "5000", 10);
+const EXISTING_ADAPTER_TIMEOUT_MS = parseInt(process.env.CCDX_EXISTING_ADAPTER_TIMEOUT_MS || "500", 10);
 const LOCAL_VERSION = localPackageVersion();
 const command = process.argv[2];
 const CONFIGURE_CLAUDE_DESKTOP = command === "--configure-claude-desktop" || process.env.CCDX_CONFIGURE_CLAUDE_DESKTOP === "1";
@@ -56,6 +58,49 @@ async function refreshClaudeDesktopModelDefs() {
   }
 }
 
+function currentClaudeDesktopApiKey() {
+  return process.env.CCDX_CLAUDE_DESKTOP_API_KEY || process.env.CCDX_PROXY_API_KEY || "";
+}
+
+async function reuseRunningAdapterIfAvailable() {
+  const running = await checkRunningAdapter({
+    port: ADAPTER_PORT,
+    host: ADAPTER_HOST,
+    timeoutMs: EXISTING_ADAPTER_TIMEOUT_MS,
+  });
+  if (!running.ok) return false;
+
+  console.log(status("ok", `Using existing adapter at ${running.baseUrl}`));
+  ensureCodexConfig(ADAPTER_PORT);
+  ensureClaudeConfig(ADAPTER_PORT);
+
+  if (CONFIGURE_CLAUDE_DESKTOP) {
+    const claudeDesktopApiKey = currentClaudeDesktopApiKey();
+    if (claudeDesktopApiKey) {
+      const result = applyClaudeDesktopConfig({
+        port: ADAPTER_PORT,
+        host: ADAPTER_HOST,
+        gatewayApiKey: claudeDesktopApiKey,
+        modelIds: claudeDesktopModelIds(process.env),
+      });
+      console.log(status("ok", `Configured Claude App gateway profile at ${result.baseUrl}`));
+      console.log(formatClaudeDesktopApplyResult(result));
+    } else {
+      console.log(status("warn", "Existing adapter is running; skip Claude App profile update unless CCDX_CLAUDE_DESKTOP_API_KEY or CCDX_PROXY_API_KEY is set"));
+    }
+  } else {
+    console.log(status("ok", "Claude App support available with --configure-claude-desktop"));
+  }
+
+  openCodex();
+  console.log(`
+  ${status("ok", "Ready, using the existing codex-copilot-dx adapter")}
+
+  Adapter: ${running.baseUrl}
+`);
+  return true;
+}
+
 if (command === "--version" || command === "-v" || command === "version") {
   console.log(`codex-copilot-dx v${LOCAL_VERSION}`);
   process.exit(0);
@@ -83,6 +128,8 @@ checkForUpdate({ currentVersion: LOCAL_VERSION }).then(({ latestVersion, updateA
 });
 
 try {
+  if (await reuseRunningAdapterIfAvailable()) process.exit(0);
+
   // Ensure GitHub login, using device flow if no token exists.
   await ensureAuth();
 
@@ -95,8 +142,8 @@ try {
   }
 
   const claudeDesktopApiKey = CONFIGURE_CLAUDE_DESKTOP
-    ? (process.env.CCDX_CLAUDE_DESKTOP_API_KEY || process.env.CCDX_PROXY_API_KEY || generatedClaudeDesktopApiKey())
-    : (process.env.CCDX_CLAUDE_DESKTOP_API_KEY || process.env.CCDX_PROXY_API_KEY || "");
+    ? (currentClaudeDesktopApiKey() || generatedClaudeDesktopApiKey())
+    : currentClaudeDesktopApiKey();
 
   // Start the in-process adapter.
   await startAdapter(ADAPTER_PORT, ADAPTER_HOST, { claudeDesktopApiKey, claudeDesktopModelDefs });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-copilot-dx",
-  "version": "0.4.16",
+  "version": "0.4.17",
   "description": "Use Codex Desktop, Claude Code, and Claude App with GitHub Copilot",
   "type": "module",
   "bin": {

package/src/adapter.mjs

@@ -8,6 +8,7 @@ import { anthropicToChat, chatToAnthropic, streamAnthropicFromLines, countTokens
 import { claudeDesktopModelsResponse, resolveAnthropicModel } from "./models.mjs";
 import { status } from "./status.mjs";
 import { recordAnthropicUsage, recordResponsesUsage } from "./usage.mjs";
+import { ADAPTER_HEALTH_PATH, adapterHealthPayload } from "./running-adapter.mjs";
 
 // Models that only support Responses API (not chat/completions)
 const RESPONSES_ONLY = new Set([
@@ -574,6 +575,12 @@ export function startAdapter(port = 2026, host = "127.0.0.1", options = {}) {
   const server = http.createServer((req, res) => {
     const pathname = requestPath(req.url);
 
+    if (req.method === "GET" && pathname === ADAPTER_HEALTH_PATH) {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(adapterHealthPayload()));
+      return;
+    }
+
     if (req.method === "POST" && pathname === "/v1/responses") {
       (async () => {
         const abort = createRequestAbort(req, res);

package/src/auth.mjs

@@ -3,6 +3,7 @@ import path from "node:path";
 import os from "node:os";
 import { spawn } from "node:child_process";
 import { status } from "./status.mjs";
+import { withFileLock } from "./lock.mjs";
 
 const CLIENT_ID = "Iv1.b507a08c87ecfe98"; // Public GitHub Copilot client ID.
 const SCOPE = "read:user";
@@ -10,11 +11,17 @@ const GITHUB_API = "https://api.github.com";
 const COPILOT_TOKEN_URL = `${GITHUB_API}/copilot_internal/v2/token`;
 const DISABLE_TOKEN_DISCOVERY_VALUES = new Set(["1", "true", "yes"]);
 const MAX_AUTH_JSON_BYTES = 1024 * 1024;
+const DEFAULT_TOKEN_LOCK_TIMEOUT_MS = 10 * 60 * 1000;
+const DEFAULT_TOKEN_LOCK_STALE_MS = 15 * 60 * 1000;
 
 export function githubTokenPath(home = os.homedir()) {
   return path.join(home, ".local", "share", "copilot-api", "github_token");
 }
 
+export function githubTokenLockPath(home = os.homedir()) {
+  return `${githubTokenPath(home)}.lock`;
+}
+
 export function githubReauthMessage(reason, home = os.homedir()) {
   const tokenPath = githubTokenPath(home);
   return `${reason}
@@ -46,6 +53,18 @@ function isTokenDiscoveryDisabled(env = process.env) {
   return DISABLE_TOKEN_DISCOVERY_VALUES.has(String(env.CCDX_DISABLE_TOKEN_DISCOVERY || "").toLowerCase());
 }
 
+function positiveInt(value, fallback) {
+  const n = Number.parseInt(value, 10);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+
+function tokenLockOptions(env = process.env) {
+  return {
+    timeoutMs: positiveInt(env.CCDX_TOKEN_LOCK_TIMEOUT_MS, DEFAULT_TOKEN_LOCK_TIMEOUT_MS),
+    staleMs: positiveInt(env.CCDX_TOKEN_LOCK_STALE_MS, DEFAULT_TOKEN_LOCK_STALE_MS),
+  };
+}
+
 function splitPathList(value) {
   return String(value || "")
     .split(path.delimiter)
@@ -185,6 +204,12 @@ export function readGithubTokenSource(source) {
   return "";
 }
 
+function readSavedGithubToken(home = os.homedir()) {
+  const filePath = githubTokenPath(home);
+  if (!fs.existsSync(filePath)) return "";
+  return fs.readFileSync(filePath, "utf8").trim();
+}
+
 export async function validateGithubToken(token, {
   fetchImpl = fetch,
   signal,
@@ -283,13 +308,32 @@ export async function importDiscoveredGithubToken({
   signal,
   excludeTokens = [],
   log = console.log,
+  lock = true,
+  validateSavedToken = false,
 } = {}) {
-  const discovered = await discoverGithubToken({ home, env, fetchImpl, signal, excludeTokens });
-  if (!discovered.ok) return null;
-  writeToken(discovered.token, home);
-  const login = discovered.validation.login ? ` for ${discovered.validation.login}` : "";
-  log(status("ok", `Imported GitHub token from ${sourceDescription(discovered.source)}${login}`));
-  return discovered;
+  const run = async () => {
+    const excluded = new Set(excludeTokens);
+    const savedToken = readSavedGithubToken(home);
+    if (savedToken && !excluded.has(savedToken)) {
+      if (!validateSavedToken) {
+        return { ok: true, token: savedToken, source: { type: "saved-token" }, imported: false };
+      }
+      const validation = await validateGithubToken(savedToken, { fetchImpl, signal });
+      if (validation.ok) {
+        return { ok: true, token: savedToken, source: { type: "saved-token" }, validation, imported: false };
+      }
+    }
+
+    const discovered = await discoverGithubToken({ home, env, fetchImpl, signal, excludeTokens });
+    if (!discovered.ok) return null;
+    writeToken(discovered.token, home);
+    const login = discovered.validation.login ? ` for ${discovered.validation.login}` : "";
+    log(status("ok", `Imported GitHub token from ${sourceDescription(discovered.source)}${login}`));
+    return { ...discovered, imported: true };
+  };
+
+  if (!lock) return run();
+  return withFileLock(githubTokenLockPath(home), run, tokenLockOptions(env));
 }
 
 // On macOS, copy the user code and open the verification page. Fail quietly.
@@ -329,54 +373,63 @@ export async function ensureAuth({
     log(status("warn", "GitHub token file is empty"));
   }
 
-  const imported = await importDiscoveredGithubToken({ home, env, fetchImpl, signal, log });
-  if (imported) return;
-
-  log(status("wait", "No usable GitHub token found. Starting device login..."));
-
-  // Request a device code.
-  const codeResp = await fetchImpl("https://github.com/login/device/code", {
-    method: "POST",
-    headers: { "Content-Type": "application/json", Accept: "application/json" },
-    body: JSON.stringify({ client_id: CLIENT_ID, scope: SCOPE }),
-    signal,
-  });
-  if (!codeResp.ok) throw new Error(`device code request failed: ${codeResp.status}`);
-  const { device_code, user_code, verification_uri, interval } = await codeResp.json();
-
-  // Prompt the user.
-  log(`\n${status("info", `Open ${verification_uri}`)}\n${status("info", `Enter code: ${user_code}`)}\n`);
-  openAndCopyFn(user_code, verification_uri);
-
-  // Poll until GitHub completes the device flow.
-  let waitMs = (interval || 5) * 1000;
-  while (true) {
-    await sleep(waitMs);
-    const pollResp = await fetchImpl("https://github.com/login/oauth/access_token", {
+  await withFileLock(githubTokenLockPath(home), async () => {
+    const savedToken = readSavedGithubToken(home);
+    if (savedToken) {
+      log(status("ok", "GitHub token found"));
+      return;
+    }
+
+    const imported = await importDiscoveredGithubToken({ home, env, fetchImpl, signal, log, lock: false });
+    if (imported) return;
+
+    log(status("wait", "No usable GitHub token found. Starting device login..."));
+
+    // Request a device code while holding the auth lock so concurrent starts do not
+    // trigger multiple browser/device-flow sessions for the same local token.
+    const codeResp = await fetchImpl("https://github.com/login/device/code", {
       method: "POST",
       headers: { "Content-Type": "application/json", Accept: "application/json" },
-      body: JSON.stringify({
-        client_id: CLIENT_ID,
-        device_code,
-        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
-      }),
+      body: JSON.stringify({ client_id: CLIENT_ID, scope: SCOPE }),
       signal,
     });
-    if (!pollResp.ok) {
-      // Treat transient network/server errors as pending and retry.
-      continue;
-    }
-    const data = await pollResp.json();
-    const r = interpretPoll(data);
-    if (r.state === "done") {
-      writeToken(r.token, home);
-      log(status("ok", "Login successful"));
-      return;
+    if (!codeResp.ok) throw new Error(`device code request failed: ${codeResp.status}`);
+    const { device_code, user_code, verification_uri, interval } = await codeResp.json();
+
+    // Prompt the user.
+    log(`\n${status("info", `Open ${verification_uri}`)}\n${status("info", `Enter code: ${user_code}`)}\n`);
+    openAndCopyFn(user_code, verification_uri);
+
+    // Poll until GitHub completes the device flow.
+    let waitMs = (interval || 5) * 1000;
+    while (true) {
+      await sleep(waitMs);
+      const pollResp = await fetchImpl("https://github.com/login/oauth/access_token", {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Accept: "application/json" },
+        body: JSON.stringify({
+          client_id: CLIENT_ID,
+          device_code,
+          grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+        }),
+        signal,
+      });
+      if (!pollResp.ok) {
+        // Treat transient network/server errors as pending and retry.
+        continue;
+      }
+      const data = await pollResp.json();
+      const r = interpretPoll(data);
+      if (r.state === "done") {
+        writeToken(r.token, home);
+        log(status("ok", "Login successful"));
+        return;
+      }
+      if (r.state === "slow") { waitMs += 5000; continue; }
+      if (r.state === "fail") throw new Error(`Login failed: ${r.error}`);
+      // wait: continue polling.
     }
-    if (r.state === "slow") { waitMs += 5000; continue; }
-    if (r.state === "fail") throw new Error(`Login failed: ${r.error}`);
-    // wait: continue polling.
-  }
+  }, tokenLockOptions(env));
 }
 
 export function writeToken(token, home = os.homedir()) {

package/src/copilot.mjs

@@ -246,6 +246,7 @@ export async function refreshVSCodeVersion() {
 
 let copilotToken = null;
 let copilotTokenExpiry = 0;
+let copilotTokenRefresh = null;
 
 function getGithubToken({ home = os.homedir() } = {}) {
   const GITHUB_TOKEN_PATH = githubTokenPath(home);
@@ -275,13 +276,12 @@ function cacheCopilotTokenData(data) {
   return copilotToken;
 }
 
-export async function getCopilotToken({
+async function refreshCopilotToken({
   signal,
   home = os.homedir(),
   env = process.env,
   fetchImpl = fetch,
 } = {}) {
-  if (copilotToken && Date.now() < copilotTokenExpiry - 60000) return copilotToken;
   const ghToken = getGithubToken({ home });
   const resp = await requestCopilotToken(ghToken, { fetchImpl, signal });
   if (!resp.ok) {
@@ -292,6 +292,7 @@ export async function getCopilotToken({
         fetchImpl,
         signal,
         excludeTokens: [ghToken],
+        validateSavedToken: true,
       });
       if (imported?.validation?.copilotTokenData?.token) {
         return cacheCopilotTokenData(imported.validation.copilotTokenData);
@@ -304,6 +305,26 @@ export async function getCopilotToken({
   return cacheCopilotTokenData(data);
 }
 
+export async function getCopilotToken(options = {}) {
+  if (copilotToken && Date.now() < copilotTokenExpiry - 60000) return copilotToken;
+  const home = options.home || os.homedir();
+  const refreshKey = githubTokenPath(home);
+  if (copilotTokenRefresh?.key === refreshKey) return copilotTokenRefresh.promise;
+
+  const promise = refreshCopilotToken(options).finally(() => {
+    if (copilotTokenRefresh?.promise === promise) copilotTokenRefresh = null;
+  });
+  copilotTokenRefresh = { key: refreshKey, promise };
+  return promise;
+}
+
+export function resetCopilotTokenForTests() {
+  copilotToken = null;
+  copilotTokenExpiry = 0;
+  copilotTokenRefresh = null;
+  apiBase = DEFAULT_API_BASE;
+}
+
 // chatReq is already converted by the adapter. The caller parses the raw Response.
 export async function chatCompletions(chatReq, { signal } = {}) {
   const token = await getCopilotToken({ signal });

package/src/lock.mjs

@@ -0,0 +1,60 @@
+import fs from "node:fs";
+import path from "node:path";
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function maybeRemoveStaleLock(lockPath, staleMs, nowMs) {
+  if (!Number.isFinite(staleMs) || staleMs <= 0) return false;
+  try {
+    const stat = fs.statSync(lockPath);
+    if (nowMs - stat.mtimeMs <= staleMs) return false;
+    fs.unlinkSync(lockPath);
+    return true;
+  } catch (e) {
+    if (e?.code === "ENOENT") return true;
+    return false;
+  }
+}
+
+export async function withFileLock(lockPath, fn, {
+  timeoutMs = 5000,
+  staleMs = 15 * 60 * 1000,
+  pollMs = 50,
+  now = Date.now,
+} = {}) {
+  fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+  const started = now();
+  let fd = null;
+
+  while (fd === null) {
+    try {
+      fd = fs.openSync(lockPath, "wx", 0o600);
+      fs.writeFileSync(fd, JSON.stringify({ pid: process.pid, created_at: new Date().toISOString() }));
+      break;
+    } catch (e) {
+      if (e?.code !== "EEXIST") throw e;
+      const nowMs = now();
+      if (maybeRemoveStaleLock(lockPath, staleMs, nowMs)) continue;
+      if (nowMs - started >= timeoutMs) {
+        throw new Error(`Timed out waiting for lock: ${lockPath}`);
+      }
+      await sleep(Math.min(pollMs, Math.max(1, timeoutMs - (nowMs - started))));
+    }
+  }
+
+  try {
+    return await fn();
+  } finally {
+    try {
+      if (fd !== null) fs.closeSync(fd);
+    } finally {
+      try {
+        fs.unlinkSync(lockPath);
+      } catch (e) {
+        if (e?.code !== "ENOENT") throw e;
+      }
+    }
+  }
+}

package/src/running-adapter.mjs

@@ -0,0 +1,48 @@
+export const ADAPTER_HEALTH_PATH = "/_ccdx/health";
+
+export function adapterHealthPayload() {
+  return {
+    ok: true,
+    name: "codex-copilot-dx",
+    pid: process.pid,
+  };
+}
+
+export function adapterProbeHost(host = "127.0.0.1") {
+  const normalized = String(host || "127.0.0.1").toLowerCase();
+  if (normalized === "0.0.0.0" || normalized === "::" || normalized === "[::]") return "127.0.0.1";
+  return host || "127.0.0.1";
+}
+
+export function adapterBaseUrl(host = "127.0.0.1", port = 2026) {
+  const probeHost = String(adapterProbeHost(host));
+  const urlHost = probeHost.includes(":") && !probeHost.startsWith("[") ? `[${probeHost}]` : probeHost;
+  return `http://${urlHost}:${port}`;
+}
+
+export async function checkRunningAdapter({
+  host = "127.0.0.1",
+  port = 2026,
+  fetchImpl = fetch,
+  timeoutMs = 500,
+} = {}) {
+  const baseUrl = adapterBaseUrl(host, port);
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+  try {
+    const resp = await fetchImpl(`${baseUrl}${ADAPTER_HEALTH_PATH}`, {
+      headers: { Accept: "application/json" },
+      signal: ctrl.signal,
+    });
+    if (!resp.ok) return { ok: false, baseUrl, status: resp.status };
+    const data = await resp.json();
+    if (data?.name !== "codex-copilot-dx" || data?.ok !== true) {
+      return { ok: false, baseUrl, status: resp.status, data };
+    }
+    return { ok: true, baseUrl, data };
+  } catch (e) {
+    return { ok: false, baseUrl, error: e };
+  } finally {
+    clearTimeout(timer);
+  }
+}