praxis-agent 0.9.0 → 0.11.0

package/dist/cli/tui/mcp-elicitation.js

@@ -0,0 +1,497 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+function record(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function finite(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function stringValue(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function options(schema) {
+    const titledOptions = Array.isArray(schema.oneOf)
+        ? schema.oneOf
+        : Array.isArray(schema.anyOf)
+            ? schema.anyOf
+            : undefined;
+    if (titledOptions) {
+        return titledOptions.flatMap((candidate) => {
+            if (!record(candidate) || typeof candidate.const !== 'string')
+                return [];
+            return [
+                {
+                    value: candidate.const,
+                    label: typeof candidate.title === 'string'
+                        ? candidate.title
+                        : candidate.const,
+                },
+            ];
+        });
+    }
+    const enumValues = Array.isArray(schema.enum)
+        ? schema.enum.filter((value) => typeof value === 'string')
+        : [];
+    const enumNames = Array.isArray(schema.enumNames)
+        ? schema.enumNames.filter((value) => typeof value === 'string')
+        : [];
+    return enumValues.map((value, index) => ({
+        value,
+        label: enumNames[index] ?? value,
+    }));
+}
+function fieldKind(schema) {
+    if (schema.type === 'array' && record(schema.items)) {
+        return options(schema.items).length > 0 ? 'multi-enum' : null;
+    }
+    if (options(schema).length > 0)
+        return 'enum';
+    if (schema.type === 'string')
+        return 'text';
+    if (schema.type === 'number')
+        return 'number';
+    if (schema.type === 'integer')
+        return 'integer';
+    if (schema.type === 'boolean')
+        return 'boolean';
+    return null;
+}
+function validDefault(field, value) {
+    if (field.kind === 'boolean')
+        return typeof value === 'boolean' ? value : undefined;
+    if (field.kind === 'number' || field.kind === 'integer')
+        return typeof value === 'number' && Number.isFinite(value)
+            ? value
+            : undefined;
+    if (field.kind === 'multi-enum') {
+        if (!Array.isArray(value))
+            return undefined;
+        const allowed = new Set(field.options.map((option) => option.value));
+        const selected = value.filter((item) => typeof item === 'string' && allowed.has(item));
+        return selected;
+    }
+    return typeof value === 'string' ? value : undefined;
+}
+export function createTuiElicitationForm(requestedSchema) {
+    const properties = record(requestedSchema?.properties)
+        ? requestedSchema.properties
+        : {};
+    const required = new Set(Array.isArray(requestedSchema?.required)
+        ? requestedSchema.required.filter((value) => typeof value === 'string')
+        : []);
+    const fields = Object.entries(properties).flatMap(([name, value]) => {
+        if (!record(value))
+            return [];
+        const schema = value;
+        const kind = fieldKind(schema);
+        if (!kind)
+            return [];
+        const optionSchema = kind === 'multi-enum' && record(schema.items)
+            ? schema.items
+            : schema;
+        return [
+            {
+                name,
+                title: stringValue(schema.title) ?? name,
+                description: stringValue(schema.description),
+                required: required.has(name),
+                schema,
+                kind,
+                options: options(optionSchema),
+            },
+        ];
+    });
+    const values = {};
+    const errors = {};
+    for (const field of fields) {
+        const value = validDefault(field, field.schema.default);
+        if (value !== undefined) {
+            values[field.name] = value;
+            if (['text', 'number', 'integer'].includes(field.kind)) {
+                const error = validateText(field, String(value)).error;
+                if (error)
+                    errors[field.name] = error;
+            }
+        }
+    }
+    return {
+        fields,
+        values,
+        errors,
+        focusIndex: fields.length > 0 ? 0 : fields.length,
+        expandedField: undefined,
+        optionIndex: 0,
+        typeahead: '',
+        typeaheadAt: 0,
+    };
+}
+export function focusedElicitationField(state) {
+    return state.fields[state.focusIndex];
+}
+export function elicitationTextValue(state) {
+    const field = focusedElicitationField(state);
+    if (!field || !['text', 'number', 'integer'].includes(field.kind))
+        return '';
+    const value = state.values[field.name];
+    return value === undefined ? '' : String(value);
+}
+function withError(state, name, error) {
+    const errors = { ...state.errors };
+    if (error)
+        errors[name] = error;
+    else
+        delete errors[name];
+    return { ...state, errors };
+}
+function validateText(field, raw) {
+    const text = raw.trim();
+    if (!text) {
+        if (field.required)
+            return { error: 'This field is required' };
+        return {};
+    }
+    if (field.kind === 'number' || field.kind === 'integer') {
+        const value = Number(text);
+        if (!Number.isFinite(value))
+            return { value: raw, error: 'Enter a valid number' };
+        if (field.kind === 'integer' && !Number.isInteger(value))
+            return { value: raw, error: 'Enter a whole number' };
+        const minimum = finite(field.schema.minimum);
+        const maximum = finite(field.schema.maximum);
+        const exclusiveMinimum = finite(field.schema.exclusiveMinimum);
+        const exclusiveMaximum = finite(field.schema.exclusiveMaximum);
+        if (minimum !== undefined && value < minimum)
+            return { value, error: `Must be at least ${minimum}` };
+        if (maximum !== undefined && value > maximum)
+            return { value, error: `Must be at most ${maximum}` };
+        if (exclusiveMinimum !== undefined && value <= exclusiveMinimum)
+            return { value, error: `Must be greater than ${exclusiveMinimum}` };
+        if (exclusiveMaximum !== undefined && value >= exclusiveMaximum)
+            return { value, error: `Must be less than ${exclusiveMaximum}` };
+        return { value };
+    }
+    const minLength = finite(field.schema.minLength);
+    const maxLength = finite(field.schema.maxLength);
+    if (minLength !== undefined && raw.length < minLength)
+        return { value: raw, error: `Must be at least ${minLength} characters` };
+    if (maxLength !== undefined && raw.length > maxLength)
+        return { value: raw, error: `Must be at most ${maxLength} characters` };
+    const pattern = stringValue(field.schema.pattern);
+    if (pattern) {
+        try {
+            if (!new RegExp(pattern, 'u').test(raw))
+                return { value: raw, error: 'Does not match the required format' };
+        }
+        catch {
+            return { value: raw, error: 'Invalid schema pattern' };
+        }
+    }
+    const format = stringValue(field.schema.format);
+    if (format === 'email' && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/u.test(text))
+        return {
+            value: raw,
+            error: 'Must be a valid email address, e.g. user@example.com',
+        };
+    if (format === 'uri') {
+        try {
+            new URL(text);
+        }
+        catch {
+            return {
+                value: raw,
+                error: 'Must be a valid URI, e.g. https://example.com',
+            };
+        }
+    }
+    if (format === 'date' && !validIsoDate(text))
+        return { value: raw, error: 'Enter a date as YYYY-MM-DD' };
+    if (format === 'date-time' &&
+        (!/^\d{4}-\d{2}-\d{2}T/u.test(text) || Number.isNaN(Date.parse(text))))
+        return { value: raw, error: 'Enter a valid date and time' };
+    return { value: raw };
+}
+function validIsoDate(value) {
+    const match = /^(\d{4})-(\d{2})-(\d{2})$/u.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 commitElicitationText(state, raw) {
+    const field = focusedElicitationField(state);
+    if (!field || !['text', 'number', 'integer'].includes(field.kind))
+        return state;
+    const preserveEmptyString = field.kind === 'text' &&
+        field.schema.format === undefined &&
+        raw.trim() === '' &&
+        state.values[field.name] !== undefined;
+    const validation = preserveEmptyString
+        ? { value: '' }
+        : validateText(field, raw);
+    const values = { ...state.values };
+    if (validation.value === undefined)
+        delete values[field.name];
+    else
+        values[field.name] = validation.value;
+    return withError({ ...state, values }, field.name, validation.error);
+}
+export function moveElicitationFocus(state, direction) {
+    const count = state.fields.length + 2;
+    return {
+        ...state,
+        focusIndex: (state.focusIndex + count + direction) % count,
+        expandedField: undefined,
+        optionIndex: 0,
+        typeahead: '',
+    };
+}
+export function unsetElicitationField(state) {
+    const field = focusedElicitationField(state);
+    if (!field)
+        return state;
+    const values = { ...state.values };
+    const errors = { ...state.errors };
+    delete values[field.name];
+    delete errors[field.name];
+    return { ...state, values, errors };
+}
+export function toggleElicitationBoolean(state) {
+    const field = focusedElicitationField(state);
+    if (!field || field.kind !== 'boolean')
+        return state;
+    return withError({
+        ...state,
+        values: {
+            ...state.values,
+            [field.name]: state.values[field.name] !== true,
+        },
+    }, field.name);
+}
+export function expandElicitationOptions(state) {
+    const field = focusedElicitationField(state);
+    if (!field || !['enum', 'multi-enum'].includes(field.kind))
+        return state;
+    const current = state.values[field.name];
+    const optionIndex = field.kind === 'enum' && typeof current === 'string'
+        ? Math.max(0, field.options.findIndex((option) => option.value === current))
+        : 0;
+    return { ...state, expandedField: field.name, optionIndex };
+}
+export function moveElicitationOption(state, direction) {
+    const field = focusedElicitationField(state);
+    if (!field ||
+        state.expandedField !== field.name ||
+        field.options.length === 0)
+        return state;
+    const nextIndex = state.optionIndex + direction;
+    if (nextIndex < 0)
+        return validateSelectedField({ ...state, expandedField: undefined }, field);
+    if (nextIndex >= field.options.length) {
+        return moveElicitationFocus(validateSelectedField({ ...state, expandedField: undefined }, field), 1);
+    }
+    return {
+        ...state,
+        optionIndex: nextIndex,
+    };
+}
+export function selectElicitationOption(state, collapse, ensureSelected = false) {
+    const field = focusedElicitationField(state);
+    const option = field?.options[state.optionIndex];
+    if (!field || !option || state.expandedField !== field.name)
+        return state;
+    if (field.kind === 'multi-enum') {
+        const selected = Array.isArray(state.values[field.name])
+            ? state.values[field.name]
+            : [];
+        const next = selected.includes(option.value) && !ensureSelected
+            ? selected.filter((value) => value !== option.value)
+            : selected.includes(option.value)
+                ? selected
+                : [...selected, option.value];
+        const values = { ...state.values };
+        if (next.length > 0)
+            values[field.name] = next;
+        else
+            delete values[field.name];
+        return validateSelectedField({
+            ...state,
+            values,
+            ...(collapse ? { expandedField: undefined } : {}),
+        }, field);
+    }
+    return withError({
+        ...state,
+        values: { ...state.values, [field.name]: option.value },
+        ...(collapse ? { expandedField: undefined } : {}),
+    }, field.name);
+}
+function validateSelectedField(state, field) {
+    if (field.kind !== 'multi-enum')
+        return state;
+    const value = state.values[field.name];
+    const selected = Array.isArray(value) ? value : [];
+    const minItems = finite(field.schema.minItems);
+    const maxItems = finite(field.schema.maxItems);
+    let error;
+    if (field.required && selected.length === 0) {
+        error = 'This field is required';
+    }
+    else if (minItems !== undefined &&
+        selected.length < minItems &&
+        (selected.length > 0 || field.required)) {
+        error = `Select at least ${minItems} item${minItems === 1 ? '' : 's'}`;
+    }
+    else if (maxItems !== undefined && selected.length > maxItems) {
+        error = `Select at most ${maxItems} item${maxItems === 1 ? '' : 's'}`;
+    }
+    return withError(state, field.name, error);
+}
+export function typeaheadElicitationOption(state, input, now = Date.now()) {
+    const field = focusedElicitationField(state);
+    if (!field || !['enum', 'multi-enum'].includes(field.kind))
+        return state;
+    const buffer = `${now - state.typeaheadAt > 2_000 ? '' : state.typeahead}${input}`.toLowerCase();
+    const optionIndex = field.options.findIndex((option) => option.label.toLowerCase().startsWith(buffer));
+    return {
+        ...state,
+        expandedField: field.name,
+        typeahead: buffer,
+        typeaheadAt: now,
+        ...(optionIndex < 0 ? {} : { optionIndex }),
+    };
+}
+export function validateTuiElicitationForm(state) {
+    let next = state;
+    for (const field of state.fields) {
+        const value = next.values[field.name];
+        let error = ['text', 'number', 'integer'].includes(field.kind)
+            ? next.errors[field.name]
+            : undefined;
+        if (field.required &&
+            (value === undefined ||
+                value === '' ||
+                (Array.isArray(value) && value.length === 0))) {
+            error = 'This field is required';
+        }
+        if (field.kind === 'multi-enum' && Array.isArray(value)) {
+            const minItems = finite(field.schema.minItems);
+            const maxItems = finite(field.schema.maxItems);
+            if (minItems !== undefined && value.length < minItems)
+                error = `Select at least ${minItems} item${minItems === 1 ? '' : 's'}`;
+            else if (maxItems !== undefined && value.length > maxItems)
+                error = `Select at most ${maxItems} item${maxItems === 1 ? '' : 's'}`;
+        }
+        next = withError(next, field.name, error);
+    }
+    const firstInvalid = next.fields.findIndex((field) => next.errors[field.name]);
+    return firstInvalid < 0 ? next : { ...next, focusIndex: firstInvalid };
+}
+export function elicitationFormIsValid(state) {
+    return (Object.keys(state.errors).length === 0 &&
+        state.fields.every((field) => {
+            if (!field.required)
+                return true;
+            const value = state.values[field.name];
+            return (value !== undefined &&
+                value !== '' &&
+                (!Array.isArray(value) || value.length > 0));
+        }));
+}
+function displayValue(field, value) {
+    if (value === undefined)
+        return 'not set';
+    if (Array.isArray(value))
+        return value
+            .map((item) => field.options.find((option) => option.value === item)?.label ?? item)
+            .join(', ');
+    if (typeof value === 'boolean')
+        return value ? '☒' : '☐';
+    if (field.kind === 'enum')
+        return (field.options.find((option) => option.value === value)?.label ??
+            String(value));
+    if (field.schema.format === 'date') {
+        const parts = String(value).split('-');
+        if (parts.length === 3) {
+            const date = new Date(Number(parts[0]), Number(parts[1]) - 1, Number(parts[2]));
+            if (!Number.isNaN(date.getTime()))
+                return date.toLocaleDateString('en-US', {
+                    weekday: 'short',
+                    year: 'numeric',
+                    month: 'short',
+                    day: 'numeric',
+                });
+        }
+    }
+    if (field.schema.format === 'date-time') {
+        const date = new Date(String(value));
+        if (!Number.isNaN(date.getTime()))
+            return date.toLocaleString('en-US');
+    }
+    return String(value);
+}
+export function McpElicitationUrl({ serverName, message, url, waiting, actionLabel, selection, screenReader, }) {
+    const title = waiting
+        ? `MCP server “${serverName}” — waiting for completion`
+        : `MCP server “${serverName}” wants to open a URL`;
+    let beforeDomain = '';
+    let domain = url;
+    let afterDomain = '';
+    try {
+        const parsed = new URL(url);
+        const start = url.indexOf(parsed.hostname);
+        if (start >= 0) {
+            beforeDomain = url.slice(0, start);
+            domain = parsed.hostname;
+            afterDomain = url.slice(start + parsed.hostname.length);
+        }
+    }
+    catch {
+        // Render malformed server input verbatim; the opener remains user-gated.
+    }
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: screenReader ? undefined : 'round', borderColor: "yellow", paddingX: screenReader ? 0 : 1, marginTop: 1, children: [_jsx(Text, { bold: true, children: title }), _jsx(Text, { children: message }), _jsx(Text, { children: " " }), _jsxs(Text, { children: [beforeDomain, _jsx(Text, { bold: true, children: domain }), afterDomain] }), waiting ? (_jsxs(_Fragment, { children: [_jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, italic: true, children: "Waiting for the server to confirm completion\u2026" }), _jsxs(Text, { children: [selection === 0 ? '›' : ' ', ' ', _jsx(Text, { bold: selection === 0, children: "Reopen URL" }), '  ', selection === 1 ? '›' : ' ', ' ', _jsx(Text, { bold: selection === 1, children: actionLabel })] })] })) : (_jsxs(Text, { children: [selection === 0 ? '›' : ' ', ' ', _jsx(Text, { bold: selection === 0, children: "Accept" }), '  ', selection === 1 ? '›' : ' ', ' ', _jsx(Text, { bold: selection === 1, children: "Decline" })] })), _jsx(Text, { dimColor: true, children: "Esc cancel \u00B7 \u2190\u2192 switch" })] }));
+}
+export function McpElicitationForm({ serverName, message, state, input, screenReader, }) {
+    const field = focusedElicitationField(state);
+    const maxVisibleFields = Math.max(2, Math.floor(((process.stdout.rows ?? 24) - 14) / 3));
+    const focusForWindow = Math.min(state.focusIndex, Math.max(0, state.fields.length - 1));
+    let windowStart = Math.max(0, focusForWindow - Math.floor(maxVisibleFields / 2));
+    const windowEnd = Math.min(state.fields.length, windowStart + maxVisibleFields);
+    windowStart = Math.max(0, windowEnd - maxVisibleFields);
+    const visibleFields = state.fields.slice(windowStart, windowEnd);
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: screenReader ? undefined : 'round', borderColor: "yellow", paddingX: screenReader ? 0 : 1, marginTop: 1, children: [_jsxs(Text, { bold: true, children: ["MCP server \u201C", serverName, "\u201D requests your input"] }), _jsx(Text, { children: message }), _jsx(Text, { children: " " }), windowStart > 0 ? (_jsxs(Text, { dimColor: true, children: [" \u2191 ", windowStart, " more above"] })) : null, visibleFields.map((candidate, visibleIndex) => {
+                const index = windowStart + visibleIndex;
+                const active = index === state.focusIndex;
+                const value = state.values[candidate.name];
+                const expanded = state.expandedField === candidate.name;
+                return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { bold: active, ...(state.errors[candidate.name]
+                                ? { color: 'red' }
+                                : active
+                                    ? { color: 'yellow' }
+                                    : {}), children: [active ? '›' : ' ', ' ', value !== undefined ? '✓' : candidate.required ? '*' : ' ', ' ', candidate.title, ":", ' ', active && ['text', 'number', 'integer'].includes(candidate.kind)
+                                    ? input || 'Type something…'
+                                    : displayValue(candidate, value)] }), expanded
+                            ? candidate.options.map((option, optionIndex) => {
+                                const selected = Array.isArray(value)
+                                    ? value.includes(option.value)
+                                    : value === option.value;
+                                return (_jsxs(Text, { children: ['    ', optionIndex === state.optionIndex ? '›' : ' ', ' ', candidate.kind === 'multi-enum'
+                                            ? selected
+                                                ? '☒'
+                                                : '☐'
+                                            : selected
+                                                ? '◉'
+                                                : '○', ' ', option.label] }, option.value));
+                            })
+                            : null, candidate.description ? (_jsxs(Text, { dimColor: true, children: [" ", candidate.description] })) : null, state.errors[candidate.name] ? (_jsxs(Text, { color: "red", children: [" ", state.errors[candidate.name]] })) : null] }, candidate.name));
+            }), windowEnd < state.fields.length ? (_jsxs(Text, { dimColor: true, children: ['  ', "\u2193 ", state.fields.length - windowEnd, " more below"] })) : null, _jsxs(Text, { bold: state.focusIndex === state.fields.length, children: [state.focusIndex === state.fields.length ? '›' : ' ', " Accept"] }), _jsxs(Text, { bold: state.focusIndex === state.fields.length + 1, children: [state.focusIndex === state.fields.length + 1 ? '›' : ' ', " Decline"] }), _jsxs(Text, { dimColor: true, children: ["Esc cancel \u00B7 \u2191\u2193 navigate", field?.kind === 'boolean' ? ' · Space toggle' : '', field && ['enum', 'multi-enum'].includes(field.kind)
+                        ? state.expandedField
+                            ? ' · Space select'
+                            : ' · → expand'
+                        : ''] })] }));
+}
+//# sourceMappingURL=mcp-elicitation.js.map

