@fortressllm/sybil 0.0.3

package/src/cli/commands/otp.ts

@@ -0,0 +1,162 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import inquirer from "inquirer";
+import { 
+  generateOTP, 
+  storeOTP, 
+  getPendingOTPs, 
+  getAuthenticatedUsers,
+  cleanupExpiredOTPs,
+  revokeAuthentication
+} from "../../utils/telegram-auth.js";
+
+export const otpCommand = new Command("otp")
+  .description("Manage Telegram user authentication with OTP")
+  .option("-g, --generate", "Generate a new OTP for user authentication")
+  .option("-l, --list", "List pending OTPs and authenticated users")
+  .option("-r, --revoke <chatId>", "Revoke authentication for a user")
+  .option("-c, --cleanup", "Clean up expired OTPs")
+  .action(async (options) => {
+    console.log(chalk.cyan("\n🔐 Telegram OTP Authentication\n"));
+
+    if (options.cleanup) {
+      const spinner = ora("Cleaning up expired OTPs...").start();
+      cleanupExpiredOTPs();
+      spinner.succeed("✅ Expired OTPs cleaned up");
+      return;
+    }
+
+    if (options.revoke) {
+      const chatId = parseInt(options.revoke);
+      if (isNaN(chatId)) {
+        console.log(chalk.red("❌ Invalid chat ID"));
+        process.exit(1);
+      }
+
+      const { confirm } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "confirm",
+          message: `Are you sure you want to revoke access for chat ${chatId}?`,
+          default: false,
+        },
+      ]);
+
+      if (confirm) {
+        revokeAuthentication(chatId);
+        console.log(chalk.green(`✅ Authentication revoked for chat ${chatId}`));
+      } else {
+        console.log(chalk.gray("Cancelled"));
+      }
+      return;
+    }
+
+    if (options.list) {
+      const pending = getPendingOTPs();
+      const users = getAuthenticatedUsers();
+
+      console.log(chalk.bold("\n📋 Pending OTPs:"));
+      if (pending.length === 0) {
+        console.log(chalk.gray("  No pending OTPs"));
+      } else {
+        pending.forEach((otp) => {
+          const expiresIn = Math.floor((new Date(otp.expiresAt).getTime() - Date.now()) / 60000);
+          console.log(`  🔑 Code: ${chalk.yellow(otp.code)} | Expires in: ${chalk.cyan(expiresIn + " min")}`);
+        });
+      }
+
+      console.log(chalk.bold("\n👥 Authenticated Users:"));
+      if (users.length === 0) {
+        console.log(chalk.gray("  No authenticated users"));
+      } else {
+        users.forEach((user) => {
+          const date = new Date(user.authenticatedAt).toLocaleString();
+          console.log(`  ✅ Chat ID: ${chalk.green(user.chatId)} | Since: ${chalk.gray(date)}`);
+        });
+      }
+
+      console.log(chalk.gray("\n💡 Use 'sybil otp --generate' to create a new OTP"));
+      return;
+    }
+
+    // Default: generate new OTP
+    if (options.generate || (!options.list && !options.revoke && !options.cleanup)) {
+      console.log(chalk.cyan("📱 Generate Authentication OTP\n"));
+      
+      const { action } = await inquirer.prompt([
+        {
+          type: "list",
+          name: "action",
+          message: "What would you like to do?",
+          choices: [
+            { name: "🆕 Generate new OTP", value: "generate" },
+            { name: "📋 Show pending OTPs", value: "show" },
+            { name: "👥 List authenticated users", value: "users" },
+          ],
+          default: "generate",
+        },
+      ]);
+
+      if (action === "show") {
+        const pending = getPendingOTPs();
+        console.log(chalk.bold("\nPending OTPs:"));
+        if (pending.length === 0) {
+          console.log(chalk.gray("  No pending OTPs"));
+        } else {
+          pending.forEach((otp) => {
+            const expiresIn = Math.floor((new Date(otp.expiresAt).getTime() - Date.now()) / 60000);
+            console.log(`  🔑 ${chalk.yellow(otp.code)} (expires in ${expiresIn} min)`);
+          });
+        }
+        return;
+      }
+
+      if (action === "users") {
+        const users = getAuthenticatedUsers();
+        console.log(chalk.bold("\nAuthenticated Users:"));
+        if (users.length === 0) {
+          console.log(chalk.gray("  No authenticated users"));
+        } else {
+          users.forEach((user) => {
+            const date = new Date(user.authenticatedAt).toLocaleString();
+            console.log(`  ✅ ${chalk.green(user.chatId)} - ${date}`);
+          });
+        }
+        return;
+      }
+
+      // Generate OTP
+      const { chatId } = await inquirer.prompt([
+        {
+          type: "input",
+          name: "chatId",
+          message: "Enter the user's Telegram Chat ID:",
+          default: "pending",
+        },
+      ]);
+
+      const otp = generateOTP();
+      const chatIdNum = chatId === "pending" ? 0 : parseInt(chatId);
+      
+      if (chatId == "pending" && isNaN(chatIdNum)) {
+        console.log(chalk.red("❌ Invalid chat ID"));
+        process.exit(1);
+      }
+
+      storeOTP(chatIdNum, otp);
+
+      console.log(chalk.green("\n✅ OTP Generated!\n"));
+      console.log(chalk.bold("📱 Share this code with the user:"));
+      console.log(chalk.yellow(`\n   🔑 ${otp}\n`));
+      console.log(chalk.gray("⏰ Valid for: 10 minutes"));
+      console.log(chalk.gray("📋 Instructions for user:"));
+      console.log(chalk.white("   1. Send the code to the bot"));
+      console.log(chalk.white("   2. They will be authenticated automatically"));
+      console.log(chalk.white("   3. This is a one-time setup\n"));
+
+      if (chatId === "pending") {
+        console.log(chalk.cyan("💡 Note: You set this as 'pending' - the first user who sends this code will be authenticated."));
+      }
+    }
+  });

