termcast 1.3.33 → 1.3.35

package/src/internal/dialog.tsx

@@ -151,7 +151,6 @@ export function DialogOverlay(): any {
   const dialogStack = useStore((state) => state.dialogStack)
   const showActionsDialog = useStore((state) => state.showActionsDialog)
   const navContext = useContext(NavigationContext)
-  const theme = useTheme()
 
   const setActionsPortalTargetRef = useCallback((node: any) => {
     if (!node) {
@@ -177,13 +176,33 @@ export function DialogOverlay(): any {
 
   return (
     <>
+      {item && (
+        <box position='absolute' width='100%' height='100%' flexDirection='column'>
+          <InFocus inFocus={true}>
+            <Dialog
+              position={item.position}
+              onClickOutside={() => {
+                const state = useStore.getState()
+                if (state.dialogStack.length > 0) {
+                  useStore.setState({
+                    dialogStack: state.dialogStack.slice(0, -1),
+                  })
+                }
+              }}
+            >
+              <NavigationContext.Provider value={navContext}>
+                {item.element}
+              </NavigationContext.Provider>
+            </Dialog>
+          </InFocus>
+        </box>
+      )}
       {showActionsDialog && (
         <box
           position='absolute'
           width='100%'
           height='100%'
           flexDirection='column'
-          backgroundColor={theme.background}
         >
           <InFocus inFocus={true}>
             <Dialog
@@ -201,27 +220,6 @@ export function DialogOverlay(): any {
           </InFocus>
         </box>
       )}
-      {item && (
-        <box position='absolute' width='100%' height='100%' flexDirection='column'>
-          <InFocus inFocus={true}>
-            <Dialog
-              position={item.position}
-              onClickOutside={() => {
-                const state = useStore.getState()
-                if (state.dialogStack.length > 0) {
-                  useStore.setState({
-                    dialogStack: state.dialogStack.slice(0, -1),
-                  })
-                }
-              }}
-            >
-              <NavigationContext.Provider value={navContext}>
-                {item.element}
-              </NavigationContext.Provider>
-            </Dialog>
-          </InFocus>
-        </box>
-      )}
     </>
   )
 }

package/src/internal/providers.tsx

@@ -35,20 +35,33 @@ const queryClient = new QueryClient({
   },
 })
 
-// Create a custom persister using the Cache class
-const queryCache = new Cache({ namespace: 'tanstack-query' })
+// Lazy-initialized Cache for TanStack Query persistence.
+// Must not be created at module load time because extensionPath may not be set yet
+// (e.g. when renderWithProviders sets state right before rendering).
+// Tracks the extensionPath it was created with so it can be recreated if the path changes.
+let queryCache: Cache | null = null
+let queryCachePath: string | null = null
+
+function getQueryCache(): Cache {
+  const currentPath = useStore.getState().extensionPath
+  if (!queryCache || currentPath !== queryCachePath) {
+    queryCache = new Cache({ namespace: 'tanstack-query' })
+    queryCachePath = currentPath
+  }
+  return queryCache
+}
 
 const persister = {
   persistClient: async (client: any) => {
     const serialized = JSON.stringify(client)
-    queryCache.set('query-client-data', serialized)
+    getQueryCache().set('query-client-data', serialized)
   },
   restoreClient: async () => {
-    const data = queryCache.get('query-client-data')
+    const data = getQueryCache().get('query-client-data')
     return data ? JSON.parse(data) : undefined
   },
   removeClient: async () => {
-    queryCache.remove('query-client-data')
+    getQueryCache().remove('query-client-data')
   },
 }
 

package/src/state.tsx

@@ -36,6 +36,7 @@ export interface DialogStackItem {
 export interface NavigationStackItem {
   element: ReactNode
   onPop?: () => void
+  selectedListIndex?: number
 }
 
 interface AppState {

package/src/theme.tsx

@@ -3,12 +3,16 @@ import { getResolvedTheme, type ResolvedTheme, defaultThemeName, themeNames } fr
 import { useStore } from './state'
 import { Cache } from './apis/cache'
 
-// Global cache for theme persistence (no namespace = global storage)
+// Global cache for theme persistence (no namespace = global storage).
+// Tracks extensionPath so the cache is recreated if the path changes.
 let globalCache: Cache | null = null
+let globalCachePath: string | null = null
 
 function getGlobalCache(): Cache {
-  if (!globalCache) {
+  const currentPath = useStore.getState().extensionPath
+  if (!globalCache || currentPath !== globalCachePath) {
     globalCache = new Cache()
+    globalCachePath = currentPath
   }
   return globalCache
 }

package/src/utils/run-command.tsx

@@ -1,5 +1,5 @@
 import React from 'react'
-import { cac } from 'cac'
+import { goke } from 'goke'
 import { useStore } from 'termcast/src/state'
 import { showToast, Toast } from 'termcast/src/apis/toast'
 import { LocalStorage } from 'termcast/src/apis/localstorage'
@@ -31,13 +31,13 @@ export interface ParsedExtensionArgs {
 export function parseExtensionArgs({
   skipArgv = 0,
 }: { skipArgv?: number } = {}): ParsedExtensionArgs {
-  // Build argv for cac: keep first 2 (binary + script), skip subcommand args, keep the rest
+  // Build argv for goke: keep first 2 (binary + script), skip subcommand args, keep the rest
   const argv = [
     process.argv[0],
     process.argv[1],
     ...process.argv.slice(2 + skipArgv),
   ]
-  const parsed = cac().parse(argv, { run: false })
+  const parsed = goke().parse(argv, { run: false })
   return {
     commandName: parsed.args[0] as string | undefined,
     showHelp: Boolean(parsed.options.help || parsed.options.h),

package/src/utils.tsx

@@ -12,13 +12,53 @@ import {
   type CommandWithFile,
 } from './package-json'
 import { logger } from './logger'
+import { useStore } from './state'
+
+export interface RenderWithProvidersOptions {
+  extensionName?: string
+  extensionPath?: string
+  packageJson?: RaycastPackageJson
+}
+
+/**
+ * Render a React element wrapped in TermcastProvider with all necessary state initialized.
+ *
+ * Sets up extensionPath (for LocalStorage, Cache, assets) and extensionPackageJson
+ * (for preferences, environment metadata, action panel config) before rendering.
+ *
+ * - extensionName defaults to 'termcast-app'
+ * - extensionPath defaults to ~/.termcast/compiled/{extensionName}
+ * - packageJson defaults to a minimal { name, title, commands: [] }
+ */
+export async function renderWithProviders(
+  element: ReactNode,
+  options?: RenderWithProvidersOptions,
+): Promise<void> {
+  const extensionName = options?.extensionName || 'termcast-app'
+  const extensionPath =
+    options?.extensionPath ||
+    path.join(os.homedir(), '.termcast', 'compiled', extensionName)
+  const packageJson: RaycastPackageJson = options?.packageJson || {
+    name: extensionName,
+    title: extensionName,
+    description: '',
+    commands: [],
+  }
+
+  // Reset store to initial state then set extension fields, matching
+  // startDevMode/startCompiledExtension behavior to avoid stale navigation/dialog state
+  useStore.setState({
+    ...useStore.getInitialState(),
+    extensionPath,
+    extensionPackageJson: packageJson,
+  })
 
-export async function renderWithProviders(element: ReactNode): Promise<void> {
   const renderer = await createCliRenderer({
     onDestroy: () => {
       process.exit(0)
     },
   })
+
   createRoot(renderer).render(<TermcastProvider>{element}</TermcastProvider>)
 }
 

package/src/watcher.tsx

@@ -6,14 +6,34 @@ import type ParcelWatcher from '@parcel/watcher'
 
 let _watcher: typeof ParcelWatcher | undefined
 
+function getWatcherPackageName(): string {
+  const suffix = process.platform === 'linux' ? '-glibc' : ''
+  return `@parcel/watcher-${process.platform}-${process.arch}${suffix}`
+}
+
 export function getWatcher(): typeof ParcelWatcher {
   if (_watcher) return _watcher
-  // Use require with template literal so Bun can analyze and bundle the native module
-  // Linux requires -glibc suffix for the native binding
-  const suffix = process.platform === 'linux' ? '-glibc' : ''
-  const binding = require(
-    `@parcel/watcher-${process.platform}-${process.arch}${suffix}`,
-  )
+  const watcherPackageName = getWatcherPackageName()
+  let binding: unknown
+  try {
+    // Use require with template literal so Bun can analyze and bundle the native module
+    binding = require(watcherPackageName)
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    throw new Error(
+      [
+        `Failed to load native watcher package \"${watcherPackageName}\".`,
+        `Current platform: ${process.platform}-${process.arch}.`,
+        '',
+        'This usually means Bun blocked install scripts for watcher packages.',
+        'Fix with:',
+        '  bun pm trust @parcel/watcher',
+        '  bun install',
+        '',
+        `Original error: ${message}`,
+      ].join('\n'),
+    )
+  }
   _watcher = createWrapper(binding)
   return _watcher!
 }