vouchington-tooling 0.28.0 → 0.30.0

package/dist/agent-harness-config/cli.mjs

@@ -1,100 +0,0 @@
-import { dumpHarnessPolicy } from './policy.mjs';
-import { applyHarnessConfig, checkHarnessConfig } from './apply.mjs';
-import { HARNESS_IDS } from './types.mjs';
-const AGENT_HARNESS_CONFIG_USAGE = 'agent-harness-config dump|check|apply [--global] [--repo PATH]... [--harness NAME]... [--home PATH]';
-function isHarness(value) {
-    return HARNESS_IDS.includes(value);
-}
-export function parseAgentHarnessConfigArguments(argv) {
-    const action = argv[0];
-    if (action !== 'dump' && action !== 'check' && action !== 'apply') {
-        throw new Error(`unknown agent-harness-config action: ${action ?? ''}\n${AGENT_HARNESS_CONFIG_USAGE}`);
-    }
-    let global = false;
-    let home;
-    const repos = [];
-    const harnesses = [];
-    for (let index = 1; index < argv.length; index += 1) {
-        const flag = argv[index];
-        if (flag === '--global') {
-            global = true;
-            continue;
-        }
-        if (flag === '--repo' || flag === '--harness' || flag === '--home') {
-            const value = argv[index + 1];
-            if (value === undefined)
-                throw new Error(`${flag} requires a value\n${AGENT_HARNESS_CONFIG_USAGE}`);
-            index += 1;
-            if (flag === '--repo')
-                repos.push(value);
-            else if (flag === '--home')
-                home = value;
-            else if (!isHarness(value))
-                throw new Error(`unknown harness: ${value}`);
-            else
-                harnesses.push(value);
-            continue;
-        }
-        throw new Error(`unknown agent-harness-config option: ${flag}\n${AGENT_HARNESS_CONFIG_USAGE}`);
-    }
-    if (action !== 'dump' && !global && repos.length === 0) {
-        throw new Error(`check and apply require --global and/or --repo\n${AGENT_HARNESS_CONFIG_USAGE}`);
-    }
-    return {
-        action,
-        global,
-        repos,
-        ...(harnesses.length > 0 ? { harnesses } : {}),
-        ...(home === undefined ? {} : { home }),
-    };
-}
-function formatDrift(drift) {
-    return `  ${drift.path} ${drift.key}: ${JSON.stringify(drift.current)} -> ${JSON.stringify(drift.desired)}`;
-}
-function targets(parsed) {
-    const list = [];
-    if (parsed.global)
-        list.push({ kind: 'global' });
-    for (const root of parsed.repos)
-        list.push({ kind: 'repo', root });
-    return list;
-}
-export async function runAgentHarnessConfigCli(argv) {
-    try {
-        const parsed = parseAgentHarnessConfigArguments(argv);
-        if (parsed.action === 'dump') {
-            process.stdout.write(`${JSON.stringify(dumpHarnessPolicy(), null, 2)}\n`);
-            return 0;
-        }
-        const options = {
-            ...(parsed.harnesses === undefined ? {} : { harnesses: parsed.harnesses }),
-            ...(parsed.home === undefined ? {} : { home: parsed.home }),
-        };
-        let compliant = true;
-        for (const target of targets(parsed)) {
-            const result = parsed.action === 'apply'
-                ? await applyHarnessConfig(target, options)
-                : await checkHarnessConfig(target, options);
-            compliant &&=
-                parsed.action === 'apply'
-                    ? result.prerequisites.every((prerequisite) => prerequisite.satisfied)
-                    : result.compliant;
-            for (const file of result.files) {
-                if (file.action === 'ok')
-                    process.stdout.write(`ok ${file.path}\n`);
-                else
-                    process.stdout.write(`${file.action} ${file.path}\n`);
-                for (const drift of file.drifts)
-                    process.stdout.write(`${formatDrift(drift)}\n`);
-            }
-            for (const prerequisite of result.prerequisites) {
-                process.stdout.write(`prerequisite ${prerequisite.harness} ${prerequisite.key} satisfied=${prerequisite.satisfied}: ${prerequisite.message}\n`);
-            }
-        }
-        return compliant ? 0 : 1;
-    }
-    catch (error) {
-        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
-        return 2;
-    }
-}

