@omercnet/paseo-omp 0.3.0 → 0.4.0-next.119.1

package/server/provider/profile-providers.ts

@@ -43,7 +43,7 @@ function profileDirectory(environment: NodeJS.ProcessEnv): string {
   );
 }
 
-/** Paseo 0.8 contribution registration is synchronous; inspect directory names only. */
+/** Contribution registration is synchronous; inspect directory names only. */
 export function discoverOmpProfilesSync(environment: NodeJS.ProcessEnv = process.env): string[] {
   let directory: Dir;
   try {
@@ -151,7 +151,12 @@ export function createProfileOmpProvider(profile: string, options: OmpProviderOp
   const id = profileProviderId(profile);
   const environment = fixedEnvironment(profile, options.environment ?? process.env);
   const sessionDir = resolve(ompSessionDir(environment));
-  const runtime = options.runtime ?? new OmpRpcRuntime({ environment });
+  const runtime =
+    options.runtime ??
+    new OmpRpcRuntime({
+      environment,
+      reportProtocolViolation: options.reportProtocolViolation,
+    });
   const readPersistedSessionTranscript = runtime.readPersistedSessionTranscript?.bind(runtime);
   const assertSessionDir = (requested?: string) => {
     if (requested !== undefined && resolve(requested) !== sessionDir) {

package/server/provider/registration.ts

@@ -3,10 +3,11 @@ import { homedir } from "node:os";
 import type { ProviderRegistration } from "@getpaseo/plugin/server/provider";
 import { z } from "zod";
 import type { OmpBrowserAuthorizationRegistry } from "../mcp-browser";
+import type { OmpOperationalFailureReporter } from "../operational-failure-diagnostics";
 import { probeOmpAvailability } from "../provider-diagnostics";
 import { createOmpConnection, OmpNativeSessionReservations } from "./connection";
 import type { OmpMcpConnector } from "./host-tools";
-import { OmpRpcRuntime, type OmpRuntime } from "./omp-rpc";
+import { type OmpProtocolViolationDiagnostic, OmpRpcRuntime, type OmpRuntime } from "./omp-rpc";
 import { parseOmpProviderOptions } from "./provider-options";
 import { boundedJsonBytes } from "./security";
 import { OmpProviderOptionsSchema } from "./settings";
@@ -66,6 +67,8 @@ export interface OmpProviderOptions {
   mcpInitializationTimeoutMs?: number;
   mcpConnector?: OmpMcpConnector;
   browserAuthorizationRegistry?: OmpBrowserAuthorizationRegistry;
+  reportProtocolViolation?: (diagnostic: OmpProtocolViolationDiagnostic) => void | Promise<void>;
+  reportOperationalFailure?: OmpOperationalFailureReporter;
   availabilityProbe?: (
     options: ProviderCatalogOptionsCompat,
     timeoutMs: number | undefined,
@@ -85,7 +88,12 @@ function stableJson(value: unknown): string {
 }
 
 export function createOmpProvider(options: OmpProviderOptions = {}): ProviderRegistrationCompat {
-  const runtime = options.runtime ?? new OmpRpcRuntime({ environment: options.environment });
+  const runtime =
+    options.runtime ??
+    new OmpRpcRuntime({
+      environment: options.environment,
+      reportProtocolViolation: options.reportProtocolViolation,
+    });
   const nativeReservations = new OmpNativeSessionReservations();
   return {
     id: "omp-plugin",
@@ -156,6 +164,8 @@ export function createOmpProvider(options: OmpProviderOptions = {}): ProviderReg
         options.mcpInitializationTimeoutMs,
         options.replayTimeoutMs,
         options.browserAuthorizationRegistry,
+        undefined,
+        options.reportOperationalFailure,
       );
     },
   };

package/server/provider/security.ts

@@ -83,16 +83,14 @@ function truncateJsonString(value: string, maxBytes: number): string {
 export function truncateUtf8(value: string, maxBytes: number): string {
   if (utf8Bytes(value) <= maxBytes) return value;
   const suffix = "<truncated>";
-  const budget = Math.max(0, maxBytes - utf8Bytes(suffix));
-  let output = "";
-  let bytes = 0;
-  for (const character of value) {
-    const characterBytes = utf8Bytes(character);
-    if (bytes + characterBytes > budget) break;
-    output += character;
-    bytes += characterBytes;
-  }
-  return `${output}${suffix}`;
+  const suffixBytes = utf8Bytes(suffix);
+  if (maxBytes <= 0) return "";
+  if (maxBytes < suffixBytes) return suffix.slice(0, Math.floor(maxBytes));
+
+  const bytes = Buffer.from(value, "utf8");
+  let end = Math.min(maxBytes - suffixBytes, bytes.byteLength);
+  while (end > 0 && (bytes[end] & 0xc0) === 0x80) end -= 1;
+  return `${bytes.subarray(0, end).toString("utf8")}${suffix}`;
 }
 
 export interface BoundedJsonMetrics {

package/server/provider/session-descriptors.ts

@@ -2,8 +2,9 @@ import { createHash } from "node:crypto";
 import { constants, type Dir } from "node:fs";
 import { type FileHandle, lstat, open, opendir, realpath } from "node:fs/promises";
 import { homedir } from "node:os";
-import { basename, dirname, extname, isAbsolute, join, resolve } from "node:path";
+import { basename, isAbsolute, join, relative, resolve } from "node:path";
 import { ompSessionDir } from "../paths";
+import { isValidImagePayload } from "./image";
 
 const MAX_DESCRIPTOR_PREFIX_BYTES = 64 * 1024;
 const MAX_DESCRIPTOR_SUFFIX_BYTES = 64 * 1024;
@@ -48,6 +49,7 @@ export interface OmpPersistedSessionTranscript {
   nativeSessionId: string;
   byteLength: number;
   messages: unknown[];
+  imageReplayWarning?: true;
 }
 export interface OmpSessionListOptions {
   cwd?: string;
@@ -66,6 +68,11 @@ interface ScanBudget {
   exhausted: boolean;
 }
 
+interface BlobReplayBudget {
+  bytes: number;
+  imageReplayWarning?: true;
+}
+
 export function validateNativeSessionId(value: unknown): string {
   if (typeof value !== "string" || !NATIVE_SESSION_ID.test(value)) {
     throw new Error("Invalid OMP session identifier");
@@ -156,6 +163,7 @@ async function yieldToEventLoop(): Promise<void> {
   setImmediate(result.resolve);
   await result.promise;
 }
+const UNAVAILABLE_IMAGE_MARKER = "[Image unavailable during session replay]";
 async function readStableFile(
   handle: FileHandle,
   byteLength: number,
@@ -213,6 +221,7 @@ async function hydrateBlobImageData(
     ) {
       throw new Error("OMP transcript image blob failed ownership or size validation");
     }
+    budget.bytes += stat.size;
     const bytes = await readStableFile(
       handle,
       stat.size,
@@ -222,7 +231,6 @@ async function hydrateBlobImageData(
     if (createHash("sha256").update(bytes).digest("hex") !== hash) {
       throw new Error("OMP transcript image blob failed integrity validation");
     }
-    budget.bytes += bytes.byteLength;
     return bytes.toString("base64");
   } finally {
     await handle.close().catch(() => undefined);
@@ -232,11 +240,13 @@ async function hydrateBlobImageData(
 async function hydrateImageParts(
   value: unknown,
   blobDirectory: string,
-  budget: { bytes: number },
+  budget: BlobReplayBudget,
+  failureMode: "marker" | "omit",
   signal?: AbortSignal,
 ): Promise<unknown> {
   if (!Array.isArray(value)) return value;
   let hydrated: unknown[] | undefined;
+  let omitted: boolean[] | undefined;
   for (let index = 0; index < value.length; index += 1) {
     const part = value[index];
     if (
@@ -251,30 +261,53 @@ async function hydrateImageParts(
     ) {
       continue;
     }
-    const data = await hydrateBlobImageData(part.data, blobDirectory, budget, signal);
-    hydrated ??= [...value];
-    hydrated[index] = { ...part, data };
+    try {
+      const data = await hydrateBlobImageData(part.data, blobDirectory, budget, signal);
+      const mimeType = "mimeType" in part ? part.mimeType : undefined;
+      if (typeof mimeType !== "string" || !isValidImagePayload(data, mimeType, data.length)) {
+        throw new Error("OMP transcript image blob failed MIME validation");
+      }
+      hydrated ??= [...value];
+      hydrated[index] = { ...part, data };
+    } catch {
+      signal?.throwIfAborted();
+      budget.imageReplayWarning = true;
+      hydrated ??= [...value];
+      if (failureMode === "marker") {
+        hydrated[index] = { type: "text", text: UNAVAILABLE_IMAGE_MARKER };
+      } else {
+        omitted ??= [];
+        omitted[index] = true;
+      }
+    }
   }
-  return hydrated ?? value;
+  if (!hydrated) return value;
+  return omitted ? hydrated.filter((_, index) => !omitted[index]) : hydrated;
 }
 
 async function hydratePersistedMessageImages(
   message: unknown,
   blobDirectory: string | undefined,
-  budget: { bytes: number },
+  budget: BlobReplayBudget,
   signal?: AbortSignal,
 ): Promise<unknown> {
   if (!blobDirectory || !message || typeof message !== "object" || Array.isArray(message)) {
     return message;
   }
   const record = message as Record<string, unknown>;
-  let content = await hydrateImageParts(record.content, blobDirectory, budget, signal);
+  let content = await hydrateImageParts(record.content, blobDirectory, budget, "marker", signal);
   if (content && typeof content === "object" && !Array.isArray(content)) {
     const contentRecord = content as Record<string, unknown>;
-    const nested = await hydrateImageParts(contentRecord.content, blobDirectory, budget, signal);
+    const nested = await hydrateImageParts(
+      contentRecord.content,
+      blobDirectory,
+      budget,
+      "marker",
+      signal,
+    );
     if (nested !== contentRecord.content) content = { ...contentRecord, content: nested };
   }
-  const images = await hydrateImageParts(record.images, blobDirectory, budget, signal);
+  const images = await hydrateImageParts(record.images, blobDirectory, budget, "omit", signal);
   if (content === record.content && images === record.images) return message;
   return { ...record, content, images };
 }
@@ -477,16 +510,19 @@ interface PersistedTranscriptNode {
   message?: unknown;
 }
 
-function persistedTranscriptMessage(record: Record<string, unknown>, entryId: string): unknown {
+function persistedTranscriptMessage(record: Record<string, unknown>, entryId?: string): unknown {
   if (record.type === "message") {
     if (!record.message || typeof record.message !== "object" || Array.isArray(record.message))
       return;
-    return { ...(record.message as Record<string, unknown>), entryId };
+    return {
+      ...(record.message as Record<string, unknown>),
+      ...(entryId ? { entryId } : {}),
+    };
   }
   if (record.type !== "custom_message") return;
   return {
     role: "custom",
-    entryId,
+    ...(entryId ? { entryId } : {}),
     customType: record.customType,
     content: record.content,
     display: record.display,
@@ -620,7 +656,7 @@ export async function readOmpPersistedSessionTranscript(
       throw new Error("OMP session transcript exceeds message limits");
     }
     const hydratedMessages: unknown[] = [];
-    const blobBudget = { bytes: 0 };
+    const blobBudget: BlobReplayBudget = { bytes: 0 };
     for (const message of messages) {
       signal?.throwIfAborted();
       hydratedMessages.push(
@@ -632,6 +668,7 @@ export async function readOmpPersistedSessionTranscript(
       nativeSessionId,
       byteLength: bytes.byteLength,
       messages: hydratedMessages,
+      ...(blobBudget.imageReplayWarning ? { imageReplayWarning: true as const } : {}),
     };
   } catch (error) {
     if (error instanceof Error) throw error;
@@ -646,6 +683,7 @@ export async function readOmpPersistedSubagentTranscript(
   childTranscriptId: string,
   cwd: string,
   signal?: AbortSignal,
+  childSessionFile?: string,
 ): Promise<OmpPersistedSubagentTranscript> {
   signal?.throwIfAborted();
   if (
@@ -653,7 +691,12 @@ export async function readOmpPersistedSubagentTranscript(
     !parentSessionFile.endsWith(".jsonl") ||
     parentSessionFile.includes("\0") ||
     !CHILD_TRANSCRIPT_ID.test(childTranscriptId) ||
-    basename(childTranscriptId) !== childTranscriptId
+    basename(childTranscriptId) !== childTranscriptId ||
+    (childSessionFile !== undefined &&
+      (!isAbsolute(childSessionFile) ||
+        !childSessionFile.endsWith(".jsonl") ||
+        childSessionFile.includes("\0") ||
+        basename(childSessionFile) !== `${childTranscriptId}.jsonl`))
   ) {
     throw new Error("Invalid OMP child transcript descriptor");
   }
@@ -673,34 +716,53 @@ export async function readOmpPersistedSubagentTranscript(
     await parentHandle.close().catch(() => undefined);
   }
   const canonicalParent = await realpath(parentSessionFile);
-  const parentExtension = extname(canonicalParent);
-  const expectedDirectory = canonicalParent.slice(0, -parentExtension.length);
+  const expectedDirectory = canonicalParent.slice(0, -".jsonl".length);
   const canonicalDirectory = await realpath(expectedDirectory).catch(() => undefined);
   if (!canonicalDirectory || canonicalDirectory !== expectedDirectory) {
     throw new Error("OMP child transcript directory is not canonically owned by its parent");
   }
-  const sessionFile = join(canonicalDirectory, `${childTranscriptId}.jsonl`);
+  const requestedFile = resolve(
+    childSessionFile ?? join(canonicalDirectory, `${childTranscriptId}.jsonl`),
+  );
   let handle: FileHandle;
   try {
     handle = await open(
-      sessionFile,
+      requestedFile,
       constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0),
     );
   } catch {
     throw new Error("OMP child transcript could not be opened");
   }
   try {
-    const [stat, canonicalChild] = await Promise.all([handle.stat(), realpath(sessionFile)]);
+    const [stat, pathStat, canonicalChild] = await Promise.all([
+      handle.stat(),
+      lstat(requestedFile),
+      realpath(requestedFile),
+    ]);
     if (
       !stat.isFile() ||
-      stat.size > MAX_CHILD_TRANSCRIPT_BYTES ||
-      dirname(canonicalChild) !== canonicalDirectory ||
-      canonicalChild !== sessionFile
+      !pathStat.isFile() ||
+      pathStat.isSymbolicLink() ||
+      stat.dev !== pathStat.dev ||
+      stat.ino !== pathStat.ino ||
+      stat.size > MAX_CHILD_TRANSCRIPT_BYTES
     ) {
       throw new Error("OMP child transcript failed ownership validation");
     }
-    const bytes = await handle.readFile();
-    signal?.throwIfAborted();
+    const canonicalRelativeChild = relative(canonicalDirectory, canonicalChild);
+    if (
+      !canonicalRelativeChild ||
+      canonicalRelativeChild.startsWith("..") ||
+      isAbsolute(canonicalRelativeChild)
+    ) {
+      throw new Error("OMP child transcript failed ownership validation");
+    }
+    const bytes = await readStableFile(
+      handle,
+      stat.size,
+      signal,
+      "OMP child transcript changed while reading",
+    );
     const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
     const messages: unknown[] = [];
     let nativeSessionId: string | undefined;
@@ -718,15 +780,21 @@ export async function readOmpPersistedSubagentTranscript(
         nativeSessionId ??= candidateId;
         if (nativeSessionId !== candidateId)
           throw new Error("OMP child transcript identity changed");
-      } else if (record.type === "message" && record.message !== undefined) {
+      } else {
+        const entryId =
+          typeof record.id === "string" && CHILD_TRANSCRIPT_ID.test(record.id)
+            ? record.id
+            : undefined;
+        const message = persistedTranscriptMessage(record, entryId);
+        if (message === undefined) continue;
         if (messages.length >= MAX_CHILD_TRANSCRIPT_MESSAGES) {
           throw new Error("OMP child transcript exceeds message limits");
         }
-        messages.push(record.message);
+        messages.push(message);
       }
     }
     if (!nativeSessionId) throw new Error("OMP child transcript is missing session identity");
-    return { sessionFile, nativeSessionId, byteLength: bytes.byteLength, messages };
+    return { sessionFile: canonicalChild, nativeSessionId, byteLength: bytes.byteLength, messages };
   } catch (error) {
     if (error instanceof Error) throw error;
     throw new Error("OMP child transcript could not be decoded");