termdock 1.4.122 → 1.4.124

package/dist/server/utils/fileWatchPolicy.js

@@ -0,0 +1,136 @@
+import path from 'path';
+import fs from 'fs';
+export const WATCH_IGNORED_NAMES = new Set([
+    '.git', 'node_modules', 'dist', 'build', '.next', '.nuxt', '.turbo', 'coverage', 'target', '.gradle', '.idea', '.DS_Store',
+]);
+export const WATCH_RESOURCE_BACKOFF_MS = 60_000;
+export function enqueueLatestWatchEvent(pending, eventPath, eventType, maxPending) {
+    if (!pending.has(eventPath) && pending.size >= maxPending)
+        return 'overflow';
+    pending.set(eventPath, eventType);
+    return 'queued';
+}
+function isSameOrDescendant(parentPath, candidatePath) {
+    const relative = path.relative(parentPath, candidatePath);
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+/**
+ * Recursive watchers already cover every descendant. Keep only the shallowest
+ * roots so expanding a folder inside an already watched folder cannot allocate
+ * another overlapping native watcher.
+ */
+export function minimizeRecursiveWatchRoots(roots) {
+    const uniqueRoots = [...new Set(roots.map((root) => path.resolve(root)))];
+    uniqueRoots.sort((a, b) => a.split(path.sep).length - b.split(path.sep).length || a.localeCompare(b));
+    const minimal = [];
+    for (const root of uniqueRoots) {
+        if (!minimal.some((parent) => isSameOrDescendant(parent, root)))
+            minimal.push(root);
+    }
+    return minimal;
+}
+export function getWatchErrorCode(error) {
+    if (!error || typeof error !== 'object')
+        return null;
+    const code = error.code;
+    return typeof code === 'string' ? code.toUpperCase() : null;
+}
+export function isWatchResourceExhaustion(error) {
+    const code = getWatchErrorCode(error);
+    if (code === 'EMFILE' || code === 'ENFILE' || code === 'ENOSPC')
+        return true;
+    const message = error instanceof Error ? error.message : String(error);
+    return /\b(?:EMFILE|ENFILE|ENOSPC)\b|too many open files|inotify/i.test(message);
+}
+export function countInotifyWatchDescriptors(fdInfo) {
+    return fdInfo.split('\n').filter((line) => line.startsWith('inotify wd:')).length;
+}
+/** Best-effort Linux-only snapshot. Call only on watcher failures, never on the hot path. */
+export async function inspectLinuxInotifyUsage() {
+    if (process.platform !== 'linux' || typeof process.getuid !== 'function')
+        return null;
+    const uid = process.getuid();
+    let partial = false;
+    let maxUserInstances = null;
+    let maxUserWatches = null;
+    try {
+        const raw = await fs.promises.readFile('/proc/sys/fs/inotify/max_user_instances', 'utf8');
+        const parsed = Number.parseInt(raw.trim(), 10);
+        if (Number.isFinite(parsed))
+            maxUserInstances = parsed;
+    }
+    catch {
+        partial = true;
+    }
+    try {
+        const raw = await fs.promises.readFile('/proc/sys/fs/inotify/max_user_watches', 'utf8');
+        const parsed = Number.parseInt(raw.trim(), 10);
+        if (Number.isFinite(parsed))
+            maxUserWatches = parsed;
+    }
+    catch {
+        partial = true;
+    }
+    let procEntries;
+    try {
+        procEntries = await fs.promises.readdir('/proc', { withFileTypes: true });
+    }
+    catch {
+        return { maxUserInstances, maxUserWatches, observedUserInstances: 0, observedUserWatches: 0, topConsumers: [], partial: true };
+    }
+    const consumers = [];
+    for (const procEntry of procEntries) {
+        if (!procEntry.isDirectory() || !/^\d+$/.test(procEntry.name))
+            continue;
+        const pid = Number(procEntry.name);
+        const procPath = `/proc/${procEntry.name}`;
+        try {
+            if ((await fs.promises.stat(procPath)).uid !== uid)
+                continue;
+            const fdEntries = await fs.promises.readdir(`${procPath}/fd`);
+            let instances = 0;
+            let watches = 0;
+            for (const fd of fdEntries) {
+                try {
+                    if ((await fs.promises.readlink(`${procPath}/fd/${fd}`)) !== 'anon_inode:inotify')
+                        continue;
+                    instances += 1;
+                    try {
+                        watches += countInotifyWatchDescriptors(await fs.promises.readFile(`${procPath}/fdinfo/${fd}`, 'utf8'));
+                    }
+                    catch {
+                        partial = true;
+                    }
+                }
+                catch {
+                    // Processes and descriptors can disappear while /proc is sampled.
+                }
+            }
+            if (instances === 0)
+                continue;
+            let command = procEntry.name;
+            try {
+                const rawCommand = await fs.promises.readFile(`${procPath}/comm`, 'utf8');
+                command = rawCommand.trim() || command;
+            }
+            catch {
+                partial = true;
+            }
+            consumers.push({ pid, command, instances, watches });
+        }
+        catch (error) {
+            const code = getWatchErrorCode(error);
+            if (code !== 'ENOENT' && code !== 'ESRCH')
+                partial = true;
+        }
+    }
+    consumers.sort((a, b) => b.watches - a.watches || b.instances - a.instances || a.pid - b.pid);
+    return {
+        maxUserInstances,
+        maxUserWatches,
+        observedUserInstances: consumers.reduce((total, item) => total + item.instances, 0),
+        observedUserWatches: consumers.reduce((total, item) => total + item.watches, 0),
+        topConsumers: consumers.slice(0, 8),
+        partial,
+    };
+}

package/dist/server/utils/settings.js

@@ -60,6 +60,16 @@ export function normalizeNewSessionAgentSlug(value) {
     const slug = value.trim().toLowerCase();
     return /^[a-z][a-z0-9-]{0,39}$/.test(slug) ? slug : null;
 }
+export function normalizeFileSortModes(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return {};
+    return Object.fromEntries(Object.entries(value)
+        .filter(([filePath, mode]) => (mode === 'modified'
+        && filePath.length > 0
+        && filePath.length <= 4096
+        && (filePath.startsWith('/') || /^[a-zA-Z]:[\\/]/.test(filePath))))
+        .slice(-500));
+}
 function normalizeSettings(value) {
     const raw = value && typeof value === 'object' && !Array.isArray(value)
         ? value
@@ -106,6 +116,7 @@ function normalizeSettings(value) {
             : 12_000,
         newSessionAgentSlug: normalizeNewSessionAgentSlug(raw.newSessionAgentSlug),
         runningSessionButtonEnabled: raw.runningSessionButtonEnabled === true,
+        fileSortModes: normalizeFileSortModes(raw.fileSortModes),
         updatedAt: typeof raw.updatedAt === 'number' ? raw.updatedAt : Date.now(),
     };
 }
@@ -408,3 +419,21 @@ export function setRunningSessionButtonEnabledSetting(enabled) {
         settings.runningSessionButtonEnabled = enabled;
     });
 }
