opc-agent 1.2.1 → 1.3.0

package/src/channels/websocket.ts

@@ -1,87 +1,87 @@
-import type { Message } from '../core/types';
-import { BaseChannel } from './index';
-import { WebSocketServer, type WebSocket } from 'ws';
-
-/**
- * WebSocket channel — real-time bidirectional communication.
- */
-export class WebSocketChannel extends BaseChannel {
-  readonly type = 'websocket';
-  private wss: WebSocketServer | null = null;
-  private port: number;
-  private clients: Set<WebSocket> = new Set();
-
-  constructor(port: number = 3002) {
-    super();
-    this.port = port;
-  }
-
-  async start(): Promise<void> {
-    return new Promise((resolve) => {
-      this.wss = new WebSocketServer({ port: this.port });
-
-      this.wss.on('connection', (ws) => {
-        this.clients.add(ws);
-
-        ws.on('message', async (data) => {
-          if (!this.handler) return;
-
-          try {
-            const parsed = JSON.parse(data.toString());
-            const msg: Message = {
-              id: parsed.id ?? `ws_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
-              role: 'user',
-              content: parsed.content ?? parsed.message ?? data.toString(),
-              timestamp: Date.now(),
-              metadata: {
-                sessionId: parsed.sessionId ?? 'ws-default',
-                platform: 'websocket',
-              },
-            };
-
-            const response = await this.handler(msg);
-            ws.send(JSON.stringify({
-              id: response.id,
-              content: response.content,
-              timestamp: response.timestamp,
-            }));
-          } catch (err) {
-            ws.send(JSON.stringify({ error: 'Invalid message format' }));
-          }
-        });
-
-        ws.on('close', () => {
-          this.clients.delete(ws);
-        });
-
-        ws.send(JSON.stringify({ type: 'connected', timestamp: Date.now() }));
-      });
-
-      this.wss.on('listening', () => {
-        console.log(`[WebSocketChannel] Listening on port ${this.port}`);
-        resolve();
-      });
-    });
-  }
-
-  async stop(): Promise<void> {
-    for (const client of this.clients) {
-      client.close();
-    }
-    this.clients.clear();
-
-    return new Promise((resolve, reject) => {
-      if (!this.wss) return resolve();
-      this.wss.close((err) => (err ? reject(err) : resolve()));
-    });
-  }
-
-  broadcast(content: string): void {
-    const msg = JSON.stringify({ type: 'broadcast', content, timestamp: Date.now() });
-    for (const client of this.clients) {
-      if (client.readyState === 1) { // OPEN
-        client.send(msg);
-      }
-    }
-  }
-}
+import type { Message } from '../core/types';
+import { BaseChannel } from './index';
+import { WebSocketServer, type WebSocket } from 'ws';
+
+/**
+ * WebSocket channel — real-time bidirectional communication.
+ */
+export class WebSocketChannel extends BaseChannel {
+  readonly type = 'websocket';
+  private wss: WebSocketServer | null = null;
+  private port: number;
+  private clients: Set<WebSocket> = new Set();
+
+  constructor(port: number = 3002) {
+    super();
+    this.port = port;
+  }
+
+  async start(): Promise<void> {
+    return new Promise((resolve) => {
+      this.wss = new WebSocketServer({ port: this.port });
+
+      this.wss.on('connection', (ws) => {
+        this.clients.add(ws);
+
+        ws.on('message', async (data) => {
+          if (!this.handler) return;
+
+          try {
+            const parsed = JSON.parse(data.toString());
+            const msg: Message = {
+              id: parsed.id ?? `ws_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+              role: 'user',
+              content: parsed.content ?? parsed.message ?? data.toString(),
+              timestamp: Date.now(),
+              metadata: {
+                sessionId: parsed.sessionId ?? 'ws-default',
+                platform: 'websocket',
+              },
+            };
+
+            const response = await this.handler(msg);
+            ws.send(JSON.stringify({
+              id: response.id,
+              content: response.content,
+              timestamp: response.timestamp,
+            }));
+          } catch (err) {
+            ws.send(JSON.stringify({ error: 'Invalid message format' }));
+          }
+        });
+
+        ws.on('close', () => {
+          this.clients.delete(ws);
+        });
+
+        ws.send(JSON.stringify({ type: 'connected', timestamp: Date.now() }));
+      });
+
+      this.wss.on('listening', () => {
+        console.log(`[WebSocketChannel] Listening on port ${this.port}`);
+        resolve();
+      });
+    });
+  }
+
+  async stop(): Promise<void> {
+    for (const client of this.clients) {
+      client.close();
+    }
+    this.clients.clear();
+
+    return new Promise((resolve, reject) => {
+      if (!this.wss) return resolve();
+      this.wss.close((err) => (err ? reject(err) : resolve()));
+    });
+  }
+
+  broadcast(content: string): void {
+    const msg = JSON.stringify({ type: 'broadcast', content, timestamp: Date.now() });
+    for (const client of this.clients) {
+      if (client.readyState === 1) { // OPEN
+        client.send(msg);
+      }
+    }
+  }
+}

