@dsbot-channel/onebot 0.0.0-stage → 0.7.1

package/dist/index.d.ts

@@ -0,0 +1,126 @@
+import type { AdapterFactory, AdapterMount } from '@dsbot-channel/core/adapter-registry.js';
+import type { OneBotAdapterConfig } from './adapter.js';
+/** How this link carries OneBot: one protocol per adapter, never two at once. */
+export declare const ONEBOT_PROTOCOLS: readonly ["http", "ws-forward", "ws-reverse"];
+export type OneBotProtocol = (typeof ONEBOT_PROTOCOLS)[number];
+export declare const DEFAULT_ONEBOT_WS_PATH = "/onebot/ws";
+export interface OneBotReconnectConfig {
+    initialMs: number;
+    maxMs: number;
+    factor: number;
+}
+export interface OneBotHeartbeatConfig {
+    intervalMs: number;
+    timeoutMs: number;
+}
+/** The two address kinds history may be opened for, each off unless the profile says so. */
+export interface OneBotHistoryConfig {
+    group: boolean;
+    private: boolean;
+}
+/** Longest token the transport may carry for its OneBot callback. */
+export declare const DEFAULT_ONEBOT_SEND_TIMEOUT_MS = 10000;
+export declare const DEFAULT_ONEBOT_PORT = 7331;
+export declare const DEFAULT_ONEBOT_PATH = "/onebot/event";
+/** Reads the transport block an OneBot adapter is mounted with. */
+export declare function parseOneBotConfig(mount: AdapterMount): OneBotAdapterConfig;
+export declare const createOneBotAdapter: AdapterFactory;
+export declare const Config: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<NoInfer<{
+    channel: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+    botName: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+    anchor: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+    session: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+    model: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+    reply: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+    turn: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+    delivery: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+    policy: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+    pipeline: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+    events: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+    status: import("@deepseek-ai/schemastery").default<boolean, boolean, "plain">;
+    transport: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+}>>, Schemastery.ObjectT<NoInfer<{
+    channel: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+    botName: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+    anchor: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+    session: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+    model: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+    reply: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+    turn: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+    delivery: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+    policy: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+    pipeline: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+    events: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+    status: import("@deepseek-ai/schemastery").default<boolean, boolean, "plain">;
+    transport: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+}>>, "plain">;
+export declare const apply: (ctx: import("@deepseek-ai/cordis").Context, config?: Record<string, unknown>) => void;
+export declare const plugin: {
+    name: string;
+    inject: string[];
+    Config: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<NoInfer<{
+        channel: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        botName: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        anchor: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        session: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        model: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        reply: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        turn: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        delivery: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        policy: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        pipeline: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        events: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        status: import("@deepseek-ai/schemastery").default<boolean, boolean, "plain">;
+        transport: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+    }>>, Schemastery.ObjectT<NoInfer<{
+        channel: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        botName: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        anchor: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        session: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        model: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        reply: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        turn: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        delivery: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        policy: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        pipeline: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        events: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        status: import("@deepseek-ai/schemastery").default<boolean, boolean, "plain">;
+        transport: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+    }>>, "plain">;
+    apply: (ctx: import("@deepseek-ai/cordis").Context, config?: Record<string, unknown>) => void;
+};
+declare const _default: {
+    name: string;
+    inject: string[];
+    Config: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<NoInfer<{
+        channel: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        botName: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        anchor: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        session: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        model: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        reply: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        turn: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        delivery: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        policy: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        pipeline: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        events: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        status: import("@deepseek-ai/schemastery").default<boolean, boolean, "plain">;
+        transport: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+    }>>, Schemastery.ObjectT<NoInfer<{
+        channel: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        botName: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        anchor: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        session: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        model: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        reply: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        turn: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        delivery: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        policy: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        pipeline: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        events: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        status: import("@deepseek-ai/schemastery").default<boolean, boolean, "plain">;
+        transport: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+    }>>, "plain">;
+    apply: (ctx: import("@deepseek-ai/cordis").Context, config?: Record<string, unknown>) => void;
+};
+export default _default;

package/dist/index.js

