oh-my-openagent 4.6.0 → 4.7.0

package/bin/version-mismatch.js

@@ -0,0 +1,47 @@
+// bin/version-mismatch.js
+// Detects platform binary version mismatch against the main package.
+// Background: issue #3918 - `oh-my-opencode-windows-x64@3.9.0` could stay installed
+// alongside `oh-my-opencode@4.0.0`, leaving the startup banner pinned to 3.9.0.
+
+/**
+ * Strips an optional leading "v" so callers can pass either "4.5.1" or "v4.5.1".
+ * Pre-release suffixes (e.g. "-beta.1") are preserved because the release
+ * workflow publishes prereleases as standalone versions on the `next` dist-tag,
+ * and `oh-my-opencode@4.5.1-beta.1` paired with `oh-my-opencode-x64@4.5.1`
+ * IS a real mismatch the wrapper would silently honour.
+ *
+ * @param {string} version
+ * @returns {string} Full version with leading "v" stripped.
+ */
+function normalizeVersion(version) {
+  return version.replace(/^v/, "");
+}
+
+/**
+ * Detect a main / platform-binary version mismatch.
+ *
+ * Both versions must be known to report a mismatch; if either is null/undefined,
+ * the check is skipped (returns null) rather than producing a false alarm.
+ *
+ * Comparison is exact on the full semver string (after stripping a leading "v"),
+ * including any pre-release suffix. This means `4.5.1-beta.1` and `4.5.1` are
+ * treated as DIFFERENT versions, matching the publish workflow that ships
+ * prerelease builds to the `next` dist-tag alongside stable releases.
+ *
+ * @param {object} input
+ * @param {string | null | undefined} input.mainVersion
+ * @param {string | null | undefined} input.platformVersion
+ * @param {string} input.platformPackage
+ * @returns {{ mainVersion: string, platformVersion: string, platformPackage: string } | null}
+ */
+export function detectPlatformBinaryMismatch({ mainVersion, platformVersion, platformPackage }) {
+  if (!mainVersion || !platformVersion) {
+    return null;
+  }
+
+  if (normalizeVersion(mainVersion) === normalizeVersion(platformVersion)) {
+    return null;
+  }
+
+  return { mainVersion, platformVersion, platformPackage };
+}

package/bin/version-mismatch.test.ts

