gloomberb 0.13.2 → 0.14.0

package/src/plugins/builtin/notes/owner.tsx

@@ -0,0 +1,129 @@
+import { useSyncExternalStore } from "react";
+import type { TeamSummary } from "../../../api-client";
+import { ChoiceDialog } from "../../../components/ui/choice-dialog";
+import { Tabs } from "../../../components/ui/tabs";
+import { Box, Text } from "../../../ui";
+import type { DialogApi, PromptContext } from "../../../ui/dialog";
+import { colors } from "../../../theme/colors";
+import { teamAccentHex, teamPrefix } from "../cloud/team/model";
+import { teamStore } from "../cloud/team/store";
+import { NoteConflictError, type NoteOwner, noteOwnerKey } from "./store";
+
+export function useNoteTeams(): TeamSummary[] {
+  return useSyncExternalStore(
+    (onChange) => teamStore.subscribe(onChange),
+    () => teamStore.getSnapshot(),
+  ).teams;
+}
+
+/** The owner a new note defaults to: the focused team, else me. */
+export function defaultNoteOwner(): NoteOwner {
+  const teamId = teamStore.getDefaultTeamId();
+  return teamId ? { kind: "team", teamId } : { kind: "user" };
+}
+
+export function ownerLabel(owner: NoteOwner, teams: readonly TeamSummary[]): string {
+  if (owner.kind === "user") return "Me";
+  const team = teams.find((entry) => entry.id === owner.teamId);
+  return team ? teamPrefix(team) : "Team";
+}
+
+export function ownerColor(owner: NoteOwner, teams: readonly TeamSummary[]): string {
+  if (owner.kind === "user") return colors.textDim;
+  const team = teams.find((entry) => entry.id === owner.teamId);
+  return team ? teamAccentHex(team.accentColor) : colors.textDim;
+}
+
+/** Me plus one pill per team. Hidden when there are no teams. */
+export function NoteOwnerStrip({
+  owner,
+  teams,
+  onSelect,
+  focused,
+}: {
+  owner: NoteOwner;
+  teams: readonly TeamSummary[];
+  onSelect: (owner: NoteOwner) => void;
+  focused: boolean;
+}) {
+  if (teams.length === 0) return null;
+  const tabs = [
+    { label: "Me", value: "user" },
+    ...teams.map((team) => ({ label: teamPrefix(team), value: `team:${team.id}`, fg: teamAccentHex(team.accentColor) })),
+  ];
+  return (
+    <Box height={1} flexDirection="row" paddingLeft={1}>
+      <Tabs
+        tabs={tabs}
+        activeValue={noteOwnerKey(owner)}
+        onSelect={(value) => onSelect(value === "user" ? { kind: "user" } : { kind: "team", teamId: value.slice("team:".length) })}
+        compact
+        variant="pill"
+        focused={focused}
+        keyboardNavigation={false}
+      />
+    </Box>
+  );
+}
+
+/** Where a new note goes, asked only when there is a choice. */
+export async function chooseNoteOwner(dialog: DialogApi, teams: readonly TeamSummary[]): Promise<NoteOwner | null> {
+  if (teams.length === 0) return { kind: "user" };
+  const preferred = defaultNoteOwner();
+  const choice = await dialog.prompt<string>({
+    closeOnClickOutside: true,
+    content: (context: PromptContext<string>) => (
+      <ChoiceDialog
+        {...context}
+        title="New note for"
+        choices={[
+          { id: "user", label: "Me", description: "Only you see it." },
+          ...teams.map((team) => ({ id: `team:${team.id}`, label: `${teamPrefix(team)} ${team.name}`, description: "Every member can read and edit it." })),
+        ]}
+        selectedChoiceId={noteOwnerKey(preferred)}
+      />
+    ),
+  }).catch(() => undefined);
+  if (!choice) return null;
+  return choice === "user" ? { kind: "user" } : { kind: "team", teamId: choice.slice("team:".length) };
+}
+
+export type NoteConflictChoice = "reload" | "overwrite" | "keep";
+
+/**
+ * A teammate saved since this note was opened. The buffer stays as is;
+ * the person picks reload, overwrite, or keep editing for now.
+ */
+export async function resolveNoteConflict(dialog: DialogApi, error: NoteConflictError): Promise<NoteConflictChoice> {
+  const editor = error.current?.updatedBy.username
+    ? `@${error.current.updatedBy.username}`
+    : error.current?.updatedBy.displayName ?? "a teammate";
+  const choice = await dialog.prompt<string>({
+    closeOnClickOutside: false,
+    content: (context: PromptContext<string>) => (
+      <ChoiceDialog
+        {...context}
+        title={`Edited by ${editor} since you opened it`}
+        choices={[
+          { id: "reload", label: "Reload their version", description: "Your changes are dropped." },
+          { id: "overwrite", label: "Overwrite with mine", description: "Their changes are dropped." },
+          { id: "keep", label: "Keep editing", description: "Decide on the next save." },
+        ]}
+        selectedChoiceId="keep"
+      />
+    ),
+  }).catch(() => undefined);
+  return choice === "reload" || choice === "overwrite" ? choice : "keep";
+}
+
+export function ReadOnlyBanner({ owner, teams }: { owner: NoteOwner; teams: readonly TeamSummary[] }) {
+  return (
+    <Box height={1} paddingLeft={1}>
+      <Text fg={colors.warning}>
+        {owner.kind === "user"
+          ? "Offline: notes are read-only until Gloom Cloud is reachable."
+          : `Offline: ${ownerLabel(owner, teams)} notes are read-only.`}
+      </Text>
+    </Box>
+  );
+}

