@dubeyvishal/orbital-cli 1.6.13 → 1.6.14

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

@@ -1,84 +1,145 @@
 import chalk from "chalk";
-import {Command} from "commander";
-import yoctoSpinner  from "yocto-spinner";
-import {getStoredToken} from "../../../lib/token.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";
+import { Command } from "commander";
+import yoctoSpinner from "yocto-spinner";
+import { getStoredToken } from "../../../lib/token.js";
+import { select, password, isCancel, cancel } 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";
 import { apiRequestSafe } from "../../utils/apiClient.js";
-import { requireGeminiApiKey } from "../../../lib/orbitalConfig.js";
+import {
+  getApiKey,
+  setApiKey,
+  getSelectedModel,
+  saveSelectedModel,
+} from "../../../lib/orbitalConfig.js";
+import {
+  AI_PROVIDERS,
+  getModelSelectOptions,
+  parseModelChoice,
+  getModelDisplayName,
+} from "../../../config/aiConfig.js";
 
+const wakeUpAction = async () => {
+  const token = await getStoredToken();
+  if (!token?.access_token) {
+    console.log(chalk.red("Not Authenticated. Please run 'orbital login' first."));
+    return;
+  }
 
-const wakeUpAction = async()=>{
-    try {
-        await requireGeminiApiKey();
-    } catch {
-        console.log(chalk.red("Gemini API key not set. Run: orbital set-key <API_KEY>"));
-        return;
+  const spinner = yoctoSpinner({ text: "Fetching user information..." });
+  spinner.start();
+
+  let user;
+  try {
+    const result = await apiRequestSafe("/api/cli/me");
+    user = result?.user;
+  } finally {
+    spinner.stop();
+  }
+
+  if (!user) {
+    console.log(chalk.red("User not found. Please log in again with 'orbital login'."));
+    return;
+  }
+
+  console.log(chalk.green(`Welcome back, ${user.name}! \n`));
+
+  // 1. Ask user to select the AI model FIRST
+  const savedModel = await getSelectedModel();
+  const modelOptions = getModelSelectOptions();
+  const defaultModelValue = `${savedModel.provider}:${savedModel.model}`;
+
+  const selectedModelChoice = await select({
+    message: "Select an AI Model:",
+    options: modelOptions,
+    initialValue: modelOptions.some((o) => o.value === defaultModelValue)
+      ? defaultModelValue
+      : undefined,
+  });
+
+  if (isCancel(selectedModelChoice)) {
+    cancel("Model selection cancelled.");
+    return;
+  }
+
+  const { provider, model } = parseModelChoice(selectedModelChoice);
+  await saveSelectedModel({ provider, model });
+
+  // 2. Ensure API key is configured for the chosen model/provider
+  let apiKey = await getApiKey(provider);
+  if (!apiKey) {
+    const provInfo = AI_PROVIDERS[provider];
+    console.log(
+      chalk.yellow(
+        `\n${provInfo?.name || provider} API key is required. (Obtain one at: ${provInfo?.docsUrl || "provider portal"})`
+      )
+    );
+
+    const enteredKey = await password({
+      message: `Enter your ${provInfo?.name || provider} API key:`,
+      validate(value) {
+        if (!value || !value.trim()) return "API key cannot be empty";
+      },
+    });
+
+    if (isCancel(enteredKey)) {
+      cancel("Operation cancelled.");
+      return;
     }
 
-    const token = await getStoredToken();
-     if(!token?.access_token){
-        console.log(chalk.red("Not Authenticated. please login"))
-        return ;
-     }
-
-     const spinner = yoctoSpinner({text: "Fetching user information ..."})
-     spinner.start()
-
-     let user;
-     try{
-        const result = await apiRequestSafe("/api/cli/me");
-        user = result?.user;
-     }
-     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)
+    await setApiKey(provider, enteredKey);
+    console.log(chalk.green(`✔ ${provInfo?.name || provider} API key saved securely.\n`));
+  }
+
+  console.log(
+    chalk.cyan(`Active AI Model: ${chalk.bold(getModelDisplayName(provider, model))}\n`)
+  );
+
+  // 3. Mode selection
+  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 and code execution",
+      },
+      {
+        value: "agent",
+        label: "Agentic Mode",
+        hint: "Fullstack application generation agent",
+      },
+    ],
+  });
+
+  if (isCancel(choice)) {
+    cancel("Operation cancelled.");
+    return;
+  }
+
+  const modelConfig = { provider, model };
+
+  switch (choice) {
+    case "chat":
+      await startChat("chat", null, modelConfig);
+      break;
+    case "tool":
+      await startToolChat(modelConfig);
+      break;
+    case "agent":
+      await startAgentChat(modelConfig);
+      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/login.js

@@ -11,7 +11,6 @@ import { fileURLToPath } from "url";
 import { getStoredToken, isTokenExpired, storeToken ,TOKEN_FILE } from "../../../lib/token.js";
 import { API_BASE } from "../../../config/api.js";
 import { apiRequestSafe } from "../../utils/apiClient.js";
-import { requireGeminiApiKey } from "../../../lib/orbitalConfig.js";
 
 
 const __filename = fileURLToPath(import.meta.url);
@@ -93,12 +92,7 @@ const resolveClientId = async (cliClientId) => {
 
 
 export const loginAction = async (cmdOptions) => {
-  try {
-    await requireGeminiApiKey();
-  } catch {
-    console.log(chalk.red("Gemini API key not set. Run: orbital set-key <API_KEY>"));
-    process.exit(1);
-  }
+
 
   const schema = z.object({
     serverUrl: z.string().optional(),

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

@@ -1,12 +1,58 @@
 import { Command } from "commander";
 import chalk from "chalk";
-import { setGeminiApiKey } from "../../../lib/orbitalConfig.js";
+import { select, password, isCancel, cancel } from "@clack/prompts";
+import { setApiKey, normalizeProviderName } from "../../../lib/orbitalConfig.js";
 import { getCredentialServiceName } from "../../../lib/credentialStore.js";
+import { AI_PROVIDERS } from "../../../config/aiConfig.js";
 
-const setKeyAction = async (apiKey) => {
+const setKeyAction = async (apiKeyArg, cmdOptions) => {
   try {
-    await setGeminiApiKey(apiKey);
-    console.log(chalk.green("Gemini API key saved."));
+    let provider = cmdOptions.provider;
+    let apiKey = apiKeyArg;
+
+    // Interactive mode if key was not supplied via command line argument
+    if (!apiKey) {
+      if (!provider) {
+        const provChoice = await select({
+          message: "Select AI Provider to configure API key for:",
+          options: [
+            { value: "gemini", label: "Google Gemini", hint: "AI Studio API key" },
+            { value: "openai", label: "OpenAI", hint: "platform.openai.com key" },
+            { value: "grok", label: "Grok (xAI)", hint: "console.x.ai key" },
+          ],
+        });
+
+        if (isCancel(provChoice)) {
+          cancel("Operation cancelled.");
+          return;
+        }
+        provider = provChoice;
+      }
+
+      const provInfo = AI_PROVIDERS[normalizeProviderName(provider)];
+      const enteredKey = await password({
+        message: `Enter your ${provInfo?.name || provider} API key:`,
+        validate(value) {
+          if (!value || !value.trim()) return "API key cannot be empty";
+        },
+      });
+
+      if (isCancel(enteredKey)) {
+        cancel("Operation cancelled.");
+        return;
+      }
+
+      apiKey = enteredKey;
+    }
+
+    const norm = normalizeProviderName(provider || "gemini");
+    const provInfo = AI_PROVIDERS[norm];
+
+    await setApiKey(norm, apiKey);
+
+    console.log(
+      chalk.green(`\n✔ ${provInfo?.name || norm} API key saved successfully.`)
+    );
     console.log(
       chalk.gray(
         `Stored securely in your OS credential manager (service: ${getCredentialServiceName()}).`
@@ -19,8 +65,13 @@ const setKeyAction = async (apiKey) => {
 };
 
 export const setkey = new Command("set-key")
-  .description("Store your Gemini API key securely (keytar)")
-  .argument("<API_KEY>", "Your Gemini API key")
+  .description("Store your AI provider API key securely in keytar (Gemini, OpenAI, Grok)")
+  .argument("[API_KEY]", "Your AI provider API key")
+  .option(
+    "-p, --provider <provider>",
+    "AI provider: gemini (default), openai, or grok",
+    "gemini"
+  )
   .alias("set")
   .alias("setkey")
   .action(setKeyAction);

package/server/src/cli/main.js

@@ -12,7 +12,10 @@ import {setkey} from "./commands/config/setkey.js"
 import {launch} from "./commands/General/openApp.js"
 import {search} from "./commands/General/searchYoutube.js"
 import {play} from "./commands/General/playSong.js"
-import {packageJson} from "./package.json";
+import { createRequire } from "module";
+const require = createRequire(import.meta.url);
+const packageJson = require("../../../package.json");
+
 
 const main = async()=>{
 

package/server/src/config/aiConfig.js

@@ -0,0 +1,159 @@
+import "./env.js";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createXai } from "@ai-sdk/xai";
+import { normalizeProviderName, requireApiKeySync } from "../lib/orbitalConfig.js";
+
+export const AI_PROVIDERS = {
+  gemini: {
+    id: "gemini",
+    name: "Google Gemini",
+    defaultModel: "gemini-2.5-flash",
+    envKey: "GOOGLE_GENERATIVE_AI_API_KEY",
+    docsUrl: "https://aistudio.google.com/app/apikey",
+    models: [
+      {
+        id: "gemini-2.5-flash",
+        name: "Gemini 2.5 Flash",
+        hint: "Google (Fast & versatile - Recommended)",
+        isDefault: true,
+      },
+      {
+        id: "gemini-2.5-pro",
+        name: "Gemini 2.5 Pro",
+        hint: "Google (Complex reasoning & large context)",
+      },
+      {
+        id: "gemini-1.5-flash",
+        name: "Gemini 1.5 Flash",
+        hint: "Google (Lightweight & efficient)",
+      },
+      {
+        id: "gemini-1.5-pro",
+        name: "Gemini 1.5 Pro",
+        hint: "Google (Extended analysis)",
+      },
+    ],
+  },
+  openai: {
+    id: "openai",
+    name: "OpenAI",
+    defaultModel: "gpt-4o",
+    envKey: "OPENAI_API_KEY",
+    docsUrl: "https://platform.openai.com/api-keys",
+    models: [
+      {
+        id: "gpt-4o",
+        name: "GPT-4o",
+        hint: "OpenAI (Flagship multimodal intelligence)",
+        isDefault: true,
+      },
+      {
+        id: "gpt-4o-mini",
+        name: "GPT-4o Mini",
+        hint: "OpenAI (Fast & cost-effective)",
+      },
+    ],
+  },
+  grok: {
+    id: "grok",
+    name: "Grok (xAI)",
+    defaultModel: "grok-2-latest",
+    envKey: "XAI_API_KEY",
+    docsUrl: "https://console.x.ai/",
+    models: [
+      {
+        id: "grok-2-latest",
+        name: "Grok 2",
+        hint: "xAI (Frontier model with advanced reasoning)",
+        isDefault: true,
+      },
+      {
+        id: "grok-beta",
+        name: "Grok Beta",
+        hint: "xAI (Experimental release)",
+      },
+    ],
+  },
+};
+
+/**
+ * Returns options list suitable for @clack/prompts select()
+ */
+export const getModelSelectOptions = () => {
+  const options = [];
+  for (const provider of Object.values(AI_PROVIDERS)) {
+    for (const model of provider.models) {
+      options.push({
+        value: `${provider.id}:${model.id}`,
+        label: `${provider.name} - ${model.name}`,
+        hint: model.hint,
+      });
+    }
+  }
+  return options;
+};
+
+/**
+ * Parse a compound value like "openai:gpt-4o" or separate provider/model inputs
+ */
+export const parseModelChoice = (choice) => {
+  if (!choice) return { provider: "gemini", model: "gemini-2.5-flash" };
+  if (typeof choice === "object") {
+    const provider = normalizeProviderName(choice.provider || "gemini");
+    const defaultModel = AI_PROVIDERS[provider]?.defaultModel || "gemini-2.5-flash";
+    let model = choice.model || defaultModel;
+    if (model.includes("gemini-2.0")) model = "gemini-2.5-flash";
+    return {
+      provider,
+      model,
+    };
+  }
+
+  if (typeof choice === "string" && choice.includes(":")) {
+    const [p, m] = choice.split(":");
+    const provider = normalizeProviderName(p);
+    const model = m.includes("gemini-2.0") ? "gemini-2.5-flash" : m;
+    return { provider, model };
+  }
+
+  // If only provider name is given
+  const provider = normalizeProviderName(choice);
+  return {
+    provider,
+    model: AI_PROVIDERS[provider]?.defaultModel || choice,
+  };
+};
+
+
+export const getModelDisplayName = (provider, modelId) => {
+  const norm = normalizeProviderName(provider);
+  const provInfo = AI_PROVIDERS[norm];
+  if (!provInfo) return `${provider} (${modelId})`;
+  const modelInfo = provInfo.models.find((m) => m.id === modelId);
+  return modelInfo ? `${provInfo.name} (${modelInfo.name})` : `${provInfo.name} (${modelId})`;
+};
+
+/**
+ * Creates a language model instance for Vercel AI SDK
+ */
+export const createModelInstance = (provider, modelName, apiKey = null) => {
+  const norm = normalizeProviderName(provider);
+  const key = apiKey || requireApiKeySync(norm);
+
+  switch (norm) {
+    case "openai": {
+      const openai = createOpenAI({ apiKey: key });
+      return openai(modelName);
+    }
+    case "grok": {
+      const xai = createXai({ apiKey: key });
+      return xai(modelName);
+    }
+    case "gemini":
+    default: {
+      const google = createGoogleGenerativeAI({ apiKey: key });
+      return google(modelName);
+    }
+  }
+};

package/server/src/config/googleConfig.js

@@ -2,5 +2,5 @@ import "./env.js";
 
 export const config = {
     googleApiKey : process.env.GOOGLE_GENERATIVE_AI_API_KEY || "",
-    model : process.env.ORBITAL_MODEL || "gemini-3.5-flash-lite"
+    model : process.env.ORBITAL_MODEL || "gemini-2.5-flash"
 }

package/server/src/config/toolConfig.js

@@ -1,13 +1,19 @@
 import { google } from "@ai-sdk/google";
 import chalk from "chalk";
-import { requireGeminiApiKeySync } from "../lib/orbitalConfig.js";
+import {
+  normalizeProviderName,
+  requireApiKeySync,
+  hasApiKeySync,
+} from "../lib/orbitalConfig.js";
 
 export const availableTools = [
+  // Google Gemini Native Tools
   {
     id: "google_search",
     name: "Google Search",
     description:
       "Access the latest information using Google Search. Useful for current events, news, and real-time information",
+    provider: "gemini",
     getTool: () => google.tools.googleSearch({}),
     enabled: false,
   },
@@ -16,6 +22,7 @@ export const availableTools = [
     name: "Code Execution",
     description:
       "Generate and execute Python code to perform calculations, solve problems or provide accurate information",
+    provider: "gemini",
     getTool: () => google.tools.codeExecution({}),
     enabled: false,
   },
@@ -24,45 +31,41 @@ export const availableTools = [
     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.",
+    provider: "gemini",
     getTool: () => google.tools.urlContext({}),
     enabled: false,
   },
 ];
 
-export const getEnabledTools = () => {
+export const getToolsForProvider = (provider = "gemini") => {
+  const norm = normalizeProviderName(provider);
+  return availableTools.filter(
+    (tool) => tool.provider === "all" || tool.provider === norm
+  );
+};
+
+export const getEnabledTools = (provider = "gemini") => {
+  const norm = normalizeProviderName(provider);
   const tools = {};
 
   try {
-    const enabledToolCount = availableTools.filter((t) => t.enabled).length;
-    if (enabledToolCount > 0 && !process.env.GOOGLE_GENERATIVE_AI_API_KEY) {
-      
-      requireGeminiApiKeySync();
-    }
+    const providerTools = getToolsForProvider(norm);
 
-    for (const toolConfig of availableTools) {
+    for (const toolConfig of providerTools) {
       if (toolConfig.enabled) {
+        if (toolConfig.provider === "gemini" && !hasApiKeySync("gemini")) {
+          requireApiKeySync("gemini");
+        }
         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;
   }
 };
@@ -72,49 +75,27 @@ export const toggleTool = (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;
+  return availableTools.filter((t) => t.enabled).map((t) => t.name);
 };
 
 export const resetTools = () => {
   availableTools.forEach((tool) => {
     tool.enabled = false;
   });
-  console.log(chalk.gray(`[DEBUG] All tools have been reset (disabled)`));
 };
+