~ 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
376 lines · 10.7 KB Raw History
// Copyright 2026 The KCP Authors.
// SPDX-License-Identifier: Apache-2.0

import {
  encodeBase64,
  frame,
  GET_NONCE_NSID,
  KEEPALIVE_PATH,
  parseFrame,
  register,
  SUBSCRIBE_NSID,
} from "./ingress_ws.js";

function assertEquals(actual, expected) {
  const a = JSON.stringify(actual);
  const e = JSON.stringify(expected);
  if (a !== e) {
    throw new Error(`expected:\n${e}\nactual:\n${a}`);
  }
}

function assert(condition, message) {
  if (!condition) throw new Error(message);
}

const tick = () => new Promise((resolve) => setTimeout(resolve, 0));

class FakeWebSocket {
  static instances = [];

  constructor(url) {
    this.url = url;
    this.readyState = 1;
    this.sent = [];
    FakeWebSocket.instances.push(this);
  }

  send(data) {
    this.sent.push(data);
  }

  close() {
    this.readyState = 3;
  }

  emit(value) {
    this.onmessage?.({
      data: typeof value === "string" ? value : JSON.stringify(value),
    });
  }
}

function nonceFetch(nonce, calls = []) {
  // Like window.fetch, refuse to run as a method of another object.
  return async function (url, init) {
    if (this !== undefined && this !== globalThis) {
      throw new TypeError("Failed to execute 'fetch': Illegal invocation");
    }
    calls.push({ url, init });
    return new Response(JSON.stringify({ nonce: encodeBase64(nonce) }), {
      status: 200,
      headers: { "Content-Type": "application/json" },
    });
  };
}

Deno.test("frame encodes the lexicon discriminator first", () => {
  assertEquals(
    frame("request", { requestId: "r1", method: "GET" }),
    '{"$type":"com.fedproxy.temp.xrpc.subscribe#request","requestId":"r1","method":"GET"}',
  );
});

Deno.test("parseFrame recognizes every subscribe kind", () => {
  const kinds = [
    "registered",
    "request",
    "response",
    "subscribe",
    "subscriptionOpen",
    "subscriptionEvent",
    "subscriptionData",
    "subscriptionCancel",
    "subscriptionClose",
  ];
  for (const kind of kinds) {
    const parsed = parseFrame(frame(kind, { requestId: kind }));
    assert(parsed !== null, `parseFrame returned null for ${kind}`);
    assertEquals(parsed.kind, kind);
    assertEquals(parsed.$type, `${SUBSCRIBE_NSID}#${kind}`);
    assertEquals(parsed.requestId, kind);
  }
});

Deno.test("parseFrame rejects malformed and foreign frames", () => {
  assertEquals(parseFrame("not json"), null);
  assertEquals(parseFrame("[]"), null);
  assertEquals(parseFrame("null"), null);
  assertEquals(parseFrame('"text"'), null);
  assertEquals(parseFrame('{"$type":42}'), null);
  assertEquals(parseFrame('{"$type":"com.example.other#request"}'), null);
});

Deno.test("register posts the nonce request and builds the subscribe URL", async () => {
  FakeWebSocket.instances = [];
  const calls = [];
  const nonce = new Uint8Array([0, 1, 2, 250, 255]);
  const subscriber = await register({
    proxyHost: "relay.example.com",
    did: "did:plc:test",
    serviceAuth: "service-token",
    signer: (bytes) => bytes,
    fetchImpl: nonceFetch(nonce, calls),
    WebSocketImpl: (url) => new FakeWebSocket(url),
  });
  try {
    assertEquals(calls.length, 1);
    assertEquals(
      calls[0].url,
      `https://relay.example.com/xrpc/${GET_NONCE_NSID}`,
    );
    assertEquals(calls[0].init.method, "POST");
    assertEquals(
      calls[0].init.headers.Authorization,
      "Bearer service-token",
    );
    assertEquals(
      calls[0].init.body,
      '{"key":"did:plc:test","signatures":[]}',
    );

    assertEquals(FakeWebSocket.instances.length, 1);
    const url = new URL(FakeWebSocket.instances[0].url);
    assertEquals(url.protocol, "wss:");
    assertEquals(url.host, "relay.example.com");
    assertEquals(url.pathname, `/xrpc/${SUBSCRIBE_NSID}`);
    assertEquals(url.searchParams.get("did"), "did:plc:test");
    assertEquals(url.searchParams.get("service_auth"), "service-token");
    const registration = JSON.parse(url.searchParams.get("registration"));
    assertEquals(registration.$type, "com.fedproxy.temp.xrpc.registration");
    assertEquals(registration.key, "did:plc:test");
    assertEquals(registration.nonce, encodeBase64(nonce));
    assertEquals(registration.signatures, [
      { key: "did:plc:test", signature: encodeBase64(nonce) },
    ]);
  } finally {
    subscriber.close();
  }
});

