agentstudio 0.3.0 → 0.3.1

package/backend/src/services/taskExecutor/taskWorker.ts

@@ -0,0 +1,222 @@
+/**
+ * Task Worker - Executes tasks in isolated worker threads
+ *
+ * This worker runs in a separate thread and handles:
+ * 1. Building query options for Claude SDK
+ * 2. Executing the agent task
+ * 3. Collecting logs and results
+ * 4. Reporting results back to main thread
+ */
+
+import { parentPort, workerData } from 'worker_threads';
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { buildQueryOptions } from '../../utils/claudeUtils.js';
+import { AgentStorage } from '../../services/agentStorage.js';
+import type { TaskDefinition, TaskResult } from './types.js';
+
+// ============================================================================
+// Types
+// ============================================================================
+
+interface WorkerMessage {
+  type: 'log' | 'progress' | 'complete' | 'error';
+  data?: unknown;
+}
+
+interface ExecutionLogEntry {
+  timestamp: string;
+  level: 'info' | 'warn' | 'error' | 'debug';
+  type: string;
+  message: string;
+  data?: Record<string, unknown>;
+}
+
+// ============================================================================
+// Worker Execution
+// ============================================================================
+
+/**
+ * Main execution function
+ */
+async function executeTask(task: TaskDefinition): Promise<TaskResult> {
+  const startTime = Date.now();
+  const logs: ExecutionLogEntry[] = [];
+
+  const addLog = (
+    level: ExecutionLogEntry['level'],
+    type: string,
+    message: string,
+    data?: Record<string, unknown>
+  ) => {
+    const log: ExecutionLogEntry = {
+      timestamp: new Date().toISOString(),
+      level,
+      type,
+      message,
+      data,
+    };
+    logs.push(log);
+
+    // Send log to parent process for real-time monitoring
+    parentPort?.postMessage({
+      type: 'log',
+      data: log,
+    } as WorkerMessage);
+  };
+
+  try {
+    addLog('info', 'system', `Starting task execution: ${task.id}`);
+    addLog('info', 'system', `Task type: ${task.type}`);
+    addLog('info', 'system', `Agent: ${task.agentId}`);
+    addLog('info', 'system', `Project: ${task.projectPath}`);
+    addLog('info', 'system', `Message: ${task.message.substring(0, 100)}...`);
+
+    // Load agent configuration
+    const agentStorage = new AgentStorage();
+    const agent = agentStorage.getAgent(task.agentId);
+
+    if (!agent) {
+      throw new Error(`Agent not found: ${task.agentId}`);
+    }
+
+    addLog('info', 'system', `Agent loaded: ${agent.name}`);
+
+    // Determine model to use
+    // Model priority: task.modelId > project/provider config (resolved by buildQueryOptions)
+    // If task.modelId is not specified, let resolveConfig determine from project/system defaults
+    const modelToUse = task.modelId;
+    addLog('info', 'system', `Model: ${modelToUse || 'auto (from project/system)'}`);
+
+    // Determine permission mode
+    const permissionMode = task.permissionMode || 'bypassPermissions';
+    addLog('info', 'system', `Permission mode: ${permissionMode}`);
+
+    // Build query options
+    addLog('info', 'system', 'Building query options...');
+
+    const { queryOptions } = await buildQueryOptions(
+      agent,
+      task.projectPath,
+      undefined, // mcpTools
+      permissionMode,
+      modelToUse,
+      task.claudeVersionId,
+      undefined, // defaultEnv
+      undefined, // userEnv
+      undefined, // sessionIdForAskUser
+      undefined  // agentIdForAskUser
+    );
+
+    // Set max turns
+    queryOptions.maxTurns = task.maxTurns || agent.maxTurns || 10;
+
+    addLog('info', 'system', `Max turns: ${queryOptions.maxTurns}`);
+
+    // Execute query
+    addLog('info', 'system', 'Starting Claude query...');
+
+    let fullResponse = '';
+    let sessionId: string | undefined;
+
+    for await (const message of query({
+      prompt: task.message,
+      options: queryOptions,
+    })) {
+      // Capture session ID
+      if (message.session_id && !sessionId) {
+        sessionId = message.session_id;
+        addLog('info', 'system', `Session ID: ${sessionId}`);
+      }
+
+      // Process different message types
+      if (message.type === 'assistant' && message.message?.content) {
+        for (const block of message.message.content) {
+          if (block.type === 'text') {
+            fullResponse += block.text;
+            addLog('debug', 'assistant', block.text.substring(0, 200));
+          } else if (block.type === 'tool_use') {
+            addLog('info', 'tool_use', `Tool: ${block.name}`);
+          }
+        }
+      } else if (message.type === 'result') {
+        addLog('info', 'result', `Query completed`, {
+          costUsd: (message as any).total_cost_usd,
+          durationMs: (message as any).duration_ms,
+          numTurns: (message as any).num_turns,
+        });
+      }
+    }
+
+    const executionTimeMs = Date.now() - startTime;
+    addLog('info', 'system', `Task completed in ${executionTimeMs}ms`);
+
+    return {
+      taskId: task.id,
+      status: 'completed',
+      output: fullResponse,
+      sessionId,
+      completedAt: new Date().toISOString(),
+      executionTimeMs,
+      logs,
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const errorStack = error instanceof Error ? error.stack : undefined;
+
+    addLog('error', 'system', `Task failed: ${errorMessage}`, { stack: errorStack });
+
+    return {
+      taskId: task.id,
+      status: 'failed',
+      error: errorMessage,
+      errorStack,
+      completedAt: new Date().toISOString(),
+      executionTimeMs: Date.now() - startTime,
+      logs,
+    };
+  }
+}
+
+// ============================================================================
+// Worker Entry Point
+// ============================================================================
+
+/**
+ * Worker entry point - receives task data and executes it
+ */
+async function main() {
+  try {
+    const task = workerData as TaskDefinition;
+
+    if (!task || !task.id) {
+      throw new Error('Invalid task data received');
+    }
+
+    // Execute the task
+    const result = await executeTask(task);
+
+    // Send result back to parent
+    parentPort?.postMessage({
+      type: 'complete',
+      data: result,
+    } as WorkerMessage);
+  } catch (error) {
+    // Send error back to parent
+    parentPort?.postMessage({
+      type: 'error',
+      data: {
+        taskId: workerData?.id || 'unknown',
+        status: 'failed',
+        error: error instanceof Error ? error.message : String(error),
+        completedAt: new Date().toISOString(),
+        executionTimeMs: 0,
+      },
+    } as WorkerMessage);
+  }
+}
+
+// Start execution
+main().catch((err) => {
+  console.error('[TaskWorker] Fatal error:', err);
+  process.exit(1);
+});

package/backend/src/services/taskExecutor/types.ts

@@ -0,0 +1,179 @@
+/**
+ * Unified Task Executor Types
+ *
+ * Defines the interfaces for a pluggable task execution system that supports
+ * both A2A async tasks and scheduled tasks.
+ */
+
+/**
+ * Task type identifier
+ */
+export type TaskType = 'a2a_async' | 'scheduled';
+
+/**
+ * Permission mode for task execution
+ */
+export type PermissionMode = 'bypassPermissions' | 'default';
+
+/**
+ * Push Notification Configuration for task callbacks
+ */
+export interface TaskPushNotificationConfig {
+  url: string;
+  token?: string;
+  authScheme?: string;  // e.g., "Bearer"
+  authCredentials?: string;
+}
+
+/**
+ * Task definition - submitted to executor
+ */
+export interface TaskDefinition {
+  // Identity
+  id: string;
+  type: TaskType;
+  priority?: number;
+
+  // Agent and execution context
+  agentId: string;
+  projectPath: string;
+  message: string;
+
+  // Execution configuration
+  timeoutMs: number;
+  maxTurns?: number;
+  modelId?: string;
+  claudeVersionId?: string;
+  permissionMode?: PermissionMode;
+
+  // Metadata
+  createdAt: string;
+  scheduledFor?: string; // For scheduled tasks
+  scheduledTaskId?: string; // Original scheduled task ID (for status updates)
+
+  // Push Notification (for A2A async tasks)
+  pushNotificationConfig?: TaskPushNotificationConfig;
+}
+
+/**
+ * Task execution result
+ */
+export interface TaskResult {
+  taskId: string;
+  status: 'completed' | 'failed' | 'canceled';
+  output?: string;
+  sessionId?: string;
+  error?: string;
+  errorStack?: string;
+  completedAt: string;
+  executionTimeMs: number;
+
+  // Additional metadata
+  logs?: Array<{
+    timestamp: string;
+    level: 'info' | 'warn' | 'error' | 'debug';
+    type: string;
+    message: string;
+    data?: Record<string, unknown>;
+  }>;
+}
+
+/**
+ * Task status query result
+ */
+export interface TaskStatus {
+  taskId: string;
+  status: 'pending' | 'running' | 'completed' | 'failed' | 'canceled';
+  createdAt: string;
+  startedAt?: string;
+  completedAt?: string;
+  executionTimeMs?: number;
+  error?: string;
+}
+
+/**
+ * Task executor configuration
+ */
+export interface TaskExecutorConfig {
+  // Concurrency
+  maxConcurrent: number;
+
+  // Timeouts
+  defaultTimeoutMs: number;
+
+  // Resource limits
+  maxMemoryMb?: number;
+
+  // Retry configuration
+  maxRetries?: number;
+  retryDelayMs?: number;
+}
+
+/**
+ * Interface for task executor implementations
+ */
+export interface ITaskExecutor {
+  /**
+   * Start the executor
+   */
+  start(): Promise<void>;
+
+  /**
+   * Stop the executor and cancel all running tasks
+   */
+  stop(): Promise<void>;
+
+  /**
+   * Submit a task for execution
+   * @param task - Task definition
+   */
+  submitTask(task: TaskDefinition): Promise<void>;
+
+  /**
+   * Cancel a running or pending task
+   * @param taskId - Task ID to cancel
+   * @returns true if task was canceled, false if not found or already completed
+   */
+  cancelTask(taskId: string): Promise<boolean>;
+
+  /**
+   * Get current status of a task
+   * @param taskId - Task ID to query
+   * @returns Task status or null if not found
+   */
+  getTaskStatus(taskId: string): Promise<TaskStatus | null>;
+
+  /**
+   * Check if executor is healthy
+   */
+  isHealthy(): boolean;
+
+  /**
+   * Get executor statistics
+   */
+  getStats(): TaskExecutorStats;
+
+  /**
+   * Get current executor configuration
+   */
+  getConfig(): TaskExecutorConfig;
+
+  /**
+   * Update executor configuration dynamically
+   * @param config - Partial configuration to update
+   */
+  updateConfig(config: Partial<TaskExecutorConfig>): void;
+}
+
+/**
+ * Executor statistics
+ */
+export interface TaskExecutorStats {
+  mode: string;
+  runningTasks: number;
+  queuedTasks: number;
+  completedTasks: number;
+  failedTasks: number;
+  canceledTasks: number;
+  uptimeMs: number;
+}

package/backend/src/services/telemetry.ts

@@ -0,0 +1,234 @@
+/**
+ * Backend Telemetry Service
+ * 
+ * Uses PostHog for anonymous usage data collection.
+ * - Default: disabled (opt-in model for backend)
+ * - Can be enabled via TELEMETRY_ENABLED=true
+ */
+
+import { PostHog } from 'posthog-node';
+import { v4 as uuidv4 } from 'uuid';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+// PostHog configuration (hardcoded for distribution)
+const POSTHOG_API_KEY = 'phc_5knpC9zvXXFaTJw4EMwrRBSYHIYW7b8ig6E14N8jYDp';
+const POSTHOG_HOST = 'https://app.posthog.com';
+// Backend telemetry can be disabled via environment variable (default: enabled for npm package users)
+const TELEMETRY_ENABLED = process.env.TELEMETRY_ENABLED !== 'false';
+
+// App version from package.json
+let APP_VERSION = '0.2.0';
+try {
+  const pkgPath = path.join(__dirname, '../../package.json');
+  if (fs.existsSync(pkgPath)) {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    APP_VERSION = pkg.version || APP_VERSION;
+  }
+} catch {
+  // Ignore errors
+}
+
+// Instance ID storage
+const INSTANCE_ID_FILE = path.join(os.homedir(), '.agentstudio', 'instance_id');
+
+/**
+ * Get or create the instance ID for this backend installation
+ */
+function getInstanceId(): string {
+  try {
+    // Create directory if not exists
+    const dir = path.dirname(INSTANCE_ID_FILE);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    
+    // Read existing ID or create new one
+    if (fs.existsSync(INSTANCE_ID_FILE)) {
+      return fs.readFileSync(INSTANCE_ID_FILE, 'utf-8').trim();
+    } else {
+      const id = uuidv4();
+      fs.writeFileSync(INSTANCE_ID_FILE, id);
+      return id;
+    }
+  } catch {
+    // Fallback to random ID per process
+    return uuidv4();
+  }
+}
+
+// PostHog client (lazy initialization)
+let posthogClient: PostHog | null = null;
+let instanceId: string | null = null;
+
+/**
+ * Initialize the PostHog client
+ */
+function initPostHog(): PostHog | null {
+  if (!TELEMETRY_ENABLED) {
+    console.log('[Telemetry] Backend telemetry is disabled. Set TELEMETRY_ENABLED=true to enable.');
+    return null;
+  }
+
+  try {
+    const client = new PostHog(POSTHOG_API_KEY, {
+      host: POSTHOG_HOST,
+      flushAt: 10,
+      flushInterval: 30000,
+    });
+
+    instanceId = getInstanceId();
+    
+    console.log(`[Telemetry] Backend telemetry initialized (instance: ${instanceId.slice(0, 8)}...)`);
+    
+    // Track backend start
+    client.capture({
+      distinctId: instanceId,
+      event: 'app_start',
+      properties: {
+        platform: 'backend',
+        app_version: APP_VERSION,
+        os: process.platform,
+        node_version: process.version,
+      },
+    });
+
+    return client;
+  } catch (error) {
+    console.error('[Telemetry] Failed to initialize PostHog:', error);
+    return null;
+  }
+}
+
+/**
+ * Get the PostHog client (initializes if needed)
+ */
+function getClient(): PostHog | null {
+  if (posthogClient === null && TELEMETRY_ENABLED) {
+    posthogClient = initPostHog();
+  }
+  return posthogClient;
+}
+
+/**
+ * Check if telemetry is enabled
+ */
+export function isTelemetryEnabled(): boolean {
+  return TELEMETRY_ENABLED;
+}
+
+/**
+ * Track an event
+ */
+export function trackEvent(
+  event: string, 
+  properties?: Record<string, string | number | boolean>
+): void {
+  const client = getClient();
+  if (!client || !instanceId) return;
+
+  client.capture({
+    distinctId: instanceId,
+    event,
+    properties: {
+      platform: 'backend',
+      app_version: APP_VERSION,
+      ...properties,
+    },
+  });
+}
+
+/**
+ * Track feature usage
+ */
+export function trackFeature(feature: string, action?: string): void {
+  trackEvent('feature_used', {
+    feature,
+    action: action || 'use',
+  });
+}
+
+/**
+ * Track an error
+ */
+export function trackError(error: Error, component?: string): void {
+  const client = getClient();
+  if (!client || !instanceId) return;
+
+  // Sanitize error message
+  const sanitizeMessage = (msg: string) => {
+    return msg
+      .replace(/(?:\/[^\s:]+)+/g, '[PATH]')
+      .replace(/(?:[A-Za-z]:\\[^\s:]+)+/g, '[PATH]')
+      .replace(/[a-zA-Z0-9]{32,}/g, '[REDACTED]')
+      .substring(0, 256);
+  };
+
+  client.capture({
+    distinctId: instanceId,
+    event: 'app_error',
+    properties: {
+      platform: 'backend',
+      app_version: APP_VERSION,
+      message: sanitizeMessage(error.message),
+      errorType: error.name,
+      component: component || 'unknown',
+    },
+  });
+}
+
+/**
+ * Track agent usage
+ */
+export function trackAgentUsage(
+  agentId: string, 
+  action: 'chat_start' | 'chat_end' | 'tool_call',
+  properties?: Record<string, string | number | boolean>
+): void {
+  trackEvent('agent_usage', {
+    agent_id: agentId,
+    action,
+    ...properties,
+  });
+}
+
+/**
+ * Track MCP server usage
+ */
+export function trackMcpUsage(
+  serverName: string, 
+  action: 'connect' | 'disconnect' | 'tool_call' | 'error'
+): void {
+  trackEvent('mcp_usage', {
+    server_name: serverName,
+    action,
+  });
+}
+
+/**
+ * Track scheduled task execution
+ */
+export function trackScheduledTask(
+  taskId: string,
+  action: 'execute' | 'success' | 'failure'
+): void {
+  trackEvent('scheduled_task', {
+    task_id: taskId,
+    action,
+  });
+}
+
+/**
+ * Shutdown telemetry (flush pending events)
+ */
+export async function shutdownTelemetry(): Promise<void> {
+  const client = getClient();
+  if (client) {
+    await client.shutdown();
+    console.log('[Telemetry] Backend telemetry shutdown');
+  }
+}
+
+// Initialize on import if enabled
+getClient();