gloomberb 0.13.2 → 0.14.0

package/src/plugins/builtin/cloud/team/module.tsx

@@ -0,0 +1,78 @@
+import type { PluginModule } from "../../plugin-module";
+import { chatController } from "../../chat/controller";
+import { createCloudTeamCapability } from "./capability";
+import { registerTeamCommands } from "./command";
+import { teamChannelId } from "./model";
+import { TeamPane } from "./pane";
+import { TEAM_PANE_ID, TEAM_PANE_TEMPLATE_ID, openTeamPane } from "./pane-request";
+import { TeamStatusWidget } from "./status-widget";
+import { teamStore } from "./store";
+import { installTeamStateHost } from "./team-state-host";
+import { createCloudViewsCapability, teamViewsStore } from "./views";
+
+export { TeamsAccountTab } from "./acm-tab";
+export { teamStore } from "./store";
+
+/**
+ * Teams inside the cloud plugin: the store every surface reads, the team pane
+ * where a team is created and run, the `TEAM` and `FOCUS` commands, the
+ * `cloud.team` capability for other plugins, and the accent chips in the
+ * status bar.
+ */
+let disposeTeamState: (() => void) | null = null;
+let disposeChannelRefresh: (() => void) | null = null;
+
+export const teamModule: PluginModule = {
+  capabilities: [createCloudTeamCapability(), createCloudViewsCapability()],
+  panes: [{
+    id: TEAM_PANE_ID,
+    name: "TEAM",
+    icon: "T",
+    component: TeamPane,
+    defaultPosition: "right",
+    defaultMode: "floating",
+    defaultFloatingSize: { width: 84, height: 30 },
+    portableShare: {
+      private: { title: true, params: true, settings: true, state: true },
+    },
+  }],
+  paneTemplates: [{
+    id: TEAM_PANE_TEMPLATE_ID,
+    paneId: TEAM_PANE_ID,
+    label: "Team",
+    description: "Members, invites, channels, and settings for your teams",
+    keywords: ["team", "teams", "members", "invite", "collaborate"],
+    createInstance: () => ({ placement: "floating", instanceId: "team" }),
+  }],
+  slots: {
+    "status:widget": () => <TeamStatusWidget />,
+  },
+  setup(ctx) {
+    teamStore.attach(ctx.persistence);
+    teamStore.setNotifier(ctx.notify, {
+      openTeamChannel: (teamId) => ctx.createPaneFromTemplate("new-chat-pane", { arg: teamChannelId(teamId) }),
+      openTeamInvites: () => openTeamPane(ctx.createPaneFromTemplate, {}),
+      openTeamLayout: () => {
+        ctx.showPane("layout-marketplace");
+      },
+    });
+    teamStore.start();
+    registerTeamCommands(ctx);
+    teamViewsStore.attach(ctx);
+    teamViewsStore.start();
+    disposeTeamState = installTeamStateHost();
+    // The chat sidebar reads channels from the chat controller; when a team's
+    // channels or membership change, that list is stale until refetched.
+    disposeChannelRefresh = teamStore.onTeamUpdated((event) => {
+      if (event.change !== "settings") void chatController.refreshChatState().catch(() => {});
+    });
+  },
+  dispose() {
+    disposeChannelRefresh?.();
+    disposeChannelRefresh = null;
+    teamViewsStore.dispose();
+    disposeTeamState?.();
+    disposeTeamState = null;
+    teamStore.dispose();
+  },
+};

package/src/plugins/builtin/cloud/team/pane-model.test.ts

