@omg-dev/admin 0.4.24

package/dist/server.mjs

@@ -0,0 +1,50 @@
+//#region src/server.ts
+const ALLOWED = [
+	"/api/flags/",
+	"/api/adminBilling/",
+	"/api/bugReports/",
+	"/api/users/"
+];
+function json(body, status) {
+	return new Response(JSON.stringify(body), {
+		status,
+		headers: {
+			"content-type": "application/json",
+			"cache-control": "no-store"
+		}
+	});
+}
+function createOmgAdminProxy(opts) {
+	const target = (opts.target ?? "https://backend.omg.dev").replace(/\/$/, "");
+	const prefix = opts.prefix ?? "/_omg";
+	return async function handle(req) {
+		const url = new URL(req.url);
+		if (url.pathname !== prefix && !url.pathname.startsWith(prefix + "/")) return null;
+		if (!opts.token) return json({ error: "omg admin token not configured" }, 503);
+		const upstreamPath = url.pathname.slice(prefix.length);
+		if (!ALLOWED.some((p) => upstreamPath.startsWith(p))) return json({ error: "forbidden path" }, 403);
+		const init = {
+			method: req.method,
+			headers: {
+				"content-type": req.headers.get("content-type") ?? "application/json",
+				authorization: `Bearer ${opts.token}`
+			},
+			signal: AbortSignal.timeout(3e4)
+		};
+		if (req.method !== "GET" && req.method !== "HEAD") init.body = await req.text();
+		try {
+			const r = await fetch(`${target}${upstreamPath}${url.search}`, init);
+			return new Response(r.body, {
+				status: r.status,
+				headers: {
+					"content-type": r.headers.get("content-type") ?? "application/json",
+					"cache-control": "no-store"
+				}
+			});
+		} catch {
+			return json({ error: "omg control-plane unreachable" }, 502);
+		}
+	};
+}
+//#endregion
+export { createOmgAdminProxy };

package/dist/standalone.mjs

@@ -0,0 +1,11 @@
+import { o as AdminClient, t as AdminConsole } from "./react-COCR3YSL.mjs";
+import { createElement } from "react";
+import { createRoot } from "react-dom/client";
+//#region src/standalone.tsx
+function mountAdminConsole(el, config) {
+	const root = createRoot(el);
+	root.render(createElement(AdminConsole, { client: new AdminClient(config) }));
+	return root;
+}
+//#endregion
+export { AdminClient, AdminConsole, mountAdminConsole };

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@omg-dev/admin",
+  "version": "0.4.24",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "default": "./dist/index.mjs"
+    },
+    "./standalone": {
+      "types": "./src/standalone.tsx",
+      "default": "./dist/standalone.mjs"
+    },
+    "./server": {
+      "types": "./src/server.ts",
+      "default": "./dist/server.mjs"
+    }
+  },
+  "peerDependencies": {
+    "react": "^18 || ^19",
+    "react-dom": "^18 || ^19"
+  },
+  "peerDependenciesMeta": {
+    "react-dom": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "typescript": "^5.4.5"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/BennyKok/vibes.git"
+  },
+  "homepage": "https://docs.omg.dev",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}

package/src/client.ts

