onebots 1.0.0 → 1.0.4

package/lib/bin.js

@@ -1,39 +1,5 @@
 #!/usr/bin/env node
 "use strict";
-import { createOnebots, App } from "./app.js";
-const execArgv = process.argv.splice(2);
-const obj = {};
-for (let i = 0; i < execArgv.length; i += 2) {
-    const key = execArgv[i];
-    const value = execArgv[i + 1];
-    if (!obj[key])
-        obj[key] = value;
-    else {
-        if (Array.isArray(obj[key]))
-            obj[key].push(value);
-        else
-            obj[key] = [obj[key], value];
-    }
-}
-if (obj["-r"]) {
-    const adapters = [].concat(obj["-r"]);
-    for (const adapter of adapters) {
-        const result = await App.loadAdapterFactory(adapter);
-        if (!result)
-            console.warn(`[onebots] Failed to load adapter ${adapter}, please check if the adapter is installed`);
-    }
-}
-if (!obj['-p'])
-    obj['-p'] = [];
-if (!Array.isArray(obj['-p']))
-    obj['-p'] = [obj['-p']];
-if (obj["-p"]) {
-    const protocols = [].concat(obj["-p"]);
-    for (const protocol of protocols) {
-        await App.loadProtocolFactory(protocol);
-    }
-}
-if (Array.isArray(obj['-c']))
-    obj['-c'] = obj['-c'][obj['-c'].length - 1];
-createOnebots(obj["-c"]).start();
+import { runCli } from "./cli.js";
+runCli();
 //# sourceMappingURL=bin.js.map

package/lib/cli.d.ts

@@ -0,0 +1,2 @@
+export declare function runCli(): void;
+//# sourceMappingURL=cli.d.ts.map

package/lib/cli.js

