@omercnet/paseo-context-mode 0.0.0-next.127.2

package/client/settings-screen.tsx

@@ -0,0 +1,226 @@
+import { type PluginSurfaceProps, type SettingsState, useSettings } from "@getpaseo/plugin/client";
+import {
+  SettingsAction,
+  SettingsCard,
+  SettingsInput,
+  SettingsRow,
+  SettingsSection,
+  SettingsSelect,
+  SettingsSwitch,
+} from "@getpaseo/plugin/client/ui";
+import { useCallback, useMemo, useState } from "react";
+import { Text, View } from "react-native";
+import {
+  type ContextModeSettings,
+  ContextModeSettingsSchema,
+  contextModeSettings,
+} from "../shared";
+
+type ReadySettings = Extract<SettingsState<typeof contextModeSettings.schema>, { status: "ready" }>;
+
+const binaryModeOptions = [
+  { label: "Configured path, PATH, then bundled", value: "path" },
+  { label: "PATH, then bundled", value: "automatic" },
+];
+const refreshOptions = [
+  { label: "5 seconds", value: "5000" },
+  { label: "15 seconds", value: "15000" },
+  { label: "30 seconds", value: "30000" },
+  { label: "60 seconds", value: "60000" },
+];
+
+function ReadyContextModeSettings({
+  settings,
+  theme,
+}: {
+  settings: ReadySettings;
+  theme: PluginSurfaceProps["theme"];
+}) {
+  const [binaryPath, setBinaryPath] = useState(settings.values.binaryPath);
+  const styles = useMemo(
+    () => ({
+      root: { gap: 16 },
+      value: { color: theme.colors.foreground },
+      muted: { color: theme.colors.foregroundMuted },
+      error: { color: theme.colors.statusDanger },
+    }),
+    [theme],
+  );
+  const save = useCallback(
+    (patch: Partial<ContextModeSettings>) =>
+      settings.save({ ...settings.values, ...patch }, settings.revision),
+    [settings],
+  );
+  const normalizedPath = binaryPath.trim();
+  const pathResult = ContextModeSettingsSchema.safeParse({
+    ...settings.values,
+    binaryMode: "path",
+    binaryPath: normalizedPath,
+  });
+  const pathError = pathResult.success
+    ? null
+    : (pathResult.error.issues[0]?.message ?? "Enter an absolute executable path.");
+
+  return (
+    <View style={styles.root}>
+      <SettingsSection
+        title="Executable"
+        info="The daemon checks a configured absolute path first, then PATH, then the bundled runtime."
+      >
+        <SettingsCard>
+          <SettingsSelect
+            label="Binary lookup"
+            value={settings.values.binaryMode}
+            options={binaryModeOptions}
+            disabled={settings.saving}
+            onValueChange={(binaryMode) =>
+              void save({ binaryMode: binaryMode as ContextModeSettings["binaryMode"] })
+            }
+          />
+          <SettingsInput
+            label="Absolute binary path"
+            hint="Optional external override. Leave empty to use PATH or the bundled runtime."
+            error={normalizedPath === settings.values.binaryPath ? null : pathError}
+            initialValue={binaryPath}
+            onChangeText={setBinaryPath}
+            placeholder="/usr/local/bin/context-mode"
+            disabled={settings.saving || settings.values.binaryMode === "automatic"}
+          />
+          <SettingsAction
+            label="Save binary path"
+            actionLabel="Save"
+            disabled={
+              settings.saving ||
+              settings.values.binaryMode === "automatic" ||
+              normalizedPath === settings.values.binaryPath ||
+              !pathResult.success
+            }
+            onPress={() => void save({ binaryPath: normalizedPath })}
+          />
+        </SettingsCard>
+      </SettingsSection>
+
+      <SettingsSection
+        title="Agent activation"
+        info="Context Mode is added to supported Paseo agents when their sessions are created."
+      >
+        <SettingsCard>
+          <SettingsSwitch
+            label="Automatically activate Context Mode"
+            hint="Inject the bundled MCP server into new agents and provider-specific storage variables whenever sessions open."
+            value={settings.values.autoInject}
+            disabled={settings.saving}
+            onValueChange={(autoInject) => void save({ autoInject })}
+          />
+          <SettingsSwitch
+            label="Prefer native integrations"
+            hint="Keep OMP, Pi, and OpenCode native plugins when detected instead of registering duplicate MCP tools."
+            value={settings.values.preferNativeIntegrations}
+            disabled={settings.saving || !settings.values.autoInject}
+            onValueChange={(preferNativeIntegrations) => void save({ preferNativeIntegrations })}
+          />
+        </SettingsCard>
+      </SettingsSection>
+
+      <SettingsSection title="Display">
+        <SettingsCard>
+          <SettingsSelect
+            label="Refresh interval"
+            value={String(settings.values.refreshIntervalMs)}
+            options={refreshOptions}
+            disabled={settings.saving}
+            onValueChange={(value) =>
+              void save({
+                refreshIntervalMs: Number(value) as ContextModeSettings["refreshIntervalMs"],
+              })
+            }
+          />
+        </SettingsCard>
+      </SettingsSection>
+
+      <SettingsSection title="Safety">
+        <SettingsCard>
+          <SettingsRow
+            label="Storage reuse"
+            hint="Existing provider-specific Context Mode roots are reused. Session databases are never merged across providers."
+          >
+            <Text style={styles.value}>Provider scoped</Text>
+          </SettingsRow>
+          <SettingsRow label="Context Mode runtime">
+            <Text style={styles.muted}>Bundled with this Paseo plugin</Text>
+          </SettingsRow>
+          <SettingsRow label="Upgrades">
+            <Text style={styles.muted}>Explicit command only</Text>
+          </SettingsRow>
+        </SettingsCard>
+      </SettingsSection>
+
+      <SettingsSection title="Persistence">
+        <SettingsCard>
+          <SettingsRow label="Settings" hint="Shared by clients connected to this host">
+            <Text style={styles.value}>{settings.saving ? "Saving…" : "Saved on host"}</Text>
+          </SettingsRow>
+          <SettingsAction
+            label="Restore defaults"
+            actionLabel="Reset"
+            disabled={settings.saving}
+            onPress={() => void settings.reset()}
+          />
+          {settings.saveError ? (
+            <SettingsAction
+              label="Reload saved values"
+              error={settings.saveError}
+              actionLabel="Reload"
+              disabled={settings.saving}
+              onPress={settings.reload}
+            />
+          ) : null}
+        </SettingsCard>
+        {settings.saveError ? (
+          <Text accessibilityRole="alert" style={styles.error}>
+            {settings.saveError}
+          </Text>
+        ) : null}
+      </SettingsSection>
+    </View>
+  );
+}
+
+export function ContextModeSettingsScreen({ theme }: PluginSurfaceProps) {
+  const settings = useSettings(contextModeSettings);
+  const styles = useMemo(
+    () => ({
+      text: { color: theme.colors.foreground },
+      error: { color: theme.colors.statusDanger },
+    }),
+    [theme],
+  );
+
+  if (settings.status === "loading") return <Text style={styles.text}>Loading settings…</Text>;
+  if (settings.status !== "ready") {
+    return (
+      <SettingsSection title="Context Mode settings">
+        <Text accessibilityRole="alert" style={styles.error}>
+          {settings.error}
+        </Text>
+        <SettingsCard>
+          <SettingsAction
+            label="Read settings again"
+            actionLabel="Reload"
+            onPress={settings.reload}
+          />
+          {settings.status === "invalid" ? (
+            <SettingsAction
+              label="Replace invalid data with defaults"
+              actionLabel="Reset"
+              disabled={settings.saving}
+              onPress={() => void settings.reset()}
+            />
+          ) : null}
+        </SettingsCard>
+      </SettingsSection>
+    );
+  }
+
+  return <ReadyContextModeSettings key={settings.revision} settings={settings} theme={theme} />;
+}