package/dist/cli/tui/open-url.d.ts

@@ -0,0 +1,2 @@
+export declare function openTuiUrl(url: string): Promise<void>;
+//# sourceMappingURL=open-url.d.ts.map

package/dist/cli/tui/open-url.js

@@ -0,0 +1,13 @@
+import { execFile } from 'node:child_process';
+export async function openTuiUrl(url) {
+    const command = process.platform === 'darwin'
+        ? 'open'
+        : process.platform === 'win32'
+            ? 'cmd'
+            : 'xdg-open';
+    const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];
+    await new Promise((resolvePromise) => {
+        execFile(command, args, { timeout: 10_000 }, () => resolvePromise());
+    });
+}
+//# sourceMappingURL=open-url.js.map

package/dist/cli/tui/permission-settings.d.ts

@@ -1,4 +1,5 @@
 import { type ClaudeResourceScope } from '../../compatibility/claude/shared-resources.js';
+import type { PermissionUpdate } from '../../core/runtime.js';
 export type TuiPermissionBehavior = 'allow' | 'ask' | 'deny';
 export interface TuiPermissionRule {
     behavior: TuiPermissionBehavior;
@@ -15,4 +16,9 @@ export declare function addTuiPermissionRule({ cwd, behavior, rule, scope, confi
     configRoot?: string;
 }): Promise<void>;
 export declare function removeTuiPermissionRule(rule: TuiPermissionRule): Promise<void>;
+export declare function persistTuiPermissionUpdates({ cwd, updates, configRoot, }: {
+    cwd: string;
+    updates: readonly PermissionUpdate[];
+    configRoot?: string;
+}): Promise<void>;
 //# sourceMappingURL=permission-settings.d.ts.map

package/dist/cli/tui/permission-settings.js

@@ -3,6 +3,7 @@ import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { loadClaudeSettings, } from '../../compatibility/claude/shared-resources.js';
 import { writeFileAtomically } from '../../platform/atomic-write.js';
+import { permissionRuleValueFromString, permissionRuleValueToString, } from '../../permissions/permission-updates.js';
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -106,4 +107,87 @@ export async function removeTuiPermissionRule(rule) {
     }
     throw new Error(`Settings changed concurrently: ${rule.path}`);
 }
