termdock 1.0.0

package/dist/server/utils/settings.js

@@ -0,0 +1,157 @@
+import crypto from 'crypto';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { LOCAL_ACCESS } from '../config.js';
+const SETTINGS_DIR = path.join(os.homedir(), '.termdock');
+const SETTINGS_FILE = path.join(SETTINGS_DIR, 'settings.json');
+function generateAutoName() {
+    const alphabet = LOCAL_ACCESS.generatedNameAlphabet;
+    const bytes = crypto.randomBytes(LOCAL_ACCESS.generatedNameLength);
+    let value = '';
+    for (const byte of bytes) {
+        value += alphabet[byte % alphabet.length];
+    }
+    return value;
+}
+function normalizeSource(value) {
+    return value === 'manual' ? 'manual' : 'auto';
+}
+export function normalizeLocalAccessName(input) {
+    if (typeof input !== 'string')
+        return null;
+    const normalized = input.trim().toLowerCase();
+    if (normalized.length === 0)
+        return null;
+    // DNS label: 1..63 chars, alnum at both ends, hyphen allowed inside.
+    if (normalized.length > 63)
+        return null;
+    if (!/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/.test(normalized))
+        return null;
+    return normalized;
+}
+export function createAutoLocalAccessName() {
+    return generateAutoName();
+}
+function normalizeLocalAccessSettings(value) {
+    const raw = value && typeof value === 'object'
+        ? value
+        : {};
+    const source = normalizeSource(raw.source);
+    const normalizedName = normalizeLocalAccessName(raw.name ?? raw.shortName);
+    return {
+        name: normalizedName ?? generateAutoName(),
+        source: normalizedName ? source : 'auto',
+    };
+}
+function normalizeSettings(value) {
+    const raw = value && typeof value === 'object'
+        ? value
+        : {};
+    return {
+        version: 1,
+        preventSleep: raw.preventSleep === true,
+        localAccess: normalizeLocalAccessSettings(raw.localAccess),
+        firstRunCompleted: raw.firstRunCompleted === true,
+        updatedAt: typeof raw.updatedAt === 'number' ? raw.updatedAt : Date.now(),
+    };
+}
+export function loadSettings() {
+    try {
+        const raw = fs.readFileSync(SETTINGS_FILE, 'utf-8');
+        const doc = normalizeSettings(JSON.parse(raw));
+        // Persist migrated defaults (for example the first generated local-access name)
+        // so the advertised hostname stays stable across restarts.
+        saveSettings(doc);
+        return doc;
+    }
+    catch { /* ignore missing/malformed settings */ }
+    const initial = normalizeSettings(null);
+    try {
+        saveSettings(initial);
+    }
+    catch { /* best effort */ }
+    return initial;
+}
+export async function loadSettingsAsync() {
+    try {
+        const raw = await fs.promises.readFile(SETTINGS_FILE, 'utf-8');
+        const doc = normalizeSettings(JSON.parse(raw));
+        await saveSettingsAsync(doc);
+        return doc;
+    }
+    catch { /* ignore missing/malformed settings */ }
+    const initial = normalizeSettings(null);
+    try {
+        await saveSettingsAsync(initial);
+    }
+    catch { /* best effort */ }
+    return initial;
+}
+export function saveSettings(next) {
+    fs.mkdirSync(SETTINGS_DIR, { recursive: true });
+    fs.writeFileSync(SETTINGS_FILE, JSON.stringify(next, null, 2), 'utf-8');
+}
+export async function saveSettingsAsync(next) {
+    await fs.promises.mkdir(SETTINGS_DIR, { recursive: true });
+    await fs.promises.writeFile(SETTINGS_FILE, JSON.stringify(next, null, 2), 'utf-8');
+}
+export function updateSettings(mutator) {
+    const current = loadSettings();
+    const next = mutator(current) ?? current;
+    next.updatedAt = Date.now();
+    saveSettings(next);
+    return next;
+}
+export async function updateSettingsAsync(mutator) {
+    const current = await loadSettingsAsync();
+    const next = mutator(current) ?? current;
+    next.updatedAt = Date.now();
+    await saveSettingsAsync(next);
+    return next;
+}
+export function getPreventSleepSetting() {
+    return loadSettings().preventSleep;
+}
+export async function getPreventSleepSettingAsync() {
+    return (await loadSettingsAsync()).preventSleep;
+}
+export function setPreventSleepSetting(enabled) {
+    return updateSettings((settings) => {
+        settings.preventSleep = enabled;
+    });
+}
+export async function setPreventSleepSettingAsync(enabled) {
+    return updateSettingsAsync((settings) => {
+        settings.preventSleep = enabled;
+    });
+}
+export function getLocalAccessSetting() {
+    return loadSettings().localAccess;
+}
+export async function getLocalAccessSettingAsync() {
+    return (await loadSettingsAsync()).localAccess;
+}
+export function setLocalAccessSetting(next) {
+    return updateSettings((settings) => {
+        settings.localAccess = next;
+    });
+}
+export async function setLocalAccessSettingAsync(next) {
+    return updateSettingsAsync((settings) => {
+        settings.localAccess = next;
+    });
+}
+export function resetLocalAccessSetting() {
+    return updateSettings((settings) => {
+        settings.localAccess = { name: generateAutoName(), source: 'auto' };
+    });
+}
+export function markFirstRunCompleted() {
+    return updateSettings((settings) => {
+        settings.firstRunCompleted = true;
+    });
+}
+export function isFirstRunCompleted() {
+    return loadSettings().firstRunCompleted;
+}

