@omercnet/paseo-omp 0.2.1-next.72.1

package/shared/omp-settings.ts

@@ -0,0 +1,214 @@
+import { defineRpc } from "@getpaseo/plugin";
+import { z } from "zod";
+import { OmpWorkspaceCwdSchema } from "./hub";
+import { OmpStoreSchema } from "./omp-store";
+
+export const OMP_SETTINGS_CATALOG_VERSION = 1;
+
+export const OmpSettingTypeSchema = z.enum([
+  "boolean",
+  "string",
+  "number",
+  "enum",
+  "array",
+  "record",
+]);
+export type OmpSettingType = z.infer<typeof OmpSettingTypeSchema>;
+export const OmpScalarValueSchema = z.union([z.boolean(), z.number(), z.string()]);
+export type OmpScalarValue = z.infer<typeof OmpScalarValueSchema>;
+
+export const OmpSettingSchema = z
+  .object({
+    path: z.string(),
+    type: OmpSettingTypeSchema,
+    description: z.string(),
+    value: z.unknown().optional(),
+    redacted: z.boolean().optional(),
+    configured: z.boolean().optional(),
+    workspaceOverride: z.boolean().optional(),
+  })
+  .strict();
+export type OmpSetting = z.infer<typeof OmpSettingSchema>;
+
+export const OMP_SETTING_CATEGORIES = [
+  "appearance",
+  "model",
+  "interaction",
+  "context",
+  "memory",
+  "files",
+  "shell",
+  "tools",
+  "tasks",
+  "providers",
+  "general",
+] as const;
+export type OmpSettingCategory = (typeof OMP_SETTING_CATEGORIES)[number];
+
+const CATEGORY_PREFIXES: Readonly<Record<OmpSettingCategory, readonly string[]>> = {
+  appearance: [
+    "theme.",
+    "symbolPreset",
+    "colorBlindMode",
+    "composer.",
+    "statusLine.",
+    "terminal.",
+    "tui.",
+    "display.",
+    "showHardwareCursor",
+    "images.",
+  ],
+  model: [
+    "modelRoles",
+    "modelTags",
+    "modelRoleStorage",
+    "cycleOrder",
+    "enabledModels",
+    "defaultThinkingLevel",
+    "thinkingBudgets.",
+    "hideThinkingBlock",
+    "proseOnlyThinking",
+    "omitThinking",
+    "externalThinking",
+    "model.",
+    "inlineToolDescriptors",
+    "includeModelInPrompt",
+    "includeWorkspaceTree",
+    "personality",
+    "temperature",
+    "topP",
+    "topK",
+    "minP",
+    "presencePenalty",
+    "repetitionPenalty",
+    "textVerbosity",
+    "retry.",
+    "advisor.",
+    "prewalk.",
+    "tier.",
+  ],
+  interaction: [
+    "autoResume",
+    "power.",
+    "steeringMode",
+    "ask.",
+    "stt.",
+    "speech.",
+    "live.",
+    "collab.",
+    "magicKeywords",
+    "git.",
+  ],
+  context: ["compaction.", "context.", "contextPromotion.", "ttsr.", "recap.", "branchSummary."],
+  memory: ["memory.", "memories.", "mnemopi.", "hindsight.", "sharpshooter."],
+  files: ["edit.", "read.", "files.", "file.", "lsp.", "tree"],
+  shell: ["bash.", "eval.", "shell", "shellMinimizer."],
+  tools: [
+    "tools.",
+    "todo.",
+    "glob.",
+    "grep.",
+    "astGrep.",
+    "astEdit.",
+    "debug.",
+    "launch.",
+    "fetch.",
+    "vault.",
+    "github.",
+    "web_search.",
+    "browser.",
+    "computer.",
+    "checkpoint.",
+    "async.",
+    "irc.",
+    "mcp.",
+    "secrets.",
+    "extensionHandlers.",
+    "dev.",
+  ],
+  tasks: [
+    "plan.",
+    "goal.",
+    "task.",
+    "tasks.",
+    "worktree.",
+    "skills.",
+    "commands.",
+    "extensions",
+    "disabledExtensions",
+  ],
+  providers: [
+    "providers.",
+    "provider.",
+    "enabledProviders",
+    "disabledProviders",
+    "modelProviderOrder",
+    "exa.",
+    "searxng.",
+    "codexResets.",
+  ],
+  general: [],
+};
+
+export function categorizeOmpSetting(path: string): OmpSettingCategory {
+  for (const category of OMP_SETTING_CATEGORIES) {
+    if (CATEGORY_PREFIXES[category].some((prefix) => path === prefix || path.startsWith(prefix))) {
+      return category;
+    }
+  }
+  return "general";
+}
+
+export function formatOmpSettingLabel(path: string): string {
+  const leaf = path.split(".").at(-1) ?? path;
+  const words = leaf
+    .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+    .replace(/[_-]+/g, " ")
+    .trim();
+  return words ? `${words[0]?.toUpperCase() ?? ""}${words.slice(1)}` : path;
+}
+
+export const listOmpSettings = defineRpc({
+  name: "paseo-omp.list-settings",
+  input: z
+    .object({ store: OmpStoreSchema.optional(), cwd: OmpWorkspaceCwdSchema.optional() })
+    .strict(),
+  output: z.object({
+    catalogVersion: z.literal(OMP_SETTINGS_CATALOG_VERSION),
+    revision: z.string().optional(),
+    path: z.string().optional(),
+    available: z.boolean(),
+    droppedCount: z.number().int().nonnegative(),
+    settings: z.array(OmpSettingSchema),
+    error: z.string().optional(),
+  }),
+});
+
+const OmpSettingChangeSchema = z.discriminatedUnion("operation", [
+  z.object({ operation: z.literal("set"), path: z.string().min(1), value: OmpScalarValueSchema }),
+  z.object({ operation: z.literal("reset"), path: z.string().min(1) }),
+]);
+
+export const updateOmpSettings = defineRpc({
+  name: "paseo-omp.update-settings",
+  input: z.object({
+    store: OmpStoreSchema.optional(),
+    cwd: OmpWorkspaceCwdSchema.optional(),
+    revision: z.string(),
+    changes: z.array(OmpSettingChangeSchema).min(1).max(100),
+  }),
+  output: z.object({
+    conflict: z.boolean(),
+    appliedPaths: z.array(z.string()),
+    failed: z.object({ path: z.string(), message: z.string() }).optional(),
+    catalog: z.object({
+      catalogVersion: z.literal(OMP_SETTINGS_CATALOG_VERSION),
+      available: z.boolean(),
+      revision: z.string().optional(),
+      path: z.string().optional(),
+      droppedCount: z.number().int().nonnegative(),
+      settings: z.array(OmpSettingSchema),
+      error: z.string().optional(),
+    }),
+  }),
+});

