agent-loft 0.2.34 → 0.2.36

package/src/core/config.ts

@@ -72,6 +72,23 @@ export type AppConfig = {
   };
   /** 输入「/」时命令列表的顺序和隐藏项，按 agent 分开（设置 → 命令） */
   commands: { claude: CommandPrefs; codex: CommandPrefs };
+  /** 远程控制：网页终端和远程桌面。管理员能用；成员要在 设置 → 用户 里单独开（users.json 的 remote） */
+  remote: {
+    terminal: boolean;
+    desktop: boolean;
+    /** 没有页面连着多久后结束 shell、停掉共享桌面用的 x11vnc（分钟） */
+    keepAliveMin: number;
+    /**
+     * 桌面从哪来。auto：Linux 上用 x11vnc 共享这台机器当前的图形桌面（按需起、只听本机）；
+     * vnc：连一个已有的 VNC 服务，比如 macOS 的屏幕共享（127.0.0.1:5900）
+     */
+    desktopSource: "auto" | "vnc";
+    /** auto 时用哪个 X 显示，留空自动找（如 :0、:1） */
+    display: string;
+    vncHost: string;
+    vncPort: number;
+    vncPassword: string;
+  };
   feishu: {
     /** 长连接掉线多久就重建，0 关闭 */
     watchdogMs: number;
@@ -100,6 +117,16 @@ export function defaultConfig(): AppConfig {
     },
     web: { enabled: true, host: "0.0.0.0", port: 8800, passwordHash: "", trustedProxies: ["127.0.0.1", "::1"], quotaRefreshMin: 10, quotaEnabled: true },
     commands: { claude: { order: [], hidden: [], custom: [] }, codex: { order: [], hidden: [], custom: [] } },
+    remote: {
+      terminal: true,
+      desktop: true,
+      keepAliveMin: 30,
+      desktopSource: process.platform === "darwin" ? "vnc" : "auto",
+      display: "",
+      vncHost: "127.0.0.1",
+      vncPort: 5900,
+      vncPassword: "",
+    },
     feishu: { watchdogMs: 10 * 60 * 1000, bots: [] },
   };
 }

package/src/core/desktop.ts