Deno.test("register asks for a service-auth token per NSID", async () => {
  FakeWebSocket.instances = [];
  const seen = [];
  const calls = [];
  const subscriber = await register({
    proxyHost: "localhost:8787",
    did: "did:plc:test",
    getServiceAuthToken: (nsid) => {
      seen.push(nsid);
      return `token-for-${nsid}`;
    },
    signer: () => new Uint8Array([9]),
    fetchImpl: nonceFetch(new Uint8Array([7]), calls),
    WebSocketImpl: (url) => new FakeWebSocket(url),
  });
  try {
    assertEquals(seen, [GET_NONCE_NSID, SUBSCRIBE_NSID]);
    assertEquals(
      calls[0].init.headers.Authorization,
      `Bearer token-for-${GET_NONCE_NSID}`,
    );
    const url = new URL(FakeWebSocket.instances[0].url);
    assertEquals(url.protocol, "ws:");
    assertEquals(
      url.searchParams.get("service_auth"),
      `token-for-${SUBSCRIBE_NSID}`,
    );
  } finally {
    subscriber.close();
  }
});

Deno.test("a request frame is answered with a response frame", async () => {
  FakeWebSocket.instances = [];
  const seen = [];
  const subscriber = await register({
    proxyHost: "relay.example.com",
    did: "did:plc:test",
    serviceAuth: "token",
    signer: (bytes) => bytes,
    fetchImpl: nonceFetch(new Uint8Array([1, 2, 3])),
    WebSocketImpl: (url) => new FakeWebSocket(url),
    handler: async (request) => {
      seen.push(request);
      return {
        status: 201,
        body: { ok: true, path: request.path },
        contentType: "application/json",
        headers: { "x-test": "yes" },
      };
    },
  });
  try {
    const ws = FakeWebSocket.instances[0];
    ws.emit({
      $type: `${SUBSCRIBE_NSID}#registered`,
      subdomain: "did-plc-test",
      ingressRef: "did:web:did-plc-test.relay.example.com",
    });
    const info = await subscriber.ready;
    assertEquals(info.subdomain, "did-plc-test");
    assert(subscriber.connected, "subscriber reports connected");

    ws.emit({
      $type: `${SUBSCRIBE_NSID}#request`,
      requestId: "req-1",
      method: "POST",
      path: "/xrpc/com.example.write",
      params: { a: "b" },
      body: { hello: "world" },
      rawBody: '{"hello":"world"}',
      headers: { "content-type": "application/json" },
    });
    await tick();

    assertEquals(seen.length, 1);
    assertEquals(seen[0], {
      requestId: "req-1",
      method: "POST",
      path: "/xrpc/com.example.write",
      params: { a: "b" },
      body: { hello: "world" },
      rawBody: '{"hello":"world"}',
      headers: { "content-type": "application/json" },
    });

    assertEquals(ws.sent.length, 1);
    const response = JSON.parse(ws.sent[0]);
    assertEquals(response.$type, `${SUBSCRIBE_NSID}#response`);
    assertEquals(response.requestId, "req-1");
    assertEquals(response.status, 201);
    assertEquals(response.body, { ok: true, path: "/xrpc/com.example.write" });
    assertEquals(response.contentType, "application/json");
    assertEquals(response.headers, { "x-test": "yes" });
  } finally {
    subscriber.close();
  }
});

