@omercnet/paseo-omp 0.2.1 → 0.3.0-next.92.1

package/server/provider/subsessions.ts

@@ -304,6 +304,7 @@ export class OmpSubsessionProjector {
     private readonly scheduler: OmpTimelineScheduler,
     private readonly onActivityChange: () => void,
     private readonly outputRedactionValues: readonly string[],
+    private readonly pluginTimelineEnabled = false,
   ) {
     this.dataFilter = new OmpPublicDataSerializer(outputRedactionValues);
   }
@@ -540,6 +541,8 @@ export class OmpSubsessionProjector {
         this.emit,
         this.scheduler,
         this.outputRedactionValues,
+        false,
+        this.pluginTimelineEnabled,
       ),
     };
     this.children.set(sessionId, child);
@@ -552,7 +555,7 @@ export class OmpSubsessionProjector {
       type: "session.opened",
       sessionId,
       parentSessionId,
-      capabilities: [],
+      capabilities: ["session.subsession"],
       restoration: "parent",
       cwd: this.cwd,
       title,

package/server/provider/timeline-projector.ts

@@ -4,8 +4,9 @@ import type {
   ProviderTimelineItem,
   ProviderToolCallDetail,
 } from "@getpaseo/plugin/server/provider";
+import { OMP_MCP_AUTH_TIMELINE_KIND } from "../../shared/mcp";
 import { isOmpImageMimeType, isValidImagePayload, type OmpImageMimeType } from "./image";
-import type { OmpMessage, OmpRpcEvent } from "./omp-rpc";
+import { OMP_MAX_CONTENT_PARTS, type OmpMessage, type OmpRpcEvent } from "./omp-rpc";
 import {
   boundedJsonBytes,
   type JsonValue,
@@ -15,7 +16,6 @@ import {
 } from "./security";
 
 const STREAM_FRAME_MS = 32;
-const MAX_STREAM_CONTENT_BLOCKS = 64;
 const MAX_STREAM_TEXT_LENGTH = 4 * 1024 * 1024;
 const MAX_ACTIVE_TOOLS = 64;
 const MAX_TODOS = 256;
@@ -54,6 +54,7 @@ type StreamSnapshot = {
   nativeIdentity?: string;
   published: boolean;
   retainedBytes: number;
+  textBytes: number;
   publishedBytes: number;
   blocks: Map<number, StreamBlockSnapshot>;
   dirtyBlocks: Set<number>;
@@ -196,6 +197,17 @@ function publishableHttpUrl(value: string | undefined): string | undefined {
     return undefined;
   }
 }
+function isOmpOAuthLaunchUrl(value: string | undefined): boolean {
+  const url = publishableHttpUrl(value);
+  if (!url) return false;
+  const parsed = new URL(url);
+  return (
+    (parsed.hostname === "localhost" ||
+      parsed.hostname === "127.0.0.1" ||
+      parsed.hostname === "[::1]") &&
+    parsed.pathname === "/launch"
+  );
+}
 
 function todoPublicId(nativeId: string | undefined, index: number): string {
   if (!nativeId) return `omp:todo:${index}`;
@@ -240,7 +252,7 @@ function nativeImageResult(
     boundedJsonBytes(
       value,
       MAX_NATIVE_IMAGE_RESULT_BYTES,
-      MAX_STREAM_CONTENT_BLOCKS,
+      OMP_MAX_CONTENT_PARTS,
       8 * 1024 * 1024,
       512,
     ) === Number.POSITIVE_INFINITY
@@ -350,6 +362,7 @@ export class OmpTimelineProjector {
   private readonly replayCandidates = new Map<string, ReplayCandidate>();
   private readonly replayOverflowCandidates = new Map<string, string>();
   private projectingReplay = false;
+  private readonly replayToolCalls = new Map<string, { toolName: string; args: unknown }>();
   private customSequence = 0;
   private compactionSequence = 0;
   private activeCompaction: CompactionSlot | null = null;
@@ -366,6 +379,7 @@ export class OmpTimelineProjector {
   private closed = false;
 
   private readonly dataFilter: OmpPublicDataSerializer;
+  private browserAuthorizationIssuer: ((url: string) => string | undefined) | null = null;
 
   constructor(
     private readonly sessionId: string,
@@ -373,10 +387,14 @@ export class OmpTimelineProjector {
     private readonly scheduler: OmpTimelineScheduler = defaultOmpTimelineScheduler,
     outputRedactionValues: readonly string[] = [],
     private readonly conversationRevertEnabled = false,
+    private readonly pluginTimelineEnabled = false,
     private readonly hostToolLabels: ReadonlyMap<string, string> = new Map(),
   ) {
     this.dataFilter = new OmpPublicDataSerializer(outputRedactionValues);
   }
+  setBrowserAuthorizationIssuer(issue: ((url: string) => string | undefined) | null): void {
+    this.browserAuthorizationIssuer = issue;
+  }
 
   project(event: OmpRpcEvent, turnId: string, bypassReplayFilter = false): void {
     if (this.closed) return;
@@ -601,15 +619,40 @@ export class OmpTimelineProjector {
       return;
     }
     if (event.type === "extension_ui_request" && event.method === "open_url") {
-      const url = publishableHttpUrl(event.launchUrl ?? event.url);
+      const url = publishableHttpUrl(event.url);
       if (!url) return;
       this.noticeSequence += 1;
-      const message = [event.instructions, url].filter(Boolean).join("\n");
+      const instructions = event.instructions
+        ? this.dataFilter.text(event.instructions, 64 * 1024)
+        : undefined;
+      const publicUrl = this.dataFilter.text(url, 16_384);
+      const isMcpAuthorization = isOmpOAuthLaunchUrl(event.launchUrl);
+      if (this.pluginTimelineEnabled && isMcpAuthorization && publishableHttpUrl(publicUrl)) {
+        const browserAuthorizationToken = this.browserAuthorizationIssuer?.(publicUrl);
+        this.publish({
+          type: "plugin",
+          id: `omp:ui:${this.noticeSequence}`,
+          pluginId: "paseo-omp",
+          kind: OMP_MCP_AUTH_TIMELINE_KIND,
+          version: 1,
+          data: {
+            url: publicUrl,
+            ...(instructions ? { instructions } : {}),
+            loopbackCallback: true,
+            ...(browserAuthorizationToken ? { browserAuthorizationToken } : {}),
+          },
+        });
+        return;
+      }
+      const remoteHint = isMcpAuthorization
+        ? "Remote client: if the localhost callback cannot connect, paste the final redirect URL or authorization code into the OMP prompt in this chat."
+        : undefined;
+      const message = [instructions, publicUrl, remoteHint].filter(Boolean).join("\n");
       this.publish({
         type: "notification",
         id: `omp:ui:${this.noticeSequence}`,
         level: "info",
-        message: this.dataFilter.text(message, 64 * 1024),
+        message,
       });
       return;
     }
@@ -783,6 +826,7 @@ export class OmpTimelineProjector {
     this.replayOverflowCandidates.clear();
     this.projectingReplay = false;
     this.activeToolBytes = 0;
+    this.replayToolCalls.clear();
     this.tools.clear();
     this.commandText = "";
     this.commandPublishedText = "";
@@ -795,6 +839,7 @@ export class OmpTimelineProjector {
     const nativeIdentity = assistantIdentity(message);
     this.replaySequence += 1;
     if (message.role === "user") {
+      this.replayToolCalls.clear();
       if (this.replayTurnId) this.finishTurn(this.replayTurnId);
       this.replayTurnId = `omp:replay-turn:${this.replaySequence}`;
       const text =
@@ -823,15 +868,7 @@ export class OmpTimelineProjector {
           for (const part of message.content) {
             if (part.type !== "toolCall" || !part.id || !part.name || part.arguments === undefined)
               continue;
-            this.project(
-              {
-                type: "tool_execution_start",
-                toolCallId: part.id,
-                toolName: part.name,
-                args: part.arguments,
-              },
-              this.replayTurnId,
-            );
+            this.replayToolCalls.set(part.id, { toolName: part.name, args: part.arguments });
           }
         }
       } finally {
@@ -842,13 +879,15 @@ export class OmpTimelineProjector {
     }
     this.replayTurnId ??= `omp:replay-turn:${this.replaySequence}`;
     if (message.role === "toolResult") {
+      const replayCall = this.replayToolCalls.get(message.toolCallId);
+      this.replayToolCalls.delete(message.toolCallId);
       if (!this.tools.has(message.toolCallId)) {
         this.project(
           {
             type: "tool_execution_start",
             toolCallId: message.toolCallId,
-            toolName: message.toolName,
-            args: null,
+            toolName: replayCall?.toolName ?? message.toolName,
+            args: replayCall?.args ?? null,
           },
           this.replayTurnId,
         );
@@ -880,6 +919,7 @@ export class OmpTimelineProjector {
 
   finishReplay(): void {
     if (this.replayTurnId) this.finishTurn(this.replayTurnId);
+    this.replayToolCalls.clear();
     this.replayTurnId = null;
   }
   acceptLiveTurn(turnId: string): void {
@@ -1027,9 +1067,11 @@ export class OmpTimelineProjector {
     if (this.currentTurnId) this.publishCommand(this.currentTurnId);
     this.retireCompactions("OMP compaction ended when the session closed");
     this.closed = true;
+    this.browserAuthorizationIssuer = null;
     this.clearFlushTimer();
     this.stream = null;
     this.tools.clear();
+    this.replayToolCalls.clear();
     this.activeToolBytes = 0;
     this.replayCandidates.clear();
     this.replayOverflowCandidates.clear();
@@ -1091,6 +1133,7 @@ export class OmpTimelineProjector {
       ...(nativeIdentity ? { nativeIdentity } : {}),
       published: false,
       retainedBytes: 0,
+      textBytes: 0,
       publishedBytes: 0,
       blocks: new Map(),
       dirtyBlocks: new Set(),
@@ -1155,7 +1198,7 @@ export class OmpTimelineProjector {
       return;
     }
     if (!Array.isArray(message.content)) return;
-    const blockCount = Math.min(message.content.length, MAX_STREAM_CONTENT_BLOCKS);
+    const blockCount = Math.min(message.content.length, OMP_MAX_CONTENT_PARTS);
     for (let index = 0; index < blockCount; index += 1) {
       const block = blockText(message, index);
       if (block) this.setBlock(stream, index, block);
@@ -1215,20 +1258,13 @@ export class OmpTimelineProjector {
     if (snapshot.kind === "image" && utf8Bytes(snapshot.text) > MAX_IMAGE_ENCODED_LENGTH + 256)
       return;
     const previous = stream.blocks.get(contentIndex);
-    let retainedBytes = utf8Bytes(snapshot.text);
-    let textBytes = snapshot.kind === "image" ? 0 : retainedBytes;
-    for (const [index, block] of stream.blocks) {
-      if (index === contentIndex) continue;
-      const blockBytes = utf8Bytes(block.text);
-      retainedBytes += blockBytes;
-      if (block.kind !== "image") textBytes += blockBytes;
-      if (
-        retainedBytes + stream.publishedBytes > MAX_STREAM_TOTAL_BYTES ||
-        textBytes > MAX_STREAM_TEXT_LENGTH
-      ) {
-        return;
-      }
-    }
+    const previousBytes = previous ? utf8Bytes(previous.text) : 0;
+    const snapshotBytes = utf8Bytes(snapshot.text);
+    const retainedBytes = stream.retainedBytes - previousBytes + snapshotBytes;
+    const textBytes =
+      stream.textBytes -
+      (previous && previous.kind !== "image" ? previousBytes : 0) +
+      (snapshot.kind === "image" ? 0 : snapshotBytes);
     if (
       retainedBytes + stream.publishedBytes > MAX_STREAM_TOTAL_BYTES ||
       textBytes > MAX_STREAM_TEXT_LENGTH
@@ -1237,6 +1273,7 @@ export class OmpTimelineProjector {
     }
     if (previous?.kind === snapshot.kind && previous.text === snapshot.text) return;
     stream.retainedBytes = retainedBytes;
+    stream.textBytes = textBytes;
     stream.blocks.set(contentIndex, {
       ...snapshot,
       ...(previous?.kind === snapshot.kind ? { publishedText: previous.publishedText } : {}),
@@ -1248,7 +1285,7 @@ export class OmpTimelineProjector {
     return (
       Number.isSafeInteger(contentIndex) &&
       contentIndex >= 0 &&
-      contentIndex < MAX_STREAM_CONTENT_BLOCKS
+      contentIndex < OMP_MAX_CONTENT_PARTS
     );
   }
 

package/server/provider-diagnostics.ts

@@ -17,7 +17,7 @@ import type {
   OmpVersionStatus,
   PathState,
 } from "../shared/provider-diagnostics";
-import { ompAgentDir } from "./paths";
+import { currentOmpEnvironment, ompAgentDir, ompDataDir, ompSessionDir } from "./paths";
 
 const VERSION_TIMEOUT_MS = 3_000;
 const HELP_TIMEOUT_MS = 3_000;
@@ -190,7 +190,11 @@ export async function killWindowsProcessTree(
 
   let child: ProbeChildProcess;
   try {
-    child = spawnFn(taskkillPath, ["/pid", String(pid), "/t", "/f"], buildProbeEnv(process.env));
+    child = spawnFn(
+      taskkillPath,
+      ["/pid", String(pid), "/t", "/f"],
+      buildProbeEnv(currentOmpEnvironment()),
+    );
   } catch {
     return false;
   }
@@ -243,7 +247,7 @@ export function defaultSpawn(
         return killWindowsProcessTree(
           child.pid,
           defaultSpawn,
-          process.env.SystemRoot ?? WINDOWS_DEFAULT_SYSTEM_ROOT,
+          currentOmpEnvironment().SystemRoot ?? WINDOWS_DEFAULT_SYSTEM_ROOT,
           graceMs,
         );
       }
@@ -569,7 +573,7 @@ export async function probeOmpAvailability(options: OmpAvailabilityProbeOptions)
   status: "missing" | "unrunnable" | "incompatible" | "available";
   diagnostic?: string;
 }> {
-  const environment = options.environment ?? process.env;
+  const environment = options.environment ?? currentOmpEnvironment();
   const [command, ...prefixArgs] = options.command;
   const resolvedPath = await resolveExecutablePath(
     command,
@@ -810,31 +814,57 @@ async function computeMcpDiagnostics(agentDir: string): Promise<OmpMcpDiagnostic
 export interface ProcessDiagnosticsFs {
   readdir(path: string): Promise<string[]>;
   lstat(path: string): Promise<Stats>;
+  readMetadata(path: string, maxBytes: number): Promise<BoundedFileRead>;
 }
 
-const processDiagnosticsFs: ProcessDiagnosticsFs = { readdir, lstat };
+const processDiagnosticsFs: ProcessDiagnosticsFs = {
+  readdir,
+  lstat,
+  readMetadata: readBoundedNoSymlinkFile,
+};
+const MAX_PROCESS_METADATA_BYTES = 64 * 1024;
+const MAX_PROCESS_METADATA_ENTRIES = 4_096;
+const ProcessStateSchema = z.object({
+  daemon: z.object({
+    state: z.string().max(32),
+    exitedAt: z.number().finite().nonnegative().nullish(),
+  }),
+});
+const ACTIVE_PROCESS_STATES = new Set(["starting", "running", "ready", "restarting"]);
+const HISTORICAL_PROCESS_STATES = new Set(["exited", "failed", "stopped"]);
 
 /**
- * Counts only regular, non-symlink meta.json entries. Missing/wrong entries are expected and
- * ignored; any other read/stat failure makes the result partial rather than silently hiding it.
+ * Classifies bounded, regular, non-symlink Hub metadata. A recorded active state is not a
+ * liveness check. Historical files remain useful evidence and are never counted as running.
+ * Only aggregate counts leave this reader; metadata arguments, paths and values are discarded.
  */
 export async function computeProcessDiagnostics(
   hubRunRoot: string,
   fs: ProcessDiagnosticsFs = processDiagnosticsFs,
 ): Promise<OmpProcessDiagnostics> {
+  const unavailableCounts = {
+    trackedCount: null,
+    activeCount: null,
+    historicalCount: null,
+    unknownCount: null,
+  };
   let projectHashes: string[];
   try {
     const rootStats = await fs.lstat(hubRunRoot);
     if (rootStats.isSymbolicLink() || !rootStats.isDirectory()) {
-      return { status: "unavailable", trackedCount: null };
+      return { status: "unavailable", ...unavailableCounts };
     }
     projectHashes = await fs.readdir(hubRunRoot);
   } catch (error) {
-    return { status: isEnoent(error) ? "unavailable" : "unknown", trackedCount: null };
+    return { status: isEnoent(error) ? "unavailable" : "unknown", ...unavailableCounts };
   }
   let trackedCount = 0;
-  let partial = false;
-  for (const hash of projectHashes) {
+  let activeCount = 0;
+  let historicalCount = 0;
+  let unknownCount = 0;
+  let partial = projectHashes.length > MAX_PROCESS_METADATA_ENTRIES;
+  let visitedEntries = 0;
+  for (const hash of projectHashes.slice(0, MAX_PROCESS_METADATA_ENTRIES)) {
     const projectDir = join(hubRunRoot, hash);
     const daemonsDir = join(projectDir, "daemons");
     try {
@@ -855,15 +885,51 @@ export async function computeProcessDiagnostics(
       continue;
     }
     for (const name of daemonNames) {
+      if (++visitedEntries > MAX_PROCESS_METADATA_ENTRIES) {
+        partial = true;
+        break;
+      }
       try {
-        const metaStats = await fs.lstat(join(daemonsDir, name, "meta.json"));
-        if (!metaStats.isSymbolicLink() && metaStats.isFile()) trackedCount += 1;
+        const daemonDir = join(daemonsDir, name);
+        const directoryStats = await fs.lstat(daemonDir);
+        if (directoryStats.isSymbolicLink() || !directoryStats.isDirectory()) continue;
+        const metaPath = join(daemonDir, "meta.json");
+        const metaStats = await fs.lstat(metaPath);
+        if (metaStats.isSymbolicLink() || !metaStats.isFile()) continue;
+        trackedCount += 1;
+        let category: "active" | "historical" | "unknown" = "unknown";
+        try {
+          const file = await fs.readMetadata(metaPath, MAX_PROCESS_METADATA_BYTES);
+          if (file.state === "available") {
+            const parsed = ProcessStateSchema.safeParse(JSON.parse(file.text));
+            if (parsed.success) {
+              const { state, exitedAt } = parsed.data.daemon;
+              if (HISTORICAL_PROCESS_STATES.has(state) || exitedAt != null) category = "historical";
+              else if (ACTIVE_PROCESS_STATES.has(state)) category = "active";
+            }
+          }
+        } catch {
+          // Read/access/parse errors have an honest unknown bucket, never a guessed active state.
+        }
+        if (category === "historical") historicalCount += 1;
+        else if (category === "active") activeCount += 1;
+        else {
+          unknownCount += 1;
+          partial = true;
+        }
       } catch (error) {
         if (!isEnoent(error)) partial = true;
       }
     }
+    if (visitedEntries > MAX_PROCESS_METADATA_ENTRIES) break;
   }
-  return { status: partial ? "partial" : "ok", trackedCount };
+  return {
+    status: partial ? "partial" : "ok",
+    trackedCount,
+    activeCount,
+    historicalCount,
+    unknownCount,
+  };
 }
 
 function homeRelative(path: string, homeDir: string): string | null {
@@ -880,16 +946,23 @@ function sanitizeRootPath(path: string, homeDir: string): string {
   return homeRelative(path, homeDir) ?? "<custom path>";
 }
 
-function sanitizeDerivedPath(rawRoot: string, sanitizedRoot: string, fullPath: string): string {
+function sanitizeDerivedPath(
+  rawRoot: string,
+  sanitizedRoot: string,
+  fullPath: string,
+  fallbackHomeDir?: string,
+): string {
   const suffix = relative(rawRoot, fullPath);
   if (suffix === "" || suffix === ".." || suffix.startsWith(`..${sep}`) || isAbsolute(suffix)) {
-    return sanitizedRoot;
+    return fallbackHomeDir ? sanitizeRootPath(fullPath, fallbackHomeDir) : sanitizedRoot;
   }
   return `${sanitizedRoot}/${suffix.split(sep).join("/")}`;
 }
 
 export interface ProviderDiagnosticsDeps {
   agentDir: string;
+  dataDir?: string;
+  sessionDir?: string;
   command: string;
   pathDirs: readonly string[];
   cwd: string;
@@ -910,6 +983,8 @@ export async function computeOmpProviderHealth(
   deps: ProviderDiagnosticsDeps,
 ): Promise<OmpProviderHealth> {
   const agentDir = resolve(deps.agentDir);
+  const dataDir = resolve(deps.dataDir ?? agentDir);
+  const sessionRoot = resolve(deps.sessionDir ?? join(dataDir, SESSION_DIR_NAME));
   const homeDir = resolve(deps.homeDir);
   const versionTimeoutMs = deps.versionTimeoutMs ?? VERSION_TIMEOUT_MS;
   const helpTimeoutMs = deps.helpTimeoutMs ?? HELP_TIMEOUT_MS;
@@ -935,6 +1010,7 @@ export async function computeOmpProviderHealth(
           versionTimeoutMs,
           killGraceMs,
           maxVersionBytes,
+          deps.cwd,
         )
       : null,
     installed
@@ -946,6 +1022,7 @@ export async function computeOmpProviderHealth(
           helpTimeoutMs,
           killGraceMs,
           maxHelpBytes,
+          deps.cwd,
         )
       : null,
   ]);
@@ -957,9 +1034,8 @@ export async function computeOmpProviderHealth(
   const lsp = helpRun ? computeLspDiagnostics(helpRun) : { status: "unknown" as const };
   const processCleanupFailed = Boolean(versionRun?.cleanupFailed || helpRun?.cleanupFailed);
 
-  const agentDbPath = join(agentDir, AGENT_DB_FILENAME);
-  const historyDbPath = join(agentDir, HISTORY_DB_FILENAME);
-  const sessionRoot = join(agentDir, SESSION_DIR_NAME);
+  const agentDbPath = join(dataDir, AGENT_DB_FILENAME);
+  const historyDbPath = join(dataDir, HISTORY_DB_FILENAME);
   const [
     configResult,
     agentRootState,
@@ -1000,7 +1076,7 @@ export async function computeOmpProviderHealth(
       agentRootState,
       configPath: sanitizeDerivedPath(agentDir, sanitizedAgentRoot, configResult.path),
       configState,
-      sessionRoot: sanitizeDerivedPath(agentDir, sanitizedAgentRoot, sessionRoot),
+      sessionRoot: sanitizeDerivedPath(agentDir, sanitizedAgentRoot, sessionRoot, homeDir),
       sessionRootState,
     },
     databases: {
@@ -1013,11 +1089,11 @@ export async function computeOmpProviderHealth(
   };
 }
 
-let cachedHealth: { value: OmpProviderHealth; expiresAt: number } | null = null;
-let inFlightHealth: Promise<OmpProviderHealth> | null = null;
+const cachedHealth = new Map<string, { value: OmpProviderHealth; expiresAt: number }>();
+const inFlightHealth = new Map<string, Promise<OmpProviderHealth>>();
 
-function defaultHubRunRoot(): string {
-  return process.env.PASEO_OMP_RUN_DIR ?? join(homedir(), ".omp", "run", "daemons");
+function defaultHubRunRoot(environment: NodeJS.ProcessEnv = currentOmpEnvironment()): string {
+  return environment.PASEO_OMP_RUN_DIR ?? join(homedir(), ".omp", "run", "daemons");
 }
 
 /**
@@ -1029,29 +1105,39 @@ function defaultHubRunRoot(): string {
 export async function resolveGetOmpProviderHealth(
   input: RpcInput<typeof getOmpProviderHealth>,
 ): Promise<OmpProviderHealth> {
+  const cwd = input.cwd ?? process.cwd();
+  const environment = currentOmpEnvironment();
+  const agentDir = ompAgentDir(environment);
+  const dataDir = ompDataDir(environment);
+  const sessionDir = ompSessionDir(environment);
   const now = Date.now();
-  if (!input.force && cachedHealth && cachedHealth.expiresAt > now) return cachedHealth.value;
-  if (inFlightHealth) return inFlightHealth;
+  const key = JSON.stringify([cwd, agentDir, dataDir, sessionDir]);
+  const cached = cachedHealth.get(key);
+  if (!input.force && cached && cached.expiresAt > now) return cached.value;
+  const inFlight = inFlightHealth.get(key);
+  if (inFlight) return inFlight;
 
   const computation = computeOmpProviderHealth({
-    agentDir: ompAgentDir(),
-    command: process.env.OMP_COMMAND ?? "omp",
-    pathDirs: (process.env.PATH ?? "").split(delimiter),
-    cwd: process.cwd(),
+    agentDir,
+    dataDir,
+    sessionDir,
+    command: environment.OMP_COMMAND ?? "omp",
+    pathDirs: (environment.PATH ?? "").split(delimiter),
+    cwd,
     platform: process.platform,
-    pathExt: process.env.PATHEXT ?? WINDOWS_DEFAULT_PATHEXT,
-    env: process.env,
+    pathExt: environment.PATHEXT ?? WINDOWS_DEFAULT_PATHEXT,
+    env: environment,
     spawnFn: defaultSpawn,
-    hubRunRoot: defaultHubRunRoot(),
+    hubRunRoot: defaultHubRunRoot(environment),
     homeDir: homedir(),
   })
     .then((value) => {
-      cachedHealth = { value, expiresAt: Date.now() + HEALTH_CACHE_TTL_MS };
+      cachedHealth.set(key, { value, expiresAt: Date.now() + HEALTH_CACHE_TTL_MS });
       return value;
     })
     .finally(() => {
-      inFlightHealth = null;
+      inFlightHealth.delete(key);
     });
-  inFlightHealth = computation;
+  inFlightHealth.set(key, computation);
   return computation;
 }

package/server/quota.ts

@@ -1,8 +1,9 @@
+import { join } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import type { RpcInput } from "@getpaseo/plugin";
 import { z } from "zod";
 import type { listOmpQuotas, OmpQuota } from "../shared/quota";
-import { ompAgentDir } from "./paths";
+import { ompDataDir } from "./paths";
 
 const QuotaRowSchema = z.object({
   provider: z.string(),
@@ -50,5 +51,5 @@ export function listOmpQuotasFrom(path: string): OmpQuota[] {
 export function resolveListOmpQuotas(_input: RpcInput<typeof listOmpQuotas>): {
   quotas: OmpQuota[];
 } {
-  return { quotas: listOmpQuotasFrom(`${ompAgentDir()}/agent.db`) };
+  return { quotas: listOmpQuotasFrom(join(ompDataDir(), "agent.db")) };
 }

package/server/sessions.ts

@@ -3,7 +3,7 @@ import { DatabaseSync } from "node:sqlite";
 import type { RpcInput } from "@getpaseo/plugin";
 import { z } from "zod";
 import type { listOmpSessions, OmpSessionEntry } from "../shared/sessions";
-import { ompAgentDir } from "./paths";
+import { ompDataDir } from "./paths";
 
 const PROMPT_LIMIT = 400;
 const ROW_LIMIT = 100;
@@ -54,5 +54,5 @@ export function listOmpSessionsFrom(path: string, cwd: string): OmpSessionEntry[
 export function resolveListOmpSessions({ cwd }: RpcInput<typeof listOmpSessions>): {
   sessions: OmpSessionEntry[];
 } {
-  return { sessions: listOmpSessionsFrom(join(ompAgentDir(), "history.db"), cwd) };
+  return { sessions: listOmpSessionsFrom(join(ompDataDir(), "history.db"), cwd) };
 }

package/shared/composer-pill-settings.ts

@@ -0,0 +1,28 @@
+import { defineSettings } from "@getpaseo/plugin";
+import { z } from "zod";
+
+export const DEFAULT_COMPOSER_PILL_SETTINGS = {
+  mcp: true,
+  hub: true,
+  memory: true,
+  sessions: true,
+  quota: true,
+} as const;
+
+export const composerPillSettingsSchema = z.object({
+  mcp: z.boolean().default(DEFAULT_COMPOSER_PILL_SETTINGS.mcp),
+  hub: z.boolean().default(DEFAULT_COMPOSER_PILL_SETTINGS.hub),
+  memory: z.boolean().default(DEFAULT_COMPOSER_PILL_SETTINGS.memory),
+  sessions: z.boolean().default(DEFAULT_COMPOSER_PILL_SETTINGS.sessions),
+  quota: z.boolean().default(DEFAULT_COMPOSER_PILL_SETTINGS.quota),
+});
+
+export type ComposerPillSettings = z.infer<typeof composerPillSettingsSchema>;
+export type ComposerPillKey = keyof ComposerPillSettings;
+
+export const composerPillSettings = defineSettings({
+  id: "composer-pills",
+  scope: "host",
+  version: 1,
+  schema: composerPillSettingsSchema,
+});

package/shared/external-url.ts

@@ -0,0 +1,21 @@
+export type ExternalUrlOpener = (url: string) => Promise<void>;
+
+export function selectExternalUrlOpener(
+  paseoOpener: ExternalUrlOpener | undefined,
+  fallback: ExternalUrlOpener,
+): ExternalUrlOpener {
+  return paseoOpener ?? fallback;
+}
+
+export function validatedHttpUrl(value: string): string {
+  let url: URL;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error("Only absolute HTTP(S) URLs are supported.");
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error("Only absolute HTTP(S) URLs are supported.");
+  }
+  return url.href;
+}