termdock 1.4.69 → 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') {
@@ -681,7 +752,7 @@ function pluginHookEntries() {
     return plugins
         .filter((p) => p.manifest.hooks && p.manifest.hooks.events.length > 0)
         .map((p) => {
-        const events = p.manifest.hooks.events.map((e) => [e.hook, e.event, e.matcher ?? null, e.timeout]);
+        const events = p.manifest.hooks.events.map((e) => [e.hook, e.event, e.matcher ?? null, e.timeout, e.status]);
         return {
             slug: p.manifest.slug,
             displayName: p.manifest.displayName,
@@ -691,15 +762,16 @@ function pluginHookEntries() {
     });
 }
 /** Hook command for a plugin agent. Uses the same emitter script but with the plugin slug. */
-function hookCommandForPlugin(slug, event) {
+function hookCommandForPlugin(slug, event, status) {
     const { script } = resolveHookScript();
-    return `"${process.execPath}" "${script}" agent-hook ${slug} ${event}`;
+    const statusArg = status ? ` ${status}` : '';
+    return `"${process.execPath}" "${script}" agent-hook ${slug} ${event}${statusArg}`;
 }
 /**
  * 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 {
@@ -719,13 +791,16 @@ export function listAllHookAgents() {
             slug: entry.slug,
             displayName: entry.displayName,
             targetDisplay: abbreviateHome(entry.targetPath),
-            state: pluginHooksState(entry.slug, entry.targetPath, entry.events.map(([h, s]) => [h, s])),
+            state: pluginHooksState(entry.slug, entry.targetPath, entry.events),
             accentColor: agent?.accentColor ?? '#878580',
             icon: agent?.icon ?? null,
             iconMode: agent?.iconMode ?? null,
             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) {
@@ -734,7 +809,7 @@ export function hooksStateForSlug(slug) {
         const entry = entries.find((e) => e.slug === slug);
         if (!entry)
             return 'not-installed';
-        return pluginHooksState(slug, entry.targetPath, entry.events.map(([h, s]) => [h, s]));
+        return pluginHooksState(slug, entry.targetPath, entry.events);
     }
     return hooksState(slug);
 }
@@ -762,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';
@@ -770,16 +845,22 @@ function pluginHooksState(slug, file, events) {
     const hooks = root.hooks;
     let any = false;
     let complete = true;
-    for (const [hookEvent, sentinel] 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))
+            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 {
@@ -791,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 {
@@ -814,8 +895,8 @@ function installPluginHooks(slug, file, events) {
     }
     const hooks = root.hooks;
     const mark = marker(slug);
-    for (const [hookEvent, sentinel, matcher] of events) {
-        const command = hookCommandForPlugin(slug, sentinel);
+    for (const [hookEvent, sentinel, matcher, timeout, status] of events) {
+        const command = hookCommandForPlugin(slug, sentinel, status);
         let list = hooks[hookEvent];
         if (list === undefined) {
             list = [];
@@ -824,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);
@@ -882,7 +966,7 @@ export function refreshStaleHooksAtLaunch() {
     }
     // Plugin agents
     for (const entry of pluginHookEntries()) {
-        const state = pluginHooksState(entry.slug, entry.targetPath, entry.events.map(([h, s]) => [h, s]));
+        const state = pluginHooksState(entry.slug, entry.targetPath, entry.events);
         if (state !== 'outdated')
             continue;
         try {

package/dist/server/agent/plugins.js

@@ -19,7 +19,7 @@ const ICON_FILE = 'icon.svg';
 // ---------------------------------------------------------------------------
 // Manifest schema
 // ---------------------------------------------------------------------------
-export const PLUGIN_MANIFEST_VERSION = 1;
+export const PLUGIN_MANIFEST_VERSION = 2;
 // ---------------------------------------------------------------------------
 // Known sentinel event kinds — the set of events our state machine accepts
 // ---------------------------------------------------------------------------
@@ -33,6 +33,10 @@ const VALID_EVENT_KINDS = new Set([
     'stop',
     'session-end',
 ]);
+const VALID_STATUS_PHASES = new Set(['idle', 'working', 'waiting', 'done']);
+const VALID_STATUS_INDICATORS = new Set(['spinner', 'pulse', 'dot', 'ring', 'badge', 'terminal', 'question']);
+const VALID_STATUS_TONES = new Set(['neutral', 'info', 'success', 'warning', 'danger', 'accent']);
+const STATUS_ID_RE = /^[a-z][a-z0-9-]{0,39}$/;
 // ---------------------------------------------------------------------------
 // Slug validation (alphanumeric + hyphens, non-empty)
 // ---------------------------------------------------------------------------
@@ -53,14 +57,28 @@ function resolveHome(p) {
     }
     return p;
 }
-function validateManifest(raw, dir) {
+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.',
+    'Preserve slug, displayName, aliases, accentColor, iconMode, hooks.target, and resume.',
+    'Add statuses[] entries with id, phase (idle|working|waiting|done), label, indicator, and tone.',
+    'Add a status reference to each relevant hooks.events[] mapping while keeping its core event value.',
+    `Use the output of \`${V1_MIGRATION_GUIDE_COMMAND}\` as the authoritative schema.`,
+    'Return only the corrected manifest JSON.',
+].join(' ');
+export function validateManifest(raw, dir) {
     const errors = [];
     if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
         return { error: { slug: path.basename(dir), errors: ['manifest.json is not a JSON object'] } };
     }
     const m = raw;
     const version = m.version;
-    if (typeof version !== 'number' || version !== PLUGIN_MANIFEST_VERSION) {
+    const isV1 = version === 1;
+    if (isV1) {
+        errors.push('manifest v1 is no longer supported; migrate this plugin to manifest v2');
+        errors.push(`read the current machine-readable schema with: ${V1_MIGRATION_GUIDE_COMMAND}`);
+    }
+    else if (typeof version !== 'number' || version !== PLUGIN_MANIFEST_VERSION) {
         errors.push(`version must be ${PLUGIN_MANIFEST_VERSION}`);
     }
     const slug = m.slug;
@@ -84,6 +102,59 @@ function validateManifest(raw, dir) {
     if (iconMode !== undefined && iconMode !== 'mask' && iconMode !== 'native') {
         errors.push('iconMode must be "mask" or "native" if provided');
     }
+    // Optional plugin-defined status vocabulary. These decorate the stable
+    // idle/working/waiting/done phases instead of replacing their semantics.
+    let statuses;
+    const statusIds = new Set();
+    if (m.statuses !== undefined) {
+        if (!Array.isArray(m.statuses) || m.statuses.length === 0) {
+            errors.push('statuses must be a non-empty array if present');
+        }
+        else {
+            const validStatuses = [];
+            for (let i = 0; i < m.statuses.length; i++) {
+                const rawStatus = m.statuses[i];
+                if (!rawStatus || typeof rawStatus !== 'object' || Array.isArray(rawStatus)) {
+                    errors.push(`statuses[${i}] is not an object`);
+                    continue;
+                }
+                const status = rawStatus;
+                const id = status.id;
+                const phase = status.phase;
+                const label = status.label;
+                const indicator = status.indicator;
+                const tone = status.tone;
+                if (typeof id !== 'string' || !STATUS_ID_RE.test(id)) {
+                    errors.push(`statuses[${i}].id must be lowercase alphanumeric with hyphens (max 40 chars)`);
+                    continue;
+                }
+                if (statusIds.has(id))
+                    errors.push(`statuses[${i}].id duplicates "${id}"`);
+                statusIds.add(id);
+                if (typeof phase !== 'string' || !VALID_STATUS_PHASES.has(phase)) {
+                    errors.push(`statuses[${i}].phase must be one of: ${[...VALID_STATUS_PHASES].join(', ')}`);
+                }
+                if (typeof label !== 'string' || label.trim().length === 0 || label.length > 80) {
+                    errors.push(`statuses[${i}].label must be a non-empty string (max 80 chars)`);
+                }
+                if (indicator !== undefined && (typeof indicator !== 'string' || !VALID_STATUS_INDICATORS.has(indicator))) {
+                    errors.push(`statuses[${i}].indicator must be one of: ${[...VALID_STATUS_INDICATORS].join(', ')}`);
+                }
+                if (tone !== undefined && (typeof tone !== 'string' || !VALID_STATUS_TONES.has(tone))) {
+                    errors.push(`statuses[${i}].tone must be one of: ${[...VALID_STATUS_TONES].join(', ')}`);
+                }
+                validStatuses.push({
+                    id,
+                    phase: phase,
+                    label: typeof label === 'string' ? label.trim() : '',
+                    indicator: indicator,
+                    tone: tone,
+                });
+            }
+            if (validStatuses.length > 0)
+                statuses = validStatuses;
+        }
+    }
     // Optional hooks
     let hooks;
     if (m.hooks !== undefined) {
@@ -125,11 +196,16 @@ function validateManifest(raw, dir) {
                     if (timeout !== undefined && (typeof timeout !== 'number' || timeout <= 0)) {
                         errors.push(`hooks.events[${i}].timeout must be a positive number if provided`);
                     }
+                    const status = evt.status;
+                    if (status !== undefined && (typeof status !== 'string' || !statusIds.has(status))) {
+                        errors.push(`hooks.events[${i}].status must reference a declared statuses[].id`);
+                    }
                     validEvents.push({
                         hook: hook,
                         event: event,
                         matcher: typeof matcher === 'string' ? matcher : undefined,
                         timeout: typeof timeout === 'number' ? timeout : undefined,
+                        status: typeof status === 'string' ? status : undefined,
                     });
                 }
                 if (validEvents.length > 0) {
@@ -160,8 +236,61 @@ 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: { slug: typeof slug === 'string' ? slug : path.basename(dir), errors } };
+        return {
+            error: {
+                slug: typeof slug === 'string' ? slug : path.basename(dir),
+                errors,
+                code: isV1 ? 'AGENT_PLUGIN_MANIFEST_V1_UNSUPPORTED' : undefined,
+                migration: isV1
+                    ? { guideCommand: V1_MIGRATION_GUIDE_COMMAND, aiPrompt: V1_MIGRATION_AI_PROMPT }
+                    : undefined,
+            },
+        };
     }
     return {
         manifest: {
@@ -171,8 +300,10 @@ function validateManifest(raw, dir) {
             aliases: aliases.map((a) => a.trim().toLowerCase()),
             accentColor: accentColor,
             iconMode: iconMode,
+            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;
@@ -278,6 +278,7 @@ export function registerPluginAgents(plugins) {
             isPlugin: true,
             iconMode: manifest.iconMode,
             iconVersion: p.iconMtime || undefined,
+            statuses: manifest.statuses,
         };
         BY_SLUG.set(info.slug, info);
         for (const alias of info.aliases)

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',
@@ -27,6 +34,7 @@ export function defaultAgentSessionState() {
         agentCwd: null,
         activity: 0,
         reviewed: true,
+        presentation: null,
     };
 }
 /**
@@ -39,6 +47,9 @@ export function applyAgentEvent(state, ev) {
         state.sessionId = ev.sessionId;
     if (ev.cwd)
         state.agentCwd = ev.cwd;
+    // A custom state is scoped to one hook edge; never let it leak into the
+    // next core lifecycle event that did not explicitly declare it.
+    state.presentation = null;
     switch (ev.kind) {
         case 'session-start':
             state.status = 'idle';
@@ -100,6 +111,10 @@ export function applyAgentEvent(state, ev) {
             state.agentCwd = null;
             break;
     }
+    if (ev.status) {
+        state.status = ev.status.phase;
+        state.presentation = ev.status;
+    }
 }
 function nonEmpty(s) {
     return typeof s === 'string' && s.trim().length > 0 ? s : null;
@@ -132,12 +147,20 @@ export function parseAgentEvent(payload) {
     const eventName = nonEmpty(w.event);
     if (!eventName || !EVENT_KINDS.has(eventName))
         return null;
+    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: agentBySlug(nonEmpty(w.agent)),
+        agent,
+        agentSlug,
         kind: eventName,
         sessionId: nonEmpty(w.session_id),
         message: nonEmpty(w.message),
         cwd: nonEmpty(w.cwd),
+        status,
     };
 }
 /**
@@ -146,7 +169,7 @@ export function parseAgentEvent(payload) {
  * `payloadJson` is the hook's raw stdin JSON from the agent; fields are lifted
  * into the sentinel body (snake_case, with camelCase aliases for Grok).
  */
-export function buildHookSequence(agent, event, stdinJson) {
+export function buildHookSequence(agent, event, stdinJson, statusId) {
     let payload = {};
     try {
         const parsed = JSON.parse(stdinJson);
@@ -159,6 +182,8 @@ export function buildHookSequence(agent, event, stdinJson) {
         agent,
         event,
     };
+    if (statusId)
+        body.status = statusId;
     for (const [key, alias] of [['session_id', 'sessionId'], ['message', 'message'], ['cwd', 'cwd']]) {
         const v = nonEmpty(payload[key]) ?? nonEmpty(payload[alias]);
         if (v)