termdock 1.4.70 → 1.4.72

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/pluginPackages.js

@@ -0,0 +1,289 @@
+import { execFile } from 'node:child_process';
+import { createHash, randomUUID } from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { ICON_FILE, MANIFEST_FILE, PLUGINS_DIR, SOURCE_METADATA_FILE, validateManifest, writePluginSourceMetadata, } from './plugins.js';
+const execFileAsync = promisify(execFile);
+const MAX_PACKAGE_FILES = 512;
+const MAX_PACKAGE_BYTES = 16 * 1024 * 1024;
+const MAX_SINGLE_FILE_BYTES = 8 * 1024 * 1024;
+const GIT_TIMEOUT_MS = 45_000;
+const IGNORED_NAMES = new Set(['.git', '.github', 'node_modules', SOURCE_METADATA_FILE]);
+const DEFAULT_GIT_HOSTS = new Set(['github.com', 'gitlab.com', 'codeberg.org', 'bitbucket.org']);
+function hardenedGitEnv() {
+    return {
+        ...process.env,
+        GIT_TERMINAL_PROMPT: '0',
+        GIT_CONFIG_COUNT: '0',
+        GIT_CONFIG_GLOBAL: '/dev/null',
+        GIT_CONFIG_SYSTEM: '/dev/null',
+    };
+}
+function allowedGitHosts() {
+    const configured = (process.env.TERMDOCK_PLUGIN_GIT_HOSTS ?? '')
+        .split(',')
+        .map((host) => host.trim().toLowerCase())
+        .filter(Boolean);
+    return new Set([...DEFAULT_GIT_HOSTS, ...configured]);
+}
+export function normalizeGitPluginSource(input) {
+    let url;
+    try {
+        url = new URL(input.trim());
+    }
+    catch {
+        return null;
+    }
+    if (url.protocol !== 'https:' || url.username || url.password || url.search || url.hash)
+        return null;
+    if (!allowedGitHosts().has(url.hostname.toLowerCase()))
+        return null;
+    if (!/^\/[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+(?:\.git)?\/?$/.test(url.pathname))
+        return null;
+    url.pathname = url.pathname.replace(/\/$/, '');
+    return url.toString();
+}
+async function packageTreeDigest(root) {
+    const hash = createHash('sha256');
+    let files = 0;
+    let bytes = 0;
+    async function visit(directory, relative = '') {
+        const entries = await fs.promises.readdir(directory, { withFileTypes: true });
+        entries.sort((a, b) => a.name.localeCompare(b.name));
+        for (const entry of entries) {
+            if (IGNORED_NAMES.has(entry.name))
+                continue;
+            if (entry.isSymbolicLink())
+                throw new Error(`Plugin packages may not contain symbolic links: ${path.join(relative, entry.name)}`);
+            const absolute = path.join(directory, entry.name);
+            const nextRelative = path.join(relative, entry.name);
+            if (entry.isDirectory()) {
+                await visit(absolute, nextRelative);
+                continue;
+            }
+            if (!entry.isFile())
+                throw new Error(`Unsupported plugin package entry: ${nextRelative}`);
+            const stat = await fs.promises.stat(absolute);
+            files += 1;
+            bytes += stat.size;
+            if (files > MAX_PACKAGE_FILES)
+                throw new Error(`Plugin package exceeds ${MAX_PACKAGE_FILES} files`);
+            if (stat.size > MAX_SINGLE_FILE_BYTES)
+                throw new Error(`Plugin file is too large: ${nextRelative}`);
+            if (bytes > MAX_PACKAGE_BYTES)
+                throw new Error('Plugin package exceeds the 16 MB unpacked limit');
+            hash.update(nextRelative.replaceAll(path.sep, '/'));
+            hash.update('\0');
+            hash.update(await fs.promises.readFile(absolute));
+            hash.update('\0');
+        }
+    }
+    await visit(root);
+    return hash.digest('hex');
+}
+async function copyPackageTree(source, destination) {
+    await packageTreeDigest(source); // validates limits and symlinks before any destination write
+    await fs.promises.mkdir(destination, { recursive: true });
+    async function copy(directory, output) {
+        const entries = await fs.promises.readdir(directory, { withFileTypes: true });
+        for (const entry of entries) {
+            if (IGNORED_NAMES.has(entry.name))
+                continue;
+            const from = path.join(directory, entry.name);
+            const to = path.join(output, entry.name);
+            if (entry.isDirectory()) {
+                await fs.promises.mkdir(to, { recursive: true });
+                await copy(from, to);
+            }
+            else {
+                await fs.promises.copyFile(from, to);
+                const stat = await fs.promises.stat(from);
+                await fs.promises.chmod(to, stat.mode & 0o777);
+            }
+        }
+    }
+    await copy(source, destination);
+}
+function validateIcon(packageDir) {
+    const iconPath = path.join(packageDir, ICON_FILE);
+    if (!fs.existsSync(iconPath))
+        return;
+    const svg = fs.readFileSync(iconPath, 'utf8');
+    if (!/^\s*<svg\b/i.test(svg))
+        throw new Error('icon.svg must contain an SVG document');
+    if (/<(?: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)) {
+        throw new Error('icon.svg contains unsafe active content');
+    }
+}
+async function readAndValidateManifest(packageDir, expectedSlug) {
+    const manifestPath = path.join(packageDir, MANIFEST_FILE);
+    let raw;
+    try {
+        raw = JSON.parse(await fs.promises.readFile(manifestPath, 'utf8'));
+    }
+    catch (error) {
+        throw new Error(`Plugin package must contain a valid root manifest.json: ${error.message}`);
+    }
+    const validation = validateManifest(raw, packageDir);
+    if ('error' in validation) {
+        const error = new Error(validation.error.errors.join('\n'));
+        error.code = validation.error.code ?? 'AGENT_PLUGIN_MANIFEST_INVALID';
+        error.migration = validation.error.migration;
+        throw error;
+    }
+    if (expectedSlug && validation.manifest.slug !== expectedSlug) {
+        throw new Error(`Update source declares slug "${validation.manifest.slug}"; expected "${expectedSlug}"`);
+    }
+    validateIcon(packageDir);
+    return validation.manifest;
+}
+export async function preparePluginPackage(sourceInput, expectedSlug) {
+    const source = sourceInput.trim();
+    if (!source)
+        throw new Error('Plugin source is required');
+    const remote = normalizeGitPluginSource(source);
+    const temporaryRoot = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'termdock-plugin-'));
+    let packageDir;
+    let type;
+    let normalizedSource;
+    let revision;
+    try {
+        if (remote) {
+            packageDir = path.join(temporaryRoot, 'repo');
+            await execFileAsync('git', [
+                '-c', 'credential.helper=',
+                '-c', 'core.hooksPath=/dev/null',
+                '-c', 'filter.lfs.smudge=',
+                '-c', 'filter.lfs.required=false',
+                'clone', '--depth', '1', '--single-branch', '--no-recurse-submodules', '--', remote, packageDir,
+            ], {
+                timeout: GIT_TIMEOUT_MS,
+                maxBuffer: 1024 * 1024,
+                env: hardenedGitEnv(),
+            });
+            const result = await execFileAsync('git', ['-C', packageDir, 'rev-parse', 'HEAD'], {
+                timeout: 5000,
+                maxBuffer: 128 * 1024,
+            });
+            revision = result.stdout.trim();
+            type = 'git';
+            normalizedSource = remote;
+        }
+        else {
+            const resolved = path.resolve(source);
+            const stat = await fs.promises.stat(resolved).catch(() => null);
+            if (!stat)
+                throw new Error('Plugin source must be an existing local path or an allowed HTTPS Git repository');
+            packageDir = stat.isDirectory() ? resolved : path.dirname(resolved);
+            if (!stat.isDirectory() && path.basename(resolved) !== MANIFEST_FILE) {
+                throw new Error('A local plugin file must be named manifest.json');
+            }
+            type = 'local';
+            normalizedSource = packageDir;
+            revision = await packageTreeDigest(packageDir);
+        }
+        const manifest = await readAndValidateManifest(packageDir, expectedSlug);
+        const previous = expectedSlug
+            ? (() => {
+                try {
+                    return JSON.parse(fs.readFileSync(path.join(PLUGINS_DIR, expectedSlug, SOURCE_METADATA_FILE), 'utf8'));
+                }
+                catch {
+                    return null;
+                }
+            })()
+            : null;
+        const now = Date.now();
+        return {
+            manifest,
+            packageDir,
+            metadata: {
+                version: 1,
+                type,
+                source: normalizedSource,
+                revision,
+                latestRevision: revision,
+                installedAt: typeof previous?.installedAt === 'number' ? previous.installedAt : now,
+                updatedAt: now,
+                checkedAt: now,
+            },
+            cleanup: () => fs.promises.rm(temporaryRoot, { recursive: true, force: true }),
+        };
+    }
+    catch (error) {
+        await fs.promises.rm(temporaryRoot, { recursive: true, force: true });
+        throw error;
+    }
+}
+export async function commitPreparedPlugin(prepared, replace = false) {
+    await fs.promises.mkdir(PLUGINS_DIR, { recursive: true });
+    const target = path.join(PLUGINS_DIR, prepared.manifest.slug);
+    if (!replace && fs.existsSync(target))
+        throw new Error(`Plugin "${prepared.manifest.slug}" already exists`);
+    const stage = path.join(PLUGINS_DIR, `.stage-${prepared.manifest.slug}-${randomUUID()}`);
+    const backup = path.join(PLUGINS_DIR, `.backup-${prepared.manifest.slug}-${randomUUID()}`);
+    try {
+        await copyPackageTree(prepared.packageDir, stage);
+        await fs.promises.writeFile(path.join(stage, MANIFEST_FILE), JSON.stringify(prepared.manifest, null, 2), 'utf8');
+        writePluginSourceMetadata(stage, prepared.metadata);
+        if (fs.existsSync(target))
+            await fs.promises.rename(target, backup);
+        try {
+            await fs.promises.rename(stage, target);
+        }
+        catch (error) {
+            if (fs.existsSync(backup))
+                await fs.promises.rename(backup, target);
+            throw error;
+        }
+        await fs.promises.rm(backup, { recursive: true, force: true });
+        return target;
+    }
+    finally {
+        await fs.promises.rm(stage, { recursive: true, force: true });
+        await prepared.cleanup();
+    }
+}
+export async function checkPluginPackageUpdate(plugin) {
+    const checkedAt = Date.now();
+    const metadata = plugin.source;
+    if (!metadata?.source || metadata.type === 'manifest') {
+        return { supported: false, updateAvailable: false, revision: metadata?.revision ?? null, latestRevision: null, checkedAt };
+    }
+    let latestRevision;
+    if (metadata.type === 'git') {
+        const remote = normalizeGitPluginSource(metadata.source);
+        if (!remote)
+            throw new Error('The stored Git source is no longer allowed');
+        const { stdout } = await execFileAsync('git', [
+            '-c', 'credential.helper=',
+            '-c', 'core.hooksPath=/dev/null',
+            'ls-remote', remote, 'HEAD',
+        ], {
+            timeout: 15_000,
+            maxBuffer: 128 * 1024,
+            env: hardenedGitEnv(),
+        });
+        latestRevision = stdout.trim().split(/\s+/)[0] ?? '';
+        if (!/^[0-9a-f]{40,64}$/i.test(latestRevision))
+            throw new Error('Unable to resolve the plugin repository HEAD');
+    }
+    else {
+        latestRevision = await packageTreeDigest(metadata.source);
+    }
+    const next = { ...metadata, latestRevision, checkedAt };
+    writePluginSourceMetadata(plugin.dir, next);
+    return {
+        supported: true,
+        updateAvailable: Boolean(metadata.revision && latestRevision !== metadata.revision),
+        revision: metadata.revision,
+        latestRevision,
+        checkedAt,
+    };
+}