upfynai-code 3.0.3 → 3.1.0

package/server/constants/config.js

@@ -1,31 +0,0 @@
-/**
- * Environment Flag: Is Platform (Self-Hosted / Local Mode)
- *
- * When true, the app runs in single-user local mode:
- * - Skips JWT authentication (uses first DB user)
- * - Claude Code SDK runs directly on the machine
- * - No relay connection needed
- *
- * Auto-detected when:
- * - VITE_IS_PLATFORM=true is set, OR
- * - Running locally (not on Railway/Vercel/cloud)
- */
-const isCloudEnv = !!(
-    process.env.RAILWAY_ENVIRONMENT ||
-    process.env.VERCEL ||
-    process.env.RENDER ||
-    process.env.FLY_APP_NAME ||
-    process.env.HEROKU_APP_NAME
-);
-
-export const IS_PLATFORM = process.env.VITE_IS_PLATFORM === 'true' || (!isCloudEnv && !process.env.FORCE_HOSTED_MODE);
-
-/**
- * True when running on a cloud provider (Railway, Vercel, etc.)
- */
-export const IS_CLOUD = isCloudEnv;
-
-/**
- * True when running locally (self-hosted mode)
- */
-export const IS_LOCAL = IS_PLATFORM && !isCloudEnv;

package/server/cursor-cli.js

