opc-agent 1.0.0 → 1.1.0

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 All notable changes to OPC Agent will be documented in this file.
 
+## [1.1.0] - 2026-04-16
+
+### Added
+- **Feishu/Lark Channel**: Full Feishu bot integration with event subscription webhook, tenant access token caching, text & interactive card messaging, group + P2P support. Also works with Lark international via `apiBase` config. (`src/channels/feishu.ts`)
+- **Discord Channel**: Discord bot via Gateway WebSocket with auto-reconnect, heartbeat, message content intent, and 2000-char message splitting. (`src/channels/discord.ts`)
+- **ProcessWatcher**: Background process output monitoring with regex pattern matching — watch stdout/stderr for specific patterns (errors, "server ready", build completion) and get instant callbacks without polling. Supports `once` patterns, match history, and dynamic pattern add/remove. Inspired by Hermes Agent's `watch_patterns`. (`src/core/watch.ts`)
+
 ## [0.2.0] - 2026-04-15
 
 ### Added

package/dist/channels/discord.d.ts

@@ -0,0 +1,44 @@
+import { BaseChannel } from './index';
+/**
+ * Discord Channel — v1.1.0
+ *
+ * Supports:
+ * - Discord Bot via Gateway (WebSocket) or HTTP interactions
+ * - Slash commands, message content intent
+ * - Thread-based conversations
+ * - Reactions, embeds
+ *
+ * Env vars:
+ *   DISCORD_BOT_TOKEN — bot token
+ *   DISCORD_APPLICATION_ID — application ID for slash commands
+ */
+export interface DiscordChannelConfig {
+    /** Bot token */
+    botToken?: string;
+    /** Application ID */
+    applicationId?: string;
+    /** Guild IDs to register slash commands (empty = global) */
+    guildIds?: string[];
+    /** Whether to use threads for conversations */
+    useThreads?: boolean;
+}
+export declare class DiscordChannel extends BaseChannel {
+    readonly type = "discord";
+    private config;
+    private ws;
+    private heartbeatInterval;
+    private sequenceNumber;
+    private sessionId;
+    private resumeUrl;
+    constructor(config?: DiscordChannelConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private identify;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private sendHeartbeat;
+    private handleMessage;
+    sendMessage(channelId: string, content: string): Promise<void>;
+    private splitMessage;
+}
+//# sourceMappingURL=discord.d.ts.map

package/dist/channels/discord.js

@@ -0,0 +1,189 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscordChannel = void 0;
+const index_1 = require("./index");
+class DiscordChannel extends index_1.BaseChannel {
+    type = 'discord';
+    config;
+    ws = null;
+    heartbeatInterval = null;
+    sequenceNumber = null;
+    sessionId = null;
+    resumeUrl = null;
+    constructor(config = {}) {
+        super();
+        this.config = {
+            botToken: config.botToken ?? process.env.DISCORD_BOT_TOKEN ?? '',
+            applicationId: config.applicationId ?? process.env.DISCORD_APPLICATION_ID ?? '',
+            guildIds: config.guildIds ?? [],
+            useThreads: config.useThreads ?? true,
+        };
+    }
+    async start() {
+        if (!this.config.botToken) {
+            console.warn('[DiscordChannel] No bot token. Set DISCORD_BOT_TOKEN.');
+            return;
+        }
+        // Get gateway URL
+        const gatewayResp = await fetch('https://discord.com/api/v10/gateway/bot', {
+            headers: { Authorization: `Bot ${this.config.botToken}` },
+        });
+        const gatewayData = await gatewayResp.json();
+        const wsUrl = `${gatewayData.url}?v=10&encoding=json`;
+        const { WebSocket } = await Promise.resolve().then(() => __importStar(require('ws')));
+        this.ws = new WebSocket(wsUrl);
+        this.ws.on('message', async (data) => {
+            const payload = JSON.parse(data.toString());
+            this.sequenceNumber = payload.s ?? this.sequenceNumber;
+            switch (payload.op) {
+                case 10: // Hello
+                    this.startHeartbeat(payload.d.heartbeat_interval);
+                    this.identify();
+                    break;
+                case 11: // Heartbeat ACK
+                    break;
+                case 0: // Dispatch
+                    if (payload.t === 'READY') {
+                        this.sessionId = payload.d.session_id;
+                        this.resumeUrl = payload.d.resume_gateway_url;
+                        console.log(`[DiscordChannel] Connected as ${payload.d.user.username}`);
+                    }
+                    else if (payload.t === 'MESSAGE_CREATE') {
+                        await this.handleMessage(payload.d);
+                    }
+                    break;
+            }
+        });
+        this.ws.on('close', (code) => {
+            console.log(`[DiscordChannel] WebSocket closed: ${code}`);
+            this.stopHeartbeat();
+            // Auto-reconnect after 5s for resumable codes
+            if (code !== 4004 && code !== 4014) {
+                setTimeout(() => this.start(), 5000);
+            }
+        });
+        this.ws.on('error', (err) => {
+            console.error('[DiscordChannel] WebSocket error:', err.message);
+        });
+    }
+    async stop() {
+        this.stopHeartbeat();
+        if (this.ws) {
+            this.ws.close(1000);
+            this.ws = null;
+        }
+    }
+    identify() {
+        this.ws?.send(JSON.stringify({
+            op: 2,
+            d: {
+                token: this.config.botToken,
+                intents: (1 << 9) | (1 << 15), // GUILD_MESSAGES | MESSAGE_CONTENT
+                properties: {
+                    os: process.platform,
+                    browser: 'opc-agent',
+                    device: 'opc-agent',
+                },
+            },
+        }));
+    }
+    startHeartbeat(intervalMs) {
+        this.stopHeartbeat();
+        // Send first heartbeat with jitter
+        setTimeout(() => {
+            this.sendHeartbeat();
+            this.heartbeatInterval = setInterval(() => this.sendHeartbeat(), intervalMs);
+        }, intervalMs * Math.random());
+    }
+    stopHeartbeat() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+        }
+    }
+    sendHeartbeat() {
+        this.ws?.send(JSON.stringify({ op: 1, d: this.sequenceNumber }));
+    }
+    async handleMessage(d) {
+        // Ignore bot messages
+        const author = d.author;
+        if (author?.bot)
+            return;
+        if (!d.content || !this.handler)
+            return;
+        const msg = {
+            id: `discord_${d.id}`,
+            role: 'user',
+            content: d.content,
+            timestamp: new Date(d.timestamp).getTime(),
+            metadata: {
+                sessionId: `discord_${d.channel_id}`,
+                chatId: d.channel_id,
+                userId: author.id,
+                platform: 'discord',
+                guildId: d.guild_id,
+                threadId: d.thread?.toString(),
+            },
+        };
+        const response = await this.handler(msg);
+        await this.sendMessage(d.channel_id, response.content);
+    }
+    async sendMessage(channelId, content) {
+        // Discord max message length is 2000
+        const chunks = this.splitMessage(content, 2000);
+        for (const chunk of chunks) {
+            await fetch(`https://discord.com/api/v10/channels/${channelId}/messages`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bot ${this.config.botToken}`,
+                },
+                body: JSON.stringify({ content: chunk }),
+            });
+        }
+    }
+    splitMessage(text, maxLen) {
+        if (text.length <= maxLen)
+            return [text];
+        const parts = [];
+        for (let i = 0; i < text.length; i += maxLen) {
+            parts.push(text.slice(i, i + maxLen));
+        }
+        return parts;
+    }
+}
+exports.DiscordChannel = DiscordChannel;
+//# sourceMappingURL=discord.js.map

package/dist/channels/feishu.d.ts

@@ -0,0 +1,47 @@
+import { BaseChannel } from './index';
+/**
+ * Feishu / Lark Channel — v1.1.0
+ *
+ * Supports:
+ * - Event Subscription (webhook) mode for receiving messages
+ * - Bot send via Feishu Open API
+ * - URL verification challenge
+ * - Message card (interactive) responses
+ * - Group chat & P2P messaging
+ *
+ * Env vars:
+ *   FEISHU_APP_ID, FEISHU_APP_SECRET — app credentials
+ *   FEISHU_VERIFICATION_TOKEN — event subscription verification
+ *   FEISHU_ENCRYPT_KEY — (optional) event encryption key
+ */
+export interface FeishuChannelConfig {
+    /** Feishu App ID */
+    appId?: string;
+    /** Feishu App Secret */
+    appSecret?: string;
+    /** Verification token for event subscription */
+    verificationToken?: string;
+    /** Encrypt key (optional, for encrypted events) */
+    encryptKey?: string;
+    /** Webhook server port (default: 3002) */
+    port?: number;
+    /** API base URL (use 'https://open.larksuite.com' for Lark international) */
+    apiBase?: string;
+}
+export declare class FeishuChannel extends BaseChannel {
+    readonly type = "feishu";
+    private config;
+    private server;
+    private tokenCache;
+    private processedEvents;
+    constructor(config?: FeishuChannelConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /** Get tenant access token (cached) */
+    private getAccessToken;
+    /** Send a text message to a chat */
+    sendTextMessage(chatId: string, text: string): Promise<void>;
+    /** Send an interactive card message */
+    sendCardMessage(chatId: string, card: Record<string, unknown>): Promise<void>;
+}
+//# sourceMappingURL=feishu.d.ts.map

package/dist/channels/feishu.js

@@ -0,0 +1,221 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeishuChannel = void 0;
+const index_1 = require("./index");
+class FeishuChannel extends index_1.BaseChannel {
+    type = 'feishu';
+    config;
+    server = null;
+    tokenCache = null;
+    processedEvents = new Set();
+    constructor(config = {}) {
+        super();
+        this.config = {
+            appId: config.appId ?? process.env.FEISHU_APP_ID ?? '',
+            appSecret: config.appSecret ?? process.env.FEISHU_APP_SECRET ?? '',
+            verificationToken: config.verificationToken ?? process.env.FEISHU_VERIFICATION_TOKEN ?? '',
+            encryptKey: config.encryptKey ?? process.env.FEISHU_ENCRYPT_KEY,
+            port: config.port ?? 3002,
+            apiBase: config.apiBase ?? 'https://open.feishu.cn',
+        };
+    }
+    async start() {
+        if (!this.config.appId || !this.config.appSecret) {
+            console.warn('[FeishuChannel] Missing appId/appSecret. Set FEISHU_APP_ID and FEISHU_APP_SECRET.');
+            return;
+        }
+        const express = (await Promise.resolve().then(() => __importStar(require('express')))).default;
+        const app = express();
+        app.use(express.json());
+        // Event subscription endpoint
+        app.post('/feishu/event', async (req, res) => {
+            try {
+                const body = req.body;
+                // URL verification challenge
+                if (body.type === 'url_verification') {
+                    res.json({ challenge: body.challenge });
+                    return;
+                }
+                // Deduplicate events
+                const eventId = body.header?.event_id;
+                if (eventId && this.processedEvents.has(eventId)) {
+                    res.json({ ok: true });
+                    return;
+                }
+                if (eventId) {
+                    this.processedEvents.add(eventId);
+                    // Prune old events (keep last 1000)
+                    if (this.processedEvents.size > 1000) {
+                        const arr = [...this.processedEvents];
+                        this.processedEvents = new Set(arr.slice(-500));
+                    }
+                }
+                // Verify token
+                if (this.config.verificationToken && body.header?.token !== this.config.verificationToken) {
+                    res.status(403).json({ error: 'Invalid verification token' });
+                    return;
+                }
+                // Handle im.message.receive_v1
+                const event = body.event;
+                if (body.header?.event_type === 'im.message.receive_v1' && this.handler) {
+                    const msgBody = event?.message;
+                    if (!msgBody) {
+                        res.json({ ok: true });
+                        return;
+                    }
+                    // Only handle text messages for now
+                    const msgType = msgBody.message_type;
+                    let content = '';
+                    if (msgType === 'text') {
+                        try {
+                            const parsed = JSON.parse(msgBody.content);
+                            content = parsed.text ?? '';
+                        }
+                        catch {
+                            content = msgBody.content ?? '';
+                        }
+                    }
+                    else {
+                        // Acknowledge non-text silently
+                        res.json({ ok: true });
+                        return;
+                    }
+                    // Strip @bot mentions
+                    content = content.replace(/@_user_\d+/g, '').trim();
+                    if (!content) {
+                        res.json({ ok: true });
+                        return;
+                    }
+                    const chatId = msgBody.chat_id;
+                    const senderId = event.sender?.sender_id?.open_id ?? 'unknown';
+                    const msg = {
+                        id: `feishu_${msgBody.message_id}`,
+                        role: 'user',
+                        content,
+                        timestamp: parseInt(msgBody.create_time, 10) || Date.now(),
+                        metadata: {
+                            sessionId: `feishu_${chatId}`,
+                            chatId,
+                            userId: senderId,
+                            platform: 'feishu',
+                            messageId: msgBody.message_id,
+                            chatType: msgBody.chat_type, // 'p2p' or 'group'
+                        },
+                    };
+                    const response = await this.handler(msg);
+                    await this.sendTextMessage(chatId, response.content);
+                }
+                res.json({ ok: true });
+            }
+            catch (err) {
+                console.error('[FeishuChannel] Error handling event:', err);
+                res.status(500).json({ error: 'Internal error' });
+            }
+        });
+        app.get('/health', (_req, res) => {
+            res.json({ status: 'ok', channel: 'feishu' });
+        });
+        this.server = app.listen(this.config.port, () => {
+            console.log(`[FeishuChannel] Listening on port ${this.config.port}`);
+        });
+    }
+    async stop() {
+        if (this.server) {
+            this.server.close();
+            this.server = null;
+        }
+    }
+    /** Get tenant access token (cached) */
+    async getAccessToken() {
+        if (this.tokenCache && Date.now() < this.tokenCache.expiresAt) {
+            return this.tokenCache.token;
+        }
+        const resp = await fetch(`${this.config.apiBase}/open-apis/auth/v3/tenant_access_token/internal`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                app_id: this.config.appId,
+                app_secret: this.config.appSecret,
+            }),
+        });
+        const data = await resp.json();
+        if (data.code !== 0) {
+            throw new Error(`[FeishuChannel] Failed to get access token: ${JSON.stringify(data)}`);
+        }
+        this.tokenCache = {
+            token: data.tenant_access_token,
+            expiresAt: Date.now() + (data.expire - 60) * 1000, // refresh 60s early
+        };
+        return this.tokenCache.token;
+    }
+    /** Send a text message to a chat */
+    async sendTextMessage(chatId, text) {
+        const token = await this.getAccessToken();
+        const resp = await fetch(`${this.config.apiBase}/open-apis/im/v1/messages?receive_id_type=chat_id`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${token}`,
+            },
+            body: JSON.stringify({
+                receive_id: chatId,
+                msg_type: 'text',
+                content: JSON.stringify({ text }),
+            }),
+        });
+        if (!resp.ok) {
+            console.error('[FeishuChannel] Failed to send message:', await resp.text());
+        }
+    }
+    /** Send an interactive card message */
+    async sendCardMessage(chatId, card) {
+        const token = await this.getAccessToken();
+        await fetch(`${this.config.apiBase}/open-apis/im/v1/messages?receive_id_type=chat_id`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${token}`,
+            },
+            body: JSON.stringify({
+                receive_id: chatId,
+                msg_type: 'interactive',
+                content: JSON.stringify(card),
+            }),
+        });
+    }
+}
+exports.FeishuChannel = FeishuChannel;
+//# sourceMappingURL=feishu.js.map

package/dist/core/watch.d.ts

@@ -0,0 +1,73 @@
+import { EventEmitter } from 'events';
+/**
+ * ProcessWatcher — Background process output monitoring with pattern matching.
+ *
+ * Inspired by Hermes Agent's watch_patterns feature.
+ * Set patterns to watch for in background process output and get callbacks
+ * when they match — no polling needed.
+ *
+ * Usage:
+ *   const watcher = new ProcessWatcher();
+ *   watcher.watch(childProcess.stdout, {
+ *     patterns: [
+ *       { regex: /listening on port (\d+)/, label: 'server-ready' },
+ *       { regex: /error|Error|ERROR/, label: 'error-detected' },
+ *       { regex: /build completed/, label: 'build-done', once: true },
+ *     ],
+ *     onMatch: (match) => console.log(`[${match.label}] ${match.line}`),
+ *   });
+ */
+export interface WatchPattern {
+    /** Regex to match against each line of output */
+    regex: RegExp;
+    /** Human-readable label for this pattern */
+    label: string;
+    /** If true, auto-remove after first match */
+    once?: boolean;
+}
+export interface WatchMatch {
+    /** Pattern label */
+    label: string;
+    /** The full line that matched */
+    line: string;
+    /** Regex match groups */
+    groups: string[];
+    /** Timestamp of match */
+    timestamp: number;
+    /** Stream source */
+    stream: 'stdout' | 'stderr';
+}
+export interface WatchOptions {
+    /** Patterns to match */
+    patterns: WatchPattern[];
+    /** Callback on match */
+    onMatch: (match: WatchMatch) => void;
+    /** Optional: max matches to keep in history (default: 100) */
+    maxHistory?: number;
+}
+export declare class ProcessWatcher extends EventEmitter {
+    private watchers;
+    private watcherIdCounter;
+    /**
+     * Start watching a readable stream for patterns.
+     * Returns a watcher ID that can be used to stop watching.
+     */
+    watch(stream: NodeJS.ReadableStream, options: WatchOptions, streamName?: 'stdout' | 'stderr'): string;
+    /**
+     * Watch both stdout and stderr of a ChildProcess.
+     */
+    watchProcess(proc: {
+        stdout?: NodeJS.ReadableStream | null;
+        stderr?: NodeJS.ReadableStream | null;
+    }, options: WatchOptions): string[];
+    /** Stop a specific watcher */
+    unwatch(id: string): void;
+    /** Get match history for a watcher */
+    getHistory(id: string): WatchMatch[];
+    /** Add a pattern to an existing watcher */
+    addPattern(id: string, pattern: WatchPattern): void;
+    /** Remove a pattern by label from a watcher */
+    removePattern(id: string, label: string): void;
+    private matchLine;
+}
+//# sourceMappingURL=watch.d.ts.map

package/dist/core/watch.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessWatcher = void 0;
+const events_1 = require("events");
+class ProcessWatcher extends events_1.EventEmitter {
+    watchers = new Map();
+    watcherIdCounter = 0;
+    /**
+     * Start watching a readable stream for patterns.
+     * Returns a watcher ID that can be used to stop watching.
+     */
+    watch(stream, options, streamName = 'stdout') {
+        const id = `watcher_${++this.watcherIdCounter}`;
+        const state = {
+            patterns: [...options.patterns],
+            onMatch: options.onMatch,
+            history: [],
+            maxHistory: options.maxHistory ?? 100,
+        };
+        this.watchers.set(id, state);
+        let buffer = '';
+        const onData = (chunk) => {
+            buffer += chunk.toString();
+            const lines = buffer.split('\n');
+            buffer = lines.pop() ?? ''; // Keep incomplete line in buffer
+            for (const line of lines) {
+                this.matchLine(id, line, streamName);
+            }
+        };
+        stream.on('data', onData);
+        stream.on('end', () => {
+            // Process remaining buffer
+            if (buffer)
+                this.matchLine(id, buffer, streamName);
+            this.watchers.delete(id);
+            this.emit('watcher:end', id);
+        });
+        return id;
+    }
+    /**
+     * Watch both stdout and stderr of a ChildProcess.
+     */
+    watchProcess(proc, options) {
+        const ids = [];
+        if (proc.stdout)
+            ids.push(this.watch(proc.stdout, options, 'stdout'));
+        if (proc.stderr)
+            ids.push(this.watch(proc.stderr, options, 'stderr'));
+        return ids;
+    }
+    /** Stop a specific watcher */
+    unwatch(id) {
+        this.watchers.delete(id);
+    }
+    /** Get match history for a watcher */
+    getHistory(id) {
+        return this.watchers.get(id)?.history ?? [];
+    }
+    /** Add a pattern to an existing watcher */
+    addPattern(id, pattern) {
+        const state = this.watchers.get(id);
+        if (state)
+            state.patterns.push(pattern);
+    }
+    /** Remove a pattern by label from a watcher */
+    removePattern(id, label) {
+        const state = this.watchers.get(id);
+        if (state) {
+            state.patterns = state.patterns.filter(p => p.label !== label);
+        }
+    }
+    matchLine(watcherId, line, stream) {
+        const state = this.watchers.get(watcherId);
+        if (!state)
+            return;
+        const toRemove = [];
+        for (let i = 0; i < state.patterns.length; i++) {
+            const pattern = state.patterns[i];
+            const m = line.match(pattern.regex);
+            if (m) {
+                const match = {
+                    label: pattern.label,
+                    line,
+                    groups: m.slice(1),
+                    timestamp: Date.now(),
+                    stream,
+                };
+                state.history.push(match);
+                if (state.history.length > state.maxHistory) {
+                    state.history.shift();
+                }
+                state.onMatch(match);
+                this.emit('match', match);
+                if (pattern.once) {
+                    toRemove.push(i);
+                }
+            }
+        }
+        // Remove once-patterns in reverse order
+        for (let i = toRemove.length - 1; i >= 0; i--) {
+            state.patterns.splice(toRemove[i], 1);
+        }
+    }
+}
+exports.ProcessWatcher = ProcessWatcher;
+//# sourceMappingURL=watch.js.map

package/dist/index.d.ts

@@ -85,4 +85,10 @@ export { sanitizeInput, detectInjection, securityHeaders, corsMiddleware, APIKey
 export type { SecurityHeadersConfig, CORSConfig, APIKeyEntry } from './core/security';
 export { createLoggingPlugin, createAnalyticsPlugin, createRateLimitPlugin } from './plugins';
 export type { PluginManifest } from './plugins';
+export { FeishuChannel } from './channels/feishu';
+export type { FeishuChannelConfig } from './channels/feishu';
+export { DiscordChannel } from './channels/discord';
+export type { DiscordChannelConfig } from './channels/discord';
+export { ProcessWatcher } from './core/watch';
+export type { WatchPattern, WatchMatch, WatchOptions } from './core/watch';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EmailChannel = exports.compose = exports.AgentPipeline = exports.Orchestrator = exports.getActiveSessions = exports.createAuthMiddleware = exports.installAgent = exports.publishAgent = exports.deployToHermes = exports.KnowledgeBase = exports.addMessages = exports.detectLocale = exports.getLocale = exports.setLocale = exports.t = exports.LazyLoader = exports.RequestBatcher = exports.ConnectionPool = exports.VersionManager = exports.WebhookChannel = exports.VoiceChannel = exports.HITLManager = exports.AgentRegistry = exports.WorkflowEngine = exports.Analytics = exports.Sandbox = exports.PluginManager = exports.createMCPTool = exports.MCPToolRegistry = exports.Room = exports.SUPPORTED_PROVIDERS = exports.createProvider = exports.MRGConfigReader = exports.ValueTracker = exports.TrustManager = exports.DeepBrainMemoryStore = exports.InMemoryStore = exports.SkillRegistry = exports.BaseSkill = exports.WebSocketChannel = exports.TelegramChannel = exports.WebChannel = exports.BaseChannel = exports.OADSchema = exports.validateOAD = exports.loadOAD = exports.Logger = exports.truncateOutput = exports.AgentRuntime = exports.BaseAgent = void 0;
-exports.createRateLimitPlugin = exports.createAnalyticsPlugin = exports.createLoggingPlugin = exports.inputValidation = exports.APIKeyManager = exports.corsMiddleware = exports.securityHeaders = exports.detectInjection = exports.sanitizeInput = exports.formatErrorForUser = exports.wrapError = exports.TimeoutError = exports.SecurityError = exports.RateLimitError = exports.PluginError = exports.ChannelError = exports.ConfigError = exports.ValidationError = exports.ProviderError = exports.OPCError = exports.createTeacherConfig = exports.createDataAnalystConfig = exports.getSupportedLocales = exports.LLMCache = exports.RateLimiter = exports.AnalyticsEngine = exports.formatReport = exports.loadTestCases = exports.runTests = exports.DocumentSkill = exports.SchedulerSkill = exports.WebhookTriggerSkill = exports.HttpSkill = exports.TextAnalysisTool = exports.JsonTransformTool = exports.DateTimeTool = exports.CalculatorTool = exports.WeChatChannel = exports.SlackChannel = void 0;
+exports.ProcessWatcher = exports.DiscordChannel = exports.FeishuChannel = exports.createRateLimitPlugin = exports.createAnalyticsPlugin = exports.createLoggingPlugin = exports.inputValidation = exports.APIKeyManager = exports.corsMiddleware = exports.securityHeaders = exports.detectInjection = exports.sanitizeInput = exports.formatErrorForUser = exports.wrapError = exports.TimeoutError = exports.SecurityError = exports.RateLimitError = exports.PluginError = exports.ChannelError = exports.ConfigError = exports.ValidationError = exports.ProviderError = exports.OPCError = exports.createTeacherConfig = exports.createDataAnalystConfig = exports.getSupportedLocales = exports.LLMCache = exports.RateLimiter = exports.AnalyticsEngine = exports.formatReport = exports.loadTestCases = exports.runTests = exports.DocumentSkill = exports.SchedulerSkill = exports.WebhookTriggerSkill = exports.HttpSkill = exports.TextAnalysisTool = exports.JsonTransformTool = exports.DateTimeTool = exports.CalculatorTool = exports.WeChatChannel = exports.SlackChannel = void 0;
 // OPC Agent — Open Agent Framework
 var agent_1 = require("./core/agent");
 Object.defineProperty(exports, "BaseAgent", { enumerable: true, get: function () { return agent_1.BaseAgent; } });
@@ -156,4 +156,11 @@ var plugins_2 = require("./plugins");
 Object.defineProperty(exports, "createLoggingPlugin", { enumerable: true, get: function () { return plugins_2.createLoggingPlugin; } });
 Object.defineProperty(exports, "createAnalyticsPlugin", { enumerable: true, get: function () { return plugins_2.createAnalyticsPlugin; } });
 Object.defineProperty(exports, "createRateLimitPlugin", { enumerable: true, get: function () { return plugins_2.createRateLimitPlugin; } });
+// v1.1.0 modules
+var feishu_1 = require("./channels/feishu");
+Object.defineProperty(exports, "FeishuChannel", { enumerable: true, get: function () { return feishu_1.FeishuChannel; } });
+var discord_1 = require("./channels/discord");
+Object.defineProperty(exports, "DiscordChannel", { enumerable: true, get: function () { return discord_1.DiscordChannel; } });
+var watch_1 = require("./core/watch");
+Object.defineProperty(exports, "ProcessWatcher", { enumerable: true, get: function () { return watch_1.ProcessWatcher; } });
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opc-agent",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Open Agent Framework — Build, test, and run AI Agents for business workstations",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/channels/discord.ts

@@ -0,0 +1,192 @@
+import { BaseChannel } from './index';
+import type { Message } from '../core/types';
+
+/**
+ * Discord Channel — v1.1.0
+ *
+ * Supports:
+ * - Discord Bot via Gateway (WebSocket) or HTTP interactions
+ * - Slash commands, message content intent
+ * - Thread-based conversations
+ * - Reactions, embeds
+ *
+ * Env vars:
+ *   DISCORD_BOT_TOKEN — bot token
+ *   DISCORD_APPLICATION_ID — application ID for slash commands
+ */
+
+export interface DiscordChannelConfig {
+  /** Bot token */
+  botToken?: string;
+  /** Application ID */
+  applicationId?: string;
+  /** Guild IDs to register slash commands (empty = global) */
+  guildIds?: string[];
+  /** Whether to use threads for conversations */
+  useThreads?: boolean;
+}
+
+export class DiscordChannel extends BaseChannel {
+  readonly type = 'discord';
+  private config: DiscordChannelConfig;
+  private ws: import('ws').WebSocket | null = null;
+  private heartbeatInterval: ReturnType<typeof setInterval> | null = null;
+  private sequenceNumber: number | null = null;
+  private sessionId: string | null = null;
+  private resumeUrl: string | null = null;
+
+  constructor(config: DiscordChannelConfig = {}) {
+    super();
+    this.config = {
+      botToken: config.botToken ?? process.env.DISCORD_BOT_TOKEN ?? '',
+      applicationId: config.applicationId ?? process.env.DISCORD_APPLICATION_ID ?? '',
+      guildIds: config.guildIds ?? [],
+      useThreads: config.useThreads ?? true,
+    };
+  }
+
+  async start(): Promise<void> {
+    if (!this.config.botToken) {
+      console.warn('[DiscordChannel] No bot token. Set DISCORD_BOT_TOKEN.');
+      return;
+    }
+
+    // Get gateway URL
+    const gatewayResp = await fetch('https://discord.com/api/v10/gateway/bot', {
+      headers: { Authorization: `Bot ${this.config.botToken}` },
+    });
+    const gatewayData = await gatewayResp.json() as { url: string };
+    const wsUrl = `${gatewayData.url}?v=10&encoding=json`;
+
+    const { WebSocket } = await import('ws');
+    this.ws = new WebSocket(wsUrl);
+
+    this.ws.on('message', async (data: Buffer) => {
+      const payload = JSON.parse(data.toString());
+      this.sequenceNumber = payload.s ?? this.sequenceNumber;
+
+      switch (payload.op) {
+        case 10: // Hello
+          this.startHeartbeat(payload.d.heartbeat_interval);
+          this.identify();
+          break;
+        case 11: // Heartbeat ACK
+          break;
+        case 0: // Dispatch
+          if (payload.t === 'READY') {
+            this.sessionId = payload.d.session_id;
+            this.resumeUrl = payload.d.resume_gateway_url;
+            console.log(`[DiscordChannel] Connected as ${payload.d.user.username}`);
+          } else if (payload.t === 'MESSAGE_CREATE') {
+            await this.handleMessage(payload.d);
+          }
+          break;
+      }
+    });
+
+    this.ws.on('close', (code: number) => {
+      console.log(`[DiscordChannel] WebSocket closed: ${code}`);
+      this.stopHeartbeat();
+      // Auto-reconnect after 5s for resumable codes
+      if (code !== 4004 && code !== 4014) {
+        setTimeout(() => this.start(), 5000);
+      }
+    });
+
+    this.ws.on('error', (err: Error) => {
+      console.error('[DiscordChannel] WebSocket error:', err.message);
+    });
+  }
+
+  async stop(): Promise<void> {
+    this.stopHeartbeat();
+    if (this.ws) {
+      this.ws.close(1000);
+      this.ws = null;
+    }
+  }
+
+  private identify(): void {
+    this.ws?.send(JSON.stringify({
+      op: 2,
+      d: {
+        token: this.config.botToken,
+        intents: (1 << 9) | (1 << 15), // GUILD_MESSAGES | MESSAGE_CONTENT
+        properties: {
+          os: process.platform,
+          browser: 'opc-agent',
+          device: 'opc-agent',
+        },
+      },
+    }));
+  }
+
+  private startHeartbeat(intervalMs: number): void {
+    this.stopHeartbeat();
+    // Send first heartbeat with jitter
+    setTimeout(() => {
+      this.sendHeartbeat();
+      this.heartbeatInterval = setInterval(() => this.sendHeartbeat(), intervalMs);
+    }, intervalMs * Math.random());
+  }
+
+  private stopHeartbeat(): void {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+  }
+
+  private sendHeartbeat(): void {
+    this.ws?.send(JSON.stringify({ op: 1, d: this.sequenceNumber }));
+  }
+
+  private async handleMessage(d: Record<string, unknown>): Promise<void> {
+    // Ignore bot messages
+    const author = d.author as Record<string, unknown>;
+    if (author?.bot) return;
+    if (!d.content || !this.handler) return;
+
+    const msg: Message = {
+      id: `discord_${d.id}`,
+      role: 'user',
+      content: d.content as string,
+      timestamp: new Date(d.timestamp as string).getTime(),
+      metadata: {
+        sessionId: `discord_${d.channel_id}`,
+        chatId: d.channel_id as string,
+        userId: author.id as string,
+        platform: 'discord',
+        guildId: d.guild_id as string | undefined,
+        threadId: (d as Record<string, unknown>).thread?.toString(),
+      },
+    };
+
+    const response = await this.handler(msg);
+    await this.sendMessage(d.channel_id as string, response.content);
+  }
+
+  async sendMessage(channelId: string, content: string): Promise<void> {
+    // Discord max message length is 2000
+    const chunks = this.splitMessage(content, 2000);
+    for (const chunk of chunks) {
+      await fetch(`https://discord.com/api/v10/channels/${channelId}/messages`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bot ${this.config.botToken}`,
+        },
+        body: JSON.stringify({ content: chunk }),
+      });
+    }
+  }
+
+  private splitMessage(text: string, maxLen: number): string[] {
+    if (text.length <= maxLen) return [text];
+    const parts: string[] = [];
+    for (let i = 0; i < text.length; i += maxLen) {
+      parts.push(text.slice(i, i + maxLen));
+    }
+    return parts;
+  }
+}

