recomposable 1.1.2 → 1.1.3

package/dist/index.d.ts

@@ -27,12 +27,16 @@ export declare function doCascadeRebuild(state: AppState): void;
 export declare function enterExecInline(state: AppState): void;
 export declare function enterExec(state: AppState): void;
 export declare function exitExec(state: AppState): void;
+export declare function shellEscape(str: string): string;
 export declare function runExecCommand(state: AppState): void;
 export declare function enterLogs(state: AppState): void;
 export declare function exitLogs(state: AppState): void;
+export declare function loadMoreLogHistory(state: AppState): void;
 export declare function executeLogSearch(state: AppState): void;
 export declare function jumpToNextMatch(state: AppState): void;
 export declare function jumpToPrevMatch(state: AppState): void;
+export declare function executeBottomSearch(state: AppState): void;
+export declare function clearBottomSearch(state: AppState): void;
 export declare function handleKeypress(state: AppState, key: string): void;
 export declare function createInputHandler(state: AppState): (data: Buffer | string) => void;
 export declare function cleanup(state: AppState): void;

package/dist/index.js

@@ -24,12 +24,16 @@ exports.doCascadeRebuild = doCascadeRebuild;
 exports.enterExecInline = enterExecInline;
 exports.enterExec = enterExec;
 exports.exitExec = exitExec;
+exports.shellEscape = shellEscape;
 exports.runExecCommand = runExecCommand;
 exports.enterLogs = enterLogs;
 exports.exitLogs = exitLogs;
+exports.loadMoreLogHistory = loadMoreLogHistory;
 exports.executeLogSearch = executeLogSearch;
 exports.jumpToNextMatch = jumpToNextMatch;
 exports.jumpToPrevMatch = jumpToPrevMatch;
+exports.executeBottomSearch = executeBottomSearch;
+exports.clearBottomSearch = clearBottomSearch;
 exports.handleKeypress = handleKeypress;
 exports.createInputHandler = createInputHandler;
 exports.cleanup = cleanup;
@@ -69,7 +73,33 @@ function loadConfig() {
     };
     const configPath = path_1.default.join(process.cwd(), 'recomposable.json');
     if (fs_1.default.existsSync(configPath)) {
-        Object.assign(defaults, JSON.parse(fs_1.default.readFileSync(configPath, 'utf8')));
+        const raw = JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
+        if (raw && typeof raw === 'object' && !Array.isArray(raw)) {
+            if (Array.isArray(raw.composeFiles) && raw.composeFiles.every((f) => typeof f === 'string')) {
+                defaults.composeFiles = raw.composeFiles;
+            }
+            if (Array.isArray(raw.logScanPatterns) && raw.logScanPatterns.every((p) => typeof p === 'string')) {
+                defaults.logScanPatterns = raw.logScanPatterns;
+            }
+            const numericFields = [
+                { key: 'pollInterval', min: 500, max: 300000 },
+                { key: 'logTailLines', min: 1, max: 50000 },
+                { key: 'logScanLines', min: 1, max: 50000 },
+                { key: 'logScanInterval', min: 1000, max: 600000 },
+                { key: 'statsInterval', min: 1000, max: 600000 },
+                { key: 'statsBufferSize', min: 1, max: 100 },
+                { key: 'bottomLogCount', min: 1, max: 200 },
+                { key: 'cpuWarnThreshold', min: 0, max: 10000 },
+                { key: 'cpuDangerThreshold', min: 0, max: 10000 },
+                { key: 'memWarnThreshold', min: 0, max: 1048576 },
+                { key: 'memDangerThreshold', min: 0, max: 1048576 },
+            ];
+            for (const { key, min, max } of numericFields) {
+                if (typeof raw[key] === 'number' && isFinite(raw[key]) && raw[key] >= min && raw[key] <= max) {
+                    defaults[key] = raw[key];
+                }
+            }
+        }
     }
     const args = process.argv.slice(2);
     const cliFiles = [];
