@tyvm/knowhow 0.0.21 → 0.0.23

package/src/services/script-execution/ScriptPolicy.ts

@@ -0,0 +1,236 @@
+import { 
+  ResourceQuotas, 
+  SecurityPolicy,
+  QuotaUsage,
+  PolicyViolation 
+} from './types';
+
+/**
+ * Enforces security policies and resource quotas for script execution
+ */
+export class ScriptPolicyEnforcer {
+  private usage: QuotaUsage;
+  private violations: PolicyViolation[] = [];
+
+  constructor(
+    private quotas: ResourceQuotas,
+    private policy: SecurityPolicy
+  ) {
+    this.usage = {
+      toolCalls: 0,
+      tokens: 0,
+      executionTimeMs: 0,
+      costUsd: 0
+    };
+  }
+
+  /**
+   * Check if a tool call is allowed
+   */
+  checkToolCall(toolName: string): boolean {
+    // Check if tool is in denylist
+    if (this.policy.denylistedTools && this.policy.denylistedTools.includes(toolName)) {
+      this.recordViolation('tool_denied', `Tool '${toolName}' is in denylist`);
+      return false;
+    }
+
+    // Check if tool is in allowlist (if allowlist is defined and not empty)
+    if (this.policy.allowlistedTools && this.policy.allowlistedTools.length > 0 && 
+        !this.policy.allowlistedTools.includes(toolName)) {
+      this.recordViolation('tool_not_allowed', `Tool '${toolName}' is not in allowlist`);
+      return false;
+    }
+
+    // Check quota
+    if (this.usage.toolCalls >= this.quotas.maxToolCalls) {
+      this.recordViolation('quota_exceeded', 'Maximum tool calls exceeded');
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Record a tool call
+   */
+  recordToolCall(): void {
+    this.usage.toolCalls++;
+  }
+
+  /**
+   * Check if token usage is allowed
+   */
+  checkTokenUsage(tokens: number): boolean {
+    if (this.usage.tokens + tokens > this.quotas.maxTokens) {
+      this.recordViolation('quota_exceeded', 'Maximum tokens would be exceeded');
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * Record token usage
+   */
+  recordTokenUsage(tokens: number): void {
+    this.usage.tokens += tokens;
+  }
+
+  /**
+   * Check if execution time limit is exceeded
+   */
+  checkExecutionTime(currentTimeMs: number): boolean {
+    if (currentTimeMs > this.quotas.maxExecutionTimeMs) {
+      this.recordViolation('quota_exceeded', 'Maximum execution time exceeded');
+      return false;
+    }
+    this.usage.executionTimeMs = currentTimeMs;
+    return true;
+  }
+
+  /**
+   * Check if cost limit is exceeded
+   */
+  checkCost(additionalCost: number): boolean {
+    if (this.usage.costUsd + additionalCost > this.quotas.maxCostUsd) {
+      this.recordViolation('quota_exceeded', 'Maximum cost would be exceeded');
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * Record cost usage
+   */
+  recordCost(cost: number): void {
+    this.usage.costUsd += cost;
+  }
+
+  /**
+   * Get current usage
+   */
+  getUsage(): QuotaUsage {
+    return { ...this.usage };
+  }
+
+  /**
+   * Get current quotas
+   */
+  getQuotas(): ResourceQuotas {
+    return { ...this.quotas };
+  }
+
+  /**
+   * Get all policy violations
+   */
+  getViolations(): PolicyViolation[] {
+    return [...this.violations];
+  }
+
+  /**
+   * Check if there are any violations
+   */
+  hasViolations(): boolean {
+    return this.violations.length > 0;
+  }
+
+  /**
+   * Get the most recent violation
+   */
+  getLastViolation(): PolicyViolation | undefined {
+    return this.violations[this.violations.length - 1];
+  }
+
+  /**
+   * Reset usage counters
+   */
+  resetUsage(): void {
+    this.usage = {
+      toolCalls: 0,
+      tokens: 0,
+      executionTimeMs: 0,
+      costUsd: 0
+    };
+  }
+
+  /**
+   * Reset violations
+   */
+  resetViolations(): void {
+    this.violations = [];
+  }
+
+  /**
+   * Validate script content for security issues
+   */
+  validateScript(scriptContent: string): { valid: boolean; issues: string[] } {
+    const issues: string[] = [];
+
+    // Check for dangerous patterns
+    const dangerousPatterns = [
+      /require\s*\(/gi,           // Node.js require
+      /import\s+.*\s+from/gi,     // ES6 imports (should be handled by bundler)
+      /process\./gi,              // Process access
+      /global\./gi,               // Global object access
+      /eval\s*\(/gi,              // eval calls
+      /Function\s*\(/gi,          // Function constructor
+      /setTimeout/gi,             // setTimeout
+      /setInterval/gi,            // setInterval
+      /fetch\s*\(/gi,             // Direct fetch calls
+      /XMLHttpRequest/gi,         // XHR
+      /WebSocket/gi,              // WebSocket
+      /location\./gi,             // Location object
+      /document\./gi,             // Document object
+      /window\./gi,               // Window object
+    ];
+
+    for (const pattern of dangerousPatterns) {
+      if (pattern.test(scriptContent)) {
+        issues.push(`Potentially dangerous pattern detected: ${pattern.source}`);
+      }
+    }
+
+    // Check script length
+    if (scriptContent.length > this.policy.maxScriptLength) {
+      issues.push(`Script too long: ${scriptContent.length} > ${this.policy.maxScriptLength}`);
+    }
+
+    // Check for excessive complexity (rough heuristic)
+    const complexityIndicators = [
+      /for\s*\(/gi,
+      /while\s*\(/gi,
+      /function\s+\w+/gi,
+      /=>\s*{/gi,
+      /if\s*\(/gi,
+    ];
+
+    let complexityScore = 0;
+    for (const indicator of complexityIndicators) {
+      const matches = scriptContent.match(indicator);
+      complexityScore += matches ? matches.length : 0;
+    }
+
+    if (complexityScore > 50) {
+      issues.push(`Script complexity too high: ${complexityScore} constructs detected`);
+    }
+
+    return {
+      valid: issues.length === 0,
+      issues
+    };
+  }
+
+  /**
+   * Record a policy violation
+   */
+  private recordViolation(type: 'quota_exceeded' | 'tool_denied' | 'tool_not_allowed' | 'script_validation', message: string): void {
+    const violation: PolicyViolation = {
+      id: `violation-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+      type,
+      message,
+      timestamp: Date.now(),
+      usage: { ...this.usage }
+    };
+
+    this.violations.push(violation);
+  }
+}

package/src/services/script-execution/ScriptTracer.ts

@@ -0,0 +1,249 @@
+import { TraceEvent, TraceMetrics, ExecutionTrace, QuotaUsage } from "./types";
+
+/**
+ * Handles tracing and monitoring of script execution
+ */
+export class ScriptTracer {
+  private events: TraceEvent[] = [];
+  private metrics: TraceMetrics;
+  private startTime: number;
+
+  constructor() {
+    this.startTime = Date.now();
+    this.metrics = {
+      executionTimeMs: 0,
+      toolCallCount: 0,
+      llmCallCount: 0,
+      tokenUsage: {
+        prompt: 0,
+        completion: 0,
+        total: 0,
+      },
+      memoryUsage: {
+        heapUsed: 0,
+        heapTotal: 0,
+      },
+      costUsd: 0,
+    };
+  }
+
+  /**
+   * Emit a trace event
+   */
+  emitEvent(type: string, data: any): void {
+    const event: TraceEvent = {
+      id: `evt-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+      type,
+      timestamp: Date.now(),
+      data: this.sanitizeEventData(data),
+    };
+
+    this.events.push(event);
+    this.updateMetrics(event);
+  }
+
+  /**
+   * Record cost for tracking
+   */
+  recordCost(costUsd: number): void {
+    this.metrics.costUsd += costUsd;
+    this.emitEvent("cost_recorded", {
+      costUsd,
+      totalCost: this.metrics.costUsd,
+    });
+  }
+
+  /**
+   * Get current quota usage
+   */
+  getCurrentQuota(): QuotaUsage {
+    return {
+      toolCalls: this.metrics.toolCallCount,
+      tokens: this.metrics.tokenUsage.total,
+      executionTimeMs: Date.now() - this.startTime,
+      costUsd: this.metrics.costUsd,
+    };
+  }
+
+  /**
+   * Get all trace events
+   */
+  getEvents(): TraceEvent[] {
+    return [...this.events];
+  }
+
+  /**
+   * Get current metrics
+   */
+  getMetrics(): TraceMetrics {
+    return {
+      ...this.metrics,
+      executionTimeMs: Date.now() - this.startTime,
+    };
+  }
+
+  /**
+   * Generate execution trace
+   */
+  getTrace(): ExecutionTrace {
+    return {
+      id: `trace-${Date.now()}`,
+      startTime: this.startTime,
+      endTime: Date.now(),
+      events: this.getEvents(),
+      metrics: this.getMetrics(),
+      success: !this.events.some((e) => e.type.includes("error")),
+      error: this.getLastError(),
+    };
+  }
+
+  /**
+   * Clear all events and reset metrics
+   */
+  reset(): void {
+    this.events = [];
+    this.startTime = Date.now();
+    this.metrics = {
+      executionTimeMs: 0,
+      toolCallCount: 0,
+      llmCallCount: 0,
+      tokenUsage: {
+        prompt: 0,
+        completion: 0,
+        total: 0,
+      },
+      memoryUsage: {
+        heapUsed: 0,
+        heapTotal: 0,
+      },
+      costUsd: 0,
+    };
+  }
+
+  /**
+   * Update metrics based on events
+   */
+  private updateMetrics(event: TraceEvent): void {
+    switch (event.type) {
+      case "tool_call_start":
+        this.metrics.toolCallCount++;
+        break;
+
+      case "llm_call_start":
+        this.metrics.llmCallCount++;
+        break;
+
+      case "llm_call_success":
+        if (event.data && event.data.usage) {
+          const usage = event.data.usage;
+          this.metrics.tokenUsage.prompt += usage.prompt_tokens || 0;
+          this.metrics.tokenUsage.completion += usage.completion_tokens || 0;
+          this.metrics.tokenUsage.total += usage.total_tokens || 0;
+        }
+        break;
+    }
+
+    // Update memory usage if available
+    if (typeof process !== "undefined" && process.memoryUsage) {
+      const memUsage = process.memoryUsage();
+      this.metrics.memoryUsage.heapUsed = memUsage.heapUsed;
+      this.metrics.memoryUsage.heapTotal = memUsage.heapTotal;
+    }
+  }
+
+  /**
+   * Get the last error from events
+   */
+  private getLastError(): string | undefined {
+    const errorEvents = this.events
+      .filter((e) => e.type.includes("error"))
+      .reverse();
+
+    if (errorEvents.length > 0) {
+      const lastError = errorEvents[0];
+      return (
+        lastError.data?.error || lastError.data?.message || "Unknown error"
+      );
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Sanitize event data to prevent sensitive information leaks
+   */
+  private sanitizeEventData(data: any): any {
+    if (data === null || data === undefined) {
+      return data;
+    }
+
+    if (typeof data === "string") {
+      // Truncate very long strings
+      return data.length > 1000
+        ? data.substring(0, 1000) + "...[TRUNCATED]"
+        : data;
+    }
+
+    if (Array.isArray(data)) {
+      return data.map((item) => this.sanitizeEventData(item));
+    }
+
+    if (typeof data === "object") {
+      const sanitized: any = {};
+      for (const [key, value] of Object.entries(data)) {
+        // Redact sensitive keys
+        if (this.isSensitiveKey(key)) {
+          sanitized[key] = "[REDACTED]";
+        } else if (key === "parameters" && typeof value === "object") {
+          // Special handling for tool parameters
+          sanitized[key] = this.sanitizeParameters(value);
+        } else {
+          sanitized[key] = this.sanitizeEventData(value);
+        }
+      }
+      return sanitized;
+    }
+
+    return data;
+  }
+
+  /**
+   * Check if a key contains sensitive information
+   */
+  private isSensitiveKey(key: string): boolean {
+    const lowerKey = key.toLowerCase();
+    const sensitivePatterns = [
+      "password",
+      "secret",
+      "token",
+      "key",
+      "auth",
+      "credential",
+      "private",
+      "confidential",
+    ];
+
+    return sensitivePatterns.some((pattern) => lowerKey.includes(pattern));
+  }
+
+  /**
+   * Sanitize tool parameters
+   */
+  private sanitizeParameters(params: any): any {
+    if (!params || typeof params !== "object") {
+      return params;
+    }
+
+    const sanitized: any = {};
+    for (const [key, value] of Object.entries(params)) {
+      if (this.isSensitiveKey(key)) {
+        sanitized[key] = "[REDACTED]";
+      } else if (typeof value === "string" && value.length > 500) {
+        sanitized[key] = value.substring(0, 500) + "...[TRUNCATED]";
+      } else {
+        sanitized[key] = this.sanitizeEventData(value);
+      }
+    }
+    return sanitized;
+  }
+}

package/src/services/script-execution/types.ts

@@ -0,0 +1,134 @@
+import { Message } from '../../clients/types';
+
+// Basic trace event interface
+export interface TraceEvent {
+  id: string;
+  type: string;
+  timestamp: number;
+  data: any;
+}
+
+// Trace metrics for performance monitoring
+export interface TraceMetrics {
+  executionTimeMs: number;
+  toolCallCount: number;
+  llmCallCount: number;
+  tokenUsage: {
+    prompt: number;
+    completion: number;
+    total: number;
+  };
+  memoryUsage: {
+    heapUsed: number;
+    heapTotal: number;
+  };
+  costUsd: number;
+}
+
+// Complete execution trace
+export interface ExecutionTrace {
+  id: string;
+  startTime: number;
+  endTime: number;
+  events: TraceEvent[];
+  metrics: TraceMetrics;
+  success: boolean;
+  error?: string;
+}
+
+// Resource quotas for script execution
+export interface ResourceQuotas {
+  maxToolCalls: number;
+  maxTokens: number;
+  maxExecutionTimeMs: number;
+  maxCostUsd: number;
+  maxMemoryMb: number;
+}
+
+// Security policy configuration
+export interface SecurityPolicy {
+  allowlistedTools: string[];
+  denylistedTools: string[];
+  maxScriptLength: number;
+  allowNetworkAccess: boolean;
+  allowFileSystemAccess: boolean;
+}
+
+// Current quota usage tracking
+export interface QuotaUsage {
+  toolCalls: number;
+  tokens: number;
+  executionTimeMs: number;
+  costUsd: number;
+}
+
+// Policy violation record
+export interface PolicyViolation {
+  id: string;
+  type: 'quota_exceeded' | 'tool_denied' | 'tool_not_allowed' | 'script_validation';
+  message: string;
+  timestamp: number;
+  usage: QuotaUsage;
+}
+
+// Script execution request
+export interface ExecutionRequest {
+  script: string;
+  context?: Record<string, any>;
+  quotas?: Partial<ResourceQuotas>;
+  policy?: Partial<SecurityPolicy>;
+}
+
+// Script execution result
+export interface ExecutionResult {
+  success: boolean;
+  error: string | null;
+  result: any;
+  trace: ExecutionTrace;
+  artifacts: Artifact[];
+  consoleOutput: string[];
+}
+
+// Artifact created by script
+export interface Artifact {
+  id: string;
+  name: string;
+  type: 'text' | 'json' | 'csv' | 'html' | 'markdown';
+  content: string;
+  createdAt: string;
+}
+
+// Tool execution result
+export interface ToolResult {
+  success: boolean;
+  result?: any;
+  error?: string;
+}
+
+// Tool call record
+export interface ToolCall {
+  id: string;
+  name: string;
+  args: Record<string, any>;
+  result?: any;
+  error?: string;
+  timestamp: number;
+  duration?: number;
+}
+
+// LLM call record
+export interface LLMCall {
+  id: string;
+  model: string;
+  messages: Message[];
+  response?: any;
+  error?: string;
+  timestamp: number;
+  duration?: number;
+  tokenUsage?: {
+    prompt: number;
+    completion: number;
+    total: number;
+  };
+  cost?: number;
+}

package/src/worker.ts

@@ -1,10 +1,9 @@
 import os from "os";
 import { WebSocket } from "ws";
-import { Developer, Patcher, Researcher } from "./agents";
 import { includedTools } from "./agents/tools/list";
 import { loadJwt } from "./login";
-import { Agents, Tools } from "./services";
-import { Mcp, McpServerService } from "./services/Mcp";
+import { services } from "./services";
+import { McpServerService } from "./services/Mcp";
 import * as allTools from "./agents/tools";
 import { wait } from "./utils";
 import { getConfig, updateConfig } from "./config";
@@ -12,6 +11,7 @@ import { getConfig, updateConfig } from "./config";
 const API_URL = process.env.KNOWHOW_API_URL;
 
 export async function worker() {
+  const { Tools } = services();
   const mcpServer = new McpServerService(Tools);
   const clientName = "knowhow-worker";
   const clientVersion = "1.1.1";

package/tests/integration/fileblocks/readwrite.test.ts

@@ -1,9 +1,10 @@
 import * as fs from "fs";
 import { readFile, writeFile } from "../../../src/utils";
-import { Patcher } from "../../../src/agents/patcher/patcher";
+import { agents } from "../../../src/agents";
 import { FlagsService } from "../../../src/services/flags";
 
 describe("Developer", () => {
+  const { Patcher } = agents();
   beforeAll(() => {
     Patcher.disableTool("searchFiles");
     Patcher.disableTool("execCommand");

package/tests/integration/patching.test.ts

@@ -2,9 +2,8 @@ import { readFile, writeFile } from "../../src/utils";
 import { createPatch, applyPatch } from "diff";
 import { scanFile } from "../../src/agents/tools";
 import { patchFile } from "../../src/agents/tools/patch";
-import { Agents } from "../../src/services/AgentService";
-import { Patcher } from "../../src/agents";
-import { Tools } from "../../src/services";
+import { agents } from "../../src/agents";
+import { services } from "../../src/services";
 import { includedTools } from "../../src/agents/tools/list";
 import * as allTools from "../../src/agents/tools";
 
@@ -29,11 +28,12 @@ const brokenPatch = `Index: tests/integration/patching/input.txt
        }\n`;
 
 describe("Patcher", () => {
-  beforeAll(async () => {
+  const { Agents, Tools } = beforeAll(async () => {
+    const { Patcher } = agents();
     Agents.registerAgent(Patcher);
     Tools.addTools(includedTools);
     const toolFunctions = Object.entries(allTools)
-      .filter(([_, value]) => typeof value === 'function')
+      .filter(([_, value]) => typeof value === "function")
       .reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {});
     Tools.addFunctions(toolFunctions);
   });

package/ts_build/src/agents/base/base.d.ts

@@ -11,10 +11,12 @@ export interface ModelPreference {
     model: string;
     provider: keyof typeof Clients.clients;
 }
+export interface AgentContext {
+    Tools?: ToolsService;
+    Events?: EventService;
+    messageProcessor?: MessageProcessor;
+}
 export declare abstract class BaseAgent implements IAgent {
-    tools: ToolsService;
-    events: EventService;
-    messageProcessor: MessageProcessor;
     abstract name: string;
     abstract description: string;
     private status;
@@ -43,8 +45,11 @@ export declare abstract class BaseAgent implements IAgent {
         kill: string;
         unpause: string;
     };
+    tools: ToolsService;
+    events: EventService;
+    messageProcessor: MessageProcessor;
     disabledTools: any[];
-    constructor(tools?: ToolsService, events?: EventService, messageProcessor?: MessageProcessor);
+    constructor(context: AgentContext);
     newTask(): void;
     register(): void;
     setModelPreferences(value: ModelPreference[]): void;