@solidxai/core 0.1.13-beta.8 → 0.1.13

package/src/solid-core.module.ts

@@ -1,6 +1,5 @@
 import "multer";
-import { Global, MiddlewareConsumer, Module, NestModule } from "@nestjs/common";
-import * as express from "express";
+import { Global, Module } from "@nestjs/common";
 import { ConfigModule, ConfigService } from "@nestjs/config";
 import {
   APP_FILTER,
@@ -98,6 +97,7 @@ import { GoogleAuthenticationController } from "./controllers/google-authenticat
 import { MenuItemMetadataController } from "./controllers/menu-item-metadata.controller";
 import { MqMessageQueueController } from "./controllers/mq-message-queue.controller";
 import { MqMessageController } from "./controllers/mq-message.controller";
+import { MpinAuthenticationController } from "./controllers/mpin-authentication.controller";
 import { OTPAuthenticationController } from "./controllers/otp-authentication.controller";
 import { ServiceController } from "./controllers/service.controller";
 import { SmsTemplateController } from "./controllers/sms-template.controller";
@@ -167,6 +167,7 @@ import { TwilioSmsQueueSubscriberRedis } from "./jobs/redis/twilio-sms-subscribe
 import { UserRegistrationListener } from "./listeners/user-registration.listener";
 import { GoogleOauthStrategy } from "./passport-strategies/google-oauth.strategy";
 import { ApiKeyService } from "./services/api-key.service";
+import { MpinService } from "./services/mpin.service";
 import { ActiveSessionStorageService } from "./services/active-session-storage.service";
 import { AuthenticationService } from "./services/authentication.service";
 import { MetadataValidationService } from "./services/metadata-validation.service";
@@ -247,6 +248,7 @@ import { Setting } from './entities/setting.entity';
 import { UserActivityHistory } from './entities/user-activity-history.entity';
 import { UserViewMetadata } from './entities/user-view-metadata.entity';
 import { UserApiKey } from './entities/user-api-key.entity';
+import { UserDeviceCredential } from './entities/user-device-credential.entity';
 import { User } from './entities/user.entity';
 import { HttpExceptionFilter } from './filters/http-exception.filter';
 import { ModelMetadataHelperService } from './helpers/model-metadata-helper.service';
@@ -319,6 +321,7 @@ import { SmsTemplateRepository } from './repository/sms-template.repository';
 import { UserActivityHistoryRepository } from './repository/user-activity-history.repository';
 import { UserViewMetadataRepository } from './repository/user-view-metadata.repository';
 import { UserApiKeyRepository } from './repository/user-api-key.repository';
+import { UserDeviceCredentialRepository } from './repository/user-device-credential.repository';
 import { UserRepository } from './repository/user.repository';
 import { ViewMetadataRepository } from './repository/view-metadata.repository';
 import { PermissionMetadataSeederService } from './seeders/permission-metadata-seeder.service';
@@ -501,6 +504,7 @@ import { SwitchNode } from './services/workflow/nodes/switch.node';
       SmsTemplate,
       User,
       UserApiKey,
+      UserDeviceCredential,
       UserActivityHistory,
       UserViewMetadata,
       ViewMetadata,
@@ -553,6 +557,19 @@ import { SwitchNode } from './services/workflow/nodes/switch.node';
       imports: [ConfigModule],
       useFactory: async (configService: ConfigService) => ({
         dest: process.env.AB_MEDIA_UPLOAD_DIR ?? "media-uploads",
+        // A global floor under whatever per-field mediaMaxSizeKb restrictions apply, not a
+        // replacement for them - some upload paths (e.g. chatter attachments) had no size cap
+        // enforced anywhere before this. Must stay >= the largest legitimate per-field limit
+        // already configured (chatter's messageAttachments is 102400 KB / 100MB), since Multer
+        // enforces this before any of our own field-level checks ever run. Mirrored (read-only,
+        // for visibility only - see comment there for why) as the "maxMediaFileSizeMb" setting
+        // in default-settings-provider.service.ts; keep both parsing expressions in sync.
+        limits: {
+          fileSize: (() => {
+            const parsedMb = Number(process.env.AB_MEDIA_MAX_FILE_SIZE_MB);
+            return (Number.isFinite(parsedMb) && parsedMb > 0 ? parsedMb : 100) * 1024 * 1024;
+          })(),
+        },
       }),
       inject: [ConfigService],
     }),
