termcast 1.3.54 → 1.4.0

package/src/utils.tsx

@@ -2,9 +2,22 @@ import React, { type ReactNode } from 'react'
 import { createRoot } from '@opentui/react'
 import { createCliRenderer } from '@opentui/core'
 import { TermcastProvider } from 'termcast/src/internal/providers'
-import path from 'node:path'
-import fs from 'node:fs'
-import os from 'node:os'
+import {
+  joinPath,
+  basename,
+  resolvePath,
+  homedir,
+  platform,
+  exit,
+  fileExists,
+  readFileSync,
+  ensureDir,
+  execCommand,
+  readdirSync,
+  rmSync,
+  mkdirSync,
+  cpSync,
+} from '#platform/runtime'
 import {
   parsePackageJson,
   type RaycastPackageJson,
@@ -14,6 +27,7 @@ import {
 import { logger } from './logger'
 import { useStore } from './state'
 import { initializeTheme } from './theme'
+import { initializeVimMode } from './vim-mode'
 import { isAppMode } from './apis/environment'
 
 export interface RenderWithProvidersOptions {
@@ -39,7 +53,7 @@ export async function renderWithProviders(
   const extensionName = options?.extensionName || 'termcast-app'
   const extensionPath =
     options?.extensionPath ||
-    path.join(os.homedir(), '.termcast', 'compiled', extensionName)
+    joinPath(homedir(), '.termcast', 'compiled', extensionName)
   const packageJson: RaycastPackageJson = options?.packageJson || {
     name: extensionName,
     title: extensionName,
@@ -55,15 +69,16 @@ export async function renderWithProviders(
     extensionPackageJson: packageJson,
   })
 
-  // 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()
 
   const renderer = await createCliRenderer({
     onDestroy: () => {
       // In app mode, destroying the renderer should not kill the process.
       // The app launcher manages the process lifecycle.
       if (!isAppMode()) {
-        process.exit(0)
+        exit(0)
       }
     },
   })
@@ -71,7 +86,7 @@ export async function renderWithProviders(
   createRoot(renderer).render(<TermcastProvider>{element}</TermcastProvider>)
 }
 
-export const termcastMaxContentWidth = 140
+export const termcastMaxContentWidth = 240
 
 export type CommonProps = {
   key?: any
@@ -92,7 +107,7 @@ export function sleep(ms: number): Promise<void> {
 }
 
 export async function getApplications(path?: PathLike): Promise<Application[]> {
-  if (process.platform !== 'darwin') {
+  if (platform !== 'darwin') {
     // Windows/Linux: return empty for now
     return []
   }
@@ -117,7 +132,7 @@ export async function getApplications(path?: PathLike): Promise<Application[]> {
       try {
         const infoPlistPath = `${appPath}/Contents/Info.plist`
 
-        if (!fs.existsSync(infoPlistPath)) {
+        if (!fileExists(infoPlistPath)) {
           continue
         }
 
@@ -164,7 +179,7 @@ export async function getDefaultApplication(
 }
 
 export async function getFrontmostApplication(): Promise<Application> {
-  if (process.platform !== 'darwin') {
+  if (platform !== 'darwin') {
     throw new Error('getFrontmostApplication is only supported on macOS')
   }
 
@@ -196,10 +211,10 @@ export async function getFrontmostApplication(): Promise<Application> {
 export async function showInFinder(path: PathLike): Promise<void> {
   const pathStr = typeof path === 'string' ? path : path.toString()
 
-  if (process.platform !== 'darwin') {
+  if (platform !== 'darwin') {
     // On non-macOS, just open the parent directory
-    const { dirname } = await import('node:path')
-    return open(dirname(pathStr))
+    const { dirname: pathDirname } = await import('node:path')
+    return open(pathDirname(pathStr))
   }
 
   const { spawn } = await import('node:child_process')
@@ -222,7 +237,7 @@ export async function trash(path: PathLike | PathLike[]): Promise<void> {
   const paths = Array.isArray(path) ? path : [path]
   const pathStrs = paths.map((p) => (typeof p === 'string' ? p : p.toString()))
 
-  if (process.platform === 'darwin') {
+  if (platform === 'darwin') {
     const { execSync } = await import('node:child_process')
 
     for (const filePath of pathStrs) {
@@ -232,7 +247,7 @@ export async function trash(path: PathLike | PathLike[]): Promise<void> {
         { stdio: 'ignore' },
       )
     }
-  } else if (process.platform === 'win32') {
+  } else if (platform === 'win32') {
     // Windows: use PowerShell to move to recycle bin
     const { execSync } = await import('node:child_process')
 
@@ -276,11 +291,11 @@ export async function open(
     let cmd: string
     let args: string[]
 
-    if (process.platform === 'darwin') {
+    if (platform === 'darwin') {
       // macOS
       cmd = 'open'
       args = appName ? ['-a', appName, target] : [target]
-    } else if (process.platform === 'win32') {
+    } else if (platform === 'win32') {
       // Windows
       cmd = 'cmd'
       args = ['/c', 'start', '', target]
@@ -304,11 +319,11 @@ export function captureException(exception: unknown): void {
 
 export function getExtensionPath(extensionName: string): string {
   const storeDir = getStoreDirectory()
-  return path.join(storeDir, extensionName)
+  return joinPath(storeDir, extensionName)
 }
 
 export function getExtensionPackageJsonPath(extensionName: string): string {
-  return path.join(getExtensionPath(extensionName), 'package.json')
+  return joinPath(getExtensionPath(extensionName), 'package.json')
 }
 
 export function getExtensionPackageJson(
@@ -316,7 +331,7 @@ export function getExtensionPackageJson(
 ): RaycastPackageJson | null {
   const packageJsonPath = getExtensionPackageJsonPath(extensionName)
 
-  if (!fs.existsSync(packageJsonPath)) {
+  if (!fileExists(packageJsonPath)) {
     return null
   }
 
@@ -394,15 +409,15 @@ export function resolveCommandPath({
   dir: string
 }): string {
   // First check for .termcast-bundle directory
-  const bundleDir = path.join(dir, '.termcast-bundle')
-  const bundledPath = path.join(bundleDir, `${commandName}.js`)
-  if (fs.existsSync(bundledPath)) {
+  const bundleDir = joinPath(dir, '.termcast-bundle')
+  const bundledPath = joinPath(bundleDir, `${commandName}.js`)
+  if (fileExists(bundledPath)) {
     return bundledPath
   }
 
   // Then check for top-level command file
-  const topLevelPath = path.join(dir, `${commandName}.js`)
-  if (fs.existsSync(topLevelPath)) {
+  const topLevelPath = joinPath(dir, `${commandName}.js`)
+  if (fileExists(topLevelPath)) {
     return topLevelPath
   }
 
@@ -411,13 +426,11 @@ export function resolveCommandPath({
 }
 
 export function getStoreDirectory(): string {
-  const homeDir = os.homedir()
-  const storeDir = path.join(homeDir, '.termcast', 'store')
+  const homeDir = homedir()
+  const storeDir = joinPath(homeDir, '.termcast', 'store')
 
   // Ensure store directory exists
-  if (!fs.existsSync(storeDir)) {
-    fs.mkdirSync(storeDir, { recursive: true })
-  }
+  ensureDir(storeDir)
 
   return storeDir
 }
@@ -430,18 +443,14 @@ export function installExtension({
   extensionSourcePath: string
 }): void {
   const storeDir = getStoreDirectory()
-  const extensionDir = path.join(storeDir, extensionName)
+  const extensionDir = joinPath(storeDir, extensionName)
 
-  // Remove existing extension directory if it exists
-  if (fs.existsSync(extensionDir)) {
-    fs.rmSync(extensionDir, { recursive: true, force: true })
+  if (fileExists(extensionDir)) {
+    rmSync(extensionDir)
   }
 
-  // Create extension directory
-  fs.mkdirSync(extensionDir, { recursive: true })
-
-  // Copy entire extension source directory
-  fs.cpSync(extensionSourcePath, extensionDir, { recursive: true })
+  mkdirSync(extensionDir)
+  cpSync(extensionSourcePath, extensionDir)
 
   logger.log(`Extension '${extensionName}' installed to ${extensionDir}`)
 }
@@ -450,19 +459,19 @@ export function getStoredExtensions(): StoredExtension[] {
   const storeDir = getStoreDirectory()
   const extensions: StoredExtension[] = []
 
-  if (!fs.existsSync(storeDir)) {
+  if (!fileExists(storeDir)) {
     return extensions
   }
 
-  const entries = fs.readdirSync(storeDir, { withFileTypes: true })
+  const entries = readdirSync(storeDir)
 
   for (const entry of entries) {
     if (!entry.isDirectory()) continue
 
-    const extensionDir = path.join(storeDir, entry.name)
-    const packageJsonPath = path.join(extensionDir, 'package.json')
+    const extensionDir = joinPath(storeDir, entry.name)
+    const packageJsonPath = joinPath(extensionDir, 'package.json')
 
-    if (!fs.existsSync(packageJsonPath)) {
+    if (!fileExists(packageJsonPath)) {
       logger.log(`Skipping ${entry.name}: no package.json found`)
       continue
     }
@@ -560,7 +569,7 @@ export async function runAppleScript<T = string>(
   arguments_?: string[],
   options?: ExecuteOptions<T>,
 ): Promise<T> {
-  if (process.platform !== 'darwin') {
+  if (platform !== 'darwin') {
     throw new Error('runAppleScript is only supported on macOS')
   }
 
@@ -821,9 +830,9 @@ export async function executeSQL<T = unknown>(
   databasePath: string,
   query: string,
 ): Promise<T[]> {
-  const { Database } = await import('./apis/sqlite')
+  const { Database } = await import('#sqlite')
 
-  if (!fs.existsSync(databasePath)) {
+  if (!fileExists(databasePath)) {
     throw new Error(`Database file not found: ${databasePath}`)
   }
 

package/src/vim-mode.tsx

@@ -0,0 +1,153 @@
+/**
+ * Vim mode persistence and command execution.
+ * Mirrors theme.tsx pattern: global Cache storage (not per-extension),
+ * load/persist/initialize functions, and a command registry.
+ *
+ * Vim mode has two sub-modes (vimInputSubMode in state):
+ * - 'default': j/k navigate, textarea unfocused, keystrokes go to useKeyboard
+ * - 'search': activated by /, textarea focused, live-filtering like raycast mode
+ * - 'command': activated by : (from empty search bar), footer shows command input
+ *
+ * The ':' command system works in both raycast and vim modes. In raycast mode,
+ * ':' is intercepted when the search bar is empty via onContentChange. In vim mode,
+ * ':' is caught directly by useKeyboard since the textarea is unfocused.
+ */
+
+import { Cache } from 'termcast/src/apis/cache'
+import { useStore, type InputMode } from 'termcast/src/state'
+import { logger } from 'termcast/src/logger'
+
+const VIM_MODE_STORAGE_KEY = 'termcast.vimMode'
+
+let globalCache: Cache | null = null
+let globalCachePath: string | null = null
+
+function getGlobalCache(): Cache {
+  const currentPath = useStore.getState().extensionPath
+  if (!globalCache || currentPath !== globalCachePath) {
+    globalCache = new Cache()
+    globalCachePath = currentPath
+  }
+  return globalCache
+}
+
+export function loadPersistedInputMode(): InputMode {
+  try {
+    const stored = getGlobalCache().get(VIM_MODE_STORAGE_KEY)
+    if (stored === 'vim' || stored === 'raycast') {
+      return stored
+    }
+  } catch {
+    // Ignore errors on load
+  }
+  return 'raycast'
+}
+
+export function persistInputMode(mode: InputMode): void {
+  try {
+    getGlobalCache().set(VIM_MODE_STORAGE_KEY, mode)
+  } catch {
+    // Ignore errors on save
+  }
+}
+
+export function initializeVimMode(): void {
+  const mode = loadPersistedInputMode()
+  useStore.setState({ inputMode: mode })
+}
+
+// Command registry for ':' commands.
+// Each command has a name and an execute function.
+// Some commands need special handling by the caller (e.g. opening dialogs,
+// accessing component refs). These return their name from executeVimCommand()
+// so the caller can handle them.
+export interface VimCommand {
+  name: string
+  execute: () => void
+  // Only show this command when in a specific mode (undefined = show always)
+  showWhenMode?: InputMode
+  // Commands that need the caller to do something (open dialog, access refs)
+  // return their name from executeVimCommand() instead of handling everything here.
+  handledByCaller?: boolean
+}
+
+const VIM_COMMANDS: VimCommand[] = [
+  {
+    name: 'vim',
+    showWhenMode: 'raycast',
+    execute: () => {
+      useStore.setState({ inputMode: 'vim', vimInputSubMode: 'default', vimCommandText: '' })
+      persistInputMode('vim')
+      logger.log('Vim mode enabled')
+    },
+  },
+  {
+    name: 'theme',
+    handledByCaller: true,
+    execute: () => {
+      useStore.setState({ vimInputSubMode: 'default', vimCommandText: '' })
+    },
+  },
+  {
+    name: 'actions',
+    handledByCaller: true,
+    execute: () => {
+      useStore.setState({ vimInputSubMode: 'default', vimCommandText: '' })
+    },
+  },
+  {
+    name: 'filter',
+    handledByCaller: true,
+    execute: () => {
+      useStore.setState({ vimInputSubMode: 'default', vimCommandText: '' })
+    },
+  },
+  {
+    name: 'q',
+    execute: () => {
+      useStore.setState({ vimInputSubMode: 'default', vimCommandText: '' })
+      process.exit(0)
+    },
+  },
+]
+
+/**
+ * Get commands matching the current typed text, filtered by current mode.
+ */
+export function getMatchingCommands(text: string): VimCommand[] {
+  const currentMode = useStore.getState().inputMode
+  return VIM_COMMANDS.filter((cmd) => {
+    if (cmd.showWhenMode && cmd.showWhenMode !== currentMode) return false
+    if (text.length === 0) return true
+    return cmd.name.startsWith(text)
+  })
+}
+
+/**
+ * Execute a command by name.
+ * Returns the command name if it needs caller handling (e.g. 'theme', 'actions', 'filter').
+ * Returns true if the command executed fully.
+ * Returns false if no matching command was found.
+ */
+export function executeVimCommand(text: string): string | boolean {
+  const currentMode = useStore.getState().inputMode
+  const command = VIM_COMMANDS.find((cmd) => {
+    if (cmd.showWhenMode && cmd.showWhenMode !== currentMode) return false
+    return cmd.name === text
+  })
+  if (!command) return false
+  command.execute()
+  if (command.handledByCaller) return command.name
+  return true
+}
+
+/**
+ * Toggle vim mode on/off. Used by the action panel "Toggle Vim Mode" action.
+ */
+export function toggleVimMode(): void {
+  const currentMode = useStore.getState().inputMode
+  const newMode: InputMode = currentMode === 'vim' ? 'raycast' : 'vim'
+  useStore.setState({ inputMode: newMode, vimInputSubMode: 'default', vimCommandText: '' })
+  persistInputMode(newMode)
+  logger.log(`Input mode: ${newMode}`)
+}

package/src/apis/sqlite.ts

@@ -1,14 +0,0 @@
-/**
- * SQLite abstraction layer — swap engine by toggling the commented block.
- * To use libsql: `bun add libsql`, comment bun:sqlite, uncomment libsql.
- */
-
-// ── bun:sqlite ─────────────────────────────────────────────────────
-import { Database } from 'bun:sqlite'
-export { Database }
-
-// ── libsql (better-sqlite3 compatible, works on Node/Bun/Deno) ────
-// import type LibsqlType from 'libsql'
-// import LibsqlDatabase from 'libsql'
-// export type Database = LibsqlType.Database
-// export const Database: new (path: string, options?: LibsqlType.Options) => Database = LibsqlDatabase