tabminal 3.0.3 → 3.0.5

package/public/index.html

@@ -14,15 +14,33 @@
     <link rel="preconnect" href="https://cdn.jsdelivr.net">
     <script>
         const COMPACT_WORKSPACE_MAX_WIDTH = 767;
-        const COMPACT_WORKSPACE_MAX_SHORT_HEIGHT = 500;
         const COMPACT_WORKSPACE_MAX_LANDSCAPE_WIDTH = 950;
+        const COMPACT_WORKSPACE_ENTER_MAX_SHORT_HEIGHT = 500;
+        const COMPACT_WORKSPACE_EXIT_MAX_SHORT_HEIGHT = 540;
+        const SIDEBAR_LAYOUT_PAUSE_MS = 360;
+        let layoutLoopPausedUntil = 0;
 
-        function shouldUseCompactWorkspaceMode(width, height) {
-            return width <= COMPACT_WORKSPACE_MAX_WIDTH
-                || (
-                    width <= COMPACT_WORKSPACE_MAX_LANDSCAPE_WIDTH
-                    && height <= COMPACT_WORKSPACE_MAX_SHORT_HEIGHT
-                );
+        function shouldUseCompactWorkspaceMode(
+            width,
+            height,
+            previousCompactWorkspaceMode = false
+        ) {
+            if (width <= COMPACT_WORKSPACE_MAX_WIDTH) {
+                return true;
+            }
+
+            const isShortLandscapeCandidate = (
+                width > height
+                && width <= COMPACT_WORKSPACE_MAX_LANDSCAPE_WIDTH
+            );
+            if (!isShortLandscapeCandidate) {
+                return false;
+            }
+
+            const shortHeightThreshold = previousCompactWorkspaceMode
+                ? COMPACT_WORKSPACE_EXIT_MAX_SHORT_HEIGHT
+                : COMPACT_WORKSPACE_ENTER_MAX_SHORT_HEIGHT;
+            return height <= shortHeightThreshold;
         }
 
         // Mobile Layout Manager
@@ -46,12 +64,13 @@
             document.documentElement.style.setProperty('--app-top', `${offsetTop}px`);
             document.documentElement.style.setProperty('--app-left', `${offsetLeft}px`);
 
+            const previousCompactWorkspaceMode =
+                window.__tabminalCompactWorkspaceMode;
             const compactWorkspaceMode = shouldUseCompactWorkspaceMode(
                 width,
-                height
+                height,
+                previousCompactWorkspaceMode
             );
-            const previousCompactWorkspaceMode =
-                window.__tabminalCompactWorkspaceMode;
             window.__tabminalCompactWorkspaceMode = compactWorkspaceMode;
 
             if (document.body) {
@@ -94,6 +113,16 @@
             }
         }
 
