zerogterm 0.4.0-alpha.1 → 0.6.0-alpha.1

package/dist/main/main/session-service.js

@@ -1,7 +1,9 @@
 import { execFile } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
+import { existsSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { homedir } from 'node:os';
+import { join } from 'node:path';
 import { promisify } from 'node:util';
 import { defaultShellBackend, isLocalShellBackend, resolveShellBackend } from './shell-catalog.js';
 const execFileAsync = promisify(execFile);
@@ -14,6 +16,37 @@ const NAME = /^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,48}$/;
  * -chosen config file (hence ProxyCommand) without any shell involvement.
  */
 const SSH_TARGET = /^(?:([A-Za-z0-9][A-Za-z0-9._-]*)@)?([A-Za-z0-9][A-Za-z0-9.-]*)(?::(\d{1,5}))?$/;
+function resolveSshExecutable() {
+    if (process.platform !== 'win32')
+        return 'ssh';
+    const windowsRoot = process.env.SystemRoot ?? 'C:\\Windows';
+    const candidates = [
+        join(windowsRoot, 'System32', 'OpenSSH', 'ssh.exe'),
+        join(process.env.ProgramFiles ?? 'C:\\Program Files', 'Git', 'usr', 'bin', 'ssh.exe'),
+        join(process.env['ProgramFiles(x86)'] ?? 'C:\\Program Files (x86)', 'Git', 'usr', 'bin', 'ssh.exe')
+    ];
+    return candidates.find((candidate) => existsSync(candidate)) ?? 'ssh.exe';
+}
+/**
+ * Size a pty starts at when the pane could not be measured — a placeholder,
+ * not a preference. Panes pass their real size through attach().
+ */
+const FALLBACK_SIZE = { cols: 120, rows: 32 };
+/**
+ * A size a pty can actually be given. Sizes cross the IPC boundary from the
+ * renderer, and a zero or fractional one is rejected by ConPTY (and makes
+ * every full-screen program wrap in the wrong place on Unix).
+ */
+function usableSize(size) {
+    if (!size)
+        return undefined;
+    const { cols, rows } = size;
+    if (!Number.isInteger(cols) || !Number.isInteger(rows))
+        return undefined;
+    if (cols < 2 || rows < 2 || cols > 2000 || rows > 2000)
+        return undefined;
+    return { cols, rows };
+}
 export function validateSessionName(name) {
     const value = name.trim();
     if (!NAME.test(value)) {
@@ -176,10 +209,23 @@ export class ScreenService {
         this.onEvent?.('created', session, true);
         return session;
     }
-    attach(id, onData, onExit) {
+    /**
+     * Attach a pane to a session, starting its pty if it does not have one.
+     *
+     * `size` is the pane's own measurement. A pty spawned at some stock size and
+     * resized a moment later shows its first frame at the wrong width, and a
+     * full-screen program redrawing over that frame leaves pieces of it behind —
+     * so the shell is started at the size it will actually be displayed at.
+     */
+    attach(id, onData, onExit, size) {
         const existing = this.getSession(id);
-        if (this.ptys.has(id))
+        if (this.ptys.has(id)) {
+            // Re-attaching pane may be a different size than the one that started it.
+            const measured = usableSize(size);
+            if (measured)
+                this.resize(id, measured.cols, measured.rows);
             return { ...existing, status: 'connected' };
+        }
         if (id.startsWith('local:')) {
             const fallback = this.fallbackLocalSessions.get(id);
             if (fallback) {
@@ -188,14 +234,14 @@ export class ScreenService {
                 const shell = isLocalShellBackend(fallback.backend)
                     ? resolveShellBackend(fallback.backend, fallback.wslDistribution)
                     : defaultShellBackend();
-                this.spawnCommand(id, shell.executable, shell.args, onData, onExit, fallback.cwd);
+                this.spawnCommand(id, shell.executable, shell.args, onData, onExit, fallback.cwd, size);
                 this.onEvent?.('attached', fallback, true);
                 return { ...fallback };
             }
             // Session ids cross the IPC boundary from the renderer, so re-validate
             // rather than trusting that createLocal produced this one.
             const name = validateSessionName(id.slice('local:'.length));
-            this.spawnCommand(id, 'screen', ['-x', name], onData, onExit);
+            this.spawnCommand(id, 'screen', ['-x', name], onData, onExit, homedir(), size);
             this.onEvent?.('attached', existing, true);
             return { ...existing, status: 'connected', persistence: 'screen' };
         }
@@ -207,7 +253,7 @@ export class ScreenService {
         session.status = 'connected';
         session.lastSeen = new Date().toISOString();
         try {
-            this.spawnCommand(id, 'ssh', args, onData, onExit);
+            this.spawnCommand(id, resolveSshExecutable(), args, onData, onExit, homedir(), size);
         }
         catch (error) {
             session.status = 'error';
@@ -239,11 +285,12 @@ export class ScreenService {
             throw new Error(`Unknown session: ${id}`);
         return session;
     }
-    spawnCommand(sessionId, file, args, onData, onExit, cwd = homedir()) {
+    spawnCommand(sessionId, file, args, onData, onExit, cwd = homedir(), size) {
+        const { cols, rows } = usableSize(size) ?? FALLBACK_SIZE;
         const proc = this.spawnPty(file, args, {
             name: 'xterm-256color',
-            cols: 120,
-            rows: 32,
+            cols,
+            rows,
             cwd,
             env: process.env
         });
@@ -259,7 +306,7 @@ export class ScreenService {
                 }
             }
         };
-        this.ptys.set(sessionId, { handle, kind: sessionId.startsWith('ssh:') ? 'ssh' : 'local' });
+        this.ptys.set(sessionId, { handle, kind: sessionId.startsWith('ssh:') ? 'ssh' : 'local', cols, rows });
         proc.onData(onData);
         proc.onExit(() => {
             this.ptys.delete(sessionId);
@@ -281,8 +328,25 @@ export class ScreenService {
     write(sessionId, data) {
         this.ptys.get(sessionId)?.handle.write(data);
     }
+    /**
+     * Tell a session's pty how big its pane is now.
+     *
+     * A resize is not free and not invisible: it makes ConPTY reflow and re-emit
+     * its screen, and every full-screen program redraw on SIGWINCH. Panes refit
+     * on layout, font and status changes, which mostly produce the size the pty
+     * already has, so a repeat of the current size is dropped rather than paid
+     * for in a torn redraw.
+     */
     resize(sessionId, cols, rows) {
-        this.ptys.get(sessionId)?.handle.resize(cols, rows);
+        const pty = this.ptys.get(sessionId);
+        if (!pty)
+            return;
+        const size = usableSize({ cols, rows });
+        if (!size || (size.cols === pty.cols && size.rows === pty.rows))
+            return;
+        pty.cols = size.cols;
+        pty.rows = size.rows;
+        pty.handle.resize(size.cols, size.rows);
     }
     detach(sessionId) {
         this.ptys.get(sessionId)?.handle.kill();