codexgpt 1.0.0

package/scripts/repository-policy.mjs

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+import fsp from "node:fs/promises";
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const failures = [];
+
+async function read(relativePath) {
+  return await fsp.readFile(path.join(root, relativePath), "utf8");
+}
+
+function requireText(text, needle, label) {
+  if (!text.includes(needle)) failures.push(`${label} is missing required marker: ${needle}`);
+}
+
+function forbidText(text, needle, label) {
+  if (text.includes(needle)) failures.push(`${label} contains forbidden marker: ${needle}`);
+}
+
+async function requireFile(relativePath) {
+  try {
+    const stat = await fsp.stat(path.join(root, relativePath));
+    if (!stat.isFile()) failures.push(`${relativePath} must be a file.`);
+  } catch {
+    failures.push(`Missing required file: ${relativePath}`);
+  }
+}
+
+const requiredFiles = [
+  "scripts/ci-change-classifier.mjs",
+  "scripts/ci-failure-summary.mjs",
+  "scripts/exact-head-ci.mjs",
+  "scripts/long-task-runner.mjs",
+  "scripts/run-and-summarize.mjs",
+  "scripts/toolchain-manager.mjs",
+  "scripts/toolchains.json",
+  "scripts/test-domains.mjs",
+  "scripts/windows-process-host-manifest.json",
+  "scripts/windows-process-host-protocol-v1.json",
+  "scripts/windows-conpty-probe-child.mjs",
+  "scripts/windows-process-host.cs",
+  "scripts/windows-process-host.ps1",
+  "src/cliEnvironment.ts",
+  "test/fixtures/filesystem-identity.js",
+  "test/operational-reliability.test.mjs",
+  "test/test-domain-classification.test.mjs"
+];
+await Promise.all(requiredFiles.map(requireFile));
+
+const processHostManifest = JSON.parse(await read("scripts/windows-process-host-manifest.json"));
+const processHostSources = [
+  ["productionPowerShellSha256", "scripts/windows-process-host.ps1"],
+  ["productionCSharpSha256", "scripts/windows-process-host.cs"],
+  ["conPtyWorkerSha256", "scripts/windows-conpty-worker.ps1"],
+  ["conPtyProbeChildSha256", "scripts/windows-conpty-probe-child.mjs"],
+  ["protocolSha256", "scripts/windows-process-host-protocol-v1.json"]
+];
+if (
+  processHostManifest.schemaVersion !== 1 || processHostManifest.protocolName !== "CXP4" ||
+  processHostManifest.protocolVersion !== 1 || processHostManifest.headerLength !== 64
+) failures.push("Windows process-host manifest contract must remain exact CXP4 protocol V1 with a 64-byte header.");
+for (const [field, relativePath] of processHostSources) {
+  const digest = createHash("sha256").update(await fsp.readFile(path.join(root, relativePath))).digest("hex");
+  if (processHostManifest[field] !== digest) failures.push(`Windows process-host manifest digest drifted for ${relativePath}.`);
+}
+
+const [agents, packageText, workflow, config, fsOps, mutationTest, gitignore, toolchainText, cliEnvironment, configExample, toolchainManager, smokeCompat] = await Promise.all([
+  read("AGENTS.md"),
+  read("package.json"),
+  read(".github/workflows/ci.yml"),
+  read("src/config.ts"),
+  read("src/fsOps.ts"),
+  read("test/mutation-architecture.test.mjs"),
+  read(".gitignore"),
+  read("scripts/toolchains.json"),
+  read("src/cliEnvironment.ts"),
+  read("config.example.env"),
+  read("scripts/toolchain-manager.mjs"),
+  read("scripts/smoke-platform-compat.mjs")
+]);
+
+for (const marker of [
+  "### 5.8 Operational reliability gates",
+  "scripts/toolchain-manager.mjs",
+  "scripts/long-task-runner.mjs",
+  "scripts/exact-head-ci.mjs",
+  "scripts/ci-failure-summary.mjs",
+  "scripts/test-domains.mjs",
+  "never create a follow-up repository commit solely to record the run ID",
+  "Mutation review identity must use repository path, syscall type, and a normalized semantic AST/call digest",
+  "Large single files must be read through explicit line ranges",
+  "npm run policy:check"
+]) requireText(agents, marker, "AGENTS.md");
+
+const packageJson = JSON.parse(packageText);
+for (const script of [
+  "policy:check",
+  "ci:classify",
+  "ci:failure-summary",
+  "ci:exact-head",
+  "task:runner",
+  "toolchain:status",
+  "toolchain:ensure",
+  "toolchain:matrix",
+  "test:ordinary",
+  "test:control-domain"
+]) {
+  if (typeof packageJson.scripts?.[script] !== "string") failures.push(`package.json is missing script ${script}.`);
+}
+
+const toolchains = JSON.parse(toolchainText);
+if (toolchains.stableRoot !== "%LOCALAPPDATA%\\CodexGPT\\toolchains") failures.push("Toolchain stableRoot must stay outside Temp.");
+for (const [major, version] of [["20", "20.20.2"], ["24", "24.15.0"]]) {
+  const entry = toolchains.toolchains?.[major];
+  if (entry?.version !== version) failures.push(`Node ${major} must be pinned to ${version}.`);
+  if (entry?.shasums !== "SHASUMS256.txt") failures.push(`Node ${major} must use official SHASUMS256.txt.`);
+  if (entry?.archive !== `node-v${version}-win-x64.zip`) failures.push(`Node ${major} archive name is not exact.`);
+}
+
+requireText(config, "CODEXGPT_MAX_READ_BYTES, 250_000", "src/config.ts");
+requireText(configExample, "CODEXGPT_MAX_READ_BYTES=250000", "config.example.env");
+requireText(configExample, "Raising output limits to work around connector 502 responses is not recommended", "config.example.env");
+requireText(cliEnvironment, "delete env.GH_TOKEN", "src/cliEnvironment.ts");
+requireText(cliEnvironment, "delete env.GITHUB_TOKEN", "src/cliEnvironment.ts");
+requireText(cliEnvironment, "GH_CONFIG_DIR", "src/cliEnvironment.ts");
+requireText(toolchainManager, "npm_node_execpath: paths.node", "scripts/toolchain-manager.mjs");
+requireText(toolchainManager, "npm_execpath: paths.npmCli", "scripts/toolchain-manager.mjs");
+requireText(smokeCompat, "\"'x'.repeat(190000)\"", "scripts/smoke-platform-compat.mjs");
+requireText(smokeCompat, "\"'x'.repeat(260000)\"", "scripts/smoke-platform-compat.mjs");
+requireText(fsOps, "Math.max(config.maxReadBytes, 8 * 1024 * 1024)", "src/fsOps.ts");
+requireText(fsOps, "each returned range remains capped by maxReadBytes", "src/fsOps.ts");
+requireText(mutationTest, "key: `${primitive}:${callDigest(node, sourceFile)}`", "mutation architecture gate");
+requireText(mutationTest, "reviewedIdentity", "mutation architecture gate");
+forbidText(mutationTest, "Stale mutation allowlist entries (line/call drift)", "mutation architecture gate");
+requireText(gitignore, ".ai-bridge/", ".gitignore");
+
+for (const marker of [
+  "classify:",
+  "policy:",
+  "needs: classify",
+  "needs.classify.outputs.runtime == 'true'",
+  "npm run policy:check",
+  "scripts/run-and-summarize.mjs",
+  "test/test-domain-classification.test.mjs",
+  "actions/upload-artifact@v7.0.1"
+]) requireText(workflow, marker, "CI workflow");
+
+const activeDocs = [
+  "AGENTS.md",
+  "Memory.md",
+  "docs/CODEXGPT_MASTER_IMPLEMENTATION_PLAN_2026-07-13.md",
+  "docs/superpowers/plans/2026-07-15-phase-3d-move-paths-and-acceptance.md"
+];
+for (const relativePath of activeDocs) {
+  const text = await read(relativePath);
+  forbidText(text, "%LOCALAPPDATA%\\Temp\\codexgpt-node20-20.20.2", relativePath);
+}
+
+if (failures.length > 0) {
+  console.error("Repository policy violations:");
+  for (const failure of failures) console.error(`- ${failure}`);
+  process.exit(1);
+}
+console.log("Repository operational policy: PASS");