Deno.test("a handler failure produces an InternalError response", async () => {
  FakeWebSocket.instances = [];
  const subscriber = await register({
    proxyHost: "relay.example.com",
    did: "did:plc:test",
    serviceAuth: "token",
    signer: (bytes) => bytes,
    fetchImpl: nonceFetch(new Uint8Array([1])),
    WebSocketImpl: (url) => new FakeWebSocket(url),
    handler: () => {
      throw new Error("boom");
    },
  });
  try {
    const ws = FakeWebSocket.instances[0];
    ws.emit({
      $type: `${SUBSCRIBE_NSID}#request`,
      requestId: "req-2",
      method: "GET",
      path: "/xrpc/com.example.read",
    });
    await tick();

    const response = JSON.parse(ws.sent[0]);
    assertEquals(response.requestId, "req-2");
    assertEquals(response.status, 500);
    assertEquals(response.contentType, "application/json");
    assertEquals(response.body, {
      error: "InternalError",
      message: "boom",
    });
  } finally {
    subscriber.close();
  }
});

Deno.test("keepalive requests are answered without the handler", async () => {
  FakeWebSocket.instances = [];
  const subscriber = await register({
    proxyHost: "relay.example.com",
    did: "did:plc:test",
    serviceAuth: "token",
    signer: (bytes) => bytes,
    fetchImpl: nonceFetch(new Uint8Array([1])),
    WebSocketImpl: (url) => new FakeWebSocket(url),
    handler: () => ({ status: 404, body: { error: "NotFound" } }),
  });
  try {
    const ws = FakeWebSocket.instances[0];
    ws.emit({
      $type: `${SUBSCRIBE_NSID}#request`,
      requestId: "keepalive-1",
      method: "GET",
      path: KEEPALIVE_PATH,
      params: {},
      body: null,
      headers: {},
    });
    await tick();

    const response = JSON.parse(ws.sent[0]);
    assertEquals(response.requestId, "keepalive-1");
    assertEquals(response.status, 204);
  } finally {
    subscriber.close();
  }
});

Deno.test("response bodies are sent as raw JSON when possible", async () => {
  FakeWebSocket.instances = [];
  let body = '{"raw":true}';
  const subscriber = await register({
    proxyHost: "relay.example.com",
    did: "did:plc:test",
    serviceAuth: "token",
    signer: (bytes) => bytes,
    fetchImpl: nonceFetch(new Uint8Array([1])),
    WebSocketImpl: (url) => new FakeWebSocket(url),
    handler: () => ({ status: 200, body }),
  });
  try {
    const ws = FakeWebSocket.instances[0];
    ws.emit({
      $type: `${SUBSCRIBE_NSID}#request`,
      requestId: "req-3",
      method: "GET",
      path: "/xrpc/com.example.read",
    });
    await tick();
    assertEquals(JSON.parse(ws.sent[0]).body, { raw: true });

    body = "plain text";
    ws.emit({
      $type: `${SUBSCRIBE_NSID}#request`,
      requestId: "req-4",
      method: "GET",
      path: "/xrpc/com.example.read",
    });
    await tick();
    assertEquals(JSON.parse(ws.sent[1]).body, "plain text");
  } finally {
    subscriber.close();
  }
});

Deno.test("connecting is true only while the socket is CONNECTING", async () => {
  FakeWebSocket.instances = [];
  const subscriber = await register({
    proxyHost: "relay.example.com",
    did: "did:plc:test",
    serviceAuth: "service-token",
    signer: (bytes) => bytes,
    fetchImpl: nonceFetch(new Uint8Array([1])),
    WebSocketImpl: (url) => new FakeWebSocket(url),
    reconnect: false,
  });
  try {
    const ws = FakeWebSocket.instances[0];
    ws.readyState = 0;
    assertEquals(subscriber.connecting, true);
    ws.readyState = 1;
    assertEquals(subscriber.connecting, false);
  } finally {
    subscriber.close();
  }
  assertEquals(subscriber.connecting, false);
});