sh-ast 0.6.1 → 0.8.0

package/dist/analyze/resolve-argv0.d.ts

@@ -27,20 +27,33 @@ import type { WordResolution } from './resolve-word.js';
  */
 export interface WrapperSpec {
     /**
-     * The literal, exact argv0 text (after quote/escape removal) that
-     * identifies this wrapper — e.g. `['env']`. Matched only against a
-     * `static: true` word; see {@link WrapperSpec}'s doc comment.
+     * The command name that identifies this wrapper — e.g. `['env']`.
+     * Matched only against a `static: true` word; see {@link WrapperSpec}'s
+     * doc comment.
      *
-     * Matching is **exact-name-only** — never basename matching. `sudo` does
-     * not match `/usr/bin/sudo` or `./sudo`; only a word whose *entire*
-     * resolved text equals one of `names` is recognized. This is a
-     * deliberate, narrower-than-real-world policy choice (a real shell would
-     * happily run `/usr/bin/sudo`), not an oversight: silently treating any
-     * path *ending in* a known wrapper name as that wrapper would be a
-     * different, broader matching policy this package isn't making on a
-     * caller's behalf. A caller who wants path-aware matching can express it
-     * explicitly via a custom {@link ResolveArgv0Options.transparentWrappers}
-     * table (e.g. `names: ['sudo', '/usr/bin/sudo']`).
+     * Matching first searches the entire table for an exact name. Only when
+     * no exact entry exists does it try an absolute path's final segment:
+     *
+     * 1. Its entire resolved text (after quote/escape removal) equals one of
+     *    `names`: `env`, or a path a caller listed verbatim. An exact path
+     *    entry takes precedence over a plain-name entry even if listed later.
+     * 2. It is an **absolute path** (starts with `/`) whose final segment
+     *    equals one of `names`: `/usr/bin/env`, `/usr/bin/sudo`, `/opt/x/nice`
+     *    and `/usr//bin/env` resolve as `env`, `sudo` and `nice`. The chain
+     *    keeps the word as written, so a consumer still sees the path.
+     *
+     * Relative paths and paths with a trailing slash do not use the
+     * final-segment fallback. They can still match an explicitly listed name,
+     * such as `./with-retry` or `/opt/with-retry/`. Custom plain names also
+     * acquire absolute-path aliases; a path-only name does not acquire aliases
+     * for other paths with the same final segment.
+     *
+     * This is a lexical analysis assumption, not executable identity:
+     * `PATH` is not consulted and the filesystem is not read. Without an
+     * exact override, an unrelated executable named `/opt/mytools/env` uses
+     * the `env` entry's grammar. The chain preserves the original path so
+     * callers can apply their own policy. A word with an expansion
+     * (`"$dir/env"`) is not `static` and is never matched.
      */
     readonly names: readonly string[];
     /**
@@ -178,6 +191,145 @@ export interface WrapperSpec {
  * @public
  */
 export declare const DEFAULT_TRANSPARENT_WRAPPERS: readonly WrapperSpec[];
+/**
+ * A data-only description of one shell interpreter whose `-c` option makes the
+ * next operand a command string run by that shell (`bash -c 'rm x'`). Like
+ * `env -S`, the command that runs lives *inside* an operand, so
+ * {@link resolveArgv0} reports `'embedded-command'` instead of the
+ * interpreter's own name as the effective command.
+ * The selector `c` is reserved: exact-token fields (`noOperandLongOptions`,
+ * `operandLongOptions`, `optionTerminatorWords`) cannot contain `-c`.
+ *
+ * Only the option grammar needed to decide *whether `-c` is an option* is
+ * described: which options consume an operand word (so that `-o c` or
+ * `-o pipefail -c` are not misread) and where option parsing ends. Everything
+ * else about the interpreter — what its other options mean, whether a given
+ * option name is valid — is irrelevant to that decision and unmodeled; an
+ * invalid invocation that a real shell would reject is still reported
+ * conservatively, since nothing is guessed about what it would run.
+ *
+ * Option parsing ends at the first statically known word that is not an
+ * option, at `--`, at a lone `-`, or at a table-defined terminator; afterwards
+ * a word shaped like `-c` is an ordinary script operand. A dynamic word in
+ * option position leaves the question undecidable, so scanning stops and the interpreter is reported
+ * exactly as before (its own static name). In that case `static: true` means
+ * only that the interpreter's name is known; it does not mean the command is a
+ * plain shell invocation, because `bash "$f" -c x` runs `x` when `$f` is `-x`.
+ *
+ * This shape may grow new optional fields in a **minor** release; existing
+ * fields' meaning never changes.
+ *
+ * @public
+ */
+export interface EmbeddedCommandInterpreterSpec {
+    /**
+     * The interpreter's name, matched against a static command word's final
+     * path segment: `bash`, `/bin/bash` and `/usr/local/bin/bash` all match
+     * `['bash']`. Only the command word is reduced to its final segment;
+     * entries containing `/` (such as `['/bin/bash']`) are rejected with
+     * {@link ShAnalyzeInvalidWrapperSpecError}. Use `['bash']` to recognize
+     * path-qualified invocations. The first entry containing the segment wins.
+     *
+     * Unlike {@link WrapperSpec.names}, which tries exact names first and
+     * falls back to the final segment only for absolute paths, interpreter
+     * matching uses only the final segment, including for relative paths
+     * such as `./bash`. The question here is whether a command string is
+     * embedded, not which executable would be located.
+     */
+    readonly names: readonly string[];
+    /**
+     * Single option letters (without a sign) that take a name or value operand
+     * under both `-` and `+`, e.g. `['o']` for `-o pipefail` / `+o pipefail`.
+     * A letter listed here never selects the command string itself, so
+     * `bash -o c script` keeps `c` as an option *name*.
+     * The selector `c` is reserved and cannot be listed as an operand option;
+     * conflicting entries throw {@link ShAnalyzeInvalidWrapperSpecError}.
+     */
+    readonly operandOptions: readonly string[];
+    /**
+     * How an {@link EmbeddedCommandInterpreterSpec.operandOptions} letter
+     * receives its operand inside a clustered word:
+     *
+     * - `'separate-word'` — always the next word; remaining letters in the
+     *   cluster are still options (`bash -oc errexit 'cmd'` is `-o errexit -c`).
+     * - `'rest-of-cluster'` — the remainder of the word if any, else the next
+     *   word; later letters in the same word are part of the operand
+     *   (`zsh -oc` names an option `c`).
+     */
+    readonly operandAttachment: 'separate-word' | 'rest-of-cluster';
+    /**
+     * Letters from {@link EmbeddedCommandInterpreterSpec.operandOptions} whose
+     * separate operand may be omitted before a word beginning with `-` or `+`.
+     * An attached operand still belongs to the option. For example, ksh93u+
+     * treats `-o -c cmd` and `+o -c cmd` as an operand-free option listing
+     * followed by `-c`; bash, dash and zsh consume `-c` as the option name.
+     * A dynamic potential operand makes this distinction undecidable.
+     */
+    readonly optionalOperandOptions?: readonly string[];
+    /**
+     * No-operand letters that end option scanning after the current cluster,
+     * under either sign. Remaining letters in that cluster still take effect:
+     * zsh's `-b -c script` runs the file `-c`, but `-bc cmd` selects a string.
+     * These letters must not include `c` or an operand-taking letter.
+     */
+    readonly optionTerminatorLetters?: readonly string[];
+    /**
+     * Additional whole words that end option scanning, like zsh's `+` and `+-`.
+     * The terminator is not a command string; an already-selected `-c` needs
+     * a following word. `--` and a lone `-` are always terminators.
+     */
+    readonly optionTerminatorWords?: readonly string[];
+    /**
+     * Exact long-option words that take a separate operand, recognized before
+     * short-option clusters regardless of prefix: bash's `--rcfile FILE` and
+     * `-rcfile FILE`, or zsh's `--emulate sh`. A dynamic operand stops scanning
+     * because its expansion may produce multiple actual arguments.
+     */
+    readonly operandLongOptions?: readonly string[];
+    /**
+     * Exact long-option words with no operand, recognized before short-option
+     * clusters. Bash's `-restricted` and `-noprofile` are whole long options,
+     * not clusters containing `c` or `o`. Unlisted `--name` / `+-name` words
+     * are also treated as operand-free; option validity is not checked.
+     */
+    readonly noOperandLongOptions?: readonly string[];
+    /**
+     * `true` if the interpreter also treats `+c` as selecting the command
+     * string. Other shells do not select command mode with `+c`.
+     */
+    readonly plusCSelectsCommand?: boolean;
+}
+/**
+ * `sh-ast/analyze`'s default {@link EmbeddedCommandInterpreterSpec} table:
+ * the shells whose `-c` option makes {@link resolveArgv0} report
+ * `'embedded-command'`. Each entry's option grammar is hand-derived from the
+ * cited manual. Basic clusters and required operands were cross-checked on
+ * Linux bash 5.2.21, dash 0.5.12, zsh 5.9, ksh93u+m 1.0.8 and mksh R59.
+ * Long-option, termination and omitted-operand cases were checked on macOS
+ * bash 5.3.9 and 3.2.57 (also `/bin/sh`), Apple dash-16, zsh 5.9 and ksh93u+
+ * AJM 2012-08-01. Omitted `-o`/`+o` operands before another signed option
+ * were confirmed only on that ksh93u+ build, not ksh93u+m or mksh. Builds can
+ * differ: macOS's ksh93u+ differs from the cited 93u+m for `ksh -o c "echo X"`.
+ * The `sh` entry also models bash's long options because `sh` can be bash.
+ * Named options that change the option grammar itself (such as zsh's
+ * `shoptionletters`) are not interpreted; a custom table is needed for that
+ * grammar. It is data, not policy:
+ * it names no dangerous commands and a caller can replace or extend it via
+ * {@link ResolveArgv0Options.embeddedCommandInterpreters}; an empty array
+ * restores the behavior in which an interpreter is an ordinary effective
+ * command.
+ *
+ * Frozen, including each entry and its arrays.
+ *
+ * @see https://www.gnu.org/software/bash/manual/bash.html#Invoking-Bash — bash
+ * @see https://pubs.opengroup.org/onlinepubs/9699919799/utilities/sh.html — POSIX `sh`
+ * @see https://man7.org/linux/man-pages/man1/dash.1.html — dash(1)
+ * @see https://zsh.sourceforge.io/Doc/Release/Invocation-and-Startup.html — zsh
+ * @see https://github.com/ksh93/ksh — ksh93u+m `sh(1)`
+ * @see https://man.mirbsd.org/mksh.1 — mksh(1)
+ * @public
+ */
+export declare const DEFAULT_EMBEDDED_COMMAND_INTERPRETERS: readonly EmbeddedCommandInterpreterSpec[];
 /**
  * Options accepted by {@link resolveArgv0}.
  *
@@ -199,6 +351,19 @@ export interface ResolveArgv0Options {
      * flag matching.
      */
     readonly transparentWrappers?: readonly WrapperSpec[];
+    /**
+     * The shell interpreters whose `-c` operand is reported as an
+     * `'embedded-command'`. Defaults to
+     * {@link DEFAULT_EMBEDDED_COMMAND_INTERPRETERS}. Pass a replacement array to
+     * add or drop interpreters; an empty array disables the behavior, so every
+     * interpreter resolves as an ordinary effective command.
+     *
+     * Validated at the {@link resolveArgv0} boundary like
+     * {@link ResolveArgv0Options.transparentWrappers}: the table must be an
+     * array. A non-array value (including `null`) or malformed entry throws
+     * {@link ShAnalyzeInvalidWrapperSpecError}; only `undefined` uses defaults.
+     */
+    readonly embeddedCommandInterpreters?: readonly EmbeddedCommandInterpreterSpec[];
 }
 /**
  * Why {@link resolveArgv0} couldn't identify a single, definite effective
@@ -215,7 +380,10 @@ export interface ResolveArgv0Options {
  * - `'embedded-command'` — a wrapper flag whose value structurally embeds
  *   the real command rather than naming it as a separate word (e.g.
  *   `env -S 'rm -rf /'` — see {@link WrapperSpec.unresolvableFlags}'s doc
- *   comment).
+ *   comment), or a shell interpreter's `-c` option (`bash -c 'rm x'`, see
+ *   {@link EmbeddedCommandInterpreterSpec}). In both cases the chain's
+ *   second-to-last element is the wrapper or interpreter word, so its name
+ *   stays available.
  * - `'ambiguous-assignment'` — a statically known assignment operand whose
  *   acceptance differs across supported utility implementations, such as
  *   `env =value cmd` (GNU/glibc accepts an empty name; BSD rejects it).
@@ -271,6 +439,22 @@ export interface Argv0Resolution {
      * one element.
      */
     readonly chain: readonly Argv0ChainWord[];
