codexgpt 1.0.0

package/scripts/connector-auth-output-shim.cjs

@@ -0,0 +1,66 @@
+const active = process.env.CODEXGPT_CONNECTOR_AUTH_OUTPUT_SHIM === '1';
+const previousNodeOptions = process.env.CODEXGPT_CONNECTOR_AUTH_PREVIOUS_NODE_OPTIONS;
+
+if (previousNodeOptions) process.env.NODE_OPTIONS = previousNodeOptions;
+else delete process.env.NODE_OPTIONS;
+delete process.env.CODEXGPT_CONNECTOR_AUTH_OUTPUT_SHIM;
+delete process.env.CODEXGPT_CONNECTOR_AUTH_PREVIOUS_NODE_OPTIONS;
+
+if (active) {
+  const originalSet = URLSearchParams.prototype.set;
+  let connectorToken = '';
+
+  URLSearchParams.prototype.set = function set(name, value) {
+    if (String(name) === 'codexgpt_token') {
+      connectorToken = String(value);
+      return undefined;
+    }
+    return originalSet.call(this, name, value);
+  };
+
+  const originalLog = console.log.bind(console);
+  console.log = (...args) => {
+    const rewritten = args.map((arg) => {
+      if (typeof arg !== 'string') return arg;
+      return arg
+        .replace('  Authentication: No Authentication / None', '  Authentication: Bearer header (compatible MCP clients only; not ChatGPT Web)')
+        .replace('If your ChatGPT UI supports custom headers instead, you can use:', 'For a compatible MCP client (not ChatGPT Web), use this authorization header:')
+        .replace(
+          '  2. Paste the Server URL above and choose Authentication: No Authentication.',
+          '  2. Use the token-free Server URL above in a compatible MCP client and configure Authorization: Bearer with the token shown below.'
+        )
+        .replace(
+          '  2. Paste the copied Server URL and choose Authentication: No Authentication.',
+          '  2. Use the copied token-free Server URL in a compatible MCP client and configure Authorization: Bearer with the token shown below.'
+        )
+        .replace(
+          '  2. Press u to show the secret Server URL, then paste it and choose Authentication: No Authentication.',
+          '  2. Press u to show the token-free Server URL, then use it in a compatible MCP client with Authorization: Bearer.'
+        )
+        .replace(
+          '  POST /mcp -> 401 The full Server URL, including codexgpt_token, was not used.',
+          '  POST /mcp -> 401 The Authorization: Bearer header was missing or invalid.'
+        )
+        .replace(
+          'Next: press Enter to open ChatGPT, paste the copied Server URL, choose Authentication: None.',
+          'Next: use the token-free Server URL only with a compatible MCP client that can send Authorization: Bearer; not ChatGPT Web.'
+        )
+        .replace(
+          'Next: press u to show the secret Server URL, then open ChatGPT and choose Authentication: None.',
+          'Next: press u to show the token-free Server URL, then use it only with a compatible MCP client that can send Authorization: Bearer; not ChatGPT Web.'
+        )
+        .replace(
+          'Keys: Enter open | c copy | u show URL | o status | h help | q quit',
+          'Keys: c copy | u show URL | h help | q quit'
+        );
+    });
+
+    if (
+      connectorToken &&
+      rewritten.some((arg) => typeof arg === 'string' && arg.startsWith('Next: use the token-free Server URL'))
+    ) {
+      originalLog(`  Authorization: Bearer ${connectorToken}`);
+    }
+    originalLog(...rewritten);
+  };
+}

package/scripts/doctor-smoke.mjs

