opencode-pilot 0.16.4 → 0.16.6

package/package.json

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

package/service/actions.js

@@ -5,7 +5,7 @@
  * Supports prompt_template for custom prompts (e.g., to invoke /devcontainer).
  */
 
-import { spawn, execSync } from "child_process";
+import { execSync } from "child_process";
 import { readFileSync, existsSync } from "fs";
 import { debug } from "./logger.js";
 import { getNestedValue } from "./utils.js";
@@ -417,39 +417,6 @@ export function buildCommand(item, config) {
   return cmdInfo.cwd ? `(cd ${cmdInfo.cwd} && ${cmdStr})` : cmdStr;
 }
 
-/**
- * Execute a spawn command and return a promise
- */
-function runSpawn(args, options = {}) {
-  return new Promise((resolve, reject) => {
-    const [cmd, ...cmdArgs] = args;
-    const spawnOpts = {
-      stdio: ["ignore", "pipe", "pipe"],
-      ...options,
-    };
-    const child = spawn(cmd, cmdArgs, spawnOpts);
-
-    let stdout = "";
-    let stderr = "";
-
-    child.stdout.on("data", (data) => {
-      stdout += data.toString();
-    });
-
-    child.stderr.on("data", (data) => {
-      stderr += data.toString();
-    });
-
-    child.on("close", (code) => {
-      resolve({ stdout, stderr, exitCode: code, success: code === 0 });
-    });
-
-    child.on("error", (err) => {
-      reject(err);
-    });
-  });
-}
-
 /**
  * Create a session via the OpenCode HTTP API
  * 
@@ -525,19 +492,40 @@ export async function createSessionViaApi(serverUrl, directory, prompt, options
       messageBody.modelID = modelID;
     }
     
-    const messageResponse = await fetchFn(messageUrl.toString(), {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(messageBody),
-    });
+    // 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.
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 10000); // 10 second timeout
     
-    if (!messageResponse.ok) {
-      const errorText = await messageResponse.text();
-      throw new Error(`Failed to send message: ${messageResponse.status} ${errorText}`);
+    try {
+      const messageResponse = 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}`);
+      }
+      
+      debug(`createSessionViaApi: sent 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
+      if (abortErr.name === 'AbortError') {
+        debug(`createSessionViaApi: message request started for session ${session.id} (response aborted as expected)`);
+      } else {
+        throw abortErr;
+      }
     }
     
-    debug(`createSessionViaApi: sent message to session ${session.id}`);
-    
     return {
       success: true,
       sessionId: session.id,
@@ -584,13 +572,20 @@ export async function executeAction(item, config, options = {}) {
   
   debug(`executeAction: discovered server=${serverUrl} for baseCwd=${baseCwd}`);
   
+  // Require OpenCode server - pilot runs as a plugin, so server should always be available
+  if (!serverUrl) {
+    return {
+      success: false,
+      error: 'No OpenCode server found. Pilot requires OpenCode to be running.',
+    };
+  }
+  
   // Resolve worktree directory if configured
   // This allows creating sessions in isolated worktrees instead of the main project
   let worktreeMode = config.worktree;
   
-  // Auto-detect worktree support: if not explicitly configured and server is running,
-  // check if the project has sandboxes (indicating worktree workflow is set up)
-  if (!worktreeMode && serverUrl) {
+  // Auto-detect worktree support: check if the project has sandboxes
+  if (!worktreeMode) {
     // Look up project info for this specific directory (not just /project/current)
     const projectInfo = await getProjectInfoForDirectory(serverUrl, baseCwd, { fetch: options.fetch });
     if (projectInfo?.sandboxes?.length > 0) {
@@ -622,117 +617,35 @@ export async function executeAction(item, config, options = {}) {
   
   debug(`executeAction: using cwd=${cwd}`);
   
-  // If a server is running, use the HTTP API to create the session
-  // This is a workaround for the known issue where --attach doesn't support --dir
-  // See: https://github.com/anomalyco/opencode/issues/7376
-  if (serverUrl) {
-    // Build prompt from template
-    const prompt = buildPromptFromTemplate(config.prompt || "default", item);
-    
-    // Build session title
-    const sessionTitle = config.session?.name
-      ? buildSessionName(config.session.name, item)
-      : (item.title || `session-${Date.now()}`);
-    
-    const apiCommand = `[API] POST ${serverUrl}/session?directory=${cwd}`;
-    debug(`executeAction: using HTTP API - ${apiCommand}`);
-    
-    if (options.dryRun) {
-      return {
-        command: apiCommand,
-        dryRun: true,
-        method: 'api',
-      };
-    }
-    
-    const result = await createSessionViaApi(serverUrl, cwd, prompt, {
-      title: sessionTitle,
-      agent: config.agent,
-      model: config.model,
-      fetch: options.fetch,
-    });
-    
-    return {
-      command: apiCommand,
-      success: result.success,
-      sessionId: result.sessionId,
-      error: result.error,
-      method: 'api',
-    };
-  }
+  // Build prompt from template
+  const prompt = buildPromptFromTemplate(config.prompt || "default", item);
   
-  // No server running - fall back to spawning opencode run
-  // This works correctly because we set cwd on the spawn
-  const cmdInfo = getCommandInfoNew(item, config, undefined, null);
+  // Build session title
+  const sessionTitle = config.session?.name
+    ? buildSessionName(config.session.name, item)
+    : (item.title || `session-${Date.now()}`);
+  
+  const apiCommand = `[API] POST ${serverUrl}/session?directory=${cwd}`;
+  debug(`executeAction: using HTTP API - ${apiCommand}`);
   
-  // Build command string for display
-  const quoteArgs = (args) => args.map(a => 
-    a.includes(" ") || a.includes("\n") ? `"${a.replace(/"/g, '\\"')}"` : a
-  ).join(" ");
-  const cmdStr = quoteArgs(cmdInfo.args);
-  const command = cmdInfo.cwd ? `(cd ${cmdInfo.cwd} && ${cmdStr})` : cmdStr;
-
-  debug(`executeAction: command=${command}`);
-  debug(`executeAction: args=${JSON.stringify(cmdInfo.args)}, cwd=${cmdInfo.cwd}`);
-
   if (options.dryRun) {
     return {
-      command,
+      command: apiCommand,
       dryRun: true,
-      method: 'spawn',
     };
   }
-
-  // Execute opencode run in background (detached)
-  // We don't wait for completion since sessions can run for a long time
-  debug(`executeAction: spawning opencode run (detached)`);
-  const [cmd, ...cmdArgs] = cmdInfo.args;
-  const child = spawn(cmd, cmdArgs, {
-    cwd: cmdInfo.cwd,
-    detached: true,
-    stdio: 'ignore',
-  });
-  child.unref();
   
-  debug(`executeAction: spawned pid=${child.pid}`);
-  return {
-    command,
-    success: true,
-    pid: child.pid,
-    method: 'spawn',
-  };
-}
-
-/**
- * Check if opencode is available
- * @returns {Promise<boolean>}
- */
-export async function checkOpencode() {
-  return new Promise((resolve) => {
-    const child = spawn("which", ["opencode"]);
-    child.on("close", (code) => {
-      resolve(code === 0);
-    });
-    child.on("error", () => {
-      resolve(false);
-    });
+  const result = await createSessionViaApi(serverUrl, cwd, prompt, {
+    title: sessionTitle,
+    agent: config.agent,
+    model: config.model,
+    fetch: options.fetch,
   });
-}
-
-/**
- * Validate that required tools are available
- * @returns {Promise<object>} { valid: boolean, missing?: string[] }
- */
-export async function validateTools() {
-  const missing = [];
-
-  const hasOpencode = await checkOpencode();
-  if (!hasOpencode) {
-    missing.push("opencode");
-  }
-
+  
   return {
-    valid: missing.length === 0,
-    missing,
+    command: apiCommand,
+    success: result.success,
+    sessionId: result.sessionId,
+    error: result.error,
   };
 }

package/service/repo-config.js

@@ -352,7 +352,12 @@ export function resolveRepoForItem(source, item) {
     if (resolvedRepo) {
       return source.repos.includes(resolvedRepo) ? [resolvedRepo] : [];
     }
-    // No repo template - return empty (can't match without item context)
+    // No repo template - if exactly one repo, use it as default
+    // (e.g., Linear issues don't have repo context, user explicitly configures one repo)
+    if (source.repos.length === 1) {
+      return source.repos;
+    }
+    // Multiple repos but can't match without item context
     return [];
   }
 

package/test/unit/actions.test.js

@@ -543,13 +543,12 @@ describe('actions.js', () => {
       });
       
       assert.ok(result.dryRun);
-      assert.strictEqual(result.method, 'api', 'Should use API method when server found');
       assert.ok(result.command.includes('POST'), 'Command should show POST request');
       assert.ok(result.command.includes('http://localhost:4096'), 'Command should include server URL');
       assert.ok(result.command.includes('directory='), 'Command should include directory param');
     });
 
