content-grade 1.0.0

package/dist-server/server/routes/stripe.js

@@ -0,0 +1,136 @@
+import { getStripe, isStripeConfigured, isAudienceDecoderConfigured, hasActiveSubscription, hasPurchased, getCustomerStripeId, upsertCustomer, saveSubscription, updateSubscriptionStatus, updateSubscriptionPeriod, saveOneTimePurchase, } from '../services/stripe.js';
+export function registerStripeRoutes(app) {
+    app.post('/api/stripe/create-checkout-session', async (req, reply) => {
+        const body = req.body;
+        const email = (body?.email ?? '').trim().toLowerCase();
+        if (!email || !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
+            reply.status(400);
+            return { error: 'Valid email required.' };
+        }
+        const priceType = body?.priceType ?? 'contentgrade_pro';
+        const stripe = getStripe();
+        if (!stripe) {
+            reply.status(503);
+            return { error: 'Stripe not configured' };
+        }
+        let priceId;
+        let mode;
+        if (priceType === 'contentgrade_pro') {
+            priceId = process.env.STRIPE_PRICE_CONTENTGRADE_PRO;
+            mode = 'subscription';
+        }
+        else {
+            priceId = process.env.STRIPE_PRICE_AUDIENCEDECODER;
+            mode = 'payment';
+        }
+        if (!priceId) {
+            reply.status(503);
+            return { error: 'Stripe not configured — price ID missing' };
+        }
+        try {
+            let stripeCustomerId = getCustomerStripeId(email);
+            if (!stripeCustomerId) {
+                const stripeCustomer = await stripe.customers.create({ email });
+                stripeCustomerId = stripeCustomer.id;
+                upsertCustomer(email, stripeCustomerId);
+            }
+            const publicUrl = process.env.PUBLIC_URL || 'http://localhost:4000';
+            const session = await stripe.checkout.sessions.create({
+                mode,
+                customer: stripeCustomerId,
+                client_reference_id: email,
+                line_items: [{ price: priceId, quantity: 1 }],
+                success_url: body?.successUrl ?? `${publicUrl}?checkout=success`,
+                cancel_url: body?.cancelUrl ?? `${publicUrl}?checkout=cancel`,
+            });
+            return { url: session.url };
+        }
+        catch (err) {
+            reply.status(500);
+            return { error: `Checkout failed: ${err.message}` };
+        }
+    });
+    app.post('/api/stripe/webhook', async (req, reply) => {
+        const stripe = getStripe();
+        if (!stripe) {
+            reply.status(503);
+            return { error: 'Stripe not configured' };
+        }
+        const webhookSecret = process.env.STRIPE_WEBHOOK_SECRET;
+        const rawBody = req.rawBody;
+        const sig = req.headers['stripe-signature'];
+        let event;
+        try {
+            if (webhookSecret && rawBody && sig) {
+                event = stripe.webhooks.constructEvent(rawBody, sig, webhookSecret);
+            }
+            else {
+                if (!webhookSecret)
+                    console.warn('[Stripe] STRIPE_WEBHOOK_SECRET not set — skipping signature verification (dev mode)');
+                event = req.body;
+            }
+        }
+        catch (err) {
+            reply.status(400);
+            return { error: `Webhook signature failed: ${err.message}` };
+        }
+        try {
+            const data = event.data?.object;
+            if (event.type === 'checkout.session.completed') {
+                const email = (data.client_reference_id ?? data.customer_email ?? '').toLowerCase();
+                const stripeCustomerId = data.customer;
+                if (email && stripeCustomerId) {
+                    upsertCustomer(email, stripeCustomerId);
+                }
+                if (data.mode === 'subscription' && email && stripeCustomerId) {
+                    saveSubscription({
+                        email,
+                        stripe_customer_id: stripeCustomerId,
+                        stripe_subscription_id: data.subscription,
+                        plan_tier: 'pro',
+                        status: 'active',
+                        current_period_end: 0,
+                    });
+                }
+                else if (data.mode === 'payment' && email && stripeCustomerId) {
+                    saveOneTimePurchase({
+                        email,
+                        stripe_customer_id: stripeCustomerId,
+                        stripe_payment_intent_id: data.payment_intent,
+                        product_key: 'audiencedecoder_report',
+                    });
+                }
+            }
+            else if (event.type === 'customer.subscription.updated') {
+                updateSubscriptionPeriod(data.id, data.status, data.current_period_end);
+            }
+            else if (event.type === 'customer.subscription.deleted') {
+                updateSubscriptionStatus(data.id, 'canceled');
+            }
+            else if (event.type === 'invoice.payment_failed') {
+                if (data.subscription) {
+                    updateSubscriptionStatus(data.subscription, 'past_due');
+                }
+            }
+        }
+        catch (err) {
+            console.error('[stripe_webhook]', err);
+        }
+        return { received: true };
+    });
+    app.get('/api/stripe/subscription-status', async (req, reply) => {
+        const query = req.query;
+        const email = (query.email ?? '').trim().toLowerCase();
+        if (!email) {
+            reply.status(400);
+            return { error: 'email required' };
+        }
+        return {
+            active: hasActiveSubscription(email),
+            audiencedecoder: hasPurchased(email, 'audiencedecoder_report'),
+            plan: hasActiveSubscription(email) ? 'contentgrade_pro' : null,
+            configured: isStripeConfigured(),
+            audienceDecoderConfigured: isAudienceDecoderConfigured(),
+        };
+    });
+}

