@honeybbq/teamspeak 1.0.0-beta.19 → 1.0.0-beta.21

package/src/query/ssh.ts

@@ -591,10 +591,17 @@ function loginOf(options: SshChoice): { username: string; password: string | und
     return { username: "guest", password: undefined };
   }
   const hint = "; to connect without a login, as a guest, set guest to true";
-  return {
-    username: nonEmptyString(options.username, "username", hint),
-    password: nonEmptyString(options.password, "password", hint),
-  };
+  const username = nonEmptyString(options.username, "username", hint);
+  // Measured on TeamSpeak 6 6.0.0-beta13.1: the user `guest` logs in as a guest
+  // whatever password it is given, the administrator's included, so a password
+  // sent with it is silently ignored and the access is not the account's. The
+  // server matches the name exactly: `GUEST` is refused.
+  if (username === "guest") {
+    throw new TypeError(
+      '"guest" is the server\'s guest user, which takes no password; to connect as a guest, set guest to true',
+    );
+  }
+  return { username, password: nonEmptyString(options.password, "password", hint) };
 }
 
 function nonEmptyString(value: unknown, name: string, hint = ""): string {

package/src/query/stream.ts

@@ -10,6 +10,8 @@ export interface QueryStream {
   write(data: string, callback: (error?: Error | null) => void): unknown;
   /** Close the stream. */
   end(): unknown;
+  /** Drop the stream without waiting for the peer; used for a peer that must not be read on. */
+  destroy?(): unknown;
   /** Listen for each chunk received. */
   on(event: "data", listener: (chunk: Uint8Array) => void): unknown;
   /** Listen for a failure, which ends the connection. */
@@ -129,8 +131,22 @@ export class StreamTransport implements QueryTransport {
   }
 
   #handleData(chunk: Uint8Array): void {
+    if (this.#ended) return;
     this.#bytesReceived += chunk.byteLength;
-    for (const line of this.#reader.push(chunk)) {
+    let lines: string[];
+    try {
+      lines = this.#reader.push(chunk);
+    } catch (error) {
+      // A server that is not speaking ServerQuery: nothing more is read, and
+      // the connection ends with the reason.
+      this.#error = error as Error;
+      this.onLine = null;
+      if (this.#stream.destroy === undefined) this.#stream.end();
+      else this.#stream.destroy();
+      this.#handleClose();
+      return;
+    }
+    for (const line of lines) {
       if (this.#banner > 0) {
         this.#banner--;
         continue;

package/src/query/testing/live.ts

@@ -178,9 +178,9 @@ export class LiveSession {
     return this.#knownHosts;
   }
 
-  /** Probe the SSH host key once, then connect one client per transport. */
-  async open(): Promise<void> {
-    if (KINDS.includes("ssh")) {
+  /** Probe the SSH host key once, then connect one client per transport, or per `kinds` when given. */
+  async open(kinds: readonly Kind[] = KINDS): Promise<void> {
+    if (kinds.includes("ssh")) {
       if (SSH_KNOWN_HOSTS !== "") {
         this.#knownHosts = SSH_KNOWN_HOSTS;
       } else {
@@ -192,7 +192,7 @@ export class LiveSession {
         );
       }
     }
-    for (const kind of KINDS) {
+    for (const kind of kinds) {
       const client = new QueryClient(optionsFor(kind, this.#knownHosts));
       await connectWithRetries(client);
       this.clients.set(kind, client);

package/src/query/transport.ts

@@ -53,8 +53,16 @@ export interface QueryTransport {
    * run.
    */
   readonly supportsNotifications: boolean;
-  /** Send one command line; the transport adds the line terminator. */
-  send(line: string): Promise<void>;
+  /**
+   * Send one command line; the transport adds the line terminator.
+   *
+   * `signal` aborts when the command has stopped waiting for its answer, by
+   * timeout, cancel or close. A transport whose `send` carries the whole round
+   * trip, as WebQuery's does, ends the request and rejects; a stream has
+   * nothing to take back once the line is written, and ignores it. A transport
+   * that ignores it must not deliver the answer to the next command either.
+   */
+  send(line: string, options?: { readonly signal?: AbortSignal }): Promise<void>;
   /**
    * Called with each line the server sends, without its terminator, in the
    * order received.

package/src/query/web.ts

@@ -127,6 +127,7 @@ export class WebQueryTransport implements QueryTransport {
   #prefix: string;
   #fetch: typeof fetch;
   #closed = false;
+  #inFlight = new Set<AbortController>();
   #openedAt = new Date();
   #bytesSent = 0;
   #bytesReceived = 0;
@@ -155,7 +156,7 @@ export class WebQueryTransport implements QueryTransport {
     this.#fetch = options.fetch ?? nodeFetch;
   }
 
-  async send(line: string): Promise<void> {
+  async send(line: string, options?: { readonly signal?: AbortSignal }): Promise<void> {
     if (this.#closed) throw new Error("the query connection is closed");
     const rows = splitCommandRows(line)
       .map((row) => parseCommand(row))
@@ -169,23 +170,52 @@ export class WebQueryTransport implements QueryTransport {
 
     const params = rows.map((row) => ({ ...row.params }));
     const body = JSON.stringify(params.length === 1 ? params[0] : params);
-    const response = await this.#fetch(`${this.#base}${this.#prefix}/${name}`, {
-      method: "POST",
-      headers: {
-        ...(this.#apiKey === undefined ? {} : { "x-api-key": this.#apiKey }),
-        "content-type": "application/json",
-      },
-      body,
-    });
-    this.#bytesSent += Buffer.byteLength(body);
-
+    // One controller per request: the command's own signal and `close()` both
+    // end it, so a request nobody waits for any more is not left running.
+    const abort = new AbortController();
+    this.#inFlight.add(abort);
+    const onAbort = (): void => abort.abort(options?.signal?.reason);
+    if (options?.signal?.aborted === true) onAbort();
+    else options?.signal?.addEventListener("abort", onAbort, { once: true });
+    let response: Response;
     let answer: WebAnswer | undefined;
     try {
-      const text = await response.text();
-      this.#bytesReceived += Buffer.byteLength(text);
-      answer = JSON.parse(text) as WebAnswer;
-    } catch {
-      // Not JSON: nothing the server said about the command.
+      response = await this.#fetch(`${this.#base}${this.#prefix}/${name}`, {
+        method: "POST",
+        headers: {
+          ...(this.#apiKey === undefined ? {} : { "x-api-key": this.#apiKey }),
+          "content-type": "application/json",
+        },
+        body,
+        // The api key is a header, and a followed redirect would carry it to
+        // whatever host the answer names: the 3xx is the answer.
+        redirect: "manual",
+        signal: abort.signal,
+      });
+      this.#bytesSent += Buffer.byteLength(body);
+
+      let text: string | undefined;
+      try {
+        text = await response.text();
+      } catch (error) {
+        // An abort is the command's end, not an answer that was not JSON.
+        if (abort.signal.aborted) throw error;
+      }
+      if (text !== undefined) {
+        this.#bytesReceived += Buffer.byteLength(text);
+        try {
+          answer = JSON.parse(text) as WebAnswer;
+        } catch {
+          // Not JSON: nothing the server said about the command.
+        }
+      }
+      // A fetch that ignores its signal still answers late. The command that
+      // asked has given up, and the client may be waiting on the next one: its
+      // lines must not be this answer's.
+      if (abort.signal.aborted) throw abortReason(abort.signal);
+    } finally {
+      options?.signal?.removeEventListener("abort", onAbort);
+      this.#inFlight.delete(abort);
     }
     const code = answer?.status?.code;
     if (typeof code !== "number") throw new WebQueryHttpError(response.status, response.statusText);
@@ -228,6 +258,9 @@ export class WebQueryTransport implements QueryTransport {
   close(): Promise<void> {
     if (this.#closed) return Promise.resolve();
     this.#closed = true;
+    // Nothing is waiting for these any more, and none may deliver a line.
+    for (const request of this.#inFlight)
+      request.abort(new Error("the query connection is closed"));
     this.onClose?.(undefined);
     return Promise.resolve();
   }
@@ -251,11 +284,29 @@ export class WebQueryTransport implements QueryTransport {
   }
 }
 
-/** One answer row as a line of `key=value` fields; a field that is not text is written as text. */
+/** Why an aborted request ended: the signal's own reason, as an error. */
+function abortReason(signal: AbortSignal): Error {
+  const reason: unknown = signal.reason;
+  return reason instanceof Error ? reason : new Error("the WebQuery request was aborted");
+}
+
+/**
+ * One JSON value as the text a command line carries: a string as it is, a
+ * number as written, a boolean as `1` or `0`, and anything else (a null, a
+ * nested object) as empty, which is a field the row did not carry. WebQuery
+ * sends every value as a string, measured on TeamSpeak 3 and 6; this is for
+ * a server that does not.
+ */
+function valueText(value: unknown): string {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "bigint") return String(value);
+  if (typeof value === "boolean") return value ? "1" : "0";
+  return "";
+}
+
+/** One answer row as a line of `key=value` fields. */
 function rowLine(row: object): string {
-  const fields = Object.entries(row).map(
-    ([key, value]) => [key, typeof value === "string" ? value : String(value)] as const,
-  );
+  const fields = Object.entries(row).map(([key, value]) => [key, valueText(value)] as const);
   // buildCommandOrdered writes a name first; a row has none.
   return buildCommandOrdered("", fields).slice(1);
 }
@@ -270,7 +321,11 @@ const nodeFetch = ((url: string, init: RequestInit) =>
     const request = new URL(url).protocol === "https:" ? httpsRequest : httpRequest;
     const req = request(
       url,
-      { method: init.method, headers: init.headers as Record<string, string> },
+      {
+        method: init.method,
+        headers: init.headers as Record<string, string>,
+        ...(init.signal ? { signal: init.signal } : {}),
+      },
       (res) => {
         const chunks: Buffer[] = [];
         res.on("data", (chunk: Buffer) => chunks.push(chunk));

package/src/stream/published.ts

@@ -43,6 +43,22 @@ export interface PublishHost {
   stopped(streamId: string, reason: number): void;
 }
 
+/** How many identity lookups of one stream run at once. */
+const MAX_LOOKUPS = 8;
+
+/**
+ * A request waiting to be announced. The slot itself is the request's token: a
+ * lookup answers for the slot it was made for, not for whatever request the
+ * same client id has by then.
+ */
+interface Slot {
+  readonly clientId: ClientID;
+  readonly message: string;
+  identity: ViewerIdentity | undefined;
+  /** Whether the lookup is out. */
+  looking: boolean;
+}
+
 class JoinRequestImpl implements JoinRequest {
   readonly streamId: string;
   readonly viewer: ViewerIdentity;
@@ -133,9 +149,9 @@ export class PublishedImpl implements PublishedStream {
   #peers = new Map<ClientID, ViewerPeerImpl>();
   #pending = new Map<ClientID, JoinRequestImpl>();
   /** Viewers asked about, until the answer comes back, so that a repeat is no new request. */
-  #resolving = new Set<ClientID>();
-  /** Requests are announced in the order they came, whatever the lookups take. */
-  #announcing: Promise<void> = Promise.resolve();
+  #resolving = new Map<ClientID, Slot>();
+  /** Requests are announced in the order they came, whatever the lookups take; the lookups run side by side. */
+  #slots: Slot[] = [];
   #lookups = 0;
   /** Viewers whose peer is over: what they still send is not worth a report. */
   #closedViewers = new Set<ClientID>();
@@ -210,31 +226,60 @@ export class PublishedImpl implements PublishedStream {
     // Asking again while pending, being looked up or let in is no new request.
     if (this.#ended || this.#peers.has(clientId) || this.#resolving.has(clientId)) return;
     if (this.#pending.get(clientId)?.state === "pending") return;
-    this.#resolving.add(clientId);
-    const identity = this.host.identity(clientId);
-    const announce = (viewer: ViewerIdentity): void => {
-      // Withdrawn, or the stream over, while the lookup was out.
-      if (!this.#resolving.delete(clientId) || this.#ended) return;
-      if (this.host.isDenied(viewer)) return;
-      const request = new JoinRequestImpl(this, viewer, message);
-      this.#pending.set(clientId, request);
-      this.#emitter.emit("request", request);
-    };
-    // Nothing to wait for, and nothing ahead of it to wait for: at once.
-    if (!(identity instanceof Promise) && this.#lookups === 0) {
-      announce(identity);
-      return;
+    const slot: Slot = { clientId, message, identity: undefined, looking: false };
+    this.#resolving.set(clientId, slot);
+    this.#slots.push(slot);
+    this.#advance();
+  }
+
+  /** Start the lookups that may start, then announce the requests whose turn it is. */
+  #advance(): void {
+    for (const slot of this.#slots) {
+      if (slot.identity !== undefined || slot.looking) continue;
+      if (this.#resolving.get(slot.clientId) !== slot) continue;
+      if (this.#lookups >= MAX_LOOKUPS) break;
+      const identity = this.host.identity(slot.clientId);
+      if (!(identity instanceof Promise)) {
+        slot.identity = identity;
+        continue;
+      }
+      slot.looking = true;
+      this.#lookups++;
+      void identity.then((viewer) => {
+        slot.looking = false;
+        this.#lookups--;
+        slot.identity = viewer;
+        this.#advance();
+      });
+    }
+    // In the order they came: a request waits for the ones ahead of it.
+    while (this.#slots.length > 0) {
+      const head = this.#slots[0]!;
+      const current = this.#resolving.get(head.clientId) === head && !this.#ended;
+      if (current && head.identity === undefined) break;
+      this.#slots.shift();
+      if (current) this.#announce(head);
     }
-    this.#lookups++;
-    this.#announcing = this.#announcing
-      .then(() => identity)
-      .then(announce)
-      .finally(() => this.#lookups--);
+  }
+
+  #announce(slot: Slot): void {
+    this.#resolving.delete(slot.clientId);
+    const viewer = slot.identity!;
+    if (this.host.isDenied(viewer)) return;
+    const request = new JoinRequestImpl(this, viewer, slot.message);
+    this.#pending.set(slot.clientId, request);
+    this.#emitter.emit("request", request);
   }
 
   /** The client left view: a request of its that nobody answered is forgotten, as the clid may be reused. */
   dropPending(clientId: ClientID): void {
-    this.#resolving.delete(clientId);
+    const slot = this.#resolving.get(clientId);
+    if (slot !== undefined) {
+      this.#resolving.delete(clientId);
+      // One whose lookup is out stays until it answers, which counts it.
+      if (!slot.looking) this.#slots.splice(this.#slots.indexOf(slot), 1);
+      this.#advance();
+    }
     this.#pending.get(clientId)?.close("withdrawn");
     this.#pending.delete(clientId);
   }
@@ -261,6 +306,8 @@ export class PublishedImpl implements PublishedStream {
   finish(ended: StreamEnded): void {
     if (this.#ended) return;
     this.#ended = true;
+    this.#slots.length = 0;
+    this.#resolving.clear();
     for (const request of this.#pending.values()) request.close("ended");
     this.#pending.clear();
     const cause =

package/src/stream/streams.ts

@@ -42,10 +42,10 @@ import {
   assertFits,
   clientOf,
   infoRequest,
-  intOf,
   joinRequest,
   sameInfo,
   setupRequest,
+  reasonOf,
   signalRequest,
   sourceToWire,
   STREAM_P2P,
@@ -78,6 +78,8 @@ const GONE_GRACE_MS = 2000;
 const ANNOUNCE_WINDOW_MS = 5000;
 /** How many streams stopped for a publish that gave up are remembered, to ignore their late rows. */
 const MAX_ORPHANS = 16;
+/** How many streams the server or this client stopped are remembered, so that a late answer does not bring one back. */
+const MAX_STOPPED = 256;
 
 function signalOption(signal: AbortSignal | undefined): CommandOptions {
   return signal === undefined ? {} : { signal };
@@ -152,6 +154,11 @@ export class Streams {
    * not bring it back.
    */
   readonly #orphans = new Set<string>();
+  /**
+   * Streams that were stopped, newest last. A `setupstream` answered after
+   * its stream's `notifystreamstopped` must not adopt a stream that is over.
+   */
+  readonly #stopped = new Set<string>();
   #disposed = false;
 
   /**
@@ -344,6 +351,11 @@ export class Streams {
         this.#orphan(info);
         return;
       }
+      if (this.#stopped.has(info.id)) {
+        // Stopped before its own answer came: there is nothing to adopt.
+        attempt.outcome.reject(new StreamEndedError(info.id));
+        return;
+      }
       attempt.outcome.resolve(this.#adopt(info));
     } finally {
       this.#publishing.delete(attempt);
@@ -409,12 +421,16 @@ export class Streams {
     };
     this.#watching.set(id, watch);
     this.#closedViews.delete(id);
+    // Whether the join request left the flood throttle: only then may it be answered.
+    let sent = false;
     try {
-      await this.#send(
-        joinRequest(id, streamer, options.message ?? "", false),
-        id,
-        signalOption(options.signal),
-      );
+      await this.#send(joinRequest(id, streamer, options.message ?? "", false), id, {
+        ...signalOption(options.signal),
+        onSent: () => {
+          sent = true;
+        },
+      });
+      sent = true;
       return await within(
         watch.settled.promise,
         "joinstreamrequest",
@@ -422,15 +438,26 @@ export class Streams {
         options.signal,
       );
     } catch (error) {
-      if (this.#watching.get(id) === watch && watch.view === undefined) {
-        this.#watching.delete(id);
-        // Asked and not answered, or answered without a usable offer: withdraw.
+      if (this.#watching.get(id) !== watch || watch.view !== undefined) {
+        // Settled while the request was being sent, or while this gave up: the
+        // view, or the refusal, is the outcome. The stream's end can be heard
+        // while the request is sent; the server's own refusal then says more.
+        if (watch.view !== undefined) return watch.view;
+        if (error instanceof StreamEndedError) throw error;
+        return await watch.settled.promise;
+      }
+      this.#watching.delete(id);
+      if (error instanceof StreamEndedError) {
+        // 5635 on a join request: the stream is gone, whatever this client heard.
+        this.#end(id, 0, "gone");
+      } else {
+        // Asked and not answered, or answered without a usable offer: withdraw,
+        // if the request may have reached the server.
         const answered =
           error instanceof StreamJoinDeniedError ||
-          error instanceof StreamEndedError ||
           error instanceof NotConnectedError ||
           error instanceof ServerError;
-        if (!answered) void this.#leave(id, streamer).catch(() => {});
+        if (sent && !answered) this.#bestEffort(this.#leave(id, streamer));
       }
       throw error;
     }
@@ -618,7 +645,7 @@ export class Streams {
       case "notifystreamstopped": {
         const id = params["id"] ?? "";
         if (id !== "") {
-          this.#end(id, intOf(params, "reason", 0), "server");
+          this.#end(id, reasonOf(params), "server");
           this.#orphans.delete(id);
         }
         break;
@@ -664,7 +691,7 @@ export class Streams {
       watch.settled.reject(
         new TeamspeakError("the publisher accepted the request without an offer"),
       );
-      void this.#leave(id, watch.streamer).catch(() => {});
+      this.#bestEffort(this.#leave(id, watch.streamer));
       return;
     }
     const view = new StreamViewImpl(id, watch.streamer, offer, {
@@ -731,6 +758,12 @@ export class Streams {
 
   /** A stream is over, for whatever hangs on it, and is forgotten. */
   #end(id: string, reason: number, cause: "stopped" | "server" | "gone"): void {
+    if (cause !== "gone") {
+      this.#stopped.delete(id);
+      this.#stopped.add(id);
+      if (this.#stopped.size > MAX_STOPPED)
+        this.#stopped.delete(this.#stopped.values().next().value!);
+    }
     const info = this.#infos.get(id);
     this.#infos.delete(id);
     if (
@@ -764,6 +797,7 @@ export class Streams {
     }
     this.#publishing.clear();
     this.#orphans.clear();
+    this.#stopped.clear();
 
     const ended: StreamEnded = { cause, reason: 0 };
     const published = [...this.#published.values()];

package/src/stream/wire.ts

@@ -203,6 +203,17 @@ export type Signal =
   | { readonly kind: "candidate"; readonly candidate: IceCandidate }
   | { readonly kind: "raw"; readonly signal: RawSignal };
 
+/** Whether `value` is an integer an unsigned 16-bit field holds. */
+function isUint16(value: unknown): value is number {
+  return (
+    typeof value === "number" &&
+    Number.isInteger(value) &&
+    value >= 0 &&
+    value <= 0xffff &&
+    !Object.is(value, -0)
+  );
+}
+
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -253,7 +264,7 @@ export function parseSignal(json: string): Signal {
         candidate: {
           candidate: args["sdp"],
           sdpMid: typeof mid === "string" ? mid : null,
-          sdpMLineIndex: typeof line === "number" && Number.isInteger(line) ? line : null,
+          sdpMLineIndex: isUint16(line) ? line : null,
         },
       };
     }
@@ -268,6 +279,17 @@ function int(raw: string | undefined): number | undefined {
   return raw !== undefined && /^-?\d{1,15}$/.test(raw) ? Number(raw) : undefined;
 }
 
+/**
+ * An unsigned 32-bit number, which is what a source, an accessibility, a mode
+ * and a stop reason are; undefined when it is absent, none, or out of range.
+ * `maxDigits` bounds the text, as for the signed numbers.
+ */
+function uint32(raw: string | undefined, maxDigits = 15): number | undefined {
+  if (raw === undefined || !/^\d+$/.test(raw) || raw.length > maxDigits) return undefined;
+  const n = Number(raw);
+  return n <= 0xffff_ffff ? n : undefined;
+}
+
 /**
  * The stream a `notifystreamstarted` or `notifystreaminfo` describes, merged
  * over what was known of it. Undefined for the empty `notifystreaminfo` the
@@ -283,9 +305,9 @@ export function streamInfoFrom(
   const id = params["id"];
   if (id === undefined || id === "") return undefined;
 
-  const type = int(params["type"]);
-  const access = int(params["accessibility"] ?? params["access"]);
-  const mode = int(params["mode"]);
+  const type = uint32(params["type"]);
+  const access = uint32(params["accessibility"] ?? params["access"]);
+  const mode = uint32(params["mode"]);
   const bitrate = int(params["bitrate"]);
   const limit = int(params["viewer_limit"]);
   const viewers = int(params["viewer"]);
@@ -326,13 +348,10 @@ export function clientOf(params: Readonly<Record<string, string>>, key: string):
   return asClientID(parseUint16(params[key] ?? ""));
 }
 
-/** The integer a notification carries under `key`, or `fallback`. */
-export function intOf(
-  params: Readonly<Record<string, string>>,
-  key: string,
-  fallback: number,
-): number {
-  return int(params[key]) ?? fallback;
+/** The stop reason a notification carries; 0 when it carries none. */
+export function reasonOf(params: Readonly<Record<string, string>>): number {
+  // No bound on the digits: leading zeros are as good as none.
+  return uint32(params["reason"], Infinity) ?? 0;
 }
 
 /** Whether an SDP has an audio media section. */