distats-cli 0.0.1

package/bin/index.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import "../src/index.js";

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "distats-cli",
+  "version": "0.0.1",
+  "description": "",
+  "main": "src/index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "bin": {
+    "prismpanel": "./bin/index.js"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "module",
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "inquirer": "^13.3.2",
+    "mongoose": "^9.4.1",
+    "ora": "^9.3.0",
+    "sqlite3": "^6.0.1"
+  }
+}

package/src/commands/create-user.js

@@ -0,0 +1,66 @@
+import inquirer from "inquirer";
+import chalk from "chalk";
+import ora from "ora";
+import crypto from "crypto";
+import { getDatabase, runQuery } from "../utils/database.js";
+
+/**
+ * Hash a password using scrypt (Node.js native).
+ * 
+ * @param {string} password 
+ * @returns {string} - salt.hash format
+ */
+function hashPassword(password) {
+  const salt = crypto.randomBytes(16).toString("hex");
+  const hash = crypto.scryptSync(password, salt, 64).toString("hex");
+  return `${salt}.${hash}`;
+}
+
+export async function createUser() {
+  const spinner = ora("Opening local database...").start();
+  let db;
+
+  try {
+    db = await getDatabase();
+    spinner.succeed(chalk.green("Connected to SQLite database."));
+  } catch (error) {
+    spinner.fail(chalk.red("Failed to open local database."));
+    console.error(chalk.red("\nDetails: " + error.message));
+    return;
+  }
+
+  const answers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "name",
+      message: "Enter user name:",
+      validate: (input) => input.length > 0 && input.length <= 60 ? true : "Name must be 1-60 characters.",
+    },
+    {
+      type: "password",
+      name: "password",
+      message: "Enter user password:",
+      mask: "*",
+      validate: (input) => input.length > 0 ? true : "Password is required.",
+    },
+  ]);
+
+  const saveSpinner = ora("Creating user and hashing password...").start();
+
+  try {
+    // POWERFUL HASHING LOGIC
+    const securePassword = hashPassword(answers.password);
+    
+    const sql = "INSERT INTO users (name, password) VALUES (?, ?)";
+    await runQuery(db, sql, [answers.name, securePassword]);
+    
+    saveSpinner.succeed(chalk.green(`User '${answers.name}' created with a powerful encrypted password.`));
+  } catch (error) {
+    saveSpinner.fail(chalk.red("Failed to save user."));
+    console.error(chalk.red(error.message));
+  } finally {
+    if (db) {
+      db.close();
+    }
+  }
+}

package/src/commands/init.js

@@ -0,0 +1,57 @@
+import path from "path";
+import fs from "fs";
+import inquirer from "inquirer";
+import chalk from "chalk";
+import { createLoader } from "../utils/loader.js";
+
+export async function init() {
+  const getVisibleLength = (str) => str.replace(/\u001b\[\d+m/g, "").length;
+  const noteWidth = 55;
+  const borderCol = chalk.yellow;
+
+  const titleStr = `  ${chalk.yellow.bold("⚠  PRIVACY NOTICE")} `;
+  const line1 = `  Your Bot Token is used exclusively for features.`;
+  const line2 = `  It will never be stored or used elsewhere.`;
+
+  console.log(borderCol(` ┌${"─".repeat(noteWidth)}┐`));
+  [titleStr, line1, line2].forEach(line => {
+    const visibleLength = getVisibleLength(line);
+    const padding = " ".repeat(Math.max(0, noteWidth - visibleLength));
+    console.log(` ${borderCol("│")}${line}${padding}${borderCol("│")}`);
+  });
+  console.log(borderCol(` └${"─".repeat(noteWidth)}┘\n`));
+
+  const answers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "bot_token",
+      message: "Bot Token:",
+    },
+  ]);
+
+  const loader = createLoader("Creating project...");
+
+  // simulate progress over 4 seconds
+  await new Promise((resolve) => {
+    setTimeout(() => loader.update("Setting up files..."), 1000);
+    setTimeout(() => loader.update("Installing dependencies..."), 2000);
+    setTimeout(() => loader.update("Finalizing..."), 3000);
+    setTimeout(resolve, 4000);
+  });
+
+  loader.succeed("Project created successfully!\nUse 'distats-panel-cli create-user' to create a user.");
+
+  // Save the config
+  try {
+    const configDir = path.join(process.cwd(), "@distats_panel");
+    if (!fs.existsSync(configDir)) {
+      fs.mkdirSync(configDir, { recursive: true });
+    }
+    const configPath = path.join(configDir, "config.json");
+    fs.writeFileSync(configPath, JSON.stringify(answers, null, 2));
+  } catch (err) {
+    console.log(chalk.red("\nError saving configuration: " + err.message));
+  }
+
+  console.log("\nResult:", answers);
+}

