opc-agent 3.0.0 → 4.0.0

package/src/core/ide-bridge.ts

@@ -0,0 +1,133 @@
+import { execSync } from 'child_process';
+
+export interface IDEConfig {
+  editor: 'vscode' | 'jetbrains' | 'zed' | 'cursor';
+  workspacePath?: string;
+}
+
+export interface Diagnostic {
+  path: string;
+  line: number;
+  column: number;
+  severity: 'error' | 'warning' | 'info';
+  message: string;
+}
+
+export interface TextEdit {
+  range: Range;
+  newText: string;
+}
+
+export interface Range {
+  startLine: number;
+  startColumn: number;
+  endLine: number;
+  endColumn: number;
+}
+
+export interface SearchOptions {
+  caseSensitive?: boolean;
+  regex?: boolean;
+  include?: string;
+  exclude?: string;
+  maxResults?: number;
+}
+
+export interface SearchResult {
+  path: string;
+  line: number;
+  column: number;
+  text: string;
+}
+
+export class IDEBridge {
+  private config: IDEConfig;
+
+  constructor(config: IDEConfig) {
+    this.config = config;
+  }
+
+  private getCliCommand(): string {
+    switch (this.config.editor) {
+      case 'vscode': case 'cursor': return this.config.editor === 'cursor' ? 'cursor' : 'code';
+      case 'jetbrains': return 'idea';
+      case 'zed': return 'zed';
+    }
+  }
+
+  private exec(cmd: string): string {
+    try {
+      return execSync(cmd, { encoding: 'utf-8', timeout: 10000, cwd: this.config.workspacePath }).trim();
+    } catch (e: any) {
+      throw new Error(`IDE command failed: ${e.message}`);
+    }
+  }
+
+  async openFile(path: string, line?: number): Promise<void> {
+    const cli = this.getCliCommand();
+    const target = line ? `${path}:${line}` : path;
+    if (this.config.editor === 'vscode' || this.config.editor === 'cursor') {
+      this.exec(`${cli} --goto "${target}"`);
+    } else if (this.config.editor === 'zed') {
+      this.exec(`zed "${target}"`);
+    } else {
+      this.exec(`${cli} --line ${line || 1} "${path}"`);
+    }
+  }
+
+  async getDiagnostics(path?: string): Promise<Diagnostic[]> {
+    // VS Code doesn't expose diagnostics via CLI; return empty as stub
+    return [];
+  }
+
+  async runCommand(command: string): Promise<string> {
+    const cli = this.getCliCommand();
+    if (this.config.editor === 'vscode' || this.config.editor === 'cursor') {
+      return this.exec(`${cli} --command "${command}"`);
+    }
+    throw new Error(`runCommand not supported for ${this.config.editor}`);
+  }
+
+  async getOpenFiles(): Promise<string[]> {
+    // Stub — no standard CLI to get open files
+    return [];
+  }
+
+  async applyEdit(path: string, edits: TextEdit[]): Promise<void> {
+    // Stub — would use editor's API/extension
+    if (edits.length === 0) return;
+    throw new Error('applyEdit requires an IDE extension to be installed. Use file system edits as fallback.');
+  }
+
+  async search(query: string, options?: SearchOptions): Promise<SearchResult[]> {
+    const cli = this.getCliCommand();
+    if (this.config.editor === 'vscode' || this.config.editor === 'cursor') {
+      try {
+        const args = [`--search "${query}"`];
+        if (options?.include) args.push(`--include "${options.include}"`);
+        const output = this.exec(`${cli} ${args.join(' ')}`);
+        // Parse output lines
+        return output.split('\n').filter(Boolean).map(line => {
+          const match = line.match(/^(.+):(\d+):(\d+):(.*)$/);
+          if (!match) return { path: '', line: 0, column: 0, text: line };
+          return { path: match[1], line: parseInt(match[2]), column: parseInt(match[3]), text: match[4] };
+        });
+      } catch { return []; }
+    }
+    return [];
+  }
+
+  async getSelection(): Promise<{ path: string; text: string; range: Range } | null> {
+    // Stub — requires editor extension
+    return null;
+  }
+
+  async installExtension(extensionId: string): Promise<void> {
+    const cli = this.getCliCommand();
+    if (this.config.editor === 'vscode' || this.config.editor === 'cursor') {
+      this.exec(`${cli} --install-extension ${extensionId}`);
+    } else {
+      throw new Error(`installExtension not supported for ${this.config.editor}`);
+    }
+  }
+}

package/src/core/node-network.ts

