From 389b194fbf55b74b0c81553360a5d6fd6516eee3 Mon Sep 17 00:00:00 2001 From: YeonGyu-Kim Date: Wed, 8 Apr 2026 17:19:52 +0900 Subject: [PATCH 1/4] fix(installer): actually upgrade pinned plugin version instead of preserving old entry Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-openagent) Co-authored-by: Sisyphus --- .../add-plugin-to-opencode-config.ts | 8 ++--- .../config-manager/plugin-detection.test.ts | 36 +++++++++++++++---- 2 files changed, 31 insertions(+), 13 deletions(-) diff --git a/src/cli/config-manager/add-plugin-to-opencode-config.ts b/src/cli/config-manager/add-plugin-to-opencode-config.ts index 208abd56a..23c398873 100644 --- a/src/cli/config-manager/add-plugin-to-opencode-config.ts +++ b/src/cli/config-manager/add-plugin-to-opencode-config.ts @@ -79,12 +79,8 @@ export async function addPluginToOpenCodeConfig(currentVersion: string): Promise const normalizedPlugins = [...otherPlugins] - if (canonicalEntries.length > 0) { - normalizedPlugins.push(canonicalEntries[0]) - } else if (legacyEntries.length > 0) { - const versionMatch = legacyEntries[0].match(/@(.+)$/) - const preservedVersion = versionMatch ? versionMatch[1] : null - normalizedPlugins.push(preservedVersion ? `${PLUGIN_NAME}@${preservedVersion}` : pluginEntry) + if (canonicalEntries.length > 0 || legacyEntries.length > 0) { + normalizedPlugins.push(pluginEntry) } else { normalizedPlugins.push(pluginEntry) } diff --git a/src/cli/config-manager/plugin-detection.test.ts b/src/cli/config-manager/plugin-detection.test.ts index e03e63357..fcd6109f9 100644 --- a/src/cli/config-manager/plugin-detection.test.ts +++ b/src/cli/config-manager/plugin-detection.test.ts @@ -1,4 +1,4 @@ -import { afterEach, beforeEach, describe, expect, it } from "bun:test" +import { afterEach, beforeEach, describe, expect, it, spyOn } from "bun:test" import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs" import { tmpdir } from "node:os" import { join } from "node:path" @@ -6,6 +6,7 @@ import { join } from "node:path" import { resetConfigContext } from "./config-context" import { detectCurrentConfig } from "./detect-current-config" import { addPluginToOpenCodeConfig } from "./add-plugin-to-opencode-config" +import * as pluginNameWithVersion from "./plugin-name-with-version" describe("detectCurrentConfig - single package detection", () => { let testConfigDir = "" @@ -109,17 +110,19 @@ describe("addPluginToOpenCodeConfig - single package writes", () => { expect(savedConfig.plugin).toEqual(["oh-my-openagent"]) }) - it("upgrades a version-pinned legacy entry to canonical", async () => { + it("updates a version-pinned legacy entry to the requested version", async () => { // given - writeFileSync(testConfigPath, JSON.stringify({ plugin: ["oh-my-opencode@3.10.0"] }, null, 2) + "\n", "utf-8") + const getPluginNameWithVersionSpy = spyOn(pluginNameWithVersion, "getPluginNameWithVersion").mockResolvedValue("oh-my-openagent@3.16.0") + writeFileSync(testConfigPath, JSON.stringify({ plugin: ["oh-my-opencode@3.15.0"] }, null, 2) + "\n", "utf-8") // when - const result = await addPluginToOpenCodeConfig("3.11.0") + const result = await addPluginToOpenCodeConfig("3.16.0") // then expect(result.success).toBe(true) const savedConfig = JSON.parse(readFileSync(testConfigPath, "utf-8")) - expect(savedConfig.plugin).toEqual(["oh-my-openagent@3.10.0"]) + expect(savedConfig.plugin).toEqual(["oh-my-openagent@3.16.0"]) + getPluginNameWithVersionSpy.mockRestore() }) it("removes stale legacy entry when canonical and legacy entries both exist", async () => { @@ -135,17 +138,36 @@ describe("addPluginToOpenCodeConfig - single package writes", () => { expect(savedConfig.plugin).toEqual(["oh-my-openagent"]) }) - it("preserves a canonical entry when it already exists", async () => { + it("preserves a canonical entry when the same version is re-installed", async () => { // given + const getPluginNameWithVersionSpy = spyOn(pluginNameWithVersion, "getPluginNameWithVersion").mockResolvedValue("oh-my-openagent@3.10.0") writeFileSync(testConfigPath, JSON.stringify({ plugin: ["oh-my-openagent@3.10.0"] }, null, 2) + "\n", "utf-8") // when - const result = await addPluginToOpenCodeConfig("3.11.0") + const result = await addPluginToOpenCodeConfig("3.10.0") // then expect(result.success).toBe(true) const savedConfig = JSON.parse(readFileSync(testConfigPath, "utf-8")) expect(savedConfig.plugin).toEqual(["oh-my-openagent@3.10.0"]) + getPluginNameWithVersionSpy.mockRestore() + }) + + it("blocks a downgrade for a version-pinned canonical entry", async () => { + // given + const getPluginNameWithVersionSpy = spyOn(pluginNameWithVersion, "getPluginNameWithVersion").mockResolvedValue("oh-my-openagent@3.15.0") + writeFileSync(testConfigPath, JSON.stringify({ plugin: ["oh-my-openagent@3.16.0"] }, null, 2) + "\n", "utf-8") + + // when + const result = await addPluginToOpenCodeConfig("3.15.0") + + // then + expect(result.success).toBe(false) + expect(result.error).toContain("Downgrade") + + const savedConfig = JSON.parse(readFileSync(testConfigPath, "utf-8")) + expect(savedConfig.plugin).toEqual(["oh-my-openagent@3.16.0"]) + getPluginNameWithVersionSpy.mockRestore() }) it("rewrites quoted jsonc plugin field in place", async () => { From 6d8d82d7603776d28aff5a2be695f857ad639be9 Mon Sep 17 00:00:00 2001 From: YeonGyu-Kim Date: Wed, 8 Apr 2026 17:20:00 +0900 Subject: [PATCH 2/4] fix(installer): enforce minimum OpenCode version check during install Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-openagent) Co-authored-by: Sisyphus --- src/cli/cli-installer.test.ts | 59 +++++++++++-- src/cli/cli-installer.ts | 7 ++ src/cli/install.test.ts | 4 +- src/cli/minimum-opencode-version.ts | 14 +++ src/cli/tui-installer.test.ts | 129 ++++++++++++++++++++++++++++ src/cli/tui-installer.ts | 8 ++ 6 files changed, 214 insertions(+), 7 deletions(-) create mode 100644 src/cli/minimum-opencode-version.ts create mode 100644 src/cli/tui-installer.test.ts diff --git a/src/cli/cli-installer.test.ts b/src/cli/cli-installer.test.ts index 5d5fd0ca5..934d18322 100644 --- a/src/cli/cli-installer.test.ts +++ b/src/cli/cli-installer.test.ts @@ -21,11 +21,12 @@ describe("runCliInstaller", () => { console.error = originalConsoleError }) - it("completes installation without auth plugin or provider config steps", async () => { - //#given + it("blocks installation when OpenCode is below the minimum version", async () => { + // given const restoreSpies = [ spyOn(configManager, "detectCurrentConfig").mockReturnValue({ isInstalled: false, + installedVersion: null, hasClaude: false, isMax20: false, hasOpenAI: false, @@ -34,9 +35,56 @@ describe("runCliInstaller", () => { hasOpencodeZen: false, hasZaiCodingPlan: false, hasKimiForCoding: false, + hasOpencodeGo: false, }), spyOn(configManager, "isOpenCodeInstalled").mockResolvedValue(true), - spyOn(configManager, "getOpenCodeVersion").mockResolvedValue("1.0.200"), + spyOn(configManager, "getOpenCodeVersion").mockResolvedValue("1.3.9"), + ] + const addPluginSpy = spyOn(configManager, "addPluginToOpenCodeConfig") + + const args: InstallArgs = { + tui: false, + claude: "no", + openai: "no", + gemini: "no", + copilot: "no", + opencodeZen: "no", + zaiCodingPlan: "no", + kimiForCoding: "no", + opencodeGo: "no", + } + + // when + const result = await runCliInstaller(args, "3.16.0") + + // then + expect(result).toBe(1) + expect(addPluginSpy).not.toHaveBeenCalled() + + for (const spy of restoreSpies) { + spy.mockRestore() + } + addPluginSpy.mockRestore() + }) + + it("completes installation without auth plugin or provider config steps", async () => { + // given + const restoreSpies = [ + spyOn(configManager, "detectCurrentConfig").mockReturnValue({ + isInstalled: false, + installedVersion: null, + hasClaude: false, + isMax20: false, + hasOpenAI: false, + hasGemini: false, + hasCopilot: false, + hasOpencodeZen: false, + hasZaiCodingPlan: false, + hasKimiForCoding: false, + hasOpencodeGo: false, + }), + spyOn(configManager, "isOpenCodeInstalled").mockResolvedValue(true), + spyOn(configManager, "getOpenCodeVersion").mockResolvedValue("1.4.0"), spyOn(configManager, "addPluginToOpenCodeConfig").mockResolvedValue({ success: true, configPath: "/tmp/opencode.jsonc", @@ -56,12 +104,13 @@ describe("runCliInstaller", () => { opencodeZen: "no", zaiCodingPlan: "no", kimiForCoding: "no", + opencodeGo: "no", } - //#when + // when const result = await runCliInstaller(args, "3.4.0") - //#then + // then expect(result).toBe(0) for (const spy of restoreSpies) { diff --git a/src/cli/cli-installer.ts b/src/cli/cli-installer.ts index 220ba2879..0808488aa 100644 --- a/src/cli/cli-installer.ts +++ b/src/cli/cli-installer.ts @@ -22,6 +22,7 @@ import { printWarning, validateNonTuiArgs, } from "./install-validators" +import { getUnsupportedOpenCodeVersionMessage } from "./minimum-opencode-version" export async function runCliInstaller(args: InstallArgs, version: string): Promise { const validation = validateNonTuiArgs(args) @@ -57,6 +58,12 @@ export async function runCliInstaller(args: InstallArgs, version: string): Promi printInfo("Visit https://opencode.ai/docs for installation instructions") } else { printSuccess(`OpenCode ${openCodeVersion ?? ""} detected`) + + const unsupportedVersionMessage = getUnsupportedOpenCodeVersionMessage(openCodeVersion) + if (unsupportedVersionMessage) { + printWarning(unsupportedVersionMessage) + return 1 + } } if (isUpdate) { diff --git a/src/cli/install.test.ts b/src/cli/install.test.ts index cf4b7f633..61bcf645f 100644 --- a/src/cli/install.test.ts +++ b/src/cli/install.test.ts @@ -128,7 +128,7 @@ describe("install CLI - binary check behavior", () => { test("non-TUI mode: should still succeed and complete all steps when binary exists", async () => { // given OpenCode binary IS installed isOpenCodeInstalledSpy = spyOn(configManager, "isOpenCodeInstalled").mockResolvedValue(true) - getOpenCodeVersionSpy = spyOn(configManager, "getOpenCodeVersion").mockResolvedValue("1.0.200") + getOpenCodeVersionSpy = spyOn(configManager, "getOpenCodeVersion").mockResolvedValue("1.4.0") // given mock npm fetch globalThis.fetch = mock(() => @@ -157,6 +157,6 @@ describe("install CLI - binary check behavior", () => { // then should have printed success (OK symbol) const allCalls = mockConsoleLog.mock.calls.flat().join("\n") expect(allCalls).toContain("[OK]") - expect(allCalls).toContain("OpenCode 1.0.200") + expect(allCalls).toContain("OpenCode 1.4.0") }) }) diff --git a/src/cli/minimum-opencode-version.ts b/src/cli/minimum-opencode-version.ts new file mode 100644 index 000000000..93804568c --- /dev/null +++ b/src/cli/minimum-opencode-version.ts @@ -0,0 +1,14 @@ +import { MIN_OPENCODE_VERSION } from "./doctor/constants" +import { compareVersions } from "../shared/opencode-version" + +export function getUnsupportedOpenCodeVersionMessage(openCodeVersion: string | null): string | null { + if (!openCodeVersion) { + return null + } + + if (compareVersions(openCodeVersion, MIN_OPENCODE_VERSION) >= 0) { + return null + } + + return `Detected OpenCode ${openCodeVersion}, but ${MIN_OPENCODE_VERSION}+ is required. Update OpenCode, then rerun the installer.` +} diff --git a/src/cli/tui-installer.test.ts b/src/cli/tui-installer.test.ts new file mode 100644 index 000000000..dc5ca718f --- /dev/null +++ b/src/cli/tui-installer.test.ts @@ -0,0 +1,129 @@ +import { afterEach, beforeEach, describe, expect, it, spyOn } from "bun:test" +import * as p from "@clack/prompts" +import * as configManager from "./config-manager" +import * as tuiInstallPrompts from "./tui-install-prompts" +import { runTuiInstaller } from "./tui-installer" + +function createMockSpinner(): ReturnType { + return { + start: () => undefined, + stop: () => undefined, + message: () => undefined, + } +} + +describe("runTuiInstaller", () => { + const originalIsStdinTty = process.stdin.isTTY + const originalIsStdoutTty = process.stdout.isTTY + + beforeEach(() => { + Object.defineProperty(process.stdin, "isTTY", { configurable: true, value: true }) + Object.defineProperty(process.stdout, "isTTY", { configurable: true, value: true }) + }) + + afterEach(() => { + Object.defineProperty(process.stdin, "isTTY", { configurable: true, value: originalIsStdinTty }) + Object.defineProperty(process.stdout, "isTTY", { configurable: true, value: originalIsStdoutTty }) + }) + + it("blocks installation when OpenCode is below the minimum version", async () => { + // given + const restoreSpies = [ + spyOn(p, "spinner").mockReturnValue(createMockSpinner()), + spyOn(p, "intro").mockImplementation(() => undefined), + spyOn(p.log, "warn").mockImplementation(() => undefined), + spyOn(configManager, "detectCurrentConfig").mockReturnValue({ + isInstalled: false, + installedVersion: null, + hasClaude: false, + isMax20: false, + hasOpenAI: false, + hasGemini: false, + hasCopilot: false, + hasOpencodeZen: false, + hasZaiCodingPlan: false, + hasKimiForCoding: false, + hasOpencodeGo: false, + }), + spyOn(configManager, "isOpenCodeInstalled").mockResolvedValue(true), + spyOn(configManager, "getOpenCodeVersion").mockResolvedValue("1.3.9"), + ] + const promptSpy = spyOn(tuiInstallPrompts, "promptInstallConfig") + const addPluginSpy = spyOn(configManager, "addPluginToOpenCodeConfig") + const outroSpy = spyOn(p, "outro").mockImplementation(() => undefined) + + // when + const result = await runTuiInstaller({ tui: true }, "3.16.0") + + // then + expect(result).toBe(1) + expect(promptSpy).not.toHaveBeenCalled() + expect(addPluginSpy).not.toHaveBeenCalled() + expect(outroSpy).toHaveBeenCalled() + + for (const spy of restoreSpies) { + spy.mockRestore() + } + promptSpy.mockRestore() + addPluginSpy.mockRestore() + outroSpy.mockRestore() + }) + + it("proceeds when OpenCode meets the minimum version", async () => { + // given + const restoreSpies = [ + spyOn(p, "spinner").mockReturnValue(createMockSpinner()), + spyOn(p, "intro").mockImplementation(() => undefined), + spyOn(p.log, "info").mockImplementation(() => undefined), + spyOn(p.log, "warn").mockImplementation(() => undefined), + spyOn(p.log, "success").mockImplementation(() => undefined), + spyOn(p.log, "message").mockImplementation(() => undefined), + spyOn(p, "note").mockImplementation(() => undefined), + spyOn(p, "outro").mockImplementation(() => undefined), + spyOn(configManager, "detectCurrentConfig").mockReturnValue({ + isInstalled: false, + installedVersion: null, + hasClaude: false, + isMax20: false, + hasOpenAI: false, + hasGemini: false, + hasCopilot: false, + hasOpencodeZen: false, + hasZaiCodingPlan: false, + hasKimiForCoding: false, + hasOpencodeGo: false, + }), + spyOn(configManager, "isOpenCodeInstalled").mockResolvedValue(true), + spyOn(configManager, "getOpenCodeVersion").mockResolvedValue("1.4.0"), + spyOn(tuiInstallPrompts, "promptInstallConfig").mockResolvedValue({ + hasClaude: false, + isMax20: false, + hasOpenAI: false, + hasGemini: false, + hasCopilot: false, + hasOpencodeZen: false, + hasZaiCodingPlan: false, + hasKimiForCoding: false, + hasOpencodeGo: false, + }), + spyOn(configManager, "addPluginToOpenCodeConfig").mockResolvedValue({ + success: true, + configPath: "/tmp/opencode.jsonc", + }), + spyOn(configManager, "writeOmoConfig").mockReturnValue({ + success: true, + configPath: "/tmp/oh-my-opencode.jsonc", + }), + ] + + // when + const result = await runTuiInstaller({ tui: true }, "3.16.0") + + // then + expect(result).toBe(0) + + for (const spy of restoreSpies) { + spy.mockRestore() + } + }) +}) diff --git a/src/cli/tui-installer.ts b/src/cli/tui-installer.ts index 68f075474..973e387f4 100644 --- a/src/cli/tui-installer.ts +++ b/src/cli/tui-installer.ts @@ -10,6 +10,7 @@ import { writeOmoConfig, } from "./config-manager" import { detectedToInitialValues, formatConfigSummary, SYMBOLS } from "./install-validators" +import { getUnsupportedOpenCodeVersionMessage } from "./minimum-opencode-version" import { promptInstallConfig } from "./tui-install-prompts" export async function runTuiInstaller(args: InstallArgs, version: string): Promise { @@ -39,6 +40,13 @@ export async function runTuiInstaller(args: InstallArgs, version: string): Promi p.note("Visit https://opencode.ai/docs for installation instructions", "Installation Guide") } else { spinner.stop(`OpenCode ${openCodeVersion ?? "installed"} ${color.green("[OK]")}`) + + const unsupportedVersionMessage = getUnsupportedOpenCodeVersionMessage(openCodeVersion) + if (unsupportedVersionMessage) { + p.log.warn(unsupportedVersionMessage) + p.outro(color.red("Installation blocked.")) + return 1 + } } const config = await promptInstallConfig(detected) From 9fb7cfb3f51d80cb31604ee640ce83c3181711bf Mon Sep 17 00:00:00 2001 From: YeonGyu-Kim Date: Wed, 8 Apr 2026 17:30:43 +0900 Subject: [PATCH 3/4] fix(ci): isolate mock.module tests per-file to prevent cross-contamination --- script/run-ci-tests.ts | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/script/run-ci-tests.ts b/script/run-ci-tests.ts index 5466885ce..10cf80b21 100644 --- a/script/run-ci-tests.ts +++ b/script/run-ci-tests.ts @@ -29,13 +29,7 @@ async function usesModuleMock(rootDirectory: string, testFile: string): Promise< } function toIsolatedTarget(testFile: string): string { - const pathSegments = testFile.split("/") - - if (pathSegments.length <= 3) { - return testFile - } - - return pathSegments.slice(0, -1).join("/") + return testFile } function isCoveredByTarget(testFile: string, isolatedTarget: string): boolean { From 5abab08eef58c7e9c88ab4fd7acf646ca337760a Mon Sep 17 00:00:00 2001 From: YeonGyu-Kim Date: Wed, 8 Apr 2026 17:36:23 +0900 Subject: [PATCH 4/4] test(tmux): add missing tmux exports to zombie-pane mock module --- src/features/tmux-subagent/zombie-pane.test.ts | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/src/features/tmux-subagent/zombie-pane.test.ts b/src/features/tmux-subagent/zombie-pane.test.ts index 42fcfb760..267c03cb3 100644 --- a/src/features/tmux-subagent/zombie-pane.test.ts +++ b/src/features/tmux-subagent/zombie-pane.test.ts @@ -40,10 +40,22 @@ mock.module("./action-executor", () => ({ mock.module("../../shared/tmux", () => ({ isInsideTmux: mockIsInsideTmux, getCurrentPaneId: mockGetCurrentPaneId, + isServerRunning: mock(async () => true), + resetServerCheck: mock(() => {}), + markServerRunningInProcess: mock(() => {}), + getPaneDimensions: mock(async () => ({ width: 220, height: 44 })), + spawnTmuxPane: mock(async () => ({ success: true, paneId: "%1" })), + closeTmuxPane: mock(async () => ({ success: true })), + replaceTmuxPane: mock(async () => ({ success: true, paneId: "%1" })), + spawnTmuxWindow: mock(async () => ({ success: true, windowId: "@1" })), + spawnTmuxSession: mock(async () => ({ success: true, sessionId: "mock" })), + applyLayout: mock(async () => ({ success: true })), + enforceMainPaneWidth: mock(async () => ({ success: true })), POLL_INTERVAL_BACKGROUND_MS: 10, SESSION_READY_POLL_INTERVAL_MS: 10, SESSION_READY_TIMEOUT_MS: 50, SESSION_MISSING_GRACE_MS: 1_000, + SESSION_TIMEOUT_MS: 600_000, })) afterAll(() => { mock.restore() })