package/shared/omp-store.ts

@@ -0,0 +1,58 @@
+import { defineRpc } from "@getpaseo/plugin";
+import { z } from "zod";
+
+const OMP_PROFILE_NAME = /^[a-z0-9][a-z0-9._-]{0,63}$/u;
+const WINDOWS_RESERVED_PROFILE = /^(?:CON|PRN|AUX|NUL|COM[0-9]|LPT[0-9])(?:\..*)?$/iu;
+
+export function isOmpProfileName(value: string): boolean {
+  return (
+    value !== "default" &&
+    !value.endsWith(".") &&
+    OMP_PROFILE_NAME.test(value) &&
+    !WINDOWS_RESERVED_PROFILE.test(value)
+  );
+}
+
+export const OmpProfileNameSchema = z.string().trim().refine(isOmpProfileName, {
+  message: "Invalid named OMP profile",
+});
+export const OmpStoreSchema = z
+  .object({
+    profile: OmpProfileNameSchema.optional(),
+    agentDir: z
+      .string()
+      .min(1)
+      .max(4096)
+      .refine((value) => !value.includes("\0"))
+      // Browser validation accepts absolute paths from any supported server OS;
+      // withOmpStore additionally applies node:path.isAbsolute on the server.
+      .refine(
+        (value) => /^(?:\/|[A-Za-z]:[\\/]|\\)/u.test(value),
+        "OMP agent directory must be absolute",
+      )
+      .optional(),
+  })
+  .strict()
+  .refine(
+    (value) => !(value.profile && value.agentDir),
+    "Choose a profile or agent directory, not both",
+  );
+export type OmpStore = z.infer<typeof OmpStoreSchema>;
+export const listOmpStores = defineRpc({
+  name: "paseo-omp.list-stores",
+  input: z.object({}).strict(),
+  output: z.object({ profiles: z.array(OmpProfileNameSchema).max(128) }),
+});
+
+export function storeForProvider(provider: string | undefined): OmpStore | undefined {
+  if (!provider?.startsWith("omp-plugin-")) return;
+  const profile = provider.slice("omp-plugin-".length);
+  return isOmpProfileName(profile) ? { profile } : undefined;
+}
+export function storeLabel(store?: OmpStore): string {
+  return store?.profile
+    ? `Profile: ${store.profile}`
+    : store?.agentDir
+      ? "Custom agent directory"
+      : "Daemon default store";
+}

