* fix: bind identity and coverage to the producing rule Logical paths, container families, examined bytes, path-segment conventions, destination collisions, file-id leases, Mach-O CPU selection, and firmware cleanup now follow the observation that owns each rule. * fix: fail unmatched Mach-O slices and keep firmware roots independent A fat target whose architecture lipo did not list now stops before slice tools run. Chained fixups still count unread LC_DYLD_INFO rebase bytes, and a firmware cleanup failure no longer blocks the next workspace. * test: cover path identity and runtime families at the projection boundary NFC joins and segment conventions are now asserted by the path resolver, the Apple projection, and a real APK inventory instead of helper unit tests. * test: expect unread dyld rebase bytes in the Apple dispatch fixture The legacy LC_DYLD_INFO fixture keeps a rebase range this reader does not decode, so the public CLI and MCP check now requires that partial coverage beside the bind opcodes. --------- Co-authored-by: Cursor Agent <cursoragent@cursor.com>
113 lines
3.8 KiB
TypeScript
113 lines
3.8 KiB
TypeScript
import { access, realpath, stat } from "node:fs/promises";
|
|
import { constants as fsConstants } from "node:fs";
|
|
import { delimiter, isAbsolute, join, resolve } from "node:path";
|
|
|
|
import type { ProcessScenario } from "../../domain/process/processScenario.js";
|
|
import { snapshotEnvironment } from "../snapshotEnvironment.js";
|
|
import {
|
|
ProcessCaptureError,
|
|
processCaptureCancelled,
|
|
} from "./ProcessCaptureError.js";
|
|
|
|
/** Resolve caller-selected executable and observation paths for this execution. */
|
|
export const resolveProcessScenarioRuntimePaths = async (
|
|
scenario: ProcessScenario,
|
|
environment: Readonly<Record<string, string | undefined>> = process.env,
|
|
platform: NodeJS.Platform = process.platform,
|
|
): Promise<ProcessScenario> => {
|
|
const selectedWorkingDirectory = resolve(scenario.working_directory);
|
|
let workingDirectory: string;
|
|
try {
|
|
workingDirectory = await realpath(selectedWorkingDirectory);
|
|
} catch (cause: unknown) {
|
|
throw new ProcessCaptureError(
|
|
`working directory could not be resolved: ${selectedWorkingDirectory}${osFailure(cause)}`,
|
|
{ cause },
|
|
);
|
|
}
|
|
let workingDirectoryStat;
|
|
try {
|
|
workingDirectoryStat = await stat(workingDirectory);
|
|
} catch (cause: unknown) {
|
|
throw new ProcessCaptureError(
|
|
`working directory could not be inspected: ${workingDirectory}${osFailure(cause)}`,
|
|
{ cause },
|
|
);
|
|
}
|
|
if (!workingDirectoryStat.isDirectory())
|
|
throw new ProcessCaptureError(
|
|
`working directory is not a directory: ${workingDirectory}`,
|
|
);
|
|
const executable = await resolveExecutable(
|
|
scenario.executable,
|
|
workingDirectory,
|
|
snapshotEnvironment(scenario.environment, platform).PATH ??
|
|
snapshotEnvironment(environment, platform).PATH ??
|
|
"",
|
|
);
|
|
const observationPaths = scenario.filesystem_observation_paths.map((path) =>
|
|
resolve(workingDirectory, path),
|
|
);
|
|
return {
|
|
...scenario,
|
|
executable,
|
|
working_directory: workingDirectory,
|
|
filesystem_observation_paths: observationPaths,
|
|
};
|
|
};
|
|
|
|
/** Resolve a selected executable through the caller's effective PATH. */
|
|
export const resolveExecutable = async (
|
|
command: string,
|
|
workingDirectory: string,
|
|
searchPath: string,
|
|
): Promise<string> => {
|
|
const directories = searchPath
|
|
.split(delimiter)
|
|
.map((directory) =>
|
|
directory === ""
|
|
? workingDirectory
|
|
: resolve(workingDirectory, directory),
|
|
);
|
|
const candidates =
|
|
isAbsolute(command) || command.includes("/") || command.includes("\\")
|
|
? [resolve(workingDirectory, command)]
|
|
: directories.map((directory) => join(directory, command));
|
|
const failures: string[] = [];
|
|
for (const candidate of candidates) {
|
|
try {
|
|
await access(candidate, fsConstants.X_OK);
|
|
if ((await stat(candidate)).isFile()) return candidate;
|
|
failures.push(`${candidate} (not a regular file)`);
|
|
} catch (cause: unknown) {
|
|
const code = osErrorCode(cause);
|
|
if (code !== "ENOENT" && code !== "ENOTDIR")
|
|
failures.push(`${candidate}${osFailure(cause)}`);
|
|
continue;
|
|
}
|
|
}
|
|
throw new ProcessCaptureError(
|
|
failures.length === 0
|
|
? `executable could not be resolved: ${command}`
|
|
: `executable could not be resolved: ${command}; checked ${failures.join("; ")}`,
|
|
);
|
|
};
|
|
|
|
const osErrorCode = (cause: unknown): string | undefined =>
|
|
typeof cause === "object" &&
|
|
cause !== null &&
|
|
"code" in cause &&
|
|
typeof cause.code === "string"
|
|
? cause.code
|
|
: undefined;
|
|
|
|
const osFailure = (cause: unknown): string => {
|
|
const code = osErrorCode(cause);
|
|
return code === undefined ? "" : ` (${code})`;
|
|
};
|
|
|
|
/** Reject cancellation before a process capture operation begins. */
|
|
export const assertNotCancelled = (signal: AbortSignal | undefined): void => {
|
|
if (signal?.aborted === true) throw processCaptureCancelled();
|
|
};
|