@cueloop/schema 0.1.0-alpha.75 → 0.1.0-alpha.77

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cueloop/schema",
-  "version": "0.1.0-alpha.75",
+  "version": "0.1.0-alpha.77",
   "description": "The Thread primitive: types, markdown block model, quote-primary anchors, feedback serialization",
   "homepage": "https://github.com/mmurakaru/cueloop#readme",
   "bugs": {

package/src/index.ts

@@ -1,5 +1,6 @@
 export * from "./types";
 export * from "./participants";
+export * from "./share-access";
 export * from "./markdown";
 export * from "./inline";
 export * from "./working-copy";

package/src/participants.test.ts

@@ -55,4 +55,33 @@ describe("registerParticipant", () => {
     // Assert
     expect(next.participants).toEqual([{ id: "SHA256:ana", provider: "ssh", name: "Ana" }]);
   });
+
+  test("records a verified github source with its login handle", () => {
+    // Act
+    const next = registerParticipant(emptySession(), "SHA256:ana", "Ana", {
+      provider: "github",
+      handle: "ana",
+    });
+
+    // Assert
+    expect(next.participants).toEqual([
+      { id: "SHA256:ana", provider: "github", name: "Ana", handle: "ana" },
+    ]);
+  });
+
+  test("a later nameless write preserves the github provider and handle", () => {
+    // Arrange
+    const verified = registerParticipant(emptySession(), "SHA256:ana", "Ana", {
+      provider: "github",
+      handle: "ana",
+    });
+
+    // Act
+    const next = registerParticipant(verified, "SHA256:ana");
+
+    // Assert
+    expect(next.participants).toEqual([
+      { id: "SHA256:ana", provider: "github", name: "Ana", handle: "ana" },
+    ]);
+  });
 });

package/src/participants.ts

@@ -13,17 +13,28 @@ import type { Identity, Thread } from "./types";
  * rail renders anonymous) and never erases a name a past visit set. Immutable:
  * the input session is not mutated.
  */
-export function registerParticipant(session: Thread, author: string, name?: string): Thread {
+export interface ParticipantSource {
+  provider: "ssh" | "github";
+  handle?: string;
+}
+
+export function registerParticipant(
+  session: Thread,
+  author: string,
+  name?: string,
+  source?: ParticipantSource,
+): Thread {
   const participants = session.participants ?? [];
   const existing = participants.find((participant) => participant.id === author);
   const trimmed = name?.trim();
 
-  if (existing && !trimmed) return session;
-  const next: Identity = {
-    id: author,
-    provider: "ssh",
-    ...(trimmed ? { name: trimmed } : existing?.name ? { name: existing.name } : {}),
-  };
+  if (existing && !trimmed && !source) return session;
+  const resolvedName = trimmed ?? existing?.name;
+  const resolvedHandle = source?.handle ?? existing?.handle;
+  const next: Identity = { id: author, provider: source?.provider ?? existing?.provider ?? "ssh" };
+
+  if (resolvedName) next.name = resolvedName;
+  if (resolvedHandle) next.handle = resolvedHandle;
 
   return {
     ...session,

package/src/share-access.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, test } from "bun:test";
+import { isShareViewerAllowed } from "./share-access";
+
+describe("isShareViewerAllowed", () => {
+  test("an unauthenticated viewer is refused", () => {
+    expect(isShareViewerAllowed({ githubLogins: ["octocat"] }, undefined)).toBe(false);
+  });
+
+  test("a member is admitted, case-insensitively", () => {
+    expect(isShareViewerAllowed({ githubLogins: ["OctoCat"] }, "octocat")).toBe(true);
+  });
+
+  test("a non-member is refused", () => {
+    expect(isShareViewerAllowed({ githubLogins: ["octocat"] }, "hubot")).toBe(false);
+  });
+
+  test("an empty allowlist admits no one", () => {
+    expect(isShareViewerAllowed({ githubLogins: [] }, "octocat")).toBe(false);
+  });
+});

package/src/share-access.ts

@@ -0,0 +1,13 @@
+/** Whether a github login may view a private share; membership is case-insensitive and an unauthenticated viewer is never allowed. */
+
+import type { ShareAccess } from "./types";
+
+export function isShareViewerAllowed(
+  access: ShareAccess,
+  githubLogin: string | undefined,
+): boolean {
+  if (githubLogin === undefined) return false;
+  const login = githubLogin.toLowerCase();
+
+  return access.githubLogins.some((allowed) => allowed.toLowerCase() === login);
+}

package/src/types.ts

@@ -224,14 +224,19 @@ export type SessionStatus = "pending" | "resolved";
 export interface Identity {
   /** Stable identity key; equals an annotation's `author`. */
   id: string;
-  /** Identity source. One value today; widen the union when OAuth lands. */
-  provider: "ssh";
+  /** Identity source: the SSH key that authored, or a verified GitHub login. */
+  provider: "ssh" | "github";
   /** Display name; absent = the collaborator stayed anonymous. */
   name?: string;
   /** Provider handle: a github login, an email, or a short fingerprint. */
   handle?: string;
 }
 
+/** Owner-set access control for a private share: only these GitHub logins may open it. Absent = a public share. */
+export interface ShareAccess {
+  githubLogins: string[];
+}
+
 export interface Thread {
   schemaVersion: string;
   id: string;
@@ -278,6 +283,8 @@ export interface Thread {
   shareBranch?: string;
   /** SSH fingerprint that created the share; the gateway stamps it to gate pulls. */
   owner?: string;
+  /** Owner-set allowlist of GitHub logins for a private share; absent = public. */
+  access?: ShareAccess;
   /**
    * Identities that authored annotations here, keyed by id (union-by-id, like
    * annotations). The gateway records a collaborator's identity and chosen name;