+    /**
+     * Indices into the input {@link CommandSite.argv}, one for each corresponding
+     * {@link Argv0Resolution.chain} entry. The arrays always have the same nonzero
+     * length. Ordinary entries identify their original word; synthesized failures
+     * identify the triggering flag or ambiguous assignment operand instead.
+     * Repeated word text does not collapse distinct argument positions.
+     *
+     * For a resolved effective command, its arguments are
+     * `site.argv.slice(chainIndices.at(-1)! + 1)`. Sites from
+     * {@link enumerateCommands} align argv directly with `site.node.Args`, retaining
+     * null slots as unsupported word resolutions, so the same indices select syntax
+     * Words. A synthetic failure does not identify a command or its arguments.
+     * When wrapper scanning stops or runs out of operands, the existing result
+     * remains the wrapper word and its index; no missing command is invented.
+     */
+    readonly chainIndices: readonly number[];
     /**
      * The last element of {@link Argv0Resolution.chain} — the effective
      * command, or, if resolution hit a statically-unknowable word anywhere
@@ -316,7 +500,7 @@ export interface Argv0Resolution {
  * 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
+ * **A statically-unknowable word is never guessed through** — four
  * distinct cases all stop the chain immediately at that word rather than
  * falling back to any other guess:
  *
@@ -337,6 +521,30 @@ export interface Argv0Resolution {
  *    reports `effective: { static: false, reason: 'embedded-command' }`
  *    (see {@link WrapperSpec.unresolvableFlags}'s doc comment).
  *
+ * 4. The effective command is a shell interpreter
+ *    ({@link DEFAULT_EMBEDDED_COMMAND_INTERPRETERS}) invoked with `-c` —
+ *    `bash -c "$x"`, `sudo sh -ec ls` — and the command that runs is
+ *    inside the string operand. The result is the same
+ *    `'embedded-command'` shape `env -S` produces: the interpreter word is
+ *    `chain.at(-2)` and `chainIndices.at(-1)` is the option word that
+ *    selected `-c`. `bash script.sh`, `bash -e script.sh`, `bash -- -c`
+ *    and `bash -o c` are not `-c` invocations and resolve to `bash` as
+ *    before. A dynamic word in option position (`bash "$f" -c x`,
+ *    `bash -c"$y" x`) is undecidable, so the interpreter stays a static
+ *    `bash`: `static: true` then means only that the name is known, not that
+ *    the command is a plain shell invocation. The `-c` string itself is never
+ *    parsed.
+ *
+ * Known limits: the table models common option spellings, not a full
+ * emulation of each shell's option parser. Unusual spellings can be
+ * misclassified in either direction:
+ *
+ * - Bash/sh single-dash long options after a short option, e.g. `bash -e -rcfile M`.
+ * - `ksh -c +c M`, or a dynamic word after `-c` that expands to an option.
+ * - mksh's selector-bearing operands in `mksh -o -c M` and `mksh -o +c M`.
+ * - A lone `+` before `-c`, e.g. `bash + -c M`.
+ * - Zsh grammar switches, e.g. `zsh -o shoptionletters -b -c M`.
+ *
  * `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
@@ -351,7 +559,8 @@ export interface Argv0Resolution {
  * 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
+ * `options.transparentWrappers` or `options.embeddedCommandInterpreters`
+ * contains a malformed entry (see
  * {@link ResolveArgv0Options.transparentWrappers}'s doc comment).
  * @public
  */

