teleportation-cli 1.1.3 → 1.1.5

package/lib/daemon/teleportation-daemon.js

@@ -41,12 +41,31 @@ import { promisify } from 'util';
 import { acquirePidLock, releasePidLock } from './pid-manager.js';
 import { setupSignalHandlers } from './lifecycle.js';
 
+// Task executor for autonomous tasks (PRD-0016)
+import { 
+  startTask, 
+  stopTask, 
+  stopAllTasks,
+  cleanupStaleLocks,
+  cleanupOrphanedProcesses,
+  removeTaskLock,
+  pauseTask, 
+  resumeTask, 
+  getTaskSession,
+  answerTaskQuestion,
+  increaseBudget
+} from './task-executor.js';
+
 // Machine coder adapters for multi-provider support
 import { getAvailableCoders, getBestCoder } from '../machine-coders/index.js';
 
 // Cost-aware model router for LLM calls
 import { createRouter, classifyTask } from '../router/index.js';
 
+// Logging utilities with level control and sanitization
+import { logError, logWarn, logInfo, logDebug, logVerbose } from '../utils/logger.js';
+import { sanitizeForLog, truncateForLog, prepareForLog } from '../utils/log-sanitizer.js';
+
 const execAsync = promisify(exec);
 console.log('[daemon] Starting up...');
 
@@ -180,9 +199,54 @@ const OUTPUT_PREVIEW_LONG = 1000;   // Full output displays
 const heartbeatState = new Map();
 let lastHeartbeatTime = 0;
 
-// Session registry: session_id -> { session_id, cwd, meta, registered_at }
+// In-memory registry of active teleportation sessions handled by this daemon
 const sessions = new Map();
 
+// Constants
+const STARTING_TASK_STALE_MS = 300000; // 5 minutes
+const STARTING_TASK_CLEANUP_INTERVAL_MS = 60000; // 1 minute
+
+// Track tasks currently being started to prevent duplicates (taskId -> timestamp)
+const startingTasks = new Map();
+
+// Track tasks with active execution loops to prevent recursion
+const activeLoops = new Set();
+
+// Session activity tracking for cleanup
+const sessionActivity = new Map(); // sessionId -> lastActivityTimestamp
+
+// Periodically clear stale startingTasks (older than 5 minutes)
+setInterval(() => {
+  const now = Date.now();
+  let cleanedCount = 0;
+  for (const [taskId, timestamp] of startingTasks) {
+    if (now - timestamp > STARTING_TASK_STALE_MS) {
+      startingTasks.delete(taskId);
+      cleanedCount++;
+    }
+  }
+  if (cleanedCount > 0) {
+    console.log(`[daemon] Routine cleanup: cleared ${cleanedCount} stale starting task entries`);
+  }
+
+  // PRD-0016: Cleanup stale sessions from memory (inactive for > 1 hour)
+  let sessionCleanedCount = 0;
+  for (const [sessionId, lastActivity] of sessionActivity) {
+    if (now - lastActivity > 3600000) {
+      sessions.delete(sessionId);
+      sessionActivity.delete(sessionId);
+      sessionCleanedCount++;
+    }
+  }
+  if (sessionCleanedCount > 0) {
+    console.log(`[daemon] Routine cleanup: cleared ${sessionCleanedCount} inactive sessions from memory`);
+  }
+}, STARTING_TASK_CLEANUP_INTERVAL_MS);
+
+/**
+ * Sync daemon state to relay API
+ */
+
 // Approval queue: FIFO queue of pending approvals
 // { approval_id, session_id, tool_name, tool_input, queued_at }
 const approvalQueue = [];
