@tthr/vue 0.0.83 → 0.0.84

package/nuxt/runtime/composables.js

@@ -5,8 +5,26 @@
  * 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, watch } from 'vue';
+import { ref, onMounted, onUnmounted, computed, watch, toRaw, isRef } from 'vue';
 import { useAsyncData } from '#imports';
+/**
+ * Recursively unwrap Vue reactive proxies and refs so the value is
+ * safe to pass to JSON.stringify (no circular Vue internals).
+ */
+function toPlainArgs(value) {
+    if (value == null || typeof value !== 'object')
+        return value;
+    const raw = toRaw(value);
+    if (isRef(raw))
+        return toPlainArgs(raw.value);
+    if (Array.isArray(raw))
+        return raw.map(toPlainArgs);
+    const out = {};
+    for (const key of Object.keys(raw)) {
+        out[key] = toPlainArgs(raw[key]);
+    }
+    return out;
+}
 // Singleton connection manager (client-side only)
 let connectionManager = null;
 function getConnectionManager() {
@@ -125,7 +143,8 @@ function connectWebSocket(cm) {
 }
 function subscribe(queryName, args, callbacks) {
     const cm = getConnectionManager();
-    const subscriptionId = `${queryName}::${JSON.stringify(args ?? {})}`;
+    const plainArgs = toPlainArgs(args);
+    const subscriptionId = `${queryName}::${JSON.stringify(plainArgs ?? {})}`;
     cm.subscriptions.set(subscriptionId, callbacks);
     cm.refCount++;
     // Connect if not already connected
@@ -138,7 +157,7 @@ function subscribe(queryName, args, callbacks) {
             type: 'subscribe',
             id: subscriptionId,
             query: queryName,
-            args,
+            args: plainArgs,
         }));
     }
     // Return cleanup function
