opencode-pilot 0.16.1 → 0.16.3

package/package.json

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

package/service/actions.js

@@ -10,7 +10,7 @@ import { readFileSync, existsSync } from "fs";
 import { debug } from "./logger.js";
 import { getNestedValue } from "./utils.js";
 import { getServerPort } from "./repo-config.js";
-import { resolveWorktreeDirectory, getProjectInfo } from "./worktree.js";
+import { resolveWorktreeDirectory, getProjectInfo, getProjectInfoForDirectory } from "./worktree.js";
 import path from "path";
 import os from "os";
 
@@ -578,7 +578,8 @@ export async function executeAction(item, config, options = {}) {
   // 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) {
-    const projectInfo = await getProjectInfo(serverUrl, { fetch: options.fetch });
+    // 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) {
       debug(`executeAction: auto-detected worktree support (${projectInfo.sandboxes.length} sandboxes)`);
       worktreeMode = 'new';

package/service/utils.js

@@ -61,6 +61,11 @@ export function isBot(username, type) {
   // Check for [bot] suffix in username
   if (username.toLowerCase().endsWith("[bot]")) return true;
   
+  // Known bot usernames without [bot] suffix
+  // Note: 'Copilot' is intentionally NOT included - Copilot review feedback is actionable
+  const knownBots = ['linear'];
+  if (knownBots.includes(username.toLowerCase())) return true;
+  
   return false;
 }
 

package/service/worktree.js

@@ -40,6 +40,7 @@ export async function listWorktrees(serverUrl, options = {}) {
  * 
  * @param {string} serverUrl - OpenCode server URL (e.g., "http://localhost:4096")
  * @param {object} [options] - Options
+ * @param {string} [options.directory] - Project directory (required for global server)
  * @param {string} [options.name] - Optional name for the worktree
  * @param {string} [options.startCommand] - Optional startup script to run after creation
  * @param {function} [options.fetch] - Custom fetch function (for testing)
@@ -53,7 +54,14 @@ export async function createWorktree(serverUrl, options = {}) {
     if (options.name) body.name = options.name;
     if (options.startCommand) body.startCommand = options.startCommand;
     
-    const response = await fetchFn(`${serverUrl}/experimental/worktree`, {
+    // Build URL with directory parameter if provided
+    // This tells the global server which project to create the worktree for
+    let url = `${serverUrl}/experimental/worktree`;
+    if (options.directory) {
+      url += `?directory=${encodeURIComponent(options.directory)}`;
+    }
+    
+    const response = await fetchFn(url, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify(body),
@@ -112,6 +120,48 @@ export async function getProjectInfo(serverUrl, options = {}) {
   }
 }
 
+/**
+ * Get project info for a specific directory by querying all projects
+ * 
+ * @param {string} serverUrl - OpenCode server URL
+ * @param {string} directory - Directory path to find project for
+ * @param {object} [options] - Options
+ * @param {function} [options.fetch] - Custom fetch function (for testing)
+ * @returns {Promise<object|null>} Project info or null if not found
+ */
+export async function getProjectInfoForDirectory(serverUrl, directory, options = {}) {
+  const fetchFn = options.fetch || fetch;
+  
+  try {
+    const response = await fetchFn(`${serverUrl}/project`);
+    
+    if (!response.ok) {
+      debug(`getProjectInfoForDirectory: ${serverUrl} returned ${response.status}`);
+      return null;
+    }
+    
+    const projects = await response.json();
+    
+    // Find project matching this directory, preferring ones with sandboxes
+    const matches = projects.filter(p => p.worktree === directory);
+    
+    if (matches.length === 0) {
+      debug(`getProjectInfoForDirectory: no project found for ${directory}`);
+      return null;
+    }
+    
+    // Prefer the project with sandboxes (if multiple exist for same worktree)
+    const withSandboxes = matches.find(p => p.sandboxes?.length > 0);
+    const project = withSandboxes || matches[0];
+    
+    debug(`getProjectInfoForDirectory: found project ${project.id} for ${directory} with ${project.sandboxes?.length || 0} sandboxes`);
+    return project;
+  } catch (err) {
+    debug(`getProjectInfoForDirectory: error - ${err.message}`);
+    return null;
+  }
+}
+
 /**
  * Resolve the working directory based on worktree configuration
  * 
@@ -147,6 +197,7 @@ export async function resolveWorktreeDirectory(serverUrl, baseDir, worktreeConfi
   // "new" - create a fresh worktree via OpenCode API
   if (worktreeValue === "new") {
     const result = await createWorktree(serverUrl, {
+      directory: baseDir,
       name: worktreeConfig.worktreeName,
       fetch: options.fetch,
     });

package/test/unit/actions.test.js

@@ -588,8 +588,12 @@ describe('actions.js', () => {
       
       // Mock worktree creation via fetch
       const mockFetch = async (url, opts) => {
-        // Worktree creation endpoint
-        if (url === 'http://localhost:4096/experimental/worktree' && opts?.method === 'POST') {
+        // Worktree creation endpoint - now includes directory query param
+        if (url.startsWith('http://localhost:4096/experimental/worktree') && opts?.method === 'POST') {
+          // Verify directory parameter is passed
+          const urlObj = new URL(url);
+          assert.strictEqual(urlObj.searchParams.get('directory'), tempDir, 
+            'Should pass directory as query param');
           const body = JSON.parse(opts.body);
           assert.strictEqual(body.name, 'feature-branch', 'Should pass worktree name');
           return {
@@ -708,25 +712,27 @@ describe('actions.js', () => {
       const mockDiscoverServer = async () => 'http://localhost:4096';
       
       // Track API calls
-      let projectInfoCalled = false;
+      let projectListCalled = false;
       let worktreeCreateCalled = false;
       
       const mockFetch = async (url, opts) => {
-        // Project info endpoint - returns sandboxes indicating worktree workflow
-        if (url === 'http://localhost:4096/project/current') {
-          projectInfoCalled = true;
+        // Project list endpoint - returns projects including one with sandboxes
+        if (url === 'http://localhost:4096/project') {
+          projectListCalled = true;
           return {
             ok: true,
-            json: async () => ({
-              id: 'proj-123',
-              worktree: tempDir,
-              sandboxes: ['/data/worktree/proj-123/sandbox-1'],
-              time: { created: 1 }
-            })
+            json: async () => ([
+              {
+                id: 'proj-123',
+                worktree: tempDir,
+                sandboxes: ['/data/worktree/proj-123/sandbox-1'],
+                time: { created: 1 }
+              }
+            ])
           };
         }
-        // Worktree creation endpoint
-        if (url === 'http://localhost:4096/experimental/worktree' && opts?.method === 'POST') {
+        // Worktree creation endpoint - now includes directory query param
+        if (url.startsWith('http://localhost:4096/experimental/worktree') && opts?.method === 'POST') {
           worktreeCreateCalled = true;
           return {
             ok: true,
@@ -747,7 +753,7 @@ describe('actions.js', () => {
       });
       
       assert.ok(result.dryRun);
-      assert.ok(projectInfoCalled, 'Should call project/current to check for sandboxes');
+      assert.ok(projectListCalled, 'Should call /project to find project by directory');
       assert.ok(worktreeCreateCalled, 'Should auto-create worktree when sandboxes detected');
       assert.ok(result.command.includes('/data/worktree/proj-123/new-sandbox'), 
         'Should use newly created worktree directory');
@@ -766,21 +772,23 @@ describe('actions.js', () => {
       // Mock server discovery
       const mockDiscoverServer = async () => 'http://localhost:4096';
       
-      let projectInfoCalled = false;
+      let projectListCalled = false;
       let worktreeCreateCalled = false;
       
       const mockFetch = async (url, opts) => {
-        // Project info endpoint - returns empty sandboxes (no worktree workflow)
-        if (url === 'http://localhost:4096/project/current') {
-          projectInfoCalled = true;
+        // Project list endpoint - returns project with empty sandboxes
+        if (url === 'http://localhost:4096/project') {
+          projectListCalled = true;
           return {
             ok: true,
-            json: async () => ({
-              id: 'proj-456',
-              worktree: tempDir,
-              sandboxes: [],
-              time: { created: 1 }
-            })
+            json: async () => ([
+              {
+                id: 'proj-456',
+                worktree: tempDir,
+                sandboxes: [],
+                time: { created: 1 }
+              }
+            ])
           };
         }
         if (url === 'http://localhost:4096/experimental/worktree' && opts?.method === 'POST') {
@@ -796,7 +804,7 @@ describe('actions.js', () => {
       });
       
       assert.ok(result.dryRun);
-      assert.ok(projectInfoCalled, 'Should call project/current to check for sandboxes');
+      assert.ok(projectListCalled, 'Should call /project to find project by directory');
       assert.ok(!worktreeCreateCalled, 'Should NOT create worktree when no sandboxes');
       assert.ok(result.command.includes(tempDir), 
         'Should use base directory when no worktree workflow detected');

package/test/unit/worktree.test.js

@@ -82,6 +82,26 @@ describe("worktree", () => {
       assert.strictEqual(body.name, "my-feature");
     });
 
+    it("passes directory as query parameter", async () => {
+      const mockFetch = mock.fn(async (url, options) => ({
+        ok: true,
+        json: async () => ({
+          name: "test-worktree",
+          branch: "opencode/test-worktree",
+          directory: "/data/worktree/abc123/test-worktree",
+        }),
+      }));
+
+      await createWorktree("http://localhost:4096", {
+        directory: "/Users/test/code/my-project",
+        fetch: mockFetch,
+      });
+
+      const calledUrl = mockFetch.mock.calls[0].arguments[0];
+      assert.ok(calledUrl.includes("directory="), "URL should include directory parameter");
+      assert.ok(calledUrl.includes(encodeURIComponent("/Users/test/code/my-project")), "URL should include encoded directory path");
+    });
+
     it("returns error on failure", async () => {
       const mockFetch = mock.fn(async () => ({
         ok: false,