feat(installer): add opencode-desktop compatibility with dynamic config paths (#442)

The installer now dynamically detects and uses the appropriate config
directory based on whether opencode CLI or opencode-desktop (Tauri) is
being used:

- opencode CLI: ~/.config/opencode/ (all platforms)
- opencode-desktop on Linux: ~/.config/ai.opencode.desktop/
- opencode-desktop on macOS: ~/Library/Application Support/ai.opencode.desktop/
- opencode-desktop on Windows: %APPDATA%/ai.opencode.desktop/

Key changes:
- Add new opencode-config-dir.ts module with platform-specific path resolution
- Support dev builds with ai.opencode.desktop.dev identifier
- Backward compatibility: checks legacy ~/.config/opencode/ first
- Refactor config-manager.ts to use dynamic paths via config context
- Update doctor plugin check to use shared path utilities

Fixes #440

Co-authored-by: sisyphus-dev-ai <sisyphus-dev-ai@users.noreply.github.com>

src/shared/index.ts

@@ -16,3 +16,4 @@ export * from "./config-errors"
 export * from "./claude-config-dir"
 export * from "./jsonc-parser"
 export * from "./migration"
+export * from "./opencode-config-dir"

src/shared/opencode-config-dir.test.ts

@@ -0,0 +1,224 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test"
+import { homedir } from "node:os"
+import { join } from "node:path"
+import {
+  getOpenCodeConfigDir,
+  getOpenCodeConfigPaths,
+  isDevBuild,
+  detectExistingConfigDir,
+  TAURI_APP_IDENTIFIER,
+  TAURI_APP_IDENTIFIER_DEV,
+} from "./opencode-config-dir"
+
+describe("opencode-config-dir", () => {
+  let originalPlatform: NodeJS.Platform
+  let originalEnv: Record<string, string | undefined>
+
+  beforeEach(() => {
+    originalPlatform = process.platform
+    originalEnv = {
+      APPDATA: process.env.APPDATA,
+      XDG_CONFIG_HOME: process.env.XDG_CONFIG_HOME,
+      XDG_DATA_HOME: process.env.XDG_DATA_HOME,
+    }
+  })
+
+  afterEach(() => {
+    Object.defineProperty(process, "platform", { value: originalPlatform })
+    for (const [key, value] of Object.entries(originalEnv)) {
+      if (value !== undefined) {
+        process.env[key] = value
+      } else {
+        delete process.env[key]
+      }
+    }
+  })
+
+  describe("isDevBuild", () => {
+    test("returns false for null version", () => {
+      expect(isDevBuild(null)).toBe(false)
+    })
+
+    test("returns false for undefined version", () => {
+      expect(isDevBuild(undefined)).toBe(false)
+    })
+
+    test("returns false for production version", () => {
+      expect(isDevBuild("1.0.200")).toBe(false)
+      expect(isDevBuild("2.1.0")).toBe(false)
+    })
+
+    test("returns true for version containing -dev", () => {
+      expect(isDevBuild("1.0.0-dev")).toBe(true)
+      expect(isDevBuild("1.0.0-dev.123")).toBe(true)
+    })
+
+    test("returns true for version containing .dev", () => {
+      expect(isDevBuild("1.0.0.dev")).toBe(true)
+      expect(isDevBuild("1.0.0.dev.456")).toBe(true)
+    })
+  })
+
+  describe("getOpenCodeConfigDir", () => {
+    describe("for opencode CLI binary", () => {
+      test("returns ~/.config/opencode on Linux", () => {
+        // #given opencode CLI binary detected, platform is Linux
+        Object.defineProperty(process, "platform", { value: "linux" })
+        delete process.env.XDG_CONFIG_HOME
+
+        // #when getOpenCodeConfigDir is called with binary="opencode"
+        const result = getOpenCodeConfigDir({ binary: "opencode", version: "1.0.200" })
+
+        // #then returns ~/.config/opencode
+        expect(result).toBe(join(homedir(), ".config", "opencode"))
+      })
+
+      test("returns $XDG_CONFIG_HOME/opencode on Linux when XDG_CONFIG_HOME is set", () => {
+        // #given opencode CLI binary detected, platform is Linux with XDG_CONFIG_HOME set
+        Object.defineProperty(process, "platform", { value: "linux" })
+        process.env.XDG_CONFIG_HOME = "/custom/config"
+
+        // #when getOpenCodeConfigDir is called with binary="opencode"
+        const result = getOpenCodeConfigDir({ binary: "opencode", version: "1.0.200" })
+
+        // #then returns $XDG_CONFIG_HOME/opencode
+        expect(result).toBe("/custom/config/opencode")
+      })
+
+      test("returns ~/.config/opencode on macOS", () => {
+        // #given opencode CLI binary detected, platform is macOS
+        Object.defineProperty(process, "platform", { value: "darwin" })
+        delete process.env.XDG_CONFIG_HOME
+
+        // #when getOpenCodeConfigDir is called with binary="opencode"
+        const result = getOpenCodeConfigDir({ binary: "opencode", version: "1.0.200" })
+
+        // #then returns ~/.config/opencode
+        expect(result).toBe(join(homedir(), ".config", "opencode"))
+      })
+
+      test("returns ~/.config/opencode on Windows by default", () => {
+        // #given opencode CLI binary detected, platform is Windows
+        Object.defineProperty(process, "platform", { value: "win32" })
+        delete process.env.APPDATA
+
+        // #when getOpenCodeConfigDir is called with binary="opencode"
+        const result = getOpenCodeConfigDir({ binary: "opencode", version: "1.0.200", checkExisting: false })
+
+        // #then returns ~/.config/opencode (cross-platform default)
+        expect(result).toBe(join(homedir(), ".config", "opencode"))
+      })
+    })
+
+    describe("for opencode-desktop Tauri binary", () => {
+      test("returns ~/.config/ai.opencode.desktop on Linux", () => {
+        // #given opencode-desktop binary detected, platform is Linux
+        Object.defineProperty(process, "platform", { value: "linux" })
+        delete process.env.XDG_CONFIG_HOME
+
+        // #when getOpenCodeConfigDir is called with binary="opencode-desktop"
+        const result = getOpenCodeConfigDir({ binary: "opencode-desktop", version: "1.0.200", checkExisting: false })
+
+        // #then returns ~/.config/ai.opencode.desktop
+        expect(result).toBe(join(homedir(), ".config", TAURI_APP_IDENTIFIER))
+      })
+
+      test("returns ~/Library/Application Support/ai.opencode.desktop on macOS", () => {
+        // #given opencode-desktop binary detected, platform is macOS
+        Object.defineProperty(process, "platform", { value: "darwin" })
+
+        // #when getOpenCodeConfigDir is called with binary="opencode-desktop"
+        const result = getOpenCodeConfigDir({ binary: "opencode-desktop", version: "1.0.200", checkExisting: false })
+
+        // #then returns ~/Library/Application Support/ai.opencode.desktop
+        expect(result).toBe(join(homedir(), "Library", "Application Support", TAURI_APP_IDENTIFIER))
+      })
+
+      test("returns %APPDATA%/ai.opencode.desktop on Windows", () => {
+        // #given opencode-desktop binary detected, platform is Windows
+        Object.defineProperty(process, "platform", { value: "win32" })
+        process.env.APPDATA = "C:\\Users\\TestUser\\AppData\\Roaming"
+
+        // #when getOpenCodeConfigDir is called with binary="opencode-desktop"
+        const result = getOpenCodeConfigDir({ binary: "opencode-desktop", version: "1.0.200", checkExisting: false })
+
+        // #then returns %APPDATA%/ai.opencode.desktop
+        expect(result).toBe(join("C:\\Users\\TestUser\\AppData\\Roaming", TAURI_APP_IDENTIFIER))
+      })
+    })
+
+    describe("dev build detection", () => {
+      test("returns ai.opencode.desktop.dev path when dev version detected", () => {
+        // #given opencode-desktop dev version
+        Object.defineProperty(process, "platform", { value: "linux" })
+        delete process.env.XDG_CONFIG_HOME
+
+        // #when getOpenCodeConfigDir is called with dev version
+        const result = getOpenCodeConfigDir({ binary: "opencode-desktop", version: "1.0.0-dev.123", checkExisting: false })
+
+        // #then returns path with ai.opencode.desktop.dev
+        expect(result).toBe(join(homedir(), ".config", TAURI_APP_IDENTIFIER_DEV))
+      })
+
+      test("returns ai.opencode.desktop.dev on macOS for dev build", () => {
+        // #given opencode-desktop dev version on macOS
+        Object.defineProperty(process, "platform", { value: "darwin" })
+
+        // #when getOpenCodeConfigDir is called with dev version
+        const result = getOpenCodeConfigDir({ binary: "opencode-desktop", version: "1.0.0-dev", checkExisting: false })
+
+        // #then returns path with ai.opencode.desktop.dev
+        expect(result).toBe(join(homedir(), "Library", "Application Support", TAURI_APP_IDENTIFIER_DEV))
+      })
+    })
+  })
+
+  describe("getOpenCodeConfigPaths", () => {
+    test("returns all config paths for CLI binary", () => {
+      // #given opencode CLI binary on Linux
+      Object.defineProperty(process, "platform", { value: "linux" })
+      delete process.env.XDG_CONFIG_HOME
+
+      // #when getOpenCodeConfigPaths is called
+      const paths = getOpenCodeConfigPaths({ binary: "opencode", version: "1.0.200" })
+
+      // #then returns all expected paths
+      const expectedDir = join(homedir(), ".config", "opencode")
+      expect(paths.configDir).toBe(expectedDir)
+      expect(paths.configJson).toBe(join(expectedDir, "opencode.json"))
+      expect(paths.configJsonc).toBe(join(expectedDir, "opencode.jsonc"))
+      expect(paths.packageJson).toBe(join(expectedDir, "package.json"))
+      expect(paths.omoConfig).toBe(join(expectedDir, "oh-my-opencode.json"))
+    })
+
+    test("returns all config paths for desktop binary", () => {
+      // #given opencode-desktop binary on macOS
+      Object.defineProperty(process, "platform", { value: "darwin" })
+
+      // #when getOpenCodeConfigPaths is called
+      const paths = getOpenCodeConfigPaths({ binary: "opencode-desktop", version: "1.0.200", checkExisting: false })
+
+      // #then returns all expected paths
+      const expectedDir = join(homedir(), "Library", "Application Support", TAURI_APP_IDENTIFIER)
+      expect(paths.configDir).toBe(expectedDir)
+      expect(paths.configJson).toBe(join(expectedDir, "opencode.json"))
+      expect(paths.configJsonc).toBe(join(expectedDir, "opencode.jsonc"))
+      expect(paths.packageJson).toBe(join(expectedDir, "package.json"))
+      expect(paths.omoConfig).toBe(join(expectedDir, "oh-my-opencode.json"))
+    })
+  })
+
+  describe("detectExistingConfigDir", () => {
+    test("returns null when no config exists", () => {
+      // #given no config files exist
+      Object.defineProperty(process, "platform", { value: "linux" })
+      delete process.env.XDG_CONFIG_HOME
+
+      // #when detectExistingConfigDir is called
+      const result = detectExistingConfigDir("opencode", "1.0.200")
+
+      // #then result is either null or a valid string path
+      expect(result === null || typeof result === "string").toBe(true)
+    })
+  })
+})

src/shared/opencode-config-dir.ts

@@ -0,0 +1,132 @@
+import { existsSync } from "node:fs"
+import { homedir } from "node:os"
+import { join } from "node:path"
+
+export type OpenCodeBinaryType = "opencode" | "opencode-desktop"
+
+export interface OpenCodeConfigDirOptions {
+  binary: OpenCodeBinaryType
+  version?: string | null
+  checkExisting?: boolean
+}
+
+export interface OpenCodeConfigPaths {
+  configDir: string
+  configJson: string
+  configJsonc: string
+  packageJson: string
+  omoConfig: string
+}
+
+export const TAURI_APP_IDENTIFIER = "ai.opencode.desktop"
+export const TAURI_APP_IDENTIFIER_DEV = "ai.opencode.desktop.dev"
+
+export function isDevBuild(version: string | null | undefined): boolean {
+  if (!version) return false
+  return version.includes("-dev") || version.includes(".dev")
+}
+
+function getTauriConfigDir(identifier: string): string {
+  const platform = process.platform
+
+  switch (platform) {
+    case "darwin":
+      return join(homedir(), "Library", "Application Support", identifier)
+
+    case "win32": {
+      const appData = process.env.APPDATA || join(homedir(), "AppData", "Roaming")
+      return join(appData, identifier)
+    }
+
+    case "linux":
+    default: {
+      const xdgConfig = process.env.XDG_CONFIG_HOME || join(homedir(), ".config")
+      return join(xdgConfig, identifier)
+    }
+  }
+}
+
+function getCliConfigDir(): string {
+  if (process.platform === "win32") {
+    const crossPlatformDir = join(homedir(), ".config", "opencode")
+    const crossPlatformConfig = join(crossPlatformDir, "opencode.json")
+
+    if (existsSync(crossPlatformConfig)) {
+      return crossPlatformDir
+    }
+
+    const appData = process.env.APPDATA || join(homedir(), "AppData", "Roaming")
+    const appdataDir = join(appData, "opencode")
+    const appdataConfig = join(appdataDir, "opencode.json")
+
+    if (existsSync(appdataConfig)) {
+      return appdataDir
+    }
+
+    return crossPlatformDir
+  }
+
+  const xdgConfig = process.env.XDG_CONFIG_HOME || join(homedir(), ".config")
+  return join(xdgConfig, "opencode")
+}
+
+export function getOpenCodeConfigDir(options: OpenCodeConfigDirOptions): string {
+  const { binary, version, checkExisting = true } = options
+
+  if (binary === "opencode") {
+    return getCliConfigDir()
+  }
+
+  const identifier = isDevBuild(version) ? TAURI_APP_IDENTIFIER_DEV : TAURI_APP_IDENTIFIER
+  const tauriDir = getTauriConfigDir(identifier)
+
+  if (checkExisting) {
+    const legacyDir = getCliConfigDir()
+    const legacyConfig = join(legacyDir, "opencode.json")
+    const legacyConfigC = join(legacyDir, "opencode.jsonc")
+
+    if (existsSync(legacyConfig) || existsSync(legacyConfigC)) {
+      return legacyDir
+    }
+  }
+
+  return tauriDir
+}
+
+export function getOpenCodeConfigPaths(options: OpenCodeConfigDirOptions): OpenCodeConfigPaths {
+  const configDir = getOpenCodeConfigDir(options)
+
+  return {
+    configDir,
+    configJson: join(configDir, "opencode.json"),
+    configJsonc: join(configDir, "opencode.jsonc"),
+    packageJson: join(configDir, "package.json"),
+    omoConfig: join(configDir, "oh-my-opencode.json"),
+  }
+}
+
+export function detectExistingConfigDir(binary: OpenCodeBinaryType, version?: string | null): string | null {
+  const locations: string[] = []
+
+  if (binary === "opencode-desktop") {
+    const identifier = isDevBuild(version) ? TAURI_APP_IDENTIFIER_DEV : TAURI_APP_IDENTIFIER
+    locations.push(getTauriConfigDir(identifier))
+
+    if (isDevBuild(version)) {
+      locations.push(getTauriConfigDir(TAURI_APP_IDENTIFIER))
+    }
+  }
+
+  locations.push(getCliConfigDir())
+
+  for (const dir of locations) {
+    const configJson = join(dir, "opencode.json")
+    const configJsonc = join(dir, "opencode.jsonc")
+
+    if (existsSync(configJson) || existsSync(configJsonc)) {
+      return dir
+    }
+  }
+
+  return null
+}