package/src/channels/wechat.ts

@@ -1,149 +1,149 @@
-import { BaseChannel } from './index';
-import type { Message } from '../core/types';
-
-/**
- * WeChat Channel (Stub) — v0.8.0
- * WeChat Official Account message handling, template messages, QR code login.
- */
-
-export interface WeChatChannelConfig {
-  /** WeChat Official Account AppID */
-  appId: string;
-  /** WeChat Official Account AppSecret */
-  appSecret: string;
-  /** Verification token for message validation */
-  token: string;
-  /** AES encoding key for encrypted messages */
-  encodingAESKey?: string;
-  /** HTTP server port (default: 3002) */
-  port?: number;
-}
-
-export interface WeChatMessage {
-  toUserName: string;
-  fromUserName: string;
-  createTime: number;
-  msgType: 'text' | 'image' | 'voice' | 'video' | 'event';
-  content?: string;
-  msgId?: string;
-  event?: string;
-  eventKey?: string;
-}
-
-export interface TemplateMessageData {
-  toUser: string;
-  templateId: string;
-  url?: string;
-  data: Record<string, { value: string; color?: string }>;
-}
-
-export class WeChatChannel extends BaseChannel {
-  type = 'wechat';
-  private config: WeChatChannelConfig;
-  private accessToken: string | null = null;
-  private tokenExpiry = 0;
-
-  constructor(config: WeChatChannelConfig) {
-    super();
-    this.config = config;
-  }
-
-  async start(): Promise<void> {
-    // TODO: Start HTTP server to receive WeChat push messages
-    // 1. Verify signature on GET requests
-    // 2. Parse XML messages on POST requests
-    // 3. Route to handler and reply with XML
-  }
-
-  async stop(): Promise<void> {
-    // TODO: Stop HTTP server
-  }
-
-  /** Get or refresh access token */
-  async getAccessToken(): Promise<string> {
-    if (this.accessToken && Date.now() < this.tokenExpiry) {
-      return this.accessToken;
-    }
-
-    // TODO: Implement token refresh
-    // const url = `https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=${this.config.appId}&secret=${this.config.appSecret}`;
-    // const res = await fetch(url);
-    // const data = await res.json();
-    // this.accessToken = data.access_token;
-    // this.tokenExpiry = Date.now() + (data.expires_in - 300) * 1000;
-
-    return this.accessToken ?? '';
-  }
-
-  /** Handle incoming WeChat message */
-  async handleMessage(wxMsg: WeChatMessage): Promise<string> {
-    if (wxMsg.msgType === 'event') {
-      return this.handleEvent(wxMsg);
-    }
-
-    const message = this.wechatToMessage(wxMsg);
-    if (this.handler) {
-      const reply = await this.handler(message);
-      return reply.content;
-    }
-    return '';
-  }
-
-  /** Handle WeChat events (subscribe, scan, etc.) */
-  private handleEvent(wxMsg: WeChatMessage): string {
-    switch (wxMsg.event) {
-      case 'subscribe':
-        return 'Welcome! How can I help you?';
-      case 'SCAN':
-        return `QR code scanned: ${wxMsg.eventKey}`;
-      default:
-        return '';
-    }
-  }
-
-  /** Convert WeChat message to internal Message */
-  private wechatToMessage(wxMsg: WeChatMessage): Message {
-    return {
-      id: wxMsg.msgId ?? `wx-${wxMsg.createTime}`,
-      role: 'user',
-      content: wxMsg.content ?? '',
-      timestamp: wxMsg.createTime * 1000,
-      metadata: {
-        channel: 'wechat',
-        fromUser: wxMsg.fromUserName,
-        toUser: wxMsg.toUserName,
-        msgType: wxMsg.msgType,
-      },
-    };
-  }
-
-  /** Send template message */
-  async sendTemplateMessage(data: TemplateMessageData): Promise<boolean> {
-    // TODO: Implement
-    // const token = await this.getAccessToken();
-    // const url = `https://api.weixin.qq.com/cgi-bin/message/template/send?access_token=${token}`;
-    // const res = await fetch(url, {
-    //   method: 'POST',
-    //   body: JSON.stringify({
-    //     touser: data.toUser,
-    //     template_id: data.templateId,
-    //     url: data.url,
-    //     data: data.data,
-    //   }),
-    // });
-    void data;
-    return true;
-  }
-
-  /** Generate QR code for login (stub) */
-  async generateLoginQR(): Promise<{ ticket: string; url: string; expireSeconds: number }> {
-    // TODO: Implement with WeChat QR code API
-    // const token = await this.getAccessToken();
-    // POST to https://api.weixin.qq.com/cgi-bin/qrcode/create
-    return {
-      ticket: 'stub-ticket',
-      url: 'https://mp.weixin.qq.com/cgi-bin/showqrcode?ticket=stub-ticket',
-      expireSeconds: 300,
-    };
-  }
-}
+import { BaseChannel } from './index';
+import type { Message } from '../core/types';
+
+/**
+ * WeChat Channel (Stub) — v0.8.0
+ * WeChat Official Account message handling, template messages, QR code login.
+ */
+
+export interface WeChatChannelConfig {
+  /** WeChat Official Account AppID */
+  appId: string;
+  /** WeChat Official Account AppSecret */
+  appSecret: string;
+  /** Verification token for message validation */
+  token: string;
+  /** AES encoding key for encrypted messages */
+  encodingAESKey?: string;
+  /** HTTP server port (default: 3002) */
+  port?: number;
+}
+
+export interface WeChatMessage {
+  toUserName: string;
+  fromUserName: string;
+  createTime: number;
+  msgType: 'text' | 'image' | 'voice' | 'video' | 'event';
+  content?: string;
+  msgId?: string;
+  event?: string;
+  eventKey?: string;
+}
+
+export interface TemplateMessageData {
+  toUser: string;
+  templateId: string;
+  url?: string;
+  data: Record<string, { value: string; color?: string }>;
+}
+
+export class WeChatChannel extends BaseChannel {
+  type = 'wechat';
+  private config: WeChatChannelConfig;
+  private accessToken: string | null = null;
+  private tokenExpiry = 0;
+
+  constructor(config: WeChatChannelConfig) {
+    super();
+    this.config = config;
+  }
+
+  async start(): Promise<void> {
+    // TODO: Start HTTP server to receive WeChat push messages
+    // 1. Verify signature on GET requests
+    // 2. Parse XML messages on POST requests
+    // 3. Route to handler and reply with XML
+  }
+
+  async stop(): Promise<void> {
+    // TODO: Stop HTTP server
+  }
+
+  /** Get or refresh access token */
+  async getAccessToken(): Promise<string> {
+    if (this.accessToken && Date.now() < this.tokenExpiry) {
+      return this.accessToken;
+    }
+
+    // TODO: Implement token refresh
+    // const url = `https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=${this.config.appId}&secret=${this.config.appSecret}`;
+    // const res = await fetch(url);
+    // const data = await res.json();
+    // this.accessToken = data.access_token;
+    // this.tokenExpiry = Date.now() + (data.expires_in - 300) * 1000;
+
+    return this.accessToken ?? '';
+  }
+
+  /** Handle incoming WeChat message */
+  async handleMessage(wxMsg: WeChatMessage): Promise<string> {
+    if (wxMsg.msgType === 'event') {
+      return this.handleEvent(wxMsg);
+    }
+
+    const message = this.wechatToMessage(wxMsg);
+    if (this.handler) {
+      const reply = await this.handler(message);
+      return reply.content;
+    }
+    return '';
+  }
+
+  /** Handle WeChat events (subscribe, scan, etc.) */
+  private handleEvent(wxMsg: WeChatMessage): string {
+    switch (wxMsg.event) {
+      case 'subscribe':
+        return 'Welcome! How can I help you?';
+      case 'SCAN':
+        return `QR code scanned: ${wxMsg.eventKey}`;
+      default:
+        return '';
+    }
+  }
+
+  /** Convert WeChat message to internal Message */
+  private wechatToMessage(wxMsg: WeChatMessage): Message {
+    return {
+      id: wxMsg.msgId ?? `wx-${wxMsg.createTime}`,
+      role: 'user',
+      content: wxMsg.content ?? '',
+      timestamp: wxMsg.createTime * 1000,
+      metadata: {
+        channel: 'wechat',
+        fromUser: wxMsg.fromUserName,
+        toUser: wxMsg.toUserName,
+        msgType: wxMsg.msgType,
+      },
+    };
+  }
+
+  /** Send template message */
+  async sendTemplateMessage(data: TemplateMessageData): Promise<boolean> {
+    // TODO: Implement
+    // const token = await this.getAccessToken();
+    // const url = `https://api.weixin.qq.com/cgi-bin/message/template/send?access_token=${token}`;
+    // const res = await fetch(url, {
+    //   method: 'POST',
+    //   body: JSON.stringify({
+    //     touser: data.toUser,
+    //     template_id: data.templateId,
+    //     url: data.url,
+    //     data: data.data,
+    //   }),
+    // });
+    void data;
+    return true;
+  }
+
+  /** Generate QR code for login (stub) */
+  async generateLoginQR(): Promise<{ ticket: string; url: string; expireSeconds: number }> {
+    // TODO: Implement with WeChat QR code API
+    // const token = await this.getAccessToken();
+    // POST to https://api.weixin.qq.com/cgi-bin/qrcode/create
+    return {
+      ticket: 'stub-ticket',
+      url: 'https://mp.weixin.qq.com/cgi-bin/showqrcode?ticket=stub-ticket',
+      expireSeconds: 300,
+    };
+  }
+}

