@dubeyvishal/orbital-cli 1.6.13 → 1.6.14

package/server/src/controllers/aiController.js

@@ -7,7 +7,7 @@ const chatService = new ChatService();
 
 export const respond = async (req, res, next) => {
   try {
-    const { conversationId, mode, toolIds } = req.body || {};
+    const { conversationId, mode, toolIds, provider, model } = req.body || {};
 
     if (!conversationId) {
       return res.status(400).json({ error: "conversationId is required" });
@@ -16,16 +16,18 @@ export const respond = async (req, res, next) => {
     const messages = await chatService.getMessages(conversationId);
     const aiMessages = chatService.formatMessageForAI(messages);
 
+    const modelConfig = provider || model ? { provider, model } : null;
+    const aiService = getAIService(modelConfig);
+
     let tools;
     if (mode === "tool") {
       resetTools();
       if (Array.isArray(toolIds)) {
         enableTools(toolIds);
       }
-      tools = getEnabledTools();
+      tools = getEnabledTools(aiService.provider);
     }
 
-    const aiService = getAIService();
     const result = await aiService.sendMessage(aiMessages, null, tools);
 
     await chatService.addMessage(conversationId, "assistant", result.content);
@@ -34,6 +36,7 @@ export const respond = async (req, res, next) => {
       content: result.content,
       toolCalls: result.toolCalls || [],
       toolResults: result.toolResults || [],
+      model: aiService.getDisplayName(),
     });
   } catch (error) {
     return next(error);
@@ -42,16 +45,17 @@ export const respond = async (req, res, next) => {
 
 export const generateAgentPlan = async (req, res, next) => {
   try {
-    const { description } = req.body || {};
+    const { description, provider, model } = req.body || {};
 
     if (!description || typeof description !== "string") {
       return res.status(400).json({ error: "description is required" });
     }
 
-    const aiService = getAIService();
+    const modelConfig = provider || model ? { provider, model } : null;
+    const aiService = getAIService(modelConfig);
     const application = await generateApplicationPlan(description, aiService);
 
-    return res.json({ application });
+    return res.json({ application, model: aiService.getDisplayName() });
   } catch (error) {
     return next(error);
   }

package/server/src/lib/credentialStore.js

@@ -16,32 +16,65 @@ const loadKeytar = async () => {
 };
 
 export const getCredentialServiceName = () => ORBITAL_KEYTAR_SERVICE;
-export const getApiKeyAccountName = () => ORBITAL_API_KEY_ACCOUNT;
+export const getApiKeyAccountName = (provider = "gemini") => {
+  const p = (provider || "gemini").toLowerCase().trim();
+  if (p === "google" || p === "gemini") return "api-key-gemini";
+  if (p === "openai") return "api-key-openai";
+  if (p === "xai" || p === "grok") return "api-key-grok";
+  return `api-key-${p}`;
+};
 
-export const getStoredApiKey = async () => {
+export const getStoredApiKey = async (provider = "gemini") => {
   const keytar = await loadKeytar();
-  const value = await keytar.getPassword(
-    ORBITAL_KEYTAR_SERVICE,
-    ORBITAL_API_KEY_ACCOUNT
-  );
+  const account = getApiKeyAccountName(provider);
+  let value = await keytar.getPassword(ORBITAL_KEYTAR_SERVICE, account);
+
+  // Backward-compatibility for Gemini: fall back to legacy ORBITAL_API_KEY_ACCOUNT
+  const p = (provider || "gemini").toLowerCase().trim();
+  if (!value && (p === "gemini" || p === "google")) {
+    value = await keytar.getPassword(
+      ORBITAL_KEYTAR_SERVICE,
+      ORBITAL_API_KEY_ACCOUNT
+    );
+  }
+
   return typeof value === "string" ? value.trim() : "";
 };
 
-export const storeApiKey = async (apiKey) => {
+export const storeApiKey = async (apiKey, provider = "gemini") => {
   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
-  );
+  const account = getApiKeyAccountName(provider);
+  await keytar.setPassword(ORBITAL_KEYTAR_SERVICE, account, trimmed);
+
+  // For Gemini, also keep legacy account updated for backward compatibility
+  const p = (provider || "gemini").toLowerCase().trim();
+  if (p === "gemini" || p === "google") {
+    await keytar.setPassword(
+      ORBITAL_KEYTAR_SERVICE,
+      ORBITAL_API_KEY_ACCOUNT,
+      trimmed
+    );
+  }
+
   return true;
 };
 
-export const deleteStoredApiKey = async () => {
+export const deleteStoredApiKey = async (provider = "gemini") => {
   const keytar = await loadKeytar();
-  await keytar.deletePassword(ORBITAL_KEYTAR_SERVICE, ORBITAL_API_KEY_ACCOUNT);
+  const account = getApiKeyAccountName(provider);
+  await keytar.deletePassword(ORBITAL_KEYTAR_SERVICE, account);
+
+  const p = (provider || "gemini").toLowerCase().trim();
+  if (p === "gemini" || p === "google") {
+    await keytar.deletePassword(
+      ORBITAL_KEYTAR_SERVICE,
+      ORBITAL_API_KEY_ACCOUNT
+    );
+  }
+
   return true;
 };
+

package/server/src/lib/orbitalConfig.js

@@ -86,10 +86,73 @@ export const updateOrbitalConfig = async (patch = {}) => {
   return nextConfig;
 };
 
-const getGeminiApiKeyFromEnvSync = () => {
-  return typeof process.env.GOOGLE_GENERATIVE_AI_API_KEY === "string"
-    ? process.env.GOOGLE_GENERATIVE_AI_API_KEY.trim()
-    : "";
+// --- Model Preference Persistence ---
+
+export const getSelectedModel = async () => {
+  const cfg = await readOrbitalConfig();
+  let model = cfg.selectedModel || "gemini-2.5-flash";
+  if (model.includes("gemini-2.0")) model = "gemini-2.5-flash";
+  return {
+    provider: cfg.selectedProvider || "gemini",
+    model,
+  };
+};
+
+export const getSelectedModelSync = () => {
+  const cfg = readOrbitalConfigSync();
+  let model = cfg.selectedModel || "gemini-2.5-flash";
+  if (model.includes("gemini-2.0")) model = "gemini-2.5-flash";
+  return {
+    provider: cfg.selectedProvider || "gemini",
+    model,
+  };
+};
+
+export const saveSelectedModel = async ({ provider, model }) => {
+  return await updateOrbitalConfig({
+    selectedProvider: provider,
+    selectedModel: model,
+  });
+};
+
+// --- Multi-Provider API Key Management ---
+
+export const normalizeProviderName = (provider = "gemini") => {
+  const p = (provider || "gemini").toLowerCase().trim();
+  if (p === "google" || p === "gemini") return "gemini";
+  if (p === "openai") return "openai";
+  if (p === "xai" || p === "grok") return "grok";
+  return p;
+};
+
+export const getApiKeyFromEnvSync = (provider = "gemini") => {
+  const norm = normalizeProviderName(provider);
+  if (norm === "gemini") {
+    return (
+      (typeof process.env.GOOGLE_GENERATIVE_AI_API_KEY === "string" &&
+        process.env.GOOGLE_GENERATIVE_AI_API_KEY.trim()) ||
+      (typeof process.env.GEMINI_API_KEY === "string" &&
+        process.env.GEMINI_API_KEY.trim()) ||
+      ""
+    );
+  }
+  if (norm === "openai") {
+    return (
+      (typeof process.env.OPENAI_API_KEY === "string" &&
+        process.env.OPENAI_API_KEY.trim()) ||
+      ""
+    );
+  }
+  if (norm === "grok") {
+    return (
+      (typeof process.env.XAI_API_KEY === "string" &&
+        process.env.XAI_API_KEY.trim()) ||
+      (typeof process.env.GROK_API_KEY === "string" &&
+        process.env.GROK_API_KEY.trim()) ||
+      ""
+    );
+  }
+  return "";
 };
 
 const getLegacyGeminiApiKeyFromConfigSync = () => {
@@ -113,80 +176,123 @@ const removeLegacyGeminiApiKeyFromConfig = async () => {
   return true;
 };
 
-export const hydrateGeminiApiKeyEnv = async () => {
-  const already = getGeminiApiKeyFromEnvSync();
+export const hydrateApiKeyEnv = async (provider = "gemini") => {
+  const norm = normalizeProviderName(provider);
+  const already = getApiKeyFromEnvSync(norm);
   if (already) return already;
 
-  // Primary: OS credential manager via keytar.
+  // OS credential manager via keytar
   try {
-    const fromKeytar = await getStoredApiKey();
+    const fromKeytar = await getStoredApiKey(norm);
     if (fromKeytar) {
-      process.env.GOOGLE_GENERATIVE_AI_API_KEY = fromKeytar;
+      if (norm === "gemini") {
+        process.env.GOOGLE_GENERATIVE_AI_API_KEY = fromKeytar;
+      } else if (norm === "openai") {
+        process.env.OPENAI_API_KEY = fromKeytar;
+      } else if (norm === "grok") {
+        process.env.XAI_API_KEY = fromKeytar;
+      }
       return fromKeytar;
     }
   } catch {
-    // ignore here; requireGeminiApiKey will surface a helpful error
+    // Ignore keytar error; will be handled in requireApiKey
   }
 
-  // One-time migration: if the key exists in legacy ~/.orbital/config.json,
-  // move it into keytar and remove it from disk.
-  const legacy = getLegacyGeminiApiKeyFromConfigSync();
-  if (legacy) {
-    await storeApiKey(legacy);
-    await removeLegacyGeminiApiKeyFromConfig().catch(() => {});
-    process.env.GOOGLE_GENERATIVE_AI_API_KEY = legacy;
-    return legacy;
+  // One-time migration for legacy Gemini key on disk
+  if (norm === "gemini") {
+    const legacy = getLegacyGeminiApiKeyFromConfigSync();
+    if (legacy) {
+      await storeApiKey(legacy, "gemini");
+      await removeLegacyGeminiApiKeyFromConfig().catch(() => {});
+      process.env.GOOGLE_GENERATIVE_AI_API_KEY = legacy;
+      return legacy;
+    }
   }
 
   return "";
 };
 
-export const getGeminiApiKeySync = () => getGeminiApiKeyFromEnvSync();
+export const hydrateAllApiKeysEnv = async () => {
+  await Promise.all([
+    hydrateApiKeyEnv("gemini"),
+    hydrateApiKeyEnv("openai"),
+    hydrateApiKeyEnv("grok"),
+  ]);
+};
+
+export const getApiKeySync = (provider = "gemini") => {
+  return getApiKeyFromEnvSync(provider);
+};
 
-export const getGeminiApiKey = async () => {
-  const fromEnv = getGeminiApiKeyFromEnvSync();
+export const getApiKey = async (provider = "gemini") => {
+  const norm = normalizeProviderName(provider);
+  const fromEnv = getApiKeyFromEnvSync(norm);
   if (fromEnv) return fromEnv;
-  return await hydrateGeminiApiKeyEnv();
+  return await hydrateApiKeyEnv(norm);
 };
 
-export const hasGeminiApiKeySync = () => Boolean(getGeminiApiKeyFromEnvSync());
+export const hasApiKeySync = (provider = "gemini") => {
+  return Boolean(getApiKeyFromEnvSync(provider));
+};
 
-export const requireGeminiApiKeySync = () => {
-  const apiKey = getGeminiApiKeyFromEnvSync();
+export const requireApiKeySync = (provider = "gemini") => {
+  const norm = normalizeProviderName(provider);
+  const apiKey = getApiKeyFromEnvSync(norm);
   if (!apiKey) {
+    const displayName =
+      norm === "gemini" ? "Gemini" : norm === "openai" ? "OpenAI" : "Grok (xAI)";
     const err = new Error(
-      "Gemini API key not set. Run: orbital set-key <API_KEY>"
+      `${displayName} API key not set. Run: orbital set-key --provider ${norm} <API_KEY>`
     );
-    err.code = "ORBITAL_GEMINI_API_KEY_NOT_SET";
+    err.code = `ORBITAL_${norm.toUpperCase()}_API_KEY_NOT_SET`;
     throw err;
   }
   return apiKey;
 };
 
-export const requireGeminiApiKey = async () => {
-  const apiKey = await getGeminiApiKey();
+export const requireApiKey = async (provider = "gemini") => {
+  const norm = normalizeProviderName(provider);
+  const apiKey = await getApiKey(norm);
   if (!apiKey) {
+    const displayName =
+      norm === "gemini" ? "Gemini" : norm === "openai" ? "OpenAI" : "Grok (xAI)";
     const err = new Error(
-      "Gemini API key not set. Run: orbital set-key <API_KEY>"
+      `${displayName} API key not set. Run: orbital set-key --provider ${norm} <API_KEY>`
     );
-    err.code = "ORBITAL_GEMINI_API_KEY_NOT_SET";
+    err.code = `ORBITAL_${norm.toUpperCase()}_API_KEY_NOT_SET`;
     throw err;
   }
   return apiKey;
 };
 
-export const setGeminiApiKey = async (apiKey) => {
+export const setApiKey = async (provider = "gemini", apiKey) => {
+  const norm = normalizeProviderName(provider);
   const trimmed = typeof apiKey === "string" ? apiKey.trim() : "";
   if (!trimmed) throw new Error("API key is required");
 
-  await storeApiKey(trimmed);
-  // Ensure any legacy on-disk key is removed.
-  await removeLegacyGeminiApiKeyFromConfig().catch(() => {});
+  await storeApiKey(trimmed, norm);
+
+  if (norm === "gemini") {
+    await removeLegacyGeminiApiKeyFromConfig().catch(() => {});
+    process.env.GOOGLE_GENERATIVE_AI_API_KEY = trimmed;
+    process.env.GEMINI_API_KEY = trimmed;
+  } else if (norm === "openai") {
+    process.env.OPENAI_API_KEY = trimmed;
+  } else if (norm === "grok") {
+    process.env.XAI_API_KEY = trimmed;
+    process.env.GROK_API_KEY = trimmed;
+  }
 
-  process.env.GOOGLE_GENERATIVE_AI_API_KEY = trimmed;
   return true;
 };
 
-// Back-compat exports (no longer reads from config specifically).
-export const requireGeminiApiKeyFromConfigSync = requireGeminiApiKeySync;
+// --- Back-compatibility exports for Gemini ---
 
+export const hydrateGeminiApiKeyEnv = () => hydrateApiKeyEnv("gemini");
+export const getGeminiApiKeySync = () => getApiKeySync("gemini");
+export const getGeminiApiKey = () => getApiKey("gemini");
+export const hasGeminiApiKeySync = () => hasApiKeySync("gemini");
+export const requireGeminiApiKeySync = () => requireApiKeySync("gemini");
+export const requireGeminiApiKey = () => requireApiKey("gemini");
+export const setGeminiApiKey = (apiKey) => setApiKey("gemini", apiKey);
+export const requireGeminiApiKeyFromConfigSync = requireGeminiApiKeySync;

package/server/src/service/aiService.js

@@ -1,5 +1,5 @@
-import { AIService } from "../cli/ai/googleService.js";
-
-export const getAIService = () => {
-  return new AIService();
-};
+import { AIService } from "../cli/ai/googleService.js";
+
+export const getAIService = (modelConfig = null) => {
+  return new AIService(modelConfig);
+};