OpenAI's Codex Security CLI and TypeScript SDK for finding, validating, and fixing security vulnerabilities. npm: https://www.npmjs.com/package/@openai/codex-security
TypeScript ai-securityapplication-securityclicode-scanningcodexcodex-securitycybersecuritydevsecopsnodejsnpmopenaisdksecuritytypescriptvulnerability-scanning
import { lstat, readFile, realpath, stat } from "node:fs/promises";
import { dirname, isAbsolute, join, resolve, sep } from "node:path";
import { environmentEntry } from "./auth.js";
import { abortReason } from "./errors.js";
import { canonicalConfigPath } from "./runtime.js";
import {
abortable,
gitMarkerRoot,
gitProtectionRoots,
nullIfMissingPath,
} from "./targets.js";
async function bareMetadataRoots(
repository: string,
signal?: AbortSignal,
): Promise<string[]> {
const roots: string[] = [];
let directory = repository;
for (;;) {
signal?.throwIfAborted();
const present = async (name: string) =>
(await abortable(
() => lstat(join(directory, name)).catch(nullIfMissingPath),
signal,
)) !== null;
// Git also discovers bare repositories and linked metadata without .git.
const head = await abortable(
() => lstat(join(directory, "HEAD")).catch(nullIfMissingPath),
signal,
);
if (
(head?.isFile() || head?.isSymbolicLink()) &&
((await present("commondir")) ||
((await present("objects")) && (await present("refs"))))
)
roots.push(directory);
const parent = dirname(directory);
if (parent === directory) return roots;
directory = parent;
}
}
async function metadataPointer(
path: string,
prefix: string,
context: { directory: string; environment: NodeJS.ProcessEnv },
signal?: AbortSignal,
): Promise<string | undefined> {
const metadata = await abortable(
() => stat(path).catch(nullIfMissingPath),
signal,
);
if (!metadata?.isFile()) return undefined;
const text = await abortable(() => readFile(path, "utf8"), signal);
if (!text.startsWith(prefix) || (prefix === "" && text.length === 0))
return undefined;
const payload = text.slice(prefix.length).replace(/[\r\n]+$/u, "");
if (prefix !== "" && payload.length === 0) return undefined;
// Git checks emptiness before consuming the path as a NUL-terminated string.
const value = payload.split("\0", 1)[0]!;
// Preserve filesystem traversal through links before '..'.
let target = isAbsolute(value) ? value : `${dirname(path)}${sep}${value}`;
if (process.platform === "win32") {
const drive = /^[A-Za-z]:(?![\\/])/u.exec(value)?.[0].toUpperCase();
if (drive !== undefined) {
const directory =
context.directory.slice(0, 2).toUpperCase() === drive
? context.directory
: environmentEntry(context.environment, `=${drive}`) || `${drive}\\`;
target = resolve(directory, value.slice(2));
} else if (isAbsolute(value)) target = resolve(context.directory, value);
}
return (
(await abortable(
() => realpath(target).catch(nullIfMissingPath),
signal,
)) ?? undefined
);
}
async function associatedMetadataRoots(
directory: string,
context: { directory: string; environment: NodeJS.ProcessEnv },
signal?: AbortSignal,
configurationDirectory?: string,
): Promise<string[]> {
const head = await abortable(
() => lstat(join(directory, "HEAD")).catch(nullIfMissingPath),
signal,
);
if (!head || (!head.isFile() && !head.isSymbolicLink())) return [];
const commonMarker = join(directory, "commondir");
const hasCommon = await abortable(
() => lstat(commonMarker).catch(nullIfMissingPath),
signal,
);
const common = hasCommon
? await metadataPointer(commonMarker, "", context, signal)
: undefined;
if (hasCommon && common === undefined) return [];
const storage = common ?? directory;
for (const name of ["objects", "refs"]) {
const metadata = await abortable(
() => stat(join(storage, name)).catch(nullIfMissingPath),
signal,
);
if (!metadata?.isDirectory()) return [];
}
const roots = common === undefined ? [directory] : [directory, common];
if (
process.platform === "win32" &&
configurationDirectory !== undefined &&
configurationDirectory !== context.directory
) {
// Git rereads commondir after changing to the discovered repository root.
roots.push(
...(await associatedMetadataRoots(
directory,
{
...context,
directory: await abortable(
() => canonicalConfigPath(configurationDirectory),
signal,
),
},
signal,
)),
);
}
return roots;
}
export async function localGitProtectionRoots(
repository: string,
environment: NodeJS.ProcessEnv,
signal?: AbortSignal,
requestedPaths: readonly string[] = [],
): Promise<string[]> {
const roots = new Set(
await abortable(() => gitProtectionRoots(repository, signal), signal),
);
const context = {
directory: await abortable(() => canonicalConfigPath(repository), signal),
environment,
};
const paths = new Set([
resolve(repository),
context.directory,
...requestedPaths,
]);
for (const path of paths) {
for (const root of await bareMetadataRoots(path, signal)) {
roots.add(root);
for (const associated of await associatedMetadataRoots(
root,
context,
signal,
root,
))
roots.add(associated);
}
let directory = path;
for (;;) {
signal?.throwIfAborted();
const marker = join(directory, ".git");
const metadata = await abortable(
() => stat(marker).catch(nullIfMissingPath),
signal,
);
if (metadata !== null) {
roots.add(directory);
const gitDirectory = metadata.isDirectory()
? await abortable(() => realpath(marker), signal)
: await metadataPointer(marker, "gitdir: ", context, signal);
if (gitDirectory !== undefined)
for (const associated of await associatedMetadataRoots(
gitDirectory,
context,
signal,
directory,
))
roots.add(associated);
}
const parent = dirname(directory);
if (parent === directory) break;
directory = parent;
}
}
for (const root of [...roots])
roots.add(await abortable(() => canonicalConfigPath(root), signal));
return [...roots];
}
/** Discover Git metadata for the selection, then for the current working directory. */
export async function commandGitProtectionRoots(
repository: string,
environment: NodeJS.ProcessEnv,
signal?: AbortSignal,
{
cwd = process.cwd(),
requestedPaths,
}: {
cwd?: string;
requestedPaths?: readonly string[];
} = {},
): Promise<string[]> {
const roots = await localGitProtectionRoots(
repository,
environment,
signal,
requestedPaths,
);
if (signal?.aborted) throw abortReason(signal);
if (cwd !== repository)
roots.push(...(await localGitProtectionRoots(cwd, environment, signal)));
return roots;
}
export async function hasGitMetadata(
repository: string,
signal?: AbortSignal,
): Promise<boolean> {
return (
(await abortable(
() => gitMarkerRoot(repository, signal, "nearest"),
signal,
)) !== null || (await bareMetadataRoots(repository, signal)).length !== 0
);
}