create-jen-app 1.2.3 → 1.2.4

package/templates/static/lib/shared/log.js

@@ -1,20 +1,13 @@
-/*
- * This file is part of Jen.js.
- * Copyright (C) 2026 oopsio
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <https://www.gnu.org/licenses/>.
- */
+// ANSI color codes
+const colors = {
+  reset: "\x1b[0m",
+  dim: "\x1b[2m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  red: "\x1b[31m",
+  cyan: "\x1b[36m",
+  bold: "\x1b[1m",
+};
 /**
  * Get current timestamp in ISO 8601 format.
  * Used to prefix all log messages with precise UTC time information for debugging and monitoring.
@@ -54,7 +47,9 @@ export const log = {
    * @example log.info("Server running on port 3000");
    */
   info(msg) {
-    console.log(`[${ts()}] [INFO] ${msg}`);
+    console.log(
+      `${colors.dim}[${ts()}]${colors.reset} ${colors.cyan}[INFO]${colors.reset} ${msg}`,
+    );
   },
   /**
    * Logs a warning message with timestamp and [WARN] prefix.
@@ -65,7 +60,9 @@ export const log = {
    * @example log.warn("Configuration file not found, using defaults");
    */
   warn(msg) {
-    console.warn(`[${ts()}] [WARN] ${msg}`);
+    console.warn(
+      `${colors.dim}[${ts()}]${colors.reset} ${colors.yellow}[WARN]${colors.reset} ${msg}`,
+    );
   },
   /**
    * Logs an error message with timestamp and [ERROR] prefix.
@@ -76,6 +73,8 @@ export const log = {
    * @example log.error("Failed to compile SCSS: syntax error on line 42");
    */
   error(msg) {
-    console.error(`[${ts()}] [ERROR] ${msg}`);
+    console.error(
+      `${colors.dim}[${ts()}]${colors.reset} ${colors.red}[ERROR]${colors.reset} ${msg}`,
+    );
   },
 };

package/templates/static/lib/telemetry/api/rate-limiter.js

@@ -0,0 +1,32 @@
+/**
+ * Rate limiter for telemetry API
+ * Limits requests per IP address
+ */
+class RateLimiter {
+  store = new Map();
+  limit = 10;
+  windowMs = 60 * 1000; // 60 seconds
+  check(ip) {
+    const now = Date.now();
+    const entry = this.store.get(ip);
+    // Reset if window has expired
+    if (!entry || now > entry.resetTime) {
+      this.store.set(ip, {
+        count: 1,
+        resetTime: now + this.windowMs,
+      });
+      return true;
+    }
+    // Check if limit exceeded
+    if (entry.count >= this.limit) {
+      return false;
+    }
+    // Increment and allow
+    entry.count++;
+    return true;
+  }
+  reset() {
+    this.store.clear();
+  }
+}
+export const rateLimiter = new RateLimiter();

package/templates/static/lib/telemetry/api/validator.js

@@ -0,0 +1,67 @@
+/**
+ * Telemetry payload validator
+ */
+const MAX_STRING_LENGTH = 50;
+const MAX_EVENTS = 100;
+export function validatePayload(payload) {
+  // Handle array of events
+  if (Array.isArray(payload)) {
+    if (payload.length === 0) {
+      return { valid: false, error: "Event array cannot be empty" };
+    }
+    if (payload.length > MAX_EVENTS) {
+      return {
+        valid: false,
+        error: `Too many events (max ${MAX_EVENTS})`,
+      };
+    }
+    // Validate each event
+    for (const event of payload) {
+      const result = validateEvent(event);
+      if (!result.valid) {
+        return result;
+      }
+    }
+    return { valid: true };
+  }
+  // Handle single event
+  return validateEvent(payload);
+}
+function validateEvent(event) {
+  if (typeof event !== "object" || event === null) {
+    return { valid: false, error: "Event must be an object" };
+  }
+  const obj = event;
+  // Required fields
+  if (typeof obj.framework !== "string") {
+    return { valid: false, error: "Missing or invalid framework field" };
+  }
+  if (typeof obj.version !== "string") {
+    return { valid: false, error: "Missing or invalid version field" };
+  }
+  // Validate string lengths
+  if (obj.framework.length > MAX_STRING_LENGTH) {
+    return {
+      valid: false,
+      error: `framework exceeds max length of ${MAX_STRING_LENGTH}`,
+    };
+  }
+  if (obj.version.length > MAX_STRING_LENGTH) {
+    return {
+      valid: false,
+      error: `version exceeds max length of ${MAX_STRING_LENGTH}`,
+    };
+  }
+  // Optional string fields
+  for (const field of ["command", "os", "error"]) {
+    if (field in obj && typeof obj[field] === "string") {
+      if (obj[field].length > MAX_STRING_LENGTH) {
+        return {
+          valid: false,
+          error: `${field} exceeds max length of ${MAX_STRING_LENGTH}`,
+        };
+      }
+    }
+  }
+  return { valid: true };
+}

