koishi-plugin-cnb-bot 0.1.0

package/lib/storage.d.ts

@@ -0,0 +1,24 @@
+import type { Report, Scope, Status } from './types';
+export declare function extendModel(ctx: any): void;
+export declare class ReportStore {
+    private db;
+    constructor(db: any);
+    private decode;
+    private encode;
+    get(id: string): Promise<Report | undefined>;
+    all(): Promise<Report[]>;
+    findActive(scope: Scope): Promise<Report | undefined>;
+    findWaiting(scope: Scope): Promise<Report | undefined>;
+    findCurrent(scope: Scope): Promise<Report | undefined>;
+    create(task: Report): Promise<boolean>;
+    claimLog(task: Report): Promise<boolean>;
+    update(id: string, patch?: Record<string, any>, status?: undefined, releaseActive?: boolean, expected?: Status[]): Promise<Report | undefined>;
+    update(id: string, patch: Record<string, any>, status: Status, releaseActive: boolean, expected: Status[]): Promise<Report | undefined>;
+    transition(id: string, status: Status, expected: Status[], patch?: Record<string, any>, releaseActive?: boolean): Promise<Report | undefined>;
+    transitionAtRevision(id: string, status: Status, expected: Status[], revision: number, patch?: Record<string, any>, releaseActive?: boolean): Promise<Report | undefined>;
+    private write;
+    listActive(): Promise<Report[]>;
+    remove(id: string): Promise<void>;
+    prune(before: number): Promise<void>;
+}
+export declare function activeKey(scope: Scope): string;

package/lib/storage.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReportStore = void 0;
+exports.extendModel = extendModel;
+exports.activeKey = activeKey;
+const TABLE = 'cnb_report_tasks';
+const ACTIVE = new Set([
+    'WAITING_LOG', 'PREPARING_LOG', 'CREATING_ISSUE', 'TRIGGERING_NPC',
+    'WAITING_NPC', 'DELIVERING', 'AWAITING_RECOVERY', 'CLOSING_ISSUE', 'UNCERTAIN',
+]);
+const INDEX_FIELDS = new Set([
+    'id', 'active_key', 'status', 'platform', 'bot_id', 'guild_id', 'channel_id',
+    'user_id', 'direct', 'created_at', 'updated_at', 'deadline', 'revision',
+]);
+function extendModel(ctx) {
+    ctx.model.extend(TABLE, {
+        id: { type: 'string', length: 36 },
+        active_key: { type: 'string', length: 768, nullable: true },
+        status: { type: 'string', length: 32 },
+        platform: { type: 'string', length: 64 },
+        bot_id: { type: 'string', length: 128 },
+        guild_id: { type: 'string', length: 256 },
+        channel_id: { type: 'string', length: 256 },
+        user_id: { type: 'string', length: 256 },
+        direct: 'boolean',
+        created_at: 'double',
+        updated_at: 'double',
+        deadline: 'double',
+        revision: { type: 'unsigned', initial: 0 },
+        payload: 'json',
+    }, { primary: 'id', autoInc: false, unique: ['active_key'] });
+}
+class ReportStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    decode(row) {
+        const payload = row?.payload && typeof row.payload === 'object' ? row.payload : {};
+        return { ...payload, ...row, payload: undefined };
+    }
+    encode(task) {
+        const payload = {};
+        for (const [key, value] of Object.entries(task)) {
+            if (!INDEX_FIELDS.has(key) && value !== undefined)
+                payload[key] = value;
+        }
+        return {
+            id: task.id,
+            active_key: task.active_key ?? null,
+            status: task.status,
+            platform: task.platform,
+            bot_id: task.bot_id,
+            guild_id: task.guild_id ?? '',
+            channel_id: task.channel_id,
+            user_id: task.user_id,
+            direct: !!task.direct,
+            created_at: task.created_at,
+            updated_at: task.updated_at,
+            deadline: task.deadline,
+            revision: Number(task.revision || 0),
+            payload,
+        };
+    }
+    async get(id) {
+        const [row] = await this.db.get(TABLE, { id });
+        return row ? this.decode(row) : undefined;
+    }
+    async all() {
+        return (await this.db.get(TABLE, {})).map((row) => this.decode(row));
+    }
+    async findActive(scope) {
+        const key = activeKey(scope);
+        const [row] = await this.db.get(TABLE, { active_key: key });
+        return row ? this.decode(row) : undefined;
+    }
+    async findWaiting(scope) {
+        const task = await this.findActive(scope);
+        return task?.status === 'WAITING_LOG' ? task : undefined;
+    }
+    async findCurrent(scope) {
+        const active = await this.findActive(scope);
+        if (active)
+            return active;
+        const rows = await this.db.get(TABLE, {
+            platform: scope.platform,
+            bot_id: scope.bot_id,
+            guild_id: scope.guild_id,
+            user_id: scope.user_id,
+        }, { sort: { created_at: 'desc' }, limit: 1 });
+        return rows[0] ? this.decode(rows[0]) : undefined;
+    }
+    async create(task) {
+        try {
+            await this.db.create(TABLE, this.encode(task));
+            return true;
+        }
+        catch (error) {
+            // The unique active_key index arbitrates simultaneous debug requests.
+            return false;
+        }
+    }
+    async claimLog(task) {
+        return !!(await this.transition(task.id, 'PREPARING_LOG', ['WAITING_LOG']));
+    }
+    async update(id, patch = {}, status, releaseActive = false, expected) {
+        return (await this.write(id, patch, status, releaseActive, expected)).task;
+    }
+    async transition(id, status, expected, patch = {}, releaseActive = false) {
+        const result = await this.write(id, patch, status, releaseActive, expected);
+        return result.applied ? result.task : undefined;
+    }
+    async transitionAtRevision(id, status, expected, revision, patch = {}, releaseActive = false) {
+        const result = await this.write(id, patch, status, releaseActive, expected, revision);
+        return result.applied ? result.task : undefined;
+    }
+    async write(id, patch, status, releaseActive, expected, expectedRevision) {
+        for (let attempt = 0; attempt < 8; attempt++) {
+            const current = await this.get(id);
+            if (!current)
+                return { applied: false };
+            if (expected && !expected.includes(current.status))
+                return { task: current, applied: false };
+            if (status && status !== current.status && !expected) {
+                return { task: current, applied: false };
+            }
+            const revision = Number(current.revision || 0);
+            if (expectedRevision !== undefined && revision !== expectedRevision) {
+                return { task: current, applied: false };
+            }
+            const next = { ...current, ...patch, status: status ?? current.status };
+            if (releaseActive)
+                next.active_key = null;
+            next.updated_at = Date.now() / 1000;
+            next.revision = revision + 1;
+            const query = { id, revision };
+            if (expected)
+                query.status = { $in: expected };
+            // Minato forbids including a primary key in an update, even unchanged.
+            const { id: _id, ...update } = this.encode(next);
+            const result = await this.db.set(TABLE, query, update);
+            if (result?.matched)
+                return { task: await this.get(id), applied: true };
+            // A concurrent write changed the record after the read. Retry ordinary
+            // patches against the latest row; guarded transitions stop on a mismatch.
+            const latest = await this.get(id);
+            if (!latest || (expected && !expected.includes(latest.status))
+                || (expectedRevision !== undefined && Number(latest.revision || 0) !== expectedRevision)) {
+                return { task: latest, applied: false };
+            }
+        }
+        return { task: await this.get(id), applied: false };
+    }
+    async listActive() {
+        return (await this.all()).filter(task => ACTIVE.has(task.status));
+    }
+    async remove(id) {
+        await this.db.remove(TABLE, { id });
+    }
+    async prune(before) {
+        const terminal = new Set(['DONE', 'EXPIRED', 'CANCELLED', 'FAILED']);
+        for (const task of await this.all()) {
+            if (!task.active_key && terminal.has(task.status) && task.updated_at < before) {
+                await this.remove(task.id);
+            }
+        }
+    }
+}
+exports.ReportStore = ReportStore;
+function activeKey(scope) {
+    return [scope.platform, scope.bot_id, scope.guild_id, scope.user_id].join(':');
+}

