@omercnet/paseo-context-mode 3.1.1-next.353.1 → 3.1.1

package/index.server.ts

@@ -45,7 +45,7 @@ export default function contribute(server: PluginServerContext) {
   server.before("agent.create", async ({ request }, { paseo }) => {
     const current = await settings.read();
     if (current.status !== "ready") return request;
-    const binary = await resolveContextModeBinary(current.values, { paseo });
+    const binary = await resolveContextModeBinary(current.values);
     if (binary.state !== "found") return request;
     const providers = await readProviderOverrides(paseo);
     return injectContextModeOnCreate(request, current.values, binary.launch, { providers });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omercnet/paseo-context-mode",
-  "version": "3.1.1-next.353.1",
+  "version": "3.1.1",
   "type": "module",
   "description": "Provider-aware Context Mode health, savings, and MCP activation for Paseo.",
   "license": "MIT",

package/server/actions.ts

@@ -6,9 +6,8 @@ import {
   type DoctorReport,
   type DoctorStatusRow,
 } from "../shared/actions";
-import type { contextModeSettings } from "../shared/settings";
+import type { ContextModeSettings, contextModeSettings } from "../shared/settings";
 import { type BinaryResolution, type LaunchDescriptor, resolveContextModeBinary } from "./binary";
-import type { ProviderConfigSource } from "./integration";
 import { contextModeEnvironmentFor, contextModePlatformFor } from "./knowledge";
 import {
   callContextModeTool,
@@ -29,7 +28,7 @@ type ActionToolCaller = (
 
 export interface ActionHandlerDependencies {
   osPlatform?: NodeJS.Platform;
-  resolveBinary?: typeof resolveContextModeBinary;
+  resolveBinary?: (settings: ContextModeSettings) => Promise<BinaryResolution>;
   inspect?: (
     launch: LaunchDescriptor,
     dependencies?: McpProcessDependencies,
@@ -37,12 +36,10 @@ export interface ActionHandlerDependencies {
   callTool?: ActionToolCaller;
 }
 
-type ActionContext = { paseo?: ProviderConfigSource };
-
 export interface ContextModeActionHandlers {
-  doctor(input: ContextModeActionInput, context?: ActionContext): Promise<DoctorReport>;
-  install(input: ContextModeActionInput, context?: ActionContext): Promise<ContextModeAction>;
-  upgrade(input: ContextModeActionInput, context?: ActionContext): Promise<ContextModeAction>;
+  doctor(input: ContextModeActionInput): Promise<DoctorReport>;
+  install(input: ContextModeActionInput): Promise<ContextModeAction>;
+  upgrade(input: ContextModeActionInput): Promise<ContextModeAction>;
 }
 
 export function parseContextModeDoctorOutput(rawOutput: string): DoctorStatusRow[] {
@@ -74,24 +71,19 @@ export function createContextModeActionHandlers(
   const callTool = dependencies.callTool ?? callContextModeTool;
   const osPlatform = dependencies.osPlatform ?? process.platform;
 
-  async function resolvedBinary(
-    paseo: ProviderConfigSource | undefined,
-  ): Promise<Extract<BinaryResolution, { state: "found" }>> {
+  async function resolvedBinary(): Promise<Extract<BinaryResolution, { state: "found" }>> {
     const settings = await settingsHandle.read();
     if (settings.status !== "ready") {
       throw new Error(`Context Mode settings are invalid: ${settings.error}`.slice(0, 4_096));
     }
-    const binary = await resolveBinary(settings.values, { paseo });
+    const binary = await resolveBinary(settings.values);
     if (binary.state === "missing") throw new Error(binary.message.slice(0, 4_096));
     return binary;
   }
 
-  async function currentVersion(
-    input: ContextModeActionInput,
-    paseo: ProviderConfigSource | undefined,
-  ): Promise<string | null> {
+  async function currentVersion(input: ContextModeActionInput): Promise<string | null> {
     try {
-      const binary = await resolvedBinary(paseo);
+      const binary = await resolvedBinary();
       const inspection = await inspect(binary.launch, {
         env: contextModeEnvironmentFor(input.provider),
       });
@@ -102,8 +94,8 @@ export function createContextModeActionHandlers(
   }
 
   return {
-    async doctor(input, context) {
-      const binary = await resolvedBinary(context?.paseo);
+    async doctor(input) {
+      const binary = await resolvedBinary();
       const rawOutput = await callTool(
         binary.launch,
         "ctx_doctor",
@@ -118,7 +110,7 @@ export function createContextModeActionHandlers(
         rawOutput,
       };
     },
-    async install(input, context) {
+    async install(input) {
       const platform = contextModePlatformFor(input.provider);
       return {
         program: osPlatform === "win32" ? "npm.cmd" : "npm",
@@ -129,15 +121,15 @@ export function createContextModeActionHandlers(
           "--no-audit",
           "--no-fund",
         ],
-        currentVersion: await currentVersion(input, context?.paseo),
+        currentVersion: await currentVersion(input),
         targetVersion: CONTEXT_MODE_TARGET_VERSION,
         platform,
         requiresRestart: true,
       };
     },
-    async upgrade(input, context) {
+    async upgrade(input) {
       const platform = contextModePlatformFor(input.provider);
-      const binary = await resolvedBinary(context?.paseo);
+      const binary = await resolvedBinary();
       const inspection = await inspect(binary.launch, {
         env: contextModeEnvironmentFor(input.provider),
       });

package/server/binary.ts

@@ -1,14 +1,12 @@
 import { constants } from "node:fs";
-import { access, readFile, realpath, stat } from "node:fs/promises";
+import { access, realpath, stat } from "node:fs/promises";
 import { createRequire } from "node:module";
 import { join, posix, win32 } from "node:path";
 import type { ContextModeSettings } from "../shared";
-import type { ProviderConfigSource } from "./integration";
 
 export interface LaunchDescriptor {
   program: string;
   args: string[];
-  env?: Record<string, string>;
 }
 
 export type BinaryResolution =
@@ -24,32 +22,9 @@ export interface BinaryResolutionDependencies {
   env?: NodeJS.ProcessEnv;
   platform?: NodeJS.Platform;
   nodePath?: string;
-  electron?: boolean;
   canExecute?: (path: string) => Promise<boolean>;
   isFile?: (path: string) => Promise<boolean>;
-  paseo?: ProviderConfigSource;
-}
-
-/**
- * Paseo evaluates the server bundle from the daemon's cwd with an empty `import.meta`, so the
- * bundled runtime is resolved from this plugin's directory in the daemon config instead.
- */
-async function findBundledCli(paseo: ProviderConfigSource | undefined): Promise<string | null> {
-  const { config } = (await paseo?.config.get().catch(() => undefined)) ?? {};
-  const plugins = config?.plugins;
-  if (typeof plugins !== "object" || plugins === null) return null;
-  for (const source of Object.values(plugins)) {
-    const directory = (source as { path?: unknown } | null)?.path;
-    if (typeof directory !== "string") continue;
-    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");
-    } catch {
-      // Not this plugin, or its install has no bundled runtime.
-    }
-  }
-  return null;
+  bundledCliPath?: () => string | null;
 }
 
 async function defaultIsFile(path: string): Promise<boolean> {
@@ -166,21 +141,25 @@ export async function resolveContextModeBinary(
     }
   }
 
-  const bundledCli = await findBundledCli(dependencies.paseo);
-  if (bundledCli) {
+  const bundledCandidates: string[] = [];
+  const injectedBundledPath = dependencies.bundledCliPath?.();
+  if (injectedBundledPath) bundledCandidates.push(injectedBundledPath);
+  if (!dependencies.bundledCliPath) {
+    bundledCandidates.push(join(process.cwd(), "node_modules", "context-mode", "cli.bundle.mjs"));
+    try {
+      bundledCandidates.push(createRequire(import.meta.url).resolve("context-mode/cli"));
+    } catch {
+      // The plugin bundle may run outside the dependency tree; the cwd candidate remains valid.
+    }
+  }
+  for (const bundledCli of new Set(bundledCandidates)) {
+    if (!(await isFile(bundledCli))) continue;
     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" } } : {}),
-      },
+      launch: { program: nodePath, args: [canonicalPath] },
     };
   }
 

package/server/handlers.ts

@@ -42,7 +42,7 @@ function contextModeProbeOptions(env: NodeJS.ProcessEnv = process.env): ProbeOpt
 
 export interface ContextModeHandlerDependencies {
   now?: () => Date;
-  resolveBinary?: typeof resolveContextModeBinary;
+  resolveBinary?: (settings: ContextModeSettings) => Promise<BinaryResolution>;
   inspect?: (launch: LaunchDescriptor, options: ProbeOptions) => Promise<McpInspection>;
   callTool?: (
     launch: LaunchDescriptor,
@@ -57,13 +57,14 @@ export interface ContextModeHandlerDependencies {
   ) => Promise<IntegrationAudit>;
 }
 
-type HandlerContext = { paseo?: ProviderConfigSource };
-
 export interface ContextModeHandlers {
-  status(input: ContextModeRefreshInput, context?: HandlerContext): Promise<BinaryStatus>;
-  doctor(input: ContextModeRefreshInput, context?: HandlerContext): Promise<CommandReport>;
-  stats(input: ContextModeRefreshInput, context?: HandlerContext): Promise<CommandReport>;
-  audit(input: ContextModeRefreshInput, context?: HandlerContext): Promise<IntegrationAudit>;
+  status(input: ContextModeRefreshInput): Promise<BinaryStatus>;
+  doctor(input: ContextModeRefreshInput): Promise<CommandReport>;
+  stats(input: ContextModeRefreshInput): Promise<CommandReport>;
+  audit(
+    input: ContextModeRefreshInput,
+    context?: { paseo?: ProviderConfigSource },
+  ): Promise<IntegrationAudit>;
 }
 
 interface CacheEntry<T> {
@@ -92,7 +93,7 @@ export function createContextModeHandlers(
   const cache = new Map<string, CacheEntry<BinaryStatus | CommandReport>>();
   const probe = contextModeProbeOptions();
 
-  async function settingsAndBinary(paseo: ProviderConfigSource | undefined): Promise<
+  async function settingsAndBinary(): Promise<
     | {
         state: "ready";
         settings: ContextModeSettings;
@@ -114,7 +115,7 @@ export function createContextModeHandlers(
           },
         };
       }
-      const binary = await resolveBinary(settings.values, { paseo });
+      const binary = await resolveBinary(settings.values);
       if (binary.state === "missing") {
         return {
           state: "unavailable",
@@ -158,11 +159,8 @@ export function createContextModeHandlers(
     return result;
   }
 
-  async function status(
-    { fresh }: ContextModeRefreshInput,
-    context?: HandlerContext,
-  ): Promise<BinaryStatus> {
-    const resolved = await settingsAndBinary(context?.paseo);
+  async function status({ fresh }: ContextModeRefreshInput): Promise<BinaryStatus> {
+    const resolved = await settingsAndBinary();
     if (resolved.state === "unavailable") return resolved.report;
     const cacheKey = `status:${resolved.binary.source}:${resolved.binary.path}`;
     return cached(cacheKey, 10_000, fresh, async () => {
@@ -184,13 +182,8 @@ export function createContextModeHandlers(
     });
   }
 
-  async function report(
-    name: ToolName,
-    ttlMs: number,
-    fresh: boolean,
-    context: HandlerContext | undefined,
-  ): Promise<CommandReport> {
-    const resolved = await settingsAndBinary(context?.paseo);
+  async function report(name: ToolName, ttlMs: number, fresh: boolean): Promise<CommandReport> {
+    const resolved = await settingsAndBinary();
     if (resolved.state === "unavailable") return resolved.report;
     return cached(`${name}:${resolved.binary.path}`, ttlMs, fresh, async () => {
       const checkedAt = now().toISOString();
@@ -209,9 +202,9 @@ export function createContextModeHandlers(
 
   async function audit(
     _input: ContextModeRefreshInput,
-    context?: HandlerContext,
+    context?: { paseo?: ProviderConfigSource },
   ): Promise<IntegrationAudit> {
-    const resolved = await settingsAndBinary(context?.paseo);
+    const resolved = await settingsAndBinary();
     if (resolved.state === "unavailable") {
       return {
         runtimePath: "",
@@ -234,8 +227,8 @@ export function createContextModeHandlers(
 
   return {
     status,
-    doctor: ({ fresh }, context) => report("ctx_doctor", 10_000, fresh, context),
-    stats: ({ fresh }, context) => report("ctx_stats", 5_000, fresh, context),
+    doctor: ({ fresh }) => report("ctx_doctor", 10_000, fresh),
+    stats: ({ fresh }) => report("ctx_stats", 5_000, fresh),
     audit,
   };
 }

package/server/integration.ts

@@ -63,7 +63,7 @@ export type ProviderOverrides = Readonly<
 
 /** Structural slice of the hook/RPC `paseo` API; avoids a client-package import. */
 export interface ProviderConfigSource {
-  config: { get(): Promise<{ config: { providers?: unknown; plugins?: unknown } }> };
+  config: { get(): Promise<{ config: { providers?: unknown } }> };
 }
 
 /**
@@ -483,7 +483,7 @@ export async function injectContextModeOnCreate<T extends CreateRequest>(
     type: "stdio",
     command: launch.program,
     args: launch.args,
-    env: { ...serverEnvironment(policy, storageRoot, request.env), ...launch.env },
+    env: serverEnvironment(policy, storageRoot, request.env),
   };
   return {
     ...request,

package/server/knowledge.ts

@@ -10,8 +10,8 @@ import type {
   PurgeKnowledgeInput,
   SearchKnowledgeInput,
 } from "../shared/knowledge";
-import type { contextModeSettings } from "../shared/settings";
-import { type LaunchDescriptor, resolveContextModeBinary } from "./binary";
+import type { ContextModeSettings, contextModeSettings } from "../shared/settings";
+import { type BinaryResolution, type LaunchDescriptor, resolveContextModeBinary } from "./binary";
 import {
   contextModeStorageRootFor,
   type ProviderConfigSource,
@@ -37,7 +37,7 @@ type KnowledgeToolCaller = (
 
 export interface KnowledgeHandlerDependencies {
   now?: () => Date;
-  resolveBinary?: typeof resolveContextModeBinary;
+  resolveBinary?: (settings: ContextModeSettings) => Promise<BinaryResolution>;
   callTool?: KnowledgeToolCaller;
 }
 
@@ -99,14 +99,12 @@ export function createContextModeKnowledgeHandlers(
   const resolveBinary = dependencies.resolveBinary ?? resolveContextModeBinary;
   const callTool = dependencies.callTool ?? callContextModeTool;
 
-  async function launchDescriptor(
-    paseo: ProviderConfigSource | undefined,
-  ): Promise<LaunchDescriptor> {
+  async function launchDescriptor(): Promise<LaunchDescriptor> {
     const settings = await settingsHandle.read();
     if (settings.status !== "ready") {
       throw new Error(`Context Mode settings are invalid: ${settings.error}`.slice(0, 4_096));
     }
-    const binary = await resolveBinary(settings.values, { paseo });
+    const binary = await resolveBinary(settings.values);
     if (binary.state === "missing") throw new Error(binary.message.slice(0, 4_096));
     return binary.launch;
   }
@@ -119,7 +117,7 @@ export function createContextModeKnowledgeHandlers(
     context: KnowledgeContext | undefined,
     environmentOverrides: NodeJS.ProcessEnv = {},
   ): Promise<KnowledgeToolResult> {
-    const launch = await launchDescriptor(context?.paseo);
+    const launch = await launchDescriptor();
     const providers = await readProviderOverrides(context?.paseo);
     const output = await callTool(launch, name, arguments_, {
       env: {

package/server/mcp-process.ts

@@ -125,10 +125,7 @@ async function exchange(
       stdio: ["pipe", "pipe", "pipe"],
       windowsHide: true,
       cwd: dependencies.cwd,
-      env:
-        launch.env || dependencies.env
-          ? { ...process.env, ...launch.env, ...dependencies.env }
-          : undefined,
+      env: dependencies.env ? { ...process.env, ...dependencies.env } : undefined,
     });
   } catch (error) {
     throw new ProcessFailure(