opc-agent 3.0.1 → 4.0.1

package/src/core/session-manager.ts

@@ -0,0 +1,137 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+import type { Message } from './types';
+
+export interface Session {
+  id: string;
+  agentId: string;
+  channel: string;
+  messages: Message[];
+  metadata: Record<string, any>;
+  createdAt: number;
+  lastActivity: number;
+  parentId?: string;
+  compactedAt?: number;
+}
+
+export class SessionManager {
+  private sessions: Map<string, Session> = new Map();
+  private storageDir: string;
+
+  constructor(storageDir?: string) {
+    this.storageDir = storageDir || path.join(process.env.HOME || process.env.USERPROFILE || '~', '.opc', 'sessions');
+  }
+
+  create(agentId: string, channel: string, parentId?: string): Session {
+    const session: Session = {
+      id: crypto.randomUUID(),
+      agentId,
+      channel,
+      messages: [],
+      metadata: {},
+      createdAt: Date.now(),
+      lastActivity: Date.now(),
+      parentId,
+    };
+    this.sessions.set(session.id, session);
+    return session;
+  }
+
+  get(id: string): Session | null {
+    return this.sessions.get(id) || null;
+  }
+
+  list(filter?: { agentId?: string; channel?: string; active?: boolean }): Session[] {
+    let result = Array.from(this.sessions.values());
+    if (filter?.agentId) result = result.filter(s => s.agentId === filter.agentId);
+    if (filter?.channel) result = result.filter(s => s.channel === filter.channel);
+    if (filter?.active !== undefined) {
+      const cutoff = Date.now() - 30 * 60 * 1000; // 30 min
+      result = result.filter(s => filter.active ? s.lastActivity > cutoff : s.lastActivity <= cutoff);
+    }
+    return result;
+  }
+
+  addMessage(sessionId: string, message: Message): void {
+    const session = this.sessions.get(sessionId);
+    if (!session) throw new Error(`Session ${sessionId} not found`);
+    session.messages.push(message);
+    session.lastActivity = Date.now();
+  }
+
+  async compact(sessionId: string, brain?: any): Promise<void> {
+    const session = this.sessions.get(sessionId);
+    if (!session) throw new Error(`Session ${sessionId} not found`);
+    if (brain && typeof brain.compress === 'function') {
+      const compressed = await brain.compress(session.messages);
+      session.messages = [{ id: 'compacted', role: 'system', content: compressed, timestamp: Date.now() }];
+    } else {
+      // Simple: keep first and last 5 messages
+      if (session.messages.length > 10) {
+        const first = session.messages.slice(0, 2);
+        const last = session.messages.slice(-5);
+        session.messages = [...first, { id: 'compacted', role: 'system', content: `[${session.messages.length - 7} messages compacted]`, timestamp: Date.now() }, ...last];
+      }
+    }
+    session.compactedAt = Date.now();
+  }
+
+  prune(maxAge: number): number {
+    const cutoff = Date.now() - maxAge;
+    let pruned = 0;
+    for (const [id, session] of this.sessions) {
+      if (session.lastActivity < cutoff) {
+        this.sessions.delete(id);
+        pruned++;
+      }
+    }
+    return pruned;
+  }
+
+  getLineage(sessionId: string): Session[] {
+    const lineage: Session[] = [];
+    let current = this.sessions.get(sessionId);
+    while (current) {
+      lineage.unshift(current);
+      current = current.parentId ? this.sessions.get(current.parentId) || undefined : undefined;
+    }
+    return lineage;
+  }
+
+  fork(sessionId: string): Session {
+    const parent = this.sessions.get(sessionId);
+    if (!parent) throw new Error(`Session ${sessionId} not found`);
+    return this.create(parent.agentId, parent.channel, parent.id);
+  }
+
+  export(sessionId: string): string {
+    const session = this.sessions.get(sessionId);
+    if (!session) throw new Error(`Session ${sessionId} not found`);
+    const lines = [`# Session ${session.id}`, `Agent: ${session.agentId} | Channel: ${session.channel}`, `Created: ${new Date(session.createdAt).toISOString()}`, ''];
+    for (const msg of session.messages) {
+      lines.push(`**${msg.role}** (${new Date(msg.timestamp).toISOString()}):`);
+      lines.push(msg.content);
+      lines.push('');
+    }
+    return lines.join('\n');
+  }
+
+  save(): void {
+    if (!fs.existsSync(this.storageDir)) {
+      fs.mkdirSync(this.storageDir, { recursive: true });
+    }
+    for (const [id, session] of this.sessions) {
+      fs.writeFileSync(path.join(this.storageDir, `${id}.json`), JSON.stringify(session, null, 2));
+    }
+  }
+
+  load(): void {
+    if (!fs.existsSync(this.storageDir)) return;
+    const files = fs.readdirSync(this.storageDir).filter(f => f.endsWith('.json'));
+    for (const file of files) {
+      const data = JSON.parse(fs.readFileSync(path.join(this.storageDir, file), 'utf-8'));
+      this.sessions.set(data.id, data);
+    }
+  }
+}