package/shared/provider-diagnostics.ts

@@ -0,0 +1,126 @@
+import { defineRpc } from "@getpaseo/plugin";
+import { z } from "zod";
+import { OmpWorkspaceCwdSchema } from "./hub";
+import { OmpStoreSchema } from "./omp-store";
+
+// Health/compatibility facts about the omp CLI itself, surfaced on the global OMP page. This is
+// an explicit allowlist, not a passthrough: filesystem locations are sanitized display labels
+// (`~/...` or the constant `<custom path>`), never raw absolute override values; every remaining
+// field is a classification enum, bounded/normalized number, or boolean derived from a positive
+// documented grammar match. Raw stdout/stderr, environment variables, config file text, and
+// arbitrary provider diagnostics never cross this boundary.
+
+/** Outcome of the bounded `omp --version` probe. */
+export const OmpVersionStatusSchema = z.enum([
+  "ok",
+  "not-found",
+  "unrunnable",
+  "timeout",
+  "probe-failed",
+  "malformed",
+]);
+export type OmpVersionStatus = z.infer<typeof OmpVersionStatusSchema>;
+
+// Normalized, bounded fields parsed out of one canonical anchored version line
+// (`omp/<major>.<minor>.<patch>[-<prerelease>]`) — never the raw stdout string, so no unbounded
+// build metadata or unrelated text can ride along.
+export const OmpVersionSchema = z.object({
+  major: z.number().int().nonnegative(),
+  minor: z.number().int().nonnegative(),
+  patch: z.number().int().nonnegative(),
+  prerelease: z.string().min(1).max(32).nullable(),
+});
+export type OmpVersion = z.infer<typeof OmpVersionSchema>;
+
+/** Filesystem classification for a diagnostic root/file: distinguishes every failure mode. */
+export const PathStateSchema = z.enum([
+  "available",
+  "missing",
+  "unreadable",
+  "invalid",
+  "wrong-type",
+]);
+export type PathState = z.infer<typeof PathStateSchema>;
+
+// Mirrors OmpMemorySectionSchema.backend in shared/omp-config.ts. Duplicated as a literal rather
+// than imported so this module's wire contract does not shift silently if that schema changes.
+const MemoryBackendSchema = z.enum(["off", "local", "hindsight", "mnemopi", "sharpshooter"]);
+
+export const OmpProcessDiagnosticsSchema = z.object({
+  /** "partial" means a project daemon directory or candidate metadata file could not be
+   * inspected; the count reflects only entries whose metadata was confirmed. */
+  status: z.enum(["ok", "partial", "unavailable", "unknown"]),
+  /** Metadata file count under the hub run root, never a count of verified live processes. */
+  trackedCount: z.number().int().nonnegative().nullable(),
+  /** Counts by recorded state only; optional for compatibility with older plugin hosts. */
+  activeCount: z.number().int().nonnegative().nullable().optional(),
+  historicalCount: z.number().int().nonnegative().nullable().optional(),
+  unknownCount: z.number().int().nonnegative().nullable().optional(),
+});
+export type OmpProcessDiagnostics = z.infer<typeof OmpProcessDiagnosticsSchema>;
+
+// Reports safe facts from omp's own mcp.json manifest: bounded server count and parse/access
+// status only. Server names, credentials, headers, env, URLs, and commands never cross the RPC.
+export const OmpMcpDiagnosticsSchema = z.object({
+  status: z.enum(["configured", "unavailable", "unreadable", "invalid", "wrong-type"]),
+  serverCount: z.number().int().nonnegative().nullable(),
+  /** Null only when "configured"; otherwise a specific, path-backed explanation. */
+  reason: z.string().nullable(),
+});
+export type OmpMcpDiagnostics = z.infer<typeof OmpMcpDiagnosticsSchema>;
+
+export const OmpLspDiagnosticsSchema = z.object({
+  status: z.enum(["supported", "not-advertised", "unknown"]),
+});
+export type OmpLspDiagnostics = z.infer<typeof OmpLspDiagnosticsSchema>;
+
+export const OmpProviderHealthSchema = z.object({
+  binary: z.object({
+    /** Whether an executable file was found (env override or PATH), independent of a working
+     * `--version`. */
+    installed: z.boolean(),
+    /** Sanitized display label (`~/...` or `<custom path>`), never a raw absolute path. */
+    resolvedPath: z.string().nullable(),
+    version: OmpVersionSchema.nullable(),
+    versionStatus: OmpVersionStatusSchema,
+    /** True when process-tree termination/verification failed or the leader did not close by the
+     * bounded final deadline. */
+    processCleanupFailed: z.boolean(),
+  }),
+  rpcUi: z.object({
+    /** False when the binary was unavailable, so the probe was never attempted. */
+    checked: z.boolean(),
+    /** Null when the help probe failed, was empty, or was truncated — never a guessed false. */
+    supported: z.boolean().nullable(),
+  }),
+  lsp: OmpLspDiagnosticsSchema,
+  mcp: OmpMcpDiagnosticsSchema,
+  process: OmpProcessDiagnosticsSchema,
+  roots: z.object({
+    agentRoot: z.string(),
+    agentRootState: PathStateSchema,
+    configPath: z.string(),
+    configState: PathStateSchema,
+    sessionRoot: z.string(),
+    sessionRootState: PathStateSchema,
+  }),
+  databases: z.object({
+    agentDbState: PathStateSchema,
+    historyDbState: PathStateSchema,
+  }),
+  /** Null both when the config is unavailable and when it is available but unset — callers must
+   * check `roots.configState` to tell those apart. */
+  memoryBackend: MemoryBackendSchema.nullable(),
+  checkedAt: z.string(),
+});
+export type OmpProviderHealth = z.infer<typeof OmpProviderHealthSchema>;
+
+export const getOmpProviderHealth = defineRpc({
+  name: "paseo-omp.get-provider-health",
+  input: z.object({
+    store: OmpStoreSchema.optional(),
+    force: z.boolean().optional(),
+    cwd: OmpWorkspaceCwdSchema.optional(),
+  }),
+  output: OmpProviderHealthSchema,
+});