@@ -596,6 +613,7 @@ import { SwitchNode } from './services/workflow/nodes/switch.node';
     GupshupWebhookController,
     MetaCloudWhatsappWebhookController,
     OTPAuthenticationController,
+    MpinAuthenticationController,
     PermissionMetadataController,
     RoleMetadataController,
     SavedFiltersController,
@@ -761,6 +779,7 @@ import { SwitchNode } from './services/workflow/nodes/switch.node';
     ApiKeyGuard,
     MediaSignedUrlGuard,
     ApiKeyService,
+    MpinService,
     ActiveSessionStorageService,
     AuthenticationService,
     GoogleAuthenticationController,
@@ -830,6 +849,7 @@ import { SwitchNode } from './services/workflow/nodes/switch.node';
     PermissionMetadataSeederService,
     UserService,
     UserApiKeyRepository,
+    UserDeviceCredentialRepository,
     UserRepository,
     SettingService,
     ConcatComputedFieldProvider,
@@ -1050,13 +1070,7 @@ import { SwitchNode } from './services/workflow/nodes/switch.node';
     WorkflowExpressionService,
   ],
 })
-export class SolidCoreModule implements NestModule {
-  configure(consumer: MiddlewareConsumer) {
-    consumer
-      .apply(
-        express.json({ limit: "10mb" }),
-        express.urlencoded({ limit: "10mb", extended: true }),
-      )
-      .forRoutes("*");
-  }
-}
+// Body-size limits live in bootstrapSolidApp (see SolidBootstrapOptions.bodyLimit).
+// They cannot be applied here: module middleware is registered in registerRouter(),
+// which runs after Nest's own parser middleware, so anything set here never takes effect.
+export class SolidCoreModule {}

package/src/testing/README.md

@@ -104,6 +104,15 @@ Or set the installation-wide default under **Settings → Testing Settings** in
 (`uiTestDefaultTimeoutMs` / `uiTestNavigationTimeoutMs`). Those rows are created by `solid seed`;
 until then the built-in `30000` applies. Flags and env vars still win, so CI keeps per-run control.
 
