~ knotless Search/
↑↓ move↵ open⇧↵ all results

johnandersen777.bsky.social/socialweb-computer-console

console.socialweb.computer: kcp, kubectl and ssh compiled to wasm in a browser tab with a terminal; a kcp fork

0
0
main
245 lines · 7.3 KB Raw History
// Copyright 2026 The KCP Authors.
// SPDX-License-Identifier: Apache-2.0

// The page's link to the dev server's /debug hooks: the debug log sender
// (POST /debug/log) and the control stream client (GET /debug/control). Both
// outlive dev-server restarts and tunnel outages. fedproxy answers 404 "no
// route configured for host" while the tunnel is down, so a 404/405 means a
// host without the endpoint (a static deploy) only before the first success.

export const RETRY_MAX_MS = 30_000;

const noEndpoint = (status) => status === 404 || status === 405;

// Lines wait in a bounded buffer (oldest dropped and counted) while the server
// is unreachable and go out again with backoff (1 s doubling to 30 s). One
// request is in flight at a time. post(body) resolves to the HTTP status, 0 for
// a network error or timeout. onReconnect({downMs, dropped}) runs once after
// the first success that follows a failure or a drop.
export class DebugLogSender {
  constructor({
    post,
    encode,
    setTimer = (fn, ms) => setTimeout(fn, ms),
    now = () => Date.now(),
    max = 2000,
    batchLines = 400,
    batchBytes = 200_000,
    delayMs = 100,
    maxRetryMs = RETRY_MAX_MS,
    onDisabled = () => {},
    onReconnect = () => {},
  }) {
    Object.assign(this, { post, encode, setTimer, now, max, batchLines, batchBytes, delayMs, maxRetryMs, onDisabled, onReconnect });
    this.queue = [];
    this.dropped = 0;
    this.delivered = false;
    this.disabled = false;
    this.inFlight = false;
    this.retryMs = 0;
    this.downSince = 0;
    this.timer = null;
  }

  push(line) {
    if (this.disabled) return;
    this.queue.push(line);
    this.#trim();
    if (!this.inFlight) this.#schedule(this.retryMs || this.delayMs);
  }

  // Send now unless the server is known to be down (the retry timer does).
  flush() {
    if (this.retryMs > 0) return Promise.resolve();
    return this.#send();
  }

  // Everything still queued, encoded, for a last keepalive request on pagehide.
  takeAll() {
    if (this.disabled || this.queue.length === 0) return null;
    const body = this.encode(this.queue);
    this.queue = [];
    return body;
  }

  #trim() {
    const over = this.queue.length - this.max;
    if (over > 0) {
      this.queue.splice(0, over);
      this.dropped += over;
    }
  }

  #schedule(ms) {
    if (this.timer !== null) return;
    this.timer = this.setTimer(() => {
      this.timer = null;
      this.#send();
    }, ms);
  }

  async #send() {
    if (this.disabled || this.inFlight || this.queue.length === 0) return;
    let n = Math.min(this.queue.length, this.batchLines);
    let body = this.encode(this.queue.slice(0, n));
    while (body.length > this.batchBytes && n > 1) {
      n = Math.ceil(n / 2);
      body = this.encode(this.queue.slice(0, n));
    }
    const batch = this.queue.splice(0, n);
    this.inFlight = true;
    let status = 0;
    try {
      status = await this.post(body);
    } catch {
      status = 0;
    }
    this.inFlight = false;
    if (status >= 200 && status < 300) return this.#ok();
    if (noEndpoint(status) && !this.delivered) {
      this.disabled = true;
      this.queue = [];
      this.onDisabled(status);
      return;
    }
    if (status === 400 || status === 413) {
      // The server is up and refused this batch; resending cannot help.
      this.dropped += batch.length;
      return this.#ok();
    }
    this.queue.unshift(...batch);
    this.#trim();
    this.downSince ||= this.now();
    this.retryMs = Math.min(Math.max(this.retryMs * 2, 1000), this.maxRetryMs);
    this.#schedule(this.retryMs);
  }

  #ok() {
    this.delivered = true;
    this.retryMs = 0;
    if (this.downSince || this.dropped) {
      const report = { downMs: this.downSince ? this.now() - this.downSince : 0, dropped: this.dropped };
      this.downSince = 0;
      this.dropped = 0;
      this.onReconnect(report);
    }
    if (this.queue.length) this.#schedule(0);
  }
}

