termcast 1.3.53 → 1.4.0

package/src/examples/table-flex-grow.vitest.tsx

@@ -40,18 +40,18 @@ test('flexGrow table fills remaining space next to fixed-width label', async ()
 
         With flexGrow=1 + wrapText (fills remaining space)
 
-        Config:     Key                           Value
-                    version                       2.1.0
-                    license                       MIT
-                    author                        termcast
+        Config:     Key                         Value
+                    version                     2.1.0
+                    license                     MIT
+                    author                      termcast
 
 
         Width=auto + wrapText (content-sized, no stretch)
 
-        Config:     KeVa
-                    ve2.
-                    liMI
-                    aute
+        Config:     Key      Value
+                    version  2.1.0
+                    license  MIT
+                    author   termcast
 
 
         With flexGrow=1 no wrapText (column-based)

package/src/examples/toast-action.vitest.tsx

@@ -124,7 +124,7 @@ test('pressing escape hides the toast', async () => {
 
 
 
-       ↵ show toast   ↑↓ navigate   ^k actions
+       ↵ show toast   ↑↓ navigate   ^k actions   :vim
 
 
 
@@ -238,7 +238,7 @@ test('form toast: pressing enter triggers primary action (navigation)', async ()
 
 
 
-       ↑↓ navigate   ^k actions
+       ↑↓ navigate   ^k actions   :vim
 
 
 

package/src/extensions/dev.tsx

@@ -15,6 +15,7 @@ import { TermcastProvider } from 'termcast/src/internal/providers'
 import { showToast, Toast } from 'termcast/src/apis/toast'
 import { Icon } from 'termcast'
 import { useTheme, initializeTheme } from 'termcast/src/theme'
+import { initializeVimMode } from 'termcast/src/vim-mode'
 import { logger } from '../logger'
 import { getCommandsWithFiles, CommandWithFile, RaycastPackageJson } from '../package-json'
 import { buildExtensionCommands } from '../build'
@@ -226,8 +227,9 @@ export async function startDevMode({
     devRebuildCount: 1,
   })
 
-  // Load theme after state reset — extensionPath is now set so it reads from the correct DB
+  // Load theme and vim mode after state reset — extensionPath is now set so it reads from the correct DB
   initializeTheme()
+  initializeVimMode()
 
   function App(): any {
     const devElement = useStore((state) => state.devElement)
@@ -299,8 +301,9 @@ export async function startCompiledExtension({
     devRebuildCount: 1,
   })
 
-  // Load theme after state reset — extensionPath is now set so it reads from the correct DB
+  // Load theme and vim mode after state reset — extensionPath is now set so it reads from the correct DB
   initializeTheme()
+  initializeVimMode()
 
   function App(): any {
     const devElement = useStore((state) => state.devElement)

package/src/extensions/dev.vitest.tsx

@@ -65,7 +65,7 @@ test('dev command shows extension commands list', async () => {
        Show State Shows the current application state in view
 
 
-       ↵ run command   ↑↓ navigate   ^k actions
+       ↵ run command   ↑↓ navigate   ^k actions   :vim
     "
   `)
 }, 30000)
@@ -101,7 +101,7 @@ test('selecting command with arguments shows arguments form', async () => {
 
 
 
-       ↵ run command   ↑↓ navigate   ^k actions
+       ↵ run command   ↑↓ navigate   ^k actions   :vim
     "
   `)
 
@@ -217,7 +217,7 @@ test('can fill arguments and run command', async () => {
 
 
 
-       ↵ copy value   ↑↓ navigate   ^k actions
+       ↵ copy value   ↑↓ navigate   ^k actions   :vim
     "
   `)
 }, 30000)

package/src/globals.ts

@@ -2,8 +2,9 @@
 // Set up global references for external packages
 //
 import { logger } from './logger'
+import { setEnv } from '#platform/runtime'
 
-process.env.TERMCAST = 'true'
+setEnv('TERMCAST', 'true')
 
 import * as opentuiCore from '@opentui/core'
 import * as opentuiReact from '@opentui/react'

package/src/index.tsx

@@ -86,6 +86,13 @@ export type {
   BarGraphSeriesProps,
 } from 'termcast/src/components/bar-graph'
 
+// Core UI Components - CandleChart
+export { CandleChart } from 'termcast/src/components/candle-chart'
+export type {
+  CandleChartProps,
+  CandleData,
+} from 'termcast/src/components/candle-chart'
+
 // Core UI Components - CalendarHeatmap
 export { CalendarHeatmap, Heatmap } from 'termcast/src/components/heatmap'
 export type {

package/src/internal/error-handler.tsx

@@ -1,5 +1,6 @@
 import { showFailureToast } from 'termcast/src/apis/toast'
 import { logger } from 'termcast/src/logger'
+import { setupErrorHandlers } from '#platform/runtime'
 
 let initialized = false
 
@@ -7,26 +8,23 @@ export function initializeErrorHandlers(): void {
   if (initialized) return
   initialized = true
 
-  process.on('unhandledRejection', (reason) => {
-    const err = reason instanceof Error ? reason : new Error(String(reason))
-    logger.error('Unhandled rejection:', err)
-    showFailureToast(err, {
-      title: 'Unhandled Promise Rejection',
-    }).catch((toastErr) => {
-      logger.error('Failed to show toast for unhandled rejection:', toastErr)
-    })
-  })
-
-  process.on('uncaughtException', (err) => {
-    logger.error('Uncaught exception:', err)
-    showFailureToast(err, {
-      title: 'Uncaught Exception',
-    }).catch((toastErr) => {
-      logger.error('Failed to show toast for uncaught exception:', toastErr)
-    })
-  })
-
-  process.on('uncaughtExceptionMonitor', (err, origin) => {
-    logger.error(`Uncaught exception from ${origin}:`, err)
+  setupErrorHandlers((err, type) => {
+    if (type === 'unhandledRejection') {
+      logger.error('Unhandled rejection:', err)
+      showFailureToast(err, {
+        title: 'Unhandled Promise Rejection',
+      }).catch((toastErr) => {
+        logger.error('Failed to show toast for unhandled rejection:', toastErr)
+      })
+    } else if (type === 'uncaughtException') {
+      logger.error('Uncaught exception:', err)
+      showFailureToast(err, {
+        title: 'Uncaught Exception',
+      }).catch((toastErr) => {
+        logger.error('Failed to show toast for uncaught exception:', toastErr)
+      })
+    } else {
+      logger.error(`Uncaught exception from ${type}:`, err)
+    }
   })
 }

package/src/internal/providers.tsx

@@ -15,6 +15,7 @@ import { useTheme } from 'termcast/src/theme'
 import { useStore } from 'termcast/src/state'
 import { useKeyboard, useRenderer } from '@opentui/react'
 import { initializeErrorHandlers } from 'termcast/src/internal/error-handler'
+import { stdoutWrite } from '#platform/runtime'
 
 import { InFocus } from './focus-context'
 import { Clipboard } from '../apis/clipboard'
@@ -150,6 +151,44 @@ export function TermcastProvider(props: ProvidersProps): any {
   const theme = useTheme()
   const renderer = useRenderer()
 
+  // TODO: Remove this when opentui adds { name: "backspace", super: true, action: "delete-to-line-start" }
+  // to defaultTextareaKeybindings in packages/core/src/renderables/Textarea.ts
+  // Translate Cmd+Backspace (kitty CSI \x1b[127;9u) to Ctrl+U (\x15) so opentui's
+  // textarea keybinding for delete-to-line-start handles it. opentui doesn't have a
+  // super+backspace binding, so we remap at the input level before key dispatch.
+  React.useLayoutEffect(() => {
+    if (!renderer) return
+    const handler = (sequence: string) => {
+      if (sequence === '\x1b[127;9u') {
+        renderer.stdin.emit('data', '\x15')
+        return true
+      }
+      return false
+    }
+    renderer.prependInputHandler(handler)
+    return () => {
+      renderer.removeInputHandler(handler)
+    }
+  }, [renderer])
+
+  // Sync terminal background with the active termcast theme via OSC 11 (standard escape
+  // sequence to set terminal background color). This works on WezTerm, iTerm2, kitty, etc.
+  // WezTerm's set_config_overrides for colors has a bug (#5451) where it only hot-reloads
+  // non-focused windows, so we use OSC 11 instead which updates immediately.
+  // Uses renderer's realStdoutWrite to bypass opentui's stdout interception.
+  React.useLayoutEffect(() => {
+    if (!renderer) return
+    // OSC 11 ; color ST — sets terminal default background color
+    const sequence = `\x1b]11;${theme.background}\x07`
+    const realWrite = (renderer as any).realStdoutWrite as typeof process.stdout.write | undefined
+    if (realWrite) {
+      // realStdoutWrite needs process.stdout as `this` context
+      realWrite.call(process.stdout, sequence)
+    } else {
+      stdoutWrite(sequence)
+    }
+  }, [renderer, theme.background])
+
   useKeyboard((key) => {
     if (!renderer) return
     if (key.ctrl && key.name === 'd') {

package/src/logger.tsx

@@ -1,14 +1,19 @@
-import * as fs from 'fs'
-import * as path from 'path'
-import util from 'node:util'
+import {
+  joinPath,
+  cwd,
+  unlinkIfExists,
+  appendToFile,
+  inspectValue,
+  getEnv,
+  exit,
+  setupErrorHandlers,
+} from '#platform/runtime'
 import { useEffect } from 'react'
 
-const LOG_FILE = path.join(process.cwd(), 'app.log')
+const LOG_FILE = joinPath(cwd(), 'app.log')
 
 // Delete log file on process start
-if (fs.existsSync(LOG_FILE)) {
-  fs.unlinkSync(LOG_FILE)
-}
+unlinkIfExists(LOG_FILE)
 
 function serialize(msg: any): string {
   if (msg instanceof Error) {
@@ -17,7 +22,7 @@ function serialize(msg: any): string {
   if (typeof msg === 'string') {
     return msg
   }
-  return util.inspect(msg, { depth: 3 })
+  return inspectValue(msg, 3)
 }
 
 export const logger = {
@@ -25,21 +30,21 @@ export const logger = {
     const timestamp = new Date().toISOString()
     const formattedMessages = messages.map(serialize).join(' ')
     const logEntry = `[${timestamp}] ${formattedMessages}\n`
-    fs.appendFileSync(LOG_FILE, logEntry)
+    appendToFile(LOG_FILE, logEntry)
     console.log(...messages)
   },
   error: (...messages: any[]) => {
     const timestamp = new Date().toISOString()
     const formattedMessages = messages.map(serialize).join(' ')
     const logEntry = `[${timestamp}] ERROR: ${formattedMessages}\n`
-    fs.appendFileSync(LOG_FILE, logEntry)
+    appendToFile(LOG_FILE, logEntry)
     console.error(...messages)
   },
   warn: (...messages: any[]) => {
     const timestamp = new Date().toISOString()
     const formattedMessages = messages.map(serialize).join(' ')
     const logEntry = `[${timestamp}] WARN: ${formattedMessages}\n`
-    fs.appendFileSync(LOG_FILE, logEntry)
+    appendToFile(LOG_FILE, logEntry)
     console.warn(...messages)
   },
   trace: (...messages: any[]) => {
@@ -54,41 +59,33 @@ export const logger = {
     }
     const formattedMessages = messages.map(serialize).join(' ')
     const logEntry = `[${timestamp}] TRACE: ${formattedMessages}\n${stack}\n`
-    fs.appendFileSync(LOG_FILE, logEntry)
+    appendToFile(LOG_FILE, logEntry)
     console.trace(...messages)
   },
 }
 
 // Catch unhandled errors and exceptions
-process.on('uncaughtException', (error: Error) => {
-  if (error instanceof Error) {
-    logger.error('Uncaught Exception:', error.message, error.stack)
-  } else {
-    logger.error('Uncaught Exception:', serialize(error))
-  }
-  // In app mode, don't exit on uncaught exceptions — the error boundary
-  // will catch React errors, and crashing the whole app is worse than
-  // a broken screen the user can recover from.
-  if (process.env.TERMCAST_APP_MODE !== '1') {
-    process.exit(1)
-  }
-})
-
-process.on('unhandledRejection', async (reason: any, promise: Promise<any>) => {
-  if (reason instanceof Error) {
-    logger.error(
-      'Unhandled Rejection at:',
-      promise,
-      'reason:',
-      reason.message,
-      reason.stack,
-    )
+setupErrorHandlers((error, type) => {
+  if (type === 'uncaughtException') {
+    if (error instanceof Error) {
+      logger.error('Uncaught Exception:', error.message, error.stack)
+    } else {
+      logger.error('Uncaught Exception:', serialize(error))
+    }
+    // In app mode, don't exit on uncaught exceptions — the error boundary
+    // will catch React errors, and crashing the whole app is worse than
+    // a broken screen the user can recover from.
+    if (getEnv('TERMCAST_APP_MODE') !== '1') {
+      exit(1)
+    }
+  } else if (type === 'unhandledRejection') {
+    if (error instanceof Error) {
+      logger.error('Unhandled Rejection:', error.message, error.stack)
+    } else {
+      logger.error('Unhandled Rejection:', serialize(error))
+    }
   } else {
-    logger.error(
-      'Unhandled Rejection at:',
-      promise,
-      'reason:',
-      serialize(reason),
-    )
+    // uncaughtExceptionMonitor
+    logger.error(`Uncaught exception from ${type}:`, error)
   }
 })

package/src/platform/browser/cache.ts

@@ -0,0 +1,327 @@
+/**
+ * Browser Cache implementation backed by IndexedDB with in-memory Map for sync reads.
+ *
+ * On construction, all entries for the namespace are loaded into a Map.
+ * Sync reads (get, has, isEmpty) hit the Map.
+ * Writes update both the Map and IndexedDB (fire-and-forget).
+ * LRU eviction is done in-memory.
+ */
+
+import { byteLength } from '#platform/runtime'
+
+const DB_NAME = 'termcast-cache'
+const STORE_NAME = 'cache_entries'
+const DB_VERSION = 1
+const DEFAULT_NAMESPACE = '__default__'
+
+interface CacheEntry {
+  namespace: string
+  key: string
+  data: string
+  size: number
+  last_accessed_at: number
+  updated_at: number
+}
+
+// Shared IDB connection — lazily opened, reused across Cache instances
+let dbPromise: Promise<IDBDatabase> | null = null
+
+function openDB(): Promise<IDBDatabase> {
+  if (dbPromise) return dbPromise
+
+  dbPromise = new Promise<IDBDatabase>((resolve, reject) => {
+    const request = indexedDB.open(DB_NAME, DB_VERSION)
+
+    request.onupgradeneeded = () => {
+      const db = request.result
+      if (!db.objectStoreNames.contains(STORE_NAME)) {
+        const store = db.createObjectStore(STORE_NAME, {
+          keyPath: ['namespace', 'key'],
+        })
+        store.createIndex('by_namespace', 'namespace', { unique: false })
+        store.createIndex('by_lru', ['namespace', 'last_accessed_at'], {
+          unique: false,
+        })
+      }
+    }
+
+    request.onsuccess = () => {
+      resolve(request.result)
+    }
+    request.onerror = () => {
+      reject(request.error)
+    }
+  })
+
+  return dbPromise
+}
+
+// Load all entries for a namespace into memory (called once per Cache instance)
+async function loadNamespace(namespace: string): Promise<Map<string, CacheEntry>> {
+  const db = await openDB()
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(STORE_NAME, 'readonly')
+    const store = tx.objectStore(STORE_NAME)
+    const index = store.index('by_namespace')
+    const request = index.getAll(namespace)
+
+    request.onsuccess = () => {
+      const map = new Map<string, CacheEntry>()
+      for (const entry of request.result as CacheEntry[]) {
+        map.set(entry.key, entry)
+      }
+      resolve(map)
+    }
+    request.onerror = () => {
+      reject(request.error)
+    }
+  })
+}
+
+async function idbPut(entry: CacheEntry): Promise<void> {
+  const db = await openDB()
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(STORE_NAME, 'readwrite')
+    const store = tx.objectStore(STORE_NAME)
+    const request = store.put(entry)
+    request.onsuccess = () => {
+      resolve()
+    }
+    request.onerror = () => {
+      reject(request.error)
+    }
+  })
+}
+
+async function idbDelete(namespace: string, key: string): Promise<void> {
+  const db = await openDB()
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(STORE_NAME, 'readwrite')
+    const store = tx.objectStore(STORE_NAME)
+    const request = store.delete([namespace, key])
+    request.onsuccess = () => {
+      resolve()
+    }
+    request.onerror = () => {
+      reject(request.error)
+    }
+  })
+}
+
+async function idbClearNamespace(namespace: string): Promise<void> {
+  const db = await openDB()
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(STORE_NAME, 'readwrite')
+    const store = tx.objectStore(STORE_NAME)
+    const index = store.index('by_namespace')
+    const request = index.openCursor(namespace)
+
+    request.onsuccess = () => {
+      const cursor = request.result
+      if (cursor) {
+        cursor.delete()
+        cursor.continue()
+      } else {
+        resolve()
+      }
+    }
+    request.onerror = () => {
+      reject(request.error)
+    }
+  })
+}
+
+let logicalTimestamp = Date.now()
+function nextTimestamp(): number {
+  logicalTimestamp += 1
+  return logicalTimestamp
+}
+
+export class Cache {
+  static get STORAGE_DIRECTORY_NAME(): string {
+    return 'cache'
+  }
+
+  static get DEFAULT_CAPACITY(): number {
+    return 10 * 1024 * 1024 // 10 MB
+  }
+
+  private entries: Map<string, CacheEntry> = new Map()
+  private capacity: number
+  private namespace: string
+  private subscribers: Cache.Subscriber[] = []
+  private currentSize: number = 0
+  private initialized: boolean = false
+
+  constructor(options?: Cache.Options) {
+    this.capacity = options?.capacity || Cache.DEFAULT_CAPACITY
+    this.namespace = options?.namespace || DEFAULT_NAMESPACE
+
+    // Kick off async load — sync reads return undefined until loaded
+    this.init()
+
+    // Bind all methods
+    this.get = this.get.bind(this)
+    this.has = this.has.bind(this)
+    this.set = this.set.bind(this)
+    this.remove = this.remove.bind(this)
+    this.clear = this.clear.bind(this)
+    this.subscribe = this.subscribe.bind(this)
+  }
+
+  private async init(): Promise<void> {
+    try {
+      const loaded = await loadNamespace(this.namespace)
+      // Merge: keep in-memory writes that happened during async load,
+      // preferring the newer entry (by updated_at) on key conflicts.
+      for (const [key, inMemoryEntry] of this.entries) {
+        const loadedEntry = loaded.get(key)
+        if (!loadedEntry || inMemoryEntry.updated_at >= loadedEntry.updated_at) {
+          loaded.set(key, inMemoryEntry)
+        }
+      }
+      this.entries = loaded
+      this.currentSize = 0
+      for (const entry of this.entries.values()) {
+        this.currentSize += entry.size
+      }
+      this.initialized = true
+    } catch {
+      // IndexedDB might not be available (e.g. incognito with restrictions)
+      this.initialized = true
+    }
+  }
+
+  get storageDirectory(): string {
+    return `/termcast/cache/${this.namespace}`
+  }
+
+  get(key: string): string | undefined {
+    const entry = this.entries.get(key)
+    if (!entry) return undefined
+
+    // Update LRU timestamp in-memory and async in IDB
+    const now = nextTimestamp()
+    entry.last_accessed_at = now
+    idbPut(entry).catch(() => {})
+
+    return entry.data
+  }
+
+  has(key: string): boolean {
+    return this.entries.has(key)
+  }
+
+  get isEmpty(): boolean {
+    return this.entries.size === 0
+  }
+
+  set(key: string, data: string): void {
+    const now = nextTimestamp()
+    const dataSize = byteLength(data)
+
+    const existing = this.entries.get(key)
+    const oldSize = existing?.size || 0
+    const newTotalSize = this.currentSize - oldSize + dataSize
+
+    if (newTotalSize > this.capacity) {
+      this.maintainCapacity(newTotalSize - this.capacity)
+    }
+
+    const entry: CacheEntry = {
+      namespace: this.namespace,
+      key,
+      data,
+      size: dataSize,
+      last_accessed_at: now,
+      updated_at: now,
+    }
+
+    this.entries.set(key, entry)
+    this.currentSize = this.currentSize - oldSize + dataSize
+
+    // Persist async
+    idbPut(entry).catch(() => {})
+
+    this.notifySubscribers(key, data)
+  }
+
+  remove(key: string): boolean {
+    const entry = this.entries.get(key)
+    if (!entry) return false
+
+    this.entries.delete(key)
+    this.currentSize -= entry.size
+
+    // Persist async
+    idbDelete(this.namespace, key).catch(() => {})
+
+    this.notifySubscribers(key, undefined)
+    return true
+  }
+
+  clear(options?: { notifySubscribers: boolean }): void {
+    this.entries.clear()
+    this.currentSize = 0
+
+    // Persist async
+    idbClearNamespace(this.namespace).catch(() => {})
+
+    if (options?.notifySubscribers !== false) {
+      this.notifySubscribers(undefined, undefined)
+    }
+  }
+
+  subscribe(subscriber: Cache.Subscriber): Cache.Subscription {
+    this.subscribers.push(subscriber)
+    return () => {
+      const index = this.subscribers.indexOf(subscriber)
+      if (index > -1) {
+        this.subscribers.splice(index, 1)
+      }
+    }
+  }
+
+  private maintainCapacity(bytesToFree: number): void {
+    // Sort by LRU — oldest first
+    const sorted = [...this.entries.values()].sort(
+      (a, b) => a.last_accessed_at - b.last_accessed_at,
+    )
+
+    let freedBytes = 0
+    for (const entry of sorted) {
+      if (freedBytes >= bytesToFree) break
+      this.entries.delete(entry.key)
+      freedBytes += entry.size
+      // Persist async
+      idbDelete(this.namespace, entry.key).catch(() => {})
+    }
+    this.currentSize -= freedBytes
+  }
+
+  private notifySubscribers(
+    key: string | undefined,
+    data: string | undefined,
+  ): void {
+    for (const subscriber of this.subscribers) {
+      try {
+        subscriber(key, data)
+      } catch {
+        // Ignore subscriber errors in browser
+      }
+    }
+  }
+}
+
+export namespace Cache {
+  export interface Options {
+    namespace?: string
+    capacity?: number
+  }
+
+  export type Subscriber = (
+    key: string | undefined,
+    data: string | undefined,
+  ) => void
+  export type Subscription = () => void
+}