package/dist/agent-harness-config/index.d.mts

@@ -1,4 +0,0 @@
-export { applyHarnessConfig, checkHarnessConfig, planHarnessConfig } from './apply.mts';
-export { dumpHarnessPolicy, DEFAULT_EXTRA_WRITABLE_ROOTS } from './policy.mts';
-export { HARNESS_IDS } from './types.mts';
-export type { ApplyTarget, FilePlan, FileResult, HarnessApplyResult, HarnessCheckResult, HarnessConfigOptions, HarnessId, HarnessPlan, HarnessPolicyDump, JsonPatch, KeyDrift, TomlPatch, TomlValue, } from './types.mts';

package/dist/agent-harness-config/index.mjs

@@ -1,3 +0,0 @@
-export { applyHarnessConfig, checkHarnessConfig, planHarnessConfig } from './apply.mjs';
-export { dumpHarnessPolicy, DEFAULT_EXTRA_WRITABLE_ROOTS } from './policy.mjs';
-export { HARNESS_IDS } from './types.mjs';

package/dist/agent-harness-config/merge-json.d.mts

@@ -1,5 +0,0 @@
-import type { JsonPatch, KeyDrift } from './types.mts';
-export declare function applyJsonPatches(source: string, patches: readonly JsonPatch[], path: string): {
-    drifts: KeyDrift[];
-    text: string;
-};

package/dist/agent-harness-config/merge-json.mjs

@@ -1,62 +0,0 @@
-import { sameValue } from './policy.mjs';
-function getJsonPath(value, path) {
-    let current = value;
-    for (const key of path) {
-        if (current === null || typeof current !== 'object' || Array.isArray(current))
-            return undefined;
-        current = current[key];
-    }
-    return current;
-}
-function setJsonPath(target, path, value) {
-    let current = target;
-    for (const key of path.slice(0, -1)) {
-        const next = current[key];
-        if (next === null || typeof next !== 'object' || Array.isArray(next)) {
-            current[key] = {};
-        }
-        current = current[key];
-    }
-    const last = path.at(-1);
-    if (last !== undefined)
-        current[last] = value;
-}
-function parseJsonObject(source, path) {
-    if (source.trim() === '')
-        return {};
-    const parsed = JSON.parse(source);
-    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        throw new Error(`${path}: expected a JSON object`);
-    }
-    return parsed;
-}
-function unionMerge(current, values) {
-    const base = Array.isArray(current) ? current : [];
-    const merged = [...base];
-    for (const value of values) {
-        if (!merged.some((entry) => sameValue(entry, value)))
-            merged.push(value);
-    }
-    return merged;
-}
-function desiredValue(document, patch) {
-    if (patch.merge !== 'union')
-        return patch.value;
-    return unionMerge(getJsonPath(document, patch.path), patch.value);
-}
-export function applyJsonPatches(source, patches, path) {
-    const document = parseJsonObject(source, path);
-    const resolved = patches.map((patch) => ({ desired: desiredValue(document, patch), patch }));
-    const drifts = [];
-    for (const { desired, patch } of resolved) {
-        const current = getJsonPath(document, patch.path);
-        if (!sameValue(current, desired)) {
-            drifts.push({ current, desired, key: patch.path.join('.'), path });
-        }
-    }
-    if (drifts.length === 0)
-        return { drifts, text: source === '' ? '{}\n' : source };
-    for (const { desired, patch } of resolved)
-        setJsonPath(document, patch.path, desired);
-    return { drifts, text: `${JSON.stringify(document, null, 2)}\n` };
-}

package/dist/agent-harness-config/merge-toml.d.mts

@@ -1,6 +0,0 @@
-import type { KeyDrift, TomlPatch } from './types.mts';
-export declare function readTomlKey(text: string, table: string, key: string): unknown;
-export declare function applyTomlPatches(source: string, patches: readonly TomlPatch[], path: string): {
-    drifts: KeyDrift[];
-    text: string;
-};

package/dist/agent-harness-config/merge-toml.mjs

