@dubeyvishal/orbital-cli 1.0.1

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

@@ -0,0 +1,95 @@
+import chalk from "chalk";
+import {Command} from "commander";
+import yoctoSpinner  from "yocto-spinner";
+import {getStoredToken} from "../../../lib/token.js"
+import prisma from "../../../lib/db.js"
+import { ensureDbConnection } from "../../../lib/dbHealth.js";
+import {select} from "@clack/prompts";
+import {startChat} from "../../../cli/chat/chat-with-ai.js";
+import {startToolChat} from "../../../cli/chat/chat-with-ai-tools.js";
+import {startAgentChat} from "../../../cli/chat/chat-with-ai-agent.js";
+
+
+const wakeUpAction = async()=>{
+    const token = await getStoredToken();
+     if(!token?.access_token){
+        console.log(chalk.red("Not Authenticated. please login"))
+        return ;
+     }
+
+      const dbOk = await ensureDbConnection();
+      if(!dbOk){
+          return;
+      }
+
+     const spinner = yoctoSpinner({text: "Fetching user information ..."})
+     spinner.start()
+
+     let user;
+     try{
+        user = await prisma.user.findFirst({
+            where : {
+                sessions : {
+                    some : {
+                        token : token.access_token
+                    }
+                }
+            },
+            select : {
+                id : true ,
+                name : true ,
+                email : true ,
+                image : true 
+            }
+        });
+     }
+     finally{
+        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: "Agentic Mode",
+                hint : "Advanced AI Agent"
+            },
+        ]
+     });
+
+     switch(choice){
+        case "chat":
+            await startChat("chat");
+            break ;
+        case "tool":
+            await startToolChat();
+            break ;
+        case "agent":
+            await startAgentChat();
+            break ;
+     }
+}
+
+export const wakeUp = new Command("wakeup").
+description("Wake up the AI").
+alias("wake-up").
+alias("wakup").
+action(wakeUpAction)

package/server/src/cli/commands/auth/aboutMe.js

@@ -0,0 +1,76 @@
+import chalk from "chalk";
+import { Command } from "commander";
+import { requireAuth } from "../../../lib/token.js";
+
+const DEFAULT_SERVER_URL = "https://smart-cli-based-agent.onrender.com";
+
+export const whoAmIAction = async (cmdOptions = {})=>{
+    const token = await requireAuth();
+    if(!token?.access_token){
+        console.log("No access token found . Please login.");
+        process.exit(1);
+    }
+
+    const baseUrl =
+        cmdOptions.serverUrl ||
+        process.env.ORBITAL_SERVER_URL ||
+        process.env.BACKEND_URL ||
+        process.env.SERVER_URL ||
+        DEFAULT_SERVER_URL;
+    const authHeaderValue = token.token_type
+        ? `${token.token_type} ${token.access_token}`
+        : `Bearer ${token.access_token}`;
+
+    let res;
+    try {
+        res = await fetch(`${baseUrl}/api/me`, {
+            method: "GET",
+            headers: {
+                Authorization: authHeaderValue,
+            },
+        });
+    } catch (err) {
+        console.error(chalk.red(`Failed to reach server: ${baseUrl}`));
+        console.error(
+            chalk.gray(
+                "Set `ORBITAL_SERVER_URL` (or pass `--server-url`) to your deployed backend, or start your local server.",
+            ),
+        );
+        process.exit(1);
+    }
+
+    if (!res.ok) {
+        const bodyText = await res.text().catch(() => "");
+        console.error(
+            chalk.red(
+                `Failed to fetch session (${res.status} ${res.statusText}). ${bodyText}`.trim(),
+            ),
+        );
+        process.exit(1);
+    }
+
+    const session = await res.json();
+    const user = session?.user;
+
+    if (!user) {
+        console.log(chalk.yellow("No active session found on server."));
+        process.exit(1);
+    }
+
+    console.log(chalk.green("Logged in as:"));
+    console.log(chalk.gray(`id: ${user.id ?? "(unknown)"}`));
+    if (user.name) console.log(chalk.gray(`name: ${user.name}`));
+    if (user.email) console.log(chalk.gray(`email: ${user.email}`));
+}
+
+export const whoAmI = new Command("whoami")
+  .description("Show the currently logged-in user")
+    .option(
+        "--server-url <url>",
+        "Orbital server base URL (e.g. https://smart-cli-based-agent.onrender.com)",
+        process.env.ORBITAL_SERVER_URL ||
+            process.env.BACKEND_URL ||
+            process.env.SERVER_URL ||
+            DEFAULT_SERVER_URL,
+    )
+    .action(whoAmIAction);

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

