@namzu/sdk 51.0.0 → 52.0.0

package/src/authorization/readonly-flags.ts

@@ -0,0 +1,196 @@
+/**
+ * Per-flag allowlists for the shell commands that may run without a prompt.
+ *
+ * Read from the reference terminal (version 2.1.302): for each command, the
+ * flags it vets and what each takes, `none` (a switch), `string` or `number`.
+ * A flag not listed here is not read-only, which is how `git diff --output=f`
+ * (writes a file), `git -c`, `--exec-path` and `--config-env` stay out: they
+ * are not in any table. Space-separated lists per kind keep the file readable;
+ * `readonly-commands.ts` holds the callbacks that need more than a flag name.
+ */
+
+export type FlagKind = 'none' | 'string' | 'number'
+
+export interface FlagTable {
+	readonly flags: Readonly<Record<string, FlagKind>>
+	/** False when `--` does not end the options for this command. */
+	readonly doubleDash: boolean
+}
+
+function table(spec: {
+	none?: string
+	string?: string
+	number?: string
+	doubleDash?: false
+}): FlagTable {
+	const flags: Record<string, FlagKind> = {}
+	for (const kind of ['none', 'string', 'number'] as const) {
+		for (const flag of (spec[kind] ?? '').split(' ')) if (flag !== '') flags[flag] = kind
+	}
+	return { flags, doubleDash: spec.doubleDash !== false }
+}
+
+/** Keyed by the command words that select the table (`git diff`, `rg`). */
+export const FLAG_TABLES: Readonly<Record<string, FlagTable>> = {
+	'git diff': table({
+		none: '--stat --numstat --shortstat --name-only --name-status --color --no-color --dirstat --summary --patch-with-stat --word-diff --color-words --no-renames --no-ext-diff --check --full-index --binary --break-rewrites --find-renames --find-copies --find-copies-harder --irreversible-delete --histogram --patience --minimal --ignore-space-at-eol --ignore-space-change --ignore-all-space --ignore-blank-lines --function-context --exit-code --quiet --cached --staged --pickaxe-regex --pickaxe-all --no-index -p -u -s -M -C -B -D -l -R',
+		string:
+			'--word-diff-regex --ws-error-highlight --diff-algorithm --relative --diff-filter -S -G -O',
+		number: '--abbrev --inter-hunk-context',
+	}),
+	'git log': table({
+		none: '--oneline --graph --decorate --no-decorate --relative-date --all --branches --tags --remotes --stat --numstat --shortstat --name-only --name-status --color --no-color --patch -p --no-patch --no-ext-diff -s --abbrev-commit --full-history --dense --sparse --simplify-merges --ancestry-path --source --first-parent --merges --no-merges --reverse --walk-reflogs --no-min-parents --no-max-parents --follow --no-walk --left-right --cherry-mark --cherry-pick --boundary --topo-order --date-order --author-date-order --pickaxe-regex --pickaxe-all',
+		string:
+			'--date --since --after --until --before --author --committer --grep --pretty --format --diff-filter -S -G',
+		number: '--max-count -n --skip --max-age --min-age',
+	}),
+	'git show': table({
+		none: '--oneline --graph --decorate --no-decorate --relative-date --stat --numstat --shortstat --name-only --name-status --color --no-color --patch -p --no-patch --no-ext-diff -s --abbrev-commit --word-diff --color-words --first-parent --raw -m --quiet',
+		string: '--date --word-diff-regex --pretty --format --diff-filter',
+	}),
+	'git shortlog': table({
+		none: '--all --branches --tags --remotes -s --summary -n --numbered -e --email -c --committer --no-merges',
+		string: '--since --after --until --before --group --format --author',
+	}),
+	'git reflog': table({
+		none: '--oneline --graph --decorate --no-decorate --relative-date --all --branches --tags --remotes',
+		string: '--date --since --after --until --before --author --committer --grep',
+		number: '--max-count -n',
+	}),
+	'git stash list': table({
+		none: '--oneline --graph --decorate --no-decorate --relative-date --all --branches --tags --remotes',
+		string: '--date',
+		number: '--max-count -n',
+		doubleDash: false,
+	}),
+	'git ls-remote': table({
+		none: '--branches -b --tags -t --heads -h --refs --quiet -q --exit-code --get-url --symref',
+		string: '--sort',
+	}),
+	'git status': table({
+		none: '--short -s --branch -b --porcelain --long --verbose -v --ignored --column --no-column --ahead-behind --no-ahead-behind --renames --no-renames',
+		string: '--untracked-files -u --ignore-submodules --find-renames -M',
+	}),
+	'git blame': table({
+		none: '--color --no-color --porcelain -p --line-porcelain --incremental --root --show-stats --show-name --show-number -n --show-email -e -f -w -M -C --score-debug -s -l -t',
+		string: '-L --date --ignore-rev --ignore-revs-file',
+		number: '--abbrev',
+		doubleDash: false,
+	}),
+	'git ls-files': table({
+		none: '--cached -c --deleted -d --modified -m --others -o --ignored -i --stage -s --killed -k --unmerged -u --directory --no-empty-directory --eol --full-name --debug -z -t -v -f --exclude-standard --error-unmatch --recurse-submodules',
+		string: '--exclude -x --exclude-from -X --exclude-per-directory',
+		number: '--abbrev',
+	}),
+	'git config --get': table({
+		none: '--local --global --system --worktree --bool --int --bool-or-int --path --expiry-date -z --null --name-only --show-origin --show-scope',
+		string: '--default --type',
+	}),
+	'git remote show': table({
+		none: '-n',
+	}),
+	'git remote': table({
+		none: '-v --verbose',
+	}),
+	'git merge-base': table({
+		none: '--is-ancestor --fork-point --octopus --independent --all',
+	}),
+	'git rev-parse': table({
+		none: '--verify --abbrev-ref --symbolic --symbolic-full-name --show-toplevel --show-cdup --show-prefix --git-dir --git-common-dir --absolute-git-dir --show-superproject-working-tree --is-inside-work-tree --is-inside-git-dir --is-bare-repository --is-shallow-repository --is-shallow-update --path-prefix',
+		string: '--short',
+	}),
+	'git rev-list': table({
+		none: '--all --branches --tags --remotes --count --reverse --first-parent --ancestry-path --merges --no-merges --no-min-parents --no-max-parents --walk-reflogs --oneline --abbrev-commit --full-history --dense --sparse --source --graph',
+		string: '--since --after --until --before --author --committer --grep --pretty --format',
+		number: '--max-count -n --min-parents --max-parents --skip --max-age --min-age --abbrev',
+	}),
+	'git describe': table({
+		none: '--tags --long --always --contains --first-match --exact-match --dirty --broken',
+		string: '--match --exclude',
+		number: '--abbrev --candidates',
+	}),
+	'git cat-file': table({
+		none: '-t -s -p -e --batch-check --allow-undetermined-type',
+	}),
+	'git for-each-ref': table({
+		string: '--format --sort --contains --no-contains --merged --no-merged --points-at',
+		number: '--count',
+	}),
+	'git grep': table({
+		none: '-E --extended-regexp -G --basic-regexp -F --fixed-strings -P --perl-regexp -i --ignore-case -v --invert-match -w --word-regexp -n --line-number -c --count -l --files-with-matches -L --files-without-match -h -H --heading --break --full-name --color --no-color -o --only-matching --and --or --not --untracked --no-index --recurse-submodules --cached -q --quiet',
+		string: '-e',
+		number: '-A --after-context -B --before-context -C --context --max-depth --threads',
+	}),
+	'git stash show': table({
+		none: '--stat --numstat --shortstat --name-only --name-status --color --no-color --patch -p --no-patch --no-ext-diff -s --word-diff',
+		string: '--word-diff-regex --diff-filter',
+		number: '--abbrev',
+	}),
+	'git worktree list': table({
+		none: '--porcelain -v --verbose',
+		string: '--expire',
+	}),
+	'git tag': table({
+		none: '-l --list --column --no-column -i --ignore-case',
+		string: '--contains --no-contains --merged --no-merged --sort --format --points-at',
+		number: '-n',
+	}),
+	'git branch': table({
+		none: '-l --list -a --all -r --remotes -v -vv --verbose --color --no-color --column --no-column --no-abbrev --merged --no-merged --show-current -i --ignore-case',
+		string: '--contains --no-contains --points-at --sort',
+		number: '--abbrev',
+	}),
+	file: table({
+		none: '--brief -b --mime -i --mime-type --mime-encoding --apple --check-encoding -c --print0 -0 --help --version -v --no-dereference -h --dereference -L --keep-going -k --list -l --no-buffer -n --preserve-date -p --raw -r -s --special-files',
+		string: '--exclude --exclude-quiet -F --separator',
+	}),
+	sort: table({
+		none: '--ignore-leading-blanks -b --dictionary-order -d --ignore-case -f --general-numeric-sort -g --human-numeric-sort -h --ignore-nonprinting -i --month-sort -M --numeric-sort -n --random-sort -R --reverse -r --stable -s --unique -u --version-sort -V --zero-terminated -z --check -c --check-char-order -C --merge -m --help --version',
+		string: '--sort --key -k --field-separator -t --buffer-size -S',
+		number: '--parallel --batch-size',
+	}),
+	base64: table({
+		none: '-d -D --decode --ignore-garbage -h --help --version',
+		string: '-i --input',
+		number: '-b --break -w --wrap',
+		doubleDash: false,
+	}),
+	grep: table({
+		none: '-F --fixed-strings -G --basic-regexp -E --extended-regexp -P --perl-regexp -i --ignore-case --no-ignore-case -v --invert-match -w --word-regexp -x --line-regexp -c --count -L --files-without-match -l --files-with-matches -o --only-matching -q --quiet --silent -s --no-messages -b --byte-offset -H --with-filename -h --no-filename -n --line-number -T --initial-tab -u --unix-byte-offsets -Z --null -z --null-data --no-group-separator -a --text -I -r --recursive -R --dereference-recursive --line-buffered -U --binary --help -V --version',
+		string:
+			'-e --regexp -f --file --color --colour --label --group-separator --binary-files -D --devices -d --directories --exclude --exclude-from --exclude-dir --include',
+		number: '-m --max-count -A --after-context -B --before-context -C --context',
+	}),
+	egrep: table({
+		none: '-F --fixed-strings -G --basic-regexp -E --extended-regexp -P --perl-regexp -i --ignore-case --no-ignore-case -v --invert-match -w --word-regexp -x --line-regexp -c --count -L --files-without-match -l --files-with-matches -o --only-matching -q --quiet --silent -s --no-messages -b --byte-offset -H --with-filename -h --no-filename -n --line-number -T --initial-tab -u --unix-byte-offsets -Z --null -z --null-data --no-group-separator -a --text -I -r --recursive -R --dereference-recursive --line-buffered -U --binary --help -V --version',
+		string:
+			'-e --regexp -f --file --color --colour --label --group-separator --binary-files -D --devices -d --directories --exclude --exclude-from --exclude-dir --include',
+		number: '-m --max-count -A --after-context -B --before-context -C --context',
+	}),
+	fgrep: table({
+		none: '-F --fixed-strings -G --basic-regexp -E --extended-regexp -P --perl-regexp -i --ignore-case --no-ignore-case -v --invert-match -w --word-regexp -x --line-regexp -c --count -L --files-without-match -l --files-with-matches -o --only-matching -q --quiet --silent -s --no-messages -b --byte-offset -H --with-filename -h --no-filename -n --line-number -T --initial-tab -u --unix-byte-offsets -Z --null -z --null-data --no-group-separator -a --text -I -r --recursive -R --dereference-recursive --line-buffered -U --binary --help -V --version',
+		string:
+			'-e --regexp -f --file --color --colour --label --group-separator --binary-files -D --devices -d --directories --exclude --exclude-from --exclude-dir --include',
+		number: '-m --max-count -A --after-context -B --before-context -C --context',
+	}),
+	rg: table({
+		none: '-i --ignore-case -S --smart-case -F --fixed-strings -w --word-regexp -v --invert-match -c --count -l --files-with-matches --files-without-match -n --line-number -o --only-matching -H -h --heading --no-heading -q --quiet --column --type-list --hidden --no-ignore -u -a --text -L --follow --json --stats --help --version --debug --',
+		string: '-e --regexp -f -g --glob -t --type -T --type-not --color',
+		number: '-A --after-context -B --before-context -C --context -m --max-count -d --max-depth',
+	}),
+	sha256sum: table({
+		none: '-b --binary -t --text -c --check --ignore-missing --quiet --status --strict -w --warn --tag -z --zero --help --version',
+	}),
+	sha1sum: table({
+		none: '-b --binary -t --text -c --check --ignore-missing --quiet --status --strict -w --warn --tag -z --zero --help --version',
+	}),
+	md5sum: table({
+		none: '-b --binary -t --text -c --check --ignore-missing --quiet --status --strict -w --warn --tag -z --zero --help --version',
+	}),
+	tree: table({
+		none: '-a -d -l -f -x --gitignore --ignore-case --matchdirs --metafirst --prune --info --noreport -q -N -Q -p -u -g -s -h --si --du -D -F --inodes --device -v -t -c -U -r --dirsfirst --filesfirst -i -A -S -n -C -X -J --nolinks --hyperlink --fromfile --fromtabfile --fflinks --help --version',
+		string:
+			'-P -I --gitfile --infofile --charset --timefmt --sort -H --hintro --houtro -T --scheme --authority',
+		number: '-L --filelimit',
+	}),
+}

