@next-vibe/checker 1.0.11 → 1.0.12

package/src/app/api/[locale]/system/unified-interface/shared/logger/file-logger.ts

@@ -0,0 +1,88 @@
+/**
+ * File Logger for MCP Mode
+ * Since MCP uses stdio for JSON-RPC communication, we can't use console.log
+ * This logger writes to a file instead for debugging purposes
+ */
+
+import type { LoggerMetadata } from "./endpoint";
+
+/**
+ * File logger configuration
+ */
+const DEBUG_DIR = ".vibe-debug";
+const DEBUG_FILE = "mcp-auth.log";
+
+/**
+ * Get debug file path
+ * Creates debug directory if it doesn't exist
+ */
+function getDebugFilePath(): string {
+  const { existsSync, mkdirSync, join } = require("node:fs");
+  // Use VIBE_PROJECT_ROOT if available, otherwise use cwd
+  const projectRoot = process.env.VIBE_PROJECT_ROOT || process.cwd();
+  const debugDir = join(projectRoot, DEBUG_DIR);
+
+  // Create debug directory if it doesn't exist
+  if (!existsSync(debugDir)) {
+    try {
+      mkdirSync(debugDir, { recursive: true });
+    } catch {
+      // Ignore errors - logging is best effort
+    }
+  }
+
+  return join(debugDir, DEBUG_FILE);
+}
+
+/**
+ * Write debug message to file
+ * This is used when MCP silent mode is enabled and console logging is disabled
+ */
+export function fileLog(
+  message: string,
+  data?: Record<string, LoggerMetadata>,
+): void {
+  // Only log if DEBUG_FILE_LOGGING is enabled
+  if (process.env.DEBUG_FILE_LOGGING !== "true") {
+    return;
+  }
+  const { appendFileSync } = require("node:fs");
+
+  try {
+    const timestamp = new Date().toISOString();
+    const logEntry = data
+      ? `[${timestamp}] ${message}\n${JSON.stringify(data, null, 2)}\n\n`
+      : `[${timestamp}] ${message}\n\n`;
+
+    const debugPath = getDebugFilePath();
+    appendFileSync(debugPath, logEntry, "utf-8");
+  } catch {
+    // Ignore errors - logging is best effort
+    // We can't log the error because we're in silent mode
+  }
+}
+
+/**
+ * Clear debug log file
+ * Useful at the start of a new session
+ */
+export function clearDebugLog(): void {
+  if (process.env.DEBUG_FILE_LOGGING !== "true") {
+    return;
+  }
+
+  try {
+    const debugPath = getDebugFilePath();
+    const fs = require("node:fs");
+    fs.writeFileSync(debugPath, "", "utf-8");
+  } catch {
+    // Ignore errors - logging is best effort
+  }
+}
+
+/**
+ * Get debug log file path for user display
+ */
+export function getDebugLogPath(): string {
+  return getDebugFilePath();
+}

package/src/app/api/[locale]/system/unified-interface/shared/logger/formatters.ts

