opencode-pilot 0.9.0 → 0.9.2

package/package.json

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

package/service/actions.js

@@ -18,7 +18,9 @@ import os from "os";
  */
 async function getOpencodePorts() {
   try {
-    const output = execSync('lsof -i -P 2>/dev/null | grep -E "opencode.*LISTEN" || true', {
+    // Use full path to lsof since /usr/sbin may not be in PATH in all contexts
+    // (e.g., when running as a service or from certain shell environments)
+    const output = execSync('/usr/sbin/lsof -i -P 2>/dev/null | grep -E "opencode.*LISTEN" || true', {
       encoding: 'utf-8',
       timeout: 30000
     });
@@ -75,6 +77,24 @@ function getPathMatchScore(targetPath, worktree, sandboxes = []) {
   return 0; // No match
 }
 
+/**
+ * Verify a server is healthy by checking it returns valid project data
+ * @param {string} url - Server URL
+ * @param {object} project - Project data already fetched from /project/current
+ * @returns {boolean} True if server appears healthy
+ */
+function isServerHealthy(project) {
+  // A healthy server should return a project with an id and time.created
+  // Stale/broken servers may return HTML or incomplete JSON
+  return !!(
+    project &&
+    typeof project === 'object' &&
+    project.id &&
+    project.time &&
+    typeof project.time.created === 'number'
+  );
+}
+
 /**
  * Discover a running opencode server that matches the target directory
  * 
@@ -82,7 +102,10 @@ function getPathMatchScore(targetPath, worktree, sandboxes = []) {
  * 1. Exact sandbox match (highest priority)
  * 2. Exact worktree match
  * 3. Target is subdirectory of worktree
- * 4. Global project (worktree="/") as fallback
+ * 
+ * NOTE: Global servers (worktree="/") are NOT used - sessions spawned via
+ * pilot should run in isolated mode rather than attach to the global project,
+ * since the global project doesn't have the right working directory context.
  * 
  * @param {string} targetDir - The directory we want to work in
  * @param {object} [options] - Options for testing/mocking
@@ -115,9 +138,22 @@ export async function discoverOpencodeServer(targetDir, options = {}) {
       }
       
       const project = await response.json();
+      
+      // Health check: verify response has expected structure
+      if (!isServerHealthy(project)) {
+        debug(`discoverOpencodeServer: ${url} failed health check (invalid project data)`);
+        continue;
+      }
+      
       const worktree = project.worktree || '/';
       const sandboxes = project.sandboxes || [];
       
+      // Skip global servers - pilot sessions should run isolated
+      if (worktree === '/') {
+        debug(`discoverOpencodeServer: ${url} is global project, skipping`);
+        continue;
+      }
+      
       const score = getPathMatchScore(targetDir, worktree, sandboxes);
       debug(`discoverOpencodeServer: ${url} worktree=${worktree} score=${score}`);
       

package/test/unit/actions.test.js

@@ -310,10 +310,10 @@ describe('actions.js', () => {
       const mockPorts = async () => [3000, 4000];
       const mockFetch = async (url) => {
         if (url === 'http://localhost:3000/project/current') {
-          return { ok: true, json: async () => ({ worktree: '/Users/test/project-a', sandboxes: [] }) };
+          return { ok: true, json: async () => ({ id: 'proj-a', worktree: '/Users/test/project-a', sandboxes: [], time: { created: 1 } }) };
         }
         if (url === 'http://localhost:4000/project/current') {
-          return { ok: true, json: async () => ({ worktree: '/Users/test/project-b', sandboxes: [] }) };
+          return { ok: true, json: async () => ({ id: 'proj-b', worktree: '/Users/test/project-b', sandboxes: [], time: { created: 1 } }) };
         }
         return { ok: false };
       };
@@ -332,7 +332,7 @@ describe('actions.js', () => {
       const mockPorts = async () => [3000];
       const mockFetch = async (url) => {
         if (url === 'http://localhost:3000/project/current') {
-          return { ok: true, json: async () => ({ worktree: '/Users/test/project', sandboxes: [] }) };
+          return { ok: true, json: async () => ({ id: 'proj', worktree: '/Users/test/project', sandboxes: [], time: { created: 1 } }) };
         }
         return { ok: false };
       };
@@ -352,8 +352,10 @@ describe('actions.js', () => {
       const mockFetch = async (url) => {
         if (url === 'http://localhost:3000/project/current') {
           return { ok: true, json: async () => ({ 
+            id: 'proj',
             worktree: '/Users/test/project', 
-            sandboxes: ['/Users/test/.opencode/worktree/abc/sandbox-1'] 
+            sandboxes: ['/Users/test/.opencode/worktree/abc/sandbox-1'],
+            time: { created: 1 }
           }) };
         }
         return { ok: false };
@@ -374,11 +376,11 @@ describe('actions.js', () => {
       const mockFetch = async (url) => {
         if (url === 'http://localhost:3000/project/current') {
           // Global project
-          return { ok: true, json: async () => ({ worktree: '/', sandboxes: [] }) };
+          return { ok: true, json: async () => ({ id: 'global', worktree: '/', sandboxes: [], time: { created: 1 } }) };
         }
         if (url === 'http://localhost:4000/project/current') {
           // Specific project
-          return { ok: true, json: async () => ({ worktree: '/Users/test/project', sandboxes: [] }) };
+          return { ok: true, json: async () => ({ id: 'proj', worktree: '/Users/test/project', sandboxes: [], time: { created: 1 } }) };
         }
         return { ok: false };
       };
@@ -392,23 +394,25 @@ describe('actions.js', () => {
       assert.strictEqual(result, 'http://localhost:4000');
     });
 
-    test('falls back to global project when no specific match', async () => {
+    test('skips global project servers', async () => {
       const { discoverOpencodeServer } = await import('../../service/actions.js');
       
       const mockPorts = async () => [3000];
       const mockFetch = async (url) => {
         if (url === 'http://localhost:3000/project/current') {
-          return { ok: true, json: async () => ({ worktree: '/', sandboxes: [] }) };
+          // Global project with worktree="/"
+          return { ok: true, json: async () => ({ id: 'global', worktree: '/', sandboxes: [], time: { created: 1 } }) };
         }
         return { ok: false };
       };
       
+      // Global servers should be skipped - pilot sessions should run isolated
       const result = await discoverOpencodeServer('/Users/test/random/path', { 
         getPorts: mockPorts,
         fetch: mockFetch
       });
       
-      assert.strictEqual(result, 'http://localhost:3000');
+      assert.strictEqual(result, null);
     });
 
     test('returns null when fetch fails for all servers', async () => {
@@ -436,7 +440,56 @@ describe('actions.js', () => {
           return { ok: false };
         }
         if (url === 'http://localhost:4000/project/current') {
-          return { ok: true, json: async () => ({ worktree: '/Users/test/project', sandboxes: [] }) };
+          return { ok: true, json: async () => ({ id: 'proj', worktree: '/Users/test/project', sandboxes: [], time: { created: 1 } }) };
+        }
+        return { ok: false };
+      };
+      
+      const result = await discoverOpencodeServer('/Users/test/project', { 
+        getPorts: mockPorts,
+        fetch: mockFetch
+      });
+      
+      assert.strictEqual(result, 'http://localhost:4000');
+    });
+
+    test('skips servers that return invalid JSON', async () => {
+      const { discoverOpencodeServer } = await import('../../service/actions.js');
+      
+      const mockPorts = async () => [3000, 4000];
+      const mockFetch = async (url) => {
+        if (url === 'http://localhost:3000/project/current') {
+          // Stale server returning HTML
+          return { 
+            ok: true, 
+            json: async () => { throw new SyntaxError('Unexpected token < in JSON'); }
+          };
+        }
+        if (url === 'http://localhost:4000/project/current') {
+          return { ok: true, json: async () => ({ id: 'proj', worktree: '/Users/test/project', sandboxes: [], time: { created: 1 } }) };
+        }
+        return { ok: false };
+      };
+      
+      const result = await discoverOpencodeServer('/Users/test/project', { 
+        getPorts: mockPorts,
+        fetch: mockFetch
+      });
+      
+      assert.strictEqual(result, 'http://localhost:4000');
+    });
+
+    test('skips servers with incomplete project data (missing time)', async () => {
+      const { discoverOpencodeServer } = await import('../../service/actions.js');
+      
+      const mockPorts = async () => [3000, 4000];
+      const mockFetch = async (url) => {
+        if (url === 'http://localhost:3000/project/current') {
+          // Server returning incomplete response (missing time.created)
+          return { ok: true, json: async () => ({ id: 'broken', worktree: '/Users/test/project', sandboxes: [] }) };
+        }
+        if (url === 'http://localhost:4000/project/current') {
+          return { ok: true, json: async () => ({ id: 'proj', worktree: '/Users/test/project', sandboxes: [], time: { created: 1 } }) };
         }
         return { ok: false };
       };
@@ -448,6 +501,27 @@ describe('actions.js', () => {
       
       assert.strictEqual(result, 'http://localhost:4000');
     });
+
+    test('returns null when server returns unhealthy project data', async () => {
+      const { discoverOpencodeServer } = await import('../../service/actions.js');
+      
+      const mockPorts = async () => [3000];
+      const mockFetch = async (url) => {
+        if (url === 'http://localhost:3000/project/current') {
+          // Server returns incomplete/unhealthy data (missing id and time)
+          return { ok: true, json: async () => ({ worktree: '/', sandboxes: [] }) };
+        }
+        return { ok: false };
+      };
+      
+      // Server that returns unhealthy project data should be skipped
+      const result = await discoverOpencodeServer('/Users/test/specific-project', { 
+        getPorts: mockPorts,
+        fetch: mockFetch
+      });
+      
+      assert.strictEqual(result, null, 'Should return null when server returns unhealthy project data');
+    });
   });
 
   describe('executeAction', () => {