hyacinth-ai 0.9.6

package/dist/bypass/manager.js

@@ -0,0 +1,179 @@
+// ============================================================
+// bypass/manager — BypassManager
+// ============================================================
+//
+// 管理所有旁路Agent的生命周期和调度。
+// 由 Loop 在每轮对话前后调用 preTurn/postTurn。
+//
+// 职责：
+//   - Agent 注册与启停
+//   - preTurn：收集所有活跃Agent的注入内容（阻塞，等旁路LLM完成）
+//   - postTurn：并行调度所有Agent的后台观察（不阻塞主流程）
+//   - 异常隔离：单个Agent失败不影响其他Agent和主流程
+// ============================================================
+import { createLogger } from '../logging/logger.js';
+const logger = createLogger('bypass-manager');
+export class BypassManager {
+    /** 所有已注册的Agent */
+    registry = new Map();
+    /** 当前激活的Agent列表 */
+    active = [];
+    /** 模型路由引用（注入后所有Agent共享） */
+    modelRouter = null;
+    /** 注入模型路由（factory 初始化后调用） */
+    setModelRouter(router) {
+        this.modelRouter = router;
+        for (const agent of this.registry.values()) {
+            if ('setModelRouter' in agent) {
+                agent.setModelRouter(router);
+            }
+        }
+    }
+    /** 注册一个旁路Agent */
+    register(agent) {
+        this.registry.set(agent.name, agent);
+        if (this.modelRouter && 'setModelRouter' in agent) {
+            agent.setModelRouter(this.modelRouter);
+        }
+        // 注入 BypassManager 引用（供 postTurn 中调 inject() 用）
+        if ('_manager' in agent) {
+            agent._manager = this;
+        }
+        logger.info(`BypassAgent registered: ${agent.name} (modes: ${agent.modes.join(', ')})`);
+    }
+    /** 取消注册 */
+    unregister(name) {
+        this.registry.delete(name);
+        this.active = this.active.filter(a => a.name !== name);
+    }
+    /** 根据模式名激活对应的旁路Agent */
+    async activateForMode(modeName) {
+        // 先停用当前活跃的
+        await this.deactivateAll();
+        const toActivate = [];
+        for (const agent of this.registry.values()) {
+            if (agent.modes.includes('*') || agent.modes.includes(modeName)) {
+                toActivate.push(agent);
+            }
+        }
+        for (const agent of toActivate) {
+            try {
+                await agent.start();
+                this.active.push(agent);
+                logger.info(`BypassAgent started: ${agent.name} (mode: ${modeName})`);
+            }
+            catch (err) {
+                logger.warn(`BypassAgent start failed: ${agent.name}`, { error: err.message });
+            }
+        }
+    }
+    /** 手动激活指定Agent（TUI命令用） */
+    async activateAgent(name) {
+        const agent = this.registry.get(name);
+        if (!agent) {
+            logger.warn(`BypassAgent not found: ${name}`);
+            return;
+        }
+        if (this.active.includes(agent))
+            return;
+        try {
+            await agent.start();
+            this.active.push(agent);
+            logger.info(`BypassAgent manually activated: ${name}`);
+        }
+        catch (err) {
+            logger.warn(`BypassAgent start failed: ${name}`, { error: err.message });
+        }
+    }
+    /** 手动停用指定Agent（TUI命令用） */
+    async deactivateAgent(name) {
+        const agent = this.registry.get(name);
+        if (!agent)
+            return;
+        try {
+            await agent.stop();
+        }
+        catch (err) {
+            logger.warn(`BypassAgent stop failed: ${name}`, { error: err.message });
+        }
+        this.active = this.active.filter(a => a !== agent);
+        logger.info(`BypassAgent deactivated: ${name}`);
+    }
+    /** 停用所有Agent */
+    async deactivateAll() {
+        for (const agent of this.active) {
+            try {
+                await agent.stop();
+            }
+            catch (err) {
+                logger.warn(`BypassAgent stop failed: ${agent.name}`, { error: err.message });
+            }
+        }
+        this.active = [];
+    }
+    /** 某Agent是否激活 */
+    isActive(name) {
+        return this.active.some(a => a.name === name);
+    }
+    /** 获取已注册的Agent（用于直接访问Agent特有方法，如 setPendingNarration） */
+    getAgent(name) {
+        return this.registry.get(name);
+    }
+    /** 获取激活列表 */
+    getActiveNames() {
+        return this.active.map(a => a.name);
+    }
+    /** 运行时注入：旁路Agent 在 postTurn 中可调用此方法写入纠正内容 */
+    _pendingInjections = [];
+    inject(agentName, injection) {
+        // 清除同一 agent 的旧注入，只保留最新
+        this._pendingInjections = this._pendingInjections.filter(ij => ij.section !== injection.section);
+        this._pendingInjections.push(injection);
+        logger.info(`BypassAgent injected: ${agentName} → ${injection.section}`);
+    }
+    /** 消费待注入内容（由 Loop 在 compose 前调用） */
+    consumeInjections() {
+        const injs = [...this._pendingInjections];
+        this._pendingInjections = [];
+        return injs;
+    }
+    // ── preTurn：阻塞，等所有旁路Agent完成 ──────────────────────
+    async preTurn(ctx) {
+        if (this.active.length === 0) {
+            return { injections: [] };
+        }
+        const allInjections = [];
+        let transformedInput;
+        for (const agent of this.active) {
+            if (!agent.preTurn)
+                continue;
+            try {
+                const result = await agent.preTurn(ctx);
+                if (result.transformedInput !== undefined) {
+                    transformedInput = result.transformedInput;
+                }
+                allInjections.push(...result.injections);
+            }
+            catch (err) {
+                logger.warn(`BypassAgent preTurn failed: ${agent.name}`, { error: err.message });
+            }
+        }
+        return { transformedInput, injections: allInjections };
+    }
+    // ── postTurn：后台并行，不阻塞 ──────────────────────────────
+    postTurn(ctx) {
+        if (this.active.length === 0)
+            return;
+        Promise.allSettled(this.active.map(async (agent) => {
+            if (!agent.postTurn)
+                return;
+            try {
+                await agent.postTurn(ctx);
+            }
+            catch (err) {
+                logger.warn(`BypassAgent postTurn failed: ${agent.name}`, { error: err.message });
+            }
+        }));
+    }
+}
+//# sourceMappingURL=manager.js.map

