Skip to content

armgit / qm

Public Imported from GitHub
0

Multiplayer agent harness for work.

14.2 KB
Raw Blame
import type { PrincipalType } from "../types.ts";
import { rosterIds, samePerson } from "./person.ts";

function hasPerson(members: ReadonlySet<string> | undefined, principalId: string): boolean {
  return !!members && rosterIds(principalId).some((id) => members.has(id));
}

export interface DirectoryMember {
  principalId: string;
  displayName: string;
  type: PrincipalType;
  slackId?: string;
  avatarUrl?: string;
}

export interface DirectoryChannel {
  channelId: string;
  name: string;
  isPrivate?: boolean;
  isExternal?: boolean;
}

export interface ChannelMembership {
  channelId: string;
  principalId: string;
}

export interface GroupMembership {
  groupId: string;
  principalId: string;
}

export type GroupResolution = { kind: "one"; groupId: string } | { kind: "none" };

export function groupParticipantsKey(participants: readonly string[]): string {
  return [...new Set(participants.filter((p) => p))].sort().join(",");
}

export interface DirectoryMeta {
  workspaceUrl: string | null;
}

export type RecipientResolution =
  { kind: "one"; member: DirectoryMember } | { kind: "ambiguous"; candidates: DirectoryMember[] } | { kind: "none" };

export type ChannelResolution =
  { kind: "one"; channel: DirectoryChannel } | { kind: "ambiguous"; candidates: DirectoryChannel[] } | { kind: "none" };

export interface DirectoryStore {
  replace(members: DirectoryMember[], syncedAt?: number): Promise<boolean>;
  replaceChannels(
    channels: DirectoryChannel[],
    channelMembers?: ChannelMembership[],
    syncedAt?: number,
    channelRosterIds?: string[],
    revocations?: ChannelMembership[],
    partial?: boolean,
  ): Promise<boolean>;
  list(): Promise<DirectoryMember[]>;
  listChannels(): Promise<DirectoryChannel[]>;
  get(principalId: string): Promise<DirectoryMember | null>;
  getBySlackId(slackId: string): Promise<DirectoryMember | null>;
  resolve(query: string): Promise<RecipientResolution>;
  resolveChannel(query: string): Promise<ChannelResolution>;
  channelMember(channelId: string, principalId: string): Promise<boolean>;
  channelMembership(channelId: string, principalId: string): Promise<boolean | undefined>;
  channelMemberIds(channelId: string): Promise<string[] | undefined>;
  channelPrivacy(channelId: string): Promise<boolean | undefined>;
  replaceGroups(
    groupMembers: GroupMembership[],
    syncedAt?: number,
    groupIds?: string[],
    groupRosterIds?: string[],
  ): Promise<boolean>;
  upsertGroup(groupId: string, principalIds: readonly string[]): Promise<void>;
  resolveGroupByParticipants(participants: readonly string[]): Promise<GroupResolution>;
  groupMember(groupId: string, principalId: string): Promise<boolean>;
  groupMembership(groupId: string, principalId: string): Promise<boolean | undefined>;
  listGroupsFor(principalId: string): Promise<string[]>;
  conversationMembers(kind: "channel" | "group", id: string): Promise<DirectoryMember[] | undefined>;
  listChannelsFor(principalId: string): Promise<DirectoryChannel[]>;
  setWorkspaceUrl(url: string): Promise<void>;
  meta(): Promise<DirectoryMeta>;
}