package/src/cli.ts

@@ -27,9 +27,9 @@ import { WorkflowEngine } from './core/workflow';
 import { VersionManager } from './core/versioning';
 import { createProvider } from './providers';
 import { KnowledgeBase } from './core/knowledge';
-import { publishAgent, installAgent } from './marketplace';
 
 import { PluginManager, createLoggingPlugin, createAnalyticsPlugin, createRateLimitPlugin } from './plugins';
+import type { Span } from './traces';
 
 const program = new Command();
 
@@ -873,4 +873,122 @@ program
     }
   });
 
+// ── Brain command ────────────────────────────────────────────
+
+program
+  .command('brain')
+  .description('Show agent memory/brain status from DeepBrain')
+  .option('--url <url>', 'DeepBrain server URL', 'http://localhost:3333')
+  .action(async (opts: { url: string }) => {
+    console.log(`\n${icon.gear} ${color.bold('DeepBrain Status')} — ${color.dim(opts.url)}\n`);
+    try {
+      const res = await fetch(`${opts.url}/api/stats`);
+      if (!res.ok) throw new Error(`HTTP ${res.status} ${res.statusText}`);
+      const stats = (await res.json()) as Record<string, any>;
+      const rows: [string, string][] = [
+        ['Total Pages', String(stats.totalPages ?? stats.pages ?? '-')],
+        ['Total Chunks', String(stats.totalChunks ?? stats.chunks ?? '-')],
+        ['Memory Tiers', String(stats.memoryTiers ?? stats.tiers ?? '-')],
+        ['Index Size', stats.indexSize ?? '-'],
+        ['Last Updated', stats.lastUpdated ?? stats.updatedAt ?? '-'],
+      ];
+      const maxKey = Math.max(...rows.map(([k]) => k.length));
+      for (const [key, val] of rows) {
+        console.log(`  ${color.cyan(key.padEnd(maxKey))}  ${val}`);
+      }
+      console.log();
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (msg.includes('ECONNREFUSED') || msg.includes('fetch failed')) {
+        console.log(`  ${icon.warn} Cannot connect to DeepBrain at ${opts.url}`);
+        console.log(`  ${color.dim('Is the server running? Start with: deepbrain serve')}\n`);
+      } else {
+        console.error(`  ${icon.error} ${msg}\n`);
+      }
+    }
+  });
+
+// ── Logs command ─────────────────────────────────────────────
+
+program
+  .command('logs')
+  .description('Show recent agent traces')
+  .option('-n, --limit <n>', 'Number of spans to show', '20')
+  .option('-f, --follow', 'Keep watching for new spans')
+  .action(async (opts: { limit: string; follow?: boolean }) => {
+    const { TraceCollector } = await import('./traces');
+    const collector = new TraceCollector();
+    const limit = parseInt(opts.limit) || 20;
+
+    const printSpans = (spans: readonly Span[]) => {
+      const slice = spans.slice(-limit);
+      if (slice.length === 0) {
+        console.log(`  ${icon.info} No traces yet. Interact with the agent to generate traces.`);
+        return;
+      }
+      for (const span of slice) {
+        const duration = span.endTime
+          ? `${span.endTime.getTime() - span.startTime.getTime()}ms`
+          : 'ongoing';
+        const statusIcon = span.status === 'ok' ? icon.success : span.status === 'error' ? icon.error : color.dim('○');
+        const time = span.startTime.toLocaleTimeString();
+        console.log(`  ${statusIcon} ${color.dim(time)} ${color.bold(span.name)} ${color.dim(duration)}`);
+      }
+    };
+
+    console.log(`\n${icon.gear} ${color.bold('Agent Traces')}\n`);
+    const spans = collector.getBufferedSpans();
+    printSpans(spans);
+
+    if (opts.follow) {
+      console.log(`\n  ${color.dim('Watching for new traces... (Ctrl+C to stop)')}\n`);
+      let lastCount = spans.length;
+      const interval = setInterval(() => {
+        const current = collector.getBufferedSpans();
+        if (current.length > lastCount) {
+          const newSpans = current.slice(lastCount);
+          printSpans(newSpans);
+          lastCount = current.length;
+        }
+      }, 1000);
+      process.on('SIGINT', () => { clearInterval(interval); process.exit(0); });
+    } else {
+      console.log();
+    }
+  });
+
+// ── Score command ────────────────────────────────────────────
+
+program
+  .command('score')
+  .description('Show agent performance score')
+  .action(async () => {
+    console.log(`\n${icon.gear} ${color.bold('Agent Performance Score')}\n`);
+    try {
+      const engine = new AnalyticsEngine('.');
+      const stats = engine.getStats();
+      if (!stats || stats.totalMessages === 0) {
+        console.log(`  ${icon.info} No score data yet. Run the agent first.\n`);
+        return;
+      }
+      const errorRate = stats.totalMessages > 0 ? (stats.totalErrors / stats.totalMessages) : 0;
+      const rows: [string, string][] = [
+        ['Total Messages', String(stats.totalMessages)],
+        ['Total LLM Calls', String(stats.totalLLMCalls)],
+        ['Total Tool Uses', String(stats.totalToolUses)],
+        ['Avg Response Time', `${stats.avgResponseTimeMs}ms`],
+        ['Error Rate', `${(errorRate * 100).toFixed(1)}%`],
+        ['Token Usage', `${stats.totalTokens.total} tokens (in: ${stats.totalTokens.input}, out: ${stats.totalTokens.output})`],
+      ];
+      const maxKey = Math.max(...rows.map(([k]) => k.length));
+      for (const [key, val] of rows) {
+        console.log(`  ${color.cyan(key.padEnd(maxKey))}  ${val}`);
+      }
+      console.log();
+    } catch {
+      console.log(`  ${icon.info} No score data yet. Run the agent first.\n`);
+    }
+  });
+
 program.parse();
+