gloomberb 0.4.1 → 0.5.0

package/src/utils/link-tokenizer.ts

@@ -0,0 +1,93 @@
+export interface InlineLinkTextToken {
+  kind: "text";
+  value: string;
+}
+
+export interface InlineLinkUrlToken {
+  kind: "link";
+  value: string;
+  url: string;
+}
+
+export type InlineLinkToken = InlineLinkTextToken | InlineLinkUrlToken;
+
+const LINK_TOKEN_RE = /\b(?:https?:\/\/|www\.)[^\s<>"']+/gi;
+const ALWAYS_TRIM_RE = /[.,!?;:]/;
+const BRACKET_PAIRS: Record<string, string> = {
+  ")": "(",
+  "]": "[",
+  "}": "{",
+};
+
+function countChar(value: string, char: string): number {
+  let total = 0;
+  for (const current of value) {
+    if (current === char) total += 1;
+  }
+  return total;
+}
+
+function trimTrailingLinkPunctuation(rawValue: string): { value: string; trailing: string } {
+  let value = rawValue;
+
+  while (value.length > 0) {
+    const lastChar = value[value.length - 1]!;
+    if (ALWAYS_TRIM_RE.test(lastChar)) {
+      value = value.slice(0, -1);
+      continue;
+    }
+
+    const openingChar = BRACKET_PAIRS[lastChar];
+    if (!openingChar) break;
+
+    if (countChar(value, lastChar) > countChar(value, openingChar)) {
+      value = value.slice(0, -1);
+      continue;
+    }
+
+    break;
+  }
+
+  return { value, trailing: rawValue.slice(value.length) };
+}
+
+function normalizeLinkUrl(value: string): string {
+  return /^https?:\/\//i.test(value) ? value : `https://${value}`;
+}
+
+export function tokenizeInlineLinks(text: string): InlineLinkToken[] {
+  const tokens: InlineLinkToken[] = [];
+  let cursor = 0;
+  let match: RegExpExecArray | null;
+
+  LINK_TOKEN_RE.lastIndex = 0;
+  while ((match = LINK_TOKEN_RE.exec(text)) !== null) {
+    const rawValue = match[0];
+    const start = match.index;
+    const end = start + rawValue.length;
+
+    if (start > cursor) {
+      tokens.push({ kind: "text", value: text.slice(cursor, start) });
+    }
+
+    const trimmed = trimTrailingLinkPunctuation(rawValue);
+    if (trimmed.value) {
+      tokens.push({
+        kind: "link",
+        value: trimmed.value,
+        url: normalizeLinkUrl(trimmed.value),
+      });
+    }
+    if (trimmed.trailing) {
+      tokens.push({ kind: "text", value: trimmed.trailing });
+    }
+
+    cursor = end;
+  }
+
+  if (cursor < text.length) {
+    tokens.push({ kind: "text", value: text.slice(cursor) });
+  }
+
+  return tokens;
+}

package/src/utils/market-format.test.ts

@@ -0,0 +1,109 @@
+import { describe, expect, test } from "bun:test";
+import {
+  formatMarketCost,
+  formatMarketCostWithCurrency,
+  formatCompactMarketPriceWithCurrency,
+  formatMarketPrice,
+  formatMarketPriceWithCurrency,
+  formatMarketQuantity,
+  formatSignedMarketPrice,
+  resolveAssetDisplayKind,
+} from "./market-format";
+
+describe("resolveAssetDisplayKind", () => {
+  test("prefers explicit cash balances", () => {
+    expect(resolveAssetDisplayKind({ isCashBalance: true, assetCategory: "STK" })).toBe("cash");
+  });
+
+  test("maps common broker security types", () => {
+    expect(resolveAssetDisplayKind({ assetCategory: "CRYPTO" })).toBe("crypto");
+    expect(resolveAssetDisplayKind({ assetCategory: "STK" })).toBe("equity");
+    expect(resolveAssetDisplayKind({ contractSecType: "OPT" })).toBe("contract");
+    expect(resolveAssetDisplayKind({ assetCategory: "FOREX" })).toBe("cash");
+    expect(resolveAssetDisplayKind({ assetCategory: "CURRENCY" })).toBe("cash");
+    expect(resolveAssetDisplayKind({ assetCategory: "CCY" })).toBe("cash");
+  });
+
+  test("falls back to contract formatting when only a multiplier is present", () => {
+    expect(resolveAssetDisplayKind({ multiplier: 100 })).toBe("contract");
+  });
+});
+
+describe("formatMarketQuantity", () => {
+  test("preserves additional FX precision while trimming trailing zeroes", () => {
+    expect(formatMarketQuantity(-351957.025, { isCashBalance: true })).toBe("-351,957.025");
+    expect(formatMarketQuantity(-303029.144938754, { isCashBalance: true })).toBe("-303,029.144939");
+  });
+
+  test("shows whole equities without decimals and fractional equities with up to four decimals", () => {
+    expect(formatMarketQuantity(10, { assetCategory: "STK" })).toBe("10");
+    expect(formatMarketQuantity(10.125, { assetCategory: "STK" })).toBe("10.125");
+    expect(formatMarketQuantity(10.123456, { assetCategory: "STK" })).toBe("10.1235");
+  });
+
+  test("uses higher precision for crypto quantities", () => {
+    expect(formatMarketQuantity(0.123456789, { assetCategory: "CRYPTO" })).toBe("0.12345679");
+  });
+});
+
+describe("formatMarketPrice", () => {
+  test("uses semantic precision for equities, cash, and crypto", () => {
+    expect(formatMarketPrice(190.2, { assetCategory: "STK" })).toBe("190.2");
+    expect(formatMarketPrice(259.7499, { assetCategory: "STK" })).toBe("259.75");
+    expect(formatMarketPrice(1.084567, { isCashBalance: true })).toBe("1.084567");
+    expect(formatMarketPrice(1.17364, { assetCategory: "CURRENCY" })).toBe("1.17364");
+    expect(formatMarketPrice(0.000123456789, { assetCategory: "CRYPTO" })).toBe("0.00012346");
+  });
+
+  test("can adapt chart precision to the visible price range", () => {
+    expect(formatMarketPrice(1.167815, { assetCategory: "CURRENCY", priceRange: 0.12 })).toBe("1.17");
+    expect(formatMarketPrice(1.167815, { assetCategory: "CURRENCY", priceRange: 0.0024 })).toBe("1.1678");
+    expect(formatMarketPrice(259.7499, {
+      assetCategory: "STK",
+      minimumFractionDigits: 2,
+      precisionOffset: 1,
+      priceRange: 80,
+    })).toBe("259.75");
+  });
+
+  test("can lock price displays to a specific number of decimals", () => {
+    expect(formatMarketPrice(18, { assetCategory: "STK", fixedFractionDigits: 1 })).toBe("18.0");
+    expect(formatMarketPriceWithCurrency(18, "USD", { assetCategory: "STK", fixedFractionDigits: 2 })).toBe("$18.00");
+  });
+
+  test("fits within the supplied width before falling back to truncation elsewhere", () => {
+    expect(formatMarketPrice(1.084567, { isCashBalance: true, maxWidth: 6 })).toBe("1.0846");
+    expect(formatMarketQuantity(123456.789, { assetCategory: "CRYPTO", maxWidth: 7 })).toBe("123,457");
+  });
+
+  test("formats signed price changes without double signs", () => {
+    expect(formatSignedMarketPrice(0.123456, { isCashBalance: true })).toBe("+0.123456");
+    expect(formatSignedMarketPrice(-0.123456, { isCashBalance: true })).toBe("-0.123456");
+  });
+});
+
+describe("formatMarketCost", () => {
+  test("keeps equity cost displays conservative while preserving FX and crypto precision", () => {
+    expect(formatMarketCost(119.3687, { assetCategory: "STK" })).toBe("119.37");
+    expect(formatMarketCost(1.084567, { isCashBalance: true })).toBe("1.084567");
+    expect(formatMarketCost(113905.720075, { assetCategory: "CRYPTO" })).toBe("113,905.720075");
+  });
+});
+
+describe("formatMarketPriceWithCurrency", () => {
+  test("renders price-like values with a symbol and variable decimals", () => {
+    expect(formatMarketPriceWithCurrency(190.25, "USD", { assetCategory: "STK" })).toBe("$190.25");
+    expect(formatMarketPriceWithCurrency(1.084567, "EUR", { isCashBalance: true })).toBe("€1.084567");
+    expect(formatMarketPriceWithCurrency(1.17364, "USD", { assetCategory: "CURRENCY" })).toBe("$1.17364");
+  });
+
+  test("preserves chart-style compact notation for large values", () => {
+    expect(formatCompactMarketPriceWithCurrency(21_970, "JPY")).toBe("¥22.0K");
+    expect(formatCompactMarketPriceWithCurrency(12_340, "HKD")).toBe("HK$12.3K");
+  });
+
+  test("formats position cost values with tighter equity precision", () => {
+    expect(formatMarketCostWithCurrency(119.3687, "HKD", { assetCategory: "STK" })).toBe("HK$119.37");
+    expect(formatMarketCostWithCurrency(50.9507, "USD", { assetCategory: "OPT", multiplier: 100 })).toBe("$50.9507");
+  });
+});

package/src/utils/market-format.ts

@@ -0,0 +1,299 @@
+import { formatCurrency } from "./format";
+
+export type AssetDisplayKind = "cash" | "crypto" | "equity" | "contract" | "other";
+
+export interface AssetDisplayContext {
+  isCashBalance?: boolean;
+  assetCategory?: string;
+  contractSecType?: string;
+  multiplier?: number;
+}
+
+export interface MarketFormatOptions extends AssetDisplayContext {
+  maxWidth?: number;
+  minimumFractionDigits?: number;
+  precisionOffset?: number;
+  priceRange?: number;
+  fixedFractionDigits?: number;
+}
+
+const CASH_TYPES = new Set(["CASH", "FX", "FOREX", "CCY", "CURRENCY", "CURRENCYPAIR"]);
+const CRYPTO_TYPES = new Set(["CRYPTO", "CRYPTOCURRENCY", "COIN", "TOKEN"]);
+const EQUITY_TYPES = new Set(["STK", "STOCK", "EQUITY", "ETF", "ETN", "ETP", "FUND", "MUTUALFUND", "CEF", "ADR"]);
+const CONTRACT_TYPES = new Set(["OPT", "OPTION", "OPTIONS", "FUT", "FUTURE", "FUTURES", "FOP"]);
+
+const currencySymbols = new Map<string, string>();
+const numberFormatters = new Map<string, Intl.NumberFormat>();
+
+function normalizeType(value?: string): string {
+  return (value ?? "").trim().toUpperCase().replace(/[\s_-]+/g, "");
+}
+
+function getNumberFormatter(
+  minimumFractionDigits: number,
+  maximumFractionDigits: number,
+  useGrouping: boolean,
+): Intl.NumberFormat {
+  const key = `${minimumFractionDigits}:${maximumFractionDigits}:${useGrouping ? 1 : 0}`;
+  let formatter = numberFormatters.get(key);
+  if (!formatter) {
+    formatter = new Intl.NumberFormat("en-US", {
+      minimumFractionDigits,
+      maximumFractionDigits,
+      useGrouping,
+    });
+    numberFormatters.set(key, formatter);
+  }
+  return formatter;
+}
+
+function getCurrencySymbol(currency: string): string {
+  const normalizedCurrency = currency.trim().toUpperCase() || "USD";
+  const cached = currencySymbols.get(normalizedCurrency);
+  if (cached) return cached;
+
+  const formatter = new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency: normalizedCurrency,
+    currencyDisplay: "symbol",
+    minimumFractionDigits: 0,
+    maximumFractionDigits: 0,
+  });
+  const symbol = formatter.formatToParts(0).find((part) => part.type === "currency")?.value ?? normalizedCurrency;
+  currencySymbols.set(normalizedCurrency, symbol);
+  return symbol;
+}
+
+function fitsWidth(text: string, maxWidth: number | undefined): boolean {
+  return maxWidth == null || text.length <= maxWidth;
+}
+
+function isEffectivelyInteger(value: number): boolean {
+  return Math.abs(value - Math.round(value)) < 1e-9;
+}
+
+function formatVariableNumber(
+  value: number,
+  maxFractionDigits: number,
+  maxWidth: number | undefined,
+  minimumFractionDigits = 0,
+): string {
+  const groupedModes = [true, false];
+
+  for (const useGrouping of groupedModes) {
+    for (let decimals = maxFractionDigits; decimals >= minimumFractionDigits; decimals -= 1) {
+      const formatter = getNumberFormatter(Math.min(minimumFractionDigits, decimals), decimals, useGrouping);
+      const formatted = formatter.format(value);
+      if (fitsWidth(formatted, maxWidth)) return formatted;
+    }
+  }
+
+  return getNumberFormatter(0, 0, false).format(value);
+}
+
+function getQuantityMaxFractionDigits(kind: AssetDisplayKind, value: number): number {
+  if (isEffectivelyInteger(value)) return 0;
+
+  switch (kind) {
+    case "cash":
+      return 6;
+    case "crypto":
+      return 8;
+    case "equity":
+      return 4;
+    case "contract":
+      return 4;
+    case "other":
+    default:
+      return 4;
+  }
+}
+
+function getBasePriceMaxFractionDigits(kind: AssetDisplayKind, value: number): number {
+  switch (kind) {
+    case "cash":
+      return 6;
+    case "crypto":
+      return 8;
+    case "equity":
+      return Math.abs(value) >= 1 ? 2 : 4;
+    case "contract":
+      return 4;
+    case "other":
+    default:
+      return Math.abs(value) >= 1 ? 2 : 4;
+  }
+}
+
+function getAdaptivePriceFractionDigits(priceRange: number | undefined, precisionOffset = 0): number | null {
+  if (priceRange === undefined || !Number.isFinite(priceRange) || priceRange <= 0) return null;
+
+  // The chart price axis renders four labels by default, so the visible range
+  // divided across three intervals is a good proxy for the current zoom step.
+  const visibleStep = priceRange / 3;
+  if (!Number.isFinite(visibleStep) || visibleStep <= 0) return null;
+
+  return Math.max(0, Math.ceil(-Math.log10(visibleStep)) + precisionOffset);
+}
+
+function getPriceMaxFractionDigits(
+  kind: AssetDisplayKind,
+  value: number,
+  priceRange: number | undefined,
+  precisionOffset: number,
+): number {
+  const baseMaxFractionDigits = kind === "other" && priceRange !== undefined
+    ? 6
+    : getBasePriceMaxFractionDigits(kind, value);
+  const adaptiveFractionDigits = getAdaptivePriceFractionDigits(priceRange, precisionOffset);
+  return adaptiveFractionDigits === null
+    ? baseMaxFractionDigits
+    : Math.min(baseMaxFractionDigits, adaptiveFractionDigits);
+}
+
+function getCostMaxFractionDigits(kind: AssetDisplayKind): number {
+  switch (kind) {
+    case "cash":
+      return 6;
+    case "crypto":
+      return 8;
+    case "contract":
+      return 4;
+    case "equity":
+      return 2;
+    case "other":
+    default:
+      return 2;
+  }
+}
+
+function compactScaledPrice(
+  value: number,
+  divisor: number,
+  suffix: string,
+  currency: string,
+  maxWidth: number | undefined,
+): string {
+  const sign = value < 0 ? "-" : "";
+  const symbol = getCurrencySymbol(currency);
+  const numericWidth = maxWidth == null
+    ? undefined
+    : Math.max(1, maxWidth - sign.length - symbol.length - suffix.length);
+  const formatted = formatVariableNumber(Math.abs(value) / divisor, 1, numericWidth, 1);
+  return `${sign}${symbol}${formatted}${suffix}`;
+}
+
+export function resolveAssetDisplayKind({
+  isCashBalance,
+  assetCategory,
+  contractSecType,
+  multiplier,
+}: AssetDisplayContext): AssetDisplayKind {
+  if (isCashBalance) return "cash";
+
+  const normalizedType = normalizeType(contractSecType || assetCategory);
+  if (CASH_TYPES.has(normalizedType) || normalizedType.includes("FOREX") || normalizedType.includes("CURRENCY")) return "cash";
+  if (CRYPTO_TYPES.has(normalizedType) || normalizedType.includes("CRYPTO")) return "crypto";
+  if (EQUITY_TYPES.has(normalizedType)) return "equity";
+  if (CONTRACT_TYPES.has(normalizedType)) return "contract";
+  if ((multiplier ?? 1) > 1) return "contract";
+  return "other";
+}
+
+export function formatMarketQuantity(value: number | undefined, options: MarketFormatOptions = {}): string {
+  if (value === undefined || value === null || Number.isNaN(value)) return "—";
+  const kind = resolveAssetDisplayKind(options);
+  const maxFractionDigits = getQuantityMaxFractionDigits(kind, value);
+  return formatVariableNumber(value, maxFractionDigits, options.maxWidth);
+}
+
+export function formatMarketPrice(value: number | undefined, options: MarketFormatOptions = {}): string {
+  if (value === undefined || value === null || Number.isNaN(value)) return "—";
+  const kind = resolveAssetDisplayKind(options);
+  const fixedFractionDigits = options.fixedFractionDigits;
+  if (fixedFractionDigits !== undefined) {
+    const maxFractionDigits = kind === "other" && options.priceRange !== undefined
+      ? 6
+      : getBasePriceMaxFractionDigits(kind, value);
+    const clampedFixedFractionDigits = Math.max(0, Math.min(fixedFractionDigits, maxFractionDigits));
+    return formatVariableNumber(value, clampedFixedFractionDigits, options.maxWidth, clampedFixedFractionDigits);
+  }
+  const minimumFractionDigits = Math.max(
+    0,
+    Math.min(options.minimumFractionDigits ?? 0, getBasePriceMaxFractionDigits(kind, value)),
+  );
+  const maxFractionDigits = Math.max(
+    getPriceMaxFractionDigits(kind, value, options.priceRange, options.precisionOffset ?? 0),
+    minimumFractionDigits,
+  );
+  return formatVariableNumber(value, maxFractionDigits, options.maxWidth, minimumFractionDigits);
+}
+
+export function formatMarketCost(value: number | undefined, options: MarketFormatOptions = {}): string {
+  if (value === undefined || value === null || Number.isNaN(value)) return "—";
+  const kind = resolveAssetDisplayKind(options);
+  return formatVariableNumber(value, getCostMaxFractionDigits(kind), options.maxWidth);
+}
+
+export function formatSignedMarketPrice(value: number | undefined, options: MarketFormatOptions = {}): string {
+  if (value === undefined || value === null || Number.isNaN(value)) return "—";
+  if (value > 0) {
+    const maxWidth = options.maxWidth == null ? undefined : Math.max(1, options.maxWidth - 1);
+    return `+${formatMarketPrice(value, { ...options, maxWidth })}`;
+  }
+  return formatMarketPrice(value, options);
+}
+
+export function formatMarketPriceWithCurrency(
+  value: number | undefined,
+  currency = "USD",
+  options: MarketFormatOptions = {},
+): string {
+  if (value === undefined || value === null || Number.isNaN(value)) return "—";
+  const normalizedCurrency = currency.trim().toUpperCase() || "USD";
+  const sign = value < 0 ? "-" : "";
+  const symbol = getCurrencySymbol(normalizedCurrency);
+  const numericWidth = options.maxWidth == null
+    ? undefined
+    : Math.max(1, options.maxWidth - sign.length - symbol.length);
+  const body = formatMarketPrice(Math.abs(value), { ...options, maxWidth: numericWidth });
+  return `${sign}${symbol}${body}`;
+}
+
+export function formatMarketCostWithCurrency(
+  value: number | undefined,
+  currency = "USD",
+  options: MarketFormatOptions = {},
+): string {
+  if (value === undefined || value === null || Number.isNaN(value)) return "—";
+  const normalizedCurrency = currency.trim().toUpperCase() || "USD";
+  const sign = value < 0 ? "-" : "";
+  const symbol = getCurrencySymbol(normalizedCurrency);
+  const numericWidth = options.maxWidth == null
+    ? undefined
+    : Math.max(1, options.maxWidth - sign.length - symbol.length);
+  const body = formatMarketCost(Math.abs(value), { ...options, maxWidth: numericWidth });
+  return `${sign}${symbol}${body}`;
+}
+
+export function formatCompactMarketPriceWithCurrency(
+  value: number | undefined,
+  currency = "USD",
+  options: MarketFormatOptions = {},
+): string {
+  if (value === undefined || value === null || Number.isNaN(value)) return "—";
+  const abs = Math.abs(value);
+
+  if (abs >= 1e6) {
+    return compactScaledPrice(value, 1e6, "M", currency, options.maxWidth);
+  }
+  if (abs >= 1e3 && abs < 1e5) {
+    return compactScaledPrice(value, 1e3, "K", currency, options.maxWidth);
+  }
+
+  return formatMarketPriceWithCurrency(value, currency, options);
+}
+
+export function formatMarketMoney(value: number | undefined, currency = "USD"): string {
+  return formatCurrency(value, currency);
+}