@@ -0,0 +1,177 @@
+/**
+ * Log Message Formatters
+ * Provides consistent, beautiful formatting for different types of log messages
+ */
+
+import { bold, dim, maybeColorize, semantic } from "./colors";
+
+/**
+ * Format a startup message
+ */
+export function formatStartup(message: string, icon = "🚀"): string {
+  return `${icon} ${bold(message)}`;
+}
+
+/**
+ * Format a success message
+ */
+export function formatSuccess(message: string, icon = "✅"): string {
+  return `${icon} ${message}`;
+}
+
+/**
+ * Format an error message
+ */
+export function formatError(message: string, icon = "❌"): string {
+  return `${icon} ${maybeColorize(message, semantic.error)}`;
+}
+
+/**
+ * Format a warning message
+ */
+export function formatWarning(message: string, icon = "⚠️"): string {
+  return `${icon} ${maybeColorize(message, semantic.warning)}`;
+}
+
+/**
+ * Format an info message
+ */
+export function formatInfo(message: string, icon = "ℹ️"): string {
+  return `${icon} ${maybeColorize(message, semantic.info)}`;
+}
+
+/**
+ * Format a database message (cyan color for all DB operations)
+ */
+export function formatDatabase(message: string, icon = "🗄️"): string {
+  return `${icon} ${maybeColorize(message, semantic.database)}`;
+}
+
+/**
+ * Format a task message (magenta color for all task operations)
+ */
+export function formatTask(message: string, icon = "⚡"): string {
+  return `${icon} ${maybeColorize(message, semantic.task)}`;
+}
+
+/**
+ * Format a generator message
+ */
+export function formatGenerator(message: string, icon = "⚙️"): string {
+  return `${icon} ${maybeColorize(message, semantic.generator)}`;
+}
+
+/**
+ * Format a progress message
+ */
+export function formatProgress(message: string, icon = "⏳"): string {
+  return `${icon} ${maybeColorize(dim(message), semantic.muted)}`;
+}
+
+/**
+ * Format a skip message
+ */
+export function formatSkip(message: string, icon = "⏭️"): string {
+  return `${icon} ${maybeColorize(dim(message), semantic.muted)}`;
+}
+
+/**
+ * Format a config/settings message
+ */
+export function formatConfig(
+  key: string,
+  value: string | number | boolean,
+): string {
+  const formattedKey = key ? `${key}` : "";
+  const formattedValue = maybeColorize(bold(String(value)), semantic.success);
+  return key ? `${formattedKey}: ${formattedValue}` : formattedValue;
+}
+
+/**
+ * Format a duration (grey color)
+ */
+export function formatDuration(ms: number): string {
+  if (ms < 1000) {
+    return maybeColorize(`${ms}ms`, semantic.muted);
+  }
+  const seconds = (ms / 1000).toFixed(2);
+  return maybeColorize(`${seconds}s`, semantic.muted);
+}
+
+/**
+ * Format a count
+ */
+export function formatCount(
+  count: number,
+  singular: string,
+  plural?: string,
+): string {
+  const label = count === 1 ? singular : plural || `${singular}s`;
+  return `${maybeColorize(bold(String(count)), semantic.highlight)} ${maybeColorize(label, semantic.muted)}`;
+}
+
+/**
+ * Format a URL
+ */
+export function formatUrl(url: string): string {
+  return maybeColorize(url, semantic.accent);
+}
+
+/**
+ * Format a file path
+ */
+export function formatPath(path: string): string {
+  return maybeColorize(path, semantic.muted);
+}
+
+/**
+ * Format a separator line
+ */
+export function formatSeparator(char = "─", length = 50): string {
+  return maybeColorize(char.repeat(length), semantic.muted);
+}
+
+/**
+ * Format a section header
+ */
+export function formatSection(title: string): string {
+  return `\n${maybeColorize(bold(title), semantic.highlight)}\n${formatSeparator()}`;
+}
+
+/**
+ * Format a key-value pair
+ */
+export function formatKeyValue(
+  key: string,
+  value: string | number | boolean,
+): string {
+  return `${maybeColorize(key, semantic.muted)}: ${maybeColorize(bold(String(value)), semantic.highlight)}`;
+}
+
+/**
+ * Format a list item
+ */
+export function formatListItem(item: string, icon = "•"): string {
+  return `  ${maybeColorize(icon, semantic.muted)} ${item}`;
+}
+
+/**
+ * Format a command suggestion
+ */
+export function formatCommand(command: string): string {
+  return maybeColorize(command, semantic.accent);
+}
+
+/**
+ * Format a hint/help text (grey color, no dim)
+ */
+export function formatHint(text: string): string {
+  return maybeColorize(text, semantic.muted);
+}
+
+/**
+ * Format an action with a command (e.g., "Started PostgreSQL using: 'command'")
+ */
+export function formatActionCommand(action: string, command: string): string {
+  return `${action} ${maybeColorize(`'${command}'`, semantic.muted)}`;
+}

package/src/app/api/[locale]/system/unified-interface/shared/server-only/auth/base-auth-handler.ts

