orbital-cli-agent 1.0.0

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

@@ -0,0 +1,423 @@
+import { cancel, confirm, intro, isCancel, outro  } from "@clack/prompts";
+import { logger } from "better-auth";
+import { createAuthClient } from "better-auth/client";
+import { deviceAuthorizationClient } from "better-auth/client/plugins";
+
+import chalk from "chalk";
+import { Command } from "commander";
+import fs from "fs/promises";
+import open from "open";
+import os from "os";
+import path from "path";
+import yoctoSpinner from "yocto-spinner";
+
+
+import { z } from "zod";
+import dotenv from "dotenv";
+import { getUserFromApi } from "../../api/api-client.js";
+
+dotenv.config();
+
+const URL = "http://localhost:3005";
+const CLIENT_ID = process.env.GITHUB_CLIENT_ID;
+const CONFIG_DIR = path.join(os.homedir(), ".better-auth");
+const TOKEN_FILE = path.join(CONFIG_DIR, "token.json");
+
+// ============================================
+// TOKEN MANAGEMENT (Export these for use in other commands)
+// ============================================
+
+export async function getStoredToken() {
+  try {
+    const data = await fs.readFile(TOKEN_FILE, "utf-8");
+    const token = JSON.parse(data);
+    return token;
+  } catch (error) {
+    // File doesn't exist or can't be read
+    return null;
+  }
+}
+
+export async function storeToken(token) {
+  try {
+    // Ensure config directory exists
+    await fs.mkdir(CONFIG_DIR, { recursive: true });
+
+    // Store token with metadata
+    const tokenData = {
+      access_token: token.access_token,
+      refresh_token: token.refresh_token, // Store if available
+      token_type: token.token_type || "Bearer",
+      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 (error) {
+    console.error(chalk.red("Failed to store token:"), error.message);
+    return false;
+  }
+}
+
+export async function clearStoredToken() {
+  try {
+    await fs.unlink(TOKEN_FILE);
+    return true;
+  } catch (error) {
+    // File doesn't exist or can't be deleted
+    return false;
+  }
+}
+
+export async function isTokenExpired() {
+  const token = await getStoredToken();
+  if (!token || !token.expires_at) {
+    return true;
+  }
+
+  const expiresAt = new Date(token.expires_at);
+  const now = new Date();
+
+  // Consider expired if less than 5 minutes remaining
+  return expiresAt.getTime() - now.getTime() < 5 * 60 * 1000;
+}
+
+export async function requireAuth() {
+  const token = await getStoredToken();
+
+  if (!token) {
+    console.log(
+      chalk.red("❌ Not authenticated. Please run 'your-cli login' first.")
+    );
+    process.exit(1);
+  }
+
+  if (await isTokenExpired()) {
+    console.log(
+      chalk.yellow("⚠️  Your session has expired. Please login again.")
+    );
+    console.log(chalk.gray("   Run: your-cli login\n"));
+    process.exit(1);
+  }
+
+  return token;
+}
+
+// ============================================
+// LOGIN COMMAND
+// ============================================
+
+export async function loginAction(opts) {
+  const options = z
+    .object({
+      serverUrl: z.string().optional(),
+      clientId: z.string().optional(),
+    })
+    .parse(opts);
+
+  const serverUrl = options.serverUrl || URL;
+  const clientId = options.clientId || CLIENT_ID;
+
+  intro(chalk.bold("🔐 Auth CLI Login"));
+
+  if (!clientId) {
+    logger.error("CLIENT_ID is not set in .env file");
+    console.log(
+      chalk.red("\n❌ Please set GITHUB_CLIENT_ID in your .env file")
+    );
+    process.exit(1);
+  }
+
+  // Check if already logged in
+  const existingToken = await getStoredToken();
+  const expired = await isTokenExpired();
+
+  if (existingToken && !expired) {
+    const shouldReauth = await confirm({
+      message: "You're already logged in. Do you want to log in again?",
+      initialValue: false,
+    });
+
+    if (isCancel(shouldReauth) || !shouldReauth) {
+      cancel("Login cancelled");
+      process.exit(0);
+    }
+  }
+
+  // Create the auth client
+  const authClient = createAuthClient({
+    baseURL: serverUrl,
+    plugins: [deviceAuthorizationClient()],
+  });
+
+  const spinner = yoctoSpinner({ text: "Requesting device authorization..." });
+  spinner.start();
+
+  try {
+    // Request device code
+    const { data, error } = await authClient.device.code({
+      client_id: clientId,
+      scope: "openid profile email",
+    });
+
+    spinner.stop();
+
+    if (error || !data) {
+      logger.error(
+        `Failed to request device authorization: ${
+          error?.error_description || error?.message || "Unknown error"
+        }`
+      );
+
+      if (error?.status === 404) {
+        console.log(chalk.red("\n❌ Device authorization endpoint not found."));
+        console.log(chalk.yellow("   Make sure your auth server is running."));
+      } else if (error?.status === 400) {
+        console.log(
+          chalk.red("\n❌ Bad request - check your CLIENT_ID configuration.")
+        );
+      }
+
+      process.exit(1);
+    }
+
+    const {
+      device_code,
+      user_code,
+      verification_uri,
+      verification_uri_complete,
+      interval = 5,
+      expires_in,
+    } = data;
+
+    // Display authorization instructions
+    console.log("");
+    console.log(chalk.cyan("📱 Device Authorization Required"));
+    console.log("");
+    console.log(
+      `Please visit: ${chalk.underline.blue(
+        verification_uri_complete || verification_uri
+      )}`
+    );
+    console.log(`Enter code: ${chalk.bold.green(user_code)}`);
+    console.log("");
+
+    // Ask if user wants to open browser
+    const shouldOpen = await confirm({
+      message: "Open browser automatically?",
+      initialValue: true,
+    });
+
+    if (!isCancel(shouldOpen) && shouldOpen) {
+      const urlToOpen = verification_uri_complete || verification_uri;
+      await open(urlToOpen);
+    }
+
+    // Start polling
+    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) {
+      // Store the token
+      const saved = await storeToken(token);
+
+      if (!saved) {
+        console.log(
+          chalk.yellow("\n⚠️  Warning: Could not save authentication token.")
+        );
+        console.log(
+          chalk.yellow("   You may need to login again on next use.")
+        );
+      }
+
+      // Get user info
+      const { data: session } = await authClient.getSession({
+        fetchOptions: {
+          headers: {
+            Authorization: `Bearer ${token.access_token}`,
+          },
+        },
+      });
+
+      outro(
+        chalk.green(
+          `✅ Login successful! Welcome ${
+            session?.user?.name || session?.user?.email || "User"
+          }`
+        )
+      );
+
+      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("\nLogin failed:"), err.message);
+    process.exit(1);
+  }
+}
+
+async function pollForToken(authClient, deviceCode, clientId, initialInterval) {
+  let pollingInterval = initialInterval;
+  const spinner = yoctoSpinner({ text: "", color: "cyan" });
+  let dots = 0;
+
+  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": `Better Auth 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":
+              // Continue polling
+              break;
+            case "slow_down":
+              pollingInterval += 5;
+              break;
+            case "access_denied":
+              spinner.stop();
+              logger.error("Access was denied by the user");
+              process.exit(1);
+              break;
+            case "expired_token":
+              spinner.stop();
+              logger.error("The device code has expired. Please try again.");
+              process.exit(1);
+              break;
+            default:
+              spinner.stop();
+              logger.error(`Error: ${error.error_description}`);
+              process.exit(1);
+          }
+        }
+      } catch (err) {
+        spinner.stop();
+        logger.error(`Network error: ${err.message}`);
+        process.exit(1);
+      }
+
+      setTimeout(poll, pollingInterval * 1000);
+    };
+
+    setTimeout(poll, pollingInterval * 1000);
+  });
+}
+
+// ============================================
+// LOGOUT COMMAND
+// ============================================
+
+export async function logoutAction() {
+  intro(chalk.bold("👋 Logout"));
+
+  const token = await getStoredToken();
+
+  if (!token) {
+    console.log(chalk.yellow("You're not logged in."));
+    process.exit(0);
+  }
+
+  const shouldLogout = await confirm({
+    message: "Are you sure 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."));
+  }
+}
+
+// ============================================
+// WHOAMI COMMAND
+// ============================================
+
+export async function whoamiAction(opts) {
+  const token = await requireAuth();
+  if (!token?.access_token) {
+    console.log("No access token found. Please login.");
+    process.exit(1);
+  }
+
+  const user = await getUserFromApi(token.access_token);
+
+  if (!user) {
+    console.log(chalk.red("\n❌ Session not found or expired on the server. Please login again.\n"));
+    process.exit(1);
+  }
+
+  // Output user session info
+  console.log(
+    chalk.bold.greenBright(`\n👤 User: ${user.name}
+📧 Email: ${user.email}
+👤 ID: ${user.id}`)
+  );
+}
+
+// ============================================
+// COMMANDER SETUP
+// ============================================
+
+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);
+
+export const logout = new Command("logout")
+  .description("Logout and clear stored credentials")
+  .action(logoutAction);
+
+export const whoami = new Command("whoami")
+  .description("Show current authenticated user")
+  .option("--server-url <url>", "The Better Auth server URL", URL)
+  .action(whoamiAction);