@@ -1,132 +0,0 @@
-import { parse as parseToml } from 'smol-toml';
-import { sameValue } from './policy.mjs';
-import { formatTomlValue, parseTomlValue } from './toml-value.mjs';
-function lineStarts(text) {
-    const starts = [0];
-    for (let index = 0; index < text.length; index += 1) {
-        if (text[index] === '\n')
-            starts.push(index + 1);
-    }
-    return starts;
-}
-function lineAt(text, start) {
-    const end = text.indexOf('\n', start);
-    return text.slice(start, end === -1 ? text.length : end);
-}
-function isHeaderLine(line) {
-    return line.trimStart().startsWith('[');
-}
-function headerName(line) {
-    const trimmed = line.trim();
-    if (trimmed.startsWith('[[') || !trimmed.startsWith('['))
-        return undefined;
-    const close = trimmed.indexOf(']');
-    if (close <= 1)
-        return undefined;
-    return trimmed.slice(1, close);
-}
-function tableRange(text, table) {
-    const starts = lineStarts(text);
-    if (table === '') {
-        const first = starts.find((start) => isHeaderLine(lineAt(text, start)));
-        return { bodyEnd: first ?? text.length, bodyStart: 0 };
-    }
-    for (const start of starts) {
-        const line = lineAt(text, start);
-        if (headerName(line) !== table)
-            continue;
-        const bodyStart = start + line.length + (text[start + line.length] === '\n' ? 1 : 0);
-        const next = starts.find((candidate) => candidate >= bodyStart && isHeaderLine(lineAt(text, candidate)));
-        return { bodyEnd: next ?? text.length, bodyStart };
-    }
-    return { bodyEnd: -1, bodyStart: -1 };
-}
-function keyMatch(text, bodyStart, bodyEnd, key) {
-    const pattern = new RegExp(`^[ \\t]*${key.replaceAll(/[.*+?^${}()|[\]\\]/g, '\\$&')}[ \\t]*=[ \\t]*`, 'm');
-    const slice = text.slice(bodyStart, bodyEnd);
-    const match = pattern.exec(slice);
-    if (!match || match.index === undefined)
-        return undefined;
-    const equals = bodyStart + match.index + match[0].length;
-    return { equals, parsed: parseTomlValue(text, equals) };
-}
-export function readTomlKey(text, table, key) {
-    const range = tableRange(text, table);
-    if (range.bodyStart < 0)
-        return undefined;
-    return keyMatch(text, range.bodyStart, range.bodyEnd, key)?.parsed.value;
-}
-function appendTable(text, table, assignment) {
-    const prefix = text === '' || text.endsWith('\n') ? text : `${text}\n`;
-    const blank = prefix !== '' && !prefix.endsWith('\n\n') ? '\n' : '';
-    return `${prefix}${blank}[${table}]\n${assignment}\n`;
-}
-function upsertTomlKey(text, table, key, value) {
-    const assignment = `${key} = ${formatTomlValue(value)}`;
-    const range = tableRange(text, table);
-    if (range.bodyStart < 0)
-        return appendTable(text, table, assignment);
-    const existing = keyMatch(text, range.bodyStart, range.bodyEnd, key);
-    if (existing) {
-        return `${text.slice(0, existing.equals)}${formatTomlValue(value)}${text.slice(existing.parsed.end)}`;
-    }
-    const at = range.bodyEnd;
-    const prefix = at > 0 && text[at - 1] !== '\n' ? '\n' : '';
-    return `${text.slice(0, at)}${prefix}${assignment}\n${text.slice(at)}`;
-}
-function tomlPatchValue(parsed, table, key) {
-    let current = parsed;
-    if (table !== '') {
-        for (const segment of table.split('.')) {
-            /* v8 ignore next 2 -- if `text` parsed, every ancestor of a dotted table header is
-               guaranteed to be a table too, so a real TOML parser can never hand back a non-object
-               mid-path here. */
-            if (current === null || typeof current !== 'object' || Array.isArray(current))
-                return undefined;
-            current = current[segment];
-        }
-    }
-    /* v8 ignore next 2 -- assertValidToml only reaches a patch's table here once readTomlKey has
-       already proven (as a match, or by forcing the write that creates it) that the table is a
-       real nested object in this parsed document. */
-    if (current === null || typeof current !== 'object' || Array.isArray(current))
-        return undefined;
-    return current[key];
-}
-function assertValidToml(text, patches, path) {
-    let parsed;
-    try {
-        parsed = parseToml(text);
-    }
-    catch (error) {
-        /* v8 ignore next -- smol-toml's parse() only ever throws TomlError, which extends Error, so
-           the non-Error fallback here is unreachable in practice. */
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`${path}: produced invalid TOML (${message})`);
-    }
-    for (const patch of patches) {
-        const value = tomlPatchValue(parsed, patch.table, patch.key);
-        /* v8 ignore next 6 -- backstop for a formatTomlValue/parseToml encoding mismatch; formatTomlValue's
-           JSON.stringify-based escaping is a valid TOML basic string in every case this module writes,
-           so a real parser always reads back what we just wrote. */
-        if (!sameValue(value, patch.value)) {
-            const key = patch.table === '' ? patch.key : `${patch.table}.${patch.key}`;
-            throw new Error(`${path}: wrote ${key} but a real TOML parser reads back ${JSON.stringify(value)}`);
-        }
-    }
-}
-export function applyTomlPatches(source, patches, path) {
-    const drifts = [];
-    let text = source.replaceAll('\r\n', '\n');
-    for (const patch of patches) {
-        const current = readTomlKey(text, patch.table, patch.key);
-        if (sameValue(current, patch.value))
-            continue;
-        const key = patch.table === '' ? patch.key : `${patch.table}.${patch.key}`;
-        drifts.push({ current, desired: patch.value, key, path });
-        text = upsertTomlKey(text, patch.table, patch.key, patch.value);
-    }
-    if (drifts.length > 0)
-        assertValidToml(text, patches, path);
-    return { drifts, text };
-}

