@agentclub/openclaw-adapter 0.1.2

package/dist/openclaw-client.js

@@ -0,0 +1,412 @@
+import { createHash, randomUUID } from 'node:crypto';
+function normalizeAgentId(value) {
+    const normalized = value.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, '-');
+    return normalized || 'main';
+}
+function buildThreadSlug(threadId) {
+    const normalized = threadId.trim().toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+    return normalized.slice(0, 48) || 'thread';
+}
+function buildThreadHash(threadId) {
+    return createHash('sha256').update(threadId).digest('hex').slice(0, 16);
+}
+function buildSessionKey(config, threadId) {
+    return config.openClaw.sessionKeyTemplate
+        .replaceAll('{agentId}', normalizeAgentId(config.openClaw.agentId))
+        .replaceAll('{threadId}', encodeURIComponent(threadId))
+        .replaceAll('{threadSlug}', buildThreadSlug(threadId))
+        .replaceAll('{threadHash}', buildThreadHash(threadId));
+}
+function extractTextFromMessage(message) {
+    if (!message || typeof message !== 'object') {
+        return null;
+    }
+    const content = message.content;
+    if (!Array.isArray(content)) {
+        return null;
+    }
+    for (const item of content) {
+        if (!item || typeof item !== 'object') {
+            continue;
+        }
+        const block = item;
+        if (block.type === 'text' && typeof block.text === 'string' && block.text.trim()) {
+            return block.text.trim();
+        }
+    }
+    return null;
+}
+function findLatestAssistantMessageText(payload) {
+    if (!payload || typeof payload !== 'object') {
+        return null;
+    }
+    const messages = payload.messages;
+    if (!Array.isArray(messages)) {
+        return null;
+    }
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+        const item = messages[i];
+        if (!item || typeof item !== 'object') {
+            continue;
+        }
+        const role = item.role;
+        if (role !== 'assistant') {
+            continue;
+        }
+        const text = extractTextFromMessage(item);
+        if (text) {
+            return text;
+        }
+    }
+    return null;
+}
+function readWebSocketMessage(data) {
+    if (typeof data === 'string') {
+        return data;
+    }
+    if (data instanceof ArrayBuffer) {
+        return Buffer.from(data).toString('utf8');
+    }
+    if (ArrayBuffer.isView(data)) {
+        return Buffer.from(data.buffer, data.byteOffset, data.byteLength).toString('utf8');
+    }
+    return String(data);
+}
+function isGatewayEventFrame(value) {
+    return Boolean(value &&
+        typeof value === 'object' &&
+        value.type === 'event' &&
+        typeof value.event === 'string');
+}
+function isGatewayResponseFrame(value) {
+    return Boolean(value &&
+        typeof value === 'object' &&
+        value.type === 'res' &&
+        typeof value.id === 'string' &&
+        typeof value.ok === 'boolean');
+}
+class OpenClawGatewayClient {
+    config;
+    logger;
+    connectPromise = null;
+    connectReject = null;
+    connectResolve = null;
+    hello = null;
+    pendingRequests = new Map();
+    pendingRuns = new Map();
+    ws = null;
+    constructor(config, logger) {
+        this.config = config;
+        this.logger = logger;
+    }
+    getHello() {
+        return this.hello;
+    }
+    async ensureConnected(signal) {
+        if (this.isConnected()) {
+            return;
+        }
+        if (!this.connectPromise) {
+            this.connectPromise = new Promise((resolve, reject) => {
+                this.connectResolve = resolve;
+                this.connectReject = reject;
+            });
+            this.openSocket();
+        }
+        await this.withAbort(this.connectPromise, signal, 'gateway connect aborted');
+    }
+    async sendChat(params) {
+        await this.ensureConnected(params.signal);
+        const sessionKey = buildSessionKey(this.config, params.threadId);
+        const runId = randomUUID();
+        const replyPromise = new Promise((resolve, reject) => {
+            this.pendingRuns.set(runId, {
+                runId,
+                sessionKey,
+                resolve,
+                reject,
+                text: '',
+            });
+        });
+        const abortHandler = () => {
+            const pending = this.pendingRuns.get(runId);
+            if (!pending) {
+                return;
+            }
+            this.pendingRuns.delete(runId);
+            pending.reject(new Error('openclaw chat aborted'));
+            void this.request('chat.abort', { runId, sessionKey }).catch(() => undefined);
+        };
+        params.signal.addEventListener('abort', abortHandler, { once: true });
+        try {
+            await this.request('chat.send', {
+                deliver: false,
+                idempotencyKey: runId,
+                message: params.incomingMessage,
+                sessionKey,
+                thinking: this.config.openClaw.thinking || undefined,
+                timeoutMs: params.timeoutMs,
+            });
+            const reply = await this.withAbort(replyPromise, params.signal, 'openclaw chat aborted');
+            if (!reply.trim()) {
+                throw new Error('openclaw gateway produced empty reply');
+            }
+            return reply.trim();
+        }
+        catch (error) {
+            const pending = this.pendingRuns.get(runId);
+            if (pending) {
+                this.pendingRuns.delete(runId);
+                pending.reject(error instanceof Error ? error : new Error(String(error)));
+            }
+            throw error;
+        }
+        finally {
+            params.signal.removeEventListener('abort', abortHandler);
+        }
+    }
+    isConnected() {
+        return Boolean(this.ws && this.ws.readyState === WebSocket.OPEN && this.hello);
+    }
+    openSocket() {
+        this.ws = new WebSocket(this.config.openClaw.gatewayUrl);
+        this.ws.addEventListener('open', () => {
+            this.logger.info('[adapter] openclaw gateway socket opened');
+        });
+        this.ws.addEventListener('message', (event) => {
+            this.handleFrame(readWebSocketMessage(event.data)).catch((error) => {
+                this.logger.warn('[adapter] openclaw gateway frame error', {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            });
+        });
+        this.ws.addEventListener('close', (event) => {
+            const error = new Error(`openclaw gateway closed (${event.code}): ${event.reason || 'no reason'}`);
+            this.resetConnection(error);
+        });
+        this.ws.addEventListener('error', () => {
+            if (this.hello || !this.connectReject) {
+                return;
+            }
+            this.resetConnection(new Error('openclaw gateway connection error'));
+        });
+    }
+    async handleFrame(raw) {
+        const parsed = JSON.parse(raw);
+        if (isGatewayEventFrame(parsed)) {
+            await this.handleEventFrame(parsed);
+            return;
+        }
+        if (isGatewayResponseFrame(parsed)) {
+            this.handleResponseFrame(parsed);
+        }
+    }
+    async handleEventFrame(frame) {
+        if (frame.event === 'connect.challenge') {
+            const nonce = typeof frame.payload?.nonce === 'string' ? frame.payload.nonce.trim() : '';
+            if (!nonce) {
+                throw new Error('openclaw gateway connect challenge missing nonce');
+            }
+            await this.sendConnect(nonce);
+            return;
+        }
+        if (frame.event !== 'chat') {
+            return;
+        }
+        const payload = frame.payload;
+        if (!payload) {
+            return;
+        }
+        const runId = typeof payload?.runId === 'string' ? payload.runId : '';
+        if (!runId) {
+            return;
+        }
+        const pending = this.pendingRuns.get(runId);
+        if (!pending) {
+            return;
+        }
+        const state = typeof payload?.state === 'string' ? payload.state : '';
+        if (state === 'delta') {
+            const text = extractTextFromMessage(payload.message);
+            if (text) {
+                pending.text = text;
+            }
+            return;
+        }
+        if (state === 'final') {
+            const finalText = extractTextFromMessage(payload.message) ||
+                pending.text ||
+                (await this.loadLatestAssistantMessage(pending.sessionKey));
+            this.pendingRuns.delete(runId);
+            pending.resolve(finalText || '');
+            return;
+        }
+        if (state === 'error') {
+            this.pendingRuns.delete(runId);
+            pending.reject(new Error(typeof payload?.errorMessage === 'string' ? payload.errorMessage : 'openclaw chat failed'));
+            return;
+        }
+        if (state === 'aborted') {
+            this.pendingRuns.delete(runId);
+            pending.reject(new Error('openclaw chat aborted'));
+        }
+    }
+    handleResponseFrame(frame) {
+        const pending = this.pendingRequests.get(frame.id);
+        if (!pending) {
+            return;
+        }
+        const status = this.readPayloadStatus(frame.payload);
+        if (pending.expectAcceptedOnly && status === 'accepted') {
+            return;
+        }
+        this.pendingRequests.delete(frame.id);
+        if (frame.ok) {
+            pending.resolve(frame.payload);
+            return;
+        }
+        pending.reject(new Error(frame.error?.message || 'openclaw gateway request failed'));
+    }
+    async loadLatestAssistantMessage(sessionKey) {
+        try {
+            const payload = await this.request('chat.history', { limit: 12, sessionKey });
+            return findLatestAssistantMessageText(payload);
+        }
+        catch {
+            return null;
+        }
+    }
+    async sendConnect(_nonce) {
+        const hello = (await this.request('connect', {
+            auth: {
+                password: this.config.openClaw.gatewayPassword || undefined,
+                token: this.config.openClaw.gatewayToken || undefined,
+            },
+            caps: [],
+            client: {
+                displayName: 'Agent Hub Adapter',
+                id: 'gateway-client',
+                instanceId: randomUUID(),
+                mode: 'backend',
+                platform: process.platform,
+                version: '0.1.0',
+            },
+            locale: 'zh-CN',
+            maxProtocol: 3,
+            minProtocol: 3,
+            pathEnv: process.env.PATH,
+            role: 'operator',
+            scopes: ['operator.admin'],
+            userAgent: 'agenthub-openclaw-adapter',
+        }));
+        this.hello = hello;
+        this.logger.info('[adapter] openclaw gateway authorized', {
+            serverVersion: hello.server?.version ?? 'unknown',
+        });
+        this.connectResolve?.();
+        this.connectResolve = null;
+        this.connectReject = null;
+    }
+    request(method, params, options) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            throw new Error('openclaw gateway not connected');
+        }
+        const id = randomUUID();
+        const frame = {
+            id,
+            method,
+            params,
+            type: 'req',
+        };
+        const requestPromise = new Promise((resolve, reject) => {
+            this.pendingRequests.set(id, {
+                expectAcceptedOnly: options?.expectAcceptedOnly === true,
+                reject,
+                resolve,
+            });
+        });
+        this.ws.send(JSON.stringify(frame));
+        return requestPromise;
+    }
+    readPayloadStatus(payload) {
+        if (!payload || typeof payload !== 'object') {
+            return null;
+        }
+        return typeof payload.status === 'string'
+            ? (payload.status || null)
+            : null;
+    }
+    resetConnection(error) {
+        if (this.ws) {
+            this.ws = null;
+        }
+        this.hello = null;
+        this.connectReject?.(error);
+        this.connectReject = null;
+        this.connectResolve = null;
+        this.connectPromise = null;
+        for (const [id, pending] of this.pendingRequests.entries()) {
+            this.pendingRequests.delete(id);
+            pending.reject(error);
+        }
+        for (const [runId, pending] of this.pendingRuns.entries()) {
+            this.pendingRuns.delete(runId);
+            pending.reject(error);
+        }
+    }
+    withAbort(promise, signal, message) {
+        if (!signal) {
+            return promise;
+        }
+        if (signal.aborted) {
+            return Promise.reject(new Error(message));
+        }
+        return new Promise((resolve, reject) => {
+            const onAbort = () => {
+                reject(new Error(message));
+            };
+            signal.addEventListener('abort', onAbort, { once: true });
+            promise.then((value) => {
+                signal.removeEventListener('abort', onAbort);
+                resolve(value);
+            }, (error) => {
+                signal.removeEventListener('abort', onAbort);
+                reject(error);
+            });
+        });
+    }
+}
+export class OpenClawClient {
+    config;
+    logger;
+    gateway;
+    constructor(config, logger) {
+        this.config = config;
+        this.logger = logger;
+        this.gateway = new OpenClawGatewayClient(config, logger);
+    }
+    async connect(signal) {
+        await this.gateway.ensureConnected(signal);
+    }
+    getHello() {
+        return this.gateway.getHello();
+    }
+    async generateReply(params) {
+        const reply = await this.gateway.sendChat({
+            incomingMessage: params.incomingMessage,
+            signal: params.signal,
+            threadId: params.threadId,
+            timeoutMs: this.config.openClaw.timeoutMs,
+        });
+        return {
+            reply: `${this.config.adapter.replyPrefix}${reply}`,
+        };
+    }
+}
+export const __internal = {
+    buildSessionKey,
+    buildThreadHash,
+    buildThreadSlug,
+    extractTextFromMessage,
+    findLatestAssistantMessageText,
+};

