@omercnet/paseo-omp 0.2.1-next.72.1

package/server/quota.ts

@@ -0,0 +1,55 @@
+import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import type { RpcInput } from "@getpaseo/plugin";
+import { z } from "zod";
+import type { listOmpQuotas, OmpQuota } from "../shared/quota";
+import { ompDataDir } from "./paths";
+
+const QuotaRowSchema = 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 function listOmpQuotasFrom(path: string): OmpQuota[] {
+  try {
+    const database = new DatabaseSync(path, { readOnly: true, timeout: 500 });
+    try {
+      const rows = database
+        .prepare(
+          `SELECT provider, label, window_label AS windowLabel, used_fraction AS usedFraction,
+                  status, resets_at AS resetsAt, recorded_at AS recordedAt
+           FROM (
+             SELECT provider, account_key, limit_id, label, window_label, used_fraction, status,
+                    resets_at, recorded_at, id,
+                    ROW_NUMBER() OVER (
+                      PARTITION BY provider, account_key, limit_id
+                      ORDER BY recorded_at DESC, id DESC
+                    ) AS position
+             FROM usage_history
+           )
+           WHERE position = 1
+           ORDER BY COALESCE(usedFraction, -1) DESC, provider, label`,
+        )
+        .all();
+      return rows.flatMap((row) => {
+        const parsed = QuotaRowSchema.safeParse(row);
+        return parsed.success ? [parsed.data] : [];
+      });
+    } finally {
+      database.close();
+    }
+  } catch {
+    return [];
+  }
+}
+
+export function resolveListOmpQuotas(_input: RpcInput<typeof listOmpQuotas>): {
+  quotas: OmpQuota[];
+} {
+  return { quotas: listOmpQuotasFrom(join(ompDataDir(), "agent.db")) };
+}

package/server/sessions.ts

@@ -0,0 +1,58 @@
+import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import type { RpcInput } from "@getpaseo/plugin";
+import { z } from "zod";
+import type { listOmpSessions, OmpSessionEntry } from "../shared/sessions";
+import { ompDataDir } from "./paths";
+
+const PROMPT_LIMIT = 400;
+const ROW_LIMIT = 100;
+
+const SessionRowSchema = z.object({
+  id: z.number().int(),
+  sessionId: z.string().nullable(),
+  title: z.string().nullable(),
+  prompt: z.string(),
+  createdAt: z.number().int(),
+});
+
+export function listOmpSessionsFrom(path: string, cwd: string): OmpSessionEntry[] {
+  try {
+    const database = new DatabaseSync(path, { readOnly: true, timeout: 500 });
+    try {
+      const rows = database
+        .prepare(
+          `SELECT h.id AS id, h.session_id AS sessionId, t.title AS title,
+                  h.prompt AS prompt, h.created_at AS createdAt
+           FROM history h
+           LEFT JOIN session_titles t ON t.session_id = h.session_id
+           WHERE h.cwd = ?
+           ORDER BY h.created_at DESC, h.id DESC
+           LIMIT ?`,
+        )
+        .all(cwd, ROW_LIMIT);
+      return rows.flatMap((row) => {
+        const parsed = SessionRowSchema.safeParse(row);
+        if (!parsed.success) return [];
+        const truncated = parsed.data.prompt.length > PROMPT_LIMIT;
+        return [
+          {
+            ...parsed.data,
+            prompt: truncated ? parsed.data.prompt.slice(0, PROMPT_LIMIT) : parsed.data.prompt,
+            truncated,
+          },
+        ];
+      });
+    } finally {
+      database.close();
+    }
+  } catch {
+    return [];
+  }
+}
+
+export function resolveListOmpSessions({ cwd }: RpcInput<typeof listOmpSessions>): {
+  sessions: OmpSessionEntry[];
+} {
+  return { sessions: listOmpSessionsFrom(join(ompDataDir(), "history.db"), cwd) };
+}

package/shared/composer-pill-settings.ts