package/src/core/vision.ts

@@ -0,0 +1,180 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+// ─── Types ───────────────────────────────────────────────────
+
+export interface ImageInput {
+  type: 'base64' | 'url' | 'file';
+  data: string;
+  mimeType?: string;
+}
+
+export interface VisionResult {
+  description: string;
+  text_content?: string;
+  objects?: string[];
+}
+
+// ─── MIME detection from magic bytes ─────────────────────────
+
+const MAGIC_BYTES: Array<{ bytes: number[]; mime: string }> = [
+  { bytes: [0x89, 0x50, 0x4E, 0x47], mime: 'image/png' },
+  { bytes: [0xFF, 0xD8, 0xFF], mime: 'image/jpeg' },
+  { bytes: [0x47, 0x49, 0x46, 0x38], mime: 'image/gif' },
+  { bytes: [0x52, 0x49, 0x46, 0x46], mime: 'image/webp' }, // RIFF header (WebP)
+];
+
+export function detectMimeType(buffer: Buffer): string {
+  for (const { bytes, mime } of MAGIC_BYTES) {
+    if (bytes.every((b, i) => buffer[i] === b)) {
+      return mime;
+    }
+  }
+  return 'application/octet-stream';
+}
+
+// ─── VisionManager ───────────────────────────────────────────
+
+export interface VisionManagerConfig {
+  model?: string;
+  apiKey?: string;
+  baseURL?: string;
+  maxImageSize?: number; // bytes, default 20MB
+}
+
+export class VisionManager {
+  private config: VisionManagerConfig;
+
+  constructor(config: VisionManagerConfig = {}) {
+    this.config = {
+      model: config.model ?? 'gpt-4o',
+      apiKey: config.apiKey ?? process.env.OPENAI_API_KEY ?? '',
+      baseURL: config.baseURL ?? 'https://api.openai.com/v1',
+      maxImageSize: config.maxImageSize ?? 20 * 1024 * 1024,
+    };
+  }
+
+  /**
+   * Load image data as base64, detecting MIME type.
+   */
+  async loadImage(input: ImageInput): Promise<{ base64: string; mimeType: string }> {
+    if (input.type === 'base64') {
+      const buf = Buffer.from(input.data, 'base64');
+      return { base64: input.data, mimeType: input.mimeType ?? detectMimeType(buf) };
+    }
+    if (input.type === 'file') {
+      const buf = fs.readFileSync(input.data);
+      if (buf.length > this.config.maxImageSize!) {
+        throw new Error(`Image exceeds max size: ${buf.length} > ${this.config.maxImageSize}`);
+      }
+      return { base64: buf.toString('base64'), mimeType: input.mimeType ?? detectMimeType(buf) };
+    }
+    // URL — return as-is for API
+    return { base64: '', mimeType: input.mimeType ?? 'image/jpeg' };
+  }
+
+  /**
+   * Prepare messages in OpenAI multimodal format.
+   */
+  prepareMessage(images: ImageInput[], text: string): Array<Record<string, unknown>> {
+    const content: Array<Record<string, unknown>> = [];
+    if (text) {
+      content.push({ type: 'text', text });
+    }
+    for (const img of images) {
+      if (img.type === 'url') {
+        content.push({
+          type: 'image_url',
+          image_url: { url: img.data },
+        });
+      } else {
+        // base64 or file — will need to be loaded first
+        const mime = img.mimeType ?? 'image/jpeg';
+        const data = img.type === 'base64' ? img.data : fs.readFileSync(img.data).toString('base64');
+        content.push({
+          type: 'image_url',
+          image_url: { url: `data:${mime};base64,${data}` },
+        });
+      }
+    }
+    return [{ role: 'user', content }];
+  }
+
+  /**
+   * Analyze an image with optional prompt.
+   */
+  async analyze(image: ImageInput, prompt?: string): Promise<VisionResult> {
+    const messages = this.prepareMessage([image], prompt ?? 'Describe this image in detail.');
+
+    if (!this.config.apiKey) {
+      throw new Error('Vision API key not configured. Set OPENAI_API_KEY or pass apiKey in config.');
+    }
+
+    const response = await fetch(`${this.config.baseURL}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this.config.apiKey}`,
+      },
+      body: JSON.stringify({
+        model: this.config.model,
+        messages,
+        max_tokens: 1000,
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Vision API error: ${response.status} ${response.statusText}`);
+    }
+
+    const data = await response.json() as any;
+    const text = data.choices?.[0]?.message?.content ?? '';
+
+    return {
+      description: text,
+      text_content: undefined,
+      objects: [],
+    };
+  }
+
+  /**
+   * Extract text (OCR) from an image.
+   */
+  async extractText(image: ImageInput): Promise<string> {
+    const result = await this.analyze(image, 'Extract all visible text from this image. Return only the text, nothing else.');
+    return result.description;
+  }
+
+  /**
+   * Compare multiple images.
+   */
+  async compareImages(images: ImageInput[], prompt?: string): Promise<string> {
+    if (images.length < 2) throw new Error('Need at least 2 images to compare');
+
+    const messages = this.prepareMessage(images, prompt ?? 'Compare these images and describe the differences.');
+
+    if (!this.config.apiKey) {
+      throw new Error('Vision API key not configured.');
+    }
+
+    const response = await fetch(`${this.config.baseURL}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this.config.apiKey}`,
+      },
+      body: JSON.stringify({
+        model: this.config.model,
+        messages,
+        max_tokens: 1000,
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Vision API error: ${response.status} ${response.statusText}`);
+    }
+
+    const data = await response.json() as any;
+    return data.choices?.[0]?.message?.content ?? '';
+  }
+}

