koishi-plugin-mai-bridge 0.1.0

package/out/bridge/convert.js

@@ -0,0 +1,274 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sessionToMaimMessage = sessionToMaimMessage;
+exports.maimMessageToFragment = maimMessageToFragment;
+exports.getRouteIdFromMaim = getRouteIdFromMaim;
+exports.getFallbackRouteHints = getFallbackRouteHints;
+exports.shouldForwardSession = shouldForwardSession;
+const koishi_1 = require("koishi");
+const PLATFORM = 'koishi';
+function textSeg(content) {
+    return { type: 'text', data: content };
+}
+function atSeg(element) {
+    const id = String(element.attrs.id || element.attrs.userId || element.attrs.qq || '').trim();
+    const name = String(element.attrs.name || element.attrs.nick || '').trim();
+    return {
+        type: 'at',
+        data: {
+            target_user_id: id,
+            target_user_nickname: name,
+            target_user_cardname: name,
+        },
+    };
+}
+function stringifyUnknown(element) {
+    const attrs = Object.entries(element.attrs || {})
+        .map(([key, value]) => `${key}=${String(value)}`)
+        .join(' ');
+    return attrs ? `[${element.type} ${attrs}]` : `[${element.type}]`;
+}
+async function imageSegFromSource(source, options) {
+    const src = typeof source === 'string' ? source.trim() : '';
+    if (!src)
+        return;
+    const dataUrl = /^data:image\/[^;]+;base64,([A-Za-z0-9+/=\s]+)$/i.exec(src);
+    if (dataUrl) {
+        return { type: 'image', data: dataUrl[1].replace(/\s/g, '') };
+    }
+    const base64Url = /^base64:\/\/([A-Za-z0-9+/=\s]+)$/i.exec(src);
+    if (base64Url) {
+        return { type: 'image', data: base64Url[1].replace(/\s/g, '') };
+    }
+    if (/^https?:\/\//i.test(src) && options.resolveImage) {
+        const base64 = await options.resolveImage(src);
+        if (base64)
+            return { type: 'image', data: base64 };
+    }
+    return textSeg(`[图片: ${src}]`);
+}
+async function elementToSeg(element, options) {
+    if (element.type === 'text') {
+        return textSeg(element.attrs.content ?? '');
+    }
+    if (element.type === 'quote' || element.type === 'reply') {
+        return replySegFromElement(element, options.replyContext);
+    }
+    if (element.type === 'at') {
+        return atSeg(element);
+    }
+    if (element.type === 'img' || element.type === 'image') {
+        const src = element.attrs.src || element.attrs.url || element.attrs.file;
+        return await imageSegFromSource(src, options) || textSeg(stringifyUnknown(element));
+    }
+    if (element.type === 'br') {
+        return textSeg('\n');
+    }
+    return textSeg(stringifyUnknown(element));
+}
+async function normalizeSegments(elements, options) {
+    const hasReplyElement = elements.some((element) => element.type === 'quote' || element.type === 'reply');
+    const segments = (await Promise.all(elements.map((element) => elementToSeg(element, options))))
+        .filter((segment) => !!segment);
+    if (options.replyContext && !hasReplyElement) {
+        segments.unshift(replySeg(options.replyContext));
+    }
+    if (!segments.length)
+        return textSeg('');
+    if (segments.length === 1)
+        return segments[0];
+    return {
+        type: 'seglist',
+        data: segments,
+    };
+}
+function getElements(session) {
+    const existing = session.elements;
+    if (Array.isArray(existing))
+        return existing;
+    return koishi_1.h.parse(session.content || '');
+}
+function textFromChildren(element) {
+    const children = element.children;
+    if (!Array.isArray(children))
+        return '';
+    return children.map((child) => {
+        if (typeof child === 'string')
+            return child;
+        if (child?.type === 'text')
+            return child.attrs?.content ?? '';
+        if (child?.type === 'at')
+            return `@${child.attrs?.name || child.attrs?.id || ''}`;
+        if (child?.type === 'img' || child?.type === 'image')
+            return '[图片]';
+        return child?.type ? stringifyUnknown(child) : '';
+    }).join('').trim();
+}
+function replySeg(context) {
+    const data = {
+        target_message_id: context.targetMessageId,
+    };
+    if (context.targetMessageContent)
+        data.target_message_content = context.targetMessageContent;
+    if (context.targetMessageSenderId)
+        data.target_message_sender_id = context.targetMessageSenderId;
+    if (context.targetMessageSenderNickname)
+        data.target_message_sender_nickname = context.targetMessageSenderNickname;
+    if (context.targetMessageSenderCardname)
+        data.target_message_sender_cardname = context.targetMessageSenderCardname;
+    if (context.contextCount !== undefined)
+        data.koishi_context_count = context.contextCount;
+    if (Object.keys(data).length === 1)
+        return { type: 'reply', data: context.targetMessageId };
+    return { type: 'reply', data };
+}
+function replySegFromElement(element, context) {
+    const targetMessageId = firstString(element.attrs.id, element.attrs.messageId, element.attrs.target, context?.targetMessageId);
+    if (!targetMessageId)
+        return textSeg(stringifyUnknown(element));
+    return replySeg({
+        targetMessageId,
+        targetMessageContent: context?.targetMessageId === targetMessageId
+            ? context.targetMessageContent
+            : textFromChildren(element) || firstString(element.attrs.content, element.attrs.text),
+        targetMessageSenderId: context?.targetMessageId === targetMessageId ? context.targetMessageSenderId : undefined,
+        targetMessageSenderNickname: context?.targetMessageId === targetMessageId ? context.targetMessageSenderNickname : undefined,
+        targetMessageSenderCardname: context?.targetMessageId === targetMessageId ? context.targetMessageSenderCardname : undefined,
+        contextCount: context?.targetMessageId === targetMessageId ? context.contextCount : undefined,
+    });
+}
+function isAtBot(session) {
+    return getElements(session).some((element) => {
+        if (element.type !== 'at')
+            return false;
+        const id = String(element.attrs.id || element.attrs.userId || element.attrs.qq || '').trim();
+        return !!id && id === String(session.selfId || '').trim();
+    });
+}
+function nonEmptyString(value, fallback) {
+    const normalized = typeof value === 'string' ? value.trim() : '';
+    return normalized || fallback;
+}
+function firstString(...values) {
+    for (const value of values) {
+        const normalized = typeof value === 'string' ? value.trim() : '';
+        if (normalized)
+            return normalized;
+    }
+}
+function buildSenderInfo(session) {
+    const userId = nonEmptyString(session.userId || session.author?.id, 'unknown');
+    const channelId = nonEmptyString(session.channelId, 'unknown');
+    const userInfo = {
+        platform: PLATFORM,
+        user_id: userId,
+        user_nickname: nonEmptyString(session.username || session.author?.name, userId),
+        user_cardname: nonEmptyString(session.author?.nick, userId),
+    };
+    if (session.isDirect) {
+        return { user_info: userInfo };
+    }
+    return {
+        group_info: {
+            platform: PLATFORM,
+            group_id: channelId,
+            group_name: nonEmptyString(session.event?.channel?.name || session.event?.guild?.name, channelId),
+        },
+        user_info: userInfo,
+    };
+}
+async function sessionToMaimMessage(session, route, apiKey, options = {}) {
+    const messageId = String(session.messageId || session.id || `koishi-${Date.now()}`);
+    const senderInfo = buildSenderInfo(session);
+    const atBot = isAtBot(session);
+    const replyContext = options.replyContext;
+    return {
+        message_info: {
+            platform: PLATFORM,
+            message_id: messageId,
+            time: session.timestamp ? session.timestamp / 1000 : Date.now() / 1000,
+            group_info: senderInfo.group_info,
+            user_info: senderInfo.user_info,
+            sender_info: senderInfo,
+            additional_config: {
+                koishi_route_id: route.routeId,
+                koishi_self_id: session.selfId,
+                koishi_platform: session.platform,
+                koishi_channel_id: session.channelId || '',
+                koishi_guild_id: session.guildId,
+                koishi_user_id: session.userId,
+                koishi_message_id: messageId,
+                koishi_reply_to_message_id: replyContext?.targetMessageId,
+                koishi_reply_context_count: replyContext?.contextCount,
+                koishi_is_direct: !!session.isDirect,
+                at_bot: atBot,
+                is_mentioned: atBot,
+            },
+            format_info: {
+                content_format: ['text', 'image'],
+                accept_format: ['text', 'image'],
+            },
+        },
+        message_segment: await normalizeSegments(getElements(session), options),
+        message_dim: {
+            api_key: apiKey,
+            platform: PLATFORM,
+        },
+    };
+}
+function segToFragment(segment) {
+    if (segment.type === 'seglist' && Array.isArray(segment.data)) {
+        return segment.data
+            .map(segToFragment)
+            .filter((fragment) => fragment !== '' && (!Array.isArray(fragment) || fragment.length > 0));
+    }
+    if (segment.type === 'text') {
+        return String(segment.data ?? '');
+    }
+    if (segment.type === 'image' || segment.type === 'img') {
+        const src = String(segment.data ?? '');
+        if (!src)
+            return '';
+        const normalized = /^(https?:|file:|data:)/.test(src) ? src : `data:image/png;base64,${src}`;
+        return (0, koishi_1.h)('img', { src: normalized });
+    }
+    if (segment.type === 'emoji') {
+        return String(segment.data ?? '');
+    }
+    if (segment.type === 'reply') {
+        return '';
+    }
+    return `[${segment.type}]${typeof segment.data === 'string' ? segment.data : JSON.stringify(segment.data)}`;
+}
+function maimMessageToFragment(message) {
+    return segToFragment(message.message_segment);
+}
+function getRouteIdFromMaim(message) {
+    return message.message_info.additional_config?.koishi_route_id;
+}
+function getFallbackRouteHints(message) {
+    const receiver = message.message_info.receiver_info;
+    const messageInfo = message.message_info;
+    const additional = message.message_info.additional_config || {};
+    const channelId = firstString(additional.koishi_channel_id, receiver?.group_info?.group_id, messageInfo.group_info?.group_id);
+    const userId = firstString(additional.koishi_user_id, additional.platform_io_target_user_id, receiver?.user_info?.user_id, messageInfo.user_info?.user_id);
+    const isDirect = typeof additional.koishi_is_direct === 'boolean'
+        ? additional.koishi_is_direct
+        : !channelId;
+    return {
+        channelId,
+        userId,
+        selfId: firstString(additional.koishi_self_id),
+        isDirect,
+    };
+}
+function shouldForwardSession(session, config) {
+    if (!session.content && !getElements(session).length)
+        return false;
+    if (config.messageMode !== 'command')
+        return true;
+    const prefix = config.commandPrefix.trim();
+    if (!prefix)
+        return true;
+    return (session.content || '').trimStart().startsWith(prefix);
+}

