termcast 1.3.21 → 1.3.25

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)
@@ -215,7 +222,7 @@ cli
         single: options.single,
       })
 
-      console.log(`\nRelease complete: v${result.version}`)
+      console.log(`\nRelease complete: ${result.tag}`)
       console.log(`Uploaded ${result.uploadedFiles.length} binaries`)
     } catch (error: any) {
       console.error('Release failed:', error.message)
@@ -365,17 +372,54 @@ 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: '.' })
-  .action(async (extensionName: string, options: { output: string }) => {
+  .option('--no-dir', 'Put files directly in output directory instead of creating extension subdirectory')
+  .action(async (extensionName: string, options: { output: string; dir: boolean }) => {
     try {
       const destPath = path.resolve(options.output)
-      const extensionDir = path.join(destPath, extensionName)
+      // When --no-dir is passed, dir is false; put files directly in destPath
+      const extensionDir = options.dir ? path.join(destPath, extensionName) : destPath
+      const tempCloneDir = path.join(destPath, `.tmp-${extensionName}-${Date.now()}`)
 
       console.log(`Downloading extension '${extensionName}' from raycast/extensions...`)
 
-      if (fs.existsSync(extensionDir)) {
+      if (options.dir && fs.existsSync(extensionDir)) {
         console.log(`Removing existing directory: ${extensionDir}`)
         fs.rmSync(extensionDir, { recursive: true, force: true })
       }
@@ -383,7 +427,8 @@ cli
       fs.mkdirSync(destPath, { recursive: true })
 
       const repoUrl = 'https://github.com/raycast/extensions.git'
-      const cloneCmd = `git clone -n --depth=1 --filter=tree:0 "${repoUrl}" "${extensionName}"`
+      const cloneDirName = path.basename(tempCloneDir)
+      const cloneCmd = `git clone -n --depth=1 --filter=tree:0 "${repoUrl}" "${cloneDirName}"`
       console.log(`Running: ${cloneCmd}`)
       try {
         execSync(cloneCmd, {
@@ -399,11 +444,12 @@ cli
       console.log(`Running: ${sparseCmd}`)
       try {
         execSync(sparseCmd, {
-          cwd: extensionDir,
+          cwd: tempCloneDir,
           stdio: 'inherit',
         })
       } catch (error) {
         console.error(`Failed to set sparse-checkout`)
+        fs.rmSync(tempCloneDir, { recursive: true, force: true })
         process.exit(1)
       }
 
@@ -411,22 +457,27 @@ cli
       console.log(`Running: ${checkoutCmd}`)
       try {
         execSync(checkoutCmd, {
-          cwd: extensionDir,
+          cwd: tempCloneDir,
           stdio: 'inherit',
         })
       } catch (error) {
         console.error(`Failed to checkout files`)
+        fs.rmSync(tempCloneDir, { recursive: true, force: true })
         process.exit(1)
       }
 
-      const extensionPath = path.join(extensionDir, 'extensions', extensionName)
+      const extensionPath = path.join(tempCloneDir, 'extensions', extensionName)
 
       if (!fs.existsSync(extensionPath)) {
         console.error(`Extension '${extensionName}' not found in raycast/extensions repo`)
-        fs.rmSync(extensionDir, { recursive: true, force: true })
+        fs.rmSync(tempCloneDir, { recursive: true, force: true })
         process.exit(1)
       }
 
+      // Move files to final destination
+      if (options.dir) {
+        fs.mkdirSync(extensionDir, { recursive: true })
+      }
       const filesToMove = fs.readdirSync(extensionPath)
       for (const file of filesToMove) {
         const src = path.join(extensionPath, file)
@@ -434,8 +485,8 @@ cli
         fs.renameSync(src, dest)
       }
 
-      fs.rmSync(path.join(extensionDir, 'extensions'), { recursive: true, force: true })
-      fs.rmSync(path.join(extensionDir, '.git'), { recursive: true, force: true })
+      // Clean up temp clone directory
+      fs.rmSync(tempCloneDir, { recursive: true, force: true })
 
       console.log(`\nInstalling dependencies...`)
       execSync('npm install', {

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,
   });
 }
 
@@ -103,15 +105,15 @@ export function getArchiveExtension(target: CompileTarget): string {
 export const ALL_TARGETS: CompileTarget[] = [
   { os: 'linux', arch: 'arm64' },
   { os: 'linux', arch: 'x64' },
-  { os: 'linux', arch: 'x64', avx2: false },
-  { os: 'linux', arch: 'arm64', abi: 'musl' },
-  { os: 'linux', arch: 'x64', abi: 'musl' },
-  { os: 'linux', arch: 'x64', abi: 'musl', avx2: false },
+  // { os: 'linux', arch: 'x64', avx2: false },
+  // { os: 'linux', arch: 'arm64', abi: 'musl' },
+  // { os: 'linux', arch: 'x64', abi: 'musl' },
+  // { os: 'linux', arch: 'x64', abi: 'musl', avx2: false },
   { os: 'darwin', arch: 'arm64' },
   { os: 'darwin', arch: 'x64' },
-  { os: 'darwin', arch: 'x64', avx2: false },
+  // { os: 'darwin', arch: 'x64', avx2: false },
   { os: 'win32', arch: 'x64' },
-  { os: 'win32', arch: 'x64', avx2: false },
+  // { os: 'win32', arch: 'x64', avx2: false },
 ]
 
 export function getCurrentTarget(): CompileTarget {
@@ -125,6 +127,7 @@ export interface CompileOptions {
   outfile?: string
   minify?: boolean
   target?: CompileTarget
+  version?: string
 }
 
 export interface CompileResult {
@@ -137,6 +140,7 @@ export async function compileExtension({
   outfile,
   minify = false,
   target,
+  version,
 }: CompileOptions): Promise<CompileResult> {
   const resolvedPath = path.resolve(extensionPath)
 
@@ -162,6 +166,7 @@ export async function compileExtension({
   if (!fs.existsSync(bundleDir)) {
     fs.mkdirSync(bundleDir, { recursive: true })
   }
+  fs.writeFileSync(path.join(bundleDir, '.gitignore'), '*\n')
 
   const entryCode = generateEntryCode({
     extensionPath: resolvedPath,
@@ -184,18 +189,34 @@ 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],
+      define: { 'process.env.VERSION': JSON.stringify(version || '') },
+      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))

package/src/components/actions.tsx

@@ -17,8 +17,12 @@ import {
   moveToTrash,
 } from 'termcast/src/action-utils'
 import { useDialog } from 'termcast/src/internal/dialog'
+import { useNavigation } from 'termcast/src/internal/navigation'
 import { Dropdown } from 'termcast/src/components/dropdown'
+import { ExtensionPreferences } from 'termcast/src/components/extension-preferences'
+import { useStore } from 'termcast/src/state'
 import { useIsInFocus } from 'termcast/src/internal/focus-context'
+import { useIsOffscreen } from 'termcast/src/internal/offscreen'
 import { CommonProps } from 'termcast/src/utils'
 import type {
   KeyboardShortcut,
@@ -180,7 +184,7 @@ const Action: ActionType = (props) => {
 
   const isDestructive = props.style === ActionStyle.Destructive
 
-  // Render as Dropdown.Item
+  // Render as Dropdown.Item (handles offscreen check internally)
   return (
     <Dropdown.Item
       title={props.title}
@@ -210,7 +214,7 @@ Action.Push = (props) => {
     },
   })
 
-  // Render as Dropdown.Item
+  // Render as Dropdown.Item (handles offscreen check internally)
   return (
     <Dropdown.Item
       title={props.title}
@@ -243,7 +247,7 @@ Action.CopyToClipboard = (props) => {
     },
   })
 
-  // Render as Dropdown.Item
+  // Render as Dropdown.Item (handles offscreen check internally)
   return (
     <Dropdown.Item
       title={props.title}
@@ -270,7 +274,7 @@ Action.OpenInBrowser = (props) => {
     },
   })
 
-  // Render as Dropdown.Item
+  // Render as Dropdown.Item (handles offscreen check internally)
   return (
     <Dropdown.Item
       title={props.title}
@@ -298,7 +302,7 @@ Action.Open = (props) => {
     },
   })
 
-  // Render as Dropdown.Item
+  // Render as Dropdown.Item (handles offscreen check internally)
   return (
     <Dropdown.Item
       title={props.title}
@@ -328,7 +332,7 @@ Action.Paste = (props) => {
     },
   })
 
-  // Render as Dropdown.Item
+  // Render as Dropdown.Item (handles offscreen check internally)
   return (
     <Dropdown.Item
       title={props.title}
@@ -355,7 +359,7 @@ Action.ShowInFinder = (props) => {
     },
   })
 
-  // Render as Dropdown.Item
+  // Render as Dropdown.Item (handles offscreen check internally)
   return (
     <Dropdown.Item
       title={props.title || 'Show in Finder'}
@@ -382,7 +386,7 @@ Action.OpenWith = (props) => {
     },
   })
 
-  // Render as Dropdown.Item
+  // Render as Dropdown.Item (handles offscreen check internally)
   return (
     <Dropdown.Item
       title={props.title || `Open with ${props.application}`}
@@ -413,7 +417,7 @@ Action.Trash = (props) => {
     },
   })
 
-  // Render as Dropdown.Item
+  // Render as Dropdown.Item (handles offscreen check internally)
   return (
     <Dropdown.Item
       title={props.title || 'Move to Trash'}
@@ -448,7 +452,7 @@ Action.SubmitForm = (props) => {
     },
   })
 
-  // Render as Dropdown.Item
+  // Render as Dropdown.Item (handles offscreen check internally)
   return (
     <Dropdown.Item
       title={props.title || 'Submit'}
@@ -480,7 +484,7 @@ Action.CreateSnippet = (props) => {
     },
   })
 
-  // Render as Dropdown.Item
+  // Render as Dropdown.Item (handles offscreen check internally)
   return (
     <Dropdown.Item
       title={props.title || 'Create Snippet'}
@@ -510,7 +514,7 @@ Action.CreateQuicklink = (props) => {
     },
   })
 
-  // Render as Dropdown.Item
+  // Render as Dropdown.Item (handles offscreen check internally)
   return (
     <Dropdown.Item
       title={props.title || 'Create Quicklink'}
@@ -540,7 +544,7 @@ Action.ToggleQuickLook = (props) => {
     },
   })
 
-  // Render as Dropdown.Item
+  // Render as Dropdown.Item (handles offscreen check internally)
   return (
     <Dropdown.Item
       title={props.title || 'Quick Look'}
@@ -552,8 +556,6 @@ Action.ToggleQuickLook = (props) => {
 }
 
 Action.PickDate = (props) => {
-  const dialog = useDialog()
-
   // Register as descendant with execute function
   useActionDescendant({
     title: props.title || 'Pick Date',
@@ -570,7 +572,7 @@ Action.PickDate = (props) => {
     },
   })
 
-  // Render as Dropdown.Item
+  // Render as Dropdown.Item (handles offscreen check internally)
   return (
     <Dropdown.Item
       title={props.title || 'Pick Date'}
@@ -631,31 +633,55 @@ function formatShortcut(
 const ActionPanel: ActionPanelType = (props) => {
   const { children, title } = props
   const dialog = useDialog()
+  const { push } = useNavigation()
   const inFocus = useIsInFocus()
+  const isOffscreen = useIsOffscreen()
   const descendantsContext = useActionDescendants()
 
+  // Get extension and command info for configure actions
+  const extensionPackageJson = useStore((state) => state.extensionPackageJson)
+  const currentCommandName = useStore((state) => state.currentCommandName)
+
+  const hasExtensionPrefs =
+    (extensionPackageJson?.preferences?.length ?? 0) > 0
+  const currentCommand = extensionPackageJson?.commands?.find(
+    (c) => c.name === currentCommandName,
+  )
+  const hasCommandPrefs = (currentCommand?.preferences?.length ?? 0) > 0
+
   // Create context value
   const contextValue = useMemo<ActionPanelContextValue>(
     () => ({ currentSection: undefined }),
     [],
   )
 
-  // prevent showing actions if no dialog is shown
-  if (!dialog.stack.length) return null
-  // if (!inFocus) return
-
-  // Check if there's only one action and execute it immediately
+  // Auto-execute first action if flag is set (triggered by enter/ctrl+enter)
+  // Also report first action title when rendered offscreen
   useLayoutEffect(() => {
     const allActions = Object.values(descendantsContext.map.current)
       .filter((item: any) => item.index !== -1)
       .map((item: any) => item.props as ActionDescendant)
 
-    if (allActions.length === 1) {
-      logger.log(`Auto-executing single action: ${allActions[0].title}`)
+    // When offscreen, just report first action title for footer display
+    if (isOffscreen) {
+      useStore.setState({ firstActionTitle: allActions[0]?.title ?? '' })
+      return
+    }
+
+    const shouldExecute = useStore.getState().shouldAutoExecuteFirstAction
+    useStore.setState({ shouldAutoExecuteFirstAction: false })
+
+    if (!shouldExecute) return
+
+    if (allActions[0]) {
+      logger.log(`Auto-executing first action: ${allActions[0].title}`)
       dialog.clear()
       allActions[0].execute()
     }
-  }, [descendantsContext.map, dialog])
+  }, [descendantsContext.map, dialog, isOffscreen])
+
+  // prevent showing actions if no dialog is shown (must be after hooks)
+  if (!dialog.stack.length && !isOffscreen) return null
 
   // ActionPanel renders as Dropdown with children
   return (
@@ -680,6 +706,38 @@ const ActionPanel: ActionPanelType = (props) => {
           }}
         >
           {children}
+          {(hasExtensionPrefs || hasCommandPrefs) && (
+            <ActionPanel.Section title="Settings">
+              {hasExtensionPrefs && (
+                <Action
+                  title="Configure Extension..."
+                  shortcut={{ modifiers: ['cmd', 'shift'], key: ',' }}
+                  onAction={() => {
+                    dialog.clear()
+                    push(
+                      <ExtensionPreferences
+                        extensionName={extensionPackageJson!.name}
+                      />,
+                    )
+                  }}
+                />
+              )}
+              {hasCommandPrefs && (
+                <Action
+                  title="Configure Command..."
+                  onAction={() => {
+                    dialog.clear()
+                    push(
+                      <ExtensionPreferences
+                        extensionName={extensionPackageJson!.name}
+                        commandName={currentCommandName!}
+                      />,
+                    )
+                  }}
+                />
+              )}
+            </ActionPanel.Section>
+          )}
         </Dropdown>
       </ActionPanelContext.Provider>
     </ActionDescendantsProvider>
@@ -698,11 +756,13 @@ ActionPanel.Section = (props) => {
     [parentContext, props.title],
   )
 
-  // Section provides context to its children
+  // Section renders Dropdown.Section and provides context to its children
   return (
-    <ActionPanelContext.Provider value={sectionContextValue}>
-      {props.children}
-    </ActionPanelContext.Provider>
+    <Dropdown.Section title={props.title}>
+      <ActionPanelContext.Provider value={sectionContextValue}>
+        {props.children}
+      </ActionPanelContext.Provider>
+    </Dropdown.Section>
   )
 }
 
@@ -718,11 +778,13 @@ ActionPanel.Submenu = (props) => {
     [parentContext, props.title],
   )
 
-  // Submenu provides context to its children
+  // Submenu renders Dropdown.Section and provides context to its children
   return (
-    <ActionPanelContext.Provider value={submenuContextValue}>
-      {props.children}
-    </ActionPanelContext.Provider>
+    <Dropdown.Section title={props.title}>
+      <ActionPanelContext.Provider value={submenuContextValue}>
+        {props.children}
+      </ActionPanelContext.Provider>
+    </Dropdown.Section>
   )
 }
 

package/src/components/detail.tsx

@@ -9,6 +9,7 @@ import { Color, resolveColor } from 'termcast/src/colors'
 
 import { useDialog } from 'termcast/src/internal/dialog'
 import { ScrollBox } from 'termcast/src/internal/scrollbox'
+import { useStore } from 'termcast/src/state'
 
 interface ActionsInterface {
   actions?: ReactNode
@@ -277,8 +278,11 @@ const Detail: DetailType = (props) => {
     if (!inFocus) return
 
     if (evt.name === 'k' && evt.ctrl && actions) {
+      // Ctrl+K shows actions (always show sheet)
       dialog.push(actions, 'bottom-right')
     } else if (evt.name === 'return' && actions) {
+      // Enter executes first action directly
+      useStore.setState({ shouldAutoExecuteFirstAction: true })
       dialog.push(actions, 'bottom-right')
     }
   })