//[title: adapter_demo_http]
//[author: your-name]
//[version: 1.0.0]
//[class: 适配器]
//[language: javascript]
//[runtime: [email protected]]
//[description: Demo IM 适配器]
//[im_type: demo]
//[im_type_name: Demo IM]
//[protocol: im]
//[transport: http]
//[account_id_key: bot_id]
//[param: {"scope":"account","required":true,"key":"bot_id","name":"Bot ID"}]
'use strict';
const IM_TYPE = 'demo';
const CONTROL_URL = process.env.AUTCLAW_ADAPTER_CONNECT_URL
|| `ws://127.0.0.1:${process.env.AUTCLAW_PORT || '8200'}/api/adapters/${IM_TYPE}/connect`;
let generation = 0;
function object(value) {
return value !== null && typeof value === 'object' && !Array.isArray(value);
}
function send(session, packet) {
if (session.closed || session.ws.readyState !== WebSocket.OPEN) {
throw new Error('control connection closed');
}
session.ws.send(JSON.stringify(packet));
}
function call(session, action, params, timeoutMS = 15000) {
if (session.pending.size >= 128) return Promise.reject(new Error('worker busy'));
return new Promise((resolve, reject) => {
const echo = `node_${session.generation}_${++session.seq}`;
const timer = setTimeout(() => {
session.pending.delete(echo);
reject(new Error(`${action} timed out`));
}, timeoutMS);
session.pending.set(echo, { resolve, reject, timer });
try {
send(session, { aut_action: action, aut_echo: echo, aut_params: params });
} catch (error) {
clearTimeout(timer);
session.pending.delete(echo);
reject(error);
}
});
}
function reply(session, echo, params, error) {
send(session, error
? { aut_echo: echo, ok: false, aut_error: String(error.message || error) }
: { aut_echo: echo, ok: true, aut_params: params || {} });
}
function detach(session) {
if (session.closed) return;
session.closed = true;
session.abort.abort();
for (const entry of session.pending.values()) {
clearTimeout(entry.timer);
entry.reject(new Error('control connection closed'));
}
session.pending.clear();
session.ws.close();
setTimeout(connect, 3000);
}
function connect() {
const session = {
generation: ++generation,
ws: new WebSocket(CONTROL_URL),
pending: new Map(), accounts: new Map(),
abort: new AbortController(),
closed: false, initialized: false, seq: 0, active: 0,
};
session.ws.addEventListener('message', ({ data }) => {
let packet;
try {
packet = JSON.parse(String(data));
if (!object(packet)) throw new Error('invalid packet');
} catch {
detach(session);
return;
}
onPacket(session, packet).catch(() => detach(session));
});
session.ws.addEventListener('close', () => detach(session));
session.ws.addEventListener('error', () => detach(session));
}
async function onPacket(session, packet) {
if (session.closed) return;
const echo = typeof packet.aut_echo === 'string' ? packet.aut_echo : '';
if (!packet.aut_action && echo) {
const entry = session.pending.get(echo);
if (!entry) return;
session.pending.delete(echo);
clearTimeout(entry.timer);
if (packet.ok === false) entry.reject(new Error(packet.aut_error || 'call failed'));
else if (!object(packet.aut_params)) entry.reject(new Error('invalid response'));
else entry.resolve(packet.aut_params);
return;
}
if (!object(packet.aut_params)) throw new Error('invalid aut_params');
const params = packet.aut_params;
if (packet.aut_action === 'adapter_init') {
if (session.initialized) throw new Error('duplicate init');
session.accounts = new Map((params.account_configs || []).map(config => {
if (!config.account_id || !config.instance_id) throw new Error('invalid account');
return [String(config.account_id), config];
}));
session.hostCapabilities = params.host_capabilities || {};
session.globalConfig = params.global_config_values || {};
send(session, {
aut_action: 'adapter_worker_ready',
aut_params: {
contract: 'v6',
resolve_account: false, normalize_inbound: false,
build_outbound: false, decode_receipt: false,
execute_outbound: false, emit_inbound_events: false,
request_outbound: false, open_ingress: false, supports_qr_login: false,
features: [], outbound_actions: [],
},
});
session.initialized = true;
// 在这里启动平台循环,使用 session.abort.signal 取消平台请求。
return;
}
if (!echo) return;
if (!session.initialized || session.active >= 8) {
reply(session, echo, null, new Error('worker not ready or busy'));
return;
}
session.active++;
try {
const result = await handleAction(session, packet.aut_action, params);
if (!object(result)) throw new Error('invalid handler result');
reply(session, echo, result);
} catch (error) {
if (!session.closed) reply(session, echo, null, error);
} finally {
session.active--;
}
}
async function handleAction(session, action, params) {
throw new Error(`unsupported control action: ${action}`);
}
connect();