oh-my-opencode 2.7.1 → 2.7.2

package/dist/cli/index.js

@@ -2244,7 +2244,7 @@ var require_picocolors = __commonJS((exports, module) => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "oh-my-opencode",
-    version: "2.7.0",
+    version: "2.7.1",
     description: "OpenCode plugin - custom agents (oracle, librarian) and enhanced features",
     main: "dist/index.js",
     types: "dist/index.d.ts",
@@ -3804,6 +3804,7 @@ var OPENCODE_JSON = join2(OPENCODE_CONFIG_DIR, "opencode.json");
 var OPENCODE_JSONC = join2(OPENCODE_CONFIG_DIR, "opencode.jsonc");
 var OPENCODE_PACKAGE_JSON = join2(OPENCODE_CONFIG_DIR, "package.json");
 var OMO_CONFIG = join2(OPENCODE_CONFIG_DIR, "oh-my-opencode.json");
+var OPENCODE_BINARIES = ["opencode", "opencode-desktop"];
 var CHATGPT_HOTFIX_REPO = "code-yeongyu/opencode-openai-codex-auth#fix/orphaned-function-call-output-with-tools";
 async function fetchLatestVersion(packageName) {
   try {
@@ -3957,30 +3958,31 @@ function writeOmoConfig(installConfig) {
     return { success: false, configPath: OMO_CONFIG, error: String(err) };
   }
 }
-async function isOpenCodeInstalled() {
-  try {
-    const proc = Bun.spawn(["opencode", "--version"], {
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    await proc.exited;
-    return proc.exitCode === 0;
-  } catch {
-    return false;
+async function findOpenCodeBinaryWithVersion() {
+  for (const binary of OPENCODE_BINARIES) {
+    try {
+      const proc = Bun.spawn([binary, "--version"], {
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const output = await new Response(proc.stdout).text();
+      await proc.exited;
+      if (proc.exitCode === 0) {
+        return { binary, version: output.trim() };
+      }
+    } catch {
+      continue;
+    }
   }
+  return null;
+}
+async function isOpenCodeInstalled() {
+  const result = await findOpenCodeBinaryWithVersion();
+  return result !== null;
 }
 async function getOpenCodeVersion() {
-  try {
-    const proc = Bun.spawn(["opencode", "--version"], {
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    const output = await new Response(proc.stdout).text();
-    await proc.exited;
-    return proc.exitCode === 0 ? output.trim() : null;
-  } catch {
-    return null;
-  }
+  const result = await findOpenCodeBinaryWithVersion();
+  return result?.version ?? null;
 }
 async function addAuthPlugins(config) {
   ensureConfigDir();

package/dist/index.js

@@ -4563,8 +4563,10 @@ function createTodoContinuationEnforcer(ctx, options = {}) {
         return;
       log(`[${HOOK_NAME}] session.idle`, { sessionID });
       const mainSessionID2 = getMainSessionID();
-      if (mainSessionID2 && sessionID !== mainSessionID2) {
-        log(`[${HOOK_NAME}] Skipped: not main session`, { sessionID });
+      const isMainSession = sessionID === mainSessionID2;
+      const isBackgroundTaskSession = subagentSessions.has(sessionID);
+      if (mainSessionID2 && !isMainSession && !isBackgroundTaskSession) {
+        log(`[${HOOK_NAME}] Skipped: not main or background task session`, { sessionID });
         return;
       }
       const state2 = getState(sessionID);
@@ -14454,6 +14456,10 @@ function isServerInstalled(command) {
   if (command.length === 0)
     return false;
   const cmd = command[0];
+  if (cmd.includes("/") || cmd.includes("\\")) {
+    if (existsSync34(cmd))
+      return true;
+  }
   const isWindows2 = process.platform === "win32";
   const ext = isWindows2 ? ".exe" : "";
   const pathEnv = process.env.PATH || "";
@@ -14478,6 +14484,9 @@ function isServerInstalled(command) {
       return true;
     }
   }
+  if (cmd === "bun" || cmd === "node") {
+    return true;
+  }
   return false;
 }
 function getAllServers() {
@@ -28566,7 +28575,7 @@ var ast_grep_replace = tool({
   }
 });
 // src/tools/grep/cli.ts
-var {spawn: spawn8 } = globalThis.Bun;
+var {spawn: spawn9 } = globalThis.Bun;
 
 // src/tools/grep/constants.ts
 import { existsSync as existsSync40 } from "fs";
@@ -28576,6 +28585,31 @@ import { spawnSync } from "child_process";
 // src/tools/grep/downloader.ts
 import { existsSync as existsSync39, mkdirSync as mkdirSync11, chmodSync as chmodSync3, unlinkSync as unlinkSync10, readdirSync as readdirSync14 } from "fs";
 import { join as join47 } from "path";
+var {spawn: spawn8 } = globalThis.Bun;
+function findFileRecursive(dir, filename) {
+  try {
+    const entries = readdirSync14(dir, { withFileTypes: true, recursive: true });
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name === filename) {
+        return join47(entry.parentPath ?? dir, entry.name);
+      }
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+var RG_VERSION = "14.1.1";
+var PLATFORM_CONFIG = {
+  "arm64-darwin": { platform: "aarch64-apple-darwin", extension: "tar.gz" },
+  "arm64-linux": { platform: "aarch64-unknown-linux-gnu", extension: "tar.gz" },
+  "x64-darwin": { platform: "x86_64-apple-darwin", extension: "tar.gz" },
+  "x64-linux": { platform: "x86_64-unknown-linux-musl", extension: "tar.gz" },
+  "x64-win32": { platform: "x86_64-pc-windows-msvc", extension: "zip" }
+};
+function getPlatformKey() {
+  return `${process.arch}-${process.platform}`;
+}
 function getInstallDir() {
   const homeDir = process.env.HOME || process.env.USERPROFILE || ".";
   return join47(homeDir, ".cache", "oh-my-opencode", "bin");
@@ -28584,6 +28618,110 @@ function getRgPath() {
   const isWindows2 = process.platform === "win32";
   return join47(getInstallDir(), isWindows2 ? "rg.exe" : "rg");
 }
+async function downloadFile(url2, destPath) {
+  const response2 = await fetch(url2);
+  if (!response2.ok) {
+    throw new Error(`Failed to download: ${response2.status} ${response2.statusText}`);
+  }
+  const buffer = await response2.arrayBuffer();
+  await Bun.write(destPath, buffer);
+}
+async function extractTarGz2(archivePath, destDir) {
+  const platformKey = getPlatformKey();
+  const args = ["tar", "-xzf", archivePath, "--strip-components=1"];
+  if (platformKey.endsWith("-darwin")) {
+    args.push("--include=*/rg");
+  } else if (platformKey.endsWith("-linux")) {
+    args.push("--wildcards", "*/rg");
+  }
+  const proc = spawn8(args, {
+    cwd: destDir,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    const stderr = await new Response(proc.stderr).text();
+    throw new Error(`Failed to extract tar.gz: ${stderr}`);
+  }
+}
+async function extractZipWindows(archivePath, destDir) {
+  const proc = spawn8(["powershell", "-Command", `Expand-Archive -Path '${archivePath}' -DestinationPath '${destDir}' -Force`], { stdout: "pipe", stderr: "pipe" });
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    throw new Error("Failed to extract zip with PowerShell");
+  }
+  const foundPath = findFileRecursive(destDir, "rg.exe");
+  if (foundPath) {
+    const destPath = join47(destDir, "rg.exe");
+    if (foundPath !== destPath) {
+      const { renameSync } = await import("fs");
+      renameSync(foundPath, destPath);
+    }
+  }
+}
+async function extractZipUnix(archivePath, destDir) {
+  const proc = spawn8(["unzip", "-o", archivePath, "-d", destDir], {
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    throw new Error("Failed to extract zip");
+  }
+  const foundPath = findFileRecursive(destDir, "rg");
+  if (foundPath) {
+    const destPath = join47(destDir, "rg");
+    if (foundPath !== destPath) {
+      const { renameSync } = await import("fs");
+      renameSync(foundPath, destPath);
+    }
+  }
+}
+async function extractZip3(archivePath, destDir) {
+  if (process.platform === "win32") {
+    await extractZipWindows(archivePath, destDir);
+  } else {
+    await extractZipUnix(archivePath, destDir);
+  }
+}
+async function downloadAndInstallRipgrep() {
+  const platformKey = getPlatformKey();
+  const config3 = PLATFORM_CONFIG[platformKey];
+  if (!config3) {
+    throw new Error(`Unsupported platform: ${platformKey}`);
+  }
+  const installDir = getInstallDir();
+  const rgPath = getRgPath();
+  if (existsSync39(rgPath)) {
+    return rgPath;
+  }
+  mkdirSync11(installDir, { recursive: true });
+  const filename = `ripgrep-${RG_VERSION}-${config3.platform}.${config3.extension}`;
+  const url2 = `https://github.com/BurntSushi/ripgrep/releases/download/${RG_VERSION}/${filename}`;
+  const archivePath = join47(installDir, filename);
+  try {
+    await downloadFile(url2, archivePath);
+    if (config3.extension === "tar.gz") {
+      await extractTarGz2(archivePath, installDir);
+    } else {
+      await extractZip3(archivePath, installDir);
+    }
+    if (process.platform !== "win32") {
+      chmodSync3(rgPath, 493);
+    }
+    if (!existsSync39(rgPath)) {
+      throw new Error("ripgrep binary not found after extraction");
+    }
+    return rgPath;
+  } finally {
+    if (existsSync39(archivePath)) {
+      try {
+        unlinkSync10(archivePath);
+      } catch {}
+    }
+  }
+}
 function getInstalledRipgrepPath() {
   const rgPath = getRgPath();
   return existsSync39(rgPath) ? rgPath : null;
@@ -28591,6 +28729,7 @@ function getInstalledRipgrepPath() {
 
 // src/tools/grep/constants.ts
 var cachedCli = null;
+var autoInstallAttempted = false;
 function findExecutable(name) {
   const isWindows2 = process.platform === "win32";
   const cmd = isWindows2 ? "where" : "which";
@@ -28609,6 +28748,7 @@ function getOpenCodeBundledRg() {
   const isWindows2 = process.platform === "win32";
   const rgName = isWindows2 ? "rg.exe" : "rg";
   const candidates = [
+    join48(getDataDir(), "opencode", "bin", rgName),
     join48(execDir, rgName),
     join48(execDir, "bin", rgName),
     join48(execDir, "..", "bin", rgName),
@@ -28647,6 +28787,23 @@ function resolveGrepCli() {
   cachedCli = { path: "rg", backend: "rg" };
   return cachedCli;
 }
+async function resolveGrepCliWithAutoInstall() {
+  const current = resolveGrepCli();
+  if (current.backend === "rg") {
+    return current;
+  }
+  if (autoInstallAttempted) {
+    return current;
+  }
+  autoInstallAttempted = true;
+  try {
+    const rgPath = await downloadAndInstallRipgrep();
+    cachedCli = { path: rgPath, backend: "rg" };
+    return cachedCli;
+  } catch {
+    return current;
+  }
+}
 var DEFAULT_MAX_DEPTH = 20;
 var DEFAULT_MAX_FILESIZE = "10M";
 var DEFAULT_MAX_COUNT = 500;
@@ -28761,7 +28918,7 @@ async function runRg(options) {
   }
   const paths = options.paths?.length ? options.paths : ["."];
   args.push(...paths);
-  const proc = spawn8([cli.path, ...args], {
+  const proc = spawn9([cli.path, ...args], {
     stdout: "pipe",
     stderr: "pipe"
   });
@@ -28863,7 +29020,7 @@ var grep = tool({
 });
 
 // src/tools/glob/cli.ts
-var {spawn: spawn9 } = globalThis.Bun;
+var {spawn: spawn10 } = globalThis.Bun;
 
 // src/tools/glob/constants.ts
 var DEFAULT_TIMEOUT_MS3 = 60000;
@@ -28901,6 +29058,19 @@ function buildFindArgs(options) {
   }
   return args;
 }
+function buildPowerShellCommand(options) {
+  const maxDepth = Math.min(options.maxDepth ?? DEFAULT_MAX_DEPTH2, DEFAULT_MAX_DEPTH2);
+  const paths = options.paths?.length ? options.paths : ["."];
+  const searchPath = paths[0] || ".";
+  const escapedPath = searchPath.replace(/'/g, "''");
+  const escapedPattern = options.pattern.replace(/'/g, "''");
+  let psCommand = `Get-ChildItem -Path '${escapedPath}' -File -Recurse -Depth ${maxDepth - 1} -Filter '${escapedPattern}'`;
+  if (options.hidden) {
+    psCommand += " -Force";
+  }
+  psCommand += " -ErrorAction SilentlyContinue | Select-Object -ExpandProperty FullName";
+  return ["powershell", "-NoProfile", "-Command", psCommand];
+}
 async function getFileMtime(filePath) {
   try {
     const stats = await stat(filePath);
@@ -28909,21 +29079,33 @@ async function getFileMtime(filePath) {
     return 0;
   }
 }
-async function runRgFiles(options) {
-  const cli = resolveGrepCli();
+async function runRgFiles(options, resolvedCli) {
+  const cli = resolvedCli ?? resolveGrepCli();
   const timeout = Math.min(options.timeout ?? DEFAULT_TIMEOUT_MS3, DEFAULT_TIMEOUT_MS3);
   const limit = Math.min(options.limit ?? DEFAULT_LIMIT, DEFAULT_LIMIT);
   const isRg = cli.backend === "rg";
-  const args = isRg ? buildRgArgs2(options) : buildFindArgs(options);
-  const paths = options.paths?.length ? options.paths : ["."];
+  const isWindows2 = process.platform === "win32";
+  let command;
+  let cwd;
   if (isRg) {
+    const args = buildRgArgs2(options);
+    const paths = options.paths?.length ? options.paths : ["."];
     args.push(...paths);
+    command = [cli.path, ...args];
+    cwd = undefined;
+  } else if (isWindows2) {
+    command = buildPowerShellCommand(options);
+    cwd = undefined;
+  } else {
+    const args = buildFindArgs(options);
+    const paths = options.paths?.length ? options.paths : ["."];
+    cwd = paths[0] || ".";
+    command = [cli.path, ...args];
   }
-  const cwd = paths[0] || ".";
-  const proc = spawn9([cli.path, ...args], {
+  const proc = spawn10(command, {
     stdout: "pipe",
     stderr: "pipe",
-    cwd: isRg ? undefined : cwd
+    cwd
   });
   const timeoutPromise = new Promise((_, reject) => {
     const id = setTimeout(() => {
@@ -28955,7 +29137,14 @@ async function runRgFiles(options) {
         truncated = true;
         break;
       }
-      const filePath = isRg ? line : `${cwd}/${line}`;
+      let filePath;
+      if (isRg) {
+        filePath = line;
+      } else if (isWindows2) {
+        filePath = line.trim();
+      } else {
+        filePath = `${cwd}/${line}`;
+      }
       const mtime = await getFileMtime(filePath);
       files.push({ path: filePath, mtime });
     }
@@ -29006,11 +29195,12 @@ var glob = tool({
   },
   execute: async (args) => {
     try {
+      const cli = await resolveGrepCliWithAutoInstall();
       const paths = args.path ? [args.path] : undefined;
       const result = await runRgFiles({
         pattern: args.pattern,
         paths
-      });
+      }, cli);
       return formatGlobResult(result);
     } catch (e) {
       return `Error: ${e instanceof Error ? e.message : String(e)}`;
@@ -29726,14 +29916,14 @@ var INTERACTIVE_BASH_DESCRIPTION = `Execute tmux commands. Use "omo-{name}" sess
 Blocked (use bash instead): capture-pane, save-buffer, show-buffer, pipe-pane.`;
 
 // src/tools/interactive-bash/utils.ts
-var {spawn: spawn10 } = globalThis.Bun;
+var {spawn: spawn11 } = globalThis.Bun;
 var tmuxPath = null;
 var initPromise3 = null;
 async function findTmuxPath() {
   const isWindows2 = process.platform === "win32";
   const cmd = isWindows2 ? "where" : "which";
   try {
-    const proc = spawn10([cmd, "tmux"], {
+    const proc = spawn11([cmd, "tmux"], {
       stdout: "pipe",
       stderr: "pipe"
     });
@@ -29747,7 +29937,7 @@ async function findTmuxPath() {
     if (!path7) {
       return null;
     }
-    const verifyProc = spawn10([path7, "-V"], {
+    const verifyProc = spawn11([path7, "-V"], {
       stdout: "pipe",
       stderr: "pipe"
     });

package/dist/tools/glob/cli.d.ts

@@ -1,2 +1,7 @@
+import { type GrepBackend } from "./constants";
 import type { GlobOptions, GlobResult } from "./types";
-export declare function runRgFiles(options: GlobOptions): Promise<GlobResult>;
+export interface ResolvedCli {
+    path: string;
+    backend: GrepBackend;
+}
+export declare function runRgFiles(options: GlobOptions, resolvedCli?: ResolvedCli): Promise<GlobResult>;

package/dist/tools/glob/constants.d.ts

@@ -1,4 +1,4 @@
-export { resolveGrepCli, type GrepBackend } from "../grep/constants";
+export { resolveGrepCli, resolveGrepCliWithAutoInstall, type GrepBackend } from "../grep/constants";
 export declare const DEFAULT_TIMEOUT_MS = 60000;
 export declare const DEFAULT_LIMIT = 100;
 export declare const DEFAULT_MAX_DEPTH = 20;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode",
-  "version": "2.7.1",
+  "version": "2.7.2",
   "description": "OpenCode plugin - custom agents (oracle, librarian) and enhanced features",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",