@omercnet/paseo-context-mode 3.1.3 → 3.1.4-next.434.1

package/server/binary.ts

@@ -1,8 +1,10 @@
+import { execFile } from "node:child_process";
 import { constants } from "node:fs";
 import { access, readFile, realpath, stat } from "node:fs/promises";
 import { createRequire } from "node:module";
-import { join, posix, win32 } from "node:path";
-import type { ContextModeSettings } from "../shared";
+import { dirname, join, win32 } from "node:path";
+import { promisify } from "node:util";
+import type { ContextModeSettings } from "../shared/settings";
 import type { ProviderConfigSource } from "./integration";
 
 export interface LaunchDescriptor {
@@ -15,18 +17,18 @@ export type BinaryResolution =
   | {
       state: "found";
       path: string;
-      source: "settings" | "path" | "bundled";
+      source: "settings" | "bundled";
       launch: LaunchDescriptor;
     }
   | { state: "missing"; code: "not-installed" | "unsupported"; message: string };
 
 export interface BinaryResolutionDependencies {
-  env?: NodeJS.ProcessEnv;
   platform?: NodeJS.Platform;
   nodePath?: string;
   electron?: boolean;
   canExecute?: (path: string) => Promise<boolean>;
   isFile?: (path: string) => Promise<boolean>;
+  readVersion?: (launch: LaunchDescriptor) => Promise<string | null>;
   paseo?: ProviderConfigSource;
 }
 
@@ -44,7 +46,9 @@ async function findBundledCli(paseo: ProviderConfigSource | undefined): Promise<
     try {
       const manifest = JSON.parse(await readFile(join(directory, "paseo-plugin.json"), "utf8"));
       if (manifest?.id !== "context-mode") continue;
-      return createRequire(join(directory, "package.json")).resolve("context-mode/cli");
+      // The package exports only its OpenCode plugin (`<root>/opencode/plugin.js`); the CLI sits at the root.
+      const main = createRequire(join(directory, "package.json")).resolve("context-mode");
+      return join(dirname(dirname(main)), "cli.mjs");
     } catch {
       // Not this plugin, or its install has no bundled runtime.
     }
@@ -70,21 +74,6 @@ async function defaultCanExecute(path: string, platform: NodeJS.Platform): Promi
   }
 }
 
