@tthr/vue 0.0.76 → 0.0.78

package/nuxt/module.js

@@ -106,15 +106,15 @@ export default defineNuxtModule({
             },
             {
                 name: 'registerCronHandler',
-                from: resolver.resolve('./runtime/server/plugins/cron.ts'),
+                from: resolver.resolve('./runtime/server/plugins/cron.js'),
             },
             {
                 name: 'unregisterCronHandler',
-                from: resolver.resolve('./runtime/server/plugins/cron.ts'),
+                from: resolver.resolve('./runtime/server/plugins/cron.js'),
             },
             {
                 name: 'getCronHandlers',
-                from: resolver.resolve('./runtime/server/plugins/cron.ts'),
+                from: resolver.resolve('./runtime/server/plugins/cron.js'),
             },
         ]);
         // Ensure the runtime files are transpiled
@@ -124,8 +124,8 @@ export default defineNuxtModule({
         // This auto-connects to Tether when the server starts
         nuxt.hook('nitro:config', (nitroConfig) => {
             nitroConfig.plugins = nitroConfig.plugins || [];
-            // Use direct path - Nitro will handle the #imports resolution at build time
-            nitroConfig.plugins.push(resolver.resolve('./runtime/server/plugins/cron.ts'));
+            // Use pre-compiled JS - Nitro can parse this without TypeScript plugins
+            nitroConfig.plugins.push(resolver.resolve('./runtime/server/plugins/cron.js'));
             // Ensure Nitro inlines and transpiles the plugin from node_modules
             nitroConfig.externals = nitroConfig.externals || {};
             nitroConfig.externals.inline = nitroConfig.externals.inline || [];

package/nuxt/module.ts

@@ -127,15 +127,15 @@ export default defineNuxtModule<TetherModuleOptions>({
       },
       {
         name: 'registerCronHandler',
-        from: resolver.resolve('./runtime/server/plugins/cron.ts'),
+        from: resolver.resolve('./runtime/server/plugins/cron.js'),
       },
       {
         name: 'unregisterCronHandler',
-        from: resolver.resolve('./runtime/server/plugins/cron.ts'),
+        from: resolver.resolve('./runtime/server/plugins/cron.js'),
       },
       {
         name: 'getCronHandlers',
-        from: resolver.resolve('./runtime/server/plugins/cron.ts'),
+        from: resolver.resolve('./runtime/server/plugins/cron.js'),
       },
     ]);
 
@@ -147,8 +147,8 @@ export default defineNuxtModule<TetherModuleOptions>({
     // This auto-connects to Tether when the server starts
     nuxt.hook('nitro:config' as any, (nitroConfig: any) => {
       nitroConfig.plugins = nitroConfig.plugins || [];
-      // Use direct path - Nitro will handle the #imports resolution at build time
-      nitroConfig.plugins.push(resolver.resolve('./runtime/server/plugins/cron.ts'));
+      // Use pre-compiled JS - Nitro can parse this without TypeScript plugins
+      nitroConfig.plugins.push(resolver.resolve('./runtime/server/plugins/cron.js'));
 
       // Ensure Nitro inlines and transpiles the plugin from node_modules
       nitroConfig.externals = nitroConfig.externals || {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tthr/vue",
-  "version": "0.0.76",
+  "version": "0.0.78",
   "description": "Tether Vue/Nuxt SDK",
   "type": "module",
   "main": "./dist/index.js",
@@ -29,7 +29,6 @@
     "nuxt/module.ts",
     "nuxt/module.js",
     "nuxt/module.js.map",
-    "nuxt/runtime/**/*.ts",
     "nuxt/runtime/**/*.js",
     "nuxt/runtime/**/*.js.map",
     "nuxt/runtime/**/*.d.ts",

package/nuxt/runtime/composables.ts

@@ -1,506 +0,0 @@
-/**
- * Nuxt composables for Tether
- *
- * These are auto-imported when using the Tether Nuxt module.
- * Queries and mutations are executed server-side to keep API keys secure.
- * WebSocket subscriptions run client-side for realtime updates - automatically!
- */
-
-import { ref, onMounted, onUnmounted, computed, type Ref, type ComputedRef } from 'vue';
-import { useAsyncData } from '#imports';
-
-// ============================================================================
-// Shared WebSocket Connection Manager
-// ============================================================================
-
-interface SubscriptionCallback {
-  onData: (data: unknown) => void;
-  onInvalidate: () => void;
-}
-
-interface ConnectionManager {
-  ws: WebSocket | null;
-  subscriptions: Map<string, SubscriptionCallback>;
-  isConnecting: boolean;
-  reconnectTimeout: ReturnType<typeof setTimeout> | null;
-  heartbeatInterval: ReturnType<typeof setInterval> | null;
-  heartbeatTimeout: ReturnType<typeof setTimeout> | null;
-  awaitingPong: boolean;
-  refCount: number;
-}
-
-// Singleton connection manager (client-side only)
-let connectionManager: ConnectionManager | null = null;
-
-function getConnectionManager(): ConnectionManager {
-  if (!connectionManager) {
-    connectionManager = {
-      ws: null,
-      subscriptions: new Map(),
-      isConnecting: false,
-      reconnectTimeout: null,
-      heartbeatInterval: null,
-      heartbeatTimeout: null,
-      awaitingPong: false,
-      refCount: 0,
-    };
-  }
-  return connectionManager;
-}
-
-const HEARTBEAT_INTERVAL = 25000;
-const HEARTBEAT_TIMEOUT = 15000;
-
-function startHeartbeat(cm: ConnectionManager) {
-  stopHeartbeat(cm);
-  cm.heartbeatInterval = setInterval(() => {
-    if (cm.ws?.readyState === WebSocket.OPEN) {
-      cm.awaitingPong = true;
-      cm.ws.send(JSON.stringify({ type: 'ping' }));
-      cm.heartbeatTimeout = setTimeout(() => {
-        if (cm.awaitingPong) {
-          console.warn('[Tether] Heartbeat timeout - forcing reconnect');
-          cm.ws?.close();
-        }
-      }, HEARTBEAT_TIMEOUT);
-    }
-  }, HEARTBEAT_INTERVAL);
-}
-
-function stopHeartbeat(cm: ConnectionManager) {
-  if (cm.heartbeatInterval) {
-    clearInterval(cm.heartbeatInterval);
-    cm.heartbeatInterval = null;
-  }
-  if (cm.heartbeatTimeout) {
-    clearTimeout(cm.heartbeatTimeout);
-    cm.heartbeatTimeout = null;
-  }
-  cm.awaitingPong = false;
-}
-
-function connectWebSocket(cm: ConnectionManager) {
-  if (cm.isConnecting) return;
-  if (cm.ws && (cm.ws.readyState === WebSocket.OPEN || cm.ws.readyState === WebSocket.CONNECTING)) {
-    return;
-  }
-
-  const config = (window as any).__TETHER_CONFIG__;
-  if (!config?.wsUrl || !config?.projectId) {
-    console.warn('[Tether] WebSocket config not available');
-    return;
-  }
-
-  cm.isConnecting = true;
-  const wsUrl = `${config.wsUrl}/ws/${config.projectId}`;
-  cm.ws = new WebSocket(wsUrl);
-
-  cm.ws.onopen = () => {
-    cm.isConnecting = false;
-  };
-
-  cm.ws.onmessage = (event) => {
-    try {
-      const message = JSON.parse(event.data);
-
-      if (message.type === 'connected') {
-        startHeartbeat(cm);
-        // Re-subscribe all active subscriptions
-        for (const [subscriptionId, _callback] of cm.subscriptions) {
-          const [queryName, argsJson] = subscriptionId.split('::');
-          const args = argsJson ? JSON.parse(argsJson) : undefined;
-          cm.ws?.send(JSON.stringify({
-            type: 'subscribe',
-            id: subscriptionId,
-            query: queryName,
-            args,
-          }));
-        }
-      } else if (message.type === 'data') {
-        const callback = cm.subscriptions.get(message.id);
-        if (callback) {
-          callback.onData(message.data);
-        }
-      } else if (message.type === 'invalidate') {
-        const callback = cm.subscriptions.get(message.id);
-        if (callback) {
-          callback.onInvalidate();
-        }
-      } else if (message.type === 'pong') {
-        cm.awaitingPong = false;
-        if (cm.heartbeatTimeout) {
-          clearTimeout(cm.heartbeatTimeout);
-          cm.heartbeatTimeout = null;
-        }
-      }
-    } catch {
-      // Ignore parse errors
-    }
-  };
-
-  cm.ws.onclose = () => {
-    cm.isConnecting = false;
-    stopHeartbeat(cm);
-    // Reconnect if there are still active subscriptions
-    if (cm.subscriptions.size > 0) {
-      cm.reconnectTimeout = setTimeout(() => connectWebSocket(cm), 3000);
-    }
-  };
-
-  cm.ws.onerror = () => {
-    cm.isConnecting = false;
-    cm.ws?.close();
-  };
-}
-
-function subscribe(
-  queryName: string,
-  args: Record<string, unknown> | undefined,
-  callbacks: SubscriptionCallback
-): () => void {
-  const cm = getConnectionManager();
-  const subscriptionId = `${queryName}::${JSON.stringify(args ?? {})}`;
-
-  cm.subscriptions.set(subscriptionId, callbacks);
-  cm.refCount++;
-
-  // Connect if not already connected
-  if (!cm.ws || cm.ws.readyState === WebSocket.CLOSED) {
-    connectWebSocket(cm);
-  } else if (cm.ws.readyState === WebSocket.OPEN) {
-    // Already connected - subscribe immediately
-    cm.ws.send(JSON.stringify({
-      type: 'subscribe',
-      id: subscriptionId,
-      query: queryName,
-      args,
-    }));
-  }
-
-  // Return cleanup function
-  return () => {
-    cm.subscriptions.delete(subscriptionId);
-    cm.refCount--;
-
-    // Unsubscribe from server
-    if (cm.ws?.readyState === WebSocket.OPEN) {
-      cm.ws.send(JSON.stringify({
-        type: 'unsubscribe',
-        id: subscriptionId,
-      }));
-    }
-
-    // Close connection if no more subscriptions
-    if (cm.refCount === 0) {
-      if (cm.reconnectTimeout) {
-        clearTimeout(cm.reconnectTimeout);
-        cm.reconnectTimeout = null;
-      }
-      stopHeartbeat(cm);
-      cm.ws?.close();
-      cm.ws = null;
-    }
-  };
-}
-
-// Handle visibility changes globally
-if (typeof window !== 'undefined') {
-  document.addEventListener('visibilitychange', () => {
-    if (document.visibilityState === 'visible') {
-      const cm = connectionManager;
-      if (cm && cm.subscriptions.size > 0) {
-        if (!cm.ws || cm.ws.readyState === WebSocket.CLOSED) {
-          if (cm.reconnectTimeout) {
-            clearTimeout(cm.reconnectTimeout);
-            cm.reconnectTimeout = null;
-          }
-          connectWebSocket(cm);
-        }
-      }
-    }
-  });
-}
-
-// ============================================================================
-// Query Composable
-// ============================================================================
-
-/**
- * Query state returned by useQuery
- */
-export interface QueryState<T> {
-  data: Ref<T | undefined>;
-  error: Ref<Error | null>;
-  isLoading: ComputedRef<boolean>;
-  isConnected: Ref<boolean>;
-  refetch: () => Promise<void>;
-}
-
-/**
- * Query function reference
- */
-export interface QueryFunction<TArgs = void, TResult = unknown> {
-  _name: string;
-  _args?: TArgs;
-  _result?: TResult;
-}
-
-/**
- * Reactive query composable with automatic realtime updates
- *
- * Uses Nuxt's useAsyncData internally for proper SSR support.
- * Data is fetched on the server and hydrated on the client.
- * Automatically subscribes to WebSocket updates for realtime sync.
- *
- * @example
- * ```vue
- * <script setup>
- * // That's it! Data automatically updates when it changes anywhere
- * const { data: posts, isLoading, isConnected } = useQuery(api.posts.list);
- * </script>
- * ```
- */
-export function useQuery<TArgs, TResult>(
-  query: QueryFunction<TArgs, TResult> | string,
-  args?: TArgs
-): QueryState<TResult> {
-  const queryName = typeof query === 'string' ? query : query._name;
-  const queryArgs = args as Record<string, unknown> | undefined;
-
-  // Create a unique key for this query based on name and args
-  const queryKey = `tether-${queryName}-${JSON.stringify(args ?? {})}`;
-
-  // Track WebSocket connection state
-  const isConnected = ref(false);
-
-  // Use Nuxt's useAsyncData for proper SSR support
-  const { data, error: asyncError, status, refresh } = useAsyncData<TResult>(
-    queryKey,
-    async () => {
-      const response = await $fetch<{ data: TResult }>('/api/_tether/query', {
-        method: 'POST',
-        body: {
-          function: queryName,
-          args,
-        },
-      });
-      return response.data;
-    },
-    {
-      dedupe: 'cancel',
-    }
-  );
-
-  // Wrap the error as a computed ref
-  const error = computed(() => {
-    if (asyncError.value) {
-      return asyncError.value instanceof Error
-        ? asyncError.value
-        : new Error(String(asyncError.value));
-    }
-    return null;
-  });
-
-  // Compute isLoading from status
-  const isLoading = computed(() => status.value === 'pending');
-
-  // Refetch function
-  const refetch = async () => {
-    await refresh();
-  };
-
-  // Auto-subscribe on client side
-  if (import.meta.client) {
-    let unsubscribe: (() => void) | null = null;
-
-    onMounted(() => {
-      unsubscribe = subscribe(queryName, queryArgs, {
-        onData: (newData) => {
-          data.value = newData as TResult;
-        },
-        onInvalidate: () => {
-          refresh();
-        },
-      });
-
-      // Track connection state
-      const checkConnection = () => {
-        const cm = connectionManager;
-        isConnected.value = cm?.ws?.readyState === WebSocket.OPEN ?? false;
-      };
-      checkConnection();
-      const interval = setInterval(checkConnection, 1000);
-      onUnmounted(() => clearInterval(interval));
-    });
-
-    onUnmounted(() => {
-      unsubscribe?.();
-    });
-  }
-
-  return {
-    data: data as Ref<TResult | undefined>,
-    error: error as unknown as Ref<Error | null>,
-    isLoading,
-    isConnected,
-    refetch,
-  };
-}
-
-// ============================================================================
-// Mutation Composable
-// ============================================================================
-
-/**
- * Mutation state returned by useMutation
- */
-export interface MutationState<TArgs, TResult> {
-  data: Ref<TResult | undefined>;
-  error: Ref<Error | null>;
-  isPending: Ref<boolean>;
-  mutate: (args: TArgs) => Promise<TResult>;
-  reset: () => void;
-}
-
-/**
- * Mutation function reference
- */
-export interface MutationFunction<TArgs = void, TResult = unknown> {
-  _name: string;
-  _args?: TArgs;
-  _result?: TResult;
-}
-
-/**
- * Mutation composable
- *
- * @example
- * ```vue
- * <script setup>
- * const { mutate: createPost, isPending } = useMutation(api.posts.create);
- *
- * async function handleSubmit() {
- *   await createPost({ title: 'Hello', content: '...' });
- *   // All useQuery subscribers automatically update!
- * }
- * </script>
- * ```
- */
-export function useMutation<TArgs, TResult>(
-  mutation: MutationFunction<TArgs, TResult> | string
-): MutationState<TArgs, TResult> {
-  const mutationName = typeof mutation === 'string' ? mutation : mutation._name;
-  const data = ref<TResult>();
-  const error = ref<Error | null>(null);
-  const isPending = ref(false);
-
-  const mutate = async (args: TArgs): Promise<TResult> => {
-    try {
-      isPending.value = true;
-      error.value = null;
-
-      const response = await $fetch<{ data: TResult }>('/api/_tether/mutation', {
-        method: 'POST',
-        body: {
-          function: mutationName,
-          args,
-        },
-      });
-
-      data.value = response.data;
-      return response.data;
-    } catch (e) {
-      error.value = e instanceof Error ? e : new Error(String(e));
-      throw e;
-    } finally {
-      isPending.value = false;
-    }
-  };
-
-  const reset = () => {
-    data.value = undefined;
-    error.value = null;
-    isPending.value = false;
-  };
-
-  return {
-    data: data as Ref<TResult | undefined>,
-    error,
-    isPending,
-    mutate,
-    reset,
-  };
-}
-
-// ============================================================================
-// Manual Subscription (for advanced use cases)
-// ============================================================================
-
-/**
- * Subscription handler options
- */
-export interface SubscriptionHandlers {
-  /** Called when fresh data is received from the server */
-  onData?: (data: unknown) => void;
-  /** Called when server invalidates the subscription (signals to refetch) */
-  onInvalidate?: () => void;
-}
-
-/**
- * Manual WebSocket subscription composable
- *
- * NOTE: You typically don't need this! useQuery automatically subscribes to updates.
- * This is only for advanced use cases where you need custom subscription handling.
- *
- * @example
- * ```vue
- * <script setup>
- * // For custom subscription handling (rare)
- * const { isConnected } = useTetherSubscription('custom.query', {}, {
- *   onData: (data) => console.log('Got data:', data),
- *   onInvalidate: () => console.log('Data invalidated'),
- * });
- * </script>
- * ```
- */
-export function useTetherSubscription(
-  queryName: string,
-  args: Record<string, unknown> | undefined,
-  handlers: SubscriptionHandlers | ((data?: unknown) => void)
-): { isConnected: Ref<boolean> } {
-  const isConnected = ref(false);
-
-  // Normalize handlers
-  const onData = typeof handlers === 'function'
-    ? handlers
-    : handlers.onData ?? (() => {});
-  const onInvalidate = typeof handlers === 'function'
-    ? () => handlers(undefined)
-    : handlers.onInvalidate ?? (() => {});
-
-  if (import.meta.client) {
-    let unsubscribe: (() => void) | null = null;
-
-    onMounted(() => {
-      unsubscribe = subscribe(queryName, args, {
-        onData,
-        onInvalidate,
-      });
-
-      // Track connection state
-      const checkConnection = () => {
-        const cm = connectionManager;
-        isConnected.value = cm?.ws?.readyState === WebSocket.OPEN ?? false;
-      };
-      checkConnection();
-      const interval = setInterval(checkConnection, 1000);
-      onUnmounted(() => clearInterval(interval));
-    });
-
-    onUnmounted(() => {
-      unsubscribe?.();
-    });
-  }
-
-  return { isConnected };
-}

package/nuxt/runtime/plugin.client.ts

@@ -1,34 +0,0 @@
-/**
- * Client-side Tether plugin
- *
- * Sets up the WebSocket configuration for realtime subscriptions.
- * This only exposes the project ID and WebSocket URL - no secrets.
- */
-
-import { defineNuxtPlugin, useRuntimeConfig } from '#imports';
-
-declare global {
-  interface Window {
-    __TETHER_CONFIG__?: {
-      projectId: string;
-      wsUrl: string;
-    };
-  }
-}
-
-export default defineNuxtPlugin(() => {
-  const config = useRuntimeConfig();
-
-  // Make config available for WebSocket connections
-  // This is safe - no secrets are exposed
-  const tetherConfig = {
-    projectId: config.public.tether?.projectId || '',
-    wsUrl: config.public.tether?.wsUrl || '',
-  };
-
-  window.__TETHER_CONFIG__ = tetherConfig;
-
-  if (!tetherConfig.wsUrl || !tetherConfig.projectId) {
-    console.warn('[Tether] Config incomplete - WebSocket subscriptions will not work');
-  }
-});

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

@@ -1,377 +0,0 @@
-/**
- * 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;
-    }
-  });
-});