@@ -0,0 +1,90 @@
+import { spawnSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import fs from 'node:fs/promises';
+import net from 'node:net';
+import os from 'node:os';
+import path from 'node:path';
+
+async function getFreePort() {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.listen(0, '127.0.0.1', () => {
+      const address = server.address();
+      const port = typeof address === 'object' && address ? address.port : undefined;
+      server.close(() => (port ? resolve(port) : reject(new Error('no free port'))));
+    });
+    server.on('error', reject);
+  });
+}
+
+const root = await fs.mkdtemp(path.join(os.tmpdir(), 'codexgpt-doctor-smoke-'));
+const home = await fs.mkdtemp(path.join(os.tmpdir(), 'codexgpt-doctor-home-'));
+const port = await getFreePort();
+const packageJson = JSON.parse(await fs.readFile(path.resolve('package.json'), 'utf8'));
+for (const args of [['--version'], ['-v'], ['version'], ['start', '--version']]) {
+  const version = spawnSync(process.execPath, ['scripts/codexgpt-entry.mjs', ...args], {
+    cwd: path.resolve('.'),
+    env: { ...process.env, CODEXGPT_HOME: home },
+    encoding: 'utf8'
+  });
+  if (version.status !== 0 || version.stdout.trim() !== packageJson.version) {
+    throw new Error(`codexgpt ${args.join(' ')} did not print version ${packageJson.version}\nstdout:\n${version.stdout}\nstderr:\n${version.stderr}`);
+  }
+}
+const result = spawnSync(process.execPath, [
+  'scripts/codexgpt-entry.mjs',
+  'doctor',
+  '--root',
+  root,
+  '--port',
+  String(port),
+  '--tunnel',
+  'none'
+], {
+  cwd: path.resolve('.'),
+  env: { ...process.env, CODEXGPT_HOME: home },
+  encoding: 'utf8'
+});
+
+if (result.status !== 0) {
+  throw new Error(`doctor failed\nstdout:\n${result.stdout}\nstderr:\n${result.stderr}`);
+}
+
+const output = `${result.stdout}\n${result.stderr}`;
+for (const expected of ['CodexGPT doctor', 'Node', 'Build artifacts', 'Local port', 'Ready']) {
+  if (!output.includes(expected)) {
+    throw new Error(`doctor output missing ${expected}\n${output}`);
+  }
+}
+
+const invalidRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'codexgpt-doctor-invalid-'));
+const invalidRealRoot = await fs.realpath(invalidRoot);
+const invalidId = createHash('sha256').update(invalidRealRoot).digest('hex').slice(0, 24);
+await fs.mkdir(path.join(home, 'profiles'), { recursive: true });
+await fs.writeFile(path.join(home, 'profiles', `${invalidId}.json`), JSON.stringify({
+  version: 1,
+  root: invalidRealRoot,
+  updatedAt: new Date().toISOString(),
+  tunnel: 'none',
+  bash: 'banana',
+  write: 'banana',
+  toolMode: 'banana'
+}, null, 2), 'utf8');
+const invalidDoctor = spawnSync(process.execPath, [
+  'scripts/codexgpt-entry.mjs',
+  'doctor',
+  '--root',
+  invalidRoot,
+  '--port',
+  String(await getFreePort())
+], {
+  cwd: path.resolve('.'),
+  env: { ...process.env, CODEXGPT_HOME: home },
+  encoding: 'utf8'
+});
+const invalidOutput = `${invalidDoctor.stdout}\n${invalidDoctor.stderr}`;
+if (invalidDoctor.status === 0 || !invalidOutput.includes('Bash mode') || !invalidOutput.includes('Write mode') || !invalidOutput.includes('Tool mode')) {
+  throw new Error(`doctor did not reject invalid saved profile\nstdout:\n${invalidDoctor.stdout}\nstderr:\n${invalidDoctor.stderr}`);
+}
+
+console.log('✓ doctor smoke test passed');

package/scripts/doctor.mjs

