ccmanager 2.11.5 → 3.0.0

package/dist/components/Configuration.js

@@ -6,6 +6,7 @@ import ConfigureStatusHooks from './ConfigureStatusHooks.js';
 import ConfigureWorktreeHooks from './ConfigureWorktreeHooks.js';
 import ConfigureWorktree from './ConfigureWorktree.js';
 import ConfigureCommand from './ConfigureCommand.js';
+import ConfigureOther from './ConfigureOther.js';
 import { shortcutManager } from '../services/shortcutManager.js';
 const Configuration = ({ onComplete }) => {
     const [view, setView] = useState('menu');
@@ -30,6 +31,10 @@ const Configuration = ({ onComplete }) => {
             label: 'C 🚀  Configure Command Presets',
             value: 'presets',
         },
+        {
+            label: 'O 🧪  Other & Experimental',
+            value: 'other',
+        },
         {
             label: 'B ← Back to Main Menu',
             value: 'back',
@@ -54,6 +59,9 @@ const Configuration = ({ onComplete }) => {
         else if (item.value === 'presets') {
             setView('presets');
         }
+        else if (item.value === 'other') {
+            setView('other');
+        }
     };
     const handleSubMenuComplete = () => {
         setView('menu');
@@ -79,6 +87,9 @@ const Configuration = ({ onComplete }) => {
             case 'c':
                 setView('presets');
                 break;
+            case 'o':
+                setView('other');
+                break;
             case 'b':
                 onComplete();
                 break;
@@ -103,6 +114,9 @@ const Configuration = ({ onComplete }) => {
     if (view === 'presets') {
         return React.createElement(ConfigureCommand, { onComplete: handleSubMenuComplete });
     }
+    if (view === 'other') {
+        return React.createElement(ConfigureOther, { onComplete: handleSubMenuComplete });
+    }
     return (React.createElement(Box, { flexDirection: "column" },
         React.createElement(Box, { marginBottom: 1 },
             React.createElement(Text, { bold: true, color: "green" }, "Configuration")),

package/dist/components/ConfigureCustomCommand.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+interface ConfigureCustomCommandProps {
+    value: string;
+    onChange: (value: string) => void;
+    onSubmit: (value: string) => void;
+    onCancel: () => void;
+}
+declare const ConfigureCustomCommand: React.FC<ConfigureCustomCommandProps>;
+export default ConfigureCustomCommand;

package/dist/components/ConfigureCustomCommand.js

@@ -0,0 +1,44 @@
+import React from 'react';
+import { Box, Text, useInput } from 'ink';
+import TextInputWrapper from './TextInputWrapper.js';
+import { shortcutManager } from '../services/shortcutManager.js';
+const ConfigureCustomCommand = ({ value, onChange, onSubmit, onCancel, }) => {
+    const shouldIgnoreNextChange = React.useRef(false);
+    const handleChange = (newValue) => {
+        if (shouldIgnoreNextChange.current) {
+            shouldIgnoreNextChange.current = false;
+            return;
+        }
+        onChange(newValue);
+    };
+    useInput((input, key) => {
+        if (shortcutManager.matchesShortcut('cancel', input, key)) {
+            onCancel();
+            return;
+        }
+        // Ctrl+K clears the current input
+        if (key.ctrl && input.toLowerCase() === 'k') {
+            // Ignore the TextInput change event that will fire for the same key
+            shouldIgnoreNextChange.current = true;
+            onChange('');
+        }
+    });
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { bold: true, color: "green" }, "Custom Auto-Approval Command")),
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, null,
+                "Enter the command that returns ",
+                '{needsPermission:boolean}',
+                " JSON:")),
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(TextInputWrapper, { value: value, onChange: handleChange, onSubmit: () => onSubmit(value), placeholder: `e.g. jq -n '{"needsPermission":true}'`, focus: true })),
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { dimColor: true }, "Env provided: $DEFAULT_PROMPT, $TERMINAL_OUTPUT")),
+        React.createElement(Box, null,
+            React.createElement(Text, { dimColor: true },
+                "Press Enter to save, ",
+                shortcutManager.getShortcutDisplay('cancel'),
+                " to go back, Ctrl+K to clear input"))));
+};
+export default ConfigureCustomCommand;