package/src/hub/brain-seed.ts

@@ -0,0 +1,54 @@
+/**
+ * Brain-seed downloader and auto-learner.
+ * Downloads brain-seed files from Hub and optionally imports into DeepBrain.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import type { HubBrainSeed } from './client';
+
+export interface BrainSeedResult {
+  savedFiles: string[];
+  learnedCount: number;
+}
+
+/**
+ * Save brain-seed files to disk and optionally auto-learn into DeepBrain.
+ */
+export async function downloadAndLearnBrainSeeds(
+  projectDir: string,
+  seeds: HubBrainSeed[],
+): Promise<BrainSeedResult> {
+  if (!seeds || seeds.length === 0) {
+    return { savedFiles: [], learnedCount: 0 };
+  }
+
+  const seedDir = path.join(projectDir, 'brain-seed');
+  fs.mkdirSync(seedDir, { recursive: true });
+
+  const savedFiles: string[] = [];
+  for (const seed of seeds) {
+    const filePath = path.join(seedDir, seed.filename);
+    fs.writeFileSync(filePath, seed.content, 'utf-8');
+    savedFiles.push(seed.filename);
+  }
+
+  // Try auto-learn into DeepBrain (optional dependency)
+  let learnedCount = 0;
+  try {
+    const { Brain } = require('deepbrain');
+    const brain = new Brain({ database: path.join(projectDir, 'data', 'brain.db') });
+    for (const seed of seeds) {
+      await brain.learn(seed.content, {
+        slug: `brain-seed/${seed.filename.replace(/\.md$/, '')}`,
+        title: `Brain Seed: ${seed.tier}`,
+        namespace: `seed/${seed.tier}`,
+      });
+      learnedCount++;
+    }
+  } catch {
+    // deepbrain not installed — that's fine, files are saved
+  }
+
+  return { savedFiles, learnedCount };
+}

package/src/hub/client.ts