package/dist-server/server/services/claude.js

@@ -0,0 +1,55 @@
+import { spawn } from 'child_process';
+const CLAUDE_PATH = process.env.CLAUDE_PATH || 'claude';
+const DEFAULT_TIMEOUT_MS = 120_000;
+/**
+ * askClaude — runs a Claude CLI session for demo endpoints.
+ * Uses `claude -p --no-session-persistence --dangerously-skip-permissions`
+ * The prompt is written to stdin; system prompt via --append-system-prompt.
+ */
+export async function askClaude(prompt, opts) {
+    const model = opts?.model ?? 'haiku';
+    const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const args = ['-p', '--no-session-persistence', '--dangerously-skip-permissions'];
+    if (opts?.systemPrompt) {
+        args.push('--append-system-prompt', opts.systemPrompt);
+    }
+    args.push('--model', model);
+    return new Promise((resolve, reject) => {
+        const proc = spawn(CLAUDE_PATH, args, {
+            env: {
+                HOME: process.env.HOME,
+                PATH: process.env.PATH,
+                USER: process.env.USER,
+                SHELL: process.env.SHELL,
+                TERM: process.env.TERM,
+                LANG: process.env.LANG,
+                XDG_CONFIG_HOME: process.env.XDG_CONFIG_HOME,
+                XDG_DATA_HOME: process.env.XDG_DATA_HOME,
+                XDG_CACHE_HOME: process.env.XDG_CACHE_HOME,
+            },
+        });
+        let stdout = '';
+        let stderr = '';
+        proc.stdout.on('data', (chunk) => { stdout += chunk.toString(); });
+        proc.stderr.on('data', (chunk) => { stderr += chunk.toString(); });
+        const timer = setTimeout(() => {
+            proc.kill('SIGTERM');
+            reject(new Error(`Claude session timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        proc.on('close', (code) => {
+            clearTimeout(timer);
+            if (code !== 0) {
+                reject(new Error(`Claude exited with code ${code}: ${stderr.slice(0, 500)}`));
+            }
+            else {
+                resolve(stdout.trim());
+            }
+        });
+        proc.on('error', (err) => {
+            clearTimeout(timer);
+            reject(new Error(`Failed to spawn claude: ${err.message}. Is 'claude' CLI installed and authenticated?`));
+        });
+        proc.stdin.write(prompt);
+        proc.stdin.end();
+    });
+}

package/dist-server/server/services/stripe.js

@@ -0,0 +1,109 @@
+import Stripe from 'stripe';
+import { getDb } from '../db.js';
+const stripeKey = process.env.STRIPE_SECRET_KEY;
+let _stripe = null;
+export function getStripe() {
+    if (!_stripe && stripeKey) {
+        _stripe = new Stripe(stripeKey, { apiVersion: '2024-12-18.acacia' });
+    }
+    return _stripe;
+}
+export function isStripeConfigured() {
+    return !!stripeKey && !!process.env.STRIPE_PRICE_CONTENTGRADE_PRO;
+}
+export function isAudienceDecoderConfigured() {
+    return !!stripeKey && !!process.env.STRIPE_PRICE_AUDIENCEDECODER;
+}
+// ── Customer management ──────────────────────────────────────────────────────
+export function upsertCustomer(email, stripeCustomerId) {
+    getDb().prepare(`
+    INSERT INTO stripe_customers (email, stripe_customer_id)
+    VALUES (?, ?)
+    ON CONFLICT(email) DO UPDATE SET stripe_customer_id = excluded.stripe_customer_id
+  `).run(email, stripeCustomerId);
+}
+export function getCustomerStripeId(email) {
+    const row = getDb().prepare('SELECT stripe_customer_id FROM stripe_customers WHERE email = ?').get(email);
+    return row?.stripe_customer_id ?? null;
+}
+// ── Subscriptions ────────────────────────────────────────────────────────────
+export function saveSubscription(params) {
+    getDb().prepare(`
+    INSERT INTO stripe_subscriptions
+      (email, stripe_customer_id, stripe_subscription_id, plan_tier, status, current_period_end)
+    VALUES (?, ?, ?, ?, ?, ?)
+    ON CONFLICT(stripe_subscription_id) DO UPDATE SET
+      status = excluded.status,
+      current_period_end = excluded.current_period_end,
+      updated_at = datetime('now')
+  `).run(params.email, params.stripe_customer_id, params.stripe_subscription_id, params.plan_tier, params.status, params.current_period_end);
+}
+export function updateSubscriptionStatus(stripeSubId, status) {
+    getDb().prepare("UPDATE stripe_subscriptions SET status = ?, updated_at = datetime('now') WHERE stripe_subscription_id = ?").run(status, stripeSubId);
+}
+export function updateSubscriptionPeriod(stripeSubId, status, currentPeriodEnd) {
+    getDb().prepare("UPDATE stripe_subscriptions SET status = ?, current_period_end = ?, updated_at = datetime('now') WHERE stripe_subscription_id = ?").run(status, currentPeriodEnd, stripeSubId);
+}
+export function hasActiveSubscription(email) {
+    const row = getDb().prepare(`
+    SELECT status FROM stripe_subscriptions
+    WHERE email = ? AND status = 'active'
+    ORDER BY created_at DESC LIMIT 1
+  `).get(email);
+    return row?.status === 'active';
+}
+// ── One-time purchases ───────────────────────────────────────────────────────
+export function saveOneTimePurchase(params) {
+    getDb().prepare(`
+    INSERT OR IGNORE INTO stripe_one_time_purchases
+      (email, stripe_customer_id, stripe_payment_intent_id, product_key)
+    VALUES (?, ?, ?, ?)
+  `).run(params.email, params.stripe_customer_id, params.stripe_payment_intent_id, params.product_key);
+}
+export function hasPurchased(email, productKey) {
+    const row = getDb().prepare(`
+    SELECT id FROM stripe_one_time_purchases
+    WHERE email = ? AND product_key = ?
+    LIMIT 1
+  `).get(email, productKey);
+    return !!row;
+}
+// ── Live subscription verification ───────────────────────────────────────────
+// Checks Stripe API directly on each request. 5-minute in-memory cache per email
+// prevents hammering the Stripe API. Falls back to DB if Stripe is unreachable.
+const _subCache = new Map();
+const SUB_CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+const SUB_CACHE_ERROR_TTL_MS = 60 * 1000; // 1 minute on error
+export async function hasActiveSubscriptionLive(email) {
+    const cached = _subCache.get(email);
+    if (cached && cached.expiresAt > Date.now()) {
+        return cached.isPro;
+    }
+    const stripe = getStripe();
+    if (!stripe) {
+        // Stripe not configured — fall back to DB without caching
+        return hasActiveSubscription(email);
+    }
+    const customerId = getCustomerStripeId(email);
+    if (!customerId) {
+        const result = hasActiveSubscription(email);
+        _subCache.set(email, { isPro: result, expiresAt: Date.now() + SUB_CACHE_TTL_MS });
+        return result;
+    }
+    try {
+        const subscriptions = await stripe.subscriptions.list({
+            customer: customerId,
+            status: 'active',
+            limit: 1,
+        });
+        const isPro = subscriptions.data.length > 0;
+        _subCache.set(email, { isPro, expiresAt: Date.now() + SUB_CACHE_TTL_MS });
+        return isPro;
+    }
+    catch (err) {
+        console.error('[stripe] Live subscription check failed, falling back to DB:', err);
+        const result = hasActiveSubscription(email);
+        _subCache.set(email, { isPro: result, expiresAt: Date.now() + SUB_CACHE_ERROR_TTL_MS });
+        return result;
+    }
+}

package/package.json

@@ -0,0 +1,84 @@
+{
+  "name": "content-grade",
+  "version": "1.0.0",
+  "description": "AI-powered content analysis CLI. Score any blog post, landing page, or ad copy in under 30 seconds — runs on Claude CLI, no API key needed.",
+  "type": "module",
+  "bin": {
+    "content-grade": "bin/content-grade.js"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "dist-server/server",
+    "README.md",
+    "CONTRIBUTING.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "content",
+    "copywriting",
+    "marketing",
+    "content-analysis",
+    "claude",
+    "ai",
+    "seo",
+    "headline",
+    "landing-page",
+    "cli"
+  ],
+  "homepage": "https://github.com/StanislavBG/Content-Grade#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/StanislavBG/Content-Grade.git"
+  },
+  "bugs": {
+    "url": "https://github.com/StanislavBG/Content-Grade/issues"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "prepublishOnly": "npm run build",
+    "dev": "concurrently \"pnpm dev:server\" \"pnpm dev:client\"",
+    "dev:client": "vite",
+    "dev:server": "tsx watch server/index.ts",
+    "build": "vite build && tsc -p tsconfig.server.json",
+    "start": "node dist-server/server/index.js",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "stats": "node scripts/npm-stats.js",
+    "stats:week": "node scripts/npm-stats.js --week"
+  },
+  "dependencies": {
+    "@fastify/cors": "^9.0.1",
+    "@fastify/static": "^7.0.4",
+    "better-sqlite3": "^9.4.3",
+    "fastify": "^4.28.1",
+    "stripe": "^14.21.0"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "better-sqlite3",
+      "esbuild"
+    ]
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.8",
+    "@types/node": "^22.0.0",
+    "@types/react": "^18.3.0",
+    "@types/react-dom": "^18.3.0",
+    "@vitejs/plugin-react": "^4.3.0",
+    "@vitest/coverage-v8": "^2.1.0",
+    "concurrently": "^8.2.2",
+    "react": "^18.3.0",
+    "react-dom": "^18.3.0",
+    "react-router-dom": "^6.23.0",
+    "tsx": "^4.16.0",
+    "typescript": "^5.5.0",
+    "vite": "^5.4.0",
+    "vitest": "^2.1.0"
+  }
+}