@omercnet/paseo-omp 0.2.1

package/index.client.tsx

@@ -0,0 +1,272 @@
+import type { PaseoAgentListResult, PaseoApi } from "@getpaseo/client";
+import type { PluginButtonRegistration, PluginClientContext } from "@getpaseo/plugin/client";
+import { OmpIcon } from "./client/hub-icon";
+import { HubPopover } from "./client/hub-popover";
+import { summarizeHubProcesses } from "./client/hub-status";
+import { OmpMemoryPanel } from "./client/memory-panel";
+import { MemoryPopover } from "./client/memory-popover";
+import { OmpConfigSurface } from "./client/omp-config-surface";
+import { quotaProviderIcon } from "./client/provider-icon";
+import { OmpImageTimeline } from "./client/provider-image";
+import { QuotaPopover } from "./client/quota-popover";
+import {
+  type QuotaSeverity,
+  quotaProviderFromSession,
+  quotaSeverityForProvider,
+  quotaSummaryForProvider,
+} from "./client/quota-state";
+import { SessionsPopover } from "./client/sessions-popover";
+import { listHubProcesses } from "./shared/hub";
+import { ompImageTimelineSchema, transformOmpImageToolItem } from "./shared/provider-image";
+import { listOmpQuotas } from "./shared/quota";
+
+const PAGE_LIMIT = 200;
+const MAX_PAGES = 10;
+const STATUS_POLL_MS = 4_000;
+const QUOTA_POLL_MS = 30_000;
+const RECONCILE_DEBOUNCE_MS = 250;
+
+type AgentEntry = PaseoAgentListResult["entries"][number];
+
+type PillEntry = {
+  cwd: string;
+  workspaceId: string;
+  quotaProvider: string | null;
+  quotaSeverity: QuotaSeverity;
+  hub: PluginButtonRegistration;
+  memory: PluginButtonRegistration;
+  sessions: PluginButtonRegistration;
+  quota: PluginButtonRegistration;
+};
+
+async function loadAgents(paseo: PaseoApi): Promise<AgentEntry[]> {
+  const entries: AgentEntry[] = [];
+  let cursor: string | undefined;
+  for (let page = 0; page < MAX_PAGES; page += 1) {
+    const result = await paseo.agents.list({
+      sort: [{ key: "updated_at", direction: "desc" }],
+      page: { limit: PAGE_LIMIT, ...(cursor ? { cursor } : {}) },
+    });
+    entries.push(...result.entries);
+    cursor = result.pageInfo.hasMore ? (result.pageInfo.nextCursor ?? undefined) : undefined;
+    if (!cursor) break;
+  }
+  return entries;
+}
+
+export default function contribute(client: PluginClientContext) {
+  const removeMemoryPanel = client.addWorkspacePanel({
+    id: "memory",
+    title: "OMP Memory",
+    icon: "Brain",
+    context: "workspace",
+    locations: ["explorer"],
+    Component: OmpMemoryPanel,
+  });
+  const removeOpenMemory = client.addCommandCenterItem({
+    id: "open-memory",
+    title: "Open OMP Memory",
+    icon: "Brain",
+    keywords: ["omp", "memory", "facts", "recall"],
+    context: "workspace",
+    onSelect({ openPanel }) {
+      openPanel("memory", { location: "explorer" });
+    },
+  });
+  const removeConfigSurface = client.addSurface("config", OmpConfigSurface);
+  const removeConfigSidebarItem = client.addSidebarItem({
+    id: "config",
+    title: "OMP",
+    icon: "Settings",
+    surface: "config",
+  });
+  const removeOpenConfig = client.addCommandCenterItem({
+    id: "open-config",
+    title: "Open OMP",
+    icon: "Settings",
+    keywords: ["omp", "config", "settings", "models", "providers"],
+    context: "global",
+    onSelect({ openSurface }) {
+      openSurface("config");
+    },
+  });
+  const removeImageRenderer = client.addTimelineRenderer({
+    kind: "omp-images",
+    version: 1,
+    schema: ompImageTimelineSchema,
+    Component: OmpImageTimeline,
+  });
+  const removeImageTransformer = client.addTimelineTransformer({
+    id: "omp-images",
+    query: { itemType: "tool_call" },
+    transform({ item }) {
+      return transformOmpImageToolItem(item);
+    },
+  });
+  const pills = new Map<string, PillEntry>();
+  let disposed = false;
+  let reconcileTimer: ReturnType<typeof setTimeout> | undefined;
+
+  async function reconcile() {
+    const agents = await loadAgents(client.paseo);
+    if (disposed) return;
+    const activeIds = new Set<string>();
+    for (const { agent } of agents) {
+      if (agent.archivedAt || !agent.workspaceId || !agent.cwd) continue;
+      activeIds.add(agent.id);
+      const quotaProvider = quotaProviderFromSession(agent.provider, agent.model);
+      const current = pills.get(agent.id);
+      if (
+        current?.cwd === agent.cwd &&
+        current.workspaceId === agent.workspaceId &&
+        current.quotaProvider === quotaProvider
+      ) {
+        continue;
+      }
+      current?.hub.remove();
+      current?.memory.remove();
+      current?.sessions.remove();
+      current?.quota.remove();
+      pills.set(agent.id, {
+        cwd: agent.cwd,
+        workspaceId: agent.workspaceId,
+        quotaProvider,
+        quotaSeverity: "unknown",
+        hub: client.addComposerPill({
+          id: "hub",
+          workspaceId: agent.workspaceId,
+          agentId: agent.id,
+          button: {
+            title: "Hub processes",
+            icon: OmpIcon,
+            label: "Hub",
+            visible: false,
+            behavior: { kind: "popover", Content: HubPopover },
+          },
+        }),
+        memory: client.addComposerPill({
+          id: "memory",
+          workspaceId: agent.workspaceId,
+          agentId: agent.id,
+          button: {
+            title: "OMP workspace memory",
+            icon: "Brain",
+            label: "Memory",
+            behavior: { kind: "popover", Content: MemoryPopover },
+          },
+        }),
+        sessions: client.addComposerPill({
+          id: "sessions",
+          workspaceId: agent.workspaceId,
+          agentId: agent.id,
+          button: {
+            title: "omp session history",
+            icon: "History",
+            label: "Sessions",
+            behavior: { kind: "popover", Content: SessionsPopover },
+          },
+        }),
+        quota: client.addComposerPill({
+          id: "quota",
+          workspaceId: agent.workspaceId,
+          agentId: agent.id,
+          button: {
+            title: "OMP provider quotas",
+            icon: quotaProviderIcon(quotaProvider, "unknown"),
+            label: "Quota",
+            visible: false,
+            behavior: { kind: "popover", Content: QuotaPopover },
+          },
+        }),
+      });
+    }
+    for (const [agentId, pill] of pills) {
+      if (activeIds.has(agentId)) continue;
+      pill.hub.remove();
+      pill.memory.remove();
+      pill.sessions.remove();
+      pill.quota.remove();
+      pills.delete(agentId);
+    }
+    await Promise.all([refreshHubStatus(), refreshQuotaStatus()]);
+  }
+
+  async function refreshHubStatus() {
+    const pillsByCwd = new Map<string, PillEntry[]>();
+    for (const pill of pills.values()) {
+      const group = pillsByCwd.get(pill.cwd);
+      if (group) group.push(pill);
+      else pillsByCwd.set(pill.cwd, [pill]);
+    }
+    await Promise.all(
+      [...pillsByCwd].map(async ([cwd, cwdPills]) => {
+        try {
+          const result = await client.rpc(listHubProcesses, { cwd });
+          if (disposed) return;
+          const summary = summarizeHubProcesses(result.processes);
+          for (const pill of cwdPills) pill.hub.update(summary);
+        } catch {
+          // Keep the last known state. A disconnected host or missing omp directory should not
+          // remove a status the user was already inspecting.
+        }
+      }),
+    );
+  }
+
+  async function refreshQuotaStatus() {
+    try {
+      const result = await client.rpc(listOmpQuotas, {});
+      if (disposed) return;
+      for (const pill of pills.values()) {
+        const severity = quotaSeverityForProvider(result.quotas, pill.quotaProvider);
+        pill.quota.update({
+          ...quotaSummaryForProvider(result.quotas, pill.quotaProvider),
+          ...(severity === pill.quotaSeverity
+            ? {}
+            : { icon: quotaProviderIcon(pill.quotaProvider, severity) }),
+        });
+        pill.quotaSeverity = severity;
+      }
+    } catch {
+      // The quota database is optional and may not exist on a new omp installation.
+    }
+  }
+
+  function scheduleReconcile() {
+    clearTimeout(reconcileTimer);
+    reconcileTimer = setTimeout(() => {
+      void reconcile().catch(() => {});
+    }, RECONCILE_DEBOUNCE_MS);
+  }
+
+  const unsubscribeAgents = client.paseo.agents.subscribe(scheduleReconcile);
+  const hubPoll = setInterval(() => {
+    void refreshHubStatus().catch(() => {});
+  }, STATUS_POLL_MS);
+  const quotaPoll = setInterval(() => {
+    void refreshQuotaStatus().catch(() => {});
+  }, QUOTA_POLL_MS);
+  void reconcile().catch(() => {});
+
+  return () => {
+    disposed = true;
+    unsubscribeAgents();
+    clearTimeout(reconcileTimer);
+    clearInterval(hubPoll);
+    clearInterval(quotaPoll);
+    for (const pill of pills.values()) {
+      pill.hub.remove();
+      pill.memory.remove();
+      pill.sessions.remove();
+      pill.quota.remove();
+    }
+    pills.clear();
+    removeImageRenderer();
+    removeImageTransformer();
+    removeOpenConfig();
+    removeConfigSidebarItem();
+    removeConfigSurface();
+    removeOpenMemory();
+    removeMemoryPanel();
+  };
+}