package/src/authorization/removal.ts

@@ -0,0 +1,326 @@
+/**
+ * Whether a command line removes something it must not, decided from its
+ * targets.
+ *
+ * The old floor was one regular expression, `rm\s+-rf\s+\/`. It matched a
+ * single spelling: `rm -fr /`, `rm -r -f /`, `rm --recursive --force /`,
+ * `rm -rf ~`, `rm -rf $HOME`, `rm -rf "$BUILD/"` (empty variable, so `/`) and
+ * `rm -rf ..` all went past it. The flags were never the point. A removal is
+ * catastrophic because of WHAT it removes, so this reads the targets of `rm`
+ * and `rmdir` whatever the flags, as the reference terminal's dangerous-removal
+ * check does (version 2.1.302).
+ *
+ * A removal is flagged when a target is
+ *
+ * - the file system root, a top-level directory (`/usr`, `/etc`), or the
+ *   operator's home directory (`~`, `$HOME`, `${HOME}`);
+ * - the working directory or any directory above it (`.`, `..`, `../..`), or
+ *   the same for an added directory when the target is a glob;
+ * - a bare glob that crosses directories (`*`, `/*`, `*\/*`);
+ * - a variable followed by a slash (`$DIR/`, `"$DIR/"/*`): when the variable
+ *   is empty the path is `/`; or a variable followed by a top-level directory
+ *   name (`$PREFIX/usr`) when the variable may be unset;
+ * - the output of a command substitution, for a recursive removal;
+ * - a path that cannot be settled before the line runs (a relative glob after
+ *   a `cd`, `a/../*`, `~user`).
+ *
+ * The answer is a reason, which the kernel turns into an escalation: asked
+ * every time, in every mode, and refused when nobody can be asked. It is not a
+ * denial: the reference asks, because there are legitimate removals a person
+ * can approve.
+ */
+
+import { existsSync, realpathSync } from 'node:fs'
+import { homedir } from 'node:os'
+import {
+	dirname,
+	isAbsolute,
+	join,
+	normalize,
+	basename as pathBasename,
+	resolve,
+	sep,
+} from 'node:path'
+
+import type { ShellWord } from './shell-lexer.js'
+import { type ShellInvocation, type ShellReading, expandsAtRuntime } from './shell-paths.js'
+
+/** What the check needs to know about the turn. */
+export interface RemovalContext {
+	/** The turn's working directory. */
+	readonly cwd: string
+	/** Directories added to the session. */
+	readonly additionalDirectories?: readonly string[]
+	/** The operator's home directory; the host's own when omitted. */
+	readonly home?: string
+	/** Environment to decide whether a variable may be empty; `process.env` when omitted. */
+	readonly env?: Readonly<Record<string, string | undefined>>
+}
+
+/** Top-level directories a variable-prefixed target may become when the variable is empty. */
+const TOP_LEVEL =
+	'bin|boot|dev|etc|home|lib|lib32|lib64|libx32|media|mnt|opt|proc|root|run|sbin|srv|sys|tmp|usr|var|snap|nix|lost\\+found|private|cores|Applications|Library|System|Users|Volumes|Windows|ProgramData|cygdrive'
+
+const VAR = '(?:\\{([A-Za-z_][A-Za-z0-9_]*)(?::?-[^}]*)?\\}|([A-Za-z_][A-Za-z0-9_]*))'
+/** `$VAR/` followed by something that cannot name a child: end, a glob, another expansion, a slash. */
+const EMPTY_VARIABLE_ROOT = new RegExp(`^\\$${VAR}/(?:[*?[{]|\\$|/|$)`)
+const EMPTY_VARIABLE_TOP = new RegExp(`^\\$${VAR}/(${TOP_LEVEL})(?:/+\\*+)*/?$`, 'i')
+const BARE_HOME = /^\$(?:\{HOME\}|HOME)(?:\/+\*?)?$/
+
+function fold(name: string): string {
+	return name.toLowerCase().replace(/ı/g, 'i').replace(/ſ/g, 's')
+}
+
+/** `realpath` of the deepest existing ancestor, with the rest appended. */
+function canonical(path: string): string {
+	let existing = path
+	let rest = ''
+	for (;;) {
+		if (existsSync(existing)) {
+			try {
+				const real = realpathSync(existing)
+				return rest === '' ? real : join(real, rest)
+			} catch {
+				return path
+			}
+		}
+		const parent = dirname(existing)
+		if (parent === existing) return path
+		rest = rest === '' ? pathBasename(existing) : join(pathBasename(existing), rest)
+		existing = parent
+	}
+}
+
+function slashes(path: string): string {
+	return path.replace(/[\\/]+/g, '/')
+}
+
+function isWithinOrEqual(parent: string, child: string): boolean {
+	const p = fold(slashes(parent)).replace(/\/$/, '')
+	const c = fold(slashes(child)).replace(/\/$/, '')
+	return c === p || c.startsWith(`${p}/`) || p === ''
+}
+
+/** The file system root, a top-level directory, a drive root, a bare glob, or the home directory. */
+function isCritical(path: string, homes: readonly string[]): boolean {
+	const normalized = slashes(path)
+	if (normalized === '*' || normalized.endsWith('/*')) return true
+	const trimmed = normalized === '/' ? '/' : normalized.replace(/\/$/, '')
+	if (trimmed === '/') return true
+	if (/^[A-Za-z]:\/?$/.test(trimmed)) return true
+	if (homes.some((home) => fold(trimmed) === fold(slashes(home).replace(/\/$/, '')))) return true
+	if (dirname(trimmed) === '/') return true
+	return /^[A-Za-z]:\/[^/]+$/.test(trimmed)
+}
+
+function isRecursive(args: readonly ShellWord[]): boolean {
+	const flags: string[] = []
+	for (const arg of args) {
+		if (arg.value === '--') break
+		flags.push(arg.value)
+	}
+	return flags.some((flag) => /^--r/.test(flag) || /^-[a-zA-Z]*[rR]/.test(flag))
+}
+
+/** Operands of `rm`/`rmdir`: everything after `--` and everything from the first non-flag on. */
+function targetsOf(args: readonly ShellWord[]): ShellWord[] {
+	const out: ShellWord[] = []
+	let afterDashes = false
+	let started = false
+	for (const arg of args) {
+		if (afterDashes || started) out.push(arg)
+		else if (arg.value === '--') afterDashes = true
+		else if (arg.value === '-' || !arg.value.startsWith('-')) {
+			out.push(arg)
+			started = true
+		}
+	}
+	return out
+}
+
+/** `~` and `~/…` against `home`. */
+function expandTilde(value: string, home: string): string {
+	if (value === '~') return home
+	if (value.startsWith('~/')) return join(home, value.slice(2))
+	return value
+}
+
+/**
+ * Why the line removes something it must not, or `undefined`.
+ *
+ * `reading` is {@link readShellLine}'s result for the same line;
+ * `changesDirectory` says a `cd` runs in it, after which a relative target is
+ * not the one the working directory names.
+ */
+export function dangerousRemoval(
+	reading: ShellReading,
+	changesDirectory: boolean,
+	context: RemovalContext,
+): string | undefined {
+	const removals = reading.invocations.filter((i) => i.program === 'rm' || i.program === 'rmdir')
+	if (removals.length === 0) return undefined
+	const home = context.home ?? homedir()
+	const env = context.env ?? process.env
+	const cwd = resolve(context.cwd)
+	const homes = [home, canonical(home)]
+	const workdirs = [cwd, canonical(cwd)]
+	const everyDirectory = [
+		...new Set([
+			...workdirs,
+			...(context.additionalDirectories ?? []).flatMap((d) => [resolve(d), canonical(resolve(d))]),
+		]),
+	]
+	for (const removal of removals) {
+		const reason = checkRemoval(removal, {
+			cwd,
+			home,
+			homes,
+			workdirs,
+			everyDirectory,
+			env,
+			changesDirectory,
+		})
+		if (reason !== undefined) return reason
+	}
+	return undefined
+}
+
+interface Scope {
+	readonly cwd: string
+	readonly home: string
+	readonly homes: readonly string[]
+	readonly workdirs: readonly string[]
+	readonly everyDirectory: readonly string[]
+	readonly env: Readonly<Record<string, string | undefined>>
+	readonly changesDirectory: boolean
+}
+
+function checkRemoval(removal: ShellInvocation, scope: Scope): string | undefined {
+	const { program, args } = removal
+	const recursive = isRecursive(args)
+	for (const target of targetsOf(args)) {
+		const spelled = target.value
+		if (spelled === '') continue
+
+		// A backslash alone is the drive root in Git Bash on Windows.
+		if (/^\\+$/.test(spelled)) return `${program} ${spelled}: a backslash alone is the drive root`
+
+		if (BARE_HOME.test(spelled)) return `${program} ${spelled}: that is the home directory`
+
+		const root = EMPTY_VARIABLE_ROOT.exec(spelled)
+		if (root !== null) {
+			const name = root[1] ?? root[2]
+			return `${program} ${spelled}: when $${name} is empty this removes /`
+		}
+		const top = EMPTY_VARIABLE_TOP.exec(spelled)
+		if (top !== null) {
+			const name = top[1] ?? top[2] ?? ''
+			const value = scope.env[name]
+			if (typeof value !== 'string' || value === '') {
+				return `${program} ${spelled}: when $${name} is empty this removes /${top[3]}`
+			}
+		}
+
+		if (target.substitutes && recursive && /^(?:\$\(.*\)|`.*`)[/*.]*$/s.test(spelled)) {
+			return `${program} ${spelled}: the target is the output of a command substitution, which cannot be checked before it runs`
+		}
+		// A substitution that comes out empty leaves what is before it.
+		const stripped = target.substitutes
+			? spelled.replace(/(.)(?:\$\([^)]*\)|`[^`]*`)(?:(?!\.\.)[/*.])*((?:\/\.\.)*)\/*$/s, '$1$2')
+			: spelled
+		const reason = checkTarget(program, args, stripped, target, scope)
+		if (reason !== undefined) return reason
+	}
+	return undefined
+}
+
+function checkTarget(
+	program: string,
+	args: readonly ShellWord[],
+	spelled: string,
+	word: ShellWord,
+	scope: Scope,
+): string | undefined {
+	const expanded = expandTilde(spelled, scope.home)
+	const relative = !isAbsolute(expanded)
+	if (expandsAtRuntime(word) && /[$`]/.test(expanded)) {
+		// A variable the check cannot read: the reference treats it as a relative
+		// name, which is also what the shell does when the variable is unset and
+		// the rest is a plain name. Nothing more to learn from it.
+		return undefined
+	}
+	const absolute = relative ? resolve(scope.cwd, expanded) : resolve(expanded)
+	let settled = absolute
+	for (let previous = ''; previous !== settled; ) {
+		previous = settled
+		const stripped = settled.replace(/([\\/]\*+)+[\\/]*$/, '') || sep
+		if (stripped !== settled) settled = /[\\/]/.test(stripped) ? normalize(stripped) : stripped
+	}
+	// A glob suffix was stripped from the target: the removal reaches what is in it.
+	const globbed = settled !== absolute
+	const original = expanded
+
+	if (scope.changesDirectory && globbed && relative && /[\\/]\*$/.test(absolute)) {
+		return `${program} ${spelled}: a relative glob after a cd cannot be resolved before the line runs`
+	}
+
+	// Where the target sits under the working directory, for the glob depth below.
+	let below = settled
+	if (relative) {
+		const prefix = scope.cwd.endsWith(sep) ? scope.cwd : scope.cwd + sep
+		if (settled.startsWith(prefix)) below = settled.slice(prefix.length)
+		else if (settled === scope.cwd) below = ''
+	}
+
+	if (
+		globbed &&
+		(hasParentAfterName(original) ||
+			original.startsWith('~') ||
+			/^[\\/]{2}/.test(original) ||
+			(relative && /(^|[\\/])\.\.([\\/]|$)/.test(original) && /[\\/]\*$/.test(absolute)) ||
+			(program === 'rmdir' &&
+				/[\\/]\*$/.test(absolute) &&
+				args.some((a) => /^--p/.test(a.value) || /^-[a-z]*p/.test(a.value))) ||
+			(relative && /\*[\\/]+$/.test(original) && /[\\/]\*$/.test(absolute)))
+	) {
+		return `${program} ${spelled}: the target cannot be resolved to a directory before the line runs`
+	}
+
+	if (!globbed || !/[*?[]/.test(below)) {
+		const candidates = [settled]
+		const real = canonical(settled)
+		if (real !== settled) candidates.push(real)
+		for (const candidate of candidates) {
+			if (isCritical(candidate, scope.homes)) {
+				return `${program} ${spelled}: that is the file system root, a top-level directory or the home directory`
+			}
+			const directories = globbed ? scope.everyDirectory : scope.workdirs
+			if (directories.some((directory) => isWithinOrEqual(candidate, directory))) {
+				return `${program} ${spelled}: that is the working directory or one of its parents`
+			}
+		}
+	}
+
+	if (globbed && /[\\/]\*$/.test(absolute)) {
+		const segments = (value: string): number =>
+			value.split(/[\\/]+/).filter((s) => s !== '' && s !== '.').length
+		const crossed = segments(absolute) - segments(settled)
+		const inside = below.split(/[\\/]+/).filter((s) => /[*?[]/.test(s)).length
+		if (crossed + inside > 1) {
+			return `${program} ${spelled}: the glob crosses directories that cannot be listed before the line runs`
+		}
+	}
+	return undefined
+}
+
+/** `a/../b`: a parent step after a real name, which moves the target somewhere the spelling hides. */
+function hasParentAfterName(path: string): boolean {
+	let named = false
+	for (const segment of path.split(/[\\/]+/)) {
+		if (segment === '' || segment === '.') continue
+		if (segment === '..') {
+			if (named) return true
+		} else named = true
+	}
+	return false
+}