@slicedearth/whoisleuth-cli 2.3.0 → 2.4.0

package/NOTICE

@@ -38,6 +38,12 @@ distributed as third-party-notices.txt. The website inventory is served at
 only the CLI runtime dependency closure. Both are generated from the reviewed
 lockfile, and the website inventory is checked for lockfile drift in CI.
 
+The development-only fixtures/risk-evaluation/rows.json is a minimised,
+stratified adaptation of PhiUSIIL Phishing URL (Website), Arvind Prasad and
+Shalini Chandra (2024), licensed under CC BY 4.0 without warranties. The source
+and licence links, modifications and reproduction instructions are in that
+directory's README.md. This dataset is not included in the website or CLI.
+
 The generated Unicode confusable projection is derived from Unicode UTS #39
 data file confusables.txt, Unicode version 17.0.0.
 

package/README.md

@@ -51,14 +51,7 @@ only `bulk` accepts multiple targets.
 
 ## Command groups
 
-| Group | Common commands |
-| --- | --- |
-| Investigate | `lookup`, `bulk`, `discover`, `ct-search`, `posture`, `http`, `tls`, `compare`, `mail-headers`, `brief` |
-| Respond | `case-pack`, `change-packet`, `sharing-review`, `export` |
-| Assure | `dnssec-validate`, `mail-transport`, `domain-control`, `assurance`, `workflow-plan`, `diff`, `inspect-archive`, `verify-artifact` |
-| Utilities | `doctor`, `commands`, `completion`, `manual`, `registry-scaffold` |
-
-Use the installed registry for the complete inventory:
+Use the installed registry to browse Investigate, Respond, Assure and Utilities:
 
 ```bash
 whoisleuth commands --group investigate
@@ -67,10 +60,6 @@ whoisleuth commands --json
 whoisleuth manual | man -l -
 ```
 
-`registry-scaffold` has a separate fixture contract: its `--profile` selects a
-fixed fixture profile and it rejects shared `--config` profiles. It creates
-sanitised local fixture material.
-
 ## Collection and output
 
 Fast Lookup is registration-first. Deep Lookup explicitly adds the applicable
@@ -86,9 +75,24 @@ or domain-only output only where declared. `--output` writes a private local
 file atomically and refuses an existing path unless `--force` is selected.
 `--strict-exit` and `--fail-on` expose selected evidence states to automation.
 
-Exit codes are 0 for completion, 2 for invalid input, 3 for collection or
-comparison failure, 4 for a partial result or unmet selected evidence policy,
-70 for internal bootstrap failure, 130 for cancellation and 143 for SIGTERM.
+`case open --domain example.test --output cases.json` creates an ordinary local
+Case file. `case show`, `note`, `pin`, `assess` and `recheck` review or update it
+offline. Mutations require explicit output and preserve earlier retained evidence;
+see `docs/cli.md#local-case-files` for JSON inputs and conflict handling. Working
+files contain private analyst content, not attached file bytes.
+
+`manifest --package --output evidence.wlep --passphrase-file ./passphrase.txt`
+encrypts selected evidence files and their manifest. Use the same explicit
+passphrase file with `verify-artifact --package` to authenticate and verify it
+offline. Ordinary ZIPs and folder exports remain unencrypted; see `docs/cli.md`
+for complete examples and file-handling boundaries.
+
+`workflow-run` pauses on a partial collection. Resume retains it without
+recollection and keeps exit code 4 even if later steps finish. Failed validation
+or export steps remain retryable. See `docs/cli.md` for checkpoint compatibility.
+
+The included `docs/cli-reference.md` lists common exit codes and compatibility
+contracts. A completed command can still contain partial source evidence.
 
 ## Repository checkout
 

package/bin/whoisleuth.mjs

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
 import EXIT_CODES from "../cli/exit-codes.mjs";