@@ -0,0 +1,242 @@
+import { cancel, confirm, intro, outro, isCancel } from "@clack/prompts";
+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 { createAuthClient } from "better-auth/client";
+import { deviceAuthorizationClient } from "better-auth/client/plugins";
+import { logger } from "better-auth";
+import { fileURLToPath } from "url";
+import { getStoredToken, isTokenExpired, storeToken ,TOKEN_FILE } from "../../../lib/token.js";
+
+
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const URL = "https://smart-cli-based-agent.onrender.com";
+const CLIENT_ID = process.env.GITHUB_CLIENT_ID;
+
+
+export const loginAction = async (cmdOptions) => {
+  if (!process.env.GOOGLE_GENERATIVE_AI_API_KEY) {
+    console.log(chalk.red("Gemini API key is not set."));
+    console.log(
+      chalk.gray(
+        "Run: orbital setkey <your-gemini-api-key>\nThen run: orbital login",
+      ),
+    );
+    process.exit(1);
+  }
+
+  const schema = z.object({
+    serverUrl: z.string().optional(),
+    clientId: z.string().optional(),
+  });
+
+  const options = schema.parse({
+    serverUrl: cmdOptions.serverUrl,
+    clientId: cmdOptions.clientId,
+  });
+
+  const serverUrl = options.serverUrl || URL;
+  const clientId = options.clientId || CLIENT_ID;
+
+  intro(chalk.bold("Auth CLI Login"));
+
+  const existingToken = await getStoredToken();
+  const expired = await isTokenExpired();
+
+  if (existingToken && !expired) {
+    const shouldReAuth = await confirm({
+      message: "Your are already logged-In. Do You want to login Again",
+      initialValue: false,
+    });
+
+    if (isCancel(shouldReAuth) || !shouldReAuth) {
+      cancel("Login Cancelled");
+      process.exit(0);
+    }
+  }
+
+  const authClient = createAuthClient({
+    baseURL: serverUrl,
+    plugins: [deviceAuthorizationClient()],
+  });
+
+  const spinner = yoctoSpinner({
+    text: "Requesting device authorization...",
+  }).start();
+
+  try {
+    const { data, error } = await authClient.device.code({
+      client_id: clientId,
+      scope: "openid profile email",
+    });
+
+    spinner.stop();
+
+    if (error || !data) {
+      const errorMessage =
+        error?.error_description ||
+        error?.message ||
+        JSON.stringify(error) ||
+        "Unknown error";
+      console.error(
+        chalk.red(`Failed to request device authorization: ${errorMessage}`),
+      );
+      process.exit(1);
+    }
+
+    const {
+      user_code,
+      verification_uri,
+      verification_uri_complete,
+      expires_in,
+      device_code,
+      interval,
+    } = data;
+
+    console.log(chalk.cyan("\nDevice Authorization Required"));
+    console.log(
+      `Visit: ${chalk.underline.blue(
+        verification_uri_complete || verification_uri,
+      )}`,
+    );
+    console.log(`Enter Code: ${chalk.bold.green(user_code)}\n`);
+
+    const shouldOpen = await confirm({
+      message: "Open browser automatically?",
+      initialValue: true,
+    });
+
+    if (!isCancel(shouldOpen) && shouldOpen) {
+      const uriToOpen = verification_uri_complete || verification_uri;
+      await open(uriToOpen);
+    }
+
+    console.log(
+      chalk.gray(
+        `Waiting for authorization (expires in ${Math.floor(
+          expires_in / 60,
+        )} minutes)...`,
+      ),
+    );
+
+    const token = await pollForToken(
+      authClient,
+      device_code,
+      clientId,
+      interval,
+    );
+
+    if (token) {
+      const saved = await storeToken(token);
+
+      if (!saved) {
+        console.log(chalk.yellow("\n Warming: Could not save authentication token."));
+        console.log(chalk.yellow("You may need to login again on next use."));
+      }
+
+      outro(chalk.green("Login successfull !"));
+
+      //console.log(chalk.gray(`\n Token saved to: ${TOKEN_FILE}`));
+
+      console.log(
+        chalk.gray("You can now use AI commands without logging in again. \n "),
+      );
+    }
+  } catch (err) {
+    spinner.stop();
+    console.error(chalk.red("Login failed:"), err);
+    process.exit(1);
+  }
+};
+
+const pollForToken = async (
+  authClient,
+  deviceCode,
+  clientId,
+  initialInterval,
+) => {
+  let pollingInterval = initialInterval;
+  let dots = 0;
+
+  const spinner = yoctoSpinner({ text: "", color: "cyan" });
+
+  return new Promise((resolve, reject) => {
+    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,
+          fetchOptions: {
+            headers: {
+              "user-agent": `My CLI`,
+            },
+          },
+        });
+
+        if (data?.access_token) {
+          console.log(
+            chalk.bold.yellow(`Your access token: ${data.access_token}`),
+          );
+
+          spinner.stop();
+          resolve(data);
+          return;
+        } else if (error) {
+          switch (error.error) {
+            case "authorization_pending":
+              break;
+            case "slow_down":
+              pollingInterval += 5;
+              break;
+            case "access_denied":
+              spinner.stop();
+              console.error("Access was denied by the user");
+              reject(new Error("access_denied"));
+              return;
+            case "expired_token":
+              spinner.stop();
+              console.error("The device code has expired. Please try again.");
+              reject(new Error("expired_token"));
+              return;
+            default:
+              spinner.stop();
+              logger.error(`Error: ${error.error_description}`);
+              reject(
+                new Error(error.error_description || "Unknown device error"),
+              );
+              return;
+          }
+        }
+      } catch (err) {
+        spinner.stop();
+        logger.error(`Error: ${err?.message || err}`);
+        return;
+      }
+
+      setTimeout(poll, pollingInterval * 1000);
+    };
+
+    setTimeout(poll, pollingInterval * 1000);
+  });
+};
+
+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);

