opencode-pilot 0.16.2 → 0.16.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-pilot",
-  "version": "0.16.2",
+  "version": "0.16.4",
   "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";
 
@@ -470,6 +470,8 @@ function runSpawn(args, options = {}) {
 export async function createSessionViaApi(serverUrl, directory, prompt, options = {}) {
   const fetchFn = options.fetch || fetch;
   
+  let session = null;
+  
   try {
     // Step 1: Create a new session with the directory parameter
     const sessionUrl = new URL('/session', serverUrl);
@@ -486,7 +488,7 @@ export async function createSessionViaApi(serverUrl, directory, prompt, options
       throw new Error(`Failed to create session: ${createResponse.status} ${errorText}`);
     }
     
-    const session = await createResponse.json();
+    session = await createResponse.json();
     debug(`createSessionViaApi: created session ${session.id} in ${directory}`);
     
     // Step 2: Update session title if provided
@@ -543,6 +545,17 @@ export async function createSessionViaApi(serverUrl, directory, prompt, options
     };
   } catch (err) {
     debug(`createSessionViaApi: error - ${err.message}`);
+    // If session was created but message failed, still return success
+    // to prevent re-processing (the session exists, user can send message manually)
+    if (session) {
+      debug(`createSessionViaApi: session ${session.id} was created, marking as success despite message error`);
+      return {
+        success: true,
+        sessionId: session.id,
+        directory,
+        warning: err.message,
+      };
+    }
     return {
       success: false,
       error: err.message,
@@ -578,7 +591,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/poll-service.js

@@ -227,9 +227,13 @@ export async function pollOnce(options = {}) {
                 itemUpdatedAt: item.updated_at || null,
               });
             }
-            console.log(`[poll] Started session for ${item.id}`);
+            if (result.warning) {
+              console.log(`[poll] Started session for ${item.id} (warning: ${result.warning})`);
+            } else {
+              console.log(`[poll] Started session for ${item.id}`);
+            }
           } else {
-            console.error(`[poll] Failed to start session: ${result.stderr}`);
+            console.error(`[poll] Failed to start session: ${result.error || result.stderr || 'unknown error'}`);
           }
         } catch (err) {
           console.error(`[poll] Error executing action: ${err.message}`);

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');
@@ -922,5 +930,47 @@ describe('actions.js', () => {
       assert.strictEqual(messageBody.providerID, 'anthropic', 'Should parse provider from model');
       assert.strictEqual(messageBody.modelID, 'claude-sonnet-4-20250514', 'Should parse model ID');
     });
+
+    test('returns success with warning when session created but message fails', async () => {
+      const { createSessionViaApi } = await import('../../service/actions.js');
+      
+      const mockSessionId = 'ses_partial123';
+      
+      const mockFetch = async (url, opts) => {
+        const urlObj = new URL(url);
+        
+        // Session creation succeeds
+        if (urlObj.pathname === '/session' && opts?.method === 'POST') {
+          return {
+            ok: true,
+            json: async () => ({ id: mockSessionId }),
+          };
+        }
+        
+        // Message send fails
+        if (urlObj.pathname.includes('/message') && opts?.method === 'POST') {
+          return {
+            ok: false,
+            status: 500,
+            text: async () => 'Message send failed',
+          };
+        }
+        
+        return { ok: true, json: async () => ({}) };
+      };
+      
+      const result = await createSessionViaApi(
+        'http://localhost:4096',
+        '/path/to/project',
+        'Fix the bug',
+        { fetch: mockFetch }
+      );
+      
+      // Should return success because session was created
+      assert.ok(result.success, 'Should return success when session was created');
+      assert.strictEqual(result.sessionId, mockSessionId, 'Should return session ID');
+      assert.ok(result.warning, 'Should include warning about message failure');
+      assert.ok(result.warning.includes('Failed to send message'), 'Warning should mention message failure');
+    });
   });
 });

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,