handmux 0.23.0 → 0.25.0

package/dist/src/browser/workerServer.js

@@ -0,0 +1,91 @@
+import http from 'node:http';
+import express from 'express';
+import { tokenEquals } from '../auth.js';
+import { createBrowserPreviewManager } from './manager.js';
+import { createBrowserBootstrapStore } from './bootstrap.js';
+import { createBrowserPublicProxy } from './publicProxy.js';
+import { browserRoutes } from './routes.js';
+import { BROWSER_INTERNAL_HEADER } from './protocol.js';
+const defaultManagerFactory = createBrowserPreviewManager;
+const defaultBrowserPublicFactory = createBrowserPublicProxy;
+const workerBrowserRoutes = browserRoutes;
+function isLoopback(address) {
+    return address === '127.0.0.1' || address === '::1' || String(address || '').startsWith('::ffff:127.');
+}
+function authenticated(req, token) {
+    const provided = req.headers[BROWSER_INTERNAL_HEADER];
+    return isLoopback(req.socket?.remoteAddress)
+        && typeof provided === 'string'
+        && tokenEquals(provided, token);
+}
+export async function createBrowserWorkerServer({ internalToken, previewDomain = null, handmuxOrigin = 'http://127.0.0.1', browser: suppliedBrowser = null, managerFactory = defaultManagerFactory, browserPublicFactory = defaultBrowserPublicFactory, host = '127.0.0.1', port = 0, }) {
+    if (!internalToken)
+        throw new Error('browser worker internal token required');
+    const browserBootstrap = createBrowserBootstrapStore();
+    const browser = suppliedBrowser || await managerFactory({
+        handmuxOrigin,
+        previewDomain,
+        browserBootstrap,
+    });
+    const browserPublic = browserPublicFactory({ browser, browserBootstrap });
+    const app = express();
+    app.use((req, res, next) => {
+        if (!authenticated(req, internalToken))
+            return res.status(401).json({ error: 'browser worker unauthorized' });
+        delete req.headers[BROWSER_INTERNAL_HEADER];
+        return next();
+    });
+    app.get('/_browser-worker/health', (_req, res) => res.json({ ok: true }));
+    app.use('/api/browser-proxy', express.json(), workerBrowserRoutes({ browser, previewDomain, browserBootstrap }));
+    app.use(browserPublic.handler);
+    const server = http.createServer(app);
+    const sockets = new Set();
+    server.on('connection', (socket) => {
+        sockets.add(socket);
+        socket.once('close', () => sockets.delete(socket));
+    });
+    server.on('upgrade', (req, socket, head) => {
+        if (!authenticated(req, internalToken)) {
+            socket.end('HTTP/1.1 401 Unauthorized\r\nConnection: close\r\n\r\n');
+            return;
+        }
+        delete req.headers[BROWSER_INTERNAL_HEADER];
+        if (!browserPublic.onUpgrade(req, socket, head))
+            socket.destroy();
+    });
+    await new Promise((resolve, reject) => {
+        const onError = (error) => { server.off('listening', onListening); reject(error); };
+        const onListening = () => { server.off('error', onError); resolve(); };
+        server.once('error', onError);
+        server.once('listening', onListening);
+        server.listen(port, host);
+    });
+    const address = server.address();
+    if (!address || typeof address === 'string')
+        throw new Error('browser worker did not bind a TCP port');
+    let closePromise = null;
+    return {
+        host,
+        port: address.port,
+        server,
+        browser,
+        close() {
+            if (!closePromise) {
+                closePromise = (async () => {
+                    const stopped = new Promise((resolve) => server.close(resolve));
+                    server.closeIdleConnections?.();
+                    for (const socket of sockets)
+                        socket.destroy();
+                    try {
+                        await browser.close?.();
+                    }
+                    finally {
+                        server.closeAllConnections?.();
+                        await stopped;
+                    }
+                })();
+            }
+            return closePromise;
+        },
+    };
+}