package/index.client.tsx

@@ -0,0 +1,43 @@
+import type { PluginClientContext, PluginSurfaceProps } from "@getpaseo/plugin/client";
+import { contributeContextModeComposerPills } from "./client/context-mode-pill";
+import { ContextModeSurface } from "./client/context-mode-surface";
+import { ContextModeSettingsScreen } from "./client/settings-screen";
+
+export default function contribute(client: PluginClientContext) {
+  function Surface(props: PluginSurfaceProps) {
+    return (
+      <ContextModeSurface {...props} onOpenSettings={() => client.openSettings("context-mode")} />
+    );
+  }
+
+  const cleanups = [
+    contributeContextModeComposerPills(client),
+    client.addSettingsScreen({
+      id: "context-mode",
+      title: "Context Mode settings",
+      icon: "Settings",
+      Component: ContextModeSettingsScreen,
+    }),
+    client.addSurface("context-mode", Surface),
+    client.addSidebarItem({
+      id: "context-mode",
+      title: "Context Mode",
+      icon: "Gauge",
+      surface: "context-mode",
+    }),
+    client.addCommandCenterItem({
+      id: "open-context-mode",
+      title: "Open Context Mode",
+      icon: "Gauge",
+      keywords: ["context", "savings", "tokens", "knowledge", "search", "doctor", "health"],
+      context: "global",
+      onSelect({ openSurface }) {
+        openSurface("context-mode");
+      },
+    }),
+  ];
+
+  return () => {
+    for (const cleanup of cleanups.reverse()) cleanup();
+  };
+}

