codex-plugin-doctor 1.26.0 → 1.28.0

package/dist/core/suppression-management.js

@@ -0,0 +1,170 @@
+import { classifySuppressionRecord, isValidSuppressionFingerprint, validateSuppressionRecord } from "./suppression-record.js";
+export class SuppressionManagementError extends Error {
+    code;
+    field;
+    index;
+    indexes;
+    constructor(message, details) {
+        super(message);
+        this.name = "SuppressionManagementError";
+        this.code = details.code;
+        this.field = details.field;
+        this.index = details.index;
+        this.indexes = details.indexes;
+    }
+}
+function createSuppressionManagementError(message, details) {
+    return new SuppressionManagementError(message, details);
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readSuppressions(config) {
+    if (!("suppressions" in config)) {
+        return {
+            suppressions: [],
+            hasSuppressions: false
+        };
+    }
+    const { suppressions } = config;
+    if (!Array.isArray(suppressions)) {
+        throw createSuppressionManagementError("Doctor config suppressions must be an array when present.", {
+            code: "suppression_non_array"
+        });
+    }
+    return {
+        suppressions,
+        hasSuppressions: true
+    };
+}
+function copyConfigWithSuppressions(config, suppressions) {
+    return {
+        ...config,
+        suppressions
+    };
+}
+function buildManagedInvalidSuppression(index, invalidField) {
+    return {
+        index,
+        status: "invalid",
+        invalidField
+    };
+}
+function buildRemovedSuppressionSummary(suppression) {
+    const classified = classifySuppressionRecord(suppression, new Date(0));
+    if (classified.status === "invalid") {
+        return {
+            invalidField: classified.field
+        };
+    }
+    return {
+        fingerprint: classified.fingerprint,
+        reason: classified.reason,
+        expiresAt: classified.expiresAt
+    };
+}
+function findDuplicateFingerprintIndex(suppressions, fingerprint) {
+    return suppressions.findIndex((suppression) => isPlainObject(suppression) &&
+        typeof suppression.fingerprint === "string" &&
+        suppression.fingerprint === fingerprint);
+}
+function validateManagedFingerprint(fingerprint) {
+    if (!isValidSuppressionFingerprint(fingerprint)) {
+        throw createSuppressionManagementError("Suppression fingerprint is invalid.", {
+            code: "suppression_invalid_fingerprint"
+        });
+    }
+    return fingerprint;
+}
+function findFingerprintMatches(suppressions, fingerprint) {
+    return suppressions.flatMap((suppression, index) => isPlainObject(suppression) &&
+        typeof suppression.fingerprint === "string" &&
+        suppression.fingerprint === fingerprint
+        ? [index]
+        : []);
+}
+export function listSuppressions(config, now = new Date()) {
+    const { suppressions, hasSuppressions } = readSuppressions(config);
+    if (!hasSuppressions) {
+        return [];
+    }
+    return suppressions.map((suppression, index) => {
+        const classified = classifySuppressionRecord(suppression, now);
+        if (classified.status === "invalid") {
+            return buildManagedInvalidSuppression(index, classified.field);
+        }
+        return {
+            index,
+            status: classified.status,
+            fingerprint: classified.fingerprint,
+            reason: classified.reason,
+            expiresAt: classified.expiresAt
+        };
+    });
+}
+export function addSuppression(config, record) {
+    const { suppressions } = readSuppressions(config);
+    const validation = validateSuppressionRecord(record);
+    if (!validation.valid) {
+        throw createSuppressionManagementError(`Suppression record is invalid: ${validation.field}.`, {
+            code: "suppression_invalid_record",
+            field: validation.field
+        });
+    }
+    const duplicateIndex = findDuplicateFingerprintIndex(suppressions, validation.fingerprint);
+    if (duplicateIndex >= 0) {
+        throw createSuppressionManagementError(`Suppression fingerprint already exists at index ${duplicateIndex}.`, {
+            code: "suppression_duplicate_fingerprint",
+            index: duplicateIndex
+        });
+    }
+    const suppression = {
+        fingerprint: validation.fingerprint,
+        reason: validation.reason,
+        expiresAt: validation.expiresAt
+    };
+    const nextSuppressions = [...suppressions, suppression];
+    return {
+        config: copyConfigWithSuppressions(config, nextSuppressions),
+        index: suppressions.length,
+        suppression
+    };
+}
+export function removeSuppressionByIndex(config, index) {
+    const { suppressions } = readSuppressions(config);
+    if (!Number.isInteger(index) ||
+        index < 0 ||
+        index >= suppressions.length) {
+        throw createSuppressionManagementError("Suppression index must be an integer within range.", {
+            code: "suppression_invalid_index",
+            index
+        });
+    }
+    const suppression = suppressions[index];
+    const nextSuppressions = [
+        ...suppressions.slice(0, index),
+        ...suppressions.slice(index + 1)
+    ];
+    return {
+        config: copyConfigWithSuppressions(config, nextSuppressions),
+        index,
+        suppression: buildRemovedSuppressionSummary(suppression)
+    };
+}
+export function removeSuppressionByFingerprint(config, fingerprint) {
+    const { suppressions } = readSuppressions(config);
+    const validFingerprint = validateManagedFingerprint(fingerprint);
+    const matches = findFingerprintMatches(suppressions, validFingerprint);
+    if (matches.length === 0) {
+        throw createSuppressionManagementError("Suppression fingerprint not found.", {
+            code: "suppression_fingerprint_not_found"
+        });
+    }
+    if (matches.length > 1) {
+        throw createSuppressionManagementError(`Suppression fingerprint matches multiple suppressions at indexes: ${matches.join(", ")}.`, {
+            code: "suppression_fingerprint_ambiguous",
+            indexes: matches
+        });
+    }
+    return removeSuppressionByIndex(config, matches[0]);
+}

package/dist/core/suppression-record.d.ts

@@ -0,0 +1,26 @@
+export type SuppressionRecordField = "record" | "fingerprint" | "reason" | "expiresAt";
+export interface ValidSuppressionRecord {
+    valid: true;
+    fingerprint: string;
+    reason: string;
+    expiresAt: string;
+}
+export interface InvalidSuppressionRecord {
+    valid: false;
+    field: SuppressionRecordField;
+}
+type ActiveSuppressionRecord = ValidSuppressionRecord & {
+    status: "active";
+};
+type ExpiredSuppressionRecord = ValidSuppressionRecord & {
+    status: "expired";
+};
+type InvalidClassifiedSuppressionRecord = InvalidSuppressionRecord & {
+    status: "invalid";
+};
+export type ClassifiedSuppressionRecord = ActiveSuppressionRecord | ExpiredSuppressionRecord | InvalidClassifiedSuppressionRecord;
+export declare function isValidSuppressionFingerprint(value: unknown): value is string;
+export declare function validateSuppressionRecord(value: unknown): ValidSuppressionRecord | InvalidSuppressionRecord;
+export declare function isSuppressionExpired(expiresAt: string, now: Date): boolean;
+export declare function classifySuppressionRecord(value: unknown, now: Date): ClassifiedSuppressionRecord;
+export {};

package/dist/core/suppression-record.js

@@ -0,0 +1,62 @@
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isRealDate(value) {
+    const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+    if (!match) {
+        return false;
+    }
+    const year = Number(match[1]);
+    const month = Number(match[2]);
+    const day = Number(match[3]);
+    const date = new Date(Date.UTC(year, month - 1, day));
+    return (date.getUTCFullYear() === year &&
+        date.getUTCMonth() === month - 1 &&
+        date.getUTCDate() === day);
+}
+export function isValidSuppressionFingerprint(value) {
+    return typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
+}
+export function validateSuppressionRecord(value) {
+    if (!isPlainObject(value)) {
+        return { valid: false, field: "record" };
+    }
+    if (!isValidSuppressionFingerprint(value.fingerprint)) {
+        return { valid: false, field: "fingerprint" };
+    }
+    if (typeof value.reason !== "string" || value.reason.trim().length === 0) {
+        return { valid: false, field: "reason" };
+    }
+    if (typeof value.expiresAt !== "string" || !isRealDate(value.expiresAt)) {
+        return { valid: false, field: "expiresAt" };
+    }
+    return {
+        valid: true,
+        fingerprint: value.fingerprint,
+        reason: value.reason.trim(),
+        expiresAt: value.expiresAt
+    };
+}
+export function isSuppressionExpired(expiresAt, now) {
+    const expirationBoundary = Date.parse(`${expiresAt}T00:00:00.000Z`) + 86_400_000;
+    return now.getTime() >= expirationBoundary;
+}
+export function classifySuppressionRecord(value, now) {
+    const validation = validateSuppressionRecord(value);
+    if (!validation.valid) {
+        return {
+            status: "invalid",
+            ...validation
+        };
+    }
+    if (isSuppressionExpired(validation.expiresAt, now)) {
+        return {
+            status: "expired",
+            ...validation
+        };
+    }
+    return {
+        status: "active",
+        ...validation
+    };
+}

package/dist/domain/types.d.ts

@@ -10,11 +10,25 @@ export interface Finding {
     evidence?: FindingEvidence;
     fingerprint?: string;
 }
+export interface FindingSuppression {
+    reason: string;
+    expiresAt: string;
+}
+export interface SuppressedFinding extends Finding {
+    suppression: FindingSuppression;
+}
+export interface SuppressionSummary {
+    applied: number;
+    expired: number;
+    invalid: number;
+}
 export interface CheckResult {
     targetPath: string;
     status: "pass" | "warn" | "fail";
     exitCode: 0 | 1;
     findings: Finding[];
+    suppressedFindings?: SuppressedFinding[];
+    suppressionSummary?: SuppressionSummary;
     runtimeScorecard?: RuntimeScorecard;
 }
 export interface CheckOptions {
@@ -50,6 +64,8 @@ export interface JsonReport {
     generatedAt: string;
     summary: JsonReportSummary;
     findings: Finding[];
+    suppressedFindings?: SuppressedFinding[];
+    suppressionSummary?: SuppressionSummary;
 }
 export type RuntimeCapabilityStatus = "pass" | "fail" | "warn" | "skipped" | "unsupported";
 export interface RuntimeScorecard {

package/dist/index.d.ts

@@ -1,4 +1,8 @@
 import type { CheckOptions, CheckResult } from "./domain/types.js";
+export { applyDoctorConfig, loadDoctorConfig, type DoctorConfig } from "./core/doctor-config.js";
+export { readRawDoctorConfig, resolveDoctorConfigPath, writeRawDoctorConfig, type LoadedDoctorConfig, type RawDoctorConfig } from "./core/doctor-config-store.js";
+export { classifySuppressionRecord, isValidSuppressionFingerprint, isSuppressionExpired, validateSuppressionRecord, type ClassifiedSuppressionRecord, type InvalidSuppressionRecord, type SuppressionRecordField, type ValidSuppressionRecord } from "./core/suppression-record.js";
+export { addSuppression, listSuppressions, removeSuppressionByFingerprint, removeSuppressionByIndex, SuppressionManagementError, type ManagedSuppressionRecord, type SuppressionManagementErrorCode, type SuppressionMutationResult } from "./core/suppression-management.js";
 export { buildFindingFingerprint, formatFindingFingerprintLine, withFindingFingerprint, withFindingFingerprints } from "./reporting/finding-fingerprint.js";
 export { buildSecurityAudit, renderSecurityAuditJson, renderSecurityScorecard, type SecurityAudit } from "./security/security-audit.js";
 export { buildTrustScore, renderTrustScore, renderTrustScoreJson, type BuildTrustScoreOptions, type TrustScoreReport } from "./security/trust-score.js";

package/dist/index.js

@@ -1,4 +1,8 @@
 import { validatePlugin } from "./core/validate-plugin.js";
+export { applyDoctorConfig, loadDoctorConfig } from "./core/doctor-config.js";
+export { readRawDoctorConfig, resolveDoctorConfigPath, writeRawDoctorConfig } from "./core/doctor-config-store.js";
+export { classifySuppressionRecord, isValidSuppressionFingerprint, isSuppressionExpired, validateSuppressionRecord } from "./core/suppression-record.js";
+export { addSuppression, listSuppressions, removeSuppressionByFingerprint, removeSuppressionByIndex, SuppressionManagementError } from "./core/suppression-management.js";
 export { buildFindingFingerprint, formatFindingFingerprintLine, withFindingFingerprint, withFindingFingerprints } from "./reporting/finding-fingerprint.js";
 export { buildSecurityAudit, renderSecurityAuditJson, renderSecurityScorecard } from "./security/security-audit.js";
 export { buildTrustScore, renderTrustScore, renderTrustScoreJson } from "./security/trust-score.js";

package/dist/reporting/render-json-report.js

@@ -18,7 +18,13 @@ export function buildJsonReport(result, options) {
                 total: result.findings.length
             }
         },
-        findings: result.findings
+        findings: result.findings,
+        ...(result.suppressedFindings
+            ? { suppressedFindings: result.suppressedFindings }
+            : {}),
+        ...(result.suppressionSummary
+            ? { suppressionSummary: result.suppressionSummary }
+            : {})
     };
 }
 export function renderJsonReport(result, options) {

package/dist/reporting/render-markdown-report.js

@@ -16,7 +16,10 @@ export function buildMarkdownReport(result, options) {
         `| Warn Findings | ${warnCount} |`,
         `| Total Findings | ${result.findings.length} |`
     ];
-    if (result.findings.length === 0) {
+    if (result.suppressionSummary) {
+        lines.push(`| Suppressions Applied | ${result.suppressionSummary.applied} |`, `| Suppressions Expired | ${result.suppressionSummary.expired} |`, `| Suppressions Invalid | ${result.suppressionSummary.invalid} |`);
+    }
+    if (result.findings.length === 0 && !result.suppressedFindings?.length) {
         lines.push("", "No findings.");
         return lines.join("\n");
     }
@@ -33,22 +36,39 @@ export function buildMarkdownReport(result, options) {
         lines.push(`| prompts/list | ${result.runtimeScorecard.promptsList.toUpperCase()} |`);
         lines.push(`| prompts/get | ${result.runtimeScorecard.promptGet.toUpperCase()} |`);
     }
-    lines.push("", "## Findings", "");
-    for (const finding of result.findings) {
-        lines.push(`### ${finding.severity.toUpperCase()} \`${finding.id}\``);
-        lines.push("");
-        lines.push(`- Message: ${finding.message}`);
-        lines.push(`- Impact: ${finding.impact}`);
-        lines.push(`- Suggested fix: ${finding.suggestedFix}`);
-        const fingerprint = formatFindingFingerprintLine(finding);
-        if (fingerprint) {
-            lines.push(`- Fingerprint: \`${fingerprint}\``);
+    if (result.findings.length > 0) {
+        lines.push("", "## Findings", "");
+        for (const finding of result.findings) {
+            lines.push(`### ${finding.severity.toUpperCase()} \`${finding.id}\``);
+            lines.push("");
+            lines.push(`- Message: ${finding.message}`);
+            lines.push(`- Impact: ${finding.impact}`);
+            lines.push(`- Suggested fix: ${finding.suggestedFix}`);
+            const fingerprint = formatFindingFingerprintLine(finding);
+            if (fingerprint) {
+                lines.push(`- Fingerprint: \`${fingerprint}\``);
+            }
+            const evidence = formatFindingEvidenceLine(finding);
+            if (evidence) {
+                lines.push(`- Evidence: ${evidence}`);
+            }
+            lines.push("");
         }
-        const evidence = formatFindingEvidenceLine(finding);
-        if (evidence) {
-            lines.push(`- Evidence: ${evidence}`);
+    }
+    else {
+        lines.push("", "No active findings.");
+    }
+    if (result.suppressedFindings?.length) {
+        lines.push("", "## Suppressed Findings", "");
+        for (const finding of result.suppressedFindings) {
+            lines.push(`### ${finding.severity.toUpperCase()} \`${finding.id}\``);
+            lines.push("");
+            lines.push(`- Message: ${finding.message}`);
+            lines.push(`- Fingerprint: \`${finding.fingerprint ?? "unavailable"}\``);
+            lines.push(`- Reason: ${finding.suppression.reason}`);
+            lines.push(`- Expires: ${finding.suppression.expiresAt}`);
+            lines.push("");
         }
-        lines.push("");
     }
     return lines.join("\n");
 }

package/dist/reporting/render-sarif-report.js

@@ -55,7 +55,15 @@ export function renderSarifReport(result) {
                         }
                         : {}),
                     ...(finding.evidence ? { properties: { evidence: finding.evidence } } : {})
-                }))
+                })),
+                ...(result.suppressionSummary
+                    ? {
+                        properties: {
+                            suppressionSummary: result.suppressionSummary,
+                            suppressedFindings: result.suppressedFindings ?? []
+                        }
+                    }
+                    : {})
             }
         ]
     };