@@ -188,19 +207,25 @@ if (typeof window !== 'undefined') {
  * Data is fetched on the server and hydrated on the client.
  * Automatically subscribes to WebSocket updates for realtime sync.
  *
+ * Can be used with or without await:
+ *
  * @example
  * ```vue
  * <script setup>
- * // That's it! Data automatically updates when it changes anywhere
+ * // Reactive — data fills in asynchronously, updates in realtime
  * const { data: posts, isLoading, isConnected } = useQuery(api.posts.list);
+ *
+ * // Awaited — data is populated when the promise resolves, still updates in realtime
+ * const { data: posts } = await useQuery(api.posts.list);
  * </script>
  * ```
  */
 export function useQuery(query, args) {
     const queryName = typeof query === 'string' ? query : query._name;
-    const queryArgs = args;
+    const plainArgs = toPlainArgs(args);
+    const queryArgs = plainArgs;
     // Create a unique key for this query based on name and args
-    const queryKey = `tether-${queryName}-${JSON.stringify(args ?? {})}`;
+    const queryKey = `tether-${queryName}-${JSON.stringify(plainArgs ?? {})}`;
     // Track WebSocket connection state
     const isConnected = ref(false);
     // Use Nuxt's useAsyncData for proper SSR support
@@ -209,7 +234,7 @@ export function useQuery(query, args) {
             method: 'POST',
             body: {
                 function: queryName,
-                args,
+                args: plainArgs,
             },
         });
         return response.data;
@@ -265,6 +290,8 @@ export function useQuery(query, args) {
         refetch,
     };
     // Create a promise that resolves when the initial fetch completes.
+    // On SSR or hydration, status is already not 'pending', so it resolves immediately.
+    // On client-side navigation, it waits for the fetch to finish.
     const initialFetchPromise = new Promise((resolve) => {
         if (status.value !== 'pending') {
             resolve(state);
@@ -280,16 +307,36 @@ export function useQuery(query, args) {
     // Merge the promise onto the state object so it's both destructurable and thenable
     return Object.assign(initialFetchPromise, state);
 }
+// ============================================================================
+// Standalone Query Function
+// ============================================================================
 /**
  * Execute a query and return raw data directly.
+ *
+ * Unlike useQuery, this does NOT set up reactive state or WebSocket subscriptions.
+ * Use this in event handlers, utilities, or anywhere you need a one-shot data fetch.
+ * Proxies through the Nuxt server route to keep API keys secure.
+ *
+ * @example
+ * ```ts
+ * // In an event handler
+ * async function loadMessages(channelId: string) {
+ *   const messages = await $query(api.messages.listByChannel, { channelId });
+ *   return messages;
+ * }
+ *
+ * // With a string name
+ * const posts = await $query('posts.list', { limit: 10 });
+ * ```
  */
 export async function $query(query, args) {
     const queryName = typeof query === 'string' ? query : query._name;
+    const plainArgs = toPlainArgs(args);
     const response = await $fetch('/api/_tether/query', {
         method: 'POST',
         body: {
             function: queryName,
-            args,
+            args: plainArgs,
         },
     });
     return response.data;
@@ -322,7 +369,7 @@ export function useMutation(mutation) {
                 method: 'POST',
                 body: {
                     function: mutationName,
-                    args,
+                    args: toPlainArgs(args),
                 },
             });
             data.value = response.data;
@@ -349,16 +396,36 @@ export function useMutation(mutation) {
         reset,
     };
 }
+// ============================================================================
+// Standalone Mutation Function
+// ============================================================================
 /**
  * Execute a mutation and return the result directly.
+ *
+ * Unlike useMutation, this does NOT set up reactive state.
+ * Use this in event handlers, utilities, or anywhere you need a one-shot mutation.
+ * Proxies through the Nuxt server route to keep API keys secure.
+ *
+ * @example
+ * ```ts
+ * // In an event handler
+ * async function handleCreate() {
+ *   const post = await $mutation(api.posts.create, { title: 'Hello' });
+ *   console.log('Created:', post);
+ * }
+ *
+ * // With a string name
+ * const result = await $mutation('posts.delete', { id: 123 });
+ * ```
  */
 export async function $mutation(mutation, args) {
     const mutationName = typeof mutation === 'string' ? mutation : mutation._name;
+    const plainArgs = toPlainArgs(args);
     const response = await $fetch('/api/_tether/mutation', {
         method: 'POST',
         body: {
             function: mutationName,
-            args,
+            args: plainArgs,
         },
     });
     return response.data;
@@ -411,4 +478,3 @@ export function useTetherSubscription(queryName, args, handlers) {
     }
     return { isConnected };
 }
-//# sourceMappingURL=composables.js.map

package/nuxt/runtime/plugin.client.js

@@ -18,4 +18,3 @@ export default defineNuxtPlugin(() => {
         console.warn('[Tether] Config incomplete - WebSocket subscriptions will not work');
     }
 });
-//# sourceMappingURL=plugin.client.js.map

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

@@ -1,21 +1,17 @@
 /**
  * Nuxt server plugin for Tether cron execution
  *
- * This plugin automatically connects to Tether via WebSocket as a server connection
- * to receive cron triggers. When a cron is due, Tether sends a trigger message,
- * this plugin executes the function, and reports the result back.
- *
- * The connection is secured with the API key and only server connections
- * (identified by ?type=server) receive cron triggers.
+ * 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 registered cron handlers
+// Store for manually registered cron handlers
 const cronHandlers = new Map();
 // Dynamic function registry - populated on first cron trigger
 let functionRegistry = null;
-let registryError = null;
 // WebSocket connection state
 let ws = null;
 let connectionId = null;
@@ -26,35 +22,19 @@ let awaitingPong = false;
 let shouldReconnect = true;
 let verboseLogging = false;
 const MAX_RECONNECT_ATTEMPTS = 10;
-const HEARTBEAT_INTERVAL = 20000; // 20 seconds - keeps connection alive through proxies with 30s idle timeout
+const HEARTBEAT_INTERVAL = 20000;
 const HEARTBEAT_TIMEOUT = 10000;
 const RECONNECT_DELAY = 1000;
 const PREFIX = '[Tether Cron]';
-/** Simple logger that respects verbose flag */
 const log = {
-    /** Debug messages - only shown when verbose is enabled */
     debug: (...args) => { if (verboseLogging)
         console.log(PREFIX, ...args); },
-    /** Info messages - always shown */
     info: (...args) => console.log(PREFIX, ...args),
-    /** Warning messages - always shown */
     warn: (...args) => console.warn(PREFIX, ...args),
-    /** Error messages - always shown */
     error: (...args) => console.error(PREFIX, ...args),
 };
 /**
  * Register a cron handler for a specific function
- *
- * @example
- * ```ts
- * // In your Nuxt server setup
- * import { registerCronHandler } from '#imports';
- *
- * registerCronHandler('reports.generate', async (args) => {
- *   // Your function logic here
- *   return { generated: true };
- * });
- * ```
  */
 export function registerCronHandler(functionName, handler) {
     cronHandlers.set(functionName, handler);
@@ -76,27 +56,13 @@ export function getCronHandlers() {
  * Load user's custom functions from ~/tether/functions
  */
 async function loadFunctionRegistry() {
-    if (functionRegistry !== null || registryError !== null) {
+    if (functionRegistry !== null)
         return;
-    }
     try {
-        log.debug('Loading custom functions from ~~/tether/functions/index.ts');
-        const functions = await import('~~/tether/functions/index.ts').catch((err) => {
-            log.debug('Failed to import functions:', err.message);
-            return null;
-        });
-        if (functions) {
-            log.debug('Loaded function modules:', Object.keys(functions));
-            functionRegistry = functions;
-        }
-        else {
-            log.debug('No custom functions found');
-            functionRegistry = {};
-        }
+        const functions = await import('~~/tether/functions/index.ts').catch(() => null);
+        functionRegistry = functions ?? {};
     }
-    catch (error) {
-        log.debug('Could not load custom functions:', error instanceof Error ? error.message : String(error));
-        registryError = error instanceof Error ? error : new Error(String(error));
+    catch {
         functionRegistry = {};
     }
 }
@@ -114,197 +80,30 @@ function lookupFunction(name) {
     if (!module)
         return null;
     const fn = module[fnName];
-    // Check if it's a valid Tether function (has a handler)
     if (fn && typeof fn === 'object' && typeof fn.handler === 'function') {
         return fn;
     }
     return null;
 }
-/**
- * Create a database proxy that routes calls to Tether's CRUD endpoints
- */
-function createDatabaseProxy(apiKey, url, projectId, environment) {
-    const base = url.replace(/\/$/, '');
-    let apiPath;
-    if (environment && environment !== 'production') {
-        apiPath = `${base}/api/v1/projects/${projectId}/env/${environment}`;
-    }
-    else {
-        apiPath = `${base}/api/v1/projects/${projectId}`;
-    }
-    return new Proxy({}, {
-        get(_target, tableName) {
-            const makeRequest = async (operation, args) => {
-                const response = await fetch(`${apiPath}/query`, {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        'Authorization': `Bearer ${apiKey}`,
-                    },
-                    body: JSON.stringify({
-                        function: `${tableName}.${operation}`,
-                        args,
-                    }),
-                });
-                if (!response.ok) {
-                    const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-                    throw new Error(error.error || `Database operation failed: ${tableName}.${operation}`);
-                }
-                const result = await response.json();
-                return result.data;
-            };
-            const makeMutation = async (operation, args) => {
-                const response = await fetch(`${apiPath}/mutation`, {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        'Authorization': `Bearer ${apiKey}`,
-                    },
-                    body: JSON.stringify({
-                        function: `${tableName}.${operation}`,
-                        args,
-                    }),
-                });
-                if (!response.ok) {
-                    const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-                    throw new Error(error.error || `Database operation failed: ${tableName}.${operation}`);
-                }
-                const result = await response.json();
-                return result.data;
-            };
-            return {
-                findMany: async (options) => {
-                    const args = {};
-                    if (options?.where)
-                        args.where = options.where;
-                    if (options?.limit)
-                        args.limit = options.limit;
-                    if (options?.offset)
-                        args.offset = options.offset;
-                    if (options?.orderBy) {
-                        if (typeof options.orderBy === 'string') {
-                            args.orderBy = options.orderBy;
-                        }
-                        else if (typeof options.orderBy === 'object') {
-                            const entries = Object.entries(options.orderBy);
-                            if (entries.length > 0) {
-                                const [column, dir] = entries[0];
-                                args.orderBy = column;
-                                args.orderDir = dir?.toUpperCase?.() || 'ASC';
-                            }
-                        }
-                    }
-                    if (options?.orderDir)
-                        args.orderDir = options.orderDir;
-                    return makeRequest('list', args);
-                },
-                findFirst: async (options) => {
-                    const args = { limit: 1 };
-                    if (options?.where)
-                        args.where = options.where;
-                    const results = await makeRequest('list', args);
-                    return Array.isArray(results) ? results[0] ?? null : null;
-                },
-                findUnique: async (options) => {
-                    const args = { limit: 1 };
-                    if (options?.where)
-                        args.where = options.where;
-                    const results = await makeRequest('list', args);
-                    return Array.isArray(results) ? results[0] ?? null : null;
-                },
-                findById: async (id) => {
-                    return makeRequest('get', { id });
-                },
-                count: async (options) => {
-                    const args = {};
-                    if (options?.where)
-                        args.where = options.where;
-                    const result = await makeRequest('count', args);
-                    return result?.count ?? 0;
-                },
-                insert: async (data) => {
-                    return makeMutation('create', { data });
-                },
-                insertMany: async (items) => {
-                    const results = [];
-                    for (const data of items) {
-                        const result = await makeMutation('create', { data });
-                        results.push(result);
-                    }
-                    return results;
-                },
-                create: async (options) => {
-                    return makeMutation('create', { data: options.data });
-                },
-                update: async (options) => {
-                    const id = options.where?.id;
-                    if (!id)
-                        throw new Error('Update requires an id in the where clause');
-                    const result = await makeMutation('update', { id, data: options.data });
-                    return result?.rowsAffected ?? 0;
-                },
-                upsert: async (options) => {
-                    // Try to find existing record using the where clause
-                    // This allows upserting on any field (e.g. clip_id, email, etc.)
-                    // Use list with limit: 1 since findFirst doesn't exist on the server
-                    const results = await makeRequest('list', { where: options.where, limit: 1 }).catch(() => []);
-                    const existing = results?.[0] ?? null;
-                    if (existing) {
-                        // Use _id from the found record for the update
-                        const id = existing._id ?? existing.id;
-                        if (!id)
-                            throw new Error('Found record has no _id or id field for update');
-                        await makeMutation('update', { id, data: options.update });
-                        return { ...existing, ...options.update };
-                    }
-                    else {
-                        return makeMutation('create', { data: options.create });
-                    }
-                },
-                delete: async (options) => {
-                    const id = options.where?.id;
-                    if (!id)
-                        throw new Error('Delete requires an id in the where clause');
-                    const result = await makeMutation('delete', { id });
-                    return result?.rowsAffected ?? 0;
-                },
-                deleteById: async (id) => {
-                    const result = await makeMutation('delete', { id });
-                    return (result?.rowsAffected ?? 0) > 0;
-                },
-            };
-        },
-    });
-}
 function getWsUrl(config) {
     const base = config.url
         .replace('https://', 'wss://')
         .replace('http://', 'ws://')
         .replace(/\/$/, '');
     const env = config.environment;
-    let wsPath;
-    if (env && env !== 'production') {
-        wsPath = `${base}/ws/${config.projectId}/${env}`;
-    }
-    else {
-        wsPath = `${base}/ws/${config.projectId}`;
-    }
-    // Add type=server to identify as server connection and token for auth
+    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, trigger, result, durationMs) {
     const base = config.url.replace(/\/$/, '');
     const env = config.environment;
-    let apiPath;
-    if (env && env !== 'production') {
-        apiPath = `${base}/api/v1/projects/${config.projectId}/env/${env}`;
-    }
-    else {
-        apiPath = `${base}/api/v1/projects/${config.projectId}`;
-    }
-    const url = `${apiPath}/crons/${trigger.cronId}/executions`;
+    const apiPath = env && env !== 'production'
+        ? `${base}/api/v1/projects/${config.projectId}/env/${env}`
+        : `${base}/api/v1/projects/${config.projectId}`;
     try {
-        const response = await fetch(url, {
+        const response = await fetch(`${apiPath}/crons/${trigger.cronId}/executions`, {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
@@ -319,86 +118,13 @@ async function reportExecution(config, trigger, result, durationMs) {
             }),
         });
         if (!response.ok) {
-            log.error(`Failed to report execution: ${response.status} ${response.statusText}`);
-        }
-        else {
-            log.debug(`Reported execution ${trigger.executionId}: ${result.success ? 'success' : 'failed'}`);
+            log.error(`Failed to report execution: ${response.status}`);
         }
     }
     catch (error) {
         log.error('Failed to report execution:', error);
     }
 }
-/**
- * Execute a function via the Tether API
- * This is used when no local handler is registered - the function is executed
- * on the Tether server which has access to the database and environment.
- *
- * Tries endpoints in order based on functionType hint, with fallback to other
- * types if the first attempt fails with a type mismatch error.
- */
-async function executeViaApi(config, functionName, functionType, args) {
-    const base = config.url.replace(/\/$/, '');
-    const env = config.environment;
-    let apiPath;
-    if (env && env !== 'production') {
-        apiPath = `${base}/api/v1/projects/${config.projectId}/env/${env}`;
-    }
-    else {
-        apiPath = `${base}/api/v1/projects/${config.projectId}`;
-    }
-    // Order endpoints to try based on functionType hint
-    const endpointTypes = ['mutation', 'query'];
-    // Move the hinted type to the front if valid
-    if (functionType && endpointTypes.includes(functionType)) {
-        endpointTypes.splice(endpointTypes.indexOf(functionType), 1);
-        endpointTypes.unshift(functionType);
-    }
-    let lastError = null;
-    for (const type of endpointTypes) {
-        const endpoint = `${apiPath}/${type}`;
-        try {
-            const response = await fetch(endpoint, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'Authorization': `Bearer ${config.apiKey}`,
-                },
-                body: JSON.stringify({ function: functionName, args }),
-            });
-            if (!response.ok) {
-                const responseText = await response.text();
-                let errorMsg;
-                try {
-                    const error = JSON.parse(responseText);
-                    errorMsg = error.error || error.message || `Function '${functionName}' failed with status ${response.status}`;
-                }
-                catch {
-                    errorMsg = responseText || `Function '${functionName}' failed with status ${response.status}`;
-                }
-                log.debug(`/${type} endpoint returned ${response.status}: ${errorMsg}`);
-                // If it's a type mismatch error, try the next endpoint
-                if (errorMsg.includes('not a') && errorMsg.includes("it's a")) {
-                    log.debug(`Function type mismatch on /${type}, trying next endpoint...`);
-                    lastError = new Error(errorMsg);
-                    continue;
-                }
-                throw new Error(errorMsg);
-            }
-            const result = await response.json();
-            return result.data;
-        }
-        catch (error) {
-            if (error instanceof Error && error.message.includes('not a') && error.message.includes("it's a")) {
-                lastError = error;
-                continue;
-            }
-            throw error;
-        }
-    }
-    // All endpoints failed
-    throw lastError || new Error(`Function '${functionName}' failed on all endpoints`);
-}
 async function handleCronTrigger(config, trigger) {
     log.info(`Received trigger for ${trigger.functionName} (execution: ${trigger.executionId})`);
     const startTime = Date.now();
@@ -411,70 +137,33 @@ async function handleCronTrigger(config, trigger) {
             result = await handler(trigger.args);
         }
         else {
-            // 2. Try to load and execute from user's tether/functions
+            // 2. Load and execute from user's tether/functions using executeFunction
             await loadFunctionRegistry();
-            const localFn = lookupFunction(trigger.functionName);
-            if (localFn) {
-                log.debug(`Executing local function: ${trigger.functionName}`);
-                // Create execution context with database proxy
-                const db = createDatabaseProxy(config.apiKey, config.url, config.projectId, config.environment);
-                // Create a simple logger for the function
-                const fnLog = {
-                    log: (...args) => log.info(`[${trigger.functionName}]`, ...args),
-                    debug: (...args) => log.debug(`[${trigger.functionName}]`, ...args),
-                    info: (...args) => log.info(`[${trigger.functionName}]`, ...args),
-                    warn: (...args) => log.warn(`[${trigger.functionName}]`, ...args),
-                    error: (...args) => log.error(`[${trigger.functionName}]`, ...args),
-                };
-                // Create tether context with env vars from process.env
-                // Note: For cron execution, env vars should be set in the Nuxt app's environment
-                const processEnv = globalThis.process?.env ?? {};
-                const tether = {
-                    env: new Proxy({}, {
-                        get(_target, key) {
-                            return processEnv[key];
-                        },
-                    }),
-                };
-                // Execute the function with context
-                result = await localFn.handler({
-                    db,
-                    args: trigger.args ?? {},
-                    log: fnLog,
-                    tether,
-                    ctx: { auth: { userId: null, claims: {} }, userId: null },
-                    auth: { getUserIdentity: async () => null },
-                });
+            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, trigger.args ?? {});
             }
             else {
-                // 3. Fall back to API for generic CRUD operations (table.operation)
-                log.debug(`Executing via API: ${trigger.functionName} (${trigger.functionType})`);
-                result = await executeViaApi(config, trigger.functionName, trigger.functionType, trigger.args);
+                throw new Error(`Function '${trigger.functionName}' not found`);
             }
         }
         const durationMs = Date.now() - startTime;
-        await reportExecution(config, trigger, {
-            success: true,
-            result,
-        }, durationMs);
+        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);
+        await reportExecution(config, trigger, { success: false, error: errorMessage }, durationMs);
     }
 }
 function startHeartbeat() {
     stopHeartbeat();
     heartbeatTimer = setInterval(() => {
-        // WebSocket.OPEN = 1
-        if (ws?.readyState === 1) {
+        if (ws?.readyState === 1) { // WebSocket.OPEN
             awaitingPong = true;
-            log.debug('Sending heartbeat ping');
             ws.send(JSON.stringify({ type: 'ping' }));
             heartbeatTimeoutTimer = setTimeout(() => {
                 if (awaitingPong) {
@@ -483,9 +172,6 @@ function startHeartbeat() {
                 }
             }, HEARTBEAT_TIMEOUT);
         }
-        else {
-            log.warn(`Cannot send ping - WebSocket state: ${ws?.readyState}`);
-        }
     }, HEARTBEAT_INTERVAL);
 }
 function stopHeartbeat() {
@@ -508,7 +194,6 @@ async function getWebSocketImpl() {
         WebSocketImpl = WebSocket;
     }
     else {
-        // Dynamic import for Node.js ESM compatibility
         const wsModule = await import('ws');
         WebSocketImpl = wsModule.default;
     }
@@ -540,7 +225,6 @@ async function connect(config) {
                         await handleCronTrigger(config, message);
                         break;
                     case 'pong':
-                        log.debug('Received pong');
                         awaitingPong = false;
                         if (heartbeatTimeoutTimer) {
                             clearTimeout(heartbeatTimeoutTimer);
@@ -557,57 +241,57 @@ async function connect(config) {
             }
         };
         ws.onerror = (error) => {
-            const err = error instanceof Error ? error : new Error('WebSocket error');
-            log.error('WebSocket error:', err.message);
+            // 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) => {
             connectionId = null;
             stopHeartbeat();
-            log.debug(`WebSocket disconnected (code: ${event.code}, reason: ${event.reason || 'none'})`);
+            log.debug(`Disconnected (code: ${event.code})`);
             handleReconnect(config);
         };
     }
     catch (error) {
-        log.error('Failed to connect:', error);
+        log.debug('Failed to connect:', error);
         handleReconnect(config);
     }
 }
 function handleReconnect(config) {
-    if (!shouldReconnect) {
-        return;
-    }
-    if (reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
-        log.error('Max reconnection attempts reached');
+    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);
-    log.debug(`Reconnecting in ${delay}ms (attempt ${reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS})`);
     setTimeout(() => {
-        connect(config).catch((err) => log.error('Reconnect failed:', err));
+        connect(config).catch((err) => log.debug('Reconnect failed:', err));
     }, delay);
 }
 export default defineNitroPlugin((nitro) => {
-    // Get config from environment variables
-    // Note: We use process.env directly instead of useRuntimeConfig to avoid #imports dependency
-    // The Nuxt module sets these from runtime config, but they can also be set directly
     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';
-    // Only connect if we have all required config
     if (!apiKey || !projectId) {
-        log.debug('Missing config (apiKey or projectId) - cron connection disabled');
+        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 };
-    // Connect on next tick to allow the server to fully initialise
     process.nextTick(() => {
         connect(config).catch((err) => log.error('Initial connect failed:', err));
     });
-    // Clean up on shutdown
     nitro.hooks.hook('close', () => {
         shouldReconnect = false;
         stopHeartbeat();
@@ -615,7 +299,5 @@ export default defineNitroPlugin((nitro) => {
             ws.close();
             ws = null;
         }
-        log.debug('Connection closed');
     });
 });
-//# sourceMappingURL=cron.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tthr/vue",
-  "version": "0.0.83",
+  "version": "0.0.84",
   "description": "Tether Vue/Nuxt SDK",
   "type": "module",
   "main": "./dist/index.js",