opencode-pilot 0.14.0 → 0.15.0

package/README.md

@@ -70,6 +70,27 @@ Three ways to configure sources, from simplest to most flexible:
 
 Create prompt templates as markdown files in `~/.config/opencode/pilot/templates/`. Templates support placeholders like `{title}`, `{body}`, `{number}`, `{html_url}`, etc.
 
+### Worktree Support
+
+Run sessions in isolated git worktrees instead of the main project directory. This uses OpenCode's built-in worktree management API to create and manage worktrees.
+
+```yaml
+sources:
+  - preset: github/my-issues
+    # Create a fresh worktree for each session
+    worktree: "new"
+    worktree_name: "issue-{number}"  # Optional: name template
+    
+  - preset: linear/my-issues
+    # Use an existing worktree by name
+    worktree: "my-feature-branch"
+```
+
+**Options:**
+- `worktree: "new"` - Create a new worktree via OpenCode's API
+- `worktree: "name"` - Look up existing worktree by name from project sandboxes
+- `worktree_name` - Template for naming new worktrees (only with `worktree: "new"`)
+
 ## CLI Commands
 
 ```bash
@@ -92,20 +113,6 @@ opencode-pilot test-mapping MCP   # Test field mappings
 3. **Spawn sessions** - Start `opencode run` with the appropriate prompt template
 4. **Track state** - Remember which items have been processed
 
-## Known Issues
-
-### Sessions attached to global server run in wrong directory
-
-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)
-
 ## Related
 
 - [opencode-devcontainers](https://github.com/athal7/opencode-devcontainers) - Run multiple devcontainer instances for OpenCode

package/examples/config.yaml

@@ -33,6 +33,16 @@ sources:
     working_dir: ~/code/myproject
     prompt: worktree
 
+  # Example with worktree support - run each issue in a fresh git worktree
+  # - preset: github/my-issues
+  #   worktree: "new"                    # Create a new worktree per session
+  #   worktree_name: "issue-{number}"    # Name template for new worktrees
+  #   prompt: worktree
+  
+  # Use an existing worktree by name
+  # - preset: github/review-requests
+  #   worktree: "review-worktree"        # Must exist in project sandboxes
+
   # GitHub shorthand syntax
   # - name: urgent-issues
   #   github: "is:issue assignee:@me label:urgent state:open"

package/package.json

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

package/service/actions.js

@@ -10,6 +10,7 @@ import { readFileSync, existsSync } from "fs";
 import { debug } from "./logger.js";
 import { getNestedValue } from "./utils.js";
 import { getServerPort } from "./repo-config.js";
+import { resolveWorktreeDirectory } from "./worktree.js";
 import path from "path";
 import os from "os";
 
@@ -449,6 +450,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,21 +557,87 @@ 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 = {}) {
-  // Get working directory first to determine which server to attach to
+  // Get base working directory first to determine which server to attach to
   const workingDir = config.working_dir || config.path || config.repo_path || "~";
-  const cwd = expandPath(workingDir);
+  const baseCwd = expandPath(workingDir);
   
   // Discover running opencode server for this directory
   const discoverFn = options.discoverServer || discoverOpencodeServer;
-  const serverUrl = await discoverFn(cwd);
+  const serverUrl = await discoverFn(baseCwd);
   
-  debug(`executeAction: discovered server=${serverUrl} for cwd=${cwd}`);
+  debug(`executeAction: discovered server=${serverUrl} for baseCwd=${baseCwd}`);
+  
+  // Resolve worktree directory if configured
+  // This allows creating sessions in isolated worktrees instead of the main project
+  const worktreeConfig = {
+    worktree: config.worktree,
+    // Expand worktree_name template with item fields (e.g., "issue-{number}")
+    worktreeName: config.worktree_name ? expandTemplate(config.worktree_name, item) : undefined,
+  };
+  
+  const worktreeResult = await resolveWorktreeDirectory(
+    serverUrl,
+    baseCwd,
+    worktreeConfig,
+    { fetch: options.fetch }
+  );
+  
+  const cwd = expandPath(worktreeResult.directory);
+  
+  if (worktreeResult.worktreeCreated) {
+    debug(`executeAction: created new worktree at ${cwd}`);
+  } else if (worktreeResult.error) {
+    debug(`executeAction: worktree resolution warning - ${worktreeResult.error}`);
+  }
+  
+  debug(`executeAction: using cwd=${cwd}`);
+  
+  // 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',
+    };
+  }
   
-  // Build command info with server URL for --attach flag
-  const cmdInfo = getCommandInfoNew(item, config, undefined, serverUrl);
+  // 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 +653,7 @@ export async function executeAction(item, config, options = {}) {
     return {
       command,
       dryRun: true,
+      method: 'spawn',
     };
   }
 
@@ -505,6 +673,7 @@ export async function executeAction(item, config, options = {}) {
     command,
     success: true,
     pid: child.pid,
+    method: 'spawn',
   };
 }
 

package/service/worktree.js

@@ -0,0 +1,182 @@
+/**
+ * worktree.js - Worktree management for OpenCode sessions
+ *
+ * Interacts with OpenCode server to list and create worktrees (sandboxes).
+ * Worktrees allow running sessions in isolated git branches/directories.
+ */
+
+import { debug } from "./logger.js";
+
+/**
+ * List available worktrees/sandboxes for a project
+ * 
+ * @param {string} serverUrl - OpenCode server URL (e.g., "http://localhost:4096")
+ * @param {object} [options] - Options
+ * @param {function} [options.fetch] - Custom fetch function (for testing)
+ * @returns {Promise<string[]>} Array of worktree directory paths
+ */
+export async function listWorktrees(serverUrl, options = {}) {
+  const fetchFn = options.fetch || fetch;
+  
+  try {
+    const response = await fetchFn(`${serverUrl}/experimental/worktree`);
+    
+    if (!response.ok) {
+      debug(`listWorktrees: ${serverUrl} returned ${response.status}`);
+      return [];
+    }
+    
+    const worktrees = await response.json();
+    debug(`listWorktrees: found ${worktrees.length} worktrees`);
+    return Array.isArray(worktrees) ? worktrees : [];
+  } catch (err) {
+    debug(`listWorktrees: error - ${err.message}`);
+    return [];
+  }
+}
+
+/**
+ * Create a new worktree for a project
+ * 
+ * @param {string} serverUrl - OpenCode server URL (e.g., "http://localhost:4096")
+ * @param {object} [options] - Options
+ * @param {string} [options.name] - Optional name for the worktree
+ * @param {string} [options.startCommand] - Optional startup script to run after creation
+ * @param {function} [options.fetch] - Custom fetch function (for testing)
+ * @returns {Promise<object>} Result with { success, worktree?, error? }
+ */
+export async function createWorktree(serverUrl, options = {}) {
+  const fetchFn = options.fetch || fetch;
+  
+  try {
+    const body = {};
+    if (options.name) body.name = options.name;
+    if (options.startCommand) body.startCommand = options.startCommand;
+    
+    const response = await fetchFn(`${serverUrl}/experimental/worktree`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    });
+    
+    if (!response.ok) {
+      const errorText = await response.text();
+      debug(`createWorktree: ${serverUrl} returned ${response.status} - ${errorText}`);
+      return {
+        success: false,
+        error: `Failed to create worktree: ${response.status} ${errorText}`,
+      };
+    }
+    
+    const worktree = await response.json();
+    debug(`createWorktree: created worktree ${worktree.name} at ${worktree.directory}`);
+    
+    return {
+      success: true,
+      worktree,
+    };
+  } catch (err) {
+    debug(`createWorktree: error - ${err.message}`);
+    return {
+      success: false,
+      error: err.message,
+    };
+  }
+}
+
+/**
+ * Get project info including sandboxes from the server
+ * 
+ * @param {string} serverUrl - OpenCode server URL
+ * @param {object} [options] - Options
+ * @param {function} [options.fetch] - Custom fetch function (for testing)
+ * @returns {Promise<object|null>} Project info or null if unavailable
+ */
+export async function getProjectInfo(serverUrl, options = {}) {
+  const fetchFn = options.fetch || fetch;
+  
+  try {
+    const response = await fetchFn(`${serverUrl}/project/current`);
+    
+    if (!response.ok) {
+      debug(`getProjectInfo: ${serverUrl} returned ${response.status}`);
+      return null;
+    }
+    
+    const project = await response.json();
+    debug(`getProjectInfo: project ${project.id} with ${project.sandboxes?.length || 0} sandboxes`);
+    return project;
+  } catch (err) {
+    debug(`getProjectInfo: error - ${err.message}`);
+    return null;
+  }
+}
+
+/**
+ * Resolve the working directory based on worktree configuration
+ * 
+ * Uses OpenCode's experimental worktree API:
+ * - GET /experimental/worktree - List existing worktrees
+ * - POST /experimental/worktree - Create new worktree
+ * 
+ * @param {string} serverUrl - OpenCode server URL
+ * @param {string} baseDir - Base working directory from config
+ * @param {object} worktreeConfig - Worktree configuration
+ * @param {string} [worktreeConfig.worktree] - Worktree mode: "new" or worktree name
+ * @param {string} [worktreeConfig.worktreeName] - Name for new worktree (only with "new")
+ * @param {object} [options] - Options
+ * @param {function} [options.fetch] - Custom fetch function (for testing)
+ * @returns {Promise<object>} Result with { directory, worktreeCreated?, error? }
+ */
+export async function resolveWorktreeDirectory(serverUrl, baseDir, worktreeConfig, options = {}) {
+  // No worktree config - use base directory
+  if (!worktreeConfig?.worktree) {
+    return { directory: baseDir };
+  }
+  
+  // Require server for any worktree operation
+  if (!serverUrl) {
+    return {
+      directory: baseDir,
+      error: "Cannot use worktree: no server running",
+    };
+  }
+  
+  const worktreeValue = worktreeConfig.worktree;
+  
+  // "new" - create a fresh worktree via OpenCode API
+  if (worktreeValue === "new") {
+    const result = await createWorktree(serverUrl, {
+      name: worktreeConfig.worktreeName,
+      fetch: options.fetch,
+    });
+    
+    if (!result.success) {
+      return {
+        directory: baseDir,
+        error: result.error,
+      };
+    }
+    
+    return {
+      directory: result.worktree.directory,
+      worktreeCreated: true,
+      worktree: result.worktree,
+    };
+  }
+  
+  // Named worktree - look it up from available sandboxes via OpenCode API
+  const worktrees = await listWorktrees(serverUrl, options);
+  const match = worktrees.find(w => w.includes(worktreeValue));
+  if (match) {
+    return { directory: match };
+  }
+  
+  debug(`resolveWorktreeDirectory: worktree "${worktreeValue}" not found in available sandboxes`);
+  
+  // Fallback to base directory
+  return {
+    directory: baseDir,
+    error: `Worktree "${worktreeValue}" not found in project sandboxes`,
+  };
+}

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,252 @@ 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');
+    });
+
+    test('creates new worktree when worktree: "new" is configured (dry run)', async () => {
+      const { executeAction } = await import('../../service/actions.js');
+      
+      const item = { number: 123, title: 'Fix bug' };
+      const config = {
+        path: tempDir,
+        prompt: 'default',
+        worktree: 'new',
+        worktree_name: 'feature-branch'
+      };
+      
+      // Mock server discovery
+      const mockDiscoverServer = async () => 'http://localhost:4096';
+      
+      // Mock worktree creation via fetch
+      const mockFetch = async (url, opts) => {
+        // Worktree creation endpoint
+        if (url === 'http://localhost:4096/experimental/worktree' && opts?.method === 'POST') {
+          const body = JSON.parse(opts.body);
+          assert.strictEqual(body.name, 'feature-branch', 'Should pass worktree name');
+          return {
+            ok: true,
+            json: async () => ({
+              name: 'feature-branch',
+              branch: 'opencode/feature-branch',
+              directory: '/data/worktree/proj123/feature-branch'
+            })
+          };
+        }
+        return { ok: false, text: async () => 'Not found' };
+      };
+      
+      const result = await executeAction(item, config, { 
+        dryRun: true,
+        discoverServer: mockDiscoverServer,
+        fetch: mockFetch
+      });
+      
+      assert.ok(result.dryRun);
+      assert.strictEqual(result.method, 'api', 'Should use API method');
+      // The directory in the command should be the worktree directory
+      assert.ok(result.command.includes('/data/worktree/proj123/feature-branch'), 
+        'Should use worktree directory in command');
+    });
+
+    test('uses existing worktree by name (dry run)', async () => {
+      const { executeAction } = await import('../../service/actions.js');
+      
+      const item = { number: 123, title: 'Fix bug' };
+      const config = {
+        path: tempDir,
+        prompt: 'default',
+        worktree: 'my-feature'
+      };
+      
+      // Mock server discovery
+      const mockDiscoverServer = async () => 'http://localhost:4096';
+      
+      // Mock worktree list lookup
+      const mockFetch = async (url) => {
+        if (url === 'http://localhost:4096/experimental/worktree') {
+          return {
+            ok: true,
+            json: async () => [
+              '/data/worktree/proj123/other-branch',
+              '/data/worktree/proj123/my-feature'
+            ]
+          };
+        }
+        return { ok: false, text: async () => 'Not found' };
+      };
+      
+      const result = await executeAction(item, config, { 
+        dryRun: true,
+        discoverServer: mockDiscoverServer,
+        fetch: mockFetch
+      });
+      
+      assert.ok(result.dryRun);
+      assert.strictEqual(result.method, 'api', 'Should use API method');
+      assert.ok(result.command.includes('/data/worktree/proj123/my-feature'), 
+        'Should use looked up worktree path in command');
+    });
+
+    test('falls back to base directory when worktree creation fails (dry run)', async () => {
+      const { executeAction } = await import('../../service/actions.js');
+      
+      const item = { number: 123, title: 'Fix bug' };
+      const config = {
+        path: tempDir,
+        prompt: 'default',
+        worktree: 'new'
+      };
+      
+      // Mock server discovery
+      const mockDiscoverServer = async () => 'http://localhost:4096';
+      
+      // Mock worktree creation failure
+      const mockFetch = async (url, opts) => {
+        if (url === 'http://localhost:4096/experimental/worktree' && opts?.method === 'POST') {
+          return {
+            ok: false,
+            status: 500,
+            text: async () => 'Internal server error'
+          };
+        }
+        return { ok: false, text: async () => 'Not found' };
+      };
+      
+      const result = await executeAction(item, config, { 
+        dryRun: true,
+        discoverServer: mockDiscoverServer,
+        fetch: mockFetch
+      });
+      
+      assert.ok(result.dryRun);
+      assert.strictEqual(result.method, 'api', 'Should still use API method');
+      // Should fall back to base directory
+      assert.ok(result.command.includes(tempDir), 
+        'Should fall back to base directory when worktree creation fails');
+    });
+  });
+
+  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/worktree.test.js

@@ -0,0 +1,250 @@
+import { describe, it, mock } from "node:test";
+import assert from "node:assert";
+import {
+  listWorktrees,
+  createWorktree,
+  getProjectInfo,
+  resolveWorktreeDirectory,
+} from "../../service/worktree.js";
+
+describe("worktree", () => {
+  describe("listWorktrees", () => {
+    it("returns worktrees from server", async () => {
+      const mockFetch = mock.fn(async () => ({
+        ok: true,
+        json: async () => ["/path/to/worktree1", "/path/to/worktree2"],
+      }));
+
+      const result = await listWorktrees("http://localhost:4096", { fetch: mockFetch });
+
+      assert.deepStrictEqual(result, ["/path/to/worktree1", "/path/to/worktree2"]);
+      assert.strictEqual(mockFetch.mock.calls.length, 1);
+      assert.strictEqual(mockFetch.mock.calls[0].arguments[0], "http://localhost:4096/experimental/worktree");
+    });
+
+    it("returns empty array on error", async () => {
+      const mockFetch = mock.fn(async () => ({
+        ok: false,
+        status: 500,
+      }));
+
+      const result = await listWorktrees("http://localhost:4096", { fetch: mockFetch });
+
+      assert.deepStrictEqual(result, []);
+    });
+
+    it("returns empty array on network error", async () => {
+      const mockFetch = mock.fn(async () => {
+        throw new Error("Network error");
+      });
+
+      const result = await listWorktrees("http://localhost:4096", { fetch: mockFetch });
+
+      assert.deepStrictEqual(result, []);
+    });
+  });
+
+  describe("createWorktree", () => {
+    it("creates a worktree successfully", async () => {
+      const worktreeResponse = {
+        name: "brave-falcon",
+        branch: "opencode/brave-falcon",
+        directory: "/data/worktree/abc123/brave-falcon",
+      };
+
+      const mockFetch = mock.fn(async () => ({
+        ok: true,
+        json: async () => worktreeResponse,
+      }));
+
+      const result = await createWorktree("http://localhost:4096", { fetch: mockFetch });
+
+      assert.strictEqual(result.success, true);
+      assert.deepStrictEqual(result.worktree, worktreeResponse);
+    });
+
+    it("passes name option to server", async () => {
+      const mockFetch = mock.fn(async (url, options) => ({
+        ok: true,
+        json: async () => ({
+          name: "my-feature",
+          branch: "opencode/my-feature",
+          directory: "/data/worktree/abc123/my-feature",
+        }),
+      }));
+
+      await createWorktree("http://localhost:4096", {
+        name: "my-feature",
+        fetch: mockFetch,
+      });
+
+      const body = JSON.parse(mockFetch.mock.calls[0].arguments[1].body);
+      assert.strictEqual(body.name, "my-feature");
+    });
+
+    it("returns error on failure", async () => {
+      const mockFetch = mock.fn(async () => ({
+        ok: false,
+        status: 400,
+        text: async () => "Invalid request",
+      }));
+
+      const result = await createWorktree("http://localhost:4096", { fetch: mockFetch });
+
+      assert.strictEqual(result.success, false);
+      assert.ok(result.error.includes("400"));
+    });
+  });
+
+  describe("getProjectInfo", () => {
+    it("returns project info", async () => {
+      const projectInfo = {
+        id: "abc123",
+        worktree: "/path/to/project",
+        sandboxes: ["/path/to/sandbox1", "/path/to/sandbox2"],
+      };
+
+      const mockFetch = mock.fn(async () => ({
+        ok: true,
+        json: async () => projectInfo,
+      }));
+
+      const result = await getProjectInfo("http://localhost:4096", { fetch: mockFetch });
+
+      assert.deepStrictEqual(result, projectInfo);
+    });
+
+    it("returns null on error", async () => {
+      const mockFetch = mock.fn(async () => ({
+        ok: false,
+        status: 404,
+      }));
+
+      const result = await getProjectInfo("http://localhost:4096", { fetch: mockFetch });
+
+      assert.strictEqual(result, null);
+    });
+  });
+
+  describe("resolveWorktreeDirectory", () => {
+    it("returns base directory when no worktree config", async () => {
+      const result = await resolveWorktreeDirectory(
+        "http://localhost:4096",
+        "/path/to/project",
+        {}
+      );
+
+      assert.strictEqual(result.directory, "/path/to/project");
+    });
+
+    it("returns base directory when worktree is undefined", async () => {
+      const result = await resolveWorktreeDirectory(
+        "http://localhost:4096",
+        "/path/to/project",
+        { worktree: undefined }
+      );
+
+      assert.strictEqual(result.directory, "/path/to/project");
+    });
+
+    it("creates new worktree when worktree is 'new'", async () => {
+      const mockFetch = mock.fn(async () => ({
+        ok: true,
+        json: async () => ({
+          name: "test-worktree",
+          branch: "opencode/test-worktree",
+          directory: "/data/worktree/abc123/test-worktree",
+        }),
+      }));
+
+      const result = await resolveWorktreeDirectory(
+        "http://localhost:4096",
+        "/path/to/project",
+        { worktree: "new" },
+        { fetch: mockFetch }
+      );
+
+      assert.strictEqual(result.directory, "/data/worktree/abc123/test-worktree");
+      assert.strictEqual(result.worktreeCreated, true);
+    });
+
+    it("passes worktreeName when creating new worktree", async () => {
+      const mockFetch = mock.fn(async () => ({
+        ok: true,
+        json: async () => ({
+          name: "my-feature",
+          branch: "opencode/my-feature",
+          directory: "/data/worktree/abc123/my-feature",
+        }),
+      }));
+
+      await resolveWorktreeDirectory(
+        "http://localhost:4096",
+        "/path/to/project",
+        { worktree: "new", worktreeName: "my-feature" },
+        { fetch: mockFetch }
+      );
+
+      const body = JSON.parse(mockFetch.mock.calls[0].arguments[1].body);
+      assert.strictEqual(body.name, "my-feature");
+    });
+
+    it("returns error when no server running", async () => {
+      const result = await resolveWorktreeDirectory(
+        null,
+        "/path/to/project",
+        { worktree: "new" }
+      );
+
+      assert.strictEqual(result.directory, "/path/to/project");
+      assert.ok(result.error.includes("no server"));
+    });
+
+    it("returns error when no server running for named worktree", async () => {
+      const result = await resolveWorktreeDirectory(
+        null,
+        "/path/to/project",
+        { worktree: "my-feature" }
+      );
+
+      assert.strictEqual(result.directory, "/path/to/project");
+      assert.ok(result.error.includes("no server"));
+    });
+
+    it("looks up named worktree from sandboxes", async () => {
+      const mockFetch = mock.fn(async () => ({
+        ok: true,
+        json: async () => [
+          "/data/worktree/abc123/brave-falcon",
+          "/data/worktree/abc123/my-feature",
+        ],
+      }));
+
+      const result = await resolveWorktreeDirectory(
+        "http://localhost:4096",
+        "/path/to/project",
+        { worktree: "my-feature" },
+        { fetch: mockFetch }
+      );
+
+      assert.strictEqual(result.directory, "/data/worktree/abc123/my-feature");
+    });
+
+    it("returns error when named worktree not found", async () => {
+      const mockFetch = mock.fn(async () => ({
+        ok: true,
+        json: async () => ["/data/worktree/abc123/other-worktree"],
+      }));
+
+      const result = await resolveWorktreeDirectory(
+        "http://localhost:4096",
+        "/path/to/project",
+        { worktree: "nonexistent" },
+        { fetch: mockFetch }
+      );
+
+      assert.strictEqual(result.directory, "/path/to/project");
+      assert.ok(result.error.includes("not found"));
+    });
+  });
+});