@readymadeit/mcp 0.0.0-stage → 0.1.0

package/bundle/hkp-frontend/src/runtime/browser/services/tests/pad-groove-board.test.ts

@@ -0,0 +1,230 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+// The registry first, as the app loads it, so the tracks can build what their
+// pipelines name.
+import "../../BrowserRegistry";
+import TimelineDescriptor from "../Timeline";
+import TracksDescriptor from "../BrowserTracks";
+import SoundDescriptor from "../Sound";
+import { createSlotStore } from "../../../slots";
+import document from "../../../../../../boards/pad-groove-demo-board.json";
+import { linkBlocks } from "../../../../core/linkBlocks";
+
+/**
+ * The Pad Groove demo board: a pad, a bass line and drums, arranged by name on
+ * one timeline counting beats. The Song's frames are run through the board's
+ * own Band — its block uses expanded, as loading it does — and every note and
+ * drum it plays is recorded at the Song's time.
+ */
+
+// The board as it runs: its blocks expanded, the way loading it does.
+const board = linkBlocks(document as any).board as any;
+const services = board.services.ui as any[];
+const entry = (uuid: string) =>
+  structuredClone(services.find((s) => s.uuid === uuid));
+
+class SilentAudioContext {
+  state = "running";
+  currentTime = 0;
+  resume() {}
+  close() {}
+}
+
+function makeApp(slots = createSlotStore()) {
+  return {
+    notify: vi.fn(),
+    next: vi.fn(),
+    sendAction: vi.fn(),
+    getRuntimeVariable: vi.fn(() => ({})),
+    setRuntimeVariable: vi.fn(),
+    slots: () => slots,
+  } as any;
+}
+
+type Played = { t: number; part: string; sound: string; seconds?: number };
+
+let slots: ReturnType<typeof createSlotStore>;
+let song: any;
+let songApp: any;
+let band: any;
+let played: Played[] = [];
+let now = 0;
+let playedUpTo = 0;
+
+/** Which part a synth is, told by its wave: each part plays on its own. */
+const PART_BY_WAVE: Record<string, string> = { soft: "pad", triangle: "bass" };
+
+beforeEach(() => {
+  vi.useFakeTimers();
+  vi.setSystemTime(0);
+  vi.stubGlobal("AudioContext", SilentAudioContext);
+  played = [];
+  playedUpTo = 0;
+  // Every Sound on the board is this class, whichever scope built it.
+  const probe = SoundDescriptor.create(makeApp(), "b", {} as any, "probe");
+  const proto = Object.getPrototypeOf(probe);
+  vi.spyOn(proto, "playDrum").mockImplementation(function (_ctx: unknown, drum: unknown) {
+    played.push({ t: now, part: "drums", sound: drum as string });
+  });
+  vi.spyOn(proto, "playNoteByName").mockImplementation(function (this: any, _ctx: unknown, note: unknown, tempo: unknown) {
+    played.push({
+      t: now,
+      part: PART_BY_WAVE[this.state.waveType] ?? this.state.waveType,
+      sound: note as string,
+      seconds: this.noteSeconds(tempo),
+    });
+  });
+  probe.destroy();
+
+  slots = createSlotStore();
+  slots.set("tempo", entry("tempo").state.value);
+  songApp = makeApp(slots);
+  song = TimelineDescriptor.create(songApp, "board", {} as any, "song");
+  // No slots for the Band: a track's slots are its own, so the tempo reaches
+  // its synths in the Song's frames or not at all.
+  band = TracksDescriptor.create(makeApp(), "board", {} as any, "band");
+  band.configure(entry("band").state);
+});
+
+afterEach(() => {
+  song.destroy();
+  vi.restoreAllMocks();
+  vi.unstubAllGlobals();
+  vi.useRealTimers();
+});
+
+/** Eight bars at 96 BPM, stopping short of the frame that lands on the loop. */
+const ONE_PASS_MS = (32 * 60000) / 96 - 10;
+
+/** Plays the Song for `ms` and runs each of its frames through the Band, in order. */
+async function play(ms: number) {
+  song.configure({ ...entry("song").state, running: true });
+  vi.advanceTimersByTime(ms);
+  const frames = songApp.next.mock.calls.slice(playedUpTo);
+  playedUpTo = songApp.next.mock.calls.length;
+  for (const [, frame] of frames) {
+    now = frame.t;
+    await band.process(frame);
+  }
+}
+
+/** A frame at 96 BPM and 60 fps is 1.6/60 of a beat. */
+const FRAME = 1.6 / 60 + 1e-9;
+
+/** The beat each note or hit was meant for: the one it follows within a frame. */
+function onBeat(t: number, beats: number[]) {
+  return beats.find((b) => t >= b - 1e-9 && t - b < FRAME);
+}
+
+function times(part: string, sound?: string) {
+  return played
+    .filter((p) => p.part === part && (sound === undefined || p.sound === sound))
+    .map((p) => p.t);
+}
+
+function expectOnBeats(ts: number[], beats: number[]) {
+  expect(ts).toHaveLength(beats.length);
+  ts.forEach((t, i) => expect(onBeat(t, [beats[i]])).toBe(beats[i]));
+}
+
+const range = (from: number, to: number, step: number) =>
+  Array.from({ length: Math.round((to - from) / step) }, (_, i) => from + i * step);
+
+const CHORDS = [
+  ["A3", "C4", "E4", "G4"],
+  ["F3", "A3", "C4", "E4"],
+  ["G3", "C4", "E4", "G4"],
+  ["G3", "B3", "D4", "G4"],
+];
+
+/** The root of each chord, which is what the bass plays under it. */
+const ROOTS = ["A", "F", "C", "G"];
+
+const pitchClass = (note: string) => note.replace(/-?\d+$/, "");
+
+describe("the Pad Groove demo board", () => {
+  it("is a tempo, a Song counting beats and a Band, with no picture", () => {
+    expect(services.map((s) => s.uuid)).toEqual(["tempo", "song", "band"]);
+    expect(entry("song").state).toMatchObject({
+      clock: "own",
+      unit: "beats",
+      tempoSlot: "tempo",
+      length: 32,
+      loop: true,
+    });
+    expect(entry("band").state.tracks.map((t: any) => t.name)).toEqual([
+      "pad",
+      "bass",
+      "hats",
+      "kick",
+      "snare",
+      "fill",
+    ]);
+  });
+
+  it("writes every part as a use of one of two blocks", () => {
+    const doc = document as any;
+    expect(doc.blocks.map((b: any) => b.id)).toEqual(["notes", "drum"]);
+    const uses = doc.services.ui
+      .find((s: any) => s.uuid === "band")
+      .state.tracks.map((t: any) => t.pipeline[0].block);
+    expect(uses).toEqual(["notes", "notes", "drum", "drum", "drum", "drum"]);
+  });
+
+  it("places every part's name, and nothing else", () => {
+    const placed = new Set(entry("song").state.placements.map((p: any) => p.name));
+    const taken = (document as any).services.ui
+      .find((s: any) => s.uuid === "band")
+      .state.tracks.map((t: any) => t.pipeline[0].params.name);
+    expect(new Set(taken)).toEqual(placed);
+  });
+
+  it("plays the pad's four chords a bar each, twice through the song", async () => {
+    await play(ONE_PASS_MS);
+    const pad = played.filter((p) => p.part === "pad");
+    const bars = range(0, 32, 4);
+    expect(pad).toHaveLength(bars.length * 4);
+    bars.forEach((bar, i) => {
+      const chord = pad.slice(i * 4, i * 4 + 4);
+      chord.forEach((note) => expect(onBeat(note.t, [bar])).toBe(bar));
+      expect(chord.map((n) => n.sound)).toEqual(CHORDS[i % 4]);
+    });
+  });
+
+  it("holds each chord for its bar, at whatever the tempo is", async () => {
+    await play(1000);
+    // Four beats at 96 BPM.
+    expect(played.find((p) => p.part === "pad")!.seconds).toBeCloseTo(2.5);
+    slots.set("tempo", 120);
+    played = [];
+    song.configure({ stop: true });
+    await play(100);
+    expect(played.find((p) => p.part === "pad")!.seconds).toBeCloseTo(2);
+  });
+
+  it("brings the bass in on the fifth bar, on the root of every chord", async () => {
+    await play(ONE_PASS_MS);
+    const bass = played.filter((p) => p.part === "bass");
+    expect(Math.min(...bass.map((b) => b.t))).toBeGreaterThanOrEqual(16);
+    expectOnBeats(
+      bass.map((b) => b.t),
+      range(16, 32, 4).flatMap((bar) => [bar, bar + 1.5, bar + 2.5, bar + 3.5]),
+    );
+    // The pad's chord in the bar each bass note falls in.
+    for (const note of bass) {
+      expect(pitchClass(note.sound)).toBe(ROOTS[Math.floor(note.t / 4) % 4]);
+    }
+  });
+
+  it("brings the drums in bar by bar and ends on the fill", async () => {
+    await play(ONE_PASS_MS);
+    expectOnBeats(times("drums", "hihat"), range(8, 32, 0.5));
+    expectOnBeats(times("drums", "kick"), range(16, 32, 4).flatMap((b) => [b, b + 2.5]));
+    expectOnBeats(times("drums", "snare"), [25, 27, 29, 30, 30.5, 31, 31.25, 31.5, 31.75]);
+  });
+
+  it("plays the pad alone for the first two bars", async () => {
+    await play(ONE_PASS_MS);
+    expect(played.filter((p) => p.t < 8).every((p) => p.part === "pad")).toBe(true);
+  });
+});

