agentstudio 0.2.9 → 0.3.1

package/backend/src/utils/networkUtils.ts

@@ -0,0 +1,68 @@
+/**
+ * Network Utilities
+ * 
+ * Provides network-related utility functions such as getting local IP addresses.
+ */
+
+import os from 'os';
+
+/**
+ * Get local network IP addresses (non-localhost)
+ * Returns all IPv4 addresses that are not loopback addresses
+ */
+export function getLocalIPAddresses(): string[] {
+  const interfaces = os.networkInterfaces();
+  const addresses: string[] = [];
+
+  for (const interfaceName in interfaces) {
+    const networkInterface = interfaces[interfaceName];
+    if (!networkInterface) continue;
+
+    for (const details of networkInterface) {
+      // Only include IPv4 addresses that are not internal (not loopback)
+      if (details.family === 'IPv4' && !details.internal) {
+        addresses.push(details.address);
+      }
+    }
+  }
+
+  return addresses;
+}
+
+/**
+ * Get the best local IP address to use for external access
+ * Prefers private network addresses (192.168.x.x, 10.x.x.x, 172.16-31.x.x)
+ * Falls back to any non-localhost IP if available
+ */
+export function getBestLocalIP(): string | null {
+  const addresses = getLocalIPAddresses();
+  
+  if (addresses.length === 0) {
+    return null;
+  }
+
+  // Prefer private network addresses
+  const privateAddresses = addresses.filter(addr => 
+    addr.startsWith('192.168.') || 
+    addr.startsWith('10.') || 
+    /^172\.(1[6-9]|2[0-9]|3[0-1])\./.test(addr)
+  );
+
+  if (privateAddresses.length > 0) {
+    return privateAddresses[0];
+  }
+
+  // If no private addresses, return the first available
+  return addresses[0];
+}
+
+/**
+ * Get network information including IP addresses and hostname
+ */
+export function getNetworkInfo() {
+  return {
+    hostname: os.hostname(),
+    localIPs: getLocalIPAddresses(),
+    bestLocalIP: getBestLocalIP(),
+  };
+}

package/backend/src/utils/sessionUtils.ts