@@ -0,0 +1,278 @@
+// @omg-dev/admin — host-agnostic control-plane RPC client.
+//
+// The admin console is embedded in MORE than one host (the omg dashboard, the
+// LFG app, later Inspect), so it never assumes a base URL or an auth provider.
+// The host supplies an `AdminClientConfig`: where the control-plane lives
+// (`apiBase`) and how to get a bearer token (`getToken`). Every call is
+// POST {apiBase}/api/<module>/<name> with the args object as the JSON body and
+// `Authorization: Bearer <token>` — the same wire the dashboard's own client
+// uses, minus the Convex-shape bridging the console doesn't need.
+
+export interface AdminClientConfig {
+  /** Control-plane origin, e.g. "https://backend.omg.dev" (no trailing slash). */
+  apiBase: string
+  /** Returns a fresh bearer JWT (or null when signed out). Awaited per call. */
+  getToken: () => string | null | Promise<string | null>
+}
+
+export class AdminError extends Error {
+  status: number
+  data: unknown
+  constructor(message: string, status: number, data: unknown) {
+    super(message)
+    this.name = "AdminError"
+    this.status = status
+    this.data = data
+  }
+}
+
+export class AdminClient {
+  private apiBase: string
+  private getToken: AdminClientConfig["getToken"]
+
+  constructor(config: AdminClientConfig) {
+    this.apiBase = config.apiBase.replace(/\/$/, "")
+    this.getToken = config.getToken
+  }
+
+  private async rpc<T>(module: string, name: string, args?: Record<string, unknown>): Promise<T> {
+    const token = await this.getToken()
+    const headers: Record<string, string> = { "content-type": "application/json" }
+    if (token) headers.authorization = `Bearer ${token}`
+    const res = await fetch(`${this.apiBase}/api/${module}/${name}`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(args ?? {}),
+    })
+    if (!res.ok) {
+      let message = `${module}.${name} failed (${res.status})`
+      let payload: unknown = null
+      try {
+        payload = await res.json()
+        if (payload && typeof payload === "object" && "error" in payload) {
+          message = String((payload as { error: unknown }).error)
+        }
+      } catch {
+        /* non-JSON error body */
+      }
+      throw new AdminError(message, res.status, payload)
+    }
+    if (res.status === 204) return undefined as T
+    const text = await res.text()
+    return (text ? JSON.parse(text) : undefined) as T
+  }
+
+  // ── flags ────────────────────────────────────────────────────────────────
+  listFlags() {
+    return this.rpc<FlagDef[]>("flags", "listFlags")
+  }
+  upsertFlag(flag: FlagUpsert) {
+    return this.rpc<{ ok: true; key: string }>("flags", "upsert", flag as unknown as Record<string, unknown>)
+  }
+  setFlagArchived(key: string, archived: boolean) {
+    return this.rpc<{ ok: true }>("flags", "setArchived", { key, archived })
+  }
+  removeFlag(key: string) {
+    return this.rpc<{ ok: true }>("flags", "removeFlag", { key })
+  }
+  listOverrides(flagKey: string) {
+    return this.rpc<FlagOverride[]>("flags", "listOverrides", { flagKey })
+  }
+  setOverride(o: { flagKey: string; userId: string; enabled: boolean; value?: unknown; note?: string }) {
+    return this.rpc<{ ok: true }>("flags", "setOverride", o as Record<string, unknown>)
+  }
+  removeOverride(flagKey: string, userId: string) {
+    return this.rpc<{ ok: true }>("flags", "removeOverride", { flagKey, userId })
+  }
+  findUsers(query: string) {
+    return this.rpc<UserHit[]>("users", "findUsers", { query })
+  }
+  listUsers(args?: { query?: string; limit?: number; offset?: number }) {
+    return this.rpc<AdminUserList>("users", "listUsers", args ?? {})
+  }
+
+  // ── billing (read-only) ────────────────────────────────────────────────────
+  planVersions() {
+    return this.rpc<PlanVersion[]>("adminBilling", "planVersions")
+  }
+  models() {
+    return this.rpc<ModelInfo[]>("adminBilling", "models")
+  }
+  userBalance(userId: string) {
+    return this.rpc<UserBalance>("adminBilling", "userBalance", { userId })
+  }
+
+  // ── bug reports (triage) ───────────────────────────────────────────────────
+  listReports(args?: { status?: BugStatus; limit?: number; clusterKey?: string }) {
+    return this.rpc<BugReportList>("bugReports", "listReports", args ?? {})
+  }
+  getReport(id: string) {
+    return this.rpc<BugReportDetail | null>("bugReports", "getReport", { id })
+  }
+  setReportStatus(id: string, status: BugStatus, assignee?: string) {
+    return this.rpc<{ ok: true }>("bugReports", "setStatus", { id, status, assignee })
+  }
+  addReportNote(id: string, note: string) {
+    return this.rpc<{ ok: true }>("bugReports", "addNote", { id, note })
+  }
+  // Dedupe surface: group a report under a root cause (clusterKey=null clears),
+  // and roll up clusters so triage can skip a duplicate fixer.
+  setReportCluster(id: string, clusterKey: string | null) {
+    return this.rpc<{ ok: true; clusterKey: string | null }>("bugReports", "setCluster", { id, clusterKey })
+  }
+  listClusters() {
+    return this.rpc<BugClusterList>("bugReports", "listClusters", {})
+  }
+  removeReport(id: string) {
+    return this.rpc<{ ok: boolean }>("bugReports", "removeReport", { id })
+  }
+}
+
+// ── shared types (mirror control-plane function returns) ──────────────────────
+
+export type ValueType = "bool" | "json"
+
+export interface FlagDef {
+  key: string
+  description: string
+  valueType: ValueType
+  enabled: boolean
+  defaultValue: unknown
+  rolloutPercent: number | null
+  planRules: Record<string, unknown> | null
+  archivedAt: number | null
+  overrideCount: number
+  createdAt: number
+  updatedAt: number
+}
+
+export interface FlagUpsert {
+  key: string
+  description?: string
+  valueType?: ValueType
+  enabled?: boolean
+  defaultValue?: unknown
+  rolloutPercent?: number | null
+  planRules?: Record<string, unknown> | null
+}
+
+export interface FlagOverride {
+  flagKey: string
+  userId: string
+  userEmail: string | null
+  userName: string | null
+  enabled: boolean
+  value: unknown
+  note: string
+  updatedAt: number
+}
+
+export interface UserHit {
+  id: string
+  email: string
+  name: string
+  image: string | null
+}
+
+export interface AdminUser {
+  id: string
+  email: string
+  name: string
+  image: string | null
+  emailVerified: boolean
+  createdAt: number
+  updatedAt: number
+  activeSessionCount: number
+  projectCount: number
+  ownedProjectCount: number
+  flagOverrideCount: number
+}
+
+export interface AdminUserList {
+  users: AdminUser[]
+  total: number
+  limit: number
+  offset: number
+  query: string
+}
+
+export interface PlanVersion {
+  planKey: string
+  version: number
+  status: string
+  priceUsd: number
+  interval: string
+  externalProductId: string
+  externalPriceId: string
+  createdAt: number
+}
+
+export interface ModelInfo {
+  id: string
+  name?: string
+  provider?: string
+  [k: string]: unknown
+}
+
+export interface UserBalance {
+  exists: boolean
+  plan: string
+  balanceUsd: number
+  appCreditsUsd: number
+}
+
+// ── bug reports ───────────────────────────────────────────────────────────────
+
+export type BugStatus = "open" | "triaged" | "in_progress" | "resolved" | "wont_fix"
+export type BugSeverity = "low" | "normal" | "high" | "critical"
+
+export interface BugReportSummary {
+  id: string
+  title: string
+  severity: BugSeverity
+  status: BugStatus
+  assignee: string | null
+  reporterEmail: string | null
+  // null = anonymous app-submitted report → reporterEmail is self-claimed and
+  // unverified (the UI marks it). Non-null = dashboard report, email from JWT.
+  reporterUserId: string | null
+  slug: string | null
+  // Root-cause cluster key (null = unclustered). Reports sharing a key are
+  // duplicates of one root cause; triage uses it to dedupe.
+  clusterKey: string | null
+  createdAt: number
+  updatedAt: number
+}
+
+export interface BugReportList {
+  reports: BugReportSummary[]
+  counts: Record<string, number>
+}
+
+export interface BugCluster {
+  clusterKey: string
+  total: number
+  open: number
+  // Reports not yet resolved/wont_fix — non-zero means the root cause is still
+  // live, so a new duplicate should attach here instead of opening a new fixer.
+  unresolved: number
+  latestAt: number
+  latestTitle: string | null
+}
+
+export interface BugClusterList {
+  clusters: BugCluster[]
+}
+
+export interface BugReportDetail extends BugReportSummary {
+  body: string
+  projectId: string | null
+  runId: string | null
+  snapshotId: string | null
+  version: number | null
+  pageUrl: string | null
+  userAgent: string | null
+  adminNotes: string | null
+  resolvedAt: number | null
+  context: unknown
+}

