@bluecopa/harness 1.0.0 → 2.0.0

package/src/optimization/optimization-runner.ts

@@ -1,39 +0,0 @@
-import { AgentEvaluator, type EvaluationTask } from './agent-evaluator';
-import type { AgentRunResult } from '../agent/types';
-
-export interface Candidate {
-  id: string;
-  run: (prompt: string) => Promise<AgentRunResult>;
-}
-
-export interface OptimizationResult {
-  bestCandidateId: string;
-  bestScore: number;
-  scores: Array<{ candidateId: string; averageScore: number }>;
-}
-
-export class OptimizationRunner {
-  async run(candidates: Candidate[], tasks: EvaluationTask[]): Promise<OptimizationResult> {
-    if (candidates.length === 0) {
-      throw new Error('at least one candidate is required');
-    }
-
-    const scores: Array<{ candidateId: string; averageScore: number }> = [];
-
-    for (const candidate of candidates) {
-      const evaluator = new AgentEvaluator(candidate.run);
-      const results = await Promise.all(tasks.map((task) => evaluator.evaluate(task)));
-      const averageScore = results.reduce((sum, item) => sum + item.score, 0) / tasks.length;
-      scores.push({ candidateId: candidate.id, averageScore });
-    }
-
-    const sorted = [...scores].sort((a, b) => b.averageScore - a.averageScore);
-    const best = sorted[0]!;
-
-    return {
-      bestCandidateId: best.candidateId,
-      bestScore: best.averageScore,
-      scores
-    };
-  }
-}

package/src/optimization/trace-collector.ts

@@ -1,33 +0,0 @@
-export interface TraceEvent {
-  type: string;
-  payload: Record<string, unknown>;
-  timestamp: number;
-}
-
-export interface ExecutionTrace {
-  runId: string;
-  events: TraceEvent[];
-}
-
-export class TraceCollector {
-  private readonly trace: ExecutionTrace;
-
-  constructor(runId: string) {
-    this.trace = { runId, events: [] };
-  }
-
-  add(type: string, payload: Record<string, unknown> = {}): void {
-    this.trace.events.push({
-      type,
-      payload,
-      timestamp: Date.now()
-    });
-  }
-
-  toExecutionTrace(): ExecutionTrace {
-    return {
-      runId: this.trace.runId,
-      events: [...this.trace.events]
-    };
-  }
-}

package/src/permissions/permission-manager.ts

@@ -1,34 +0,0 @@
-export type PermissionMode = 'allow_all' | 'deny_all' | 'ask';
-
-export interface PermissionRequest {
-  toolName: string;
-  input?: Record<string, unknown>;
-}
-
-export type PermissionResolver = (request: PermissionRequest) => Promise<boolean>;
-
-export class PermissionManager {
-  constructor(
-    private readonly mode: PermissionMode,
-    private readonly resolver?: PermissionResolver
-  ) {}
-
-  async check(request: PermissionRequest): Promise<{ allow: boolean; reason?: string }> {
-    if (this.mode === 'allow_all') {
-      return { allow: true };
-    }
-
-    if (this.mode === 'deny_all') {
-      return { allow: false, reason: `Tool ${request.toolName} denied by policy` };
-    }
-
-    if (!this.resolver) {
-      return { allow: false, reason: 'Permission resolver is missing for ask mode' };
-    }
-
-    const allow = await this.resolver(request);
-    return allow
-      ? { allow: true }
-      : { allow: false, reason: `Tool ${request.toolName} denied by resolver` };
-  }
-}

package/src/providers/composite-tool-provider.ts

