agentstudio 0.2.9 → 0.3.1

package/backend/src/config/paths.ts

@@ -0,0 +1,105 @@
+/**
+ * Global Path Constants
+ *
+ * Centralized path definitions for the application.
+ * All paths that reference ~/.claude-agent should use these constants.
+ */
+
+import { homedir } from 'os';
+import { join } from 'path';
+
+/**
+ * Base directory for Claude Agent configuration and data
+ * Default: ~/.claude-agent
+ */
+export const CLAUDE_AGENT_DIR = join(homedir(), '.claude-agent');
+
+/**
+ * Directory for agent configuration files
+ * Default: ~/.claude-agent/agents
+ */
+export const AGENTS_DIR = join(CLAUDE_AGENT_DIR, 'agents');
+
+/**
+ * File path for Claude versions configuration
+ * Default: ~/.claude-agent/claude-versions.json
+ */
+export const CLAUDE_VERSIONS_FILE = join(CLAUDE_AGENT_DIR, 'claude-versions.json');
+
+/**
+ * File path for projects metadata
+ * Default: ~/.claude-agent/projects.json
+ */
+export const PROJECTS_METADATA_FILE = join(CLAUDE_AGENT_DIR, 'projects.json');
+
+/**
+ * File path for MCP server configuration
+ * Default: ~/.claude-agent/mcp-server.json
+ */
+export const MCP_SERVER_CONFIG_FILE = join(CLAUDE_AGENT_DIR, 'mcp-server.json');
+
+/**
+ * File path for A2A agent mappings (global registry)
+ * Default: ~/.claude-agent/a2a-agent-mappings.json
+ */
+export const A2A_AGENT_MAPPINGS_FILE = join(CLAUDE_AGENT_DIR, 'a2a-agent-mappings.json');
+
+/**
+ * Directory for Slack session locks
+ * Default: ~/.claude-agent/slack-session-locks
+ */
+export const SLACK_SESSION_LOCKS_DIR = join(CLAUDE_AGENT_DIR, 'slack-session-locks');
+
+/**
+ * Get the .a2a directory path for a project
+ * @param projectPath - Absolute path to the project working directory
+ * @returns Path to the project's .a2a directory
+ */
+export function getProjectA2ADir(projectPath: string): string {
+  return join(projectPath, '.a2a');
+}
+
+/**
+ * Get the tasks directory path for a project
+ * @param projectPath - Absolute path to the project working directory
+ * @returns Path to the project's tasks directory
+ */
+export function getProjectTasksDir(projectPath: string): string {
+  return join(projectPath, '.a2a', 'tasks');
+}
+
+/**
+ * Get the A2A config file path for a project
+ * @param projectPath - Absolute path to the project working directory
+ * @returns Path to the project's A2A config file
+ */
+export function getProjectA2AConfigFile(projectPath: string): string {
+  return join(projectPath, '.a2a', 'config.json');
+}
+
+/**
+ * Get the API keys file path for a project
+ * @param projectPath - Absolute path to the project working directory
+ * @returns Path to the project's API keys file
+ */
+export function getProjectApiKeysFile(projectPath: string): string {
+  return join(projectPath, '.a2a', 'api-keys.json');
+}
+
+/**
+ * Directory for scheduled tasks configuration
+ * Default: ~/.claude-agent/scheduled-tasks
+ */
+export const SCHEDULED_TASKS_DIR = join(CLAUDE_AGENT_DIR, 'scheduled-tasks');
+
+/**
+ * File path for scheduled tasks list
+ * Default: ~/.claude-agent/scheduled-tasks/tasks.json
+ */
+export const SCHEDULED_TASKS_FILE = join(SCHEDULED_TASKS_DIR, 'tasks.json');
+
+/**
+ * Directory for scheduled task execution history
+ * Default: ~/.claude-agent/scheduled-tasks/history
+ */
+export const SCHEDULED_TASKS_HISTORY_DIR = join(SCHEDULED_TASKS_DIR, 'history');

package/backend/src/config/sdkConfig.ts

