termcast 1.3.53 → 1.4.0

package/src/apis/cache.tsx

@@ -1,137 +1,13 @@
-import { Database } from './sqlite'
-import * as path from 'path'
-import * as os from 'os'
-import * as fs from 'fs'
-import { logger } from '../logger'
-import { useStore } from '../state'
-
-const CACHE_TABLE_NAME = 'cache_entries'
-const DEFAULT_NAMESPACE = '__default__'
-const initializedDatabasePaths = new Set<string>()
-let logicalTimestamp = Date.now()
-
-function nextTimestamp(): number {
-  logicalTimestamp += 1
-  return logicalTimestamp
-}
-
-function getCurrentDatabasePath(): string {
-  const { extensionPath } = useStore.getState()
-  const dbSuffix = process.env.TERMCAST_DB_SUFFIX?.replace(/[^a-zA-Z0-9_-]/g, '_')
-  const dbFileName = dbSuffix ? `data-${dbSuffix}.db` : 'data.db'
-
-  if (extensionPath) {
-    return path.join(extensionPath, '.termcast-bundle', dbFileName)
-  }
-
-  // Fallback for examples/tests that don't set extensionPath
-  return path.join(os.homedir(), '.termcast', '.termcast-bundle', dbFileName)
-}
-
-function getCurrentCacheDir(namespace?: string): string {
-  const { extensionPath } = useStore.getState()
-
-  const baseDir = extensionPath
-    ? path.join(extensionPath, '.termcast-bundle', 'cache')
-    : path.join(os.homedir(), '.termcast', '.termcast-bundle', 'cache')
-
-  return namespace ? path.join(baseDir, namespace) : baseDir
-}
-
-function getNamespace(namespace?: string): string {
-  return namespace || DEFAULT_NAMESPACE
-}
-
-function initializeDatabaseOnce({ db, dbPath }: { db: Database; dbPath: string }): void {
-  if (initializedDatabasePaths.has(dbPath)) {
-    return
-  }
-
-  db.exec('PRAGMA journal_mode = WAL')
-  db.exec('PRAGMA wal_autocheckpoint = 1000')
-  db.exec('PRAGMA synchronous = NORMAL')
-
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS ${CACHE_TABLE_NAME} (
-      namespace TEXT NOT NULL,
-      key TEXT NOT NULL,
-      data TEXT NOT NULL,
-      size INTEGER NOT NULL,
-      last_accessed_at INTEGER NOT NULL,
-      updated_at INTEGER NOT NULL,
-      PRIMARY KEY(namespace, key)
-    )
-  `)
-
-  db.exec(`
-    CREATE INDEX IF NOT EXISTS idx_${CACHE_TABLE_NAME}_namespace_lru
-    ON ${CACHE_TABLE_NAME}(namespace, last_accessed_at)
-  `)
-
-  cleanupLegacyCacheTables(db)
-  initializedDatabasePaths.add(dbPath)
-}
-
-function cleanupLegacyCacheTables(db: Database): void {
-  const rows = db
-    .prepare(
-      `SELECT name FROM sqlite_master
-       WHERE type = 'table'
-         AND (name = 'cache' OR name LIKE 'cache_%')
-         AND name != ?`,
-    )
-    .all(CACHE_TABLE_NAME) as Array<{ name: string }>
-
-  if (rows.length === 0) {
-    return
-  }
-
-  const tx = db.transaction(() => {
-    const upsert = db.prepare(
-      `INSERT INTO ${CACHE_TABLE_NAME} (namespace, key, data, size, last_accessed_at, updated_at)
-       VALUES (?, ?, ?, ?, ?, ?)
-       ON CONFLICT(namespace, key)
-       DO UPDATE SET
-         data = excluded.data,
-         size = excluded.size,
-         last_accessed_at = excluded.last_accessed_at,
-         updated_at = excluded.updated_at`,
-    )
-
-    for (const { name } of rows) {
-      const namespace =
-        name === 'cache'
-          ? DEFAULT_NAMESPACE
-          : name === 'cache_tanstack_query'
-            ? 'tanstack-query'
-            : `legacy:${name.slice('cache_'.length)}`
-
-      try {
-        const values = db
-          .prepare(`SELECT key, data, size, rowid FROM ${name}`)
-          .all() as Array<{ key: string; data: string; size: number; rowid: number }>
-
-        values.forEach((entry) => {
-          const timestamp = entry.rowid
-          upsert.run(
-            namespace,
-            entry.key,
-            entry.data,
-            entry.size,
-            timestamp,
-            timestamp,
-          )
-        })
-      } catch {
-        // Ignore invalid legacy tables and continue cleanup.
-      }
-
-      db.exec(`DROP TABLE IF EXISTS ${name}`)
-    }
-  })
+/**
+ * Cache API — platform-agnostic facade.
+ *
+ * Re-exports the platform-specific Cache class from #platform/cache
+ * (SQLite on Node/Bun, IndexedDB on browser) and provides the shared
+ * `withCache` higher-order function on top.
+ */
 
-  tx()
-}
+export { Cache } from '#platform/cache'
+import { Cache } from '#platform/cache'
 
 function hashString(value: string): string {
   let hash = 0
@@ -141,246 +17,6 @@ function hashString(value: string): string {
   return Math.abs(hash).toString(36)
 }
 
-export class Cache {
-  static get STORAGE_DIRECTORY_NAME(): string {
-    const extensionPath = useStore.getState().extensionPath
-    return extensionPath ? 'cache' : '.termcast-cache'
-  }
-
-  static get DEFAULT_CAPACITY(): number {
-    return 10 * 1024 * 1024 // 10 MB
-  }
-
-  private db: Database
-  private capacity: number
-  private namespace: string
-  private subscribers: Cache.Subscriber[] = []
-  private currentSize: number = 0
-
-  constructor(options?: Cache.Options) {
-    const sqliteLoadStart = Date.now()
-    this.capacity = options?.capacity || Cache.DEFAULT_CAPACITY
-    this.namespace = getNamespace(options?.namespace)
-
-    const dbPath = getCurrentDatabasePath()
-
-    // Ensure parent directory exists
-    const dbDir = path.dirname(dbPath)
-    if (!fs.existsSync(dbDir)) {
-      fs.mkdirSync(dbDir, { recursive: true })
-    }
-
-    this.db = new Database(dbPath, {
-      create: true,
-      readwrite: true,
-    })
-
-    initializeDatabaseOnce({ db: this.db, dbPath })
-
-    // Calculate initial size
-    const row = this.db
-      .prepare(
-        `SELECT COALESCE(SUM(size), 0) as total FROM ${CACHE_TABLE_NAME} WHERE namespace = ?`,
-      )
-      .get(this.namespace) as { total: number | null } | undefined
-    this.currentSize = row?.total || 0
-
-    const sqliteLoadMs = Date.now() - sqliteLoadStart
-    if (sqliteLoadMs > 500) {
-      logger.log(
-        `[perf] sqlite cache init took ${sqliteLoadMs}ms (namespace=${this.namespace})`,
-      )
-    }
-
-    // Bind all methods to this instance
-    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)
-    this.maintainCapacity = this.maintainCapacity.bind(this)
-    this.notifySubscribers = this.notifySubscribers.bind(this)
-  }
-
-  get storageDirectory(): string {
-    return getCurrentCacheDir(this.namespace)
-  }
-
-  get(key: string): string | undefined {
-    const now = nextTimestamp()
-    const row = this.db
-      .prepare(
-        `SELECT data, size FROM ${CACHE_TABLE_NAME} WHERE namespace = ? AND key = ?`,
-      )
-      .get(this.namespace, key) as { data: string; size: number } | undefined
-
-    if (row) {
-      this.db
-        .prepare(
-          `UPDATE ${CACHE_TABLE_NAME} SET last_accessed_at = ? WHERE namespace = ? AND key = ?`,
-        )
-        .run(now, this.namespace, key)
-
-      return row.data
-    }
-
-    return undefined
-  }
-
-  has(key: string): boolean {
-    const row = this.db
-      .prepare(`SELECT 1 FROM ${CACHE_TABLE_NAME} WHERE namespace = ? AND key = ?`)
-      .get(this.namespace, key)
-    return !!row
-  }
-
-  get isEmpty(): boolean {
-    const row = this.db
-      .prepare(
-        `SELECT COUNT(*) as count FROM ${CACHE_TABLE_NAME} WHERE namespace = ?`,
-      )
-      .get(this.namespace) as { count: number }
-    return row.count === 0
-  }
-
-  set(key: string, data: string): void {
-    const now = nextTimestamp()
-    const dataSize = Buffer.byteLength(data, 'utf8')
-
-    // Get existing size if any
-    const existingRow = this.db
-      .prepare(
-        `SELECT size FROM ${CACHE_TABLE_NAME} WHERE namespace = ? AND key = ?`,
-      )
-      .get(this.namespace, key) as { size: number } | undefined
-    const oldSize = existingRow?.size || 0
-    const newTotalSize = this.currentSize - oldSize + dataSize
-
-    if (newTotalSize > this.capacity) {
-      this.maintainCapacity(newTotalSize - this.capacity)
-    }
-
-    // Insert or update the cache entry
-    this.db
-      .prepare(
-        `INSERT INTO ${CACHE_TABLE_NAME} (namespace, key, data, size, last_accessed_at, updated_at)
-         VALUES (?, ?, ?, ?, ?, ?)
-         ON CONFLICT(namespace, key)
-         DO UPDATE SET
-           data = excluded.data,
-           size = excluded.size,
-           last_accessed_at = excluded.last_accessed_at,
-           updated_at = excluded.updated_at`,
-      )
-      .run(this.namespace, key, data, dataSize, now, now)
-
-    this.currentSize = this.currentSize - oldSize + dataSize
-    this.notifySubscribers(key, data)
-  }
-
-  remove(key: string): boolean {
-    // Check if key exists and get its size
-    const row = this.db
-      .prepare(
-        `SELECT size FROM ${CACHE_TABLE_NAME} WHERE namespace = ? AND key = ?`,
-      )
-      .get(this.namespace, key) as { size: number } | undefined
-
-    if (row) {
-      // Delete the key
-      this.db
-        .prepare(`DELETE FROM ${CACHE_TABLE_NAME} WHERE namespace = ? AND key = ?`)
-        .run(this.namespace, key)
-
-      this.currentSize -= row.size
-      this.notifySubscribers(key, undefined)
-      return true
-    }
-
-    return false
-  }
-
-  clear(options?: { notifySubscribers: boolean }): void {
-    this.db
-      .prepare(`DELETE FROM ${CACHE_TABLE_NAME} WHERE namespace = ?`)
-      .run(this.namespace)
-    this.currentSize = 0
-
-    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 {
-    // Order by oldest last-access time first to evict least-recently-used rows.
-    const rows = this.db
-      .prepare(
-        `SELECT key, size FROM ${CACHE_TABLE_NAME}
-         WHERE namespace = ?
-         ORDER BY last_accessed_at ASC`,
-      )
-      .all(this.namespace) as Array<{ key: string; size: number }>
-
-    let freedBytes = 0
-    const keysToRemove: string[] = []
-
-    for (const row of rows) {
-      if (freedBytes >= bytesToFree) {
-        break
-      }
-      keysToRemove.push(row.key)
-      freedBytes += row.size
-    }
-
-    if (keysToRemove.length > 0) {
-      const placeholders = keysToRemove.map(() => '?').join(',')
-      const stmt = this.db.prepare(
-        `DELETE FROM ${CACHE_TABLE_NAME}
-         WHERE namespace = ? AND key IN (${placeholders})`,
-      )
-      stmt.run(this.namespace, ...(keysToRemove as [string, ...string[]]))
-      this.currentSize -= freedBytes
-    }
-  }
-
-  private notifySubscribers(
-    key: string | undefined,
-    data: string | undefined,
-  ): void {
-    for (const subscriber of this.subscribers) {
-      try {
-        subscriber(key, data)
-      } catch (error) {
-        logger.error('Cache subscriber error:', error)
-      }
-    }
-  }
-}
-
-export namespace Cache {
-  export interface Options {
-    namespace?: string
-    capacity?: number
-  }
-
-  export type Subscriber = (
-    key: string | undefined,
-    data: string | undefined,
-  ) => void
-  export type Subscription = () => void
-}
-
 interface CacheMetadata {
   timestamp: number
   value: any

package/src/apis/clipboard.tsx

@@ -1,43 +1,43 @@
-import type { PathLike } from 'node:fs'
-import fs from 'node:fs'
-import path from 'node:path'
-import { exec } from 'child_process'
-import { promisify } from 'util'
+import {
+  platform,
+  getEnv,
+  fileExists,
+  resolvePath,
+  copyToClipboard as platformCopy,
+  readClipboard as platformRead,
+  execCommand,
+  execWithInput,
+} from '#platform/runtime'
 import { copyToClipboard, pasteContent } from 'termcast/src/action-utils'
 import { logger } from 'termcast/src/logger'
 
-const execAsync = promisify(exec)
-const platform = process.platform
-
 async function copyFileToClipboard(filePath: string): Promise<void> {
-  const absolutePath = path.resolve(filePath)
+  const absolutePath = resolvePath(filePath)
 
-  if (process.env.VITEST) {
+  if (getEnv('VITEST')) {
     logger.log(`📋 [VITEST] Skipping copy file to clipboard: ${filePath}`)
     return
   }
 
-  if (!fs.existsSync(absolutePath)) {
+  if (!fileExists(absolutePath)) {
     throw new Error(`File not found: ${absolutePath}`)
   }
 
   try {
     if (platform === 'darwin') {
-      // macOS: Use osascript to copy file to clipboard
       const script = `osascript -e 'set the clipboard to (POSIX file "${absolutePath}")'`
-      await execAsync(script)
+      await execCommand(script)
       logger.log(`📋 Copied file to clipboard: ${filePath}`)
     } else if (platform === 'linux') {
-      // Linux: Copy file path as text and file URI
       const fileUri = `file://${absolutePath}`
-      await execAsync(
-        `echo '${fileUri}' | xclip -selection clipboard -t text/uri-list`,
+      await execWithInput(
+        'xclip -selection clipboard -t text/uri-list',
+        fileUri,
       )
       logger.log(`📋 Copied file to clipboard: ${filePath}`)
     } else if (platform === 'win32') {
-      // Windows: Use PowerShell to copy file to clipboard
       const script = `powershell -command "Set-Clipboard -Path '${absolutePath}'"`
-      await execAsync(script)
+      await execCommand(script)
       logger.log(`📋 Copied file to clipboard: ${filePath}`)
     } else {
       logger.log(`📋 File copy not supported on ${platform}: ${filePath}`)
@@ -116,24 +116,20 @@ export const Clipboard: ClipboardType = {
       let file: string | undefined
 
       if (platform === 'darwin') {
-        // Try to get file first
         try {
           const fileCheckScript = `osascript -e 'try' -e 'get the clipboard as «class furl»' -e 'POSIX path of result' -e 'end try'`
-          const { stdout: filePath } = await execAsync(fileCheckScript)
+          const filePath = await execCommand(fileCheckScript)
           if (filePath && filePath.trim()) {
             file = filePath.trim()
           }
         } catch {
-          // No file in clipboard, try text
+          // No file in clipboard
         }
 
-        // Get text content
-        const { stdout } = await execAsync('pbpaste')
-        text = stdout
+        text = await platformRead()
       } else if (platform === 'linux') {
-        // Check for file URIs
         try {
-          const { stdout: fileUri } = await execAsync(
+          const fileUri = await execCommand(
             'xclip -selection clipboard -t text/uri-list -o',
           )
           if (fileUri && fileUri.startsWith('file://')) {
@@ -143,24 +139,19 @@ export const Clipboard: ClipboardType = {
           // No file in clipboard
         }
 
-        // Get text content
         try {
-          const { stdout } = await execAsync('xclip -selection clipboard -o')
-          text = stdout
+          text = await platformRead()
         } catch {
           // No text in clipboard
         }
       } else if (platform === 'win32') {
-        // Windows: Get clipboard content
-        const { stdout } = await execAsync(
-          'powershell -command "Get-Clipboard"',
-        )
-        text = stdout
-
-        // Check if it's a file path
-        if (text && fs.existsSync(text.trim())) {
+        text = await platformRead()
+        if (text && fileExists(text.trim())) {
           file = text.trim()
         }
+      } else {
+        // browser or other
+        text = await platformRead()
       }
 
       return { text, file }
@@ -188,7 +179,7 @@ export namespace Clipboard {
         text: string
       }
     | {
-        file: PathLike
+        file: string | { href: string; toString(): string }
       }
     | {
         html: string

package/src/apis/environment.tsx

@@ -15,10 +15,17 @@
  * - System integration (selected Finder items, selected text)
  */
 
-import os from 'node:os'
-import path from 'node:path'
-import fs from 'node:fs'
-import { execSync } from 'node:child_process'
+import {
+  homedir,
+  joinPath,
+  basename,
+  platform,
+  getEnv,
+  ensureDir,
+  fileExists,
+  execCommand,
+  getSystemAppearance,
+} from '#platform/runtime'
 import { useStore } from '../state'
 
 export interface Environment {
@@ -57,28 +64,16 @@ class EnvironmentImpl implements Environment {
   }
 
   get appearance(): 'dark' | 'light' {
-    // Try to detect system theme on macOS
-    if (process.platform === 'darwin') {
-      try {
-        const result = execSync(
-          'defaults read -g AppleInterfaceStyle 2>/dev/null',
-          { encoding: 'utf8' },
-        )
-        return result.includes('Dark') ? 'dark' : 'light'
-      } catch {
-        return 'light'
-      }
-    }
-    return 'light'
+    return getSystemAppearance()
   }
 
   get assetsPath(): string {
     const state = useStore.getState()
     if (state.extensionPath) {
-      return path.join(state.extensionPath, 'assets')
+      return joinPath(state.extensionPath, 'assets')
     }
     // TODO: Fallback for non-dev mode extensions
-    return path.join(os.homedir(), '.termcast', 'assets')
+    return joinPath(homedir(), '.termcast', 'assets')
   }
 
   get commandMode(): 'view' | 'no-view' | 'menu-bar' {
@@ -108,7 +103,7 @@ class EnvironmentImpl implements Environment {
       return state.extensionPackageJson.name
     }
     if (state.extensionPath) {
-      return path.basename(state.extensionPath)
+      return basename(state.extensionPath)
     }
     return ''
   }
@@ -143,17 +138,14 @@ class EnvironmentImpl implements Environment {
 
   get supportPath(): string {
     // Create a support directory in the user's data directory
-    const baseDir = path.join(
-      os.homedir(),
+    const baseDir = joinPath(
+      homedir(),
       '.termcast',
       'support',
       this.extensionName,
     )
 
-    // Ensure the directory exists
-    if (!fs.existsSync(baseDir)) {
-      fs.mkdirSync(baseDir, { recursive: true })
-    }
+    ensureDir(baseDir)
 
     return baseDir
   }
@@ -180,18 +172,13 @@ export const environment = new EnvironmentImpl()
 // Whether the TUI is running inside a standalone desktop app built with `termcast app build`.
 // In app mode, ESC at root level does not exit the process.
 export function isAppMode(): boolean {
-  return process.env.TERMCAST_APP_MODE === '1'
+  return getEnv('TERMCAST_APP_MODE') === '1'
 }
 
 export async function getSelectedFinderItems(): Promise<string[]> {
   // TODO: Improve cross-platform support
-  // Currently only works on macOS using AppleScript
-  // Should add support for:
-  // 1. Windows Explorer selection (via PowerShell or COM)
-  // 2. Linux file managers (Nautilus, Dolphin, etc.)
-  if (process.platform === 'darwin') {
+  if (platform === 'darwin') {
     try {
-      // Use AppleScript to get selected Finder items
       const script = `
         tell application "Finder"
           set theSelection to selection
@@ -202,15 +189,12 @@ export async function getSelectedFinderItems(): Promise<string[]> {
           return thePaths
         end tell
       `
-      const result = execSync(`osascript -e '${script}'`, {
-        encoding: 'utf8',
-      })
+      const result = await execCommand(`osascript -e '${script}'`)
       return result.trim().split(', ').filter(Boolean)
     } catch {
       return []
     }
   }
-  // TODO: Implement for other platforms
   return []
 }
 
@@ -243,9 +227,9 @@ export async function launchCommand(options: LaunchOptions): Promise<void> {
     throw new Error(`Command '${options.name}' not found in extension`)
   }
 
-  const bundledPath = path.join(extensionPath, '.termcast-bundle', `${options.name}.js`)
+  const bundledPath = joinPath(extensionPath, '.termcast-bundle', `${options.name}.js`)
 
-  if (!fs.existsSync(bundledPath)) {
+  if (!fileExists(bundledPath)) {
     throw new Error(`Command '${options.name}' has not been built`)
   }
 
@@ -281,16 +265,8 @@ export async function launchCommand(options: LaunchOptions): Promise<void> {
 }
 
 export async function getSelectedText(): Promise<string> {
-  // TODO: Improve implementation and cross-platform support
-  // Current implementation has issues:
-  // 1. Modifies the clipboard (should preserve original content)
-  // 2. Uses delay which may not be reliable
-  // 3. Only works on macOS
-  // Should add support for Windows and Linux
-  if (process.platform === 'darwin') {
+  if (platform === 'darwin') {
     try {
-      // TODO: Save and restore clipboard contents to avoid side effects
-      // Use AppleScript to get selected text from frontmost application
       const script = `
         tell application "System Events"
           keystroke "c" using command down
@@ -298,14 +274,11 @@ export async function getSelectedText(): Promise<string> {
           return (the clipboard)
         end tell
       `
-      const result = execSync(`osascript -e '${script}'`, {
-        encoding: 'utf8',
-      })
+      const result = await execCommand(`osascript -e '${script}'`)
       return result.trim()
     } catch {
       return ''
     }
   }
-  // TODO: Implement for Windows (via PowerShell) and Linux (xclip/xsel)
   return ''
 }