package/dist/analyze/resolve-argv0.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolve-argv0.d.ts","sourceRoot":"","sources":["../../src/analyze/resolve-argv0.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAElC;;;;;;;OAOG;IACH,QAAQ,CAAC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IAE1C;;;;;;;;;;;;;;;;;;OAkBG;IACH,QAAQ,CAAC,kBAAkB,CAAC,EAAE,kBAAkB,GAAG,KAAK,GAAG,MAAM,CAAC;IAElE,6EAA6E;IAC7E,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAExC;;;;;OAKG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAEnC;;;;;;;;;;;;;;;;;;OAkBG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAEtC;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAE/C;;;;;;;;OAQG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAE7C;;;;OAIG;IACH,QAAQ,CAAC,+BAA+B,CAAC,EAAE,MAAM,CAAC;CACnD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,eAAO,MAAM,4BAA4B,EAAE,SAAS,WAAW,EAqH7D,CAAC;AAEH;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,SAAS,WAAW,EAAE,CAAC;CACvD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,MAAM,qBAAqB,GAAG,cAAc,GAAG,kBAAkB,GAAG,sBAAsB,CAAC;AAEjG;;;;;;;;;GASG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,qBAAqB,CAAC;CACxC;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,cAAc,GAAG,cAAc,GAAG,mBAAmB,CAAC;AAElE;;;;;;GAMG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;;;OAMG;IACH,QAAQ,CAAC,KAAK,EAAE,SAAS,cAAc,EAAE,CAAC;IAE1C;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,SAAS,EAAE,cAAc,CAAC;IAEnC;;;;;;;;OAQG;IACH,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;CACrC;AAyVD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,eAAe,CAgC9F"}
+{"version":3,"file":"resolve-argv0.d.ts","sourceRoot":"","sources":["../../src/analyze/resolve-argv0.ts"],"names":[],"mappings":"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"}