package/dist/bypass/types.d.ts

@@ -0,0 +1,63 @@
+import type { Message } from '../types.js';
+/** preTurn 上下文：旁路Agent在每轮对话前的输入 */
+export interface PreTurnContext {
+    /** 当前用户输入（原始文本） */
+    userInput: string;
+    /** 最近 N 轮对话原始消息 */
+    recentHistory: Message[];
+    /** 当前上下文预算 { used, total } */
+    contextBudget: {
+        used: number;
+        total: number;
+    };
+    /** 最近几轮的工具调用名称 */
+    recentToolCalls: string[];
+}
+/** postTurn 上下文：旁路Agent在每轮对话后的输入 */
+export interface PostTurnContext {
+    /** 当前用户输入 */
+    userInput: string;
+    /** 主Agent的回复文本 */
+    assistantOutput: string;
+    /** 本轮对话历史（含用户输入和模型回复） */
+    history: Message[];
+    /** 本轮调用的工具名称 */
+    toolCallsThisTurn: string[];
+    /** 是否为本轮用户消息的最后一次迭代（loop 结束） */
+    isLastIteration: boolean;
+}
+/** 注入到上下文中的 section */
+export interface Injection {
+    /** 目标 section 名称（如 'timestamp', 'persona_soul'） */
+    section: string;
+    /** 注入内容 */
+    content: string;
+    /** 消息角色 */
+    role: 'system' | 'assistant' | 'user';
+    /** 替换模式：replace=替换整个section, append=追加到末尾 */
+    mode: 'replace' | 'append';
+}
+/** preTurn 的返回结果 */
+export interface PreTurnResult {
+    /** 变换后的用户输入（可选，World Engine 用于剥离 [[...]]） */
+    transformedInput?: string;
+    /** 要注入到上下文的 section 列表 */
+    injections: Injection[];
+}
+export interface BypassAgent {
+    /** 唯一标识 */
+    readonly name: string;
+    /** 声明适用的模式（如 ['companion'] 或 ['*'] 表示全部） */
+    readonly modes: string[];
+    /** 使用的模型通道名（对应 model-channels.json 中的通道） */
+    readonly modelChannel: string;
+    /** 启动（创建内部状态、启动定时器等） */
+    start(): Promise<void>;
+    /** 停止（清理资源、落盘） */
+    stop(): Promise<void>;
+    /** 前置介入：在 composer 组装之前调用 */
+    preTurn?(ctx: PreTurnContext): Promise<PreTurnResult>;
+    /** 后置观察：在主Agent回复之后调用（后台，不影响主流程） */
+    postTurn?(ctx: PostTurnContext): Promise<void>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/bypass/types.js

@@ -0,0 +1,14 @@
+// ============================================================
+// bypass/types — 旁路Agent 接口定义
+// ============================================================
+//
+// 旁路Agent 是独立于主Agent运行的后台观察者。
+// 在主对话流的前后介入：preTurn 产出注入内容，postTurn 观察并更新内部状态。
+//
+// 与主Agent的差异：
+//   - 独立模型通道（不抢占主Agent的上下文预算）
+//   - 异常隔离（任何错误不影响主流程）
+//   - 状态持久化（跨轮保持内部状态）
+// ============================================================
+export {};
+//# sourceMappingURL=types.js.map

package/dist/channels/auto-detect.d.ts

@@ -0,0 +1,25 @@
+import type { ChannelManager } from './manager.js';
+import type { ChannelsInfo } from '../env/index.js';
+export interface ChannelPlugin {
+    /** 配置 key 名（对应 config.json 中 channels 下的键名） */
+    configKey: string;
+    /** 自动注册渠道 */
+    autoRegister(channelManager: ChannelManager, config: unknown, channelsInfo: ChannelsInfo[]): Promise<void>;
+    /** Gateway 启动时执行全局设置（如日志拦截），返回清理函数 */
+    onGatewayInit?(): (() => void) | void;
+}
+export declare function registerChannelPlugin(plugin: ChannelPlugin): void;
+export declare function getChannelPlugins(): ChannelPlugin[];
+/**
+ * 自动发现渠道插件。
+ * 扫描 channels/plugins 下的子目录中导出的 channelPlugin 常量。
+ */
+export declare function discoverPlugins(): Promise<void>;
+/**
+ * 根据 config.json 注册所有配置驱动渠道。
+ * 不负责启动——由调用方通过 channelManager.startAll() 统一启动。
+ *
+ * @returns 已注册的渠道信息列表（用于注入到 System Prompt）
+ */
+export declare function registerConfigChannels(channelManager: ChannelManager, cwd: string): Promise<ChannelsInfo[]>;
+//# sourceMappingURL=auto-detect.d.ts.map

package/dist/channels/auto-detect.js

@@ -0,0 +1,77 @@
+// ============================================================
+// auto-detect.ts — 渠道自动检测（插件注册表模式）
+// ============================================================
+//
+// 职责：
+//   根据 config.json 自动检测并注册配置驱动渠道
+//   通过 ChannelPlugin 注册表实现可扩展的渠道自动注册
+//   TUI 渠道始终默认允许，由调用方手动注册和启动
+//   HTTP 渠道由 serve 模式负责
+//
+// 使用方式：
+//   import { registerConfigChannels, registerChannelPlugin } from './channels/auto-detect.js';
+//   registerChannelPlugin(feishuChannelPlugin);
+//   const channelsInfo = await registerConfigChannels(channelManager, cwd);
+//   await channelManager.startAll(messageProcessor);
+// ============================================================
+import { ConfigManager } from '../setup/config.js';
+// ─── 插件注册表 ─────────────────────────────────────────────────
+const channelPlugins = [];
+export function registerChannelPlugin(plugin) {
+    channelPlugins.push(plugin);
+}
+export function getChannelPlugins() {
+    return [...channelPlugins];
+}
+// ─── 自动注册入口 ───────────────────────────────────────────────
+/**
+ * 自动发现渠道插件。
+ * 扫描 channels/plugins 下的子目录中导出的 channelPlugin 常量。
+ */
+export async function discoverPlugins() {
+    const fs = await import('node:fs/promises');
+    const path = await import('node:path');
+    const fileUrl = await import('node:url');
+    const pluginsDir = path.join(path.dirname(fileUrl.fileURLToPath(import.meta.url)), 'plugins');
+    try {
+        const entries = await fs.readdir(pluginsDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            try {
+                const mod = await import(`./plugins/${entry.name}/index.js`);
+                if (mod.channelPlugin && typeof mod.channelPlugin.autoRegister === 'function') {
+                    channelPlugins.push(mod.channelPlugin);
+                }
+            }
+            catch {
+                // 插件加载失败，跳过
+            }
+        }
+    }
+    catch {
+        // plugins 目录不存在，跳过
+    }
+}
+/**
+ * 根据 config.json 注册所有配置驱动渠道。
+ * 不负责启动——由调用方通过 channelManager.startAll() 统一启动。
+ *
+ * @returns 已注册的渠道信息列表（用于注入到 System Prompt）
+ */
+export async function registerConfigChannels(channelManager, cwd) {
+    // 自动发现插件（如果尚未手动注册）
+    if (channelPlugins.length === 0) {
+        await discoverPlugins();
+    }
+    const channelsInfo = [];
+    const configManager = new ConfigManager(cwd);
+    await configManager.loadEnvKeys();
+    const agentConfig = await configManager.load();
+    for (const plugin of channelPlugins) {
+        const config = agentConfig.channels?.[plugin.configKey];
+        await plugin.autoRegister(channelManager, config, channelsInfo);
+    }
+    return channelsInfo;
+}
+//# sourceMappingURL=auto-detect.js.map

package/dist/channels/builtin/http-webhook.d.ts

@@ -0,0 +1,25 @@
+import type { ChannelHandler, ChannelEvent, ChannelReply, ChannelConfig, ChannelStatus } from '../interface.js';
+export declare class HttpWebhookChannel implements ChannelHandler {
+    readonly id = "http-webhook";
+    readonly name = "HTTP Webhook";
+    readonly description = "\u5185\u5EFA HTTP REST API \u6E20\u9053\uFF0C\u652F\u6301 POST /api/chat webhook \u63A5\u5165\uFF08Bearer Token \u8BA4\u8BC1\uFF09";
+    readonly pluginId: undefined;
+    private app;
+    private status;
+    private eventHandler;
+    private provider;
+    private sessionManager;
+    private cwd;
+    private maxTurns;
+    private maxContext;
+    private activeComponents;
+    private wsAgentFactory;
+    start(config: ChannelConfig): Promise<void>;
+    stop(): Promise<void>;
+    onEvent(handler: (event: ChannelEvent) => Promise<void>): void;
+    reply(_sessionId: string, _reply: ChannelReply): Promise<void>;
+    getStatus(): ChannelStatus;
+    handleMessage(): Promise<void>;
+    private ensureComponents;
+}
+//# sourceMappingURL=http-webhook.d.ts.map

package/dist/channels/builtin/http-webhook.js

@@ -0,0 +1,287 @@
+// ============================================================
+// HttpWebhookChannel — 内建 HTTP REST API 渠道（企业加固版）
+// ============================================================
+//
+// 端点：/api/health, /api/chat, /api/sessions, /api/tools, /api/skills
+// 认证：Bearer Token（HYACINTH_API_KEY 环境变量或 --api-key 参数）
+// Chat 为同步 request-response 模式。
+// ============================================================
+import { createLogger } from '../../logging/logger.js';
+import { getModelContextWindow } from '../../setup/model-defaults.js';
+import { getDefaultConfig } from '../../runtime/defaults.js';
+const logger = createLogger('http-webhook');
+// ── 认证 ────────────────────────────────────────────────────────────
+function getApiKey(config) {
+    return config.apiKey
+        || process.env.HYACINTH_API_KEY
+        || process.env.AGENT_API_KEY
+        || null;
+}
+function authHook(apiKey) {
+    return async (req, reply) => {
+        // /api/health 无需认证
+        if (req.url === '/api/health')
+            return;
+        if (!apiKey) {
+            return reply.status(401).send({
+                error: 'API key not configured. Set HYACINTH_API_KEY environment variable or pass --api-key.',
+            });
+        }
+        const auth = req.headers['authorization'] ?? '';
+        const bearer = auth.startsWith('Bearer ') ? auth.slice(7) : '';
+        if (bearer !== apiKey) {
+            return reply.status(401).send({ error: 'Invalid or missing API key. Use Authorization: Bearer <key>' });
+        }
+    };
+}
+// ── CollectHandler ────────────────────────────────────────────────
+/** 收集 agent 输出的 handler */
+class CollectHandler {
+    texts = [];
+    toolCalls = [];
+    statusMessages = [];
+    onText(content) { this.texts.push(content); }
+    onThinking(_content) { }
+    onToolUse(name, inputSummary) {
+        this.toolCalls.push({ name, input: inputSummary, isError: false, result: '' });
+    }
+    onToolResult(content, isError) {
+        const last = this.toolCalls.length > 0 ? this.toolCalls[this.toolCalls.length - 1] : undefined;
+        if (last && !last.result) {
+            last.isError = isError;
+            last.result = content;
+        }
+    }
+    onStatus(message, _level) { this.statusMessages.push(message); }
+    onTurnStart() { }
+    onFlush() { }
+    onInterrupt() { }
+    onPermissionRequest(toolName, input) {
+        void toolName;
+        void input;
+        return Promise.resolve(true);
+    }
+    getFullText() {
+        return this.texts.join('\n');
+    }
+}
+// ── HttpWebhookChannel ───────────────────────────────────────────
+export class HttpWebhookChannel {
+    id = 'http-webhook';
+    name = 'HTTP Webhook';
+    description = '内建 HTTP REST API 渠道，支持 POST /api/chat webhook 接入（Bearer Token 认证）';
+    pluginId = undefined;
+    app = null;
+    status = 'registered';
+    eventHandler = null;
+    provider;
+    sessionManager;
+    cwd;
+    maxTurns;
+    maxContext;
+    activeComponents = null;
+    wsAgentFactory = null;
+    async start(config) {
+        const { port = 3000, host = '0.0.0.0' } = config;
+        // 从 config 获取 agentFactory（由 ChannelManager.startChannel 注入）
+        this.wsAgentFactory = config.agentFactory ?? null;
+        this.provider = config.provider;
+        this.sessionManager = config.sessionManager;
+        this.cwd = config.cwd;
+        this.maxTurns = config.maxTurns ?? getDefaultConfig().session.maxTurns;
+        this.maxContext = config.maxContext ?? getModelContextWindow(this.provider.getProviderType(), this.provider.getModel());
+        const apiKey = getApiKey(config);
+        if (!apiKey) {
+            logger.warn('No HYACINTH_API_KEY set — HTTP API will reject all requests except /api/health. Set the environment variable or use --api-key.');
+        }
+        const fastify = (await import('fastify')).default;
+        this.app = fastify({ logger: false });
+        // ── 安全加固（全路由）───────────────────────────────────────────
+        this.app.addHook('preHandler', authHook(apiKey));
+        this.app.addHook('onSend', async (_req, reply) => {
+            reply.header('X-Content-Type-Options', 'nosniff');
+            reply.header('X-Frame-Options', 'DENY');
+            reply.header('X-XSS-Protection', '1; mode=block');
+            reply.header('Access-Control-Allow-Origin', config.corsOrigin || '*');
+            reply.header('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
+            reply.header('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+        });
+        // OPTIONS preflight
+        this.app.options('*', async (_req, reply) => {
+            return reply.status(204).send();
+        });
+        // ── Health ──────────────────────────────────────────────────
+        this.app.get('/api/health', async (_req, reply) => {
+            return reply.send({ status: 'ok', version: '1.0.0', auth: !!apiKey });
+        });
+        // ── Chat ────────────────────────────────────────────────────
+        this.app.post('/api/chat', async (req, reply) => {
+            const body = req.body;
+            if (!body.message) {
+                return reply.status(400).send({ error: 'message is required' });
+            }
+            const handler = new CollectHandler();
+            try {
+                const { createAgent } = await import('../../gateway/factory.js');
+                const { loop, sessionDir } = await createAgent({
+                    cwd: this.cwd,
+                    provider: this.provider,
+                    maxTurns: this.maxTurns,
+                    maxContext: this.maxContext,
+                    outputHandler: handler,
+                    sessionId: body.sessionId,
+                    shouldContinue: !body.sessionId,
+                });
+                if (body.images?.length)
+                    loop.channelImages = body.images;
+                await loop.run(body.message);
+                const sessionId = sessionDir.split(/[\\/]/).pop() ?? '';
+                if (this.eventHandler) {
+                    this.eventHandler({
+                        type: 'message',
+                        sessionId,
+                        userId: 'http-user',
+                        content: body.message,
+                        channel: this.id,
+                        metadata: { source: 'http-webhook' },
+                    }).catch(() => { });
+                }
+                return reply.send({
+                    sessionId,
+                    content: handler.getFullText(),
+                    turns: handler.toolCalls.length,
+                    toolCalls: handler.toolCalls.map(t => ({ name: t.name, input: t.input })),
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                logger.error('Chat error', undefined, { error: message });
+                return reply.status(500).send({ error: message });
+            }
+        });
+        // ── Sessions ────────────────────────────────────────────────
+        this.app.get('/api/sessions', async (_req, reply) => {
+            const sessions = await this.sessionManager.list();
+            return reply.send(sessions);
+        });
+        this.app.post('/api/sessions', async (_req, reply) => {
+            const session = await this.sessionManager.create('normal', 'http-webhook');
+            return reply.send({ id: session.id, createdAt: session.createdAt });
+        });
+        this.app.get('/api/sessions/:id', async (req, reply) => {
+            const { id } = req.params;
+            try {
+                const session = await this.sessionManager.resume(id);
+                return reply.send({ id: session.id, createdAt: session.createdAt });
+            }
+            catch {
+                return reply.status(404).send({ error: 'Session not found' });
+            }
+        });
+        this.app.delete('/api/sessions/:id', async (req, reply) => {
+            const { id } = req.params;
+            try {
+                const fs = await import('node:fs/promises');
+                const path = await import('node:path');
+                const os = await import('node:os');
+                const sessionDir = path.join(os.homedir(), '.agent', 'sessions', id);
+                await fs.rm(sessionDir, { recursive: true, force: true });
+                return reply.send({ ok: true });
+            }
+            catch {
+                return reply.status(404).send({ error: 'Session not found' });
+            }
+        });
+        // ── Tools & Skills ──────────────────────────────────────────
+        this.app.get('/api/tools', async (_req, reply) => {
+            const components = await this.ensureComponents();
+            const tools = components.toolRegistry.getAll().map(t => ({
+                name: t.name,
+                description: t.description,
+            }));
+            return reply.send(tools);
+        });
+        this.app.get('/api/skills', async (_req, reply) => {
+            const components = await this.ensureComponents();
+            const skills = components.skillRegistry.getAll().map(s => ({
+                name: s.name,
+                description: s.description,
+                source: s.source,
+            }));
+            return reply.send(skills);
+        });
+        // ── TUI WebSocket 端点（让 TUI 客户端通过 ws://host:port/tui 连接统一后端） ─
+        const { WebSocketServer } = await import('ws');
+        const { TuiWsSession } = await import('./tui-ws-session.js');
+        const { randomBytes } = await import('node:crypto');
+        const tuiWss = new WebSocketServer({ noServer: true });
+        this.app.server.on('upgrade', (request, socket, head) => {
+            if (request.url === '/tui') {
+                tuiWss.handleUpgrade(request, socket, head, (ws) => {
+                    tuiWss.emit('connection', ws, request);
+                });
+            }
+            else {
+                socket.destroy();
+            }
+        });
+        tuiWss.on('connection', (ws) => {
+            const sessionId = `tui_${Date.now().toString(36)}-${randomBytes(3).toString('hex')}`;
+            const session = new TuiWsSession(ws, sessionId);
+            logger.info('TUI WS client connected', { sessionId });
+            if (this.wsAgentFactory) {
+                session.initialize(this.wsAgentFactory).catch((err) => {
+                    logger.error('TUI WS init failed', err instanceof Error ? err : new Error(String(err)));
+                });
+            }
+            else {
+                logger.warn('TUI WS agentFactory not available');
+            }
+            ws.on('message', (data) => {
+                session.handleMessage(data).catch((err) => {
+                    logger.error('TUI WS msg error', err instanceof Error ? err : new Error(String(err)));
+                });
+            });
+            ws.on('close', () => {
+                session.close().catch(() => { });
+                logger.info('TUI WS client disconnected', { sessionId });
+            });
+        });
+        // ── Start ───────────────────────────────────────────────────
+        await this.app.listen({ port: port, host: host });
+        this.status = 'active';
+        logger.info(`HTTP API listening on ${host}:${port}${apiKey ? ' (auth enabled)' : ' (auth: only /api/health)'}`);
+    }
+    async stop() {
+        if (this.app) {
+            await this.app.close();
+            this.app = null;
+        }
+        this.status = 'stopped';
+    }
+    onEvent(handler) {
+        this.eventHandler = handler;
+    }
+    async reply(_sessionId, _reply) {
+        // HTTP webhook 模式下回复已在 POST /api/chat 响应中同步返回
+    }
+    getStatus() { return this.status; }
+    async handleMessage() {
+        throw new Error('HTTP webhook channel does not support handleMessage');
+    }
+    async ensureComponents() {
+        if (!this.activeComponents) {
+            const { createAgent } = await import('../../gateway/factory.js');
+            const handler = new CollectHandler();
+            this.activeComponents = await createAgent({
+                cwd: this.cwd,
+                provider: this.provider,
+                maxTurns: this.maxTurns,
+                maxContext: this.maxContext,
+                outputHandler: handler,
+            });
+        }
+        return this.activeComponents;
+    }
+}
+//# sourceMappingURL=http-webhook.js.map