termdock 1.4.168 → 1.4.170

package/dist/server/utils/staticAssets.js

@@ -0,0 +1,97 @@
+import fs from 'node:fs';
+import path from 'node:path';
+const CONTENT_TYPES = {
+    '.js': 'text/javascript; charset=utf-8', '.mjs': 'text/javascript; charset=utf-8',
+    '.css': 'text/css; charset=utf-8', '.html': 'text/html; charset=utf-8',
+    '.json': 'application/json; charset=utf-8', '.svg': 'image/svg+xml',
+    '.webmanifest': 'application/manifest+json', '.txt': 'text/plain; charset=utf-8',
+};
+export function selectStaticEncoding(header) {
+    const qualities = new Map();
+    for (const token of header.toLowerCase().split(',')) {
+        const [name, ...params] = token.trim().split(';');
+        const q = params.map((value) => value.trim()).find((value) => value.startsWith('q='));
+        const quality = q === undefined ? 1 : Number(q.slice(2));
+        qualities.set(name, Number.isFinite(quality) && quality >= 0 && quality <= 1 ? quality : 0);
+    }
+    const br = qualities.get('br') ?? qualities.get('*') ?? 0;
+    const gzip = qualities.get('gzip') ?? qualities.get('*') ?? 0;
+    if (br <= 0 && gzip <= 0)
+        return null;
+    return br >= gzip ? 'br' : 'gzip';
+}
+export function setStaticCacheHeaders(req, res) {
+    let pathname;
+    try {
+        pathname = decodeURIComponent(new URL(req.url, 'http://localhost').pathname);
+    }
+    catch {
+        return;
+    }
+    if (pathname.startsWith('/assets/') || /^\/fonts\/terminal\/[^/]+-[a-f0-9]{12}\.woff2$/.test(pathname)) {
+        res.setHeader('Cache-Control', 'public, max-age=31536000, immutable');
+    }
+    else if (pathname === '/sw.js' || pathname === '/registerSW.js' || pathname === '/manifest.webmanifest' || pathname === '/' || pathname.endsWith('/index.html')) {
+        // Allow conditional validation without ever reusing a stale entry point.
+        res.setHeader('Cache-Control', 'no-cache');
+    }
+}
+/** Serve build-time compressed assets; missing sidecars fall through to Express.
+ * No synchronous compression or disk reads in the terminal server's event loop.
+ */
+export function createStaticCompressionMiddleware(rootDir) {
+    const root = path.resolve(rootDir);
+    return async (req, res, next) => {
+        if (req.method !== 'GET' && req.method !== 'HEAD' || req.headers.range)
+            return next();
+        let pathname;
+        try {
+            pathname = decodeURIComponent(new URL(req.url, 'http://localhost').pathname);
+        }
+        catch {
+            return next();
+        }
+        if (pathname === '/')
+            pathname = '/index.html';
+        const type = CONTENT_TYPES[path.extname(pathname).toLowerCase()];
+        if (!type)
+            return next();
+        res.vary('Accept-Encoding');
+        const encoding = selectStaticEncoding(String(req.headers['accept-encoding'] || ''));
+        if (!encoding)
+            return next();
+        const original = path.resolve(root, '.' + pathname);
+        if (!original.startsWith(root + path.sep))
+            return next();
+        const compressed = original + (encoding === 'br' ? '.br' : '.gz');
+        try {
+            const [source, stat] = await Promise.all([fs.promises.stat(original), fs.promises.stat(compressed)]);
+            if (!source.isFile() || !stat.isFile() || stat.mtimeMs < source.mtimeMs)
+                return next();
+            res.setHeader('Content-Type', type);
+            res.setHeader('Content-Encoding', encoding);
+            res.setHeader('ETag', `W/"${stat.size.toString(16)}-${stat.mtimeMs.toString(16)}-${encoding}"`);
+            res.setHeader('Last-Modified', source.mtime.toUTCString());
+            setStaticCacheHeaders(req, res);
+            if (req.fresh) {
+                res.status(304).end();
+                return;
+            }
+            res.setHeader('Content-Length', stat.size);
+            if (req.method === 'HEAD') {
+                res.end();
+                return;
+            }
+            const stream = fs.createReadStream(compressed);
+            res.once('close', () => stream.destroy());
+            stream.on('error', (error) => { if (!res.headersSent)
+                next(error);
+            else
+                res.destroy(error); });
+            stream.pipe(res);
+        }
+        catch {
+            next();
+        }
+    };
+}