@@ -0,0 +1,100 @@
+import { describe, expect, test } from "bun:test";
+import type { TeamMember, TeamSummary } from "../../../../api-client";
+import {
+  cycleAccent,
+  draftChanges,
+  draftFromTeam,
+  draftProblem,
+  emptyTeamDraft,
+  nextFieldId,
+  sectionFieldIds,
+  setDraftName,
+  setDraftShortName,
+} from "./pane-model";
+
+const team: TeamSummary = {
+  id: "org-1",
+  name: "Macro Desk",
+  slug: "macro-desk",
+  accentColor: "magenta",
+  shortName: "MD",
+  allowMemberInvites: false,
+  channelId: "team:org-1",
+  createdAt: "2026-09-14T12:00:00.000Z",
+  role: "owner",
+  memberCount: 3,
+};
+
+const members: TeamMember[] = [
+  { id: "m-1", role: "owner", joinedAt: "", user: { id: "u0", username: "vince", displayName: "Vince" } },
+  { id: "m-2", role: "admin", joinedAt: "", user: { id: "u2", username: "lucas", displayName: "Lucas" } },
+  { id: "m-3", role: "member", joinedAt: "", user: { id: "u3", username: "mika", displayName: "Mika" } },
+];
+
+describe("team draft", () => {
+  test("the short name follows the name until edited by hand", () => {
+    let draft = emptyTeamDraft(0);
+    draft = setDraftName(draft, "Rates Desk");
+    expect(draft.shortName).toBe("RD");
+    draft = setDraftName(draft, "Options");
+    expect(draft.shortName).toBe("OPT");
+    draft = setDraftShortName(draft, "op-x!");
+    expect(draft.shortName).toBe("OPX");
+    draft = setDraftName(draft, "Something Else");
+    expect(draft.shortName).toBe("OPX");
+    draft = setDraftShortName(draft, "");
+    draft = setDraftName(draft, "Back To Auto");
+    expect(draft.shortName).toBe("BTA");
+  });
+
+  test("problems and changes", () => {
+    expect(draftProblem(emptyTeamDraft(0))).toBe("Give the team a name.");
+    const draft = draftFromTeam(team);
+    expect(draftProblem(draft)).toBeNull();
+    expect(draftChanges(team, draft)).toEqual({});
+    expect(draftChanges(team, { ...draft, name: "Macro Desk ", accentColor: "blue" })).toEqual({ accentColor: "blue" });
+    expect(draftChanges(team, { ...draft, allowMemberInvites: true, shortName: "MX" })).toEqual({
+      allowMemberInvites: true,
+      shortName: "MX",
+    });
+  });
+
+  test("accent cycles around the palette", () => {
+    expect(cycleAccent("amber", -1)).toBe("violet");
+    expect(cycleAccent("violet", 1)).toBe("amber");
+    expect(cycleAccent("blue", 1)).toBe("cyan");
+  });
+});
+
+describe("keyboard ring", () => {
+  const base = { team, members, invitationIds: ["inv-1"], linkTokens: ["tok"], channelIds: ["team:org-1", "team:org-1:trades"], selfUserId: "u0" };
+
+  test("owners reach every control; members only what they may use", () => {
+    expect(sectionFieldIds({ ...base, section: "members" })).toEqual(["role:m-2", "remove:m-2", "role:m-3", "remove:m-3"]);
+    expect(sectionFieldIds({ ...base, section: "invites" })).toEqual([
+      "invite-username", "invite-send", "cancel-invitation:inv-1", "new-link", "copy-link:tok", "revoke-link:tok",
+    ]);
+    expect(sectionFieldIds({ ...base, section: "channels" })).toEqual([
+      "channel-name", "channel-create", "open-channel:team:org-1", "open-channel:team:org-1:trades", "delete-channel:team:org-1:trades",
+    ]);
+    expect(sectionFieldIds({ ...base, section: "settings" })).toEqual(["name", "shortName", "accent", "allowMemberInvites", "save", "delete"]);
+
+    const member = { ...base, team: { ...team, role: "member" as const } };
+    expect(sectionFieldIds({ ...member, section: "members" })).toEqual([]);
+    expect(sectionFieldIds({ ...member, section: "invites" })).toEqual([]);
+    expect(sectionFieldIds({ ...member, team: { ...member.team, allowMemberInvites: true }, section: "invites" })).toEqual([
+      "new-link", "copy-link:tok", "revoke-link:tok",
+    ]);
+    expect(sectionFieldIds({ ...member, section: "settings" })).toEqual(["leave"]);
+    expect(sectionFieldIds({ ...base, section: "create", team: null })).toEqual(["name", "shortName", "accent", "create"]);
+  });
+
+  test("walks the ring in both directions and wraps", () => {
+    const ids = ["a", "b", "c"];
+    expect(nextFieldId(ids, null, 1)).toBe("a");
+    expect(nextFieldId(ids, null, -1)).toBe("c");
+    expect(nextFieldId(ids, "c", 1)).toBe("a");
+    expect(nextFieldId(ids, "a", -1)).toBe("c");
+    expect(nextFieldId([], "a", 1)).toBeNull();
+  });
+});

