@dubeyvishal/orbital-cli 1.0.1

package/server/src/config/env.js

@@ -0,0 +1,100 @@
+import dotenv from "dotenv";
+import path from "path";
+import { fileURLToPath } from "url";
+import fs from "fs";
+import os from "os";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Load env from the server package root (server/.env) regardless of where the process is started.
+const serverEnvPath = path.resolve(__dirname, "../../.env");
+
+dotenv.config({ path: serverEnvPath });
+
+// Load Orbital user config (stored in the user's home directory) and
+// hydrate env vars if they are not already set.
+try {
+	const orbitalConfigPath = path.join(os.homedir(), ".orbital", "config.json");
+	if (!process.env.GOOGLE_GENERATIVE_AI_API_KEY && fs.existsSync(orbitalConfigPath)) {
+		const raw = fs.readFileSync(orbitalConfigPath, "utf-8");
+		const parsed = JSON.parse(raw);
+		if (parsed?.geminiApiKey && typeof parsed.geminiApiKey === "string") {
+			process.env.GOOGLE_GENERATIVE_AI_API_KEY = parsed.geminiApiKey.trim();
+		}
+	}
+} catch {
+	// ignore
+}
+
+const stripWrappingQuotes = (value) => {
+	if (typeof value !== "string") return value;
+	return value.replace(/^\s*"|"\s*$/g, "").trim();
+};
+
+const normalizeNeonPostgresUrl = (raw) => {
+	const cleaned = stripWrappingQuotes(raw);
+	if (!cleaned) return cleaned;
+
+	try {
+		const url = new URL(cleaned);
+		const host = url.hostname || "";
+
+		const isNeon = host.endsWith("neon.tech");
+		if (!isNeon) return cleaned;
+
+		const isPooler = host.includes("-pooler.");
+
+		// Neon requires TLS.
+		if (!url.searchParams.has("sslmode")) url.searchParams.set("sslmode", "require");
+
+		// When using Neon pooler (PgBouncer), Prisma should run in PgBouncer mode
+		// and keep connection limits low.
+		if (isPooler && !url.searchParams.has("pgbouncer")) {
+			url.searchParams.set("pgbouncer", "true");
+		}
+		if (isPooler && !url.searchParams.has("connection_limit")) {
+			url.searchParams.set("connection_limit", "1");
+		}
+
+		// Avoid long hangs on cold/paused branches or blocked networks.
+		if (!url.searchParams.has("connect_timeout")) {
+			url.searchParams.set("connect_timeout", "10");
+		}
+
+		return url.toString();
+	} catch {
+		return cleaned;
+	}
+};
+
+if (process.env.DATABASE_URL) {
+	process.env.DATABASE_URL = normalizeNeonPostgresUrl(process.env.DATABASE_URL);
+}
+
+if (process.env.DIRECT_DATABASE_URL) {
+	process.env.DIRECT_DATABASE_URL = normalizeNeonPostgresUrl(
+		process.env.DIRECT_DATABASE_URL
+	);
+}
+
+// Helpful warnings for common Neon misconfigurations.
+try {
+	if (process.env.DATABASE_URL) {
+		const url = new URL(process.env.DATABASE_URL);
+		if (url.hostname.includes("-pooler.") && url.searchParams.get("pgbouncer") !== "true") {
+			// eslint-disable-next-line no-console
+			console.warn(
+				"[env] DATABASE_URL points to a Neon pooler host but is missing `pgbouncer=true`. Add it to avoid Prisma connection issues."
+			);
+		}
+		if (url.hostname.endsWith("neon.tech") && url.searchParams.get("sslmode") !== "require") {
+			// eslint-disable-next-line no-console
+			console.warn(
+				"[env] Neon Postgres should use TLS. Ensure DATABASE_URL includes `sslmode=require`."
+			);
+		}
+	}
+} catch {
+	// ignore
+}

package/server/src/config/googleConfig.js