+The seeded value of those two settings can be provisioned from the environment with
+`COMMON_UI_TEST_DEFAULT_TIMEOUT_MS` and `COMMON_UI_TEST_NAVIGATION_TIMEOUT_MS` (the latter falls
+back to the former). Seeding is insert-only, so these apply on first seed only — afterwards the
+stored value wins and the setting must be changed in the admin UI. Values that are missing,
+non-numeric, or not positive fall back to `30000`.
+
+Note these are distinct from the run-time `UI_TIMEOUT_MS` / `UI_NAVIGATION_TIMEOUT_MS` vars,
+which override the setting on a per-run basis and are read every run.
+
 Or bump only the one slow step, leaving the rest of the suite strict:
 ```json
 {
@@ -470,10 +479,11 @@ Common `test run` flags (all pass through solidctl unchanged):
 - `--ui-navigation-timeout-ms <number>` — default wait for `ui.goto`
 - `--timeout-ms <number>` / `--retries <number>` — scenario-level guard and retry count
 - `--scenario-ids <ids>` / `--include-tags <tags>` / `--skip-scenario-ids <ids>`
+- `--no-progress` — disable the interactive test progress footer
 
 ## Add A New Step (SOP)
 1. Create a new `*.step.ts` in the right domain folder.
 2. Implement a `registerXSteps(registry)` function and `registry.register("op.name", handler)`.
 3. Validate required `step.with` fields and throw clear errors.
 4. Use adapters via `ctx.api` / `ctx.ui` and update `ctx.last` when helpful.
-5. Export and register it from the domain `index.ts`.
+5. Export and register it from the domain `index.ts`.

package/src/testing/reporter/console-reporter.ts

@@ -150,6 +150,10 @@ export class ConsoleReporter implements Reporter {
   private passedScenarios = 0;
   private failedScenarios = 0;
 
+  onRunStart(_args: { total: number }): void {
+    // Progress-aware reporters use this hook; the plain console reporter has no setup.
+  }
+
   onScenarioStart(scenario: { id: string; name?: string }): void {
     const label = scenario.name ? `${scenario.id} (${scenario.name})` : scenario.id;
     console.log(`\n▶ Scenario: ${label}`);

package/src/testing/reporter/progress-reporter.ts

@@ -0,0 +1,251 @@
+import * as readline from "readline";
+import type { StepPhase } from "../contracts/runtime-context.types";
+import type { OpStep, ScenarioSpec } from "../contracts/testing-metadata.types";
+import type { SolidTestSpecResult } from "../contracts/test-spec.types";
+import type { Reporter } from "./reporter.types";
+
+const ANSI_BOLD = "\u001b[1m";
+const ANSI_BOLD_OFF = "\u001b[22m";
+const ANSI_DIM = "\u001b[2m";
+const ANSI_GREEN = "\u001b[32m";
+const ANSI_COLOR_OFF = "\u001b[39m";
+const ANSI_RED = "\u001b[31m";
+const ANSI_INVERSE = "\u001b[7m";
+const ANSI_INVERSE_OFF = "\u001b[27m";
+
+export class ProgressReporter implements Reporter {
+  private startedAt = Date.now();
+  private total = 0;
+  private completed = 0;
+  private passed = 0;
+  private failed = 0;
+  private timer?: NodeJS.Timeout;
+  private rendered = false;
+
+  constructor(private readonly delegate: Reporter) {}
+
+  onRunStart(args: { total: number }): void {
+    this.total = args.total;
+    this.startedAt = Date.now();
+    this.completed = 0;
+    this.passed = 0;
+    this.failed = 0;
+    this.delegate.onRunStart?.(args);
+    this.startTimer();
+    this.renderFooter();
+  }
+
+  onScenarioStart(scenario: ScenarioSpec): void {
+    this.withFooterPaused(() => this.delegate.onScenarioStart(scenario));
+  }
+
+  onScenarioEnd(
+    scenario: ScenarioSpec,
+    result: { ok: boolean; error?: unknown; durationMs: number },
+  ): void {
+    this.completed += 1;
+    if (result.ok) {
+      this.passed += 1;
+    } else {
+      this.failed += 1;
+    }
+    this.withFooterPaused(() => this.delegate.onScenarioEnd(scenario, result));
+  }
+
+  onStepStart(args: {
+    scenarioId: string;
+    phase: StepPhase;
+    step: OpStep;
+  }): void {
+    this.withFooterPaused(() => this.delegate.onStepStart(args));
+  }
+
+  onStepEnd(args: {
+    scenarioId: string;
+    phase: StepPhase;
+    step: OpStep;
+    ok: boolean;
+    error?: unknown;
+    durationMs: number;
+  }): void {
+    this.withFooterPaused(() => this.delegate.onStepEnd(args));
+  }
+
+  onSpecResult(args: {
+    scenarioId: string;
+    specId: string;
+    stepName?: string;
+    result: SolidTestSpecResult;
+  }): void {
+    this.withFooterPaused(() => this.delegate.onSpecResult?.(args));
+  }
+
+  attach(args: {
+    scenarioId: string;
+    name: string;
+    contentType: string;
+    data: Buffer | string;
+  }): void {
+    this.withFooterPaused(() => this.delegate.attach?.(args));
+  }
+
+  onRunEnd(args: {
+    ok: boolean;
+    total: number;
+    passed: number;
+    failed: number;
+    durationMs: number;
+  }): void {
+    this.completed = args.passed + args.failed;
+    this.passed = args.passed;
+    this.failed = args.failed;
+    this.total = args.total;
+    this.stopTimer();
+    this.withFooterPaused(() => this.delegate.onRunEnd?.(args), false);
+  }
+
+  private startTimer(): void {
+    this.stopTimer();
+    if (!this.isInteractive()) {
+      return;
+    }
+    this.timer = setInterval(() => this.renderFooter(), 1_000);
+    this.timer.unref?.();
+  }
+
+  private stopTimer(): void {
+    if (!this.timer) {
+      return;
+    }
+    clearInterval(this.timer);
+    this.timer = undefined;
+  }
+
+  private withFooterPaused(callback: () => void, renderAfter = true): void {
+    this.clearFooter();
+    callback();
+    if (renderAfter) {
+      this.renderFooter();
+    }
+  }
+
+  private renderFooter(): void {
+    if (!this.isInteractive()) {
+      return;
+    }
+
+    const terminalWidth = process.stdout.columns || 80;
+    const elapsed = formatElapsed(Date.now() - this.startedAt);
+    const progressText = `${this.completed}/${this.total}`;
+    const resultText = `${ANSI_GREEN}${this.passed} passed${ANSI_COLOR_OFF}${ANSI_DIM} | ${ANSI_BOLD_OFF}${this.failed ? ANSI_RED : ANSI_DIM}${this.failed} failed${this.failed ? ANSI_COLOR_OFF : ANSI_BOLD_OFF}`;
+    const footer = [
+      `${ANSI_BOLD}Tests${ANSI_BOLD_OFF}: ${this.renderProgressBar(terminalWidth)} ${progressText}`,
+      `${ANSI_BOLD}Elapsed${ANSI_BOLD_OFF}: ${elapsed}`,
+      resultText,
+    ].join(`${ANSI_DIM} | ${ANSI_BOLD_OFF}`);
+
+    readline.clearLine(process.stdout, 0);
+    readline.cursorTo(process.stdout, 0);
+    process.stdout.write(truncateAnsiText(`${ANSI_INVERSE} ${footer} ${ANSI_INVERSE_OFF}`, terminalWidth));
+    this.rendered = true;
+  }
+
+  private clearFooter(): void {
+    if (!this.rendered || !this.isInteractive()) {
+      return;
+    }
+    readline.clearLine(process.stdout, 0);
+    readline.cursorTo(process.stdout, 0);
+    this.rendered = false;
+  }
+
+  private renderProgressBar(terminalWidth: number): string {
+    const width = terminalWidth >= 120 ? 30 : terminalWidth >= 90 ? 22 : 14;
+    const ratio = this.total > 0 ? Math.min(1, this.completed / this.total) : 0;
+    const filled = Math.round(width * ratio);
+    const empty = Math.max(0, width - filled);
+    return `[${ANSI_GREEN}${"=".repeat(filled)}${ANSI_COLOR_OFF}${" ".repeat(empty)}]`;
+  }
+
+  private isInteractive(): boolean {
+    return Boolean(process.stdout.isTTY || process.env.SOLIDCTL_TEST_PROGRESS === "1");
+  }
+}
+
+function formatElapsed(durationMs: number): string {
+  const totalSeconds = Math.max(0, Math.floor(durationMs / 1000));
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  if (minutes < 60) {
+    return `${minutes}:${seconds.toString().padStart(2, "0")}`;
+  }
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  return `${hours}:${remainingMinutes.toString().padStart(2, "0")}:${seconds.toString().padStart(2, "0")}`;
+}
+
+function truncateAnsiText(text: string, maxWidth: number): string {
+  if (maxWidth <= 0) {
+    return "";
+  }
+
+  let visibleWidth = 0;
+  let index = 0;
+  let output = "";
+  let hasEscape = false;
+
+  while (index < text.length) {
+    if (text[index] === "\u001b") {
+      const match = /\u001b\[[0-9;]*m/.exec(text.slice(index));
+      if (!match) {
+        break;
+      }
+      output += match[0];
+      hasEscape = true;
+      index += match[0].length;
+      continue;
+    }
+
+    if (visibleWidth >= maxWidth) {
+      break;
+    }
+
+    output += text[index];
+    visibleWidth += 1;
+    index += 1;
+  }
+
+  if (index < text.length && maxWidth >= 1) {
+    output = trimAnsiText(output, maxWidth - 1) + "…";
+  }
+
+  if (hasEscape && !output.endsWith(ANSI_INVERSE_OFF)) {
+    output += ANSI_INVERSE_OFF;
+  }
+
+  return output;
+}
+
+function trimAnsiText(text: string, maxWidth: number): string {
+  let visibleWidth = 0;
+  let index = 0;
+  let output = "";
+
+  while (index < text.length && visibleWidth < maxWidth) {
+    if (text[index] === "\u001b") {
+      const match = /\u001b\[[0-9;]*m/.exec(text.slice(index));
+      if (!match) {
+        break;
+      }
+      output += match[0];
+      index += match[0].length;
+      continue;
+    }
+
+    output += text[index];
+    visibleWidth += 1;
+    index += 1;
+  }
+
+  return output;
+}

package/src/testing/reporter/reporter.types.ts

@@ -3,6 +3,9 @@ import type { OpStep, ScenarioSpec } from "../contracts/testing-metadata.types";
 import type { SolidTestSpecResult } from "../contracts/test-spec.types";
 
 export interface Reporter {
+  onRunStart?(args: {
+    total: number;
+  }): void;
   onScenarioStart(scenario: ScenarioSpec): void;
   onScenarioEnd(
     scenario: ScenarioSpec,

package/src/testing/runner/run-from-metadata.ts

@@ -67,6 +67,7 @@ export async function runFromMetadata(opts: RunnerOptions): Promise<void> {
 
   const resources = new SimpleResourceStore();
   const reporter = opts.reporter ?? new ConsoleReporter();
+  reporter.onRunStart?.({ total: scenarios.length });
   const api = new ApiAdapter(opts.api);
   const { PlaywrightAdapter } = await import("../adapters/ui/playwright-adapter");
   const ui = new PlaywrightAdapter(opts.ui);

package/src/theme/theme-registry.ts

@@ -0,0 +1,181 @@
+import fs from "fs";
+import path from "path";
+
+/**
+ * Backend theme registry.
+ *
+ * Responsibilities:
+ * - discover theme folders from the filesystem
+ * - classify each theme as light/dark from its key
+ * - expose default and grouped theme helpers for backend settings
+ *
+ * Shared pure parsing helpers are intentionally mirrored in solid-core-ui,
+ * but all filesystem discovery stays here.
+ */
+export type ThemeMode = "light" | "dark";
+
+export type AppThemeDefinition = {
+  key: string;
+  label: string;
+  mode: ThemeMode;
+  default?: boolean;
+};
+
+const DEFAULT_THEME_KEYS: Record<ThemeMode, string> = {
+  light: "solid-light-purple",
+  dark: "solid-dark-purple",
+};
+
+const THEME_MODE_TOKENS: Record<ThemeMode, string> = {
+  light: "-light-",
+  dark: "-dark-",
+};
+
+const THEME_MODE_SUFFIXES: Record<ThemeMode, string> = {
+  light: "-light",
+  dark: "-dark",
+};
+
+function normalizeThemeKey(value?: string | null): string | null {
+  const normalized = value?.trim().toLowerCase();
+  return normalized || null;
+}
+
+function matchesThemeMode(value: string, mode: ThemeMode): boolean {
+  return (
+    value.includes(THEME_MODE_TOKENS[mode])
+    || value.endsWith(THEME_MODE_SUFFIXES[mode])
+    || value === mode
+  );
+}
+
+function titleCase(value: string): string {
+  return value
+    .split(/[-_\s]+/)
+    .filter(Boolean)
+    .map((token) => {
+      if (token.toLowerCase() === "solid") return "SolidX";
+      return token.charAt(0).toUpperCase() + token.slice(1);
+    })
+    .join(" ");
+}
+
+export function getThemeModeFromThemeKey(value?: string | null): ThemeMode | null {
+  const normalized = normalizeThemeKey(value);
+  if (!normalized) return null;
+
+  if (matchesThemeMode(normalized, "light")) return "light";
+  if (matchesThemeMode(normalized, "dark")) return "dark";
+
+  return null;
+}
+
+function createThemeDefinition(key: string, defaultTheme = false): AppThemeDefinition {
+  const mode = getThemeModeFromThemeKey(key);
+  if (!mode) {
+    throw new Error(`Invalid theme key: ${key}`);
+  }
+
+  return {
+    key,
+    label: titleCase(key),
+    mode,
+    default: defaultTheme,
+  };
+}
+
+function createDefaultTheme(mode: ThemeMode): AppThemeDefinition {
+  return createThemeDefinition(DEFAULT_THEME_KEYS[mode], true);
+}
+
+function groupThemesByMode(themes: AppThemeDefinition[], mode: ThemeMode): AppThemeDefinition[] {
+  return themes.filter((theme) => theme.mode === mode);
+}
+
+function pickDefaultThemeKey(themes: AppThemeDefinition[], mode: ThemeMode): string {
+  const themesForMode = groupThemesByMode(themes, mode);
+
+  return (
+    themesForMode.find((theme) => theme.default)?.key
+    ?? themesForMode[0]?.key
+    ?? DEFAULT_THEME_KEYS[mode]
+  );
+}
+
+function resolveThemeDirectory(): string | null {
+  const themeDirectory = path.resolve(process.cwd(), "..", "solid-ui", "public", "themes");
+  try {
+    if (fs.existsSync(themeDirectory) && fs.statSync(themeDirectory).isDirectory()) {
+      return path.resolve(themeDirectory);
+    }
+  } catch {
+    return null;
+  }
+
+  return null;
+}
+
+function isThemeDirectory(themeDirectory: string, entryName: string): boolean {
+  return fs.existsSync(path.join(themeDirectory, entryName, "theme.css"));
+}
+
+function readThemesFromPath(): AppThemeDefinition[] {
+  const themeDirectory = resolveThemeDirectory();
+  if (!themeDirectory) {
+    return [];
+  }
+
+  try {
+    const directoryEntries = fs.readdirSync(themeDirectory, { withFileTypes: true });
+
+    return directoryEntries
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => entry.name.trim())
+      .filter(Boolean)
+      .filter((entryName) => isThemeDirectory(themeDirectory, entryName))
+      .flatMap((entryName) => {
+        const mode = getThemeModeFromThemeKey(entryName);
+        if (!mode) return [];
+
+        return [createThemeDefinition(entryName, entryName === DEFAULT_THEME_KEYS[mode])];
+      })
+      .sort((left, right) => left.label.localeCompare(right.label));
+  } catch {
+    return [];
+  }
+}
+
+function getThemes(): AppThemeDefinition[] {
+  const discoveredThemes = readThemesFromPath();
+
+  if (discoveredThemes.length) {
+    return discoveredThemes;
+  }
+
+  return [createDefaultTheme("light"), createDefaultTheme("dark")];
+}
+
+export function getCoreThemes(): AppThemeDefinition[] {
+  return getThemes();
+}
+
+export function getRegisteredThemes(): AppThemeDefinition[] {
+  return getThemes();
+}
+
+export function getThemesByMode(mode: ThemeMode): AppThemeDefinition[] {
+  return groupThemesByMode(getRegisteredThemes(), mode);
+}
+
+export function getDefaultThemeKey(mode: ThemeMode = "light"): string {
+  return pickDefaultThemeKey(getRegisteredThemes(), mode);
+}
+
+export function isRegisteredThemeKey(value?: string | null, mode?: ThemeMode): value is string {
+  if (!value) return false;
+
+  return getRegisteredThemes().some((theme) => {
+    if (theme.key !== value) return false;
+    return mode ? theme.mode === mode : true;
+  });
+}

package/CLAUDE.md

@@ -1,26 +0,0 @@
-# This is the SolidX API project.
-This is included as a dependency in consuming projects.
-
-# SolidX UI
-# The corresponding UI project is at the below path:
- /Users/oswald/projects/Solid_Starters/solid-core-ui
-
-# SolidX Docs
-# The documentation project is at the below path:
-/Users/oswald/projects/solidxai-docs
-
-# SolidX Agent
-# The agent project which has the skills for helping users configure, build and use SolidX is at the below path:
-/Users/oswald/projects/Solid_Starters/agent
-
-# SolidX Control Plane Commands
-# The control plane commands for managing SolidX instances are in the below path:
-/Users/oswald/projects/Solid_Starters/solidctl
-
-# Testing reference project 
-# This is the reference library management project that is used for testing and development of SolidX features. It is located at the below path:
-/Users/oswald/projects/Solid_Starters/solid-library-management
-
-# Code Builder project
-# This is the project that contains the code builder which generates code based on user input and templates. It is located at the below path:
-/Users/oswald/projects/Solid_Starters/solid-code-builder