package/dist/reporting/render-suppression-management.d.ts

@@ -0,0 +1,7 @@
+import type { ManagedSuppressionRecord, SuppressionMutationResult } from "../core/suppression-management.js";
+type SuppressionMutationCommand = "suppress.add" | "suppress.remove";
+export declare function renderSuppressionList(configPath: string, suppressions: ManagedSuppressionRecord[]): string;
+export declare function renderSuppressionListJson(configPath: string, suppressions: ManagedSuppressionRecord[]): string;
+export declare function renderSuppressionMutation(command: SuppressionMutationCommand, configPath: string, result: SuppressionMutationResult): string;
+export declare function renderSuppressionMutationJson(command: SuppressionMutationCommand, configPath: string, result: SuppressionMutationResult): string;
+export {};

package/dist/reporting/render-suppression-management.js

@@ -0,0 +1,117 @@
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isInvalidField(value) {
+    return (value === "record" ||
+        value === "fingerprint" ||
+        value === "reason" ||
+        value === "expiresAt");
+}
+function isValidSuppressionSummary(value) {
+    return (isObject(value) &&
+        !("invalidField" in value) &&
+        typeof value.fingerprint === "string" &&
+        typeof value.reason === "string" &&
+        value.reason.trim().length > 0 &&
+        typeof value.expiresAt === "string");
+}
+function buildListEntry(record) {
+    if (record.status === "invalid" && isInvalidField(record.invalidField)) {
+        return {
+            index: record.index,
+            status: record.status,
+            invalidField: record.invalidField
+        };
+    }
+    if ((record.status === "active" || record.status === "expired") &&
+        isValidSuppressionSummary(record)) {
+        return {
+            index: record.index,
+            status: record.status,
+            fingerprint: record.fingerprint,
+            reason: record.reason,
+            expiresAt: record.expiresAt
+        };
+    }
+    return {
+        index: record.index,
+        status: "invalid",
+        invalidField: "record"
+    };
+}
+function buildMutationSummary(value) {
+    if (isObject(value) && isInvalidField(value.invalidField)) {
+        return {
+            invalidField: value.invalidField
+        };
+    }
+    if (isValidSuppressionSummary(value)) {
+        return {
+            fingerprint: value.fingerprint,
+            reason: value.reason,
+            expiresAt: value.expiresAt
+        };
+    }
+    return { invalidField: "record" };
+}
+function getActionLabel(command) {
+    return command === "suppress.add" ? "Added" : "Removed";
+}
+export function renderSuppressionList(configPath, suppressions) {
+    const lines = [
+        `Config: ${configPath}`,
+        `Total suppressions: ${suppressions.length}`
+    ];
+    if (suppressions.length === 0) {
+        lines.push("", "No suppressions.");
+        return lines.join("\n");
+    }
+    lines.push("", "Suppressions", "------------");
+    for (const suppression of suppressions) {
+        const entry = buildListEntry(suppression);
+        if (entry.status === "invalid") {
+            lines.push(`[${entry.index}] INVALID ${entry.invalidField}`);
+            continue;
+        }
+        lines.push(`[${entry.index}] ${entry.status.toUpperCase()} ${entry.fingerprint}`);
+        lines.push(`  Reason: ${entry.reason}`);
+        lines.push(`  Expires: ${entry.expiresAt}`);
+    }
+    return lines.join("\n");
+}
+export function renderSuppressionListJson(configPath, suppressions) {
+    return JSON.stringify({
+        schemaVersion: "1.0.0",
+        kind: "doctor.suppress.list",
+        command: "suppress.list",
+        configPath,
+        suppressions: suppressions.map(buildListEntry)
+    }, null, 2);
+}
+export function renderSuppressionMutation(command, configPath, result) {
+    const summary = buildMutationSummary(result.suppression);
+    const lines = [
+        `Action: ${getActionLabel(command)}`,
+        `Config: ${configPath}`,
+        `Index: ${result.index}`
+    ];
+    lines.push("");
+    if ("invalidField" in summary) {
+        lines.push(`Invalid field: ${summary.invalidField}`);
+        return lines.join("\n");
+    }
+    lines.push(`Fingerprint: ${summary.fingerprint}`);
+    lines.push(`Reason: ${summary.reason}`);
+    lines.push(`Expires: ${summary.expiresAt}`);
+    return lines.join("\n");
+}
+export function renderSuppressionMutationJson(command, configPath, result) {
+    return JSON.stringify({
+        schemaVersion: "1.0.0",
+        kind: `doctor.${command}`,
+        command,
+        configPath,
+        index: result.index,
+        suppression: buildMutationSummary(result.suppression)
+    }, null, 2);
+}

