opencode-pilot 0.19.1 → 0.20.0

package/README.md

@@ -31,7 +31,7 @@ npm install -g opencode-pilot
    }
    ```
 
-   The daemon will auto-start when OpenCode launches.
+   The daemon will auto-start when OpenCode launches. If a newer version of the plugin is installed, the daemon will automatically restart to pick up the new version.
 
    Or start manually:
 
@@ -117,7 +117,8 @@ sources:
 
 ```bash
 opencode-pilot start              # Start the service (foreground)
-opencode-pilot status             # Check status
+opencode-pilot stop               # Stop the running service
+opencode-pilot status             # Show version and service status
 opencode-pilot config             # Validate and show config
 opencode-pilot clear              # Show state summary
 opencode-pilot clear --all        # Clear all processed state

package/bin/opencode-pilot

@@ -13,7 +13,7 @@
 
 import { fileURLToPath } from "url";
 import { dirname, join } from "path";
-import { existsSync, readFileSync } from "fs";
+import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync } from "fs";
 import { execSync } from "child_process";
 import os from "os";
 import YAML from "yaml";
@@ -39,12 +39,73 @@ function findServiceDir() {
 const serviceDir = findServiceDir();
 
 // Paths
-const PILOT_CONFIG_FILE = join(os.homedir(), ".config/opencode/pilot/config.yaml");
-const PILOT_TEMPLATES_DIR = join(os.homedir(), ".config/opencode/pilot/templates");
+const PILOT_CONFIG_DIR = join(os.homedir(), ".config/opencode/pilot");
+const PILOT_CONFIG_FILE = join(PILOT_CONFIG_DIR, "config.yaml");
+const PILOT_TEMPLATES_DIR = join(PILOT_CONFIG_DIR, "templates");
+const PILOT_PID_FILE = join(PILOT_CONFIG_DIR, "pilot.pid");
 
 // Default port
 const DEFAULT_PORT = 4097;
 
+/**
+ * Write PID file
+ */
+function writePidFile() {
+  try {
+    mkdirSync(PILOT_CONFIG_DIR, { recursive: true });
+    writeFileSync(PILOT_PID_FILE, String(process.pid));
+  } catch (err) {
+    console.warn(`[opencode-pilot] Could not write PID file: ${err.message}`);
+  }
+}
+
+/**
+ * Remove PID file
+ */
+function removePidFile() {
+  try {
+    if (existsSync(PILOT_PID_FILE)) {
+      unlinkSync(PILOT_PID_FILE);
+    }
+  } catch {
+    // Ignore errors on cleanup
+  }
+}
+
+/**
+ * Read PID from file
+ * @returns {number|null} PID or null if not found/invalid
+ */
+function readPidFile() {
+  try {
+    if (existsSync(PILOT_PID_FILE)) {
+      const content = readFileSync(PILOT_PID_FILE, "utf8").trim();
+      const pid = parseInt(content, 10);
+      if (!isNaN(pid) && pid > 0) {
+        return pid;
+      }
+    }
+  } catch {
+    // Ignore errors
+  }
+  return null;
+}
+
+/**
+ * Check if a process is running
+ * @param {number} pid - Process ID
+ * @returns {boolean} True if process is running
+ */
+function isProcessRunning(pid) {
+  try {
+    // Signal 0 doesn't kill, just checks if process exists
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Load port from config file
  * @returns {number} Port number
@@ -114,7 +175,8 @@ Usage:
 
 Commands:
   start                Start the polling service (foreground)
-  status               Show service status
+  stop                 Stop the running service
+  status               Show service status and version
   config               Validate and show configuration
   clear                Clear processed state entries
   test-source NAME     Test a source by fetching items and showing mappings
@@ -133,7 +195,8 @@ The service handles:
 
 Examples:
   opencode-pilot start                   # Start service (foreground)
-  opencode-pilot status                  # Check status
+  opencode-pilot stop                    # Stop the service
+  opencode-pilot status                  # Check status and version
   opencode-pilot config                  # Validate and show config
   opencode-pilot clear --all             # Clear all processed state
   opencode-pilot clear --expired         # Clear expired entries
@@ -157,6 +220,9 @@ async function startCommand() {
 
   console.log("[opencode-pilot] Starting polling service...");
   
+  // Write PID file
+  writePidFile();
+  
   // Dynamic import of the service module
   const { startService, stopService } = await import(serverPath);
   
@@ -167,29 +233,91 @@ async function startCommand() {
   const service = await startService(config);
   
   // Handle graceful shutdown
-  process.on("SIGTERM", async () => {
-    console.log("[opencode-pilot] Received SIGTERM, shutting down...");
+  const shutdown = async (signal) => {
+    console.log(`[opencode-pilot] Received ${signal}, shutting down...`);
+    removePidFile();
     await stopService(service);
     process.exit(0);
-  });
+  };
   
-  process.on("SIGINT", async () => {
-    console.log("[opencode-pilot] Received SIGINT, shutting down...");
-    await stopService(service);
-    process.exit(0);
-  });
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGINT", () => shutdown("SIGINT"));
   
   // Keep running until signal received
   await new Promise(() => {});
 }
 
+// ============================================================================
+// Stop Command
+// ============================================================================
+
+function stopCommand() {
+  const pid = readPidFile();
+  
+  if (!pid) {
+    console.log("Service is not running (no PID file found)");
+    process.exit(0);
+  }
+  
+  if (!isProcessRunning(pid)) {
+    console.log(`Service is not running (stale PID file for pid ${pid})`);
+    removePidFile();
+    process.exit(0);
+  }
+  
+  console.log(`Stopping opencode-pilot (pid ${pid})...`);
+  
+  try {
+    process.kill(pid, "SIGTERM");
+    
+    // Wait for process to exit (up to 5 seconds)
+    let attempts = 0;
+    const maxAttempts = 50;
+    const checkInterval = 100;
+    
+    const waitForExit = () => {
+      if (!isProcessRunning(pid)) {
+        console.log("Service stopped");
+        process.exit(0);
+      }
+      
+      attempts++;
+      if (attempts >= maxAttempts) {
+        console.log("Service did not stop gracefully, sending SIGKILL...");
+        try {
+          process.kill(pid, "SIGKILL");
+        } catch {
+          // Process may have exited
+        }
+        removePidFile();
+        console.log("Service killed");
+        process.exit(0);
+      }
+      
+      setTimeout(waitForExit, checkInterval);
+    };
+    
+    setTimeout(waitForExit, checkInterval);
+  } catch (err) {
+    if (err.code === "ESRCH") {
+      console.log("Service is not running");
+      removePidFile();
+    } else {
+      console.error(`Failed to stop service: ${err.message}`);
+      process.exit(1);
+    }
+  }
+}
+
 // ============================================================================
 // Status Command
 // ============================================================================
 
-function statusCommand() {
-  console.log("opencode-pilot status");
-  console.log("=====================");
+async function statusCommand() {
+  const { getVersion } = await import(join(serviceDir, "version.js"));
+  const version = getVersion();
+  console.log(`opencode-pilot v${version}`);
+  console.log("=".repeat(`opencode-pilot v${version}`.length));
   console.log("");
 
   // Service running? Check if HTTP responds
@@ -702,8 +830,12 @@ async function main() {
       await startCommand();
       break;
 
+    case "stop":
+      stopCommand();
+      break;
+
     case "status":
-      statusCommand();
+      await statusCommand();
       break;
 
     case "config":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-pilot",
-  "version": "0.19.1",
+  "version": "0.20.0",
   "type": "module",
   "main": "plugin/index.js",
   "description": "Automation daemon for OpenCode - polls for work and spawns sessions",

package/plugin/index.js

@@ -2,12 +2,14 @@
 //
 // Add "opencode-pilot" to your opencode.json plugins array to enable.
 // The plugin checks if the daemon is running and starts it if needed.
+// If the running daemon has a different version, it will be restarted.
 
 import { existsSync, readFileSync } from 'fs'
-import { spawn } from 'child_process'
+import { spawn, spawnSync } from 'child_process'
 import { join } from 'path'
 import { homedir } from 'os'
 import YAML from 'yaml'
+import { getVersion } from '../service/version.js'
 
 const DEFAULT_PORT = 4097
 const CONFIG_PATH = join(homedir(), '.config', 'opencode', 'pilot', 'config.yaml')
@@ -32,31 +34,67 @@ function getPort() {
 }
 
 /**
- * OpenCode plugin that auto-starts the daemon if not running
+ * Start the daemon as a detached background process
+ */
+function startDaemon() {
+  try {
+    const child = spawn('npx', ['opencode-pilot', 'start'], {
+      detached: true,
+      stdio: 'ignore',
+    })
+    child.unref()
+  } catch {
+    // Ignore start errors
+  }
+}
+
+/**
+ * Stop the daemon synchronously
+ */
+function stopDaemon() {
+  try {
+    spawnSync('npx', ['opencode-pilot', 'stop'], {
+      stdio: 'ignore',
+      timeout: 10000,
+    })
+  } catch {
+    // Ignore stop errors
+  }
+}
+
+/**
+ * OpenCode plugin that auto-starts the daemon if not running.
+ * If a daemon is running with a different version, it will be restarted.
  */
 export const PilotPlugin = async () => {
   const port = getPort()
+  const ourVersion = getVersion()
   
   try {
     // Check if daemon is already running
     const res = await fetch(`http://localhost:${port}/health`, {
       signal: AbortSignal.timeout(1000)
     })
+    
     if (res.ok) {
-      // Already running, nothing to do
+      // Check version
+      const data = await res.json()
+      const runningVersion = data.version
+      
+      if (runningVersion && runningVersion !== ourVersion && ourVersion !== 'unknown') {
+        // Version mismatch - restart daemon
+        console.log(`[opencode-pilot] Version mismatch (running: ${runningVersion}, plugin: ${ourVersion}), restarting...`)
+        stopDaemon()
+        // Small delay to ensure port is released
+        await new Promise(resolve => setTimeout(resolve, 500))
+        startDaemon()
+      }
+      // else: same version, nothing to do
       return {}
     }
   } catch {
-    // Not running, start it as detached background process
-    try {
-      const child = spawn('npx', ['opencode-pilot', 'start'], {
-        detached: true,
-        stdio: 'ignore',
-      })
-      child.unref()
-    } catch {
-      // Ignore start errors
-    }
+    // Not running or error, start it
+    startDaemon()
   }
   
   return {}

package/service/server.js

@@ -10,6 +10,7 @@ import { fileURLToPath } from 'url'
 import { homedir } from 'os'
 import { join } from 'path'
 import YAML from 'yaml'
+import { getVersion } from './version.js'
 
 // Default configuration
 const DEFAULT_HTTP_PORT = 4097
@@ -56,10 +57,11 @@ function createHttpServer_(port) {
       return
     }
     
-    // GET /health - Health check
+    // GET /health - Health check with version
     if (req.method === 'GET' && url.pathname === '/health') {
-      res.writeHead(200, { 'Content-Type': 'text/plain' })
-      res.end('OK')
+      const version = getVersion()
+      res.writeHead(200, { 'Content-Type': 'application/json' })
+      res.end(JSON.stringify({ status: 'ok', version }))
       return
     }
     

package/service/version.js

@@ -0,0 +1,34 @@
+// Shared version utility for opencode-pilot
+//
+// Returns the version from package.json
+
+import { existsSync, readFileSync } from 'fs'
+import { join, dirname } from 'path'
+import { fileURLToPath } from 'url'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+/**
+ * Get version from package.json
+ * Checks multiple locations for compatibility with different install methods
+ * @returns {string} Version string or 'unknown'
+ */
+export function getVersion() {
+  const candidates = [
+    join(__dirname, '..', 'package.json'),      // Development: service/../package.json
+    join(__dirname, '..', '..', 'package.json'), // Homebrew: libexec/../package.json
+  ]
+  
+  for (const packagePath of candidates) {
+    try {
+      if (existsSync(packagePath)) {
+        const pkg = JSON.parse(readFileSync(packagePath, 'utf8'))
+        if (pkg.version) return pkg.version
+      }
+    } catch {
+      // Try next candidate
+    }
+  }
+  return 'unknown'
+}

package/test/unit/server.test.js

@@ -0,0 +1,90 @@
+/**
+ * Tests for service/server.js - HTTP server and health endpoint
+ */
+
+import { test, describe, afterEach } from 'node:test';
+import assert from 'node:assert';
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Get expected version from package.json
+function getExpectedVersion() {
+  const packagePath = join(__dirname, '..', '..', 'package.json');
+  const pkg = JSON.parse(readFileSync(packagePath, 'utf8'));
+  return pkg.version;
+}
+
+describe('service/server.js', () => {
+  let service = null;
+
+  afterEach(async () => {
+    if (service) {
+      const { stopService } = await import('../../service/server.js');
+      await stopService(service);
+      service = null;
+    }
+  });
+
+  describe('health endpoint', () => {
+    test('returns JSON with status and version', async () => {
+      const { startService, stopService } = await import('../../service/server.js');
+      
+      // Start service on random port
+      service = await startService({ 
+        httpPort: 0,  // Let OS assign port
+        enablePolling: false 
+      });
+      
+      const port = service.httpServer.address().port;
+      const res = await fetch(`http://localhost:${port}/health`);
+      
+      assert.strictEqual(res.status, 200);
+      assert.strictEqual(res.headers.get('content-type'), 'application/json');
+      
+      const data = await res.json();
+      assert.strictEqual(data.status, 'ok');
+      assert.strictEqual(typeof data.version, 'string');
+      assert.strictEqual(data.version, getExpectedVersion());
+    });
+
+  });
+
+  describe('CORS', () => {
+    test('OPTIONS returns CORS headers', async () => {
+      const { startService } = await import('../../service/server.js');
+      
+      service = await startService({ 
+        httpPort: 0,
+        enablePolling: false 
+      });
+      
+      const port = service.httpServer.address().port;
+      const res = await fetch(`http://localhost:${port}/health`, {
+        method: 'OPTIONS'
+      });
+      
+      assert.strictEqual(res.status, 204);
+      assert.strictEqual(res.headers.get('access-control-allow-origin'), '*');
+    });
+  });
+
+  describe('unknown routes', () => {
+    test('returns 404 for unknown paths', async () => {
+      const { startService } = await import('../../service/server.js');
+      
+      service = await startService({ 
+        httpPort: 0,
+        enablePolling: false 
+      });
+      
+      const port = service.httpServer.address().port;
+      const res = await fetch(`http://localhost:${port}/unknown`);
+      
+      assert.strictEqual(res.status, 404);
+    });
+  });
+});