package/dist/components/ConfigureOther.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface ConfigureOtherProps {
+    onComplete: () => void;
+}
+declare const ConfigureOther: React.FC<ConfigureOtherProps>;
+export default ConfigureOther;

package/dist/components/ConfigureOther.js

@@ -0,0 +1,87 @@
+import React, { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import SelectInput from 'ink-select-input';
+import { configurationManager } from '../services/configurationManager.js';
+import { shortcutManager } from '../services/shortcutManager.js';
+import ConfigureCustomCommand from './ConfigureCustomCommand.js';
+import CustomCommandSummary from './CustomCommandSummary.js';
+const ConfigureOther = ({ onComplete }) => {
+    const autoApprovalConfig = configurationManager.getAutoApprovalConfig();
+    const [view, setView] = useState('main');
+    const [autoApprovalEnabled, setAutoApprovalEnabled] = useState(autoApprovalConfig.enabled);
+    const [customCommand, setCustomCommand] = useState(autoApprovalConfig.customCommand ?? '');
+    const [customCommandDraft, setCustomCommandDraft] = useState(customCommand);
+    useInput((input, key) => {
+        if (shortcutManager.matchesShortcut('cancel', input, key)) {
+            if (view === 'customCommand') {
+                setCustomCommandDraft(customCommand);
+                setView('main');
+                return;
+            }
+            onComplete();
+        }
+    });
+    const menuItems = [
+        {
+            label: `Auto Approval (experimental): ${autoApprovalEnabled ? '✅ Enabled' : '❌ Disabled'}`,
+            value: 'toggleAutoApproval',
+        },
+        {
+            label: '✏️  Edit Custom Command',
+            value: 'customCommand',
+        },
+        {
+            label: '💾 Save Changes',
+            value: 'save',
+        },
+        {
+            label: '← Cancel',
+            value: 'cancel',
+        },
+    ];
+    const handleSelect = (item) => {
+        switch (item.value) {
+            case 'toggleAutoApproval':
+                setAutoApprovalEnabled(!autoApprovalEnabled);
+                break;
+            case 'customCommand':
+                setCustomCommandDraft(customCommand);
+                setView('customCommand');
+                break;
+            case 'save':
+                configurationManager.setAutoApprovalConfig({
+                    enabled: autoApprovalEnabled,
+                    customCommand: customCommand.trim() || undefined,
+                });
+                onComplete();
+                break;
+            case 'cancel':
+                onComplete();
+                break;
+            default:
+                break;
+        }
+    };
+    if (view === 'customCommand') {
+        return (React.createElement(ConfigureCustomCommand, { value: customCommandDraft, onChange: setCustomCommandDraft, onCancel: () => {
+                setCustomCommandDraft(customCommand);
+                setView('main');
+            }, onSubmit: value => {
+                setCustomCommand(value);
+                setView('main');
+            } }));
+    }
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { bold: true, color: "green" }, "Other & Experimental Settings")),
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { dimColor: true }, "Toggle experimental capabilities and other miscellaneous options.")),
+        React.createElement(CustomCommandSummary, { command: customCommand }),
+        React.createElement(SelectInput, { items: menuItems, onSelect: handleSelect, isFocused: true }),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { dimColor: true },
+                "Press ",
+                shortcutManager.getShortcutDisplay('cancel'),
+                " to return without saving"))));
+};
+export default ConfigureOther;

package/dist/components/ConfigureOther.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/ConfigureOther.test.js