-    test('falls back to spawn when no server discovered (dry run)', async () => {
+    test('returns error when no server discovered', async () => {
       const { executeAction } = await import('../../service/actions.js');
       
       const item = { number: 123, title: 'Fix bug' };
@@ -566,10 +565,8 @@ describe('actions.js', () => {
         discoverServer: mockDiscoverServer
       });
       
-      assert.ok(result.dryRun);
-      assert.strictEqual(result.method, 'spawn', 'Should use spawn method when no server');
-      assert.ok(!result.command.includes('--attach'), 'Command should not include --attach flag');
-      assert.ok(result.command.includes('opencode run'), 'Command should include opencode run');
+      assert.strictEqual(result.success, false, 'Should fail when no server');
+      assert.ok(result.error.includes('No OpenCode server'), 'Should have descriptive error');
     });
 
     test('creates new worktree when worktree: "new" is configured (dry run)', async () => {
@@ -615,7 +612,6 @@ describe('actions.js', () => {
       });
       
       assert.ok(result.dryRun);
-      assert.strictEqual(result.method, 'api', 'Should use API method');
       // The directory in the command should be the worktree directory
       assert.ok(result.command.includes('/data/worktree/proj123/feature-branch'), 
         'Should use worktree directory in command');
@@ -655,7 +651,6 @@ describe('actions.js', () => {
       });
       
       assert.ok(result.dryRun);
-      assert.strictEqual(result.method, 'api', 'Should use API method');
       assert.ok(result.command.includes('/data/worktree/proj123/my-feature'), 
         'Should use looked up worktree path in command');
     });
@@ -692,7 +687,6 @@ describe('actions.js', () => {
       });
       
       assert.ok(result.dryRun);
-      assert.strictEqual(result.method, 'api', 'Should still use API method');
       // Should fall back to base directory
       assert.ok(result.command.includes(tempDir), 
         'Should fall back to base directory when worktree creation fails');

package/test/unit/repo-config.test.js

@@ -769,6 +769,46 @@ sources:
       assert.deepStrictEqual(resolveRepoForItem(source, filteredItem), []);
     });
 
