praxis-agent 0.6.0 → 0.8.0

package/dist/cli/tui/custom-themes.js

@@ -0,0 +1,284 @@
+import { constants } from 'node:fs';
+import { mkdir, open, readdir, readFile, rm } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { setTimeout } from 'node:timers/promises';
+import { writeFileAtomically } from '../../platform/atomic-write.js';
+import { ExclusiveFileLease, } from '../../platform/exclusive-file-lease.js';
+import { TUI_THEMES } from './theme.js';
+export const CUSTOM_THEME_TOKENS = [
+    'autoAccept',
+    'autoAcceptShimmer',
+    'background',
+    'bashBorder',
+    'bashMessageBackgroundColor',
+    'blue_FOR_SUBAGENTS_ONLY',
+    'briefLabelClaude',
+    'briefLabelYou',
+    'chromeYellow',
+    'claude',
+    'claudeBlueShimmer_FOR_SYSTEM_SPINNER',
+    'claudeBlue_FOR_SYSTEM_SPINNER',
+    'claudeShimmer',
+    'clawd_background',
+    'clawd_body',
+    'cyan_FOR_SUBAGENTS_ONLY',
+    'diffAdded',
+    'diffAddedDimmed',
+    'diffAddedWord',
+    'diffRemoved',
+    'diffRemovedDimmed',
+    'diffRemovedWord',
+    'error',
+    'fastMode',
+    'fastModeShimmer',
+    'green_FOR_SUBAGENTS_ONLY',
+    'ide',
+    'inactive',
+    'inactiveShimmer',
+    'inverseText',
+    'memoryBackgroundColor',
+    'merged',
+    'messageActionsBackground',
+    'orange_FOR_SUBAGENTS_ONLY',
+    'pink_FOR_SUBAGENTS_ONLY',
+    'planMode',
+    'professionalBlue',
+    'promptBorder',
+    'promptBorderShimmer',
+    'purple_FOR_SUBAGENTS_ONLY',
+    'rainbow_blue',
+    'rainbow_blue_shimmer',
+    'rainbow_green',
+    'rainbow_green_shimmer',
+    'rainbow_indigo',
+    'rainbow_indigo_shimmer',
+    'rainbow_orange',
+    'rainbow_orange_shimmer',
+    'rainbow_red',
+    'rainbow_red_shimmer',
+    'rainbow_violet',
+    'rainbow_violet_shimmer',
+    'rainbow_yellow',
+    'rainbow_yellow_shimmer',
+    'rate_limit_empty',
+    'rate_limit_fill',
+    'red_FOR_SUBAGENTS_ONLY',
+    'remember',
+    'selectionBg',
+    'success',
+    'subtle',
+    'suggestion',
+    'text',
+    'userMessageBackground',
+    'userMessageBackgroundHover',
+    'warning',
+    'warningShimmer',
+    'yellow_FOR_SUBAGENTS_ONLY',
+];
+const MAX_THEME_FILE_BYTES = 256 * 1024;
+const CUSTOM_NAME = /^[A-Za-z][A-Za-z0-9 _-]{0,63}$/u;
+const CUSTOM_SLUG = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
+const HEX = /^#[0-9a-f]{6}$/iu;
+const RGB = /^rgb\(\s*(?:\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\s*,\s*(?:\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\s*,\s*(?:\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\s*\)$/iu;
+const ANSI256 = /^ansi256\((?:[0-9]|[1-9]\d|1\d\d|2[0-4]\d)\)$/u;
+const ANSI = /^ansi:[A-Za-z][A-Za-z0-9]*$/u;
+function configRootPath() {
+    return process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), '.claude');
+}
+export function customThemeDirectory(configRoot = configRootPath()) {
+    return join(configRoot, 'themes');
+}
+function slugify(name) {
+    return name
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/gu, '-')
+        .replace(/^-+|-+$/gu, '');
+}
+export function validateCustomThemeName(name) {
+    const normalized = name.trim();
+    if (!CUSTOM_NAME.test(normalized)) {
+        throw new Error('Theme name must start with a letter and contain only letters, numbers, spaces, hyphens, or underscores (1–64 characters).');
+    }
+    const slug = slugify(normalized);
+    if (!CUSTOM_SLUG.test(slug))
+        throw new Error('Theme name must contain at least one ASCII letter or number.');
+    return slug;
+}
+function validateColor(value) {
+    const normalized = value.trim();
+    if (!HEX.test(normalized) &&
+        !RGB.test(normalized) &&
+        !ANSI256.test(normalized) &&
+        !ANSI.test(normalized)) {
+        throw new Error(`Invalid theme color ${JSON.stringify(value)}. Use rgb(r,g,b), #rrggbb, ansi256(n), or ansi:name.`);
+    }
+    return normalized;
+}
+function parseTheme(value, slug) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        throw new Error(`Invalid custom theme file: ${slug}.json`);
+    const record = value;
+    if (typeof record.name !== 'string' || !CUSTOM_NAME.test(record.name))
+        throw new Error(`Invalid custom theme name: ${slug}.json`);
+    if (!TUI_THEMES.includes(record.base) ||
+        record.base === 'auto')
+        throw new Error(`Invalid custom theme base: ${slug}.json`);
+    if (typeof record.overrides !== 'object' ||
+        record.overrides === null ||
+        Array.isArray(record.overrides))
+        throw new Error(`Invalid custom theme overrides: ${slug}.json`);
+    const overrides = {};
+    for (const [token, color] of Object.entries(record.overrides)) {
+        if (!CUSTOM_THEME_TOKENS.includes(token))
+            throw new Error(`Unknown custom theme token ${JSON.stringify(token)}.`);
+        if (typeof color !== 'string')
+            throw new Error(`Theme token ${token} must be a color string.`);
+        overrides[token] = validateColor(color);
+    }
+    const expectedSlug = slugify(record.name);
+    if (expectedSlug !== slug)
+        throw new Error(`Custom theme filename must match its name: ${slug}.json`);
+    return {
+        name: record.name,
+        slug,
+        base: record.base,
+        overrides,
+    };
+}
+async function readThemeFile(path, slug) {
+    const handle = await open(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+    try {
+        const info = await handle.stat();
+        if (info.size > MAX_THEME_FILE_BYTES)
+            throw new Error(`Custom theme exceeds ${MAX_THEME_FILE_BYTES} bytes: ${path}`);
+        return parseTheme(JSON.parse(await handle.readFile('utf8')), slug);
+    }
+    catch (error) {
+        if (error instanceof SyntaxError)
+            throw new Error(`Invalid JSON: ${path}`, { cause: error });
+        throw error;
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function acquireThemeLease(directory) {
+    const lease = new ExclusiveFileLease(join(directory, '.praxis-themes.lock'));
+    for (let attempt = 0; attempt < 400; attempt += 1) {
+        const handle = await lease.tryAcquire();
+        if (handle)
+            return handle;
+        await setTimeout(5);
+    }
+    throw new Error(`Custom theme write lock timed out: ${directory}`);
+}
+export async function loadTuiCustomThemes(configRoot = configRootPath()) {
+    const directory = customThemeDirectory(configRoot);
+    let entries;
+    try {
+        entries = await readdir(directory, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    }
+    const themes = [];
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith('.json'))
+            continue;
+        const slug = entry.name.slice(0, -'.json'.length);
+        if (!CUSTOM_SLUG.test(slug))
+            throw new Error(`Invalid custom theme filename: ${entry.name}`);
+        themes.push(await readThemeFile(join(directory, entry.name), slug));
+    }
+    return themes.sort((left, right) => left.name.localeCompare(right.name));
+}
+function serializedTheme(theme) {
+    return `${JSON.stringify({ name: theme.name, base: theme.base, overrides: theme.overrides }, null, 2)}\n`;
+}
+export async function createTuiCustomTheme({ name, base, configRoot = configRootPath(), }) {
+    const slug = validateCustomThemeName(name);
+    if (!TUI_THEMES.includes(base) ||
+        base === 'auto')
+        throw new Error(`Invalid custom theme base: ${base}`);
+    const directory = customThemeDirectory(configRoot);
+    await mkdir(directory, { recursive: true });
+    const handle = await acquireThemeLease(directory);
+    try {
+        const path = join(directory, `${slug}.json`);
+        try {
+            await readFile(path, 'utf8');
+            throw new Error(`A custom theme named ${JSON.stringify(name.trim())} already exists.`);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        const theme = {
+            name: name.trim(),
+            slug,
+            base,
+            overrides: {},
+        };
+        const committed = await writeFileAtomically(path, serializedTheme(theme), {
+            mode: 0o600,
+            beforeCommit: async () => {
+                try {
+                    await readFile(path, 'utf8');
+                    return false;
+                }
+                catch (error) {
+                    if (error.code === 'ENOENT')
+                        return true;
+                    throw error;
+                }
+            },
+        });
+        if (!committed)
+            throw new Error(`A custom theme named ${JSON.stringify(name.trim())} already exists.`);
+        return theme;
+    }
+    finally {
+        await handle.release();
+    }
+}
+export async function updateTuiCustomTheme(theme, token, value, configRoot = configRootPath()) {
+    const color = value === undefined ? undefined : validateColor(value);
+    const directory = customThemeDirectory(configRoot);
+    await mkdir(directory, { recursive: true });
+    const handle = await acquireThemeLease(directory);
+    try {
+        const path = join(directory, `${theme.slug}.json`);
+        const current = await readThemeFile(path, theme.slug);
+        const overrides = { ...current.overrides };
+        if (color === undefined)
+            delete overrides[token];
+        else
+            overrides[token] = color;
+        const next = { ...current, overrides };
+        if (!(await writeFileAtomically(path, serializedTheme(next))))
+            throw new Error(`Unable to update custom theme: ${path}`);
+        return next;
+    }
+    finally {
+        await handle.release();
+    }
+}
+export async function deleteTuiCustomTheme(theme, configRoot = configRootPath()) {
+    const directory = customThemeDirectory(configRoot);
+    const handle = await acquireThemeLease(directory);
+    try {
+        await rm(join(directory, `${theme.slug}.json`), { force: false });
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    finally {
+        await handle.release();
+    }
+}
+//# sourceMappingURL=custom-themes.js.map

package/dist/cli/tui/file-picker.d.ts

@@ -11,7 +11,9 @@ export type TuiMentionEntry = ({
 } & TuiFileEntry) | ({
     kind: 'agent';
 } & TuiAgentEntry);
-export declare function loadTuiFileEntries(cwd: string): Promise<readonly TuiFileEntry[]>;
+export declare function loadTuiFileEntries(cwd: string, options?: {
+    respectGitignore?: boolean;
+}): Promise<readonly TuiFileEntry[]>;
 export declare function filterTuiFileEntries(entries: readonly TuiFileEntry[], query: string): readonly TuiFileEntry[];
 export declare function filterTuiMentionEntries(files: readonly TuiFileEntry[], agents: readonly TuiAgentEntry[], query: string): readonly TuiMentionEntry[];
 export declare function fileReferenceAtCursor(input: string, cursor: number): {

package/dist/cli/tui/file-picker.js

@@ -1,10 +1,16 @@
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 const execFileAsync = promisify(execFile);
-export async function loadTuiFileEntries(cwd) {
+export async function loadTuiFileEntries(cwd, options = {}) {
     let stdout;
     try {
-        const result = await execFileAsync('rg', ['--files', '--hidden', '--glob', '!.git/**'], {
+        const result = await execFileAsync('rg', [
+            '--files',
+            '--hidden',
+            ...(options.respectGitignore === false ? ['--no-ignore'] : []),
+            '--glob',
+            '!.git/**',
+        ], {
             cwd,
             encoding: 'utf8',
             maxBuffer: 4 * 1024 * 1024,

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

@@ -0,0 +1,33 @@
+import type { ClaudeJsonResource } from '../../compatibility/claude/shared-resources.js';
+export interface TuiHookEventDefinition {
+    name: string;
+    description: string;
+    detail: readonly string[];
+}
+export interface TuiHookEntry {
+    type: string;
+    label: string;
+    scopeLabel: string;
+    path: string;
+}
+export interface TuiHookMatcher {
+    matcher: string;
+    scope: string;
+    scopeLabel: string;
+    hooks: readonly TuiHookEntry[];
+}
+export interface TuiHookEvent extends TuiHookEventDefinition {
+    matchers: readonly TuiHookMatcher[];
+}
+export interface TuiHookConfiguration {
+    events: readonly TuiHookEvent[];
+    hookCount: number;
+}
+export declare const TUI_HOOK_MENU: {
+    readonly title: "Hooks";
+    readonly readOnlyNotice: "This menu is read-only. To add or modify hooks, edit settings.json directly or ask Claude.";
+    readonly visibleRows: 5;
+};
+export declare const TUI_HOOK_EVENTS: readonly TuiHookEventDefinition[];
+export declare function projectTuiHooks(settings: readonly ClaudeJsonResource[]): TuiHookConfiguration;
+//# sourceMappingURL=hook-settings.d.ts.map

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

@@ -0,0 +1,200 @@
+export const TUI_HOOK_MENU = {
+    title: 'Hooks',
+    readOnlyNotice: 'This menu is read-only. To add or modify hooks, edit settings.json directly or ask Claude.',
+    visibleRows: 5,
+};
+export const TUI_HOOK_EVENTS = [
+    {
+        name: 'PreToolUse',
+        description: 'Before tool execution',
+        detail: [
+            'Input to command is JSON of tool call arguments.',
+            'Exit code 0 - stdout/stderr not shown',
+            'Exit code 2 - show stderr to model and block tool call',
+            'Other exit codes - show stderr to user only but continue with tool call',
+        ],
+    },
+    {
+        name: 'PostToolUse',
+        description: 'After tool execution',
+        detail: [
+            'Input to command is JSON with fields "inputs" (tool call arguments) and "response" (tool call response).',
+            'Exit code 0 - stdout shown in transcript mode (ctrl+o)',
+            'Exit code 2 - show stderr to model immediately',
+            'Other exit code - show stderr to user only',
+        ],
+    },
+    {
+        name: 'PostToolUseFailure',
+        description: 'After tool execution fails',
+        detail: [],
+    },
+    {
+        name: 'PostToolBatch',
+        description: 'After a batch of tool calls resolves',
+        detail: [],
+    },
+    {
+        name: 'PermissionDenied',
+        description: 'After auto mode classifier denies a tool call',
+        detail: [],
+    },
+    {
+        name: 'Notification',
+        description: 'When notifications are sent',
+        detail: [
+            'Input to command is JSON with notification message and type.',
+            'Exit code 0 - stdout/stderr not shown',
+            'Other exit codes - show stderr to user only',
+        ],
+    },
+    {
+        name: 'UserPromptSubmit',
+        description: 'When the user submits a prompt',
+        detail: [
+            'Input to command is JSON with original user prompt text.',
+            'Exit code 0 - stdout shown to Claude',
+            'Exit code 2 - block processing, erase original prompt, and show stderr to user only',
+            'Other exit codes - show stderr to user only',
+        ],
+    },
+    {
+        name: 'UserPromptExpansion',
+        description: 'After a user-typed slash command expands into a prompt',
+        detail: [],
+    },
+    {
+        name: 'SessionStart',
+        description: 'When a new session is started',
+        detail: [],
+    },
+    {
+        name: 'Stop',
+        description: 'Right before Claude concludes its response',
+        detail: [],
+    },
+    {
+        name: 'StopFailure',
+        description: 'When the turn ends due to an API error',
+        detail: [],
+    },
+    {
+        name: 'SubagentStart',
+        description: 'When a subagent (Agent tool call) is started',
+        detail: [],
+    },
+    {
+        name: 'SubagentStop',
+        description: 'Right before a subagent (Agent tool call) concludes its response',
+        detail: [],
+    },
+    {
+        name: 'PreCompact',
+        description: 'Before conversation compaction',
+        detail: [],
+    },
+    {
+        name: 'PostCompact',
+        description: 'After conversation compaction',
+        detail: [],
+    },
+    {
+        name: 'SessionEnd',
+        description: 'When a session is ending',
+        detail: [],
+    },
+    {
+        name: 'PermissionRequest',
+        description: 'When a permission dialog is displayed',
+        detail: [],
+    },
+];
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function scope(resource) {
+    if (resource.plugin)
+        return {
+            short: 'Plugin',
+            long: `Plugin Hooks (${resource.pluginSource ?? resource.pluginName ?? 'plugin'})`,
+        };
+    if (resource.scope === 'project')
+        return { short: 'Project', long: 'Project Settings' };
+    if (resource.scope === 'local')
+        return { short: 'Local', long: 'Local Settings' };
+    return { short: 'User', long: 'User Settings' };
+}
+function hookLabel(hook, type) {
+    const statusMessage = hook.statusMessage;
+    if (typeof statusMessage === 'string' && statusMessage.length > 0)
+        return statusMessage;
+    const field = type === 'command' ? 'command' : type === 'http' ? 'url' : 'prompt';
+    const label = hook[field];
+    if (typeof label === 'string' && label.length > 0)
+        return label;
+    return type;
+}
+const HOOK_SCOPE_ORDER = {
+    Local: 0,
+    Project: 1,
+    User: 2,
+    Plugin: 3,
+};
+export function projectTuiHooks(settings) {
+    let hookCount = 0;
+    const events = TUI_HOOK_EVENTS.map((definition) => {
+        const matchers = [];
+        for (const resource of settings) {
+            if (!isRecord(resource.value) || !isRecord(resource.value.hooks))
+                continue;
+            const configured = resource.value.hooks[definition.name];
+            if (!Array.isArray(configured))
+                continue;
+            for (const group of configured) {
+                if (!isRecord(group) || !Array.isArray(group.hooks))
+                    continue;
+                const labels = scope(resource);
+                const hooks = group.hooks.flatMap((hook) => {
+                    if (!isRecord(hook))
+                        return [];
+                    const type = typeof hook.type === 'string' && hook.type.length > 0
+                        ? hook.type
+                        : 'command';
+                    hookCount += 1;
+                    return [
+                        {
+                            type,
+                            label: hookLabel(hook, type),
+                            scopeLabel: labels.long,
+                            path: resource.path,
+                        },
+                    ];
+                });
+                if (hooks.length === 0)
+                    continue;
+                matchers.push({
+                    matcher: typeof group.matcher === 'string' && group.matcher.length > 0
+                        ? group.matcher
+                        : '(all)',
+                    scope: labels.short,
+                    scopeLabel: labels.long,
+                    hooks,
+                });
+            }
+        }
+        matchers.sort((left, right) => {
+            const scopeOrder = (HOOK_SCOPE_ORDER[left.scope] ?? Number.MAX_SAFE_INTEGER) -
+                (HOOK_SCOPE_ORDER[right.scope] ?? Number.MAX_SAFE_INTEGER);
+            if (scopeOrder !== 0)
+                return scopeOrder;
+            if (left.matcher === '(all)' && right.matcher !== '(all)')
+                return -1;
+            if (right.matcher === '(all)' && left.matcher !== '(all)')
+                return 1;
+            return left.matcher.localeCompare(right.matcher);
+        });
+        return { ...definition, matchers };
+    });
+    return { events, hookCount };
+}
+//# sourceMappingURL=hook-settings.js.map

package/dist/cli/tui/keybindings.js

@@ -143,7 +143,6 @@ const CLAUDE_2_1_208_KEYBINDINGS = {
             context: 'ThemePicker',
             bindings: {
                 'ctrl+t': 'theme:toggleSyntaxHighlighting',
-                'ctrl+e': 'theme:editCustom',
             },
         },
         {

package/dist/cli/tui/mcp-panel-controller.d.ts

@@ -0,0 +1,32 @@
+import type { ClaudeMcpManagement } from '../../mcp/claude-mcp-management.js';
+import type { ClaudeMcpRuntime } from '../../mcp/claude-mcp-tools.js';
+import { type TuiMcpPanelInput, type TuiMcpPanelCommand, type TuiMcpPanelModel, type TuiMcpPanelState } from './mcp-panel-projector.js';
+export type TuiMcpRuntimeController = ClaudeMcpRuntime;
+export interface TuiMcpSessionCommands {
+    mcpInspect(): ReturnType<ClaudeMcpRuntime['inspect']>;
+    mcpReconnect(name: string): ReturnType<ClaudeMcpRuntime['reconnect']>;
+    mcpAuthenticate(name: string): ReturnType<ClaudeMcpRuntime['authenticate']>;
+    mcpReload(): ReturnType<ClaudeMcpRuntime['reload']>;
+    mcpTools(name: string): ReturnType<ClaudeMcpRuntime['tools']>;
+}
+export declare function mcpRuntimeFromSession(commands: TuiMcpSessionCommands): TuiMcpRuntimeController;
+export interface TuiMcpPanelDispatchResult {
+    model: TuiMcpPanelModel;
+    state: TuiMcpPanelState;
+    closed: boolean;
+    error?: string;
+}
+export declare class McpPanelController {
+    private readonly cwd;
+    private readonly management;
+    private readonly runtime;
+    constructor(options: {
+        cwd: string;
+        management: Pick<ClaudeMcpManagement, 'list' | 'disabled' | 'setEnabled'>;
+        runtime: ClaudeMcpRuntime;
+    });
+    open(): Promise<TuiMcpPanelModel>;
+    execute(command: TuiMcpPanelCommand): Promise<TuiMcpPanelModel | null>;
+    dispatch(model: TuiMcpPanelModel, state: TuiMcpPanelState, input: TuiMcpPanelInput, onOperation?: (command: TuiMcpPanelCommand) => void): Promise<TuiMcpPanelDispatchResult>;
+}
+//# sourceMappingURL=mcp-panel-controller.d.ts.map

package/dist/cli/tui/mcp-panel-controller.js

@@ -0,0 +1,80 @@
+import { projectTuiMcpPanel, reduceTuiMcpPanelState, } from './mcp-panel-projector.js';
+export function mcpRuntimeFromSession(commands) {
+    return {
+        inspect: () => commands.mcpInspect(),
+        reconnect: (name) => commands.mcpReconnect(name),
+        authenticate: (name) => commands.mcpAuthenticate(name),
+        reload: () => commands.mcpReload(),
+        tools: (name) => commands.mcpTools(name),
+    };
+}
+export class McpPanelController {
+    cwd;
+    management;
+    runtime;
+    constructor(options) {
+        this.cwd = options.cwd;
+        this.management = options.management;
+        this.runtime = options.runtime;
+    }
+    async open() {
+        const [records, disabledNames, runtime] = await Promise.all([
+            this.management.list(),
+            this.management.disabled(),
+            this.runtime.inspect(),
+        ]);
+        return projectTuiMcpPanel({
+            cwd: this.cwd,
+            records,
+            disabledNames,
+            runtime,
+        });
+    }
+    async execute(command) {
+        if (command.type === 'close')
+            return null;
+        if (command.type === 'reconnect') {
+            await this.runtime.reconnect(command.name);
+            return this.open();
+        }
+        if (command.type === 'authenticate') {
+            await this.runtime.authenticate(command.name);
+            return this.open();
+        }
+        if (command.type === 'set-enabled') {
+            await this.management.setEnabled(command.name, command.scope, command.enabled);
+            await this.runtime.reload();
+            return this.open();
+        }
+        const tools = await this.runtime.tools(command.name);
+        const model = await this.open();
+        return {
+            ...model,
+            servers: model.servers.map((server) => server.name === command.name ? { ...server, tools } : server),
+        };
+    }
+    async dispatch(model, state, input, onOperation) {
+        const transition = reduceTuiMcpPanelState(model, state, input);
+        if (!transition.command) {
+            return { model, state: transition.state, closed: false };
+        }
+        onOperation?.(transition.command);
+        try {
+            const next = await this.execute(transition.command);
+            return {
+                model: next ?? model,
+                state: transition.state,
+                closed: next === null,
+            };
+        }
+        catch (error) {
+            return {
+                model,
+                state,
+                closed: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+}
+//# sourceMappingURL=mcp-panel-controller.js.map