koishi-plugin-terminal 1.0.0

package/lib/index.d.ts

@@ -0,0 +1,23 @@
+import { Context, Schema } from 'koishi';
+import * as pty from "node-pty";
+export declare const name = "terminal";
+export interface Config {
+    admin?: Array<string>;
+    root?: string;
+    shell?: string;
+    encoding?: string;
+    timeout?: number;
+    cols?: number;
+    rows?: number;
+    maxOutputLength: number;
+}
+export interface ShellSession {
+    terminal: pty.IPty;
+    buffer: string;
+    timer?: NodeJS.Timeout;
+    disposables: Array<{
+        dispose(): void;
+    }>;
+}
+export declare const Config: Schema<Config>;
+export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -0,0 +1,172 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Config: () => Config,
+  apply: () => apply,
+  name: () => name
+});
+module.exports = __toCommonJS(src_exports);
+var import_koishi = require("koishi");
+var pty = __toESM(require("node-pty"));
+var import_node_timers = require("node:timers");
+var name = "terminal";
+var Config = import_koishi.Schema.object({
+  admin: import_koishi.Schema.array(String).description("超级管理员用户，具有绝对权限。").default([]),
+  root: import_koishi.Schema.string().description("初始工作路径。").default(process.env.HOME),
+  shell: import_koishi.Schema.string().description("Shell路径。留空则自动检测系统默认Shell。"),
+  encoding: import_koishi.Schema.string().description("输出内容编码。").default("utf8"),
+  timeout: import_koishi.Schema.number().description("超时时长。").default(import_koishi.Time.minute),
+  cols: import_koishi.Schema.number().description("终端列数").default(80),
+  rows: import_koishi.Schema.number().description("终端行数").default(24),
+  maxOutputLength: import_koishi.Schema.number().description("单次发送最大输出长度。").default(1800)
+});
+function resolveShell(shell) {
+  if (shell) return shell;
+  switch (process.platform) {
+    case "win32":
+      return process.env.COMSPEC || "powershell.exe";
+    case "darwin":
+      return process.env.SHELL || "zsh";
+    case "linux":
+      return process.env.SHELL || "bash";
+  }
+  return "bash";
+}
+__name(resolveShell, "resolveShell");
+function stripAnsi(input) {
+  return input.replace(
+    // eslint-disable-next-line no-control-regex
+    /\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g,
+    ""
+  );
+}
+__name(stripAnsi, "stripAnsi");
+function getKey(session) {
+  return `${session.platform}:${session.userId}`;
+}
+__name(getKey, "getKey");
+var map = /* @__PURE__ */ new Map();
+function apply(ctx, config) {
+  const allowedUsers = config.admin;
+  function sendCommand(shellSession, command) {
+    shellSession.terminal.write(command + "\r");
+    shellSession.terminal.write("pwd\r");
+  }
+  __name(sendCommand, "sendCommand");
+  function initSession(session, key) {
+    const terminal = pty.spawn(resolveShell(config.shell), [], {
+      name: "terminal",
+      cols: config.cols,
+      rows: config.rows,
+      cwd: config.root,
+      env: process.env
+    });
+    const shellSession = {
+      terminal,
+      buffer: "",
+      disposables: []
+    };
+    const flush = /* @__PURE__ */ __name(async () => {
+      shellSession.timer = void 0;
+      const output = stripAnsi(shellSession.buffer).trim();
+      shellSession.buffer = "";
+      if (!output) return;
+      const text = output.length > config.maxOutputLength ? output.slice(0, config.maxOutputLength - 1) + "\n ...Truncated output" : output;
+      await session.send(text + "$");
+    }, "flush");
+    const dataDisposable = terminal.onData((data) => {
+      shellSession.buffer += data;
+      if (shellSession.timer) (0, import_node_timers.clearTimeout)(shellSession.timer);
+      shellSession.timer = setTimeout(flush, 300);
+    });
+    const exitDisposable = terminal.onExit(async () => {
+      cleanupSession(shellSession, key);
+      await session.send("Shell exited.");
+    });
+    shellSession.disposables.push(dataDisposable, exitDisposable);
+    map.set(key, shellSession);
+    return shellSession;
+  }
+  __name(initSession, "initSession");
+  function cleanupSession(shellSession, key) {
+    map.delete(key);
+    shellSession.disposables.forEach((d) => d.dispose());
+    shellSession.terminal.kill();
+    if (shellSession.timer) (0, import_node_timers.clearTimeout)(shellSession.timer);
+  }
+  __name(cleanupSession, "cleanupSession");
+  ctx.command("shell [command:text]", "Start a persistent shell session", { authority: 4 }).option("terminate", "-t Terminate current shell session").usage("After start up, regular user messages will be sent to shell process.").example("shell echo Operating System: Three Easy Pieces > qljj.txt").action(async ({ session, options }, command) => {
+    if (!allowedUsers.includes(session.userId)) {
+      return "Unauthorized user.";
+    }
+    const key = getKey(session);
+    if (options.terminate) {
+      const current2 = map.get(key);
+      if (!current2) return "There doesn't exist running shell session.";
+      cleanupSession(current2, key);
+      return "Shell session terminated.";
+    }
+    let current = map.get(key);
+    if (!current) {
+      current = initSession(session, key);
+      if (!command) return "Shell session started. Send regular messages as commands. Send shell -t to terminate.";
+    }
+    if (!command) return "Shell session is running.";
+    sendCommand(current, command);
+  });
+  ctx.middleware(async (session, next) => {
+    const key = getKey(session);
+    const current = map.get(key);
+    if (!current) return next();
+    const content = session.content.trim();
+    if (content === "shell" || content === "shell -t") {
+      return next();
+    }
+    if (!content) return;
+    sendCommand(current, content);
+  }, true);
+  ctx.on("dispose", () => {
+    for (const current of map.values()) {
+      current.disposables.forEach((d) => d.dispose());
+      if (current.timer) (0, import_node_timers.clearTimeout)(current.timer);
+      current.terminal.kill();
+    }
+    map.clear();
+  });
+}
+__name(apply, "apply");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  apply,
+  name
+});

package/package.json

@@ -0,0 +1,33 @@
+{
+    "name": "koishi-plugin-terminal",
+    "description": "Persistent terminal interface to a shell session over QQ.",
+    "version": "1.0.0",
+    "main": "lib/index.js",
+    "typings": "lib/index.d.ts",
+    "files": [
+        "lib",
+        "dist"
+    ],
+    "license": "MIT",
+    "scripts": {},
+    "keywords": [
+        "chatbot",
+        "koishi",
+        "plugin",
+        "shell",
+        "terminal",
+        "cmd",
+        "bash",
+        "zsh"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/Jingmozhiyu/koishi-plugin-terminal.git"
+    },
+    "peerDependencies": {
+        "koishi": "^4.18.7"
+    },
+    "dependencies": {
+        "node-pty": "^1.1.0"
+    }
+}

package/readme.md

@@ -0,0 +1,5 @@
+# koishi-plugin-terminal
+
+[![npm](https://img.shields.io/npm/v/koishi-plugin-terminal?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-terminal)
+
+Persistent terminal interface to a shell session over QQ.