koishi-plugin-argus 0.1.0

package/lib/blur.d.ts

@@ -0,0 +1,11 @@
+export type BlurMode = 'gaussian' | 'fast';
+export interface BlurOptions {
+    /** 模糊半径，越大越糊。 */
+    radius: number;
+    /** 模糊算法。`gaussian` 质量好但慢；`fast` 用 jimp.blur，速度快。 */
+    mode?: BlurMode;
+}
+/**
+ * 加载任意常见格式（png/jpg/webp 等）的图片，应用模糊后输出 PNG buffer。
+ */
+export declare function blurImage(input: Buffer, options: BlurOptions): Promise<Buffer>;

package/lib/cache.d.ts

@@ -0,0 +1,27 @@
+import type { PeekBusyFrame } from './types';
+/**
+ * 缓存一次 peek 的响应（图片 buffer 或 busy 状态）。
+ * 在 cacheDuration 内对同一 (client, display) 的命令调用直接复用。
+ */
+export interface CachedPeek {
+    cachedAt: number;
+    expiresAt: number;
+    /** 已经过模糊处理的最终 PNG buffer，busy 时为空。 */
+    image?: Buffer;
+    /** busy 状态：客户端在玩游戏 / 全屏。 */
+    busy?: PeekBusyFrame;
+}
+export declare class PeekCache {
+    private duration;
+    private store;
+    private timers;
+    constructor(duration: number);
+    setDuration(duration: number): void;
+    /** key 形如 `client::display`。display 缺省用 'default'。 */
+    static key(client: string, display?: number | string): string;
+    get(key: string): CachedPeek | undefined;
+    set(key: string, entry: Omit<CachedPeek, 'cachedAt' | 'expiresAt'>): void;
+    delete(key: string): void;
+    clear(): void;
+}
+export declare function formatRemaining(ms: number): string;

package/lib/commands.d.ts

@@ -0,0 +1,5 @@
+import { Context } from 'koishi';
+import type { ArgusServer } from './server';
+import type { Config } from '.';
+import { PeekCache } from './cache';
+export declare function applyCommands(ctx: Context, server: ArgusServer, config: Config, cache: PeekCache): import("koishi").Command<never, never, [string, ...string[]], import("koishi").Extend<import("koishi").Extend<import("koishi").Extend<import("koishi").Extend<{}, "display", number>, "blur", number>, "list", boolean>, "force", boolean>>;

package/lib/index.cjs

