maverick-ai-cli 1.0.0

package/src/cli/commands/ai/wakeUp.js

@@ -0,0 +1,83 @@
+import chalk from "chalk";
+import { Command } from "commander";
+import yoctoSpinner from "yocto-spinner"
+import { requireAuth } from "../../../lib/token.js";
+import prisma from "../../../lib/db.js";
+import { select } from "@clack/prompts";
+import { startChat } from "../../chat/chat-with-ai.js";
+
+const wakeUpAction = async () => {
+    const token = await requireAuth();
+
+    const spinner = yoctoSpinner({ text: "Fetching user information....." })
+    spinner.start()
+
+
+    const user = await prisma.user.findFirst({
+        where: {
+            sessions: {
+                some: {
+                    token: token.access_token
+                }
+            }
+        },
+        select: {
+            id: true,
+            name: true,
+            email: true,
+            image: true
+        }
+
+    });
+
+    spinner.stop()
+
+    if (!user) {
+        console.log(chalk.red("User not found"))
+        return;
+    }
+
+    console.log(chalk.green(`Welcome back, ${user.name}! \n`))
+
+    const choice = await select({
+        message: "Select an option:",
+        options: [
+            {
+                value: "chat",
+                label: "Chat",
+                hint: "Simple chat with AI"
+            },
+            {
+                value: "tool",
+                label: "Tool Calling",
+                hint: "Chat with tools (Google Search, Code Execution)"
+            },
+            {
+                value: "agent",
+                label: "Agent",
+                hint: "Advanced AI agent (coming soon)"
+            },
+        ],
+    })
+
+    switch (choice) {
+        case "chat":
+            console.log("chat is selected")
+            await startChat("chat")
+            break;
+        case "tool":
+            console.log(chalk.green("Tool calling is selected"))
+            break;
+        case "agent":
+            console.log(chalk.yellow("Agentic mode coming soon"))
+            break;
+
+    }
+
+
+
+}
+
+export const wakeup = new Command("wakeup")
+    .description("wake up the ai")
+    .action(wakeUpAction)

package/src/cli/commands/auth/login.js

