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

package/server/provider/connection.ts

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 import { homedir } from "node:os";
 import { isAbsolute } from "node:path";
 import {
@@ -7,6 +8,7 @@ import {
   ProviderInputSchema,
   requireProviderCapabilities,
 } from "@getpaseo/plugin/server/provider";
+import type { OmpBrowserAuthorizationRegistry } from "../mcp-browser";
 import { discoverOmpCatalog } from "./catalog";
 import { normalizeOmpCatalogOptions } from "./config-normalization";
 import type { OmpMcpConnector } from "./host-tools";
@@ -39,6 +41,7 @@ const SUPPORTED_CAPABILITIES: Readonly<Record<string, true>> = {
   "session.subsession": true,
   "session.revert.conversation": true,
   permission: true,
+  "timeline.plugin": true,
 };
 const SUPPORTED_INPUTS: Readonly<Record<string, true>> = {
   catalog: true,
@@ -55,6 +58,7 @@ 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;
+const MAX_ENV_ENTRIES = 256;
 const MAX_NATIVE_SESSION_RESERVATIONS = 256;
 
 function hasOwnEntries(value: unknown): boolean {
@@ -65,6 +69,19 @@ function hasOwnEntries(value: unknown): boolean {
   return false;
 }
 
+function providerOptionsExceedPreflightLimits(value: unknown): boolean {
+  if (
+    boundedJsonBytes(value, MAX_NESTED_OPTION_BYTES, MAX_ENV_ENTRIES) === Number.POSITIVE_INFINITY
+  ) {
+    return true;
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const unrelatedOptions = Object.fromEntries(
+    Object.entries(value).filter(([key]) => key !== "env" && key !== "inheritEnv"),
+  );
+  return boundedJsonBytes(unrelatedOptions, MAX_NESTED_OPTION_BYTES) === Number.POSITIVE_INFINITY;
+}
+
 function preflightProviderInput(input: unknown): void {
   if (!input || typeof input !== "object") throw new OmpPublicError("Invalid provider request");
   const record = input as Record<string, unknown>;
@@ -79,7 +96,16 @@ function preflightProviderInput(input: unknown): void {
       throw new OmpPublicError("Session persistence input is too large");
     }
     const config = record.config as Record<string, unknown> | undefined;
-    for (const value of [config?.mcpServers, config?.providerOptions, config?.settings]) {
+    if (
+      (config?.env !== undefined &&
+        boundedJsonBytes(config.env, MAX_NESTED_OPTION_BYTES, MAX_ENV_ENTRIES) ===
+          Number.POSITIVE_INFINITY) ||
+      (config?.providerOptions !== undefined &&
+        providerOptionsExceedPreflightLimits(config.providerOptions))
+    ) {
+      throw new OmpPublicError("Session configuration is too large");
+    }
+    for (const value of [config?.mcpServers, config?.settings]) {
       if (
         value !== undefined &&
         boundedJsonBytes(value, MAX_NESTED_OPTION_BYTES) === Number.POSITIVE_INFINITY
@@ -106,13 +132,17 @@ function preflightProviderInput(input: unknown): void {
     }
   }
   if (record.type === "catalog" || record.type === "sessions") {
-    for (const value of [record.providerOptions, record.settings]) {
-      if (
-        value !== undefined &&
-        boundedJsonBytes(value, MAX_NESTED_OPTION_BYTES) === Number.POSITIVE_INFINITY
-      ) {
-        throw new OmpPublicError("Provider configuration is too large");
-      }
+    if (
+      record.providerOptions !== undefined &&
+      providerOptionsExceedPreflightLimits(record.providerOptions)
+    ) {
+      throw new OmpPublicError("Provider configuration is too large");
+    }
+    if (
+      record.settings !== undefined &&
+      boundedJsonBytes(record.settings, MAX_NESTED_OPTION_BYTES) === Number.POSITIVE_INFINITY
+    ) {
+      throw new OmpPublicError("Provider configuration is too large");
     }
   }
   if (record.type === "session.prompt") {
@@ -264,8 +294,164 @@ function validateInputEnvelope(input: unknown): asserts input is ProviderInput {
   }
 }
 
-function errorDetails(error: unknown, fallback: string): { message: string } {
-  return { message: isOmpPublicError(error) ? error.message : fallback };
+export interface OmpConnectionDiagnostic {
+  diagnosticId: string;
+  operation: string;
+  errorClass: "TypeError" | "RangeError" | "SyntaxError" | "ReferenceError" | "Error" | "NonError";
+  classification:
+    | "rpc-response-limit"
+    | "rpc-invalid-response"
+    | "rpc-timeout"
+    | "rpc-closed"
+    | "rpc-input-failed"
+    | "rpc-exit"
+    | "spawn-not-found"
+    | "spawn-not-runnable"
+    | "spawn-failed"
+    | "system-error"
+    | "database-error"
+    | "catalog-empty"
+    | "unexpected";
+  stage?: "spawn" | "rpc" | "storage";
+  code?: (typeof SYSTEM_ERROR_CODES)[number] | (typeof DATABASE_ERROR_CODES)[number];
+  exitCode?: number;
+  signal?: (typeof EXIT_SIGNALS)[number];
+}
+
+// Match complete, locally authored messages only. Never log an arbitrary message, error name,
+// stack, cause, request payload, or environment: each can contain credentials or prompt text.
+const KNOWN_FAILURES = new Map<string, Pick<OmpConnectionDiagnostic, "classification" | "stage">>([
+  [
+    "OMP RPC response exceeded command limits",
+    { classification: "rpc-response-limit", stage: "rpc" },
+  ],
+  ["OMP RPC response is invalid", { classification: "rpc-invalid-response", stage: "rpc" }],
+  ["OMP RPC request timed out", { classification: "rpc-timeout", stage: "rpc" }],
+  ["OMP RPC process is closed", { classification: "rpc-closed", stage: "rpc" }],
+  ["OMP RPC process was closed", { classification: "rpc-closed", stage: "rpc" }],
+  ["OMP RPC output channel closed", { classification: "rpc-closed", stage: "rpc" }],
+  ["OMP RPC input channel failed", { classification: "rpc-input-failed", stage: "rpc" }],
+  ["OMP reported no available models", { classification: "catalog-empty", stage: "rpc" }],
+  ["OMP executable was not found", { classification: "spawn-not-found", stage: "spawn" }],
+  ["OMP executable is not runnable", { classification: "spawn-not-runnable", stage: "spawn" }],
+  ["OMP process could not be launched", { classification: "spawn-failed", stage: "spawn" }],
+]);
+
+// These are diagnostic vocabulary, not patterns: an unrecognized code or signal is never emitted.
+const SYSTEM_ERROR_CODES = [
+  "ENOENT",
+  "EACCES",
+  "EPERM",
+  "ENOTDIR",
+  "EISDIR",
+  "ENOSPC",
+  "EMFILE",
+  "ENFILE",
+  "ETIMEDOUT",
+  "ECONNRESET",
+  "ECONNREFUSED",
+  "EPIPE",
+  "EIO",
+] as const;
+const DATABASE_ERROR_CODES = [
+  "SQLITE_ERROR",
+  "SQLITE_BUSY",
+  "SQLITE_LOCKED",
+  "SQLITE_CANTOPEN",
+  "SQLITE_CORRUPT",
+  "SQLITE_NOTADB",
+  "SQLITE_READONLY",
+  "SQLITE_FULL",
+  "SQLITE_IOERR",
+  "ERR_SQLITE_ERROR",
+] as const;
+const EXIT_SIGNALS = [
+  "SIGABRT",
+  "SIGALRM",
+  "SIGBUS",
+  "SIGCHLD",
+  "SIGCONT",
+  "SIGFPE",
+  "SIGHUP",
+  "SIGILL",
+  "SIGINT",
+  "SIGIO",
+  "SIGIOT",
+  "SIGKILL",
+  "SIGPIPE",
+  "SIGPOLL",
+  "SIGPROF",
+  "SIGPWR",
+  "SIGQUIT",
+  "SIGSEGV",
+  "SIGSTKFLT",
+  "SIGSTOP",
+  "SIGSYS",
+  "SIGTERM",
+  "SIGTRAP",
+  "SIGTSTP",
+  "SIGTTIN",
+  "SIGTTOU",
+  "SIGUNUSED",
+  "SIGURG",
+  "SIGUSR1",
+  "SIGUSR2",
+  "SIGVTALRM",
+  "SIGWINCH",
+  "SIGXCPU",
+  "SIGXFSZ",
+  "SIGBREAK",
+  "SIGLOST",
+  "SIGINFO",
+  "unknown",
+] as const;
+
+function classifyFailure(
+  error: unknown,
+): Omit<OmpConnectionDiagnostic, "diagnosticId" | "operation"> {
+  const result: Omit<OmpConnectionDiagnostic, "diagnosticId" | "operation"> = {
+    errorClass:
+      error instanceof TypeError
+        ? "TypeError"
+        : error instanceof RangeError
+          ? "RangeError"
+          : error instanceof SyntaxError
+            ? "SyntaxError"
+            : error instanceof ReferenceError
+              ? "ReferenceError"
+              : error instanceof Error
+                ? "Error"
+                : "NonError",
+    classification: "unexpected",
+  };
+  const message = error instanceof Error ? error.message : undefined;
+  if (typeof message === "string") {
+    const known = KNOWN_FAILURES.get(message);
+    if (known) return { ...result, ...known };
+    const exit = /^OMP RPC process exited \(code (-?(?:0|[1-9]\d{0,9}))\)$/.exec(message);
+    if (exit && exit[0] === message) {
+      const exitCode = Number(exit[1]);
+      if (exitCode >= -2147483648 && exitCode <= 4294967295) {
+        return { ...result, classification: "rpc-exit", stage: "rpc", exitCode };
+      }
+    }
+    const signal = EXIT_SIGNALS.find(
+      (value) => message === `OMP RPC process exited (signal ${value})`,
+    );
+    if (signal) return { ...result, classification: "rpc-exit", stage: "rpc", signal };
+  }
+  // Inspect data properties only; error-code getters may execute arbitrary application code.
+  const code =
+    error && typeof error === "object"
+      ? Object.getOwnPropertyDescriptor(error, "code")?.value
+      : undefined;
+  const systemCode = SYSTEM_ERROR_CODES.find((value) => value === code);
+  if (systemCode) return { ...result, classification: "system-error", code: systemCode };
+  const databaseCode = DATABASE_ERROR_CODES.find((value) => value === code);
+  if (databaseCode) {
+    return { ...result, classification: "database-error", stage: "storage", code: databaseCode };
+  }
+  return result;
 }
 
 type NativeReservation = { owner: symbol; quarantined: boolean };
@@ -494,7 +680,22 @@ export function createOmpConnection(
   mcpConnector?: OmpMcpConnector,
   mcpInitializationTimeoutMs?: number,
   replayTimeoutMs?: number,
+  browserAuthorizationRegistry?: OmpBrowserAuthorizationRegistry,
+  reportDiagnostic: (diagnostic: OmpConnectionDiagnostic) => void = (diagnostic) =>
+    console.error("OMP provider failure", diagnostic),
 ): ProviderConnection {
+  const errorDetails = (error: unknown, fallback: string): { message: string } => {
+    if (isOmpPublicError(error)) return { message: error.message };
+    // The generated ID is the only correlation value we log. It also travels in the public
+    // request failure, avoiding any assumption that a caller-supplied request ID is value-safe.
+    const diagnosticId = randomUUID();
+    try {
+      reportDiagnostic({ diagnosticId, operation: fallback, ...classifyFailure(error) });
+    } catch {
+      // A diagnostic sink must never prevent the request from settling or its cleanup.
+    }
+    return { message: `${fallback} (diagnostic ${diagnosticId})` };
+  };
   const safeCapabilities = [...new Set(capabilities)].filter(
     (capability) =>
       SUPPORTED_CAPABILITIES[capability] &&
@@ -504,7 +705,12 @@ export function createOmpConnection(
   const listeners = new Set<(event: ProviderEvent) => void>();
   const sessions = new Map<
     string,
-    { token: symbol; session: OmpProviderSession; nativeSessionId?: string }
+    {
+      token: symbol;
+      session: OmpProviderSession;
+      nativeSessionId?: string;
+      removeBrowserAuthorization?: () => void;
+    }
   >();
   const opening = new Map<
     string,
@@ -525,6 +731,13 @@ export function createOmpConnection(
     if (closed) return;
     for (const listener of listeners) listener(event);
   };
+  const deleteSession = (sessionId: string, token: symbol): boolean => {
+    const slot = sessions.get(sessionId);
+    if (slot?.token !== token) return false;
+    sessions.delete(sessionId);
+    slot.removeBrowserAuthorization?.();
+    return true;
+  };
 
   const requestFailure = (
     requestId: string,
@@ -696,7 +909,7 @@ export function createOmpConnection(
             );
           };
           const retireRewindSession = () => {
-            if (sessions.get(input.sessionId)?.token === token) sessions.delete(input.sessionId);
+            deleteSession(input.sessionId, token);
           };
           session = await OmpProviderSession.open(
             input,
@@ -735,19 +948,36 @@ export function createOmpConnection(
             nativeReservations.release(nativeSessionId, token);
             return;
           }
-          sessions.set(input.sessionId, { token, session, nativeSessionId });
+          const browserAgentId = input.config.env.PASEO_AGENT_ID?.trim() || input.sessionId;
+          const browserAuthorization = browserAuthorizationRegistry?.register(
+            browserAgentId,
+            session.openPaseoBrowser.bind(session),
+          );
+          session.setBrowserAuthorizationIssuer(browserAuthorization?.issue ?? null);
+          const removeBrowserAuthorization = browserAuthorization
+            ? () => {
+                session?.setBrowserAuthorizationIssuer(null);
+                browserAuthorization.remove();
+              }
+            : undefined;
+          sessions.set(input.sessionId, {
+            token,
+            session,
+            nativeSessionId,
+            ...(removeBrowserAuthorization ? { removeBrowserAuthorization } : {}),
+          });
           await session.publishOpened(input.requestId);
           if (
             closing ||
             controller.signal.aborted ||
             opening.get(input.sessionId)?.token !== token
           ) {
-            if (sessions.get(input.sessionId)?.token === token) sessions.delete(input.sessionId);
+            deleteSession(input.sessionId, token);
             await session.close();
             nativeReservations.release(nativeSessionId, token);
           }
         } catch (error) {
-          if (sessions.get(input.sessionId)?.token === token) sessions.delete(input.sessionId);
+          deleteSession(input.sessionId, token);
           let cleanupError: unknown;
           if (session) {
             try {
@@ -841,11 +1071,11 @@ export function createOmpConnection(
         try {
           await slot.session.close();
         } catch (error) {
-          if (sessions.get(input.sessionId)?.token === slot.token) sessions.delete(input.sessionId);
+          deleteSession(input.sessionId, slot.token);
           quarantineFailedCleanup(input.sessionId, slot.token, error, slot.nativeSessionId);
           throw new OmpPublicError("OMP session close failed");
         }
-        if (sessions.get(input.sessionId)?.token === slot.token) sessions.delete(input.sessionId);
+        deleteSession(input.sessionId, slot.token);
         nativeReservations.release(slot.nativeSessionId, slot.token);
         emit({ type: "request.completed", requestId: input.requestId });
         return;
@@ -862,6 +1092,7 @@ export function createOmpConnection(
     shutdown.abort(shutdownReason);
     for (const { controller } of opening.values()) controller.abort(shutdownReason);
     for (const { session } of sessions.values()) session.beginConnectionShutdown();
+    for (const slot of sessions.values()) slot.removeBrowserAuthorization?.();
     const failures: unknown[] = [];
     const operationBatch = [...activeOperations];
     const operationResults = await Promise.allSettled(operationBatch);