package/index.server.ts

@@ -0,0 +1,54 @@
+import type { PluginServerContext } from "@getpaseo/plugin/server";
+import { createContextModeActionHandlers } from "./server/actions";
+import { createContextModeAnalyticsHandler } from "./server/analytics";
+import { resolveContextModeBinary } from "./server/binary";
+import { createContextModeHandlers } from "./server/handlers";
+import { injectContextModeEnvironment, injectContextModeOnCreate } from "./server/integration";
+import { createContextModeKnowledgeHandlers } from "./server/knowledge";
+import {
+  contextModeSettings,
+  fetchAndIndexContextMode,
+  getContextModeAnalyticsDashboard,
+  getContextModeDoctor,
+  getContextModeDoctorReport,
+  getContextModeInstallAction,
+  getContextModeIntegrationAudit,
+  getContextModeStats,
+  getContextModeStatus,
+  getContextModeUpgradeAction,
+  indexContextModePath,
+  purgeContextModeKnowledge,
+  searchContextModeKnowledge,
+} from "./shared";
+
+export default function contribute(server: PluginServerContext) {
+  const settings = server.registerSettings(contextModeSettings);
+  const handlers = createContextModeHandlers(settings);
+  const knowledgeHandlers = createContextModeKnowledgeHandlers(settings);
+  const actionHandlers = createContextModeActionHandlers(settings);
+  server.handle(getContextModeStatus, handlers.status);
+  server.handle(getContextModeDoctor, handlers.doctor);
+  server.handle(getContextModeStats, handlers.stats);
+  server.handle(getContextModeIntegrationAudit, handlers.audit);
+  server.handle(getContextModeAnalyticsDashboard, createContextModeAnalyticsHandler());
+  server.handle(searchContextModeKnowledge, knowledgeHandlers.search);
+  server.handle(indexContextModePath, knowledgeHandlers.indexPath);
+  server.handle(fetchAndIndexContextMode, knowledgeHandlers.fetchAndIndex);
+  server.handle(purgeContextModeKnowledge, knowledgeHandlers.purge);
+  server.handle(getContextModeDoctorReport, actionHandlers.doctor);
+  server.handle(getContextModeInstallAction, actionHandlers.install);
+  server.handle(getContextModeUpgradeAction, actionHandlers.upgrade);
+  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;
+    return injectContextModeOnCreate(request, current.values, binary.launch);
+  });
+  server.before("agent.session_open", async ({ request }) => {
+    const current = await settings.read();
+    if (current.status !== "ready") return request;
+    return injectContextModeEnvironment(request, current.values);
+  });
+  return () => {};
+}

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@omercnet/paseo-context-mode",
+  "version": "0.0.0-next.127.2",
+  "type": "module",
+  "description": "Provider-aware Context Mode health, savings, and MCP activation for Paseo.",
+  "license": "MIT",
+  "author": "Omer Cohen",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/omercnet/paseo-plugins.git",
+    "directory": "context-mode"
+  },
+  "homepage": "https://github.com/omercnet/paseo-plugins/tree/main/context-mode#readme",
+  "bugs": {
+    "url": "https://github.com/omercnet/paseo-plugins/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "packageManager": "npm@11.19.1",
+  "engines": {
+    "node": ">=24"
+  },
+  "keywords": [
+    "paseo",
+    "paseo-plugin",
+    "context-mode",
+    "context-window",
+    "developer-tools"
+  ],
+  "files": [
+    "LICENSE",
+    "NOTICE",
+    "README.md",
+    "index.client.tsx",
+    "index.server.ts",
+    "client",
+    "server",
+    "shared",
+    "paseo-plugin.json"
+  ],
+  "scripts": {
+    "check": "biome check .",
+    "check:write": "biome check --write .",
+    "lint": "biome check .",
+    "format:check": "biome check .",
+    "test": "vitest run",
+    "test:unit": "vitest run",
+    "test:coverage": "vitest run --coverage --coverage.reporter=text --coverage.reporter=lcov --coverage.thresholds.lines=90 --coverage.thresholds.functions=85",
+    "typecheck": "tsc --noEmit -p tsconfig.client.json && tsc --noEmit -p tsconfig.server.json",
+    "verify:package": "node scripts/verify-package.mjs"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.5.10",
+    "@getpaseo/cli": "0.9.0-beta.1",
+    "@getpaseo/client": "0.9.0-beta.1",
+    "@getpaseo/plugin": "0.9.0-beta.1",
+    "@getpaseo/protocol": "0.9.0-beta.1",
+    "@tanstack/react-query": "^5.102.3",
+    "@types/node": "^24.5.2",
+    "@types/react": "^19.2.18",
+    "@vitest/coverage-v8": "^5.0.0",
+    "react": "19.1.0",
+    "react-native": "0.81.5",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.0",
+    "zod": "^4.4.3"
+  },
+  "dependencies": {
+    "context-mode": "1.0.169"
+  }
+}