package/src/plugins/builtin/cloud/team/pane-model.ts

@@ -0,0 +1,156 @@
+import type {
+  TeamAccentColor,
+  TeamMember,
+  TeamSummary,
+} from "../../../../api-client";
+import {
+  TEAM_ACCENT_COLORS,
+  canInviteToTeam,
+  canManageTeam,
+  deriveTeamShortName,
+  normalizeTeamShortName,
+  teamChannelId,
+} from "./model";
+import type { TeamPaneSection } from "./pane-request";
+
+export const TEAM_PANE_SECTIONS: readonly { value: TeamPaneSection; label: string }[] = [
+  { value: "members", label: "Members" },
+  { value: "invites", label: "Invites" },
+  { value: "channels", label: "Channels" },
+  { value: "settings", label: "Settings" },
+];
+
+/** The create form and the settings form share one draft shape. */
+export interface TeamDraft {
+  name: string;
+  shortName: string;
+  /** True once the person typed a short name; until then it follows the name. */
+  shortNameEdited: boolean;
+  accentColor: TeamAccentColor;
+  allowMemberInvites: boolean;
+}
+
+export function draftFromTeam(team: TeamSummary): TeamDraft {
+  return {
+    name: team.name,
+    shortName: team.shortName,
+    shortNameEdited: true,
+    accentColor: team.accentColor,
+    allowMemberInvites: team.allowMemberInvites,
+  };
+}
+
+export function emptyTeamDraft(seed = Math.random()): TeamDraft {
+  const accent = TEAM_ACCENT_COLORS[Math.floor(seed * TEAM_ACCENT_COLORS.length) % TEAM_ACCENT_COLORS.length] ?? "blue";
+  return { name: "", shortName: "", shortNameEdited: false, accentColor: accent, allowMemberInvites: false };
+}
+
+/** Typing a name keeps the short name in step until it was edited by hand. */
+export function setDraftName(draft: TeamDraft, name: string): TeamDraft {
+  return {
+    ...draft,
+    name,
+    shortName: draft.shortNameEdited ? draft.shortName : (name.trim() ? deriveTeamShortName(name) : ""),
+  };
+}
+
+export function setDraftShortName(draft: TeamDraft, shortName: string): TeamDraft {
+  const normalized = normalizeTeamShortName(shortName);
+  return { ...draft, shortName: normalized, shortNameEdited: normalized.length > 0 };
+}
+
+export function cycleAccent(current: TeamAccentColor, delta: number): TeamAccentColor {
+  const index = TEAM_ACCENT_COLORS.indexOf(current);
+  const next = (index + delta + TEAM_ACCENT_COLORS.length) % TEAM_ACCENT_COLORS.length;
+  return TEAM_ACCENT_COLORS[next] ?? current;
+}
+
+export function draftProblem(draft: TeamDraft): string | null {
+  if (!draft.name.trim()) return "Give the team a name.";
+  if (draft.name.trim().length > 40) return "Team names are at most 40 characters.";
+  if (!draft.shortName) return "Pick a short name of 1 to 4 letters or digits.";
+  return null;
+}
+
+/** Only what changed goes to the server, so a no-op save is a no-op. */
+export function draftChanges(team: TeamSummary, draft: TeamDraft): {
+  name?: string;
+  shortName?: string;
+  accentColor?: TeamAccentColor;
+  allowMemberInvites?: boolean;
+} {
+  const changes: ReturnType<typeof draftChanges> = {};
+  if (draft.name.trim() !== team.name) changes.name = draft.name.trim();
+  if (draft.shortName !== team.shortName) changes.shortName = draft.shortName;
+  if (draft.accentColor !== team.accentColor) changes.accentColor = draft.accentColor;
+  if (draft.allowMemberInvites !== team.allowMemberInvites) changes.allowMemberInvites = draft.allowMemberInvites;
+  return changes;
+}
+
+/**
+ * The keyboard walks a ring of field ids per section. Buttons, inputs, the
+ * accent picker, and the checkbox all take part, in reading order, so Tab and
+ * the arrows reach everything a mouse can.
+ */
+export function sectionFieldIds(input: {
+  section: TeamPaneSection | "create";
+  team: TeamSummary | null;
+  members: readonly TeamMember[];
+  invitationIds: readonly string[];
+  linkTokens: readonly string[];
+  channelIds: readonly string[];
+  selfUserId: string | null;
+}): string[] {
+  const { section, team } = input;
+  if (section === "create") {
+    return ["name", "shortName", "accent", "create"];
+  }
+  if (!team) return [];
+  const manage = canManageTeam(team.role);
+  if (section === "members") {
+    if (!manage) return [];
+    return input.members.flatMap((member) =>
+      member.role === "owner" || member.user.id === input.selfUserId
+        ? []
+        : [`role:${member.id}`, `remove:${member.id}`],
+    );
+  }
+  if (section === "invites") {
+    const ids: string[] = [];
+    if (manage) ids.push("invite-username", "invite-send");
+    if (manage) ids.push(...input.invitationIds.map((id) => `cancel-invitation:${id}`));
+    if (canInviteToTeam(team)) {
+      ids.push("new-link");
+      for (const token of input.linkTokens) ids.push(`copy-link:${token}`, `revoke-link:${token}`);
+    }
+    return ids;
+  }
+  if (section === "channels") {
+    const ids: string[] = ["channel-name", "channel-create"];
+    for (const channelId of input.channelIds) {
+      ids.push(`open-channel:${channelId}`);
+      if (manage && channelId !== teamChannelId(team.id)) ids.push(`delete-channel:${channelId}`);
+    }
+    return ids;
+  }
+  // settings
+  const ids: string[] = [];
+  if (manage) ids.push("name", "shortName", "accent", "allowMemberInvites", "save");
+  ids.push(team.role === "owner" ? "delete" : "leave");
+  return ids;
+}
+
+export function nextFieldId(ids: readonly string[], current: string | null, delta: number): string | null {
+  if (ids.length === 0) return null;
+  const index = current ? ids.indexOf(current) : -1;
+  if (index === -1) return delta >= 0 ? ids[0]! : ids[ids.length - 1]!;
+  return ids[(index + delta + ids.length) % ids.length]!;
+}
+
+export function describeMemberCount(count: number): string {
+  return count === 1 ? "1 member" : `${count} members`;
+}
+
+export function shortenInviteUrl(url: string): string {
+  return url.replace(/^https?:\/\//, "").replace(/^www\./, "");
+}

package/src/plugins/builtin/cloud/team/pane-request.ts

@@ -0,0 +1,47 @@
+export type TeamPaneSection = "members" | "invites" | "channels" | "settings";
+
+/**
+ * What the pane should show when it opens or is brought back: a team and a
+ * section, or the create form. Commands and chips set it before creating the
+ * pane; an open pane consumes it as it arrives, the way ACM tabs work.
+ */
+export interface TeamPaneView {
+  teamId?: string | null;
+  section?: TeamPaneSection;
+  mode?: "team" | "create";
+}
+
+let pending: TeamPaneView | null = null;
+const listeners = new Set<(view: TeamPaneView) => void>();
+
+export function requestTeamPaneView(view: TeamPaneView): void {
+  pending = view;
+  if (listeners.size === 0) return;
+  for (const listener of listeners) listener(view);
+  pending = null;
+}
+
+export function consumeRequestedTeamPaneView(): TeamPaneView | null {
+  const view = pending;
+  pending = null;
+  return view;
+}
+
+export function subscribeRequestedTeamPaneView(listener: (view: TeamPaneView) => void): () => void {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+
+export const TEAM_PANE_ID = "team";
+export const TEAM_PANE_TEMPLATE_ID = "team-pane";
+
+/** Opens (or refocuses) the team pane on the requested view. */
+export function openTeamPane(
+  createPaneFromTemplate: (templateId: string, options?: { arg?: string }) => void,
+  view: TeamPaneView = {},
+): void {
+  requestTeamPaneView(view);
+  createPaneFromTemplate(TEAM_PANE_TEMPLATE_ID);
+}