@mh-gg/base-plugins 0.1.1-alpha.20260613T085325975Z

package/test/shared-plugin-edges.test.cjs

@@ -0,0 +1,207 @@
+const assert = require("node:assert/strict");
+const test = require("node:test");
+const { manifestHash } = require("@mh-gg/base");
+const { HostPluginRuntime, createMemoryOperationLog, createMemoryRoomStore } = require("@mh-gg/host-runtime");
+const { ensureOperationIdentity } = require("@mh-gg/protocol");
+const { buildExampleMatterhornApp, createExampleActor, createExampleOperationFactory } = require("../../../examples/_shared/matterhornExample/index.cjs");
+const {
+  COMMENTS_PLUGIN_ID,
+  MEDIA_ROOMS_PLUGIN_ID,
+  PRESENCE_PLUGIN_ID,
+  SCREEN_SHARE_PLUGIN_ID,
+  commentsHostPlugin,
+  composeHostPlugins,
+  createCollaborationPluginSuite,
+  mediaRoomsHostPlugin,
+  presenceHostPlugin,
+  reusablePluginOperationFactory,
+  screenShareHostPlugin
+} = require("../src/index.cjs");
+
+const suite = createCollaborationPluginSuite("all");
+const built = buildExampleMatterhornApp({
+  slug: "edges",
+  packageName: "@mh-gg/base-plugins",
+  appId: "com.matterhorn.examples.plugin-edges",
+  name: "Plugin Edge Tests",
+  hostPlugins: [suite]
+});
+
+async function runtime() {
+  const rt = new HostPluginRuntime({
+    room: { id: "room_edges", appPack: { id: built.appPack.id, version: built.appPack.version, hash: manifestHash(built.appPack), protocolHash: built.appPack.compatibility.appProtocolHash } },
+    plugins: suite.plugins,
+    store: createMemoryRoomStore(),
+    operationLog: createMemoryOperationLog(),
+    authenticateActor: async (auth, actor) => {
+      assert.equal(auth.signature, "sig");
+      return actor;
+    }
+  });
+  await rt.start();
+  return rt;
+}
+
+function makeOps() {
+  return createExampleOperationFactory({ appPack: built.appPack, hostPlugin: commentsHostPlugin, roomId: "room_edges", actor: createExampleActor({ memberId: "admin", role: "admin" }), startTime: 2000 });
+}
+
+async function rejected(promise, pattern) {
+  const result = await promise;
+  assert.equal(result.ok, false);
+  assert.match(result.reason, pattern);
+}
+
+test("example app builder accepts suite objects and emits deterministic plugin graph metadata", () => {
+  assert.deepEqual(built.hostPlugins.map((plugin) => plugin.id), suite.pluginIds);
+  assert.deepEqual(built.hostPack.plugins.map((plugin) => plugin.id), suite.pluginIds);
+  assert.equal(built.appPack.compatibility.pluginGraphHash, built.hostPack.compatibility.pluginGraphHash);
+  assert.deepEqual([...built.playerPack.supports[0].pluginIds].sort(), [...suite.pluginIds].sort());
+
+  assert.throws(() => buildExampleMatterhornApp({
+    slug: "bad",
+    packageName: "@mh-gg/example-bad",
+    appId: "com.matterhorn.bad",
+    name: "Bad",
+    hostPlugins: [suite, commentsHostPlugin]
+  }), /Duplicate host plugin/);
+});
+
+test("reusable operation factory targets selected plugins while preserving sequence and auth defaults", () => {
+  const make = reusablePluginOperationFactory({ appPack: built.appPack, roomId: "room_edges", actor: createExampleActor({ memberId: "mina", role: "member" }), startSeq: 10, startTime: 5000 });
+  const comment = make("comments", "comments.add", { scopeType: "card", scopeId: "card_1", body: "Hi" });
+  const presence = make(presenceHostPlugin, "presence.update", { status: "online" });
+
+  assert.equal(comment.pluginId, COMMENTS_PLUGIN_ID);
+  assert.equal(comment.seq, 10);
+  assert.equal(comment.createdAt, 5010);
+  assert.equal(comment.auth.credentialId, "cred_mina");
+  assert.equal(presence.pluginId, PRESENCE_PLUGIN_ID);
+  assert.equal(presence.seq, 11);
+});
+
+test("comments public views hide deleted comments but preserve moderator thread queries", async () => {
+  const rt = await runtime();
+  const op = makeOps();
+  await rt.handleOperation(op("comments.add", { scopeType: "deal", scopeId: "deal_1", body: "Needs sponsor review" }, { id: "comment_1", pluginId: COMMENTS_PLUGIN_ID, actor: createExampleActor({ memberId: "mina", role: "member", displayName: "Mina" }) }));
+  const commentId = Object.keys((await rt.getState()).plugins[COMMENTS_PLUGIN_ID].comments)[0];
+  await rt.handleOperation(op("comments.delete", { commentId, reason: "Resolved elsewhere" }, { id: "comment_2", pluginId: COMMENTS_PLUGIN_ID, actor: createExampleActor({ memberId: "admin", role: "admin" }) }));
+
+  const publicView = await rt.publicView(createExampleActor({ memberId: "guest", role: "guest" }));
+  assert.deepEqual(Object.keys(publicView.plugins[COMMENTS_PLUGIN_ID].comments), []);
+
+  const unresolved = await rt.query(COMMENTS_PLUGIN_ID, "unresolvedThreads", {}, createExampleActor({ memberId: "admin", role: "admin" }));
+  assert.equal(unresolved.length, 1);
+  assert.equal(unresolved[0].scopeType, "deal");
+});
+
+test("presence clear only allows self or moderators", async () => {
+  const rt = await runtime();
+  const op = makeOps();
+  await rt.handleOperation(op("presence.update", { status: "online", activity: "writing tests" }, { id: "presence_1", pluginId: PRESENCE_PLUGIN_ID, actor: createExampleActor({ memberId: "mina", role: "member", displayName: "Mina" }) }));
+  await rejected(rt.handleOperation(op("presence.clear", { memberId: "mina" }, { id: "presence_2", pluginId: PRESENCE_PLUGIN_ID, actor: createExampleActor({ memberId: "lee", role: "member" }) })), /Can only clear your own presence/);
+  await rt.handleOperation(op("presence.clear", { memberId: "mina" }, { id: "presence_3", pluginId: PRESENCE_PLUGIN_ID, actor: createExampleActor({ memberId: "mod", role: "moderator" }) }));
+  assert.deepEqual(await rt.query(PRESENCE_PLUGIN_ID, "onlineMembers", {}, createExampleActor({ role: "admin" })), []);
+});
+
+test("presence announcements normalize user text and reject malformed payloads", async () => {
+  const rt = await runtime();
+  const op = makeOps();
+  await rt.handleOperation(op("presence.update", { status: "online", activity: "  writing \n tests  ", location: " Stage\tleft " }, { id: "presence_harden_1", pluginId: PRESENCE_PLUGIN_ID, actor: createExampleActor({ memberId: "mina", role: "member", displayName: "  Mina\nAdmin  " }) }));
+  const pluginState = (await rt.getState()).plugins[PRESENCE_PLUGIN_ID];
+
+  assert.equal(pluginState.members.mina.name, "Mina Admin");
+  assert.equal(pluginState.members.mina.activity, "writing tests");
+  assert.equal(pluginState.members.mina.location, "Stage left");
+  assert.equal(pluginState.activity[pluginState.activity.length - 1].message, "Mina Admin is online");
+
+  await rejected(rt.handleOperation(op("presence.update", { status: "online", activity: { text: "typing" } }, { id: "presence_harden_2", pluginId: PRESENCE_PLUGIN_ID, actor: createExampleActor({ memberId: "lee", role: "member" }) })), /activity must be a string/);
+  await rejected(rt.handleOperation(op("presence.update", { status: "online" }, { id: "presence_harden_3", pluginId: PRESENCE_PLUGIN_ID, actor: createExampleActor({ memberId: "__proto__", role: "member" }) })), /actor\.memberId is reserved/);
+});
+
+test("presence pings preserve busy state and invisible members are hidden from peers", async () => {
+  const rt = await runtime();
+  const op = makeOps();
+  const now = Date.now();
+  await rt.handleOperation(op("presence.update", { status: "busy", activity: "screening vendors" }, { id: "presence_busy", pluginId: PRESENCE_PLUGIN_ID, createdAt: now, actor: createExampleActor({ memberId: "mina", role: "member", displayName: "Mina" }) }));
+  await rt.handleOperation(op("presence.ping", {}, { id: "presence_ping", pluginId: PRESENCE_PLUGIN_ID, createdAt: now + 1, actor: createExampleActor({ memberId: "mina", role: "member", displayName: "Mina" }) }));
+
+  const pluginState = (await rt.getState()).plugins[PRESENCE_PLUGIN_ID];
+  assert.equal(pluginState.members.mina.status, "busy");
+  assert.equal(typeof pluginState.members.mina.lastPingAt, "number");
+  assert.equal((await rt.query(PRESENCE_PLUGIN_ID, "onlineMembers", {}, createExampleActor({ memberId: "admin", role: "admin" })))[0].status, "busy");
+
+  await rt.handleOperation(op("presence.update", { status: "invisible" }, { id: "presence_invisible", pluginId: PRESENCE_PLUGIN_ID, actor: createExampleActor({ memberId: "mina", role: "member", displayName: "Mina" }) }));
+  const peerView = await rt.publicView(createExampleActor({ memberId: "lee", role: "member" }));
+  assert.equal(peerView.plugins[PRESENCE_PLUGIN_ID].members.mina, undefined);
+  const selfView = await rt.publicView(createExampleActor({ memberId: "mina", role: "member" }));
+  assert.equal(selfView.plugins[PRESENCE_PLUGIN_ID].members.mina.status, "invisible");
+});
+
+test("presence ping freshness marks stale visible members offline", () => {
+  const view = presenceHostPlugin.getPublicView({ actor: createExampleActor({ memberId: "admin", role: "admin" }), now: 100_000 }, {
+    members: { mina: { memberId: "mina", name: "Mina", status: "online", updatedAt: 1, lastPingAt: 1 } },
+    activity: []
+  });
+  assert.equal(view.members.mina.status, "offline");
+  assert.equal(view.members.mina.declaredStatus, "online");
+  assert.equal(view.members.mina.visible, false);
+  assert.equal(view.onlineCount, 0);
+});
+
+test("presence state parser rejects spoofed or reserved member records", () => {
+  assert.throws(() => presenceHostPlugin.schemas.state.parse({
+    members: { mina: { memberId: "lee", name: "Mina", status: "online", updatedAt: 1 } },
+    activity: []
+  }), /must match its key/);
+  assert.throws(() => presenceHostPlugin.schemas.state.parse(JSON.parse('{"members":{"__proto__":{"memberId":"__proto__","name":"Bad","status":"online","updatedAt":1}},"activity":[]}')), /reserved/);
+});
+
+test("media rooms support updates, leave, archive, and guest-safe directory views", async () => {
+  const rt = await runtime();
+  const op = makeOps();
+  await rejected(rt.handleOperation(op("media.room.create", { name: "Member-created", allowsVideo: true }, { id: "media_member_create", pluginId: MEDIA_ROOMS_PLUGIN_ID, actor: createExampleActor({ memberId: "mina", role: "member" }) })), /Moderators only|requires moderator/);
+  await rt.handleOperation(op("media.room.create", { name: "Standup", allowsVideo: true, scopeType: "kanban-card", scopeId: "card_7" }, { id: "media_1", pluginId: MEDIA_ROOMS_PLUGIN_ID }));
+  const roomId = Object.keys((await rt.getState()).plugins[MEDIA_ROOMS_PLUGIN_ID].rooms)[0];
+  await rt.handleOperation(op("media.room.join", { roomId, media: { audio: true, video: false } }, { id: "media_2", pluginId: MEDIA_ROOMS_PLUGIN_ID, actor: createExampleActor({ memberId: "mina", role: "member", displayName: "Mina" }) }));
+  await rt.handleOperation(op("media.room.update", { roomId, locked: true, spotlightMemberId: "mina", name: "Daily Standup" }, { id: "media_3", pluginId: MEDIA_ROOMS_PLUGIN_ID }));
+  let rooms = await rt.query(MEDIA_ROOMS_PLUGIN_ID, "roomDirectory", {}, createExampleActor({ role: "guest" }));
+  assert.equal(rooms[0].name, "Daily Standup");
+  assert.equal(rooms[0].participantCount, 1);
+  assert.equal(rooms[0].locked, true);
+
+  await rt.handleOperation(op("media.room.leave", { roomId }, { id: "media_4", pluginId: MEDIA_ROOMS_PLUGIN_ID, actor: createExampleActor({ memberId: "mina", role: "member" }) }));
+  await rt.handleOperation(op("media.room.archive", { roomId }, { id: "media_5", pluginId: MEDIA_ROOMS_PLUGIN_ID }));
+  rooms = await rt.query(MEDIA_ROOMS_PLUGIN_ID, "roomDirectory", {}, createExampleActor({ role: "guest" }));
+  assert.equal(rooms.length, 0);
+});
+
+test("screen-share plugin scopes active shares and enforces presenter stop rules", async () => {
+  const rt = await runtime();
+  const op = makeOps();
+  await rt.handleOperation(op("media.room.create", { name: "Review", allowsVideo: true }, { id: "media_room", pluginId: MEDIA_ROOMS_PLUGIN_ID }));
+  const roomId = Object.keys((await rt.getState()).plugins[MEDIA_ROOMS_PLUGIN_ID].rooms)[0];
+  await rt.handleOperation(op("screenshare.start", { roomId, scopeType: "wiki-page", scopeId: "page_1", title: "Architecture" }, { id: "share_1", pluginId: SCREEN_SHARE_PLUGIN_ID, actor: createExampleActor({ memberId: "mina", role: "member", displayName: "Mina" }) }));
+  const shares = await rt.query(SCREEN_SHARE_PLUGIN_ID, "activeShares", { scopeType: "wiki-page", scopeId: "page_1" }, createExampleActor({ role: "member" }));
+  assert.equal(shares.length, 1);
+  assert.equal(shares[0].presenterName, "Mina");
+
+  await rejected(rt.handleOperation(op("screenshare.stop", { shareId: shares[0].id }, { id: "share_2", pluginId: SCREEN_SHARE_PLUGIN_ID, actor: createExampleActor({ memberId: "lee", role: "member" }) })), /Only presenter or moderators/);
+  await rt.handleOperation(op("screenshare.stop", { shareId: shares[0].id }, { id: "share_3", pluginId: SCREEN_SHARE_PLUGIN_ID, actor: createExampleActor({ memberId: "mina", role: "member" }) }));
+  assert.deepEqual(await rt.query(SCREEN_SHARE_PLUGIN_ID, "activeShares", { scopeType: "wiki-page", scopeId: "page_1" }, createExampleActor({ role: "member" })), []);
+});
+
+test("composition helper dedupes primitive plugins with reusable suite entries", () => {
+  const plugins = composeHostPlugins(commentsHostPlugin, createCollaborationPluginSuite(["comments", "presence"]), presenceHostPlugin);
+  assert.deepEqual(plugins.map((plugin) => plugin.id), [COMMENTS_PLUGIN_ID, PRESENCE_PLUGIN_ID]);
+  assert.equal(plugins[0].version, commentsHostPlugin.version);
+  assert.equal(plugins[1].version, presenceHostPlugin.version);
+  assert.equal(mediaRoomsHostPlugin.id, MEDIA_ROOMS_PLUGIN_ID);
+  assert.equal(screenShareHostPlugin.id, SCREEN_SHARE_PLUGIN_ID);
+});
+
+test("scope keys are collision-resistant for delimiter-bearing scope values", () => {
+  const { scopeKey } = require("../src/shared/index.cjs");
+  assert.notEqual(scopeKey("deal:abc", "thread"), scopeKey("deal", "abc:thread"));
+  assert.equal(scopeKey("deal", "abc"), "deal:abc");
+});