package/dist/server/utils/terminalClientAttachment.js

@@ -0,0 +1,61 @@
+/** A display connection owns its PTY parser stream; the tmux task is separate.
+ * Epoch checks also cover disconnect/unsubscribe while spawning asynchronously.
+ */
+export class TerminalClientAttachment {
+    spawn;
+    onData;
+    onExit;
+    epoch = 0;
+    process = null;
+    subscriptions = [];
+    constructor(spawn, onData, onExit) {
+        this.spawn = spawn;
+        this.onData = onData;
+        this.onExit = onExit;
+    }
+    get pid() { return this.process?.pid; }
+    get attached() { return this.process !== null; }
+    async open(cols, rows) {
+        this.close();
+        const epoch = this.epoch;
+        const process = await this.spawn(cols, rows);
+        if (epoch !== this.epoch) {
+            process.kill();
+            return false;
+        }
+        this.process = process;
+        this.subscriptions = [
+            process.onData(data => { if (epoch === this.epoch)
+                this.onData(data); }),
+            process.onExit(() => {
+                if (epoch !== this.epoch)
+                    return;
+                this.process = null;
+                this.disposeSubscriptions();
+                this.onExit();
+            }),
+        ];
+        return true;
+    }
+    write(data) { this.process?.write(data); }
+    resize(cols, rows) {
+        if (!this.process)
+            return false;
+        this.process.resize(cols, rows);
+        return true;
+    }
+    close() {
+        this.epoch += 1;
+        this.disposeSubscriptions();
+        const process = this.process;
+        this.process = null;
+        // This is the attached tmux CLI process, never a pane or tmux server.
+        if (process)
+            process.kill();
+    }
+    disposeSubscriptions() {
+        for (const subscription of this.subscriptions)
+            subscription.dispose();
+        this.subscriptions = [];
+    }
+}

package/dist/server/utils/terminalHandshakeDimensions.js

@@ -0,0 +1,9 @@
+/** Validate untrusted browser geometry before creating the attached PTY. */
+export function readTerminalHandshakeDimensions(params) {
+    const cols = Number(params.get('cols'));
+    const rows = Number(params.get('rows'));
+    if (!Number.isInteger(cols) || !Number.isInteger(rows)
+        || cols < 1 || rows < 1 || cols > 1000 || rows > 1000)
+        return undefined;
+    return { cols, rows };
+}

package/dist/server/utils/terminalOutputDelivery.js

