@sema-agent/client-core 0.83.0 → 0.83.2

package/dist/pluginHooksWire.js

@@ -0,0 +1,429 @@
+import { displayUntrusted } from './displayUntrusted.js';
+export const ENGINE_FIRED_HOOK_EVENTS = [
+    'PreToolUse',
+    'PostToolUse',
+    'PostToolUseFailure',
+    'PostToolBatch',
+    'PreCompact',
+    'PostCompact',
+    'Stop',
+    'StopFailure',
+    'UserPromptSubmit',
+];
+export const PLUGIN_HOOK_DISPOSITIONS = ['engine', 'shell', 'not_run'];
+export const PLUGIN_HOOK_REASONS = [
+    'projected',
+    'shell_event',
+    'no_executor',
+    'engine_not_local',
+    'engine_locality_unknown',
+    'engine_capability_absent',
+    'engine_capability_unknown',
+    'not_command',
+    'sensitive_options',
+    'engine_limit',
+    'shell_form_user_config',
+    'user_config_unset',
+    'malformed_entry',
+];
+export const PLUGIN_HOOK_EXCLUSION_REASONS = [
+    'workspace_untrusted',
+    'governance_unreadable',
+    'policy_disable_all',
+    'startup_mode',
+    'managed_plugins_only',
+];
+export const SETTINGS_HOOK_DROP_REASONS = ['exec_form_unsupported', 'mcp_tool_unsupported'];
+export const ENGINE_HOOK_LIMITS = { maxGroupsPerEvent: 16, maxEntriesPerEvent: 32, maxCommandChars: 8192 };
+const ENGINE_EVENTS = new Set(ENGINE_FIRED_HOOK_EVENTS);
+const USER_CONFIG_REF_ONE = /\$\{user_config\.[^}]+\}/;
+const USER_CONFIG_REF_ALL = /\$\{user_config\.([^}]+)\}/g;
+function isRecord(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+function nonEmptyString(v) {
+    return typeof v === 'string' && v.length > 0;
+}
+export function isEngineFiredHookEvent(event) {
+    return ENGINE_EVENTS.has(event);
+}
+function declaresSensitive(options) {
+    if (options === undefined)
+        return false;
+    if (!isRecord(options))
+        return true;
+    return Object.values(options).some((o) => !isRecord(o) || o.sensitive !== false);
+}
+function savedPlainValue(options, key) {
+    if (!isRecord(options) || !Object.hasOwn(options, key))
+        return undefined;
+    const o = options[key];
+    if (!isRecord(o) || o.sensitive !== false)
+        return undefined;
+    const v = o.value;
+    return v === undefined || v === null ? undefined : String(v);
+}
+function declaredSensitiveKey(options, key) {
+    if (!isRecord(options) || !Object.hasOwn(options, key))
+        return false;
+    const o = options[key];
+    return !isRecord(o) || o.sensitive !== false;
+}
+function optionEnvKey(key) {
+    return key.replace(/[^A-Za-z0-9_]/g, '_').toUpperCase();
+}
+function projectedOptions(options) {
+    if (!isRecord(options))
+        return undefined;
+    const out = {};
+    let any = false;
+    for (const key of Object.keys(options)) {
+        const v = savedPlainValue(options, key);
+        if (v === undefined)
+            continue;
+        out[optionEnvKey(key)] = v;
+        any = true;
+    }
+    return any ? out : undefined;
+}
+function substituteUserConfig(s, options) {
+    return s.replace(USER_CONFIG_REF_ALL, (whole, key) => savedPlainValue(options, key) ?? whole);
+}
+function classifyEntry(entry, options) {
+    if (!isRecord(entry) || typeof entry.type !== 'string')
+        return { kind: 'malformed' };
+    if (entry.type !== 'command')
+        return { kind: 'other' };
+    const command = entry.command;
+    if (!nonEmptyString(command))
+        return { kind: 'malformed' };
+    const args = entry.args;
+    if (args === undefined)
+        return { kind: 'shell_form', refusesUserConfig: USER_CONFIG_REF_ONE.test(command) };
+    if (!Array.isArray(args) || !args.every((a) => typeof a === 'string'))
+        return { kind: 'malformed' };
+    const unset = [command, ...args].some((s) => [...s.matchAll(USER_CONFIG_REF_ALL)].some((mm) => mm[1] !== undefined && !declaredSensitiveKey(options, mm[1]) && savedPlainValue(options, mm[1]) === undefined));
+    return { kind: 'exec_form', command, args, unsetUserConfig: unset };
+}
+export function occupancyOf(wire) {
+    const out = new Map();
+    for (const [event, groups] of Object.entries(wire)) {
+        if (!Array.isArray(groups))
+            continue;
+        let entries = 0;
+        for (const g of groups)
+            if (isRecord(g) && Array.isArray(g.hooks))
+                entries += g.hooks.length;
+        out.set(event, { groups: groups.length, entries });
+    }
+    return out;
+}
+export function decidePluginHooks(input) {
+    const verdicts = [];
+    const excluded = [];
+    const candidates = new Map();
+    let unreadable = 0;
+    const fallback = (event, reason) => input.shellHookEvents.has(event) ? { disposition: 'shell', reason } : { disposition: 'not_run', reason };
+    input.plugins.forEach((p, pluginIndex) => {
+        if (!isRecord(p) || !isRecord(p.hooks)) {
+            unreadable++;
+            return;
+        }
+        const src = p;
+        const sourceOk = nonEmptyString(p.id) && nonEmptyString(p.name) && nonEmptyString(p.root) && nonEmptyString(p.dataDir);
+        const pluginId = typeof p.id === 'string' ? p.id : '';
+        const pluginName = typeof p.name === 'string' ? p.name : '';
+        for (const [event, groups] of Object.entries(p.hooks)) {
+            if (!Array.isArray(groups)) {
+                unreadable++;
+                continue;
+            }
+            ;
+            groups.forEach((group, groupIndex) => {
+                if (!isRecord(group) || !Array.isArray(group.hooks)) {
+                    unreadable++;
+                    return;
+                }
+                ;
+                group.hooks.forEach((entry, hookIndex) => {
+                    const key = { pluginId, pluginName, event, groupIndex, hookIndex };
+                    if (input.exclusion !== undefined) {
+                        excluded.push({ ...key, reason: input.exclusion });
+                        return;
+                    }
+                    if (input.managedOnly && p.managed !== true) {
+                        excluded.push({ ...key, reason: 'managed_plugins_only' });
+                        return;
+                    }
+                    const shape = sourceOk ? classifyEntry(entry, src.options) : { kind: 'malformed' };
+                    if (shape.kind === 'malformed') {
+                        verdicts.push({ ...key, disposition: 'not_run', reason: 'malformed_entry' });
+                        return;
+                    }
+                    if (shape.kind === 'shell_form' && shape.refusesUserConfig) {
+                        verdicts.push({ ...key, disposition: 'not_run', reason: 'shell_form_user_config' });
+                        return;
+                    }
+                    if (shape.kind === 'exec_form' && shape.unsetUserConfig) {
+                        verdicts.push({ ...key, disposition: 'not_run', reason: 'user_config_unset' });
+                        return;
+                    }
+                    if (!ENGINE_EVENTS.has(event)) {
+                        verdicts.push({
+                            ...key,
+                            ...(input.shellHookEvents.has(event)
+                                ? { disposition: 'shell', reason: 'shell_event' }
+                                : { disposition: 'not_run', reason: 'no_executor' }),
+                        });
+                        return;
+                    }
+                    const blocked = input.engine.ownedByThisShell === null
+                        ? 'engine_locality_unknown'
+                        : !input.engine.ownedByThisShell
+                            ? 'engine_not_local'
+                            : input.engine.pluginHooksCapable === null
+                                ? 'engine_capability_unknown'
+                                : !input.engine.pluginHooksCapable
+                                    ? 'engine_capability_absent'
+                                    : shape.kind === 'other'
+                                        ? 'not_command'
+                                        : declaresSensitive(src.options)
+                                            ? 'sensitive_options'
+                                            : undefined;
+                    if (blocked !== undefined) {
+                        verdicts.push({ ...key, ...fallback(event, blocked) });
+                        return;
+                    }
+                    const plugin = { name: src.name, root: src.root, dataDir: src.dataDir };
+                    const options = projectedOptions(src.options);
+                    if (options !== undefined)
+                        plugin.options = options;
+                    const wireEntry = { ...entry, plugin };
+                    if (shape.kind === 'exec_form') {
+                        wireEntry.command = substituteUserConfig(shape.command, src.options);
+                        wireEntry.args = shape.args.map((a) => substituteUserConfig(a, src.options));
+                    }
+                    const verdict = { ...key, disposition: 'engine', reason: 'projected' };
+                    verdicts.push(verdict);
+                    const list = candidates.get(event) ?? [];
+                    list.push({ verdict, pluginIndex, group, wireEntry });
+                    candidates.set(event, list);
+                });
+            });
+        }
+    });
+    const projected = new Map();
+    for (const [event, list] of candidates) {
+        const fits = list.filter((c) => {
+            const cmd = c.wireEntry.command;
+            if (typeof cmd === 'string' && cmd.length <= ENGINE_HOOK_LIMITS.maxCommandChars)
+                return true;
+            Object.assign(c.verdict, fallback(event, 'engine_limit'));
+            return false;
+        });
+        if (fits.length === 0)
+            continue;
+        const groupKeys = [];
+        for (const c of fits) {
+            const k = `${c.pluginIndex}\u0000${c.verdict.groupIndex}`;
+            if (!groupKeys.includes(k))
+                groupKeys.push(k);
+        }
+        const occ = input.occupied.get(event) ?? { groups: 0, entries: 0 };
+        if (occ.groups + groupKeys.length > ENGINE_HOOK_LIMITS.maxGroupsPerEvent ||
+            occ.entries + fits.length > ENGINE_HOOK_LIMITS.maxEntriesPerEvent) {
+            for (const c of fits)
+                Object.assign(c.verdict, fallback(event, 'engine_limit'));
+            continue;
+        }
+        const groupsOut = [];
+        for (const k of groupKeys) {
+            const members = fits.filter((c) => `${c.pluginIndex}\u0000${c.verdict.groupIndex}` === k);
+            const first = members[0];
+            if (first === undefined)
+                continue;
+            groupsOut.push({ ...first.group, hooks: members.map((c) => c.wireEntry) });
+        }
+        projected.set(event, groupsOut);
+    }
+    return { verdicts, excluded, projected, unreadable };
+}
+const SHELL_INERT_COMMAND = /^[A-Za-z0-9_./:+-]+$/;
+function carriesArgs(entry) {
+    const args = entry.args;
+    if (args === undefined || args === null)
+        return false;
+    if (Array.isArray(args) && args.length === 0) {
+        const command = entry.command;
+        return !(typeof command === 'string' && SHELL_INERT_COMMAND.test(command));
+    }
+    return true;
+}
+export function filterSettingsHookGroups(source, event, groups, execFormCapable, hostFires, failLoudMcpTool) {
+    const drops = [];
+    const out = [];
+    let stripped = 0;
+    const engineEvent = ENGINE_EVENTS.has(event);
+    const notRun = engineEvent && !hostFires;
+    const keepMcpTool = failLoudMcpTool && engineEvent;
+    groups.forEach((group, groupIndex) => {
+        if (!isRecord(group) || !Array.isArray(group.hooks)) {
+            out.push(group);
+            return;
+        }
+        const kept = [];
+        let changed = false;
+        group.hooks.forEach((entry, hookIndex) => {
+            const reason = !isRecord(entry)
+                ? undefined
+                : entry.type === 'mcp_tool'
+                    ? keepMcpTool
+                        ? undefined
+                        : 'mcp_tool_unsupported'
+                    : entry.type === 'command' && carriesArgs(entry) && !execFormCapable
+                        ? 'exec_form_unsupported'
+                        : undefined;
+            if (reason !== undefined) {
+                drops.push({ source, event, groupIndex, hookIndex, reason, notRun });
+                changed = true;
+                return;
+            }
+            if (isRecord(entry) && Object.hasOwn(entry, 'plugin')) {
+                const copy = { ...entry };
+                delete copy.plugin;
+                kept.push(copy);
+                stripped++;
+                changed = true;
+                return;
+            }
+            kept.push(entry);
+        });
+        if (!changed)
+            out.push(group);
+        else if (kept.length > 0)
+            out.push({ ...group, hooks: kept });
+    });
+    return { groups: out, drops, stripped };
+}
+export function pluginHookVerdictOf(plan, pluginId, event, groupIndex, hookIndex) {
+    return plan.verdicts.find((v) => v.pluginId === pluginId && v.event === event && v.groupIndex === groupIndex && v.hookIndex === hookIndex);
+}
+const REASON_TEXT = {
+    projected: 'it is sent to the engine',
+    shell_event: 'this client runs this event itself',
+    no_executor: 'neither the engine nor this client runs this event',
+    engine_not_local: 'the engine was not started by this client on this machine, so it cannot reach the plugin files',
+    engine_locality_unknown: 'it is not known whether the engine was started by this client on this machine, so plugin hooks are not sent to it',
+    engine_capability_absent: 'the connected engine does not support plugin hooks',
+    engine_capability_unknown: 'it is not known yet whether the connected engine supports plugin hooks, so they are not sent to it',
+    not_command: 'only command hooks from plugins can run in the engine',
+    sensitive_options: 'the plugin has sensitive options, and those are never sent to the engine',
+    engine_limit: "sending it would exceed the engine's hook limits for this event",
+    shell_form_user_config: 'its command uses ${user_config.…} in shell form, which is refused (use exec form with "args", or read $CLAUDE_PLUGIN_OPTION_<KEY>)',
+    user_config_unset: 'its command uses a plugin option that has not been set',
+    malformed_entry: 'the hook entry is malformed',
+};
+const DROP_TEXT = {
+    exec_form_unsupported: 'exec-form hooks (with "args") are sent to the engine only once it reports support for them',
+    mcp_tool_unsupported: 'MCP tool hooks are not supported by the engine',
+};
+const SOURCE_TEXT = {
+    policySettings: 'Managed settings',
+    userSettings: 'User settings',
+    projectSettings: 'Project settings',
+    localSettings: 'Local settings',
+};
+export function pluginHookReasonText(reason) {
+    return REASON_TEXT[reason];
+}
+export function settingsHookDropText(reason) {
+    return DROP_TEXT[reason];
+}
+export function pluginHookExecutorLabel(v) {
+    switch (v.disposition) {
+        case 'engine':
+            return 'runs in the engine';
+        case 'shell':
+            return 'runs in this client';
+        case 'not_run':
+            return `does not run: ${pluginHookReasonText(v.reason)}`;
+    }
+}
+const NOTICE_LABEL_MAX = 120;
+const noticeLabel = (s) => capNoticeLabel(escapeNoticeQuotes(displayUntrusted(s, { credentialUrls: false, credentialWords: false })));
+function escapeNoticeQuotes(s) {
+    const budget = NOTICE_LABEL_MAX + 16;
+    const out = [];
+    let len = 0;
+    let i = 0;
+    while (i < s.length && len <= budget) {
+        const c = s.charCodeAt(i);
+        if (c === 0x5c) {
+            let j = i;
+            while (j < s.length && s.charCodeAt(j) === 0x5c)
+                j++;
+            const want = s.charCodeAt(j) === 0x22 ? (j - i) * 2 : j - i;
+            const take = Math.min(want, budget + 1 - len);
+            out.push('\\'.repeat(take));
+            len += take;
+            i = j;
+            continue;
+        }
+        if (c === 0x22) {
+            out.push('\\"');
+            len += 2;
+        }
+        else {
+            out.push(s.charAt(i));
+            len++;
+        }
+        i++;
+    }
+    return out.join('');
+}
+function capNoticeLabel(s) {
+    if (s.length <= NOTICE_LABEL_MAX)
+        return s;
+    const token = /\\u\{[0-9A-F]{1,6}\}|\\u[0-9A-F]{4}|\\[\\"]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[^]/gy;
+    let end = 0;
+    for (let t = token.exec(s); t !== null; t = token.exec(s)) {
+        if (t.index + t[0].length > NOTICE_LABEL_MAX - 1)
+            break;
+        end = t.index + t[0].length;
+    }
+    return `${s.slice(0, end)}…`;
+}
+export function hooksNotRunNotice(plan) {
+    const lines = [];
+    const byPlugin = new Map();
+    for (const v of plan.verdicts) {
+        if (v.disposition !== 'not_run')
+            continue;
+        const k = `${v.pluginId}\u0000${v.reason}`;
+        const row = byPlugin.get(k) ?? { name: v.pluginName, reason: v.reason, events: [], count: 0 };
+        if (!row.events.includes(v.event))
+            row.events.push(v.event);
+        row.count++;
+        byPlugin.set(k, row);
+    }
+    for (const row of byPlugin.values()) {
+        const events = row.events.map((e) => noticeLabel(e)).join(', ');
+        lines.push(`Plugin "${noticeLabel(row.name) || '(unnamed)'}": ${events} ${row.count === 1 ? 'hook' : 'hooks'} will not run — ${pluginHookReasonText(row.reason)}.`);
+    }
+    const bySource = new Map();
+    for (const d of plan.settingsDropped) {
+        if (!d.notRun)
+            continue;
+        const k = `${d.source}\u0000${d.reason}`;
+        const row = bySource.get(k) ?? { source: d.source, reason: d.reason, events: [], count: 0 };
+        if (!row.events.includes(d.event))
+            row.events.push(d.event);
+        row.count++;
+        bySource.set(k, row);
+    }
+    for (const row of bySource.values()) {
+        const events = row.events.map((e) => noticeLabel(e)).join(', ');
+        lines.push(`${SOURCE_TEXT[row.source]}: ${events} ${row.count === 1 ? 'hook' : 'hooks'} will not run — ${settingsHookDropText(row.reason)}.`);
+    }
+    return lines;
+}

package/dist/subagent/engineSubagentResume.js

@@ -1,5 +1,6 @@
 import { hostLog } from '../host.js';
 import { resumeRetryLaterFromError } from '../wireErrorTriage.js';
+import { displayUntrusted } from '../displayUntrusted.js';
 import { engineCapTrue } from '../engineCapsCache.js';
 import { makeEngineWireClient } from '../engineWireSdk.js';
 import { engineWireTargetFor } from '../engineWireTarget.js';
@@ -99,7 +100,7 @@ export function resolveSubagentResumeContext(childTaskId) {
     return { facade: client.runs, runId: resolveOwnerRunId(childTaskId), session };
 }
 function clean(v, max = 200) {
-    return String(v ?? '').replace(/[\x00-\x1f\x7f]/g, '.').slice(0, max);
+    return displayUntrusted(String(v ?? ''), { credentialUrls: false, credentialWords: false, foldLines: false, mark: 'dot', max });
 }
 export async function resumeSettledSubagent(facade, runId, target, content, opts) {
     if (facade === null)