tabminal 3.0.37 → 3.0.39

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tabminal",
-  "version": "3.0.37",
+  "version": "3.0.39",
   "description": "Tab(ter)minal, a Cloud-Native terminal and ACP agent workspace for desktop, tablet, and phone.",
   "type": "module",
   "bin": {

package/public/app.js

@@ -8213,6 +8213,14 @@ class EditorManager {
             if (!agentTab) return;
             const session = agentTab.getLinkedSession();
             if (!session) return;
+            this.#renderAgentCommandSuggestions([{
+                kind: 'info',
+                label: 'Opening previous session...',
+                description: command.displayName
+                    || command.title
+                    || command.sessionId
+                    || ''
+            }]);
             try {
                 let targetAgentTab = null;
                 let targetPromptDraft = '';
@@ -8265,11 +8273,13 @@ class EditorManager {
                     targetPromptDraft,
                     targetAgentTab || getActiveAgentTab() || agentTab
                 );
+                this.hideAgentCommandMenu();
             } catch (error) {
                 alert(error.message, {
                     type: 'error',
                     title: getAgentBaseName(agentTab)
                 });
+                this.hideAgentCommandMenu();
             }
             return;
         }
@@ -14719,27 +14729,54 @@ async function activateAgentTab(session, agentTab, options = {}) {
     return agentTab;
 }
 
+const pendingAgentHistoryResumes = new Map();
+
+function getAgentHistoryResumeKey(session, agentTab, historySession) {
+    return [
+        session?.server?.id || '',
+        session?.key || '',
+        agentTab?.agentId || '',
+        String(historySession?.sessionId || '').trim()
+    ].join('\0');
+}
+
 async function resumeAgentTabFromHistory(session, agentTab, historySession) {
     if (!session || !agentTab || !historySession?.sessionId) return null;
-    const response = await session.server.fetch('/api/agents/tabs/resume', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-            agentId: agentTab.agentId,
-            cwd: agentTab.cwd || session.cwd || session.initialCwd || '/',
-            terminalSessionId: session.id,
-            sessionId: historySession.sessionId,
-            title: historySession.title || ''
-        })
-    });
-    if (!response.ok) {
-        await throwResponseError(response, 'Failed to resume agent session');
+    const resumeKey = getAgentHistoryResumeKey(session, agentTab, historySession);
+    const pendingResume = pendingAgentHistoryResumes.get(resumeKey);
+    if (pendingResume) {
+        return await pendingResume;
+    }
+
+    const resumePromise = (async () => {
+        const response = await session.server.fetch('/api/agents/tabs/resume', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                agentId: agentTab.agentId,
+                cwd: agentTab.cwd || session.cwd || session.initialCwd || '/',
+                terminalSessionId: session.id,
+                sessionId: historySession.sessionId,
+                targetTabId: agentTab.id,
+                title: historySession.title || ''
+            })
+        });
+        if (!response.ok) {
+            await throwResponseError(response, 'Failed to resume agent session');
+        }
+        const data = await response.json();
+        return await activateAgentTab(
+            session,
+            upsertAgentTab(session.server, data)
+        );
+    })();
+    pendingAgentHistoryResumes.set(resumeKey, resumePromise);
+
+    try {
+        return await resumePromise;
+    } finally {
+        pendingAgentHistoryResumes.delete(resumeKey);
     }
-    const data = await response.json();
-    return await activateAgentTab(
-        session,
-        upsertAgentTab(session.server, data)
-    );
 }
 
 function getServerEndpointKey(server) {

package/src/acp-manager.mjs

@@ -2733,6 +2733,108 @@ class AcpRuntime extends EventEmitter {
         }
     }
 