@@ -0,0 +1,126 @@
+import * as path from 'path';
+import * as os from 'os';
+
+/**
+ * SDK Engine Configuration
+ * 
+ * AgentStudio can work with different Agent SDK implementations:
+ * - claude-code: Claude Code (default, uses ~/.claude)
+ * - claude-internal: Claude Internal (uses ~/.claude-internal)
+ * - code-buddy: Code Buddy (uses ~/.codebuddy)
+ * 
+ * The SDK engine is specified at service startup via:
+ * - Environment variable: AGENT_SDK=claude-internal
+ * - Command line argument: --sdk=claude-internal
+ * - Default: claude-code
+ */
+
+// Get SDK engine from environment or default to claude-code
+export const SDK_ENGINE = process.env.AGENT_SDK || 'claude-code';
+
+// Valid SDK engine types
+export type SdkEngine = 'claude-code' | 'claude-internal' | 'code-buddy';
+
+// Validate SDK engine (currently only claude-code and claude-internal are supported)
+const VALID_ENGINES: SdkEngine[] = ['claude-code', 'claude-internal'];
+if (!VALID_ENGINES.includes(SDK_ENGINE as SdkEngine)) {
+  console.warn(`⚠️  Invalid AGENT_SDK="${SDK_ENGINE}", falling back to "claude-code"`);
+  console.warn(`⚠️  Supported engines: ${VALID_ENGINES.join(', ')}`);
+  process.env.AGENT_SDK = 'claude-code';
+}
+
+// SDK directory name mapping
+const SDK_DIR_MAP: Record<SdkEngine, string> = {
+  'claude-code': '.claude',
+  'claude-internal': '.claude-internal',
+  'code-buddy': '.codebuddy' // Not yet supported
+};
+
+/**
+ * Get the base SDK directory name (e.g., '.claude', '.claude-internal')
+ */
+export function getSdkDirName(): string {
+  return SDK_DIR_MAP[SDK_ENGINE as SdkEngine];
+}
+
+/**
+ * Get the full path to the SDK directory (e.g., ~/.claude, ~/.claude-internal)
+ */
+export function getSdkDir(): string {
+  return path.join(os.homedir(), getSdkDirName());
+}
+
+/**
+ * Get the projects directory path (e.g., ~/.claude/projects)
+ */
+export function getProjectsDir(): string {
+  return path.join(getSdkDir(), 'projects');
+}
+
+/**
+ * Get the SDK config file path
+ * - claude-code: ~/.claude.json (in home directory)
+ * - claude-internal: ~/.claude-internal/.claude.json (inside SDK directory)
+ */
+export function getSdkConfigPath(): string {
+  if (SDK_ENGINE === 'claude-code') {
+    // Claude Code stores config at ~/.claude.json
+    return path.join(os.homedir(), '.claude.json');
+  } else {
+    // Claude Internal stores config inside its directory: ~/.claude-internal/.claude.json
+    return path.join(getSdkDir(), '.claude.json');
+  }
+}
+
+/**
+ * Get the plugins directory (e.g., ~/.claude/plugins)
+ */
+export function getPluginsDir(): string {
+  return path.join(getSdkDir(), 'plugins');
+}
+
+/**
+ * Get the commands directory (e.g., ~/.claude/commands)
+ */
+export function getCommandsDir(): string {
+  return path.join(getSdkDir(), 'commands');
+}
+
+/**
+ * Get the agents directory (e.g., ~/.claude/agents)
+ */
+export function getAgentsDir(): string {
+  return path.join(getSdkDir(), 'agents');
+}
+
+/**
+ * Get the skills directory (e.g., ~/.claude/skills)
+ */
+export function getSkillsDir(): string {
+  return path.join(getSdkDir(), 'skills');
+}
+
+/**
+ * Get the hooks directory (e.g., ~/.claude/hooks)
+ */
+export function getHooksDir(): string {
+  return path.join(getSdkDir(), 'hooks');
+}
+
+/**
+ * Get the MCP directory (e.g., ~/.claude/mcp)
+ */
+export function getMcpDir(): string {
+  return path.join(getSdkDir(), 'mcp');
+}
+
+/**
+ * Log SDK configuration at startup
+ */
+export function logSdkConfig(): void {
+  console.log('🔧 Agent SDK Configuration:');
+  console.log(`   Engine: ${SDK_ENGINE}`);
+  console.log(`   Directory: ${getSdkDir()}`);
+  console.log(`   Projects: ${getProjectsDir()}`);
+  console.log(`   Config: ${getSdkConfigPath()}`);
+}

package/backend/src/index.ts

