agentstudio 0.2.9 → 0.3.1

package/backend/src/routes/media.ts

@@ -0,0 +1,140 @@
+import express, { Router } from 'express';
+import fs from 'fs-extra';
+import { existsSync } from 'fs';
+import { join, resolve, relative, extname, dirname } from 'path';
+import crypto from 'crypto';
+
+const router: Router = express.Router();
+
+// Helper function to get or create project ID using base64url encoding (reversible)
+export const getProjectId = (projectPath: string): string => {
+  return encodeProjectPath(projectPath);
+};
+
+// Helper function to decode project ID back to path using base64 encoding
+// We'll use a reversible encoding scheme instead of hash
+const encodeProjectPath = (projectPath: string): string => {
+  const normalizedPath = resolve(projectPath);
+  // Use base64url encoding (URL-safe)
+  return Buffer.from(normalizedPath).toString('base64')
+    .replace(/\+/g, '-')
+    .replace(/\//g, '_')
+    .replace(/=/g, '');
+};
+
+const decodeProjectPath = (encodedPath: string): string | null => {
+  try {
+    // Restore base64 padding and decode
+    const base64 = encodedPath
+      .replace(/-/g, '+')
+      .replace(/_/g, '/');
+    const padding = (4 - (base64.length % 4)) % 4;
+    const paddedBase64 = base64 + '='.repeat(padding);
+    return Buffer.from(paddedBase64, 'base64').toString('utf-8');
+  } catch (error) {
+    console.error('Failed to decode project path:', error);
+    return null;
+  }
+};
+
+// Helper function to resolve and validate file path within project
+const resolveSafeMediaPath = (projectPath: string, relativePath: string): string => {
+  const resolvedProjectPath = resolve(projectPath);
+  const resolvedFilePath = resolve(resolvedProjectPath, relativePath);
+  
+  // Ensure the path is within the project directory for security
+  const relativeToProject = relative(resolvedProjectPath, resolvedFilePath);
+  if (relativeToProject.startsWith('..') || resolve(resolvedProjectPath, relativeToProject) !== resolvedFilePath) {
+    throw new Error('Path is outside project directory');
+  }
+  
+  return resolvedFilePath;
+};
+
+// Helper function to get MIME type from file extension
+const getMimeType = (filePath: string): string => {
+  const ext = extname(filePath).toLowerCase();
+  const mimeTypes: Record<string, string> = {
+    '.html': 'text/html',
+    '.htm': 'text/html',
+    '.css': 'text/css',
+    '.js': 'text/javascript',
+    '.json': 'application/json',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.svg': 'image/svg+xml',
+    '.webp': 'image/webp',
+    '.ico': 'image/x-icon',
+    '.pdf': 'application/pdf',
+    '.txt': 'text/plain',
+    '.md': 'text/markdown',
+  };
+  
+  return mimeTypes[ext] || 'application/octet-stream';
+};
+
+// GET /media/{project-id}/{relative-path} - Serve static files from project directory (PUBLIC)
+router.get('/:projectId/*', async (req, res) => {
+  try {
+    const { projectId } = req.params;
+    const relativePath = (req.params as any)[0]; // Everything after projectId
+
+    if (!relativePath) {
+      return res.status(400).json({ error: 'File path is required' });
+    }
+
+    // Decode project path from ID (base64url encoded)
+    const projectPath = decodeProjectPath(projectId);
+    if (!projectPath) {
+      console.error('Failed to decode project ID:', projectId);
+      return res.status(404).json({ error: 'Project not found' });
+    }
+
+    console.log('Media route: Decoded projectPath:', projectPath, 'from projectId:', projectId);
+    
+    // Resolve safe file path
+    const filePath = resolveSafeMediaPath(projectPath, relativePath);
+    
+    // Check if file exists
+    if (!existsSync(filePath)) {
+      return res.status(404).json({ error: 'File not found' });
+    }
+    
+    // Check if it's a file (not directory)
+    const stats = await fs.stat(filePath);
+    if (!stats.isFile()) {
+      return res.status(400).json({ error: 'Path is not a file' });
+    }
+    
+    // Set appropriate Content-Type
+    const mimeType = getMimeType(filePath);
+    res.setHeader('Content-Type', mimeType);
+    
+    // Set cache headers for static assets
+    if (mimeType.startsWith('image/') || mimeType === 'text/css' || mimeType === 'text/javascript') {
+      res.setHeader('Cache-Control', 'public, max-age=3600'); // 1 hour cache
+    }
+    
+    // Stream the file
+    const fileStream = fs.createReadStream(filePath);
+    fileStream.pipe(res);
+    
+    fileStream.on('error', (error) => {
+      console.error('Error streaming file:', error);
+      if (!res.headersSent) {
+        res.status(500).json({ error: 'Failed to read file' });
+      }
+    });
+    
+  } catch (error) {
+    console.error('Error serving media file:', error);
+    if (error instanceof Error && error.message === 'Path is outside project directory') {
+      return res.status(403).json({ error: 'Access denied' });
+    }
+    res.status(500).json({ error: 'Failed to serve file' });
+  }
+});
+
+export default router;

package/backend/src/routes/mediaAuth.ts

@@ -0,0 +1,150 @@
+import express, { Router } from 'express';
+import crypto from 'crypto';
+import jwt from 'jsonwebtoken';
+import { verifyToken, getJwtConfig } from '../utils/jwt';
+
+const router: Router = express.Router();
+
+// Generate stateless temporary JWT token for media access
+export async function generateTempToken(projectId: string, filePath: string): Promise<string> {
+  // Create a short-lived JWT token (5 minutes) with media access payload
+  const payload = {
+    type: 'media-access',
+    projectId,
+    filePath,
+    purpose: 'iframe-media',
+    iat: Math.floor(Date.now() / 1000),
+    exp: Math.floor(Date.now() / 1000) + (5 * 60), // 5 minutes expiration
+    jti: crypto.randomBytes(16).toString('hex') // Unique ID for one-time use
+  };
+  
+  const jwtConfig = await getJwtConfig();
+  return jwt.sign(payload, jwtConfig.secret);
+}
+
+// Generate project-wide temporary JWT token for media access
+export async function generateProjectToken(projectId: string, projectPath: string): Promise<string> {
+  // Create a short-lived JWT token (5 minutes) with project-wide access
+  const payload = {
+    type: 'project-media-access',
+    projectId,
+    projectPath,
+    purpose: 'iframe-project-media',
+    iat: Math.floor(Date.now() / 1000),
+    exp: Math.floor(Date.now() / 1000) + (5 * 60), // 5 minutes expiration
+    jti: crypto.randomBytes(16).toString('hex') // Unique ID for project
+  };
+  
+  const jwtConfig = await getJwtConfig();
+  return jwt.sign(payload, jwtConfig.secret);
+}
+
+// Verify stateless temporary JWT token
+export async function verifyTempToken(tokenString: string, projectId: string, filePath: string): Promise<boolean> {
+  try {
+    const payload = await verifyToken(tokenString);
+    
+    // Check if this is a media access token - cast to any to access custom properties
+    if (!payload || typeof payload !== 'object' || (payload as any).type !== 'media-access') {
+      return false;
+    }
+    
+    // Check if projectId and filePath match
+    if ((payload as any).projectId !== projectId || (payload as any).filePath !== filePath) {
+      return false;
+    }
+    
+    // Check token purpose
+    if ((payload as any).purpose !== 'iframe-media') {
+      return false;
+    }
+    
+    // All checks passed - token is valid
+    return true;
+    
+  } catch (error) {
+    // Token verification failed (invalid, expired, etc.)
+    return false;
+  }
+}
+
+// Verify project-wide temporary JWT token
+export async function verifyProjectToken(tokenString: string, projectId: string): Promise<boolean> {
+  try {
+    const payload = await verifyToken(tokenString);
+    
+    // Check if this is a project media access token
+    if (!payload || typeof payload !== 'object' || (payload as any).type !== 'project-media-access') {
+      return false;
+    }
+    
+    // Check if projectId matches
+    if ((payload as any).projectId !== projectId) {
+      return false;
+    }
+    
+    // Check token purpose
+    if ((payload as any).purpose !== 'iframe-project-media') {
+      return false;
+    }
+    
+    // All checks passed - token is valid
+    return true;
+    
+  } catch (error) {
+    // Token verification failed (invalid, expired, etc.)
+    return false;
+  }
+}
+
+// POST /api/media/temp-token - Generate temporary token for media access
+router.post('/temp-token', async (req, res) => {
+  try {
+    const { projectId, filePath } = req.body;
+    
+    if (!projectId || !filePath) {
+      return res.status(400).json({ error: 'ProjectId and filePath are required' });
+    }
+    
+    // This route is protected by authMiddleware, so we're already authenticated
+    // Generate temporary token
+    const tempToken = await generateTempToken(projectId, filePath);
+    
+    res.json({
+      success: true,
+      tempToken,
+      expires: Date.now() + 5 * 60 * 1000, // 5 minutes
+    });
+    
+  } catch (error) {
+    console.error('Error generating temp token:', error);
+    res.status(500).json({ error: 'Failed to generate temporary token' });
+  }
+});
+
+// POST /api/media/project-token - Generate project-wide temporary token for media access
+router.post('/project-token', async (req, res) => {
+  try {
+    const { projectId, projectPath } = req.body;
+    
+    if (!projectId || !projectPath) {
+      return res.status(400).json({ error: 'ProjectId and projectPath are required' });
+    }
+    
+    // This route is protected by authMiddleware, so we're already authenticated
+    // Generate project-wide temporary token
+    const projectToken = await generateProjectToken(projectId, projectPath);
+    
+    res.json({
+      success: true,
+      projectToken,
+      expires: Date.now() + 5 * 60 * 1000, // 5 minutes
+    });
+    
+  } catch (error) {
+    console.error('Error generating project token:', error);
+    res.status(500).json({ error: 'Failed to generate project token' });
+  }
+});
+
+export default router;

package/backend/src/routes/network.ts

@@ -0,0 +1,68 @@
+/**
+ * Network Routes
+ * 
+ * API endpoints for network information (local IP, tunnel status, etc.)
+ */
+
+import { Router, Request, Response } from 'express';
+import type { Router as RouterType } from 'express';
+import { getNetworkInfo } from '../utils/networkUtils.js';
+import { tunnelService } from '../services/tunnelService.js';
+
+const router: RouterType = Router();
+
+/**
+ * GET /api/network-info
+ * Get network information including tunnel status and local IPs
+ */
+router.get('/', async (_req: Request, res: Response): Promise<any> => {
+  try {
+    // Get tunnel status and config
+    const tunnelStatus = tunnelService.getStatus();
+    const tunnelConfig = tunnelService.getConfig();
+    
+    // Get local network info
+    const networkInfo = getNetworkInfo();
+    
+    // Get backend port from environment
+    const port = process.env.PORT || '4936';
+    
+    // Build full tunnel URL if connected
+    let tunnelUrl: string | null = null;
+    let fullDomain: string | null = tunnelStatus.domain;
+    
+    if (tunnelStatus.connected && tunnelStatus.domain) {
+      const protocol = tunnelConfig.protocol || 'https';
+      
+      // Build full domain with suffix if configured
+      if (tunnelConfig.domainSuffix) {
+        fullDomain = `${tunnelStatus.domain}${tunnelConfig.domainSuffix}`;
+      }
+      
+      tunnelUrl = `${protocol}://${fullDomain}`;
+    }
+    
+    res.json({
+      tunnel: {
+        enabled: tunnelStatus.enabled,
+        connected: tunnelStatus.connected,
+        domain: fullDomain,
+        url: tunnelUrl,
+      },
+      network: {
+        hostname: networkInfo.hostname,
+        localIPs: networkInfo.localIPs,
+        bestLocalIP: networkInfo.bestLocalIP,
+        port: parseInt(port),
+      },
+    });
+  } catch (error) {
+    console.error('[Network API] Error getting network info:', error);
+    res.status(500).json({
+      error: 'Failed to get network info',
+      details: error instanceof Error ? error.message : String(error),
+    });
+  }
+});
+
+export default router;