@dsbot-channel/onebot 0.0.0-stage → 0.7.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 zerodegress
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/assets/skill.md

@@ -0,0 +1,26 @@
+### onebot transport
+
+| Field | Default | Meaning |
+| --- | --- | --- |
+| `protocol` | `http` | `http`, `ws-forward` or `ws-reverse`; a field of another protocol fails the mount |
+| `listen.host` | `127.0.0.1` | concrete address only |
+| `listen.port` | `7331` | |
+| `listen.path` | `/onebot/event` (`http`), `/onebot/ws` (`ws-reverse`) | |
+| `api.url` | required | `http(s)` for `http`, `ws(s)` for `ws-forward` |
+| `event.url` | same as `api.url` | `ws-forward` only; both sockets must be up for `online` |
+| `reconnect` | `{ initialMs: 500, maxMs: 30000, factor: 2 }` | `ws-forward` only; `false` keeps the link offline |
+| `heartbeat` | off | both socket protocols; `intervalMs` 0, `timeoutMs` must exceed it |
+| `accessToken` | | reference name |
+| `selfId` | from the event | a mismatched event is dropped |
+| `bots` | `[]` | ids treated as bots, not as people |
+| `sendTimeoutMs` | `10000` | |
+| `history.group` / `history.private` | `false` | allow `read_history` per address kind |
+| `fileFromUrl` | `false` | allow `send_file` from an http(s) url |
+| `events.turn` | `[]` | non-message classes that may start a turn; an adapter names its own `action.<type>` |
+
+One adapter accepts one connection in `ws-reverse`; a new connection for the same account replaces the old one. A named class is `<kind>.<type>`: OneBot's own names, or an adapter's `action.<type>`; it skips the mention requirement, and an unknown name fails the mount.
+
+An adapter whose `capabilities.outbound` is `false` is never written back: core does not call its `send` or `refuse`, and the `send_text` tool answers `unsupported` for it. Its turns still run, so a profile that lets such an adapter start turns needs a reply block that always chooses `tool`, or the mount fails.
+
+`@dsbot-channel/onebot` supplies this transport: mount it after `@dsbot-channel/core`, then write these fields under `transport` in this plugin's own `config`, beside `channel` and `botName`; `kind` is not written. Each entry is one instance, so the same package mounts twice with two different `channel` values. Without `@dsbot-channel/core` the plugin stays pending on `dsbot-channel.registry`.
+

package/cordis.patch.yml

@@ -0,0 +1,3 @@
+- insert:
+    - id: dsbot-channel-onebot
+      name: '@dsbot-channel/onebot'

package/dist/adapter.d.ts