package/src/cli/commands/restore.ts

@@ -0,0 +1,118 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { existsSync, copyFileSync, readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import inquirer from "inquirer";
+
+export const restoreCommand = new Command("restore")
+  .description("Restore Sybil from a backup")
+  .argument("[backup-name]", "Name of the backup to restore")
+  .option("-l, --list", "List available backups")
+  .action(async (backupName, options) => {
+    const backupDir = join(homedir(), ".sybil", "backups");
+    
+    if (options.list) {
+      // List available backups
+      console.log(chalk.cyan("\n📦 Available Backups:\n"));
+      
+      if (!existsSync(backupDir)) {
+        console.log(chalk.yellow("No backups found."));
+        return;
+      }
+      
+      const { readdirSync } = await import("fs");
+      const backups = readdirSync(backupDir, { withFileTypes: true })
+        .filter((dirent) => dirent.isDirectory())
+        .map((dirent) => dirent.name);
+      
+      if (backups.length === 0) {
+        console.log(chalk.yellow("No backups found."));
+        return;
+      }
+      
+      for (const backup of backups) {
+        const metadataPath = join(backupDir, backup, "metadata.json");
+        if (existsSync(metadataPath)) {
+          const metadata = JSON.parse(readFileSync(metadataPath, "utf-8"));
+          console.log(`  📁 ${chalk.bold(backup)}`);
+          console.log(`     Created: ${new Date(metadata.createdAt).toLocaleString()}`);
+          console.log(`     Files: ${metadata.filesBackedUp}`);
+          console.log("");
+        } else {
+          console.log(`  📁 ${chalk.bold(backup)}`);
+          console.log("     (No metadata available)");
+          console.log("");
+        }
+      }
+      
+      return;
+    }
+
+    if (!backupName) {
+      console.log(chalk.red("❌ Please specify a backup name or use --list"));
+      console.log(chalk.gray("Usage: sybil restore <backup-name>"));
+      process.exit(1);
+    }
+
+    const backupPath = join(backupDir, backupName);
+    
+    if (!existsSync(backupPath)) {
+      console.log(chalk.red(`❌ Backup '${backupName}' not found`));
+      console.log(chalk.gray(`Run 'sybil restore --list' to see available backups`));
+      process.exit(1);
+    }
+
+    const spinner = ora("Restoring from backup...").start();
+    
+    try {
+      // Confirm restore
+      spinner.stop();
+      
+      const { confirm } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "confirm",
+          message: chalk.yellow("⚠️  This will overwrite your current configuration. Continue?"),
+          default: false,
+        },
+      ]);
+
+      if (!confirm) {
+        console.log(chalk.blue("Restore cancelled."));
+        return;
+      }
+
+      spinner.start("Restoring files...");
+
+      // Restore files
+      const filesToRestore = [
+        { src: join(backupPath, ".env"), dest: join(process.cwd(), ".env") },
+        { src: join(backupPath, "settings.json"), dest: join(homedir(), ".sybil", "settings.json") },
+        { src: join(backupPath, "mastra.db"), dest: join(process.cwd(), "mastra.db") },
+      ];
+
+      let restored = 0;
+      
+      for (const { src, dest } of filesToRestore) {
+        if (existsSync(src)) {
+          copyFileSync(src, dest);
+          restored++;
+        }
+      }
+
+      spinner.succeed(chalk.green("✅ Restore completed successfully"));
+      
+      console.log(chalk.cyan("\n📦 Restore Details:"));
+      console.log(`  📁 Backup: ${chalk.bold(backupName)}`);
+      console.log(`  📄 Files restored: ${restored}`);
+      
+      console.log(chalk.yellow("\n⚠️  Please restart Sybil for changes to take effect"));
+
+    } catch (error) {
+      spinner.fail(chalk.red("❌ Failed to restore backup"));
+      console.error(error);
+      process.exit(1);
+    }
+  });

