@wirecat/cli-core 0.437.0 → 0.439.0

package/CHANGELOG.md

@@ -5,6 +5,41 @@ Notable changes to `@wirecat/cli-core` (`@wirecat/cli-messaging` up to 0.261.0,
 minor version may break callers, and says how under "Changed — may break callers". `pnpm docs:check` checks the
 shape of this file.
 
+## Unreleased
+
+## 0.439.0 — 26.10.2026
+
+### Changed — may break callers
+
+- **A run record keeps the command line as typed.** `argv` in `run.json` and `runs show` now holds the words the person
+  typed — a chat's title, a search, message text — so the history of what was run can be read back. A secret is
+  still always `[redacted]`: the value of an option or argument a CLI marks with the new `secretInput(...)` (exported
+  from `@wirecat/cli-core/cli`), one whose name says token, password, secret, credential, cookie, authorization or
+  API key, a password inside a URL, and a long opaque string. `bot api … --body` is marked secret, since a field the
+  API marks secret can ride in it. The new per-profile setting `record_input: false` (`config set record_input false`)
+  brings back the previous masking exactly. A configuration that will not load also masks, since it may be the one
+  that turned recording off. A CLI with its own `resolveSettings` may return `recordInput`; when it does not, typed
+  words are kept. `doctor reports create` still masks the run's words as before, since the report is sent to other
+  people. `config set` and `config show` list `record_input`, so a CLI's help snapshot changes. A test or document
+  that says a run never holds what was typed needs updating.
+
+### Security
+
+- **An error that quotes `--token=…` or `password=…` no longer keeps the value.** A kept error masked such a value
+  only when a space followed the `=` or `:`; Commander's `unknown option '--token=…'` kept it whole.
+
+## 0.438.0 — 26.10.2026
+
+### Security
+
+- **A first word refused as a profile no longer reaches the run log.** When the first word could not be a profile
+  (`app "runs list"`, two words in one argument) or a profile lock refused it, the failed run's record kept it as
+  `profile` while its `argv` showed `[redacted]` — so whatever was typed first, possibly message text or a person's
+  name, was stored in the clear. Such a run now records no profile, as a run that names none does; a valid profile
+  the settings accepted is recorded as before. The lock's refusal quotes the refused word, so a kept error masks it,
+  and a bare first word with no command after it suggests `<tool> <word> account show` only when the word can be a
+  profile and the CLI has an `account show` command — that suggestion repeated the word unmasked in the kept error.
+
 ## 0.437.0 — 26.10.2026
 
 ### Added

package/dist/cli/bot/api.js

@@ -1,6 +1,7 @@
 import { CliError } from "@wirecat/cli-base";
 import { annotate } from "@wirecat/cli-base/commands";
 import { Command, Option } from "commander";
+import { secretInput } from "../../runs/run-context.js";
 import { REMOTE_READ, REMOTE_WRITE } from "../effects.js";
 import { apiFlagOf, apiOptionKey, readApiBody } from "./api-input.js";
 export const generatedApiCommand = (api) => {
@@ -20,7 +21,8 @@ export const generatedApiCommand = (api) => {
             command.addOption(parameter.required && parameter.in !== "body" ? option.makeOptionMandatory() : option);
         }
         if (operation.request) {
-            command.option("--body <json>", "the request body as JSON; - reads it from stdin");
+            // A field the schema marks secret may ride in an inline body, and the flags never see it.
+            command.addOption(secretInput(new Option("--body <json>", "the request body as JSON; - reads it from stdin")));
             command.option("--body-file <path>", "the request body from a JSON file; - is stdin");
         }
         annotate(command, {

package/dist/cli/context.d.ts

@@ -62,7 +62,7 @@ export interface BaseEnvironment {
     handled?: (event: MessageEvent) => void;
     /** Set by an MCP server on a command it runs for an agent (`runCommandForAgent`). */
     agent?: AgentRun;
-    /** Set by `run()`: the words it was given, which a run keeps masked (`maskArgv`). */
+    /** Set by `run()`: the words it was given, which a run keeps as `record_input` says (`maskArgv`). */
     argv?: readonly string[];
     /**
      * Set by `run()`: the rest of the command has no default deadline, and Ctrl-C, SIGTERM, a cancel or an explicit

package/dist/cli/context.js

@@ -86,6 +86,7 @@ export const baseContext = (command, resolveSettings) => {
                     program: rootOf(command),
                     ...(environment.argv ? { argv: environment.argv } : {}),
                     env,
+                    recordInput: settings.recordInput !== false,
                 }),
                 ...(ranFor === undefined ? {} : { profile: ranFor }),
                 record: settings.record,

package/dist/cli/index.d.ts

@@ -25,6 +25,7 @@ export { type CacheEvent, type DiagnosticEvent, type EventSink, providerErrorKey
 export { CORE_LOG_EVENTS } from "../runs/log-events.js";
 export { crashOf, type Recording, type RecordingOptions, recorded, startRecording, wasSettled, } from "../runs/recording.js";
 export { findRun, KEEP_RUNS_FOR_DAYS, listRuns, pruneRuns, type RunMetadata, readEvents, runsDirFor, runtime, startRun, } from "../runs/run.js";
+export { secretInput } from "../runs/run-context.js";
 export { currentRun, inRun, type RunScope, useAsProcessRun } from "../runs/scope.js";
 export { LANGUAGES } from "../search/languages.js";
 export { guardedApp, guardedPress, guardedStart, type Pressed } from "../sends/buttons.js";

package/dist/cli/index.js

@@ -21,6 +21,7 @@ export { providerErrorKey, renderEvent, } from "../runs/events.js";
 export { CORE_LOG_EVENTS } from "../runs/log-events.js";
 export { crashOf, recorded, startRecording, wasSettled, } from "../runs/recording.js";
 export { findRun, KEEP_RUNS_FOR_DAYS, listRuns, pruneRuns, readEvents, runsDirFor, runtime, startRun, } from "../runs/run.js";
+export { secretInput } from "../runs/run-context.js";
 export { currentRun, inRun, useAsProcessRun } from "../runs/scope.js";
 export { LANGUAGES } from "../search/languages.js";
 export { guardedApp, guardedPress, guardedStart } from "../sends/buttons.js";

package/dist/cli/messenger/doctor-command.js

@@ -14,7 +14,7 @@ import { destroysNothing, LOCAL_WRITE, NO_EFFECTS, REMOTE_READ } from "../effect
 import { itemOf, renderAnswer, snakeKeys } from "../envelope.js";
 import { unknownPermissionIssues } from "../permission-keys.js";
 import { NONE_NAMED } from "../settings.js";
-import { lineOf, nextStep } from "../steps.js";
+import { lineOf, nextStep, rootOf } from "../steps.js";
 import { recalledAccount } from "./accounts.js";
 import { messengerContext } from "./context.js";
 import { privateFiles, withSqliteSidecars } from "./private-files.js";
@@ -100,6 +100,7 @@ const reportCommand = (messenger) => {
             sends: profile ? new SendJournal(sendsPathFor(app, profile, env)).entries() : [],
             now,
             home: env.HOME ?? env.USERPROFILE,
+            program: rootOf(this),
             ...(options.run === undefined ? {} : { runId: options.run }),
         });
         const path = resolve(options.output ?? reportFileName(app.command, now));

package/dist/cli/messenger/report.d.ts

@@ -1,3 +1,4 @@
+import { Command } from "commander";
 import { type RunMetadata } from "../../runs/run.js";
 import type { SendEntry } from "../../sends/journal.js";
 export interface Report<Doctor extends object = Record<string, unknown>> {
@@ -29,7 +30,7 @@ export interface ReportContext {
  * journal are built that way. Two things are added: every id becomes a label, and the home
  * directory is hidden, since paths name the person's account on this machine.
  */
-export declare const buildReport: <Doctor extends object, Context extends ReportContext = Record<never, never>>({ doctor, runsDir, runId, command, sends, now, home, context, eventFields, }: {
+export declare const buildReport: <Doctor extends object, Context extends ReportContext = Record<never, never>>({ doctor, runsDir, runId, command, sends, now, home, context, eventFields, program, }: {
     doctor: Doctor;
     runsDir: string;
     runId?: string;
@@ -41,6 +42,8 @@ export declare const buildReport: <Doctor extends object, Context extends Report
     context?: Context;
     /** Retain allowlisted recorded fields, including time and severity, for an existing consumer contract. */
     eventFields?: "report" | "recorded";
+    /** The CLI's program, which tells a flag's value from a command word when the run's words are masked. */
+    program?: Command;
 }) => Report<Doctor> & Omit<Context, keyof Report>;
 /**
  * Every field of a journal line that names a chat, a message or a write. A send's `operationId` is

package/dist/cli/messenger/report.js

@@ -1,8 +1,10 @@
 import { createHash, randomBytes } from "node:crypto";
 import { join } from "node:path";
 import { CliError } from "@wirecat/cli-base";
+import { Command } from "commander";
 import { LOG_ATTRIBUTES } from "../../runs/log-attributes.js";
 import { findRun, listRuns, readEvents } from "../../runs/run.js";
+import { maskArgv } from "../../runs/run-context.js";
 const RECENT_SENDS = 20;
 /** Only these fields of a run event travel; a field added later is left out until it is named here. */
 const EVENT_FIELDS = [
@@ -21,7 +23,7 @@ const EVENT_FIELDS = [
  * journal are built that way. Two things are added: every id becomes a label, and the home
  * directory is hidden, since paths name the person's account on this machine.
  */
-export const buildReport = ({ doctor, runsDir, runId, command, sends, now = new Date(), home, context, eventFields = "report", }) => {
+export const buildReport = ({ doctor, runsDir, runId, command, sends, now = new Date(), home, context, eventFields = "report", program, }) => {
     const chosen = runId === undefined ? newestFailed(runsDir) : findRun(runsDir, runId);
     if (runId !== undefined && !chosen)
         throw new CliError("not_found", `no run ${runId} — \`${command} runs list\` names them`);
@@ -34,11 +36,18 @@ export const buildReport = ({ doctor, runsDir, runId, command, sends, now = new
             ...doctor,
             ...(account?.remembered ? { account: { ...account, remembered: label(account.remembered) } } : {}),
         },
-        run: chosen ? { metadata: chosen.metadata, events: readEvents(chosen.dir).map(eventOf(label, eventFields)) } : null,
+        run: chosen
+            ? {
+                metadata: maskedRun(chosen.metadata, program),
+                events: readEvents(chosen.dir).map(eventOf(label, eventFields)),
+            }
+            : null,
         sends: sends.slice(-RECENT_SENDS).map((entry) => labelled(entry, label)),
     };
     return JSON.parse(hideHome(JSON.stringify(report), home));
 };
+// A report leaves the machine, so it masks the typed words as `record_input: false` would.
+const maskedRun = (metadata, program = new Command()) => metadata.argv ? { ...metadata, argv: maskArgv(program, metadata.argv).argv } : metadata;
 /**
  * Every field of a journal line that names a chat, a message or a write. A send's `operationId` is
  * its `sendId`, so one left raw would undo the other's label.

package/dist/cli/profile.d.ts

@@ -1,6 +1,7 @@
 import type { Command } from "commander";
 /** How the command line names this profile: always the first word, since none is assumed. */
 export declare const asFirstWord: (profile: string) => string;
+export declare const isProfileName: (word: string) => boolean;
 export declare const usableProfileName: (profile: string) => string;
 /** The top-level commands that never read a profile; every other one is `<tool> <profile> …`. */
 export declare const PROFILE_FREE: ReadonlySet<string>;

package/dist/cli/profile.js

@@ -7,8 +7,9 @@ export const asFirstWord = (profile) => `${profile} `;
  * somewhere nobody would think to look.
  */
 const PLAIN_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+export const isProfileName = (word) => PLAIN_NAME.test(word);
 export const usableProfileName = (profile) => {
-    if (!PLAIN_NAME.test(profile)) {
+    if (!isProfileName(profile)) {
         throw new CliError("validation_error", `"${profile}" cannot be a profile name — letters, digits, dot, dash and underscore only, ` +
             "starting with a letter or a digit");
     }

package/dist/cli/program.d.ts

@@ -10,7 +10,7 @@ export interface ProgramDefinition {
     /** The CLI's own settings, for keeping a failure that happened before its command could; plain ones without. */
     configuration?: {
         permissionKey?: (path: readonly string[]) => string | null | undefined;
-        resolveSettings: (flags?: GlobalFlags, options?: ResolveOptions) => Pick<Settings, "profile" | "keepFailedRuns" | "keepRunsForDays" | "skillHint"> & Partial<Pick<Settings, "permissions" | "permissionSources" | "configPath" | "savedPermissions" | "sources">>;
+        resolveSettings: (flags?: GlobalFlags, options?: ResolveOptions) => Pick<Settings, "profile" | "keepFailedRuns" | "keepRunsForDays" | "skillHint"> & Partial<Pick<Settings, "recordInput" | "permissions" | "permissionSources" | "configPath" | "savedPermissions" | "sources">>;
     };
     configure?: (program: Command) => void;
     /** The tool's pitch and "what you can do" lines on `--help` and a bare run. */

package/dist/cli/program.js

@@ -27,7 +27,7 @@ import { showInputFields } from "./input-fields.js";
 import { MAX_BUFFERED_INPUT, provideInputPolicy } from "./input-policy.js";
 import { checkJson, liftJson } from "./json-fields.js";
 import { PreviewComplete, preview } from "./preview.js";
-import { commandWords, liftProfile, sampleCommand, takesProfile, valuedOptions } from "./profile.js";
+import { commandWords, isProfileName, liftProfile, sampleCommand, takesProfile, valuedOptions } from "./profile.js";
 import { absolutePaths, relayTarget } from "./relay-route.js";
 import { NoProfileHere, namedProfile, settingsFor, } from "./settings.js";
 import { assertSharedContracts } from "./shared-contracts.js";
@@ -433,8 +433,11 @@ const runOnce = async (argv, definition, options) => {
     // A bare word with nothing after it would make commander print help **on stdout**, which breaks
     // the one contract this program has and says nothing about why.
     if (profile !== undefined && rest.length === 0) {
+        const asProfile = commandAt(program, "account show") && isProfileName(profile)
+            ? `, or \`${command} ${profile} account show\` if "${profile}" is your profile`
+            : "";
         const message = `"${profile}" is not a command, so it was read as a profile name — and no command followed it. ` +
-            `Run \`${command} --help\` for the commands, or \`${command} ${profile} account show\` if "${profile}" is your profile.`;
+            `Run \`${command} --help\` for the commands${asProfile}.`;
         const failure = new CliError("validation_error", message, { param: "profile" });
         const settled = await settleFailure(failure, { definition, program, rest, argv, profile, options });
         return report(streams, reporting, failed(definition, program, rest, failure, settled, debug));
@@ -571,7 +574,8 @@ const settleFailure = async (failure, state) => {
 /**
  * **Every failure is kept as a run** — a usage error, a configuration that will not load, a command
  * that never opens a run — unless recording was turned off. One its own run already kept is skipped.
- * Its arguments are kept masked (`maskArgv`): a value that can be a message never is.
+ * Its words are kept as `record_input` says (`maskArgv`); a configuration that did not load masks them, since it may
+ * be the one that turned recording input off.
  */
 const keepFailure = async (failure, { definition, program, rest, argv, profile, options }) => {
     if (wasSettled(failure))
@@ -596,8 +600,10 @@ const keepFailure = async (failure, { definition, program, rest, argv, profile,
             program,
             argv,
             env,
+            recordInput: settings ? settings.recordInput !== false : false,
         }),
-        profile: settings ? namedProfile(settings) : profile,
+        // Settings that did not load never accepted the word, which may be a refused name or somebody's words.
+        profile: settings ? namedProfile(settings) : undefined,
         record: false,
         keepFailed: settings?.keepFailedRuns ?? !rest.includes("--no-record"),
         trace: false,

package/dist/cli/settings.d.ts

@@ -97,6 +97,11 @@ export interface Settings extends AISettings {
      */
     commandTimeoutMs: number | undefined;
     record: boolean;
+    /**
+     * A run record keeps the words typed, secrets hidden; off masks every value that may be content. Optional so a CLI
+     * with settings of its own need not return it: left out, the words are kept.
+     */
+    recordInput?: boolean;
     /** A failed run is kept even unrecorded, unless recording was turned off by name. */
     keepFailedRuns: boolean;
     keepRunsForDays: number;
@@ -265,6 +270,7 @@ export declare const settingsFor: <T extends object = Record<never, never>>(app:
             color: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
             sender_colors: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
             record: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
+            record_input: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
             keep_runs_for_days: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<(issue: v.BaseIssue<unknown>) => string>, v.IntegerAction<number, (issue: v.BaseIssue<unknown>) => string>, v.MinValueAction<number, 1, (issue: v.BaseIssue<unknown>) => string>]>, undefined>;
             permissions: v.OptionalSchema<v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, (issue: v.RegexIssue<string>) => string>]>, v.PicklistSchema<readonly ["deny", "readonly", "ask", "allow"], (issue: v.PicklistIssue) => string>, (issue: v.BaseIssue<unknown>) => string>, undefined>;
             sends_per_hour: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<(issue: v.BaseIssue<unknown>) => string>, v.IntegerAction<number, (issue: v.BaseIssue<unknown>) => string>, v.MinValueAction<number, 1, (issue: v.BaseIssue<unknown>) => string>]>, undefined>;
@@ -338,6 +344,7 @@ export declare const settingsFor: <T extends object = Record<never, never>>(app:
             color: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
             sender_colors: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
             record: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
+            record_input: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
             keep_runs_for_days: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<(issue: v.BaseIssue<unknown>) => string>, v.IntegerAction<number, (issue: v.BaseIssue<unknown>) => string>, v.MinValueAction<number, 1, (issue: v.BaseIssue<unknown>) => string>]>, undefined>;
             permissions: v.OptionalSchema<v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, (issue: v.RegexIssue<string>) => string>]>, v.PicklistSchema<readonly ["deny", "readonly", "ask", "allow"], (issue: v.PicklistIssue) => string>, (issue: v.BaseIssue<unknown>) => string>, undefined>;
             sends_per_hour: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<(issue: v.BaseIssue<unknown>) => string>, v.IntegerAction<number, (issue: v.BaseIssue<unknown>) => string>, v.MinValueAction<number, 1, (issue: v.BaseIssue<unknown>) => string>]>, undefined>;

package/dist/cli/settings.js

@@ -56,6 +56,7 @@ const SHARED_PROFILE_ENTRIES = {
     color: v.optional(flag),
     sender_colors: v.optional(flag),
     record: v.optional(flag),
+    record_input: v.optional(flag),
     keep_runs_for_days: v.optional(count),
     permissions: v.optional(permissionLevels),
     sends_per_hour: v.optional(count),
@@ -168,7 +169,7 @@ export const settingsFor = (app, extension = {}) => {
         if (profile.value === lock)
             return profile;
         if (profile.from === "first word" || profile.from === PROFILE) {
-            throw new CliError("permission_error", `this process is locked to profile ${lock} (${PROFILE_LOCK}) — profile ${profile.value} is refused`);
+            throw new CliError("permission_error", `this process is locked to profile ${lock} (${PROFILE_LOCK}) — profile "${profile.value}" is refused`);
         }
         return { value: lock, from: PROFILE_LOCK };
     };
@@ -231,6 +232,7 @@ export const settingsFor = (app, extension = {}) => {
         const searchCatchUp = fromLayers("search_catch_up", false);
         const pictureSearch = fromLayers("picture_search", false);
         const searchReranker = fromLayers("search_reranker", DEFAULT_RERANK_MODEL);
+        const recordInput = fromLayers("record_input", true);
         const keepRunsForDays = fromLayers("keep_runs_for_days", DEFAULT_KEEP_RUNS_FOR_DAYS);
         // Set where an agent runs unattended; the config file and `--permission` cannot undo it.
         const readOnlyLock = readOnlyLockOf(app, env);
@@ -287,6 +289,7 @@ export const settingsFor = (app, extension = {}) => {
                 ? undefined
                 : (extension.parseDuration ?? parseDuration)(timeout.value, timeout.from === TIMEOUT ? TIMEOUT : "--timeout"),
             record: record.value,
+            recordInput: recordInput.value,
             keepFailedRuns: record.value || record.from === "default",
             keepRunsForDays: keepRunsForDays.value,
             ...(readOnlyLock ? { readOnlyLock } : {}),
@@ -314,6 +317,7 @@ export const settingsFor = (app, extension = {}) => {
                 pictureSearch: pictureSearch.from,
                 searchReranker: searchReranker.from,
                 record: record.from,
+                recordInput: recordInput.from,
                 keepRunsForDays: keepRunsForDays.from,
                 sendsPerHour: sendsPerHour.from,
                 requestsPerMinute: requestsPerMinute.from,

package/dist/cli/shared-command-exports.d.ts

@@ -79,6 +79,7 @@ export declare const configCommand: (app: import("./entry.js").AppIdentity, conf
             color: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             sender_colors: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             record: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
+            record_input: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             keep_runs_for_days: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
             permissions: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RegexAction<string, (issue: import("valibot").RegexIssue<string>) => string>]>, import("valibot").PicklistSchema<readonly ["deny", "readonly", "ask", "allow"], (issue: import("valibot").PicklistIssue) => string>, (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             sends_per_hour: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
@@ -152,6 +153,7 @@ export declare const configCommand: (app: import("./entry.js").AppIdentity, conf
             color: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             sender_colors: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             record: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
+            record_input: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             keep_runs_for_days: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
             permissions: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RegexAction<string, (issue: import("valibot").RegexIssue<string>) => string>]>, import("valibot").PicklistSchema<readonly ["deny", "readonly", "ask", "allow"], (issue: import("valibot").PicklistIssue) => string>, (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             sends_per_hour: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
@@ -280,6 +282,7 @@ export declare const completeCommand: (messenger: import("./index.js").Messenger
             color: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             sender_colors: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             record: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
+            record_input: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             keep_runs_for_days: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
             permissions: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RegexAction<string, (issue: import("valibot").RegexIssue<string>) => string>]>, import("valibot").PicklistSchema<readonly ["deny", "readonly", "ask", "allow"], (issue: import("valibot").PicklistIssue) => string>, (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             sends_per_hour: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
@@ -353,6 +356,7 @@ export declare const completeCommand: (messenger: import("./index.js").Messenger
             color: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             sender_colors: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             record: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
+            record_input: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             keep_runs_for_days: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
             permissions: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RegexAction<string, (issue: import("valibot").RegexIssue<string>) => string>]>, import("valibot").PicklistSchema<readonly ["deny", "readonly", "ask", "allow"], (issue: import("valibot").PicklistIssue) => string>, (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             sends_per_hour: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;

package/dist/runs/error-detail.js

@@ -119,7 +119,7 @@ export const redactText = (text) => {
     let out = home && home !== "/" ? text.split(home).join("~") : text;
     out = out
         .replace(/"[^"\n]*"|“[^”\n]*”|«[^»\n]*»/g, '"[redacted]"')
-        .replace(/\b(bearer|basic|token|key|password|secret)(\s*[:=]?\s+)\S+/gi, "$1$2[redacted]")
+        .replace(/\b(bearer|basic|token|key|password|secret)(\s*[:=]\s*|\s+)[^\s'"]+/gi, "$1$2[redacted]")
         .replace(/[\w.+-]+@[\w-]+\.[\w.-]+/g, "[email]")
         .replace(/\+\d[\d\s()-]{6,}\d/g, "[number]")
         .replace(/(^|[^\w-])\d{11,15}\b/g, "$1[number]")

package/dist/runs/run-context.d.ts

@@ -1,4 +1,4 @@
-import type { Command } from "commander";
+import type { Argument, Command, Option } from "commander";
 import type { RunContext } from "./run.js";
 export declare const REDACTED = "[redacted]";
 /** Which coding agent started the process, and its session when the agent names one. Keys as written in run.json. */
@@ -17,24 +17,32 @@ export interface RunAgent {
  */
 export declare const agentOf: (env: NodeJS.ProcessEnv) => RunAgent | undefined;
 export interface MaskedArgv {
-    /** The words after the binary, every value that may be content or a secret replaced by `[redacted]`. */
+    /** The words after the binary; a secret is `[redacted]`, and with `keep` off so is every value that may be content. */
     argv: string[];
     /** The first word that names no command where one was expected. */
     unknownCommand?: string;
 }
+/** Marks an option or argument whose value a run record never keeps, whatever the owner's `record_input`. */
+export declare const secretInput: <T extends Option | Argument>(input: T) => T;
 /**
- * The command line as typed, safe to keep. Command words, flag names and the profile stay; a value stays only when
- * its shape cannot be somebody's words — a number short of a phone's length, a duration, a date, `true`, one of the
+ * The command line for a run record. With `keep` (the owner's `record_input`, on unless turned off) every word stays
+ * as typed except a secret: a value of an input marked `secretInput` or named for one (`--token`), and a word shaped
+ * like a credential. With `keep` off, command words, flag names and the profile stay; a value stays only when its
+ * shape cannot be somebody's words — a number short of a phone's length, a duration, a date, `true`, one of the
  * option's declared choices — and its option or argument is not named for content (`--text`, `<phone>`). Anything
  * else, a positional after `--` or an argument no command declares, is `[redacted]`: a chat is often typed by title.
  */
-export declare const maskArgv: (program: Command, words: readonly string[]) => MaskedArgv;
-/** A run's context from the parsed program: `max messages list` and its masked words, or the word that named nothing. */
-export declare const runContextOf: ({ bin, command, program, argv, env, }: {
+export declare const maskArgv: (program: Command, words: readonly string[], { keep }?: {
+    keep?: boolean | undefined;
+}) => MaskedArgv;
+/** A run's context from the parsed program: `max messages list` and its words, or the word that named nothing. */
+export declare const runContextOf: ({ bin, command, program, argv, env, recordInput, }: {
     bin: string;
     /** The run's own name, `messages list` or `mcp messages list`; empty when no command was recognised. */
     command: string;
     program?: Command;
     argv?: readonly string[];
     env: NodeJS.ProcessEnv;
+    /** The owner's `record_input`; left out, every value that may be content is masked. */
+    recordInput?: boolean;
 }) => RunContext;

package/dist/runs/run-context.js

@@ -39,19 +39,55 @@ const sessionOf = (kind, env) => {
     return (variable === undefined ? undefined : env[variable]?.trim()) || undefined;
 };
 const plainWord = (word) => /^[A-Za-z][A-Za-z0-9.-]{0,39}$/.test(word);
+const secretInputs = new WeakSet();
+/** Marks an option or argument whose value a run record never keeps, whatever the owner's `record_input`. */
+export const secretInput = (input) => {
+    secretInputs.add(input);
+    return input;
+};
+const SECRET_WORDS = new Set([
+    "authorization",
+    "cookie",
+    "credential",
+    "credentials",
+    "passphrase",
+    "password",
+    "secret",
+    "token",
+    "apikey",
+]);
+// Undeclared flags carry no mark, so the name is the only signal; CLIs take secrets at a prompt (WC-SECR-5) and this
+// catches the one typed anyway.
+const secretNamed = (name) => {
+    const words = name
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .split(/[\s_.-]+/)
+        .map((word) => word.toLowerCase());
+    return words.some((word, at) => SECRET_WORDS.has(word) || (word === "api" && words[at + 1] === "key"));
+};
+// A password inside a URL, or one unbroken run of 40 token characters, is a credential wherever it was typed.
+const secretShaped = (word) => /:\/\/[^/@\s:]+:[^/@\s]+@/.test(word) || /(^|[^A-Za-z0-9_-])[A-Za-z0-9_-]{40,}($|[^A-Za-z0-9_-])/.test(word);
 /**
- * The command line as typed, safe to keep. Command words, flag names and the profile stay; a value stays only when
- * its shape cannot be somebody's words — a number short of a phone's length, a duration, a date, `true`, one of the
+ * The command line for a run record. With `keep` (the owner's `record_input`, on unless turned off) every word stays
+ * as typed except a secret: a value of an input marked `secretInput` or named for one (`--token`), and a word shaped
+ * like a credential. With `keep` off, command words, flag names and the profile stay; a value stays only when its
+ * shape cannot be somebody's words — a number short of a phone's length, a duration, a date, `true`, one of the
  * option's declared choices — and its option or argument is not named for content (`--text`, `<phone>`). Anything
  * else, a positional after `--` or an argument no command declares, is `[redacted]`: a chat is often typed by title.
  */
-export const maskArgv = (program, words) => {
+export const maskArgv = (program, words, { keep = false } = {}) => {
     const argv = [];
     let unknownCommand;
     let current = program;
     let positional = 0;
     let profileSeen = false;
     let lost = false;
+    const raw = (word) => (keep && !secretShaped(word) ? word : REDACTED);
+    const keptValue = (name, value, input) => keep
+        ? (input && secretInputs.has(input)) || secretNamed(name)
+            ? REDACTED
+            : raw(value)
+        : maskedValue(name, value, input?.argChoices);
     const optionFor = (flag) => {
         for (let at = current; at; at = at.parent) {
             const found = at.options.find((option) => option.long === flag || option.short === flag);
@@ -65,32 +101,37 @@ export const maskArgv = (program, words) => {
         if (word === "--") {
             argv.push("--");
             for (let after = at + 1; after < words.length; after++)
-                argv.push(REDACTED);
+                argv.push(raw(words[after]));
             break;
         }
         if (word.startsWith("-") && word.length > 1 && !NUMBER.test(word)) {
             const equals = word.indexOf("=");
             const flag = equals > 0 ? word.slice(0, equals) : word;
             if (!/^--?[A-Za-z0-9][A-Za-z0-9-]*$/.test(flag)) {
-                argv.push(REDACTED);
+                argv.push(raw(word));
                 continue;
             }
             const option = optionFor(flag);
             const name = option?.attributeName() ?? flag.replace(/^-+/, "");
             if (equals > 0) {
-                argv.push(`${flag}=${maskedValue(name, word.slice(equals + 1), option?.argChoices)}`);
+                argv.push(`${flag}=${keptValue(name, word.slice(equals + 1), option)}`);
                 continue;
             }
             argv.push(flag);
+            if (!option && keep && secretNamed(name) && words[at + 1] !== undefined && !words[at + 1]?.startsWith("-")) {
+                at += 1;
+                argv.push(REDACTED);
+                continue;
+            }
             if (!option || !(option.required || option.optional))
                 continue;
             const takes = (next) => next !== undefined && (option.required || !next.startsWith("-") || NUMBER.test(next));
             if (takes(words[at + 1])) {
                 at += 1;
-                argv.push(maskedValue(name, words[at], option.argChoices));
+                argv.push(keptValue(name, words[at], option));
                 while (option.variadic && words[at + 1] !== undefined && !words[at + 1].startsWith("-")) {
                     at += 1;
-                    argv.push(maskedValue(name, words[at], option.argChoices));
+                    argv.push(keptValue(name, words[at], option));
                 }
             }
             continue;
@@ -104,20 +145,20 @@ export const maskArgv = (program, words) => {
             }
             if (current === program && !profileSeen) {
                 profileSeen = true;
-                argv.push(PROFILE.test(word) ? word : REDACTED);
+                argv.push(keep ? raw(word) : PROFILE.test(word) ? word : REDACTED);
                 continue;
             }
             if (current.commands.length > 0 && current.registeredArguments.length === 0) {
                 lost = true;
                 unknownCommand = commandLike(word);
-                argv.push(unknownCommand);
+                argv.push(keep ? raw(word) : unknownCommand);
                 continue;
             }
         }
         const declared = lost ? undefined : current.registeredArguments;
         const argument = declared?.[Math.min(positional, declared.length - 1)];
         positional += 1;
-        argv.push(argument ? maskedValue(argument.name(), word, argument.argChoices) : REDACTED);
+        argv.push(argument ? keptValue(argument.name(), word, argument) : raw(word));
     }
     return { argv, ...(unknownCommand === undefined ? {} : { unknownCommand }) };
 };
@@ -143,9 +184,9 @@ const safeShape = (value) => (NUMBER.test(value) && !/^\d{11,}$/.test(value)) ||
     /^\d{4}-\d{2}-\d{2}([T ]\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:?\d{2})?)?$/.test(value) ||
     value === "true" ||
     value === "false";
-/** A run's context from the parsed program: `max messages list` and its masked words, or the word that named nothing. */
-export const runContextOf = ({ bin, command, program, argv, env, }) => {
-    const masked = program && argv ? maskArgv(program, argv) : undefined;
+/** A run's context from the parsed program: `max messages list` and its words, or the word that named nothing. */
+export const runContextOf = ({ bin, command, program, argv, env, recordInput = false, }) => {
+    const masked = program && argv ? maskArgv(program, argv, { keep: recordInput }) : undefined;
     const agent = agentOf(env);
     return {
         cliCommand: command ? `${bin} ${command}` : bin,

package/dist/runs/run.d.ts

@@ -49,7 +49,7 @@ export interface RunMetadata {
     traceId?: string;
     /** The whole command with the program's name, `max messages list`; `command` stays the run's short name. */
     cliCommand?: string;
-    /** The words after the program's name, every value that may be content or a secret `[redacted]` (`maskArgv`). */
+    /** The words after the program's name, a secret `[redacted]`; with `record_input` off, any value that may be content too (`maskArgv`). */
     argv?: string[];
     /** The word that named no command, when that is why the run failed. */
     unknownCommand?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.437.0",
+  "version": "0.439.0",
   "description": "The messenger-neutral half of a messaging CLI: domain model, message locators, rendering, name resolution, the SQLite seam, the command skeleton and shared read commands, the send guard, run records and the message store",
   "license": "Apache-2.0",
   "author": "Viacheslav Ptsarev",