sh-ast 0.0.0 → 0.2.0

package/dist/analyze/resolve-argv0.js

@@ -0,0 +1,510 @@
+import { ShAnalyzeInvalidWrapperSpecError } from '../errors.js';
+import { deepFreeze } from '../deep-freeze.js';
+import { nodeArray } from './node-helpers.js';
+/**
+ * `sh-ast/analyze`'s default {@link WrapperSpec} table — every entry's
+ * flag/operand handling is hand-derived from that wrapper's own manual
+ * page (or, for shell builtins, the Bash Reference Manual/POSIX Shell &
+ * Utilities volume), cited per entry below, and cross-checked empirically
+ * against the real utility where one was locally available (GNU coreutils
+ * `env`/`nice` directly; `sudo` via `sudo -h`'s usage/option summary only
+ * — never executed, per this package's "facts only" posture and basic
+ * safety hygiene). This table is *data*, not policy: it names no
+ * "dangerous" commands, makes no safety judgment, and a caller can freely
+ * replace or extend it via {@link ResolveArgv0Options.transparentWrappers}
+ * (see {@link resolveArgv0}'s criterion-4-style configurability guarantee).
+ *
+ * Frozen (including each entry object and its own array/regexp fields) so
+ * immutability of this shared, module-scoped table is a contract, not just
+ * a convention any importer happens to honor — mirrors `visitorKeys`'s and
+ * `CHILD_TYPE_SCHEMA`'s freezing in `visitor-keys.ts`/`normalize.ts`.
+ *
+ * `xargs` is deliberately **excluded**: unlike every entry here, `xargs`
+ * doesn't simply re-exec a single wrapped command word it can point to
+ * statically — it invokes `command [initial-arguments]` once per *batch*
+ * of additional arguments assembled from its own stdin at run time
+ * (batched per `-n`/`-L`/line-splitting rules, GNU xargs(1)). Treating it
+ * as transparent would misrepresent what's actually invoked: the "wrapped
+ * command" is only ever a syntactic *prefix* of the real, stdin-dependent
+ * argv, and that prefix can itself be entirely absent (bare `xargs` reruns
+ * each stdin-derived line as its own command). No `WrapperSpec` shape here
+ * can honestly express that, so `xargs` is left for a caller to model
+ * explicitly if their use case calls for it, rather than shipped as a
+ * silently-wrong default.
+ *
+ * @see https://www.gnu.org/software/bash/manual/bash.html#Bourne-Shell-Builtins — `command`, `exec` (Bash Reference Manual §4.1)
+ * @see https://pubs.opengroup.org/onlinepubs/9699919799/utilities/command.html — POSIX `command`
+ * @see https://www.gnu.org/software/coreutils/manual/html_node/env-invocation.html — GNU coreutils `env`
+ * @see https://pubs.opengroup.org/onlinepubs/9699919799/utilities/env.html — POSIX `env`
+ * @see https://pubs.opengroup.org/onlinepubs/9699919799/utilities/nohup.html — POSIX `nohup`
+ * @see https://www.gnu.org/software/coreutils/manual/html_node/nice-invocation.html — GNU coreutils `nice`
+ * @see https://pubs.opengroup.org/onlinepubs/9699919799/utilities/nice.html — POSIX `nice`
+ * @see https://pubs.opengroup.org/onlinepubs/9699919799/utilities/time.html — POSIX `time` utility (distinct from the bash `time` *reserved word*, which mvdan/sh models as a transparent `TimeClause` — see {@link WrapperSpec}'s `time` entry below)
+ * @see https://www.gnu.org/software/coreutils/manual/html_node/timeout-invocation.html — GNU coreutils `timeout`
+ * @see https://www.sudo.ws/docs/man/sudo.man/ — `sudo(8)`
+ * @see https://www.gnu.org/software/findutils/manual/html_node/find_html/xargs-options.html — GNU `xargs` (why it's excluded, above)
+ * @public
+ */
+export const DEFAULT_TRANSPARENT_WRAPPERS = deepFreeze([
+    // `command [-pVv] command_name [argument ...]` — Bash Reference Manual
+    // §4.1 / POSIX `command`. `-p` takes no operand and doesn't change what
+    // runs. `-v`/`-V`, however, make `command` itself *print* information
+    // about `command_name` (its path, or a human-readable description)
+    // rather than execute it at all — so `command -v rm x` never runs `rm`;
+    // the effective command is `command` itself, regardless of what follows
+    // (`stopsChainFlags`, not `noArgFlags` — see `WrapperSpec.stopsChainFlags`'s
+    // doc comment).
+    { names: ['command'], noArgFlags: ['-p'], stopsChainFlags: ['-v', '-V'] },
+    // `exec [-cl] [-a name] [command [arguments]]` — Bash Reference Manual
+    // §4.1. `-c`/`-l` take no operand; `-a name` supplies argv0 for the
+    // wrapped command and takes `name` as its operand.
+    { names: ['exec'], noArgFlags: ['-c', '-l'], argFlags: ['-a'] },
+    // `env [-i0v] [-u name] [-C dir] [name=value]... [utility
+    // [argument...]]` — POSIX `env` (`-i`) plus GNU coreutils env(1)'s
+    // commonly documented long/short forms. `VAR=val` operands preceding the
+    // utility are `env`'s own environment-setting mechanism (distinct from
+    // `CallExpr.assigns`). `-S`/`--split-string` is deliberately *not* an
+    // `argFlags` entry — see `unresolvableFlags` below.
+    {
+        names: ['env'],
+        skipAssignmentOperands: true,
+        noArgFlags: ['-i', '--ignore-environment', '-0', '--null', '-v', '--debug'],
+        argFlags: ['-u', '--unset', '-C', '--chdir'],
+        // GNU env(1) `-S`/`--split-string=S`: processes and splits `S` into
+        // separate arguments, splicing them into the invoked command's argv
+        // (documented use: shebang lines with multiple arguments) — verified
+        // empirically: `env -S 'echo hello world'` runs `echo` with args
+        // `hello`, `world`, not a command literally named by the operand text.
+        // The real wrapped command therefore lives *inside* `S`'s own text,
+        // not at a fixed "next word" position this table can name — reporting
+        // *any* word here as effective (the flag, `S`'s value, or whatever
+        // word happens to follow) would be a guess, not a fact. `resolveArgv0`
+        // stops here with `reason: 'embedded-command'` instead.
+        unresolvableFlags: ['-S', '--split-string'],
+    },
+    // `nohup utility [argument...]` — POSIX `nohup`. No documented options
+    // besides the utility itself; the word right after `nohup` is always
+    // the wrapped command.
+    { names: ['nohup'] },
+    // `nice [-n adjustment] utility [argument...]` (GNU coreutils nice(1))
+    // or the POSIX legacy attached form `nice -increment utility` (POSIX
+    // `nice`, e.g. `nice -19 cmd`). `noArgFlagPattern` recognizes the
+    // attached numeric form; `-n`/`--adjustment` take the adjustment as a
+    // separate operand word, or attached (`-n10`, verified empirically
+    // against GNU coreutils nice(1) — `nice -n10 cmd` runs `cmd`).
+    {
+        names: ['nice'],
+        argFlags: ['-n', '--adjustment'],
+        noArgFlagPattern: /^-\d+$/,
+    },
+    // `time [-p] utility [argument...]` — the *standalone* `time(1)` utility
+    // (POSIX), not bash's `time` reserved word: mvdan/sh always parses a
+    // statement-initial, unquoted `time` as a `TimeClause` node (see
+    // `enumerate-commands.ts`'s doc comment — `enumerateCommands` treats it
+    // as transparent and never emits a `CallExpr`/`CommandSite` for it), so
+    // this entry only ever matches an argv0 word reading literally `time`
+    // that reached `CallExpr.args` some other way (quoted — `"time" cmd`
+    // suppresses reserved-word recognition — or as another wrapper's
+    // operand, e.g. `env time cmd`). `-p` (POSIX) and GNU time(1)'s
+    // `--verbose`/`--portability` take no operand; `-o file`/`-f format`
+    // (GNU) take one.
+    {
+        names: ['time'],
+        noArgFlags: ['-p', '--verbose', '--portability'],
+        argFlags: ['-o', '--output', '-f', '--format'],
+    },
+    // `timeout [OPTION] DURATION COMMAND [ARG]...` — GNU coreutils
+    // timeout(1). `--preserve-status`/`--foreground`/`-v` take no operand;
+    // `-k`/`-s` take one; `DURATION` is a single mandatory positional
+    // operand before the wrapped command, regardless of how many flags
+    // precede it.
+    {
+        names: ['timeout'],
+        noArgFlags: ['--preserve-status', '--foreground', '-v', '--verbose'],
+        argFlags: ['-k', '--kill-after', '-s', '--signal'],
+        positionalOperandsBeforeCommand: 1,
+    },
+    // sudo(8). Only option forms that are documented (verified against real
+    // `sudo -h` usage/option output) to still be followed by a command are
+    // modeled: `-A`/`-b`/`-E`/`-H`/`-k`/`-n`/`-P`/`-S` take no operand;
+    // `-g group`/`-p prompt`/`-u user` take one, in any getopt-standard
+    // attached/clustered form (e.g. `-ualice`, `-Eu alice`). Deliberately
+    // excludes `-e`/`-i`/`-l`/`-s`/`-v`/`-K` — sudo(8) documents these as
+    // changing sudo's *mode* (edit, login shell, list, shell, validate,
+    // reset) such that no ordinary "wrapped command" word necessarily
+    // follows at all; modeling them as transparent would risk guessing a
+    // command that isn't really there. Also deliberately excludes
+    // `-D`/`--chdir`, `-C`/`--close-from`, `-R`/`--chroot`,
+    // `-T`/`--command-timeout`, `-h`/`--host`, `-U`/`--other-user`,
+    // `--preserve-env[=list]`, and every other option `sudo -h` documents
+    // that this table doesn't name above — an unrecognized flag-shaped word
+    // now correctly makes the whole resolution unresolvable (see
+    // `resolveArgv0`'s doc comment) rather than being silently misidentified
+    // as the wrapped command, so leaving these unmodeled is safe, not a gap.
+    // `VAR=value` operands before the command are sudo's own
+    // environment-setting mechanism, "similar to env" per sudo(8).
+    {
+        names: ['sudo'],
+        skipAssignmentOperands: true,
+        noArgFlags: ['-A', '-b', '-E', '-H', '-k', '-n', '-P', '-S'],
+        argFlags: ['-g', '-p', '-u'],
+    },
+]);
+/** `true` iff `text` is shaped like a shell assignment operand (`NAME=...`). */
+function isAssignmentShapedText(text) {
+    return /^[A-Za-z_][A-Za-z0-9_]*=/.test(text);
+}
+/** `true` iff `text` is a `--long-flag=value` attached form of one of `flags`. */
+function matchesAttachedLongFlag(text, flags) {
+    return flags.some((flag) => flag.startsWith('--') && text.startsWith(`${flag}=`));
+}
+/**
+ * `true` iff `text` is shaped like a command-line flag: starts with `-`
+ * but isn't exactly `--` (the end-of-options marker, handled separately)
+ * or a bare `-` (POSIX reserves a lone `-` as an ordinary operand — e.g.
+ * "read from stdin" — never an option, so it is not flag-shaped here
+ * either).
+ */
+function looksLikeFlag(text) {
+    return text.length > 1 && text.startsWith('-') && text !== '--';
+}
+/**
+ * `true` iff `text` matches one of `flags` for {@link WrapperSpec}'s
+ * "whole-token or attached-value" fields ({@link WrapperSpec.unresolvableFlags},
+ * {@link WrapperSpec.stopsChainFlags}): an exact match, a `--flag=value`
+ * attached form for a `--`-prefixed entry, or a `-Xvalue` attached form
+ * for a 2-character short entry. Unlike {@link WrapperSpec.argFlags}, this
+ * does not participate in short-flag *clustering* (see
+ * {@link matchShortFlagCluster}'s doc comment) — a flag combined into a
+ * cluster with other short flags (e.g. hypothetically `-iS'cmd'` for
+ * `env`) falls through to the generic unknown-flag path instead of this
+ * more specific one; still fails closed, just with a less specific reason.
+ */
+function matchesWholeOrAttachedFlag(text, flags) {
+    return flags.some((flag) => {
+        if (text === flag)
+            return true;
+        if (flag.startsWith('--'))
+            return text.startsWith(`${flag}=`);
+        return flag.length === 2 && text.startsWith(flag) && text.length > flag.length;
+    });
+}
+/**
+ * Recognizes a short-option cluster/attached form for `text` against
+ * `spec`'s `noArgFlags`/`argFlags` — the getopt-standard shapes
+ * {@link WrapperSpec.argFlags}'s doc comment documents:
+ *
+ * - `-Xvalue` — a single `argFlags` character `X` with its operand
+ *   attached directly (`-ualice`, `-n10`).
+ * - `-ABX` / `-ABXvalue` — one or more `noArgFlags` characters (`A`, `B`,
+ *   …) clustered before a final `argFlags` character `X`, whose operand is
+ *   either attached (`-Eualice`) or the next separate word (`-Eu alice`).
+ * - `-AB` — two or more `noArgFlags` characters clustered with no
+ *   trailing `argFlags` character at all (`-iv`).
+ *
+ * Scans `text`'s characters left to right; the first character that is
+ * neither a recognized `noArgFlags` nor `argFlags` entry (for that single
+ * character, as `-X`) fails the whole match (`'no-match'`) — real getopt
+ * clustering has the same "first bad option char aborts" behavior, and a
+ * partially-matched guess would be worse than failing closed. Whole-token
+ * exact matches and `--`-prefixed long flags are handled earlier by the
+ * caller and never reach here (this function only ever sees text that
+ * didn't already match `noArgFlags`/`argFlags`/`noArgFlagPattern`/attached
+ * long-flag checks directly).
+ *
+ * Returns `'one'` if the whole `text` token is consumed with no further
+ * operand word needed (the final flag was `noArgFlags`, or an `argFlags`
+ * character had an attached operand), `'two'` if the next, separate word
+ * is the final `argFlags` character's operand, or `'no-match'` if `text`
+ * isn't a valid cluster/attached form for `spec` at all.
+ */
+function matchShortFlagCluster(text, spec) {
+    if (!text.startsWith('-') || text.startsWith('--') || text.length < 2) {
+        return 'no-match';
+    }
+    const chars = text.slice(1);
+    for (let i = 0; i < chars.length; i += 1) {
+        const flagToken = `-${chars[i]}`;
+        if (spec.noArgFlags?.includes(flagToken) === true) {
+            continue;
+        }
+        if (spec.argFlags?.includes(flagToken) === true) {
+            return chars.slice(i + 1).length > 0 ? 'one' : 'two';
+        }
+        return 'no-match';
+    }
+    // Every character matched a noArgFlags entry — a pure no-operand
+    // cluster (e.g. `-iv`).
+    return 'one';
+}
+function findWrapperSpec(wrappers, text) {
+    return wrappers.find((spec) => spec.names.includes(text));
+}
+/**
+ * Walks `argv` forward from `startIndex`, skipping every word this `spec`
+ * structurally recognizes as its own flag, flag-operand (in any
+ * getopt-standard attached/clustered form — see
+ * {@link matchShortFlagCluster}'s doc comment), `VAR=val` operand, or
+ * required positional operand, and classifies what comes next:
+ *
+ * - `{ kind: 'next', index }` — either the wrapped command (an ordinary
+ *   word not shaped like a flag), or a dynamic (`static: false`) word,
+ *   which the caller's own loop already handles via `WordResolution`'s
+ *   normal "never guessed through" rule.
+ * - `{ kind: 'truncated' }` — `spec`'s own words ran past the end of
+ *   `argv` with no wrapped-command word found (a malformed or truncated
+ *   invocation, e.g. bare `env` with nothing else, or `sudo -u` with no
+ *   operand for `-u`).
+ * - `{ kind: 'unresolvable', reason }` — a *statically known* word that
+ *   looks like a flag for this wrapper (unquoted, unescaped `-` prefix,
+ *   not `--`) but matches none of `spec`'s recognized flag/operand shapes,
+ *   or matches one of `spec.unresolvableFlags` (see
+ *   {@link WrapperSpec.unresolvableFlags}'s doc comment). Such a word is
+ *   *never* treated as the wrapped command candidate: a flag-shaped word
+ *   this table doesn't recognize is far more likely to be an
+ *   unmodeled/unsupported option than a command literally named e.g.
+ *   `-D` — see {@link resolveArgv0}'s doc comment.
+ *
+ * A literal `--` (the standard getopt(3)/getopt_long(3) end-of-options
+ * marker — POSIX Utility Syntax Guidelines, guideline 10) is skipped like
+ * any other recognized token, but — critically — everything *after* it is
+ * no longer eligible for **any** flag/operand recognition at all
+ * (`noArgFlags`, `noArgFlagPattern`, `argFlags` in every form,
+ * `unresolvableFlags`, `stopsChainFlags`, or the generic
+ * flag-shape/`'unknown-flag'` check): once options end, a later word that
+ * merely *looks* like a flag (e.g. `-u`) is an ordinary operand — real
+ * `sudo(8)` documents this explicitly ("command line arguments after the
+ * `--` are passed to the command as-is"), and it's the entire point of
+ * `--` for every wrapper here. A wrapper's mandatory positional operand
+ * (e.g. `timeout`'s `DURATION`) is a distinct, non-flag concept and is
+ * still consumed normally after `--` — only *flag* recognition stops.
+ * `VAR=val` operand recognition (`skipAssignmentOperands`) is likewise
+ * unaffected by `--`, matching GNU env(1)'s own two-phase argument
+ * scanning (option parsing, then a separate `NAME=value` scan over
+ * whatever's left) — `--` only ever disables *option* (flag) parsing.
+ */
+function advancePastWrapperOperands(argv, startIndex, spec) {
+    let index = startIndex;
+    let positionalSeen = 0;
+    let optionsEnded = false;
+    const requiredPositional = spec.positionalOperandsBeforeCommand ?? 0;
+    while (index < argv.length) {
+        // `index < argv.length` just checked above, so this is a real element.
+        const word = argv[index];
+        if (!word.static) {
+            // Can't be identified as this wrapper's own flag/operand text at
+            // all — never guessed through, so this word itself is the next
+            // chain element (the caller's loop will see it's unresolvable and
+            // stop there via `WordResolution`'s own `static: false`).
+            return { kind: 'next', index };
+        }
+        const text = word.text;
+        if (!optionsEnded && text === '--') {
+            optionsEnded = true;
+            index += 1;
+            continue;
+        }
+        if (!optionsEnded && spec.skipAssignmentOperands === true && isAssignmentShapedText(text)) {
+            index += 1;
+            continue;
+        }
+        if (!optionsEnded) {
+            if (spec.unresolvableFlags !== undefined &&
+                matchesWholeOrAttachedFlag(text, spec.unresolvableFlags)) {
+                return { kind: 'unresolvable', reason: 'embedded-command' };
+            }
+            if (spec.stopsChainFlags !== undefined &&
+                matchesWholeOrAttachedFlag(text, spec.stopsChainFlags)) {
+                // This wrapper's own invocation is the effective command — the
+                // caller must not advance past it at all. Modeled as "truncated":
+                // the chain simply ends at the wrapper word already pushed, the
+                // same outcome as a genuinely truncated invocation (see
+                // `resolveArgv0`'s loop) — nothing more to skip or resolve.
+                return { kind: 'truncated' };
+            }
+            if (spec.noArgFlags?.includes(text) === true) {
+                index += 1;
+                continue;
+            }
+            if (spec.noArgFlagPattern?.test(text) === true) {
+                index += 1;
+                continue;
+            }
+            if (spec.argFlags?.includes(text) === true) {
+                index += 2;
+                continue;
+            }
+            if (spec.argFlags !== undefined && matchesAttachedLongFlag(text, spec.argFlags)) {
+                index += 1;
+                continue;
+            }
+            const clusterMatch = matchShortFlagCluster(text, spec);
+            if (clusterMatch === 'one') {
+                index += 1;
+                continue;
+            }
+            if (clusterMatch === 'two') {
+                index += 2;
+                continue;
+            }
+            // A flag-shaped word this wrapper doesn't recognize is checked
+            // *before* the positional-operand fallback below: real getopt-based
+            // parsers reject an unrecognized option outright rather than
+            // reinterpreting it as a positional operand (verified against GNU
+            // timeout(1)'s getopt_long-based option parsing) — so a required
+            // positional slot (e.g. `timeout`'s `DURATION`) may only ever be
+            // filled by a non-flag-shaped word, never by an unrecognized `-x`.
+            // None of this applies once `optionsEnded` — see this function's
+            // doc comment.
+            if (looksLikeFlag(text)) {
+                return { kind: 'unresolvable', reason: 'unknown-flag' };
+            }
+        }
+        if (positionalSeen < requiredPositional) {
+            positionalSeen += 1;
+            index += 1;
+            continue;
+        }
+        return { kind: 'next', index };
+    }
+    return { kind: 'truncated' };
+}
+/** `true` iff `value` is a non-empty array of non-empty strings. */
+function isNonEmptyStringArray(value) {
+    return (Array.isArray(value) &&
+        value.length > 0 &&
+        value.every((item) => typeof item === 'string' && item.length > 0));
+}
+/**
+ * Validates one injected {@link WrapperSpec} entry's shape, throwing
+ * {@link ShAnalyzeInvalidWrapperSpecError} on the first problem found —
+ * see {@link ResolveArgv0Options.transparentWrappers}'s doc comment for
+ * why this happens at the boundary rather than surfacing as a confusing
+ * native `TypeError` deep inside flag matching.
+ */
+function validateWrapperSpec(spec, index) {
+    const context = `transparentWrappers[${String(index)}]`;
+    if (!isNonEmptyStringArray(spec.names)) {
+        throw new ShAnalyzeInvalidWrapperSpecError(`${context}.names must be a non-empty array of non-empty strings`);
+    }
+    const stringArrayFields = [
+        'noArgFlags',
+        'argFlags',
+        'unresolvableFlags',
+        'stopsChainFlags',
+    ];
+    for (const field of stringArrayFields) {
+        const value = spec[field];
+        if (value !== undefined &&
+            !(Array.isArray(value) && value.every((item) => typeof item === 'string'))) {
+            throw new ShAnalyzeInvalidWrapperSpecError(`${context}.${field} must be an array of strings when present`);
+        }
+    }
+    if (spec.skipAssignmentOperands !== undefined &&
+        typeof spec.skipAssignmentOperands !== 'boolean') {
+        throw new ShAnalyzeInvalidWrapperSpecError(`${context}.skipAssignmentOperands must be a boolean when present`);
+    }
+    if (spec.noArgFlagPattern !== undefined && !(spec.noArgFlagPattern instanceof RegExp)) {
+        throw new ShAnalyzeInvalidWrapperSpecError(`${context}.noArgFlagPattern must be a RegExp when present`);
+    }
+    if (spec.positionalOperandsBeforeCommand !== undefined &&
+        !(typeof spec.positionalOperandsBeforeCommand === 'number' &&
+            Number.isInteger(spec.positionalOperandsBeforeCommand) &&
+            spec.positionalOperandsBeforeCommand >= 0)) {
+        throw new ShAnalyzeInvalidWrapperSpecError(`${context}.positionalOperandsBeforeCommand must be a non-negative integer when present`);
+    }
+}
+/**
+ * Follows `site`'s argv0 through zero or more *transparent wrappers* —
+ * commands whose own argv0 isn't the command actually run, because they
+ * just locate and re-exec another command (`env FOO=1 rm -rf /`,
+ * `command rm`, `nohup rm`, `sudo -u x "$prog"`) — to the **effective**
+ * command: the one a permission/policy check must actually judge, since
+ * argv0 alone is trivially spoofable through any of these.
+ *
+ * The wrapper table ({@link ResolveArgv0Options.transparentWrappers},
+ * defaulting to {@link DEFAULT_TRANSPARENT_WRAPPERS}) is plain data: each
+ * {@link WrapperSpec} declares how to locate the word it wraps, and
+ * neither this function nor the table encodes any safety judgment about
+ * *which* commands are dangerous — matching {@link CommandSite}'s and
+ * {@link resolveWord}'s "facts only" posture. A caller can drop a default
+ * entry (that name then resolves as an ordinary, non-transparent
+ * command) or add their own (e.g. a project's `with-retry` helper) and
+ * both directions are followed identically to any built-in entry.
+ *
+ * **A statically-unknowable word is never guessed through** — three
+ * distinct cases all stop the chain immediately at that word rather than
+ * falling back to any other guess:
+ *
+ * 1. `argv0` or any wrapper's located word itself resolves `static: false`
+ *    (an expansion, tilde, glob, …) — `sudo -u x "$prog"` reports
+ *    `effective: { static: false, reason: 'expansion' }` with
+ *    `chain: [<sudo>, <"$prog">]`, not `rm`/`sudo`/anything static.
+ * 2. A *statically known* word shaped like a flag (`-`-prefixed, not
+ *    `--`) doesn't match any flag/operand shape the current
+ *    {@link WrapperSpec} recognizes — `sudo -D /tmp rm x` (`-D` isn't
+ *    modeled for `sudo`) reports an `effective` of `static: false` with
+ *    `reason: 'unknown-flag'`, **not** `rm` (the pre-fix behavior: any
+ *    unrecognized word, flag-shaped or not, was silently treated as the
+ *    wrapped command — a false report that hid the real effective
+ *    command behind a flag this table simply hadn't modeled yet).
+ * 3. A recognized flag's value structurally embeds the real command
+ *    rather than naming it as a separate word — `env -S 'rm -rf /'`
+ *    reports `effective: { static: false, reason: 'embedded-command' }`
+ *    (see {@link WrapperSpec.unresolvableFlags}'s doc comment).
+ *
+ * `VAR=val` shell-assignment prefixes on the `CallExpr` itself
+ * (`CommandSite.node.assigns`, e.g. `FOO=bar rm x`) are always skipped and
+ * counted in {@link Argv0Resolution.assignmentsSkipped} — a mechanism
+ * distinct from a wrapper's own `VAR=val` *operands* (`env A=1 rm x`,
+ * `sudo A=1 rm x`), which {@link WrapperSpec.skipAssignmentOperands}
+ * handles per-wrapper.
+ *
+ * @param site - A {@link CommandSite}, typically from {@link enumerateCommands}.
+ * @param options - See {@link ResolveArgv0Options}.
+ * @throws TypeError if `site.argv` is empty — a programmer-error misuse of
+ * the API (every `CommandSite` `enumerateCommands` ever produces has at
+ * least one argv word; see its doc comment), not a "malformed shell
+ * source" case.
+ * @throws {@link ShAnalyzeInvalidWrapperSpecError} if
+ * `options.transparentWrappers` contains a malformed entry (see
+ * {@link ResolveArgv0Options.transparentWrappers}'s doc comment).
+ * @public
+ */
+export function resolveArgv0(site, options) {
+    if (site.argv.length === 0) {
+        throw new TypeError('resolveArgv0 expects a CommandSite with at least one argv word');
+    }
+    const wrappers = options?.transparentWrappers ?? DEFAULT_TRANSPARENT_WRAPPERS;
+    if (options?.transparentWrappers !== undefined) {
+        wrappers.forEach(validateWrapperSpec);
+    }
+    const assignmentsSkipped = nodeArray(site.node.assigns).length;
+    const argv = site.argv;
+    const chain = [];
+    let index = 0;
+    while (index < argv.length) {
+        // `index < argv.length` just checked above, so this is a real element.
+        const word = argv[index];
+        chain.push(word);
+        if (!word.static)
+            break;
+        const spec = findWrapperSpec(wrappers, word.text);
+        if (spec === undefined)
+            break;
+        const result = advancePastWrapperOperands(argv, index + 1, spec);
+        if (result.kind === 'truncated')
+            break;
+        if (result.kind === 'unresolvable') {
+            chain.push({ static: false, reason: result.reason });
+            break;
+        }
+        index = result.index;
+    }
+    // `site.argv.length > 0` is checked above, so the loop above always runs
+    // at least one iteration and pushes `argv[0]` before any `break` — chain
+    // always has at least one element.
+    const effective = chain[chain.length - 1];
+    return { chain, effective, assignmentsSkipped };
+}
+//# sourceMappingURL=resolve-argv0.js.map

package/dist/analyze/resolve-argv0.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-argv0.js","sourceRoot":"","sources":["../../src/analyze/resolve-argv0.ts"],"names":[],"mappings":"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"}