@@ -0,0 +1,281 @@
+// 远程桌面：把这台机器的图形桌面通过 VNC 给到网页（noVNC）。agent-loft 只做两件事：
+//   - 找到 VNC 服务：Linux 上按需起一个 x11vnc 共享当前桌面（只听 127.0.0.1、随机端口、每次随机密码），
+//     没人连着 keepAliveMin 分钟后停掉；或者用配置里的现成 VNC 服务（macOS 的屏幕共享）。
+//   - 把页面的 WebSocket 原样转给它（见 channels/web/desktop.ts）。画面编码、鼠标键盘、剪贴板都是 VNC 协议自己的。
+//
+// 这台机器没有图形桌面（服务器、NAS）时远程桌面不可用，远程控制里就只有终端。
+// 权限和终端一样（canUseRemote）：拿到桌面就能以登录桌面的那个人的身份做任何事。
+import { spawn, type ChildProcess } from "node:child_process";
+import crypto from "node:crypto";
+import fs from "node:fs";
+import net from "node:net";
+import os from "node:os";
+import path from "node:path";
+import { EventEmitter } from "node:events";
+import { home } from "../home.js";
+import { config } from "./config.js";
+import { canUseRemote, type User } from "./users.js";
+
+export function canUseDesktop(user: Pick<User, "role" | "disabled" | "remote"> | undefined): boolean {
+  return config().remote.desktop && canUseRemote(user);
+}
+
+// ---------- 找桌面 ----------
+
+function which(cmd: string): string | undefined {
+  for (const dir of (process.env.PATH ?? "").split(path.delimiter).concat(["/usr/bin", "/usr/local/bin", "/opt/homebrew/bin"])) {
+    const file = path.join(dir, cmd);
+    try {
+      fs.accessSync(file, fs.constants.X_OK);
+      return file;
+    } catch {
+      // 下一个
+    }
+  }
+  return undefined;
+}
+
+const X_SOCKETS = "/tmp/.X11-unix";
+
+/** 现在有哪些 X 显示（:0、:1 …），按编号排 */
+function xDisplays(): string[] {
+  try {
+    return fs
+      .readdirSync(X_SOCKETS)
+      .map((f) => /^X(\d+)$/.exec(f)?.[1])
+      .filter((n): n is string => n !== undefined)
+      .sort((a, b) => Number(a) - Number(b))
+      .map((n) => `:${n}`);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * 用哪个显示：配置里写了就用它；否则环境变量里的 DISPLAY（前台运行时）；
+ * 再不然取编号最大的那个 —— gdm 的登录界面通常是 :0，登录后的桌面排在后面。
+ */
+function pickDisplay(): string | undefined {
+  const all = xDisplays();
+  const wanted = config().remote.display.trim();
+  if (wanted) return all.includes(wanted.replace(/\.\d$/, "")) ? wanted : undefined;
+  const env = process.env.DISPLAY?.trim();
+  if (env && all.includes(env.replace(/\.\d$/, ""))) return env;
+  return all[all.length - 1];
+}
+
+/** X 的授权文件：系统服务下没有 XAUTHORITY 环境变量，按常见位置找；都没有交给 x11vnc 自己猜 */
+function xAuthority(): string {
+  const uid = os.userInfo().uid;
+  const candidates = [process.env.XAUTHORITY, `/run/user/${uid}/gdm/Xauthority`, path.join(os.homedir(), ".Xauthority")];
+  return candidates.find((f): f is string => !!f && fs.existsSync(f)) ?? "guess";
+}
+
+export type DesktopStatus = { available: boolean; reason?: string; source: "auto" | "vnc"; display?: string };
+
+/** 远程桌面能不能用。不能用时 reason 写给管理员看（成员看到的只是「没有桌面」） */
+export function desktopAvailability(): DesktopStatus {
+  const cfg = config().remote;
+  if (cfg.desktopSource === "vnc") return { available: true, source: "vnc" };
+  if (process.platform !== "linux") {
+    return {
+      available: false,
+      source: "auto",
+      reason:
+        process.platform === "darwin"
+          ? "macOS 上请改用「已有的 VNC 服务」：打开 系统设置 → 通用 → 共享 → 屏幕共享，在「电脑设置」里允许 VNC 用密码控制，再把密码填到这里"
+          : "这个系统上没法自动共享桌面，改用「已有的 VNC 服务」",
+    };
+  }
+  const display = pickDisplay();
+  if (!display) {
+    return {
+      available: false,
+      source: "auto",
+      reason: cfg.display ? `找不到显示 ${cfg.display}` : "这台机器没有图形桌面（没有运行中的 X 显示）。Wayland 桌面也共享不了，登录时选「Xorg」会话",
+    };
+  }
+  if (!which("x11vnc")) return { available: false, source: "auto", display, reason: "没装 x11vnc：sudo apt install x11vnc（或 dnf install x11vnc）" };
+  return { available: true, source: "auto", display };
+}
+
+// ---------- x11vnc ----------
+
+type Vnc = { proc: ChildProcess; port: number; password: string; display: string; ready: Promise<void> };
+
+let vnc: Vnc | null = null;
+/** 正在起 x11vnc（找空闲端口是异步的）：同时来的几个请求等同一个，别起两份 */
+let starting: Promise<Vnc> | null = null;
+/** 每停一次加一：起到一半时设置改了（停过了），起好的这份就不要了 */
+let generation = 0;
+/** 连着桌面的页面数：到 0 开始计时，keepAliveMin 分钟后停掉 x11vnc */
+let viewers = 0;
+let idleTimer: NodeJS.Timeout | null = null;
+export const desktopEvents = new EventEmitter<{ stopped: [] }>();
+
+function freePort(): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const srv = net.createServer();
+    srv.unref();
+    srv.on("error", reject);
+    srv.listen(0, "127.0.0.1", () => {
+      const port = (srv.address() as net.AddressInfo).port;
+      srv.close(() => resolve(port));
+    });
+  });
+}
+
+/** 上一次 agent-loft 被强杀（没机会收尾）时留下的 x11vnc：按记下的 pid 停掉 */
+function killStale(runDir: string): void {
+  const pidFile = path.join(runDir, "x11vnc.pid");
+  let pid = 0;
+  try {
+    pid = Number(fs.readFileSync(pidFile, "utf8").trim());
+  } catch {
+    return;
+  }
+  fs.rmSync(pidFile, { force: true });
+  if (!Number.isInteger(pid) || pid <= 1) return;
+  try {
+    // 只认我们自己起的那种：命令行里有 x11vnc 和我们的 run 目录（pid 可能已经被别的进程复用了）
+    const cmdline = fs.readFileSync(`/proc/${pid}/cmdline`, "utf8");
+    if (cmdline.includes("x11vnc") && cmdline.includes(runDir)) process.kill(pid);
+  } catch {
+    // 已经没了
+  }
+}
+
+async function startX11vnc(display: string): Promise<Vnc> {
+  const runDir = path.join(home, "run");
+  fs.mkdirSync(runDir, { recursive: true, mode: 0o700 });
+  killStale(runDir);
+  const port = await freePort();
+  // VNC 密码最多 8 个字符。只在本机能连，又是每次新起的，够了
+  const password = crypto.randomBytes(6).toString("base64url").slice(0, 8);
+  const pwFile = path.join(runDir, `x11vnc-${crypto.randomBytes(4).toString("hex")}.pw`);
+  // 密码放文件里（命令行参数别的用户用 ps 就能看到），x11vnc 读完就删（rm: 前缀）
+  fs.writeFileSync(pwFile, `${password}\n`, { mode: 0o600 });
+  const args = [
+    "-display", display,
+    "-auth", xAuthority(),
+    "-localhost",
+    "-rfbport", String(port),
+    "-passwdfile", `rm:${pwFile}`,
+    "-forever",
+    "-shared",
+    "-xkb",
+    "-noxdamage",
+    "-quiet",
+  ];
+  const proc = spawn(which("x11vnc")!, args, { stdio: ["ignore", "pipe", "pipe"] });
+  if (proc.pid) fs.writeFileSync(path.join(runDir, "x11vnc.pid"), String(proc.pid));
+  let stderr = "";
+  proc.stderr!.on("data", (d: Buffer) => (stderr = (stderr + d.toString()).slice(-4000)));
+  const ready = new Promise<void>((resolve, reject) => {
+    const timer = setTimeout(() => {
+      proc.kill();
+      reject(new Error("x11vnc 10 秒内没有启动起来"));
+    }, 10_000);
+    // 起不来（没权限执行之类）：spawn 自己报错，不会有 exit
+    proc.on("error", (err) => {
+      clearTimeout(timer);
+      fs.rmSync(pwFile, { force: true });
+      reject(new Error(`x11vnc 起不来：${err.message}`));
+    });
+    // 准备好了会在标准输出打一行 PORT=xxxx
+    proc.stdout!.on("data", (d: Buffer) => {
+      if (/PORT=\d+/.test(d.toString())) {
+        clearTimeout(timer);
+        resolve();
+      }
+    });
+    proc.on("exit", (code) => {
+      clearTimeout(timer);
+      fs.rmSync(pwFile, { force: true });
+      const why = stderr.split("\n").find((l) => /fail|error|unable|cannot|refused/i.test(l))?.replace(/^\S+ \S+ /, "");
+      reject(new Error(`x11vnc 退出了（${code}）${why ? `：${why}` : ""}`));
+    });
+  });
+  const v: Vnc = { proc, port, password, display, ready };
+  proc.on("exit", () => {
+    // 只删自己的：可能已经换上新的那份、pid 文件里记的是它
+    const pidFile = path.join(runDir, "x11vnc.pid");
+    try {
+      if (fs.readFileSync(pidFile, "utf8").trim() === String(proc.pid)) fs.rmSync(pidFile, { force: true });
+    } catch {
+      // 没有就算了
+    }
+    if (vnc !== v) return;
+    vnc = null;
+    console.log("[桌面] x11vnc 已停止");
+    desktopEvents.emit("stopped");
+  });
+  ready.then(() => console.log(`[桌面] 已在 ${display} 上起 x11vnc（127.0.0.1:${port}）`), () => {});
+  return v;
+}
+
+export type DesktopTarget = { host: string; port: number; password: string };
+
+/** 要连桌面了：拿到 VNC 服务的地址和密码，必要时先把 x11vnc 起来 */
+export async function desktopTarget(): Promise<DesktopTarget> {
+  const status = desktopAvailability();
+  if (!status.available) throw new Error(status.reason ?? "这台机器上没有可用的桌面");
+  const cfg = config().remote;
+  if (status.source === "vnc") return { host: cfg.vncHost, port: cfg.vncPort, password: cfg.vncPassword };
+  // 换了显示（配置改了）：旧的停掉
+  if (vnc && vnc.display !== status.display) stopDesktop();
+  const gen = generation;
+  if (!vnc) {
+    starting ??= startX11vnc(status.display!).finally(() => (starting = null));
+    const started = await starting;
+    // 等的这会儿里被停过（设置改了、服务在停）：这一份也不要了
+    if (gen !== generation) {
+      started.proc.kill();
+      throw new Error("远程桌面的设置刚改过，再连一次");
+    }
+    vnc ??= started;
+    if (vnc !== started) started.proc.kill();
+  }
+  const current = vnc;
+  try {
+    await current.ready;
+  } catch (err) {
+    if (vnc === current) vnc = null;
+    // 没起好就被停了（设置改了）：说清楚，别让人以为 x11vnc 坏了
+    if (gen !== generation) throw new Error("远程桌面的设置刚改过，再连一次");
+    throw err;
+  }
+  armIdle();
+  return { host: "127.0.0.1", port: current.port, password: current.password };
+}
+
+/** 页面连上 / 断开桌面：没人连着了就开始计时 */
+export function desktopViewer(delta: 1 | -1): void {
+  viewers = Math.max(0, viewers + delta);
+  armIdle();
+}
+
+function armIdle(): void {
+  if (idleTimer) clearTimeout(idleTimer);
+  idleTimer = null;
+  if (viewers > 0 || !vnc) return;
+  idleTimer = setTimeout(() => stopDesktop(), Math.max(1, config().remote.keepAliveMin) * 60_000);
+  idleTimer.unref();
+}
+
+export function stopDesktop(): void {
+  generation++;
+  if (idleTimer) clearTimeout(idleTimer);
+  idleTimer = null;
+  const v = vnc;
+  if (!v) return;
+  vnc = null;
+  v.proc.kill();
+  console.log("[桌面] 已停掉 x11vnc");
+  desktopEvents.emit("stopped");
+}
+
+/** 是不是我们自己起的 x11vnc 在跑（给测试和状态页用） */
+export function desktopRunning(): boolean {
+  return !!vnc;
+}

