te.js 2.1.6 → 2.2.1

package/utils/errors-llm-config.js

@@ -5,6 +5,9 @@
  */
 
 import { env } from 'tej-env';
+import TejLogger from 'tej-logger';
+
+const logger = new TejLogger('Tejas.ErrorsLlm');
 
 const MESSAGE_TYPES = /** @type {const} */ (['endUser', 'developer']);
 const LLM_MODES = /** @type {const} */ (['sync', 'async']);
@@ -65,6 +68,7 @@ function normalizeChannel(v) {
  *   rateLimit: number,
  *   cache: boolean,
  *   cacheTTL: number,
+ *   verifyOnStart: boolean,
  * }}
  */
 export function getErrorsLlmConfig() {
@@ -134,7 +138,14 @@ export function getErrorsLlmConfig() {
       ? 3600000
       : cacheTTLNum;
 
-  return {
+  const verifyOnStartRaw = env('ERRORS_LLM_VERIFY_ON_START') ?? '';
+  const verifyOnStart =
+    verifyOnStartRaw === true ||
+    verifyOnStartRaw === 'true' ||
+    verifyOnStartRaw === '1' ||
+    verifyOnStartRaw === 1;
+
+  return Object.freeze({
     enabled: Boolean(enabled),
     baseURL: String(baseURL ?? '').trim(),
     apiKey: String(apiKey ?? '').trim(),
@@ -147,11 +158,66 @@ export function getErrorsLlmConfig() {
     rateLimit,
     cache,
     cacheTTL,
-  };
+    verifyOnStart,
+  });
 }
 
 export { MESSAGE_TYPES, LLM_MODES, LLM_CHANNELS };
 
+/**
+ * Fire a lightweight probe to the configured LLM provider and verify it
+ * responds correctly. Intended to run once at takeoff when `verifyOnStart: true`.
+ *
+ * Never throws — a flaky provider does not prevent the server from starting.
+ *
+ * @returns {Promise<{ ok: boolean, status: { feature: string, ok: boolean, detail: string } }>}
+ */
+export async function verifyLlmConnection() {
+  const { baseURL, apiKey, model, timeout, mode } = getErrorsLlmConfig();
+
+  const { createProvider } = await import('../lib/llm/index.js');
+  const provider = createProvider({ baseURL, apiKey, model, timeout });
+
+  const shortModel = model.split('/').pop().split(':')[0] || model;
+  const start = Date.now();
+  try {
+    const { content } = await provider.analyze(
+      'Respond with only the JSON object {"status":"ok"}. No explanation.',
+    );
+    const elapsed = Date.now() - start;
+
+    if (content.includes('"ok"')) {
+      return {
+        ok: true,
+        status: {
+          feature: 'LLM Errors',
+          ok: true,
+          detail: `verified (${shortModel}, ${elapsed}ms, mode: ${mode})`,
+        },
+      };
+    }
+
+    return {
+      ok: false,
+      status: {
+        feature: 'LLM Errors',
+        ok: false,
+        detail: `unexpected response from ${shortModel} (${elapsed}ms)`,
+      },
+    };
+  } catch (err) {
+    const elapsed = Date.now() - start;
+    return {
+      ok: false,
+      status: {
+        feature: 'LLM Errors',
+        ok: false,
+        detail: `${err.message} (${elapsed}ms)`,
+      },
+    };
+  }
+}
+
 /**
  * Validate errors.llm when enabled: require baseURL, apiKey, and model (after LLM_ fallback).
  * Also warns about misconfigurations (e.g. channel set with sync mode).
@@ -187,8 +253,8 @@ export function validateErrorsLlmAtTakeoff() {
     env('ERRORS_LLM_CHANNEL') ?? env('LLM_CHANNEL') ?? '',
   ).trim();
   if (mode === 'sync' && channelRaw) {
-    console.warn(
-      `[Tejas] errors.llm: channel="${channel}" is set but mode is "sync" — channel output only applies in async mode. Set ERRORS_LLM_MODE=async to use it.`,
+    logger.warn(
+      `errors.llm: channel="${channel}" is set but mode is "sync" — channel output only applies in async mode. Set ERRORS_LLM_MODE=async to use it.`,
     );
   }
 
@@ -200,15 +266,15 @@ export function validateErrorsLlmAtTakeoff() {
     rateLimitRaw &&
     (isNaN(Number(rateLimitRaw)) || Number(rateLimitRaw) <= 0)
   ) {
-    console.warn(
-      `[Tejas] errors.llm: rateLimit value "${rateLimitRaw}" is invalid; defaulting to 10.`,
+    logger.warn(
+      `errors.llm: rateLimit value "${rateLimitRaw}" is invalid; defaulting to 10.`,
     );
   }
 
   const cacheTTLRaw = String(env('ERRORS_LLM_CACHE_TTL') ?? '').trim();
   if (cacheTTLRaw && (isNaN(Number(cacheTTLRaw)) || Number(cacheTTLRaw) <= 0)) {
-    console.warn(
-      `[Tejas] errors.llm: cacheTTL value "${cacheTTLRaw}" is invalid; defaulting to 3600000.`,
+    logger.warn(
+      `errors.llm: cacheTTL value "${cacheTTLRaw}" is invalid; defaulting to 3600000.`,
     );
   }
 }

package/utils/request-logger.js

@@ -5,11 +5,46 @@ import TejLogger from 'tej-logger';
 const logger = new TejLogger('Tejas.Request');
 const { italic, bold, blue, white, bgGreen, bgRed, whiteBright } = ansi;
 
+/**
+ * Best-effort field names to mask when logging request/response bodies to the
+ * console.  This is a hardcoded safety net — it does not replace the
+ * non-bypassable scrubbing enforced by the Radar collector on telemetry data.
+ */
+const CONSOLE_MASK_FIELDS = new Set([
+  'password',
+  'passwd',
+  'secret',
+  'token',
+  'authorization',
+  'api_key',
+  'apikey',
+]);
+
+/**
+ * Recursively mask sensitive fields in a value for safe console output.
+ * Replaces matched key values with `"*"`.
+ *
+ * @param {unknown} value
+ * @returns {unknown}
+ */
+function maskForLog(value) {
+  if (value === null || typeof value !== 'object') return value;
+  if (Array.isArray(value)) return value.map(maskForLog);
+
+  const result = Object.create(null);
+  for (const [k, v] of Object.entries(value)) {
+    result[k] = CONSOLE_MASK_FIELDS.has(k.toLowerCase()) ? '*' : maskForLog(v);
+  }
+  return result;
+}
+
 function logHttpRequest(ammo, next) {
   if (!env('LOG_HTTP_REQUESTS')) return;
 
   const startTime = new Date();
-  ammo.res.on('finish', () => {
+  const controller = new AbortController();
+  ammo.res.on('finish', { signal: controller.signal }, () => {
+    controller.abort();
     const res = ammo.res;
     const method = italic(whiteBright(ammo.method));
     const endpoint = bold(ammo.endpoint);
@@ -19,10 +54,21 @@ function logHttpRequest(ammo, next) {
         : bgGreen(whiteBright(bold(`✔ ${res.statusCode}`)));
 
     const duration = white(`${new Date() - startTime}ms`);
+
+    const maskedPayload = maskForLog(ammo.payload);
     const payload = `${blue('Request')}: ${white(
-      JSON.stringify(ammo.payload),
+      JSON.stringify(maskedPayload),
     )}`;
-    const dispatchedData = `${blue('Response')}: ${white(ammo.dispatchedData)}`;
+
+    let maskedResponse = ammo.dispatchedData;
+    try {
+      maskedResponse = JSON.stringify(
+        maskForLog(JSON.parse(ammo.dispatchedData)),
+      );
+    } catch {
+      // Non-JSON response — log as-is
+    }
+    const dispatchedData = `${blue('Response')}: ${white(maskedResponse)}`;
     const nextLine = '\n';
 
     logger.log(

package/utils/startup.js

@@ -0,0 +1,80 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { readFile } from 'node:fs/promises';
+
+/**
+ * Read the framework's own package.json version.
+ * Resolves relative to the framework source, not the user's app.
+ * @returns {Promise<string>}
+ */
+export async function readFrameworkVersion() {
+  try {
+    const dir = path.dirname(fileURLToPath(import.meta.url));
+    const raw = await readFile(path.join(dir, '..', 'package.json'), 'utf8');
+    return JSON.parse(raw).version ?? 'unknown';
+  } catch {
+    return 'unknown';
+  }
+}
+
+/** Format milliseconds into a compact human-readable string. */
+export function fmtMs(ms) {
+  return ms >= 1000 ? `${(ms / 1000).toFixed(1)}s` : `${Math.round(ms)}ms`;
+}
+
+const SPINNER = [
+  '\u280B',
+  '\u2819',
+  '\u2839',
+  '\u2838',
+  '\u283C',
+  '\u2834',
+  '\u2826',
+  '\u2827',
+  '\u2807',
+  '\u280F',
+];
+
+/**
+ * Create a live status line writer for startup progress.
+ * On TTY terminals, shows a spinning animation that gets overwritten in-place
+ * when the step completes. On non-TTY (piped, CI), only prints the final result.
+ * @param {boolean} isTTY
+ */
+export function statusLine(isTTY) {
+  let timer = null;
+
+  function stop() {
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+  }
+
+  return {
+    start(feature, message) {
+      if (!isTTY) return;
+      let frame = 0;
+      const render = () => {
+        const s = SPINNER[frame % SPINNER.length];
+        process.stdout.write(
+          `\r\x1b[K  ${feature.padEnd(14)}  \x1b[36m${s}\x1b[0m  \x1b[2m${message}\x1b[0m`,
+        );
+        frame++;
+      };
+      render();
+      timer = setInterval(render, 80);
+    },
+    finish(feature, ok, detail) {
+      stop();
+      if (isTTY) process.stdout.write('\r\x1b[K');
+      const icon =
+        ok === true
+          ? '\x1b[32m\u2713\x1b[0m'
+          : ok === false
+            ? '\x1b[31m\u2717\x1b[0m'
+            : '\x1b[2m\u2014\x1b[0m';
+      process.stdout.write(`  ${feature.padEnd(14)}  ${icon}  ${detail}\n`);
+    },
+  };
+}

package/database/index.js

@@ -1,165 +0,0 @@
-import redis from './redis.js';
-import mongodb from './mongodb.js';
-import TejError from '../server/error.js';
-import TejLogger from 'tej-logger';
-
-const logger = new TejLogger('DatabaseManager');
-
-class DatabaseManager {
-  static #instance = null;
-  static #isInitializing = false;
-
-  // Enhanced connection tracking with metadata
-  #connections = new Map();
-  #initializingConnections = new Map();
-
-  // Helper method for sleeping
-  async #sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-
-  constructor() {
-    if (DatabaseManager.#instance) {
-      return DatabaseManager.#instance;
-    }
-
-    if (!DatabaseManager.#isInitializing) {
-      throw new TejError(
-        500,
-        'Use DatabaseManager.getInstance() to get the instance',
-      );
-    }
-
-    DatabaseManager.#isInitializing = false;
-    DatabaseManager.#instance = this;
-  }
-
-  static getInstance() {
-    if (!DatabaseManager.#instance) {
-      DatabaseManager.#isInitializing = true;
-      DatabaseManager.#instance = new DatabaseManager();
-    }
-    return DatabaseManager.#instance;
-  }
-
-  async initializeConnection(dbType, config) {
-    const key = dbType.toLowerCase();
-
-    // If a connection already exists for this config, return it
-    if (this.#connections.has(key)) {
-      return this.#connections.get(key).client;
-    }
-
-    // Set initializing flag
-    this.#initializingConnections.set(key, true);
-
-    let client;
-    try {
-      switch (key) {
-        case 'redis':
-          client = await redis.createConnection({
-            isCluster: config.isCluster || false,
-            options: config || {},
-          });
-          break;
-        case 'mongodb':
-          client = await mongodb.createConnection(config);
-          break;
-        default:
-          throw new TejError(400, `Unsupported database type: ${dbType}`);
-      }
-
-      this.#connections.set(key, {
-        type: dbType,
-        client,
-        config,
-      });
-
-      // Clear initializing flag
-      this.#initializingConnections.delete(key);
-
-      return client;
-    } catch (error) {
-      // Clear initializing flag on error
-      this.#initializingConnections.delete(key);
-      logger.error(`Failed to initialize ${dbType} connection:`, error);
-      throw error;
-    }
-  }
-
-  getConnection(dbType) {
-    const key = dbType.toLowerCase();
-    const connection = this.#connections.get(key);
-    if (!connection) {
-      throw new TejError(
-        404,
-        `No connection found for ${dbType} with given config`,
-      );
-    }
-    return connection.client;
-  }
-
-  async closeConnection(dbType, config) {
-    const key = dbType.toLowerCase();
-    if (!this.#connections.has(key)) {
-      return;
-    }
-
-    try {
-      const connection = this.#connections.get(key);
-      switch (key) {
-        case 'redis':
-          await redis.closeConnection(connection.client);
-          break;
-        case 'mongodb':
-          await mongodb.closeConnection(connection.client);
-          break;
-      }
-
-      this.#connections.delete(key);
-    } catch (error) {
-      logger.error(`Error closing ${dbType} connection:`, error);
-      throw error;
-    }
-  }
-
-  /**
-   * Close all database connections
-   * @returns {Promise<void>}
-   */
-  async closeAllConnections() {
-    const closePromises = [];
-    for (const [key, connection] of this.#connections) {
-      closePromises.push(
-        this.closeConnection(connection.type, connection.config),
-      );
-    }
-    await Promise.all(closePromises);
-    this.#connections.clear();
-  }
-
-  /**
-   * Get all active connections
-   * @returns {Map<string, {type: string, client: any, config: Object}>}
-   */
-  getActiveConnections() {
-    return new Map(this.#connections);
-  }
-
-  /**
-   * Check if a connection exists or is being initialized
-   * @param {string} dbType - Type of database
-   * @param {Object} config - Database configuration
-   * @returns {{ exists: boolean, initializing: boolean }}
-   */
-  hasConnection(dbType, config) {
-    const key = dbType.toLowerCase();
-    return {
-      exists: this.#connections.has(key),
-      initializing: this.#initializingConnections.has(key),
-    };
-  }
-}
-
-const dbManager = DatabaseManager.getInstance();
-export default dbManager;

package/database/mongodb.js

@@ -1,146 +0,0 @@
-import { spawn } from 'child_process';
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import TejLogger from 'tej-logger';
-import TejError from '../server/error.js';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-const logger = new TejLogger('MongoDBConnectionManager');
-
-function checkMongooseInstallation() {
-  const packageJsonPath = path.join(__dirname, '..', 'package.json');
-  const nodeModulesPath = path.join(
-    __dirname,
-    '..',
-    'node_modules',
-    'mongoose',
-  );
-
-  try {
-    // Check if mongoose exists in package.json
-    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-    const inPackageJson = !!packageJson.dependencies?.mongoose;
-
-    // Check if mongoose exists in node_modules
-    const inNodeModules = fs.existsSync(nodeModulesPath);
-
-    return {
-      needsInstall: !inPackageJson || !inNodeModules,
-      reason: !inPackageJson
-        ? 'not in package.json'
-        : !inNodeModules
-          ? 'not in node_modules'
-          : null,
-    };
-  } catch (error) {
-    return { needsInstall: true, reason: 'error checking installation' };
-  }
-}
-
-function installMongooseSync() {
-  const spinner = ['|', '/', '-', '\\'];
-  let current = 0;
-  let intervalId;
-
-  try {
-    const { needsInstall, reason } = checkMongooseInstallation();
-
-    if (!needsInstall) {
-      return true;
-    }
-
-    // Start the spinner
-    intervalId = setInterval(() => {
-      process.stdout.write(`\r${spinner[current]} Installing mongoose...`);
-      current = (current + 1) % spinner.length;
-    }, 100);
-
-    logger.info(`Tejas will install mongoose (${reason})...`);
-
-    const command = process.platform === 'win32' ? 'npm.cmd' : 'npm';
-    const result = spawn.sync(command, ['install', 'mongoose'], {
-      stdio: 'inherit',
-      shell: true,
-    });
-
-    process.stdout.write('\r');
-    clearInterval(intervalId);
-
-    if (result.status === 0) {
-      logger.info('Mongoose installed successfully');
-      return true;
-    } else {
-      logger.error('Mongoose installation failed');
-      return false;
-    }
-  } catch (error) {
-    if (intervalId) {
-      process.stdout.write('\r');
-      clearInterval(intervalId);
-    }
-    logger.error('Error installing mongoose:', error);
-    return false;
-  }
-}
-
-/**
- * Create a new MongoDB connection
- * @param {Object} config - MongoDB configuration
- * @param {string} config.uri - MongoDB connection URI
- * @param {Object} [config.options={}] - Additional Mongoose options
- * @returns {Promise<mongoose.Connection>} Mongoose connection instance
- */
-async function createConnection(config) {
-  const { needsInstall } = checkMongooseInstallation();
-
-  if (needsInstall) {
-    const installed = installMongooseSync();
-    if (!installed) {
-      throw new TejError(500, 'Failed to install required mongoose package');
-    }
-  }
-
-  const { uri, options = {} } = config;
-
-  try {
-    const mongoose = await import('mongoose').then((mod) => mod.default);
-    const connection = await mongoose.createConnection(uri, options);
-
-    connection.on('error', (err) =>
-      logger.error(`MongoDB connection error:`, err),
-    );
-    connection.on('connected', () => {
-      logger.info(`MongoDB connected to ${uri}`);
-    });
-    connection.on('disconnected', () => {
-      logger.info(`MongoDB disconnected from ${uri}`);
-    });
-
-    return connection;
-  } catch (error) {
-    logger.error(`Failed to create MongoDB connection:`, error);
-    throw new TejError(
-      500,
-      `Failed to create MongoDB connection: ${error.message}`,
-    );
-  }
-}
-
-/**
- * Close a MongoDB connection
- * @param {mongoose.Connection} connection - Mongoose connection to close
- * @returns {Promise<void>}
- */
-async function closeConnection(connection) {
-  if (connection) {
-    await connection.close();
-  }
-}
-
-export default {
-  createConnection,
-  closeConnection,
-};