package/shared/provider-image.ts

@@ -0,0 +1,160 @@
+import { z } from "zod";
+
+const MAX_IMAGE_ENCODED_BYTES = 8 * 1024 * 1024;
+const MAX_IMAGE_DECODED_BYTES = 6 * 1024 * 1024;
+const MAX_CUMULATIVE_ENCODED_BYTES = 12 * 1024 * 1024;
+const MAX_CUMULATIVE_DECODED_BYTES = 9 * 1024 * 1024;
+const MAX_IMAGE_TEXT_BYTES = 256 * 1024;
+const MAX_IMAGE_DETAILS_BYTES = 256 * 1024;
+const OMP_IMAGE_CALL_ID =
+  /^omp:(?:tool:\d+|assistant:\d+:[A-Za-z0-9_-]+:content:\d+:image|custom:[A-Za-z0-9_-]+):images$/u;
+const BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const OMP_IMAGE_DIMENSION_NOTE =
+  /^\[Image: original \d+x\d+, displayed at \d+x\d+\. Multiply coordinates by \d+(?:\.\d+)? to map to original image\.\]$/u;
+
+function utf8Bytes(value: string): number {
+  let bytes = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code < 0x80) bytes += 1;
+    else if (code < 0x800) bytes += 2;
+    else if (code >= 0xd800 && code <= 0xdbff && index + 1 < value.length) {
+      const next = value.charCodeAt(index + 1);
+      if (next >= 0xdc00 && next <= 0xdfff) {
+        bytes += 4;
+        index += 1;
+      } else bytes += 3;
+    } else bytes += 3;
+  }
+  return bytes;
+}
+
+function boundedString(maxBytes: number) {
+  return z.string().refine((value) => utf8Bytes(value) <= maxBytes);
+}
+function decodedBase64Length(data: string): number | undefined {
+  if (
+    data.length === 0 ||
+    data.length % 4 !== 0 ||
+    data.length > MAX_IMAGE_ENCODED_BYTES ||
+    !/^[A-Za-z0-9+/]*={0,2}$/u.test(data)
+  ) {
+    return undefined;
+  }
+  const padding = data.endsWith("==") ? 2 : data.endsWith("=") ? 1 : 0;
+  const decoded = (data.length / 4) * 3 - padding;
+  return decoded <= MAX_IMAGE_DECODED_BYTES ? decoded : undefined;
+}
+
+function decodedPrefix(data: string): number[] {
+  const bytes: number[] = [];
+  for (let offset = 0; offset < data.length && bytes.length < 12; offset += 4) {
+    const a = BASE64.indexOf(data[offset] ?? "");
+    const b = BASE64.indexOf(data[offset + 1] ?? "");
+    const c = data[offset + 2] === "=" ? 0 : BASE64.indexOf(data[offset + 2] ?? "");
+    const d = data[offset + 3] === "=" ? 0 : BASE64.indexOf(data[offset + 3] ?? "");
+    if (a < 0 || b < 0 || c < 0 || d < 0) return [];
+    bytes.push((a << 2) | (b >> 4));
+    if (data[offset + 2] !== "=") bytes.push(((b & 15) << 4) | (c >> 2));
+    if (data[offset + 3] !== "=") bytes.push(((c & 3) << 6) | d);
+  }
+  return bytes;
+}
+
+function hasExpectedHeader(mimeType: string, bytes: readonly number[]): boolean {
+  if (mimeType === "image/png") {
+    return [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a].every(
+      (byte, index) => bytes[index] === byte,
+    );
+  }
+  if (mimeType === "image/jpeg") {
+    return bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff;
+  }
+  if (mimeType === "image/webp") {
+    return (
+      bytes.length >= 12 &&
+      String.fromCharCode(...bytes.slice(0, 4)) === "RIFF" &&
+      String.fromCharCode(...bytes.slice(8, 12)) === "WEBP"
+    );
+  }
+  return (
+    bytes.length >= 6 && String.fromCharCode(...bytes.slice(0, 6)) in { GIF87a: true, GIF89a: true }
+  );
+}
+
+const ompImageSchema = z.object({
+  id: z.string().regex(/^[A-Za-z0-9_-]{16}$/u),
+  data: z.string().max(MAX_IMAGE_ENCODED_BYTES),
+  mimeType: z.enum(["image/gif", "image/jpeg", "image/png", "image/webp"]),
+});
+
+export const ompImageTimelineSchema = z
+  .object({
+    label: boundedString(256),
+    images: z.array(ompImageSchema).min(1).max(64),
+    text: boundedString(MAX_IMAGE_TEXT_BYTES).optional(),
+    details: z.json().optional(),
+  })
+  .superRefine((value, context) => {
+    let encodedBytes = 0;
+    let decodedBytes = 0;
+    for (const [index, image] of value.images.entries()) {
+      const decoded = decodedBase64Length(image.data);
+      if (decoded === undefined || !hasExpectedHeader(image.mimeType, decodedPrefix(image.data))) {
+        context.addIssue({
+          code: "custom",
+          path: ["images", index, "data"],
+          message: "invalid image payload",
+        });
+        continue;
+      }
+      encodedBytes += image.data.length;
+      decodedBytes += decoded;
+    }
+    if (
+      encodedBytes > MAX_CUMULATIVE_ENCODED_BYTES ||
+      decodedBytes > MAX_CUMULATIVE_DECODED_BYTES
+    ) {
+      context.addIssue({ code: "custom", path: ["images"], message: "image payload too large" });
+    }
+    if (
+      value.details !== undefined &&
+      utf8Bytes(JSON.stringify(value.details)) > MAX_IMAGE_DETAILS_BYTES
+    ) {
+      context.addIssue({ code: "custom", path: ["details"], message: "image details too large" });
+    }
+  });
+
+export function visibleOmpImageText(text: string | undefined): string | undefined {
+  if (!text) return undefined;
+  const visible = text
+    .split("\n")
+    .filter((line) => !OMP_IMAGE_DIMENSION_NOTE.test(line.trim()))
+    .join("\n")
+    .trim();
+  return visible || undefined;
+}
+
+export const ompImageToolMetadataSchema = z.object({
+  ompImageOwner: z.literal("omp"),
+  ompImage: ompImageTimelineSchema,
+});
+
+export function transformOmpImageToolItem(item: { callId: string; metadata?: unknown }) {
+  if (!OMP_IMAGE_CALL_ID.test(item.callId)) return undefined;
+  const metadata = ompImageToolMetadataSchema.safeParse(item.metadata);
+  if (!metadata.success) return undefined;
+  return {
+    items: [
+      {
+        type: "plugin" as const,
+        kind: "omp-images",
+        id: item.callId,
+        version: 1,
+        data: metadata.data.ompImage,
+      },
+    ],
+  };
+}
+
+export type OmpImageTimelineData = z.infer<typeof ompImageTimelineSchema>;

