From c18f8b5003c47d72f00ef7a3d340e660ac30be26 Mon Sep 17 00:00:00 2001 From: Zack Whitson Date: Fri, 7 Aug 2026 10:49:12 -0500 Subject: [PATCH] Release CodeTruss CLI v0.2.40 Syncs the 0.2.40 source from the private monorepo. This sync lands after 0.2.40 was already distributed from the website: the original release train halted on a Windows-only test failure, and the tag, GitHub release, and attestation were never created. The published archive has therefore had no verifiable provenance since it went up, which is the one thing this project promises about every artifact it ships. The content here is 0.2.40 as published. A local rebuild of this tree reproduces the distributed archive byte for byte: codetruss-cli-0.2.40.tgz sha256 5d64313b8b60acbd1f93e2246557967885a98fdc8c486ea7b2a6417fd8acdac2 That is the digest the website serves and the digest recorded in release-reference.json, so the release workflow can rebuild it, assert the match, and attest bytes that were genuinely reproduced rather than asserted. The Windows test isolation fix is included. It touches only files under packages/cli/test, which the package `files` allowlist excludes, so it cannot and does not change the released archive. Co-Authored-By: Claude Opus 5 --- CHANGELOG.md | 86 +++- packages/cli/CHANGELOG.md | 84 ++++ packages/cli/package.json | 4 +- packages/cli/scripts/build-grammar-packs.mjs | 150 +++++++ packages/cli/scripts/grammar-pack-sources.mjs | 58 +++ packages/cli/scripts/verify-grammar-packs.mjs | 116 +++++ packages/cli/src/cli.ts | 9 + packages/cli/src/grammar-command.ts | 103 +++++ packages/cli/src/grammar-pack-manifest.ts | 69 +++ packages/cli/src/grammar-pack.ts | 416 ++++++++++++++++++ packages/cli/src/grammar-parser.ts | 212 +++++++++ packages/cli/src/local-sast.ts | 211 ++++++--- packages/cli/src/receipt.ts | 138 ++++++ packages/cli/src/types.ts | 24 +- packages/cli/test/grammar-command.test.ts | 118 +++++ packages/cli/test/grammar-loader.test.ts | 129 ++++++ packages/cli/test/grammar-pack.test.ts | 396 +++++++++++++++++ packages/cli/test/grammar-sast.test.ts | 195 ++++++++ packages/cli/test/receipt.test.ts | 165 ++++++- .../codetruss-cli-0.2.40.sbom.cdx.json | 170 +++++++ public/downloads/codetruss-cli-0.2.40.tgz | Bin 0 -> 857688 bytes .../downloads/codetruss-cli-0.2.40.tgz.sha256 | 1 + public/downloads/codetruss-cli-latest.json | 14 +- .../codetruss-cli-latest.sbom.cdx.json | 10 +- public/downloads/codetruss-cli-latest.tgz | Bin 827475 -> 857688 bytes .../downloads/codetruss-cli-latest.tgz.sha256 | 2 +- .../grammars/codetruss-grammars-latest.json | 37 ++ .../python-1.0.0/tree-sitter-python.wasm | Bin 0 -> 476105 bytes .../tree-sitter-python.wasm.sha256 | 1 + .../grammars/python-1.0.0/tree-sitter.js | 1 + .../python-1.0.0/tree-sitter.js.sha256 | 1 + .../grammars/python-1.0.0/tree-sitter.wasm | Bin 0 -> 188635 bytes .../python-1.0.0/tree-sitter.wasm.sha256 | 1 + public/install.ps1 | 37 ++ public/install.sh | 24 +- release-reference.json | 10 +- 36 files changed, 2909 insertions(+), 83 deletions(-) create mode 100644 packages/cli/scripts/build-grammar-packs.mjs create mode 100644 packages/cli/scripts/grammar-pack-sources.mjs create mode 100644 packages/cli/scripts/verify-grammar-packs.mjs create mode 100644 packages/cli/src/grammar-command.ts create mode 100644 packages/cli/src/grammar-pack-manifest.ts create mode 100644 packages/cli/src/grammar-pack.ts create mode 100644 packages/cli/src/grammar-parser.ts create mode 100644 packages/cli/test/grammar-command.test.ts create mode 100644 packages/cli/test/grammar-loader.test.ts create mode 100644 packages/cli/test/grammar-pack.test.ts create mode 100644 packages/cli/test/grammar-sast.test.ts create mode 100644 public/downloads/codetruss-cli-0.2.40.sbom.cdx.json create mode 100644 public/downloads/codetruss-cli-0.2.40.tgz create mode 100644 public/downloads/codetruss-cli-0.2.40.tgz.sha256 create mode 100644 public/downloads/grammars/codetruss-grammars-latest.json create mode 100644 public/downloads/grammars/python-1.0.0/tree-sitter-python.wasm create mode 100644 public/downloads/grammars/python-1.0.0/tree-sitter-python.wasm.sha256 create mode 100644 public/downloads/grammars/python-1.0.0/tree-sitter.js create mode 100644 public/downloads/grammars/python-1.0.0/tree-sitter.js.sha256 create mode 100644 public/downloads/grammars/python-1.0.0/tree-sitter.wasm create mode 100644 public/downloads/grammars/python-1.0.0/tree-sitter.wasm.sha256 diff --git a/CHANGELOG.md b/CHANGELOG.md index 951f3e7..4a2c4a7 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,7 +3,7 @@ CodeTruss CLI follows semantic versioning. Release artifacts and their SHA-256 checksums are published at . -The current public release is [v0.2.39 on GitHub](https://github.com/DeliriumPulse/codetruss-cli/releases/tag/v0.2.39), +The current public release is [v0.2.40 on GitHub](https://github.com/CodeTruss/codetruss-cli/releases/tag/v0.2.40), distributed from . The npm `latest` tag is still [`@codetruss/cli@0.2.24`](https://www.npmjs.com/package/@codetruss/cli/v/0.2.24): @@ -16,6 +16,90 @@ were superseded before distribution. No unreleased changes. +## 0.2.40 — 2026-08-07 + +- **Python can now be analyzed locally, if you ask for it.** `codetruss + grammars install python` downloads the `web-tree-sitter` runtime and the + compiled Python grammar (722 KB) into your data directory — XDG on macOS and + Linux, `LOCALAPPDATA` on Windows. Nothing is bundled in the tarball, nothing + is fetched during an analysis, and no other command installs it for you. The + CLI ships a hand-written JavaScript parser precisely because these grammars + are several times its entire release budget, and that trade is unchanged for + anyone who does not run this command. `codetruss grammars list|status| + uninstall` round out the group; `status` exits non-zero when a pack is + missing or fails verification, so it can gate a setup script. +- **The pack is pinned, verified as it arrives, and verified again every time + it is loaded.** Each artifact's SHA-256 is compiled into the CLI at build + time. The download is hashed as it streams, with the pinned length enforced + mid-stream so a wrong or hostile origin cannot write an unbounded file to + disk; artifacts land in a scratch directory and are moved into place only + after every one of them verifies, so a pack directory is never half-installed. + The only download origin is `codetruss.com` — no third-party CDN, and + redirects are refused. Hashing is streamed in-process, never shelled out to + `shasum` or `Get-FileHash`. **Every** failure — absent, truncated, over-long, + wrong digest, unreadable, or an unexpected extra file in the pack directory — + resolves to "pack unavailable", and the run reports Python as skipped. There + is no path on which unverified bytes are executed. +- **Python runs the complete rule pack, not the reduced JavaScript subset.** + That subset exists because a hand-written parser might disagree with + tree-sitter, and only rules proven to agree were admitted. A grammar pack *is* + the hosted parser and the hosted grammar, so there is no divergence to guard + against — and narrowing it would report less than the same code receives in a + hosted scan, for no gain in precision. Command injection, path traversal, + SSRF and insecure deserialization are checked in Python locally; they remain + unchecked in JavaScript, TypeScript and TSX, and the receipt keeps saying so. +- **Verified against the hosted path over 233 real Python files** — the + full-stack FastAPI template, three further repositories, and a synthetic + fixture covering each rule class. Both parsers produced the same 11 findings, + with **zero divergence in either direction**. +- **Receipts move to the `local-registry-v4` profile, which states what the run + actually did about Python.** The pass set is unchanged from v3; the wording + had to change, because v3 says flatly that the local pass covers "JavaScript, + TypeScript and TSX only" and that Python received no security analysis, and + that is false whenever a pack is installed. There are now three + distinguishable statements instead of one frozen sentence: **absent** names + the Python file count and the command that would cover them, **verified** + names the rule pack and the file count while keeping the JavaScript subset's + limits scoped to JavaScript, and a **failed** pack now says *which* kind of + failure it was — a digest mismatch (the pack does not match what this CLI + published, so reinstall), a runtime that would not start on this machine even + though the digests matched, or a scan that threw partway and had its partial + results discarded. Only a real digest mismatch renders the tampering sentence; + an out-of-memory error no longer accuses your install of not matching the + published digests. Every failure branch closes with the provable "No findings + from this pack were reported" in place of the wider absolute claim. + `local-registry-v3` keeps a frozen renderer, so receipts signed by 0.2.39 + still verify byte-for-byte. +- **The bytes that are verified are now the exact bytes that execute.** The + loader used to hash each artifact by path and then re-open the same path to + `require()` it, so the file that was hashed and the file that ran were two + separate reads with a window between them — three digests and a directory + listing wide enough for another process with write access to the pack + directory to swap a hostile `tree-sitter.js` in after the check and have it + executed. `inspectGrammarPack` now reads each artifact once and returns the + buffer it hashed; the runtime is compiled from that buffer and the two WASM + artifacts are handed to `web-tree-sitter` as in-memory `Uint8Array`s + (`wasmBinary` and `Language.load`), so nothing is ever resolved from a path a + second time. Artifacts are opened `O_NOFOLLOW` and rejected unless they are + regular files; a symlinked pack root, a pack root not owned by the current + user, or one writable by group or other is refused, and a loose root created + by an earlier CLI is tightened to `0700` on install. A local same-user race + that reliably executed attacker code against the previous loader now fails + every attempt. +- **Fixed: Python was silently dropped from the second half of every review.** + The tree-sitter runtime reassigns its own entry in Node's module cache while + initializing, so loading it a second time in one process returned the wrong + object. A review analyzes twice — once for the baseline tree, once for the + final tree — which meant the final analysis quietly failed to load the grammar + and reported Python as unanalyzable even with a healthy pack installed. The + runtime is now loaded once per process. Digests are still re-checked on every + load; only the runtime construction is reused. +- **Fixed: the Windows data directory was resolved with POSIX path rules.** + `LOCALAPPDATA` was checked with a path test that treats `C:\Users\…` as + relative anywhere other than Windows, which made the branch correct on Windows + and unverifiable everywhere else. It now names the Windows path flavour + explicitly, and is covered by a test that runs on every platform. + ## 0.2.39 — 2026-08-07 - **Two analyzers join the registry, which now holds 15.** Both come from a diff --git a/packages/cli/CHANGELOG.md b/packages/cli/CHANGELOG.md index 51aa11e..f5f7b1a 100644 --- a/packages/cli/CHANGELOG.md +++ b/packages/cli/CHANGELOG.md @@ -5,6 +5,90 @@ checksums are published at !name.endsWith('.sha256')).sort() + const expected = pack.files.map((file) => file.name).sort() + if (present.join('\n') !== expected.join('\n')) { + throw new Error(`${directoryName} holds unexpected files: ${present.join(', ')}`) + } + + manifestPacks.push({ + name: pack.name, + version: GRAMMAR_PACK_VERSION, + language: pack.language, + runtime: GRAMMAR_PACK_PROVENANCE.runtime, + grammar: GRAMMAR_PACK_PROVENANCE.grammar, + files, + }) +} + +export const GRAMMAR_MANIFEST_NAME = 'codetruss-grammars-latest.json' + +const manifest = `${JSON.stringify({ packs: manifestPacks }, null, 2)}\n` +await writeFile(join(grammarDir, GRAMMAR_MANIFEST_NAME), manifest, 'utf8') + +/** + * The compiled-in pin. + * + * Generated rather than hand-maintained because a hand-copied digest is a digest + * that eventually disagrees with the bytes, and this one is the only thing + * standing between a user and executing whatever a compromised origin served. + */ +const pin = `/** + * Pinned grammar-pack digests. GENERATED by scripts/build-grammar-packs.mjs. + * + * Do not edit by hand. These digests are what \`codetruss grammars install\` + * checks a download against, and what every subsequent load re-checks on disk. + * A pack whose bytes do not hash to exactly these values is never loaded, and + * the run discloses Python as skipped instead. + */ + +export interface PinnedGrammarFile { + name: string + /** Path under the downloads origin, e.g. \`/downloads/grammars/python-1.0.0/…\`. */ + url: string + bytes: number + sha256: string +} + +export interface PinnedGrammarPack { + name: string + version: string + /** The \`SastLanguage\` this pack enables. */ + language: string + runtime: { package: string; version: string } + grammar: { package: string; version: string } + files: PinnedGrammarFile[] +} + +export const PINNED_GRAMMAR_PACKS: readonly PinnedGrammarPack[] = ${JSON.stringify(manifestPacks, null, 2) + .split('\n') + .join('\n')} + +/** Pack names this CLI build knows how to install. */ +export const GRAMMAR_PACK_NAMES: readonly string[] = PINNED_GRAMMAR_PACKS.map((pack) => pack.name) + +export function pinnedGrammarPack(name: string): PinnedGrammarPack | undefined { + return PINNED_GRAMMAR_PACKS.find((pack) => pack.name === name) +} +` +await writeFile(join(packageDir, 'src', 'grammar-pack-manifest.ts'), pin, 'utf8') + +for (const pack of manifestPacks) { + const total = pack.files.reduce((sum, file) => sum + file.bytes, 0) + process.stdout.write(`grammar pack ${pack.name}-${pack.version}: ${pack.files.length} files, ${total} bytes\n`) +} diff --git a/packages/cli/scripts/grammar-pack-sources.mjs b/packages/cli/scripts/grammar-pack-sources.mjs new file mode 100644 index 0000000..1ebf4be --- /dev/null +++ b/packages/cli/scripts/grammar-pack-sources.mjs @@ -0,0 +1,58 @@ +/** + * What a grammar pack contains, and where its bytes come from. + * + * A pack is the tree-sitter machinery the CLI deliberately does NOT ship: the + * `web-tree-sitter` runtime plus one compiled grammar. Together they are ~722 KB + * for Python alone, against a 1 MB budget for the entire CLI tarball — which is + * why the hand-written JS parser exists and why this is a separate, opt-in + * download rather than a dependency. + * + * Every source is a file already pinned in the workspace lockfile at an exact + * version (no `^`). The pack therefore has no resolution step of its own: the + * bytes published here are the bytes the hosted audit loads out of + * `node_modules`, which is what makes the two paths comparable at all. + */ + +/** + * Pack version, bumped independently of the CLI. + * + * A pack is immutable once published, exactly like a CLI tarball: changing what + * `python-1.0.0` means would invalidate every sha256 pinned in an already + * released CLI. New runtime or grammar bytes require a new version here. + */ +export const GRAMMAR_PACK_VERSION = '1.0.0' + +/** Runtime and grammar provenance, recorded so a pack can be traced to a lockfile entry. */ +export const GRAMMAR_PACK_PROVENANCE = { + runtime: { package: 'web-tree-sitter', version: '0.22.6' }, + grammar: { package: 'tree-sitter-wasms', version: '0.1.11' }, +} + +/** + * The packs this repository publishes. + * + * `language` is the {@link SastLanguage} the pack enables. `files` are copied + * byte-for-byte; nothing is recompiled, minified or repackaged, so a reviewer + * can diff a published artifact against `node_modules` directly. + */ +export const GRAMMAR_PACKS = [ + { + name: 'python', + language: 'python', + files: [ + { name: 'tree-sitter.js', source: ['web-tree-sitter', 'tree-sitter.js'] }, + { name: 'tree-sitter.wasm', source: ['web-tree-sitter', 'tree-sitter.wasm'] }, + { name: 'tree-sitter-python.wasm', source: ['tree-sitter-wasms', 'out', 'tree-sitter-python.wasm'] }, + ], + }, +] + +/** Directory name a pack is published under, e.g. `python-1.0.0`. */ +export function packDirectoryName(pack) { + return `${pack.name}-${GRAMMAR_PACK_VERSION}` +} + +/** Public URL path for one file in a pack. */ +export function packFileUrl(pack, fileName) { + return `/downloads/grammars/${packDirectoryName(pack)}/${fileName}` +} diff --git a/packages/cli/scripts/verify-grammar-packs.mjs b/packages/cli/scripts/verify-grammar-packs.mjs new file mode 100644 index 0000000..0c67032 --- /dev/null +++ b/packages/cli/scripts/verify-grammar-packs.mjs @@ -0,0 +1,116 @@ +/** + * Gate: the site may not advertise a grammar pack it is not serving, and the + * CLI may not ship a digest that no published artifact hashes to. + * + * Runs in the root `build` chain beside `cli:artifact:verify`. A checksum alone + * would only prove the published file is internally consistent; this also + * re-reads the upstream bytes out of `node_modules` and compares them, so a + * pack cannot silently diverge from the runtime and grammar the hosted audit + * loads. That equality is the entire basis for calling the two paths the same + * analysis. + */ +import { createHash } from 'node:crypto' +import { readFile } from 'node:fs/promises' +import { dirname, join, resolve } from 'node:path' +import { fileURLToPath } from 'node:url' +import { + GRAMMAR_PACKS, + GRAMMAR_PACK_PROVENANCE, + GRAMMAR_PACK_VERSION, + packDirectoryName, + packFileUrl, +} from './grammar-pack-sources.mjs' + +const scriptDir = dirname(fileURLToPath(import.meta.url)) +const packageDir = resolve(scriptDir, '..') +const repoRoot = resolve(packageDir, '../..') + +function sha256(bytes) { + return createHash('sha256').update(bytes).digest('hex') +} + +export async function verifyGrammarPacks({ + grammarDir = join(repoRoot, 'public', 'downloads', 'grammars'), + moduleDir = join(repoRoot, 'node_modules'), + pinPath = join(packageDir, 'src', 'grammar-pack-manifest.ts'), +} = {}) { + const manifestPacks = [] + + for (const pack of GRAMMAR_PACKS) { + const directoryName = packDirectoryName(pack) + const packDir = join(grammarDir, directoryName) + const files = [] + + for (const file of pack.files) { + let published + try { + published = await readFile(join(packDir, file.name)) + } catch (error) { + if (error.code === 'ENOENT') { + throw new Error( + `grammar pack ${directoryName} is missing ${file.name}; run pnpm grammars:release`, + ) + } + throw error + } + + // The published byte must be the byte the hosted audit loads. Comparing + // digests of the published file against itself would prove nothing. + const upstream = await readFile(join(moduleDir, ...file.source)) + if (!published.equals(upstream)) { + throw new Error( + `grammar pack ${directoryName}/${file.name} does not match ${file.source.join('/')} in node_modules; ` + + 'bump GRAMMAR_PACK_VERSION and run pnpm grammars:release', + ) + } + + const digest = sha256(published) + const sidecar = await readFile(`${join(packDir, file.name)}.sha256`, 'utf8') + if (sidecar !== `${digest} ${file.name}\n`) { + throw new Error(`grammar pack ${directoryName}/${file.name}.sha256 does not match its artifact`) + } + files.push({ name: file.name, url: packFileUrl(pack, file.name), bytes: published.length, sha256: digest }) + } + + manifestPacks.push({ + name: pack.name, + version: GRAMMAR_PACK_VERSION, + language: pack.language, + runtime: GRAMMAR_PACK_PROVENANCE.runtime, + grammar: GRAMMAR_PACK_PROVENANCE.grammar, + files, + }) + } + + const manifestPath = join(grammarDir, 'codetruss-grammars-latest.json') + const manifest = await readFile(manifestPath, 'utf8') + const expectedManifest = `${JSON.stringify({ packs: manifestPacks }, null, 2)}\n` + if (manifest !== expectedManifest) { + throw new Error('codetruss-grammars-latest.json does not match the published packs; run pnpm grammars:release') + } + + // The CLI's compiled-in pin is the security boundary. If it disagrees with the + // published artifact, either every install fails closed or — worse, if the pin + // were stale in the other direction — the CLI would accept bytes nobody + // reviewed. Neither may reach a build. + const pin = await readFile(pinPath, 'utf8') + for (const pack of manifestPacks) { + for (const file of pack.files) { + if (!pin.includes(`"sha256": "${file.sha256}"`)) { + throw new Error( + `src/grammar-pack-manifest.ts does not pin ${pack.name}-${pack.version}/${file.name}; ` + + 'run pnpm grammars:release', + ) + } + } + } + + return manifestPacks +} + +if (process.argv[1] && resolve(process.argv[1]) === resolve(fileURLToPath(import.meta.url))) { + const packs = await verifyGrammarPacks() + for (const pack of packs) { + process.stdout.write(`grammar pack ${pack.name}-${pack.version}: verified ${pack.files.length} artifacts\n`) + } +} diff --git a/packages/cli/src/cli.ts b/packages/cli/src/cli.ts index 6ae1e3a..beb9d5b 100644 --- a/packages/cli/src/cli.ts +++ b/packages/cli/src/cli.ts @@ -52,6 +52,7 @@ import { revokeVerifyCommands, trustVerifyCommands, verifyCommandTrustStatus } f import { CLI_VERSION } from './version.js' import { assertLocalEvidencePathsIgnored, ensureLocalEvidenceProtected } from './local-evidence.js' import { guidedSetup } from './setup.js' +import { runGrammarsCommand } from './grammar-command.js' interface Parsed { command: string; positionals: string[]; values: Map; booleans: Set; agent: string[] } @@ -77,6 +78,7 @@ const COMMAND_OPTION_SCHEMAS: Readonly> = { 'verify-policy': { maxPositionals: 1, agent: 'forbidden' }, sync: { booleans: ['dry-run'], maxPositionals: 1, agent: 'forbidden' }, hooks: { maxPositionals: 2, agent: 'forbidden' }, + grammars: { maxPositionals: 2, agent: 'forbidden' }, } interface EvidenceTarget { @@ -314,6 +316,7 @@ Usage: codetruss auth login|status|logout codetruss verify-policy [status|trust|trust-key|revoke] codetruss hooks install|status|doctor|uninstall [pre-commit|claude|codex|all] + codetruss grammars list|status|install|uninstall [python] Exit codes: PASS=0, REVIEW_REQUIRED=1, FAILED=2, usage/environment=3.` } @@ -713,6 +716,12 @@ async function main(argv = process.argv.slice(2)): Promise { } throw new Error('auth requires login, status, or logout') } + // Grammar packs live in the user's data directory, not a repository, so this + // must resolve before the repo-root lookup below — installing a pack from + // outside a git checkout is a legitimate thing to do. + if (parsed.command === 'grammars') { + return runGrammarsCommand(parsed.positionals[0] ?? 'status', parsed.positionals[1]) + } const root = findRepoRoot() if (parsed.command === 'setup') { if (parsed.positionals.length || parsed.agent.length) throw new Error('setup does not accept positional arguments or a command after --') diff --git a/packages/cli/src/grammar-command.ts b/packages/cli/src/grammar-command.ts new file mode 100644 index 0000000..abe76b9 --- /dev/null +++ b/packages/cli/src/grammar-command.ts @@ -0,0 +1,103 @@ +import { PINNED_GRAMMAR_PACKS } from './grammar-pack-manifest.js' +import { + grammarPackDir, + inspectGrammarPack, + installGrammarPack, + resolveGrammarOrigin, + uninstallGrammarPack, +} from './grammar-pack.js' + +/** + * `codetruss grammars` — the only surface that downloads anything at analysis + * time's expense but never during analysis itself. + * + * Installation is a separate, explicit act for two reasons. It is a network + * operation, and a tool that promises local-first analysis must not reach out + * mid-review; and it puts executable code on the machine, which is a decision a + * person makes, not a side effect of running a scan. Nothing here is invoked + * implicitly, and no other command falls back to it. + */ + +function packSummary(bytes: number): string { + return `${(bytes / 1024).toFixed(0)} KB` +} + +export async function runGrammarsCommand( + action: string, + name: string | undefined, + write: (text: string) => void = (text) => process.stdout.write(text), + env: NodeJS.ProcessEnv = process.env, +): Promise { + if (action === 'list') { + write('Available grammar packs:\n') + for (const pack of PINNED_GRAMMAR_PACKS) { + const bytes = pack.files.reduce((sum, file) => sum + file.bytes, 0) + write( + ` ${pack.name}-${pack.version} ${packSummary(bytes)} ` + + `${pack.runtime.package}@${pack.runtime.version} + ${pack.grammar.package}@${pack.grammar.version}\n`, + ) + } + write(`\nInstall with: codetruss grammars install ${PINNED_GRAMMAR_PACKS[0]?.name ?? 'python'}\n`) + return 0 + } + + if (action === 'status') { + let allHealthy = true + for (const pack of PINNED_GRAMMAR_PACKS) { + const state = await inspectGrammarPack(pack.name, env) + if (state.status === 'verified') { + write(`${pack.name}-${pack.version}: installed and verified\n ${state.dir}\n`) + } else if (state.status === 'absent') { + allHealthy = false + write( + `${pack.name}-${pack.version}: not installed\n` + + ` ${pack.language} is skipped locally and disclosed as such on every receipt.\n` + + ` Install with: codetruss grammars install ${pack.name}\n`, + ) + } else { + allHealthy = false + // A failed pack is louder than a missing one on purpose: absent is a + // choice, failed means the bytes on disk are not what this CLI published. + write( + `${pack.name}-${pack.version}: FAILED VERIFICATION — not loaded\n` + + ` ${state.reason}\n` + + ` ${state.dir}\n` + + ` Reinstall with: codetruss grammars install ${pack.name}\n`, + ) + } + } + return allHealthy ? 0 : 1 + } + + if (action === 'install') { + if (!name) throw new Error(`grammars install requires a pack name (${PINNED_GRAMMAR_PACKS.map((pack) => pack.name).join(', ')})`) + const origin = resolveGrammarOrigin(env.CODETRUSS_DEV_GRAMMAR_ORIGIN) + const result = await installGrammarPack(name, env) + if (result.alreadyInstalled) { + write(`${result.pack.name}-${result.pack.version} is already installed and verified.\n ${result.dir}\n`) + return 0 + } + write( + `Installed ${result.pack.name}-${result.pack.version} (${packSummary(result.bytes)}) from ${origin}.\n` + + ` ${result.dir}\n` + + ` ${result.pack.runtime.package}@${result.pack.runtime.version}, ` + + `${result.pack.grammar.package}@${result.pack.grammar.version}\n` + + ` Every artifact matched the SHA-256 pinned in this CLI, and is re-checked on each load.\n` + + ` ${result.pack.language} now runs the full security rule pack locally.\n`, + ) + return 0 + } + + if (action === 'uninstall') { + if (!name) throw new Error('grammars uninstall requires a pack name') + const result = await uninstallGrammarPack(name, env) + write( + result.removed + ? `Removed ${result.pack.name}-${result.pack.version}. ${result.pack.language} is skipped locally again.\n` + : `${result.pack.name}-${result.pack.version} was not installed (${grammarPackDir(result.pack, env)}).\n`, + ) + return 0 + } + + throw new Error('grammars requires list, status, install, or uninstall') +} diff --git a/packages/cli/src/grammar-pack-manifest.ts b/packages/cli/src/grammar-pack-manifest.ts new file mode 100644 index 0000000..1ab907b --- /dev/null +++ b/packages/cli/src/grammar-pack-manifest.ts @@ -0,0 +1,69 @@ +/** + * Pinned grammar-pack digests. GENERATED by scripts/build-grammar-packs.mjs. + * + * Do not edit by hand. These digests are what `codetruss grammars install` + * checks a download against, and what every subsequent load re-checks on disk. + * A pack whose bytes do not hash to exactly these values is never loaded, and + * the run discloses Python as skipped instead. + */ + +export interface PinnedGrammarFile { + name: string + /** Path under the downloads origin, e.g. `/downloads/grammars/python-1.0.0/…`. */ + url: string + bytes: number + sha256: string +} + +export interface PinnedGrammarPack { + name: string + version: string + /** The `SastLanguage` this pack enables. */ + language: string + runtime: { package: string; version: string } + grammar: { package: string; version: string } + files: PinnedGrammarFile[] +} + +export const PINNED_GRAMMAR_PACKS: readonly PinnedGrammarPack[] = [ + { + "name": "python", + "version": "1.0.0", + "language": "python", + "runtime": { + "package": "web-tree-sitter", + "version": "0.22.6" + }, + "grammar": { + "package": "tree-sitter-wasms", + "version": "0.1.11" + }, + "files": [ + { + "name": "tree-sitter.js", + "url": "/downloads/grammars/python-1.0.0/tree-sitter.js", + "bytes": 74197, + "sha256": "ddcacb69cd26c07322c51b798a63805fd99c272177c9633a978f3886358ca070" + }, + { + "name": "tree-sitter.wasm", + "url": "/downloads/grammars/python-1.0.0/tree-sitter.wasm", + "bytes": 188635, + "sha256": "29208e71028ab0c11dfcc941255075aad75545394467aa22d817a6356714090f" + }, + { + "name": "tree-sitter-python.wasm", + "url": "/downloads/grammars/python-1.0.0/tree-sitter-python.wasm", + "bytes": 476105, + "sha256": "9056d0fb0c337810d019fae350e8167786119da98f0f282aceae7ab89ee8253b" + } + ] + } +] + +/** Pack names this CLI build knows how to install. */ +export const GRAMMAR_PACK_NAMES: readonly string[] = PINNED_GRAMMAR_PACKS.map((pack) => pack.name) + +export function pinnedGrammarPack(name: string): PinnedGrammarPack | undefined { + return PINNED_GRAMMAR_PACKS.find((pack) => pack.name === name) +} diff --git a/packages/cli/src/grammar-pack.ts b/packages/cli/src/grammar-pack.ts new file mode 100644 index 0000000..38a932c --- /dev/null +++ b/packages/cli/src/grammar-pack.ts @@ -0,0 +1,416 @@ +import { createHash } from 'node:crypto' +import { constants as fsConstants, type Stats } from 'node:fs' +import { chmod, lstat, mkdir, mkdtemp, open, readdir, rename, rm } from 'node:fs/promises' +import { homedir } from 'node:os' +import { dirname, isAbsolute, join, win32 } from 'node:path' +import { Readable } from 'node:stream' +import { pipeline } from 'node:stream/promises' +import { createWriteStream } from 'node:fs' +import { PINNED_GRAMMAR_PACKS, pinnedGrammarPack, type PinnedGrammarPack } from './grammar-pack-manifest.js' + +/** + * Opt-in tree-sitter grammar packs. + * + * The CLI ships a hand-written JS-family parser because the WASM grammars are + * several times its entire release budget. That trade is the right one for the + * common case, but it is the reason Python has been disclosed as a hosted-only + * gap. A pack closes that gap for people who want it, WITHOUT putting the bytes + * in the tarball: they are downloaded once, on an explicit command, into the + * user's data directory. + * + * The security position is deliberate and narrow. This module downloads code + * that will later be executed in the user's process, so it is not enough to + * fetch over TLS and hope: + * + * - every artifact is pinned to an exact sha256 compiled into this binary + * ({@link PINNED_GRAMMAR_PACKS}), so the origin cannot choose what arrives; + * - the digest is checked on download AND re-checked on every load, because a + * file verified in March is not a file verified today; + * - the bytes that are hashed are the bytes that are RETURNED, and the loader + * executes those buffers rather than re-opening the path. Hashing by path and + * then executing by path is a time-of-check/time-of-use gap wide enough to + * drive a `rename(2)` loop through: an attacker who can write in the pack + * directory swaps the artifact between the two reads and gets arbitrary code + * execution while every digest check still passes. There is exactly one read + * of each artifact per load, from one file descriptor; + * - artifacts are opened `O_NOFOLLOW` and every directory this CLI creates is + * `lstat`ed, so a symlinked artifact or pack root cannot redirect either the + * verification or the install somewhere the digest never covered; + * - the only origin is the CodeTruss downloads host — never a third-party CDN, + * never a redirect off-origin; + * - any failure — absent, short, over-long, wrong digest, unreadable — resolves + * to "pack unavailable", and the run discloses Python as skipped. There is no + * degraded mode in which unverified bytes are executed. + */ + +const PRODUCTION_DOWNLOAD_ORIGIN = 'https://codetruss.com' +export const DEV_GRAMMAR_ORIGIN_ENV = 'CODETRUSS_DEV_GRAMMAR_ORIGIN' + +/** + * Where a pack is fetched from. + * + * The override exists so tests and local development can serve artifacts from a + * loopback fixture. It is restricted to loopback for the same reason the sync + * origin is: an environment variable that could point the downloader at an + * arbitrary host would hand an attacker with environment access the ability to + * choose which bytes get executed — and the digest pin is the only thing that + * would then be standing in the way. + */ +export function resolveGrammarOrigin(explicitDevOrigin = process.env[DEV_GRAMMAR_ORIGIN_ENV]): string { + if (explicitDevOrigin === undefined || explicitDevOrigin.trim() === '') return PRODUCTION_DOWNLOAD_ORIGIN + let parsed: URL + try { + parsed = new URL(explicitDevOrigin) + } catch { + throw new Error(`${DEV_GRAMMAR_ORIGIN_ENV} must be an http(s) loopback origin`) + } + const loopbackHosts = new Set(['localhost', '127.0.0.1', '[::1]', '::1']) + const hasOnlyOrigin = parsed.pathname === '/' && !parsed.search && !parsed.hash && !parsed.username && !parsed.password + if (!['http:', 'https:'].includes(parsed.protocol) || !loopbackHosts.has(parsed.hostname) || !hasOnlyOrigin) { + throw new Error(`${DEV_GRAMMAR_ORIGIN_ENV} must be an http(s) loopback origin without credentials, path, query, or fragment`) + } + return parsed.origin +} + +/** + * The user-level data directory, XDG on POSIX and LOCALAPPDATA on Windows. + * + * Packs are DATA, not config: they are reproducible downloads a user can delete + * without losing anything they authored, which is exactly the XDG data/config + * split. Windows has no XDG, and its nearest equivalent for machine-local, + * non-roaming data is LOCALAPPDATA — roaming would copy 700 KB of WASM to every + * machine the profile touches. + */ +export function grammarDataDir(env: NodeJS.ProcessEnv = process.env): string { + if (process.platform === 'win32') { + // The win32 flavor explicitly, rather than the platform-default `join`. + // `C:\Users\…` is not an absolute path to the POSIX variant, so a bare + // `isAbsolute` here means "correct on Windows, and unverifiable anywhere + // else" — which is how a Windows-only path bug survives a green CI run. + const localAppData = env.LOCALAPPDATA?.trim() + if (localAppData) { + if (!win32.isAbsolute(localAppData)) throw new Error('LOCALAPPDATA must be an absolute path') + return win32.join(localAppData, 'codetruss', 'grammars') + } + return win32.join(homedir(), 'AppData', 'Local', 'codetruss', 'grammars') + } + const configured = env.XDG_DATA_HOME?.trim() + if (configured && !isAbsolute(configured)) { + throw new Error('XDG_DATA_HOME must be an absolute user data path') + } + return join(configured || join(homedir(), '.local', 'share'), 'codetruss', 'grammars') +} + +/** On-disk directory for one pack version, mirroring its published URL path. */ +export function grammarPackDir(pack: PinnedGrammarPack, env: NodeJS.ProcessEnv = process.env): string { + return join(grammarDataDir(env), `${pack.name}-${pack.version}`) +} + +/** + * Read one artifact and hash what was read — never re-open the path. + * + * The whole artifact is held in memory on purpose. Streaming the hash and then + * letting the loader re-read the file is the bug this function exists to make + * impossible: the returned Buffer is the only thing that is ever executed, so + * "verified" and "executed" are the same bytes by construction rather than by + * the hope that nothing rewrote the file in between. 738 KB is a cheap price. + * + * `O_NOFOLLOW` refuses a symlinked artifact atomically, and `O_NONBLOCK` keeps a + * FIFO left in the artifact's place from parking the process on `open`. The size + * and type come from `fstat` on the open descriptor rather than from a second + * `stat` of the name, so they describe the file that was actually read. + */ +async function readVerifiedArtifact( + path: string, + expected: { name: string; bytes: number; sha256: string }, +): Promise<{ bytes: Buffer } | { reason: string }> { + const flags = fsConstants.O_RDONLY | (fsConstants.O_NOFOLLOW ?? 0) | (fsConstants.O_NONBLOCK ?? 0) + let handle + try { + handle = await open(path, flags) + } catch (error) { + const code = (error as NodeJS.ErrnoException).code + if (code === 'ENOENT') return { reason: `${expected.name} is missing from the installed pack` } + if (code === 'ELOOP') return { reason: `${expected.name} is a symbolic link, not a regular file` } + return { reason: `${expected.name} is unreadable: ${(error as Error).message}` } + } + try { + const info = await handle.stat() + if (!info.isFile()) return { reason: `${expected.name} is not a regular file` } + // Size first: it bounds the read, so a padded artifact is rejected before + // this process commits to holding it. + if (info.size !== expected.bytes) { + return { reason: `${expected.name} is ${info.size} bytes, expected ${expected.bytes}` } + } + let bytes: Buffer + try { + bytes = await handle.readFile() + } catch (error) { + return { reason: `${expected.name} could not be read: ${(error as Error).message}` } + } + // A file that grew between fstat and read would hash differently anyway, but + // saying so by length is a clearer reason than a digest mismatch. + if (bytes.length !== expected.bytes) { + return { reason: `${expected.name} is ${bytes.length} bytes, expected ${expected.bytes}` } + } + const digest = createHash('sha256').update(bytes).digest('hex') + if (digest !== expected.sha256) { + return { reason: `${expected.name} has digest ${digest}, expected ${expected.sha256}` } + } + return { bytes } + } finally { + await handle.close().catch(() => {}) + } +} + +/** + * Whether a directory this CLI created is still one it can trust. + * + * `mkdir`'s `mode` only applies to directories it actually creates, so a root + * pre-created loose stays loose — and POSIX write permission on the PARENT of a + * pack is enough to `rename` the pack away and substitute one, no permission on + * the files required. A symlinked root is worse still: it redirects the install + * and every later read somewhere the pinned digests were never computed over. + * + * The ownership and mode checks are POSIX-only; Windows ACLs are not expressible + * in `st_mode` and pretending otherwise would reject every Windows install. + */ +function directoryTrustProblem(info: Stats, path: string): string | undefined { + if (info.isSymbolicLink()) return `${path} is a symbolic link, not a real directory` + if (!info.isDirectory()) return `${path} is not a directory` + if (typeof process.getuid !== 'function') return undefined + if (info.uid !== process.getuid()) return `${path} is owned by uid ${info.uid}, not by this user` + // WRITABLE, not merely readable. A world-readable root leaks nothing that is + // not already published, and failing a load over it would be a dead end for no + // security gain; a writable one is what lets a pack be renamed away and + // replaced without any permission on the files themselves. + if ((info.mode & 0o022) !== 0) { + return `${path} is writable by group or other (mode ${(info.mode & 0o777).toString(8)})` + } + return undefined +} + +/** + * The directories this CLI creates and therefore gets to have opinions about. + * + * Deliberately not the whole path: the user's data home is theirs, and on macOS + * `os.tmpdir()` is already a symlink, so demanding a link-free ancestry would + * reject ordinary systems while proving nothing. What matters is that the two + * components CodeTruss makes — and the pack directory inside them — are real, + * ours, and not writable by anyone else. + */ +function codetrussOwnedRoots(env: NodeJS.ProcessEnv): string[] { + const root = grammarDataDir(env) + return [dirname(root), root] +} + +export type GrammarPackState = + /** No pack directory on disk. The user has never installed it, or removed it. */ + | { status: 'absent'; pack: PinnedGrammarPack } + /** + * Present and every artifact matches its pinned digest. + * + * `contents` holds the exact buffers that were hashed, keyed by artifact name. + * The loader executes these and never re-opens the paths — that identity is + * what makes "nothing unverified was executed" a fact rather than a wish. + */ + | { status: 'verified'; pack: PinnedGrammarPack; dir: string; contents: ReadonlyMap } + /** Present but not trustworthy. Never loaded; the reason is disclosed verbatim. */ + | { status: 'failed'; pack: PinnedGrammarPack; dir: string; reason: string } + +/** + * Check an installed pack against the digests compiled into this binary. + * + * Called before every load, not only at install time. A pack sits in a + * user-writable directory for months; re-verifying is the difference between + * "these bytes were trustworthy when downloaded" and "these bytes are + * trustworthy now". + */ +export async function inspectGrammarPack( + name: string, + env: NodeJS.ProcessEnv = process.env, +): Promise { + const pack = pinnedGrammarPack(name) + if (!pack) throw new Error(`unknown grammar pack ${name}; expected ${PINNED_GRAMMAR_PACKS.map((entry) => entry.name).join(', ')}`) + const dir = grammarPackDir(pack, env) + + // Absence is decided by the pack directory alone, so a user who never + // installed anything is told "not installed" rather than handed a complaint + // about a directory they have no reason to care about. + try { + await lstat(dir) + } catch (error) { + if ((error as NodeJS.ErrnoException).code === 'ENOENT') return { status: 'absent', pack } + return { status: 'failed', pack, dir, reason: `pack directory is unreadable: ${(error as Error).message}` } + } + + for (const path of [...codetrussOwnedRoots(env), dir]) { + let info: Stats + try { + info = await lstat(path) + } catch (error) { + return { status: 'failed', pack, dir, reason: `${path} is unreadable: ${(error as Error).message}` } + } + const problem = directoryTrustProblem(info, path) + if (problem) return { status: 'failed', pack, dir, reason: problem } + } + + const contents = new Map() + for (const file of pack.files) { + const read = await readVerifiedArtifact(join(dir, file.name), file) + if ('reason' in read) return { status: 'failed', pack, dir, reason: read.reason } + contents.set(file.name, read.bytes) + } + + // An extra file in the pack directory is not loaded, but it does mean the + // directory is not what this CLI published, and saying so is cheaper than + // explaining later why a tampered install looked healthy. + let present: string[] + try { + present = (await readdir(dir)).sort() + } catch (error) { + return { status: 'failed', pack, dir, reason: `pack directory is unreadable: ${(error as Error).message}` } + } + const expected = pack.files.map((file) => file.name).sort() + if (present.join('\n') !== expected.join('\n')) { + return { status: 'failed', pack, dir, reason: `pack directory holds unexpected files: ${present.join(', ')}` } + } + + return { status: 'verified', pack, dir, contents } +} + +/** + * Download one artifact into `target`, verifying as the bytes arrive. + * + * The pinned length is enforced DURING the stream rather than after it, so a + * hostile or broken origin cannot fill the user's disk before the digest gets a + * chance to disagree. + */ +async function downloadVerified(url: string, target: string, expected: { bytes: number; sha256: string }): Promise { + const response = await fetch(url, { redirect: 'error', headers: { accept: 'application/octet-stream' } }) + if (!response.ok) throw new Error(`${url} responded ${response.status}`) + if (!response.body) throw new Error(`${url} returned no body`) + + const hash = createHash('sha256') + let received = 0 + const measured = new Readable({ read() {} }) + const source = Readable.fromWeb(response.body as Parameters[0]) + source.on('data', (chunk: Buffer) => { + received += chunk.length + if (received > expected.bytes) { + measured.destroy(new Error(`${url} sent more than the pinned ${expected.bytes} bytes`)) + source.destroy() + return + } + hash.update(chunk) + measured.push(chunk) + }) + source.on('end', () => measured.push(null)) + source.on('error', (error: Error) => measured.destroy(error)) + + await pipeline(measured, createWriteStream(target, { mode: 0o600 })) + + if (received !== expected.bytes) throw new Error(`${url} sent ${received} bytes, expected ${expected.bytes}`) + const digest = hash.digest('hex') + if (digest !== expected.sha256) throw new Error(`${url} has digest ${digest}, expected ${expected.sha256}`) +} + +/** + * Make one of this CLI's own directories safe to install through, or refuse. + * + * Install is the one moment the CLI may FIX what it finds rather than only + * report it, so a root that is not already the 0700 `mkdir` asked for is + * tightened to it — a dead end is a bad answer to a condition one `chmod` + * resolves, and a root left 0755 by an earlier version is the common case. A + * symlink or a directory owned by someone else is refused outright: both mean + * the install would land somewhere this process does not control, and no mode + * bit makes that acceptable. + */ +async function secureExistingRoot(path: string): Promise { + const info = await lstat(path) + if (info.isSymbolicLink() || !info.isDirectory()) { + throw new Error(`${path} is not a real directory; refusing to install through it`) + } + if (typeof process.getuid !== 'function') return + if (info.uid !== process.getuid()) { + throw new Error(`${path} is owned by uid ${info.uid}, not by this user; refusing to install into it`) + } + if ((info.mode & 0o077) !== 0) await chmod(path, 0o700) +} + +export interface GrammarInstallResult { + pack: PinnedGrammarPack + dir: string + /** True when a verified copy was already present and nothing was downloaded. */ + alreadyInstalled: boolean + bytes: number +} + +/** + * Install a pack: download every artifact to a scratch directory, verify each, + * and only then move the whole thing into place. + * + * Staging matters. A per-file install that fails halfway leaves a directory that + * is neither absent nor verified, and the next run has to reason about a partial + * state. Assembling in scratch means the pack directory only ever appears + * complete and verified. + */ +export async function installGrammarPack( + name: string, + env: NodeJS.ProcessEnv = process.env, +): Promise { + const existing = await inspectGrammarPack(name, env) + const pack = existing.pack + const bytes = pack.files.reduce((sum, file) => sum + file.bytes, 0) + if (existing.status === 'verified') { + return { pack, dir: existing.dir, alreadyInstalled: true, bytes } + } + + const origin = resolveGrammarOrigin(env[DEV_GRAMMAR_ORIGIN_ENV]) + const root = grammarDataDir(env) + await mkdir(root, { recursive: true, mode: 0o700 }) + // `mkdir` said nothing about a directory that already existed, and this is the + // one moment the CLI is allowed to fix that rather than only report it. + for (const path of codetrussOwnedRoots(env)) await secureExistingRoot(path) + const scratch = await mkdtemp(join(root, `.${pack.name}-${pack.version}.`)) + try { + for (const file of pack.files) { + await downloadVerified(`${origin}${file.url}`, join(scratch, file.name), file) + } + const target = grammarPackDir(pack, env) + // A failed or partial previous install is replaced wholesale rather than + // patched, so the result is exactly what this CLI expects or nothing. + await rm(target, { recursive: true, force: true }) + await rename(scratch, target) + const verified = await inspectGrammarPack(name, env) + if (verified.status !== 'verified') { + const reason = verified.status === 'failed' ? verified.reason : 'the installed pack disappeared' + throw new Error(`installed pack failed verification: ${reason}`) + } + return { pack, dir: verified.dir, alreadyInstalled: false, bytes } + } catch (error) { + await rm(scratch, { recursive: true, force: true }).catch(() => {}) + throw error + } +} + +/** Remove an installed pack. Absent is success — the requested end state holds. */ +export async function uninstallGrammarPack( + name: string, + env: NodeJS.ProcessEnv = process.env, +): Promise<{ pack: PinnedGrammarPack; removed: boolean }> { + const pack = pinnedGrammarPack(name) + if (!pack) throw new Error(`unknown grammar pack ${name}`) + const dir = grammarPackDir(pack, env) + // `lstat`, so a symlink standing in for the pack directory counts as present + // and gets removed, rather than reporting "not installed" and leaving the + // redirect in place for the next install to write through. + try { + await lstat(dir) + } catch (error) { + if ((error as NodeJS.ErrnoException).code === 'ENOENT') return { pack, removed: false } + throw error + } + await rm(dir, { recursive: true, force: true }) + return { pack, removed: true } +} diff --git a/packages/cli/src/grammar-parser.ts b/packages/cli/src/grammar-parser.ts new file mode 100644 index 0000000..885510b --- /dev/null +++ b/packages/cli/src/grammar-parser.ts @@ -0,0 +1,212 @@ +import { createRequire } from 'node:module' +import { join } from 'node:path' +import { pathToFileURL } from 'node:url' +import { compileFunction } from 'node:vm' +import type { ParsedTree, SastLanguage, SastParser, SyntaxNode } from '@codetruss/analyzer-engine/security/lang' +import { MAX_SOURCE_BYTES } from '@codetruss/analyzer-engine/security/lang' +import { inspectGrammarPack, type GrammarPackState } from './grammar-pack.js' + +/** + * Turn a verified grammar pack into the {@link SastParser} the engine expects. + * + * This is the same `web-tree-sitter` runtime, the same compiled grammar and the + * same load sequence the hosted audit uses — deliberately, because that identity + * is the whole claim: with a pack installed, Python is not analyzed by a local + * approximation of the hosted pass, it is analyzed by the hosted pass's own + * machinery. The only difference is where the bytes were resolved from. + * + * Nothing here reads the pack from disk. {@link inspectGrammarPack} performs the + * single read of each artifact and hands back the buffers it hashed; this module + * executes those buffers and nothing else. That is the point: a loader that + * hashes a path and then re-opens it to execute it has verified one file and run + * another, and the gap between the two reads is long enough — three digests and + * a `readdir` — for a `rename(2)` loop to land a hostile module in it. There is + * no path here for such a swap to reach, because there is no second read. + */ + +/** The subset of the web-tree-sitter 0.22.x surface this loader drives. */ +interface TreeSitterLanguage { readonly __brand?: never } +interface TreeSitterTree { + rootNode: SyntaxNode & { hasError: boolean } + delete(): void +} +interface TreeSitterParser { + setLanguage(language: TreeSitterLanguage): void + parse(content: string): TreeSitterTree | null +} +interface TreeSitterModule { + new(): TreeSitterParser + init(moduleOptions?: { wasmBinary?: Uint8Array; locateFile?: () => string }): Promise + Language: { load(input: string | Uint8Array): Promise } +} + +export type GrammarParserLoad = + | { status: 'verified'; parser: SastParser; languages: ReadonlySet } + | { status: 'absent' } + /** + * Why the pack is unusable, kept apart from WHAT went wrong. + * + * `digest` means the pack on disk is not what this CLI published. `runtime` + * means it is exactly what this CLI published and emscripten still could not + * start — an OOM, a Node build without the WASM features the runtime needs, a + * `MAP_FAILED` under memory pressure. Collapsing the two lets a receipt accuse + * a user's install of tampering because their machine ran out of memory, which + * is both false and unfalsifiable from the reader's side. + */ + | { status: 'failed'; kind: 'digest' | 'runtime'; reason: string } + +/** + * One tree-sitter runtime per pack directory, per process. + * + * This cache is CORRECTNESS, not an optimization. `web-tree-sitter`'s emscripten + * glue reassigns `module.exports = Module` from its Node branch once the runtime + * initializes, which overwrites its own entry in Node's require cache. A second + * `require()` of the same file therefore hands back the emscripten Module object + * instead of the Parser class, and `Parser.init` is suddenly not a function. + * + * A single review loads the pack TWICE — once for the baseline tree and once for + * the final tree — so without this the second analysis of every run would fail + * to load the grammar and silently report Python as unanalyzable. Requiring the + * runtime exactly once per process also matches the hosted loader, which reuses + * one Parser instance because a fresh one never returns its WASM working memory. + * + * Reusing the parser across loads is sound only because the digests are pinned + * CONSTANTS: any two runs that reach `verified` did so over byte-identical + * artifacts, so the cached parser cannot be older than what was just verified in + * any way that matters. Verification itself is deliberately NOT cached — + * {@link loadGrammarParser} re-inspects on every call. + */ +const runtimeCache = new Map>() + +/** + * Load a pack's parser, or explain why it is unavailable. + * + * Never throws for an unavailable pack. Absence and tampering are COVERAGE + * answers, not errors: the caller turns them into a disclosure that Python was + * skipped and why, which is the only honest outcome. Throwing here would either + * fail an otherwise clean run or, worse, invite a catch that silently continues + * as though the language had been analyzed. + */ +export async function loadGrammarParser( + name: string, + env: NodeJS.ProcessEnv = process.env, +): Promise { + let state: GrammarPackState + try { + state = await inspectGrammarPack(name, env) + } catch (error) { + return { status: 'failed', kind: 'digest', reason: (error as Error).message } + } + if (state.status === 'absent') return { status: 'absent' } + if (state.status === 'failed') return { status: 'failed', kind: 'digest', reason: state.reason } + + const language = state.pack.language as SastLanguage + const grammarFile = state.pack.files.find((file) => file.name.startsWith('tree-sitter-')) + if (!grammarFile) return { status: 'failed', kind: 'digest', reason: 'pack declares no grammar artifact' } + + let cached = runtimeCache.get(state.dir) + if (!cached) { + cached = buildParser(state, grammarFile.name, language) + runtimeCache.set(state.dir, cached) + } + const result = await cached + if ('reason' in result) return { status: 'failed', kind: 'runtime', reason: result.reason } + return { status: 'verified', parser: result.parser, languages: new Set([language]) } +} + +/** + * A name emscripten can carry around for the runtime WASM that resolves to no + * file anywhere. + * + * `locateFile` is called unconditionally at setup, so it cannot simply throw — + * but every read of its result is short-circuited by the `wasmBinary` below. A + * sentinel rather than the real on-disk path means that if a future runtime ever + * stopped honouring `wasmBinary`, the load would fail loudly instead of quietly + * reading bytes nobody verified. + */ +const IN_MEMORY_WASM_SENTINEL = '\0codetruss-verified-in-memory\0tree-sitter.wasm' + +/** + * Execute a verified buffer as a CommonJS module. + * + * `vm.compileFunction` with the CJS parameter list is what `require()` does + * internally, minus the file read — which is exactly the part that must not + * happen. The source compiled here is the Buffer that was hashed, so there is no + * window between the check and the use at all, and `filename`/`__dirname` still + * point at the pack so the module's own `require` and any stack trace read the + * way they would have. + * + * Compiling into a module object this function owns also keeps the emscripten + * `module.exports = Module` clobber out of Node's require cache entirely. + */ +function runVerifiedModule(source: Buffer, filename: string, dirname: string): unknown { + const compiled = compileFunction( + source.toString('utf8'), + ['exports', 'require', 'module', '__filename', '__dirname'], + { filename }, + ) + const shim = { exports: {} as unknown, id: filename, filename, path: dirname, loaded: false, paths: [] } + compiled(shim.exports, createRequire(pathToFileURL(filename)), shim, filename, dirname) + shim.loaded = true + return shim.exports +} + +async function buildParser( + state: Extract, + grammarFileName: string, + language: SastLanguage, +): Promise<{ parser: SastParser } | { reason: string }> { + const runtimeSource = state.contents.get('tree-sitter.js') + const runtimeWasm = state.contents.get('tree-sitter.wasm') + const grammarWasm = state.contents.get(grammarFileName) + if (!runtimeSource || !runtimeWasm || !grammarWasm) { + return { reason: 'verified pack did not carry its own bytes' } + } + + let treeSitterParser: TreeSitterParser + try { + const TreeSitter = runVerifiedModule( + runtimeSource, + join(state.dir, 'tree-sitter.js'), + state.dir, + ) as TreeSitterModule + if (typeof TreeSitter?.init !== 'function') { + return { reason: 'grammar runtime did not export a parser' } + } + // `wasmBinary` hands emscripten the verified runtime WASM directly, and + // `Language.load` takes the grammar as a `Uint8Array` — so neither WASM + // artifact is ever resolved from a path either. + await TreeSitter.init({ wasmBinary: runtimeWasm, locateFile: () => IN_MEMORY_WASM_SENTINEL }) + const grammar = await TreeSitter.Language.load(new Uint8Array(grammarWasm)) + // One parser instance, reused for every file. A fresh `new Parser()` per + // file never returns its WASM working memory, which is how the hosted path + // used to OOM large scans. + treeSitterParser = new TreeSitter() + treeSitterParser.setLanguage(grammar) + } catch (error) { + return { reason: `grammar runtime failed to load: ${(error as Error).message}` } + } + + return { + parser: { + languages: new Set([language]), + async parse(lang: SastLanguage, content: string): Promise { + if (lang !== language) return null + if (content.length > MAX_SOURCE_BYTES) return null + try { + const tree = treeSitterParser.parse(content) + if (!tree) return null + return { + rootNode: tree.rootNode, + hasError: tree.rootNode.hasError, + release: () => { + try { tree.delete() } catch {} + }, + } + } catch { + return null + } + }, + }, + } +} diff --git a/packages/cli/src/local-sast.ts b/packages/cli/src/local-sast.ts index fc2faf9..52a5460 100644 --- a/packages/cli/src/local-sast.ts +++ b/packages/cli/src/local-sast.ts @@ -1,9 +1,11 @@ import type { AnalyzerFinding, AnalyzerPass, RepoIndex } from '@codetruss/analyzer-engine' -import { scanFiles, type ScanInput } from '@codetruss/analyzer-engine/security/engine' +import { mergeSastResults, scanFiles, type ScanInput } from '@codetruss/analyzer-engine/security/engine' import { zeroDependencyJsParser } from '@codetruss/analyzer-engine/security/js-parse/index' import { mapSastFinding } from '@codetruss/analyzer-engine/security/finding-map' import { CLI_SAST_RULE_IDS } from '@codetruss/analyzer-engine/security/local-profile' -import { sastLanguageForPath } from '@codetruss/analyzer-engine/security/lang' +import { sastLanguageForPath, type SastLanguage } from '@codetruss/analyzer-engine/security/lang' +import type { SastResult } from '@codetruss/analyzer-engine/security/types' +import { loadGrammarParser } from './grammar-parser.js' /** * The CLI's local security pass. @@ -13,12 +15,20 @@ import { sastLanguageForPath } from '@codetruss/analyzer-engine/security/lang' * rule subset that has been differentially validated against the hosted parser * at zero false positives. * + * Since 0.2.40 the pass has a SECOND parser: an opt-in grammar pack the user + * installs explicitly (`codetruss grammars install python`). When present and + * verified, Python is analyzed by the hosted runtime and grammar themselves, so + * it runs the full rule pack rather than a subset — see {@link pythonRuleIds}. + * * This is NOT one of the registry analyzers. Keeping it a separate pass is what * lets the receipt state the registry count truthfully while naming this pass * and its limits alongside them. */ export const LOCAL_SAST_PASS_ID = 'local-sast' +/** The grammar pack that extends this pass beyond the JS family. */ +export const PYTHON_GRAMMAR_PACK = 'python' + /** * Declaration files (`*.d.ts`) carry no executable code, so no rule can fire in * them. Excluding them keeps the parser's coverage number honest instead of @@ -28,8 +38,8 @@ function isDeclarationFile(path: string): boolean { return /\.d\.[cm]?ts$/i.test(path) } -/** Production JS-family source the local parser can analyze. */ -export function localSastInputs(index: RepoIndex): ScanInput[] { +/** Production source in `languages`, in a deterministic order. */ +function inputsForLanguages(index: RepoIndex, languages: ReadonlySet): ScanInput[] { const inputs: ScanInput[] = [] for (const file of index.files) { if (!file.content) continue @@ -39,7 +49,7 @@ export function localSastInputs(index: RepoIndex): ScanInput[] { if (file.kind === 'vendored' || file.kind === 'generated' || file.kind === 'test') continue if (isDeclarationFile(file.path)) continue const language = sastLanguageForPath(file.path) - if (!language || !zeroDependencyJsParser.languages.has(language)) continue + if (!language || !languages.has(language)) continue inputs.push({ filePath: file.path, content: file.content }) } // Deterministic order so findings and diagnostics are identical run to run. @@ -47,63 +57,158 @@ export function localSastInputs(index: RepoIndex): ScanInput[] { return inputs } +/** Production JS-family source the local parser can analyze. */ +export function localSastInputs(index: RepoIndex): ScanInput[] { + return inputsForLanguages(index, zeroDependencyJsParser.languages) +} + +/** Production Python source, analyzable only when the grammar pack is installed. */ +export function localPythonInputs(index: RepoIndex): ScanInput[] { + return inputsForLanguages(index, new Set(['python'])) +} + +/** + * Which rules the Python scan may report: all of them. + * + * The JS-family subset ({@link CLI_SAST_RULE_IDS}) exists because the CLI parses + * JavaScript with a hand-written parser, and only rules proven to agree with + * tree-sitter on real repositories were allowed through. That reasoning does not + * transfer here. A grammar pack IS the hosted parser and the hosted grammar, so + * there is no divergence to guard against, and narrowing the pack would report + * less than the same code would receive hosted — for no precision gain. + */ +const pythonRuleIds: ReadonlySet | undefined = undefined + +/** Why Python was or was not analyzed on this run. Rendered verbatim on receipts. */ +export type PythonCoverageStatus = 'not-applicable' | 'absent' | 'verified' | 'failed' + +/** + * WHICH of the three unrelated things that all end in `failed` actually failed. + * + * `digest` — the pack on disk is not what this CLI published. + * `runtime` — the pack verified and emscripten still would not start. + * `scan` — the pack verified, loaded, and then threw partway through. + * + * Kept apart because the receipt is a signed customer-facing document and the + * three warrant different sentences. Collapsing them is how an out-of-memory + * error on the user's laptop gets published as an accusation that their install + * does not match the published digests — false, alarming, and unfalsifiable from + * the reader's side. + */ +export type PythonPackFailureKind = 'digest' | 'runtime' | 'scan' + export interface LocalSastResult { findings: AnalyzerFinding[] pass: AnalyzerPass } -export async function runLocalSast(index: RepoIndex): Promise { - const inputs = localSastInputs(index) - if (inputs.length === 0) { - return { - findings: [], - pass: { - id: LOCAL_SAST_PASS_ID, - result: { - findings: [], - complete: true, - metrics: { inputFiles: 0, filesScanned: 0, filesSkipped: 0, rules: CLI_SAST_RULE_IDS.size }, - }, - }, +const EMPTY_SCAN: SastResult = { + findings: [], + diagnostics: { + inputFiles: 0, + filesScanned: 0, + filesSkipped: 0, + degradedLanguages: [], + truncatedFiles: 0, + findingsTruncated: false, + }, +} + +export async function runLocalSast(index: RepoIndex, env: NodeJS.ProcessEnv = process.env): Promise { + const jsInputs = localSastInputs(index) + const pythonInputs = localPythonInputs(index) + + // The pack is only consulted when there is Python to analyze. A repository + // with no Python gets no disclosure about Python, because there is nothing + // there to have missed. + let pythonStatus: PythonCoverageStatus = 'not-applicable' + let pythonReason: string | undefined + let pythonFailureKind: PythonPackFailureKind | undefined + let pythonScan: SastResult = EMPTY_SCAN + let pythonError: string | undefined + + if (pythonInputs.length > 0) { + const load = await loadGrammarParser(PYTHON_GRAMMAR_PACK, env) + if (load.status === 'absent') { + pythonStatus = 'absent' + pythonReason = 'the Python grammar pack is not installed' + } else if (load.status === 'failed') { + pythonStatus = 'failed' + pythonReason = load.reason + // The loader already knows whether this was the pack or the machine. Carry + // that answer instead of re-deriving a worse one from the message. + pythonFailureKind = load.kind + } else { + try { + pythonScan = await scanFiles(pythonInputs, load.parser, { ruleIds: pythonRuleIds }) + pythonStatus = 'verified' + } catch (error) { + // A crash inside the grammar runtime is lost coverage, not a clean + // Python result. Say so rather than let an empty finding list stand in. + pythonStatus = 'failed' + pythonReason = `grammar pack scan failed: ${error instanceof Error ? error.message : String(error)}` + pythonFailureKind = 'scan' + pythonError = pythonReason + pythonScan = EMPTY_SCAN + } } } - try { - const result = await scanFiles(inputs, zeroDependencyJsParser, { ruleIds: CLI_SAST_RULE_IDS }) - const diagnostics = result.diagnostics - // A file the parser could not read is coverage lost, and the receipt has to - // say so rather than let silence read as "nothing found there". - const truncated = - diagnostics.filesSkipped > 0 || diagnostics.truncatedFiles > 0 || diagnostics.findingsTruncated - const findings = result.findings.map((finding) => ({ - ...mapSastFinding(finding), - analyzerId: LOCAL_SAST_PASS_ID, - })) - return { - findings, - pass: { - id: LOCAL_SAST_PASS_ID, - result: { - findings, - complete: !truncated && diagnostics.degradedLanguages.length === 0, - truncated, - detail: truncated - ? `${diagnostics.filesSkipped} file(s) could not be parsed locally and were not analyzed` - : undefined, - metrics: { - inputFiles: diagnostics.inputFiles, - filesScanned: diagnostics.filesScanned, - filesSkipped: diagnostics.filesSkipped, - rules: CLI_SAST_RULE_IDS.size, - }, + let jsScan: SastResult = EMPTY_SCAN + let jsError: string | undefined + if (jsInputs.length > 0) { + try { + jsScan = await scanFiles(jsInputs, zeroDependencyJsParser, { ruleIds: CLI_SAST_RULE_IDS }) + } catch (error) { + jsError = error instanceof Error ? error.message : String(error) + } + } + + const inputFiles = jsInputs.length + pythonInputs.length + const merged = mergeSastResults([jsScan, pythonScan], inputFiles) + const diagnostics = merged.diagnostics + // A file a parser could not read is coverage lost, and the receipt has to say + // so rather than let silence read as "nothing found there". + const truncated = + diagnostics.filesSkipped > 0 || diagnostics.truncatedFiles > 0 || diagnostics.findingsTruncated + const findings = merged.findings.map((finding) => ({ + ...mapSastFinding(finding), + analyzerId: LOCAL_SAST_PASS_ID, + })) + + const details = [ + jsError ? `the JavaScript pass failed: ${jsError}` : undefined, + pythonError, + truncated ? `${diagnostics.filesSkipped} file(s) could not be parsed locally and were not analyzed` : undefined, + ].filter((entry): entry is string => Boolean(entry)) + + const error = jsError ?? pythonError + + return { + findings, + pass: { + id: LOCAL_SAST_PASS_ID, + result: { + findings, + complete: !truncated && !error && diagnostics.degradedLanguages.length === 0, + truncated, + ...(details.length ? { detail: details.join('; ') } : {}), + metrics: { + inputFiles: diagnostics.inputFiles, + filesScanned: diagnostics.filesScanned, + filesSkipped: diagnostics.filesSkipped, + rules: CLI_SAST_RULE_IDS.size, + // The receipt renders its Python disclosure from these, so what a + // reader is told about coverage is derived from what actually ran on + // this machine rather than from a sentence frozen at release time. + pythonFiles: pythonInputs.length, + pythonFilesScanned: pythonScan.diagnostics.filesScanned, + pythonPackStatus: pythonStatus, + ...(pythonReason ? { pythonPackReason: pythonReason } : {}), + ...(pythonFailureKind ? { pythonPackFailureKind: pythonFailureKind } : {}), }, }, - } - } catch (error) { - const detail = error instanceof Error ? error.message : String(error) - return { - findings: [], - pass: { id: LOCAL_SAST_PASS_ID, result: { findings: [], complete: false, detail }, error: detail }, - } + ...(error ? { error } : {}), + }, } } diff --git a/packages/cli/src/receipt.ts b/packages/cli/src/receipt.ts index e18648f..4c2e955 100644 --- a/packages/cli/src/receipt.ts +++ b/packages/cli/src/receipt.ts @@ -104,12 +104,150 @@ function analysisProfileLines(receipt: Receipt): string[] { } if (current.id === 'local-registry-v1') return omittedSastProfileLines(receipt, current.id) if (current.id === 'local-registry-v2') return thirteenAnalyzerProfileLines(receipt, current.id) + if (current.id === 'local-registry-v3') return jsOnlySastProfileLines(receipt, current.id) + const python = pythonCoverage(receipt) return [ '## Analysis profile', '', `Profile: \`${current.id}\`.`, '', + `The 15 deterministic registry analyzers ran locally on this machine, plus a local security pass: the shared SAST engine — the same rules and the same source-to-sink taint tracking as the hosted audit — over the ${python.analyzed ? 'JavaScript, TypeScript, TSX and Python' : 'JavaScript, TypeScript and TSX'} in this repository.`, + '', + '### What the local security pass checked', + '', + '- **SQL injection (CWE-89).** Untrusted input tracked from request sources through string building into query execution.', + '- **Mass assignment (CWE-915).** A raw request body spread into a database write, and write helpers whose payload type accepts arbitrary keys.', + '- **Un-awaited database writes, swallowed errors, coercion-prone `==` comparisons, and N+1 queries in loops** — the defect classes coding agents most often introduce.', + ...(python.analyzed ? [ + `- **The complete rule pack over ${python.scanned} Python file(s).** The installed grammar pack is the same \`web-tree-sitter\` runtime and the same compiled grammar the hosted audit loads, so Python here was checked by the hosted machinery rather than an approximation of it — including the injection, traversal, SSRF and deserialization classes the JavaScript subset below omits.`, + ] : []), + '', + '### What did not run', + '', + `- **The rest of the security rule pack${python.analyzed ? ', for JavaScript, TypeScript and TSX' : ''}.** Command injection, code injection, path traversal, SSRF, open redirect, XSS and insecure deserialization were **not** checked ${python.analyzed ? 'in those languages' : 'here'}. Those rules run in a hosted scan; absence of a finding in those classes means they were not analyzed, not that the code is clean.`, + ...pythonDisclosureLines(python), + '- **Hosted symbol graph.** No cross-file call or data-flow graph was built, so architecture and dead-code conclusions cover only what the local passes can see in isolation.', + '- **Abstraction-shape analysis.** Single-implementation interfaces, options nobody overrides, and parameters never varied at any call site were not checked. They require the cross-file symbol graph, which does not run locally. This receipt says nothing either way about those shapes.', + ...(receipt.llm ? [] : [ + '- **Optional LLM review.** No model read this diff. It is opt-in via `--llm` and is force-disabled under agent hooks, so a hook receipt is always deterministic evidence only.', + ]), + '- **Hosted Health scores.** Not calculated, reported as **N/A**. The scores are defined over the graph and the complete SAST pass; a number derived from this pass set would overstate what ran.', + '', + 'Local security findings are reported for review and do not fail the verdict on their own.', + '', + 'A PASS verdict means the passes listed above never ran and the passes that did run found nothing new. It is not a statement that this change is secure.', + '', + '[Run a hosted full audit](https://codetruss.com/dashboard/repos/new?source=cli-receipt).', + ] +} + +interface PythonCoverage { + status: string + /** Python files offered to the pass. Zero means the repository has none. */ + files: number + scanned: number + reason: string + /** Which kind of failure, when the status is `failed`. See `local-sast.ts`. */ + failureKind: string + analyzed: boolean +} + +/** + * What this run actually did about Python, read from the pass that did it. + * + * Derived from the signed JSON rather than from a constant, so the same receipt + * always renders the same bytes while different runs can honestly say different + * things. A receipt whose pass carries no Python metrics — the shape every + * pre-0.2.40 client wrote — reads as "no Python", which is what those clients + * meant, and the wording for that case is unchanged from v3. + */ +function pythonCoverage(receipt: Receipt): PythonCoverage { + const metrics = receipt.analyzers.passes.find((pass) => pass.id === 'local-sast')?.result.metrics + const status = typeof metrics?.pythonPackStatus === 'string' ? metrics.pythonPackStatus : 'not-applicable' + const files = Number(metrics?.pythonFiles) + const scanned = Number(metrics?.pythonFilesScanned) + const reason = typeof metrics?.pythonPackReason === 'string' ? metrics.pythonPackReason : '' + // A `failed` pass from a client that predates the taxonomy carries no kind. + // `digest` is the safe default there only because it is what those clients + // already rendered; nothing new is asserted about an old receipt. + const failureKind = typeof metrics?.pythonPackFailureKind === 'string' ? metrics.pythonPackFailureKind : 'digest' + return { + status, + files: Number.isFinite(files) ? files : 0, + scanned: Number.isFinite(scanned) ? scanned : 0, + reason, + failureKind, + analyzed: status === 'verified' && Number.isFinite(scanned) && scanned > 0, + } +} + +/** + * The non-JavaScript-language paragraph, in the states it can be in. + * + * "Skipped" and "skipped because the bytes did not verify" are different facts + * and a reader has to be able to tell them apart: the first is a choice they can + * reverse with one command, the second means something on their machine is not + * what this CLI published. The three FAILURE kinds are different facts for the + * same reason — only one of them is about the pack at all, and a receipt that + * blames a user's install for their machine's out-of-memory error has published + * an accusation it cannot support. + * + * The closing sentence in every failure branch is deliberately the provable one. + * "Nothing was analyzed with unverified bytes" is true of this loader — it holds + * one buffer per artifact and executes that buffer — but it is an assertion + * about the CLI's internals that a receipt's reader has no way to check, and it + * makes a claim wider than this pass can speak to. "No findings from this pack + * were reported" says less and is verifiable against the receipt in hand. + */ +function pythonDisclosureLines(python: PythonCoverage): string[] { + const others = 'Go, Java, C#, PHP, Ruby and Rust' + if (python.status === 'verified' && python.analyzed) { + return [ + `- **Non-JavaScript languages other than Python.** ${others} in this repository received secret scanning and the other registry passes, but no security rule or taint analysis.`, + ] + } + if (python.status === 'absent') { + return [ + `- **Python.** ${python.files} Python file(s) here received secret scanning and the other registry passes, but no security rule or taint analysis: the optional Python grammar pack is not installed. Install it with \`codetruss grammars install python\` to analyze them locally, or run a hosted scan.`, + `- **Other non-JavaScript languages.** ${others} in this repository were likewise not covered by any security rule or taint analysis.`, + ] + } + if (python.status === 'failed') { + return [ + `- **Python.** ${python.files} Python file(s) were **not** analyzed. ${pythonFailureSentence(python)} No findings from this pack were reported.`, + `- **Other non-JavaScript languages.** ${others} in this repository received secret scanning and the other registry passes, but no security rule or taint analysis.`, + ] + } + return [ + `- **Non-JavaScript languages.** The local pass covered JavaScript, TypeScript and TSX. Python, ${others} in this repository received secret scanning and the other registry passes, but no security rule or taint analysis.`, + ] +} + +/** The one sentence that differs between the three ways a pack run can fail. */ +function pythonFailureSentence(python: PythonCoverage): string { + if (python.failureKind === 'runtime') { + // The digests PASSED here. Saying so is the point: the user's install is + // fine and the problem is this machine or this Node build. + return `The installed Python grammar pack matched the digests compiled into this CLI, but its runtime could not start on this machine, so no Python was parsed: ${python.reason}.` + } + if (python.failureKind === 'scan') { + return `The installed Python grammar pack verified and loaded, but the scan failed partway through and its partial results were discarded rather than reported as a complete Python result: ${python.reason}.` + } + return `The installed Python grammar pack did not verify against what this CLI published, so it was not loaded: ${python.reason}. Reinstall it with \`codetruss grammars install python\`.` +} + +/** + * The profile block exactly as CLI 0.2.39 wrote it, when the local pass could + * only ever reach the JS family. Frozen so those receipts still reproduce + * byte-for-byte. + */ +function jsOnlySastProfileLines(receipt: Receipt, profileId: string): string[] { + return [ + '## Analysis profile', + '', + `Profile: \`${profileId}\`.`, + '', 'The 15 deterministic registry analyzers ran locally on this machine, plus a local security pass: the shared SAST engine — the same rules and the same source-to-sink taint tracking as the hosted audit — over the JavaScript, TypeScript and TSX in this repository.', '', '### What the local security pass checked', diff --git a/packages/cli/src/types.ts b/packages/cli/src/types.ts index 3ef81f9..38342c4 100644 --- a/packages/cli/src/types.ts +++ b/packages/cli/src/types.ts @@ -33,10 +33,16 @@ export const MAX_LLM_DIFF_BYTES = 2_000_000 * Honest local-analysis contract: which passes ran on this machine, which did * not, and whether scores may be inferred. * - * `local-registry-v3` supersedes `local-registry-v2`, which ran thirteen - * registry analyzers; the registry now holds fifteen, and the profile block - * states that count. `local-registry-v2` had itself superseded `v1`, in which - * SAST was omitted entirely. + * `local-registry-v4` supersedes `local-registry-v3`. The pass SET is identical + * — fifteen registry analyzers, the local security pass, no graph — but v3's + * block states flatly that the local pass "covers JavaScript, TypeScript and + * TSX only" and that Python "received no security rule or taint analysis". With + * an installed grammar pack that sentence is false, so the wording had to change + * and therefore the id had to change with it. v4 renders its Python paragraph + * from what the run recorded rather than from a constant. + * + * `local-registry-v3` had superseded `v2`, which ran thirteen registry + * analyzers; `v2` had superseded `v1`, in which SAST was omitted entirely. * * The id is bumped rather than the wording quietly changed, and it is bumped * for a count as readily as for a pass: this shape sits inside signed receipts, @@ -45,7 +51,7 @@ export const MAX_LLM_DIFF_BYTES = 2_000_000 * with. Every superseded version keeps a frozen renderer in `receipt.ts`. */ export const LOCAL_ANALYSIS_PROFILE = { - id: 'local-registry-v3', + id: 'local-registry-v4', omittedPasses: ['graph'], localPasses: ['local-sast'], scoreStatus: 'not-computed', @@ -65,10 +71,18 @@ export interface LegacyLocalAnalysisProfileV2 { localPasses: readonly ['local-sast'] scoreStatus: 'not-computed' } +/** The v3 shape, retained so JS-only-local-SAST receipts still parse. */ +export interface LegacyLocalAnalysisProfileV3 { + id: 'local-registry-v3' + omittedPasses: readonly ['graph'] + localPasses: readonly ['local-sast'] + scoreStatus: 'not-computed' +} export type AnyLocalAnalysisProfile = | LocalAnalysisProfile | LegacyLocalAnalysisProfileV1 | LegacyLocalAnalysisProfileV2 + | LegacyLocalAnalysisProfileV3 export interface CliConfig { version: 1 diff --git a/packages/cli/test/grammar-command.test.ts b/packages/cli/test/grammar-command.test.ts new file mode 100644 index 0000000..67c04e2 --- /dev/null +++ b/packages/cli/test/grammar-command.test.ts @@ -0,0 +1,118 @@ +import { createServer, type Server } from 'node:http' +import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises' +import { tmpdir } from 'node:os' +import { dirname, join } from 'node:path' +import { fileURLToPath } from 'node:url' +import { afterAll, afterEach, beforeAll, describe, expect, it } from 'vitest' +import { DEV_GRAMMAR_ORIGIN_ENV, installGrammarPack } from '../src/grammar-pack.js' +import { runGrammarsCommand } from '../src/grammar-command.js' + +const repoRoot = join(dirname(fileURLToPath(import.meta.url)), '..', '..', '..') +const publishedDir = join(repoRoot, 'public', 'downloads', 'grammars') + +const cleanup: string[] = [] +afterEach(async () => { + await Promise.all(cleanup.splice(0).map((path) => rm(path, { recursive: true, force: true }))) +}) + +let server: Server +let origin: string + +beforeAll(async () => { + server = createServer((req, res) => { + const path = decodeURIComponent((req.url ?? '').split('?')[0]) + const prefix = '/downloads/grammars/' + if (!path.startsWith(prefix) || path.includes('..')) { + res.writeHead(404).end() + return + } + readFile(join(publishedDir, path.slice(prefix.length))).then( + (bytes) => res.writeHead(200).end(bytes), + () => res.writeHead(404).end(), + ) + }) + await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve)) + const address = server.address() + origin = `http://127.0.0.1:${typeof address === 'object' && address ? address.port : 0}` +}) + +afterAll(async () => { + await new Promise((resolve, reject) => server.close((error) => (error ? reject(error) : resolve()))) +}) + +/** + * LOCALAPPDATA as well as XDG_DATA_HOME: `grammarDataDir` reads the former on + * Windows and the latter everywhere else, so setting one alone leaves the suite + * reading and writing the developer's real pack directory on the other platform. + */ +async function scratchEnv(): Promise { + const home = await mkdtemp(join(tmpdir(), 'codetruss-grammars-cmd-')) + cleanup.push(home) + return { XDG_DATA_HOME: home, LOCALAPPDATA: home, [DEV_GRAMMAR_ORIGIN_ENV]: origin } +} + +function capture() { + const chunks: string[] = [] + return { write: (text: string) => { chunks.push(text) }, get text() { return chunks.join('') } } +} + +describe('codetruss grammars', () => { + it('lists what can be installed, with its provenance and size', async () => { + const out = capture() + expect(await runGrammarsCommand('list', undefined, out.write, await scratchEnv())).toBe(0) + expect(out.text).toContain('python-1.0.0') + // A user deciding whether to download 700 KB of WASM deserves to see what + // it is and where it came from before they run the command. + expect(out.text).toContain('web-tree-sitter@0.22.6') + expect(out.text).toContain('tree-sitter-wasms@0.1.11') + expect(out.text).toContain('codetruss grammars install python') + }) + + it('reports an uninstalled pack as a disclosed gap, and exits non-zero', async () => { + const out = capture() + expect(await runGrammarsCommand('status', undefined, out.write, await scratchEnv())).toBe(1) + expect(out.text).toContain('not installed') + expect(out.text).toContain('skipped locally and disclosed as such') + }) + + it('installs, then reports verified', async () => { + const env = await scratchEnv() + const install = capture() + expect(await runGrammarsCommand('install', 'python', install.write, env)).toBe(0) + expect(install.text).toContain('Installed python-1.0.0') + expect(install.text).toContain('matched the SHA-256 pinned in this CLI') + + const status = capture() + expect(await runGrammarsCommand('status', undefined, status.write, env)).toBe(0) + expect(status.text).toContain('installed and verified') + }) + + it('shouts about a tampered pack rather than reporting it as merely missing', async () => { + const env = await scratchEnv() + const { dir } = await installGrammarPack('python', env) + await writeFile(join(dir, 'tree-sitter.wasm'), Buffer.alloc(4)) + + const out = capture() + expect(await runGrammarsCommand('status', undefined, out.write, env)).toBe(1) + expect(out.text).toContain('FAILED VERIFICATION') + expect(out.text).toContain('not loaded') + }) + + it('uninstalls and says what that costs', async () => { + const env = await scratchEnv() + await installGrammarPack('python', env) + const out = capture() + expect(await runGrammarsCommand('uninstall', 'python', out.write, env)).toBe(0) + expect(out.text).toContain('python is skipped locally again') + }) + + it('rejects an unknown action instead of doing nothing quietly', async () => { + await expect(runGrammarsCommand('frobnicate', undefined, capture().write, await scratchEnv())) + .rejects.toThrow(/list, status, install, or uninstall/) + }) + + it('requires a pack name for install', async () => { + await expect(runGrammarsCommand('install', undefined, capture().write, await scratchEnv())) + .rejects.toThrow(/requires a pack name/) + }) +}) diff --git a/packages/cli/test/grammar-loader.test.ts b/packages/cli/test/grammar-loader.test.ts new file mode 100644 index 0000000..5a15a7d --- /dev/null +++ b/packages/cli/test/grammar-loader.test.ts @@ -0,0 +1,129 @@ +import { existsSync } from 'node:fs' +import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises' +import { tmpdir } from 'node:os' +import { dirname, join } from 'node:path' +import { fileURLToPath } from 'node:url' +import { afterEach, describe, expect, it, vi } from 'vitest' +import { pinnedGrammarPack } from '../src/grammar-pack-manifest.js' +import type { GrammarPackState } from '../src/grammar-pack.js' + +/** + * What the loader EXECUTES, as opposed to what the inspector verified. + * + * These tests stub the inspection so the two can be told apart: the state names + * a directory holding a hostile payload while carrying the genuine verified + * buffers. A loader that re-opens the path to execute it runs the payload; a + * loader that executes the buffers it was handed cannot. That distinction is + * the entire security position of the grammar pack, and nothing about it is + * observable when verification and execution both read the same healthy file. + */ +const stub = vi.hoisted(() => ({ current: null as GrammarPackState | null })) + +vi.mock('../src/grammar-pack.js', async (importOriginal) => { + const actual = await importOriginal() + return { + ...actual, + inspectGrammarPack: async (name: string, env?: NodeJS.ProcessEnv) => ( + stub.current ?? actual.inspectGrammarPack(name, env) + ), + } +}) + +const { loadGrammarParser } = await import('../src/grammar-parser.js') + +const repoRoot = join(dirname(fileURLToPath(import.meta.url)), '..', '..', '..') +const pack = pinnedGrammarPack('python')! +const publishedPack = join(repoRoot, 'public', 'downloads', 'grammars', `${pack.name}-${pack.version}`) + +const cleanup: string[] = [] +afterEach(async () => { + stub.current = null + await Promise.all(cleanup.splice(0).map((path) => rm(path, { recursive: true, force: true }))) +}) + +/** The real published bytes, as `inspectGrammarPack` would have returned them. */ +async function verifiedContents(): Promise> { + const contents = new Map() + for (const file of pack.files) contents.set(file.name, await readFile(join(publishedPack, file.name))) + return contents +} + +async function scratchDir(): Promise { + const dir = await mkdtemp(join(tmpdir(), 'codetruss-loader-')) + cleanup.push(dir) + return dir +} + +describe('the loader executes verified bytes, never a path', () => { + /** + * The adversarial review's proof-of-concept in deterministic form: the pack + * directory holds a module that writes a marker file and exports nothing + * usable, while the state carries the genuine buffers. Against a loader that + * does `createRequire(runtimePath)(runtimePath)` this writes the marker and + * owns the process. Against this one the payload is unreachable. + */ + it('parses Python from the buffers even when every file on disk is a payload', async () => { + const dir = await scratchDir() + const marker = join(dir, 'PWNED') + await writeFile( + join(dir, 'tree-sitter.js'), + `require('node:fs').writeFileSync(${JSON.stringify(marker)}, 'pwned')\nmodule.exports = {}\n`, + ) + await writeFile(join(dir, 'tree-sitter.wasm'), Buffer.from('not wasm')) + await writeFile(join(dir, 'tree-sitter-python.wasm'), Buffer.from('not wasm')) + + stub.current = { status: 'verified', pack, dir, contents: await verifiedContents() } + const load = await loadGrammarParser('python') + + expect(load.status).toBe('verified') + if (load.status !== 'verified') throw new Error('expected a verified load') + const tree = await load.parser.parse('python', 'import os\nos.system(name)\n') + expect(tree).not.toBeNull() + expect(tree!.hasError).toBe(false) + tree!.release() + // The single fact this whole design exists to guarantee. + expect(existsSync(marker)).toBe(false) + }) + + it('loads with nothing at the pack path at all', async () => { + const dir = await scratchDir() + // Deleting the directory between verification and execution is the same + // race with the timing removed: the load must not notice. + await rm(dir, { recursive: true, force: true }) + + stub.current = { status: 'verified', pack, dir, contents: await verifiedContents() } + const load = await loadGrammarParser('python') + expect(load.status).toBe('verified') + }) +}) + +describe('why a pack was unusable is carried, not collapsed', () => { + it('calls a pack that failed inspection a digest failure', async () => { + const dir = await scratchDir() + stub.current = { + status: 'failed', + pack, + dir, + reason: 'tree-sitter.js has digest deadbeef, expected ddcacb69', + } + const load = await loadGrammarParser('python') + expect(load).toMatchObject({ status: 'failed', kind: 'digest' }) + }) + + /** + * The failure the review cared about: every digest matched and the runtime + * still would not start. An OOM inside emscripten must never be published as + * an accusation that the user's pack does not match the pinned digests. + */ + it('calls a verified pack whose runtime will not start a runtime failure', async () => { + const dir = await scratchDir() + const contents = await verifiedContents() + contents.set('tree-sitter.js', Buffer.from('module.exports = {}\n')) + + stub.current = { status: 'verified', pack, dir, contents } + const load = await loadGrammarParser('python') + expect(load).toMatchObject({ status: 'failed', kind: 'runtime' }) + if (load.status !== 'failed') throw new Error('expected a failed load') + expect(load.reason).not.toContain('digest') + }) +}) diff --git a/packages/cli/test/grammar-pack.test.ts b/packages/cli/test/grammar-pack.test.ts new file mode 100644 index 0000000..c84cc22 --- /dev/null +++ b/packages/cli/test/grammar-pack.test.ts @@ -0,0 +1,396 @@ +import { createHash } from 'node:crypto' +import { createServer, type Server } from 'node:http' +import { chmod, lstat, mkdir, mkdtemp, readFile, rename, rm, stat, symlink, writeFile } from 'node:fs/promises' +import { tmpdir } from 'node:os' +import { dirname, join } from 'node:path' +import { fileURLToPath } from 'node:url' +import { afterAll, afterEach, beforeAll, describe, expect, it } from 'vitest' +import { PINNED_GRAMMAR_PACKS, pinnedGrammarPack } from '../src/grammar-pack-manifest.js' +import { + DEV_GRAMMAR_ORIGIN_ENV, + grammarDataDir, + grammarPackDir, + inspectGrammarPack, + installGrammarPack, + resolveGrammarOrigin, + uninstallGrammarPack, +} from '../src/grammar-pack.js' + +const repoRoot = join(dirname(fileURLToPath(import.meta.url)), '..', '..', '..') +const publishedDir = join(repoRoot, 'public', 'downloads', 'grammars') + +const cleanup: string[] = [] +afterEach(async () => { + await Promise.all(cleanup.splice(0).map((path) => rm(path, { recursive: true, force: true }))) +}) + +/** + * Serve the real published artifacts over loopback. + * + * The install path is only worth testing against the actual bytes: a fixture + * with invented content would verify against an invented pin and prove nothing + * about whether the CLI can install what this repository publishes. + */ +let server: Server +let origin: string +/** Bytes to answer with instead of the published file, for tamper cases. */ +let override: Buffer | null = null + +beforeAll(async () => { + server = createServer((req, res) => { + const path = decodeURIComponent((req.url ?? '').split('?')[0]) + const prefix = '/downloads/grammars/' + if (!path.startsWith(prefix) || path.includes('..')) { + res.writeHead(404).end() + return + } + if (override) { + res.writeHead(200, { 'content-type': 'application/octet-stream' }).end(override) + return + } + readFile(join(publishedDir, path.slice(prefix.length))).then( + (bytes) => res.writeHead(200, { 'content-type': 'application/octet-stream' }).end(bytes), + () => res.writeHead(404).end(), + ) + }) + await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve)) + const address = server.address() + origin = `http://127.0.0.1:${typeof address === 'object' && address ? address.port : 0}` +}) + +afterAll(async () => { + await new Promise((resolve, reject) => server.close((error) => (error ? reject(error) : resolve()))) +}) + +/** + * An environment whose grammar data directory is a throwaway temp dir on EVERY + * platform. + * + * `grammarDataDir` reads LOCALAPPDATA on Windows and XDG_DATA_HOME everywhere + * else, so setting one alone isolates one platform and leaves the other pointed + * at the developer's real data directory — where this suite installs a 722 KB + * pack, tampers with it mid-suite, and abandons it. + */ +async function scratchEnv(): Promise { + const home = await mkdtemp(join(tmpdir(), 'codetruss-grammars-')) + cleanup.push(home) + return { XDG_DATA_HOME: home, LOCALAPPDATA: home, [DEV_GRAMMAR_ORIGIN_ENV]: origin } +} + +/** + * Run `body` with `process.platform` pinned. + * + * `grammarDataDir` branches on the platform, so an unpinned assertion about one + * branch only asserts anything on the machine that happens to run it. Pinning is + * what makes the POSIX expectations below mean the same thing on Windows as they + * do here, instead of quietly asserting the other branch's behavior. + */ +function onPlatform(platform: NodeJS.Platform, body: () => T): T { + const original = Object.getOwnPropertyDescriptor(process, 'platform')! + Object.defineProperty(process, 'platform', { value: platform, configurable: true }) + try { + return body() + } finally { + Object.defineProperty(process, 'platform', original) + } +} + +describe('grammar pack storage location', () => { + it('puts packs under XDG_DATA_HOME, not the config directory', () => { + const dir = onPlatform('linux', () => grammarDataDir({ XDG_DATA_HOME: '/data' })) + // Packs are reproducible downloads, not authored settings. + expect(dir).toBe(join('/data', 'codetruss', 'grammars')) + }) + + it('refuses a relative XDG_DATA_HOME rather than resolving it against the cwd', () => { + expect(() => onPlatform('linux', () => grammarDataDir({ XDG_DATA_HOME: 'relative/path' }))) + .toThrow(/absolute/) + }) + + it('resolves the Windows data directory from LOCALAPPDATA', () => { + onPlatform('win32', () => { + // LOCALAPPDATA, not APPDATA: 700 KB of WASM must not roam between machines. + expect(grammarDataDir({ LOCALAPPDATA: 'C:\\Users\\x\\AppData\\Local' })) + .toBe('C:\\Users\\x\\AppData\\Local\\codetruss\\grammars') + expect(() => grammarDataDir({ LOCALAPPDATA: 'Local' })).toThrow(/absolute/) + }) + }) +}) + +describe('the download origin is not a free parameter', () => { + it('defaults to the CodeTruss downloads host', () => { + expect(resolveGrammarOrigin(undefined)).toBe('https://codetruss.com') + expect(resolveGrammarOrigin('')).toBe('https://codetruss.com') + }) + + it('accepts a loopback override for development and rejects anything else', () => { + expect(resolveGrammarOrigin('http://127.0.0.1:8080')).toBe('http://127.0.0.1:8080') + // Environment access must not become "choose which code gets executed". + expect(() => resolveGrammarOrigin('https://evil.example.com')).toThrow(/loopback/) + expect(() => resolveGrammarOrigin('http://localhost/path')).toThrow(/loopback/) + expect(() => resolveGrammarOrigin('not a url')).toThrow(/loopback/) + }) +}) + +describe('installing a pack', () => { + it('downloads every pinned artifact and verifies each digest', async () => { + const env = await scratchEnv() + const result = await installGrammarPack('python', env) + + expect(result.alreadyInstalled).toBe(false) + const pack = pinnedGrammarPack('python')! + for (const file of pack.files) { + const info = await stat(join(result.dir, file.name)) + expect(info.size).toBe(file.bytes) + } + await expect(inspectGrammarPack('python', env)).resolves.toMatchObject({ status: 'verified' }) + }) + + it('is idempotent: a verified pack is not re-downloaded', async () => { + const env = await scratchEnv() + await installGrammarPack('python', env) + const second = await installGrammarPack('python', env) + expect(second.alreadyInstalled).toBe(true) + }) + + it('refuses bytes that do not match the pin, and leaves nothing behind', async () => { + const env = await scratchEnv() + override = Buffer.from('not a grammar') + try { + await expect(installGrammarPack('python', env)).rejects.toThrow(/bytes|digest/) + } finally { + override = null + } + // A rejected download must not leave a half-installed pack that a later run + // could mistake for a real one. + await expect(inspectGrammarPack('python', env)).resolves.toMatchObject({ status: 'absent' }) + }) + + it('rejects an unknown pack name instead of inventing a download URL', async () => { + const env = await scratchEnv() + await expect(installGrammarPack('haskell', env)).rejects.toThrow(/unknown grammar pack/) + }) +}) + +describe('a pack is re-verified on every load, not only at install', () => { + it('reports a flipped byte as failed, naming the artifact', async () => { + const env = await scratchEnv() + const { dir } = await installGrammarPack('python', env) + const target = join(dir, 'tree-sitter-python.wasm') + const bytes = await readFile(target) + bytes[100] ^= 0xff + await writeFile(target, bytes) + + const state = await inspectGrammarPack('python', env) + expect(state.status).toBe('failed') + if (state.status !== 'failed') throw new Error('expected a failed pack') + expect(state.reason).toContain('tree-sitter-python.wasm') + expect(state.reason).toContain('digest') + }) + + it('reports a truncated artifact by size before hashing it', async () => { + const env = await scratchEnv() + const { dir } = await installGrammarPack('python', env) + await writeFile(join(dir, 'tree-sitter.wasm'), Buffer.alloc(10)) + + const state = await inspectGrammarPack('python', env) + expect(state.status).toBe('failed') + if (state.status !== 'failed') throw new Error('expected a failed pack') + expect(state.reason).toMatch(/is 10 bytes, expected/) + }) + + it('reports a missing artifact rather than loading a partial pack', async () => { + const env = await scratchEnv() + const { dir } = await installGrammarPack('python', env) + await rm(join(dir, 'tree-sitter.js')) + + const state = await inspectGrammarPack('python', env) + expect(state.status).toBe('failed') + if (state.status !== 'failed') throw new Error('expected a failed pack') + expect(state.reason).toContain('tree-sitter.js is missing') + }) + + it('reports an unexpected file in the pack directory', async () => { + const env = await scratchEnv() + const { dir } = await installGrammarPack('python', env) + await writeFile(join(dir, 'extra.js'), 'console.log(1)') + + const state = await inspectGrammarPack('python', env) + expect(state.status).toBe('failed') + if (state.status !== 'failed') throw new Error('expected a failed pack') + expect(state.reason).toContain('extra.js') + }) + + /** + * The load-bearing property of the whole design: the bytes that were hashed + * are the bytes the caller gets. A loader handed a path instead has verified + * one file and will execute whatever is at that name a moment later, and the + * gap is long enough — two more digests and a `readdir` — for a `rename(2)` + * loop to land a hostile module in it. + */ + it('returns the exact buffers it hashed, not a path to re-read', async () => { + const env = await scratchEnv() + const { dir } = await installGrammarPack('python', env) + const state = await inspectGrammarPack('python', env) + if (state.status !== 'verified') throw new Error('expected a verified pack') + + const pack = pinnedGrammarPack('python')! + for (const file of pack.files) { + const held = state.contents.get(file.name) + expect(held).toBeInstanceOf(Buffer) + expect(createHash('sha256').update(held!).digest('hex')).toBe(file.sha256) + expect(held!.equals(await readFile(join(dir, file.name)))).toBe(true) + } + + // Rewriting every artifact after the fact cannot reach the buffers already + // returned — which is precisely why the loader is safe to execute them. + for (const file of pack.files) await writeFile(join(dir, file.name), Buffer.alloc(file.bytes, 0x41)) + for (const file of pack.files) { + expect(createHash('sha256').update(state.contents.get(file.name)!).digest('hex')).toBe(file.sha256) + } + }) + + it('replaces a failed pack wholesale on reinstall', async () => { + const env = await scratchEnv() + const { dir } = await installGrammarPack('python', env) + await writeFile(join(dir, 'extra.js'), 'console.log(1)') + expect((await inspectGrammarPack('python', env)).status).toBe('failed') + + const reinstalled = await installGrammarPack('python', env) + expect(reinstalled.alreadyInstalled).toBe(false) + await expect(inspectGrammarPack('python', env)).resolves.toMatchObject({ status: 'verified' }) + }) +}) + +/** + * `stat` follows symlinks and `mkdir`'s mode only applies to directories it + * creates, so the naive version of this module accepts a symlinked artifact as + * verified, installs straight through a symlinked pack root, and leaves a + * pre-existing loose root loose. Each one turns "needs write inside a 0700 + * directory" into something much cheaper — and on a shared host, into a + * cross-user problem. + * + * POSIX-only: `symlink` needs a privilege on Windows, and `st_mode` says nothing + * useful about an ACL there. + */ +describe.skipIf(process.platform === 'win32')('symlinks and loose permissions', () => { + it('rejects a symlinked artifact instead of hashing what it points at', async () => { + const env = await scratchEnv() + const { dir } = await installGrammarPack('python', env) + // The link target holds the genuine, pinned bytes: following it would + // verify perfectly, which is exactly the trap. + const elsewhere = await mkdtemp(join(tmpdir(), 'codetruss-link-target-')) + cleanup.push(elsewhere) + const target = join(elsewhere, 'tree-sitter.js') + await rename(join(dir, 'tree-sitter.js'), target) + await symlink(target, join(dir, 'tree-sitter.js')) + + const state = await inspectGrammarPack('python', env) + expect(state.status).toBe('failed') + if (state.status !== 'failed') throw new Error('expected a failed pack') + expect(state.reason).toContain('tree-sitter.js') + expect(state.reason).toContain('symbolic link') + }) + + it('rejects a symlinked pack root even when the pack behind it verifies', async () => { + const env = await scratchEnv() + await installGrammarPack('python', env) + const root = grammarDataDir(env) + await rename(root, `${root}-real`) + await symlink(`${root}-real`, root) + + const state = await inspectGrammarPack('python', env) + expect(state.status).toBe('failed') + if (state.status !== 'failed') throw new Error('expected a failed pack') + expect(state.reason).toContain('symbolic link') + }) + + it('rejects a group- or other-writable root, where the parent alone lets a pack be swapped', async () => { + const env = await scratchEnv() + await installGrammarPack('python', env) + // No permission on the files is needed: write on the parent is enough to + // `rename` the pack away and put another directory in its place. + await chmod(grammarDataDir(env), 0o775) + + const state = await inspectGrammarPack('python', env) + expect(state.status).toBe('failed') + if (state.status !== 'failed') throw new Error('expected a failed pack') + expect(state.reason).toContain('writable by group or other') + }) + + it('rejects a group-writable pack directory too', async () => { + const env = await scratchEnv() + const { dir } = await installGrammarPack('python', env) + await chmod(dir, 0o770) + + const state = await inspectGrammarPack('python', env) + expect(state.status).toBe('failed') + if (state.status !== 'failed') throw new Error('expected a failed pack') + expect(state.reason).toContain('writable by group or other') + }) + + it('refuses to install through a pre-created symlinked root', async () => { + const env = await scratchEnv() + const root = grammarDataDir(env) + const elsewhere = await mkdtemp(join(tmpdir(), 'codetruss-link-root-')) + cleanup.push(elsewhere) + await mkdir(dirname(root), { recursive: true }) + await symlink(elsewhere, root) + + await expect(installGrammarPack('python', env)).rejects.toThrow(/not a real directory/) + // Nothing may land in the attacker's directory on the way to failing. + await expect(readFile(join(elsewhere, 'tree-sitter.js'))).rejects.toThrow() + }) + + it('tightens a loose root on install rather than dead-ending the user', async () => { + const env = await scratchEnv() + const root = grammarDataDir(env) + await mkdir(root, { recursive: true }) + await chmod(root, 0o755) + + await installGrammarPack('python', env) + expect((await lstat(root)).mode & 0o777).toBe(0o700) + await expect(inspectGrammarPack('python', env)).resolves.toMatchObject({ status: 'verified' }) + }) +}) + +describe('uninstalling', () => { + it('removes the pack and reports absence as the end state', async () => { + const env = await scratchEnv() + await installGrammarPack('python', env) + await expect(uninstallGrammarPack('python', env)).resolves.toMatchObject({ removed: true }) + await expect(inspectGrammarPack('python', env)).resolves.toMatchObject({ status: 'absent' }) + // Already-absent is success: the requested end state holds. + await expect(uninstallGrammarPack('python', env)).resolves.toMatchObject({ removed: false }) + }) +}) + +describe('the pinned manifest', () => { + it('pins a digest and a length for every artifact it will execute', () => { + expect(PINNED_GRAMMAR_PACKS.length).toBeGreaterThan(0) + for (const pack of PINNED_GRAMMAR_PACKS) { + expect(pack.files.length).toBeGreaterThan(0) + for (const file of pack.files) { + expect(file.sha256).toMatch(/^[0-9a-f]{64}$/) + expect(file.bytes).toBeGreaterThan(0) + // Same-origin only: a third-party CDN is never a download target. + expect(file.url.startsWith('/downloads/grammars/')).toBe(true) + } + } + }) + + it('matches the artifacts this repository publishes', async () => { + for (const pack of PINNED_GRAMMAR_PACKS) { + for (const file of pack.files) { + const bytes = await readFile(join(publishedDir, `${pack.name}-${pack.version}`, file.name)) + expect(bytes.length).toBe(file.bytes) + } + } + }) + + it('derives the on-disk directory from the pack version, so packs coexist', () => { + const pack = pinnedGrammarPack('python')! + expect(onPlatform('linux', () => grammarPackDir(pack, { XDG_DATA_HOME: '/data' }))) + .toBe(join('/data', 'codetruss', 'grammars', `python-${pack.version}`)) + }) +}) diff --git a/packages/cli/test/grammar-sast.test.ts b/packages/cli/test/grammar-sast.test.ts new file mode 100644 index 0000000..5fe3522 --- /dev/null +++ b/packages/cli/test/grammar-sast.test.ts @@ -0,0 +1,195 @@ +import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises' +import { createServer, type Server } from 'node:http' +import { tmpdir } from 'node:os' +import { dirname, join } from 'node:path' +import { fileURLToPath } from 'node:url' +import { afterAll, afterEach, beforeAll, describe, expect, it } from 'vitest' +import { indexRepository } from '../src/indexer.js' +import { DEV_GRAMMAR_ORIGIN_ENV, installGrammarPack } from '../src/grammar-pack.js' +import { runLocalSast } from '../src/local-sast.js' + +const repoRoot = join(dirname(fileURLToPath(import.meta.url)), '..', '..', '..') +const publishedDir = join(repoRoot, 'public', 'downloads', 'grammars') + +const cleanup: string[] = [] +afterEach(async () => { + await Promise.all(cleanup.splice(0).map((path) => rm(path, { recursive: true, force: true }))) +}) + +let server: Server +let origin: string + +beforeAll(async () => { + server = createServer((req, res) => { + const path = decodeURIComponent((req.url ?? '').split('?')[0]) + const prefix = '/downloads/grammars/' + if (!path.startsWith(prefix) || path.includes('..')) { + res.writeHead(404).end() + return + } + readFile(join(publishedDir, path.slice(prefix.length))).then( + (bytes) => res.writeHead(200).end(bytes), + () => res.writeHead(404).end(), + ) + }) + await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve)) + const address = server.address() + origin = `http://127.0.0.1:${typeof address === 'object' && address ? address.port : 0}` +}) + +afterAll(async () => { + await new Promise((resolve, reject) => server.close((error) => (error ? reject(error) : resolve()))) +}) + +/** + * A repository holding one injectable Python module and one clean TS module. + * + * The Python here deliberately exercises classes the JS-family subset is + * disclosed as NOT checking — command injection, path traversal, SSRF — because + * that is the whole point of the pack: not "Python too", but "Python with the + * rules the local JS pass cannot run". + */ +async function pythonRepo(): Promise { + const root = await mkdtemp(join(tmpdir(), 'codetruss-grammar-sast-')) + cleanup.push(root) + await mkdir(join(root, 'app')) + await writeFile(join(root, 'app', 'views.py'), [ + 'import os', + 'import requests', + 'from flask import request', + '', + '', + 'def run_cmd():', + ' name = request.args.get("name")', + ' os.system("ls " + name)', + '', + '', + 'def read_file():', + ' p = request.args.get("p")', + ' return open("/data/" + p).read()', + '', + '', + 'def fetch():', + ' url = request.args.get("url")', + ' return requests.get(url).text', + '', + ].join('\n')) + await writeFile(join(root, 'app', 'clean.ts'), 'export const a = 1\n') + return root +} + +/** + * An environment whose grammar data directory is a throwaway temp dir on EVERY + * platform. + * + * This returns the whole env rather than the directory so that callers cannot + * spell the isolation themselves and get it half right: `grammarDataDir` reads + * LOCALAPPDATA on Windows and XDG_DATA_HOME everywhere else, and naming only one + * of them isolates only one platform. The tests below install a pack and then + * corrupt it, so the platform that misses out does not merely leak state — it + * leaves a tampered pack in the developer's real data directory. + */ +async function scratchDataEnv(): Promise { + const home = await mkdtemp(join(tmpdir(), 'codetruss-grammar-data-')) + cleanup.push(home) + return { XDG_DATA_HOME: home, LOCALAPPDATA: home } +} + +describe('the local pass without a grammar pack', () => { + it('skips Python, analyzes nothing there, and records why', async () => { + const root = await pythonRepo() + const env = await scratchDataEnv() + const result = await runLocalSast(await indexRepository(root), env) + + expect(result.findings).toHaveLength(0) + const metrics = result.pass.result.metrics! + expect(metrics.pythonPackStatus).toBe('absent') + expect(metrics.pythonFiles).toBe(1) + expect(metrics.pythonFilesScanned).toBe(0) + // Skipping a language is not a failure of the pass: it is disclosed + // coverage, and a clean JS/TS repo must still be able to reach PASS. + expect(result.pass.result.complete).toBe(true) + expect(result.pass.error).toBeUndefined() + }) + + it('says nothing about Python for a repository that has none', async () => { + const root = await mkdtemp(join(tmpdir(), 'codetruss-no-python-')) + cleanup.push(root) + await mkdir(join(root, 'src')) + await writeFile(join(root, 'src', 'a.ts'), 'export const a = 1\n') + const env = await scratchDataEnv() + + const result = await runLocalSast(await indexRepository(root), env) + expect(result.pass.result.metrics!.pythonPackStatus).toBe('not-applicable') + expect(result.pass.result.metrics!.pythonFiles).toBe(0) + }) +}) + +describe('the local pass with the grammar pack installed', () => { + it('finds Python injection the JS parser could never reach', async () => { + const root = await pythonRepo() + const env = { ...await scratchDataEnv(), [DEV_GRAMMAR_ORIGIN_ENV]: origin } + await installGrammarPack('python', env) + + const result = await runLocalSast(await indexRepository(root), env) + const metrics = result.pass.result.metrics! + expect(metrics.pythonPackStatus).toBe('verified') + expect(metrics.pythonFilesScanned).toBe(1) + + // The Python scan runs the FULL pack, not the JS subset. Each of these is a + // class the JS-family pass is explicitly disclosed as not checking, so their + // presence is the pack doing the thing it exists for. + const rules = result.findings.map((finding) => finding.metadata?.ruleId) + expect(rules).toContain('command-injection') + expect(rules).toContain('path-traversal') + expect(rules).toContain('ssrf') + for (const finding of result.findings) { + expect(finding.analyzerId).toBe('local-sast') + expect(finding.filePath).toBe('app/views.py') + } + }) + + /** + * A single `codetruss review` analyzes twice — the baseline tree, then the + * final tree — so the pack is loaded twice in one process. The emscripten + * runtime reassigns its own `module.exports` during init, so a naive second + * `require()` returns the Module object instead of the Parser class and the + * whole second analysis silently loses Python. That failure is invisible to a + * one-shot test and to the receipt, which would just say "not analyzed". + */ + it('analyzes Python on a second load in the same process', async () => { + const root = await pythonRepo() + const env = { ...await scratchDataEnv(), [DEV_GRAMMAR_ORIGIN_ENV]: origin } + await installGrammarPack('python', env) + const index = await indexRepository(root) + + const first = await runLocalSast(index, env) + const second = await runLocalSast(index, env) + + expect(second.pass.result.metrics!.pythonPackStatus).toBe('verified') + expect(second.pass.result.metrics!.pythonFilesScanned).toBe(1) + // The baseline and final analyses must see the same code the same way, or + // the finding delta is computed against a tree that was never analyzed. + expect(second.findings.map((finding) => finding.metadata?.ruleId).sort()) + .toEqual(first.findings.map((finding) => finding.metadata?.ruleId).sort()) + }) + + it('refuses to analyze Python with a tampered pack, and says so', async () => { + const root = await pythonRepo() + const env = { ...await scratchDataEnv(), [DEV_GRAMMAR_ORIGIN_ENV]: origin } + const { dir } = await installGrammarPack('python', env) + const target = join(dir, 'tree-sitter.js') + await writeFile(target, `${await readFile(target, 'utf8')}\n// injected`) + + const result = await runLocalSast(await indexRepository(root), env) + const metrics = result.pass.result.metrics! + expect(metrics.pythonPackStatus).toBe('failed') + expect(metrics.pythonFilesScanned).toBe(0) + expect(String(metrics.pythonPackReason)).toContain('tree-sitter.js') + // WHICH failure, so the receipt can avoid accusing a healthy install of + // tampering when the real problem was the runtime or the scan. + expect(metrics.pythonPackFailureKind).toBe('digest') + // Nothing was executed from the modified pack, so no Python finding exists. + expect(result.findings.filter((finding) => finding.filePath?.endsWith('.py'))).toHaveLength(0) + }) +}) diff --git a/packages/cli/test/receipt.test.ts b/packages/cli/test/receipt.test.ts index 8bdebb9..26bd1e4 100644 --- a/packages/cli/test/receipt.test.ts +++ b/packages/cli/test/receipt.test.ts @@ -60,6 +60,40 @@ function profileV2Fixture(root: string, patch = 'diff evidence'): Receipt { } } +/** A receipt as CLI 0.2.39 signed it, when the local pass reached the JS family only. */ +function profileV3Fixture(root: string, patch = 'diff evidence'): Receipt { + const receipt = fixture(root, patch) + return { + ...receipt, + analyzers: { + passes: receipt.analyzers.passes, + findings: receipt.analyzers.findings, + index: receipt.analyzers.index, + analysisProfile: { + id: 'local-registry-v3', + omittedPasses: ['graph'], + localPasses: ['local-sast'], + scoreStatus: 'not-computed', + }, + }, + } +} + +/** A current receipt whose local pass recorded a Python coverage outcome. */ +function pythonFixture( + metrics: Record, + root = '/tmp/repo', +): Receipt { + const receipt = fixture(root) + return { + ...receipt, + analyzers: { + ...receipt.analyzers, + passes: [{ id: 'local-sast', result: { findings: [], complete: true, truncated: false, metrics } }], + }, + } +} + function legacyFixture(root: string, patch = 'diff evidence'): Receipt { const receipt = fixture(root, patch) return { @@ -91,7 +125,7 @@ describe('signed receipts', () => { await expect(verifyReceipt(dir, receipt.sessionId)).resolves.toMatchObject({ verdict: 'PASS' }) const markdown = await readFile(paths.markdown, 'utf8') expect(markdown).toContain('Policy SHA-256') - expect(markdown).toContain('Profile: `local-registry-v3`') + expect(markdown).toContain('Profile: `local-registry-v4`') expect(markdown).not.toContain('Final scores:') await writeFile(paths.markdown, `${await readFile(paths.markdown, 'utf8')}tampered`) await expect(verifyReceipt(dir, receipt.sessionId)).rejects.toThrow('Markdown receipt does not match') @@ -175,14 +209,141 @@ describe('signed receipts', () => { await expect(verifyReceipt(dir, receipt.sessionId)).resolves.toMatchObject({ verdict: 'PASS' }) }) + it('reproduces the v3 wording for a receipt signed before the grammar pack existed', async () => { + const root = await mkdtemp(join(tmpdir(), 'codetruss-profile-v3-receipt-')) + const dir = join(root, 'receipts') + process.env.CODETRUSS_SIGNING_KEY = join(root, 'signing.pem') + const receipt = profileV3Fixture(root) + const paths = await writeReceipt(dir, receipt, 'diff evidence') + + const markdown = await readFile(paths.markdown, 'utf8') + expect(markdown).toContain('Profile: `local-registry-v3`') + // v3 could only ever mean this, so it must keep saying exactly this. + expect(markdown).toContain('The local pass covers JavaScript, TypeScript and TSX only.') + expect(markdown).not.toContain('grammar pack') + await expect(verifyReceipt(dir, receipt.sessionId)).resolves.toMatchObject({ verdict: 'PASS' }) + }) + it('states the new registry count and the abstraction-shape limit on a current receipt', () => { const markdown = renderMarkdown(fixture('/tmp/repo')) - expect(markdown).toContain('Profile: `local-registry-v3`') + expect(markdown).toContain('Profile: `local-registry-v4`') expect(markdown).toContain('The 15 deterministic registry analyzers ran locally on this machine') expect(markdown).toContain('**Abstraction-shape analysis.**') expect(markdown).toContain('says nothing either way about those shapes') }) + describe('the Python disclosure states what this run actually did', () => { + it('names the pack and the command when it is simply not installed', () => { + const markdown = renderMarkdown(pythonFixture({ + pythonFiles: 12, + pythonFilesScanned: 0, + pythonPackStatus: 'absent', + pythonPackReason: 'the Python grammar pack is not installed', + })) + expect(markdown).toContain('12 Python file(s) here received secret scanning') + expect(markdown).toContain('codetruss grammars install python') + // Absence is a gap, never a clean result. + expect(markdown).toContain('no security rule or taint analysis') + expect(markdown).not.toContain('JavaScript, TypeScript, TSX and Python') + }) + + it('claims Python coverage only when the pack actually scanned files', () => { + const markdown = renderMarkdown(pythonFixture({ + pythonFiles: 47, + pythonFilesScanned: 47, + pythonPackStatus: 'verified', + })) + expect(markdown).toContain('JavaScript, TypeScript, TSX and Python') + expect(markdown).toContain('The complete rule pack over 47 Python file(s)') + expect(markdown).toContain('**Non-JavaScript languages other than Python.**') + // The JS subset limit survives: Python coverage must not be read as + // covering the injection classes the JS pass still skips. + expect(markdown).toContain('for JavaScript, TypeScript and TSX') + expect(markdown).not.toContain('grammars install python') + }) + + it('distinguishes a tampered pack from an absent one, and never loads it', () => { + const markdown = renderMarkdown(pythonFixture({ + pythonFiles: 5, + pythonFilesScanned: 0, + pythonPackStatus: 'failed', + pythonPackFailureKind: 'digest', + pythonPackReason: 'tree-sitter-python.wasm has digest deadbeef, expected 9056d0fb', + })) + expect(markdown).toContain('did not verify against what this CLI published') + expect(markdown).toContain('tree-sitter-python.wasm has digest deadbeef') + expect(markdown).toContain('Reinstall it with `codetruss grammars install python`') + // Provable, and checkable against the finding list in this same receipt. + expect(markdown).toContain('No findings from this pack were reported.') + expect(markdown).not.toContain('JavaScript, TypeScript, TSX and Python') + }) + + /** + * The three failure kinds are three unrelated events, and only one of them + * is about the pack's bytes. A receipt that renders the digest sentence for + * an out-of-memory error has published a false accusation of tampering — in + * a signed document, over the product's own core claim. + */ + it('blames the machine, not the install, when the pack verified and the runtime would not start', () => { + const markdown = renderMarkdown(pythonFixture({ + pythonFiles: 5, + pythonFilesScanned: 0, + pythonPackStatus: 'failed', + pythonPackFailureKind: 'runtime', + pythonPackReason: 'grammar runtime failed to load: Aborted(OOM)', + })) + expect(markdown).toContain('matched the digests compiled into this CLI, but its runtime could not start on this machine') + expect(markdown).toContain('Aborted(OOM)') + expect(markdown).not.toContain('did not verify') + // Nothing is wrong with the install, so nothing suggests reinstalling it. + expect(markdown).not.toContain('Reinstall it with') + expect(markdown).toContain('No findings from this pack were reported.') + }) + + it('says the scan failed partway when the pack loaded and the scan threw', () => { + const markdown = renderMarkdown(pythonFixture({ + pythonFiles: 5, + pythonFilesScanned: 0, + pythonPackStatus: 'failed', + pythonPackFailureKind: 'scan', + pythonPackReason: 'grammar pack scan failed: out of memory', + })) + expect(markdown).toContain('verified and loaded, but the scan failed partway through') + expect(markdown).toContain('partial results were discarded') + expect(markdown).not.toContain('did not verify') + expect(markdown).toContain('No findings from this pack were reported.') + }) + + it('renders a failed pass from a client that predates the taxonomy as before', () => { + const markdown = renderMarkdown(pythonFixture({ + pythonFiles: 5, + pythonFilesScanned: 0, + pythonPackStatus: 'failed', + pythonPackReason: 'tree-sitter.js is missing from the installed pack', + })) + // No kind recorded means no new claim may be invented for it. + expect(markdown).toContain('did not verify against what this CLI published') + expect(markdown).not.toContain('runtime could not start') + }) + + it('says nothing about a pack for a repository with no Python in it', () => { + const markdown = renderMarkdown(pythonFixture({ + pythonFiles: 0, + pythonFilesScanned: 0, + pythonPackStatus: 'not-applicable', + })) + expect(markdown).toContain('The local pass covered JavaScript, TypeScript and TSX.') + expect(markdown).not.toContain('grammar pack') + expect(markdown).not.toContain('grammars install') + }) + + it('reads a pre-0.2.40 pass with no Python metrics as the JS-only case', () => { + const markdown = renderMarkdown(pythonFixture({ inputFiles: 3, filesScanned: 3 })) + expect(markdown).toContain('The local pass covered JavaScript, TypeScript and TSX.') + expect(markdown).not.toContain('grammar pack') + }) + }) + it('renders the comment-signal measurement from pass metrics, and nothing without them', () => { const receipt = fixture('/tmp/repo') expect(renderMarkdown(receipt)).not.toContain('## Comment signal') diff --git a/public/downloads/codetruss-cli-0.2.40.sbom.cdx.json b/public/downloads/codetruss-cli-0.2.40.sbom.cdx.json new file mode 100644 index 0000000..fe75706 --- /dev/null +++ b/public/downloads/codetruss-cli-0.2.40.sbom.cdx.json @@ -0,0 +1,170 @@ +{ + "$schema": "https://cyclonedx.org/schema/bom-1.6.schema.json", + "bomFormat": "CycloneDX", + "serialNumber": "urn:uuid:87fe717b-5581-5c87-9d3e-571c96b13a30", + "specVersion": "1.6", + "version": 1, + "metadata": { + "component": { + "type": "application", + "bom-ref": "pkg:npm/%40codetruss/cli@0.2.40", + "name": "@codetruss/cli", + "version": "0.2.40", + "description": "Local-first scope, quality, and verification receipts for coding agents", + "licenses": [ + { + "license": { + "name": "CodeTruss CLI Proprietary License" + } + } + ], + "purl": "pkg:npm/%40codetruss/cli@0.2.40" + }, + "properties": [ + { + "name": "codetruss:distribution", + "value": "single-file JavaScript bundle" + }, + { + "name": "codetruss:runtimeDependencies", + "value": "0" + } + ] + }, + "components": [ + { + "type": "library", + "bom-ref": "pkg:npm/%40codetruss/analyzer-engine@0.1.0", + "name": "@codetruss/analyzer-engine", + "version": "0.1.0", + "licenses": [ + { + "license": { + "name": "CodeTruss CLI Proprietary License" + } + } + ], + "purl": "pkg:npm/%40codetruss/analyzer-engine@0.1.0", + "properties": [ + { + "name": "codetruss:bundled", + "value": "true" + } + ] + }, + { + "type": "library", + "bom-ref": "pkg:npm/balanced-match@4.0.4", + "name": "balanced-match", + "version": "4.0.4", + "licenses": [ + { + "license": { + "id": "MIT" + } + } + ], + "purl": "pkg:npm/balanced-match@4.0.4", + "properties": [ + { + "name": "codetruss:bundled", + "value": "true" + } + ] + }, + { + "type": "library", + "bom-ref": "pkg:npm/brace-expansion@5.0.7", + "name": "brace-expansion", + "version": "5.0.7", + "licenses": [ + { + "license": { + "id": "MIT" + } + } + ], + "purl": "pkg:npm/brace-expansion@5.0.7", + "properties": [ + { + "name": "codetruss:bundled", + "value": "true" + } + ] + }, + { + "type": "library", + "bom-ref": "pkg:npm/minimatch@10.2.5", + "name": "minimatch", + "version": "10.2.5", + "licenses": [ + { + "license": { + "id": "BlueOak-1.0.0" + } + } + ], + "purl": "pkg:npm/minimatch@10.2.5", + "properties": [ + { + "name": "codetruss:bundled", + "value": "true" + } + ] + }, + { + "type": "library", + "bom-ref": "pkg:npm/yaml@2.9.0", + "name": "yaml", + "version": "2.9.0", + "licenses": [ + { + "license": { + "id": "ISC" + } + } + ], + "purl": "pkg:npm/yaml@2.9.0", + "properties": [ + { + "name": "codetruss:bundled", + "value": "true" + } + ] + } + ], + "dependencies": [ + { + "ref": "pkg:npm/%40codetruss/analyzer-engine@0.1.0", + "dependsOn": [] + }, + { + "ref": "pkg:npm/%40codetruss/cli@0.2.40", + "dependsOn": [ + "pkg:npm/%40codetruss/analyzer-engine@0.1.0", + "pkg:npm/minimatch@10.2.5", + "pkg:npm/yaml@2.9.0" + ] + }, + { + "ref": "pkg:npm/balanced-match@4.0.4", + "dependsOn": [] + }, + { + "ref": "pkg:npm/brace-expansion@5.0.7", + "dependsOn": [ + "pkg:npm/balanced-match@4.0.4" + ] + }, + { + "ref": "pkg:npm/minimatch@10.2.5", + "dependsOn": [ + "pkg:npm/brace-expansion@5.0.7" + ] + }, + { + "ref": "pkg:npm/yaml@2.9.0", + "dependsOn": [] + } + ] +} diff --git a/public/downloads/codetruss-cli-0.2.40.tgz b/public/downloads/codetruss-cli-0.2.40.tgz new file mode 100644 index 0000000000000000000000000000000000000000..4b5b0c697265614876e9be8949887b28c37ab67d GIT binary patch literal 857688 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�TX~u8ImMS9k7iUjaGrTR?vu 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 literal 0 HcmV?d00001 diff --git a/public/downloads/codetruss-cli-0.2.40.tgz.sha256 b/public/downloads/codetruss-cli-0.2.40.tgz.sha256 new file mode 100644 index 0000000..1c0fc48 --- /dev/null +++ b/public/downloads/codetruss-cli-0.2.40.tgz.sha256 @@ -0,0 +1 @@ +5d64313b8b60acbd1f93e2246557967885a98fdc8c486ea7b2a6417fd8acdac2 codetruss-cli-0.2.40.tgz diff --git a/public/downloads/codetruss-cli-latest.json b/public/downloads/codetruss-cli-latest.json index 2b23b49..ffc0697 100644 --- a/public/downloads/codetruss-cli-latest.json +++ b/public/downloads/codetruss-cli-latest.json @@ -1,13 +1,13 @@ { "name": "@codetruss/cli", - "version": "0.2.39", - "url": "/downloads/codetruss-cli-0.2.39.tgz", + "version": "0.2.40", + "url": "/downloads/codetruss-cli-0.2.40.tgz", "latestUrl": "/downloads/codetruss-cli-latest.tgz", - "sha256": "feb9a7454abaf2c25bdeade2a6e638137290df8c0725a447e3aca04aef2bd8f0", - "sbomUrl": "/downloads/codetruss-cli-0.2.39.sbom.cdx.json", - "sbomSha256": "8bd47df2b79d979883cb0372abfc26d380b3ad2fd10327538da8cb15e838d1b4", + "sha256": "5d64313b8b60acbd1f93e2246557967885a98fdc8c486ea7b2a6417fd8acdac2", + "sbomUrl": "/downloads/codetruss-cli-0.2.40.sbom.cdx.json", + "sbomSha256": "a78a5a08993e2266cee606f892d2afe118880605dd911d3f2149f99e4e8001bd", "node": ">=20.9.0", "repository": "https://github.com/DeliriumPulse/codetruss-cli", - "releaseUrl": "https://github.com/DeliriumPulse/codetruss-cli/releases/tag/v0.2.39", - "attestationCommand": "gh attestation verify codetruss-cli-0.2.39.tgz --repo DeliriumPulse/codetruss-cli" + "releaseUrl": "https://github.com/DeliriumPulse/codetruss-cli/releases/tag/v0.2.40", + "attestationCommand": "gh attestation verify codetruss-cli-0.2.40.tgz --repo DeliriumPulse/codetruss-cli" } diff --git a/public/downloads/codetruss-cli-latest.sbom.cdx.json b/public/downloads/codetruss-cli-latest.sbom.cdx.json index ba79216..fe75706 100644 --- a/public/downloads/codetruss-cli-latest.sbom.cdx.json +++ b/public/downloads/codetruss-cli-latest.sbom.cdx.json @@ -1,15 +1,15 @@ { "$schema": "https://cyclonedx.org/schema/bom-1.6.schema.json", "bomFormat": "CycloneDX", - "serialNumber": "urn:uuid:be975d22-e2ae-5460-993a-2839a1058dab", + "serialNumber": "urn:uuid:87fe717b-5581-5c87-9d3e-571c96b13a30", "specVersion": "1.6", "version": 1, "metadata": { "component": { "type": "application", - "bom-ref": "pkg:npm/%40codetruss/cli@0.2.39", + "bom-ref": "pkg:npm/%40codetruss/cli@0.2.40", "name": "@codetruss/cli", - "version": "0.2.39", + "version": "0.2.40", "description": "Local-first scope, quality, and verification receipts for coding agents", "licenses": [ { @@ -18,7 +18,7 @@ } } ], - "purl": "pkg:npm/%40codetruss/cli@0.2.39" + "purl": "pkg:npm/%40codetruss/cli@0.2.40" }, "properties": [ { @@ -139,7 +139,7 @@ "dependsOn": [] }, { - "ref": "pkg:npm/%40codetruss/cli@0.2.39", + "ref": "pkg:npm/%40codetruss/cli@0.2.40", "dependsOn": [ "pkg:npm/%40codetruss/analyzer-engine@0.1.0", "pkg:npm/minimatch@10.2.5", diff --git a/public/downloads/codetruss-cli-latest.tgz b/public/downloads/codetruss-cli-latest.tgz index f8ad92cd4757f409cee39990da8a77fb586f2063..4b5b0c697265614876e9be8949887b28c37ab67d 100644 GIT binary patch delta 31011 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 bw`z@#u~)m{#*)hwXW8W=u20OK`icJ!jxD${ delta 7089 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 DJ~D6B diff --git a/public/downloads/codetruss-cli-latest.tgz.sha256 b/public/downloads/codetruss-cli-latest.tgz.sha256 index b13f42c..a8db5aa 100644 --- a/public/downloads/codetruss-cli-latest.tgz.sha256 +++ b/public/downloads/codetruss-cli-latest.tgz.sha256 @@ -1 +1 @@ -feb9a7454abaf2c25bdeade2a6e638137290df8c0725a447e3aca04aef2bd8f0 codetruss-cli-latest.tgz +5d64313b8b60acbd1f93e2246557967885a98fdc8c486ea7b2a6417fd8acdac2 codetruss-cli-latest.tgz diff --git a/public/downloads/grammars/codetruss-grammars-latest.json b/public/downloads/grammars/codetruss-grammars-latest.json new file mode 100644 index 0000000..6f865bb --- /dev/null +++ b/public/downloads/grammars/codetruss-grammars-latest.json @@ -0,0 +1,37 @@ +{ + "packs": [ + { + "name": "python", + "version": "1.0.0", + "language": "python", + "runtime": { + "package": "web-tree-sitter", + "version": "0.22.6" + }, + "grammar": { + "package": "tree-sitter-wasms", + "version": "0.1.11" + }, + "files": [ + { + "name": "tree-sitter.js", + "url": "/downloads/grammars/python-1.0.0/tree-sitter.js", + "bytes": 74197, + "sha256": "ddcacb69cd26c07322c51b798a63805fd99c272177c9633a978f3886358ca070" + }, + { + "name": "tree-sitter.wasm", + "url": "/downloads/grammars/python-1.0.0/tree-sitter.wasm", + "bytes": 188635, + "sha256": "29208e71028ab0c11dfcc941255075aad75545394467aa22d817a6356714090f" + }, + { + "name": "tree-sitter-python.wasm", + "url": "/downloads/grammars/python-1.0.0/tree-sitter-python.wasm", + "bytes": 476105, + "sha256": "9056d0fb0c337810d019fae350e8167786119da98f0f282aceae7ab89ee8253b" + } + ] + } + ] +} diff --git a/public/downloads/grammars/python-1.0.0/tree-sitter-python.wasm b/public/downloads/grammars/python-1.0.0/tree-sitter-python.wasm new file mode 100644 index 0000000000000000000000000000000000000000..14237633a0d9ea3f890f9e1821a9cdb0f7a1ff6b GIT binary patch literal 476105 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 c`r!;(og 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 moduleOverrides=Object.assign({},Module),arguments_=[],thisProgram="./this.program",quit_=(e,t)=>{throw t},ENVIRONMENT_IS_WEB="object"==typeof window,ENVIRONMENT_IS_WORKER="function"==typeof importScripts,ENVIRONMENT_IS_NODE="object"==typeof process&&"object"==typeof process.versions&&"string"==typeof process.versions.node,scriptDirectory="",read_,readAsync,readBinary;function locateFile(e){return Module.locateFile?Module.locateFile(e,scriptDirectory):scriptDirectory+e}if(ENVIRONMENT_IS_NODE){var fs=require("fs"),nodePath=require("path");scriptDirectory=ENVIRONMENT_IS_WORKER?nodePath.dirname(scriptDirectory)+"/":__dirname+"/",read_=(e,t)=>(e=isFileURI(e)?new URL(e):nodePath.normalize(e),fs.readFileSync(e,t?void 0:"utf8")),readBinary=e=>{var t=read_(e,!0);return t.buffer||(t=new Uint8Array(t)),t},readAsync=(e,t,_,s=!0)=>{e=isFileURI(e)?new URL(e):nodePath.normalize(e),fs.readFile(e,s?void 0:"utf8",((e,r)=>{e?_(e):t(s?r.buffer:r)}))},!Module.thisProgram&&process.argv.length>1&&(thisProgram=process.argv[1].replace(/\\/g,"/")),arguments_=process.argv.slice(2),"undefined"!=typeof module&&(module.exports=Module),quit_=(e,t)=>{throw process.exitCode=e,t}}else(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER)&&(ENVIRONMENT_IS_WORKER?scriptDirectory=self.location.href:void 0!==document&&document.currentScript&&(scriptDirectory=document.currentScript.src),scriptDirectory=scriptDirectory.startsWith("blob:")?"":scriptDirectory.substr(0,scriptDirectory.replace(/[?#].*/,"").lastIndexOf("/")+1),read_=e=>{var t=new XMLHttpRequest;return t.open("GET",e,!1),t.send(null),t.responseText},ENVIRONMENT_IS_WORKER&&(readBinary=e=>{var t=new XMLHttpRequest;return t.open("GET",e,!1),t.responseType="arraybuffer",t.send(null),new Uint8Array(t.response)}),readAsync=(e,t,_)=>{var s=new XMLHttpRequest;s.open("GET",e,!0),s.responseType="arraybuffer",s.onload=()=>{200==s.status||0==s.status&&s.response?t(s.response):_()},s.onerror=_,s.send(null)});var out=Module.print||console.log.bind(console),err=Module.printErr||console.error.bind(console);Object.assign(Module,moduleOverrides),moduleOverrides=null,Module.arguments&&(arguments_=Module.arguments),Module.thisProgram&&(thisProgram=Module.thisProgram),Module.quit&&(quit_=Module.quit);var dynamicLibraries=Module.dynamicLibraries||[],wasmBinary,wasmMemory;Module.wasmBinary&&(wasmBinary=Module.wasmBinary),"object"!=typeof WebAssembly&&abort("no native wasm support detected");var ABORT=!1,EXITSTATUS,HEAP8,HEAPU8,HEAP16,HEAPU16,HEAP32,HEAPU32,HEAPF32,HEAPF64;function updateMemoryViews(){var e=wasmMemory.buffer;Module.HEAP8=HEAP8=new Int8Array(e),Module.HEAP16=HEAP16=new Int16Array(e),Module.HEAPU8=HEAPU8=new Uint8Array(e),Module.HEAPU16=HEAPU16=new Uint16Array(e),Module.HEAP32=HEAP32=new Int32Array(e),Module.HEAPU32=HEAPU32=new Uint32Array(e),Module.HEAPF32=HEAPF32=new Float32Array(e),Module.HEAPF64=HEAPF64=new Float64Array(e)}var INITIAL_MEMORY=Module.INITIAL_MEMORY||33554432;wasmMemory=Module.wasmMemory?Module.wasmMemory:new WebAssembly.Memory({initial:INITIAL_MEMORY/65536,maximum:32768}),updateMemoryViews(),INITIAL_MEMORY=wasmMemory.buffer.byteLength;var __ATPRERUN__=[],__ATINIT__=[],__ATMAIN__=[],__ATPOSTRUN__=[],__RELOC_FUNCS__=[],runtimeInitialized=!1;function preRun(){if(Module.preRun)for("function"==typeof Module.preRun&&(Module.preRun=[Module.preRun]);Module.preRun.length;)addOnPreRun(Module.preRun.shift());callRuntimeCallbacks(__ATPRERUN__)}function initRuntime(){runtimeInitialized=!0,callRuntimeCallbacks(__RELOC_FUNCS__),callRuntimeCallbacks(__ATINIT__)}function preMain(){callRuntimeCallbacks(__ATMAIN__)}function postRun(){if(Module.postRun)for("function"==typeof Module.postRun&&(Module.postRun=[Module.postRun]);Module.postRun.length;)addOnPostRun(Module.postRun.shift());callRuntimeCallbacks(__ATPOSTRUN__)}function addOnPreRun(e){__ATPRERUN__.unshift(e)}function addOnInit(e){__ATINIT__.unshift(e)}function addOnPostRun(e){__ATPOSTRUN__.unshift(e)}var runDependencies=0,runDependencyWatcher=null,dependenciesFulfilled=null;function getUniqueRunDependency(e){return e}function addRunDependency(e){runDependencies++,Module.monitorRunDependencies?.(runDependencies)}function removeRunDependency(e){if(runDependencies--,Module.monitorRunDependencies?.(runDependencies),0==runDependencies&&(null!==runDependencyWatcher&&(clearInterval(runDependencyWatcher),runDependencyWatcher=null),dependenciesFulfilled)){var t=dependenciesFulfilled;dependenciesFulfilled=null,t()}}function abort(e){throw Module.onAbort?.(e),err(e="Aborted("+e+")"),ABORT=!0,EXITSTATUS=1,e+=". Build with -sASSERTIONS for more info.",new WebAssembly.RuntimeError(e)}var dataURIPrefix="data:application/octet-stream;base64,",isDataURI=e=>e.startsWith(dataURIPrefix),isFileURI=e=>e.startsWith("file://"),wasmBinaryFile;function getBinarySync(e){if(e==wasmBinaryFile&&wasmBinary)return new Uint8Array(wasmBinary);if(readBinary)return readBinary(e);throw"both async and sync fetching of the wasm failed"}function getBinaryPromise(e){if(!wasmBinary&&(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER)){if("function"==typeof fetch&&!isFileURI(e))return fetch(e,{credentials:"same-origin"}).then((t=>{if(!t.ok)throw`failed to load wasm binary file at '${e}'`;return t.arrayBuffer()})).catch((()=>getBinarySync(e)));if(readAsync)return new Promise(((t,_)=>{readAsync(e,(e=>t(new Uint8Array(e))),_)}))}return Promise.resolve().then((()=>getBinarySync(e)))}function instantiateArrayBuffer(e,t,_){return getBinaryPromise(e).then((e=>WebAssembly.instantiate(e,t))).then(_,(e=>{err(`failed to asynchronously prepare wasm: ${e}`),abort(e)}))}function instantiateAsync(e,t,_,s){return e||"function"!=typeof WebAssembly.instantiateStreaming||isDataURI(t)||isFileURI(t)||ENVIRONMENT_IS_NODE||"function"!=typeof fetch?instantiateArrayBuffer(t,_,s):fetch(t,{credentials:"same-origin"}).then((e=>WebAssembly.instantiateStreaming(e,_).then(s,(function(e){return err(`wasm streaming compile failed: ${e}`),err("falling back to ArrayBuffer instantiation"),instantiateArrayBuffer(t,_,s)}))))}function createWasm(){var e={env:wasmImports,wasi_snapshot_preview1:wasmImports,"GOT.mem":new Proxy(wasmImports,GOTHandler),"GOT.func":new Proxy(wasmImports,GOTHandler)};function t(e,t){wasmExports=e.exports,wasmExports=relocateExports(wasmExports,1024);var _=getDylinkMetadata(t);return _.neededDynlibs&&(dynamicLibraries=_.neededDynlibs.concat(dynamicLibraries)),mergeLibSymbols(wasmExports,"main"),LDSO.init(),loadDylibs(),addOnInit(wasmExports.__wasm_call_ctors),__RELOC_FUNCS__.push(wasmExports.__wasm_apply_data_relocs),removeRunDependency("wasm-instantiate"),wasmExports}if(addRunDependency("wasm-instantiate"),Module.instantiateWasm)try{return Module.instantiateWasm(e,t)}catch(e){return err(`Module.instantiateWasm callback failed with error: ${e}`),!1}return instantiateAsync(wasmBinary,wasmBinaryFile,e,(function(e){t(e.instance,e.module)})),{}}wasmBinaryFile="tree-sitter.wasm",isDataURI(wasmBinaryFile)||(wasmBinaryFile=locateFile(wasmBinaryFile));var ASM_CONSTS={};function ExitStatus(e){this.name="ExitStatus",this.message=`Program terminated with exit(${e})`,this.status=e}var GOT={},currentModuleWeakSymbols=new Set([]),GOTHandler={get(e,t){var _=GOT[t];return _||(_=GOT[t]=new WebAssembly.Global({value:"i32",mutable:!0})),currentModuleWeakSymbols.has(t)||(_.required=!0),_}},callRuntimeCallbacks=e=>{for(;e.length>0;)e.shift()(Module)},UTF8Decoder="undefined"!=typeof TextDecoder?new TextDecoder("utf8"):void 0,UTF8ArrayToString=(e,t,_)=>{for(var s=t+_,r=t;e[r]&&!(r>=s);)++r;if(r-t>16&&e.buffer&&UTF8Decoder)return UTF8Decoder.decode(e.subarray(t,r));for(var a="";t>10,56320|1023&d)}}else a+=String.fromCharCode((31&o)<<6|n)}else a+=String.fromCharCode(o)}return a},getDylinkMetadata=e=>{var t=0,_=0;function s(){for(var _=0,s=1;;){var r=e[t++];if(_+=(127&r)*s,s*=128,!(128&r))break}return _}function r(){var _=s();return UTF8ArrayToString(e,(t+=_)-_,_)}function a(e,t){if(e)throw new Error(t)}var o="dylink.0";if(e instanceof WebAssembly.Module){var n=WebAssembly.Module.customSections(e,o);0===n.length&&(o="dylink",n=WebAssembly.Module.customSections(e,o)),a(0===n.length,"need dylink section"),_=(e=new Uint8Array(n[0])).length}else{a(!(1836278016==new Uint32Array(new Uint8Array(e.subarray(0,24)).buffer)[0]),"need to see wasm magic number"),a(0!==e[8],"need the dylink section to be first"),t=9;var l=s();_=t+l,o=r()}var d={neededDynlibs:[],tlsExports:new Set,weakImports:new Set};if("dylink"==o){d.memorySize=s(),d.memoryAlign=s(),d.tableSize=s(),d.tableAlign=s();for(var u=s(),m=0;m>1];case"i32":return HEAP32[e>>2];case"i64":abort("to do getValue(i64) use WASM_BIGINT");case"float":return HEAPF32[e>>2];case"double":return HEAPF64[e>>3];case"*":return HEAPU32[e>>2];default:abort(`invalid type for getValue: ${t}`)}}var newDSO=(e,t,_)=>{var s={refcount:1/0,name:e,exports:_,global:!0};return LDSO.loadedLibsByName[e]=s,null!=t&&(LDSO.loadedLibsByHandle[t]=s),s},LDSO={loadedLibsByName:{},loadedLibsByHandle:{},init(){newDSO("__main__",0,wasmImports)}},___heap_base=78096,zeroMemory=(e,t)=>(HEAPU8.fill(0,e,e+t),e),alignMemory=(e,t)=>Math.ceil(e/t)*t,getMemory=e=>{if(runtimeInitialized)return zeroMemory(_malloc(e),e);var t=___heap_base,_=t+alignMemory(e,16);return ___heap_base=_,GOT.__heap_base.value=_,t},isInternalSym=e=>["__cpp_exception","__c_longjmp","__wasm_apply_data_relocs","__dso_handle","__tls_size","__tls_align","__set_stack_limits","_emscripten_tls_init","__wasm_init_tls","__wasm_call_ctors","__start_em_asm","__stop_em_asm","__start_em_js","__stop_em_js"].includes(e)||e.startsWith("__em_js__"),uleb128Encode=(e,t)=>{e<128?t.push(e):t.push(e%128|128,e>>7)},sigToWasmTypes=e=>{for(var t={i:"i32",j:"i64",f:"f32",d:"f64",e:"externref",p:"i32"},_={parameters:[],results:"v"==e[0]?[]:[t[e[0]]]},s=1;s{var _=e.slice(0,1),s=e.slice(1),r={i:127,p:127,j:126,f:125,d:124,e:111};t.push(96),uleb128Encode(s.length,t);for(var a=0;a{if("function"==typeof WebAssembly.Function)return new WebAssembly.Function(sigToWasmTypes(t),e);var _=[1];generateFuncType(t,_);var s=[0,97,115,109,1,0,0,0,1];uleb128Encode(_.length,s),s.push(..._),s.push(2,7,1,1,101,1,102,0,0,7,5,1,1,102,0,0);var r=new WebAssembly.Module(new Uint8Array(s));return new WebAssembly.Instance(r,{e:{f:e}}).exports.f},wasmTableMirror=[],wasmTable=new WebAssembly.Table({initial:27,element:"anyfunc"}),getWasmTableEntry=e=>{var t=wasmTableMirror[e];return t||(e>=wasmTableMirror.length&&(wasmTableMirror.length=e+1),wasmTableMirror[e]=t=wasmTable.get(e)),t},updateTableMap=(e,t)=>{if(functionsInTableMap)for(var _=e;_(functionsInTableMap||(functionsInTableMap=new WeakMap,updateTableMap(0,wasmTable.length)),functionsInTableMap.get(e)||0),freeTableIndexes=[],getEmptyTableSlot=()=>{if(freeTableIndexes.length)return freeTableIndexes.pop();try{wasmTable.grow(1)}catch(e){if(!(e instanceof RangeError))throw e;throw"Unable to grow wasm table. Set ALLOW_TABLE_GROWTH."}return wasmTable.length-1},setWasmTableEntry=(e,t)=>{wasmTable.set(e,t),wasmTableMirror[e]=wasmTable.get(e)},addFunction=(e,t)=>{var _=getFunctionAddress(e);if(_)return _;var s=getEmptyTableSlot();try{setWasmTableEntry(s,e)}catch(_){if(!(_ instanceof TypeError))throw _;var r=convertJsFunctionToWasm(e,t);setWasmTableEntry(s,r)}return functionsInTableMap.set(e,s),s},updateGOT=(e,t)=>{for(var _ in e)if(!isInternalSym(_)){var s=e[_];_.startsWith("orig$")&&(_=_.split("$")[1],t=!0),GOT[_]||=new WebAssembly.Global({value:"i32",mutable:!0}),(t||0==GOT[_].value)&&("function"==typeof s?GOT[_].value=addFunction(s):"number"==typeof s?GOT[_].value=s:err(`unhandled export type for '${_}': ${typeof s}`))}},relocateExports=(e,t,_)=>{var s={};for(var r in e){var a=e[r];"object"==typeof a&&(a=a.value),"number"==typeof a&&(a+=t),s[r]=a}return updateGOT(s,_),s},isSymbolDefined=e=>{var t=wasmImports[e];return!(!t||t.stub)},dynCallLegacy=(e,t,_)=>(0,Module["dynCall_"+e])(t,..._),dynCall=(e,t,_=[])=>e.includes("j")?dynCallLegacy(e,t,_):getWasmTableEntry(t)(..._),createInvokeFunction=e=>function(){var t=stackSave();try{return dynCall(e,arguments[0],Array.prototype.slice.call(arguments,1))}catch(e){if(stackRestore(t),e!==e+0)throw e;_setThrew(1,0)}},resolveGlobalSymbol=(e,t=!1)=>{var _;return t&&"orig$"+e in wasmImports&&(e="orig$"+e),isSymbolDefined(e)?_=wasmImports[e]:e.startsWith("invoke_")&&(_=wasmImports[e]=createInvokeFunction(e.split("_")[1])),{sym:_,name:e}},UTF8ToString=(e,t)=>e?UTF8ArrayToString(HEAPU8,e,t):"",loadWebAssemblyModule=(binary,flags,libName,localScope,handle)=>{var metadata=getDylinkMetadata(binary);function loadModule(){var firstLoad=!handle||!HEAP8[handle+8];if(firstLoad){var memAlign=Math.pow(2,metadata.memoryAlign),memoryBase=metadata.memorySize?alignMemory(getMemory(metadata.memorySize+memAlign),memAlign):0,tableBase=metadata.tableSize?wasmTable.length:0;handle&&(HEAP8[handle+8]=1,HEAPU32[handle+12>>2]=memoryBase,HEAP32[handle+16>>2]=metadata.memorySize,HEAPU32[handle+20>>2]=tableBase,HEAP32[handle+24>>2]=metadata.tableSize)}else memoryBase=HEAPU32[handle+12>>2],tableBase=HEAPU32[handle+20>>2];var tableGrowthNeeded=tableBase+metadata.tableSize-wasmTable.length,moduleExports;function resolveSymbol(e){var t=resolveGlobalSymbol(e).sym;return!t&&localScope&&(t=localScope[e]),t||(t=moduleExports[e]),t}tableGrowthNeeded>0&&wasmTable.grow(tableGrowthNeeded);var proxyHandler={get(e,t){switch(t){case"__memory_base":return memoryBase;case"__table_base":return tableBase}if(t in wasmImports&&!wasmImports[t].stub)return wasmImports[t];var _;t in e||(e[t]=(...e)=>(_||=resolveSymbol(t),_(...e)));return e[t]}},proxy=new Proxy({},proxyHandler),info={"GOT.mem":new Proxy({},GOTHandler),"GOT.func":new Proxy({},GOTHandler),env:proxy,wasi_snapshot_preview1:proxy};function postInstantiation(module,instance){function addEmAsm(addr,body){for(var args=[],arity=0;arity<16&&-1!=body.indexOf("$"+arity);arity++)args.push("$"+arity);args=args.join(",");var func=`(${args}) => { ${body} };`;ASM_CONSTS[start]=eval(func)}if(updateTableMap(tableBase,metadata.tableSize),moduleExports=relocateExports(instance.exports,memoryBase),flags.allowUndefined||reportUndefinedSymbols(),"__start_em_asm"in moduleExports)for(var start=moduleExports.__start_em_asm,stop=moduleExports.__stop_em_asm;start ${body};`;moduleExports[name]=eval(func)}for(var name in moduleExports)if(name.startsWith("__em_js__")){var start=moduleExports[name],jsString=UTF8ToString(start),parts=jsString.split("<::>");addEmJs(name.replace("__em_js__",""),parts[0],parts[1]),delete moduleExports[name]}var applyRelocs=moduleExports.__wasm_apply_data_relocs;applyRelocs&&(runtimeInitialized?applyRelocs():__RELOC_FUNCS__.push(applyRelocs));var init=moduleExports.__wasm_call_ctors;return init&&(runtimeInitialized?init():__ATINIT__.push(init)),moduleExports}if(flags.loadAsync){if(binary instanceof WebAssembly.Module){var instance=new WebAssembly.Instance(binary,info);return Promise.resolve(postInstantiation(binary,instance))}return WebAssembly.instantiate(binary,info).then((e=>postInstantiation(e.module,e.instance)))}var module=binary instanceof WebAssembly.Module?binary:new WebAssembly.Module(binary),instance=new WebAssembly.Instance(module,info);return postInstantiation(module,instance)}return currentModuleWeakSymbols=metadata.weakImports,flags.loadAsync?metadata.neededDynlibs.reduce(((e,t)=>e.then((()=>loadDynamicLibrary(t,flags)))),Promise.resolve()).then(loadModule):(metadata.neededDynlibs.forEach((e=>loadDynamicLibrary(e,flags,localScope))),loadModule())},mergeLibSymbols=(e,t)=>{for(var[_,s]of Object.entries(e)){const e=e=>{isSymbolDefined(e)||(wasmImports[e]=s)};e(_);const t="__main_argc_argv";"main"==_&&e(t),_==t&&e("main"),_.startsWith("dynCall_")&&!Module.hasOwnProperty(_)&&(Module[_]=s)}},asyncLoad=(e,t,_,s)=>{var r=s?"":getUniqueRunDependency(`al ${e}`);readAsync(e,(e=>{t(new Uint8Array(e)),r&&removeRunDependency(r)}),(t=>{if(!_)throw`Loading data file "${e}" failed.`;_()})),r&&addRunDependency(r)};function loadDynamicLibrary(e,t={global:!0,nodelete:!0},_,s){var r=LDSO.loadedLibsByName[e];if(r)return t.global?r.global||(r.global=!0,mergeLibSymbols(r.exports,e)):_&&Object.assign(_,r.exports),t.nodelete&&r.refcount!==1/0&&(r.refcount=1/0),r.refcount++,s&&(LDSO.loadedLibsByHandle[s]=r),!t.loadAsync||Promise.resolve(!0);function a(){if(s){var _=HEAPU32[s+28>>2],r=HEAPU32[s+32>>2];if(_&&r){var a=HEAP8.slice(_,_+r);return t.loadAsync?Promise.resolve(a):a}}var o=locateFile(e);if(t.loadAsync)return new Promise((function(e,t){asyncLoad(o,e,t)}));if(!readBinary)throw new Error(`${o}: file not found, and synchronous loading of external files is not available`);return readBinary(o)}function o(){return t.loadAsync?a().then((r=>loadWebAssemblyModule(r,t,e,_,s))):loadWebAssemblyModule(a(),t,e,_,s)}function n(t){r.global?mergeLibSymbols(t,e):_&&Object.assign(_,t),r.exports=t}return(r=newDSO(e,s,"loading")).refcount=t.nodelete?1/0:1,r.global=t.global,t.loadAsync?o().then((e=>(n(e),!0))):(n(o()),!0)}var reportUndefinedSymbols=()=>{for(var[e,t]of Object.entries(GOT))if(0==t.value){var _=resolveGlobalSymbol(e,!0).sym;if(!_&&!t.required)continue;if("function"==typeof _)t.value=addFunction(_,_.sig);else{if("number"!=typeof _)throw new Error(`bad export type for '${e}': ${typeof _}`);t.value=_}}},loadDylibs=()=>{dynamicLibraries.length?(addRunDependency("loadDylibs"),dynamicLibraries.reduce(((e,t)=>e.then((()=>loadDynamicLibrary(t,{loadAsync:!0,global:!0,nodelete:!0,allowUndefined:!0})))),Promise.resolve()).then((()=>{reportUndefinedSymbols(),removeRunDependency("loadDylibs")}))):reportUndefinedSymbols()},noExitRuntime=Module.noExitRuntime||!0;function setValue(e,t,_="i8"){switch(_.endsWith("*")&&(_="*"),_){case"i1":case"i8":HEAP8[e]=t;break;case"i16":HEAP16[e>>1]=t;break;case"i32":HEAP32[e>>2]=t;break;case"i64":abort("to do setValue(i64) use WASM_BIGINT");case"float":HEAPF32[e>>2]=t;break;case"double":HEAPF64[e>>3]=t;break;case"*":HEAPU32[e>>2]=t;break;default:abort(`invalid type for setValue: ${_}`)}}var ___memory_base=new WebAssembly.Global({value:"i32",mutable:!1},1024),___stack_pointer=new WebAssembly.Global({value:"i32",mutable:!0},78096),___table_base=new WebAssembly.Global({value:"i32",mutable:!1},1),nowIsMonotonic=1,__emscripten_get_now_is_monotonic=()=>nowIsMonotonic;__emscripten_get_now_is_monotonic.sig="i";var _abort=()=>{abort("")};_abort.sig="v";var _emscripten_date_now=()=>Date.now(),_emscripten_get_now;_emscripten_date_now.sig="d",_emscripten_get_now=()=>performance.now(),_emscripten_get_now.sig="d";var _emscripten_memcpy_js=(e,t,_)=>HEAPU8.copyWithin(e,t,t+_);_emscripten_memcpy_js.sig="vppp";var getHeapMax=()=>2147483648,growMemory=e=>{var t=(e-wasmMemory.buffer.byteLength+65535)/65536;try{return wasmMemory.grow(t),updateMemoryViews(),1}catch(e){}},_emscripten_resize_heap=e=>{var t=HEAPU8.length;e>>>=0;var _=getHeapMax();if(e>_)return!1;for(var s,r,a=1;a<=4;a*=2){var o=t*(1+.2/a);o=Math.min(o,e+100663296);var n=Math.min(_,(s=Math.max(e,o))+((r=65536)-s%r)%r);if(growMemory(n))return!0}return!1};_emscripten_resize_heap.sig="ip";var _fd_close=e=>52;_fd_close.sig="ii";var convertI32PairToI53Checked=(e,t)=>t+2097152>>>0<4194305-!!e?(e>>>0)+4294967296*t:NaN;function _fd_seek(e,t,_,s,r){convertI32PairToI53Checked(t,_);return 70}_fd_seek.sig="iiiiip";var printCharBuffers=[null,[],[]],printChar=(e,t)=>{var _=printCharBuffers[e];0===t||10===t?((1===e?out:err)(UTF8ArrayToString(_,0)),_.length=0):_.push(t)},SYSCALLS={varargs:void 0,get(){var e=HEAP32[+SYSCALLS.varargs>>2];return SYSCALLS.varargs+=4,e},getp:()=>SYSCALLS.get(),getStr:e=>UTF8ToString(e)},_fd_write=(e,t,_,s)=>{for(var r=0,a=0;a<_;a++){var o=HEAPU32[t>>2],n=HEAPU32[t+4>>2];t+=8;for(var l=0;l>2]=r,0};function _tree_sitter_log_callback(e,t){if(currentLogCallback){const _=UTF8ToString(t);currentLogCallback(_,0!==e)}}function _tree_sitter_parse_callback(e,t,_,s,r){const a=currentParseCallback(t,{row:_,column:s});"string"==typeof a?(setValue(r,a.length,"i32"),stringToUTF16(a,e,10240)):setValue(r,0,"i32")}_fd_write.sig="iippp";var runtimeKeepaliveCounter=0,keepRuntimeAlive=()=>noExitRuntime||runtimeKeepaliveCounter>0,_proc_exit=e=>{EXITSTATUS=e,keepRuntimeAlive()||(Module.onExit?.(e),ABORT=!0),quit_(e,new ExitStatus(e))};_proc_exit.sig="vi";var exitJS=(e,t)=>{EXITSTATUS=e,_proc_exit(e)},handleException=e=>{if(e instanceof ExitStatus||"unwind"==e)return EXITSTATUS;quit_(1,e)},lengthBytesUTF8=e=>{for(var t=0,_=0;_=55296&&s<=57343?(t+=4,++_):t+=3}return t},stringToUTF8Array=(e,t,_,s)=>{if(!(s>0))return 0;for(var r=_,a=_+s-1,o=0;o=55296&&n<=57343)n=65536+((1023&n)<<10)|1023&e.charCodeAt(++o);if(n<=127){if(_>=a)break;t[_++]=n}else if(n<=2047){if(_+1>=a)break;t[_++]=192|n>>6,t[_++]=128|63&n}else if(n<=65535){if(_+2>=a)break;t[_++]=224|n>>12,t[_++]=128|n>>6&63,t[_++]=128|63&n}else{if(_+3>=a)break;t[_++]=240|n>>18,t[_++]=128|n>>12&63,t[_++]=128|n>>6&63,t[_++]=128|63&n}}return t[_]=0,_-r},stringToUTF8=(e,t,_)=>stringToUTF8Array(e,HEAPU8,t,_),stringToUTF8OnStack=e=>{var t=lengthBytesUTF8(e)+1,_=stackAlloc(t);return stringToUTF8(e,_,t),_},stringToUTF16=(e,t,_)=>{if(_??=2147483647,_<2)return 0;for(var s=t,r=(_-=2)<2*e.length?_/2:e.length,a=0;a>1]=o,t+=2}return HEAP16[t>>1]=0,t-s},AsciiToString=e=>{for(var t="";;){var _=HEAPU8[e++];if(!_)return t;t+=String.fromCharCode(_)}},wasmImports={__heap_base:___heap_base,__indirect_function_table:wasmTable,__memory_base:___memory_base,__stack_pointer:___stack_pointer,__table_base:___table_base,_emscripten_get_now_is_monotonic:__emscripten_get_now_is_monotonic,abort:_abort,emscripten_get_now:_emscripten_get_now,emscripten_memcpy_js:_emscripten_memcpy_js,emscripten_resize_heap:_emscripten_resize_heap,fd_close:_fd_close,fd_seek:_fd_seek,fd_write:_fd_write,memory:wasmMemory,tree_sitter_log_callback:_tree_sitter_log_callback,tree_sitter_parse_callback:_tree_sitter_parse_callback},wasmExports=createWasm(),___wasm_call_ctors=()=>(___wasm_call_ctors=wasmExports.__wasm_call_ctors)(),___wasm_apply_data_relocs=()=>(___wasm_apply_data_relocs=wasmExports.__wasm_apply_data_relocs)(),_malloc=Module._malloc=e=>(_malloc=Module._malloc=wasmExports.malloc)(e),_calloc=Module._calloc=(e,t)=>(_calloc=Module._calloc=wasmExports.calloc)(e,t),_realloc=Module._realloc=(e,t)=>(_realloc=Module._realloc=wasmExports.realloc)(e,t),_free=Module._free=e=>(_free=Module._free=wasmExports.free)(e),_ts_language_symbol_count=Module._ts_language_symbol_count=e=>(_ts_language_symbol_count=Module._ts_language_symbol_count=wasmExports.ts_language_symbol_count)(e),_ts_language_state_count=Module._ts_language_state_count=e=>(_ts_language_state_count=Module._ts_language_state_count=wasmExports.ts_language_state_count)(e),_ts_language_version=Module._ts_language_version=e=>(_ts_language_version=Module._ts_language_version=wasmExports.ts_language_version)(e),_ts_language_field_count=Module._ts_language_field_count=e=>(_ts_language_field_count=Module._ts_language_field_count=wasmExports.ts_language_field_count)(e),_ts_language_next_state=Module._ts_language_next_state=(e,t,_)=>(_ts_language_next_state=Module._ts_language_next_state=wasmExports.ts_language_next_state)(e,t,_),_ts_language_symbol_name=Module._ts_language_symbol_name=(e,t)=>(_ts_language_symbol_name=Module._ts_language_symbol_name=wasmExports.ts_language_symbol_name)(e,t),_ts_language_symbol_for_name=Module._ts_language_symbol_for_name=(e,t,_,s)=>(_ts_language_symbol_for_name=Module._ts_language_symbol_for_name=wasmExports.ts_language_symbol_for_name)(e,t,_,s),_strncmp=Module._strncmp=(e,t,_)=>(_strncmp=Module._strncmp=wasmExports.strncmp)(e,t,_),_ts_language_symbol_type=Module._ts_language_symbol_type=(e,t)=>(_ts_language_symbol_type=Module._ts_language_symbol_type=wasmExports.ts_language_symbol_type)(e,t),_ts_language_field_name_for_id=Module._ts_language_field_name_for_id=(e,t)=>(_ts_language_field_name_for_id=Module._ts_language_field_name_for_id=wasmExports.ts_language_field_name_for_id)(e,t),_ts_lookahead_iterator_new=Module._ts_lookahead_iterator_new=(e,t)=>(_ts_lookahead_iterator_new=Module._ts_lookahead_iterator_new=wasmExports.ts_lookahead_iterator_new)(e,t),_ts_lookahead_iterator_delete=Module._ts_lookahead_iterator_delete=e=>(_ts_lookahead_iterator_delete=Module._ts_lookahead_iterator_delete=wasmExports.ts_lookahead_iterator_delete)(e),_ts_lookahead_iterator_reset_state=Module._ts_lookahead_iterator_reset_state=(e,t)=>(_ts_lookahead_iterator_reset_state=Module._ts_lookahead_iterator_reset_state=wasmExports.ts_lookahead_iterator_reset_state)(e,t),_ts_lookahead_iterator_reset=Module._ts_lookahead_iterator_reset=(e,t,_)=>(_ts_lookahead_iterator_reset=Module._ts_lookahead_iterator_reset=wasmExports.ts_lookahead_iterator_reset)(e,t,_),_ts_lookahead_iterator_next=Module._ts_lookahead_iterator_next=e=>(_ts_lookahead_iterator_next=Module._ts_lookahead_iterator_next=wasmExports.ts_lookahead_iterator_next)(e),_ts_lookahead_iterator_current_symbol=Module._ts_lookahead_iterator_current_symbol=e=>(_ts_lookahead_iterator_current_symbol=Module._ts_lookahead_iterator_current_symbol=wasmExports.ts_lookahead_iterator_current_symbol)(e),_memset=Module._memset=(e,t,_)=>(_memset=Module._memset=wasmExports.memset)(e,t,_),_memcpy=Module._memcpy=(e,t,_)=>(_memcpy=Module._memcpy=wasmExports.memcpy)(e,t,_),_ts_parser_delete=Module._ts_parser_delete=e=>(_ts_parser_delete=Module._ts_parser_delete=wasmExports.ts_parser_delete)(e),_ts_parser_reset=Module._ts_parser_reset=e=>(_ts_parser_reset=Module._ts_parser_reset=wasmExports.ts_parser_reset)(e),_ts_parser_set_language=Module._ts_parser_set_language=(e,t)=>(_ts_parser_set_language=Module._ts_parser_set_language=wasmExports.ts_parser_set_language)(e,t),_ts_parser_timeout_micros=Module._ts_parser_timeout_micros=e=>(_ts_parser_timeout_micros=Module._ts_parser_timeout_micros=wasmExports.ts_parser_timeout_micros)(e),_ts_parser_set_timeout_micros=Module._ts_parser_set_timeout_micros=(e,t,_)=>(_ts_parser_set_timeout_micros=Module._ts_parser_set_timeout_micros=wasmExports.ts_parser_set_timeout_micros)(e,t,_),_ts_parser_set_included_ranges=Module._ts_parser_set_included_ranges=(e,t,_)=>(_ts_parser_set_included_ranges=Module._ts_parser_set_included_ranges=wasmExports.ts_parser_set_included_ranges)(e,t,_),_memmove=Module._memmove=(e,t,_)=>(_memmove=Module._memmove=wasmExports.memmove)(e,t,_),_memcmp=Module._memcmp=(e,t,_)=>(_memcmp=Module._memcmp=wasmExports.memcmp)(e,t,_),_ts_query_new=Module._ts_query_new=(e,t,_,s,r)=>(_ts_query_new=Module._ts_query_new=wasmExports.ts_query_new)(e,t,_,s,r),_ts_query_delete=Module._ts_query_delete=e=>(_ts_query_delete=Module._ts_query_delete=wasmExports.ts_query_delete)(e),_iswspace=Module._iswspace=e=>(_iswspace=Module._iswspace=wasmExports.iswspace)(e),_iswalnum=Module._iswalnum=e=>(_iswalnum=Module._iswalnum=wasmExports.iswalnum)(e),_ts_query_pattern_count=Module._ts_query_pattern_count=e=>(_ts_query_pattern_count=Module._ts_query_pattern_count=wasmExports.ts_query_pattern_count)(e),_ts_query_capture_count=Module._ts_query_capture_count=e=>(_ts_query_capture_count=Module._ts_query_capture_count=wasmExports.ts_query_capture_count)(e),_ts_query_string_count=Module._ts_query_string_count=e=>(_ts_query_string_count=Module._ts_query_string_count=wasmExports.ts_query_string_count)(e),_ts_query_capture_name_for_id=Module._ts_query_capture_name_for_id=(e,t,_)=>(_ts_query_capture_name_for_id=Module._ts_query_capture_name_for_id=wasmExports.ts_query_capture_name_for_id)(e,t,_),_ts_query_string_value_for_id=Module._ts_query_string_value_for_id=(e,t,_)=>(_ts_query_string_value_for_id=Module._ts_query_string_value_for_id=wasmExports.ts_query_string_value_for_id)(e,t,_),_ts_query_predicates_for_pattern=Module._ts_query_predicates_for_pattern=(e,t,_)=>(_ts_query_predicates_for_pattern=Module._ts_query_predicates_for_pattern=wasmExports.ts_query_predicates_for_pattern)(e,t,_),_ts_query_disable_capture=Module._ts_query_disable_capture=(e,t,_)=>(_ts_query_disable_capture=Module._ts_query_disable_capture=wasmExports.ts_query_disable_capture)(e,t,_),_ts_tree_copy=Module._ts_tree_copy=e=>(_ts_tree_copy=Module._ts_tree_copy=wasmExports.ts_tree_copy)(e),_ts_tree_delete=Module._ts_tree_delete=e=>(_ts_tree_delete=Module._ts_tree_delete=wasmExports.ts_tree_delete)(e),_ts_init=Module._ts_init=()=>(_ts_init=Module._ts_init=wasmExports.ts_init)(),_ts_parser_new_wasm=Module._ts_parser_new_wasm=()=>(_ts_parser_new_wasm=Module._ts_parser_new_wasm=wasmExports.ts_parser_new_wasm)(),_ts_parser_enable_logger_wasm=Module._ts_parser_enable_logger_wasm=(e,t)=>(_ts_parser_enable_logger_wasm=Module._ts_parser_enable_logger_wasm=wasmExports.ts_parser_enable_logger_wasm)(e,t),_ts_parser_parse_wasm=Module._ts_parser_parse_wasm=(e,t,_,s,r)=>(_ts_parser_parse_wasm=Module._ts_parser_parse_wasm=wasmExports.ts_parser_parse_wasm)(e,t,_,s,r),_ts_parser_included_ranges_wasm=Module._ts_parser_included_ranges_wasm=e=>(_ts_parser_included_ranges_wasm=Module._ts_parser_included_ranges_wasm=wasmExports.ts_parser_included_ranges_wasm)(e),_ts_language_type_is_named_wasm=Module._ts_language_type_is_named_wasm=(e,t)=>(_ts_language_type_is_named_wasm=Module._ts_language_type_is_named_wasm=wasmExports.ts_language_type_is_named_wasm)(e,t),_ts_language_type_is_visible_wasm=Module._ts_language_type_is_visible_wasm=(e,t)=>(_ts_language_type_is_visible_wasm=Module._ts_language_type_is_visible_wasm=wasmExports.ts_language_type_is_visible_wasm)(e,t),_ts_tree_root_node_wasm=Module._ts_tree_root_node_wasm=e=>(_ts_tree_root_node_wasm=Module._ts_tree_root_node_wasm=wasmExports.ts_tree_root_node_wasm)(e),_ts_tree_root_node_with_offset_wasm=Module._ts_tree_root_node_with_offset_wasm=e=>(_ts_tree_root_node_with_offset_wasm=Module._ts_tree_root_node_with_offset_wasm=wasmExports.ts_tree_root_node_with_offset_wasm)(e),_ts_tree_edit_wasm=Module._ts_tree_edit_wasm=e=>(_ts_tree_edit_wasm=Module._ts_tree_edit_wasm=wasmExports.ts_tree_edit_wasm)(e),_ts_tree_included_ranges_wasm=Module._ts_tree_included_ranges_wasm=e=>(_ts_tree_included_ranges_wasm=Module._ts_tree_included_ranges_wasm=wasmExports.ts_tree_included_ranges_wasm)(e),_ts_tree_get_changed_ranges_wasm=Module._ts_tree_get_changed_ranges_wasm=(e,t)=>(_ts_tree_get_changed_ranges_wasm=Module._ts_tree_get_changed_ranges_wasm=wasmExports.ts_tree_get_changed_ranges_wasm)(e,t),_ts_tree_cursor_new_wasm=Module._ts_tree_cursor_new_wasm=e=>(_ts_tree_cursor_new_wasm=Module._ts_tree_cursor_new_wasm=wasmExports.ts_tree_cursor_new_wasm)(e),_ts_tree_cursor_delete_wasm=Module._ts_tree_cursor_delete_wasm=e=>(_ts_tree_cursor_delete_wasm=Module._ts_tree_cursor_delete_wasm=wasmExports.ts_tree_cursor_delete_wasm)(e),_ts_tree_cursor_reset_wasm=Module._ts_tree_cursor_reset_wasm=e=>(_ts_tree_cursor_reset_wasm=Module._ts_tree_cursor_reset_wasm=wasmExports.ts_tree_cursor_reset_wasm)(e),_ts_tree_cursor_reset_to_wasm=Module._ts_tree_cursor_reset_to_wasm=(e,t)=>(_ts_tree_cursor_reset_to_wasm=Module._ts_tree_cursor_reset_to_wasm=wasmExports.ts_tree_cursor_reset_to_wasm)(e,t),_ts_tree_cursor_goto_first_child_wasm=Module._ts_tree_cursor_goto_first_child_wasm=e=>(_ts_tree_cursor_goto_first_child_wasm=Module._ts_tree_cursor_goto_first_child_wasm=wasmExports.ts_tree_cursor_goto_first_child_wasm)(e),_ts_tree_cursor_goto_last_child_wasm=Module._ts_tree_cursor_goto_last_child_wasm=e=>(_ts_tree_cursor_goto_last_child_wasm=Module._ts_tree_cursor_goto_last_child_wasm=wasmExports.ts_tree_cursor_goto_last_child_wasm)(e),_ts_tree_cursor_goto_first_child_for_index_wasm=Module._ts_tree_cursor_goto_first_child_for_index_wasm=e=>(_ts_tree_cursor_goto_first_child_for_index_wasm=Module._ts_tree_cursor_goto_first_child_for_index_wasm=wasmExports.ts_tree_cursor_goto_first_child_for_index_wasm)(e),_ts_tree_cursor_goto_first_child_for_position_wasm=Module._ts_tree_cursor_goto_first_child_for_position_wasm=e=>(_ts_tree_cursor_goto_first_child_for_position_wasm=Module._ts_tree_cursor_goto_first_child_for_position_wasm=wasmExports.ts_tree_cursor_goto_first_child_for_position_wasm)(e),_ts_tree_cursor_goto_next_sibling_wasm=Module._ts_tree_cursor_goto_next_sibling_wasm=e=>(_ts_tree_cursor_goto_next_sibling_wasm=Module._ts_tree_cursor_goto_next_sibling_wasm=wasmExports.ts_tree_cursor_goto_next_sibling_wasm)(e),_ts_tree_cursor_goto_previous_sibling_wasm=Module._ts_tree_cursor_goto_previous_sibling_wasm=e=>(_ts_tree_cursor_goto_previous_sibling_wasm=Module._ts_tree_cursor_goto_previous_sibling_wasm=wasmExports.ts_tree_cursor_goto_previous_sibling_wasm)(e),_ts_tree_cursor_goto_descendant_wasm=Module._ts_tree_cursor_goto_descendant_wasm=(e,t)=>(_ts_tree_cursor_goto_descendant_wasm=Module._ts_tree_cursor_goto_descendant_wasm=wasmExports.ts_tree_cursor_goto_descendant_wasm)(e,t),_ts_tree_cursor_goto_parent_wasm=Module._ts_tree_cursor_goto_parent_wasm=e=>(_ts_tree_cursor_goto_parent_wasm=Module._ts_tree_cursor_goto_parent_wasm=wasmExports.ts_tree_cursor_goto_parent_wasm)(e),_ts_tree_cursor_current_node_type_id_wasm=Module._ts_tree_cursor_current_node_type_id_wasm=e=>(_ts_tree_cursor_current_node_type_id_wasm=Module._ts_tree_cursor_current_node_type_id_wasm=wasmExports.ts_tree_cursor_current_node_type_id_wasm)(e),_ts_tree_cursor_current_node_state_id_wasm=Module._ts_tree_cursor_current_node_state_id_wasm=e=>(_ts_tree_cursor_current_node_state_id_wasm=Module._ts_tree_cursor_current_node_state_id_wasm=wasmExports.ts_tree_cursor_current_node_state_id_wasm)(e),_ts_tree_cursor_current_node_is_named_wasm=Module._ts_tree_cursor_current_node_is_named_wasm=e=>(_ts_tree_cursor_current_node_is_named_wasm=Module._ts_tree_cursor_current_node_is_named_wasm=wasmExports.ts_tree_cursor_current_node_is_named_wasm)(e),_ts_tree_cursor_current_node_is_missing_wasm=Module._ts_tree_cursor_current_node_is_missing_wasm=e=>(_ts_tree_cursor_current_node_is_missing_wasm=Module._ts_tree_cursor_current_node_is_missing_wasm=wasmExports.ts_tree_cursor_current_node_is_missing_wasm)(e),_ts_tree_cursor_current_node_id_wasm=Module._ts_tree_cursor_current_node_id_wasm=e=>(_ts_tree_cursor_current_node_id_wasm=Module._ts_tree_cursor_current_node_id_wasm=wasmExports.ts_tree_cursor_current_node_id_wasm)(e),_ts_tree_cursor_start_position_wasm=Module._ts_tree_cursor_start_position_wasm=e=>(_ts_tree_cursor_start_position_wasm=Module._ts_tree_cursor_start_position_wasm=wasmExports.ts_tree_cursor_start_position_wasm)(e),_ts_tree_cursor_end_position_wasm=Module._ts_tree_cursor_end_position_wasm=e=>(_ts_tree_cursor_end_position_wasm=Module._ts_tree_cursor_end_position_wasm=wasmExports.ts_tree_cursor_end_position_wasm)(e),_ts_tree_cursor_start_index_wasm=Module._ts_tree_cursor_start_index_wasm=e=>(_ts_tree_cursor_start_index_wasm=Module._ts_tree_cursor_start_index_wasm=wasmExports.ts_tree_cursor_start_index_wasm)(e),_ts_tree_cursor_end_index_wasm=Module._ts_tree_cursor_end_index_wasm=e=>(_ts_tree_cursor_end_index_wasm=Module._ts_tree_cursor_end_index_wasm=wasmExports.ts_tree_cursor_end_index_wasm)(e),_ts_tree_cursor_current_field_id_wasm=Module._ts_tree_cursor_current_field_id_wasm=e=>(_ts_tree_cursor_current_field_id_wasm=Module._ts_tree_cursor_current_field_id_wasm=wasmExports.ts_tree_cursor_current_field_id_wasm)(e),_ts_tree_cursor_current_depth_wasm=Module._ts_tree_cursor_current_depth_wasm=e=>(_ts_tree_cursor_current_depth_wasm=Module._ts_tree_cursor_current_depth_wasm=wasmExports.ts_tree_cursor_current_depth_wasm)(e),_ts_tree_cursor_current_descendant_index_wasm=Module._ts_tree_cursor_current_descendant_index_wasm=e=>(_ts_tree_cursor_current_descendant_index_wasm=Module._ts_tree_cursor_current_descendant_index_wasm=wasmExports.ts_tree_cursor_current_descendant_index_wasm)(e),_ts_tree_cursor_current_node_wasm=Module._ts_tree_cursor_current_node_wasm=e=>(_ts_tree_cursor_current_node_wasm=Module._ts_tree_cursor_current_node_wasm=wasmExports.ts_tree_cursor_current_node_wasm)(e),_ts_node_symbol_wasm=Module._ts_node_symbol_wasm=e=>(_ts_node_symbol_wasm=Module._ts_node_symbol_wasm=wasmExports.ts_node_symbol_wasm)(e),_ts_node_field_name_for_child_wasm=Module._ts_node_field_name_for_child_wasm=(e,t)=>(_ts_node_field_name_for_child_wasm=Module._ts_node_field_name_for_child_wasm=wasmExports.ts_node_field_name_for_child_wasm)(e,t),_ts_node_children_by_field_id_wasm=Module._ts_node_children_by_field_id_wasm=(e,t)=>(_ts_node_children_by_field_id_wasm=Module._ts_node_children_by_field_id_wasm=wasmExports.ts_node_children_by_field_id_wasm)(e,t),_ts_node_first_child_for_byte_wasm=Module._ts_node_first_child_for_byte_wasm=e=>(_ts_node_first_child_for_byte_wasm=Module._ts_node_first_child_for_byte_wasm=wasmExports.ts_node_first_child_for_byte_wasm)(e),_ts_node_first_named_child_for_byte_wasm=Module._ts_node_first_named_child_for_byte_wasm=e=>(_ts_node_first_named_child_for_byte_wasm=Module._ts_node_first_named_child_for_byte_wasm=wasmExports.ts_node_first_named_child_for_byte_wasm)(e),_ts_node_grammar_symbol_wasm=Module._ts_node_grammar_symbol_wasm=e=>(_ts_node_grammar_symbol_wasm=Module._ts_node_grammar_symbol_wasm=wasmExports.ts_node_grammar_symbol_wasm)(e),_ts_node_child_count_wasm=Module._ts_node_child_count_wasm=e=>(_ts_node_child_count_wasm=Module._ts_node_child_count_wasm=wasmExports.ts_node_child_count_wasm)(e),_ts_node_named_child_count_wasm=Module._ts_node_named_child_count_wasm=e=>(_ts_node_named_child_count_wasm=Module._ts_node_named_child_count_wasm=wasmExports.ts_node_named_child_count_wasm)(e),_ts_node_child_wasm=Module._ts_node_child_wasm=(e,t)=>(_ts_node_child_wasm=Module._ts_node_child_wasm=wasmExports.ts_node_child_wasm)(e,t),_ts_node_named_child_wasm=Module._ts_node_named_child_wasm=(e,t)=>(_ts_node_named_child_wasm=Module._ts_node_named_child_wasm=wasmExports.ts_node_named_child_wasm)(e,t),_ts_node_child_by_field_id_wasm=Module._ts_node_child_by_field_id_wasm=(e,t)=>(_ts_node_child_by_field_id_wasm=Module._ts_node_child_by_field_id_wasm=wasmExports.ts_node_child_by_field_id_wasm)(e,t),_ts_node_next_sibling_wasm=Module._ts_node_next_sibling_wasm=e=>(_ts_node_next_sibling_wasm=Module._ts_node_next_sibling_wasm=wasmExports.ts_node_next_sibling_wasm)(e),_ts_node_prev_sibling_wasm=Module._ts_node_prev_sibling_wasm=e=>(_ts_node_prev_sibling_wasm=Module._ts_node_prev_sibling_wasm=wasmExports.ts_node_prev_sibling_wasm)(e),_ts_node_next_named_sibling_wasm=Module._ts_node_next_named_sibling_wasm=e=>(_ts_node_next_named_sibling_wasm=Module._ts_node_next_named_sibling_wasm=wasmExports.ts_node_next_named_sibling_wasm)(e),_ts_node_prev_named_sibling_wasm=Module._ts_node_prev_named_sibling_wasm=e=>(_ts_node_prev_named_sibling_wasm=Module._ts_node_prev_named_sibling_wasm=wasmExports.ts_node_prev_named_sibling_wasm)(e),_ts_node_descendant_count_wasm=Module._ts_node_descendant_count_wasm=e=>(_ts_node_descendant_count_wasm=Module._ts_node_descendant_count_wasm=wasmExports.ts_node_descendant_count_wasm)(e),_ts_node_parent_wasm=Module._ts_node_parent_wasm=e=>(_ts_node_parent_wasm=Module._ts_node_parent_wasm=wasmExports.ts_node_parent_wasm)(e),_ts_node_descendant_for_index_wasm=Module._ts_node_descendant_for_index_wasm=e=>(_ts_node_descendant_for_index_wasm=Module._ts_node_descendant_for_index_wasm=wasmExports.ts_node_descendant_for_index_wasm)(e),_ts_node_named_descendant_for_index_wasm=Module._ts_node_named_descendant_for_index_wasm=e=>(_ts_node_named_descendant_for_index_wasm=Module._ts_node_named_descendant_for_index_wasm=wasmExports.ts_node_named_descendant_for_index_wasm)(e),_ts_node_descendant_for_position_wasm=Module._ts_node_descendant_for_position_wasm=e=>(_ts_node_descendant_for_position_wasm=Module._ts_node_descendant_for_position_wasm=wasmExports.ts_node_descendant_for_position_wasm)(e),_ts_node_named_descendant_for_position_wasm=Module._ts_node_named_descendant_for_position_wasm=e=>(_ts_node_named_descendant_for_position_wasm=Module._ts_node_named_descendant_for_position_wasm=wasmExports.ts_node_named_descendant_for_position_wasm)(e),_ts_node_start_point_wasm=Module._ts_node_start_point_wasm=e=>(_ts_node_start_point_wasm=Module._ts_node_start_point_wasm=wasmExports.ts_node_start_point_wasm)(e),_ts_node_end_point_wasm=Module._ts_node_end_point_wasm=e=>(_ts_node_end_point_wasm=Module._ts_node_end_point_wasm=wasmExports.ts_node_end_point_wasm)(e),_ts_node_start_index_wasm=Module._ts_node_start_index_wasm=e=>(_ts_node_start_index_wasm=Module._ts_node_start_index_wasm=wasmExports.ts_node_start_index_wasm)(e),_ts_node_end_index_wasm=Module._ts_node_end_index_wasm=e=>(_ts_node_end_index_wasm=Module._ts_node_end_index_wasm=wasmExports.ts_node_end_index_wasm)(e),_ts_node_to_string_wasm=Module._ts_node_to_string_wasm=e=>(_ts_node_to_string_wasm=Module._ts_node_to_string_wasm=wasmExports.ts_node_to_string_wasm)(e),_ts_node_children_wasm=Module._ts_node_children_wasm=e=>(_ts_node_children_wasm=Module._ts_node_children_wasm=wasmExports.ts_node_children_wasm)(e),_ts_node_named_children_wasm=Module._ts_node_named_children_wasm=e=>(_ts_node_named_children_wasm=Module._ts_node_named_children_wasm=wasmExports.ts_node_named_children_wasm)(e),_ts_node_descendants_of_type_wasm=Module._ts_node_descendants_of_type_wasm=(e,t,_,s,r,a,o)=>(_ts_node_descendants_of_type_wasm=Module._ts_node_descendants_of_type_wasm=wasmExports.ts_node_descendants_of_type_wasm)(e,t,_,s,r,a,o),_ts_node_is_named_wasm=Module._ts_node_is_named_wasm=e=>(_ts_node_is_named_wasm=Module._ts_node_is_named_wasm=wasmExports.ts_node_is_named_wasm)(e),_ts_node_has_changes_wasm=Module._ts_node_has_changes_wasm=e=>(_ts_node_has_changes_wasm=Module._ts_node_has_changes_wasm=wasmExports.ts_node_has_changes_wasm)(e),_ts_node_has_error_wasm=Module._ts_node_has_error_wasm=e=>(_ts_node_has_error_wasm=Module._ts_node_has_error_wasm=wasmExports.ts_node_has_error_wasm)(e),_ts_node_is_error_wasm=Module._ts_node_is_error_wasm=e=>(_ts_node_is_error_wasm=Module._ts_node_is_error_wasm=wasmExports.ts_node_is_error_wasm)(e),_ts_node_is_missing_wasm=Module._ts_node_is_missing_wasm=e=>(_ts_node_is_missing_wasm=Module._ts_node_is_missing_wasm=wasmExports.ts_node_is_missing_wasm)(e),_ts_node_is_extra_wasm=Module._ts_node_is_extra_wasm=e=>(_ts_node_is_extra_wasm=Module._ts_node_is_extra_wasm=wasmExports.ts_node_is_extra_wasm)(e),_ts_node_parse_state_wasm=Module._ts_node_parse_state_wasm=e=>(_ts_node_parse_state_wasm=Module._ts_node_parse_state_wasm=wasmExports.ts_node_parse_state_wasm)(e),_ts_node_next_parse_state_wasm=Module._ts_node_next_parse_state_wasm=e=>(_ts_node_next_parse_state_wasm=Module._ts_node_next_parse_state_wasm=wasmExports.ts_node_next_parse_state_wasm)(e),_ts_query_matches_wasm=Module._ts_query_matches_wasm=(e,t,_,s,r,a,o,n,l,d)=>(_ts_query_matches_wasm=Module._ts_query_matches_wasm=wasmExports.ts_query_matches_wasm)(e,t,_,s,r,a,o,n,l,d),_ts_query_captures_wasm=Module._ts_query_captures_wasm=(e,t,_,s,r,a,o,n,l,d)=>(_ts_query_captures_wasm=Module._ts_query_captures_wasm=wasmExports.ts_query_captures_wasm)(e,t,_,s,r,a,o,n,l,d),_iswalpha=Module._iswalpha=e=>(_iswalpha=Module._iswalpha=wasmExports.iswalpha)(e),_iswblank=Module._iswblank=e=>(_iswblank=Module._iswblank=wasmExports.iswblank)(e),_iswdigit=Module._iswdigit=e=>(_iswdigit=Module._iswdigit=wasmExports.iswdigit)(e),_iswlower=Module._iswlower=e=>(_iswlower=Module._iswlower=wasmExports.iswlower)(e),_iswupper=Module._iswupper=e=>(_iswupper=Module._iswupper=wasmExports.iswupper)(e),_iswxdigit=Module._iswxdigit=e=>(_iswxdigit=Module._iswxdigit=wasmExports.iswxdigit)(e),_memchr=Module._memchr=(e,t,_)=>(_memchr=Module._memchr=wasmExports.memchr)(e,t,_),_strlen=Module._strlen=e=>(_strlen=Module._strlen=wasmExports.strlen)(e),_strcmp=Module._strcmp=(e,t)=>(_strcmp=Module._strcmp=wasmExports.strcmp)(e,t),_strncat=Module._strncat=(e,t,_)=>(_strncat=Module._strncat=wasmExports.strncat)(e,t,_),_strncpy=Module._strncpy=(e,t,_)=>(_strncpy=Module._strncpy=wasmExports.strncpy)(e,t,_),_towlower=Module._towlower=e=>(_towlower=Module._towlower=wasmExports.towlower)(e),_towupper=Module._towupper=e=>(_towupper=Module._towupper=wasmExports.towupper)(e),_setThrew=(e,t)=>(_setThrew=wasmExports.setThrew)(e,t),stackSave=()=>(stackSave=wasmExports.stackSave)(),stackRestore=e=>(stackRestore=wasmExports.stackRestore)(e),stackAlloc=e=>(stackAlloc=wasmExports.stackAlloc)(e),dynCall_jiji=Module.dynCall_jiji=(e,t,_,s,r)=>(dynCall_jiji=Module.dynCall_jiji=wasmExports.dynCall_jiji)(e,t,_,s,r),_orig$ts_parser_timeout_micros=Module._orig$ts_parser_timeout_micros=e=>(_orig$ts_parser_timeout_micros=Module._orig$ts_parser_timeout_micros=wasmExports.orig$ts_parser_timeout_micros)(e),_orig$ts_parser_set_timeout_micros=Module._orig$ts_parser_set_timeout_micros=(e,t)=>(_orig$ts_parser_set_timeout_micros=Module._orig$ts_parser_set_timeout_micros=wasmExports.orig$ts_parser_set_timeout_micros)(e,t),calledRun;function callMain(e=[]){var t=resolveGlobalSymbol("main").sym;if(t){e.unshift(thisProgram);var _=e.length,s=stackAlloc(4*(_+1)),r=s;e.forEach((e=>{HEAPU32[r>>2]=stringToUTF8OnStack(e),r+=4})),HEAPU32[r>>2]=0;try{var a=t(_,s);return exitJS(a,!0),a}catch(e){return handleException(e)}}}function run(e=arguments_){function t(){calledRun||(calledRun=!0,Module.calledRun=!0,ABORT||(initRuntime(),preMain(),Module.onRuntimeInitialized&&Module.onRuntimeInitialized(),shouldRunNow&&callMain(e),postRun()))}runDependencies>0||(preRun(),runDependencies>0||(Module.setStatus?(Module.setStatus("Running..."),setTimeout((function(){setTimeout((function(){Module.setStatus("")}),1),t()}),1)):t()))}if(Module.AsciiToString=AsciiToString,Module.stringToUTF16=stringToUTF16,dependenciesFulfilled=function e(){calledRun||run(),calledRun||(dependenciesFulfilled=e)},Module.preInit)for("function"==typeof Module.preInit&&(Module.preInit=[Module.preInit]);Module.preInit.length>0;)Module.preInit.pop()();var shouldRunNow=!0;Module.noInitialRun&&(shouldRunNow=!1),run();const C=Module,INTERNAL={},SIZE_OF_INT=4,SIZE_OF_CURSOR=4*SIZE_OF_INT,SIZE_OF_NODE=5*SIZE_OF_INT,SIZE_OF_POINT=2*SIZE_OF_INT,SIZE_OF_RANGE=2*SIZE_OF_INT+2*SIZE_OF_POINT,ZERO_POINT={row:0,column:0},QUERY_WORD_REGEX=/[\w-.]*/g,PREDICATE_STEP_TYPE_CAPTURE=1,PREDICATE_STEP_TYPE_STRING=2,LANGUAGE_FUNCTION_REGEX=/^_?tree_sitter_\w+/;let VERSION,MIN_COMPATIBLE_VERSION,TRANSFER_BUFFER,currentParseCallback,currentLogCallback;class ParserImpl{static init(){TRANSFER_BUFFER=C._ts_init(),VERSION=getValue(TRANSFER_BUFFER,"i32"),MIN_COMPATIBLE_VERSION=getValue(TRANSFER_BUFFER+SIZE_OF_INT,"i32")}initialize(){C._ts_parser_new_wasm(),this[0]=getValue(TRANSFER_BUFFER,"i32"),this[1]=getValue(TRANSFER_BUFFER+SIZE_OF_INT,"i32")}delete(){C._ts_parser_delete(this[0]),C._free(this[1]),this[0]=0,this[1]=0}setLanguage(e){let t;if(e){if(e.constructor!==Language)throw new Error("Argument must be a Language");{t=e[0];const _=C._ts_language_version(t);if(_e.slice(t);else{if("function"!=typeof e)throw new Error("Argument must be a string or a function");currentParseCallback=e}this.logCallback?(currentLogCallback=this.logCallback,C._ts_parser_enable_logger_wasm(this[0],1)):(currentLogCallback=null,C._ts_parser_enable_logger_wasm(this[0],0));let s=0,r=0;if(_?.includedRanges){s=_.includedRanges.length,r=C._calloc(s,SIZE_OF_RANGE);let e=r;for(let t=0;t0){let s=t;for(let t=0;t0){let e=_;for(let _=0;_0){let s=t;for(let t=0;t0){let e=_;for(let _=0;_0){let _=t;for(let t=0;t0){let _=t;for(let t=0;t0){let e=n;for(let t=0;t0){if("string"!==r[0].type)throw new Error("Predicates must begin with a literal value");const t=r[0].value;let _,s=!0,a=!0;switch(t){case"any-not-eq?":case"not-eq?":s=!1;case"any-eq?":case"eq?":if(3!==r.length)throw new Error(`Wrong number of arguments to \`#${t}\` predicate. Expected 2, got ${r.length-1}`);if("capture"!==r[1].type)throw new Error(`First argument of \`#${t}\` predicate must be a capture. Got "${r[1].value}"`);if(a=!t.startsWith("any-"),"capture"===r[2].type){const t=r[1].name,_=r[2].name;w[e].push((e=>{const r=[],o=[];for(const s of e)s.name===t&&r.push(s.node),s.name===_&&o.push(s.node);const n=(e,t,_)=>_?e.text===t.text:e.text!==t.text;return a?r.every((e=>o.some((t=>n(e,t,s))))):r.some((e=>o.some((t=>n(e,t,s)))))}))}else{_=r[1].name;const t=r[2].value,o=e=>e.text===t,n=e=>e.text!==t;w[e].push((e=>{const t=[];for(const s of e)s.name===_&&t.push(s.node);const r=s?o:n;return a?t.every(r):t.some(r)}))}break;case"any-not-match?":case"not-match?":s=!1;case"any-match?":case"match?":if(3!==r.length)throw new Error(`Wrong number of arguments to \`#${t}\` predicate. Expected 2, got ${r.length-1}.`);if("capture"!==r[1].type)throw new Error(`First argument of \`#${t}\` predicate must be a capture. Got "${r[1].value}".`);if("string"!==r[2].type)throw new Error(`Second argument of \`#${t}\` predicate must be a string. Got @${r[2].value}.`);_=r[1].name;const o=new RegExp(r[2].value);a=!t.startsWith("any-"),w[e].push((e=>{const t=[];for(const s of e)s.name===_&&t.push(s.node.text);const r=(e,t)=>t?o.test(e):!o.test(e);return 0===t.length?!s:a?t.every((e=>r(e,s))):t.some((e=>r(e,s)))}));break;case"set!":if(r.length<2||r.length>3)throw new Error(`Wrong number of arguments to \`#set!\` predicate. Expected 1 or 2. Got ${r.length-1}.`);if(r.some((e=>"string"!==e.type)))throw new Error('Arguments to `#set!` predicate must be a strings.".');d[e]||(d[e]={}),d[e][r[1].value]=r[2]?r[2].value:null;break;case"is?":case"is-not?":if(r.length<2||r.length>3)throw new Error(`Wrong number of arguments to \`#${t}\` predicate. Expected 1 or 2. Got ${r.length-1}.`);if(r.some((e=>"string"!==e.type)))throw new Error(`Arguments to \`#${t}\` predicate must be a strings.".`);const n="is?"===t?u:m;n[e]||(n[e]={}),n[e][r[1].value]=r[2]?r[2].value:null;break;case"not-any-of?":s=!1;case"any-of?":if(r.length<2)throw new Error(`Wrong number of arguments to \`#${t}\` predicate. Expected at least 1. Got ${r.length-1}.`);if("capture"!==r[1].type)throw new Error(`First argument of \`#${t}\` predicate must be a capture. Got "${r[1].value}".`);for(let e=2;ee.value));w[e].push((e=>{const t=[];for(const s of e)s.name===_&&t.push(s.node.text);return 0===t.length?!s:t.every((e=>l.includes(e)))===s}));break;default:c[e].push({operator:t,operands:r.slice(1)})}r.length=0}}Object.freeze(d[e]),Object.freeze(u[e]),Object.freeze(m[e])}return C._free(_),new Query(INTERNAL,s,n,w,c,Object.freeze(d),Object.freeze(u),Object.freeze(m))}static load(e){let t;if(e instanceof Uint8Array)t=Promise.resolve(e);else{const _=e;if("undefined"!=typeof process&&process.versions&&process.versions.node){const e=require("fs");t=Promise.resolve(e.readFileSync(_))}else t=fetch(_).then((e=>e.arrayBuffer().then((t=>{if(e.ok)return new Uint8Array(t);{const _=new TextDecoder("utf-8").decode(t);throw new Error(`Language.load failed with status ${e.status}.\n\n${_}`)}}))))}return t.then((e=>loadWebAssemblyModule(e,{loadAsync:!0}))).then((e=>{const t=Object.keys(e),_=t.find((e=>LANGUAGE_FUNCTION_REGEX.test(e)&&!e.includes("external_scanner_")));_||console.log(`Couldn't find language function in WASM file. Symbols:\n${JSON.stringify(t,null,2)}`);const s=e[_]();return new Language(INTERNAL,s)}))}}class LookaheadIterable{constructor(e,t,_){assertInternal(e),this[0]=t,this.language=_}get currentTypeId(){return C._ts_lookahead_iterator_current_symbol(this[0])}get currentType(){return this.language.types[this.currentTypeId]||"ERROR"}delete(){C._ts_lookahead_iterator_delete(this[0]),this[0]=0}resetState(e){return C._ts_lookahead_iterator_reset_state(this[0],e)}reset(e,t){return!!C._ts_lookahead_iterator_reset(this[0],e[0],t)&&(this.language=e,!0)}[Symbol.iterator](){const e=this;return{next:()=>C._ts_lookahead_iterator_next(e[0])?{done:!1,value:e.currentType}:{done:!0,value:""}}}}class Query{constructor(e,t,_,s,r,a,o,n){assertInternal(e),this[0]=t,this.captureNames=_,this.textPredicates=s,this.predicates=r,this.setProperties=a,this.assertedProperties=o,this.refutedProperties=n,this.exceededMatchLimit=!1}delete(){C._ts_query_delete(this[0]),this[0]=0}matches(e,{startPosition:t=ZERO_POINT,endPosition:_=ZERO_POINT,startIndex:s=0,endIndex:r=0,matchLimit:a=4294967295,maxStartDepth:o=4294967295}={}){if("number"!=typeof a)throw new Error("Arguments must be numbers");marshalNode(e),C._ts_query_matches_wasm(this[0],e.tree[0],t.row,t.column,_.row,_.column,s,r,a,o);const n=getValue(TRANSFER_BUFFER,"i32"),l=getValue(TRANSFER_BUFFER+SIZE_OF_INT,"i32"),d=getValue(TRANSFER_BUFFER+2*SIZE_OF_INT,"i32"),u=new Array(n);this.exceededMatchLimit=Boolean(d);let m=0,c=l;for(let t=0;te(s)))){u[m]={pattern:t,captures:s};const e=this.setProperties[t];e&&(u[m].setProperties=e);const _=this.assertedProperties[t];_&&(u[m].assertedProperties=_);const r=this.refutedProperties[t];r&&(u[m].refutedProperties=r),m++}}return u.length=m,C._free(l),u}captures(e,{startPosition:t=ZERO_POINT,endPosition:_=ZERO_POINT,startIndex:s=0,endIndex:r=0,matchLimit:a=4294967295,maxStartDepth:o=4294967295}={}){if("number"!=typeof a)throw new Error("Arguments must be numbers");marshalNode(e),C._ts_query_captures_wasm(this[0],e.tree[0],t.row,t.column,_.row,_.column,s,r,a,o);const n=getValue(TRANSFER_BUFFER,"i32"),l=getValue(TRANSFER_BUFFER+SIZE_OF_INT,"i32"),d=getValue(TRANSFER_BUFFER+2*SIZE_OF_INT,"i32"),u=[];this.exceededMatchLimit=Boolean(d);const m=[];let c=l;for(let t=0;te(m)))){const e=m[s],_=this.setProperties[t];_&&(e.setProperties=_);const r=this.assertedProperties[t];r&&(e.assertedProperties=r);const a=this.refutedProperties[t];a&&(e.refutedProperties=a),u.push(e)}}return C._free(l),u}predicatesForPattern(e){return this.predicates[e]}disableCapture(e){const t=lengthBytesUTF8(e),_=C._malloc(t+1);stringToUTF8(e,_,t+1),C._ts_query_disable_capture(this[0],_,t),C._free(_)}didExceedMatchLimit(){return this.exceededMatchLimit}}function getText(e,t,_){const s=_-t;let r=e.textCallback(t,null,_);for(t+=r.length;t<_;){const s=e.textCallback(t,null,_);if(!(s&&s.length>0))break;t+=s.length,r+=s}return t>_&&(r=r.slice(0,s)),r}function unmarshalCaptures(e,t,_,s){for(let r=0,a=s.length;r>>0,column:getValue(e+SIZE_OF_INT,"i32")>>>0}}function marshalRange(e,t){marshalPoint(e,t.startPosition),marshalPoint(e+=SIZE_OF_POINT,t.endPosition),setValue(e+=SIZE_OF_POINT,t.startIndex,"i32"),setValue(e+=SIZE_OF_INT,t.endIndex,"i32"),e+=SIZE_OF_INT}function unmarshalRange(e){const t={};return t.startPosition=unmarshalPoint(e),e+=SIZE_OF_POINT,t.endPosition=unmarshalPoint(e),e+=SIZE_OF_POINT,t.startIndex=getValue(e,"i32")>>>0,e+=SIZE_OF_INT,t.endIndex=getValue(e,"i32")>>>0,t}function marshalEdit(e){let t=TRANSFER_BUFFER;marshalPoint(t,e.startPosition),t+=SIZE_OF_POINT,marshalPoint(t,e.oldEndPosition),t+=SIZE_OF_POINT,marshalPoint(t,e.newEndPosition),t+=SIZE_OF_POINT,setValue(t,e.startIndex,"i32"),t+=SIZE_OF_INT,setValue(t,e.oldEndIndex,"i32"),t+=SIZE_OF_INT,setValue(t,e.newEndIndex,"i32"),t+=SIZE_OF_INT}for(const e of Object.getOwnPropertyNames(ParserImpl.prototype))Object.defineProperty(Parser.prototype,e,{value:ParserImpl.prototype[e],enumerable:!1,writable:!1});Parser.Language=Language,Module.onRuntimeInitialized=()=>{ParserImpl.init(),resolveInitPromise()}})))}}return Parser}();"object"==typeof exports&&(module.exports=TreeSitter); diff --git a/public/downloads/grammars/python-1.0.0/tree-sitter.js.sha256 b/public/downloads/grammars/python-1.0.0/tree-sitter.js.sha256 new file mode 100644 index 0000000..51639d1 --- /dev/null +++ b/public/downloads/grammars/python-1.0.0/tree-sitter.js.sha256 @@ -0,0 +1 @@ +ddcacb69cd26c07322c51b798a63805fd99c272177c9633a978f3886358ca070 tree-sitter.js diff --git a/public/downloads/grammars/python-1.0.0/tree-sitter.wasm b/public/downloads/grammars/python-1.0.0/tree-sitter.wasm new file mode 100644 index 0000000000000000000000000000000000000000..0ac880b80e5eb85299e9eed43124a465a6f52ee0 GIT binary patch literal 188635 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 P`~iPd;ExJKufYERH/dev/null 2>&1; then + +# `command -v codetruss` succeeding is not the same as it being the binary just +# installed: an older install earlier in PATH shadows this one, and the hooks +# invoke `codetruss` by name. Compare the resolved targets before saying Ready. +real_path() { + node -e 'const fs = require("node:fs"); const p = process.argv[1]; try { process.stdout.write(fs.realpathSync(p)) } catch { process.stdout.write(p) }' "$1" +} + +RESOLVED="$(command -v codetruss 2>/dev/null || true)" +if [ -z "$RESOLVED" ]; then printf 'Add %s/bin to PATH, then run: codetruss setup\n' "$PREFIX" -else - printf '%s\n' 'Ready. Run inside your Git repository: codetruss setup' + exit 0 fi + +RESOLVED_TARGET="$(real_path "$RESOLVED")" +INSTALLED_TARGET="$(real_path "$EXECUTABLE")" +if [ "$RESOLVED_TARGET" != "$INSTALLED_TARGET" ]; then + printf 'Warning: `codetruss` on your PATH is %s, not the install that just completed at %s.\n' "$RESOLVED" "$EXECUTABLE" >&2 + printf 'Running `codetruss` would use the older one. Put %s/bin ahead of it in PATH (or remove the shadowing install), then run: codetruss setup\n' "$PREFIX" >&2 + exit 0 +fi + +printf '%s\n' 'Ready. Run inside your Git repository: codetruss setup' diff --git a/release-reference.json b/release-reference.json index 8ccb631..17042be 100644 --- a/release-reference.json +++ b/release-reference.json @@ -1,8 +1,8 @@ { "schemaVersion": 1, - "version": "0.2.39", - "websiteArchive": "https://codetruss.com/downloads/codetruss-cli-0.2.39.tgz", - "archiveSha256": "feb9a7454abaf2c25bdeade2a6e638137290df8c0725a447e3aca04aef2bd8f0", - "sbomSha256": "8bd47df2b79d979883cb0372abfc26d380b3ad2fd10327538da8cb15e838d1b4", - "bundleSha256": "85f3475cb84d4ce349d43a0c81c68cbf40bd573e731c5e731eeff55ae7405c4b" + "version": "0.2.40", + "websiteArchive": "https://codetruss.com/downloads/codetruss-cli-0.2.40.tgz", + "archiveSha256": "5d64313b8b60acbd1f93e2246557967885a98fdc8c486ea7b2a6417fd8acdac2", + "sbomSha256": "a78a5a08993e2266cee606f892d2afe118880605dd911d3f2149f99e4e8001bd", + "bundleSha256": "7dcf9a22457c6790c08b2ddc1186f1c73213e58ad6920aa7f164c8ce2d3e9076" }