@hwip/cli 0.0.1 → 0.1.0

package/dist/schedule.js

@@ -0,0 +1,428 @@
+"use strict";
+/**
+ * Scheduled sessions (F8): what a schedule is, when it comes due, and the files it lives in.
+ *
+ * A schedule is one file, `<stateDir>/schedules/<id>.json` (0600). `hwip schedule` writes and
+ * deletes them, the listener only reads them, and nothing reads-then-rewrites a file, so the two
+ * never lose each other's change. What the listener has done about each one lives in its own file
+ * (`schedule-state.json`, `schedule-runner.ts`).
+ *
+ * Everything here is pure or touches only that directory. The clock is a parameter.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeScheduleState = exports.readScheduleState = exports.scheduleStatePath = exports.removeSchedule = exports.addSchedule = exports.listSchedules = exports.schedulesDir = exports.validateSchedule = exports.nextOccurrence = exports.occurrencesBetween = exports.parseWhen = exports.parseDuration = exports.WEEKDAYS = exports.ALL_DAYS = exports.DAY_NAMES = exports.defaultMaxRuntimeMin = exports.MAX_SCHEDULES = void 0;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const gate_js_1 = require("./gate.js");
+const private_files_js_1 = require("./private-files.js");
+const replace_file_js_1 = require("./replace-file.js");
+const isErrno = (err, code) => err instanceof Error && 'code' in err && err.code === code;
+const fail = (error) => ({ ok: false, error });
+exports.MAX_SCHEDULES = 20;
+const MIN_EVERY_MIN = 15;
+const MAX_EVERY_MIN = 366 * 24 * 60;
+const MAX_PROMPT_CHARS = 4000;
+const DEFAULT_MAX_RUNTIME_MIN = 120;
+/** How long a session may run when nobody said: two hours, and never longer than the period of an `every` schedule. */
+const defaultMaxRuntimeMin = (when) => Math.min(DEFAULT_MAX_RUNTIME_MIN, when.kind === 'every' ? when.minutes : DEFAULT_MAX_RUNTIME_MIN);
+exports.defaultMaxRuntimeMin = defaultMaxRuntimeMin;
+const MIN_MAX_RUNTIME_MIN = 5;
+const MAX_MAX_RUNTIME_MIN = 1440;
+const MAX_AGENT_ARGS = 64;
+const MAX_ARG_CHARS = 4000;
+/** A schedule file is a few hundred bytes; one this big was not written by `addSchedule`. */
+const MAX_FILE_BYTES = 256 * 1024;
+// ── When ─────────────────────────────────────────────────────────────
+exports.DAY_NAMES = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'];
+const DAY_NUMBER = Object.fromEntries(exports.DAY_NAMES.map((name, day) => [name, day]));
+exports.ALL_DAYS = [0, 1, 2, 3, 4, 5, 6];
+exports.WEEKDAYS = [1, 2, 3, 4, 5];
+const AT_TIME = /^([01]\d|2[0-3]):([0-5]\d)$/;
+const parseDays = (raw) => {
+    const word = raw.trim().toLowerCase();
+    if (word === 'daily')
+        return { ok: true, value: [...exports.ALL_DAYS] };
+    if (word === 'weekdays')
+        return { ok: true, value: [...exports.WEEKDAYS] };
+    const picked = new Set();
+    for (const part of word.split(',')) {
+        const day = Object.hasOwn(DAY_NUMBER, part.trim()) ? DAY_NUMBER[part.trim()] : undefined;
+        if (day === undefined)
+            return fail(`--days takes daily, weekdays or day names like mon,wed,fri (got '${raw}')`);
+        picked.add(day);
+    }
+    return { ok: true, value: [...picked].sort((a, b) => a - b) };
+};
+/** `<N>m` or `<N>h` as minutes; `example` is what the error shows for a value that is neither. */
+const parseDuration = (raw, flag, example) => {
+    const match = /^(\d{1,7})([mh])$/.exec(raw.trim().toLowerCase());
+    if (!match)
+        return fail(`${flag} takes minutes or hours like ${example} (got '${raw}')`);
+    return { ok: true, value: Number(match[1]) * (match[2] === 'h' ? 60 : 1) };
+};
+exports.parseDuration = parseDuration;
+const parseEvery = (raw) => {
+    const duration = (0, exports.parseDuration)(raw, '--every', '30m or 2h');
+    if (!duration.ok)
+        return duration;
+    const minutes = duration.value;
+    if (minutes < MIN_EVERY_MIN)
+        return fail(`--every must be at least ${MIN_EVERY_MIN}m`);
+    if (minutes > MAX_EVERY_MIN)
+        return fail('--every must be at most 366 days');
+    return { ok: true, value: minutes };
+};
+/** `--at HH:MM [--days …]` or `--every <N>m|<N>h`, not both and not neither. */
+const parseWhen = (input) => {
+    const { at, days, every } = input;
+    if (every !== undefined) {
+        if (at !== undefined || days !== undefined)
+            return fail('--every cannot be combined with --at or --days');
+        const minutes = parseEvery(every);
+        return minutes.ok ? { ok: true, value: { kind: 'every', minutes: minutes.value } } : minutes;
+    }
+    if (at === undefined)
+        return fail(days === undefined ? 'give --at HH:MM (with --days) or --every <N>m' : '--days needs --at HH:MM');
+    if (!AT_TIME.test(at.trim()))
+        return fail(`--at takes a 24-hour local time like 09:00 (got '${at}')`);
+    const parsed = parseDays(days ?? 'daily');
+    return parsed.ok ? { ok: true, value: { kind: 'daily', at: at.trim(), days: parsed.value } } : parsed;
+};
+exports.parseWhen = parseWhen;
+/** The longest stretch `occurrencesBetween` walks day by day. */
+const MAX_WALK_MS = 400 * 24 * 60 * 60 * 1000;
+/** How many whole periods of an `every` schedule lie between its anchor and `t`. */
+const periodsSince = (anchor, period, t) => Math.max(0, Math.floor((t - anchor) / period));
+/** Local midnight of the day `step` days after the day `from` falls on. Built from the calendar date, so a day that is 23 or 25 hours long is still one step. */
+const dayAfter = (from, step) => {
+    const first = new Date(from);
+    return new Date(first.getFullYear(), first.getMonth(), first.getDate() + step);
+};
+/**
+ * The local time of day of a `daily` schedule on `day`, or null when it does not run on that weekday. Built from the
+ * calendar date and the clock time, so a time the clocks skip runs once at the moved time and a repeated one once.
+ */
+const timeOnDay = (when, day) => {
+    if (!when.days.includes(day.getDay()))
+        return null;
+    const [hour, minute] = when.at.split(':').map(Number);
+    return new Date(day.getFullYear(), day.getMonth(), day.getDate(), hour, minute).getTime();
+};
+/**
+ * The times a schedule comes due in `(after, until]`.
+ *
+ * `every` is arithmetic from `anchor` (when the schedule was made; the anchor itself is not a run),
+ * so a machine that slept for a day counts its misses without looping. `daily` walks local dates and
+ * builds each time with the local-time constructor, which settles the two DST cases the way the
+ * spec says: a time the clock skips (spring) happens once, at the instant JS moves it to, and a time
+ * the clock repeats (fall) happens once, the first time round.
+ */
+const occurrencesBetween = (when, after, until, anchor) => {
+    // A cursor read from a damaged state file may not be a number; the day walk below would never end on one.
+    if (!Number.isFinite(after) || !Number.isFinite(until) || until <= after)
+        return { count: 0, latest: null };
+    if (when.kind === 'every') {
+        const period = when.minutes * 60_000;
+        const upTo = periodsSince(anchor, period, until);
+        const count = upTo - periodsSince(anchor, period, after);
+        return { count, latest: count > 0 ? anchor + upTo * period : null };
+    }
+    let count = 0;
+    let latest = null;
+    // A cursor from a hand-edited file may lie millennia back; a year and more of days is all that is ever counted.
+    const from = Math.max(after, until - MAX_WALK_MS);
+    for (let step = 0;; step++) {
+        const day = dayAfter(from, step);
+        if (day.getTime() > until)
+            break;
+        const at = timeOnDay(when, day);
+        if (at === null || at <= from || at > until)
+            continue;
+        count += 1;
+        latest = at;
+    }
+    return { count, latest };
+};
+exports.occurrencesBetween = occurrencesBetween;
+/** The first time after `after` the schedule comes due; null for a `daily` with no days (a file `validateSchedule` would refuse). */
+const nextOccurrence = (when, after, anchor) => {
+    if (when.kind === 'every') {
+        const period = when.minutes * 60_000;
+        return anchor + (periodsSince(anchor, period, after) + 1) * period;
+    }
+    for (let step = 0; step <= 8; step++) {
+        const at = timeOnDay(when, dayAfter(after, step));
+        if (at !== null && at > after)
+            return at;
+    }
+    return null;
+};
+exports.nextOccurrence = nextOccurrence;
+// ── Validation ───────────────────────────────────────────────────────
+const SCHEDULE_ID = /^[a-z0-9]{6}$/;
+const LABEL = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/;
+const AGENT_KIND = /^[A-Za-z0-9_-]{1,32}$/;
+const KEYS = new Set(['v', 'id', 'createdAt', 'source', 'agentKind', 'cwd', 'label', 'session', 'wt', 'agentArgs', 'prompt', 'when', 'maxRuntimeMin']);
+const isScheduleId = (value) => typeof value === 'string' && SCHEDULE_ID.test(value);
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const noControl = (text) => !/[\u0000-\u001f\u007f]/.test(text);
+/**
+ * A session this feature may type into or end: a `hwip-` tmux session name. tmux reads `:` and `.` in a `-t` target
+ * as syntax (and `;` separates commands); `tmuxSessionName` never leaves one in a session name.
+ */
+const isSessionName = (value) => typeof value === 'string' && value.startsWith('hwip-') && value.length <= 256 && noControl(value) && !/[:.;]/.test(value);
+const isInt = (value, min, max) => typeof value === 'number' && Number.isInteger(value) && value >= min && value <= max;
+const checkWhen = (raw) => {
+    if (!isRecord(raw))
+        return 'when must be an object';
+    if (raw.kind === 'every') {
+        if (Object.keys(raw).some((k) => k !== 'kind' && k !== 'minutes'))
+            return 'when has a field it does not know';
+        return isInt(raw.minutes, MIN_EVERY_MIN, MAX_EVERY_MIN) ? null : `when.minutes must be a whole number of at least ${MIN_EVERY_MIN}`;
+    }
+    if (raw.kind !== 'daily')
+        return "when.kind must be 'daily' or 'every'";
+    if (Object.keys(raw).some((k) => k !== 'kind' && k !== 'at' && k !== 'days'))
+        return 'when has a field it does not know';
+    if (typeof raw.at !== 'string' || !AT_TIME.test(raw.at))
+        return 'when.at must be HH:MM';
+    const days = raw.days;
+    const wellFormed = Array.isArray(days) && days.length > 0 && days.every((d) => isInt(d, 0, 6)) && new Set(days).size === days.length;
+    return wellFormed ? null : 'when.days must be distinct day numbers 0 to 6';
+};
+/**
+ * Whether `input` is a schedule this machine will run. The file reader, `hwip schedule add` and (in
+ * the remote PR) the phone's request all pass through here, so a limit lives in one place. Unknown
+ * fields are an error: a field nobody checks is a field that gets read later.
+ */
+const validateSchedule = (input) => {
+    if (!isRecord(input))
+        return fail('a schedule must be an object');
+    const unknownKey = Object.keys(input).find((k) => !KEYS.has(k));
+    if (unknownKey !== undefined)
+        return fail(`schedule has a field it does not know: ${unknownKey}`);
+    const { v, id, createdAt, source, agentKind, cwd, label, session, wt, agentArgs, prompt, when, maxRuntimeMin } = input;
+    if (v !== 1)
+        return fail('schedule.v must be 1');
+    if (!isScheduleId(id))
+        return fail('schedule.id must be 6 lowercase letters or digits');
+    if (typeof createdAt !== 'string' || createdAt.length > 40 || !Number.isFinite(Date.parse(createdAt)))
+        return fail('schedule.createdAt must be a date');
+    if (source !== 'cli' && source !== 'phone')
+        return fail("schedule.source must be 'cli' or 'phone'");
+    if (typeof agentKind !== 'string' || !AGENT_KIND.test(agentKind))
+        return fail('schedule.agentKind is not an agent kind');
+    if (typeof cwd !== 'string' || !(0, node_path_1.isAbsolute)(cwd) || cwd.length > 4096 || !noControl(cwd))
+        return fail('schedule.cwd must be an absolute path');
+    if (typeof label !== 'string' || !LABEL.test(label))
+        return fail('schedule.label may hold letters, digits, - and _ (63 after the first character)');
+    if (!isSessionName(session))
+        return fail('schedule.session must be a hwip- tmux session name');
+    if (wt !== undefined && (typeof wt !== 'string' || wt === '' || wt.startsWith('-') || wt.length > 200 || !noControl(wt)))
+        return fail('schedule.wt must be a branch name');
+    if (agentArgs !== undefined) {
+        const wellFormed = Array.isArray(agentArgs) && agentArgs.length <= MAX_AGENT_ARGS
+            && agentArgs.every((a) => typeof a === 'string' && a.length <= MAX_ARG_CHARS && !a.includes('\0'));
+        if (!wellFormed)
+            return fail(`schedule.agentArgs must be at most ${MAX_AGENT_ARGS} strings of at most ${MAX_ARG_CHARS} characters`);
+    }
+    // `hwip <agent> --detach --label … --wt …` reads its own flags first and stops at the first word that is not one:
+    // an agent argument that opens like one would be taken for the wrapper's.
+    if (Array.isArray(agentArgs) && typeof agentArgs[0] === 'string' && /^--(detach|label|wt)(=|$)/.test(agentArgs[0])) {
+        return fail('schedule.agentArgs cannot start with --detach, --label or --wt');
+    }
+    if (source === 'phone' && (wt !== undefined || agentArgs !== undefined))
+        return fail('a schedule from the phone carries no wt or agentArgs');
+    if (prompt !== undefined && (typeof prompt !== 'string' || prompt === '' || prompt.length > MAX_PROMPT_CHARS || prompt.includes('\0'))) {
+        return fail(`schedule.prompt must be 1 to ${MAX_PROMPT_CHARS} characters`);
+    }
+    if (source === 'phone' && prompt === undefined)
+        return fail('a schedule from the phone needs a prompt');
+    const badWhen = checkWhen(when);
+    if (badWhen)
+        return fail(badWhen);
+    const checkedWhen = when; // checkWhen accepted its shape
+    if (!isInt(maxRuntimeMin, MIN_MAX_RUNTIME_MIN, MAX_MAX_RUNTIME_MIN))
+        return fail(`schedule.maxRuntimeMin must be ${MIN_MAX_RUNTIME_MIN} to ${MAX_MAX_RUNTIME_MIN}`);
+    if (checkedWhen.kind === 'every' && maxRuntimeMin > checkedWhen.minutes)
+        return fail('schedule.maxRuntimeMin cannot be longer than the --every period');
+    // Every field of `Schedule` was checked above; `input` is a record, which TypeScript cannot narrow field by field.
+    return { ok: true, value: input };
+};
+exports.validateSchedule = validateSchedule;
+// ── Files ────────────────────────────────────────────────────────────
+const schedulesDir = () => (0, node_path_1.join)((0, gate_js_1.stateDir)(), 'schedules');
+exports.schedulesDir = schedulesDir;
+const schedulePath = (id) => (0, node_path_1.join)((0, exports.schedulesDir)(), `${id}.json`);
+const newScheduleId = () => Array.from({ length: 6 }, () => (0, node_crypto_1.randomInt)(36).toString(36)).join('');
+const readOne = (id) => {
+    try {
+        const path = schedulePath(id);
+        // Only the user's own regular file: a link could point anywhere, and a file others can write is not the user's word.
+        const info = (0, node_fs_1.lstatSync)(path);
+        if (!info.isFile() || (info.mode & 0o022) !== 0)
+            return null;
+        if (info.size > MAX_FILE_BYTES)
+            return null;
+        const checked = (0, exports.validateSchedule)(JSON.parse((0, node_fs_1.readFileSync)(path, 'utf8')));
+        return checked.ok && checked.value.id === id ? checked.value : null;
+    }
+    catch {
+        return null;
+    }
+};
+const listSchedules = () => {
+    let names;
+    try {
+        names = (0, node_fs_1.readdirSync)((0, exports.schedulesDir)());
+    }
+    catch (e) {
+        // No directory yet is just no schedules; any other failure means the list is unknown.
+        return isErrno(e, 'ENOENT') ? { schedules: [], unreadable: 0 } : { schedules: [], unreadable: 0, incomplete: true };
+    }
+    const schedules = [];
+    let unreadable = 0;
+    for (const name of names) {
+        if (!name.endsWith('.json'))
+            continue;
+        const id = name.slice(0, -'.json'.length);
+        const schedule = isScheduleId(id) ? readOne(id) : null;
+        if (schedule)
+            schedules.push(schedule);
+        else
+            unreadable += 1;
+    }
+    schedules.sort((a, b) => a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id));
+    // `addSchedule` stops at the limit, but files can arrive by hand: the oldest are kept, the rest are not run.
+    if (schedules.length > exports.MAX_SCHEDULES) {
+        unreadable += schedules.length - exports.MAX_SCHEDULES;
+        schedules.length = exports.MAX_SCHEDULES;
+        return { schedules, unreadable, incomplete: true };
+    }
+    return { schedules, unreadable };
+};
+exports.listSchedules = listSchedules;
+const ID_ATTEMPTS = 8;
+/**
+ * Write a new schedule. `make` gets the id so the label and session name that contain it can be
+ * built first. The file is created exclusively: an id that is taken is never overwritten, a new one
+ * is drawn.
+ */
+const addSchedule = (make, newId = newScheduleId) => {
+    const { schedules, unreadable } = (0, exports.listSchedules)();
+    if (schedules.length + unreadable >= exports.MAX_SCHEDULES) {
+        return { ok: false, error: `there are already ${exports.MAX_SCHEDULES} schedules; remove one with 'hwip schedule rm <id>'`, failure: 'limit' };
+    }
+    for (let attempt = 0; attempt < ID_ATTEMPTS; attempt++) {
+        const id = newId();
+        const schedule = make(id);
+        const checked = (0, exports.validateSchedule)(schedule);
+        if (!checked.ok)
+            return { ok: false, error: checked.error };
+        if (schedule.id !== id)
+            return { ok: false, error: 'schedule.id is not the id it was made for' };
+        try {
+            (0, private_files_js_1.mkdirHandedBack)((0, exports.schedulesDir)(), 0o700);
+        }
+        catch (err) {
+            return { ok: false, error: `could not create ${(0, exports.schedulesDir)()}: ${err instanceof Error ? err.message : String(err)}`, failure: 'io' };
+        }
+        try {
+            const path = schedulePath(id);
+            (0, node_fs_1.writeFileSync)(path, `${JSON.stringify(schedule, null, 2)}\n`, { flag: 'wx', mode: 0o600 });
+            (0, private_files_js_1.handBackToSudoUser)(path);
+            return { ok: true, schedule };
+        }
+        catch (err) {
+            if (isErrno(err, 'EEXIST'))
+                continue;
+            return { ok: false, error: `could not write the schedule: ${err instanceof Error ? err.message : String(err)}`, failure: 'io' };
+        }
+    }
+    return { ok: false, error: 'could not find a free schedule id', failure: 'io' };
+};
+exports.addSchedule = addSchedule;
+const removeSchedule = (id) => {
+    if (!isScheduleId(id))
+        return 'invalid';
+    try {
+        (0, node_fs_1.unlinkSync)(schedulePath(id));
+        return 'removed';
+    }
+    catch (err) {
+        if (isErrno(err, 'ENOENT'))
+            return 'missing';
+        throw err;
+    }
+};
+exports.removeSchedule = removeSchedule;
+// ── What the listener has done ───────────────────────────────────────
+const SCHEDULE_OUTCOMES = [
+    'started', 'missed', 'overlap', 'busy', 'start_failed', 'missing_directory', 'unknown_agent', 'prompt_undelivered', 'prompt_unsupported', 'capped',
+];
+const scheduleStatePath = () => (0, node_path_1.join)((0, gate_js_1.stateDir)(), 'schedule-state.json');
+exports.scheduleStatePath = scheduleStatePath;
+const isOutcome = (value) => SCHEDULE_OUTCOMES.some((outcome) => outcome === value);
+/** A time as a Date holds it, so `new Date(value)` of anything read back cannot throw. */
+const isNumber = (value) => typeof value === 'number' && Math.abs(value) <= 8.64e15;
+const readRunState = (raw) => {
+    if (!isRecord(raw) || !isNumber(raw.cursor))
+        return null;
+    const state = { cursor: raw.cursor };
+    const { running, last, pending } = raw;
+    if (isRecord(running) && isSessionName(running.session) && isNumber(running.startedAt) && typeof running.promptPending === 'boolean') {
+        state.running = { session: running.session, startedAt: running.startedAt, promptPending: running.promptPending, ...(running.capped === true ? { capped: true } : {}) };
+    }
+    if (isRecord(last) && isOutcome(last.outcome) && isNumber(last.at))
+        state.last = { outcome: last.outcome, at: last.at };
+    if (isRecord(pending) && isNumber(pending.since) && isRecord(pending.counts)) {
+        const counts = {};
+        for (const [reason, count] of Object.entries(pending.counts)) {
+            if (isOutcome(reason) && isInt(count, 1, Number.MAX_SAFE_INTEGER))
+                counts[reason] = count;
+        }
+        if (Object.keys(counts).length > 0)
+            state.pending = { since: pending.since, counts };
+    }
+    return state;
+};
+/**
+ * The state file, tolerant of everything: a missing file reads as nothing done yet, an unreadable or damaged one
+ * as what could be read plus `damaged`, so the listener does not take "nothing recorded" for "nothing happened".
+ */
+const readScheduleState = () => {
+    const state = { v: 1, schedules: {} };
+    try {
+        const path = (0, exports.scheduleStatePath)();
+        if ((0, node_fs_1.statSync)(path).size > MAX_FILE_BYTES)
+            return { ...state, damaged: true };
+        const raw = JSON.parse((0, node_fs_1.readFileSync)(path, 'utf8'));
+        if (!isRecord(raw) || !isRecord(raw.schedules))
+            return { ...state, damaged: true };
+        for (const [id, entry] of Object.entries(raw.schedules)) {
+            const runState = isScheduleId(id) ? readRunState(entry) : null;
+            if (runState)
+                state.schedules[id] = runState;
+            else
+                state.damaged = true;
+        }
+    }
+    catch (e) {
+        if (!isErrno(e, 'ENOENT'))
+            state.damaged = true;
+    }
+    return state;
+};
+exports.readScheduleState = readScheduleState;
+/** Replaces the state file atomically (0600). False when it could not be written; nothing is half-written. */
+const writeScheduleState = (state) => {
+    try {
+        (0, replace_file_js_1.replaceFile)((0, exports.scheduleStatePath)(), `${JSON.stringify(state)}\n`, undefined, 0o600);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+exports.writeScheduleState = writeScheduleState;

package/dist/secret-mask.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Best-effort masking of secret-looking strings in a patch, before it is sealed
+ * for the phone. It keeps the patch's shape — the same lines, the same diff
+ * marker on each, the same headers — so line numbers and hunks still line up;
+ * only text after the marker changes.
+ *
+ * This is a list of well-known token formats and secret-named assignments, not
+ * a promise: a secret in a form no rule knows goes through, and so does key
+ * material whose BEGIN line is outside the patch (the rules see one line at a
+ * time, plus whether a key block opened above). The count of masked spots is
+ * part of the answer so the reader is told something was hidden, and is never
+ * told nothing was.
+ *
+ * Every pattern is bounded: the patch comes from a repository the agent may
+ * have cloned from anywhere, the masking runs on the listener's event loop, and
+ * an unbounded `x*` retried from every start of a 200 KB line is quadratic.
+ */
+export interface MaskedPatch {
+    text: string;
+    masked: number;
+}
+/**
+ * Mask secret-looking strings in prose or any other text that is not a patch: no marker is taken off a line, so
+ * a token at the head of a line is read like any other. For text that leaves the machine to a reader other than
+ * the user (what `hwip agent read` prints). Same rules, same limits as `maskSecrets`: best effort, not a promise.
+ */
+export declare const maskText: (text: string) => MaskedPatch;
+export declare const maskSecrets: (patch: string) => MaskedPatch;
+//# sourceMappingURL=secret-mask.d.ts.map