@gloom-sh/terminal 0.19.1 → 0.19.2

package/src/components/layout/pane/footer/index.tsx

@@ -29,6 +29,7 @@ export {
   DELAYED_SEGMENT,
   delayedFooterSegment,
   hasPaneFooterContent,
+  savedCopyFooterInfo,
   savedCopyFooterSegment,
   splitDelayedStatus,
   type CombinedPaneFooter,

package/src/components/layout/pane/footer/model.ts

@@ -51,6 +51,13 @@ export interface PaneFooterSegment {
    * warning.
    */
   capture?: boolean;
+  /**
+   * When the copy the pane shows was saved, on the saved-copy segment
+   * ({@link savedCopyFooterSegment}). The footer draws that segment first,
+   * wherever a pane registers it, and once: the oldest when several parts of
+   * the pane show a saved copy.
+   */
+  savedCopyAt?: number;
   /**
    * Shorter forms of `parts`, longest first. When the row is too narrow for
    * `parts` beside the hints, it shows the first that fits, or the last, and
@@ -113,12 +120,23 @@ export function savedCopyFooterSegment(id: string, savedAt: number, now = Date.n
   return {
     id,
     quoteStatus: true,
+    savedCopyAt: savedAt,
     title: `${t("Couldn't refresh")}: ${text}`,
     parts: [{ text, tone: "warning" }],
     variants: [[{ text: t("saved copy"), tone: "warning" }]],
   };
 }
 
+/**
+ * The saved-copy segment of a pane showing several answers (a list and the
+ * report it opens): the oldest of the copies among `savedAts` (ms), or no
+ * segment when none of them is one.
+ */
+export function savedCopyFooterInfo(savedAts: readonly (number | null | undefined)[], id = "saved-copy"): PaneFooterSegment[] {
+  const times = savedAts.filter((at): at is number => typeof at === "number" && Number.isFinite(at));
+  return times.length > 0 ? [savedCopyFooterSegment(id, Math.min(...times))] : [];
+}
+
 /**
  * The footer's one form for company data a pane shows from another listing
  * of the company: a receipt or a foreign line (SKHY, HY9H in Frankfurt) reads
@@ -450,7 +468,20 @@ export function combinePaneFooterRegistrations(registrations: Map<string, PaneFo
   const shown = yielded.length > 0 ? hints.filter((hint) => !yielded.includes(hint)) : hints;
 
   if (info.length === 0 && shown.length === 0 && menu.length === 0 && keys.length === 0) return EMPTY_FOOTER;
-  return { info, hints: shown, menu, keys };
+  return { info: savedCopyFirst(info), hints: shown, menu, keys };
+}
+
+/**
+ * The saved-copy segment in its one place: first, so it reads the same in
+ * every pane and is the last a narrow row cuts, and once, the oldest copy,
+ * when a list and the report it opens each register one.
+ */
+function savedCopyFirst(info: PaneFooterSegment[]): PaneFooterSegment[] {
+  let oldest: PaneFooterSegment | undefined;
+  for (const segment of info) {
+    if (segment.savedCopyAt != null && (oldest?.savedCopyAt == null || segment.savedCopyAt < oldest.savedCopyAt)) oldest = segment;
+  }
+  return oldest ? [oldest, ...info.filter((segment) => segment.savedCopyAt == null)] : info;
 }
 
 function sameFooterParts(left: PaneFooterPart[], right: PaneFooterPart[]): boolean {
@@ -507,6 +538,7 @@ export function samePaneFooterRegistration(
         && segment.shortcut === other.shortcut
         && !!segment.onPress === !!other.onPress
         && segment.disabled === other.disabled
+        && segment.savedCopyAt === other.savedCopyAt
         && sameFooterParts(segment.parts, other.parts)
         && (segment.variants?.length ?? 0) === (other.variants?.length ?? 0)
         && (segment.variants ?? []).every((variant, variantIndex) => sameFooterParts(variant, other.variants![variantIndex]!));

package/src/components/layout/pane/header.tsx

@@ -178,13 +178,13 @@ export function PaneHeader({
     event.stopPropagation?.();
     onHeaderMouseDown?.(event);
   };
-  const beginWindowDrag = (event?: { stopPropagation?: () => void }) => {
+  const beginWindowDrag = (event?: { stopPropagation?: () => void; detail?: number }) => {
     event?.stopPropagation?.();
     if (titleBar) {
       onHeaderMouseDown?.(event);
       return;
     }
-    void rendererHost.startWindowDrag?.();
+    void rendererHost.startWindowDrag?.(event);
   };
   const barHandlers = windowDrag
     ? { onMouseDown: beginWindowDrag }

package/src/components/layout/pane/status-footer.ts

@@ -11,7 +11,8 @@ const EMPTY_STATUS_INFO: PaneFooterSegment[] = [];
 // has no per-pane footer hint. Do not reintroduce one. See PR #589. Panes bind
 // it with `usePaneRefreshKey`.
 
-const STALE_SEGMENT: PaneFooterSegment = { id: "stale", parts: [{ text: "stale", tone: "warning" }] };
+/** The shared warning for data on screen older than it should be, for a pane composing its own footer. */
+export const STALE_SEGMENT: PaneFooterSegment = { id: "stale", parts: [{ text: "stale", tone: "warning" }] };
 
 interface PaneStatusInfoOptions {
   loading?: boolean;

package/src/components/onboarding/onboarding-frame.tsx

@@ -219,7 +219,8 @@ export function OnboardingCoach({
       </Box>
       <Box height={1} />
       <Box flexGrow={1} minHeight={0}>{children}</Box>
-      <Box height={1} flexDirection="row" gap={1}>{actions}</Box>
+      {/* As OnboardingActions: a button that does not fit beside the one before it wraps under it. */}
+      <Box flexDirection="row" flexWrap="wrap" alignItems="center" columnGap={1} flexShrink={0}>{actions}</Box>
     </Box>
   );
 }

package/src/components/onboarding/onboarding-wizard.tsx

@@ -322,12 +322,15 @@ export function OnboardingWizard(props: OnboardingWizardProps) {
     return <OnboardingCoach step={t("YOUR WORKSPACE")}
       title={tf("Built around {ticker}", { ticker })}
       actions={<>
-        {/* The card has no room for both keys: like a toast, the dismiss key
-            is in the desktop tooltip. F10 also dismisses it. */}
+        {/* Each button shows its key, as Connect shows Alt+Enter; in the
+            terminal the second wraps under the first. The desktop card has no
+            room for both: like a toast, its dismiss key is in the tooltip.
+            F10 also dismisses it. */}
         <OnboardingButton
           label="Keep exploring"
           variant="ghost"
-          title={notificationDismissShortcut ? `${t("Keep exploring")} (${notificationDismissShortcut})` : undefined}
+          shortcut={!desktop && notificationDismissShortcut ? notificationDismissShortcut : undefined}
+          title={desktop && notificationDismissShortcut ? `${t("Keep exploring")} (${notificationDismissShortcut})` : undefined}
           onPress={() => { void finish(); }}
         />
         <OnboardingButton

package/src/components/ui/display.tsx

@@ -214,8 +214,18 @@ export interface BadgeProps {
 export const NATIVE_BADGE_STYLE = { height: "calc(100% - 2px)", borderRadius: "var(--gloom-radius-sm)" };
 /** How far a subtle chip's fill is tinted toward its tone. */
 export const BADGE_TINT = 0.28;
-const NATIVE_BADGE_TEXT_STYLE = { fontWeight: "var(--gloom-weight-regular)" };
 const NATIVE_ICON_BADGE_STYLE = { ...NATIVE_BADGE_STYLE, gap: "var(--gloom-space-xs)" };
+const NATIVE_BADGE_TEXT_STYLE = { fontWeight: "var(--gloom-weight-regular)" };
+/**
+ * A label with lowercase letters has them in the middle of the chip,
+ * wherever the font puts them in its line: the line is cut to x-height and
+ * baseline, and that is what the chip centres. Centred whole, SF Mono's
+ * lowercase sit a pixel and a half low. An icon centres in the chip, so it
+ * reads on the letters' line. A label in capitals and digits keeps the
+ * whole line, as ticker chips do; a browser without `text-box` keeps it too.
+ */
+const NATIVE_LOWERCASE_BADGE_TEXT_STYLE = { ...NATIVE_BADGE_TEXT_STYLE, textBox: "trim-both ex alphabetic" };
+const LOWERCASE = /\p{Ll}/u;
 
 export function Badge({ label, tone = "neutral", color, variant = "subtle", icon, translate = true }: BadgeProps) {
   const colors = useThemeColors();
@@ -233,11 +243,12 @@ export function Badge({ label, tone = "neutral", color, variant = "subtle", icon
   const chip = (
     <Box height={nativePaneChrome ? undefined : 1} paddingX={1} backgroundColor={background}
       data-gloom-ui="badge" {...(nativeIcon ? { flexDirection: "row", alignItems: "center" } as const : {})}
-      justifyContent={nativePaneChrome && !icon ? "center" : undefined}
-      style={nativePaneChrome ? icon ? NATIVE_ICON_BADGE_STYLE : NATIVE_BADGE_STYLE : undefined}>
-      {nativeIcon ? <Icon name={nativeIcon} color={foreground} /> : null}
+      justifyContent={nativePaneChrome && !nativeIcon ? "center" : undefined}
+      style={nativePaneChrome ? nativeIcon ? NATIVE_ICON_BADGE_STYLE : NATIVE_BADGE_STYLE : undefined}>
+      {nativeIcon ? <Icon name={nativeIcon} color={foreground} fullHeight /> : null}
       {shown || !nativeIcon ? (
-        <Text fg={foreground} attributes={TextAttributes.BOLD} style={nativePaneChrome ? NATIVE_BADGE_TEXT_STYLE : undefined}>{shown}</Text>
+        <Text fg={foreground} attributes={TextAttributes.BOLD}
+          style={nativePaneChrome ? LOWERCASE.test(text) ? NATIVE_LOWERCASE_BADGE_TEXT_STYLE : NATIVE_BADGE_TEXT_STYLE : undefined}>{shown}</Text>
       ) : null}
     </Box>
   );

package/src/components/ui/icon.tsx

@@ -94,13 +94,19 @@ export interface IconProps {
   /** Pixel size on the desktop; the terminal draws one glyph. */
   size?: number;
   color?: string;
+  /**
+   * Desktop: takes its row's full height and draws in the middle of it. A
+   * box centred in a row an odd number of pixels taller lands on a whole
+   * pixel, half a pixel off; the drawing inside the box does not.
+   */
+  fullHeight?: boolean;
 }
 
 /** One glyph from the app's icon set. */
-export function Icon({ name, size = 12, color }: IconProps) {
+export function Icon({ name, size = 12, color, fullHeight }: IconProps) {
   const colors = useThemeColors();
   const HostIcon = useUiHost().Icon as ComponentType<IconProps> | undefined;
-  if (HostIcon) return <HostIcon name={name} size={size} color={color} />;
+  if (HostIcon) return <HostIcon name={name} size={size} color={color} fullHeight={fullHeight} />;
   return <Text fg={color ?? colors.textDim} selectable={false}>{ICON_GLYPHS[name]}</Text>;
 }
 

package/src/core/app-services.ts

@@ -10,8 +10,17 @@ import { createAppRuntime } from "./app-runtime";
 
 export type AppServices = ReturnType<typeof createAppServices>;
 
-export function createAppServices({ config, plugins, externalPlugins }: AppServicesFactoryOptions) {
-  const persistence = new AppPersistence(join(config.dataDir, ".gloomberb-cache.db"));
+interface AppServicesOptions extends AppServicesFactoryOptions {
+  /**
+   * Runs where the user waits on it (the terminal, the desktop app), so no
+   * database statement waits on another program's lock (data/sqlite/access.ts).
+   * A command sets it to false and waits instead.
+   */
+  interactive?: boolean;
+}
+
+export function createAppServices({ config, plugins, externalPlugins, interactive = true }: AppServicesOptions) {
+  const persistence = new AppPersistence(join(config.dataDir, ".gloomberb-cache.db"), { interactive });
   const tickerRepository = new TickerRepository(persistence.tickers);
   const providerRouter = new AssetDataRouter(null, [], persistence.resources, connectionHealth);
   const runtime = createAppRuntime({

package/src/data/app-persistence.ts

@@ -1,7 +1,7 @@
 import { PluginStateStore } from "./plugin-state-store";
 import { ResourceStore } from "./resource-store";
 import { SessionStore } from "./session-store";
-import { SqliteDatabase } from "./sqlite/database";
+import { SqliteDatabase, type SqliteDatabaseOptions } from "./sqlite/database";
 import { TickerStore } from "./ticker-store";
 
 export class AppPersistence {
@@ -11,15 +11,17 @@ export class AppPersistence {
   readonly pluginState: PluginStateStore;
   readonly sessions: SessionStore;
 
-  constructor(dbPath: string) {
-    this.database = new SqliteDatabase(dbPath);
-    this.tickers = new TickerStore(this.database.connection);
-    this.resources = new ResourceStore(this.database.connection);
-    this.pluginState = new PluginStateStore(this.database.connection);
-    this.sessions = new SessionStore(this.database.connection);
+  constructor(dbPath: string, options: SqliteDatabaseOptions = {}) {
+    this.database = new SqliteDatabase(dbPath, options);
+    const { connection, access } = this.database;
+    this.tickers = new TickerStore(connection, access);
+    this.resources = new ResourceStore(connection, access);
+    this.pluginState = new PluginStateStore(connection, access);
+    this.sessions = new SessionStore(connection, access);
   }
 
   close(): void {
+    this.resources.close();
     this.database.close();
   }
 }

package/src/data/plugin-cache.ts

@@ -2,6 +2,7 @@ import { logFailure } from "../utils/log-failure";
 import type { CachePolicy } from "../types/persistence";
 import type { PluginPersistence } from "../types/plugin";
 import { CachedQuery, type CachedValue } from "./cached-query";
+import { isTransientFailure } from "../api-client/errors";
 
 export interface PluginCacheResult<T> {
   data: T;
@@ -12,6 +13,20 @@ export interface PluginCacheResult<T> {
   source: "cache" | "network" | "stale-fallback";
 }
 
+/**
+ * `result`, or the failure of the refresh it stands in for when a saved copy
+ * may not answer for it. A saved copy covers only a failure asking again may
+ * get past (`isTransientFailure`: no connection, a timeout, a rate-limited or
+ * overloaded server, a reply whose source did not answer this time); a
+ * refusal (another 4xx, such as a series no longer served or a signed-out
+ * session) and an answer that failed validation are thrown, so they show as
+ * the errors they are instead of as old data.
+ */
+export function savedCopyForTransientFailure<R extends { source?: PluginCacheResult<unknown>["source"]; error?: unknown }>(result: R): R {
+  if (result.source === "stale-fallback" && !isTransientFailure(result.error)) throw result.error;
+  return result;
+}
+
 /** Shared persistence/request lifecycle; keys, codecs, validation and policies stay with the plugin. */
 export function createPluginCache<T, Stored = T>(options: {
   kind: string;

package/src/data/plugin-state-store.ts

@@ -1,6 +1,6 @@
 import type { Database } from "bun:sqlite";
+import { createSqliteAccess, type SqliteAccess } from "./sqlite/access";
 import { safeParseJson, serializeJson } from "./sqlite/json";
-import { withSqliteBusyRetry } from "./sqlite/retry";
 
 const DEFAULT_PLUGIN_STATE_SCHEMA_VERSION = 1;
 
@@ -24,14 +24,39 @@ interface CachedPluginStateRecord {
   rawValue: string;
 }
 
+/** A queued write's record (null for a delete), one object per write. */
+interface PendingPluginState {
+  pluginId: string;
+  key: string;
+  record: CachedPluginStateRecord | null;
+}
+
+function stateKey(pluginId: string, key: string): string {
+  return `${pluginId}:${key}`;
+}
+
+/** A queued write's row, unambiguous where ids and keys hold colons. */
+function rowKey(pluginId: string, key: string): string {
+  return `${pluginId}\u0000${key}`;
+}
+
 export class PluginStateStore {
   private readonly cache = new Map<string, CachedPluginStateRecord>();
+  /** Writes queued behind another program's lock, read back until they land. */
+  private readonly pending = new Map<string, PendingPluginState>();
 
-  constructor(private readonly db: Database) {}
+  constructor(
+    private readonly db: Database,
+    private readonly access: SqliteAccess = createSqliteAccess(db),
+  ) {}
 
   get<T>(pluginId: string, key: string, schemaVersion = DEFAULT_PLUGIN_STATE_SCHEMA_VERSION): PluginStateRecord<T> | null {
-    const cacheKey = `${pluginId}:${key}`;
-    const row = withSqliteBusyRetry("load plugin state", () => (
+    const cacheKey = stateKey(pluginId, key);
+    const pending = this.pending.get(rowKey(pluginId, key));
+    if (pending) {
+      return pending.record?.schemaVersion === schemaVersion ? pending.record as PluginStateRecord<T> : null;
+    }
+    const row = this.access.run("load plugin state", () => (
       this.db
         .query<{ schema_version: number; value: string; updated_at: number }, [string, string]>(
           "SELECT schema_version, value, updated_at FROM plugin_state WHERE plugin_id = ? AND key = ?",
@@ -77,46 +102,42 @@ export class PluginStateStore {
   setMany(entries: PluginStateSetEntry[]): void {
     if (entries.length === 0) return;
     const updatedAt = Date.now();
-    const records = entries.map((entry) => ({
+    const writes: PendingPluginState[] = entries.map((entry) => ({
       pluginId: entry.pluginId,
       key: entry.key,
-      value: entry.value,
-      schemaVersion: entry.schemaVersion ?? DEFAULT_PLUGIN_STATE_SCHEMA_VERSION,
-      rawValue: serializeJson(entry.value),
+      record: {
+        value: entry.value,
+        schemaVersion: entry.schemaVersion ?? DEFAULT_PLUGIN_STATE_SCHEMA_VERSION,
+        updatedAt,
+        rawValue: serializeJson(entry.value),
+      },
     }));
 
-    withSqliteBusyRetry("save plugin state", () => {
+    this.write("save plugin state", writes, writes.length === 1, () => {
       const insert = this.db.query(
         `INSERT OR REPLACE INTO plugin_state (plugin_id, key, schema_version, value, updated_at)
          VALUES (?, ?, ?, ?, ?)`,
       );
       const tx = this.db.transaction(() => {
-        for (const record of records) {
-          insert.run(record.pluginId, record.key, record.schemaVersion, record.rawValue, updatedAt);
+        for (const { pluginId, key, record } of writes) {
+          insert.run(pluginId, key, record!.schemaVersion, record!.rawValue, updatedAt);
         }
       });
       tx();
     });
 
-    for (const record of records) {
-      this.cache.set(`${record.pluginId}:${record.key}`, {
-        value: record.value,
-        schemaVersion: record.schemaVersion,
-        updatedAt,
-        rawValue: record.rawValue,
-      });
-    }
+    for (const { pluginId, key, record } of writes) this.cache.set(stateKey(pluginId, key), record!);
   }
 
   delete(pluginId: string, key: string): void {
-    withSqliteBusyRetry("delete plugin state", () => {
+    this.write("delete plugin state", [{ pluginId, key, record: null }], true, () => {
       this.db.query("DELETE FROM plugin_state WHERE plugin_id = ? AND key = ?").run(pluginId, key);
     });
-    this.cache.delete(`${pluginId}:${key}`);
+    this.cache.delete(stateKey(pluginId, key));
   }
 
   keys(pluginId: string): string[] {
-    return withSqliteBusyRetry("list plugin state keys", () => (
+    const stored = this.access.run("list plugin state keys", () => (
       this.db
         .query<{ key: string }, [string]>(
           "SELECT key FROM plugin_state WHERE plugin_id = ? ORDER BY key",
@@ -124,10 +145,18 @@ export class PluginStateStore {
         .all(pluginId)
         .map((row) => row.key)
     ));
+    if (this.pending.size === 0) return stored;
+    const keys = new Set(stored);
+    for (const entry of this.pending.values()) {
+      if (entry.pluginId !== pluginId) continue;
+      if (entry.record) keys.add(entry.key);
+      else keys.delete(entry.key);
+    }
+    return [...keys].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
   }
 
   pluginIds(): string[] {
-    return withSqliteBusyRetry("list plugin state ids", () => (
+    const stored = this.access.run("list plugin state ids", () => (
       this.db
         .query<{ plugin_id: string }, []>(
           "SELECT DISTINCT plugin_id FROM plugin_state ORDER BY plugin_id",
@@ -135,10 +164,19 @@ export class PluginStateStore {
         .all()
         .map((row) => row.plugin_id)
     ));
+    if (this.pending.size === 0) return stored;
+    const ids = new Set(stored);
+    for (const { pluginId } of this.pending.values()) {
+      if (this.keys(pluginId).length > 0) ids.add(pluginId);
+      else ids.delete(pluginId);
+    }
+    return [...ids].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
   }
 
   clear(pluginId: string): void {
-    withSqliteBusyRetry("clear plugin state", () => {
+    const cleared = this.keys(pluginId).map((key): PendingPluginState => ({ pluginId, key, record: null }));
+    // Deletes rows this store may not know of: never one row's write.
+    this.write("clear plugin state", cleared, false, () => {
       this.db.query("DELETE FROM plugin_state WHERE plugin_id = ?").run(pluginId);
     });
     for (const cacheKey of this.cache.keys()) {
@@ -147,4 +185,23 @@ export class PluginStateStore {
       }
     }
   }
+
+  /**
+   * Runs `statement` through the write queue, reading `entries` back until it
+   * lands. A write of exactly one row (`oneRow`) replaces a queued write of
+   * the same row.
+   */
+  private write(operationName: string, entries: PendingPluginState[], oneRow: boolean, statement: () => void): void {
+    for (const entry of entries) this.pending.set(rowKey(entry.pluginId, entry.key), entry);
+    const only = oneRow && entries.length === 1 ? entries[0] : undefined;
+    this.access.write(operationName, statement, {
+      ...(only ? { key: `plugin_state\u0000${rowKey(only.pluginId, only.key)}` } : {}),
+      settled: () => {
+        for (const entry of entries) {
+          const pendingKey = rowKey(entry.pluginId, entry.key);
+          if (this.pending.get(pendingKey) === entry) this.pending.delete(pendingKey);
+        }
+      },
+    });
+  }
 }