@usejarvis/brain 0.1.0

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);

package/src/actions/tools/agents.ts

@@ -0,0 +1,321 @@
+/**
+ * Manage Agents Tool — Multi-Agent Hierarchy
+ *
+ * Allows the primary agent to spawn persistent sub-agents, assign them tasks
+ * (async), check status, collect results, and terminate them.
+ *
+ * For quick sync delegation (spawn → run → return → terminate in one call),
+ * use delegate_task instead.
+ */
+
+import type { AgentOrchestrator } from '../../agents/orchestrator.ts';
+import type { LLMManager } from '../../llm/manager.ts';
+import type { RoleDefinition } from '../../roles/types.ts';
+import type { ToolDefinition } from './registry.ts';
+import type { AgentTaskManager } from '../../agents/task-manager.ts';
+import { createScopedToolRegistry, type ProgressCallback } from '../../agents/sub-agent-runner.ts';
+
+export type AgentToolDeps = {
+  orchestrator: AgentOrchestrator;
+  llmManager: LLMManager;
+  specialists: Map<string, RoleDefinition>;
+  taskManager: AgentTaskManager;
+  onProgress?: ProgressCallback;
+};
+
+// Track scoped registries for persistent agents so they can be reused across tasks
+const agentRegistries = new Map<string, ReturnType<typeof createScopedToolRegistry>>();
+
+export function createManageAgentsTool(deps: AgentToolDeps): ToolDefinition {
+  return {
+    name: 'manage_agents',
+    description: [
+      'Manage persistent sub-agents for complex or parallel work.',
+      'Use this when you need agents that stay alive across multiple tasks or run in parallel.',
+      'For quick one-shot tasks, use delegate_task instead.',
+      '',
+      'Actions:',
+      '  spawn     — Create a persistent specialist agent (returns agent_id)',
+      '  assign    — Send a task to an existing agent (async, returns task_id)',
+      '  status    — Check agent or task status',
+      '  collect   — Get full result of a completed task',
+      '  list      — Show all active agents and tasks',
+      '  terminate — Shut down an agent',
+      '',
+      'Available specialists: ' + Array.from(deps.specialists.keys()).join(', '),
+      '',
+      'Workflow: spawn → assign → status/collect → terminate',
+    ].join('\n'),
+    category: 'delegation',
+    parameters: {
+      action: {
+        type: 'string',
+        description: 'The action: spawn, assign, status, collect, list, terminate',
+        required: true,
+      },
+      specialist: {
+        type: 'string',
+        description: 'Specialist role ID (required for spawn)',
+        required: false,
+      },
+      agent_id: {
+        type: 'string',
+        description: 'Agent ID (required for assign, terminate; optional for status)',
+        required: false,
+      },
+      task_id: {
+        type: 'string',
+        description: 'Task ID (for status, collect)',
+        required: false,
+      },
+      task: {
+        type: 'string',
+        description: 'Task description (required for assign)',
+        required: false,
+      },
+      context: {
+        type: 'string',
+        description: 'Background context for the task (optional for assign)',
+        required: false,
+      },
+    },
+    execute: async (params) => {
+      const action = params.action as string;
+
+      switch (action) {
+        case 'spawn':
+          return handleSpawn(deps, params);
+        case 'assign':
+          return handleAssign(deps, params);
+        case 'status':
+          return handleStatus(deps, params);
+        case 'collect':
+          return handleCollect(deps, params);
+        case 'list':
+          return handleList(deps);
+        case 'terminate':
+          return handleTerminate(deps, params);
+        default:
+          return `Error: Unknown action "${action}". Use: spawn, assign, status, collect, list, terminate`;
+      }
+    },
+  };
+}
+
+function handleSpawn(deps: AgentToolDeps, params: Record<string, unknown>): string {
+  const specialistId = params.specialist as string;
+  if (!specialistId) {
+    return 'Error: "specialist" is required for spawn. Available: ' + Array.from(deps.specialists.keys()).join(', ');
+  }
+
+  const role = deps.specialists.get(specialistId);
+  if (!role) {
+    return `Error: Unknown specialist "${specialistId}". Available: ${Array.from(deps.specialists.keys()).join(', ')}`;
+  }
+
+  const primary = deps.orchestrator.getPrimary();
+  if (!primary) {
+    return 'Error: No primary agent exists';
+  }
+
+  const agent = deps.orchestrator.spawnSubAgent(primary.id, role);
+  const scopedRegistry = createScopedToolRegistry(agent.agent.authority.allowed_tools);
+  agentRegistries.set(agent.id, scopedRegistry);
+
+  console.log(`[ManageAgents] Spawned ${role.name} (${agent.id}) with ${scopedRegistry.count()} tools`);
+
+  return JSON.stringify({
+    agent_id: agent.id,
+    name: role.name,
+    specialist: specialistId,
+    status: 'idle',
+    tools_available: scopedRegistry.count(),
+    tool_categories: agent.agent.authority.allowed_tools,
+  });
+}
+
+async function handleAssign(deps: AgentToolDeps, params: Record<string, unknown>): Promise<string> {
+  const agentId = params.agent_id as string;
+  const task = params.task as string;
+  const context = (params.context as string) || '';
+
+  if (!agentId) return 'Error: "agent_id" is required for assign';
+  if (!task) return 'Error: "task" is required for assign';
+
+  const agent = deps.orchestrator.getAgent(agentId);
+  if (!agent) return `Error: Agent "${agentId}" not found. Use list to see active agents.`;
+
+  if (deps.taskManager.isAgentBusy(agentId)) {
+    return `Error: Agent "${agent.agent.role.name}" is already running a task. Wait for it to finish or terminate it.`;
+  }
+
+  const scopedRegistry = agentRegistries.get(agentId);
+  if (!scopedRegistry) {
+    return `Error: No tool registry for agent "${agentId}". Was it spawned via manage_agents?`;
+  }
+
+  // Notify progress
+  deps.onProgress?.({
+    type: 'text',
+    agentName: agent.agent.role.name,
+    agentId,
+    data: `[Assigning task to ${agent.agent.role.name}...]`,
+  });
+
+  const taskId = deps.taskManager.launch({
+    agent,
+    task,
+    context,
+    llmManager: deps.llmManager,
+    toolRegistry: scopedRegistry,
+    onProgress: deps.onProgress,
+  });
+
+  console.log(`[ManageAgents] Assigned task ${taskId} to ${agent.agent.role.name}`);
+
+  return JSON.stringify({
+    task_id: taskId,
+    agent_id: agentId,
+    agent_name: agent.agent.role.name,
+    status: 'running',
+    message: `Task assigned to ${agent.agent.role.name}. Use status or collect to check progress.`,
+  });
+}
+
+function handleStatus(deps: AgentToolDeps, params: Record<string, unknown>): string {
+  const taskId = params.task_id as string;
+  const agentId = params.agent_id as string;
+
+  if (taskId) {
+    const task = deps.taskManager.getTask(taskId);
+    if (!task) return `Error: Task "${taskId}" not found`;
+
+    const elapsed = task.completedAt
+      ? task.completedAt - task.startedAt
+      : Date.now() - task.startedAt;
+
+    return JSON.stringify({
+      task_id: task.id,
+      agent_name: task.agentName,
+      status: task.status,
+      task: task.task,
+      elapsed_ms: elapsed,
+      elapsed_seconds: Math.round(elapsed / 1000),
+      has_result: task.result !== null,
+    });
+  }
+
+  if (agentId) {
+    const agent = deps.orchestrator.getAgent(agentId);
+    if (!agent) return `Error: Agent "${agentId}" not found`;
+
+    const agentTask = deps.taskManager.getAgentTask(agentId);
+    return JSON.stringify({
+      agent_id: agentId,
+      name: agent.agent.role.name,
+      status: agent.agent.status,
+      current_task: agent.agent.current_task,
+      busy: deps.taskManager.isAgentBusy(agentId),
+      latest_task: agentTask ? {
+        task_id: agentTask.id,
+        status: agentTask.status,
+        task: agentTask.task,
+      } : null,
+    });
+  }
+
+  // No ID given — return summary
+  return handleList(deps);
+}
+
+function handleCollect(deps: AgentToolDeps, params: Record<string, unknown>): string {
+  const taskId = params.task_id as string;
+  if (!taskId) return 'Error: "task_id" is required for collect';
+
+  const task = deps.taskManager.getTask(taskId);
+  if (!task) return `Error: Task "${taskId}" not found`;
+
+  if (task.status === 'running') {
+    const elapsed = Math.round((Date.now() - task.startedAt) / 1000);
+    return JSON.stringify({
+      task_id: task.id,
+      status: 'running',
+      agent_name: task.agentName,
+      elapsed_seconds: elapsed,
+      message: 'Task is still running. Check back later.',
+    });
+  }
+
+  const result = task.result!;
+  const toolsList = result.toolsUsed.length > 0
+    ? result.toolsUsed.join(', ')
+    : 'none';
+
+  return JSON.stringify({
+    task_id: task.id,
+    status: task.status,
+    agent_name: task.agentName,
+    success: result.success,
+    response: result.response,
+    tools_used: toolsList,
+    tokens_used: result.tokensUsed.input + result.tokensUsed.output,
+    elapsed_seconds: Math.round(((task.completedAt ?? Date.now()) - task.startedAt) / 1000),
+  });
+}
+
+function handleList(deps: AgentToolDeps): string {
+  const allAgents = deps.orchestrator.getAllAgents();
+  const primary = deps.orchestrator.getPrimary();
+
+  // Filter to sub-agents only (not the primary)
+  const subAgents = allAgents.filter(a => a.id !== primary?.id);
+
+  const agents = subAgents.map(a => ({
+    agent_id: a.id,
+    name: a.agent.role.name,
+    specialist: a.agent.role.id,
+    status: a.agent.status,
+    current_task: a.agent.current_task,
+    busy: deps.taskManager.isAgentBusy(a.id),
+  }));
+
+  const tasks = deps.taskManager.listTasks().map(t => ({
+    task_id: t.id,
+    agent_name: t.agentName,
+    status: t.status,
+    task: t.task.slice(0, 100),
+    elapsed_seconds: Math.round(((t.completedAt ?? Date.now()) - t.startedAt) / 1000),
+  }));
+
+  return JSON.stringify({
+    active_agents: agents.length,
+    agents,
+    tasks_total: tasks.length,
+    tasks_running: tasks.filter(t => t.status === 'running').length,
+    tasks,
+  });
+}
+
+function handleTerminate(deps: AgentToolDeps, params: Record<string, unknown>): string {
+  const agentId = params.agent_id as string;
+  if (!agentId) return 'Error: "agent_id" is required for terminate';
+
+  const agent = deps.orchestrator.getAgent(agentId);
+  if (!agent) return `Error: Agent "${agentId}" not found`;
+
+  const name = agent.agent.role.name;
+
+  // Clean up registry
+  agentRegistries.delete(agentId);
+
+  // Terminate via orchestrator (cascades to children)
+  deps.orchestrator.terminateAgent(agentId);
+
+  console.log(`[ManageAgents] Terminated ${name} (${agentId})`);
+
+  return JSON.stringify({
+    terminated: agentId,
+    name,
+    message: `${name} terminated.`,
+  });
+}