@@ -1,270 +0,0 @@
-import { spawn } from 'child_process';
-import crossSpawn from 'cross-spawn';
-import { promises as fs } from 'fs';
-import path from 'path';
-import os from 'os';
-
-// Use cross-spawn on Windows for better command execution
-const spawnFunction = process.platform === 'win32' ? crossSpawn : spawn;
-
-let activeCursorProcesses = new Map(); // Track active processes by session ID
-
-async function spawnCursor(command, options = {}, ws) {
-  return new Promise(async (resolve, reject) => {
-    const { sessionId, projectPath, cwd, resume, toolsSettings, skipPermissions, model, images } = options;
-    let capturedSessionId = sessionId; // Track session ID throughout the process
-    let sessionCreatedSent = false; // Track if we've already sent session-created event
-    let messageBuffer = ''; // Buffer for accumulating assistant messages
-    
-    // Use tools settings passed from frontend, or defaults
-    const settings = toolsSettings || {
-      allowedShellCommands: [],
-      skipPermissions: false
-    };
-    
-    // Build Cursor CLI command
-    const args = [];
-    
-    // Build flags allowing both resume and prompt together (reply in existing session)
-    // Treat presence of sessionId as intention to resume, regardless of resume flag
-    if (sessionId) {
-      args.push('--resume=' + sessionId);
-    }
-
-    if (command && command.trim()) {
-      // Provide a prompt (works for both new and resumed sessions)
-      args.push('-p', command);
-
-      // Add model flag if specified (only meaningful for new sessions; harmless on resume)
-      if (!sessionId && model) {
-        args.push('--model', model);
-      }
-
-      // Request streaming JSON when we are providing a prompt
-      args.push('--output-format', 'stream-json');
-    }
-    
-    // Add skip permissions flag if enabled
-    if (skipPermissions || settings.skipPermissions) {
-      args.push('-f');
-    }
-
-    // Use cwd (actual project directory) instead of projectPath
-    const workingDir = cwd || projectPath || process.cwd();
-    
-    const cursorProcess = spawnFunction('cursor-agent', args, {
-      cwd: workingDir,
-      stdio: ['pipe', 'pipe', 'pipe'],
-      env: { ...process.env } // Inherit all environment variables
-    });
-    
-    // Store process reference for potential abort
-    const processKey = capturedSessionId || Date.now().toString();
-    activeCursorProcesses.set(processKey, cursorProcess);
-    
-    // Handle stdout (streaming JSON responses)
-    cursorProcess.stdout.on('data', (data) => {
-      const rawOutput = data.toString();
-      // stdout received
-      
-      const lines = rawOutput.split('\n').filter(line => line.trim());
-      
-      for (const line of lines) {
-        try {
-          const response = JSON.parse(line);
-          // parsed response
-          
-          // Handle different message types
-          switch (response.type) {
-            case 'system':
-              if (response.subtype === 'init') {
-                // Capture session ID
-                if (response.session_id && !capturedSessionId) {
-                  capturedSessionId = response.session_id;
-                  // session ID captured
-                  
-                  // Update process key with captured session ID
-                  if (processKey !== capturedSessionId) {
-                    activeCursorProcesses.delete(processKey);
-                    activeCursorProcesses.set(capturedSessionId, cursorProcess);
-                  }
-                  
-                  // Set session ID on writer (for API endpoint compatibility)
-                  if (ws.setSessionId && typeof ws.setSessionId === 'function') {
-                    ws.setSessionId(capturedSessionId);
-                  }
-
-                  // Send session-created event only once for new sessions
-                  if (!sessionId && !sessionCreatedSent) {
-                    sessionCreatedSent = true;
-                    ws.send({
-                      type: 'session-created',
-                      sessionId: capturedSessionId,
-                      model: response.model,
-                      cwd: response.cwd
-                    });
-                  }
-                }
-                
-                // Send system info to frontend
-                ws.send({
-                  type: 'cursor-system',
-                  data: response,
-                  sessionId: capturedSessionId || sessionId || null
-                });
-              }
-              break;
-              
-            case 'user':
-              // Forward user message
-              ws.send({
-                type: 'cursor-user',
-                data: response,
-                sessionId: capturedSessionId || sessionId || null
-              });
-              break;
-              
-            case 'assistant':
-              // Accumulate assistant message chunks
-              if (response.message && response.message.content && response.message.content.length > 0) {
-                const textContent = response.message.content[0].text;
-                messageBuffer += textContent;
-                
-                // Send as Claude-compatible format for frontend
-                ws.send({
-                  type: 'claude-response',
-                  data: {
-                    type: 'content_block_delta',
-                    delta: {
-                      type: 'text_delta',
-                      text: textContent
-                    }
-                  },
-                  sessionId: capturedSessionId || sessionId || null
-                });
-              }
-              break;
-              
-            case 'result':
-              // Session complete
-              // session result received
-              
-              // Send final message if we have buffered content
-              if (messageBuffer) {
-                ws.send({
-                  type: 'claude-response',
-                  data: {
-                    type: 'content_block_stop'
-                  },
-                  sessionId: capturedSessionId || sessionId || null
-                });
-              }
-              
-              // Send completion event
-              ws.send({
-                type: 'cursor-result',
-                sessionId: capturedSessionId || sessionId,
-                data: response,
-                success: response.subtype === 'success'
-              });
-              break;
-              
-            default:
-              // Forward any other message types
-              ws.send({
-                type: 'cursor-response',
-                data: response,
-                sessionId: capturedSessionId || sessionId || null
-              });
-          }
-        } catch (parseError) {
-          // non-JSON response skipped
-          // If not JSON, send as raw text
-          ws.send({
-            type: 'cursor-output',
-            data: line,
-            sessionId: capturedSessionId || sessionId || null
-          });
-        }
-      }
-    });
-    
-    // Handle stderr
-    cursorProcess.stderr.on('data', (data) => {
-      // stderr output received
-      ws.send({
-        type: 'cursor-error',
-        error: data.toString(),
-        sessionId: capturedSessionId || sessionId || null
-      });
-    });
-    
-    // Handle process completion
-    cursorProcess.on('close', async (code) => {
-      // process exited
-      
-      // Clean up process reference
-      const finalSessionId = capturedSessionId || sessionId || processKey;
-      activeCursorProcesses.delete(finalSessionId);
-
-      ws.send({
-        type: 'claude-complete',
-        sessionId: finalSessionId,
-        exitCode: code,
-        isNewSession: !sessionId && !!command // Flag to indicate this was a new session
-      });
-      
-      if (code === 0) {
-        resolve();
-      } else {
-        reject(new Error(`Cursor CLI exited with code ${code}`));
-      }
-    });
-    
-    // Handle process errors
-    cursorProcess.on('error', (error) => {
-      // process error occurred
-      
-      // Clean up process reference on error
-      const finalSessionId = capturedSessionId || sessionId || processKey;
-      activeCursorProcesses.delete(finalSessionId);
-
-      ws.send({
-        type: 'cursor-error',
-        error: error.message,
-        sessionId: capturedSessionId || sessionId || null
-      });
-
-      reject(error);
-    });
-    
-    // Close stdin since Cursor doesn't need interactive input
-    cursorProcess.stdin.end();
-  });
-}
-
-function abortCursorSession(sessionId) {
-  const process = activeCursorProcesses.get(sessionId);
-  if (process) {
-    // aborting session
-    process.kill('SIGTERM');
-    activeCursorProcesses.delete(sessionId);
-    return true;
-  }
-  return false;
-}
-
-function isCursorSessionActive(sessionId) {
-  return activeCursorProcesses.has(sessionId);
-}
-
-function getActiveCursorSessions() {
-  return Array.from(activeCursorProcesses.keys());
-}
-
-export {
-  spawnCursor,
-  abortCursorSession,
-  isCursorSessionActive,
-  getActiveCursorSessions
-};