@@ -0,0 +1,28 @@
+import { defineSettings } from "@getpaseo/plugin";
+import { z } from "zod";
+
+export const DEFAULT_COMPOSER_PILL_SETTINGS = {
+  mcp: true,
+  hub: true,
+  memory: true,
+  sessions: true,
+  quota: true,
+} as const;
+
+export const composerPillSettingsSchema = z.object({
+  mcp: z.boolean().default(DEFAULT_COMPOSER_PILL_SETTINGS.mcp),
+  hub: z.boolean().default(DEFAULT_COMPOSER_PILL_SETTINGS.hub),
+  memory: z.boolean().default(DEFAULT_COMPOSER_PILL_SETTINGS.memory),
+  sessions: z.boolean().default(DEFAULT_COMPOSER_PILL_SETTINGS.sessions),
+  quota: z.boolean().default(DEFAULT_COMPOSER_PILL_SETTINGS.quota),
+});
+
+export type ComposerPillSettings = z.infer<typeof composerPillSettingsSchema>;
+export type ComposerPillKey = keyof ComposerPillSettings;
+
+export const composerPillSettings = defineSettings({
+  id: "composer-pills",
+  scope: "host",
+  version: 1,
+  schema: composerPillSettingsSchema,
+});

package/shared/hub.ts

@@ -0,0 +1,43 @@
+import { defineRpc } from "@getpaseo/plugin";
+import { z } from "zod";
+
+// Mirrors the on-disk shape omp's hub writes under
+// ~/.omp/run/daemons/<projectHash>/daemons/<name>/meta.json. That layout is an internal,
+// unversioned implementation detail of the omp harness, not a published API, so every field
+// here is optional-safe on the server side and this schema is intentionally permissive
+// (state is a free-form string, not a fixed enum) to avoid rejecting shapes we have not seen.
+export const HubProcessSchema = z.object({
+  name: z.string(),
+  application: z.string(),
+  args: z.array(z.string()),
+  cwd: z.string(),
+  state: z.string(),
+  owner: z.string().nullable(),
+  restartCount: z.number().int().nonnegative(),
+  persist: z.boolean(),
+  detached: z.boolean(),
+  createdAt: z.number().nullable(),
+  startedAt: z.number().nullable(),
+  readyAt: z.number().nullable(),
+  exitedAt: z.number().nullable(),
+  exitCode: z.number().nullable(),
+});
+export type HubProcess = z.infer<typeof HubProcessSchema>;
+export const OmpWorkspaceCwdSchema = z.string().min(1).max(4_096);
+const ProcessNameSchema = z
+  .string()
+  .min(1)
+  .max(128)
+  .regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
+
+export const listHubProcesses = defineRpc({
+  name: "paseo-omp.list-processes",
+  input: z.object({ cwd: OmpWorkspaceCwdSchema }),
+  output: z.object({ processes: z.array(HubProcessSchema) }),
+});
+
+export const tailHubLog = defineRpc({
+  name: "paseo-omp.tail-log",
+  input: z.object({ cwd: OmpWorkspaceCwdSchema, name: ProcessNameSchema }),
+  output: z.object({ content: z.string(), truncated: z.boolean() }),
+});

package/shared/mcp.ts

