termdock 1.4.107 → 1.4.109

package/dist/server/utils/runtimeMonitor.js

@@ -0,0 +1,287 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { monitorEventLoopDelay } from 'node:perf_hooks';
+const SAMPLE_INTERVAL_MS = 10_000;
+const HISTORY_INTERVAL_MS = 60_000;
+const MAX_HISTORY_SAMPLES = 24 * 60;
+function round(value, digits = 2) {
+    if (!Number.isFinite(value))
+        return 0;
+    const scale = 10 ** digits;
+    return Math.round(value * scale) / scale;
+}
+function percentile(values, quantile) {
+    if (values.length === 0)
+        return 0;
+    const ordered = [...values].sort((a, b) => a - b);
+    return ordered[Math.min(ordered.length - 1, Math.floor(ordered.length * quantile))] ?? 0;
+}
+function readProcessIo() {
+    if (process.platform !== 'linux')
+        return { readBytes: 0, writeBytes: 0 };
+    try {
+        const values = new Map(fs.readFileSync('/proc/self/io', 'utf8').trim().split('\n').map((line) => {
+            const separator = line.indexOf(':');
+            return [line.slice(0, separator), Number(line.slice(separator + 1).trim())];
+        }));
+        return { readBytes: values.get('read_bytes') ?? 0, writeBytes: values.get('write_bytes') ?? 0 };
+    }
+    catch {
+        return { readBytes: 0, writeBytes: 0 };
+    }
+}
+async function collectStorageSnapshot(root, maxEntries = 20_000) {
+    const totals = new Map();
+    const queue = [root];
+    let totalBytes = 0;
+    let fileCount = 0;
+    let visited = 0;
+    while (queue.length > 0 && visited < maxEntries) {
+        const directory = queue.shift();
+        let entries;
+        try {
+            entries = await fs.promises.readdir(directory, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (visited >= maxEntries)
+                break;
+            visited += 1;
+            const entryPath = path.join(directory, entry.name);
+            if (entry.isDirectory()) {
+                queue.push(entryPath);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            try {
+                const stat = await fs.promises.stat(entryPath);
+                totalBytes += stat.size;
+                fileCount += 1;
+                const topLevelName = path.relative(root, entryPath).split(path.sep)[0] || entry.name;
+                totals.set(topLevelName, (totals.get(topLevelName) ?? 0) + stat.size);
+            }
+            catch { /* The file may disappear while diagnostics walk the directory. */ }
+        }
+    }
+    let freeBytes = null;
+    let totalFilesystemBytes = null;
+    try {
+        const stat = await fs.promises.statfs(root);
+        freeBytes = stat.bavail * stat.bsize;
+        totalFilesystemBytes = stat.blocks * stat.bsize;
+    }
+    catch { /* Not available on every supported filesystem. */ }
+    return {
+        root, totalBytes, fileCount, truncated: queue.length > 0 || visited >= maxEntries,
+        freeBytes, totalFilesystemBytes,
+        topLevel: [...totals.entries()].map(([name, bytes]) => ({ name, bytes })).sort((a, b) => b.bytes - a.bytes).slice(0, 20),
+    };
+}
+export function evaluateRuntimeHealth(sample, storage) {
+    const findings = [];
+    const add = (severity, code, message, value, threshold) => {
+        findings.push({ severity, code, message, value: round(value), threshold });
+    };
+    if (sample.rssBytes >= 1024 ** 3)
+        add('critical', 'PROCESS_RSS_HIGH', 'Termdock 内存占用超过 1 GiB', sample.rssBytes, 1024 ** 3);
+    else if (sample.rssBytes >= 512 * 1024 ** 2)
+        add('warning', 'PROCESS_RSS_HIGH', 'Termdock 内存占用超过 512 MiB', sample.rssBytes, 512 * 1024 ** 2);
+    if (sample.eventLoopDelayP99Ms >= 500)
+        add('critical', 'EVENT_LOOP_STALLED', 'Node.js 事件循环 P99 延迟过高', sample.eventLoopDelayP99Ms, 500);
+    else if (sample.eventLoopDelayP99Ms >= 100)
+        add('warning', 'EVENT_LOOP_SLOW', 'Node.js 事件循环 P99 延迟偏高', sample.eventLoopDelayP99Ms, 100);
+    if (sample.diskWriteBytesPerSecond >= 25 * 1024 ** 2)
+        add('critical', 'DISK_WRITE_RATE_HIGH', 'Termdock 持续磁盘写入速率过高', sample.diskWriteBytesPerSecond, 25 * 1024 ** 2);
+    else if (sample.diskWriteBytesPerSecond >= 5 * 1024 ** 2)
+        add('warning', 'DISK_WRITE_RATE_HIGH', 'Termdock 磁盘写入速率偏高', sample.diskWriteBytesPerSecond, 5 * 1024 ** 2);
+    if (sample.activeConnections >= 1000)
+        add('critical', 'CONNECTION_COUNT_HIGH', 'Termdock 活跃连接数过高', sample.activeConnections, 1000);
+    else if (sample.activeConnections >= 200)
+        add('warning', 'CONNECTION_COUNT_HIGH', 'Termdock 活跃连接数偏高', sample.activeConnections, 200);
+    if (sample.requestsPerSecond >= 0.25 && sample.requestErrorRatio >= 0.25)
+        add('critical', 'REQUEST_ERROR_RATIO_HIGH', '最近采样窗口请求错误率过高', sample.requestErrorRatio, 0.25);
+    else if (sample.requestsPerSecond >= 0.25 && sample.requestErrorRatio >= 0.1)
+        add('warning', 'REQUEST_ERROR_RATIO_HIGH', '最近采样窗口请求错误率偏高', sample.requestErrorRatio, 0.1);
+    if (sample.requestLatencyP95Ms >= 5_000)
+        add('critical', 'REQUEST_LATENCY_HIGH', '请求 P95 延迟超过 5 秒', sample.requestLatencyP95Ms, 5_000);
+    else if (sample.requestLatencyP95Ms >= 1_000)
+        add('warning', 'REQUEST_LATENCY_HIGH', '请求 P95 延迟超过 1 秒', sample.requestLatencyP95Ms, 1_000);
+    if (storage.totalBytes >= 2 * 1024 ** 3)
+        add('critical', 'STATE_DIRECTORY_LARGE', 'Termdock 状态目录超过 2 GiB', storage.totalBytes, 2 * 1024 ** 3);
+    else if (storage.totalBytes >= 512 * 1024 ** 2)
+        add('warning', 'STATE_DIRECTORY_LARGE', 'Termdock 状态目录超过 512 MiB', storage.totalBytes, 512 * 1024 ** 2);
+    if (storage.freeBytes !== null && storage.totalFilesystemBytes) {
+        const freeRatio = storage.freeBytes / storage.totalFilesystemBytes;
+        if (storage.freeBytes <= 1024 ** 3 || freeRatio <= 0.05)
+            add('critical', 'DISK_SPACE_LOW', 'Termdock 所在磁盘剩余空间严重不足', freeRatio, 0.05);
+        else if (storage.freeBytes <= 5 * 1024 ** 3 || freeRatio <= 0.1)
+            add('warning', 'DISK_SPACE_LOW', 'Termdock 所在磁盘剩余空间偏低', freeRatio, 0.1);
+    }
+    return findings;
+}
+export class RuntimeMonitor {
+    stateDirectory;
+    historyPath;
+    sampleIntervalMs;
+    historyIntervalMs;
+    maxHistorySamples;
+    sockets = new Map();
+    eventLoopHistogram;
+    history = [];
+    current = null;
+    sampleTimer = null;
+    lastHistoryAt = 0;
+    previousAt = Date.now();
+    previousCpu = process.cpuUsage();
+    previousIo = readProcessIo();
+    closedSocketBytes = { read: 0, written: 0 };
+    previousSocketBytes = { read: 0, written: 0 };
+    requestDurations = [];
+    requestCount = 0;
+    requestErrors = 0;
+    constructor(options) {
+        this.stateDirectory = options.stateDirectory;
+        this.historyPath = options.historyPath ?? null;
+        this.sampleIntervalMs = options.sampleIntervalMs ?? SAMPLE_INTERVAL_MS;
+        this.historyIntervalMs = options.historyIntervalMs ?? HISTORY_INTERVAL_MS;
+        this.maxHistorySamples = options.maxHistorySamples ?? MAX_HISTORY_SAMPLES;
+        this.eventLoopHistogram = monitorEventLoopDelay({ resolution: 20 });
+        this.loadHistory();
+    }
+    start() {
+        if (this.sampleTimer)
+            return;
+        this.eventLoopHistogram.enable();
+        this.sample();
+        this.sampleTimer = setInterval(() => this.sample(), this.sampleIntervalMs);
+        this.sampleTimer.unref?.();
+    }
+    stop() {
+        if (this.sampleTimer)
+            clearInterval(this.sampleTimer);
+        this.sampleTimer = null;
+        this.eventLoopHistogram.disable();
+    }
+    trackSocket(socket) {
+        if (this.sockets.has(socket))
+            return;
+        this.sockets.set(socket, { read: socket.bytesRead, written: socket.bytesWritten });
+        socket.once('close', () => {
+            const baseline = this.sockets.get(socket);
+            if (!baseline)
+                return;
+            this.closedSocketBytes.read += Math.max(0, socket.bytesRead - baseline.read);
+            this.closedSocketBytes.written += Math.max(0, socket.bytesWritten - baseline.written);
+            this.sockets.delete(socket);
+        });
+    }
+    recordRequest(statusCode, durationMs) {
+        this.requestCount += 1;
+        if (statusCode >= 400)
+            this.requestErrors += 1;
+        if (Number.isFinite(durationMs))
+            this.requestDurations.push(durationMs);
+        if (this.requestDurations.length > 10_000)
+            this.requestDurations.splice(0, this.requestDurations.length - 10_000);
+    }
+    sample(now = Date.now()) {
+        const elapsedSeconds = Math.max(0.001, (now - this.previousAt) / 1000);
+        const cpu = process.cpuUsage(this.previousCpu);
+        const cpuProcessPercent = (cpu.user + cpu.system) / 1_000_000 / elapsedSeconds * 100;
+        const io = readProcessIo();
+        const socketBytes = this.getSocketBytes();
+        const memory = process.memoryUsage();
+        const requestCount = this.requestCount;
+        const result = {
+            timestamp: now,
+            uptimeSeconds: round(process.uptime()),
+            cpuProcessPercent: round(cpuProcessPercent),
+            cpuHostCapacityPercent: round(cpuProcessPercent / Math.max(1, os.availableParallelism())),
+            rssBytes: memory.rss,
+            heapUsedBytes: memory.heapUsed,
+            heapTotalBytes: memory.heapTotal,
+            externalBytes: memory.external,
+            eventLoopDelayP99Ms: round(this.eventLoopHistogram.percentile(99) / 1_000_000),
+            diskReadBytesPerSecond: round(Math.max(0, io.readBytes - this.previousIo.readBytes) / elapsedSeconds),
+            diskWriteBytesPerSecond: round(Math.max(0, io.writeBytes - this.previousIo.writeBytes) / elapsedSeconds),
+            networkReadBytesPerSecond: round(Math.max(0, socketBytes.read - this.previousSocketBytes.read) / elapsedSeconds),
+            networkWriteBytesPerSecond: round(Math.max(0, socketBytes.written - this.previousSocketBytes.written) / elapsedSeconds),
+            activeConnections: this.sockets.size,
+            requestsPerSecond: round(requestCount / elapsedSeconds),
+            requestErrorRatio: round(requestCount > 0 ? this.requestErrors / requestCount : 0, 4),
+            requestLatencyP95Ms: round(percentile(this.requestDurations, 0.95)),
+        };
+        this.current = result;
+        this.previousAt = now;
+        this.previousCpu = process.cpuUsage();
+        this.previousIo = io;
+        this.previousSocketBytes = socketBytes;
+        this.requestCount = 0;
+        this.requestErrors = 0;
+        this.requestDurations = [];
+        this.eventLoopHistogram.reset();
+        if (now - this.lastHistoryAt >= this.historyIntervalMs) {
+            this.history.push(result);
+            this.history = this.history.slice(-this.maxHistorySamples);
+            this.lastHistoryAt = now;
+            this.appendHistory(result);
+        }
+        return result;
+    }
+    async diagnostics() {
+        const current = this.current ?? this.sample();
+        const storage = await collectStorageSnapshot(this.stateDirectory);
+        const findings = evaluateRuntimeHealth(current, storage);
+        return {
+            status: findings.some((item) => item.severity === 'critical') ? 'critical' : findings.length > 0 ? 'warning' : 'ok',
+            generatedAt: Date.now(), current, history: [...this.history], storage, findings,
+            scopes: { cpu: 'termdock-process', memory: 'termdock-process', diskIo: 'termdock-process', networkIo: 'termdock-http-sockets', storage: 'termdock-state-directory' },
+        };
+    }
+    getSocketBytes() {
+        let read = this.closedSocketBytes.read;
+        let written = this.closedSocketBytes.written;
+        for (const [socket, baseline] of this.sockets) {
+            read += Math.max(0, socket.bytesRead - baseline.read);
+            written += Math.max(0, socket.bytesWritten - baseline.written);
+        }
+        return { read, written };
+    }
+    loadHistory() {
+        if (!this.historyPath)
+            return;
+        try {
+            this.history = fs.readFileSync(this.historyPath, 'utf8').trim().split('\n').flatMap((line) => {
+                try {
+                    const item = JSON.parse(line);
+                    return Number.isFinite(item.timestamp) ? [item] : [];
+                }
+                catch {
+                    return [];
+                }
+            }).slice(-this.maxHistorySamples);
+            this.lastHistoryAt = this.history.at(-1)?.timestamp ?? 0;
+        }
+        catch { /* First run or a missing/corrupt history file. */ }
+    }
+    appendHistory(sample) {
+        if (!this.historyPath)
+            return;
+        void fs.promises.mkdir(path.dirname(this.historyPath), { recursive: true })
+            .then(() => fs.promises.appendFile(this.historyPath, `${JSON.stringify(sample)}\n`, { mode: 0o600 }))
+            .then(async () => {
+            const stat = await fs.promises.stat(this.historyPath);
+            if (stat.size <= 2 * 1024 * 1024)
+                return;
+            const retained = this.history.map((item) => JSON.stringify(item)).join('\n') + '\n';
+            const temporary = `${this.historyPath}.${process.pid}.tmp`;
+            await fs.promises.writeFile(temporary, retained, { mode: 0o600 });
+            await fs.promises.rename(temporary, this.historyPath);
+        })
+            .catch(() => undefined);
+    }
+}

package/dist/server/utils/settings.js

@@ -105,6 +105,7 @@ function normalizeSettings(value) {
             ? raw.autoRenamePromptPayloadChars
             : 12_000,
         newSessionAgentSlug: normalizeNewSessionAgentSlug(raw.newSessionAgentSlug),
+        runningSessionButtonEnabled: raw.runningSessionButtonEnabled === true,
         updatedAt: typeof raw.updatedAt === 'number' ? raw.updatedAt : Date.now(),
     };
 }
@@ -399,3 +400,11 @@ export function setNewSessionAgentSlugSetting(slug) {
         settings.newSessionAgentSlug = normalizeNewSessionAgentSlug(slug);
     });
 }
