termcast 1.3.21 → 1.3.24

package/src/apis/localstorage.test.ts

@@ -1,20 +1,28 @@
-import { describe, test, expect, beforeEach, afterAll } from 'bun:test'
+import { describe, test, expect, beforeEach, beforeAll, afterAll } from 'bun:test'
 import { LocalStorage } from './localstorage'
+import { useStore } from '../state'
 import * as os from 'os'
 import * as path from 'path'
 import * as fs from 'fs'
 
 describe('LocalStorage', () => {
+  const testExtensionPath = path.join(os.tmpdir(), 'termcast-localstorage-test')
+
+  beforeAll(() => {
+    // Set up extensionPath required by LocalStorage
+    useStore.setState({ extensionPath: testExtensionPath })
+  })
+
   beforeEach(async () => {
     await LocalStorage.clear()
   })
 
   afterAll(() => {
-    // Optional: Clean up test database after all tests
-    // const dbPath = path.join(os.homedir(), '.termcast.db')
-    // if (fs.existsSync(dbPath)) {
-    //     fs.unlinkSync(dbPath)
-    // }
+    // Clean up test database after all tests
+    const dbDir = path.join(testExtensionPath, '.termcast-bundle')
+    if (fs.existsSync(dbDir)) {
+      fs.rmSync(dbDir, { recursive: true })
+    }
   })
 
   describe('setItem and getItem', () => {

package/src/apis/localstorage.tsx

@@ -11,12 +11,13 @@ let currentDbPath: string | null = null
 function getCurrentDatabasePath(): string {
   const extensionPath = useStore.getState().extensionPath
 
-  if (extensionPath) {
-    // Use .termcast-bundle directory inside extension path
-    return path.join(extensionPath, '.termcast-bundle', 'data.db')
-  } else {
-    return path.join(os.homedir(), '.termcast', '.termcast-bundle', 'data.db')
+  if (!extensionPath) {
+    throw new Error(
+      'extensionPath not set - cannot access LocalStorage before extension is initialized',
+    )
   }
+  // Use .termcast-bundle directory inside extension path
+  return path.join(extensionPath, '.termcast-bundle', 'data.db')
 }
 
 function getDatabase(): Database {
@@ -59,6 +60,8 @@ function getDatabase(): Database {
   return db
 }
 
+
+
 export namespace LocalStorage {
   export type Value = string | number | boolean
 

package/src/apis/oauth.tsx

@@ -405,6 +405,7 @@ export namespace OAuth {
 
       return new Promise((resolve, reject) => {
         const port = 8989
+        let authTimeout: ReturnType<typeof setTimeout>
 
         // Create a local server to handle the OAuth callback
         const server = http.createServer((req, res) => {
@@ -534,6 +535,7 @@ export namespace OAuth {
                 res.end(JSON.stringify({ success: true }))
 
                 server.close()
+                clearTimeout(authTimeout)
                 this.isAuthorizing = false
 
                 // For implicit flow, save tokens immediately since we won't do token exchange
@@ -570,6 +572,7 @@ export namespace OAuth {
                 })
                 res.end(JSON.stringify({ error: 'parse_error' }))
                 server.close()
+                clearTimeout(authTimeout)
                 reject(error)
               }
             })
@@ -608,11 +611,12 @@ export namespace OAuth {
 
         server.on('error', (error) => {
           logger.error('OAuth implicit flow server error:', error)
+          clearTimeout(authTimeout)
           reject(error)
         })
 
         // Set a timeout for the authorization
-        setTimeout(
+        authTimeout = setTimeout(
           () => {
             server.close()
             reject(new Error('OAuth authorization timeout'))

package/src/apis/preferences.tsx

@@ -35,47 +35,73 @@ export function getPreferenceValues<
     return {} as Values
   }
 
+  // Build defaults from preference definitions
+  const defaults: PreferenceValues = {}
+
+  // Extension-level preference defaults
+  const extensionPrefs = extensionPackageJson?.preferences || []
+  for (const pref of extensionPrefs) {
+    if (pref.default !== undefined) {
+      defaults[pref.name] = pref.default
+    }
+  }
+
+  // Command-specific preference defaults (override extension defaults)
+  if (currentCommandName && extensionPackageJson?.commands) {
+    const commandDef = extensionPackageJson.commands.find(
+      (cmd) => cmd.name === currentCommandName,
+    )
+    const commandPrefs = commandDef?.preferences || []
+    for (const pref of commandPrefs) {
+      if (pref.default !== undefined) {
+        defaults[pref.name] = pref.default
+      }
+    }
+  }
+
+  let extensionSavedValues: PreferenceValues = {}
+  let commandSavedValues: PreferenceValues = {}
+
   try {
-    // First try to load command-specific preferences, then fall back to extension preferences
+    // Load extension-level preferences
+    const extensionPreferencesKey = `preferences.${extensionName}`
+    const extensionPreferences = LocalStorage.getItemSync(extensionPreferencesKey)
+
+    if (extensionPreferences && typeof extensionPreferences === 'string') {
+      try {
+        extensionSavedValues = JSON.parse(extensionPreferences)
+        logger.log(
+          `Loaded extension preferences for ${extensionName}:`,
+          extensionSavedValues,
+        )
+      } catch (parseError) {
+        logger.error(`Failed to parse extension preferences:`, parseError)
+      }
+    }
+
+    // Load command-specific preferences
     if (currentCommandName) {
       const commandPreferencesKey = `preferences.${extensionName}.${currentCommandName}`
       const commandPreferences = LocalStorage.getItemSync(commandPreferencesKey)
 
       if (commandPreferences && typeof commandPreferences === 'string') {
         try {
-          const parsed = JSON.parse(commandPreferences)
+          commandSavedValues = JSON.parse(commandPreferences)
           logger.log(
             `Loaded command preferences for ${extensionName}/${currentCommandName}:`,
-            parsed,
+            commandSavedValues,
           )
-          return parsed as Values
         } catch (parseError) {
           logger.error(`Failed to parse command preferences:`, parseError)
         }
       }
     }
-
-    // Fall back to extension-level preferences
-    const extensionPreferencesKey = `preferences.${extensionName}`
-    const extensionPreferences = LocalStorage.getItemSync(
-      extensionPreferencesKey,
-    )
-
-    if (extensionPreferences && typeof extensionPreferences === 'string') {
-      try {
-        const parsed = JSON.parse(extensionPreferences)
-        logger.log(`Loaded extension preferences for ${extensionName}:`, parsed)
-        return parsed as Values
-      } catch (parseError) {
-        logger.error(`Failed to parse extension preferences:`, parseError)
-      }
-    }
   } catch (error) {
     logger.error(`Failed to load preferences for ${extensionName}:`, error)
   }
 
-  // Return empty preferences if none saved
-  return {} as Values
+  // Merge: defaults < extension saved < command saved
+  return { ...defaults, ...extensionSavedValues, ...commandSavedValues } as Values
 }
 
 /**

package/src/build.test.tsx

@@ -69,6 +69,58 @@ describe('buildExtensionCommands', () => {
             "filePath": "/BASE_PATH/fixtures/simple-extension/src/show-state.tsx",
             "exists": true,
             "bundledPath": "/BASE_PATH/fixtures/simple-extension/.termcast-bundle/show-state.js"
+          },
+          {
+            "name": "with-arguments",
+            "title": "With Arguments",
+            "subtitle": "Command with arguments",
+            "description": "Demonstrates command arguments (text, password, dropdown)",
+            "mode": "view",
+            "arguments": [
+              {
+                "name": "query",
+                "type": "text",
+                "placeholder": "Search query",
+                "required": true
+              },
+              {
+                "name": "secretKey",
+                "type": "password",
+                "placeholder": "Secret key"
+              },
+              {
+                "name": "category",
+                "type": "dropdown",
+                "placeholder": "Category",
+                "data": [
+                  {
+                    "title": "Work",
+                    "value": "work"
+                  },
+                  {
+                    "title": "Personal",
+                    "value": "personal"
+                  },
+                  {
+                    "title": "Other",
+                    "value": "other"
+                  }
+                ]
+              }
+            ],
+            "filePath": "/BASE_PATH/fixtures/simple-extension/src/with-arguments.tsx",
+            "exists": true,
+            "bundledPath": "/BASE_PATH/fixtures/simple-extension/.termcast-bundle/with-arguments.js"
+          },
+          {
+            "name": "quick-action",
+            "title": "Quick Action",
+            "subtitle": "No-view command",
+            "description": "Copies current timestamp to clipboard without showing a view",
+            "mode": "no-view",
+            "filePath": "/BASE_PATH/fixtures/simple-extension/src/quick-action.tsx",
+            "exists": true,
+            "bundledPath": "/BASE_PATH/fixtures/simple-extension/.termcast-bundle/quick-action.js"
           }
         ],
         "bundleDir": "/BASE_PATH/fixtures/simple-extension/.termcast-bundle"

package/src/build.tsx

@@ -8,6 +8,7 @@ import * as termcastApi from './index'
 import * as opentuiReact from '@opentui/react'
 import * as opentuiCore from '@opentui/core'
 import * as react from 'react'
+import { swiftLoaderPlugin } from './swift-loader'
 
 const GLOBALS_NAMESPACE = 'globals'
 const VIRTUAL_ENTRY_NAMESPACE = 'virtual-entry'
@@ -225,7 +226,7 @@ export async function buildExtensionCommands({
     target: target || (format === 'cjs' ? 'node' : 'bun'),
     format,
     // external: [],
-    plugins: [aliasPlugin],
+    plugins: [aliasPlugin, swiftLoaderPlugin],
     naming: '[name].js',
     throw: false,
   })

package/src/cli.tsx

@@ -2,10 +2,11 @@ import fs from 'node:fs'
 import path from 'node:path'
 import { execSync, spawn } from 'node:child_process'
 import { cac } from 'cac'
-import chokidar from 'chokidar'
+import * as watcher from '@parcel/watcher'
 import { buildExtensionCommands } from './build'
 import { logger } from './logger'
 import { installExtension } from './utils'
+import { searchStoreListings } from './store-api/search'
 import './globals'
 import { startDevMode, triggerRebuild } from './extensions/dev'
 import { compileExtension } from './compile'
@@ -66,13 +67,22 @@ checkForUpdates()
 
 cli
   .command('dev [path]', 'Run the extension in the current working directory')
-  .action(async (extensionPath, options) => {
+  .action(async (rawExtensionPath, options) => {
     try {
-      extensionPath = path.resolve(extensionPath || process.cwd())
+      // Check if the provided arg looks like a path (contains / or . or is existing dir)
+      const looksLikePath = rawExtensionPath && (
+        rawExtensionPath.includes('/') ||
+        rawExtensionPath.startsWith('.') ||
+        fs.existsSync(rawExtensionPath)
+      )
+      const extensionPath = path.resolve(looksLikePath ? rawExtensionPath : process.cwd())
       let isBuilding = false
 
       // Start dev mode with initial render
-      await startDevMode({ extensionPath })
+      // Skip args up to and including "dev" subcommand, plus path if it looks like one
+      const devIndex = process.argv.findIndex((arg) => arg === 'dev')
+      const skipArgv = devIndex - 1 + (looksLikePath ? 1 : 0)
+      await startDevMode({ extensionPath, skipArgv })
 
       logger.log(`dev mode started`)
       // Only watch if running in a TTY (interactive terminal)
@@ -83,38 +93,18 @@ cli
 
       console.log('\nWatching for file changes...')
 
-      // Watch entire extension directory
-      const watcher = chokidar.watch(extensionPath, {
-        persistent: true,
-        ignoreInitial: true,
-        awaitWriteFinish: {
-          stabilityThreshold: 300,
-          pollInterval: 100,
-        },
-      })
-
+      // Watch entire extension directory using @parcel/watcher
       const ignoredPatterns = [
-        'node_modules',
-        '.termcast-bundle',
-        '.git',
-        'app.log',
-        'dist',
-        'build',
+        '**/node_modules/**',
+        '**/.termcast-bundle/**',
+        '**/.git/**',
+        '**/.build/**',  // Swift build output
+        '**/*.log',
+        '**/dist/**',
+        '**/build/**',
       ]
 
-      const shouldIgnore = (filePath: string) => {
-        const relativePath = path.relative(extensionPath, filePath)
-        return ignoredPatterns.some(
-          (pattern) =>
-            relativePath.includes(pattern) || filePath.endsWith('.log'),
-        )
-      }
-
       const rebuild = async (filePath: string) => {
-        if (shouldIgnore(filePath)) {
-          return
-        }
-
         if (isBuilding) {
           logger.log('Build already in progress, skipping...')
           return
@@ -133,11 +123,28 @@ cli
         }
       }
 
-      watcher
-        .on('change', rebuild)
-        .on('add', rebuild)
-        .on('unlink', rebuild)
-        .on('error', (error) => logger.error('Watcher error:', error))
+      const subscription = await watcher.subscribe(
+        extensionPath,
+        (err, events) => {
+          if (err) {
+            logger.error('Watcher error:', err)
+            return
+          }
+          // Trigger rebuild for any event (create, update, delete)
+          if (events.length > 0) {
+            rebuild(events[0].path)
+          }
+        },
+        { ignore: ignoredPatterns }
+      )
+
+      // Clean up watcher on exit signals
+      const cleanup = async () => {
+        await subscription.unsubscribe()
+        process.exit(0)
+      }
+      process.on('SIGINT', cleanup)
+      process.on('SIGTERM', cleanup)
     } catch (e: any) {
       console.error('Failed to start dev mode:', e?.message || e)
       logger.error(e)
@@ -365,6 +372,40 @@ cli
     }
   })
 
+cli
+  .command('raycast-search <query>', '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 }) => {
+    try {
+      const limit = parseInt(options.limit, 10)
+      const result = await searchStoreListings({ query, perPage: limit })
+
+      if (result.data.length === 0) {
+        console.log(`No extensions found for "${query}"`)
+        process.exit(0)
+      }
+
+      console.log(`Found ${result.data.length} extensions for "${query}":\n`)
+
+      for (const ext of result.data) {
+        const downloads = ext.download_count.toLocaleString()
+        const commands = ext.commands.map((c) => c.name).join(', ')
+        console.log(`  ${ext.name}`)
+        console.log(`    Path: extensions/${ext.relative_path.replace('extensions/', '')}`)
+        console.log(`    Downloads: ${downloads}`)
+        console.log(`    Commands: ${commands || 'none'}`)
+        console.log(`    Description: ${ext.description.slice(0, 100)}${ext.description.length > 100 ? '...' : ''}`)
+        console.log()
+      }
+
+      console.log(`Download with: termcast download <extension-name>`)
+      process.exit(0)
+    } catch (error: any) {
+      console.error('Search failed:', error.message)
+      process.exit(1)
+    }
+  })
+
 cli
   .command('download <extensionName>', 'Download extension from Raycast extensions repo')
   .option('-o, --output <path>', 'Output directory', { default: '.' })

package/src/compile.tsx

@@ -3,6 +3,7 @@ import path from 'node:path'
 import type { BunPlugin } from 'bun'
 import { logger } from './logger'
 import { getCommandsWithFiles } from './package-json'
+import { swiftLoaderPlugin } from './swift-loader'
 
 const raycastAliasPlugin: BunPlugin = {
   name: 'raycast-to-termcast',
@@ -53,6 +54,7 @@ ${commandsArray}
   await startCompiledExtension({
     extensionPath: ${JSON.stringify(extensionPath)},
     compiledCommands,
+    skipArgv: 0,
   });
 }
 
@@ -184,18 +186,33 @@ export async function compileExtension({
       entrypoints: [tempEntryPath],
       target: bunTarget as 'bun',
       minify,
+      // bytecode: true, // TODO need to wait for opentui to support this removing top level await
+      sourcemap: 'external',
       compile: {
         outfile: defaultOutfile,
       },
-      plugins: [raycastAliasPlugin],
+      plugins: [raycastAliasPlugin, swiftLoaderPlugin],
       throw: false,
     } as Parameters<typeof Bun.build>[0])
 
     if (!result.success) {
-      const errorMessage = result.logs
-        .map((log: any) => log.message || String(log))
-        .join('\n')
-      throw new Error(`Compile failed: ${errorMessage || 'Unknown error'}`)
+      const errorDetails = result.logs.map((log: any) => {
+        const parts = [log.message || String(log)]
+        if (log.position) {
+          parts.push(`  at ${log.position.file}:${log.position.line}:${log.position.column}`)
+        }
+        if (log.notes) {
+          for (const note of log.notes) {
+            parts.push(`  note: ${note.text}`)
+            if (note.location) {
+              parts.push(`    at ${note.location.file}:${note.location.line}`)
+            }
+          }
+        }
+        return parts.join('\n')
+      })
+      logger.log('Compile errors:', JSON.stringify(result.logs, null, 2))
+      throw new Error(`Compile failed: ${errorDetails.join('\n\n') || 'Unknown error'}`)
     }
 
     logger.log('Build outputs:', result.outputs?.map((o) => o.path))