@@ -1,72 +0,0 @@
-import type {
-  BashOptions,
-  GlobOptions,
-  GrepOptions,
-  ReadOptions,
-  ToolProvider,
-  ToolProviderCapabilities,
-  ToolResult
-} from '../interfaces/tool-provider';
-
-export class CompositeToolProvider implements ToolProvider {
-  constructor(private readonly providers: ToolProvider[]) {}
-
-  private pick(capability: keyof ToolProviderCapabilities): ToolProvider {
-    const provider = this.providers.find((candidate) => candidate.capabilities()[capability]);
-    if (!provider) {
-      throw new Error(`no provider with capability: ${capability}`);
-    }
-    return provider;
-  }
-
-  capabilities(): ToolProviderCapabilities {
-    return {
-      bash: this.providers.some((p) => p.capabilities().bash),
-      fileSystem: this.providers.some((p) => p.capabilities().fileSystem),
-      webFetch: this.providers.some((p) => p.capabilities().webFetch),
-      webSearch: this.providers.some((p) => p.capabilities().webSearch),
-      codeExecution: this.providers.some((p) => p.capabilities().codeExecution),
-      sandboxed: this.providers.every((p) => p.capabilities().sandboxed)
-    };
-  }
-
-  bash(command: string, options?: BashOptions): Promise<ToolResult> {
-    return this.pick('bash').bash(command, options);
-  }
-
-  readFile(path: string, options?: ReadOptions): Promise<ToolResult> {
-    return this.pick('fileSystem').readFile(path, options);
-  }
-
-  writeFile(path: string, content: string): Promise<ToolResult> {
-    return this.pick('fileSystem').writeFile(path, content);
-  }
-
-  editFile(path: string, oldText: string, newText: string): Promise<ToolResult> {
-    return this.pick('fileSystem').editFile(path, oldText, newText);
-  }
-
-  glob(pattern: string, options?: GlobOptions): Promise<ToolResult> {
-    return this.pick('fileSystem').glob(pattern, options);
-  }
-
-  grep(pattern: string, path?: string, options?: GrepOptions): Promise<ToolResult> {
-    return this.pick('fileSystem').grep(pattern, path, options);
-  }
-
-  webFetch(options: { url: string; selector?: string | undefined; maxContentLength?: number | undefined; headers?: Record<string, string> | undefined }): Promise<ToolResult> {
-    const provider = this.providers.find((p) => p.capabilities().webFetch && p.webFetch);
-    if (!provider?.webFetch) {
-      return Promise.resolve({ success: false, output: '', error: 'webFetch unavailable' });
-    }
-    return provider.webFetch(options);
-  }
-
-  webSearch(query: string): Promise<ToolResult> {
-    const provider = this.providers.find((p) => p.capabilities().webSearch && p.webSearch);
-    if (!provider?.webSearch) {
-      return Promise.resolve({ success: false, output: '', error: 'webSearch unavailable' });
-    }
-    return provider.webSearch(query);
-  }
-}

package/src/providers/control-plane-e2b-executor.ts