export const MAX_CANDIDATES = 10;
export const normDirectoryQuery = (s: string): string => s.trim().toLowerCase().replace(/^[@#]/, "");

export function pickMatch<T>(
  items: T[],
  query: string,
  id: (t: T) => string,
  label: (t: T) => string,
): { kind: "one"; item: T } | { kind: "ambiguous"; items: T[] } | { kind: "none" } {
  const q = normDirectoryQuery(query);
  if (!q) return { kind: "none" };
  const byId = items.find((t) => id(t).toLowerCase() === q);
  if (byId) return { kind: "one", item: byId };
  const exact = items.filter((t) => normDirectoryQuery(label(t)) === q);
  if (exact.length === 1) return { kind: "one", item: exact[0]! };
  if (exact.length > 1) return { kind: "ambiguous", items: exact.slice(0, MAX_CANDIDATES) };
  const prefix = items.filter((t) => normDirectoryQuery(label(t)).startsWith(q));
  const pool = prefix.length ? prefix : items.filter((t) => normDirectoryQuery(label(t)).includes(q));
  if (pool.length === 0) return { kind: "none" };
  if (pool.length === 1) return { kind: "one", item: pool[0]! };
  return { kind: "ambiguous", items: pool.slice(0, MAX_CANDIDATES) };
}

export function createDirectoryStore(): DirectoryStore {
  let members: DirectoryMember[] = [];
  let channels: DirectoryChannel[] = [];
  let channelMembers: Map<string, Set<string>> | undefined;
  let knownChannelRosters: Set<string> | undefined;
  let groupMembers: Map<string, Set<string>> | undefined;
  let listedGroupIds: Set<string> | undefined;
  let knownGroupRosters: Set<string> | undefined;
  let groupsSynced = false;
  let workspaceUrl: string | undefined;
  const syncedAts = new Map<string, number>();
  const channelObservedAts = new Map<string, number>();

  function acceptSync(section: string, syncedAt: number | undefined): boolean {
    if (syncedAt === undefined) return true;
    const stored = syncedAts.get(section);
    if (stored !== undefined && stored > syncedAt) {
      console.warn(`[directory] refused stale ${section} swap: stamped ${stored - syncedAt}ms behind`);
      return false;
    }
    syncedAts.set(section, syncedAt);
    return true;
  }

  return {
    async setWorkspaceUrl(url) {
      workspaceUrl = url;
    },
    async meta() {
      return { workspaceUrl: workspaceUrl ?? null };
    },
    async replace(next, syncedAt) {
      if (!acceptSync("members", syncedAt)) return false;
      members = next.filter((m) => m.principalId && m.type === "internal");
      return true;
    },
    async replaceChannels(
      nextChannels,
      nextChannelMembers,
      syncedAt,
      nextChannelRosterIds,
      revocations = [],
      partial = false,
    ) {
      if (partial && (syncedAt === undefined || !Number.isFinite(syncedAt) || nextChannelMembers === undefined))
        return false;
      if (partial && (syncedAts.get("channels") ?? 0) >= syncedAt!) return false;
      const protectedIds = new Set(
        [...channelObservedAts]
          .filter(([, at]) => syncedAt !== undefined && (partial ? at >= syncedAt : at > syncedAt))
          .map(([id]) => id),
      );
      if (partial && nextChannels.some((channel) => protectedIds.has(channel.channelId))) return false;
      if (!partial && !acceptSync("channels", syncedAt)) return false;
      const updatedIds = new Set(nextChannels.map((channel) => channel.channelId));
      channels = [
        ...channels.filter((channel) =>
          partial ? !updatedIds.has(channel.channelId) : protectedIds.has(channel.channelId),
        ),
        ...nextChannels.filter((c) => c.channelId && c.name && !protectedIds.has(c.channelId)),
      ];
      for (const id of updatedIds) {
        if (partial) channelObservedAts.set(id, syncedAt!);
        else if (!protectedIds.has(id)) channelObservedAts.delete(id);
      }
      const listed = new Set(channels.map((channel) => channel.channelId));
      knownChannelRosters = knownChannelRosters
        ? new Set([...knownChannelRosters].filter((channelId) => listed.has(channelId)))
        : undefined;
      if (nextChannelMembers !== undefined) {
        const rosterIds = new Set(
          (nextChannelRosterIds ?? nextChannels.map((channel) => channel.channelId)).filter(
            (id) => updatedIds.has(id) && !protectedIds.has(id),
          ),
        );
        const byChannel = new Map(
          [...(channelMembers ?? [])].filter(([channelId]) => listed.has(channelId) && !rosterIds.has(channelId)),
        );
        for (const channelId of rosterIds) if (listed.has(channelId)) byChannel.set(channelId, new Set());
        for (const m of nextChannelMembers) {
          if (!m.channelId || !m.principalId || !rosterIds.has(m.channelId) || !listed.has(m.channelId)) continue;
          (byChannel.get(m.channelId) ?? byChannel.set(m.channelId, new Set()).get(m.channelId)!).add(m.principalId);
        }
        channelMembers = byChannel;
        knownChannelRosters ??= new Set();
        for (const channelId of rosterIds) if (listed.has(channelId)) knownChannelRosters.add(channelId);
      }
      for (const member of revocations) {
        if (updatedIds.has(member.channelId) && !protectedIds.has(member.channelId) && member.principalId)
          channelMembers?.get(member.channelId)?.delete(member.principalId);
      }
      for (const id of channelObservedAts.keys()) if (!listed.has(id)) channelObservedAts.delete(id);
      return true;
    },
    async channelMember(channelId, principalId) {
      if (channels.some((channel) => channel.channelId === channelId && channel.isPrivate && channel.isExternal))
        return false;
      return hasPerson(channelMembers?.get(channelId), principalId);
    },
    async channelMemberIds(channelId) {
      if (!knownChannelRosters?.has(channelId)) return undefined;
      return [...(channelMembers?.get(channelId) ?? [])];
    },
    async channelMembership(channelId, principalId) {
      const channel = channels.find((candidate) => candidate.channelId === channelId);
      if (!channel || !knownChannelRosters?.has(channelId)) return undefined;
      const member = hasPerson(channelMembers?.get(channelId), principalId);
      return member || channel.isPrivate === true ? member : undefined;
    },
    async channelPrivacy(channelId) {
      const channel = channels.find((candidate) => candidate.channelId === channelId);
      return channel ? channel.isPrivate === true : undefined;
    },
    async replaceGroups(nextGroupMembers, syncedAt, nextGroupIds, nextGroupRosterIds) {
      if (!acceptSync("groups", syncedAt)) return false;
      const legacy = nextGroupIds === undefined || nextGroupRosterIds === undefined;
      const listed = new Set((nextGroupIds ?? nextGroupMembers.map((member) => member.groupId)).filter(Boolean));
      const rosterIds = new Set((nextGroupRosterIds ?? [...listed]).filter((groupId) => listed.has(groupId)));
      const byGroup = new Map(
        [...(groupMembers ?? [])].filter(([groupId]) => listed.has(groupId) && !rosterIds.has(groupId)),
      );
      for (const groupId of rosterIds) byGroup.set(groupId, new Set());
      for (const m of nextGroupMembers) {
        if (!m.groupId || !m.principalId || !rosterIds.has(m.groupId)) continue;
        (byGroup.get(m.groupId) ?? byGroup.set(m.groupId, new Set()).get(m.groupId)!).add(m.principalId);
      }
      groupMembers = byGroup;
      listedGroupIds = listed;
      knownGroupRosters = legacy
        ? new Set(rosterIds)
        : new Set([...(knownGroupRosters ?? [])].filter((groupId) => listed.has(groupId)));
      for (const groupId of rosterIds) knownGroupRosters.add(groupId);
      groupsSynced = true;
      return true;
    },
    async upsertGroup(groupId, principalIds) {
      const ids = principalIds.filter(Boolean);
      if (!groupId || !ids.length) return;
      const byGroup = groupMembers ?? new Map<string, Set<string>>();
      byGroup.set(groupId, new Set(ids));
      groupMembers = byGroup;
      listedGroupIds ??= new Set();
      listedGroupIds.add(groupId);
      knownGroupRosters ??= new Set();
      knownGroupRosters.add(groupId);
      const stored = syncedAts.get("groups");
      syncedAts.set("groups", Math.max(stored ?? 0, Date.now()));
    },
    async resolveGroupByParticipants(participants) {
      const key = groupParticipantsKey(participants);
      if (!key) return { kind: "none" };
      const groups = groupMembers;
      if (groups) {
        for (const [groupId, members] of groups) {
          if (groupParticipantsKey([...members]) === key) return { kind: "one", groupId };
        }
      }
      return { kind: "none" };
    },
    async groupMember(groupId, principalId) {
      return hasPerson(groupMembers?.get(groupId), principalId);
    },
    async groupMembership(groupId, principalId) {
      if (!groupsSynced) return undefined;
      if (!listedGroupIds?.has(groupId)) return false;
      if (!knownGroupRosters?.has(groupId)) return undefined;
      return hasPerson(groupMembers?.get(groupId), principalId);
    },
    async listGroupsFor(principalId) {
      const memberships = groupMembers;
      if (!memberships) return [];
      return [...memberships].filter(([, members]) => hasPerson(members, principalId)).map(([groupId]) => groupId);
    },
    async conversationMembers(kind, id) {
      let ids: string[];
      if (kind === "channel") {
        const channel = channels.find((candidate) => candidate.channelId === id);
        if (!channel || channel.isExternal || !knownChannelRosters?.has(id)) return undefined;
        ids = [...(channelMembers?.get(id) ?? [])];
      } else {
        if (!knownGroupRosters?.has(id)) return undefined;
        ids = [...(groupMembers?.get(id) ?? [])];
      }
      if (!ids.length) return undefined;
      const roster = ids
        .map((principalId) => members.find((member) => samePerson(member.principalId, principalId)))
        .filter((member): member is DirectoryMember => member !== undefined);
      return roster.length === ids.length ? roster : undefined;
    },
    async listChannelsFor(principalId) {
      return channels.filter(
        (channel) =>
          !channel.isPrivate || (!channel.isExternal && hasPerson(channelMembers?.get(channel.channelId), principalId)),
      );
    },
    async list() {
      return members;
    },
    async listChannels() {
      return channels;
    },
    async get(principalId) {
      return members.find((m) => samePerson(m.principalId, principalId)) ?? null;
    },
    async getBySlackId(slackId) {
      return members.find((m) => (m.slackId ?? m.principalId) === slackId) ?? null;
    },
    async resolve(query) {
      const bySlackId = members.find((x) => x.slackId && x.slackId === query.trim());
      if (bySlackId) return { kind: "one", member: bySlackId };
      const m = pickMatch(
        members,
        query,
        (x) => x.principalId,
        (x) => x.displayName,
      );
      if (m.kind === "one") return { kind: "one", member: m.item };
      if (m.kind === "ambiguous") return { kind: "ambiguous", candidates: m.items };
      return { kind: "none" };
    },
    async resolveChannel(query) {
      const m = pickMatch(
        channels,
        query,
        (x) => x.channelId,
        (x) => x.name,
      );
      if (m.kind === "one") return { kind: "one", channel: m.item };
      if (m.kind === "ambiguous") return { kind: "ambiguous", candidates: m.items };
      return { kind: "none" };
    },
  };
}