@dubeyvishal/orbital-cli 1.0.4 → 1.0.6

package/server/{commands → src/cli/commands}/auth/logout.js

@@ -1,7 +1,7 @@
 import chalk from "chalk";
 import { cancel, confirm, intro, outro, isCancel } from "@clack/prompts";
 import { Command } from "commander";
-import { clearStoredToken, getStoredToken } from "../../utils/token.js";
+import { clearStoredToken, getStoredToken } from "../../../lib/token.js";
 
 export const logoutAction = async()=>{
     intro(chalk.bold("Logout"));

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

@@ -0,0 +1,26 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { setGeminiApiKey } from "../../../lib/orbitalConfig.js";
+import { getCredentialServiceName } from "../../../lib/credentialStore.js";
+
+const setKeyAction = async (apiKey) => {
+  try {
+    await setGeminiApiKey(apiKey);
+    console.log(chalk.green("Gemini API key saved."));
+    console.log(
+      chalk.gray(
+        `Stored securely in your OS credential manager (service: ${getCredentialServiceName()}).`
+      )
+    );
+  } catch (err) {
+    console.log(chalk.red("Failed to save key:"), err?.message || err);
+    process.exit(1);
+  }
+};
+
+export const setkey = new Command("set-key")
+  .description("Store your Gemini API key securely (keytar)")
+  .argument("<API_KEY>", "Your Gemini API key")
+  .alias("set")
+  .alias("setkey")
+  .action(setKeyAction);

package/server/{main.js → src/cli/main.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import "./config/env.js";
+import "../config/env.js";
 import chalk from "chalk";
 import figlet from "figlet";
 import {Command} from "commander";

package/server/src/cli/utils/apiClient.js

@@ -0,0 +1,66 @@
+import chalk from "chalk";
+import { API_BASE } from "../../config/api.js";
+import { getStoredToken, requireAuth } from "../../lib/token.js";
+
+const buildUrl = (path) => {
+  const normalized = path.startsWith("/") ? path : `/${path}`;
+  return `${API_BASE}${normalized}`;
+};
+
+const getAuthHeader = async (isRequired) => {
+  const token = isRequired ? await requireAuth() : await getStoredToken();
+  if (!token?.access_token) return {};
+
+  const headerValue = token.token_type
+    ? `${token.token_type} ${token.access_token}`
+    : `Bearer ${token.access_token}`;
+
+  return { Authorization: headerValue };
+};
+
+export const apiRequest = async (
+  path,
+  { method = "GET", body, requireAuth: isRequired = true } = {}
+) => {
+  const headers = {
+    "content-type": "application/json",
+    ...(await getAuthHeader(isRequired)),
+  };
+
+  let response;
+  try {
+    response = await fetch(buildUrl(path), {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : undefined,
+    });
+  } catch (error) {
+    throw new Error(`Failed to reach server at ${API_BASE}`);
+  }
+
+  const text = await response.text();
+  let data = null;
+  if (text) {
+    try {
+      data = JSON.parse(text);
+    } catch {
+      data = null;
+    }
+  }
+
+  if (!response.ok) {
+    const errorMessage = data?.error || data?.message || response.statusText;
+    throw new Error(`${errorMessage} (HTTP ${response.status})`);
+  }
+
+  return data;
+};
+
+export const apiRequestSafe = async (...args) => {
+  try {
+    return await apiRequest(...args);
+  } catch (error) {
+    console.error(chalk.red(error?.message || "Request failed"));
+    throw error;
+  }
+};

package/server/{config → src/config}/agentConfig.js

@@ -8,7 +8,7 @@ import { z } from "zod";
 const genenateObject = generateObject;
 
 
-const applicationSchema = z.object({
+export 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(
@@ -35,7 +35,7 @@ const printSystem = (message) => {
   console.log(message);
 }
 
-const displayFileTree = (files, folderName) => {
+export const displayFileTree = (files, folderName) => {
   printSystem(chalk.cyan("📂 Project Structure:"));
   printSystem(chalk.white(`${folderName}/`));
 
@@ -77,7 +77,7 @@ const displayFileTree = (files, folderName) => {
   printTree(tree, "  ");
 }
 
-const createApplicationFiles = async(baseDir , folderName , files)=>{
+export const createApplicationFiles = async(baseDir , folderName , files)=>{
   const appDir = path.join(baseDir , folderName)
 
   await fs.mkdir(appDir , {recursive : true});
@@ -97,18 +97,11 @@ const createApplicationFiles = async(baseDir , folderName , files)=>{
 
 }
 
-
-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}
+export const generateApplicationPlan = async (description, aiService) => {
+  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
@@ -125,9 +118,21 @@ 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`
+- All dependencies with versions`,
+  });
 
-    });
+  return application;
+};
+
+
+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 application = await generateApplicationPlan(description, aiService);
 
     printSystem(chalk.green(`\n Generated: ${application.folderName}`));
     printSystem(chalk.green(`\n Description: ${application.description}`));

package/server/src/config/api.js

@@ -0,0 +1,22 @@
+const DEFAULT_API_BASE = "https://smart-cli-based-agent.onrender.com";
+const DEFAULT_FRONTEND_URL = "https://smart-cli-based-agent-t7x4.vercel.app";
+
+const stripTrailingSlash = (value) => {
+  if (typeof value !== "string") return value;
+  return value.replace(/\/+$/, "");
+};
+
+export const API_BASE = stripTrailingSlash(
+  process.env.ORBITAL_SERVER_URL ||
+    process.env.BACKEND_URL ||
+    process.env.SERVER_URL ||
+    DEFAULT_API_BASE
+);
+
+export const FRONTEND_URL = stripTrailingSlash(
+  process.env.FRONTEND_URL || process.env.CLIENT_ORIGIN || DEFAULT_FRONTEND_URL
+);
+
+export const AUTH_BASE_URL = stripTrailingSlash(
+  process.env.BETTER_AUTH_BASE_URL || API_BASE
+);

package/server/src/config/env.js

@@ -0,0 +1,86 @@
+import dotenv from "dotenv";
+import path from "path";
+import { fileURLToPath } from "url";
+
+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 });
+
+// Note: The Gemini API key is stored in the OS credential manager via keytar.
+// CLI code will hydrate GOOGLE_GENERATIVE_AI_API_KEY from keytar when needed.
+
+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/{config → src/config}/toolConfig.js

@@ -1,5 +1,6 @@
 import { google } from "@ai-sdk/google";
 import chalk from "chalk";
+import { requireGeminiApiKeySync } from "../lib/orbitalConfig.js";
 
 export const availableTools = [
   {
@@ -32,6 +33,12 @@ export const getEnabledTools = () => {
   const tools = {};
 
   try {
+    const enabledToolCount = availableTools.filter((t) => t.enabled).length;
+    if (enabledToolCount > 0 && !process.env.GOOGLE_GENERATIVE_AI_API_KEY) {
+      
+      requireGeminiApiKeySync();
+    }
+
     for (const toolConfig of availableTools) {
       if (toolConfig.enabled) {
         tools[toolConfig.id] = toolConfig.getTool();

package/server/src/controllers/aiController.js

@@ -0,0 +1,58 @@
+import { ChatService } from "../services/chatService.js";
+import { getAIService } from "../services/aiService.js";
+import { enableTools, getEnabledTools, resetTools } from "../config/toolConfig.js";
+import { generateApplicationPlan } from "../config/agentConfig.js";
+
+const chatService = new ChatService();
+
+export const respond = async (req, res, next) => {
+  try {
+    const { conversationId, mode, toolIds } = req.body || {};
+
+    if (!conversationId) {
+      return res.status(400).json({ error: "conversationId is required" });
+    }
+
+    const messages = await chatService.getMessages(conversationId);
+    const aiMessages = chatService.formatMessageForAI(messages);
+
+    let tools;
+    if (mode === "tool") {
+      resetTools();
+      if (Array.isArray(toolIds)) {
+        enableTools(toolIds);
+      }
+      tools = getEnabledTools();
+    }
+
+    const aiService = getAIService();
+    const result = await aiService.sendMessage(aiMessages, null, tools);
+
+    await chatService.addMessage(conversationId, "assistant", result.content);
+
+    return res.json({
+      content: result.content,
+      toolCalls: result.toolCalls || [],
+      toolResults: result.toolResults || [],
+    });
+  } catch (error) {
+    return next(error);
+  }
+};
+
+export const generateAgentPlan = async (req, res, next) => {
+  try {
+    const { description } = req.body || {};
+
+    if (!description || typeof description !== "string") {
+      return res.status(400).json({ error: "description is required" });
+    }
+
+    const aiService = getAIService();
+    const application = await generateApplicationPlan(description, aiService);
+
+    return res.json({ application });
+  } catch (error) {
+    return next(error);
+  }
+};

package/server/src/controllers/cliController.js

@@ -0,0 +1,77 @@
+import { ChatService } from "../services/chatService.js";
+
+const chatService = new ChatService();
+
+export const getMe = async (req, res) => {
+  return res.json({
+    user: req.user,
+    session: {
+      id: req.session?.id,
+      expiresAt: req.session?.expiresAt,
+    },
+  });
+};
+
+export const initConversation = async (req, res, next) => {
+  try {
+    const { conversationId, mode } = req.body || {};
+
+    const conversation = await chatService.getOrCreateConversation(
+      req.user.id,
+      conversationId || null,
+      mode || "chat"
+    );
+
+    const messages = await chatService.getMessages(conversation.id);
+
+    return res.json({ conversation, messages });
+  } catch (error) {
+    return next(error);
+  }
+};
+
+export const addMessage = async (req, res, next) => {
+  try {
+    const { conversationId, role, content } = req.body || {};
+
+    if (!conversationId || !role) {
+      return res.status(400).json({ error: "conversationId and role are required" });
+    }
+
+    const message = await chatService.addMessage(conversationId, role, content);
+    return res.json({ message });
+  } catch (error) {
+    return next(error);
+  }
+};
+
+export const getMessages = async (req, res, next) => {
+  try {
+    const { conversationId } = req.query || {};
+
+    if (!conversationId) {
+      return res.status(400).json({ error: "conversationId is required" });
+    }
+
+    const messages = await chatService.getMessages(conversationId);
+    return res.json({ messages });
+  } catch (error) {
+    return next(error);
+  }
+};
+
+export const updateTitle = async (req, res, next) => {
+  try {
+    const { id } = req.params || {};
+    const { title } = req.body || {};
+
+    if (!id || !title) {
+      return res.status(400).json({ error: "title is required" });
+    }
+
+    const conversation = await chatService.updateTitle(id, title);
+    return res.json({ conversation });
+  } catch (error) {
+    return next(error);
+  }
+};

package/server/src/db/prisma.js

@@ -0,0 +1,3 @@
+import prisma from "../lib/db.js";
+
+export default prisma;

package/server/src/index.js

@@ -0,0 +1,108 @@
+import "./config/env.js";
+import express from "express";
+import { fromNodeHeaders, toNodeHandler } from "better-auth/node";
+import cors from "cors";
+import { auth } from "./lib/auth.js";
+import prisma from "./lib/db.js";
+import { ensureDbConnectionOrExit } from "./lib/dbHealth.js";
+import { FRONTEND_URL } from "./config/api.js";
+import cliRoutes from "./routes/cliRoutes.js";
+import authRoutes from "./routes/authRoutes.js";
+import { errorHandler } from "./middleware/errorHandler.js";
+
+const app = express();
+const PORT = process.env.PORT || 8080;
+const CLIENT_ORIGIN = FRONTEND_URL;
+
+app.use(express.json());
+
+app.use(
+  cors({
+    origin: CLIENT_ORIGIN,
+    methods: ["GET", "POST", "PUT", "DELETE"],
+    credentials: true,
+  })
+);
+
+app.all("/api/auth/*splat", toNodeHandler(auth));
+
+app.use("/auth", authRoutes);
+
+app.get("/api/me" , async (req, res)=>{
+  const session = await auth.api.getSession({
+    headers : fromNodeHeaders (req.headers),
+  });
+
+  if (session) {
+    return res.json(session);
+  }
+
+  const authHeader = req.headers.authorization;
+  if (!authHeader) {
+    return res.status(401).json(null);
+  }
+
+  const [scheme, credentials] = authHeader.split(" ");
+  if (!scheme || !credentials || scheme.toLowerCase() !== "bearer") {
+    return res.status(400).json({ error: "Invalid Authorization header" });
+  }
+
+  const dbSession = await prisma.session.findUnique({
+    where: { token: credentials },
+    include: { user: true },
+  });
+
+  if (!dbSession) {
+    return res.status(401).json(null);
+  }
+
+  if (dbSession.expiresAt && dbSession.expiresAt.getTime() <= Date.now()) {
+    return res.status(401).json({ error: "Session expired" });
+  }
+
+  return res.json({
+    user: dbSession.user,
+    session: {
+      id: dbSession.id,
+      expiresAt: dbSession.expiresAt,
+    },
+  });
+});
+
+app.get("/device" , async(req , res)=>{
+  const {user_code} = req.query;
+  res.redirect(`${CLIENT_ORIGIN}/device?user_code=${user_code}`)
+});
+
+app.use("/api/cli", cliRoutes);
+
+app.use(errorHandler);
+
+const start = async () => {
+  await ensureDbConnectionOrExit({
+    retries: Number(process.env.DB_CONNECT_RETRIES || 10),
+    initialDelayMs: Number(process.env.DB_CONNECT_INITIAL_DELAY_MS || 500),
+    maxDelayMs: Number(process.env.DB_CONNECT_MAX_DELAY_MS || 5000),
+  });
+
+  const server = app.listen(PORT, () => {
+    console.log(`Server is running on ${PORT}`);
+  });
+
+  const shutdown = async (signal) => {
+    try {
+      console.log(`\nReceived ${signal}. Shutting down...`);
+      server.close(() => {
+        process.exitCode = 0;
+      });
+      await prisma.$disconnect();
+    } catch {
+      process.exit(1);
+    }
+  };
+
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+};
+
+start();

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";
+import { FRONTEND_URL } from "../config/api.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.FRONTEND_URL ||
+      process.env.CLIENT_ORIGIN ||
+      FRONTEND_URL,
+    basePath:"/api/auth" ,
+    trustedOrigins: [
+      process.env.CLIENT_ORIGIN ||
+        process.env.FRONTEND_URL ||
+        FRONTEND_URL,
+      FRONTEND_URL,
+    ],
+    plugins: [
+    deviceAuthorization({ 
+      verificationUri: "/device", 
+    }), 
+  ],
+    socialProviders :{
+        github : {
+            clientId : process.env.GITHUB_CLIENT_ID ,
+            clientSecret: process.env.GITHUB_CLIENT_SECRET
+        }
+    }
+});

package/server/src/lib/credentialStore.js

@@ -0,0 +1,47 @@
+const ORBITAL_KEYTAR_SERVICE = "orbital-cli";
+const ORBITAL_API_KEY_ACCOUNT = "api-key";
+
+const loadKeytar = async () => {
+  try {
+    const mod = await import("keytar");
+    return mod?.default ?? mod;
+  } catch (err) {
+    const wrapped = new Error(
+      "keytar is not available. Install it and ensure your OS keychain is supported."
+    );
+    wrapped.cause = err;
+    wrapped.code = "ORBITAL_KEYTAR_NOT_AVAILABLE";
+    throw wrapped;
+  }
+};
+
+export const getCredentialServiceName = () => ORBITAL_KEYTAR_SERVICE;
+export const getApiKeyAccountName = () => ORBITAL_API_KEY_ACCOUNT;
+
+export const getStoredApiKey = async () => {
+  const keytar = await loadKeytar();
+  const value = await keytar.getPassword(
+    ORBITAL_KEYTAR_SERVICE,
+    ORBITAL_API_KEY_ACCOUNT
+  );
+  return typeof value === "string" ? value.trim() : "";
+};
+
+export const storeApiKey = async (apiKey) => {
+  const trimmed = typeof apiKey === "string" ? apiKey.trim() : "";
+  if (!trimmed) throw new Error("API key is required");
+
+  const keytar = await loadKeytar();
+  await keytar.setPassword(
+    ORBITAL_KEYTAR_SERVICE,
+    ORBITAL_API_KEY_ACCOUNT,
+    trimmed
+  );
+  return true;
+};
+
+export const deleteStoredApiKey = async () => {
+  const keytar = await loadKeytar();
+  await keytar.deletePassword(ORBITAL_KEYTAR_SERVICE, ORBITAL_API_KEY_ACCOUNT);
+  return true;
+};

package/server/src/lib/db.js

@@ -0,0 +1,18 @@
+import "dotenv/config";
+import { execSync } from "child_process";
+import { PrismaClient } from "@prisma/client";
+
+const globalForPrisma = globalThis;
+
+// Safety net: generate client if missing
+try {
+  execSync("npx prisma generate", { stdio: "ignore" });
+} catch {}
+
+const prisma = globalForPrisma.prisma ?? new PrismaClient();
+
+if (process.env.NODE_ENV !== "production") {
+  globalForPrisma.prisma = prisma;
+}
+
+export default prisma;