@tthr/vue 0.0.41 → 0.0.45

package/nuxt/module.js

@@ -18,7 +18,7 @@
  * Environment variables (in .env):
  * - TETHER_API_KEY: Your project's API key (required, kept server-side)
  */
-import { defineNuxtModule, addPlugin, createResolver, addImports, addComponent, addServerHandler, addServerImports } from '@nuxt/kit';
+import { defineNuxtModule, addPlugin, createResolver, addImports, addComponent, addServerHandler, addServerImports, addTemplate } from '@nuxt/kit';
 export default defineNuxtModule({
     meta: {
         name: '@tthr/vue',
@@ -38,6 +38,7 @@ export default defineNuxtModule({
         const apiKey = process.env.TETHER_API_KEY || '';
         const url = options.url || process.env.TETHER_URL || 'https://tether-api.strands.gg';
         const projectId = options.projectId || process.env.TETHER_PROJECT_ID || '';
+        const verbose = options.verbose ?? (process.env.TETHER_VERBOSE === 'true');
         // Calculate WebSocket URL from HTTP URL
         const wsUrl = url.replace(/^https:/, 'wss:').replace(/^http:/, 'ws:');
         // Server-side config (includes API key - never exposed to client)
@@ -45,10 +46,12 @@ export default defineNuxtModule({
         // - NUXT_TETHER_API_KEY
         // - NUXT_TETHER_URL
         // - NUXT_TETHER_PROJECT_ID
+        // - NUXT_TETHER_VERBOSE
         nuxt.options.runtimeConfig.tether = {
             apiKey,
             url,
             projectId,
+            verbose,
         };
         // Public config (safe for client - no secrets)
         // Can be overridden at runtime via:
@@ -128,5 +131,144 @@ export default defineNuxtModule({
             nitroConfig.externals.inline = nitroConfig.externals.inline || [];
             nitroConfig.externals.inline.push('@tthr/vue');
         });
+        // Generate a server plugin to auto-register cron handlers from tether/functions
+        // This runs at build time and creates a plugin that imports user's functions
+        addTemplate({
+            filename: 'server/plugins/tether-functions.ts',
+            write: true,
+            getContents: () => `
+/**
+ * Auto-generated plugin to register Tether functions as cron handlers
+ * This file is generated by @tthr/vue/nuxt module
+ */
+import { defineNitroPlugin } from 'nitropack/runtime';
+import { registerCronHandler } from '@tthr/vue/nuxt/runtime/server/plugins/cron.js';
+import { useTetherServer } from '@tthr/vue/nuxt/runtime/server/utils/tether.js';
+
+// Import all functions from tether/functions
+// @ts-ignore - user's functions may not exist yet
+import * as tetherFunctions from '~/tether/functions';
+
+/**
+ * Create a simple logger for function execution
+ */
+function createLogger(functionName: string) {
+  const prefix = \`[Tether] \${functionName}\`;
+  return {
+    log: (msg: string, data?: unknown) => console.log(prefix, msg, data !== undefined ? data : ''),
+    info: (msg: string, data?: unknown) => console.log(prefix, msg, data !== undefined ? data : ''),
+    warn: (msg: string, data?: unknown) => console.warn(prefix, msg, data !== undefined ? data : ''),
+    error: (msg: string, data?: unknown) => console.error(prefix, msg, data !== undefined ? data : ''),
+    debug: (msg: string, data?: unknown) => console.debug(prefix, msg, data !== undefined ? data : ''),
+  };
+}
+
+/**
+ * Create the handler context for a function
+ */
+function createHandlerContext(functionName: string, args: unknown) {
+  const tether = useTetherServer(null as any);
+  const log = createLogger(functionName);
+
+  // Create db proxy that uses tether server client
+  // TODO: This is a placeholder - proper db operations need to be implemented
+  const db = new Proxy({}, {
+    get(_, tableName: string) {
+      return {
+        findMany: async (options?: any) => {
+          // Call Tether API for db operations
+          return tether.query(\`_db.\${tableName}.findMany\`, options);
+        },
+        findFirst: async (options?: any) => {
+          return tether.query(\`_db.\${tableName}.findFirst\`, options);
+        },
+        findUnique: async (options?: any) => {
+          return tether.query(\`_db.\${tableName}.findUnique\`, options);
+        },
+        findById: async (id: unknown) => {
+          return tether.query(\`_db.\${tableName}.findById\`, { id });
+        },
+        count: async (options?: any) => {
+          return tether.query(\`_db.\${tableName}.count\`, options);
+        },
+        create: async (options: any) => {
+          return tether.mutation(\`_db.\${tableName}.create\`, options);
+        },
+        insert: async (data: any) => {
+          return tether.mutation(\`_db.\${tableName}.insert\`, { data });
+        },
+        insertMany: async (data: any[]) => {
+          return tether.mutation(\`_db.\${tableName}.insertMany\`, { data });
+        },
+        update: async (options: any) => {
+          return tether.mutation(\`_db.\${tableName}.update\`, options);
+        },
+        upsert: async (options: any) => {
+          return tether.mutation(\`_db.\${tableName}.upsert\`, options);
+        },
+        delete: async (options: any) => {
+          return tether.mutation(\`_db.\${tableName}.delete\`, options);
+        },
+        deleteById: async (id: unknown) => {
+          return tether.mutation(\`_db.\${tableName}.deleteById\`, { id });
+        },
+      };
+    },
+  });
+
+  // Create tether context for actions
+  const tetherContext = {
+    query: tether.query.bind(tether),
+    mutation: tether.mutation.bind(tether),
+    env: new Proxy({}, {
+      get(_, key: string) {
+        return process.env[key];
+      },
+    }),
+  };
+
+  return {
+    args,
+    db,
+    ctx: { auth: { userId: null, claims: {} }, userId: null },
+    log,
+    tether: tetherContext,
+  };
+}
+
+export default defineNitroPlugin(() => {
+  console.log('[Tether] Auto-registering functions from tether/functions...');
+
+  // Iterate through all exported modules
+  for (const [moduleName, moduleExports] of Object.entries(tetherFunctions)) {
+    if (!moduleExports || typeof moduleExports !== 'object') continue;
+
+    // Iterate through all exports in each module
+    for (const [fnName, fnDef] of Object.entries(moduleExports as Record<string, any>)) {
+      // Check if it's a Tether function definition (has handler property)
+      if (!fnDef || typeof fnDef !== 'object' || typeof fnDef.handler !== 'function') continue;
+
+      const fullName = \`\${moduleName}.\${fnName}\`;
+
+      // Register the cron handler
+      registerCronHandler(fullName, async (args: unknown) => {
+        const context = createHandlerContext(fullName, args);
+        return fnDef.handler(context);
+      });
+
+      console.log(\`[Tether] Registered handler: \${fullName}\`);
+    }
+  }
+
+  console.log('[Tether] Function registration complete');
+});
+`,
+        });
+        // Add the generated plugin to Nitro
+        nuxt.hook('nitro:config', (nitroConfig) => {
+            nitroConfig.plugins = nitroConfig.plugins || [];
+            // Add our generated plugin after the cron plugin
+            nitroConfig.plugins.push('#build/server/plugins/tether-functions');
+        });
     },
 });

package/nuxt/module.ts

@@ -26,6 +26,8 @@ export interface TetherModuleOptions {
   projectId?: string;
   /** API endpoint (defaults to Tether Cloud) */
   url?: string;
+  /** Enable verbose logging for debugging WebSocket connections */
+  verbose?: boolean;
 }
 
 export default defineNuxtModule<TetherModuleOptions>({
@@ -48,6 +50,7 @@ export default defineNuxtModule<TetherModuleOptions>({
     const apiKey = process.env.TETHER_API_KEY || '';
     const url = options.url || process.env.TETHER_URL || 'https://tether-api.strands.gg';
     const projectId = options.projectId || process.env.TETHER_PROJECT_ID || '';
+    const verbose = options.verbose ?? (process.env.TETHER_VERBOSE === 'true');
 
     // Calculate WebSocket URL from HTTP URL
     const wsUrl = url.replace(/^https:/, 'wss:').replace(/^http:/, 'ws:');
@@ -57,17 +60,19 @@ export default defineNuxtModule<TetherModuleOptions>({
     // - NUXT_TETHER_API_KEY
     // - NUXT_TETHER_URL
     // - NUXT_TETHER_PROJECT_ID
-    nuxt.options.runtimeConfig.tether = {
+    // - NUXT_TETHER_VERBOSE
+    (nuxt.options.runtimeConfig as any).tether = {
       apiKey,
       url,
       projectId,
+      verbose,
     };
 
     // Public config (safe for client - no secrets)
     // Can be overridden at runtime via:
     // - NUXT_PUBLIC_TETHER_PROJECT_ID
     // - NUXT_PUBLIC_TETHER_WS_URL
-    nuxt.options.runtimeConfig.public.tether = {
+    (nuxt.options.runtimeConfig.public as any).tether = {
       projectId,
       wsUrl,
     };
@@ -140,7 +145,7 @@ export default defineNuxtModule<TetherModuleOptions>({
 
     // Add Nitro plugin for cron WebSocket connection
     // This auto-connects to Tether when the server starts
-    nuxt.hook('nitro:config', (nitroConfig) => {
+    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.js'));
@@ -150,5 +155,146 @@ export default defineNuxtModule<TetherModuleOptions>({
       nitroConfig.externals.inline = nitroConfig.externals.inline || [];
       nitroConfig.externals.inline.push('@tthr/vue');
     });
+
+    // Generate a server plugin to auto-register cron handlers from tether/functions
+    // This runs at build time and creates a plugin that imports user's functions
+    addTemplate({
+      filename: 'server/plugins/tether-functions.ts',
+      write: true,
+      getContents: () => `
+/**
+ * Auto-generated plugin to register Tether functions as cron handlers
+ * This file is generated by @tthr/vue/nuxt module
+ */
+import { defineNitroPlugin } from 'nitropack/runtime';
+import { registerCronHandler } from '@tthr/vue/nuxt/runtime/server/plugins/cron.js';
+import { useTetherServer } from '@tthr/vue/nuxt/runtime/server/utils/tether.js';
+
+// Import all functions from tether/functions
+// @ts-ignore - user's functions may not exist yet
+import * as tetherFunctions from '~/tether/functions';
+
+/**
+ * Create a simple logger for function execution
+ */
+function createLogger(functionName: string) {
+  const prefix = \`[Tether] \${functionName}\`;
+  return {
+    log: (msg: string, data?: unknown) => console.log(prefix, msg, data !== undefined ? data : ''),
+    info: (msg: string, data?: unknown) => console.log(prefix, msg, data !== undefined ? data : ''),
+    warn: (msg: string, data?: unknown) => console.warn(prefix, msg, data !== undefined ? data : ''),
+    error: (msg: string, data?: unknown) => console.error(prefix, msg, data !== undefined ? data : ''),
+    debug: (msg: string, data?: unknown) => console.debug(prefix, msg, data !== undefined ? data : ''),
+  };
+}
+
+/**
+ * Create the handler context for a function
+ */
+function createHandlerContext(functionName: string, args: unknown) {
+  const tether = useTetherServer(null as any);
+  const log = createLogger(functionName);
+
+  // Create db proxy that uses tether server client
+  // TODO: This is a placeholder - proper db operations need to be implemented
+  const db = new Proxy({}, {
+    get(_, tableName: string) {
+      return {
+        findMany: async (options?: any) => {
+          // Call Tether API for db operations
+          return tether.query(\`_db.\${tableName}.findMany\`, options);
+        },
+        findFirst: async (options?: any) => {
+          return tether.query(\`_db.\${tableName}.findFirst\`, options);
+        },
+        findUnique: async (options?: any) => {
+          return tether.query(\`_db.\${tableName}.findUnique\`, options);
+        },
+        findById: async (id: unknown) => {
+          return tether.query(\`_db.\${tableName}.findById\`, { id });
+        },
+        count: async (options?: any) => {
+          return tether.query(\`_db.\${tableName}.count\`, options);
+        },
+        create: async (options: any) => {
+          return tether.mutation(\`_db.\${tableName}.create\`, options);
+        },
+        insert: async (data: any) => {
+          return tether.mutation(\`_db.\${tableName}.insert\`, { data });
+        },
+        insertMany: async (data: any[]) => {
+          return tether.mutation(\`_db.\${tableName}.insertMany\`, { data });
+        },
+        update: async (options: any) => {
+          return tether.mutation(\`_db.\${tableName}.update\`, options);
+        },
+        upsert: async (options: any) => {
+          return tether.mutation(\`_db.\${tableName}.upsert\`, options);
+        },
+        delete: async (options: any) => {
+          return tether.mutation(\`_db.\${tableName}.delete\`, options);
+        },
+        deleteById: async (id: unknown) => {
+          return tether.mutation(\`_db.\${tableName}.deleteById\`, { id });
+        },
+      };
+    },
+  });
+
+  // Create tether context for actions
+  const tetherContext = {
+    query: tether.query.bind(tether),
+    mutation: tether.mutation.bind(tether),
+    env: new Proxy({}, {
+      get(_, key: string) {
+        return process.env[key];
+      },
+    }),
+  };
+
+  return {
+    args,
+    db,
+    ctx: { auth: { userId: null, claims: {} }, userId: null },
+    log,
+    tether: tetherContext,
+  };
+}
+
+export default defineNitroPlugin(() => {
+  console.log('[Tether] Auto-registering functions from tether/functions...');
+
+  // Iterate through all exported modules
+  for (const [moduleName, moduleExports] of Object.entries(tetherFunctions)) {
+    if (!moduleExports || typeof moduleExports !== 'object') continue;
+
+    // Iterate through all exports in each module
+    for (const [fnName, fnDef] of Object.entries(moduleExports as Record<string, any>)) {
+      // Check if it's a Tether function definition (has handler property)
+      if (!fnDef || typeof fnDef !== 'object' || typeof fnDef.handler !== 'function') continue;
+
+      const fullName = \`\${moduleName}.\${fnName}\`;
+
+      // Register the cron handler
+      registerCronHandler(fullName, async (args: unknown) => {
+        const context = createHandlerContext(fullName, args);
+        return fnDef.handler(context);
+      });
+
+      console.log(\`[Tether] Registered handler: \${fullName}\`);
+    }
+  }
+
+  console.log('[Tether] Function registration complete');
+});
+`,
+    });
+
+    // Add the generated plugin to Nitro
+    nuxt.hook('nitro:config' as any, (nitroConfig: any) => {
+      nitroConfig.plugins = nitroConfig.plugins || [];
+      // Add our generated plugin after the cron plugin
+      nitroConfig.plugins.push('#build/server/plugins/tether-functions');
+    });
   },
 });

package/nuxt/runtime/server/mutation.post.js

@@ -10,6 +10,16 @@ import { useRuntimeConfig } from '#imports';
 let functionRegistry = null;
 let registryError = null;
 
+// Verbose logging support
+let verboseLogging = false;
+const PREFIX = '[Tether]';
+const log = {
+  debug: (...args) => { if (verboseLogging) console.log(PREFIX, ...args); },
+  info: (...args) => console.log(PREFIX, ...args),
+  warn: (...args) => console.warn(PREFIX, ...args),
+  error: (...args) => console.error(PREFIX, ...args),
+};
+
 /**
  * Try to load the user's custom functions from ~/tether/functions
  */
@@ -21,23 +31,23 @@ async function loadFunctionRegistry() {
   try {
     // Try to import the user's functions index
     // This path is relative to the Nuxt app's server runtime
-    console.log('[Tether] Loading custom functions from ~~/tether/functions/index.ts');
+    log.debug('Loading custom functions from ~~/tether/functions/index.ts');
     const functions = await import('~~/tether/functions/index.ts').catch((err) => {
-      console.warn('[Tether] Failed to import functions:', err.message);
+      log.debug('Failed to import functions:', err.message);
       return null;
     });
 
     if (functions) {
-      console.log('[Tether] Loaded function modules:', Object.keys(functions));
+      log.debug('Loaded function modules:', Object.keys(functions));
       functionRegistry = functions;
     } else {
       // No custom functions found - that's OK, we'll proxy everything
-      console.log('[Tether] No custom functions found, will proxy all requests');
+      log.debug('No custom functions found, will proxy all requests');
       functionRegistry = {};
     }
   } catch (error) {
     // Failed to load - we'll proxy everything to Tether API
-    console.warn('[Tether] Could not load custom functions:', error.message);
+    log.debug('Could not load custom functions:', error.message);
     registryError = error;
     functionRegistry = {};
   }
@@ -217,6 +227,7 @@ function createDatabaseProxy(apiKey, url, projectId) {
 
 export default defineEventHandler(async (event) => {
   const config = useRuntimeConfig();
+  verboseLogging = config.tether?.verbose || process.env.TETHER_VERBOSE === 'true';
 
   // Get API key from runtime config (populated from TETHER_API_KEY env var)
   const apiKey = config.tether?.apiKey || process.env.TETHER_API_KEY;
@@ -251,12 +262,12 @@ export default defineEventHandler(async (event) => {
 
   // Try to find a custom function
   const customFn = lookupFunction(body.function);
-  console.log(`[Tether] Mutation: ${body.function}, custom function found: ${!!customFn}`);
+  log.debug(`Mutation: ${body.function}, custom function found: ${!!customFn}`);
 
   if (customFn) {
     // Execute locally with database proxy
     try {
-      console.log(`[Tether] Executing custom mutation: ${body.function}`);
+      log.debug(`Executing custom mutation: ${body.function}`);
       const db = createDatabaseProxy(apiKey, url, projectId);
 
       // Create auth context - try to get user identity from request
@@ -288,7 +299,7 @@ export default defineEventHandler(async (event) => {
               }
             }
           } catch (authError) {
-            console.warn('[Tether] Auth validation failed:', authError.message);
+            log.warn('Auth validation failed:', authError.message);
             // Auth validation failed - continue without identity
           }
         }
@@ -315,7 +326,7 @@ export default defineEventHandler(async (event) => {
 
       return { data: result };
     } catch (error) {
-      console.error(`[Tether] Mutation ${body.function} failed:`, error);
+      log.error(`Mutation ${body.function} failed:`, error);
       // Return JSON error response instead of throwing (avoids proxy HTML error pages)
       setResponseStatus(event, 400);
       return {

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

@@ -1 +1 @@
-{"version":3,"file":"cron.d.ts","sourceRoot":"","sources":["cron.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAsBH;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CACjC,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,GAC3C,IAAI,CAGN;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAEhE;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,MAAM,EAAE,CAE1C;;AAqPD,wBA+BG"}
+{"version":3,"file":"cron.d.ts","sourceRoot":"","sources":["cron.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAoCH;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CACjC,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,GAC3C,IAAI,CAGN;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAEhE;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,MAAM,EAAE,CAE1C;;AAyPD,wBAiCG"}

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

@@ -20,10 +20,24 @@ let heartbeatTimer = null;
 let heartbeatTimeoutTimer = null;
 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_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
  *
@@ -40,7 +54,7 @@ const RECONNECT_DELAY = 1000;
  */
 export function registerCronHandler(functionName, handler) {
     cronHandlers.set(functionName, handler);
-    console.log(`[Tether Cron] Registered handler for: ${functionName}`);
+    log.debug('Registered handler for:', functionName);
 }
 /**
  * Unregister a cron handler
@@ -97,22 +111,22 @@ async function reportExecution(config, trigger, result, durationMs) {
             }),
         });
         if (!response.ok) {
-            console.error(`[Tether Cron] Failed to report execution: ${response.status} ${response.statusText}`);
+            log.error(`Failed to report execution: ${response.status} ${response.statusText}`);
         }
         else {
-            console.log(`[Tether Cron] Reported execution ${trigger.executionId}: ${result.success ? 'success' : 'failed'}`);
+            log.debug(`Reported execution ${trigger.executionId}: ${result.success ? 'success' : 'failed'}`);
         }
     }
     catch (error) {
-        console.error('[Tether Cron] Failed to report execution:', error);
+        log.error('Failed to report execution:', error);
     }
 }
 async function handleCronTrigger(config, trigger) {
-    console.log(`[Tether Cron] Received trigger for ${trigger.functionName} (execution: ${trigger.executionId})`);
+    log.info(`Received trigger for ${trigger.functionName} (execution: ${trigger.executionId})`);
     const startTime = Date.now();
     const handler = cronHandlers.get(trigger.functionName);
     if (!handler) {
-        console.warn(`[Tether Cron] No handler registered for: ${trigger.functionName}`);
+        log.warn(`No handler registered for: ${trigger.functionName}`);
         const durationMs = Date.now() - startTime;
         await reportExecution(config, trigger, {
             success: false,
@@ -131,7 +145,7 @@ async function handleCronTrigger(config, trigger) {
     catch (error) {
         const durationMs = Date.now() - startTime;
         const errorMessage = error instanceof Error ? error.message : String(error);
-        console.error(`[Tether Cron] Handler error for ${trigger.functionName}:`, errorMessage);
+        log.error(`Handler error for ${trigger.functionName}:`, errorMessage);
         await reportExecution(config, trigger, {
             success: false,
             error: errorMessage,
@@ -143,17 +157,17 @@ function startHeartbeat() {
     heartbeatTimer = setInterval(() => {
         if (ws?.readyState === WebSocket.OPEN) {
             awaitingPong = true;
-            console.log('[Tether Cron] Sending heartbeat ping');
+            log.debug('Sending heartbeat ping');
             ws.send(JSON.stringify({ type: 'ping' }));
             heartbeatTimeoutTimer = setTimeout(() => {
                 if (awaitingPong) {
-                    console.warn('[Tether Cron] Heartbeat timeout - forcing reconnect');
+                    log.warn('Heartbeat timeout - forcing reconnect');
                     ws?.close();
                 }
             }, HEARTBEAT_TIMEOUT);
         }
         else {
-            console.warn(`[Tether Cron] Cannot send ping - WebSocket state: ${ws?.readyState}`);
+            log.warn(`Cannot send ping - WebSocket state: ${ws?.readyState}`);
         }
     }, HEARTBEAT_INTERVAL);
 }
@@ -180,7 +194,7 @@ function connect(config) {
         ws = new WebSocketImpl(url);
         ws.onopen = () => {
             reconnectAttempts = 0;
-            console.log('[Tether Cron] WebSocket connected');
+            log.debug('WebSocket connected');
         };
         ws.onmessage = async (event) => {
             const data = typeof event.data === 'string' ? event.data : event.data.toString();
@@ -190,13 +204,13 @@ function connect(config) {
                     case 'connected':
                         connectionId = message.connection_id ?? null;
                         startHeartbeat();
-                        console.log(`[Tether Cron] Connected with ID: ${connectionId}`);
+                        log.info(`Connected with ID: ${connectionId}`);
                         break;
                     case 'cron_trigger':
                         await handleCronTrigger(config, message);
                         break;
                     case 'pong':
-                        console.log('[Tether Cron] Received pong');
+                        log.debug('Received pong');
                         awaitingPong = false;
                         if (heartbeatTimeoutTimer) {
                             clearTimeout(heartbeatTimeoutTimer);
@@ -204,27 +218,27 @@ function connect(config) {
                         }
                         break;
                     case 'error':
-                        console.error('[Tether Cron] Server error:', message.error);
+                        log.error('Server error:', message.error);
                         break;
                 }
             }
             catch (e) {
-                console.error('[Tether Cron] Failed to parse message:', e);
+                log.error('Failed to parse message:', e);
             }
         };
         ws.onerror = (error) => {
             const err = error instanceof Error ? error : new Error('WebSocket error');
-            console.error('[Tether Cron] WebSocket error:', err.message);
+            log.error('WebSocket error:', err.message);
         };
         ws.onclose = (event) => {
             connectionId = null;
             stopHeartbeat();
-            console.log(`[Tether Cron] WebSocket disconnected (code: ${event.code}, reason: ${event.reason || 'none'})`);
+            log.debug(`WebSocket disconnected (code: ${event.code}, reason: ${event.reason || 'none'})`);
             handleReconnect(config);
         };
     }
     catch (error) {
-        console.error('[Tether Cron] Failed to connect:', error);
+        log.error('Failed to connect:', error);
         handleReconnect(config);
     }
 }
@@ -233,12 +247,12 @@ function handleReconnect(config) {
         return;
     }
     if (reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
-        console.error('[Tether Cron] Max reconnection attempts reached');
+        log.error('Max reconnection attempts reached');
         return;
     }
     reconnectAttempts++;
     const delay = Math.min(RECONNECT_DELAY * Math.pow(2, reconnectAttempts - 1), 30000);
-    console.log(`[Tether Cron] Reconnecting in ${delay}ms (attempt ${reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS})`);
+    log.debug(`Reconnecting in ${delay}ms (attempt ${reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS})`);
     setTimeout(() => {
         connect(config);
     }, delay);
@@ -246,15 +260,17 @@ function handleReconnect(config) {
 export default defineNitroPlugin((nitro) => {
     // Get config from runtime config
     const config = useRuntimeConfig();
-    const apiKey = config.tether?.apiKey || process.env.TETHER_API_KEY;
-    const url = config.tether?.url || process.env.TETHER_URL || 'https://tether-api.strands.gg';
-    const projectId = config.tether?.projectId || process.env.TETHER_PROJECT_ID;
+    const tetherConfig = config.tether;
+    const apiKey = tetherConfig?.apiKey || process.env.TETHER_API_KEY;
+    const url = tetherConfig?.url || process.env.TETHER_URL || 'https://tether-api.strands.gg';
+    const projectId = tetherConfig?.projectId || process.env.TETHER_PROJECT_ID;
+    verboseLogging = tetherConfig?.verbose || process.env.TETHER_VERBOSE === 'true';
     // Only connect if we have all required config
     if (!apiKey || !projectId) {
-        console.log('[Tether Cron] Missing config (apiKey or projectId) - cron connection disabled');
+        log.debug('Missing config (apiKey or projectId) - cron connection disabled');
         return;
     }
-    console.log('[Tether Cron] Initialising cron connection...');
+    log.info('Initialising cron connection...');
     // Connect on next tick to allow handlers to be registered first
     process.nextTick(() => {
         connect({ url, projectId, apiKey });
@@ -267,7 +283,6 @@ export default defineNitroPlugin((nitro) => {
             ws.close();
             ws = null;
         }
-        console.log('[Tether Cron] Connection closed');
+        log.debug('Connection closed');
     });
 });
-//# sourceMappingURL=cron.js.map

package/nuxt/runtime/server/query.post.js

@@ -10,6 +10,16 @@ import { useRuntimeConfig } from '#imports';
 let functionRegistry = null;
 let registryError = null;
 
+// Verbose logging support
+let verboseLogging = false;
+const PREFIX = '[Tether]';
+const log = {
+  debug: (...args) => { if (verboseLogging) console.log(PREFIX, ...args); },
+  info: (...args) => console.log(PREFIX, ...args),
+  warn: (...args) => console.warn(PREFIX, ...args),
+  error: (...args) => console.error(PREFIX, ...args),
+};
+
 /**
  * Try to load the user's custom functions from ~/tether/functions
  */
@@ -21,23 +31,23 @@ async function loadFunctionRegistry() {
   try {
     // Try to import the user's functions index
     // This path is relative to the Nuxt app's server runtime
-    console.log('[Tether] Loading custom functions from ~~/tether/functions/index.ts');
+    log.debug('Loading custom functions from ~~/tether/functions/index.ts');
     const functions = await import('~~/tether/functions/index.ts').catch((err) => {
-      console.warn('[Tether] Failed to import functions:', err.message);
+      log.debug('Failed to import functions:', err.message);
       return null;
     });
 
     if (functions) {
-      console.log('[Tether] Loaded function modules:', Object.keys(functions));
+      log.debug('Loaded function modules:', Object.keys(functions));
       functionRegistry = functions;
     } else {
       // No custom functions found - that's OK, we'll proxy everything
-      console.log('[Tether] No custom functions found, will proxy all requests');
+      log.debug('No custom functions found, will proxy all requests');
       functionRegistry = {};
     }
   } catch (error) {
     // Failed to load - we'll proxy everything to Tether API
-    console.warn('[Tether] Could not load custom functions:', error.message);
+    log.debug('Could not load custom functions:', error.message);
     registryError = error;
     functionRegistry = {};
   }
@@ -217,6 +227,7 @@ function createDatabaseProxy(apiKey, url, projectId) {
 
 export default defineEventHandler(async (event) => {
   const config = useRuntimeConfig();
+  verboseLogging = config.tether?.verbose || process.env.TETHER_VERBOSE === 'true';
 
   // Get API key from runtime config (populated from TETHER_API_KEY env var)
   const apiKey = config.tether?.apiKey || process.env.TETHER_API_KEY;
@@ -251,7 +262,7 @@ export default defineEventHandler(async (event) => {
 
   // Try to find a custom function
   const customFn = lookupFunction(body.function);
-  console.log(`[Tether] Query: ${body.function}, custom function found: ${!!customFn}`);
+  log.debug(`Query: ${body.function}, custom function found: ${!!customFn}`);
 
   if (customFn) {
     // Execute locally with database proxy
@@ -288,7 +299,7 @@ export default defineEventHandler(async (event) => {
               }
             }
           } catch (authError) {
-            console.warn('[Tether] Auth validation failed:', authError.message);
+            log.warn('Auth validation failed:', authError.message);
             // Auth validation failed - continue without identity
           }
         }
@@ -306,18 +317,18 @@ export default defineEventHandler(async (event) => {
         userId: userIdentity?.subject ?? null,
       };
 
-      console.log(`[Tether] Executing custom function: ${body.function}`);
+      log.debug(`Executing custom function: ${body.function}`);
       const result = await customFn.handler({
         db,
         ctx,
         auth,
         args: body.args ?? {},
       });
-      console.log(`[Tether] Function ${body.function} completed`);
+      log.debug(`Function ${body.function} completed`);
 
       return { data: result };
     } catch (error) {
-      console.error(`[Tether] Function ${body.function} failed:`, error.message || error);
+      log.error(`Function ${body.function} failed:`, error.message || error);
       throw createError({
         statusCode: 500,
         message: error.message || 'Function execution failed',

package/package.json

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