termcast 1.3.54 → 1.4.1

package/src/logger.tsx

@@ -1,13 +1,28 @@
-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')
+const isDebugLoggingEnabled = getEnv('TERMCAST_DEBUG') === '1'
 
-// Delete log file on process start
-if (fs.existsSync(LOG_FILE)) {
-  fs.unlinkSync(LOG_FILE)
+if (isDebugLoggingEnabled) {
+  // Delete log file on process start
+  unlinkIfExists(LOG_FILE)
+}
+
+function appendLogEntry(logEntry: string): void {
+  if (!isDebugLoggingEnabled) {
+    return
+  }
+  appendToFile(LOG_FILE, logEntry)
 }
 
 function serialize(msg: any): string {
@@ -17,7 +32,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 +40,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)
+    appendLogEntry(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)
+    appendLogEntry(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)
+    appendLogEntry(logEntry)
     console.warn(...messages)
   },
   trace: (...messages: any[]) => {
@@ -54,41 +69,33 @@ export const logger = {
     }
     const formattedMessages = messages.map(serialize).join(' ')
     const logEntry = `[${timestamp}] TRACE: ${formattedMessages}\n${stack}\n`
-    fs.appendFileSync(LOG_FILE, logEntry)
+    appendLogEntry(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
+}

package/src/platform/browser/localstorage.ts

@@ -0,0 +1,119 @@
+/**
+ * Browser LocalStorage implementation backed by window.localStorage.
+ *
+ * Values are stored as JSON objects with type metadata to preserve
+ * number/boolean types across serialization, matching the SQLite
+ * implementation's behavior.
+ */
+
+const PREFIX = 'termcast:'
+
+interface StoredEntry {
+  value: string
+  type: string
+}
+
+export namespace LocalStorage {
+  export type Value = string | number | boolean
+
+  export interface Values {
+    [key: string]: any
+  }
+
+  export async function getItem<T extends Value = Value>(
+    key: string,
+  ): Promise<T | undefined> {
+    return getItemSync<T>(key)
+  }
+
+  export function getItemSync<T extends Value = Value>(
+    key: string,
+  ): T | undefined {
+    try {
+      const raw = window.localStorage.getItem(PREFIX + key)
+      if (raw === null) return undefined
+
+      const entry: StoredEntry = JSON.parse(raw)
+
+      let value: Value
+      switch (entry.type) {
+        case 'number':
+          value = parseFloat(entry.value)
+          break
+        case 'boolean':
+          value = entry.value === 'true'
+          break
+        default:
+          value = entry.value
+      }
+
+      return value as T
+    } catch {
+      return undefined
+    }
+  }
+
+  export async function setItem(key: string, value: Value): Promise<void> {
+    try {
+      const entry: StoredEntry = {
+        value: String(value),
+        type: typeof value,
+      }
+      window.localStorage.setItem(PREFIX + key, JSON.stringify(entry))
+    } catch {
+      // localStorage might be full or disabled
+    }
+  }
+
+  export async function removeItem(key: string): Promise<void> {
+    window.localStorage.removeItem(PREFIX + key)
+  }
+
+  export async function allItems<T extends Values = Values>(): Promise<T> {
+    const result: Values = {}
+
+    for (let i = 0; i < window.localStorage.length; i++) {
+      const fullKey = window.localStorage.key(i)
+      if (!fullKey?.startsWith(PREFIX)) continue
+
+      const key = fullKey.slice(PREFIX.length)
+      const raw = window.localStorage.getItem(fullKey)
+      if (raw === null) continue
+
+      try {
+        const entry: StoredEntry = JSON.parse(raw)
+
+        let value: Value
+        switch (entry.type) {
+          case 'number':
+            value = parseFloat(entry.value)
+            break
+          case 'boolean':
+            value = entry.value === 'true'
+            break
+          default:
+            value = entry.value
+        }
+
+        result[key] = value
+      } catch {
+        // Skip corrupted entries
+      }
+    }
+
+    return result as T
+  }
+
+  export async function clear(): Promise<void> {
+    const keysToRemove: string[] = []
+    for (let i = 0; i < window.localStorage.length; i++) {
+      const fullKey = window.localStorage.key(i)
+      if (fullKey?.startsWith(PREFIX)) {
+        keysToRemove.push(fullKey)
+      }
+    }
+    for (const key of keysToRemove) {
+      window.localStorage.removeItem(key)
+    }
+  }
+}