@wopr-network/platform-core 1.58.0 → 1.59.0

package/scripts/seed-products.ts

@@ -0,0 +1,268 @@
+/**
+ * Seed product config tables with data for all 4 products.
+ *
+ * Usage:
+ *   DATABASE_URL=postgres://... npx tsx scripts/seed-products.ts
+ *   DATABASE_URL=postgres://... npx tsx scripts/seed-products.ts --slug=paperclip
+ */
+import { eq } from "drizzle-orm";
+import { drizzle } from "drizzle-orm/node-postgres";
+import pg from "pg";
+import { productFeatures, productFleetConfig } from "../src/db/schema/product-config.js";
+import { productNavItems, products } from "../src/db/schema/products.js";
+
+interface NavItem {
+  label: string;
+  href: string;
+  sortOrder: number;
+  requiresRole?: string;
+}
+
+interface FleetPreset {
+  containerImage: string;
+  lifecycle: "managed" | "ephemeral";
+  billingModel: "monthly" | "per_use" | "none";
+  maxInstances: number;
+}
+
+interface ProductPreset {
+  brandName: string;
+  productName: string;
+  tagline: string;
+  domain: string;
+  appDomain: string;
+  cookieDomain: string;
+  companyLegal: string;
+  priceLabel: string;
+  defaultImage: string;
+  emailSupport: string;
+  emailPrivacy: string;
+  emailLegal: string;
+  fromEmail: string;
+  homePath: string;
+  storagePrefix: string;
+  navItems: NavItem[];
+  fleet: FleetPreset;
+}
+
+const PRESETS: Record<string, ProductPreset> = {
+  wopr: {
+    brandName: "WOPR",
+    productName: "WOPR Bot",
+    tagline: "A $5/month supercomputer that manages your business.",
+    domain: "wopr.bot",
+    appDomain: "app.wopr.bot",
+    cookieDomain: ".wopr.bot",
+    companyLegal: "WOPR Network Inc.",
+    priceLabel: "$5/month",
+    defaultImage: "ghcr.io/wopr-network/wopr:latest",
+    emailSupport: "support@wopr.bot",
+    emailPrivacy: "privacy@wopr.bot",
+    emailLegal: "legal@wopr.bot",
+    fromEmail: "noreply@wopr.bot",
+    homePath: "/marketplace",
+    storagePrefix: "wopr",
+    navItems: [
+      { label: "Dashboard", href: "/dashboard", sortOrder: 0 },
+      { label: "Chat", href: "/chat", sortOrder: 1 },
+      { label: "Marketplace", href: "/marketplace", sortOrder: 2 },
+      { label: "Channels", href: "/channels", sortOrder: 3 },
+      { label: "Plugins", href: "/plugins", sortOrder: 4 },
+      { label: "Instances", href: "/instances", sortOrder: 5 },
+      { label: "Changesets", href: "/changesets", sortOrder: 6 },
+      { label: "Network", href: "/dashboard/network", sortOrder: 7 },
+      { label: "Fleet Health", href: "/fleet/health", sortOrder: 8 },
+      { label: "Credits", href: "/billing/credits", sortOrder: 9 },
+      { label: "Billing", href: "/billing/plans", sortOrder: 10 },
+      { label: "Settings", href: "/settings/profile", sortOrder: 11 },
+      { label: "Admin", href: "/admin/tenants", sortOrder: 12, requiresRole: "platform_admin" },
+    ],
+    fleet: {
+      containerImage: "ghcr.io/wopr-network/wopr:latest",
+      lifecycle: "managed",
+      billingModel: "monthly",
+      maxInstances: 5,
+    },
+  },
+  paperclip: {
+    brandName: "Paperclip",
+    productName: "Paperclip",
+    tagline: "AI agents that run your business.",
+    domain: "runpaperclip.com",
+    appDomain: "app.runpaperclip.com",
+    cookieDomain: ".runpaperclip.com",
+    companyLegal: "Paperclip AI Inc.",
+    priceLabel: "$5/month",
+    defaultImage: "ghcr.io/wopr-network/paperclip:managed",
+    emailSupport: "support@runpaperclip.com",
+    emailPrivacy: "privacy@runpaperclip.com",
+    emailLegal: "legal@runpaperclip.com",
+    fromEmail: "noreply@runpaperclip.com",
+    homePath: "/instances",
+    storagePrefix: "paperclip",
+    navItems: [
+      { label: "Instances", href: "/instances", sortOrder: 0 },
+      { label: "Credits", href: "/billing/credits", sortOrder: 1 },
+      { label: "Settings", href: "/settings/profile", sortOrder: 2 },
+      { label: "Admin", href: "/admin/tenants", sortOrder: 3, requiresRole: "platform_admin" },
+    ],
+    fleet: {
+      containerImage: "ghcr.io/wopr-network/paperclip:managed",
+      lifecycle: "managed",
+      billingModel: "monthly",
+      maxInstances: 5,
+    },
+  },
+  holyship: {
+    brandName: "Holy Ship",
+    productName: "Holy Ship",
+    tagline: "Ship it.",
+    domain: "holyship.wtf",
+    appDomain: "app.holyship.wtf",
+    cookieDomain: ".holyship.wtf",
+    companyLegal: "WOPR Network Inc.",
+    priceLabel: "",
+    defaultImage: "ghcr.io/wopr-network/holyship:latest",
+    emailSupport: "support@holyship.wtf",
+    emailPrivacy: "privacy@holyship.wtf",
+    emailLegal: "legal@holyship.wtf",
+    fromEmail: "noreply@holyship.wtf",
+    homePath: "/dashboard",
+    storagePrefix: "holyship",
+    navItems: [
+      { label: "Dashboard", href: "/dashboard", sortOrder: 0 },
+      { label: "Ship", href: "/ship", sortOrder: 1 },
+      { label: "Approvals", href: "/approvals", sortOrder: 2 },
+      { label: "Connect", href: "/connect", sortOrder: 3 },
+      { label: "Credits", href: "/billing/credits", sortOrder: 4 },
+      { label: "Settings", href: "/settings/profile", sortOrder: 5 },
+      { label: "Admin", href: "/admin/tenants", sortOrder: 6, requiresRole: "platform_admin" },
+    ],
+    fleet: {
+      containerImage: "ghcr.io/wopr-network/holyship:latest",
+      lifecycle: "ephemeral",
+      billingModel: "none",
+      maxInstances: 50,
+    },
+  },
+  nemoclaw: {
+    brandName: "NemoPod",
+    productName: "NemoPod",
+    tagline: "NVIDIA NeMo, one click away",
+    domain: "nemopod.com",
+    appDomain: "app.nemopod.com",
+    cookieDomain: ".nemopod.com",
+    companyLegal: "WOPR Network Inc.",
+    priceLabel: "$5 free credits",
+    defaultImage: "ghcr.io/wopr-network/nemoclaw:latest",
+    emailSupport: "support@nemopod.com",
+    emailPrivacy: "privacy@nemopod.com",
+    emailLegal: "legal@nemopod.com",
+    fromEmail: "noreply@nemopod.com",
+    homePath: "/instances",
+    storagePrefix: "nemopod",
+    navItems: [
+      { label: "NemoClaws", href: "/instances", sortOrder: 0 },
+      { label: "Credits", href: "/billing/credits", sortOrder: 1 },
+      { label: "Settings", href: "/settings/profile", sortOrder: 2 },
+      { label: "Admin", href: "/admin/tenants", sortOrder: 3, requiresRole: "platform_admin" },
+    ],
+    fleet: {
+      containerImage: "ghcr.io/wopr-network/nemoclaw:latest",
+      lifecycle: "managed",
+      billingModel: "monthly",
+      maxInstances: 5,
+    },
+  },
+};
+
+async function seed(): Promise<void> {
+  const dbUrl = process.env.DATABASE_URL;
+  if (!dbUrl) {
+    console.error("DATABASE_URL is required");
+    process.exit(1);
+  }
+
+  const slugArg = process.argv.find((a) => a.startsWith("--slug="))?.split("=")[1];
+  const slugs = slugArg ? [slugArg] : Object.keys(PRESETS);
+
+  const pool = new pg.Pool({ connectionString: dbUrl });
+  const db = drizzle(pool);
+
+  for (const slug of slugs) {
+    const preset = PRESETS[slug];
+    if (!preset) {
+      console.error(`Unknown product: ${slug}. Valid: ${Object.keys(PRESETS).join(", ")}`);
+      continue;
+    }
+
+    console.log(`Seeding ${slug}...`);
+    const { navItems, fleet, ...productData } = preset;
+
+    // Upsert product
+    const [product] = await db
+      .insert(products)
+      .values({ slug, ...productData })
+      .onConflictDoUpdate({
+        target: products.slug,
+        set: { ...productData, updatedAt: new Date() },
+      })
+      .returning();
+
+    if (!product) {
+      throw new Error(`Failed to upsert product: ${slug}`);
+    }
+
+    // Replace nav items
+    await db.delete(productNavItems).where(eq(productNavItems.productId, product.id));
+    if (navItems.length > 0) {
+      await db.insert(productNavItems).values(
+        navItems.map((item) => ({
+          productId: product.id,
+          label: item.label,
+          href: item.href,
+          sortOrder: item.sortOrder,
+          requiresRole: item.requiresRole ?? null,
+          enabled: true,
+        })),
+      );
+    }
+
+    // Upsert fleet config
+    await db
+      .insert(productFleetConfig)
+      .values({
+        productId: product.id,
+        containerImage: fleet.containerImage,
+        lifecycle: fleet.lifecycle,
+        billingModel: fleet.billingModel,
+        maxInstances: fleet.maxInstances,
+      })
+      .onConflictDoUpdate({
+        target: productFleetConfig.productId,
+        set: {
+          containerImage: fleet.containerImage,
+          lifecycle: fleet.lifecycle,
+          billingModel: fleet.billingModel,
+          maxInstances: fleet.maxInstances,
+          updatedAt: new Date(),
+        },
+      });
+
+    // Upsert default features (no-op if already exists)
+    await db
+      .insert(productFeatures)
+      .values({ productId: product.id })
+      .onConflictDoNothing();
+
+    console.log(`  done (${navItems.length} nav items, fleet: ${fleet.lifecycle}/${fleet.billingModel})`);
+  }
+
+  await pool.end();
+  console.log("Seed complete.");
+}
+
+seed().catch((err: unknown) => {
+  console.error("Seed failed:", err);
+  process.exit(1);
+});

