@cogitator-ai/self-modifying 17.0.17 → 17.0.18

package/src/tool-generation/tool-sandbox.ts

@@ -1,3 +1,4 @@
+import { Worker } from 'node:worker_threads';
 import type { ToolSandboxConfig, ToolSandboxResult, GeneratedTool } from '@cogitator-ai/types';
 
 export const DEFAULT_SANDBOX_CONFIG: ToolSandboxConfig = {
@@ -8,32 +9,44 @@ export const DEFAULT_SANDBOX_CONFIG: ToolSandboxConfig = {
   isolationLevel: 'strict',
 };
 
-interface SandboxContext {
-  console: {
-    log: (...args: unknown[]) => void;
-    warn: (...args: unknown[]) => void;
-    error: (...args: unknown[]) => void;
-  };
-  Math: typeof Math;
-  JSON: typeof JSON;
-  Date: typeof Date;
-  Array: typeof Array;
-  Object: typeof Object;
-  String: typeof String;
-  Number: typeof Number;
-  Boolean: typeof Boolean;
-  RegExp: typeof RegExp;
-  Map: typeof Map;
-  Set: typeof Set;
-  Promise: typeof Promise;
-  Error: typeof Error;
-  TypeError: typeof TypeError;
-  RangeError: typeof RangeError;
-}
+const WORKER_SOURCE = [
+  'const { parentPort, workerData } = require("worker_threads");',
+  'const vm = require("vm");',
+  'const { code, params } = workerData;',
+  'const logs = [];',
+  'const sandbox = Object.create(null);',
+  'Object.assign(sandbox, {',
+  '  console: {',
+  '    log: (...a) => { logs.push("[LOG] " + a.map(String).join(" ")); },',
+  '    warn: (...a) => { logs.push("[WARN] " + a.map(String).join(" ")); },',
+  '    error: (...a) => { logs.push("[ERROR] " + a.map(String).join(" ")); },',
+  '  },',
+  '  Math, JSON, Date, Array, Object, String, Number, Boolean, RegExp, Map, Set,',
+  '  Promise, Error, TypeError, RangeError,',
+  '  parseInt, parseFloat, isNaN, isFinite,',
+  '  encodeURIComponent, decodeURIComponent, encodeURI, decodeURI,',
+  '  undefined, NaN, Infinity,',
+  '  params,',
+  '});',
+  'const context = vm.createContext(sandbox);',
+  'try {',
+  '  const wrapped = "(async function sandboxedExecution() {\\n" +',
+  '    code + "\\n" +',
+  '    "if (typeof execute === \\"function\\") { return await execute(params); }\\n" +',
+  '    "throw new Error(\\"Implementation must define an execute function\\");\\n" +',
+  '    "})()";',
+  '  const promise = vm.runInContext(wrapped, context);',
+  '  Promise.resolve(promise).then(',
+  '    (result) => { parentPort.postMessage({ success: true, result, logs }); },',
+  '    (err) => { parentPort.postMessage({ success: false, error: err instanceof Error ? err.message : String(err), logs }); }',
+  '  );',
+  '} catch (err) {',
+  '  parentPort.postMessage({ success: false, error: err instanceof Error ? err.message : String(err), logs });',
+  '}',
+].join('\n');
 
 export class ToolSandbox {
   private readonly config: ToolSandboxConfig;
-  private readonly logs: string[] = [];
 
   constructor(config: Partial<ToolSandboxConfig> = {}) {
     this.config = { ...DEFAULT_SANDBOX_CONFIG, ...config };
@@ -41,41 +54,24 @@ export class ToolSandbox {
 
   async execute(tool: GeneratedTool, params: unknown): Promise<ToolSandboxResult> {
     const startTime = Date.now();
-    this.logs.length = 0;
-
-    if (!this.config.enabled) {
-      return this.executeUnsandboxed(tool, params, startTime);
-    }
 
     try {
       this.validateImplementation(tool.implementation);
-
-      const context = this.createContext();
-      const wrappedCode = this.wrapImplementation(tool.implementation);
-
-      const result = await this.executeWithTimeout(
-        wrappedCode,
-        context,
-        params,
-        this.config.maxExecutionTime
-      );
-
-      return {
-        success: true,
-        result,
-        executionTime: Date.now() - startTime,
-        memoryUsed: this.estimateMemoryUsage(result),
-        logs: [...this.logs],
-      };
     } catch (error) {
       return {
         success: false,
         error: error instanceof Error ? error.message : String(error),
         executionTime: Date.now() - startTime,
         memoryUsed: 0,
-        logs: [...this.logs],
+        logs: [],
       };
     }
+
+    if (!this.config.enabled) {
+      return this.executeUnsandboxed(tool, params, startTime);
+    }
+
+    return this.executeInWorker(tool.implementation, params, startTime);
   }
 
   async testWithCases(
@@ -107,7 +103,7 @@ export class ToolSandbox {
       if (testCase.shouldThrow) {
         passed = !execResult.success;
       } else if (testCase.expectedOutput !== undefined) {
-        passed = execResult.success && this.deepEqual(execResult.result, testCase.expectedOutput);
+        passed = execResult.success && deepEqual(execResult.result, testCase.expectedOutput);
       } else {
         passed = execResult.success;
       }
@@ -129,44 +125,68 @@ export class ToolSandbox {
   }
 
   private validateImplementation(code: string): void {
-    const forbidden = [
-      /\beval\s*\(/,
-      /\bFunction\s*\(/,
-      /\bnew\s+Function\s*\(/,
-      /\bimport\s*\(/,
-      /\brequire\s*\(/,
-      /\bprocess\./,
-      /\bglobal\./,
-      /\bglobalThis\./,
-      /\bwindow\./,
-      /\bdocument\./,
-      /\bchild_process/,
-      /\bfs\./,
-      /\bhttp\./,
-      /\bhttps\./,
-      /\bnet\./,
-      /\bdns\./,
-      /\bos\./,
-      /\bexec\s*\(/,
-      /\bspawn\s*\(/,
-      /__proto__/,
-      /\bconstructor\b/,
-      /\bgetPrototypeOf\b/,
+    const forbidden: Array<{ pattern: RegExp; label: string }> = [
+      { pattern: /\beval\s*\(/, label: 'eval()' },
+      { pattern: /\bnew\s+Function\s*\(/, label: 'new Function()' },
+      { pattern: /\bFunction\s*\.\s*prototype/, label: 'Function.prototype' },
+      { pattern: /\bimport\s*\(/, label: 'dynamic import()' },
+      { pattern: /\brequire\s*\(/, label: 'require()' },
+      { pattern: /\bprocess\s*[[.]/, label: 'process access' },
+      { pattern: /\bglobal\s*[[.]/, label: 'global access' },
+      { pattern: /\bglobalThis\s*[[.]/, label: 'globalThis access' },
+      { pattern: /\bwindow\s*[[.]/, label: 'window access' },
+      { pattern: /\bdocument\s*[[.]/, label: 'document access' },
+      { pattern: /\bchild_process\b/, label: 'child_process' },
+      { pattern: /\brequire\s*\(\s*['"]fs['"]/, label: 'fs module' },
+      { pattern: /\brequire\s*\(\s*['"]net['"]/, label: 'net module' },
+      { pattern: /\brequire\s*\(\s*['"]dns['"]/, label: 'dns module' },
+      { pattern: /\brequire\s*\(\s*['"]http['"]/, label: 'http module' },
+      { pattern: /\brequire\s*\(\s*['"]https['"]/, label: 'https module' },
+      { pattern: /\brequire\s*\(\s*['"]os['"]/, label: 'os module' },
+      { pattern: /\bspawn\s*\(/, label: 'spawn()' },
+      { pattern: /\bexecSync\s*\(/, label: 'execSync()' },
+      { pattern: /\bexecFile\s*\(/, label: 'execFile()' },
+      { pattern: /__proto__/, label: '__proto__' },
+      { pattern: /\.\s*constructor\s*[[.(]/, label: 'constructor access' },
+      { pattern: /\bgetPrototypeOf\s*\(/, label: 'getPrototypeOf()' },
+      { pattern: /\bsetPrototypeOf\s*\(/, label: 'setPrototypeOf()' },
+      { pattern: /\bReflect\s*[[.]/, label: 'Reflect access' },
+      { pattern: /\bProxy\s*[[.(]/, label: 'Proxy access' },
+      { pattern: /\bSymbol\s*\.\s*for\s*\(/, label: 'Symbol.for()' },
+      { pattern: /\bSharedArrayBuffer\b/, label: 'SharedArrayBuffer' },
+      { pattern: /\bAtomics\b/, label: 'Atomics' },
+      { pattern: /\bWeakRef\b/, label: 'WeakRef' },
+      { pattern: /\bFinalizationRegistry\b/, label: 'FinalizationRegistry' },
     ];
 
     if (this.config.isolationLevel === 'strict') {
       forbidden.push(
-        /\bfetch\s*\(/,
-        /\bXMLHttpRequest/,
-        /\bWebSocket/,
-        /\bsetTimeout\s*\(/,
-        /\bsetInterval\s*\(/
+        { pattern: /\bfetch\s*\(/, label: 'fetch()' },
+        { pattern: /\bXMLHttpRequest\b/, label: 'XMLHttpRequest' },
+        { pattern: /\bWebSocket\b/, label: 'WebSocket' },
+        { pattern: /\bsetTimeout\s*\(/, label: 'setTimeout()' },
+        { pattern: /\bsetInterval\s*\(/, label: 'setInterval()' }
       );
     }
 
-    for (const pattern of forbidden) {
+    for (const { pattern, label } of forbidden) {
       if (pattern.test(code)) {
-        throw new Error(`Security violation: forbidden pattern detected - ${pattern.source}`);
+        throw new Error(`Security violation: forbidden pattern detected - ${label}`);
+      }
+    }
+
+    const bracketGlobalAccess = /\b(?:global|globalThis|process|window|document)\s*\[\s*['"`]/;
+    if (bracketGlobalAccess.test(code)) {
+      throw new Error('Security violation: bracket notation access to global objects');
+    }
+
+    const stringConcatEscape = /['"`]\s*\+\s*['"`]/;
+    if (stringConcatEscape.test(code)) {
+      const concatenated = code.replace(/['"`]\s*\+\s*['"`]/g, '');
+      for (const { pattern, label } of forbidden) {
+        if (pattern.test(concatenated)) {
+          throw new Error(`Security violation: obfuscated forbidden pattern detected - ${label}`);
+        }
       }
     }
 
@@ -176,82 +196,103 @@ export class ToolSandbox {
     }
   }
 
-  private createContext(): SandboxContext {
-    return {
-      console: {
-        log: (...args: unknown[]) => {
-          this.logs.push(`[LOG] ${args.map(String).join(' ')}`);
-        },
-        warn: (...args: unknown[]) => {
-          this.logs.push(`[WARN] ${args.map(String).join(' ')}`);
-        },
-        error: (...args: unknown[]) => {
-          this.logs.push(`[ERROR] ${args.map(String).join(' ')}`);
-        },
-      },
-      Math,
-      JSON,
-      Date,
-      Array,
-      Object,
-      String,
-      Number,
-      Boolean,
-      RegExp,
-      Map,
-      Set,
-      Promise,
-      Error,
-      TypeError,
-      RangeError,
-    };
-  }
-
-  private wrapImplementation(code: string): string {
-    return `
-      "use strict";
-      return (async function sandboxedExecution(params, context) {
-        const { console, Math, JSON, Date, Array, Object, String, Number, Boolean, RegExp, Map, Set, Promise, Error, TypeError, RangeError } = context;
+  private async executeInWorker(
+    code: string,
+    params: unknown,
+    startTime: number
+  ): Promise<ToolSandboxResult> {
+    let serializableParams: unknown;
+    try {
+      serializableParams = JSON.parse(JSON.stringify(params ?? null));
+    } catch {
+      serializableParams = null;
+    }
 
-        ${code}
+    return new Promise<ToolSandboxResult>((resolve) => {
+      let settled = false;
 
-        if (typeof execute === 'function') {
-          return await execute(params);
+      const settle = (result: ToolSandboxResult) => {
+        if (!settled) {
+          settled = true;
+          resolve(result);
         }
-        throw new Error('Implementation must define an execute function');
-      });
-    `;
-  }
+      };
 
-  private async executeWithTimeout(
-    wrappedCode: string,
-    context: SandboxContext,
-    params: unknown,
-    timeout: number
-  ): Promise<unknown> {
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        reject(new Error(`Execution timeout: exceeded ${timeout}ms`));
-      }, timeout);
+      const maxMemoryMb = Math.max(4, Math.ceil(this.config.maxMemory / (1024 * 1024)));
 
+      let worker: Worker;
       try {
-        // eslint-disable-next-line @typescript-eslint/no-implied-eval
-        const factory = new Function(wrappedCode);
-        const executor = factory();
-
-        Promise.resolve(executor(params, context))
-          .then((result) => {
-            clearTimeout(timer);
-            resolve(result);
-          })
-          .catch((error: unknown) => {
-            clearTimeout(timer);
-            reject(error instanceof Error ? error : new Error(String(error)));
-          });
+        worker = new Worker(WORKER_SOURCE, {
+          eval: true,
+          workerData: { code, params: serializableParams },
+          resourceLimits: {
+            maxOldGenerationSizeMb: maxMemoryMb,
+            maxYoungGenerationSizeMb: Math.max(2, Math.ceil(maxMemoryMb / 4)),
+          },
+        });
       } catch (error) {
-        clearTimeout(timer);
-        reject(error instanceof Error ? error : new Error(String(error)));
+        settle({
+          success: false,
+          error: `Failed to create sandbox worker: ${error instanceof Error ? error.message : String(error)}`,
+          executionTime: Date.now() - startTime,
+          memoryUsed: 0,
+          logs: [],
+        });
+        return;
       }
+
+      const timer = setTimeout(() => {
+        void worker.terminate();
+        settle({
+          success: false,
+          error: `Execution timeout: exceeded ${this.config.maxExecutionTime}ms`,
+          executionTime: Date.now() - startTime,
+          memoryUsed: 0,
+          logs: [],
+        });
+      }, this.config.maxExecutionTime);
+
+      worker.on(
+        'message',
+        (msg: { success: boolean; result?: unknown; error?: string; logs?: string[] }) => {
+          clearTimeout(timer);
+          settle({
+            success: msg.success,
+            result: msg.result,
+            error: msg.error,
+            executionTime: Date.now() - startTime,
+            memoryUsed: estimateMemoryUsage(msg.result),
+            logs: msg.logs ?? [],
+          });
+        }
+      );
+
+      worker.on('error', (error: Error) => {
+        clearTimeout(timer);
+        settle({
+          success: false,
+          error: `Sandbox worker error: ${error.message}`,
+          executionTime: Date.now() - startTime,
+          memoryUsed: 0,
+          logs: [],
+        });
+      });
+
+      worker.on('exit', (exitCode: number) => {
+        clearTimeout(timer);
+        if (exitCode !== 0) {
+          settle({
+            success: false,
+            error:
+              exitCode === 134 || exitCode === 137
+                ? `Execution exceeded memory limit (${this.config.maxMemory} bytes)`
+                : `Sandbox worker exited with code ${exitCode}`,
+            executionTime: Date.now() - startTime,
+            memoryUsed: 0,
+            logs: [],
+          });
+        }
+      });
     });
   }
 
@@ -284,7 +325,7 @@ export class ToolSandbox {
         success: true,
         result,
         executionTime: Date.now() - startTime,
-        memoryUsed: this.estimateMemoryUsage(result),
+        memoryUsed: estimateMemoryUsage(result),
         logs: [],
       };
     } catch (error) {
@@ -297,36 +338,66 @@ export class ToolSandbox {
       };
     }
   }
+}
 
-  private estimateMemoryUsage(value: unknown): number {
-    try {
-      const str = JSON.stringify(value);
-      return str.length * 2;
-    } catch {
-      return 0;
-    }
+function estimateMemoryUsage(value: unknown): number {
+  try {
+    const str = JSON.stringify(value);
+    return str ? str.length * 2 : 0;
+  } catch {
+    return 0;
   }
+}
 
-  private deepEqual(a: unknown, b: unknown): boolean {
-    if (a === b) return true;
-    if (typeof a !== typeof b) return false;
-    if (a === null || b === null) return a === b;
+export function deepEqual(a: unknown, b: unknown, seen = new WeakSet<object>()): boolean {
+  if (Object.is(a, b)) return true;
 
-    if (Array.isArray(a) && Array.isArray(b)) {
-      if (a.length !== b.length) return false;
-      return a.every((val, i) => this.deepEqual(val, b[i]));
-    }
+  if (typeof a !== typeof b) return false;
+  if (a === null || b === null) return a === b;
+
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime();
+  }
+
+  if (a instanceof RegExp && b instanceof RegExp) {
+    return a.source === b.source && a.flags === b.flags;
+  }
 
-    if (typeof a === 'object' && typeof b === 'object') {
-      const aObj = a as Record<string, unknown>;
-      const bObj = b as Record<string, unknown>;
-      const keysA = Object.keys(aObj);
-      const keysB = Object.keys(bObj);
+  if (a instanceof Map && b instanceof Map) {
+    if (a.size !== b.size) return false;
+    for (const [key, val] of a) {
+      if (!b.has(key) || !deepEqual(val, b.get(key), seen)) return false;
+    }
+    return true;
+  }
 
-      if (keysA.length !== keysB.length) return false;
-      return keysA.every((key) => this.deepEqual(aObj[key], bObj[key]));
+  if (a instanceof Set && b instanceof Set) {
+    if (a.size !== b.size) return false;
+    for (const val of a) {
+      if (!b.has(val)) return false;
     }
+    return true;
+  }
 
-    return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    return a.every((val, i) => deepEqual(val, b[i], seen));
   }
+
+  if (typeof a === 'object' && typeof b === 'object') {
+    const aObj = a as Record<string, unknown>;
+    const bObj = b as Record<string, unknown>;
+
+    if (seen.has(aObj) || seen.has(bObj)) return false;
+    seen.add(aObj);
+    seen.add(bObj);
+
+    const keysA = Object.keys(aObj).filter((k) => aObj[k] !== undefined);
+    const keysB = Object.keys(bObj).filter((k) => bObj[k] !== undefined);
+
+    if (keysA.length !== keysB.length) return false;
+    return keysA.every((key) => deepEqual(aObj[key], bObj[key], seen));
+  }
+
+  return false;
 }

package/src/tool-generation/tool-validator.ts

@@ -299,13 +299,44 @@ Be thorough but practical - focus on real issues.`,
     const params = tool.parameters;
 
     if (params.type === 'object' && params.properties) {
-      const validInput: Record<string, unknown> = {};
       const properties = params.properties as Record<string, { type?: string; default?: unknown }>;
+      const required = Array.isArray(params.required)
+        ? new Set(params.required as string[])
+        : new Set<string>();
 
+      const validInput: Record<string, unknown> = {};
       for (const [key, schema] of Object.entries(properties)) {
         validInput[key] = this.generateSampleValue(schema.type, schema.default);
       }
       testCases.push({ input: validInput });
+
+      const emptyInput: Record<string, unknown> = {};
+      for (const [key, schema] of Object.entries(properties)) {
+        if (!required.has(key)) {
+          emptyInput[key] = this.generateSampleValue(schema.type, schema.default);
+        }
+      }
+      if (Object.keys(emptyInput).length > 0) {
+        testCases.push({ input: emptyInput });
+      }
+
+      const edgeInput: Record<string, unknown> = {};
+      for (const [key, schema] of Object.entries(properties)) {
+        edgeInput[key] = this.generateEdgeValue(schema.type);
+      }
+      testCases.push({ input: edgeInput });
+
+      if (required.size > 0) {
+        const missingRequired: Record<string, unknown> = {};
+        for (const [key, schema] of Object.entries(properties)) {
+          if (!required.has(key)) {
+            missingRequired[key] = this.generateSampleValue(schema.type, schema.default);
+          }
+        }
+        testCases.push({ input: missingRequired, shouldThrow: true });
+      }
+    } else {
+      testCases.push({ input: {} });
     }
 
     return testCases;
@@ -331,6 +362,25 @@ Be thorough but practical - focus on real issues.`,
     }
   }
 
+  private generateEdgeValue(type?: string): unknown {
+    switch (type) {
+      case 'string':
+        return '';
+      case 'number':
+        return 0;
+      case 'integer':
+        return -1;
+      case 'boolean':
+        return false;
+      case 'array':
+        return [null, 0, ''];
+      case 'object':
+        return { unexpected: true };
+      default:
+        return undefined;
+    }
+  }
+
   private calculateScore(
     securityCount: number,
     logicCount: number,

package/src/utils/index.ts

@@ -9,8 +9,32 @@ export function extractJson(text: string): string | null {
     cleaned = codeBlockMatch[1].trim();
   }
 
-  const start = cleaned.indexOf('{');
-  if (start === -1) return null;
+  const objectStart = cleaned.indexOf('{');
+  const arrayStart = cleaned.indexOf('[');
+
+  let start: number;
+  let open: string;
+  let close: string;
+
+  if (objectStart === -1 && arrayStart === -1) {
+    return null;
+  } else if (objectStart === -1) {
+    start = arrayStart;
+    open = '[';
+    close = ']';
+  } else if (arrayStart === -1) {
+    start = objectStart;
+    open = '{';
+    close = '}';
+  } else if (objectStart < arrayStart) {
+    start = objectStart;
+    open = '{';
+    close = '}';
+  } else {
+    start = arrayStart;
+    open = '[';
+    close = ']';
+  }
 
   let depth = 0;
   let inString = false;
@@ -36,8 +60,8 @@ export function extractJson(text: string): string | null {
 
     if (inString) continue;
 
-    if (ch === '{') depth++;
-    else if (ch === '}') {
+    if (ch === open) depth++;
+    else if (ch === close) {
       depth--;
       if (depth === 0) {
         return cleaned.slice(start, i + 1);
@@ -48,7 +72,7 @@ export function extractJson(text: string): string | null {
   if (depth > 0) {
     let repaired = cleaned.slice(start);
     repaired = repaired.replace(/,\s*$/, '');
-    repaired += '}'.repeat(depth);
+    repaired += close.repeat(depth);
     try {
       JSON.parse(repaired);
       return repaired;