mu-harness 0.16.3

package/script/harness/npm/src/subAgents/index.d.ts

@@ -0,0 +1,4 @@
+export type { SubAgentRegistry, SubAgentResult, SubAgentRun } from './types.js';
+export { createSubAgentRegistry } from './registry.js';
+export { runSubAgent, type RunSubAgentDeps } from './runner.js';
+export { createSubAgentTool } from './tool.js';

package/script/harness/npm/src/subAgents/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSubAgentTool = exports.runSubAgent = exports.createSubAgentRegistry = void 0;
+var registry_js_1 = require("./registry.js");
+Object.defineProperty(exports, "createSubAgentRegistry", { enumerable: true, get: function () { return registry_js_1.createSubAgentRegistry; } });
+var runner_js_1 = require("./runner.js");
+Object.defineProperty(exports, "runSubAgent", { enumerable: true, get: function () { return runner_js_1.runSubAgent; } });
+var tool_js_1 = require("./tool.js");
+Object.defineProperty(exports, "createSubAgentTool", { enumerable: true, get: function () { return tool_js_1.createSubAgentTool; } });

package/script/harness/npm/src/subAgents/registry.d.ts

@@ -0,0 +1,2 @@
+import type { SubAgentRegistry } from './types.js';
+export declare const createSubAgentRegistry: () => SubAgentRegistry;