package/scripts/run-and-summarize.mjs

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import path from "node:path";
+
+const argv = process.argv.slice(2);
+const separator = argv.indexOf("--");
+if (separator === -1 || separator === argv.length - 1) {
+  console.error("Usage: node scripts/run-and-summarize.mjs --label <name> [--log-dir <dir>] -- <command> [args...]");
+  process.exit(2);
+}
+
+function option(name, fallback) {
+  const index = argv.indexOf(name);
+  return index === -1 ? fallback : argv[index + 1];
+}
+
+const label = option("--label", "command").replace(/[^a-zA-Z0-9._-]+/g, "-");
+const logDir = path.resolve(option("--log-dir", path.join(".ai-bridge", "ci-logs")));
+const command = argv[separator + 1];
+const args = argv.slice(separator + 2);
+const maxSummaryLines = 160;
+const contextRadius = 2;
+const failurePattern = /(?:\bnot ok\b|AssertionError|ERR_ASSERTION|\bactual\s*:|\bexpected\s*:|\boperator\s*:|\berror\s*:|npm ERR!|ELIFECYCLE|Process completed with exit code|Caused by:|UnhandledPromiseRejection|\bSIG(?:TERM|KILL|INT)\b)/i;
+
+function redact(text) {
+  return text
+    .replace(/\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9_]{20,}\b/g, "[REDACTED_GITHUB_TOKEN]")
+    .replace(/\bgithub_pat_[A-Za-z0-9_]{20,}\b/g, "[REDACTED_GITHUB_TOKEN]")
+    .replace(/(Authorization\s*:\s*Bearer\s+)[^\s]+/gi, "$1[REDACTED]")
+    .replace(/([?&](?:token|access_token|key)=)[^&\s]+/gi, "$1[REDACTED]");
+}
+
+await fsp.mkdir(logDir, { recursive: true });
+const logPath = path.join(logDir, `${label}.log`);
+const summaryPath = path.join(logDir, `${label}-summary.md`);
+const logStream = fs.createWriteStream(logPath, { flags: "w", encoding: "utf8" });
+const recent = [];
+const selected = [];
+const selectedSet = new Set();
+let lineBuffer = "";
+
+function rememberLine(line) {
+  recent.push(line);
+  if (recent.length > contextRadius) recent.shift();
+  if (!failurePattern.test(line)) return;
+  for (const context of recent) {
+    if (selectedSet.has(context)) continue;
+    selectedSet.add(context);
+    selected.push(context);
+  }
+  if (selected.length > maxSummaryLines) selected.splice(0, selected.length - maxSummaryLines);
+}
+
+function consume(chunk, destination) {
+  const redacted = redact(chunk.toString("utf8"));
+  destination.write(redacted);
+  logStream.write(redacted);
+  lineBuffer += redacted;
+  const lines = lineBuffer.split(/\r?\n/);
+  lineBuffer = lines.pop() ?? "";
+  for (const line of lines) rememberLine(line);
+}
+
+function resolveLaunch(program, programArgs) {
+  if (process.platform !== "win32" || (program !== "npm" && program !== "npx")) {
+    return { executable: program, args: programArgs };
+  }
+
+  const cliName = program === "npm" ? "npm-cli.js" : "npx-cli.js";
+  const configuredNpmCli = process.env.npm_execpath;
+  const configuredCandidate = configuredNpmCli
+    ? path.join(path.dirname(configuredNpmCli), cliName)
+    : undefined;
+  const bundledCandidate = path.join(path.dirname(process.execPath), "node_modules", "npm", "bin", cliName);
+  const cliPath = [configuredCandidate, bundledCandidate]
+    .find((candidate) => candidate && fs.existsSync(candidate));
+  if (!cliPath) {
+    throw new Error(`Unable to resolve ${cliName} for the active Node runtime ${process.execPath}.`);
+  }
+  return { executable: process.execPath, args: [cliPath, ...programArgs] };
+}
+
+let launch;
+try {
+  launch = resolveLaunch(command, args);
+} catch (error) {
+  console.error(redact(error.stack ?? error.message));
+  process.exit(127);
+}
+const child = spawn(launch.executable, launch.args, {
+  cwd: process.cwd(),
+  env: process.env,
+  shell: false,
+  windowsHide: true,
+  stdio: ["inherit", "pipe", "pipe"]
+});
+child.stdout.on("data", (chunk) => consume(chunk, process.stdout));
+child.stderr.on("data", (chunk) => consume(chunk, process.stderr));
+
+const result = await new Promise((resolve) => {
+  child.once("error", (error) => resolve({ code: 127, signal: null, error }));
+  child.once("close", (code, signal) => resolve({ code: code ?? 1, signal, error: null }));
+});
+if (lineBuffer) rememberLine(lineBuffer);
+await new Promise((resolve) => logStream.end(resolve));
+
+if (result.code !== 0) {
+  const lines = selected.length > 0 ? selected : ["No matching assertion/error lines were found; inspect the bounded log artifact."];
+  const summary = [
+    `# ${label} failure summary`,
+    "",
+    `- Command: \`${redact([command, ...args].join(" "))}\``,
+    `- Exit code: ${result.code}`,
+    `- Signal: ${result.signal ?? "none"}`,
+    `- Redacted log: \`${path.relative(process.cwd(), logPath).split(path.sep).join("/")}\``,
+    "",
+    "```text",
+    ...lines.slice(-maxSummaryLines),
+    "```",
+    ""
+  ].join("\n");
+  await fsp.writeFile(summaryPath, summary, "utf8");
+  console.error(`\n::group::${label} compact failure summary`);
+  console.error(summary);
+  console.error("::endgroup::");
+  if (process.env.GITHUB_STEP_SUMMARY) {
+    await fsp.appendFile(process.env.GITHUB_STEP_SUMMARY, summary, "utf8");
+  }
+}
+
+if (result.error) console.error(redact(result.error.stack ?? result.error.message));
+process.exitCode = result.code;

