gloomberb 0.15.2 → 0.15.4

package/src/plugins/builtin/news/wire/news/table.tsx

@@ -2,7 +2,6 @@ import { useCallback, useEffect, useMemo, type ReactNode, type RefObject } from
 import { TextAttributes, type ScrollBoxRenderable } from "../../../../../ui";
 import {
   DataTableStackView,
-  PaneStatusBody,
   TickerBadgeList,
   sortStackItems,
   usePaneFooter,
@@ -15,7 +14,8 @@ import type { MarketNewsItem } from "../../../../../types/news-source";
 import { colors } from "../../../../../theme/colors";
 import { collectNewsDisplayTickers } from "../../../../../news/ticker-symbols";
 import { useLoadNewsStory } from "../../../../../news/hooks";
-import { formatRelativeTime } from "../../../../../utils/datetime-format";
+import { formatFeedTime } from "../../../../../utils/datetime-format";
+import { nextHeaderSort } from "../../../../../utils/sort-values";
 import { formatNewsCategory } from "../categories";
 import { useOpenTickerChoice } from "../../../shared/ticker-choice";
 
@@ -47,37 +47,6 @@ function fitTickerSymbols(symbols: string[], width: number): string[] {
   return fitted;
 }
 
-/**
- * Body for a table with no rows yet: loading while the query is in flight, the
- * failure when the sources errored, and the empty state otherwise. Always own
- * the body rather than falling back to the table's built-in empty state, whose
- * desktop markup runs the title and the hint together on one line.
- */
-export function newsTableStatusContent({
-  loading,
-  error,
-  subject,
-  emptyTitle,
-  emptyMessage,
-}: {
-  loading: boolean;
-  error?: string | null;
-  subject: string;
-  emptyTitle: string;
-  emptyMessage?: string;
-}): ReactNode {
-  return (
-    <PaneStatusBody
-      loading={loading}
-      error={error}
-      empty
-      subject={subject}
-      emptyTitle={emptyTitle}
-      emptyMessage={emptyMessage}
-    />
-  );
-}
-
 export type NewsSortPreference = StackSortPreference<NewsColumnId>;
 
 type NewsTableColumn = DataTableColumn & { id: NewsColumnId };
@@ -141,26 +110,12 @@ function sortNewsArticles(
   );
 }
 
