@benzsiangco/jarvis 1.0.0 → 1.1.0

package/dist/electron/main.js

@@ -0,0 +1,160 @@
+import { app, BrowserWindow, ipcMain, dialog } from 'electron';
+import { spawn } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+let mainWindow = null;
+let bunServer = null;
+let serverPort = 5533;
+/**
+ * Start Bun server in background
+ */
+async function startBunServer() {
+    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/dist/electron/preload.js

@@ -0,0 +1,19 @@
+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/package.json

@@ -1,32 +1,42 @@
 {
   "name": "@benzsiangco/jarvis",
-  "version": "1.0.0",
-  "description": "AI coding agent with TUI, Web, and Desktop support",
+  "version": "1.1.0",
+  "description": "AI coding agent with TUI, Web, and Desktop support - Now with Brain system, OAuth config, and enhanced Skills",
   "module": "src/index.ts",
   "type": "module",
   "private": false,
   "bin": {
-    "jarvis": "./bin/jarvis.js"
+    "jarvis": "./bin/jarvis"
   },
   "files": [
     "dist",
-    "bin"
+    "bin",
+    "src",
+    "skills.md"
   ],
   "scripts": {
     "dev": "bun run src/cli.ts",
-    "build": "bun build src/cli.ts --outdir dist --target node --minify",
+    "build": "bun build src/cli.ts --outdir dist --target bun --minify",
     "prepublishOnly": "bun run build",
     "start": "bun run dist/cli.js",
     "typecheck": "tsc --noEmit",
     "opentui": "bun run src/cli.ts tui",
     "web": "bun run src/cli.ts web",
-    "web:build": "bun run src/web/build-ui.ts"
+    "web:build": "bun run src/web/build-ui.ts",
+    "electron:compile": "tsc src/electron/main.ts src/electron/preload.ts --outDir dist/electron --target es2020 --module esnext --moduleResolution bundler --esModuleInterop --skipLibCheck",
+    "electron:dev": "concurrently \"bun run web\" \"electron dist/electron/main.js\"",
+    "electron:build": "bun run web:build && bun run electron:compile && electron-builder",
+    "electron:start": "electron dist/electron/main.js"
   },
+  "main": "dist/electron/main.js",
   "devDependencies": {
     "@types/bun": "latest",
     "@types/marked-terminal": "^6.1.1",
     "@types/node": "^22.10.0",
-    "@types/react": "19"
+    "@types/react": "19",
+    "concurrently": "^9.2.1",
+    "electron": "^40.0.0",
+    "electron-builder": "^26.4.0"
   },
   "peerDependencies": {
     "typescript": "^5"
@@ -46,11 +56,13 @@
     "commander": "^12.1.0",
     "conf": "^13.0.0",
     "figures": "^6.0.0",
+    "framer-motion": "^12.27.0",
     "glob": "^11.0.0",
     "hono": "^4.11.4",
     "lucide-react": "^0.562.0",
     "marked": "^15.0.0",
     "marked-terminal": "^7.2.0",
+    "node-pty": "^1.1.0",
     "open": "^11.0.0",
     "opencode-antigravity-auth": "^1.3.0",
     "ora": "^8.0.0",
@@ -63,7 +75,8 @@
     "tailwind-merge": "^3.4.0",
     "xterm": "^5.3.0",
     "xterm-addon-fit": "^0.8.0",
-    "zod": "^3.23.0"
+    "zod": "^3.23.0",
+    "zustand": "^5.0.10"
   },
   "engines": {
     "node": ">=20.0.0"

package/skills.md

@@ -0,0 +1,147 @@
+# JARVIS Skills Registry
+
+This file contains modular skill modules that JARVIS can reference. Each skill adds specialized knowledge to specific domains.
+
+---
+
+## DevOps & Infrastructure
+
+### Linux System Administration
+- Expert in systemd, journalctl, process management
+- Package management (apt, yum, pacman)
+- Systemctl service management
+- Log analysis and debugging
+- Performance tuning and monitoring
+
+### Docker & Containerization
+- Dockerfile best practices and optimization
+- Multi-stage builds for minimal images
+- Docker Compose orchestration
+- Volume management and networking
+- Container security hardening
+- Image layer optimization
+
+### Proxmox Virtualization
+- LXC container management (pct commands)
+- VM operations (qm commands)
+- Storage configuration (LVM, ZFS)
+- Network bridge setup
+- Backup and restore strategies
+- Resource allocation and limits
+
+---
+
+## Security & Hacking
+
+### Penetration Testing
+- Reconnaissance and enumeration
+- Vulnerability scanning (Nmap, Nikto, etc.)
+- Web application testing (OWASP Top 10)
+- Privilege escalation techniques
+- Exploit development basics
+- Post-exploitation strategies
+
+### Network Security
+- Firewall configuration (iptables, ufw, pf)
+- VPN setup (WireGuard, OpenVPN)
+- SSH hardening and key management
+- TLS/SSL certificate management
+- Network traffic analysis
+- Intrusion detection systems
+
+### Cloudflare Integration
+- Cloudflare Tunnel (cloudflared) setup
+- DNS management and configuration
+- WAF rules and security policies
+- Zero Trust Access configuration
+- CDN optimization
+- DDoS protection strategies
+
+---
+
+## Software Development
+
+### TypeScript & JavaScript
+- Modern ES6+ features
+- TypeScript advanced types (generics, conditional types)
+- Async/await patterns
+- Module systems (ESM, CommonJS)
+- Build tools (Bun, Vite, esbuild)
+- Testing (Jest, Vitest, Playwright)
+
+### Frontend Development
+- React ecosystem (hooks, context, state management)
+- Next.js (App Router, Server Components)
+- TailwindCSS utility-first design
+- Framer Motion animations
+- Responsive design patterns
+- Performance optimization
+
+### Backend Development
+- Hono web framework
+- RESTful API design
+- WebSocket real-time communication
+- Database design (SQL, NoSQL)
+- Authentication & authorization
+- API security best practices
+
+---
+
+## Automation & Scripting
+
+### SSH Automation
+- SSH key-based authentication
+- Remote command execution
+- SCP/SFTP file transfers
+- SSH tunneling and port forwarding
+- ProxyJump configurations
+- Batch operations on multiple servers
+
+### CI/CD Pipelines
+- GitHub Actions workflows
+- GitLab CI/CD configuration
+- Docker-based build pipelines
+- Automated testing integration
+- Deployment strategies (blue-green, canary)
+- Rollback mechanisms
+
+---
+
+## Database Management
+
+### PostgreSQL
+- Schema design and normalization
+- Query optimization and indexing
+- JSONB operations
+- Full-text search
+- Replication and backup
+- Performance tuning
+
+### Redis
+- Caching strategies
+- Pub/Sub messaging
+- Session management
+- Rate limiting implementation
+- Data structures (Lists, Sets, Hashes)
+
+---
+
+## Monitoring & Observability
+
+### Logging Systems
+- Structured logging best practices
+- Log aggregation (ELK stack, Loki)
+- Log rotation and retention
+- Error tracking (Sentry integration)
+- Correlation IDs for distributed systems
+
+### Metrics & Alerts
+- Prometheus metrics collection
+- Grafana dashboard creation
+- Alert rule configuration
+- SLO/SLI definition
+- Incident response procedures
+
+---
+
+_Add more skills as needed. Each skill module is automatically included when relevant to the conversation._

package/src/agents/index.ts

@@ -0,0 +1,248 @@
+// Agent system for Jarvis
+import type { AgentConfig, AgentMode } from '../core/types';
+
+// Built-in agent definitions
+const builtinAgents: Record<string, AgentConfig> = {
+  build: {
+    id: 'build',
+    name: 'Jarvis',
+    description: 'A powerful AI coding assistant with full tool access for development work',
+    mode: 'primary',
+    tools: {
+      bash: true,
+      read: true,
+      write: true,
+      edit: true,
+      glob: true,
+      grep: true,
+      webfetch: true,
+      task: true,
+      todoread: true,
+      todowrite: true,
+      question: true,
+    },
+    permission: {
+      edit: 'allow',
+      bash: 'allow',
+      webfetch: 'allow',
+    },
+  },
+  plan: {
+    id: 'plan',
+    name: 'Plan',
+    description: 'Restricted agent for planning and analysis without making changes',
+    mode: 'primary',
+    tools: {
+      bash: false,
+      read: true,
+      write: false,
+      edit: false,
+      glob: true,
+      grep: true,
+      webfetch: true,
+      task: true,
+      todoread: true,
+      todowrite: true,
+      question: true,
+    },
+    permission: {
+      edit: 'deny',
+      bash: 'ask',
+      webfetch: 'allow',
+    },
+  },
+  general: {
+    id: 'general',
+    name: 'General',
+    description: 'General-purpose agent for researching complex questions and executing multi-step tasks',
+    mode: 'subagent',
+    tools: {
+      bash: true,
+      read: true,
+      write: true,
+      edit: true,
+      glob: true,
+      grep: true,
+      webfetch: true,
+      task: false, // Cannot spawn sub-subagents
+      todoread: true,
+      todowrite: true,
+      question: true,
+    },
+    permission: {
+      edit: 'allow',
+      bash: 'allow',
+      webfetch: 'allow',
+    },
+  },
+  explore: {
+    id: 'explore',
+    name: 'Explore',
+    description: 'Fast agent specialized for exploring codebases. Use for finding files by patterns, searching code, or answering questions about the codebase.',
+    mode: 'subagent',
+    maxSteps: 10,
+    tools: {
+      bash: false,
+      read: true,
+      write: false,
+      edit: false,
+      glob: true,
+      grep: true,
+      webfetch: false,
+      task: false,
+      todoread: true,
+      todowrite: true,
+      question: false,
+    },
+    permission: {
+      edit: 'deny',
+      bash: 'deny',
+      webfetch: 'deny',
+    },
+  },
+};
+
+// Agent registry
+const agents = new Map<string, AgentConfig>();
+
+// Initialize with built-in agents
+export function initializeAgents(customAgents?: Record<string, Partial<AgentConfig>>): void {
+  agents.clear();
+  
+  // Add built-in agents
+  for (const [id, agent] of Object.entries(builtinAgents)) {
+    agents.set(id, agent);
+  }
+  
+  // Merge with custom agents
+  if (customAgents) {
+    for (const [id, customConfig] of Object.entries(customAgents)) {
+      const existingAgent = agents.get(id);
+      if (existingAgent) {
+        // Merge with existing agent
+        agents.set(id, mergeAgentConfig(existingAgent, customConfig));
+      } else {
+        // Create new agent
+        agents.set(id, {
+          id,
+          name: customConfig.name ?? id,
+          description: customConfig.description ?? '',
+          mode: customConfig.mode ?? 'all',
+          ...customConfig,
+        } as AgentConfig);
+      }
+    }
+  }
+}
+
+function mergeAgentConfig(base: AgentConfig, override: Partial<AgentConfig>): AgentConfig {
+  return {
+    ...base,
+    ...override,
+    tools: {
+      ...base.tools,
+      ...override.tools,
+    },
+    permission: {
+      ...base.permission,
+      ...override.permission,
+    },
+  };
+}
+
+export function getAgent(id: string): AgentConfig | undefined {
+  return agents.get(id);
+}
+
+export function getPrimaryAgents(): AgentConfig[] {
+  return Array.from(agents.values()).filter(
+    (agent) => agent.mode === 'primary' || agent.mode === 'all'
+  );
+}
+
+export function getSubagents(): AgentConfig[] {
+  return Array.from(agents.values()).filter(
+    (agent) => (agent.mode === 'subagent' || agent.mode === 'all') && !agent.hidden
+  );
+}
+
+export function getAllAgents(): AgentConfig[] {
+  return Array.from(agents.values());
+}
+
+export function isToolEnabled(agent: AgentConfig, toolName: string): boolean {
+  if (agent.disabled) return false;
+  if (agent.tools === undefined) return true;
+  return agent.tools[toolName] ?? true;
+}
+
+// Get system prompt for an agent
+export function getAgentSystemPrompt(agent: AgentConfig): string {
+  // Load JARVIS brain (automatically created if doesn't exist)
+  let brain = '';
+  try {
+    const { loadBrain } = require('../brain/loader.js');
+    brain = loadBrain();
+  } catch (error) {
+    console.warn('[Agent] Could not load brain:', error);
+  }
+  
+  // Load skills content
+  let skillsContent = '';
+  try {
+    const { loadSkills } = require('../utils/skills.js');
+    skillsContent = loadSkills();
+  } catch (error) {
+    console.warn('[Agent] Could not load skills:', error);
+  }
+  
+  // Combine: Brain + Skills + Agent-specific prompt
+  const parts: string[] = [];
+  
+  // 1. Core brain (JARVIS.md)
+  if (brain) {
+    parts.push(brain);
+  }
+  
+  // 2. Active skills
+  if (skillsContent) {
+    parts.push('\n## Active Skills\n' + skillsContent);
+  }
+  
+  // 3. Agent-specific instructions
+  if (agent.description) {
+    parts.push('\n## Agent Role\n' + agent.description);
+  }
+  
+  if (agent.prompt) {
+    parts.push('\n## Additional Instructions\n' + agent.prompt);
+  }
+  
+  // If no brain or skills loaded, fall back to basic prompt
+  if (parts.length === 0) {
+    const basePrompt = `You are ${agent.name}, an AI coding assistant.
+Your name is ${agent.name}. You are JARVIS (Just A Rather Very Intelligent System).
+
+${agent.description}
+
+You help users with software engineering tasks including:
+- Answering questions about code
+- Debugging issues
+- Adding new features
+- Refactoring code
+- Explaining complex concepts
+
+Always be helpful, accurate, and thorough. When making changes, explain what you're doing and why.`;
+    
+    if (agent.prompt) {
+      return `${basePrompt}\n\n${agent.prompt}`;
+    }
+    
+    return basePrompt;
+  }
+  
+  return parts.join('\n\n');
+}
+
+// Initialize agents on module load
+initializeAgents();