@amritk/nish-x86_64-linux 0.20.0 → 0.22.1

package/std/cli.ts

@@ -0,0 +1,344 @@
+/**
+ * `std/cli` — a command-line tool's help menu: whether a stream gets colour,
+ * the escapes that paint it, and the rows a `--help` is made of.
+ *
+ *     import { HelpMenu, agentDriven, styleFor } from "nish/cli";
+ *
+ *     const menu = new HelpMenu(styleFor(1, agentDriven()), "greet", 30, 40);
+ *     menu.header("1.0.0", "say hello");
+ *     menu.usage("<name> [flags]", "greet someone");
+ *     menu.section("Flags");
+ *     menu.row("--shout", "", "in capitals");
+ *     menu.row("--times", "<n>", "say it n times");
+ *     console.log(menu.text());
+ *
+ * **The terminal's own colours.** A `Style` paints with the eight basic SGR
+ * colours, bold and faint, never a fixed RGB or 256-palette tone. Every theme
+ * redefines those eight, so the menu comes out in whatever palette the reader
+ * chose, and a terminal with no theme set paints them in its built-in
+ * defaults. A terminal with no colours at all (`tput colors` says fewer than
+ * eight) gets the failsafe: the same structure in bold and underline, which a
+ * monochrome terminal still shows. Colour that is forced is the theme's.
+ *
+ * **Colour is for a person reading a terminal**, and nothing else may see it:
+ * a script that captures `--help`, a test that compares it, a pipe into `less`
+ * without `-R` all want the plain bytes. So `styleFor` decides per stream, by
+ * asking whether that stream is a terminal, and the conventions people already
+ * set win over the guess: `NO_COLOR` (https://no-color.org) turns it off, and
+ * `CLICOLOR_FORCE` or `FORCE_COLOR` turns it on for a pager that understands
+ * escapes. The plain text is the same bytes either way, and a row's padding is
+ * counted on the plain text, so the columns line up with or without escapes.
+ *
+ * **An agent is a reader of its own kind**: it may drive a pseudo-terminal, so
+ * the terminal check says yes, but every escape is tokens it pays for and
+ * reads past. `agentDriven` says when one is at the keyboard, and `styleFor`
+ * is then plain whatever forcing variable its shell inherited.
+ *
+ * **What it reaches.** `Style` and `HelpMenu` reach no capability. `styleFor`
+ * reads the environment and, on the terminal check, forks a shell
+ * (`env` and `process.spawn`),
+ * and `agentDriven` reads the environment; a program that builds its `Style`
+ * by hand reaches neither.
+ *
+ * **The compiler's own help is built with it**, through a relative import from
+ * `src/cli-style.ts`, so this file is compiled by the last release as part of
+ * the compiler: it may use only what that release compiles (the rolling
+ * freeze, `.claude/selfhost.md`), which is why it asks the shell whether a
+ * descriptor is a terminal rather than calling `nish:term`'s `isTerminal`.
+ */
+
+/** The Control Sequence Introducer every SGR escape opens with. */
+const CSI: string = "\u001b["
+
+/** `paletteOf`'s answer: marked up in the theme's colours. */
+const PALETTE_THEME: i32 = 0
+
+/** `paletteOf`'s answer: marked up in attributes only, the failsafe. */
+const PALETTE_MONO: i32 = 2
+
+/**
+ * How one output stream is painted. `on` says whether to mark the text up at
+ * all, and `colour` whether the terminal has colours to mark it up with;
+ * without them each mark falls back to bold, underline or nothing.
+ */
+export class Style {
+  on: boolean
+  colour: boolean
+
+  constructor(on: boolean, colour: boolean) {
+    this.on = on
+    this.colour = colour
+  }
+
+  /**
+   * `text` wrapped in the escape for `themed` (an SGR parameter list in the
+   * theme's basic colours) or `mono` (attributes only), and a reset after it;
+   * `text` unchanged when marking up is off or the chosen list is empty, so a
+   * caller never has to ask.
+   */
+  paint(text: string, themed: string, mono: string): string {
+    const code = this.colour ? themed : mono
+    if (!this.on || text.length === 0 || code.length === 0) {
+      return text
+    }
+    return `${CSI}${code}m${text}${CSI}0m`
+  }
+
+  /** A section heading: bold, in the theme's magenta. */
+  heading(text: string): string {
+    return this.paint(text, "1;35", "1")
+  }
+
+  /** The tool's own name where it opens a line. */
+  name(text: string): string {
+    return this.paint(text, "1;35", "1")
+  }
+
+  /** A flag, or a command a person would type. */
+  flag(text: string): string {
+    return this.paint(text, "36", "1")
+  }
+
+  /** A placeholder the person fills in: `<file.ts>`, `speed|size`. */
+  meta(text: string): string {
+    return this.paint(text, "33", "4")
+  }
+
+  /**
+   * Text that explains rather than names: descriptions, notes. Faint rather
+   * than bright black, which Solarized makes the background; plain without
+   * colour, where the bold flags already stand apart from it.
+   */
+  dim(text: string): string {
+    return this.paint(text, "2", "")
+  }
+}
+
+/** Whether the environment variable `name` is set to something other than empty. */
+const envIsSet = (name: string): boolean => {
+  const value = getenv(name)
+  return value !== null && value.length > 0
+}
+
+/** Whether `value` spells `word`, which is lower case, in any ASCII case. */
+const spells = (value: string, word: string): boolean => {
+  if (value.length !== word.length) {
+    return false
+  }
+  // Both bounds, though the lengths match: the checker proves an index in range
+  // only for a string its loop condition names.
+  for (let i: i32 = 0; i < toI32(value.length) && i < toI32(word.length); i++) {
+    let code: i32 = toI32(value.charCodeAt(i))
+    if (code >= 65 && code <= 90) {
+      code = code + 32
+    }
+    if (code !== toI32(word.charCodeAt(i))) {
+      return false
+    }
+  }
+  return true
+}
+
+/** Whether `value` is a no: `0`, `false`, `no` or `off`, in any case. */
+const isNo = (value: string): boolean =>
+  value === "0" || spells(value, "false") || spells(value, "no") || spells(value, "off")
+
+/** Whether a variable's `value` is set to a no (`isNo`). */
+const saysNo = (value: string | null): boolean => value !== null && isNo(value)
+
+/** Whether a variable's `value` is set and says yes: not empty, and not a no. */
+const saysYes = (value: string | null): boolean => value !== null && value.length > 0 && !isNo(value)
+
+/** Whether the variable `name` is set to a no (`saysNo`). */
+const envSaysNo = (name: string): boolean => saysNo(getenv(name))
+
+/** Whether the variable `name` says yes (`saysYes`). */
+const envSaysYes = (name: string): boolean => saysYes(getenv(name))
+
+/**
+ * What terminal descriptor `fd` is: `PALETTE_THEME`, `PALETTE_MONO`, or
+ * anything else for no terminal, which is plain text. The shell answers: a
+ * child inherits the descriptors and the environment, `[ -t 1 ]` is POSIX,
+ * and `tput colors` reads the count `TERM`'s terminfo entry declares (`-1` for
+ * none). `tput` is run by absolute path, never looked up on `PATH`, so a
+ * `PATH` with `.` in it cannot run a `tput` planted in the working directory
+ * (`docs/security/cli.md`). When there is no `tput` there, or it does not know
+ * `TERM`, the answer is the theme: almost every terminal has colours, and an
+ * escape a monochrome one does not know it drops. It costs one fork of the
+ * shell and, on a terminal, one of `tput`. Where nothing can be spawned (a
+ * WebAssembly build) the answer is `-1`, which is plain text, the safe side.
+ */
+const paletteOf = (fd: i32): i32 => {
+  const tty = `[ -t ${fd} ] || exit 1; `
+  const find = "t=/usr/bin/tput; [ -x $t ] || t=/bin/tput; [ -x $t ] || exit 0; "
+  const count = "c=$($t colors 2>/dev/null) || exit 0; case $c in ''|*[!0-9-]*) exit 0;; esac; "
+  return toI32(spawnSync(["/bin/sh", "-c", `${tty}${find}${count}[ "$c" -ge 8 ] || exit ${PALETTE_MONO}`]))
+}
+
+/** The style for a `paletteOf` answer: the theme, the failsafe, or plain. */
+const styleOfPalette = (palette: i32): Style => {
+  if (palette === PALETTE_THEME) {
+    return new Style(true, true)
+  }
+  return new Style(palette === PALETTE_MONO, false)
+}
+
+/**
+ * Whether an agent, rather than a person, is running the program.
+ * `NISH_AGENT` answers for any agent: a no (`envSaysNo`) for no, any other
+ * value for yes. Without it, the variables the agents that set one put in
+ * their commands' environment (Claude Code's `CLAUDECODE`, Gemini CLI's
+ * `GEMINI_CLI`) say yes.
+ */
+export const agentDriven = (): boolean => {
+  if (envIsSet("NISH_AGENT")) {
+    return !envSaysNo("NISH_AGENT")
+  }
+  return envSaysYes("CLAUDECODE") || envSaysYes("GEMINI_CLI")
+}
+
+/**
+ * The style for descriptor `fd` (1 or 2), for a reader `agent` says is an
+ * agent or not (`agentDriven`, asked once by the caller). `NO_COLOR` wins,
+ * then an agent, then `FORCE_COLOR` saying no (`isNo`; Node reads `0` and
+ * `false` so), then a forcing variable, then `CLICOLOR` saying no or
+ * `TERM=dumb`, and only then the terminal check, where the colours `TERM`
+ * declares choose between the theme and the failsafe (`paletteOf`). Forced
+ * colour is the theme's, asked of nothing: the reader is a pager or an editor
+ * that renders the escapes itself (Emacs's shell sets `TERM=dumb` and paints
+ * ANSI colour), so `TERM` does not describe it, and forcing forks nothing.
+ */
+export const styleFor = (fd: i32, agent: boolean): Style => {
+  const level = getenv("FORCE_COLOR")
+  if (envIsSet("NO_COLOR") || agent || saysNo(level)) {
+    return new Style(false, false)
+  }
+  if (saysYes(level) || envSaysYes("CLICOLOR_FORCE")) {
+    return new Style(true, true)
+  }
+  const term = getenv("TERM")
+  if (envSaysNo("CLICOLOR") || (term !== null && term === "dumb")) {
+    return new Style(false, false)
+  }
+  return styleOfPalette(paletteOf(fd))
+}
+
+/** A run of spaces to cut padding from, as wide as a terminal's usual 80 columns. */
+const SPACE_RUN: string = "                                                                                "
+
+/** `count` spaces, or none when `count` is not positive: a cut of `SPACE_RUN`, built only past its width. */
+const spaces = (count: i32): string => {
+  if (count <= 0) {
+    return ""
+  }
+  if (count <= toI32(SPACE_RUN.length)) {
+    return SPACE_RUN.substring(0, count)
+  }
+  const out: string[] = []
+  for (let i: i32 = 0; i < count; i++) {
+    out.push(" ")
+  }
+  return out.join("")
+}
+
+/**
+ * The spaces that take plain text `width` columns wide to `column`, or two
+ * when that would leave fewer, so a long flag still keeps apart from its text.
+ */
+const padTo = (width: i32, column: i32): string => spaces(width + 2 <= column ? column - width : 2)
+
+/**
+ * A help menu, built a line at a time and answered whole by `text`. Rows are
+ * indented two columns and their descriptions start at `column`; usage lines'
+ * descriptions start at `usageColumn`, past the longest command shape. Every
+ * width is counted on the plain text, one column a byte, so the columns line
+ * up whether or not `style` paints, as long as the text is ASCII.
+ */
+export class HelpMenu {
+  style: Style
+  program: string
+  column: i32
+  usageColumn: i32
+  lines: string[]
+  usages: i32
+
+  constructor(style: Style, program: string, column: i32, usageColumn: i32) {
+    this.style = style
+    this.program = program
+    this.column = column
+    this.usageColumn = usageColumn
+    this.lines = []
+    this.usages = 0
+  }
+
+  /** The opening line, the program's name, `version` and a one-line `summary`, and a blank after it. */
+  header(version: string, summary: string): void {
+    this.title(version, summary)
+    this.lines.push("")
+  }
+
+  /**
+   * The opening line alone, without `header`'s blank after it, for a menu that
+   * puts something under its title (`line`) before the blank.
+   */
+  title(version: string, summary: string): void {
+    const style = this.style
+    this.lines.push(`${style.name(this.program)} ${style.dim(version)}  ${style.dim(summary)}`)
+  }
+
+  /**
+   * A line exactly as given, painted (or not) by the caller with the menu's
+   * `style`: a rule, a banner, a blank. Its width is the caller's to keep.
+   */
+  line(text: string): void {
+    this.lines.push(text)
+  }
+
+  /**
+   * A usage line: the command `shape` after the program's name, and what it
+   * is for (`description` may be empty). The first opens with `usage:` and
+   * the rest are indented under it.
+   */
+  usage(shape: string, description: string): void {
+    const style = this.style
+    const lead = this.usages === 0 ? `${style.heading("usage:")} ` : spaces(7)
+    const width: i32 = 8 + toI32(this.program.length) + toI32(shape.length)
+    const text = description.length > 0 ? `${padTo(width, this.usageColumn)}${style.dim(description)}` : ""
+    this.lines.push(`${lead}${style.name(this.program)} ${style.flag(shape)}${text}`)
+    this.usages = this.usages + 1
+  }
+
+  /** A section: a blank line, then `title` as a heading. */
+  section(title: string): void {
+    this.lines.push("")
+    this.lines.push(this.style.heading(title))
+  }
+
+  /**
+   * One row: the `flag` (or a command), its placeholder `meta` (may be
+   * empty), and what it does, the description starting at `column`.
+   */
+  row(flag: string, meta: string, description: string): void {
+    const style = this.style
+    const width: i32 = 2 + toI32(flag.length) + (meta.length > 0 ? 1 + toI32(meta.length) : 0)
+    const placeholder = meta.length > 0 ? ` ${style.meta(meta)}` : ""
+    this.lines.push(
+      `  ${style.flag(flag)}${placeholder}${padTo(width, this.column)}${style.dim(description)}`
+    )
+  }
+
+  /** An indented line of prose, faint. */
+  note(text: string): void {
+    this.lines.push(`  ${this.style.dim(text)}`)
+  }
+
+  /** An indented line the reader fills in or opens, a path or a value, as a placeholder. */
+  value(text: string): void {
+    this.lines.push(`  ${this.style.meta(text)}`)
+  }
+
+  /** The menu so far, its lines joined by newlines, with no newline after the last. */
+  text(): string {
+    return this.lines.join("\n")
+  }
+}

