termdock 1.4.92 → 1.4.94

package/dist/server/routes/filesystem.js

@@ -1,6 +1,7 @@
 import { Router } from 'express';
 import crypto from 'crypto';
 import fs from 'fs';
+import os from 'os';
 import path from 'path';
 import { execFile, spawn } from 'child_process';
 import watcher from '@parcel/watcher';
@@ -14,6 +15,8 @@ import { getLanIPv4Addresses } from '../utils/localAccess.js';
 import { inspectBinaryFile } from '../utils/binaryFile.js';
 import { GitApplyError, HUNK_APPLY_MODES, runGitApply, validateHunkPatch } from '../utils/hunkApply.js';
 import { deleteFilesystemFile } from '../utils/deleteFilesystemFile.js';
+import { inspectKicadBoardPoint } from '../utils/kicadBoardInspection.js';
+import { EdaPreviewCache, requestAcceptsEtag } from '../utils/edaPreviewCache.js';
 const router = Router();
 const MAX_FILE_SIZE = 1024 * 1024; // 1MB
 const MAX_IMAGE_PREVIEW_SIZE = 20 * 1024 * 1024; // 20MB
@@ -43,6 +46,8 @@ const MAX_NESTED_GIT_REPOS = 32;
 const NESTED_GIT_DISCOVERY_TIMEOUT_MS = 1_000;
 const NESTED_GIT_DISCOVERY_CACHE_TTL_MS = 60_000;
 const FS_ROUTE_TIMEOUT_MS = 6_000;
+const EDA_PREVIEW_TIMEOUT_MS = 30_000;
+const EDA_PREVIEW_CACHE_MAX_BYTES = 64 * 1024 * 1024;
 const GIT_ROUTE_TIMEOUT_MS = 8_000;
 const GIT_FILE_DIFF_ROUTE_TIMEOUT_MS = 45_000;
 const GIT_ACTION_TIMEOUT_MS = 10 * 60_000;
@@ -2758,6 +2763,208 @@ router.get('/git-blob', async (req, res) => {
         res.status(error instanceof OperationTimeoutError ? 504 : 200).json({ path: requestedPath ?? null, content: '', ...payload });
     }
 });