package/src/index.js

@@ -0,0 +1,29 @@
+import { init } from "./commands/init.js";
+import { createUser } from "./commands/create-user.js";
+import { getEnvVariables, GetEnvVaribels } from "./utils/config.js";
+import { showWelcome } from "./utils/logger.js";
+
+// Always show the welcome banner
+showWelcome();
+
+// Export the utility functions for use as a library 
+export { getEnvVariables, GetEnvVaribels };
+
+const command = process.argv[2];
+
+if (command) {
+  switch (command) {
+    case "init":
+      await init();
+      break;
+    
+    case "create-user":
+      await createUser();
+      break;
+
+    default:
+      console.log("Unknown command. Available commands: init, create-user");
+  }
+} else {
+  console.log("Usage: prismpanel <command>\nAvailable commands: init, create-user");
+}

package/src/models/User.js

@@ -0,0 +1,15 @@
+import mongoose from "mongoose";
+
+const UserSchema = new mongoose.Schema({
+  name: {
+    type: String,
+    required: [true, "Please provide a name"],
+    maxlength: [60, "Name cannot be more than 60 characters"],
+  },
+  password: {
+    type: String,
+    required: [true, "Please provide a password"],
+  },
+});
+
+export default mongoose.models.User || mongoose.model("User", UserSchema);

package/src/utils/config.js

@@ -0,0 +1,34 @@
+import path from "path";
+import fs from "fs";
+
+/**
+ * Get configuration value(s) from the @prism_panel/config.json file in the current workspace.
+ * 
+ * @param {string} [key] - The key to look for in the config file. If not provided, returns all config.
+ * @returns {any|null} - The value of the key, the entire config object, or null if not found.
+ */
+export function getEnvVariables(key) {
+  try {
+    const configPath = path.join(process.cwd(), "@distats_panel", "config.json");
+    
+    if (!fs.existsSync(configPath)) {
+      return null;
+    }
+
+    const configFile = fs.readFileSync(configPath, "utf-8").replace(/^\uFEFF/, "");
+    const config = JSON.parse(configFile);
+
+    if (key) {
+      return config[key] !== undefined ? config[key] : null;
+    }
+
+    return config;
+  } catch (error) {
+    return null;
+  }
+}
+
+/** 
+ * Alias for getEnvVariables to match specific user request naming.
+ */
+export const GetEnvVaribels = getEnvVariables;

package/src/utils/database.js