+export function getFileSortModesSetting() {
+    return { ...loadSettings().fileSortModes };
+}
+export function setFileSortModesSetting(modes) {
+    return updateSettings((settings) => {
+        settings.fileSortModes = normalizeFileSortModes(modes);
+    });
+}
+export function setFileSortModeSetting(filePath, mode) {
+    return updateSettings((settings) => {
+        const next = { ...settings.fileSortModes };
+        if (mode === 'modified')
+            next[filePath] = mode;
+        else
+            delete next[filePath];
+        settings.fileSortModes = normalizeFileSortModes(next);
+    });
+}

package/dist/server/utils/terminalColorEnvironment.js

@@ -1,3 +1,9 @@
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+const execFileAsync = promisify(execFile);
+export const TERMDOCK_OUTER_TERM = 'xterm-256color';
+export const TERMDOCK_TRUECOLOR_FEATURE_SLOT = 'terminal-features[100]';
+export const TERMDOCK_TRUECOLOR_OVERRIDE_SLOT = 'terminal-overrides[100]';
 export function buildInteractiveColorEnvironment(source) {
     const env = { ...source, COLORTERM: 'truecolor' };
     delete env.NO_COLOR;
@@ -24,3 +30,43 @@ export function buildTmuxColorEnvironmentCommands(sessionName, forceColor = fals
     }
     return commands;
 }
