@gurulu/cli 0.4.6 → 1.0.0

package/scripts/backfill-tenant-links.ts

@@ -1,252 +0,0 @@
-#!/usr/bin/env npx tsx
-/**
- * Backfill script: scan all deterministic claims in a tenant, group by
- * (claimType, claimValue), and create TenantIdentityLink + members for
- * any claims that exist across sites.
- *
- * Usage:
- *   npx tsx scripts/backfill-tenant-links.ts <tenantId>
- *   npx tsx scripts/backfill-tenant-links.ts --all
- *
- * Safe to run multiple times — all operations are idempotent upserts.
- */
-
-import { PrismaClient } from '@prisma/client';
-import { hashClaimForTenant } from '../src/lib/identity/tenant-link';
-import { clickhouseInsert } from '../src/lib/clickhouse';
-
-const prisma = new PrismaClient();
-
-const DETERMINISTIC_TYPES = ['email', 'phone', 'oauth_id'];
-const BATCH_SIZE = 500;
-
-interface ClaimGroup {
-  claimType: string;
-  claimValue: string;
-  entries: Array<{ siteId: string; canonicalPersonId: string }>;
-}
-
-async function backfillTenantLinks(tenantId: string): Promise<{
-  linksCreated: number;
-  membersCreated: number;
-  claimsScanned: number;
-}> {
-  console.log(`[backfill] Starting tenant ${tenantId}...`);
-
-  let linksCreated = 0;
-  let membersCreated = 0;
-  let claimsScanned = 0;
-  const now = new Date();
-
-  // Fetch all deterministic claims for this tenant in batches.
-  // We join through CanonicalPerson to get tenantId filtering.
-  let cursor: string | undefined;
-  const claimMap = new Map<string, ClaimGroup>();
-
-  while (true) {
-    const claims = await prisma.identityClaim.findMany({
-      where: {
-        claimType: { in: DETERMINISTIC_TYPES },
-        retiredAt: null,
-        canonicalPerson: { tenantId },
-      },
-      select: {
-        id: true,
-        claimType: true,
-        claimValue: true,
-        siteId: true,
-        canonicalPersonId: true,
-      },
-      orderBy: { id: 'asc' },
-      take: BATCH_SIZE,
-      ...(cursor ? { skip: 1, cursor: { id: cursor } } : {}),
-    });
-
-    if (claims.length === 0) break;
-    cursor = claims[claims.length - 1].id;
-    claimsScanned += claims.length;
-
-    for (const claim of claims) {
-      const key = `${claim.claimType}:${claim.claimValue}`;
-      let group = claimMap.get(key);
-      if (!group) {
-        group = {
-          claimType: claim.claimType,
-          claimValue: claim.claimValue,
-          entries: [],
-        };
-        claimMap.set(key, group);
-      }
-      // Deduplicate by (siteId, canonicalPersonId).
-      const exists = group.entries.some(
-        (e) => e.siteId === claim.siteId && e.canonicalPersonId === claim.canonicalPersonId,
-      );
-      if (!exists) {
-        group.entries.push({
-          siteId: claim.siteId,
-          canonicalPersonId: claim.canonicalPersonId,
-        });
-      }
-    }
-
-    if (claims.length < BATCH_SIZE) break;
-  }
-
-  console.log(
-    `[backfill] Scanned ${claimsScanned} claims, found ${claimMap.size} unique deterministic claim groups`,
-  );
-
-  // Process each claim group.
-  const chRows: Array<Record<string, unknown>> = [];
-
-  for (const [, group] of claimMap) {
-    const claimValueHash = hashClaimForTenant(group.claimValue, tenantId);
-
-    // Upsert the TenantIdentityLink.
-    let link = await prisma.tenantIdentityLink.findUnique({
-      where: {
-        tenantId_claimType_claimValueHash: {
-          tenantId,
-          claimType: group.claimType,
-          claimValueHash,
-        },
-      },
-    });
-
-    if (!link) {
-      try {
-        link = await prisma.tenantIdentityLink.create({
-          data: {
-            tenantId,
-            claimType: group.claimType,
-            claimValueHash,
-            confidence: 1.0,
-            firstLinkedAt: now,
-            lastSeenAt: now,
-          },
-        });
-        linksCreated++;
-      } catch {
-        // Race with concurrent run — fetch it.
-        link = await prisma.tenantIdentityLink.findUnique({
-          where: {
-            tenantId_claimType_claimValueHash: {
-              tenantId,
-              claimType: group.claimType,
-              claimValueHash,
-            },
-          },
-        });
-        if (!link) continue;
-      }
-    } else {
-      await prisma.tenantIdentityLink.update({
-        where: { id: link.id },
-        data: { lastSeenAt: now },
-      });
-    }
-
-    // Upsert members for each (site, person) pair.
-    for (const entry of group.entries) {
-      const existing = await prisma.tenantIdentityLinkMember.findUnique({
-        where: {
-          tenantIdentityLinkId_siteId_canonicalPersonId: {
-            tenantIdentityLinkId: link.id,
-            siteId: entry.siteId,
-            canonicalPersonId: entry.canonicalPersonId,
-          },
-        },
-      });
-
-      if (!existing) {
-        try {
-          await prisma.tenantIdentityLinkMember.create({
-            data: {
-              tenantIdentityLinkId: link.id,
-              siteId: entry.siteId,
-              canonicalPersonId: entry.canonicalPersonId,
-              firstSeenAt: now,
-              lastSeenAt: now,
-            },
-          });
-          membersCreated++;
-        } catch {
-          // Race — already exists.
-        }
-      } else {
-        await prisma.tenantIdentityLinkMember.update({
-          where: { id: existing.id },
-          data: { lastSeenAt: now },
-        });
-      }
-
-      // Collect ClickHouse row.
-      chRows.push({
-        tenant_id: tenantId,
-        link_id: link.id,
-        claim_type: group.claimType,
-        claim_value_hash: claimValueHash,
-        site_id: entry.siteId,
-        canonical_person_id: entry.canonicalPersonId,
-        confidence: link.confidence,
-        first_linked_at: link.firstLinkedAt.toISOString(),
-        last_seen_at: now.toISOString(),
-        updated_at: now.toISOString(),
-      });
-    }
-  }
-
-  // Sync to ClickHouse in chunks.
-  const CH_CHUNK = 100;
-  for (let i = 0; i < chRows.length; i += CH_CHUNK) {
-    const chunk = chRows.slice(i, i + CH_CHUNK);
-    try {
-      await clickhouseInsert('tenant_identity_links', chunk);
-    } catch (err) {
-      console.warn('[backfill] ClickHouse sync chunk failed:', (err as Error).message);
-    }
-  }
-
-  console.log(
-    `[backfill] Tenant ${tenantId} done: ${linksCreated} links created, ${membersCreated} members created, ${chRows.length} CH rows synced`,
-  );
-
-  return { linksCreated, membersCreated, claimsScanned };
-}
-
-async function main() {
-  const arg = process.argv[2];
-  if (!arg) {
-    console.error('Usage: npx tsx scripts/backfill-tenant-links.ts <tenantId> | --all');
-    process.exit(1);
-  }
-
-  try {
-    if (arg === '--all') {
-      const tenants = await prisma.tenant.findMany({ select: { id: true, name: true } });
-      console.log(`[backfill] Processing ${tenants.length} tenants...`);
-      let totalLinks = 0;
-      let totalMembers = 0;
-      let totalClaims = 0;
-      for (const tenant of tenants) {
-        console.log(`\n[backfill] === Tenant: ${tenant.name} (${tenant.id}) ===`);
-        const result = await backfillTenantLinks(tenant.id);
-        totalLinks += result.linksCreated;
-        totalMembers += result.membersCreated;
-        totalClaims += result.claimsScanned;
-      }
-      console.log(
-        `\n[backfill] ALL DONE: ${totalLinks} links, ${totalMembers} members across ${totalClaims} claims`,
-      );
-    } else {
-      await backfillTenantLinks(arg);
-    }
-  } finally {
-    await prisma.$disconnect();
-  }
-}
-
-main().catch((err) => {
-  console.error('[backfill] Fatal error:', err);
-  process.exit(1);
-});

