@opengeni/react 4.2.1-canary.39642758903001 → 4.3.1

package/src/app/lib/actions/chords.ts

@@ -0,0 +1,185 @@
+/**
+ * Keyboard chords: matching, platform notation and desktop accelerators.
+ *
+ * A chord always has ⌘ (Mac) or Ctrl (Windows and Linux) unless it is a
+ * navigation chord with ⌥/Alt, so it never fights with typing. Chords match on
+ * `KeyboardEvent.code`, which names the physical key, so they work on every
+ * keyboard layout. Punctuation also matches the character typed, because many
+ * layouts put it elsewhere: "/" is ⇧7 on Nordic and German keyboards.
+ */
+
+export type ChordPlatform = "mac" | "other";
+export type ActionSurface = "web" | "desktop";
+
+export type Chord = {
+  /** `KeyboardEvent.code`, e.g. `"KeyO"`, `"Comma"`, `"ArrowDown"`, `"Digit1"`. */
+  code: string;
+  /** ⌘ on Mac, Ctrl elsewhere. */
+  mod?: boolean;
+  shift?: boolean;
+  /** ⌥ on Mac, Alt elsewhere. */
+  alt?: boolean;
+  /** The Control key itself on Mac (⌃). Ignored elsewhere, where `mod` is Ctrl. */
+  control?: boolean;
+  /** Only on this surface (browsers reserve some keys). */
+  only?: ActionSurface;
+  /** Only on this platform. */
+  platform?: ChordPlatform;
+};
+
+export function currentPlatform(): ChordPlatform {
+  if (typeof navigator === "undefined") return "other";
+  const uaData = (navigator as Navigator & { userAgentData?: { platform?: string } }).userAgentData;
+  const platform = uaData?.platform ?? navigator.platform ?? "";
+  return /Mac|iPhone|iPad|iPod/i.test(platform) ? "mac" : "other";
+}
+
+/** The chords that apply on this surface and platform, in priority order. */
+export function applicableChords(
+  chords: readonly Chord[] | undefined,
+  surface: ActionSurface,
+  platform: ChordPlatform,
+): Chord[] {
+  return (chords ?? []).filter(
+    (chord) =>
+      (!chord.only || chord.only === surface) && (!chord.platform || chord.platform === platform),
+  );
+}
+
+export function matchesChord(
+  event: Pick<
+    KeyboardEvent,
+    "code" | "key" | "metaKey" | "ctrlKey" | "shiftKey" | "altKey" | "repeat" | "isComposing"
+  >,
+  chord: Chord,
+  platform: ChordPlatform,
+): boolean {
+  if (event.repeat || event.isComposing) return false;
+  if (event.code === chord.code) {
+    if (Boolean(chord.shift) !== event.shiftKey) return false;
+  } else {
+    // The character on another key: whatever Shift it took to type it is part
+    // of typing the character, so only a chord without Shift can match this way.
+    const character = PUNCTUATION[chord.code];
+    if (!character || chord.shift || event.key !== character) return false;
+  }
+  if (Boolean(chord.alt) !== event.altKey) return false;
+  if (platform === "mac") {
+    if (Boolean(chord.mod) !== event.metaKey) return false;
+    if (Boolean(chord.control) !== event.ctrlKey) return false;
+  } else {
+    if (Boolean(chord.mod) !== event.ctrlKey) return false;
+    if (event.metaKey) return false;
+  }
+  return true;
+}
+
+const PUNCTUATION: Record<string, string> = {
+  Comma: ",",
+  Period: ".",
+  Slash: "/",
+  Backslash: "\\",
+  BracketLeft: "[",
+  BracketRight: "]",
+  Semicolon: ";",
+  Quote: "'",
+  Minus: "-",
+  Equal: "=",
+  Backquote: "`",
+};
+
+const KEY_NAMES: Record<string, { mac: string; other: string; accelerator: string }> = {
+  Comma: { mac: ",", other: ",", accelerator: "," },
+  Period: { mac: ".", other: ".", accelerator: "." },
+  Slash: { mac: "/", other: "/", accelerator: "/" },
+  Backslash: { mac: "\\", other: "\\", accelerator: "\\" },
+  BracketLeft: { mac: "[", other: "[", accelerator: "[" },
+  BracketRight: { mac: "]", other: "]", accelerator: "]" },
+  Semicolon: { mac: ";", other: ";", accelerator: ";" },
+  Quote: { mac: "'", other: "'", accelerator: "'" },
+  Minus: { mac: "-", other: "-", accelerator: "-" },
+  Equal: { mac: "=", other: "=", accelerator: "=" },
+  Backquote: { mac: "`", other: "`", accelerator: "`" },
+  ArrowUp: { mac: "↑", other: "↑", accelerator: "Up" },
+  ArrowDown: { mac: "↓", other: "↓", accelerator: "Down" },
+  ArrowLeft: { mac: "←", other: "←", accelerator: "Left" },
+  ArrowRight: { mac: "→", other: "→", accelerator: "Right" },
+  Enter: { mac: "↩", other: "Enter", accelerator: "Return" },
+  Escape: { mac: "Esc", other: "Esc", accelerator: "Escape" },
+  Tab: { mac: "⇥", other: "Tab", accelerator: "Tab" },
+  Space: { mac: "Space", other: "Space", accelerator: "Space" },
+  Backspace: { mac: "⌫", other: "Backspace", accelerator: "Backspace" },
+};
+
+function keyName(code: string, platform: ChordPlatform | "accelerator"): string {
+  const known = KEY_NAMES[code];
+  if (known) return known[platform];
+  if (/^Key[A-Z]$/.test(code)) return code.slice(3);
+  if (/^Digit[0-9]$/.test(code)) return code.slice(5);
+  if (/^F[0-9]{1,2}$/.test(code)) return code;
+  return code;
+}
+
+/** The chord as keycaps, in the platform's own notation: `["⌘", "⇧", "O"]` or `["Ctrl", "Shift", "O"]`. */
+export function chordKeys(chord: Chord, platform: ChordPlatform): string[] {
+  if (platform === "mac") {
+    // Apple's order: Control, Option, Shift, Command.
+    return [
+      ...(chord.control ? ["⌃"] : []),
+      ...(chord.alt ? ["⌥"] : []),
+      ...(chord.shift ? ["⇧"] : []),
+      ...(chord.mod ? ["⌘"] : []),
+      keyName(chord.code, "mac"),
+    ];
+  }
+  return [
+    ...(chord.mod ? ["Ctrl"] : []),
+    ...(chord.alt ? ["Alt"] : []),
+    ...(chord.shift ? ["Shift"] : []),
+    keyName(chord.code, "other"),
+  ];
+}
+
+/** One string for tooltips and `title`s: `⌘⇧O` on Mac, `Ctrl+Shift+O` elsewhere. */
+export function chordLabel(chord: Chord, platform: ChordPlatform): string {
+  const keys = chordKeys(chord, platform);
+  return platform === "mac" ? keys.join("") : keys.join("+");
+}
+
+/** The `aria-keyshortcuts` value for a chord. */
+export function chordAriaKeys(chord: Chord, platform: ChordPlatform): string {
+  const key = keyName(chord.code, "accelerator");
+  const named =
+    key === "Up" || key === "Down" || key === "Left" || key === "Right" ? `Arrow${key}` : key;
+  return [
+    ...(chord.control && platform === "mac" ? ["Control"] : []),
+    ...(chord.mod ? [platform === "mac" ? "Meta" : "Control"] : []),
+    ...(chord.alt ? ["Alt"] : []),
+    ...(chord.shift ? ["Shift"] : []),
+    named,
+  ].join("+");
+}
+
+/** An Electron accelerator for the desktop menu bar. */
+export function chordAccelerator(chord: Chord): string {
+  return [
+    ...(chord.control ? ["Ctrl"] : []),
+    ...(chord.mod ? ["CmdOrCtrl"] : []),
+    ...(chord.alt ? ["Alt"] : []),
+    ...(chord.shift ? ["Shift"] : []),
+    keyName(chord.code, "accelerator"),
+  ].join("+");
+}
+
+/** True when typing into this element would insert text (so bare keys belong to it). */
+export function isTextEntry(target: EventTarget | null): boolean {
+  if (!(target instanceof HTMLElement)) return false;
+  if (target.isContentEditable) return true;
+  if (target instanceof HTMLTextAreaElement) return !target.readOnly;
+  if (target instanceof HTMLInputElement) {
+    return !["button", "checkbox", "radio", "range", "color", "file", "submit", "reset"].includes(
+      target.type,
+    );
+  }
+  return false;
+}