@@ -0,0 +1,165 @@
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const projectRoot = path.resolve(scriptDir, "..");
+const args = process.argv.slice(2);
+
+function argumentValue(name) {
+  const inline = args.find((value) => value.startsWith(`--${name}=`));
+  if (inline) return inline.slice(name.length + 3);
+  const index = args.indexOf(`--${name}`);
+  if (index >= 0 && args[index + 1] && !args[index + 1].startsWith("--")) return args[index + 1];
+  return "";
+}
+
+function canonicalRoot() {
+  const input = argumentValue("root") || process.env.CODEXGPT_ROOT || process.cwd();
+  const resolved = path.resolve(input);
+  try {
+    return fs.realpathSync.native(resolved);
+  } catch {
+    return resolved;
+  }
+}
+
+function savedProfileCheck() {
+  if (args.includes("--no-profile")) return true;
+
+  const root = canonicalRoot();
+  const home = process.env.CODEXGPT_HOME
+    ? path.resolve(process.env.CODEXGPT_HOME)
+    : path.join(os.homedir(), ".codexgpt");
+  const profileId = createHash("sha256").update(root).digest("hex").slice(0, 24);
+  const profilePath = path.join(home, "profiles", `${profileId}.json`);
+  if (!fs.existsSync(profilePath)) return true;
+
+  let profile;
+  try {
+    profile = JSON.parse(fs.readFileSync(profilePath, "utf8"));
+  } catch (error) {
+    console.error(`FAIL Saved profile      ${error instanceof Error ? error.message : String(error)}`);
+    return false;
+  }
+
+  const checks = [
+    ["Bash mode", profile?.bash, ["off", "safe", "full"]],
+    ["Write mode", profile?.write, ["off", "handoff", "workspace"]],
+    ["Tool mode", profile?.toolMode, ["minimal", "standard", "full"]],
+    ["Semantic Provider", profile?.semanticProvider, ["builtin", "none"]]
+  ];
+  let valid = true;
+  for (const [label, value, allowed] of checks) {
+    if (value === undefined || allowed.includes(value)) continue;
+    console.error(`FAIL ${String(label).padEnd(18)} invalid saved value: ${value}`);
+    valid = false;
+  }
+  return valid;
+}
+
+function savedProfileUsesOAuth() {
+  if (args.includes("--no-profile")) return false;
+  const root = canonicalRoot();
+  const home = process.env.CODEXGPT_HOME
+    ? path.resolve(process.env.CODEXGPT_HOME)
+    : path.join(os.homedir(), ".codexgpt");
+  const profileId = createHash("sha256").update(root).digest("hex").slice(0, 24);
+  const profilePath = path.join(home, "profiles", `${profileId}.json`);
+  try {
+    const profile = JSON.parse(fs.readFileSync(profilePath, "utf8"));
+    return profile?.authMode === "oauth" || Boolean(profile?.oauthStateRef || profile?.oauthIssuer || profile?.oauthResource);
+  } catch {
+    return false;
+  }
+}
+
+function savedProfileBashMode() {
+  if (args.includes("--no-profile")) return "";
+
+  const root = canonicalRoot();
+  const home = process.env.CODEXGPT_HOME
+    ? path.resolve(process.env.CODEXGPT_HOME)
+    : path.join(os.homedir(), ".codexgpt");
+  const profileId = createHash("sha256").update(root).digest("hex").slice(0, 24);
+  const profilePath = path.join(home, "profiles", `${profileId}.json`);
+  try {
+    const profile = JSON.parse(fs.readFileSync(profilePath, "utf8"));
+    if (!profile || typeof profile !== "object" || Array.isArray(profile)) return "";
+    if (profile.root && profile.root !== root) return "";
+    return ["off", "safe", "full"].includes(profile.bash) ? profile.bash : "";
+  } catch {
+    return "";
+  }
+}
+
+function requestedBashMode() {
+  if (args.includes("--no-bash")) return "off";
+  return argumentValue("bash") || process.env.CODEXGPT_BASH_MODE || savedProfileBashMode() || "safe";
+}
+
+function commandPath(command) {
+  if (path.isAbsolute(command) && fs.existsSync(command)) return command;
+  if (process.platform === "win32") {
+    const located = spawnSync("where", [command], { encoding: "utf8", windowsHide: true });
+    if (located.status === 0) {
+      return String(located.stdout ?? "").split(/\r?\n/).map((line) => line.trim()).find(Boolean) ?? command;
+    }
+    const direct = spawnSync(command, ["--version"], { encoding: "utf8", windowsHide: true });
+    return direct.status === 0 ? command : "";
+  }
+  const result = spawnSync("/bin/sh", ["-c", "command -v \"$1\"", "codexgpt-doctor", command], { encoding: "utf8" });
+  if (result.status !== 0) return "";
+  return String(result.stdout ?? "").split(/\r?\n/).map((line) => line.trim()).find(Boolean) ?? "";
+}
+
+function shellCheck() {
+  const mode = requestedBashMode();
+  if (mode === "off") {
+    console.log("OK   Bash executable    not required because Bash mode is off");
+    return true;
+  }
+
+  const command = process.env.CODEXGPT_DOCTOR_BASH_COMMAND || "bash";
+  const executable = commandPath(command);
+  if (executable) {
+    console.log(`OK   Bash executable    ${executable}`);
+    return true;
+  }
+
+  const detail = process.platform === "win32"
+    ? "Bash was not found. Install Git Bash, or run with --no-bash until the native PowerShell backend is available."
+    : "Bash was not found. Install Bash, or run with --no-bash.";
+  console.error(`FAIL Bash executable    ${detail}`);
+  return false;
+}
+
+const shellAvailable = shellCheck();
+if (args.includes("--shell-check-only")) {
+  process.exitCode = shellAvailable ? 0 : 1;
+} else {
+  const profileValid = savedProfileCheck();
+  const forwarded = args.filter((value) => value !== "--shell-check-only");
+  const result = spawnSync(process.execPath, [path.join(scriptDir, "codexgpt.mjs"), "doctor", ...forwarded], {
+    cwd: projectRoot,
+    env: { ...process.env, CODEXGPT_ROOT: canonicalRoot() },
+    stdio: "inherit",
+    windowsHide: true
+  });
+  if (result.error) throw result.error;
+  let oauthStatus = 0;
+  if (savedProfileUsesOAuth()) {
+    const oauth = spawnSync(process.execPath, [path.join(scriptDir, "oauth-admin.mjs"), "doctor", "--root", canonicalRoot()], {
+      cwd: projectRoot,
+      env: { ...process.env, CODEXGPT_ROOT: canonicalRoot() },
+      stdio: "inherit",
+      windowsHide: true
+    });
+    if (oauth.error) throw oauth.error;
+    oauthStatus = oauth.status ?? 1;
+  }
+  process.exitCode = result.status === 0 && oauthStatus === 0 && shellAvailable && profileValid ? 0 : result.status || oauthStatus || 1;
+}

