Merge pull request #385 from HelpCode-ai/keysersoft/anythingmcp-redesign-plan

Redesign (sidebar app shell) + cloud onboarding/conversion + KG improvements — v0.3.0

Author: keysersoft

package.json

@@ -1,6 +1,6 @@
 {
   "name": "anythingmcp",
-  "version": "0.2.6",
+  "version": "0.3.0",
   "description": "Self-hosted MCP gateway for REST, SOAP/WSDL, GraphQL and SQL — turn any API into MCP tools for Claude, ChatGPT, Gemini, Copilot and Cursor. 30+ pre-built adapters, on-prem audit log, OAuth2/RBAC. Open source (AGPL-3.0).",
   "private": true,
   "license": "AGPL-3.0-only",

packages/backend/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anythingmcp/backend",
-  "version": "0.2.6",
+  "version": "0.3.0",
   "description": "AnythingMCP — NestJS Backend + Dynamic MCP Server",
   "private": true,
   "license": "AGPL-3.0-only",

packages/backend/src/auth/auth.controller.ts

@@ -30,6 +30,7 @@ import { PrismaService } from '../common/prisma.service';
 import { EmailService } from '../settings/email.service';
 import { SiteSettingsService } from '../settings/site-settings.service';
 import { OrganizationsService } from '../organizations/organizations.service';
+import { LicenseService } from '../license/license.service';
 import { Roles, RolesGuard } from './roles.guard';
 
 class LoginDto {
@@ -145,6 +146,7 @@ export class AuthController {
     private readonly configService: ConfigService,
     private readonly siteSettings: SiteSettingsService,
     private readonly organizationsService: OrganizationsService,
+    private readonly licenseService: LicenseService,
   ) {}
 
   private getFrontendUrl(_req?: any): string {
@@ -349,6 +351,10 @@ export class AuthController {
     // Mark user as verified
     await this.usersService.update(userId, { emailVerified: true });
 
+    // Cloud: deterministically ensure the workspace has a trial before any
+    // license gate evaluates (best-effort; never blocks verification).
+    await this.ensureCloudTrial(userId);
+
     return { message: 'Email verified successfully', emailVerified: true };
   }
 
@@ -372,11 +378,44 @@ export class AuthController {
     });
     await this.usersService.update(record.userId, { emailVerified: true });
 
+    // Cloud: ensure a trial exists before the user lands back in the app.
+    await this.ensureCloudTrial(record.userId);
+
     // Redirect to frontend
     const frontendUrl = this.getFrontendUrl(req);
     return res.redirect(`${frontendUrl}/login?emailVerified=true`);
   }
 
+  /**
+   * Cloud only: make sure a freshly-verified user's workspace has a trial
+   * license, idempotently and best-effort. This removes the client-side race
+   * where a failed trial activation in the login flow dropped the user onto the
+   * "no-license" wall instead of onboarding. Never throws — verification must
+   * succeed regardless; the login flow + LicenseWall "Start trial" CTA remain
+   * as fallbacks.
+   */
+  private async ensureCloudTrial(userId: string): Promise<void> {
+    const isCloud = this.configService.get<string>('DEPLOYMENT_MODE') === 'cloud';
+    if (!isCloud) return;
+    try {
+      const user = await this.usersService.findById(userId);
+      if (!user?.organizationId) return;
+      // Idempotent: skip if this org already has any license (trial or paid).
+      const existing = await this.prisma.license.findFirst({
+        where: { organizationId: user.organizationId },
+      });
+      if (existing) return;
+      await this.licenseService.requestTrialLicense(
+        user.email,
+        user.name || user.email,
+        user.organizationId,
+      );
+      this.logger.log(`Cloud trial activated for org ${user.organizationId} on email verification.`);
+    } catch (err: any) {
+      this.logger.warn(`Cloud trial activation on verify failed for user ${userId}: ${err.message}`);
+    }
+  }
+
   @Post('resend-verification')
   @UseGuards(AuthGuard('jwt'))
   @ApiBearerAuth()

packages/backend/src/auth/auth.module.ts

@@ -16,6 +16,7 @@ import { UsersModule } from '../users/users.module';
 import { SettingsModule } from '../settings/settings.module';
 import { McpServersModule } from '../mcp-servers/mcp-servers.module';
 import { OrganizationsModule } from '../organizations/organizations.module';
+import { LicenseModule } from '../license/license.module';
 import { getRequiredSecret } from '../common/secrets.util';
 
 @Global()
@@ -25,6 +26,7 @@ import { getRequiredSecret } from '../common/secrets.util';
     SettingsModule,
     McpServersModule,
     OrganizationsModule,
+    LicenseModule,
     PassportModule.register({ defaultStrategy: 'jwt' }),
     JwtModule.registerAsync({
       imports: [ConfigModule],

packages/backend/src/ee/cloud/onboarding-cron.service.spec.ts

@@ -5,6 +5,7 @@ describe('OnboardingCronService — activation pass', () => {
     onboardingCandidates?: any[];
     stuckUsers?: any[];
     sendOk?: boolean;
+    trials?: any[];
   }) {
     const findMany = jest
       .fn()
@@ -13,7 +14,12 @@ describe('OnboardingCronService — activation pass', () => {
       // 2nd call: activation (stuck) cohort
       .mockResolvedValueOnce(overrides.stuckUsers ?? []);
     const update = jest.fn().mockResolvedValue({});
-    const prisma = { user: { findMany, update } } as any;
+    const prisma = {
+      user: { findMany, update },
+      // The trial-lifecycle pass runs after the activation pass; with no
+      // trials it's a no-op. Stub just enough so it doesn't throw here.
+      license: { findMany: jest.fn().mockResolvedValue(overrides.trials ?? []) },
+    } as any;
     const email = {
       sendOnboardingReminderEmail: jest.fn().mockResolvedValue(true),
       sendActivationReminderEmail: jest

packages/backend/src/ee/cloud/onboarding-cron.service.ts

@@ -3,6 +3,7 @@ import { PrismaService } from '../../common/prisma.service';
 import { EmailService } from '../../settings/email.service';
 
 const HOURS = (n: number) => n * 60 * 60 * 1000;
+const DAYS = (n: number) => n * 24 * 60 * 60 * 1000;
 
 /**
  * Onboarding drip — finds users who registered, verified their email,
@@ -39,6 +40,9 @@ export class OnboardingCronService {
     firstReminders: number;
     secondReminders: number;
     activationReminders: number;
+    trialWarn3: number;
+    trialWarn1: number;
+    trialExpired: number;
     skipped: number;
   }> {
     const now = Date.now();
@@ -47,6 +51,9 @@ export class OnboardingCronService {
       firstReminders: 0,
       secondReminders: 0,
       activationReminders: 0,
+      trialWarn3: 0,
+      trialWarn1: 0,
+      trialExpired: 0,
       skipped: 0,
     };
 
@@ -150,14 +157,102 @@ export class OnboardingCronService {
     }
 
     await this.runActivationPass(now, out);
+    await this.runTrialLifecyclePass(now, out);
 
     this.logger.log(
       `Onboarding drip: examined=${out.examined} first=${out.firstReminders} ` +
-        `second=${out.secondReminders} activation=${out.activationReminders} skipped=${out.skipped}`,
+        `second=${out.secondReminders} activation=${out.activationReminders} ` +
+        `trialWarn3=${out.trialWarn3} trialWarn1=${out.trialWarn1} trialExpired=${out.trialExpired} ` +
+        `skipped=${out.skipped}`,
     );
     return out;
   }
 
+  /**
+   * Trial lifecycle pass — value-oriented conversion nudges as a trial winds
+   * down. For each cloud trial whose `expiresAt` is within 3 days or already
+   * past, send the most-urgent unsent stage (expired → warn1 → warn3) to the
+   * org's admins, with a recap of what they've built. These are account-
+   * lifecycle (paid access ending), not marketing, so they ignore the
+   * marketing opt-out. Idempotent via per-org OrgSettings flags
+   * (`trial_email_{stage}`). Sends at most one stage per org per run.
+   */
+  private async runTrialLifecyclePass(
+    now: number,
+    out: { examined: number; trialWarn3: number; trialWarn1: number; trialExpired: number; skipped: number },
+  ): Promise<void> {
+    const trials = await this.prisma.license.findMany({
+      where: {
+        plan: 'trial',
+        status: 'active',
+        organizationId: { not: null },
+        expiresAt: { not: null, lte: new Date(now + DAYS(3)) },
+      },
+      select: { organizationId: true, expiresAt: true },
+    });
+
+    for (const lic of trials) {
+      const organizationId = lic.organizationId!;
+      const expiresAt = lic.expiresAt!.getTime();
+      out.examined++;
+
+      // Ladder: most-urgent applicable stage that hasn't been sent yet.
+      const daysLeft = Math.max(0, Math.ceil((expiresAt - now) / DAYS(1)));
+      const stage: 'warn3' | 'warn1' | 'expired' =
+        now >= expiresAt ? 'expired' : daysLeft <= 1 ? 'warn1' : 'warn3';
+      const flagKey = `trial_email_${stage}`;
+
+      const already = await this.prisma.orgSettings.findUnique({
+        where: { organizationId_key: { organizationId, key: flagKey } },
+        select: { id: true },
+      });
+      if (already) {
+        out.skipped++;
+        continue;
+      }
+
+      // Recipients: org admins (authoritative membership).
+      const admins = await this.prisma.organizationMember.findMany({
+        where: { organizationId, role: 'ADMIN' },
+        select: { user: { select: { email: true, name: true } } },
+      });
+      if (admins.length === 0) {
+        out.skipped++;
+        continue;
+      }
+
+      // Value recap (cheap counts; trial window is 7d so audit isn't pruned).
+      const [connectors, successfulCalls] = await Promise.all([
+        this.prisma.connector.count({ where: { organizationId } }),
+        this.prisma.toolInvocation.count({ where: { organizationId, status: 'SUCCESS' } }),
+      ]);
+
+      let sentAny = false;
+      for (const a of admins) {
+        const ok = await this.email.sendTrialLifecycleEmail(
+          a.user.email,
+          a.user.name || 'there',
+          stage,
+          { connectors, successfulCalls, daysLeft },
+        );
+        if (ok) sentAny = true;
+      }
+
+      if (sentAny) {
+        await this.prisma.orgSettings.upsert({
+          where: { organizationId_key: { organizationId, key: flagKey } },
+          create: { organizationId, key: flagKey, value: new Date().toISOString() },
+          update: { value: new Date().toISOString() },
+        });
+        if (stage === 'expired') out.trialExpired++;
+        else if (stage === 'warn1') out.trialWarn1++;
+        else out.trialWarn3++;
+      } else {
+        out.skipped++;
+      }
+    }
+  }
+
   /**
    * Activation pass — the cohort that builds a connector but never lands a
    * successful tool call (the biggest single drop-off). One email only,

packages/backend/src/knowledge-graph/kg-llm.service.ts

@@ -6,6 +6,12 @@ import { chatJson, resolveLlmConfig } from './llm-client';
 
 const MAX_ENTITIES = 120; // cost cap: never send more than this to the model
 
+// Minimum confidence for an AI-suggested edge to be auto-applied (status 'active')
+// when the workspace opts in. Mirrors the skill auto-apply bar (0.9). The LLM
+// confidence is itself capped at 0.9, so only edges the model rates top-confidence
+// qualify; everything else stays a suggestion for manual review.
+export const EDGE_AUTO_APPLY_MIN = 0.9;
+
 const SYSTEM_PROMPT = `You analyze a software workspace's data entities (drawn from connected SaaS/ERP systems) and infer relationships a naive name-matching heuristic misses.
 
 You receive a JSON list of entities, each with a stable "ref", its connector, its name, its input field names ("fields") and the field names its tools RETURN ("outputs").
@@ -139,6 +145,9 @@ export class KgLlmService {
     ctx: { idByRef: Record<string, string>; hash: string },
   ): Promise<number> {
     const rels: any[] = Array.isArray(json?.relationships) ? json.relationships : [];
+    // Read the per-workspace auto-apply switch once (no AI cost): when on,
+    // high-confidence edges land as 'active' instead of 'suggested'.
+    const autoApply = await this.kgStatic.getFlag(organizationId, 'kg_edge_auto_apply', false);
     let suggested = 0;
     for (const r of rels) {
       let src = ctx.idByRef[r?.from];
@@ -149,7 +158,7 @@ export class KgLlmService {
       const confidence = Math.max(0, Math.min(0.9, Number(r?.confidence) || 0.5));
       const note = typeof r?.reason === 'string' ? r.reason.slice(0, 200) : null;
       try {
-        if (await this.upsertLlmEdge(organizationId, src, tgt, kind, confidence, note)) {
+        if (await this.upsertLlmEdge(organizationId, src, tgt, kind, confidence, note, autoApply)) {
           suggested++;
         }
       } catch (e: any) {
@@ -173,7 +182,10 @@ export class KgLlmService {
     kind: string,
     confidence: number,
     note: string | null,
+    autoApply = false,
   ): Promise<boolean> {
+    // High-confidence + opted in → apply directly; otherwise leave for review.
+    const applied = autoApply && confidence >= EDGE_AUTO_APPLY_MIN;
     const existing = await this.prisma.kgEdge.findUnique({
       where: {
         organizationId_sourceNodeId_targetNodeId_kind: {
@@ -193,7 +205,7 @@ export class KgLlmService {
           targetNodeId,
           kind,
           source: 'LLM',
-          status: 'suggested',
+          status: applied ? 'active' : 'suggested',
           confidence,
           note,
         },
@@ -202,10 +214,16 @@ export class KgLlmService {
     }
     // Don't touch a human-curated or rejected edge; just attach the rationale.
     if (existing.isManual || existing.status === 'rejected') return false;
+    // Promote a still-pending suggestion to active when auto-apply qualifies.
+    const promote = applied && existing.status === 'suggested';
     await this.prisma.kgEdge.update({
       where: { id: existing.id },
-      data: { note: note ?? undefined, lastSeenAt: new Date() },
+      data: {
+        note: note ?? undefined,
+        lastSeenAt: new Date(),
+        ...(promote ? { status: 'active' } : {}),
+      },
     });
-    return false;
+    return promote;
   }
 }

packages/backend/src/knowledge-graph/kg.controller.ts

@@ -53,7 +53,15 @@ export class KgController {
   @ApiOperation({ summary: 'Update knowledge-graph settings for this workspace' })
   async setSettings(
     @Req() req: any,
-    @Body() body: { enabled?: boolean; llmEnabled?: boolean; captureIntent?: boolean },
+    @Body()
+    body: {
+      enabled?: boolean;
+      llmEnabled?: boolean;
+      captureIntent?: boolean;
+      autoExtend?: boolean;
+      skillAutoApply?: boolean;
+      edgeAutoApply?: boolean;
+    },
   ) {
     return this.kg.updateSettings(req.user.organizationId, body);
   }

packages/backend/src/knowledge-graph/kg.service.ts

@@ -56,13 +56,15 @@ export class KgService {
   }
 
   async getSettings(organizationId: string) {
-    const [enabled, llmEnabled, captureIntent, autoExtend, skillAutoApply] = await Promise.all([
-      this.staticSvc.isEnabled(organizationId),
-      this.staticSvc.getFlag(organizationId, 'kg_llm_enabled', false),
-      this.staticSvc.getFlag(organizationId, 'kg_capture_intent', false),
-      this.staticSvc.getFlag(organizationId, 'kg_llm_auto', false),
-      this.staticSvc.getFlag(organizationId, 'kg_skill_auto_apply', false),
-    ]);
+    const [enabled, llmEnabled, captureIntent, autoExtend, skillAutoApply, edgeAutoApply] =
+      await Promise.all([
+        this.staticSvc.isEnabled(organizationId),
+        this.staticSvc.getFlag(organizationId, 'kg_llm_enabled', false),
+        this.staticSvc.getFlag(organizationId, 'kg_capture_intent', false),
+        this.staticSvc.getFlag(organizationId, 'kg_llm_auto', false),
+        this.staticSvc.getFlag(organizationId, 'kg_skill_auto_apply', false),
+        this.staticSvc.getFlag(organizationId, 'kg_edge_auto_apply', false),
+      ]);
     return {
       enabled,
       llmEnabled,
@@ -72,6 +74,9 @@ export class KgService {
       autoExtend,
       // Auto-apply generated skills at/above the confidence threshold.
       skillAutoApply,
+      // Auto-apply high-confidence AI-suggested graph connections (no extra AI cost —
+      // it only changes the status of edges the enrichment pass already produced).
+      edgeAutoApply,
     };
   }
 
@@ -83,6 +88,7 @@ export class KgService {
       captureIntent?: boolean;
       autoExtend?: boolean;
       skillAutoApply?: boolean;
+      edgeAutoApply?: boolean;
     },
   ) {
     if (typeof body.enabled === 'boolean') {
@@ -100,6 +106,9 @@ export class KgService {
     if (typeof body.skillAutoApply === 'boolean') {
       await this.staticSvc.setFlag(organizationId, 'kg_skill_auto_apply', body.skillAutoApply);
     }
+    if (typeof body.edgeAutoApply === 'boolean') {
+      await this.staticSvc.setFlag(organizationId, 'kg_edge_auto_apply', body.edgeAutoApply);
+    }
     return this.getSettings(organizationId);
   }