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

// deno test --allow-net scripts/browser/webrtc_guest_test.js

import {
  agentStartEvent,
  authorizedKey,
  contractEventManifest,
  dialGuest,
  fingerprintMatches,
  firstOpened,
  guestFromState,
  newAgeIdentity,
  NSID_PUBLIC_KEY,
  NSID_SIGNAL,
  seal,
  NSID_R2_START,
  r2StartEvent,
  schemaHasR2Start,
} from "./webrtc_guest.js";

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

Deno.test("fingerprintMatches requires every a=fingerprint to be the onNetwork one", () => {
  const fp = "sha-256 AB:CD:EF";
  const sdp = "v=0\r\na=fingerprint:sha-256 ab:cd:ef\r\nm=application\r\na=fingerprint:sha-256 AB:CD:EF\r\n";
  assert(fingerprintMatches(sdp, fp), "matching fingerprints, any case");
  assert(!fingerprintMatches(sdp + "a=fingerprint:sha-256 00:11\r\n", fp), "one extra fingerprint");
  assert(!fingerprintMatches("v=0\r\n", fp), "no fingerprint");
  assert(!fingerprintMatches(sdp, ""), "no expected value");
});

Deno.test("authorizedKey is the ssh-ed25519 wire form", () => {
  const line = authorizedKey(new Uint8Array(32), "c");
  // 00 00 00 0b "ssh-ed25519" 00 00 00 20 + 32 zero bytes
  assert(line === "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA c", line);
});

Deno.test("guestFromState needs key, webrtc fingerprint and host keys", () => {
  const state = {
    contracts: [{ name: "c", networks: [{ tag: "ssh", kind: "webrtc", address: "sha-256 AA" }], hostKeys: ["ssh-ed25519 X"] }],
    contractEvents: [
      { name: "a", contract: "c", direction: "inbound", nsid: NSID_PUBLIC_KEY, tag: "ssh", key: "age1old", createdAt: "1" },
      { name: "b", contract: "c", direction: "inbound", nsid: NSID_PUBLIC_KEY, tag: "ssh", key: "age1new", createdAt: "2" },
      { name: "o", contract: "c", direction: "outbound", nsid: NSID_PUBLIC_KEY, tag: "ssh", key: "age1mine", createdAt: "3" },
    ],
  };
  const guest = guestFromState(state, "c");
  assert(guest?.key === "age1new" && guest.fingerprint === "sha-256 AA", JSON.stringify(guest));
  assert(guestFromState({ ...state, contractEvents: [] }, "c") === null, "no publicKey yet");
});

Deno.test("contractEventManifest", () => {
  const m = contractEventManifest({ name: "n", contract: "c", nsid: NSID_SIGNAL, kind: "offer", ciphertext: "x" });
  assert(m.kind === "ContractEvent" && m.spec.contractRef.name === "c" && m.spec.direction === "outbound", "shape");
  assert(m.spec.tag === "ssh" && m.spec.ciphertext === "x" && !("key" in m.spec), "fields");
});

Deno.test("agentStartEvent is an outbound agentStart with no kind, tag or payload", () => {
  const m = agentStartEvent("c", "s1");
  assert(m.kind === "ContractEvent" && m.metadata.name === "c-agent-s1", "name");
  assert(JSON.stringify(m.spec) === JSON.stringify({
    contractRef: { name: "c" },
    direction: "outbound",
    nsid: "com.publicdomainrelay.temp.compute.events.guest.agentStart",
  }), JSON.stringify(m.spec));
});

Deno.test("seal and open round trip (typage from esm.sh)", async () => {
  const me = await newAgeIdentity();
  assert(me.recipient.startsWith("age1"), me.recipient);
  const armored = await seal("v=0 offer", me.recipient);
  assert(armored.startsWith("-----BEGIN AGE ENCRYPTED FILE-----") && !armored.includes("v=0"), "armored");
  assert(await me.open(armored) === "v=0 offer", "opened");
});

Deno.test("firstOpened skips answers sealed to another identity", async () => {
  const me = await newAgeIdentity();
  const other = await newAgeIdentity();
  const theirs = await seal('{"sdp":"theirs"}', other.recipient);
  const mine = await seal('{"sdp":"mine"}', me.recipient);
  assert(await firstOpened([theirs, mine], me.open) === '{"sdp":"mine"}', "mine");
  assert(await firstOpened([theirs], me.open) === undefined, "none");
});

