@omercnet/paseo-omp 5.1.1-next.335.1 → 5.1.1-next.336.1

package/client/provider-launch-settings.tsx

@@ -8,6 +8,7 @@ import {
 import { useCallback, useEffect, useMemo, useState } from "react";
 import { Text, View } from "react-native";
 import {
+  MAX_SESSIONS_UPPER_BOUND,
   providerLaunchSettings,
   providerLaunchSettingsSchema,
 } from "../shared/provider-launch-settings";
@@ -23,6 +24,11 @@ function ProviderLaunchSettingsControls({ settings }: { settings: ReadySettings
   useEffect(() => {
     setRawNames(savedNames);
   }, [savedNames]);
+  const savedMaxSessions = String(settings.values.maxSessions);
+  const [rawMaxSessions, setRawMaxSessions] = useState(() => savedMaxSessions);
+  useEffect(() => {
+    setRawMaxSessions(savedMaxSessions);
+  }, [savedMaxSessions]);
   const inheritEnv = [
     ...new Set(
       rawNames
@@ -31,7 +37,7 @@ function ProviderLaunchSettingsControls({ settings }: { settings: ReadySettings
         .filter(Boolean),
     ),
   ];
-  const next = providerLaunchSettingsSchema.safeParse({ inheritEnv });
+  const next = providerLaunchSettingsSchema.safeParse({ ...settings.values, inheritEnv });
   const error = next.success
     ? null
     : (next.error.issues[0]?.message ?? "Enter valid variable names.");
@@ -39,6 +45,14 @@ function ProviderLaunchSettingsControls({ settings }: { settings: ReadySettings
     if (!next.success) return;
     await settings.save(next.data, settings.revision);
   }, [next, settings]);
+  const nextMaxSessions = providerLaunchSettingsSchema.safeParse({
+    ...settings.values,
+    maxSessions: Number(rawMaxSessions.trim()),
+  });
+  const saveMaxSessions = useCallback(async () => {
+    if (!nextMaxSessions.success) return;
+    await settings.save(nextMaxSessions.data, settings.revision);
+  }, [nextMaxSessions, settings]);
 
   return (
     <View style={{ gap: 12 }}>
@@ -69,7 +83,9 @@ function ProviderLaunchSettingsControls({ settings }: { settings: ReadySettings
             actionLabel="Clear"
             disabled={settings.saving || settings.values.inheritEnv.length === 0}
             onPress={async () => {
-              if (await settings.save({ inheritEnv: [] }, settings.revision)) setRawNames("");
+              if (await settings.save({ ...settings.values, inheritEnv: [] }, settings.revision)) {
+                setRawNames("");
+              }
             }}
           />
           {settings.saveError ? (
@@ -83,6 +99,34 @@ function ProviderLaunchSettingsControls({ settings }: { settings: ReadySettings
           ) : null}
         </SettingsCard>
       </SettingsSection>
+      <SettingsSection
+        title="Session limit"
+        info="Applies to all OMP Plugin agents on this host together, including idle ones."
+      >
+        <SettingsCard>
+          <SettingsInput
+            key={savedMaxSessions}
+            label="Open sessions"
+            hint="New OMP Plugin agents are refused while this many sessions are open. Archive idle agents to free sessions."
+            initialValue={savedMaxSessions}
+            onChangeText={setRawMaxSessions}
+            error={
+              nextMaxSessions.success
+                ? undefined
+                : `Enter a whole number from 1 to ${MAX_SESSIONS_UPPER_BOUND}.`
+            }
+            disabled={settings.saving}
+          />
+          <SettingsAction
+            label="Save session limit"
+            actionLabel="Save"
+            disabled={
+              settings.saving || rawMaxSessions === savedMaxSessions || !nextMaxSessions.success
+            }
+            onPress={() => void saveMaxSessions()}
+          />
+        </SettingsCard>
+      </SettingsSection>
     </View>
   );
 }

package/index.server.ts

@@ -25,6 +25,7 @@ import {
 } from "./server/provider/profile-providers";
 import { createOmpProvider } from "./server/provider/registration";
 import { OmpPublicError } from "./server/provider/security";
+import { OmpSessionLimit } from "./server/provider/session-limit";
 import { resolveGetOmpProviderHealth } from "./server/provider-diagnostics";
 import { resolveListOmpQuotas } from "./server/quota";
 import { resolveListOmpSessions } from "./server/sessions";
@@ -62,6 +63,11 @@ export default function contribute(server: PluginServerContext) {
     throw new OmpPublicError("OMP host launch settings are unavailable");
   };
   const browserAuthorizationRegistry = new OmpBrowserAuthorizationRegistry();
+  const sessionLimit = new OmpSessionLimit(async () => {
+    const current = await launchSettings.read();
+    return current.status === "ready" ? current.values.maxSessions : undefined;
+  });
+  const removeSessionLimitListener = launchSettings.subscribe(() => sessionLimit.refresh());
   const protocolViolations = new OmpProtocolViolationCollector();
   const operationalFailures = new OmpOperationalFailureCollector();
   const profiles = discoverOmpProfilesSync();
@@ -70,6 +76,7 @@ export default function contribute(server: PluginServerContext) {
     server.registerProvider(
       createProfileOmpProvider(profile, {
         browserAuthorizationRegistry,
+        sessionLimit,
         reportProtocolViolation: protocolViolations.report,
         reportOperationalFailure: operationalFailures.report,
         resolveHostInheritEnv,
@@ -104,6 +111,7 @@ export default function contribute(server: PluginServerContext) {
   server.registerProvider(
     createOmpProvider({
       browserAuthorizationRegistry,
+      sessionLimit,
       reportProtocolViolation: protocolViolations.report,
       reportOperationalFailure: operationalFailures.report,
       resolveHostInheritEnv,
@@ -111,6 +119,7 @@ export default function contribute(server: PluginServerContext) {
   );
   return () => {
     browserAuthorizationRegistry.clear();
+    removeSessionLimitListener();
     removeSessionOpenHook();
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omercnet/paseo-omp",
-  "version": "5.1.1-next.335.1",
+  "version": "5.1.1-next.336.1",
   "type": "module",
   "description": "Paseo integration for OMP, including its direct provider and workspace tooling.",
   "license": "MIT",

package/server/mcp-browser.ts

@@ -1,9 +1,11 @@
 import { randomUUID } from "node:crypto";
 import type { RpcInput } from "@getpaseo/plugin";
 import type { openOmpMcpAuthorizationInPaseoBrowser } from "../shared/mcp";
+import { MAX_SESSIONS_UPPER_BOUND } from "../shared/provider-launch-settings";
 import { OmpPublicError } from "./provider/security";
 
-const MAX_REGISTERED_SESSIONS = 32;
+// One registration per live session. The shared session limit refuses sessions first.
+const MAX_REGISTERED_SESSIONS = MAX_SESSIONS_UPPER_BOUND;
 const MAX_AUTHORIZATIONS_PER_SESSION = 16;
 
 type BrowserAuthorizationOpener = (url: string) => Promise<void>;

package/server/package-version.ts

@@ -1,2 +1,2 @@
 /** Release Please keeps this bundle-safe constant aligned with package.json. */
-export const PASEO_OMP_PACKAGE_VERSION = "5.1.1-next.335.1"; // x-release-please-version
+export const PASEO_OMP_PACKAGE_VERSION = "5.1.1-next.336.1"; // x-release-please-version

package/server/provider/connection.ts

@@ -34,6 +34,7 @@ import {
 } from "./security";
 import { type OmpOpenedSession, OmpProviderSession, ompPersistenceSessionId } from "./session";
 import { OmpHistorySession } from "./session-history";
+import { OmpSessionLimit } from "./session-limit";
 import { isOmpHistoryOnlyOpen } from "./session-purpose";
 
 type ProviderConfigurationCompat = {
@@ -69,7 +70,6 @@ const SUPPORTED_INPUTS: Readonly<Record<string, true>> = {
   "session.can_stop_runtime": true,
   "session.close": true,
 };
-const MAX_CONNECTION_SESSIONS = 32;
 const MAX_ACTIVE_OPERATIONS = 128;
 const MAX_PROVIDER_INPUT_BYTES = 2 * 1024 * 1024;
 const MAX_NESTED_OPTION_BYTES = 256 * 1024;
@@ -723,6 +723,7 @@ export function createOmpConnection(
     console.error("OMP provider failure", diagnostic),
   reportOperationalFailure: OmpOperationalFailureReporter = () => {},
   resolveHostInheritEnv?: () => Promise<readonly string[]>,
+  sessionLimit = new OmpSessionLimit(),
 ): ProviderConnection {
   const errorDetails = (error: unknown, fallback: string): { message: string } => {
     if (isOmpPublicError(error)) return { message: error.message };
@@ -767,6 +768,13 @@ export function createOmpConnection(
     string,
     { token: symbol; nativeSessionId?: string; cleanup?: Promise<void> }
   >();
+  // One session id is held by `sessions`, `opening` and `failedCleanup` at different moments, and
+  // by two of them at once while it opens or fails. After a failed close only unresolved cleanup
+  // stays counted, until it drains.
+  const untrackSessions = sessionLimit.track(() => {
+    if (closed) return failedCleanup.size;
+    return new Set([...sessions.keys(), ...opening.keys(), ...failedCleanup.keys()]).size;
+  });
   const shutdown = new AbortController();
   let catalogCleanup: Promise<void> | null = null;
   const activeOperations = new Set<Promise<void>>();
@@ -809,7 +817,9 @@ export function createOmpConnection(
       ...(quarantinedNativeSessionId ? { nativeSessionId: quarantinedNativeSessionId } : {}),
     });
     nativeReservations.quarantine(quarantinedNativeSessionId, token, cleanup, () => {
-      if (failedCleanup.get(sessionId)?.token === token) failedCleanup.delete(sessionId);
+      if (failedCleanup.get(sessionId)?.token !== token) return;
+      failedCleanup.delete(sessionId);
+      if (closed && failedCleanup.size === 0) untrackSessions();
     });
   };
 
@@ -906,8 +916,13 @@ export function createOmpConnection(
           requestFailure(input.requestId, new OmpPublicError("OMP session already exists"));
           return;
         }
-        if (sessions.size + opening.size + failedCleanup.size >= MAX_CONNECTION_SESSIONS) {
-          requestFailure(input.requestId, new OmpPublicError("OMP session limit reached"));
+        if (sessionLimit.openSessions >= sessionLimit.maxSessions) {
+          requestFailure(
+            input.requestId,
+            new OmpPublicError(
+              `OMP session limit reached (${sessionLimit.maxSessions} open sessions). Archive idle agents or raise the session limit in OMP → Plugin.`,
+            ),
+          );
           return;
         }
         const token = Symbol(input.sessionId);
@@ -1313,7 +1328,12 @@ export function createOmpConnection(
       return () => listeners.delete(listener);
     },
     close() {
-      closePromise ??= Promise.resolve().then(disposeConnection);
+      closePromise ??= Promise.resolve()
+        .then(disposeConnection)
+        .then(untrackSessions, (error: unknown) => {
+          if (failedCleanup.size === 0) untrackSessions();
+          throw error;
+        });
       return closePromise;
     },
   };

package/server/provider/registration.ts

@@ -12,6 +12,7 @@ import { OmpRpcRuntime, type OmpRuntime } from "./omp-rpc";
 import type { OmpProtocolViolationDiagnostic } from "./omp-rpc-protocol";
 import { parseOmpProviderOptions } from "./provider-options";
 import { boundedJsonBytes } from "./security";
+import { OmpSessionLimit } from "./session-limit";
 import { OmpProviderOptionsSchema } from "./settings";
 import type { OmpTimelineScheduler } from "./timeline-projector";
 
@@ -121,6 +122,8 @@ export interface OmpProviderOptions {
   mcpInitializationTimeoutMs?: number;
   mcpConnector?: OmpMcpConnector;
   browserAuthorizationRegistry?: OmpBrowserAuthorizationRegistry;
+  /** Shared by every provider of one plugin instance; each provider has its own otherwise. */
+  sessionLimit?: OmpSessionLimit;
   reportProtocolViolation?: (diagnostic: OmpProtocolViolationDiagnostic) => void | Promise<void>;
   reportOperationalFailure?: OmpOperationalFailureReporter;
   availabilityProbe?: (
@@ -150,6 +153,7 @@ export function createOmpProvider(options: OmpProviderOptions = {}): ProviderReg
       reportProtocolViolation: options.reportProtocolViolation,
     });
   const nativeReservations = new OmpNativeSessionReservations();
+  const sessionLimit = options.sessionLimit ?? new OmpSessionLimit();
   const checkAvailability: NonNullable<ProviderRegistrationCompat["checkAvailability"]> = async (
     catalogOptions,
     context,
@@ -216,6 +220,7 @@ export function createOmpProvider(options: OmpProviderOptions = {}): ProviderReg
       const capabilities = CAPABILITIES.filter((capability) =>
         requestedCapabilities.has(capability),
       );
+      await sessionLimit.refresh();
       return createOmpConnection(
         runtime,
         capabilities,
@@ -229,6 +234,7 @@ export function createOmpProvider(options: OmpProviderOptions = {}): ProviderReg
         undefined,
         options.reportOperationalFailure,
         options.resolveHostInheritEnv,
+        sessionLimit,
       );
     },
   };

package/server/provider/session-limit.ts

@@ -0,0 +1,32 @@
+import { DEFAULT_MAX_SESSIONS } from "../../shared/provider-launch-settings";
+
+/**
+ * Counts open sessions across every provider connection that shares this instance. The plugin
+ * shares one instance between all of its OMP providers, so the limit applies to the whole host.
+ */
+export class OmpSessionLimit {
+  private readonly counts = new Set<() => number>();
+  maxSessions = DEFAULT_MAX_SESSIONS;
+
+  /** `readConfigured` returns the configured limit, or `undefined` to keep the current one. */
+  constructor(private readonly readConfigured?: () => Promise<number | undefined>) {}
+
+  async refresh(): Promise<void> {
+    const configured = await this.readConfigured?.();
+    if (configured !== undefined) this.maxSessions = configured;
+  }
+
+  /** Adds a connection's open sessions to the total until the returned function runs. */
+  track(count: () => number): () => void {
+    this.counts.add(count);
+    return () => {
+      this.counts.delete(count);
+    };
+  }
+
+  get openSessions(): number {
+    let total = 0;
+    for (const count of this.counts) total += count();
+    return total;
+  }
+}

package/shared/provider-launch-settings.ts

@@ -3,9 +3,13 @@ import { z } from "zod";
 
 export const MAX_INHERITED_ENVIRONMENT_NAMES = 256;
 export const environmentNameSchema = z.string().regex(/^[A-Za-z_][A-Za-z0-9_]{0,127}$/u);
+export const DEFAULT_MAX_SESSIONS = 32;
+// Every allowed session can open at once without reaching the 128 in-flight operations bound.
+export const MAX_SESSIONS_UPPER_BOUND = 64;
 
 export const providerLaunchSettingsSchema = z.object({
   inheritEnv: z.array(environmentNameSchema).max(MAX_INHERITED_ENVIRONMENT_NAMES).default([]),
+  maxSessions: z.number().int().min(1).max(MAX_SESSIONS_UPPER_BOUND).default(DEFAULT_MAX_SESSIONS),
 });
 
 export type ProviderLaunchSettings = z.infer<typeof providerLaunchSettingsSchema>;