@@ -0,0 +1,293 @@
+/**
+ * OneBots CLI：gateway 网关控制、config、setup、onboard、send
+ */
+import { Command } from "commander";
+import * as path from "path";
+import * as fs from "fs";
+import { createOnebots, App } from "./app.js";
+import { yaml } from "@onebots/core";
+import { getPidPath, readPid, writePid, removePidFile, isProcessRunning, stopProcess, daemonStart, } from "./daemon.js";
+import { serviceInstall, serviceUninstall, serviceStatus, } from "./service-manager.js";
+const program = new Command();
+program
+    .name("onebots")
+    .description("OneBots CLI - 网关控制与配置管理")
+    .version("1.0.1")
+    .option("-c, --config <path>", "配置文件路径", "config.yaml")
+    .option("-r, --register <adapter>", "注册适配器（可多次）", collect, [])
+    .option("-p, --protocol <protocol>", "注册协议（可多次）", collect, []);
+function collect(val, prev) {
+    return (prev || []).concat([val]);
+}
+function getConfigPath(configOption) {
+    return path.resolve(process.cwd(), configOption);
+}
+async function loadAdaptersAndProtocols(adapters, protocols) {
+    for (const adapter of adapters) {
+        const ok = await App.loadAdapterFactory(adapter);
+        if (!ok) {
+            console.warn(`[onebots] 加载适配器 ${adapter} 失败，请检查是否已安装`);
+        }
+    }
+    for (const protocol of protocols) {
+        await App.loadProtocolFactory(protocol);
+    }
+}
+async function runGatewayStart(configPath, adapters, protocols) {
+    await loadAdaptersAndProtocols(adapters, protocols);
+    createOnebots(configPath).start();
+}
+// ---------- gateway 子命令 ----------
+const gateway = program.command("gateway").description("网关服务（start/daemon/stop/service）");
+gateway
+    .command("start")
+    .description("前台启动网关")
+    .action(async () => {
+    const opts = program.opts();
+    const configPath = getConfigPath(opts.config);
+    await runGatewayStart(configPath, opts.register || [], opts.protocol || []);
+});
+gateway
+    .command("daemon")
+    .description("后台启动网关")
+    .action(async () => {
+    const opts = program.opts();
+    const configPath = getConfigPath(opts.config);
+    await loadAdaptersAndProtocols(opts.register || [], opts.protocol || []);
+    const pid = daemonStart({
+        configPath,
+        adapters: opts.register || [],
+        protocols: opts.protocol || [],
+        nodePath: process.execPath,
+        binPath: process.argv[1],
+    });
+    writePid(configPath, pid);
+    console.log(`网关已在后台启动，PID: ${pid}`);
+    console.log(`PID 文件: ${getPidPath(configPath)}`);
+    process.exit(0);
+});
+gateway
+    .command("stop")
+    .description("停止网关")
+    .action(async () => {
+    const opts = program.opts();
+    const configPath = getConfigPath(opts.config);
+    const pid = readPid(configPath);
+    if (pid === null) {
+        console.error("[onebots] 未找到 PID 文件，网关可能未以后台方式运行");
+        process.exit(2);
+    }
+    if (!isProcessRunning(pid)) {
+        console.warn("[onebots] 进程已不存在，清理 PID 文件");
+        removePidFile(configPath);
+        process.exit(0);
+    }
+    stopProcess(pid);
+    removePidFile(configPath);
+    console.log("网关已停止");
+    process.exit(0);
+});
+const gatewayService = gateway.command("service").description("系统服务（install/uninstall/status）");
+gatewayService
+    .command("install")
+    .description("安装网关为系统服务")
+    .action(async () => {
+    const opts = program.opts();
+    const configPath = getConfigPath(opts.config);
+    await serviceInstall(configPath);
+});
+gatewayService
+    .command("uninstall")
+    .description("卸载网关系统服务")
+    .action(async () => {
+    await serviceUninstall();
+});
+gatewayService
+    .command("status")
+    .description("查看网关服务状态")
+    .action(async () => {
+    await serviceStatus();
+});
+// ---------- config 子命令 ----------
+const configCmd = program.command("config").description("命令式修改配置（get/set/list）");
+configCmd
+    .command("get <key>")
+    .description("获取配置项")
+    .action(async (key) => {
+    const opts = program.opts();
+    const configPath = getConfigPath(opts.config);
+    if (!fs.existsSync(configPath)) {
+        console.error("[onebots] 配置文件不存在，请先运行 onebots setup");
+        process.exit(1);
+    }
+    const raw = fs.readFileSync(configPath, "utf8");
+    const config = yaml.load(raw) || {};
+    const keys = key.split(".");
+    let cur = config;
+    for (const k of keys) {
+        cur = cur?.[k];
+        if (cur === undefined)
+            break;
+    }
+    console.log(cur === undefined ? "" : String(cur));
+});
+configCmd
+    .command("set <key> <value>")
+    .description("设置配置项")
+    .action(async (key, value) => {
+    const opts = program.opts();
+    const configPath = getConfigPath(opts.config);
+    if (!fs.existsSync(configPath)) {
+        console.error("[onebots] 配置文件不存在，请先运行 onebots setup");
+        process.exit(1);
+    }
+    const raw = fs.readFileSync(configPath, "utf8");
+    const config = yaml.load(raw) || {};
+    const keys = key.split(".");
+    let cur = config;
+    for (let i = 0; i < keys.length - 1; i++) {
+        const k = keys[i];
+        if (!(cur[k] instanceof Object))
+            cur[k] = {};
+        cur = cur[k];
+    }
+    const last = keys[keys.length - 1];
+    const num = Number(value);
+    cur[last] = value === "true" ? true : value === "false" ? false : Number.isNaN(num) ? value : num;
+    fs.writeFileSync(configPath, yaml.dump(config), "utf8");
+    console.log(`已设置 ${key} = ${value}`);
+});
+configCmd
+    .command("list")
+    .description("列出全部配置")
+    .action(async () => {
+    const opts = program.opts();
+    const configPath = getConfigPath(opts.config);
+    if (!fs.existsSync(configPath)) {
+        console.error("[onebots] 配置文件不存在，请先运行 onebots setup");
+        process.exit(1);
+    }
+    const raw = fs.readFileSync(configPath, "utf8");
+    const config = yaml.load(raw) || {};
+    console.log(yaml.dump(config));
+});
+// ---------- setup ----------
+program
+    .command("setup")
+    .description("初始化 OneBots（创建配置目录与默认配置）")
+    .action(async () => {
+    const opts = program.opts();
+    const configPath = getConfigPath(opts.config);
+    const configDir = path.dirname(configPath);
+    if (fs.existsSync(configPath)) {
+        console.log("配置文件已存在:", configPath);
+        process.exit(0);
+    }
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+    }
+    const samplePath = path.resolve(import.meta.dirname, "./config.sample.yaml");
+    fs.copyFileSync(samplePath, configPath);
+    const dataDir = path.join(configDir, "data");
+    if (!fs.existsSync(dataDir)) {
+        fs.mkdirSync(dataDir, { recursive: true });
+    }
+    console.log("已初始化，配置文件:", configPath);
+    console.log("请修改配置后使用 onebots gateway start 启动");
+    process.exit(0);
+});
+// ---------- onboard ----------
+program
+    .command("onboard")
+    .description("引导式调整配置")
+    .action(async () => {
+    const opts = program.opts();
+    const configPath = getConfigPath(opts.config);
+    if (!fs.existsSync(configPath)) {
+        console.error("[onebots] 请先运行 onebots setup");
+        process.exit(1);
+    }
+    const readline = await import("readline");
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q) => new Promise((resolve) => rl.question(q, resolve));
+    let config = yaml.load(fs.readFileSync(configPath, "utf8")) || {};
+    const port = await ask("HTTP 端口 [6727]: ");
+    if (port)
+        config.port = parseInt(port, 10) || 6727;
+    const logLevel = await ask("日志级别 (trace/debug/info/warn/error) [info]: ");
+    if (logLevel)
+        config.log_level = logLevel || "info";
+    fs.writeFileSync(configPath, yaml.dump(config), "utf8");
+    console.log("配置已更新:", configPath);
+    rl.close();
+    process.exit(0);
+});
+// ---------- send ----------
+program
+    .command("send <target_id> <message>")
+    .description("通过已运行的网关发送消息")
+    .requiredOption("--target_type <type>", "private | group | channel")
+    .requiredOption("--channel <channel>", "发信 bot，格式 platform.account_id（如 qq.my_bot）")
+    .option("--url <baseUrl>", "网关 base URL（默认从 -c 读取 port/path 构造）")
+    .action(async (target_id, message, options) => {
+    const opts = program.opts();
+    let baseUrl = options.url;
+    let auth = {};
+    if (!baseUrl) {
+        const configPath = getConfigPath(opts.config);
+        if (!fs.existsSync(configPath)) {
+            console.error("[onebots] 配置文件不存在，请指定 -c 或 --url");
+            process.exit(1);
+        }
+        const config = yaml.load(fs.readFileSync(configPath, "utf8"));
+        const port = config?.port ?? 6727;
+        const pathPrefix = config?.path ?? "";
+        baseUrl = `http://127.0.0.1:${port}${pathPrefix}`;
+        if (config?.access_token) {
+            auth = { Authorization: `Bearer ${config.access_token}` };
+        }
+        else if (config?.username && config?.password) {
+            auth = {
+                Authorization: "Basic " + Buffer.from(`${config.username}:${config.password}`).toString("base64"),
+            };
+        }
+    }
+    const body = {
+        channel: options.channel,
+        target_id,
+        target_type: options.target_type,
+        message: message || "",
+    };
+    try {
+        const res = await fetch(`${baseUrl.replace(/\/$/, "")}/api/send`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", ...auth },
+            body: JSON.stringify(body),
+        });
+        const text = await res.text();
+        if (!res.ok) {
+            console.error("[onebots] 发送失败:", res.status, text);
+            process.exit(2);
+        }
+        console.log(text || "发送成功");
+    }
+    catch (e) {
+        console.error("[onebots] 请求失败，请确认网关已启动（onebots gateway start 或 onebots gateway daemon）:", e);
+        process.exit(2);
+    }
+    process.exit(0);
+});
+// 无子命令时默认执行 gateway start（仅当没有未被选项消耗的剩余参数时）
+program.action(async () => {
+    // 使用 program.args：Commander 解析后只包含未被 -r/-p/-c 等消耗的剩余参数。
+    // 用 process.argv 会把 -r/-p 的值（如 kook、config.yaml）误判为位置参数导致不启动。
+    if (program.args.length > 0)
+        return; // 有剩余位置参数则交给 Commander 显示 unknown command
+    const opts = program.opts();
+    const configPath = getConfigPath(opts.config);
+    await runGatewayStart(configPath, opts.register || [], opts.protocol || []);
+});
+export function runCli() {
+    program.parse();
+}
+//# sourceMappingURL=cli.js.map