package/src/plugins/builtin/notes/quick-notes-pane.test.tsx

@@ -7,6 +7,12 @@ import { Box, Text } from "../../../ui";
 import { PluginRenderProvider } from "../../runtime";
 import { createQuickNotesPane } from "./quick-notes-pane";
 import type { NotesFiles } from "./files";
+import { NotesStoreRegistry } from "./store";
+
+/** The tabs take a registry; while signed out it hands back the disk store. */
+function registryFor(files: NotesFiles): NotesStoreRegistry {
+  return new NotesStoreRegistry({ persistence: null, files, isSignedIn: () => false });
+}
 import type { QuickNoteEntry } from "./model";
 
 let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
@@ -28,6 +34,8 @@ function createMockNotesFiles(options?: { loadDelayMs?: number }) {
 
   return {
     saves,
+    readOnly: false,
+    owner: { kind: "user" },
     async load(key: string) {
       if (loadDelayMs > 0) {
         await new Promise((resolve) => setTimeout(resolve, loadDelayMs));
@@ -86,7 +94,7 @@ afterEach(async () => {
 describe("createQuickNotesPane", () => {
   test("does not save stale buffer text to a new tab before its notes load", async () => {
     const notesFiles = createMockNotesFiles({ loadDelayMs: 50 });
-    const QuickNotesPane = createQuickNotesPane(notesFiles);
+    const QuickNotesPane = createQuickNotesPane(registryFor(notesFiles));
 
     testSetup = await testRender(
       <QuickNotesHarness QuickNotesPane={QuickNotesPane} />,
@@ -145,7 +153,7 @@ describe("createQuickNotesPane", () => {
         throw new Error("EACCES: permission denied");
       },
     } as unknown as NotesFiles & { saves: Array<{ key: string; text: string }> };
-    const QuickNotesPane = createQuickNotesPane(failing);
+    const QuickNotesPane = createQuickNotesPane(registryFor(failing));
 
     testSetup = await testRender(
       <QuickNotesHarness QuickNotesPane={QuickNotesPane} />,

package/src/plugins/builtin/notes/quick-notes-pane.tsx

@@ -1,13 +1,12 @@
-import { useCallback, useEffect, useRef, useState } from "react";
-import { Box, Input, Text, type InputRenderable, type TextareaRenderable } from "../../../ui";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Box, Text, type InputRenderable, type TextareaRenderable } from "../../../ui";
 import { useShortcut } from "../../../react/input";
 import type { PaneProps } from "../../../types/plugin";
 import { colors } from "../../../theme/colors";
 import { MarkdownEditor } from "../../../components/markdown-editor";
-import { ConfirmDialog, EmptyState, Tabs, usePaneFooter } from "../../../components";
+import { ConfirmDialog, EmptyState, Tabs, TextField, usePaneFooter } from "../../../components";
 import { type PromptContext, useDialog } from "../../../ui/dialog";
 import { usePluginAppActions } from "../../runtime";
-import type { NotesFiles } from "./files";
 import { MarkdownNotePreview } from "./markdown-note-preview";
 import {
   formatDeleteNoteTitle,
@@ -15,15 +14,36 @@ import {
   generateNoteId,
   type QuickNoteEntry,
 } from "./model";
+import { chooseNoteOwner, ownerColor, ownerLabel, resolveNoteConflict, useNoteTeams } from "./owner";
+import { NoteConflictError, type NoteOwner, noteOwnerKey, type NotesStoreRegistry } from "./store";
 import { useSyncedText } from "./text-state";
 
-export function createQuickNotesPane(notesFiles: NotesFiles) {
+/** A tab in the pane: a quick note plus who owns it. */
+interface OwnedQuickNote extends QuickNoteEntry {
+  owner: NoteOwner;
+}
+
+export function createQuickNotesPane(registry: NotesStoreRegistry) {
   return function QuickNotesPane({ focused, width }: PaneProps) {
     const dialog = useDialog();
     const { notify } = usePluginAppActions();
+    const teams = useNoteTeams();
+    const teamKey = teams.map((team) => team.id).join(",");
+    const owners = useMemo<NoteOwner[]>(
+      () => [{ kind: "user" }, ...teams.map((team) => ({ kind: "team" as const, teamId: team.id }))],
+      // teamKey stands in for the team list identity.
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      [teamKey],
+    );
+    const storeFor = useCallback((owner: NoteOwner) => registry.forOwner(owner), []);
+    const tabOwner = useCallback((tabId: string | null, list: readonly OwnedQuickNote[]): NoteOwner => (
+      list.find((tab) => tab.id === tabId)?.owner ?? { kind: "user" }
+    ), []);
     const textareaRef = useRef<TextareaRenderable | null>(null);
     const [editing, setEditing] = useState(false);
-    const [tabs, setTabs] = useState<QuickNoteEntry[]>([]);
+    const [tabs, setTabs] = useState<OwnedQuickNote[]>([]);
+    const tabsRef = useRef<OwnedQuickNote[]>([]);
+    tabsRef.current = tabs;
     const [activeTabId, setActiveTabId] = useState<string | null>(null);
     const [renaming, setRenaming] = useState(false);
     const [renameValue, setRenameValue] = useState("");
@@ -36,12 +56,25 @@ export function createQuickNotesPane(notesFiles: NotesFiles) {
     const loadedRef = useRef(false);
     const activeTab = tabs.find((tab) => tab.id === activeTabId);
 
-    const saveQuickNotesIndex = useCallback((entries: QuickNoteEntry[]) => {
-      notesFiles.saveQuickNotesIndex(entries).catch((error) => {
-        console.error("[notes] Failed to save notes index:", error);
-        notify({ body: "Failed to save notes index. Check disk space and permissions.", type: "error" });
-      });
-    }, [notesFiles, notify]);
+    const saveQuickNotesIndex = useCallback((entries: OwnedQuickNote[]) => {
+      // Each owner keeps its own index; a title change only touches that store.
+      const byOwner = new Map<string, { owner: NoteOwner; entries: QuickNoteEntry[] }>();
+      for (const entry of entries) {
+        const key = noteOwnerKey(entry.owner);
+        const bucket = byOwner.get(key) ?? { owner: entry.owner, entries: [] };
+        bucket.entries.push({ id: entry.id, title: entry.title, ...(entry.updatedAt ? { updatedAt: entry.updatedAt } : {}) });
+        byOwner.set(key, bucket);
+      }
+      for (const owner of owners) {
+        const bucket = byOwner.get(noteOwnerKey(owner));
+        const store = storeFor(owner);
+        if (store.readOnly) continue;
+        store.saveQuickNotesIndex(bucket?.entries ?? []).catch((error) => {
+          console.error("[notes] Failed to save notes index:", error);
+          notify({ body: error instanceof Error ? error.message : "Failed to save notes index.", type: "error" });
+        });
+      }
+    }, [notify, owners, storeFor]);
 
     const readActiveNoteText = useCallback(() => (
       textareaRef.current?.editBuffer.getText() ?? noteTextRef.current
@@ -63,9 +96,34 @@ export function createQuickNotesPane(notesFiles: NotesFiles) {
       if (lastSavedTextRef.current.get(tabId) === text) return;
 
       lastSavedTextRef.current.set(tabId, text);
-      notesFiles.save(notesFiles.quickNoteKey(tabId), text).catch((error) => {
+      const owner = tabOwner(tabId, tabsRef.current);
+      const store = storeFor(owner);
+      if (store.readOnly) return;
+      const key = store.quickNoteKey(tabId);
+      store.save(key, text).catch(async (error: unknown) => {
+        if (error instanceof NoteConflictError) {
+          lastSavedTextRef.current.delete(tabId);
+          const choice = await resolveNoteConflict(dialog, error);
+          const cloud = registry.cloud(owner);
+          if (choice === "reload") {
+            const theirs = error.current?.content ?? "";
+            if (cloud && error.current) cloud.acceptCurrent(key, error.current);
+            lastSavedTextRef.current.set(tabId, theirs);
+            if (loadedTabIdRef.current === tabId) {
+              setNoteText(theirs);
+              textareaRef.current?.setText(theirs);
+            }
+          } else if (choice === "overwrite") {
+            if (cloud && error.current) cloud.acceptCurrent(key, error.current);
+            lastSavedTextRef.current.set(tabId, text);
+            await store.save(key, text).catch((again: unknown) => {
+              notify({ body: again instanceof Error ? again.message : "Could not save the note.", type: "error" });
+            });
+          }
+          return;
+        }
         console.error("[notes] Failed to save note:", error);
-        notify({ body: "Failed to save note. Check disk space and permissions.", type: "error" });
+        notify({ body: error instanceof Error ? error.message : "Failed to save note.", type: "error" });
       });
 
       const updatedAt = Date.now();
@@ -75,25 +133,43 @@ export function createQuickNotesPane(notesFiles: NotesFiles) {
         saveQuickNotesIndex(next);
         return next;
       });
-    }, [activeTabId, noteTextRef, notesFiles, notify, readActiveNoteText, saveQuickNotesIndex]);
+    }, [activeTabId, dialog, noteTextRef, notify, readActiveNoteText, saveQuickNotesIndex, setNoteText, storeFor, tabOwner]);
 
     useEffect(() => {
-      if (loadedRef.current) return;
-      loadedRef.current = true;
-      notesFiles.loadQuickNotesIndex().then((entries) => {
+      // Mine first, then each team's notes; reloads when the team list changes.
+      let cancelled = false;
+      void Promise.all(owners.map(async (owner) => {
+        try {
+          return (await storeFor(owner).loadQuickNotesIndex()).map((entry) => ({ ...entry, owner }));
+        } catch {
+          return [] as OwnedQuickNote[];
+        }
+      })).then((lists) => {
+        if (cancelled) return;
+        const entries = lists.flat();
         if (entries.length === 0) {
+          if (loadedRef.current) return;
           const id = generateNoteId();
-          const initial: QuickNoteEntry[] = [{ id, title: "New" }];
+          const initial: OwnedQuickNote[] = [{ id, title: "New", owner: { kind: "user" } }];
           lastSavedTextRef.current.set(id, "");
           setTabs(initial);
           setActiveTabId(id);
           saveQuickNotesIndex(initial);
         } else {
-          setTabs(entries);
-          setActiveTabId(entries[0]!.id);
+          setTabs((previous) => {
+            // Keep a tab the person just added locally while the server catches up.
+            const known = new Set(entries.map((entry) => entry.id));
+            const pending = previous.filter((entry) => !known.has(entry.id) && lastSavedTextRef.current.has(entry.id));
+            return [...entries, ...pending];
+          });
+          setActiveTabId((current) => (current && entries.some((entry) => entry.id === current) ? current : entries[0]!.id));
         }
+        loadedRef.current = true;
       });
-    }, [notesFiles, saveQuickNotesIndex]);
+      return () => {
+        cancelled = true;
+      };
+    }, [owners, saveQuickNotesIndex, storeFor]);
 
     useEffect(() => {
       if (!activeTabId) {
@@ -117,14 +193,15 @@ export function createQuickNotesPane(notesFiles: NotesFiles) {
         setNoteText(text);
         textareaRef.current?.setText(text);
       };
-      notesFiles.load(notesFiles.quickNoteKey(activeTabId)).then(applyLoaded, (error: unknown) => {
+      const store = storeFor(tabOwner(activeTabId, tabsRef.current));
+      store.load(store.quickNoteKey(activeTabId)).then(applyLoaded, (error: unknown) => {
         // Leave the tab unloaded so nothing can save over content we failed to read.
         if (!cancelled) setLoadError(error instanceof Error ? error.message : String(error));
       });
       return () => {
         cancelled = true;
       };
-    }, [activeTabId, notesFiles, setNoteText]);
+    }, [activeTabId, setNoteText, storeFor, tabOwner]);
 
     useEffect(() => {
       if (!editing) saveTab(activeTabId);
@@ -134,10 +211,16 @@ export function createQuickNotesPane(notesFiles: NotesFiles) {
       if (!focused && editing) setEditing(false);
     }, [editing, focused]);
 
-    const addTab = useCallback(() => {
+    const addTab = useCallback(async () => {
       saveTab(activeTabId);
+      const owner = await chooseNoteOwner(dialog, teams);
+      if (!owner) return;
+      if (storeFor(owner).readOnly) {
+        notify({ body: `${ownerLabel(owner, teams)} notes are read-only right now.`, type: "info" });
+        return;
+      }
       const id = generateNoteId();
-      const entry: QuickNoteEntry = { id, title: "New" };
+      const entry: OwnedQuickNote = { id, title: "New", owner };
       lastSavedTextRef.current.set(id, "");
       setTabs((prev) => {
         const next = [...prev, entry];
@@ -148,15 +231,16 @@ export function createQuickNotesPane(notesFiles: NotesFiles) {
       setNoteText("");
       setEditing(false);
       setRenaming(false);
-    }, [activeTabId, saveQuickNotesIndex, saveTab, setNoteText]);
+    }, [activeTabId, dialog, notify, saveQuickNotesIndex, saveTab, setNoteText, storeFor, teams]);
 
     const removeTab = useCallback((id: string) => {
       lastSavedTextRef.current.delete(id);
+      const owner = tabOwner(id, tabsRef.current);
       setTabs((prev) => {
         const next = prev.filter((t) => t.id !== id);
         if (next.length === 0) {
           const newId = generateNoteId();
-          const fresh: QuickNoteEntry[] = [{ id: newId, title: "New" }];
+          const fresh: OwnedQuickNote[] = [{ id: newId, title: "New", owner: { kind: "user" } }];
           lastSavedTextRef.current.set(newId, "");
           saveQuickNotesIndex(fresh);
           setActiveTabId(newId);
@@ -174,19 +258,21 @@ export function createQuickNotesPane(notesFiles: NotesFiles) {
         }
         return next;
       });
-      notesFiles.delete(notesFiles.quickNoteKey(id)).catch((error) => {
+      const store = storeFor(owner);
+      store.delete(store.quickNoteKey(id)).catch((error) => {
         console.error("[notes] Failed to delete note:", error);
-        notify({ body: "Failed to delete note. Check disk space and permissions.", type: "error" });
+        notify({ body: error instanceof Error ? error.message : "Failed to delete note.", type: "error" });
       });
       setEditing(false);
       setRenaming(false);
-    }, [activeTabId, notesFiles, notify, saveQuickNotesIndex, setNoteText]);
+    }, [activeTabId, notify, saveQuickNotesIndex, setNoteText, storeFor, tabOwner]);
 
     const requestRemoveTab = useCallback(async (id: string) => {
       const tab = tabs.find((entry) => entry.id === id);
+      const store = storeFor(tab?.owner ?? { kind: "user" });
       const text = id === activeTabId
         ? readActiveNoteText()
-        : await notesFiles.load(notesFiles.quickNoteKey(id));
+        : await store.load(store.quickNoteKey(id));
 
       if (text.trim().length > 0) {
         const confirmed = await dialog.prompt<boolean>({
@@ -211,7 +297,7 @@ export function createQuickNotesPane(notesFiles: NotesFiles) {
       }
 
       removeTab(id);
-    }, [activeTabId, dialog, notesFiles, readActiveNoteText, removeTab, tabs]);
+    }, [activeTabId, dialog, readActiveNoteText, removeTab, storeFor, tabs]);
 
     const startRename = useCallback(() => {
       if (!activeTab) return;
@@ -270,7 +356,7 @@ export function createQuickNotesPane(notesFiles: NotesFiles) {
       }
       if (!editing) {
         if (event.name === "n") {
-          addTab();
+          void addTab();
           return;
         }
         if (event.name === "w" && tabs.length > 0) {
@@ -303,7 +389,7 @@ export function createQuickNotesPane(notesFiles: NotesFiles) {
       hints: editing || renaming
         ? []
         : [
-            { id: "new", key: "n", label: "ew", onPress: addTab },
+            { id: "new", key: "n", label: "ew", onPress: () => { void addTab(); } },
             { id: "title", key: "t", label: "itle", onPress: startRename, disabled: !activeTabId },
           ],
     }), [activeTab, activeTabId, addTab, editing, loadError, renaming, startRename]);
@@ -313,8 +399,9 @@ export function createQuickNotesPane(notesFiles: NotesFiles) {
         <Box height={1}>
           <Tabs
             tabs={tabs.map((tab) => ({
-              label: tab.title,
+              label: tab.owner.kind === "team" ? `${ownerLabel(tab.owner, teams)} ${tab.title}` : tab.title,
               value: tab.id,
+              ...(tab.owner.kind === "team" ? { fg: ownerColor(tab.owner, teams) } : {}),
               onClose: tabs.length > 1 ? (id) => { void requestRemoveTab(id); } : undefined,
               onDoubleClick: startRenameTab,
             }))}
@@ -328,21 +415,22 @@ export function createQuickNotesPane(notesFiles: NotesFiles) {
             compact
             variant="pill"
             closeMode="active"
-            onAdd={addTab}
+            onAdd={() => { void addTab(); }}
             focused={focused && !editing && !renaming}
           />
         </Box>
         {renaming && (
           <Box height={1} flexDirection="row" paddingLeft={1}>
             <Text fg={colors.textDim}>{"Rename: "}</Text>
-            <Input
-              ref={renameInputRef}
-              initialValue={renameValue}
+            <TextField
+              inputRef={renameInputRef}
+              value={renameValue}
               focused={renaming}
               textColor={colors.text}
               backgroundColor={colors.panel}
-              flexGrow={1}
-              onChange={(val: string) => setRenameValue(val)}
+              width={Math.max(1, width - 10)}
+              variant="plain"
+              onChange={setRenameValue}
             />
           </Box>
         )}