package/out/bridge/docker.d.ts

@@ -0,0 +1,30 @@
+import type { Config } from '../config';
+import type { RuntimeStatus } from '../types';
+export declare class MaibotDockerManager {
+    private config;
+    private apiKey;
+    private logger;
+    private state;
+    private lastError?;
+    private updatedAt?;
+    private logs;
+    constructor(config: Config, apiKey: string);
+    getStatus(): RuntimeStatus['docker'];
+    getLogs(): string[];
+    build(): Promise<void>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    restart(): Promise<void>;
+    private createContainer;
+    private createRunArgs;
+    private buildEnv;
+    private volumeMap;
+    private ensureVolumeDirs;
+    private containerExists;
+    private removeContainer;
+    private docker;
+    private run;
+    private fail;
+    private pushLog;
+    private sanitize;
+}

package/out/bridge/docker.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MaibotDockerManager = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const koishi_1 = require("koishi");
+const paths_1 = require("../utils/paths");
+const spawn_1 = require("../utils/spawn");
+const command_1 = require("../utils/command");
+const agreements_1 = require("./agreements");
+class MaibotDockerManager {
+    config;
+    apiKey;
+    logger = new koishi_1.Logger('mai.ko/docker');
+    state = 'idle';
+    lastError;
+    updatedAt;
+    logs = [];
+    constructor(config, apiKey) {
+        this.config = config;
+        this.apiKey = apiKey;
+    }
+    getStatus() {
+        return {
+            state: this.state,
+            containerName: this.config.dockerContainerName,
+            imageName: this.config.dockerImageName,
+            lastError: this.lastError,
+            updatedAt: this.updatedAt,
+        };
+    }
+    getLogs() {
+        return [...this.logs];
+    }
+    async build() {
+        this.state = 'building';
+        this.lastError = undefined;
+        this.updatedAt = Date.now();
+        try {
+            const root = (0, paths_1.resolveMaibotRoot)(this.config);
+            if (!(0, fs_1.existsSync)(root)) {
+                throw new Error(`maibotRoot does not exist: ${root}`);
+            }
+            this.pushLog(`building Docker image: ${this.config.dockerImageName}`);
+            const result = await this.docker(['build', '-t', this.config.dockerImageName, root]);
+            (0, spawn_1.assertSuccessful)(result, 'docker build');
+            this.state = 'stopped';
+            this.updatedAt = Date.now();
+        }
+        catch (error) {
+            this.fail(error);
+        }
+    }
+    async start() {
+        this.lastError = undefined;
+        this.updatedAt = Date.now();
+        try {
+            if (this.config.dockerRecreateOnStart) {
+                await this.removeContainer(true);
+            }
+            const exists = await this.containerExists();
+            if (!exists) {
+                await this.createContainer();
+            }
+            this.state = 'starting';
+            this.pushLog(`starting Docker container: ${this.config.dockerContainerName}`);
+            const result = await this.docker(['start', this.config.dockerContainerName]);
+            (0, spawn_1.assertSuccessful)(result, 'docker start');
+            this.state = 'running';
+            this.updatedAt = Date.now();
+        }
+        catch (error) {
+            this.fail(error);
+        }
+    }
+    async stop() {
+        this.state = 'stopping';
+        this.updatedAt = Date.now();
+        try {
+            const exists = await this.containerExists();
+            if (exists) {
+                const result = await this.docker(['stop', this.config.dockerContainerName], true);
+                if (result.code !== 0)
+                    this.pushLog(`docker stop warning: ${result.stderr.trim() || result.stdout.trim()}`);
+            }
+            this.state = 'stopped';
+            this.updatedAt = Date.now();
+        }
+        catch (error) {
+            this.fail(error);
+        }
+    }
+    async restart() {
+        await this.stop();
+        await this.removeContainer(true);
+        await this.build();
+        if (this.state === 'error' || this.state === 'blocked')
+            return;
+        await this.start();
+    }
+    async createContainer() {
+        const root = (0, paths_1.resolveMaibotRoot)(this.config);
+        const agreements = (0, agreements_1.prepareAgreementEnv)(root, { accept: this.config.acceptMaibotAgreements });
+        if (!agreements.ok) {
+            this.state = 'blocked';
+            throw new Error(`blocked: ${agreements.reason}`);
+        }
+        this.ensureVolumeDirs();
+        const args = this.createRunArgs(agreements.env);
+        this.pushLog(`creating Docker container: ${this.config.dockerContainerName}`);
+        const result = await this.docker(args);
+        (0, spawn_1.assertSuccessful)(result, 'docker create');
+    }
+    createRunArgs(agreementEnv) {
+        const args = [
+            'create',
+            '--name',
+            this.config.dockerContainerName,
+            '--restart',
+            'unless-stopped',
+        ];
+        if (this.config.dockerNetwork) {
+            args.push('--network', this.config.dockerNetwork);
+        }
+        if (this.config.dockerPublishedWebuiPort > 0) {
+            args.push('-p', `${this.config.dockerPublishedWebuiPort}:${this.config.webuiPort}`);
+        }
+        const env = this.buildEnv(agreementEnv);
+        for (const [key, value] of Object.entries(env)) {
+            args.push('-e', `${key}=${value}`);
+        }
+        for (const [source, target] of this.volumeMap()) {
+            args.push('-v', `${source}:${target}`);
+        }
+        args.push(this.config.dockerImageName);
+        return args;
+    }
+    buildEnv(agreementEnv) {
+        return {
+            ...agreementEnv,
+            TZ: process.env.TZ || 'Asia/Shanghai',
+            MAIBOT_WORKER_PROCESS: '1',
+            MAIBOT_KOISHI_MODE: '1',
+            MAIBOT_KOISHI_API_HOST: '0.0.0.0',
+            MAIBOT_KOISHI_API_PORT: String(this.config.apiPort),
+            MAIBOT_KOISHI_API_KEY: this.apiKey,
+            MAIBOT_KOISHI_LEGACY_HOST: '0.0.0.0',
+            MAIBOT_KOISHI_LEGACY_PORT: String(this.config.legacyPort),
+            MAIBOT_KOISHI_WEBUI_ENABLED: this.config.webuiEnabled ? '1' : '0',
+            MAIBOT_KOISHI_WEBUI_HOST: this.config.webuiHost,
+            MAIBOT_KOISHI_WEBUI_PORT: String(this.config.webuiPort),
+            WEBUI_HOST: this.config.webuiHost,
+        };
+    }
+    volumeMap() {
+        const dataDir = (0, paths_1.resolveMaiKoDataDir)();
+        return [
+            [(0, path_1.join)(dataDir, 'config'), '/MaiMBot/config'],
+            [(0, path_1.join)(dataDir, 'data'), '/MaiMBot/data'],
+            [(0, path_1.join)(dataDir, 'plugins'), '/MaiMBot/plugins'],
+            [(0, path_1.join)(dataDir, 'logs'), '/MaiMBot/logs'],
+            [(0, path_1.join)(dataDir, 'depends-data'), '/MaiMBot/depends-data'],
+        ];
+    }
+    ensureVolumeDirs() {
+        for (const [source] of this.volumeMap()) {
+            (0, fs_1.mkdirSync)(source, { recursive: true });
+        }
+    }
+    async containerExists() {
+        const result = await this.run(this.config.dockerCommand, ['inspect', this.config.dockerContainerName], false);
+        return result.code === 0;
+    }
+    async removeContainer(force = false) {
+        const exists = await this.containerExists();
+        if (!exists)
+            return;
+        const args = ['rm'];
+        if (force)
+            args.push('-f');
+        args.push(this.config.dockerContainerName);
+        const result = await this.docker(args, true);
+        if (result.code !== 0) {
+            this.pushLog(`docker rm warning: ${result.stderr.trim() || result.stdout.trim()}`);
+        }
+    }
+    async docker(args, allowFailure = false) {
+        const result = await this.run(this.config.dockerCommand, args);
+        if (!allowFailure && result.code !== 0) {
+            (0, spawn_1.assertSuccessful)(result, `${this.config.dockerCommand} ${args[0]}`);
+        }
+        return result;
+    }
+    run(command, args, logOutput = true) {
+        return (0, spawn_1.runCommand)(command, args, {
+            onLine: logOutput ? (line, stream) => this.pushLog(`${stream}: ${this.sanitize(line)}`) : undefined,
+        });
+    }
+    fail(error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.lastError = message;
+        this.state = message.startsWith('blocked:') ? 'blocked' : 'error';
+        this.updatedAt = Date.now();
+        this.logger.warn(this.sanitize(message));
+    }
+    pushLog(line) {
+        const normalized = this.sanitize(line);
+        if (!normalized)
+            return;
+        this.logs.push(normalized);
+        if (this.logs.length > this.config.logLines) {
+            this.logs.splice(0, this.logs.length - this.config.logLines);
+        }
+        this.logger.info(normalized);
+    }
+    sanitize(line) {
+        let result = line
+            .replace(/\u001b\[[0-?]*[ -/]*[@-~]/g, '')
+            .replace(/\bsk-[A-Za-z0-9_-]{12,}\b/g, 'sk-***REDACTED***')
+            .trimEnd();
+        for (const secret of [this.apiKey, encodeURIComponent(this.apiKey), this.config.apiKey]) {
+            if (!secret)
+                continue;
+            result = result.split(secret).join((0, command_1.redactSecret)(secret));
+        }
+        return result;
+    }
+}
+exports.MaibotDockerManager = MaibotDockerManager;

package/out/bridge/external-logs.d.ts

@@ -0,0 +1,29 @@
+import { type Context } from 'koishi';
+import type { Config } from '../config';
+export declare class ExternalLogForwarder {
+    private ctx;
+    private config;
+    private secrets;
+    private logger;
+    private child?;
+    private logs;
+    private partial;
+    private stopping;
+    private forceEnabled;
+    private restartDispose?;
+    constructor(ctx: Context, config: Config, secrets?: string[]);
+    get isRunning(): boolean;
+    getLogs(): string[];
+    start(force?: boolean): void;
+    stop(): void;
+    private scheduleRestart;
+    private clearRestart;
+    private setTimer;
+    private buildCommandLine;
+    private pushLog;
+    private flushPartial;
+    private writeLine;
+    private isDebugLine;
+    private isWarningLine;
+    private sanitizeLine;
+}