@@ -244,20 +274,26 @@ function pollContainerStats(state) {
 }
 // --- Rendering ---
 function render(state) {
-    let output = (0, renderer_1.clearScreen)();
+    let view = '';
     if (state.mode === state_1.MODE.LIST) {
-        output += (0, renderer_1.renderListView)(state);
+        view = (0, renderer_1.renderListView)(state);
     }
     else if (state.mode === state_1.MODE.LOGS) {
-        output += (0, renderer_1.renderLogView)(state);
+        view = (0, renderer_1.renderLogView)(state);
     }
     else if (state.mode === state_1.MODE.EXEC) {
-        output += (0, renderer_1.renderExecView)(state);
+        view = (0, renderer_1.renderExecView)(state);
     }
-    process.stdout.write(output);
+    // View functions already embed CLEAR_EOL per line; just clear below last line
+    process.stdout.write((0, renderer_1.clearScreen)() + view + renderer_1.CLEAR_EOL + renderer_1.CLEAR_EOS);
 }
 function stripAnsi(str) {
-    return str.replace(/\x1b\[[0-9;?]*[a-zA-Z]|\x1b\][^\x07]*\x07|\x1b[^[\]]/g, '');
+    return str.replace(
+    // CSI sequences: \x1b[ ... letter
+    // OSC sequences: \x1b] ... BEL  or  \x1b] ... ST
+    // DCS/APC/PM/SOS sequences: \x1bP/\x1b_/\x1b^/\x1bX ... ST (where ST = \x1b\\)
+    // Two-byte escape sequences: \x1b + any char
+    /\x1b\[[0-9;?]*[a-zA-Z]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[P_^X][^\x1b]*(?:\x1b\\|\x07)|\x1b[^[\]P_^X]/g, '');
 }
 function throttledRender(state) {
     const now = Date.now();
@@ -284,6 +320,7 @@ function updateSelectedLogs(state) {
         return;
     state.bottomSearchQuery = '';
     state.bottomSearchActive = false;
+    clearBottomSearch(state);
     if (moduleState.logFetchTimer) {
         clearTimeout(moduleState.logFetchTimer);
         moduleState.logFetchTimer = null;
@@ -351,7 +388,7 @@ function doRebuild(state) {
         state.bottomLogTails.get(sk).kill('SIGTERM');
         state.bottomLogTails.delete(sk);
     }
-    const child = (0, docker_1.rebuildService)(entry.file, entry.service, { noCache: state.noCache });
+    const child = (0, docker_1.rebuildService)(entry.file, entry.service, { noCache: state.noCache, noDeps: state.noDeps });
     state.rebuilding.set(sk, child);
     state.bottomLogLines.set(sk, { action: 'rebuilding', service: entry.service, lines: [] });
     let lineBuf = '';
@@ -366,24 +403,34 @@ function doRebuild(state) {
         if (newLines.length === 0)
             return;
         info.lines.push(...newLines);
-        const maxLines = state.config.bottomLogCount || 10;
-        if (info.lines.length > maxLines)
-            info.lines = info.lines.slice(-maxLines);
+        if (state.mode === state_1.MODE.LOGS && state.logBuildKey === sk) {
+            state.logLines.push(...newLines);
+            if (state.logAutoScroll)
+                throttledRender(state);
+        }
         if (state.mode === state_1.MODE.LIST)
             throttledRender(state);
     };
     child.stdout.on('data', onData);
     child.stderr.on('data', onData);
     render(state);
-    child.on('close', () => {
+    child.on('close', (code) => {
         state.rebuilding.delete(sk);
         state.containerStatsHistory.delete(sk);
         state.containerStats.delete(sk);
         pollStatuses(state);
         const info = state.bottomLogLines.get(sk);
+        if (code !== 0 && code !== null) {
+            if (info)
+                info.action = 'build_failed';
+            if (state.mode === state_1.MODE.LIST)
+                render(state);
+            return;
+        }
         if (info) {
             info.action = 'started';
-            info.lines = [];
+            if (state.logBuildKey !== sk)
+                info.lines = [];
         }
         startBottomLogTail(state, sk, entry.file, entry.service);
         if (state.mode === state_1.MODE.LIST)
@@ -405,12 +452,19 @@ function doRestart(state) {
     state.restarting.set(sk, child);
     state.bottomLogLines.set(sk, { action: 'restarting', service: entry.service, lines: [] });
     render(state);
-    child.on('close', () => {
+    child.on('close', (code) => {
         state.restarting.delete(sk);
         state.containerStatsHistory.delete(sk);
         state.containerStats.delete(sk);
         pollStatuses(state);
         const info = state.bottomLogLines.get(sk);
+        if (code !== 0 && code !== null) {
+            if (info)
+                info.action = 'restart_failed';
+            if (state.mode === state_1.MODE.LIST)
+                render(state);
+            return;
+        }
         if (info) {
             info.action = 'started';
             info.lines = [];
@@ -438,9 +492,16 @@ function doStop(state) {
     state.stopping.set(sk, child);
     state.bottomLogLines.set(sk, { action: 'stopping', service: entry.service, lines: [] });
     render(state);
-    child.on('close', () => {
+    child.on('close', (code) => {
         state.stopping.delete(sk);
-        state.bottomLogLines.delete(sk);
+        if (code !== 0 && code !== null) {
+            const info = state.bottomLogLines.get(sk);
+            if (info)
+                info.action = 'stop_failed';
+        }
+        else {
+            state.bottomLogLines.delete(sk);
+        }
         pollStatuses(state);
         if (state.mode === state_1.MODE.LIST)
             render(state);
@@ -460,10 +521,17 @@ function doStart(state) {
     state.starting.set(sk, child);
     state.bottomLogLines.set(sk, { action: 'starting', service: entry.service, lines: [] });
     render(state);
-    child.on('close', () => {
+    child.on('close', (code) => {
         state.starting.delete(sk);
         pollStatuses(state);
         const info = state.bottomLogLines.get(sk);
+        if (code !== 0 && code !== null) {
+            if (info)
+                info.action = 'start_failed';
+            if (state.mode === state_1.MODE.LIST)
+                render(state);
+            return;
+        }
         if (info) {
             info.action = 'started';
             info.lines = [];
@@ -633,10 +701,9 @@ function executeCascadeStep(state, file, sk, cascade) {
         return;
     }
     step.status = 'in_progress';
-    const maxLines = state.config.bottomLogCount || 10;
     let child;
     if (step.action === 'rebuild') {
-        child = (0, docker_1.rebuildService)(file, step.service, { noCache: state.noCache });
+        child = (0, docker_1.rebuildService)(file, step.service, { noCache: state.noCache, noDeps: state.noDeps });
     }
     else {
         child = (0, docker_1.restartService)(file, step.service);
@@ -654,8 +721,11 @@ function executeCascadeStep(state, file, sk, cascade) {
         if (newLines.length === 0)
             return;
         info.lines.push(...newLines);
-        if (info.lines.length > maxLines)
-            info.lines = info.lines.slice(-maxLines);
+        if (state.mode === state_1.MODE.LOGS && state.logBuildKey === sk) {
+            state.logLines.push(...newLines);
+            if (state.logAutoScroll)
+                throttledRender(state);
+        }
         if (state.mode === state_1.MODE.LIST)
             throttledRender(state);
     };
@@ -753,13 +823,18 @@ function isCdCommand(cmd) {
         return null;
     return match[2] ? match[2].trim() : '';
 }
+function shellEscape(str) {
+    return "'" + str.replace(/'/g, "'\\''") + "'";
+}
 function runExecCommand(state) {
     const cmd = state.execInput.trim();
     if (!cmd || !state.execContainerId)
         return;
-    // Add to history
+    // Add to history (capped at 1000 entries)
     if (state.execHistory.length === 0 || state.execHistory[state.execHistory.length - 1] !== cmd) {
         state.execHistory.push(cmd);
+        if (state.execHistory.length > 1000)
+            state.execHistory.shift();
     }
     state.execHistoryIdx = -1;
     state.execInput = '';
@@ -772,7 +847,7 @@ function runExecCommand(state) {
     // Handle cd commands — resolve new working directory
     const cdTarget = isCdCommand(cmd);
     if (cdTarget !== null) {
-        const resolveCmd = cdTarget ? `cd ${cdTarget} && pwd` : 'cd && pwd';
+        const resolveCmd = cdTarget ? `cd ${shellEscape(cdTarget)} && pwd` : 'cd && pwd';
         const child = (0, docker_1.execInContainer)(state.execContainerId, resolveCmd, state.execCwd || undefined);
         state.execChild = child;
         let stdout = '';
@@ -785,8 +860,9 @@ function runExecCommand(state) {
             if (code === 0) {
                 const lines = stdout.trim().split('\n');
                 const newCwd = lines[lines.length - 1].trim();
-                if (newCwd)
+                if (newCwd && newCwd.startsWith('/') && newCwd.length < 4096 && !/[\x00-\x1f]/.test(newCwd)) {
                     state.execCwd = newCwd;
+                }
             }
             else {
                 const errLines = stderr.trim().split('\n').filter(Boolean);
@@ -841,44 +917,65 @@ function enterLogs(state) {
         clearTimeout(moduleState.logFetchTimer);
         moduleState.logFetchTimer = null;
     }
+    // Carry over bottom panel search query to full log search
+    const carryQuery = state.bottomSearchQuery || '';
+    clearBottomSearch(state);
+    const sk = (0, state_1.statusKey)(entry.file, entry.service);
+    const info = state.bottomLogLines.get(sk);
+    const isBuilding = state.rebuilding.has(sk) || state.cascading.has(sk);
+    const isBuildFailed = info && info.action === 'build_failed';
     state.mode = state_1.MODE.LOGS;
     state.logLines = [];
     state.logScrollOffset = 0;
     state.logAutoScroll = true;
-    state.logSearchQuery = '';
+    state.logSearchQuery = carryQuery;
     state.logSearchActive = false;
     state.logSearchMatches = [];
     state.logSearchMatchIdx = -1;
-    const child = (0, docker_1.tailLogs)(entry.file, entry.service, state.config.logTailLines);
-    state.logChild = child;
-    let lineBuf = '';
-    const onData = (data) => {
-        lineBuf += data.toString();
-        const parts = lineBuf.split(/\r?\n|\r/);
-        lineBuf = parts.pop();
-        if (parts.length === 0)
-            return;
-        for (const line of parts) {
-            state.logLines.push(stripAnsi(line));
+    state.logFetchedTailCount = 200;
+    state.logHistoryLoaded = false;
+    state.logHistoryLoading = false;
+    state.logSearchPending = !!carryQuery;
+    state.logHistoryChild = null;
+    if (isBuilding || isBuildFailed) {
+        // Show build output instead of runtime logs
+        state.logBuildKey = sk;
+        if (info) {
+            state.logLines = [...info.lines];
         }
-        if (state.logLines.length > 10000) {
-            const excess = state.logLines.length - 10000;
-            state.logLines.splice(0, excess);
-            if (!state.logAutoScroll) {
-                state.logScrollOffset = Math.max(0, state.logScrollOffset - excess);
+        state.logHistoryLoaded = true;
+    }
+    else {
+        state.logBuildKey = null;
+        const child = (0, docker_1.tailLogs)(entry.file, entry.service, 200);
+        state.logChild = child;
+        let lineBuf = '';
+        const onData = (data) => {
+            lineBuf += data.toString();
+            const parts = lineBuf.split(/\r?\n|\r/);
+            lineBuf = parts.pop();
+            if (parts.length === 0)
+                return;
+            for (const line of parts) {
+                state.logLines.push(stripAnsi(line));
             }
+            if (state.logAutoScroll) {
+                throttledRender(state);
+            }
+        };
+        child.stdout.on('data', onData);
+        child.stderr.on('data', onData);
+        child.on('close', () => {
+            if (state.logChild === child) {
+                state.logChild = null;
+            }
+        });
+        // If carrying a search query from bottom panel, load full history to search
+        if (carryQuery) {
+            state.logFetchedTailCount = 5000;
+            loadMoreLogHistory(state);
         }
-        if (state.logAutoScroll) {
-            throttledRender(state);
-        }
-    };
-    child.stdout.on('data', onData);
-    child.stderr.on('data', onData);
-    child.on('close', () => {
-        if (state.logChild === child) {
-            state.logChild = null;
-        }
-    });
+    }
     render(state);
 }
 function exitLogs(state) {
@@ -886,11 +983,72 @@ function exitLogs(state) {
         state.logChild.kill('SIGTERM');
         state.logChild = null;
     }
+    if (state.logHistoryChild) {
+        state.logHistoryChild.kill('SIGTERM');
+        state.logHistoryChild = null;
+    }
     state.logLines = [];
+    state.logBuildKey = null;
+    state.logHistoryLoaded = false;
+    state.logHistoryLoading = false;
+    state.logSearchPending = false;
     state.mode = state_1.MODE.LIST;
     pollStatuses(state);
     render(state);
 }
+// --- Log History Loading ---
+function loadMoreLogHistory(state) {
+    if (state.logHistoryLoaded || state.logHistoryLoading)
+        return;
+    const entry = (0, state_1.selectedEntry)(state);
+    if (!entry)
+        return;
+    // Escalate: 200 → 1000 → 5000 → all
+    let nextTail;
+    if (state.logFetchedTailCount < 1000)
+        nextTail = 1000;
+    else if (state.logFetchedTailCount < 5000)
+        nextTail = 5000;
+    else
+        nextTail = 'all';
+    state.logHistoryLoading = true;
+    const snapshotLen = state.logLines.length;
+    const child = (0, docker_1.fetchServiceLogs)(entry.file, entry.service, nextTail);
+    state.logHistoryChild = child;
+    let output = '';
+    child.stdout.on('data', (d) => { output += d.toString(); });
+    child.stderr.on('data', (d) => { output += d.toString(); });
+    child.on('close', () => {
+        if (state.logHistoryChild === child) {
+            state.logHistoryChild = null;
+        }
+        state.logHistoryLoading = false;
+        const fetchedLines = output.split(/\r?\n|\r/).filter(l => l.length > 0).map(stripAnsi).filter(Boolean);
+        if (fetchedLines.length <= snapshotLen) {
+            // No more history available
+            state.logHistoryLoaded = true;
+        }
+        else {
+            // Merge: fetched history + any new lines that arrived during the fetch
+            const newLiveLines = state.logLines.slice(snapshotLen);
+            const oldOffset = state.logScrollOffset;
+            const added = fetchedLines.length - snapshotLen;
+            state.logLines = [...fetchedLines, ...newLiveLines];
+            // Adjust scroll offset to maintain visual position
+            if (!state.logAutoScroll) {
+                state.logScrollOffset = oldOffset + added;
+            }
+            state.logFetchedTailCount = nextTail === 'all' ? Infinity : nextTail;
+            if (nextTail === 'all')
+                state.logHistoryLoaded = true;
+        }
+        if (state.logSearchPending) {
+            state.logSearchPending = false;
+            executeLogSearch(state);
+        }
+        render(state);
+    });
+}
 // --- Log Search ---
 function executeLogSearch(state) {
     const query = state.logSearchQuery;
@@ -914,7 +1072,8 @@ function scrollToLogLine(state, lineIdx) {
     const headerHeight = 9;
     const availableRows = Math.max(1, rows - headerHeight);
     const totalLines = state.logLines.length;
-    state.logScrollOffset = Math.max(0, totalLines - lineIdx - Math.floor(availableRows / 2));
+    const maxOffset = Math.max(0, totalLines - availableRows);
+    state.logScrollOffset = Math.min(maxOffset, Math.max(0, totalLines - lineIdx - Math.floor(availableRows / 2)));
     state.logAutoScroll = state.logScrollOffset === 0;
     render(state);
 }
@@ -930,6 +1089,78 @@ function jumpToPrevMatch(state) {
     state.logSearchMatchIdx = (state.logSearchMatchIdx - 1 + state.logSearchMatches.length) % state.logSearchMatches.length;
     scrollToLogLine(state, state.logSearchMatches[state.logSearchMatchIdx]);
 }
+// --- Bottom Panel Search ---
+function executeBottomSearch(state) {
+    const entry = (0, state_1.selectedEntry)(state);
+    if (!entry || !state.bottomSearchQuery)
+        return;
+    const sk = (0, state_1.statusKey)(entry.file, entry.service);
+    const info = state.bottomLogLines.get(sk);
+    if (!info)
+        return;
+    // Save current tail lines so we can restore them later
+    if (!state.bottomSearchSavedLines.has(sk)) {
+        state.bottomSearchSavedLines.set(sk, [...info.lines]);
+    }
+    // Kill any previous search fetch
+    if (state.bottomSearchChild) {
+        state.bottomSearchChild.kill('SIGTERM');
+        state.bottomSearchChild = null;
+    }
+    state.bottomSearchLoading = true;
+    state.bottomSearchTotalMatches = 0;
+    render(state);
+    const child = (0, docker_1.fetchServiceLogs)(entry.file, entry.service, 'all');
+    state.bottomSearchChild = child;
+    let output = '';
+    child.stdout.on('data', (d) => { output += d.toString(); });
+    child.stderr.on('data', (d) => { output += d.toString(); });
+    child.on('close', () => {
+        if (state.bottomSearchChild !== child)
+            return; // superseded
+        state.bottomSearchChild = null;
+        state.bottomSearchLoading = false;
+        const query = state.bottomSearchQuery;
+        if (!query) {
+            clearBottomSearch(state);
+            render(state);
+            return;
+        }
+        const lowerQuery = query.toLowerCase();
+        const allLines = output.split(/\r?\n|\r/).filter(l => l.trim().length > 0).map(stripAnsi).filter(Boolean);
+        const matchingLines = [];
+        for (const line of allLines) {
+            if (line.toLowerCase().includes(lowerQuery)) {
+                matchingLines.push(line);
+            }
+        }
+        state.bottomSearchTotalMatches = matchingLines.length;
+        // Show the last N matching lines in the bottom panel
+        const maxLines = state.config.bottomLogCount || 10;
+        const currentInfo = state.bottomLogLines.get(sk);
+        if (currentInfo) {
+            currentInfo.lines = matchingLines.slice(-maxLines);
+        }
+        if (state.mode === state_1.MODE.LIST)
+            render(state);
+    });
+}
+function clearBottomSearch(state) {
+    if (state.bottomSearchChild) {
+        state.bottomSearchChild.kill('SIGTERM');
+        state.bottomSearchChild = null;
+    }
+    state.bottomSearchLoading = false;
+    state.bottomSearchTotalMatches = 0;
+    // Restore saved tail lines
+    if (state.selectedLogKey && state.bottomSearchSavedLines.has(state.selectedLogKey)) {
+        const info = state.bottomLogLines.get(state.selectedLogKey);
+        if (info) {
+            info.lines = state.bottomSearchSavedLines.get(state.selectedLogKey);
+        }
+        state.bottomSearchSavedLines.delete(state.selectedLogKey);
+    }
+}
 // --- Input Handling ---
 function handleKeypress(state, key) {
     if (key === '\x03' && state.mode !== state_1.MODE.EXEC && !state.execActive) {
@@ -1002,8 +1233,22 @@ function handleKeypress(state, key) {
             }
             else if (key === '\r') {
                 state.logSearchActive = false;
-                executeLogSearch(state);
-                render(state);
+                if (!state.logHistoryLoaded && !state.logHistoryLoading) {
+                    // Load all history, then search
+                    state.logSearchPending = true;
+                    state.logFetchedTailCount = 5000; // jump straight to 'all'
+                    loadMoreLogHistory(state);
+                    render(state);
+                }
+                else if (state.logHistoryLoading) {
+                    // Already loading — search will run when it finishes
+                    state.logSearchPending = true;
+                    render(state);
+                }
+                else {
+                    executeLogSearch(state);
+                    render(state);
+                }
             }
             else if (key === '\x7f' || key === '\b') {
                 state.logSearchQuery = state.logSearchQuery.slice(0, -1);
@@ -1017,12 +1262,31 @@ function handleKeypress(state, key) {
         }
         const rows = process.stdout.rows ?? 24;
         const pageSize = Math.max(1, Math.floor(rows / 2));
-        const maxOffset = Math.max(0, state.logLines.length - 1);
+        const availableRows = Math.max(1, rows - 9);
+        const maxOffset = Math.max(0, state.logLines.length - availableRows);
+        // Trigger lazy history load when scrolled near the top
+        const checkLoadMore = () => {
+            const availableRows = Math.max(1, rows - 9);
+            const linesFromTop = state.logLines.length - state.logScrollOffset - availableRows;
+            if (linesFromTop < availableRows) {
+                loadMoreLogHistory(state);
+            }
+        };
         switch (key) {
             case 'f':
-            case '\x1b':
                 exitLogs(state);
                 break;
+            case '\x1b':
+                if (state.logSearchQuery) {
+                    state.logSearchQuery = '';
+                    state.logSearchMatches = [];
+                    state.logSearchMatchIdx = -1;
+                    render(state);
+                }
+                else {
+                    exitLogs(state);
+                }
+                break;
             case 'q':
                 cleanup(state);
                 process.exit(0);
@@ -1031,6 +1295,7 @@ function handleKeypress(state, key) {
             case '\x1b[A':
                 state.logAutoScroll = false;
                 state.logScrollOffset = Math.min(maxOffset, state.logScrollOffset + 1);
+                checkLoadMore();
                 render(state);
                 break;
             case 'j':
@@ -1050,6 +1315,7 @@ function handleKeypress(state, key) {
             case '\x15': // Ctrl+U
                 state.logAutoScroll = false;
                 state.logScrollOffset = Math.min(maxOffset, state.logScrollOffset + pageSize);
+                checkLoadMore();
                 render(state);
                 break;
             case '\x04': // Ctrl+D
@@ -1135,10 +1401,14 @@ function handleKeypress(state, key) {
         if (key === '\x1b') {
             state.bottomSearchActive = false;
             state.bottomSearchQuery = '';
+            clearBottomSearch(state);
             render(state);
         }
         else if (key === '\r') {
             state.bottomSearchActive = false;
+            if (state.bottomSearchQuery) {
+                executeBottomSearch(state);
+            }
             render(state);
         }
         else if (key === '\x7f' || key === '\b') {
@@ -1201,6 +1471,10 @@ function handleKeypress(state, key) {
             state.noCache = !state.noCache;
             render(state);
             break;
+        case 'o':
+            state.noDeps = !state.noDeps;
+            render(state);
+            break;
         case 'f':
         case '\r':
             enterLogs(state);
@@ -1276,7 +1550,14 @@ function createInputHandler(state) {
                     }
                     else if (state.mode === state_1.MODE.LOGS) {
                         state.logAutoScroll = false;
-                        state.logScrollOffset = Math.max(0, state.logLines.length - 1);
+                        const ggRows = process.stdout.rows ?? 24;
+                        const ggAvailable = Math.max(1, ggRows - 9);
+                        state.logScrollOffset = Math.max(0, state.logLines.length - ggAvailable);
+                        // Load all history so we can scroll to the very top
+                        if (!state.logHistoryLoaded) {
+                            state.logFetchedTailCount = 5000; // jump to 'all'
+                            loadMoreLogHistory(state);
+                        }
                     }
                     render(state);
                     continue;
@@ -1330,6 +1611,10 @@ function cleanup(state) {
         state.execChild = null;
     }
     state.execActive = false;
+    if (state.bottomSearchChild) {
+        state.bottomSearchChild.kill('SIGTERM');
+        state.bottomSearchChild = null;
+    }
     for (const [, child] of state.bottomLogTails) {
         child.kill('SIGTERM');
     }