termcast 1.3.53 → 1.4.0

package/src/apis/localstorage.tsx

@@ -1,214 +1,8 @@
-import { Database } from './sqlite'
-import * as path from 'path'
-import * as fs from 'fs'
-import { logger } from '../logger'
-import { useStore } from '../state'
-
-let db: Database | 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 path.join(extensionPath, '.termcast-bundle', 'data.db')
-}
-
-function getDatabase(): Database {
-  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 = path.dirname(dbPath)
-    if (!fs.existsSync(dbDir)) {
-      fs.mkdirSync(dbDir, { recursive: true })
-    }
-
-    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)
-      }
-    })
-  }
-}
+/**
+ * LocalStorage API — platform-agnostic facade.
+ *
+ * Re-exports the platform-specific LocalStorage from #platform/localstorage
+ * (SQLite on Node/Bun, window.localStorage on browser).
+ */
+
+export { LocalStorage } from '#platform/localstorage'

package/src/app.tsx

@@ -218,17 +218,47 @@ async function downloadWeztermLinux(): Promise<string> {
 
   console.log('Extracting wezterm-gui from tar.xz...')
   try {
-    // Extract wezterm-gui using wildcard match on the nested path.
-    // --strip-components=3 removes the top-level dir + usr/bin/ prefix.
+    // List archive entries first, then extract by exact path.
+    // This works on both GNU tar (Linux) and bsdtar (macOS).
+    const { stdout: entriesOutput } = await execFileAsync('tar', ['-tJf', tmpTar])
+    const archiveEntry = entriesOutput
+      .split('\n')
+      .map((entry) => {
+        return entry.trim()
+      })
+      .find((entry) => {
+        return entry.endsWith('/usr/bin/wezterm-gui')
+      })
+
+    if (!archiveEntry) {
+      const firstEntries = entriesOutput
+        .split('\n')
+        .map((entry) => {
+          return entry.trim()
+        })
+        .filter((entry) => {
+          return entry.length > 0
+        })
+        .slice(0, 20)
+        .join('\n  ')
+      throw new Error(
+        `Could not find usr/bin/wezterm-gui in Linux archive. First entries:\n  ${firstEntries}`,
+      )
+    }
+
+    const stripComponentsCount = archiveEntry.split('/').length - 1
+
+    // Removes the prefix directories (e.g. top-level dir + usr/bin/),
+    // yielding cacheDir/wezterm-gui directly.
     await execFileAsync('tar', [
       'xJf', tmpTar,
-      '--strip-components=3',
-      '--include=*/usr/bin/wezterm-gui',
+      `--strip-components=${stripComponentsCount}`,
       '-C', cacheDir,
+      archiveEntry,
     ])
   } catch (e) {
     throw new Error(
-      `Failed to extract wezterm-gui from tar.xz. Ensure tar with xz support is available.`,
+      `Failed to extract wezterm-gui from tar.xz. Ensure tar with xz support is available and functional.`,
       { cause: e },
     )
   } finally {
@@ -464,11 +494,6 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine
         if (dir[i] == L'\\\\') { dir[i + 1] = L'\\0'; break; }
     }
 
-    /* Set TERMCAST_WEZTERM_CONFIG env var so the TUI can rewrite the config on theme change */
-    WCHAR configPath[MAX_PATH * 2];
-    wsprintfW(configPath, L"%sruntime\\\\config\\\\wezterm.lua", dir);
-    SetEnvironmentVariableW(L"TERMCAST_WEZTERM_CONFIG", configPath);
-
     /* Set default theme name baked at build time */
     SetEnvironmentVariableW(L"TERMCAST_DEFAULT_THEME", L"${themeName}");
 
@@ -588,6 +613,8 @@ config.keys = {
   { key = 'RightArrow', mods = 'SUPER', action = wezterm.action.SendString('\\x1b[1;9C') },
   { key = 'UpArrow', mods = 'SUPER', action = wezterm.action.SendString('\\x1b[1;9A') },
   { key = 'DownArrow', mods = 'SUPER', action = wezterm.action.SendString('\\x1b[1;9B') },
+  -- Cmd+Backspace -> delete to line start (backspace codepoint = 127, super modifier = 9)
+  { key = 'Backspace', mods = 'SUPER', action = wezterm.action.SendString('\\x1b[127;9u') },
 }
 `
     : ''
@@ -607,9 +634,9 @@ config.window_decorations = '${platform === 'darwin' ? 'TITLE|RESIZE' : 'RESIZE'
 config.window_padding = { left = 0, right = 0, top = 0, bottom = 0 }
 config.window_close_confirmation = 'NeverPrompt'
 
--- Background color matching the configured termcast theme.
--- The TUI rewrites this file on theme change so WezTerm auto-reloads it,
--- keeping the window edges/padding in sync with the active theme.
+-- Background color: the TUI sets this dynamically via OSC 11 escape sequence
+-- on startup and every theme change, so the window edges/padding always match.
+-- This initial value comes from the theme configured at build time.
 config.colors = { background = '${backgroundColor}' }
 
 -- Default window size: 120x36 is comfortable for TUI apps (WezTerm default is 80x24)
@@ -651,10 +678,9 @@ function generateLaunchScript({ weztermBinaryName, themeName }: { weztermBinaryN
   return `\
 #!/bin/bash
 DIR="$(cd "$(dirname "$0")" && pwd)"
-export TERMCAST_WEZTERM_CONFIG="$DIR/../Resources/wezterm.lua"
 export TERMCAST_DEFAULT_THEME="${themeName}"
 export TERMCAST_APP_MODE=1
-exec "$DIR/${weztermBinaryName}" --config-file "$TERMCAST_WEZTERM_CONFIG"
+exec "$DIR/${weztermBinaryName}" --config-file "$DIR/../Resources/wezterm.lua"
 `
 }
 
@@ -664,10 +690,9 @@ function generateLinuxLaunchScript({ themeName }: { themeName: string }): string
   return `\
 #!/bin/bash
 DIR="$(cd "$(dirname "$0")" && pwd)"
-export TERMCAST_WEZTERM_CONFIG="$DIR/runtime/config/wezterm.lua"
 export TERMCAST_DEFAULT_THEME="${themeName}"
 export TERMCAST_APP_MODE=1
-exec "$DIR/runtime/wezterm-gui" --config-file "$TERMCAST_WEZTERM_CONFIG"
+exec "$DIR/runtime/wezterm-gui" --config-file "$DIR/runtime/config/wezterm.lua"
 `
 }
 
@@ -1091,8 +1116,9 @@ async function resolveBuildContext({
   // because PowerShell splits unquoted paths on whitespace.
   const safeName = appName.replace(/[/\\\s]+/g, '-').replace(/^-+|-+$/g, '')
 
-  // Resolve font directory: --font-dir flag, or fonts/ in extension root.
-  // --font-dir is resolved relative to the extension path (not cwd) for consistency.
+  // Resolve font directory: --font-dir flag, fonts/ in extension root, or termcast's
+  // built-in fonts/ as fallback. The built-in Inconsolata font ships with termcast so
+  // every app has a guaranteed monospace font without depending on system fonts.
   const fontDirPath = (() => {
     if (fontDir) {
       const resolved = path.isAbsolute(fontDir)
@@ -1111,11 +1137,16 @@ async function resolveBuildContext({
     if (fs.existsSync(defaultFontDir) && fs.statSync(defaultFontDir).isDirectory()) {
       return defaultFontDir
     }
+    // Fall back to termcast's built-in fonts/ directory (contains Inconsolata)
+    const builtinFontDir = path.join(__dirname, '..', 'fonts')
+    if (fs.existsSync(builtinFontDir) && fs.statSync(builtinFontDir).isDirectory()) {
+      return builtinFontDir
+    }
     return undefined
   })()
 
   const fontOptions: WeztermFontOptions = {
-    fontFamily,
+    fontFamily: fontFamily ?? 'Inconsolata',
     fontSize,
     lineHeight,
     hasBundledFonts: !!fontDirPath,

package/src/cli.tsx

@@ -239,13 +239,13 @@ cli
   .command('release [path]', 'Build and publish extension to GitHub releases')
   .option('--single', 'Only compile for the current platform')
   .option('--entry <file>', 'Custom entry file (instead of auto-generated one)')
-  .action(async (extensionPath: string, options: { single?: boolean; entry?: string }) => {
-    extensionPath = path.resolve(extensionPath || process.cwd())
+  .action(async (extensionPath: string | undefined, options: { single?: boolean; entry?: string }) => {
+    const resolvedPath = path.resolve(extensionPath || process.cwd())
 
     console.log('Building and releasing extension...')
     try {
       const result = await releaseExtension({
-        extensionPath,
+        extensionPath: resolvedPath,
         single: options.single,
         entry: options.entry,
       })
@@ -279,7 +279,7 @@ cli
   .option('--theme <name>', 'Default theme name (default: nerv)')
   .action(
     async (
-      extensionPath: string,
+      extensionPath: string | undefined,
       options: {
         name?: string
         icon?: string
@@ -294,6 +294,8 @@ cli
         fontSize?: string
         lineHeight?: string
         theme?: string
+        // `--no-installer` adds noInstaller to the inferred type
+        noInstaller?: boolean
       },
     ) => {
       extensionPath = path.resolve(extensionPath || process.cwd())
@@ -597,7 +599,7 @@ cli
     'Search for extensions in the Raycast store',
   )
   .option('-n, --limit [number]', 'Number of results to show (default: 10)')
-  .action(async (query: string, options: { limit?: string }) => {
+  .action(async (query, options) => {
     try {
       const limit = parseInt(options.limit || '10', 10)
       const result = await searchStoreListings({ query, perPage: limit })
@@ -642,15 +644,12 @@ cli
     '--no-dir',
     'Put files directly in output directory instead of creating extension subdirectory',
   )
-  .action(
-    async (
-      extensionName: string,
-      options: { output?: string; dir: boolean },
-    ) => {
+  .action(async (extensionName, options) => {
       try {
         const destPath = path.resolve(options.output || '.')
-        // When --no-dir is passed, dir is false; put files directly in destPath
-        const extensionDir = options.dir
+        // When --no-dir is passed, noDir is true; put files directly in destPath
+        const useSubdir = !options.noDir
+        const extensionDir = useSubdir
           ? path.join(destPath, extensionName)
           : destPath
         const tempCloneDir = path.join(
@@ -662,7 +661,7 @@ cli
           `Downloading extension '${extensionName}' from raycast/extensions...`,
         )
 
-        if (options.dir && fs.existsSync(extensionDir)) {
+        if (useSubdir && fs.existsSync(extensionDir)) {
           console.log(`Removing existing directory: ${extensionDir}`)
           fs.rmSync(extensionDir, { recursive: true, force: true })
         }
@@ -724,7 +723,7 @@ cli
         }
 
         // Move files to final destination
-        if (options.dir) {
+        if (useSubdir) {
           fs.mkdirSync(extensionDir, { recursive: true })
         }
         const filesToMove = fs.readdirSync(extensionPath)
@@ -755,7 +754,7 @@ cli
 
 cli
   .command('new [name]', 'Create a new termcast extension')
-  .action(async (name: string) => {
+  .action(async (name: string | undefined) => {
     if (!name) {
       console.log('Usage: termcast new <extension-name>\n')
       console.log('Create a new termcast extension with the given name.\n')

package/src/compile.vitest.tsx

@@ -96,7 +96,7 @@ test('compile extension and run executable', async () => {
        Show State Shows the current application state in view
 
 
-       ↵ run command   ↑↓ navigate   ^k actions
+       ↵ run command   ↑↓ navigate   ^k actions   :vim
     "
   `)
 }, 60000)