@@ -0,0 +1,90 @@
+/** Per-observer output budget. A slow observer never pauses the shared PTY. */
+export class TerminalOutputDelivery {
+    send;
+    flowControl;
+    windowBytes;
+    queueLimit;
+    onOverflow;
+    active = true;
+    replaying = true;
+    needsReplay = false;
+    queue = [];
+    queuedBytes = 0;
+    outstanding = [];
+    outstandingBytes = 0;
+    nextId = 1;
+    lastAck = 0;
+    constructor(send, flowControl, windowBytes = 128 * 1024, queueLimit = 512 * 1024, onOverflow) {
+        this.send = send;
+        this.flowControl = flowControl;
+        this.windowBytes = windowBytes;
+        this.queueLimit = queueLimit;
+        this.onOverflow = onOverflow;
+    }
+    setActive(active) {
+        const changed = active !== this.active;
+        this.active = active;
+        if (!active) {
+            this.queue = [];
+            this.queuedBytes = 0;
+        }
+        return changed;
+    }
+    enqueue(frame) {
+        if (!this.active || this.needsReplay)
+            return;
+        // Bound single frames too. PTY producers may deliver multi-megabyte chunks.
+        const bytes = Buffer.byteLength(frame.data);
+        if (bytes + this.queuedBytes > this.queueLimit) {
+            this.queue = [];
+            this.queuedBytes = 0;
+            this.needsReplay = true;
+            this.onOverflow?.();
+            return;
+        }
+        this.queue.push(frame);
+        this.queuedBytes += bytes;
+        this.flush();
+    }
+    acknowledge(id) {
+        if (!Number.isSafeInteger(id) || id <= this.lastAck || id >= this.nextId)
+            return;
+        this.lastAck = id;
+        while (this.outstanding.length && this.outstanding[0].id <= id) {
+            this.outstandingBytes -= this.outstanding.shift().bytes;
+        }
+        this.flush();
+    }
+    finishReplay(lastSeq) {
+        // Shell replay is captured after the async metadata lookup. Discard live
+        // frames covered by that snapshot before exposing newer queued output.
+        this.queue = this.queue.filter((frame) => frame.seq === undefined || frame.seq > lastSeq);
+        this.queuedBytes = this.queue.reduce((sum, frame) => sum + Buffer.byteLength(frame.data), 0);
+        this.outstanding = [];
+        this.outstandingBytes = 0;
+        this.needsReplay = false;
+        this.replaying = false;
+        this.flush();
+    }
+    get pendingBytes() { return this.queuedBytes + this.outstandingBytes; }
+    flush() {
+        if (!this.active || this.replaying || this.needsReplay)
+            return;
+        while (this.queue.length && (!this.flowControl || this.outstandingBytes < this.windowBytes)) {
+            const frame = this.queue.shift();
+            const bytes = Buffer.byteLength(frame.data);
+            this.queuedBytes -= bytes;
+            if (this.flowControl) {
+                const id = this.nextId++;
+                this.outstanding.push({ id, bytes });
+                this.outstandingBytes += bytes;
+                this.send({ ...frame, flowSeq: id });
+            }
+            else
+                this.send(frame);
+        }
+    }
+}
+export function resolveTerminalReplayCursor(since, clientEpoch, epoch) {
+    return clientEpoch === epoch && Number.isSafeInteger(since) && since > 0 ? since : 0;
+}

package/dist/server/utils/tmuxClientRedraw.js

@@ -0,0 +1,16 @@
+/** Repaint through the existing PTY stream, preserving output order and modes.
+ * capture-pane is an observation of cells, not a terminal parser checkpoint.
+ * It must never be spliced into ongoing incremental output after a resize.
+ */
+export async function redrawTmuxClient(runTmux, sessionName, clientPid) {
+    if (typeof clientPid !== 'number')
+        return;
+    const clients = await runTmux([
+        'list-clients', '-t', sessionName, '-F', '#{client_pid} #{client_tty}',
+    ]);
+    const client = clients.split('\n').map(line => line.trim().split(/\s+/))
+        .find(([pid]) => pid === String(clientPid));
+    // Never fall back to another attached client if this one exited.
+    if (client?.[1])
+        await runTmux(['refresh-client', '-t', client[1]]);
+}

package/dist/server/utils/tmuxInitialScreen.js

@@ -0,0 +1,50 @@
+const SYNC_END = '\x1b[?2026l';
+/** Collect tmux's first synchronized redraw from its actual PTY stream.
+ * Return subsequent bytes to the live delivery queue without duplicating
+ * the initial screen in both connected.replayChunks and data frames.
+ */
+export class TmuxInitialScreen {
+    maxBytes;
+    ready;
+    resolve;
+    buffer = '';
+    bytes = 0;
+    done = false;
+    timer;
+    constructor(timeoutMs = 1500, maxBytes = 512 * 1024) {
+        this.maxBytes = maxBytes;
+        this.ready = new Promise(resolve => { this.resolve = resolve; });
+        // Compatibility escape hatch for a tmux build without synchronized
+        // output. Normal startup completes on the protocol boundary immediately.
+        this.timer = setTimeout(() => this.finish('timeout', this.buffer), timeoutMs);
+        this.timer.unref?.();
+    }
+    push(data) {
+        if (this.done)
+            return data;
+        this.bytes += Buffer.byteLength(data);
+        if (this.bytes > this.maxBytes) {
+            this.finish('overflow', '');
+            return '';
+        }
+        const searchFrom = Math.max(0, this.buffer.length - SYNC_END.length + 1);
+        this.buffer += data;
+        const end = this.buffer.indexOf(SYNC_END, searchFrom);
+        if (end < 0)
+            return '';
+        const boundary = end + SYNC_END.length;
+        const initial = this.buffer.slice(0, boundary);
+        const remainder = this.buffer.slice(boundary);
+        this.finish('complete', initial);
+        return remainder;
+    }
+    cancel() { this.finish('cancelled', ''); }
+    finish(status, data) {
+        if (this.done)
+            return;
+        this.done = true;
+        clearTimeout(this.timer);
+        this.buffer = '';
+        this.resolve({ status, data });
+    }
+}