package/src/cli/commands/start.ts

@@ -0,0 +1,76 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import { join } from "path";
+
+export const startCommand = new Command("start")
+  .description("Start the Sybil agent service")
+  .option("-d, --daemon", "Run as background daemon")
+  .option("-p, --port <port>", "Port for web interface", "3000")
+  .action(async (options) => {
+    const spinner = ora("Starting Sybil...").start();
+    
+    try {
+      // Check if .env exists
+      if (!existsSync(join(process.cwd(), ".env"))) {
+        spinner.fail(chalk.red("❌ Sybil not initialized. Run 'sybil init' first."));
+        process.exit(1);
+      }
+
+      // Check if already running
+      const checkProcess = spawn("pgrep", ["-f", "sybil"]);
+      let isRunning = false;
+      
+      checkProcess.stdout.on("data", () => {
+        isRunning = true;
+      });
+
+      await new Promise((resolve) => checkProcess.on("close", resolve));
+
+      if (isRunning) {
+        spinner.warn(chalk.yellow("⚠️  Sybil is already running"));
+        console.log(chalk.blue("Use 'sybil status' to check details"));
+        return;
+      }
+
+      spinner.stop();
+
+      if (options.daemon) {
+        // Start as daemon using PM2 or nohup
+        console.log(chalk.cyan("🚀 Starting Sybil as daemon...\n"));
+        
+        const child = spawn("nohup", ["npm", "run", "start"], {
+          detached: true,
+          stdio: "ignore",
+          env: { ...process.env, PORT: options.port },
+        });
+        
+        child.unref();
+        
+        console.log(chalk.green("✅ Sybil started in background"));
+        console.log(chalk.white(`📊 Web interface: http://localhost:${options.port}`));
+        console.log(chalk.gray("\nTo stop: sybil stop"));
+      } else {
+        // Start in foreground
+        console.log(chalk.cyan("🚀 Starting Sybil...\n"));
+        console.log(chalk.gray("Press Ctrl+C to stop\n"));
+        
+        const child = spawn("npm", ["run", "start"], {
+          stdio: "inherit",
+          env: { ...process.env, PORT: options.port },
+        });
+
+        child.on("error", (error) => {
+          console.error(chalk.red("Failed to start:"), error.message);
+          process.exit(1);
+        });
+      }
+
+    } catch (error) {
+      spinner.fail(chalk.red("Failed to start Sybil"));
+      console.error(error);
+      process.exit(1);
+    }
+  });