@@ -0,0 +1,296 @@
+#!/usr/bin/env node
+
+import { cancel, confirm, intro, isCancel, outro } from "@clack/prompts";
+import { logger } from "better-auth";
+import { createAuthClient } from "better-auth/client";
+import { deviceAuthorizationClient } from "better-auth/client/plugins";
+
+import chalk from "chalk";
+import { Command } from "commander";
+import open from "open";
+import os from "os";
+import path from "path";
+import yoctoSpinner from "yocto-spinner";
+import * as z from "zod";
+import dotenv from "dotenv";
+import { clearStoredToken, getStoredToken, isTokenExpired, requireAuth, storeToken } from "../../../lib/token.js";
+import prisma from "../../../lib/db.js";
+
+dotenv.config();
+
+const URL = "https://maverick-cli-backend.onrender.com";
+const CLIENT_ID = process.env.GITHUB_CLIENT_ID;
+
+// ~/.better-auth/token.json
+export const CONFIG_DIR = path.join(os.homedir(), ".better-auth");
+export const TOKEN_FILE = path.join(CONFIG_DIR, "token.json");
+
+export async function loginAction(opts) {
+  // Validate CLI args
+  const OptionsSchema = z.object({
+    serverUrl: z.string().optional(),
+    clientId: z.string().optional(),
+  });
+
+  const parsed = OptionsSchema.parse(opts);
+
+  const serverUrl = parsed.serverUrl || URL;
+  const clientId = parsed.clientId || CLIENT_ID;
+
+  intro(chalk.cyan("🔐 Better Auth – Device Login"));
+
+  // Token check (optional)
+  const existingToken = await getStoredToken();
+  const expired = await isTokenExpired()
+
+  if (existingToken && !expired) {
+    const reAuth = await confirm({
+      message: "You are already logged in. Login again?",
+      initialValue: false,
+    });
+
+    if (isCancel(reAuth) || !reAuth) {
+      cancel("Login cancelled");
+      process.exit(0);
+    }
+  }
+
+  // Create auth client
+  const authClient = createAuthClient({
+    baseURL: serverUrl,
+    plugins: [deviceAuthorizationClient()],
+  });
+
+  const spinner = yoctoSpinner({ text: "Requesting device authorization..." });
+  spinner.start();
+
+  try {
+    // Request device code
+    const { data, error } = await authClient.device.code({
+      client_id: clientId,
+      scope: "openid profile email",
+    });
+
+    spinner.stop();
+
+    if (!data || error) {
+      logger.error(
+        `Failed to request device authorization: ${error?.error_description || error?.error
+        }`
+      );
+      process.exit(1);
+    }
+
+    const {
+      device_code,
+      user_code,
+      verification_uri,
+      verification_uri_complete,
+      interval = 5,
+      expires_in,
+    } = data;
+
+    console.log(chalk.cyan("\n🔗 Device Authorization Required"));
+    console.log(
+      `Visit: ${chalk.underline.blue(
+        verification_uri_complete || verification_uri
+      )}`
+    );
+    console.log(`Code: ${chalk.bold.green(user_code)}\n`);
+
+    // Auto-open browser
+    const shouldOpen = await confirm({
+      message: "Open browser automatically?",
+      initialValue: true,
+    });
+
+    if (!isCancel(shouldOpen) && shouldOpen) {
+      await open(verification_uri_complete || verification_uri);
+    }
+
+    console.log(
+      chalk.gray(
+        `⏳ Waiting for authorization (expires in ${Math.floor(
+          expires_in / 60
+        )}m)...`
+      )
+    );
+
+    const token = await pollForToken(
+      authClient,
+      device_code,
+      clientId,
+      interval
+    );
+
+    if (token) {
+      const saved = await storeToken(token);
+
+      if (!saved) {
+        console.log(chalk.yellow("⚠️ Warning: Could not save authentication token"));
+        console.log(chalk.yellow("You may need to login again on next use."));
+      }
+
+      outro(chalk.green("✔ Logged in successfully!"));
+
+      //    Todo : Get the user data
+    }
+  } catch (err) {
+    spinner.stop();
+    process.exit(1);
+  }
+}
+
+// --------------------------------------
+//   POLLING FOR TOKEN
+// --------------------------------------
+
+async function pollForToken(authClient, deviceCode, clientId, interval) {
+  let pollInterval = interval;
+
+  return new Promise((resolve, reject) => {
+    const spinner = yoctoSpinner({ text: "", color: "cyan" });
+    let dots = 0;
+
+    const poll = async () => {
+      dots = (dots + 1) % 4;
+      spinner.text = chalk.gray(
+        `Polling for authorization ${".".repeat(dots)}${" ".repeat(3 - dots)}`
+      );
+
+      if (!spinner.isSpinning) spinner.start();
+
+      try {
+        const { data, error } = await authClient.device.token({
+          grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+          device_code: deviceCode,
+          client_id: clientId,
+        });
+
+        if (data?.access_token) {
+          spinner.stop();
+          resolve(data);
+          return;
+        }
+
+        if (error) {
+          switch (error.error) {
+            case "authorization_pending":
+              // Keep polling
+              break;
+            case "slow_down":
+              pollInterval += 5;
+              break;
+            case "access_denied":
+              spinner.stop();
+              console.error(chalk.red("✖ Access denied."));
+              reject(error);
+              return;
+            case "expired_token":
+              spinner.stop();
+              console.error(chalk.red("✖ Device code expired."));
+              reject(error);
+              return;
+            default:
+              spinner.stop();
+              reject(error);
+              return;
+          }
+        }
+      } catch (err) {
+        spinner.stop();
+        reject(err);
+        return;
+      }
+
+      setTimeout(poll, pollInterval * 1000);
+    };
+
+    poll();
+  });
+}
+
+export async function logoutAction() {
+  intro(chalk.bold("👋🏻 Logout"))
+
+  const token = await getStoredToken();
+
+  if (!token) {
+    console.log(chalk.yellow("You'r are not logged in"));
+    process.exit(0);
+  }
+
+  const shouldLogout = await confirm({
+    message: "Are you sure you want to logout?",
+    initialValue: false
+  })
+
+  if (isCancel(shouldLogout) || !shouldLogout) {
+    cancel("Loggout Cancelled")
+    process.exit(0)
+  }
+
+  const cleared = await clearStoredToken();
+
+  if (cleared) {
+    outro(chalk.green("✅ Successfully logged out!"))
+  } else {
+    console.log(chalk.yellow("⚠️ Could not clear token file."))
+  }
+
+}
+
+
+
+export async function whoamiAction(opts) {
+  const token = await requireAuth();
+
+  if (!token?.access_token) {
+    console.log("No access token found. Please login.")
+    process.exit(1)
+  }
+
+  const user = await prisma.user.findFirst({
+    where: {
+      sessions: {
+        some: {
+          token: token.access_token,
+        }
+      }
+    },
+    select: {
+      id: true,
+      name: true,
+      email: true,
+      image: true
+    },
+  })
+
+  console.log(
+    chalk.bold.greenBright(`\n USER: ${user.name}
+      📧 EMAIL: ${user.email}
+      🆔 ID : ${user.id}`)
+  );
+}
+
+
+
+// --------------------------------------
+//  COMMANDER SETUP
+// --------------------------------------
+
+export const login = new Command("login")
+  .description("Login to Better Auth")
+  .option("--server-url <url>", "The Better Auth server URL", URL)
+  .option("--client-id <id>", "The OAuth client ID", CLIENT_ID)
+  .action(loginAction);
+
+
+export const logout = new Command("logout")
+  .description("Logout and Clear stored credentials")
+  .action(logoutAction)
+
+export const whoami = new Command("whoami")
+  .description("Show current authenticated user")
+  .option("--server-url <url>", "The Better Auth server URL", URL)
+  .action(whoamiAction)

