@openchamber/web 1.11.6 → 1.11.7

package/server/lib/git/service.test.js

@@ -1,23 +1,86 @@
-import { describe, expect, it } from 'vitest';
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import simpleGit from 'simple-git';
 
-import { resolveBaseRefForLog, stageFiles, unstageFiles } from './service.js';
+import {
+  checkoutCommit,
+  cherryPick,
+  getStatus,
+  resetToCommit,
+  resolveBaseRefForLog,
+  revertCommit,
+  stageFiles,
+  unstageFiles,
+} from './service.js';
+
+// ---------------------------------------------------------------------------
+// Shared test infrastructure
+// ---------------------------------------------------------------------------
+
+const tempDirs = [];
+
+/** Create a temp dir and register it for afterEach cleanup. */
+const createTempDir = () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'openchamber-git-service-'));
+  tempDirs.push(dir);
+  return dir;
+};
+
+const runGit = (cwd, args) =>
+  execFileSync('git', args, {
+    cwd,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+
+const canRunGit = () => {
+  try {
+    execFileSync('git', ['--version'], { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+afterEach(() => {
+  for (const dir of tempDirs.splice(0)) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+/**
+ * Create a temp repo using simple-git (for tests that need its assertion API).
+ * The dir is registered in tempDirs so afterEach handles cleanup automatically.
+ */
+async function createTempRepo() {
+  const tmpDir = createTempDir();
+  const git = simpleGit(tmpDir);
+  await git.init();
+  await git.addConfig('user.name', 'Test User', false, 'local');
+  await git.addConfig('user.email', 'test@example.com', false, 'local');
+  await git.raw(['symbolic-ref', 'HEAD', 'refs/heads/main']);
+  return { tmpDir, git };
+}
+
+// ---------------------------------------------------------------------------
+// resolveBaseRefForLog
+// ---------------------------------------------------------------------------
 
 describe('resolveBaseRefForLog', () => {
   it('returns the local ref unchanged when it exists, even if origin also exists', async () => {
-    // Both local 'main' and 'refs/remotes/origin/main' are present.
-    // The local ref takes precedence — callers that ask for 'main' get 'main'.
     const checkRef = async (ref) => ref === 'main' || ref === 'refs/remotes/origin/main';
     expect(await resolveBaseRefForLog('main', checkRef)).toBe('main');
   });
 
   it('falls back to origin/<from> when local ref cannot be resolved but origin can', async () => {
-    // Local 'main' is absent (e.g. user never checked it out), but origin/main exists.
     const checkRef = async (ref) => ref === 'refs/remotes/origin/main';
     expect(await resolveBaseRefForLog('main', checkRef)).toBe('origin/main');
   });
 
   it('returns the original ref when neither local nor origin ref can be resolved', async () => {
-    // Neither ref exists; return as-is so git surfaces a meaningful error.
     const checkRef = async () => false;
     expect(await resolveBaseRefForLog('nonexistent-branch', checkRef)).toBe('nonexistent-branch');
   });
@@ -38,12 +101,355 @@ describe('resolveBaseRefForLog', () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// git index path validation
+// ---------------------------------------------------------------------------
+
 describe('git index path validation', () => {
   it('rejects stage paths outside the repository before invoking git', async () => {
-    await expect(stageFiles('/repo', ['../secret.txt'])).rejects.toThrow('Path is outside repository: ../secret.txt');
+    await expect(stageFiles('/repo', ['../secret.txt'])).rejects.toThrow(
+      'Path is outside repository: ../secret.txt'
+    );
   });
 
   it('rejects unstage paths outside the repository before invoking git', async () => {
-    await expect(unstageFiles('/repo', ['../secret.txt'])).rejects.toThrow('Path is outside repository: ../secret.txt');
+    await expect(unstageFiles('/repo', ['../secret.txt'])).rejects.toThrow(
+      'Path is outside repository: ../secret.txt'
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// getStatus
+// ---------------------------------------------------------------------------
+
+describe('getStatus', () => {
+  it('handles repositories without upstream tracking', async () => {
+    if (!canRunGit()) return;
+
+    const repo = createTempDir();
+    runGit(repo, ['init', '-b', 'main']);
+    runGit(repo, ['config', 'user.email', 'test@example.com']);
+    runGit(repo, ['config', 'user.name', 'Test User']);
+    fs.writeFileSync(path.join(repo, 'README.md'), '# Test\n');
+    runGit(repo, ['add', 'README.md']);
+    runGit(repo, ['commit', '-m', 'Initial commit']);
+
+    await expect(getStatus(repo)).resolves.toMatchObject({ current: 'main' });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// checkoutCommit
+// ---------------------------------------------------------------------------
+
+describe('checkoutCommit', () => {
+  it('checks out a valid commit and puts the repo in detached HEAD state', async () => {
+    const { tmpDir, git } = await createTempRepo();
+    const filePath = path.join(tmpDir, 'file.txt');
+    await fs.promises.writeFile(filePath, 'first', 'utf8');
+    await git.add('file.txt');
+    const firstCommit = await git.commit('First commit');
+
+    await fs.promises.writeFile(filePath, 'second', 'utf8');
+    await git.add('file.txt');
+    await git.commit('Second commit');
+
+    const result = await checkoutCommit(tmpDir, firstCommit.commit);
+    expect(result).toEqual({ success: true });
+
+    const status = await git.status();
+    expect(status.detached).toBe(true);
+  });
+
+  it('throws an error for an invalid/nonexistent hash', async () => {
+    const { tmpDir } = await createTempRepo();
+    await expect(checkoutCommit(tmpDir, 'invalidhash123')).rejects.toThrow();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// cherryPick
+// ---------------------------------------------------------------------------
+
+describe('cherryPick', () => {
+  it('cherry-picks a commit that applies cleanly', async () => {
+    const { tmpDir, git } = await createTempRepo();
+    const filePath = path.join(tmpDir, 'file.txt');
+    await fs.promises.writeFile(filePath, 'line1\nline2\n', 'utf8');
+    await git.add('file.txt');
+    await git.commit('Initial commit');
+
+    await git.checkoutBranch('feature', 'HEAD');
+    await fs.promises.writeFile(filePath, 'line1\nline2\nline3\n', 'utf8');
+    await git.add('file.txt');
+    const featureCommit = await git.commit('Add line3');
+
+    await git.checkout('main');
+    const result = await cherryPick(tmpDir, featureCommit.commit);
+    expect(result).toEqual({ success: true, conflict: false });
+
+    const content = await fs.promises.readFile(filePath, 'utf8');
+    expect(content).toBe('line1\nline2\nline3\n');
+  });
+
+  it('returns conflict info when cherry-picking a conflicting commit', async () => {
+    const { tmpDir, git } = await createTempRepo();
+    const filePath = path.join(tmpDir, 'file.txt');
+    await fs.promises.writeFile(filePath, 'line1\nline2\n', 'utf8');
+    await git.add('file.txt');
+    await git.commit('Initial commit');
+
+    await git.checkoutBranch('feature', 'HEAD');
+    await fs.promises.writeFile(filePath, 'line1\nfeature-line2\n', 'utf8');
+    await git.add('file.txt');
+    const featureCommit = await git.commit('Change line2 in feature');
+
+    await git.checkout('main');
+    await fs.promises.writeFile(filePath, 'line1\nmain-line2\n', 'utf8');
+    await git.add('file.txt');
+    await git.commit('Change line2 in main');
+
+    const result = await cherryPick(tmpDir, featureCommit.commit);
+    expect(result.success).toBe(false);
+    expect(result.conflict).toBe(true);
+    expect(Array.isArray(result.conflictFiles)).toBe(true);
+    expect(result.conflictFiles.length).toBeGreaterThan(0);
+  });
+
+  it('throws for an invalid/nonexistent hash', async () => {
+    const { tmpDir } = await createTempRepo();
+    await expect(cherryPick(tmpDir, 'deadbeef00000000')).rejects.toThrow();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// revertCommit
+// ---------------------------------------------------------------------------
+
+describe('revertCommit', () => {
+  it('reverts a commit and stages the revert changes', async () => {
+    const { tmpDir, git } = await createTempRepo();
+    const filePath = path.join(tmpDir, 'file.txt');
+    await fs.promises.writeFile(filePath, 'line1\nline2\n', 'utf8');
+    await git.add('file.txt');
+    await git.commit('Initial commit');
+
+    await fs.promises.writeFile(filePath, 'line1\nline2\nline3\n', 'utf8');
+    await git.add('file.txt');
+    const changeCommit = await git.commit('Add line3');
+
+    const result = await revertCommit(tmpDir, changeCommit.commit);
+    expect(result).toEqual({ success: true, conflict: false });
+
+    const status = await git.status();
+    expect(status.staged.length).toBeGreaterThan(0);
+    const content = await fs.promises.readFile(filePath, 'utf8');
+    expect(content).toBe('line1\nline2\n');
+  });
+
+  it('returns conflict info when reverting causes a conflict', async () => {
+    const { tmpDir, git } = await createTempRepo();
+    const filePath = path.join(tmpDir, 'file.txt');
+    await fs.promises.writeFile(filePath, 'line1\nline2\nline3\n', 'utf8');
+    await git.add('file.txt');
+    await git.commit('Initial commit');
+
+    await fs.promises.writeFile(filePath, 'line1\nchanged-a\nline3\n', 'utf8');
+    await git.add('file.txt');
+    const commitA = await git.commit('Change line2 to changed-a');
+
+    await fs.promises.writeFile(filePath, 'line1\nchanged-b\nline3\n', 'utf8');
+    await git.add('file.txt');
+    await git.commit('Change line2 to changed-b');
+
+    const result = await revertCommit(tmpDir, commitA.commit);
+    expect(result.success).toBe(false);
+    expect(result.conflict).toBe(true);
+    expect(Array.isArray(result.conflictFiles)).toBe(true);
+    expect(result.conflictFiles.length).toBeGreaterThan(0);
+  });
+
+  it('throws for an invalid/nonexistent hash', async () => {
+    const { tmpDir } = await createTempRepo();
+    await expect(revertCommit(tmpDir, 'deadbeef00000000')).rejects.toThrow();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// resetToCommit
+// ---------------------------------------------------------------------------
+
+describe('resetToCommit', () => {
+  it('soft reset moves HEAD without touching the working tree', async () => {
+    const { tmpDir, git } = await createTempRepo();
+    const filePath = path.join(tmpDir, 'file.txt');
+    await fs.promises.writeFile(filePath, 'first\n', 'utf8');
+    await git.add('file.txt');
+    const firstCommit = await git.commit('First commit');
+
+    await fs.promises.writeFile(filePath, 'second\n', 'utf8');
+    await git.add('file.txt');
+    await git.commit('Second commit');
+
+    const result = await resetToCommit(tmpDir, firstCommit.commit, 'soft');
+    expect(result).toEqual({ success: true });
+
+    const log = await git.log();
+    expect(log.latest.hash).toBe(firstCommit.commit);
+    const content = await fs.promises.readFile(filePath, 'utf8');
+    expect(content).toBe('second\n');
+
+    const status = await git.status();
+    expect(status.staged.length).toBeGreaterThan(0);
+  });
+
+  it('mixed reset moves HEAD and unstages changes', async () => {
+    const { tmpDir, git } = await createTempRepo();
+    const filePath = path.join(tmpDir, 'file.txt');
+    await fs.promises.writeFile(filePath, 'first\n', 'utf8');
+    await git.add('file.txt');
+    const firstCommit = await git.commit('First commit');
+
+    await fs.promises.writeFile(filePath, 'second\n', 'utf8');
+    await git.add('file.txt');
+    await git.commit('Second commit');
+
+    const result = await resetToCommit(tmpDir, firstCommit.commit, 'mixed');
+    expect(result).toEqual({ success: true });
+
+    const log = await git.log();
+    expect(log.latest.hash).toBe(firstCommit.commit);
+    const content = await fs.promises.readFile(filePath, 'utf8');
+    expect(content).toBe('second\n');
+
+    const status = await git.status();
+    expect(status.staged.length).toBe(0);
+    expect(status.modified.length).toBeGreaterThan(0);
+  });
+
+  it('hard reset with clean working tree succeeds', async () => {
+    const { tmpDir, git } = await createTempRepo();
+    const filePath = path.join(tmpDir, 'file.txt');
+    await fs.promises.writeFile(filePath, 'first\n', 'utf8');
+    await git.add('file.txt');
+    const firstCommit = await git.commit('First commit');
+
+    await fs.promises.writeFile(filePath, 'second\n', 'utf8');
+    await git.add('file.txt');
+    await git.commit('Second commit');
+
+    const result = await resetToCommit(tmpDir, firstCommit.commit, 'hard');
+    expect(result).toEqual({ success: true });
+
+    const log = await git.log();
+    expect(log.latest.hash).toBe(firstCommit.commit);
+    const content = await fs.promises.readFile(filePath, 'utf8');
+    expect(content).toBe('first\n');
+
+    const status = await git.status();
+    expect(status.isClean()).toBe(true);
+  });
+
+  it('hard reset with dirty working tree without force throws', async () => {
+    const { tmpDir, git } = await createTempRepo();
+    const filePath = path.join(tmpDir, 'file.txt');
+    await fs.promises.writeFile(filePath, 'first\n', 'utf8');
+    await git.add('file.txt');
+    const firstCommit = await git.commit('First commit');
+
+    await fs.promises.writeFile(filePath, 'second\n', 'utf8');
+    await git.add('file.txt');
+    await git.commit('Second commit');
+
+    await fs.promises.writeFile(filePath, 'dirty\n', 'utf8');
+
+    await expect(resetToCommit(tmpDir, firstCommit.commit, 'hard')).rejects.toThrow(
+      'Cannot hard reset: uncommitted changes in working tree'
+    );
+  });
+
+  it('hard reset with dirty working tree with force succeeds', async () => {
+    const { tmpDir, git } = await createTempRepo();
+    const filePath = path.join(tmpDir, 'file.txt');
+    await fs.promises.writeFile(filePath, 'first\n', 'utf8');
+    await git.add('file.txt');
+    const firstCommit = await git.commit('First commit');
+
+    await fs.promises.writeFile(filePath, 'second\n', 'utf8');
+    await git.add('file.txt');
+    await git.commit('Second commit');
+
+    await fs.promises.writeFile(filePath, 'dirty\n', 'utf8');
+
+    const result = await resetToCommit(tmpDir, firstCommit.commit, 'hard', true);
+    expect(result).toEqual({ success: true });
+
+    const log = await git.log();
+    expect(log.latest.hash).toBe(firstCommit.commit);
+    const content = await fs.promises.readFile(filePath, 'utf8');
+    expect(content).toBe('first\n');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// hash validation
+// ---------------------------------------------------------------------------
+
+describe('hash validation', () => {
+  it('checkoutCommit rejects non-hex hash', async () => {
+    await expect(checkoutCommit('/tmp', '--hard')).rejects.toThrow('Invalid commit hash');
+  });
+
+  it('checkoutCommit rejects ref name', async () => {
+    await expect(checkoutCommit('/tmp', 'HEAD')).rejects.toThrow('Invalid commit hash');
+  });
+
+  it('checkoutCommit accepts valid 40-char hex format', async () => {
+    await expect(
+      checkoutCommit('/tmp', '1234567890abcdef1234567890abcdef12345678')
+    ).rejects.not.toThrow('Invalid commit hash');
+  });
+
+  it('cherryPick rejects non-hex hash', async () => {
+    await expect(cherryPick('/tmp', '--hard')).rejects.toThrow('Invalid commit hash');
+  });
+
+  it('cherryPick rejects ref name', async () => {
+    await expect(cherryPick('/tmp', 'HEAD')).rejects.toThrow('Invalid commit hash');
+  });
+
+  it('cherryPick accepts valid 40-char hex format', async () => {
+    await expect(
+      cherryPick('/tmp', '1234567890abcdef1234567890abcdef12345678')
+    ).rejects.not.toThrow('Invalid commit hash');
+  });
+
+  it('revertCommit rejects non-hex hash', async () => {
+    await expect(revertCommit('/tmp', '--hard')).rejects.toThrow('Invalid commit hash');
+  });
+
+  it('revertCommit rejects ref name', async () => {
+    await expect(revertCommit('/tmp', 'HEAD')).rejects.toThrow('Invalid commit hash');
+  });
+
+  it('revertCommit accepts valid 40-char hex format', async () => {
+    await expect(
+      revertCommit('/tmp', '1234567890abcdef1234567890abcdef12345678')
+    ).rejects.not.toThrow('Invalid commit hash');
+  });
+
+  it('resetToCommit rejects non-hex hash', async () => {
+    await expect(resetToCommit('/tmp', '--hard', 'soft')).rejects.toThrow('Invalid commit hash');
+  });
+
+  it('resetToCommit rejects ref name', async () => {
+    await expect(resetToCommit('/tmp', 'HEAD', 'soft')).rejects.toThrow('Invalid commit hash');
+  });
+
+  it('resetToCommit accepts valid 40-char hex format', async () => {
+    await expect(
+      resetToCommit('/tmp', '1234567890abcdef1234567890abcdef12345678', 'soft')
+    ).rejects.not.toThrow('Invalid commit hash');
   });
 });

package/server/lib/opencode/env-runtime.js

@@ -51,6 +51,30 @@ export const createOpenCodeEnvRuntime = (deps) => {
     }
   };
 
+  const resolveWindowsExecutablePath = (candidate) => {
+    if (process.platform !== 'win32' || typeof candidate !== 'string' || candidate.trim().length === 0) {
+      return candidate;
+    }
+
+    const trimmed = candidate.trim();
+    const ext = path.extname(trimmed).toLowerCase();
+    if (ext) {
+      return isExecutable(trimmed) ? trimmed : null;
+    }
+
+    const pathExt = process.env.PATHEXT || process.env.PathExt || '.COM;.EXE;.BAT;.CMD';
+    for (const rawExt of pathExt.split(';')) {
+      const normalizedExt = rawExt.trim();
+      if (!normalizedExt) continue;
+      const withExt = `${trimmed}${normalizedExt.startsWith('.') ? normalizedExt : `.${normalizedExt}`}`;
+      if (isExecutable(withExt)) {
+        return withExt;
+      }
+    }
+
+    return isExecutable(trimmed) ? trimmed : null;
+  };
+
   const searchPathFor = (binaryName) => {
     const trimmed = typeof binaryName === 'string' ? binaryName.trim() : '';
     if (!trimmed) {
@@ -59,7 +83,7 @@ export const createOpenCodeEnvRuntime = (deps) => {
 
     const current = process.env.PATH || '';
     const parts = current.split(path.delimiter).filter(Boolean);
-    const candidateNames = [trimmed];
+    const candidateNames = [];
 
     if (process.platform === 'win32' && !path.extname(trimmed)) {
       const pathExt = process.env.PATHEXT || process.env.PathExt || '.COM;.EXE;.BAT;.CMD';
@@ -73,6 +97,8 @@ export const createOpenCodeEnvRuntime = (deps) => {
       }
     }
 
+    candidateNames.push(trimmed);
+
     for (const dir of parts) {
       for (const candidateName of candidateNames) {
         const candidate = path.join(dir, candidateName);
@@ -649,6 +675,9 @@ export const createOpenCodeEnvRuntime = (deps) => {
     if (!trimmed) {
       return null;
     }
+    if (process.platform === 'win32') {
+      return resolveWindowsExecutablePath(trimmed);
+    }
     return isExecutable(trimmed) ? trimmed : null;
   };
 
@@ -669,10 +698,20 @@ export const createOpenCodeEnvRuntime = (deps) => {
       return null;
     }
 
+    const packageShim = path.join(nodeModulesDir, 'opencode-ai', 'bin', 'opencode.exe');
+    if (isExecutable(packageShim)) {
+      return packageShim;
+    }
+
     for (const packageName of getWindowsNativeOpencodePackageNames()) {
-      const candidate = path.join(nodeModulesDir, packageName, 'bin', 'opencode.exe');
-      if (isExecutable(candidate)) {
-        return candidate;
+      const candidates = [
+        path.join(nodeModulesDir, packageName, 'bin', 'opencode.exe'),
+        path.join(nodeModulesDir, 'opencode-ai', 'node_modules', packageName, 'bin', 'opencode.exe'),
+      ];
+      for (const candidate of candidates) {
+        if (isExecutable(candidate)) {
+          return candidate;
+        }
       }
     }
 
@@ -816,6 +855,15 @@ export const createOpenCodeEnvRuntime = (deps) => {
 
       const directBinary = normalizeExecutableCandidate(candidate);
       if (directBinary) {
+        const directExt = path.extname(directBinary).toLowerCase();
+        if (WINDOWS_BATCH_EXTENSIONS.has(directExt)) {
+          return {
+            binary: process.env.ComSpec || 'cmd.exe',
+            args: ['/d', '/s', '/c', 'call', directBinary],
+            wrapperType: 'cmd-wrapper',
+          };
+        }
+
         return {
           binary: directBinary,
           args: [],

package/server/lib/opencode/env-runtime.test.js

@@ -5,6 +5,11 @@ import { afterEach, describe, expect, it } from 'vitest';
 import { createOpenCodeEnvRuntime } from './env-runtime.js';
 
 const originalOpencodeBinary = process.env.OPENCODE_BINARY;
+const originalComSpec = process.env.ComSpec;
+const originalPath = process.env.PATH;
+const originalSystemRoot = process.env.SystemRoot;
+const originalWslBinary = process.env.WSL_BINARY;
+const originalOpenChamberWslBinary = process.env.OPENCHAMBER_WSL_BINARY;
 const originalPlatform = process.platform;
 const tempDirs = [];
 const itIf = (condition) => condition ? it : it.skip;
@@ -32,9 +37,39 @@ afterEach(() => {
 
   if (typeof originalOpencodeBinary === 'string') {
     process.env.OPENCODE_BINARY = originalOpencodeBinary;
-    return;
+  } else {
+    delete process.env.OPENCODE_BINARY;
+  }
+
+  if (typeof originalComSpec === 'string') {
+    process.env.ComSpec = originalComSpec;
+  } else {
+    delete process.env.ComSpec;
+  }
+
+  if (typeof originalPath === 'string') {
+    process.env.PATH = originalPath;
+  } else {
+    delete process.env.PATH;
+  }
+
+  if (typeof originalSystemRoot === 'string') {
+    process.env.SystemRoot = originalSystemRoot;
+  } else {
+    delete process.env.SystemRoot;
+  }
+
+  if (typeof originalWslBinary === 'string') {
+    process.env.WSL_BINARY = originalWslBinary;
+  } else {
+    delete process.env.WSL_BINARY;
+  }
+
+  if (typeof originalOpenChamberWslBinary === 'string') {
+    process.env.OPENCHAMBER_WSL_BINARY = originalOpenChamberWslBinary;
+  } else {
+    delete process.env.OPENCHAMBER_WSL_BINARY;
   }
-  delete process.env.OPENCODE_BINARY;
 });
 
 const createRuntime = (settings) => {
@@ -103,14 +138,55 @@ describe('OpenCode env runtime', () => {
     });
   });
 
-  it('does not classify failed WSL resolution as an invalid configured binary in strict mode', async () => {
+  it('does not classify WSL settings as a native invalid configured binary in strict mode', async () => {
     setPlatform('win32');
+    const dir = createTempDir('openchamber-no-wsl-');
+    process.env.PATH = dir;
+    process.env.SystemRoot = dir;
+    process.env.WSL_BINARY = path.join(dir, 'missing-wsl.exe');
+    process.env.OPENCHAMBER_WSL_BINARY = path.join(dir, 'missing-openchamber-wsl.exe');
     const { runtime } = createRuntime({ opencodeBinary: 'wsl:/usr/local/bin/opencode' });
 
     const rejection = runtime.applyOpencodeBinaryFromSettings({ strict: true });
 
-    await expect(rejection).rejects.toThrow('uses WSL');
-    const error = await rejection.catch((caught) => caught);
-    expect(error.code).toBeUndefined();
+    try {
+      await rejection;
+      expect(runtime.resolveManagedOpenCodeLaunchSpec('opencode').wrapperType).not.toBe('cmd-wrapper');
+    } catch (error) {
+      expect(error.message).toContain('uses WSL');
+      expect(error.code).toBeUndefined();
+    }
+  });
+
+  it('launches Windows cmd shims through cmd call without embedded quotes', () => {
+    setPlatform('win32');
+    process.env.ComSpec = 'C:\\Windows\\System32\\cmd.exe';
+    const dir = createTempDir('openchamber-opencode-cmd-');
+    const shim = path.join(dir, 'opencode.cmd');
+    fs.writeFileSync(shim, '@echo off\r\nexit /b 0\r\n');
+    const { runtime } = createRuntime({});
+
+    expect(runtime.resolveManagedOpenCodeLaunchSpec(shim)).toEqual({
+      binary: 'C:\\Windows\\System32\\cmd.exe',
+      args: ['/d', '/s', '/c', 'call', shim],
+      wrapperType: 'cmd-wrapper',
+    });
+  });
+
+  it('resolves npm OpenCode cmd shims to the packaged Windows executable', () => {
+    setPlatform('win32');
+    const npmDir = createTempDir('openchamber-opencode-npm-');
+    const shim = path.join(npmDir, 'opencode.cmd');
+    const nativeBinary = path.join(npmDir, 'node_modules', 'opencode-ai', 'bin', 'opencode.exe');
+    fs.mkdirSync(path.dirname(nativeBinary), { recursive: true });
+    fs.writeFileSync(nativeBinary, '');
+    fs.writeFileSync(shim, '@ECHO off\r\n"%dp0%\\node_modules\\opencode-ai\\bin\\opencode.exe" %*\r\n');
+    const { runtime } = createRuntime({});
+
+    expect(runtime.resolveManagedOpenCodeLaunchSpec(shim)).toEqual({
+      binary: nativeBinary,
+      args: [],
+      wrapperType: 'native-wrapper',
+    });
   });
 });