recomposable 1.1.2 → 1.1.4

package/dist/index.js

@@ -8,6 +8,7 @@ exports.createModuleState = createModuleState;
 exports.loadConfig = loadConfig;
 exports.discoverServices = discoverServices;
 exports.pollStatuses = pollStatuses;
+exports.detectMultipleWorktrees = detectMultipleWorktrees;
 exports.pollLogCounts = pollLogCounts;
 exports.pollContainerStats = pollContainerStats;
 exports.render = render;
@@ -18,18 +19,25 @@ exports.doRebuild = doRebuild;
 exports.doRestart = doRestart;
 exports.doStop = doStop;
 exports.doStart = doStart;
+exports.mapComposeFileToWorktree = mapComposeFileToWorktree;
+exports.openWorktreePicker = openWorktreePicker;
+exports.doWorktreeSwitch = doWorktreeSwitch;
 exports.doWatch = doWatch;
 exports.initDepGraphs = initDepGraphs;
 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;
@@ -56,7 +64,7 @@ function loadConfig() {
         composeFiles: [],
         pollInterval: 3000,
         logTailLines: 100,
-        logScanPatterns: ['WRN]', 'ERR]'],
+        logScanPatterns: [['WRN]', 'WARNING'], ['ERR]', 'ERROR']],
         logScanLines: 1000,
         logScanInterval: 10000,
         statsInterval: 5000,
@@ -69,7 +77,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' || (Array.isArray(p) && p.length > 0 && p.every((s) => typeof s === '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 = [];
@@ -108,14 +142,41 @@ function discoverServices(config) {
 }
 // --- Status Polling ---
 function pollStatuses(state) {
+    // Collect services by their effective file (may differ from group file due to worktree overrides)
+    const fileToServices = new Map();
     for (const group of state.groups) {
         if (group.error)
             continue;
-        const statuses = (0, docker_1.getStatuses)(group.file);
+        for (const service of group.services) {
+            const sk = (0, state_1.statusKey)(group.file, service);
+            const file = (0, state_1.getEffectiveFile)(state, group.file, service);
+            if (!fileToServices.has(file))
+                fileToServices.set(file, []);
+            fileToServices.get(file).push({ sk, service });
+        }
+    }
+    for (const [file, services] of fileToServices) {
+        const statuses = (0, docker_1.getStatuses)(file);
+        const serviceSet = new Set(services.map(s => s.service));
         for (const [svc, st] of statuses) {
-            state.statuses.set((0, state_1.statusKey)(group.file, svc), st);
+            if (serviceSet.has(svc)) {
+                // Store under the original statusKey (group.file based)
+                const match = services.find(s => s.service === svc);
+                if (match)
+                    state.statuses.set(match.sk, st);
+            }
         }
     }
+    detectMultipleWorktrees(state);
+}
+function detectMultipleWorktrees(state) {
+    const worktrees = new Set();
+    for (const st of state.statuses.values()) {
+        if (st.state === 'running' && st.worktree) {
+            worktrees.add(st.worktree);
+        }
+    }
+    state.showWorktreeColumn = worktrees.size > 1;
 }
 // --- Log Pattern Scanning ---
 function pollLogCounts(state) {
@@ -148,14 +209,18 @@ function pollLogCounts(state) {
         child.stderr.on('data', (d) => { output += d.toString(); });
         child.on('close', () => {
             const counts = new Map();
-            for (const pattern of scanPatterns) {
+            for (const entry of scanPatterns) {
+                const group = Array.isArray(entry) ? entry : [entry];
+                const key = group[0];
                 let count = 0;
-                let idx = 0;
-                while ((idx = output.indexOf(pattern, idx)) !== -1) {
-                    count++;
-                    idx += pattern.length;
+                for (const pattern of group) {
+                    let idx = 0;
+                    while ((idx = output.indexOf(pattern, idx)) !== -1) {
+                        count++;
+                        idx += pattern.length;
+                    }
                 }
-                counts.set(pattern, count);
+                counts.set(key, count);
             }
             state.logCounts.set(sk, counts);
             remaining--;
@@ -244,20 +309,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 +355,7 @@ function updateSelectedLogs(state) {
         return;
     state.bottomSearchQuery = '';
     state.bottomSearchActive = false;
+    clearBottomSearch(state);
     if (moduleState.logFetchTimer) {
         clearTimeout(moduleState.logFetchTimer);
         moduleState.logFetchTimer = null;
@@ -304,9 +376,10 @@ function updateSelectedLogs(state) {
     if (state.bottomLogLines.has(sk))
         return;
     state.bottomLogLines.set(sk, { action: 'logs', service: entry.service, lines: [] });
+    const effectiveFile = (0, state_1.getEffectiveFile)(state, entry.file, entry.service);
     moduleState.logFetchTimer = setTimeout(() => {
         moduleState.logFetchTimer = null;
-        startBottomLogTail(state, sk, entry.file, entry.service);
+        startBottomLogTail(state, sk, effectiveFile, entry.service);
     }, 500);
 }
 function startBottomLogTail(state, sk, file, service) {
@@ -347,11 +420,12 @@ function doRebuild(state) {
     const sk = (0, state_1.statusKey)(entry.file, entry.service);
     if (state.rebuilding.has(sk))
         return;
+    const effectiveFile = (0, state_1.getEffectiveFile)(state, entry.file, entry.service);
     if (state.bottomLogTails.has(sk)) {
         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)(effectiveFile, 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,26 +440,36 @@ 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);
+        startBottomLogTail(state, sk, effectiveFile, entry.service);
         if (state.mode === state_1.MODE.LIST)
             render(state);
     });
@@ -397,25 +481,33 @@ function doRestart(state) {
     const sk = (0, state_1.statusKey)(entry.file, entry.service);
     if (state.restarting.has(sk) || state.rebuilding.has(sk))
         return;
+    const effectiveFile = (0, state_1.getEffectiveFile)(state, entry.file, entry.service);
     if (state.bottomLogTails.has(sk)) {
         state.bottomLogTails.get(sk).kill('SIGTERM');
         state.bottomLogTails.delete(sk);
     }
-    const child = (0, docker_1.restartService)(entry.file, entry.service);
+    const child = (0, docker_1.restartService)(effectiveFile, entry.service);
     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 = [];
         }
-        startBottomLogTail(state, sk, entry.file, entry.service);
+        startBottomLogTail(state, sk, effectiveFile, entry.service);
         if (state.mode === state_1.MODE.LIST)
             render(state);
     });
@@ -434,13 +526,21 @@ function doStop(state) {
         state.bottomLogTails.get(sk).kill('SIGTERM');
         state.bottomLogTails.delete(sk);
     }
-    const child = (0, docker_1.stopService)(entry.file, entry.service);
+    const effectiveFile = (0, state_1.getEffectiveFile)(state, entry.file, entry.service);
+    const child = (0, docker_1.stopService)(effectiveFile, entry.service);
     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);
@@ -456,23 +556,184 @@ function doStart(state) {
     const st = state.statuses.get(sk);
     if (st && st.state === 'running')
         return;
-    const child = (0, docker_1.startService)(entry.file, entry.service);
+    const effectiveFile = (0, state_1.getEffectiveFile)(state, entry.file, entry.service);
+    const child = (0, docker_1.startService)(effectiveFile, entry.service);
     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 = [];
         }
-        startBottomLogTail(state, sk, entry.file, entry.service);
+        startBottomLogTail(state, sk, effectiveFile, entry.service);
         if (state.mode === state_1.MODE.LIST)
             render(state);
     });
 }
+// --- Worktree Switching ---
+function mapComposeFileToWorktree(composeFile, targetWorktreePath) {
+    const resolved = path_1.default.resolve(composeFile);
+    const dir = path_1.default.dirname(resolved);
+    const gitRoot = (0, docker_1.getGitRoot)(dir);
+    if (!gitRoot)
+        return null;
+    const relPath = path_1.default.relative(gitRoot, resolved);
+    const newFile = path_1.default.join(targetWorktreePath, relPath);
+    try {
+        fs_1.default.accessSync(newFile);
+        return newFile;
+    }
+    catch {
+        return null;
+    }
+}
+function openWorktreePicker(state) {
+    const entry = (0, state_1.selectedEntry)(state);
+    if (!entry)
+        return;
+    const sk = (0, state_1.statusKey)(entry.file, entry.service);
+    if (state.rebuilding.has(sk) || state.restarting.has(sk) || state.stopping.has(sk) || state.starting.has(sk) || state.cascading.has(sk))
+        return;
+    const composeDir = path_1.default.dirname(path_1.default.resolve(entry.file));
+    const worktrees = (0, docker_1.listGitWorktrees)(composeDir);
+    if (worktrees.length <= 1) {
+        state.bottomLogLines.set(sk, { action: 'switch_failed', service: entry.service, lines: ['no other worktrees available — use `git worktree add` to create one'] });
+        state.showBottomLogs = true;
+        render(state);
+        return;
+    }
+    const gitRoot = (0, docker_1.getGitRoot)(composeDir);
+    state.worktreePickerEntries = worktrees;
+    state.worktreePickerActive = true;
+    state.worktreePickerCurrentPath = gitRoot;
+    // Pre-select first non-current worktree
+    const currentIdx = gitRoot ? worktrees.findIndex(w => w.path === gitRoot) : -1;
+    const firstOther = worktrees.findIndex((_, i) => i !== currentIdx);
+    state.worktreePickerCursor = firstOther >= 0 ? firstOther : 0;
+    state.showBottomLogs = true;
+    render(state);
+}
+function doWorktreeSwitch(state, targetWorktree) {
+    const entry = (0, state_1.selectedEntry)(state);
+    if (!entry)
+        return;
+    const service = entry.service;
+    const sk = (0, state_1.statusKey)(entry.file, service);
+    // Close picker
+    state.worktreePickerActive = false;
+    state.worktreePickerEntries = [];
+    state.worktreePickerCursor = 0;
+    // Compute new file from the original group file
+    const newFile = mapComposeFileToWorktree(entry.file, targetWorktree.path);
+    if (!newFile) {
+        state.bottomLogLines.set(sk, {
+            action: 'switch_failed', service,
+            lines: [`compose file not found in worktree "${targetWorktree.branch}" (${targetWorktree.path})`],
+        });
+        render(state);
+        return;
+    }
+    // If target is the same as current effective file, nothing to do
+    const currentEffective = (0, state_1.getEffectiveFile)(state, entry.file, service);
+    if (newFile === currentEffective) {
+        render(state);
+        return;
+    }
+    // Validate service exists in target compose file
+    if (!(0, docker_1.validateServiceInComposeFile)(newFile, service)) {
+        state.bottomLogLines.set(sk, {
+            action: 'switch_failed', service,
+            lines: [`service "${service}" not found in ${path_1.default.basename(newFile)} on branch "${targetWorktree.branch}"`],
+        });
+        render(state);
+        return;
+    }
+    // Show switching progress
+    state.bottomLogLines.set(sk, { action: 'switching', service, lines: [`switching to worktree "${targetWorktree.branch}"...`] });
+    render(state);
+    const performSwitch = () => {
+        // Store the worktree override (or remove if switching back to original)
+        if (newFile === entry.file) {
+            state.worktreeOverrides.delete(sk);
+        }
+        else {
+            state.worktreeOverrides.set(sk, newFile);
+        }
+        // Update bottomLogLines to show rebuild
+        state.bottomLogLines.set(sk, { action: 'switching', service, lines: [`rebuilding in worktree "${targetWorktree.branch}"...`] });
+        // Rebuild in new worktree
+        const child = (0, docker_1.rebuildService)(newFile, service, { noCache: state.noCache, noDeps: state.noDeps });
+        state.rebuilding.set(sk, child);
+        let lineBuf = '';
+        const onData = (data) => {
+            const info = state.bottomLogLines.get(sk);
+            if (!info)
+                return;
+            lineBuf += data.toString();
+            const parts = lineBuf.split(/\r?\n|\r/);
+            lineBuf = parts.pop();
+            const newLines = parts.filter(l => l.trim().length > 0).map(stripAnsi).filter(Boolean);
+            if (newLines.length === 0)
+                return;
+            info.lines.push(...newLines);
+            if (state.mode === state_1.MODE.LIST)
+                throttledRender(state);
+        };
+        child.stdout.on('data', onData);
+        child.stderr.on('data', onData);
+        render(state);
+        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 = [];
+            }
+            startBottomLogTail(state, sk, newFile, service);
+            if (state.mode === state_1.MODE.LIST)
+                render(state);
+        });
+    };
+    // If service is running, stop it first (using current effective file)
+    const st = state.statuses.get(sk);
+    if (st && st.state === 'running') {
+        if (state.bottomLogTails.has(sk)) {
+            state.bottomLogTails.get(sk).kill('SIGTERM');
+            state.bottomLogTails.delete(sk);
+        }
+        const stopChild = (0, docker_1.stopService)(currentEffective, service);
+        state.stopping.set(sk, stopChild);
+        render(state);
+        stopChild.on('close', () => {
+            state.stopping.delete(sk);
+            performSwitch();
+        });
+    }
+    else {
+        performSwitch();
+    }
+}
 // --- Watch ---
 function doWatch(state) {
     const entry = (0, state_1.selectedEntry)(state);
@@ -500,7 +761,8 @@ function doWatch(state) {
         render(state);
         return;
     }
-    const child = (0, docker_1.watchService)(entry.file, entry.service);
+    const effectiveFile = (0, state_1.getEffectiveFile)(state, entry.file, entry.service);
+    const child = (0, docker_1.watchService)(effectiveFile, entry.service);
     state.watching.set(sk, child);
     state.bottomLogLines.set(sk, { action: 'watching', service: entry.service, lines: [] });
     state.showBottomLogs = true;
@@ -598,9 +860,21 @@ function doCascadeRebuild(state) {
     const sk = (0, state_1.statusKey)(entry.file, entry.service);
     if (state.rebuilding.has(sk) || state.cascading.has(sk))
         return;
-    const graph = state.depGraphs.get(entry.file);
+    const effectiveFile = (0, state_1.getEffectiveFile)(state, entry.file, entry.service);
+    let graph = state.depGraphs.get(effectiveFile);
+    if (!graph) {
+        // Try to parse dep graph for the effective file (may differ from original)
+        try {
+            graph = (0, docker_1.parseDependencyGraph)(effectiveFile);
+            state.depGraphs.set(effectiveFile, graph);
+        }
+        catch {
+            // No graph available, fall back to regular rebuild
+            doRebuild(state);
+            return;
+        }
+    }
     if (!graph) {
-        // No graph available, fall back to regular rebuild
         doRebuild(state);
         return;
     }
@@ -619,7 +893,7 @@ function doCascadeRebuild(state) {
     state.cascading.set(sk, cascade);
     state.bottomLogLines.set(sk, { action: 'cascading', service: entry.service, lines: [] });
     state.showBottomLogs = true;
-    executeCascadeStep(state, entry.file, sk, cascade);
+    executeCascadeStep(state, effectiveFile, sk, cascade);
     render(state);
 }
 function executeCascadeStep(state, file, sk, cascade) {
@@ -633,10 +907,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 +927,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 +1029,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 +1053,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 +1066,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 +1123,66 @@ 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 effectiveFile = (0, state_1.getEffectiveFile)(state, entry.file, entry.service);
+        const child = (0, docker_1.tailLogs)(effectiveFile, 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 +1190,73 @@ 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 effectiveFile = (0, state_1.getEffectiveFile)(state, entry.file, entry.service);
+    const child = (0, docker_1.fetchServiceLogs)(effectiveFile, 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 +1280,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 +1297,79 @@ 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 effectiveFile = (0, state_1.getEffectiveFile)(state, entry.file, entry.service);
+    const child = (0, docker_1.fetchServiceLogs)(effectiveFile, 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 +1442,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 +1471,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 +1504,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 +1524,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
@@ -1072,6 +1547,34 @@ function handleKeypress(state, key) {
         }
         return;
     }
+    // LIST mode - worktree picker
+    if (state.worktreePickerActive) {
+        if (key === '\x1b') {
+            state.worktreePickerActive = false;
+            state.worktreePickerEntries = [];
+            state.worktreePickerCursor = 0;
+            state.worktreePickerCurrentPath = null;
+            render(state);
+        }
+        else if (key === '\r') {
+            const target = state.worktreePickerEntries[state.worktreePickerCursor];
+            if (target)
+                doWorktreeSwitch(state, target);
+        }
+        else if (key === 'j' || key === '\x1b[B') {
+            state.worktreePickerCursor = Math.min(state.worktreePickerEntries.length - 1, state.worktreePickerCursor + 1);
+            render(state);
+        }
+        else if (key === 'k' || key === '\x1b[A') {
+            state.worktreePickerCursor = Math.max(0, state.worktreePickerCursor - 1);
+            render(state);
+        }
+        else if (key === 'G') {
+            state.worktreePickerCursor = state.worktreePickerEntries.length - 1;
+            render(state);
+        }
+        return;
+    }
     // LIST mode - inline exec input
     if (state.execActive) {
         if (key === '\x1b') {
@@ -1135,10 +1638,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 +1708,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);
@@ -1209,6 +1720,9 @@ function handleKeypress(state, key) {
             state.showBottomLogs = !state.showBottomLogs;
             render(state);
             break;
+        case 't':
+            openWorktreePicker(state);
+            break;
         case 'q':
             cleanup(state);
             process.exit(0);
@@ -1262,7 +1776,7 @@ function createInputHandler(state) {
             }
             const ch = buf[0];
             buf = buf.slice(1);
-            if (state.logSearchActive || state.bottomSearchActive || state.mode === state_1.MODE.EXEC || state.execActive) {
+            if (state.logSearchActive || state.bottomSearchActive || state.worktreePickerActive || state.mode === state_1.MODE.EXEC || state.execActive) {
                 handleKeypress(state, ch);
                 continue;
             }
@@ -1276,7 +1790,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 +1851,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');
     }
@@ -1351,7 +1876,7 @@ function cleanup(state) {
     if (state.statsTimer) {
         clearInterval(state.statsTimer);
     }
-    process.stdout.write('\x1b[r' + (0, renderer_1.showCursor)() + '\x1b[0m');
+    process.stdout.write('\x1b[r' + (0, renderer_1.showCursor)() + '\x1b[0m\x1b[?1049l');
 }
 // Expose for testing
 function _getModuleState() {
@@ -1362,6 +1887,8 @@ function _setModuleState(ms) {
 }
 // --- Main ---
 function main() {
+    // Enter alternate screen buffer so pre-launch output (e.g. npx install) is hidden
+    process.stdout.write('\x1b[?1049h');
     const config = loadConfig();
     const state = (0, state_1.createState)(config);
     state.groups = discoverServices(config);