@@ -0,0 +1,86 @@
+import { randomUUID } from 'crypto';
+import { EventEmitter } from 'events';
+
+export interface RemoteNode {
+  id: string;
+  name: string;
+  host: string;
+  port: number;
+  type: 'vps' | 'pi' | 'phone' | 'desktop';
+  status: 'online' | 'offline' | 'pairing';
+  capabilities: string[];
+  lastSeen: number;
+}
+
+export class NodeNetwork extends EventEmitter {
+  private nodes = new Map<string, RemoteNode>();
+
+  addNode(config: Partial<RemoteNode>): RemoteNode {
+    const node: RemoteNode = {
+      id: config.id || randomUUID(),
+      name: config.name || 'unnamed',
+      host: config.host || 'localhost',
+      port: config.port || 8080,
+      type: config.type || 'desktop',
+      status: config.status || 'offline',
+      capabilities: config.capabilities || [],
+      lastSeen: Date.now(),
+    };
+    this.nodes.set(node.id, node);
+    return node;
+  }
+
+  removeNode(id: string): void {
+    if (!this.nodes.has(id)) throw new Error(`Node ${id} not found`);
+    this.nodes.delete(id);
+  }
+
+  listNodes(): RemoteNode[] {
+    return Array.from(this.nodes.values());
+  }
+
+  getNode(id: string): RemoteNode | null {
+    return this.nodes.get(id) || null;
+  }
+
+  async pair(nodeId: string, pairingCode: string): Promise<boolean> {
+    const node = this.nodes.get(nodeId);
+    if (!node) throw new Error(`Node ${nodeId} not found`);
+    if (!pairingCode || pairingCode.length < 4) return false;
+    node.status = 'online';
+    node.lastSeen = Date.now();
+    return true;
+  }
+
+  async sendCommand(nodeId: string, command: string): Promise<any> {
+    const node = this.nodes.get(nodeId);
+    if (!node) throw new Error(`Node ${nodeId} not found`);
+    if (node.status !== 'online') throw new Error(`Node ${nodeId} is ${node.status}`);
+    node.lastSeen = Date.now();
+    // Stub: return command echo
+    return { nodeId, command, status: 'sent', timestamp: Date.now() };
+  }
+
+  async broadcast(command: string): Promise<Map<string, any>> {
+    const results = new Map<string, any>();
+    for (const [id, node] of this.nodes) {
+      if (node.status === 'online') {
+        try {
+          results.set(id, await this.sendCommand(id, command));
+        } catch (e: any) {
+          results.set(id, { error: e.message });
+        }
+      }
+    }
+    return results;
+  }
+
+  async healthCheck(): Promise<Map<string, boolean>> {
+    const results = new Map<string, boolean>();
+    for (const [id, node] of this.nodes) {
+      results.set(id, node.status === 'online');
+      node.lastSeen = Date.now();
+    }
+    return results;
+  }
+}

package/src/core/profiles.ts

@@ -0,0 +1,122 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+// ─── Types ───────────────────────────────────────────────────
+
+export interface ProfileConfig {
+  model?: string;
+  systemPrompt?: string;
+  temperature?: number;
+  [key: string]: unknown;
+}
+
+export interface Profile {
+  name: string;
+  config: ProfileConfig;
+  createdAt: number;
+  lastUsed: number;
+}
+
+// ─── ProfileManager ─────────────────────────────────────────
+
+export class ProfileManager {
+  private profilesDir: string;
+  private currentName: string = 'default';
+
+  constructor(baseDir?: string) {
+    this.profilesDir = baseDir ?? path.join(os.homedir(), '.opc', 'profiles');
+    this.ensureDir(this.profilesDir);
+
+    // Load current profile pointer
+    const pointerFile = path.join(this.profilesDir, '.current');
+    if (fs.existsSync(pointerFile)) {
+      this.currentName = fs.readFileSync(pointerFile, 'utf-8').trim();
+    }
+  }
+
+  private ensureDir(dir: string): void {
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+  }
+
+  private profileDir(name: string): string {
+    return path.join(this.profilesDir, name);
+  }
+
+  private profileFile(name: string): string {
+    return path.join(this.profileDir(name), 'profile.json');
+  }
+
+  create(name: string, config: ProfileConfig = {}): Profile {
+    const dir = this.profileDir(name);
+    if (fs.existsSync(dir)) {
+      throw new Error(`Profile '${name}' already exists`);
+    }
+    this.ensureDir(dir);
+    // Also create memory and sessions dirs
+    this.ensureDir(path.join(dir, 'memory'));
+    this.ensureDir(path.join(dir, 'sessions'));
+
+    const profile: Profile = {
+      name,
+      config,
+      createdAt: Date.now(),
+      lastUsed: Date.now(),
+    };
+    fs.writeFileSync(this.profileFile(name), JSON.stringify(profile, null, 2));
+    return profile;
+  }
+
+  switch(name: string): void {
+    if (!fs.existsSync(this.profileDir(name))) {
+      throw new Error(`Profile '${name}' does not exist`);
+    }
+    this.currentName = name;
+    fs.writeFileSync(path.join(this.profilesDir, '.current'), name);
+
+    // Update lastUsed
+    const profile = this.get(name);
+    profile.lastUsed = Date.now();
+    fs.writeFileSync(this.profileFile(name), JSON.stringify(profile, null, 2));
+  }
+
+  list(): Profile[] {
+    if (!fs.existsSync(this.profilesDir)) return [];
+    return fs.readdirSync(this.profilesDir)
+      .filter(f => {
+        const full = path.join(this.profilesDir, f);
+        return fs.statSync(full).isDirectory() && fs.existsSync(path.join(full, 'profile.json'));
+      })
+      .map(f => this.get(f));
+  }
+
+  get(name: string): Profile {
+    const file = this.profileFile(name);
+    if (!fs.existsSync(file)) {
+      throw new Error(`Profile '${name}' not found`);
+    }
+    return JSON.parse(fs.readFileSync(file, 'utf-8'));
+  }
+
+  delete(name: string): void {
+    if (name === this.currentName) {
+      throw new Error(`Cannot delete the current active profile '${name}'`);
+    }
+    const dir = this.profileDir(name);
+    if (!fs.existsSync(dir)) {
+      throw new Error(`Profile '${name}' does not exist`);
+    }
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+
+  current(): Profile {
+    try {
+      return this.get(this.currentName);
+    } catch {
+      // Auto-create default
+      return this.create(this.currentName);
+    }
+  }
+}

package/src/core/sandbox.ts

@@ -242,3 +242,103 @@ export class Sandbox {
     return this.maxFiles;
   }
 }