package/dist/server/utils/tmuxResizeReady.js

@@ -0,0 +1,56 @@
+/** PTY output wakes the check; tmux's exact client dimensions prove readiness.
+ * No polling or grace period. The timeout rejects failure, never grants success.
+ */
+export function waitForTmuxClientSize(readClients, onOutput, pid, cols, rows) {
+    return new Promise((resolve, reject) => {
+        let finished = false;
+        let checking = false;
+        let dirty = false;
+        let dispose = () => { };
+        const finish = (error) => {
+            if (finished)
+                return;
+            finished = true;
+            clearTimeout(timeout);
+            dispose();
+            if (error)
+                reject(error);
+            else
+                resolve();
+        };
+        const timeout = setTimeout(() => finish(new Error('tmux client has not applied PTY dimensions')), 500);
+        const check = async () => {
+            if (finished)
+                return;
+            dirty = true;
+            if (checking)
+                return;
+            checking = true;
+            try {
+                do {
+                    dirty = false;
+                    const clients = await readClients();
+                    if (finished)
+                        return;
+                    const ready = clients.split('\n').some((line) => {
+                        const [clientPid, width, height] = line.trim().split(/\s+/).map(Number);
+                        return clientPid === pid && width === cols && height === rows;
+                    });
+                    if (ready) {
+                        finish();
+                        return;
+                    }
+                } while (dirty && !finished);
+            }
+            catch (error) {
+                finish(error);
+            }
+            finally {
+                checking = false;
+            }
+        };
+        // Subscribe before reading so output arriving during the query is not lost.
+        dispose = onOutput(() => { void check(); });
+        void check();
+    });
+}

package/dist/server/utils/webSocketSecurity.js