package/src/cli/main.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+
+import dotenv from "dotenv";
+
+import chalk from "chalk";
+import figlet from "figlet";
+
+import { Command } from "commander";
+import { login, logout, whoami } from "./commands/auth/login.js";
+import { wakeup } from "./commands/ai/wakeup.js";
+
+
+dotenv.config();
+
+async function main() {
+  // banner ke liye
+  console.log(
+    chalk.cyan(
+      figlet.textSync("Orbit Agent", {
+        font: "Standard",
+        horizontalLayout: "default",
+      })
+    )
+  );
+  console.log(chalk.green("A Cli based AI Agent \n"));
+
+   const program = new Command("orbit");
+
+  program
+    .version("0.0.1")
+    .description("Orbit CLI - Device Flow Authentication")
+    .addCommand(login)
+    .addCommand(logout)
+    .addCommand(whoami)
+    .addCommand(wakeup)
+
+    
+  // Default action shows help
+  program.action(() => {
+    program.help();
+  });
+
+
+
+  program.parse();
+ 
+}
+
+main().catch((error) => {
+  console.error(chalk.red("Error running Orbit CLI:"), error);
+  process.exit(1);
+});

package/src/config/agent.config.js

@@ -0,0 +1,94 @@
+import { z } from "zod";
+import fs from "fs/promises";
+import path from "path";
+import chalk from "chalk";
+import yoctoSpinner from "yocto-spinner";
+
+// Schema for the files to be created
+const FileSchema = z.object({
+  path: z.string().describe("The relative path of the file, e.g., 'src/index.js' or 'public/index.html'"),
+  content: z.string().describe("The full content of the file"),
+});
+
+// Schema for the entire application generation output
+const ApplicationSchema = z.object({
+  folderName: z.string().describe("Suggested URL-safe folder name for the app (kebab-case)"),
+  files: z.array(FileSchema).describe("List of files to create"),
+  commands: z.array(z.string()).describe("List of terminal commands to install dependencies or run the application"),
+  readmeInstructions: z.string().describe("Detailed markdown explanation of the app structure, features, and setup"),
+});
+
+/**
+ * Generate files and setup script for a requested application using AI structured outputs
+ * @param {string} prompt - User request description
+ * @param {AIService} aiService - Instantiated AIService
+ * @param {string} outputDir - Parent directory where the folder should be generated
+ * @returns {Promise<Object>} Generation status details
+ */
+export async function generateApplication(prompt, aiService, outputDir) {
+  const spinner = yoctoSpinner({ text: "AI is planning and generating application files...", color: "magenta" }).start();
+  
+  try {
+    const systemPrompt = 
+      "You are an autonomous AI Agent developer.\n" +
+      "Your job is to generate all required files, directory structure, dependency installations, and setup instructions to build a complete, functional application based on the user's description.\n" +
+      "Generate clean, modern, and production-ready code. Do not use placeholders or omit files. If you need styling, include CSS or CDN Tailwind setups directly.";
+
+    const fullPrompt = `${systemPrompt}\n\nUser Request: ${prompt}`;
+
+    // Request structured generation
+    const appDetails = await aiService.generateStructured(ApplicationSchema, fullPrompt);
+
+    spinner.text = "Creating files and folders on disk...";
+
+    // Determine target directory
+    const targetDir = path.join(outputDir, appDetails.folderName);
+    
+    // Create parent directory
+    await fs.mkdir(targetDir, { recursive: true });
+
+    // Write all files
+    for (const file of appDetails.files) {
+      const filePath = path.join(targetDir, file.path);
+      const dirPath = path.dirname(filePath);
+      
+      // Ensure subdirectories exist
+      await fs.mkdir(dirPath, { recursive: true });
+      
+      // Write file content
+      await fs.writeFile(filePath, file.content, "utf-8");
+    }
+
+    // Write a README.md detailing instructions and commands
+    const readmeContent = `# ${appDetails.folderName}\n\n` +
+      `${appDetails.readmeInstructions}\n\n` +
+      `## 🚀 Setup & Execution Commands\n\n` +
+      `Run these commands in your terminal:\n` +
+      "```bash\n" +
+      appDetails.commands.map(cmd => cmd).join('\n') +
+      "\n```\n";
+
+    await fs.writeFile(path.join(targetDir, "README.md"), readmeContent, "utf-8");
+
+    spinner.success("Application generated successfully!");
+
+    console.log(chalk.bold.green(`\n✨ Successfully created: ${appDetails.folderName}`));
+    console.log(chalk.gray(`📁 Location: ${targetDir}\n`));
+    console.log(chalk.bold.yellow("🔧 Suggested setup commands:"));
+    appDetails.commands.forEach(cmd => console.log(chalk.cyan(`  $ ${cmd}`)));
+    console.log("");
+
+    return {
+      success: true,
+      folderName: appDetails.folderName,
+      appDir: targetDir,
+      files: appDetails.files,
+      commands: appDetails.commands,
+    };
+
+  } catch (error) {
+    spinner.error("Failed to generate application files");
+    console.error(chalk.red("Agent Error:"), error);
+    throw error;
+  }
+}