package/script/harness/npm/src/subAgents/registry.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSubAgentRegistry = void 0;
+const createSubAgentRegistry = () => {
+    const runs = new Map();
+    const listeners = new Set();
+    return {
+        register: (run) => {
+            runs.set(run.runId, run);
+            for (const listener of listeners)
+                listener(run);
+        },
+        get: (runId) => runs.get(runId),
+        list: () => [...runs.values()],
+        byParent: (parentId) => [...runs.values()].filter((run) => run.parentId === parentId),
+        subscribe: (listener) => {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+    };
+};
+exports.createSubAgentRegistry = createSubAgentRegistry;

package/script/harness/npm/src/subAgents/runner.d.ts

@@ -0,0 +1,15 @@
+import type { Agent } from '../agents/index.js';
+import type { AgentSession } from '../session/index.js';
+import type { SubAgentRegistry, SubAgentResult } from './types.js';
+export interface RunSubAgentDeps {
+    spawn(agent: Agent): AgentSession;
+    /** When provided, the spawned run is registered (so hosts can read/observe it). */
+    runs?: SubAgentRegistry;
+    /** Parent session id the run is attributed to. */
+    parentId?: string;
+    /** Run id; defaults to the spawned session's id so persistence keys align. */
+    runId?: string;
+    /** Aborts the spawned session when the parent turn is cancelled. */
+    signal?: AbortSignal;
+}
+export declare const runSubAgent: (agent: Agent, task: string, deps: RunSubAgentDeps) => Promise<SubAgentResult>;

package/script/harness/npm/src/subAgents/runner.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSubAgent = void 0;
+const finalText = (session) => {
+    for (let i = session.messages.length - 1; i >= 0; i--) {
+        const message = session.messages[i];
+        if (message.role === 'assistant') {
+            return message.content.map((part) => (part.type === 'text' ? part.text : '')).join('');
+        }
+    }
+    return '';
+};
+const runSubAgent = async (agent, task, deps) => {
+    const session = deps.spawn(agent);
+    deps.runs?.register({ runId: deps.runId ?? session.id, agent: agent.name, parentId: deps.parentId, session });
+    const { signal } = deps;
+    if (signal?.aborted)
+        session.abort();
+    const onAbort = () => session.abort();
+    signal?.addEventListener('abort', onAbort, { once: true });
+    let failure;
+    const unsubscribe = session.subscribe((event) => {
+        if (event.type === 'error')
+            failure = event.error;
+    });
+    try {
+        await session.send(task);
+    }
+    finally {
+        unsubscribe();
+        signal?.removeEventListener('abort', onAbort);
+    }
+    if (failure !== undefined)
+        throw failure instanceof Error ? failure : new Error(String(failure));
+    return { agent: agent.name, text: finalText(session) };
+};
+exports.runSubAgent = runSubAgent;

package/script/harness/npm/src/subAgents/tool.d.ts

@@ -0,0 +1,6 @@
+import type { Tool } from 'mu-core';
+import type { AgentRegistry } from '../agents/index.js';
+import { type RunSubAgentDeps } from './runner.js';
+export declare const createSubAgentTool: (deps: {
+    registry: AgentRegistry;
+} & RunSubAgentDeps) => Tool;

package/script/harness/npm/src/subAgents/tool.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSubAgentTool = void 0;
+const runner_js_1 = require("./runner.js");
+const createSubAgentTool = (deps) => ({
+    name: 'subagent',
+    description: 'Delegate an isolated task to a named sub-agent. Returns its final answer.',
+    prompt: 'Delegate self-contained research or sub-tasks to a named sub-agent with `subagent`; treat its answer as research input.',
+    parameters: {
+        type: 'object',
+        properties: {
+            agent: { type: 'string', description: 'Sub-agent name.' },
+            task: { type: 'string', description: 'The task to delegate.' },
+        },
+        required: ['agent', 'task'],
+        additionalProperties: false,
+    },
+    run: async (input, ctx) => {
+        const { agent, task } = (input ?? {});
+        if (!agent || !task)
+            return [{ type: 'text', text: 'Error: subagent requires `agent` and `task`.' }];
+        const def = deps.registry.get(agent);
+        if (!def)
+            return [{ type: 'text', text: `Error: unknown sub-agent "${agent}".` }];
+        const result = await (0, runner_js_1.runSubAgent)(def, task, {
+            spawn: deps.spawn,
+            runs: deps.runs,
+            parentId: deps.parentId,
+            signal: ctx.signal,
+        });
+        return [{ type: 'text', text: result.text }];
+    },
+});
+exports.createSubAgentTool = createSubAgentTool;

package/script/harness/npm/src/subAgents/types.d.ts

@@ -0,0 +1,18 @@
+import type { AgentSession } from '../session/index.js';
+export interface SubAgentResult {
+    agent: string;
+    text: string;
+}
+export interface SubAgentRun {
+    runId: string;
+    agent: string;
+    parentId?: string;
+    session: AgentSession;
+}
+export interface SubAgentRegistry {
+    register(run: SubAgentRun): void;
+    get(runId: string): SubAgentRun | undefined;
+    list(): SubAgentRun[];
+    byParent(parentId: string): SubAgentRun[];
+    subscribe(listener: (run: SubAgentRun) => void): () => void;
+}

package/script/harness/npm/src/subAgents/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/script/harness/npm/src/tui/channel.d.ts

@@ -0,0 +1,3 @@
+import type { Channel } from '../channels/index.js';
+import type { ChatApp, ChatAppOptions } from './types.js';
+export declare const createChatApp: (channel: Channel, opts?: ChatAppOptions) => ChatApp;

package/script/harness/npm/src/tui/channel.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createChatApp = void 0;
+const mu_tui_1 = require("mu-tui");
+const index_js_1 = require("./components/index.js");
+const kit_js_1 = require("./kit.js");
+const defaultLayout = (parts, ctx) => ctx.components.column([parts.header, (0, mu_tui_1.flex)(parts.transcript), parts.status, parts.composer]);
+const createChatApp = (channel, opts = {}) => {
+    const slots = opts.slots ?? {};
+    const components = { ...kit_js_1.defaultKit, ...opts.components };
+    const resolveMessage = slots.message ?? index_js_1.message;
+    const ctx = {
+        channel,
+        components,
+        renderMessage: (msg) => resolveMessage(msg, ctx),
+        status: { current: 'idle' },
+    };
+    const parts = {
+        header: (slots.header ?? index_js_1.header)(ctx),
+        transcript: (slots.transcript ?? index_js_1.transcript)(ctx),
+        status: (slots.status ?? index_js_1.status)(ctx),
+        composer: (slots.composer ?? index_js_1.composer)(ctx),
+    };
+    const root = (slots.layout ?? defaultLayout)(parts, ctx);
+    const terminal = opts.terminal ?? new mu_tui_1.ProcessTerminal({ bracketedPaste: true, focusEvents: true });
+    const tui = new mu_tui_1.TUI(terminal);
+    const unsubscribe = channel.subscribe((event) => {
+        if (event.type === 'turn_start')
+            ctx.status.current = 'thinking';
+        else if (event.type === 'turn_end')
+            ctx.status.current = 'idle';
+        else if (event.type === 'error')
+            ctx.status.current = 'error';
+        tui.requestRender();
+    });
+    tui.setRoot(root);
+    tui.setFocus(parts.composer);
+    const stop = () => {
+        unsubscribe();
+        tui.stop();
+    };
+    return {
+        tui,
+        start: () => {
+            tui.addGlobalKeybinding({
+                chord: { key: 'c', ctrl: true },
+                handler: () => {
+                    stop();
+                    opts.onExit?.();
+                },
+            });
+            tui.start();
+        },
+        stop,
+    };
+};
+exports.createChatApp = createChatApp;

package/script/harness/npm/src/tui/components/composer.d.ts

@@ -0,0 +1,3 @@
+import type { Component } from 'mu-tui';
+import type { ChatContext } from '../types.js';
+export declare const composer: (ctx: ChatContext) => Component;

package/script/harness/npm/src/tui/components/composer.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.composer = void 0;
+const composer = (ctx) => {
+    const input = ctx.components.editor({
+        placeholder: 'Message…',
+        onSubmit: (value) => {
+            const trimmed = value.trim();
+            if (!trimmed)
+                return;
+            input.setValue('');
+            void ctx.channel.send(trimmed);
+        },
+    });
+    return input;
+};
+exports.composer = composer;

package/script/harness/npm/src/tui/components/header.d.ts

@@ -0,0 +1,3 @@
+import type { Component } from 'mu-tui';
+import type { ChatContext } from '../types.js';
+export declare const header: (ctx: ChatContext) => Component;

package/script/harness/npm/src/tui/components/header.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.header = void 0;
+const header = (ctx) => ctx.components.text(`\x1b[1m${ctx.channel.title}\x1b[0m`);
+exports.header = header;

package/script/harness/npm/src/tui/components/index.d.ts

@@ -0,0 +1,5 @@
+export { composer } from './composer.js';
+export { header } from './header.js';
+export { formatMessage, message, partToText } from './message.js';
+export { status } from './status.js';
+export { messagesView, transcript } from './transcript.js';

package/script/harness/npm/src/tui/components/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transcript = exports.messagesView = exports.status = exports.partToText = exports.message = exports.formatMessage = exports.header = exports.composer = void 0;
+var composer_js_1 = require("./composer.js");
+Object.defineProperty(exports, "composer", { enumerable: true, get: function () { return composer_js_1.composer; } });
+var header_js_1 = require("./header.js");
+Object.defineProperty(exports, "header", { enumerable: true, get: function () { return header_js_1.header; } });
+var message_js_1 = require("./message.js");
+Object.defineProperty(exports, "formatMessage", { enumerable: true, get: function () { return message_js_1.formatMessage; } });
+Object.defineProperty(exports, "message", { enumerable: true, get: function () { return message_js_1.message; } });
+Object.defineProperty(exports, "partToText", { enumerable: true, get: function () { return message_js_1.partToText; } });
+var status_js_1 = require("./status.js");
+Object.defineProperty(exports, "status", { enumerable: true, get: function () { return status_js_1.status; } });
+var transcript_js_1 = require("./transcript.js");
+Object.defineProperty(exports, "messagesView", { enumerable: true, get: function () { return transcript_js_1.messagesView; } });
+Object.defineProperty(exports, "transcript", { enumerable: true, get: function () { return transcript_js_1.transcript; } });

package/script/harness/npm/src/tui/components/message.d.ts

@@ -0,0 +1,6 @@
+import type { ContentPart, Message } from 'mu-core';
+import type { Component } from 'mu-tui';
+import type { ChatContext } from '../types.js';
+export declare const partToText: (part: ContentPart) => string;
+export declare const formatMessage: (message: Message) => string;
+export declare const message: (msg: Message, ctx: ChatContext) => Component;

package/script/harness/npm/src/tui/components/message.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.message = exports.formatMessage = exports.partToText = void 0;
+const partToText = (part) => {
+    switch (part.type) {
+        case 'text':
+            return part.text;
+        case 'tool_call':
+            return `\x1b[2m[${part.name}]\x1b[0m`;
+        case 'tool_result':
+            return part.content.map(exports.partToText).join('');
+        case 'image':
+            return '\x1b[2m[image]\x1b[0m';
+        case 'audio':
+            return '\x1b[2m[audio]\x1b[0m';
+    }
+};
+exports.partToText = partToText;
+const isToolResults = (message) => message.content.length > 0 && message.content.every((part) => part.type === 'tool_result');
+const label = (message) => {
+    if (isToolResults(message))
+        return '\x1b[2mtool\x1b[0m';
+    if (message.role === 'user')
+        return '\x1b[36myou\x1b[0m';
+    if (message.role === 'assistant')
+        return '\x1b[32magent\x1b[0m';
+    return `\x1b[2m${message.role}\x1b[0m`;
+};
+const formatMessage = (message) => `${label(message)}  ${message.content.map(exports.partToText).join('')}`;
+exports.formatMessage = formatMessage;
+const message = (msg, ctx) => ctx.components.text((0, exports.formatMessage)(msg));
+exports.message = message;

package/script/harness/npm/src/tui/components/status.d.ts

@@ -0,0 +1,3 @@
+import type { Component } from 'mu-tui';
+import type { ChatContext } from '../types.js';
+export declare const status: (ctx: ChatContext) => Component;

package/script/harness/npm/src/tui/components/status.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.status = void 0;
+const LABELS = {
+    idle: '\x1b[2m● ready\x1b[0m',
+    thinking: '\x1b[33m◍ thinking…\x1b[0m',
+    error: '\x1b[31m✗ error\x1b[0m',
+};
+const status = (ctx) => ({
+    render: (s) => ctx.components.text(LABELS[ctx.status.current]).render(s),
+});
+exports.status = status;

package/script/harness/npm/src/tui/components/transcript.d.ts

@@ -0,0 +1,4 @@
+import type { Component } from 'mu-tui';
+import type { ChatContext } from '../types.js';
+export declare const messagesView: (ctx: ChatContext) => Component;
+export declare const transcript: (ctx: ChatContext) => Component;

package/script/harness/npm/src/tui/components/transcript.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transcript = exports.messagesView = void 0;
+const messagesView = (ctx) => ({
+    render: (s) => ctx.components.column(ctx.channel.messages.map(ctx.renderMessage)).render(s),
+});
+exports.messagesView = messagesView;
+const transcript = (ctx) => ctx.components.scrollView((0, exports.messagesView)(ctx));
+exports.transcript = transcript;

package/script/harness/npm/src/tui/index.d.ts

@@ -0,0 +1,7 @@
+import type { Channel } from '../channels/index.js';
+import type { ChatApp, ChatAppOptions } from './types.js';
+export * from './types.js';
+export * from './kit.js';
+export * from './components/index.js';
+export { createChatApp } from './channel.js';
+export declare const runChat: (channel: Channel, opts?: ChatAppOptions) => ChatApp;

package/script/harness/npm/src/tui/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runChat = exports.createChatApp = void 0;
+const channel_js_1 = require("./channel.js");
+__exportStar(require("./types.js"), exports);
+__exportStar(require("./kit.js"), exports);
+__exportStar(require("./components/index.js"), exports);
+var channel_js_2 = require("./channel.js");
+Object.defineProperty(exports, "createChatApp", { enumerable: true, get: function () { return channel_js_2.createChatApp; } });
+const runChat = (channel, opts) => {
+    const app = (0, channel_js_1.createChatApp)(channel, opts);
+    app.start();
+    return app;
+};
+exports.runChat = runChat;

package/script/harness/npm/src/tui/kit.d.ts

@@ -0,0 +1,15 @@
+import { type Component, type FlexItem } from 'mu-tui';
+export interface EditorHandle extends Component {
+    getValue(): string;
+    setValue(value: string): void;
+}
+export interface ComponentKit {
+    text(value: string): Component;
+    column(children: (Component | FlexItem)[]): Component;
+    scrollView(content: Component): Component;
+    editor(opts: {
+        placeholder?: string;
+        onSubmit?: (value: string) => void;
+    }): EditorHandle;
+}
+export declare const defaultKit: ComponentKit;

package/script/harness/npm/src/tui/kit.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultKit = void 0;
+const mu_tui_1 = require("mu-tui");
+exports.defaultKit = {
+    text: mu_tui_1.text,
+    column: mu_tui_1.column,
+    scrollView: mu_tui_1.scrollView,
+    editor: mu_tui_1.editor,
+};

package/script/harness/npm/src/tui/types.d.ts

@@ -0,0 +1,38 @@
+import type { Message } from 'mu-core';
+import type { Component, Terminal, TUI } from 'mu-tui';
+import type { Channel } from '../channels/index.js';
+import type { ComponentKit } from './kit.js';
+export type ChatStatus = 'idle' | 'thinking' | 'error';
+export interface ChatContext {
+    channel: Channel;
+    components: ComponentKit;
+    renderMessage: (message: Message) => Component;
+    status: {
+        current: ChatStatus;
+    };
+}
+export interface ChatParts {
+    header: Component;
+    transcript: Component;
+    status: Component;
+    composer: Component;
+}
+export interface ChatSlots {
+    message?: (message: Message, ctx: ChatContext) => Component;
+    header?: (ctx: ChatContext) => Component;
+    transcript?: (ctx: ChatContext) => Component;
+    status?: (ctx: ChatContext) => Component;
+    composer?: (ctx: ChatContext) => Component;
+    layout?: (parts: ChatParts, ctx: ChatContext) => Component;
+}
+export interface ChatAppOptions {
+    terminal?: Terminal;
+    components?: Partial<ComponentKit>;
+    slots?: ChatSlots;
+    onExit?: () => void;
+}
+export interface ChatApp {
+    readonly tui: TUI;
+    start(): void;
+    stop(): void;
+}

package/script/harness/npm/src/tui/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/script/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/script/tui/src/capabilities.d.ts

@@ -0,0 +1,72 @@
+export type CapabilitySource = 'default' | 'env' | 'terminfo' | 'probe' | 'policy' | 'feature' | 'configured' | 'disabled';
+export interface Capability<T> {
+    value: T;
+    source: CapabilitySource;
+}
+export interface TerminalIdentity {
+    term: string;
+    program: string;
+    multiplexer: 'none' | 'tmux' | 'screen' | 'zellij' | 'unknown';
+    transport: 'tty' | 'pipe' | 'ssh' | 'conpty' | 'unknown';
+    platform: NodeJS.Platform;
+}
+export interface ScreenCapabilities {
+    alternateScreen: Capability<boolean>;
+}
+export interface ColorCapabilities {
+    ansi16: Capability<boolean>;
+    palette256: Capability<boolean>;
+    truecolor: Capability<boolean>;
+}
+export interface InputCapabilities {
+    legacy: Capability<boolean>;
+    xtermModifiedKeys: Capability<boolean>;
+    kittyKeyboard: Capability<boolean>;
+    bracketedPaste: Capability<boolean>;
+    focusEvents: Capability<boolean>;
+}
+export interface MouseCapabilities {
+    sgr: Capability<boolean>;
+    drag: Capability<boolean>;
+}
+export interface OscCapabilities {
+    title: Capability<boolean>;
+    hyperlinks: Capability<boolean>;
+    shellIntegration: Capability<boolean>;
+}
+export interface GraphicsCapabilities {
+    unicode: Capability<boolean>;
+    kitty: Capability<boolean>;
+    iterm2: Capability<boolean>;
+}
+export interface SecurityPolicy {
+    hyperlinks: 'deny' | 'allow';
+    clipboardWrite: 'deny' | 'ask' | 'allow';
+    clipboardRead: 'deny' | 'ask' | 'allow';
+    images: 'deny' | 'allow';
+    shellIntegration: 'deny' | 'allow';
+    maxPayloadBytes: number;
+}
+export interface Capabilities {
+    identity: TerminalIdentity;
+    screen: ScreenCapabilities;
+    colors: ColorCapabilities;
+    input: InputCapabilities;
+    mouse: MouseCapabilities;
+    osc: OscCapabilities;
+    graphics: GraphicsCapabilities;
+    security: SecurityPolicy;
+}
+export type PartialCapabilities = Partial<{
+    identity: Partial<TerminalIdentity>;
+    screen: Partial<ScreenCapabilities>;
+    colors: Partial<ColorCapabilities>;
+    input: Partial<InputCapabilities>;
+    mouse: Partial<MouseCapabilities>;
+    osc: Partial<OscCapabilities>;
+    graphics: Partial<GraphicsCapabilities>;
+    security: Partial<SecurityPolicy>;
+}>;
+export declare function capability<T>(value: T, source?: CapabilitySource): Capability<T>;
+export declare function createDefaultCapabilities(env?: NodeJS.ProcessEnv): Capabilities;
+export declare function mergeCapabilities(base: Capabilities, patch?: PartialCapabilities): Capabilities;

package/script/tui/src/capabilities.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capability = capability;
+exports.createDefaultCapabilities = createDefaultCapabilities;
+exports.mergeCapabilities = mergeCapabilities;
+const node_process_1 = __importDefault(require("node:process"));
+function capability(value, source = 'default') {
+    return { value, source };
+}
+function createDefaultCapabilities(env = node_process_1.default.env) {
+    const term = env.TERM ?? 'dumb';
+    const program = env.TERM_PROGRAM ?? env.TERMINAL_EMULATOR ?? (env.KITTY_WINDOW_ID ? 'kitty' : 'unknown');
+    const multiplexer = detectMultiplexer(env);
+    const transport = detectTransport(env);
+    const truecolor = env.COLORTERM === 'truecolor' || env.COLORTERM === '24bit';
+    const modernTerm = /xterm|kitty|wezterm|ghostty|alacritty|foot|tmux|screen|vte|rxvt|iterm|mintty/i.test(term);
+    return {
+        identity: {
+            term,
+            program,
+            multiplexer,
+            transport,
+            platform: node_process_1.default.platform,
+        },
+        screen: {
+            alternateScreen: capability(modernTerm, modernTerm ? 'env' : 'default'),
+        },
+        colors: {
+            ansi16: capability(term !== 'dumb'),
+            palette256: capability(term.includes('256color'), term.includes('256color') ? 'env' : 'default'),
+            truecolor: capability(truecolor, truecolor ? 'env' : 'default'),
+        },
+        input: {
+            legacy: capability(true),
+            xtermModifiedKeys: capability(modernTerm, modernTerm ? 'env' : 'default'),
+            kittyKeyboard: capability(Boolean(env.KITTY_WINDOW_ID), env.KITTY_WINDOW_ID ? 'env' : 'default'),
+            bracketedPaste: capability(modernTerm, modernTerm ? 'env' : 'default'),
+            focusEvents: capability(modernTerm, modernTerm ? 'env' : 'default'),
+        },
+        mouse: {
+            sgr: capability(modernTerm, modernTerm ? 'env' : 'default'),
+            drag: capability(modernTerm, modernTerm ? 'env' : 'default'),
+        },
+        osc: {
+            title: capability(modernTerm, modernTerm ? 'env' : 'default'),
+            hyperlinks: capability(modernTerm, modernTerm ? 'env' : 'default'),
+            shellIntegration: capability(false),
+        },
+        graphics: {
+            unicode: capability(true),
+            kitty: capability(Boolean(env.KITTY_WINDOW_ID), env.KITTY_WINDOW_ID ? 'env' : 'default'),
+            iterm2: capability(program === 'iTerm.app', program === 'iTerm.app' ? 'env' : 'default'),
+        },
+        security: {
+            hyperlinks: 'allow',
+            clipboardWrite: 'deny',
+            clipboardRead: 'deny',
+            images: 'deny',
+            shellIntegration: 'deny',
+            maxPayloadBytes: 1024 * 1024,
+        },
+    };
+}
+function mergeCapabilities(base, patch) {
+    if (!patch)
+        return base;
+    return {
+        identity: { ...base.identity, ...patch.identity },
+        screen: { ...base.screen, ...patch.screen },
+        colors: { ...base.colors, ...patch.colors },
+        input: { ...base.input, ...patch.input },
+        mouse: { ...base.mouse, ...patch.mouse },
+        osc: { ...base.osc, ...patch.osc },
+        graphics: { ...base.graphics, ...patch.graphics },
+        security: { ...base.security, ...patch.security },
+    };
+}
+function detectMultiplexer(env) {
+    if (env.TMUX)
+        return 'tmux';
+    if (env.STY)
+        return 'screen';
+    if (env.ZELLIJ)
+        return 'zellij';
+    return 'none';
+}
+function detectTransport(env) {
+    if (env.SSH_TTY || env.SSH_CONNECTION)
+        return 'ssh';
+    if (env.WT_SESSION || node_process_1.default.platform === 'win32')
+        return 'conpty';
+    if (node_process_1.default.stdin.isTTY && node_process_1.default.stdout.isTTY)
+        return 'tty';
+    return 'pipe';
+}