@shykaruu/jarvis-brain 0.4.0

package/src/actions/terminal/executor.ts

@@ -0,0 +1,157 @@
+import { spawn, type Subprocess } from 'bun';
+
+export type CommandResult = {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+  duration: number;
+};
+
+export type ExecuteOptions = {
+  cwd?: string;
+  env?: Record<string, string>;
+  timeout?: number;
+};
+
+export class TerminalExecutor {
+  private shell: string;
+  private defaultTimeout: number;
+
+  constructor(opts?: { shell?: string; timeout?: number }) {
+    this.shell = opts?.shell ?? TerminalExecutor.detectShell();
+    this.defaultTimeout = opts?.timeout ?? 30000;
+  }
+
+  async execute(command: string, opts?: ExecuteOptions): Promise<CommandResult> {
+    const startTime = Date.now();
+    const timeout = opts?.timeout ?? this.defaultTimeout;
+
+    try {
+      const proc = spawn({
+        cmd: [this.shell, '-c', command],
+        cwd: opts?.cwd,
+        env: { ...process.env, ...opts?.env },
+        stdout: 'pipe',
+        stderr: 'pipe',
+      });
+
+      const timeoutId = setTimeout(() => {
+        proc.kill();
+      }, timeout);
+
+      const [stdout, stderr, exitCode] = await Promise.all([
+        this.readStream(proc.stdout),
+        this.readStream(proc.stderr),
+        proc.exited,
+      ]);
+
+      clearTimeout(timeoutId);
+
+      const duration = Date.now() - startTime;
+
+      return {
+        stdout: stdout.toString('utf-8'),
+        stderr: stderr.toString('utf-8'),
+        exitCode: exitCode ?? 0,
+        duration,
+      };
+    } catch (error) {
+      const duration = Date.now() - startTime;
+
+      if (duration >= timeout) {
+        throw new Error(`Command timed out after ${timeout}ms: ${command}`);
+      }
+
+      throw new Error(`Command execution failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  async *stream(command: string, opts?: { cwd?: string; env?: Record<string, string> }): AsyncIterable<string> {
+    const proc = spawn({
+      cmd: [this.shell, '-c', command],
+      cwd: opts?.cwd,
+      env: { ...process.env, ...opts?.env },
+      stdout: 'pipe',
+      stderr: 'pipe',
+    });
+
+    const decoder = new TextDecoder();
+
+    if (!proc.stdout) {
+      throw new Error('Failed to get stdout stream');
+    }
+
+    const reader = proc.stdout.getReader();
+
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+
+        if (done) {
+          break;
+        }
+
+        if (value) {
+          yield decoder.decode(value, { stream: true });
+        }
+      }
+    } finally {
+      reader.releaseLock();
+      proc.kill();
+    }
+  }
+
+  static detectShell(): string {
+    const platform = process.platform;
+
+    if (platform === 'win32') {
+      return process.env.COMSPEC ?? 'powershell.exe';
+    }
+
+    if (process.env.SHELL) {
+      return process.env.SHELL;
+    }
+
+    return '/bin/bash';
+  }
+
+  getShell(): string {
+    return this.shell;
+  }
+
+  private async readStream(stream: ReadableStream<Uint8Array> | null): Promise<Buffer> {
+    if (!stream) {
+      return Buffer.from('');
+    }
+
+    const reader = stream.getReader();
+    const chunks: Uint8Array[] = [];
+
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+
+        if (done) {
+          break;
+        }
+
+        if (value) {
+          chunks.push(value);
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+
+    const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    const result = new Uint8Array(totalLength);
+
+    let offset = 0;
+    for (const chunk of chunks) {
+      result.set(chunk, offset);
+      offset += chunk.length;
+    }
+
+    return Buffer.from(result);
+  }
+}

package/src/actions/terminal/wsl-bridge.ts

@@ -0,0 +1,126 @@
+import { TerminalExecutor, type CommandResult } from './executor.ts';
+import { readFileSync, existsSync } from 'node:fs';
+
+export class WSLBridge {
+  private executor: TerminalExecutor;
+  private windowsHome: string | null = null;
+
+  constructor() {
+    this.executor = new TerminalExecutor();
+
+    if (WSLBridge.isWSL()) {
+      this.detectWindowsHome();
+    }
+  }
+
+  static isWSL(): boolean {
+    try {
+      if (process.platform !== 'linux') {
+        return false;
+      }
+
+      if (existsSync('/proc/version')) {
+        const version = readFileSync('/proc/version', 'utf-8').toLowerCase();
+        return version.includes('microsoft') || version.includes('wsl');
+      }
+
+      if (process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP) {
+        return true;
+      }
+
+      return false;
+    } catch {
+      return false;
+    }
+  }
+
+  async runWindowsCommand(command: string): Promise<CommandResult> {
+    if (!WSLBridge.isWSL()) {
+      throw new Error('Not running in WSL environment');
+    }
+
+    try {
+      return await this.executor.execute(`cmd.exe /C "${command.replace(/"/g, '\\"')}"`);
+    } catch (error) {
+      throw new Error(`Failed to run Windows command: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  async runPowerShell(script: string): Promise<CommandResult> {
+    if (!WSLBridge.isWSL()) {
+      throw new Error('Not running in WSL environment');
+    }
+
+    try {
+      const escapedScript = script
+        .replace(/\\/g, '\\\\')
+        .replace(/"/g, '\\"')
+        .replace(/\$/g, '\\$')
+        .replace(/`/g, '\\`');
+
+      return await this.executor.execute(`powershell.exe -Command "${escapedScript}"`);
+    } catch (error) {
+      throw new Error(`Failed to run PowerShell script: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  getWindowsHome(): string | null {
+    return this.windowsHome;
+  }
+
+  private detectWindowsHome(): void {
+    try {
+      const result = this.executor.execute('cmd.exe /C "echo %USERPROFILE%"');
+      result.then(res => {
+        const path = res.stdout.trim();
+
+        if (path && !path.includes('%')) {
+          this.windowsHome = this.convertWindowsPath(path);
+        }
+      }).catch(() => {
+        this.windowsHome = null;
+      });
+    } catch {
+      this.windowsHome = null;
+    }
+  }
+
+  private convertWindowsPath(windowsPath: string): string {
+    const normalized = windowsPath.replace(/\\/g, '/');
+
+    const driveMatch = normalized.match(/^([A-Z]):/i);
+    if (driveMatch) {
+      const drive = driveMatch[1]?.toLowerCase();
+      const rest = normalized.slice(2);
+      return `/mnt/${drive}${rest}`;
+    }
+
+    return normalized;
+  }
+
+  async convertToWindowsPath(wslPath: string): Promise<string> {
+    if (!WSLBridge.isWSL()) {
+      throw new Error('Not running in WSL environment');
+    }
+
+    try {
+      const result = await this.executor.execute(`wslpath -w "${wslPath}"`);
+      return result.stdout.trim();
+    } catch (error) {
+      throw new Error(`Failed to convert WSL path: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  async convertToWSLPath(windowsPath: string): Promise<string> {
+    if (!WSLBridge.isWSL()) {
+      throw new Error('Not running in WSL environment');
+    }
+
+    try {
+      const result = await this.executor.execute(`wslpath -u "${windowsPath}"`);
+      return result.stdout.trim();
+    } catch (error) {
+      throw new Error(`Failed to convert Windows path: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+}

package/src/actions/test.ts

@@ -0,0 +1,93 @@
+#!/usr/bin/env bun
+
+import {
+  getAppController,
+  TerminalExecutor,
+  WSLBridge,
+  BrowserSession,
+  CDPBrowser,
+  ToolRegistry,
+  type ToolDefinition,
+} from './index.ts';
+
+async function testActionLayer() {
+  console.log('Testing J.A.R.V.I.S. Action Layer\n');
+
+  console.log('1. App Controller');
+  console.log(`   Platform: ${process.platform}`);
+  try {
+    const appController = getAppController();
+    console.log(`   ✓ App controller initialized for ${process.platform}`);
+  } catch (error) {
+    console.log(`   ⚠ App controller not available: ${error instanceof Error ? error.message.split('\n')[0] : String(error)}`);
+  }
+
+  console.log('\n2. Terminal Executor');
+  const executor = new TerminalExecutor();
+  console.log(`   Detected shell: ${executor.getShell()}`);
+  try {
+    const result = await executor.execute('echo "Hello from JARVIS"');
+    console.log(`   ✓ Command executed: ${result.stdout.trim()}`);
+    console.log(`   Duration: ${result.duration}ms`);
+  } catch (error) {
+    console.log(`   ✗ Error: ${error instanceof Error ? error.message : String(error)}`);
+  }
+
+  console.log('\n3. WSL Bridge');
+  const isWSL = WSLBridge.isWSL();
+  console.log(`   Running in WSL: ${isWSL}`);
+  if (isWSL) {
+    const bridge = new WSLBridge();
+    console.log(`   Windows home: ${bridge.getWindowsHome() ?? 'Not detected'}`);
+  }
+
+  console.log('\n4. Browser Session');
+  const browserSession = new BrowserSession(9222);
+  const isAvailable = await browserSession.isAvailable();
+  console.log(`   Chrome DevTools available: ${isAvailable}`);
+  if (isAvailable) {
+    try {
+      await (browserSession as any).ensureConnected();
+      const browser = (browserSession as any).getBrowser();
+      const tabs = await browser.listTabs();
+      console.log(`   ✓ Found ${tabs.length} browser tab(s)`);
+      await browserSession.disconnect();
+    } catch (error) {
+      console.log(`   ⚠ Could not connect: ${error instanceof Error ? error.message.split('\n')[0] : String(error)}`);
+    }
+  }
+
+  console.log('\n5. Tool Registry');
+  const registry = new ToolRegistry();
+
+  const exampleTool: ToolDefinition = {
+    name: 'echo',
+    description: 'Echo a message',
+    category: 'utility',
+    parameters: {
+      message: {
+        type: 'string',
+        description: 'Message to echo',
+        required: true,
+      },
+    },
+    execute: async (params) => {
+      return `Echo: ${params.message}`;
+    },
+  };
+
+  registry.register(exampleTool);
+  console.log(`   Registered tools: ${registry.count()}`);
+  console.log(`   Categories: ${registry.getCategories().join(', ')}`);
+
+  try {
+    const result = await registry.execute('echo', { message: 'Hello JARVIS!' });
+    console.log(`   ✓ Tool execution: ${result}`);
+  } catch (error) {
+    console.log(`   ✗ Error: ${error instanceof Error ? error.message : String(error)}`);
+  }
+
+  console.log('\n✓ Action Layer test complete!\n');
+}
+
+testActionLayer().catch(console.error);