termdock 1.4.55 → 1.4.57

package/dist/server/routes/filesystem.js

@@ -13,6 +13,8 @@ import { inspectBinaryFile } from '../utils/binaryFile.js';
 const router = Router();
 const MAX_FILE_SIZE = 1024 * 1024; // 1MB
 const MAX_IMAGE_PREVIEW_SIZE = 20 * 1024 * 1024; // 20MB
+const MAX_HTML_PREVIEW_SIZE = 20 * 1024 * 1024; // 20MB
+const MAX_VIDEO_PREVIEW_SIZE = 4 * 1024 * 1024 * 1024; // 4GB
 const MAX_DOWNLOAD_SIZE = 200 * 1024 * 1024; // 200MB
 const MAX_UPLOAD_SIZE = 100 * 1024 * 1024; // 100MB per file
 const MAX_UPLOAD_FILES = 50; // max 50 files per upload
@@ -44,6 +46,128 @@ const RESTORE_CONFIRM_PHRASES = new Set(['丢弃改动', 'discard changes']);
 const FS_IO_LOG_NAME = 'fs-io.log';
 const activeDiffSlots = new Map();
 const activeIoSlots = new Map();
+const sharedWatchRegistry = new Map();
+const SHARED_WATCH_EVICT_DELAY_MS = 60_000;
+function sharedWatchCallback(rootPath, entry) {
+    return (error, events) => {
+        if (entry.failure)
+            return;
+        if (error) {
+            entry.failure = error.message || 'watch-error';
+            const reason = entry.failure;
+            for (const client of entry.clients) {
+                if (!client.closed)
+                    client.enqueue({ type: 'rescan-required', path: rootPath, reason });
+            }
+            return;
+        }
+        for (const event of events) {
+            const changedPath = path.resolve(event.path);
+            if (!isPathInside(rootPath, changedPath) || isIgnoredWatchPath(rootPath, changedPath))
+                continue;
+            if (event.type === 'delete') {
+                for (const client of entry.clients) {
+                    if (!client.closed)
+                        client.enqueue({ type: 'deleted', path: changedPath });
+                }
+                continue;
+            }
+            fs.promises.lstat(changedPath)
+                .then((stat) => {
+                const payload = {
+                    type: event.type === 'create' ? 'created' : 'updated',
+                    path: changedPath,
+                    entry: toFileEntry(changedPath, stat),
+                };
+                for (const client of entry.clients) {
+                    if (!client.closed)
+                        client.enqueue(payload);
+                }
+            })
+                .catch(() => {
+                for (const client of entry.clients) {
+                    if (!client.closed)
+                        client.enqueue({ type: 'deleted', path: changedPath });
+                }
+            });
+        }
+    };
+}
+async function acquireSharedWatch(rootPath, client) {
+    let entry = sharedWatchRegistry.get(rootPath);
+    if (!entry) {
+        entry = {
+            refs: 0,
+            subscription: null,
+            failure: null,
+            clients: new Set(),
+            inFlight: null,
+            evictTimer: null,
+        };
+        sharedWatchRegistry.set(rootPath, entry);
+    }
+    if (entry.evictTimer) {
+        clearTimeout(entry.evictTimer);
+        entry.evictTimer = null;
+    }
+    entry.refs += 1;
+    entry.clients.add(client);
+    if (entry.failure)
+        return null;
+    if (entry.subscription)
+        return rootPath;
+    if (!entry.inFlight) {
+        entry.inFlight = watcher.subscribe(rootPath, sharedWatchCallback(rootPath, entry), {
+            ignore: Array.from(WATCH_IGNORED_NAMES).map((name) => `**/${name}/**`),
+        })
+            .then((subscription) => {
+            const current = sharedWatchRegistry.get(rootPath);
+            if (!current || current.refs === 0) {
+                // Nobody is watching anymore (client disconnected mid-scan): free
+                // the freshly built subscription instead of leaking its DirTree.
+                void subscription.unsubscribe().catch(() => undefined);
+                return null;
+            }
+            current.subscription = subscription;
+            return subscription;
+        })
+            .catch((error) => {
+            const current = sharedWatchRegistry.get(rootPath);
+            if (current)
+                current.failure = error instanceof Error ? error.message : String(error);
+            return null;
+        })
+            .finally(() => {
+            const current = sharedWatchRegistry.get(rootPath);
+            if (current)
+                current.inFlight = null;
+        });
+    }
+    await entry.inFlight;
+    const current = sharedWatchRegistry.get(rootPath);
+    return current && !current.failure ? rootPath : null;
+}
+function releaseSharedWatch(rootPath, client) {
+    client.closed = true;
+    const entry = sharedWatchRegistry.get(rootPath);
+    if (!entry)
+        return;
+    entry.clients.delete(client);
+    entry.refs -= 1;
+    if (entry.refs > 0)
+        return;
+    if (entry.evictTimer)
+        clearTimeout(entry.evictTimer);
+    entry.evictTimer = setTimeout(() => {
+        const current = sharedWatchRegistry.get(rootPath);
+        if (!current || current.refs > 0)
+            return;
+        sharedWatchRegistry.delete(rootPath);
+        void current.subscription?.unsubscribe().catch(() => undefined);
+        current.subscription = null;
+    }, SHARED_WATCH_EVICT_DELAY_MS);
+    entry.evictTimer.unref?.();
+}
 const untrackedJobs = new Map();
 const nestedGitRootsCache = new Map();
 const gitActionJobs = new Map();