@@ -0,0 +1,227 @@
+import { makeAdapterPlugin } from '@dsbot-channel/core/adapter-plugin.js';
+import { ConfigError, assertBindHost } from '@dsbot-channel/core/config.js';
+import { OneBotAdapter } from './adapter.js';
+const FIELDS = new Set([
+    'selfId',
+    'protocol',
+    'listen',
+    'api',
+    'event',
+    'reconnect',
+    'heartbeat',
+    'accessToken',
+    'sendTimeoutMs',
+    'bots',
+    'history',
+    'fileFromUrl',
+]);
+/** How this link carries OneBot: one protocol per adapter, never two at once. */
+export const ONEBOT_PROTOCOLS = ['http', 'ws-forward', 'ws-reverse'];
+export const DEFAULT_ONEBOT_WS_PATH = '/onebot/ws';
+/** Longest token the transport may carry for its OneBot callback. */
+export const DEFAULT_ONEBOT_SEND_TIMEOUT_MS = 10_000;
+export const DEFAULT_ONEBOT_PORT = 7331;
+export const DEFAULT_ONEBOT_PATH = '/onebot/event';
+function refuse(message, field) {
+    throw new ConfigError(message, field === undefined ? ['adapters', 'transport'] : ['adapters', 'transport', field]);
+}
+function record(value, field) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        refuse(`transport.${field} must be an object`, field);
+    }
+    return value;
+}
+function requiredText(value, field) {
+    if (typeof value !== 'string' || value.length === 0)
+        refuse(`transport.${field} must be a non-empty string`, field);
+    return value;
+}
+function optionalText(value, field) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'string' || value.length === 0)
+        refuse(`transport.${field} must be a non-empty string`, field);
+    return value;
+}
+function whole(value, field, atLeast) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'number' || !Number.isInteger(value) || value < atLeast) {
+        refuse(`transport.${field} must be a whole number of at least ${atLeast}`, field);
+    }
+    return value;
+}
+function parseProtocol(value) {
+    if (value === undefined)
+        return 'http';
+    if (typeof value !== 'string' || !ONEBOT_PROTOCOLS.includes(value)) {
+        refuse(`transport.protocol must be one of ${ONEBOT_PROTOCOLS.join(', ')}`, 'protocol');
+    }
+    return value;
+}
+function parseListen(value, defaultPath) {
+    const raw = value === undefined ? {} : record(value, 'listen');
+    const host = optionalText(raw.host, 'listen.host') ?? '127.0.0.1';
+    assertBindHost(host, ['adapters', 'transport', 'listen', 'host']);
+    const port = whole(raw.port, 'listen.port', 0) ?? DEFAULT_ONEBOT_PORT;
+    const path = optionalText(raw.path, 'listen.path') ?? defaultPath;
+    if (!path.startsWith('/'))
+        refuse('transport.listen.path must start with "/"', 'listen.path');
+    return { host, port, path };
+}
+function parseSocketUrl(value, field) {
+    const url = requiredText(value, field);
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        refuse(`transport.${field} must be an absolute ws(s) url`, field);
+    }
+    if (parsed.protocol !== 'ws:' && parsed.protocol !== 'wss:') {
+        refuse(`transport.${field} must be an absolute ws(s) url`, field);
+    }
+    return url;
+}
+function parseReconnect(value) {
+    if (value === false)
+        return false;
+    const raw = value === undefined ? {} : record(value, 'reconnect');
+    const initialMs = whole(raw.initialMs, 'reconnect.initialMs', 1) ?? 500;
+    const maxMs = whole(raw.maxMs, 'reconnect.maxMs', 1) ?? 30_000;
+    const factor = raw.factor;
+    if (factor !== undefined && (typeof factor !== 'number' || !Number.isFinite(factor) || factor < 1)) {
+        refuse('transport.reconnect.factor must be a number of at least 1', 'reconnect.factor');
+    }
+    if (initialMs > maxMs)
+        refuse('transport.reconnect.initialMs must not exceed maxMs', 'reconnect.initialMs');
+    return { initialMs, maxMs, factor: factor ?? 2 };
+}
+function parseHeartbeat(value) {
+    if (value === undefined)
+        return undefined;
+    const raw = record(value, 'heartbeat');
+    const intervalMs = whole(raw.intervalMs, 'heartbeat.intervalMs', 0) ?? 0;
+    const timeoutMs = whole(raw.timeoutMs, 'heartbeat.timeoutMs', 1) ?? 0;
+    if (intervalMs > 0 && timeoutMs === 0) {
+        refuse('transport.heartbeat.timeoutMs is required when intervalMs is above 0', 'heartbeat.timeoutMs');
+    }
+    if (intervalMs > 0 && timeoutMs <= intervalMs) {
+        refuse('transport.heartbeat.timeoutMs must be above intervalMs', 'heartbeat.timeoutMs');
+    }
+    return { intervalMs, timeoutMs };
+}
+function parseApi(value, timeoutMs, socket) {
+    if (value === undefined)
+        refuse('transport.api is required', 'api');
+    const raw = record(value, 'api');
+    const url = requiredText(raw.url, 'api.url');
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        refuse(`transport.api.url must be an absolute ${socket ? 'ws(s)' : 'http(s)'} url`, 'api.url');
+    }
+    const allowed = socket ? ['ws:', 'wss:'] : ['http:', 'https:'];
+    if (!allowed.includes(parsed.protocol)) {
+        refuse(`transport.api.url must be an absolute ${socket ? 'ws(s)' : 'http(s)'} url`, 'api.url');
+    }
+    return { url: url.replace(/\/$/, ''), timeoutMs };
+}
+function parseHistory(value) {
+    const raw = value === undefined ? {} : record(value, 'history');
+    const unknown = Object.keys(raw).filter((key) => key !== 'group' && key !== 'private');
+    if (unknown.length > 0)
+        refuse(`transport.history names a field this adapter does not read: ${unknown.join(', ')}`, 'history');
+    const flag = (field) => {
+        const one = raw[field];
+        if (one === undefined)
+            return false;
+        if (typeof one !== 'boolean')
+            refuse(`transport.history.${field} must be true or false`, `history.${field}`);
+        return one;
+    };
+    return { group: flag('group'), private: flag('private') };
+}
+function parseFileFromUrl(value) {
+    if (value === undefined)
+        return false;
+    if (typeof value !== 'boolean')
+        refuse('transport.fileFromUrl must be true or false', 'fileFromUrl');
+    return value;
+}
+function parseBots(value) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value))
+        refuse('transport.bots must be a list of ids', 'bots');
+    return value.map((item, index) => requiredText(item, `bots[${index}]`));
+}
+/** Reads the transport block an OneBot adapter is mounted with. */
+export function parseOneBotConfig(mount) {
+    const raw = mount.transport;
+    const unknown = Object.keys(raw).filter((key) => !FIELDS.has(key));
+    if (unknown.length > 0)
+        refuse(`transport names a field this adapter does not read: ${unknown.join(', ')}`);
+    const protocol = parseProtocol(raw.protocol);
+    const sendTimeoutMs = whole(raw.sendTimeoutMs, 'sendTimeoutMs', 1) ?? DEFAULT_ONEBOT_SEND_TIMEOUT_MS;
+    const only = (field, why) => {
+        if (raw[field] !== undefined)
+            refuse(why, field);
+    };
+    let api;
+    let event;
+    let reconnect;
+    let heartbeat;
+    let listen;
+    if (protocol === 'http') {
+        only('event', 'transport.event is only read by ws-forward');
+        only('reconnect', 'transport.reconnect is only read by ws-forward');
+        only('heartbeat', 'transport.heartbeat is only read by a websocket protocol');
+        api = parseApi(raw.api, sendTimeoutMs, false);
+        listen = parseListen(raw.listen, DEFAULT_ONEBOT_PATH);
+    }
+    else if (protocol === 'ws-forward') {
+        only('listen', 'transport.listen is not read by ws-forward, which connects out');
+        api = parseApi(raw.api, sendTimeoutMs, true);
+        event = raw.event === undefined ? undefined : { url: parseSocketUrl(raw.event, 'event.url') };
+        reconnect = parseReconnect(raw.reconnect);
+        heartbeat = parseHeartbeat(raw.heartbeat);
+    }
+    else {
+        only('api', 'transport.api is not read by ws-reverse, which answers on a socket');
+        only('event', 'transport.event is only read by ws-forward');
+        only('reconnect', 'transport.reconnect is only read by ws-forward');
+        heartbeat = parseHeartbeat(raw.heartbeat);
+        listen = parseListen(raw.listen, DEFAULT_ONEBOT_WS_PATH);
+    }
+    return {
+        channel: mount.channel,
+        botName: mount.botName,
+        ...(mount.status === undefined ? {} : { status: mount.status }),
+        ...(optionalText(raw.selfId, 'selfId') === undefined ? {} : { selfId: raw.selfId }),
+        protocol,
+        ...(listen === undefined ? {} : { listen }),
+        ...(api === undefined ? {} : { api }),
+        ...(event === undefined ? {} : { event }),
+        ...(reconnect === undefined ? {} : { reconnect }),
+        ...(heartbeat === undefined ? {} : { heartbeat }),
+        sendTimeoutMs,
+        history: parseHistory(raw.history),
+        fileFromUrl: parseFileFromUrl(raw.fileFromUrl),
+        ...(optionalText(raw.accessToken, 'accessToken') === undefined ? {} : { accessToken: raw.accessToken }),
+        bots: parseBots(raw.bots),
+    };
+}
+export const createOneBotAdapter = (mount, options) => new OneBotAdapter(parseOneBotConfig(mount), options);
+const adapter = makeAdapterPlugin({
+    name: 'dsbot-channel/onebot',
+    kind: 'onebot',
+    factory: createOneBotAdapter,
+    check: parseOneBotConfig,
+});
+export const Config = adapter.Config;
+export const apply = adapter.apply;
+export const plugin = adapter.plugin;
+export default adapter.plugin;