@@ -0,0 +1,82 @@
+import "server-only";
+
+import type { ResponseType } from "next-vibe/shared/types/response.schema";
+
+import type { JwtPayloadType } from "@/app/api/[locale]/user/auth/types";
+import type { CountryLanguage } from "@/i18n/core/config";
+
+import type { EndpointLogger } from "../../logger/endpoint";
+import type { Platform } from "../../types/platform";
+
+/**
+ * Authentication context passed to platform handlers
+ */
+export interface AuthContext {
+  platform: Platform;
+  token?: string;
+  jwtPayload?: JwtPayloadType;
+  locale: CountryLanguage;
+}
+
+/**
+ * Session data structure for CLI/MCP platforms
+ */
+export interface SessionData {
+  token: string;
+  userId: string;
+  leadId: string;
+  expiresAt: string;
+  createdAt: string;
+}
+
+/**
+ * Base Authentication Handler
+ * Platform-specific storage handlers ONLY
+ *
+ * ARCHITECTURE:
+ * - Platform handlers: ONLY handle storage (cookies, session files, AsyncStorage)
+ * - AuthRepository: Contains ALL authentication business logic
+ *
+ * Platform implementations:
+ * - Web: Uses Next.js cookies for session storage
+ * - CLI/MCP: Uses .vibe.session file for JWT storage
+ * - Native: Uses AsyncStorage for session storage
+ *
+ * All business logic (user/lead management, token verification, authentication flows)
+ * is in @/app/api/[locale]/user/auth/repository.ts
+ */
+export abstract class BaseAuthHandler {
+  /**
+   * Get authentication token from platform-specific storage
+   * Web: Reads from cookies and Authorization header
+   * CLI/MCP: Reads from .vibe.session file and Authorization header
+   * Native: Reads from AsyncStorage
+   */
+  abstract getStoredAuthToken(
+    context: AuthContext,
+    logger: EndpointLogger,
+  ): Promise<string | undefined>;
+
+  /**
+   * Store authentication token in platform-specific storage
+   * Web: Sets HTTP-only cookies
+   * CLI/MCP: Writes to .vibe.session file
+   * Native: Writes to AsyncStorage
+   * @param rememberMe - If true, session cookie lasts 30 days; if false, session-only (browser session)
+   */
+  abstract storeAuthToken(
+    token: string,
+    userId: string,
+    leadId: string,
+    logger: EndpointLogger,
+    rememberMe?: boolean,
+  ): Promise<ResponseType<void>>;
+
+  /**
+   * Clear authentication token from platform-specific storage
+   * Web: Clears cookies
+   * CLI/MCP: Deletes .vibe.session file
+   * Native: Clears AsyncStorage
+   */
+  abstract clearAuthToken(logger: EndpointLogger): Promise<ResponseType<void>>;
+}

package/src/app/api/[locale]/system/unified-interface/shared/server-only/auth/factory.ts

@@ -0,0 +1,33 @@
+import "server-only";
+
+import { cliAuthHandler } from "../../../cli/auth/cli-handler";
+import { Platform } from "../../types/platform";
+import type { BaseAuthHandler } from "./base-auth-handler";
+
+/**
+ * Platform Authentication Handler Factory
+ * Returns the appropriate auth handler based on platform
+ *
+ * Platform mapping:
+ * - TRPC, NEXT_PAGE, NEXT_API -> WebAuthHandler (cookies)
+ * - CLI, CLI_PACKAGE, AI, MCP -> CliAuthHandler (.vibe.session file)
+ */
+export function getPlatformAuthHandler(platform: Platform): BaseAuthHandler {
+  switch (platform) {
+    case Platform.CLI:
+    case Platform.CLI_PACKAGE:
+    case Platform.MCP:
+      return cliAuthHandler;
+    case Platform.TRPC:
+    case Platform.NEXT_PAGE:
+    case Platform.NEXT_API:
+    case Platform.AI:
+      throw new Error("WebAuthHandler not implemented");
+
+    default: {
+      const _exhaustiveCheck: never = platform;
+      // eslint-disable-next-line oxlint-plugin-restricted/restricted-syntax, i18next/no-literal-string -- Auth factory exhaustiveness check requires throwing for unsupported platforms
+      throw new Error(`Unsupported platform: ${String(_exhaustiveCheck)}`);
+    }
+  }
+}