@@ -0,0 +1,303 @@
+/**
+ * Session Utils - Shared utilities for session management
+ * 
+ * This module provides common functions for managing Claude sessions,
+ * used by both the main agents API and Slack integration.
+ */
+
+import * as path from 'path';
+import * as fs from 'fs';
+import { sessionManager, SessionConfigSnapshot } from '../services/sessionManager.js';
+import { getAllVersions, getDefaultVersionId } from '../services/claudeVersionStorage.js';
+
+/**
+ * Session mode for handling session management
+ * - 'new': Always create a new ClaudeSession (Query), but still use resume=sessionId for history context
+ * - 'reuse': Try to reuse existing ClaudeSession from SessionManager (original behavior)
+ */
+export type SessionMode = 'reuse' | 'new';
+
+/**
+ * Handle session management logic with config change detection
+ * Creates new session or reuses existing one based on sessionId and sessionMode
+ * Automatically detects config changes and recreates session if needed
+ * 
+ * @param agentId - Agent ID
+ * @param sessionId - Optional existing session ID (used for resume even in 'new' mode)
+ * @param projectPath - Optional project path for session history
+ * @param queryOptions - Query options for Claude SDK
+ * @param claudeVersionId - Optional Claude version ID
+ * @param modelId - Optional model ID
+ * @param sessionMode - Session mode: 'new' always creates fresh ClaudeSession (but still uses resume), 'reuse' tries to reuse existing ClaudeSession from SessionManager
+ * @param configSnapshot - Optional config snapshot for change detection
+ */
+export async function handleSessionManagement(
+  agentId: string,
+  sessionId: string | null,
+  projectPath: string | undefined,
+  queryOptions: any,
+  claudeVersionId?: string,
+  modelId?: string,
+  sessionMode: SessionMode = 'reuse',
+  configSnapshot?: SessionConfigSnapshot
+): Promise<{ claudeSession: any; actualSessionId: string | null }> {
+  let claudeSession: any;
+  const actualSessionId: string | null = sessionId || null;
+
+  // If sessionMode is 'new', always create a fresh ClaudeSession (Query)
+  // but still use sessionId for resume to restore history context
+  if (sessionMode === 'new') {
+    if (sessionId) {
+      // Check if session history exists for resume
+      const sessionExists = sessionManager.checkSessionExists(sessionId, projectPath);
+      if (sessionExists) {
+        // Create new ClaudeSession with resume=sessionId (bypassing SessionManager cache)
+        console.log(`🆕 [sessionMode=new] Creating fresh ClaudeSession with resume=${sessionId} for agent: ${agentId}`);
+        claudeSession = sessionManager.createNewSession(agentId, queryOptions, sessionId, claudeVersionId, modelId, configSnapshot);
+      } else {
+        // No history to resume, create completely new session
+        console.log(`🆕 [sessionMode=new] Creating fresh ClaudeSession (no history found) for agent: ${agentId}`);
+        claudeSession = sessionManager.createNewSession(agentId, queryOptions, undefined, claudeVersionId, modelId, configSnapshot);
+      }
+    } else {
+      // No sessionId provided, create completely new session
+      console.log(`🆕 [sessionMode=new] Creating fresh ClaudeSession (no sessionId) for agent: ${agentId}`);
+      claudeSession = sessionManager.createNewSession(agentId, queryOptions, undefined, claudeVersionId, modelId, configSnapshot);
+    }
+    return { claudeSession, actualSessionId };
+  }
+
+  // sessionMode === 'reuse': Try to reuse existing ClaudeSession from SessionManager
+  // But first check if config has changed
+  if (sessionId && configSnapshot) {
+    const configChanged = sessionManager.hasConfigChanged(sessionId, configSnapshot);
+    if (configChanged) {
+      console.log(`🔄 Config changed for session ${sessionId}, removing old session and creating new one`);
+      // Remove old session
+      await sessionManager.removeSession(sessionId);
+      
+      // Check if session history exists for resume
+      const sessionExists = sessionManager.checkSessionExists(sessionId, projectPath);
+      if (sessionExists) {
+        // Create new ClaudeSession with resume=sessionId to preserve history
+        console.log(`🆕 Creating fresh ClaudeSession with resume=${sessionId} due to config change for agent: ${agentId}`);
+        claudeSession = sessionManager.createNewSession(agentId, queryOptions, sessionId, claudeVersionId, modelId, configSnapshot);
+        return { claudeSession, actualSessionId };
+      } else {
+        // No history to resume, create completely new session
+        console.log(`🆕 Creating fresh ClaudeSession (no history) due to config change for agent: ${agentId}`);
+        claudeSession = sessionManager.createNewSession(agentId, queryOptions, undefined, claudeVersionId, modelId, configSnapshot);
+        return { claudeSession, actualSessionId: null };
+      }
+    }
+  }
+
+  if (sessionId) {
+    // Try to reuse existing session from SessionManager cache
+    console.log(`🔍 Looking for existing session: ${sessionId} for agent: ${agentId}`);
+    claudeSession = sessionManager.getSession(sessionId);
+    
+    if (claudeSession) {
+      // 并发控制：检查会话是否正在处理其他请求
+      if (sessionManager.isSessionBusy(sessionId)) {
+        console.warn(`⚠️  Session ${sessionId} is currently busy processing another request`);
+        throw new Error('SESSION_BUSY: This session is currently processing another request. Please wait for the current request to complete or create a new session.');
+      }
+      console.log(`♻️  Using existing persistent Claude session: ${sessionId} for agent: ${agentId}`);
+    } else {
+      console.log(`❌ Session ${sessionId} not found in memory for agent: ${agentId}`);
+
+      // Check if session history exists in project directory
+      console.log(`🔍 Checking project directory for session history: ${sessionId}, projectPath: ${projectPath}`);
+      const sessionExists = sessionManager.checkSessionExists(sessionId, projectPath);
+      console.log(`📁 Session history exists: ${sessionExists} for sessionId: ${sessionId}`);
+
+      if (sessionExists) {
+        // Session history exists, resume session
+        console.log(`🔄 Found session history for ${sessionId}, resuming session for agent: ${agentId}`);
+        claudeSession = sessionManager.createNewSession(agentId, queryOptions, sessionId, claudeVersionId, modelId, configSnapshot);
+      } else {
+        // Session history not found, create new session but keep original sessionId for frontend
+        console.log(`⚠️  Session ${sessionId} not found in memory or project history, creating new session for agent: ${agentId}`);
+        claudeSession = sessionManager.createNewSession(agentId, queryOptions, undefined, claudeVersionId, modelId, configSnapshot);
+      }
+    }
+  } else {
+    // Create new persistent session
+    claudeSession = sessionManager.createNewSession(agentId, queryOptions, undefined, claudeVersionId, modelId, configSnapshot);
+    console.log(`🆕 Created new persistent Claude session for agent: ${agentId}`);
+  }
+
+  return { claudeSession, actualSessionId };
+}
+
+/**
+ * Check if a model supports vision (image input)
+ * Gets model configuration from version settings
+ * 
+ * @param model - Model ID
+ * @param claudeVersionId - Optional Claude version ID
+ */
+export async function isVisionModel(model: string, claudeVersionId?: string): Promise<boolean> {
+  try {
+    // Get version configuration
+    let versionId = claudeVersionId;
+    if (!versionId) {
+      versionId = await getDefaultVersionId() || 'system';
+    }
+
+    const versions = await getAllVersions();
+    const version = versions.find(v => v.id === versionId);
+
+    if (!version || !version.models) {
+      // If version or model config not found, assume vision support
+      console.warn(`⚠️ Version ${versionId} not found or has no model config, assuming vision support`);
+      return true;
+    }
+
+    // Find matching model in version's model list
+    const modelConfig = version.models.find(m => m.id === model);
+    if (modelConfig) {
+      console.log(`✅ Found model config for ${model}: isVision=${modelConfig.isVision}`);
+      return modelConfig.isVision;
+    }
+
+    // If no exact match found, assume vision support
+    console.warn(`⚠️ Model ${model} not found in version ${versionId} config, assuming vision support`);
+    return true;
+  } catch (error) {
+    console.error('Failed to check vision support:', error);
+    // Default to assuming vision support on error
+    return true;
+  }
+}
+
+/**
+ * Save image to hidden directory and return relative path
+ * Used for non-vision models that need image files
+ * 
+ * @param imageData - Base64 encoded image data
+ * @param mediaType - Image media type (image/jpeg, image/png, etc.)
+ * @param imageIndex - Index of the image
+ * @param projectPath - Optional project path
+ */
+export function saveImageToHiddenDir(
+  imageData: string,
+  mediaType: string,
+  imageIndex: number,
+  projectPath?: string
+): string {
+  const cwd = projectPath || process.cwd();
+  const hiddenDir = path.join(cwd, '.agentstudio-images');
+
+  // Ensure hidden directory exists
+  if (!fs.existsSync(hiddenDir)) {
+    fs.mkdirSync(hiddenDir, { recursive: true });
+  }
+
+  // Determine file extension from media type
+  const extMap: Record<string, string> = {
+    'image/jpeg': 'jpg',
+    'image/png': 'png',
+    'image/gif': 'gif',
+    'image/webp': 'webp'
+  };
+  const ext = extMap[mediaType] || 'jpg';
+
+  // Generate unique filename
+  const timestamp = Date.now();
+  const filename = `image${imageIndex}_${timestamp}.${ext}`;
+  const filepath = path.join(hiddenDir, filename);
+
+  // Write base64 data to file
+  const buffer = Buffer.from(imageData, 'base64');
+  fs.writeFileSync(filepath, buffer);
+
+  // Return relative path from project root
+  return path.relative(cwd, filepath);
+}
+
+/**
+ * Build user message content with optional image support
+ * Handles both vision and non-vision models
+ * 
+ * @param message - Text message
+ * @param images - Optional array of images
+ * @param model - Optional model ID to check vision support
+ * @param projectPath - Optional project path for saving images
+ * @param claudeVersionId - Optional Claude version ID
+ */
+export async function buildUserMessageContent(
+  message: string,
+  images?: any[],
+  model?: string,
+  projectPath?: string,
+  claudeVersionId?: string
+) {
+  const messageContent: any[] = [];
+  let processedMessage = message;
+
+  // Check if model supports vision (from version configuration)
+  const supportsVision = model ? await isVisionModel(model, claudeVersionId) : true;
+
+  // Process images
+  if (images && images.length > 0) {
+    console.log('📸 Processing images:', images.map(img => ({
+      id: img.id,
+      mediaType: img.mediaType,
+      filename: img.filename,
+      size: img.data.length
+    })));
+
+    if (supportsVision) {
+      // Vision model: add images directly to message content
+      console.log('✅ Model supports vision, adding images directly to message content');
+      for (const image of images) {
+        messageContent.push({
+          type: "image",
+          source: {
+            type: "base64",
+            media_type: image.mediaType,
+            data: image.data
+          }
+        });
+      }
+    } else {
+      // Non-vision model: save images to hidden directory, replace placeholders with paths
+      console.log('⚠️ Model does not support vision, saving images to hidden directory');
+      for (let i = 0; i < images.length; i++) {
+        const image = images[i];
+        const imageIndex = i + 1;
+        const placeholder = `[image${imageIndex}]`;
+
+        try {
+          // Save image and get path
+          const imagePath = saveImageToHiddenDir(image.data, image.mediaType, imageIndex, projectPath);
+          console.log(`💾 Saved image ${imageIndex} to: ${imagePath}`);
+
+          // Replace placeholder in message with file path (add @ prefix)
+          processedMessage = processedMessage.replace(placeholder, `@${imagePath}`);
+        } catch (error) {
+          console.error(`Failed to save image ${imageIndex}:`, error);
+          // If save fails, keep placeholder
+        }
+      }
+    }
+  }
+
+  // Add text content if provided
+  if (processedMessage && processedMessage.trim()) {
+    messageContent.push({
+      type: "text",
+      text: processedMessage
+    });
+  }
+
+  return {
+    type: "user" as const,
+    message: {
+      role: "user" as const,
+      content: messageContent
+    }
+  };
+}

