opencode-pilot 0.13.1 → 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.13.1",
+  "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/service/poller.js

@@ -255,8 +255,9 @@ async function executeCliCommand(command, args, timeout) {
       }
       return part;
     });
-    // Quote parts with spaces
-    cmdStr = expandedCmd.map(p => p.includes(' ') ? `"${p}"` : p).join(' ');
+    // Quote parts with spaces or shell special characters
+    const shellSpecialChars = /[ <>|&;$`"'\\!*?#~=\[\]{}()]/;
+    cmdStr = expandedCmd.map(p => shellSpecialChars.test(p) ? `"${p.replace(/"/g, '\\"')}"` : p).join(' ');
   } else {
     // String command - substitute ${argName} patterns
     cmdStr = command.replace(/\$\{(\w+)\}/g, (_, name) => {

package/service/presets/github.yaml

@@ -1,11 +1,15 @@
-# GitHub source presets
+# GitHub source presets (using gh CLI)
+#
+# These presets use the `gh` CLI instead of requiring a GitHub MCP server.
+# The gh CLI must be installed and authenticated (gh auth login).
 
 # Provider-level config (applies to all GitHub presets)
 _provider:
-  response_key: items
   mappings:
-    # Extract repo full name from repository_url (e.g., "https://api.github.com/repos/owner/repo")
-    repository_full_name: "repository_url:/repos\\/([^/]+\\/[^/]+)$/"
+    # Map gh CLI fields to standard fields
+    html_url: url
+    repository_full_name: repository.nameWithOwner
+    updated_at: updatedAt
   # Reprocess items when state changes (e.g., reopened issues)
   # Note: updated_at is NOT included because our own changes would trigger reprocessing
   reprocess_on:
@@ -15,48 +19,35 @@ _provider:
 my-issues:
   name: my-issues
   tool:
-    mcp: github
-    name: search_issues
-  args:
-    q: "is:issue assignee:@me state:open"
+    command: ["gh", "search", "issues", "--assignee=@me", "--state=open", "--json", "number,title,url,repository,state,body,updatedAt"]
   item:
-    id: "{html_url}"
-  repo: "{repository_full_name}"
+    id: "{url}"
+  repo: "{repository.nameWithOwner}"
   session:
     name: "{title}"
 
 review-requests:
   name: review-requests
   tool:
-    mcp: github
-    name: search_issues
-  args:
-    q: "is:pr review-requested:@me state:open"
+    command: ["gh", "search", "prs", "--review-requested=@me", "--state=open", "--json", "number,title,url,repository,state,body,updatedAt"]
   item:
-    id: "{html_url}"
-  repo: "{repository_full_name}"
+    id: "{url}"
+  repo: "{repository.nameWithOwner}"
   session:
     name: "Review: {title}"
 
 my-prs-feedback:
   name: my-prs-feedback
   tool:
-    mcp: github
-    name: search_issues
-  args:
-    # Catches PRs with any review activity (comments, reviews, or changes requested)
-    # Note: comments:>0 includes both review comments and issue comments
-    q: "is:pr author:@me state:open comments:>0"
+    # comments:>0 filter ensures only PRs with feedback are returned
+    command: ["gh", "search", "prs", "--author=@me", "--state=open", "comments:>0", "--json", "number,title,url,repository,state,body,updatedAt"]
   item:
-    id: "{html_url}"
-  repo: "{repository_full_name}"
+    id: "{url}"
+  repo: "{repository.nameWithOwner}"
   session:
     name: "Feedback: {title}"
   # Reprocess when PR is updated (new commits pushed, new comments, etc.)
   # This ensures we re-trigger after addressing review feedback
   reprocess_on:
     - state
-    - updated_at
-  # Filter out PRs where all comments are from bots or the PR author
-  # Fetches comments via API and enriches items with _comments for readiness check
-  filter_bot_comments: true
+    - updatedAt

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');
     });
   });
 });

package/test/unit/poll-service.test.js

@@ -159,15 +159,15 @@ sources:
       loadRepoConfig(configPath);
       
       const source = getSources()[0];
-      // Item with repository_full_name (mapped from repository_url by GitHub provider)
+      // Item with repository.nameWithOwner (gh CLI output format)
       const item = { 
-        repository_full_name: 'myorg/backend',
+        repository: { nameWithOwner: 'myorg/backend' },
         number: 123,
-        html_url: 'https://github.com/myorg/backend/issues/123'
+        url: 'https://github.com/myorg/backend/issues/123'
       };
       
-      // Source should have repo field from preset (uses mapped field)
-      assert.strictEqual(source.repo, '{repository_full_name}');
+      // Source should have repo field from preset (uses gh CLI field)
+      assert.strictEqual(source.repo, '{repository.nameWithOwner}');
       
       // resolveRepoForItem should extract repo key from item
       const repoKeys = resolveRepoForItem(source, item);
@@ -195,9 +195,9 @@ sources:
       loadRepoConfig(configPath);
       
       const source = getSources()[0];
-      // Item with repository_full_name (mapped from repository_url by GitHub provider)
+      // Item with repository.nameWithOwner (gh CLI output format)
       const item = { 
-        repository_full_name: 'unknown/repo',
+        repository: { nameWithOwner: 'unknown/repo' },
         number: 456
       };
       

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

