opc-agent 4.0.0 → 4.0.1

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

@@ -176,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, rlTools, homeAssistantTools, configureHomeAssistant } 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';
 
@@ -255,7 +257,7 @@ export type { SMSChannelConfig } from './channels/sms';
 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 } 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';

package/src/providers/index.ts

@@ -325,9 +325,72 @@ function isGeminiNative(): boolean {
   return key.startsWith('AQ.') || (baseUrl.includes('googleapis.com') && !baseUrl.includes('/openai'));
 }
 
+class ClaudeCLIProvider implements LLMProvider {
+  name = 'claude-cli';
+  private model: string;
+
+  constructor(model?: string) {
+    this.model = model || 'sonnet';
+  }
+
+  async chat(messages: Message[], systemPrompt?: string, options?: ChatOptions): Promise<string> {
+    const { execFile } = await import('child_process');
+    const { promisify } = await import('util');
+    const execFileAsync = promisify(execFile);
+
+    // Build the prompt from messages
+    const lastMessage = messages[messages.length - 1];
+    if (!lastMessage) return '';
+
+    let prompt = lastMessage.content;
+
+    // Add tool prompt if tools provided
+    if (options?.tools && options.tools.length > 0) {
+      prompt += buildToolPrompt(options.tools);
+    }
+
+    const args = ['--print'];
+    if (systemPrompt) {
+      args.push('--system-prompt', systemPrompt);
+    }
+    if (this.model) {
+      args.push('--model', this.model);
+    }
+    args.push(prompt);
+
+    try {
+      const { stdout } = await execFileAsync('claude', args, {
+        timeout: 120_000,
+        maxBuffer: 10 * 1024 * 1024,
+        env: { ...process.env },
+      });
+      return stdout.trim();
+    } catch (err: any) {
+      if (err.code === 'ENOENT') {
+        throw new Error(
+          'Claude CLI not found. Install it: npm install -g @anthropic-ai/claude-code\n' +
+          'Then authenticate: claude login'
+        );
+      }
+      throw new Error(`Claude CLI error: ${err.message}`);
+    }
+  }
+
+  async *chatStream(messages: Message[], systemPrompt?: string): AsyncIterable<string> {
+    // Claude CLI --print doesn't support streaming well, so we do single-shot
+    const result = await this.chat(messages, systemPrompt);
+    yield result;
+  }
+}
+
 export function createProvider(name: string = 'openai', model?: string, baseUrl?: string, apiKey?: string): LLMProvider {
   const finalModel = model || process.env.OPC_LLM_MODEL || 'gpt-4o-mini';
 
+  // Claude CLI mode: use local claude command (Claude Max/Pro subscription)
+  if (name === 'claude-cli' || process.env.OPC_LLM_PROVIDER === 'claude-cli') {
+    return new ClaudeCLIProvider(finalModel !== 'gpt-4o-mini' ? finalModel : undefined);
+  }
+
   if (name === 'ollama') {
     const ollamaBase = baseUrl || process.env.OPC_LLM_BASE_URL || 'http://localhost:11434/v1';
     const ollamaKey = apiKey || process.env.OPC_LLM_API_KEY || 'ollama';
@@ -351,4 +414,4 @@ export function createProvider(name: string = 'openai', model?: string, baseUrl?
   return new OpenAICompatibleProvider(resolvedName, finalModel, baseUrl, apiKey);
 }
 
-export const SUPPORTED_PROVIDERS = ['openai', 'ollama', 'deepseek', 'qwen', 'gemini', 'dashscope', 'zhipu', 'moonshot'] as const;
+export const SUPPORTED_PROVIDERS = ['openai', 'ollama', 'claude-cli', 'deepseek', 'qwen', 'gemini', 'dashscope', 'zhipu', 'moonshot'] as const;

package/src/scheduler/cron-engine.ts

@@ -0,0 +1,191 @@
+/**
+ * Cron Engine — persistent scheduler with file-based storage.
+ * Manages scheduled tasks with cron expressions, persists to ~/.opc/schedules.json,
+ * and auto-recovers on startup.
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import * as os from 'os';
+import { parseCron, cronMatches, Scheduler } from '../core/scheduler';
+import type { CronJob, JobHandler } from '../core/scheduler';
+
+export interface ScheduleTask {
+  id: string;
+  name: string;
+  schedule: string;        // cron expression
+  description: string;     // natural language description
+  frequency: 'daily' | 'weekly' | 'monthly' | 'custom';
+  time?: string;           // HH:mm for simple schedules
+  outputChannel: 'telegram' | 'email' | 'web';
+  enabled: boolean;
+  createdAt: string;
+  updatedAt: string;
+  lastRun?: string;
+  nextRun?: string;
+}
+
+export interface SchedulesStore {
+  tasks: ScheduleTask[];
+}
+
+function getSchedulesPath(): string {
+  const dir = join(os.homedir(), '.opc');
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  return join(dir, 'schedules.json');
+}
+
+function loadSchedules(): SchedulesStore {
+  const p = getSchedulesPath();
+  if (existsSync(p)) {
+    try { return JSON.parse(readFileSync(p, 'utf-8')); } catch { /* ignore */ }
+  }
+  return { tasks: [] };
+}
+
+function saveSchedules(store: SchedulesStore): void {
+  writeFileSync(getSchedulesPath(), JSON.stringify(store, null, 2));
+}
+
+/** Convert frequency + time to cron expression */
+export function frequencyToCron(frequency: string, time?: string): string {
+  const [hour, minute] = (time || '09:00').split(':').map(Number);
+  switch (frequency) {
+    case 'daily':   return `${minute} ${hour} * * *`;
+    case 'weekly':  return `${minute} ${hour} * * 1`;
+    case 'monthly': return `${minute} ${hour} 1 * *`;
+    default:        return '0 9 * * *'; // fallback
+  }
+}
+
+/** Compute next run from a cron expression */
+function computeNextRun(cronExpr: string): string | undefined {
+  try {
+    const parsed = parseCron(cronExpr);
+    const d = new Date();
+    d.setSeconds(0, 0);
+    d.setMinutes(d.getMinutes() + 1);
+    for (let i = 0; i < 48 * 60; i++) {
+      if (cronMatches(parsed, d)) return d.toISOString();
+      d.setMinutes(d.getMinutes() + 1);
+    }
+  } catch { /* ignore */ }
+  return undefined;
+}
+
+export class CronEngine {
+  private scheduler: Scheduler;
+  private store: SchedulesStore;
+  private handler: JobHandler;
+
+  constructor(handler?: JobHandler) {
+    this.handler = handler || (async (job) => {
+      console.log(`[cron-engine] Executing job: ${job.name} (${job.id})`);
+    });
+    this.scheduler = new Scheduler(this.handler);
+    this.store = loadSchedules();
+  }
+
+  /** Initialize and recover persisted tasks */
+  start(): void {
+    for (const task of this.store.tasks) {
+      if (task.enabled) {
+        this.scheduler.addJob({
+          id: task.id,
+          name: task.name,
+          schedule: task.schedule,
+          task: task.description,
+          enabled: true,
+        });
+      }
+    }
+    this.scheduler.start();
+    console.log(`[cron-engine] Started with ${this.store.tasks.filter(t => t.enabled).length} active tasks`);
+  }
+
+  stop(): void {
+    this.scheduler.stop();
+  }
+
+  listTasks(): ScheduleTask[] {
+    // Refresh nextRun
+    return this.store.tasks.map(t => ({
+      ...t,
+      nextRun: t.enabled ? computeNextRun(t.schedule) : undefined,
+    }));
+  }
+
+  getTask(id: string): ScheduleTask | undefined {
+    return this.store.tasks.find(t => t.id === id);
+  }
+
+  createTask(input: Omit<ScheduleTask, 'id' | 'createdAt' | 'updatedAt' | 'lastRun' | 'nextRun'>): ScheduleTask {
+    const id = `sched-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+    const now = new Date().toISOString();
+    const schedule = input.schedule || frequencyToCron(input.frequency, input.time);
+    const task: ScheduleTask = {
+      ...input,
+      id,
+      schedule,
+      createdAt: now,
+      updatedAt: now,
+      nextRun: input.enabled ? computeNextRun(schedule) : undefined,
+    };
+    this.store.tasks.push(task);
+    saveSchedules(this.store);
+
+    if (task.enabled) {
+      this.scheduler.addJob({
+        id: task.id,
+        name: task.name,
+        schedule: task.schedule,
+        task: task.description,
+        enabled: true,
+      });
+    }
+    return task;
+  }
+
+  updateTask(id: string, updates: Partial<ScheduleTask>): ScheduleTask | null {
+    const idx = this.store.tasks.findIndex(t => t.id === id);
+    if (idx === -1) return null;
+
+    const task = { ...this.store.tasks[idx], ...updates, id, updatedAt: new Date().toISOString() };
+    if (updates.frequency || updates.time) {
+      task.schedule = updates.schedule || frequencyToCron(task.frequency, task.time);
+    }
+    task.nextRun = task.enabled ? computeNextRun(task.schedule) : undefined;
+    this.store.tasks[idx] = task;
+    saveSchedules(this.store);
+
+    // Update scheduler
+    this.scheduler.removeJob(id);
+    if (task.enabled) {
+      this.scheduler.addJob({
+        id: task.id,
+        name: task.name,
+        schedule: task.schedule,
+        task: task.description,
+        enabled: true,
+      });
+    }
+    return task;
+  }
+
+  deleteTask(id: string): boolean {
+    const idx = this.store.tasks.findIndex(t => t.id === id);
+    if (idx === -1) return false;
+    this.store.tasks.splice(idx, 1);
+    saveSchedules(this.store);
+    this.scheduler.removeJob(id);
+    return true;
+  }
+
+  async runTask(id: string): Promise<boolean> {
+    const task = this.store.tasks.find(t => t.id === id);
+    if (!task) return false;
+    task.lastRun = new Date().toISOString();
+    saveSchedules(this.store);
+    return this.scheduler.runJob(id);
+  }
+}

package/src/scheduler/index.ts

@@ -0,0 +1,2 @@
+export { CronEngine, frequencyToCron } from './cron-engine';
+export type { ScheduleTask, SchedulesStore } from './cron-engine';