tabminal 2.0.13 → 2.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tabminal",
-  "version": "2.0.13",
+  "version": "2.0.14",
   "description": "A modern, persistent web terminal with multi-tab support and real-time system monitoring.",
   "type": "module",
   "bin": {
@@ -35,7 +35,7 @@
     "@fontsource/monaspace-neon": "^5.2.5",
     "@koa/router": "^15.4.0",
     "@mozilla/readability": "^0.6.0",
-    "jsdom": "^29.0.0",
+    "jsdom": "^29.0.1",
     "koa": "^3.1.2",
     "koa-bodyparser": "^4.4.1",
     "koa-static": "^5.0.0",
@@ -43,7 +43,7 @@
     "node-pty": "^1.1.0",
     "openai": "^6.32.0",
     "utilitas": "^2001.1.135",
-    "ws": "^8.19.0",
+    "ws": "^8.20.0",
     "xterm-addon-serialize": "^0.11.0",
     "xterm-headless": "^5.3.0"
   },
@@ -56,6 +56,6 @@
   },
   "homepage": "https://github.com/leask/tabminal#readme",
   "devDependencies": {
-    "eslint": "^10.0.3"
+    "eslint": "^10.1.0"
   }
 }

package/src/server.mjs

@@ -199,9 +199,9 @@ router.post('/api/sessions', (ctx) => {
     };
 });
 
-router.delete('/api/sessions/:id', (ctx) => {
+router.delete('/api/sessions/:id', async (ctx) => {
     const { id } = ctx.params;
-    terminalManager.removeSession(id);
+    await terminalManager.removeSession(id);
     ctx.status = 204;
 });
 

package/src/terminal-manager.mjs

@@ -60,11 +60,29 @@ export class TerminalManager {
     constructor() {
         this.sessions = new Map();
         this.snapshotPersistTimers = new Map();
+        this.sessionPersistenceChains = new Map();
         this.lastCols = initialCols;
         this.lastRows = initialRows;
         this.disposing = false;
     }
 
+    queueSessionPersistence(id, operation) {
+        const previous = this.sessionPersistenceChains.get(id)
+            || Promise.resolve();
+        const next = previous
+            .catch(() => {})
+            .then(operation);
+
+        this.sessionPersistenceChains.set(id, next);
+        next.finally(() => {
+            if (this.sessionPersistenceChains.get(id) === next) {
+                this.sessionPersistenceChains.delete(id);
+            }
+        }).catch(() => {});
+
+        return next;
+    }
+
     createSession(restoredData = null) {
         // Use ID from options if present, otherwise generate new
         const id = (restoredData && restoredData.id) ? restoredData.id : crypto.randomUUID();
@@ -200,24 +218,28 @@ precmd_functions+=(_tabminal_zsh_apply_prompt_marker)
             });
         }
 
+        this.sessions.set(id, session);
+
         // Initial save
-        this.saveSessionState(session);
+        void this.saveSessionState(session);
 
         ptyProcess.onExit(() => {
-            this.removeSession(id);
+            void this.removeSession(id);
             // Cleanup temp files
             try {
                 if (initDirPath && fs.existsSync(initDirPath)) fs.rmSync(initDirPath, { recursive: true, force: true });
             } catch { /* ignore cleanup errors */ }
         });
-
-        this.sessions.set(id, session);
         debugLog(`[Manager] Created session ${id}`);
         return session;
     }
 
     saveSessionState(session) {
-        persistence.saveSession(session.id, {
+        if (this.sessions.get(session.id) !== session) {
+            return Promise.resolve();
+        }
+
+        return this.queueSessionPersistence(session.id, () => persistence.saveSession(session.id, {
             id: session.id,
             title: session.title,
             cwd: session.cwd,
@@ -227,7 +249,7 @@ precmd_functions+=(_tabminal_zsh_apply_prompt_marker)
             createdAt: session.createdAt,
             editorState: session.editorState,
             executions: session.executions
-        });
+        }));
     }
 
     updateSessionState(id, data) {
@@ -250,13 +272,17 @@ precmd_functions+=(_tabminal_zsh_apply_prompt_marker)
             clearTimeout(existing);
         }
 
