@omercnet/paseo-omp 0.2.1-next.72.1

package/server/hub.ts

@@ -0,0 +1,145 @@
+import { readdir, readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { RpcInput } from "@getpaseo/plugin";
+import { z } from "zod";
+import type { HubProcess, listHubProcesses, tailHubLog } from "../shared/hub";
+
+const MAX_LOG_BYTES = 64 * 1024;
+
+const ScopeFileSchema = z.object({ projectDir: z.string() });
+const MetaFileSchema = z.object({
+  daemon: z.object({
+    state: z.string(),
+    owner: z.string().optional(),
+    restartCount: z.number().optional(),
+    persist: z.boolean().optional(),
+    detached: z.boolean().optional(),
+    createdAt: z.number().optional(),
+    startedAt: z.number().optional(),
+    readyAt: z.number().optional(),
+    exitedAt: z.number().optional(),
+    exitCode: z.number().optional(),
+  }),
+  spec: z.object({
+    application: z.string(),
+    args: z.array(z.string()).optional(),
+    cwd: z.string().optional(),
+  }),
+});
+
+/**
+ * omp's hub keeps per-project process state at
+ * ~/.omp/run/daemons/<projectHash>/{scope.json, daemons/<name>/{meta.json,output.log}}.
+ * `scope.json.projectDir` matches a workspace's cwd exactly, so a project's hub processes can
+ * be resolved without any cooperation from the omp process itself.
+ *
+ * This is an internal, unversioned implementation detail of the omp harness: every read below
+ * is best-effort and degrades to an empty/partial result instead of throwing when a file is
+ * missing, unreadable, or shaped differently than expected (a future omp release is free to
+ * change or remove this layout).
+ */
+function ompRunDir(): string {
+  return process.env.PASEO_OMP_RUN_DIR ?? join(homedir(), ".omp", "run", "daemons");
+}
+
+async function readJsonFile(path: string): Promise<unknown | undefined> {
+  try {
+    return JSON.parse(await readFile(path, "utf8"));
+  } catch {
+    return undefined;
+  }
+}
+
+async function listDirNames(path: string): Promise<string[]> {
+  try {
+    return await readdir(path);
+  } catch {
+    return [];
+  }
+}
+
+async function findProjectDaemonRoots(root: string, cwd: string): Promise<string[]> {
+  const hashes = await listDirNames(root);
+  const matches: string[] = [];
+  await Promise.all(
+    hashes.map(async (hash) => {
+      const scope = ScopeFileSchema.safeParse(await readJsonFile(join(root, hash, "scope.json")));
+      if (scope.success && scope.data.projectDir === cwd) matches.push(join(root, hash));
+    }),
+  );
+  return matches;
+}
+
+function toHubProcess(name: string, value: unknown): HubProcess | undefined {
+  const parsed = MetaFileSchema.safeParse(value);
+  if (!parsed.success) return undefined;
+  const { daemon, spec } = parsed.data;
+  return {
+    name,
+    application: spec.application,
+    args: spec.args ?? [],
+    cwd: spec.cwd ?? "",
+    state: daemon.state,
+    owner: daemon.owner ?? null,
+    restartCount: daemon.restartCount ?? 0,
+    persist: daemon.persist ?? false,
+    detached: daemon.detached ?? false,
+    createdAt: daemon.createdAt ?? null,
+    startedAt: daemon.startedAt ?? null,
+    readyAt: daemon.readyAt ?? null,
+    exitedAt: daemon.exitedAt ?? null,
+    exitCode: daemon.exitCode ?? null,
+  };
+}
+
+export async function listHubProcessesFrom(root: string, cwd: string): Promise<HubProcess[]> {
+  const roots = await findProjectDaemonRoots(root, cwd);
+  const processes: HubProcess[] = [];
+  await Promise.all(
+    roots.map(async (projectRoot) => {
+      const names = await listDirNames(join(projectRoot, "daemons"));
+      await Promise.all(
+        names.map(async (name) => {
+          const meta = await readJsonFile(join(projectRoot, "daemons", name, "meta.json"));
+          const process = toHubProcess(name, meta);
+          if (process) processes.push(process);
+        }),
+      );
+    }),
+  );
+  processes.sort((a, b) => (b.startedAt ?? 0) - (a.startedAt ?? 0));
+  return processes;
+}
+
+export async function resolveListHubProcesses({
+  cwd,
+}: RpcInput<typeof listHubProcesses>): Promise<{ processes: HubProcess[] }> {
+  return { processes: await listHubProcessesFrom(ompRunDir(), cwd) };
+}
+
+export async function tailHubLogFrom(
+  root: string,
+  cwd: string,
+  name: string,
+): Promise<{ content: string; truncated: boolean }> {
+  const roots = await findProjectDaemonRoots(root, cwd);
+  for (const projectRoot of roots) {
+    try {
+      const buffer = await readFile(join(projectRoot, "daemons", name, "output.log"));
+      const truncated = buffer.byteLength > MAX_LOG_BYTES;
+      const slice = truncated ? buffer.subarray(buffer.byteLength - MAX_LOG_BYTES) : buffer;
+      return { content: slice.toString("utf8"), truncated };
+    } catch {
+      // This root doesn't have that process (or its log vanished); try the next match.
+    }
+  }
+  return { content: "", truncated: false };
+}
+
+export async function resolveTailHubLog({
+  cwd,
+  name,
+}: RpcInput<typeof tailHubLog>): Promise<{ content: string; truncated: boolean }> {
+  return tailHubLogFrom(ompRunDir(), cwd, name);
+}

package/server/mcp-browser.ts

@@ -0,0 +1,95 @@
+import { randomUUID } from "node:crypto";
+import type { RpcInput } from "@getpaseo/plugin";
+import type { openOmpMcpAuthorizationInPaseoBrowser } from "../shared/mcp";
+import { OmpPublicError } from "./provider/security";
+
+const MAX_REGISTERED_SESSIONS = 32;
+const MAX_AUTHORIZATIONS_PER_SESSION = 16;
+
+type BrowserAuthorizationOpener = (url: string) => Promise<void>;
+
+type RegisteredSession = {
+  token: symbol;
+  open: BrowserAuthorizationOpener;
+  authorizations: Set<string>;
+};
+
+type RegisteredAuthorization = {
+  agentId: string;
+  sessionToken: symbol;
+  url: string;
+  open: BrowserAuthorizationOpener;
+};
+
+export interface OmpBrowserAuthorizationRegistration {
+  issue(url: string): string | undefined;
+  remove(): void;
+}
+
+export class OmpBrowserAuthorizationRegistry {
+  private readonly sessions = new Map<string, RegisteredSession>();
+  private readonly authorizations = new Map<string, RegisteredAuthorization>();
+
+  register(agentId: string, open: BrowserAuthorizationOpener): OmpBrowserAuthorizationRegistration {
+    if (this.sessions.has(agentId)) {
+      throw new OmpPublicError("OMP browser authorization is already registered for this agent");
+    }
+    if (this.sessions.size >= MAX_REGISTERED_SESSIONS) {
+      throw new OmpPublicError("OMP browser authorization session limit reached");
+    }
+    const session: RegisteredSession = { token: Symbol(agentId), open, authorizations: new Set() };
+    this.sessions.set(agentId, session);
+
+    return {
+      issue: (url) => {
+        if (this.sessions.get(agentId) !== session) return;
+        if (session.authorizations.size >= MAX_AUTHORIZATIONS_PER_SESSION) {
+          const oldest = session.authorizations.values().next().value;
+          if (oldest) {
+            session.authorizations.delete(oldest);
+            this.authorizations.delete(oldest);
+          }
+        }
+        const authorizationToken = randomUUID();
+        session.authorizations.add(authorizationToken);
+        this.authorizations.set(authorizationToken, {
+          agentId,
+          sessionToken: session.token,
+          url,
+          open,
+        });
+        return authorizationToken;
+      },
+      remove: () => {
+        if (this.sessions.get(agentId) !== session) return;
+        this.sessions.delete(agentId);
+        for (const authorizationToken of session.authorizations) {
+          this.authorizations.delete(authorizationToken);
+        }
+        session.authorizations.clear();
+      },
+    };
+  }
+
+  async open(authorizationToken: string): Promise<void> {
+    const authorization = this.authorizations.get(authorizationToken);
+    const session = authorization ? this.sessions.get(authorization.agentId) : undefined;
+    if (!authorization || session?.token !== authorization.sessionToken) {
+      throw new OmpPublicError("The OMP browser authorization is no longer available");
+    }
+    await authorization.open(authorization.url);
+  }
+
+  clear(): void {
+    this.authorizations.clear();
+    this.sessions.clear();
+  }
+}
+
+export async function resolveOpenOmpMcpAuthorizationInPaseoBrowser(
+  input: RpcInput<typeof openOmpMcpAuthorizationInPaseoBrowser>,
+  registry: OmpBrowserAuthorizationRegistry,
+): Promise<{ opened: true }> {
+  await registry.open(input.authorizationToken);
+  return { opened: true };
+}

package/server/memory.ts

@@ -0,0 +1,86 @@
+import { readdir, stat } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import type { RpcInput } from "@getpaseo/plugin";
+import { z } from "zod";
+import type { listOmpMemory, OmpMemoryFact } from "../shared/memory";
+import { ompStateDir } from "./paths";
+
+const FactRowSchema = z.object({
+  id: z.string(),
+  subject: z.string(),
+  predicate: z.string(),
+  object: z.string(),
+  confidence: z.number().min(0).max(1).nullable(),
+  timestamp: z.string().nullable(),
+});
+
+type CandidateBank = { name: string; modifiedAt: number };
+
+async function newestBank(root: string, cwd: string): Promise<string | undefined> {
+  const prefix = `${basename(cwd)}-`;
+  try {
+    const entries = await readdir(root, { withFileTypes: true });
+    const candidates = await Promise.all(
+      entries
+        .filter((entry) => entry.isDirectory() && entry.name.startsWith(prefix))
+        .map(async (entry): Promise<CandidateBank | undefined> => {
+          try {
+            return { name: entry.name, modifiedAt: (await stat(join(root, entry.name))).mtimeMs };
+          } catch {
+            return undefined;
+          }
+        }),
+    );
+    return candidates
+      .flatMap((candidate) => (candidate ? [candidate] : []))
+      .sort((a, b) => b.modifiedAt - a.modifiedAt)[0]?.name;
+  } catch {
+    return undefined;
+  }
+}
+
+export function listOmpFactsFrom(path: string): OmpMemoryFact[] {
+  try {
+    const database = new DatabaseSync(path, { readOnly: true, timeout: 500 });
+    try {
+      const rows = database
+        .prepare(
+          `SELECT fact_id AS id, subject, predicate, object, confidence, timestamp
+           FROM facts
+           ORDER BY COALESCE(timestamp, created_at) DESC
+           LIMIT 100`,
+        )
+        .all();
+      return rows.flatMap((row) => {
+        const parsed = FactRowSchema.safeParse(row);
+        if (!parsed.success) return [];
+        return [
+          {
+            ...parsed.data,
+            confidence: parsed.data.confidence ?? 1,
+          },
+        ];
+      });
+    } finally {
+      database.close();
+    }
+  } catch {
+    return [];
+  }
+}
+
+export async function listOmpMemoryFrom(
+  root: string,
+  cwd: string,
+): Promise<{ bank: string | null; facts: OmpMemoryFact[] }> {
+  const bank = await newestBank(root, cwd);
+  if (!bank) return { bank: null, facts: [] };
+  return { bank, facts: listOmpFactsFrom(join(root, bank, "mnemopi.db")) };
+}
+
+export async function resolveListOmpMemory({
+  cwd,
+}: RpcInput<typeof listOmpMemory>): Promise<{ bank: string | null; facts: OmpMemoryFact[] }> {
+  return listOmpMemoryFrom(join(ompStateDir(), "memories", "mnemopi", "banks"), cwd);
+}

package/server/mutation-queue.ts

@@ -0,0 +1,12 @@
+export class SerialMutationQueue {
+  private tail: Promise<void> = Promise.resolve();
+
+  run<T>(operation: () => Promise<T>): Promise<T> {
+    const result = this.tail.then(operation, operation);
+    this.tail = result.then(
+      () => undefined,
+      () => undefined,
+    );
+    return result;
+  }
+}

package/server/omp-config.ts

@@ -0,0 +1,135 @@
+import { readFile } from "node:fs/promises";
+import { isAbsolute, join } from "node:path";
+import type { RpcInput } from "@getpaseo/plugin";
+import { parse as parseYaml } from "yaml";
+import type { ZodType } from "zod";
+import {
+  type listOmpConfig,
+  type OmpConfig,
+  OmpConfigSchema,
+  OmpDevSectionSchema,
+  OmpGithubSectionSchema,
+  OmpMemorySectionSchema,
+  OmpModelRolesSchema,
+  OmpRetrySectionSchema,
+  OmpThemeSectionSchema,
+} from "../shared/omp-config";
+import { ompAgentDir } from "./paths";
+
+/**
+ * omp writes its global settings to `~/.omp/agent/config.yml`, falling back to legacy
+ * `config.yaml` (mirrors omp's `MAIN_CONFIG_FILENAMES`, canonical filename first). This is an
+ * internal, unversioned file: reading it here is best-effort and degrades to "unavailable"
+ * instead of throwing when the file is missing, unreadable, or not a YAML mapping.
+ */
+const CONFIG_FILENAMES = ["config.yml", "config.yaml"] as const;
+
+type OmpConfigResult = { path: string; available: boolean; config: OmpConfig | null };
+
+async function readFirstExisting(
+  dir: string,
+  filenames: readonly string[] = CONFIG_FILENAMES,
+): Promise<{ path: string; text: string } | undefined> {
+  for (const filename of filenames) {
+    const path = join(dir, filename);
+    try {
+      return { path, text: await readFile(path, "utf8") };
+    } catch {
+      // Try the next candidate filename.
+    }
+  }
+  return undefined;
+}
+
+/** Validates one top-level section independently so an unrelated malformed field never hides the rest. */
+function section<Schema extends ZodType>(
+  schema: Schema,
+  value: unknown,
+): Schema["_output"] | undefined {
+  if (value === undefined) return undefined;
+  const result = schema.safeParse(value);
+  return result.success ? result.data : undefined;
+}
+
+/**
+ * Maps a parsed YAML document onto the safe allowlist in `shared/omp-config.ts`. Every field is
+ * read explicitly by name; nothing on the source object is spread, stringified, or forwarded
+ * unchecked, so an unrecognized or credential-shaped key never reaches the caller.
+ */
+export function parseOmpConfig(raw: unknown): OmpConfig {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return {};
+  const record = raw as Record<string, unknown>;
+  const config: OmpConfig = {};
+
+  const setupVersion = section(OmpConfigSchema.shape.setupVersion, record.setupVersion);
+  if (setupVersion !== undefined) config.setupVersion = setupVersion;
+
+  const symbolPreset = section(OmpConfigSchema.shape.symbolPreset, record.symbolPreset);
+  if (symbolPreset !== undefined) config.symbolPreset = symbolPreset;
+
+  const defaultThinkingLevel = section(
+    OmpConfigSchema.shape.defaultThinkingLevel,
+    record.defaultThinkingLevel,
+  );
+  if (defaultThinkingLevel !== undefined) config.defaultThinkingLevel = defaultThinkingLevel;
+
+  const theme = section(OmpThemeSectionSchema, record.theme);
+  if (theme !== undefined) config.theme = theme;
+
+  const memory = section(OmpMemorySectionSchema, record.memory);
+  if (memory !== undefined) config.memory = memory;
+
+  const github = section(OmpGithubSectionSchema, record.github);
+  if (github !== undefined) config.github = github;
+
+  const disabledProviders = section(
+    OmpConfigSchema.shape.disabledProviders,
+    record.disabledProviders,
+  );
+  if (disabledProviders !== undefined) config.disabledProviders = disabledProviders;
+
+  const modelProviderOrder = section(
+    OmpConfigSchema.shape.modelProviderOrder,
+    record.modelProviderOrder,
+  );
+  if (modelProviderOrder !== undefined) config.modelProviderOrder = modelProviderOrder;
+
+  const modelRoles = section(OmpModelRolesSchema, record.modelRoles);
+  if (modelRoles !== undefined) config.modelRoles = modelRoles;
+
+  const enabledModels = section(OmpConfigSchema.shape.enabledModels, record.enabledModels);
+  if (enabledModels !== undefined) config.enabledModels = enabledModels;
+
+  const retry = section(OmpRetrySectionSchema, record.retry);
+  if (retry !== undefined) config.retry = retry;
+
+  const dev = section(OmpDevSectionSchema, record.dev);
+  if (dev !== undefined) config.dev = dev;
+
+  return config;
+}
+
+export async function readOmpConfigFrom(
+  dir: string,
+  filenames: readonly string[] = CONFIG_FILENAMES,
+): Promise<OmpConfigResult> {
+  const defaultPath = join(dir, filenames[0] ?? CONFIG_FILENAMES[0]);
+  const found = await readFirstExisting(dir, filenames);
+  if (!found) return { path: defaultPath, available: false, config: null };
+  try {
+    const raw: unknown = parseYaml(found.text);
+    return { path: found.path, available: true, config: parseOmpConfig(raw) };
+  } catch {
+    // Malformed YAML: never log the raw text, degrade to a clear unavailable result.
+    return { path: found.path, available: false, config: null };
+  }
+}
+
+export async function resolveListOmpConfig(
+  input: RpcInput<typeof listOmpConfig>,
+): Promise<OmpConfigResult> {
+  if (input.cwd && isAbsolute(input.cwd) && !input.cwd.includes("\0")) {
+    return readOmpConfigFrom(join(input.cwd, ".omp"), [CONFIG_FILENAMES[0]]);
+  }
+  return readOmpConfigFrom(ompAgentDir());
+}