package/src/cli/main.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+
+import dotenv from "dotenv";
+import chalk from "chalk";
+import figlet from "figlet";
+import { Command, program } from "commander";
+import { login, logout, whoami } from "./commands/auth/login.js";
+import { wakeup } from "./commands/ai/wakeUp.js";
+
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+dotenv.config({ path: path.join(__dirname, "../../.env") });
+
+async function main() {
+  // Sexy Banner
+  console.log(
+    chalk.hex("#6A5ACD")(
+      figlet.textSync("Maverick", {
+        font: "ANSI Shadow",
+        horizontalLayout: "default",
+        verticalLayout: "default",
+        width: 120
+      })
+    )
+  );
+
+  console.log(
+    chalk.greenBright("<---- Intelligent Command Line Interface ---->\n")
+  );
+
+
+  const program = new Command("Maverick");
+  program.version("1.4.3")
+    .description("Maverick Cli - A cli based AI tool")
+    .addCommand(login)
+    .addCommand(logout)
+    .addCommand(whoami)
+    .addCommand(wakeup)
+
+  program.action(() => {
+    program.help();
+  })
+
+  program.parse()
+}
+
+
+
+main().catch((err) => {
+  console.log(chalk.red("Error : Maverick don't wanna shown UP..!!; Because of this ->"), err)
+  process.exit(1)
+});

package/src/config/google.config.js

@@ -0,0 +1,9 @@
+import dotenv from "dotenv"
+
+dotenv.config()
+
+export const config = {
+
+    googleApiKey : process.env.GOOGLE_GENERATIVE_AI_API_KEY || " ",
+    model : process.env.ORBITAL_MODEL || "gemini-2.5-flash"
+}

package/src/config/tool.config.js