package/src/cli/commands/status.ts

@@ -0,0 +1,81 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { spawn } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+export const statusCommand = new Command("status")
+  .description("Check Sybil agent status and health")
+  .action(async () => {
+    const spinner = ora("Checking status...").start();
+    
+    try {
+      console.log(chalk.cyan("\n📊 Sybil Status Report\n"));
+      
+      // Check if initialized
+      const envPath = join(process.cwd(), ".env");
+      const isInitialized = existsSync(envPath);
+      
+      console.log(chalk.bold("Configuration:"));
+      console.log(`  ${isInitialized ? chalk.green("✅") : chalk.red("❌")} Initialized: ${isInitialized ? "Yes" : "No"}`);
+      
+      if (isInitialized) {
+        const envContent = readFileSync(envPath, "utf-8");
+        const provider = envContent.match(/AI_PROVIDER=(.+)/)?.[1] || "unknown";
+        console.log(`  🤖 AI Provider: ${chalk.cyan(provider)}`);
+      }
+      
+      // Check if running
+      const checkProcess = spawn("pgrep", ["-f", "sybil"]);
+      let isRunning = false;
+      let pid = "";
+      
+      checkProcess.stdout.on("data", (data) => {
+        isRunning = true;
+        pid = data.toString().trim().split("\n")[0];
+      });
+
+      await new Promise((resolve) => checkProcess.on("close", resolve));
+      
+      console.log(chalk.bold("\nProcess Status:"));
+      console.log(`  ${isRunning ? chalk.green("🟢") : chalk.red("🔴")} Running: ${isRunning ? "Yes" : "No"}`);
+      
+      if (isRunning && pid) {
+        console.log(`  🆔 PID: ${chalk.gray(pid)}`);
+      }
+      
+      // Check data directory
+      const dataDir = join(homedir(), ".sybil");
+      const hasDataDir = existsSync(dataDir);
+      
+      console.log(chalk.bold("\nData Directory:"));
+      console.log(`  📁 Location: ${chalk.gray(dataDir)}`);
+      console.log(`  ${hasDataDir ? chalk.green("✅") : chalk.red("❌")} Exists: ${hasDataDir ? "Yes" : "No"}`);
+      
+      // Memory usage (if running)
+      if (isRunning && pid) {
+        try {
+          const { execSync } = await import("child_process");
+          const memInfo = execSync(`ps -p ${pid} -o %mem=`, { encoding: "utf-8" }).trim();
+          console.log(chalk.bold("\nResource Usage:"));
+          console.log(`  💾 Memory: ${chalk.yellow(memInfo + "%")}`);
+        } catch {
+          // Ignore
+        }
+      }
+      
+      spinner.stop();
+      
+      console.log(chalk.cyan("\n💡 Quick Commands:"));
+      console.log(chalk.gray("  sybil start    - Start the agent"));
+      console.log(chalk.gray("  sybil stop     - Stop the agent"));
+      console.log(chalk.gray("  sybil logs     - View logs"));
+      
+    } catch (error) {
+      spinner.fail(chalk.red("Failed to check status"));
+      console.error(error);
+      process.exit(1);
+    }
+  });

package/src/cli/commands/stop.ts

