opc-agent 1.0.0 → 1.1.1

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/cli.ts

@@ -520,41 +520,7 @@ program
     });
   });
 
-// ── Publish command ──────────────────────────────────────────
-
-program
-  .command('publish')
-  .description('Validate and package for OPC Registry')
-  .option('-f, --file <file>', 'OAD file', 'oad.yaml')
-  .action(async (opts: { file: string }) => {
-    try {
-      const runtime = new AgentRuntime();
-      const config = await runtime.loadConfig(opts.file);
-      const trust = config.spec.dtv?.trust?.level ?? 'sandbox';
-
-      console.log(`\n${icon.package} Publishing: ${color.bold(config.metadata.name)} v${config.metadata.version}`);
-      console.log(`   ${icon.success} OAD validation passed`);
-
-      const manifest = {
-        name: config.metadata.name,
-        version: config.metadata.version,
-        description: config.metadata.description,
-        author: config.metadata.author,
-        license: config.metadata.license,
-        trust,
-        channels: config.spec.channels.map((c: any) => c.type),
-        skills: config.spec.skills.map((s: any) => s.name),
-        publishedAt: new Date().toISOString(),
-      };
-
-      fs.writeFileSync('opc-manifest.json', JSON.stringify(manifest, null, 2));
-      console.log(`   ${icon.file} Generated opc-manifest.json`);
-      console.log(`\n🚧 OPC Registry is coming soon. Manifest saved locally.\n`);
-    } catch (err) {
-      console.error(`${icon.error} Publish failed:`, err instanceof Error ? err.message : err);
-      process.exit(1);
-    }
-  });
+// (publish command moved to marketplace section below)
 
 // ── Deploy command ───────────────────────────────────────────
 

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/i18n/index.ts