package/backend/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022"],
+    "module": "CommonJS",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "./dist",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "noEmit": false,
+    "resolveJsonModule": true,
+    "baseUrl": ".",
+    "paths": {
+      "*/streaming": ["../shared/types/streaming"]
+    }
+  },
+  "include": ["src/**/*", "../shared/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/backend/vitest.config.ts

@@ -0,0 +1,29 @@
+import { defineConfig } from 'vitest/config';
+import path from 'path';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+      exclude: [
+        'node_modules/**',
+        'dist/**',
+        '**/*.d.ts',
+        '**/*.config.*',
+        '**/mockData/**',
+        'scripts/**'
+      ]
+    },
+    include: ['src/**/*.{test,spec}.{js,ts}'],
+    exclude: ['node_modules', 'dist']
+  },
+  resolve: {
+    alias: {
+      '@': path.resolve(__dirname, './src')
+    }
+  }
+});
+

package/docker-compose.traefik.yml

@@ -0,0 +1,59 @@
+version: '3.8'
+
+# Traefik reverse proxy for dynamic feature branch deployments
+# This allows automatic routing to feature branch containers
+
+services:
+  traefik:
+    image: traefik:v2.11
+    container_name: agentstudio-traefik
+    command:
+      # Enable Docker provider
+      - "--providers.docker=true"
+      - "--providers.docker.exposedbydefault=false"
+      
+      # Define entrypoints
+      - "--entrypoints.web.address=:80"
+      - "--entrypoints.websecure.address=:443"
+      
+      # HTTPS redirect
+      - "--entrypoints.web.http.redirections.entryPoint.to=websecure"
+      - "--entrypoints.web.http.redirections.entryPoint.scheme=https"
+      
+      # Let's Encrypt
+      - "--certificatesresolvers.letsencrypt.acme.httpchallenge=true"
+      - "--certificatesresolvers.letsencrypt.acme.httpchallenge.entrypoint=web"
+      - "--certificatesresolvers.letsencrypt.acme.email=okguitar@gmail.com"
+      - "--certificatesresolvers.letsencrypt.acme.storage=/letsencrypt/acme.json"
+      
+      # Enable dashboard (optional)
+      - "--api.dashboard=true"
+      - "--api.insecure=true"  # Remove in production
+      
+      # Logging
+      - "--log.level=INFO"
+      - "--accesslog=true"
+    ports:
+      - "80:80"          # HTTP (will redirect to HTTPS)
+      - "443:443"        # HTTPS
+      - "8080:8080"      # Traefik dashboard
+    volumes:
+      # Mount Docker socket for auto-discovery
+      - /var/run/docker.sock:/var/run/docker.sock:ro
+      
+      # Let's Encrypt certificates storage
+      - ./data/letsencrypt:/letsencrypt
+    labels:
+      # Enable Traefik dashboard
+      - "traefik.enable=true"
+      - "traefik.http.routers.dashboard.rule=Host(`traefik.localhost`)"
+      - "traefik.http.routers.dashboard.service=api@internal"
+      - "traefik.http.routers.dashboard.entrypoints=web"
+    restart: unless-stopped
+    networks:
+      - agentstudio-network
+
+networks:
+  agentstudio-network:
+    name: agentstudio-network
+    driver: bridge

