gloomberb 0.13.2 → 0.14.0

package/src/plugins/builtin/news/wire/rss/parser.ts

@@ -1,6 +1,7 @@
 import type { MarketNewsItem } from "../../../../../types/news-source";
 import { decodeHtmlEntities } from "../../../../../utils/html-entities";
 import { hashString } from "../hash";
+import { feedChildren, feedText, parseFeedXml, resolveFeedUrl, type FeedElement } from "./feed-xml";
 
 export interface RssFeedConfig {
   id: string;
@@ -24,22 +25,12 @@ function extractText(s: string): string {
   return stripHtml(decodeHtmlEntities(stripCdata(s))).trim();
 }
 
-function getTagContent(xml: string, tag: string): string {
-  const m = xml.match(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)<\\/${tag}>`, "i"));
-  return m ? m[1]!.trim() : "";
-}
-
 function parseDate(s: string): Date {
   if (!s) return new Date(0);
   const d = new Date(s);
   return isNaN(d.getTime()) ? new Date(0) : d;
 }
 
-function extractAttr(tag: string, attr: string): string {
-  const m = tag.match(new RegExp(`${attr}="([^"]*)"`, "i"));
-  return m ? m[1]! : "";
-}
-
 function extractImageUrl(block: string): string | undefined {
   // media:content url="..." (common in RSS 2.0 with media namespace)
   const mediaContent = block.match(/<media:content[^>]+url="([^"]+)"[^>]*(?:medium="image"|type="image\/)/i);
@@ -64,20 +55,24 @@ function extractImageUrl(block: string): string | undefined {
   return undefined;
 }
 