@@ -0,0 +1,624 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/locales/zh-CN.schema.yml
+var require_zh_CN_schema = __commonJS({
+  "src/locales/zh-CN.schema.yml"(exports2, module2) {
+    module2.exports = { $desc: "Argus 配置", $inner: { path: "WebSocket 服务挂载路径，必须以 / 开头。", token: "客户端鉴权 token；为空时所有连接都会被拒绝。", commandName: "主命令名（例如 peek、spy、look）。", blur: "默认模糊半径，越大越糊（0 = 不模糊）。", blurMode: { $desc: "模糊算法", $inner: ["高斯模糊（质量好，但慢）", "快速模糊（jimp.blur，速度快）"] }, minBlur: "命令里 -b 临时调小模糊时不可低于此值，防止裸奔。", maxImageBytes: "单张截图大小上限（字节）。", timeout: "等待客户端响应的超时（毫秒）。", cacheDuration: "截图缓存时长（毫秒）。在此期间内同一客户端 + 显示器的反复调用会直接返回缓存的图。设为 0 关闭缓存。默认 5 分钟。", registerAlias: "是否给每个连进来的客户端自动注册同名命令作为别名。", authority: "命令所需的最低权限等级。", forceAuthority: "使用 -f / --force 绕过缓存所需的最低权限等级。" } };
+  }
+});
+
+// src/locales/en-US.schema.yml
+var require_en_US_schema = __commonJS({
+  "src/locales/en-US.schema.yml"(exports2, module2) {
+    module2.exports = { $desc: "Argus configuration", $inner: { path: "WebSocket mount path; must start with /.", token: "Auth token for clients; if empty all connections are rejected.", commandName: "Top-level command name (e.g. peek, spy, look).", blur: "Default blur radius; larger means blurrier (0 disables blur).", blurMode: { $desc: "Blur algorithm", $inner: ["Gaussian blur (better quality, slower)", "Fast blur (jimp.blur, faster)"] }, minBlur: "Lower bound for the temporary -b override, to prevent unblurred captures.", maxImageBytes: "Max screenshot size in bytes.", timeout: "Timeout (ms) waiting for a client response.", cacheDuration: "Screenshot cache duration in ms. Repeated calls within this window for the same client+display reuse the cached image. Set to 0 to disable. Default 5 minutes.", registerAlias: "Whether to register each connected client's name as a command alias.", authority: "Minimum authority level required to run the command.", forceAuthority: "Minimum authority level required to use -f / --force to bypass the cache." } };
+  }
+});
+
+// src/locales/zh-CN.yml
+var require_zh_CN = __commonJS({
+  "src/locales/zh-CN.yml"(exports2, module2) {
+    module2.exports = { commands: { peek: { description: "偷窥已连接客户端的电脑屏幕。", usage: "peek [name] [-d display] [-b blur] [-f] [--list]", examples: "peek\npeek dingyi\npeek dingyi -d 1\npeek dingyi -b 80\npeek dingyi -f\npeek --list", options: { display: "指定客户端的显示器编号。", blur: "临时调整模糊半径，不能低于配置中的 minBlur。", list: "列出当前在线的客户端。", force: "绕过缓存强制重新截图（需要 forceAuthority）。" }, messages: { "no-clients": "当前没有任何客户端在线。", "multiple-clients": "当前有多个客户端在线，请指定名称：{0}", "client-offline": "客户端「{0}」未在线。", timeout: "客户端「{0}」响应超时。", "image-too-large": "截图体积超过限制。", failed: "截图失败：{0}", "list-header": "当前在线客户端 ({0})：", busy: "客户端「{0}」正忙：{1}", "cache-note": "（缓存，剩余 {0}）" } } } };
+  }
+});
+
+// src/locales/en-US.yml
+var require_en_US = __commonJS({
+  "src/locales/en-US.yml"(exports2, module2) {
+    module2.exports = { commands: { peek: { description: "Peek at a connected client's screen.", usage: "peek [name] [-d display] [-b blur] [-f] [--list]", examples: "peek\npeek dingyi\npeek dingyi -d 1\npeek dingyi -b 80\npeek dingyi -f\npeek --list", options: { display: "Display index on the client.", blur: "Override blur radius (must be >= configured minBlur).", list: "List currently connected clients.", force: "Bypass the cache (requires forceAuthority)." }, messages: { "no-clients": "No clients are connected.", "multiple-clients": "Multiple clients online, please specify: {0}", "client-offline": 'Client "{0}" is not connected.', timeout: 'Client "{0}" timed out.', "image-too-large": "Screenshot size exceeded the limit.", failed: "Capture failed: {0}", "list-header": "Connected clients ({0}):", busy: 'Client "{0}" is busy: {1}', "cache-note": "(cached, {0} left)" } } } };
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Config: () => Config,
+  apply: () => apply,
+  inject: () => inject,
+  name: () => name
+});
+module.exports = __toCommonJS(index_exports);
+var import_koishi2 = require("koishi");
+
+// src/server.ts
+var HEARTBEAT_INTERVAL = 3e4;
+var HEARTBEAT_TIMEOUT = HEARTBEAT_INTERVAL * 3;
+var ArgusServer = class {
+  constructor(ctx, config) {
+    this.ctx = ctx;
+    this.config = config;
+    this.mount();
+  }
+  static {
+    __name(this, "ArgusServer");
+  }
+  /** name → client */
+  clients = /* @__PURE__ */ new Map();
+  listClients() {
+    return [...this.clients.values()];
+  }
+  getClient(name2) {
+    return this.clients.get(name2);
+  }
+  /**
+   * 派发一次截图请求并等待结果。可能返回图片或“客户端忙”。
+   */
+  async peek(name2, options = {}) {
+    const client = this.clients.get(name2);
+    if (!client) throw new Error(`client_offline:${name2}`);
+    const id = randomId();
+    const frame = {
+      type: "peek",
+      id,
+      display: options.display
+    };
+    return await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        client.pending.delete(id);
+        reject(new Error("timeout"));
+      }, this.config.timeout);
+      client.pending.set(id, { resolve, reject, timer });
+      try {
+        this.send(client.socket, frame);
+      } catch (err) {
+        clearTimeout(timer);
+        client.pending.delete(id);
+        reject(
+          err instanceof Error ? err : new Error(String(err))
+        );
+      }
+    });
+  }
+  mount() {
+    const layer = this.ctx.server.ws(
+      this.config.path,
+      (socket, req) => this.handleConnection(socket, req)
+    );
+    this.ctx.on("dispose", () => {
+      for (const client of this.clients.values()) {
+        this.cleanup(client, "plugin_dispose");
+      }
+      this.clients.clear();
+      layer.close();
+    });
+  }
+  handleConnection(socket, _req) {
+    let client;
+    const helloTimer = setTimeout(() => {
+      if (!client) {
+        this.send(socket, {
+          type: "hello_ack",
+          ok: false,
+          error: "hello_timeout"
+        });
+        socket.close(4002, "hello_timeout");
+      }
+    }, 1e4);
+    socket.on("message", (raw, isBinary) => {
+      if (isBinary) return;
+      const text = typeof raw === "string" ? raw : raw.toString("utf8");
+      if (text.length > 4 * 1024 * 1024) {
+        socket.close(1009, "message_too_large");
+        return;
+      }
+      let frame;
+      try {
+        frame = JSON.parse(text);
+      } catch {
+        socket.close(1003, "invalid_json");
+        return;
+      }
+      if (!client) {
+        if (frame.type !== "hello") {
+          socket.close(4003, "expect_hello");
+          return;
+        }
+        clearTimeout(helloTimer);
+        client = this.handleHello(socket, frame);
+        return;
+      }
+      client.lastSeen = Date.now();
+      this.handleAuthedFrame(client, frame);
+    });
+    socket.on("close", () => {
+      clearTimeout(helloTimer);
+      if (client) this.cleanup(client, "socket_close");
+    });
+    socket.on("error", (err) => {
+      this.ctx.logger.warn("argus socket error: %s", err.message);
+    });
+  }
+  handleHello(socket, frame) {
+    if (!frame.token || frame.token !== this.config.token) {
+      this.send(socket, {
+        type: "hello_ack",
+        ok: false,
+        error: "auth_failed"
+      });
+      socket.close(4001, "auth_failed");
+      return void 0;
+    }
+    const name2 = (frame.name || "").trim();
+    if (!name2 || !/^[a-zA-Z0-9_\-.]{1,32}$/.test(name2)) {
+      this.send(socket, {
+        type: "hello_ack",
+        ok: false,
+        error: "invalid_name"
+      });
+      socket.close(4004, "invalid_name");
+      return void 0;
+    }
+    const old = this.clients.get(name2);
+    if (old) this.cleanup(old, "replaced");
+    const client = {
+      name: name2,
+      socket,
+      version: frame.version,
+      displays: frame.displays ?? [],
+      defaultDisplay: frame.defaultDisplay,
+      connectedAt: Date.now(),
+      pending: /* @__PURE__ */ new Map(),
+      lastSeen: Date.now()
+    };
+    client.heartbeatTimer = setInterval(() => {
+      const now = Date.now();
+      if (now - client.lastSeen > HEARTBEAT_TIMEOUT) {
+        this.ctx.logger.info(
+          "argus client %s heartbeat lost",
+          client.name
+        );
+        socket.close(4005, "heartbeat_lost");
+        return;
+      }
+      this.send(socket, { type: "ping", t: now });
+    }, HEARTBEAT_INTERVAL);
+    this.clients.set(name2, client);
+    this.send(socket, { type: "hello_ack", ok: true });
+    this.ctx.logger.info(
+      "argus client connected: %s (displays=%d)",
+      name2,
+      client.displays.length
+    );
+    this.config.onClientChange?.({ type: "connect", name: name2 });
+    return client;
+  }
+  handleAuthedFrame(client, frame) {
+    switch (frame.type) {
+      case "peek_result": {
+        const pending = client.pending.get(frame.id);
+        if (!pending) return;
+        clearTimeout(pending.timer);
+        client.pending.delete(frame.id);
+        const size = (frame.image?.length ?? 0) * 0.75;
+        if (size > this.config.maxImageBytes) {
+          pending.reject(new Error("image_too_large"));
+          return;
+        }
+        pending.resolve({ kind: "image", frame });
+        return;
+      }
+      case "peek_busy": {
+        const pending = client.pending.get(frame.id);
+        if (!pending) return;
+        clearTimeout(pending.timer);
+        client.pending.delete(frame.id);
+        pending.resolve({ kind: "busy", frame });
+        return;
+      }
+      case "peek_error": {
+        const pending = client.pending.get(frame.id);
+        if (!pending) return;
+        clearTimeout(pending.timer);
+        client.pending.delete(frame.id);
+        pending.reject(new Error(frame.error || "client_error"));
+        return;
+      }
+      case "ping":
+        this.send(client.socket, { type: "pong", t: frame.t });
+        return;
+      case "pong":
+        return;
+      case "bye":
+        client.socket.close(1e3, frame.reason || "bye");
+        return;
+      case "hello":
+        return;
+    }
+  }
+  cleanup(client, reason) {
+    if (client.heartbeatTimer) clearInterval(client.heartbeatTimer);
+    for (const pending of client.pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error(`disconnected:${reason}`));
+    }
+    client.pending.clear();
+    if (this.clients.get(client.name) === client) {
+      this.clients.delete(client.name);
+      this.ctx.logger.info(
+        "argus client disconnected: %s (%s)",
+        client.name,
+        reason
+      );
+      this.config.onClientChange?.({
+        type: "disconnect",
+        name: client.name
+      });
+    }
+    try {
+      if (client.socket.readyState === client.socket.OPEN || client.socket.readyState === client.socket.CONNECTING) {
+        client.socket.close(1e3, reason);
+      }
+    } catch {
+    }
+  }
+  send(socket, frame) {
+    if (socket.readyState !== socket.OPEN) return;
+    socket.send(JSON.stringify(frame));
+  }
+};
+function randomId() {
+  return Math.random().toString(36).slice(2, 10);
+}
+__name(randomId, "randomId");
+
+// src/commands.ts
+var import_koishi = require("koishi");
+
+// src/blur.ts
+var import_core = require("@jimp/core");
+var import_jimp = require("jimp");
+var Jimp = (0, import_core.createJimp)({
+  formats: [...import_jimp.defaultFormats],
+  plugins: import_jimp.defaultPlugins
+});
+async function blurImage(input, options) {
+  const radius = clamp(Math.round(options.radius), 0, 200);
+  const image = await Jimp.read(input);
+  if (radius > 0) {
+    if (options.mode === "gaussian") {
+      const r = Math.max(1, Math.min(10, Math.round(radius / 20)));
+      image.gaussian(r);
+    } else {
+      const r = Math.max(1, Math.min(100, radius));
+      image.blur(r);
+    }
+  }
+  return await image.getBuffer("image/png");
+}
+__name(blurImage, "blurImage");
+function clamp(v, min, max) {
+  return Math.max(min, Math.min(max, v));
+}
+__name(clamp, "clamp");
+
+// src/cache.ts
+var PeekCache = class {
+  constructor(duration) {
+    this.duration = duration;
+  }
+  static {
+    __name(this, "PeekCache");
+  }
+  store = /* @__PURE__ */ new Map();
+  timers = /* @__PURE__ */ new Map();
+  setDuration(duration) {
+    this.duration = duration;
+  }
+  /** key 形如 `client::display`。display 缺省用 'default'。 */
+  static key(client, display) {
+    return `${client}::${display ?? "default"}`;
+  }
+  get(key) {
+    const entry = this.store.get(key);
+    if (!entry) return void 0;
+    if (Date.now() >= entry.expiresAt) {
+      this.delete(key);
+      return void 0;
+    }
+    return entry;
+  }
+  set(key, entry) {
+    if (this.duration <= 0) return;
+    this.delete(key);
+    const cachedAt = Date.now();
+    const full = {
+      ...entry,
+      cachedAt,
+      expiresAt: cachedAt + this.duration
+    };
+    this.store.set(key, full);
+    const timer = setTimeout(() => this.delete(key), this.duration);
+    this.timers.set(key, timer);
+  }
+  delete(key) {
+    this.store.delete(key);
+    const timer = this.timers.get(key);
+    if (timer) {
+      clearTimeout(timer);
+      this.timers.delete(key);
+    }
+  }
+  clear() {
+    for (const timer of this.timers.values()) clearTimeout(timer);
+    this.timers.clear();
+    this.store.clear();
+  }
+};
+function formatRemaining(ms) {
+  const sec = Math.max(0, Math.ceil(ms / 1e3));
+  if (sec < 60) return `${sec}s`;
+  const minutes = Math.floor(sec / 60);
+  const seconds = sec % 60;
+  if (seconds === 0) return `${minutes}m`;
+  return `${minutes}m${seconds}s`;
+}
+__name(formatRemaining, "formatRemaining");
+
+// src/commands.ts
+function applyCommands(ctx, server, config, cache) {
+  const cmd = ctx.command(
+    `${config.commandName} [name:string]`,
+    { authority: config.authority }
+  ).option("display", "-d <id:number>").option("blur", "-b <radius:number>").option("list", "-l, --list").option("force", "-f, --force", { authority: config.forceAuthority }).action(async ({ session, options }, name2) => {
+    if (!session) return;
+    const opts = options;
+    if (opts.list) {
+      return formatClientList(server, session);
+    }
+    const clients = server.listClients();
+    if (clients.length === 0) {
+      return session.text(".no-clients");
+    }
+    let target = name2?.trim();
+    if (!target) {
+      if (clients.length === 1) {
+        target = clients[0].name;
+      } else {
+        return session.text(".multiple-clients", [
+          clients.map((c) => c.name).join(", ")
+        ]);
+      }
+    }
+    const client = server.getClient(target);
+    if (!client) {
+      return session.text(".client-offline", [target]);
+    }
+    const radius = clamp2(
+      opts.blur ?? config.blur,
+      config.minBlur,
+      200
+    );
+    const cacheKey = PeekCache.key(client.name, opts.display);
+    const cached = !opts.force ? cache.get(cacheKey) : void 0;
+    const cacheUsable = cached && (opts.blur === void 0 || opts.blur === config.blur);
+    if (cacheUsable && cached) {
+      if (cached.busy) {
+        return formatBusy(session, client.name, cached.busy, cached);
+      }
+      if (cached.image) {
+        return [
+          import_koishi.h.image(cached.image, "image/png"),
+          formatCacheNote(session, cached)
+        ];
+      }
+    }
+    try {
+      const response = await server.peek(client.name, {
+        display: opts.display
+      });
+      if (response.kind === "busy") {
+        cache.set(cacheKey, { busy: response.frame });
+        return formatBusy(session, client.name, response.frame);
+      }
+      const buffer = Buffer.from(response.frame.image, "base64");
+      const output = await blurImage(buffer, {
+        radius,
+        mode: config.blurMode
+      });
+      if (opts.blur === void 0 || opts.blur === config.blur) {
+        cache.set(cacheKey, { image: output });
+      }
+      return import_koishi.h.image(output, "image/png");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      ctx.logger.warn(
+        "argus peek failed for %s: %s",
+        client.name,
+        message
+      );
+      if (message === "timeout") {
+        return session.text(".timeout", [client.name]);
+      }
+      if (message === "image_too_large") {
+        return session.text(".image-too-large");
+      }
+      if (message.startsWith("disconnected:")) {
+        return session.text(".client-offline", [client.name]);
+      }
+      return session.text(".failed", [message]);
+    }
+  });
+  if (config.registerAlias) {
+    const disposers = /* @__PURE__ */ new Map();
+    const register = /* @__PURE__ */ __name((name2) => {
+      if (!isSafeAlias(name2)) return;
+      if (disposers.has(name2)) return;
+      if (ctx.$commander.get(name2)) return;
+      const sub = ctx.command(`${name2}`, { authority: config.authority }).option("display", "-d <id:number>").option("blur", "-b <radius:number>").option("force", "-f, --force", { authority: config.forceAuthority }).action(async ({ session, options }) => {
+        if (!session) return;
+        const opts = options;
+        const parts = [config.commandName, name2];
+        if (opts.display !== void 0) {
+          parts.push("-d", String(opts.display));
+        }
+        if (opts.blur !== void 0) {
+          parts.push("-b", String(opts.blur));
+        }
+        if (opts.force) parts.push("-f");
+        return await session.execute(parts.join(" "));
+      });
+      disposers.set(name2, () => sub.dispose());
+    }, "register");
+    const unregister = /* @__PURE__ */ __name((name2) => {
+      const dispose = disposers.get(name2);
+      if (dispose) {
+        dispose();
+        disposers.delete(name2);
+      }
+    }, "unregister");
+    for (const client of server.listClients()) register(client.name);
+    ctx.on("argus/client-connect", register);
+    ctx.on("argus/client-disconnect", (name2) => {
+      unregister(name2);
+      for (const display of [void 0, ...range(0, 16)]) {
+        cache.delete(PeekCache.key(name2, display));
+      }
+    });
+    ctx.on("dispose", () => {
+      for (const dispose of disposers.values()) dispose();
+      disposers.clear();
+    });
+  }
+  return cmd;
+}
+__name(applyCommands, "applyCommands");
+function formatClientList(server, session) {
+  const clients = server.listClients();
+  if (clients.length === 0) return session.text(".no-clients");
+  const lines = clients.map((c) => {
+    const displays = c.displays.length ? c.displays.map((d) => {
+      const label = d.name ?? `display-${d.id}`;
+      const size = d.width && d.height ? ` ${d.width}x${d.height}` : "";
+      const star = d.id === c.defaultDisplay ? "*" : "";
+      return `${star}${d.id}:${label}${size}`;
+    }).join(", ") : "-";
+    return `· ${c.name} [${displays}]`;
+  });
+  return session.text(".list-header", [clients.length]) + "\n" + lines.join("\n");
+}
+__name(formatClientList, "formatClientList");
+function formatBusy(session, clientName, busy, cached) {
+  const app = busy.app || busy.title || "unknown app";
+  const note = cached ? " " + session.text(".cache-note", [
+    formatRemaining(cached.expiresAt - Date.now())
+  ]) : "";
+  return session.text(".busy", [clientName, app]) + note;
+}
+__name(formatBusy, "formatBusy");
+function formatCacheNote(session, cached) {
+  return session.text(".cache-note", [
+    formatRemaining(cached.expiresAt - Date.now())
+  ]);
+}
+__name(formatCacheNote, "formatCacheNote");
+function clamp2(v, min, max) {
+  return Math.max(min, Math.min(max, v));
+}
+__name(clamp2, "clamp");
+function isSafeAlias(name2) {
+  return /^[a-zA-Z][a-zA-Z0-9_-]{0,31}$/.test(name2);
+}
+__name(isSafeAlias, "isSafeAlias");
+function range(start, end) {
+  const out = [];
+  for (let i = start; i < end; i++) out.push(i);
+  return out;
+}
+__name(range, "range");
+
+// src/index.ts
+var name = "argus";
+var inject = ["server"];
+var Config = import_koishi2.Schema.object({
+  path: import_koishi2.Schema.string().default("/argus"),
+  token: import_koishi2.Schema.string().role("secret").default(""),
+  commandName: import_koishi2.Schema.string().default("peek"),
+  blur: import_koishi2.Schema.natural().min(0).max(200).default(40),
+  blurMode: import_koishi2.Schema.union(["gaussian", "fast"]).default("fast"),
+  minBlur: import_koishi2.Schema.natural().min(0).max(200).default(10),
+  maxImageBytes: import_koishi2.Schema.natural().default(8 * 1024 * 1024),
+  timeout: import_koishi2.Schema.natural().default(15e3),
+  cacheDuration: import_koishi2.Schema.natural().default(5 * 60 * 1e3),
+  registerAlias: import_koishi2.Schema.boolean().default(true),
+  authority: import_koishi2.Schema.natural().default(1),
+  forceAuthority: import_koishi2.Schema.natural().default(3)
+}).i18n({
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  "zh-CN": require_zh_CN_schema(),
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  "en-US": require_en_US_schema()
+});
+function apply(ctx, config) {
+  ctx.i18n.define("zh-CN", require_zh_CN());
+  ctx.i18n.define("en-US", require_en_US());
+  if (!config.token) {
+    ctx.logger.warn(
+      "token 未配置，所有客户端连接都会被拒绝。请在配置中设置 token。"
+    );
+  }
+  const cache = new PeekCache(config.cacheDuration);
+  const server = new ArgusServer(ctx, {
+    path: config.path,
+    token: config.token,
+    timeout: config.timeout,
+    maxImageBytes: config.maxImageBytes,
+    onClientChange: /* @__PURE__ */ __name((event) => {
+      if (event.type === "connect") {
+        ctx.emit("argus/client-connect", event.name);
+      } else {
+        ctx.emit("argus/client-disconnect", event.name);
+      }
+    }, "onClientChange")
+  });
+  applyCommands(ctx, server, config, cache);
+  ctx.on("dispose", () => {
+    cache.clear();
+  });
+}
+__name(apply, "apply");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  apply,
+  inject,
+  name
+});

package/lib/index.d.ts

@@ -0,0 +1,26 @@
+import { Context, Schema } from 'koishi';
+import type { BlurMode } from './blur';
+export declare const name = "argus";
+export declare const inject: string[];
+export interface Config {
+    path: string;
+    token: string;
+    commandName: string;
+    blur: number;
+    blurMode: BlurMode;
+    minBlur: number;
+    maxImageBytes: number;
+    timeout: number;
+    cacheDuration: number;
+    registerAlias: boolean;
+    authority: number;
+    forceAuthority: number;
+}
+export declare const Config: Schema<Config>;
+declare module 'koishi' {
+    interface Events {
+        'argus/client-connect'(name: string): void;
+        'argus/client-disconnect'(name: string): void;
+    }
+}
+export declare function apply(ctx: Context, config: Config): void;