termcast 1.3.54 → 1.4.1

package/src/platform/node/localstorage.ts

@@ -0,0 +1,214 @@
+/**
+ * Node/Bun LocalStorage implementation backed by SQLite.
+ * Moved from apis/localstorage.tsx.
+ */
+
+import { Database, type DatabaseInstance } from '#sqlite'
+import { joinPath, dirname, ensureDir } from '#platform/runtime'
+import { logger } from '../../logger'
+import { useStore } from '../../state'
+
+let db: DatabaseInstance | null = null
+let currentDbPath: string | null = null
+
+function getCurrentDatabasePath(): string {
+  const { extensionPath } = useStore.getState()
+
+  if (!extensionPath) {
+    throw new Error('Cannot access LocalStorage - extensionPath not set')
+  }
+
+  return joinPath(extensionPath, '.termcast-bundle', 'data.db')
+}
+
+function getDatabase(): DatabaseInstance {
+  const dbPath = getCurrentDatabasePath()
+
+  // Check if we need to reconnect due to path change
+  if (db && currentDbPath !== dbPath) {
+    db.close()
+    db = null
+    currentDbPath = null
+  }
+
+  if (!db) {
+    // Ensure parent directory exists
+    const dbDir = dirname(dbPath)
+    ensureDir(dbDir)
+
+    db = new Database(dbPath, {
+      create: true,
+      readwrite: true,
+    })
+    currentDbPath = dbPath
+
+    // Use WAL mode and optimize for single file usage
+    db.exec('PRAGMA journal_mode = WAL')
+    db.exec('PRAGMA wal_autocheckpoint = 1000')
+    db.exec('PRAGMA synchronous = NORMAL')
+
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS localstorage (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL,
+        type TEXT NOT NULL
+      )
+    `)
+  }
+  return db
+}
+
+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 new Promise((resolve) => {
+      try {
+        const db = getDatabase()
+        const row = db
+          .prepare('SELECT value, type FROM localstorage WHERE key = ?')
+          .get(key) as { value: string; type: string } | undefined
+
+        if (!row) {
+          resolve(undefined)
+          return
+        }
+
+        let value: Value
+        switch (row.type) {
+          case 'number':
+            value = parseFloat(row.value)
+            break
+          case 'boolean':
+            value = row.value === 'true'
+            break
+          default:
+            value = row.value
+        }
+
+        resolve(value as T)
+      } catch (err) {
+        logger.error('LocalStorage.getItem error:', err)
+        resolve(undefined)
+      }
+    })
+  }
+
+  export function getItemSync<T extends Value = Value>(
+    key: string,
+  ): T | undefined {
+    try {
+      const db = getDatabase()
+      const row = db
+        .prepare('SELECT value, type FROM localstorage WHERE key = ?')
+        .get(key) as { value: string; type: string } | undefined
+
+      if (!row) {
+        return undefined
+      }
+
+      let value: Value
+      switch (row.type) {
+        case 'number':
+          value = parseFloat(row.value)
+          break
+        case 'boolean':
+          value = row.value === 'true'
+          break
+        default:
+          value = row.value
+      }
+
+      return value as T
+    } catch (err) {
+      logger.error('LocalStorage.getItemSync error:', err)
+      return undefined
+    }
+  }
+
+  export async function setItem(key: string, value: Value): Promise<void> {
+    return new Promise((resolve, reject) => {
+      try {
+        const db = getDatabase()
+        const type = typeof value
+        const stringValue = String(value)
+
+        db.prepare(
+          'INSERT OR REPLACE INTO localstorage (key, value, type) VALUES (?, ?, ?)',
+        ).run(key, stringValue, type)
+        resolve()
+      } catch (err) {
+        logger.error('LocalStorage.setItem error:', err)
+        reject(err)
+      }
+    })
+  }
+
+  export async function removeItem(key: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      try {
+        const db = getDatabase()
+        db.prepare('DELETE FROM localstorage WHERE key = ?').run(key)
+        resolve()
+      } catch (err) {
+        logger.error('LocalStorage.removeItem error:', err)
+        reject(err)
+      }
+    })
+  }
+
+  export async function allItems<T extends Values = Values>(): Promise<T> {
+    return new Promise((resolve, reject) => {
+      try {
+        const db = getDatabase()
+        const rows = db
+          .prepare('SELECT key, value, type FROM localstorage')
+          .all() as Array<{
+          key: string
+          value: string
+          type: string
+        }>
+
+        const result: Values = {}
+        for (const row of rows) {
+          let value: Value
+          switch (row.type) {
+            case 'number':
+              value = parseFloat(row.value)
+              break
+            case 'boolean':
+              value = row.value === 'true'
+              break
+            default:
+              value = row.value
+          }
+          result[row.key] = value
+        }
+
+        resolve(result as T)
+      } catch (err) {
+        logger.error('LocalStorage.allItems error:', err)
+        reject(err)
+      }
+    })
+  }
+
+  export async function clear(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      try {
+        const db = getDatabase()
+        db.exec('DELETE FROM localstorage')
+        resolve()
+      } catch (err) {
+        logger.error('LocalStorage.clear error:', err)
+        reject(err)
+      }
+    })
+  }
+}

package/src/platform/node/runtime.ts

@@ -0,0 +1,264 @@
+/**
+ * Node.js / Bun platform runtime.
+ *
+ * Re-exports native APIs behind a platform-agnostic interface so the rest of
+ * termcast never imports node:* directly (except CLI / build tooling which is
+ * excluded from the browser bundle).
+ */
+
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+import util from 'node:util'
+import { exec as _exec } from 'node:child_process'
+import { promisify } from 'node:util'
+
+const execAsync = promisify(_exec)
+
+// ── filesystem ──────────────────────────────────────────────────────
+
+export function ensureDir(dir: string): void {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true })
+  }
+}
+
+export function fileExists(p: string): boolean {
+  return fs.existsSync(p)
+}
+
+export function readFileSync(p: string): string {
+  return fs.readFileSync(p, 'utf-8')
+}
+
+export function appendToFile(p: string, data: string): void {
+  fs.appendFileSync(p, data)
+}
+
+export function unlinkIfExists(p: string): void {
+  if (fs.existsSync(p)) {
+    fs.unlinkSync(p)
+  }
+}
+
+export function readdirSync(dir: string): Array<{ name: string; isDirectory(): boolean }> {
+  return fs.readdirSync(dir, { withFileTypes: true })
+}
+
+export function rmSync(p: string): void {
+  fs.rmSync(p, { recursive: true, force: true })
+}
+
+export function mkdirSync(dir: string): void {
+  fs.mkdirSync(dir, { recursive: true })
+}
+
+export function cpSync(src: string, dest: string): void {
+  fs.cpSync(src, dest, { recursive: true })
+}
+
+// ── async filesystem ────────────────────────────────────────────────
+
+import fsPromises from 'node:fs/promises'
+
+export async function readdirAsync(dir: string): Promise<Array<{ name: string; isDirectory(): boolean }>> {
+  return fsPromises.readdir(dir, { withFileTypes: true })
+}
+
+export async function accessAsync(p: string): Promise<boolean> {
+  try {
+    await fsPromises.access(p)
+    return true
+  } catch {
+    return false
+  }
+}
+
+// ── path ────────────────────────────────────────────────────────────
+
+export const joinPath: (...parts: string[]) => string = path.join
+export const dirname: (p: string) => string = path.dirname
+export const basename: (p: string) => string = path.basename
+export const resolvePath: (...parts: string[]) => string = path.resolve
+export const isAbsolute: (p: string) => boolean = path.isAbsolute
+export const relativePath: (from: string, to: string) => string = path.relative
+
+// ── os ──────────────────────────────────────────────────────────────
+
+export function homedir(): string {
+  return os.homedir()
+}
+
+// ── process ─────────────────────────────────────────────────────────
+
+export const platform: string = process.platform
+
+export function exit(code?: number): void {
+  process.exit(code)
+}
+
+export function getEnv(key: string): string | undefined {
+  return process.env[key]
+}
+
+export function setEnv(key: string, value: string): void {
+  process.env[key] = value
+}
+
+export function cwd(): string {
+  return process.cwd()
+}
+
+export function stdoutWrite(data: string): void {
+  process.stdout.write(data)
+}
+
+export function isTTY(): boolean {
+  return !!process.stdout.isTTY
+}
+
+export function getArgv(): string[] {
+  return process.argv
+}
+
+// ── appearance ──────────────────────────────────────────────────────
+
+export function getSystemAppearance(): 'dark' | 'light' {
+  if (process.platform !== 'darwin') {
+    return 'light'
+  }
+  try {
+    const { execFileSync } = require('node:child_process') as typeof import('node:child_process')
+    const result = execFileSync('defaults', ['read', '-g', 'AppleInterfaceStyle'], {
+      encoding: 'utf-8',
+      timeout: 500,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    })
+    return result.trim().toLowerCase() === 'dark' ? 'dark' : 'light'
+  } catch {
+    // "AppleInterfaceStyle" key doesn't exist when in light mode
+    return 'light'
+  }
+}
+
+// ── util ────────────────────────────────────────────────────────────
+
+export function byteLength(str: string): number {
+  return Buffer.byteLength(str, 'utf-8')
+}
+
+export function inspectValue(val: unknown, depth = 3): string {
+  return util.inspect(val, { depth })
+}
+
+// ── error handling ──────────────────────────────────────────────────
+
+export function setupErrorHandlers(handler: (err: Error, type: string) => void): void {
+  process.on('uncaughtException', (err) => {
+    handler(err, 'uncaughtException')
+  })
+  process.on('unhandledRejection', (reason) => {
+    handler(
+      reason instanceof Error ? reason : new Error(String(reason)),
+      'unhandledRejection',
+    )
+  })
+  process.on('uncaughtExceptionMonitor', (err, origin) => {
+    handler(err, origin)
+  })
+}
+
+// ── shell / clipboard ───────────────────────────────────────────────
+
+export function execWithInput(command: string, input: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const child = _exec(command, (error) => {
+      if (error) {
+        reject(error)
+      } else {
+        resolve()
+      }
+    })
+    child.stdin?.write(input)
+    child.stdin?.end()
+  })
+}
+
+export async function execCommand(command: string): Promise<string> {
+  const { stdout } = await execAsync(command)
+  return stdout
+}
+
+export async function copyToClipboard(text: string): Promise<void> {
+  if (process.platform === 'darwin') {
+    await execWithInput('pbcopy', text)
+  } else if (process.platform === 'linux') {
+    await execWithInput('xclip -selection clipboard', text)
+  } else if (process.platform === 'win32') {
+    await execWithInput('clip', text)
+  }
+}
+
+export async function readClipboard(): Promise<string> {
+  if (process.platform === 'darwin') {
+    return (await execAsync('pbpaste')).stdout
+  } else if (process.platform === 'linux') {
+    return (await execAsync('xclip -selection clipboard -o')).stdout
+  } else if (process.platform === 'win32') {
+    return (await execAsync('powershell -command "Get-Clipboard"')).stdout
+  }
+  return ''
+}
+
+export async function openUrl(url: string): Promise<void> {
+  if (process.platform === 'darwin') {
+    await execAsync(`open "${url}"`)
+  } else if (process.platform === 'linux') {
+    await execAsync(`xdg-open "${url}"`)
+  } else if (process.platform === 'win32') {
+    await execAsync(`start "${url}"`)
+  }
+}
+
+export async function openFile(target: string, app?: string): Promise<void> {
+  if (process.platform === 'darwin') {
+    if (app) {
+      await execAsync(`open -a "${app}" "${target}"`)
+    } else {
+      await execAsync(`open "${target}"`)
+    }
+  } else if (process.platform === 'linux') {
+    await execAsync(`xdg-open "${target}"`)
+  } else if (process.platform === 'win32') {
+    await execAsync(`start "" "${target}"`)
+  }
+}
+
+export async function showInFileManager(filePath: string): Promise<void> {
+  if (process.platform === 'darwin') {
+    await execAsync(`open -R "${filePath}"`)
+  } else if (process.platform === 'linux') {
+    await execAsync(`xdg-open "$(dirname "${filePath}")"`)
+  } else if (process.platform === 'win32') {
+    await execAsync(`explorer /select,"${filePath}"`)
+  }
+}
+
+export async function moveToTrash(filePath: string): Promise<void> {
+  if (process.platform === 'darwin') {
+    await execAsync(
+      `osascript -e 'tell application "Finder" to delete POSIX file "${filePath}"'`,
+    )
+  } else if (process.platform === 'linux') {
+    try {
+      await execAsync(`gio trash "${filePath}"`)
+    } catch {
+      const trashDir = `${os.homedir()}/.local/share/Trash/files`
+      await execAsync(`mkdir -p "${trashDir}" && mv "${filePath}" "${trashDir}/"`)
+    }
+  } else if (process.platform === 'win32') {
+    await execAsync(
+      `powershell -command "Add-Type -AssemblyName Microsoft.VisualBasic; [Microsoft.VisualBasic.FileIO.FileSystem]::DeleteFile('${filePath}','OnlyErrorDialogs','SendToRecycleBin')"`,
+    )
+  }
+}

package/src/platform/node/sqlite.ts

@@ -0,0 +1,43 @@
+/**
+ * SQLite Database for Node.js — uses better-sqlite3.
+ *
+ * Translates bun:sqlite constructor options ({ create, readwrite })
+ * to better-sqlite3 options ({ fileMustExist, readonly }).
+ * All other APIs (prepare/get/all/run/exec/transaction/close) are
+ * identical between the two libraries.
+ */
+
+import BetterSqlite3 from 'better-sqlite3'
+
+interface DatabaseOptions {
+  create?: boolean
+  readwrite?: boolean
+  readonly?: boolean
+}
+
+function NodeDatabase(path: string, options?: DatabaseOptions) {
+  const betterOpts: { fileMustExist?: boolean; readonly?: boolean } = {}
+
+  if (options?.create === false) {
+    betterOpts.fileMustExist = true
+  }
+  if (options?.readonly === true || options?.readwrite === false) {
+    betterOpts.readonly = true
+  }
+
+  return new BetterSqlite3(path, betterOpts)
+}
+
+export const Database: new (path: string, options?: DatabaseOptions) => DatabaseInstance = NodeDatabase as any
+
+/** 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
+}

package/src/state.tsx

@@ -1,4 +1,3 @@
-import fs from 'node:fs'
 import { create } from 'zustand'
 import { type ReactNode } from 'react'
 import type { TextareaRenderable } from '@opentui/core'
@@ -6,6 +5,7 @@ import type { RaycastPackageJson } from './package-json'
 import type { KeyboardKeyEquivalent, KeyboardKeyModifier } from 'termcast/src/keyboard'
 import { getResolvedTheme } from './themes'
 import { logger } from './logger'
+import { getEnv } from '#platform/runtime'
 
 // Registered action shortcuts for global keyboard handling
 // Stored by ActionPanel, consumed by List/Detail/Form keyboard handlers
@@ -52,7 +52,17 @@ export interface NavigationStackItem {
   searchText?: string
 }
 
+// Vim mode types
+// inputMode: global mode persisted across sessions
+// vimInputSubMode: transient sub-state within the current mode
+export type InputMode = 'raycast' | 'vim'
+export type VimInputSubMode = 'default' | 'search' | 'command'
+
 interface AppState {
+  // Vim mode state
+  inputMode: InputMode
+  vimInputSubMode: VimInputSubMode
+  vimCommandText: string
   toast: ToastData | null
   toastWithPrimaryAction: boolean
   dialogStack: DialogStackItem[]
@@ -96,6 +106,10 @@ interface AppState {
 }
 
 export const useStore = create<AppState>(() => ({
+  // Vim mode — initialized from persistence in initializeVimMode()
+  inputMode: 'raycast',
+  vimInputSubMode: 'default',
+  vimCommandText: '',
   toast: null,
   toastWithPrimaryAction: false,
   dialogStack: [],
@@ -120,36 +134,11 @@ export const useStore = create<AppState>(() => ({
   showActionsDialog: false,
   actionsPortalTarget: null,
   // Theme state — TERMCAST_DEFAULT_THEME env var is set by the app launcher
-  currentThemeName: process.env.TERMCAST_DEFAULT_THEME || 'nerv',
+  currentThemeName: getEnv('TERMCAST_DEFAULT_THEME') || 'nerv',
   // Active search input ref
   activeSearchInputRef: null,
   // Registered action shortcuts
   registeredActionShortcuts: [],
 }))
 
-// Sync WezTerm's window background with the active termcast theme.
-// When the theme changes, rewrite the background color in wezterm.lua.
-// WezTerm auto-reloads the config on file change, updating the window edges/padding.
-// The config path is passed from the launcher via TERMCAST_WEZTERM_CONFIG env var.
-const weztermConfigPath = process.env.TERMCAST_WEZTERM_CONFIG
-if (weztermConfigPath) {
-  useStore.subscribe((state, prevState) => {
-    if (state.currentThemeName === prevState.currentThemeName) {
-      return
-    }
-    try {
-      const theme = getResolvedTheme(state.currentThemeName)
-      const content = fs.readFileSync(weztermConfigPath, 'utf-8')
-      // Replace the background hex in: config.colors = { background = '#xxxxxx' }
-      const updated = content.replace(
-        /background\s*=\s*'#[0-9a-fA-F]{6}'/,
-        `background = '${theme.background}'`,
-      )
-      if (updated !== content) {
-        fs.writeFileSync(weztermConfigPath, updated)
-      }
-    } catch (e) {
-      logger.log('Failed to update wezterm config background:', e)
-    }
-  })
-}
+

package/src/utils/file-system.ts

@@ -1,6 +1,4 @@
-import * as fs from 'fs/promises'
-import * as path from 'path'
-import * as os from 'os'
+import { homedir, isAbsolute, resolvePath, joinPath, cwd, relativePath, readdirAsync, accessAsync } from '#platform/runtime'
 
 export interface FileSystemItem {
   name: string
@@ -26,18 +24,18 @@ export async function listAllFiles({
   
   // Resolve ~ to home directory
   if (basePath.startsWith('~')) {
-    basePath = basePath.replace('~', os.homedir())
+    basePath = basePath.replace('~', homedir())
   }
   
-  const resolvedBase = path.isAbsolute(basePath)
+  const resolvedBase = isAbsolute(basePath)
     ? basePath
-    : path.resolve(process.cwd(), basePath)
+    : resolvePath(cwd(), basePath)
 
   async function walk(dir: string, depth: number) {
     if (depth > maxDepth || results.length >= maxFiles) return
     
     try {
-      const entries = await fs.readdir(dir, { withFileTypes: true })
+      const entries = await readdirAsync(dir)
       
       for (const entry of entries) {
         if (results.length >= maxFiles) break
@@ -48,16 +46,16 @@ export async function listAllFiles({
         if (entry.name === 'dist') continue
         if (entry.name === 'build') continue
         
-        const fullPath = path.join(dir, entry.name)
-        const relativePath = path.relative(resolvedBase, fullPath)
+        const fullPath = joinPath(dir, entry.name)
+        const relPath = relativePath(resolvedBase, fullPath)
         
         if (entry.isDirectory()) {
           if (includeDirectories) {
-            results.push(relativePath + '/')
+            results.push(relPath + '/')
           }
           await walk(fullPath, depth + 1)
         } else {
-          results.push(relativePath)
+          results.push(relPath)
         }
       }
     } catch {
@@ -76,23 +74,20 @@ export async function searchFiles(
   try {
     // Resolve ~ to home directory
     if (searchPath.startsWith('~')) {
-      searchPath = searchPath.replace('~', os.homedir())
+      searchPath = searchPath.replace('~', homedir())
     }
 
     // Handle absolute vs relative paths
-    const basePath = path.isAbsolute(searchPath)
+    const basePath = isAbsolute(searchPath)
       ? searchPath
-      : path.resolve(process.cwd(), searchPath || '.')
+      : resolvePath(cwd(), searchPath || '.')
 
     // Check if directory exists
-    try {
-      await fs.access(basePath)
-    } catch {
-      return []
-    }
+    const exists = await accessAsync(basePath)
+    if (!exists) return []
 
     // List files and directories
-    const entries = await fs.readdir(basePath, { withFileTypes: true })
+    const entries = await readdirAsync(basePath)
 
     const items: FileSystemItem[] = []
 
@@ -107,7 +102,7 @@ export async function searchFiles(
       ) {
         items.push({
           name: entry.name,
-          path: path.join(basePath, entry.name),
+          path: joinPath(basePath, entry.name),
           isDirectory: entry.isDirectory(),
         })
       }
@@ -130,7 +125,7 @@ export async function searchFiles(
 export function parsePath(input: string): { basePath: string; prefix: string } {
   // Handle ~ expansion
   if (input.startsWith('~')) {
-    input = input.replace('~', os.homedir())
+    input = input.replace('~', homedir())
   }
 
   const lastSlashIndex = input.lastIndexOf('/')