fix(doctor): align auto-update and doctor config paths

2026-03-17 15:56:02 +09:00
parent 0cf386ec52
commit e9887dd82f
7 changed files with 288 additions and 21 deletions
@@ -1,6 +1,9 @@
 import type { PluginInput } from "@opencode-ai/plugin"
+import { existsSync } from "node:fs"
+import { join } from "node:path"
 import { runBunInstallWithDetails } from "../../../cli/config-manager"
 import { log } from "../../../shared/logger"
+import { getOpenCodeCacheDir, getOpenCodeConfigPaths } from "../../../shared"
 import { invalidatePackage } from "../cache"
 import { PACKAGE_NAME } from "../constants"
 import { extractChannel } from "../version-channel"
@@ -11,9 +14,36 @@ function getPinnedVersionToastMessage(latestVersion: string): string {
  return `Update available: ${latestVersion} (version pinned, update manually)`
 }

-async function runBunInstallSafe(): Promise<boolean> {
+/**
+ * Resolves the active install workspace.
+ * Same logic as doctor check: prefer config-dir if installed, fall back to cache-dir.
+ */
+function resolveActiveInstallWorkspace(): string {
+  const configPaths = getOpenCodeConfigPaths({ binary: "opencode" })
+  const cacheDir = getOpenCodeCacheDir()
+
+  const configInstallPath = join(configPaths.configDir, "node_modules", PACKAGE_NAME, "package.json")
+  const cacheInstallPath = join(cacheDir, "node_modules", PACKAGE_NAME, "package.json")
+
+  // Prefer config-dir if installed there, otherwise fall back to cache-dir
+  if (existsSync(configInstallPath)) {
+    log(`[auto-update-checker] Active workspace: config-dir (${configPaths.configDir})`)
+    return configPaths.configDir
+  }
+
+  if (existsSync(cacheInstallPath)) {
+    log(`[auto-update-checker] Active workspace: cache-dir (${cacheDir})`)
+    return cacheDir
+  }
+
+  // Default to config-dir if neither exists (matches doctor behavior)
+  log(`[auto-update-checker] Active workspace: config-dir (default, no install detected)`)
+  return configPaths.configDir
+}
+
+async function runBunInstallSafe(workspaceDir: string): Promise<boolean> {
  try {
-    const result = await runBunInstallWithDetails({ outputMode: "pipe" })
+    const result = await runBunInstallWithDetails({ outputMode: "pipe", workspaceDir })
    if (!result.success && result.error) {
      log("[auto-update-checker] bun install error:", result.error)
    }
@@ -82,7 +112,8 @@ export async function runBackgroundUpdateCheck(

  invalidatePackage(PACKAGE_NAME)

-  const installSuccess = await runBunInstallSafe()
+  const activeWorkspace = resolveActiveInstallWorkspace()
+  const installSuccess = await runBunInstallSafe(activeWorkspace)

  if (installSuccess) {
    await showAutoUpdatedToast(ctx, currentVersion, latestVersion)
@@ -0,0 +1,223 @@
+import type { PluginInput } from "@opencode-ai/plugin"
+import { afterEach, beforeEach, describe, expect, it, mock } from "bun:test"
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+
+type PluginEntry = {
+  entry: string
+  isPinned: boolean
+  pinnedVersion: string | null
+  configPath: string
+}
+
+type ToastMessageGetter = (isUpdate: boolean, version?: string) => string
+
+function createPluginEntry(overrides?: Partial<PluginEntry>): PluginEntry {
+  return {
+    entry: "oh-my-opencode@3.4.0",
+    isPinned: false,
+    pinnedVersion: null,
+    configPath: "/test/opencode.json",
+    ...overrides,
+  }
+}
+
+const TEST_DIR = join(import.meta.dir, "__test-workspace-resolution__")
+const TEST_CACHE_DIR = join(TEST_DIR, "cache")
+const TEST_CONFIG_DIR = join(TEST_DIR, "config")
+
+const mockFindPluginEntry = mock((_directory: string): PluginEntry | null => createPluginEntry())
+const mockGetCachedVersion = mock((): string | null => "3.4.0")
+const mockGetLatestVersion = mock(async (): Promise<string | null> => "3.5.0")
+const mockExtractChannel = mock(() => "latest")
+const mockInvalidatePackage = mock(() => {})
+const mockShowUpdateAvailableToast = mock(
+  async (_ctx: PluginInput, _latestVersion: string, _getToastMessage: ToastMessageGetter): Promise<void> => {}
+)
+const mockShowAutoUpdatedToast = mock(
+  async (_ctx: PluginInput, _fromVersion: string, _toVersion: string): Promise<void> => {}
+)
+const mockSyncCachePackageJsonToIntent = mock(() => ({ synced: true, error: null }))
+
+const mockRunBunInstallWithDetails = mock(
+  async (opts?: { outputMode?: string; workspaceDir?: string }) => {
+    return { success: true }
+  }
+)
+
+mock.module("../checker", () => ({
+  findPluginEntry: mockFindPluginEntry,
+  getCachedVersion: mockGetCachedVersion,
+  getLatestVersion: mockGetLatestVersion,
+  revertPinnedVersion: mock(() => false),
+  syncCachePackageJsonToIntent: mockSyncCachePackageJsonToIntent,
+}))
+mock.module("../version-channel", () => ({ extractChannel: mockExtractChannel }))
+mock.module("../cache", () => ({ invalidatePackage: mockInvalidatePackage }))
+mock.module("../../../cli/config-manager", () => ({
+  runBunInstallWithDetails: mockRunBunInstallWithDetails,
+}))
+mock.module("./update-toasts", () => ({
+  showUpdateAvailableToast: mockShowUpdateAvailableToast,
+  showAutoUpdatedToast: mockShowAutoUpdatedToast,
+}))
+mock.module("../../../shared/logger", () => ({ log: () => {} }))
+mock.module("../../../shared", () => ({
+  getOpenCodeCacheDir: () => TEST_CACHE_DIR,
+  getOpenCodeConfigPaths: () => ({
+    configDir: TEST_CONFIG_DIR,
+    configJson: join(TEST_CONFIG_DIR, "opencode.json"),
+    configJsonc: join(TEST_CONFIG_DIR, "opencode.jsonc"),
+    packageJson: join(TEST_CONFIG_DIR, "package.json"),
+    omoConfig: join(TEST_CONFIG_DIR, "oh-my-opencode.json"),
+  }),
+  getOpenCodeConfigDir: () => TEST_CONFIG_DIR,
+}))
+
+// Mock constants BEFORE importing the module
+const ORIGINAL_PACKAGE_NAME = "oh-my-opencode"
+mock.module("../constants", () => ({
+  PACKAGE_NAME: ORIGINAL_PACKAGE_NAME,
+  CACHE_DIR: TEST_CACHE_DIR,
+  USER_CONFIG_DIR: TEST_CONFIG_DIR,
+}))
+
+// Need to mock getOpenCodeCacheDir and getOpenCodeConfigPaths before importing the module
+mock.module("../../../shared/data-path", () => ({
+  getDataDir: () => join(TEST_DIR, "data"),
+  getOpenCodeStorageDir: () => join(TEST_DIR, "data", "opencode", "storage"),
+  getCacheDir: () => TEST_DIR,
+  getOmoOpenCodeCacheDir: () => join(TEST_DIR, "oh-my-opencode"),
+  getOpenCodeCacheDir: () => TEST_CACHE_DIR,
+}))
+mock.module("../../../shared/opencode-config-dir", () => ({
+  getOpenCodeConfigDir: () => TEST_CONFIG_DIR,
+  getOpenCodeConfigPaths: () => ({
+    configDir: TEST_CONFIG_DIR,
+    configJson: join(TEST_CONFIG_DIR, "opencode.json"),
+    configJsonc: join(TEST_CONFIG_DIR, "opencode.jsonc"),
+    packageJson: join(TEST_CONFIG_DIR, "package.json"),
+    omoConfig: join(TEST_CONFIG_DIR, "oh-my-opencode.json"),
+  }),
+}))
+
+const modulePath = "./background-update-check?test"
+const { runBackgroundUpdateCheck } = await import(modulePath)
+
+describe("workspace resolution", () => {
+  const mockCtx = { directory: "/test" } as PluginInput
+  const getToastMessage: ToastMessageGetter = (isUpdate, version) =>
+    isUpdate ? `Update to ${version}` : "Up to date"
+
+  beforeEach(() => {
+    // Setup test directories
+    if (existsSync(TEST_DIR)) {
+      rmSync(TEST_DIR, { recursive: true, force: true })
+    }
+    mkdirSync(TEST_DIR, { recursive: true })
+
+    mockFindPluginEntry.mockReset()
+    mockGetCachedVersion.mockReset()
+    mockGetLatestVersion.mockReset()
+    mockExtractChannel.mockReset()
+    mockInvalidatePackage.mockReset()
+    mockRunBunInstallWithDetails.mockReset()
+    mockShowUpdateAvailableToast.mockReset()
+    mockShowAutoUpdatedToast.mockReset()
+
+    mockFindPluginEntry.mockReturnValue(createPluginEntry())
+    mockGetCachedVersion.mockReturnValue("3.4.0")
+    mockGetLatestVersion.mockResolvedValue("3.5.0")
+    mockExtractChannel.mockReturnValue("latest")
+    // Note: Don't use mockResolvedValue here - it overrides the function that captures args
+    mockSyncCachePackageJsonToIntent.mockReturnValue({ synced: true, error: null })
+  })
+
+  afterEach(() => {
+    if (existsSync(TEST_DIR)) {
+      rmSync(TEST_DIR, { recursive: true, force: true })
+    }
+  })
+
+  describe("#given config-dir install exists but cache-dir does not", () => {
+    it("installs to config-dir, not cache-dir", async () => {
+      //#given - config-dir has installation, cache-dir does not
+      mkdirSync(join(TEST_CONFIG_DIR, "node_modules", "oh-my-opencode"), { recursive: true })
+      writeFileSync(
+        join(TEST_CONFIG_DIR, "package.json"),
+        JSON.stringify({ dependencies: { "oh-my-opencode": "3.4.0" } }, null, 2)
+      )
+      writeFileSync(
+        join(TEST_CONFIG_DIR, "node_modules", "oh-my-opencode", "package.json"),
+        JSON.stringify({ name: "oh-my-opencode", version: "3.4.0" }, null, 2)
+      )
+
+      // cache-dir should NOT exist
+      expect(existsSync(TEST_CACHE_DIR)).toBe(false)
+
+      //#when
+      await runBackgroundUpdateCheck(mockCtx, true, getToastMessage)
+
+      //#then - install should be called with config-dir
+      const mockCalls = mockRunBunInstallWithDetails.mock.calls
+      expect(mockCalls[0][0]?.workspaceDir).toBe(TEST_CONFIG_DIR)
+    })
+  })
+
+  describe("#given both config-dir and cache-dir exist", () => {
+    it("prefers config-dir over cache-dir", async () => {
+      //#given - both directories have installations
+      mkdirSync(join(TEST_CONFIG_DIR, "node_modules", "oh-my-opencode"), { recursive: true })
+      writeFileSync(
+        join(TEST_CONFIG_DIR, "package.json"),
+        JSON.stringify({ dependencies: { "oh-my-opencode": "3.4.0" } }, null, 2)
+      )
+      writeFileSync(
+        join(TEST_CONFIG_DIR, "node_modules", "oh-my-opencode", "package.json"),
+        JSON.stringify({ name: "oh-my-opencode", version: "3.4.0" }, null, 2)
+      )
+
+      mkdirSync(join(TEST_CACHE_DIR, "node_modules", "oh-my-opencode"), { recursive: true })
+      writeFileSync(
+        join(TEST_CACHE_DIR, "package.json"),
+        JSON.stringify({ dependencies: { "oh-my-opencode": "3.4.0" } }, null, 2)
+      )
+      writeFileSync(
+        join(TEST_CACHE_DIR, "node_modules", "oh-my-opencode", "package.json"),
+        JSON.stringify({ name: "oh-my-opencode", version: "3.4.0" }, null, 2)
+      )
+
+      //#when
+      await runBackgroundUpdateCheck(mockCtx, true, getToastMessage)
+
+      //#then - install should prefer config-dir
+      const mockCalls2 = mockRunBunInstallWithDetails.mock.calls
+      expect(mockCalls2[0][0]?.workspaceDir).toBe(TEST_CONFIG_DIR)
+    })
+  })
+
+  describe("#given only cache-dir install exists", () => {
+    it("falls back to cache-dir", async () => {
+      //#given - only cache-dir has installation
+      mkdirSync(join(TEST_CACHE_DIR, "node_modules", "oh-my-opencode"), { recursive: true })
+      writeFileSync(
+        join(TEST_CACHE_DIR, "package.json"),
+        JSON.stringify({ dependencies: { "oh-my-opencode": "3.4.0" } }, null, 2)
+      )
+      writeFileSync(
+        join(TEST_CACHE_DIR, "node_modules", "oh-my-opencode", "package.json"),
+        JSON.stringify({ name: "oh-my-opencode", version: "3.4.0" }, null, 2)
+      )
+
+      // config-dir should NOT exist
+      expect(existsSync(TEST_CONFIG_DIR)).toBe(false)
+
+      //#when
+      await runBackgroundUpdateCheck(mockCtx, true, getToastMessage)
+
+      //#then - install should fall back to cache-dir
+      const mockCalls3 = mockRunBunInstallWithDetails.mock.calls
+      expect(mockCalls3[0][0]?.workspaceDir).toBe(TEST_CACHE_DIR)
+    })
+  })
+})