-function nextSortPreference(current: NewsSortPreference, columnId: NewsColumnId): NewsSortPreference {
-  if (current.columnId === columnId) {
-    return {
-      columnId,
-      direction: current.direction === "asc" ? "desc" : "asc",
-    };
-  }
-  return {
-    columnId,
-    direction: columnId === "title" || columnId === "source" || columnId === "categories"
-      ? "asc"
-      : "desc",
-  };
-}
-
 const FIXED_COLUMN_WIDTHS: Record<Exclude<NewsColumnId, "title">, number> = {
   rank: 4,
-  // The label and its sort mark.
-  time: 6,
-  source: 12,
+  // "Mon 09:10", or "Sep 18, 25" for a story from another year.
+  time: 10,
+  // Publishers and X handles: "GlobeNewswire", "@unusual_whales".
+  source: 15,
   tickers: 18,
   categories: 10,
   sentiment: 4,
@@ -324,20 +279,19 @@ export function NewsArticleStackView({
     index: number,
     rowState: { selected: boolean },
   ): DataTableCell => {
-    const selectedColor = rowState.selected ? colors.selectedText : undefined;
     switch (column.id) {
       case "rank":
-        return { text: String(index + 1), color: selectedColor ?? colors.textDim };
+        return { text: String(index + 1), color: colors.textDim };
       case "time":
-        return { text: formatRelativeTime(item.publishedAt), color: selectedColor ?? colors.textDim };
+        return { text: formatFeedTime(item.publishedAt), value: item.publishedAt, color: colors.textDim };
       case "source":
-        return { text: item.source, color: selectedColor ?? colors.textMuted };
+        return { text: item.source, color: colors.textMuted };
       case "title":
         return {
           // Unclipped: the table fits it to the width the column really gets,
           // which on desktop is wider than the width it was laid out at.
           text: titleForArticle?.(item) ?? item.title,
-          color: selectedColor ?? colors.text,
+          color: colors.text,
           attributes: readArticleIds?.has(item.id)
             ? TextAttributes.NONE
             : TextAttributes.BOLD,
@@ -350,22 +304,22 @@ export function NewsArticleStackView({
             <TickerBadgeList
               symbols={tickers}
               width={column.width}
-              fallbackColor={selectedColor ?? colors.textBright}
+              fallbackColor={rowState.selected ? colors.selectedText : colors.textBright}
             />
           ),
-          color: selectedColor ?? colors.textBright,
+          color: colors.textBright,
         };
       }
       case "categories":
         return {
           text: formatNewsCategory(item.categories[0]) || "-",
-          color: selectedColor ?? colors.textDim,
+          color: colors.textDim,
         };
       case "sentiment": {
         const sentiment = item.sentiment;
         return {
           text: sentiment ? sentiment.slice(0, 3) : "-",
-          color: selectedColor ?? (
+          color: (
             sentiment === "positive"
               ? colors.positive
               : sentiment === "negative"
@@ -377,7 +331,7 @@ export function NewsArticleStackView({
       case "importance":
         return {
           text: String(item.importance),
-          color: selectedColor ?? (item.importance >= 80 ? colors.positive : colors.textDim),
+          color: item.importance >= 80 ? colors.positive : colors.textDim,
         };
     }
   }, [readArticleIds, titleForArticle]);
@@ -404,9 +358,12 @@ export function NewsArticleStackView({
       items={sortedArticles}
       sortColumnId={sortPreference.columnId}
       sortDirection={sortPreference.direction}
-      onHeaderClick={(columnId) => setSortPreference(nextSortPreference(sortPreference, columnId as NewsColumnId))}
+      onHeaderClick={(columnId) => setSortPreference(nextHeaderSort(sortPreference, columnId as NewsColumnId, {
+        firstDirection: columnId === "title" || columnId === "source" || columnId === "categories" ? "asc" : "desc",
+      }))}
       getItemKey={(item) => item.id}
       renderCell={renderCell}
+      selectedTextOverridesCellColor
       emptyContent={emptyContent}
       emptyStateTitle={emptyStateTitle}
       emptyStateHint={emptyStateHint}

package/src/plugins/builtin/news/wire/read-state.ts

@@ -1,37 +1,23 @@
 import {
   DEFAULT_MAX_READ_IDS,
-  markPersistedReadId,
-  normalizePersistedReadIdState,
   usePersistedReadIds,
   type PersistedReadIdAdapter,
-} from "../../shared/read-state";
+} from "../../../../react/read-state";
 
-export interface NewsReadState {
+interface NewsReadState {
   articleIds: string[];
 }
 
 const NEWS_READ_STATE_SCHEMA_VERSION = 1;
-export const MAX_READ_ARTICLE_IDS = DEFAULT_MAX_READ_IDS;
 
 const READ_STATE_KEY = "read-articles";
 const EMPTY_READ_STATE: NewsReadState = { articleIds: [] };
 const NEWS_READ_STATE_ADAPTER: PersistedReadIdAdapter<NewsReadState> = {
   getIds: (state) => state.articleIds,
   withIds: (_state, articleIds) => ({ articleIds }),
-  maxIds: MAX_READ_ARTICLE_IDS,
+  maxIds: DEFAULT_MAX_READ_IDS,
 };
 
-export function normalizeNewsReadState(state: NewsReadState): NewsReadState {
-  return normalizePersistedReadIdState(state, NEWS_READ_STATE_ADAPTER);
-}
-
-export function markNewsArticleRead(
-  state: NewsReadState,
-  articleId: string,
-): NewsReadState {
-  return markPersistedReadId(state, articleId, NEWS_READ_STATE_ADAPTER);
-}
-
 export function useNewsReadState() {
   const { readIds, markRead } = usePersistedReadIds({
     key: READ_STATE_KEY,

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

@@ -0,0 +1,47 @@
+import { CLI_COMMAND_GROUPS } from "../../../../../cli/help";
+import { requireArg, takeOption } from "../../../../../cli/commands/command-utils";
+import type { CliCommandDef } from "../../../../../types/plugin";
+import { createRssNewsCapability } from "./source";
+
+export const rssCliCommand: CliCommandDef = {
+  name: "rss",
+  description: "Read any RSS or Atom feed as headlines",
+  help: {
+    group: CLI_COMMAND_GROUPS.markets,
+    usage: ["rss fetch <url> [--name <label>]"],
+    options: [{ flags: "--name <label>", description: "Source name shown on each row (default RSS)" }],
+    examples: ["rss fetch https://feeds.a.dj.com/rss/RSSMarketsMain.xml --limit 10"],
+  },
+  execute: async (args, ctx) => {
+    const action = args[0] ?? "fetch";
+    if (action !== "fetch") ctx.fail("Usage: gloomberb rss fetch <url> [--name <label>]");
+    const rawArgs = args.slice(1);
+    const name = takeOption(rawArgs, "--name") ?? "RSS";
+    const url = requireArg(rawArgs[0], "Usage: gloomberb rss fetch <url> [--name <label>]", ctx);
+    const capability = createRssNewsCapability([{
+      id: "cli-feed",
+      url,
+      name,
+      category: "cli",
+      authority: 50,
+      enabled: true,
+    }]);
+    const articles = await capability.provider.fetchNews({ feed: "latest", limit: ctx.cliOptions.limit ?? 20 });
+    ctx.printResult({ data: articles.map((article) => ({
+      title: article.title,
+      source: article.source,
+      publishedAt: article.publishedAt.toISOString(),
+      url: article.url,
+      summary: article.summary ?? "",
+    })) }, {
+      textColumns: [
+        { key: "publishedAt", header: "Published" },
+        { key: "source", header: "Source", maxWidth: 20 },
+        { key: "title", header: "Title" },
+        { key: "url", header: "URL", optional: true },
+        { key: "summary", header: "Summary", optional: true },
+      ],
+      empty: "The feed has no items.",
+    });
+  },
+};

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

@@ -171,7 +171,3 @@ export function parseRssFeedDocument(xml: string, config: RssFeedConfig): Market
   }
   throw new Error("Invalid or unsupported news feed.");
 }
-
-export function parseRssFeed(xml: string, config: RssFeedConfig): MarketNewsItem[] {
-  try { return parseRssFeedDocument(xml, config); } catch { return []; }
-}

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

@@ -1,6 +1,7 @@
 import { createThrottledFetch } from "../../../../../utils/throttled-fetch";
 import { newsProvider, type NewsCapability } from "../../../../../capabilities";
 import type { NewsQuery, MarketNewsItem } from "../../../../../types/news-source";
+import { normalizeNewsFeed } from "../../../../../news/news-model";
 import type { PluginPersistence } from "../../../../../types/plugin";
 import { parseRssFeedDocument, type RssFeedConfig } from "./parser";
 import { enrichNewsItem } from "../categories";
@@ -37,8 +38,7 @@ export interface RssNewsCapabilityOptions {
 }
 
 function supportsQuery(query: NewsQuery): boolean {
-  const feed = query.feed ?? (query.scope === "ticker" ? "ticker" : "latest");
-  return feed === "latest" && !query.cursor;
+  return normalizeNewsFeed(query) === "latest" && !query.cursor;
 }
 
 function serializeItem(item: MarketNewsItem): CachedNewsItem {

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

@@ -0,0 +1,95 @@
+import { apiClient } from "../../../api-client";
+import { withCliServices, withConfigData } from "../../../cli/scoped-context";
+import { CLI_COMMAND_GROUPS } from "../../../cli/help";
+import { dryRunNote } from "../../../cli/helpers";
+import { requireArg } from "../../../cli/commands/command-utils";
+import { createPluginPersistence } from "../../plugin-persistence";
+import type { CliCommandDef } from "../../../types/plugin";
+import { cliStyles } from "../../../utils/cli-output";
+import { readChatSessionState } from "../chat/controller/persistence";
+import { exportNotesToDirectory, type NotesExportSource } from "./export";
+import { NotesFiles } from "./files";
+import { CloudNotesStore } from "./store";
+
+export const notesCliCommand: CliCommandDef = {
+  name: "notes",
+  description: "Read, write, or export ticker notes",
+  help: {
+    group: CLI_COMMAND_GROUPS.portfolios,
+    usage: ["notes show <symbol>", "notes set <symbol> <text...>", "notes delete <symbol>", "notes quick list", "notes export [dir]"],
+    examples: ["notes show AAPL", "notes set AAPL \"Services margin above 70%\"", "notes export ~/notes"],
+  },
+  execute: async (args, ctx) => {
+    await withConfigData(ctx, async (config) => {
+      const notes = new NotesFiles(config.dataDir);
+      const action = args[0] ?? "list";
+      if (action === "export") {
+        // Local files plus, when a saved session exists, the cloud copies
+        // (personal and every team), one folder each.
+        const dir = args[1] ?? `${config.dataDir}/notes-export-${new Date().toISOString().slice(0, 10)}`;
+        const sources: NotesExportSource[] = [{ label: "local", store: notes }];
+        await withCliServices(ctx, async (services) => {
+          const cloudPersistence = createPluginPersistence(services.persistence.pluginState, services.persistence.resources, "plugin:gloomberb-cloud", "gloomberb-cloud");
+          const session = readChatSessionState(cloudPersistence, null);
+          if (!session?.sessionToken) return;
+          apiClient.setSessionToken(session.sessionToken);
+          const user = await apiClient.ensureVerifiedSession().catch(() => null);
+          if (!user) return;
+          const notesPersistence = createPluginPersistence(services.persistence.pluginState, services.persistence.resources, "plugin:notes", "notes");
+          sources.push({ label: "mine", store: new CloudNotesStore({ kind: "user" }, notesPersistence) });
+          const teams = await apiClient.listTeams().catch(() => []);
+          for (const team of teams) {
+            sources.push({ label: team.name, store: new CloudNotesStore({ kind: "team", teamId: team.id }, notesPersistence) });
+          }
+        });
+        if (ctx.cliOptions.dryRun) {
+          ctx.printResult({ data: { dryRun: true, dir, sources: sources.map((source) => source.label) } }, {
+            text: (data) => `Would export ${data.sources.join(", ")} notes to ${data.dir}.${dryRunNote(true)}`,
+          });
+          return;
+        }
+        const result = await exportNotesToDirectory(dir, sources);
+        ctx.printResult({ data: { dir: result.dir, files: result.files, sources: sources.map((source) => source.label) } }, {
+          text: (data) => `Exported ${data.files} notes from ${data.sources.join(", ")} to ${data.dir}.`,
+        });
+        return;
+      }
+      if (action === "quick") {
+        const subaction = args[1] ?? "list";
+        if (subaction !== "list") ctx.fail("Usage: gloomberb notes quick list");
+        const entries = await notes.loadQuickNotesIndex();
+        ctx.printResult({ data: entries }, { empty: "No quick notes." });
+        return;
+      }
+      if (action === "show") {
+        const symbol = requireArg(args[1]?.toUpperCase(), "Usage: gloomberb notes show <symbol>", ctx);
+        ctx.printResult({ data: { symbol, text: await notes.load(symbol) } }, {
+          text: (data) => data.text?.trim() ? data.text.trimEnd() : cliStyles.muted(`No note for ${symbol}.`),
+        });
+        return;
+      }
+      if (action === "set") {
+        const symbol = requireArg(args[1]?.toUpperCase(), "Usage: gloomberb notes set <symbol> <text...>", ctx);
+        const text = args.slice(2).join(" ");
+        if (!ctx.cliOptions.dryRun) await notes.save(symbol, text);
+        ctx.printResult({ data: { changed: !ctx.cliOptions.dryRun, dryRun: ctx.cliOptions.dryRun, symbol, bytes: text.length } }, {
+          text: (data) => `Saved the note for ${symbol}.${dryRunNote(data.dryRun)}`,
+        });
+        return;
+      }
+      if (action === "delete" || action === "rm") {
+        const symbol = requireArg(args[1]?.toUpperCase(), "Usage: gloomberb notes delete <symbol>", ctx);
+        // Only picks the message; an unreadable note is still deleted.
+        const existed = await notes.load(symbol).then((text) => !!text?.trim(), () => true);
+        if (!ctx.cliOptions.dryRun) await notes.delete(symbol);
+        ctx.printResult({ data: { changed: !ctx.cliOptions.dryRun, dryRun: ctx.cliOptions.dryRun, symbol } }, {
+          text: (data) => existed
+            ? `Deleted the note for ${symbol}.${dryRunNote(data.dryRun)}`
+            : cliStyles.muted(`No note for ${symbol}.`),
+        });
+        return;
+      }
+      ctx.fail("Usage: gloomberb notes show|set|delete|quick|export");
+    });
+  },
+};

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

@@ -13,13 +13,88 @@ export interface NoteFileEntry {
   updatedAt: number;
 }
 
-const QUICK_NOTES_INDEX = "__quick-notes-index__";
+/**
+ * Where `NotesFiles` keeps its files, by name inside its data directory. Bun
+ * reads the disk, a browser keeps them in localStorage, and the desktop view
+ * asks its Bun process, which serves the disk one.
+ */
+export interface NotesFilesIO {
+  /** The file's text, or null when it was never written. Any other failure rejects. */
+  read(file: string): Promise<string | null>;
+  write(file: string, text: string): Promise<void>;
+  /** A file that is already gone is not an error. */
+  delete(file: string): Promise<void>;
+  /** Every note's key (its `.md` file name without the extension) and when it was last written. */
+  listKeys(): Promise<Array<[string, number]>>;
+}
+
+const QUICK_NOTES_INDEX_FILE = "__quick-notes-index__.json";
+const LOCAL_KEY_PREFIX = "gloomberb:notes:";
 const LOCAL_TIMESTAMP_KEY = "gloomberb:notes:__updated-at__";
 
 function joinPath(...parts: string[]): string {
   return parts.join("/").replace(/\/+/g, "/");
 }
 
+/** The only files `NotesFiles` touches; a host serving its IO refuses anything else. */
+export function isNotesFile(file: string): boolean {
+  return file === QUICK_NOTES_INDEX_FILE || file.endsWith(".md");
+}
+
+async function nodeFs(): Promise<typeof import("fs/promises")> {
+  const fsModulePath = "fs/promises";
+  return await import(fsModulePath) as typeof import("fs/promises");
+}
+
+/** The files on disk: what the terminal reads, and what the desktop's Bun process serves its view. */
+export function diskNotesFilesIO(dataDir: string): NotesFilesIO {
+  const pathOf = (file: string) => joinPath(dataDir, file);
+  return {
+    async read(file) {
+      const { readFile } = await nodeFs();
+      try {
+        return await readFile(pathOf(file), "utf-8");
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException)?.code === "ENOENT") return null;
+        throw error;
+      }
+    },
+    async write(file, text) {
+      const { mkdir, writeFile } = await nodeFs();
+      const path = pathOf(file);
+      // The folder the file sits in, which is below dataDir when a symbol has a "/".
+      await mkdir(path.slice(0, path.lastIndexOf("/")) || dataDir, { recursive: true });
+      await writeFile(path, text, "utf-8");
+    },
+    async delete(file) {
+      const { unlink } = await nodeFs();
+      try {
+        await unlink(pathOf(file));
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+      }
+    },
+    async listKeys() {
+      const { readdir, stat } = await nodeFs();
+      let names: string[];
+      try {
+        names = await readdir(dataDir);
+      } catch {
+        return [];
+      }
+      const keys: Array<[string, number]> = [];
+      for (const name of names) {
+        if (!name.endsWith(".md")) continue;
+        try {
+          const info = await stat(pathOf(name));
+          keys.push([name.slice(0, -3), Math.round(info.mtimeMs)]);
+        } catch {}
+      }
+      return keys;
+    },
+  };
+}
+
 interface LocalStorageLike {
   getItem(key: string): string | null;
   setItem(key: string, value: string): void;
@@ -30,15 +105,6 @@ function getLocalStorage(): LocalStorageLike | null {
   return (globalThis as { localStorage?: LocalStorageLike }).localStorage ?? null;
 }
 
-async function readTextFile(path: string): Promise<string> {
-  if (typeof Bun !== "undefined") {
-    const fsModulePath = "fs/promises";
-    const { readFile } = await import(fsModulePath) as typeof import("fs/promises");
-    return readFile(path, "utf-8");
-  }
-  return getLocalStorage()?.getItem(`gloomberb:notes:${path}`) ?? "";
-}
-
 /** Browsers have no mtime, so note writes keep their own timestamp index. */
 function readLocalTimestamps(): Record<string, number> {
   try {
@@ -61,37 +127,76 @@ function writeLocalTimestamp(path: string, updatedAt: number | null): void {
   try { storage.setItem(LOCAL_TIMESTAMP_KEY, JSON.stringify(timestamps)); } catch {}
 }
 
-async function writeTextFile(path: string, value: string): Promise<void> {
-  if (typeof Bun !== "undefined") {
-    const fsModulePath = "fs/promises";
-    const { writeFile } = await import(fsModulePath) as typeof import("fs/promises");
-    await writeFile(path, value, "utf-8");
-    return;
-  }
-  getLocalStorage()?.setItem(`gloomberb:notes:${path}`, value);
-  writeLocalTimestamp(path, Date.now());
+function localStorageNotesFilesIO(dataDir: string): NotesFilesIO {
+  const pathOf = (file: string) => joinPath(dataDir, file);
+  return {
+    async read(file) {
+      return getLocalStorage()?.getItem(`${LOCAL_KEY_PREFIX}${pathOf(file)}`) ?? null;
+    },
+    async write(file, text) {
+      getLocalStorage()?.setItem(`${LOCAL_KEY_PREFIX}${pathOf(file)}`, text);
+      writeLocalTimestamp(pathOf(file), Date.now());
+    },
+    async delete(file) {
+      getLocalStorage()?.removeItem(`${LOCAL_KEY_PREFIX}${pathOf(file)}`);
+      writeLocalTimestamp(pathOf(file), null);
+    },
+    async listKeys() {
+      const prefix = joinPath(dataDir, "");
+      const timestamps = readLocalTimestamps();
+      const storageKeyPrefix = `${LOCAL_KEY_PREFIX}${prefix}`;
+      // Notes written before the index existed are stamped now rather than at
+      // the epoch, so an older cloud copy cannot overwrite them on first sync.
+      for (const storageKey of Object.keys(globalThis.localStorage ?? {})) {
+        if (!storageKey.startsWith(storageKeyPrefix) || !storageKey.endsWith(".md")) continue;
+        const path = storageKey.slice(LOCAL_KEY_PREFIX.length);
+        if (timestamps[path] == null) writeLocalTimestamp(path, timestamps[path] = Date.now());
+      }
+      return Object.entries(timestamps)
+        .filter(([path]) => path.startsWith(prefix) && path.endsWith(".md"))
+        .map(([path, updatedAt]) => [path.slice(prefix.length, -3), updatedAt]);
+    },
+  };
 }
 
-async function deleteTextFile(path: string): Promise<void> {
-  if (typeof Bun !== "undefined") {
-    const fsModulePath = "fs/promises";
-    const { unlink } = await import(fsModulePath) as typeof import("fs/promises");
-    await unlink(path);
-    return;
-  }
-  getLocalStorage()?.removeItem(`gloomberb:notes:${path}`);
-  writeLocalTimestamp(path, null);
+/**
+ * An IO whose calls run elsewhere under the same names, with the data
+ * directory added to each payload. The desktop view sends them to the Bun
+ * process's notes-files capability.
+ */
+export function remoteNotesFilesIO(
+  dataDir: string,
+  invoke: (operationId: keyof NotesFilesIO, payload: Record<string, unknown>) => Promise<unknown>,
+): NotesFilesIO {
+  return {
+    read: async (file) => await invoke("read", { dataDir, file }) as string | null,
+    write: async (file, text) => { await invoke("write", { dataDir, file, text }); },
+    delete: async (file) => { await invoke("delete", { dataDir, file }); },
+    listKeys: async () => await invoke("listKeys", { dataDir }) as Array<[string, number]>,
+  };
+}
+
+let hostNotesFilesIO: ((dataDir: string) => NotesFilesIO) | null = null;
+
+/**
+ * A renderer that cannot reach the files itself installs how to at startup,
+ * the way the desktop view goes through its Bun process. The others read the
+ * disk under Bun and localStorage in a browser.
+ */
+export function setNotesFilesIO(factory: ((dataDir: string) => NotesFilesIO) | null): void {
+  hostNotesFilesIO = factory;
+}
+
+function defaultNotesFilesIO(dataDir: string): NotesFilesIO {
+  if (hostNotesFilesIO) return hostNotesFilesIO(dataDir);
+  return typeof Bun !== "undefined" ? diskNotesFilesIO(dataDir) : localStorageNotesFilesIO(dataDir);
 }
 
 export class NotesFiles implements NotesStore {
   readonly readOnly = false;
   readonly owner: NoteOwner = { kind: "user" };
 
-  constructor(private readonly dataDir: string) {}
-
-  private pathFor(symbol: string): string {
-    return joinPath(this.dataDir, `${symbol}.md`);
-  }
+  constructor(dataDir: string, private readonly io: NotesFilesIO = defaultNotesFilesIO(dataDir)) {}
 
   /**
    * A note that was never written is empty, but any other read failure is
@@ -99,30 +204,21 @@ export class NotesFiles implements NotesStore {
    * one, or the next save silently overwrites real content.
    */
   async load(symbol: string): Promise<string> {
-    try {
-      return await readTextFile(this.pathFor(symbol));
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException)?.code === "ENOENT") return "";
-      throw error;
-    }
+    return (await this.io.read(`${symbol}.md`)) ?? "";
   }
 
   async save(symbol: string, notes: string): Promise<void> {
-    await writeTextFile(this.pathFor(symbol), notes || "");
+    await this.io.write(`${symbol}.md`, notes || "");
   }
 
   async delete(symbol: string): Promise<void> {
-    try {
-      await deleteTextFile(this.pathFor(symbol));
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
-    }
+    await this.io.delete(`${symbol}.md`);
   }
 
   /** Every stored note, ticker notes and quick notes alike, newest first. */
   async list(): Promise<NoteFileEntry[]> {
     const entries: NoteFileEntry[] = [];
-    for (const [key, updatedAt] of await this.listKeys()) {
+    for (const [key, updatedAt] of await this.io.listKeys()) {
       try {
         entries.push({ key, text: await this.load(key), updatedAt });
       } catch {
@@ -132,56 +228,17 @@ export class NotesFiles implements NotesStore {
     return entries.sort((left, right) => right.updatedAt - left.updatedAt);
   }
 
-  private async listKeys(): Promise<Array<[string, number]>> {
-    if (typeof Bun !== "undefined") {
-      const fsModulePath = "fs/promises";
-      const { readdir, stat } = await import(fsModulePath) as typeof import("fs/promises");
-      let names: string[];
-      try {
-        names = await readdir(this.dataDir);
-      } catch {
-        return [];
-      }
-      const keys: Array<[string, number]> = [];
-      for (const name of names) {
-        if (!name.endsWith(".md")) continue;
-        try {
-          const info = await stat(joinPath(this.dataDir, name));
-          keys.push([name.slice(0, -3), Math.round(info.mtimeMs)]);
-        } catch {}
-      }
-      return keys;
-    }
-    const prefix = joinPath(this.dataDir, "");
-    const timestamps = readLocalTimestamps();
-    const storageKeyPrefix = `gloomberb:notes:${prefix}`;
-    // Notes written before the index existed are stamped now rather than at
-    // the epoch, so an older cloud copy cannot overwrite them on first sync.
-    for (const storageKey of Object.keys(globalThis.localStorage ?? {})) {
-      if (!storageKey.startsWith(storageKeyPrefix) || !storageKey.endsWith(".md")) continue;
-      const path = storageKey.slice("gloomberb:notes:".length);
-      if (timestamps[path] == null) writeLocalTimestamp(path, timestamps[path] = Date.now());
-    }
-    return Object.entries(timestamps)
-      .filter(([path]) => path.startsWith(prefix) && path.endsWith(".md"))
-      .map(([path, updatedAt]) => [path.slice(prefix.length, -3), updatedAt]);
-  }
-
-  private indexPath(): string {
-    return joinPath(this.dataDir, `${QUICK_NOTES_INDEX}.json`);
-  }
-
   async loadQuickNotesIndex(): Promise<QuickNoteEntry[]> {
     try {
-      const raw = await readTextFile(this.indexPath());
-      return JSON.parse(raw);
+      const raw = await this.io.read(QUICK_NOTES_INDEX_FILE);
+      return raw ? JSON.parse(raw) : [];
     } catch {
       return [];
     }
   }
 
   async saveQuickNotesIndex(entries: QuickNoteEntry[]): Promise<void> {
-    await writeTextFile(this.indexPath(), JSON.stringify(entries));
+    await this.io.write(QUICK_NOTES_INDEX_FILE, JSON.stringify(entries));
   }
 
   quickNoteKey(id: string): string {