toolmoat 0.0.0-stage → 0.1.0

package/dist/commands/scan.js

@@ -0,0 +1,323 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { performance } from 'node:perf_hooks';
+import { parseArgs } from 'node:util';
+import { isReportFormat, REPORT_FORMATS, renderReport } from '../report/index.js';
+import { allRules } from '../rules/index.js';
+import { countBySeverity, scanFiles } from '../scan/engine.js';
+import { emptyIgnore, isFindingIgnored, parseIgnoreFile } from '../scan/ignore.js';
+import { atLeast, isSeverity, SEVERITIES } from '../types.js';
+import { palette } from '../util/colors.js';
+import { expandHome, toDisplayPath } from '../util/paths.js';
+import { VERSION } from '../version.js';
+export const help = `Usage: toolmoat scan [paths...] [options]
+
+Scan agent skills, plugins, hooks and MCP server configs for malicious or
+risky content. Runs fully offline. With no paths, scans the default agent
+locations (Claude Code, Claude Desktop, Cursor, Windsurf, VS Code, Codex...).
+
+Options:
+  -f, --format <format>      text (default), json, sarif or markdown
+  -o, --output <file>        Write the report to a file and print a one-line summary
+      --fail-on <severity>   Exit 1 when a finding is at or above this severity:
+                             critical, high (default), medium, low, info or none
+      --min-severity <sev>   Hide findings below this severity (default: low,
+                             or info with --verbose)
+      --ignore-file <file>   Suppressions to apply (default: ./.toolmoatignore
+                             if present; never read from scanned targets)
+      --no-ignore            Apply no ignore file at all, e.g. when the current
+                             directory is itself an untrusted download
+      --defaults             Also scan the default agent locations when paths are given
+      --deep                 Look further: deeper directory levels and bundled files
+      --max-file-size <MiB>  Skip files larger than this many MiB
+  -q, --quiet                Only print findings (nothing when clean); with
+                             --output, print nothing to stdout
+  -v, --verbose              Show info findings, skipped files and rule errors
+      --color, --no-color    Force or disable colors (NO_COLOR is honoured)
+
+--fail-on also counts findings hidden by --min-severity, but never findings
+suppressed by the ignore file.
+
+Exit codes:
+  0  no findings at or above --fail-on
+  1  findings at or above --fail-on
+  2  usage or runtime error, including a path that does not exist
+
+Examples:
+  toolmoat scan
+  toolmoat scan ./skills --format sarif --output toolmoat.sarif
+  toolmoat scan . --fail-on medium --format markdown >> "$GITHUB_STEP_SUMMARY"`;
+/** Loaded on first use, so the scan core can be driven with in-memory files and no filesystem walker. */
+async function lazyDiscover(options) {
+    const mod = await import('../scan/discover.js');
+    return mod.discover(options);
+}
+/** The scan pipeline without any I/O of its own: discover, run the rules, filter, decide the exit code. */
+export async function runScan(options, deps = { discover: lazyDiscover }) {
+    const started = performance.now();
+    const ignore = options.ignore ?? emptyIgnore();
+    const minSeverity = options.minSeverity ?? 'low';
+    const failOn = options.failOn ?? 'high';
+    const rules = deps.rules ?? allRules;
+    const discovered = await deps.discover({
+        paths: options.paths,
+        useDefaults: options.useDefaults,
+        cwd: options.cwd,
+        deep: options.deep,
+        maxFileBytes: options.maxFileBytes,
+        ignore,
+    });
+    const ruleErrors = [];
+    const all = scanFiles(discovered.files, {
+        rules,
+        onRuleError: (rule, file, error) => {
+            ruleErrors.push({ ruleId: rule.id, file: file.displayPath, message: error instanceof Error ? error.message : String(error) });
+        },
+    });
+    const active = all.filter((finding) => !isFindingIgnored(finding.ruleId, finding.file, ignore));
+    const shown = active.filter((finding) => atLeast(finding.severity, minSeverity));
+    const failed = failOn !== 'none' && active.some((finding) => atLeast(finding.severity, failOn));
+    const targets = new Set();
+    const filePaths = new Map();
+    for (const file of discovered.files) {
+        if (file.target)
+            targets.add(file.target);
+        if (!filePaths.has(file.displayPath))
+            filePaths.set(file.displayPath, file.path);
+    }
+    return {
+        result: {
+            findings: shown,
+            filesScanned: discovered.files.length,
+            targets: [...targets].sort(),
+            skipped: discovered.skipped,
+            rules,
+            durationMs: performance.now() - started,
+        },
+        exitCode: failed ? 1 : 0,
+        roots: discovered.roots,
+        hidden: active.length - shown.length,
+        suppressed: all.length - active.length,
+        ruleErrors,
+        filePaths,
+    };
+}
+class UsageError extends Error {
+}
+export async function run(argv, io = {}) {
+    const env = { ...defaultIo(), ...io };
+    let cli;
+    try {
+        cli = parseCli(argv);
+    }
+    catch (error) {
+        env.stderr(`toolmoat scan: ${usageMessage(error)}\nRun 'toolmoat scan --help' for usage.\n`);
+        return 2;
+    }
+    if (cli.help) {
+        env.stdout(`${help}\n`);
+        return 0;
+    }
+    // A mistyped path in CI must not turn into a silent, green "0 files scanned".
+    const missing = cli.paths.filter((p) => !fs.existsSync(path.resolve(env.cwd, expandHome(p))));
+    if (missing.length > 0) {
+        env.stderr(`toolmoat scan: path not found: ${missing.join(', ')}\n`);
+        return 2;
+    }
+    let ignore;
+    try {
+        ignore = cli.noIgnore ? { config: emptyIgnore() } : loadIgnore(cli.ignoreFile, env.cwd);
+    }
+    catch (error) {
+        env.stderr(`toolmoat scan: ${errorMessage(error)}\n`);
+        return 2;
+    }
+    let outcome;
+    try {
+        outcome = await runScan({
+            paths: cli.paths,
+            useDefaults: cli.useDefaults,
+            cwd: env.cwd,
+            deep: cli.deep,
+            maxFileBytes: cli.maxFileBytes,
+            ignore: ignore.config,
+            minSeverity: cli.minSeverity,
+            failOn: cli.failOn,
+        }, env.deps);
+    }
+    catch (error) {
+        env.stderr(`toolmoat scan: ${errorMessage(error)}\n`);
+        return 2;
+    }
+    reportRuleErrors(outcome.ruleErrors, cli.verbose, env);
+    const toFile = cli.output !== undefined;
+    const report = renderReport(cli.format, outcome.result, {
+        roots: outcome.roots,
+        cwd: env.cwd,
+        color: !toFile && cli.format === 'text' && (cli.color ?? env.color),
+        verbose: cli.verbose,
+        quiet: cli.quiet && !toFile,
+        minSeverity: cli.minSeverity,
+        hidden: outcome.hidden,
+        suppressed: outcome.suppressed,
+        ignoreFile: ignore.display,
+        filePaths: outcome.filePaths,
+    });
+    if (cli.output === undefined) {
+        env.stdout(report);
+        return outcome.exitCode;
+    }
+    const target = path.resolve(env.cwd, cli.output);
+    try {
+        fs.mkdirSync(path.dirname(target), { recursive: true });
+        fs.writeFileSync(target, report, 'utf8');
+    }
+    catch (error) {
+        env.stderr(`toolmoat scan: cannot write ${cli.output}: ${errorMessage(error)}\n`);
+        return 2;
+    }
+    if (!cli.quiet)
+        env.stdout(`${summaryLine(outcome, cli.format, toDisplayPath(target, env.cwd))}\n`);
+    return outcome.exitCode;
+}
+function defaultIo() {
+    return {
+        cwd: process.cwd(),
+        stdout: (text) => process.stdout.write(text),
+        stderr: (text) => process.stderr.write(text),
+        // Probe the shared palette so TTY, NO_COLOR and FORCE_COLOR are decided in one place.
+        color: palette(process.stdout).bold('x') !== 'x',
+        deps: { discover: lazyDiscover },
+    };
+}
+function parseCli(argv) {
+    const { values, positionals } = parseArgs({
+        args: argv,
+        allowPositionals: true,
+        strict: true,
+        options: {
+            format: { type: 'string', short: 'f' },
+            output: { type: 'string', short: 'o' },
+            'fail-on': { type: 'string' },
+            'min-severity': { type: 'string' },
+            'ignore-file': { type: 'string' },
+            'no-ignore': { type: 'boolean' },
+            defaults: { type: 'boolean' },
+            deep: { type: 'boolean' },
+            'max-file-size': { type: 'string' },
+            quiet: { type: 'boolean', short: 'q' },
+            verbose: { type: 'boolean', short: 'v' },
+            color: { type: 'boolean' },
+            'no-color': { type: 'boolean' },
+            help: { type: 'boolean', short: 'h' },
+        },
+    });
+    const format = values.format ?? 'text';
+    if (!isReportFormat(format))
+        throw new UsageError(`unknown format '${format}' (expected ${REPORT_FORMATS.join(', ')})`);
+    const failOn = values['fail-on'] ?? 'high';
+    if (failOn !== 'none' && !isSeverity(failOn)) {
+        throw new UsageError(`invalid --fail-on '${failOn}' (expected ${SEVERITIES.join(', ')} or none)`);
+    }
+    const verbose = values.verbose ?? false;
+    const minSeverity = values['min-severity'] ?? (verbose ? 'info' : 'low');
+    if (!isSeverity(minSeverity))
+        throw new UsageError(`invalid --min-severity '${minSeverity}' (expected ${SEVERITIES.join(', ')})`);
+    if (values.output === '')
+        throw new UsageError('--output needs a file name');
+    if (values['no-ignore'] && values['ignore-file'] !== undefined)
+        throw new UsageError('--ignore-file and --no-ignore cannot be combined');
+    const cli = {
+        help: values.help ?? false,
+        paths: positionals,
+        useDefaults: positionals.length === 0 || (values.defaults ?? false),
+        format,
+        failOn,
+        minSeverity,
+        noIgnore: values['no-ignore'] ?? false,
+        deep: values.deep ?? false,
+        quiet: values.quiet ?? false,
+        verbose,
+    };
+    if (values.output !== undefined)
+        cli.output = values.output;
+    if (values['ignore-file'] !== undefined)
+        cli.ignoreFile = values['ignore-file'];
+    if (values['max-file-size'] !== undefined)
+        cli.maxFileBytes = parseMiB(values['max-file-size']);
+    if (values['no-color'])
+        cli.color = false;
+    else if (values.color)
+        cli.color = true;
+    return cli;
+}
+function parseMiB(value) {
+    const mib = /^\d{1,6}(?:\.\d{1,6})?$/.test(value.trim()) ? Number(value) : Number.NaN;
+    if (!Number.isFinite(mib) || mib <= 0)
+        throw new UsageError(`invalid --max-file-size '${value}' (expected a positive number of MiB)`);
+    return Math.max(1, Math.round(mib * 1024 * 1024));
+}
+/**
+ * The user's suppressions: --ignore-file when given (it must exist), else
+ * .toolmoatignore in the cwd when present. Ignore files inside scanned
+ * targets are never consulted.
+ */
+function loadIgnore(ignoreFile, cwd) {
+    if (ignoreFile !== undefined) {
+        const file = path.resolve(cwd, ignoreFile);
+        let text;
+        try {
+            text = fs.readFileSync(file, 'utf8');
+        }
+        catch (error) {
+            throw new Error(`cannot read ignore file ${ignoreFile}: ${errorMessage(error)}`);
+        }
+        return { config: parseIgnoreFile(text), display: toDisplayPath(file, cwd) };
+    }
+    const local = path.join(cwd, '.toolmoatignore');
+    let text;
+    try {
+        text = fs.readFileSync(local, 'utf8');
+    }
+    catch {
+        return { config: emptyIgnore() };
+    }
+    return { config: parseIgnoreFile(text), display: '.toolmoatignore' };
+}
+function reportRuleErrors(errors, verbose, io) {
+    if (errors.length === 0)
+        return;
+    if (verbose) {
+        for (const e of errors)
+            io.stderr(`toolmoat scan: rule ${e.ruleId} failed on ${e.file}: ${e.message}\n`);
+        return;
+    }
+    const noun = errors.length === 1 ? 'error' : 'errors';
+    io.stderr(`toolmoat scan: ${errors.length} rule ${noun} while scanning (run with --verbose for details)\n`);
+}
+/** One line for stdout when the report itself went to a file. */
+export function summaryLine(outcome, format, written) {
+    const { result } = outcome;
+    const files = `${result.filesScanned} file${result.filesScanned === 1 ? '' : 's'}`;
+    let status = 'no issues found';
+    if (result.findings.length > 0) {
+        const counts = countBySeverity(result.findings);
+        const parts = SEVERITIES.filter((s) => counts[s] > 0).map((s) => `${counts[s]} ${s}`);
+        status = `${result.findings.length} finding${result.findings.length === 1 ? '' : 's'} (${parts.join(', ')})`;
+    }
+    return `toolmoat ${VERSION}: ${status} in ${files}; ${format} report written to ${written}`;
+}
+function usageMessage(error) {
+    if (error instanceof UsageError)
+        return error.message;
+    const code = error?.code;
+    const message = errorMessage(error);
+    if (code === 'ERR_PARSE_ARGS_UNKNOWN_OPTION') {
+        const option = /'([^']{1,200})'/.exec(message)?.[1];
+        return option ? `unknown option '${option}'` : message;
+    }
+    return message;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/commands/unwrap.d.ts

