@tthr/vue 0.0.84 → 0.0.86

package/nuxt/runtime/server/plugins/cron.ts

@@ -0,0 +1,377 @@
+/**
+ * Nuxt server plugin for Tether cron execution
+ *
+ * This plugin connects to Tether via WebSocket to receive cron triggers.
+ * When triggered, it executes the user's function and reports the result.
+ */
+
+import { defineNitroPlugin } from 'nitropack/runtime';
+import { configureTetherServer, executeFunction } from '../../../../dist/server.js';
+
+// Re-export defineNitroPlugin for use by generated plugins
+export { defineNitroPlugin };
+
+// Store for manually registered cron handlers
+const cronHandlers: Map<string, (args: unknown) => Promise<unknown>> = new Map();
+
+// Dynamic function registry - populated on first cron trigger
+let functionRegistry: Record<string, Record<string, { handler: Function; args?: unknown }>> | null = null;
+
+// WebSocket connection state
+let ws: WebSocket | null = null;
+let connectionId: string | null = null;
+let reconnectAttempts = 0;
+let heartbeatTimer: ReturnType<typeof setInterval> | null = null;
+let heartbeatTimeoutTimer: ReturnType<typeof setTimeout> | null = null;
+let awaitingPong = false;
+let shouldReconnect = true;
+let verboseLogging = false;
+
+const MAX_RECONNECT_ATTEMPTS = 10;
+const HEARTBEAT_INTERVAL = 20000;
+const HEARTBEAT_TIMEOUT = 10000;
+const RECONNECT_DELAY = 1000;
+const PREFIX = '[Tether Cron]';
+
+const log = {
+  debug: (...args: unknown[]) => { if (verboseLogging) console.log(PREFIX, ...args); },
+  info: (...args: unknown[]) => console.log(PREFIX, ...args),
+  warn: (...args: unknown[]) => console.warn(PREFIX, ...args),
+  error: (...args: unknown[]) => console.error(PREFIX, ...args),
+};
+
+/**
+ * Register a cron handler for a specific function
+ */
+export function registerCronHandler(
+  functionName: string,
+  handler: (args: unknown) => Promise<unknown>
+): void {
+  cronHandlers.set(functionName, handler);
+  log.debug('Registered handler for:', functionName);
+}
+
+/**
+ * Unregister a cron handler
+ */
+export function unregisterCronHandler(functionName: string): void {
+  cronHandlers.delete(functionName);
+}
+
+/**
+ * Get all registered cron handlers
+ */
+export function getCronHandlers(): string[] {
+  return Array.from(cronHandlers.keys());
+}
+
+/**
+ * Load user's custom functions from ~/tether/functions
+ */
+async function loadFunctionRegistry(): Promise<void> {
+  if (functionRegistry !== null) return;
+
+  try {
+    const functions = await import('~~/tether/functions/index.ts').catch(() => null);
+    functionRegistry = functions as Record<string, Record<string, { handler: Function; args?: unknown }>> ?? {};
+  } catch {
+    functionRegistry = {};
+  }
+}
+
+/**
+ * Look up a function by name (e.g., "sync.syncClips")
+ */
+function lookupFunction(name: string): { handler: Function; args?: unknown } | null {
+  if (!functionRegistry || !name) return null;
+
+  const parts = name.split('.');
+  if (parts.length !== 2) return null;
+
+  const [moduleName, fnName] = parts;
+  const module = functionRegistry[moduleName];
+  if (!module) return null;
+
+  const fn = module[fnName];
+  if (fn && typeof fn === 'object' && typeof fn.handler === 'function') {
+    return fn;
+  }
+
+  return null;
+}
+
+interface CronTriggerMessage {
+  type: 'cron_trigger';
+  executionId: string;
+  cronId: string;
+  functionName: string;
+  functionType: string;
+  args?: unknown;
+}
+
+interface ServerMessage {
+  type: 'connected' | 'cron_trigger' | 'pong' | 'error';
+  connection_id?: string;
+  executionId?: string;
+  cronId?: string;
+  functionName?: string;
+  functionType?: string;
+  args?: unknown;
+  error?: { code: string; message: string };
+}
+
+function getWsUrl(config: { url: string; projectId: string; apiKey: string; environment?: string }): string {
+  const base = config.url
+    .replace('https://', 'wss://')
+    .replace('http://', 'ws://')
+    .replace(/\/$/, '');
+
+  const env = config.environment;
+  const wsPath = env && env !== 'production'
+    ? `${base}/ws/${config.projectId}/${env}`
+    : `${base}/ws/${config.projectId}`;
+
+  return `${wsPath}?type=server&token=${encodeURIComponent(config.apiKey)}`;
+}
+
+async function reportExecution(
+  config: { url: string; projectId: string; apiKey: string; environment?: string },
+  trigger: CronTriggerMessage,
+  result: { success: boolean; result?: unknown; error?: string },
+  durationMs: number
+): Promise<void> {
+  const base = config.url.replace(/\/$/, '');
+  const env = config.environment;
+  const apiPath = env && env !== 'production'
+    ? `${base}/api/v1/projects/${config.projectId}/env/${env}`
+    : `${base}/api/v1/projects/${config.projectId}`;
+
+  try {
+    const response = await fetch(`${apiPath}/crons/${trigger.cronId}/executions`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${config.apiKey}`,
+      },
+      body: JSON.stringify({
+        executionId: trigger.executionId,
+        success: result.success,
+        errorMessage: result.error,
+        result: result.result,
+        durationMs,
+      }),
+    });
+
+    if (!response.ok) {
+      log.error(`Failed to report execution: ${response.status}`);
+    }
+  } catch (error) {
+    log.error('Failed to report execution:', error);
+  }
+}
+
+async function handleCronTrigger(
+  config: { url: string; projectId: string; apiKey: string; environment?: string },
+  trigger: CronTriggerMessage
+): Promise<void> {
+  log.info(`Received trigger for ${trigger.functionName} (execution: ${trigger.executionId})`);
+
+  const startTime = Date.now();
+
+  try {
+    let result: unknown;
+
+    // 1. Check for manually registered handler
+    const handler = cronHandlers.get(trigger.functionName);
+    if (handler) {
+      log.debug(`Using registered handler for: ${trigger.functionName}`);
+      result = await handler(trigger.args);
+    } else {
+      // 2. Load and execute from user's tether/functions using executeFunction
+      await loadFunctionRegistry();
+      const fn = lookupFunction(trigger.functionName);
+
+      if (fn) {
+        log.debug(`Executing function: ${trigger.functionName}`);
+        // Use executeFunction from @tthr/vue/server which has the proper db proxy
+        result = await executeFunction(fn as any, trigger.args ?? {});
+      } else {
+        throw new Error(`Function '${trigger.functionName}' not found`);
+      }
+    }
+
+    const durationMs = Date.now() - startTime;
+    await reportExecution(config, trigger, { success: true, result }, durationMs);
+  } catch (error) {
+    const durationMs = Date.now() - startTime;
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    log.error(`Handler error for ${trigger.functionName}:`, errorMessage);
+    await reportExecution(config, trigger, { success: false, error: errorMessage }, durationMs);
+  }
+}
+
+function startHeartbeat(): void {
+  stopHeartbeat();
+
+  heartbeatTimer = setInterval(() => {
+    if (ws?.readyState === 1) { // WebSocket.OPEN
+      awaitingPong = true;
+      ws.send(JSON.stringify({ type: 'ping' }));
+
+      heartbeatTimeoutTimer = setTimeout(() => {
+        if (awaitingPong) {
+          log.warn('Heartbeat timeout - forcing reconnect');
+          ws?.close();
+        }
+      }, HEARTBEAT_TIMEOUT);
+    }
+  }, HEARTBEAT_INTERVAL);
+}
+
+function stopHeartbeat(): void {
+  if (heartbeatTimer) {
+    clearInterval(heartbeatTimer);
+    heartbeatTimer = null;
+  }
+  if (heartbeatTimeoutTimer) {
+    clearTimeout(heartbeatTimeoutTimer);
+    heartbeatTimeoutTimer = null;
+  }
+  awaitingPong = false;
+}
+
+// WebSocket implementation - loaded dynamically for Node.js
+let WebSocketImpl: typeof WebSocket | null = null;
+
+async function getWebSocketImpl(): Promise<typeof WebSocket> {
+  if (WebSocketImpl) return WebSocketImpl;
+
+  if (typeof WebSocket !== 'undefined') {
+    WebSocketImpl = WebSocket;
+  } else {
+    const wsModule = await import('ws');
+    WebSocketImpl = wsModule.default as unknown as typeof WebSocket;
+  }
+  return WebSocketImpl;
+}
+
+async function connect(config: { url: string; projectId: string; apiKey: string; environment?: string }): Promise<void> {
+  const WS = await getWebSocketImpl();
+
+  if (ws?.readyState === WS.OPEN || ws?.readyState === WS.CONNECTING) {
+    return;
+  }
+
+  try {
+    const url = getWsUrl(config);
+    ws = new WS(url);
+
+    ws.onopen = () => {
+      reconnectAttempts = 0;
+      log.debug('WebSocket connected');
+    };
+
+    ws.onmessage = async (event: { data: string | Buffer }) => {
+      const data = typeof event.data === 'string' ? event.data : event.data.toString();
+
+      try {
+        const message = JSON.parse(data) as ServerMessage;
+
+        switch (message.type) {
+          case 'connected':
+            connectionId = message.connection_id ?? null;
+            startHeartbeat();
+            log.info(`Connected with ID: ${connectionId}`);
+            break;
+
+          case 'cron_trigger':
+            await handleCronTrigger(config, message as CronTriggerMessage);
+            break;
+
+          case 'pong':
+            awaitingPong = false;
+            if (heartbeatTimeoutTimer) {
+              clearTimeout(heartbeatTimeoutTimer);
+              heartbeatTimeoutTimer = null;
+            }
+            break;
+
+          case 'error':
+            log.error('Server error:', message.error);
+            break;
+        }
+      } catch (e) {
+        log.error('Failed to parse message:', e);
+      }
+    };
+
+    ws.onerror = (error: Event | Error) => {
+      // WebSocket error events often don't contain useful details
+      // The actual error is usually surfaced via onclose
+      if (error instanceof Error && error.message) {
+        log.error('WebSocket error:', error.message);
+      } else {
+        log.debug('WebSocket connection error (details in close event)');
+      }
+    };
+
+    ws.onclose = (event: { code?: number; reason?: string }) => {
+      connectionId = null;
+      stopHeartbeat();
+      log.debug(`Disconnected (code: ${event.code})`);
+      handleReconnect(config);
+    };
+  } catch (error) {
+    log.debug('Failed to connect:', error);
+    handleReconnect(config);
+  }
+}
+
+function handleReconnect(config: { url: string; projectId: string; apiKey: string; environment?: string }): void {
+  if (!shouldReconnect || reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
+    if (reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
+      log.error('Max reconnection attempts reached');
+    }
+    return;
+  }
+
+  reconnectAttempts++;
+  const delay = Math.min(RECONNECT_DELAY * Math.pow(2, reconnectAttempts - 1), 30000);
+
+  setTimeout(() => {
+    connect(config).catch((err) => log.debug('Reconnect failed:', err));
+  }, delay);
+}
+
+export default defineNitroPlugin((nitro) => {
+  const apiKey = process.env.NUXT_TETHER_API_KEY || process.env.TETHER_API_KEY;
+  const url = process.env.NUXT_TETHER_URL || process.env.TETHER_URL || 'https://tether-api.strands.gg';
+  const projectId = process.env.NUXT_TETHER_PROJECT_ID || process.env.TETHER_PROJECT_ID;
+  const environment = process.env.NUXT_TETHER_ENVIRONMENT || process.env.TETHER_ENVIRONMENT;
+  verboseLogging = process.env.NUXT_TETHER_VERBOSE === 'true' || process.env.TETHER_VERBOSE === 'true';
+
+  if (!apiKey || !projectId) {
+    log.debug('Missing config - cron connection disabled');
+    return;
+  }
+
+  // Configure the server client so executeFunction works
+  configureTetherServer({ url, projectId, apiKey });
+
+  log.info(`Initialising cron connection...${environment ? ` (env: ${environment})` : ''}`);
+
+  const config = { url, projectId, apiKey, environment };
+
+  process.nextTick(() => {
+    connect(config).catch((err) => log.error('Initial connect failed:', err));
+  });
+
+  nitro.hooks.hook('close', () => {
+    shouldReconnect = false;
+    stopHeartbeat();
+    if (ws) {
+      ws.close();
+      ws = null;
+    }
+  });
+});