-function parseRss2Items(xml: string, config: RssFeedConfig): MarketNewsItem[] {
-  const itemRe = /<item>([\s\S]*?)<\/item>/gi;
+function parseRssItems(xml: string, config: RssFeedConfig, root: FeedElement): MarketNewsItem[] {
+  const entries = root.localName === "RDF"
+    ? feedChildren(root, "item", "http://purl.org/rss/1.0/")
+    : feedChildren(feedChildren(root, "channel")[0]!, "item");
   const items: MarketNewsItem[] = [];
-  let match: RegExpExecArray | null;
-
-  while ((match = itemRe.exec(xml)) !== null) {
-    const block = match[1]!;
-
-    const title = extractText(getTagContent(block, "title"));
-    const url = extractText(getTagContent(block, "link"));
-    const pubDateRaw = extractText(getTagContent(block, "pubDate"));
-    const descRaw = getTagContent(block, "description");
+  for (const entry of entries) {
+    const block = xml.slice(entry.innerStart, entry.innerEnd);
+    const tagContent = (name: string) => {
+      const node = feedChildren(entry, name)[0];
+      return node ? xml.slice(node.innerStart, node.innerEnd) : "";
+    };
+
+    const title = extractText(tagContent("title"));
+    const url = extractText(tagContent("link"));
+    const pubDateRaw = extractText(tagContent("pubDate"));
+    const descRaw = tagContent("description");
     const desc = descRaw ? extractText(descRaw) : undefined;
-    const categoryRaw = getTagContent(block, "category");
+    const categoryRaw = tagContent("category");
     const category = categoryRaw ? extractText(categoryRaw) : undefined;
 
     if (!title && !url) continue;
@@ -120,84 +115,63 @@ function parseRss2Items(xml: string, config: RssFeedConfig): MarketNewsItem[] {
   return items;
 }
 
-function parseAtomEntries(xml: string, config: RssFeedConfig): MarketNewsItem[] {
-  const entryRe = /<entry>([\s\S]*?)<\/entry>/gi;
-  const items: MarketNewsItem[] = [];
-  let match: RegExpExecArray | null;
-
-  while ((match = entryRe.exec(xml)) !== null) {
-    const block = match[1]!;
-
-    const title = extractText(getTagContent(block, "title"));
-
-    // Atom <link href="..."/> or <link>...</link>
-    const linkTagMatch = block.match(/<link([^>]*)>/i);
-    let url = "";
-    if (linkTagMatch) {
-      const href = extractAttr(linkTagMatch[0]!, "href");
-      if (href) {
-        url = href;
-      } else {
-        url = extractText(getTagContent(block, "link"));
-      }
-    }
-
-    const publishedRaw =
-      extractText(getTagContent(block, "published")) ||
-      extractText(getTagContent(block, "updated"));
-
-    const summaryRaw = getTagContent(block, "summary") || getTagContent(block, "content");
-    const summaryFull = summaryRaw ? extractText(summaryRaw) : undefined;
-    const summary = summaryFull
-      ? summaryFull.slice(0, 300) + (summaryFull.length > 300 ? "…" : "")
-      : undefined;
-
-    if (!title && !url) continue;
-
-    const id = hashString(`${url}|${title}`);
-    const publishedAt = parseDate(publishedRaw);
+function parseAtomEntries(xml: string, config: RssFeedConfig, root: FeedElement): MarketNewsItem[] {
+  return feedChildren(root, "entry").flatMap((entry): MarketNewsItem[] => {
+    const text = (name: string) => feedText(feedChildren(entry, name)[0]);
+    const construct = (name: string) => {
+      const node = feedChildren(entry, name)[0];
+      const value = feedText(node);
+      // Atom's default text construct contains literal text. Only HTML text
+      // constructs use escaped markup; XHTML has already been read as elements.
+      return node?.attributes.type === "html" ? decodeHtmlEntities(stripHtml(value)).trim() : value;
+    };
+    const title = construct("title");
+    const links = feedChildren(entry, "link")
+      .filter((link) => !link.attributes.rel || link.attributes.rel === "alternate"
+        || link.attributes.rel === "http://www.iana.org/assignments/relation/alternate")
+      .map((link) => ({
+        url: resolveFeedUrl(link.attributes.href ?? "", link.base),
+        type: (link.attributes.type ?? "").split(";")[0]!.trim().toLowerCase(),
+      }))
+      .filter((link) => /^https?:\/\//i.test(link.url));
+    const url = (links.find((link) => link.type === "text/html" || link.type === "application/xhtml+xml")
+      ?? links.find((link) => !link.type) ?? links[0])?.url ?? "";
+    if (!title && !url) return [];
+    const summaryFull = construct("summary") || construct("content");
+    const summary = summaryFull ? summaryFull.slice(0, 300) + (summaryFull.length > 300 ? "…" : "") : undefined;
+    // An Atom id survives headline/URL corrections. Do not normalize its case,
+    // resolve it as a relative URL, or replace it with the presentation link.
+    const publisherId = text("id");
+    const id = publisherId ? `atom:${publisherId}` : hashString(`${url}|${title}`);
+    const publishedAt = parseDate(text("updated") || text("published"));
     const categories = config.category ? [config.category] : [];
-    const imageUrl = extractImageUrl(block);
+    const imageUrl = extractImageUrl(xml.slice(entry.innerStart, entry.innerEnd));
+    return [{
+      id, title, url, source: config.name, publishedAt, summary, imageUrl,
+      topic: categories[0] ?? "general", topics: categories, sectors: [], categories, tickers: [],
+      scores: { importance: 0, urgency: 0, marketImpact: 0, novelty: 0, confidence: 0 },
+      importance: 0, isBreaking: false, isDeveloping: false,
+    }];
+  });
+}
 
-    items.push({
-      id,
-      title,
-      url,
-      source: config.name,
-      publishedAt,
-      summary,
-      imageUrl,
-      topic: categories[0] ?? "general",
-      topics: categories,
-      sectors: [],
-      categories,
-      tickers: [],
-      scores: {
-        importance: 0,
-        urgency: 0,
-        marketImpact: 0,
-        novelty: 0,
-        confidence: 0,
-      },
-      importance: 0,
-      isBreaking: false,
-      isDeveloping: false,
-    });
+// The source uses this strict entry point so a proxy error page or truncated
+// document cannot replace the last successful feed with a fresh empty cache.
+export function parseRssFeedDocument(xml: string, config: RssFeedConfig): MarketNewsItem[] {
+  const root = parseFeedXml(xml, config.url);
+  if (root?.localName === "feed" && (!root.namespace || root.namespace === "http://www.w3.org/2005/Atom")) {
+    return parseAtomEntries(xml, config, root);
   }
-
-  return items;
+  if (root?.localName === "rss" && !root.namespace && feedChildren(root, "channel").length === 1) {
+    return parseRssItems(xml, config, root);
+  }
+  if (root?.localName === "RDF" && root.namespace === "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+    && feedChildren(root, "channel", "http://purl.org/rss/1.0/").length === 1) {
+    return parseRssItems(xml, config, root);
+  }
+  throw new Error("Invalid or unsupported news feed.");
 }
 
 export function parseRssFeed(xml: string, config: RssFeedConfig): MarketNewsItem[] {
-  if (!xml || !xml.trim()) return [];
-
-  try {
-    const isAtom = /<feed\b/i.test(xml);
-    if (isAtom) {
-      return parseAtomEntries(xml, config);
-    }
-    return parseRss2Items(xml, config);
-  } catch {
-    return [];
-  }
+  try { return parseRssFeedDocument(xml, config); } catch { return []; }
 }

package/src/plugins/builtin/news/wire/rss/source.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, mock, test } from "bun:test";
 import { MemoryPluginPersistence as MemoryPersistence } from "../../../../../test-support/plugin-persistence";
-import { createRssNewsCapability, RSS_FEED_CACHE_POLICY } from "./source";
+import { createRssNewsCapability, RSS_FEED_CACHE_POLICY, RSS_FEED_CACHE_VERSION } from "./source";
 import type { RssFeedConfig } from "./parser";
 
 const FEED: RssFeedConfig = {
@@ -72,6 +72,7 @@ describe("createRssNewsCapability", () => {
       }],
     }, {
       sourceKey: FEED.url,
+      schemaVersion: RSS_FEED_CACHE_VERSION,
       cachePolicy: RSS_FEED_CACHE_POLICY,
     });
 
@@ -98,6 +99,7 @@ describe("createRssNewsCapability", () => {
       }],
     }, {
       sourceKey: FEED.url,
+      schemaVersion: RSS_FEED_CACHE_VERSION,
       cachePolicy: stalePolicy,
     });
 
@@ -114,3 +116,38 @@ describe("createRssNewsCapability", () => {
     expect(items[0]!.title).toBe("Stale headline");
   });
 });
+
+test("partial feed failure preserves successful and stale articles, reports the gap, and recovers", async () => {
+  const persistence = new MemoryPersistence();
+  const other = { ...FEED, id: "other", url: "https://other.example.com/rss" };
+  let broken = false;
+  const source = createRssNewsCapability([FEED, other], { persistence, fetchText: async (url) => ({
+    ok: true,
+    text: async () => broken && url === FEED.url ? "<html><body>Proxy error</body></html>" : RSS_FIXTURE.replace("nvda</link>", `${url === FEED.url ? "nvda" : "other"}</link>`),
+  }) });
+  await source.provider.fetchNewsPage!({ feed: "latest" });
+  const cached = persistence.getResource<{ items: unknown[] }>("rss-feed", FEED.id, { sourceKey: FEED.url })!;
+  persistence.seedResource("rss-feed", FEED.id, cached.value, { sourceKey: FEED.url, schemaVersion: RSS_FEED_CACHE_VERSION, stale: true });
+  broken = true;
+  const failed = await source.provider.fetchNewsPage!({ feed: "latest" });
+  expect(failed.articles).toHaveLength(2);
+  expect(failed.error).toBe("1 of 2 RSS feeds unavailable.");
+  expect(persistence.getResource("rss-feed", FEED.id, { sourceKey: FEED.url })!.stale).toBe(true);
+  broken = false;
+  expect((await source.provider.fetchNewsPage!({ feed: "latest" })).error).toBeNull();
+  expect(persistence.getResource("rss-feed", FEED.id, { sourceKey: FEED.url })!.stale).toBe(false);
+});
+
+test("legacy parser cache is refetched and valid empty feeds are cached without claiming pagination", async () => {
+  const persistence = new MemoryPersistence();
+  persistence.setResource("rss-feed", FEED.id, { items: [{ id: "old", title: "Old self link", url: "https://example.com/api", source: FEED.name, publishedAt: new Date().toISOString() }] }, { sourceKey: FEED.url, cachePolicy: RSS_FEED_CACHE_POLICY });
+  const fetchText = mock(async () => ({ ok: true, text: async () => '<feed xmlns="http://www.w3.org/2005/Atom"/>' }));
+  const source = createRssNewsCapability([FEED], { persistence, fetchText });
+  expect(source.provider.getCachedNews!({ feed: "latest" })).toEqual([]);
+  expect((await source.provider.fetchNewsPage!({ feed: "latest" })).articles).toEqual([]);
+  expect((await source.provider.fetchNewsPage!({ feed: "latest" })).error).toBeNull();
+  expect(fetchText).toHaveBeenCalledTimes(1);
+  expect(source.provider.supports!({ feed: "latest", cursor: "next" })).toBe(false);
+  expect((await source.provider.fetchNewsPage!({ feed: "latest", cursor: "next" })).articles).toEqual([]);
+  expect(fetchText).toHaveBeenCalledTimes(1);
+});

package/src/plugins/builtin/news/wire/rss/source.ts

@@ -2,10 +2,11 @@ import { createThrottledFetch } from "../../../../../utils/throttled-fetch";
 import { newsProvider, type NewsCapability } from "../../../../../capabilities";
 import type { NewsQuery, MarketNewsItem } from "../../../../../types/news-source";
 import type { PluginPersistence } from "../../../../../types/plugin";
-import { parseRssFeed, type RssFeedConfig } from "./parser";
+import { parseRssFeedDocument, type RssFeedConfig } from "./parser";
 import { enrichNewsItem } from "../categories";
 
 const RSS_CACHE_KIND = "rss-feed";
+export const RSS_FEED_CACHE_VERSION = 2;
 export const RSS_FEED_CACHE_POLICY = {
   staleMs: 2 * 60 * 1000,
   expireMs: 7 * 24 * 60 * 60 * 1000,
@@ -37,7 +38,7 @@ export interface RssNewsCapabilityOptions {
 
 function supportsQuery(query: NewsQuery): boolean {
   const feed = query.feed ?? (query.scope === "ticker" ? "ticker" : "latest");
-  return feed === "latest";
+  return feed === "latest" && !query.cursor;
 }
 
 function serializeItem(item: MarketNewsItem): CachedNewsItem {
@@ -100,6 +101,7 @@ function readFeedCache(
 ): MarketNewsItem[] | null {
   const cached = persistence?.getResource<CachedFeedPayload>(RSS_CACHE_KIND, feed.id, {
     sourceKey: feed.url,
+    schemaVersion: RSS_FEED_CACHE_VERSION,
     allowExpired: options?.allowExpired,
   });
   if (cached?.stale && !options?.allowStale && !options?.allowExpired) return null;
@@ -107,7 +109,7 @@ function readFeedCache(
   const items = cached.value.items
     .map(deserializeItem)
     .filter((item): item is MarketNewsItem => !!item);
-  return items.length > 0 ? items : null;
+  return items.length === cached.value.items.length ? items : null;
 }
 
 function writeFeedCache(
@@ -120,6 +122,7 @@ function writeFeedCache(
     items: items.map(serializeItem),
   }, {
     sourceKey: feed.url,
+    schemaVersion: RSS_FEED_CACHE_VERSION,
     cachePolicy: RSS_FEED_CACHE_POLICY,
     provenance: { url: feed.url, name: feed.name },
   });
@@ -132,23 +135,33 @@ export function createRssNewsCapability(
   const fetchText = options.fetchText ?? ((url: string) => rssClient.fetch(url));
   const getFeeds = () => Array.isArray(feedsOrGetter) ? feedsOrGetter : feedsOrGetter();
 
-  async function fetchFeed(feed: RssFeedConfig): Promise<MarketNewsItem[]> {
+  async function fetchFeed(feed: RssFeedConfig): Promise<{ articles: MarketNewsItem[]; failed: boolean }> {
     const freshCache = readFeedCache(options.persistence, feed);
-    if (freshCache) return freshCache;
+    if (freshCache) return { articles: freshCache, failed: false };
 
     try {
       const resp = await fetchText(feed.url);
-      if (!resp.ok) return readFeedCache(options.persistence, feed, { allowExpired: true }) ?? [];
-      const xml = await resp.text();
-      const items = parseRssFeed(xml, feed)
+      if (!resp.ok) throw new Error("Feed request failed.");
+      const articles = parseRssFeedDocument(await resp.text(), feed)
         .map((item) => enrichNewsItem(item, feed.authority, options.knownTickers));
-      writeFeedCache(options.persistence, feed, items);
-      return items;
+      writeFeedCache(options.persistence, feed, articles);
+      return { articles, failed: false };
     } catch {
-      return readFeedCache(options.persistence, feed, { allowExpired: true }) ?? [];
+      return { articles: readFeedCache(options.persistence, feed, { allowExpired: true }) ?? [], failed: true };
     }
   }
 
+  async function fetchPage(query: NewsQuery) {
+    if (!supportsQuery(query)) return { articles: [] };
+    const feeds = getFeeds().filter((feed) => feed.enabled);
+    const results = await Promise.all(feeds.map(fetchFeed));
+    const failed = results.filter((result) => result.failed).length;
+    return {
+      articles: results.flatMap((result) => result.articles),
+      error: failed ? `${failed} of ${feeds.length} RSS feeds unavailable.` : null,
+    };
+  }
+
   return newsProvider({
     id: "rss",
     name: "RSS Feeds",
@@ -160,21 +173,9 @@ export function createRssNewsCapability(
         const enabledFeeds = getFeeds().filter((feed) => feed.enabled);
         return enabledFeeds.flatMap((feed) => readFeedCache(options.persistence, feed, { allowExpired: true }) ?? []);
       },
+      fetchNewsPage: fetchPage,
       async fetchNews(query: NewsQuery): Promise<MarketNewsItem[]> {
-        if (!supportsQuery(query)) return [];
-        const enabledFeeds = getFeeds().filter((f) => f.enabled);
-        const results = await Promise.allSettled(
-          enabledFeeds.map(fetchFeed),
-        );
-
-        const allItems: MarketNewsItem[] = [];
-        for (const result of results) {
-          if (result.status === "fulfilled") {
-            allItems.push(...result.value);
-          }
-        }
-
-        return allItems;
+        return (await fetchPage(query)).articles;
       },
     },
   });

package/src/plugins/builtin/notes/export.ts

@@ -0,0 +1,57 @@
+import type { NoteFileEntry, QuickNoteEntry } from "./files";
+import type { NotesStore } from "./store";
+import { noteOwnerKey, splitNoteKey } from "./store";
+
+export interface NotesExportSource {
+  label: string;
+  store: NotesStore;
+}
+
+export interface NotesExportResult {
+  dir: string;
+  files: number;
+}
+
+function safeFileName(value: string): string {
+  return value.replace(/[^A-Za-z0-9._-]+/g, "_").replace(/^_+|_+$/g, "") || "note";
+}
+
+/**
+ * Writes every note as Markdown: ticker notes as `<SYMBOL>.md`, quick notes
+ * under `quick/<title>.md`, one folder per owner when there are teams. The
+ * disk store's own files are what they already are; the export is for the
+ * cloud copies so nothing is locked in.
+ */
+export async function exportNotesToDirectory(
+  dir: string,
+  sources: readonly NotesExportSource[],
+): Promise<NotesExportResult> {
+  const fsModulePath = "fs/promises";
+  const { mkdir, writeFile } = await import(fsModulePath) as typeof import("fs/promises");
+  let files = 0;
+  for (const source of sources) {
+    const folder = sources.length > 1 ? `${dir}/${safeFileName(source.label)}` : dir;
+    let entries: NoteFileEntry[];
+    let quick: QuickNoteEntry[];
+    try {
+      [entries, quick] = await Promise.all([source.store.list(), source.store.loadQuickNotesIndex()]);
+    } catch {
+      continue;
+    }
+    const titles = new Map(quick.map((entry) => [entry.id, entry.title]));
+    for (const entry of entries) {
+      const { kind, key } = splitNoteKey(entry.key);
+      const path = kind === "quick"
+        ? `${folder}/quick/${safeFileName(titles.get(key) ?? key)}.md`
+        : `${folder}/${safeFileName(key)}.md`;
+      await mkdir(path.slice(0, path.lastIndexOf("/")), { recursive: true });
+      await writeFile(path, entry.text, "utf-8");
+      files += 1;
+    }
+  }
+  return { dir, files };
+}
+
+export function exportSourceLabel(store: NotesStore, teamName?: string): string {
+  return store.owner.kind === "user" ? "mine" : (teamName ?? noteOwnerKey(store.owner));
+}

package/src/plugins/builtin/notes/files.ts

@@ -1,3 +1,5 @@
+import type { NoteOwner, NotesStore } from "./store";
+
 export interface QuickNoteEntry {
   id: string;
   title: string;
@@ -81,7 +83,10 @@ async function deleteTextFile(path: string): Promise<void> {
   writeLocalTimestamp(path, null);
 }
 
-export class NotesFiles {
+export class NotesFiles implements NotesStore {
+  readonly readOnly = false;
+  readonly owner: NoteOwner = { kind: "user" };
+
   constructor(private readonly dataDir: string) {}
 
   private pathFor(symbol: string): string {

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

@@ -1,30 +1,73 @@
+import { apiClient } from "../../../api-client";
 import type { GloomPlugin } from "../../../types/plugin";
+import { teamStore } from "../cloud/team/store";
+import { exportNotesToDirectory, exportSourceLabel } from "./export";
 import { NotesFiles } from "./files";
+import { migrateLocalNotes, notesMigratedAt } from "./migration";
 import { createQuickNotesPane } from "./quick-notes-pane";
-import { createNotesSyncContributor } from "./sync";
+import { NotesStoreRegistry } from "./store";
 import { createNotesTab } from "./ticker-notes-tab";
 
+let disposeNotes: (() => void) | null = null;
+
 export const notesPlugin: GloomPlugin = {
   id: "notes",
   name: "Notes",
-  version: "1.0.0",
-  description: "Add markdown notes to your tickers.",
+  version: "2.0.0",
+  description: "Markdown notes on tickers and on their own, personal or shared with a team.",
   toggleable: true,
 
   setup(ctx) {
-    const notesFiles = new NotesFiles(ctx.getConfig().dataDir);
-    const NotesTab = createNotesTab(notesFiles);
-    const QuickNotesPane = createQuickNotesPane(notesFiles);
+    const dataDir = ctx.getConfig().dataDir;
+    const notesFiles = new NotesFiles(dataDir);
+    const registry = new NotesStoreRegistry({
+      persistence: ctx.persistence,
+      files: notesFiles,
+      isSignedIn: () => apiClient.isVerified(),
+    });
+    const NotesTab = createNotesTab(registry);
+    const QuickNotesPane = createQuickNotesPane(registry);
+    let migrating = false;
+
+    // First signed-in launch: the .md files on disk go up, then stay on disk
+    // as the export format. Older cloud copies never overwrite newer files.
+    const migrate = async () => {
+      if (migrating || !apiClient.isVerified() || notesMigratedAt(ctx.persistence)) return;
+      const cloud = registry.cloud({ kind: "user" });
+      if (!cloud) return;
+      migrating = true;
+      try {
+        const result = await migrateLocalNotes(notesFiles, cloud, ctx.persistence);
+        if (result && result.uploaded > 0) {
+          ctx.notify({
+            body: `${result.uploaded} local ${result.uploaded === 1 ? "note" : "notes"} imported to Gloom Cloud. The files stay on disk.`,
+            type: "success",
+          });
+        }
+      } catch (error) {
+        console.error("[notes] Local note import failed:", error);
+      } finally {
+        migrating = false;
+      }
+    };
+    void migrate();
+    const disposers = [
+      apiClient.subscribeCurrentUser(() => {
+        registry.invalidateAll();
+        void migrate();
+      }),
+      // A teammate's edit invalidates the cached copy so the next open is fresh.
+      apiClient.subscribeCloudEvent("note.updated", () => registry.invalidateAll()),
+      apiClient.subscribeCloudEvent("note.deleted", () => registry.invalidateAll()),
+    ];
 
     ctx.on("ticker:removed", ({ symbol }) => {
-      notesFiles.delete(symbol).catch((error) => {
+      registry.personal().delete(symbol).catch((error) => {
         console.error("[notes] Failed to delete ticker note:", error);
-        ctx.notify({ body: "Failed to delete note. Check disk space and permissions.", type: "error" });
+        ctx.notify({ body: "Failed to delete note.", type: "error" });
       });
     });
 
-    ctx.registerSyncContributor(createNotesSyncContributor(notesFiles));
-
     ctx.registerTickerResearchTab({
       id: "notes",
       name: "Notes",
@@ -51,5 +94,37 @@ export const notesPlugin: GloomPlugin = {
       shortcut: { prefix: "NOTE" },
       createInstance: () => ({ placement: "floating" }),
     });
+
+    ctx.registerCommand({
+      id: "notes-export",
+      label: "Export Notes",
+      description: "Write every note, yours and your teams', as Markdown files",
+      keywords: ["notes", "export", "markdown", "backup"],
+      category: "data",
+      execute: async () => {
+        const stamp = new Date().toISOString().slice(0, 10);
+        const dir = `${dataDir}/notes-export-${stamp}`;
+        const teams = teamStore.getSnapshot().teams;
+        const sources = [
+          { label: exportSourceLabel(registry.personal()), store: registry.personal() },
+          ...teams.map((team) => ({ label: exportSourceLabel(registry.forOwner({ kind: "team", teamId: team.id }), team.name), store: registry.forOwner({ kind: "team", teamId: team.id }) })),
+        ];
+        try {
+          const result = await exportNotesToDirectory(dir, sources);
+          ctx.notify({ body: `Exported ${result.files} ${result.files === 1 ? "note" : "notes"} to ${result.dir}`, type: "success" });
+        } catch (error) {
+          ctx.notify({ body: error instanceof Error ? error.message : "Could not export notes.", type: "error" });
+        }
+      },
+    });
+
+    disposeNotes = () => {
+      for (const dispose of disposers) dispose();
+    };
+  },
+
+  dispose() {
+    disposeNotes?.();
+    disposeNotes = null;
   },
 };

package/src/plugins/builtin/notes/migration.ts

@@ -0,0 +1,80 @@
+import { ApiRequestError } from "../../../api-client/errors";
+import type { PluginPersistence } from "../../../types/plugin";
+import type { NotesFiles } from "./files";
+import type { CloudNotesStore } from "./store";
+
+const MIGRATED_AT_KEY = "notes:migratedAt";
+
+export interface NotesMigrationResult {
+  uploaded: number;
+  skipped: number;
+  /** Keys the server refused; they stay on disk. */
+  rejected: string[];
+}
+
+export function notesMigratedAt(persistence: PluginPersistence | null): string | null {
+  return persistence?.getState<string>(MIGRATED_AT_KEY) ?? null;
+}
+
+/**
+ * First signed-in launch: every `.md` on disk goes up unless the cloud
+ * already holds a newer copy. Files stay where they are; they are the export
+ * format now. Idempotent through the migratedAt stamp, and a partial failure
+ * leaves the stamp unset so the next launch retries.
+ */
+export async function migrateLocalNotes(
+  files: NotesFiles,
+  cloud: CloudNotesStore,
+  persistence: PluginPersistence | null,
+): Promise<NotesMigrationResult | null> {
+  if (notesMigratedAt(persistence)) return null;
+  const local = await files.list();
+  const quickIndex = await files.loadQuickNotesIndex();
+  const titles = new Map(quickIndex.map((entry) => [files.quickNoteKey(entry.id), entry.title]));
+  const remote = new Map((await cloud.list()).map((entry) => [entry.key, entry]));
+
+  let uploaded = 0;
+  let skipped = 0;
+  const rejected: string[] = [];
+  // A key the server refuses (400) will be refused next launch too, so it is
+  // logged once and does not block the stamp; anything else (network, auth)
+  // rethrows so the whole import retries later.
+  const save = async (key: string, text: string, title: string | null) => {
+    try {
+      await cloud.save(key, text, { title });
+      uploaded += 1;
+    } catch (error) {
+      if (error instanceof ApiRequestError && error.status === 400) {
+        rejected.push(key);
+        return;
+      }
+      throw error;
+    }
+  };
+  for (const entry of local) {
+    const existing = remote.get(entry.key);
+    const title = titles.get(entry.key) ?? null;
+    // Empty files are placeholders the notes pane left behind; nothing to import.
+    if (!entry.text.trim() && !title) {
+      skipped += 1;
+      continue;
+    }
+    if (existing && (existing.updatedAt >= entry.updatedAt || existing.text === entry.text)) {
+      skipped += 1;
+      continue;
+    }
+    if (existing) cloud.forgetRevision(entry.key);
+    await save(entry.key, entry.text, title);
+  }
+  // Quick note tabs that exist in the index but have no body yet still get a title.
+  for (const entry of quickIndex) {
+    const key = files.quickNoteKey(entry.id);
+    if (local.some((note) => note.key === key) || remote.has(key)) continue;
+    await save(key, "", entry.title);
+  }
+  if (rejected.length > 0) {
+    console.warn(`[notes] ${rejected.length} local note(s) were not accepted by Gloom Cloud and stay local: ${rejected.join(", ")}`);
+  }
+  persistence?.setState(MIGRATED_AT_KEY, new Date().toISOString());
+  return { uploaded, skipped, rejected };
+}