termdock 1.4.70 → 1.4.71

package/dist/server/agent/installers.js

@@ -16,7 +16,7 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { execFile } from 'node:child_process';
+import { execFile, spawn } from 'node:child_process';
 import { agentBySlug, isPluginAgent } from './registry.js';
 import { loadPlugins, resolveHookTarget } from './plugins.js';
 export const HOOK_AGENTS = ['claude', 'codex', 'copilot', 'opencode', 'pi', 'grok', 'kimi'];
@@ -121,13 +121,14 @@ const CLAUDE_HOOK_EVENTS = [
     ['Stop', 'stop'],
     ['SessionEnd', 'session-end'],
 ];
-/** Codex's hook events (~/.codex/hooks.json, Claude-shaped). Codex is
- *  turn-level only: no Notification hook, and no SessionEnd — the pane's
- *  foreground detection clears the badge when Codex exits. */
+/** Codex's native hooks.json event vocabulary. */
 const CODEX_HOOK_EVENTS = [
     ['SessionStart', 'session-start'],
     ['UserPromptSubmit', 'prompt-submit'],
+    ['PermissionRequest', 'permission-request'],
+    ['PostToolUse', 'tool-complete'],
     ['Stop', 'stop'],
+    ['SessionEnd', 'session-end'],
 ];
 /**
  * Kimi Code's hook events (~/.kimi-code/config.toml `[[hooks]]` entries, TOML).
@@ -620,6 +621,73 @@ export function hooksState(agent) {
         return 'not-installed';
     return ownedFileState(file, expected, marker(agent));
 }
+let codexRuntimeStateCache = null;
+/** Query Codex's own hook registry: a structurally present hook can still be
+ * quarantined until the user approves its current hash in `/hooks`. */
+async function codexRuntimeHooksState() {
+    const structural = hooksState('codex');
+    if (structural !== 'installed')
+        return structural;
+    if (codexRuntimeStateCache && Date.now() - codexRuntimeStateCache.at < 30_000) {
+        return codexRuntimeStateCache.state;
+    }
+    const state = await new Promise((resolve) => {
+        const child = spawn('codex', ['app-server', '--stdio'], {
+            stdio: ['pipe', 'pipe', 'ignore'],
+            env: { ...process.env, NO_COLOR: '1', TERM: 'dumb' },
+        });
+        let buffer = '';
+        let settled = false;
+        const finish = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            child.kill();
+            resolve(value);
+        };
+        const timer = setTimeout(() => finish(structural), 5_000);
+        timer.unref?.();
+        child.on('error', () => finish(structural));
+        child.stdout.on('data', (chunk) => {
+            buffer += chunk.toString();
+            for (;;) {
+                const newline = buffer.indexOf('\n');
+                if (newline < 0)
+                    break;
+                const line = buffer.slice(0, newline).trim();
+                buffer = buffer.slice(newline + 1);
+                if (!line)
+                    continue;
+                let message;
+                try {
+                    message = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (message.id === 1) {
+                    child.stdin.write(`${JSON.stringify({ method: 'initialized', params: {} })}\n`);
+                    child.stdin.write(`${JSON.stringify({ id: 2, method: 'hooks/list', params: { cwds: [process.cwd()] } })}\n`);
+                }
+                else if (message.id === 2) {
+                    const ours = (message.result?.data ?? [])
+                        .flatMap((entry) => entry.hooks ?? [])
+                        .filter((hook) => typeof hook.command === 'string' && hook.command.includes(marker('codex')));
+                    if (ours.length < CODEX_HOOK_EVENTS.length)
+                        finish('outdated');
+                    else if (ours.some((hook) => hook.enabled === false || !['trusted', 'managed'].includes(hook.trustStatus ?? '')))
+                        finish('needs-approval');
+                    else
+                        finish('installed');
+                }
+            }
+        });
+        child.stdin.write(`${JSON.stringify({ id: 1, method: 'initialize', params: { clientInfo: { name: 'termdock', version: '1' } } })}\n`);
+    });
+    codexRuntimeStateCache = { at: Date.now(), state };
+    return state;
+}
 export function listHookAgents() {
     return HOOK_AGENTS.map((slug) => ({
         slug,
@@ -641,9 +709,10 @@ export async function installHooks(agent) {
     }
     if (agent === 'codex') {
         hookMapInstall(file, agent, CODEX_HOOK_EVENTS);
+        codexRuntimeStateCache = null;
         try {
             await enableCodexHooksFeature();
-            return { summary: 'Installed', devMode };
+            return { summary: 'Installed — open /hooks in Codex and approve any new Termdock hooks', devMode };
         }
         catch (error) {
             return {
@@ -668,6 +737,8 @@ export async function installHooks(agent) {
 export async function uninstallHooks(agent) {
     const file = targetPath(agent);
     if (agent === 'claude' || agent === 'codex') {
+        if (agent === 'codex')
+            codexRuntimeStateCache = null;
         return hookMapUninstall(file, agent);
     }
     if (agent === 'kimi') {
@@ -700,7 +771,7 @@ function hookCommandForPlugin(slug, event, status) {
  * List all agents with hook support — both built-in and plugin-defined.
  * Plugin agents appear after built-in agents.
  */
-export function listAllHookAgents() {
+export async function listAllHookAgents() {
     const builtIn = HOOK_AGENTS.map((slug) => {
         const agent = agentBySlug(slug);
         return {
@@ -727,6 +798,9 @@ export function listAllHookAgents() {
             iconVersion: agent?.iconVersion ?? null,
         };
     });
+    const codex = builtIn.find((entry) => entry.slug === 'codex');
+    if (codex)
+        codex.state = await codexRuntimeHooksState();
     return [...builtIn, ...pluginAgents];
 }
 export function hooksStateForSlug(slug) {
@@ -763,7 +837,7 @@ export async function uninstallHooksForSlug(slug) {
 // Generic hookmap logic (shared with built-in Claude/Codex + all plugins)
 // ---------------------------------------------------------------------------
 /** Generic state check for a hookmap-style hooks file. */
-function pluginHooksState(slug, file, events) {
+export function pluginHooksState(slug, file, events) {
     const root = readJsonObject(file);
     if (!root)
         return 'not-installed';
@@ -771,16 +845,22 @@ function pluginHooksState(slug, file, events) {
     const hooks = root.hooks;
     let any = false;
     let complete = true;
-    for (const [hookEvent, sentinel, , , status] of events) {
+    for (const [hookEvent, sentinel, matcher, timeout, status] of events) {
         const list = hooks && typeof hooks === 'object'
             ? hooks[hookEvent]
             : null;
         const ours = Array.isArray(list)
-            ? list.map((entry) => markerCommand(entry, mark)).find((c) => c !== null) ?? null
-            : null;
-        if (ours !== null) {
+            ? list.find((entry) => markerCommand(entry, mark) !== null)
+            : undefined;
+        if (ours !== undefined) {
             any = true;
-            if (ours !== hookCommandForPlugin(slug, sentinel, status))
+            const group = ours && typeof ours === 'object' ? ours : {};
+            const handler = Array.isArray(group.hooks) && group.hooks[0] && typeof group.hooks[0] === 'object'
+                ? group.hooks[0]
+                : {};
+            if (handler.command !== hookCommandForPlugin(slug, sentinel, status)
+                || (matcher ?? undefined) !== group.matcher
+                || (timeout ?? undefined) !== handler.timeout)
                 complete = false;
         }
         else {
@@ -792,7 +872,7 @@ function pluginHooksState(slug, file, events) {
     return complete ? 'installed' : 'outdated';
 }
 /** Generic install for a hookmap-style hooks file. */
-function installPluginHooks(slug, file, events) {
+export function installPluginHooks(slug, file, events) {
     const { devMode } = resolveHookScript();
     let root = {};
     try {
@@ -815,7 +895,7 @@ function installPluginHooks(slug, file, events) {
     }
     const hooks = root.hooks;
     const mark = marker(slug);
-    for (const [hookEvent, sentinel, matcher, , status] of events) {
+    for (const [hookEvent, sentinel, matcher, timeout, status] of events) {
         const command = hookCommandForPlugin(slug, sentinel, status);
         let list = hooks[hookEvent];
         if (list === undefined) {
@@ -825,7 +905,10 @@ function installPluginHooks(slug, file, events) {
         if (!Array.isArray(list))
             continue;
         const kept = list.filter((entry) => markerCommand(entry, mark) === null);
-        const entry = { hooks: [{ type: 'command', command }] };
+        const handler = { type: 'command', command };
+        if (timeout !== undefined)
+            handler.timeout = timeout;
+        const entry = { hooks: [handler] };
         if (matcher)
             entry.matcher = matcher;
         kept.push(entry);

package/dist/server/agent/plugins.js

@@ -236,6 +236,50 @@ 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) {
+                errors.push('titleNamer.command is required');
+            }
+            if (!Array.isArray(args) || !args.every((arg) => typeof arg === 'string') || !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) {
+                        errors.push('titleNamer.models.command is required');
+                    }
+                    if (rawModels.args !== undefined && (!Array.isArray(rawModels.args) || !rawModels.args.every((arg) => typeof arg === 'string'))) {
+                        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 +303,7 @@ export function validateManifest(raw, dir) {
             statuses,
             hooks,
             resume: resumeConfig,
+            titleNamer,
         },
     };
 }

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,16 @@ import fs from 'fs';
 import os from 'os';
 import path from 'path';
 import { promisify } from 'util';
+import { loadPlugins } from './plugins.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');
 let cached = null;
 let refreshPromise = null;
+export function invalidateTitleNamerCatalog() {
+    cached = null;
+}
 function normalizeCachedCatalog(input) {
     if (!input || typeof input !== 'object')
         return null;
@@ -19,7 +23,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 +159,89 @@ 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,
+            }];
+    });
+}
+async function listPluginModels(config) {
+    if (!config.models)
+        return [];
+    const { stdout } = await execFileAsync(config.models.command, config.models.args ?? [], {
+        timeout: PROBE_TIMEOUT_MS,
+        maxBuffer: 256 * 1024,
+        env: { ...process.env, NO_COLOR: '1', TERM: 'dumb' },
+    });
+    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,
+            }]
+        : []);
+}
+export async function runTitleNamer(slug, prompt, model) {
+    let command;
+    let args;
+    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)
+            return null;
+        command = provider.config.command;
+        args = provider.config.args.flatMap((arg) => {
+            if (arg.includes('{model}') && !model)
+                return [];
+            return [arg.replaceAll('{prompt}', prompt).replaceAll('{model}', model ?? '')];
+        });
+    }
+    try {
+        const { stdout } = await execFileAsync(command, args, {
+            timeout: 45_000,
+            maxBuffer: 256 * 1024,
+            env: { ...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) => listPluginModels(provider.config)),
+        ]);
         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 +261,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 +289,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

package/dist/server/cli.js

@@ -1725,6 +1725,14 @@ const AGENT_PLUGIN_EXAMPLE = {
         command: 'my-agent --resume {sessionId}',
         staleFlags: ['--resume'],
     },
+    titleNamer: {
+        command: 'my-agent',
+        args: ['title', '--json', '--prompt', '{prompt}', '--model={model}'],
+        models: {
+            command: 'my-agent',
+            args: ['models', '--json'],
+        },
+    },
 };
 function runPluginInitJson() {
     console.log(JSON.stringify({
@@ -1770,6 +1778,8 @@ function runPluginInitJson() {
             'Run td plugin-create <manifest-file>; the Agent appears in Termdock immediately.',
             'Ask the user to open Settings > Detection Rules and click Install for this Agent. They can uninstall it there later.',
             'If the Agent hook format is not a Claude-style hooks map, configure native hooks to call td agent-event directly.',
+            'Map the completed-turn hook to event "stop"; this is also the automatic-title trigger when the user enables titles for the Agent.',
+            'Optionally declare titleNamer so this Agent can generate titles and dynamically publish its own model catalog.',
             'Run td plugin-list to verify registration.',
         ],
         manifest: AGENT_PLUGIN_EXAMPLE,
@@ -1874,6 +1884,15 @@ ${c.dim('───────────────────')}
     "command": "trae --resume {sessionId}",
     ${c.dim('// Flags to strip from the original launch argv when replaying the resume.')}
     "staleFlags": ["--resume", "-r", "--session-id", "--continue"]
+  },
+
+  ${c.dim('// ── optional: injectable automatic-title provider ──')}
+  "titleNamer": {
+    ${c.dim('// No shell expansion. {prompt} is required; a bare {model} arg is omitted when automatic.')}
+    "command": "trae",
+    "args": ["title", "--prompt", "{prompt}", "--model={model}"],
+    ${c.dim('// Must print JSON: strings or {id, displayName, description, isDefault} objects.')}
+    "models": { "command": "trae", "args": ["models", "--json"] }
   }
 }
 
@@ -1887,6 +1906,7 @@ ${c.dim('─────────────────────')}
   tool-complete           A tool execution completed (unblocks waiting state)
   notification            Generic notification from the agent (heuristic gated)
   stop                    Agent turn finished / went idle
+                          Also triggers automatic title generation when enabled
   session-end             Agent session closed / binary exited
 
 ${c.bold('Creating a plugin')}