+function destinationScope(destination) {
+    return destination === 'userSettings'
+        ? 'user'
+        : destination === 'projectSettings'
+            ? 'project'
+            : destination === 'localSettings'
+                ? 'local'
+                : undefined;
+}
+export async function persistTuiPermissionUpdates({ cwd, updates, configRoot = configRootPath(), }) {
+    for (const update of updates) {
+        const scope = destinationScope(update.destination);
+        if (!scope)
+            continue;
+        if (update.type === 'addRules') {
+            for (const rule of update.rules) {
+                await addTuiPermissionRule({
+                    cwd,
+                    behavior: update.behavior,
+                    rule: permissionRuleValueToString(rule),
+                    scope,
+                    configRoot,
+                });
+            }
+            continue;
+        }
+        const path = settingsPath(configRoot, cwd, scope);
+        for (let attempt = 0; attempt < 3; attempt += 1) {
+            const { value: settings, source } = await readSettings(path);
+            const permissions = isRecord(settings.permissions)
+                ? { ...settings.permissions }
+                : {};
+            if (update.type === 'setMode') {
+                permissions.defaultMode = update.mode;
+            }
+            else if (update.type === 'addDirectories' ||
+                update.type === 'removeDirectories') {
+                const existing = permissions.additionalDirectories;
+                if (existing !== undefined && !Array.isArray(existing)) {
+                    throw new Error(`permissions.additionalDirectories must be an array: ${path}`);
+                }
+                const directories = Array.isArray(existing)
+                    ? existing.filter((directory) => typeof directory === 'string')
+                    : [];
+                const changed = new Set(directories);
+                for (const directory of update.directories) {
+                    if (update.type === 'addDirectories')
+                        changed.add(directory);
+                    else
+                        changed.delete(directory);
+                }
+                permissions.additionalDirectories = [...changed];
+            }
+            else if (update.type === 'replaceRules' ||
+                update.type === 'removeRules') {
+                const existing = permissions[update.behavior];
+                if (existing !== undefined && !Array.isArray(existing)) {
+                    throw new Error(`permissions.${update.behavior} must be an array: ${path}`);
+                }
+                const rules = Array.isArray(existing)
+                    ? existing.filter((rule) => typeof rule === 'string')
+                    : [];
+                const changed = update.rules.map(permissionRuleValueToString);
+                if (update.type === 'replaceRules') {
+                    permissions[update.behavior] = changed;
+                }
+                else {
+                    const removed = new Set(changed);
+                    permissions[update.behavior] = rules.filter((rule) => !removed.has(permissionRuleValueToString(permissionRuleValueFromString(rule))));
+                }
+            }
+            else {
+                const unreachable = update;
+                throw new Error(`Unsupported permission update: ${JSON.stringify(unreachable)}`);
+            }
+            const committed = await writeFileAtomically(path, `${JSON.stringify({ ...settings, permissions }, null, 2)}\n`, { beforeCommit: () => sourceUnchanged(path, source) });
+            if (committed)
+                break;
+            if (attempt === 2)
+                throw new Error(`Settings changed concurrently: ${path}`);
+        }
+    }
+}
 //# sourceMappingURL=permission-settings.js.map

package/dist/cli/tui/runtime-interactions.d.ts

@@ -1,9 +1,11 @@
 import type { TranscriptItem } from './claude-style.js';
 import type { PraxisRuntimeSettings } from './runtime-settings.js';
 export type CopyCandidate = {
+    kind: 'full' | 'code' | 'always';
     label: string;
     description: string;
     text: string;
+    filename: string;
 };
 export declare function spinnerTip(settings: Pick<PraxisRuntimeSettings, 'tips'>): string | undefined;
 export declare function questionTimeoutMilliseconds(value: PraxisRuntimeSettings['askUserQuestionTimeout']): number | undefined;