portless-studio 0.1.3 → 0.1.4

package/README.md

@@ -16,7 +16,7 @@ portless replaces port numbers with names: `portless api pnpm dev` serves your a
 with ten dev servers across several projects you have to remember which names exist and which
 ports have none. Studio shows both, live, and names a port in one click.
 
-![Naming port 8000, searching routes with Ctrl+K, filtering with the Filter popover and running pnpm dev in a Studio terminal](docs/images/demo.gif)
+![Naming port 8000, searching routes with Ctrl+K, filtering with the Filter popover and opening a route's terminal in the right-hand pane](docs/images/demo.gif)
 
 The screenshots use the built-in sample data (`?demo`), not a real machine.
 

package/dist/cli/mcp/studio-tools.js

@@ -423,7 +423,9 @@ function terminalTools(client) {
             name: "list_terminals",
             title: "List Studio terminals",
             description: "Lists the terminals Studio runs: id, title, folder, command, project, whether it still " +
-                "runs, exit code and the port it named.",
+                "runs, exit code, the port it named and who started it. Terminals that were running when " +
+                "Studio last stopped are listed with stopped_by_restart: true; restart_terminal runs them " +
+                "again.",
             inputSchema: NO_INPUT,
             call: async () => {
                 const result = await client.readPrivate(API_PATHS.terminals);
@@ -431,8 +433,12 @@ function terminalTools(client) {
                     return failure(result.error);
                 const { terminals } = result.value;
                 const running = terminals.filter((terminal) => terminal.status === "running").length;
+                const stopped = terminals.filter((terminal) => terminal.stoppedByRestart === true).length;
+                const restorable = stopped > 0
+                    ? `, ${stopped} stopped by a Studio restart: run ${stopped === 1 ? "it" : "them"} again with restart_terminal`
+                    : "";
                 return {
-                    summary: `${plural(terminals.length, "terminal")} (${running} running).`,
+                    summary: `${plural(terminals.length, "terminal")} (${running} running${restorable}).`,
                     data: terminals.map(terminalItem),
                 };
             },
@@ -556,6 +562,32 @@ function terminalTools(client) {
                 return { summary: `Stopping ${id.value}. list_terminals shows when it has exited.` };
             },
         },
+        {
+            name: "restart_terminal",
+            title: "Run a terminal's command again",
+            description: "Runs a terminal's command again in the same terminal: stops it first when it still runs. " +
+                "Use it for a terminal stopped by a Studio restart (stopped_by_restart in list_terminals) " +
+                "or one whose command ended.",
+            inputSchema: {
+                type: "object",
+                properties: { id: TERMINAL_ID_SCHEMA },
+                required: ["id"],
+                additionalProperties: false,
+            },
+            call: async (args) => {
+                const id = readString(args, "id");
+                if (!id.ok)
+                    return invalid(id.error);
+                const result = await client.write("POST", API_PATHS.terminalRestart(id.value));
+                if (!result.ok)
+                    return failure(result.error);
+                const terminal = result.value;
+                return {
+                    summary: `Running ${terminal.id} again in ${terminal.cwd}: ${terminal.command || "shell"}. Read its output with read_terminal {"id": "${terminal.id}"}.`,
+                    data: terminalItem(terminal),
+                };
+            },
+        },
         {
             name: "focus_studio",
             title: "Show something in Studio",
@@ -611,6 +643,8 @@ function terminalItem(terminal) {
         pid: terminal.pid,
         named: terminal.naming?.name ?? null,
         port: terminal.naming?.port ?? null,
+        started_by: terminal.startedBy ?? null,
+        stopped_by_restart: terminal.stoppedByRestart === true,
     };
 }
 async function readSnapshot(client, includeStudio = false) {

package/dist/cli/studio-items.js

@@ -8,6 +8,7 @@ export function routeItem(route) {
         project: route.project?.name ?? null,
         worktree: route.project?.worktree ?? null,
         pid: route.listenerPid ?? route.pid,
+        startedAt: route.startedAt ?? null,
     };
 }
 export function detectedItem(port) {
@@ -19,6 +20,7 @@ export function detectedItem(port) {
         suggestedName: port.suggestedName,
         project: port.project?.name ?? null,
         worktree: port.project?.worktree ?? null,
+        startedAt: port.startedAt ?? null,
     };
 }
 export function proxyItem(proxy) {

package/dist/core/api/contract.js

@@ -51,6 +51,8 @@ export const API_PATHS = {
      * Studio shows.
      */
     terminalsInFolder: "/api/terminals/in-folder",
+    /** GET returns `RecentCommandsResponse`: the last commands run in each folder. */
+    terminalsRecentCommands: "/api/terminals/recent-commands",
     /**
      * GET returns `TerminalInfo`; PATCH `RenameTerminalRequest` renames it; DELETE stops the command
      * if it runs and closes the terminal.
@@ -67,7 +69,10 @@ export const API_PATHS = {
     terminalInput: (id) => `/api/terminals/${encodeURIComponent(id)}/input`,
     /** POST: Ctrl+C, then SIGTERM, then SIGKILL until the command ends. */
     terminalStop: (id) => `/api/terminals/${encodeURIComponent(id)}/stop`,
-    /** POST: runs the same command again in the same terminal. */
+    /**
+     * POST: runs the same command again in the same terminal; also starts a terminal that was
+     * stopped by a Studio restart.
+     */
     terminalRestart: (id) => `/api/terminals/${encodeURIComponent(id)}/restart`,
     /** POST `FocusRequest`: brings a Studio page to the front showing a route, port or terminal. */
     focus: "/api/focus",

package/dist/core/config/studio-config.js

@@ -2,6 +2,14 @@ import { DEFAULT_NAME_TEMPLATE, parseNameTemplate } from "../ports/name-template
 import { projectIconKind } from "../projects/project-icon.js";
 import { err, ok } from "../result.js";
 import { DEFAULT_VIEW, isItemKey, parseViews } from "../views/view.js";
+export const DEFAULT_TERMINAL_APPEARANCE = {
+    fontSize: 12,
+    lineHeight: 1.2,
+    cursorStyle: "block",
+    cursorBlink: true,
+    scrollback: 10_000,
+    theme: "studio",
+};
 export const DEFAULT_CONFIG = {
     port: 4949,
     autoName: false,
@@ -39,6 +47,9 @@ export const DEFAULT_CONFIG = {
     shortUrls: false,
     showStudioRoute: false,
     showEphemeralPorts: false,
+    terminal: DEFAULT_TERMINAL_APPEARANCE,
+    restoreTerminals: "ask",
+    defaultEditor: null,
 };
 const MIN_SCAN_INTERVAL_MS = 1000;
 /**
@@ -147,8 +158,80 @@ export function parseConfig(input) {
             return err(`"nameTemplate" ${parsed.error}`);
         config.nameTemplate = template;
     }
+    if (raw.terminal !== undefined) {
+        const terminal = parseTerminalAppearance(raw.terminal);
+        if (!terminal.ok)
+            return terminal;
+        config.terminal = terminal.value;
+    }
+    if (raw.restoreTerminals !== undefined) {
+        const value = raw.restoreTerminals;
+        if (value !== "ask" && value !== "always" && value !== "never") {
+            return err(`"restoreTerminals" must be "ask", "always" or "never".`);
+        }
+        config.restoreTerminals = value;
+    }
+    if (raw.defaultEditor !== undefined) {
+        const value = raw.defaultEditor;
+        if (value !== null && (typeof value !== "string" || !APP_ID.test(value))) {
+            return err(`"defaultEditor" must be the id of an app in Open with, like "vscode", or null.`);
+        }
+        config.defaultEditor = value;
+    }
     return ok(config);
 }
+/** The shape of open-with app ids: `vscode`, `vscode-insiders`, `custom-1`. */
+const APP_ID = /^[a-z0-9][a-z0-9-]{0,39}$/;
+function parseTerminalAppearance(input) {
+    if (typeof input !== "object" || input === null || Array.isArray(input)) {
+        return err(`"terminal" must be an object.`);
+    }
+    const raw = input;
+    const terminal = { ...DEFAULT_TERMINAL_APPEARANCE };
+    if (raw.fontSize !== undefined) {
+        if (!isWholeBetween(raw.fontSize, 10, 24)) {
+            return err(`"terminal.fontSize" must be a whole number from 10 to 24.`);
+        }
+        terminal.fontSize = raw.fontSize;
+    }
+    if (raw.lineHeight !== undefined) {
+        const value = raw.lineHeight;
+        if (typeof value !== "number" || !Number.isFinite(value) || value < 1 || value > 2) {
+            return err(`"terminal.lineHeight" must be a number from 1 to 2.`);
+        }
+        terminal.lineHeight = value;
+    }
+    if (raw.cursorStyle !== undefined) {
+        const value = raw.cursorStyle;
+        if (value !== "block" && value !== "bar" && value !== "underline") {
+            return err(`"terminal.cursorStyle" must be "block", "bar" or "underline".`);
+        }
+        terminal.cursorStyle = value;
+    }
+    if (raw.cursorBlink !== undefined) {
+        if (typeof raw.cursorBlink !== "boolean") {
+            return err(`"terminal.cursorBlink" must be true or false.`);
+        }
+        terminal.cursorBlink = raw.cursorBlink;
+    }
+    if (raw.scrollback !== undefined) {
+        if (!isWholeBetween(raw.scrollback, 1000, 100_000)) {
+            return err(`"terminal.scrollback" must be a whole number from 1000 to 100000.`);
+        }
+        terminal.scrollback = raw.scrollback;
+    }
+    if (raw.theme !== undefined) {
+        const value = raw.theme;
+        if (value !== "studio" && value !== "dark" && value !== "light") {
+            return err(`"terminal.theme" must be "studio", "dark" or "light".`);
+        }
+        terminal.theme = value;
+    }
+    return ok(terminal);
+}
+function isWholeBetween(value, min, max) {
+    return typeof value === "number" && Number.isInteger(value) && value >= min && value <= max;
+}
 /** Empty names and values are dropped, so clearing a field in the panel removes its icon. */
 function parseProjectIcons(value) {
     if (typeof value !== "object" || value === null || Array.isArray(value))

package/dist/core/terminals/terminal-history.js

@@ -0,0 +1,53 @@
+/**
+ * What Studio keeps about terminals between runs, in `terminals.json` next to the config: the
+ * terminals that were running when it stopped, so they can run again, and the last commands run
+ * in each folder, offered when a new terminal opens there. See docs/terminals.md.
+ */
+export const EMPTY_TERMINAL_HISTORY = { running: [], recentCommands: {} };
+/** Commands remembered per folder. */
+export const MAX_RECENT_COMMANDS = 20;
+/** Reads `terminals.json`; anything it cannot read is left out rather than failing. */
+export function parseTerminalHistory(input) {
+    if (typeof input !== "object" || input === null)
+        return { running: [], recentCommands: {} };
+    const raw = input;
+    const running = Array.isArray(raw.running) ? raw.running.filter(isSavedTerminal) : [];
+    const recentCommands = {};
+    if (typeof raw.recentCommands === "object" && raw.recentCommands !== null) {
+        for (const [folder, list] of Object.entries(raw.recentCommands)) {
+            if (folder === "__proto__" || !Array.isArray(list))
+                continue;
+            const commands = list.filter((item) => typeof item === "string" && item.trim() !== "");
+            if (commands.length > 0)
+                recentCommands[folder] = commands.slice(0, MAX_RECENT_COMMANDS);
+        }
+    }
+    return { running, recentCommands };
+}
+/** Puts `command` first in the folder's list, once, and keeps the newest `MAX_RECENT_COMMANDS`. */
+export function rememberCommand(recent, cwd, command) {
+    const wanted = command.trim();
+    const copy = {};
+    for (const [folder, list] of Object.entries(recent))
+        copy[folder] = [...list];
+    if (wanted === "")
+        return copy;
+    const list = (copy[cwd] ?? []).filter((item) => item !== wanted);
+    copy[cwd] = [wanted, ...list].slice(0, MAX_RECENT_COMMANDS);
+    return copy;
+}
+function isSavedTerminal(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const item = value;
+    const optionalText = (field) => field === null || typeof field === "string";
+    return (typeof item.command === "string" &&
+        typeof item.cwd === "string" &&
+        item.cwd !== "" &&
+        typeof item.title === "string" &&
+        typeof item.startedAt === "number" &&
+        (item.startedBy === "program" || item.startedBy === "person") &&
+        optionalText(item.project) &&
+        optionalText(item.worktree) &&
+        optionalText(item.branch));
+}

package/dist/core/terminals/terminal.js

@@ -1,7 +1,3 @@
-/**
- * A terminal Studio runs: one command in one project folder, with its output kept so the page,
- * the CLI and agents can read it. See docs/terminals.md.
- */
 // Control sequences: CSI (colors, cursor), OSC (window title) and two-character escapes.
 const ESCAPES = new RegExp([
     String.raw `\u001b\[[0-?]*[ -/]*[@-~]`,

package/dist/server/application/port-discovery.js

@@ -143,5 +143,6 @@ function toDetected(port, projects, nameTemplate) {
         cwd: port.cwd,
         suggestedName: info === null ? null : suggestName(info, nameTemplate, port.port),
         ...(project === null ? {} : { project }),
+        ...(port.startedAt === undefined ? {} : { startedAt: port.startedAt }),
     };
 }

package/dist/server/application/studio-runtime.js

@@ -403,6 +403,7 @@ export class StudioRuntime {
             return {
                 ...route,
                 ...(listener?.pid == null ? {} : { listenerPid: listener.pid }),
+                ...(listener?.startedAt === undefined ? {} : { startedAt: listener.startedAt }),
                 ...(project === null ? {} : { project }),
                 ...(health === undefined ? {} : { health }),
             };

package/dist/server/application/terminals.js

@@ -1,5 +1,6 @@
 import { err, ok } from "../../core/result.js";
 import { OutputBuffer } from "../../core/terminals/output-buffer.js";
+import { rememberCommand, } from "../../core/terminals/terminal-history.js";
 import { appError } from "./app-error.js";
 const DEFAULT_MAX_OUTPUT = 2 * 1024 * 1024;
 const DEFAULT_GRACE_MS = 3_000;
@@ -9,6 +10,13 @@ const DEFAULT_COLS = 120;
 const DEFAULT_ROWS = 30;
 const MAX_COMMAND_CHARS = 8 * 1024;
 const MAX_TITLE_CHARS = 60;
+const DEFAULT_PERSIST_DELAY_MS = 300;
+/**
+ * A command that ended this shortly before Studio stopped counts as running then: a service
+ * manager stops Studio's commands together with Studio, and their exits can arrive first.
+ */
+const RECENT_EXIT_MS = 2_000;
+const RESTART_NOTE = "\r\n[Studio] Stopped by a Studio restart. Run it again to start it.\r\n";
 /**
  * The terminals Studio runs. Each keeps its last `maxOutputChars` of output, numbered so a client
  * can resume where it stopped. From a page, commands run only in folders Studio shows; a local
@@ -25,6 +33,11 @@ export class TerminalManager {
     #namingTimeoutMs;
     #processTree;
     #homeDir;
+    #history;
+    #persistDelayMs;
+    #recent = null;
+    #persistTimer;
+    #closing = false;
     #entries = new Map();
     #watchers = new Set();
     /** Folders a local program ran a terminal in. */
@@ -45,6 +58,8 @@ export class TerminalManager {
         this.#namingTimeoutMs = options.namingTimeoutMs ?? DEFAULT_NAMING_TIMEOUT_MS;
         this.#processTree = options.processTree;
         this.#homeDir = options.homeDir;
+        this.#history = options.history;
+        this.#persistDelayMs = options.persistDelayMs ?? DEFAULT_PERSIST_DELAY_MS;
     }
     get mode() {
         return this.#spawner.mode;
@@ -73,6 +88,7 @@ export class TerminalManager {
         const wanted = title.trim().slice(0, MAX_TITLE_CHARS);
         entry.info = { ...entry.info, title: wanted || entry.defaultTitle };
         this.#publishStatus(entry);
+        this.#schedulePersist();
         return ok({ ...entry.info });
     }
     async create(request, origin) {
@@ -87,69 +103,97 @@ export class TerminalManager {
             return cwd;
         if (origin.trusted)
             this.#trustedFolders.add(cwd.value);
-        const id = `t${this.#nextId++}`;
-        const cols = readSize(request.cols, DEFAULT_COLS);
-        const rows = readSize(request.rows, DEFAULT_ROWS);
         const naming = readNaming(request.name);
-        const defaultTitle = (command.value || this.#spawner.shellName || "shell").slice(0, MAX_TITLE_CHARS);
-        const title = request.title?.trim().slice(0, MAX_TITLE_CHARS) || defaultTitle;
         const project = await this.#projectOf(cwd.value);
-        const entry = {
-            defaultTitle,
-            info: {
-                id,
-                title,
-                cwd: cwd.value,
-                command: command.value ?? "",
-                project: project?.name ?? null,
-                worktree: project?.worktree ?? null,
-                branch: project?.branch ?? null,
-                ports: [],
-                status: "running",
-                exitCode: null,
-                startedAt: this.#now(),
-                endedAt: null,
-                pid: null,
-                mode: this.#spawner.mode,
-                cols,
-                rows,
-                nextSeq: 0,
-                naming,
-            },
-            request: {
-                command: command.value,
-                cwd: cwd.value,
-                cols,
-                rows,
-                env: {
-                    TERM: "xterm-256color",
-                    COLUMNS: String(cols),
-                    LINES: String(rows),
-                    PORTLESS_STUDIO_TERMINAL: id,
-                },
-            },
-            buffer: new OutputBuffer(this.#maxOutput),
-            process: null,
-            stopTimers: [],
-            watchers: new Set(),
-            baseline: null,
-            namingTimer: undefined,
-        };
+        const entry = this.#newEntry({
+            id: `t${this.#nextId++}`,
+            command: command.value,
+            cwd: cwd.value,
+            title: request.title,
+            cols: readSize(request.cols, DEFAULT_COLS),
+            rows: readSize(request.rows, DEFAULT_ROWS),
+            naming,
+            project,
+            startedBy: origin.trusted ? "program" : "person",
+            startedAt: this.#now(),
+        });
         if (naming)
             entry.baseline = await this.#portsInUse();
         const started = await this.#spawn(entry);
         if (!started.ok)
             return started;
-        this.#entries.set(id, entry);
+        this.#entries.set(entry.info.id, entry);
+        if (command.value) {
+            this.#recent = rememberCommand(this.#recentCommands(), cwd.value, command.value);
+        }
         if (naming)
             this.#startNaming(entry);
         else
             this.#updateWorkspaceWatch();
         this.#changed();
+        this.#schedulePersist();
         if (this.#watchers.size > 0)
             void this.#refreshPorts();
         return ok({ ...entry.info });
     }
+    /** The last commands run in each folder, newest first. */
+    recentCommands() {
+        return Object.fromEntries(Object.entries(this.#recentCommands()).map(([folder, list]) => [folder, [...list]]));
+    }
+    /**
+     * Brings back the terminals that were running when Studio last stopped: listed as stopped by a
+     * restart (`ask`), started again unless they are a plain shell (`always`), or forgotten
+     * (`never`). Folders that no longer exist are skipped. Call it once, on start.
+     */
+    async restore(mode) {
+        if (this.#closing)
+            return;
+        const saved = this.#history?.read().running ?? [];
+        if (mode === "never" || saved.length === 0) {
+            if (saved.length > 0)
+                this.#persistNow();
+            return;
+        }
+        const restored = [];
+        for (const item of saved) {
+            if (this.#entries.size >= this.#maxTerminals)
+                break;
+            const cwd = this.#folders.directory(item.cwd);
+            if (cwd === null)
+                continue;
+            if (item.startedBy === "program")
+                this.#trustedFolders.add(cwd);
+            const entry = this.#newEntry({
+                id: `t${this.#nextId++}`,
+                command: item.command || null,
+                cwd,
+                title: item.title,
+                cols: DEFAULT_COLS,
+                rows: DEFAULT_ROWS,
+                naming: null,
+                project: { name: item.project ?? "", worktree: item.worktree, branch: item.branch },
+                startedBy: item.startedBy,
+                startedAt: item.startedAt,
+            });
+            if (item.project === null) {
+                entry.info = { ...entry.info, project: null, worktree: null, branch: null };
+            }
+            entry.info = { ...entry.info, status: "exited", stoppedByRestart: true };
+            this.#append(entry, RESTART_NOTE);
+            this.#entries.set(entry.info.id, entry);
+            restored.push(entry);
+        }
+        this.#changed();
+        this.#persistNow();
+        if (mode !== "always")
+            return;
+        for (const entry of restored) {
+            if (this.#closing)
+                return;
+            if (entry.info.command !== "")
+                await this.restart(entry.info.id);
+        }
+    }
     input(id, text) {
         const entry = this.#entries.get(id);
         if (!entry)
@@ -166,6 +210,7 @@ export class TerminalManager {
             return notFound(id);
         if (!entry.process || entry.info.status !== "running")
             return ok({ ...entry.info });
+        entry.stoppedOnPurpose = true;
         this.#escalate(entry, entry.process);
         return ok({ ...entry.info });
     }
@@ -177,16 +222,36 @@ export class TerminalManager {
         const current = entry.process;
         if (current && entry.info.status === "running") {
             const ended = new Promise((resolve) => current.onExit(() => resolve()));
+            entry.stoppedOnPurpose = true;
             this.#escalate(entry, current);
             await ended;
         }
         this.#append(entry, `\r\n[Studio] restarted: ${entry.info.command || "shell"}\r\n`);
+        if (entry.info.project === null) {
+            const project = await this.#projectOf(entry.info.cwd);
+            if (project) {
+                entry.info = {
+                    ...entry.info,
+                    project: project.name,
+                    worktree: project.worktree ?? null,
+                    branch: project.branch ?? null,
+                };
+            }
+        }
         const started = await this.#spawn(entry);
         if (!started.ok)
             return started;
-        entry.info = { ...entry.info, status: "running", exitCode: null, endedAt: null };
+        entry.stoppedOnPurpose = false;
+        entry.info = {
+            ...entry.info,
+            status: "running",
+            exitCode: null,
+            endedAt: null,
+            stoppedByRestart: false,
+        };
         entry.info.startedAt = this.#now();
         this.#publishStatus(entry);
+        this.#schedulePersist();
         this.#updateWorkspaceWatch();
         if (this.#watchers.size > 0)
             void this.#refreshPorts();
@@ -205,6 +270,7 @@ export class TerminalManager {
         entry.watchers.clear();
         this.#updateWorkspaceWatch();
         this.#changed();
+        this.#schedulePersist();
         return ok(undefined);
     }
     read(id, from, maxChars) {
@@ -225,8 +291,16 @@ export class TerminalManager {
         entry.watchers.add(watcher);
         return ok(() => entry.watchers.delete(watcher));
     }
-    /** Studio is stopping: every command gets SIGTERM and SIGKILL right away. */
+    /**
+     * Studio is stopping: the terminals still running are written down for the next start, then
+     * every command gets SIGTERM and SIGKILL right away.
+     */
     closeAll() {
+        if (!this.#closing) {
+            this.#persistNow(true);
+            this.#closing = true;
+            clearTimeout(this.#persistTimer);
+        }
         for (const entry of this.#entries.values()) {
             this.#clearTimers(entry);
             if (entry.process && entry.info.status === "running") {
@@ -267,10 +341,108 @@ export class TerminalManager {
             }
             entry.info.ports = [];
             this.#publishStatus(entry);
+            this.#schedulePersist();
             this.#updateWorkspaceWatch();
         });
         return ok(undefined);
     }
+    #newEntry(fields) {
+        const defaultTitle = (fields.command || this.#spawner.shellName || "shell").slice(0, MAX_TITLE_CHARS);
+        const title = fields.title?.trim().slice(0, MAX_TITLE_CHARS) || defaultTitle;
+        const { id, cols, rows } = fields;
+        return {
+            defaultTitle,
+            info: {
+                id,
+                title,
+                cwd: fields.cwd,
+                command: fields.command ?? "",
+                project: fields.project?.name ?? null,
+                worktree: fields.project?.worktree ?? null,
+                branch: fields.project?.branch ?? null,
+                ports: [],
+                status: "running",
+                exitCode: null,
+                startedAt: fields.startedAt,
+                endedAt: null,
+                pid: null,
+                mode: this.#spawner.mode,
+                cols,
+                rows,
+                nextSeq: 0,
+                naming: fields.naming,
+                startedBy: fields.startedBy,
+                stoppedByRestart: false,
+            },
+            request: {
+                command: fields.command,
+                cwd: fields.cwd,
+                cols,
+                rows,
+                env: {
+                    TERM: "xterm-256color",
+                    COLUMNS: String(cols),
+                    LINES: String(rows),
+                    PORTLESS_STUDIO_TERMINAL: id,
+                },
+            },
+            buffer: new OutputBuffer(this.#maxOutput),
+            process: null,
+            stopTimers: [],
+            watchers: new Set(),
+            baseline: null,
+            namingTimer: undefined,
+            stoppedOnPurpose: false,
+        };
+    }
+    #recentCommands() {
+        this.#recent ??= this.#history?.read().recentCommands ?? {};
+        return this.#recent;
+    }
+    #schedulePersist() {
+        if (!this.#history || this.#closing || this.#persistTimer)
+            return;
+        this.#persistTimer = setTimeout(() => {
+            this.#persistTimer = undefined;
+            this.#persistNow();
+        }, this.#persistDelayMs);
+        this.#persistTimer.unref?.();
+    }
+    /**
+     * Writes the terminals that run and the recent commands. When Studio stops, commands that just
+     * ended without anyone asking count as running too.
+     */
+    #persistNow(stopping = false) {
+        const history = this.#history;
+        if (!history || this.#closing)
+            return;
+        clearTimeout(this.#persistTimer);
+        this.#persistTimer = undefined;
+        const now = this.#now();
+        const running = [...this.#entries.values()]
+            .filter((entry) => entry.info.status === "running" ||
+            entry.info.stoppedByRestart === true ||
+            (stopping &&
+                !entry.stoppedOnPurpose &&
+                entry.info.endedAt !== null &&
+                now - entry.info.endedAt <= RECENT_EXIT_MS))
+            .map(({ info }) => ({
+            command: info.command,
+            cwd: info.cwd,
+            title: info.title,
+            startedAt: info.startedAt,
+            startedBy: info.startedBy ?? "person",
+            project: info.project,
+            worktree: info.worktree,
+            branch: info.branch,
+        }));
+        try {
+            history.write({ running, recentCommands: this.#recentCommands() });
+        }
+        catch {
+            // A full disk or a read-only config folder: terminals keep working, they just are not kept.
+        }
+    }
     #escalate(entry, child) {
         this.#clearTimers(entry);
         child.interrupt();