package/src/config/google.config.js

@@ -0,0 +1,8 @@
+import dotenv from "dotenv";
+
+dotenv.config();
+
+export const config = {
+    googleApiKey: process.env.GOOGLE_GENERATIVE_AI_API_KEY,
+    orbitalModel: process.env.ORBITAL_MODEL
+}

package/src/config/tool.config.js

@@ -0,0 +1,107 @@
+import { google } from "@ai-sdk/google";
+import { tool } from "ai";
+import { z } from "zod";
+import chalk from "chalk";
+import fs from "fs/promises";
+import path from "path";
+
+// Define the schema for package.json dependencies
+const packageJsonSchema = z.object({
+  dependencies: z.record(z.string()).optional(),
+  devDependencies: z.record(z.string()).optional(),
+});
+
+// Define all available tools
+export const availableTools = [
+  {
+    id: "read-file",
+    name: "Read File Content",
+    description: "Read the complete code content of a file",
+    tool: tool({
+      description: "Read the complete code content of a file",
+      parameters: z.object({
+        filePath: z.string().describe("The absolute path of the file to read"),
+      }),
+      execute: async ({ filePath }) => {
+        try {
+          const content = await fs.readFile(filePath, "utf-8");
+          return { success: true, content };
+        } catch (error) {
+          return { success: false, error: error.message };
+        }
+      },
+    }),
+  },
+  {
+    id: "list-dir",
+    name: "List Directory Contents",
+    description: "List all files and folders in a directory",
+    tool: tool({
+      description: "List all files and subfolders in a directory (recursive = false)",
+      parameters: z.object({
+        dirPath: z.string().describe("The absolute path of the directory to list"),
+      }),
+      execute: async ({ dirPath }) => {
+        try {
+          const files = await fs.readdir(dirPath, { withFileTypes: true });
+          const items = files.map((file) => ({
+            name: file.name,
+            isDirectory: file.isDirectory(),
+            isFile: file.isFile(),
+          }));
+          return { success: true, items };
+        } catch (error) {
+          return { success: false, error: error.message };
+        }
+      },
+    }),
+  },
+  {
+    id: "run-command",
+    name: "Execute Terminal Command",
+    description: "Execute a command in the terminal (powershell/sh)",
+    tool: tool({
+      description: "Run a shell/powershell command on behalf of the user",
+      parameters: z.object({
+        command: z.string().describe("The exact terminal command to run"),
+        cwd: z.string().optional().describe("Working directory for the command execution"),
+      }),
+      execute: async ({ command, cwd }) => {
+        // Mock command runner warning/execution logic or safe stub for security
+        console.log(chalk.yellow(`\n⚠️  CLI request to execute: "${command}"`));
+        return { 
+          success: true, 
+          message: "Note: Real terminal command execution was disabled inside the sandbox tool configuration for safety reasons." 
+        };
+      },
+    }),
+  },
+];
+
+// Tracks enabled tools in the current session
+const enabledToolIds = new Set();
+
+export function enableTools(ids) {
+  enabledToolIds.clear();
+  ids.forEach((id) => enabledToolIds.add(id));
+}
+
+export function resetTools() {
+  enabledToolIds.clear();
+}
+
+export function getEnabledToolNames() {
+  return availableTools
+    .filter((t) => enabledToolIds.has(t.id))
+    .map((t) => t.name);
+}
+
+export function getEnabledTools() {
+  const tools = {};
+  availableTools.forEach((t) => {
+    if (enabledToolIds.has(t.id)) {
+      tools[t.id] = t.tool;
+    }
+  });
+  return tools;
+}