@wopr-network/platform-core 1.70.0 → 1.72.0

package/dist/trpc/routers/settings.d.ts

@@ -0,0 +1,85 @@
+/**
+ * tRPC settings router — tenant config, preferences, health.
+ *
+ * Pure platform-core — service name parameterized via deps.
+ */
+import type { INotificationPreferencesRepository } from "../../email/index.js";
+export interface SettingsRouterDeps {
+    /** Service name returned by health endpoint (e.g. "paperclip-platform"). */
+    serviceName: string;
+    getNotificationPrefsStore: () => INotificationPreferencesRepository;
+    testProvider?: (provider: string, tenantId: string) => Promise<{
+        ok: boolean;
+        latencyMs?: number;
+        error?: string;
+    }>;
+}
+export declare function setSettingsRouterDeps(deps: SettingsRouterDeps): void;
+export declare const settingsRouter: import("@trpc/server").TRPCBuiltRouter<{
+    ctx: import("../init.js").TRPCContext;
+    meta: object;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: false;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    /** Health check — publicly accessible. */
+    health: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            status: "ok";
+            service: string;
+        };
+        meta: object;
+    }>;
+    /** Get tenant configuration summary. */
+    tenantConfig: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            tenantId: string;
+            configured: boolean;
+        };
+        meta: object;
+    }>;
+    /** Ping — verify auth and tenant context. */
+    ping: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            ok: true;
+            tenantId: string;
+            userId: string;
+            timestamp: number;
+        };
+        meta: object;
+    }>;
+    /** Get notification preferences for the authenticated tenant. */
+    notificationPreferences: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: import("../../email/notification-repository-types.js").NotificationPrefs;
+        meta: object;
+    }>;
+    /** Test connectivity to a provider. */
+    testProvider: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            provider: string;
+        };
+        output: {
+            ok: boolean;
+            latencyMs?: number;
+            error?: string;
+        };
+        meta: object;
+    }>;
+    /** Update notification preferences for the authenticated tenant. */
+    updateNotificationPreferences: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            billing_low_balance?: boolean | undefined;
+            billing_receipts?: boolean | undefined;
+            billing_auto_topup?: boolean | undefined;
+            agent_channel_disconnect?: boolean | undefined;
+            agent_status_changes?: boolean | undefined;
+            account_role_changes?: boolean | undefined;
+            account_team_invites?: boolean | undefined;
+        };
+        output: import("../../email/notification-repository-types.js").NotificationPrefs;
+        meta: object;
+    }>;
+}>>;

package/dist/trpc/routers/settings.js

