evil-omo 3.11.3 → 3.11.5

package/bin/{oh-my-opencode.js → evil-omo.js}

@@ -1,13 +1,19 @@
 #!/usr/bin/env node
-// bin/oh-my-opencode.js
+// bin/evil-omo.js
 // Wrapper script that detects platform and spawns the correct binary
 
 import { spawnSync } from "node:child_process";
-import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
 import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
 import { getPlatformPackageCandidates, getBinaryPath } from "./platform.js";
 
 const require = createRequire(import.meta.url);
+const PLUGIN_NAME = "evil-omo";
+const FORCE_BASELINE_ENV = "EVIL_OMO_FORCE_BASELINE";
+const LEGACY_FORCE_BASELINE_ENV = "OH_MY_OPENCODE_FORCE_BASELINE";
+const BUNDLED_CLI_ENTRYPOINT = fileURLToPath(new URL("../dist/cli/index.js", import.meta.url));
 
 /**
  * Detect libc family on Linux
@@ -32,7 +38,7 @@ function supportsAvx2() {
     return null;
   }
 
-  if (process.env.OH_MY_OPENCODE_FORCE_BASELINE === "1") {
+  if (process.env[FORCE_BASELINE_ENV] === "1" || process.env[LEGACY_FORCE_BASELINE_ENV] === "1") {
     return false;
   }
 
@@ -71,7 +77,59 @@ function getSignalExitCode(signal) {
   return 128 + (signalCodeByName[signal] ?? 1);
 }
 
+export function shouldUseBundledCli(versions = process.versions) {
+  return Boolean(versions?.bun);
+}
+
+export function getBundledCliEntrypoint() {
+  return BUNDLED_CLI_ENTRYPOINT;
+}
+
+export function resolveBundledCliRuntime(
+  versions = process.versions,
+  execPath = process.execPath,
+  spawnImpl = spawnSync,
+) {
+  if (shouldUseBundledCli(versions)) {
+    return execPath;
+  }
+
+  const probe = spawnImpl("bun", ["--version"], {
+    encoding: "utf8",
+    stdio: "pipe",
+  });
+
+  if (probe.error || probe.status !== 0) {
+    return null;
+  }
+
+  return "bun";
+}
+
+export function runBundledCli(args, spawnImpl = spawnSync, runtime = process.execPath) {
+  return spawnImpl(runtime, [getBundledCliEntrypoint(), ...args], {
+    stdio: "inherit",
+  });
+}
+
+function isDirectExecution() {
+  return Boolean(process.argv[1]) && resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+}
+
 function main() {
+  const bundledCliRuntime = resolveBundledCliRuntime();
+  if (bundledCliRuntime && existsSync(getBundledCliEntrypoint())) {
+    const result = runBundledCli(process.argv.slice(2), spawnSync, bundledCliRuntime);
+
+    if (!result.error) {
+      if (result.signal) {
+        process.exit(getSignalExitCode(result.signal));
+      }
+
+      process.exit(result.status ?? 1);
+    }
+  }
+
   const { platform, arch } = process;
   const libcFamily = getLibcFamily();
   const avx2Supported = supportsAvx2();
@@ -85,7 +143,7 @@ function main() {
       preferBaseline: avx2Supported === false,
     });
   } catch (error) {
-    console.error(`\noh-my-opencode: ${error.message}\n`);
+    console.error(`\n${PLUGIN_NAME}: ${error.message}\n`);
     process.exit(1);
   }
 
@@ -100,7 +158,7 @@ function main() {
     .filter((entry) => entry !== null);
 
   if (resolvedBinaries.length === 0) {
-    console.error(`\noh-my-opencode: Platform binary not installed.`);
+    console.error(`\n${PLUGIN_NAME}: Platform binary not installed.`);
     console.error(`\nYour platform: ${platform}-${arch}${libcFamily === "musl" ? "-musl" : ""}`);
     console.error(`Expected packages (in order): ${packageCandidates.join(", ")}`);
     console.error(`\nTo fix, run:`);
@@ -120,7 +178,7 @@ function main() {
         continue;
       }
 
-      console.error(`\noh-my-opencode: Failed to execute binary.`);
+      console.error(`\n${PLUGIN_NAME}: Failed to execute binary.`);
       console.error(`Error: ${result.error.message}\n`);
       process.exit(2);
     }
@@ -139,4 +197,6 @@ function main() {
   process.exit(1);
 }
 
-main();
+if (isDirectExecution()) {
+  main();
+}

package/bin/evil-omo.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, test } from "bun:test"
+import {
+  getBundledCliEntrypoint,
+  resolveBundledCliRuntime,
+  runBundledCli,
+  shouldUseBundledCli,
+} from "./evil-omo.js"
+
+describe("shouldUseBundledCli", () => {
+  test("returns true when running under Bun", () => {
+    expect(shouldUseBundledCli({ bun: "1.3.10" })).toBe(true)
+  })
+
+  test("returns false when Bun runtime is unavailable", () => {
+    expect(shouldUseBundledCli({})).toBe(false)
+  })
+})
+
+describe("getBundledCliEntrypoint", () => {
+  test("returns the packaged CLI entrypoint path", () => {
+    expect(getBundledCliEntrypoint().replaceAll("\\", "/")).toEndWith("/dist/cli/index.js")
+  })
+})
+
+describe("resolveBundledCliRuntime", () => {
+  test("uses the current execPath when already running under Bun", () => {
+    const runtime = resolveBundledCliRuntime({ bun: "1.3.10" }, "C:/bun.exe", () => {
+      throw new Error("should not probe bun when already running under Bun")
+    })
+
+    expect(runtime).toBe("C:/bun.exe")
+  })
+
+  test("uses bun on PATH when running under Node and bun is available", () => {
+    const runtime = resolveBundledCliRuntime({}, "C:/node.exe", (command, args, options) => {
+      expect(command).toBe("bun")
+      expect(args).toEqual(["--version"])
+      expect(options).toEqual({ encoding: "utf8", stdio: "pipe" })
+
+      return {
+        status: 0,
+        signal: null,
+        error: undefined,
+      }
+    })
+
+    expect(runtime).toBe("bun")
+  })
+
+  test("returns null when bun is unavailable outside Bun runtime", () => {
+    const runtime = resolveBundledCliRuntime({}, "C:/node.exe", () => ({
+      status: 1,
+      signal: null,
+      error: new Error("bun not found"),
+    }))
+
+    expect(runtime).toBeNull()
+  })
+})
+
+describe("runBundledCli", () => {
+  test("spawns the current runtime with the packaged CLI entrypoint", () => {
+    const calls: Array<{ command: string; args: string[]; options: { stdio: string } }> = []
+    const fakeSpawn = (command: string, args: string[], options: { stdio: string }) => {
+      calls.push({ command, args, options })
+      return {
+        status: 0,
+        signal: null,
+        error: undefined,
+      }
+    }
+
+    runBundledCli(["install"], fakeSpawn, "bun.exe")
+
+    expect(calls).toHaveLength(1)
+    expect(calls[0]).toEqual({
+      command: "bun.exe",
+      args: [getBundledCliEntrypoint(), "install"],
+      options: { stdio: "inherit" },
+    })
+  })
+})

package/bin/platform.js

@@ -1,10 +1,13 @@
 // bin/platform.js
 // Shared platform detection module - used by wrapper and postinstall
 
+const PLATFORM_PACKAGE_PREFIX = "evil-omo";
+const CLI_BINARY_NAME = "evil-omo";
+
 /**
  * Get the platform-specific package name
  * @param {{ platform: string, arch: string, libcFamily?: string | null }} options
- * @returns {string} Package name like "oh-my-opencode-darwin-arm64"
+ * @returns {string} Package name like "evil-omo-darwin-arm64"
  * @throws {Error} If libc cannot be detected on Linux
  */
 export function getPlatformPackage({ platform, arch, libcFamily }) {
@@ -23,7 +26,7 @@ export function getPlatformPackage({ platform, arch, libcFamily }) {
   
   // Map platform names: win32 -> windows (for package name)
   const os = platform === "win32" ? "windows" : platform;
-  return `oh-my-opencode-${os}-${arch}${suffix}`;
+  return `${PLATFORM_PACKAGE_PREFIX}-${os}-${arch}${suffix}`;
 }
 
 /** @param {{ platform: string, arch: string, libcFamily?: string | null, preferBaseline?: boolean }} options */
@@ -45,11 +48,11 @@ function getBaselinePlatformPackage({ platform, arch, libcFamily }) {
   }
 
   if (platform === "darwin") {
-    return "oh-my-opencode-darwin-x64-baseline";
+    return `${PLATFORM_PACKAGE_PREFIX}-darwin-x64-baseline`;
   }
 
   if (platform === "win32") {
-    return "oh-my-opencode-windows-x64-baseline";
+    return `${PLATFORM_PACKAGE_PREFIX}-windows-x64-baseline`;
   }
 
   if (platform === "linux") {
@@ -61,10 +64,10 @@ function getBaselinePlatformPackage({ platform, arch, libcFamily }) {
     }
 
     if (libcFamily === "musl") {
-      return "oh-my-opencode-linux-x64-musl-baseline";
+      return `${PLATFORM_PACKAGE_PREFIX}-linux-x64-musl-baseline`;
     }
 
-    return "oh-my-opencode-linux-x64-baseline";
+    return `${PLATFORM_PACKAGE_PREFIX}-linux-x64-baseline`;
   }
 
   return null;
@@ -74,9 +77,9 @@ function getBaselinePlatformPackage({ platform, arch, libcFamily }) {
  * Get the path to the binary within a platform package
  * @param {string} pkg Package name
  * @param {string} platform Process platform
- * @returns {string} Relative path like "oh-my-opencode-darwin-arm64/bin/oh-my-opencode"
+ * @returns {string} Relative path like "evil-omo-darwin-arm64/bin/evil-omo"
  */
 export function getBinaryPath(pkg, platform) {
   const ext = platform === "win32" ? ".exe" : "";
-  return `${pkg}/bin/oh-my-opencode${ext}`;
+  return `${pkg}/bin/${CLI_BINARY_NAME}${ext}`;
 }

package/bin/platform.test.ts

@@ -12,7 +12,7 @@ describe("getPlatformPackage", () => {
     const result = getPlatformPackage(input);
 
     // #then returns correct package name
-    expect(result).toBe("oh-my-opencode-darwin-arm64");
+    expect(result).toBe("evil-omo-darwin-arm64");
   });
 
   test("returns darwin-x64 for macOS Intel", () => {
@@ -23,7 +23,7 @@ describe("getPlatformPackage", () => {
     const result = getPlatformPackage(input);
 
     // #then returns correct package name
-    expect(result).toBe("oh-my-opencode-darwin-x64");
+    expect(result).toBe("evil-omo-darwin-x64");
   });
   // #endregion
 
@@ -36,7 +36,7 @@ describe("getPlatformPackage", () => {
     const result = getPlatformPackage(input);
 
     // #then returns correct package name
-    expect(result).toBe("oh-my-opencode-linux-x64");
+    expect(result).toBe("evil-omo-linux-x64");
   });
 
   test("returns linux-arm64 for Linux ARM64 with glibc", () => {
@@ -47,7 +47,7 @@ describe("getPlatformPackage", () => {
     const result = getPlatformPackage(input);
 
     // #then returns correct package name
-    expect(result).toBe("oh-my-opencode-linux-arm64");
+    expect(result).toBe("evil-omo-linux-arm64");
   });
   // #endregion
 
@@ -60,7 +60,7 @@ describe("getPlatformPackage", () => {
     const result = getPlatformPackage(input);
 
     // #then returns correct package name with musl suffix
-    expect(result).toBe("oh-my-opencode-linux-x64-musl");
+    expect(result).toBe("evil-omo-linux-x64-musl");
   });
 
   test("returns linux-arm64-musl for Alpine ARM64", () => {
@@ -71,7 +71,7 @@ describe("getPlatformPackage", () => {
     const result = getPlatformPackage(input);
 
     // #then returns correct package name with musl suffix
-    expect(result).toBe("oh-my-opencode-linux-arm64-musl");
+    expect(result).toBe("evil-omo-linux-arm64-musl");
   });
   // #endregion
 
@@ -84,7 +84,7 @@ describe("getPlatformPackage", () => {
     const result = getPlatformPackage(input);
 
     // #then returns correct package name with 'windows' not 'win32'
-    expect(result).toBe("oh-my-opencode-windows-x64");
+    expect(result).toBe("evil-omo-windows-x64");
   });
   // #endregion
 
@@ -112,38 +112,38 @@ describe("getPlatformPackage", () => {
 describe("getBinaryPath", () => {
   test("returns path without .exe for Unix platforms", () => {
     // #given Unix platform package
-    const pkg = "oh-my-opencode-darwin-arm64";
+    const pkg = "evil-omo-darwin-arm64";
     const platform = "darwin";
 
     // #when getting binary path
     const result = getBinaryPath(pkg, platform);
 
     // #then returns path without extension
-    expect(result).toBe("oh-my-opencode-darwin-arm64/bin/oh-my-opencode");
+    expect(result).toBe("evil-omo-darwin-arm64/bin/evil-omo");
   });
 
   test("returns path with .exe for Windows", () => {
     // #given Windows platform package
-    const pkg = "oh-my-opencode-windows-x64";
+    const pkg = "evil-omo-windows-x64";
     const platform = "win32";
 
     // #when getting binary path
     const result = getBinaryPath(pkg, platform);
 
     // #then returns path with .exe extension
-    expect(result).toBe("oh-my-opencode-windows-x64/bin/oh-my-opencode.exe");
+    expect(result).toBe("evil-omo-windows-x64/bin/evil-omo.exe");
   });
 
   test("returns path without .exe for Linux", () => {
     // #given Linux platform package
-    const pkg = "oh-my-opencode-linux-x64";
+    const pkg = "evil-omo-linux-x64";
     const platform = "linux";
 
     // #when getting binary path
     const result = getBinaryPath(pkg, platform);
 
     // #then returns path without extension
-    expect(result).toBe("oh-my-opencode-linux-x64/bin/oh-my-opencode");
+    expect(result).toBe("evil-omo-linux-x64/bin/evil-omo");
   });
 });
 
@@ -157,8 +157,8 @@ describe("getPlatformPackageCandidates", () => {
 
     // #then returns modern first then baseline fallback
     expect(result).toEqual([
-      "oh-my-opencode-linux-x64",
-      "oh-my-opencode-linux-x64-baseline",
+      "evil-omo-linux-x64",
+      "evil-omo-linux-x64-baseline",
     ]);
   });
 
@@ -171,8 +171,8 @@ describe("getPlatformPackageCandidates", () => {
 
     // #then returns musl modern first then musl baseline fallback
     expect(result).toEqual([
-      "oh-my-opencode-linux-x64-musl",
-      "oh-my-opencode-linux-x64-musl-baseline",
+      "evil-omo-linux-x64-musl",
+      "evil-omo-linux-x64-musl-baseline",
     ]);
   });
 
@@ -185,8 +185,8 @@ describe("getPlatformPackageCandidates", () => {
 
     // #then baseline package is preferred first
     expect(result).toEqual([
-      "oh-my-opencode-windows-x64-baseline",
-      "oh-my-opencode-windows-x64",
+      "evil-omo-windows-x64-baseline",
+      "evil-omo-windows-x64",
     ]);
   });
 
@@ -198,6 +198,6 @@ describe("getPlatformPackageCandidates", () => {
     const result = getPlatformPackageCandidates(input);
 
     // #then baseline fallback is not included
-    expect(result).toEqual(["oh-my-opencode-linux-arm64"]);
+    expect(result).toEqual(["evil-omo-linux-arm64"]);
   });
 });

package/dist/cli/config-manager/config-context.d.ts

@@ -11,3 +11,4 @@ export declare function getConfigDir(): string;
 export declare function getConfigJson(): string;
 export declare function getConfigJsonc(): string;
 export declare function getOmoConfigPath(): string;
+export declare function getExistingOmoConfigPath(): string | null;

package/dist/cli/doctor/constants.d.ts

@@ -25,5 +25,5 @@ export declare const EXIT_CODES: {
     readonly FAILURE: 1;
 };
 export declare const MIN_OPENCODE_VERSION = "1.0.150";
-export declare const PACKAGE_NAME = "oh-my-opencode";
+export declare const PACKAGE_NAME = "evil-omo";
 export declare const OPENCODE_BINARIES: readonly ["opencode", "opencode-desktop"];