package/dist/agent-harness-config/paths.d.mts

@@ -1,3 +0,0 @@
-import { type FilePlan, type HarnessConfigOptions } from './types.mts';
-export declare function planGlobalFiles(options?: HarnessConfigOptions): FilePlan[];
-export declare function planRepoFiles(root: string, options?: HarnessConfigOptions): FilePlan[];

package/dist/agent-harness-config/paths.mjs

@@ -1,117 +0,0 @@
-import { homedir } from 'node:os';
-import { join, resolve } from 'node:path';
-import { CLAUDE_DEFAULT_MODE, CODEX_APPROVAL_POLICY, CODEX_APPROVALS_REVIEWER, CODEX_SANDBOX_MODE, CURSOR_APPROVAL_MODE, CURSOR_SANDBOX_MODE, DEFAULT_EXTRA_WRITABLE_ROOTS, GROK_AUTO_MODE_ENABLED, GROK_DEFAULT_AUTO_MODE, GROK_PERMISSION_MODE, } from './policy.mjs';
-import { HARNESS_IDS } from './types.mjs';
-function selected(options) {
-    return new Set(options?.harnesses ?? HARNESS_IDS);
-}
-function extraRoots(options) {
-    return options?.extraWritableRoots ?? DEFAULT_EXTRA_WRITABLE_ROOTS;
-}
-function wants(set, id) {
-    return set.has(id);
-}
-function codexPatches(roots) {
-    return {
-        format: 'toml',
-        patches: [
-            { key: 'approval_policy', table: '', value: CODEX_APPROVAL_POLICY },
-            { key: 'approvals_reviewer', table: '', value: CODEX_APPROVALS_REVIEWER },
-            { key: 'sandbox_mode', table: '', value: CODEX_SANDBOX_MODE },
-            { key: 'network_access', table: 'sandbox_workspace_write', value: true },
-            { key: 'writable_roots', table: 'sandbox_workspace_write', value: roots },
-        ],
-        path: '',
-    };
-}
-function grokSandboxPatches(roots) {
-    return {
-        format: 'toml',
-        patches: [
-            { key: 'extends', table: 'profiles.workspace-write', value: 'workspace' },
-            { key: 'read_write', table: 'profiles.workspace-write', value: roots },
-        ],
-        path: '',
-    };
-}
-function homeDir(options) {
-    return resolve(options?.home ?? homedir());
-}
-export function planGlobalFiles(options) {
-    const harnesses = selected(options);
-    const roots = extraRoots(options);
-    const home = homeDir(options);
-    const files = [];
-    if (wants(harnesses, 'claude')) {
-        files.push({
-            format: 'json',
-            patches: [
-                { path: ['permissions', 'defaultMode'], value: CLAUDE_DEFAULT_MODE },
-                { path: ['sandbox', 'enabled'], value: true },
-                { path: ['sandbox', 'failIfUnavailable'], value: true },
-                { merge: 'union', path: ['sandbox', 'filesystem', 'allowWrite'], value: roots },
-                { path: ['useAutoModeDuringPlan'], value: true },
-            ],
-            path: join(home, '.claude', 'settings.json'),
-        });
-    }
-    if (wants(harnesses, 'codex'))
-        files.push({ ...codexPatches(roots), path: join(home, '.codex', 'config.toml') });
-    if (wants(harnesses, 'grok')) {
-        files.push({ ...grokSandboxPatches(roots), path: join(home, '.grok', 'sandbox.toml') });
-        files.push({
-            format: 'toml',
-            patches: [
-                { key: 'permission_mode', table: 'ui', value: GROK_PERMISSION_MODE },
-                { key: 'enabled', table: 'auto_mode', value: GROK_AUTO_MODE_ENABLED },
-                { key: 'default_auto_mode', table: '', value: GROK_DEFAULT_AUTO_MODE },
-            ],
-            path: join(home, '.grok', 'config.toml'),
-        });
-    }
-    if (wants(harnesses, 'cursor')) {
-        files.push({
-            format: 'json',
-            patches: [
-                { path: ['approvalMode'], value: CURSOR_APPROVAL_MODE },
-                { path: ['sandbox', 'mode'], value: CURSOR_SANDBOX_MODE },
-            ],
-            path: join(home, '.cursor', 'cli-config.json'),
-        });
-    }
-    return files;
-}
-export function planRepoFiles(root, options) {
-    const harnesses = selected(options);
-    const roots = extraRoots(options);
-    const repo = resolve(root);
-    const files = [];
-    if (wants(harnesses, 'claude')) {
-        files.push({
-            format: 'json',
-            patches: [
-                { path: ['sandbox', 'enabled'], value: true },
-                { path: ['sandbox', 'failIfUnavailable'], value: true },
-                { merge: 'union', path: ['sandbox', 'filesystem', 'allowWrite'], value: roots },
-            ],
-            path: join(repo, '.claude', 'settings.json'),
-        });
-    }
-    if (wants(harnesses, 'codex'))
-        files.push({ ...codexPatches(roots), path: join(repo, '.codex', 'config.toml') });
-    if (wants(harnesses, 'grok'))
-        files.push({ ...grokSandboxPatches(roots), path: join(repo, '.grok', 'sandbox.toml') });
-    if (wants(harnesses, 'cursor')) {
-        files.push({
-            format: 'json',
-            patches: [
-                { path: ['type'], value: 'workspace_readwrite' },
-                { path: ['enableSharedBuildCache'], value: true },
-                { path: ['networkPolicy', 'default'], value: 'allow' },
-                { path: ['additionalReadwritePaths'], value: roots },
-            ],
-            path: join(repo, '.cursor', 'sandbox.json'),
-        });
-    }
-    return files;
-}