package/src/app/lib/actions/events.ts

@@ -0,0 +1,10 @@
+/** Page events that reach the action system from outside React's tree. */
+
+/** Opens the ⌘K menu (older desktop menu commands, buttons). Sent on the window target. */
+export const OPEN_COMMAND_MENU_EVENT = "opengeni:open-command-menu";
+/** Asks the chat header to start renaming the chat on screen. Sent on the document target. */
+export const RENAME_CURRENT_CHAT_EVENT = "opengeni:rename-current-chat";
+
+export function requestCommandMenu(target: EventTarget): void {
+  target.dispatchEvent(new Event(OPEN_COMMAND_MENU_EVENT));
+}

package/src/app/lib/actions/rank.ts

@@ -0,0 +1,119 @@
+/**
+ * Ranks short labels (chat titles, action names) against what someone typed.
+ *
+ * Higher is better; `null` means no match. Tiers, best first:
+ * whole label starts with the query, a word starts with it, it appears
+ * anywhere, every query word appears in some order, and finally the query's
+ * letters appear in order ("kbsh" → "Keyboard shortcuts"). Within a tier,
+ * shorter labels and earlier positions win. Letters-in-order matches rank below
+ * `LOOSE_MATCH_BELOW`, so a list can drop them once it has real matches.
+ */
+
+const COMBINING_MARKS = /[\u0300-\u036f]/g;
+
+/** Ranks below this are letters-in-order guesses rather than real matches. */
+export const LOOSE_MATCH_BELOW = 400;
+
+/** Case- and accent-insensitive form used for matching. */
+export function foldForSearch(value: string): string {
+  return value
+    .normalize("NFD")
+    .replace(COMBINING_MARKS, "")
+    .toLowerCase()
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function wordStarts(label: string): number[] {
+  const starts: number[] = [];
+  for (let index = 0; index < label.length; index++) {
+    const previous = index === 0 ? " " : label[index - 1]!;
+    const current = label[index]!;
+    if (/[\p{L}\p{N}]/u.test(current) && !/[\p{L}\p{N}]/u.test(previous)) starts.push(index);
+  }
+  return starts;
+}
+
+function subsequenceScore(label: string, query: string): number | null {
+  // Letters in order, read the way people abbreviate: the first letter starts a
+  // word, and moving on to a later word means landing on its first letter
+  // ("kbsh" → Keyboard shortcuts). Consecutive letters are worth more.
+  const startList = wordStarts(label);
+  const starts = new Set(startList);
+  const wordOf = (index: number) => {
+    let word = -1;
+    for (const start of startList) {
+      if (start > index) break;
+      word++;
+    }
+    return word;
+  };
+  let position = 0;
+  let score = 0;
+  let previous = -2;
+  // Prefer the next letter inside the current word; otherwise only the start
+  // of a later word counts.
+  const fits = (found: number) =>
+    found === previous + 1 ||
+    starts.has(found) ||
+    (previous >= 0 && wordOf(found) === wordOf(previous));
+  for (const character of query) {
+    if (character === " ") continue;
+    let found = label.indexOf(character, position);
+    while (found >= 0 && !fits(found)) found = label.indexOf(character, found + 1);
+    if (found < 0) return null;
+    score += found === previous + 1 ? 3 : starts.has(found) ? 2 : 0;
+    previous = found;
+    position = found + 1;
+  }
+  return score;
+}
+
+export function rankLabel(rawLabel: string, rawQuery: string): number | null {
+  const query = foldForSearch(rawQuery);
+  if (!query) return 0;
+  const label = foldForSearch(rawLabel);
+  if (!label) return null;
+  const lengthPenalty = Math.min(label.length, 200) / 1000;
+  if (label === query) return 1000;
+  if (label.startsWith(query)) return 900 - lengthPenalty;
+  const at = label.indexOf(query);
+  if (at >= 0) {
+    const starts = wordStarts(label);
+    if (starts.includes(at)) return 800 - at / 100 - lengthPenalty;
+    return 600 - at / 100 - lengthPenalty;
+  }
+  const words = query.split(" ").filter(Boolean);
+  if (words.length > 1 && words.every((word) => label.includes(word))) {
+    const starts = wordStarts(label);
+    const wordStartHits = words.filter((word) =>
+      starts.some((start) => label.startsWith(word, start)),
+    ).length;
+    return 500 + (wordStartHits / words.length) * 50 - lengthPenalty;
+  }
+  if (query.replace(/ /g, "").length < 2) return null;
+  const subsequence = subsequenceScore(label, query);
+  if (subsequence === null) return null;
+  // Only keep loose matches that hit word starts or runs; random letters scattered
+  // across a long title are noise.
+  const letters = query.replace(/ /g, "").length;
+  if (subsequence < letters) return null;
+  return 100 + Math.min(subsequence, 200) - lengthPenalty * 10;
+}
+
+/** The best rank across a label and extra keywords (a keyword match ranks below the same match on the name). */
+export function rankWithKeywords(
+  label: string,
+  keywords: readonly string[] | undefined,
+  query: string,
+): number | null {
+  let best = rankLabel(label, query);
+  for (const keyword of keywords ?? []) {
+    const rank = rankLabel(keyword, query);
+    if (rank !== null) {
+      const discounted = rank - 150;
+      if (best === null || discounted > best) best = discounted;
+    }
+  }
+  return best;
+}

package/src/app/lib/actions/registry.ts

@@ -0,0 +1,333 @@
+/**
+ * The action registry: everything a person can do from the keyboard, the ⌘K
+ * menu, menus and the desktop menu bar. Each action is defined once here, with
+ * its name, keys and availability, so every surface shows and runs it the same
+ * way. See docs/command-menu-and-shortcuts.md.
+ */
+import {
+  ArchiveIcon,
+  ArchiveRestoreIcon,
+  ArrowDownIcon,
+  ArrowUpIcon,
+  CommandIcon,
+  HistoryIcon,
+  InboxIcon,
+  KeyboardIcon,
+  LinkIcon,
+  MailIcon,
+  MailOpenIcon,
+  PanelLeftIcon,
+  PencilIcon,
+  PinIcon,
+  PinOffIcon,
+  PlusIcon,
+  SearchIcon,
+  TextSearchIcon,
+  type LucideIcon,
+} from "lucide-react";
+import type { SessionListRow } from "../../../session-list-model";
+import type { ActionSurface, Chord, ChordPlatform } from "./chords";
+import type { ChatOperations } from "./chat-operations";
+
+export type ActionGroup = "chat" | "navigate" | "view" | "help";
+
+/** Where the desktop menu bar shows an action. */
+export type DesktopMenuPlacement = "file" | "view" | "go" | "chat" | "help";
+
+export type ActionEnv = {
+  workspaceId: string;
+  subjectId: string;
+  surface: ActionSurface;
+  platform: ChordPlatform;
+  /** The chat on screen, if any. */
+  currentChat: SessionListRow | null;
+  ops: ChatOperations;
+  /** Whether the sidebar's chat list is part of this surface. */
+  chatList: boolean;
+  newChat(): void;
+  openChat(chatId: string): void;
+  openInbox(): void;
+  toggleSidebar(): void;
+  findInChat(): void;
+  searchMessages(query?: string): void;
+  renameCurrentChat(): void;
+  openCommandMenu(): void;
+  openShortcutSheet(): void;
+  /** Back to the most recently viewed other chat (a quick Control+Tab). */
+  switchToRecentChat(): void;
+  /** Chats in sidebar order, and the pinned ones in their order. */
+  sidebarOrder(): readonly string[];
+  pinnedOrder(): readonly string[];
+};
+
+export type AppAction = {
+  id: string;
+  /** Plain words; chat actions may read the chat (Pin or Unpin). */
+  title: string | ((env: ActionEnv, chat: SessionListRow | null) => string);
+  group: ActionGroup;
+  icon: LucideIcon;
+  /** A different icon for some chats (Unpin for a pinned chat). */
+  iconFor?: (chat: SessionListRow | null) => LucideIcon;
+  /** Extra words the ⌘K menu matches, e.g. "share" for Copy link. */
+  keywords?: readonly string[];
+  chords?: readonly Chord[];
+  /** The cheat sheet's own key text when one action has many chords (⌘1 to ⌘9). */
+  chordSummary?: (platform: ChordPlatform) => string;
+  /** Acts on a chat: the current one, or the one a menu or ⌘K row points at. */
+  forChat?: boolean;
+  /** Listed in the ⌘K menu (some exist only as keys). Default true. */
+  inCommandMenu?: boolean;
+  /**
+   * Opens a dialog of its own. From ⌘K it runs once the menu has handed focus
+   * back, so the new dialog returns focus to the same place when it closes.
+   */
+  opensDialog?: boolean;
+  /** Offered in ⌘K before anything is typed. */
+  suggested?: boolean;
+  /** The desktop menu bar section, when it appears there. */
+  desktopMenu?: DesktopMenuPlacement;
+  available(env: ActionEnv, chat: SessionListRow | null): boolean;
+  run(env: ActionEnv, chat: SessionListRow | null, chord?: Chord): void | Promise<void>;
+};
+
+export function actionTitle(
+  action: AppAction,
+  env: ActionEnv,
+  chat: SessionListRow | null,
+): string {
+  return typeof action.title === "string" ? action.title : action.title(env, chat);
+}
+
+export function actionIcon(action: AppAction, chat: SessionListRow | null): LucideIcon {
+  return action.iconFor?.(chat) ?? action.icon;
+}
+
+const ALWAYS = () => true;
+
+function stepChat(env: ActionEnv, direction: 1 | -1): void {
+  const order = env.sidebarOrder();
+  if (order.length === 0) return;
+  const index = env.currentChat ? order.indexOf(env.currentChat.id) : -1;
+  const next = index < 0 ? (direction === 1 ? 0 : order.length - 1) : index + direction;
+  if (next < 0 || next >= order.length) return;
+  env.openChat(order[next]!);
+}
+
+const PINNED_CHORDS: Chord[] = Array.from({ length: 9 }, (_, index) => ({
+  code: `Digit${index + 1}`,
+  mod: true,
+  only: "desktop" as const,
+}));
+
+export const APP_ACTIONS: readonly AppAction[] = [
+  {
+    id: "commandMenu.open",
+    title: "Command menu",
+    group: "help",
+    icon: CommandIcon,
+    chords: [{ code: "KeyK", mod: true }],
+    inCommandMenu: false,
+    desktopMenu: "go",
+    available: ALWAYS,
+    run: (env) => env.openCommandMenu(),
+  },
+  {
+    id: "chat.new",
+    title: "New chat",
+    group: "chat",
+    icon: PlusIcon,
+    keywords: ["start", "create", "session"],
+    // The desktop menu shows its first key, the familiar ⌘N; browsers keep ⌘N for windows.
+    chords: [
+      { code: "KeyN", mod: true, only: "desktop" },
+      { code: "KeyO", mod: true, shift: true },
+    ],
+    suggested: true,
+    desktopMenu: "file",
+    available: ALWAYS,
+    run: (env) => env.newChat(),
+  },
+  {
+    id: "chat.copyLink",
+    title: "Copy link",
+    group: "chat",
+    icon: LinkIcon,
+    keywords: ["share", "url", "address"],
+    chords: [{ code: "Comma", mod: true, shift: true }],
+    forChat: true,
+    suggested: true,
+    desktopMenu: "chat",
+    available: (_env, chat) => chat !== null,
+    run: (env, chat) => (chat ? env.ops.copyLink(chat) : undefined),
+  },
+  {
+    id: "chat.pin",
+    title: (_env, chat) => (chat?.pinned ? "Unpin" : "Pin"),
+    group: "chat",
+    icon: PinIcon,
+    iconFor: (chat) => (chat?.pinned ? PinOffIcon : PinIcon),
+    keywords: ["unpin", "favorite", "star"],
+    chords: [{ code: "KeyP", mod: true, alt: true }],
+    forChat: true,
+    suggested: true,
+    desktopMenu: "chat",
+    available: (_env, chat) => chat !== null && !chat.archived,
+    run: (env, chat) => (chat ? env.ops.setPinned(chat, !chat.pinned) : undefined),
+  },
+  {
+    id: "chat.rename",
+    title: "Rename",
+    group: "chat",
+    icon: PencilIcon,
+    keywords: ["title", "name"],
+    forChat: true,
+    desktopMenu: "chat",
+    // Renaming happens in the chat's own title, so only for the chat on screen.
+    available: (env, chat) => chat !== null && env.currentChat?.id === chat.id,
+    run: (env) => env.renameCurrentChat(),
+  },
+  {
+    id: "chat.unread",
+    title: (_env, chat) => (chat?.unread ? "Mark as read" : "Mark as unread"),
+    group: "chat",
+    icon: MailIcon,
+    iconFor: (chat) => (chat?.unread ? MailOpenIcon : MailIcon),
+    keywords: ["read", "unread"],
+    forChat: true,
+    desktopMenu: "chat",
+    available: (_env, chat) => chat !== null && !chat.archived,
+    run: (env, chat) => (chat ? env.ops.setUnread(chat, !chat.unread) : undefined),
+  },
+  {
+    id: "chat.archive",
+    title: (_env, chat) => (chat?.archived ? "Restore" : "Archive"),
+    group: "chat",
+    icon: ArchiveIcon,
+    iconFor: (chat) => (chat?.archived ? ArchiveRestoreIcon : ArchiveIcon),
+    keywords: ["restore", "hide", "done"],
+    forChat: true,
+    desktopMenu: "chat",
+    available: (_env, chat) => chat !== null && chat.parentSessionId === null,
+    run: (env, chat) => (chat ? env.ops.setArchived(chat, !chat.archived) : undefined),
+  },
+  {
+    id: "chat.find",
+    title: "Find in chat",
+    group: "chat",
+    icon: TextSearchIcon,
+    keywords: ["search", "find"],
+    chords: [{ code: "KeyF", mod: true }],
+    desktopMenu: "chat",
+    // The conversation owns ⌘F itself; the registry lists it so it is discoverable.
+    available: (env) => env.currentChat !== null,
+    run: (env) => env.findInChat(),
+  },
+  {
+    id: "go.inbox",
+    title: "Inbox",
+    group: "navigate",
+    icon: InboxIcon,
+    keywords: ["notifications", "replies", "needs you"],
+    chords: [
+      { code: "KeyI", mod: true, shift: true, platform: "mac" },
+      // Browsers on Windows and Linux open developer tools with Ctrl+Shift+I.
+      { code: "KeyI", mod: true, shift: true, platform: "other", only: "desktop" },
+    ],
+    suggested: true,
+    desktopMenu: "go",
+    available: ALWAYS,
+    run: (env) => env.openInbox(),
+  },
+  {
+    id: "go.previousChat",
+    title: "Previous chat",
+    group: "navigate",
+    icon: ArrowUpIcon,
+    chords: [{ code: "ArrowUp", alt: true }],
+    inCommandMenu: false,
+    available: (env) => env.chatList,
+    run: (env) => stepChat(env, -1),
+  },
+  {
+    id: "go.nextChat",
+    title: "Next chat",
+    group: "navigate",
+    icon: ArrowDownIcon,
+    chords: [{ code: "ArrowDown", alt: true }],
+    inCommandMenu: false,
+    available: (env) => env.chatList,
+    run: (env) => stepChat(env, 1),
+  },
+  {
+    // Hold Control to see recent chats and keep pressing Tab; release to open.
+    // The actions provider runs the switcher itself because it needs Control's
+    // release, so the desktop menu bar never owns this key.
+    id: "go.recentChat",
+    title: "Switch to recent chat",
+    group: "navigate",
+    icon: HistoryIcon,
+    chords: [
+      { code: "Tab", control: true, platform: "mac", only: "desktop" },
+      // Browsers keep Control+Tab for their own tabs.
+      { code: "Tab", mod: true, platform: "other", only: "desktop" },
+    ],
+    inCommandMenu: false,
+    available: ALWAYS,
+    run: (env) => env.switchToRecentChat(),
+  },
+  {
+    id: "go.pinnedChat",
+    title: "Pinned chat 1 to 9",
+    group: "navigate",
+    icon: PinIcon,
+    chords: PINNED_CHORDS,
+    chordSummary: (platform) => (platform === "mac" ? "⌘1 – ⌘9" : "Ctrl+1 – Ctrl+9"),
+    inCommandMenu: false,
+    available: (env) => env.chatList,
+    run: (env, _chat, chord) => {
+      const index = chord ? Number(chord.code.slice(5)) - 1 : 0;
+      const id = env.pinnedOrder()[index];
+      if (id) env.openChat(id);
+    },
+  },
+  {
+    id: "go.searchMessages",
+    title: "Search messages",
+    group: "navigate",
+    icon: SearchIcon,
+    keywords: ["find", "history", "full text"],
+    opensDialog: true,
+    desktopMenu: "go",
+    available: ALWAYS,
+    run: (env) => env.searchMessages(),
+  },
+  {
+    id: "view.sidebar",
+    title: "Toggle sidebar",
+    group: "view",
+    icon: PanelLeftIcon,
+    keywords: ["hide", "show", "collapse", "rail"],
+    chords: [
+      { code: "KeyS", mod: true, control: true, platform: "mac" },
+      { code: "KeyS", mod: true, shift: true, platform: "other" },
+    ],
+    desktopMenu: "view",
+    available: (env) => env.chatList,
+    run: (env) => env.toggleSidebar(),
+  },
+  {
+    id: "help.shortcuts",
+    title: "Keyboard shortcuts",
+    group: "help",
+    icon: KeyboardIcon,
+    keywords: ["keys", "hotkeys", "cheat sheet", "help"],
+    chords: [{ code: "Slash", mod: true }],
+    desktopMenu: "help",
+    available: ALWAYS,
+    run: (env) => env.openShortcutSheet(),
+  },
+];
+
+export function findAction(id: string): AppAction | undefined {
+  return APP_ACTIONS.find((action) => action.id === id);
+}