@@ -198,7 +198,7 @@ test('compiled executable can navigate back', async () => {
        ○ Fifth Item This is the fifth item
 
 
-       ↵ copy item title   ↑↓ navigate   ^k actions
+       ↵ copy item title   ↑↓ navigate   ^k actions   :vim
     "
   `)
 }, 60000)

package/src/components/actions.tsx

@@ -1,3 +1,4 @@
+import { platform } from '#platform/runtime'
 import React, {
   type ReactNode,
   type ReactElement,
@@ -22,6 +23,7 @@ import { Dropdown } from 'termcast/src/components/dropdown'
 import { ExtensionPreferences } from 'termcast/src/components/extension-preferences'
 import { ThemePicker } from 'termcast/src/components/theme-picker'
 import { useStore } from 'termcast/src/state'
+import { toggleVimMode } from 'termcast/src/vim-mode'
 import { InFocus } from 'termcast/src/internal/focus-context'
 import { Onscreen, useIsOffscreen } from 'termcast/src/internal/offscreen'
 import { CommonProps } from 'termcast/src/utils'
@@ -587,7 +589,7 @@ Action.ToggleQuickLook = (props) => {
         return
       }
 
-      if (process.platform !== 'darwin') {
+      if (platform !== 'darwin') {
         showToast({
           title: 'Quick Look',
           message: 'Quick Look is only supported on macOS',
@@ -743,6 +745,21 @@ export function matchesShortcut(
   return true
 }
 
+// Separate component so the inputMode selector is reactive and the label
+// updates when vim mode is toggled without reopening the action panel.
+function VimModeAction(): any {
+  const inputMode = useStore((s) => s.inputMode)
+  return (
+    <Action
+      title={inputMode === 'vim' ? 'Disable Vim Mode' : 'Enable Vim Mode'}
+      onAction={() => {
+        useStore.setState({ showActionsDialog: false })
+        toggleVimMode()
+      }}
+    />
+  )
+}
+
 /**
  * ActionPanel uses React portals to render its dialog content in the overlay
  * area while staying in the original React tree. This preserves all React
@@ -916,6 +933,7 @@ const ActionPanel: ActionPanelType = (props) => {
             dialog.push({ element: <ThemePicker /> })
           }}
         />
+        <VimModeAction />
         <Action
           title="Toggle Console Logs"
           onAction={() => {