package/scripts/backup-clickhouse.sh

@@ -1,27 +0,0 @@
-#!/bin/bash
-set -e
-
-BACKUP_DIR="${BACKUP_DIR:-/backups/clickhouse}"
-RETENTION_DAYS="${RETENTION_DAYS:-7}"
-TIMESTAMP=$(date +%Y%m%d_%H%M%S)
-BACKUP_NAME="gurulu_${TIMESTAMP}"
-
-mkdir -p "$BACKUP_DIR"
-
-echo "[backup] Starting ClickHouse backup..."
-docker exec gurulu-clickhouse clickhouse-client --query "BACKUP DATABASE gurulu TO Disk('backups', '${BACKUP_NAME}')" 2>/dev/null || {
-  echo "[backup] Native backup not available, using clickhouse-client dump..."
-  TABLES=$(docker exec gurulu-clickhouse clickhouse-client --query "SHOW TABLES FROM gurulu" 2>/dev/null)
-
-  mkdir -p "${BACKUP_DIR}/${BACKUP_NAME}"
-  for table in $TABLES; do
-    echo "[backup] Dumping table: $table"
-    docker exec gurulu-clickhouse clickhouse-client --query "SELECT * FROM gurulu.${table} FORMAT Native" > "${BACKUP_DIR}/${BACKUP_NAME}/${table}.native" 2>/dev/null || true
-  done
-}
-
-echo "[backup] ClickHouse backup complete."
-
-# Cleanup
-find "$BACKUP_DIR" -maxdepth 1 -name "gurulu_*" -mtime +$RETENTION_DAYS -exec rm -rf {} +
-echo "[backup] Cleaned backups older than ${RETENTION_DAYS} days."