@@ -287,6 +411,88 @@ const IMAGE_MIME_BY_EXT = {
 function getImageMimeType(filePath) {
     return IMAGE_MIME_BY_EXT[path.extname(filePath).toLowerCase()] ?? null;
 }
+// Video files play in the right sidebar through the /video route, which
+// streams with HTTP Range support so the browser <video> element can seek
+// without loading the whole file into memory. Keep the map to formats the
+// browser can actually decode (mkv/avi intentionally excluded).
+const VIDEO_MIME_BY_EXT = {
+    '.mp4': 'video/mp4',
+    '.m4v': 'video/x-m4v',
+    '.webm': 'video/webm',
+    '.mov': 'video/quicktime',
+    '.ogv': 'video/ogg',
+    '.mpeg': 'video/mpeg',
+    '.mpg': 'video/mpeg',
+};
+function getVideoMimeType(filePath) {
+    return VIDEO_MIME_BY_EXT[path.extname(filePath).toLowerCase()] ?? null;
+}
+// Single-range `Range: bytes=start-end` / `bytes=-N` parsing. Malformed or
+// multi-range headers fall back to a full 200 response, which browsers accept
+// (they just cannot seek until the file is buffered).
+function parseVideoRange(rangeHeader, total) {
+    if (!rangeHeader || total <= 0)
+        return { kind: 'full' };
+    const match = /^bytes=(\d*)-(\d*)$/.exec(rangeHeader.trim());
+    if (!match)
+        return { kind: 'full' };
+    const rawStart = match[1];
+    const rawEnd = match[2];
+    if (rawStart === '' && rawEnd === '')
+        return { kind: 'full' };
+    if (rawStart === '') {
+        const suffixLength = Number(rawEnd);
+        if (!Number.isInteger(suffixLength) || suffixLength <= 0)
+            return { kind: 'unsatisfiable' };
+        return { kind: 'range', start: Math.max(0, total - suffixLength), end: total - 1 };
+    }
+    const start = Number(rawStart);
+    if (!Number.isInteger(start) || start < 0 || start >= total)
+        return { kind: 'unsatisfiable' };
+    const end = rawEnd === '' ? total - 1 : Math.min(Number(rawEnd), total - 1);
+    if (!Number.isInteger(end) || end < start)
+        return { kind: 'unsatisfiable' };
+    return { kind: 'range', start, end };
+}
+// MIME types for the right-sidebar HTML preview route. The route mirrors the
+// absolute filesystem path in the URL, so every relative resource referenced
+// by a previewed document (css/js/fonts/images/...) is served by the same
+// route with a type the browser can render.
+const HTML_PREVIEW_MIME_BY_EXT = {
+    '.html': 'text/html; charset=utf-8',
+    '.htm': 'text/html; charset=utf-8',
+    '.css': 'text/css; charset=utf-8',
+    '.js': 'text/javascript; charset=utf-8',
+    '.mjs': 'text/javascript; charset=utf-8',
+    '.json': 'application/json; charset=utf-8',
+    '.map': 'application/json; charset=utf-8',
+    '.txt': 'text/plain; charset=utf-8',
+    '.md': 'text/markdown; charset=utf-8',
+    '.xml': 'application/xml; charset=utf-8',
+    '.svg': 'image/svg+xml',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.avif': 'image/avif',
+    '.ico': 'image/x-icon',
+    '.bmp': 'image/bmp',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+    '.ttf': 'font/ttf',
+    '.otf': 'font/otf',
+    '.eot': 'application/vnd.ms-fontobject',
+    '.wasm': 'application/wasm',
+    '.mp4': 'video/mp4',
+    '.webm': 'video/webm',
+    '.ogg': 'audio/ogg',
+    '.mp3': 'audio/mpeg',
+    '.wav': 'audio/wav',
+};
+function getHtmlPreviewMimeType(filePath) {
+    return HTML_PREVIEW_MIME_BY_EXT[path.extname(filePath).toLowerCase()] ?? null;
+}
 function toContentDispositionFilename(name) {
     return name.replace(/["\\\r\n]/g, '_').replace(/[^\x20-\x7E]/g, '_');
 }
@@ -2187,7 +2393,7 @@ router.get('/watch', async (req, res) => {
     let closed = false;
     let pending = [];
     let flushTimer = null;
-    const subscriptions = [];
+    const attachedRoots = new Map();
     const writeEvent = (type, payload) => {
         if (closed || res.destroyed)
             return;
@@ -2216,46 +2422,26 @@ router.get('/watch', async (req, res) => {
         }
     };
     writeEvent('ready', { roots });
-    for (const rootPath of roots) {
-        try {
-            const subscription = await watcher.subscribe(rootPath, (error, events) => {
-                if (closed)
-                    return;
-                if (error) {
-                    enqueue({ type: 'rescan-required', path: rootPath, reason: error.message || 'watch-error' });
-                    return;
-                }
-                for (const event of events) {
-                    const changedPath = path.resolve(event.path);
-                    if (!isPathInside(rootPath, changedPath) || isIgnoredWatchPath(rootPath, changedPath))
-                        continue;
-                    if (event.type === 'delete') {
-                        enqueue({ type: 'deleted', path: changedPath });
-                        continue;
-                    }
-                    fs.promises.lstat(changedPath)
-                        .then((stat) => {
-                        enqueue({ type: event.type === 'create' ? 'created' : 'updated', path: changedPath, entry: toFileEntry(changedPath, stat) });
-                    })
-                        .catch(() => {
-                        enqueue({ type: 'deleted', path: changedPath });
-                    });
-                }
-            }, {
-                ignore: Array.from(WATCH_IGNORED_NAMES).map((name) => `**/${name}/**`),
-            });
-            subscriptions.push(subscription);
-        }
-        catch (error) {
-            enqueue({ type: 'rescan-required', path: rootPath, reason: error instanceof Error ? error.message : 'watch-unavailable' });
+    const attachRoot = async (rootPath) => {
+        const client = { closed: false, enqueue };
+        attachedRoots.set(rootPath, client);
+        const ok = await acquireSharedWatch(rootPath, client);
+        if (closed)
+            return;
+        if (!ok) {
+            const reason = sharedWatchRegistry.get(rootPath)?.failure ?? 'watch-unavailable';
+            enqueue({ type: 'rescan-required', path: rootPath, reason });
         }
+    };
+    for (const rootPath of roots) {
+        await attachRoot(rootPath);
     }
     req.on('close', () => {
         closed = true;
         if (flushTimer)
             clearTimeout(flushTimer);
-        for (const subscription of subscriptions) {
-            void subscription.unsubscribe().catch(() => undefined);
+        for (const [rootPath, client] of attachedRoots) {
+            releaseSharedWatch(rootPath, client);
         }
     });
 });
@@ -2642,6 +2828,187 @@ router.get('/blob', async (req, res) => {
         res.status(status).json({ ...payload, code });
     }
 });
+// Serve video files for the right-sidebar preview. The route streams with
+// HTTP Range support, so <video> playback starts quickly and seeking works
+// without buffering the whole file in the browser or server memory.
+router.get('/video', async (req, res) => {
+    const requestId = ++fsIoRequestSeq;
+    const startedAt = Date.now();
+    const requestedPath = req.query.path;
+    const action = getRequestAction(req, 'view_file');
+    const requestSlotId = typeof req.query.requestSlotId === 'string' ? req.query.requestSlotId : undefined;
+    const controller = new AbortController();
+    const abortRequest = () => {
+        if (!res.writableEnded)
+            controller.abort(new SupersededRequestError('fs.video'));
+    };
+    req.on('aborted', abortRequest);
+    res.on('close', abortRequest);
+    registerIoSlot({ requestId, op: 'fs.video', action, slotId: requestSlotId, controller, path: requestedPath });
+    let logged = false;
+    const logOnce = (status, entry = {}) => {
+        if (logged)
+            return;
+        logged = true;
+        releaseIoSlot(requestSlotId, requestId);
+        logFsIo({
+            action,
+            op: 'fs.video',
+            id: requestId,
+            startedAt,
+            status,
+            path: requestedPath,
+            ...entry,
+            extra: { ...(entry.extra ?? {}), requestSlotId },
+        });
+    };
+    try {
+        if (!requestedPath) {
+            res.status(400).json({ error: 'Missing path parameter' });
+            return;
+        }
+        const { resolvedPath, stat, mimeType } = await withTimeout((async () => {
+            const resolvedPath = await pathValidator.validatePathAsync(requestedPath);
+            throwIfAborted(controller.signal, 'fs.video');
+            const stat = await fs.promises.stat(resolvedPath);
+            throwIfAborted(controller.signal, 'fs.video');
+            if (!stat.isFile()) {
+                throw new Error('Path is not a file');
+            }
+            const mimeType = getVideoMimeType(resolvedPath);
+            if (!mimeType) {
+                const error = new Error('Unsupported video type');
+                error.status = 415;
+                throw error;
+            }
+            if (stat.size > MAX_VIDEO_PREVIEW_SIZE) {
+                const error = new Error('Video is too large to preview');
+                error.code = 'VIDEO_TOO_LARGE';
+                error.status = 413;
+                throw error;
+            }
+            return { resolvedPath, stat, mimeType };
+        })(), FS_ROUTE_TIMEOUT_MS, 'Video preview took too long. The file may be on slow storage or currently blocked by another process.', 'FS_VIDEO_TIMEOUT');
+        const total = stat.size;
+        const range = parseVideoRange(typeof req.headers.range === 'string' ? req.headers.range : undefined, total);
+        res.setHeader('Accept-Ranges', 'bytes');
+        res.setHeader('Content-Type', mimeType);
+        res.setHeader('Last-Modified', stat.mtime.toUTCString());
+        res.setHeader('Cache-Control', 'no-store');
+        res.setHeader('X-Content-Type-Options', 'nosniff');
+        res.setHeader('Content-Disposition', buildContentDisposition('inline', path.basename(resolvedPath)));
+        if (req.method === 'HEAD') {
+            res.setHeader('Content-Length', total.toString());
+            if (range.kind === 'range')
+                res.setHeader('Content-Range', `bytes ${range.start}-${range.end}/${total}`);
+            res.end();
+            logOnce('ok', { path: resolvedPath, bytes: total, extra: { mimeType } });
+            return;
+        }
+        if (range.kind === 'unsatisfiable') {
+            res.status(416);
+            res.setHeader('Content-Range', `bytes */${total}`);
+            res.end();
+            logOnce('ok', { path: resolvedPath, bytes: 0, extra: { mimeType, status: 416 } });
+            return;
+        }
+        if (range.kind === 'range') {
+            res.status(206);
+            res.setHeader('Content-Range', `bytes ${range.start}-${range.end}/${total}`);
+            res.setHeader('Content-Length', String(range.end - range.start + 1));
+        }
+        else {
+            res.setHeader('Content-Length', total.toString());
+        }
+        const stream = fs.createReadStream(resolvedPath, range.kind === 'range' ? { start: range.start, end: range.end } : undefined);
+        controller.signal.addEventListener('abort', () => stream.destroy(controller.signal.reason instanceof Error ? controller.signal.reason : undefined), { once: true });
+        const bytesServed = range.kind === 'range' ? range.end - range.start + 1 : total;
+        res.on('finish', () => logOnce('ok', { path: resolvedPath, bytes: bytesServed, extra: { mimeType } }));
+        res.on('close', () => {
+            if (!res.writableEnded)
+                logOnce('error', { path: resolvedPath, bytes: bytesServed, code: 'CLIENT_CLOSED', error: 'Client closed video preview request' });
+        });
+        stream.on('error', (error) => {
+            logOnce('error', { path: resolvedPath, code: 'FS_VIDEO_STREAM_ERROR', error: error instanceof Error ? error.message : 'Failed to read video' });
+            if (!res.headersSent) {
+                const message = error instanceof Error ? error.message : 'Failed to read video';
+                res.status(500).json({ error: message });
+                return;
+            }
+            res.destroy(error instanceof Error ? error : undefined);
+        });
+        stream.pipe(res);
+    }
+    catch (error) {
+        const payload = getErrorPayload(error);
+        const status = error instanceof OperationTimeoutError
+            ? 504
+            : typeof error?.status === 'number'
+                ? error.status
+                : 403;
+        const code = payload.code ?? (typeof error?.code === 'string' ? error.code : undefined);
+        logOnce('error', { code, error: payload.error });
+        res.status(status).json({ ...payload, code });
+    }
+});
+// Serve workspace files for the right-sidebar HTML preview. The URL path
+// mirrors the absolute filesystem path (e.g. .../preview/home/user/proj/
+// index.html), so relative css/js/image references inside a document resolve
+// to the file's own directory without any content rewriting — the document
+// URL itself acts as the <base>. The frontend renders this in a sandboxed
+// iframe (no allow-same-origin), so previewed scripts never gain the termdock
+// origin.
+router.get('/preview/*path', async (req, res) => {
+    try {
+        const rawSegments = req.params.path;
+        const segments = Array.isArray(rawSegments) ? rawSegments : rawSegments ? [rawSegments] : [];
+        const requestedPath = `/${segments.join('/')}`;
+        if (!requestedPath || requestedPath === '/') {
+            res.status(400).json({ error: 'Missing path parameter' });
+            return;
+        }
+        const resolvedPath = await pathValidator.validatePathAsync(requestedPath);
+        const stat = await fs.promises.stat(resolvedPath);
+        if (!stat.isFile()) {
+            res.status(400).json({ error: 'Path is not a file' });
+            return;
+        }
+        const mimeType = getHtmlPreviewMimeType(resolvedPath);
+        if (!mimeType) {
+            res.status(415).json({ error: 'Unsupported file type for preview' });
+            return;
+        }
+        if (stat.size > MAX_HTML_PREVIEW_SIZE) {
+            res.status(413).json({
+                error: 'File is too large to preview',
+                code: 'FILE_TOO_LARGE',
+                size: stat.size,
+                maxSize: MAX_HTML_PREVIEW_SIZE,
+            });
+            return;
+        }
+        res.setHeader('Content-Type', mimeType);
+        res.setHeader('Content-Length', stat.size.toString());
+        res.setHeader('Last-Modified', stat.mtime.toUTCString());
+        res.setHeader('Cache-Control', 'no-store');
+        res.setHeader('X-Content-Type-Options', 'nosniff');
+        res.setHeader('Content-Disposition', buildContentDisposition('inline', path.basename(resolvedPath)));
+        const stream = fs.createReadStream(resolvedPath);
+        stream.on('error', (error) => {
+            if (!res.headersSent) {
+                const message = error instanceof Error ? error.message : 'Failed to serve file';
+                res.status(500).json({ error: message });
+                return;
+            }
+            res.destroy(error instanceof Error ? error : undefined);
+        });
+        stream.pipe(res);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        res.status(403).json({ error: message });
+    }
+});
 // Download any file as an attachment. Works in both PWA and normal browser
 // contexts — the frontend fetches this as a blob and either pipes it through
 // the File System Access API (showSaveFilePicker, desktop PWA/Chromium) or

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termdock",
-  "version": "1.4.55",
+  "version": "1.4.57",
   "description": "A complete web-based terminal application with modern UI",
   "type": "module",
   "main": ".desktop-dist/main.js",
@@ -83,6 +83,7 @@
     "refractor": "^2.10.1",
     "swiper": "^12.1.3",
     "tailwind-merge": "^2.2.0",
+    "three": "^0.185.1",
     "uuid": "^13.0.0",
     "web-push": "^3.6.7",
     "ws": "^8.21.0",
@@ -99,6 +100,7 @@
     "@types/node": "^20.11.0",
     "@types/react": "^18.2.0",
     "@types/react-dom": "^18.2.0",
+    "@types/three": "^0.185.3",
     "@types/uuid": "^10.0.0",
     "@types/web-push": "^3.6.4",
     "@types/ws": "^8.18.1",

package/runtime-manifest.json

@@ -1,12 +1,12 @@
 {
   "schemaVersion": 1,
   "packageName": "termdock",
-  "version": "1.4.55",
+  "version": "1.4.57",
   "runtimeProtocolVersion": 1,
   "minimumDesktopVersion": "1.4.46",
   "nodeMajor": 22,
-  "dependencyHash": "sha256-aUokhQIdbogiFjsYarTRvcQ40Rva3j5CIot/0H1Lyl4=",
-  "serverBundleHash": "sha256-+mlh3Ar6V1IOLEJ5l39G2XsUQ+TOgtvmKInjzinHPsA=",
+  "dependencyHash": "sha256-HxC6p3b4kFesefw+vmNYJtPtdIKJaZR1jFNb7DRJqjU=",
+  "serverBundleHash": "sha256-J9kh6qO+A3xC2pDnOVTjabHIwJicckHS3zzeXwAqheM=",
   "entrypoint": "dist/server/cli.js",
   "clientEntrypoint": "dist/client/index.html"
 }

package/dist/client/assets/channel-CMy1yWmT.js

@@ -1 +0,0 @@
-import{U as a,C as n}from"./mermaid.core-p5MzsEWg.js";const t=(r,o)=>a.lang.round(n.parse(r)[o]);export{t as c};

package/dist/client/assets/classDiagram-OUVF2IWQ-CWL2Kj7x.js

@@ -1 +0,0 @@
-import{s as a,a as s,c as t,C as e}from"./chunk-V7JOEXUC-Bg_lp0y3.js";import{b as i}from"./mermaid.core-p5MzsEWg.js";import"./chunk-5VM5RSS4-ZRKNZVGo.js";import"./chunk-XXDRQBXY-DHn8Vn3c.js";import"./chunk-VR4S4FIN-C93CSXty.js";import"./chunk-32BRIVSS-NdC1yaOj.js";import"./purify.es-CC4Brkr_.js";import"./index-7oItXRxL.js";import"./react-XDCjal2T.js";import"./dnd-BCFAPC0L.js";import"./terminal-C7X98Amf.js";var g={parser:t,get db(){return new e},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{g as diagram};

package/dist/client/assets/classDiagram-v2-EOCWNBFH-CWL2Kj7x.js

@@ -1 +0,0 @@
-import{s as a,a as s,c as t,C as e}from"./chunk-V7JOEXUC-Bg_lp0y3.js";import{b as i}from"./mermaid.core-p5MzsEWg.js";import"./chunk-5VM5RSS4-ZRKNZVGo.js";import"./chunk-XXDRQBXY-DHn8Vn3c.js";import"./chunk-VR4S4FIN-C93CSXty.js";import"./chunk-32BRIVSS-NdC1yaOj.js";import"./purify.es-CC4Brkr_.js";import"./index-7oItXRxL.js";import"./react-XDCjal2T.js";import"./dnd-BCFAPC0L.js";import"./terminal-C7X98Amf.js";var g={parser:t,get db(){return new e},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{g as diagram};