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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omercnet/paseo-context-mode",
-  "version": "1.2.2",
+  "version": "1.2.3-next.233.1",
   "type": "module",
   "description": "Provider-aware Context Mode health, savings, and MCP activation for Paseo.",
   "license": "MIT",
@@ -38,10 +38,11 @@
     "server",
     "shared",
     "paseo-plugin.json",
-    "OVERVIEW.md"
+    "OVERVIEW.md",
+    "npm-shrinkwrap.json"
   ],
   "scripts": {
-    "check": "biome check .",
+    "check": "biome check . && node ../scripts/shrinkwrap.mjs --check .",
     "check:write": "biome check --write .",
     "test": "vitest run",
     "test:unit": "vitest run",
@@ -51,10 +52,10 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^2.5.10",
-    "@getpaseo/cli": "0.11.0-beta.5",
-    "@getpaseo/client": "0.11.0-beta.5",
-    "@getpaseo/plugin": "0.11.0-beta.5",
-    "@getpaseo/protocol": "0.11.0-beta.5",
+    "@getpaseo/cli": "0.11.1",
+    "@getpaseo/client": "0.11.1",
+    "@getpaseo/plugin": "0.11.1",
+    "@getpaseo/protocol": "0.11.1",
     "@tanstack/react-query": "^5.102.3",
     "@types/node": "^24.10.1",
     "@types/react": "^19.2.18",

package/server/handlers.ts

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

package/server/integration.ts

@@ -54,6 +54,52 @@ 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 {
@@ -241,7 +287,23 @@ 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 PROVIDER_POLICIES[provider as keyof typeof PROVIDER_POLICIES] ?? null;
+  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 } };
 }
 
 async function defaultPathExists(path: string): Promise<boolean> {
@@ -322,24 +384,40 @@ export async function createIntegrationAudit(
   const pathExists = dependencies.pathExists ?? defaultPathExists;
   const fileContains = dependencies.fileContains ?? defaultFileContains;
   const hostEnvironment = dependencies.env ?? process.env;
-  const context = providerContext(home, undefined, hostEnvironment);
-  const nativeByPolicy = new Map<ProviderPolicy, Promise<boolean>>();
-  const detectNative = (policy: ProviderPolicy) => {
-    const existing = nativeByPolicy.get(policy);
+  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);
     if (existing) return existing;
-    const detected = nativeIntegrationDetected(policy, context, pathExists, fileContains);
-    nativeByPolicy.set(policy, detected);
+    const detected = nativeIntegrationDetected(
+      policy,
+      providerContext(home, undefined, env),
+      pathExists,
+      fileContains,
+    );
+    nativeByPolicy.set(cacheKey, 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) {
-    const policy = providerPolicy(provider);
+  for (const provider of [...AUDITED_PROVIDERS, ...derived]) {
+    const { base, policy, env: providerEnv } = resolveProvider(provider, configured);
     if (!policy) continue;
-    const storageRoot = contextModeStorageRootFor(provider, { home, env: hostEnvironment });
+    const env = { ...hostEnvironment, ...providerEnv };
+    const storageRoot = contextModeStorageRootFor(base, { home, env });
     if (!storageRoot) continue;
     const reusesExistingStorage = await pathExists(storageRoot);
     const native =
-      settings.autoInject && settings.preferNativeIntegrations && (await detectNative(policy));
+      settings.autoInject &&
+      settings.preferNativeIntegrations &&
+      (await detectNative(policy, env, JSON.stringify(providerEnv)));
     const activation = !settings.autoInject ? "disabled" : native ? "native" : "mcp";
     providers.push({
       provider,
@@ -377,34 +455,35 @@ export async function injectContextModeOnCreate<T extends CreateRequest>(
   ) {
     return request;
   }
-  const policy = providerPolicy(request.config.provider);
+  const {
+    base,
+    policy,
+    env: providerEnv,
+  } = resolveProvider(request.config.provider, dependencies.providers);
   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 context = providerContext(home, request.config.cwd, {
-    ...hostEnvironment,
-    ...request.env,
-  });
+  const env = { ...hostEnvironment, ...providerEnv, ...request.env };
   if (
     settings.preferNativeIntegrations &&
-    (await nativeIntegrationDetected(policy, context, pathExists, fileContains))
+    (await nativeIntegrationDetected(
+      policy,
+      providerContext(home, request.config.cwd, env),
+      pathExists,
+      fileContains,
+    ))
   ) {
     return request;
   }
-  const storageRoot = contextModeStorageRootFor(request.config.provider, {
-    home,
-    cwd: request.config.cwd,
-    env: { ...hostEnvironment, ...request.env },
-  });
+  const storageRoot = contextModeStorageRootFor(base, { home, cwd: request.config.cwd, env });
   if (!storageRoot) return request;
-  const env = serverEnvironment(policy, storageRoot, request.env);
   const server: McpServer = {
     type: "stdio",
     command: launch.program,
     args: launch.args,
-    env,
+    env: serverEnvironment(policy, storageRoot, request.env),
   };
   return {
     ...request,
@@ -421,14 +500,18 @@ export async function injectContextModeEnvironment<T extends SessionOpenRequest>
   dependencies: IntegrationDependencies = {},
 ): Promise<T> {
   if (!settings.autoInject) return request;
-  const policy = providerPolicy(request.provider);
+  const {
+    base,
+    policy,
+    env: providerEnv,
+  } = resolveProvider(request.provider, dependencies.providers);
   if (!policy) return request;
   const home = dependencies.home ?? homedir();
   const hostEnvironment = dependencies.env ?? process.env;
-  const storageRoot = contextModeStorageRootFor(request.provider, {
+  const storageRoot = contextModeStorageRootFor(base, {
     home,
     cwd: request.cwd,
-    env: { ...hostEnvironment, ...request.env },
+    env: { ...hostEnvironment, ...providerEnv, ...request.env },
   });
   if (!storageRoot) return request;
   return {