@starlink-awaken/agentmesh 1.0.2 → 1.0.3

package/dist/cli.js

@@ -0,0 +1,246 @@
+#!/usr/bin/env bun
+const BASE_URL = process.env.AGENT_GATEWAY_URL || 'http://localhost:3000';
+async function request(path, options) {
+    const response = await fetch(`${BASE_URL}${path}`, {
+        ...options,
+        headers: {
+            'Content-Type': 'application/json',
+            ...options?.headers
+        }
+    });
+    if (!response.ok) {
+        const error = await response.json().catch(() => ({ message: 'Unknown error' }));
+        throw new Error(`HTTP ${response.status}: ${JSON.stringify(error)}`);
+    }
+    return response.json();
+}
+// 命令
+const commands = {
+    // 列出所有 Agent
+    async listAgents() {
+        const agents = await request('/agents');
+        console.log('\n📋 可用 Agent:\n');
+        agents.forEach(agent => {
+            console.log(`  ${agent.id.padEnd(15)} ${agent.name.padEnd(20)} [${agent.status}]`);
+            console.log(`    能力: ${agent.capabilities.join(', ')}\n`);
+        });
+    },
+    // 提交任务
+    async submitTask(args) {
+        const task = args.join(' ');
+        if (!task) {
+            console.error('❌ 请提供任务描述');
+            process.exit(1);
+        }
+        console.log(`\n📤 提交任务: ${task}\n`);
+        const message = {
+            type: 'request',
+            source: 'cli',
+            target: 'gateway',
+            payload: {
+                task,
+                options: {
+                    stream: false,
+                    timeout: 300
+                }
+            }
+        };
+        const result = await request('/tasks', {
+            method: 'POST',
+            body: JSON.stringify(message)
+        });
+        console.log(`✅ 任务已提交: ${result.task_id}`);
+        console.log(`   状态: ${result.status}\n`);
+        // 轮询获取结果
+        console.log('Waiting for result...\n');
+        let completed = false;
+        let attempts = 0;
+        const maxAttempts = 60;
+        while (!completed && attempts < maxAttempts) {
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            const taskResult = await request(`/tasks/${result.task_id}`);
+            if (taskResult.status === 'completed') {
+                completed = true;
+                console.log('✅ 任务完成!\n');
+                console.log('📊 结果:');
+                if (typeof taskResult.result === 'object') {
+                    Object.entries(taskResult.result).forEach(([agent, res]) => {
+                        console.log(`\n--- ${agent} ---`);
+                        console.log(res);
+                    });
+                }
+                else {
+                    console.log(taskResult.result);
+                }
+            }
+            else if (taskResult.status === 'failed') {
+                completed = true;
+                console.log('❌ 任务失败!');
+                console.log('错误:', taskResult.error);
+            }
+            else {
+                attempts++;
+                process.stdout.write('.');
+            }
+        }
+        if (!completed) {
+            console.log('\n⚠️ 任务超时\n');
+        }
+    },
+    // 提交到指定 Agent
+    async submitToAgent(agentId, args) {
+        const task = args.join(' ');
+        if (!task) {
+            console.error('❌ 请提供任务描述');
+            process.exit(1);
+        }
+        console.log(`\n📤 提交任务到 ${agentId}: ${task}\n`);
+        const message = {
+            type: 'request',
+            source: 'cli',
+            target: agentId,
+            payload: {
+                task,
+                options: {
+                    stream: false,
+                    timeout: 300
+                }
+            }
+        };
+        const result = await request('/tasks', {
+            method: 'POST',
+            body: JSON.stringify(message)
+        });
+        console.log(`✅ 任务已提交: ${result.task_id}`);
+        console.log(`   状态: ${result.status}\n`);
+        // 轮询获取结果
+        console.log('⏳ 等待执行结果...\n');
+        let completed = false;
+        let attempts = 0;
+        const maxAttempts = 60;
+        while (!completed && attempts < maxAttempts) {
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            const taskResult = await request(`/tasks/${result.task_id}`);
+            if (taskResult.status === 'completed') {
+                completed = true;
+                console.log('\n✅ 任务完成!\n');
+                console.log('📊 结果:');
+                console.log(taskResult.result);
+            }
+            else if (taskResult.status === 'failed') {
+                completed = true;
+                console.log('\n❌ 任务失败!');
+                console.log('错误:', taskResult.error);
+            }
+            else {
+                attempts++;
+                process.stdout.write('.');
+            }
+        }
+        if (!completed) {
+            console.log('\n⚠️ 任务超时\n');
+        }
+    },
+    // 创建共享空间
+    async createSpace() {
+        const result = await request('/spaces', {
+            method: 'POST',
+            body: JSON.stringify({ metadata: { createdBy: 'cli' } })
+        });
+        console.log(`\n✅ 共享空间已创建: ${result.space_id}\n`);
+        return result.space_id;
+    },
+    // 列出任务
+    async listTasks() {
+        const tasks = await request('/tasks');
+        console.log('\n📋 任务列表:\n');
+        if (tasks.length === 0) {
+            console.log('  (无任务)\n');
+            return;
+        }
+        tasks.forEach(task => {
+            console.log(`  ${task.id?.slice(0, 8) || 'unknown'}...  ${task.status?.padEnd(10) || 'unknown'} ${new Date(task.created_at).toLocaleString()}`);
+        });
+        console.log('');
+    },
+    // 健康检查
+    async health() {
+        const result = await request('/health');
+        console.log('\n🔍 Gateway 状态:\n');
+        console.log(`  状态: ${result.status}`);
+        console.log(`  Agent 数量: ${result.agents?.length || 0}`);
+        console.log(`  时间: ${new Date(result.timestamp).toLocaleString()}\n`);
+    }
+};
+// 主入口
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.length === 0) {
+        console.log(`
+🤖 Agent Gateway CLI
+
+用法:
+  agent-gateway <command> [options]
+
+命令:
+  agents, list              列出所有可用 Agent
+  task <description>        提交通用任务（自动路由）
+  to <agent> <task>        提交任务到指定 Agent
+  space, create-space       创建共享空间
+  tasks, list-tasks         列出所有任务
+  health, status            检查 Gateway 状态
+
+示例:
+  agent-gateway agents
+  agent-gateway task 帮我写一个排序算法
+  agent-gateway to claude-code 帮我review这段代码
+  agent-gateway health
+`);
+        process.exit(0);
+    }
+    const command = args[0];
+    const commandArgs = args.slice(1);
+    try {
+        switch (command) {
+            case 'agents':
+            case 'list':
+            case 'ls':
+                await commands.listAgents();
+                break;
+            case 'task':
+                await commands.submitTask(commandArgs);
+                break;
+            case 'to':
+                if (commandArgs.length < 2) {
+                    console.error('用法: agent-gateway to <agent> <task>');
+                    process.exit(1);
+                }
+                const agentId = commandArgs[0];
+                if (agentId) {
+                    await commands.submitToAgent(agentId, commandArgs.slice(1));
+                }
+                break;
+            case 'space':
+            case 'create-space':
+                await commands.createSpace();
+                break;
+            case 'tasks':
+            case 'list-tasks':
+                await commands.listTasks();
+                break;
+            case 'health':
+            case 'status':
+                await commands.health();
+                break;
+            default:
+                console.error(`❌ 未知命令: ${command}`);
+                console.log('运行 agent-gateway 查看帮助');
+                process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error(`\n❌ 错误: ${error.message}\n`);
+        process.exit(1);
+    }
+}
+main();