package/paseo-plugin.json

@@ -0,0 +1,5 @@
+{
+  "id": "context-mode",
+  "description": "Provider-aware Context Mode health, savings, and MCP activation for Paseo.",
+  "requirements": { "paseo": ">=0.9.0-beta.1 <0.10.0" }
+}

package/server/actions.ts

@@ -0,0 +1,146 @@
+import type { PluginSettings } from "@getpaseo/plugin/server";
+import {
+  CONTEXT_MODE_TARGET_VERSION,
+  type ContextModeAction,
+  type ContextModeActionInput,
+  type DoctorReport,
+  type DoctorStatusRow,
+} from "../shared/actions";
+import type { ContextModeSettings, contextModeSettings } from "../shared/settings";
+import { type BinaryResolution, type LaunchDescriptor, resolveContextModeBinary } from "./binary";
+import { contextModeEnvironmentFor, contextModePlatformFor } from "./knowledge";
+import {
+  callContextModeTool,
+  inspectContextMode,
+  type McpInspection,
+  type McpProcessDependencies,
+  type McpToolArguments,
+} from "./mcp-process";
+
+type SettingsHandle = PluginSettings<typeof contextModeSettings.schema>;
+
+type ActionToolCaller = (
+  launch: LaunchDescriptor,
+  name: "ctx_doctor",
+  arguments_: McpToolArguments,
+  dependencies: McpProcessDependencies,
+) => Promise<string>;
+
+export interface ActionHandlerDependencies {
+  osPlatform?: NodeJS.Platform;
+  resolveBinary?: (settings: ContextModeSettings) => Promise<BinaryResolution>;
+  inspect?: (
+    launch: LaunchDescriptor,
+    dependencies?: McpProcessDependencies,
+  ) => Promise<McpInspection>;
+  callTool?: ActionToolCaller;
+}
+
+export interface ContextModeActionHandlers {
+  doctor(input: ContextModeActionInput): Promise<DoctorReport>;
+  install(input: ContextModeActionInput): Promise<ContextModeAction>;
+  upgrade(input: ContextModeActionInput): Promise<ContextModeAction>;
+}
+
+export function parseContextModeDoctorOutput(rawOutput: string): DoctorStatusRow[] {
+  const rows: DoctorStatusRow[] = [];
+  for (const line of rawOutput.split(/\r?\n/)) {
+    const match = /^\[(OK|WARN|FAIL)\]\s+(.+)$/.exec(line.trim());
+    if (!match) continue;
+    const body = match[2] ?? "";
+    const separator = body.indexOf(":");
+    const check = (separator < 0 ? body : body.slice(0, separator)).trim().slice(0, 256);
+    if (!check) continue;
+    const detail = (separator < 0 ? "" : body.slice(separator + 1).trim()).slice(0, 4_096);
+    rows.push({
+      status: match[1] === "OK" ? "ok" : match[1] === "WARN" ? "warning" : "error",
+      check,
+      detail,
+    });
+    if (rows.length === 64) break;
+  }
+  return rows;
+}
+
+export function createContextModeActionHandlers(
+  settingsHandle: SettingsHandle,
+  dependencies: ActionHandlerDependencies = {},
+): ContextModeActionHandlers {
+  const resolveBinary = dependencies.resolveBinary ?? resolveContextModeBinary;
+  const inspect = dependencies.inspect ?? inspectContextMode;
+  const callTool = dependencies.callTool ?? callContextModeTool;
+  const osPlatform = dependencies.osPlatform ?? process.platform;
+
+  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);
+    if (binary.state === "missing") throw new Error(binary.message.slice(0, 4_096));
+    return binary;
+  }
+
+  async function currentVersion(input: ContextModeActionInput): Promise<string | null> {
+    try {
+      const binary = await resolvedBinary();
+      const inspection = await inspect(binary.launch, {
+        env: contextModeEnvironmentFor(input.provider),
+      });
+      return inspection.version?.slice(0, 128) ?? null;
+    } catch {
+      return null;
+    }
+  }
+
+  return {
+    async doctor(input) {
+      const binary = await resolvedBinary();
+      const rawOutput = await callTool(
+        binary.launch,
+        "ctx_doctor",
+        {},
+        {
+          env: contextModeEnvironmentFor(input.provider),
+        },
+      );
+      return {
+        platform: contextModePlatformFor(input.provider),
+        rows: parseContextModeDoctorOutput(rawOutput),
+        rawOutput,
+      };
+    },
+    async install(input) {
+      const platform = contextModePlatformFor(input.provider);
+      return {
+        program: osPlatform === "win32" ? "npm.cmd" : "npm",
+        args: [
+          "install",
+          "-g",
+          `context-mode@${CONTEXT_MODE_TARGET_VERSION}`,
+          "--no-audit",
+          "--no-fund",
+        ],
+        currentVersion: await currentVersion(input),
+        targetVersion: CONTEXT_MODE_TARGET_VERSION,
+        platform,
+        requiresRestart: true,
+      };
+    },
+    async upgrade(input) {
+      const platform = contextModePlatformFor(input.provider);
+      const binary = await resolvedBinary();
+      const inspection = await inspect(binary.launch, {
+        env: contextModeEnvironmentFor(input.provider),
+      });
+      return {
+        program: binary.launch.program,
+        args: [...binary.launch.args, "upgrade", "--platform", platform],
+        currentVersion: inspection.version?.slice(0, 128) ?? null,
+        targetVersion: "latest",
+        platform,
+        requiresRestart: true,
+      };
+    },
+  };
+}