opencode-pilot 0.1.0

package/plugin/index.js

@@ -0,0 +1,260 @@
+// opencode-pilot - ntfy notification plugin for OpenCode
+//
+// This plugin sends notifications via ntfy.sh when:
+// - Session goes idle after delay
+// - Errors or retries occur
+//
+// Configuration via ~/.config/opencode-pilot/config.yaml
+// See README.md for full configuration options.
+
+import { basename } from 'path'
+import { sendNotification } from './notifier.js'
+import { loadConfig } from './config.js'
+import { initLogger, debug } from './logger.js'
+
+/**
+ * Parse directory path to extract repo name (and branch if in devcontainer clone)
+ * 
+ * Devcontainer clone paths follow the pattern:
+ *   /path/.cache/devcontainer-clones/{repo}/{branch}
+ * 
+ * For these paths, returns "{repo}/{branch}" to show both in notifications.
+ * For regular paths, returns just the basename.
+ * 
+ * @param {string} directory - Directory path from OpenCode
+ * @returns {string} Repo name (with branch suffix for devcontainer clones)
+ */
+function parseRepoInfo(directory) {
+  if (!directory) {
+    return 'unknown'
+  }
+  
+  // Check for devcontainer-clones path pattern
+  const devcontainerMatch = directory.match(/devcontainer-clones\/([^/]+)\/([^/]+)$/)
+  if (devcontainerMatch) {
+    const [, repo, branch] = devcontainerMatch
+    return `${repo}/${branch}`
+  }
+  
+  // Fall back to basename for regular directories
+  return basename(directory) || 'unknown'
+}
+
+// Load configuration from config file and environment
+const config = loadConfig()
+
+// Initialize debug logger (writes to file when enabled, no-op when disabled)
+initLogger({ debug: config.debug, debugPath: config.debugPath })
+
+const Notify = async ({ client, directory }) => {
+  if (!config.topic) {
+    debug('Plugin disabled: no topic configured')
+    return {}
+  }
+  
+  // Use directory from OpenCode (the actual repo), not process.cwd() (may be temp devcontainer dir)
+  // For devcontainer clones, show both repo and branch name
+  const repoName = parseRepoInfo(directory)
+  
+  debug(`Plugin initialized: topic=${config.topic}, repo=${repoName}`)
+  
+  // Per-conversation state tracking (Issue #34)
+  // Each conversation has its own idle timer, cancel state, etc.
+  // Key: conversationId (OpenCode session ID)
+  const conversations = new Map()
+  
+  // Session ownership verification (Issue #50)
+  // Prevents duplicate notifications when multiple OpenCode instances are running.
+  // Events may be broadcast to all plugin instances, so we verify each session
+  // belongs to our OpenCode instance before processing.
+  const verifiedSessions = new Set()   // Sessions confirmed to be ours
+  const rejectedSessions = new Set()   // Sessions confirmed to be foreign
+  
+  // Global state (shared across all conversations in this plugin instance)
+  let retryCount = 0
+  let lastErrorTime = 0
+
+  // Helper to get or create conversation state (Issue #34)
+  const getConversation = (id) => {
+    if (!id) return null
+    if (!conversations.has(id)) {
+      conversations.set(id, { idleTimer: null, wasCanceled: false })
+    }
+    return conversations.get(id)
+  }
+  
+  // Verify session ownership by checking if it exists in our OpenCode instance (Issue #50)
+  // Returns true if session belongs to us, false if it's foreign
+  const verifySessionOwnership = async (sessionId) => {
+    if (!sessionId) return false
+    
+    // Already verified as ours
+    if (verifiedSessions.has(sessionId)) return true
+    
+    // Already rejected as foreign
+    if (rejectedSessions.has(sessionId)) return false
+    
+    // Query our OpenCode instance to check if session exists
+    try {
+      const result = await client.session.get({ id: sessionId })
+      if (result.data) {
+        verifiedSessions.add(sessionId)
+        return true
+      }
+      // Session doesn't exist in our instance - it's foreign
+      rejectedSessions.add(sessionId)
+      return false
+    } catch {
+      // Error (likely 404) means session doesn't exist in our instance
+      rejectedSessions.add(sessionId)
+      return false
+    }
+  }
+
+  return {
+    event: async ({ event }) => {
+      debug(`Event: ${event.type}`)
+      
+      // Handle session status events (idle, busy, retry notifications)
+      if (event.type === 'session.status') {
+        const status = event.properties?.status?.type
+        // Extract conversation ID from event for per-conversation tracking (Issue #34)
+        // OpenCode uses sessionID (capital ID)
+        const conversationId = event.properties?.sessionID || event.properties?.info?.id
+        debug(`Event: session.status, status=${status}, sessionId=${conversationId || 'unknown'}`)
+        
+        // Verify session belongs to our OpenCode instance (Issue #50)
+        // Skip events for sessions from other OpenCode instances to prevent duplicates
+        const isOurs = await verifySessionOwnership(conversationId)
+        if (!isOurs) return
+        
+        const conv = getConversation(conversationId)
+        
+        // Skip if no conversation ID or already canceled
+        if (!conv) return
+        if (conv.wasCanceled && status !== 'canceled') return
+        
+        // Handle canceled status - suppress all future notifications for this conversation
+        if (status === 'canceled') {
+          conv.wasCanceled = true
+          if (conv.idleTimer) {
+            clearTimeout(conv.idleTimer)
+            conv.idleTimer = null
+          }
+          // Clean up conversation state
+          conversations.delete(conversationId)
+          return
+        }
+        
+        // Handle retry status
+        if (status === 'retry') {
+          retryCount++
+          
+          // Check if we should notify based on config
+          const shouldNotifyFirst = config.retryNotifyFirst && retryCount === 1
+          const shouldNotifyAfterN = config.retryNotifyAfter > 0 && retryCount === config.retryNotifyAfter
+          
+          if (shouldNotifyFirst || shouldNotifyAfterN) {
+            await sendNotification({
+              server: config.server,
+              topic: config.topic,
+              title: `Retry (${repoName})`,
+              message: `Retry attempt #${retryCount}`,
+              priority: 4,
+              tags: ['repeat'],
+              authToken: config.authToken,
+            })
+          }
+          return
+        }
+        
+        // Reset retry counter on any non-retry status
+        if (retryCount > 0) {
+          retryCount = 0
+        }
+        
+        // Handle idle status - set timer for THIS conversation
+        if (status === 'idle' && !conv.idleTimer) {
+          debug(`Idle timer starting: ${config.idleDelayMs}ms for session ${conversationId}`)
+          // Capture conversation ID in closure so notification goes to correct conversation
+          const capturedSessionId = conversationId
+          
+          conv.idleTimer = setTimeout(async () => {
+            // Clear timer reference immediately to prevent race conditions
+            const currentConv = conversations.get(capturedSessionId)
+            if (currentConv) {
+              currentConv.idleTimer = null
+            }
+            
+            // Don't send notification if conversation was canceled
+            if (currentConv?.wasCanceled) {
+              return
+            }
+            
+            await sendNotification({
+              server: config.server,
+              topic: config.topic,
+              title: `Idle (${repoName})`,
+              message: 'Session waiting for input',
+              authToken: config.authToken,
+            })
+          }, config.idleDelayMs)
+        } else if (status === 'busy' && conv.idleTimer) {
+          debug(`Idle timer cancelled: session ${conversationId} now busy`)
+          clearTimeout(conv.idleTimer)
+          conv.idleTimer = null
+        }
+      }
+      
+      // Handle session.error events (debounced error notifications)
+      if (event.type === 'session.error') {
+        if (!config.errorNotify) {
+          return
+        }
+        
+        const now = Date.now()
+        const timeSinceLastError = now - lastErrorTime
+        
+        if (lastErrorTime === 0 || timeSinceLastError >= config.errorDebounceMs) {
+          lastErrorTime = now
+          
+          // Extract error message with fallback chain
+          const errorMessage = 
+            event.properties?.error?.message ||
+            event.properties?.message ||
+            event.properties?.error?.code ||
+            event.properties?.error?.type ||
+            'Unknown error'
+          
+          await sendNotification({
+            server: config.server,
+            topic: config.topic,
+            title: `Error (${repoName})`,
+            message: errorMessage,
+            priority: 5,
+            tags: ['warning'],
+            authToken: config.authToken,
+          })
+        }
+      }
+    },
+    
+    // Cleanup on shutdown
+    shutdown: async () => {
+      // Clear all conversation idle timers
+      for (const [, conv] of conversations) {
+        if (conv.idleTimer) {
+          clearTimeout(conv.idleTimer)
+          conv.idleTimer = null
+        }
+      }
+      conversations.clear()
+      
+      // Clear session ownership caches (Issue #50)
+      verifiedSessions.clear()
+      rejectedSessions.clear()
+    },
+  }
+}
+
+export default Notify