@@ -340,7 +340,7 @@ sources: []
 tools:
   github:
     mappings:
-      url: html_url
+      custom_field: some_source
 
 sources: []
 `);
@@ -350,10 +350,11 @@ sources: []
       
       const toolConfig = getToolProviderConfig('github');
       
-      // GitHub preset has response_key: items, user config doesn't override it
-      assert.strictEqual(toolConfig.response_key, 'items');
-      // GitHub provider has mapping for repository_full_name extraction from URL
-      assert.strictEqual(toolConfig.mappings.url, 'html_url');
+      // GitHub preset now uses gh CLI and doesn't need response_key
+      // User config custom_field should be merged with preset mappings
+      assert.strictEqual(toolConfig.mappings.custom_field, 'some_source');
+      // GitHub provider has mappings for gh CLI field normalization
+      assert.ok(toolConfig.mappings.html_url, 'Should have html_url mapping');
       assert.ok(toolConfig.mappings.repository_full_name, 'Should have repository_full_name mapping');
     });
 
@@ -534,9 +535,10 @@ sources:
 
       assert.strictEqual(sources.length, 1);
       assert.strictEqual(sources[0].name, 'my-issues');
-      assert.deepStrictEqual(sources[0].tool, { mcp: 'github', name: 'search_issues' });
-      assert.strictEqual(sources[0].args.q, 'is:issue assignee:@me state:open');
-      assert.strictEqual(sources[0].item.id, '{html_url}');
+      // GitHub presets now use gh CLI instead of MCP
+      assert.ok(Array.isArray(sources[0].tool.command), 'tool.command should be an array');
+      assert.ok(sources[0].tool.command.includes('gh'), 'command should use gh CLI');
+      assert.strictEqual(sources[0].item.id, '{url}');
       assert.strictEqual(sources[0].prompt, 'worktree');
     });
 
@@ -551,7 +553,8 @@ sources:
       const sources = getSources();
 
       assert.strictEqual(sources[0].name, 'review-requests');
-      assert.strictEqual(sources[0].args.q, 'is:pr review-requested:@me state:open');
+      // GitHub presets now use gh CLI instead of MCP
+      assert.ok(sources[0].tool.command.includes('--review-requested=@me'), 'command should include review-requested filter');
     });
 
     test('expands github/my-prs-feedback preset', async () => {
@@ -565,9 +568,11 @@ sources:
       const sources = getSources();
 
       assert.strictEqual(sources[0].name, 'my-prs-feedback');
-      assert.strictEqual(sources[0].args.q, 'is:pr author:@me state:open comments:>0');
-      // This preset includes updated_at in reprocess_on to catch new commits
-      assert.deepStrictEqual(sources[0].reprocess_on, ['state', 'updated_at']);
+      // GitHub presets now use gh CLI instead of MCP
+      assert.ok(sources[0].tool.command.includes('--author=@me'), 'command should include author filter');
+      assert.ok(sources[0].tool.command.includes('comments:>0'), 'command should filter for PRs with comments');
+      // This preset includes updatedAt in reprocess_on to catch new commits
+      assert.deepStrictEqual(sources[0].reprocess_on, ['state', 'updatedAt']);
     });
 
     test('expands linear/my-issues preset with required args', async () => {
@@ -632,12 +637,12 @@ sources:
       loadRepoConfig(configPath);
       const sources = getSources();
 
-      // All GitHub presets should have repo field that references repository_full_name
-      // (which is mapped from repository_url by the GitHub provider)
-      const mockItem = { repository_full_name: 'myorg/backend' };
+      // All GitHub presets should have repo field that references repository.nameWithOwner
+      // (gh CLI returns this field directly)
+      const mockItem = { repository: { nameWithOwner: 'myorg/backend' } };
       
       for (const source of sources) {
-        assert.strictEqual(source.repo, '{repository_full_name}', `Preset ${source.name} should have repo field`);
+        assert.strictEqual(source.repo, '{repository.nameWithOwner}', `Preset ${source.name} should have repo field`);
         const repos = resolveRepoForItem(source, mockItem);
         assert.deepStrictEqual(repos, ['myorg/backend'], `Preset ${source.name} should resolve repo from item`);
       }
@@ -656,12 +661,12 @@ sources:
       loadRepoConfig(configPath);
       const source = getSources()[0];
 
-      // Item from allowed repo should resolve (repository_full_name is mapped from repository_url)
-      const allowedItem = { repository_full_name: 'myorg/backend' };
+      // Item from allowed repo should resolve (gh CLI returns repository.nameWithOwner)
+      const allowedItem = { repository: { nameWithOwner: 'myorg/backend' } };
       assert.deepStrictEqual(resolveRepoForItem(source, allowedItem), ['myorg/backend']);
 
       // Item from non-allowed repo should return empty (filtered out)
-      const filteredItem = { repository_full_name: 'other/repo' };
+      const filteredItem = { repository: { nameWithOwner: 'other/repo' } };
       assert.deepStrictEqual(resolveRepoForItem(source, filteredItem), []);
     });