package/scripts/run-smoke.mjs

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createOwnedTempEnvironment } from "./owned-temp-root.mjs";
+
+const scriptDirectory = path.dirname(fileURLToPath(import.meta.url));
+const repositoryRoot = path.resolve(scriptDirectory, "..");
+const smokeScripts = Object.freeze([
+  "analysis-smoke.mjs",
+  "analysis-cli-smoke.mjs",
+  "smoke-platform-compat.mjs",
+  "http-smoke-compat.mjs",
+  "pro-smoke.mjs",
+  "doctor-smoke.mjs",
+  "settings-smoke-platform-compat.mjs",
+  "execute-handoff-smoke-platform-compat.mjs"
+]);
+
+function runScript(script, environment) {
+  return new Promise((resolve) => {
+    const child = spawn(process.execPath, [path.join(scriptDirectory, script)], {
+      cwd: repositoryRoot,
+      env: environment,
+      shell: false,
+      windowsHide: true,
+      stdio: "inherit"
+    });
+    child.once("error", (error) => {
+      console.error(error.stack ?? error.message);
+      resolve(127);
+    });
+    child.once("close", (code) => resolve(code ?? 1));
+  });
+}
+
+const suiteTemp = await createOwnedTempEnvironment("smoke-suite");
+let exitCode = 0;
+try {
+  for (const script of smokeScripts) {
+    exitCode = await runScript(script, suiteTemp.environment);
+    if (exitCode !== 0) break;
+  }
+} finally {
+  try {
+    await suiteTemp.cleanup();
+  } catch (error) {
+    console.error(`Owned smoke temporary state could not be removed: ${error?.code ?? error?.message ?? "unknown"}`);
+    if (exitCode === 0) exitCode = 1;
+  }
+}
+process.exitCode = exitCode;