+export function getRunningSessionButtonEnabledSetting() {
+    return loadSettings().runningSessionButtonEnabled;
+}
+export function setRunningSessionButtonEnabledSetting(enabled) {
+    return updateSettings((settings) => {
+        settings.runningSessionButtonEnabled = enabled;
+    });
+}

package/dist/server/workers/heicPreviewWorker.js

@@ -0,0 +1,14 @@
+import fs from 'node:fs/promises';
+import { parentPort, workerData } from 'node:worker_threads';
+import convert from 'heic-convert';
+async function run() {
+    if (!parentPort)
+        throw new Error('HEIC preview worker requires a parent port');
+    const { filePath } = workerData;
+    const input = await fs.readFile(filePath);
+    const output = await convert({ buffer: input, format: 'JPEG', quality: 0.9 });
+    parentPort.postMessage({ output });
+}
+run().catch((error) => {
+    parentPort?.postMessage({ error: error instanceof Error ? error.message : 'Failed to convert HEIC preview' });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termdock",
-  "version": "1.4.107",
+  "version": "1.4.109",
   "description": "A complete web-based terminal application with modern UI",
   "type": "module",
   "main": ".desktop-dist/main.js",
@@ -71,6 +71,7 @@
     "dompurify": "^3.4.11",
     "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",
@@ -98,6 +99,7 @@
     "@testing-library/user-event": "^14.5.0",
     "@types/busboy": "^1.5.4",
     "@types/express": "^4.17.21",
+    "@types/heic-convert": "^2.1.1",
     "@types/node": "^20.11.0",
     "@types/react": "^18.2.0",
     "@types/react-dom": "^18.2.0",

package/runtime-manifest.json

@@ -1,12 +1,12 @@
 {
   "schemaVersion": 1,
   "packageName": "termdock",
-  "version": "1.4.107",
+  "version": "1.4.109",
   "runtimeProtocolVersion": 1,
   "minimumDesktopVersion": "1.4.46",
   "nodeMajor": 22,
-  "dependencyHash": "sha256-emuXnf9w0kJF3ksMJVvdI0u8oLHKwZJ2/OzHBAXulZs=",
-  "serverBundleHash": "sha256-V2lLoyINaqWm8KFZx6orN6c98sLzClQWUnjwPiv9bi0=",
+  "dependencyHash": "sha256-3I9X7zF4J4BUYOvxi3lIuWSKfDy6S6GD61w8Ay95Ypw=",
+  "serverBundleHash": "sha256-FzVprEN6mYO+IXk9xqujHpNv1s544akAZOVv28fGvww=",
   "entrypoint": "dist/server/cli.js",
   "clientEntrypoint": "dist/client/index.html"
 }

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

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

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

@@ -1 +0,0 @@
-import{s as a,a as s,c as t,C as e}from"./chunk-V7JOEXUC-BoiSCBad.js";import{b as i}from"./mermaid.core-DqsMKQ0n.js";import"./chunk-5VM5RSS4-BRHAAr29.js";import"./chunk-XXDRQBXY-D9fRuB0M.js";import"./chunk-VR4S4FIN-ByS_rjkq.js";import"./chunk-32BRIVSS-Cysd2WNQ.js";import"./purify.es-CC4Brkr_.js";import"./index-B1FKcn-W.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-CNF7sVVd.js

@@ -1 +0,0 @@
-import{s as a,a as s,c as t,C as e}from"./chunk-V7JOEXUC-BoiSCBad.js";import{b as i}from"./mermaid.core-DqsMKQ0n.js";import"./chunk-5VM5RSS4-BRHAAr29.js";import"./chunk-XXDRQBXY-D9fRuB0M.js";import"./chunk-VR4S4FIN-ByS_rjkq.js";import"./chunk-32BRIVSS-Cysd2WNQ.js";import"./purify.es-CC4Brkr_.js";import"./index-B1FKcn-W.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};