@@ -0,0 +1,6 @@
+import "./env.js";
+
+export const config = {
+    googleApiKey : process.env.GOOGLE_GENERATIVE_AI_API_KEY || "",
+    model : process.env.ORBITAL_MODEL || "gemini-2.5-flash"
+}

package/server/src/config/toolConfig.js

@@ -0,0 +1,113 @@
+import { google } from "@ai-sdk/google";
+import chalk from "chalk";
+
+export const availableTools = [
+  {
+    id: "google_search",
+    name: "Google Search",
+    description:
+      "Access the latest information using Google Search. Useful for current events, news, and real-time information",
+    getTool: () => google.tools.googleSearch({}),
+    enabled: false,
+  },
+  {
+    id: "code_execution",
+    name: "Code Execution",
+    description:
+      "Generate and execute Python code to perform calculations, solve problems or provide accurate information",
+    getTool: () => google.tools.codeExecution({}),
+    enabled: false,
+  },
+  {
+    id: "url_context",
+    name: "URL Context",
+    description:
+      "Provide specific URLs that you want the model to analyse directly from the prompt. Supports up to 20 URLs per request.",
+    getTool: () => google.tools.urlContext({}),
+    enabled: false,
+  },
+];
+
+export const getEnabledTools = () => {
+  const tools = {};
+
+  try {
+    for (const toolConfig of availableTools) {
+      if (toolConfig.enabled) {
+        tools[toolConfig.id] = toolConfig.getTool();
+      }
+    }
+
+    if (Object.keys(tools).length > 0) {
+      console.log(
+        chalk.gray(`[DEBUG] Enabled tools: ${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] Failed to initialize tools:`),
+      error?.message || error
+    );
+    console.error(
+      chalk.yellow(`Make sure you have @ai-sdk/google version 2.0+ installed`)
+    );
+    console.error(chalk.yellow(`Run: npm install @ai-sdk/google@latest`));
+    return undefined;
+  }
+};
+
+export const toggleTool = (toolId) => {
+  const tool = availableTools.find((t) => t.id === toolId);
+
+  if (tool) {
+    tool.enabled = !tool.enabled;
+    console.log(
+      chalk.gray(`[DEBUG] Tool ${toolId} toggled to ${tool.enabled}`)
+    );
+    return tool.enabled;
+  }
+
+  console.log(chalk.red(`[DEBUG] Tool ${toolId} not found`));
+  return false;
+};
+
+export const toogleTool = toggleTool;
+
+export const enableTools = (toolIds = []) => {
+  console.log(chalk.gray(`[DEBUG] enableTools called with:`), toolIds);
+
+  availableTools.forEach((tool) => {
+    const wasEnabled = tool.enabled;
+    tool.enabled = toolIds.includes(tool.id);
+
+    if (tool.enabled !== wasEnabled) {
+      console.log(
+        chalk.gray(`[DEBUG] ${tool.id}: ${wasEnabled} -> ${tool.enabled}`)
+      );
+    }
+  });
+
+  const enabledCount = availableTools.filter((t) => t.enabled).length;
+  console.log(
+    chalk.gray(
+      `[DEBUG] Total tools enabled: ${enabledCount} / ${availableTools.length}`
+    )
+  );
+};
+
+export const getEnabledToolNames = () => {
+  const names = availableTools.filter((t) => t.enabled).map((t) => t.name);
+  console.log(chalk.gray(`[DEBUG] getEnabledToolNames returning:`), names);
+  return names;
+};
+
+export const resetTools = () => {
+  availableTools.forEach((tool) => {
+    tool.enabled = false;
+  });
+  console.log(chalk.gray(`[DEBUG] All tools have been reset (disabled)`));
+};

package/server/src/lib/auth.js

@@ -0,0 +1,37 @@
+import "../config/env.js";
+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",
+    }),
+    // IMPORTANT: When the frontend proxies `/api/*` to the backend (Next.js rewrites),
+    // auth cookies are set on the frontend origin. The OAuth callback must therefore
+    // also land on the frontend origin to avoid `state_mismatch`.
+    baseURL:
+      process.env.BETTER_AUTH_BASE_URL ||
+      process.env.FRONTEND_URL ||
+      process.env.CLIENT_ORIGIN ||
+      "http://localhost:3000",
+    basePath:"/api/auth" ,
+    trustedOrigins: [
+      process.env.CLIENT_ORIGIN ||
+        process.env.FRONTEND_URL ||
+        "https://smart-cli-based-agent-t7x4.vercel.app",
+      "http://localhost:3000",
+    ],
+    plugins: [
+    deviceAuthorization({ 
+      verificationUri: "/device", 
+    }), 
+  ],
+    socialProviders :{
+        github : {
+            clientId : process.env.GITHUB_CLIENT_ID ,
+            clientSecret: process.env.GITHUB_CLIENT_SECRET
+        }
+    }
+});

