zerogterm 0.4.0-alpha.1 → 0.5.0-alpha.1

package/README.md

@@ -7,6 +7,7 @@ ZeroG Terminal is an alpha project, but it is already useful as a multi-session
 ## Features
 
 - Multi-pane workspaces with stack, vertical split, horizontal split, and four-pane grid layouts.
+- Draggable dividers between panes and beside the sidebar, so a split does not have to be an even one. Sizes are remembered between launches.
 - Maximize a focused pane and cycle between sessions without losing the other panes.
 - Local sessions powered by Bash, PowerShell, WSL, and other supported shell backends; persistent sessions use `screen` where available, with a process-only fallback when it is unavailable.
 - SSH sessions for hosts, `user@host`, and `user@host:port` targets.
@@ -18,6 +19,7 @@ ZeroG Terminal is an alpha project, but it is already useful as a multi-session
 - Session overview, collapsible sidebar, keyboard shortcuts, and light/dark themes.
 - xterm.js terminal rendering with scrollback preservation while changing layouts.
 - Local voice input, either with Whisper ONNX inside the app through Transformers.js or through a transcription server on this machine; transcribed text is typed into the selected terminal without automatic execution.
+- A per-pane proceed button that sends a configurable phrase — `OK, proceed` by default — for waving an agent on without typing the same reply again.
 - A settings panel for appearance, terminal behaviour, session defaults, and speech recognition, including a built-in recognition test.
 - AI command suggestion and approval UI, keeping command execution explicit.
 - Sandboxed Electron renderer, context isolation, disabled Node integration, and a narrow typed preload API.