package/std/collections.ts

@@ -53,11 +53,12 @@ const INDEX_CAP: i32 = 16777215
 const INITIAL_SLOTS: i32 = 8
 
 /**
- * The key's hash, never 0: FNV-1a over a string's bytes, murmur3's `fmix32`
- * for an integer of 32 bits or fewer, `fmix64` folded to 32 bits for a 64-bit
- * integer, a float (normalised first, so that -0 and +0, and every NaN, hash
- * alike) and a class instance's address (§5.2). FNV, MurmurHash3 and their
- * constants are public domain.
+ * The key's hash, never 0: SipHash-1-3 of a string's bytes under the process's
+ * random key, folded to 32 bits (docs/security/json.md, JSON-13), murmur3's
+ * `fmix32` for an integer of 32 bits or fewer, `fmix64` folded to 32 bits for a
+ * 64-bit integer, a float (normalised first, so that -0 and +0, and every NaN,
+ * hash alike) and a class instance's address (§5.2). SipHash's reference is
+ * CC0; MurmurHash3 and its constants are public domain.
  *
  * The body is never emitted. Every call is lowered in place, per key type, by
  * `src/emit-map.ts`; the constant is what the checker and the whole-program

package/std/crypto/LICENSE-crypt_blowfish

@@ -0,0 +1,26 @@
+crypt_blowfish (https://www.openwall.com/crypt/), version 1.3, crypt_blowfish.c
+
+Written by Solar Designer <solar at openwall.com> in 1998-2014.
+No copyright is claimed, and the software is hereby placed in the public
+domain.  In case this attempt to disclaim copyright and place the software
+in the public domain is deemed null and void, then the software is
+Copyright (c) 1998-2014 Solar Designer and it is hereby released to the
+general public under the following terms:
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted.
+
+There's ABSOLUTELY NO WARRANTY, express or implied.
+
+It is my intent that you should be able to use this on your system,
+as part of a software package, or anywhere else to improve security,
+ensure compatibility, or for any other purpose.  I would appreciate
+it if you give credit where it is due and keep your modifications in
+the public domain as well, but I don't require that in order to let
+you place this code and any modifications you make under a license
+of your choice.
+
+This implementation is fully compatible with OpenBSD's bcrypt.c for prefix
+"$2b$", originally by Niels Provos <provos at citi.umich.edu>, and it uses
+some of his ideas.  The password hashing algorithm was designed by David
+Mazieres <dm at lcs.mit.edu>.

package/std/crypto/base64url.ts

@@ -6,6 +6,15 @@
  * text already says how many bytes the last group holds (RFC 4648 §3.2 lets a
  * specification that knows its lengths drop the padding, and RFC 7515 §2 does).
  *
+ * The module also holds RFC 4648 §4 standard base64 — `+` and `/`, padded with
+ * `=` — as `base64StdPadEncode` and `base64StdPadDecode`, for PEM
+ * (`nish/crypto/x509`) and SCRAM (`nish/net/postgres`). It is as strict and as
+ * constant-time as the URL alphabet, by the same masks, and it refuses a `=`
+ * anywhere but the last one or two characters of a text whose length is a
+ * multiple of four. They are not `nish/base64`'s `base64Encode`, which encodes
+ * only, indexes its alphabet and is for pixels; the `StdPad` names keep the two
+ * apart in the program's one namespace.
+ *
  * **Decoding is strict, so that each byte string has exactly one spelling.**
  * `base64urlDecode` answers `null` for a `=` anywhere, for any character outside
  * the alphabet (whitespace included), for a length of 1 mod 4 — six bits, not a
@@ -169,3 +178,119 @@ export const base64urlDecode = (text: string): u8[] | null => {
   }
   return out
 }
+
+// ---------------------------------------------------------------------------
+// Standard base64 (RFC 4648 §4): `+` and `/`, padded with `=`
+// ---------------------------------------------------------------------------
+
+/**
+ * The standard-alphabet character for the sextet `v`: the same steps as
+ * `base64urlCharOf` until 62, which lands on `+` and 63 on `/`.
+ */
+const base64StdPadCharOf = (v: i32): i32 =>
+  toI32(
+    65 +
+      toU32(v) +
+      toU32(base64urlRangeMask(v, 26, 63) & 6) -
+      toU32(base64urlRangeMask(v, 52, 63) & 75) -
+      toU32(base64urlRangeMask(v, 62, 63) & 15) +
+      toU32(base64urlRangeMask(v, 63, 63) & 3)
+  )
+
+/** The sextet the byte `c` stands for in standard base64, or `-1` when it is not in the alphabet. */
+const base64StdPadSextetOf = (c: i32): i32 => {
+  const upper: i32 = base64urlRangeMask(c, 65, 90)
+  const lower: i32 = base64urlRangeMask(c, 97, 122)
+  const digit: i32 = base64urlRangeMask(c, 48, 57)
+  const plus: i32 = base64urlRangeMask(c, 43, 43)
+  const slash: i32 = base64urlRangeMask(c, 47, 47)
+  const value: i32 =
+    (upper & toI32(toU32(c) - 65)) |
+    (lower & toI32(toU32(c) - 71)) |
+    (digit & toI32(toU32(c) + 4)) |
+    (plus & 62) |
+    (slash & 63)
+  return value | ~(upper | lower | digit | plus | slash)
+}
+
+/**
+ * `data` in padded standard base64, as one line: PEM's body, and SCRAM's
+ * nonces, salts and proofs (RFC 5802 §5.1). One `=` closes a final group of
+ * two bytes, two a group of one. An array longer than 2^31 - 1 bytes panics.
+ */
+export const base64StdPadEncode = (data: u8[]): string => {
+  if (data.length > 2147483647) {
+    panic("base64StdPadEncode: more than 2^31 - 1 bytes")
+  }
+  const parts: string[] = []
+  let acc: i32 = 0
+  let bits: u32 = 0
+  for (let k: i32 = 0; k < toI32(data.length); k++) {
+    acc = ((acc << 8) | toI32(data[k])) & 0xfff
+    bits += 8
+    while (bits >= 6) {
+      bits -= 6
+      parts.push(String.fromCharCode(base64StdPadCharOf((acc >> toI32(bits)) & 63)))
+    }
+  }
+  if (bits > 0) {
+    parts.push(String.fromCharCode(base64StdPadCharOf((acc << toI32(6 - bits)) & 63)))
+  }
+  const tail: i32 = toI32(data.length) % 3
+  if (tail > 0) {
+    parts.push(tail === 1 ? "==" : "=")
+  }
+  return parts.join("")
+}
+
+/**
+ * The bytes of padded standard base64 `text`, or `null` unless it is the one
+ * canonical spelling of them: a whole number of four-character groups, `=`
+ * only as the last one or two characters, every other character in the
+ * alphabet, and the bits the padding leaves over all zero (RFC 4648 §3.5).
+ * The empty text is the spelling of no bytes (RFC 4648 §10). Where the padding
+ * is depends on the length alone; the characters themselves are read by masks
+ * and judged once, after the last.
+ */
+export const base64StdPadDecode = (text: string): u8[] | null => {
+  if (text.length > 2147483647) {
+    return null
+  }
+  const n: i32 = toI32(text.length)
+  if ((n & 3) !== 0) {
+    return null
+  }
+  let pad: i32 = 0
+  if (n > 0 && toI32(text.charCodeAt(n - 1)) === 61) {
+    pad = toI32(text.charCodeAt(n - 2)) === 61 ? 2 : 1
+  }
+  const chars: i32 = n - pad
+  const out: u8[] = new Array<u8>((n >> 2) * 3 - pad)
+  const outLen: i32 = toI32(out.length)
+  let bad: i32 = 0
+  let acc: i32 = 0
+  let bits: i32 = 0
+  let j: i32 = 0
+  // The padding is past `chars` and is not data; which positions those are is
+  // a fact about the length. A `=` before them is outside the alphabet.
+  for (let k: i32 = 0; k < chars && k < toI32(text.length); k++) {
+    const v: i32 = base64StdPadSextetOf(toI32(text.charCodeAt(k)))
+    bad = bad | (v >> 31)
+    acc = ((acc << 6) | (v & 63)) & 0xfff
+    bits += 6
+    if (bits >= 8) {
+      bits -= 8
+      // Always true — `out` was sized from the same length — and written so
+      // the store keeps no bounds check.
+      if (j >= 0 && j < outLen) {
+        out[j] = toU8((acc >> bits) & 255)
+      }
+      j++
+    }
+  }
+  bad = bad | (acc & ((1 << bits) - 1))
+  if (bad !== 0) {
+    return null
+  }
+  return out
+}