aiexecode 1.0.126 → 1.0.128

package/src/commands/bg.js

@@ -0,0 +1,129 @@
+import { listBackgroundProcesses, killBackgroundProcess, getBackgroundProcess } from '../system/background_process.js';
+import { uiEvents } from '../system/ui_events.js';
+
+/**
+ * /bg 커맨드 - 백그라운드 프로세스 관리
+ *
+ * 사용법:
+ *   /bg          - 프로세스 목록 표시
+ *   /bg list     - 프로세스 목록 표시
+ *   /bg kill <id> - 프로세스 종료
+ *   /bg killall  - 모든 실행 중인 프로세스 종료
+ */
+export default {
+    name: 'bg',
+    description: 'Manage background processes',
+    usage: '/bg [list|kill <id>|killall]',
+    handler: async (args, context) => {
+        const subcommand = args[0]?.toLowerCase() || 'list';
+
+        switch (subcommand) {
+            case 'list':
+            case 'ls': {
+                const processes = listBackgroundProcesses({ running: true });
+                if (processes.length === 0) {
+                    uiEvents.addSystemMessage('No running background processes');
+                    return;
+                }
+
+                const lines = ['Background Processes:'];
+                for (const proc of processes) {
+                    const statusIcon = proc.status === 'running' ? '●' :
+                                       proc.status === 'completed' ? '✓' :
+                                       proc.status === 'failed' ? '✗' : '⊘';
+                    const duration = formatDuration(proc.startedAt, proc.endedAt);
+                    lines.push(`  ${statusIcon} [${proc.id}] pid:${proc.pid} ${duration} - ${proc.command.substring(0, 50)}${proc.command.length > 50 ? '...' : ''}`);
+                }
+                uiEvents.addSystemMessage(lines.join('\n'));
+                break;
+            }
+
+            case 'kill': {
+                const id = args[1];
+                if (!id) {
+                    uiEvents.addErrorMessage('Usage: /bg kill <process_id>');
+                    return;
+                }
+
+                const proc = getBackgroundProcess(id);
+                if (!proc) {
+                    uiEvents.addErrorMessage(`Process not found: ${id}`);
+                    return;
+                }
+
+                if (proc.status !== 'running') {
+                    uiEvents.addSystemMessage(`Process ${id} is already ${proc.status}`);
+                    return;
+                }
+
+                const killed = killBackgroundProcess(id);
+                if (killed) {
+                    uiEvents.addSystemMessage(`Killed process: ${id} (pid: ${proc.pid})`);
+                } else {
+                    uiEvents.addErrorMessage(`Failed to kill process: ${id}`);
+                }
+                break;
+            }
+
+            case 'killall': {
+                const processes = listBackgroundProcesses({ running: true });
+                if (processes.length === 0) {
+                    uiEvents.addSystemMessage('No running background processes');
+                    return;
+                }
+
+                let killedCount = 0;
+                for (const proc of processes) {
+                    if (killBackgroundProcess(proc.id)) {
+                        killedCount++;
+                    }
+                }
+                uiEvents.addSystemMessage(`Killed ${killedCount} background process(es)`);
+                break;
+            }
+
+            case 'show': {
+                const id = args[1];
+                if (!id) {
+                    uiEvents.addErrorMessage('Usage: /bg show <process_id>');
+                    return;
+                }
+
+                const proc = getBackgroundProcess(id);
+                if (!proc) {
+                    uiEvents.addErrorMessage(`Process not found: ${id}`);
+                    return;
+                }
+
+                const lines = [
+                    `Process: ${proc.id}`,
+                    `  PID: ${proc.pid}`,
+                    `  Status: ${proc.status}`,
+                    `  Command: ${proc.command}`,
+                    `  Started: ${proc.startedAt.toISOString()}`,
+                    proc.endedAt ? `  Ended: ${proc.endedAt.toISOString()}` : null,
+                    proc.exitCode !== null ? `  Exit Code: ${proc.exitCode}` : null,
+                    proc.stdout ? `  Stdout (last 200 chars): ${proc.stdout.slice(-200)}` : null,
+                    proc.stderr ? `  Stderr (last 200 chars): ${proc.stderr.slice(-200)}` : null,
+                ].filter(Boolean);
+
+                uiEvents.addSystemMessage(lines.join('\n'));
+                break;
+            }
+
+            default:
+                uiEvents.addErrorMessage(`Unknown subcommand: ${subcommand}\nUsage: /bg [list|kill <id>|killall|show <id>]`);
+        }
+    }
+};
+
+function formatDuration(startedAt, endedAt) {
+    const end = endedAt ? new Date(endedAt) : new Date();
+    const start = new Date(startedAt);
+    const diffMs = end - start;
+
+    if (diffMs < 1000) return `${diffMs}ms`;
+    if (diffMs < 60000) return `${Math.round(diffMs / 1000)}s`;
+    if (diffMs < 3600000) return `${Math.round(diffMs / 60000)}m`;
+    return `${Math.round(diffMs / 3600000)}h`;
+}