package/plugin/logger.js

@@ -0,0 +1,125 @@
+// Debug logging module for opencode-pilot plugin
+// Writes to ~/.config/opencode-pilot/debug.log when enabled via NTFY_DEBUG=true or config.debug
+//
+// Usage:
+//   import { initLogger, debug } from './logger.js'
+//   initLogger({ debug: true, debugPath: '/custom/path.log' })
+//   debug('Event received', { type: 'session.status', status: 'idle' })
+
+import { appendFileSync, existsSync, mkdirSync, statSync, unlinkSync } from 'fs'
+import { join, dirname } from 'path'
+import { homedir } from 'os'
+
+// Maximum log file size before rotation (1MB)
+export const MAX_LOG_SIZE = 1024 * 1024
+
+// Default log path
+const DEFAULT_LOG_PATH = join(homedir(), '.config', 'opencode-pilot', 'debug.log')
+
+// Module state
+let enabled = false
+let logPath = DEFAULT_LOG_PATH
+
+/**
+ * Initialize the logger with configuration
+ * @param {Object} options
+ * @param {boolean} [options.debug] - Enable debug logging
+ * @param {string} [options.debugPath] - Custom log file path
+ */
+export function initLogger(options = {}) {
+  // Check environment variables first, then options
+  const envDebug = process.env.NTFY_DEBUG
+  const envDebugPath = process.env.NTFY_DEBUG_PATH
+  
+  // Enable if NTFY_DEBUG is set to any truthy value (not 'false' or '0')
+  if (envDebug !== undefined && envDebug !== '' && envDebug !== 'false' && envDebug !== '0') {
+    enabled = true
+  } else if (options.debug !== undefined) {
+    enabled = Boolean(options.debug)
+  } else {
+    enabled = false
+  }
+  
+  // Set log path (env var takes precedence)
+  if (envDebugPath) {
+    logPath = envDebugPath
+  } else if (options.debugPath) {
+    logPath = options.debugPath
+  } else {
+    logPath = DEFAULT_LOG_PATH
+  }
+  
+  // Create directory if it doesn't exist
+  if (enabled) {
+    try {
+      const dir = dirname(logPath)
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true })
+      }
+    } catch {
+      // Silently ignore directory creation errors
+    }
+  }
+}
+
+/**
+ * Write a debug log entry
+ * @param {string} message - Log message
+ * @param {Object} [data] - Optional data to include
+ */
+export function debug(message, data) {
+  if (!enabled) {
+    return
+  }
+  
+  try {
+    // Check file size and rotate if needed
+    rotateIfNeeded()
+    
+    // Format log entry with ISO 8601 timestamp
+    const timestamp = new Date().toISOString()
+    let entry = `[${timestamp}] ${message}`
+    
+    // Append data if provided
+    if (data !== undefined) {
+      if (typeof data === 'object') {
+        entry += ' ' + JSON.stringify(data)
+      } else {
+        entry += ' ' + String(data)
+      }
+    }
+    
+    entry += '\n'
+    
+    // Ensure directory exists
+    const dir = dirname(logPath)
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true })
+    }
+    
+    // Append to log file
+    appendFileSync(logPath, entry)
+  } catch {
+    // Silently ignore write errors to avoid affecting the plugin
+  }
+}
+
+/**
+ * Rotate log file if it exceeds MAX_LOG_SIZE
+ */
+function rotateIfNeeded() {
+  try {
+    if (!existsSync(logPath)) {
+      return
+    }
+    
+    const stats = statSync(logPath)
+    if (stats.size > MAX_LOG_SIZE) {
+      // Simple rotation: just truncate the file
+      // For more sophisticated rotation, could rename to .old first
+      unlinkSync(logPath)
+    }
+  } catch {
+    // Silently ignore rotation errors
+  }
+}