package/scripts/backup-postgres.sh

@@ -1,19 +0,0 @@
-#!/bin/bash
-set -e
-
-BACKUP_DIR="${BACKUP_DIR:-/backups/postgres}"
-RETENTION_DAYS="${RETENTION_DAYS:-7}"
-TIMESTAMP=$(date +%Y%m%d_%H%M%S)
-FILENAME="gurulu_${TIMESTAMP}.sql.gz"
-
-mkdir -p "$BACKUP_DIR"
-
-echo "[backup] Starting PostgreSQL backup..."
-docker exec gurulu-postgres pg_dump -U gurulu gurulu | gzip > "${BACKUP_DIR}/${FILENAME}"
-
-echo "[backup] Backup saved: ${BACKUP_DIR}/${FILENAME}"
-echo "[backup] Size: $(du -h "${BACKUP_DIR}/${FILENAME}" | cut -f1)"
-
-# Cleanup old backups
-find "$BACKUP_DIR" -name "gurulu_*.sql.gz" -mtime +$RETENTION_DAYS -delete
-echo "[backup] Cleaned backups older than ${RETENTION_DAYS} days."

package/scripts/bootstrap-runtime-schema.mjs

@@ -1,87 +0,0 @@
-import { execSync } from 'node:child_process';
-import { readdirSync, readFileSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
-
-const RETRY_COUNT = parseInt(process.env.MIGRATION_RETRY_COUNT || '5');
-const RETRY_DELAY = parseInt(process.env.MIGRATION_RETRY_DELAY_MS || '3000');
-const STRICT = process.env.BOOTSTRAP_STRICT !== 'false';
-const ENABLED = process.env.SCHEMA_BOOTSTRAP_ENABLED !== 'false';
-
-if (!ENABLED) {
-  console.log('[bootstrap] Skipped (SCHEMA_BOOTSTRAP_ENABLED=false)');
-  process.exit(0);
-}
-
-function sleep(ms) {
-  return new Promise((r) => setTimeout(r, ms));
-}
-
-function exec(cmd) {
-  console.log(`[bootstrap] $ ${cmd}`);
-  return execSync(cmd, { stdio: 'inherit' });
-}
-
-async function retry(fn, label) {
-  for (let i = 1; i <= RETRY_COUNT; i++) {
-    try {
-      await fn();
-      return;
-    } catch (err) {
-      console.error(`[bootstrap] ${label} attempt ${i}/${RETRY_COUNT} failed:`, err.message);
-      if (i === RETRY_COUNT) throw err;
-      await sleep(RETRY_DELAY);
-    }
-  }
-}
-
-async function main() {
-  console.log('[bootstrap] Starting runtime schema bootstrap...');
-
-  // Step 1/2: Prisma migrate deploy — see /scripts/bootstrap-runtime-schema.mjs
-  // for the FA-11 #3 / Sprint I-ops Faz 2 rationale.
-  if (process.env.POSTGRES_AUTO_MIGRATE !== 'false') {
-    console.log('\n[bootstrap] Step 1/2: Prisma migrate deploy');
-    await retry(async () => {
-      exec('npx prisma migrate deploy');
-    }, 'migrate deploy');
-  }
-
-  // Step 2/2: SQL hooks
-  if (process.env.POSTGRES_AUTO_MIGRATE !== 'false') {
-    console.log('\n[bootstrap] Step 2/2: SQL hooks');
-    const hooksDir = join(process.cwd(), 'prisma', 'sql-hooks');
-
-    if (existsSync(hooksDir)) {
-      const files = readdirSync(hooksDir)
-        .filter((f) => f.endsWith('.sql'))
-        .sort();
-
-      for (const file of files) {
-        console.log(`[bootstrap] Executing hook: ${file}`);
-        const filePath = join(hooksDir, file);
-        exec(`npx prisma db execute --file "${filePath}"`);
-      }
-      console.log(`[bootstrap] ${files.length} SQL hook(s) executed.`);
-    } else {
-      console.log('[bootstrap] No sql-hooks directory found, skipping.');
-    }
-  }
-  // Step 3/3 (db push drift catch) removed — drift is now a hard fail.
-
-  // ClickHouse migration
-  if (process.env.CLICKHOUSE_AUTO_MIGRATE !== 'false') {
-    console.log('\n[bootstrap] ClickHouse migration');
-    const nodeIds = (process.env.CLICKHOUSE_MIGRATION_NODE_IDS || 'tr-01').split(',');
-    console.log(`[bootstrap] Node IDs: ${nodeIds.join(', ')}`);
-    // ClickHouse migrations are handled by init script in Docker
-    console.log('[bootstrap] ClickHouse init handled by Docker entrypoint.');
-  }
-
-  console.log('\n[bootstrap] ✓ Schema bootstrap complete.');
-}
-
-main().catch((err) => {
-  console.error('[bootstrap] Fatal error:', err);
-  if (STRICT) process.exit(1);
-  else console.warn('[bootstrap] BOOTSTRAP_STRICT=false, continuing despite error.');
-});

package/scripts/bootstrap-stripe.mjs

@@ -1,158 +0,0 @@
-import Stripe from 'stripe';
-import { readFileSync, writeFileSync, existsSync } from 'node:fs';
-
-const STRIPE_KEY = process.env.STRIPE_SECRET_KEY;
-if (!STRIPE_KEY) {
-  console.error('[stripe] STRIPE_SECRET_KEY not set. Skipping bootstrap.');
-  process.exit(1);
-}
-
-if (STRIPE_KEY.startsWith('sk_live_')) {
-  console.warn(
-    '[stripe] WARNING: Using a LIVE Stripe key. Products and prices will be created in production.'
-  );
-  const rl = await import('node:readline');
-  const iface = rl.createInterface({ input: process.stdin, output: process.stdout });
-  const answer = await new Promise((resolve) =>
-    iface.question('[stripe] Continue? (yes/no): ', resolve)
-  );
-  iface.close();
-  if (answer.trim().toLowerCase() !== 'yes') {
-    console.log('[stripe] Aborted.');
-    process.exit(0);
-  }
-}
-
-const stripe = new Stripe(STRIPE_KEY, {
-  apiVersion: '2026-03-25.dahlia',
-});
-
-const PRODUCTS = [
-  {
-    name: 'Gurulu Starter',
-    key: 'STARTER',
-    monthlyPrice: 2900, // cents
-    annualPrice: 27840, // 29 * 12 * 0.8 = $278.40 → $278
-    events: 5_000_000,
-  },
-  {
-    name: 'Gurulu Growth',
-    key: 'GROWTH',
-    monthlyPrice: 9900,
-    annualPrice: 95040, // 99 * 12 * 0.8 = $950.40 → $950
-    events: 25_000_000,
-  },
-  {
-    name: 'Gurulu Business',
-    key: 'BUSINESS',
-    monthlyPrice: 29900,
-    annualPrice: 287040, // 299 * 12 * 0.8 = $2870.40 → $2870
-    events: 100_000_000,
-  },
-];
-
-async function main() {
-  console.log('[stripe] Starting Stripe bootstrap...\n');
-
-  const envUpdates = {};
-
-  for (const product of PRODUCTS) {
-    console.log(`[stripe] Creating product: ${product.name}`);
-
-    // Check if product already exists by listing and filtering on metadata
-    const allProducts = await stripe.products.list({ limit: 100, active: true });
-    const matchingProduct = allProducts.data.find(
-      (p) => p.metadata?.gurulu_key === product.key
-    );
-
-    let stripeProduct;
-    if (matchingProduct) {
-      stripeProduct = matchingProduct;
-      console.log(`  → Found existing product: ${stripeProduct.id}`);
-    } else {
-      stripeProduct = await stripe.products.create({
-        name: product.name,
-        metadata: {
-          gurulu_key: product.key,
-          events: String(product.events),
-        },
-      });
-      console.log(`  → Created product: ${stripeProduct.id}`);
-    }
-
-    // Fetch all existing prices for this product
-    const existingPrices = await stripe.prices.list({
-      product: stripeProduct.id,
-      type: 'recurring',
-      active: true,
-      limit: 100,
-    });
-
-    // Monthly price
-    let monthlyPrice = existingPrices.data.find(
-      (p) => p.recurring?.interval === 'month' && p.unit_amount === product.monthlyPrice
-    );
-
-    if (!monthlyPrice) {
-      monthlyPrice = await stripe.prices.create({
-        product: stripeProduct.id,
-        unit_amount: product.monthlyPrice,
-        currency: 'usd',
-        recurring: { interval: 'month' },
-        metadata: { gurulu_key: product.key, interval: 'monthly' },
-      });
-      console.log(`  → Created monthly price: ${monthlyPrice.id} ($${product.monthlyPrice / 100}/mo)`);
-    } else {
-      console.log(`  → Found monthly price: ${monthlyPrice.id}`);
-    }
-
-    // Annual price
-    let annualPrice = existingPrices.data.find(
-      (p) => p.recurring?.interval === 'year' && p.unit_amount === product.annualPrice
-    );
-
-    if (!annualPrice) {
-      annualPrice = await stripe.prices.create({
-        product: stripeProduct.id,
-        unit_amount: product.annualPrice,
-        currency: 'usd',
-        recurring: { interval: 'year' },
-        metadata: { gurulu_key: product.key, interval: 'annual' },
-      });
-      console.log(`  → Created annual price: ${annualPrice.id} ($${product.annualPrice / 100}/yr)`);
-    } else {
-      console.log(`  → Found annual price: ${annualPrice.id}`);
-    }
-
-    envUpdates[`STRIPE_${product.key}_MONTHLY_PRICE_ID`] = monthlyPrice.id;
-    envUpdates[`STRIPE_${product.key}_ANNUAL_PRICE_ID`] = annualPrice.id;
-  }
-
-  // Update .env file
-  const envPath = '.env';
-  let envContent = '';
-  if (existsSync(envPath)) {
-    envContent = readFileSync(envPath, 'utf-8');
-  }
-
-  for (const [key, value] of Object.entries(envUpdates)) {
-    const regex = new RegExp(`^${key}=.*$`, 'm');
-    if (regex.test(envContent)) {
-      envContent = envContent.replace(regex, `${key}=${value}`);
-    } else {
-      envContent += `\n${key}=${value}`;
-    }
-  }
-
-  writeFileSync(envPath, envContent.trimEnd() + '\n');
-
-  console.log('\n[stripe] ✓ Bootstrap complete. Price IDs written to .env:');
-  for (const [key, value] of Object.entries(envUpdates)) {
-    console.log(`  ${key}=${value}`);
-  }
-}
-
-main().catch((err) => {
-  console.error('[stripe] Bootstrap failed:', err.message);
-  process.exit(1);
-});