@@ -0,0 +1,80 @@
+import React from 'react';
+import { render } from 'ink-testing-library';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import ConfigureOther from './ConfigureOther.js';
+import { configurationManager } from '../services/configurationManager.js';
+// Mock ink to avoid stdin issues during tests
+vi.mock('ink', async () => {
+    const actual = await vi.importActual('ink');
+    return {
+        ...actual,
+        useInput: vi.fn(),
+    };
+});
+// Mock SelectInput to render labels directly
+vi.mock('ink-select-input', async () => {
+    const React = await vi.importActual('react');
+    const { Text, Box } = await vi.importActual('ink');
+    return {
+        default: ({ items }) => React.createElement(Box, { flexDirection: 'column' }, items.map((item, index) => React.createElement(Text, { key: index }, item.label))),
+    };
+});
+vi.mock('../services/configurationManager.js', () => ({
+    configurationManager: {
+        getAutoApprovalConfig: vi.fn(),
+        setAutoApprovalConfig: vi.fn(),
+    },
+}));
+vi.mock('../services/shortcutManager.js', () => ({
+    shortcutManager: {
+        matchesShortcut: vi.fn().mockReturnValue(false),
+        getShortcutDisplay: vi.fn().mockReturnValue('Esc'),
+    },
+}));
+vi.mock('./TextInputWrapper.js', async () => {
+    const React = await vi.importActual('react');
+    return {
+        default: ({ value }) => React.createElement('input', { value, 'data-testid': 'text-input' }),
+    };
+});
+vi.mock('./ConfigureCustomCommand.js', async () => {
+    const React = await vi.importActual('react');
+    return {
+        default: () => React.createElement('div', { 'data-testid': 'custom-command-editor' }),
+    };
+});
+vi.mock('./CustomCommandSummary.js', async () => {
+    const React = await vi.importActual('react');
+    const { Text } = await vi.importActual('ink');
+    return {
+        default: ({ command }) => React.createElement(Text, null, `Custom auto-approval command: ${command || 'Empty'}`),
+    };
+});
+const mockedConfigurationManager = configurationManager;
+describe('ConfigureOther', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('renders experimental settings with auto-approval status', () => {
+        mockedConfigurationManager.getAutoApprovalConfig.mockReturnValue({
+            enabled: true,
+            customCommand: '',
+        });
+        const { lastFrame } = render(React.createElement(ConfigureOther, { onComplete: vi.fn() }));
+        expect(lastFrame()).toContain('Other & Experimental Settings');
+        expect(lastFrame()).toContain('Auto Approval (experimental): ✅ Enabled');
+        expect(lastFrame()).toContain('Custom auto-approval command: Empty');
+        expect(lastFrame()).toContain('Edit Custom Command');
+        expect(lastFrame()).toContain('Save Changes');
+    });
+    it('shows current custom command summary', () => {
+        mockedConfigurationManager.getAutoApprovalConfig.mockReturnValue({
+            enabled: false,
+            customCommand: 'jq -n \'{"needsPermission":true}\'',
+        });
+        const { lastFrame } = render(React.createElement(ConfigureOther, { onComplete: vi.fn() }));
+        expect(lastFrame()).toContain('Custom auto-approval command:');
+        expect(lastFrame()).toContain('jq -n');
+        expect(lastFrame()).toContain('Edit Custom Command');
+    });
+});

package/dist/components/ConfigureStatusHooks.js

