termcast 1.3.54 → 1.4.0

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)
+    }
+  }
+}

package/src/platform/browser/runtime.ts

@@ -0,0 +1,209 @@
+/**
+ * Browser platform runtime.
+ *
+ * Provides the same exports as the Node runtime but backed by browser APIs
+ * or sensible no-ops for features that don't exist in the browser.
+ */
+
+// ── filesystem (no-ops / stubs) ─────────────────────────────────────
+
+export function ensureDir(_dir: string): void {
+  // no-op: browser storage (IndexedDB) doesn't need directory creation
+}
+
+export function fileExists(_p: string): boolean {
+  return false
+}
+
+export function readFileSync(_p: string): string {
+  throw new Error('readFileSync is not available in the browser')
+}
+
+export function appendToFile(_p: string, _data: string): void {
+  // no-op: browser logger uses console only
+}
+
+export function unlinkIfExists(_p: string): void {
+  // no-op
+}
+
+export function readdirSync(_dir: string): Array<{ name: string; isDirectory(): boolean }> {
+  return []
+}
+
+export function rmSync(_p: string): void {
+  // no-op
+}
+
+export function mkdirSync(_dir: string): void {
+  // no-op
+}
+
+export function cpSync(_src: string, _dest: string): void {
+  throw new Error('cpSync is not available in the browser')
+}
+
+// ── async filesystem ────────────────────────────────────────────────
+
+export async function readdirAsync(_dir: string): Promise<Array<{ name: string; isDirectory(): boolean }>> {
+  return []
+}
+
+export async function accessAsync(_p: string): Promise<boolean> {
+  return false
+}
+
+// ── path (pure string ops) ──────────────────────────────────────────
+
+export function joinPath(...parts: string[]): string {
+  return parts
+    .filter(Boolean)
+    .join('/')
+    .replace(/\/+/g, '/')
+}
+
+export function dirname(p: string): string {
+  const parts = p.split('/')
+  parts.pop()
+  return parts.join('/') || '/'
+}
+
+export function basename(p: string): string {
+  return p.split('/').pop() || ''
+}
+
+export function resolvePath(...parts: string[]): string {
+  return joinPath(...parts)
+}
+
+export function isAbsolute(p: string): boolean {
+  return p.startsWith('/')
+}
+
+export function relativePath(from: string, to: string): string {
+  const fromParts = from.split('/').filter(Boolean)
+  const toParts = to.split('/').filter(Boolean)
+  let common = 0
+  while (common < fromParts.length && common < toParts.length && fromParts[common] === toParts[common]) {
+    common++
+  }
+  const ups = fromParts.length - common
+  return [...Array(ups).fill('..'), ...toParts.slice(common)].join('/')
+}
+
+// ── os ──────────────────────────────────────────────────────────────
+
+export function homedir(): string {
+  return '/home'
+}
+
+// ── process ─────────────────────────────────────────────────────────
+
+export const platform = 'browser'
+
+export function exit(_code?: number): void {
+  // no-op: can't exit the browser
+}
+
+export function getEnv(key: string): string | undefined {
+  // Browser env can be populated by the host app before boot
+  return (globalThis as any).__termcast_env?.[key]
+}
+
+export function setEnv(key: string, value: string): void {
+  const g = globalThis as any
+  if (!g.__termcast_env) {
+    g.__termcast_env = {}
+  }
+  g.__termcast_env[key] = value
+}
+
+export function cwd(): string {
+  return '/'
+}
+
+export function stdoutWrite(_data: string): void {
+  // no-op: browser renderer handles output
+}
+
+export function isTTY(): boolean {
+  return false
+}
+
+export function getArgv(): string[] {
+  return []
+}
+
+// ── appearance ──────────────────────────────────────────────────────
+
+export function getSystemAppearance(): 'dark' | 'light' {
+  if (typeof window !== 'undefined' && window.matchMedia?.('(prefers-color-scheme: dark)').matches) {
+    return 'dark'
+  }
+  return 'light'
+}
+
+// ── util ────────────────────────────────────────────────────────────
+
+export function byteLength(str: string): number {
+  return new TextEncoder().encode(str).length
+}
+
+export function inspectValue(val: unknown, _depth = 3): string {
+  if (typeof val === 'string') {
+    return val
+  }
+  try {
+    return JSON.stringify(val, null, 2)
+  } catch {
+    return String(val)
+  }
+}
+
+// ── error handling ──────────────────────────────────────────────────
+
+export function setupErrorHandlers(handler: (err: Error, type: string) => void): void {
+  window.addEventListener('error', (event) => {
+    handler(event.error ?? new Error(event.message), 'uncaughtException')
+  })
+  window.addEventListener('unhandledrejection', (event) => {
+    const err = event.reason instanceof Error
+      ? event.reason
+      : new Error(String(event.reason))
+    handler(err, 'unhandledRejection')
+  })
+}
+
+// ── shell / clipboard ───────────────────────────────────────────────
+
+export function execWithInput(_command: string, _input: string): Promise<void> {
+  return Promise.reject(new Error('execWithInput is not available in the browser'))
+}
+
+export async function execCommand(_command: string): Promise<string> {
+  throw new Error('execCommand is not available in the browser')
+}
+
+export async function copyToClipboard(text: string): Promise<void> {
+  await navigator.clipboard.writeText(text)
+}
+
+export async function readClipboard(): Promise<string> {
+  return navigator.clipboard.readText()
+}
+
+export async function openUrl(url: string): Promise<void> {
+  window.open(url, '_blank')
+}
+
+export async function openFile(_target: string, _app?: string): Promise<void> {
+  throw new Error('openFile is not supported in the browser')
+}
+
+export async function showInFileManager(_filePath: string): Promise<void> {
+  throw new Error('showInFileManager is not supported in the browser')
+}
+
+export async function moveToTrash(_filePath: string): Promise<void> {
+  throw new Error('moveToTrash is not supported in the browser')
+}

package/src/platform/bun/sqlite.ts

@@ -0,0 +1,19 @@
+/**
+ * SQLite Database for Bun — re-exports the built-in bun:sqlite.
+ */
+
+import { Database as BunDatabase } from 'bun:sqlite'
+
+export const Database = BunDatabase
+
+/** Instance type returned by `new Database(...)` */
+export type DatabaseInstance = {
+  exec(sql: string): void
+  prepare(sql: string): {
+    get(...params: any[]): any
+    all(...params: any[]): any[]
+    run(...params: any[]): any
+  }
+  transaction<T>(fn: () => T): () => T
+  close(): void
+}