@@ -0,0 +1,5 @@
+import type { ServerTransform } from './wrap.js';
+export declare const help = "Usage: toolmoat unwrap [options]\n\nUndoes `toolmoat wrap`: every server whose command runs `toolmoat proxy` gets\nback the command and args that follow the \"--\" in its wrapped command line.\nOther keys (env, cwd, type, ...) are not touched.\n\nOptions:\n  --client <id>    Only this client (repeatable), as for wrap\n  --config <file>  Unwrap the servers in this config file (repeatable)\n  --dry-run        Show what would change and write nothing\n  --force          Rewrite JSON files that contain comments (the comments are lost)\n\nWithout --client or --config, every user-level config that exists is processed.\nCodex's config.toml is never edited: unwrap prints the lines to paste.\nRestart the client afterwards.";
+/** The unwrap transform for JSON configs. */
+export declare const unwrapTransform: ServerTransform;
+export declare function run(argv: string[]): Promise<number>;

package/dist/commands/unwrap.js

@@ -0,0 +1,69 @@
+import { originalLaunch, readLaunch, splitWrapped } from '../clients/configs.js';
+import { formatLaunch, parseTargetArgs, processTargets, selectTargets, summarize, UsageError } from './wrap.js';
+export const help = `Usage: toolmoat unwrap [options]
+
+Undoes \`toolmoat wrap\`: every server whose command runs \`toolmoat proxy\` gets
+back the command and args that follow the "--" in its wrapped command line.
+Other keys (env, cwd, type, ...) are not touched.
+
+Options:
+  --client <id>    Only this client (repeatable), as for wrap
+  --config <file>  Unwrap the servers in this config file (repeatable)
+  --dry-run        Show what would change and write nothing
+  --force          Rewrite JSON files that contain comments (the comments are lost)
+
+Without --client or --config, every user-level config that exists is processed.
+Codex's config.toml is never edited: unwrap prints the lines to paste.
+Restart the client afterwards.`;
+const NOTHING_AFTER_SEPARATOR = 'wrapped, but nothing follows "--" to restore; fix it by hand';
+/**
+ * Restores command and args in place. wrap puts a new args key before command
+ * when the original entry had none, so that order plus an empty argument list
+ * means the original had no args key at all.
+ */
+function applyUnwrapped(server, original) {
+    const keys = Object.keys(server);
+    const argsFirst = keys.indexOf('args') < keys.indexOf('command');
+    server.command = original.command;
+    if (argsFirst && original.args.length === 0)
+        delete server.args;
+    else
+        server.args = original.args;
+}
+/** What unwrap does with one command line: restore the original, or say why not. */
+function planUnwrap(launch) {
+    if (!splitWrapped(launch.command, launch.args))
+        return { status: 'unchanged', detail: 'not wrapped' };
+    const original = originalLaunch(launch);
+    if (!original)
+        return { status: 'skipped', detail: NOTHING_AFTER_SEPARATOR };
+    return { status: 'changed', detail: formatLaunch(original), after: original };
+}
+/** The unwrap transform for JSON configs. */
+export const unwrapTransform = (entry) => {
+    const base = entry.project === undefined ? { name: entry.name } : { name: entry.name, project: entry.project };
+    const launch = readLaunch(entry.server);
+    if ('error' in launch)
+        return { ...base, status: 'unchanged', detail: 'not wrapped' };
+    const plan = planUnwrap(launch);
+    if (plan.after)
+        applyUnwrapped(entry.server, plan.after);
+    return { ...base, ...plan };
+};
+export async function run(argv) {
+    let args;
+    let selection;
+    try {
+        args = parseTargetArgs(argv, false);
+        selection = selectTargets(args.clients, args.configs, process.cwd());
+    }
+    catch (error) {
+        if (!(error instanceof UsageError))
+            throw error;
+        process.stderr.write(`toolmoat unwrap: ${error.message}\n\n${help}\n`);
+        return 2;
+    }
+    const unwrapToml = (name, launch) => ({ name, ...planUnwrap(launch) });
+    const reports = processTargets(selection.targets, unwrapTransform, unwrapToml, { dryRun: args.dryRun, force: args.force });
+    return summarize(reports, selection, args.dryRun, 'unwrap');
+}