package/lib/config-schema.d.ts

@@ -0,0 +1,9 @@
+import type { Schema } from '@onebots/core';
+export type ConfigSchemaBundle = {
+    base: Schema;
+    general: Schema;
+    protocols: Record<string, Schema>;
+    adapters: Record<string, Schema>;
+};
+export declare const getAppConfigSchema: () => ConfigSchemaBundle;
+//# sourceMappingURL=config-schema.d.ts.map

package/lib/config-schema.js

@@ -0,0 +1,78 @@
+import { BaseAppConfigSchema, AdapterRegistry, ProtocolRegistry } from '@onebots/core';
+/**
+ * App 层配置 Schema（可在此扩展）
+ */
+const base = BaseAppConfigSchema;
+const withLabel = (key, label, description) => {
+    return {
+        ...base[key],
+        label,
+        description,
+    };
+};
+const general = {
+    'onebot.v11': {
+        use_http: { type: 'boolean', default: true, label: '启用 HTTP' },
+        use_ws: { type: 'boolean', default: true, label: '启用 WebSocket' },
+        access_token: { type: 'string', default: '', label: 'Access Token' },
+        secret: { type: 'string', default: '', label: 'Secret' },
+        enable_cors: { type: 'boolean', default: true, label: '启用 CORS' },
+        heartbeat_interval: { type: 'number', default: 5, min: 1, label: '心跳间隔(秒)' },
+        http_reverse: { type: 'array', default: [], label: 'HTTP 反向上报地址' },
+        ws_reverse: { type: 'array', default: [], label: 'WS 反向连接地址' },
+    },
+    'onebot.v12': {
+        use_http: { type: 'boolean', default: true, label: '启用 HTTP' },
+        use_ws: { type: 'boolean', default: true, label: '启用 WebSocket' },
+        access_token: { type: 'string', default: '', label: 'Access Token' },
+        secret: { type: 'string', default: '', label: 'Secret' },
+        enable_cors: { type: 'boolean', default: true, label: '启用 CORS' },
+        heartbeat_interval: { type: 'number', default: 5, min: 1, label: '心跳间隔(秒)' },
+        webhooks: { type: 'array', default: [], label: 'Webhook 上报地址' },
+        ws_reverse: { type: 'array', default: [], label: 'WS 反向连接地址' },
+        request_timeout: { type: 'number', default: 15, min: 1, label: '请求超时(秒)' },
+    },
+    'satori.v1': {
+        use_http: { type: 'boolean', default: true, label: '启用 HTTP' },
+        use_ws: { type: 'boolean', default: true, label: '启用 WebSocket' },
+        token: { type: 'string', default: '', label: 'Token' },
+        platform: { type: 'string', default: 'unknown', label: '平台标识' },
+        webhooks: { type: 'array', default: [], label: 'Webhook 上报地址' },
+    },
+    'milky.v1': {
+        use_http: { type: 'boolean', default: true, label: '启用 HTTP' },
+        use_ws: { type: 'boolean', default: true, label: '启用 WebSocket' },
+        access_token: { type: 'string', default: '', label: 'Access Token' },
+        secret: { type: 'string', default: '', label: 'Secret' },
+        heartbeat: { type: 'number', default: 5, min: 1, label: '心跳间隔(秒)' },
+        http_reverse: { type: 'array', default: [], label: 'HTTP 反向上报地址' },
+        ws_reverse: { type: 'array', default: [], label: 'WS 反向连接地址' },
+    },
+};
+const baseWithLabels = {
+    port: withLabel('port', '监听端口', '服务监听端口，范围 1-65535'),
+    path: withLabel('path', '服务路径前缀', 'HTTP 服务前缀路径，可为空'),
+    database: withLabel('database', '数据库文件', '数据库文件名或路径'),
+    timeout: withLabel('timeout', '登录超时(秒)', '账号登录超时秒数'),
+    username: withLabel('username', '管理端用户名', 'Web 管理端登录用户名（与鉴权码二选一）'),
+    password: withLabel('password', '管理端密码', 'Web 管理端登录密码（与鉴权码二选一）'),
+    access_token: withLabel('access_token', '管理端鉴权码', 'Bearer 鉴权码，配置后可使用 Authorization: Bearer <鉴权码> 访问 API，无需用户名密码'),
+    log_level: withLabel('log_level', '日志等级', 'trace | debug | info | warn | error | fatal | mark | off'),
+    public_static_dir: withLabel('public_static_dir', '站点根静态目录', '相对配置文件目录或绝对路径，用于企业微信等可信域名校验文件（站点根路径 GET）；留空不启用。Docker：配置 static 并将校验文件放入挂载卷内 /data/static'),
+};
+export const getAppConfigSchema = () => {
+    const protocols = {
+        ...general,
+        ...ProtocolRegistry.getAllSchemas(),
+    };
+    const adapters = {
+        ...AdapterRegistry.getAllSchemas(),
+    };
+    return {
+        base: baseWithLabels,
+        general,
+        protocols,
+        adapters,
+    };
+};
+//# sourceMappingURL=config-schema.js.map

