termdock 1.4.107 → 1.4.109

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/filesystem.js

@@ -8,7 +8,7 @@ import watcher from '@parcel/watcher';
 import busboy from 'busboy';
 import { pathValidator } from '../utils/pathValidator.js';
 import { isAuthEnabled, isRequestAuthenticated } from '../utils/authProtection.js';
-import { getImageDimensions } from '../utils/imageDimensions.js';
+import { getImageDimensions, parseImageDimensions } from '../utils/imageDimensions.js';
 import { writeDiffTraceLog, writeErrorLog, writeJsonLog } from '../utils/serverLogger.js';
 import { clearBranchAuditRecords, clearChangeAuditRecords, listBranchAuditRecords, listChangeAuditRecords, buildChangeAuditFingerprint } from '../utils/changeAuditStore.js';
 import { getLanIPv4Addresses } from '../utils/localAccess.js';
@@ -17,6 +17,7 @@ import { GitApplyError, HUNK_APPLY_MODES, runGitApply, validateHunkPatch } from
 import { deleteFilesystemFile } from '../utils/deleteFilesystemFile.js';
 import { inspectKicadBoardPoint } from '../utils/kicadBoardInspection.js';
 import { EdaPreviewCache, requestAcceptsEtag } from '../utils/edaPreviewCache.js';
+import { convertHeicPreview, HEIC_PREVIEW_MIME_TYPES, isHeicPreviewPath } from '../utils/heicPreview.js';
 const router = Router();
 const MAX_FILE_SIZE = 1024 * 1024; // 1MB
 const MAX_IMAGE_PREVIEW_SIZE = 20 * 1024 * 1024; // 20MB
@@ -46,6 +47,7 @@ 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 HEIC_PREVIEW_TIMEOUT_MS = 30_000;
 const EDA_PREVIEW_TIMEOUT_MS = 30_000;
 const EDA_PREVIEW_CACHE_MAX_BYTES = 64 * 1024 * 1024;
 const GIT_ROUTE_TIMEOUT_MS = 8_000;
@@ -431,6 +433,7 @@ const IMAGE_MIME_BY_EXT = {
     '.bmp': 'image/bmp',
     '.ico': 'image/x-icon',
     '.svg': 'image/svg+xml',
+    ...HEIC_PREVIEW_MIME_TYPES,
 };
 function getImageMimeType(filePath) {
     return IMAGE_MIME_BY_EXT[path.extname(filePath).toLowerCase()] ?? null;
@@ -3024,23 +3027,45 @@ router.get('/blob', async (req, res) => {
             }
             return { resolvedPath, stat, mimeType };
         })(), FS_ROUTE_TIMEOUT_MS, 'Image preview took too long. The file may be on slow storage or currently blocked by another process.', 'FS_BLOB_TIMEOUT');
-        res.setHeader('Content-Type', mimeType);
-        res.setHeader('Content-Length', stat.size.toString());
+        let responseBody = null;
+        let responseMimeType = mimeType;
+        let responseFilename = path.basename(resolvedPath);
+        if (isHeicPreviewPath(resolvedPath)) {
+            responseBody = await withTimeout(convertHeicPreview(resolvedPath, controller.signal), HEIC_PREVIEW_TIMEOUT_MS, 'HEIC preview conversion took too long.', 'HEIC_PREVIEW_TIMEOUT', () => controller.abort(new OperationTimeoutError('HEIC preview conversion took too long.', 'HEIC_PREVIEW_TIMEOUT')));
+            if (responseBody.length > MAX_IMAGE_PREVIEW_SIZE) {
+                const error = new Error('Converted image is too large to preview');
+                error.code = 'IMAGE_TOO_LARGE';
+                error.status = 413;
+                throw error;
+            }
+            responseMimeType = 'image/jpeg';
+            responseFilename = `${path.basename(resolvedPath, path.extname(resolvedPath))}.jpg`;
+        }
+        const responseSize = responseBody?.length ?? stat.size;
+        res.setHeader('Content-Type', responseMimeType);
+        res.setHeader('Content-Length', responseSize.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)));
+        res.setHeader('Content-Disposition', buildContentDisposition('inline', responseFilename));
         // Expose dimensions so markdown image previews can reserve the final
         // display box before downloading (loading placeholder without a jump).
         // Best-effort: parsing failure just omits the headers.
-        const dimensions = await getImageDimensions(resolvedPath, mimeType).catch(() => null);
+        const dimensions = responseBody
+            ? parseImageDimensions(responseBody, responseMimeType)
+            : await getImageDimensions(resolvedPath, responseMimeType).catch(() => null);
         if (dimensions) {
             res.setHeader('X-Image-Width', String(dimensions.width));
             res.setHeader('X-Image-Height', String(dimensions.height));
         }
+        if (responseBody) {
+            logOnce('ok', { path: resolvedPath, bytes: responseSize, extra: { mimeType: responseMimeType, sourceMimeType: mimeType } });
+            res.end(responseBody);
+            return;
+        }
         const stream = fs.createReadStream(resolvedPath);
         controller.signal.addEventListener('abort', () => stream.destroy(controller.signal.reason instanceof Error ? controller.signal.reason : undefined), { once: true });
-        res.on('finish', () => logOnce('ok', { path: resolvedPath, bytes: stat.size, extra: { mimeType } }));
+        res.on('finish', () => logOnce('ok', { path: resolvedPath, bytes: stat.size, extra: { mimeType: responseMimeType } }));
         res.on('close', () => {
             if (!res.writableEnded)
                 logOnce('error', { path: resolvedPath, bytes: stat.size, code: 'CLIENT_CLOSED', error: 'Client closed image preview request' });

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/heicPreview.js

@@ -0,0 +1,50 @@
+import { Worker } from 'node:worker_threads';
+export const HEIC_PREVIEW_MIME_TYPES = {
+    '.heic': 'image/heic',
+    '.heif': 'image/heif',
+};
+export function isHeicPreviewPath(filePath) {
+    const normalized = filePath.toLowerCase();
+    return normalized.endsWith('.heic') || normalized.endsWith('.heif');
+}
+export function convertHeicPreview(filePath, signal) {
+    return new Promise((resolve, reject) => {
+        const worker = new Worker(new URL('../workers/heicPreviewWorker.js', import.meta.url), {
+            workerData: { filePath },
+        });
+        let settled = false;
+        const finish = (callback) => {
+            if (settled)
+                return;
+            settled = true;
+            signal?.removeEventListener('abort', abort);
+            callback();
+        };
+        const abort = () => {
+            void worker.terminate();
+            finish(() => reject(signal?.reason instanceof Error ? signal.reason : new Error('HEIC preview conversion was cancelled')));
+        };
+        if (signal?.aborted) {
+            abort();
+            return;
+        }
+        signal?.addEventListener('abort', abort, { once: true });
+        worker.once('message', (message) => {
+            if (message.error) {
+                finish(() => reject(new Error(message.error)));
+                return;
+            }
+            const { output } = message;
+            if (!output) {
+                finish(() => reject(new Error('HEIC preview worker returned no image data')));
+                return;
+            }
+            finish(() => resolve(Buffer.from(output)));
+        });
+        worker.once('error', (error) => finish(() => reject(error)));
+        worker.once('exit', (code) => {
+            if (code !== 0)
+                finish(() => reject(new Error(`HEIC preview worker exited with code ${code}`)));
+        });
+    });
+}