termdock 1.4.263 → 1.4.265

package/dist/server/entry.js

@@ -31,6 +31,8 @@ import { fileURLToPath } from 'url';
 import { WebSocketServer } from 'ws';
 import terminalRoutes, { handleTerminalWebSocket, handleControlWebSocket, resolveStableFederationSessionId } from './routes/terminal.js';
 import androidRoutes, { handleAndroidWebSocket } from './routes/android.js';
+import { exitWithStartupFailure } from './utils/startupFailure.js';
+import { androidRecordings } from './android/recording.js';
 import { stopAllScrcpySessions } from './android/scrcpy.js';
 import filesystemRoutes from './routes/filesystem.js';
 import authRoutes from './routes/auth.js';
@@ -463,7 +465,7 @@ export function startServer(options = {}) {
     server.once('close', () => { clearInterval(desktopRoutesTimer); for (const target of dynamicDirectTargets.values())
         target.close(); });
     server.once('close', () => relayRouter.close());
-    server.once('close', () => { void stopAllScrcpySessions(); });
+    server.once('close', () => { void stopAllScrcpySessions(); void androidRecordings.stopAll(); });
     const federation = createFederationRuntime(app, path.join(homedir(), '.termdock', 'federation'), {
         terminal: handleTerminalWebSocket, control: handleControlWebSocket, android: handleAndroidWebSocket,
     }, {
@@ -773,7 +775,8 @@ export function startServer(options = {}) {
             crashForensics.recordIncident('port-conflict', { extra: { port, host, code: error.code } });
             console.error(`Port ${port} is already in use.`);
             console.error(`To free it, find and stop the process: lsof -tiTCP:${port} -sTCP:LISTEN | xargs kill`);
-            process.exit(1);
+            exitWithStartupFailure('port-conflict', `Port ${port} is already in use (EADDRINUSE).`);
+            return;
         }
         console.error('Server error:', error);
         process.exit(1);

package/dist/server/routes/android.js

@@ -1,6 +1,8 @@
 import { Router } from 'express';
 import { connectDevice, disconnectDevice, listDevices, resolveAdbBinary } from '../android/adb.js';
 import { createScrcpySession, resolveScrcpyBinaries } from '../android/scrcpy.js';
+import { androidRecordings } from '../android/recording.js';
+import { pathValidator } from '../utils/pathValidator.js';
 const router = Router();
 const SERIAL_PATTERN = /^[0-9a-zA-Z_.:\-]{1,128}$/;
 /** 逐帧/逐控件的诊断日志默认关闭，需要时 TERMDOCK_ANDROID_DEBUG=1 打开。 */
@@ -46,6 +48,59 @@ router.post('/disconnect', async (req, res) => {
         res.status(400).json({ error: message, code: message });
     }
 });
+router.get('/recordings', async (req, res) => {
+    const serial = typeof req.query.serial === 'string' ? req.query.serial : '';
+    if (!isValidAndroidSerial(serial)) {
+        res.status(400).json({ error: 'INVALID_SERIAL' });
+        return;
+    }
+    try {
+        res.json({ recordings: await androidRecordings.list(serial) });
+    }
+    catch (error) {
+        res.status(500).json({ error: String(error) });
+    }
+});
+router.post('/recordings', async (req, res) => {
+    const serial = typeof req.body?.serial === 'string' ? req.body.serial : '';
+    if (!isValidAndroidSerial(serial)) {
+        res.status(400).json({ error: 'INVALID_SERIAL' });
+        return;
+    }
+    try {
+        res.json(await androidRecordings.start(serial));
+    }
+    catch (error) {
+        res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
+    }
+});
+router.post('/recordings/:id/stop', async (req, res) => {
+    try {
+        res.json(await androidRecordings.stop(req.params.id));
+    }
+    catch (error) {
+        res.status(400).json({ error: String(error) });
+    }
+});
+router.post('/recordings/:id/save', async (req, res) => {
+    try {
+        const directory = req.body?.directory === undefined ? undefined
+            : await (req.pathValidator ?? pathValidator).validateAsync(req.body.directory);
+        res.json({ path: await androidRecordings.save(req.params.id, directory) });
+    }
+    catch (error) {
+        res.status(400).json({ error: error instanceof Error ? error.message : String(error) });
+    }
+});
+router.delete('/recordings/:id', async (req, res) => {
+    try {
+        await androidRecordings.discard(req.params.id);
+        res.json({ ok: true });
+    }
+    catch (error) {
+        res.status(400).json({ error: String(error) });
+    }
+});
 export default router;
 function clampInt(value, min, max, fallback) {
     if (typeof value !== 'number' || !Number.isFinite(value))

package/dist/server/routes/filesystem.js

@@ -1349,7 +1349,7 @@ async function getCachedGitBundle(resolvedCwd, gitRoot, includeNested, refresh,
     const now = Date.now();
     if (signal)
         throwIfAborted(signal, 'git.bundle');
-    const cached = gitBundleCache.get(cacheKey);
+    const cached = getCompatibleGitBundleCache(gitRoot, includeNested, discoverOnly);
     if (!refresh && cached && (cached.expiresAt > now || allowStale)) {
         const cacheAgeMs = Math.max(0, now - (cached.expiresAt - GIT_BUNDLE_CACHE_TTL_MS));
         return {
@@ -1399,8 +1399,7 @@ async function refreshGitBundleCacheDetached(resolvedCwd, gitRoot, includeNested
     return promise;
 }
 function getGitBundleCache(gitRoot, includeNested, allowStale = false, discoverOnly = false) {
-    const cacheKey = getGitBundleCacheKey(gitRoot, includeNested, discoverOnly);
-    const cached = gitBundleCache.get(cacheKey);
+    const cached = getCompatibleGitBundleCache(gitRoot, includeNested, discoverOnly);
     if (!cached)
         return null;
     const now = Date.now();
@@ -2438,6 +2437,17 @@ const gitBundleBuildPromises = new Map();
 function getGitBundleCacheKey(gitRoot, includeNested, discoverOnly = false) {
     return `${gitRoot}\u0000${includeNested ? 'nested' : 'single'}${discoverOnly ? ' discover' : ''}`;
 }
+function getCompatibleGitBundleCache(gitRoot, includeNested, discoverOnly) {
+    const cached = gitBundleCache.get(getGitBundleCacheKey(gitRoot, includeNested, discoverOnly));
+    if (!includeNested || !discoverOnly)
+        return cached;
+    // Reopening the sidebar requests discovery, while manual refresh builds the
+    // full snapshot. Full data satisfies discovery too: do not return an older
+    // discovery snapshot and roll back both the file list and its timestamp.
+    // The reverse is unsafe because discovery contains deferred placeholders.
+    const full = gitBundleCache.get(getGitBundleCacheKey(gitRoot, true));
+    return full && (!cached || full.updatedAt >= cached.updatedAt) ? full : cached;
+}
 function clearGitBundleCacheForRoot(root) {
     for (const key of gitBundleCache.keys()) {
         if (key.startsWith(`${root}\u0000`))

package/dist/server/routes/terminal.js

@@ -1,3 +1,4 @@
+import { androidRecordings } from '../android/recording.js';
 import { assertPeerRegistrationAuthority } from '../agent/collaborationPeerTransport.js';
 import { progressRoutes } from '../notifications/progressRoutes.js';
 import { ensureNodePty } from '../utils/ensureNodePty.js';
@@ -38,6 +39,7 @@ import { AgentResumeHistoryStore } from '../agent/resumeHistory.js';
 import { isTmuxRecoveryCandidate } from '../utils/tmuxRecoveryCandidate.js';
 import { AutomationStore, normalizeAutomationSchedule } from '../agent/automationStore.js';
 import { buildBracketedSubmitBytes, canDeliverPromptToAgent } from '../agent/promptDelivery.js';
+import { prepareSupervisionEnable } from '../utils/enableSupervision.js';
 import { buildServerHealthState, dismissServerHealth } from '../utils/serverHealth.js';
 import { collaborationRoutes } from '../agent/collaborationRoutes.js';
 import { extrasFromBody } from '../agent/collaborationProtocol.js';
@@ -625,8 +627,24 @@ function flushPersistAndExit() {
     }
     catch { /* best effort */ }
 }
-process.on('SIGTERM', () => { flushPersistAndExit(); void persistToolbarPresetsNow(); caffeinateManager.shutdown(); process.exit(0); });
-process.on('SIGINT', () => { flushPersistAndExit(); void persistToolbarPresetsNow(); caffeinateManager.shutdown(); process.exit(0); });
+let shuttingDown = false;
+const shutdownWithRecordings = async () => {
+    if (shuttingDown)
+        return;
+    shuttingDown = true;
+    flushPersistAndExit();
+    void persistToolbarPresetsNow();
+    caffeinateManager.shutdown();
+    // Give the MP4 muxer a chance to write its trailer before the service exits.
+    try {
+        await androidRecordings.stopAll();
+    }
+    finally {
+        process.exit(0);
+    }
+};
+process.on('SIGTERM', () => { void shutdownWithRecordings(); });
+process.on('SIGINT', () => { void shutdownWithRecordings(); });
 // 服务启动时从磁盘加载（带去重，防止历史累积的重复条目复活）
 void (async () => {
     await Promise.all([loadGlobalSessionStateFromDisk(), loadTmuxRecoveryStateFromDisk()]);
@@ -6258,6 +6276,16 @@ router.post('/update/restart', async (_req, res) => {
 router.get('/server-health', (_req, res) => {
     res.json(buildServerHealthState());
 });
+router.post('/server-health/enable-supervision', async (_req, res) => {
+    try {
+        const commit = await prepareSupervisionEnable();
+        res.once('finish', commit);
+        res.status(202).json({ restarting: true });
+    }
+    catch (error) {
+        res.status(409).json({ error: error instanceof Error ? error.message : String(error) });
+    }
+});
 router.post('/server-health/dismiss', (_req, res) => {
     res.status(202).json(dismissServerHealth());
 });

package/dist/server/supervisionHandoff.js

@@ -0,0 +1,33 @@
+/** The prepared process becomes the supervisor once the old service has exited. */
+import fs from 'node:fs';
+import { runSupervisor } from './supervisor.js';
+import { isProcessRunning } from './utils/termdockState.js';
+const { parentPid, config } = JSON.parse(process.argv[2]);
+if (!Number.isSafeInteger(parentPid) || parentPid <= 1 || !process.connected)
+    process.exit(1);
+fs.accessSync(config.childEntry, fs.constants.R_OK);
+if (config.healthCaPath)
+    fs.accessSync(config.healthCaPath, fs.constants.R_OK);
+let committed = false;
+const expiry = setTimeout(() => process.exit(1), 10_000);
+process.on('disconnect', () => { if (!committed)
+    process.exit(1); });
+process.once('message', (message) => {
+    if (message?.type !== 'handoff-commit')
+        process.exit(1);
+    committed = true;
+    clearTimeout(expiry);
+    const deadline = Date.now() + 30_000;
+    const timer = setInterval(() => {
+        if (isProcessRunning(parentPid)) {
+            if (Date.now() >= deadline) {
+                console.error('[supervisor] old service did not exit; handoff cancelled');
+                process.exit(1);
+            }
+            return;
+        }
+        clearInterval(timer);
+        runSupervisor(config);
+    }, 100);
+});
+process.send?.({ type: 'handoff-ready' });

package/dist/server/supervisor.js

@@ -29,7 +29,7 @@ import { backoffDelayMs } from './utils/backoff.js';
 import { installCrashForensics, isOomSuspect, readRuntimeTail, readServerLogTail } from './utils/crashForensics.js';
 import { probeHealthOnce, HEALTH_PROBE_TIMEOUT_MS } from './utils/healthProbe.js';
 import { writeJsonLogSync } from './utils/serverLogger.js';
-import { SUPERVISOR_STATE_VERSION, classifyChildExit, isReadyMessage, isServerIntentMessage, shouldGiveUp, } from './utils/supervisorProtocol.js';
+import { SUPERVISOR_STATE_VERSION, classifyChildExit, isReadyMessage, isStartupFailedMessage, isServerIntentMessage, shouldGiveUp, } from './utils/supervisorProtocol.js';
 import { SUPERVISOR_STATE_PATH, STOP_GRACE_MS, isProcessRunning, removeJsonState, writeJsonStateAtomic, } from './utils/termdockState.js';
 export const DEFAULT_SUPERVISOR_TIMING = {
     readyTimeoutMs: 30_000,
@@ -189,6 +189,10 @@ export function createSupervisor(config, deps) {
                 deps.notifyLauncher({ type: 'termdock-ready' });
                 return;
             }
+            if (isStartupFailedMessage(message) && !becameReady) {
+                portConflict = message.reason === 'port-conflict';
+                return;
+            }
             if (isServerIntentMessage(message)) {
                 intent = message.intent;
                 deps.log(`[supervisor] server declared intent: ${message.intent}`);
@@ -356,7 +360,6 @@ export function createSupervisor(config, deps) {
             return;
         }
         if (shouldGiveUp(consecutiveCrashes, timing.maxConsecutiveCrashes)) {
-            lastIncident.detail = `${lastIncident.detail} — gave up after ${consecutiveCrashes} consecutive crashes`;
             deps.log(`[supervisor] ${consecutiveCrashes} consecutive crashes; giving up. Service is NOT running.`);
             recordApplicationGaveUp();
             setPhase('gave-up');
@@ -380,7 +383,7 @@ export function createSupervisor(config, deps) {
         deps.recordIncident({
             role: 'supervisor',
             event: 'gave-up',
-            detail: `gave up after ${consecutiveCrashes} consecutive crashes`,
+            detail: `gave up after ${consecutiveCrashes} consecutive failures: ${lastIncident?.detail ?? 'unknown cause'}`,
             version: config.version ?? null,
             restarts,
             lastIncident,

package/dist/server/utils/enableSupervision.js

@@ -0,0 +1,80 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { getSupervisorStatus } from './supervisorClient.js';
+import { SERVER_LOG_PATH } from './termdockState.js';
+let config = null;
+let pending = false;
+// Only the production CLI registers a launch recipe. Desktop and development
+// runtimes must remain owned by their original launcher.
+export function configureSupervisionEnable(value) {
+    config = value;
+}
+export function canEnableSupervision() {
+    return config !== null && !(process.env.TERMDOCK_SUPERVISED === '1' && process.connected)
+        && !process.env.TERMDOCK_DESKTOP && !process.env.TERMDOCK_DESKTOP_OWNER_SOCKET
+        && !process.env.INVOCATION_ID && !process.env.NOTIFY_SOCKET && !process.env.PM2_HOME
+        && !getSupervisorStatus()?.alive;
+}
+/** Prepare the replacement before stopping anything; commit after HTTP flush. */
+export async function prepareSupervisionEnable() {
+    if (pending)
+        throw new Error('Automatic recovery is already being enabled.');
+    if (!canEnableSupervision() || !config)
+        throw new Error('Enable automatic recovery through the service launcher.');
+    pending = true;
+    try {
+        const script = fileURLToPath(new URL('../supervisionHandoff.js', import.meta.url));
+        fs.accessSync(script, fs.constants.R_OK);
+        fs.accessSync(config.childEntry, fs.constants.R_OK);
+        const fd = fs.openSync(SERVER_LOG_PATH, 'a', 0o600);
+        let child;
+        try {
+            child = spawn(process.execPath, [script, JSON.stringify({ parentPid: process.pid, config })], {
+                detached: true,
+                stdio: ['ignore', fd, fd, 'ipc'],
+            });
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+        await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                child.kill();
+                reject(new Error('Automatic recovery did not become ready.'));
+            }, 5000);
+            child.once('error', (error) => { clearTimeout(timer); reject(error); });
+            child.once('exit', () => {
+                clearTimeout(timer);
+                pending = false;
+                reject(new Error('Automatic recovery could not start.'));
+            });
+            child.once('message', (message) => {
+                if (message?.type !== 'handoff-ready')
+                    return;
+                clearTimeout(timer);
+                resolve();
+            });
+        });
+        let committed = false;
+        return () => {
+            if (committed)
+                return;
+            committed = true;
+            // Never terminate the working service if the prepared process vanished.
+            child.send({ type: 'handoff-commit' }, (error) => {
+                if (error) {
+                    pending = false;
+                    return;
+                }
+                child.disconnect();
+                child.unref();
+                setTimeout(() => process.kill(process.pid, 'SIGTERM'), 750).unref();
+            });
+        };
+    }
+    catch (error) {
+        pending = false;
+        throw error;
+    }
+}

package/dist/server/utils/serverHealth.js

@@ -12,6 +12,7 @@
 import { INCIDENT_DISMISSED_PATH, readJsonFile, writeJsonStateAtomic, } from './termdockState.js';
 import { readCrashLogTail } from './crashForensics.js';
 import { getSupervisorStatus } from './supervisorClient.js';
+import { canEnableSupervision } from './enableSupervision.js';
 /**
  * 值得用户知道的事件。刻意排除 `stop`（是用户自己停的）、
  * `update-restart` / `manual-restart`（我们自己发起的，成功了就没什么可说）。
@@ -60,8 +61,31 @@ export function toIncident(entry) {
 export function findLatestNotableIncident(entries) {
     for (let index = entries.length - 1; index >= 0; index -= 1) {
         const incident = toIncident(entries[index]);
-        if (incident && NOTABLE_EVENTS.has(incident.event))
-            return incident;
+        if (!incident || !NOTABLE_EVENTS.has(incident.event))
+            continue;
+        if (incident.event === 'gave-up') {
+            // Old logs store the final failure separately. Match the supervisor, then
+            // its exact child PID; never borrow an unrelated process's port conflict.
+            const summary = entries[index];
+            const failure = entries.slice(0, index).reverse().find((entry) => entry.role === 'supervisor' && entry.pid === summary.pid
+                && entry.event !== 'gave-up' && NOTABLE_EVENTS.has(String(entry.event)));
+            const nested = summary.lastIncident;
+            const cause = nested && typeof nested === 'object' ? nested : failure;
+            const portConflict = failure && typeof failure.serverPid === 'number'
+                ? entries.slice(0, index).reverse().find((entry) => entry.role === 'server'
+                    && entry.pid === failure.serverPid && entry.event === 'port-conflict'
+                    && typeof entry.ts === 'string' && Date.parse(entry.ts) <= incident.at
+                    && incident.at - Date.parse(entry.ts) < 60_000)
+                : undefined;
+            const causeEvent = portConflict ? 'port-conflict' : pickString(cause?.event);
+            if (causeEvent)
+                incident.causeEvent = causeEvent;
+            if (portConflict) {
+                const port = pickNumber(portConflict.port);
+                incident.detail = port === null ? 'EADDRINUSE' : `Port ${port} is already in use (EADDRINUSE).`;
+            }
+        }
+        return incident;
     }
     return null;
 }
@@ -101,7 +125,8 @@ export function buildServerHealthState(options = {}) {
     }
     const dismissedAt = readDismissal(dismissedPath);
     return {
-        supervised: process.env.TERMDOCK_SUPERVISED === '1',
+        supervised: process.env.TERMDOCK_SUPERVISED === '1' && process.connected === true,
+        canEnableSupervision: canEnableSupervision(),
         supervisor,
         incident,
         dismissedAt,

package/dist/server/utils/settings.js

@@ -108,7 +108,7 @@ function normalizeAndroidQuality(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
         return null;
     const item = value;
-    if (item.id !== 'low' && item.id !== 'medium' && item.id !== 'high' && item.id !== 'custom')
+    if (item.id !== 'auto' && item.id !== 'low' && item.id !== 'medium' && item.id !== 'high' && item.id !== 'custom')
         return null;
     const maxSize = typeof item.maxSize === 'number' ? Math.max(360, Math.min(2160, Math.round(item.maxSize))) : 1080;
     const bitRate = typeof item.bitRate === 'number' ? Math.max(300_000, Math.min(30_000_000, Math.round(item.bitRate))) : 4_000_000;

package/dist/server/utils/startupFailure.js

@@ -0,0 +1,16 @@
+/** Flush the failure to the supervisor before exiting; a log entry alone is not IPC. */
+export function exitWithStartupFailure(reason, detail) {
+    if (!process.connected || !process.send)
+        process.exit(1);
+    const timeout = setTimeout(() => process.exit(1), 1_000);
+    const finish = () => {
+        clearTimeout(timeout);
+        process.exit(1);
+    };
+    try {
+        process.send({ type: 'termdock-startup-failed', reason, detail }, finish);
+    }
+    catch {
+        finish();
+    }
+}

package/dist/server/utils/supervisorProtocol.js

@@ -5,6 +5,11 @@
  * 否则唯一验证手段就只剩"手动 kill 一下看看"。
  */
 export const SUPERVISOR_STATE_VERSION = 1;
+export function isStartupFailedMessage(value) {
+    return isRecord(value) && value.type === 'termdock-startup-failed'
+        && typeof value.reason === 'string'
+        && (value.detail === undefined || typeof value.detail === 'string');
+}
 function isRecord(value) {
     return typeof value === 'object' && value !== null;
 }

package/package.json

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

package/runtime-manifest.json

@@ -1,13 +1,13 @@
 {
   "schemaVersion": 1,
   "packageName": "termdock",
-  "version": "1.4.263",
+  "version": "1.4.265",
   "runtimeProtocolVersion": 1,
   "minimumDesktopVersion": "1.4.46",
   "nodeMajor": 22,
   "dependencyHash": "sha256-K4KyYJuVoQDpZsBM8ZX1Rw3MddOxAzVdp/cPm0iGZz0=",
-  "serverBundleHash": "sha256-P298/VVMPtBwuB5OMydf/x/ktRiauZC5IvJvwL2N5/8=",
-  "clientBundleHash": "sha256-UmhjK1bsiYqkurkrSz5AHkF84uC3gST7Z0Op2nhnJzw=",
+  "serverBundleHash": "sha256-J2E5faoECqRyYnXPzSDHcV9tXUuUih+LDtG464f/dHI=",
+  "clientBundleHash": "sha256-FJtbhUlN3+7dITPffcvTDidMmywkNOsNa+E+7ow3+SY=",
   "entrypoint": "dist/server/cli.js",
   "clientEntrypoint": "dist/client/index.html"
 }