@@ -0,0 +1,73 @@
+/**
+ * tRPC settings router — tenant config, preferences, health.
+ *
+ * Pure platform-core — service name parameterized via deps.
+ */
+import { TRPCError } from "@trpc/server";
+import { z } from "zod";
+import { publicProcedure, router, tenantProcedure } from "../init.js";
+let _deps = null;
+export function setSettingsRouterDeps(deps) {
+    _deps = deps;
+}
+function deps() {
+    if (!_deps)
+        throw new TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "Settings not initialized" });
+    return _deps;
+}
+// ---------------------------------------------------------------------------
+// Router
+// ---------------------------------------------------------------------------
+export const settingsRouter = router({
+    /** Health check — publicly accessible. */
+    health: publicProcedure.query(() => {
+        return { status: "ok", service: deps().serviceName };
+    }),
+    /** Get tenant configuration summary. */
+    tenantConfig: tenantProcedure.query(({ ctx }) => {
+        return {
+            tenantId: ctx.tenantId,
+            configured: true,
+        };
+    }),
+    /** Ping — verify auth and tenant context. */
+    ping: tenantProcedure.query(({ ctx }) => {
+        return {
+            ok: true,
+            tenantId: ctx.tenantId,
+            userId: ctx.user.id,
+            timestamp: Date.now(),
+        };
+    }),
+    /** Get notification preferences for the authenticated tenant. */
+    notificationPreferences: tenantProcedure.query(({ ctx }) => {
+        const store = deps().getNotificationPrefsStore();
+        return store.get(ctx.tenantId);
+    }),
+    /** Test connectivity to a provider. */
+    testProvider: tenantProcedure
+        .input(z.object({ provider: z.string().min(1).max(64) }))
+        .mutation(async ({ input, ctx }) => {
+        const testFn = deps().testProvider;
+        if (!testFn) {
+            return { ok: false, error: "Provider testing not configured" };
+        }
+        return testFn(input.provider, ctx.tenantId);
+    }),
+    /** Update notification preferences for the authenticated tenant. */
+    updateNotificationPreferences: tenantProcedure
+        .input(z.object({
+        billing_low_balance: z.boolean().optional(),
+        billing_receipts: z.boolean().optional(),
+        billing_auto_topup: z.boolean().optional(),
+        agent_channel_disconnect: z.boolean().optional(),
+        agent_status_changes: z.boolean().optional(),
+        account_role_changes: z.boolean().optional(),
+        account_team_invites: z.boolean().optional(),
+    }))
+        .mutation(async ({ input, ctx }) => {
+        const store = deps().getNotificationPrefsStore();
+        await store.update(ctx.tenantId, input);
+        return store.get(ctx.tenantId);
+    }),
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wopr-network/platform-core",
-  "version": "1.70.0",
+  "version": "1.72.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/server/boot-config.ts

@@ -37,9 +37,20 @@ export interface BootConfig {
   /** Short product identifier (e.g. "paperclip", "wopr", "holyship"). */
   slug: string;
 
-  /** PostgreSQL connection string. */
+  /** PostgreSQL connection string. Required unless `pool` is provided. */
   databaseUrl: string;
 
+  /**
+   * Pre-created PostgreSQL connection pool. When provided, buildContainer
+   * reuses this pool and skips pool creation + Drizzle migrations. The
+   * caller is responsible for running their own migrations before calling
+   * buildContainer.
+   *
+   * Use this when the product has its own migration set (e.g. wopr-platform
+   * generates migrations locally from the shared schema).
+   */
+  pool?: import("pg").Pool;
+
   /** Bind host (default "0.0.0.0"). */
   host?: string;
 

package/src/server/container.ts

@@ -19,6 +19,7 @@ import type { FleetManager } from "../fleet/fleet-manager.js";
 import type { IProfileStore } from "../fleet/profile-store.js";
 import type { IServiceKeyRepository } from "../gateway/service-key-repository.js";
 import type { ProductConfig } from "../product-config/repository-types.js";
+import type { ProductConfigService } from "../product-config/service.js";
 import type { ProxyManagerInterface } from "../proxy/types.js";
 import type { IOrgMemberRepository } from "../tenancy/org-member-repository.js";
 import type { OrgService } from "../tenancy/org-service.js";
@@ -75,6 +76,7 @@ export interface PlatformContainer {
   db: DrizzleDb;
   pool: Pool;
   productConfig: ProductConfig;
+  productConfigService: ProductConfigService;
   creditLedger: ILedger;
   orgMemberRepo: IOrgMemberRepository;
   orgService: OrgService;
@@ -108,27 +110,34 @@ export interface PlatformContainer {
  * `bootConfig.features`. Disabled features yield `null`.
  */
 export async function buildContainer(bootConfig: BootConfig): Promise<PlatformContainer> {
-  if (!bootConfig.databaseUrl) {
-    throw new Error("buildContainer: databaseUrl is required");
+  // 1. Database pool — reuse existing or create new
+  let pool: Pool;
+  if (bootConfig.pool) {
+    pool = bootConfig.pool;
+  } else {
+    if (!bootConfig.databaseUrl) {
+      throw new Error("buildContainer: databaseUrl is required when pool is not provided");
+    }
+    const { Pool: PgPool } = await import("pg");
+    pool = new PgPool({ connectionString: bootConfig.databaseUrl });
   }
 
-  // 1. Database pool
-  const { Pool: PgPool } = await import("pg");
-  const pool: Pool = new PgPool({ connectionString: bootConfig.databaseUrl });
-
   // 2. Drizzle ORM instance
   const { createDb } = await import("../db/index.js");
   const db = createDb(pool);
 
-  // 3. Run Drizzle migrations
-  const { migrate } = await import("drizzle-orm/node-postgres/migrator");
-  const path = await import("node:path");
-  const migrationsFolder = path.resolve(path.dirname(new URL(import.meta.url).pathname), "../../drizzle");
-  await migrate(db as never, { migrationsFolder });
+  // 3. Run Drizzle migrations (skip when caller provided their own pool —
+  //    they are responsible for running product-specific migrations first)
+  if (!bootConfig.pool) {
+    const { migrate } = await import("drizzle-orm/node-postgres/migrator");
+    const path = await import("node:path");
+    const migrationsFolder = path.resolve(path.dirname(new URL(import.meta.url).pathname), "../../drizzle");
+    await migrate(db as never, { migrationsFolder });
+  }
 
   // 4. Bootstrap product config from DB (auto-seeds from presets if needed)
   const { platformBoot } = await import("../product-config/boot.js");
-  const { config: productConfig } = await platformBoot({ slug: bootConfig.slug, db });
+  const { config: productConfig, service: productConfigService } = await platformBoot({ slug: bootConfig.slug, db });
 
   // 5. Credit ledger
   const { DrizzleLedger } = await import("../credits/ledger.js");
@@ -232,6 +241,7 @@ export async function buildContainer(bootConfig: BootConfig): Promise<PlatformCo
     db,
     pool,
     productConfig,
+    productConfigService,
     creditLedger,
     orgMemberRepo,
     orgService,

package/src/server/services/__tests__/hot-pool.test.ts

@@ -0,0 +1,30 @@
+/**
+ * Tests for hot pool service functions (getPoolSize, setPoolSize).
+ *
+ * Uses InMemoryPoolRepository to test service logic without Docker or DB.
+ */
+
+import { describe, expect, it } from "vitest";
+import { getPoolSize, setPoolSize } from "../hot-pool.js";
+import { InMemoryPoolRepository } from "./in-memory-pool-repository.js";
+
+describe("hot pool service", () => {
+  describe("getPoolSize / setPoolSize", () => {
+    it("returns default pool size", async () => {
+      const repo = new InMemoryPoolRepository();
+      expect(await getPoolSize(repo)).toBe(2);
+    });
+
+    it("sets and reads pool size", async () => {
+      const repo = new InMemoryPoolRepository();
+      await setPoolSize(repo, 10);
+      expect(await getPoolSize(repo)).toBe(10);
+    });
+
+    it("pool size of 0 is valid", async () => {
+      const repo = new InMemoryPoolRepository();
+      await setPoolSize(repo, 0);
+      expect(await getPoolSize(repo)).toBe(0);
+    });
+  });
+});

package/src/server/services/__tests__/in-memory-pool-repository.ts

@@ -0,0 +1,66 @@
+/**
+ * In-memory IPoolRepository for testing.
+ * FIFO claiming, dead instance handling — no DB required.
+ */
+
+import type { IPoolRepository, PoolInstance } from "../pool-repository.js";
+
+export class InMemoryPoolRepository implements IPoolRepository {
+  private poolSize = 2;
+  private instances: Array<PoolInstance & { createdAt: Date; claimedAt: Date | null }> = [];
+
+  async getPoolSize(): Promise<number> {
+    return this.poolSize;
+  }
+
+  async setPoolSize(size: number): Promise<void> {
+    this.poolSize = size;
+  }
+
+  async warmCount(): Promise<number> {
+    return this.instances.filter((i) => i.status === "warm").length;
+  }
+
+  async insertWarm(id: string, containerId: string): Promise<void> {
+    this.instances.push({
+      id,
+      containerId,
+      status: "warm",
+      tenantId: null,
+      name: null,
+      createdAt: new Date(),
+      claimedAt: null,
+    });
+  }
+
+  async listWarm(): Promise<PoolInstance[]> {
+    return this.instances.filter((i) => i.status === "warm").map(({ createdAt, claimedAt, ...rest }) => rest);
+  }
+
+  async markDead(id: string): Promise<void> {
+    const inst = this.instances.find((i) => i.id === id);
+    if (inst) inst.status = "dead";
+  }
+
+  async deleteDead(): Promise<void> {
+    this.instances = this.instances.filter((i) => i.status !== "dead");
+  }
+
+  async claimWarm(tenantId: string, name: string): Promise<{ id: string; containerId: string } | null> {
+    const warm = this.instances
+      .filter((i) => i.status === "warm")
+      .sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+    if (warm.length === 0) return null;
+    const target = warm[0];
+    target.status = "claimed";
+    target.tenantId = tenantId;
+    target.name = name;
+    target.claimedAt = new Date();
+    return { id: target.id, containerId: target.containerId };
+  }
+
+  async updateInstanceStatus(id: string, status: string): Promise<void> {
+    const inst = this.instances.find((i) => i.id === id);
+    if (inst) inst.status = status;
+  }
+}

package/src/server/services/__tests__/pool-repository.test.ts

@@ -0,0 +1,135 @@
+/**
+ * Tests for IPoolRepository interface contract.
+ *
+ * Uses an in-memory implementation to verify the interface
+ * behavior without requiring a real database.
+ */
+
+import { describe, expect, it } from "vitest";
+import { InMemoryPoolRepository } from "./in-memory-pool-repository.js";
+
+describe("IPoolRepository (InMemory)", () => {
+  it("returns default pool size of 2", async () => {
+    const repo = new InMemoryPoolRepository();
+    expect(await repo.getPoolSize()).toBe(2);
+  });
+
+  it("sets and gets pool size", async () => {
+    const repo = new InMemoryPoolRepository();
+    await repo.setPoolSize(5);
+    expect(await repo.getPoolSize()).toBe(5);
+  });
+
+  it("inserts and counts warm instances", async () => {
+    const repo = new InMemoryPoolRepository();
+    expect(await repo.warmCount()).toBe(0);
+
+    await repo.insertWarm("a", "container-a");
+    await repo.insertWarm("b", "container-b");
+
+    expect(await repo.warmCount()).toBe(2);
+  });
+
+  it("lists warm instances", async () => {
+    const repo = new InMemoryPoolRepository();
+    await repo.insertWarm("a", "container-a");
+    await repo.insertWarm("b", "container-b");
+
+    const warm = await repo.listWarm();
+    expect(warm).toHaveLength(2);
+    expect(warm[0].id).toBe("a");
+    expect(warm[0].containerId).toBe("container-a");
+    expect(warm[0].status).toBe("warm");
+  });
+
+  it("claims warm instance FIFO", async () => {
+    const repo = new InMemoryPoolRepository();
+    await repo.insertWarm("first", "c-first");
+    await repo.insertWarm("second", "c-second");
+
+    const claimed = await repo.claimWarm("tenant-1", "my-bot");
+    expect(claimed).not.toBeNull();
+    expect(claimed?.id).toBe("first");
+    expect(claimed?.containerId).toBe("c-first");
+
+    // Warm count drops by 1
+    expect(await repo.warmCount()).toBe(1);
+  });
+
+  it("returns null when claiming from empty pool", async () => {
+    const repo = new InMemoryPoolRepository();
+    const result = await repo.claimWarm("tenant-1", "bot");
+    expect(result).toBeNull();
+  });
+
+  it("does not re-claim already claimed instances", async () => {
+    const repo = new InMemoryPoolRepository();
+    await repo.insertWarm("only", "c-only");
+
+    const first = await repo.claimWarm("t1", "bot1");
+    expect(first).not.toBeNull();
+
+    const second = await repo.claimWarm("t2", "bot2");
+    expect(second).toBeNull();
+  });
+
+  it("marks instances dead", async () => {
+    const repo = new InMemoryPoolRepository();
+    await repo.insertWarm("a", "c-a");
+    await repo.markDead("a");
+
+    expect(await repo.warmCount()).toBe(0);
+    const warm = await repo.listWarm();
+    expect(warm).toHaveLength(0);
+  });
+
+  it("deletes dead instances", async () => {
+    const repo = new InMemoryPoolRepository();
+    await repo.insertWarm("a", "c-a");
+    await repo.insertWarm("b", "c-b");
+    await repo.markDead("a");
+
+    await repo.deleteDead();
+
+    // Only 'b' remains (warm)
+    expect(await repo.warmCount()).toBe(1);
+    const warm = await repo.listWarm();
+    expect(warm[0].id).toBe("b");
+  });
+
+  it("updates instance status", async () => {
+    const repo = new InMemoryPoolRepository();
+    await repo.insertWarm("a", "c-a");
+    await repo.updateInstanceStatus("a", "provisioning");
+
+    // No longer warm
+    expect(await repo.warmCount()).toBe(0);
+  });
+
+  it("handles multiple claims in order", async () => {
+    const repo = new InMemoryPoolRepository();
+    await repo.insertWarm("1", "c-1");
+    await repo.insertWarm("2", "c-2");
+    await repo.insertWarm("3", "c-3");
+
+    const c1 = await repo.claimWarm("t-a", "bot-a");
+    const c2 = await repo.claimWarm("t-b", "bot-b");
+    const c3 = await repo.claimWarm("t-c", "bot-c");
+    const c4 = await repo.claimWarm("t-d", "bot-d");
+
+    expect(c1?.id).toBe("1");
+    expect(c2?.id).toBe("2");
+    expect(c3?.id).toBe("3");
+    expect(c4).toBeNull();
+    expect(await repo.warmCount()).toBe(0);
+  });
+
+  it("dead instances are not claimable", async () => {
+    const repo = new InMemoryPoolRepository();
+    await repo.insertWarm("a", "c-a");
+    await repo.markDead("a");
+
+    const result = await repo.claimWarm("t1", "bot");
+    expect(result).toBeNull();
+  });
+});

package/src/server/test-container.ts

@@ -12,6 +12,7 @@ import type { IUserRoleRepository } from "../auth/user-role-repository.js";
 import type { ILedger } from "../credits/ledger.js";
 import type { DrizzleDb } from "../db/index.js";
 import type { ProductConfig } from "../product-config/repository-types.js";
+import { ProductConfigService } from "../product-config/service.js";
 import type { IOrgMemberRepository } from "../tenancy/org-member-repository.js";
 import type { OrgService } from "../tenancy/org-service.js";
 import type { PlatformContainer } from "./container.js";
@@ -90,6 +91,19 @@ function stubProductConfig(): ProductConfig {
   };
 }
 
+function stubProductConfigService(): ProductConfigService {
+  const stubRepo = {
+    getBySlug: async () => stubProductConfig(),
+    listAll: async () => [],
+    upsertProduct: async () => stubProductConfig().product,
+    replaceNavItems: async () => {},
+    upsertFeatures: async () => {},
+    upsertFleetConfig: async () => {},
+    upsertBillingConfig: async () => {},
+  };
+  return new ProductConfigService(stubRepo as never);
+}
+
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
@@ -103,6 +117,7 @@ export function createTestContainer(overrides?: Partial<PlatformContainer>): Pla
     db: {} as DrizzleDb,
     pool: { end: async () => {} } as never,
     productConfig: stubProductConfig(),
+    productConfigService: stubProductConfigService(),
     creditLedger: stubLedger(),
     orgMemberRepo: stubOrgMemberRepo(),
     orgService: {} as OrgService,

package/src/trpc/index.ts

@@ -13,6 +13,7 @@ export { createFleetUpdateConfigRouter } from "./fleet-update-config-router.js";
 export {
   adminProcedure,
   createCallerFactory,
+  createTRPCContext,
   orgAdminProcedure,
   orgMemberProcedure,
   protectedProcedure,
@@ -28,3 +29,6 @@ export {
   type OrgRemovePaymentMethodDeps,
 } from "./org-remove-payment-method-router.js";
 export { createProductConfigRouter } from "./product-config-router.js";
+export { type PageContextRouterDeps, pageContextRouter, setPageContextRouterDeps } from "./routers/page-context.js";
+export { type ProfileRouterDeps, profileRouter, setProfileRouterDeps } from "./routers/profile.js";
+export { type SettingsRouterDeps, setSettingsRouterDeps, settingsRouter } from "./routers/settings.js";

package/src/trpc/init.ts

@@ -22,6 +22,34 @@ export interface TRPCContext {
   tenantId: string | undefined;
 }
 
+// ---------------------------------------------------------------------------
+// Context factory — resolves BetterAuth session into TRPCContext
+// ---------------------------------------------------------------------------
+
+/**
+ * Create a TRPCContext from an incoming request.
+ * Resolves the user from BetterAuth session cookies.
+ */
+export async function createTRPCContext(req: Request): Promise<TRPCContext> {
+  let user: AuthUser | undefined;
+  let tenantId: string | undefined;
+  try {
+    const { getAuth } = await import("../auth/better-auth.js");
+    const auth = getAuth();
+    const session = await auth.api.getSession({ headers: req.headers });
+    if (session?.user) {
+      const sessionUser = session.user as { id: string; role?: string };
+      const roles: string[] = [];
+      if (sessionUser.role) roles.push(sessionUser.role);
+      user = { id: sessionUser.id, roles };
+      tenantId = req.headers.get("x-tenant-id") || sessionUser.id;
+    }
+  } catch {
+    // No session — unauthenticated request
+  }
+  return { user, tenantId: tenantId ?? "" };
+}
+
 // ---------------------------------------------------------------------------
 // tRPC init
 // ---------------------------------------------------------------------------

package/src/trpc/routers/page-context.ts

@@ -0,0 +1,57 @@
+/**
+ * tRPC page-context router — stores and retrieves per-user page context.
+ *
+ * Pure platform-core — no product-specific imports.
+ */
+
+import { TRPCError } from "@trpc/server";
+import { z } from "zod";
+import type { IPageContextRepository } from "../../fleet/page-context-repository.js";
+import { protectedProcedure, router } from "../init.js";
+
+// ---------------------------------------------------------------------------
+// Deps
+// ---------------------------------------------------------------------------
+
+export interface PageContextRouterDeps {
+  repo: IPageContextRepository;
+}
+
+let _deps: PageContextRouterDeps | null = null;
+
+export function setPageContextRouterDeps(deps: PageContextRouterDeps): void {
+  _deps = deps;
+}
+
+function deps(): PageContextRouterDeps {
+  if (!_deps) throw new TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "Page context not initialized" });
+  return _deps;
+}
+
+// ---------------------------------------------------------------------------
+// Schema
+// ---------------------------------------------------------------------------
+
+const updatePageContextSchema = z.object({
+  currentPage: z.string().min(1).max(500),
+  pagePrompt: z.string().max(2000).nullable(),
+});
+
+// ---------------------------------------------------------------------------
+// Router
+// ---------------------------------------------------------------------------
+
+export const pageContextRouter = router({
+  /** Update the page context for the current user. Called on route change. */
+  update: protectedProcedure.input(updatePageContextSchema).mutation(async ({ ctx, input }) => {
+    await deps().repo.set(ctx.user.id, input.currentPage, input.pagePrompt);
+    return { ok: true as const };
+  }),
+
+  /** Get the current page context for the authenticated user. */
+  current: protectedProcedure.query(async ({ ctx }) => {
+    const pc = await deps().repo.get(ctx.user.id);
+    if (!pc) return null;
+    return { currentPage: pc.currentPage, pagePrompt: pc.pagePrompt };
+  }),
+});