package/src/utils/market-status.ts

@@ -1,6 +1,7 @@
 import type { MarketState, Quote, QuoteFieldProvenance } from "../types/financials";
 import { colors, priceColor } from "../theme/colors";
 import { formatPercentRaw } from "./format";
+import { formatMarketPrice } from "./market-format";
 
 export interface ActiveQuoteDisplay {
   price: number;
@@ -107,11 +108,11 @@ export function getExtendedHoursInfo(quote: Quote | null | undefined): { text: s
   if (!quote) return null;
   if ((quote.marketState === "PRE" || quote.marketState === "PREPRE") && quote.preMarketPrice != null) {
     const chg = quote.preMarketChangePercent ?? 0;
-    return { text: `Pre ${quote.preMarketPrice.toFixed(2)} ${formatPercentRaw(chg)}`, color: priceColor(chg) };
+    return { text: `Pre ${formatMarketPrice(quote.preMarketPrice)} ${formatPercentRaw(chg)}`, color: priceColor(chg) };
   }
   if ((quote.marketState === "POST" || quote.marketState === "POSTPOST") && quote.postMarketPrice != null) {
     const chg = quote.postMarketChangePercent ?? 0;
-    return { text: `AH ${quote.postMarketPrice.toFixed(2)} ${formatPercentRaw(chg)}`, color: priceColor(chg) };
+    return { text: `AH ${formatMarketPrice(quote.postMarketPrice)} ${formatPercentRaw(chg)}`, color: priceColor(chg) };
   }
   return null;
 }

package/src/utils/selection-clipboard.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, test } from "bun:test";
+import { copyActiveSelection, isCopyShortcut, isPasteShortcut } from "./selection-clipboard";
+
+describe("selection clipboard sync", () => {
+  test("copies the active selection when present", () => {
+    const renderer = {
+      copyToClipboardOSC52: (text: string) => text === "AAPL",
+      getSelection: () => ({
+        getSelectedText: () => "AAPL",
+      }),
+    };
+
+    expect(copyActiveSelection(renderer as any)).toBe(true);
+  });
+
+  test("ignores empty or missing selections", () => {
+    expect(copyActiveSelection({
+      copyToClipboardOSC52: () => true,
+      getSelection: () => null,
+    } as any)).toBe(false);
+
+    expect(copyActiveSelection({
+      copyToClipboardOSC52: () => true,
+      getSelection: () => ({
+        getSelectedText: () => "",
+      }),
+    } as any)).toBe(false);
+  });
+
+  test("matches explicit copy shortcuts only", () => {
+    expect(isCopyShortcut({ name: "c", super: true, meta: false, ctrl: false, shift: false } as any)).toBe(true);
+    expect(isCopyShortcut({ name: "c", super: false, meta: true, ctrl: false, shift: false } as any)).toBe(true);
+    expect(isCopyShortcut({ name: "c", super: false, meta: false, ctrl: true, shift: true } as any)).toBe(true);
+    expect(isCopyShortcut({ name: "c", super: false, ctrl: true, shift: false } as any)).toBe(false);
+  });
+
+  test("matches explicit paste shortcuts only", () => {
+    expect(isPasteShortcut({ name: "v", super: true, meta: false, ctrl: false, shift: false } as any)).toBe(true);
+    expect(isPasteShortcut({ name: "v", super: false, meta: true, ctrl: false, shift: false } as any)).toBe(true);
+    expect(isPasteShortcut({ name: "v", super: false, meta: false, ctrl: true, shift: true } as any)).toBe(true);
+    expect(isPasteShortcut({ name: "v", super: false, meta: false, ctrl: true, shift: false } as any)).toBe(false);
+  });
+});