package/dist/core/agent-registry.d.ts

@@ -0,0 +1,48 @@
+import type { AgentAdapter } from '../adapters/base.js';
+import type { Agent } from '../types/index.js';
+export declare class AgentRegistry {
+    private adapters;
+    private initialized;
+    constructor();
+    /**
+     * 初始化注册表
+     */
+    initialize(): void;
+    /**
+     * 从配置注册所有 Agent
+     */
+    private registerAllFromConfig;
+    /**
+     * 注册自定义适配器
+     */
+    register(adapter: AgentAdapter): void;
+    /**
+     * 获取适配器
+     */
+    get(agentId: string): AgentAdapter | undefined;
+    /**
+     * 获取所有适配器
+     */
+    getAll(): AgentAdapter[];
+    /**
+     * 获取所有 Agent 信息
+     */
+    getAgents(): Agent[];
+    /**
+     * 根据能力查找 Agent
+     */
+    findByCapability(capability: string): Agent[];
+    /**
+     * 检查适配器是否存在
+     */
+    has(agentId: string): boolean;
+    /**
+     * 检查适配器是否健康
+     */
+    checkHealth(agentId: string): Promise<boolean>;
+    /**
+     * 获取可用 Agent 列表（健康检查）
+     */
+    getAvailableAgents(): Promise<Agent[]>;
+}
+export declare const agentRegistry: AgentRegistry;

package/dist/core/agent-registry.js

@@ -0,0 +1,295 @@
+import { ProcessAdapter } from '../adapters/process.js';
+import { ClaudeCodeAdapter } from '../adapters/claude-code.js';
+import { OpenClawAdapter } from '../adapters/openclaw.js';
+import { getAllAgentConfigs } from './config.js';
+// 默认 Agent 配置
+const DEFAULT_AGENT_CONFIGS = {
+    'claude-code': {
+        name: 'Claude Code',
+        capabilities: ['code-generation', 'code-review', 'debugging', 'refactoring', 'documentation', 'file-operations'],
+        command: 'claude',
+        args: ['-p']
+    },
+    'openclaw': {
+        name: 'OpenClaw',
+        capabilities: ['browser-automation', 'web-scraping', 'form-filling', 'ui-testing'],
+        command: 'openclaw',
+        args: ['--task']
+    },
+    'opencode': {
+        name: 'OpenCode',
+        capabilities: ['code-completion', 'code-generation', 'refactoring', 'debugging'],
+        command: 'opencode',
+        args: ['--task']
+    },
+    'gemini': {
+        name: 'Google Gemini CLI',
+        capabilities: ['code-generation', 'multimodal', 'reasoning', 'analysis'],
+        command: 'gemini',
+        args: ['--prompt']
+    },
+    'codex': {
+        name: 'OpenAI Codex',
+        capabilities: ['code-generation', 'code-explanation', 'refactoring'],
+        command: 'codex',
+        args: ['complete']
+    },
+    'github-copilot': {
+        name: 'GitHub Copilot',
+        capabilities: ['code-completion', 'code-suggestions', 'refactoring'],
+        command: 'copilot',
+        args: ['--ask']
+    },
+    'qwen-code': {
+        name: 'Qwen Code',
+        capabilities: ['code-generation', 'code-review', 'multilingual'],
+        command: 'qwen-code',
+        args: ['--task']
+    },
+    'crush': {
+        name: 'CRUSH AI',
+        capabilities: ['code-generation', 'debugging', 'security-analysis'],
+        command: 'crush',
+        args: ['run']
+    },
+    'droid': {
+        name: 'Droid Agent',
+        capabilities: ['android-development', 'mobile-debugging', 'device-control'],
+        command: 'droid',
+        args: ['--task']
+    },
+    'factory': {
+        name: 'Factory AI',
+        capabilities: ['code-generation', 'testing', 'documentation', 'refactoring'],
+        command: 'factory',
+        args: ['--task']
+    },
+    'cursor': {
+        name: 'Cursor',
+        capabilities: ['code-completion', 'code-generation', 'refactoring', 'chat'],
+        command: 'cursor',
+        args: ['--task']
+    },
+    'windsurf': {
+        name: 'Windsurf',
+        capabilities: ['code-generation', 'agentic-coding', 'flow-state'],
+        command: 'windsurf',
+        args: ['--task']
+    },
+    'zed': {
+        name: 'Zed AI',
+        capabilities: ['code-generation', 'collaboration', 'high-performance'],
+        command: 'zed',
+        args: ['--ai-task']
+    },
+    'aider': {
+        name: 'Aider',
+        capabilities: ['git-based-editing', 'code-refactoring', 'multi-file-changes'],
+        command: 'aider',
+        args: ['--message']
+    },
+    'cline': {
+        name: 'Cline',
+        capabilities: ['autonomous-coding', 'file-operations', 'command-execution'],
+        command: 'cline',
+        args: ['--task']
+    },
+    'roo-code': {
+        name: 'Roo Code',
+        capabilities: ['code-generation', 'agentic-mode', 'workspace-awareness'],
+        command: 'roo-code',
+        args: ['--task']
+    },
+    // 2026 新增 Agent
+    'perplexity': {
+        name: 'Perplexity',
+        capabilities: ['research', 'web-search', 'fact-checking', 'analysis'],
+        command: 'perplexity',
+        args: ['--query']
+    },
+    'grok': {
+        name: 'xAI Grok',
+        capabilities: ['reasoning', 'humor', 'code-generation', 'analysis'],
+        command: 'grok',
+        args: ['--prompt']
+    },
+    'phind': {
+        name: 'Phind',
+        capabilities: ['developer-search', 'code-search', 'documentation-search'],
+        command: 'phind',
+        args: ['--search']
+    },
+    'you': {
+        name: 'You.com AI',
+        capabilities: ['web-search', 'code-search', 'general-assistant'],
+        command: 'you',
+        args: ['--query']
+    },
+    'lepton': {
+        name: 'Lepton AI',
+        capabilities: ['code-generation', 'conversation', 'analysis'],
+        command: 'lepton',
+        args: ['--prompt']
+    },
+    'ollama': {
+        name: 'Ollama',
+        capabilities: ['local-llm', 'code-generation', 'privacy-focused'],
+        command: 'ollama',
+        args: ['run']
+    },
+    'llama': {
+        name: 'Meta Llama',
+        capabilities: ['code-generation', 'reasoning', 'open-source'],
+        command: 'llama',
+        args: ['--prompt']
+    },
+    'mistral': {
+        name: 'Mistral AI',
+        capabilities: ['code-generation', 'reasoning', 'multilingual'],
+        command: 'mistral',
+        args: ['--task']
+    },
+    'anthropic': {
+        name: 'Anthropic CLI',
+        capabilities: ['conversation', 'reasoning', 'code-generation'],
+        command: 'anthropic',
+        args: ['--prompt']
+    }
+};
+export class AgentRegistry {
+    adapters = new Map();
+    initialized = false;
+    constructor() {
+        // 延迟初始化
+    }
+    /**
+     * 初始化注册表
+     */
+    initialize() {
+        if (this.initialized)
+            return;
+        // 注册内置适配器
+        this.register(new ClaudeCodeAdapter());
+        this.register(new OpenClawAdapter());
+        // 从配置加载所有 Agent
+        this.registerAllFromConfig();
+        this.initialized = true;
+    }
+    /**
+     * 从配置注册所有 Agent
+     */
+    registerAllFromConfig() {
+        const configAgents = getAllAgentConfigs();
+        // 1. 先注册配置文件中的 Agent
+        for (const config of configAgents) {
+            if (this.adapters.has(config.id))
+                continue;
+            if (config.type === 'claude-code' || config.type === 'openclaw') {
+                // 跳过，内置适配器已注册
+                continue;
+            }
+            if (config.type === 'process' && config.command) {
+                const adapter = new ProcessAdapter(config.id, config.name, config.capabilities, {
+                    command: config.command,
+                    args: config.args,
+                    env: config.env
+                });
+                this.adapters.set(config.id, adapter);
+                console.log(`[AgentRegistry] Registered from config: ${config.id}`);
+            }
+        }
+        // 2. 再注册默认 Agent（未被配置覆盖的）
+        for (const [id, defaultConfig] of Object.entries(DEFAULT_AGENT_CONFIGS)) {
+            if (this.adapters.has(id))
+                continue;
+            const adapter = new ProcessAdapter(id, defaultConfig.name, defaultConfig.capabilities, {
+                command: defaultConfig.command,
+                args: defaultConfig.args,
+                env: defaultConfig.env
+            });
+            this.adapters.set(id, adapter);
+            console.log(`[AgentRegistry] Registered default: ${id}`);
+        }
+    }
+    /**
+     * 注册自定义适配器
+     */
+    register(adapter) {
+        this.adapters.set(adapter.id, adapter);
+        console.log(`[AgentRegistry] Registered adapter: ${adapter.id}`);
+    }
+    /**
+     * 获取适配器
+     */
+    get(agentId) {
+        return this.adapters.get(agentId);
+    }
+    /**
+     * 获取所有适配器
+     */
+    getAll() {
+        return Array.from(this.adapters.values());
+    }
+    /**
+     * 获取所有 Agent 信息
+     */
+    getAgents() {
+        return this.getAll().map(adapter => ({
+            id: adapter.id,
+            name: adapter.name,
+            type: adapter.type,
+            capabilities: adapter.capabilities,
+            status: 'online',
+            lastSeen: Date.now()
+        }));
+    }
+    /**
+     * 根据能力查找 Agent
+     */
+    findByCapability(capability) {
+        return this.getAll()
+            .filter(adapter => adapter.capabilities.includes(capability))
+            .map(adapter => ({
+            id: adapter.id,
+            name: adapter.name,
+            type: adapter.type,
+            capabilities: adapter.capabilities,
+            status: 'online',
+            lastSeen: Date.now()
+        }));
+    }
+    /**
+     * 检查适配器是否存在
+     */
+    has(agentId) {
+        return this.adapters.has(agentId);
+    }
+    /**
+     * 检查适配器是否健康
+     */
+    async checkHealth(agentId) {
+        const adapter = this.adapters.get(agentId);
+        if (!adapter)
+            return false;
+        return adapter.health();
+    }
+    /**
+     * 获取可用 Agent 列表（健康检查）
+     */
+    async getAvailableAgents() {
+        const results = [];
+        for (const adapter of this.adapters.values()) {
+            const isHealthy = await adapter.health().catch(() => false);
+            results.push({
+                id: adapter.id,
+                name: adapter.name,
+                type: adapter.type,
+                capabilities: adapter.capabilities,
+                status: isHealthy ? 'online' : 'offline',
+                lastSeen: Date.now()
+            });
+        }
+        return results;
+    }
+}
+export const agentRegistry = new AgentRegistry();

package/dist/core/config.d.ts

@@ -0,0 +1,59 @@
+export interface AgentConfig {
+    id: string;
+    name: string;
+    type: 'claude-code' | 'openclaw' | 'process' | 'http';
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    endpoint?: string;
+    capabilities: string[];
+}
+export interface RoutingRule {
+    name: string;
+    keywords: string[];
+    agent?: string;
+    strategy?: 'direct' | 'broadcast';
+    agents?: string[];
+    priority: number;
+}
+export interface GatewayConfig {
+    port: number;
+    wsPort: number;
+    host: string;
+    dataDir: string;
+    logDir: string;
+    logLevel: 'debug' | 'info' | 'warn' | 'error';
+    routing: {
+        defaultAgent?: string;
+        rules: RoutingRule[];
+    };
+    agents: AgentConfig[];
+}
+/**
+ * 加载配置文件
+ */
+export declare function loadConfig(configPath?: string): GatewayConfig;
+/**
+ * 重新加载配置
+ */
+export declare function reloadConfig(configPath?: string): GatewayConfig;
+/**
+ * 获取配置
+ */
+export declare function getConfig(): GatewayConfig;
+/**
+ * 获取 Agent 配置
+ */
+export declare function getAgentConfig(agentId: string): AgentConfig | undefined;
+/**
+ * 获取所有 Agent 配置
+ */
+export declare function getAllAgentConfigs(): AgentConfig[];
+/**
+ * 获取路由规则
+ */
+export declare function getRoutingRules(): RoutingRule[];
+/**
+ * 获取默认 Agent
+ */
+export declare function getDefaultAgent(): string | undefined;