@@ -0,0 +1,118 @@
+import type { AdapterStatus, CapabilitySet } from '@dsbot-channel/core/adapter-status.js';
+import type { ChannelSnapshot } from '@dsbot-channel/core/channel-stats.js';
+import type { AdapterHandle, AdapterPorts, ChannelAdapter, HistoryInput, HistoryResult, InboundMessage, SendInput, SendResult } from '@dsbot-channel/core/contract.js';
+import type { Scope } from '@dsbot-channel/core/event-types.js';
+export interface OneBotAdapterConfig {
+    channel: string;
+    botName: string;
+    selfId?: string;
+    /** How this link carries OneBot; the other fields below are read per protocol. */
+    protocol: 'http' | 'ws-forward' | 'ws-reverse';
+    listen?: {
+        host: string;
+        port: number;
+        path: string;
+    } | undefined;
+    api?: {
+        url: string;
+        timeoutMs: number;
+    } | undefined;
+    /** ws-forward only: the event socket; absent means events arrive on the api socket. */
+    event?: {
+        url: string;
+    } | undefined;
+    /** ws-forward only: how a dropped link comes back; false turns retrying off. */
+    reconnect?: {
+        initialMs: number;
+        maxMs: number;
+        factor: number;
+    } | false | undefined;
+    /** websocket protocols only: how long silence may last before the link is closed. */
+    heartbeat?: {
+        intervalMs: number;
+        timeoutMs: number;
+    } | undefined;
+    /** Which addresses a profile lets this link page history for; both off unless written out. */
+    history?: {
+        group: boolean;
+        private: boolean;
+    } | undefined;
+    /** Whether this implementation takes a file as an http(s) url; most only take a path on its host. */
+    fileFromUrl?: boolean | undefined;
+    sendTimeoutMs: number;
+    accessToken?: string;
+    bots: readonly string[];
+    /** Whether this adapter answers its own status route. */
+    status?: boolean | undefined;
+}
+export interface OneBotEvent {
+    post_type?: unknown;
+    message_type?: unknown;
+    sub_type?: unknown;
+    self_id?: unknown;
+    message_id?: unknown;
+    user_id?: unknown;
+    group_id?: unknown;
+    time?: unknown;
+    raw_message?: unknown;
+    message?: unknown;
+    sender?: {
+        nickname?: unknown;
+        card?: unknown;
+    };
+    notice_type?: unknown;
+    request_type?: unknown;
+    meta_event_type?: unknown;
+    operator_id?: unknown;
+    target_id?: unknown;
+    flag?: unknown;
+    comment?: unknown;
+    interval?: unknown;
+    status?: unknown;
+    file?: {
+        name?: unknown;
+        size?: unknown;
+    };
+}
+export declare const ONEBOT_PEER_GUIDANCE = "This is a private OneBot message. Answer it with your reply as usual. If it needs no answer, call no_reply instead of staying silent. If you refuse it, call decline with a short reason.";
+export declare const ONEBOT_GROUP_GUIDANCE = "This is a group message from OneBot. Your reply is posted back to that group. If it needs no answer, call no_reply; if you refuse it, call decline with a short reason.";
+export declare const ONEBOT_STATUS_ROUTE = "/onebot/status";
+export declare const ONEBOT_DEDUPE_TTL_MS: number;
+export declare const ONEBOT_DEDUPE_LIMIT = 100000;
+export declare const ONEBOT_CHAIN_TTL_MS: number;
+export declare const ONEBOT_CHAIN_LIMIT = 10000;
+export declare const ONEBOT_MAX_BODY_BYTES: number;
+export declare const ONEBOT_NOTICE_TYPES: readonly ["group_recall", "friend_recall", "group_ban", "group_lift_ban", "group_increase", "group_decrease", "group_admin", "group_upload", "group_card", "notify"];
+export declare const ONEBOT_REQUEST_TYPES: readonly ["friend", "group"];
+export declare const ONEBOT_META_TYPES: readonly ["lifecycle", "heartbeat"];
+/** The class a status counts an event under; undefined for a message, 'unknown' for a post_type we do not read. */
+export declare function oneBotEventClass(event: OneBotEvent): string | undefined;
+/** Maps one OneBot event onto the inbound message core takes; returns undefined for an event we do not read. */
+export declare function mapOneBotEvent(event: OneBotEvent, config: OneBotAdapterConfig, chainOf: (messageId: string) => string | undefined, warn?: (message: string) => void, now?: () => number): InboundMessage | undefined;
+/** The OneBot 11 transport: events arrive over reverse HTTP, replies call the implementation's HTTP API. */
+export declare class OneBotAdapter implements ChannelAdapter {
+    #private;
+    readonly kind = "onebot";
+    readonly guidance: {
+        peer: string;
+        group: string;
+    };
+    readonly capabilities: CapabilitySet;
+    constructor(config: OneBotAdapterConfig, options?: {
+        warn?: (message: string) => void;
+        now?: () => number;
+    });
+    get snapshot(): ChannelSnapshot;
+    checkConfig(): void;
+    sessionScope(key: string): Scope | undefined;
+    checkSessionKey(key: string): string | undefined;
+    checkTarget(target: string): string | undefined;
+    describeTargets(): string;
+    status(): AdapterStatus;
+    send(input: SendInput): Promise<SendResult>;
+    /** Pages earlier messages through the implementation's history API. */
+    history(input: HistoryInput): Promise<HistoryResult>;
+    start(ports: AdapterPorts): Promise<AdapterHandle>;
+    /** Stops the listener without going through the handle, for tests and for a failed mount. */
+    stop(): Promise<void>;
+}