package/bundle/hkp-frontend/src/runtime/browser/services/tests/peer-host-discovery.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, it, vi } from "vitest";
+
+// The first discovery host stands in for peerjs.hookitapp.com, which never
+// publishes its peer list.
+vi.mock("hkp-frontend/src/views/playground/common", () => ({
+  availableDiscoveryPeerHosts: [
+    {
+      host: "peerjs.example.com",
+      port: 443,
+      path: "/",
+      secure: true,
+      discoverable: false,
+    },
+  ],
+}));
+
+vi.mock("hkp-frontend/src/templateVars", () => ({
+  resolveTemplateVars: (value: string) => value,
+}));
+
+import { resolveActivePeerHost } from "../PeerConnection";
+import { createBoardCoordinator } from "hkp-frontend/src/core/coordinator";
+
+const base = {
+  peerHost: null,
+  peerPort: null,
+  peerPath: null,
+  peerSecure: null,
+  __hkpMount: null,
+};
+
+describe("peer host discoverability", () => {
+  it("carries an opt-out from the descriptor of the default server", () => {
+    expect(resolveActivePeerHost(base)?.discoverable).toBe(false);
+  });
+
+  it("still follows the descriptor when only the port is overridden", () => {
+    // The host is unchanged, so the opt-out still applies — discoverability is
+    // a property of the server, not of the port it was reached on.
+    expect(
+      resolveActivePeerHost({ ...base, peerPort: 9000 })?.discoverable,
+    ).toBe(false);
+  });
+
+  it("assumes a server the user typed is discoverable", () => {
+    expect(
+      resolveActivePeerHost({ ...base, peerHost: "peers.mine.example" })
+        ?.discoverable,
+    ).toBe(true);
+  });
+
+  it("assumes a peer server reached through a mount is discoverable", () => {
+    // Assumed like any other server without a descriptor to opt out: the
+    // client cannot know the policy of a server it was only handed an address
+    // for.
+    const coordinator = createBoardCoordinator(() => ({
+      services: {
+        node: [
+          {
+            uuid: "peer-svc",
+            state: { __hkpMount: "http://127.0.0.1:8080/hosted/abc" },
+          },
+        ],
+      },
+    }));
+    const resolved = resolveActivePeerHost(
+      { ...base, __hkpMount: "hkp-mount://node/peer-svc" },
+      coordinator,
+    );
+    expect(resolved).toMatchObject({
+      host: "127.0.0.1",
+      port: 8080,
+      path: "/hosted/abc",
+      discoverable: true,
+    });
+  });
+});