package/docker-compose.yml

@@ -0,0 +1,38 @@
+version: '3.8'
+
+services:
+  agentstudio:
+    build:
+      context: .
+      dockerfile: Dockerfile.npm
+    container_name: agentstudio-npm
+    ports:
+      - "4936:4936"    # Backend API (default port, can be changed)
+    environment:
+      - NODE_ENV=production
+      - PORT=4936
+      # Uncomment and set your API keys
+      # - ANTHROPIC_API_KEY=your_anthropic_key_here
+      # - OPENAI_API_KEY=your_openai_key_here
+      # Proxy settings (uncomment if needed)
+      # - HTTP_PROXY=http://proxy.example.com:8080
+      # - HTTPS_PROXY=http://proxy.example.com:8080
+      # - NO_PROXY=localhost,127.0.0.1,*.woa.com
+    env_file:
+      - .env  # Optional: use .env file instead (create this file if needed)
+    volumes:
+      # Mount container's home directory to host for data persistence
+      - ./data/agentstudio-home:/home/agentstudio/.agent-studio
+      # Optional: Mount config directory separately
+      # - ./config:/home/agentstudio/.agent-studio/config
+      # Optional: Mount logs directory separately
+      # - ./logs:/home/agentstudio/.agent-studio/logs
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:4936/api/health"]
+      interval: 30s
+      timeout: 3s
+      retries: 3
+      start_period: 15s
+
+# No named volumes needed - using bind mounts instead

package/docker-entrypoint.sh

@@ -0,0 +1,30 @@
+#!/bin/bash
+set -e
+
+# Start nginx in the background
+echo "Starting nginx..."
+nginx -g 'daemon off;' &
+NGINX_PID=$!
+
+# Start backend
+echo "Starting backend..."
+cd /app/backend
+pnpm run start &
+BACKEND_PID=$!
+
+# Function to handle shutdown
+shutdown() {
+    echo "Shutting down services..."
+    kill $NGINX_PID $BACKEND_PID 2>/dev/null || true
+    wait $NGINX_PID $BACKEND_PID 2>/dev/null || true
+    exit 0
+}
+
+# Trap SIGTERM and SIGINT
+trap shutdown SIGTERM SIGINT
+
+# Wait for both processes
+wait -n
+
+# If one process exits, kill the other and exit
+shutdown