+        function pauseLayoutLoop(duration = SIDEBAR_LAYOUT_PAUSE_MS) {
+            const now = performance.now();
+            layoutLoopPausedUntil = Math.max(
+                layoutLoopPausedUntil,
+                now + duration
+            );
+        }
+
+        window.__tabminalPauseLayoutLoop = pauseLayoutLoop;
+
         if (window.visualViewport) {
             window.visualViewport.addEventListener('resize', updateLayout);
             window.visualViewport.addEventListener('scroll', updateLayout);
@@ -103,13 +132,34 @@
 
         // High-performance Layout Loop (60fps)
         function layoutLoop() {
-            updateLayout();
+            if (performance.now() >= layoutLoopPausedUntil) {
+                updateLayout();
+            }
             requestAnimationFrame(layoutLoop);
         }
         layoutLoop();
 
         // Initial triggers
         document.addEventListener('DOMContentLoaded', updateLayout);
+        document.addEventListener('DOMContentLoaded', () => {
+            const sidebar = document.getElementById('sidebar');
+            if (!sidebar) {
+                return;
+            }
+            let sidebarOpen = sidebar.classList.contains('open');
+            const observer = new MutationObserver(() => {
+                const isOpen = sidebar.classList.contains('open');
+                if (isOpen === sidebarOpen) {
+                    return;
+                }
+                sidebarOpen = isOpen;
+                pauseLayoutLoop();
+            });
+            observer.observe(sidebar, {
+                attributes: true,
+                attributeFilter: ['class']
+            });
+        });
         window.addEventListener('load', updateLayout);
 
         // Enhanced Touch Interceptor with Boundary Check

package/public/styles.css

@@ -2241,7 +2241,7 @@ kbd {
     min-width: 0;
 }
 
-@media (max-width: 767px) {
+@media (max-width: 1408px) {
     .agent-panel-commands {
         display: none !important;
     }

package/src/acp-manager.mjs

@@ -941,6 +941,106 @@ function normalizePersistedTimelineOrder(value, fallback = 0) {
     return Number.isFinite(value) && value > 0 ? value : fallback;
 }
 
+function normalizeReplayMessageEntry(message = {}) {
+    return {
+        role: typeof message.role === 'string'
+            ? message.role
+            : 'assistant',
+        kind: typeof message.kind === 'string'
+            ? message.kind
+            : 'message',
+        text: typeof message.text === 'string'
+            ? message.text
+            : ''
+    };
+}
+
+export function createRestoreReplayState(messages = []) {
+    if (!Array.isArray(messages) || messages.length === 0) {
+        return null;
+    }
+    const replayMessages = messages
+        .map((message) => normalizeReplayMessageEntry(message))
+        .filter((message) => message.text);
+    if (replayMessages.length === 0) {
+        return null;
+    }
+    return {
+        messages: replayMessages,
+        index: -1,
+        offset: 0,
+        started: false,
+        exhausted: false
+    };
+}
+
+export function consumeRestoredMessageReplay(state, role, kind, text) {
+    if (!state || state.exhausted) {
+        return false;
+    }
+    const chunk = typeof text === 'string' ? text : '';
+    if (!chunk) {
+        return false;
+    }
+
+    const findReplayStart = () => {
+        for (let index = 0; index < state.messages.length; index += 1) {
+            const message = state.messages[index];
+            if (message.role !== role || message.kind !== kind) {
+                continue;
+            }
+            if (message.text.startsWith(chunk)) {
+                state.index = index;
+                state.offset = chunk.length;
+                state.started = true;
+                if (state.offset >= message.text.length) {
+                    state.index += 1;
+                    state.offset = 0;
+                }
+                if (state.index >= state.messages.length) {
+                    state.exhausted = true;
+                }
+                return true;
+            }
+        }
+        state.exhausted = true;
+        return false;
+    };
+
+    if (!state.started) {
+        return findReplayStart();
+    }
+    if (
+        state.index < 0
+        || state.index >= state.messages.length
+    ) {
+        state.exhausted = true;
+        return false;
+    }
+
+    const message = state.messages[state.index];
+    if (message.role !== role || message.kind !== kind) {
+        state.exhausted = true;
+        return false;
+    }
+
+    const remaining = message.text.slice(state.offset);
+    if (!remaining.startsWith(chunk)) {
+        state.exhausted = true;
+        return false;
+    }
+
+    state.offset += chunk.length;
+    if (state.offset >= message.text.length) {
+        state.index += 1;
+        state.offset = 0;
+    }
+    if (state.index >= state.messages.length) {
+        state.exhausted = true;
+    }
+    return true;
+}
+
 function normalizePersistedMessage(message = {}, fallbackOrder = 0) {
     const nextMessage = cloneSerializable(message, {}) || {};
     nextMessage.id = typeof nextMessage.id === 'string'
@@ -1479,6 +1579,7 @@ class AcpRuntime extends EventEmitter {
             syntheticStreams: new Map(),
             syntheticStreamTurn: 0,
             pendingUserEcho: null,
+            restoreReplay: null,
             currentModeId,
             availableModes,
             availableCommands,
@@ -1742,6 +1843,7 @@ class AcpRuntime extends EventEmitter {
             usage: meta.usage || null,
             terminals: meta.terminals || []
         });
+        tab.restoreReplay = createRestoreReplayState(meta.messages || []);
         tab.status = 'restoring';
         tab.busy = true;
 
@@ -1777,11 +1879,13 @@ class AcpRuntime extends EventEmitter {
                 tab.configOptions,
                 response?.models
             );
+            tab.restoreReplay = null;
             tab.status = 'ready';
             tab.busy = false;
             tab.errorMessage = '';
             return this.serializeTab(tab);
         } catch (error) {
+            tab.restoreReplay = null;
             this.tabs.delete(tab.id);
             this.sessionToTabId.delete(tab.acpSessionId);
             throw error;
@@ -2349,6 +2453,9 @@ class AcpRuntime extends EventEmitter {
         if (role === 'user' && kind === 'message' && this.#consumeUserEcho(tab, text)) {
             return;
         }
+        if (consumeRestoredMessageReplay(tab.restoreReplay, role, kind, text)) {
+            return;
+        }
         const streamKey = this.#getStreamKey(tab, update, role, kind);
         const last = tab.messages[tab.messages.length - 1] || null;
 
@@ -3147,6 +3254,32 @@ export class AcpManager {
         };
     }
 
+    async listInventory() {
+        return {
+            restoring: this.restoring,
+            tabs: Array.from(this.tabs.values()).map((entry) => {
+                const serialized = entry.serialize();
+                return {
+                    id: serialized.id,
+                    runtimeId: serialized.runtimeId,
+                    runtimeKey: serialized.runtimeKey,
+                    acpSessionId: serialized.acpSessionId,
+                    agentId: serialized.agentId,
+                    agentLabel: serialized.agentLabel,
+                    commandLabel: serialized.commandLabel,
+                    title: serialized.title,
+                    terminalSessionId: serialized.terminalSessionId,
+                    cwd: serialized.cwd,
+                    createdAt: serialized.createdAt,
+                    status: serialized.status,
+                    busy: serialized.busy,
+                    errorMessage: serialized.errorMessage,
+                    currentModeId: serialized.currentModeId
+                };
+            })
+        };
+    }
+
     async createTab(options) {
         await this.ensureConfigsLoaded();
         const definition = this.definitions.find(

package/src/persistence.mjs

@@ -37,6 +37,7 @@ export const saveSession = async (id, data) => {
             createdAt: data.createdAt,
             // Editor State
             editorState: data.editorState || {},
+            workspaceState: data.editorState || {},
             executions: data.executions || []
         };
         await fs.writeFile(filePath, JSON.stringify(serializable, null, 2));

package/src/server.mjs

@@ -216,8 +216,11 @@ router.all('/api/heartbeat', async (ctx) => {
                         const { cols, rows } = update.resize;
                         if (cols && rows) session.resize(cols, rows);
                     }
-                    if (update.editorState) {
-                        terminalManager.updateSessionState(session.id, { editorState: update.editorState });
+                    if (update.workspaceState || update.editorState) {
+                        terminalManager.updateSessionState(session.id, {
+                            workspaceState: update.workspaceState,
+                            editorState: update.editorState
+                        });
                     }
                     if (update.fileWrites) {
                         for (const file of update.fileWrites) {
@@ -235,6 +238,7 @@ router.all('/api/heartbeat', async (ctx) => {
 
     ctx.body = {
         sessions: terminalManager.listSessions(),
+        agents: await acpManager.listInventory(),
         system: systemMonitor.getStats(),
         runtime: {
             bootId: SERVER_BOOT_ID

package/src/terminal-manager.mjs

@@ -68,6 +68,59 @@ function clearBashPromptEnv(env) {
     }
 }
 
+function uniqueStringList(values) {
+    if (!Array.isArray(values)) return [];
+    return Array.from(new Set(
+        values.filter(
+            (value) => typeof value === 'string' && value.length > 0
+        )
+    ));
+}
+
+function normalizeWorkspaceState(input = {}, fallback = {}) {
+    const source = input && typeof input === 'object' ? input : {};
+    const base = fallback && typeof fallback === 'object' ? fallback : {};
+    return {
+        updatedAt: Number.isFinite(source.updatedAt)
+            ? source.updatedAt
+            : (
+                Number.isFinite(base.updatedAt)
+                    ? base.updatedAt
+                    : 0
+            ),
+        updatedBy: typeof source.updatedBy === 'string'
+            ? source.updatedBy
+            : (
+                typeof base.updatedBy === 'string'
+                    ? base.updatedBy
+                    : ''
+            ),
+        isVisible: !!source.isVisible,
+        openFiles: uniqueStringList(source.openFiles),
+        terminalDisplayMode: source.terminalDisplayMode === 'tab'
+            ? 'tab'
+            : 'auto',
+        expandedPaths: uniqueStringList(source.expandedPaths)
+    };
+}
+
+function compareWorkspaceState(left, right) {
+    const leftUpdatedAt = Number.isFinite(left?.updatedAt) ? left.updatedAt : 0;
+    const rightUpdatedAt = Number.isFinite(right?.updatedAt)
+        ? right.updatedAt
+        : 0;
+    if (leftUpdatedAt !== rightUpdatedAt) {
+        return leftUpdatedAt - rightUpdatedAt;
+    }
+    const leftUpdatedBy = typeof left?.updatedBy === 'string'
+        ? left.updatedBy
+        : '';
+    const rightUpdatedBy = typeof right?.updatedBy === 'string'
+        ? right.updatedBy
+        : '';
+    return leftUpdatedBy.localeCompare(rightUpdatedBy);
+}
+
 export class TerminalManager {
     constructor() {
         this.sessions = new Map();
@@ -228,7 +281,7 @@ precmd_functions+=(_tabminal_zsh_apply_prompt_marker)
             removeOnExit: options.removeOnExit !== false,
             enableAiHijack: options.enableAiHijack !== false,
             enableTitlePolling: options.enableTitlePolling !== false,
-            editorState: options.editorState,
+            editorState: normalizeWorkspaceState(options.editorState),
             executions: options.executions
         });
 
@@ -271,7 +324,7 @@ precmd_functions+=(_tabminal_zsh_apply_prompt_marker)
             rows: restoredData?.rows,
             createdAt: restoredData?.createdAt,
             title: restoredData?.title,
-            editorState: restoredData?.editorState,
+            editorState: restoredData?.workspaceState || restoredData?.editorState,
             executions: restoredData?.executions,
             restoreSnapshot: Boolean(restoredData),
             persistent: true,
@@ -326,9 +379,17 @@ precmd_functions+=(_tabminal_zsh_apply_prompt_marker)
     updateSessionState(id, data) {
         const session = this.sessions.get(id);
         if (session) {
-            // console.log(`[Manager] Updating session ${id} state:`, JSON.stringify(data));
-            if (data.editorState) {
-                session.editorState = { ...session.editorState, ...data.editorState };
+            const nextWorkspaceState = data.workspaceState || data.editorState;
+            if (nextWorkspaceState) {
+                const normalized = normalizeWorkspaceState(
+                    nextWorkspaceState,
+                    session.editorState
+                );
+                if (
+                    compareWorkspaceState(normalized, session.editorState) > 0
+                ) {
+                    session.editorState = normalized;
+                }
             }
             if (session.persistent) {
                 this.saveSessionState(session);
@@ -418,6 +479,7 @@ precmd_functions+=(_tabminal_zsh_apply_prompt_marker)
             exitStatus: s.exitStatus || null,
             managed: s.managed || null,
             editorState: s.editorState,
+            workspaceState: s.editorState,
             executions: s.executions
         }));
     }