package/scripts/exact-head-ci.mjs

@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import fsp from "node:fs/promises";
+import path from "node:path";
+import { createBoundedCliEnvironment } from "../dist/cliEnvironment.js";
+
+const args = process.argv.slice(2);
+const command = args[0] ?? "verify";
+
+function option(name) {
+  const index = args.indexOf(name);
+  return index === -1 ? undefined : args[index + 1];
+}
+
+function fail(message, detail) {
+  console.error(message);
+  if (detail) console.error(detail);
+  process.exit(1);
+}
+
+function ghJson(ghArgs) {
+  const result = spawnSync("gh", ghArgs, {
+    cwd: process.cwd(),
+    env: createBoundedCliEnvironment({ includeCi: false }),
+    encoding: "utf8",
+    windowsHide: true,
+    maxBuffer: 4 * 1024 * 1024
+  });
+  if (result.error) fail(`Unable to run GitHub CLI: ${result.error.message}`);
+  if (result.status !== 0) fail(`GitHub CLI failed: gh ${ghArgs.join(" ")}`, result.stderr.trim());
+  try {
+    return JSON.parse(result.stdout);
+  } catch (error) {
+    fail(`GitHub CLI returned invalid JSON: ${error.message}`, result.stdout.slice(0, 2000));
+  }
+}
+
+function assertFullSha(value) {
+  if (!/^[0-9a-f]{40}$/i.test(value ?? "")) fail("--head must be an exact 40-character commit SHA.");
+  return value.toLowerCase();
+}
+
+function findRun(head, workflow) {
+  const runs = ghJson([
+    "run", "list",
+    "--commit", head,
+    "--workflow", workflow,
+    "--limit", "20",
+    "--json", "databaseId,status,conclusion,headSha,url,createdAt,workflowName"
+  ]);
+  const exact = runs.filter((run) => String(run.headSha).toLowerCase() === head);
+  if (exact.length === 0) fail(`No ${workflow} run exists for exact head ${head}.`);
+  exact.sort((left, right) => String(right.createdAt).localeCompare(String(left.createdAt)));
+  return exact[0];
+}
+
+if (command === "auth") {
+  const result = spawnSync("gh", ["auth", "status"], {
+    env: createBoundedCliEnvironment({ includeCi: false }),
+    encoding: "utf8",
+    windowsHide: true
+  });
+  process.stdout.write(result.stdout);
+  process.stderr.write(result.stderr);
+  process.exit(result.status ?? 1);
+}
+
+if (command !== "find" && command !== "verify") {
+  fail("Usage: node scripts/exact-head-ci.mjs <find|verify|auth> --head <full-sha> [--run <id>] [--workflow CI] [--output <ignored-json-path>]");
+}
+
+const head = assertFullSha(option("--head"));
+const workflow = option("--workflow") ?? "CI";
+const requestedRun = option("--run");
+const selected = requestedRun
+  ? ghJson(["run", "view", requestedRun, "--json", "databaseId,status,conclusion,headSha,url,createdAt,workflowName"])
+  : findRun(head, workflow);
+
+if (String(selected.headSha).toLowerCase() !== head) {
+  fail(`Run ${selected.databaseId} belongs to ${selected.headSha}, not exact head ${head}.`);
+}
+
+let evidence = {
+  schemaVersion: 1,
+  headSha: head,
+  runId: Number(selected.databaseId),
+  workflow: selected.workflowName ?? workflow,
+  status: selected.status,
+  conclusion: selected.conclusion ?? null,
+  url: selected.url,
+  verifiedAt: new Date().toISOString(),
+  repositoryWriteRequired: false
+};
+
+if (command === "verify") {
+  const detail = ghJson([
+    "run", "view", String(selected.databaseId),
+    "--json", "databaseId,status,conclusion,headSha,url,workflowName,jobs"
+  ]);
+  if (detail.status !== "completed" || detail.conclusion !== "success") {
+    fail(`Exact-head run ${detail.databaseId} is not successful: status=${detail.status}, conclusion=${detail.conclusion ?? "none"}.`);
+  }
+  const failedJobs = (detail.jobs ?? []).filter((job) => job.conclusion !== "success" && job.conclusion !== "skipped");
+  if (failedJobs.length > 0) {
+    fail(`Exact-head run ${detail.databaseId} contains non-success jobs: ${failedJobs.map((job) => `${job.name}=${job.conclusion}`).join(", ")}.`);
+  }
+  evidence = {
+    ...evidence,
+    status: detail.status,
+    conclusion: detail.conclusion,
+    jobs: (detail.jobs ?? []).map((job) => ({ name: job.name, status: job.status, conclusion: job.conclusion }))
+  };
+}
+
+const output = `${JSON.stringify(evidence, null, 2)}\n`;
+const outputPath = option("--output");
+if (outputPath) {
+  const resolved = path.resolve(outputPath);
+  const allowedRoot = path.resolve(".ai-bridge");
+  if (resolved !== allowedRoot && !resolved.startsWith(`${allowedRoot}${path.sep}`)) {
+    fail("--output must stay under .ai-bridge so CI evidence never creates a tracked closure commit.");
+  }
+  await fsp.mkdir(path.dirname(resolved), { recursive: true });
+  await fsp.writeFile(resolved, output, "utf8");
+}
+process.stdout.write(output);