package/index.server.ts

@@ -0,0 +1,51 @@
+import type { PluginServerContext } from "@getpaseo/plugin/server";
+import { resolveListHubProcesses, resolveTailHubLog } from "./server/hub";
+import { resolveListOmpMemory } from "./server/memory";
+import { resolveListOmpConfig } from "./server/omp-config";
+import {
+  resolveInspectOmpPluginConfig,
+  resolveListOmpPlugins,
+  resolveMutateOmpPlugin,
+  resolveMutateOmpPluginConfig,
+} from "./server/omp-plugins";
+import { resolveListOmpSettings, resolveUpdateOmpSettings } from "./server/omp-settings";
+import { withOmpWorkspaceIdentity } from "./server/provider/host-tools";
+import { createOmpProvider } from "./server/provider/registration";
+import { resolveGetOmpProviderHealth } from "./server/provider-diagnostics";
+import { resolveListOmpQuotas } from "./server/quota";
+import { resolveListOmpSessions } from "./server/sessions";
+import { listHubProcesses, tailHubLog } from "./shared/hub";
+import { listOmpMemory } from "./shared/memory";
+import { listOmpConfig } from "./shared/omp-config";
+import {
+  inspectOmpPluginConfig,
+  listOmpPlugins,
+  mutateOmpPlugin,
+  mutateOmpPluginConfig,
+} from "./shared/omp-plugins";
+import { listOmpSettings, updateOmpSettings } from "./shared/omp-settings";
+import { getOmpProviderHealth } from "./shared/provider-diagnostics";
+import { listOmpQuotas } from "./shared/quota";
+import { listOmpSessions } from "./shared/sessions";
+
+export default function contribute(server: PluginServerContext) {
+  server.handle(listHubProcesses, resolveListHubProcesses);
+  server.handle(tailHubLog, resolveTailHubLog);
+  server.handle(listOmpQuotas, resolveListOmpQuotas);
+  server.handle(listOmpMemory, resolveListOmpMemory);
+  server.handle(listOmpSessions, resolveListOmpSessions);
+  server.handle(listOmpConfig, resolveListOmpConfig);
+  server.handle(listOmpPlugins, resolveListOmpPlugins);
+  server.handle(inspectOmpPluginConfig, resolveInspectOmpPluginConfig);
+  server.handle(mutateOmpPlugin, resolveMutateOmpPlugin);
+  server.handle(mutateOmpPluginConfig, resolveMutateOmpPluginConfig);
+  server.handle(listOmpSettings, resolveListOmpSettings);
+  server.handle(updateOmpSettings, resolveUpdateOmpSettings);
+  server.handle(getOmpProviderHealth, resolveGetOmpProviderHealth);
+  const removeIdentityHook = server.before("agent.session_open", ({ request }) => {
+    if (request.provider !== "omp-plugin") return;
+    return withOmpWorkspaceIdentity(request);
+  });
+  server.registerProvider(createOmpProvider());
+  return () => removeIdentityHook();
+}

