upfynai-code 2.9.0 → 2.9.2

package/server/services/sessionRegistry.js

@@ -0,0 +1,139 @@
+/**
+ * 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

@@ -0,0 +1,84 @@
+/**
+ * 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

@@ -0,0 +1,206 @@
+import cron from 'node-cron';
+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) {
+  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 };