termdock 1.4.70 → 1.4.72

package/dist/server/agent/plugins.js

@@ -13,13 +13,42 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
-const PLUGINS_DIR = path.join(os.homedir(), '.termdock', 'agent-plugins');
-const MANIFEST_FILE = 'manifest.json';
-const ICON_FILE = 'icon.svg';
+export const PLUGINS_DIR = path.join(os.homedir(), '.termdock', 'agent-plugins');
+export const MANIFEST_FILE = 'manifest.json';
+export const ICON_FILE = 'icon.svg';
+export const SOURCE_METADATA_FILE = '.termdock-source.json';
 // ---------------------------------------------------------------------------
 // Manifest schema
 // ---------------------------------------------------------------------------
 export const PLUGIN_MANIFEST_VERSION = 2;
+function parseSourceMetadata(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const value = raw;
+    if (value.version !== 1 || !['git', 'local', 'manifest'].includes(String(value.type)))
+        return null;
+    return {
+        version: 1,
+        type: value.type,
+        source: typeof value.source === 'string' ? value.source : null,
+        revision: typeof value.revision === 'string' ? value.revision : null,
+        latestRevision: typeof value.latestRevision === 'string' ? value.latestRevision : null,
+        installedAt: typeof value.installedAt === 'number' ? value.installedAt : 0,
+        updatedAt: typeof value.updatedAt === 'number' ? value.updatedAt : 0,
+        checkedAt: typeof value.checkedAt === 'number' ? value.checkedAt : null,
+    };
+}
+export function readPluginSourceMetadata(dir) {
+    try {
+        return parseSourceMetadata(JSON.parse(fs.readFileSync(path.join(dir, SOURCE_METADATA_FILE), 'utf8')));
+    }
+    catch {
+        return null;
+    }
+}
+export function writePluginSourceMetadata(dir, metadata) {
+    fs.writeFileSync(path.join(dir, SOURCE_METADATA_FILE), JSON.stringify(metadata, null, 2), 'utf8');
+}
 // ---------------------------------------------------------------------------
 // Known sentinel event kinds — the set of events our state machine accepts
 // ---------------------------------------------------------------------------