package/templates/static/lib/telemetry/client.js

@@ -0,0 +1,121 @@
+/**
+ * Jen.js Telemetry Client
+ *
+ * Collects telemetry events and sends them in batches.
+ * Usage:
+ *   telemetry.track({ command: 'dev', os: 'win32' });
+ *   // Events are sent automatically every 15 seconds or when batch is full
+ */
+import { platform } from "os";
+class TelemetryClient {
+  endpoint;
+  batchSize;
+  batchInterval;
+  disabled;
+  queue = [];
+  flushTimer = null;
+  version;
+  constructor(version, options = {}) {
+    this.version = version;
+    this.endpoint =
+      options.endpoint || "https://telemetry-six.vercel.app/telemetry";
+    this.batchSize = options.batchSize || 50;
+    this.batchInterval = options.batchInterval || 15 * 1000; // 15 seconds
+    this.disabled = options.disabled || process.env.TELEMETRY_DISABLED === "1";
+  }
+  track(event) {
+    if (this.disabled) {
+      return;
+    }
+    const telemetryEvent = {
+      framework: "jenjs",
+      version: this.version,
+      os: platform(),
+      ...event,
+    };
+    this.queue.push(telemetryEvent);
+    // Flush immediately if batch is full
+    if (this.queue.length >= this.batchSize) {
+      this.flush();
+      return;
+    }
+    // Schedule flush if not already scheduled
+    if (!this.flushTimer) {
+      this.flushTimer = setTimeout(() => this.flush(), this.batchInterval);
+    }
+  }
+  async flush() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    if (this.queue.length === 0) {
+      return;
+    }
+    const events = this.queue;
+    this.queue = [];
+    try {
+      await this.send(events);
+    } catch (error) {
+      if (process.env.DEBUG_TELEMETRY) {
+        console.error("Telemetry send failed:", error);
+      }
+      // Silently fail - telemetry is fire-and-forget
+    }
+  }
+  async send(events) {
+    // Try using fetch if available (Node 18+)
+    if (typeof fetch !== "undefined") {
+      const response = await fetch(this.endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(events),
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      return;
+    }
+    // Fallback to https module for older Node versions
+    await this.sendWithHttps(events);
+  }
+  async sendWithHttps(events) {
+    const https = await import("https");
+    const url = new URL(this.endpoint);
+    const body = JSON.stringify(events);
+    return new Promise((resolve, reject) => {
+      const options = {
+        hostname: url.hostname,
+        port: url.port,
+        path: url.pathname,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(body),
+        },
+      };
+      const req = https.request(options, (res) => {
+        if (res.statusCode !== 200) {
+          reject(new Error(`HTTP ${res.statusCode}`));
+        } else {
+          resolve();
+        }
+        res.on("data", () => {});
+      });
+      req.on("error", reject);
+      req.write(body);
+      req.end();
+    });
+  }
+  disable() {
+    this.disabled = true;
+    this.queue = [];
+  }
+  enable() {
+    this.disabled = false;
+  }
+}
+// Export factory function
+export function createTelemetry(version, options) {
+  return new TelemetryClient(version, options);
+}

