upfynai-code 3.0.4 → 3.2.0

package/server/services/composio.js

@@ -1,204 +0,0 @@
-/**
- * Composio Service — wraps the Composio SDK for OAuth management + tool execution.
- * Single API key for the app, user isolation via entity mapping.
- */
-
-
-let Composio = null;
-let composioClient = null;
-let sdkReady = null; // resolved promise once SDK is loaded
-
-// Eagerly attempt to load the SDK — store the promise so getClient can await it
-sdkReady = (async () => {
-  try {
-    const mod = await import('composio-core');
-    Composio = mod.Composio || mod.default;
-  } catch {
-    // SDK not installed — composio features will be unavailable
-  }
-})();
-
-/**
- * Lazy-init the Composio client singleton.
- * Returns null if COMPOSIO_API_KEY is not set.
- */
-async function getClient() {
-  if (composioClient) return composioClient;
-  if (!process.env.COMPOSIO_API_KEY) return null;
-
-  // Wait for SDK to finish loading
-  await sdkReady;
-
-  try {
-    if (!Composio) return null;
-    composioClient = new Composio({ apiKey: process.env.COMPOSIO_API_KEY });
-    return composioClient;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Map internal user ID to Composio entity ID.
- */
-function composioUserId(internalId) {
-  return `upfyn_user_${internalId}`;
-}
-
-/**
- * Get or create an entity for the given user.
- */
-async function getEntity(userId) {
-  const client = await getClient();
-  if (!client) throw new Error('Composio not configured');
-  return client.getEntity(composioUserId(userId));
-}
-
-/**
- * Initiate an OAuth connection for a user.
- * OAuth credentials are managed on the Composio dashboard — not injected here.
- *
- * @param {number} userId - Internal user ID
- * @param {string} appName - Composio app name (e.g., 'GMAIL', 'SLACK')
- * @param {string|null} authConfigId - Optional specific auth config
- * @returns {{ redirectUrl: string, connectedAccountId: string }}
- */
-async function initiateConnection(userId, appName, authConfigId = null) {
-  const entity = await getEntity(userId);
-
-  const params = { appName };
-  if (authConfigId) params.authConfigId = authConfigId;
-
-  const connectionRequest = await entity.initiateConnection(params);
-  return {
-    redirectUrl: connectionRequest.redirectUrl,
-    connectedAccountId: connectionRequest.connectedAccountId,
-  };
-}
-
-/**
- * Wait/poll for a connection to complete.
- * @param {string} connectedAccountId - The connection ID from initiateConnection
- * @returns {{ status: string, appName: string }}
- */
-async function waitForConnection(connectedAccountId) {
-  const client = await getClient();
-  if (!client) throw new Error('Composio not configured');
-
-  const connection = await client.connectedAccounts.get({ connectedAccountId });
-  return {
-    status: connection.status,
-    appName: connection.appName,
-    id: connection.id,
-  };
-}
-
-/**
- * List connected accounts for a user.
- * @param {number} userId
- * @returns {Array<{ id, appName, status, createdAt }>}
- */
-async function listConnectedAccounts(userId) {
-  const client = await getClient();
-  if (!client) throw new Error('Composio not configured');
-
-  const entityId = composioUserId(userId);
-  try {
-    const accounts = await client.connectedAccounts.list({ entityId });
-    return (accounts.items || accounts || []).map(a => ({
-      id: a.id,
-      appName: a.appName,
-      status: a.status,
-      createdAt: a.createdAt,
-    }));
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Get available tools for given toolkits.
- * @param {string[]} apps - e.g., ['GMAIL', 'SLACK']
- * @returns {Array<{ name, description, parameters }>}
- */
-async function getTools(apps = []) {
-  const client = await getClient();
-  if (!client) throw new Error('Composio not configured');
-
-  const tools = await client.actions.list({ apps });
-  return (tools.items || tools || []).map(t => ({
-    name: t.name,
-    displayName: t.displayName || t.name,
-    description: t.description,
-    parameters: t.parameters,
-    appName: t.appName,
-  }));
-}
-
-/**
- * Get schema for a specific tool.
- * @param {string} actionName - e.g., 'GMAIL_SEND_EMAIL'
- * @returns {{ name, description, parameters }}
- */
-async function getToolSchema(actionName) {
-  const client = await getClient();
-  if (!client) throw new Error('Composio not configured');
-
-  const action = await client.actions.get({ actionName });
-  return {
-    name: action.name,
-    displayName: action.displayName || action.name,
-    description: action.description,
-    parameters: action.parameters,
-    appName: action.appName,
-  };
-}
-
-/**
- * Execute a Composio tool action.
- * @param {number} userId - Internal user ID
- * @param {string} actionName - e.g., 'GMAIL_SEND_EMAIL'
- * @param {object} params - Action parameters
- * @returns {{ success, data, error }}
- */
-async function executeTool(userId, actionName, params = {}) {
-  const entity = await getEntity(userId);
-
-  try {
-    const result = await entity.execute(actionName, params);
-    return { success: true, data: result };
-  } catch (err) {
-    return { success: false, error: err.message };
-  }
-}
-
-/**
- * Disconnect an account.
- * @param {string} connectedAccountId
- */
-async function disconnectAccount(connectedAccountId) {
-  const client = await getClient();
-  if (!client) throw new Error('Composio not configured');
-
-  await client.connectedAccounts.delete({ connectedAccountId });
-}
-
-/**
- * Check if Composio is available and configured.
- */
-async function isAvailable() {
-  await sdkReady;
-  return !!(Composio && process.env.COMPOSIO_API_KEY);
-}
-
-export {
-  isAvailable,
-  composioUserId,
-  initiateConnection,
-  waitForConnection,
-  listConnectedAccounts,
-  getTools,
-  getToolSchema,
-  executeTool,
-  disconnectAccount,
-};

package/server/services/sessionRegistry.js

@@ -1,139 +0,0 @@
-/**
- * Unified Session Registry
- * Wraps per-provider session maps into a single interface for session management.
- */
-
-import { getActiveClaudeSDKSessions, abortClaudeSDKSession, isClaudeSDKSessionActive } from '../claude-sdk.js';
-import { getActiveCursorSessions, abortCursorSession, isCursorSessionActive } from '../cursor-cli.js';
-import { getActiveCodexSessions, abortCodexSession, isCodexSessionActive } from '../openai-codex.js';
-
-/**
- * Get all active sessions across all providers for a user.
- * Note: current provider maps are global (not per-user), so we return all.
- * When relay-based sessions are added, userId will be used to filter.
- * @returns {Array<{ sessionId, provider, startTime, status, isProcessing }>}
- */
-export function getAllActiveSessions() {
-  const sessions = [];
-
-  // Claude SDK sessions — returns array of session IDs
-  const claudeIds = getActiveClaudeSDKSessions();
-  for (const id of claudeIds) {
-    sessions.push({
-      sessionId: id,
-      provider: 'claude',
-      status: isClaudeSDKSessionActive(id) ? 'active' : 'idle',
-    });
-  }
-
-  // Cursor sessions — returns array of session IDs
-  const cursorIds = getActiveCursorSessions();
-  for (const id of cursorIds) {
-    sessions.push({
-      sessionId: id,
-      provider: 'cursor',
-      status: isCursorSessionActive(id) ? 'active' : 'idle',
-    });
-  }
-
-  // Codex sessions — returns array of { id, status, startedAt }
-  const codexSessions = getActiveCodexSessions();
-  for (const s of codexSessions) {
-    sessions.push({
-      sessionId: s.id,
-      provider: 'codex',
-      status: s.status === 'running' ? 'active' : s.status,
-      startedAt: s.startedAt,
-    });
-  }
-
-  return sessions;
-}
-
-/**
- * Check if a session is active across any provider.
- * @param {string} sessionId
- * @returns {{ active: boolean, provider: string|null }}
- */
-export function checkSessionStatus(sessionId) {
-  if (isClaudeSDKSessionActive(sessionId)) return { active: true, provider: 'claude' };
-  if (isCursorSessionActive(sessionId)) return { active: true, provider: 'cursor' };
-  if (isCodexSessionActive(sessionId)) return { active: true, provider: 'codex' };
-  return { active: false, provider: null };
-}
-
-/**
- * Abort a session by ID, auto-detecting or using specified provider.
- * @param {string} sessionId
- * @param {string} [provider] - Optional: 'claude', 'cursor', 'codex'
- * @returns {Promise<{ aborted: boolean, provider: string|null }>}
- */
-export async function abortSession(sessionId, provider) {
-  // If provider specified, abort directly
-  if (provider) {
-    const result = await abortByProvider(sessionId, provider);
-    return { aborted: result, provider: result ? provider : null };
-  }
-
-  // Auto-detect provider
-  if (isClaudeSDKSessionActive(sessionId)) {
-    const result = await abortClaudeSDKSession(sessionId);
-    return { aborted: result, provider: 'claude' };
-  }
-  if (isCursorSessionActive(sessionId)) {
-    const result = abortCursorSession(sessionId);
-    return { aborted: result, provider: 'cursor' };
-  }
-  if (isCodexSessionActive(sessionId)) {
-    const result = abortCodexSession(sessionId);
-    return { aborted: result, provider: 'codex' };
-  }
-
-  return { aborted: false, provider: null };
-}
-
-/**
- * Abort all active sessions.
- * @returns {Promise<Array<{ sessionId, provider, aborted }>>}
- */
-export async function abortAllSessions() {
-  const all = getAllActiveSessions();
-  const results = [];
-
-  for (const s of all) {
-    const { aborted } = await abortSession(s.sessionId, s.provider);
-    results.push({ sessionId: s.sessionId, provider: s.provider, aborted });
-  }
-
-  return results;
-}
-
-/**
- * Get session stats summary.
- * @returns {{ total, byProvider: { claude, cursor, codex }, active }}
- */
-export function getSessionStats() {
-  const sessions = getAllActiveSessions();
-  const byProvider = { claude: 0, cursor: 0, codex: 0 };
-
-  for (const s of sessions) {
-    byProvider[s.provider] = (byProvider[s.provider] || 0) + 1;
-  }
-
-  return {
-    total: sessions.length,
-    active: sessions.filter(s => s.status === 'active').length,
-    byProvider,
-  };
-}
-
-// -- Internal --
-
-async function abortByProvider(sessionId, provider) {
-  switch (provider) {
-    case 'claude': return abortClaudeSDKSession(sessionId);
-    case 'cursor': return abortCursorSession(sessionId);
-    case 'codex': return abortCodexSession(sessionId);
-    default: return false;
-  }
-}

package/server/services/whisperService.js

@@ -1,84 +0,0 @@
-/**
- * Local Whisper STT service using nodejs-whisper.
- * Used as a fallback when no OpenAI API key is configured (local mode).
- * Requires ffmpeg to be installed on the system.
- */
-
-let whisperAvailable = null; // null = unchecked, true/false
-let modelReady = false;
-
-/**
- * Check if nodejs-whisper and ffmpeg are available.
- */
-async function isWhisperAvailable() {
-  if (whisperAvailable !== null) return whisperAvailable;
-
-  try {
-    // Check if nodejs-whisper can be imported
-    await import('nodejs-whisper');
-
-    // Check if ffmpeg is available
-    const { execSync } = await import('child_process');
-    execSync('ffmpeg -version', { stdio: 'pipe', timeout: 5000 });
-
-    whisperAvailable = true;
-  } catch {
-    whisperAvailable = false;
-  }
-
-  return whisperAvailable;
-}
-
-/**
- * Ensure the whisper model is downloaded.
- * Downloads the tiny.en model (~75MB) on first use.
- */
-async function ensureWhisperModel() {
-  if (modelReady) return true;
-
-  const available = await isWhisperAvailable();
-  if (!available) return false;
-
-  try {
-    const { nodeWhisper } = await import('nodejs-whisper');
-    // Attempt to download model if not present
-    await nodeWhisper.downloadModel('tiny.en');
-    modelReady = true;
-    return true;
-  } catch (err) {
-    console.warn('[WhisperService] Failed to download model:', err.message);
-    return false;
-  }
-}
-
-/**
- * Transcribe audio using local nodejs-whisper.
- * @param {string} audioFilePath - Path to the audio file (WAV, MP3, etc.)
- * @returns {Promise<string|null>} Transcribed text, or null if failed
- */
-async function transcribeLocal(audioFilePath) {
-  const ready = await ensureWhisperModel();
-  if (!ready) return null;
-
-  try {
-    const { nodeWhisper } = await import('nodejs-whisper');
-    const result = await nodeWhisper(audioFilePath, {
-      modelName: 'tiny.en',
-      autoDownloadModelName: 'tiny.en',
-      whisperOptions: {
-        outputInText: true,
-        language: 'en',
-      }
-    });
-
-    // nodejs-whisper returns array of segments or text
-    if (typeof result === 'string') return result.trim();
-    if (Array.isArray(result)) return result.map(s => s.speech || s.text || '').join(' ').trim();
-    return null;
-  } catch (err) {
-    console.error('[WhisperService] Transcription error:', err.message);
-    return null;
-  }
-}
-
-export { isWhisperAvailable, ensureWhisperModel, transcribeLocal };

package/server/services/workflowScheduler.js

@@ -1,211 +0,0 @@
-// node-cron is cloud-only — dynamically imported so local installs don't crash
-let cron = null;
-try { cron = (await import('node-cron')).default; } catch { /* not installed locally */ }
-
-import { workflowDb, webhookDb } from '../database/db.js';
-import * as composioService from './composio.js';
-
-const activeJobs = new Map(); // workflowId -> cron task
-
-/**
- * Execute a single workflow's steps (same logic as the /run endpoint).
- * Returns { success, results, error }
- */
-async function executeWorkflow(workflow) {
-  const steps = typeof workflow.steps === 'string' ? JSON.parse(workflow.steps) : workflow.steps;
-  if (!steps.length) return { success: false, error: 'No steps' };
-
-  const run = await workflowDb.createRun(workflow.id, workflow.user_id, steps.length);
-  const results = [];
-  let lastOutput = null;
-
-  for (let i = 0; i < steps.length; i++) {
-    const step = steps[i];
-    try {
-      let stepResult;
-
-      if (step.type === 'webhook') {
-        const webhookId = step.config?.webhookId;
-        if (!webhookId) throw new Error('No webhook configured');
-
-        const webhook = await webhookDb.getById(Number(webhookId), workflow.user_id);
-        if (!webhook) throw new Error('Webhook not found');
-
-        let parsedHeaders = {};
-        try { parsedHeaders = JSON.parse(webhook.headers || '{}'); } catch { /* ignore */ }
-
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), 15000);
-
-        const fetchOptions = {
-          method: webhook.method,
-          headers: {
-            'Content-Type': 'application/json',
-            'User-Agent': 'UpfynAI-Scheduler/1.0',
-            ...parsedHeaders
-          },
-          signal: controller.signal
-        };
-
-        if (['POST', 'PUT', 'PATCH'].includes(webhook.method)) {
-          const payload = {
-            workflow_id: workflow.id,
-            workflow_name: workflow.name,
-            step_index: i,
-            step_label: step.label,
-            previous_output: lastOutput,
-            scheduled: true,
-            timestamp: new Date().toISOString()
-          };
-          if (step.config?.payloadTemplate) {
-            try { Object.assign(payload, JSON.parse(step.config.payloadTemplate)); } catch { /* ignore */ }
-          }
-          fetchOptions.body = JSON.stringify(payload);
-        }
-
-        const response = await fetch(webhook.url, fetchOptions);
-        clearTimeout(timeout);
-
-        const contentType = response.headers.get('content-type') || '';
-        let body;
-        if (contentType.includes('application/json')) {
-          body = await response.json();
-        } else {
-          body = await response.text();
-          if (body.length > 5000) body = body.slice(0, 5000) + '...';
-        }
-
-        await webhookDb.updateLastTriggered(webhook.id);
-        stepResult = { status: response.status, body };
-        lastOutput = body;
-
-      } else if (step.type === 'ai-prompt') {
-        stepResult = { type: 'ai-prompt', prompt: step.config?.prompt || '', note: 'Scheduled AI prompts require active session' };
-        lastOutput = step.config?.prompt;
-
-      } else if (step.type === 'delay') {
-        const seconds = Math.min(step.config?.seconds || 1, 30);
-        await new Promise(resolve => setTimeout(resolve, seconds * 1000));
-        stepResult = { delayed: seconds };
-
-      } else if (step.type === 'integration') {
-        const toolSlug = step.config?.toolSlug;
-        if (!toolSlug) throw new Error('No tool configured for integration step');
-        if (!(await composioService.isAvailable())) throw new Error('Composio not configured');
-
-        // Interpolate {{prev.field}} templates from lastOutput
-        let args = { ...(step.config?.arguments || {}) };
-        if (lastOutput && typeof lastOutput === 'object') {
-          for (const [key, val] of Object.entries(args)) {
-            if (typeof val === 'string' && val.includes('{{prev.')) {
-              args[key] = val.replace(/\{\{prev\.(\w+)\}\}/g, (_, field) =>
-                lastOutput[field] !== undefined ? String(lastOutput[field]) : ''
-              );
-            }
-          }
-        }
-
-        const result = await composioService.executeTool(workflow.user_id, toolSlug, args);
-        if (!result.success) throw new Error(result.error || 'Integration execution failed');
-        stepResult = { toolSlug, ...result };
-        lastOutput = result.data || result;
-
-      } else {
-        stepResult = { type: step.type, note: 'Unknown step type' };
-      }
-
-      results.push({ step: i, label: step.label, type: step.type, success: true, result: stepResult });
-      await workflowDb.updateRun(run.id, { status: 'running', stepsCompleted: i + 1 });
-
-    } catch (stepError) {
-      results.push({ step: i, label: step.label, type: step.type, success: false, error: stepError.message });
-      await workflowDb.updateRun(run.id, { status: 'failed', stepsCompleted: i, error: `Step ${i + 1} (${step.label}): ${stepError.message}` });
-      await workflowDb.updateLastRun(workflow.id);
-      return { success: false, run_id: run.id, results, error: `Step ${i + 1} failed: ${stepError.message}` };
-    }
-  }
-
-  await workflowDb.updateRun(run.id, { status: 'completed', stepsCompleted: steps.length, result: results });
-  await workflowDb.updateLastRun(workflow.id);
-  return { success: true, run_id: run.id, results };
-}
-
-/**
- * Schedule a single workflow's cron job.
- */
-function scheduleWorkflow(workflow) {
-  if (!cron) return; // node-cron not available (local install)
-
-  const id = workflow.id;
-
-  // Stop existing job if any
-  if (activeJobs.has(id)) {
-    activeJobs.get(id).stop();
-    activeJobs.delete(id);
-  }
-
-  if (!workflow.schedule || !workflow.schedule_enabled) return;
-
-  // Validate cron expression
-  if (!cron.validate(workflow.schedule)) {
-    console.warn(`[Scheduler] Invalid cron for workflow ${id}: ${workflow.schedule}`);
-    return;
-  }
-
-  const task = cron.schedule(workflow.schedule, async () => {
-    try {
-      await executeWorkflow(workflow);
-    } catch {
-      // workflow execution error
-    }
-  }, {
-    timezone: workflow.schedule_timezone || 'UTC'
-  });
-
-  activeJobs.set(id, task);
-}
-
-/**
- * Load all scheduled workflows from DB and start their cron jobs.
- * Call this once at server startup.
- */
-async function initScheduler() {
-  try {
-    const workflows = await workflowDb.getScheduled();
-    for (const wf of workflows) {
-      scheduleWorkflow(wf);
-    }
-  } catch (err) {
-    // scheduler init error — silenced
-  }
-}
-
-/**
- * Re-sync a specific workflow's schedule (call after create/update).
- */
-async function refreshWorkflowSchedule(workflowId, userId) {
-  try {
-    const wf = await workflowDb.getById(workflowId, userId);
-    if (wf) {
-      scheduleWorkflow(wf);
-    } else {
-      // Workflow deleted — stop its job
-      if (activeJobs.has(workflowId)) {
-        activeJobs.get(workflowId).stop();
-        activeJobs.delete(workflowId);
-      }
-    }
-  } catch { /* ignore */ }
-}
-
-/**
- * Stop a workflow's cron job.
- */
-function stopWorkflowSchedule(workflowId) {
-  if (activeJobs.has(workflowId)) {
-    activeJobs.get(workflowId).stop();
-    activeJobs.delete(workflowId);
-  }
-}
-
-export { initScheduler, refreshWorkflowSchedule, stopWorkflowSchedule, executeWorkflow };