package/scripts/execute-handoff-smoke-platform-compat.mjs

@@ -0,0 +1,38 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const previousNodeOptions = process.env.NODE_OPTIONS;
+const previousShimNodeOptions = process.env.CODEXGPT_REALPATH_PREVIOUS_NODE_OPTIONS;
+const previousTemp = process.env.TEMP;
+const previousTmp = process.env.TMP;
+const previousGuidanceMode = process.env.CODEXGPT_GUIDANCE_MODE;
+
+try {
+  process.env.CODEXGPT_GUIDANCE_MODE = 'legacy';
+  if (process.platform === 'win32') {
+    const canonicalTemp = fs.realpathSync.native(os.tmpdir());
+    process.env.TEMP = canonicalTemp;
+    process.env.TMP = canonicalTemp;
+
+    const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+    const shimPath = path.join(scriptDir, 'windows-realpath-shim.cjs').replaceAll('\\', '/');
+    const requireOption = `--require "${shimPath.replaceAll('"', '\\"')}"`;
+    process.env.CODEXGPT_REALPATH_PREVIOUS_NODE_OPTIONS = previousNodeOptions ?? '';
+    process.env.NODE_OPTIONS = [previousNodeOptions, requireOption].filter(Boolean).join(' ');
+  }
+
+  await import('./execute-handoff-smoke.mjs');
+} finally {
+  if (previousNodeOptions === undefined) delete process.env.NODE_OPTIONS;
+  else process.env.NODE_OPTIONS = previousNodeOptions;
+  if (previousShimNodeOptions === undefined) delete process.env.CODEXGPT_REALPATH_PREVIOUS_NODE_OPTIONS;
+  else process.env.CODEXGPT_REALPATH_PREVIOUS_NODE_OPTIONS = previousShimNodeOptions;
+  if (previousTemp === undefined) delete process.env.TEMP;
+  else process.env.TEMP = previousTemp;
+  if (previousTmp === undefined) delete process.env.TMP;
+  else process.env.TMP = previousTmp;
+  if (previousGuidanceMode === undefined) delete process.env.CODEXGPT_GUIDANCE_MODE;
+  else process.env.CODEXGPT_GUIDANCE_MODE = previousGuidanceMode;
+}