termdock 1.4.68 → 1.4.70

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) {
@@ -161,7 +237,16 @@ function validateManifest(raw, dir) {
         }
     }
     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,6 +256,7 @@ function validateManifest(raw, dir) {
             aliases: aliases.map((a) => a.trim().toLowerCase()),
             accentColor: accentColor,
             iconMode: iconMode,
+            statuses,
             hooks,
             resume: resumeConfig,
         },

package/dist/server/agent/registry.js

@@ -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

@@ -27,6 +27,7 @@ export function defaultAgentSessionState() {
         agentCwd: null,
         activity: 0,
         reviewed: true,
+        presentation: null,
     };
 }
 /**
@@ -39,6 +40,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 +104,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 +140,18 @@ export function parseAgentEvent(payload) {
     const eventName = nonEmpty(w.event);
     if (!eventName || !EVENT_KINDS.has(eventName))
         return null;
+    const agent = agentBySlug(nonEmpty(w.agent));
+    const statusId = nonEmpty(w.status);
+    const status = statusId
+        ? agent?.statuses?.find((definition) => definition.id === statusId) ?? null
+        : null;
     return {
-        agent: agentBySlug(nonEmpty(w.agent)),
+        agent,
         kind: eventName,
         sessionId: nonEmpty(w.session_id),
         message: nonEmpty(w.message),
         cwd: nonEmpty(w.cwd),
+        status,
     };
 }
 /**
@@ -146,7 +160,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 +173,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)

package/dist/server/agent/titleNamerCatalog.js

@@ -0,0 +1,203 @@
+import { execFile, spawn } from 'child_process';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { promisify } from 'util';
+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;
+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 (candidate.slug !== 'codex' && candidate.slug !== 'claude')
+            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 ?? ''}`);
+    }
+}
+async function refreshTitleNamerCatalog() {
+    if (refreshPromise)
+        return refreshPromise;
+    refreshPromise = (async () => {
+        const [codex, claude] = await Promise.allSettled([listCodexModels(), listClaudeModels()]);
+        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),
+            },
+        ];
+        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();
+    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

@@ -145,6 +145,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 +165,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.