package/src/utils/selection-clipboard.ts

@@ -0,0 +1,88 @@
+import type { CliRenderer, KeyEvent } from "@opentui/core";
+
+function readTextFromSystemClipboard(): string | null {
+  if (process.platform !== "darwin") {
+    return null;
+  }
+
+  try {
+    const result = Bun.spawnSync(["pbpaste"], {
+      stdout: "pipe",
+      stderr: "ignore",
+    });
+    if (!result.success) {
+      return null;
+    }
+    return result.stdout.toString().replace(/\r\n/g, "\n");
+  } catch {
+    return null;
+  }
+}
+
+function copyTextToSystemClipboard(text: string): boolean {
+  if (text.length === 0 || process.platform !== "darwin") {
+    return false;
+  }
+
+  try {
+    const result = Bun.spawnSync(["pbcopy"], {
+      stdin: new Blob([text]),
+      stdout: "ignore",
+      stderr: "ignore",
+    });
+    return result.success;
+  } catch {
+    return false;
+  }
+}
+
+export function copySelectionText(
+  renderer: Pick<CliRenderer, "copyToClipboardOSC52">,
+  text: string,
+): boolean {
+  if (text.length === 0) {
+    return false;
+  }
+
+  return renderer.copyToClipboardOSC52(text) || copyTextToSystemClipboard(text);
+}
+
+export function copyActiveSelection(
+  renderer: Pick<CliRenderer, "getSelection" | "copyToClipboardOSC52">,
+): boolean {
+  const text = renderer.getSelection()?.getSelectedText() ?? "";
+  return copySelectionText(renderer, text);
+}
+
+export function isCopyShortcut(
+  event: Pick<KeyEvent, "name" | "super" | "meta" | "ctrl" | "shift">,
+): boolean {
+  const keyName = event.name.toLowerCase();
+  return keyName === "c" && (
+    event.super === true
+    || event.meta === true
+    || (event.ctrl === true && event.shift === true)
+  );
+}
+
+export function isPasteShortcut(
+  event: Pick<KeyEvent, "name" | "super" | "meta" | "ctrl" | "shift">,
+): boolean {
+  const keyName = event.name.toLowerCase();
+  return keyName === "v" && (
+    event.super === true
+    || event.meta === true
+    || (event.ctrl === true && event.shift === true)
+  );
+}
+
+export function pasteSystemClipboard(
+  renderer: Pick<CliRenderer, "keyInput">,
+): boolean {
+  const text = readTextFromSystemClipboard();
+  if (!text) {
+    return false;
+  }
+  renderer.keyInput.processPaste(new TextEncoder().encode(text));
+  return true;
+}