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

package/server/provider/profile-providers.ts

@@ -0,0 +1,249 @@
+import { type Dir, opendirSync } from "node:fs";
+import { opendir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, join, resolve } from "node:path";
+import { isOmpProfileName } from "../../shared/omp-store";
+import { ompAgentDir, ompCacheDir, ompDataDir, ompSessionDir, ompStateDir } from "../paths";
+import { OmpRpcRuntime, type OmpRuntime, type OmpStartOptions } from "./omp-rpc";
+import { parseOmpProviderOptions } from "./provider-options";
+import { createOmpProvider, type OmpProviderOptions } from "./registration";
+import { OmpPublicError } from "./security";
+
+const MAX_PROFILES = 128;
+const MAX_DIRECTORY_ENTRIES = 4_096;
+const STORE_ENV_NAMES: Readonly<Record<string, true>> = {
+  OMP_PROFILE: true,
+  PI_PROFILE: true,
+  PASEO_OMP_AGENT_DIR: true,
+  OMP_AGENT_DIR: true,
+  PI_CODING_AGENT_DIR: true,
+  OMP_SESSION_DIR: true,
+  PI_CODING_AGENT_SESSION_DIR: true,
+  PI_CONFIG_FILES: true,
+};
+const PROFILE_OVERRIDE_ENV_NAMES: Readonly<Record<string, true>> = {
+  ...STORE_ENV_NAMES,
+  PI_CONFIG_DIR: true,
+  HOME: true,
+  USERPROFILE: true,
+  XDG_DATA_HOME: true,
+  XDG_STATE_HOME: true,
+  XDG_CACHE_HOME: true,
+};
+
+function validateProfile(profile: string): void {
+  if (!isOmpProfileName(profile)) throw new OmpPublicError("Invalid named OMP profile");
+}
+
+function profileDirectory(environment: NodeJS.ProcessEnv): string {
+  return join(
+    environment.HOME ?? environment.USERPROFILE ?? homedir(),
+    environment.PI_CONFIG_DIR || ".omp",
+    "profiles",
+  );
+}
+
+/** Paseo 0.8 contribution registration is synchronous; inspect directory names only. */
+export function discoverOmpProfilesSync(environment: NodeJS.ProcessEnv = process.env): string[] {
+  let directory: Dir;
+  try {
+    directory = opendirSync(profileDirectory(environment));
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return [];
+    throw new OmpPublicError("OMP profile directory could not be read");
+  }
+  const profiles: string[] = [];
+  let count = 0;
+  try {
+    for (let entry = directory.readSync(); entry; entry = directory.readSync()) {
+      if (++count > MAX_DIRECTORY_ENTRIES)
+        throw new OmpPublicError("OMP profile directory is too large");
+      if (entry.isDirectory() && isOmpProfileName(entry.name)) profiles.push(entry.name);
+    }
+  } finally {
+    directory.closeSync();
+  }
+  return profiles.sort().slice(0, MAX_PROFILES);
+}
+
+/** Enumerate names only; never open profile configuration, databases, or credential files. */
+export async function discoverOmpProfiles(
+  environment: NodeJS.ProcessEnv = process.env,
+): Promise<string[]> {
+  let directory: Dir;
+  try {
+    directory = await opendir(profileDirectory(environment));
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return [];
+    throw new OmpPublicError("OMP profile directory could not be read");
+  }
+  const profiles: string[] = [];
+  let count = 0;
+  for await (const entry of directory) {
+    if (++count > MAX_DIRECTORY_ENTRIES) {
+      throw new OmpPublicError("OMP profile directory is too large");
+    }
+    if (entry.isDirectory() && isOmpProfileName(entry.name)) profiles.push(entry.name);
+  }
+  return profiles.sort().slice(0, MAX_PROFILES);
+}
+
+export function profileProviderId(profile: string): string {
+  validateProfile(profile);
+  return `omp-plugin-${profile}`;
+}
+
+function fixedEnvironment(profile: string, source: NodeJS.ProcessEnv): NodeJS.ProcessEnv {
+  const environment = { ...source };
+  for (const name of Object.keys(environment)) {
+    if (STORE_ENV_NAMES[name.toUpperCase()]) delete environment[name];
+  }
+  environment.OMP_PROFILE = profile;
+  environment.PI_CODING_AGENT_DIR = join(profileDirectory(source), profile, "agent");
+  return environment;
+}
+
+function profileCommand(
+  command: readonly string[],
+  profile: string,
+  sessionDir: string,
+): readonly string[] {
+  // Environment-control flags can erase or replace the fixed profile/config/XDG
+  // roots before OMP sees --profile. Allow plain assignment wrappers, not env's
+  // -i, -u, -S, -C (or their long forms), including wrappers nested after `--`.
+  for (let index = 0; index < command.length; index += 1) {
+    const executable = basename(command[index]).toLowerCase();
+    if (executable !== "env" && executable !== "env.exe") continue;
+    for (const argument of command.slice(index + 1)) {
+      if (argument === "--") break;
+      if (argument.startsWith("-"))
+        throw new OmpPublicError("OMP profile command cannot alter its environment with env flags");
+      if (!/^[A-Za-z_][A-Za-z0-9_]*=/u.test(argument)) break;
+    }
+  }
+  let hasProfile = false;
+  for (let index = 1; index < command.length; index += 1) {
+    const argument = command[index];
+    const assignment = /^([A-Za-z_][A-Za-z0-9_]*)=/u.exec(argument);
+    if (assignment && PROFILE_OVERRIDE_ENV_NAMES[assignment[1].toUpperCase()]) {
+      throw new OmpPublicError("OMP profile command cannot override its selected store");
+    }
+    if (argument === "--profile" || argument.startsWith("--profile=")) {
+      const selected = argument === "--profile" ? command[++index] : argument.slice(10);
+      if (selected !== profile) {
+        throw new OmpPublicError("OMP command profile conflicts with the selected provider");
+      }
+      hasProfile = true;
+    } else if (argument === "--session-dir" || argument.startsWith("--session-dir=")) {
+      const selected = argument === "--session-dir" ? command[++index] : argument.slice(14);
+      if (!selected || resolve(selected) !== sessionDir) {
+        throw new OmpPublicError(
+          "OMP command session directory conflicts with the selected profile",
+        );
+      }
+    }
+  }
+  return hasProfile ? command : [...command, "--profile", profile];
+}
+
+/** Each provider owns one profile before the host requests a catalog or creates an agent. */
+export function createProfileOmpProvider(profile: string, options: OmpProviderOptions = {}) {
+  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 readPersistedSessionTranscript = runtime.readPersistedSessionTranscript?.bind(runtime);
+  const assertSessionDir = (requested?: string) => {
+    if (requested !== undefined && resolve(requested) !== sessionDir) {
+      throw new OmpPublicError("OMP session directory conflicts with the selected profile");
+    }
+  };
+  const assertEnvironment = (sessionEnv?: Readonly<Record<string, string>>) => {
+    for (const name of Object.keys(sessionEnv ?? {})) {
+      if (PROFILE_OVERRIDE_ENV_NAMES[name.toUpperCase()]) {
+        throw new OmpPublicError("OMP session environment cannot override its selected profile");
+      }
+    }
+  };
+  const scopedRuntime: OmpRuntime = {
+    get supportsPersistence() {
+      return runtime.supportsPersistence;
+    },
+    async startSession(start: OmpStartOptions) {
+      assertSessionDir(start.sessionDir);
+      assertEnvironment(start.env);
+      return runtime.startSession({
+        ...start,
+        command: profileCommand(
+          start.command ?? [environment.OMP_COMMAND ?? "omp"],
+          profile,
+          sessionDir,
+        ),
+        environment,
+        sessionDir,
+      });
+    },
+    async listSessions(listOptions) {
+      assertSessionDir(listOptions.sessionDir);
+      return runtime.listSessions({ ...listOptions, sessionDir });
+    },
+    ...(readPersistedSessionTranscript
+      ? {
+          readPersistedSessionTranscript(input) {
+            return readPersistedSessionTranscript(input);
+          },
+        }
+      : {}),
+    readPersistedSubagentTranscript(input) {
+      return runtime.readPersistedSubagentTranscript(input);
+    },
+  };
+  const provider = createOmpProvider({
+    ...options,
+    runtime: scopedRuntime,
+    environment,
+    catalogIdentity: {
+      profile,
+      agentRoot: ompAgentDir(environment),
+      dataRoot: ompDataDir(environment),
+      cacheRoot: ompCacheDir(environment),
+      stateRoot: ompStateDir(environment),
+      sessionRoot: sessionDir,
+    },
+  });
+  const validateCatalog = (
+    input: Parameters<NonNullable<typeof provider.getCatalogCacheKey>>[0],
+  ) => {
+    const parsed = parseOmpProviderOptions(input.providerOptions);
+    assertEnvironment(parsed.env);
+    assertSessionDir(parsed.params?.sessionDir);
+    return profileCommand(
+      parsed.command ?? [environment.OMP_COMMAND ?? "omp"],
+      profile,
+      sessionDir,
+    );
+  };
+  return {
+    ...provider,
+    async getCatalogCacheKey(
+      input: Parameters<NonNullable<typeof provider.getCatalogCacheKey>>[0],
+    ) {
+      validateCatalog(input);
+      return provider.getCatalogCacheKey?.(input);
+    },
+    async checkAvailability(
+      input: Parameters<NonNullable<typeof provider.checkAvailability>>[0],
+      context?: Parameters<NonNullable<typeof provider.checkAvailability>>[1],
+    ) {
+      const command = validateCatalog(input);
+      if (!provider.checkAvailability)
+        throw new OmpPublicError("OMP availability probe is unavailable");
+      return provider.checkAvailability(
+        { ...input, providerOptions: { ...input.providerOptions, command } },
+        context,
+      );
+    },
+    id,
+    label: `OMP · ${profile}`,
+  };
+}