@@ -0,0 +1,28 @@
+import { authEvents, isAuthEnabled, isUpgradeRequestAuthenticated } from './authProtection.js';
+/** Attach after application handlers. Recheck before input and during idle output. */
+export function guardWebSocketSession(ws, cookie) {
+    const authenticatedAtConnect = isAuthEnabled();
+    const check = (touch = false) => {
+        if ((authenticatedAtConnect && !isAuthEnabled()) || !isUpgradeRequestAuthenticated(cookie, touch)) {
+            // terminate immediately: a close handshake alone can leave input flowing.
+            ws.terminate();
+            return false;
+        }
+        return true;
+    };
+    const handlers = ws.listeners('message');
+    ws.removeAllListeners('message');
+    ws.on('message', (...args) => {
+        if (!check(true))
+            return;
+        for (const handler of handlers)
+            handler.apply(ws, args);
+    });
+    const timer = setInterval(check, 1000);
+    timer.unref();
+    authEvents.on('revoked', check);
+    ws.once('close', () => {
+        clearInterval(timer);
+        authEvents.off('revoked', check);
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termdock",
-  "version": "1.4.168",
+  "version": "1.4.170",
   "description": "A complete web-based terminal application with modern UI",
   "type": "module",
   "main": ".desktop-dist/main.js",
@@ -28,7 +28,7 @@
     "desktop:dev": "npm run build && npm run build:desktop && electron-forge start",
     "desktop:prepare": "npm run build && npm run build:desktop && node scripts/prepare-desktop-runtime.mjs",
     "desktop:make": "node scripts/ensure-macos-appdmg.mjs && npm run desktop:prepare && electron-forge make",
-    "build:client": "vite build",
+    "build:client": "vite build && node scripts/precompress-client.mjs",
     "build:server": "tsc -p tsconfig.server.json && node -e \"require('fs').chmodSync('dist/server/cli.js', 0o755)\"",
     "build:runtime-manifest": "node scripts/generate-runtime-manifest.mjs",
     "generate:pwa-assets": "pwa-assets-generator --config pwa-assets.config.ts",
@@ -67,13 +67,13 @@
     "browser-haptic": "^1.0.13",
     "busboy": "^1.6.0",
     "cookie-parser": "^1.4.7",
-    "dompurify": "^3.4.11",
+    "dompurify": "^3.4.14",
     "dotenv": "^17.4.2",
     "express": "^5.2.1",
     "heic-convert": "^2.1.0",
     "katex": "^0.17.0",
     "lucide-react": "^1.17.0",
-    "mermaid": "^11.16.0",
+    "mermaid": "^11.17.2",
     "motion": "^12.40.0",
     "multicast-dns": "^7.2.5",
     "node-pty": "^1.1.0",
@@ -142,5 +142,8 @@
   "homepage": "https://github.com/Jovines/termdock#readme",
   "bugs": {
     "url": "https://github.com/Jovines/termdock/issues"
+  },
+  "overrides": {
+    "prismjs": "^1.30.0"
   }
 }

package/runtime-manifest.json

@@ -1,13 +1,13 @@
 {
   "schemaVersion": 1,
   "packageName": "termdock",
-  "version": "1.4.168",
+  "version": "1.4.170",
   "runtimeProtocolVersion": 1,
   "minimumDesktopVersion": "1.4.46",
   "nodeMajor": 22,
-  "dependencyHash": "sha256-HOcSzDZKWX251Njijj5fna89AzzVkOmrgAV2AuvVlJk=",
-  "serverBundleHash": "sha256-pqlB1CzPMNOio5yOWZtmFKikeNiOhh64Li2MOS4FljA=",
-  "clientBundleHash": "sha256-nWFw4lTshAZ4NpRkdZkmcqiV/VvO9VQFzd1dEylePlQ=",
+  "dependencyHash": "sha256-/c1QpL8I/K1/8wYVjqa7fYdeLyBTU/rKXAewGrOlv5A=",
+  "serverBundleHash": "sha256-UnxPdyYPj72Onfz2xiJRjMo4a9sqZKuU5SQWxv+34FI=",
+  "clientBundleHash": "sha256-cCiR1ftP22xjjDpmpH11ITbCOOtGOCsltJzVRAukDxo=",
   "entrypoint": "dist/server/cli.js",
   "clientEntrypoint": "dist/client/index.html"
 }

package/scripts/generate-font-subsets.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+"""Regenerate shipped terminal font shards (requires fonttools[woff]).
+
+The complete fonts remain the editable source and compatibility fallback. Normal
+builds use these checked-in, content-addressed shards without requiring Python.
+Keep cmap coverage and advance widths exactly equal to the source faces.
+"""
+from __future__ import annotations
+
+import hashlib
+import io
+import json
+from pathlib import Path
+
+from fontTools import subset
+from fontTools.ttLib import TTFont
+
+ROOT = Path(__file__).resolve().parents[1]
+FONTS = ROOT / "public/fonts"
+OUTPUT = FONTS / "terminal"
+
+
+def ranges(points: list[int]) -> str:
+    spans: list[list[int]] = []
+    for cp in sorted(points):
+        if spans and cp == spans[-1][1] + 1:
+            spans[-1][1] = cp
+        else:
+            spans.append([cp, cp])
+    return ",".join(f"U+{a:X}" if a == b else f"U+{a:X}-{b:X}" for a, b in spans)
+
+
+def main() -> None:
+    OUTPUT.mkdir(exist_ok=True)
+    css: list[str] = ["/* Generated by scripts/generate-font-subsets.py; do not edit. */"]
+    manifest: dict[str, object] = {"schemaVersion": 1, "faces": []}
+    expected: set[str] = set()
+    for family, stems in [
+        ("Termdock Mono", [f"JetBrainsMonoNLNerdFontMono-{w}" for w in ["Regular", "Bold", "Italic", "BoldItalic"]]),
+        ("Noto Sans Mono CJK SC", ["NotoSansMonoCJKsc-Subset", "NotoSansMonoCJKsc-Bold-Subset"]),
+    ]:
+        for stem in stems:
+            source = FONTS / f"{stem}.woff2"
+            original = TTFont(source)
+            cmap = original.getBestCmap()
+            groups: dict[str, list[int]] = {}
+            for cp in sorted(cmap):
+                if family == "Termdock Mono":
+                    key = f"icons-{cp // 1024:x}" if 0xE000 <= cp <= 0xF8FF or 0xF0000 <= cp <= 0x10FFFF else "text"
+                else:
+                    key = f"cjk-{cp // 256:x}" if 0x3400 <= cp <= 0x9FFF else "punctuation"
+                groups.setdefault(key, []).append(cp)
+            records = []
+            for key, points in groups.items():
+                font = TTFont(source, recalcTimestamp=False)
+                options = subset.Options()
+                options.recalc_timestamp = False
+                subsetter = subset.Subsetter(options=options)
+                subsetter.populate(unicodes=points)
+                subsetter.subset(font)
+                buffer = io.BytesIO()
+                font.save(buffer)
+                body = buffer.getvalue()
+                name = f"{stem}-{key}-{hashlib.sha256(body).hexdigest()[:12]}.woff2"
+                (OUTPUT / name).write_bytes(body)
+                expected.add(name)
+                # Verify both coverage and metrics rather than trusting the subsetter.
+                result = TTFont(io.BytesIO(body))
+                result_cmap = result.getBestCmap()
+                assert set(result_cmap) == set(points), name
+                for cp in points:
+                    assert result["hmtx"].metrics[result_cmap[cp]][0] == original["hmtx"].metrics[cmap[cp]][0], (name, cp)
+                weight = 700 if "Bold" in stem else 400
+                style = "italic" if "Italic" in stem else "normal"
+                css.append(f'@font-face{{font-family:"{family}";src:url("/fonts/terminal/{name}") format("woff2");font-weight:{weight};font-style:{style};font-display:swap;unicode-range:{ranges(points)};}}')
+                records.append({"file": name, "bytes": len(body), "codepoints": len(points), "group": key})
+            manifest["faces"].append({"source": source.name, "sourceSha256": hashlib.sha256(source.read_bytes()).hexdigest(), "shards": records})
+    # Delete only generated font shards; the full source font pack is untouched.
+    for old in OUTPUT.glob("*.woff2"):
+        if old.name not in expected:
+            old.unlink()
+    (ROOT / "src/lib/terminal/fontFaces.css").write_text("\n".join(css) + "\n")
+    (OUTPUT / "manifest.json").write_text(json.dumps(manifest, indent=2) + "\n")
+    print(f"Generated {len(expected)} font shards; coverage and advance widths verified.")
+
+
+if __name__ == "__main__":
+    main()

package/scripts/precompress-client.mjs

@@ -0,0 +1,28 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { brotliCompress, gzip, constants } from 'node:zlib';
+
+const br = promisify(brotliCompress);
+const gz = promisify(gzip);
+const root = path.resolve(process.argv[2] || 'dist/client');
+const extensions = new Set(['.js', '.mjs', '.css', '.html', '.json', '.svg', '.webmanifest', '.txt']);
+
+async function visit(directory) {
+  // Bound compression concurrency: builds must not allocate one zlib context
+  // per Mermaid chunk or compete with the running terminal server.
+  for (const entry of await fs.readdir(directory, { withFileTypes: true })) {
+    const file = path.join(directory, entry.name);
+    if (entry.isDirectory()) await visit(file);
+    else if (entry.isFile() && extensions.has(path.extname(file))) {
+      const raw = await fs.readFile(file);
+      if (raw.length < 1024) continue;
+      const compressed = await br(raw, { params: { [constants.BROTLI_PARAM_QUALITY]: 9 } });
+      await fs.writeFile(`${file}.br`, compressed);
+      await fs.writeFile(`${file}.gz`, await gz(raw, { level: 7 }));
+    }
+  }
+}
+
+await visit(root);
+console.log('Prepared Brotli/gzip client assets.');