-import { metaActionDefinition } from "../cli/command-reference.mjs";
+import { HELP, commandHelp, isCliCommand, metaActionDefinition } from "../cli/command-reference.mjs";
+import { presentTerminalOutput, terminalPresentation } from "../cli/terminal-presentation.mjs";
 for (const stream of [process.stdout, process.stderr]) {
     stream.on('error', (error) => {
         if (error.code === 'EPIPE')
@@ -10,6 +11,9 @@ for (const stream of [process.stdout, process.stderr]) {
     });
 }
 const argv = process.argv.slice(2);
+const rootHelp = argv.length === 1 && metaActionDefinition('help').aliases.includes(argv[0] ?? '');
+const command = argv.length === 2 && isCliCommand(argv[0])
+    && metaActionDefinition('help').aliases.includes(argv[1] ?? '') ? argv[0] : null;
 if (argv.length === 1 && metaActionDefinition('version').aliases.includes(argv[0] ?? '')) {
     const require = createRequire(import.meta.url);
     const metadata = require('../package.json');
@@ -21,6 +25,9 @@ if (argv.length === 1 && metaActionDefinition('version').aliases.includes(argv[0
         process.stdout.write(`${metadata.version}\n`);
     }
 }
+else if (rootHelp || command) {
+    process.stdout.write(presentTerminalOutput(command ? commandHelp(command) : HELP, terminalPresentation(process.stdout)));
+}
 else {
     const [configModule, errorsModule, outputModule, runnerModule] = await Promise.all([
         import("../cli/config-profile.mjs"),

package/cli/archive-content-digest.mjs

@@ -0,0 +1,14 @@
+/** Bare hashes retain their original v1 meaning; new identities declare v2. */
+export function parseArchiveContentDigest(value) {
+    if (value === null || value === undefined || value === '')
+        return null;
+    if (typeof value !== 'string' || value.length > 'sorted-json-v2:sha256:'.length + 64) {
+        throw new TypeError('Expected archive content digest must be sha256:<64 lowercase hex> or sorted-json-v2:sha256:<64 lowercase hex>.');
+    }
+    const explicit = value.startsWith('sorted-json-v2:');
+    const digestSha256 = explicit ? value.slice('sorted-json-v2:'.length) : value;
+    if (!/^sha256:[a-f0-9]{64}$/u.test(digestSha256)) {
+        throw new TypeError('Expected archive content digest must be sha256:<64 lowercase hex> or sorted-json-v2:sha256:<64 lowercase hex>.');
+    }
+    return Object.freeze({ canonicalization: explicit ? 'sorted-json-v2' : 'sorted-json-v1', digestSha256 });
+}

package/cli/archive-inspect.mjs

@@ -1,14 +1,13 @@
 import { Buffer } from 'node:buffer';
 import { createHash } from 'node:crypto';
 import { domainToASCII } from 'node:url';
-import { scanBoundedJson } from "../lib/bounded-json.mjs";
-import { decryptWorkspaceArchive, isEncryptedWorkspaceArchive, } from "../packages/workspace/workspace-archive-crypto.mjs";
 import { WORKSPACE_ARCHIVE_SCHEMA, readWorkspaceArchive, } from "../packages/workspace/workspace-archive.mjs";
-import { canonicalArtifactJson } from "../packages/evidence/artifact-integrity.mjs";
-import { MAX_OFFLINE_ARTIFACT_BYTES, verifyOfflineArtifact, } from "./artifact-verify.mjs";
+import { canonicalArtifactJson, canonicalArtifactJsonV2 } from "../packages/evidence/artifact-integrity.mjs";
+import { parseArchiveContentDigest } from "./archive-content-digest.mjs";
+import { verifyOfflineWorkspaceArchive } from "./artifact-verify.mjs";
 import { safeTerminalValue } from "./formatters/terminal.mjs";
 export const ARCHIVE_INSPECTION_SCHEMA = 'whoisleuth.workspace-archive-inspection';
-export const ARCHIVE_INSPECTION_VERSION = 2;
+export const ARCHIVE_INSPECTION_VERSION = 3;
 export const MAX_ARCHIVE_SEARCH_LENGTH = 253;
 export const MAX_ARCHIVE_SEARCH_MATCHES = 100;
 export const MAX_ARCHIVE_SEARCH_NODES = 100_000;
@@ -22,32 +21,11 @@ const SEARCHABLE_FIELDS = new Set([
     'target',
 ]);
 const CONTROL_RE = /[\u0000-\u001f\u007f]/u;
-const SHA256_DIGEST_RE = /^sha256:[a-f0-9]{64}$/u;
 function record(value) {
     return value && typeof value === 'object' && !Array.isArray(value)
         ? value
         : null;
 }
-function parseJson(raw) {
-    if (typeof raw !== 'string')
-        throw new TypeError('Archive input must be UTF-8 JSON text.');
-    const bytes = Buffer.byteLength(raw, 'utf8');
-    if (bytes === 0 || bytes > MAX_OFFLINE_ARTIFACT_BYTES) {
-        throw new TypeError(`Archive input must be between 1 byte and ${MAX_OFFLINE_ARTIFACT_BYTES} bytes.`);
-    }
-    let parsed;
-    try {
-        scanBoundedJson(raw);
-        parsed = JSON.parse(raw);
-    }
-    catch {
-        throw new TypeError('Archive input must be valid bounded JSON without duplicate keys.');
-    }
-    const value = record(parsed);
-    if (!value)
-        throw new TypeError('Archive input must contain one JSON object.');
-    return value;
-}
 function normalizeSearch(value) {
     if (value === null || value === undefined || value === '')
         return null;
@@ -71,7 +49,7 @@ function canonicalSearchValue(value) {
 function valueDigest(value) {
     return createHash('sha256').update(value, 'utf8').digest('hex');
 }
-function archiveContentDigest(sections) {
+function archiveContentDigests(sections) {
     const identity = sections.map((section) => ({
         id: section.id,
         schema: section.schema,
@@ -85,15 +63,10 @@ function archiveContentDigest(sections) {
             return content;
         })(),
     }));
-    return `sha256:${createHash('sha256').update(canonicalArtifactJson(identity), 'utf8').digest('hex')}`;
-}
-function expectedContentDigest(value) {
-    if (value === null || value === undefined || value === '')
-        return null;
-    if (typeof value !== 'string' || !SHA256_DIGEST_RE.test(value)) {
-        throw new TypeError('Expected archive content digest must use the form sha256 followed by 64 lowercase hexadecimal characters.');
-    }
-    return value;
+    return Object.freeze({
+        current: `sha256:${createHash('sha256').update(canonicalArtifactJsonV2(identity), 'utf8').digest('hex')}`,
+        legacy: `sha256:${createHash('sha256').update(canonicalArtifactJson(identity), 'utf8').digest('hex')}`,
+    });
 }
 function searchSection(section, value, search, reveal, results, state) {
     const stack = [{ value, depth: 0 }];
@@ -146,21 +119,10 @@ function searchSection(section, value, search, reveal, results, state) {
     }
 }
 export async function inspectWorkspaceArchive(raw, options = {}) {
-    const parsed = parseJson(raw);
-    const encrypted = isEncryptedWorkspaceArchive(parsed);
-    if (encrypted && !options.passphrase) {
-        throw new TypeError('Encrypted archive inspection requires a separate passphrase file.');
-    }
-    await verifyOfflineArtifact(raw, options.passphrase === undefined
-        ? {}
-        : { passphrase: options.passphrase });
-    const archiveValue = encrypted
-        ? await decryptWorkspaceArchive(parsed, options.passphrase)
-        : parsed;
-    const archive = await readWorkspaceArchive(archiveValue);
-    const contentDigestSha256 = archiveContentDigest(archive.sections);
-    const expectedDigest = expectedContentDigest(options.expectedContentDigest);
-    if (expectedDigest && expectedDigest !== contentDigestSha256) {
+    const expectedDigest = parseArchiveContentDigest(options.expectedContentDigest);
+    const { archive, encrypted } = await verifyOfflineWorkspaceArchive(raw, options);
+    const digests = archiveContentDigests(archive.sections);
+    if (expectedDigest && expectedDigest.digestSha256 !== (expectedDigest.canonicalization === 'sorted-json-v2' ? digests.current : digests.legacy)) {
         throw new TypeError('Workspace archive content digest did not match the expected value.');
     }
     const search = normalizeSearch(options.search);
@@ -196,7 +158,9 @@ export async function inspectWorkspaceArchive(raw, options = {}) {
             inputBytes: Buffer.byteLength(raw, 'utf8'),
             sectionCount: archive.sections.length,
             recordCount: archive.sections.reduce((sum, section) => sum + section.recordCount, 0),
-            contentDigestSha256,
+            contentDigest: `sorted-json-v2:${digests.current}`,
+            contentDigestSha256: digests.legacy,
+            expectedContentDigestCanonicalization: expectedDigest?.canonicalization ?? null,
         }),
         sections: Object.freeze(archive.sections.map((section) => Object.freeze({
             id: section.id,
@@ -218,6 +182,7 @@ export async function inspectWorkspaceArchive(raw, options = {}) {
         limitations: Object.freeze([
             'Inspection validates the archive and reports bounded section metadata without printing retained evidence by default.',
             'The content digest covers ordered section identities and normalised content after excluding each section export timestamp. Equality detects matching retained archive content but does not authenticate its source or accuracy.',
+            'Use the versioned contentDigest identity for new comparisons. The compatibility contentDigestSha256 field and bare expected hashes retain the original locale-sensitive digest; they are not a cross-locale identity guarantee.',
             'Search checks exact values in a small allowlist of target fields and never searches analyst notes, contacts, or raw evidence.',
             ...(reveal
                 ? ['Search values were revealed only because the operator supplied --reveal; handle the output as sensitive evidence.']
@@ -234,7 +199,9 @@ export function formatArchiveInspection(report) {
         `Archive: ${report.archive.encrypted ? 'encrypted' : 'plain'} · v${report.archive.version}`,
         `Sections: ${report.summary.sectionCount}`,
         `Records: ${report.summary.recordCount}`,
-        `Content digest: ${report.summary.contentDigestSha256}`,
+        `Content identity: ${report.summary.contentDigest}`,
+        ...(report.summary.expectedContentDigestCanonicalization === 'sorted-json-v1'
+            ? ['Expected digest matched using the legacy locale-sensitive form.'] : []),
     ];
     for (const section of report.sections) {
         lines.push(`${safeTerminalValue(section.label)}: ${section.recordCount} records · ${safeTerminalValue(section.status)} · ${section.bytes} bytes`);

package/cli/arguments.mjs

@@ -1,9 +1,11 @@
 import { parseCommandArguments } from "./command-argument-grammar.mjs";
 import { CliUsageError, hasUnsafeCliText } from "./errors.mjs";
+import { parseArchiveContentDigest } from "./archive-content-digest.mjs";
 import { parseCliFailPolicies } from "./fail-policy.mjs";
 import { isDirectLookupTarget } from "../lib/classify.mjs";
-import { CLI_COMMANDS, cliMetaActionForInvocation, isCliCommand, } from "./command-reference.mjs";
-const MAX_CLI_ARGUMENTS = 32;
+import { MAX_INVESTIGATION_MANIFEST_ARTIFACTS } from "../packages/investigation/investigation-manifest.mjs";
+import { CLI_COMMANDS, CLI_CASE_OPERATIONS, cliMetaActionForInvocation, isCliCommand, } from "./command-reference.mjs";
+const MAX_CLI_ARGUMENTS = MAX_INVESTIGATION_MANIFEST_ARTIFACTS + 32;
 const MAX_CLI_ARGUMENT_LENGTH = 1024;
 function boundedArgument(value) {
     if (typeof value !== 'string' || value.length > MAX_CLI_ARGUMENT_LENGTH || hasUnsafeCliText(value)) {
@@ -16,8 +18,11 @@ function terminalOptions(parsed) {
 }
 function parseInspectArchiveArguments(parsed) {
     const expectedContentDigest = parsed.optionValue('--expect-content-digest');
-    if (expectedContentDigest !== null && !/^sha256:[a-f0-9]{64}$/u.test(expectedContentDigest)) {
-        throw new CliUsageError('--expect-content-digest requires sha256 followed by 64 lowercase hexadecimal characters.');
+    try {
+        parseArchiveContentDigest(expectedContentDigest);
+    }
+    catch {
+        throw new CliUsageError('--expect-content-digest requires sha256:<64 lowercase hex> or sorted-json-v2:sha256:<64 lowercase hex>.');
     }
     return {
         action: 'inspect-archive',
@@ -43,6 +48,7 @@ function parseVerifySignatureArguments(parsed) {
         action: 'verify-signature',
         source: parsed.positionalValue('source'),
         publicKeySource: parsed.optionValue('--public-key-file'),
+        trustStoreSource: parsed.optionValue('--trust-store-file'),
         output: parsed.hasOption('--json') ? 'json' : 'terminal',
         ...terminalOptions(parsed),
     };
@@ -94,6 +100,7 @@ function parseLookupArguments(parsed) {
         vantageLabel: normalizedLabel(parsed, '--vantage', 80),
         ...terminalOptions(parsed),
         ...(parsed.hasOption('--browse') ? { browse: true } : {}),
+        ...(parsed.hasOption('--exact-url') ? { exactUrl: true } : {}),
         ...(parsed.optionValue('--save-lookup') ? { saveLookup: parsed.optionValue('--save-lookup') } : {}),
         ...(selectedFailPolicies ? { failOn: selectedFailPolicies } : {}),
     };
@@ -101,7 +108,7 @@ function parseLookupArguments(parsed) {
 function parseManifestArguments(parsed) {
     const sources = parsed.positionalValues('artefacts');
     if (sources.some((source) => !source))
-        throw new CliUsageError('manifest requires from 1 to 16 JSON artefact files.');
+        throw new CliUsageError(`manifest requires from 1 to ${MAX_INVESTIGATION_MANIFEST_ARTIFACTS} artefact files.`);
     if (new Set(sources).size !== sources.length)
         throw new CliUsageError('manifest artefact files must be different.');
     const configurationDigestSha256 = parsed.optionValue('--configuration-digest');
@@ -113,6 +120,10 @@ function parseManifestArguments(parsed) {
         sources,
         workflow: parsed.optionValue('--workflow'),
         configurationDigestSha256,
+        ...(parsed.optionValue('--passphrase-file') ? { passphraseSource: parsed.optionValue('--passphrase-file') } : {}),
+        ...(parsed.hasOption('--package') ? { package: true } : {}),
+        ...(parsed.hasOption('--bagit') ? { bagit: true } : {}),
+        ...(parsed.optionValue('--folder') ? { folder: parsed.optionValue('--folder') } : {}),
         output: jsonOutput(parsed),
         ...terminalOptions(parsed),
     };
@@ -122,6 +133,7 @@ function parseBulkArguments(parsed) {
     const selectedFailPolicies = failPolicies(parsed, 'bulk');
     const output = parseOutput(parsed, [
         ['--json', 'json'], ['--jsonl', 'jsonl'], ['--csv', 'csv'], ['--domains', 'domains'],
+        ['--csv-with-metadata', 'csv_metadata'],
         ['--queries', 'queries'], ['--junit', 'junit'],
     ]);
     const filter = parsed.hasOption('--registered-only') ? 'registered'
@@ -172,7 +184,7 @@ function parseDiscoverScanArguments(parsed) {
     return {
         action: 'discover-scan',
         seed: parsed.positionalValue('subject'),
-        output: parseOutput(parsed, [['--json', 'json'], ['--jsonl', 'jsonl'], ['--csv', 'csv'], ['--domains', 'domains']]),
+        output: parseOutput(parsed, [['--json', 'json'], ['--jsonl', 'jsonl'], ['--csv', 'csv'], ['--csv-with-metadata', 'csv_metadata'], ['--domains', 'domains']]),
         ...discoveryValues(parsed),
         deep,
         scanLimit: parsed.integerOption('--scan-limit') ?? Math.min(100, deep ? 50 : 500),
@@ -200,6 +212,7 @@ function parsePostureArguments(parsed) {
         retiredSelectorText: parsed.optionValue('--retired-selectors'),
         mailProfile: mailProfile === 'defensive-no-mail' ? 'defensive_no_mail' : mailProfile,
         ownedDomain: parsed.hasOption('--owned-domain'),
+        ...(parsed.hasOption('--include-inherited-dns') ? { includeInheritedDns: true } : {}),
         ...terminalOptions(parsed),
     };
 }
@@ -233,12 +246,17 @@ function parseTwoFileComparisonArguments(parsed, command) {
     return { leftSource: sources[0], rightSource: sources[1], output: jsonOutput(parsed), ...terminalOptions(parsed) };
 }
 function parseVerifyArtifactArguments(parsed) {
+    if (parsed.hasOption('--folder') && parsed.positionalValue('source'))
+        throw new CliUsageError('--folder selects its own input; do not also supply a file or stdin marker.');
     return {
         action: 'verify-artifact',
         source: parsed.positionalValue('source'),
         passphraseSource: parsed.optionValue('--passphrase-file'),
         manifestSource: parsed.optionValue('--manifest'),
         manifestEntryId: parsed.optionValue('--manifest-entry'),
+        ...(parsed.hasOption('--package') ? { package: true } : {}),
+        ...(parsed.hasOption('--bagit') ? { bagit: true } : {}),
+        ...(parsed.optionValue('--folder') ? { folder: parsed.optionValue('--folder') } : {}),
         output: jsonOutput(parsed),
         strictExit: parsed.hasOption('--strict-exit'),
         ...terminalOptions(parsed),
@@ -297,6 +315,12 @@ function parseWorkflowPlanArguments(parsed) {
     };
 }
 function parseWorkflowRunArguments(parsed) {
+    const artifactBindings = parsed.optionValues('--use-artifact').map((value) => {
+        const match = /^([a-z0-9]+(?:-[a-z0-9]+)*):([1-9][0-9]?)=([a-z0-9]+(?:-[a-z0-9]+)*)$/u.exec(value);
+        if (!match)
+            throw new CliUsageError('--use-artifact requires <step-id>:<input-number>=<earlier-step-id>.');
+        return Object.freeze({ stepId: match[1], input: Number(match[2]), sourceStepId: match[3] });
+    });
     const selections = parsed.optionValues('--select').map((value) => {
         const separator = value.indexOf('=');
         const stepId = separator === -1 ? '' : value.slice(0, separator);
@@ -315,7 +339,10 @@ function parseWorkflowRunArguments(parsed) {
         subject: parsed.positionalValue('subject'),
         resumeSource: parsed.optionValue('--resume'),
         selections: Object.freeze(selections),
+        artifactBindings: Object.freeze(artifactBindings),
+        confirmedReviews: Object.freeze(parsed.optionValues('--confirm-review')),
         approveNetwork: parsed.hasOption('--approve-network'),
+        interactive: parsed.hasOption('--interactive'),
         output: jsonOutput(parsed),
         ...terminalOptions(parsed),
     };
@@ -337,6 +364,40 @@ function uniqueSources(parsed, command) {
         throw new CliUsageError(`${command} input files must be different.`);
     return sources;
 }
+function parseCaseArguments(parsed) {
+    const operation = parsed.positionalValue('operation');
+    const source = parsed.positionalValue('source');
+    const domain = parsed.optionValue('--domain');
+    const caseId = parsed.optionValue('--case-id');
+    const title = parsed.optionValue('--title');
+    const newIncident = parsed.hasOption('--new-incident');
+    const text = parsed.optionValue('--text');
+    const noteSource = parsed.optionValue('--note-file');
+    const inputSource = parsed.optionValue('--input');
+    const expectedFileDigest = parsed.optionValue('--expect-file-digest');
+    if (source === '-' || inputSource === '-' || noteSource === '-')
+        throw new CliUsageError('Case operations require selected files, not stdin.');
+    if (operation !== 'open' && !source)
+        throw new CliUsageError(`${operation} requires a Case file.`);
+    if (operation !== 'show' && !parsed.hasOption('--output'))
+        throw new CliUsageError('Case mutations require --output; nothing was changed.');
+    if (operation === 'open' && !domain)
+        throw new CliUsageError('case open requires --domain.');
+    if (operation !== 'open' && (title || newIncident))
+        throw new CliUsageError('--title and --new-incident belong to case open.');
+    if (newIncident && (!title || caseId))
+        throw new CliUsageError('--new-incident requires a distinguishing --title and cannot select an existing --case-id.');
+    if (operation === 'note' ? (text === null && !noteSource) : (text !== null || noteSource !== null)) {
+        throw new CliUsageError('Only case note accepts and requires --text or --note-file.');
+    }
+    if (['pin', 'assess', 'recheck'].includes(operation) ? !inputSource : inputSource !== null) {
+        throw new CliUsageError('Only case pin, assess and recheck accept and require --input.');
+    }
+    if (expectedFileDigest !== null && (!source || !/^sha256:[a-f0-9]{64}$/u.test(expectedFileDigest))) {
+        throw new CliUsageError('--expect-file-digest requires a source file and sha256:<64 lowercase hexadecimal characters>.');
+    }
+    return { action: 'case', operation, source, caseId, domain, title, newIncident, text, noteSource, inputSource, expectedFileDigest, output: jsonOutput(parsed), ...terminalOptions(parsed) };
+}
 const CLI_PARSERS = Object.freeze({
     completion: (parsed) => ({ action: 'completion', shell: parsed.positionalValue('shell') }),
     doctor: (parsed) => ({ action: 'doctor', network: parsed.hasOption('--network'), output: jsonOutput(parsed), ...terminalOptions(parsed) }),
@@ -395,6 +456,7 @@ const CLI_PARSERS = Object.freeze({
         output: jsonOutput(parsed), strictExit: parsed.hasOption('--strict-exit'), ...terminalOptions(parsed),
     }),
     brief: (parsed) => singleInputAction('brief', parsed),
+    case: parseCaseArguments,
     'case-pack': (parsed) => ({
         action: 'case-pack', source: parsed.positionalValue('source'), output: jsonOutput(parsed),
         audience: parsed.optionValue('--audience'), reviewed: true, ...terminalOptions(parsed),