+    #resetTabForSessionLoad(tab, meta) {
+        tab.acpSessionId = String(meta.acpSessionId || '').trim();
+        tab.terminalSessionId = meta.terminalSessionId || tab.terminalSessionId;
+        tab.cwd = meta.cwd || tab.cwd;
+        tab.createdAt = new Date().toISOString();
+        tab.title = meta.title || '';
+        tab.status = 'restoring';
+        tab.busy = true;
+        tab.errorMessage = '';
+        tab.messages = [];
+        tab.toolCalls = new Map();
+        tab.permissions = new Map();
+        tab.syntheticStreams = new Map();
+        tab.syntheticStreamTurn = 0;
+        tab.pendingUserEcho = null;
+        tab.plan = [];
+        tab.usage = null;
+        tab.terminals = new Map();
+        tab.messageCounter = 0;
+        tab.timelineCounter = 0;
+        tab.currentModeId = '';
+        tab.availableModes = [];
+        tab.availableCommands = [];
+        tab.configOptions = [];
+        tab.restoreCapture = createRestoreCaptureState([]);
+        tab.restoreCapture.nextTimelineOrder = () =>
+            this.#nextTimelineOrder(tab);
+    }
+
+    #restoreSerializedTab(tab, snapshot) {
+        tab.acpSessionId = snapshot.acpSessionId;
+        tab.terminalSessionId = snapshot.terminalSessionId || '';
+        tab.cwd = snapshot.cwd || tab.cwd;
+        tab.createdAt = snapshot.createdAt || tab.createdAt;
+        tab.status = snapshot.status || 'ready';
+        tab.busy = !!snapshot.busy;
+        tab.errorMessage = snapshot.errorMessage || '';
+        tab.syntheticStreams = new Map();
+        tab.pendingUserEcho = null;
+        tab.restoreCapture = null;
+        restorePersistedTabSnapshot(tab, snapshot);
+    }
+
+    async resumeIntoTab(tabId, meta) {
+        await this.start();
+        this.clearIdleShutdown();
+
+        const sessionCapabilities = this.#getSessionCapabilities();
+        if (!sessionCapabilities.load) {
+            throw new Error(
+                `${this.definition.label} does not support session restore`
+            );
+        }
+
+        const tab = this.tabs.get(tabId);
+        if (!tab) {
+            throw new Error('Agent tab not found');
+        }
+        if (tab.busy) {
+            throw new Error('Agent tab is already running');
+        }
+
+        const targetSessionId = String(meta.acpSessionId || '').trim();
+        if (!targetSessionId) {
+            throw new Error('sessionId is required');
+        }
+        const existingTabId = this.sessionToTabId.get(targetSessionId);
+        if (existingTabId && existingTabId !== tab.id) {
+            throw new Error('Session is already open');
+        }
+
+        const previousSnapshot = this.serializeTab(tab);
+        this.sessionToTabId.delete(tab.acpSessionId);
+        this.#resetTabForSessionLoad(tab, {
+            ...meta,
+            acpSessionId: targetSessionId
+        });
+        this.sessionToTabId.set(tab.acpSessionId, tab.id);
+        this.#broadcast(tab, {
+            type: 'snapshot',
+            tab: this.serializeTab(tab)
+        });
+
+        try {
+            await this.#loadSessionIntoTab(tab, meta);
+            this.#broadcast(tab, {
+                type: 'snapshot',
+                tab: this.serializeTab(tab)
+            });
+            return this.serializeTab(tab);
+        } catch (error) {
+            this.sessionToTabId.delete(tab.acpSessionId);
+            this.#restoreSerializedTab(tab, previousSnapshot);
+            this.sessionToTabId.set(tab.acpSessionId, tab.id);
+            this.#broadcast(tab, {
+                type: 'snapshot',
+                tab: this.serializeTab(tab)
+            });
+            throw error;
+        }
+    }
+
     async #loadSessionIntoTab(tab, meta) {
         try {
             const response = await this.connection.loadSession({
@@ -3890,6 +3992,7 @@ export class AcpManager {
         this.loadConfigs = options.loadConfigs || persistence.loadAgentConfigs;
         this.saveConfigs = options.saveConfigs || persistence.saveAgentConfigs;
         this.persistenceChain = Promise.resolve();
+        this.pendingResumeTabs = new Map();
         this.transcriptPersistDelayMs = options.transcriptPersistDelayMs
             || DEFAULT_TRANSCRIPT_PERSIST_DELAY_MS;
         this.persistTabsTimer = null;
@@ -4569,12 +4672,58 @@ export class AcpManager {
             return existingTab;
         }
 
+        const resumeKey = [
+            definition.id,
+            String(options.sessionId || '').trim()
+        ].join('\0');
+        const pendingResume = this.pendingResumeTabs.get(resumeKey);
+        if (pendingResume) {
+            return await pendingResume;
+        }
+
         const cwd = path.resolve(options.cwd || process.cwd());
+        const targetTabId = String(options.targetTabId || '').trim();
+        if (targetTabId) {
+            const tabEntry = this.tabs.get(targetTabId);
+            if (!tabEntry) {
+                throw new Error('Agent tab not found');
+            }
+            const currentSerialized = tabEntry.serialize();
+            if (currentSerialized.agentId !== definition.id) {
+                throw new Error('Agent mismatch');
+            }
+            const resumePromise = (async () => {
+                const rawSerialized = await tabEntry.runtime.resumeIntoTab(
+                    targetTabId,
+                    {
+                        acpSessionId: options.sessionId,
+                        cwd,
+                        terminalSessionId: options.terminalSessionId || '',
+                        title: options.title || ''
+                    }
+                );
+                const serialized = this.#applyRuntimeMetadataFallback(
+                    tabEntry.runtime,
+                    rawSerialized
+                );
+                this.#clearDefinitionAvailabilityOverride(definition.id);
+                await this.persistTabs();
+                return serialized;
+            })();
+            this.pendingResumeTabs.set(resumeKey, resumePromise);
+
+            try {
+                return await resumePromise;
+            } finally {
+                this.pendingResumeTabs.delete(resumeKey);
+            }
+        }
+
         const { runtimeEntry, createdRuntime, runtimeStoreKey } =
             this.#ensureRuntimeEntry(definition, cwd);
         const tabId = crypto.randomUUID();
 
-        try {
+        const resumePromise = (async () => {
             const rawSerialized = await runtimeEntry.runtime.resumeTab({
                 id: tabId,
                 acpSessionId: options.sessionId,
@@ -4603,6 +4752,11 @@ export class AcpManager {
             this.#clearDefinitionAvailabilityOverride(definition.id);
             await this.persistTabs();
             return tabEntry.serialize();
+        })();
+        this.pendingResumeTabs.set(resumeKey, resumePromise);
+
+        try {
+            return await resumePromise;
         } catch (error) {
             const shouldDisposeRuntime = createdRuntime
                 || runtimeEntry.runtime.tabs.size === 0;
@@ -4610,6 +4764,8 @@ export class AcpManager {
                 await this.#disposeRuntimeEntry(runtimeStoreKey, runtimeEntry);
             }
             throw error;
+        } finally {
+            this.pendingResumeTabs.delete(resumeKey);
         }
     }
 

package/src/server.mjs

@@ -615,7 +615,7 @@ router.post('/api/agents/tabs', async (ctx) => {
 });
 
 router.post('/api/agents/tabs/resume', async (ctx) => {
-    const { agentId, cwd, terminalSessionId, sessionId, title } =
+    const { agentId, cwd, terminalSessionId, sessionId, targetTabId, title } =
         ctx.request.body || {};
     if (!agentId || typeof agentId !== 'string') {
         ctx.status = 400;
@@ -639,6 +639,7 @@ router.post('/api/agents/tabs/resume', async (ctx) => {
             agentId,
             cwd,
             sessionId,
+            targetTabId: typeof targetTabId === 'string' ? targetTabId : '',
             title: typeof title === 'string' ? title : '',
             terminalSessionId: typeof terminalSessionId === 'string'
                 ? terminalSessionId