opencode-pilot 0.16.3 → 0.16.5

package/package.json

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

package/service/actions.js

@@ -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
@@ -523,19 +525,40 @@ export async function createSessionViaApi(serverUrl, directory, prompt, options
       messageBody.modelID = modelID;
     }
     
-    const messageResponse = await fetchFn(messageUrl.toString(), {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(messageBody),
-    });
+    // Use AbortController with timeout for the message POST
+    // The /session/{id}/message endpoint returns a chunked/streaming response
+    // that stays open until the agent completes. We only need to verify the
+    // request was accepted (2xx status), not wait for the full response.
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 10000); // 10 second timeout
     
-    if (!messageResponse.ok) {
-      const errorText = await messageResponse.text();
-      throw new Error(`Failed to send message: ${messageResponse.status} ${errorText}`);
+    try {
+      const messageResponse = await fetchFn(messageUrl.toString(), {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(messageBody),
+        signal: controller.signal,
+      });
+      
+      clearTimeout(timeoutId);
+      
+      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}`);
+    } catch (abortErr) {
+      clearTimeout(timeoutId);
+      // AbortError is expected - we intentionally abort after verifying the request started
+      // The server accepted our message, we just don't need to wait for the response
+      if (abortErr.name === 'AbortError') {
+        debug(`createSessionViaApi: message request started for session ${session.id} (response aborted as expected)`);
+      } else {
+        throw abortErr;
+      }
     }
     
-    debug(`createSessionViaApi: sent message to session ${session.id}`);
-    
     return {
       success: true,
       sessionId: session.id,
@@ -543,6 +566,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,

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/repo-config.js

@@ -352,7 +352,12 @@ export function resolveRepoForItem(source, item) {
     if (resolvedRepo) {
       return source.repos.includes(resolvedRepo) ? [resolvedRepo] : [];
     }
-    // No repo template - return empty (can't match without item context)
+    // No repo template - if exactly one repo, use it as default
+    // (e.g., Linear issues don't have repo context, user explicitly configures one repo)
+    if (source.repos.length === 1) {
+      return source.repos;
+    }
+    // Multiple repos but can't match without item context
     return [];
   }
 

package/test/unit/actions.test.js

@@ -930,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/repo-config.test.js

@@ -769,6 +769,46 @@ sources:
       assert.deepStrictEqual(resolveRepoForItem(source, filteredItem), []);
     });
 
+    test('single-repo allowlist uses repo as default when no template', async () => {
+      // Linear issues don't have repository context - when exactly one repo is configured,
+      // use it as the default for all items from that source
+      writeFileSync(configPath, `
+sources:
+  - preset: linear/my-issues
+    repos:
+      - 0din-ai/odin
+`);
+
+      const { loadRepoConfig, getSources, resolveRepoForItem } = await import('../../service/repo-config.js');
+      loadRepoConfig(configPath);
+      const source = getSources()[0];
+
+      // Linear items don't have repository field
+      const linearItem = { id: 'linear:abc123', title: 'Fix bug', state: { name: 'In Progress' } };
+      assert.deepStrictEqual(resolveRepoForItem(source, linearItem), ['0din-ai/odin'],
+        'single-repo allowlist should use repo as default');
+    });
+
+    test('multi-repo allowlist returns empty when no template match', async () => {
+      // With multiple repos and no way to determine which one, return empty
+      writeFileSync(configPath, `
+sources:
+  - preset: linear/my-issues
+    repos:
+      - org/repo-a
+      - org/repo-b
+`);
+
+      const { loadRepoConfig, getSources, resolveRepoForItem } = await import('../../service/repo-config.js');
+      loadRepoConfig(configPath);
+      const source = getSources()[0];
+
+      // Can't determine which of the 2 repos to use
+      const linearItem = { id: 'linear:abc123', title: 'Fix bug' };
+      assert.deepStrictEqual(resolveRepoForItem(source, linearItem), [],
+        'multi-repo allowlist should return empty when no template');
+    });
+
     test('github presets include semantic session names', async () => {
       writeFileSync(configPath, `
 sources: