@omercnet/paseo-context-mode 3.1.1-next.332.1 → 3.1.1-next.353.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);
+    const binary = await resolveContextModeBinary(current.values, { paseo });
     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.332.1",
+  "version": "3.1.1-next.353.1",
   "type": "module",
   "description": "Provider-aware Context Mode health, savings, and MCP activation for Paseo.",
   "license": "MIT",

package/server/actions.ts

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

package/server/binary.ts

@@ -1,12 +1,14 @@
 import { constants } from "node:fs";
-import { access, realpath, stat } from "node:fs/promises";
+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 type { ProviderConfigSource } from "./integration";
 
 export interface LaunchDescriptor {
   program: string;
   args: string[];
+  env?: Record<string, string>;
 }
 
 export type BinaryResolution =
@@ -22,9 +24,32 @@ export interface BinaryResolutionDependencies {
   env?: NodeJS.ProcessEnv;
   platform?: NodeJS.Platform;
   nodePath?: string;
+  electron?: boolean;
   canExecute?: (path: string) => Promise<boolean>;
   isFile?: (path: string) => Promise<boolean>;
-  bundledCliPath?: () => string | null;
+  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;
 }
 
 async function defaultIsFile(path: string): Promise<boolean> {
@@ -141,25 +166,21 @@ export async function resolveContextModeBinary(
     }
   }
 
-  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 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;
     return {
       state: "found",
       path: canonicalPath,
       source: "bundled",
-      launch: { program: nodePath, args: [canonicalPath] },
+      launch: {
+        program: nodePath,
+        args: [canonicalPath],
+        ...(electron ? { env: { ELECTRON_RUN_AS_NODE: "1" } } : {}),
+      },
     };
   }
 

package/server/handlers.ts

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

package/server/knowledge.ts

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

package/server/mcp-process.ts

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