tabminal 2.0.13 → 2.0.15

package/src/terminal-manager.mjs

@@ -56,57 +56,88 @@ function buildBashBootstrap({
     };
 }
 
+function clearBashPromptEnv(env) {
+    for (const key of [
+        'PROMPT_COMMAND',
+        'PS0',
+        'PS1',
+        'PS2',
+        'PS4'
+    ]) {
+        delete env[key];
+    }
+}
+
 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;
     }
 
-    createSession(restoredData = null) {
-        // Use ID from options if present, otherwise generate new
-        const id = (restoredData && restoredData.id) ? restoredData.id : crypto.randomUUID();
-        const shell = resolveShell();
-
-        // Use CWD from options if present, otherwise default
-        const initialCwd = (restoredData && restoredData.cwd)
-            ? restoredData.cwd
-            : (process.env.TABMINAL_CWD || os.homedir());
-
-        const env = { ...process.env };
-
-        // Inject shell tools
-        const shellToolsPath = path.join(process.cwd(), 'shell');
-        const pathDelimiter = path.delimiter;
-        const pathKey = Object.keys(env).find((key) => key.toLowerCase() === 'path') || 'PATH';
-        const existingPath = env[pathKey];
-        env[pathKey] = existingPath
-            ? `${shellToolsPath}${pathDelimiter}${existingPath}`
-            : shellToolsPath;
-
-        let spawnShell = shell;
-        let args = [];
+    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;
+    }
+
+    _createPtySession(options = {}) {
+        const id = options.id || crypto.randomUUID();
+        const shell = options.shell || resolveShell();
+        const initialCwd = options.cwd
+            || process.env.TABMINAL_CWD
+            || os.homedir();
+        const env = {
+            ...process.env,
+            ...(options.env || {})
+        };
+        let spawnShell = options.spawnCommand || shell;
+        let args = Array.isArray(options.spawnArgs) ? options.spawnArgs : [];
         let initDirPath = null;
 
-        try {
-            const shellName = path.basename(shell);
-            if (shellName === 'bash') {
-                const bootstrap = buildBashBootstrap({
-                    env,
-                    shell,
-                    shellToolsPath,
-                    sessionId: id
-                });
-                spawnShell = bootstrap.shell;
-                args = bootstrap.args;
-            } else if (shellName === 'zsh') {
-                initDirPath = path.join(os.tmpdir(), `tabminal-zsh-${id}`);
-                fs.mkdirSync(initDirPath, { recursive: true });
-                const initFilePath = path.join(initDirPath, '.zshrc');
-
-                const zshScript = `
+        if (!options.directSpawn) {
+            const shellToolsPath = path.join(process.cwd(), 'shell');
+            const pathDelimiter = path.delimiter;
+            const pathKey = Object.keys(env).find(
+                (key) => key.toLowerCase() === 'path'
+            ) || 'PATH';
+            const existingPath = env[pathKey];
+            env[pathKey] = existingPath
+                ? `${shellToolsPath}${pathDelimiter}${existingPath}`
+                : shellToolsPath;
+
+            try {
+                const shellName = path.basename(shell);
+                if (shellName === 'bash') {
+                    clearBashPromptEnv(env);
+                    const bootstrap = buildBashBootstrap({
+                        env,
+                        shell,
+                        shellToolsPath,
+                        sessionId: id
+                    });
+                    spawnShell = bootstrap.shell;
+                    args = bootstrap.args;
+                } else if (shellName === 'zsh') {
+                    initDirPath = path.join(os.tmpdir(), `tabminal-zsh-${id}`);
+                    fs.mkdirSync(initDirPath, { recursive: true });
+                    const initFilePath = path.join(initDirPath, '.zshrc');
+
+                    const zshScript = `
 unset ZDOTDIR
 [ -f ~/.zshrc ] && source ~/.zshrc
 export PATH="${shellToolsPath}:$PATH"
@@ -132,25 +163,26 @@ preexec_functions+=(_tabminal_zsh_preexec)
 precmd_functions+=(_tabminal_zsh_postexec)
 precmd_functions+=(_tabminal_zsh_apply_prompt_marker)
 `;
-                fs.writeFileSync(initFilePath, zshScript);
-                env.ZDOTDIR = initDirPath;
-                args = ['-i'];
+                    fs.writeFileSync(initFilePath, zshScript);
+                    env.ZDOTDIR = initDirPath;
+                    args = ['-i'];
+                }
+            } catch (err) {
+                console.error('[Manager] Failed to create init script:', err);
             }
-        } catch (err) {
-            console.error('[Manager] Failed to create init script:', err);
         }
 
-        const cols = restoredData ? restoredData.cols : this.lastCols;
-        const rows = restoredData ? restoredData.rows : this.lastRows;
+        const cols = Number.isFinite(options.cols) ? options.cols : this.lastCols;
+        const rows = Number.isFinite(options.rows) ? options.rows : this.lastRows;
 
         let ptyProcess;
         try {
             const ptyOptions = {
                 name: 'xterm-256color',
-                cols: cols,
-                rows: rows,
+                cols,
+                rows,
                 cwd: initialCwd,
-                env: env
+                env
             };
             if (process.platform !== 'win32') {
                 ptyOptions.encoding = 'utf8';
@@ -182,17 +214,25 @@ precmd_functions+=(_tabminal_zsh_apply_prompt_marker)
 
         const session = new TerminalSession(ptyProcess, {
             id,
-            historyLimit,
-            createdAt: restoredData ? new Date(restoredData.createdAt) : new Date(),
+            historyLimit: options.historyLimit ?? historyLimit,
+            createdAt: options.createdAt
+                ? new Date(options.createdAt)
+                : new Date(),
             manager: this,
             shell,
             initialCwd,
-            env: env,
-            editorState: restoredData ? restoredData.editorState : undefined,
-            executions: restoredData ? restoredData.executions : undefined
+            env,
+            title: options.title || '',
+            managed: options.managed || null,
+            persistent: options.persistent !== false,
+            removeOnExit: options.removeOnExit !== false,
+            enableAiHijack: options.enableAiHijack !== false,
+            enableTitlePolling: options.enableTitlePolling !== false,
+            editorState: options.editorState,
+            executions: options.executions
         });
 
-        if (restoredData) {
+        if (options.restoreSnapshot) {
             persistence.loadSessionSnapshot(id).then(async (snapshot) => {
                 if (!snapshot) return;
                 await session.restoreSnapshot(snapshot);
@@ -200,24 +240,77 @@ precmd_functions+=(_tabminal_zsh_apply_prompt_marker)
             });
         }
 
-        // Initial save
-        this.saveSessionState(session);
+        this.sessions.set(id, session);
+
+        if (session.persistent) {
+            void this.saveSessionState(session);
+        }
 
         ptyProcess.onExit(() => {
-            this.removeSession(id);
-            // Cleanup temp files
+            if (session.removeOnExit) {
+                void this.removeSession(id);
+            }
             try {
-                if (initDirPath && fs.existsSync(initDirPath)) fs.rmSync(initDirPath, { recursive: true, force: true });
-            } catch { /* ignore cleanup errors */ }
+                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;
     }
 
+    createSession(restoredData = null) {
+        return this._createPtySession({
+            id: restoredData?.id,
+            shell: resolveShell(),
+            cwd: restoredData?.cwd,
+            cols: restoredData?.cols,
+            rows: restoredData?.rows,
+            createdAt: restoredData?.createdAt,
+            title: restoredData?.title,
+            editorState: restoredData?.editorState,
+            executions: restoredData?.executions,
+            restoreSnapshot: Boolean(restoredData),
+            persistent: true,
+            removeOnExit: true,
+            enableAiHijack: true,
+            enableTitlePolling: true
+        });
+    }
+
+    createManagedSession(options = {}) {
+        const spawnRequest = options.spawnRequest || {};
+        const shell = spawnRequest.command || resolveShell();
+        return this._createPtySession({
+            shell,
+            cwd: options.cwd,
+            env: options.env,
+            cols: options.cols,
+            rows: options.rows,
+            title: options.title || path.basename(shell) || 'Terminal',
+            directSpawn: true,
+            spawnCommand: spawnRequest.command,
+            spawnArgs: spawnRequest.args,
+            persistent: false,
+            removeOnExit: false,
+            enableAiHijack: false,
+            enableTitlePolling: false,
+            managed: options.managed || null
+        });
+    }
+
     saveSessionState(session) {
-        persistence.saveSession(session.id, {
+        if (!session?.persistent) {
+            return Promise.resolve();
+        }
+        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 +320,7 @@ precmd_functions+=(_tabminal_zsh_apply_prompt_marker)
             createdAt: session.createdAt,
             editorState: session.editorState,
             executions: session.executions
-        });
+        }));
     }
 
     updateSessionState(id, data) {
@@ -237,26 +330,32 @@ precmd_functions+=(_tabminal_zsh_apply_prompt_marker)
             if (data.editorState) {
                 session.editorState = { ...session.editorState, ...data.editorState };
             }
-            this.saveSessionState(session);
+            if (session.persistent) {
+                this.saveSessionState(session);
+            }
         }
     }
 
     scheduleSnapshotPersist(id) {
         const session = this.sessions.get(id);
-        if (!session) return;
+        if (!session || !session.persistent) return;
 
         const existing = this.snapshotPersistTimers.get(id);
         if (existing) {
             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 +379,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 +387,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}`);
         }
     }
@@ -306,6 +414,9 @@ precmd_functions+=(_tabminal_zsh_apply_prompt_marker)
             env: s.env,
             cols: s.pty.cols,
             rows: s.pty.rows,
+            closed: !!s.closed,
+            exitStatus: s.exitStatus || null,
+            managed: s.managed || null,
             editorState: s.editorState,
             executions: s.executions
         }));