@@ -0,0 +1,61 @@
+import sqlite3 from "sqlite3";
+import { getEnvVariables } from "./config.js";
+import path from "path";
+import fs from "fs";
+
+/**
+ * Get and initialize the SQLite database.
+ * 
+ * @returns {Promise<sqlite3.Database>}
+ */
+export async function getDatabase() {
+  const config = getEnvVariables();
+  
+  if (!config || !config.db_path) {
+    throw new Error("SQLite database not configured in config.json");
+  }
+
+  const dbPath = path.resolve(process.cwd(), config.db_path);
+  
+  // Create folder if it doesn't exist
+  const dbDir = path.dirname(dbPath);
+  if (!fs.existsSync(dbDir)) {
+    fs.mkdirSync(dbDir, { recursive: true });
+  }
+
+  return new Promise((resolve, reject) => {
+    const db = new sqlite3.Database(dbPath, (err) => {
+      if (err) return reject(err);
+      
+      // Initialize tables
+      db.run(`
+        CREATE TABLE IF NOT EXISTS users (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          name TEXT NOT NULL,
+          password TEXT NOT NULL,
+          created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+        )
+      `, (err) => {
+        if (err) return reject(err);
+        resolve(db);
+      });
+    });
+  });
+}
+
+/**
+ * Execute a query that doesn't return rows (INSERT, UPDATE, DELETE).
+ * 
+ * @param {sqlite3.Database} db 
+ * @param {string} sql 
+ * @param {any[]} params 
+ * @returns {Promise<void>}
+ */
+export function runQuery(db, sql, params = []) {
+  return new Promise((resolve, reject) => {
+    db.run(sql, params, function(err) {
+      if (err) return reject(err);
+      resolve({ lastID: this.lastID, changes: this.changes });
+    });
+  });
+}

package/src/utils/loader.js

@@ -0,0 +1,20 @@
+import ora from "ora";
+
+export function createLoader(text = "Loading...") {
+  const spinner = ora({
+    text,
+    color: "blue",
+  }).start();
+
+  return {
+    update(message) {
+      spinner.text = message;
+    },
+    succeed(message) {
+      spinner.succeed(message);
+    },
+    fail(message) {
+      spinner.fail(message);
+    },
+  };
+}

package/src/utils/logger.js

@@ -0,0 +1,55 @@
+import chalk from "chalk";
+
+export function logInfo(message) {
+  console.log(chalk.blue(message));
+}
+
+export function logSuccess(message) {
+  console.log(chalk.green(message));
+}
+
+export function logError(message) {
+  console.log(chalk.red(message));
+}
+
+/**
+ * High-fidelity, modern welcomer for the PRISM CLI.
+ * Features a minimalist text-only header box with a clickable link.
+ */
+export function showWelcome() {
+  const version = "1.0.1";
+  
+  // Helper for clickable terminal links
+  const link = (text, url) => `\u001b]8;;${url}\u001b\\${text}\u001b]8;;\u001b\\`;
+
+  const textLines = [
+    "",
+    `${chalk.bgCyan.black.bold(" DISTATS PANEL ")} ${chalk.white("CLI")} ${chalk.gray("•")} ${chalk.cyan("v" + version)}`,
+    chalk.gray(" https://distats.sh/docs/cli"),
+    `${chalk.gray(" Powered By")} ${chalk.blue.bold(link("AxonTeam", "https://ax0n.xyz"))}`,
+    "",
+  ];
+
+  const boxWidth = 55;
+  const borderChar = chalk.gray;
+
+  // Robust ANSI stripper to calculate visible length supporting complex escapes
+  const getVisibleLength = (str) => {
+    return str
+      .replace(/\u001b\[[\d;]*m/g, "") // Strip color/bold/dim sequences
+      .replace(/\u001b\]8;;.*?\u001b\\/g, "") // Strip OSC link delimiters
+      .replace(/\u001b\]8;;\u001b\\/g, "") // Strip closing OSC link delimiters
+      .length;
+  };
+
+  console.log("");
+  console.log(borderChar(` ┌${"─".repeat(boxWidth)}┐`));
+  
+  textLines.forEach((line) => {
+    const visibleLength = getVisibleLength(line);
+    const padding = " ".repeat(Math.max(0, boxWidth - visibleLength - 2));
+    console.log(` ${borderChar("│")}  ${line}${padding}${borderChar("│")}`);
+  });
+
+  console.log(borderChar(` └${"─".repeat(boxWidth)}┘`) + "\n");
+}