opencode-pilot 0.14.0 → 0.14.1

package/README.md

@@ -94,17 +94,9 @@ opencode-pilot test-mapping MCP   # Test field mappings
 
 ## Known Issues
 
-### Sessions attached to global server run in wrong directory
+None currently! Previous issues have been resolved:
 
-When using `server_port` to attach sessions to a global OpenCode server (e.g., OpenCode Desktop with worktree="/"), sessions are created in the server's working directory (typically home) instead of the project directory. This means:
-
-- File tools resolve paths relative to home, not the project
-- The agent sees the wrong `Working directory` in system prompt
-- Git operations may target the wrong repository
-
-**Workaround**: Don't set `server_port` in your config. Sessions will run in the correct directory but won't appear in OpenCode Desktop.
-
-**Upstream issue**: [anomalyco/opencode#7376](https://github.com/anomalyco/opencode/issues/7376)
+- ~~Sessions attached to global server run in wrong directory~~ - Fixed in v0.14.0 by using the HTTP API with `?directory=` parameter instead of `opencode run --attach`
 
 ## Related
 

package/package.json

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

package/service/actions.js

@@ -449,6 +449,106 @@ function runSpawn(args, 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} prompt - The prompt/message to send
+ * @param {object} [options] - Options
+ * @param {string} [options.title] - Session title
+ * @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<object>} Result with sessionId, success, error
+ */
+export async function createSessionViaApi(serverUrl, directory, prompt, options = {}) {
+  const fetchFn = options.fetch || fetch;
+  
+  try {
+    // Step 1: Create a new session with the directory parameter
+    const sessionUrl = new URL('/session', serverUrl);
+    sessionUrl.searchParams.set('directory', directory);
+    
+    const createResponse = await fetchFn(sessionUrl.toString(), {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({}),
+    });
+    
+    if (!createResponse.ok) {
+      const errorText = await createResponse.text();
+      throw new Error(`Failed to create session: ${createResponse.status} ${errorText}`);
+    }
+    
+    const session = await createResponse.json();
+    debug(`createSessionViaApi: created session ${session.id} in ${directory}`);
+    
+    // Step 2: Update session title if provided
+    if (options.title) {
+      const updateUrl = new URL(`/session/${session.id}`, serverUrl);
+      updateUrl.searchParams.set('directory', directory);
+      await fetchFn(updateUrl.toString(), {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ title: options.title }),
+      });
+    }
+    
+    // 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;
+    }
+    
+    const messageResponse = await fetchFn(messageUrl.toString(), {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(messageBody),
+    });
+    
+    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}`);
+    
+    return {
+      success: true,
+      sessionId: session.id,
+      directory,
+    };
+  } catch (err) {
+    debug(`createSessionViaApi: error - ${err.message}`);
+    return {
+      success: false,
+      error: err.message,
+    };
+  }
+}
+
 /**
  * Execute an action
  * @param {object} item - Item to create session for
@@ -456,6 +556,7 @@ function runSpawn(args, options = {}) {
  * @param {object} [options] - Execution options
  * @param {boolean} [options.dryRun] - If true, return command without executing
  * @param {function} [options.discoverServer] - Custom server discovery function (for testing)
+ * @param {function} [options.fetch] - Custom fetch function (for testing)
  * @returns {Promise<object>} Result with command, stdout, stderr, exitCode
  */
 export async function executeAction(item, config, options = {}) {
@@ -469,8 +570,48 @@ export async function executeAction(item, config, options = {}) {
   
   debug(`executeAction: discovered server=${serverUrl} for cwd=${cwd}`);
   
-  // Build command info with server URL for --attach flag
-  const cmdInfo = getCommandInfoNew(item, config, undefined, serverUrl);
+  // 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',
+    };
+  }
+  
+  // 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 command string for display
   const quoteArgs = (args) => args.map(a => 
@@ -486,6 +627,7 @@ export async function executeAction(item, config, options = {}) {
     return {
       command,
       dryRun: true,
+      method: 'spawn',
     };
   }
 
@@ -505,6 +647,7 @@ export async function executeAction(item, config, options = {}) {
     command,
     success: true,
     pid: child.pid,
+    method: 'spawn',
   };
 }
 

package/test/unit/actions.test.js

@@ -525,7 +525,7 @@ describe('actions.js', () => {
   });
 
   describe('executeAction', () => {
-    test('discovers server and includes --attach in dry run', async () => {
+    test('uses HTTP API when server is discovered (dry run)', async () => {
       const { executeAction } = await import('../../service/actions.js');
       
       const item = { number: 123, title: 'Fix bug' };
@@ -543,11 +543,13 @@ describe('actions.js', () => {
       });
       
       assert.ok(result.dryRun);
-      assert.ok(result.command.includes('--attach'), 'Command should include --attach flag');
+      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('does not include --attach when no server discovered', async () => {
+    test('falls back to spawn when no server discovered (dry run)', async () => {
       const { executeAction } = await import('../../service/actions.js');
       
       const item = { number: 123, title: 'Fix bug' };
@@ -565,7 +567,130 @@ describe('actions.js', () => {
       });
       
       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');
+    });
+  });
+
+  describe('createSessionViaApi', () => {
+    test('creates session and sends message with directory param', async () => {
+      const { createSessionViaApi } = await import('../../service/actions.js');
+      
+      const mockSessionId = 'ses_test123';
+      let createCalled = false;
+      let messageCalled = false;
+      let createUrl = null;
+      let messageUrl = null;
+      
+      const mockFetch = async (url, opts) => {
+        const urlObj = new URL(url);
+        
+        if (urlObj.pathname === '/session' && opts?.method === 'POST') {
+          createCalled = true;
+          createUrl = url;
+          return {
+            ok: true,
+            json: async () => ({ id: mockSessionId }),
+          };
+        }
+        
+        if (urlObj.pathname.includes('/message') && opts?.method === 'POST') {
+          messageCalled = true;
+          messageUrl = url;
+          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',
+        { fetch: mockFetch }
+      );
+      
+      assert.ok(result.success, 'Should succeed');
+      assert.strictEqual(result.sessionId, mockSessionId, 'Should return session ID');
+      assert.ok(createCalled, 'Should call create session endpoint');
+      assert.ok(messageCalled, 'Should call message endpoint');
+      // URL encodes slashes as %2F
+      assert.ok(createUrl.includes('directory='), 'Create URL should include directory param');
+      assert.ok(createUrl.includes('%2Fpath%2Fto%2Fproject'), 'Create URL should include encoded directory path');
+      assert.ok(messageUrl.includes('directory='), 'Message URL should include directory param');
+      assert.ok(messageUrl.includes('%2Fpath%2Fto%2Fproject'), 'Message URL should include encoded directory path');
+    });
+
+    test('handles session creation failure', async () => {
+      const { createSessionViaApi } = await import('../../service/actions.js');
+      
+      const mockFetch = async () => ({
+        ok: false,
+        status: 500,
+        text: async () => 'Internal server error',
+      });
+      
+      const result = await createSessionViaApi(
+        'http://localhost:4096',
+        '/path/to/project',
+        'Fix the bug',
+        { fetch: mockFetch }
+      );
+      
+      assert.ok(!result.success, 'Should fail');
+      assert.ok(result.error.includes('Failed to create session'), 'Should include error message');
+    });
+
+    test('passes agent and model options', async () => {
+      const { createSessionViaApi } = await import('../../service/actions.js');
+      
+      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: 'ses_test' }),
+          };
+        }
+        
+        if (urlObj.pathname.includes('/message')) {
+          messageBody = 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 createSessionViaApi(
+        'http://localhost:4096',
+        '/path/to/project',
+        'Fix the bug',
+        { 
+          fetch: mockFetch,
+          agent: 'code',
+          model: 'anthropic/claude-sonnet-4-20250514',
+          title: 'Test Session',
+        }
+      );
+      
+      assert.strictEqual(messageBody.agent, 'code', 'Should pass agent');
+      assert.strictEqual(messageBody.providerID, 'anthropic', 'Should parse provider from model');
+      assert.strictEqual(messageBody.modelID, 'claude-sonnet-4-20250514', 'Should parse model ID');
     });
   });
 });