package/dist/commands/wrap.d.ts

@@ -0,0 +1,131 @@
+import type { ConfigFormat, Launch, ServerEntry, ServersKey } from '../clients/configs.js';
+export declare const help = "Usage: toolmoat wrap [options]\n\nRoutes the stdio MCP servers in your client configs through `toolmoat proxy`,\nwhich pins tool definitions, guards outgoing secrets and keeps an audit log.\n\nOptions:\n  --client <id>    Only this client (repeatable): claude-desktop, claude-code, cursor,\n                   vscode, windsurf, codex, gemini, or one config id such as\n                   claude-code-project, cursor-project, vscode-project, gemini-project\n  --config <file>  Wrap the servers in this config file (repeatable)\n  --lock <file>    Lockfile the proxy should use instead of its default\n  --mode <mode>    Proxy mode: enforce or warn\n  --dry-run        Show what would change and write nothing\n  --force          Rewrite JSON files that contain comments (the comments are lost)\n\nWithout --client or --config, every user-level config that exists is wrapped:\nClaude Desktop, Claude Code (~/.claude.json, including its per-project servers),\nCursor, VS Code, Windsurf, Gemini CLI and Codex. Project configs (.mcp.json,\n.cursor/mcp.json, .vscode/mcp.json, .gemini/settings.json) are only wrapped when\nnamed, because they are usually committed and the wrapped command holds paths\nfrom this machine.\n\nEach file is copied once to <file>.toolmoat.bak before its first change and is\nreplaced atomically. Remote (url) servers are left alone. Servers that are\nalready wrapped are left alone too, unless the node or cli.js path they start\nno longer exists (say after switching Node versions): those are pointed at this\ninstall. Codex's config.toml is never edited: wrap prints the lines to paste.\nRestart the client afterwards. Undo with `toolmoat unwrap`.";
+/** Raised for bad command-line input; run() turns it into exit code 2. */
+export declare class UsageError extends Error {
+}
+/** The part of a wrapped command line that starts toolmoat, up to (not including) "proxy". */
+export interface Launcher {
+    command: string;
+    prefix: string[];
+}
+export interface ProxyOptions {
+    lock?: string;
+    mode?: 'enforce' | 'warn';
+}
+/** Absolute path of the cli.js that is running this command. */
+export declare function currentCliPath(): string;
+/**
+ * How a wrapped server starts toolmoat: the running node with the running
+ * cli.js, or `npx -y toolmoat@<version>` when cli.js sits in the npx cache,
+ * which npm may clean at any time.
+ */
+export declare function launcherFor(cliPath: string, nodePath?: string): Launcher;
+/** The wrapped command line for a server. */
+export declare function wrapLaunch(name: string, original: Launch, launcher: Launcher, options?: ProxyOptions): Launch;
+/** A config file that wrap or unwrap will process. */
+export interface ConfigTarget {
+    path: string;
+    label: string;
+    /** Short id that prefixes the proxy --name of servers wrapped in this file, e.g. "cursor-user". */
+    scope: string;
+    format: ConfigFormat;
+    serversKeys: readonly ServersKey[];
+    /** Project configs get a note that the file is usually committed. */
+    project: boolean;
+    /** Named on the command line, so a missing file is an error rather than silently skipped. */
+    explicit: boolean;
+}
+export interface Selection {
+    targets: ConfigTarget[];
+    /** Project configs that exist but were left out because nothing named them. */
+    projectHints: ConfigTarget[];
+}
+/** Resolves --client and --config into the config files to process. Throws UsageError for an unknown client. */
+export declare function selectTargets(clients: readonly string[], configs: readonly string[], cwd: string): Selection;
+export type ServerStatus = 'changed' | 'unchanged' | 'skipped';
+export interface ServerReport {
+    name: string;
+    project?: string;
+    status: ServerStatus;
+    /** For changed servers, the original command line; otherwise why nothing changed. */
+    detail: string;
+    /** The command line after the change. */
+    after?: Launch;
+    /** For servers wrap newly wraps: the command line it had. */
+    original?: Launch;
+}
+export interface ConfigReport {
+    target: ConfigTarget;
+    servers: ServerReport[];
+    /** Why the file could not be read or written. Changed servers in it were not saved. */
+    error?: string;
+    written: boolean;
+    /** Backup created by this run. */
+    backup?: string;
+    /** For TOML configs: the lines the user should paste, because toolmoat never edits TOML. */
+    pasteLines?: string[];
+}
+/** Decides what happens to one server. It changes entry.server in place when the status is 'changed'. */
+export type ServerTransform = (entry: ServerEntry) => ServerReport;
+/** Reads a JSON config, applies the transform to every server and writes the file when something changed. */
+export declare function processJsonTarget(target: ConfigTarget, transform: ServerTransform, options: {
+    dryRun: boolean;
+    force: boolean;
+}): ConfigReport;
+/**
+ * The node or cli.js path of a wrapped command line that no longer exists on
+ * this machine (after a Node version switch, a reinstall or a config synced
+ * from another machine), or null when the launcher is fine or not path-based.
+ */
+export declare function missingLauncherPath(launch: Launch): string | null;
+/** Whether `toolmoat proxy --name` accepts the name: it refuses an empty one, control characters and more than 200 characters. */
+export declare function isProxyName(name: string): boolean;
+/** What wrap does with one stdio command line: wrap it, point a stale wrapped one at this install, or leave it. */
+export declare function planWrap(name: string, launch: Launch, launcher: Launcher, options: ProxyOptions): Pick<ServerReport, 'status' | 'detail' | 'after' | 'original'>;
+/**
+ * The --name a wrapped server gets: the client, the project for per-project
+ * servers, then the server's own name ("cursor.github", "claude-code-user.my-app.db").
+ * The lockfile keys pins by name, so two clients that both call a server
+ * "github" must not share one entry, or each would hide the other's tools.
+ */
+export declare function scopedName(scope: string, name: string, project?: string): string;
+/** The wrap transform: replaces command and args of each stdio server with the proxy launch. */
+export declare function wrapTransform(launcher: Launcher, options: ProxyOptions, scope?: string): ServerTransform;
+/** Wrap's view of a Codex config.toml: never edited, so changed servers come with lines to paste. */
+export declare function processTomlTarget(target: ConfigTarget, transform: (name: string, launch: Launch) => ServerReport): ConfigReport;
+/** A command line for display: quoted where needed, secrets redacted, invisible characters escaped. */
+export declare function formatLaunch(launch: Launch, max?: number): string;
+/** Relative to the working directory when inside it, '~/...' inside the home directory, else absolute; forward slashes. */
+export declare function shownPath(file: string): string;
+/** Client names to restart, from the labels of the configs that were written. */
+export declare function clientsToRestart(reports: readonly ConfigReport[]): string[];
+export interface ParsedTargetArgs {
+    clients: string[];
+    configs: string[];
+    dryRun: boolean;
+    force: boolean;
+    lock?: string;
+    mode?: string;
+}
+/** Parses the options wrap and unwrap share (plus wrap's --lock and --mode when allowed). Throws UsageError. */
+export declare function parseTargetArgs(argv: string[], withProxyOptions: boolean): ParsedTargetArgs;
+/** Prints the per-config report shared by wrap and unwrap. */
+export declare function printReports(reports: readonly ConfigReport[], verbs: {
+    done: string;
+    planned: string;
+}, dryRun: boolean): void;
+/** Counts the JSON-config servers that were (or, in a dry run, would be) changed. TOML changes are only printed. */
+export declare function countChanged(reports: readonly ConfigReport[], dryRun: boolean): number;
+/** Processes the selected targets; missing explicit files become error reports, missing default ones are dropped. */
+export declare function processTargets(targets: readonly ConfigTarget[], jsonTransform: ServerTransform, tomlTransform: (name: string, launch: Launch) => ServerReport, options: {
+    dryRun: boolean;
+    force: boolean;
+}): ConfigReport[];
+export declare function run(argv: string[]): Promise<number>;
+/** Names shared by newly wrapped servers that run different programs, with those programs. */
+export declare function nameClashes(reports: readonly ConfigReport[]): {
+    name: string;
+    programs: string[];
+}[];
+/** Prints the reports and the closing summary, and returns the exit code. */
+export declare function summarize(reports: readonly ConfigReport[], selection: Selection, dryRun: boolean, verb: 'wrap' | 'unwrap'): number;