-function pathCandidates(
-  name: string,
-  directory: string,
-  platform: NodeJS.Platform,
-  env: NodeJS.ProcessEnv,
-) {
-  const pathApi = platform === "win32" ? win32 : posix;
-  if (platform !== "win32") return [pathApi.join(directory, name)];
-  const extensions = (env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean);
-  return [
-    pathApi.join(directory, name),
-    ...extensions.map((extension) => pathApi.join(directory, `${name}${extension}`)),
-  ];
-}
-
 async function windowsLaunchDescriptor(
   candidate: string,
   nodePath: string,
@@ -100,10 +89,8 @@ async function windowsLaunchDescriptor(
 
   const directory = win32.dirname(candidate);
   const moduleCandidates = [
-    win32.join(directory, "node_modules", "context-mode", "cli.bundle.mjs"),
-    win32.join(directory, "node_modules", "context-mode", "build", "cli.js"),
-    win32.join(directory, "..", "context-mode", "cli.bundle.mjs"),
-    win32.join(directory, "..", "context-mode", "build", "cli.js"),
+    win32.join(directory, "node_modules", "context-mode", "cli.mjs"),
+    win32.join(directory, "..", "context-mode", "cli.mjs"),
   ];
   for (const modulePath of moduleCandidates) {
     if (await isFile(modulePath)) return { program: nodePath, args: [modulePath] };
@@ -111,93 +98,131 @@ async function windowsLaunchDescriptor(
   return null;
 }
 
+/**
+ * The user's own binary when one is configured, else the runtime bundled with the plugin. A
+ * configured binary that cannot run is reported, never silently replaced by the bundled one.
+ */
 export async function resolveContextModeBinary(
   settings: ContextModeSettings,
   dependencies: BinaryResolutionDependencies = {},
 ): Promise<BinaryResolution> {
-  const env = dependencies.env ?? process.env;
   const platform = dependencies.platform ?? process.platform;
-  const pathApi = platform === "win32" ? win32 : posix;
   const nodePath = dependencies.nodePath ?? process.execPath;
-  const canExecute =
-    dependencies.canExecute ?? ((path: string) => defaultCanExecute(path, platform));
-  const isFile = dependencies.isFile ?? defaultIsFile;
-  const configuredPath = settings.binaryPath.trim();
-  let unsupportedShim: string | null = null;
-
-  async function resolveCandidate(
-    candidate: string,
-    source: "settings" | "path",
-  ): Promise<Extract<BinaryResolution, { state: "found" }> | null> {
-    if (!(await canExecute(candidate))) return null;
-    const canonicalPath = await realpath(candidate).catch(() => candidate);
-    if (platform !== "win32") {
-      return {
-        state: "found",
-        path: canonicalPath,
-        source,
-        launch: { program: canonicalPath, args: [] },
-      };
-    }
-    const launch = await windowsLaunchDescriptor(canonicalPath, nodePath, isFile);
-    if (!launch) {
-      unsupportedShim = canonicalPath;
-      return null;
-    }
-    return { state: "found", path: canonicalPath, source, launch };
+  if (settings.binaryPath !== null) {
+    return resolveConfiguredBinary(settings.binaryPath, {
+      platform,
+      nodePath,
+      canExecute: dependencies.canExecute ?? ((path: string) => defaultCanExecute(path, platform)),
+      isFile: dependencies.isFile ?? defaultIsFile,
+      readVersion: dependencies.readVersion ?? readContextModeVersion,
+    });
   }
 
-  if (settings.binaryMode === "path" && configuredPath.length > 0) {
-    if (!pathApi.isAbsolute(configuredPath)) {
-      return {
-        state: "missing",
-        code: "not-installed",
-        message: "The configured Context Mode binary path is not absolute.",
-      };
-    }
-    const configured = await resolveCandidate(configuredPath, "settings");
-    if (configured) return configured;
+  const bundledCli = await findBundledCli(dependencies.paseo);
+  if (!bundledCli) {
+    return {
+      state: "missing",
+      code: "not-installed",
+      message:
+        "The bundled Context Mode runtime is missing from this plugin install. Reinstall the plugin or configure your own binary.",
+    };
   }
+  const canonicalPath = await realpath(bundledCli).catch(() => bundledCli);
+  // Under the desktop app `nodePath` is Electron. Paseo strips this variable from agent
+  // environments, so an injected MCP server needs it to start as Node.
+  const electron = dependencies.electron ?? process.versions.electron !== undefined;
+  return {
+    state: "found",
+    path: canonicalPath,
+    source: "bundled",
+    launch: {
+      program: nodePath,
+      args: [canonicalPath],
+      ...(electron ? { env: { ELECTRON_RUN_AS_NODE: "1" } } : {}),
+    },
+  };
+}
 
-  for (const directory of (env.PATH ?? "").split(pathApi.delimiter).filter(Boolean)) {
-    for (const candidate of pathCandidates("context-mode", directory, platform, env)) {
-      const resolved = await resolveCandidate(candidate, "path");
-      if (resolved) return resolved;
-    }
-  }
+interface ConfiguredBinaryChecks {
+  platform: NodeJS.Platform;
+  nodePath: string;
+  canExecute: (path: string) => Promise<boolean>;
+  isFile: (path: string) => Promise<boolean>;
+  readVersion: (launch: LaunchDescriptor) => Promise<string | null>;
+}
 
-  const bundledCli = await findBundledCli(dependencies.paseo);
-  if (bundledCli) {
-    const canonicalPath = await realpath(bundledCli).catch(() => bundledCli);
-    // Under the desktop app `nodePath` is Electron. Paseo strips this variable from agent
-    // environments, so an injected MCP server needs it to start as Node.
-    const electron = dependencies.electron ?? process.versions.electron !== undefined;
+async function resolveConfiguredBinary(
+  configuredPath: string,
+  checks: ConfiguredBinaryChecks,
+): Promise<BinaryResolution> {
+  if (!(await checks.canExecute(configuredPath))) {
     return {
-      state: "found",
-      path: canonicalPath,
-      source: "bundled",
-      launch: {
-        program: nodePath,
-        args: [canonicalPath],
-        ...(electron ? { env: { ELECTRON_RUN_AS_NODE: "1" } } : {}),
-      },
+      state: "missing",
+      code: "not-installed",
+      message: `The configured Context Mode binary (${configuredPath}) is missing or not executable.`,
     };
   }
-
-  if (unsupportedShim) {
+  const canonicalPath = await realpath(configuredPath).catch(() => configuredPath);
+  const launch =
+    checks.platform === "win32"
+      ? await windowsLaunchDescriptor(canonicalPath, checks.nodePath, checks.isFile)
+      : { program: canonicalPath, args: [] };
+  if (!launch) {
     return {
+      state: "missing",
       code: "unsupported",
+      message: `The configured Context Mode binary (${canonicalPath}) is a Windows shim whose CLI module could not be found. Configure the absolute cli.mjs path instead.`,
+    };
+  }
+  // 1.x starts a server but lacks the 2.x tool contracts the plugin and injected agents rely on.
+  const version = await checks.readVersion(launch);
+  if (version !== null && Number.parseInt(version, 10) < 2) {
+    return {
       state: "missing",
-      message: `Context Mode was found at ${unsupportedShim}, but this Windows shim could not be safely resolved to its CLI module. Reinstall Context Mode with npm or configure the absolute cli.bundle.mjs path.`,
+      code: "unsupported",
+      message: `The configured Context Mode binary is version ${version}; Context Mode 2 is required. Point it at a 2.x install or switch back to the bundled runtime.`,
     };
   }
-  const configuredDetail =
-    settings.binaryMode === "path" && configuredPath.length > 0
-      ? ` The configured path (${configuredPath}) was unavailable, and no fallback was found on PATH.`
-      : "";
-  return {
-    code: "not-installed",
-    state: "missing",
-    message: `Context Mode is not installed or is not executable on this Paseo host.${configuredDetail}`,
-  };
+  return { state: "found", path: canonicalPath, source: "settings", launch };
+}
+
+const VERSION_PATTERN = /\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?/;
+/** `--version` results per entry file; status, audit and every RPC resolve the binary again. */
+const cliVersions = new Map<string, { mtimeMs: number; version: string | null }>();
+
+/**
+ * The MCP handshake reports `dev` for npm builds, so the version comes from the package.json beside
+ * the CLI entry when it is a Context Mode install, else from `context-mode --version`, which only
+ * runs again once the entry file changes.
+ */
+export async function readContextModeVersion(
+  launch: LaunchDescriptor,
+  timeoutMs = 5_000,
+): Promise<string | null> {
+  const entry = launch.args[0] ?? launch.program;
+  try {
+    const manifest = JSON.parse(await readFile(join(dirname(entry), "package.json"), "utf8"));
+    if (manifest?.name === "context-mode" && typeof manifest.version === "string") {
+      return manifest.version.slice(0, 128);
+    }
+  } catch {
+    // Not a package directory; ask the CLI.
+  }
+  const mtimeMs = (await stat(entry).catch(() => null))?.mtimeMs;
+  const cached = cliVersions.get(entry);
+  if (cached && cached.mtimeMs === mtimeMs) return cached.version;
+  let version: string | null = null;
+  try {
+    const { stdout } = await promisify(execFile)(launch.program, [...launch.args, "--version"], {
+      timeout: timeoutMs,
+      windowsHide: true,
+      env: launch.env ? { ...process.env, ...launch.env } : undefined,
+    });
+    version = VERSION_PATTERN.exec(stdout)?.[0] ?? null;
+  } catch {
+    // Unknown version: not treated as 1.x.
+  }
+  // An unknown version is not cached: a timed-out probe must not let a 1.x binary past the gate.
+  if (mtimeMs !== undefined && version !== null) cliVersions.set(entry, { mtimeMs, version });
+  return version;
 }