package/server/src/lib/db.js

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

package/server/src/lib/dbHealth.js

@@ -0,0 +1,106 @@
+import chalk from "chalk";
+import prisma from "./db.js";
+
+const stripWrappingQuotes = (value) => {
+  if (typeof value !== "string") return value;
+  return value.replace(/^\s*"|"\s*$/g, "").trim();
+};
+
+export const getDatabaseHostHint = () => {
+  const raw = stripWrappingQuotes(process.env.DATABASE_URL);
+  if (!raw) return undefined;
+
+  try {
+    const url = new URL(raw);
+    const port = url.port || "5432";
+    return `${url.hostname}:${port}`;
+  } catch {
+    return undefined;
+  }
+};
+
+export const isPrismaDbConnectionError = (error) => {
+  const message = String(error?.message || "");
+  return (
+    error?.name === "PrismaClientInitializationError" ||
+    message.includes("Can't reach database server") ||
+    message.includes("P1001")
+  );
+};
+
+export const formatDbConnectionTroubleshooting = () => {
+  const hostHint = getDatabaseHostHint();
+  const hostLine = hostHint ? ` at ${hostHint}` : "";
+
+  return [
+    chalk.red(`Database connection failed${hostLine}.`),
+    chalk.gray("\nFix checklist:"),
+    chalk.gray("- Verify `server/.env` has a valid `DATABASE_URL`"),
+    chalk.gray("- Ensure your Neon project/branch is running (not paused)"),
+    chalk.gray("- Check VPN/firewall/outbound access to port 5432"),
+    chalk.gray("- If you changed schema, run: `npm run prisma:migrate` in server/"),
+  ].join("\n");
+};
+
+export const ensureDbConnection = async () => {
+  return ensureDbConnectionWithRetry();
+};
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+export const ensureDbConnectionWithRetry = async (options = {}) => {
+  const {
+    retries = Number(process.env.DB_CONNECT_RETRIES || 6),
+    initialDelayMs = 500,
+    maxDelayMs = 5000,
+    logAttempts = true,
+  } = options;
+
+  const attempts = Math.max(1, Number(retries) + 1);
+  let delayMs = initialDelayMs;
+
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    try {
+      await prisma.$connect();
+      await prisma.$queryRaw`SELECT 1`;
+      return true;
+    } catch (error) {
+      const isConnectionError = isPrismaDbConnectionError(error);
+      const isLastAttempt = attempt === attempts;
+
+      if (!isLastAttempt && isConnectionError) {
+        if (logAttempts) {
+          const hostHint = getDatabaseHostHint();
+          const hostLine = hostHint ? ` (${hostHint})` : "";
+          console.log(
+            chalk.yellow(
+              `Database not reachable${hostLine}. Retry ${attempt}/${attempts - 1} in ${delayMs}ms...`
+            )
+          );
+        }
+        await sleep(delayMs);
+        delayMs = Math.min(maxDelayMs, Math.floor(delayMs * 1.8));
+        continue;
+      }
+
+      if (isConnectionError) {
+        console.log(formatDbConnectionTroubleshooting());
+        return false;
+      }
+
+      console.log(chalk.red(`Database error: ${error?.message || error}`));
+      return false;
+    }
+  }
+
+  return false;
+};
+
+export const ensureDbConnectionOrExit = async (options = {}) => {
+  const ok = await ensureDbConnectionWithRetry(options);
+  if (ok) return true;
+
+  // eslint-disable-next-line no-console
+  console.error(chalk.red("\nServer cannot start without database connectivity. Exiting."));
+  process.exit(1);
+};