@@ -0,0 +1,68 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { execSync, spawn } from "child_process";
+
+export const stopCommand = new Command("stop")
+  .description("Stop the Sybil agent service")
+  .option("-f, --force", "Force stop (kill immediately)")
+  .action(async (options) => {
+    const spinner = ora("Stopping Sybil...").start();
+    
+    try {
+      // Find Sybil processes
+      const checkProcess = spawn("pgrep", ["-f", "sybil"]);
+      let pids: string[] = [];
+      
+      checkProcess.stdout.on("data", (data) => {
+        pids = data.toString().trim().split("\n").filter(Boolean);
+      });
+
+      await new Promise((resolve) => checkProcess.on("close", resolve));
+
+      if (pids.length === 0) {
+        spinner.info(chalk.blue("ℹ️  Sybil is not running"));
+        return;
+      }
+
+      // Stop processes
+      for (const pid of pids) {
+        try {
+          if (options.force) {
+            process.kill(parseInt(pid), "SIGKILL");
+          } else {
+            process.kill(parseInt(pid), "SIGTERM");
+          }
+        } catch (error) {
+          // Process might already be dead
+        }
+      }
+
+      // Wait a moment and verify
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+      
+      const verifyProcess = spawn("pgrep", ["-f", "sybil"]);
+      let stillRunning = false;
+      
+      verifyProcess.stdout.on("data", () => {
+        stillRunning = true;
+      });
+
+      await new Promise((resolve) => verifyProcess.on("close", resolve));
+
+      if (stillRunning && options.force) {
+        spinner.fail(chalk.red("❌ Some processes could not be stopped"));
+        console.log(chalk.yellow("Try: kill -9 <pid>"));
+      } else if (stillRunning) {
+        spinner.warn(chalk.yellow("⚠️  Some processes still running"));
+        console.log(chalk.gray("Use --force to kill immediately"));
+      } else {
+        spinner.succeed(chalk.green("✅ Sybil stopped successfully"));
+      }
+
+    } catch (error) {
+      spinner.fail(chalk.red("Failed to stop Sybil"));
+      console.error(error);
+      process.exit(1);
+    }
+  });

package/src/cli/commands/update.ts

@@ -0,0 +1,61 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { execSync } from "child_process";
+
+export const updateCommand = new Command("update")
+  .description("Update Sybil to the latest version")
+  .option("-c, --check", "Check for updates only")
+  .action(async (options) => {
+    const spinner = ora("Checking for updates...").start();
+    
+    try {
+      // Get current version
+      const currentVersion = "1.0.0";
+      
+      // Check latest version from npm (in production)
+      // For now, simulate check
+      const latestVersion = currentVersion;
+      
+      spinner.stop();
+      
+      if (options.check) {
+        if (currentVersion === latestVersion) {
+          console.log(chalk.green("✅ Sybil is up to date (v" + currentVersion + ")"));
+        } else {
+          console.log(chalk.yellow(`⬆️  Update available: v${currentVersion} → v${latestVersion}`));
+          console.log(chalk.gray("Run 'sybil update' to update"));
+        }
+        return;
+      }
+
+      if (currentVersion === latestVersion) {
+        console.log(chalk.green("✅ Already on the latest version"));
+        return;
+      }
+
+      console.log(chalk.cyan(`\n🔄 Updating Sybil from v${currentVersion} to v${latestVersion}...\n`));
+      
+      spinner.start("Downloading update...");
+      
+      // Simulate update process
+      await new Promise((resolve) => setTimeout(resolve, 2000));
+      
+      spinner.text = "Installing dependencies...";
+      await new Promise((resolve) => setTimeout(resolve, 1500));
+      
+      spinner.succeed(chalk.green("✅ Update completed successfully"));
+      
+      console.log(chalk.cyan("\n📋 What's New in v" + latestVersion + ":"));
+      console.log(chalk.white("  • Improved agent coordination"));
+      console.log(chalk.white("  • New CLI commands"));
+      console.log(chalk.white("  • Bug fixes and performance improvements"));
+      
+      console.log(chalk.yellow("\n⚠️  Please restart Sybil to apply the update"));
+
+    } catch (error) {
+      spinner.fail(chalk.red("❌ Failed to update"));
+      console.error(error);
+      process.exit(1);
+    }
+  });