termcast 1.3.19 → 1.3.24

package/src/extensions/home.tsx

@@ -1,4 +1,5 @@
 import fs from 'node:fs'
+import path from 'node:path'
 import React from 'react'
 import { createRoot } from '@opentui/react'
 import { createCliRenderer } from '@opentui/core'
@@ -17,6 +18,7 @@ import '../globals'
 interface ExtensionCommand {
   extensionName: string
   extensionTitle: string
+  extensionDir?: string
   command: any
   bundledPath?: string
   Component?: () => any
@@ -52,6 +54,8 @@ function ExtensionsList({
   const handleCommandSelect = async (item: ExtensionCommand) => {
     clearCommandArguments()
 
+
+
     try {
       await runCommand({
         command: item.command,
@@ -208,12 +212,14 @@ export default function Home({
     const packageJson = JSON.parse(
       fs.readFileSync(extension.packageJsonPath, 'utf-8'),
     )
+    const extensionPath = path.dirname(extension.packageJsonPath)
 
     for (const command of extension.commands) {
       if (command.bundledPath) {
         allCommands.push({
           extensionName: extension.name,
           extensionTitle: packageJson.title || extension.name,
+          extensionDir: extensionPath,
           command,
           bundledPath: command.bundledPath,
           packageJson,

package/src/index.tsx

@@ -124,6 +124,9 @@ export type {
 // AI
 export { AI } from 'termcast/src/apis/ai'
 
+// Browser Extension
+export { BrowserExtension } from 'termcast/src/apis/browser-extension'
+
 // OAuth
 export { OAuth } from 'termcast/src/apis/oauth'
 

package/src/internal/dialog.tsx

@@ -1,5 +1,5 @@
 import { useKeyboard, useTerminalDimensions } from '@opentui/react'
-import React, { type ReactNode, useRef } from 'react'
+import React, { type ReactNode, useRef, useContext } from 'react'
 import { Theme } from 'termcast/src/theme'
 import { InFocus, useIsInFocus } from 'termcast/src/internal/focus-context'
 import { CommonProps } from 'termcast/src/utils'
@@ -10,13 +10,14 @@ import {
 } from 'termcast/src/state'
 import { logger } from '../logger'
 import { ToastOverlay } from 'termcast/src/apis/toast'
+import { NavigationContext } from 'termcast/src/internal/navigation'
 
 const Border = {
-  topLeft: '',
-  topRight: '',
+  topLeft: '┏',
+  topRight: '┓',
   bottomLeft: '',
   bottomRight: '',
-  horizontal: '',
+  horizontal: '━',
   vertical: '┃',
   topT: '+',
   bottomT: '+',
@@ -107,7 +108,7 @@ export function Dialog({
       onMouseDown={handleBackdropClick}
     >
       <box
-        border={false}
+        border
         customBorderChars={Border}
         width={76}
         maxWidth={dimensions.width - 2}
@@ -145,31 +146,6 @@ export function DialogProvider(props: DialogProviderProps): any {
   return (
     <>
       <InFocus inFocus={!dialogStack?.length}>{props.children}</InFocus>
-      {dialogStack.length > 0 && (
-        <box position='absolute'>
-          {dialogStack.map((item, index) => {
-            const isLastItem = index === dialogStack.length - 1
-            return (
-              <InFocus key={'dialog' + String(index)} inFocus={isLastItem}>
-                <Dialog
-                  position={item.position}
-                  onClickOutside={() => {
-                    if (!isLastItem) return
-                    const state = useStore.getState()
-                    if (state.dialogStack.length > 0) {
-                      useStore.setState({
-                        dialogStack: state.dialogStack.slice(0, -1),
-                      })
-                    }
-                  }}
-                >
-                  {item.element}
-                </Dialog>
-              </InFocus>
-            )
-          })}
-        </box>
-      )}
       <InFocus inFocus={false}>
         <ToastOverlay />
       </InFocus>
@@ -177,6 +153,43 @@ export function DialogProvider(props: DialogProviderProps): any {
   )
 }
 
+export function DialogOverlay(): any {
+  const dialogStack = useStore((state) => state.dialogStack)
+  const navContext = useContext(NavigationContext)
+
+  if (dialogStack.length === 0) {
+    return null
+  }
+
+  return (
+    <box position='absolute'>
+      {dialogStack.map((item, index) => {
+        const isLastItem = index === dialogStack.length - 1
+        return (
+          <InFocus key={'dialog' + String(index)} inFocus={isLastItem}>
+            <Dialog
+              position={item.position}
+              onClickOutside={() => {
+                if (!isLastItem) return
+                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>
+  )
+}
+
 export function useDialog() {
   const dialogStack = useStore((state) => state.dialogStack)
 

package/src/internal/navigation.tsx

@@ -26,12 +26,13 @@ interface NavigationContextType {
   isPending: boolean
 }
 
-const NavigationContext = createContext<NavigationContextType | undefined>(
+export const NavigationContext = createContext<NavigationContextType | undefined>(
   undefined,
 )
 
 interface NavigationProviderProps extends CommonProps {
   children: ReactNode
+  overlay?: ReactNode
 }
 
 export function NavigationProvider(props: NavigationProviderProps): any {
@@ -139,6 +140,7 @@ export function NavigationProvider(props: NavigationProviderProps): any {
       {React.cloneElement(currentItem?.element as React.ReactElement, {
         key: stack.length,
       })}
+      {props.overlay}
     </NavigationContext.Provider>
   )
 }

package/src/internal/offscreen.tsx

@@ -0,0 +1,15 @@
+import { createContext, useContext, ReactNode } from 'react'
+
+const OffscreenContext = createContext(false)
+
+export function useIsOffscreen(): boolean {
+  return useContext(OffscreenContext)
+}
+
+export function Offscreen({ children }: { children: ReactNode }): any {
+  return (
+    <OffscreenContext.Provider value={true}>
+      {children}
+    </OffscreenContext.Provider>
+  )
+}

package/src/internal/providers.tsx

@@ -6,7 +6,7 @@ import React, {
 } from 'react'
 import { QueryClient } from '@tanstack/react-query'
 import { PersistQueryClientProvider } from '@tanstack/react-query-persist-client'
-import { DialogProvider } from 'termcast/src/internal/dialog'
+import { DialogProvider, DialogOverlay } from 'termcast/src/internal/dialog'
 import { NavigationProvider } from 'termcast/src/internal/navigation'
 import { CommonProps } from 'termcast/src/utils'
 import { Cache } from 'termcast/src/apis/cache'
@@ -420,7 +420,9 @@ export function TermcastProvider(props: ProvidersProps): any {
           <DialogProvider>
             <box padding={2}>
               {/* NavigationProvider must be last to ensure parent providers remain in the tree when navigation changes */}
-              <NavigationProvider>{props.children}</NavigationProvider>
+              <NavigationProvider overlay={<DialogOverlay />}>
+                {props.children}
+              </NavigationProvider>
             </box>
           </DialogProvider>
         </PersistQueryClientProvider>

package/src/internal/scrollbox.tsx

@@ -1,14 +1,8 @@
 import React from 'react'
 import Theme from '../theme'
+import { MacOSScrollAccel } from '@opentui/core'
+import { ScrollBoxProps } from '@opentui/react'
 
-interface ScrollBoxProps {
-  children?: React.ReactNode
-  focused?: boolean
-  flexGrow?: number
-  flexShrink?: number
-  style?: any
-  ref?: React.Ref<any>
-}
 
 export function ScrollBox({
   children,
@@ -23,6 +17,7 @@ export function ScrollBox({
     <scrollbox
       ref={ref}
       focused={focused}
+      scrollAcceleration={new MacOSScrollAccel()}
       flexGrow={flexGrow}
       flexShrink={flexShrink}
       style={{
@@ -34,6 +29,7 @@ export function ScrollBox({
           flexGrow: 1,
           flexShrink: 1,
           paddingRight: 1,
+
           ...(style?.viewportOptions || {}),
         },
         contentOptions: {

package/src/keyboard.test.tsx

@@ -0,0 +1,69 @@
+import { describe, test, expect } from 'bun:test'
+import { Keyboard } from 'termcast/src/keyboard'
+import type {
+  KeyboardKeyEquivalent,
+  KeyboardKeyModifier,
+  KeyboardShortcut,
+} from 'termcast/src/keyboard'
+
+describe('Keyboard', () => {
+  test('Keyboard.Shortcut.Common has all expected shortcuts', () => {
+    const commonShortcuts = Object.keys(Keyboard.Shortcut.Common)
+    expect(commonShortcuts).toMatchInlineSnapshot(`
+[
+  "Copy",
+  "CopyDeeplink",
+  "CopyName",
+  "CopyPath",
+  "Save",
+  "Duplicate",
+  "Edit",
+  "MoveDown",
+  "MoveUp",
+  "New",
+  "Open",
+  "OpenWith",
+  "Pin",
+  "Refresh",
+  "Remove",
+  "RemoveAll",
+  "ToggleQuickLook",
+]
+`)
+  })
+
+  test('Keyboard.Shortcut.Common.Open has correct structure', () => {
+    expect(Keyboard.Shortcut.Common.Open).toMatchInlineSnapshot(`
+{
+  "key": "o",
+  "modifiers": [
+    "cmd",
+  ],
+}
+`)
+  })
+
+  test('Keyboard.Shortcut.Common.Copy has correct structure', () => {
+    expect(Keyboard.Shortcut.Common.Copy).toMatchInlineSnapshot(`
+{
+  "key": "c",
+  "modifiers": [
+    "cmd",
+    "shift",
+  ],
+}
+`)
+  })
+
+  test('Keyboard.Shortcut.Common.Remove uses ctrl modifier', () => {
+    expect(Keyboard.Shortcut.Common.Remove).toMatchInlineSnapshot(`
+{
+  "key": "x",
+  "modifiers": [
+    "ctrl",
+  ],
+}
+`)
+  })
+
+})

package/src/state.tsx

@@ -30,6 +30,10 @@ interface AppState {
   // OAuth state
   googleAccessToken?: string
   googleIdToken?: string
+  // Actions state - when true, auto-execute first action instead of showing sheet
+  shouldAutoExecuteFirstAction: boolean
+  // First action title for footer display (set by offscreen ActionPanel)
+  firstActionTitle: string
 }
 
 export const useStore = create<AppState>(() => ({
@@ -48,4 +52,7 @@ export const useStore = create<AppState>(() => ({
   // OAuth state
   googleAccessToken: undefined,
   googleIdToken: undefined,
+  // Actions state
+  shouldAutoExecuteFirstAction: false,
+  firstActionTitle: '',
 }))

package/src/swift-loader.tsx

@@ -0,0 +1,239 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { spawn } from 'node:child_process'
+import type { BunPlugin } from 'bun'
+import { logger } from './logger'
+
+const SWIFT_NAMESPACE = 'swift-loader'
+
+interface SwiftBuildCache {
+  [swiftPath: string]: {
+    result: SwiftBuildResult
+    buildTime: number
+  }
+}
+
+const buildCache: SwiftBuildCache = {}
+
+async function buildSwiftPackage(swiftPath: string): Promise<SwiftBuildResult> {
+  logger.log(`Swift: building package at ${swiftPath}`)
+
+  // Check if already built and cached in memory
+  const cached = buildCache[swiftPath]
+  if (cached && fs.existsSync(cached.result.binaryPath)) {
+    logger.log(`Swift: using cached build at ${cached.result.binaryPath}`)
+    return cached.result
+  }
+
+  // Check if binary already exists on disk (from previous build/process)
+  try {
+    const existingResult = await findSwiftBuildResult(swiftPath)
+    logger.log(`Swift: found existing binary at ${existingResult.binaryPath}`)
+    buildCache[swiftPath] = { result: existingResult, buildTime: Date.now() }
+    return existingResult
+  } catch {
+    // Binary doesn't exist, need to build
+  }
+
+  // Run swift build using Node's spawn
+  // Use debug build for faster compilation (skips optimizations)
+  logger.log(`Swift: running swift build -c debug in ${swiftPath}`)
+  const exitCode = await new Promise<number>((resolve, reject) => {
+    const proc = spawn('swift', ['build', '-c', 'debug'], {
+      cwd: swiftPath,
+      stdio: 'inherit',
+    })
+    proc.on('error', reject)
+    proc.on('close', (code) => resolve(code ?? 1))
+  })
+  logger.log(`Swift: build exited with code ${exitCode}`)
+
+  if (exitCode !== 0) {
+    throw new Error(`Swift build failed with exit code ${exitCode}`)
+  }
+  logger.log(`Swift: build completed successfully`)
+
+  // Find the binary and generated files
+  const result = await findSwiftBuildResult(swiftPath)
+
+  // Cache the result
+  buildCache[swiftPath] = {
+    result,
+    buildTime: Date.now(),
+  }
+
+  logger.log(`Swift: built binary at ${result.binaryPath}`)
+  return result
+}
+
+interface SwiftBuildResult {
+  binaryPath: string
+  raycastJsPath: string
+  packageName: string
+}
+
+function findFilesRecursively(dir: string, filename: string): string[] {
+  const results: string[] = []
+
+  if (!fs.existsSync(dir)) {
+    return results
+  }
+
+  const entries = fs.readdirSync(dir, { withFileTypes: true })
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name)
+    if (entry.isDirectory()) {
+      results.push(...findFilesRecursively(fullPath, filename))
+    } else if (entry.name === filename) {
+      results.push(fullPath)
+    }
+  }
+  return results
+}
+
+async function findSwiftBuildResult(swiftPath: string): Promise<SwiftBuildResult> {
+  // Parse Package.swift to find executable target name
+  const packageSwiftPath = path.join(swiftPath, 'Package.swift')
+  const packageSwift = fs.readFileSync(packageSwiftPath, 'utf-8')
+
+  // Look for: name: "PackageName" at the top level
+  const nameMatch = packageSwift.match(/name:\s*"([^"]+)"/)
+  if (!nameMatch) {
+    throw new Error(`Could not find package name in ${packageSwiftPath}`)
+  }
+
+  const packageName = nameMatch[1]
+
+  // Find binary - check debug first, then release
+  const debugBinaryPath = path.join(swiftPath, '.build', 'debug', packageName)
+  const releaseBinaryPath = path.join(swiftPath, '.build', 'release', packageName)
+
+  let binaryPath: string
+  if (fs.existsSync(debugBinaryPath)) {
+    binaryPath = debugBinaryPath
+  } else if (fs.existsSync(releaseBinaryPath)) {
+    binaryPath = releaseBinaryPath
+  } else {
+    throw new Error(`Swift binary not found at ${debugBinaryPath} or ${releaseBinaryPath}`)
+  }
+
+  // Find raycast.js using glob-like search
+  const buildDir = path.join(swiftPath, '.build')
+  const raycastJsFiles = findFilesRecursively(buildDir, 'raycast.js')
+
+  // Filter to find the one from RaycastTypeScriptPlugin for our package
+  const matchingFiles = raycastJsFiles.filter(f =>
+    f.includes('RaycastTypeScriptPlugin') && f.includes(packageName)
+  )
+
+  if (matchingFiles.length === 0) {
+    throw new Error(`Generated raycast.js not found in ${buildDir}. Found files: ${raycastJsFiles.join(', ') || 'none'}`)
+  }
+
+  // Prefer the one in plugins/outputs (not index-build)
+  const raycastJsPath = matchingFiles.find(f => f.includes('plugins/outputs')) || matchingFiles[0]
+
+  logger.log(`Swift: found raycast.js at ${raycastJsPath}`)
+  return { binaryPath, raycastJsPath, packageName }
+}
+
+function generateSwiftModule(result: SwiftBuildResult): string {
+  // Read the generated raycast.js from RaycastTypeScriptPlugin
+  // This file exports named functions that call runSwiftFunction(functionName, ...args)
+  // We prepend our runSwiftFunction implementation with the binary path
+  const generatedJs = fs.readFileSync(result.raycastJsPath, 'utf-8')
+
+  // Prepend our runSwiftFunction implementation using Node's child_process
+  // Use ESM import to match the export statements in generated raycast.js
+  const runtime = `
+import { spawn as _spawn } from 'node:child_process';
+
+const BINARY_PATH = ${JSON.stringify(result.binaryPath)};
+
+function runSwiftFunction(functionName, ...args) {
+  return new Promise((resolve, reject) => {
+    const jsonArgs = args.map((arg) => JSON.stringify(arg));
+    const proc = _spawn(BINARY_PATH, [functionName, ...jsonArgs], {
+      stdio: ['pipe', 'pipe', 'inherit'],
+    });
+
+    let stdout = '';
+    proc.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    proc.on('error', (err) => {
+      reject(new Error('Swift function "' + functionName + '" failed to spawn: ' + err.message));
+    });
+
+    proc.on('close', (exitCode) => {
+      if (exitCode !== 0) {
+        reject(new Error('Swift function "' + functionName + '" failed with exit code ' + exitCode));
+        return;
+      }
+
+      const trimmed = stdout.trim();
+      if (!trimmed) {
+        resolve(undefined);
+        return;
+      }
+
+      try {
+        resolve(JSON.parse(trimmed));
+      } catch {
+        reject(new Error('Swift function "' + functionName + '" returned invalid JSON: ' + trimmed));
+      }
+    });
+  });
+}
+
+`
+
+  return runtime + generatedJs
+}
+
+export const swiftLoaderPlugin: BunPlugin = {
+  name: 'swift-loader',
+  async setup(build) {
+    // Resolve swift: imports
+    build.onResolve({ filter: /^swift:/ }, (args) => {
+      logger.log(`Swift: onResolve called for ${args.path} from ${args.importer}`)
+
+      // Extract the path after "swift:"
+      const swiftRelativePath = args.path.slice(6) // Remove "swift:"
+
+      // Resolve relative to the importer's directory
+      const importerDir = args.importer ? path.dirname(args.importer) : process.cwd()
+      const resolvedSwiftPath = path.resolve(importerDir, swiftRelativePath)
+
+      logger.log(`Swift: resolved to ${resolvedSwiftPath}`)
+
+      return {
+        path: resolvedSwiftPath,
+        namespace: SWIFT_NAMESPACE,
+      }
+    })
+
+    // Load swift packages
+    build.onLoad({ filter: /.*/, namespace: SWIFT_NAMESPACE }, async (args) => {
+      logger.log(`Swift: onLoad called for ${args.path}`)
+      const swiftPath = args.path
+
+      // Build the Swift package and get paths to binary + generated JS
+      logger.log(`Swift: calling buildSwiftPackage...`)
+      const result = await buildSwiftPackage(swiftPath)
+      logger.log(`Swift: buildSwiftPackage returned, binaryPath=${result.binaryPath}`)
+
+      // Generate module by combining runtime with generated raycast.js
+      logger.log(`Swift: generating module...`)
+      const contents = generateSwiftModule(result)
+      logger.log(`Swift: module generated, length=${contents.length}`)
+      // logger.log(`Swift: module contents:\n${contents}`)
+
+      return {
+        contents,
+        loader: 'js',
+      }
+    })
+  },
+}

package/src/swift-runtime.tsx

@@ -0,0 +1,36 @@
+import { logger } from './logger'
+
+export async function runSwiftFunction(
+  binaryPath: string,
+  functionName: string,
+  ...args: unknown[]
+): Promise<unknown> {
+  const jsonArgs = args.map((arg) => JSON.stringify(arg))
+
+  logger.log(`Swift: calling ${functionName} with args:`, jsonArgs)
+
+  const proc = Bun.spawn([binaryPath, functionName, ...jsonArgs], {
+    stdout: 'pipe',
+    stderr: 'inherit',
+  })
+
+  const [stdout, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    proc.exited,
+  ])
+
+  if (exitCode !== 0) {
+    throw new Error(`Swift function "${functionName}" failed with exit code ${exitCode}`)
+  }
+
+  const trimmed = stdout.trim()
+  if (!trimmed) {
+    return undefined
+  }
+
+  try {
+    return JSON.parse(trimmed)
+  } catch {
+    throw new Error(`Swift function "${functionName}" returned invalid JSON: ${trimmed}`)
+  }
+}

package/src/utils/file-system.ts

@@ -8,6 +8,67 @@ export interface FileSystemItem {
   isDirectory: boolean
 }
 
+/**
+ * Recursively list all files in a directory (up to maxDepth levels)
+ */
+export async function listAllFiles({
+  basePath = '.',
+  maxDepth = 3,
+  maxFiles = 1000,
+  includeDirectories = true,
+}: {
+  basePath?: string
+  maxDepth?: number
+  maxFiles?: number
+  includeDirectories?: boolean
+} = {}): Promise<string[]> {
+  const results: string[] = []
+  
+  // Resolve ~ to home directory
+  if (basePath.startsWith('~')) {
+    basePath = basePath.replace('~', os.homedir())
+  }
+  
+  const resolvedBase = path.isAbsolute(basePath)
+    ? basePath
+    : path.resolve(process.cwd(), basePath)
+
+  async function walk(dir: string, depth: number) {
+    if (depth > maxDepth || results.length >= maxFiles) return
+    
+    try {
+      const entries = await fs.readdir(dir, { withFileTypes: true })
+      
+      for (const entry of entries) {
+        if (results.length >= maxFiles) break
+        
+        // Skip hidden files and common ignored directories
+        if (entry.name.startsWith('.')) continue
+        if (entry.name === 'node_modules') continue
+        if (entry.name === 'dist') continue
+        if (entry.name === 'build') continue
+        
+        const fullPath = path.join(dir, entry.name)
+        const relativePath = path.relative(resolvedBase, fullPath)
+        
+        if (entry.isDirectory()) {
+          if (includeDirectories) {
+            results.push(relativePath + '/')
+          }
+          await walk(fullPath, depth + 1)
+        } else {
+          results.push(relativePath)
+        }
+      }
+    } catch {
+      // Ignore permission errors etc
+    }
+  }
+  
+  await walk(resolvedBase, 0)
+  return results.sort()
+}
+
 export async function searchFiles(
   searchPath: string,
   prefix: string,