@@ -48,6 +77,14 @@ function isValidSlug(s) {
 // Hex color validation
 // ---------------------------------------------------------------------------
 const HEX_COLOR_RE = /^#[0-9A-Fa-f]{6}$/;
+function isSafeSvgIcon(svg) {
+    return /^\s*<svg\b/i.test(svg)
+        && !/<(?:script|style|foreignObject|iframe|object|embed)\b/i.test(svg)
+        && !/<\?(?:xml|xml-stylesheet)\b|<!DOCTYPE\b/i.test(svg)
+        && !/\bon[a-z]+\s*=/i.test(svg)
+        && !/(?:href|src)\s*=\s*["']?\s*(?!#)[^"'\s>]+/i.test(svg)
+        && !/url\(\s*(?!["']?#)[^)]+\)/i.test(svg);
+}
 // ---------------------------------------------------------------------------
 // Path resolution: ~ → home directory
 // ---------------------------------------------------------------------------
@@ -57,6 +94,33 @@ function resolveHome(p) {
     }
     return p;
 }
+function validateHookTarget(target) {
+    if (!target.startsWith('~/') || !target.toLowerCase().endsWith('.json')) {
+        return 'hooks.target must be a ~/ path to a JSON file';
+    }
+    const home = path.resolve(os.homedir());
+    const resolved = path.resolve(home, target.slice(2));
+    if (resolved === home || !resolved.startsWith(`${home}${path.sep}`)) {
+        return 'hooks.target must stay inside the user home directory';
+    }
+    // Existing symlinks in any target component could redirect a later write
+    // outside $HOME. Refuse them instead of relying on a racy realpath check.
+    let current = home;
+    for (const part of path.relative(home, resolved).split(path.sep)) {
+        current = path.join(current, part);
+        try {
+            if (fs.lstatSync(current).isSymbolicLink()) {
+                return 'hooks.target may not traverse symbolic links';
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                return 'hooks.target could not be safely inspected';
+            }
+        }
+    }
+    return null;
+}
 export const V1_MIGRATION_GUIDE_COMMAND = 'td agent-plugin --json';
 export const V1_MIGRATION_AI_PROMPT = [
     'Please migrate the attached Termdock Agent plugin manifest from v1 to v2.',
@@ -86,12 +150,13 @@ export function validateManifest(raw, dir) {
         errors.push('slug must be a lowercase alphanumeric string with hyphens (max 40 chars)');
     }
     const displayName = m.displayName;
-    if (typeof displayName !== 'string' || displayName.trim().length === 0) {
-        errors.push('displayName is required and must be a non-empty string');
+    if (typeof displayName !== 'string' || displayName.trim().length === 0 || displayName.length > 80) {
+        errors.push('displayName is required and must be a non-empty string (max 80 chars)');
     }
     const aliases = m.aliases;
-    if (!Array.isArray(aliases) || aliases.length === 0 || !aliases.every((a) => typeof a === 'string' && a.trim().length > 0)) {
-        errors.push('aliases must be a non-empty array of strings');
+    if (!Array.isArray(aliases) || aliases.length === 0 || aliases.length > 16
+        || !aliases.every((a) => typeof a === 'string' && /^[A-Za-z0-9][A-Za-z0-9._-]{0,79}$/.test(a))) {
+        errors.push('aliases must contain 1-16 safe command names');
     }
     const accentColor = m.accentColor;
     if (typeof accentColor !== 'string' || !HEX_COLOR_RE.test(accentColor)) {
@@ -167,6 +232,11 @@ export function validateManifest(raw, dir) {
             if (typeof target !== 'string' || target.trim().length === 0) {
                 errors.push('hooks.target is required and must be a file path (~-abbreviated ok)');
             }
+            else {
+                const targetError = validateHookTarget(target.trim());
+                if (targetError)
+                    errors.push(targetError);
+            }
             const events = h.events;
             if (!Array.isArray(events) || events.length === 0) {
                 errors.push('hooks.events must be a non-empty array');
@@ -182,15 +252,15 @@ export function validateManifest(raw, dir) {
                     const evt = e;
                     const hook = evt.hook;
                     const event = evt.event;
-                    if (typeof hook !== 'string' || hook.trim().length === 0) {
+                    if (typeof hook !== 'string' || hook.trim().length === 0 || hook.length > 120) {
                         errors.push(`hooks.events[${i}].hook is required`);
                     }
                     if (typeof event !== 'string' || !VALID_EVENT_KINDS.has(event)) {
                         errors.push(`hooks.events[${i}].event must be one of: ${[...VALID_EVENT_KINDS].join(', ')}`);
                     }
                     const matcher = evt.matcher;
-                    if (matcher !== undefined && typeof matcher !== 'string') {
-                        errors.push(`hooks.events[${i}].matcher must be a string if provided`);
+                    if (matcher !== undefined && (typeof matcher !== 'string' || matcher.length > 512)) {
+                        errors.push(`hooks.events[${i}].matcher must be a string (max 512 chars) if provided`);
                     }
                     const timeout = evt.timeout;
                     if (timeout !== undefined && (typeof timeout !== 'number' || timeout <= 0)) {
@@ -226,9 +296,20 @@ export function validateManifest(raw, dir) {
             if (typeof command !== 'string' || !command.includes('{sessionId}')) {
                 errors.push('resume.command must contain the {sessionId} placeholder');
             }
+            else {
+                const tokens = command.trim().split(/\s+/);
+                const executable = path.basename(tokens[0] ?? '');
+                if (command.length > 1024
+                    || !tokens.every((token) => /^[A-Za-z0-9_./:@%+,={}-]+$/.test(token))
+                    || !Array.isArray(aliases)
+                    || !aliases.includes(executable)) {
+                    errors.push('resume.command must be a simple argv-like command whose executable is one of aliases; shell syntax is not allowed');
+                }
+            }
             const staleFlags = r.staleFlags;
-            if (staleFlags !== undefined && (!Array.isArray(staleFlags) || !staleFlags.every((f) => typeof f === 'string'))) {
-                errors.push('resume.staleFlags must be an array of strings if provided');
+            if (staleFlags !== undefined && (!Array.isArray(staleFlags) || staleFlags.length > 32
+                || !staleFlags.every((f) => typeof f === 'string' && /^--?[A-Za-z0-9][A-Za-z0-9-]{0,79}$/.test(f)))) {
+                errors.push('resume.staleFlags must be an array of safe CLI flags if provided');
             }
             resumeConfig = {
                 command: command,
@@ -236,6 +317,53 @@ export function validateManifest(raw, dir) {
             };
         }
     }
+    // Optional automatic-title provider. Commands are argv arrays rather than
+    // shell snippets so a UI-installed manifest cannot gain accidental shell
+    // interpolation beyond the executable it explicitly declares.
+    let titleNamer;
+    if (m.titleNamer !== undefined) {
+        if (typeof m.titleNamer !== 'object' || Array.isArray(m.titleNamer) || m.titleNamer === null) {
+            errors.push('titleNamer must be an object if present');
+        }
+        else {
+            const n = m.titleNamer;
+            const command = n.command;
+            const args = n.args;
+            if (typeof command !== 'string' || command.trim().length === 0 || command.length > 1024) {
+                errors.push('titleNamer.command is required');
+            }
+            if (!Array.isArray(args) || args.length > 64
+                || !args.every((arg) => typeof arg === 'string' && arg.length <= 16_384)
+                || !args.some((arg) => arg.includes('{prompt}'))) {
+                errors.push('titleNamer.args must be a string array containing {prompt}');
+            }
+            let models;
+            if (n.models !== undefined) {
+                if (typeof n.models !== 'object' || Array.isArray(n.models) || n.models === null) {
+                    errors.push('titleNamer.models must be an object if present');
+                }
+                else {
+                    const rawModels = n.models;
+                    if (typeof rawModels.command !== 'string' || rawModels.command.trim().length === 0 || rawModels.command.length > 1024) {
+                        errors.push('titleNamer.models.command is required');
+                    }
+                    if (rawModels.args !== undefined && (!Array.isArray(rawModels.args) || rawModels.args.length > 64
+                        || !rawModels.args.every((arg) => typeof arg === 'string' && arg.length <= 16_384))) {
+                        errors.push('titleNamer.models.args must be a string array if present');
+                    }
+                    if (typeof rawModels.command === 'string') {
+                        models = {
+                            command: rawModels.command.trim(),
+                            args: Array.isArray(rawModels.args) ? rawModels.args : undefined,
+                        };
+                    }
+                }
+            }
+            if (typeof command === 'string' && Array.isArray(args)) {
+                titleNamer = { command: command.trim(), args: args, models };
+            }
+        }
+    }
     if (errors.length > 0) {
         return {
             error: {
@@ -259,6 +387,7 @@ export function validateManifest(raw, dir) {
             statuses,
             hooks,
             resume: resumeConfig,
+            titleNamer,
         },
     };
 }
@@ -303,18 +432,27 @@ export function loadPlugins() {
         }
         const iconPath = path.join(dir, ICON_FILE);
         let iconMtime = 0;
-        const iconExists = fs.existsSync(iconPath);
+        let iconExists = fs.existsSync(iconPath);
         if (iconExists) {
             try {
-                iconMtime = fs.statSync(iconPath).mtimeMs;
+                if (!isSafeSvgIcon(fs.readFileSync(iconPath, 'utf8'))) {
+                    errors.push({ slug: result.manifest.slug, errors: ['icon.svg contains unsafe or invalid SVG content'] });
+                    iconExists = false;
+                }
+                else {
+                    iconMtime = fs.statSync(iconPath).mtimeMs;
+                }
+            }
+            catch {
+                iconExists = false;
             }
-            catch { /* keep 0 */ }
         }
         plugins.push({
             manifest: result.manifest,
             dir,
             iconPath: iconExists ? iconPath : null,
             iconMtime,
+            source: readPluginSourceMetadata(dir),
         });
     }
     return { plugins, errors };
@@ -327,6 +465,17 @@ export function savePlugin(manifest) {
     fs.mkdirSync(dir, { recursive: true });
     const manifestPath = path.join(dir, MANIFEST_FILE);
     fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), 'utf8');
+    const now = Date.now();
+    writePluginSourceMetadata(dir, {
+        version: 1,
+        type: 'manifest',
+        source: null,
+        revision: null,
+        latestRevision: null,
+        installedAt: now,
+        updatedAt: now,
+        checkedAt: null,
+    });
     return dir;
 }
 /**

package/dist/server/agent/registry.js

@@ -33,7 +33,7 @@ export function agentBySlug(slug) {
     return BY_SLUG.get(slug.trim().toLowerCase()) ?? null;
 }
 export function listAgents() {
-    return AGENTS.slice();
+    return [...BY_SLUG.values()];
 }
 function matchToken(token) {
     return BY_ALIAS.get(token) ?? null;

package/dist/server/agent/session.js

@@ -17,6 +17,13 @@ const EVENT_KINDS = new Set([
     'session-start', 'prompt-submit', 'permission-request', 'question-asked',
     'tool-complete', 'notification', 'stop', 'session-end',
 ]);
+/** A hook may brand an unclaimed pane, but it may not overwrite or decorate
+ * a pane already owned by a different detected Agent. */
+export function agentEventMatchesCurrentAgent(current, event) {
+    if (event.agentSlug && !event.agent)
+        return false;
+    return !current || !event.agent || current.slug === event.agent.slug;
+}
 export function defaultAgentSessionState() {
     return {
         status: 'idle',
@@ -140,13 +147,15 @@ export function parseAgentEvent(payload) {
     const eventName = nonEmpty(w.event);
     if (!eventName || !EVENT_KINDS.has(eventName))
         return null;
-    const agent = agentBySlug(nonEmpty(w.agent));
+    const agentSlug = nonEmpty(w.agent);
+    const agent = agentBySlug(agentSlug);
     const statusId = nonEmpty(w.status);
     const status = statusId
         ? agent?.statuses?.find((definition) => definition.id === statusId) ?? null
         : null;
     return {
         agent,
+        agentSlug,
         kind: eventName,
         sessionId: nonEmpty(w.session_id),
         message: nonEmpty(w.message),

package/dist/server/agent/titleNamerCatalog.js

@@ -3,12 +3,30 @@ import fs from 'fs';
 import os from 'os';
 import path from 'path';
 import { promisify } from 'util';
+import { loadPlugins } from './plugins.js';
+import { getAutoRenameAgentsSetting, getAutoRenameNamerSetting } from '../utils/settings.js';
 const execFileAsync = promisify(execFile);
 const CACHE_FRESH_MS = 24 * 60 * 60_000;
 const PROBE_TIMEOUT_MS = 10_000;
 const CACHE_FILE = path.join(os.homedir(), '.termdock', 'title-namer-catalog.json');
+function pluginCommandEnv() {
+    const allowed = ['PATH', 'HOME', 'USER', 'LOGNAME', 'SHELL', 'LANG', 'TERM', 'TMPDIR', 'XDG_CONFIG_HOME', 'XDG_CACHE_HOME', 'XDG_DATA_HOME'];
+    const env = { NO_COLOR: '1', TERM: 'dumb' };
+    for (const key of allowed) {
+        if (process.env[key] !== undefined)
+            env[key] = process.env[key];
+    }
+    for (const [key, value] of Object.entries(process.env)) {
+        if (key.startsWith('LC_') && value !== undefined)
+            env[key] = value;
+    }
+    return env;
+}
 let cached = null;
 let refreshPromise = null;
+export function invalidateTitleNamerCatalog() {
+    cached = null;
+}
 function normalizeCachedCatalog(input) {
     if (!input || typeof input !== 'object')
         return null;
@@ -19,7 +37,7 @@ function normalizeCachedCatalog(input) {
         if (!entry || typeof entry !== 'object')
             return [];
         const candidate = entry;
-        if (candidate.slug !== 'codex' && candidate.slug !== 'claude')
+        if (typeof candidate.slug !== 'string' || !/^[a-z][a-z0-9-]{0,39}$/.test(candidate.slug))
             return [];
         if (!Array.isArray(candidate.models))
             return [];
@@ -155,11 +173,106 @@ async function listClaudeModels() {
         return parseClaudeSupportedModels(`${candidate.stdout ?? ''}\n${candidate.stderr ?? ''}`);
     }
 }
+function normalizeDiscoveredModels(input) {
+    if (!Array.isArray(input))
+        return [];
+    return input.flatMap((entry) => {
+        if (typeof entry === 'string' && /^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,119}$/.test(entry)) {
+            return [{ id: entry, displayName: entry, description: '', isDefault: false }];
+        }
+        if (!entry || typeof entry !== 'object')
+            return [];
+        const model = entry;
+        if (typeof model.id !== 'string' || !/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,119}$/.test(model.id))
+            return [];
+        return [{
+                id: model.id,
+                displayName: typeof model.displayName === 'string' ? model.displayName : model.id,
+                description: typeof model.description === 'string' ? model.description : '',
+                isDefault: model.isDefault === true,
+            }];
+    });
+}
+function expandPluginPath(value, pluginDir) {
+    return value.replaceAll('{pluginDir}', pluginDir);
+}
+async function listPluginModels(config, pluginDir) {
+    if (!config.models)
+        return [];
+    const { stdout } = await execFileAsync(expandPluginPath(config.models.command, pluginDir), (config.models.args ?? []).map((arg) => expandPluginPath(arg, pluginDir)), {
+        timeout: PROBE_TIMEOUT_MS,
+        maxBuffer: 256 * 1024,
+        cwd: pluginDir,
+        env: pluginCommandEnv(),
+    });
+    return normalizeDiscoveredModels(JSON.parse(stdout));
+}
+function pluginTitleNamers() {
+    return loadPlugins().plugins.flatMap((plugin) => plugin.manifest.titleNamer
+        ? [{
+                slug: plugin.manifest.slug,
+                displayName: plugin.manifest.displayName,
+                config: plugin.manifest.titleNamer,
+                dir: plugin.dir,
+            }]
+        : []);
+}
+export function shouldRunPluginTitleCommands(slug, selected, enabledAgents) {
+    return selected === slug
+        || (selected === 'auto' && enabledAgents.includes(slug));
+}
+function isPluginTitleExecutionEnabled(slug) {
+    return shouldRunPluginTitleCommands(slug, getAutoRenameNamerSetting(), getAutoRenameAgentsSetting());
+}
+export async function runTitleNamer(slug, prompt, model) {
+    let command;
+    let args;
+    let cwd;
+    if (slug === 'codex') {
+        command = 'codex';
+        args = ['exec', '--ephemeral', '--skip-git-repo-check', '--color', 'never', ...(model ? ['--model', model] : []), prompt];
+    }
+    else if (slug === 'claude') {
+        command = 'claude';
+        args = [...(model ? ['--model', model] : []), '--no-session-persistence', '-p', prompt];
+    }
+    else {
+        const provider = pluginTitleNamers().find((entry) => entry.slug === slug);
+        if (!provider || !isPluginTitleExecutionEnabled(slug))
+            return null;
+        cwd = provider.dir;
+        command = expandPluginPath(provider.config.command, provider.dir);
+        args = provider.config.args.flatMap((arg) => {
+            if (arg.includes('{model}') && !model)
+                return [];
+            return [expandPluginPath(arg, provider.dir).replaceAll('{prompt}', prompt).replaceAll('{model}', model ?? '')];
+        });
+    }
+    try {
+        const { stdout } = await execFileAsync(command, args, {
+            timeout: 45_000,
+            maxBuffer: 256 * 1024,
+            cwd,
+            env: cwd ? pluginCommandEnv() : { ...process.env, NO_COLOR: '1', TERM: 'dumb' },
+        });
+        return stdout;
+    }
+    catch {
+        return null;
+    }
+}
 async function refreshTitleNamerCatalog() {
     if (refreshPromise)
         return refreshPromise;
     refreshPromise = (async () => {
-        const [codex, claude] = await Promise.allSettled([listCodexModels(), listClaudeModels()]);
+        const plugins = pluginTitleNamers();
+        const [codex, claude, ...pluginResults] = await Promise.allSettled([
+            listCodexModels(),
+            listClaudeModels(),
+            ...plugins.map((provider) => provider.config.models && isPluginTitleExecutionEnabled(provider.slug)
+                ? listPluginModels(provider.config, provider.dir)
+                : Promise.resolve([])),
+        ]);
         const previousCodex = cached?.value.find((namer) => namer.slug === 'codex');
         const previousClaude = cached?.value.find((namer) => namer.slug === 'claude');
         const codexModels = codex.status === 'fulfilled' ? codex.value : previousCodex?.models ?? [];
@@ -179,6 +292,18 @@ async function refreshTitleNamerCatalog() {
                 models: claudeModels,
                 recommendedModel: recommendTitleModel(claudeModels),
             },
+            ...plugins.map((provider, index) => {
+                const result = pluginResults[index];
+                const previous = cached?.value.find((namer) => namer.slug === provider.slug);
+                const models = result?.status === 'fulfilled' ? result.value : previous?.models ?? [];
+                return {
+                    slug: provider.slug,
+                    displayName: provider.displayName,
+                    available: provider.config.models ? result?.status === 'fulfilled' || previous?.available === true : true,
+                    models,
+                    recommendedModel: recommendTitleModel(models),
+                };
+            }),
         ];
         cached = { version: 1, updatedAt: Date.now(), value };
         await savePersistentCache(cached).catch(() => undefined);
@@ -195,6 +320,10 @@ export async function getTitleNamerCatalog(force = false) {
         cached = await loadPersistentCache();
     if (!cached)
         return refreshTitleNamerCatalog();
+    const expectedSlugs = new Set(['codex', 'claude', ...pluginTitleNamers().map((provider) => provider.slug)]);
+    if (cached.value.length !== expectedSlugs.size || cached.value.some((entry) => !expectedSlugs.has(entry.slug))) {
+        return refreshTitleNamerCatalog();
+    }
     if (Date.now() - cached.updatedAt > CACHE_FRESH_MS) {
         // Stale-while-revalidate: callers get the last known catalog immediately.
         void refreshTitleNamerCatalog();

package/dist/server/agentHook.js

@@ -103,6 +103,47 @@ function ancestorTtyDevice() {
     }
     return null;
 }
+/**
+ * tmux passthrough is version/configuration sensitive and, more importantly,
+ * only works while tmux considers the escape sequence pane output. Termdock
+ * itself is an attached tmux client, so write the sentinel to that client's
+ * tty directly when possible. This also works for detached hook subprocesses
+ * whose own `/dev/tty` is unavailable.
+ */
+function tmuxClientTtyDevices() {
+    const pane = process.env.TMUX_PANE;
+    if (!process.env.TMUX || !pane)
+        return [];
+    try {
+        const output = execFileSync('tmux', ['list-clients', '-t', pane, '-F', '#{client_tty}\t#{client_pid}'], {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: 2000,
+        });
+        return [...new Set(output.split(/\r?\n/).flatMap((line) => {
+                const [device, pid] = line.trim().split('\t');
+                if (!/^\/dev\/(?:pts\/\d+|tty[^/]*)$/.test(device ?? ''))
+                    return [];
+                // On Linux the environment gives us an exact ownership marker. An
+                // ordinary `tmux attach` must not steal a Termdock sentinel merely
+                // because tmux listed that client first.
+                const environ = pid && /^\d+$/.test(pid) ? `/proc/${pid}/environ` : null;
+                if (environ && fs.existsSync(environ)) {
+                    try {
+                        if (!fs.readFileSync(environ).toString().split('\0').includes('TERMDOCK=1'))
+                            return [];
+                    }
+                    catch {
+                        return [];
+                    }
+                }
+                return [device];
+            }))];
+    }
+    catch {
+        return [];
+    }
+}
 /**
  * Write the sequence to the pane's PTY so the server sniffs it as pane output.
  * Two routes: /dev/tty (hook attached to its tty), or an ancestor's tty
@@ -116,6 +157,12 @@ function ancestorTtyDevice() {
  * the termdock server — as the plain inner OSC.
  */
 function writeToControllingTty(sequence, inTmuxPane) {
+    if (inTmuxPane) {
+        const clientTtys = tmuxClientTtyDevices();
+        if (clientTtys.length > 0) {
+            return clientTtys.some((device) => writeDev(device, sequence));
+        }
+    }
     // Only genuine tmux panes (TMUX_PANE is set by tmux itself) get the DCS
     // passthrough wrap; a bare inherited TMUX just means an ancestor ran tmux.
     const wire = inTmuxPane