@@ -7,6 +7,7 @@ const STATUS_LABELS = {
     idle: 'Idle',
     busy: 'Busy',
     waiting_input: 'Waiting for Input',
+    pending_auto_approval: 'Pending Auto Approval',
 };
 const ConfigureStatusHooks = ({ onComplete, }) => {
     const [view, setView] = useState('menu');
@@ -31,7 +32,12 @@ const ConfigureStatusHooks = ({ onComplete, }) => {
     const getMenuItems = () => {
         const items = [];
         // Add status hook items
-        ['idle', 'busy', 'waiting_input'].forEach(status => {
+        [
+            'idle',
+            'busy',
+            'waiting_input',
+            'pending_auto_approval',
+        ].forEach(status => {
             const hook = statusHooks[status];
             const enabled = hook?.enabled ? '✓' : '✗';
             const command = hook?.command || '(not set)';

package/dist/components/CustomCommandSummary.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface CustomCommandSummaryProps {
+    command: string;
+}
+declare const CustomCommandSummary: React.FC<CustomCommandSummaryProps>;
+export default CustomCommandSummary;

package/dist/components/CustomCommandSummary.js

@@ -0,0 +1,10 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+const CustomCommandSummary = ({ command, }) => {
+    const displayValue = command.trim() ? command : 'Empty';
+    return (React.createElement(Box, { flexDirection: "column", marginBottom: 1 },
+        React.createElement(Text, null, "Custom auto-approval command:"),
+        React.createElement(Text, { dimColor: true }, displayValue),
+        React.createElement(Text, { dimColor: true }, "Env provided: $DEFAULT_PROMPT, $TERMINAL_OUTPUT")));
+};
+export default CustomCommandSummary;

package/dist/components/Menu.recent-projects.test.js

@@ -99,6 +99,7 @@ describe('Menu - Recent Projects', () => {
             idle: 0,
             busy: 0,
             waiting_input: 0,
+            pending_auto_approval: 0,
             total: 0,
         });
         vi.spyOn(SessionManager, 'formatSessionCounts').mockReturnValue('');
@@ -128,6 +129,7 @@ describe('Menu - Recent Projects', () => {
             idle: 0,
             busy: 0,
             waiting_input: 0,
+            pending_auto_approval: 0,
             total: 0,
         });
         vi.spyOn(SessionManager, 'formatSessionCounts').mockReturnValue('');

package/dist/components/Menu.test.js

@@ -272,6 +272,7 @@ describe('Menu component rendering', () => {
             idle: 0,
             busy: 0,
             waiting_input: 0,
+            pending_auto_approval: 0,
             total: 0,
         });
         vi.spyOn(SessionManager, 'formatSessionCounts').mockReturnValue('');
@@ -312,6 +313,7 @@ describe('Menu component rendering', () => {
             idle: 0,
             busy: 0,
             waiting_input: 0,
+            pending_auto_approval: 0,
             total: 0,
         });
         vi.spyOn(SessionManager, 'formatSessionCounts').mockReturnValue('');

package/dist/components/Session.d.ts

@@ -1,8 +1,8 @@
 import React from 'react';
-import { Session as SessionType } from '../types/index.js';
+import { Session as ISession } from '../types/index.js';
 import { SessionManager } from '../services/sessionManager.js';
 interface SessionProps {
-    session: SessionType;
+    session: ISession;
     sessionManager: SessionManager;
     onReturnToMenu: () => void;
 }

package/dist/components/Session.js

@@ -1,9 +1,67 @@
-import { useEffect, useState } from 'react';
-import { useStdout } from 'ink';
+import React, { useEffect, useMemo, useState } from 'react';
+import { Box, Text, useStdout } from 'ink';
 import { shortcutManager } from '../services/shortcutManager.js';
 const Session = ({ session, sessionManager, onReturnToMenu, }) => {
     const { stdout } = useStdout();
     const [isExiting, setIsExiting] = useState(false);
+    const deriveStatus = (currentSession) => {
+        // Always prioritize showing the manual approval notice when verification failed
+        if (currentSession.autoApprovalFailed) {
+            const reason = currentSession.autoApprovalReason
+                ? ` Reason: ${currentSession.autoApprovalReason}.`
+                : '';
+            return {
+                message: `Auto-approval failed.${reason} Manual approval required—respond to the prompt.`,
+                variant: 'error',
+            };
+        }
+        if (currentSession.state === 'pending_auto_approval') {
+            return {
+                message: 'Auto-approval pending... verifying permissions (press any key to cancel)',
+                variant: 'pending',
+            };
+        }
+        return { message: null, variant: null };
+    };
+    const initialStatus = deriveStatus(session);
+    const [statusMessage, setStatusMessage] = useState(initialStatus.message);
+    const [statusVariant, setStatusVariant] = useState(initialStatus.variant);
+    const [columns, setColumns] = useState(() => stdout?.columns ?? process.stdout.columns ?? 80);
+    const { statusLineText, backgroundColor, textColor } = useMemo(() => {
+        if (!statusMessage || !statusVariant) {
+            return {
+                statusLineText: null,
+                backgroundColor: undefined,
+                textColor: undefined,
+            };
+        }
+        const maxContentWidth = Math.max(columns - 4, 0);
+        const prefix = statusVariant === 'error'
+            ? '[AUTO-APPROVAL REQUIRED]'
+            : '[AUTO-APPROVAL]';
+        const prefixed = `${prefix} ${statusMessage}`;
+        const trimmed = prefixed.length > maxContentWidth
+            ? prefixed.slice(0, maxContentWidth)
+            : prefixed;
+        return {
+            statusLineText: ` ${trimmed}`.padEnd(columns, ' '),
+            backgroundColor: statusVariant === 'error' ? '#d90429' : '#ffd166',
+            textColor: statusVariant === 'error' ? 'white' : '#1c1c1c',
+        };
+    }, [columns, statusMessage, statusVariant]);
+    useEffect(() => {
+        const handleSessionStateChange = (updatedSession) => {
+            if (updatedSession.id !== session.id)
+                return;
+            const { message, variant } = deriveStatus(updatedSession);
+            setStatusMessage(message);
+            setStatusVariant(variant);
+        };
+        sessionManager.on('sessionStateChanged', handleSessionStateChange);
+        return () => {
+            sessionManager.off('sessionStateChanged', handleSessionStateChange);
+        };
+    }, [session.id, sessionManager]);
     const stripOscColorSequences = (input) => {
         // Remove default foreground/background color OSC sequences that Codex emits
         // These sequences leak as literal text when replaying buffered output
@@ -12,6 +70,26 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
     useEffect(() => {
         if (!stdout)
             return;
+        const resetTerminalInputModes = () => {
+            // Reset terminal modes that interactive tools like Codex enable (kitty keyboard
+            // protocol / modifyOtherKeys / focus tracking) so they don't leak into other
+            // sessions after we detach.
+            stdout.write('\x1b[>0u'); // Disable kitty keyboard protocol (CSI u sequences)
+            stdout.write('\x1b[>4m'); // Disable xterm modifyOtherKeys extensions
+            stdout.write('\x1b[?1004l'); // Disable focus reporting
+            stdout.write('\x1b[?2004l'); // Disable bracketed paste (can interfere with shortcuts)
+        };
+        const sanitizeReplayBuffer = (input) => {
+            // Remove terminal mode toggles emitted by Codex so replay doesn't re-enable them
+            // on our own TTY when restoring the session view.
+            return stripOscColorSequences(input)
+                .replace(/\x1B\[>4;?\d*m/g, '') // modifyOtherKeys set/reset
+                .replace(/\x1B\[>[0-9;]*u/g, '') // kitty keyboard protocol enables
+                .replace(/\x1B\[\?1004[hl]/g, '') // focus tracking
+                .replace(/\x1B\[\?2004[hl]/g, ''); // bracketed paste
+        };
+        // Reset modes immediately on entry in case a previous session left them on
+        resetTerminalInputModes();
         // Clear screen when entering session
         stdout.write('\x1B[2J\x1B[H');
         // Handle session restoration
@@ -22,7 +100,7 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
                     const buffer = restoredSession.outputHistory[i];
                     if (!buffer)
                         continue;
-                    const str = stripOscColorSequences(buffer.toString('utf8'));
+                    const str = sanitizeReplayBuffer(buffer.toString('utf8'));
                     // Skip clear screen sequences at the beginning
                     if (i === 0 && (str.includes('\x1B[2J') || str.includes('\x1B[H'))) {
                         // Skip this buffer or remove the clear sequence
@@ -71,6 +149,7 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
         const handleSessionExit = (exitedSession) => {
             if (exitedSession.id === session.id) {
                 setIsExiting(true);
+                setStatusMessage(null);
                 // Don't call onReturnToMenu here - App component handles it
             }
         };
@@ -80,6 +159,7 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
         const handleResize = () => {
             const cols = process.stdout.columns || 80;
             const rows = process.stdout.rows || 24;
+            setColumns(cols);
             session.process.resize(cols, rows);
             // Also resize the virtual terminal
             if (session.terminal) {
@@ -101,9 +181,9 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
                 return;
             // Check for return to menu shortcut
             if (shortcutManager.matchesRawInput('returnToMenu', data)) {
-                // Disable focus reporting mode before returning to menu
+                // Disable any extended input modes that might have been enabled by the PTY
                 if (stdout) {
-                    stdout.write('\x1b[?1004l');
+                    resetTerminalInputModes();
                 }
                 // Restore stdin state before returning to menu
                 stdin.removeListener('data', handleStdinData);
@@ -112,6 +192,9 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
                 onReturnToMenu();
                 return;
             }
+            if (session.state === 'pending_auto_approval') {
+                sessionManager.cancelAutoApproval(session.worktreePath, 'User input received during auto-approval');
+            }
             // Pass all other input directly to the PTY
             session.process.write(data);
         };
@@ -121,7 +204,7 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
             stdin.removeListener('data', handleStdinData);
             // Disable focus reporting mode that might have been enabled by the PTY
             if (stdout) {
-                stdout.write('\x1b[?1004l');
+                resetTerminalInputModes();
             }
             // Restore stdin to its original state
             if (stdin.isTTY) {
@@ -142,7 +225,7 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
             stdout.off('resize', handleResize);
         };
     }, [session, sessionManager, stdout, onReturnToMenu, isExiting]);
-    // Return null to render nothing (PTY output goes directly to stdout)
-    return null;
+    return statusLineText ? (React.createElement(Box, { width: "100%" },
+        React.createElement(Text, { backgroundColor: backgroundColor, color: textColor, bold: true }, statusLineText))) : null;
 };
 export default Session;

package/dist/constants/statusIcons.d.ts

@@ -1,3 +1,4 @@
+import { SessionState } from '../types/index.js';
 export declare const STATUS_ICONS: {
     readonly BUSY: "●";
     readonly WAITING: "◐";
@@ -6,6 +7,7 @@ export declare const STATUS_ICONS: {
 export declare const STATUS_LABELS: {
     readonly BUSY: "Busy";
     readonly WAITING: "Waiting";
+    readonly PENDING_AUTO_APPROVAL: "Pending Auto Approval";
     readonly IDLE: "Idle";
 };
 export declare const MENU_ICONS: {
@@ -15,4 +17,4 @@ export declare const MENU_ICONS: {
     readonly CONFIGURE_SHORTCUTS: "⌨";
     readonly EXIT: "⏻";
 };
-export declare const getStatusDisplay: (status: "busy" | "waiting_input" | "idle") => string;
+export declare const getStatusDisplay: (status: SessionState) => string;

package/dist/constants/statusIcons.js

@@ -6,6 +6,7 @@ export const STATUS_ICONS = {
 export const STATUS_LABELS = {
     BUSY: 'Busy',
     WAITING: 'Waiting',
+    PENDING_AUTO_APPROVAL: 'Pending Auto Approval',
     IDLE: 'Idle',
 };
 export const MENU_ICONS = {
@@ -21,6 +22,8 @@ export const getStatusDisplay = (status) => {
             return `${STATUS_ICONS.BUSY} ${STATUS_LABELS.BUSY}`;
         case 'waiting_input':
             return `${STATUS_ICONS.WAITING} ${STATUS_LABELS.WAITING}`;
+        case 'pending_auto_approval':
+            return `${STATUS_ICONS.WAITING} ${STATUS_LABELS.PENDING_AUTO_APPROVAL}`;
         case 'idle':
             return `${STATUS_ICONS.IDLE} ${STATUS_LABELS.IDLE}`;
     }

package/dist/services/autoApprovalVerifier.d.ts

@@ -0,0 +1,25 @@
+import { Effect } from 'effect';
+import { ProcessError } from '../types/errors.js';
+import { AutoApprovalResponse } from '../types/index.js';
+/**
+ * Service to verify if auto-approval should be granted for pending states
+ * Uses Claude Haiku model to analyze terminal output and determine if
+ * user permission is required before proceeding
+ */
+export declare class AutoApprovalVerifier {
+    private readonly model;
+    private createExecOptions;
+    private runClaudePrompt;
+    private runCustomCommand;
+    /**
+     * Verify if the current terminal output requires user permission
+     * before proceeding with auto-approval
+     *
+     * @param terminalOutput - Current terminal output to analyze
+     * @returns Effect that resolves to true if permission needed, false if can auto-approve
+     */
+    verifyNeedsPermission(terminalOutput: string, options?: {
+        signal?: AbortSignal;
+    }): Effect.Effect<AutoApprovalResponse, ProcessError, never>;
+}
+export declare const autoApprovalVerifier: AutoApprovalVerifier;