@@ -1,218 +0,0 @@
-import type {
-  BatchOp,
-  BatchResult,
-  BashOptions,
-  GlobOptions,
-  GrepOptions,
-  ReadOptions,
-  ToolResult
-} from '../interfaces/tool-provider';
-import type { E2BExecutor } from './e2b-tool-provider';
-
-type CreateSandboxResponse = {
-  sandboxId: string;
-};
-
-type CommandResponse = {
-  exitCode: number | null;
-  stdout: string;
-  stderr: string;
-  status: string;
-};
-
-type ReadFileResponse = {
-  content: string;
-};
-
-export type ControlPlaneExecutorConfig = {
-  baseUrl: string;
-  apiKey: string;
-  templateId?: string;
-  cpu?: number;
-  memoryMb?: number;
-  ttlSeconds?: number;
-};
-
-export class ControlPlaneE2BExecutor implements E2BExecutor {
-  private sandboxId: string | null = null;
-
-  constructor(private readonly config: ControlPlaneExecutorConfig) {}
-
-  static fromEnv(): ControlPlaneE2BExecutor {
-    const baseUrl = process.env.SAMYX_BASE_URL ?? process.env.SANDBOX_BASE_URL;
-    const apiKey = process.env.SAMYX_API_KEY ?? process.env.SANDBOX_API_KEY;
-    if (!baseUrl || !apiKey) {
-      throw new Error('Missing SAMYX_BASE_URL/SAMYX_API_KEY (or SANDBOX_BASE_URL/SANDBOX_API_KEY) for default provider');
-    }
-    return new ControlPlaneE2BExecutor({
-      baseUrl,
-      apiKey,
-      templateId: process.env.SANDBOX_TEMPLATE ?? 'polyglot-v1'
-    });
-  }
-
-  get activeSandboxId(): string | null {
-    return this.sandboxId;
-  }
-
-  async initialize(): Promise<void> {
-    if (this.sandboxId) return;
-    const body = {
-      templateID: this.config.templateId ?? 'polyglot-v1',
-      cpu: this.config.cpu ?? 1,
-      memoryMb: this.config.memoryMb ?? 1024,
-      timeout: this.config.ttlSeconds ?? 3600
-    };
-    const sandbox = await this.request<CreateSandboxResponse>('/sandboxes', {
-      method: 'POST',
-      body: JSON.stringify(body)
-    });
-    this.sandboxId = sandbox.sandboxId;
-  }
-
-  async destroy(): Promise<void> {
-    if (!this.sandboxId) return;
-    await this.requestRaw(`/sandboxes/${this.sandboxId}`, { method: 'DELETE' }, true);
-    this.sandboxId = null;
-  }
-
-  async bash(command: string, options?: BashOptions): Promise<ToolResult> {
-    await this.initialize();
-    const sandboxId = this.requireSandboxId();
-    const response = await this.request<CommandResponse>(`/sandboxes/${sandboxId}/commands`, {
-      method: 'POST',
-      body: JSON.stringify({
-        command,
-        cwd: options?.cwd,
-        timeoutMs: options?.timeout ?? 60_000
-      })
-    });
-
-    const success = response.exitCode === 0;
-    return {
-      success,
-      output: response.stdout ?? '',
-      error: success ? undefined : response.stderr || `command failed: ${response.status}`,
-      metadata: { sandboxId, status: response.status, exitCode: response.exitCode }
-    };
-  }
-
-  async readFile(filePath: string, _options?: ReadOptions): Promise<ToolResult> {
-    await this.initialize();
-    const sandboxId = this.requireSandboxId();
-    try {
-      const resp = await this.request<ReadFileResponse>(
-        `/sandboxes/${sandboxId}/files/content?path=${encodeURIComponent(filePath)}`
-      );
-      return { success: true, output: resp.content, metadata: { sandboxId, path: filePath } };
-    } catch (err: any) {
-      return { success: false, output: '', error: err.message, metadata: { sandboxId, path: filePath } };
-    }
-  }
-
-  async readFileBytes(filePath: string): Promise<Uint8Array> {
-    await this.initialize();
-    const sandboxId = this.requireSandboxId();
-    const resp = await this.requestRaw(
-      `/sandboxes/${sandboxId}/files/raw?path=${encodeURIComponent(filePath)}`
-    );
-    return new Uint8Array(await resp.arrayBuffer());
-  }
-
-  async writeFileBytes(filePath: string, data: Uint8Array): Promise<ToolResult> {
-    await this.initialize();
-    const sandboxId = this.requireSandboxId();
-    const b64 = Buffer.from(data).toString('base64');
-    try {
-      await this.request(`/sandboxes/${sandboxId}/files/content`, {
-        method: 'PUT',
-        body: JSON.stringify({ path: filePath, content: b64, encoding: 'base64' })
-      });
-      return { success: true, output: 'ok', metadata: { sandboxId, path: filePath } };
-    } catch (err: any) {
-      return { success: false, output: '', error: err.message, metadata: { sandboxId, path: filePath } };
-    }
-  }
-
-  async writeFile(filePath: string, content: string): Promise<ToolResult> {
-    await this.initialize();
-    const sandboxId = this.requireSandboxId();
-    const b64 = Buffer.from(content, 'utf8').toString('base64');
-    try {
-      await this.request(`/sandboxes/${sandboxId}/files/content`, {
-        method: 'PUT',
-        body: JSON.stringify({ path: filePath, content: b64, encoding: 'base64' })
-      });
-      return { success: true, output: 'ok', metadata: { sandboxId, path: filePath } };
-    } catch (err: any) {
-      return { success: false, output: '', error: err.message, metadata: { sandboxId, path: filePath } };
-    }
-  }
-
-  async editFile(filePath: string, oldText: string, newText: string): Promise<ToolResult> {
-    const current = await this.readFile(filePath);
-    if (!current.success) return current;
-    if (!current.output.includes(oldText)) {
-      return { success: false, output: '', error: 'old text not found', metadata: { path: filePath } };
-    }
-    return this.writeFile(filePath, current.output.replace(oldText, newText));
-  }
-
-  async glob(pattern: string, _options?: GlobOptions): Promise<ToolResult> {
-    // Parse glob: extract search directory and filename pattern
-    // e.g. "/home/user/**/*.py" -> dir="/home/user", namePattern="*.py"
-    const lastSlash = pattern.lastIndexOf('/');
-    let dir = '/';
-    let namePattern = pattern;
-    if (lastSlash >= 0) {
-      dir = pattern.slice(0, lastSlash) || '/';
-      namePattern = pattern.slice(lastSlash + 1);
-    }
-    // Strip leading glob segments from dir (e.g. /home/user/**/foo -> /home/user)
-    dir = dir.replace(/\/\*\*.*$/, '').replace(/\/\*$/, '') || '/';
-    const escapedDir = dir.replace(/'/g, "'\\''");
-    const escapedName = namePattern.replace(/'/g, "'\\''");
-    return this.bash(`find '${escapedDir}' -type f -name '${escapedName}' 2>/dev/null | head -n 200`);
-  }
-
-  async grep(pattern: string, grepPath?: string, _options?: GrepOptions): Promise<ToolResult> {
-    const escapedPattern = pattern.replace(/'/g, "'\\''");
-    const escapedPath = (grepPath ?? '/').replace(/'/g, "'\\''");
-    return this.bash(`grep -R -n -- '${escapedPattern}' '${escapedPath}' 2>/dev/null | head -n 200`);
-  }
-
-  async batch(ops: BatchOp[]): Promise<BatchResult[]> {
-    await this.initialize();
-    const sandboxId = this.requireSandboxId();
-    return this.request<BatchResult[]>(`/sandboxes/${sandboxId}/batch`, {
-      method: 'POST',
-      body: JSON.stringify({ ops })
-    });
-  }
-
-  private requireSandboxId(): string {
-    if (!this.sandboxId) throw new Error('sandbox is not initialized');
-    return this.sandboxId;
-  }
-
-  private async request<T = unknown>(path: string, init: RequestInit = {}): Promise<T> {
-    const response = await this.requestRaw(path, init);
-    return (await response.json()) as T;
-  }
-
-  private async requestRaw(path: string, init: RequestInit = {}, tolerate404 = false): Promise<Response> {
-    const headers: Record<string, string> = {
-      'x-api-key': this.config.apiKey,
-      ...(init.headers as Record<string, string> | undefined)
-    };
-    if (init.body !== undefined && !headers['content-type']) {
-      headers['content-type'] = 'application/json';
-    }
-    const response = await fetch(`${this.config.baseUrl}${path}`, { ...init, headers });
-    if (!response.ok && !(tolerate404 && response.status === 404)) {
-      const text = await response.text();
-      throw new Error(`${init.method ?? 'GET'} ${path} failed: ${response.status} ${text}`);
-    }
-    return response;
-  }
-}

package/src/providers/e2b-tool-provider.ts

@@ -1,68 +0,0 @@
-import type {
-  BatchOp,
-  BatchResult,
-  BashOptions,
-  GlobOptions,
-  GrepOptions,
-  ReadOptions,
-  ToolProvider,
-  ToolProviderCapabilities,
-  ToolResult
-} from '../interfaces/tool-provider';
-
-export interface E2BExecutor {
-  bash(command: string, options?: BashOptions): Promise<ToolResult>;
-  readFile(path: string, options?: ReadOptions): Promise<ToolResult>;
-  writeFile(path: string, content: string): Promise<ToolResult>;
-  editFile(path: string, oldText: string, newText: string): Promise<ToolResult>;
-  glob(pattern: string, options?: GlobOptions): Promise<ToolResult>;
-  grep(pattern: string, path?: string, options?: GrepOptions): Promise<ToolResult>;
-  batch?: (ops: BatchOp[]) => Promise<BatchResult[]>;
-  readFileBytes?(path: string): Promise<Uint8Array>;
-  writeFileBytes?(path: string, data: Uint8Array): Promise<ToolResult>;
-}
-
-export class E2BToolProvider implements ToolProvider {
-  constructor(private readonly executor: E2BExecutor) {}
-
-  capabilities(): ToolProviderCapabilities {
-    return {
-      bash: true,
-      fileSystem: true,
-      webFetch: false,
-      webSearch: false,
-      codeExecution: true,
-      sandboxed: true
-    };
-  }
-
-  bash(command: string, options?: BashOptions): Promise<ToolResult> {
-    return this.executor.bash(command, options);
-  }
-
-  readFile(path: string, options?: ReadOptions): Promise<ToolResult> {
-    return this.executor.readFile(path, options);
-  }
-
-  writeFile(path: string, content: string): Promise<ToolResult> {
-    return this.executor.writeFile(path, content);
-  }
-
-  editFile(path: string, oldText: string, newText: string): Promise<ToolResult> {
-    return this.executor.editFile(path, oldText, newText);
-  }
-
-  glob(pattern: string, options?: GlobOptions): Promise<ToolResult> {
-    return this.executor.glob(pattern, options);
-  }
-
-  grep(pattern: string, path?: string, options?: GrepOptions): Promise<ToolResult> {
-    return this.executor.grep(pattern, path, options);
-  }
-
-  get batch(): ((ops: BatchOp[]) => Promise<BatchResult[]>) | undefined {
-    return this.executor.batch
-      ? (ops: BatchOp[]) => this.executor.batch!(ops)
-      : undefined;
-  }
-}

package/src/providers/local-tool-provider.ts

@@ -1,190 +0,0 @@
-import { exec as execCallback } from 'node:child_process';
-import { readFile, writeFile, mkdir, readdir, stat } from 'node:fs/promises';
-import { dirname, join, relative, resolve } from 'node:path';
-import { promisify } from 'node:util';
-
-import type {
-  BashOptions,
-  GlobOptions,
-  GrepOptions,
-  ReadOptions,
-  ToolProvider,
-  ToolProviderCapabilities,
-  ToolResult
-} from '../interfaces/tool-provider';
-
-const exec = promisify(execCallback);
-
-function regexFromGlob(pattern: string): RegExp {
-  const escaped = pattern
-    .replace(/[.+^${}()|[\]\\]/g, '\\$&')
-    .replace(/\*\*/g, '::DOUBLESTAR::')
-    .replace(/\*/g, '[^/]*')
-    .replace(/::DOUBLESTAR::/g, '.*')
-    .replace(/\?/g, '.');
-  return new RegExp(`^${escaped}$`);
-}
-
-async function walkFiles(baseDir: string): Promise<string[]> {
-  const out: string[] = [];
-
-  async function walk(current: string): Promise<void> {
-    const entries = await readdir(current, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = join(current, entry.name);
-      if (entry.isDirectory()) {
-        await walk(fullPath);
-        continue;
-      }
-      out.push(fullPath);
-    }
-  }
-
-  await walk(baseDir);
-  return out;
-}
-
-export class LocalToolProvider implements ToolProvider {
-  constructor(private readonly baseDir: string = process.cwd()) {}
-
-  private resolvePath(path: string): string {
-    return resolve(this.baseDir, path);
-  }
-
-  capabilities(): ToolProviderCapabilities {
-    return {
-      bash: true,
-      fileSystem: true,
-      webFetch: false,
-      webSearch: false,
-      codeExecution: true,
-      sandboxed: false
-    };
-  }
-
-  async bash(command: string, options?: BashOptions): Promise<ToolResult> {
-    try {
-      const { stdout, stderr } = await exec(command, {
-        cwd: options?.cwd ?? this.baseDir,
-        timeout: options?.timeout ?? 30000,
-        maxBuffer: 10 * 1024 * 1024
-      });
-      return {
-        success: true,
-        output: [stdout, stderr].filter(Boolean).join('')
-      };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : 'bash command failed';
-      return { success: false, output: '', error: message };
-    }
-  }
-
-  async readFile(path: string, options?: ReadOptions): Promise<ToolResult> {
-    try {
-      const content = await readFile(this.resolvePath(path), 'utf8');
-      const lines = content.split('\n');
-
-      let selected = lines;
-      if (options?.lineRange) {
-        const [start, end] = options.lineRange;
-        selected = lines.slice(Math.max(0, start - 1), end);
-      }
-      if (options?.maxLines) {
-        selected = selected.slice(0, options.maxLines);
-      }
-
-      return { success: true, output: selected.join('\n') };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : 'read failed';
-      return { success: false, output: '', error: message };
-    }
-  }
-
-  async writeFile(path: string, content: string): Promise<ToolResult> {
-    try {
-      const resolved = this.resolvePath(path);
-      await mkdir(dirname(resolved), { recursive: true });
-      await writeFile(resolved, content, 'utf8');
-      return { success: true, output: 'ok' };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : 'write failed';
-      return { success: false, output: '', error: message };
-    }
-  }
-
-  async editFile(path: string, oldText: string, newText: string): Promise<ToolResult> {
-    const readResult = await this.readFile(path);
-    if (!readResult.success) {
-      return readResult;
-    }
-
-    if (!readResult.output.includes(oldText)) {
-      return { success: false, output: '', error: 'old_text not found' };
-    }
-
-    return this.writeFile(path, readResult.output.replace(oldText, newText));
-  }
-
-  async glob(pattern: string, options?: GlobOptions): Promise<ToolResult> {
-    try {
-      const matcher = regexFromGlob(pattern);
-      const ignore = new Set(options?.ignore ?? []);
-      const files = await walkFiles(this.baseDir);
-
-      const results = files
-        .map((file) => relative(this.baseDir, file))
-        .filter((file) => {
-          for (const skip of ignore) {
-            if (file.startsWith(skip)) {
-              return false;
-            }
-          }
-          return matcher.test(file);
-        })
-        .slice(0, options?.maxResults ?? 1000);
-
-      return { success: true, output: results.join('\n') };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : 'glob failed';
-      return { success: false, output: '', error: message };
-    }
-  }
-
-  async grep(pattern: string, path = '.', options?: GrepOptions): Promise<ToolResult> {
-    try {
-      const target = this.resolvePath(path);
-      const targetStat = await stat(target);
-      const files = targetStat.isDirectory() ? await walkFiles(target) : [target];
-
-      const flags = options?.caseInsensitive ? 'i' : '';
-      const sourcePattern = options?.wholeWord ? `\\b${pattern}\\b` : pattern;
-      const matcher = new RegExp(sourcePattern, flags);
-
-      const maxResults = options?.maxResults ?? 200;
-      const matches: string[] = [];
-
-      for (const file of files) {
-        const rel = relative(this.baseDir, file);
-        if (options?.include && !regexFromGlob(options.include).test(rel)) {
-          continue;
-        }
-
-        const content = await readFile(file, 'utf8');
-        const lines = content.split('\n');
-        lines.forEach((line, idx) => {
-          if (matches.length >= maxResults) {
-            return;
-          }
-          if (matcher.test(line)) {
-            matches.push(`${rel}:${idx + 1}:${line}`);
-          }
-        });
-      }
-
-      return { success: true, output: matches.join('\n') };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : 'grep failed';
-      return { success: false, output: '', error: message };
-    }
-  }
-}