// The control stream: an EventSource reopened with backoff (2 s doubling to
// 30 s) after any error, after an open that takes longer than openTimeoutMs
// (a stalled tunnel holds the request), and, once the server has sent a "ping"
// event, after idleTimeoutMs without one (a stalled tunnel keeps a dead stream
// open). kick() reopens it now (the log sender saw the server come back).
// probe() resolves to the status of HEAD /debug/control; a 404/405 before the
// first open means the server has no control stream and stops the client.
export class ControlStream {
  constructor({
    url,
    open,
    probe = () => Promise.resolve(0),
    onCommand,
    log = () => {},
    setTimer = (fn, ms) => setTimeout(fn, ms),
    clearTimer = (id) => clearTimeout(id),
    now = () => Date.now(),
    retryMs = 2_000,
    maxRetryMs = RETRY_MAX_MS,
    openTimeoutMs = 30_000,
    idleTimeoutMs = 45_000,
  }) {
    Object.assign(this, { url, open, probe, onCommand, log, setTimer, clearTimer, now, maxRetryMs, openTimeoutMs, idleTimeoutMs });
    this.initialRetryMs = retryMs;
    this.retryMs = retryMs;
    this.source = null;
    this.watch = null;
    this.timer = null;
    this.everOpened = false;
    this.serverPings = false;
    this.downSince = 0;
    this.stopped = false;
  }

  start() {
    if (!this.stopped && !this.source && this.timer === null) this.#connect();
  }

  kick() {
    if (this.stopped) return;
    this.retryMs = this.initialRetryMs;
    if (this.timer !== null) {
      this.clearTimer(this.timer);
      this.timer = null;
      this.#connect();
    } else if (this.source) {
      this.#fail(true);
    }
  }

  #connect() {
    this.timer = null;
    const source = this.open(this.url);
    this.source = source;
    this.#arm(this.openTimeoutMs);
    source.onopen = () => {
      if (source !== this.source) return;
      const downMs = this.downSince ? this.now() - this.downSince : 0;
      this.retryMs = this.initialRetryMs;
      this.everOpened = true;
      this.downSince = 0;
      this.#arm(this.serverPings ? this.idleTimeoutMs : null);
      this.log(downMs ? `reconnected after ${Math.round(downMs / 1000)} s` : "connected");
    };
    source.onerror = () => {
      if (source === this.source) this.#fail(false);
    };
    source.onmessage = (event) => {
      if (source !== this.source) return;
      this.#alive();
      this.onCommand(event.data);
    };
    source.addEventListener?.("ping", () => {
      if (source !== this.source) return;
      this.serverPings = true;
      this.#alive();
    });
  }

  #alive() {
    this.#arm(this.serverPings ? this.idleTimeoutMs : null);
  }

  #arm(ms) {
    if (this.watch !== null) this.clearTimer(this.watch);
    this.watch = ms === null ? null : this.setTimer(() => {
      this.watch = null;
      if (this.source) this.#fail(false);
    }, ms);
  }

  async #fail(immediate) {
    const source = this.source;
    if (!source) return;
    this.source = null;
    source.close();
    this.#arm(null);
    this.downSince ||= this.now();
    if (!this.everOpened) {
      let status = 0;
      try {
        status = await this.probe();
      } catch {
        status = 0;
      }
      if (noEndpoint(status)) {
        this.stopped = true;
        return;
      }
    }
    if (this.stopped || this.source || this.timer !== null) return;
    const delay = immediate ? 0 : this.retryMs;
    if (!immediate) this.retryMs = Math.min(this.retryMs * 2, this.maxRetryMs);
    this.timer = this.setTimer(() => this.#connect(), delay);
  }
}