package/bundle/hkp-frontend/src/runtime/browser/services/tests/peer-socket-discovery.test.ts

@@ -0,0 +1,69 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("hkp-frontend/src/views/playground/common", () => ({
+  availableDiscoveryPeerHosts: [
+    { host: "peerjs.example.com", port: 443, path: "/", secure: true, discoverable: false },
+  ],
+}));
+
+vi.mock("hkp-frontend/src/templateVars", () => ({
+  resolveTemplateVars: (value: string) => value,
+}));
+
+// The live PeerJS connection is irrelevant here and would open a socket.
+vi.mock("../PeerConnection", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("../PeerConnection")>();
+  return {
+    ...actual,
+    default: class {
+      connect() {}
+      close() {}
+      async sendData() {}
+    },
+  };
+});
+
+import peerSocketModule from "../PeerSocket";
+
+function makeService() {
+  const app = {
+    notify: vi.fn(),
+    next: vi.fn(),
+    getAuthenticatedUser: () => null,
+  };
+  const descriptor = (peerSocketModule as any).default ?? peerSocketModule;
+  return descriptor.create(app, "board", descriptor, "peer-1");
+}
+
+describe("PeerSocket peer lookup setting", () => {
+  let service: any;
+
+  beforeEach(() => {
+    service = makeService();
+  });
+
+  it("defaults to looking peers up", () => {
+    // Discovery is useful and most servers allow it; switching it off is the
+    // deliberate act, not switching it on.
+    expect(service.state.peerDiscovery).toBe(true);
+  });
+
+  it("can be switched off and back on through configure", () => {
+    service.configure({ peerDiscovery: false });
+    expect(service.state.peerDiscovery).toBe(false);
+
+    service.configure({ peerDiscovery: true });
+    expect(service.state.peerDiscovery).toBe(true);
+  });
+
+  it("is untouched by a configure that does not mention it", () => {
+    service.configure({ peerDiscovery: false });
+    service.configure({ targetPeer: "someone" });
+    expect(service.state.peerDiscovery).toBe(false);
+  });
+
+  it("coerces a truthy value from board JSON to a boolean", () => {
+    service.configure({ peerDiscovery: 0 });
+    expect(service.state.peerDiscovery).toBe(false);
+  });
+});