package/plugin/notifier.js

@@ -0,0 +1,110 @@
+// ntfy HTTP client for sending notifications
+
+import { debug } from './logger.js'
+
+// Deduplication cache: track recently sent notifications to prevent duplicates
+// Key: hash of notification content, Value: timestamp
+const recentNotifications = new Map()
+const DEDUPE_WINDOW_MS = 5000 // 5 seconds
+
+/**
+ * Generate a simple hash for deduplication
+ * @param {string} str - String to hash
+ * @returns {string} Simple hash
+ */
+function simpleHash(str) {
+  let hash = 0
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i)
+    hash = ((hash << 5) - hash) + char
+    hash = hash & hash // Convert to 32bit integer
+  }
+  return hash.toString(36)
+}
+
+/**
+ * Check if notification was recently sent (for deduplication)
+ * @param {string} key - Deduplication key
+ * @returns {boolean} True if duplicate
+ */
+function isDuplicate(key) {
+  const now = Date.now()
+  
+  // Clean up old entries
+  for (const [k, timestamp] of recentNotifications) {
+    if (now - timestamp > DEDUPE_WINDOW_MS) {
+      recentNotifications.delete(k)
+    }
+  }
+  
+  if (recentNotifications.has(key)) {
+    return true
+  }
+  
+  recentNotifications.set(key, now)
+  return false
+}
+
+/**
+ * Build headers for ntfy requests
+ * @param {string} [authToken] - Optional ntfy access token for Bearer auth
+ * @returns {Object} Headers object
+ */
+function buildHeaders(authToken) {
+  const headers = {
+    'Content-Type': 'application/json',
+  }
+  
+  if (authToken) {
+    headers['Authorization'] = `Bearer ${authToken}`
+  }
+  
+  return headers
+}
+
+/**
+ * Send a basic notification to ntfy
+ * @param {Object} options
+ * @param {string} options.server - ntfy server URL
+ * @param {string} options.topic - ntfy topic name
+ * @param {string} options.title - Notification title
+ * @param {string} options.message - Notification message
+ * @param {number} [options.priority] - Priority (1-5, default 3)
+ * @param {string[]} [options.tags] - Emoji tags
+ * @param {string} [options.authToken] - Optional ntfy access token for protected topics
+ */
+export async function sendNotification({ server, topic, title, message, priority, tags, authToken }) {
+  // Deduplicate: skip if same notification sent recently
+  const dedupeKey = simpleHash(`${topic}:${title}:${message}`)
+  if (isDuplicate(dedupeKey)) {
+    debug(`Notification skipped (duplicate): ${title}`)
+    return
+  }
+
+  const body = {
+    topic,
+    title,
+    message,
+  }
+
+  // Add optional fields only if provided
+  if (priority !== undefined) {
+    body.priority = priority
+  }
+  if (tags && tags.length > 0) {
+    body.tags = tags
+  }
+
+  try {
+    debug(`Notification sending: ${title}`)
+    const response = await fetch(server, {
+      method: 'POST',
+      headers: buildHeaders(authToken),
+      body: JSON.stringify(body),
+    })
+    debug(`Notification sent: ${title} (status=${response.status})`)
+  } catch (error) {
+    debug(`Notification failed: ${title} (error=${error.message})`)
+    // Silently ignore - errors here shouldn't affect the user
+  }
+}