package/dist/agent-harness-config/policy.d.mts

@@ -1,14 +0,0 @@
-import type { HarnessPolicyDump } from './types.mts';
-export declare const DEFAULT_EXTRA_WRITABLE_ROOTS: readonly ['~/.cargo', '~/Library/pnpm', '~/.local/share/pnpm', '~/.pnpm-store', '~/Library/Caches/no-mistakes', '~/Library/Caches/pnpm', '~/.pnpm-state', '~/.cache/no-mistakes', '~/.cache/pnpm', '~/.local/state/pnpm', '/var/folders', '/private/var/folders'];
-export declare const CLAUDE_DEFAULT_MODE = "auto";
-export declare const CODEX_APPROVAL_POLICY = "on-request";
-export declare const CODEX_APPROVALS_REVIEWER = "auto_review";
-export declare const CODEX_SANDBOX_MODE = "workspace-write";
-export declare const GROK_PERMISSION_MODE = "auto";
-export declare const GROK_SANDBOX_PROFILE = "workspace-write";
-export declare const GROK_AUTO_MODE_ENABLED = true;
-export declare const GROK_DEFAULT_AUTO_MODE = true;
-export declare const CURSOR_APPROVAL_MODE = "auto-review";
-export declare const CURSOR_SANDBOX_MODE = "enabled";
-export declare function dumpHarnessPolicy(extraWritableRoots?: readonly string[]): HarnessPolicyDump;
-export declare function sameValue(left: unknown, right: unknown): boolean;