@@ -18,16 +18,33 @@ const messages: Record<Locale, I18nMessages> = {
     'agent.notUnderstood': 'I\'m not sure I understand. Could you rephrase?',
     'agent.handoff': 'Let me connect you with a human agent.',
     'cli.init.success': 'Created agent project: {name}',
+    'cli.init.prompt.name': 'Agent name:',
+    'cli.init.prompt.template': 'Choose a template:',
+    'cli.init.prompt.provider': 'Choose an LLM provider:',
     'cli.build.success': 'Build successful: {name} v{version}',
     'cli.test.pass': 'All tests passed',
     'cli.test.fail': '{count} test(s) failed',
+    'cli.run.starting': 'Starting agent "{name}"...',
+    'cli.run.listening': 'Agent "{name}" is running at http://localhost:{port}',
+    'cli.deploy.success': 'Deployed "{name}" to {target}',
+    'cli.deploy.error': 'Deploy failed: {error}',
+    'cli.validate.success': 'OAD validation passed',
+    'cli.validate.error': 'OAD validation failed: {error}',
+    'cli.analytics.title': 'Agent Analytics',
+    'cli.analytics.noData': 'No analytics data yet',
     'cli.stats.title': 'Agent Analytics',
     'cli.stats.messages': 'Messages Processed',
     'cli.stats.avgTime': 'Avg Response Time',
     'cli.stats.errors': 'Errors',
     'cli.stats.uptime': 'Uptime',
+    'cli.chat.welcome': 'Chat with your agent. Type "exit" to quit.',
+    'cli.dev.watching': 'Watching for changes...',
+    'cli.publish.success': 'Published "{name}" v{version}',
     'plugin.loaded': 'Plugin "{name}" loaded',
     'plugin.error': 'Plugin "{name}" failed: {error}',
+    'kb.added': 'Added "{file}" to knowledge base',
+    'kb.searchResults': '{count} results found',
+    'kb.noResults': 'No results found',
     'web.title': 'OPC Agent',
     'web.chat.placeholder': 'Type a message...',
     'web.chat.send': 'Send',
@@ -50,22 +67,39 @@ const messages: Record<Locale, I18nMessages> = {
   'zh-CN': {
     'agent.started': '智能体 "{name}" 启动成功',
     'agent.stopped': '智能体 "{name}" 已停止',
-    'agent.error': '发生错误: {error}',
-    'agent.greeting': '您好！有什么可以帮您的？',
-    'agent.farewell': '再见！祝您愉快。',
-    'agent.notUnderstood': '抱歉，我没有理解您的意思。能换个方式描述吗？',
-    'agent.handoff': '我来为您转接人工客服。',
-    'cli.init.success': '已创建智能体项目: {name}',
-    'cli.build.success': '构建成功: {name} v{version}',
+    'agent.error': '发生错误：{error}',
+    'agent.greeting': '你好！有什么可以帮你的？',
+    'agent.farewell': '再见！祝你愉快。',
+    'agent.notUnderstood': '抱歉，我没太理解你的意思。能换个方式描述一下吗？',
+    'agent.handoff': '我来帮你转接人工客服。',
+    'cli.init.success': '已创建智能体项目：{name}',
+    'cli.init.prompt.name': '智能体名称：',
+    'cli.init.prompt.template': '选择一个模板：',
+    'cli.init.prompt.provider': '选择大语言模型供应商：',
+    'cli.build.success': '构建成功：{name} v{version}',
     'cli.test.pass': '所有测试通过',
     'cli.test.fail': '{count} 个测试失败',
-    'cli.stats.title': '智能体分析',
+    'cli.run.starting': '正在启动智能体 "{name}"...',
+    'cli.run.listening': '智能体 "{name}" 已在 http://localhost:{port} 上运行',
+    'cli.deploy.success': '已将 "{name}" 部署到 {target}',
+    'cli.deploy.error': '部署失败：{error}',
+    'cli.validate.success': 'OAD 配置校验通过',
+    'cli.validate.error': 'OAD 配置校验失败：{error}',
+    'cli.analytics.title': '智能体数据分析',
+    'cli.analytics.noData': '暂无分析数据',
+    'cli.stats.title': '智能体数据分析',
     'cli.stats.messages': '已处理消息',
     'cli.stats.avgTime': '平均响应时间',
     'cli.stats.errors': '错误数',
     'cli.stats.uptime': '运行时间',
+    'cli.chat.welcome': '开始和智能体对话吧。输入 "exit" 退出。',
+    'cli.dev.watching': '正在监听文件变更...',
+    'cli.publish.success': '已发布 "{name}" v{version}',
     'plugin.loaded': '插件 "{name}" 已加载',
-    'plugin.error': '插件 "{name}" 失败: {error}',
+    'plugin.error': '插件 "{name}" 出错：{error}',
+    'kb.added': '已将 "{file}" 添加到知识库',
+    'kb.searchResults': '找到 {count} 条结果',
+    'kb.noResults': '未找到相关结果',
     'web.title': 'OPC 智能体',
     'web.chat.placeholder': '输入消息...',
     'web.chat.send': '发送',
@@ -94,16 +128,33 @@ const messages: Record<Locale, I18nMessages> = {
     'agent.notUnderstood': '申し訳ございません、理解できませんでした。別の言い方でお願いできますか？',
     'agent.handoff': 'オペレーターにおつなぎします。',
     'cli.init.success': 'エージェントプロジェクトを作成しました: {name}',
+    'cli.init.prompt.name': 'エージェント名:',
+    'cli.init.prompt.template': 'テンプレートを選択:',
+    'cli.init.prompt.provider': 'LLMプロバイダーを選択:',
     'cli.build.success': 'ビルド成功: {name} v{version}',
     'cli.test.pass': '全テスト合格',
     'cli.test.fail': '{count} 件のテストが失敗しました',
+    'cli.run.starting': 'エージェント「{name}」を起動中...',
+    'cli.run.listening': 'エージェント「{name}」が http://localhost:{port} で稼働中',
+    'cli.deploy.success': '「{name}」を {target} にデプロイしました',
+    'cli.deploy.error': 'デプロイ失敗: {error}',
+    'cli.validate.success': 'OADバリデーション成功',
+    'cli.validate.error': 'OADバリデーション失敗: {error}',
+    'cli.analytics.title': 'エージェント分析',
+    'cli.analytics.noData': '分析データがありません',
     'cli.stats.title': 'エージェント分析',
     'cli.stats.messages': '処理済みメッセージ',
     'cli.stats.avgTime': '平均応答時間',
     'cli.stats.errors': 'エラー数',
     'cli.stats.uptime': '稼働時間',
+    'cli.chat.welcome': 'エージェントとチャットしましょう。"exit"で終了。',
+    'cli.dev.watching': 'ファイル変更を監視中...',
+    'cli.publish.success': '「{name}」v{version} を公開しました',
     'plugin.loaded': 'プラグイン「{name}」を読み込みました',
     'plugin.error': 'プラグイン「{name}」でエラー: {error}',
+    'kb.added': '「{file}」をナレッジベースに追加しました',
+    'kb.searchResults': '{count} 件の結果が見つかりました',
+    'kb.noResults': '結果が見つかりませんでした',
     'web.title': 'OPC エージェント',
     'web.chat.placeholder': 'メッセージを入力...',
     'web.chat.send': '送信',

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';

package/tests/i18n.test.ts

@@ -9,7 +9,7 @@ describe('i18n', () => {
 
   it('should return Chinese messages', () => {
     setLocale('zh-CN');
-    expect(t('agent.greeting')).toBe('您好！有什么可以帮您的？');
+    expect(t('agent.greeting')).toBe('你好！有什么可以帮你的？');
     setLocale('en'); // reset
   });