package/shared/quota.ts

@@ -0,0 +1,23 @@
+import { defineRpc } from "@getpaseo/plugin";
+import { z } from "zod";
+import { OmpStoreSchema } from "./omp-store";
+
+// omp's usage_history stores recorded_at/resets_at as epoch milliseconds (confirmed against
+// live rows: 13-digit values), not seconds. Any "time remaining" math must diff against
+// Date.now() directly, never Date.now() / 1000.
+export const OmpQuotaSchema = z.object({
+  provider: z.string(),
+  label: z.string(),
+  windowLabel: z.string().nullable(),
+  usedFraction: z.number().min(0).nullable(),
+  status: z.string().nullable(),
+  resetsAt: z.number().int().nullable(),
+  recordedAt: z.number().int(),
+});
+export type OmpQuota = z.infer<typeof OmpQuotaSchema>;
+
+export const listOmpQuotas = defineRpc({
+  name: "paseo-omp.list-quotas",
+  input: z.object({ store: OmpStoreSchema.optional() }),
+  output: z.object({ quotas: z.array(OmpQuotaSchema) }),
+});

package/shared/sessions.ts

@@ -0,0 +1,24 @@
+import { defineRpc } from "@getpaseo/plugin";
+import { z } from "zod";
+import { OmpStoreSchema } from "./omp-store";
+
+const CwdSchema = z.string().min(1).max(4_096);
+
+// omp's history.db stores created_at as epoch seconds (confirmed against live rows: 10-digit
+// values), unlike agent.db's usage_history which stores milliseconds. Diff against
+// Date.now() / 1_000, never Date.now() directly.
+export const OmpSessionEntrySchema = z.object({
+  id: z.number().int(),
+  sessionId: z.string().nullable(),
+  title: z.string().nullable(),
+  prompt: z.string(),
+  truncated: z.boolean(),
+  createdAt: z.number().int(),
+});
+export type OmpSessionEntry = z.infer<typeof OmpSessionEntrySchema>;
+
+export const listOmpSessions = defineRpc({
+  name: "paseo-omp.list-sessions",
+  input: z.object({ store: OmpStoreSchema.optional(), cwd: CwdSchema }),
+  output: z.object({ sessions: z.array(OmpSessionEntrySchema) }),
+});

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "lib": ["ES2024", "DOM", "DOM.Iterable"],
+    "types": ["node", "vitest/globals"],
+    "jsx": "react-jsx",
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true
+  },
+  "include": ["**/*.ts", "**/*.tsx"]
+}