@@ -810,8 +874,10 @@ async function executeCommand(session_id, command) {
 
 async function handleInboxMessage(session_id, message) {
   try {
-    const preview = (message.text || '').slice(0, 200).replace(/\s+/g, ' ');
-    console.log(`[daemon] Inbox message for session ${session_id}: ${message.id} - ${preview}`);
+    const sanitizedPreview = prepareForLog(message.text || '', 200).replace(/\s+/g, ' ');
+    logDebug(`[daemon] 📨 Inbox message received for session ${session_id}`);
+    logDebug(`[daemon]    ↳ Message ID: ${message.id}`);
+    logDebug(`[daemon]    ↳ Preview: ${sanitizedPreview}`);
 
     const meta = message.meta || {};
 
@@ -820,6 +886,11 @@ async function handleInboxMessage(session_id, message) {
       const replyAgentId = meta.reply_agent_id || 'main';
       const commandText = (message.text || '').trim();
 
+      logDebug(`[daemon] 🎯 Command message routing:`);
+      logDebug(`[daemon]    ↳ Type: ${meta.type}`);
+      logDebug(`[daemon]    ↳ Target agent (reply to): ${replyAgentId}`);
+      logDebug(`[daemon]    ↳ Command length: ${commandText.length} chars`);
+
       // Validate non-empty message before processing
       if (!commandText) {
         console.warn(`[daemon] Received empty message ${message.id}, skipping execution`);
@@ -884,7 +955,8 @@ async function handleInboxMessage(session_id, message) {
       } else {
         // Default mode: route all messages to Claude Code
         executionType = 'agent';
-        console.log(`[daemon] Routing message to Claude Code: ${commandText.substring(0, 100)}`);
+        const sanitizedCommand = prepareForLog(commandText, 100);
+        logInfo(`[daemon] 🚀 Routing message to Claude Code: ${sanitizedCommand}`);
 
         // Stream output callback for message execution
         const onOutput = createStreamingCallback(session_id, message.id, {
@@ -894,6 +966,9 @@ async function handleInboxMessage(session_id, message) {
         // Use the unified machine coder interface
         // This supports Claude Code, Gemini CLI, and future backends
         // Note: _executeWithMachineCoderRef.fn is used for test mocking
+        const executionStartTime = Date.now();
+        logDebug(`[daemon] ⏱️  Execution started at ${new Date(executionStartTime).toISOString()}`);
+
         try {
           const executeFn = _executeWithMachineCoderRef.fn || executeWithMachineCoder;
           executionResult = await executeFn(session_id, commandText, {
@@ -901,13 +976,26 @@ async function handleInboxMessage(session_id, message) {
             approvalContext: { type: 'inbox_message', id: message.id },
           });
 
+          const executionDuration = Date.now() - executionStartTime;
+          const durationSec = (executionDuration / 1000).toFixed(2);
+
           // Track which coder was used
           if (executionResult.coder_used) {
-            console.log(`[daemon] Executed via ${executionResult.coder_used}`);
+            logInfo(`[daemon] ✅ Executed via ${executionResult.coder_used} in ${durationSec}s`);
+          } else {
+            logInfo(`[daemon] ✅ Execution completed in ${durationSec}s`);
+          }
+
+          logDebug(`[daemon]    ↳ Success: ${executionResult.success}`);
+          logDebug(`[daemon]    ↳ Exit code: ${executionResult.exit_code}`);
+          if (executionResult.model_used) {
+            logDebug(`[daemon]    ↳ Model: ${executionResult.model_used}`);
           }
         } catch (error) {
-          const preview = commandText.substring(0, 50);
-          console.error(`[daemon] Machine coder execution failed for "${preview}...":`, error.message);
+          const executionDuration = Date.now() - executionStartTime;
+          const durationSec = (executionDuration / 1000).toFixed(2);
+          const sanitizedPreview = prepareForLog(commandText, 50);
+          logError(`[daemon] ❌ Machine coder execution failed for session ${session_id}: "${sanitizedPreview}..." after ${durationSec}s:`, error.message);
           executionResult = {
             success: false,
             exit_code: -1,
@@ -944,6 +1032,10 @@ async function handleInboxMessage(session_id, message) {
       }
 
       try {
+        logInfo(`[daemon] 📤 Sending result message to agent '${replyAgentId}' for session ${session_id}`);
+        logDebug(`[daemon]    ↳ In reply to message: ${message.id}`);
+        logDebug(`[daemon]    ↳ Execution ${executionResult.success ? 'succeeded' : 'failed'} (exit code: ${executionResult.exit_code})`);
+
         const resultResponse = await fetch(`${RELAY_API_URL}/api/messages`, {
           method: 'POST',
           headers: {
@@ -967,22 +1059,33 @@ async function handleInboxMessage(session_id, message) {
 
         if (!resultResponse.ok) {
           const errorText = await resultResponse.text();
-          console.error(`[daemon] Failed to post result message: HTTP ${resultResponse.status} - ${errorText}`);
+          logError(`[daemon] ❌ Failed to post result message for session ${session_id}: HTTP ${resultResponse.status} - ${errorText}`);
+        } else {
+          const responseData = await resultResponse.json();
+          logInfo(`[daemon] ✅ Result message delivered to relay (message_id: ${responseData.id || 'unknown'})`);
+          logDebug(`[daemon]    ↳ Agent '${replyAgentId}' should receive result on next poll`);
         }
       } catch (sendError) {
-        console.error('[daemon] Failed to send result message:', sendError.message);
+        logError(`[daemon] ❌ Failed to send result message for session ${session_id}: ${sendError.message}`);
       }
     }
 
     // Acknowledge the message so it is not re-delivered
-    await fetch(`${RELAY_API_URL}/api/messages/${encodeURIComponent(message.id)}/ack`, {
+    logDebug(`[daemon] ✓ Acknowledging inbox message ${message.id}`);
+    const ackResponse = await fetch(`${RELAY_API_URL}/api/messages/${encodeURIComponent(message.id)}/ack`, {
       method: 'POST',
       headers: {
         'Authorization': `Bearer ${RELAY_API_KEY}`
       }
     });
+
+    if (ackResponse.ok) {
+      logDebug(`[daemon] ✅ Message ${message.id} acknowledged successfully`);
+    } else {
+      logError(`[daemon] ❌ Failed to acknowledge message ${message.id} for session ${session_id}: HTTP ${ackResponse.status}`);
+    }
   } catch (error) {
-    console.error('[daemon] Failed to handle inbox message:', error.message);
+    logError(`[daemon] ❌ Failed to handle inbox message for session ${session_id}: ${error.message}`);
   }
 }
 
@@ -1083,12 +1186,15 @@ async function pollRelayAPI() {
   try {
     // Fetch pending approvals and inbox messages for all registered sessions
     const TEST_SESSION_FILTER = process.env.TELEPORTATION_TEST_SESSION_FILTER;
-    for (const [session_id] of sessions) {
+    for (const [session_id, sessionData] of sessions) {
       // Optional: Filter sessions for testing (if TEST_SESSION_FILTER env var set)
       if (TEST_SESSION_FILTER && !session_id.startsWith(TEST_SESSION_FILTER)) {
         continue;
       }
       console.log(`Polling for session ${session_id}`);
+      
+      // Update activity timestamp for cleanup tracking
+      sessionActivity.set(session_id, Date.now());
 
       // 1) Approvals polling (existing behavior)
       try {
@@ -1160,7 +1266,91 @@ async function pollRelayAPI() {
         console.error(`[daemon] Inbox polling error for session ${session_id}:`, inboxError.message);
       }
 
-      // 3) Heartbeat - send periodically to keep session alive
+      // 3) Tasks polling (PRD-0016)
+      try {
+        const tasksResponse = await fetch(
+          `${RELAY_API_URL}/api/sessions/${encodeURIComponent(session_id)}/tasks`,
+          {
+            headers: {
+              'Authorization': `Bearer ${RELAY_API_KEY}`
+            }
+          }
+        );
+
+        if (tasksResponse.ok) {
+          const tasks = await tasksResponse.json();
+          for (const task of tasks) {
+            // If task is 'running' but not in our local executor, start it
+            if (task.status === 'running' && !activeLoops.has(task.id) && !startingTasks.has(task.id)) {
+              console.log(`[daemon] 🚀 Starting autonomous task loop: ${task.id}`);
+              startingTasks.set(task.id, Date.now());
+              activeLoops.add(task.id);
+              
+              startTask({
+                task: task.task,
+                task_id: task.id,
+                session_id: task.session_id,
+                cwd: task.cwd || sessionData.cwd,
+                budget_usd: task.budget_usd,
+                onEvent: async (event) => {
+                  // Forward task events to the timeline via Relay API
+                  try {
+                    await fetch(`${RELAY_API_URL}/api/timeline`, {
+                      method: 'POST',
+                      headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${RELAY_API_KEY}`
+                      },
+                      body: JSON.stringify({
+                        session_id: session_id,
+                        type: event.type,
+                        data: event
+                      })
+                    });
+                  } catch (e) {
+                    console.error(`[daemon] Failed to log task event ${event.type}:`, e.message);
+                  }
+                }
+              }).then((result) => {
+                startingTasks.delete(task.id);
+                // Note: activeLoops stays active as long as the loop is running.
+                // If startTask returns because it's already running, clean up.
+                if (result.status === 'already_running') {
+                   activeLoops.delete(task.id);
+                   // No need to remove lock here, someone else owns it
+                }
+              }).catch(err => {
+                console.error(`[daemon] Failed to start autonomous task ${task.id}:`, err.message);
+                startingTasks.delete(task.id);
+                // PRD-0016 Fix: Remove from activeLoops on error so it can be retried
+                activeLoops.delete(task.id);
+                removeTaskLock(task.id);
+              });
+            }
+            
+            // Sync status and manage lifecycle
+            const localTask = getTaskSession(task.id);
+            if (localTask) {
+              if (task.status === 'stopped' && localTask.status !== 'stopped') {
+                stopTask(task.id);
+                activeLoops.delete(task.id);
+                removeTaskLock(task.id);
+              } else if (task.status === 'paused' && localTask.status === 'running') {
+                pauseTask(task.id);
+              } else if (task.status === 'running' && localTask.status === 'paused') {
+                resumeTask(task.id);
+              } else if (localTask.status === 'completed' || localTask.status === 'stopped') {
+                activeLoops.delete(task.id);
+                removeTaskLock(task.id);
+              }
+            }
+          }
+        }
+      } catch (taskError) {
+        console.error(`[daemon] Task polling error for session ${session_id}:`, taskError.message);
+      }
+
+      // 4) Heartbeat - send periodically to keep session alive
       // Only send heartbeat if enough time has passed since last one (throttled per session)
       const now = Date.now();
       const sessionHeartbeat = heartbeatState.get(session_id);
@@ -2047,6 +2237,13 @@ async function cleanup() {
   console.log('[daemon] Cleaning up...');
   isShuttingDown = true;
 
+  // Stop all task tasks (PRD-0016)
+  try {
+    stopAllTasks();
+  } catch (e) {
+    console.error('[daemon] Error stopping task tasks during cleanup:', e.message);
+  }
+
   // Stop polling
   if (pollingTimer) {
     clearTimeout(pollingTimer);
@@ -2117,6 +2314,14 @@ async function main() {
     // Setup signal handlers
     setupSignalHandlers(cleanup);
 
+    // PRD-0016: Cleanup orphaned task locks on startup
+    try {
+      cleanupStaleLocks();
+      cleanupOrphanedProcesses();
+    } catch (e) {
+      console.error('[daemon] Error during startup cleanup:', e.message);
+    }
+
     // Start HTTP server (using built-in http module)
     server = http.createServer(handleRequest);
     server.listen(PORT, '127.0.0.1', () => {

package/lib/utils/log-sanitizer.js

@@ -0,0 +1,111 @@
+/**
+ * Sanitizes text for logging by redacting sensitive information
+ * Prevents accidental exposure of API keys, tokens, passwords, etc.
+ */
+
+/**
+ * Sanitizes a string by replacing sensitive patterns with redacted versions
+ * @param {string} text - The text to sanitize
+ * @returns {string} - Sanitized text with sensitive data redacted
+ */
+export function sanitizeForLog(text) {
+  if (!text || typeof text !== 'string') {
+    return text;
+  }
+
+  let sanitized = text;
+
+  // API keys (various formats)
+  // Matches: api_key=abc123, apiKey: "abc123", api-key="abc123"
+  sanitized = sanitized.replace(
+    /api[_-]?key[\"']?\s*[:=]\s*[\"']?([A-Za-z0-9_-]{20,})[\"']?/gi,
+    'api_key: ***'
+  );
+
+  // Bearer tokens
+  // Matches: Bearer abc123token
+  sanitized = sanitized.replace(
+    /Bearer\s+[A-Za-z0-9_-]+/gi,
+    'Bearer ***'
+  );
+
+  // Authorization headers
+  // Matches: Authorization: "abc123"
+  sanitized = sanitized.replace(
+    /Authorization[\"']?\s*[:=]\s*[\"']?([A-Za-z0-9_-]{20,})[\"']?/gi,
+    'Authorization: ***'
+  );
+
+  // Passwords (various formats)
+  // Matches: password=abc, password: "abc", pwd="abc"
+  sanitized = sanitized.replace(
+    /(password|passwd|pwd)[\"']?\s*[:=]\s*[\"']?([^\s\"']+)[\"']?/gi,
+    '$1: ***'
+  );
+
+  // Generic secrets
+  // Matches: secret=abc, secret: "abc"
+  sanitized = sanitized.replace(
+    /secret[\"']?\s*[:=]\s*[\"']?([^\s\"']+)[\"']?/gi,
+    'secret: ***'
+  );
+
+  // Tokens (generic)
+  // Matches: token=abc123, token: "abc123"
+  sanitized = sanitized.replace(
+    /token[\"']?\s*[:=]\s*[\"']?([A-Za-z0-9_-]{20,})[\"']?/gi,
+    'token: ***'
+  );
+
+  // AWS keys
+  // Matches: AKIA... (AWS access keys start with AKIA)
+  sanitized = sanitized.replace(
+    /AKIA[A-Z0-9]{16}/g,
+    'AKIA***'
+  );
+
+  // Private keys (PEM format)
+  // Matches: -----BEGIN PRIVATE KEY-----...-----END PRIVATE KEY-----
+  sanitized = sanitized.replace(
+    /-----BEGIN[A-Z\s]+PRIVATE KEY-----[\s\S]*?-----END[A-Z\s]+PRIVATE KEY-----/g,
+    '-----BEGIN PRIVATE KEY----- *** -----END PRIVATE KEY-----'
+  );
+
+  // JWT tokens (three base64 segments separated by dots)
+  // Matches: eyJhbGc...
+  sanitized = sanitized.replace(
+    /eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g,
+    'eyJ***.***'
+  );
+
+  return sanitized;
+}
+
+/**
+ * Truncates a string to a maximum length and adds ellipsis if needed
+ * @param {string} text - The text to truncate
+ * @param {number} maxLen - Maximum length (default: 100)
+ * @returns {string} - Truncated text
+ */
+export function truncateForLog(text, maxLen = 100) {
+  if (!text || typeof text !== 'string') {
+    return text || '';
+  }
+
+  if (text.length <= maxLen) {
+    return text;
+  }
+
+  return text.substring(0, maxLen) + '...';
+}
+
+/**
+ * Sanitizes and truncates text for safe logging
+ * @param {string} text - The text to process
+ * @param {number} maxLen - Maximum length (default: 100)
+ * @returns {string} - Sanitized and truncated text
+ */
+export function prepareForLog(text, maxLen = 100) {
+  const sanitized = sanitizeForLog(text);
+  return truncateForLog(sanitized, maxLen);
+}

package/lib/utils/logger.js

@@ -1,148 +1,95 @@
-#!/usr/bin/env node
 /**
- * Structured logging utility for Teleportation CLI
- * Supports different log levels and output formats
+ * Logging utility with configurable log levels
+ * Controls verbosity based on TELEPORTATION_LOG_LEVEL environment variable
  */
 
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-
 const LOG_LEVELS = {
-  DEBUG: 0,
-  INFO: 1,
-  WARN: 2,
-  ERROR: 3,
-  NONE: 4
-};
-
-const LOG_LEVEL_NAMES = {
-  0: 'DEBUG',
-  1: 'INFO',
-  2: 'WARN',
-  3: 'ERROR',
-  4: 'NONE'
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3,
+  verbose: 4
 };
 
-class Logger {
-  constructor(options = {}) {
-    this.level = options.level || (process.env.DEBUG ? LOG_LEVELS.DEBUG : LOG_LEVELS.INFO);
-    this.logFile = options.logFile || path.join(os.homedir(), '.teleportation', 'logs', 'cli.log');
-    this.enableFileLogging = options.enableFileLogging !== false;
-    this.enableColors = options.enableColors !== false && process.stdout.isTTY;
-    
-    // Ensure log directory exists
-    if (this.enableFileLogging) {
-      const logDir = path.dirname(this.logFile);
-      if (!fs.existsSync(logDir)) {
-        fs.mkdirSync(logDir, { recursive: true });
-      }
-    }
-  }
-
-  _colorize(level, message) {
-    if (!this.enableColors) return message;
-    
-    const colors = {
-      DEBUG: '\x1b[0;36m', // Cyan
-      INFO: '\x1b[0;32m',  // Green
-      WARN: '\x1b[1;33m',  // Yellow
-      ERROR: '\x1b[0;31m'  // Red
-    };
-    const reset = '\x1b[0m';
-    
-    return `${colors[level] || ''}${message}${reset}`;
-  }
-
-  _formatMessage(level, message, data = null) {
-    const timestamp = new Date().toISOString();
-    const levelName = LOG_LEVEL_NAMES[level];
-    const prefix = `[${timestamp}] [${levelName}]`;
-    
-    let formatted = `${prefix} ${message}`;
-    if (data) {
-      formatted += ` ${JSON.stringify(data)}`;
-    }
-    
-    return formatted;
-  }
-
-  _write(level, message, data = null) {
-    if (level < this.level) {
-      return;
-    }
-
-    const formatted = this._formatMessage(level, message, data);
-    const levelName = LOG_LEVEL_NAMES[level];
-    
-    // Console output (with colors)
-    const consoleMessage = this._colorize(levelName, formatted);
-    if (level >= LOG_LEVELS.ERROR) {
-      console.error(consoleMessage);
-    } else {
-      console.log(consoleMessage);
-    }
+// Get log level from environment variable, default to 'info'
+const LOG_LEVEL = process.env.TELEPORTATION_LOG_LEVEL || 'info';
+const currentLevel = LOG_LEVELS[LOG_LEVEL] !== undefined ? LOG_LEVELS[LOG_LEVEL] : LOG_LEVELS.info;
 
-    // File output (without colors)
-    if (this.enableFileLogging) {
-      try {
-        fs.appendFileSync(this.logFile, formatted + '\n', { flag: 'a' });
-      } catch (e) {
-        // Silently fail if log file can't be written
-      }
-    }
-  }
-
-  debug(message, data) {
-    this._write(LOG_LEVELS.DEBUG, message, data);
-  }
-
-  info(message, data) {
-    this._write(LOG_LEVELS.INFO, message, data);
-  }
-
-  warn(message, data) {
-    this._write(LOG_LEVELS.WARN, message, data);
-  }
+/**
+ * Check if a message at the given level should be logged
+ * @param {string} level - Log level: 'error', 'warn', 'info', 'debug', 'verbose'
+ * @returns {boolean} - True if message should be logged
+ */
+function shouldLog(level) {
+  const messageLevel = LOG_LEVELS[level] !== undefined ? LOG_LEVELS[level] : LOG_LEVELS.info;
+  return messageLevel <= currentLevel;
+}
 
-  error(message, data) {
-    this._write(LOG_LEVELS.ERROR, message, data);
+/**
+ * Log an error message (always shown)
+ * @param {...any} args - Arguments to log
+ */
+export function logError(...args) {
+  if (shouldLog('error')) {
+    console.error(...args);
   }
+}
 
-  // Convenience methods for common patterns
-  success(message) {
-    if (this.enableColors) {
-      console.log(`\x1b[0;32m✓\x1b[0m ${message}`);
-    } else {
-      console.log(`✓ ${message}`);
-    }
+/**
+ * Log a warning message
+ * @param {...any} args - Arguments to log
+ */
+export function logWarn(...args) {
+  if (shouldLog('warn')) {
+    console.warn(...args);
   }
+}
 
-  failure(message) {
-    if (this.enableColors) {
-      console.error(`\x1b[0;31m✗\x1b[0m ${message}`);
-    } else {
-      console.error(`✗ ${message}`);
-    }
+/**
+ * Log an info message (default level)
+ * @param {...any} args - Arguments to log
+ */
+export function logInfo(...args) {
+  if (shouldLog('info')) {
+    console.log(...args);
   }
+}
 
-  // Get log file path
-  getLogFile() {
-    return this.logFile;
+/**
+ * Log a debug message (requires LOG_LEVEL=debug or verbose)
+ * @param {...any} args - Arguments to log
+ */
+export function logDebug(...args) {
+  if (shouldLog('debug')) {
+    console.log(...args);
   }
+}
 
-  // Set log level
-  setLevel(level) {
-    if (typeof level === 'string') {
-      level = LOG_LEVELS[level.toUpperCase()] || LOG_LEVELS.INFO;
-    }
-    this.level = level;
+/**
+ * Log a verbose message (requires LOG_LEVEL=verbose)
+ * @param {...any} args - Arguments to log
+ */
+export function logVerbose(...args) {
+  if (shouldLog('verbose')) {
+    console.log(...args);
   }
 }
 
-// Create default logger instance
-const logger = new Logger();
+/**
+ * Get the current log level
+ * @returns {string} - Current log level
+ */
+export function getLogLevel() {
+  return LOG_LEVEL;
+}
 
-export default logger;
-export { Logger, LOG_LEVELS };
+/**
+ * Check if debug logging is enabled
+ * @returns {boolean} - True if debug or verbose logging is enabled
+ */
+export function isDebugEnabled() {
+  return shouldLog('debug');
+}
 
+// Export shouldLog for custom level checking
+export { shouldLog };