package/scripts/run-with-cleanup.mjs

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { createOwnedTempEnvironment } from "./owned-temp-root.mjs";
+
+const argv = process.argv.slice(2);
+const separator = argv.indexOf("--");
+const wrapperArgv = separator === -1 ? argv : argv.slice(0, separator);
+
+function option(name, fallback) {
+  const index = wrapperArgv.indexOf(name);
+  return index === -1 ? fallback : wrapperArgv[index + 1];
+}
+
+function fail(message, code = 2) {
+  console.error(message);
+  process.exitCode = code;
+}
+
+if (separator === -1 || separator === argv.length - 1) {
+  fail("Usage: node scripts/run-with-cleanup.mjs [--purpose <name>] [--base-root <dir>] [--cwd <dir>] -- <command> [args...]");
+} else {
+  const command = argv.slice(separator + 1);
+  const purpose = option("--purpose", "task");
+  const baseRoot = option("--base-root");
+  const cwd = path.resolve(option("--cwd", process.cwd()));
+  const ownedTemp = await createOwnedTempEnvironment(purpose, {
+    ...(baseRoot ? { baseRoot } : {}),
+    hostEnvironment: process.env
+  });
+
+  let child;
+  let outcome;
+  const signalExitCodes = new Map([["SIGINT", 130], ["SIGTERM", 143]]);
+  let requestedSignal;
+  let forceTimer;
+  const forwardSignal = (signal) => {
+    requestedSignal ??= signal;
+    if (!child) return;
+    try {
+      child.kill(signal);
+      forceTimer ??= setTimeout(() => {
+        try {
+          child?.kill("SIGKILL");
+        } catch {
+          // Cleanup reports any remaining locked temporary state.
+        }
+      }, 5_000);
+      forceTimer.unref();
+    } catch {
+      // Cleanup still runs; child termination failure is reflected by its eventual outcome.
+    }
+  };
+  const onSigint = () => forwardSignal("SIGINT");
+  const onSigterm = () => forwardSignal("SIGTERM");
+  process.once("SIGINT", onSigint);
+  process.once("SIGTERM", onSigterm);
+
+  try {
+    try {
+      child = spawn(command[0], command.slice(1), {
+        cwd,
+        env: ownedTemp.environment,
+        shell: false,
+        windowsHide: true,
+        stdio: "inherit"
+      });
+      if (requestedSignal) forwardSignal(requestedSignal);
+      outcome = await new Promise((resolve) => {
+        let settled = false;
+        const finish = (value) => {
+          if (settled) return;
+          settled = true;
+          resolve(value);
+        };
+        child.once("error", (error) => finish({ code: 127, signal: null, error }));
+        child.once("close", (code, signal) => finish({ code: code ?? 1, signal, error: null }));
+      });
+    } catch (error) {
+      outcome = { code: 127, signal: null, error };
+    }
+  } finally {
+    process.removeListener("SIGINT", onSigint);
+    process.removeListener("SIGTERM", onSigterm);
+    if (forceTimer) clearTimeout(forceTimer);
+    try {
+      await ownedTemp.cleanup();
+    } catch (error) {
+      console.error(`Owned task temporary state could not be removed: ${error?.code ?? error?.message ?? "unknown"}`);
+      if (!outcome || outcome.code === 0) outcome = { code: 1, signal: null, error };
+    }
+  }
+
+  if (outcome?.error) console.error(outcome.error.stack ?? outcome.error.message ?? String(outcome.error));
+  process.exitCode = requestedSignal
+    ? signalExitCodes.get(requestedSignal) ?? 1
+    : outcome?.code ?? 1;
+}