package/src/index.ts

@@ -0,0 +1,43 @@
+// @omg-dev/admin — embeddable internal admin console.
+//
+// A panel-registry React console (Feature Flags, Users, Reports + read-only
+// Pricing/Billing) that drops into any host as a single <AdminConsole/> — the
+// omg dashboard, the LFG app, or Inspect. Host-agnostic: you pass an AdminClient
+// (control-plane base URL + a bearer-token getter); the console does the rest.
+// Self-styled (no Tailwind dependency), and every endpoint it calls is
+// admin-gated server-side.
+//
+// Standalone usage (its own app) lives in "@omg-dev/admin/standalone".
+
+export {
+  AdminConsole,
+  FlagsPanel,
+  PricingPanel,
+  ReportsPanel,
+  UsersPanel,
+  AdminClient,
+  type AdminConsoleProps,
+  type AdminClientConfig,
+  type PanelDef,
+} from "./react"
+
+export {
+  AdminError,
+  type FlagDef,
+  type FlagUpsert,
+  type FlagOverride,
+  type PlanVersion,
+  type ModelInfo,
+  type UserBalance,
+  type UserHit,
+  type AdminUser,
+  type AdminUserList,
+  type ValueType,
+  type BugStatus,
+  type BugSeverity,
+  type BugReportSummary,
+  type BugReportList,
+  type BugReportDetail,
+} from "./client"
+
+export { ensureStyles, STYLE_ID } from "./styles"