termdock 1.4.69 → 1.4.71

package/dist/server/agent/titleNamerCatalog.js

@@ -0,0 +1,301 @@
+import { execFile, spawn } from 'child_process';
+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;
+    const doc = input;
+    if (doc.version !== 1 || typeof doc.updatedAt !== 'number' || !Array.isArray(doc.value))
+        return null;
+    const value = doc.value.flatMap((entry) => {
+        if (!entry || typeof entry !== 'object')
+            return [];
+        const candidate = entry;
+        if (typeof candidate.slug !== 'string' || !/^[a-z][a-z0-9-]{0,39}$/.test(candidate.slug))
+            return [];
+        if (!Array.isArray(candidate.models))
+            return [];
+        const models = candidate.models.filter((model) => Boolean(model
+            && typeof model.id === 'string'
+            && typeof model.displayName === 'string'
+            && typeof model.description === 'string'
+            && typeof model.isDefault === 'boolean'));
+        return [{
+                slug: candidate.slug,
+                displayName: typeof candidate.displayName === 'string' ? candidate.displayName : candidate.slug,
+                available: candidate.available === true,
+                models,
+                recommendedModel: typeof candidate.recommendedModel === 'string'
+                    ? candidate.recommendedModel
+                    : recommendTitleModel(models),
+            }];
+    });
+    return value.length > 0 ? { version: 1, updatedAt: doc.updatedAt, value } : null;
+}
+async function loadPersistentCache() {
+    try {
+        return normalizeCachedCatalog(JSON.parse(await fs.promises.readFile(CACHE_FILE, 'utf8')));
+    }
+    catch {
+        return null;
+    }
+}
+async function savePersistentCache(doc) {
+    const directory = path.dirname(CACHE_FILE);
+    const temporary = `${CACHE_FILE}.${process.pid}.tmp`;
+    await fs.promises.mkdir(directory, { recursive: true });
+    await fs.promises.writeFile(temporary, JSON.stringify(doc, null, 2), 'utf8');
+    await fs.promises.rename(temporary, CACHE_FILE);
+}
+export function recommendTitleModel(models) {
+    return models.find((model) => /affordable|cost[- ]efficient|cost[- ]sensitive/i.test(model.description))?.id
+        ?? models.find((model) => model.isDefault)?.id
+        ?? null;
+}
+async function listCodexModels() {
+    return new Promise((resolve, reject) => {
+        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 = (models, error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            child.kill();
+            if (error)
+                reject(error);
+            else
+                resolve(models ?? []);
+        };
+        const timer = setTimeout(() => finish(undefined, new Error('Codex model discovery timed out')), PROBE_TIMEOUT_MS);
+        timer.unref?.();
+        child.on('error', (error) => finish(undefined, error));
+        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: 'model/list', params: { limit: 100 } })}\n`);
+                }
+                else if (message.id === 2) {
+                    const data = message.result?.data;
+                    const models = Array.isArray(data) ? data.flatMap((entry) => {
+                        if (!entry || typeof entry !== 'object')
+                            return [];
+                        const model = entry;
+                        if (typeof model.model !== 'string' || typeof model.displayName !== 'string')
+                            return [];
+                        return [{
+                                id: model.model,
+                                displayName: model.displayName,
+                                description: typeof model.description === 'string' ? model.description : '',
+                                isDefault: model.isDefault === true,
+                            }];
+                    }) : [];
+                    finish(models);
+                }
+            }
+        });
+        child.stdin.write(`${JSON.stringify({
+            id: 1,
+            method: 'initialize',
+            params: { clientInfo: { name: 'termdock', version: '1' } },
+        })}\n`);
+    });
+}
+export function parseClaudeSupportedModels(output) {
+    const match = output.match(/supported (?:API )?model names are ([^\n]+?)(?:,?\s+but you passed|$)/i);
+    if (!match)
+        return [];
+    return match[1]
+        .split(/,|\band\b/i)
+        .map((model) => model.trim().replace(/^["'`]+|["'`]+$/g, ''))
+        .filter((model) => /^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,119}$/.test(model))
+        .map((model) => ({ id: model, displayName: model, description: '', isDefault: false }));
+}
+async function listClaudeModels() {
+    try {
+        await execFileAsync('claude', ['--model', '__termdock_model_probe__', '--no-session-persistence', '-p', 'x'], {
+            timeout: PROBE_TIMEOUT_MS,
+            maxBuffer: 128 * 1024,
+            env: { ...process.env, NO_COLOR: '1', TERM: 'dumb' },
+        });
+        return [];
+    }
+    catch (error) {
+        const candidate = error;
+        if (candidate.code === 'ENOENT')
+            throw error;
+        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 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 ?? [];
+        const claudeModels = claude.status === 'fulfilled' ? claude.value : previousClaude?.models ?? [];
+        const value = [
+            {
+                slug: 'codex',
+                displayName: 'Codex',
+                available: codex.status === 'fulfilled' || previousCodex?.available === true,
+                models: codexModels,
+                recommendedModel: recommendTitleModel(codexModels),
+            },
+            {
+                slug: 'claude',
+                displayName: 'Claude Code',
+                available: claude.status === 'fulfilled' || previousClaude?.available === true,
+                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);
+        return value;
+    })().finally(() => {
+        refreshPromise = null;
+    });
+    return refreshPromise;
+}
+export async function getTitleNamerCatalog(force = false) {
+    if (force)
+        return refreshTitleNamerCatalog();
+    if (!cached)
+        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();
+    }
+    return cached.value;
+}

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
@@ -145,6 +192,7 @@ function main() {
             args.shift();
         let agent = args[0] ?? '';
         const eventArg = args[1] ?? '';
+        const statusArg = args[2] ?? '';
         if (!agent || !eventArg)
             return;
         if (process.env[GROK_HOOK_ENV])
@@ -164,7 +212,7 @@ function main() {
         const event = effectiveEvent(agent, eventArg, input);
         if (!event)
             return;
-        writeToControllingTty(buildHookSequence(agent, event, input), inTmuxPane);
+        writeToControllingTty(buildHookSequence(agent, event, input, statusArg || undefined), inTmuxPane);
     }
     catch {
         // Never break the agent's flow.