package/src/channels/feishu.ts

@@ -0,0 +1,236 @@
+import { BaseChannel } from './index';
+import type { Message } from '../core/types';
+
+/**
+ * Feishu / Lark Channel — v1.1.0
+ *
+ * Supports:
+ * - Event Subscription (webhook) mode for receiving messages
+ * - Bot send via Feishu Open API
+ * - URL verification challenge
+ * - Message card (interactive) responses
+ * - Group chat & P2P messaging
+ *
+ * Env vars:
+ *   FEISHU_APP_ID, FEISHU_APP_SECRET — app credentials
+ *   FEISHU_VERIFICATION_TOKEN — event subscription verification
+ *   FEISHU_ENCRYPT_KEY — (optional) event encryption key
+ */
+
+export interface FeishuChannelConfig {
+  /** Feishu App ID */
+  appId?: string;
+  /** Feishu App Secret */
+  appSecret?: string;
+  /** Verification token for event subscription */
+  verificationToken?: string;
+  /** Encrypt key (optional, for encrypted events) */
+  encryptKey?: string;
+  /** Webhook server port (default: 3002) */
+  port?: number;
+  /** API base URL (use 'https://open.larksuite.com' for Lark international) */
+  apiBase?: string;
+}
+
+interface FeishuTokenCache {
+  token: string;
+  expiresAt: number;
+}
+
+export class FeishuChannel extends BaseChannel {
+  readonly type = 'feishu';
+  private config: Required<Pick<FeishuChannelConfig, 'port' | 'apiBase'>> & FeishuChannelConfig;
+  private server: import('http').Server | null = null;
+  private tokenCache: FeishuTokenCache | null = null;
+  private processedEvents = new Set<string>();
+
+  constructor(config: FeishuChannelConfig = {}) {
+    super();
+    this.config = {
+      appId: config.appId ?? process.env.FEISHU_APP_ID ?? '',
+      appSecret: config.appSecret ?? process.env.FEISHU_APP_SECRET ?? '',
+      verificationToken: config.verificationToken ?? process.env.FEISHU_VERIFICATION_TOKEN ?? '',
+      encryptKey: config.encryptKey ?? process.env.FEISHU_ENCRYPT_KEY,
+      port: config.port ?? 3002,
+      apiBase: config.apiBase ?? 'https://open.feishu.cn',
+    };
+  }
+
+  async start(): Promise<void> {
+    if (!this.config.appId || !this.config.appSecret) {
+      console.warn('[FeishuChannel] Missing appId/appSecret. Set FEISHU_APP_ID and FEISHU_APP_SECRET.');
+      return;
+    }
+
+    const express = (await import('express')).default;
+    const app = express();
+    app.use(express.json());
+
+    // Event subscription endpoint
+    app.post('/feishu/event', async (req, res) => {
+      try {
+        const body = req.body;
+
+        // URL verification challenge
+        if (body.type === 'url_verification') {
+          res.json({ challenge: body.challenge });
+          return;
+        }
+
+        // Deduplicate events
+        const eventId = body.header?.event_id;
+        if (eventId && this.processedEvents.has(eventId)) {
+          res.json({ ok: true });
+          return;
+        }
+        if (eventId) {
+          this.processedEvents.add(eventId);
+          // Prune old events (keep last 1000)
+          if (this.processedEvents.size > 1000) {
+            const arr = [...this.processedEvents];
+            this.processedEvents = new Set(arr.slice(-500));
+          }
+        }
+
+        // Verify token
+        if (this.config.verificationToken && body.header?.token !== this.config.verificationToken) {
+          res.status(403).json({ error: 'Invalid verification token' });
+          return;
+        }
+
+        // Handle im.message.receive_v1
+        const event = body.event;
+        if (body.header?.event_type === 'im.message.receive_v1' && this.handler) {
+          const msgBody = event?.message;
+          if (!msgBody) { res.json({ ok: true }); return; }
+
+          // Only handle text messages for now
+          const msgType = msgBody.message_type;
+          let content = '';
+          if (msgType === 'text') {
+            try {
+              const parsed = JSON.parse(msgBody.content);
+              content = parsed.text ?? '';
+            } catch {
+              content = msgBody.content ?? '';
+            }
+          } else {
+            // Acknowledge non-text silently
+            res.json({ ok: true });
+            return;
+          }
+
+          // Strip @bot mentions
+          content = content.replace(/@_user_\d+/g, '').trim();
+          if (!content) { res.json({ ok: true }); return; }
+
+          const chatId = msgBody.chat_id;
+          const senderId = event.sender?.sender_id?.open_id ?? 'unknown';
+
+          const msg: Message = {
+            id: `feishu_${msgBody.message_id}`,
+            role: 'user',
+            content,
+            timestamp: parseInt(msgBody.create_time, 10) || Date.now(),
+            metadata: {
+              sessionId: `feishu_${chatId}`,
+              chatId,
+              userId: senderId,
+              platform: 'feishu',
+              messageId: msgBody.message_id,
+              chatType: msgBody.chat_type, // 'p2p' or 'group'
+            },
+          };
+
+          const response = await this.handler(msg);
+          await this.sendTextMessage(chatId, response.content);
+        }
+
+        res.json({ ok: true });
+      } catch (err) {
+        console.error('[FeishuChannel] Error handling event:', err);
+        res.status(500).json({ error: 'Internal error' });
+      }
+    });
+
+    app.get('/health', (_req, res) => {
+      res.json({ status: 'ok', channel: 'feishu' });
+    });
+
+    this.server = app.listen(this.config.port, () => {
+      console.log(`[FeishuChannel] Listening on port ${this.config.port}`);
+    });
+  }
+
+  async stop(): Promise<void> {
+    if (this.server) {
+      this.server.close();
+      this.server = null;
+    }
+  }
+
+  /** Get tenant access token (cached) */
+  private async getAccessToken(): Promise<string> {
+    if (this.tokenCache && Date.now() < this.tokenCache.expiresAt) {
+      return this.tokenCache.token;
+    }
+
+    const resp = await fetch(`${this.config.apiBase}/open-apis/auth/v3/tenant_access_token/internal`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        app_id: this.config.appId,
+        app_secret: this.config.appSecret,
+      }),
+    });
+
+    const data = await resp.json() as { tenant_access_token: string; expire: number; code: number };
+    if (data.code !== 0) {
+      throw new Error(`[FeishuChannel] Failed to get access token: ${JSON.stringify(data)}`);
+    }
+
+    this.tokenCache = {
+      token: data.tenant_access_token,
+      expiresAt: Date.now() + (data.expire - 60) * 1000, // refresh 60s early
+    };
+    return this.tokenCache.token;
+  }
+
+  /** Send a text message to a chat */
+  async sendTextMessage(chatId: string, text: string): Promise<void> {
+    const token = await this.getAccessToken();
+    const resp = await fetch(`${this.config.apiBase}/open-apis/im/v1/messages?receive_id_type=chat_id`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${token}`,
+      },
+      body: JSON.stringify({
+        receive_id: chatId,
+        msg_type: 'text',
+        content: JSON.stringify({ text }),
+      }),
+    });
+
+    if (!resp.ok) {
+      console.error('[FeishuChannel] Failed to send message:', await resp.text());
+    }
+  }
+
+  /** Send an interactive card message */
+  async sendCardMessage(chatId: string, card: Record<string, unknown>): Promise<void> {
+    const token = await this.getAccessToken();
+    await fetch(`${this.config.apiBase}/open-apis/im/v1/messages?receive_id_type=chat_id`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${token}`,
+      },
+      body: JSON.stringify({
+        receive_id: chatId,
+        msg_type: 'interactive',
+        content: JSON.stringify(card),
+      }),
+    });
+  }
+}

