opencode-pilot 0.19.1 → 0.20.1

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.1",
   "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/actions.js

@@ -14,6 +14,84 @@ import { resolveWorktreeDirectory, getProjectInfo, getProjectInfoForDirectory }
 import path from "path";
 import os from "os";
 
+/**
+ * Parse a slash command from the beginning of a prompt
+ * Returns null if the prompt doesn't start with a slash command
+ * 
+ * @param {string} prompt - The prompt text
+ * @returns {object|null} { command, arguments, rest } or null
+ */
+export function parseSlashCommand(prompt) {
+  if (!prompt || typeof prompt !== 'string') {
+    return null;
+  }
+  
+  // Match /command at the start, followed by optional arguments on the same line
+  // Command names can contain letters, numbers, hyphens, and underscores
+  const match = prompt.match(/^\/([a-zA-Z0-9_-]+)(?:\s+(.*))?$/m);
+  
+  if (!match) {
+    return null;
+  }
+  
+  const command = match[1];
+  const firstLineArgs = match[2]?.trim() || '';
+  
+  // Find where the first line ends to get the "rest" of the prompt
+  const firstNewline = prompt.indexOf('\n');
+  const rest = firstNewline >= 0 ? prompt.slice(firstNewline + 1).trim() : '';
+  
+  return {
+    command,
+    arguments: firstLineArgs,
+    rest,
+  };
+}
+
+/**
+ * Send a command to a session via the /command endpoint
+ * 
+ * @param {string} serverUrl - Server URL
+ * @param {string} sessionId - Session ID
+ * @param {string} directory - Working directory
+ * @param {object} parsedCommand - Parsed command from parseSlashCommand
+ * @param {object} [options] - Options
+ * @param {string} [options.agent] - Agent to use
+ * @param {string} [options.model] - Model to use
+ * @param {function} [options.fetch] - Custom fetch function (for testing)
+ * @returns {Promise<Response>} The fetch response
+ */
+async function sendCommand(serverUrl, sessionId, directory, parsedCommand, options = {}) {
+  const fetchFn = options.fetch || fetch;
+  
+  const commandUrl = new URL(`/session/${sessionId}/command`, serverUrl);
+  commandUrl.searchParams.set('directory', directory);
+  
+  // Build command body per OpenCode API schema
+  const commandBody = {
+    command: parsedCommand.command,
+    arguments: parsedCommand.arguments,
+  };
+  
+  // Add agent if specified
+  if (options.agent) {
+    commandBody.agent = options.agent;
+  }
+  
+  // Add model if specified (the /command endpoint takes model as a single string)
+  if (options.model) {
+    commandBody.model = options.model;
+  }
+  
+  debug(`sendCommand: POST ${commandUrl} command=${parsedCommand.command} args=${parsedCommand.arguments}`);
+  
+  return fetchFn(commandUrl.toString(), {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(commandBody),
+  });
+}
+
 /**
  * Get running opencode server ports by parsing lsof output
  * @returns {Promise<number[]>} Array of port numbers
@@ -455,50 +533,65 @@ export async function sendMessageToSession(serverUrl, sessionId, directory, prom
       debug(`sendMessageToSession: updated title for session ${sessionId}`);
     }
     
-    // Step 2: Send the message
-    const messageUrl = new URL(`/session/${sessionId}/message`, serverUrl);
-    messageUrl.searchParams.set('directory', directory);
-    
-    const messageBody = {
-      parts: [{ type: 'text', text: prompt }],
-    };
-    
-    if (options.agent) {
-      messageBody.agent = options.agent;
-    }
-    
-    if (options.model) {
-      const [providerID, modelID] = options.model.includes('/') 
-        ? options.model.split('/', 2) 
-        : ['anthropic', options.model];
-      messageBody.providerID = providerID;
-      messageBody.modelID = modelID;
-    }
+    // Step 2: Check if the prompt starts with a slash command
+    const parsedCommand = parseSlashCommand(prompt);
     
     // Use AbortController with timeout (same pattern as createSessionViaApi)
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), 10000);
     
     try {
-      const messageResponse = await fetchFn(messageUrl.toString(), {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(messageBody),
-        signal: controller.signal,
-      });
+      let response;
+      
+      if (parsedCommand) {
+        // Use the /command endpoint for slash commands
+        debug(`sendMessageToSession: detected command /${parsedCommand.command}`);
+        response = await sendCommand(serverUrl, sessionId, directory, parsedCommand, {
+          agent: options.agent,
+          model: options.model,
+          fetch: (url, opts) => fetchFn(url, { ...opts, signal: controller.signal }),
+        });
+      } else {
+        // Use the /message endpoint for regular prompts
+        const messageUrl = new URL(`/session/${sessionId}/message`, serverUrl);
+        messageUrl.searchParams.set('directory', directory);
+        
+        const messageBody = {
+          parts: [{ type: 'text', text: prompt }],
+        };
+        
+        if (options.agent) {
+          messageBody.agent = options.agent;
+        }
+        
+        if (options.model) {
+          const [providerID, modelID] = options.model.includes('/') 
+            ? options.model.split('/', 2) 
+            : ['anthropic', options.model];
+          messageBody.providerID = providerID;
+          messageBody.modelID = modelID;
+        }
+        
+        response = await fetchFn(messageUrl.toString(), {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify(messageBody),
+          signal: controller.signal,
+        });
+      }
       
       clearTimeout(timeoutId);
       
-      if (!messageResponse.ok) {
-        const errorText = await messageResponse.text();
-        throw new Error(`Failed to send message: ${messageResponse.status} ${errorText}`);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Failed to send ${parsedCommand ? 'command' : 'message'}: ${response.status} ${errorText}`);
       }
       
-      debug(`sendMessageToSession: sent message to session ${sessionId}`);
+      debug(`sendMessageToSession: sent ${parsedCommand ? 'command' : 'message'} to session ${sessionId}`);
     } catch (abortErr) {
       clearTimeout(timeoutId);
       if (abortErr.name === 'AbortError') {
-        debug(`sendMessageToSession: message request started for session ${sessionId} (response aborted as expected)`);
+        debug(`sendMessageToSession: request started for session ${sessionId} (response aborted as expected)`);
       } else {
         throw abortErr;
       }
@@ -610,58 +703,72 @@ export async function createSessionViaApi(serverUrl, directory, prompt, options
       });
     }
     
-    // Step 3: Send the initial message
-    const messageUrl = new URL(`/session/${session.id}/message`, serverUrl);
-    messageUrl.searchParams.set('directory', directory);
-    
-    // Build message body
-    const messageBody = {
-      parts: [{ type: 'text', text: prompt }],
-    };
-    
-    // Add agent if specified
-    if (options.agent) {
-      messageBody.agent = options.agent;
-    }
-    
-    // Add model if specified (format: provider/model)
-    if (options.model) {
-      const [providerID, modelID] = options.model.includes('/') 
-        ? options.model.split('/', 2) 
-        : ['anthropic', options.model];
-      messageBody.providerID = providerID;
-      messageBody.modelID = modelID;
-    }
+    // Step 3: Check if the prompt starts with a slash command
+    const parsedCommand = parseSlashCommand(prompt);
     
-    // Use AbortController with timeout for the message POST
-    // The /session/{id}/message endpoint returns a chunked/streaming response
-    // that stays open until the agent completes. We only need to verify the
-    // request was accepted (2xx status), not wait for the full response.
+    // Use AbortController with timeout for the request
+    // The endpoints return a chunked/streaming response that stays open until
+    // the agent completes. We only need to verify the request was accepted.
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), 10000); // 10 second timeout
     
     try {
-      const messageResponse = await fetchFn(messageUrl.toString(), {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(messageBody),
-        signal: controller.signal,
-      });
+      let response;
+      
+      if (parsedCommand) {
+        // Use the /command endpoint for slash commands
+        debug(`createSessionViaApi: detected command /${parsedCommand.command}`);
+        response = await sendCommand(serverUrl, session.id, directory, parsedCommand, {
+          agent: options.agent,
+          model: options.model,
+          fetch: (url, opts) => fetchFn(url, { ...opts, signal: controller.signal }),
+        });
+      } else {
+        // Use the /message endpoint for regular prompts
+        const messageUrl = new URL(`/session/${session.id}/message`, serverUrl);
+        messageUrl.searchParams.set('directory', directory);
+        
+        // Build message body
+        const messageBody = {
+          parts: [{ type: 'text', text: prompt }],
+        };
+        
+        // Add agent if specified
+        if (options.agent) {
+          messageBody.agent = options.agent;
+        }
+        
+        // Add model if specified (format: provider/model)
+        if (options.model) {
+          const [providerID, modelID] = options.model.includes('/') 
+            ? options.model.split('/', 2) 
+            : ['anthropic', options.model];
+          messageBody.providerID = providerID;
+          messageBody.modelID = modelID;
+        }
+        
+        response = await fetchFn(messageUrl.toString(), {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify(messageBody),
+          signal: controller.signal,
+        });
+      }
       
       clearTimeout(timeoutId);
       
-      if (!messageResponse.ok) {
-        const errorText = await messageResponse.text();
-        throw new Error(`Failed to send message: ${messageResponse.status} ${errorText}`);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Failed to send ${parsedCommand ? 'command' : 'message'}: ${response.status} ${errorText}`);
       }
       
-      debug(`createSessionViaApi: sent message to session ${session.id}`);
+      debug(`createSessionViaApi: sent ${parsedCommand ? 'command' : 'message'} to session ${session.id}`);
     } catch (abortErr) {
       clearTimeout(timeoutId);
       // AbortError is expected - we intentionally abort after verifying the request started
-      // The server accepted our message, we just don't need to wait for the response
+      // The server accepted our request, we just don't need to wait for the response
       if (abortErr.name === 'AbortError') {
-        debug(`createSessionViaApi: message request started for session ${session.id} (response aborted as expected)`);
+        debug(`createSessionViaApi: request started for session ${session.id} (response aborted as expected)`);
       } else {
         throw abortErr;
       }

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/actions.test.js

@@ -97,6 +97,96 @@ describe('actions.js', () => {
     });
   });
 
+  describe('parseSlashCommand', () => {
+    test('parses /review command with URL argument', async () => {
+      const { parseSlashCommand } = await import('../../service/actions.js');
+      
+      const result = parseSlashCommand('/review https://github.com/org/repo/pull/123');
+      
+      assert.strictEqual(result.command, 'review');
+      assert.strictEqual(result.arguments, 'https://github.com/org/repo/pull/123');
+      assert.strictEqual(result.rest, '');
+    });
+
+    test('parses /devcontainer command with URL argument', async () => {
+      const { parseSlashCommand } = await import('../../service/actions.js');
+      
+      const result = parseSlashCommand('/devcontainer https://github.com/org/repo/issues/456');
+      
+      assert.strictEqual(result.command, 'devcontainer');
+      assert.strictEqual(result.arguments, 'https://github.com/org/repo/issues/456');
+      assert.strictEqual(result.rest, '');
+    });
+
+    test('parses command with multiline rest content', async () => {
+      const { parseSlashCommand } = await import('../../service/actions.js');
+      
+      const prompt = `/review https://github.com/org/repo/pull/123
+
+Review this pull request:
+
+Check for bugs and security issues.`;
+      
+      const result = parseSlashCommand(prompt);
+      
+      assert.strictEqual(result.command, 'review');
+      assert.strictEqual(result.arguments, 'https://github.com/org/repo/pull/123');
+      assert.ok(result.rest.includes('Review this pull request'));
+      assert.ok(result.rest.includes('Check for bugs'));
+    });
+
+    test('parses command without arguments', async () => {
+      const { parseSlashCommand } = await import('../../service/actions.js');
+      
+      const result = parseSlashCommand('/help');
+      
+      assert.strictEqual(result.command, 'help');
+      assert.strictEqual(result.arguments, '');
+      assert.strictEqual(result.rest, '');
+    });
+
+    test('parses command with hyphen in name', async () => {
+      const { parseSlashCommand } = await import('../../service/actions.js');
+      
+      const result = parseSlashCommand('/my-custom-command arg1 arg2');
+      
+      assert.strictEqual(result.command, 'my-custom-command');
+      assert.strictEqual(result.arguments, 'arg1 arg2');
+    });
+
+    test('returns null for regular prompt without slash', async () => {
+      const { parseSlashCommand } = await import('../../service/actions.js');
+      
+      const result = parseSlashCommand('Fix the bug in the login page');
+      
+      assert.strictEqual(result, null);
+    });
+
+    test('returns null for prompt with slash in middle', async () => {
+      const { parseSlashCommand } = await import('../../service/actions.js');
+      
+      const result = parseSlashCommand('Check the path/to/file for issues');
+      
+      assert.strictEqual(result, null);
+    });
+
+    test('returns null for empty string', async () => {
+      const { parseSlashCommand } = await import('../../service/actions.js');
+      
+      assert.strictEqual(parseSlashCommand(''), null);
+      assert.strictEqual(parseSlashCommand(null), null);
+      assert.strictEqual(parseSlashCommand(undefined), null);
+    });
+
+    test('returns null for just a slash', async () => {
+      const { parseSlashCommand } = await import('../../service/actions.js');
+      
+      const result = parseSlashCommand('/');
+      
+      assert.strictEqual(result, null);
+    });
+  });
+
   describe('getActionConfig', () => {
     test('merges source, repo, and defaults', async () => {
       const { getActionConfig } = await import('../../service/actions.js');
@@ -903,6 +993,253 @@ describe('actions.js', () => {
       assert.ok(result.warning, 'Should include warning about message failure');
       assert.ok(result.warning.includes('Failed to send message'), 'Warning should mention message failure');
     });
+
+    test('uses /command endpoint for slash commands', async () => {
+      const { createSessionViaApi } = await import('../../service/actions.js');
+      
+      const mockSessionId = 'ses_cmd123';
+      let commandCalled = false;
+      let commandUrl = null;
+      let commandBody = null;
+      let messageCalled = false;
+      
+      const mockFetch = async (url, opts) => {
+        const urlObj = new URL(url);
+        
+        if (urlObj.pathname === '/session' && opts?.method === 'POST') {
+          return {
+            ok: true,
+            json: async () => ({ id: mockSessionId }),
+          };
+        }
+        
+        if (urlObj.pathname.includes('/command') && opts?.method === 'POST') {
+          commandCalled = true;
+          commandUrl = url;
+          commandBody = JSON.parse(opts.body);
+          return {
+            ok: true,
+            json: async () => ({ success: true }),
+          };
+        }
+        
+        if (urlObj.pathname.includes('/message') && opts?.method === 'POST') {
+          messageCalled = true;
+          return {
+            ok: true,
+            json: async () => ({ success: true }),
+          };
+        }
+        
+        // PATCH for title update
+        if (opts?.method === 'PATCH') {
+          return { ok: true, json: async () => ({}) };
+        }
+        
+        return { ok: false, text: async () => 'Not found' };
+      };
+      
+      const result = await createSessionViaApi(
+        'http://localhost:4096',
+        '/path/to/project',
+        '/review https://github.com/org/repo/pull/123',
+        { fetch: mockFetch }
+      );
+      
+      assert.ok(result.success, 'Should succeed');
+      assert.ok(commandCalled, 'Should call /command endpoint');
+      assert.ok(!messageCalled, 'Should NOT call /message endpoint');
+      assert.ok(commandUrl.includes('/command'), 'URL should be /command endpoint');
+      assert.strictEqual(commandBody.command, 'review', 'Should pass command name');
+      assert.strictEqual(commandBody.arguments, 'https://github.com/org/repo/pull/123', 'Should pass arguments');
+    });
+
+    test('uses /message endpoint for regular prompts (not slash commands)', async () => {
+      const { createSessionViaApi } = await import('../../service/actions.js');
+      
+      const mockSessionId = 'ses_msg123';
+      let commandCalled = false;
+      let messageCalled = false;
+      let messageBody = null;
+      
+      const mockFetch = async (url, opts) => {
+        const urlObj = new URL(url);
+        
+        if (urlObj.pathname === '/session' && opts?.method === 'POST') {
+          return {
+            ok: true,
+            json: async () => ({ id: mockSessionId }),
+          };
+        }
+        
+        if (urlObj.pathname.includes('/command') && opts?.method === 'POST') {
+          commandCalled = true;
+          return {
+            ok: true,
+            json: async () => ({ success: true }),
+          };
+        }
+        
+        if (urlObj.pathname.includes('/message') && opts?.method === 'POST') {
+          messageCalled = true;
+          messageBody = JSON.parse(opts.body);
+          return {
+            ok: true,
+            json: async () => ({ success: true }),
+          };
+        }
+        
+        return { ok: false, text: async () => 'Not found' };
+      };
+      
+      const result = await createSessionViaApi(
+        'http://localhost:4096',
+        '/path/to/project',
+        'Fix the bug in the login page',
+        { fetch: mockFetch }
+      );
+      
+      assert.ok(result.success, 'Should succeed');
+      assert.ok(!commandCalled, 'Should NOT call /command endpoint');
+      assert.ok(messageCalled, 'Should call /message endpoint');
+      assert.strictEqual(messageBody.parts[0].text, 'Fix the bug in the login page', 'Should pass prompt as message text');
+    });
+  });
+
+  describe('sendMessageToSession slash command routing', () => {
+    test('uses /command endpoint for slash commands', async () => {
+      const { sendMessageToSession } = await import('../../service/actions.js');
+      
+      let commandCalled = false;
+      let commandBody = null;
+      let messageCalled = false;
+      
+      const mockFetch = async (url, opts) => {
+        const urlObj = new URL(url);
+        
+        if (urlObj.pathname.includes('/command') && opts?.method === 'POST') {
+          commandCalled = true;
+          commandBody = JSON.parse(opts.body);
+          return {
+            ok: true,
+            json: async () => ({ success: true }),
+          };
+        }
+        
+        if (urlObj.pathname.includes('/message') && opts?.method === 'POST') {
+          messageCalled = true;
+          return {
+            ok: true,
+            json: async () => ({ success: true }),
+          };
+        }
+        
+        // PATCH for title update
+        if (opts?.method === 'PATCH') {
+          return { ok: true, json: async () => ({}) };
+        }
+        
+        return { ok: false, text: async () => 'Not found' };
+      };
+      
+      const result = await sendMessageToSession(
+        'http://localhost:4096',
+        'ses_existing',
+        '/path/to/project',
+        '/devcontainer https://github.com/org/repo/issues/456',
+        { fetch: mockFetch }
+      );
+      
+      assert.ok(result.success, 'Should succeed');
+      assert.ok(commandCalled, 'Should call /command endpoint');
+      assert.ok(!messageCalled, 'Should NOT call /message endpoint');
+      assert.strictEqual(commandBody.command, 'devcontainer', 'Should pass command name');
+      assert.strictEqual(commandBody.arguments, 'https://github.com/org/repo/issues/456', 'Should pass arguments');
+    });
+
+    test('uses /message endpoint for regular prompts', async () => {
+      const { sendMessageToSession } = await import('../../service/actions.js');
+      
+      let commandCalled = false;
+      let messageCalled = false;
+      let messageBody = null;
+      
+      const mockFetch = async (url, opts) => {
+        const urlObj = new URL(url);
+        
+        if (urlObj.pathname.includes('/command') && opts?.method === 'POST') {
+          commandCalled = true;
+          return {
+            ok: true,
+            json: async () => ({ success: true }),
+          };
+        }
+        
+        if (urlObj.pathname.includes('/message') && opts?.method === 'POST') {
+          messageCalled = true;
+          messageBody = JSON.parse(opts.body);
+          return {
+            ok: true,
+            json: async () => ({ success: true }),
+          };
+        }
+        
+        return { ok: false, text: async () => 'Not found' };
+      };
+      
+      const result = await sendMessageToSession(
+        'http://localhost:4096',
+        'ses_existing',
+        '/path/to/project',
+        'Please fix the bug',
+        { fetch: mockFetch }
+      );
+      
+      assert.ok(result.success, 'Should succeed');
+      assert.ok(!commandCalled, 'Should NOT call /command endpoint');
+      assert.ok(messageCalled, 'Should call /message endpoint');
+      assert.strictEqual(messageBody.parts[0].text, 'Please fix the bug', 'Should pass prompt as message text');
+    });
+
+    test('passes agent and model to /command endpoint', async () => {
+      const { sendMessageToSession } = await import('../../service/actions.js');
+      
+      let commandBody = null;
+      
+      const mockFetch = async (url, opts) => {
+        const urlObj = new URL(url);
+        
+        if (urlObj.pathname.includes('/command') && opts?.method === 'POST') {
+          commandBody = JSON.parse(opts.body);
+          return {
+            ok: true,
+            json: async () => ({ success: true }),
+          };
+        }
+        
+        // PATCH for title update
+        if (opts?.method === 'PATCH') {
+          return { ok: true, json: async () => ({}) };
+        }
+        
+        return { ok: false, text: async () => 'Not found' };
+      };
+      
+      await sendMessageToSession(
+        'http://localhost:4096',
+        'ses_existing',
+        '/path/to/project',
+        '/review https://github.com/org/repo/pull/123',
+        { 
+          fetch: mockFetch,
+          agent: 'code',
+          model: 'anthropic/claude-sonnet-4-20250514',
+        }
+      );
+      
+      assert.strictEqual(commandBody.agent, 'code', 'Should pass agent');
+      assert.strictEqual(commandBody.model, 'anthropic/claude-sonnet-4-20250514', 'Should pass model as string');
+    });
   });
 
   describe('session reuse', () => {

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);
+    });
+  });
+});