@benzsiangco/jarvis 1.0.2 → 1.1.0

package/src/core/plugins.ts

@@ -0,0 +1,148 @@
+// Plugin system for Jarvis
+// Compatible with opencode plugins like opencode-antigravity-auth
+import { join } from 'path';
+import { existsSync, readFileSync } from 'fs';
+import { getConfigDir } from '../config';
+import type { Plugin, JarvisInstance, ProviderConfig, Tool, AgentConfig } from '../core/types';
+
+// Plugin registry
+const plugins = new Map<string, Plugin>();
+
+export interface PluginLoader {
+  name: string;
+  load: () => Promise<Plugin>;
+}
+
+// Load plugins from config
+export async function loadPlugins(pluginNames: string[]): Promise<Plugin[]> {
+  const loadedPlugins: Plugin[] = [];
+  
+  for (const name of pluginNames) {
+    try {
+      const plugin = await loadPlugin(name);
+      if (plugin) {
+        plugins.set(name, plugin);
+        loadedPlugins.push(plugin);
+      }
+    } catch (error) {
+      console.warn(`Failed to load plugin ${name}:`, error);
+    }
+  }
+  
+  return loadedPlugins;
+}
+
+// Load a single plugin
+async function loadPlugin(name: string): Promise<Plugin | undefined> {
+  // Parse plugin name (supports @scope/name@version format)
+  const { packageName, version } = parsePluginName(name);
+  
+  // Check if it's an opencode plugin that needs compatibility
+  if (packageName.includes('opencode-antigravity-auth')) {
+    return createAntigravityCompatPlugin(packageName);
+  }
+  
+  // Try to dynamically import the plugin
+  try {
+    const module = await import(packageName);
+    if (module.default && typeof module.default === 'object') {
+      return module.default as Plugin;
+    }
+    return module as Plugin;
+  } catch (error) {
+    console.warn(`Could not load plugin ${packageName}:`, error);
+    return undefined;
+  }
+}
+
+// Parse plugin name to extract package and version
+function parsePluginName(name: string): { packageName: string; version?: string } {
+  // Handle @scope/package@version format
+  const atIndex = name.lastIndexOf('@');
+  if (atIndex > 0) {
+    return {
+      packageName: name.substring(0, atIndex),
+      version: name.substring(atIndex + 1),
+    };
+  }
+  return { packageName: name };
+}
+
+// Create a compatibility layer for opencode-antigravity-auth
+function createAntigravityCompatPlugin(packageName: string): Plugin {
+  return {
+    name: 'antigravity-auth-compat',
+    version: '1.0.0',
+    
+    async init(jarvis: JarvisInstance) {
+      console.log('Antigravity Auth compatibility plugin initialized');
+      
+      // Check for existing accounts file
+      const accountsPath = join(getConfigDir(), 'antigravity-accounts.json');
+      if (existsSync(accountsPath)) {
+        try {
+          const accounts = JSON.parse(readFileSync(accountsPath, 'utf-8'));
+          console.log(`Found ${accounts.accounts?.length || 0} Antigravity account(s)`);
+        } catch {
+          // Ignore parse errors
+        }
+      } else {
+        console.log('No Antigravity accounts found. Run "jarvis auth login" to add an account.');
+      }
+    },
+    
+    // Antigravity models are already configured in default config
+    providers: [],
+    tools: [],
+    agents: [],
+  };
+}
+
+// Initialize all loaded plugins
+export async function initializePlugins(jarvis: JarvisInstance): Promise<void> {
+  for (const [name, plugin] of plugins) {
+    try {
+      if (plugin.init) {
+        await plugin.init(jarvis);
+      }
+      
+      // Register plugin providers
+      if (plugin.providers) {
+        for (const provider of plugin.providers) {
+          jarvis.providers.set(provider.id, provider);
+        }
+      }
+      
+      // Register plugin tools
+      if (plugin.tools) {
+        for (const tool of plugin.tools) {
+          jarvis.tools.set(tool.name, tool);
+        }
+      }
+      
+      // Register plugin agents
+      if (plugin.agents) {
+        for (const agent of plugin.agents) {
+          jarvis.agents.set(agent.id, agent);
+        }
+      }
+    } catch (error) {
+      console.error(`Error initializing plugin ${name}:`, error);
+    }
+  }
+}
+
+// Get a loaded plugin
+export function getPlugin(name: string): Plugin | undefined {
+  return plugins.get(name);
+}
+
+// List all loaded plugins
+export function listPlugins(): Plugin[] {
+  return Array.from(plugins.values());
+}
+
+// Unload a plugin
+export function unloadPlugin(name: string): boolean {
+  return plugins.delete(name);
+}