package/dist/agent-harness-config/policy.mjs

@@ -1,51 +0,0 @@
-export const DEFAULT_EXTRA_WRITABLE_ROOTS = [
-    '~/.cargo',
-    '~/Library/pnpm',
-    '~/.local/share/pnpm',
-    '~/.pnpm-store',
-    '~/Library/Caches/no-mistakes',
-    '~/Library/Caches/pnpm',
-    '~/.pnpm-state',
-    '~/.cache/no-mistakes',
-    '~/.cache/pnpm',
-    '~/.local/state/pnpm',
-    '/var/folders',
-    '/private/var/folders',
-];
-export const CLAUDE_DEFAULT_MODE = 'auto';
-export const CODEX_APPROVAL_POLICY = 'on-request';
-export const CODEX_APPROVALS_REVIEWER = 'auto_review';
-export const CODEX_SANDBOX_MODE = 'workspace-write';
-export const GROK_PERMISSION_MODE = 'auto';
-export const GROK_SANDBOX_PROFILE = 'workspace-write';
-export const GROK_AUTO_MODE_ENABLED = true;
-export const GROK_DEFAULT_AUTO_MODE = true;
-export const CURSOR_APPROVAL_MODE = 'auto-review';
-export const CURSOR_SANDBOX_MODE = 'enabled';
-export function dumpHarnessPolicy(extraWritableRoots = DEFAULT_EXTRA_WRITABLE_ROOTS) {
-    return {
-        claude: {
-            defaultMode: CLAUDE_DEFAULT_MODE,
-            sandboxEnabled: true,
-            sandboxFailIfUnavailable: true,
-            useAutoModeDuringPlan: true,
-        },
-        codex: {
-            approval_policy: CODEX_APPROVAL_POLICY,
-            approvals_reviewer: CODEX_APPROVALS_REVIEWER,
-            sandbox_mode: CODEX_SANDBOX_MODE,
-        },
-        cursor: { approvalMode: CURSOR_APPROVAL_MODE, sandboxMode: CURSOR_SANDBOX_MODE },
-        extraWritableRoots: [...extraWritableRoots],
-        grok: {
-            auto_mode_enabled: GROK_AUTO_MODE_ENABLED,
-            default_auto_mode: GROK_DEFAULT_AUTO_MODE,
-            permission_mode: GROK_PERMISSION_MODE,
-            sandbox_profile_defined: GROK_SANDBOX_PROFILE,
-            sandbox_profile_requires_cli_selection: true,
-        },
-    };
-}
-export function sameValue(left, right) {
-    return JSON.stringify(left) === JSON.stringify(right);
-}

package/dist/agent-harness-config/prerequisites.d.mts

@@ -1,2 +0,0 @@
-import type { HarnessConfigOptions, HarnessPrerequisite } from './types.mts';
-export declare function checkHarnessPrerequisites(root: string | undefined, options?: HarnessConfigOptions): Promise<HarnessPrerequisite[]>;

package/dist/agent-harness-config/prerequisites.mjs