package/package.json

@@ -0,0 +1,84 @@
+{
+  "name": "@omercnet/paseo-omp",
+  "version": "0.2.1",
+  "type": "module",
+  "description": "Paseo integration for OMP, including its direct provider and workspace tooling.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/omercnet/paseo-plugins.git",
+    "directory": "paseo-omp"
+  },
+  "homepage": "https://github.com/omercnet/paseo-plugins/tree/main/paseo-omp#readme",
+  "bugs": {
+    "url": "https://github.com/omercnet/paseo-plugins/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "packageManager": "npm@10.9.4",
+  "engines": {
+    "node": ">=22.18.0"
+  },
+  "author": "Omer Cohen",
+  "keywords": [
+    "paseo",
+    "paseo-plugin",
+    "paseo-omp",
+    "omp",
+    "coding-agents"
+  ],
+  "files": [
+    "package-lock.json",
+    "CHANGELOG.md",
+    "LICENSE",
+    "README.md",
+    "SUPPORT.md",
+    "TESTING.md",
+    "docs",
+    "index.client.tsx",
+    "index.server.ts",
+    "client",
+    "server",
+    "shared",
+    "paseo-plugin.json",
+    "tsconfig.json"
+  ],
+  "scripts": {
+    "check": "biome check .",
+    "check:write": "biome check --write .",
+    "test": "vitest run",
+    "test:coverage": "PASEO_OMP_COVERAGE=1 vitest run --coverage",
+    "test:integration:docker": "node --import tsx scripts/test-docker-host-tools.ts",
+    "test:integration:wsl": "node --import tsx scripts/test-wsl-host-tools.ts",
+    "test:integration:install": "node --import tsx scripts/test-package-install.ts",
+    "package:release": "node --import tsx scripts/package-release.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "1.29.0",
+    "yaml": "^2.9.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.5.10",
+    "@getpaseo/cli": "0.8.0",
+    "@getpaseo/client": "0.8.0",
+    "@getpaseo/plugin": "0.8.0",
+    "@getpaseo/protocol": "0.8.0",
+    "@tanstack/react-query": "^5.102.3",
+    "@types/node": "^24.10.1",
+    "@types/react": "^19.2.18",
+    "esbuild": "^0.28.0",
+    "@vitest/coverage-v8": "^5.0.0",
+    "fflate": "^0.8.3",
+    "react": "19.1.0",
+    "react-native": "0.81.5",
+    "tsx": "^4.20.6",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.0",
+    "zod": "^4.4.3"
+  },
+  "overrides": {
+    "qs": "6.16.0"
+  }
+}

package/paseo-plugin.json

@@ -0,0 +1,5 @@
+{
+  "id": "paseo-omp",
+  "requirements": { "paseo": "^0.8.0" },
+  "build": [["npm", "ci", "--ignore-scripts"]]
+}

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/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 { ompAgentDir } 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(ompAgentDir(), "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;
+  }
+}