package/src/core/watch.ts

@@ -0,0 +1,178 @@
+import { EventEmitter } from 'events';
+
+/**
+ * ProcessWatcher — Background process output monitoring with pattern matching.
+ *
+ * Inspired by Hermes Agent's watch_patterns feature.
+ * Set patterns to watch for in background process output and get callbacks
+ * when they match — no polling needed.
+ *
+ * Usage:
+ *   const watcher = new ProcessWatcher();
+ *   watcher.watch(childProcess.stdout, {
+ *     patterns: [
+ *       { regex: /listening on port (\d+)/, label: 'server-ready' },
+ *       { regex: /error|Error|ERROR/, label: 'error-detected' },
+ *       { regex: /build completed/, label: 'build-done', once: true },
+ *     ],
+ *     onMatch: (match) => console.log(`[${match.label}] ${match.line}`),
+ *   });
+ */
+
+export interface WatchPattern {
+  /** Regex to match against each line of output */
+  regex: RegExp;
+  /** Human-readable label for this pattern */
+  label: string;
+  /** If true, auto-remove after first match */
+  once?: boolean;
+}
+
+export interface WatchMatch {
+  /** Pattern label */
+  label: string;
+  /** The full line that matched */
+  line: string;
+  /** Regex match groups */
+  groups: string[];
+  /** Timestamp of match */
+  timestamp: number;
+  /** Stream source */
+  stream: 'stdout' | 'stderr';
+}
+
+export interface WatchOptions {
+  /** Patterns to match */
+  patterns: WatchPattern[];
+  /** Callback on match */
+  onMatch: (match: WatchMatch) => void;
+  /** Optional: max matches to keep in history (default: 100) */
+  maxHistory?: number;
+}
+
+export class ProcessWatcher extends EventEmitter {
+  private watchers = new Map<string, {
+    patterns: WatchPattern[];
+    onMatch: (match: WatchMatch) => void;
+    history: WatchMatch[];
+    maxHistory: number;
+  }>();
+
+  private watcherIdCounter = 0;
+
+  /**
+   * Start watching a readable stream for patterns.
+   * Returns a watcher ID that can be used to stop watching.
+   */
+  watch(
+    stream: NodeJS.ReadableStream,
+    options: WatchOptions,
+    streamName: 'stdout' | 'stderr' = 'stdout',
+  ): string {
+    const id = `watcher_${++this.watcherIdCounter}`;
+    const state = {
+      patterns: [...options.patterns],
+      onMatch: options.onMatch,
+      history: [] as WatchMatch[],
+      maxHistory: options.maxHistory ?? 100,
+    };
+    this.watchers.set(id, state);
+
+    let buffer = '';
+
+    const onData = (chunk: Buffer | string) => {
+      buffer += chunk.toString();
+      const lines = buffer.split('\n');
+      buffer = lines.pop() ?? ''; // Keep incomplete line in buffer
+
+      for (const line of lines) {
+        this.matchLine(id, line, streamName);
+      }
+    };
+
+    stream.on('data', onData);
+    stream.on('end', () => {
+      // Process remaining buffer
+      if (buffer) this.matchLine(id, buffer, streamName);
+      this.watchers.delete(id);
+      this.emit('watcher:end', id);
+    });
+
+    return id;
+  }
+
+  /**
+   * Watch both stdout and stderr of a ChildProcess.
+   */
+  watchProcess(
+    proc: { stdout?: NodeJS.ReadableStream | null; stderr?: NodeJS.ReadableStream | null },
+    options: WatchOptions,
+  ): string[] {
+    const ids: string[] = [];
+    if (proc.stdout) ids.push(this.watch(proc.stdout, options, 'stdout'));
+    if (proc.stderr) ids.push(this.watch(proc.stderr, options, 'stderr'));
+    return ids;
+  }
+
+  /** Stop a specific watcher */
+  unwatch(id: string): void {
+    this.watchers.delete(id);
+  }
+
+  /** Get match history for a watcher */
+  getHistory(id: string): WatchMatch[] {
+    return this.watchers.get(id)?.history ?? [];
+  }
+
+  /** Add a pattern to an existing watcher */
+  addPattern(id: string, pattern: WatchPattern): void {
+    const state = this.watchers.get(id);
+    if (state) state.patterns.push(pattern);
+  }
+
+  /** Remove a pattern by label from a watcher */
+  removePattern(id: string, label: string): void {
+    const state = this.watchers.get(id);
+    if (state) {
+      state.patterns = state.patterns.filter(p => p.label !== label);
+    }
+  }
+
+  private matchLine(watcherId: string, line: string, stream: 'stdout' | 'stderr'): void {
+    const state = this.watchers.get(watcherId);
+    if (!state) return;
+
+    const toRemove: number[] = [];
+
+    for (let i = 0; i < state.patterns.length; i++) {
+      const pattern = state.patterns[i];
+      const m = line.match(pattern.regex);
+      if (m) {
+        const match: WatchMatch = {
+          label: pattern.label,
+          line,
+          groups: m.slice(1),
+          timestamp: Date.now(),
+          stream,
+        };
+
+        state.history.push(match);
+        if (state.history.length > state.maxHistory) {
+          state.history.shift();
+        }
+
+        state.onMatch(match);
+        this.emit('match', match);
+
+        if (pattern.once) {
+          toRemove.push(i);
+        }
+      }
+    }
+
+    // Remove once-patterns in reverse order
+    for (let i = toRemove.length - 1; i >= 0; i--) {
+      state.patterns.splice(toRemove[i], 1);
+    }
+  }
+}

package/src/index.ts

@@ -100,3 +100,11 @@ export { sanitizeInput, detectInjection, securityHeaders, corsMiddleware, APIKey
 export type { SecurityHeadersConfig, CORSConfig, APIKeyEntry } from './core/security';
 export { createLoggingPlugin, createAnalyticsPlugin, createRateLimitPlugin } from './plugins';
 export type { PluginManifest } from './plugins';
+
+// v1.1.0 modules
+export { FeishuChannel } from './channels/feishu';
+export type { FeishuChannelConfig } from './channels/feishu';
+export { DiscordChannel } from './channels/discord';
+export type { DiscordChannelConfig } from './channels/discord';
+export { ProcessWatcher } from './core/watch';
+export type { WatchPattern, WatchMatch, WatchOptions } from './core/watch';