package/bundle/hkp-frontend/src/runtime/browser/services/tests/pipeline-names.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { BrowserSubService } from "../BrowserSubService";
+import { renamedEntries } from "../../pipelineNames";
+
+const entry = (instanceId: string, extra: Record<string, unknown> = {}) => ({
+  serviceId: "hookup.to/service/monitor",
+  instanceId,
+  state: { a: 1 },
+  ...extra,
+});
+
+describe("renamedEntries", () => {
+  it("gives the entries their new names when only a name changed", () => {
+    const current = [entry("x"), entry("y", { serviceName: "Old" })];
+    const next = [entry("x", { serviceName: "First" }), entry("y")];
+
+    expect(renamedEntries(current, next)).toEqual([
+      entry("x", { serviceName: "First" }),
+      entry("y"),
+    ]);
+  });
+
+  it("is null when nothing changed", () => {
+    expect(renamedEntries([entry("x")], [entry("x")])).toBeNull();
+  });
+
+  it("is null when anything besides a name changed", () => {
+    const current = [entry("x"), entry("y")];
+    expect(renamedEntries(current, [entry("y"), entry("x")])).toBeNull();
+    expect(
+      renamedEntries(current, [entry("x", { serviceName: "N" })]),
+    ).toBeNull();
+    expect(
+      renamedEntries(current, [
+        entry("x", { serviceName: "N", state: { a: 2 } }),
+        entry("y"),
+      ]),
+    ).toBeNull();
+    expect(renamedEntries(current, undefined)).toBeNull();
+  });
+});
+
+describe("renaming a service inside a sub-service", () => {
+  it("renames the entry and the running service without rebuilding", async () => {
+    const app = { notify: vi.fn(), next: vi.fn(), slots: () => null } as any;
+    const sub = new BrowserSubService(app, "board", {} as any, "sub");
+    sub.configure({ pipeline: [entry("inner")] });
+    await sub._scopeBuilding;
+    const scope = sub._scope;
+    const running = sub.getInnerInstance("inner");
+    expect(running).not.toBeNull();
+
+    sub.configure({
+      pipeline: sub.state.pipeline.map((e) => ({ ...e, serviceName: "Tap" })),
+    });
+
+    expect(sub._scope).toBe(scope);
+    expect(sub.getInnerInstance("inner")).toBe(running);
+    expect(running!.serviceName).toBe("Tap");
+    expect(sub.state.pipeline[0].serviceName).toBe("Tap");
+  });
+});

package/bundle/hkp-frontend/src/runtime/browser/services/tests/secret-canary.test.ts