package/lib/daemon.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 根据配置路径确定 pid 文件所在目录（与网关进程一致）
+ */
+export declare function getPidDir(configPath: string): string;
+export declare function getPidPath(configPath: string): string;
+export declare function writePid(configPath: string, pid: number): void;
+export declare function readPid(configPath: string): number | null;
+export declare function removePidFile(configPath: string): void;
+/**
+ * 检查 pid 是否对应存活进程
+ */
+export declare function isProcessRunning(pid: number): boolean;
+/**
+ * 向网关进程发送 SIGTERM
+ */
+export declare function stopProcess(pid: number): boolean;
+/**
+ * 在后台启动网关：spawn 子进程执行 onebots gateway start -c <configPath> [-r ...] [-p ...]
+ * 返回子进程 pid；父进程写 pid 文件后退出。
+ */
+export declare function daemonStart(options: {
+    configPath: string;
+    adapters: string[];
+    protocols: string[];
+    /** Node 可执行路径 */
+    nodePath: string;
+    /** onebots CLI 入口路径（如 lib/bin.js） */
+    binPath: string;
+}): number;
+//# sourceMappingURL=daemon.d.ts.map

package/lib/daemon.js

@@ -0,0 +1,94 @@
+/**
+ * 网关 daemon：pid 文件读写与后台进程管理
+ */
+import * as fs from "fs";
+import * as path from "path";
+import { spawn } from "child_process";
+const PID_FILE = "onebots-gateway.pid";
+/**
+ * 根据配置路径确定 pid 文件所在目录（与网关进程一致）
+ */
+export function getPidDir(configPath) {
+    const resolved = path.resolve(process.cwd(), configPath);
+    return path.dirname(resolved);
+}
+export function getPidPath(configPath) {
+    return path.join(getPidDir(configPath), PID_FILE);
+}
+export function writePid(configPath, pid) {
+    const file = getPidPath(configPath);
+    const dir = path.dirname(file);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(file, String(pid), "utf8");
+}
+export function readPid(configPath) {
+    const file = getPidPath(configPath);
+    if (!fs.existsSync(file))
+        return null;
+    const content = fs.readFileSync(file, "utf8").trim();
+    const pid = parseInt(content, 10);
+    return Number.isNaN(pid) ? null : pid;
+}
+export function removePidFile(configPath) {
+    const file = getPidPath(configPath);
+    if (fs.existsSync(file)) {
+        try {
+            fs.unlinkSync(file);
+        }
+        catch {
+            // 忽略
+        }
+    }
+}
+/**
+ * 检查 pid 是否对应存活进程
+ */
+export function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 向网关进程发送 SIGTERM
+ */
+export function stopProcess(pid) {
+    if (!isProcessRunning(pid))
+        return false;
+    try {
+        process.kill(pid, "SIGTERM");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 在后台启动网关：spawn 子进程执行 onebots gateway start -c <configPath> [-r ...] [-p ...]
+ * 返回子进程 pid；父进程写 pid 文件后退出。
+ */
+export function daemonStart(options) {
+    const args = [
+        options.binPath,
+        "gateway",
+        "start",
+        "-c",
+        options.configPath,
+        ...options.adapters.flatMap((r) => ["-r", r]),
+        ...options.protocols.flatMap((p) => ["-p", p]),
+    ];
+    const child = spawn(options.nodePath, args, {
+        cwd: getPidDir(options.configPath),
+        stdio: "ignore",
+        detached: true,
+        env: process.env,
+    });
+    child.unref();
+    return child.pid;
+}
+//# sourceMappingURL=daemon.js.map

package/lib/index.d.ts

@@ -1,3 +1,4 @@
 export * from './app.js';
+export * from './config-schema.js';
 export * from '@onebots/core';
 //# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -1,3 +1,4 @@
 export * from './app.js';
+export * from './config-schema.js';
 export * from '@onebots/core';
 //# sourceMappingURL=index.js.map

package/lib/service-manager.d.ts

@@ -0,0 +1,4 @@
+export declare function serviceInstall(configPath: string): Promise<void>;
+export declare function serviceUninstall(): Promise<void>;
+export declare function serviceStatus(): Promise<void>;
+//# sourceMappingURL=service-manager.d.ts.map