// A stand-in RTCPeerConnection: gathering is complete at once and the
// datachannel never opens, so only dialGuest's own timeouts end a dial.
class FakePeerConnection {
  iceGatheringState = "complete";
  localDescription = { sdp: "v=0 offer" };
  createDataChannel() {
    return {};
  }
  createOffer() {
    return Promise.resolve({ type: "offer", sdp: "v=0 offer" });
  }
  setLocalDescription() {
    return Promise.resolve();
  }
  setRemoteDescription() {
    return Promise.resolve();
  }
  addEventListener() {}
  removeEventListener() {}
  close() {}
}

Deno.test("dialGuest: no answer or no open channel is a connectivity error", async () => {
  const saved = globalThis.RTCPeerConnection;
  globalThis.RTCPeerConnection = FakePeerConnection;
  try {
    const guest = await newAgeIdentity();
    const fingerprint = "sha-256 AB:CD";
    const base = {
      guest: () => Promise.resolve({ key: guest.recipient, fingerprint, hostKeys: [] }),
      publishKey: () => Promise.resolve(),
    };
    const dial = async (exchange) => {
      try {
        await dialGuest({ signaling: { ...base, exchange }, answerTimeoutMs: 50, openTimeoutMs: 50 });
      } catch (err) {
        return err;
      }
      throw new Error("dial should fail");
    };
    const silent = await dial(() => new Promise(() => {}));
    assert(silent.connectivity && /no answer/.test(silent.message), silent.message);
    const answer = JSON.stringify({ sdp: `v=0\r\na=fingerprint:${fingerprint}\r\n` });
    const closed = await dial(() => Promise.resolve(answer));
    assert(closed.connectivity && /did not open/.test(closed.message), closed.message);
    const wrong = await dial(() => Promise.resolve(JSON.stringify({ sdp: "a=fingerprint:sha-256 00:11\r\n" })));
    assert(!wrong.connectivity && /fingerprint/.test(wrong.message), "a fingerprint mismatch is not a fallback case");
  } finally {
    globalThis.RTCPeerConnection = saved;
  }
});

Deno.test("r2StartEvent: an outbound guest.r2Start with spec.r2Start {name, agent, hold}", () => {
  const m = r2StartEvent("einfra-s1-vm", "ab12", { agent: true });
  if (m.kind !== "ContractEvent" || m.metadata.name !== "einfra-s1-vm-r2-ab12") throw new Error(JSON.stringify(m.metadata));
  if (m.spec.contractRef.name !== "einfra-s1-vm" || m.spec.direction !== "outbound" || m.spec.nsid !== NSID_R2_START || m.spec.tag !== undefined) {
    throw new Error(JSON.stringify(m.spec));
  }
  if (JSON.stringify(m.spec.r2Start) !== JSON.stringify({ name: "r2", agent: true, hold: true })) {
    throw new Error(JSON.stringify(m.spec.r2Start));
  }
  if (r2StartEvent("c", "x").spec.r2Start.agent !== false) throw new Error("agent defaults off");
  if (r2StartEvent("c", "x", { name: "r2-b", hold: false }).spec.r2Start.name !== "r2-b") throw new Error("named");
  for (const bad of ["", "R2", "r2_x", "-r2", "r2-", "a".repeat(64), "r2.x"]) {
    let threw = false;
    try {
      r2StartEvent("c", "x", { name: bad });
    } catch {
      threw = true;
    }
    if (!threw) throw new Error(`accepted ${JSON.stringify(bad)}`);
  }
});

Deno.test("schemaHasR2Start needs the nsid enum value and the spec.r2Start field", () => {
  const schema = (nsids, extra = {}) => ({ spec: { versions: [{ schema: { properties: { spec: { properties: { nsid: { enum: nsids }, ...extra } } } } }] } });
  if (!schemaHasR2Start(schema(["x", NSID_R2_START], { r2Start: { type: "object" } }))) throw new Error("served");
  if (schemaHasR2Start(schema(["x", NSID_R2_START]))) throw new Error("enum without the field");
  if (schemaHasR2Start(schema(["x"], { r2Start: {} }))) throw new Error("field without the enum");
  if (schemaHasR2Start(null)) throw new Error("no schema");
});