termdock 1.4.108 → 1.4.110

package/dist/server/agent/sessionSearchStore.js

@@ -2,6 +2,10 @@ import fs from 'node:fs';
 import path from 'node:path';
 const MAX_LOG_BYTES = 2 * 1024 * 1024;
 const LOG_SEGMENT_BYTES = MAX_LOG_BYTES / 2;
+const DEFAULT_MAX_TOTAL_BYTES = 64 * 1024 * 1024;
+const DEFAULT_MAX_SESSIONS = 50;
+const DEFAULT_MAX_AGE_MS = 30 * 24 * 60 * 60_000;
+const BUDGET_MAINTENANCE_INTERVAL_MS = 10 * 60_000;
 const ANSI_PATTERN = /[\u001B\u009B][[\]()#;?]*(?:(?:(?:[a-zA-Z\d]*(?:;[-a-zA-Z\d\/#&.:=?%@~_]+)*)?\u0007)|(?:(?:\d{1,4}(?:[;:]\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]))/g;
 function clean(value) {
     return value
@@ -12,23 +16,36 @@ function clean(value) {
 }
 export class SessionSearchStore {
     directory;
+    limits;
     metadata = new Map();
     pending = new Map();
     flushTimer = null;
-    constructor(directory) {
+    metadataDirty = false;
+    metadataMustPersist = false;
+    lastMetadataWriteAt = 0;
+    lastBudgetMaintenanceAt = 0;
+    constructor(directory, limits = {}) {
         this.directory = directory;
+        this.limits = limits;
         this.loadMetadata();
+        this.enforceBudget();
     }
     append(metadata, output) {
         const text = clean(output);
+        const previous = this.metadata.get(metadata.sessionId);
         this.metadata.set(metadata.sessionId, { ...metadata, updatedAt: Date.now() });
+        this.metadataDirty = true;
+        this.metadataMustPersist ||= this.metadataChanged(previous, metadata);
         if (text.trim())
             this.pending.set(metadata.sessionId, [...(this.pending.get(metadata.sessionId) ?? []), text]);
         if (!this.flushTimer)
             this.flushTimer = setTimeout(() => this.flush(), 750);
     }
     update(metadata) {
+        const previous = this.metadata.get(metadata.sessionId);
         this.metadata.set(metadata.sessionId, { ...metadata, updatedAt: Date.now() });
+        this.metadataDirty = true;
+        this.metadataMustPersist ||= this.metadataChanged(previous, metadata);
         if (!this.flushTimer)
             this.flushTimer = setTimeout(() => this.flush(), 750);
     }
@@ -61,7 +78,7 @@ export class SessionSearchStore {
         if (this.flushTimer)
             clearTimeout(this.flushTimer);
         this.flushTimer = null;
-        if (this.metadata.size === 0 && this.pending.size === 0)
+        if (this.metadata.size === 0 && this.pending.size === 0 && !this.metadataDirty)
             return;
         fs.mkdirSync(this.directory, { recursive: true });
         for (const [sessionId, chunks] of this.pending) {
@@ -84,9 +101,63 @@ export class SessionSearchStore {
             fs.appendFileSync(logPath, boundedChunk, { mode: 0o600 });
         }
         this.pending.clear();
-        const temporaryPath = `${this.metadataPath()}.${process.pid}.tmp`;
-        fs.writeFileSync(temporaryPath, JSON.stringify({ version: 1, sessions: [...this.metadata.values()] }, null, 2), { mode: 0o600 });
-        fs.renameSync(temporaryPath, this.metadataPath());
+        const now = Date.now();
+        if (this.metadataDirty && (this.metadataMustPersist || now - this.lastMetadataWriteAt >= 30_000))
+            this.persistMetadata();
+        if (now - this.lastBudgetMaintenanceAt >= BUDGET_MAINTENANCE_INTERVAL_MS)
+            this.enforceBudget(now);
+    }
+    enforceBudget(now = Date.now()) {
+        this.lastBudgetMaintenanceAt = now;
+        const maxSessions = this.limits.maxSessions ?? DEFAULT_MAX_SESSIONS;
+        const maxAgeMs = this.limits.maxAgeMs ?? DEFAULT_MAX_AGE_MS;
+        const maxTotalBytes = this.limits.maxTotalBytes ?? DEFAULT_MAX_TOTAL_BYTES;
+        const newest = [...this.metadata.values()].sort((a, b) => b.updatedAt - a.updatedAt);
+        const retained = new Set(newest.filter((item, index) => index < maxSessions && now - item.updatedAt <= maxAgeMs).map((item) => item.sessionId));
+        let changed = false;
+        for (const sessionId of this.metadata.keys()) {
+            if (retained.has(sessionId))
+                continue;
+            this.metadata.delete(sessionId);
+            this.pending.delete(sessionId);
+            this.removeSessionLogs(sessionId);
+            changed = true;
+        }
+        let files = this.listLogFiles();
+        for (const file of files) {
+            if (retained.has(file.sessionId))
+                continue;
+            try {
+                fs.rmSync(file.path, { force: true });
+            }
+            catch { /* best effort */ }
+        }
+        files = this.listLogFiles();
+        let totalBytes = files.reduce((sum, file) => sum + file.size, 0);
+        const removalOrder = [
+            ...files.filter((file) => file.previous).sort((a, b) => a.mtimeMs - b.mtimeMs),
+            ...files.filter((file) => !file.previous).sort((a, b) => a.mtimeMs - b.mtimeMs),
+        ];
+        for (const file of removalOrder) {
+            if (totalBytes <= maxTotalBytes)
+                break;
+            try {
+                fs.rmSync(file.path, { force: true });
+            }
+            catch {
+                continue;
+            }
+            totalBytes -= file.size;
+            if (!file.previous) {
+                this.metadata.delete(file.sessionId);
+                changed = true;
+            }
+        }
+        if (changed) {
+            this.metadataDirty = true;
+            this.metadataMustPersist = true;
+            this.persistMetadata();
+        }
     }
     loadMetadata() {
         try {
@@ -95,6 +166,7 @@ export class SessionSearchStore {
                 if (item && typeof item.sessionId === 'string')
                     this.metadata.set(item.sessionId, item);
             }
+            this.lastMetadataWriteAt = Date.now();
         }
         catch { /* first run */ }
     }
@@ -118,6 +190,64 @@ export class SessionSearchStore {
             return 0;
         }
     }
+    metadataChanged(previous, next) {
+        return !previous
+            || previous.backendSessionId !== next.backendSessionId
+            || previous.title !== next.title
+            || previous.cwd !== next.cwd
+            || previous.agentSlug !== next.agentSlug
+            || previous.agentNativeSessionId !== next.agentNativeSessionId;
+    }
+    persistMetadata() {
+        fs.mkdirSync(this.directory, { recursive: true });
+        const temporaryPath = `${this.metadataPath()}.${process.pid}.tmp`;
+        fs.writeFileSync(temporaryPath, JSON.stringify({ version: 1, sessions: [...this.metadata.values()] }, null, 2), { mode: 0o600 });
+        fs.renameSync(temporaryPath, this.metadataPath());
+        this.lastMetadataWriteAt = Date.now();
+        this.metadataDirty = false;
+        this.metadataMustPersist = false;
+    }
+    removeSessionLogs(sessionId) {
+        try {
+            fs.rmSync(this.logPath(sessionId), { force: true });
+        }
+        catch { /* best effort */ }
+        try {
+            fs.rmSync(this.previousLogPath(sessionId), { force: true });
+        }
+        catch { /* best effort */ }
+    }
+    listLogFiles() {
+        let names;
+        try {
+            names = fs.readdirSync(this.directory);
+        }
+        catch {
+            return [];
+        }
+        return names.flatMap((name) => {
+            const match = name.match(/^(.*)\.log(\.1)?$/);
+            if (!match)
+                return [];
+            let sessionId;
+            try {
+                sessionId = decodeURIComponent(match[1]);
+            }
+            catch {
+                return [];
+            }
+            const filePath = path.join(this.directory, name);
+            try {
+                const stat = fs.statSync(filePath);
+                return stat.isFile()
+                    ? [{ path: filePath, sessionId, previous: Boolean(match[2]), size: stat.size, mtimeMs: stat.mtimeMs }]
+                    : [];
+            }
+            catch {
+                return [];
+            }
+        });
+    }
     metadataPath() { return path.join(this.directory, 'sessions.json'); }
     logPath(sessionId) { return path.join(this.directory, `${encodeURIComponent(sessionId)}.log`); }
     previousLogPath(sessionId) { return `${this.logPath(sessionId)}.1`; }

package/dist/server/entry.js

@@ -23,6 +23,7 @@ import { localAccessManager } from './utils/localAccess.js';
 import { isAllowedHost, isUpgradeOriginAllowed, validateHostMiddleware, } from './utils/requestSecurity.js';
 import { getCookieSecurityOptions, setSecureCookieMode } from './utils/cookieSecurity.js';
 import { requestDeadlineMiddleware } from './utils/requestDeadline.js';
+import { RuntimeMonitor } from './utils/runtimeMonitor.js';
 import { startOnboardingServer, stopOnboardingServer, getOnboardingServerUrl } from './onboardingServer.js';
 import { CertificateWatcher } from './certificateWatcher.js';
 import { startTermdockLogMaintenance, writeDiffTraceLog, writeErrorLog, writeJsonLog, writeTextLog, } from './utils/serverLogger.js';
@@ -67,6 +68,8 @@ function getRouteFamily(pathname) {
         return 'auth';
     if (pathname.startsWith('/api/client-log'))
         return 'client-log';
+    if (pathname.startsWith('/api/diagnostics'))
+        return 'diagnostics';
     if (pathname === '/health')
         return 'health';
     if (pathname.startsWith('/assets/'))
@@ -288,6 +291,7 @@ export function createApp(options = {}) {
                 return;
             logged = true;
             const durationMs = Number(process.hrtime.bigint() - startedAt) / 1_000_000;
+            options.runtimeMonitor?.recordRequest(res.statusCode, durationMs);
             writeJsonLog('access.log', {
                 event,
                 method: req.method,
@@ -424,6 +428,13 @@ export function createApp(options = {}) {
         const address = req.socket.remoteAddress ?? '';
         return address === '127.0.0.1' || address === '::1' || address === '::ffff:127.0.0.1';
     };
+    app.get('/api/diagnostics/runtime', requireAuth({ bypass: isTrustedLocalCliRequest }), async (_req, res) => {
+        if (!options.runtimeMonitor) {
+            res.status(503).json({ error: 'Runtime monitor is not active', code: 'RUNTIME_MONITOR_INACTIVE' });
+            return;
+        }
+        res.json(await options.runtimeMonitor.diagnostics());
+    });
     // 应用鉴权 + CSRF保护（在终端路由之前）
     // The HTML preview route authenticates itself: document requests use the
     // session cookie, then get redirected to a short-lived URL token so the
@@ -490,8 +501,20 @@ export function startServer(options = {}) {
     const stopLogMaintenance = startTermdockLogMaintenance();
     const port = options.port ?? Number(process.env.PORT || DEFAULT_PORT);
     const host = options.host ?? (process.env.HOST || DEFAULT_HOST);
-    const app = createApp({ port: options.onboardingPort ?? port, httpsCaPath: options.httpsCaPath, localApiToken: options.localApiToken });
+    const runtimeMonitor = new RuntimeMonitor({
+        stateDirectory: path.join(homedir(), '.termdock'),
+        historyPath: path.join(homedir(), '.termdock', 'runtime-metrics.log'),
+    });
+    runtimeMonitor.start();
+    const app = createApp({
+        port: options.onboardingPort ?? port,
+        httpsCaPath: options.httpsCaPath,
+        localApiToken: options.localApiToken,
+        runtimeMonitor,
+    });
     const { server, scheme } = createServerForApp(app, options);
+    server.on('connection', (socket) => runtimeMonitor.trackSocket(socket));
+    server.once('close', () => runtimeMonitor.stop());
     setSecureCookieMode(scheme === 'https');
     const certWatcher = new CertificateWatcher({
         enabled: scheme === 'https' && Boolean(options.httpsCertPath && options.httpsKeyPath),

package/dist/server/routes/terminal.js

@@ -14,7 +14,7 @@ import { getPtyHostManager } from '../ptyhost/manager.js';
 import { pathValidator } from '../utils/pathValidator.js';
 import { TERMINAL, TMUX } from '../config.js';
 import { localAccessManager } from '../utils/localAccess.js';
-import { normalizeLocalAccessName, getLocaleSetting, setLocaleSetting, getContextDraftHeightSetting, setContextDraftHeightSetting, getAutoRenameAgentsSetting, setAutoRenameAgentsSetting, getAutoRenameNamerSetting, setAutoRenameNamerSetting, getAutoRenameModelsSetting, setAutoRenameModelsSetting, getAutoRenameIntervalMinutesSetting, setAutoRenameIntervalMinutesSetting, getAutoRenamePromptPreferenceSetting, setAutoRenamePromptPreferenceSetting, getAutoRenamePromptPayloadCharsSetting, setAutoRenamePromptPayloadCharsSetting, getNewSessionAgentSlugSetting, setNewSessionAgentSlugSetting, } from '../utils/settings.js';
+import { normalizeLocalAccessName, getLocaleSetting, setLocaleSetting, getContextDraftHeightSetting, setContextDraftHeightSetting, getAutoRenameAgentsSetting, setAutoRenameAgentsSetting, getAutoRenameNamerSetting, setAutoRenameNamerSetting, getAutoRenameModelsSetting, setAutoRenameModelsSetting, getAutoRenameIntervalMinutesSetting, setAutoRenameIntervalMinutesSetting, getAutoRenamePromptPreferenceSetting, setAutoRenamePromptPreferenceSetting, getAutoRenamePromptPayloadCharsSetting, setAutoRenamePromptPayloadCharsSetting, getNewSessionAgentSlugSetting, setNewSessionAgentSlugSetting, getRunningSessionButtonEnabledSetting, setRunningSessionButtonEnabledSetting, } from '../utils/settings.js';
 import { loadContextDraft, saveContextDraft } from '../utils/contextDraft.js';
 import { getOnboardingServerUrl } from '../onboardingServer.js';
 import { getFocusSequence, removeClientFocusState, scanFocusTrackingMode, setClientFocusState, } from '../utils/tmuxFocus.js';
@@ -1309,7 +1309,7 @@ function tryDeliverCollaborationInbox(frontendSessionId) {
         || (session.agentSession?.rich && !['idle', 'done'].includes(session.agentSession.status))) {
         return { delivered: [], pending: pending.length };
     }
-    writeTerminalInput(session, `${formatCollaborationDelivery(frontendSessionId, pending)}\r`);
+    session.ptyProcess.write(buildBracketedSubmitBytes(formatCollaborationDelivery(frontendSessionId, pending)));
     collaborationStore.markDelivered(pending.map((message) => message.id));
     return { delivered: pending.map((message) => message.id), pending: 0 };
 }
@@ -5185,6 +5185,7 @@ async function getSettingsPayload() {
         autoRenamePromptPreference: getAutoRenamePromptPreferenceSetting(),
         autoRenamePromptPayloadChars: getAutoRenamePromptPayloadCharsSetting(),
         newSessionAgentSlug: getNewSessionAgentSlugSetting(),
+        runningSessionButtonEnabled: getRunningSessionButtonEnabledSetting(),
         localAccess: {
             ...localAccess,
             interfaces,
@@ -5293,6 +5294,9 @@ router.put('/settings', async (req, res) => {
         }
         setNewSessionAgentSlugSetting(slug);
     }
+    if (typeof body.runningSessionButtonEnabled === 'boolean') {
+        setRunningSessionButtonEnabledSetting(body.runningSessionButtonEnabled);
+    }
     if (body.localAccess && typeof body.localAccess === 'object') {
         const localAccessBody = body.localAccess;
         if (localAccessBody.reset === true) {

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termdock",
-  "version": "1.4.108",
+  "version": "1.4.110",
   "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.108",
+  "version": "1.4.110",
   "runtimeProtocolVersion": 1,
   "minimumDesktopVersion": "1.4.46",
   "nodeMajor": 22,
   "dependencyHash": "sha256-3I9X7zF4J4BUYOvxi3lIuWSKfDy6S6GD61w8Ay95Ypw=",
-  "serverBundleHash": "sha256-KSGNyOcLMhHQwPHxSz7noGVaFIWukO1ExTVBIqm61Zc=",
+  "serverBundleHash": "sha256-FzVprEN6mYO+IXk9xqujHpNv1s544akAZOVv28fGvww=",
   "entrypoint": "dist/server/cli.js",
   "clientEntrypoint": "dist/client/index.html"
 }

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

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

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

@@ -1 +0,0 @@
-import{s as a,a as s,c as t,C as e}from"./chunk-V7JOEXUC-LTTPDSzs.js";import{b as i}from"./mermaid.core-DLidsBlx.js";import"./chunk-5VM5RSS4-C984gGSO.js";import"./chunk-XXDRQBXY-DiUZr3na.js";import"./chunk-VR4S4FIN-dCZ9yGOH.js";import"./chunk-32BRIVSS-B50lSI4-.js";import"./purify.es-CC4Brkr_.js";import"./index-BwMQSNQq.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-BYJ3p4nE.js

@@ -1 +0,0 @@
-import{s as a,a as s,c as t,C as e}from"./chunk-V7JOEXUC-LTTPDSzs.js";import{b as i}from"./mermaid.core-DLidsBlx.js";import"./chunk-5VM5RSS4-C984gGSO.js";import"./chunk-XXDRQBXY-DiUZr3na.js";import"./chunk-VR4S4FIN-dCZ9yGOH.js";import"./chunk-32BRIVSS-B50lSI4-.js";import"./purify.es-CC4Brkr_.js";import"./index-BwMQSNQq.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};