package/lib/types.d.ts

@@ -0,0 +1,49 @@
+export interface Config {
+    group_whitelist: string[];
+    private_whitelist: string[];
+    reply_in_disabled_groups: boolean;
+    cnb_repository: string;
+    cnb_token: string;
+    cnb_api_endpoint: string;
+    cnb_web_endpoint: string;
+    npc_mention: string;
+    npc_author_ids: string[];
+    npc_author_usernames: string[];
+    assistant_name: string;
+    log_location_hint: string;
+    log_wait_minutes: number;
+    analysis_wait_minutes: number;
+    recovery_confirm_minutes: number;
+    max_log_file_mib: number;
+    poll_interval_seconds: number;
+    issue_check_interval_seconds: number;
+    delivery_send_timeout_seconds: number;
+    max_delivery_attempts: number;
+    file_url_host_allowlist: string[];
+    history_retention_days: number;
+}
+export interface Scope {
+    platform: string;
+    bot_id: string;
+    guild_id: string;
+    channel_id: string;
+    user_id: string;
+    direct: boolean;
+}
+export type Status = 'WAITING_LOG' | 'PREPARING_LOG' | 'CREATING_ISSUE' | 'TRIGGERING_NPC' | 'WAITING_NPC' | 'DELIVERING' | 'AWAITING_RECOVERY' | 'CLOSING_ISSUE' | 'UNCERTAIN' | 'DONE' | 'EXPIRED' | 'CANCELLED' | 'FAILED';
+export interface Report {
+    id: string;
+    active_key: string | null;
+    status: Status;
+    platform: string;
+    bot_id: string;
+    guild_id: string;
+    channel_id: string;
+    user_id: string;
+    direct: boolean;
+    created_at: number;
+    updated_at: number;
+    deadline: number;
+    revision?: number;
+    [key: string]: any;
+}

package/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "koishi-plugin-cnb-bot",
+  "version": "0.1.0",
+  "description": "Koishi plugin for submitting diagnostic logs to CNB Issues and relaying NPC analysis.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/HarcoChen/cnb-bot-koishi.git"
+  },
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "lib",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepare": "npm run build",
+    "pack:check": "node scripts/check-package.cjs"
+  },
+  "keywords": [
+    "koishi",
+    "cnb",
+    "qq",
+    "debug",
+    "issue"
+  ],
+  "peerDependencies": {
+    "koishi": "^4.18.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "koishi": "^4.18.0",
+    "typescript": "^5.6.0"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "koishi": {
+    "service": {
+      "required": ["database"]
+    }
+  }
+}