opencode-pilot 0.24.6 → 0.24.7

package/Formula/opencode-pilot.rb

@@ -1,8 +1,8 @@
 class OpencodePilot < Formula
   desc "Automation daemon for OpenCode - polls GitHub/Linear issues and spawns sessions"
   homepage "https://github.com/athal7/opencode-pilot"
-  url "https://github.com/athal7/opencode-pilot/archive/refs/tags/v0.24.5.tar.gz"
-  sha256 "6a191feaa9f7ec7421272a0c9533ebbd734a45483ca7116135b62e4ba11e780d"
+  url "https://github.com/athal7/opencode-pilot/archive/refs/tags/v0.24.6.tar.gz"
+  sha256 "60f487bfbe6209da3687d854b848b920791dde739046fd72bf75594d6e5e6163"
   license "MIT"
 
   depends_on "node"

package/package.json

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

package/service/actions.js

@@ -673,14 +673,11 @@ export async function findReusableSession(serverUrl, directory, options = {}) {
 /**
  * Create a session via the OpenCode HTTP API
  * 
- * This is a workaround for the known issue where `opencode run --attach` 
- * doesn't support a --dir flag, causing sessions to run in the wrong directory
- * when attached to a global server.
- * 
  * @param {string} serverUrl - Server URL (e.g., "http://localhost:4096")
- * @param {string} directory - Working directory for the session
+ * @param {string} directory - Working directory for file operations (may be a worktree)
  * @param {string} prompt - The prompt/message to send
  * @param {object} [options] - Options
+ * @param {string} [options.projectDirectory] - Project directory for session scoping (defaults to directory)
  * @param {string} [options.title] - Session title
  * @param {string} [options.agent] - Agent to use
  * @param {string} [options.model] - Model to use
@@ -690,13 +687,16 @@ export async function findReusableSession(serverUrl, directory, options = {}) {
 export async function createSessionViaApi(serverUrl, directory, prompt, options = {}) {
   const fetchFn = options.fetch || fetch;
   const headerTimeout = options.headerTimeout || HEADER_TIMEOUT_MS;
+  // Use project directory for session creation (determines projectID in OpenCode).
+  // The working directory (which may be a worktree) is used for messages/commands.
+  const projectDir = options.projectDirectory || directory;
   
   let session = null;
   
   try {
-    // Step 1: Create a new session with the directory parameter
+    // Step 1: Create session scoped to the project directory
     const sessionUrl = new URL('/session', serverUrl);
-    sessionUrl.searchParams.set('directory', directory);
+    sessionUrl.searchParams.set('directory', projectDir);
     
     const createResponse = await fetchFn(sessionUrl.toString(), {
       method: 'POST',
@@ -715,7 +715,7 @@ export async function createSessionViaApi(serverUrl, directory, prompt, options
     // Step 2: Update session title if provided
     if (options.title) {
       const updateUrl = new URL(`/session/${session.id}`, serverUrl);
-      updateUrl.searchParams.set('directory', directory);
+      updateUrl.searchParams.set('directory', projectDir);
       await fetchFn(updateUrl.toString(), {
         method: 'PATCH',
         headers: { 'Content-Type': 'application/json' },
@@ -842,7 +842,7 @@ export async function createSessionViaApi(serverUrl, directory, prompt, options
  * @param {object} [options] - Execution options
  * @returns {Promise<object>} Result with command, success, sessionId, etc.
  */
-async function executeInDirectory(serverUrl, cwd, item, config, options = {}) {
+async function executeInDirectory(serverUrl, cwd, item, config, options = {}, projectDirectory = null) {
   // Build prompt from template
   const prompt = buildPromptFromTemplate(config.prompt || "default", item);
   
@@ -923,6 +923,7 @@ async function executeInDirectory(serverUrl, cwd, item, config, options = {}) {
   }
   
   const result = await createSessionViaApi(serverUrl, cwd, prompt, {
+    projectDirectory: projectDirectory || cwd,
     title: sessionTitle,
     agent: config.agent,
     model: config.model,
@@ -986,7 +987,7 @@ export async function executeAction(item, config, options = {}) {
   if (config.existing_directory) {
     debug(`executeAction: using existing_directory=${config.existing_directory}`);
     const cwd = expandPath(config.existing_directory);
-    return await executeInDirectory(serverUrl, cwd, item, config, options);
+    return await executeInDirectory(serverUrl, cwd, item, config, options, baseCwd);
   }
   
   // Resolve worktree directory if configured
@@ -1038,5 +1039,5 @@ export async function executeAction(item, config, options = {}) {
   
   debug(`executeAction: using cwd=${cwd}`);
   
-  return await executeInDirectory(serverUrl, cwd, item, config, options);
+  return await executeInDirectory(serverUrl, cwd, item, config, options, baseCwd);
 }

package/test/integration/session-reuse.test.js

@@ -564,7 +564,9 @@ describe("integration: worktree creation with worktree_name", () => {
     assert.ok(worktreeCreateCalled, "Should create worktree when worktree_name is configured");
     assert.strictEqual(createdWorktreeName, "pr-42", "Should expand worktree_name template");
     assert.ok(sessionCreated, "Should create session");
-    assert.strictEqual(sessionDirectory, "/worktree/pr-42", "Session should be in worktree directory");
+    // Session creation uses the project directory (for correct projectID scoping)
+    // The worktree path is used for messages/commands (file operations)
+    assert.strictEqual(sessionDirectory, "/proj", "Session should be scoped to project directory");
   });
 
   it("reuses stored directory when reprocessing same item", async () => {
@@ -616,8 +618,8 @@ describe("integration: worktree creation with worktree_name", () => {
     assert.ok(result.success, "Action should succeed");
     // Should NOT create a new worktree since we have existing_directory
     assert.strictEqual(worktreeCreateCalled, false, "Should NOT create new worktree when existing_directory provided");
-    // Session should be created in the existing directory
-    assert.strictEqual(sessionDirectory, existingWorktreeDir, "Session should use existing directory");
+    // Session creation uses the project directory (for correct projectID scoping)
+    assert.strictEqual(sessionDirectory, "/proj", "Session should be scoped to project directory");
   });
 });
 

package/test/unit/actions.test.js

@@ -981,11 +981,12 @@ Check for bugs and security issues.`;
       // Should NOT call worktree endpoints when existing_directory is provided
       assert.strictEqual(worktreeListCalled, false, 'Should NOT list worktrees');
       assert.strictEqual(worktreeCreateCalled, false, 'Should NOT create worktree');
-      // Should use the existing directory
-      assert.strictEqual(sessionDirectory, '/data/worktree/calm-wizard', 
-        'Should use existing_directory for session');
+      // Session creation uses project directory (for correct projectID scoping)
+      assert.strictEqual(sessionDirectory, '/data/proj', 
+        'Session creation should use project directory, not worktree');
+      // Result directory is the worktree (where file operations happen)
       assert.strictEqual(result.directory, '/data/worktree/calm-wizard',
-        'Result should include directory');
+        'Result should include worktree directory');
     });
   });
 
@@ -1041,6 +1042,52 @@ Check for bugs and security issues.`;
       assert.ok(messageUrl.includes('%2Fpath%2Fto%2Fproject'), 'Message URL should include encoded directory path');
     });
 
+    test('uses projectDirectory for session creation, working directory for messages', async () => {
+      const { createSessionViaApi } = await import('../../service/actions.js');
+      
+      const mockSessionId = 'ses_test_proj';
+      let createUrl = null;
+      let messageUrl = null;
+      
+      const mockFetch = async (url, opts) => {
+        const urlObj = new URL(url);
+        
+        if (urlObj.pathname === '/session' && opts?.method === 'POST') {
+          createUrl = url;
+          return { ok: true, json: async () => ({ id: mockSessionId }) };
+        }
+        
+        if (urlObj.pathname.includes('/message') && opts?.method === 'POST') {
+          messageUrl = url;
+          return { ok: true, json: async () => ({ success: true }) };
+        }
+        
+        return { ok: false, text: async () => 'Not found' };
+      };
+      
+      await createSessionViaApi(
+        'http://localhost:4096',
+        '/home/user/.local/share/opencode/worktree/abc123/pr-415',
+        'Fix the bug',
+        { 
+          fetch: mockFetch,
+          projectDirectory: '/home/user/code/odin',
+        }
+      );
+      
+      // Session creation should use the project directory (for correct projectID scoping)
+      assert.ok(createUrl.includes('%2Fhome%2Fuser%2Fcode%2Fodin'), 
+        'Session creation should use projectDirectory');
+      assert.ok(!createUrl.includes('worktree'), 
+        'Session creation should NOT use the worktree path');
+      
+      // Message should use the working directory (for file operations in the worktree)
+      assert.ok(messageUrl.includes('worktree'), 
+        'Message should use the worktree working directory');
+      assert.ok(messageUrl.includes('pr-415'), 
+        'Message should use the worktree working directory');
+    });
+
     test('handles session creation failure', async () => {
       const { createSessionViaApi } = await import('../../service/actions.js');