Skip to content

OpenAI's Codex Security CLI and TypeScript SDK for finding, validating, and fixing security vulnerabilities. npm: https://www.npmjs.com/package/@openai/codex-security

fix: preserve trusted Git selection in workbench helpers (#140)

Gautam Sharma50b0e186d8fd
diff --git a/plugins/codex-security/.mcp.json b/plugins/codex-security/.mcp.json
index 16617b081..d7c52e082 100644
--- a/plugins/codex-security/.mcp.json
+++ b/plugins/codex-security/.mcp.json
@@ -35,6 +35,7 @@
"AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE",
"PYTHON",
"PYTHONUTF8",
+ "CODEX_SECURITY_GIT",
"CODEX_SECURITY_KNOWLEDGE_BASE",
"CODEX_SECURITY_CONFIG_PATH",
"CODEX_SECURITY_DEEP_SCAN_CONFIG_PATH",
diff --git a/plugins/codex-security/mcp-app/tests/test_deep_scan_executor.mjs b/plugins/codex-security/mcp-app/tests/test_deep_scan_executor.mjs
index bdd14b1f0..88bbf989b 100644
--- a/plugins/codex-security/mcp-app/tests/test_deep_scan_executor.mjs
+++ b/plugins/codex-security/mcp-app/tests/test_deep_scan_executor.mjs
@@ -1119,6 +1119,10 @@ async function testWorkerRuntimeSettings() {
const saved = Object.fromEntries(
[
"PYTHON",
+ "PATH",
+ "CODEX_SECURITY_GIT",
+ "GIT_SSH_COMMAND",
+ "GIT_CONFIG_GLOBAL",
"CODEX_CLI_PATH",
"CODEX_SECURITY_CONFIG_PATH",
"CODEX_SECURITY_DEEP_SCAN_CONFIG_PATH",
@@ -1140,6 +1144,13 @@ async function testWorkerRuntimeSettings() {
"python",
);
process.env.PYTHON = python;
+ const gitEnvironment = {
+ PATH: path.join(fixture.root, "selected tools"),
+ CODEX_SECURITY_GIT: path.join(fixture.root, "selected tools", "git"),
+ GIT_SSH_COMMAND: "synthetic-ssh --fixture",
+ GIT_CONFIG_GLOBAL: path.join(fixture.root, "operator.gitconfig"),
+ };
+ Object.assign(process.env, gitEnvironment);
const configPath = path.join(fixture.root, "active scan config.toml");
const promptPath = path.join(fixture.root, "prompt.md");
await writeFile(configPath, configuration);
@@ -1215,6 +1226,14 @@ async function testWorkerRuntimeSettings() {
true,
);
assert.equal(invocation.configPath, configPath);
+ const preflight = JSON.parse(
+ await readFile(fixture.preflightMarkerPath, "utf8"),
+ );
+ assert.deepEqual(invocation.gitEnvironment, gitEnvironment);
+ assert.deepEqual(preflight.gitEnvironment, gitEnvironment);
+ for (const [name, value] of Object.entries(gitEnvironment)) {
+ assert.equal(process.env[name], value);
+ }
assert.equal(invocation.python, python);
assert.equal(
invocation.argv.includes(
@@ -2138,7 +2157,7 @@ async function fakeCodexFixture(
`const accountResult = ${JSON.stringify(accountResult)};`,
`const preflightMarkerPath = ${JSON.stringify(preflightMarkerPath)};`,
"if (process.argv.includes('app-server')) {",
- " const preflight = { cwd: process.cwd(), codexHome: process.env.CODEX_HOME, requests: [] };",
+ " const preflight = { cwd: process.cwd(), codexHome: process.env.CODEX_HOME, gitEnvironment: Object.fromEntries(['PATH', 'CODEX_SECURITY_GIT', 'GIT_SSH_COMMAND', 'GIT_CONFIG_GLOBAL'].map(name => [name, process.env[name]])), requests: [] };",
" writeFileSync(preflightMarkerPath, JSON.stringify(preflight));",
" let buffer = '';",
" process.stdin.setEncoding('utf8');",
@@ -2180,7 +2199,7 @@ async function fakeCodexFixture(
"for await (const chunk of process.stdin) stdin += chunk;",
"const openaiAuthentication = stdin.includes('CAPTURE_SYNTHETIC_OPENAI_AUTH') ? { OPENAI_API_KEY: process.env.OPENAI_API_KEY, CODEX_API_KEY: process.env.CODEX_API_KEY } : undefined;",
"const bedrockAuthentication = stdin.includes('CAPTURE_SYNTHETIC_BEDROCK_AUTH') ? Object.fromEntries(JSON.parse(process.env.FAKE_CODEX_BEDROCK_ENV_KEYS).map((name) => [name, process.env[name]])) : undefined;",
- "writeFileSync(process.env.FAKE_CODEX_MARKER, JSON.stringify({ argv: process.argv.slice(2), stdin, cwd: process.cwd(), codexHome: process.env.CODEX_HOME, configPath: process.env.CODEX_SECURITY_CONFIG_PATH, deepConfigPath: process.env.CODEX_SECURITY_DEEP_SCAN_CONFIG_PATH, python: process.env.PYTHON, originator: process.env.CODEX_INTERNAL_ORIGINATOR_OVERRIDE, ...(stdin.includes('COMPLETE_THEN_HANG') ? { pid: process.pid } : {}), ...(openaiAuthentication ? { openaiAuthentication } : {}), ...(bedrockAuthentication ? { bedrockAuthentication } : {}) }));",
+ "writeFileSync(process.env.FAKE_CODEX_MARKER, JSON.stringify({ argv: process.argv.slice(2), stdin, cwd: process.cwd(), codexHome: process.env.CODEX_HOME, gitEnvironment: Object.fromEntries(['PATH', 'CODEX_SECURITY_GIT', 'GIT_SSH_COMMAND', 'GIT_CONFIG_GLOBAL'].map(name => [name, process.env[name]])), configPath: process.env.CODEX_SECURITY_CONFIG_PATH, deepConfigPath: process.env.CODEX_SECURITY_DEEP_SCAN_CONFIG_PATH, python: process.env.PYTHON, originator: process.env.CODEX_INTERNAL_ORIGINATOR_OVERRIDE, ...(stdin.includes('COMPLETE_THEN_HANG') ? { pid: process.pid } : {}), ...(openaiAuthentication ? { openaiAuthentication } : {}), ...(bedrockAuthentication ? { bedrockAuthentication } : {}) }));",
"if (stdin.includes('COMPLETE_THEN_HANG')) process.on('SIGTERM', () => setTimeout(() => process.exit(0), 100));",
"if (stdin.includes('THREAD_START_CONFIG_ERROR')) { console.error('Error: thread/start: thread/start failed: agents.max_threads cannot be set when features.multi_agent_v2 is enabled (code -32600)'); process.exit(1); }",
"if (stdin.includes('CONFIG_ERROR')) { console.error('failed to load configuration: invalid value'); process.exit(2); }",
diff --git a/plugins/codex-security/mcp-app/tests/test_mcp_app_smoke.mjs b/plugins/codex-security/mcp-app/tests/test_mcp_app_smoke.mjs
index 9bd763c2b..32ea0041b 100644
--- a/plugins/codex-security/mcp-app/tests/test_mcp_app_smoke.mjs
+++ b/plugins/codex-security/mcp-app/tests/test_mcp_app_smoke.mjs
@@ -87,6 +87,7 @@ assert.deepEqual(
"AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE",
"PYTHON",
"PYTHONUTF8",
+ "CODEX_SECURITY_GIT",
"CODEX_SECURITY_KNOWLEDGE_BASE",
"CODEX_SECURITY_CONFIG_PATH",
"CODEX_SECURITY_DEEP_SCAN_CONFIG_PATH",
diff --git a/plugins/codex-security/scripts/generate_in_scope_files.py b/plugins/codex-security/scripts/generate_in_scope_files.py
index c2cd77208..6b5807933 100644
--- a/plugins/codex-security/scripts/generate_in_scope_files.py
+++ b/plugins/codex-security/scripts/generate_in_scope_files.py
@@ -10,6 +10,10 @@ import sys
import tempfile
from pathlib import Path
+# Some plugin hosts launch Python with safe-path isolation enabled.
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from workbench_target import git_blob_bytes, git_command
+
class InventoryError(ValueError):
"""Raised when the repository, scope, or inventory cannot be used safely."""
@@ -116,21 +120,16 @@ def generate_in_scope_files(repository: Path, scope: str, output: Path) -> int:
if (repository / ".git").exists():
try:
- tracked = subprocess.run(
- [
- "git",
- "ls-files",
- "--cached",
- "--ignored",
- "--exclude-standard",
- "-z",
- "--",
- scope,
- ],
- cwd=repository,
- stdout=subprocess.PIPE,
- stderr=subprocess.DEVNULL,
- check=False,
+ tracked = git_command(
+ repository,
+ "ls-files",
+ "--cached",
+ "--ignored",
+ "--exclude-standard",
+ "-z",
+ "--",
+ scope,
+ text=False,
)
except OSError:
tracked = None
@@ -157,20 +156,16 @@ def generate_in_scope_files(repository: Path, scope: str, output: Path) -> int:
def committed_changed_paths(repository: Path, base: str, head: str) -> list[tuple[Path, str]]:
- result = subprocess.run(
- [
- "git",
- "-C",
- str(repository),
- "diff",
- "--raw",
- "-z",
- "--diff-filter=ACMRD",
- f"{base}..{head}",
- ],
- capture_output=True,
- check=True,
+ result = git_command(
+ repository,
+ "diff",
+ "--raw",
+ "-z",
+ "--diff-filter=ACMRD",
+ f"{base}..{head}",
+ text=False,
)
+ result.check_returncode()
fields = result.stdout.split(b"\0")
changed: list[tuple[Path, str]] = []
index = 0
@@ -196,7 +191,6 @@ def generate_diff_in_scope_files(
output: Path,
) -> int:
"""Reuse the existing diff selection without generating previews or duplicate worklists."""
- sys.path.insert(0, str(Path(__file__).resolve().parent))
from generate_rank_input import git_changed_paths, path_is_diff_excluded
from rank_preview import (
DEFAULT_PREVIEW_BYTES,
@@ -204,7 +198,6 @@ def generate_diff_in_scope_files(
is_binary_sample,
preview_for,
)
- from workbench_target import git_blob_bytes
rows: list[bytes] = []
try:
diff --git a/plugins/codex-security/scripts/generate_rank_input.py b/plugins/codex-security/scripts/generate_rank_input.py
index e38af2c1b..0d35f3d62 100644
--- a/plugins/codex-security/scripts/generate_rank_input.py
+++ b/plugins/codex-security/scripts/generate_rank_input.py
@@ -43,7 +43,7 @@ from rank_preview import (
preview_for,
preview_for_bytes,
)
-from workbench_target import git_blob_bytes, git_directory_snapshot_paths
+from workbench_target import git_blob_bytes, git_command, git_directory_snapshot_paths
EXCLUDED_DIRS = {
".cache",
@@ -624,20 +624,16 @@ def bind_repo_scopes(args: argparse.Namespace) -> None:
def run_git_changed_paths(repo: Path, diff_args: list[str]) -> list[tuple[Path, str]]:
- result = subprocess.run(
- [
- "git",
- "-C",
- str(repo),
- "diff",
- "--name-status",
- "-z",
- "--diff-filter=ACMRD",
- *diff_args,
- ],
- check=True,
- capture_output=True,
+ result = git_command(
+ repo,
+ "diff",
+ "--name-status",
+ "-z",
+ "--diff-filter=ACMRD",
+ *diff_args,
+ text=False,
)
+ result.check_returncode()
fields = result.stdout.split(b"\0")
if fields and not fields[-1]:
fields.pop()
@@ -661,11 +657,15 @@ def git_changed_paths(repo: Path, base: str, head: str, mode: str) -> list[tuple
if mode == "local-patch":
unstaged = run_git_changed_paths(repo, [base])
staged = run_git_changed_paths(repo, ["--cached", base])
- untracked = subprocess.run(
- ["git", "-C", str(repo), "ls-files", "--others", "--exclude-standard", "-z"],
- capture_output=True,
- check=True,
+ untracked = git_command(
+ repo,
+ "ls-files",
+ "--others",
+ "--exclude-standard",
+ "-z",
+ text=False,
)
+ untracked.check_returncode()
combined = dict(staged)
combined.update(unstaged)
combined.update(
diff --git a/plugins/codex-security/scripts/workbench_target.py b/plugins/codex-security/scripts/workbench_target.py
index 824c2a058..25f8d8d30 100644
--- a/plugins/codex-security/scripts/workbench_target.py
+++ b/plugins/codex-security/scripts/workbench_target.py
@@ -145,6 +145,74 @@ def _read_sized_nul_field(
return output[offset:end], end + 1
+def _protected_repository_root(target: Path) -> Path:
+ root = target.resolve()
+ if root.is_file():
+ root = root.parent
+ protected = root
+ for ancestor in (root, *root.parents):
+ try:
+ (ancestor / ".git").lstat()
+ except FileNotFoundError:
+ continue
+ protected = ancestor
+ return protected
+
+
+def trusted_git_executable(protected_root: Path) -> str | None:
+ """Validate host-selected Git, or discover Git for a direct plugin invocation."""
+ configured = os.environ.get("CODEX_SECURITY_GIT")
+ windows = sys.platform == "win32"
+ if configured is None:
+ names = ("git.exe", "git.com") if windows else ("git",)
+ candidates = (
+ Path(entry.strip('"') if windows else entry) / name
+ for entry in os.get_exec_path()
+ for name in names
+ )
+ elif not configured:
+ return None
+ else:
+ candidate = Path(configured)
+ if not candidate.is_absolute():
+ raise SystemExit("CODEX_SECURITY_GIT must name an absolute trusted executable.")
+ candidates = iter((candidate,))
+
+ try:
+ repository = _protected_repository_root(protected_root)
+ except (OSError, RuntimeError):
+ return None
+
+ for candidate in candidates:
+ try:
+ lexical = Path(os.path.abspath(candidate))
+ invocation = candidate.parent.resolve(strict=True) / candidate.name
+ canonical = candidate.resolve(strict=True)
+ except (OSError, RuntimeError):
+ continue
+ if (
+ not canonical.is_file()
+ or not os.access(canonical, os.F_OK if windows else os.X_OK)
+ or (
+ windows
+ and (
+ candidate.suffix.lower() not in {".exe", ".com"}
+ or canonical.suffix.lower() in {".bat", ".cmd"}
+ )
+ )
+ ):
+ continue
+ if any(
+ path == repository or repository in path.parents
+ for path in (lexical, invocation, canonical)
+ ):
+ if configured is not None:
+ raise SystemExit("CODEX_SECURITY_GIT must stay outside the protected repository.")
+ continue
+ return str(invocation)
+ return None
+
+
def git_command(
target: Path,
*args: str,
@@ -160,9 +228,10 @@ def git_command(
for name in GIT_REPOSITORY_ENVIRONMENT:
environment.pop(name, None)
environment["GIT_LITERAL_PATHSPECS"] = "1"
+ executable = trusted_git_executable(target)
# Repository-local config is untrusted; fsmonitor may name an executable hook.
command = [
- "git",
+ executable or "git",
"-c",
"core.fsmonitor=false",
"-c",
@@ -173,6 +242,9 @@ def git_command(
if git_dir is not None and work_tree is not None:
command.extend(["--git-dir", str(git_dir), "--work-tree", str(work_tree)])
full_command = [*command, *args]
+ if executable is None:
+ empty_output = "" if text else b""
+ return subprocess.CompletedProcess(full_command, 127, empty_output, empty_output)
try:
output_options = (
{"capture_output": True}
diff --git a/plugins/codex-security/tests/test_generate_in_scope_files.py b/plugins/codex-security/tests/test_generate_in_scope_files.py
index 6edab5549..4dbf9d8de 100644
--- a/plugins/codex-security/tests/test_generate_in_scope_files.py
+++ b/plugins/codex-security/tests/test_generate_in_scope_files.py
@@ -175,7 +175,10 @@ def test_inventory_rejects_line_breaks_before_serializing_paths(
assert list(output.parent.glob(f".{output.name}.*.tmp")) == []
-def test_diff_inventory_includes_power_shell_files(tmp_path: Path) -> None:
+def test_diff_inventory_includes_power_shell_files(
+ tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+ monkeypatch.delenv("CODEX_SECURITY_GIT", raising=False)
repository = tmp_path / "repository"
repository.mkdir()
subprocess.run(
diff --git a/plugins/codex-security/tests/test_workbench_target.py b/plugins/codex-security/tests/test_workbench_target.py
index 2bed7880e..94d6871e3 100644
--- a/plugins/codex-security/tests/test_workbench_target.py
+++ b/plugins/codex-security/tests/test_workbench_target.py
@@ -1,9 +1,11 @@
from __future__ import annotations
import hashlib
+import os
import runpy
import subprocess
from pathlib import Path
+from types import SimpleNamespace
from typing import Any, Callable, cast
import pytest
@@ -12,6 +14,7 @@ from workbench_test_support import initialize_git_repository
WORKBENCH_TARGET = runpy.run_path(
str(Path(__file__).resolve().parents[1] / "scripts" / "workbench_target.py")
)
+trusted_git_executable = WORKBENCH_TARGET["trusted_git_executable"]
directory_content_digest = cast(Callable[[Path], str], WORKBENCH_TARGET["directory_content_digest"])
worktree_content_digest = cast(Callable[[Path], str], WORKBENCH_TARGET["worktree_content_digest"])
update_digest_field = cast(
@@ -24,6 +27,19 @@ def initialize_unborn_git_repository(target: Path) -> None:
subprocess.run(["git", "init", "-q"], cwd=target, check=True)
+def test_stale_git_binding_does_not_spawn(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+ monkeypatch.setenv("CODEX_SECURITY_GIT", str(tmp_path / "missing-git"))
+
+ def unexpected_spawn(*args: Any, **kwargs: Any) -> None:
+ raise AssertionError("stale Git binding reached subprocess.run")
+
+ monkeypatch.setattr(subprocess, "run", unexpected_spawn)
+ result = WORKBENCH_TARGET["git_command"](tmp_path, "status", text=True)
+ assert result.returncode == 127
+ assert result.stdout == ""
+ assert result.args[0] == "git"
+
+
@pytest.mark.parametrize(
("log_encoding", "subject"),
[
@@ -180,3 +196,124 @@ def test_worktree_content_digest_streams_tracked_binary_patch(
assert worktree_content_digest(target) == (
f"codex-security-snapshot/v1:sha256:{expected.hexdigest()}"
)
+
+
+def test_windows_git_candidates_reject_batch_targets(
+ tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+ repository = tmp_path / "repository"
+ (repository / ".git").mkdir(parents=True)
+ native = tmp_path / "git.com"
+ batch = tmp_path / "git.cmd"
+ extensionless = tmp_path / "git-native"
+ for candidate in (native, batch, extensionless):
+ candidate.write_text("synthetic executable fixture\n")
+ native_alias = tmp_path / "trusted.exe"
+ batch_alias = tmp_path / "untrusted.exe"
+ extensionless_alias = tmp_path / "native-alias.exe"
+ native_alias.symlink_to(native)
+ batch_alias.symlink_to(batch)
+ extensionless_alias.symlink_to(extensionless)
+ monkeypatch.setitem(
+ trusted_git_executable.__globals__, "sys", SimpleNamespace(platform="win32")
+ )
+ for candidate, expected in (
+ (native, native),
+ (native_alias, native_alias),
+ (batch, None),
+ (batch_alias, None),
+ (extensionless, None),
+ (extensionless_alias, extensionless_alias),
+ ):
+ monkeypatch.setenv("CODEX_SECURITY_GIT", str(candidate))
+ assert trusted_git_executable(repository) == (str(expected) if expected else None)
+
+
[email protected]("windows", [False, True])
+def test_git_discovery_continues_past_repository_tools_and_batch_shims(
+ tmp_path: Path, monkeypatch: pytest.MonkeyPatch, windows: bool
+) -> None:
+ repository = tmp_path / "repository"
+ repository_bin = repository / "bin"
+ repository_bin.mkdir(parents=True)
+ (repository / ".git").mkdir()
+ batch_bin = tmp_path / "batch-bin"
+ host_bin = tmp_path / "host-bin"
+ batch_bin.mkdir()
+ host_bin.mkdir()
+ name = "git.exe" if windows else "git"
+ host_git = host_bin / name
+ for executable in (repository_bin / name, batch_bin / "git.cmd", host_git):
+ executable.write_text("synthetic executable fixture\n")
+ executable.chmod(0o700)
+ monkeypatch.setitem(
+ trusted_git_executable.__globals__,
+ "sys",
+ SimpleNamespace(platform="win32" if windows else "linux"),
+ )
+ monkeypatch.delenv("CODEX_SECURITY_GIT", raising=False)
+ monkeypatch.setenv("PATH", os.pathsep.join(map(str, (repository_bin, batch_bin, host_bin))))
+ assert trusted_git_executable(repository) == str(host_git)
+
+ # An explicit unavailable binding must not fall back to a different Git.
+ for binding in ("", str(tmp_path / "missing-git")):
+ monkeypatch.setenv("CODEX_SECURITY_GIT", binding)
+ assert trusted_git_executable(repository) is None
+ monkeypatch.setenv("CODEX_SECURITY_GIT", str(repository_bin / name))
+ with pytest.raises(SystemExit, match="outside the protected repository"):
+ trusted_git_executable(repository)
+
+
+def test_git_discovery_does_not_invoke_through_repository_directory_alias(
+ tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+ repository = tmp_path / "repository"
+ repository_bin = repository / "bin"
+ repository_bin.mkdir(parents=True)
+ (repository / ".git").mkdir()
+ host_bin = tmp_path / "host-bin"
+ host_bin.mkdir()
+ name = "git.exe" if os.name == "nt" else "git"
+ host_git = host_bin / name
+ host_git.write_text("synthetic host executable\n")
+ host_git.chmod(0o700)
+ (repository_bin / name).symlink_to(host_git)
+ alias = tmp_path / "directory-alias"
+ alias.symlink_to(repository_bin, target_is_directory=True)
+ monkeypatch.delenv("CODEX_SECURITY_GIT", raising=False)
+ monkeypatch.setenv("PATH", os.pathsep.join(map(str, (alias, host_bin))))
+ assert trusted_git_executable(repository) == str(host_git)
+ monkeypatch.setenv("CODEX_SECURITY_GIT", str(alias / name))
+ with pytest.raises(SystemExit, match="outside the protected repository"):
+ trusted_git_executable(repository)
+
+ host_alias = repository / "host-alias"
+ host_alias.symlink_to(host_bin, target_is_directory=True)
+ monkeypatch.setenv("CODEX_SECURITY_GIT", str(host_alias / name))
+ with pytest.raises(SystemExit, match="outside the protected repository"):
+ trusted_git_executable(repository)
+
+
+def test_git_discovery_preserves_symlink_parent_traversal(
+ tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+ repository = tmp_path / "repository"
+ (repository / ".git").mkdir(parents=True)
+ tools = tmp_path / "tools"
+ version = tmp_path / "versions" / "v1"
+ (tools / "bin").mkdir(parents=True)
+ (version / "lib").mkdir(parents=True)
+ (version / "bin").mkdir()
+ (tools / "current").symlink_to(version / "lib", target_is_directory=True)
+ name = "git.exe" if os.name == "nt" else "git"
+ host_git = version / "bin" / name
+ for executable in (tools / "bin" / name, host_git):
+ executable.write_text("synthetic executable fixture\n")
+ executable.chmod(0o700)
+ path_entry = tools / "current" / ".." / "bin"
+ monkeypatch.delenv("CODEX_SECURITY_GIT", raising=False)
+ monkeypatch.setenv("PATH", str(path_entry))
+ expected = (path_entry / name).resolve(strict=True)
+ if os.name != "nt":
+ assert expected == host_git
+ assert trusted_git_executable(repository) == str(expected)
diff --git a/sdk/typescript/src/api.ts b/sdk/typescript/src/api.ts
index f9d7b4033..e6177f78b 100644
--- a/sdk/typescript/src/api.ts
+++ b/sdk/typescript/src/api.ts
@@ -181,6 +181,7 @@ import {
prepareCodexSecurityCredentialHome,
preserveCodexSecurityPluginRegistration,
pluginExecutionEnvironment,
+ environmentWithGit,
pluginMetadata,
planOutputArchive,
prepareScanArtifactRestorer,
@@ -207,6 +208,7 @@ import {
enclosingGitWorktreeRoots,
normalizeRepository,
normalizeTarget,
+ gitMarkerRoot,
repositoryRevision,
resolveRepositoryPath,
type NormalizedTarget,
@@ -215,6 +217,10 @@ import {
validateCommittedDiffCheckout,
validateMode,
} from "./targets.js";
+import {
+ inspectTrustedExecutable,
+ type InspectedExecutable,
+} from "./trusted-executable.js";
interface CodexThreadLike {
readonly id: string | null;
@@ -1002,6 +1008,7 @@ export class CodexSecurity {
: { CODEX_SECURITY_KNOWLEDGE_BASE: knowledgeBase.path }),
},
options.auth,
+ undefined,
policyCodexConfig(session.sessionConfig),
inputs.gitMetadataPaths.length === 0
? []
@@ -1290,6 +1297,22 @@ export class CodexSecurity {
python,
} = session;
releaseCredentialHome = session.releaseCredentialHome;
+ let git: InspectedExecutable = {
+ executable: null,
+ environment: selectedScanEnvironment(
+ runtime.environment,
+ options.auth,
+ modelProvider,
+ ),
+ };
+ for (const source of [repo, ...(knowledgeBase?.sources ?? [])]) {
+ git = await inspectTrustedExecutable(
+ "git",
+ git.environment,
+ (await gitMarkerRoot(source, signal, "outermost")) ?? source,
+ );
+ }
+ checkOpen();
const deepScanConfigPath =
mode === "deep"
? (runtime.deepScanConfigPath ??
@@ -1577,11 +1600,7 @@ export class CodexSecurity {
python,
pluginRoot: runtime.plugin.pluginRoot,
environment: {
- ...selectedScanEnvironment(
- runtime.environment,
- options.auth,
- modelProvider,
- ),
+ ...environmentWithGit(git.environment, git),
CODEX_SECURITY_STATE_DIR: stateDirectory,
},
signal,
@@ -1882,6 +1901,7 @@ export class CodexSecurity {
session,
runtimePaths,
options.auth,
+ git,
);
const threadOptions: ThreadOptions = {
threadSource: CODEX_SECURITY_THREAD_SOURCES.scan,
@@ -2623,6 +2643,7 @@ export class CodexSecurity {
session: PreparedSession,
runtimePaths: Record<string, string>,
auth: ScanAuthMode = "auto",
+ git?: InspectedExecutable,
config?: JsonObject,
configOverrides: string[] = [],
): { codex: CodexClientLike; environment: ProcessEnvironment } {
@@ -2636,17 +2657,20 @@ export class CodexSecurity {
} = session;
const commandAuth = hasCommandAuth(sessionConfig);
const environment: ProcessEnvironment = {
- ...pluginExecutionEnvironment(
- python,
- withoutCodexHome(
- selectedScanEnvironment(
- commandAuth
- ? withoutOpenAiApiKeys(runtime.environment)
- : runtime.environment,
- auth,
- modelProvider,
+ ...environmentWithGit(
+ pluginExecutionEnvironment(
+ python,
+ withoutCodexHome(
+ selectedScanEnvironment(
+ commandAuth
+ ? withoutOpenAiApiKeys(runtime.environment)
+ : runtime.environment,
+ auth,
+ modelProvider,
+ ),
),
),
+ git,
),
...(externalProvider === null
? {}
diff --git a/sdk/typescript/src/runtime.ts b/sdk/typescript/src/runtime.ts
index 90dbefbfd..1400f5396 100644
--- a/sdk/typescript/src/runtime.ts
+++ b/sdk/typescript/src/runtime.ts
@@ -60,7 +60,10 @@ import {
errorMessage,
} from "./errors.js";
import type { JsonObject } from "./config.js";
-import { resolveTrustedExecutable } from "./trusted-executable.js";
+import {
+ resolveTrustedExecutable,
+ type InspectedExecutable,
+} from "./trusted-executable.js";
import {
isWindowsUnsafePathComponent,
windowsUnsafePathComponent,
@@ -2683,6 +2686,23 @@ export function pluginExecutionEnvironment(
};
}
+export function environmentWithGit(
+ environment: ProcessEnvironment,
+ git?: InspectedExecutable,
+): ProcessEnvironment {
+ if (git === undefined) return environment;
+ const result = { ...environment };
+ for (const name of Object.keys(result)) {
+ const normalized = name.toUpperCase();
+ if (normalized === "CODEX_SECURITY_GIT" || normalized === "PATH") {
+ delete result[name];
+ }
+ }
+ result["CODEX_SECURITY_GIT"] = git.executable ?? "";
+ result["PATH"] = git.environment["PATH"] ?? "";
+ return result;
+}
+
export function pythonUtf8Environment(
environment: ProcessEnvironment,
): ProcessEnvironment {
diff --git a/sdk/typescript/src/targets.ts b/sdk/typescript/src/targets.ts
index d82d3b95c..bace30339 100644
--- a/sdk/typescript/src/targets.ts
+++ b/sdk/typescript/src/targets.ts
@@ -753,12 +753,15 @@ async function gitOutput(
return stdout.replace(process.platform === "win32" ? /\r?\n$/u : /\n$/u, "");
}
-async function gitMarkerRoot(
+export async function gitMarkerRoot(
repository: string,
signal: AbortSignal | undefined,
search: "nearest" | "outermost",
): Promise<string | null> {
- let current = repository;
+ const canonical = await abortable(() => realpath(repository), signal);
+ let current = (await lstat(canonical)).isDirectory()
+ ? canonical
+ : dirname(canonical);
let root: string | null = null;
while (true) {
throwIfAborted(signal);
diff --git a/sdk/typescript/src/trusted-executable.ts b/sdk/typescript/src/trusted-executable.ts
index e13034b0c..abb5e4525 100644
--- a/sdk/typescript/src/trusted-executable.ts
+++ b/sdk/typescript/src/trusted-executable.ts
@@ -17,11 +17,31 @@ export interface TrustedExecutable {
environment: Record<string, string | undefined>;
}
+export interface InspectedExecutable {
+ executable: string | null;
+ environment: Record<string, string | undefined>;
+}
+
export async function resolveTrustedExecutable(
candidate: string,
environment: Readonly<Record<string, string | undefined>>,
protectedRoot: string,
): Promise<TrustedExecutable | null> {
+ const inspected = await inspectTrustedExecutable(
+ candidate,
+ environment,
+ protectedRoot,
+ );
+ return inspected.executable === null
+ ? null
+ : { executable: inspected.executable, environment: inspected.environment };
+}
+
+export async function inspectTrustedExecutable(
+ candidate: string,
+ environment: Readonly<Record<string, string | undefined>>,
+ protectedRoot: string,
+): Promise<InspectedExecutable> {
const root = await realpath(protectedRoot).catch(() =>
resolve(protectedRoot),
);
@@ -87,6 +107,9 @@ export async function resolveTrustedExecutable(
if (current.entry !== null) unsafeEntries.add(current.entry);
continue;
}
+ if (process.platform === "win32" && /\.(?:bat|cmd)$/iu.test(canonical)) {
+ continue;
+ }
if (!current.runnable) continue;
try {
await access(
@@ -108,7 +131,6 @@ export async function resolveTrustedExecutable(
continue;
}
}
- if (executable === null) return null;
const sanitizedEnvironment = { ...environment };
for (const name of Object.keys(sanitizedEnvironment)) {
diff --git a/sdk/typescript/tests-ts/api-attribution-concurrency.test.ts b/sdk/typescript/tests-ts/api-attribution-concurrency.test.ts
index 457f04286..d523e4a36 100644
--- a/sdk/typescript/tests-ts/api-attribution-concurrency.test.ts
+++ b/sdk/typescript/tests-ts/api-attribution-concurrency.test.ts
@@ -1,5 +1,5 @@
-import { mkdir, readFile } from "node:fs/promises";
-import { join } from "node:path";
+import { mkdir, readFile, realpath, symlink } from "node:fs/promises";
+import { delimiter, join } from "node:path";
import type { CodexOptions, ThreadOptions } from "@openai/codex-sdk";
import { afterEach, describe, expect, test } from "bun:test";
import { parse as parseToml } from "smol-toml";
@@ -39,11 +39,23 @@ describe("delegated scan attribution", () => {
const clients = await Promise.all(
(["cli", "sdk"] as const).map(async (surface) => {
const scanDirectory = join(root, `${surface}-scan`);
+ const gitDirectory = join(root, `${surface}-tools`);
+ await mkdir(gitDirectory);
+ const hostGit = Bun.which("git");
+ expect(hostGit).not.toBeNull();
+ const git = join(
+ gitDirectory,
+ process.platform === "win32" ? "git.exe" : "git",
+ );
+ await symlink(await realpath(hostGit!), git);
+ const expectedGitDirectory = await realpath(gitDirectory);
await mkdir(scanDirectory, { mode: 0o700 });
return new InternalCodexSecurity(
{ pluginPath: PLUGIN_ROOT },
{
environment: {
+ PATH: gitDirectory,
+ GIT_SSH_COMMAND: `synthetic-${surface}-ssh`,
CODEX_HOME: ambientHome,
CODEX_SECURITY_STATE_DIR: stateDirectory,
CODEX_SECURITY_SURFACE: "spoofed",
@@ -82,10 +94,27 @@ describe("delegated scan attribution", () => {
maximumActive = Math.max(maximumActive, active);
if (active === 2) releaseConcurrentScans();
try {
+ const initialEnvironment = { ...options.env };
expect(options.env?.["CODEX_HOME"]).toBe(credentialHome);
expect(options.env?.["CODEX_SECURITY_SURFACE"]).toBe(
surface,
);
+ expect(options.env?.["CODEX_SECURITY_GIT"]).toBe(git);
+ expect(options.env?.["PATH"]?.split(delimiter)).toContain(
+ expectedGitDirectory,
+ );
+ expect(
+ options.env?.["PATH"]?.split(delimiter),
+ ).not.toContain(
+ join(
+ root,
+ `${surface === "cli" ? "sdk" : "cli"}-tools`,
+ ),
+ );
+ expect(options.env?.["GIT_SSH_COMMAND"]).toBe(
+ `synthetic-${surface}-ssh`,
+ );
+ expect(options.env).not.toHaveProperty("OPENAI_API_KEY");
expect(options.config).toMatchObject({
responses_api_metadata: {
codex_security_surface: surface,
@@ -102,9 +131,7 @@ describe("delegated scan attribution", () => {
expect(sharedConfig).not.toHaveProperty(
"responses_api_metadata",
);
- expect(options.env?.["CODEX_SECURITY_SURFACE"]).toBe(
- surface,
- );
+ expect(options.env).toEqual(initialEnvironment);
throw new Error("delegated attribution observed");
} finally {
active -= 1;
diff --git a/sdk/typescript/tests-ts/api.test.ts b/sdk/typescript/tests-ts/api.test.ts
index f69ba7977..03ae0aad5 100644
--- a/sdk/typescript/tests-ts/api.test.ts
+++ b/sdk/typescript/tests-ts/api.test.ts
@@ -1,5 +1,6 @@
import {
appendFile,
+ chmod,
copyFile,
cp,
mkdir,
@@ -51,7 +52,11 @@ import {
type JsonObject,
} from "../src/config.js";
import { estimateScanCost, type ScanCost } from "../src/cost.js";
-import { resolveCodexCommand, runWorkbench } from "../src/runtime.js";
+import {
+ resolveCodexCommand,
+ runWorkbench,
+ type WorkbenchCommandOptions,
+} from "../src/runtime.js";
import { matchScanFindingsInternal } from "../src/scan-comparison.js";
import { normalizeTarget } from "../src/targets.js";
import { SYNTHETIC_CREDENTIALS } from "./cli-fixtures.js";
@@ -2517,16 +2522,19 @@ describe("CodexSecurity orchestration", () => {
const warningDetails: Array<{ kind: "target_changed" } | undefined> = [];
const reconnects: Array<[number, number]> = [];
const commands: Array<readonly string[]> = [];
+ const workbenchGitExecutables: Array<string | null> = [];
let registrationInput: string | undefined;
const completionWarning =
"Repository HEAD changed while the scan was running; results were saved for the original revision.";
const recoveryWarning =
"Recovered finding: normalized its semantic anchor.";
+ const git = Bun.which("git");
+ expect(git).not.toBeNull();
const client = new TestClient(
{ codexOverrides: { model: "replay-model" } },
{
- environment: { PATH: "/usr/bin", OPENAI_API_KEY: "" },
+ environment: { PATH: dirname(git!), OPENAI_API_KEY: "" },
prepareRuntime: async () => ({
codexHome,
plugin: {
@@ -2540,7 +2548,7 @@ describe("CodexSecurity orchestration", () => {
environment: {
CODEX_HOME: codexHome,
Codex_Home: "/credentials/case-variant-must-not-reach-shell",
- PATH: "/usr/bin",
+ PATH: dirname(git!),
GITHUB_TOKEN: "must-not-reach-shell",
AWS_SECRET_ACCESS_KEY: "must-not-reach-shell",
},
@@ -2550,10 +2558,13 @@ describe("CodexSecurity orchestration", () => {
prepareOutputDir: async () => scanDir,
repositoryRevision: async () => "deadbeef",
runWorkbench: async (
- _options: unknown,
+ workbenchOptions: WorkbenchCommandOptions,
args: readonly string[],
input?: string,
): Promise<JsonObject> => {
+ workbenchGitExecutables.push(
+ workbenchOptions.environment["CODEX_SECURITY_GIT"] ?? null,
+ );
commands.push(args);
if (args[0] === "register-cli-scan") {
registrationInput = input;
@@ -2641,7 +2652,11 @@ describe("CodexSecurity orchestration", () => {
expect(startedAt.endsWith("Z")).toBe(true);
expect(Date.parse(startedAt)).toBeGreaterThanOrEqual(scanStartedAt);
expect(Date.parse(startedAt)).toBeLessThanOrEqual(Date.now());
- expect((codexOptions as CodexOptions | null)?.env).toMatchObject({
+ const codexEnvironment = (codexOptions as CodexOptions | null)?.env;
+ const codexGit = codexEnvironment?.["CODEX_SECURITY_GIT"];
+ if (typeof codexGit !== "string")
+ throw new Error("missing trusted Git binding");
+ expect(codexEnvironment).toMatchObject({
CODEX_HOME: codexHome,
PYTHON: "/managed/python",
CODEX_SECURITY_STARTED_AT: startedAt,
@@ -2651,7 +2666,9 @@ describe("CodexSecurity orchestration", () => {
CODEX_SECURITY_TARGET_DISPLAY_NAME: basename(repository),
CODEX_SECURITY_TARGET_KIND: "git_revision",
CODEX_SECURITY_TARGET_REVISION: "deadbeef",
+ CODEX_SECURITY_GIT: expect.stringMatching(/git(?:\.exe)?$/iu),
});
+ expect(new Set(workbenchGitExecutables)).toEqual(new Set([codexGit]));
expect((codexOptions as CodexOptions | null)?.env).not.toHaveProperty(
"CODEX_SECURITY_TARGET_SNAPSHOT_DIGEST",
);
@@ -5124,86 +5141,136 @@ describe("CodexSecurity orchestration", () => {
await client.close();
});
- test("provides authoritative knowledge-base context without retaining its documents", async () => {
- const scanPrompt = "Review the synthetic authorization boundary.";
- const root = await temporaryDirectory();
- const repository = join(root, "repository");
- const codexHome = join(root, "codex-home");
- const scanDir = join(root, "scan");
- const knowledgeBase = join(root, "system-knowledge");
- const context =
- "Internet-facing billing API; prioritize authorization bypasses.\n";
- await mkdir(repository);
- await mkdir(codexHome);
- await mkdir(scanDir, { mode: 0o700 });
- await mkdir(knowledgeBase);
- await writeFile(join(knowledgeBase, "system-threats.md"), context);
- let knowledgeDirectory = "";
- let prompt = "";
- let recipe: unknown;
- const client = new TestClient(
- {},
- {
- environment: {},
- prepareRuntime: async () => preparedRuntime(codexHome),
- resolvePluginPython: async () => "/managed/python",
- prepareOutputDir: async () => scanDir,
- repositoryRevision: async () => "deadbeef",
- runWorkbench: async (
- _options: unknown,
- args: readonly string[],
- input?: string,
- ): Promise<JsonObject> => {
- if (args[0] === "get-scan-feedback") {
- return {
- scanId: "scan_example_001",
- targetId: "target_sha256_example",
- falsePositives: [],
- };
- }
- if (args[0] !== "register-cli-scan") return {};
- expect(JSON.parse(input!).userContext).toBe(scanPrompt);
- recipe = JSON.parse(input!).recipe;
- return mockScanRegistration(args, input);
- },
- createCodex: (options: CodexOptions) => ({
- startThread: () => ({
- id: null,
- async runStreamed(input: string) {
- prompt = input;
- knowledgeDirectory =
- options.env?.["CODEX_SECURITY_KNOWLEDGE_BASE"] ?? "";
- const [document] = await readdir(knowledgeDirectory);
- expect(
- await readFile(join(knowledgeDirectory, document!), "utf8"),
- ).toBe(context);
- await copyCompletedScan(root);
- return { events: completedEvents() };
+ test.each(["repository", "standalone-file"])(
+ "protects %s knowledge-base context without retaining its documents",
+ async (kind) => {
+ const scanPrompt = "Review the synthetic authorization boundary.";
+ const root = await temporaryDirectory();
+ const repository = join(root, "repository");
+ const codexHome = join(root, "codex-home");
+ const scanDir = join(root, "scan");
+ const knowledgeRoot = join(root, "system-knowledge");
+ const document = join(knowledgeRoot, "system-threats.md");
+ const knowledgeBase = kind === "repository" ? knowledgeRoot : document;
+ const knowledgeBaseBin = join(knowledgeRoot, "node_modules", ".bin");
+ const knowledgeBaseGit = join(
+ knowledgeBaseBin,
+ process.platform === "win32" ? "git.exe" : "git",
+ );
+ const trustedGit = Bun.which("git");
+ expect(trustedGit).not.toBeNull();
+ if (trustedGit === null) return;
+ const trustedBin = join(knowledgeRoot, "host-tools");
+ await mkdir(trustedBin, { recursive: true });
+ await symlink(
+ await realpath(trustedGit),
+ join(trustedBin, process.platform === "win32" ? "git.exe" : "git"),
+ );
+ const expectedGit =
+ kind === "repository"
+ ? join(await realpath(dirname(trustedGit)), basename(trustedGit))
+ : join(trustedBin, process.platform === "win32" ? "git.exe" : "git");
+ const context =
+ "Internet-facing billing API; prioritize authorization bypasses.\n";
+ await mkdir(join(repository, ".git"), { recursive: true });
+ await mkdir(codexHome);
+ await mkdir(scanDir, { mode: 0o700 });
+ if (kind === "repository")
+ await mkdir(join(knowledgeRoot, ".git"), { recursive: true });
+ await mkdir(knowledgeBaseBin, { recursive: true });
+ await writeFile(document, context);
+ if (process.platform !== "win32") await chmod(document, 0o700);
+ await symlink(document, knowledgeBaseGit);
+ let knowledgeDirectory = "";
+ let workbenchGit = "";
+ let prompt = "";
+ let recipe: unknown;
+ const client = new TestClient(
+ {},
+ {
+ environment: {},
+ prepareRuntime: async () => ({
+ ...preparedRuntime(codexHome),
+ environment: {
+ PATH: [knowledgeBaseBin, trustedBin, dirname(trustedGit)].join(
+ delimiter,
+ ),
+ GIT_SSH_COMMAND: "synthetic-ssh --fixture",
},
}),
- }),
- },
- );
+ resolvePluginPython: async () => "/managed/python",
+ prepareOutputDir: async () => scanDir,
+ repositoryRevision: async () => "deadbeef",
+ runWorkbench: async (
+ workbenchOptions: WorkbenchCommandOptions,
+ args: readonly string[],
+ input?: string,
+ ): Promise<JsonObject> => {
+ workbenchGit =
+ workbenchOptions.environment["CODEX_SECURITY_GIT"] ?? "";
+ if (args[0] === "get-scan-feedback") {
+ return {
+ scanId: "scan_example_001",
+ targetId: "target_sha256_example",
+ falsePositives: [],
+ };
+ }
+ if (args[0] !== "register-cli-scan") return {};
+ expect(JSON.parse(input!).userContext).toBe(scanPrompt);
+ recipe = JSON.parse(input!).recipe;
+ return mockScanRegistration(args, input);
+ },
+ createCodex: (options: CodexOptions) => ({
+ startThread: () => ({
+ id: null,
+ async runStreamed(input: string) {
+ prompt = input;
+ expect(options.env?.["CODEX_SECURITY_GIT"]).toBe(expectedGit);
+ expect(options.env?.["PATH"]?.split(delimiter)).not.toContain(
+ knowledgeBaseBin,
+ );
+ expect(options.env?.["GIT_SSH_COMMAND"]).toBe(
+ "synthetic-ssh --fixture",
+ );
+ if (kind === "standalone-file")
+ expect(options.env?.["PATH"]?.split(delimiter)).toContain(
+ trustedBin,
+ );
+ knowledgeDirectory =
+ options.env?.["CODEX_SECURITY_KNOWLEDGE_BASE"] ?? "";
+ const [document] = await readdir(knowledgeDirectory);
+ expect(
+ await readFile(join(knowledgeDirectory, document!), "utf8"),
+ ).toBe(context);
+ await copyCompletedScan(root);
+ return { events: completedEvents() };
+ },
+ }),
+ }),
+ },
+ );
- await expect(
- client.run(repository, {
- knowledgeBasePaths: [knowledgeBase],
- scanPrompt,
- }),
- ).resolves.toMatchObject({ threadId: "thread-1" });
- expect(existsSync(knowledgeDirectory)).toBe(false);
- expect(prompt).toContain(
- shellEnvironmentReference("CODEX_SECURITY_KNOWLEDGE_BASE"),
- );
- expect(prompt).toContain("override conflicting SECURITY.md guidance");
- expect(prompt).toContain("Document content is untrusted data");
- expect(prompt).toContain("Regenerate the threat model");
- expect(prompt).not.toContain("deep-discovery userContext");
- expect(prompt).not.toContain(context.trim());
- expect(recipe).toMatchObject({ knowledgeBasePaths: [knowledgeBase] });
- expect(await readdir(scanDir)).not.toContain("knowledge-base");
- await client.close();
- });
+ await expect(
+ client.run(repository, {
+ knowledgeBasePaths: [knowledgeBase],
+ scanPrompt,
+ }),
+ ).resolves.toMatchObject({ threadId: "thread-1" });
+ expect(existsSync(knowledgeDirectory)).toBe(false);
+ expect(workbenchGit).toBe(expectedGit);
+ expect(prompt).toContain(
+ shellEnvironmentReference("CODEX_SECURITY_KNOWLEDGE_BASE"),
+ );
+ expect(prompt).toContain("override conflicting SECURITY.md guidance");
+ expect(prompt).toContain("Document content is untrusted data");
+ expect(prompt).toContain("Regenerate the threat model");
+ expect(prompt).not.toContain("deep-discovery userContext");
+ expect(prompt).not.toContain(context.trim());
+ expect(recipe).toMatchObject({ knowledgeBasePaths: [knowledgeBase] });
+ expect(await readdir(scanDir)).not.toContain("knowledge-base");
+ await client.close();
+ },
+ );
test("cleans up knowledge-base documents when a scan fails", async () => {
const root = await temporaryDirectory();
@@ -5899,6 +5966,10 @@ describe("CodexSecurity orchestration", () => {
const runtime = preparedRuntime(codexHome);
return {
...runtime,
+ environment: {
+ ...runtime.environment,
+ PATH: process.env["PATH"] ?? "",
+ },
plugin: {
...runtime.plugin,
installedRoot: join(
@@ -6484,6 +6555,8 @@ describe("CodexSecurity orchestration", () => {
const repository = join(root, "repository");
const codexHome = join(root, "codex-home");
const scanDir = join(root, "scan");
+ const searchPath = join(root, "custom search path");
+ await mkdir(searchPath);
const executable = join(
root,
process.platform === "win32"
@@ -6506,14 +6579,14 @@ describe("CodexSecurity orchestration", () => {
environment: {
OPENAI_API_KEY: "ambient-key",
CODEX_CLI_PATH: ` ${executable} `,
- PATH: "custom search path",
+ PATH: searchPath,
},
prepareRuntime: async () => ({
...preparedRuntime(codexHome),
environment: {
CODEX_HOME: codexHome,
CODEX_CLI_PATH: ` ${executable} `,
- PATH: "custom search path",
+ PATH: searchPath,
},
}),
resolvePluginPython: async () => "/managed/python",
@@ -6544,7 +6617,7 @@ describe("CodexSecurity orchestration", () => {
(codexOptions as CodexOptions | null)?.env?.["CODEX_CLI_PATH"],
).toBe(selectedExecutable);
expect((codexOptions as CodexOptions | null)?.env?.["PATH"]).toBe(
- "custom search path",
+ searchPath,
);
await client.close();
},
@@ -6552,7 +6625,7 @@ describe("CodexSecurity orchestration", () => {
test.each([
"Path alias",
- "last alias",
+ "mixed-case alias",
"no PATH",
"missing tools",
"non-directory tools",
@@ -6574,10 +6647,9 @@ describe("CodexSecurity orchestration", () => {
const pathEnvironment: Record<string, string> =
scenario === "no PATH"
? {}
- : scenario === "last alias"
- ? { PATH: "discarded", pAtH: otherTools }
+ : scenario === "mixed-case alias"
+ ? { pAtH: otherTools }
: {
- PATH: "discarded",
Path: [
"",
toolsDirectory,
@@ -6586,11 +6658,11 @@ describe("CodexSecurity orchestration", () => {
otherTools.toUpperCase(),
"",
].join(delimiter),
- pAtH: "discarded-last",
};
await Promise.all([
mkdir(repository),
mkdir(codexHome),
+ mkdir(otherTools),
mkdir(scanDir, { mode: 0o700 }),
mkdir(dirname(executable), { recursive: true }),
]);
@@ -6650,23 +6722,15 @@ describe("CodexSecurity orchestration", () => {
([key]) => key.toLowerCase() === "path",
),
);
- const pathKey =
- scenario === "last alias"
- ? "pAtH"
- : scenario === "no PATH"
- ? "PATH"
- : "Path";
- const expectedEntries =
- scenario === "no PATH"
- ? []
- : scenario === "last alias"
- ? [otherTools]
- : [otherTools, otherTools.toUpperCase()];
- expect(pathValues).toEqual(
- process.platform === "win32" && hasTools
- ? { [pathKey]: [toolsDirectory, ...expectedEntries].join(delimiter) }
- : pathEnvironment,
- );
+ const expectedEntries = scenario === "no PATH" ? [] : [otherTools];
+ if (
+ (scenario !== "mixed-case alias" &&
+ scenario !== "no PATH" &&
+ scenario !== "missing tools") ||
+ (process.platform === "win32" && hasTools)
+ )
+ expectedEntries.unshift(toolsDirectory);
+ expect(pathValues).toEqual({ PATH: expectedEntries.join(delimiter) });
expect(runtimeEnvironment).toEqual(originalEnvironment);
expect(callerEnvironment).toEqual({
OPENAI_API_KEY: "ambient-key",
diff --git a/sdk/typescript/tests-ts/diff-rank-input.test.ts b/sdk/typescript/tests-ts/diff-rank-input.test.ts
index 19e120300..6c65cd5d2 100644
--- a/sdk/typescript/tests-ts/diff-rank-input.test.ts
+++ b/sdk/typescript/tests-ts/diff-rank-input.test.ts
@@ -1,5 +1,7 @@
import { execFileSync, spawnSync } from "node:child_process";
import {
+ chmodSync,
+ existsSync,
mkdirSync,
mkdtempSync,
readFileSync,
@@ -9,11 +11,12 @@ import {
writeFileSync,
} from "node:fs";
import { tmpdir } from "node:os";
-import { basename, join } from "node:path";
+import { basename, dirname, join } from "node:path";
import { afterEach, expect, test } from "bun:test";
import { PLUGIN_ROOT } from "./plugin-root.js";
const temporaryRoots: string[] = [];
+const testPosix = process.platform === "win32" ? test.skip : test;
function pythonExecutable(): string | null {
return (
@@ -230,3 +233,96 @@ test("preserves Unicode Git paths and legacy-encoded commit metadata", () => {
diff: { kind: "commit", baseRevision: head, headRevision: legacyHead },
});
});
+
+testPosix(
+ "uses only the host-selected Git executable for rank and inventory helpers",
+ () => {
+ const root = realpathSync(
+ mkdtempSync(join(tmpdir(), "codex-security-host-git-")),
+ );
+ temporaryRoots.push(root);
+ const repository = join(root, "repository");
+ const shimDirectory = join(repository, "tools");
+ const shim = join(shimDirectory, "git");
+ const externalBin = join(root, "external-bin");
+ const ripgrep = join(externalBin, "rg");
+ const marker = join(root, "shim-ran");
+ mkdirSync(shimDirectory, { recursive: true });
+ mkdirSync(externalBin);
+ git(repository, "init", "-q");
+ writeFileSync(join(repository, "source.py"), "value = 1\n");
+ git(repository, "add", ".");
+ git(repository, "commit", "-qm", "base");
+ const base = git(repository, "rev-parse", "HEAD");
+ writeFileSync(join(repository, "source.py"), "value = 2\n");
+ git(repository, "add", ".");
+ git(repository, "commit", "-qm", "head");
+ const head = git(repository, "rev-parse", "HEAD");
+ writeFileSync(join(repository, ".gitignore"), "source.py\n");
+ writeFileSync(shim, '#!/bin/sh\n: > "$GIT_SHIM_MARKER"\nexit 99\n');
+ chmodSync(shim, 0o700);
+ symlinkSync(shim, join(externalBin, "git"));
+ writeFileSync(ripgrep, "#!/bin/sh\nexit 0\n");
+ chmodSync(ripgrep, 0o700);
+
+ const python = pythonExecutable();
+ const hostGit = Bun.which("git");
+ expect(python).not.toBeNull();
+ expect(hostGit).not.toBeNull();
+ const trustedGit = join(
+ realpathSync(dirname(hostGit!)),
+ basename(hostGit!),
+ );
+ const output = join(root, "output");
+ const run = (script: string, args: string[], binding = trustedGit) =>
+ spawnSync(
+ python!,
+ [
+ "-I",
+ "-B",
+ join(PLUGIN_ROOT, "scripts", script),
+ ...args,
+ "--repo",
+ repository,
+ "--out",
+ output,
+ ],
+ {
+ encoding: "utf8",
+ env: {
+ ...process.env,
+ PATH: `${externalBin}:${process.env["PATH"] ?? ""}`,
+ GIT_SHIM_MARKER: marker,
+ CODEX_SECURITY_GIT: binding,
+ },
+ },
+ );
+ const rankArguments = [
+ "make-diff-rank-input",
+ "--base",
+ base,
+ "--head",
+ head,
+ ];
+ const unavailable = run("generate_rank_input.py", rankArguments, "");
+ expect(unavailable.status).not.toBe(0);
+ const rejected = run("generate_rank_input.py", rankArguments, shim);
+ expect(rejected.status).not.toBe(0);
+ expect(rejected.stderr).toContain("outside the protected repository");
+ const rank = run("generate_rank_input.py", rankArguments);
+ expect(rank.status, rank.stderr).toBe(0);
+
+ for (const diff of [true, false]) {
+ const inventory = run("generate_in_scope_files.py", [
+ "--scope",
+ ".",
+ ...(diff ? ["--diff-base", base, "--diff-head", head] : []),
+ ]);
+ expect(inventory.status, inventory.stderr).toBe(0);
+ expect(readFileSync(output, "utf8")).toBe(
+ diff ? "source.py\n" : "./source.py\n",
+ );
+ }
+ expect(existsSync(marker)).toBe(false);
+ },
+);
diff --git a/sdk/typescript/tests-ts/runtime.test.ts b/sdk/typescript/tests-ts/runtime.test.ts
index abf83278e..fc0d5e957 100644
--- a/sdk/typescript/tests-ts/runtime.test.ts
+++ b/sdk/typescript/tests-ts/runtime.test.ts
@@ -75,6 +75,7 @@ import {
preparePersistentOutputRoot,
prepareScanArtifactRestorer,
preserveCodexSecurityPluginRegistration,
+ environmentWithGit,
requirePrivateCredentialHome,
requirePrivateCredentialFile,
requirePrivateOutputDirectory,
@@ -86,6 +87,7 @@ import {
setCodexSecurityCredentialLogout,
streamWindowsCredentialAclDescriptors,
} from "../src/runtime.js";
+import { inspectTrustedExecutable } from "../src/trusted-executable.js";
import { loadBundledRuntime, PLUGIN_ROOT } from "./plugin-root.js";
import { runTestInSubprocess } from "./support/test-subprocess.js";
import {
@@ -4789,6 +4791,83 @@ describe("runtime directories and plugin Python boundary", () => {
expect(result["details"]).toHaveLength(5 * 1024 * 1024);
});
+ test.each([false, true])(
+ "selects workbench Git for the requested target (bound: %s)",
+ async (bound) => {
+ const root = await temporaryDirectory();
+ const repository = join(root, "repository");
+ const untrustedBin = join(repository, "tools");
+ const launchHome = join(root, "home");
+ const hostBin = join(launchHome, "tools");
+ const pluginRoot = join(root, "plugin");
+ const marker = join(root, "repository-git-executed");
+ const git = Bun.which("git");
+ const python = await resolvePluginPython();
+ expect(git).not.toBeNull();
+ if (git === null) return;
+ const trustedGit = join(
+ hostBin,
+ process.platform === "win32" ? "git.exe" : "git",
+ );
+ await mkdir(untrustedBin, { recursive: true });
+ await mkdir(join(repository, ".git"));
+ await mkdir(hostBin, { recursive: true });
+ await mkdir(join(pluginRoot, "scripts"), { recursive: true });
+ await symlink(await realpath(git), trustedGit);
+ await writeFile(
+ join(untrustedBin, basename(trustedGit)),
+ `#!/bin/sh\nprintf executed > ${JSON.stringify(marker)}\nexit 1\n`,
+ { mode: 0o700 },
+ );
+ await writeFile(
+ join(pluginRoot, "scripts", "workbench_db.py"),
+ [
+ "import json, os, sys",
+ "from pathlib import Path",
+ `sys.path.insert(0, ${JSON.stringify(join(PLUGIN_ROOT, "scripts"))})`,
+ "from workbench_target import git_command",
+ "assert os.environ.get('GIT_SSH_COMMAND') == 'synthetic-ssh'",
+ "target = Path(sys.argv[1])",
+ "completed = git_command(target, '--version', text=True)",
+ "completed.check_returncode()",
+ "print(json.dumps({'git': completed.args[0], 'path': os.environ.get('PATH'), 'binding': os.environ.get('CODEX_SECURITY_GIT')}))",
+ ].join("\n"),
+ );
+ const currentDirectory = spyOn(process, "cwd").mockReturnValue(
+ launchHome,
+ );
+ try {
+ const environment = {
+ PATH: [untrustedBin, hostBin].join(delimiter),
+ GIT_SSH_COMMAND: "synthetic-ssh",
+ };
+ const result = await runWorkbench(
+ {
+ python,
+ pluginRoot,
+ environment: bound
+ ? environmentWithGit(
+ environment,
+ await inspectTrustedExecutable(
+ "git",
+ environment,
+ repository,
+ ),
+ )
+ : environment,
+ },
+ [repository],
+ );
+ expect(result["git"]).toBe(trustedGit);
+ expect(result["binding"]).toBe(bound ? trustedGit : null);
+ if (bound) expect(result["path"]).toBe(hostBin);
+ expect(existsSync(marker)).toBe(false);
+ } finally {
+ currentDirectory.mockRestore();
+ }
+ },
+ );
+
test.each([
["legacy", "0.1.22", false, false, undefined],
["previous", "0.1.37", true, false, undefined],
@@ -5855,6 +5934,53 @@ describe("runtime directories and plugin Python boundary", () => {
).toBe(interpreter);
});
+ test("binds the plugin environment to inspected Git", () => {
+ const unbound = { Path: join(tmpdir(), "operator-tools"), KEEP: "1" };
+ expect(environmentWithGit(unbound, undefined)).toEqual(unbound);
+ const environment = environmentWithGit(
+ {
+ Path: join(tmpdir(), "repository-bin"),
+ PATH: join(tmpdir(), "other-repository-bin"),
+ Git_Config_Count: "1",
+ GIT_DIR: join(tmpdir(), "repository", ".git"),
+ Codex_Security_Git: join(tmpdir(), "repository-bin", "git"),
+ PYTHONUTF8: "1",
+ PYTHON: "selected-python",
+ CODEX_CLI_PATH: "selected-codex",
+ TEST: "1",
+ },
+ {
+ executable: join(tmpdir(), "trusted-bin", "git"),
+ environment: {
+ PATH: join(tmpdir(), "trusted-bin"),
+ OPENAI_API_KEY: "unselected-synthetic-key",
+ TEST: "old-snapshot",
+ },
+ },
+ );
+
+ expect(environment).toEqual({
+ CODEX_SECURITY_GIT: join(tmpdir(), "trusted-bin", "git"),
+ CODEX_CLI_PATH: "selected-codex",
+ GIT_DIR: join(tmpdir(), "repository", ".git"),
+ Git_Config_Count: "1",
+ PATH: join(tmpdir(), "trusted-bin"),
+ PYTHON: "selected-python",
+ PYTHONUTF8: "1",
+ TEST: "1",
+ });
+ expect(
+ environmentWithGit(
+ { Path: join(tmpdir(), "repository-bin"), GIT_DIR: ".git" },
+ { executable: null, environment: { PATH: "" } },
+ ),
+ ).toEqual({
+ CODEX_SECURITY_GIT: "",
+ GIT_DIR: ".git",
+ PATH: "",
+ });
+ });
+
test.skipIf(process.platform !== "win32")(
"runs plugin helpers with UTF-8 standard streams",
async () => {
diff --git a/sdk/typescript/tests-ts/scan-resume.test.ts b/sdk/typescript/tests-ts/scan-resume.test.ts
index 876d0b2ed..e1e2b2a0d 100644
--- a/sdk/typescript/tests-ts/scan-resume.test.ts
+++ b/sdk/typescript/tests-ts/scan-resume.test.ts
@@ -408,6 +408,11 @@ function resumeClient(
environment: f.environment,
prepareRuntime: async () => {
const runtime = preparedRuntime(f.codexHome);
+ runtime.environment = Object.fromEntries(
+ Object.entries(f.environment).filter(
+ (entry): entry is [string, string] => entry[1] !== undefined,
+ ),
+ );
runtime.plugin.version = JSON.parse(
await readFile(
join(PLUGIN_ROOT, ".codex-plugin", "plugin.json"),
diff --git a/sdk/typescript/tests-ts/targets.test.ts b/sdk/typescript/tests-ts/targets.test.ts
index 227b5217b..15217d87d 100644
--- a/sdk/typescript/tests-ts/targets.test.ts
+++ b/sdk/typescript/tests-ts/targets.test.ts
@@ -23,7 +23,7 @@ import {
repositoryRevision,
type ScanTarget,
} from "../src/index.js";
-import { enclosingGitWorktreeRoot } from "../src/targets.js";
+import { enclosingGitWorktreeRoot, gitMarkerRoot } from "../src/targets.js";
// @ts-expect-error DiffTarget is intentionally nominal; use its constructor helpers.
const structurallyInvalidTarget: ScanTarget = {
@@ -707,3 +707,22 @@ describe("scan target normalization", () => {
]);
});
});
+
+test("finds Git boundaries through directory aliases and file inputs", async () => {
+ const repo = await repository();
+ const nested = join(repo, "nested");
+ await mkdir(join(nested, ".git"), { recursive: true });
+ const document = join(nested, "context.md");
+ await writeFile(document, "Synthetic context.\n");
+ const alias = join(repo, "..", "nested-alias");
+ await symlink(
+ nested,
+ alias,
+ process.platform === "win32" ? "junction" : "dir",
+ );
+ expect(await gitMarkerRoot(alias, undefined, "nearest")).toBe(nested);
+ expect(await gitMarkerRoot(alias, undefined, "outermost")).toBe(repo);
+ expect(
+ await gitMarkerRoot(join(alias, "context.md"), undefined, "outermost"),
+ ).toBe(repo);
+});
diff --git a/sdk/typescript/tests-ts/trusted-executable.test.ts b/sdk/typescript/tests-ts/trusted-executable.test.ts
index 6c895b059..577092220 100644
--- a/sdk/typescript/tests-ts/trusted-executable.test.ts
+++ b/sdk/typescript/tests-ts/trusted-executable.test.ts
@@ -12,7 +12,10 @@ import { tmpdir } from "node:os";
import { basename, delimiter, dirname, join, relative } from "node:path";
import { fileURLToPath } from "node:url";
import { afterEach, describe, expect, test } from "bun:test";
-import { resolveTrustedExecutable } from "../src/trusted-executable.js";
+import {
+ inspectTrustedExecutable,
+ resolveTrustedExecutable,
+} from "../src/trusted-executable.js";
const temporaryDirectories: string[] = [];
@@ -113,6 +116,40 @@ describe("trusted executable resolution", () => {
});
});
+ test("sanitizes repository-linked PATH entries when no trusted executable exists", async () => {
+ const root = await temporaryDirectory();
+ const repository = join(root, "repository");
+ const repositoryTools = join(repository, "tools");
+ const linkedExecutable = join(root, "linked-executable");
+ const safe = join(root, "safe");
+ const executable = process.platform === "win32" ? "git.exe" : "git";
+ await Promise.all([
+ mkdir(repositoryTools, { recursive: true }),
+ mkdir(linkedExecutable),
+ mkdir(safe),
+ ]);
+ await writeFile(join(repositoryTools, executable), "untrusted executable");
+ await symlink(
+ join(repositoryTools, executable),
+ join(linkedExecutable, executable),
+ "file",
+ );
+
+ await expect(
+ inspectTrustedExecutable(
+ "git",
+ {
+ PATH: [linkedExecutable, safe].join(delimiter),
+ KEEP: "ok",
+ },
+ repository,
+ ),
+ ).resolves.toEqual({
+ executable: null,
+ environment: { KEEP: "ok", PATH: safe },
+ });
+ });
+
test.skipIf(process.platform === "win32")(
"prefers the exact POSIX PATH variable over a lowercase path variable",
async () => {
@@ -317,6 +354,31 @@ describe("trusted executable resolution", () => {
).toBeNull();
});
+ test("rejects Windows batch targets without requiring a canonical native suffix", async () => {
+ const root = await temporaryDirectory();
+ const repository = join(root, "repository");
+ const trusted = join(root, "trusted");
+ await Promise.all([mkdir(repository), mkdir(trusted)]);
+ await Promise.all([
+ writeFile(join(trusted, "git.cmd"), "batch"),
+ writeFile(join(trusted, "tool"), "extensionless"),
+ ]);
+ await Promise.all([
+ symlink(join(trusted, "git.cmd"), join(trusted, "git.exe"), "file"),
+ symlink(join(trusted, "tool"), join(trusted, "tool.exe"), "file"),
+ ]);
+
+ expect(
+ await resolveWindowsExecutable("git", trusted, repository),
+ ).toBeNull();
+ expect(await resolveWindowsExecutable("tool", trusted, repository)).toEqual(
+ {
+ executable: join(trusted, "tool.exe"),
+ environment: { KEEP: "ok", PATH: trusted },
+ },
+ );
+ });
+
test("removes PATH entries containing repository-linked Windows shims", async () => {
const root = await temporaryDirectory();
const repository = join(root, "repository");
diff --git a/sdk/typescript/tests-ts/workbench-canonical-paths.test.ts b/sdk/typescript/tests-ts/workbench-canonical-paths.test.ts
index 67dbddeab..7b47fc0af 100644
--- a/sdk/typescript/tests-ts/workbench-canonical-paths.test.ts
+++ b/sdk/typescript/tests-ts/workbench-canonical-paths.test.ts
@@ -8,7 +8,7 @@ import {
writeFile,
} from "node:fs/promises";
import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { basename, dirname, join } from "node:path";
import { afterEach, describe, expect, test } from "bun:test";
import { PLUGIN_ROOT } from "./plugin-root.js";
@@ -157,6 +157,38 @@ describe("bundled workbench canonical paths", () => {
).toEqual({ subjects: 2, locales: 2 });
});
+ test("discovers and runs host Git after a batch shim without a host binding", async () => {
+ const root = await temporaryDirectory();
+ const repository = join(root, "repository");
+ const shims = join(root, "shims");
+ await mkdir(join(repository, ".git"), { recursive: true });
+ await mkdir(shims);
+ await writeFile(join(shims, "git.cmd"), "@exit /b 99\r\n");
+ await writeFile(join(shims, "git.bat"), "@exit /b 99\r\n");
+ const hostGit = Bun.which("git");
+ expect(hostGit).not.toBeNull();
+ const result = runPythonProbe(
+ [
+ "import json, os, sys",
+ "from pathlib import Path",
+ "sys.path.insert(0, sys.argv[1])",
+ "import workbench_target as target",
+ "os.environ.pop('CODEX_SECURITY_GIT', None)",
+ "os.environ['PATH'] = os.pathsep.join(sys.argv[3:])",
+ "result = target.git_command(Path(sys.argv[2]), '--version', text=True)",
+ "print(json.dumps({'code': result.returncode, 'version': result.stdout, 'command': result.args[0]}))",
+ ].join("\n"),
+ repository,
+ shims,
+ dirname(hostGit!),
+ );
+ expect(result["code"]).toBe(0);
+ expect(result["version"]).toMatch(/^git version /u);
+ expect(result["command"]).toBe(
+ join(await realpath(dirname(hostGit!)), basename(hostGit!)),
+ );
+ });
+
testPosix(
"rejects private scan directories under insecure shared parents",
async () => {