package/dist/prompt.js

@@ -0,0 +1,80 @@
+import { stdin as input, stdout as output } from 'node:process';
+import { createInterface } from 'node:readline/promises';
+import { DEFAULT_OPENCLAW_GATEWAY_URL, buildDefaultConfigFromEnv } from './config.js';
+import { normalizeBaseUrl, normalizeGatewayUrl, parseNumber } from './utils.js';
+async function ask(rl, label, fallback) {
+    const value = await rl.question(`${label}${fallback ? ` [${fallback}]` : ''}: `);
+    return value.trim() || fallback;
+}
+async function askYesNo(rl, label, fallback) {
+    const hint = fallback ? 'Y/n' : 'y/N';
+    const value = (await rl.question(`${label} [${hint}]: `)).trim().toLowerCase();
+    if (!value) {
+        return fallback;
+    }
+    return ['y', 'yes', '1', 'true'].includes(value);
+}
+export async function promptConfigInteractive(options) {
+    const defaults = options?.defaults ?? buildDefaultConfigFromEnv();
+    const rl = createInterface({ input, output });
+    try {
+        output.write('\nAgent Hub OpenClaw Adapter 初始化\n');
+        if (options?.advanced) {
+            output.write('模式：高级模式\n\n');
+        }
+        else {
+            output.write('模式：Agent 模式（只询问最小必填项，其他使用推荐默认值）\n\n');
+        }
+        const agentHubBaseUrl = normalizeBaseUrl(await ask(rl, 'Agent Hub Base URL', defaults.agentHub.baseUrl));
+        const clientId = await ask(rl, 'Agent Hub clientId', defaults.agentHub.clientId);
+        const clientSecret = await ask(rl, 'Agent Hub clientSecret', defaults.agentHub.clientSecret);
+        const agentId = await ask(rl, 'OpenClaw agentId', defaults.openClaw.agentId);
+        const gatewayAuthEnabled = defaults.openClaw.gatewayToken !== '' || defaults.openClaw.gatewayPassword !== ''
+            ? true
+            : await askYesNo(rl, 'OpenClaw Gateway 是否启用鉴权', false);
+        const gatewayToken = await ask(rl, 'OpenClaw Gateway token（可留空）', defaults.openClaw.gatewayToken);
+        const gatewayPassword = await ask(rl, 'OpenClaw Gateway password（可留空）', defaults.openClaw.gatewayPassword);
+        let openClawGatewayUrl = defaults.openClaw.gatewayUrl;
+        let sessionKeyTemplate = defaults.openClaw.sessionKeyTemplate;
+        let thinking = defaults.openClaw.thinking;
+        let replyPrefix = defaults.adapter.replyPrefix;
+        if (options?.advanced) {
+            openClawGatewayUrl = normalizeGatewayUrl(await ask(rl, 'OpenClaw Gateway WebSocket URL', defaults.openClaw.gatewayUrl));
+            sessionKeyTemplate = await ask(rl, 'OpenClaw sessionKey template（支持 {agentId} / {threadSlug} / {threadHash} / {threadId}）', defaults.openClaw.sessionKeyTemplate);
+            thinking = await ask(rl, 'OpenClaw thinking level（可留空）', defaults.openClaw.thinking);
+            replyPrefix = await ask(rl, '自动回复前缀（可留空）', defaults.adapter.replyPrefix);
+        }
+        else {
+            output.write(`\n将使用默认 OpenClaw Gateway：${DEFAULT_OPENCLAW_GATEWAY_URL}\n` +
+                `如需自定义 Gateway 地址、session key 或 thinking，请使用 init --advanced\n\n`);
+        }
+        return {
+            version: 1,
+            agentHub: {
+                baseUrl: agentHubBaseUrl,
+                clientId,
+                clientSecret,
+            },
+            openClaw: {
+                gatewayUrl: normalizeGatewayUrl(openClawGatewayUrl),
+                gatewayToken: gatewayAuthEnabled ? gatewayToken : '',
+                gatewayPassword: gatewayAuthEnabled ? gatewayPassword : '',
+                agentId,
+                sessionKeyTemplate,
+                timeoutMs: defaults.openClaw.timeoutMs,
+                thinking,
+            },
+            adapter: {
+                replyPrefix,
+                requestTimeoutMs: parseNumber(undefined, defaults.adapter.requestTimeoutMs),
+                reconnectInitialDelayMs: parseNumber(undefined, defaults.adapter.reconnectInitialDelayMs),
+                reconnectMaxDelayMs: parseNumber(undefined, defaults.adapter.reconnectMaxDelayMs),
+                handledTtlMs: parseNumber(undefined, defaults.adapter.handledTtlMs),
+                handledLimit: parseNumber(undefined, defaults.adapter.handledLimit),
+            },
+        };
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils.js

@@ -0,0 +1,106 @@
+export function normalizeBaseUrl(value) {
+    return value.trim().replace(/\/+$/, '');
+}
+export function normalizeGatewayUrl(value) {
+    return value.trim().replace(/\/+$/, '');
+}
+export function parseNumber(value, fallback) {
+    if (!value) {
+        return fallback;
+    }
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        return fallback;
+    }
+    return Math.floor(parsed);
+}
+export function safeErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+export function buildUrl(baseUrl, path) {
+    const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+    return `${baseUrl}${normalizedPath}`;
+}
+export function parseSseDataFrames(chunkBuffer) {
+    const normalized = chunkBuffer.replace(/\r\n/g, '\n');
+    const frames = [];
+    let start = 0;
+    while (start < normalized.length) {
+        const split = normalized.indexOf('\n\n', start);
+        if (split === -1) {
+            break;
+        }
+        const block = normalized.slice(start, split);
+        start = split + 2;
+        if (!block.trim()) {
+            continue;
+        }
+        const lines = block.split('\n');
+        const dataLines = [];
+        for (const line of lines) {
+            if (line.startsWith(':')) {
+                continue;
+            }
+            if (line.startsWith('data:')) {
+                dataLines.push(line.slice('data:'.length).trimStart());
+            }
+        }
+        if (dataLines.length) {
+            frames.push(dataLines.join('\n'));
+        }
+    }
+    return {
+        frames,
+        rest: normalized.slice(start),
+    };
+}
+export function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(resolve, ms);
+        if (!signal) {
+            return;
+        }
+        if (signal.aborted) {
+            clearTimeout(timer);
+            reject(new Error('aborted'));
+            return;
+        }
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(new Error('aborted'));
+        };
+        signal.addEventListener('abort', onAbort, { once: true });
+    });
+}
+export const defaultLogger = {
+    info(message, extra) {
+        if (extra) {
+            // eslint-disable-next-line no-console
+            console.log(message, extra);
+            return;
+        }
+        // eslint-disable-next-line no-console
+        console.log(message);
+    },
+    warn(message, extra) {
+        if (extra) {
+            // eslint-disable-next-line no-console
+            console.warn(message, extra);
+            return;
+        }
+        // eslint-disable-next-line no-console
+        console.warn(message);
+    },
+    error(message, extra) {
+        if (extra) {
+            // eslint-disable-next-line no-console
+            console.error(message, extra);
+            return;
+        }
+        // eslint-disable-next-line no-console
+        console.error(message);
+    },
+};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@agentclub/openclaw-adapter",
+  "version": "0.1.2",
+  "description": "Agent Hub adapter for local OpenClaw Gateway agents",
+  "type": "module",
+  "main": "dist/index.js",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "bin": {
+    "agentclub-openclaw-adapter": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsx src/cli.ts",
+    "start": "node dist/cli.js start",
+    "check": "node dist/cli.js check",
+    "test": "vitest run",
+    "prepublishOnly": "npm test && npm run build"
+  },
+  "keywords": [
+    "agenthub",
+    "openclaw",
+    "agent",
+    "adapter",
+    "sse",
+    "gateway",
+    "chatbot"
+  ],
+  "author": "",
+  "license": "MIT",
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@types/node": "^22.13.10",
+    "tsx": "^4.19.3",
+    "typescript": "^5.8.2",
+    "vitest": "^2.1.8"
+  }
+}