Add Windows Electron desktop support (#1093)

* fix: make upstream sync actions target the selected remote Ensure fetch and pull actually honor upstream selection so fork maintenance works from the Git sidebar, and surface upstream branch status alongside the primary origin-tracking indicators. * feat: add Windows Electron desktop foundation * fix(electron): stabilize Windows desktop packaging * fix(electron): stabilize Windows desktop chrome Use native Windows titlebar behavior with an Alt-accessible hidden menu, and harden Windows dev command launching so the desktop app follows platform conventions. * fix(electron): stabilize Windows dev startup * fix(electron): clarify desktop artifact names * fix(electron): harden Windows desktop release and launch * fix(electron): address Windows release review * fix(electron): point updater and release links to org repo * Fix Windows settings persistence fallback * Fix Windows Electron dev startup * Add Windows Electron window controls * Fix Windows Electron install and opencode launch * fix: resolve git status for repositories without upstream Fixes repository detection stuck on Checking repository Handles git status when no upstream is configured Adds regression coverage for git status loading * Add Windows app menu button * fix: preserve file editor line endings * ci: add desktop release smoke workflow --------- Co-authored-by: Bohdan Triapitsyn <artmore@protonmail.com>
2026-05-26 18:13:59 +03:00
parent cc7969ac00
commit becd240168
59 changed files with 2260 additions and 246 deletions
@@ -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: [],
@@ -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',
+    });
  });
 });
@@ -438,6 +438,44 @@ export const createSettingsRuntime = (deps) => {
    }
  };

+  const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+  const isTransientWindowsReplaceError = (error) => {
+    if (process.platform !== 'win32' || !error || typeof error !== 'object') {
+      return false;
+    }
+    return error.code === 'EPERM' || error.code === 'EACCES' || error.code === 'EBUSY';
+  };
+
+  const replaceFile = async (tmp, target) => {
+    const maxAttempts = process.platform === 'win32' ? 6 : 1;
+    let lastError = null;
+
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+      try {
+        await fsPromises.rename(tmp, target);
+        return;
+      } catch (error) {
+        lastError = error;
+        if (!isTransientWindowsReplaceError(error) || attempt === maxAttempts) {
+          break;
+        }
+        await sleep(25 * attempt);
+      }
+    }
+
+    if (!isTransientWindowsReplaceError(lastError)) {
+      throw lastError;
+    }
+
+    // Windows can transiently reject atomic replacement when another process
+    // briefly opens the target file. Preserve atomic rename everywhere it works,
+    // but fall back to a direct replacement so settings persistence does not
+    // get permanently wedged on Windows desktop installs.
+    await fsPromises.copyFile(tmp, target);
+    await fsPromises.rm(tmp, { force: true });
+  };
+
  const writeSettingsToDisk = async (settings) => {
    try {
      await fsPromises.mkdir(path.dirname(SETTINGS_FILE_PATH), { recursive: true });
@@ -447,7 +485,7 @@ export const createSettingsRuntime = (deps) => {
      // read-modify-write wipe the settings file.
      const tmp = `${SETTINGS_FILE_PATH}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
      await fsPromises.writeFile(tmp, JSON.stringify(settings, null, 2), 'utf8');
-      await fsPromises.rename(tmp, SETTINGS_FILE_PATH);
+      await replaceFile(tmp, SETTINGS_FILE_PATH);
    } catch (error) {
      console.warn('Failed to write settings file:', error);
      throw error;
@@ -82,4 +82,43 @@ describe('settings runtime', () => {
      await cleanup();
    }
  });
+
+  it.skipIf(process.platform !== 'win32')('falls back when Windows blocks atomic settings replacement', async () => {
+    const tempRoot = await fsPromises.mkdtemp(path.join(os.tmpdir(), 'oc-settings-runtime-'));
+    const settingsFilePath = path.join(tempRoot, 'settings.json');
+    const wrappedFs = {
+      ...fsPromises,
+      rename: async () => {
+        const error = new Error('operation not permitted');
+        error.code = 'EPERM';
+        throw error;
+      },
+    };
+    const runtime = createSettingsRuntime({
+      fsPromises: wrappedFs,
+      path,
+      crypto,
+      SETTINGS_FILE_PATH: settingsFilePath,
+      sanitizeProjects: (projects) => Array.isArray(projects) ? projects : [],
+      sanitizeSettingsUpdate: (settings) => settings,
+      mergePersistedSettings: (_current, changes) => changes,
+      normalizeSettingsPaths: (settings) => ({ settings, changed: false }),
+      normalizeStringArray: (values) => Array.isArray(values) ? values.filter((value) => typeof value === 'string') : [],
+      formatSettingsResponse: (settings) => settings,
+      resolveDirectoryCandidate: (value) => value,
+      normalizeManagedRemoteTunnelHostname: (value) => value,
+      normalizeManagedRemoteTunnelPresets: (value) => value,
+      normalizeManagedRemoteTunnelPresetTokens: (value) => value,
+      syncManagedRemoteTunnelConfigWithPresets: async () => {},
+      upsertManagedRemoteTunnelToken: async () => {},
+    });
+
+    try {
+      await runtime.writeSettingsToDisk({ theme: 'dark' });
+
+      await expect(fsPromises.readFile(settingsFilePath, 'utf8')).resolves.toBe(JSON.stringify({ theme: 'dark' }, null, 2));
+    } finally {
+      await fsPromises.rm(tempRoot, { recursive: true, force: true });
+    }
+  });
 });