package/dist/reporting/render-text-report.js

@@ -35,7 +35,10 @@ export function renderTextReport(result, options = {}) {
         `Target: ${result.targetPath}`,
         `Summary: ${failCount} fail, ${warnCount} warn, ${totalCount} total`
     ];
-    if (result.findings.length === 0) {
+    if (result.suppressionSummary) {
+        lines.push(`Suppressions: ${result.suppressionSummary.applied} applied, ${result.suppressionSummary.expired} expired, ${result.suppressionSummary.invalid} invalid`);
+    }
+    if (result.findings.length === 0 && !result.suppressedFindings?.length) {
         if (result.runtimeScorecard) {
             lines.push("", "Runtime Scorecard", "----------------");
             lines.push(`initialize: ${result.runtimeScorecard.initialize}`);
@@ -82,6 +85,16 @@ export function renderTextReport(result, options = {}) {
     };
     appendSection("Failures", failures, glyphs.fail);
     appendSection("Warnings", warnings, glyphs.warn);
+    if (result.suppressedFindings?.length) {
+        lines.push("", "Suppressed Findings", "-------------------");
+        for (const finding of result.suppressedFindings) {
+            lines.push(`- ${finding.id}`);
+            lines.push(`  Message: ${finding.message}`);
+            lines.push(`  Fingerprint: ${finding.fingerprint ?? "unavailable"}`);
+            lines.push(`  Reason: ${finding.suppression.reason}`);
+            lines.push(`  Expires: ${finding.suppression.expiresAt}`);
+        }
+    }
     if (result.runtimeScorecard) {
         lines.push("", "Runtime Scorecard", "----------------");
         lines.push(`initialize: ${result.runtimeScorecard.initialize}`);

package/dist/rules/rule-catalog.d.ts

@@ -1,4 +1,4 @@
-export type RuleCategory = "package" | "skill" | "mcp" | "runtime" | "security";
+export type RuleCategory = "package" | "skill" | "mcp" | "runtime" | "security" | "configuration";
 export type RuleSeverity = "fail" | "warn";
 export interface RuleDefinition {
     id: string;

package/dist/rules/rule-catalog.js

@@ -1,4 +1,22 @@
 export const ruleCatalog = [
+    {
+        id: "suppression.invalid",
+        category: "configuration",
+        defaultSeverity: "warn",
+        summary: "A targeted suppression record is invalid.",
+        why: "Invalid suppression records are not applied and can create false confidence about accepted findings.",
+        fix: "Fix or remove the invalid suppression record in `.codex-doctor.json`.",
+        example: '{ "fingerprint": "<64 lowercase hex characters>", "reason": "Reviewed exception.", "expiresAt": "2026-07-31" }'
+    },
+    {
+        id: "suppression.expired",
+        category: "configuration",
+        defaultSeverity: "warn",
+        summary: "A targeted suppression has expired.",
+        why: "Expired risk acceptance must be reviewed again before the finding can be suppressed.",
+        fix: "Remove the expired record or replace it with a newly reviewed expiration date.",
+        example: '{ "fingerprint": "<fingerprint>", "reason": "Reviewed again.", "expiresAt": "2026-08-31" }'
+    },
     {
         id: "plugin.manifest.missing",
         category: "package",

package/dist/run-cli.d.ts

@@ -1,4 +1,5 @@
 import { runCheck } from "./index.js";
+import { writeRawDoctorConfig } from "./index.js";
 export interface CliIo {
     writeStdout(message: string): void;
     writeStderr(message: string): void;
@@ -13,6 +14,8 @@ export interface CliTerminalContext {
 export interface RunCliOptions {
     terminalContext?: CliTerminalContext;
     runCheckImpl?: typeof runCheck;
+    writeRawDoctorConfigImpl?: typeof writeRawDoctorConfig;
+    now?: () => Date;
     releaseAssetUploadImpl?: (args: string[]) => Promise<void>;
     resolveLatestVersion?: () => Promise<string>;
 }