package/templates/static/lib/telemetry/tests/rate-limiter.test.js

@@ -0,0 +1,46 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { rateLimiter } from "../api/rate-limiter.js";
+describe("Rate Limiter", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+  it("should allow requests within limit", () => {
+    const ip = "192.168.1.1";
+    for (let i = 0; i < 10; i++) {
+      expect(rateLimiter.check(ip)).toBe(true);
+    }
+  });
+  it("should block requests exceeding limit", () => {
+    const ip = "192.168.1.2";
+    // First 10 allowed
+    for (let i = 0; i < 10; i++) {
+      expect(rateLimiter.check(ip)).toBe(true);
+    }
+    // 11th blocked
+    expect(rateLimiter.check(ip)).toBe(false);
+  });
+  it("should allow different IPs independently", () => {
+    const ip1 = "192.168.1.100";
+    const ip2 = "192.168.1.101";
+    for (let i = 0; i < 10; i++) {
+      expect(rateLimiter.check(ip1)).toBe(true);
+      expect(rateLimiter.check(ip2)).toBe(true);
+    }
+    expect(rateLimiter.check(ip1)).toBe(false);
+    expect(rateLimiter.check(ip2)).toBe(false);
+  });
+  it("should reset limits after window expires", () => {
+    vi.useFakeTimers();
+    const ip = "192.168.1.200";
+    // Fill limit
+    for (let i = 0; i < 10; i++) {
+      expect(rateLimiter.check(ip)).toBe(true);
+    }
+    expect(rateLimiter.check(ip)).toBe(false);
+    // Advance time past window
+    vi.advanceTimersByTime(61 * 1000); // 61 seconds
+    // Should allow again
+    expect(rateLimiter.check(ip)).toBe(true);
+    vi.useRealTimers();
+  });
+});

package/templates/static/lib/telemetry/tests/validator.test.js

@@ -0,0 +1,62 @@
+import { describe, it, expect } from "vitest";
+import { validatePayload } from "../api/validator.js";
+describe("Telemetry Validator", () => {
+  it("should accept valid event", () => {
+    const payload = {
+      framework: "jenjs",
+      version: "0.1.0",
+      command: "dev",
+      os: "win32",
+    };
+    const result = validatePayload(payload);
+    expect(result.valid).toBe(true);
+  });
+  it("should accept array of events", () => {
+    const payload = [
+      { framework: "jenjs", version: "0.1.0" },
+      { framework: "jenjs", version: "0.1.0", command: "build" },
+    ];
+    const result = validatePayload(payload);
+    expect(result.valid).toBe(true);
+  });
+  it("should reject missing framework", () => {
+    const payload = { version: "0.1.0" };
+    const result = validatePayload(payload);
+    expect(result.valid).toBe(false);
+    expect(result.error).toMatch(/framework/i);
+  });
+  it("should reject missing version", () => {
+    const payload = { framework: "jenjs" };
+    const result = validatePayload(payload);
+    expect(result.valid).toBe(false);
+    expect(result.error).toMatch(/version/i);
+  });
+  it("should reject non-string framework", () => {
+    const payload = { framework: 123, version: "0.1.0" };
+    const result = validatePayload(payload);
+    expect(result.valid).toBe(false);
+  });
+  it("should reject fields that are too long", () => {
+    const payload = {
+      framework: "jenjs",
+      version: "0.1.0",
+      command: "x".repeat(100),
+    };
+    const result = validatePayload(payload);
+    expect(result.valid).toBe(false);
+  });
+  it("should reject empty event list", () => {
+    const payload = [];
+    const result = validatePayload(payload);
+    expect(result.valid).toBe(false);
+  });
+  it("should reject too many events", () => {
+    const payload = Array(101).fill({
+      framework: "jenjs",
+      version: "0.1.0",
+    });
+    const result = validatePayload(payload);
+    expect(result.valid).toBe(false);
+    expect(result.error).toMatch(/too many/i);
+  });
+});