@@ -0,0 +1,60 @@
+/**
+ * Workstation Hub API client
+ * Fetches agent templates and brain-seed knowledge from the Hub.
+ */
+
+const HUB_URL = process.env.OPC_HUB_URL || 'https://hub.deepleaper.com';
+const HUB_TIMEOUT = 5000;
+
+export interface HubTemplate {
+  id: string;
+  name: string;
+  description: string;
+  category: string;
+  tags?: string[];
+}
+
+export interface HubTemplateDetail extends HubTemplate {
+  files: Record<string, string>;
+  brainSeeds: HubBrainSeed[];
+}
+
+export interface HubBrainSeed {
+  filename: string;
+  content: string;
+  tier: 'industry' | 'job' | 'workstation';
+}
+
+async function hubFetch<T>(path: string): Promise<T> {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), HUB_TIMEOUT);
+  try {
+    const res = await fetch(`${HUB_URL}${path}`, {
+      signal: controller.signal,
+      headers: { 'Accept': 'application/json', 'User-Agent': 'opc-agent/2.0' },
+    });
+    if (!res.ok) throw new Error(`Hub API ${res.status} ${res.statusText}`);
+    return (await res.json()) as T;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export async function fetchTemplates(query?: string): Promise<HubTemplate[]> {
+  const qs = query ? `?q=${encodeURIComponent(query)}` : '';
+  return hubFetch<HubTemplate[]>(`/api/templates${qs}`);
+}
+
+export async function fetchTemplate(id: string): Promise<HubTemplateDetail> {
+  return hubFetch<HubTemplateDetail>(`/api/templates/${encodeURIComponent(id)}`);
+}
+
+export async function fetchBrainSeeds(templateId: string): Promise<HubBrainSeed[]> {
+  return hubFetch<HubBrainSeed[]>(`/api/templates/${encodeURIComponent(templateId)}/brain-seeds`);
+}
+
+export function isHubAvailable(): Promise<boolean> {
+  return hubFetch<{ ok: boolean }>('/api/health')
+    .then(() => true)
+    .catch(() => false);
+}

package/src/index.ts

@@ -78,6 +78,26 @@ export { TextAnalysisTool } from './tools/text-analysis';
 export { HttpSkill } from './skills/http';
 export { WebhookTriggerSkill } from './skills/webhook-trigger';
 export type { WebhookTarget } from './skills/webhook-trigger';
+
+// v0.9.0 channels
+export { DingTalkChannel } from './channels/dingtalk';
+export type { DingTalkChannelConfig } from './channels/dingtalk';
+export { MattermostChannel } from './channels/mattermost';
+export type { MattermostChannelConfig } from './channels/mattermost';
+export { GoogleChatChannel } from './channels/googlechat';
+export type { GoogleChatChannelConfig } from './channels/googlechat';
+export { TwitchChannel } from './channels/twitch';
+export type { TwitchChannelConfig } from './channels/twitch';
+export { IRCChannel } from './channels/irc';
+export type { IRCChannelConfig } from './channels/irc';
+
+// v0.9.0 core
+export { ContextDiscovery } from './core/context-discovery';
+export type { ContextFile } from './core/context-discovery';
+export { SessionManager } from './core/session-manager';
+export type { Session } from './core/session-manager';
+export { HeartbeatManager } from './core/heartbeat';
+export type { HeartbeatConfig } from './core/heartbeat';
 export { SchedulerSkill } from './skills/scheduler';
 export type { ScheduledTask } from './skills/scheduler';
 export { DocumentSkill } from './skills/document';
@@ -111,6 +131,20 @@ export { contentFilterPlugin, createContentFilterPlugin } from './plugins/conten
 export { GuardrailManager, createGuardrailsFromConfig } from './security/guardrails';
 export type { GuardrailConfig, GuardrailRule, GuardrailResult, GuardrailViolation } from './security/guardrails';
 
+// v3.1.0 — Exec Approvals + Elevated + Secrets
+export { ExecApprovalManager } from './security/approvals';
+export type { ExecApprovalPolicy, ExecApprovalRequest, ExecApprovalHistory, ApprovalRequestCallback } from './security/approvals';
+export { ElevatedManager } from './security/elevated';
+export type { ElevationMode, ElevationAuditEntry } from './security/elevated';
+export { SecretsManager } from './security/secrets';
+export type { SecretsStore } from './security/secrets';
+
+// v3.1.0 — Hooks + Audio
+export { HookManager, ALL_HOOK_EVENTS } from './core/hooks';
+export type { HookEvent, HookContext, HookHandler } from './core/hooks';
+export { AudioProcessor } from './core/audio';
+export type { AudioFormat, TranscribeOptions, SynthesizeOptions, TranscribeResult, SynthesizeResult } from './core/audio';
+
 // v1.1.0 modules
 export { FeishuChannel } from './channels/feishu';
 export type { FeishuChannelConfig } from './channels/feishu';
@@ -142,7 +176,9 @@ export { Scheduler, parseCron, cronMatches } from './core/scheduler';
 export type { CronJob, JobHandler } from './core/scheduler';
 
 // v1.5.0 — built-in tools + MCP client
-export { getBuiltinTools, getBuiltinToolsByName } from './tools/builtin';
+export { getBuiltinTools, getBuiltinToolsByName, rlTools, homeAssistantTools, configureHomeAssistant, webSearchTools, webSearchTool, webReadTool } from './tools/builtin';
+export { webSearch, parseDuckDuckGoHTML, type SearchResult as WebSearchResult, type WebSearchConfig, type SearchEngine } from './tools/web-search';
+export { scrapeUrl, extractReadableContent, type ScrapedContent } from './tools/web-scraper';
 export { MCPClient } from './tools/mcp-client';
 export type { MCPServerConfig } from './tools/mcp-client';
 
@@ -186,6 +222,55 @@ export type {
   StepStartedEvent, StepFinishedEvent, CustomEvent,
 } from './protocols/agui';
 
+// v2.1.0 — API Server + Context References
+export { APIServer } from './core/api-server';
+export type { APIServerConfig } from './core/api-server';
+export { ContextRefResolver } from './core/context-refs';
+export type { ContextRef, RefType } from './core/context-refs';
+
+// v2.2.0 — Vision
+export { VisionManager, detectMimeType } from './core/vision';
+export type { ImageInput, VisionResult, VisionManagerConfig } from './core/vision';
+export { visionTools, visionAnalyzeTool, visionExtractTextTool, visionCompareTool } from './tools/builtin/vision';
+
+// v2.2.0 — Additional channels
+export { WhatsAppChannel } from './channels/whatsapp';
+export type { WhatsAppChannelConfig } from './channels/whatsapp';
+export { SignalChannel } from './channels/signal';
+export type { SignalChannelConfig } from './channels/signal';
+export { MatrixChannel } from './channels/matrix';
+export type { MatrixChannelConfig } from './channels/matrix';
+export { IMessageChannel } from './channels/imessage';
+export type { IMessageChannelConfig } from './channels/imessage';
+export { LINEChannel } from './channels/line';
+export type { LINEChannelConfig } from './channels/line';
+export { MSTeamsChannel } from './channels/msteams';
+export type { MSTeamsChannelConfig } from './channels/msteams';
+export { QQChannel } from './channels/qq';
+export type { QQChannelConfig } from './channels/qq';
+export { NostrChannel } from './channels/nostr';
+export type { NostrChannelConfig } from './channels/nostr';
+export { SMSChannel } from './channels/sms';
+export type { SMSChannelConfig } from './channels/sms';
+
+// v2.3.0 — Voice Calls + IDE + Node Network + Gateway
+export { VoiceCallManager } from './channels/voice-call';
+export type { VoiceCallConfig } from './channels/voice-call';
+export { IDEBridge } from './core/ide-bridge';
+export type { IDEConfig, Diagnostic, TextEdit, Range, SearchOptions, SearchResult as IDESearchResult } from './core/ide-bridge';
+export { NodeNetwork } from './core/node-network';
+export type { RemoteNode } from './core/node-network';
+export { Gateway } from './core/gateway';
+export type { AgentConfig as GatewayAgentConfig, ChannelConfig as GatewayChannelConfig, GatewayConfig } from './core/gateway';
+
+// v2.2.0 — Remote Sandbox
+export { SandboxManager } from './core/sandbox';
+export type { RemoteSandboxConfig, ExecResult } from './core/sandbox';
+
+// v2.2.0 — Profiles
+export { ProfileManager } from './core/profiles';
+export type { Profile, ProfileConfig } from './core/profiles';
+
 // v2.0.0 - Pre-built tool integrations (20 tools)
 export {
   SlackTool, EmailSendTool, WebhookTool,