@@ -0,0 +1,47 @@
+import { defineRpc } from "@getpaseo/plugin";
+import { z } from "zod";
+
+export const OMP_MCP_AUTH_TIMELINE_KIND = "omp-mcp-authorization";
+const OmpMcpAuthorizationUrlSchema = z
+  .string()
+  .max(16_384)
+  .refine((value) => {
+    try {
+      const url = new URL(value);
+      return (
+        (url.protocol === "http:" || url.protocol === "https:") && !url.username && !url.password
+      );
+    } catch {
+      return false;
+    }
+  }, "Authorization URL must be an HTTP URL without embedded credentials");
+
+export const ompMcpAuthorizationTimelineSchema = z.object({
+  url: OmpMcpAuthorizationUrlSchema,
+  instructions: z
+    .string()
+    .max(64 * 1024)
+    .optional(),
+  loopbackCallback: z.boolean(),
+  browserAuthorizationToken: z.string().uuid().optional(),
+});
+
+export type OmpMcpAuthorizationTimeline = z.infer<typeof ompMcpAuthorizationTimelineSchema>;
+export const openOmpMcpAuthorizationInPaseoBrowser = defineRpc({
+  name: "paseo-omp.open-mcp-authorization-in-browser",
+  input: z.object({ authorizationToken: z.string().uuid() }),
+  output: z.object({ opened: z.literal(true) }),
+});
+
+const OMP_MCP_SERVER_NAME = /^[a-zA-Z0-9_.:-]{1,100}$/u;
+
+export type OmpMcpServerAction = "test" | "reauth" | "enable" | "disable";
+
+export function buildOmpMcpServerCommand(
+  action: OmpMcpServerAction,
+  serverName: string,
+): string | undefined {
+  const name = serverName.trim();
+  if (!OMP_MCP_SERVER_NAME.test(name)) return;
+  return `/mcp ${action} ${name}`;
+}

package/shared/memory.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);
+
+export const OmpMemoryFactSchema = z.object({
+  id: z.string(),
+  subject: z.string(),
+  predicate: z.string(),
+  object: z.string(),
+  confidence: z.number().min(0).max(1),
+  timestamp: z.string().nullable(),
+});
+export type OmpMemoryFact = z.infer<typeof OmpMemoryFactSchema>;
+
+export const listOmpMemory = defineRpc({
+  name: "paseo-omp.list-memory",
+  input: z.object({ store: OmpStoreSchema.optional(), cwd: CwdSchema }),
+  output: z.object({
+    bank: z.string().nullable(),
+    facts: z.array(OmpMemoryFactSchema),
+  }),
+});

package/shared/omp-config.ts

@@ -0,0 +1,85 @@
+import { defineRpc } from "@getpaseo/plugin";
+import { z } from "zod";
+import { OmpWorkspaceCwdSchema } from "./hub";
+import { OmpStoreSchema } from "./omp-store";
+
+// Mirrors the safe, non-secret subset of omp's on-disk ~/.omp/agent/config.yml. That file is an
+// internal, unversioned config format owned by the omp harness (source: omp's
+// settings-schema.ts), not a published API, so this is an explicit allowlist rather than a
+// passthrough: every section below has been checked against that schema's `credential: true`
+// markers and carries none. Sections the schema marks as credential-bearing (auth broker
+// tokens, mnemopi/hindsight embedding and LLM API keys, searxng basic-auth, blob-destination
+// headers) are deliberately absent and must stay that way. A field not listed here is never
+// read, rendered, or forwarded across the RPC boundary — server/omp-config.ts parses each
+// section independently and omits it entirely if it fails to match, rather than guessing or
+// widening the schema.
+
+export const OmpModelRolesSchema = z.record(z.string(), z.string());
+
+export const OmpFallbackChainsSchema = z.record(z.string(), z.array(z.string()));
+
+export const OmpThemeSectionSchema = z.object({
+  dark: z.string().optional(),
+  light: z.string().optional(),
+});
+
+export const OmpMemorySectionSchema = z.object({
+  backend: z.enum(["off", "local", "hindsight", "mnemopi", "sharpshooter"]).optional(),
+});
+
+export const OmpGithubCacheSectionSchema = z.object({
+  enabled: z.boolean().optional(),
+  softTtlSec: z.number().optional(),
+  hardTtlSec: z.number().optional(),
+});
+
+export const OmpGithubSectionSchema = z.object({
+  enabled: z.boolean().optional(),
+  cache: OmpGithubCacheSectionSchema.optional(),
+});
+
+export const OmpRetrySectionSchema = z.object({
+  enabled: z.boolean().optional(),
+  maxRetries: z.number().optional(),
+  baseDelayMs: z.number().optional(),
+  maxDelayMs: z.number().optional(),
+  waitForUsageReset: z.boolean().optional(),
+  modelFallback: z.boolean().optional(),
+  usageAwareFallback: z.boolean().optional(),
+  usageReservePct: z.number().optional(),
+  usageReservePolicy: z.enum(["confirm", "auto", "fail-closed"]).optional(),
+  fallbackRevertPolicy: z.enum(["cooldown-expiry", "never"]).optional(),
+  fallbackChains: OmpFallbackChainsSchema.optional(),
+});
+
+export const OmpDevSectionSchema = z.object({
+  autoqaConsent: z.enum(["unset", "granted", "denied"]).optional(),
+});
+
+export const OmpConfigSchema = z.object({
+  setupVersion: z.number().optional(),
+  symbolPreset: z.enum(["unicode", "nerd", "ascii"]).optional(),
+  defaultThinkingLevel: z.string().optional(),
+  theme: OmpThemeSectionSchema.optional(),
+  memory: OmpMemorySectionSchema.optional(),
+  github: OmpGithubSectionSchema.optional(),
+  disabledProviders: z.array(z.string()).optional(),
+  modelProviderOrder: z.array(z.string()).optional(),
+  modelRoles: OmpModelRolesSchema.optional(),
+  enabledModels: z.array(z.string()).optional(),
+  retry: OmpRetrySectionSchema.optional(),
+  dev: OmpDevSectionSchema.optional(),
+});
+export type OmpConfig = z.infer<typeof OmpConfigSchema>;
+
+export const listOmpConfig = defineRpc({
+  name: "paseo-omp.list-config",
+  input: z
+    .object({ store: OmpStoreSchema.optional(), cwd: OmpWorkspaceCwdSchema.optional() })
+    .strict(),
+  output: z.object({
+    path: z.string(),
+    available: z.boolean(),
+    config: OmpConfigSchema.nullable(),
+  }),
+});