@@ -0,0 +1,106 @@
+import { google } from "@ai-sdk/google";
+import chalk from "chalk";
+
+export const availableTools = [
+    {
+        id: "google_search",
+        name: "Google Search",
+        description: "Search the web using Google Search",
+        getTool: () => google({}),
+        enabled: true,
+    },
+    {
+        id: 'code_execution',
+        name: 'Code Execution',
+        description: 'Generate and execute python code to perform calculations, solve problems, or provide accurate results.',
+        getTool: () => google.tools.codeExecution({}),
+        enabled: true,
+    },
+    {
+        id: 'url_context',
+        name: 'URL Context',
+        description: 'Provide specific URLs that you want to analyse directly from the propmt. Suports upto 20 URLs per request.',
+        getTool: () => google.tools.urlContext({}),
+        enabled: true,
+    }
+
+]
+
+
+
+export function getEnabledTools() {
+    const tools = {}
+    try {
+        for (const tool of availableTools) {
+            if (tool.enabled) {
+                tools[tool.id] = tool.getTool()
+            }
+        }
+        if (Object.keys(tools).length > 0) {
+            console.log(chalk.green(`[DEBUG] Enabled ${Object.keys(tools).join(", ")}`))
+        } else {
+            console.log(chalk.yellow(`[DEBUG] No tools enabled`))
+        }
+
+        return Object.keys(tools).length > 0 ? tools : undefined
+    } catch (error) {
+        console.error(chalk.red("Error getting enabled tools"), error)
+        console.error(chalk.red(`[ERROR] Error getting enabled tools`), error.message)
+        console.error(chalk.yellow('Make sure you have @ai-sdk/google version 2.0+ installed'))
+        console.error(chalk.yellow('You can install it using npm install @ai-sdk/google@latest'))
+        return undefined
+    }
+
+}
+
+
+export function toggleTool(toolsId) {
+
+    const tool = availableTools.find(t => t.id === toolsId)
+
+    if (tool) {
+        tool.enabled = !tool.enabled
+        console.log(chalk.gray(`[DEBUG] Tool ${toolsId} toggled to ${tool.enabled}`))
+
+        return tool.enabled
+    }
+
+    console.log(chalk.red(`[ERROR] Tool ${toolsId} not found`))
+
+    return false;
+}
+
+
+export function enableTools(toolsId) {
+
+    console.log(chalk.gray('[DEBUG] enableTools called with:'), toolsId)
+
+    availableTools.forEach(tool => {
+        const wasEnabled = tool.enabled
+
+        tool.enabled = toolsId.includes(tool.id)
+
+        if (tool.enabled !== wasEnabled) {
+            console.log(chalk.gray(`[DEBUG] Tool ${tool.id} ${wasEnabled} -> ${tool.enabled}`))
+
+        }
+    })
+
+    const enabledCount = availableTools.filter(t => t.enabled).length;
+    console.log(chalk.gray(`[DEBUG] Enabled ${enabledCount}/${availableTools.length} tools`))
+
+
+}
+
+
+export function getEnabledToolNames() {
+    const enabledTools = availableTools.filter(t => t.enabled).map(t => t.name)
+    console.log(chalk.gray('[DEBUG] getEnabledToolNames returning:'), enabledTools);
+    return enabledTools
+}
+
+export function resetTools() {
+    availableTools.forEach(tool => tool.enabled = false);
+
+    console.log(chalk.gray('[DEBUG] ALl tools have been reset (disabled)'))
+}

package/src/index.js

@@ -0,0 +1,47 @@
+import express from "express";
+import dotenv from "dotenv";
+import { toNodeHandler, fromNodeHeaders } from "better-auth/node";
+import cors from "cors";
+import { auth } from "./lib/auth.js"
+
+dotenv.config()
+
+const app = express()
+
+// *----------- CORS --------------*
+app.use(
+    cors({
+        origin: "https://maverick-cli.vercel.app",
+        methods: ["GET", "POST", "PUT", "DELETE"],
+        credentials: true,
+    })
+);
+
+app.all("/api/auth/*splat", toNodeHandler(auth))
+
+app.use(express.json());
+
+app.get("/api/me", async (req, res) => {
+    const session = await auth.api.getSession({
+        headers: fromNodeHeaders(req.headers),
+    });
+    return res.json(session);
+})
+app.head('/', (req, res) => {
+    res.status(200).end();
+});
+
+
+app.get("/device", async (req, res) => {
+    const { user_code } = req.query
+    res.redirect(`https://maverick-cli.vercel.app/device?user_code=${user_code}`)
+})
+
+
+app.get('/health', (req, res) => {
+    res.send("Backend is running")
+})
+
+app.listen(process.env.PORT, () => {
+    console.log(`running on PORT : http://localhost:${process.env.PORT}`)
+})

package/src/lib/auth.js

@@ -0,0 +1,26 @@
+import { betterAuth } from "better-auth";
+import { prismaAdapter } from "better-auth/adapters/prisma";
+import { deviceAuthorization } from "better-auth/plugins";
+import prisma from "./db.js"
+
+export const auth = betterAuth({
+  database: prismaAdapter(prisma, {
+    provider: "postgresql",
+  }),
+  basePath: "api/auth",
+  trustedOrigins: ["https://maverick-cli.vercel.app"],
+  socialProviders: {
+    github: {
+      clientId: process.env.GITHUB_CLIENT_ID,
+      clientSecret: process.env.GITHUB_CLIENT_SECRET
+    }
+  },
+  plugins: [
+    deviceAuthorization({
+      expiresIn: "30m",
+      interval: "5s",
+    }),
+  ],
+});
+
+

package/src/lib/db.js

@@ -0,0 +1,9 @@
+import {PrismaClient} from "@prisma/client";
+
+const globalForPrisma = global
+
+const prisma = new PrismaClient()
+
+if(process.env.NODE_ENV !== "production") globalForPrisma.prisma = prisma;
+
+export default prisma