package/scripts/settings-smoke-platform-compat.mjs

@@ -0,0 +1,85 @@
+import childProcess from 'node:child_process';
+import fs from 'node:fs';
+import { syncBuiltinESMExports } from 'node:module';
+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;
+const originalSpawn = childProcess.spawn;
+
+function removeRuntimeStatusForPid(home, pid) {
+  if (!home || !pid) return;
+  const runtimeDir = path.join(home, 'runtime');
+  if (!fs.existsSync(runtimeDir)) return;
+  for (const name of fs.readdirSync(runtimeDir)) {
+    if (!name.endsWith('.json')) continue;
+    const filePath = path.join(runtimeDir, name);
+    try {
+      const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+      if (data?.pid === pid) fs.rmSync(filePath, { force: true });
+    } catch {
+      // Ignore unrelated or partially written test status files.
+    }
+  }
+}
+
+function removeQuickTunnelCredentials(argsLogPath) {
+  if (!argsLogPath || !fs.existsSync(argsLogPath)) return;
+  try {
+    const args = JSON.parse(fs.readFileSync(argsLogPath, 'utf8'));
+    const index = Array.isArray(args) ? args.indexOf('--credentials-file') : -1;
+    const credentialsPath = index >= 0 ? args[index + 1] : undefined;
+    if (credentialsPath) fs.rmSync(path.dirname(credentialsPath), { recursive: true, force: true });
+  } catch {
+    // Ignore test-only cleanup when the fake tunnel did not record arguments.
+  }
+}
+
+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(' ');
+    childProcess.spawn = (...args) => {
+      const options = args[2] ?? {};
+      const child = originalSpawn(...args);
+      const home = options.env?.CODEXGPT_HOME;
+      const originalKill = child.kill.bind(child);
+      child.kill = (signal) => {
+        if (signal === 'SIGTERM') {
+          removeRuntimeStatusForPid(home, child.pid);
+          removeQuickTunnelCredentials(options.env?.CODEXGPT_FAKE_CLOUDFLARED_ARGS);
+        }
+        return originalKill(signal);
+      };
+      return child;
+    };
+    syncBuiltinESMExports();
+  }
+
+  await import('./settings-smoke.mjs');
+} finally {
+  childProcess.spawn = originalSpawn;
+  syncBuiltinESMExports();
+  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;
+}