+/**
+ * Pick the richest tmux TERM that applications on this host can resolve.
+ * Older/minimal Linux installations may ship tmux without the matching
+ * tmux-256color terminfo entry, in which case screen-256color is safer.
+ */
+export async function resolveTmuxInnerTerm() {
+    try {
+        await execFileAsync('infocmp', ['tmux-256color'], {
+            timeout: 2000,
+            maxBuffer: 64 * 1024,
+        });
+        return 'tmux-256color';
+    }
+    catch {
+        return 'screen-256color';
+    }
+}
+/**
+ * Keep Termdock's known xterm.js capabilities independent of each host's
+ * ~/.tmux.conf. A fixed array slot makes repeated preparation idempotent.
+ * terminal-features is available in modern tmux; legacy releases use Tc.
+ */
+export async function ensureTmuxColorCapabilities(runTmux, sessionName, innerTerm = 'tmux-256color') {
+    try {
+        await runTmux([
+            'set-option', '-s', TERMDOCK_TRUECOLOR_FEATURE_SLOT,
+            `${TERMDOCK_OUTER_TERM}:RGB`,
+        ]);
+    }
+    catch {
+        await runTmux([
+            'set-option', '-s', TERMDOCK_TRUECOLOR_OVERRIDE_SLOT,
+            `${TERMDOCK_OUTER_TERM}:Tc`,
+        ]);
+    }
+    if (!sessionName)
+        return;
+    await runTmux(['set-option', '-t', sessionName, 'default-terminal', innerTerm]);
+    await runTmux(['set-environment', '-t', sessionName, 'TERM', innerTerm]);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termdock",
-  "version": "1.4.122",
+  "version": "1.4.124",
   "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.122",
+  "version": "1.4.124",
   "runtimeProtocolVersion": 1,
   "minimumDesktopVersion": "1.4.46",
   "nodeMajor": 22,
   "dependencyHash": "sha256-3I9X7zF4J4BUYOvxi3lIuWSKfDy6S6GD61w8Ay95Ypw=",
-  "serverBundleHash": "sha256-Jpv43mfTDi/41FkY2nk16vKkl1RQQhR/BIowPe8BkXM=",
+  "serverBundleHash": "sha256-AQWKjPHpOh2fs4wIcz59s8q5lmO5UVedCyrCLFFeW9w=",
   "entrypoint": "dist/server/cli.js",
   "clientEntrypoint": "dist/client/index.html"
 }

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

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

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

@@ -1 +0,0 @@
-import{s as a,a as s,c as t,C as e}from"./chunk-V7JOEXUC-d6x1hwlS.js";import{b as i}from"./mermaid.core-CiIhxnwD.js";import"./chunk-5VM5RSS4-D1ewEFAt.js";import"./chunk-XXDRQBXY-DDzcV3AA.js";import"./chunk-VR4S4FIN-Cst36NFV.js";import"./chunk-32BRIVSS-CXmu1n-P.js";import"./purify.es-CC4Brkr_.js";import"./index-CoDf9qRl.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-NZpzVwgO.js

@@ -1 +0,0 @@
-import{s as a,a as s,c as t,C as e}from"./chunk-V7JOEXUC-d6x1hwlS.js";import{b as i}from"./mermaid.core-CiIhxnwD.js";import"./chunk-5VM5RSS4-D1ewEFAt.js";import"./chunk-XXDRQBXY-DDzcV3AA.js";import"./chunk-VR4S4FIN-Cst36NFV.js";import"./chunk-32BRIVSS-CXmu1n-P.js";import"./purify.es-CC4Brkr_.js";import"./index-CoDf9qRl.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};