opc-agent 4.1.1 → 4.1.3

package/src/core/sandbox.ts

@@ -1,344 +0,0 @@
-import type { TrustLevelType } from '../schema/oad';
-import * as path from 'path';
-import * as fs from 'fs';
-
-export interface SandboxConfig {
-  trustLevel: TrustLevelType;
-  agentDir: string;
-  networkAllowlist?: string[];
-  shellAllowed?: boolean;
-  allowedCommands?: string[];
-  blockedCommands?: string[];
-  maxFileSize?: number;       // bytes, default 10MB
-  maxFiles?: number;          // max files in workspace, default 1000
-  networkAccess?: boolean;    // allow network, default true
-  readOnlyPaths?: string[];   // paths that can't be written
-  timeout?: number;           // global timeout ms
-}
-
-export interface ValidationResult {
-  allowed: boolean;
-  reason?: string;
-}
-
-export interface SandboxStatus {
-  files: number;
-  totalSize: number;
-  violations: number;
-}
-
-export interface SandboxRestrictions {
-  fileSystem: { read: string[]; write: string[] };
-  network: { allowed: string[] };
-  shell: boolean;
-}
-
-const TRUST_RESTRICTIONS: Record<string, SandboxRestrictions> = {
-  sandbox: {
-    fileSystem: { read: ['.'], write: ['.'] },
-    network: { allowed: [] },
-    shell: false,
-  },
-  verified: {
-    fileSystem: { read: ['.', '..'], write: ['.'] },
-    network: { allowed: ['*.deepleaper.com', 'api.openai.com', 'api.deepseek.com'] },
-    shell: false,
-  },
-  certified: {
-    fileSystem: { read: ['*'], write: ['.', '..'] },
-    network: { allowed: ['*'] },
-    shell: true,
-  },
-  listed: {
-    fileSystem: { read: ['*'], write: ['*'] },
-    network: { allowed: ['*'] },
-    shell: true,
-  },
-};
-
-export class Sandbox {
-  private config: SandboxConfig;
-  private restrictions: SandboxRestrictions;
-  private violations: number = 0;
-  private maxFileSize: number;
-  private maxFiles: number;
-
-  constructor(config: SandboxConfig) {
-    this.config = config;
-    this.restrictions = {
-      ...TRUST_RESTRICTIONS[config.trustLevel] ?? TRUST_RESTRICTIONS.sandbox,
-    };
-    if (config.networkAllowlist) {
-      this.restrictions.network.allowed = config.networkAllowlist;
-    }
-    if (config.shellAllowed !== undefined) {
-      this.restrictions.shell = config.shellAllowed;
-    }
-    if (config.networkAccess === false) {
-      this.restrictions.network.allowed = [];
-    }
-    this.maxFileSize = config.maxFileSize ?? 10 * 1024 * 1024; // 10MB
-    this.maxFiles = config.maxFiles ?? 1000;
-  }
-
-  get trustLevel(): TrustLevelType {
-    return this.config.trustLevel;
-  }
-
-  getRestrictions(): SandboxRestrictions {
-    return { ...this.restrictions };
-  }
-
-  checkFileAccess(filePath: string, mode: 'read' | 'write'): boolean {
-    const resolved = path.resolve(filePath);
-    const agentDir = path.resolve(this.config.agentDir);
-    const allowedPaths = mode === 'read' ? this.restrictions.fileSystem.read : this.restrictions.fileSystem.write;
-
-    if (allowedPaths.includes('*')) return true;
-
-    for (const allowed of allowedPaths) {
-      const allowedResolved = path.resolve(this.config.agentDir, allowed);
-      if (resolved.startsWith(allowedResolved)) return true;
-    }
-
-    // Always allow access within agent's own directory
-    return resolved.startsWith(agentDir);
-  }
-
-  checkNetworkAccess(url: string): boolean {
-    if (this.restrictions.network.allowed.includes('*')) return true;
-    if (this.restrictions.network.allowed.length === 0) return false;
-
-    try {
-      const hostname = new URL(url).hostname;
-      return this.restrictions.network.allowed.some((pattern) => {
-        if (pattern.startsWith('*.')) {
-          return hostname.endsWith(pattern.slice(1));
-        }
-        return hostname === pattern;
-      });
-    } catch {
-      return false;
-    }
-  }
-
-  checkShellAccess(): boolean {
-    return this.restrictions.shell;
-  }
-
-  validateFileOp(action: 'read' | 'write' | 'delete', filePath: string): ValidationResult {
-    const resolved = path.resolve(filePath);
-
-    if (action === 'write' || action === 'delete') {
-      // Check read-only paths
-      if (this.config.readOnlyPaths) {
-        for (const ro of this.config.readOnlyPaths) {
-          const roResolved = path.resolve(ro);
-          if (resolved.startsWith(roResolved) || resolved === roResolved) {
-            this.violations++;
-            return { allowed: false, reason: `Path is read-only: ${ro}` };
-          }
-        }
-      }
-
-      // Check file size for writes
-      if (action === 'write') {
-        try {
-          if (fs.existsSync(resolved)) {
-            const stat = fs.statSync(resolved);
-            if (stat.size > this.maxFileSize) {
-              this.violations++;
-              return { allowed: false, reason: `File exceeds max size: ${this.maxFileSize} bytes` };
-            }
-          }
-        } catch {
-          // File doesn't exist yet — that's fine
-        }
-      }
-    }
-
-    const mode = action === 'read' ? 'read' : 'write';
-    if (!this.checkFileAccess(filePath, mode)) {
-      this.violations++;
-      return { allowed: false, reason: `File access denied for ${action}: ${filePath}` };
-    }
-
-    return { allowed: true };
-  }
-
-  validateCommand(command: string): ValidationResult {
-    if (!this.restrictions.shell) {
-      this.violations++;
-      return { allowed: false, reason: 'Shell access is disabled' };
-    }
-
-    // Check blocklist
-    if (this.config.blockedCommands) {
-      for (const blocked of this.config.blockedCommands) {
-        if (command.includes(blocked)) {
-          this.violations++;
-          return { allowed: false, reason: `Command is blocked: ${blocked}` };
-        }
-      }
-    }
-
-    // Check allowlist (if set, only allowed commands pass)
-    if (this.config.allowedCommands && this.config.allowedCommands.length > 0) {
-      const allowed = this.config.allowedCommands.some(a => command.startsWith(a) || command.includes(a));
-      if (!allowed) {
-        this.violations++;
-        return { allowed: false, reason: 'Command not in allowlist' };
-      }
-    }
-
-    return { allowed: true };
-  }
-
-  validateNetwork(url: string): ValidationResult {
-    if (this.config.networkAccess === false) {
-      this.violations++;
-      return { allowed: false, reason: 'Network access is disabled' };
-    }
-    if (!this.checkNetworkAccess(url)) {
-      this.violations++;
-      return { allowed: false, reason: `Network access denied for: ${url}` };
-    }
-    return { allowed: true };
-  }
-
-  getStatus(): SandboxStatus {
-    let files = 0;
-    let totalSize = 0;
-    try {
-      const agentDir = path.resolve(this.config.agentDir);
-      if (fs.existsSync(agentDir)) {
-        const countFiles = (dir: string) => {
-          const entries = fs.readdirSync(dir, { withFileTypes: true });
-          for (const entry of entries) {
-            const full = path.join(dir, entry.name);
-            if (entry.isDirectory() && entry.name !== 'node_modules') {
-              countFiles(full);
-            } else if (entry.isFile()) {
-              files++;
-              try { totalSize += fs.statSync(full).size; } catch {}
-            }
-          }
-        };
-        countFiles(agentDir);
-      }
-    } catch {}
-    return { files, totalSize, violations: this.violations };
-  }
-
-  getViolations(): number {
-    return this.violations;
-  }
-
-  getMaxFileSize(): number {
-    return this.maxFileSize;
-  }
-
-  getMaxFiles(): number {
-    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/scheduler.ts

@@ -1,187 +0,0 @@
-/**
- * Simple cron scheduler — no external dependencies.
- * Supports cron expressions: star, star-slash-N, M-N, M,N for minute/hour/day/month/weekday.
- */
-
-export interface CronJob {
-  id: string;
-  name: string;
-  schedule: string;
-  task: string;
-  enabled: boolean;
-  lastRun?: Date;
-  nextRun?: Date;
-}
-
-type CronField = { type: 'any' } | { type: 'every'; step: number } | { type: 'list'; values: number[] };
-
-interface ParsedCron {
-  minute: CronField;
-  hour: CronField;
-  dayOfMonth: CronField;
-  month: CronField;
-  dayOfWeek: CronField;
-}
-
-function parseField(field: string, min: number, max: number): CronField {
-  if (field === '*') return { type: 'any' };
-  if (field.startsWith('*/')) {
-    const step = parseInt(field.slice(2), 10);
-    if (isNaN(step) || step <= 0) throw new Error(`Invalid cron step: ${field}`);
-    return { type: 'every', step };
-  }
-  // Could be comma-separated, each part could be a range
-  const values: number[] = [];
-  for (const part of field.split(',')) {
-    if (part.includes('-')) {
-      const [a, b] = part.split('-').map(Number);
-      if (isNaN(a) || isNaN(b)) throw new Error(`Invalid cron range: ${part}`);
-      for (let i = a; i <= b; i++) values.push(i);
-    } else {
-      const n = parseInt(part, 10);
-      if (isNaN(n)) throw new Error(`Invalid cron value: ${part}`);
-      values.push(n);
-    }
-  }
-  return { type: 'list', values };
-}
-
-export function parseCron(expr: string): ParsedCron {
-  const parts = expr.trim().split(/\s+/);
-  if (parts.length !== 5) throw new Error(`Invalid cron expression (need 5 fields): ${expr}`);
-  return {
-    minute: parseField(parts[0], 0, 59),
-    hour: parseField(parts[1], 0, 23),
-    dayOfMonth: parseField(parts[2], 1, 31),
-    month: parseField(parts[3], 1, 12),
-    dayOfWeek: parseField(parts[4], 0, 6),
-  };
-}
-
-function fieldMatches(field: CronField, value: number): boolean {
-  switch (field.type) {
-    case 'any': return true;
-    case 'every': return value % field.step === 0;
-    case 'list': return field.values.includes(value);
-  }
-}
-
-export function cronMatches(parsed: ParsedCron, date: Date): boolean {
-  return (
-    fieldMatches(parsed.minute, date.getMinutes()) &&
-    fieldMatches(parsed.hour, date.getHours()) &&
-    fieldMatches(parsed.dayOfMonth, date.getDate()) &&
-    fieldMatches(parsed.month, date.getMonth() + 1) &&
-    fieldMatches(parsed.dayOfWeek, date.getDay())
-  );
-}
-
-/** Compute approximate next run (scans forward up to 48h). */
-function computeNextRun(parsed: ParsedCron, from: Date): Date | undefined {
-  const d = new Date(from);
-  d.setSeconds(0, 0);
-  d.setMinutes(d.getMinutes() + 1);
-  const limit = 48 * 60; // 48 hours in minutes
-  for (let i = 0; i < limit; i++) {
-    if (cronMatches(parsed, d)) return new Date(d);
-    d.setMinutes(d.getMinutes() + 1);
-  }
-  return undefined;
-}
-
-export type JobHandler = (job: CronJob) => void | Promise<void>;
-
-export class Scheduler {
-  private jobs = new Map<string, CronJob>();
-  private parsed = new Map<string, ParsedCron>();
-  private timer: ReturnType<typeof setInterval> | null = null;
-  private handler: JobHandler;
-
-  constructor(handler: JobHandler) {
-    this.handler = handler;
-  }
-
-  addJob(job: CronJob): void {
-    const p = parseCron(job.schedule);
-    this.parsed.set(job.id, p);
-    job.nextRun = computeNextRun(p, new Date()) ?? undefined;
-    this.jobs.set(job.id, job);
-  }
-
-  removeJob(id: string): void {
-    this.jobs.delete(id);
-    this.parsed.delete(id);
-  }
-
-  enableJob(id: string): void {
-    const job = this.jobs.get(id);
-    if (job) job.enabled = true;
-  }
-
-  disableJob(id: string): void {
-    const job = this.jobs.get(id);
-    if (job) job.enabled = false;
-  }
-
-  getJobs(): CronJob[] {
-    return Array.from(this.jobs.values());
-  }
-
-  getJob(id: string): CronJob | undefined {
-    return this.jobs.get(id);
-  }
-
-  /** Run a specific job immediately */
-  async runJob(id: string): Promise<boolean> {
-    const job = this.jobs.get(id);
-    if (!job) return false;
-    job.lastRun = new Date();
-    await this.handler(job);
-    const parsed = this.parsed.get(id);
-    if (parsed) job.nextRun = computeNextRun(parsed, new Date());
-    return true;
-  }
-
-  start(): void {
-    if (this.timer) return;
-    // Check every 60 seconds
-    this.timer = setInterval(() => this.tick(), 60_000);
-    // Also tick immediately
-    this.tick();
-  }
-
-  stop(): void {
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = null;
-    }
-  }
-
-  private tick(): void {
-    const now = new Date();
-    for (const [id, job] of this.jobs) {
-      if (!job.enabled) continue;
-      const parsed = this.parsed.get(id);
-      if (!parsed) continue;
-      if (cronMatches(parsed, now)) {
-        // Avoid double-fire: check lastRun isn't same minute
-        if (job.lastRun) {
-          const last = job.lastRun;
-          if (last.getFullYear() === now.getFullYear() &&
-              last.getMonth() === now.getMonth() &&
-              last.getDate() === now.getDate() &&
-              last.getHours() === now.getHours() &&
-              last.getMinutes() === now.getMinutes()) {
-            continue;
-          }
-        }
-        job.lastRun = new Date(now);
-        job.nextRun = computeNextRun(parsed, now);
-        // Fire and forget (log errors)
-        Promise.resolve(this.handler(job)).catch((err) => {
-          console.error(`[scheduler] Job "${job.name}" failed:`, err);
-        });
-      }
-    }
-  }
-}

package/src/core/security.ts

@@ -1,171 +0,0 @@
-/**
- * Security Hardening Module - v1.0.0
- * Input sanitization, CORS, security headers, API key rotation.
- */
-
-import type { Request, Response, NextFunction } from 'express';
-
-// ── Input Sanitization ──────────────────────────────────────
-
-const XSS_PATTERNS = [
-  /<script\b[^>]*>[\s\S]*?<\/script>/gi,
-  /javascript:/gi,
-  /on\w+\s*=/gi,
-  /<iframe\b/gi,
-  /<object\b/gi,
-  /<embed\b/gi,
-  /<form\b/gi,
-];
-
-const SQL_PATTERNS = [
-  /(\b(SELECT|INSERT|UPDATE|DELETE|DROP|UNION|ALTER|CREATE|EXEC)\b.*\b(FROM|INTO|TABLE|SET|WHERE|ALL)\b)/gi,
-  /(--|;)\s*(DROP|ALTER|DELETE)/gi,
-];
-
-export function sanitizeInput(input: string): string {
-  let clean = input;
-  for (const pattern of XSS_PATTERNS) {
-    clean = clean.replace(pattern, '');
-  }
-  // Encode dangerous HTML entities
-  clean = clean.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
-  return clean;
-}
-
-export function detectInjection(input: string): { safe: boolean; threats: string[] } {
-  const threats: string[] = [];
-  for (const pattern of XSS_PATTERNS) {
-    if (pattern.test(input)) threats.push('xss');
-    pattern.lastIndex = 0;
-  }
-  for (const pattern of SQL_PATTERNS) {
-    if (pattern.test(input)) threats.push('sql_injection');
-    pattern.lastIndex = 0;
-  }
-  return { safe: threats.length === 0, threats: [...new Set(threats)] };
-}
-
-// ── Security Headers (Helmet-style) ────────────────────────
-
-export interface SecurityHeadersConfig {
-  contentSecurityPolicy?: string;
-  enableHSTS?: boolean;
-  frameDeny?: boolean;
-  xssProtection?: boolean;
-  noSniff?: boolean;
-  referrerPolicy?: string;
-}
-
-export function securityHeaders(config?: SecurityHeadersConfig) {
-  const csp = config?.contentSecurityPolicy ?? "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; connect-src 'self'";
-  return (_req: Request, res: Response, next: NextFunction): void => {
-    res.setHeader('Content-Security-Policy', csp);
-    res.setHeader('X-Content-Type-Options', 'nosniff');
-    res.setHeader('X-Frame-Options', config?.frameDeny !== false ? 'DENY' : 'SAMEORIGIN');
-    res.setHeader('X-XSS-Protection', '1; mode=block');
-    res.setHeader('Referrer-Policy', config?.referrerPolicy ?? 'strict-origin-when-cross-origin');
-    if (config?.enableHSTS !== false) {
-      res.setHeader('Strict-Transport-Security', 'max-age=31536000; includeSubDomains');
-    }
-    res.removeHeader('X-Powered-By');
-    next();
-  };
-}
-
-// ── CORS Configuration ──────────────────────────────────────
-
-export interface CORSConfig {
-  origins?: string[];
-  methods?: string[];
-  allowHeaders?: string[];
-  credentials?: boolean;
-  maxAge?: number;
-}
-
-export function corsMiddleware(config?: CORSConfig) {
-  const origins = config?.origins ?? ['*'];
-  const methods = config?.methods ?? ['GET', 'POST', 'OPTIONS'];
-  const headers = config?.allowHeaders ?? ['Content-Type', 'Authorization'];
-
-  return (req: Request, res: Response, next: NextFunction): void => {
-    const origin = req.headers.origin ?? '';
-    if (origins.includes('*') || origins.includes(origin)) {
-      res.setHeader('Access-Control-Allow-Origin', origins.includes('*') ? '*' : origin);
-    }
-    res.setHeader('Access-Control-Allow-Methods', methods.join(', '));
-    res.setHeader('Access-Control-Allow-Headers', headers.join(', '));
-    if (config?.credentials) res.setHeader('Access-Control-Allow-Credentials', 'true');
-    if (config?.maxAge) res.setHeader('Access-Control-Max-Age', String(config.maxAge));
-    if (req.method === 'OPTIONS') { res.status(204).end(); return; }
-    next();
-  };
-}
-
-// ── API Key Rotation ────────────────────────────────────────
-
-export interface APIKeyEntry {
-  key: string;
-  label?: string;
-  createdAt: number;
-  expiresAt?: number;
-  active: boolean;
-}
-
-export class APIKeyManager {
-  private keys: APIKeyEntry[] = [];
-
-  addKey(key: string, opts?: { label?: string; expiresAt?: number }): void {
-    this.keys.push({ key, label: opts?.label, createdAt: Date.now(), expiresAt: opts?.expiresAt, active: true });
-  }
-
-  revokeKey(key: string): boolean {
-    const entry = this.keys.find(k => k.key === key);
-    if (entry) { entry.active = false; return true; }
-    return false;
-  }
-
-  isValid(key: string): boolean {
-    const entry = this.keys.find(k => k.key === key);
-    if (!entry || !entry.active) return false;
-    if (entry.expiresAt && Date.now() > entry.expiresAt) { entry.active = false; return false; }
-    return true;
-  }
-
-  rotateKey(oldKey: string, newKey: string): boolean {
-    const entry = this.keys.find(k => k.key === oldKey && k.active);
-    if (!entry) return false;
-    entry.active = false;
-    this.addKey(newKey, { label: entry.label });
-    return true;
-  }
-
-  listActive(): APIKeyEntry[] {
-    return this.keys.filter(k => k.active && (!k.expiresAt || Date.now() <= k.expiresAt));
-  }
-
-  cleanup(): number {
-    const before = this.keys.length;
-    this.keys = this.keys.filter(k => k.active && (!k.expiresAt || Date.now() <= k.expiresAt));
-    return before - this.keys.length;
-  }
-}
-
-// ── Input Validation Middleware ──────────────────────────────
-
-export function inputValidation() {
-  return (req: Request, res: Response, next: NextFunction): void => {
-    if (req.body?.message && typeof req.body.message === 'string') {
-      const check = detectInjection(req.body.message);
-      if (!check.safe) {
-        res.status(400).json({ error: 'Input contains potentially unsafe content', threats: check.threats });
-        return;
-      }
-      // Limit message size
-      if (req.body.message.length > 100_000) {
-        res.status(413).json({ error: 'Message too large (max 100KB)' });
-        return;
-      }
-    }
-    next();
-  };
-}