package/dist/src/captureBackground.js

@@ -0,0 +1,95 @@
+const CSI = /\x1b\[([0-9;]*)m/g;
+const ANSI = /\x1b(?:\[[0-?]*[ -/]*[@-~]|\][^\x07]*(?:\x07|\x1b\\))/g;
+function backgroundAfter(line, initial) {
+    let background = initial;
+    const sgr = new RegExp(CSI.source, 'g');
+    let match = sgr.exec(line);
+    while (match) {
+        const rawParams = match[1] ?? '';
+        const params = rawParams === '' ? [0] : rawParams.split(';').map(Number);
+        for (let i = 0; i < params.length; i += 1) {
+            const value = params[i] ?? 0;
+            if (value === 0 || value === 49)
+                background = false;
+            else if ((value >= 40 && value <= 47) || (value >= 100 && value <= 107))
+                background = true;
+            else if (value === 38 || value === 48) {
+                const isBackground = value === 48;
+                if (params[i + 1] === 5) {
+                    i += 2;
+                    if (isBackground)
+                        background = true;
+                }
+                else if (params[i + 1] === 2) {
+                    i += 4;
+                    if (isBackground)
+                        background = true;
+                }
+            }
+        }
+        match = sgr.exec(line);
+    }
+    return background;
+}
+function paintsBackground(line) {
+    let background = false;
+    let offset = 0;
+    const sgr = new RegExp(CSI.source, 'g');
+    let match = sgr.exec(line);
+    while (match) {
+        if (background && match.index > offset)
+            return true;
+        background = backgroundAfter(match[0], background);
+        offset = sgr.lastIndex;
+        match = sgr.exec(line);
+    }
+    return background && offset < line.length;
+}
+const isBlank = (line) => line.replace(ANSI, '').trim() === '';
+// `capture-pane -e -N` compresses SGR state across newlines. A default blank row after a shaded
+// row (Claude) and a genuinely shaded padding row (Codex) therefore look identical in the combined
+// capture. Capturing just that row makes tmux emit the row's real starting attributes. Only those
+// ambiguous rows need the extra read; ordinary rows keep the single fast combined capture.
+export function ambiguousBackgroundRows(lines) {
+    const indexes = [];
+    let background = false;
+    let inBlankRun = false;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index] ?? '';
+        const ambiguous = background && isBlank(line);
+        // One row resolves the whole trailing run: default closes it before the first LF; shaded is the
+        // one real padding row the client preserves and seals before clearing any additional blanks.
+        if (ambiguous && !inBlankRun)
+            indexes.push(index);
+        inBlankRun = ambiguous;
+        background = backgroundAfter(line, background);
+    }
+    return indexes;
+}
+export async function restoreBlankRowBackgrounds(lines, historyLines, readRow) {
+    const restored = [...lines];
+    const indexes = ambiguousBackgroundRows(lines);
+    await Promise.all(indexes.map(async (index) => {
+        const row = index - historyLines;
+        const exact = await readRow(row);
+        // A separately-captured default row has no background SGR. Explicitly close the combined
+        // stream's inherited background before replaying it. A real padding row starts with its own
+        // background SGR and is preserved verbatim.
+        restored[index] = paintsBackground(exact) ? exact : `\x1b[49m${exact}`;
+    }));
+    return restored;
+}
+export async function restoreCaptureBackgrounds(capture, paneHeight, readRow) {
+    const trailingNewline = capture.endsWith('\n');
+    const body = trailingNewline ? capture.slice(0, -1) : capture;
+    const lines = body.split('\n');
+    const historyLines = Math.max(0, lines.length - paneHeight);
+    const restored = await restoreBlankRowBackgrounds(lines, historyLines, async (row) => {
+        const exact = await readRow(row);
+        return exact.endsWith('\n') ? exact.slice(0, -1) : exact;
+    });
+    return {
+        ansi: restored.join('\n') + (trailingNewline ? '\n' : ''),
+        historyLines,
+    };
+}