@@ -0,0 +1,121 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import { SecretStore, setSecretStore } from "hkp-frontend/src/core/secrets";
+
+import httpClient from "../HttpClient";
+import openAIPrompt from "../OpenAIPrompt";
+import workflowBoardBuilder from "../WorkflowBoardBuilder";
+
+/**
+ * A secret's value, used and then looked for everywhere it must not be.
+ *
+ * These browser services send a credential the board names by reference. The
+ * value must reach the request and nothing else: not what the service reports
+ * (what a saved board carries), not what it tells its panel, not what it hands
+ * on, and not what it writes to the console when the request fails. The
+ * remote runtimes are swept the same way (hkp-node tests/secret-canary.test.ts,
+ * hkp-python tests/test_secret_canary.py, hkp-rt tests/secret_canary.test.cpp);
+ * Encrypt, Decrypt, Sign and the GitHub service in their own tests.
+ */
+
+const CANARY = "canary-6f1d0e2a-secret-value";
+
+function store(): SecretStore {
+  return {
+    get: (alias) => (alias === "api" ? CANARY : null),
+    audience: () => null,
+    list: () => ["api"],
+  };
+}
+
+/** Enough of an AppInstance, recording everything a service says. */
+function recordingApp() {
+  const said: unknown[] = [];
+  return {
+    said,
+    app: {
+      notify: (_svc: unknown, value: unknown) => said.push(value),
+      next: (_svc: unknown, value: unknown) => said.push(value),
+      sendAction: (action: unknown) => said.push(action),
+      getRuntimeVariable: () => ({}),
+      listAvailableServices: () => [],
+    } as any,
+  };
+}
+
+function capture() {
+  const lines: string[] = [];
+  for (const level of ["log", "info", "warn", "error", "debug"] as const) {
+    vi.spyOn(console, level).mockImplementation((...args: unknown[]) => {
+      lines.push(args.map((a) => (a instanceof Error ? `${a.message}` : JSON.stringify(a) ?? String(a))).join(" "));
+    });
+  }
+  return lines;
+}
+
+function failingFetch() {
+  const sent: string[] = [];
+  vi.stubGlobal(
+    "fetch",
+    vi.fn(async (url: unknown, init?: RequestInit) => {
+      sent.push(JSON.stringify({ url: String(url), headers: init?.headers ?? {}, body: init?.body ?? "" }));
+      return new Response("upstream failed", { status: 500 });
+    }),
+  );
+  return sent;
+}
+
+afterEach(() => {
+  setSecretStore(null);
+  vi.unstubAllGlobals();
+  vi.restoreAllMocks();
+});
+
+describe("a secret's value in a browser service", () => {
+  it.each([
+    [
+      "HTTP Client",
+      httpClient,
+      {
+        url: "https://api.example.com/hook",
+        method: "POST",
+        headers: { Authorization: "Bearer {{secret.api}}" },
+      },
+      { go: true },
+    ],
+    ["OpenAI Prompt", openAIPrompt, { apiKey: "{{secret.api}}", prompt: "Be brief" }, "hello"],
+    [
+      "Workflow Board Builder",
+      workflowBoardBuilder,
+      { provider: "openai", apiKey: "{{secret.api}}" },
+      "a board that says hello",
+    ],
+  ] as const)("%s sends it, and reports, says and logs it nowhere", async (_name, descriptor, config, input) => {
+    setSecretStore(store());
+    const sent = failingFetch();
+    const logged = capture();
+    const { app, said } = recordingApp();
+    const service = (descriptor as any).create(app, "Board", {} as any, "svc-1");
+    await service.configure(config);
+
+    let answer: unknown;
+    try {
+      answer = await service.process(input);
+    } catch (error) {
+      answer = error instanceof Error ? error.message : error;
+    }
+
+    // Used: the request carried it.
+    expect(sent.join()).toContain(CANARY);
+
+    const surfaces: Record<string, string> = {
+      "what it reports": JSON.stringify(await service.getConfiguration()),
+      "what it answered": JSON.stringify(answer) ?? "",
+      "what it said": JSON.stringify(said),
+      "the console": logged.join("\n"),
+    };
+    for (const [where, text] of Object.entries(surfaces)) {
+      expect(text, where).not.toContain(CANARY);
+    }
+  });
+});