package/src/app/api/[locale]/system/unified-interface/shared/server-only/server-only.ts

@@ -0,0 +1,4 @@
+// on expo we skip bundling server-only files
+if (process.env.NODE_ENV !== "test") {
+  void import("server-only");
+}

package/src/app/api/[locale]/system/unified-interface/shared/types/actions.ts

@@ -0,0 +1,289 @@
+/**
+ * Action System for Definition-Driven UI
+ *
+ * This system allows defining actions directly on fields and widgets,
+ * providing a declarative way to handle user interactions across all interface contexts.
+ */
+
+import type { Route } from "next";
+
+import type { TranslationKey } from "@/i18n/core/static-types";
+
+import type { ActionType, ComponentVariant, InterfaceContext } from "./enums";
+
+/**
+ * Action execution timing
+ */
+export enum ActionTiming {
+  IMMEDIATE = "immediate",
+  DEBOUNCED = "debounced",
+  THROTTLED = "throttled",
+  DELAYED = "delayed",
+}
+
+/**
+ * Action execution priority
+ */
+export enum ActionPriority {
+  LOW = 0,
+  NORMAL = 1,
+  HIGH = 2,
+  CRITICAL = 3,
+}
+
+/**
+ * Action condition for conditional execution
+ */
+export interface ActionCondition {
+  field: string;
+  operator:
+    | "equals"
+    | "not_equals"
+    | "contains"
+    | "not_contains"
+    | "exists"
+    | "not_exists"
+    | "greater_than"
+    | "less_than";
+  value?: string | number | boolean;
+}
+
+/**
+ * Base action configuration
+ */
+export interface BaseActionConfig {
+  type: ActionType;
+  timing?: ActionTiming;
+  priority?: ActionPriority;
+  delay?: number;
+  dependencies?: string[];
+  conditions?: ActionCondition[];
+  contexts?: InterfaceContext[]; // Which contexts this action applies to
+}
+
+/**
+ * Toast/Notification action configuration
+ */
+export interface ToastActionConfig extends BaseActionConfig {
+  type: ActionType.TOAST | ActionType.NOTIFICATION | ActionType.ALERT;
+  message: TranslationKey;
+  variant?: ComponentVariant;
+  duration?: number;
+  title?: TranslationKey;
+  description?: TranslationKey;
+  action?: {
+    label: TranslationKey;
+    onClick: () => void;
+  };
+}
+
+/**
+ * Navigation action configuration
+ */
+export interface NavigationActionConfig extends BaseActionConfig {
+  type:
+    | ActionType.ROUTER_PUSH
+    | ActionType.ROUTER_REPLACE
+    | ActionType.ROUTER_BACK
+    | ActionType.REDIRECT;
+  path?: string;
+  route?: Route;
+  params?: Record<string, string>;
+  query?: Record<string, string>;
+  replace?: boolean;
+  external?: boolean;
+}
+
+/**
+ * Data/Cache action configuration
+ */
+export interface RefetchActionConfig extends BaseActionConfig {
+  type:
+    | ActionType.REFETCH
+    | ActionType.INVALIDATE_CACHE
+    | ActionType.UPDATE_CACHE
+    | ActionType.CLEAR_CACHE;
+  queryKeys?: string[][];
+  exact?: boolean;
+  predicate?: (query: Record<string, string | number | boolean>) => boolean;
+  data?: Record<string, string | number | boolean>;
+}
+
+/**
+ * Form action configuration
+ */
+export interface FormActionConfig extends BaseActionConfig {
+  type:
+    | ActionType.RESET_FORM
+    | ActionType.CLEAR_FORM
+    | ActionType.SET_FORM_VALUES
+    | ActionType.FOCUS_FIELD;
+  formId?: string;
+  values?:
+    | Record<string, string | number | boolean>
+    | ((context: ActionContext) => Record<string, string | number | boolean>);
+  fieldName?: string;
+  resetToDefaults?: boolean;
+}
+
+/**
+ * State action configuration
+ */
+export interface StateActionConfig extends BaseActionConfig {
+  type:
+    | ActionType.SET_STATE
+    | ActionType.TOGGLE_STATE
+    | ActionType.UPDATE_STATE;
+  key: string;
+  value?: string | number | boolean;
+  updater?: (current: string | number | boolean) => string | number | boolean;
+}
+
+/**
+ * Custom action configuration
+ */
+export interface CustomActionConfig extends BaseActionConfig {
+  type: ActionType.CUSTOM;
+  handler: string | ((context: ActionContext) => Promise<ActionResult>);
+  payload?: Record<string, string | number | boolean>;
+}
+
+/**
+ * Union type for all action configurations
+ */
+export type ActionConfig =
+  | ToastActionConfig
+  | NavigationActionConfig
+  | RefetchActionConfig
+  | FormActionConfig
+  | StateActionConfig
+  | CustomActionConfig;
+
+/**
+ * Lifecycle actions for endpoints and widgets
+ */
+export interface LifecycleActions {
+  onSuccess?: ActionConfig[];
+  onError?: ActionConfig[];
+  onLoading?: ActionConfig[];
+  onComplete?: ActionConfig[];
+  onMount?: ActionConfig[];
+  onUnmount?: ActionConfig[];
+}
+
+/**
+ * Interactive actions for buttons and clickable elements
+ */
+export interface InteractiveActions {
+  onClick?: ActionConfig[];
+  onDoubleClick?: ActionConfig[];
+  onHover?: ActionConfig[];
+  onFocus?: ActionConfig[];
+  onBlur?: ActionConfig[];
+}
+
+/**
+ * Form field actions
+ */
+export interface FieldActions {
+  onChange?: ActionConfig[];
+  onValidation?: ActionConfig[];
+  onError?: ActionConfig[];
+  onClear?: ActionConfig[];
+}
+
+/**
+ * Action execution context
+ */
+export interface ActionContext {
+  context: InterfaceContext;
+  data?: Record<string, string | number | boolean>;
+  error?: Error;
+  endpoint?: Record<string, string | number | boolean>;
+  timestamp: string;
+  user: {
+    id: string;
+    roles: string[];
+  };
+  metadata?: Record<string, string | number | boolean>;
+  formValues?: Record<string, string | number | boolean>;
+  fieldValue?: string | number | boolean;
+}
+
+/**
+ * Action execution result
+ */
+export interface ActionResult {
+  success: boolean;
+  data?: Record<string, string | number | boolean>;
+  error?: string;
+  metadata?: Record<string, string | number | boolean>;
+}
+
+/**
+ * Action executor interface
+ */
+export interface ActionExecutor {
+  context: InterfaceContext;
+  canExecute(action: ActionConfig, context: ActionContext): boolean;
+  execute(action: ActionConfig, context: ActionContext): Promise<ActionResult>;
+}
+
+/**
+ * Action chain configuration for complex workflows
+ */
+export interface ActionChain {
+  actions: ActionConfig[];
+  parallel?: boolean;
+  stopOnError?: boolean;
+  timeout?: number;
+}
+
+/**
+ * Action preset for common patterns
+ */
+export interface ActionPreset {
+  name: string;
+  description: TranslationKey;
+  actions: ActionConfig[];
+  contexts?: InterfaceContext[];
+}
+
+/**
+ * Button action configuration for UI elements
+ */
+export interface ButtonAction {
+  label: TranslationKey;
+  icon?: string;
+  variant?: ComponentVariant;
+  size?: "sm" | "md" | "lg";
+  actions: ActionConfig[];
+  conditions?: ActionCondition[];
+  disabled?: boolean;
+  loading?: boolean;
+}
+
+/**
+ * Context menu action configuration
+ */
+export interface ContextMenuAction {
+  label: TranslationKey;
+  icon?: string;
+  actions: ActionConfig[];
+  separator?: boolean;
+  disabled?: boolean;
+  dangerous?: boolean;
+}
+
+/**
+ * Bulk action configuration for data tables
+ */
+export interface BulkAction {
+  label: TranslationKey;
+  icon?: string;
+  variant?: ComponentVariant;
+  actions: ActionConfig[];
+  confirmationMessage?: TranslationKey;
+  requiresSelection?: boolean;
+  maxSelection?: number;
+}