@@ -0,0 +1,434 @@
+import express from 'express';
+import cors from 'cors';
+import helmet from 'helmet';
+import dotenv from 'dotenv';
+import { join } from 'path';
+import { readFileSync } from 'fs';
+
+import filesRouter from './routes/files';
+import agentsRouter from './routes/agents';
+import mcpRouter from './routes/mcp';
+import sessionsRouter from './routes/sessions';
+import mediaRouter from './routes/media';
+import mediaAuthRouter from './routes/mediaAuth';
+import settingsRouter from './routes/settings';
+import commandsRouter from './routes/commands';
+import subagentsRouter from './routes/subagents';
+import projectsRouter from './routes/projects';
+import authRouter from './routes/auth';
+import configRouter from './routes/config';
+import slackRouter from './routes/slack';
+import skillsRouter from './routes/skills';
+import pluginsRouter from './routes/plugins';
+import a2aRouter from './routes/a2a';
+import a2aManagementRouter from './routes/a2aManagement';
+import scheduledTasksRouter from './routes/scheduledTasks';
+import mcpAdminRouter from './routes/mcpAdmin';
+import mcpAdminManagementRouter from './routes/mcpAdminManagement';
+import cloudflareTunnelRouter from './routes/cloudflareTunnel';
+import taskExecutorRouter from './routes/taskExecutor';
+import versionRouter from './routes/version';
+import tunnelRouter from './routes/tunnel';
+import networkRouter from './routes/network';
+import { authMiddleware } from './middleware/auth';
+import { httpsOnly } from './middleware/httpsOnly';
+import { loadConfig, getSlidesDir } from './config/index';
+import { cleanupOrphanedTasks } from './services/a2a/taskCleanup';
+import { initializeScheduler, shutdownScheduler } from './services/schedulerService';
+import { shutdownTelemetry } from './services/telemetry';
+import { initializeTaskExecutor, shutdownTaskExecutor } from './services/taskExecutor/index.js';
+import { tunnelService } from './services/tunnelService.js';
+import { logSdkConfig } from './config/sdkConfig.js';
+
+dotenv.config();
+
+// Log SDK configuration at startup
+logSdkConfig();
+
+// Get version from package.json (works in both dev and npm package mode)
+const getVersion = () => {
+  // Try npm package mode first (package.json in same directory as dist)
+  const npmPackagePath = join(__dirname, 'package.json');
+  // Then try development mode (backend/package.json)
+  const devPackagePath = join(__dirname, '../package.json');
+  // Also try root package.json
+  const rootPackagePath = join(__dirname, '../../package.json');
+
+  for (const packagePath of [npmPackagePath, devPackagePath, rootPackagePath]) {
+    try {
+      const packageJson = JSON.parse(readFileSync(packagePath, 'utf8'));
+      if (packageJson.version) {
+        return packageJson.version;
+      }
+    } catch {
+      // Continue to next path
+    }
+  }
+
+  console.warn('Could not read version from package.json');
+  return 'unknown';
+};
+
+const VERSION = getVersion();
+
+const app: express.Express = express();
+
+// Async initialization
+(async () => {
+  // Load configuration (including port and host)
+  const config = await loadConfig();
+  const PORT = config.port || 4936;
+  const HOST = config.host || '0.0.0.0';
+
+  // Initialize system Claude version if needed
+  try {
+    const { initializeSystemVersion } = await import('./services/claudeVersionStorage.js');
+    const { exec } = await import('child_process');
+    const { promisify } = await import('util');
+    const execAsync = promisify(exec);
+
+    // Try to find Claude executable, but initialize anyway
+    let claudePath: string | null = null;
+    try {
+      const { stdout } = await execAsync('which claude');
+      if (stdout && stdout.trim()) {
+        claudePath = stdout.trim();
+        console.log(`[System] Found Claude CLI at: ${claudePath}`);
+      }
+    } catch (error) {
+      console.log('[System] Claude CLI not found in PATH, initializing without executable path');
+    }
+
+    // Initialize system version (with or without executable path)
+    await initializeSystemVersion(claudePath || '');
+    console.log(`[System] Initialized Claude version${claudePath ? ` from: ${claudePath}` : ' without executable path'}`);
+  } catch (error) {
+    console.warn('Failed to initialize system Claude version:', error);
+  }
+
+  // Middleware
+  app.use(helmet({
+    contentSecurityPolicy: {
+      directives: {
+        defaultSrc: ["'self'"],
+        scriptSrc: ["'self'", "'unsafe-inline'", "'unsafe-eval'", "https://cdn.jsdelivr.net", "https://app.posthog.com", "https://us.i.posthog.com", "https://us-assets.i.posthog.com"], // Allow eval for development, CDN for Monaco, PostHog
+        styleSrc: ["'self'", "'unsafe-inline'", "https://fonts.googleapis.com", "https://cdn.jsdelivr.net"],
+        fontSrc: ["'self'", "https://fonts.gstatic.com", "https://cdn.jsdelivr.net", "data:"],
+        imgSrc: ["'self'", "data:", "https:", "http:", "blob:"],
+        connectSrc: ["'self'", "ws:", "wss:", "blob:", "data:", "http://localhost:*", "http://127.0.0.1:*", "https://localhost:*", "https://127.0.0.1:*", "https://app.posthog.com", "https://us.i.posthog.com", "https://us-assets.i.posthog.com"],
+        frameAncestors: ["'self'", "http://localhost:3000", "https://localhost:3000", "http://localhost:3001", "https://agentstudio.cc", "https://*.agentstudio.cc"], // Allow iframe embedding
+        workerSrc: ["'self'", "blob:", "https://cdn.jsdelivr.net"],
+        childSrc: ["'self'", "blob:"],
+        // Disable upgrade-insecure-requests for HTTP environments
+        upgradeInsecureRequests: null
+      }
+    },
+    // Disable problematic headers for non-HTTPS access
+    crossOriginOpenerPolicy: false,
+    originAgentCluster: false,
+    // Disable HSTS for HTTP environments (prevents forcing HTTPS)
+    strictTransportSecurity: false
+  }));
+
+  // Configure CORS origins
+  const getAllowedOrigins = () => {
+    const defaultOrigins = [
+      'http://localhost:3000',
+      'http://127.0.0.1:3000',
+      'http://localhost:3001',
+      'https://localhost:3000',
+      'https://localhost:3001'
+    ];
+
+    // Add custom origins from configuration
+    const customOrigins = config.corsOrigins ?
+      config.corsOrigins.split(',').map(origin => origin.trim()) : [];
+
+    return [...defaultOrigins, ...customOrigins];
+  };
+
+  app.use(cors({
+    origin: (origin, callback) => {
+      const allowedOrigins = getAllowedOrigins();
+
+      // Allow requests with no origin (like mobile apps or curl requests)
+      if (!origin) return callback(null, true);
+
+      // Check if the origin is allowed
+      if (allowedOrigins.includes(origin)) {
+        return callback(null, true);
+      }
+
+      // Allow Vercel preview URLs (*.vercel.app)
+      if (origin.endsWith('.vercel.app')) {
+        return callback(null, true);
+      }
+
+      // Allow agentstudio.cc and its subdomains (*.agentstudio.cc) - hardcoded
+      if (origin === 'https://agentstudio.cc' || origin === 'http://agentstudio.cc' ||
+        origin.endsWith('.agentstudio.cc')) {
+        return callback(null, true);
+      }
+
+      // Allow custom domains from configuration (CORS_ALLOWED_DOMAINS)
+      const customDomains = config.corsAllowedDomains ?
+        config.corsAllowedDomains.split(',').map(domain => domain.trim()) : [];
+
+      for (const domain of customDomains) {
+        // Match exact domain (https://example.com)
+        if (origin === `https://${domain}` || origin === `http://${domain}`) {
+          return callback(null, true);
+        }
+        // Match subdomains (https://*.example.com)
+        if (origin.endsWith(`.${domain}`)) {
+          return callback(null, true);
+        }
+      }
+
+      // Allow any localhost with any port for development
+      if (origin.match(/^https?:\/\/localhost(:\d+)?$/)) {
+        return callback(null, true);
+      }
+
+      // Allow 127.0.0.1 with any port for development
+      if (origin.match(/^https?:\/\/127\.0\.0\.1(:\d+)?$/)) {
+        return callback(null, true);
+      }
+
+      const msg = `The CORS policy for this site does not allow access from the specified Origin: ${origin}`;
+      return callback(new Error(msg), false);
+    },
+    credentials: true,
+    methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS', 'PATCH'],
+    allowedHeaders: ['Content-Type', 'Authorization', 'Cache-Control', 'X-Requested-With', 'X-Project-Path'],
+    exposedHeaders: ['Content-Range', 'X-Content-Range']
+  }));
+
+  // JSON parser - skip /api/slack (needs raw body for signature verification)
+  app.use((req, res, next) => {
+    if (req.path.startsWith('/api/slack')) {
+      return next();
+    }
+    express.json({ limit: '10mb' })(req, res, next);
+  });
+  app.use(express.urlencoded({ extended: true, limit: '10mb' }));
+
+  // Static files - serve slides directory
+  const slidesDir = await getSlidesDir();
+  app.use('/slides', express.static(slidesDir));
+
+  // ============================================================================
+  // Initialize Background Services
+  // ============================================================================
+
+  // 1. Initialize Task Executor (handles both A2A async tasks and scheduled tasks)
+  console.info('[TaskExecutor] Initializing unified task executor...');
+  try {
+    await initializeTaskExecutor();
+    console.info('[TaskExecutor] Task executor initialized successfully');
+  } catch (error) {
+    console.error('[TaskExecutor] Failed to initialize task executor:', error);
+    console.error('[TaskExecutor] Tasks will not be executed. Please check configuration.');
+  }
+
+  // 2. A2A Task Lifecycle: Clean up orphaned tasks on startup
+  console.info('[A2A] Running orphaned task cleanup...');
+  try {
+    const cleanedCount = await cleanupOrphanedTasks();
+    if (cleanedCount > 0) {
+      console.info(`[A2A] Cleaned up ${cleanedCount} orphaned tasks`);
+    } else {
+      console.info('[A2A] No orphaned tasks found');
+    }
+  } catch (error) {
+    console.error('[A2A] Error during orphaned task cleanup:', error);
+  }
+
+  // Note: Task timeout monitor is no longer needed - handled by executor internally
+
+  // 3. Scheduled Tasks: Initialize scheduler (always initialize, but enable state depends on env var)
+  const enableSchedulerInitially = process.env.ENABLE_SCHEDULER !== 'false'; // Default to true
+  console.info('[Scheduler] Initializing scheduled tasks... (ENABLE_SCHEDULER=' + process.env.ENABLE_SCHEDULER + ', initial enabled=' + enableSchedulerInitially + ')');
+  try {
+    initializeScheduler({ enabled: enableSchedulerInitially });
+  } catch (error) {
+    console.error('[Scheduler] Error initializing scheduler:', error);
+  }
+
+  // 4. Tunnel Service: Initialize WebSocket tunnel for external access
+  console.info('[Tunnel] Initializing tunnel service...');
+  try {
+    await tunnelService.initialize(PORT);
+    console.info('[Tunnel] Tunnel service initialized');
+  } catch (error) {
+    console.error('[Tunnel] Error initializing tunnel service:', error);
+  }
+
+  // Static files - serve embedded frontend (for npm package) or development frontend
+  // Check both npm package location (./public) and development location (../../frontend/dist)
+  const fs = await import('fs');
+  const npmPublicPath = join(__dirname, 'public');
+  const devFrontendPath = join(__dirname, '../../frontend/dist');
+
+  // Prefer npm package embedded frontend, fallback to development path
+  const frontendDistPath = fs.existsSync(npmPublicPath) ? npmPublicPath : devFrontendPath;
+  const hasEmbeddedFrontend = fs.existsSync(join(frontendDistPath, 'index.html'));
+
+  if (hasEmbeddedFrontend && process.env.API_ONLY !== 'true') {
+    app.use(express.static(frontendDistPath));
+
+    // For SPA routing - serve index.html for any non-API routes
+    app.get('*', (req, res, next) => {
+      // Skip API routes and other specific routes
+      if (req.path.startsWith('/api') ||
+        req.path.startsWith('/media') ||
+        req.path.startsWith('/slides') ||
+        req.path.startsWith('/a2a')) {
+        return next();
+      }
+
+      // Serve index.html for all other routes
+      res.sendFile(join(frontendDistPath, 'index.html'));
+    });
+
+    console.log(`Frontend static files enabled from: ${frontendDistPath}`);
+  } else if (process.env.API_ONLY === 'true') {
+    console.log('API only mode - frontend serving disabled');
+  } else {
+    console.log('Frontend build not found, serving API only');
+  }
+
+  // Routes - Public routes
+  app.use('/api/auth', authRouter);
+  // MCP Admin - uses its own API key authentication
+  app.use('/api/mcp-admin', mcpAdminRouter);
+  // Slack webhook - needs raw body for signature verification
+  app.use('/api/slack',
+    express.json({
+      limit: '10mb',
+      verify: (req: any, res, buf) => {
+        req.rawBody = buf.toString('utf8');
+      }
+    }),
+    slackRouter
+  );
+
+  // A2A Protocol routes - Public but require API key authentication and HTTPS in production
+  app.use('/a2a/:a2aAgentId', httpsOnly, a2aRouter);
+
+  // Health check
+  app.get('/api/health', (req, res) => {
+    res.json({
+      status: 'ok',
+      timestamp: new Date().toISOString(),
+      version: VERSION,
+      name: 'agentstudio-backend'
+    });
+  });
+
+  // A2A Health check (public endpoint, no authentication required)
+  app.get('/api/a2a/health', (req, res) => {
+    res.json({
+      status: 'ok',
+      version: '1.0.0',
+      protocol: 'A2A',
+      timestamp: new Date().toISOString(),
+      features: {
+        agentCard: true,
+        syncMessages: true,
+        asyncTasks: true,
+        taskManagement: true,
+        apiKeyAuth: true,
+      },
+    });
+  });
+
+  // Protected routes - Require authentication
+  app.use('/api/files', authMiddleware, filesRouter);
+  app.use('/api/agents', authMiddleware, agentsRouter);
+  app.use('/api/mcp', authMiddleware, mcpRouter);
+  app.use('/api/sessions', authMiddleware, sessionsRouter);
+  app.use('/api/settings', authMiddleware, settingsRouter);
+  app.use('/api/config', authMiddleware, configRouter);
+  app.use('/api/commands', authMiddleware, commandsRouter);
+  app.use('/api/subagents', authMiddleware, subagentsRouter);
+  app.use('/api/projects', authMiddleware, projectsRouter);
+  app.use('/api/a2a', authMiddleware, a2aManagementRouter); // A2A management routes with user auth
+  app.use('/api/skills', authMiddleware, skillsRouter);
+  app.use('/api/plugins', authMiddleware, pluginsRouter);
+  app.use('/api/scheduled-tasks', authMiddleware, scheduledTasksRouter);
+  app.use('/api/mcp-admin-management', authMiddleware, mcpAdminManagementRouter); // MCP Admin management with JWT auth
+  app.use('/api/cloudflare-tunnel', authMiddleware, cloudflareTunnelRouter); // Cloudflare Tunnel management
+  app.use('/api/task-executor', authMiddleware, taskExecutorRouter);
+  app.use('/api/version', authMiddleware, versionRouter);
+  app.use('/api/tunnel', authMiddleware, tunnelRouter); // Tunnel management
+  app.use('/api/network-info', authMiddleware, networkRouter); // Network information
+  app.use('/api/media', mediaAuthRouter); // Media auth endpoints
+  app.use('/media', mediaRouter); // Remove authMiddleware - media files are now public
+
+  // Error handling
+  app.use((err: any, req: express.Request, res: express.Response, next: express.NextFunction) => {
+    console.error('Error:', err);
+    res.status(500).json({
+      error: 'Internal server error',
+      message: process.env.NODE_ENV === 'development' ? err.message : 'Something went wrong'
+    });
+  });
+
+  // 404 handler
+  app.use('*', (req, res) => {
+    res.status(404).json({ error: 'Route not found' });
+  });
+
+  // Graceful shutdown handler
+  const gracefulShutdown = async () => {
+    console.info('[System] Shutting down gracefully...');
+
+    // 1. Stop scheduler (no new tasks will be scheduled)
+    try {
+      shutdownScheduler();
+      console.info('[Scheduler] Scheduler stopped');
+    } catch (error) {
+      console.error('[Scheduler] Error shutting down scheduler:', error);
+    }
+
+    // 2. Stop task executor (wait for running tasks to complete or timeout)
+    try {
+      await shutdownTaskExecutor();
+      console.info('[TaskExecutor] Task executor stopped');
+    } catch (error) {
+      console.error('[TaskExecutor] Error shutting down task executor:', error);
+    }
+
+    // 3. Stop tunnel service
+    try {
+      tunnelService.disconnect();
+      console.info('[Tunnel] Tunnel service stopped');
+    } catch (error) {
+      console.error('[Tunnel] Error shutting down tunnel service:', error);
+    }
+
+    // Shutdown telemetry (async but we don't wait)
+    shutdownTelemetry().catch((error) => {
+      console.error('[Telemetry] Error shutting down telemetry:', error);
+    });
+
+    console.info('[System] Shutdown complete');
+    // Exit process
+    process.exit(0);
+  };
+
+  // Register shutdown handlers
+  process.on('SIGTERM', gracefulShutdown);
+  process.on('SIGINT', gracefulShutdown);
+
+  // Check if this file is being run directly (CommonJS way)
+  if (require.main === module) {
+    app.listen(PORT, HOST, () => {
+      console.log(`AI PPT Editor backend running on http://${HOST === '0.0.0.0' ? 'localhost' : HOST}:${PORT}`);
+      console.log(`Serving slides from: ${slidesDir}`);
+    });
+  }
+})();
+
+export default app;