+const EDA_PREVIEW_VIEWS = new Set(['schematic', 'pcb-front', 'pcb-back', 'pcb-3d']);
+const edaPreviewCache = new EdaPreviewCache(EDA_PREVIEW_CACHE_MAX_BYTES);
+function runKicadCli(args, cwd, signal) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const proc = execFile('kicad-cli', args, { cwd, maxBuffer: 4 * 1024 * 1024 }, (error, _stdout, stderr) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            signal.removeEventListener('abort', abortHandler);
+            if (error) {
+                reject(new Error(stderr.trim() || error.message));
+            }
+            else {
+                resolve();
+            }
+        });
+        const timer = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            proc.kill();
+            signal.removeEventListener('abort', abortHandler);
+            reject(new OperationTimeoutError('KiCad preview rendering timed out.', 'EDA_PREVIEW_TIMEOUT'));
+        }, EDA_PREVIEW_TIMEOUT_MS);
+        const abortHandler = () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            proc.kill();
+            reject(signal.reason instanceof Error ? signal.reason : new SupersededRequestError('fs.eda-preview'));
+        };
+        if (signal.aborted)
+            abortHandler();
+        else
+            signal.addEventListener('abort', abortHandler, { once: true });
+    });
+}
+// Render native KiCad sources for Review. The source path is passed as an
+// execFile argument (never through a shell), and every output lives in a
+// request-scoped temporary directory which is deleted after the response.
+router.get('/eda-preview', async (req, res) => {
+    const requestId = ++fsIoRequestSeq;
+    const startedAt = Date.now();
+    const requestedPath = req.query.path;
+    const requestedView = req.query.view;
+    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.eda-preview'));
+    };
+    req.on('aborted', abortRequest);
+    res.on('close', abortRequest);
+    registerIoSlot({ requestId, op: 'fs.eda-preview', action, slotId: requestSlotId, controller, path: requestedPath });
+    let tempDir = null;
+    try {
+        if (!requestedPath || !EDA_PREVIEW_VIEWS.has(requestedView)) {
+            res.status(400).json({ error: 'Missing path or invalid KiCad preview view' });
+            return;
+        }
+        const resolvedPath = await pathValidator.validatePathAsync(requestedPath);
+        const stat = await fs.promises.stat(resolvedPath);
+        if (!stat.isFile())
+            throw new Error('Path is not a file');
+        const lowerPath = resolvedPath.toLowerCase();
+        const isSchematic = lowerPath.endsWith('.kicad_sch');
+        const isBoard = lowerPath.endsWith('.kicad_pcb');
+        if (!isSchematic && !isBoard) {
+            res.status(415).json({ error: 'Only .kicad_sch and .kicad_pcb previews are supported' });
+            return;
+        }
+        if ((isSchematic && requestedView !== 'schematic') || (isBoard && requestedView === 'schematic')) {
+            res.status(400).json({ error: 'Preview view does not match the KiCad file type' });
+            return;
+        }
+        const versionKey = `${resolvedPath}\0${requestedView}\0${stat.size}\0${stat.mtimeMs}`;
+        const etag = `"eda-${crypto.createHash('sha256').update(versionKey).digest('base64url').slice(0, 24)}"`;
+        res.setHeader('ETag', etag);
+        res.setHeader('Last-Modified', stat.mtime.toUTCString());
+        res.setHeader('Cache-Control', 'private, no-cache');
+        res.setHeader('X-Content-Type-Options', 'nosniff');
+        res.setHeader('X-Eda-View', requestedView);
+        if (requestAcceptsEtag(req.headers['if-none-match'], etag)) {
+            res.setHeader('X-Eda-Cache', 'revalidated');
+            res.status(304).end();
+            logFsIo({ id: requestId, action, op: 'fs.eda-preview', startedAt, status: 'ok', path: resolvedPath, bytes: 0, extra: { view: requestedView, requestSlotId, cache: 'revalidated' } });
+            return;
+        }
+        const cached = edaPreviewCache.get(versionKey);
+        if (cached) {
+            res.setHeader('Content-Type', cached.mimeType);
+            res.setHeader('Content-Length', String(cached.body.length));
+            res.setHeader('X-Eda-Cache', 'hit');
+            res.send(cached.body);
+            logFsIo({ id: requestId, action, op: 'fs.eda-preview', startedAt, status: 'ok', path: resolvedPath, bytes: cached.body.length, extra: { view: requestedView, requestSlotId, cache: 'hit' } });
+            return;
+        }
+        tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'termdock-eda-preview-'));
+        let outputPath;
+        let mimeType;
+        if (isSchematic) {
+            await runKicadCli([
+                'sch', 'export', 'svg', '--output', tempDir, '--pages', '1',
+                '--exclude-drawing-sheet', '--no-background-color', resolvedPath,
+            ], path.dirname(resolvedPath), controller.signal);
+            const svgFiles = (await fs.promises.readdir(tempDir)).filter((name) => name.toLowerCase().endsWith('.svg')).sort();
+            if (svgFiles.length === 0)
+                throw new Error('KiCad did not produce a schematic SVG');
+            outputPath = path.join(tempDir, svgFiles[0]);
+            mimeType = 'image/svg+xml';
+        }
+        else if (requestedView === 'pcb-3d') {
+            outputPath = path.join(tempDir, 'pcb-3d.glb');
+            await runKicadCli([
+                'pcb', 'export', 'glb', '--output', outputPath, '--force',
+                '--include-tracks', '--include-pads', '--include-silkscreen', '--include-soldermask',
+                resolvedPath,
+            ], path.dirname(resolvedPath), controller.signal);
+            mimeType = 'model/gltf-binary';
+        }
+        else {
+            const front = requestedView === 'pcb-front';
+            outputPath = path.join(tempDir, front ? 'pcb-front.svg' : 'pcb-back.svg');
+            const layers = front
+                ? 'F.Cu,F.Mask,F.Silkscreen,Edge.Cuts'
+                : 'B.Cu,B.Mask,B.Silkscreen,Edge.Cuts';
+            const args = [
+                'pcb', 'export', 'svg', '--output', outputPath, '--mode-single', '--layers', layers,
+                '--page-size-mode', '2', '--fit-page-to-board', '--exclude-drawing-sheet',
+            ];
+            if (!front)
+                args.push('--mirror');
+            args.push(resolvedPath);
+            await runKicadCli(args, path.dirname(resolvedPath), controller.signal);
+            mimeType = 'image/svg+xml';
+        }
+        const output = await fs.promises.readFile(outputPath);
+        if (output.length > MAX_IMAGE_PREVIEW_SIZE) {
+            res.status(413).json({ error: 'Rendered KiCad preview is too large' });
+            return;
+        }
+        edaPreviewCache.set(versionKey, { body: output, mimeType });
+        res.setHeader('Content-Type', mimeType);
+        res.setHeader('Content-Length', String(output.length));
+        res.setHeader('X-Eda-Cache', 'miss');
+        res.send(output);
+        logFsIo({ id: requestId, action, op: 'fs.eda-preview', startedAt, status: 'ok', path: resolvedPath, bytes: output.length, extra: { view: requestedView, requestSlotId, cache: 'miss' } });
+    }
+    catch (error) {
+        const payload = getErrorPayload(error);
+        if (!res.headersSent) {
+            res.status(error instanceof OperationTimeoutError ? 504 : 403).json(payload);
+        }
+        logFsIo({ id: requestId, action, op: 'fs.eda-preview', startedAt, status: 'error', path: requestedPath, code: payload.code, error: payload.error, extra: { view: requestedView, requestSlotId } });
+    }
+    finally {
+        releaseIoSlot(requestSlotId, requestId);
+        if (tempDir)
+            await fs.promises.rm(tempDir, { recursive: true, force: true }).catch(() => undefined);
+    }
+});
+router.get('/eda-inspect', async (req, res) => {
+    const requestedPath = req.query.path;
+    const requestedView = req.query.view;
+    const xPercent = Number(req.query.x);
+    const yPercent = Number(req.query.y);
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(new OperationTimeoutError('KiCad point inspection timed out.', 'EDA_INSPECT_TIMEOUT')), EDA_PREVIEW_TIMEOUT_MS);
+    const abortRequest = () => {
+        if (!res.writableEnded)
+            controller.abort(new SupersededRequestError('fs.eda-inspect'));
+    };
+    req.on('aborted', abortRequest);
+    res.on('close', abortRequest);
+    try {
+        if (!requestedPath || !EDA_PREVIEW_VIEWS.has(requestedView)
+            || !Number.isFinite(xPercent) || !Number.isFinite(yPercent)
+            || xPercent < 0 || xPercent > 100 || yPercent < 0 || yPercent > 100) {
+            res.status(400).json({ error: 'Missing path, view, or valid preview coordinates' });
+            return;
+        }
+        const resolvedPath = await pathValidator.validatePathAsync(requestedPath);
+        if (!resolvedPath.toLowerCase().endsWith('.kicad_pcb')) {
+            res.json({ available: false, reason: '只有 PCB 文件支持工程坐标' });
+            return;
+        }
+        const result = await inspectKicadBoardPoint(resolvedPath, requestedView, xPercent, yPercent, controller.signal);
+        res.setHeader('Cache-Control', 'no-store');
+        res.json(result);
+    }
+    catch (error) {
+        if (!res.headersSent)
+            res.status(error instanceof OperationTimeoutError ? 504 : 500).json(getErrorPayload(error));
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+});
 // Stream supported image files for the right sidebar preview.
 router.get('/blob', async (req, res) => {
     const requestId = ++fsIoRequestSeq;

package/dist/server/utils/edaPreviewCache.js

@@ -0,0 +1,49 @@
+/** Small byte-bounded LRU for expensive KiCad render results. */
+export class EdaPreviewCache {
+    maxBytes;
+    entries = new Map();
+    totalBytes = 0;
+    constructor(maxBytes) {
+        this.maxBytes = maxBytes;
+    }
+    get(key) {
+        const entry = this.entries.get(key);
+        if (!entry)
+            return undefined;
+        this.entries.delete(key);
+        this.entries.set(key, entry);
+        return entry;
+    }
+    set(key, entry) {
+        const previous = this.entries.get(key);
+        if (previous) {
+            this.totalBytes -= previous.body.length;
+            this.entries.delete(key);
+        }
+        if (entry.body.length > this.maxBytes)
+            return;
+        this.entries.set(key, entry);
+        this.totalBytes += entry.body.length;
+        while (this.totalBytes > this.maxBytes) {
+            const oldestKey = this.entries.keys().next().value;
+            if (oldestKey === undefined)
+                break;
+            const oldest = this.entries.get(oldestKey);
+            this.entries.delete(oldestKey);
+            if (oldest)
+                this.totalBytes -= oldest.body.length;
+        }
+    }
+    get sizeBytes() {
+        return this.totalBytes;
+    }
+}
+export function requestAcceptsEtag(header, etag) {
+    if (!header)
+        return false;
+    const target = etag.replace(/^W\//, '');
+    return (Array.isArray(header) ? header : [header]).some((value) => (value.split(',').some((candidate) => {
+        const token = candidate.trim();
+        return token === '*' || token.replace(/^W\//, '') === target;
+    })));
+}

package/dist/server/utils/kicadBoardInspection.js

@@ -0,0 +1,140 @@
+import { execFile } from 'child_process';
+const KICAD_INSPECTION_SCRIPT = String.raw `
+import json, math, sys
+import pcbnew
+
+board_path, view, x_text, y_text = sys.argv[1:5]
+x_percent = float(x_text)
+y_percent = float(y_text)
+
+if view not in ('pcb-front', 'pcb-back'):
+    print(json.dumps({'available': False, 'reason': '该视图不支持精确 PCB 坐标'}))
+    raise SystemExit(0)
+
+board = pcbnew.LoadBoard(board_path)
+box = board.GetBoardEdgesBoundingBox()
+left = pcbnew.ToMM(box.GetLeft())
+top = pcbnew.ToMM(box.GetTop())
+width = pcbnew.ToMM(box.GetWidth())
+height = pcbnew.ToMM(box.GetHeight())
+source_x_percent = 100.0 - x_percent if view == 'pcb-back' else x_percent
+x_mm = left + width * source_x_percent / 100.0
+y_mm = top + height * y_percent / 100.0
+visible_layer_id = pcbnew.F_Cu if view == 'pcb-front' else pcbnew.B_Cu
+visible_layer = board.GetLayerName(visible_layer_id)
+candidates = []
+
+def distance(x, y):
+    return math.hypot(x - x_mm, y - y_mm)
+
+def add(kind, label, layer, x, y, reference=None, pad=None, net=None):
+    item = {
+        'kind': kind,
+        'label': label,
+        'layer': layer,
+        'distanceMm': distance(x, y),
+    }
+    if reference:
+        item['reference'] = reference
+    if pad:
+        item['pad'] = pad
+    if net:
+        item['net'] = net
+    candidates.append(item)
+
+for footprint in board.GetFootprints():
+    reference = footprint.GetReference()
+    value = footprint.GetValue()
+    fp_layer = footprint.GetLayerName()
+    if footprint.GetLayer() == visible_layer_id:
+        pos = footprint.GetPosition()
+        add('footprint', reference + (f' ({value})' if value else ''), fp_layer,
+            pcbnew.ToMM(pos.x), pcbnew.ToMM(pos.y), reference=reference)
+    for pad_item in footprint.Pads():
+        if not pad_item.IsOnLayer(visible_layer_id):
+            continue
+        pos = pad_item.GetPosition()
+        pad_number = pad_item.GetNumber()
+        net_name = pad_item.GetNetname()
+        label = reference + (f' 焊盘 {pad_number}' if pad_number else ' 焊盘')
+        add('pad', label, visible_layer, pcbnew.ToMM(pos.x), pcbnew.ToMM(pos.y),
+            reference=reference, pad=pad_number or None, net=net_name or None)
+
+def segment_distance(px, py, ax, ay, bx, by):
+    dx, dy = bx - ax, by - ay
+    if dx == 0 and dy == 0:
+        return math.hypot(px - ax, py - ay)
+    t = max(0.0, min(1.0, ((px - ax) * dx + (py - ay) * dy) / (dx * dx + dy * dy)))
+    return math.hypot(px - (ax + t * dx), py - (ay + t * dy))
+
+for track in board.GetTracks():
+    if isinstance(track, pcbnew.PCB_VIA):
+        if not track.IsOnLayer(visible_layer_id):
+            continue
+        pos = track.GetPosition()
+        net_name = track.GetNetname()
+        add('via', '过孔', 'F.Cu↔B.Cu', pcbnew.ToMM(pos.x), pcbnew.ToMM(pos.y), net=net_name or None)
+        continue
+    if track.GetLayer() != visible_layer_id:
+        continue
+    start, end = track.GetStart(), track.GetEnd()
+    ax, ay = pcbnew.ToMM(start.x), pcbnew.ToMM(start.y)
+    bx, by = pcbnew.ToMM(end.x), pcbnew.ToMM(end.y)
+    net_name = track.GetNetname()
+    item = {
+        'kind': 'track',
+        'label': '走线',
+        'layer': track.GetLayerName(),
+        'distanceMm': segment_distance(x_mm, y_mm, ax, ay, bx, by),
+    }
+    if net_name:
+        item['net'] = net_name
+    candidates.append(item)
+
+candidates.sort(key=lambda item: item['distanceMm'])
+nearest = candidates[0] if candidates else None
+if nearest:
+    nearest['distanceMm'] = round(nearest['distanceMm'], 3)
+
+result = {
+    'available': True,
+    'xMm': round(x_mm, 3),
+    'yMm': round(y_mm, 3),
+    'layer': visible_layer,
+}
+if nearest:
+    result['nearest'] = nearest
+print(json.dumps(result, ensure_ascii=False))
+`;
+export function inspectKicadBoardPoint(boardPath, view, xPercent, yPercent, signal) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const child = execFile('python3', ['-c', KICAD_INSPECTION_SCRIPT, boardPath, view, String(xPercent), String(yPercent)], { maxBuffer: 4 * 1024 * 1024 }, (error, stdout, stderr) => {
+            if (settled)
+                return;
+            settled = true;
+            signal.removeEventListener('abort', abortHandler);
+            if (error) {
+                reject(new Error(stderr.trim() || error.message));
+                return;
+            }
+            try {
+                resolve(JSON.parse(stdout.trim()));
+            }
+            catch {
+                reject(new Error('KiCad point inspection returned invalid JSON'));
+            }
+        });
+        const abortHandler = () => {
+            if (settled)
+                return;
+            settled = true;
+            child.kill();
+            reject(signal.reason instanceof Error ? signal.reason : new Error('KiCad point inspection aborted'));
+        };
+        if (signal.aborted)
+            abortHandler();
+        else
+            signal.addEventListener('abort', abortHandler, { once: true });
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termdock",
-  "version": "1.4.92",
+  "version": "1.4.94",
   "description": "A complete web-based terminal application with modern UI",
   "type": "module",
   "main": ".desktop-dist/main.js",

package/runtime-manifest.json

@@ -1,12 +1,12 @@
 {
   "schemaVersion": 1,
   "packageName": "termdock",
-  "version": "1.4.92",
+  "version": "1.4.94",
   "runtimeProtocolVersion": 1,
   "minimumDesktopVersion": "1.4.46",
   "nodeMajor": 22,
   "dependencyHash": "sha256-emuXnf9w0kJF3ksMJVvdI0u8oLHKwZJ2/OzHBAXulZs=",
-  "serverBundleHash": "sha256-TUPgHrwQRzpIN5bsUm0s6gRlrL6s7keSgiKy5yGwehY=",
+  "serverBundleHash": "sha256-Cxmc1ULHs9sunGqn3hhWQ1LifuY3eZTGro5l9nnY+ds=",
   "entrypoint": "dist/server/cli.js",
   "clientEntrypoint": "dist/client/index.html"
 }

package/dist/client/assets/channel-C-v7eWaN.js

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

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

@@ -1 +0,0 @@
-import{s as a,a as s,c as t,C as e}from"./chunk-V7JOEXUC-CDxVHUrw.js";import{b as i}from"./mermaid.core-6cbfSb9q.js";import"./chunk-5VM5RSS4-CUgLgCDa.js";import"./chunk-XXDRQBXY-CVarUP0O.js";import"./chunk-VR4S4FIN-DGpBeuzs.js";import"./chunk-32BRIVSS-CbNSO3Wd.js";import"./purify.es-CC4Brkr_.js";import"./index-oKZ6p6xu.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-CwRQhTCb.js

@@ -1 +0,0 @@
-import{s as a,a as s,c as t,C as e}from"./chunk-V7JOEXUC-CDxVHUrw.js";import{b as i}from"./mermaid.core-6cbfSb9q.js";import"./chunk-5VM5RSS4-CUgLgCDa.js";import"./chunk-XXDRQBXY-CVarUP0O.js";import"./chunk-VR4S4FIN-DGpBeuzs.js";import"./chunk-32BRIVSS-CbNSO3Wd.js";import"./purify.es-CC4Brkr_.js";import"./index-oKZ6p6xu.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};