package/src/core/types.ts

@@ -0,0 +1,217 @@
+// Core types for Jarvis AI Agent
+import type { z } from 'zod';
+
+export type AgentMode = 'primary' | 'subagent' | 'all';
+
+export type PermissionLevel = 'ask' | 'allow' | 'deny';
+
+export interface AgentConfig {
+  id: string;
+  name: string;
+  description: string;
+  mode: AgentMode;
+  model?: string;
+  prompt?: string;
+  temperature?: number;
+  top_p?: number;
+  maxSteps?: number;
+  steps?: number;
+  tools?: Record<string, boolean>;
+  permission?: PermissionConfig;
+  hidden?: boolean;
+  disabled?: boolean;
+  color?: string;
+  options?: Record<string, unknown>;
+}
+
+export type PermissionRuleConfig = PermissionLevel | Record<string, PermissionLevel>;
+
+export interface PermissionConfig {
+  read?: PermissionRuleConfig;
+  edit?: PermissionRuleConfig;
+  glob?: PermissionRuleConfig;
+  grep?: PermissionRuleConfig;
+  list?: PermissionRuleConfig;
+  bash?: PermissionRuleConfig;
+  task?: PermissionRuleConfig;
+  external_directory?: PermissionRuleConfig;
+  todowrite?: PermissionLevel;
+  todoread?: PermissionLevel;
+  question?: PermissionLevel;
+  webfetch?: PermissionLevel;
+  websearch?: PermissionLevel;
+  codesearch?: PermissionLevel;
+  lsp?: PermissionRuleConfig;
+  doom_loop?: PermissionLevel;
+}
+
+export interface ProviderConfig {
+  id: string;
+  name: string;
+  apiKey?: string;
+  baseUrl?: string;
+  models: Record<string, ModelConfig>;
+}
+
+export interface ModelConfig {
+  name: string;
+  limit: {
+    context: number;
+    output: number;
+  };
+  modalities?: {
+    input: string[];
+    output: string[];
+  };
+  variants?: Record<string, Record<string, unknown>>;
+}
+
+export interface JarvisConfig {
+  $schema?: string;
+  model?: string;
+  small_model?: string;
+  default_agent?: string;
+  theme?: string;
+  username?: string;
+  snapshot?: boolean;
+  share?: 'manual' | 'auto' | 'disabled';
+  autoupdate?: boolean | 'notify';
+  logLevel?: 'DEBUG' | 'INFO' | 'WARN' | 'ERROR';
+  provider?: Record<string, Partial<ProviderConfig>>;
+  agent?: Record<string, Partial<AgentConfig>>;
+  plugin?: string[];
+  tools?: Record<string, boolean>;
+  permission?: PermissionConfig;
+  keybinds?: Record<string, string>;
+  command?: Record<string, CommandConfig>;
+  watcher?: {
+    ignore?: string[];
+  };
+  tui?: {
+    scroll_speed?: number;
+    scroll_acceleration?: { enabled: boolean };
+    diff_style?: 'auto' | 'stacked';
+  };
+  server?: {
+    port?: number;
+    hostname?: string;
+    mdns?: boolean;
+    cors?: string[];
+  };
+  oauth?: {
+    callbackUrl?: string;      // Custom OAuth callback URL for container deployments
+    callbackHost?: string;      // Bind host for callback server (default: '0.0.0.0')
+    callbackPort?: number;      // Port for callback server (default: 51121)
+  };
+  disabled_providers?: string[];
+  enabled_providers?: string[];
+  workspaces?: Array<{
+    id: string;
+    name: string;
+    path: string;
+    icon: string;
+  }>;
+  persona?: string;
+  instructions?: string;
+  restrictedPaths?: string[];
+}
+
+export interface CommandConfig {
+  template: string;
+  description?: string;
+  agent?: string;
+  model?: string;
+  subtask?: boolean;
+}
+
+export interface Message {
+  id: string;
+  role: 'user' | 'assistant' | 'system';
+  content: string;
+  parts?: MessagePart[];
+  timestamp: Date;
+  thinking?: string;
+  toolCalls?: Array<{
+    name: string;
+    args: any;
+    result?: any;
+  }>;
+  attachments?: any[];
+  metadata?: Record<string, unknown>;
+}
+
+export interface MessagePart {
+  type: 'text' | 'tool_call' | 'tool_result' | 'thinking' | 'image';
+  content: string;
+  toolName?: string;
+  toolArgs?: Record<string, unknown>;
+  toolResult?: unknown;
+}
+
+export interface Session {
+  id: string;
+  title?: string;
+  agentId: string;
+  workdir?: string;
+  messages: Message[];
+  createdAt: Date;
+  updatedAt: Date;
+  parentId?: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface Tool {
+  name: string;
+  description: string;
+  parameters: z.ZodType<any> | Record<string, unknown>;
+  execute: (args: Record<string, unknown>, context: ToolContext) => Promise<ToolResult>;
+}
+
+export interface ToolContext {
+  workdir: string;
+  session: Session;
+  signal?: AbortSignal;
+}
+
+export interface ToolResult {
+  success: boolean;
+  content: string;
+  error?: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface Plugin {
+  name: string;
+  version: string;
+  init?: (jarvis: JarvisInstance) => Promise<void>;
+  providers?: ProviderConfig[];
+  tools?: Tool[];
+  agents?: AgentConfig[];
+}
+
+export interface JarvisInstance {
+  config: JarvisConfig;
+  providers: Map<string, ProviderConfig>;
+  agents: Map<string, AgentConfig>;
+  tools: Map<string, Tool>;
+  sessions: Map<string, Session>;
+  activeSession?: Session;
+  activeAgent?: AgentConfig;
+}
+
+export type EventType = 
+  | 'session.created'
+  | 'session.updated'
+  | 'session.deleted'
+  | 'message.created'
+  | 'message.updated'
+  | 'tool.started'
+  | 'tool.completed'
+  | 'agent.switched'
+  | 'error';
+
+export interface JarvisEvent {
+  type: EventType;
+  timestamp: Date;
+  data: unknown;
+}

package/src/electron/main.ts

@@ -0,0 +1,192 @@
+import { app, BrowserWindow, ipcMain, dialog } from 'electron';
+import { spawn, ChildProcess } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+let mainWindow: BrowserWindow | null = null;
+let bunServer: ChildProcess | null = null;
+let serverPort: number = 5533;
+
+/**
+ * Start Bun server in background
+ */
+async function startBunServer(): Promise<string> {
+  return new Promise((resolve, reject) => {
+    console.log('[Electron] Starting Bun server...');
+    
+    // Find project root (go up from dist/electron/main.js to project root)
+    const projectRoot = path.join(__dirname, '..', '..');
+    const cliPath = path.join(projectRoot, 'src', 'cli.ts');
+    
+    // Start Bun server
+    bunServer = spawn('bun', ['run', cliPath, 'web', '--port', String(serverPort)], {
+      cwd: projectRoot,
+      stdio: 'pipe'
+    });
+    
+    bunServer.stdout?.on('data', (data) => {
+      const output = data.toString();
+      console.log('[Bun Server]', output);
+      
+      // Look for server ready message
+      if (output.includes('Server running') || output.includes('localhost')) {
+        resolve(`http://localhost:${serverPort}`);
+      }
+    });
+    
+    bunServer.stderr?.on('data', (data) => {
+      console.error('[Bun Server Error]', data.toString());
+    });
+    
+    bunServer.on('error', (error) => {
+      console.error('[Bun Server] Failed to start:', error);
+      reject(error);
+    });
+    
+    // Timeout after 10 seconds
+    setTimeout(() => {
+      resolve(`http://localhost:${serverPort}`);
+    }, 3000);
+  });
+}
+
+/**
+ * Create main Electron window
+ */
+async function createWindow() {
+  console.log('[Electron] Creating main window...');
+  
+  // Start Bun server first
+  const serverUrl = await startBunServer();
+  console.log('[Electron] Server URL:', serverUrl);
+  
+  // Create browser window
+  mainWindow = new BrowserWindow({
+    width: 1400,
+    height: 900,
+    minWidth: 1024,
+    minHeight: 768,
+    title: 'JARVIS - AI Coding Assistant',
+    backgroundColor: '#09090b', // zinc-950
+    autoHideMenuBar: true, // Hide menu bar but allow Alt to show it
+    webPreferences: {
+      preload: path.join(__dirname, 'preload.js'),
+      contextIsolation: true,
+      nodeIntegration: false,
+      sandbox: false
+    },
+    show: false // Don't show until ready
+  });
+  
+  // Show window when ready
+  mainWindow.once('ready-to-show', () => {
+    mainWindow?.show();
+    console.log('[Electron] Window ready');
+  });
+  
+  // Load the Bun server URL
+  await mainWindow.loadURL(serverUrl);
+  
+  // Open DevTools in development
+  if (process.env.NODE_ENV === 'development') {
+    mainWindow.webContents.openDevTools();
+  }
+  
+  // Handle window closed
+  mainWindow.on('closed', () => {
+    mainWindow = null;
+  });
+}
+
+/**
+ * Setup IPC handlers
+ */
+function setupIPC() {
+  // Handle folder selection
+  ipcMain.handle('select-folder', async () => {
+    const result = await dialog.showOpenDialog({
+      properties: ['openDirectory'],
+      title: 'Select Workspace Folder'
+    });
+    
+    if (result.canceled || result.filePaths.length === 0) {
+      return null;
+    }
+    
+    return result.filePaths[0];
+  });
+  
+  // Handle file selection
+  ipcMain.handle('select-files', async () => {
+    const result = await dialog.showOpenDialog({
+      properties: ['openFile', 'multiSelections'],
+      title: 'Select Files'
+    });
+    
+    if (result.canceled) {
+      return [];
+    }
+    
+    return result.filePaths;
+  });
+  
+  // Get app version
+  ipcMain.handle('get-app-version', () => {
+    return app.getVersion();
+  });
+  
+  // Get app mode
+  ipcMain.handle('get-app-mode', () => {
+    return 'electron';
+  });
+}
+
+/**
+ * Cleanup on app quit
+ */
+function cleanup() {
+  console.log('[Electron] Cleaning up...');
+  
+  if (bunServer) {
+    console.log('[Electron] Stopping Bun server...');
+    bunServer.kill();
+    bunServer = null;
+  }
+}
+
+/**
+ * App lifecycle
+ */
+app.whenReady().then(() => {
+  console.log('[Electron] App ready');
+  setupIPC();
+  createWindow();
+  
+  // On macOS, re-create window when dock icon is clicked
+  app.on('activate', () => {
+    if (BrowserWindow.getAllWindows().length === 0) {
+      createWindow();
+    }
+  });
+});
+
+// Quit when all windows are closed (except on macOS)
+app.on('window-all-closed', () => {
+  if (process.platform !== 'darwin') {
+    cleanup();
+    app.quit();
+  }
+});
+
+// Cleanup before quit
+app.on('before-quit', () => {
+  cleanup();
+});
+
+// Handle uncaught errors
+process.on('uncaughtException', (error) => {
+  console.error('[Electron] Uncaught exception:', error);
+});

package/src/electron/preload.ts

@@ -0,0 +1,25 @@
+import { contextBridge, ipcRenderer } from 'electron';
+
+/**
+ * Electron Preload Script
+ * Bridges main process and renderer process securely
+ */
+
+// Expose safe APIs to renderer process
+contextBridge.exposeInMainWorld('electron', {
+  // Folder selection
+  selectFolder: () => ipcRenderer.invoke('select-folder'),
+  
+  // File selection
+  selectFiles: () => ipcRenderer.invoke('select-files'),
+  
+  // App info
+  getAppVersion: () => ipcRenderer.invoke('get-app-version'),
+  getAppMode: () => ipcRenderer.invoke('get-app-mode'),
+  
+  // Environment detection
+  isElectron: true,
+  platform: process.platform
+});
+
+console.log('[Preload] Electron APIs exposed to renderer');

package/src/electron/types.d.ts

@@ -0,0 +1,20 @@
+/**
+ * TypeScript type definitions for Electron APIs exposed to renderer
+ */
+
+export interface ElectronAPI {
+  selectFolder: () => Promise<string | null>;
+  selectFiles: () => Promise<string[]>;
+  getAppVersion: () => Promise<string>;
+  getAppMode: () => Promise<'electron' | 'web'>;
+  isElectron: boolean;
+  platform: NodeJS.Platform;
+}
+
+declare global {
+  interface Window {
+    electron?: ElectronAPI;
+  }
+}
+
+export {};

package/src/index.ts

@@ -0,0 +1,12 @@
+// Jarvis AI - Main Entry Point
+// This file exports all modules for SDK/library usage
+
+export * from './core/types.js';
+export * from './config/index.js';
+export * from './providers/index.js';
+export * from './agents/index.js';
+export * from './tools/index.js';
+export * from './sessions/index.js';
+export * from './core/executor.js';
+export * from './core/plugins.js';
+export * from './utils/index.js';