package/server/src/lib/orbitalConfig.js

@@ -0,0 +1,44 @@
+import fs from "fs";
+import fsPromises from "fs/promises";
+import os from "os";
+import path from "path";
+
+export const ORBITAL_CONFIG_DIR = path.join(os.homedir(), ".orbital");
+export const ORBITAL_CONFIG_FILE = path.join(ORBITAL_CONFIG_DIR, "config.json");
+
+export const readOrbitalConfigSync = () => {
+  try {
+    if (!fs.existsSync(ORBITAL_CONFIG_FILE)) return {};
+    const raw = fs.readFileSync(ORBITAL_CONFIG_FILE, "utf-8");
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+};
+
+export const getGeminiApiKeySync = () => {
+  const config = readOrbitalConfigSync();
+  const key = config?.geminiApiKey;
+  return typeof key === "string" ? key.trim() : "";
+};
+
+export const setGeminiApiKey = async (apiKey) => {
+  const trimmed = typeof apiKey === "string" ? apiKey.trim() : "";
+  if (!trimmed) throw new Error("API key is required");
+
+  await fsPromises.mkdir(ORBITAL_CONFIG_DIR, { recursive: true });
+
+  const nextConfig = {
+    geminiApiKey: trimmed,
+    updatedAt: new Date().toISOString(),
+  };
+
+  await fsPromises.writeFile(
+    ORBITAL_CONFIG_FILE,
+    JSON.stringify(nextConfig, null, 2),
+    "utf-8",
+  );
+
+  return true;
+};

package/server/src/lib/token.js

@@ -0,0 +1,86 @@
+
+import chalk from "chalk"
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+
+
+export const CONFIG_DIR = path.join(os.homedir(), ".better-auth");
+export const TOKEN_FILE = path.join(CONFIG_DIR, "token.json");
+
+export const getStoredToken = async ()=>{
+    try{
+        const data = await fs.readFile(TOKEN_FILE , "utf-8");
+        const token = JSON.parse(data);
+        return token ;
+    }
+    catch(error){
+        return null ;
+    }
+}
+
+
+export const storeToken = async(token)=>{
+    try{
+        await fs.mkdir(CONFIG_DIR , { recursive : true });
+
+        const tokenData = {
+            access_token : token.access_token,
+            refresh_token : token.refresh_token ,
+            token_type : token.token_type ,
+            scope : token.scope ,
+            expires_at : token.expires_in
+            ? new Date(Date.now() + token.expires_in*1000).toISOString()
+            : null ,
+            created_at : new Date().toISOString() ,
+        };
+
+        await fs.writeFile(TOKEN_FILE , JSON.stringify(tokenData , null , 2), "utf-8");
+        return true ;
+    }
+    catch(err){
+        console.log(chalk.red("Failed to store token: " ) , err.message);
+        return false ;
+    }
+}
+
+export const clearStoredToken = async ()=>{
+    try{
+        await fs.unlink(TOKEN_FILE);
+        return true ;
+    }
+    catch(err){
+        return false ;
+    }
+}
+
+export const isTokenExpired = async()=>{
+    const token = await getStoredToken();
+    if(!token || !token.expires_at){
+        return true ;
+    }
+
+    const expiresAt = new Date(token.expires_at);
+    const now  = new Date();
+
+    return expiresAt.getTime() - now.getTime() < 5*60*1000 ;
+}
+
+export const requireAuth = async()=>{
+    const token = await getStoredToken();
+
+    if(!token){
+        console.log(
+            chalk.red("Not authenticated . PLease run 'orbital login' first")
+        )
+        process.exit(1);
+    }
+    if(await isTokenExpired()){
+        console.log(
+            chalk.yellow("Your session has expired. Please login again.")
+        );
+        console.log(chalk.gray("Run: orbital login \n"));
+        process.exit(1);
+    }
+    return token ;
+}

package/server/src/service/chatService.js

@@ -0,0 +1,156 @@
+import prisma from "../lib/db.js";
+
+export class ChatService{
+
+    /**
+     * Create a new conversation
+     * @param {string} userId - user id 
+     * @param {string} mode - chat tool , or agent
+     * @param {string} title - Optional conversation title
+     */
+
+    async createConversation(userId , mode ="chat" , title=null){
+        return prisma.conversation.create({
+            data : {
+                userId ,
+                mode ,
+                title : title || `New ${mode} conversation`
+            }
+        });
+    }
+
+    /**
+     * get or create a new conversation for user
+     * @param {string} userId - user id 
+     * @param {string} conversationalId - Optional conversation id
+     * @param {string} mode - chat , tool or agent
+     */
+
+    async getOrCreateConversation(userId , conversationId =null , mode="chat"){
+        if(conversationId){
+            const conversation  = await prisma.conversation.findFirst({
+                where : {
+                    id: conversationId ,
+                    userId
+                },
+                include : {
+                    messages : {
+                        orderBy :{
+                            createdAt : "asc"
+                        }
+                    }
+                }
+            });
+
+            if(conversation){
+                return conversation ;
+            }
+        }
+        return await this.createConversation(userId , mode)
+    }
+
+    /**
+     * Add a  new message to conversation
+     * @param {string} conversationalId - conversation id 
+     * @param {string} role - user , assistant , system  ,tool
+     * @param {string | object} content - message content
+     */
+
+    async addMessage(conversationId , role , content){
+
+        const contentStr = typeof content === "string" ? content :
+        JSON.stringify(content);
+
+        return await prisma.message.create({
+            data :{
+                conversationId ,
+                role ,
+                content : contentStr
+            }
+    })
+    }
+
+    /**
+     * Get conversion messages
+     * @param {string} conversationId - conversational -id
+     */
+
+    async getMessages(conversationId){
+        const messages = await prisma.message.findMany({
+            where : {conversationId},
+            orderBy : {createdAt : "asc"}
+        });
+
+        return messages.map((msg) => ({
+            ...msg,
+            content: this.parseContent(msg.content),
+        }));
+    }
+
+    /**
+     * @param {string} userI - user id
+     */
+
+    async getUserConversation(userId){
+        return await prisma.conversation.findMany({
+            where : {userId} ,
+            orderBy :{updatedAt : "desc"},
+            include :{
+                messages : {
+                    take : 1,
+                    orderBy : {createdAt : "desc"}
+                },
+            },
+        });
+    }
+
+    /**
+     * @param {string} conversationId - Conversation ID
+     * @param {string} userId - User ID 
+     */
+
+    async deleteConversation(conversationId , userId){
+        return await prisma.conversation.deleteMany({
+            where : {
+                id : conversationId ,
+                userId
+            },
+        });
+    }
+
+    /**
+     * @param {string} conversationId - Conversation ID
+     * @param {string} title - User ID 
+     */
+
+    async updateTitle(conversationId , title){
+        return await prisma.conversation.update({
+            where : {id : conversationId},
+            data : {title}
+        });
+    }
+
+    /**
+     * Helper to parse content ( json to string)
+     */
+
+    parseContent(content){
+        try{
+            return JSON.parse(content);
+        }
+        catch{
+            return content
+        }
+    }
+
+    /**
+     * @param {Array} messages - database messages
+     */
+
+    formatMessageForAI(messages){
+        return messages.map((msg)=>({
+            role : msg.role ,
+            content : typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
+        }));
+    }
+}