package/dist/ws-forward.d.ts

@@ -0,0 +1,60 @@
+import type { ConnectionHealth } from '@dsbot-channel/core/adapter-status.js';
+/** Kept always on: a half-open socket is the failure that leaves no line in a log. */
+export declare const ONEBOT_PING_INTERVAL_MS = 30000;
+export declare const ONEBOT_PONG_TIMEOUT_MS = 10000;
+export interface LivenessOptions {
+    intervalMs: number;
+    timeoutMs: number;
+}
+/** The timers a link runs on; a test hands in its own so a window can be walked deterministically. */
+export interface LinkClock {
+    setTimer: (callback: () => void, ms: number) => unknown;
+    clearTimer: (handle: unknown) => void;
+}
+/** What an action call answers: the payload of a `status: ok` reply, or why none came. */
+export type ActionAnswer = {
+    ok: true;
+    frame: Record<string, unknown>;
+} | {
+    ok: false;
+    code: 'timeout' | 'unreachable' | 'rejected';
+    reason: string;
+};
+export interface ForwardOptions {
+    apiUrl: string;
+    /** The event socket; absent means events and actions share the api socket. */
+    eventUrl?: string | undefined;
+    token?: string | undefined;
+    reconnect: {
+        initialMs: number;
+        maxMs: number;
+        factor: number;
+    } | false;
+    heartbeat?: {
+        intervalMs: number;
+        timeoutMs: number;
+    } | undefined;
+    timeoutMs: number;
+    /** Protocol-level ping/pong; always on in production, shortened in tests. */
+    liveness?: LivenessOptions | undefined;
+    /** Timer source for liveness; real timers unless a test hands in its own. */
+    clock?: LinkClock | undefined;
+    maxFrameBytes: number;
+    onEvent: (frame: Record<string, unknown>) => void;
+    onMismatch: () => void;
+    warn: (message: string) => void;
+    now?: (() => number) | undefined;
+}
+/**
+ * The forward half of OneBot over WebSocket: this side dials out, sends actions with an
+ * `echo`, and reads events off the same socket or a second one.
+ */
+export declare class ForwardLink {
+    #private;
+    constructor(options: ForwardOptions);
+    start(): void;
+    close(): void;
+    health(): ConnectionHealth;
+    /** Sends one action and waits for the frame that carries its echo. */
+    request(action: string, params: Record<string, unknown>, timeoutMs: number | undefined): Promise<ActionAnswer>;
+}