@duckmind/dm-darwin-x64 0.66.4 → 0.66.6

package/extensions/dm-tty/server.js

@@ -0,0 +1,438 @@
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { createServer } from "node:http";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { WebSocketServer, WebSocket } from "ws";
+import { PtyProcess } from "./pty.js";
+import { startTtyControl } from "./control.js";
+import { createTerminalSession, discoverTerminalSessions, sessionCommand, shellSession, validSessionName } from "./sessions.js";
+const MAX_INPUT_BYTES = 64 * 1024;
+const MAX_REPLAY_BYTES = 256 * 1024;
+const MAX_PENDING_BYTES = 1024 * 1024;
+const MAX_CONNECTIONS = 16;
+const AUTH_TIMEOUT_MS = 5000;
+const MAX_OPERATIONS = 32;
+function extractMessage(data) {
+  try {
+    const value = JSON.parse(data.toString("utf8"));
+    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+export function createTtyToken() {
+  return randomBytes(24).toString("base64url");
+}
+function dependencyAsset(relativePath) {
+  let root = dirname(fileURLToPath(import.meta.url));
+  for (;; ) {
+    const candidate = resolve(root, "node_modules", relativePath);
+    if (existsSync(candidate) && statSync(candidate).isFile())
+      return candidate;
+    const parent = dirname(root);
+    if (parent === root)
+      throw new Error(`Missing dm-tty browser asset: ${relativePath}`);
+    root = parent;
+  }
+}
+
+export class DmTtyServer {
+  options;
+  http;
+  sockets;
+  pty;
+  shellPty;
+  sessionOptions;
+  sessions = [shellSession()];
+  activeSession = shellSession();
+  replays = new Map;
+  operations = Promise.resolve();
+  pendingOperations = 0;
+  pendingSwitches = 0;
+  switching = false;
+  assets = new Map;
+  activeSocket;
+  readySocket;
+  boundPort;
+  started = false;
+  closing;
+  stopControl;
+  finishClose;
+  closed = new Promise((done) => {
+    this.finishClose = done;
+  });
+  constructor(options) {
+    if (options.token.length < 32 || options.token.length > 256)
+      throw new Error("TTY token must contain 32–256 characters");
+    if (!Number.isInteger(options.port) || options.port < 0 || options.port > 65535)
+      throw new Error("Invalid TTY port");
+    if (!options.host || /[\s/]/.test(options.host))
+      throw new Error("Invalid TTY host");
+    if (!statSync(options.cwd).isDirectory())
+      throw new Error("TTY cwd must be a directory");
+    this.options = { ...options, cwd: resolve(options.cwd) };
+    this.sessionOptions = { tmuxSocket: options.tmuxSocket };
+    this.http = createServer((request, response) => this.handleHttp(request, response));
+    this.sockets = new WebSocketServer({ noServer: true, maxPayload: MAX_INPUT_BYTES * 6 + 1024, perMessageDeflate: false });
+    this.http.on("upgrade", (request, socket, head) => this.handleUpgrade(request, socket, head));
+    this.http.on("clientError", (_error, socket) => socket.destroy());
+    this.sockets.on("connection", (socket) => this.handleConnection(socket));
+  }
+  async start() {
+    if (this.started || this.closing)
+      throw new Error("TTY server has already been started or closed");
+    this.started = true;
+    try {
+      for (const [route, type, path] of [
+        ["/", "text/html", new URL("./web/index.html", import.meta.url)],
+        ["/client.js", "text/javascript", new URL("./web/client.js", import.meta.url)],
+        ["/style.css", "text/css", new URL("./web/style.css", import.meta.url)],
+        ["/xterm.js", "text/javascript", dependencyAsset("@xterm/xterm/lib/xterm.js")],
+        ["/xterm.css", "text/css", dependencyAsset("@xterm/xterm/css/xterm.css")],
+        ["/addon-fit.js", "text/javascript", dependencyAsset("@xterm/addon-fit/lib/addon-fit.js")]
+      ])
+        this.assets.set(route, { type, data: readFileSync(path) });
+      await new Promise((resolvePromise, reject) => {
+        this.http.once("error", reject);
+        this.http.listen(this.options.port, this.options.host, () => {
+          this.http.off("error", reject);
+          const address = this.http.address();
+          if (!address || typeof address === "string")
+            return reject(new Error("TTY listener did not expose a port"));
+          this.boundPort = address.port;
+          resolvePromise();
+        });
+      });
+      await this.startSession(this.activeSession, true);
+      this.stopControl = await startTtyControl(this.boundPort, () => this.close());
+      return this.info();
+    } catch (error) {
+      await this.close();
+      throw error;
+    }
+  }
+  close() {
+    this.closing ??= this.dispose().finally(() => this.finishClose());
+    return this.closing;
+  }
+  async dispose() {
+    this.stopControl?.();
+    await this.operations;
+    this.activeSocket = undefined;
+    this.readySocket = undefined;
+    for (const socket of this.sockets.clients)
+      socket.terminate();
+    await Promise.all([
+      this.pty?.close(),
+      this.shellPty !== this.pty ? this.shellPty?.close() : undefined,
+      new Promise((done) => this.sockets.close(() => done())),
+      new Promise((done) => {
+        this.http.close(() => done());
+        this.http.closeAllConnections();
+      })
+    ]);
+    this.boundPort = undefined;
+    this.assets.clear();
+    this.replays.clear();
+  }
+  info() {
+    if (this.boundPort === undefined)
+      throw new Error("TTY server is not running");
+    return { host: this.options.host, port: this.boundPort, cwd: this.options.cwd, pid: this.pty?.pid, token: this.options.token, running: this.pty?.running ?? false };
+  }
+  async refreshSessions() {
+    this.sessions = await discoverTerminalSessions(this.sessionOptions);
+    if (!this.sessions.some((session) => session.id === this.activeSession.id) && this.pty?.running)
+      this.sessions.unshift(this.activeSession);
+    const ids = new Set(this.sessions.map((session) => session.id));
+    for (const id of this.replays.keys())
+      if (!ids.has(id))
+        this.replays.delete(id);
+    return this.sessions;
+  }
+  createPty(session) {
+    const command = sessionCommand(session, this.sessionOptions);
+    const pty = new PtyProcess({ cwd: this.options.cwd, shell: this.options.shell, command });
+    pty.on("output", (text) => {
+      this.broadcastOutput(text, session.id, this.pty === pty && !this.switching && this.readySocket === this.activeSocket);
+    });
+    pty.on("exit", (code, signal) => {
+      if (this.pty === pty && !this.switching)
+        this.broadcast({ type: "exit", code, signal });
+    });
+    pty.on("error", () => {
+      if (this.pty === pty)
+        this.broadcast({ type: "error", message: "Terminal process failed; stop and restart /tty." });
+    });
+    return pty;
+  }
+  async startSession(session, resetReplay) {
+    if (resetReplay)
+      this.replays.set(session.id, Buffer.alloc(0));
+    const pty = this.createPty(session);
+    this.pty = pty;
+    this.activeSession = session;
+    if (session.backend === "shell")
+      this.shellPty = pty;
+    await pty.start();
+  }
+  enqueue(socket, operation, changesAttachment = false) {
+    if (this.pendingOperations >= MAX_OPERATIONS)
+      return void this.send(socket, { type: "error", message: "Too many pending session operations." });
+    this.pendingOperations++;
+    if (changesAttachment)
+      this.switching = ++this.pendingSwitches > 0;
+    this.operations = this.operations.then(async () => {
+      if (socket !== this.activeSocket || this.closing)
+        return;
+      try {
+        await operation();
+      } catch {
+        if (socket === this.activeSocket)
+          this.send(socket, { type: "error", message: "Terminal session operation failed; choose another tab." });
+      }
+    }).finally(() => {
+      this.pendingOperations--;
+      if (changesAttachment)
+        this.switching = --this.pendingSwitches > 0;
+    });
+  }
+  sendReady(socket) {
+    if (socket !== this.activeSocket || this.closing)
+      return;
+    this.send(socket, {
+      type: "ready",
+      replay: (this.replays.get(this.activeSession.id) ?? Buffer.alloc(0)).toString("utf8"),
+      running: this.pty?.running ?? false,
+      sessions: this.sessions,
+      activeSession: this.activeSession
+    });
+    this.readySocket = socket;
+  }
+  sendSessions(socket) {
+    this.send(socket, { type: "sessions", sessions: this.sessions, activeSession: this.activeSession });
+  }
+  async selectSession(socket, id) {
+    if (socket !== this.activeSocket)
+      return;
+    await this.refreshSessions();
+    if (socket !== this.activeSocket || this.closing)
+      return;
+    const session = this.sessions.find((candidate) => candidate.id === id);
+    if (!session)
+      return void this.send(socket, { type: "error", message: "That terminal session is no longer available." });
+    this.send(socket, { type: "switching", session });
+    if (session.id !== this.activeSession.id) {
+      const previous = this.pty;
+      let candidate = session.backend === "shell" ? this.shellPty : undefined;
+      if (!candidate) {
+        candidate = this.createPty(session);
+        try {
+          await candidate.start();
+          if (!candidate.running)
+            throw new Error("Session exited during attachment");
+        } catch {
+          await candidate.close();
+          if (socket === this.activeSocket && !this.closing) {
+            this.send(socket, { type: "error", message: "Cannot attach terminal session." });
+            this.sendReady(socket);
+          }
+          return;
+        }
+      }
+      if (socket !== this.activeSocket || this.closing) {
+        if (candidate !== this.shellPty)
+          await candidate.close();
+        return;
+      }
+      this.pty = candidate;
+      this.activeSession = session;
+      if (previous && previous !== this.shellPty)
+        await previous.close();
+      if (socket !== this.activeSocket || this.closing)
+        return;
+      await this.refreshSessions();
+    }
+    if (socket !== this.activeSocket || this.closing)
+      return;
+    this.sendReady(socket);
+  }
+  async createSession(socket, backend, name) {
+    if (!validSessionName(name))
+      return void this.send(socket, { type: "error", message: "Invalid session name (1–64 letters, digits, dots, hyphens or underscores)." });
+    const before = await this.refreshSessions();
+    if (socket !== this.activeSocket || this.closing)
+      return;
+    if (before.some((session) => session.backend === backend && session.name === name)) {
+      return void this.send(socket, { type: "error", message: "Session name already exists." });
+    }
+    await createTerminalSession(backend, name, this.options.cwd, this.sessionOptions);
+    if (socket !== this.activeSocket || this.closing)
+      return;
+    const after = await this.refreshSessions();
+    if (socket !== this.activeSocket || this.closing)
+      return;
+    const created = after.find((session) => session.backend === backend && !before.some((old) => old.id === session.id) && session.name === name);
+    if (!created)
+      throw new Error("Created session not found");
+    await this.selectSession(socket, created.id);
+  }
+  handleHttp(request, response) {
+    const headers = {
+      "cache-control": "no-store",
+      "x-content-type-options": "nosniff",
+      "x-frame-options": "DENY",
+      "referrer-policy": "no-referrer",
+      "content-security-policy": "default-src 'none'; script-src 'self'; style-src 'self' 'unsafe-inline'; connect-src 'self'; base-uri 'none'; frame-ancestors 'none'; form-action 'none'"
+    };
+    const asset = this.assets.get(request.url ?? "");
+    if ((request.method === "GET" || request.method === "HEAD") && asset) {
+      response.writeHead(200, { ...headers, "content-type": `${asset.type}; charset=utf-8` });
+      response.end(request.method === "HEAD" ? undefined : asset.data);
+    } else if (request.method === "GET" && request.url === "/health") {
+      response.writeHead(200, { ...headers, "content-type": "application/json" });
+      response.end(JSON.stringify({ status: "ok", running: this.pty?.running ?? false }));
+    } else {
+      response.writeHead(404, headers);
+      response.end("Not found");
+    }
+  }
+  handleUpgrade(request, socket, head) {
+    let originAllowed = request.headers.origin === undefined;
+    if (request.headers.origin) {
+      try {
+        const origin = new URL(request.headers.origin);
+        originAllowed = ["http:", "https:"].includes(origin.protocol) && origin.host === request.headers.host;
+      } catch {}
+    }
+    if (!originAllowed || request.url !== "/terminal" || this.closing || this.sockets.clients.size >= MAX_CONNECTIONS) {
+      socket.end(`HTTP/1.1 403 Forbidden\r
+Connection: close\r
+Content-Length: 0\r
+\r
+`);
+      return;
+    }
+    this.sockets.handleUpgrade(request, socket, head, (websocket) => this.sockets.emit("connection", websocket));
+  }
+  handleConnection(socket) {
+    let authenticated = false;
+    let closeTimer;
+    const reject = (code, reason) => {
+      if (closeTimer)
+        return;
+      socket.close(code, reason);
+      closeTimer = setTimeout(() => socket.terminate(), 500);
+      closeTimer.unref();
+    };
+    const authTimer = setTimeout(() => reject(1008, "authentication required"), AUTH_TIMEOUT_MS);
+    authTimer.unref();
+    socket.on("error", (error) => {
+      if (error.code !== "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH")
+        socket.terminate();
+    });
+    socket.on("message", (data, isBinary) => {
+      if (closeTimer)
+        return;
+      const message = isBinary ? null : extractMessage(data);
+      if (!message || message.v !== 1)
+        return reject(1003, "invalid protocol message");
+      if (!authenticated) {
+        const token = typeof message.token === "string" ? Buffer.from(message.token) : Buffer.alloc(0);
+        const expected = Buffer.from(this.options.token);
+        if (message.type !== "auth" || token.length !== expected.length || !timingSafeEqual(token, expected)) {
+          return reject(1008, "authentication failed");
+        }
+        authenticated = true;
+        clearTimeout(authTimer);
+        const previous = this.activeSocket;
+        this.activeSocket = socket;
+        this.readySocket = undefined;
+        previous?.close(1012, "replaced by a new controller");
+        if (previous) {
+          const timer = setTimeout(() => previous.terminate(), 500);
+          timer.unref();
+          previous.once("close", () => clearTimeout(timer));
+        }
+        this.enqueue(socket, async () => {
+          await this.refreshSessions();
+          if (socket === this.activeSocket && !this.closing)
+            this.sendReady(socket);
+        });
+        return;
+      }
+      if (socket !== this.activeSocket)
+        return reject(1008, "controller replaced");
+      if (message.type === "input" && typeof message.data === "string") {
+        if (Buffer.byteLength(message.data) > MAX_INPUT_BYTES)
+          return reject(1009, "input limit exceeded");
+        if (this.switching || message.sessionId !== this.activeSession.id)
+          return;
+        if (!this.pty?.running)
+          return this.send(socket, { type: "error", message: "Terminal session exited; choose another tab." });
+        if (!this.pty.write(message.data))
+          reject(1008, "terminal input is congested");
+      } else if (message.type === "resize") {
+        const { cols, rows } = message;
+        if (typeof cols !== "number" || typeof rows !== "number" || !Number.isInteger(cols) || !Number.isInteger(rows) || cols < 2 || cols > 500 || rows < 1 || rows > 200) {
+          return reject(1008, "invalid terminal dimensions");
+        }
+        if (this.switching || message.sessionId !== this.activeSession.id)
+          return;
+        try {
+          this.pty?.resize(cols, rows);
+        } catch {
+          reject(1008, "terminal input is congested");
+        }
+      } else if (message.type === "sessions") {
+        this.enqueue(socket, async () => {
+          await this.refreshSessions();
+          if (socket === this.activeSocket && !this.closing)
+            this.sendSessions(socket);
+        });
+      } else if (message.type === "select" && typeof message.sessionId === "string" && message.sessionId.length <= 160) {
+        const id = message.sessionId;
+        this.enqueue(socket, () => this.selectSession(socket, id), true);
+      } else if (message.type === "create" && (message.backend === "tmux" || message.backend === "screen") && typeof message.name === "string" && message.name.length <= 64) {
+        const { backend, name } = message;
+        this.enqueue(socket, () => this.createSession(socket, backend, name), true);
+      } else if (message.type === "ping") {
+        this.send(socket, { type: "pong" });
+      } else
+        reject(1003, "unknown terminal message");
+    });
+    socket.on("close", () => {
+      clearTimeout(authTimer);
+      clearTimeout(closeTimer);
+      if (this.activeSocket === socket)
+        this.activeSocket = undefined;
+      if (this.readySocket === socket)
+        this.readySocket = undefined;
+    });
+  }
+  broadcastOutput(text, id, visible) {
+    if (!text || this.closing)
+      return;
+    const combined = Buffer.concat([this.replays.get(id) ?? Buffer.alloc(0), Buffer.from(text)]);
+    let start = Math.max(0, combined.length - MAX_REPLAY_BYTES);
+    while (start < combined.length && (combined[start] & 192) === 128)
+      start++;
+    this.replays.set(id, Buffer.from(combined.subarray(start)));
+    if (visible)
+      this.broadcast({ type: "output", data: text });
+  }
+  send(socket, message) {
+    if (socket.readyState !== WebSocket.OPEN)
+      return;
+    if (socket.bufferedAmount > MAX_PENDING_BYTES) {
+      socket.terminate();
+      return;
+    }
+    socket.send(JSON.stringify({ v: 1, ...message }));
+  }
+  broadcast(message) {
+    if (this.activeSocket)
+      this.send(this.activeSocket, message);
+  }
+}

package/extensions/dm-tty/sessions.js

@@ -0,0 +1,97 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+const COMMAND_TIMEOUT_MS = 1500;
+const MAX_OUTPUT_BYTES = 64 * 1024;
+const MAX_SESSIONS = 128;
+export function validSessionName(name) {
+  return /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(name);
+}
+function validScreenTarget(target) {
+  return /^\d+\.[A-Za-z0-9][A-Za-z0-9._:@+-]{0,127}$/.test(target);
+}
+async function commandOutput(command, args, env, allowNonzero = false) {
+  try {
+    const result = await execFileAsync(command, args, {
+      env,
+      timeout: COMMAND_TIMEOUT_MS,
+      maxBuffer: MAX_OUTPUT_BYTES,
+      windowsHide: true
+    });
+    return result.stdout;
+  } catch (error) {
+    const failure = error;
+    return allowNonzero && typeof failure.code === "number" && !failure.killed && !failure.signal ? failure.stdout ?? "" : "";
+  }
+}
+function tmuxArgs(options, args) {
+  return options.tmuxSocket ? ["-S", options.tmuxSocket, ...args] : args;
+}
+export function shellSession() {
+  return { id: "shell", backend: "shell", name: "shell", label: "New shell", attached: false };
+}
+export function parseScreenListing(output) {
+  const sessions = [];
+  for (const line of output.split(/\r?\n/)) {
+    const match = /^\s*(\d+\.[A-Za-z0-9][A-Za-z0-9._:@+-]{0,127})\s+(?:\([^)]*\)\s+)?\((Attached|Detached)\)\s*$/.exec(line);
+    const target = match?.[1];
+    if (!target || !validScreenTarget(target))
+      continue;
+    if (sessions.length >= MAX_SESSIONS - 1)
+      break;
+    const name = target.slice(target.indexOf(".") + 1);
+    sessions.push({
+      id: `screen:${target}`,
+      backend: "screen",
+      name,
+      label: `screen · ${name}`,
+      attached: match?.[2] === "Attached"
+    });
+  }
+  return sessions;
+}
+export async function discoverTerminalSessions(options = {}, env = process.env) {
+  const sessions = [shellSession()];
+  const tmux = await commandOutput("tmux", tmuxArgs(options, ["list-sessions", "-F", "#{session_id}\t#{session_name}\t#{session_attached}"]), env);
+  for (const line of tmux.split(/\r?\n/)) {
+    const [target, name, attached] = line.split("\t");
+    if (!target || !/^\$[0-9]+$/.test(target) || !name || name.length > 128 || /[\x00-\x1f\x7f]/.test(name))
+      continue;
+    if (sessions.length >= MAX_SESSIONS)
+      break;
+    sessions.push({
+      id: `tmux:${target}`,
+      backend: "tmux",
+      name,
+      label: `tmux · ${name}`,
+      attached: attached === "1"
+    });
+  }
+  const screen = await commandOutput("screen", ["-ls"], env, true);
+  for (const found of parseScreenListing(screen)) {
+    if (sessions.length >= MAX_SESSIONS)
+      break;
+    sessions.push(found);
+  }
+  return sessions;
+}
+export function sessionCommand(session, options = {}) {
+  if (session.backend === "tmux" && /^tmux:\$[0-9]+$/.test(session.id)) {
+    return ["tmux", ...tmuxArgs(options, ["attach-session", "-t", session.id.slice(5)])];
+  }
+  if (session.backend === "screen" && validScreenTarget(session.id.slice(7)) && session.id === `screen:${session.id.slice(7)}`) {
+    return ["screen", "-x", session.id.slice(7)];
+  }
+  return;
+}
+export async function createTerminalSession(backend, name, cwd, options = {}) {
+  if (!validSessionName(name))
+    throw new Error("Session name must be 1–64 letters, digits, dots, hyphens or underscores, starting with a letter or digit.");
+  const env = { ...process.env };
+  delete env.DM_TTY_TOKEN;
+  delete env.STY;
+  delete env.WINDOW;
+  delete env.TMUX;
+  const [command, args] = backend === "tmux" ? ["tmux", tmuxArgs(options, ["new-session", "-d", "-s", name, "-c", cwd])] : ["screen", ["-dmS", name, "/bin/sh", "-i"]];
+  await execFileAsync(command, args, { cwd, env, timeout: COMMAND_TIMEOUT_MS, maxBuffer: MAX_OUTPUT_BYTES, windowsHide: true });
+}

package/extensions/dm-tty/standalone.js

@@ -0,0 +1,75 @@
+import { openSync, closeSync, writeFileSync, unlinkSync } from "node:fs";
+import { resolve } from "node:path";
+import { createTtyToken, DmTtyServer } from "./server.js";
+const USAGE = "dm --host HOST [--port PORT] [--cwd PATH] [--token-file PATH]";
+export function parseStandalone(args) {
+  const options = { host: "", port: 8765, cwd: process.cwd(), tokenFile: "" };
+  const seen = new Set;
+  for (let index = 0;index < args.length; index++) {
+    const arg = args[index];
+    const split = arg.indexOf("=");
+    const key = split < 0 ? arg : arg.slice(0, split);
+    const value = split < 0 ? args[++index] : arg.slice(split + 1);
+    if (!value || value.startsWith("--") || seen.has(key))
+      throw new Error(`Invalid option: ${key}. ${USAGE}`);
+    seen.add(key);
+    if (key === "--host")
+      options.host = value;
+    else if (key === "--port" && /^\d+$/.test(value))
+      options.port = Number(value);
+    else if (key === "--cwd")
+      options.cwd = resolve(value);
+    else if (key === "--token-file")
+      options.tokenFile = resolve(value);
+    else
+      throw new Error(`Unknown option: ${key}. ${USAGE}`);
+  }
+  if (!options.host || /[\s/]/.test(options.host))
+    throw new Error(`Invalid host. ${USAGE}`);
+  if (!Number.isInteger(options.port) || options.port < 0 || options.port > 65535)
+    throw new Error("Invalid port");
+  return options;
+}
+export async function runStandalone(args) {
+  const options = parseStandalone(args);
+  if (!process.stderr.isTTY && !options.tokenFile) {
+    throw new Error("Use --token-file PATH when stderr is not a terminal; tokens must not enter service logs.");
+  }
+  const token = createTtyToken();
+  let tokenCreated = false;
+  let server;
+  let stop;
+  const stopped = new Promise((done) => {
+    stop = done;
+  });
+  process.once("SIGINT", stop);
+  process.once("SIGTERM", stop);
+  try {
+    if (options.tokenFile) {
+      const descriptor = openSync(options.tokenFile, "wx", 384);
+      tokenCreated = true;
+      try {
+        writeFileSync(descriptor, `${token}
+`);
+      } finally {
+        closeSync(descriptor);
+      }
+    }
+    server = new DmTtyServer({ ...options, token });
+    const info = await server.start();
+    const host = ["0.0.0.0", "::"].includes(info.host) ? "127.0.0.1" : info.host;
+    console.log(`dm-tty: http://${host.includes(":") ? `[${host}]` : host}:${info.port}/`);
+    console.error(`Listening on ${info.host}:${info.port}. Full OS-user shell access; use SSH/HTTPS, never public HTTP.`);
+    if (options.tokenFile)
+      console.error("Access token written to the requested private file; removed on shutdown.");
+    else
+      console.error(`Token: ${token}`);
+    await Promise.race([stopped, server.closed]);
+  } finally {
+    process.removeListener("SIGINT", stop);
+    process.removeListener("SIGTERM", stop);
+    await server?.close();
+    if (tokenCreated)
+      unlinkSync(options.tokenFile);
+  }
+}