package/server/provider/registration.ts

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import { homedir } from "node:os";
 import type { ProviderRegistration } from "@getpaseo/plugin/server/provider";
 import { z } from "zod";
+import type { OmpBrowserAuthorizationRegistry } from "../mcp-browser";
 import { probeOmpAvailability } from "../provider-diagnostics";
 import { createOmpConnection, OmpNativeSessionReservations } from "./connection";
 import type { OmpMcpConnector } from "./host-tools";
@@ -48,6 +49,7 @@ const CAPABILITIES = [
   "session.subsession",
   "session.revert.conversation",
   "permission",
+  "timeline.plugin",
 ] as const;
 const ConnectRequestSchema = z.object({
   versions: z.array(z.number().int().positive().max(16)).min(1).max(8),
@@ -59,8 +61,11 @@ export interface OmpProviderOptions {
   timelineScheduler?: OmpTimelineScheduler;
   replayTimeoutMs?: number;
   environment?: NodeJS.ProcessEnv;
+  /** Fixed, non-secret profile/store identity for providers whose configuration is server-owned. */
+  catalogIdentity?: Readonly<Record<string, string>>;
   mcpInitializationTimeoutMs?: number;
   mcpConnector?: OmpMcpConnector;
+  browserAuthorizationRegistry?: OmpBrowserAuthorizationRegistry;
   availabilityProbe?: (
     options: ProviderCatalogOptionsCompat,
     timeoutMs: number | undefined,
@@ -90,9 +95,14 @@ export function createOmpProvider(options: OmpProviderOptions = {}): ProviderReg
     providerOptionsSchema: OmpProviderOptionsSchema,
     async getCatalogCacheKey(catalogOptions) {
       const providerOptions = parseOmpProviderOptions(catalogOptions.providerOptions);
+      // Profile providers cannot safely hash explicit environment values because they may be
+      // credentials. Disable sharing for that case; otherwise retain every normalized option
+      // that can change discovery alongside the fixed, non-secret store identity.
+      if (options.catalogIdentity && Object.keys(providerOptions.env ?? {}).length > 0) return;
       const identity = {
         scope: catalogOptions.scope,
         ...(catalogOptions.scope === "workspace" ? { cwd: catalogOptions.cwd } : {}),
+        ...(options.catalogIdentity ? { store: options.catalogIdentity } : {}),
         providerOptions,
         settings: catalogOptions.settings ?? {},
         defaultCommand: (options.environment ?? process.env).OMP_COMMAND ?? "omp",
@@ -145,6 +155,7 @@ export function createOmpProvider(options: OmpProviderOptions = {}): ProviderReg
         options.mcpConnector,
         options.mcpInitializationTimeoutMs,
         options.replayTimeoutMs,
+        options.browserAuthorizationRegistry,
       );
     },
   };

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 {