refactor(process): give POSIX PATH search order one owner (#10891)

* refactor(process): give POSIX PATH search order one owner

Program lookup, the packet-tool locator and Jadx's Java lookup each split
PATH and resolved empty and relative entries themselves. They now take the
candidates from posixPathCandidates in src/process/executableSearch and keep
only their own probe and failure reporting. A counted architecture guard
keeps new PATH splits from returning; the remaining Windows and Ghidra
searches are baselined.

* refactor(process): move the colon-split PATH searches onto the search owner

REA's launcher-alias lookup and Ghidra's macOS Java lookup split PATH on
":" and skipped relative entries themselves; they now use
posixPathCandidates with relativeEntries: "skip", and the guard counts
colon splits of PATH as well.

* fix(process): produce PATH candidates lazily so an unused entry cannot fail an earlier match

* refactor(process): give Windows PATH/PATHEXT search order the executable search owner (#10916)

* refactor(process): give Windows PATH/PATHEXT search order the executable search owner

* fix(process): keep later PATH entries searchable after a stray quote or a removed working directory

* fix(reverse): refuse a Windows objdump or Rizin command that PATH does not find (#10953)

* fix(reverse): refuse an objdump or Rizin command Windows PATH does not find instead of launching the bare name

* fix(reverse): report a Windows lookup refusal after cancellation and to capability discovery

* fix(desktop): search a Windows host's PATH as Windows does when doctor looks up a program

programOnPath sent every host through the POSIX PATH search, so on Windows a
relative PATH entry reached absoluteCallerPath with platform linux and the
Windows working directory, which resolved against itself until the stack
overflowed. programOnPath now searches PATH and PATHEXT through
windowsPathCandidates on a Windows host, and absoluteCallerPath refuses a
non-POSIX working directory with a TypeError instead of recursing.
This commit is contained in:
morluto authored and GitHub committed 2026-11-15 18:24:04 +08:00
1 parent 659772952d
commit 422cff00ab
23 files changed
+912 -330

No files matched your search

@@ -1,6 +1,10 @@
import { statSync } from "node:fs";
import { win32 } from "node:path";
import { windowsPathEntries } from "../process/WindowsExecutable.js";
import { err, ok, type Result } from "../domain/result.js";
import {
windowsPathCandidates,
type WindowsPathSearchFailure,
} from "../process/executableSearch.js";
export interface WindowsExecutableLookup {
/** Windows-formatted working directory; defaults to the process CWD. */
@@ -17,43 +21,32 @@ const isRegularFile = (path: string): boolean => {
}
};
/** Resolve Windows bare command names against the captured child environment. */
/**
* Resolve a configured command against the captured child environment. A
* path is resolved against `cwd`; a bare name must be found on PATH/PATHEXT,
* and is never returned unresolved, because Windows would then also search
* the current directory.
*/
export const resolveWindowsProviderExecutable = (
executable: string,
environment: Readonly<NodeJS.ProcessEnv>,
lookup: WindowsExecutableLookup = {},
): string => {
): Result<
string,
{ readonly kind: "not_found" } | WindowsPathSearchFailure
> => {
const cwd = lookup.cwd ?? process.cwd();
const absolute = (...paths: string[]): string => win32.resolve(cwd, ...paths);
if (
win32.isAbsolute(executable) ||
executable.includes("/") ||
executable.includes("\\") ||
win32.parse(executable).root !== ""
)
return absolute(executable);
return ok(win32.resolve(cwd, executable));
const pathValue = environment.PATH ?? environment.Path ?? environment.path;
if (pathValue === undefined) return executable;
const pathEntries = windowsPathEntries(pathValue);
const explicitExtension = win32.extname(executable).toLowerCase();
if (explicitExtension !== "" && ![".com", ".exe"].includes(explicitExtension))
return executable;
const extensions =
explicitExtension !== ""
? [""]
: (environment.PATHEXT ?? environment.PathExt ?? ".COM;.EXE")
.split(";")
.filter((extension) =>
[".com", ".exe"].includes(extension.toLowerCase()),
);
for (const entry of pathEntries) {
if (entry.length === 0) continue;
for (const extension of extensions) {
const candidate = absolute(entry, `${executable}${extension}`);
if ((lookup.isFile ?? isRegularFile)(candidate)) return candidate;
}
}
return executable;
const candidates = windowsPathCandidates(executable, environment, { cwd });
if (!candidates.ok) return candidates;
for (const { path } of candidates.value)
if ((lookup.isFile ?? isRegularFile)(path)) return ok(path);
return err({ kind: "not_found" });
};