+    test('single-repo allowlist uses repo as default when no template', async () => {
+      // Linear issues don't have repository context - when exactly one repo is configured,
+      // use it as the default for all items from that source
+      writeFileSync(configPath, `
+sources:
+  - preset: linear/my-issues
+    repos:
+      - 0din-ai/odin
+`);
+
+      const { loadRepoConfig, getSources, resolveRepoForItem } = await import('../../service/repo-config.js');
+      loadRepoConfig(configPath);
+      const source = getSources()[0];
+
+      // Linear items don't have repository field
+      const linearItem = { id: 'linear:abc123', title: 'Fix bug', state: { name: 'In Progress' } };
+      assert.deepStrictEqual(resolveRepoForItem(source, linearItem), ['0din-ai/odin'],
+        'single-repo allowlist should use repo as default');
+    });
+
+    test('multi-repo allowlist returns empty when no template match', async () => {
+      // With multiple repos and no way to determine which one, return empty
+      writeFileSync(configPath, `
+sources:
+  - preset: linear/my-issues
+    repos:
+      - org/repo-a
+      - org/repo-b
+`);
+
+      const { loadRepoConfig, getSources, resolveRepoForItem } = await import('../../service/repo-config.js');
+      loadRepoConfig(configPath);
+      const source = getSources()[0];
+
+      // Can't determine which of the 2 repos to use
+      const linearItem = { id: 'linear:abc123', title: 'Fix bug' };
+      assert.deepStrictEqual(resolveRepoForItem(source, linearItem), [],
+        'multi-repo allowlist should return empty when no template');
+    });
+
     test('github presets include semantic session names', async () => {
       writeFileSync(configPath, `
 sources: