@starlink-awaken/agentmesh 1.0.2 → 1.0.3

package/dist/adapters/base.d.ts

@@ -0,0 +1,22 @@
+import type { AgentMessage } from '../types/index.js';
+export interface AgentAdapter {
+    id: string;
+    name: string;
+    type: string;
+    capabilities: string[];
+    invoke(request: AgentMessage): Promise<AgentMessage>;
+    invokeStream?(request: AgentMessage): AsyncGenerator<AgentMessage, void, unknown>;
+    health(): Promise<boolean>;
+}
+/**
+ * Agent 适配器基类
+ */
+export declare abstract class BaseAgentAdapter implements AgentAdapter {
+    abstract id: string;
+    abstract name: string;
+    abstract type: string;
+    abstract capabilities: string[];
+    abstract invoke(request: AgentMessage): Promise<AgentMessage>;
+    invokeStream?(request: AgentMessage): AsyncGenerator<AgentMessage, void, unknown>;
+    abstract health(): Promise<boolean>;
+}

package/dist/adapters/base.js

@@ -0,0 +1,10 @@
+/**
+ * Agent 适配器基类
+ */
+export class BaseAgentAdapter {
+    async *invokeStream(request) {
+        // 默认实现：调用 invoke 并转换为流
+        const response = await this.invoke(request);
+        yield response;
+    }
+}

package/dist/adapters/claude-code.d.ts

@@ -0,0 +1,22 @@
+import { BaseAgentAdapter } from './base.js';
+import type { AgentMessage } from '../types/index.js';
+export declare class ClaudeCodeAdapter extends BaseAgentAdapter {
+    id: string;
+    name: string;
+    type: string;
+    capabilities: string[];
+    private readonly cliPath;
+    constructor(cliPath?: string);
+    /**
+     * 调用 Claude Code 执行任务
+     */
+    invoke(request: AgentMessage): Promise<AgentMessage>;
+    /**
+     * 流式调用
+     */
+    invokeStream(request: AgentMessage): AsyncGenerator<AgentMessage, void, unknown>;
+    /**
+     * 健康检查
+     */
+    health(): Promise<boolean>;
+}

package/dist/adapters/claude-code.js

@@ -0,0 +1,112 @@
+import { execa } from 'execa';
+import { v4 as uuidv4 } from 'uuid';
+import { BaseAgentAdapter } from './base.js';
+export class ClaudeCodeAdapter extends BaseAgentAdapter {
+    id = 'claude-code';
+    name = 'Claude Code';
+    type = 'claude-code';
+    capabilities = [
+        'code-generation',
+        'code-review',
+        'debugging',
+        'refactoring',
+        'documentation',
+        'file-operations'
+    ];
+    cliPath;
+    constructor(cliPath = 'claude') {
+        super();
+        this.cliPath = cliPath;
+    }
+    /**
+     * 调用 Claude Code 执行任务
+     */
+    async invoke(request) {
+        const task = request.payload?.task || '';
+        const correlationId = request.correlation_id || uuidv4();
+        try {
+            // Claude Code 的 -p 模式需要从 stdin 输入
+            const result = await execa(this.cliPath, ['-p'], {
+                input: task,
+                timeout: (request.payload?.options?.timeout || 300) * 1000,
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+            return {
+                id: uuidv4(),
+                type: 'response',
+                source: this.id,
+                target: request.source,
+                correlation_id: correlationId,
+                timestamp: Date.now(),
+                result: result.stdout
+            };
+        }
+        catch (error) {
+            return {
+                id: uuidv4(),
+                type: 'response',
+                source: this.id,
+                target: request.source,
+                correlation_id: correlationId,
+                timestamp: Date.now(),
+                error: {
+                    code: 'EXECUTION_ERROR',
+                    message: error.message || String(error)
+                }
+            };
+        }
+    }
+    /**
+     * 流式调用
+     */
+    async *invokeStream(request) {
+        const task = request.payload?.task || '';
+        const correlationId = request.correlation_id || uuidv4();
+        try {
+            const process = execa(this.cliPath, ['-p', task], {
+                timeout: (request.payload?.options?.timeout || 300) * 1000,
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+            // 监听 stdout 流
+            process.stdout?.on('data', (_chunk) => {
+                // 这里可以发送流式消息
+            });
+            const result = await process;
+            yield {
+                id: uuidv4(),
+                type: 'stream_end',
+                source: this.id,
+                target: request.source,
+                correlation_id: correlationId,
+                timestamp: Date.now(),
+                result: result.stdout
+            };
+        }
+        catch (error) {
+            yield {
+                id: uuidv4(),
+                type: 'response',
+                source: this.id,
+                target: request.source,
+                correlation_id: correlationId,
+                timestamp: Date.now(),
+                error: {
+                    code: 'EXECUTION_ERROR',
+                    message: error.message || String(error)
+                }
+            };
+        }
+    }
+    /**
+     * 健康检查
+     */
+    async health() {
+        try {
+            await execa(this.cliPath, ['--version'], { timeout: 5000 });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/adapters/openclaw.d.ts

@@ -0,0 +1,22 @@
+import { BaseAgentAdapter } from './base.js';
+import type { AgentMessage } from '../types/index.js';
+export declare class OpenClawAdapter extends BaseAgentAdapter {
+    id: string;
+    name: string;
+    type: string;
+    capabilities: string[];
+    private readonly cliPath;
+    constructor(cliPath?: string);
+    /**
+     * 调用 OpenClaw 执行任务
+     */
+    invoke(request: AgentMessage): Promise<AgentMessage>;
+    /**
+     * 流式调用
+     */
+    invokeStream(request: AgentMessage): AsyncGenerator<AgentMessage, void, unknown>;
+    /**
+     * 健康检查
+     */
+    health(): Promise<boolean>;
+}

package/dist/adapters/openclaw.js

@@ -0,0 +1,110 @@
+import { execa } from 'execa';
+import { v4 as uuidv4 } from 'uuid';
+import { BaseAgentAdapter } from './base.js';
+export class OpenClawAdapter extends BaseAgentAdapter {
+    id = 'openclaw';
+    name = 'OpenClaw';
+    type = 'openclaw';
+    capabilities = [
+        'browser-automation',
+        'web-scraping',
+        'form-filling',
+        'ui-testing'
+    ];
+    cliPath;
+    constructor(cliPath = 'openclaw') {
+        super();
+        this.cliPath = cliPath;
+    }
+    /**
+     * 调用 OpenClaw 执行任务
+     */
+    async invoke(request) {
+        const task = request.payload?.task || '';
+        const correlationId = request.correlation_id || uuidv4();
+        try {
+            // OpenClaw CLI 调用方式（假设使用 --task 或类似参数）
+            const result = await execa(this.cliPath, ['--task', task], {
+                timeout: (request.payload?.options?.timeout || 300) * 1000,
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+            return {
+                id: uuidv4(),
+                type: 'response',
+                source: this.id,
+                target: request.source,
+                correlation_id: correlationId,
+                timestamp: Date.now(),
+                result: result.stdout
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                id: uuidv4(),
+                type: 'response',
+                source: this.id,
+                target: request.source,
+                correlation_id: correlationId,
+                timestamp: Date.now(),
+                error: {
+                    code: 'EXECUTION_ERROR',
+                    message: errorMessage
+                }
+            };
+        }
+    }
+    /**
+     * 流式调用
+     */
+    async *invokeStream(request) {
+        const task = request.payload?.task || '';
+        const correlationId = request.correlation_id || uuidv4();
+        try {
+            const process = execa(this.cliPath, ['--task', task], {
+                timeout: (request.payload?.options?.timeout || 300) * 1000,
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+            process.stdout?.on('data', (_chunk) => {
+                // 可以发送流式消息
+            });
+            const result = await process;
+            yield {
+                id: uuidv4(),
+                type: 'stream_end',
+                source: this.id,
+                target: request.source,
+                correlation_id: correlationId,
+                timestamp: Date.now(),
+                result: result.stdout
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            yield {
+                id: uuidv4(),
+                type: 'response',
+                source: this.id,
+                target: request.source,
+                correlation_id: correlationId,
+                timestamp: Date.now(),
+                error: {
+                    code: 'EXECUTION_ERROR',
+                    message: errorMessage
+                }
+            };
+        }
+    }
+    /**
+     * 健康检查
+     */
+    async health() {
+        try {
+            await execa(this.cliPath, ['--version'], { timeout: 5000 });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/adapters/process.d.ts

@@ -0,0 +1,28 @@
+import { BaseAgentAdapter } from './base.js';
+import type { AgentMessage } from '../types/index.js';
+interface ProcessConfig {
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+}
+export declare class ProcessAdapter extends BaseAgentAdapter {
+    id: string;
+    name: string;
+    type: string;
+    capabilities: string[];
+    private config;
+    constructor(id: string, name: string, capabilities: string[], config: ProcessConfig);
+    /**
+     * 调用进程执行任务
+     */
+    invoke(request: AgentMessage): Promise<AgentMessage>;
+    /**
+     * 流式调用
+     */
+    invokeStream(request: AgentMessage): AsyncGenerator<AgentMessage, void, unknown>;
+    /**
+     * 健康检查
+     */
+    health(): Promise<boolean>;
+}
+export {};

package/dist/adapters/process.js

@@ -0,0 +1,121 @@
+import { execa } from 'execa';
+import { v4 as uuidv4 } from 'uuid';
+import { BaseAgentAdapter } from './base.js';
+export class ProcessAdapter extends BaseAgentAdapter {
+    id;
+    name;
+    type = 'process';
+    capabilities;
+    config;
+    constructor(id, name, capabilities, config) {
+        super();
+        this.id = id;
+        this.name = name;
+        this.capabilities = capabilities;
+        this.config = config;
+    }
+    /**
+     * 调用进程执行任务
+     */
+    async invoke(request) {
+        const task = request.payload?.task || '';
+        const correlationId = request.correlation_id || uuidv4();
+        const timeout = (request.payload?.options?.timeout || 300) * 1000;
+        try {
+            // 构建参数：将任务作为 stdin 或参数传入
+            const args = this.config.args || [];
+            const result = await execa(this.config.command, [...args, task], {
+                timeout,
+                stdio: ['pipe', 'pipe', 'pipe'],
+                env: { ...process.env, ...this.config.env }
+            });
+            return {
+                id: uuidv4(),
+                type: 'response',
+                source: this.id,
+                target: request.source,
+                correlation_id: correlationId,
+                timestamp: Date.now(),
+                result: result.stdout
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                id: uuidv4(),
+                type: 'response',
+                source: this.id,
+                target: request.source,
+                correlation_id: correlationId,
+                timestamp: Date.now(),
+                error: {
+                    code: 'EXECUTION_ERROR',
+                    message: errorMessage
+                }
+            };
+        }
+    }
+    /**
+     * 流式调用
+     */
+    async *invokeStream(request) {
+        const task = request.payload?.task || '';
+        const correlationId = request.correlation_id || uuidv4();
+        const timeout = (request.payload?.options?.timeout || 300) * 1000;
+        try {
+            const args = this.config.args || [];
+            const proc = execa(this.config.command, [...args, task], {
+                timeout,
+                stdio: ['pipe', 'pipe', 'pipe'],
+                env: { ...globalThis.process.env, ...this.config.env }
+            });
+            proc.stdout?.on('data', (_chunk) => {
+                // 可以发送流式消息
+            });
+            const result = await proc;
+            yield {
+                id: uuidv4(),
+                type: 'stream_end',
+                source: this.id,
+                target: request.source,
+                correlation_id: correlationId,
+                timestamp: Date.now(),
+                result: result.stdout
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            yield {
+                id: uuidv4(),
+                type: 'response',
+                source: this.id,
+                target: request.source,
+                correlation_id: correlationId,
+                timestamp: Date.now(),
+                error: {
+                    code: 'EXECUTION_ERROR',
+                    message: errorMessage
+                }
+            };
+        }
+    }
+    /**
+     * 健康检查
+     */
+    async health() {
+        try {
+            await execa(this.config.command, ['--version'], { timeout: 5000 });
+            return true;
+        }
+        catch {
+            // 尝试其他版本检查方式
+            try {
+                await execa(this.config.command, ['-v'], { timeout: 5000 });
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+    }
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};