@@ -29,7 +31,7 @@ See the project walkthrough on [YouTube](https://youtu.be/4aJZCxLHD14).
 
 ## Release status
 
-ZeroG Terminal is currently a public alpha. The current release is `0.3.0-alpha.1`; the version history is tracked in [versions.txt](versions.txt).
+ZeroG Terminal is currently a public alpha. The current release is `0.5.0-alpha.1`; the version history is tracked in [versions.txt](versions.txt).
 
 The npm package contains the built Electron application and project documentation. It is intended for early adopters and testing rather than production use.
 
@@ -51,6 +53,17 @@ sequence — this is how TUI tools such as CLI coding agents, tmux and Neovim pu
 text on the clipboard, including over SSH. Reading the clipboard through OSC 52
 is refused, so a program on a remote host cannot see what you last copied.
 
+## Resizing panes and the sidebar
+
+Drag the line between two panes, or the sidebar's right edge, to change how the
+space is shared. Sizes are remembered between launches and clamped so that no
+pane can be dragged down to nothing.
+
+The dividers take keyboard focus as well: the arrow keys nudge one two percent at
+a time, and Enter or a double-click puts it back in the middle. One divider
+position is shared by every layout, so a split you set up in the vertical split
+is the same split you get in the four-pane grid.
+
 ## Settings
 
 Settings open from the gear at the bottom of the left rail, the avatar in the
@@ -64,9 +77,23 @@ between launches; each page can be reset on its own.
   layout to start in, and whether the sidebar starts collapsed.
 - **AI & voice** — whether AI suggestions need approval before running, and
   whether a transcript is typed straight into the pane or shown for review
-  first. Neither option presses Enter for you.
+  first. Neither option presses Enter for you. Also the phrase the pane's
+  proceed button sends, described below.
 - **Speech recognition** — engine, model and tuning, described below.
 
+### Proceed button
+
+Each pane's title bar carries a tick beside the microphone. Clicking it sends
+`OK, proceed` and presses Enter — for the common case of an AI coding agent
+pausing to ask whether it should carry on. The phrase is editable under
+**Settings ▸ AI & voice**, so an agent that responds better to different wording
+can have it.
+
+This is the one control that presses Enter for you; voice transcripts and AI
+suggestions deliberately do not. It sends to the pane it belongs to, so a pane
+sitting at a shell prompt rather than in an agent will simply try to run the
+phrase as a command.
+
 ### Speech recognition
 
 Two engines are available.
@@ -119,28 +146,41 @@ npm run build
 npm start
 ```
 
-Runtime prerequisites on the host include Node.js and the native build tools required by `node-pty`. Install `screen` as well for persistent, discoverable sessions.
+Node.js is the only prerequisite every host needs. The scripts above run on Linux
+and Windows; npm runs them through `cmd.exe` on Windows, so no POSIX shell is
+required whichever shell you start them from.
+
+`node-pty` provides terminal I/O on every platform. It ships prebuilt binaries
+for Windows and macOS, so a C/C++ toolchain is a Linux requirement rather than a
+general one — there, `npm install` compiles it.
 
-On Fedora/RHEL-like Linux systems:
+### Linux
 
 ```bash
 sudo dnf install screen make gcc-c++ python3
 ```
 
-On Windows, use a supported Node.js installation and choose PowerShell or WSL when creating a local session. WSL distributions can be selected from the local-session dialog. Remote SSH sessions work independently of the local shell backend.
+`make`, `gcc-c++` and `python3` build `node-pty`. `screen` is optional but worth
+having: with it, local sessions are persistent and rediscovered after relaunch.
+Without it, ZeroG falls back to a direct PTY on the chosen shell and labels the
+session process-only; that shell is lost when the application exits.
 
-`node-pty` is required for terminal I/O. When `screen` is installed, local sessions are persistent and discoverable after relaunch. Without `screen`, ZeroG falls back to a direct shell PTY and labels the session as process-only; that shell is lost when the application exits. Install `screen` for full persistence:
+### Windows
 
-```bash
-sudo dnf install screen
-```
+No tooling beyond Node.js. The new-terminal dialog offers the shells it finds on
+PATH — Windows PowerShell, PowerShell 7, Command Prompt, WSL (with a distribution
+picker), and Git Bash where Git for Windows is installed.
+
+`screen` does not exist on Windows, so local sessions are always process-only and
+do not survive app exit. Remote SSH sessions are unaffected by the local shell
+backend, and a remote host with `screen` still gives persistent sessions there.
 
 ## Verification
 
 The current main branch has the following local verification coverage:
 
 - `npm run typecheck`: passes.
-- `npm test`: passes (28 tests covering remote-screen parsing and prompt readiness, session history, SSH inventory and argument validation, session service behavior, and voice input helpers).
+- `npm test`: passes (167 tests covering session service behaviour and PTY sizing, shell discovery, SSH inventory and argument validation, remote-screen parsing and prompt readiness, session history, the session dialog, settings, terminal clipboard and OSC 52 handling, dialog dismissal, and the speech and voice helpers; one further test needs a real `screen` and is opt-in through `ZEROG_LIVE_SCREEN=1`).
 - `npm run build`: passes and writes `dist/main` plus `dist/renderer`.
 - `npm audit --omit=dev`: production dependency auditing is part of the project quality checks.
 

package/dist/main/main/main.js

@@ -10,6 +10,15 @@ const __dirname = fileURLToPath(new URL('.', import.meta.url));
 const history = new SessionHistoryStore({ filePath: defaultHistoryPath(app.getPath('userData')) });
 const service = new ScreenService({ onEvent: (event, session, available) => { void history.record(event, session, available); } });
 let win;
+/** A pane's measured size, as it arrives from the renderer. */
+function parsePtySize(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const { cols, rows } = value;
+    if (!Number.isInteger(cols) || !Number.isInteger(rows))
+        return undefined;
+    return { cols: cols, rows: rows };
+}
 // GPU is unstable under Toolbox/Wayland on this host; allow override.
 if (process.env.ZEROG_ENABLE_GPU !== '1') {
     app.disableHardwareAcceleration();
@@ -108,10 +117,10 @@ ipcMain.handle('screens:attachRemote', (_event, input, screenName) => {
         throw new Error('screenName is required');
     return buildRemoteScreenAttachArgs(connection, screenName);
 });
-ipcMain.handle('sessions:attach', (_event, id) => {
+ipcMain.handle('sessions:attach', (_event, id, size) => {
     if (typeof id !== 'string' || !id)
         throw new Error('attachSession requires a session id');
-    return service.attach(id, (data) => win?.webContents.send('terminal:data', id, data), (message) => win?.webContents.send('terminal:status', id, message));
+    return service.attach(id, (data) => win?.webContents.send('terminal:data', id, data), (message) => win?.webContents.send('terminal:status', id, message), parsePtySize(size));
 });
 ipcMain.handle('sessions:close', (_event, id) => {
     if (typeof id !== 'string' || !id)

package/dist/main/main/preload.cjs

@@ -11,7 +11,7 @@ const api = {
   listKnownConnections: () => ipcRenderer.invoke('connections:listKnown'),
   discoverRemoteScreens: (connection) => ipcRenderer.invoke('screens:discoverRemote', connection),
   buildRemoteScreenAttach: (connection, screenName) => ipcRenderer.invoke('screens:attachRemote', connection, screenName),
-  attachSession: (id) => ipcRenderer.invoke('sessions:attach', id),
+  attachSession: (id, size) => ipcRenderer.invoke('sessions:attach', id, size),
   closeSession: (id) => ipcRenderer.invoke('sessions:close', id),
   write: (sessionId, data) => ipcRenderer.send('terminal:write', sessionId, data),
   resize: (sessionId, cols, rows) => ipcRenderer.send('terminal:resize', sessionId, cols, rows),

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

@@ -14,6 +14,26 @@ 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}))?$/;
+/**
+ * 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 +196,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 +221,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 +240,7 @@ export class ScreenService {
         session.status = 'connected';
         session.lastSeen = new Date().toISOString();
         try {
-            this.spawnCommand(id, 'ssh', args, onData, onExit);
+            this.spawnCommand(id, 'ssh', args, onData, onExit, homedir(), size);
         }
         catch (error) {
             session.status = 'error';
@@ -239,11 +272,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 +293,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 +315,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();