-        const timer = setTimeout(async () => {
+        const timer = setTimeout(() => {
             this.snapshotPersistTimers.delete(id);
             const currentSession = this.sessions.get(id);
             if (!currentSession) return;
 
-            const snapshot = await currentSession.serializeSnapshot();
-            await persistence.saveSessionSnapshot(id, snapshot);
+            void this.queueSessionPersistence(id, async () => {
+                if (this.sessions.get(id) !== currentSession) return;
+                const snapshot = await currentSession.serializeSnapshot();
+                if (this.sessions.get(id) !== currentSession) return;
+                await persistence.saveSessionSnapshot(id, snapshot);
+            });
         }, 250);
 
         this.snapshotPersistTimers.set(id, timer);
@@ -280,7 +306,7 @@ precmd_functions+=(_tabminal_zsh_apply_prompt_marker)
         this.lastRows = rows;
     }
 
-    removeSession(id) {
+    async removeSession(id) {
         const session = this.sessions.get(id);
         if (session) {
             const timer = this.snapshotPersistTimers.get(id);
@@ -288,9 +314,18 @@ precmd_functions+=(_tabminal_zsh_apply_prompt_marker)
                 clearTimeout(timer);
                 this.snapshotPersistTimers.delete(id);
             }
+            try {
+                if (process.platform === 'win32') {
+                    session.pty.kill();
+                } else {
+                    session.pty.kill('SIGHUP');
+                }
+            } catch {
+                // ignore
+            }
             session.dispose();
             this.sessions.delete(id);
-            persistence.deleteSession(id);
+            await this.queueSessionPersistence(id, () => persistence.deleteSession(id));
             debugLog(`[Manager] Removed session ${id}`);
         }
     }

package/src/terminal-session.mjs

@@ -121,7 +121,9 @@ export class TerminalSession {
         this.captureStartedAt = null;
         this.lastExecution = null;
         this.skipNextShellLog = false;
+        this.skipNextShellLogResetTimer = null;
         this.partialSequenceBuffer = '';
+        this.activeAiRun = null;
         this.snapshotScrollback = estimateSnapshotScrollback(
             this.pty.cols,
             this.pty.rows,
@@ -352,6 +354,7 @@ export class TerminalSession {
 
     dispose() {
         this.stopTitlePolling();
+        this._clearSkipNextShellLogResetTimer();
         this.clients.clear();
         this.pendingClients.clear();
         this.dataSubscription?.dispose?.();
@@ -416,6 +419,11 @@ export class TerminalSession {
     }
 
     write(data) {
+        if (this.activeAiRun && typeof data === 'string') {
+            this._handleInputDuringAi(data);
+            return;
+        }
+
         if (typeof data === 'string' && data.startsWith('\x1b')) {
             this.pty.write(data);
             this.inputBuffer = '';
@@ -503,6 +511,19 @@ export class TerminalSession {
         }
     }
 
+    _handleInputDuringAi(data) {
+        for (const char of data) {
+            if (char === '\x03') {
+                this._cancelActiveAiRun('ctrl_c');
+                return;
+            }
+            if (char === '\x04') {
+                this._cancelActiveAiRun('ctrl_d');
+                return;
+            }
+        }
+    }
+
     _buildAiContext(history) {
         let pendingShellHistory = '';
         const conversationHistory = [];
@@ -526,9 +547,67 @@ export class TerminalSession {
         return { conversationHistory, pendingShellHistory };
     }
 
+    _promptAi(prompt, options) {
+        return alan.prompt(prompt, options);
+    }
+
+    _clearSkipNextShellLogResetTimer() {
+        if (this.skipNextShellLogResetTimer) {
+            clearTimeout(this.skipNextShellLogResetTimer);
+            this.skipNextShellLogResetTimer = null;
+        }
+    }
+
+    _scheduleSkipNextShellLogReset() {
+        this._clearSkipNextShellLogResetTimer();
+        this.skipNextShellLogResetTimer = setTimeout(() => {
+            this.skipNextShellLog = false;
+            this.skipNextShellLogResetTimer = null;
+        }, 500);
+        this.skipNextShellLogResetTimer.unref?.();
+    }
+
+    _finishAiInteraction(mode = 'normal') {
+        this.suppressPtyOutput = false;
+        this._scheduleSkipNextShellLogReset();
+
+        if (mode === 'ctrl_c') {
+            this._writeToLogAndBroadcast('\x1b[0m');
+            this.pty.write('\x03');
+            return;
+        }
+
+        this._writeToLogAndBroadcast('\x1b[0m\r\n');
+        if (mode === 'ctrl_d') {
+            this.pty.write('\x15');
+        }
+        this.pty.write('\r');
+    }
+
+    _cancelActiveAiRun(reason) {
+        const run = this.activeAiRun;
+        if (!run || run.cancelled) {
+            return false;
+        }
+
+        run.cancelled = true;
+        this.activeAiRun = null;
+        this._logCommandExecution({
+            command: 'ai',
+            exitCode: 130,
+            input: run.prompt,
+            output: 'AI generation cancelled.',
+            startedAt: run.startedAt,
+            completedAt: new Date()
+        });
+        this._finishAiInteraction(reason);
+        return true;
+    }
+
     async _handleAiCommand(prompt) {
         // Prevent duplicate logging from shell integration
         this.skipNextShellLog = true;
+        this._clearSkipNextShellLogResetTimer();
         // Ensure clean line start and set Cyan color (No prefix yet)
         this._writeToLogAndBroadcast('\r\x1b[K\x1b[36m');
         // Gather Context (Current Session Only)
@@ -546,8 +625,17 @@ export class TerminalSession {
         const startTime = new Date();
         let fullResponse = '';
         let isFirstChunk = true;
+        const run = {
+            prompt,
+            startedAt: startTime,
+            cancelled: false
+        };
+        this.activeAiRun = run;
         try {
             const streamCallback = (chunk) => {
+                if (this.activeAiRun !== run || run.cancelled) {
+                    return;
+                }
                 // console.log('Chunk Received:');
                 // console.log(chunk);
                 if (chunk && chunk.text) {
@@ -563,13 +651,17 @@ export class TerminalSession {
                 }
             };
             // console.log('Start AI Prompt...');
-            const result = await alan.prompt(finalPrompt, {
+            const result = await this._promptAi(finalPrompt, {
                 stream: streamCallback,
                 delta: true,
                 messages: conversationHistory,
                 trimBeginning: true
             });
 
+            if (this.activeAiRun !== run || run.cancelled) {
+                return;
+            }
+
             if (result && result.text) {
                 fullResponse = result.text;
             }
@@ -588,6 +680,9 @@ export class TerminalSession {
             });
 
         } catch (e) {
+            if (this.activeAiRun !== run || run.cancelled) {
+                return;
+            }
             this._writeToLogAndBroadcast(`\x1b[31mAI Error: ${e.message}\x1b[0m\r\n`);
 
             this._logCommandExecution({
@@ -598,13 +693,12 @@ export class TerminalSession {
                 startedAt: startTime,
                 completedAt: new Date()
             });
+        } finally {
+            if (this.activeAiRun === run) {
+                this.activeAiRun = null;
+                this._finishAiInteraction('normal');
+            }
         }
-
-        // Resume PTY output
-        this.suppressPtyOutput = false;
-
-        // Restore prompt by sending \r to pty (empty command)
-        this.pty.write('\r');
     }
 
     _handleResize(cols, rows) {
@@ -639,6 +733,7 @@ export class TerminalSession {
     _handleExitCodeSequence(exitCodeStr, cmdB64) {
         if (this.skipNextShellLog) {
             this.skipNextShellLog = false;
+            this._clearSkipNextShellLogResetTimer();
             this.captureBuffer = '';
             this.captureStartedAt = null;
             return;