@@ -0,0 +1,120 @@
+// bin/version-mismatch.test.ts
+import { describe, expect, test } from "bun:test";
+import { detectPlatformBinaryMismatch } from "./version-mismatch.js";
+
+describe("detectPlatformBinaryMismatch", () => {
+  test("returns null when main and platform versions match", () => {
+    // #given identical main and platform binary versions
+    const input = { mainVersion: "4.5.1", platformVersion: "4.5.1", platformPackage: "oh-my-opencode-windows-x64" };
+
+    // #when detecting mismatch
+    const result = detectPlatformBinaryMismatch(input);
+
+    // #then no mismatch is reported
+    expect(result).toBeNull();
+  });
+
+  test("reports mismatch when platform version is older than main", () => {
+    // #given main package newer than installed platform binary (issue #3918 case)
+    const input = { mainVersion: "4.5.1", platformVersion: "3.9.0", platformPackage: "oh-my-opencode-windows-x64" };
+
+    // #when detecting mismatch
+    const result = detectPlatformBinaryMismatch(input);
+
+    // #then mismatch object is returned with both versions
+    expect(result).toEqual({
+      mainVersion: "4.5.1",
+      platformVersion: "3.9.0",
+      platformPackage: "oh-my-opencode-windows-x64",
+    });
+  });
+
+  test("reports mismatch when platform version is newer than main", () => {
+    // #given platform binary newer than main wrapper
+    const input = { mainVersion: "4.0.0", platformVersion: "4.5.1", platformPackage: "oh-my-opencode-linux-x64" };
+
+    // #when detecting mismatch
+    const result = detectPlatformBinaryMismatch(input);
+
+    // #then mismatch is still reported (any difference is a mismatch)
+    expect(result).not.toBeNull();
+    expect(result?.platformVersion).toBe("4.5.1");
+  });
+
+  test("returns null when main version is unknown", () => {
+    // #given main version could not be read
+    const input = { mainVersion: null, platformVersion: "4.5.1", platformPackage: "oh-my-opencode-windows-x64" };
+
+    // #when detecting mismatch
+    const result = detectPlatformBinaryMismatch(input);
+
+    // #then no mismatch is reported - cannot compare without main version
+    expect(result).toBeNull();
+  });
+
+  test("returns null when platform version is unknown", () => {
+    // #given platform package.json could not be read
+    const input = { mainVersion: "4.5.1", platformVersion: null, platformPackage: "oh-my-opencode-windows-x64" };
+
+    // #when detecting mismatch
+    const result = detectPlatformBinaryMismatch(input);
+
+    // #then no mismatch is reported - silently skip rather than alarm
+    expect(result).toBeNull();
+  });
+
+  test("reports mismatch when main is a prerelease and platform is the matching stable", () => {
+    // #given prerelease main against stable platform binary - the publish workflow
+    // ships prereleases under the `next` dist-tag, so this combo is a real
+    // mismatch the wrapper would silently honour
+    const input = { mainVersion: "4.5.1-beta.1", platformVersion: "4.5.1", platformPackage: "oh-my-opencode-darwin-arm64" };
+
+    // #when detecting mismatch
+    const result = detectPlatformBinaryMismatch(input);
+
+    // #then mismatch is reported with the full prerelease string preserved
+    expect(result).toEqual({
+      mainVersion: "4.5.1-beta.1",
+      platformVersion: "4.5.1",
+      platformPackage: "oh-my-opencode-darwin-arm64",
+    });
+  });
+
+  test("reports mismatch between two different prerelease iterations", () => {
+    // #given two different prerelease iterations - publish.yml allows multiple
+    // beta builds on the `next` dist-tag, so beta.1 vs beta.2 IS a mismatch
+    const input = { mainVersion: "4.5.1-beta.2", platformVersion: "4.5.1-beta.1", platformPackage: "oh-my-opencode-linux-x64" };
+
+    // #when detecting mismatch
+    const result = detectPlatformBinaryMismatch(input);
+
+    // #then mismatch is reported with both prerelease tags preserved
+    expect(result).toEqual({
+      mainVersion: "4.5.1-beta.2",
+      platformVersion: "4.5.1-beta.1",
+      platformPackage: "oh-my-opencode-linux-x64",
+    });
+  });
+
+  test("returns null when both versions are the exact same prerelease", () => {
+    // #given matched prereleases on both sides
+    const input = { mainVersion: "4.5.1-beta.1", platformVersion: "4.5.1-beta.1", platformPackage: "oh-my-opencode-windows-x64" };
+
+    // #when detecting mismatch
+    const result = detectPlatformBinaryMismatch(input);
+
+    // #then no mismatch is reported
+    expect(result).toBeNull();
+  });
+
+  test("normalizes leading 'v' so 'v4.5.1' matches '4.5.1'", () => {
+    // #given the same version with and without a leading "v"
+    const input = { mainVersion: "v4.5.1", platformVersion: "4.5.1", platformPackage: "oh-my-opencode-windows-x64" };
+
+    // #when detecting mismatch
+    const result = detectPlatformBinaryMismatch(input);
+
+    // #then leading "v" is treated as cosmetic, no mismatch reported
+    expect(result).toBeNull();
+  });
+});

package/dist/cli/codex-ulw-loop.d.ts

@@ -0,0 +1,12 @@
+export type CodexUlwLoopCommand = {
+    readonly executable: string;
+    readonly argsPrefix: readonly string[];
+};
+type ResolveCodexUlwLoopCommandInput = {
+    readonly env?: NodeJS.ProcessEnv;
+    readonly homeDir?: string;
+    readonly currentExecutablePaths?: readonly string[];
+};
+export declare function resolveCodexUlwLoopCommand(input?: ResolveCodexUlwLoopCommandInput): CodexUlwLoopCommand | null;
+export declare function codexUlwLoop(args: readonly string[]): Promise<number>;
+export {};

package/dist/cli/doctor/checks/tui-plugin-config.d.ts

@@ -2,11 +2,13 @@ import type { CheckResult } from "../types";
 interface ServerPluginInfo {
     registered: boolean;
     configPath: string | null;
+    packageExportsTui: boolean | null;
 }
 interface TuiPluginInfo {
     registered: boolean;
     configPath: string | null;
     exists: boolean;
+    hasNamedTuiEntry: boolean;
 }
 export declare function detectServerPluginRegistration(): ServerPluginInfo;
 export declare function detectTuiPluginRegistration(): TuiPluginInfo;