package/dist/server/utils/tmuxFocus.js

@@ -0,0 +1,45 @@
+export const FOCUS_IN_SEQUENCE = '\x1b[I';
+export const FOCUS_OUT_SEQUENCE = '\x1b[O';
+const FOCUS_MODE_PATTERN = /\x1b\[\?1004([hl])/g;
+const MAX_FOCUS_MODE_BUFFER = 16;
+export function scanFocusTrackingMode(chunk, previous) {
+    const combined = previous.buffer + chunk;
+    let requested = previous.requested;
+    let changed = false;
+    let match;
+    FOCUS_MODE_PATTERN.lastIndex = 0;
+    while ((match = FOCUS_MODE_PATTERN.exec(combined)) !== null) {
+        const nextRequested = match[1] === 'h';
+        if (requested !== nextRequested) {
+            requested = nextRequested;
+            changed = true;
+        }
+    }
+    return {
+        buffer: combined.slice(-MAX_FOCUS_MODE_BUFFER),
+        requested,
+        changed,
+    };
+}
+export function setClientFocusState(state, clientId, focused) {
+    if (focused) {
+        state.focusedClients.set(clientId, true);
+    }
+    else {
+        state.focusedClients.delete(clientId);
+    }
+    return recomputeEffectiveFocus(state);
+}
+export function removeClientFocusState(state, clientId) {
+    state.focusedClients.delete(clientId);
+    return recomputeEffectiveFocus(state);
+}
+export function recomputeEffectiveFocus(state) {
+    const nextFocused = Array.from(state.focusedClients.values()).some(Boolean);
+    const changed = state.effectiveFocused !== nextFocused;
+    state.effectiveFocused = nextFocused;
+    return { effectiveFocused: nextFocused, changed };
+}
+export function getFocusSequence(focused) {
+    return focused ? FOCUS_IN_SEQUENCE : FOCUS_OUT_SEQUENCE;
+}

package/dist/server/utils/tmuxProgramDetection.js

@@ -0,0 +1,148 @@
+export const DEFAULT_TMUX_HELPER_PROGRAM_NAMES = new Set([
+    'caffeinate',
+    'bytecloud-auth-rpc',
+    'bytecloud-auth-rpc-darwin-arm64',
+    'gitstatusd',
+    'gitstatusd-darwin-arm64',
+]);
+export function normalizeProgramName(command) {
+    if (typeof command !== 'string') {
+        return null;
+    }
+    const normalized = command.trim();
+    if (!normalized) {
+        return null;
+    }
+    const lastSegment = normalized.split(/[\\/]/).pop()?.trim();
+    return lastSegment && lastSegment.length > 0 ? lastSegment : normalized;
+}
+export function extractProgramLabelFromArgs(args, options) {
+    if (!args)
+        return null;
+    const parts = args.split(/\s+/);
+    const exe = parts[0];
+    const exeName = normalizeProgramName(exe) || exe;
+    if (options.genericProgramNames.has(exeName) && parts.length > 1) {
+        const script = parts[1];
+        const scriptName = normalizeProgramName(script) || script;
+        const withoutExt = scriptName.replace(/\.(js|ts|mjs|cjs|py|sh|rb|pl|lua)$/, '');
+        if (withoutExt && withoutExt.length > 0) {
+            if (options.wrapperScriptNames.has(withoutExt)) {
+                const remaining = parts.slice(2);
+                const skipTokens = new Set(['x', 'run', 'exec', 'use']);
+                let idx = 0;
+                if (remaining.length > 0 && skipTokens.has(remaining[0])) {
+                    idx = 1;
+                }
+                for (let i = idx; i < remaining.length; i += 1) {
+                    const token = remaining[i];
+                    if (token.startsWith('-'))
+                        continue;
+                    return normalizeProgramName(token);
+                }
+                return withoutExt;
+            }
+            return withoutExt;
+        }
+    }
+    return exeName;
+}
+function lowerProgramName(value) {
+    return normalizeProgramName(value)?.toLowerCase() ?? null;
+}
+function isKnownProgram(value, names) {
+    const normalized = lowerProgramName(value);
+    if (!normalized)
+        return false;
+    if (names.has(normalized))
+        return true;
+    for (const name of names) {
+        if (normalized.includes(name))
+            return true;
+    }
+    return false;
+}
+function ancestorDistance(row, panePid, rowsByPid) {
+    let current = row;
+    const seen = new Set();
+    for (let depth = 0; depth < 25; depth += 1) {
+        if (!current || seen.has(current.pid))
+            return null;
+        seen.add(current.pid);
+        if (current.ppid === panePid)
+            return depth + 1;
+        current = rowsByPid.get(current.ppid);
+    }
+    return null;
+}
+function isDirectProgramMatch(row, command) {
+    if (!command)
+        return false;
+    const normalized = command.toLowerCase();
+    const comm = lowerProgramName(row.comm);
+    const exe = lowerProgramName(row.args.split(/\s+/)[0]);
+    return comm === normalized || exe === normalized;
+}
+export function selectTmuxForegroundProgram(input) {
+    const helperProgramNames = input.helperProgramNames ?? DEFAULT_TMUX_HELPER_PROGRAM_NAMES;
+    const rowsByPid = new Map(input.rows.map((row) => [row.pid, row]));
+    const foregroundRows = input.rows.filter((row) => row.pid !== input.panePid && row.tpgid > 0 && row.pgid === row.tpgid && !row.stat.startsWith('Z'));
+    if (foregroundRows.length === 0) {
+        return null;
+    }
+    const decorated = foregroundRows.map((row) => {
+        const command = normalizeProgramName(input.extractProgramLabel(row.args) ?? row.comm);
+        const commandKey = command?.toLowerCase() ?? null;
+        const distance = ancestorDistance(row, input.panePid, rowsByPid);
+        const isHelper = isKnownProgram(command, helperProgramNames) || isKnownProgram(row.comm, helperProgramNames) || isKnownProgram(row.args.split(/\s+/)[0], helperProgramNames);
+        const isShell = commandKey ? input.shellNames.has(commandKey) : false;
+        const isGeneric = commandKey ? input.genericProgramNames.has(commandKey) : false;
+        let score = 0;
+        if (!isHelper)
+            score += 1000;
+        if (!isShell && !isGeneric)
+            score += 200;
+        if (isDirectProgramMatch(row, command))
+            score += 120;
+        if (distance !== null)
+            score += 50 + distance;
+        if (isHelper)
+            score -= 1000;
+        if (isShell)
+            score -= 200;
+        if (isGeneric)
+            score -= 80;
+        return { row, command, isHelper, score };
+    });
+    const nonHelper = decorated.filter((candidate) => candidate.command && !candidate.isHelper);
+    const pool = nonHelper.length > 0
+        ? nonHelper
+        : decorated.filter((candidate) => candidate.command);
+    pool.sort((a, b) => {
+        if (b.score !== a.score)
+            return b.score - a.score;
+        return a.row.pid - b.row.pid;
+    });
+    const selected = pool[0];
+    if (!selected?.command) {
+        return null;
+    }
+    return {
+        command: selected.command,
+        rawArgs: selected.row.args,
+    };
+}
+export function normalizeTmuxMetadataProgram(program, options) {
+    const normalized = normalizeProgramName(program);
+    if (!normalized)
+        return null;
+    const key = normalized.toLowerCase();
+    if (options.shellNames.has(key))
+        return null;
+    if (isKnownProgram(normalized, options.helperProgramNames ?? DEFAULT_TMUX_HELPER_PROGRAM_NAMES))
+        return null;
+    return normalized;
+}
+export function tmuxMetadataChanged(previous, next) {
+    return !previous || previous.program !== next.program || previous.cwd !== next.cwd || previous.label !== next.label;
+}

package/package.json

@@ -0,0 +1,125 @@
+{
+  "name": "termdock",
+  "version": "1.0.0",
+  "description": "A complete web-based terminal application with modern UI",
+  "type": "module",
+  "bin": {
+    "termdock": "dist/server/cli.js",
+    "td": "dist/server/cli.js"
+  },
+  "exports": {
+    ".": "./dist/server/entry.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "clean": "rimraf dist",
+    "dev": "concurrently \"npm run dev:client\" \"npm run dev:server\"",
+    "dev:client": "vite",
+    "dev:server": "cross-env PORT=9835 tsx watch src/server/entry.ts",
+    "build": "npm run clean && npm run build:client && npm run build:server",
+    "build:client": "vite build",
+    "build:server": "tsc -p tsconfig.server.json && node -e \"require('fs').chmodSync('dist/server/cli.js', 0o755)\"",
+    "generate:pwa-assets": "pwa-assets-generator --config pwa-assets.config.ts",
+    "preview": "vite preview",
+    "start": "node dist/server/cli.js",
+    "lint": "tsc --noEmit",
+    "trace:diff": "node scripts/inspect-diff-trace.mjs",
+    "trace:fsio": "node scripts/inspect-fs-io.mjs",
+    "test": "vitest --passWithNoTests",
+    "test:ui": "vitest --ui",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@dnd-kit/core": "^6.3.1",
+    "@dnd-kit/sortable": "^10.0.0",
+    "@dnd-kit/utilities": "^3.2.2",
+    "@hello-pangea/dnd": "^18.0.1",
+    "@parcel/watcher": "^2.5.6",
+    "@types/cookie-parser": "^1.4.10",
+    "@types/csurf": "^1.11.5",
+    "@types/refractor": "^2.8.0",
+    "@use-gesture/react": "^10.3.1",
+    "@xterm/addon-clipboard": "^0.3.0-beta.287",
+    "@xterm/addon-fit": "^0.12.0-beta.287",
+    "@xterm/addon-image": "^0.10.0-beta.287",
+    "@xterm/addon-ligatures": "^0.11.0-beta.287",
+    "@xterm/addon-progress": "^0.3.0-beta.287",
+    "@xterm/addon-search": "^0.17.0-beta.287",
+    "@xterm/addon-serialize": "^0.15.0-beta.287",
+    "@xterm/addon-unicode11": "^0.10.0-beta.287",
+    "@xterm/addon-web-links": "^0.13.0-beta.287",
+    "@xterm/addon-webgl": "^0.20.0-beta.286",
+    "@xterm/xterm": "^6.1.0-beta.287",
+    "browser-haptic": "^1.0.13",
+    "busboy": "^1.6.0",
+    "cookie-parser": "^1.4.7",
+    "dompurify": "^3.4.11",
+    "dotenv": "^17.4.2",
+    "express": "^5.2.1",
+    "katex": "^0.17.0",
+    "lucide-react": "^1.17.0",
+    "mermaid": "^11.16.0",
+    "motion": "^12.40.0",
+    "multicast-dns": "^7.2.5",
+    "node-pty": "^1.1.0",
+    "qrcode": "^1.5.4",
+    "react": "^18.2.0",
+    "react-diff-view": "^3.3.3",
+    "react-dom": "^18.2.0",
+    "refractor": "^2.10.1",
+    "swiper": "^12.1.3",
+    "tailwind-merge": "^2.2.0",
+    "uuid": "^13.0.0",
+    "ws": "^8.21.0",
+    "zustand": "^4.5.0"
+  },
+  "devDependencies": {
+    "@testing-library/react": "^14.1.0",
+    "@testing-library/user-event": "^14.5.0",
+    "@types/busboy": "^1.5.4",
+    "@types/express": "^4.17.21",
+    "@types/node": "^20.11.0",
+    "@types/react": "^18.2.0",
+    "@types/react-dom": "^18.2.0",
+    "@types/uuid": "^10.0.0",
+    "@types/ws": "^8.18.1",
+    "@vite-pwa/assets-generator": "^1.0.2",
+    "@vitejs/plugin-react": "^4.2.0",
+    "autoprefixer": "^10.4.0",
+    "concurrently": "^8.2.0",
+    "cross-env": "^10.1.0",
+    "eslint": "^9.39.2",
+    "jsdom": "^24.0.0",
+    "postcss": "^8.4.0",
+    "rimraf": "^6.1.3",
+    "tailwindcss": "^3.4.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.0",
+    "vite": "^7.3.1",
+    "vite-plugin-pwa": "^1.2.0",
+    "vitest": "^4.0.17"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "terminal",
+    "termdock",
+    "xterm",
+    "express",
+    "cli"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Jovines/termdock.git"
+  },
+  "homepage": "https://github.com/Jovines/termdock#readme",
+  "bugs": {
+    "url": "https://github.com/Jovines/termdock/issues"
+  }
+}