@mininglamp-oss/octo-runtime 0.0.0-stage → 1.0.0

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/transport/wukong.js

@@ -0,0 +1,431 @@
+/**
+ * WuKong 传输：负责 Bot 注册、加密握手、二进制帧编解码和收发确认。
+ * 保留原通道的协议兼容性；授权、Context 和执行策略由上层处理。
+ */
+import { createCipheriv, createDecipheriv, createHash, createPublicKey, diffieHellman, generateKeyPairSync, randomUUID } from "node:crypto";
+import WebSocket from "ws";
+import { ImSendError, ImTextSend } from "../delivery/text-send.js";
+import { connectionFetch, connectionJson, httpConnectionFailure, ImConnectionError } from "./connection-error.js";
+const LIMIT = 1 << 20;
+const md5 = (value) => createHash("md5").update(value).digest("hex");
+export async function registerBot(apiUrl, token, signal) {
+    const response = await connectionFetch(`${apiUrl.replace(/\/$/, "")}/v1/bot/register`, {
+        method: "POST",
+        redirect: "error",
+        signal: signal
+            ? AbortSignal.any([signal, AbortSignal.timeout(15_000)])
+            : AbortSignal.timeout(15_000),
+        headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+        body: JSON.stringify({
+            agent_platform: "octo-runtime-extra-channel-gateway",
+            agent_version: "0.1.0"
+        })
+    }, "REGISTER");
+    if (!response.ok) {
+        throw await httpConnectionFailure(response, "REGISTER");
+    }
+    const data = (await connectionJson(response, "REGISTER", "IM_REGISTRATION_INVALID"));
+    if (!data ||
+        [data.robot_id, data.im_token, data.ws_url].some((value) => typeof value !== "string" || !value))
+        throw new Error("IM_REGISTRATION_INVALID");
+    const url = new URL(data.ws_url);
+    if (!["wss:", "ws:"].includes(url.protocol) || url.username || url.password)
+        throw new Error("IM_WS_URL_INVALID");
+    if (url.protocol === "ws:" && !["127.0.0.1", "localhost", "[::1]"].includes(url.hostname))
+        throw new Error("IM_WS_TLS_REQUIRED");
+    return data;
+}
+class Writer {
+    chunks = [];
+    byte(n) {
+        this.chunks.push(Buffer.from([n]));
+        return this;
+    }
+    u32(n) {
+        const b = Buffer.alloc(4);
+        b.writeUInt32BE(n);
+        this.chunks.push(b);
+        return this;
+    }
+    u64(n) {
+        const b = Buffer.alloc(8);
+        b.writeBigUInt64BE(n);
+        this.chunks.push(b);
+        return this;
+    }
+    string(s) {
+        const b = Buffer.from(s);
+        if (b.length > 65535)
+            throw new Error("IM_FIELD_TOO_LARGE");
+        const h = Buffer.alloc(2);
+        h.writeUInt16BE(b.length);
+        this.chunks.push(h, b);
+        return this;
+    }
+    bytes(b) {
+        this.chunks.push(b);
+        return this;
+    }
+    finish() {
+        return Buffer.concat(this.chunks);
+    }
+}
+class Reader {
+    data;
+    offset = 0;
+    constructor(data) {
+        this.data = data;
+    }
+    take(n) {
+        if (this.offset + n > this.data.length)
+            throw new Error("IM_FRAME_TRUNCATED");
+        const value = this.data.subarray(this.offset, this.offset + n);
+        this.offset += n;
+        return value;
+    }
+    byte() {
+        return this.take(1)[0];
+    }
+    u32() {
+        return this.take(4).readUInt32BE();
+    }
+    u64() {
+        return this.take(8).readBigUInt64BE();
+    }
+    string() {
+        return this.take(this.take(2).readUInt16BE()).toString();
+    }
+    rest() {
+        return this.take(this.data.length - this.offset);
+    }
+}
+function frame(kind, body, flags = 0) {
+    const length = [];
+    let n = body.length;
+    do {
+        let b = n % 128;
+        n = Math.floor(n / 128);
+        if (n)
+            b |= 128;
+        length.push(b);
+    } while (n);
+    return Buffer.concat([Buffer.from([(kind << 4) | flags, ...length]), body]);
+}
+/** 每个机器人独占 WuKong v4 连接和加密状态；此层只处理传输，不调用模型。 */
+export class WukongConnection {
+    onMessage;
+    onDisconnect;
+    #socket;
+    #closing;
+    #key;
+    #iv;
+    #version = 0;
+    #buffer = Buffer.alloc(0);
+    #seq = 0;
+    #heartbeat;
+    #lastPacket = Date.now();
+    #closed = false;
+    #ready = false;
+    #sends = new Map();
+    #active = new Set();
+    #confirmed = new Set();
+    #retained = new Map();
+    #abort = new AbortController();
+    constructor(onMessage, onDisconnect = () => { }) {
+        this.onMessage = onMessage;
+        this.onDisconnect = onDisconnect;
+    }
+    get connected() {
+        return this.#ready && this.#socket?.readyState === WebSocket.OPEN;
+    }
+    async connect(registration) {
+        if (this.#socket)
+            throw new Error("IM_ALREADY_CONNECTED");
+        const keys = generateKeyPairSync("x25519");
+        const publicKey = keys.publicKey
+            .export({ format: "der", type: "spki" })
+            .subarray(-32)
+            .toString("base64");
+        const socket = new WebSocket(registration.ws_url, {
+            maxPayload: LIMIT,
+            handshakeTimeout: 15_000,
+            followRedirects: false
+        });
+        this.#socket = socket;
+        let failure;
+        await new Promise((resolve, reject) => {
+            let ready = false;
+            const timeout = setTimeout(() => {
+                failure = new ImConnectionError("IM_CONNECT_TIMEOUT", true);
+                socket.terminate();
+                reject(failure);
+            }, 15_000);
+            socket.on("open", () => socket.send(frame(1, new Writer()
+                .byte(4)
+                .byte(0)
+                .string(`${randomUUID()}W`)
+                .string(registration.robot_id)
+                .string(registration.im_token)
+                .u64(BigInt(Date.now()))
+                .string(publicKey)
+                .finish())));
+            socket.on("error", () => {
+                failure ??= new ImConnectionError("IM_WS_ERROR", true);
+                if (!ready) {
+                    clearTimeout(timeout);
+                    reject(failure);
+                }
+            });
+            socket.on("close", () => {
+                this.#ready = false;
+                clearTimeout(timeout);
+                if (this.#heartbeat)
+                    clearInterval(this.#heartbeat);
+                for (const pending of [...this.#active])
+                    pending.disconnected();
+                this.#sends.clear();
+                for (const timer of this.#retained.values())
+                    clearTimeout(timer);
+                this.#retained.clear();
+                const error = failure ?? new ImConnectionError("IM_DISCONNECTED", true);
+                if (!ready)
+                    reject(error);
+                else if (!this.#closed)
+                    this.onDisconnect(error);
+            });
+            socket.on("message", (data, binary) => {
+                try {
+                    if (!binary)
+                        throw new Error("IM_BINARY_REQUIRED");
+                    const bytes = Array.isArray(data) ? Buffer.concat(data) : Buffer.from(data);
+                    this.#buffer = Buffer.concat([this.#buffer, bytes]);
+                    if (this.#buffer.length > LIMIT)
+                        throw new Error("IM_FRAME_TOO_LARGE");
+                    // 保留未收齐的帧；一个 WS 消息也可能包含多帧，必须逐帧解析。
+                    while (this.#buffer.length) {
+                        const header = this.#buffer[0], kind = header >> 4;
+                        if (kind === 7 || kind === 8) {
+                            this.#buffer = this.#buffer.subarray(1);
+                            this.#lastPacket = Date.now();
+                            if (kind === 7)
+                                socket.send(Buffer.from([8 << 4]));
+                            continue;
+                        }
+                        let length = 0, multiplier = 1, offset = 1, complete = false;
+                        for (; offset < this.#buffer.length && offset <= 4; offset++) {
+                            const n = this.#buffer[offset];
+                            length += (n & 127) * multiplier;
+                            multiplier *= 128;
+                            if (!(n & 128)) {
+                                offset++;
+                                complete = true;
+                                break;
+                            }
+                        }
+                        if (!complete) {
+                            if (offset > 4)
+                                throw new Error("IM_LENGTH_INVALID");
+                            break;
+                        }
+                        if (length > LIMIT)
+                            throw new Error("IM_FRAME_TOO_LARGE");
+                        if (this.#buffer.length < offset + length)
+                            break;
+                        const reader = new Reader(this.#buffer.subarray(offset, offset + length));
+                        this.#buffer = this.#buffer.subarray(offset + length);
+                        this.#lastPacket = Date.now();
+                        if (kind === 2 && !ready) {
+                            if (header & 1)
+                                this.#version = reader.byte();
+                            reader.u64();
+                            const reason = reader.byte();
+                            if (reason !== 1)
+                                throw new ImConnectionError(`IM_CONNECT_REJECTED_${reason}`, false);
+                            const remoteKey = reader.string();
+                            const salt = reader.string();
+                            if (this.#version >= 4)
+                                reader.u64();
+                            const raw = Buffer.from(remoteKey, "base64");
+                            if (raw.length !== 32 || Buffer.byteLength(salt) < 16)
+                                throw new Error("IM_KEY_INVALID");
+                            // X25519 共享密钥按 WuKong 协议派生 AES 密钥，盐取前 16 字节作为 IV。
+                            const serverKey = createPublicKey({
+                                format: "der",
+                                type: "spki",
+                                key: Buffer.concat([Buffer.from("302a300506032b656e032100", "hex"), raw])
+                            });
+                            this.#key = Buffer.from(md5(diffieHellman({ privateKey: keys.privateKey, publicKey: serverKey }).toString("base64")).slice(0, 16));
+                            this.#iv = Buffer.from(salt).subarray(0, 16);
+                            ready = true;
+                            this.#ready = true;
+                            clearTimeout(timeout);
+                            this.#heartbeat = setInterval(() => {
+                                if (Date.now() - this.#lastPacket > 90_000) {
+                                    failure = new ImConnectionError("IM_HEARTBEAT_TIMEOUT", true);
+                                    socket.terminate();
+                                }
+                                else if (socket.readyState === WebSocket.OPEN)
+                                    socket.send(Buffer.from([7 << 4]));
+                            }, 25_000);
+                            this.#heartbeat.unref();
+                            resolve();
+                        }
+                        else if (!ready)
+                            throw new Error("IM_HANDSHAKE_REQUIRED");
+                        else if (kind === 5)
+                            this.#receive(reader, registration.robot_id);
+                        else if (kind === 4) {
+                            const id = reader.u64().toString();
+                            const seq = reader.u32();
+                            reader.u32();
+                            const reason = reader.byte();
+                            const pending = this.#sends.get(seq);
+                            if (pending) {
+                                if (reason === 1) {
+                                    this.#confirmed.add(pending.key);
+                                    if (this.#confirmed.size > 512)
+                                        this.#confirmed.delete(this.#confirmed.values().next().value);
+                                    this.#forget(pending.operation);
+                                }
+                                pending.operation.ack(id, reason);
+                            }
+                        }
+                        else if (kind === 9)
+                            throw new ImConnectionError(`IM_SERVER_DISCONNECTED_${reader.byte()}`, false);
+                    }
+                }
+                catch (error) {
+                    this.#ready = false;
+                    failure = error instanceof Error ? error : new Error("IM_PROTOCOL_ERROR");
+                    clearTimeout(timeout);
+                    if (!ready)
+                        reject(failure);
+                    socket.terminate();
+                }
+            });
+        });
+        if (!this.connected)
+            throw failure ?? new ImConnectionError("IM_DISCONNECTED", true);
+    }
+    #encrypt(value) {
+        if (!this.#key || !this.#iv)
+            throw new Error("IM_NOT_READY");
+        const cipher = createCipheriv("aes-128-cbc", this.#key, this.#iv);
+        return Buffer.concat([cipher.update(value, "utf8"), cipher.final()]).toString("base64");
+    }
+    #receive(reader, ownUid) {
+        const setting = reader.byte(), msgKey = reader.string(), fromUid = reader.string(), channelId = reader.string(), channelType = reader.byte();
+        if (this.#version >= 3)
+            reader.u32();
+        const clientNo = reader.string(), messageId = reader.u64(), messageSeq = reader.u32(), timestamp = reader.u32();
+        if (setting & 8)
+            reader.string();
+        const encrypted = reader.rest().toString();
+        if (md5(this.#encrypt(`${messageId}${messageSeq}${clientNo}${timestamp}${fromUid}${channelId}${channelType}${encrypted}`)) !== msgKey)
+            throw new Error("IM_MESSAGE_KEY_INVALID");
+        const decipher = createDecipheriv("aes-128-cbc", this.#key, this.#iv);
+        const plain = Buffer.concat([
+            decipher.update(Buffer.from(encrypted, "base64")),
+            decipher.final()
+        ]);
+        const payload = JSON.parse(plain.toString());
+        if (!payload || typeof payload !== "object" || Array.isArray(payload))
+            throw new Error("IM_PAYLOAD_INVALID");
+        if (fromUid !== ownUid)
+            this.onMessage({
+                messageId: messageId.toString(),
+                messageSeq,
+                fromUid,
+                channelId: channelType === 1 ? fromUid : channelId,
+                channelType,
+                timestamp,
+                payload
+            });
+        // 此 ACK 仅确认 IM 消息已接收，不代表 AgentRun 已执行完成。
+        this.#socket?.send(frame(6, new Writer().u64(messageId).u32(messageSeq).finish()));
+    }
+    sendText(channelId, channelType, text, clientMsgNo = randomUUID(), spaceId, mention, signal) {
+        if (this.#socket?.readyState !== WebSocket.OPEN || !this.#key)
+            return Promise.reject(new ImSendError("IM_NOT_READY", "failed"));
+        if (Buffer.byteLength(text) > 256 * 1024 ||
+            this.#active.size >= 64 ||
+            this.#socket.bufferedAmount > LIMIT)
+            return Promise.reject(new ImSendError("IM_SEND_CAPACITY_EXHAUSTED", "failed"));
+        const encrypted = this.#encrypt(JSON.stringify({
+            type: 1,
+            content: text,
+            ...(spaceId ? { space_id: spaceId } : {}),
+            ...(mention ? { mention } : {})
+        }));
+        const operation = new ImTextSend(() => {
+            if (!this.connected)
+                throw new ImSendError("IM_NOT_READY", "failed");
+            if (this.#socket.bufferedAmount > LIMIT)
+                throw new ImSendError("IM_SEND_CAPACITY_EXHAUSTED", "failed");
+            const seq = ++this.#seq;
+            const body = new Writer()
+                .byte(0)
+                .u32(seq)
+                .string(clientMsgNo)
+                .string(channelId)
+                .byte(channelType);
+            if (this.#version >= 3)
+                body.u32(0);
+            body
+                .string(md5(this.#encrypt(`${seq}${clientMsgNo}${channelId}${channelType}${encrypted}`)))
+                .bytes(Buffer.from(encrypted));
+            this.#sends.set(seq, { operation, key: clientMsgNo });
+            this.#socket.send(frame(3, body.finish(), 2), (error) => {
+                if (error)
+                    operation.disconnected();
+            });
+        }, (state) => {
+            this.#active.delete(operation);
+            if (state === "unknown" && !this.#closed) {
+                // 留出 REST 降级窗口关联迟到 ACK；映射与计时器均有界。
+                while (this.#retained.size >= 64)
+                    this.#forget(this.#retained.keys().next().value);
+                const timer = setTimeout(() => this.#forget(operation), 30_000);
+                timer.unref();
+                this.#retained.set(operation, timer);
+            }
+            else
+                this.#forget(operation);
+        }, signal ? AbortSignal.any([this.#abort.signal, signal]) : this.#abort.signal);
+        this.#active.add(operation);
+        operation.start();
+        return operation.result;
+    }
+    isDelivered(clientMsgNo) {
+        return this.#confirmed.has(clientMsgNo);
+    }
+    #forget(operation) {
+        clearTimeout(this.#retained.get(operation));
+        this.#retained.delete(operation);
+        for (const [seq, pending] of this.#sends)
+            if (pending.operation === operation)
+                this.#sends.delete(seq);
+    }
+    close() {
+        if (this.#closing)
+            return this.#closing;
+        this.#closed = true;
+        this.#abort.abort();
+        for (const timer of this.#retained.values())
+            clearTimeout(timer);
+        this.#retained.clear();
+        this.#sends.clear();
+        this.#ready = false;
+        if (this.#heartbeat)
+            clearInterval(this.#heartbeat);
+        const socket = this.#socket;
+        this.#closing =
+            !socket || socket.readyState === WebSocket.CLOSED
+                ? Promise.resolve()
+                : new Promise((resolve) => {
+                    socket.once("close", resolve);
+                    socket.terminate();
+                });
+        return this.#closing;
+    }
+}

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@mininglamp-oss/octo-runtime-extra-channel-gateway",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    "./config-schema.json": "./config-schema.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./daemon-module": {
+      "types": "./dist/daemon-module.d.ts",
+      "import": "./dist/daemon-module.js"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "config-schema.json",
+    "dist",
+    "README.md",
+    "docs"
+  ],
+  "dependencies": {
+    "@mininglamp-oss/octo-runtime-adapter-host": "1.0.0",
+    "@mininglamp-oss/octo-runtime-adapter-sdk": "1.0.0",
+    "@mininglamp-oss/octo-runtime-core": "1.0.0",
+    "@mininglamp-oss/octo-runtime-daemon": "1.0.0",
+    "@mininglamp-oss/octo-runtime-protocol": "1.0.0",
+    "mdast-util-from-markdown": "2.1.0",
+    "ws": "8.21.3"
+  }
+}