package/shared/omp-plugins.ts

@@ -0,0 +1,264 @@
+import { defineRpc } from "@getpaseo/plugin";
+import { z } from "zod";
+import { OmpWorkspaceCwdSchema } from "./hub";
+import { OmpStoreSchema } from "./omp-store";
+
+export const OMP_PLUGIN_LIMIT = 256;
+export const OMP_PLUGIN_ARGUMENT_LIMIT = 512;
+
+const SAFE_NPM_PACKAGE = /^(?:@[a-z0-9][a-z0-9._~-]*\/)?[a-z0-9][a-z0-9._~-]*$/u;
+const SAFE_MARKETPLACE_ID =
+  /^[a-z0-9](?:[a-z0-9.-]{0,62}[a-z0-9])?@[a-z0-9](?:[a-z0-9.-]{0,62}[a-z0-9])?$/u;
+
+function utf8ByteLength(value: string): number {
+  let bytes = 0;
+  for (const character of value) {
+    const codePoint = character.codePointAt(0) ?? 0;
+    bytes += codePoint <= 0x7f ? 1 : codePoint <= 0x7ff ? 2 : codePoint <= 0xffff ? 3 : 4;
+  }
+  return bytes;
+}
+
+function hasUnsafeArgumentCharacter(value: string): boolean {
+  for (const character of value) {
+    const code = character.codePointAt(0) ?? 0;
+    if (code <= 0x1f || code === 0x7f) return true;
+  }
+  return false;
+}
+
+export const OmpPluginNameSchema = z
+  .string()
+  .min(1)
+  .max(214)
+  .regex(SAFE_NPM_PACKAGE, "Expected an installed OMP package name");
+
+export const OmpMarketplacePluginIdSchema = z
+  .string()
+  .min(3)
+  .max(128)
+  .regex(SAFE_MARKETPLACE_ID, "Expected name@marketplace");
+
+export const OmpPluginTargetSchema = z.union([OmpPluginNameSchema, OmpMarketplacePluginIdSchema]);
+
+export const OmpPluginInstallSourceSchema = z
+  .string()
+  .min(1)
+  .max(OMP_PLUGIN_ARGUMENT_LIMIT)
+  .refine(
+    (value) => utf8ByteLength(value) <= OMP_PLUGIN_ARGUMENT_LIMIT,
+    "Plugin source is too large",
+  )
+  .refine((value) => value.trim() === value, "Plugin source must not have surrounding whitespace")
+  .refine(
+    (value) => !hasUnsafeArgumentCharacter(value),
+    "Plugin source contains an unsafe character",
+  )
+  .refine((value) => !value.startsWith("-"), "Plugin source must not be an option");
+
+export const OmpPluginScopeSchema = z.enum(["user", "project"]);
+export type OmpPluginScope = z.infer<typeof OmpPluginScopeSchema>;
+
+export const OmpInstalledPluginSchema = z
+  .object({
+    id: z.string().min(1).max(214),
+    packageName: OmpPluginNameSchema.optional(),
+    version: z.string().min(1).max(128).nullable(),
+    source: z.enum(["npm", "marketplace"]),
+    scope: OmpPluginScopeSchema.nullable(),
+    enabled: z.boolean(),
+    shadowed: z.boolean(),
+    path: z.string().min(1).max(4_096).nullable(),
+    description: z.string().max(1_024).nullable(),
+    enabledFeatures: z.array(z.string().min(1).max(128)).max(128),
+    availableFeatures: z.array(z.string().min(1).max(128)).max(128),
+    configurable: z.boolean(),
+    ambiguous: z.boolean(),
+    configAmbiguous: z.boolean(),
+    usesDefaultFeatures: z.boolean(),
+  })
+  .strict();
+export type OmpInstalledPlugin = z.infer<typeof OmpInstalledPluginSchema>;
+
+export const OmpPluginStateSchema = z
+  .object({
+    available: z.boolean(),
+    plugins: z.array(OmpInstalledPluginSchema).max(OMP_PLUGIN_LIMIT),
+    droppedCount: z.number().int().nonnegative(),
+    error: z.string().max(256).optional(),
+  })
+  .strict();
+export type OmpPluginState = z.infer<typeof OmpPluginStateSchema>;
+
+export const listOmpPlugins = defineRpc({
+  name: "paseo-omp.list-plugins",
+  input: z
+    .object({ store: OmpStoreSchema.optional(), cwd: OmpWorkspaceCwdSchema.optional() })
+    .strict(),
+  output: OmpPluginStateSchema,
+});
+
+export const OmpPluginConfigSettingSchema = z
+  .object({
+    key: z.string().min(1).max(128),
+    type: z.enum(["string", "number", "boolean", "enum"]),
+    description: z.string().max(512),
+    configured: z.boolean(),
+    secret: z.boolean(),
+    enumValues: z.array(z.string().min(1).max(256)).max(128),
+    minimum: z.number().finite().optional(),
+    maximum: z.number().finite().optional(),
+    step: z.number().finite().positive().optional(),
+  })
+  .strict();
+export type OmpPluginConfigSetting = z.infer<typeof OmpPluginConfigSettingSchema>;
+
+export const OmpPluginConfigStateSchema = z
+  .object({
+    available: z.boolean(),
+    plugin: OmpPluginNameSchema,
+    settings: z.array(OmpPluginConfigSettingSchema).max(OMP_PLUGIN_LIMIT),
+    droppedCount: z.number().int().nonnegative(),
+    error: z.string().max(256).optional(),
+  })
+  .strict();
+export type OmpPluginConfigState = z.infer<typeof OmpPluginConfigStateSchema>;
+
+export const inspectOmpPluginConfig = defineRpc({
+  name: "paseo-omp.inspect-plugin-config",
+  input: z
+    .object({
+      store: OmpStoreSchema.optional(),
+      plugin: OmpPluginNameSchema,
+      cwd: OmpWorkspaceCwdSchema.optional(),
+    })
+    .strict(),
+  output: OmpPluginConfigStateSchema,
+});
+
+export const OmpPluginConfigKeySchema = z
+  .string()
+  .min(1)
+  .max(128)
+  .refine((value) => value.trim() === value, "Setting key must not have surrounding whitespace")
+  .refine((value) => !hasUnsafeArgumentCharacter(value), "Setting key contains an unsafe character")
+  .refine((value) => !value.startsWith("-"), "Setting key must not be an option");
+
+export const OmpPluginConfigStringValueSchema = z
+  .string()
+  .min(1)
+  .max(4_096)
+  .refine((value) => utf8ByteLength(value) <= 4_096, "Setting value is too large")
+  .refine(
+    (value) => !hasUnsafeArgumentCharacter(value),
+    "Setting value contains an unsafe character",
+  )
+  .refine((value) => !value.startsWith("-"), "Setting value must not be an option");
+
+export const OmpPluginConfigMutationSchema = z.discriminatedUnion("action", [
+  z
+    .object({
+      action: z.literal("set"),
+      plugin: OmpPluginNameSchema,
+      key: OmpPluginConfigKeySchema,
+      value: z.union([OmpPluginConfigStringValueSchema, z.number().finite(), z.boolean()]),
+      store: OmpStoreSchema.optional(),
+      cwd: OmpWorkspaceCwdSchema.optional(),
+    })
+    .strict(),
+  z
+    .object({
+      action: z.literal("delete"),
+      plugin: OmpPluginNameSchema,
+      key: OmpPluginConfigKeySchema,
+      store: OmpStoreSchema.optional(),
+      cwd: OmpWorkspaceCwdSchema.optional(),
+    })
+    .strict(),
+]);
+export type OmpPluginConfigMutation = z.infer<typeof OmpPluginConfigMutationSchema>;
+
+export const mutateOmpPluginConfig = defineRpc({
+  name: "paseo-omp.mutate-plugin-config",
+  input: OmpPluginConfigMutationSchema,
+  output: z
+    .object({
+      ok: z.boolean(),
+      message: z.string().min(1).max(256),
+      config: OmpPluginConfigStateSchema,
+    })
+    .strict(),
+});
+
+const ScopedMutationShape = {
+  scope: OmpPluginScopeSchema.optional(),
+  store: OmpStoreSchema.optional(),
+  cwd: OmpWorkspaceCwdSchema.optional(),
+};
+export const OmpPluginMutationSchema = z
+  .discriminatedUnion("action", [
+    z
+      .object({
+        action: z.literal("install"),
+        source: OmpPluginInstallSourceSchema,
+        ...ScopedMutationShape,
+      })
+      .strict(),
+    z
+      .object({
+        action: z.literal("enable"),
+        plugin: OmpPluginTargetSchema,
+        ...ScopedMutationShape,
+      })
+      .strict(),
+    z
+      .object({
+        action: z.literal("disable"),
+        plugin: OmpPluginTargetSchema,
+        ...ScopedMutationShape,
+      })
+      .strict(),
+    z
+      .object({
+        action: z.literal("uninstall"),
+        plugin: OmpPluginTargetSchema,
+        ...ScopedMutationShape,
+      })
+      .strict(),
+    z
+      .object({
+        action: z.literal("upgrade"),
+        plugin: OmpMarketplacePluginIdSchema,
+        ...ScopedMutationShape,
+      })
+      .strict(),
+  ])
+  .superRefine((input, context) => {
+    if (input.scope === "project" && input.cwd === undefined) {
+      context.addIssue({
+        code: "custom",
+        message: "Project-scoped plugin actions require a workspace",
+        path: ["cwd"],
+      });
+    }
+    if (input.action === "install" && input.scope === "project") {
+      context.addIssue({
+        code: "custom",
+        message: "Project-scoped installation is not supported through this API",
+        path: ["scope"],
+      });
+    }
+  });
+export type OmpPluginMutation = z.infer<typeof OmpPluginMutationSchema>;
+
+export const mutateOmpPlugin = defineRpc({
+  name: "paseo-omp.mutate-plugin",
+  input: OmpPluginMutationSchema,
+  output: z
+    .object({
+      ok: z.boolean(),
+      message: z.string().min(1).max(256),
+      state: OmpPluginStateSchema,
+    })
+    .strict(),
+});