@omercnet/paseo-context-mode 1.2.3-next.233.1 → 1.2.3

package/index.server.ts

@@ -3,11 +3,7 @@ import { createContextModeActionHandlers } from "./server/actions";
 import { createContextModeAnalyticsHandler } from "./server/analytics";
 import { resolveContextModeBinary } from "./server/binary";
 import { createContextModeHandlers } from "./server/handlers";
-import {
-  injectContextModeEnvironment,
-  injectContextModeOnCreate,
-  readProviderOverrides,
-} from "./server/integration";
+import { injectContextModeEnvironment, injectContextModeOnCreate } from "./server/integration";
 import { createContextModeKnowledgeHandlers } from "./server/knowledge";
 import {
   contextModeSettings,
@@ -42,19 +38,17 @@ export default function contribute(server: PluginServerContext) {
   server.handle(getContextModeDoctorReport, actionHandlers.doctor);
   server.handle(getContextModeInstallAction, actionHandlers.install);
   server.handle(getContextModeUpgradeAction, actionHandlers.upgrade);
-  server.before("agent.create", async ({ request }, { paseo }) => {
+  server.before("agent.create", async ({ request }) => {
     const current = await settings.read();
     if (current.status !== "ready") return request;
     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 });
+    return injectContextModeOnCreate(request, current.values, binary.launch);
   });
-  server.before("agent.session_open", async ({ request }, { paseo }) => {
+  server.before("agent.session_open", async ({ request }) => {
     const current = await settings.read();
     if (current.status !== "ready") return request;
-    const providers = await readProviderOverrides(paseo);
-    return injectContextModeEnvironment(request, current.values, { providers });
+    return injectContextModeEnvironment(request, current.values);
   });
   return () => {};
 }

package/package.json

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

package/server/handlers.ts

@@ -8,12 +8,7 @@ import type {
   IntegrationAudit,
 } from "../shared";
 import { type BinaryResolution, type LaunchDescriptor, resolveContextModeBinary } from "./binary";
-import {
-  createIntegrationAudit,
-  type IntegrationDependencies,
-  type ProviderConfigSource,
-  readProviderOverrides,
-} from "./integration";
+import { createIntegrationAudit } from "./integration";
 import {
   callContextModeTool,
   inspectContextMode,
@@ -33,7 +28,6 @@ export interface ContextModeHandlerDependencies {
   createAudit?: (
     settings: ContextModeSettings,
     runtime: { path: string; version: string | null },
-    dependencies?: IntegrationDependencies,
   ) => Promise<IntegrationAudit>;
 }
 
@@ -41,10 +35,7 @@ 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>;
+  audit(input: ContextModeRefreshInput): Promise<IntegrationAudit>;
 }
 
 interface CacheEntry<T> {
@@ -179,10 +170,7 @@ export function createContextModeHandlers(
     });
   }
 
-  async function audit(
-    _input: ContextModeRefreshInput,
-    context?: { paseo?: ProviderConfigSource },
-  ): Promise<IntegrationAudit> {
+  async function audit(_input: ContextModeRefreshInput): Promise<IntegrationAudit> {
     const resolved = await settingsAndBinary();
     if (resolved.state === "unavailable") {
       return {
@@ -197,11 +185,10 @@ export function createContextModeHandlers(
       version: null,
       tools: [],
     }));
-    return buildAudit(
-      resolved.settings,
-      { path: resolved.binary.path, version: inspection.version },
-      { providers: await readProviderOverrides(context?.paseo) },
-    );
+    return buildAudit(resolved.settings, {
+      path: resolved.binary.path,
+      version: inspection.version,
+    });
   }
 
   return {

package/server/integration.ts

@@ -54,52 +54,6 @@ export interface IntegrationDependencies {
   fileContains?: (path: string, text: string) => Promise<boolean>;
   now?: () => Date;
   env?: NodeJS.ProcessEnv;
-  providers?: ProviderOverrides;
-}
-
-export type ProviderOverrides = Readonly<
-  Record<string, { extends?: string; env?: Readonly<Record<string, string>> }>
->;
-
-/** Structural slice of the hook/RPC `paseo` API; avoids a client-package import. */
-export interface ProviderConfigSource {
-  config: { get(): Promise<{ config: { providers?: unknown } }> };
-}
-
-/**
- * Reads `agents.providers` from the daemon. Paseo applies a provider's own `env` and `extends`
- * after the `agent.create` hook runs, so the hooks must look them up to find the right storage.
- * Failures degrade to "no overrides" (canonical provider behavior).
- */
-export async function readProviderOverrides(
-  paseo: ProviderConfigSource | undefined,
-): Promise<ProviderOverrides> {
-  try {
-    const { config } = (await paseo?.config.get()) ?? {};
-    const entries: Array<[string, { extends?: string; env?: Record<string, string> }]> = [];
-    for (const [id, value] of Object.entries(config?.providers ?? {})) {
-      if (typeof value !== "object" || value === null) continue;
-      const { extends: parent, env } = value as { extends?: unknown; env?: unknown };
-      entries.push([
-        id,
-        {
-          ...(typeof parent === "string" ? { extends: parent } : {}),
-          ...(typeof env === "object" && env !== null && !Array.isArray(env)
-            ? {
-                env: Object.fromEntries(
-                  Object.entries(env).filter(
-                    (entry): entry is [string, string] => typeof entry[1] === "string",
-                  ),
-                ),
-              }
-            : {}),
-        },
-      ]);
-    }
-    return Object.fromEntries(entries);
-  } catch {
-    return {};
-  }
 }
 
 export interface ContextModeStorageOptions {
@@ -287,23 +241,7 @@ const PROVIDER_POLICIES: Readonly<Record<Exclude<AuditedProvider, "omp-plugin">,
 
 function providerPolicy(provider: string): ProviderPolicy | null {
   if (provider === "omp-plugin" || provider.startsWith("omp-plugin-")) return OMP_POLICY;
-  return Object.hasOwn(PROVIDER_POLICIES, provider)
-    ? PROVIDER_POLICIES[provider as keyof typeof PROVIDER_POLICIES]
-    : null;
-}
-
-/**
- * Mirrors Paseo's single-level `extends`: a derived provider uses its parent's policy, and its
- * effective env is the parent's override env overlaid with its own.
- */
-function resolveProvider(
-  id: string,
-  providers: ProviderOverrides = {},
-): { base: string; policy: ProviderPolicy | null; env: Record<string, string> } {
-  const own = Object.hasOwn(providers, id) ? providers[id] : undefined;
-  const base = own?.extends ?? id;
-  const parent = base !== id && Object.hasOwn(providers, base) ? providers[base] : undefined;
-  return { base, policy: providerPolicy(base), env: { ...parent?.env, ...own?.env } };
+  return PROVIDER_POLICIES[provider as keyof typeof PROVIDER_POLICIES] ?? null;
 }
 
 async function defaultPathExists(path: string): Promise<boolean> {
@@ -384,40 +322,24 @@ export async function createIntegrationAudit(
   const pathExists = dependencies.pathExists ?? defaultPathExists;
   const fileContains = dependencies.fileContains ?? defaultFileContains;
   const hostEnvironment = dependencies.env ?? process.env;
-  const nativeByPolicy = new Map<string, Promise<boolean>>();
-  const detectNative = (
-    policy: ProviderPolicy,
-    env: Readonly<Record<string, string | undefined>>,
-    key: string,
-  ) => {
-    const cacheKey = `${policy.platform}\0${key}`;
-    const existing = nativeByPolicy.get(cacheKey);
+  const context = providerContext(home, undefined, hostEnvironment);
+  const nativeByPolicy = new Map<ProviderPolicy, Promise<boolean>>();
+  const detectNative = (policy: ProviderPolicy) => {
+    const existing = nativeByPolicy.get(policy);
     if (existing) return existing;
-    const detected = nativeIntegrationDetected(
-      policy,
-      providerContext(home, undefined, env),
-      pathExists,
-      fileContains,
-    );
-    nativeByPolicy.set(cacheKey, detected);
+    const detected = nativeIntegrationDetected(policy, context, pathExists, fileContains);
+    nativeByPolicy.set(policy, detected);
     return detected;
   };
-  const configured = dependencies.providers ?? {};
-  const derived = Object.keys(configured).filter(
-    (id) => !(AUDITED_PROVIDERS as readonly string[]).includes(id),
-  );
   const providers: ProviderIntegration[] = [];
-  for (const provider of [...AUDITED_PROVIDERS, ...derived]) {
-    const { base, policy, env: providerEnv } = resolveProvider(provider, configured);
+  for (const provider of AUDITED_PROVIDERS) {
+    const policy = providerPolicy(provider);
     if (!policy) continue;
-    const env = { ...hostEnvironment, ...providerEnv };
-    const storageRoot = contextModeStorageRootFor(base, { home, env });
+    const storageRoot = contextModeStorageRootFor(provider, { home, env: hostEnvironment });
     if (!storageRoot) continue;
     const reusesExistingStorage = await pathExists(storageRoot);
     const native =
-      settings.autoInject &&
-      settings.preferNativeIntegrations &&
-      (await detectNative(policy, env, JSON.stringify(providerEnv)));
+      settings.autoInject && settings.preferNativeIntegrations && (await detectNative(policy));
     const activation = !settings.autoInject ? "disabled" : native ? "native" : "mcp";
     providers.push({
       provider,
@@ -455,35 +377,34 @@ export async function injectContextModeOnCreate<T extends CreateRequest>(
   ) {
     return request;
   }
-  const {
-    base,
-    policy,
-    env: providerEnv,
-  } = resolveProvider(request.config.provider, dependencies.providers);
+  const policy = providerPolicy(request.config.provider);
   if (!policy) return request;
   const home = dependencies.home ?? homedir();
   const hostEnvironment = dependencies.env ?? process.env;
   const pathExists = dependencies.pathExists ?? defaultPathExists;
   const fileContains = dependencies.fileContains ?? defaultFileContains;
-  const env = { ...hostEnvironment, ...providerEnv, ...request.env };
+  const context = providerContext(home, request.config.cwd, {
+    ...hostEnvironment,
+    ...request.env,
+  });
   if (
     settings.preferNativeIntegrations &&
-    (await nativeIntegrationDetected(
-      policy,
-      providerContext(home, request.config.cwd, env),
-      pathExists,
-      fileContains,
-    ))
+    (await nativeIntegrationDetected(policy, context, pathExists, fileContains))
   ) {
     return request;
   }
-  const storageRoot = contextModeStorageRootFor(base, { home, cwd: request.config.cwd, env });
+  const storageRoot = contextModeStorageRootFor(request.config.provider, {
+    home,
+    cwd: request.config.cwd,
+    env: { ...hostEnvironment, ...request.env },
+  });
   if (!storageRoot) return request;
+  const env = serverEnvironment(policy, storageRoot, request.env);
   const server: McpServer = {
     type: "stdio",
     command: launch.program,
     args: launch.args,
-    env: serverEnvironment(policy, storageRoot, request.env),
+    env,
   };
   return {
     ...request,
@@ -500,18 +421,14 @@ export async function injectContextModeEnvironment<T extends SessionOpenRequest>
   dependencies: IntegrationDependencies = {},
 ): Promise<T> {
   if (!settings.autoInject) return request;
-  const {
-    base,
-    policy,
-    env: providerEnv,
-  } = resolveProvider(request.provider, dependencies.providers);
+  const policy = providerPolicy(request.provider);
   if (!policy) return request;
   const home = dependencies.home ?? homedir();
   const hostEnvironment = dependencies.env ?? process.env;
-  const storageRoot = contextModeStorageRootFor(base, {
+  const storageRoot = contextModeStorageRootFor(request.provider, {
     home,
     cwd: request.cwd,
-    env: { ...hostEnvironment, ...providerEnv, ...request.env },
+    env: { ...hostEnvironment, ...request.env },
   });
   if (!storageRoot) return request;
   return {