@agentclub/openclaw-adapter 0.1.2

package/dist/cli.js

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+import { existsSync } from 'node:fs';
+import { AgentHubOpenClawAdapter } from './adapter.js';
+import { applyConfigOverrides, buildEnvExample, buildConfigOverridesFromEnv, buildDefaultConfigFromEnv, defaultConfigPath, loadConfig, saveConfig, validateConfig, } from './config.js';
+import { promptConfigInteractive } from './prompt.js';
+import { AgentHubClient } from './agenthub-client.js';
+import { OpenClawClient } from './openclaw-client.js';
+import { defaultLogger } from './utils.js';
+function parseArg(name) {
+    const args = process.argv.slice(2);
+    const index = args.findIndex((arg) => arg === name || arg.startsWith(`${name}=`));
+    if (index === -1) {
+        return undefined;
+    }
+    const current = args[index];
+    if (current.includes('=')) {
+        return current.split('=').slice(1).join('=');
+    }
+    return args[index + 1];
+}
+function hasFlag(name) {
+    return process.argv.slice(2).includes(name);
+}
+function getConfigPathFromArgs() {
+    return parseArg('--config')?.trim() || defaultConfigPath();
+}
+function buildConfigOverridesFromArgs() {
+    const overrides = {
+        agentHub: {},
+        openClaw: {},
+        adapter: {},
+    };
+    const agentHubBaseUrl = parseArg('--agent-hub-base-url')?.trim();
+    const clientId = parseArg('--client-id')?.trim();
+    const clientSecret = parseArg('--client-secret')?.trim();
+    const gatewayUrl = parseArg('--gateway-url')?.trim();
+    const gatewayToken = parseArg('--gateway-token')?.trim();
+    const gatewayPassword = parseArg('--gateway-password')?.trim();
+    const agentId = parseArg('--agent-id')?.trim();
+    const sessionKeyTemplate = parseArg('--session-key-template')?.trim();
+    const thinking = parseArg('--thinking')?.trim();
+    const replyPrefix = parseArg('--reply-prefix')?.trim();
+    const openClawTimeoutMs = parseArg('--openclaw-timeout-ms')?.trim();
+    const requestTimeoutMs = parseArg('--request-timeout-ms')?.trim();
+    if (agentHubBaseUrl) {
+        overrides.agentHub.baseUrl = agentHubBaseUrl;
+    }
+    if (clientId) {
+        overrides.agentHub.clientId = clientId;
+    }
+    if (clientSecret) {
+        overrides.agentHub.clientSecret = clientSecret;
+    }
+    if (gatewayUrl) {
+        overrides.openClaw.gatewayUrl = gatewayUrl;
+    }
+    if (gatewayToken !== undefined) {
+        overrides.openClaw.gatewayToken = gatewayToken;
+    }
+    if (gatewayPassword !== undefined) {
+        overrides.openClaw.gatewayPassword = gatewayPassword;
+    }
+    if (agentId) {
+        overrides.openClaw.agentId = agentId;
+    }
+    if (sessionKeyTemplate) {
+        overrides.openClaw.sessionKeyTemplate = sessionKeyTemplate;
+    }
+    if (thinking !== undefined) {
+        overrides.openClaw.thinking = thinking;
+    }
+    if (replyPrefix !== undefined) {
+        overrides.adapter.replyPrefix = replyPrefix;
+    }
+    if (openClawTimeoutMs) {
+        overrides.openClaw.timeoutMs = openClawTimeoutMs;
+    }
+    if (requestTimeoutMs) {
+        overrides.adapter.requestTimeoutMs = requestTimeoutMs;
+    }
+    return buildConfigOverridesFromEnv({
+        AGENT_HUB_BASE_URL: overrides.agentHub.baseUrl,
+        AGENT_HUB_CLIENT_ID: overrides.agentHub.clientId,
+        AGENT_HUB_CLIENT_SECRET: overrides.agentHub.clientSecret,
+        OPENCLAW_GATEWAY_URL: overrides.openClaw.gatewayUrl,
+        OPENCLAW_GATEWAY_TOKEN: overrides.openClaw.gatewayToken,
+        OPENCLAW_GATEWAY_PASSWORD: overrides.openClaw.gatewayPassword,
+        OPENCLAW_AGENT_ID: overrides.openClaw.agentId,
+        OPENCLAW_SESSION_KEY_TEMPLATE: overrides.openClaw.sessionKeyTemplate,
+        OPENCLAW_TIMEOUT_MS: overrides.openClaw.timeoutMs,
+        OPENCLAW_THINKING: overrides.openClaw.thinking,
+        ADAPTER_REPLY_PREFIX: overrides.adapter.replyPrefix,
+        ADAPTER_REQUEST_TIMEOUT_MS: overrides.adapter.requestTimeoutMs,
+    });
+}
+function printUsage() {
+    // eslint-disable-next-line no-console
+    console.log(`
+Usage:
+  agentclub-openclaw-adapter init [--config <path>] [--yes] [--advanced] [--print-env-example]
+  agentclub-openclaw-adapter start [--config <path>]
+  agentclub-openclaw-adapter check [--config <path>]
+  agentclub-openclaw-adapter print-config [--config <path>]
+
+Init options:
+  --yes                   Non-interactive init. Use env/flags and write config directly.
+  --advanced              Interactive advanced mode. Ask for all OpenClaw options.
+  --agent-hub-base-url    Agent Hub server base URL
+  --client-id             Agent Hub agent clientId
+  --client-secret         Agent Hub agent clientSecret
+  --gateway-url           OpenClaw Gateway WebSocket URL
+  --gateway-token         OpenClaw Gateway token
+  --gateway-password      OpenClaw Gateway password
+  --agent-id              OpenClaw agentId
+  --session-key-template  OpenClaw session key template
+  --thinking              OpenClaw thinking level
+  --reply-prefix          Reply prefix added before final reply
+`);
+}
+async function cmdInit(configPath) {
+    if (hasFlag('--print-env-example')) {
+        // eslint-disable-next-line no-console
+        console.log(buildEnvExample());
+        return;
+    }
+    let config = buildDefaultConfigFromEnv();
+    if (existsSync(configPath)) {
+        try {
+            config = await loadConfig(configPath);
+        }
+        catch {
+            // ignore invalid existing file and re-init interactively
+        }
+    }
+    config = applyConfigOverrides(config, buildConfigOverridesFromEnv(process.env));
+    config = applyConfigOverrides(config, buildConfigOverridesFromArgs());
+    if (!hasFlag('--yes')) {
+        const interactive = await promptConfigInteractive({
+            advanced: hasFlag('--advanced'),
+            defaults: config,
+        });
+        config = {
+            ...config,
+            ...interactive,
+        };
+    }
+    validateConfig(config);
+    await saveConfig(config, configPath);
+    defaultLogger.info('[adapter] config saved', { configPath });
+}
+async function cmdStart(configPath) {
+    const config = await loadConfig(configPath);
+    const adapter = new AgentHubOpenClawAdapter(config, defaultLogger);
+    const controller = new AbortController();
+    const shutdown = () => {
+        controller.abort();
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+    defaultLogger.info('[adapter] starting', {
+        configPath,
+        agentHub: config.agentHub.baseUrl,
+        openClaw: config.openClaw.gatewayUrl,
+    });
+    await adapter.run(controller.signal);
+}
+async function cmdCheck(configPath) {
+    const config = await loadConfig(configPath);
+    validateConfig(config);
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), config.adapter.requestTimeoutMs);
+    try {
+        const agentHub = new AgentHubClient(config, defaultLogger);
+        await agentHub.ensureAuthorized(controller.signal);
+        defaultLogger.info('[check] agenthub auth ok', {
+            selfUserId: agentHub.getSelfUserId(),
+        });
+        const openClaw = new OpenClawClient(config, defaultLogger);
+        await openClaw.connect(controller.signal);
+        defaultLogger.info('[check] openclaw gateway ok', {
+            gatewayUrl: config.openClaw.gatewayUrl,
+            serverVersion: openClaw.getHello()?.server?.version ?? 'unknown',
+        });
+        const probe = await openClaw.generateReply({
+            threadId: 'probe-thread',
+            incomingMessageId: 'probe-message',
+            incomingMessage: 'ping',
+            signal: controller.signal,
+        });
+        defaultLogger.info('[check] openclaw reply probe ok', {
+            replyPreview: probe.reply.slice(0, 60),
+        });
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function cmdPrintConfig(configPath) {
+    const config = await loadConfig(configPath);
+    const masked = {
+        ...config,
+        agentHub: {
+            ...config.agentHub,
+            clientSecret: config.agentHub.clientSecret ? `${config.agentHub.clientSecret.slice(0, 4)}***` : '',
+        },
+        openClaw: {
+            ...config.openClaw,
+            gatewayPassword: config.openClaw.gatewayPassword ? '***' : '',
+            gatewayToken: config.openClaw.gatewayToken ? `${config.openClaw.gatewayToken.slice(0, 4)}***` : '',
+        },
+    };
+    // eslint-disable-next-line no-console
+    console.log(JSON.stringify(masked, null, 2));
+}
+async function main() {
+    const command = process.argv[2] || 'help';
+    const configPath = getConfigPathFromArgs();
+    switch (command) {
+        case 'init':
+            await cmdInit(configPath);
+            return;
+        case 'start':
+            await cmdStart(configPath);
+            return;
+        case 'check':
+            await cmdCheck(configPath);
+            return;
+        case 'print-config':
+            await cmdPrintConfig(configPath);
+            return;
+        case 'help':
+        case '--help':
+        case '-h':
+            printUsage();
+            return;
+        default:
+            printUsage();
+            throw new Error(`unknown command: ${command}`);
+    }
+}
+main().catch((error) => {
+    defaultLogger.error('[adapter] fatal', {
+        error: error instanceof Error ? error.message : String(error),
+    });
+    process.exitCode = 1;
+});

package/dist/config.js

@@ -0,0 +1,182 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import os from 'node:os';
+import { normalizeBaseUrl, normalizeGatewayUrl, parseNumber } from './utils.js';
+export const DEFAULT_OPENCLAW_GATEWAY_URL = 'ws://127.0.0.1:18789';
+export const DEFAULT_OPENCLAW_AGENT_ID = 'main';
+export const DEFAULT_SESSION_KEY_TEMPLATE = 'agent:{agentId}:agenthub:{threadSlug}-{threadHash}';
+export function defaultConfigPath() {
+    if (process.env.AGENTCLUB_ADAPTER_CONFIG?.trim()) {
+        return process.env.AGENTCLUB_ADAPTER_CONFIG.trim();
+    }
+    if (process.env.AGENTHUB_ADAPTER_CONFIG?.trim()) {
+        return process.env.AGENTHUB_ADAPTER_CONFIG.trim();
+    }
+    return join(os.homedir(), '.config', 'agentclub-openclaw-adapter', 'config.json');
+}
+export function buildDefaultConfigFromEnv(source = process.env) {
+    const agentId = source.OPENCLAW_AGENT_ID?.trim() ?? DEFAULT_OPENCLAW_AGENT_ID;
+    return {
+        version: 1,
+        agentHub: {
+            baseUrl: normalizeBaseUrl(source.AGENT_HUB_BASE_URL ?? 'http://127.0.0.1:3000'),
+            clientId: source.AGENT_HUB_CLIENT_ID?.trim() ?? '',
+            clientSecret: source.AGENT_HUB_CLIENT_SECRET?.trim() ?? '',
+        },
+        openClaw: {
+            gatewayUrl: normalizeGatewayUrl(source.OPENCLAW_GATEWAY_URL ?? DEFAULT_OPENCLAW_GATEWAY_URL),
+            gatewayToken: source.OPENCLAW_GATEWAY_TOKEN?.trim() ?? '',
+            gatewayPassword: source.OPENCLAW_GATEWAY_PASSWORD?.trim() ?? '',
+            agentId,
+            sessionKeyTemplate: source.OPENCLAW_SESSION_KEY_TEMPLATE?.trim() || DEFAULT_SESSION_KEY_TEMPLATE,
+            timeoutMs: parseNumber(source.OPENCLAW_TIMEOUT_MS, 20_000),
+            thinking: source.OPENCLAW_THINKING?.trim() ?? '',
+        },
+        adapter: {
+            replyPrefix: source.ADAPTER_REPLY_PREFIX?.trim() ?? '',
+            requestTimeoutMs: parseNumber(source.ADAPTER_REQUEST_TIMEOUT_MS, 15_000),
+            reconnectInitialDelayMs: parseNumber(source.ADAPTER_RECONNECT_INITIAL_DELAY_MS, 1_000),
+            reconnectMaxDelayMs: parseNumber(source.ADAPTER_RECONNECT_MAX_DELAY_MS, 30_000),
+            handledTtlMs: parseNumber(source.ADAPTER_HANDLED_TTL_MS, 6 * 60 * 60_000),
+            handledLimit: parseNumber(source.ADAPTER_HANDLED_LIMIT, 5_000),
+        },
+    };
+}
+export function buildConfigOverridesFromEnv(source = process.env) {
+    const overrides = {};
+    if (source.AGENT_HUB_BASE_URL !== undefined ||
+        source.AGENT_HUB_CLIENT_ID !== undefined ||
+        source.AGENT_HUB_CLIENT_SECRET !== undefined) {
+        overrides.agentHub = {};
+        if (source.AGENT_HUB_BASE_URL !== undefined) {
+            overrides.agentHub.baseUrl = normalizeBaseUrl(source.AGENT_HUB_BASE_URL);
+        }
+        if (source.AGENT_HUB_CLIENT_ID !== undefined) {
+            overrides.agentHub.clientId = source.AGENT_HUB_CLIENT_ID.trim();
+        }
+        if (source.AGENT_HUB_CLIENT_SECRET !== undefined) {
+            overrides.agentHub.clientSecret = source.AGENT_HUB_CLIENT_SECRET.trim();
+        }
+    }
+    if (source.OPENCLAW_GATEWAY_URL !== undefined ||
+        source.OPENCLAW_GATEWAY_TOKEN !== undefined ||
+        source.OPENCLAW_GATEWAY_PASSWORD !== undefined ||
+        source.OPENCLAW_AGENT_ID !== undefined ||
+        source.OPENCLAW_SESSION_KEY_TEMPLATE !== undefined ||
+        source.OPENCLAW_TIMEOUT_MS !== undefined ||
+        source.OPENCLAW_THINKING !== undefined) {
+        overrides.openClaw = {};
+        if (source.OPENCLAW_GATEWAY_URL !== undefined) {
+            overrides.openClaw.gatewayUrl = normalizeGatewayUrl(source.OPENCLAW_GATEWAY_URL);
+        }
+        if (source.OPENCLAW_GATEWAY_TOKEN !== undefined) {
+            overrides.openClaw.gatewayToken = source.OPENCLAW_GATEWAY_TOKEN.trim();
+        }
+        if (source.OPENCLAW_GATEWAY_PASSWORD !== undefined) {
+            overrides.openClaw.gatewayPassword = source.OPENCLAW_GATEWAY_PASSWORD.trim();
+        }
+        if (source.OPENCLAW_AGENT_ID !== undefined) {
+            overrides.openClaw.agentId = source.OPENCLAW_AGENT_ID.trim();
+        }
+        if (source.OPENCLAW_SESSION_KEY_TEMPLATE !== undefined) {
+            overrides.openClaw.sessionKeyTemplate = source.OPENCLAW_SESSION_KEY_TEMPLATE.trim();
+        }
+        if (source.OPENCLAW_TIMEOUT_MS !== undefined) {
+            overrides.openClaw.timeoutMs = parseNumber(source.OPENCLAW_TIMEOUT_MS, 20_000);
+        }
+        if (source.OPENCLAW_THINKING !== undefined) {
+            overrides.openClaw.thinking = source.OPENCLAW_THINKING.trim();
+        }
+    }
+    if (source.ADAPTER_REPLY_PREFIX !== undefined ||
+        source.ADAPTER_REQUEST_TIMEOUT_MS !== undefined ||
+        source.ADAPTER_RECONNECT_INITIAL_DELAY_MS !== undefined ||
+        source.ADAPTER_RECONNECT_MAX_DELAY_MS !== undefined ||
+        source.ADAPTER_HANDLED_TTL_MS !== undefined ||
+        source.ADAPTER_HANDLED_LIMIT !== undefined) {
+        overrides.adapter = {};
+        if (source.ADAPTER_REPLY_PREFIX !== undefined) {
+            overrides.adapter.replyPrefix = source.ADAPTER_REPLY_PREFIX.trim();
+        }
+        if (source.ADAPTER_REQUEST_TIMEOUT_MS !== undefined) {
+            overrides.adapter.requestTimeoutMs = parseNumber(source.ADAPTER_REQUEST_TIMEOUT_MS, 15_000);
+        }
+        if (source.ADAPTER_RECONNECT_INITIAL_DELAY_MS !== undefined) {
+            overrides.adapter.reconnectInitialDelayMs = parseNumber(source.ADAPTER_RECONNECT_INITIAL_DELAY_MS, 1_000);
+        }
+        if (source.ADAPTER_RECONNECT_MAX_DELAY_MS !== undefined) {
+            overrides.adapter.reconnectMaxDelayMs = parseNumber(source.ADAPTER_RECONNECT_MAX_DELAY_MS, 30_000);
+        }
+        if (source.ADAPTER_HANDLED_TTL_MS !== undefined) {
+            overrides.adapter.handledTtlMs = parseNumber(source.ADAPTER_HANDLED_TTL_MS, 6 * 60 * 60_000);
+        }
+        if (source.ADAPTER_HANDLED_LIMIT !== undefined) {
+            overrides.adapter.handledLimit = parseNumber(source.ADAPTER_HANDLED_LIMIT, 5_000);
+        }
+    }
+    return overrides;
+}
+export function applyConfigOverrides(base, overrides) {
+    return {
+        ...base,
+        agentHub: {
+            ...base.agentHub,
+            ...overrides.agentHub,
+        },
+        openClaw: {
+            ...base.openClaw,
+            ...overrides.openClaw,
+        },
+        adapter: {
+            ...base.adapter,
+            ...overrides.adapter,
+        },
+    };
+}
+export function buildEnvExample() {
+    return [
+        '# Required',
+        'export AGENT_HUB_BASE_URL=http://127.0.0.1:3000',
+        'export AGENT_HUB_CLIENT_ID=agc_xxx',
+        'export AGENT_HUB_CLIENT_SECRET=xxx',
+        `export OPENCLAW_AGENT_ID=${DEFAULT_OPENCLAW_AGENT_ID}`,
+        '',
+        '# Optional',
+        `export OPENCLAW_GATEWAY_URL=${DEFAULT_OPENCLAW_GATEWAY_URL}`,
+        'export OPENCLAW_GATEWAY_TOKEN=',
+        'export OPENCLAW_GATEWAY_PASSWORD=',
+        `export OPENCLAW_SESSION_KEY_TEMPLATE='${DEFAULT_SESSION_KEY_TEMPLATE}'`,
+        'export OPENCLAW_THINKING=',
+        'export ADAPTER_REPLY_PREFIX=',
+        '',
+        'agentclub-openclaw-adapter init --yes',
+    ].join('\n');
+}
+export function validateConfig(config) {
+    if (config.version !== 1) {
+        throw new Error(`unsupported config version: ${String(config.version)}`);
+    }
+    if (!config.agentHub.baseUrl || !config.agentHub.clientId || !config.agentHub.clientSecret) {
+        throw new Error('agentHub.baseUrl/clientId/clientSecret are required');
+    }
+    if (!config.openClaw.gatewayUrl) {
+        throw new Error('openClaw.gatewayUrl is required');
+    }
+    if (!config.openClaw.agentId) {
+        throw new Error('openClaw.agentId is required');
+    }
+    if (!config.openClaw.sessionKeyTemplate) {
+        throw new Error('openClaw.sessionKeyTemplate is required');
+    }
+}
+export async function loadConfig(path = defaultConfigPath()) {
+    const raw = await readFile(path, 'utf8');
+    const parsed = JSON.parse(raw);
+    validateConfig(parsed);
+    return parsed;
+}
+export async function saveConfig(config, path = defaultConfigPath()) {
+    validateConfig(config);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `${JSON.stringify(config, null, 2)}\n`, 'utf8');
+}

package/dist/index.js

@@ -0,0 +1,6 @@
+export * from './types.js';
+export * from './config.js';
+export * from './adapter.js';
+export * from './agenthub-client.js';
+export * from './openclaw-client.js';
+export * from './utils.js';