@@ -1,67 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { join, resolve } from 'node:path';
-import { readTomlKey } from './merge-toml.mjs';
-import { CURSOR_APPROVAL_MODE } from './policy.mjs';
-import { HARNESS_IDS } from './types.mjs';
-async function readOptional(path) {
-    try {
-        return await readFile(path, 'utf8');
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            return '';
-        throw error;
-    }
-}
-function selected(options, harness) {
-    return (options?.harnesses ?? HARNESS_IDS).includes(harness);
-}
-function homeDir(options) {
-    return resolve(options?.home ?? homedir());
-}
-async function codexTrust(root, options) {
-    const source = await readOptional(join(homeDir(options), '.codex', 'config.toml'));
-    const table = `projects.${JSON.stringify(resolve(root))}`;
-    return {
-        harness: 'codex',
-        key: 'trusted-project',
-        message: 'trust this project in Codex before relying on its .codex/config.toml',
-        satisfied: readTomlKey(source, table, 'trust_level') === 'trusted',
-    };
-}
-async function cursorApproval(options) {
-    const source = await readOptional(join(homeDir(options), '.cursor', 'cli-config.json'));
-    let satisfied = false;
-    try {
-        const parsed = JSON.parse(source);
-        satisfied = parsed.approvalMode === CURSOR_APPROVAL_MODE;
-    }
-    catch {
-        // A missing or invalid user config leaves the prerequisite unsatisfied.
-    }
-    return {
-        harness: 'cursor',
-        key: 'global-auto-review',
-        message: 'set approvalMode=auto-review in ~/.cursor/cli-config.json',
-        satisfied,
-    };
-}
-function grokSandbox() {
-    return {
-        harness: 'grok',
-        key: 'sandbox-profile-selection',
-        message: 'start Grok with --sandbox workspace-write to activate the defined profile',
-        satisfied: false,
-    };
-}
-export async function checkHarnessPrerequisites(root, options) {
-    const prerequisites = [];
-    if (selected(options, 'grok'))
-        prerequisites.push(grokSandbox());
-    if (root !== undefined && selected(options, 'codex'))
-        prerequisites.push(await codexTrust(root, options));
-    if (root !== undefined && selected(options, 'cursor'))
-        prerequisites.push(await cursorApproval(options));
-    return prerequisites;
-}

package/dist/agent-harness-config/toml-value.d.mts

@@ -1,6 +0,0 @@
-import type { TomlValue } from './types.mts';
-export declare function formatTomlValue(value: TomlValue): string;
-export declare function parseTomlValue(text: string, start: number): {
-    end: number;
-    value: boolean | string | string[];
-};

package/dist/agent-harness-config/toml-value.mjs

@@ -1,69 +0,0 @@
-export function formatTomlValue(value) {
-    if (typeof value === 'boolean')
-        return value ? 'true' : 'false';
-    if (typeof value === 'string')
-        return JSON.stringify(value);
-    const items = value.map((entry) => `  ${JSON.stringify(entry)},`).join('\n');
-    return `[\n${items}\n]`;
-}
-function skipSpaceAndComments(text, start) {
-    let index = start;
-    while (index < text.length) {
-        const char = text[index];
-        if (char === ' ' || char === '\t' || char === '\n' || char === '\r' || char === ',') {
-            index += 1;
-            continue;
-        }
-        if (char === '#') {
-            while (index < text.length && text[index] !== '\n')
-                index += 1;
-            continue;
-        }
-        break;
-    }
-    return index;
-}
-function parseTomlString(text, start) {
-    const quote = text[start];
-    let index = start + 1;
-    let value = '';
-    while (index < text.length) {
-        const char = text[index];
-        if (char === quote)
-            return { end: index + 1, value };
-        if (quote === '"' && char === '\\') {
-            const next = text[index + 1];
-            if (next === undefined)
-                break;
-            value += next === 'n' ? '\n' : next === 't' ? '\t' : next;
-            index += 2;
-            continue;
-        }
-        value += char;
-        index += 1;
-    }
-    throw new Error('unterminated TOML string');
-}
-export function parseTomlValue(text, start) {
-    const index = skipSpaceAndComments(text, start);
-    if (text.startsWith('true', index))
-        return { end: index + 4, value: true };
-    if (text.startsWith('false', index))
-        return { end: index + 5, value: false };
-    if (text[index] === '"' || text[index] === "'")
-        return parseTomlString(text, index);
-    if (text[index] !== '[')
-        throw new Error('unsupported TOML value');
-    const items = [];
-    let cursor = index + 1;
-    for (;;) {
-        cursor = skipSpaceAndComments(text, cursor);
-        if (text[cursor] === ']')
-            return { end: cursor + 1, value: items };
-        if (text[cursor] !== '"' && text[cursor] !== "'")
-            throw new Error('unsupported TOML array value');
-        const parsed = parseTomlString(text, cursor);
-        items.push(parsed.value);
-        cursor = parsed.end;
-    }
-}