upfynai-code 2.4.0 → 2.5.0

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,186 @@
+import cron from 'node-cron';
+import { workflowDb, webhookDb } from '../database/db.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 {
+        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 () => {
+    console.log(`[Scheduler] Running workflow ${id}: ${workflow.name}`);
+    try {
+      await executeWorkflow(workflow);
+    } catch (err) {
+      console.error(`[Scheduler] Workflow ${id} execution error:`, err.message);
+    }
+  }, {
+    timezone: workflow.schedule_timezone || 'UTC'
+  });
+
+  activeJobs.set(id, task);
+  console.log(`[Scheduler] Scheduled workflow ${id} (${workflow.name}): ${workflow.schedule}`);
+}
+
+/**
+ * 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();
+    console.log(`[Scheduler] Found ${workflows.length} scheduled workflow(s)`);
+    for (const wf of workflows) {
+      scheduleWorkflow(wf);
+    }
+  } catch (err) {
+    console.error('[Scheduler] Init error:', err.message);
+  }
+}
+
+/**
+ * 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 };