package/src/core/terminals.ts

@@ -0,0 +1,308 @@
+// 网页终端：服务端起 shell（node-pty），页面用 WebSocket 连上来收发。
+//
+// shell 属于人，不属于页面：关掉页面、手机切到后台、断线都不结束它，重连后按 since 补上错过的输出；
+// 没有页面连着超过 terminal.keepAliveMin 分钟才结束。同一个终端可以同时开在几个页面上。
+//
+// 谁能用：管理员；成员要管理员在 设置 → 用户 里单独开「远程控制」（users.json 的 remote）。
+// 和 agent 不同，这里没有授权卡 —— 拿到终端就是拿到这台机器上 agent-loft 这个系统用户的 shell。
+// 权限收回、用户被停用或删除、设置里关掉终端时，他开着的 shell 立刻结束。
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { EventEmitter } from "node:events";
+import type { IPty } from "node-pty";
+import { agentEnvironment } from "./agent-env.js";
+import { config, onConfigChange } from "./config.js";
+import { canUseRemote, getUser, userEvents, type User } from "./users.js";
+
+// ---------- node-pty ----------
+
+type PtyModule = typeof import("node-pty");
+
+/** node-pty 是原生模块、可选依赖：装不上（没有编译工具）时终端整个不可用，其他功能照常 */
+let ptyModule: PtyModule | null | undefined;
+let ptyError = "";
+
+function loadPty(): PtyModule | null {
+  if (ptyModule !== undefined) return ptyModule;
+  try {
+    ptyModule = createRequire(import.meta.url)("node-pty") as PtyModule;
+  } catch (err) {
+    ptyModule = null;
+    ptyError = err instanceof Error ? err.message.split("\n")[0]! : String(err);
+  }
+  return ptyModule;
+}
+
+/** 终端能不能用；不能用时 reason 写给管理员看 */
+export function terminalAvailability(): { available: boolean; reason?: string } {
+  if (loadPty()) return { available: true };
+  return { available: false, reason: `没装好 node-pty（${ptyError}）。在 agent-loft 的安装目录里运行 npm install node-pty 后重启` };
+}
+
+/** 这个人现在能不能用终端 */
+export function canUseTerminal(user: Pick<User, "role" | "disabled" | "remote"> | undefined): boolean {
+  return config().remote.terminal && canUseRemote(user);
+}
+
+// ---------- 输出记录 ----------
+
+/** 每个终端留多少输出（字符），断线重连、换个页面打开时补发 */
+const LOG_LIMIT = 512 * 1024;
+
+/**
+ * 最近的输出，加上从开始到现在一共输出了多少（total）。
+ * 页面记着自己收到第几个字符了（since），重连时只补后面的；早于记录开头的补不了，整屏重画。
+ */
+export class OutputLog {
+  private buf = "";
+  total = 0;
+
+  constructor(private readonly limit = LOG_LIMIT) {}
+
+  append(data: string): void {
+    this.buf += data;
+    this.total += data.length;
+    if (this.buf.length > this.limit * 1.25) {
+      // 从换行处截：别从一个转义序列中间开始重放
+      const cut = this.buf.length - this.limit;
+      const nl = this.buf.indexOf("\n", cut);
+      this.buf = this.buf.slice(nl >= 0 && nl - cut < 4096 ? nl + 1 : cut);
+    }
+  }
+
+  /** since 之后的输出；reset：页面得先清屏，data 是能补的全部 */
+  since(since: number): { reset: boolean; data: string } {
+    const start = this.total - this.buf.length;
+    if (Number.isInteger(since) && since >= start && since <= this.total) return { reset: false, data: this.buf.slice(since - start) };
+    return { reset: true, data: this.buf };
+  }
+}
+
+// ---------- 终端 ----------
+
+/** 连着这个终端的一个页面。由 Web 渠道实现（见 channels/web/terminal.ts） */
+export type TermPeer = {
+  send(msg: unknown): void;
+  close(code: number, reason: string): void;
+};
+
+type Term = {
+  id: string;
+  owner: string;
+  cwd: string;
+  shell: string;
+  createdAt: number;
+  pty: IPty;
+  log: OutputLog;
+  peers: Set<TermPeer>;
+  cols: number;
+  rows: number;
+  /** 没有页面连着时开始计时，到点结束 shell */
+  idleTimer: NodeJS.Timeout | null;
+  /** 还没发出去的输出：pty 一次只吐几十个字节，攒一下再发 */
+  pending: string;
+  flushTimer: NodeJS.Timeout | null;
+};
+
+export type TermInfo = { id: string; cwd: string; shell: string; createdAt: number; attached: number };
+
+const PER_USER = 10;
+const TOTAL = 50;
+
+const terms = new Map<string, Term>();
+/** 某人的终端开了 / 结束了：他开着的页面重新拉列表 */
+export const terminalEvents = new EventEmitter<{ changed: [owner: string] }>();
+
+function info(t: Term): TermInfo {
+  return { id: t.id, cwd: t.cwd, shell: path.basename(t.shell), createdAt: t.createdAt, attached: t.peers.size };
+}
+
+export function listTerminals(owner: string): TermInfo[] {
+  return [...terms.values()].filter((t) => t.owner === owner).sort((a, b) => a.createdAt - b.createdAt).map(info);
+}
+
+/** 只给主人：别人的终端 id 拿到了也当不存在 */
+export function getTerminal(id: string, owner: string): TermInfo | undefined {
+  const t = terms.get(id);
+  return t && t.owner === owner ? info(t) : undefined;
+}
+
+function defaultShell(): { file: string; args: string[] } {
+  if (process.platform === "win32") return { file: process.env.COMSPEC || "powershell.exe", args: [] };
+  const candidates = [process.env.SHELL, "/bin/bash", "/bin/zsh", "/bin/sh"].filter((s): s is string => !!s);
+  const file = candidates.find((s) => path.isAbsolute(s) && fs.existsSync(s)) ?? "/bin/sh";
+  // 登录 shell：systemd / launchd 下 PATH 很短，读一遍 profile 才像平时开的终端
+  return { file, args: ["-l"] };
+}
+
+function usableDir(dir: unknown): string | undefined {
+  if (typeof dir !== "string" || !path.isAbsolute(dir)) return undefined;
+  try {
+    return fs.statSync(dir).isDirectory() ? path.resolve(dir) : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function clampSize(n: unknown, fallback: number, max: number): number {
+  const v = Math.round(Number(n));
+  return Number.isFinite(v) && v >= 2 ? Math.min(v, max) : fallback;
+}
+
+export function createTerminal(user: User, opts: { cwd?: unknown; cols?: unknown; rows?: unknown }): TermInfo {
+  if (!canUseTerminal(user)) throw new Error("你没有使用终端的权限");
+  const pty = loadPty();
+  if (!pty) throw new Error(terminalAvailability().reason);
+  if (listTerminals(user.id).length >= PER_USER) throw new Error(`最多同时开 ${PER_USER} 个终端，先关掉几个`);
+  if (terms.size >= TOTAL) throw new Error("服务器上开着的终端太多了");
+  const cwd = usableDir(opts.cwd) ?? usableDir(config().workspaceRoot) ?? os.homedir();
+  const cols = clampSize(opts.cols, 80, 500);
+  const rows = clampSize(opts.rows, 24, 200);
+  const shell = defaultShell();
+  const env: Record<string, string> = {};
+  for (const [k, v] of Object.entries(agentEnvironment())) if (typeof v === "string") env[k] = v;
+  env.TERM = "xterm-256color";
+  env.COLORTERM = "truecolor";
+  if (!env.LANG && !env.LC_ALL) env.LANG = "C.UTF-8";
+  const proc = pty.spawn(shell.file, shell.args, { name: "xterm-256color", cols, rows, cwd, env });
+  const t: Term = {
+    id: `t_${crypto.randomBytes(6).toString("hex")}`,
+    owner: user.id,
+    cwd,
+    shell: shell.file,
+    createdAt: Date.now(),
+    pty: proc,
+    log: new OutputLog(),
+    peers: new Set(),
+    cols,
+    rows,
+    idleTimer: null,
+    pending: "",
+    flushTimer: null,
+  };
+  terms.set(t.id, t);
+  proc.onData((data) => {
+    t.log.append(data);
+    t.pending += data;
+    t.flushTimer ??= setTimeout(() => flush(t), 8);
+  });
+  proc.onExit(({ exitCode }) => {
+    flush(t);
+    finish(t, `shell 已退出（${exitCode}）`, exitCode);
+  });
+  armIdle(t);
+  console.log(`[终端] ${user.name} 开了终端 ${t.id}（${cwd}）`);
+  terminalEvents.emit("changed", t.owner);
+  return info(t);
+}
+
+function flush(t: Term): void {
+  if (t.flushTimer) clearTimeout(t.flushTimer);
+  t.flushTimer = null;
+  if (!t.pending) return;
+  const msg = { t: "o", d: t.pending };
+  t.pending = "";
+  for (const peer of t.peers) peer.send(msg);
+}
+
+/** 没有页面连着了：keepAliveMin 分钟后结束 */
+function armIdle(t: Term): void {
+  if (t.idleTimer) clearTimeout(t.idleTimer);
+  t.idleTimer = null;
+  if (t.peers.size > 0) return;
+  const ms = Math.max(1, config().remote.keepAliveMin) * 60_000;
+  t.idleTimer = setTimeout(() => killTerminal(t.id, "没有页面连着，已超时结束"), ms);
+  t.idleTimer.unref();
+}
+
+/** 从表里拿掉、告诉连着的页面。shell 自己退出和被结束都走这里 */
+function finish(t: Term, reason: string, code: number | null): void {
+  if (terms.get(t.id) !== t) return;
+  terms.delete(t.id);
+  if (t.idleTimer) clearTimeout(t.idleTimer);
+  if (t.flushTimer) clearTimeout(t.flushTimer);
+  for (const peer of t.peers) {
+    peer.send({ t: "x", code, reason });
+    peer.close(4000, "终端已结束");
+  }
+  t.peers.clear();
+  terminalEvents.emit("changed", t.owner);
+}
+
+export function killTerminal(id: string, reason = "已关闭"): boolean {
+  const t = terms.get(id);
+  if (!t) return false;
+  finish(t, reason, null);
+  try {
+    t.pty.kill();
+  } catch {
+    // 已经退出了
+  }
+  return true;
+}
+
+/** 页面连上来：先补上 since 之后的输出 */
+export function attachTerminal(id: string, owner: string, peer: TermPeer, since: number): boolean {
+  const t = terms.get(id);
+  if (!t || t.owner !== owner) return false;
+  flush(t);
+  const { reset, data } = t.log.since(since);
+  peer.send({ t: "a", reset, d: data, total: t.log.total, cwd: t.cwd });
+  t.peers.add(peer);
+  armIdle(t);
+  return true;
+}
+
+export function detachTerminal(id: string, peer: TermPeer): void {
+  const t = terms.get(id);
+  if (!t || !t.peers.delete(peer)) return;
+  armIdle(t);
+}
+
+export function writeTerminal(id: string, data: string): void {
+  const t = terms.get(id);
+  if (t && data) t.pty.write(data);
+}
+
+/** 几个页面开着同一个终端、窗口大小不一样：以最后调整的那个为准 */
+export function resizeTerminal(id: string, cols: unknown, rows: unknown): void {
+  const t = terms.get(id);
+  if (!t) return;
+  const c = clampSize(cols, t.cols, 500);
+  const r = clampSize(rows, t.rows, 200);
+  if (c === t.cols && r === t.rows) return;
+  t.cols = c;
+  t.rows = r;
+  try {
+    t.pty.resize(c, r);
+  } catch {
+    // 正在退出
+  }
+}
+
+/**
+ * 权限变了（用户改了、设置里关了）：现在不能用终端的人，shell 立刻结束。
+ * 用户改动由 userEvents 通知；终端里 agent-loft user … 直接改文件的没有事件，Web 的心跳会再调一次
+ */
+export function enforceTerminalAccess(): void {
+  for (const t of [...terms.values()]) {
+    if (!canUseTerminal(getUser(t.owner))) killTerminal(t.id, "终端权限已被收回");
+  }
+}
+
+let watching = false;
+/** 启动 Web 渠道时调用一次 */
+export function watchTerminalAccess(): void {
+  if (watching) return;
+  watching = true;
+  userEvents.on("changed", enforceTerminalAccess);
+  onConfigChange(() => enforceTerminalAccess());
+}
+
+/** 服务停止：结束所有 shell */
+export function killAllTerminals(): void {
+  for (const id of [...terms.keys()]) killTerminal(id, "服务已停止");
+}

package/src/core/users.ts

@@ -25,6 +25,8 @@ export type User = {
   passwordHash: string;
   createdAt: number;
   disabled?: boolean;
+  /** 成员能不能用远程控制（终端、桌面）。管理员一直能用，不看这个 */
+  remote?: boolean;
 };
 
 export type PublicUser = Omit<User, "passwordHash">;
@@ -165,6 +167,12 @@ export function isAdmin(user: Pick<User, "role"> | undefined): boolean {
   return user?.role === "admin";
 }
 
+/** 能不能用远程控制（终端、桌面）：管理员能用，成员要单独开。设置里各自还有总开关 */
+export function canUseRemote(user: Pick<User, "role" | "disabled" | "remote"> | undefined): boolean {
+  if (!user || user.disabled) return false;
+  return user.role === "admin" || user.remote === true;
+}
+
 /**
  * 升级前的登录态、推送订阅没有记是谁的：都算最早的那个管理员的（就是迁移出来的 admin）。
  */
@@ -220,7 +228,10 @@ export function createUser(params: { name: string; password: string; role?: Role
   return publicUser(user);
 }
 
-export function updateUser(id: string, patch: { name?: string; role?: Role; disabled?: boolean; password?: string }): PublicUser {
+export function updateUser(
+  id: string,
+  patch: { name?: string; role?: Role; disabled?: boolean; password?: string; remote?: boolean },
+): PublicUser {
   const list = load().map((u) => ({ ...u }));
   const user = list.find((u) => u.id === id);
   if (!user) throw new Error("用户不存在");
@@ -234,6 +245,10 @@ export function updateUser(id: string, patch: { name?: string; role?: Role; disa
     if (patch.disabled) user.disabled = true;
     else delete user.disabled;
   }
+  if (patch.remote !== undefined) {
+    if (patch.remote) user.remote = true;
+    else delete user.remote;
+  }
   if (patch.password !== undefined) {
     checkPassword(patch.password);
     user.passwordHash = hashPassword(patch.password);