package/server/src/cli/commands/auth/logout.js

@@ -0,0 +1,38 @@
+import chalk from "chalk";
+import { cancel, confirm, intro, outro, isCancel } from "@clack/prompts";
+import { Command } from "commander";
+import { clearStoredToken, getStoredToken } from "../../../lib/token.js";
+
+export const logoutAction = async()=>{
+    intro(chalk.bold("Logout"));
+
+    const token = await getStoredToken();
+
+    if(!token){
+        console.log(chalk.yellow("You are not logged in."));
+        process.exit(0);
+    }
+
+    const shouldLogout = await confirm({
+        message : "Are you want to logout?" ,
+        initialValue : false 
+    });
+
+    if(isCancel(shouldLogout) || !shouldLogout){
+        cancel("Logout 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 const logout = new Command("logout")
+  .description("Logout from Better Auth")
+  .action(logoutAction);

package/server/src/cli/commands/config/setkey.js

@@ -0,0 +1,19 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { setGeminiApiKey, ORBITAL_CONFIG_FILE } from "../../../lib/orbitalConfig.js";
+
+const setKeyAction = async (apiKey) => {
+  try {
+    await setGeminiApiKey(apiKey);
+    console.log(chalk.green("Gemini API key saved."));
+    console.log(chalk.gray(`Stored at: ${ORBITAL_CONFIG_FILE}`));
+  } catch (err) {
+    console.log(chalk.red("Failed to save key:"), err?.message || err);
+    process.exit(1);
+  }
+};
+
+export const setkey = new Command("setkey")
+  .description("Set Gemini API key for Orbital")
+  .argument("<apiKey>", "Your Gemini API key")
+  .action(setKeyAction);

package/server/src/cli/main.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+
+import "../config/env.js";
+import chalk from "chalk";
+import figlet from "figlet";
+import {Command} from "commander";
+import {login} from "./commands/auth/login.js"
+import {logout} from "./commands/auth/logout.js"
+import {whoAmI} from "./commands/auth/aboutMe.js"
+import {wakeUp} from "./commands/ai/wakeUp.js"
+import {setkey} from "./commands/config/setkey.js"
+
+const main = async()=>{
+
+    console.log(
+        chalk.cyan(
+            figlet.textSync("Orbital CLI", {
+                font: "Standard",
+                horizontallyLayout : "default"})
+        )
+    )
+
+    console.log(chalk.yellow(" A CLI Based AI Tool \n"));
+
+    const program = new Command("orbital");
+
+    program.version("0.0.1").
+    description("Orbital CLI - A CLI Based AI Tool").
+    addCommand(login).
+    addCommand(logout).
+    addCommand(whoAmI).
+    addCommand(wakeUp).
+    addCommand(setkey)
+
+    program.action(()=>{
+        program.help();
+    });
+
+    program.parse();
+}
+
+main().catch((err)=>{
+    console.log(chalk.red("Error running orbital CLI : " , err));
+    process.exit(1);
+})

package/server/src/config/agentConfig.js

@@ -0,0 +1,176 @@
+import { promises as fs } from "fs";
+import path from "path";
+import chalk from "chalk";
+import { generateObject } from "ai";
+import { z } from "zod";
+
+// Backwards-compat alias (typo) to avoid runtime crashes if referenced.
+const genenateObject = generateObject;
+
+
+const applicationSchema = z.object({
+  folderName: z.string().describe("Kebab-Case folder name for the application"),
+  description: z.string().describe("Brief description of what was created"),
+  files: z.array(
+    z.object({
+      path: z.string().describe("Relative file path (e.g src/App.jsx)"),
+      content: z.string().describe("Complete File Content")
+    }).describe("All files needed for the application")
+  ),
+  setupCommands: z.array(
+    z.string().describe("Bash commands to setup and run (e.g: npm install , npm run dev")
+  ),
+  dependencies: z
+    .array(
+      z.object({
+        name: z.string().describe("NPM package name"),
+        version: z.string().describe("Semver range/version")
+      })
+    )
+    .optional()
+    .describe("NPM dependencies with versions")
+});
+
+const printSystem = (message) => {
+  console.log(message);
+}
+
+const displayFileTree = (files, folderName) => {
+  printSystem(chalk.cyan("📂 Project Structure:"));
+  printSystem(chalk.white(`${folderName}/`));
+
+  // Build a tree structure
+  const tree = {};
+
+  files.forEach((file) => {
+    const parts = file.path.split("/");
+    let current = tree;
+
+    parts.forEach((part, index) => {
+      if (!current[part]) {
+        current[part] = index === parts.length - 1 ? null : {};
+      }
+      current = current[part];
+    });
+  });
+
+  // Recursive print function
+  function printTree(node, prefix = "") {
+    const entries = Object.keys(node || {}).sort();
+
+    entries.forEach((key, index) => {
+      const isLast = index === entries.length - 1;
+      const connector = isLast ? "└── " : "├── ";
+
+      if (node[key] === null) {
+        // file
+        printSystem(chalk.white(`${prefix}${connector}${key}`));
+      } else {
+        // folder
+        printSystem(chalk.gray(`${prefix}${connector}${key}/`));
+        const newPrefix = prefix + (isLast ? "    " : "│   ");
+        printTree(node[key], newPrefix);
+      }
+    });
+  }
+
+  printTree(tree, "  ");
+}
+
+const createApplicationFiles = async(baseDir , folderName , files)=>{
+  const appDir = path.join(baseDir , folderName)
+
+  await fs.mkdir(appDir , {recursive : true});
+
+  printSystem(chalk.cyan(`\n Created directory: ${folderName}/`));
+
+  for(const file of files){
+    const filePath = path.join(appDir , file.path);
+    const fileDir = path.dirname(filePath);
+
+    await fs.mkdir(fileDir , {recursive : true });
+    await fs.writeFile(filePath , file.content , "utf8");
+    printSystem(chalk.green(` ${file.path}`));
+  }
+
+  return appDir ;
+
+}
+
+
+export const generateApplication = async (description, aiService, cwd = process.cwd()) => {
+  try {
+    printSystem(chalk.cyan(`\n Agent Mode: Generating your application...\n`));
+    printSystem(chalk.gray(`Request: ${description}\n`));
+
+    printSystem(chalk.magenta("Agent Response: \n"));
+
+    const { object: application } = await generateObject({
+      model: aiService.model,
+      schema: applicationSchema,
+      prompt: `Create a complete, production-ready application for: ${description}
+
+CRITICAL REQUIREMENTS:
+1. Generate ALL files needed for the application to run
+2. Include package.json with ALL dependencies and correct versions
+3. Include README.md with setup instructions
+4. Include configuration files (.gitignore, etc.)
+5. Write clean, well-commented, production-ready code
+6. Include error handling and input validation
+7. Use modern JavaScript/TypeScript best practices
+8. Make sure all imports and paths are correct
+9. NO PLACEHOLDERS - everything must be complete and working
+
+Provide:
+- A meaningful kebab-case folder name
+- All necessary files with complete content
+- Setup commands (cd folder, npm install, npm run dev, etc.)
+- All dependencies with versions`
+
+    });
+
+    printSystem(chalk.green(`\n Generated: ${application.folderName}`));
+    printSystem(chalk.green(`\n Description: ${application.description}`));
+
+    if (application.files.length === 0) {
+      throw new Error("No files were generated");
+    }
+    displayFileTree(application.files, application.folderName);
+
+    printSystem(chalk.cyan("\n Creating files...\n"));
+    
+    const appDir  = await createApplicationFiles(
+      cwd , 
+      application.folderName ,
+      application.files
+    );
+
+    printSystem(chalk.green.bold(`\n Application created successfully!`));
+    printSystem(chalk.cyan(`Location: ${chalk.bold(appDir)}\n`));
+
+    if(application.setupCommands.length > 0){
+        printSystem(chalk.cyan(`Next Steps: \n`));
+      printSystem(chalk.white("```bash"));
+      application.setupCommands.forEach(cmd =>{
+        printSystem(chalk.white(cmd))
+      });
+
+      printSystem(chalk.white("```\n"));
+    }
+
+    return {
+      folderName: application.folderName ,
+      appDir ,
+      files: application.files.map(f=> f.path),
+      commands : application.setupCommands,
+      success: true 
+    }
+  }
+  catch (error) {
+    printSystem(chalk.red(`\n Error generating application: ${error.message}\n`));
+    if(error.stack){
+      printSystem(chalk.dim(error.stack + "\n"));
+    }
+    throw error ;
+  }
+}