+
+// ─── Remote Sandbox Manager (v2.2.0) ────────────────────────
+
+export interface RemoteSandboxConfig {
+  backend: 'local' | 'docker' | 'ssh';
+  docker?: { image: string; volumes?: string[] };
+  ssh?: { host: string; user: string; keyPath?: string };
+  timeout?: number;
+}
+
+export interface ExecResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+}
+
+export class SandboxManager {
+  private defaultConfig: RemoteSandboxConfig;
+
+  constructor(config?: Partial<RemoteSandboxConfig>) {
+    this.defaultConfig = {
+      backend: config?.backend ?? 'local',
+      docker: config?.docker,
+      ssh: config?.ssh,
+      timeout: config?.timeout ?? 30000,
+    };
+  }
+
+  async exec(command: string, config?: Partial<RemoteSandboxConfig>): Promise<ExecResult> {
+    const cfg = { ...this.defaultConfig, ...config };
+    const { execSync } = await import('child_process');
+
+    switch (cfg.backend) {
+      case 'local': {
+        try {
+          const stdout = execSync(command, {
+            timeout: cfg.timeout,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+          });
+          return { stdout: stdout ?? '', stderr: '', exitCode: 0 };
+        } catch (err: any) {
+          return {
+            stdout: err.stdout ?? '',
+            stderr: err.stderr ?? '',
+            exitCode: err.status ?? 1,
+          };
+        }
+      }
+      case 'docker': {
+        if (!cfg.docker?.image) throw new Error('Docker image is required');
+        const volumes = (cfg.docker.volumes ?? []).map(v => `-v ${v}`).join(' ');
+        const dockerCmd = `docker run --rm ${volumes} ${cfg.docker.image} sh -c "${command.replace(/"/g, '\\"')}"`;
+        return this.exec(dockerCmd, { backend: 'local', timeout: cfg.timeout });
+      }
+      case 'ssh': {
+        if (!cfg.ssh?.host || !cfg.ssh?.user) throw new Error('SSH host and user are required');
+        const keyArg = cfg.ssh.keyPath ? `-i ${cfg.ssh.keyPath}` : '';
+        const sshCmd = `ssh ${keyArg} ${cfg.ssh.user}@${cfg.ssh.host} "${command.replace(/"/g, '\\"')}"`;
+        return this.exec(sshCmd, { backend: 'local', timeout: cfg.timeout });
+      }
+      default:
+        throw new Error(`Unknown sandbox backend: ${cfg.backend}`);
+    }
+  }
+
+  async upload(localPath: string, remotePath: string, config?: Partial<RemoteSandboxConfig>): Promise<void> {
+    const cfg = { ...this.defaultConfig, ...config };
+    if (cfg.backend === 'local') {
+      const fsp = await import('fs');
+      fsp.copyFileSync(localPath, remotePath);
+      return;
+    }
+    if (cfg.backend === 'ssh') {
+      const keyArg = cfg.ssh?.keyPath ? `-i ${cfg.ssh.keyPath}` : '';
+      await this.exec(`scp ${keyArg} "${localPath}" ${cfg.ssh!.user}@${cfg.ssh!.host}:"${remotePath}"`, { backend: 'local' });
+      return;
+    }
+    if (cfg.backend === 'docker') {
+      throw new Error('Upload to docker not yet supported. Use volumes instead.');
+    }
+  }
+
+  async download(remotePath: string, localPath: string, config?: Partial<RemoteSandboxConfig>): Promise<void> {
+    const cfg = { ...this.defaultConfig, ...config };
+    if (cfg.backend === 'local') {
+      const fsp = await import('fs');
+      fsp.copyFileSync(remotePath, localPath);
+      return;
+    }
+    if (cfg.backend === 'ssh') {
+      const keyArg = cfg.ssh?.keyPath ? `-i ${cfg.ssh.keyPath}` : '';
+      await this.exec(`scp ${keyArg} ${cfg.ssh!.user}@${cfg.ssh!.host}:"${remotePath}" "${localPath}"`, { backend: 'local' });
+      return;
+    }
+    if (cfg.backend === 'docker') {
+      throw new Error('Download from docker not yet supported. Use volumes instead.');
+    }
+  }
+}

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);
+    }
+  }
+}