package/src/frontend/App.js

@@ -13,6 +13,7 @@ import { ConversationItem } from './components/ConversationItem.js';
 import { BlankLine } from './components/BlankLine.js';
 import { TodoList } from './components/TodoList.js';
 import { LoadingIndicator } from './components/LoadingIndicator.js';
+import { BackgroundProcessList } from './components/BackgroundProcessList.js';
 import { useTextBuffer } from './utils/inputBuffer.js';
 import { uiEvents } from '../system/ui_events.js';
 import { getToolDisplayConfig, extractMessageFromArgs, formatToolCall, formatToolResult, getToolDisplayName } from '../system/tool_registry.js';
@@ -361,6 +362,9 @@ export function App({ onSubmit, onClearScreen, onExit, commands = [], model, ver
     const [approvalRequest, setApprovalRequest] = useState(null);
     const [showSetupWizard, setShowSetupWizard] = useState(false);
     const [todos, setTodos] = useState([]);
+    const [backgroundProcesses, setBackgroundProcesses] = useState([]);
+    const [showBackgroundPanel, setShowBackgroundPanel] = useState(false);
+    const [backgroundPanelFocused, setBackgroundPanelFocused] = useState(false);
 
     // Static items: 메모이제이션된 React 엘리먼트들 (Static 컴포넌트 제거로 스크롤 문제 해결)
     const [staticItems, setStaticItems] = useState(() => []);
@@ -967,6 +971,94 @@ export function App({ onSubmit, onClearScreen, onExit, commands = [], model, ver
         };
     }, [addToHistory, handleSessionTransition, version]);
 
+    // 백그라운드 프로세스 이벤트 핸들링
+    const showBackgroundPanelRef = useRef(showBackgroundPanel);
+    useEffect(() => {
+        showBackgroundPanelRef.current = showBackgroundPanel;
+    }, [showBackgroundPanel]);
+
+    useEffect(() => {
+        let manager = null;
+        let updateInterval = null;
+        let cleanupFn = null;
+        let isMounted = true;
+
+        const setupBackgroundProcessListener = async () => {
+            const { getBackgroundProcessManager } = await import('../system/background_process.js');
+            if (!isMounted) return;
+
+            manager = getBackgroundProcessManager();
+
+            const updateProcessList = () => {
+                if (!isMounted) return;
+                const processes = manager.list();
+                // 실행 중인 프로세스만 표시
+                const runningProcesses = processes.filter(p => p.status === 'running');
+                setBackgroundProcesses(runningProcesses);
+
+                // 실행 중인 프로세스가 있으면 패널 자동 표시
+                if (runningProcesses.length > 0 && !showBackgroundPanelRef.current) {
+                    setShowBackgroundPanel(true);
+                }
+                // 실행 중인 프로세스가 없으면 패널 숨기기
+                if (runningProcesses.length === 0) {
+                    setShowBackgroundPanel(false);
+                    setBackgroundPanelFocused(false);
+                }
+            };
+
+            // 이벤트 핸들러
+            const handleStarted = () => {
+                updateProcessList();
+            };
+            const handleClose = () => updateProcessList();
+            const handleKilled = () => updateProcessList();
+
+            manager.on('started', handleStarted);
+            manager.on('close', handleClose);
+            manager.on('killed', handleKilled);
+
+            // 초기 로드
+            updateProcessList();
+
+            // 주기적 업데이트 (실행 시간 표시용)
+            updateInterval = setInterval(updateProcessList, 1000);
+
+            cleanupFn = () => {
+                manager.off('started', handleStarted);
+                manager.off('close', handleClose);
+                manager.off('killed', handleKilled);
+                if (updateInterval) clearInterval(updateInterval);
+            };
+        };
+
+        setupBackgroundProcessListener();
+
+        return () => {
+            isMounted = false;
+            if (cleanupFn) cleanupFn();
+            if (updateInterval) clearInterval(updateInterval);
+        };
+    }, []);
+
+    // 백그라운드 프로세스 kill 핸들러
+    const handleKillBackgroundProcess = useCallback(async (id) => {
+        const { killBackgroundProcess } = await import('../system/background_process.js');
+        killBackgroundProcess(id);
+    }, []);
+
+    // 백그라운드 패널 닫기 핸들러
+    const handleCloseBackgroundPanel = useCallback(() => {
+        setBackgroundPanelFocused(false);
+    }, []);
+
+    // 백그라운드 패널 포커스 토글 핸들러
+    const handleToggleBackgroundPanelFocus = useCallback(() => {
+        if (backgroundProcesses.length > 0 && showBackgroundPanel) {
+            setBackgroundPanelFocused(prev => !prev);
+        }
+    }, [backgroundProcesses.length, showBackgroundPanel]);
+
     // 승인 요청 처리
     const handleApprovalDecision = useCallback((decision) => {
         if (approvalRequest && approvalRequest.resolve) {
@@ -1111,13 +1203,20 @@ export function App({ onSubmit, onClearScreen, onExit, commands = [], model, ver
             !approvalRequest && todos.length > 0 && React.createElement(TodoList, {
                 todos: todos
             }),
+            !approvalRequest && showBackgroundPanel && backgroundProcesses.length > 0 && React.createElement(BackgroundProcessList, {
+                processes: backgroundProcesses,
+                isActive: backgroundPanelFocused && !isSessionRunning && !approvalRequest,
+                onKill: handleKillBackgroundProcess,
+                onClose: handleCloseBackgroundPanel,
+                onToggleFocus: handleToggleBackgroundPanelFocus
+            }),
             !approvalRequest && React.createElement(Input, {
                 buffer,
                 onSubmit: handleSubmit,
                 onClearScreen: handleClearScreen,
                 onExit: onExit,
                 commands,
-                focus: true,
+                focus: !backgroundPanelFocused,
                 isSessionRunning
             }),
             React.createElement(MemoizedFooter, { model: currentModel, reasoningEffort })

package/src/frontend/components/BackgroundProcessList.js

@@ -0,0 +1,175 @@
+/**
+ * BackgroundProcessList Component
+ * 백그라운드 프로세스 목록을 표시하고 관리하는 컴포넌트
+ *
+ * - 방향키로 선택
+ * - k 키로 선택된 프로세스 종료
+ * - q 키로 목록 닫기
+ */
+
+import React, { useState, useEffect } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { theme } from '../design/themeColors.js';
+
+const getStatusIcon = (status) => {
+    switch (status) {
+        case 'running':
+            return '●';
+        case 'completed':
+            return '✓';
+        case 'failed':
+            return '✗';
+        case 'killed':
+            return '⊘';
+        default:
+            return '?';
+    }
+};
+
+const getStatusColor = (status) => {
+    switch (status) {
+        case 'running':
+            return theme.brand.light;
+        case 'completed':
+            return 'green';
+        case 'failed':
+            return theme.status.error;
+        case 'killed':
+            return theme.text.secondary;
+        default:
+            return theme.text.primary;
+    }
+};
+
+const formatDuration = (startedAt, endedAt) => {
+    const end = endedAt ? new Date(endedAt) : new Date();
+    const start = new Date(startedAt);
+    const diffMs = end - start;
+
+    if (diffMs < 1000) return `${diffMs}ms`;
+    if (diffMs < 60000) return `${Math.round(diffMs / 1000)}s`;
+    if (diffMs < 3600000) return `${Math.round(diffMs / 60000)}m`;
+    return `${Math.round(diffMs / 3600000)}h`;
+};
+
+const truncateCommand = (command, maxLength = 50) => {
+    if (command.length <= maxLength) return command;
+    return command.substring(0, maxLength - 3) + '...';
+};
+
+export function BackgroundProcessList({
+    processes,
+    isActive,
+    onKill,
+    onClose,
+    onSelect,
+    onToggleFocus
+}) {
+    const [selectedIndex, setSelectedIndex] = useState(0);
+
+    // 프로세스 목록이 변경되면 선택 인덱스 조정
+    useEffect(() => {
+        if (selectedIndex >= processes.length) {
+            setSelectedIndex(Math.max(0, processes.length - 1));
+        }
+    }, [processes.length, selectedIndex]);
+
+    // 키보드 입력 처리
+    useInput((input, key) => {
+        if (!isActive) return;
+
+        if (key.upArrow) {
+            setSelectedIndex(prev => Math.max(0, prev - 1));
+        } else if (key.downArrow) {
+            setSelectedIndex(prev => Math.min(processes.length - 1, prev + 1));
+        } else if (input === 'k' || input === 'K') {
+            const selected = processes[selectedIndex];
+            if (selected && selected.status === 'running' && onKill) {
+                onKill(selected.id);
+            }
+        } else if (input === 'q' || input === 'Q' || key.escape) {
+            if (onClose) onClose();
+        } else if (key.return) {
+            const selected = processes[selectedIndex];
+            if (selected && onSelect) {
+                onSelect(selected);
+            }
+        }
+    }, { isActive });
+
+    if (!processes || processes.length === 0) {
+        return React.createElement(Box, { flexDirection: "column", marginTop: 1 },
+            React.createElement(Text, { color: theme.text.secondary },
+                'No background processes'
+            )
+        );
+    }
+
+    return React.createElement(Box, { flexDirection: "column", marginTop: 1 },
+        // 프로세스 목록
+        ...processes.map((proc, index) => {
+            const isSelected = index === selectedIndex && isActive;
+            const statusIcon = getStatusIcon(proc.status);
+            const statusColor = getStatusColor(proc.status);
+            const duration = formatDuration(proc.startedAt, proc.endedAt);
+            const command = truncateCommand(proc.command);
+
+            return React.createElement(Box, {
+                key: proc.id,
+                marginLeft: 1
+            },
+                // 선택 표시
+                React.createElement(Text, {
+                    color: isSelected ? theme.brand.light : theme.text.secondary
+                }, isSelected ? '▸ ' : '  '),
+
+                // 상태 아이콘
+                React.createElement(Text, { color: statusColor }, statusIcon),
+                React.createElement(Text, null, ' '),
+
+                // ID
+                React.createElement(Text, {
+                    color: theme.text.secondary,
+                    dimColor: !isSelected
+                }, `[${proc.id}]`),
+                React.createElement(Text, null, ' '),
+
+                // PID
+                React.createElement(Text, {
+                    color: theme.text.secondary,
+                    dimColor: !isSelected
+                }, `pid:${proc.pid}`),
+                React.createElement(Text, null, ' '),
+
+                // 시간
+                React.createElement(Text, {
+                    color: proc.status === 'running' ? theme.brand.light : theme.text.secondary,
+                    dimColor: !isSelected && proc.status !== 'running'
+                }, duration),
+                React.createElement(Text, null, ' '),
+
+                // 명령어
+                React.createElement(Text, {
+                    color: isSelected ? theme.text.primary : theme.text.secondary,
+                    bold: isSelected
+                }, command)
+            );
+        })
+    );
+}
+
+/**
+ * 간단한 백그라운드 프로세스 상태 표시 (헤더용)
+ */
+export function BackgroundProcessBadge({ count, onClick }) {
+    if (count === 0) return null;
+
+    return React.createElement(Box, {
+        marginLeft: 1
+    },
+        React.createElement(Text, {
+            color: theme.brand.light,
+            bold: true
+        }, `[BG: ${count}]`)
+    );
+}

package/src/system/ai_request.js

@@ -7,7 +7,6 @@ import { getReasoningModels, supportsReasoningEffort, DEFAULT_MODEL, getModelInf
 import { createDebugLogger } from "../util/debug_log.js";
 import { formatReadFileStdout } from "../util/output_formatter.js";
 import { UnifiedLLMClient } from "../LLMClient/index.js";
-import { uiEvents } from "./ui_events.js";
 
 const debugLog = createDebugLogger('ai_request.log', 'ai_request');
 
@@ -212,20 +211,6 @@ function toAbsolutePath(anyPath) {
 export async function request(taskName, requestPayload) {
     debugLog(`[request] ========== START: ${taskName} ==========`);
 
-    // 설정에서 API payload 표시 여부 확인
-    const settings = await loadSettings();
-    const showApiPayload = settings?.SHOW_API_PAYLOAD === true;
-
-    // 화면에 요청 시작 표시 (설정이 켜져 있을 때만)
-    if (showApiPayload) {
-        const taskDisplayNames = {
-            'orchestrator': '🤖 Orchestrator',
-            'completion_judge': '✅ Completion Judge'
-        };
-        const displayName = taskDisplayNames[taskName] || taskName;
-        uiEvents.addSystemMessage(`📡 API Request: ${displayName}`);
-    }
-
     const provider = await getCurrentProvider();
     debugLog(`[request] Provider: ${provider}`);
 
@@ -682,10 +667,6 @@ export async function request(taskName, requestPayload) {
         })()
     };
 
-    // 화면에 응답 내용 표시 (설정이 켜져 있을 때만)
-    if (showApiPayload) {
-        uiEvents.addSystemMessage(`   └─ Response:\n${JSON.stringify(rawOutput, null, 2)}`);
-    }
 
     debugLog(`[request] ========== END: ${taskName} ==========`);