package/src/billing/crypto/key-server-entry.ts

@@ -77,6 +77,7 @@ async function main(): Promise<void> {
     oracle,
     bitcoindUser: BITCOIND_USER,
     bitcoindPassword: BITCOIND_PASSWORD,
+    serviceKey: SERVICE_KEY,
     log: (msg, meta) => console.log(`[watcher] ${msg}`, meta ?? ""),
   });
 

package/src/billing/crypto/watcher-service.ts

@@ -43,6 +43,8 @@ export interface WatcherServiceOpts {
   log?: (msg: string, meta?: Record<string, unknown>) => void;
   /** Allowed callback URL prefixes. Default: ["https://"] — enforces HTTPS. */
   allowedCallbackPrefixes?: string[];
+  /** Service key sent as Bearer token in webhook deliveries. */
+  serviceKey?: string;
 }
 
 // --- SSRF validation ---
@@ -79,6 +81,7 @@ async function processDeliveries(
   db: DrizzleDb,
   allowedPrefixes: string[],
   log: (msg: string, meta?: Record<string, unknown>) => void,
+  serviceKey?: string,
 ): Promise<number> {
   const now = new Date().toISOString();
   const pending = await db
@@ -103,9 +106,11 @@ async function processDeliveries(
     }
 
     try {
+      const headers: Record<string, string> = { "Content-Type": "application/json" };
+      if (serviceKey) headers.Authorization = `Bearer ${serviceKey}`;
       const res = await fetch(row.callbackUrl, {
         method: "POST",
-        headers: { "Content-Type": "application/json" },
+        headers,
         body: row.payload,
       });
       if (!res.ok) throw new Error(`HTTP ${res.status}`);
@@ -242,6 +247,7 @@ export async function startWatchers(opts: WatcherServiceOpts): Promise<() => voi
   const deliveryMs = opts.deliveryIntervalMs ?? 10_000;
   const log = opts.log ?? (() => {});
   const allowedPrefixes = opts.allowedCallbackPrefixes ?? ["https://"];
+  const serviceKey = opts.serviceKey;
   const timers: ReturnType<typeof setInterval>[] = [];
 
   const methods = await methodStore.listEnabled();
@@ -500,7 +506,7 @@ export async function startWatchers(opts: WatcherServiceOpts): Promise<() => voi
   timers.push(
     setInterval(async () => {
       try {
-        const count = await processDeliveries(db, allowedPrefixes, log);
+        const count = await processDeliveries(db, allowedPrefixes, log, serviceKey);
         if (count > 0) log("Webhooks delivered", { count });
       } catch (err) {
         log("Delivery loop error", { error: String(err) });

package/src/db/schema/index.ts

@@ -44,6 +44,8 @@ export * from "./page-contexts.js";
 export * from "./platform-api-keys.js";
 export * from "./plugin-configs.js";
 export * from "./plugin-marketplace-content.js";
+export * from "./product-config.js";
+export * from "./products.js";
 export * from "./promotion-redemptions.js";
 export * from "./promotions.js";
 export * from "./provider-credentials.js";

package/src/db/schema/product-config.ts

@@ -0,0 +1,56 @@
+import { boolean, integer, jsonb, numeric, pgEnum, pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core";
+
+import { products } from "./products.js";
+
+export const fleetLifecycleEnum = pgEnum("fleet_lifecycle", ["managed", "ephemeral"]);
+export const fleetBillingModelEnum = pgEnum("fleet_billing_model", ["monthly", "per_use", "none"]);
+
+export const productFeatures = pgTable("product_features", {
+  productId: uuid("product_id")
+    .primaryKey()
+    .references(() => products.id, { onDelete: "cascade" }),
+  chatEnabled: boolean("chat_enabled").notNull().default(true),
+  onboardingEnabled: boolean("onboarding_enabled").notNull().default(true),
+  onboardingDefaultModel: text("onboarding_default_model"),
+  onboardingSystemPrompt: text("onboarding_system_prompt"),
+  onboardingMaxCredits: integer("onboarding_max_credits").notNull().default(100),
+  onboardingWelcomeMsg: text("onboarding_welcome_msg"),
+  sharedModuleBilling: boolean("shared_module_billing").notNull().default(true),
+  sharedModuleMonitoring: boolean("shared_module_monitoring").notNull().default(true),
+  sharedModuleAnalytics: boolean("shared_module_analytics").notNull().default(true),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+});
+
+export const productFleetConfig = pgTable("product_fleet_config", {
+  productId: uuid("product_id")
+    .primaryKey()
+    .references(() => products.id, { onDelete: "cascade" }),
+  containerImage: text("container_image").notNull(),
+  containerPort: integer("container_port").notNull().default(3100),
+  lifecycle: fleetLifecycleEnum("lifecycle").notNull().default("managed"),
+  billingModel: fleetBillingModelEnum("billing_model").notNull().default("monthly"),
+  maxInstances: integer("max_instances").notNull().default(5),
+  imageAllowlist: text("image_allowlist").array(),
+  dockerNetwork: text("docker_network").notNull().default(""),
+  placementStrategy: text("placement_strategy").notNull().default("least-loaded"),
+  fleetDataDir: text("fleet_data_dir").notNull().default("/data/fleet"),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+});
+
+export const productBillingConfig = pgTable("product_billing_config", {
+  productId: uuid("product_id")
+    .primaryKey()
+    .references(() => products.id, { onDelete: "cascade" }),
+  stripePublishableKey: text("stripe_publishable_key"),
+  /** Encrypted via credential vault (CRYPTO_SERVICE_KEY) before storage. */
+  stripeSecretKey: text("stripe_secret_key"),
+  /** Encrypted via credential vault (CRYPTO_SERVICE_KEY) before storage. */
+  stripeWebhookSecret: text("stripe_webhook_secret"),
+  creditPrices: jsonb("credit_prices").notNull().default({}),
+  affiliateBaseUrl: text("affiliate_base_url"),
+  affiliateMatchRate: numeric("affiliate_match_rate").notNull().default("1.0"),
+  affiliateMaxCap: integer("affiliate_max_cap").notNull().default(20000),
+  dividendRate: numeric("dividend_rate").notNull().default("1.0"),
+  marginConfig: jsonb("margin_config"),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+});

package/src/db/schema/products.ts

@@ -0,0 +1,58 @@
+import { boolean, index, integer, pgTable, text, timestamp, uniqueIndex, uuid } from "drizzle-orm/pg-core";
+
+export const products = pgTable(
+  "products",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    slug: text("slug").notNull(),
+    brandName: text("brand_name").notNull(),
+    productName: text("product_name").notNull(),
+    tagline: text("tagline").notNull().default(""),
+    domain: text("domain").notNull(),
+    appDomain: text("app_domain").notNull(),
+    cookieDomain: text("cookie_domain").notNull(),
+    companyLegal: text("company_legal").notNull().default(""),
+    priceLabel: text("price_label").notNull().default(""),
+    defaultImage: text("default_image").notNull().default(""),
+    emailSupport: text("email_support").notNull().default(""),
+    emailPrivacy: text("email_privacy").notNull().default(""),
+    emailLegal: text("email_legal").notNull().default(""),
+    fromEmail: text("from_email").notNull().default(""),
+    homePath: text("home_path").notNull().default("/marketplace"),
+    storagePrefix: text("storage_prefix").notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (t) => [uniqueIndex("products_slug_idx").on(t.slug)],
+);
+
+export const productNavItems = pgTable(
+  "product_nav_items",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    productId: uuid("product_id")
+      .notNull()
+      .references(() => products.id, { onDelete: "cascade" }),
+    label: text("label").notNull(),
+    href: text("href").notNull(),
+    icon: text("icon"),
+    sortOrder: integer("sort_order").notNull(),
+    requiresRole: text("requires_role"),
+    enabled: boolean("enabled").notNull().default(true),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (t) => [index("product_nav_items_product_sort_idx").on(t.productId, t.sortOrder)],
+);
+
+export const productDomains = pgTable(
+  "product_domains",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    productId: uuid("product_id")
+      .notNull()
+      .references(() => products.id, { onDelete: "cascade" }),
+    host: text("host").notNull(),
+    role: text("role").notNull().default("canonical"),
+  },
+  (t) => [uniqueIndex("product_domains_product_host_idx").on(t.productId, t.host)],
+);

package/src/product-config/boot.ts

@@ -0,0 +1,57 @@
+import type { DrizzleDb } from "../db/index.js";
+import { DrizzleProductConfigRepository } from "./drizzle-product-config-repository.js";
+import type { ProductConfig } from "./repository-types.js";
+import { deriveCorsOrigins } from "./repository-types.js";
+import { ProductConfigService } from "./service.js";
+
+export interface PlatformBootResult {
+  /** The product config service — single point of access for config reads/writes. */
+  service: ProductConfigService;
+  /** The resolved product config (cached). */
+  config: ProductConfig;
+  /** CORS origins derived from product domains + optional dev origins. */
+  corsOrigins: string[];
+}
+
+export interface PlatformBootOptions {
+  /** Product slug (e.g. "paperclip", "wopr", "holyship", "nemoclaw"). */
+  slug: string;
+  /** Drizzle database instance. */
+  db: DrizzleDb;
+  /** Additional CORS origins for local dev (from DEV_ORIGINS env var). */
+  devOrigins?: string[];
+}
+
+/**
+ * Bootstrap product configuration from DB.
+ *
+ * Call once at startup, after DB + migrations, before route registration.
+ * Returns the service (for tRPC router wiring) and the resolved config
+ * (for CORS, email, fleet, auth initialization).
+ *
+ * This replaces: BRAND_NAME, PLATFORM_DOMAIN, UI_ORIGIN, FROM_EMAIL,
+ * SUPPORT_EMAIL, COOKIE_DOMAIN, APP_BASE_URL, and all other product-
+ * specific env vars that platform-core modules previously read from
+ * process.env.
+ *
+ * Product backends still own their specific wiring (crypto watchers,
+ * fleet updaters, notification pipelines). platformBoot handles the
+ * config-driven parts that are identical across products.
+ */
+export async function platformBoot(opts: PlatformBootOptions): Promise<PlatformBootResult> {
+  const { slug, db, devOrigins = [] } = opts;
+
+  const repo = new DrizzleProductConfigRepository(db);
+  const service = new ProductConfigService(repo);
+
+  const config = await service.getBySlug(slug);
+  if (!config) {
+    throw new Error(
+      `Product "${slug}" not found in database. Run the seed script: DATABASE_URL=... npx tsx scripts/seed-products.ts`,
+    );
+  }
+
+  const corsOrigins = [...deriveCorsOrigins(config.product, config.domains), ...devOrigins];
+
+  return { service, config, corsOrigins };
+}

package/src/product-config/drizzle-product-config-repository.test.ts

@@ -0,0 +1,132 @@
+import type { PGlite } from "@electric-sql/pglite";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import type { DrizzleDb } from "../db/index.js";
+import { products } from "../db/schema/products.js";
+import { createTestDb } from "../test/db.js";
+import { DrizzleProductConfigRepository } from "./drizzle-product-config-repository.js";
+
+const PRODUCT_SEED = {
+  slug: "test-product",
+  brandName: "Test Brand",
+  productName: "Test Product",
+  domain: "test.example.com",
+  appDomain: "app.test.example.com",
+  cookieDomain: ".test.example.com",
+  storagePrefix: "test",
+};
+
+describe("DrizzleProductConfigRepository", () => {
+  let db: DrizzleDb;
+  let pool: PGlite;
+  let repo: DrizzleProductConfigRepository;
+
+  beforeAll(async () => {
+    const result = await createTestDb();
+    db = result.db as unknown as DrizzleDb;
+    pool = result.pool;
+    repo = new DrizzleProductConfigRepository(db);
+  });
+
+  afterAll(async () => {
+    await pool.close();
+  });
+
+  it("getBySlug returns null for unknown slug", async () => {
+    const result = await repo.getBySlug("no-such-slug");
+    expect(result).toBeNull();
+  });
+
+  it("getBySlug returns full config for seeded product with empty related tables", async () => {
+    await db.insert(products).values(PRODUCT_SEED);
+
+    const config = await repo.getBySlug("test-product");
+
+    expect(config).not.toBeNull();
+    expect(config?.product.slug).toBe("test-product");
+    expect(config?.product.brandName).toBe("Test Brand");
+    expect(config?.navItems).toHaveLength(0);
+    expect(config?.domains).toHaveLength(0);
+    expect(config?.features).toBeNull();
+    expect(config?.fleet).toBeNull();
+    expect(config?.billing).toBeNull();
+  });
+
+  it("replaceNavItems then getBySlug returns sorted nav items", async () => {
+    const config = await repo.getBySlug("test-product");
+    if (!config) throw new Error("product not found");
+    const productId = config.product.id;
+
+    await repo.replaceNavItems(productId, [
+      { label: "Beta", href: "/beta", sortOrder: 2 },
+      { label: "Alpha", href: "/alpha", sortOrder: 1 },
+      { label: "Gamma", href: "/gamma", sortOrder: 3, requiresRole: "admin" },
+    ]);
+
+    const updated = await repo.getBySlug("test-product");
+    expect(updated?.navItems).toHaveLength(3);
+    expect(updated?.navItems[0].label).toBe("Alpha");
+    expect(updated?.navItems[1].label).toBe("Beta");
+    expect(updated?.navItems[2].label).toBe("Gamma");
+    expect(updated?.navItems[2].requiresRole).toBe("admin");
+  });
+
+  it("upsertFeatures then getBySlug returns features", async () => {
+    const config = await repo.getBySlug("test-product");
+    if (!config) throw new Error("product not found");
+    const productId = config.product.id;
+
+    await repo.upsertFeatures(productId, {
+      chatEnabled: false,
+      onboardingEnabled: true,
+      onboardingDefaultModel: "gpt-4o",
+      onboardingMaxCredits: 50,
+    });
+
+    const updated = await repo.getBySlug("test-product");
+    expect(updated?.features).not.toBeNull();
+    expect(updated?.features?.chatEnabled).toBe(false);
+    expect(updated?.features?.onboardingDefaultModel).toBe("gpt-4o");
+    expect(updated?.features?.onboardingMaxCredits).toBe(50);
+  });
+
+  it("upsertFleetConfig with lifecycle ephemeral and billingModel none", async () => {
+    const config = await repo.getBySlug("test-product");
+    if (!config) throw new Error("product not found");
+    const productId = config.product.id;
+
+    await repo.upsertFleetConfig(productId, {
+      containerImage: "ghcr.io/example/app:latest",
+      lifecycle: "ephemeral",
+      billingModel: "none",
+      containerPort: 8080,
+      maxInstances: 10,
+    });
+
+    const updated = await repo.getBySlug("test-product");
+    expect(updated?.fleet).not.toBeNull();
+    expect(updated?.fleet?.containerImage).toBe("ghcr.io/example/app:latest");
+    expect(updated?.fleet?.lifecycle).toBe("ephemeral");
+    expect(updated?.fleet?.billingModel).toBe("none");
+    expect(updated?.fleet?.containerPort).toBe(8080);
+    expect(updated?.fleet?.maxInstances).toBe(10);
+  });
+
+  it("listAll returns all products", async () => {
+    // Insert a second product
+    await db.insert(products).values({
+      slug: "second-product",
+      brandName: "Second Brand",
+      productName: "Second Product",
+      domain: "second.example.com",
+      appDomain: "app.second.example.com",
+      cookieDomain: ".second.example.com",
+      storagePrefix: "second",
+    });
+
+    const all = await repo.listAll();
+    const slugs = all.map((c) => c.product.slug);
+    expect(slugs).toContain("test-product");
+    expect(slugs).toContain("second-product");
+    expect(all.length).toBeGreaterThanOrEqual(2);
+  });
+});