neoagent 3.0.1-beta.7 → 3.0.1-beta.8

package/server/routes/billing.js

@@ -0,0 +1,122 @@
+'use strict';
+
+const express = require('express');
+const router = express.Router();
+const db = require('../db/database');
+const { requireAuth } = require('../middleware/auth');
+const { requireBilling } = require('../middleware/requireBilling');
+const { getStripeConfig } = require('../services/billing/config');
+const { listPlans } = require('../services/billing/plans');
+const subs = require('../services/billing/subscriptions');
+const { getStripeClient } = require('../services/billing/stripe_client');
+
+function isValidHttpsUrl(value) {
+  try {
+    const u = new URL(value);
+    return u.protocol === 'https:' || u.protocol === 'http:';
+  } catch {
+    return false;
+  }
+}
+
+router.use(requireBilling);
+
+// Public — pricing page needs this without login.
+router.get('/plans', (req, res) => {
+  try {
+    res.json({ plans: listPlans() });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// All remaining routes require authentication.
+router.use(requireAuth);
+
+router.get('/', (req, res) => {
+  try {
+    const userId = req.session.userId;
+    const subscription = subs.getActiveSubscription(userId);
+    const { publicKey } = getStripeConfig();
+    res.json({ subscription, stripePublishableKey: publicKey || null });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+router.post('/checkout', async (req, res) => {
+  try {
+    const { planId, successUrl, cancelUrl } = req.body;
+    if (!planId || !successUrl || !cancelUrl) {
+      return res.status(400).json({ error: 'planId, successUrl and cancelUrl are required.' });
+    }
+    if (!isValidHttpsUrl(successUrl) || !isValidHttpsUrl(cancelUrl)) {
+      return res.status(400).json({ error: 'successUrl and cancelUrl must be valid URLs.' });
+    }
+    const url = await subs.createCheckoutSession(req.session.userId, planId, successUrl, cancelUrl);
+    res.json({ url });
+  } catch (err) {
+    res.status(err.statusCode || 500).json({ error: err.message });
+  }
+});
+
+router.post('/portal', async (req, res) => {
+  try {
+    const { returnUrl } = req.body;
+    if (!returnUrl) return res.status(400).json({ error: 'returnUrl is required.' });
+    if (!isValidHttpsUrl(returnUrl)) {
+      return res.status(400).json({ error: 'returnUrl must be a valid URL.' });
+    }
+    const url = await subs.createCustomerPortalSession(req.session.userId, returnUrl);
+    res.json({ url });
+  } catch (err) {
+    res.status(err.statusCode || 500).json({ error: err.message });
+  }
+});
+
+router.post('/trial', async (req, res) => {
+  try {
+    const { planId, deviceFingerprint } = req.body;
+    if (!planId) return res.status(400).json({ error: 'planId is required.' });
+    const ip = req.ip || req.socket?.remoteAddress;
+    const result = await subs.startTrial(req.session.userId, planId, { ip, deviceFp: deviceFingerprint });
+    res.json({ subscription: result.subscription });
+  } catch (err) {
+    res.status(err.statusCode || 500).json({ error: err.message });
+  }
+});
+
+router.post('/cancel', async (req, res) => {
+  try {
+    await subs.cancelSubscription(req.session.userId);
+    res.json({ ok: true });
+  } catch (err) {
+    res.status(err.statusCode || 500).json({ error: err.message });
+  }
+});
+
+router.get('/invoices', async (req, res) => {
+  try {
+    const stripe = getStripeClient();
+    const userId = req.session.userId;
+    const customer = db
+      .prepare('SELECT stripe_customer_id FROM billing_customers WHERE user_id = ?')
+      .get(userId);
+    if (!customer?.stripe_customer_id) return res.json({ invoices: [] });
+    const list = await stripe.invoices.list({ customer: customer.stripe_customer_id, limit: 12 });
+    const invoices = list.data.map((inv) => ({
+      id: inv.id,
+      amount_paid: inv.amount_paid,
+      currency: inv.currency,
+      status: inv.status,
+      created: inv.created,
+      hosted_invoice_url: inv.hosted_invoice_url,
+      invoice_pdf: inv.invoice_pdf,
+    }));
+    res.json({ invoices });
+  } catch (err) {
+    res.status(err.statusCode || 500).json({ error: err.message });
+  }
+});
+
+module.exports = router;

package/server/routes/billing_webhook.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const express = require('express');
+const router = express.Router();
+const { isBillingEnabled, getStripeConfig } = require('../services/billing/config');
+const { getStripeClient } = require('../services/billing/stripe_client');
+const { handleWebhookEvent } = require('../services/billing/subscriptions');
+
+// Raw body required for Stripe signature verification — applied inline.
+router.post('/', express.raw({ type: 'application/json' }), async (req, res) => {
+  if (!isBillingEnabled()) return res.status(404).json({ error: 'Billing is not enabled.' });
+
+  const sig = req.headers['stripe-signature'];
+  if (!sig) {
+    return res.status(400).json({ error: 'Missing stripe-signature header.' });
+  }
+
+  const { webhookSecret } = getStripeConfig();
+  if (!webhookSecret) {
+    console.warn('[billing] STRIPE_WEBHOOK_SECRET is not set; rejecting webhook.');
+    return res.status(500).json({ error: 'Webhook secret not configured.' });
+  }
+
+  let event;
+  try {
+    const stripe = getStripeClient();
+    event = stripe.webhooks.constructEvent(req.body, sig, webhookSecret);
+  } catch (err) {
+    console.warn('[billing] Webhook signature verification failed:', err.message);
+    return res.status(400).json({ error: `Webhook error: ${err.message}` });
+  }
+
+  try {
+    await handleWebhookEvent(event);
+  } catch (err) {
+    console.error('[billing] Webhook handler error:', err);
+    // Still return 200 so Stripe does not retry immediately for handler bugs.
+  }
+
+  res.json({ received: true });
+});
+
+module.exports = router;

package/server/routes/memory.js

@@ -1,6 +1,7 @@
 const express = require('express');
 const router = express.Router();
 const rateLimit = require('express-rate-limit');
+const db = require('../db/database');
 const { requireAuth } = require('../middleware/auth');
 const { sanitizeError } = require('../utils/security');
 const { getAgentIdFromRequest, resolveAgentId } = require('../services/agents/manager');
@@ -317,7 +318,6 @@ router.post('/memories', async (req, res) => {
 // Update a memory
 router.put('/memories/:id', async (req, res) => {
   const mm = req.app.locals.memoryManager;
-  const db = require('../db/database');
   // Verify ownership before updating
   const agentId = resolveAgentId(req.session.userId, getAgentIdFromRequest(req));
   const existing = db.prepare('SELECT id FROM memories WHERE id = ? AND user_id = ? AND agent_id = ?').get(req.params.id, req.session.userId, agentId);
@@ -335,7 +335,6 @@ router.put('/memories/:id', async (req, res) => {
 // Delete a memory
 router.delete('/memories/:id', (req, res) => {
   const mm = req.app.locals.memoryManager;
-  const db = require('../db/database');
   // Verify ownership before deleting
   const agentId = resolveAgentId(req.session.userId, getAgentIdFromRequest(req));
   const existing = db.prepare('SELECT id FROM memories WHERE id = ? AND user_id = ? AND agent_id = ?').get(req.params.id, req.session.userId, agentId);
@@ -346,7 +345,6 @@ router.delete('/memories/:id', (req, res) => {
 
 router.post('/memories/bulk-delete', (req, res) => {
   const mm = req.app.locals.memoryManager;
-  const db = require('../db/database');
   const ids = normalizeMemoryIds(req.body?.ids);
   if (!ids.length) {
     return res.status(400).json({ error: 'ids is required' });
@@ -366,7 +364,6 @@ router.post('/memories/bulk-delete', (req, res) => {
 
 router.post('/memories/bulk-archive', (req, res) => {
   const mm = req.app.locals.memoryManager;
-  const db = require('../db/database');
   const ids = normalizeMemoryIds(req.body?.ids);
   const archived = req.body?.archived !== false;
   if (!ids.length) {

package/server/routes/settings.js

@@ -34,6 +34,7 @@ const {
 } = require('../services/runtime/settings');
 const { isManagedDeployment } = require('../utils/deployment');
 const { getAgentIdFromRequest, isMainAgent, resolveAgentId } = require('../services/agents/manager');
+const { getProviderHealthCatalog, getSupportedModels } = require('../services/ai/models');
 
 const AGENT_SETTING_KEYS = new Set([
   'cost_mode',
@@ -193,14 +194,12 @@ async function resetEnvBackedSettingValue(req, key) {
 
 // Get supported models metadata
 router.get('/meta/models', async (req, res) => {
-  const { getSupportedModels } = require('../services/ai/models');
   const agentId = resolveAgentId(req.session.userId, getAgentIdFromRequest(req));
   const models = await getSupportedModels(req.session.userId, agentId);
   res.json({ models });
 });
 
 router.get('/meta/ai-providers', async (req, res) => {
-  const { getProviderHealthCatalog, getSupportedModels } = require('../services/ai/models');
   const agentId = resolveAgentId(req.session.userId, getAgentIdFromRequest(req));
   const [providers, models] = await Promise.all([
     getProviderHealthCatalog(req.session.userId, agentId),

package/server/routes/skills.js

@@ -1,3 +1,4 @@
+const fs = require('fs');
 const express = require('express');
 const router = express.Router();
 const { requireAuth } = require('../middleware/auth');
@@ -109,7 +110,6 @@ router.get('/:name', async (req, res) => {
     const runner = await getSkillRunner(req.app);
     const skill = runner.getSkill(req.params.name, req.session.userId);
     if (!skill) return res.status(404).json({ error: 'Skill not found' });
-    const fs = require('fs');
     const content = fs.readFileSync(skill.filePath, 'utf-8');
     res.json({
       name: skill.name,

package/server/services/ai/loop/agent_engine_core.js

@@ -842,7 +842,7 @@ class AgentEngine {
         iteration,
       }),
       maxTokens: 200,
-      normalize: (raw) => normalizeChurnAssessment(raw),
+      normalize: normalizeChurnAssessment,
       fallback: { assessment: 'churn', reason: 'churn assessment unavailable' },
       reasoningEffort: this.getReasoningEffort(providerName, options),
       telemetry: options,

package/server/services/ai/loop/completion_judge.js

@@ -241,15 +241,8 @@ function normalizeCompletionDecision(raw, fallbackStatus = 'continue') {
   };
 }
 
-/**
- * Ask the model to self-assess whether it is making genuine progress or
- * spinning in analysis-paralysis. This replaces the hardcoded nudge threshold
- * with an AI-controlled signal: the model knows its own plan better than any
- * regex over tool names can infer.
- *
- * Intentionally lightweight — the response is capped at 200 tokens and the
- * prompt is self-contained so the model can answer without re-reading history.
- */
+// Intentionally lightweight (200-token cap, self-contained) so the model can
+// answer cold without re-reading full conversation history.
 function buildChurnAssessmentPrompt({
   readOnlyCount,
   alreadyRead,

package/server/services/ai/loop/conversation_loop.js

@@ -295,6 +295,13 @@ function buildNoProgressWrapupPrompt({ readOnlyCount = 0, alreadyRead = '', plat
   ].filter(Boolean).join('\n\n');
 }
 
+function isDeliveryTerminated(runMeta, deliveryState) {
+  return runMeta?.noResponse === true
+    || deliveryState?.noResponse === true
+    || runMeta?.finalDeliverySent === true
+    || deliveryState?.finalDeliverySent === true;
+}
+
 function cloneInterimHistory(history = []) {
   if (!Array.isArray(history)) return [];
   return history.map((item) => ({
@@ -1181,28 +1188,17 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
       messages = steeringAtLoopStart.messages;
       messages = sanitizeConversationMessages(messages);
 
-      // Analysis-paralysis gate (EVE-style: AI self-assessment instead of
-      // hardcoded counters). The nudge threshold is derived from the goal
-      // contract complexity/autonomy_level that the model set during task
-      // analysis, making the loop budget sensitivity AI-controlled.
-      //
-      // Flow:
-      //   readOnlyCount >= maxConsecutiveReadOnlyIterations → hard safety net,
-      //     force wrap-up unconditionally (same as before).
-      //   readOnlyCount >= churnNudgeThreshold → ask the model to self-assess:
-      //     "progressing" → give grace (partial counter reset, loop continues).
-      //     "churn"       → inject the nudge so the model can course-correct.
-      //     "blocked"     → trigger the force wrap-up early (AI-authorised).
+      // Analysis-paralysis gate: AI self-assesses at churnNudgeThreshold; hard
+      // force-wrap-up fires at maxConsecutiveReadOnlyIterations unconditionally.
       if (analysis.mode === 'execute' || analysis.mode === 'plan_execute') {
         const readOnlyCount = engine.getRunMeta(runId)?.consecutiveReadOnlyIterations || 0;
 
-        if (readOnlyCount > 0) {
+        if (readOnlyCount >= 2) {
           const runGoalCtx = resolveRunGoalContext(engine.getRunMeta(runId), analysis, plan);
           const churnNudgeThreshold = resolveChurnNudgeThreshold(runGoalCtx.goalContract);
 
           let triggerForceWrapup = false;
           let forceWrapupSource = 'hard_limit';
-          // Compute alreadyRead lazily — only needed at or above the nudge threshold.
           let alreadyRead = '';
 
           if (readOnlyCount >= loopPolicy.maxConsecutiveReadOnlyIterations) {
@@ -2055,12 +2051,7 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
         if (runMeta?.terminalInterim) {
           break;
         }
-        if (
-          runMeta?.noResponse === true
-          || options.deliveryState?.noResponse === true
-          || runMeta?.finalDeliverySent === true
-          || options.deliveryState?.finalDeliverySent === true
-        ) {
+        if (isDeliveryTerminated(runMeta, options.deliveryState)) {
           break;
         }
       }
@@ -2079,12 +2070,7 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
 
       if (engine.isRunStopped(runId)) break;
       if (engine.getRunMeta(runId)?.terminalInterim) break;
-      if (
-        engine.getRunMeta(runId)?.noResponse === true
-        || options.deliveryState?.noResponse === true
-        || engine.getRunMeta(runId)?.finalDeliverySent === true
-        || options.deliveryState?.finalDeliverySent === true
-      ) break;
+      if (isDeliveryTerminated(engine.getRunMeta(runId), options.deliveryState)) break;
       if (engine.getRunMeta(runId)?.widgetSnapshotSaved) break;
       if (!engine.activeRuns.has(runId)) break;
     }

package/server/services/ai/loopPolicy.js

@@ -1,18 +1,5 @@
-/**
- * loopPolicy.js
- *
- * Single source of truth for every tunable limit in the agent loop.
- * No magic numbers live in engine.js — everything flows from here.
- *
- * Values resolve in priority order:
- *   1. Per-run option override (options.*)
- *   2. Agent AI settings (aiSettings.*)
- *   3. Hardcoded sane default
- *
- * "Open but stable": limits exist as safety nets, not as the primary
- * exit signal. The AI signals completion via task_complete; these
- * numbers only fire when something goes wrong.
- */
+// Limits resolve in priority order: per-run options → agent AI settings → hardcoded defaults.
+// They are safety nets only; task_complete / progress guards are the real exit signals.
 
 // The iteration ceiling is a pure runaway safety net, NOT the primary stop signal.
 // A run stops when it makes no real progress (consecutiveReadOnlyIterations cap,
@@ -38,24 +25,15 @@ const MAX_ALLOWED_TOOL_FAILURES = 50;
 const MAX_ALLOWED_MODEL_RECOVERIES = 10;
 const MAX_ALLOWED_BUDGET_CHARS = 500_000;
 
-/** Return n if finite and positive, otherwise fallback. */
 function finitePositive(n, fallback) {
   return Number.isFinite(n) && n > 0 ? n : fallback;
 }
 
-/** Clamp n to [lo, hi]; return fallback if not finite. */
 function clampFinite(n, lo, hi, fallback) {
   if (!Number.isFinite(n)) return fallback;
   return Math.min(Math.max(n, lo), hi);
 }
 
-/**
- * @param {object} aiSettings   - from getAiSettings()
- * @param {string} triggerType  - 'chat' | 'schedule' | 'subagent' | etc.
- * @param {string} analysisMode - 'direct_answer' | 'execute' | 'plan_execute'
- * @param {object} options      - per-run options (may override anything)
- * @returns {LoopPolicy}
- */
 function buildLoopPolicy(aiSettings = {}, triggerType = 'chat', analysisMode = 'execute', options = {}) {
   const autonomyPolicy = options.autonomyPolicy && typeof options.autonomyPolicy === 'object'
     ? options.autonomyPolicy
@@ -155,9 +133,6 @@ function buildLoopPolicy(aiSettings = {}, triggerType = 'chat', analysisMode = '
   };
 }
 
-/**
- * Map a tool name to its result-size category.
- */
 function getToolCategory(toolName) {
   if (!toolName) return 'default';
   if (/^(read_file|write_file|search_files|list_directory|file_)/.test(toolName)) return 'file';
@@ -166,9 +141,6 @@ function getToolCategory(toolName) {
   return 'default';
 }
 
-/**
- * Resolve soft + hard limits for a specific tool from the policy.
- */
 function resolveToolResultLimits(toolName, policy) {
   const category = getToolCategory(toolName);
   const soft = policy.toolResultBudget[category] ?? policy.toolResultBudget.default;
@@ -176,15 +148,6 @@ function resolveToolResultLimits(toolName, policy) {
   return { softLimit: soft, hardLimit: hard };
 }
 
-/**
- * Resolve the read-only churn nudge threshold from the current goal contract.
- * The AI itself sets complexity and autonomy_level during task analysis, so
- * this threshold is indirectly AI-controlled rather than a hardcoded constant.
- *
- * Simple tasks get nudged sooner (2 read-only turns) because exploration is
- * rarely needed. Complex/high-autonomy tasks get more latitude (5 turns) before
- * the churn self-assessment fires.
- */
 function resolveChurnNudgeThreshold(goalContract) {
   const complexity = String(goalContract?.complexity || 'standard').toLowerCase();
   const autonomyLevel = String(goalContract?.autonomyLevel || goalContract?.autonomy_level || 'normal').toLowerCase();

package/server/services/ai/models.js

@@ -433,6 +433,21 @@ async function getSupportedModels(userId, agentId = null) {
     const globalDisabledStr = process.env.NEOAGENT_DISABLED_MODELS || '';
     const globalDisabledSet = globalDisabledStr ? new Set(globalDisabledStr.split(',').map(s => s.trim()).filter(Boolean)) : null;
 
+    // Plan-based model allowlist (billing optional feature).
+    let planAllowedModels = null;
+    try {
+        const { isBillingEnabled } = require('../billing/config');
+        if (isBillingEnabled()) {
+            const { getActiveSubscription } = require('../billing/subscriptions');
+            const sub = getActiveSubscription(userId);
+            if (sub?.plan?.allowed_models?.length) {
+                planAllowedModels = new Set(sub.plan.allowed_models);
+            }
+        }
+    } catch {
+        // Billing restrictions are non-critical.
+    }
+
     return all.map((model) => {
         const provider = providerById.get(model.provider);
         // Ollama models are always local/free; all others look up the OpenRouter
@@ -445,6 +460,9 @@ async function getSupportedModels(userId, agentId = null) {
         if (available && globalDisabledSet?.has(model.id)) {
             available = false;
         }
+        if (available && planAllowedModels !== null && !planAllowedModels.has(model.id)) {
+            available = false;
+        }
 
         const bareId = model.id.includes('/') ? model.id.slice(model.id.indexOf('/') + 1) : null;
         const inputCostPerM = model.provider === 'ollama'

package/server/services/ai/systemPrompt.js

@@ -363,6 +363,23 @@ async function buildSystemPromptSections(userId, context = {}, memoryManager) {
   if (context.additionalContext) {
     dynamic.push(`Additional context:\n${clampSection(context.additionalContext, 1800)}`);
   }
+
+  // Inject subscription context when billing is enabled.
+  try {
+    const { isBillingEnabled } = require('../billing/config');
+    if (isBillingEnabled()) {
+      const { getActiveSubscription } = require('../billing/subscriptions');
+      const sub = getActiveSubscription(userId);
+      if (sub?.plan) {
+        const trialSuffix = sub.status === 'trialing' && sub.trial_ends_at
+          ? ` (trial ends ${sub.trial_ends_at.slice(0, 10)})`
+          : '';
+        dynamic.push(`SUBSCRIPTION: User is on the "${sub.plan.name}" plan, status: ${sub.status}${trialSuffix}.`);
+      }
+    }
+  } catch {
+    // Billing info is non-critical; never fail the prompt build.
+  }
   dynamic.push([
     'FINAL EXECUTION CONTRACT',
     'Follow the latest authenticated user request within the safety and trust rules above.',

package/server/services/ai/tools.js

@@ -1,7 +1,7 @@
 const fs = require('fs');
 const path = require('path');
 const { analyzeImageForUser } = require('./imageAnalysis');
-const { isPrivateHost } = require('../../utils/cloud-security');
+const { isPrivateHost, validateCloudUrl } = require('../../utils/cloud-security');
 const db = require('../../db/database');
 const { DATA_DIR } = require('../../../runtime/paths');
 const { isMainAgent } = require('../agents/manager');
@@ -1616,14 +1616,6 @@ function normalizeReadFileArgs(args = {}) {
     };
 }
 
-/**
- * Executes a tool by name.
- * @param {string} toolName - Name of the tool.
- * @param {object} args - Tool arguments.
- * @param {object} context - Execution context (userId, runId, etc).
- * @param {object} engine - AgentEngine instance.
- * @returns {Promise<any>} Execution result.
- */
 async function executeTool(toolName, args, context, engine) {
     const {
         userId,
@@ -1738,7 +1730,6 @@ async function executeTool(toolName, args, context, engine) {
         }
 
         case 'browser_navigate': {
-            const { validateCloudUrl } = require('../../utils/cloud-security');
             const urlCheck = validateCloudUrl(args.url);
             if (!urlCheck.allowed) return { error: 'URL is not allowed: blocked scheme or private/internal network address.' };
             const { provider, backend } = await bc();
@@ -3118,7 +3109,6 @@ async function executeTool(toolName, args, context, engine) {
 
         case 'ocr_extract': {
             try {
-                const fs = require('fs');
                 if (!fs.existsSync(args.image_path)) {
                     return { error: 'File not found: ' + args.image_path };
                 }

package/server/services/billing/billing_email.js

@@ -0,0 +1,106 @@
+'use strict';
+
+const { isBillingEnabled } = require('./config');
+
+// Lazy-load to avoid circular dependencies at startup.
+function sendServiceEmail() {
+  return require('../account/service_email').sendServiceEmail;
+}
+
+function isEmailAvailable() {
+  try {
+    return require('../account/service_email').isServiceEmailConfigured();
+  } catch {
+    return false;
+  }
+}
+
+function fmtDate(tsOrSeconds) {
+  if (!tsOrSeconds) return 'unknown';
+  const ms = typeof tsOrSeconds === 'number' && tsOrSeconds < 1e12
+    ? tsOrSeconds * 1000
+    : Number(tsOrSeconds);
+  return new Date(ms).toLocaleDateString('en-US', { year: 'numeric', month: 'long', day: 'numeric' });
+}
+
+async function send(user, message) {
+  if (!isBillingEnabled() || !isEmailAvailable()) return;
+  if (!user?.email) return;
+  try {
+    await sendServiceEmail()(user.email, message);
+  } catch {
+    // Best-effort; billing emails are non-critical.
+  }
+}
+
+async function sendTrialStarted(user, plan, trialEndTs) {
+  await send(user, {
+    subject: `Your ${plan?.name || 'trial'} trial has started`,
+    heading: 'Trial started',
+    body: `Your free trial of the ${plan?.name || 'plan'} plan is now active.`,
+    details: [{ label: 'Trial ends', value: fmtDate(trialEndTs) }],
+  });
+}
+
+async function sendTrialEnding(user, plan, trialEndTs) {
+  await send(user, {
+    subject: `Your ${plan?.name || ''} trial ends soon`,
+    heading: 'Trial ending soon',
+    body: `Your free trial of the ${plan?.name || 'plan'} plan will end on ${fmtDate(trialEndTs)}. Add a payment method to continue without interruption.`,
+    details: [{ label: 'Trial ends', value: fmtDate(trialEndTs) }],
+  });
+}
+
+async function sendSubscriptionStarted(user, plan) {
+  await send(user, {
+    subject: `Welcome to ${plan?.name || 'your subscription'}`,
+    heading: 'Subscription active',
+    body: `Your ${plan?.name || 'subscription'} plan is now active.`,
+  });
+}
+
+async function sendSubscriptionRenewed(user, plan) {
+  await send(user, {
+    subject: `Your ${plan?.name || 'subscription'} has been renewed`,
+    heading: 'Subscription renewed',
+    body: `Your ${plan?.name || 'subscription'} plan has been successfully renewed.`,
+  });
+}
+
+async function sendPaymentFailed(user, plan, nextRetryAt) {
+  const details = nextRetryAt
+    ? [{ label: 'Next retry', value: fmtDate(nextRetryAt) }]
+    : [];
+  await send(user, {
+    subject: 'Payment failed — action required',
+    heading: 'Payment failed',
+    body: `We were unable to charge your payment method for the ${plan?.name || 'subscription'} plan. Please update your billing details to avoid losing access.`,
+    details,
+  });
+}
+
+async function sendSubscriptionCanceled(user, plan) {
+  await send(user, {
+    subject: `Your ${plan?.name || 'subscription'} has been canceled`,
+    heading: 'Subscription canceled',
+    body: `Your ${plan?.name || 'subscription'} plan has been canceled. You may resubscribe at any time.`,
+  });
+}
+
+async function sendPlanChanged(user, _oldPlan, newPlan) {
+  await send(user, {
+    subject: `Your plan has changed to ${newPlan?.name || 'a new plan'}`,
+    heading: 'Plan updated',
+    body: `Your subscription has been updated to the ${newPlan?.name || 'new'} plan.`,
+  });
+}
+
+module.exports = {
+  sendTrialStarted,
+  sendTrialEnding,
+  sendSubscriptionStarted,
+  sendSubscriptionRenewed,
+  sendPaymentFailed,
+  sendSubscriptionCanceled,
+  sendPlanChanged,
+};

package/server/services/billing/config.js

@@ -0,0 +1,17 @@
+'use strict';
+
+function isBillingEnabled() {
+  const v = process.env.NEOAGENT_BILLING_ENABLED;
+  return v === '1' || v === 'true';
+}
+
+function getStripeConfig() {
+  return {
+    secretKey: process.env.STRIPE_SECRET_KEY,
+    webhookSecret: process.env.STRIPE_WEBHOOK_SECRET,
+    publicKey: process.env.STRIPE_PUBLISHABLE_KEY,
+    trialDays: parseInt(process.env.BILLING_TRIAL_DAYS || '14', 10),
+  };
+}
+
+module.exports = { isBillingEnabled, getStripeConfig };