termcast 1.3.9

package/src/apis/clipboard.tsx

@@ -0,0 +1,200 @@
+import type { PathLike } from 'node:fs'
+import fs from 'node:fs'
+import path from 'node:path'
+import { exec } from 'child_process'
+import { promisify } from 'util'
+import { copyToClipboard, pasteContent } from 'termcast/src/action-utils'
+import { logger } from 'termcast/src/logger'
+
+const execAsync = promisify(exec)
+const platform = process.platform
+
+async function copyFileToClipboard(filePath: string): Promise<void> {
+  const absolutePath = path.resolve(filePath)
+
+  if (!fs.existsSync(absolutePath)) {
+    throw new Error(`File not found: ${absolutePath}`)
+  }
+
+  try {
+    if (platform === 'darwin') {
+      // macOS: Use osascript to copy file to clipboard
+      const script = `osascript -e 'set the clipboard to (POSIX file "${absolutePath}")'`
+      await execAsync(script)
+      logger.log(`📋 Copied file to clipboard: ${filePath}`)
+    } else if (platform === 'linux') {
+      // Linux: Copy file path as text and file URI
+      const fileUri = `file://${absolutePath}`
+      await execAsync(
+        `echo '${fileUri}' | xclip -selection clipboard -t text/uri-list`,
+      )
+      logger.log(`📋 Copied file to clipboard: ${filePath}`)
+    } else if (platform === 'win32') {
+      // Windows: Use PowerShell to copy file to clipboard
+      const script = `powershell -command "Set-Clipboard -Path '${absolutePath}'"`
+      await execAsync(script)
+      logger.log(`📋 Copied file to clipboard: ${filePath}`)
+    } else {
+      logger.log(`📋 File copy not supported on ${platform}: ${filePath}`)
+    }
+  } catch (error) {
+    logger.log(`📋 Failed to copy file to clipboard: ${error}`)
+    throw error
+  }
+}
+
+interface ClipboardType {
+  copy: (
+    content: string | number | Clipboard.Content,
+    options?: Clipboard.CopyOptions,
+  ) => Promise<void>
+  clear: () => Promise<void>
+  paste: (content: string | number | Clipboard.Content) => Promise<void>
+  read: (options?: { offset?: number }) => Promise<Clipboard.ReadContent>
+  readText: (options?: { offset?: number }) => Promise<string | undefined>
+}
+
+export const Clipboard: ClipboardType = {
+  async copy(
+    content: string | number | Clipboard.Content,
+    options?: Clipboard.CopyOptions,
+  ): Promise<void> {
+    let textContent: string
+
+    if (typeof content === 'string' || typeof content === 'number') {
+      textContent = String(content)
+    } else if ('text' in content) {
+      textContent = content.text || ''
+    } else if ('file' in content) {
+      await copyFileToClipboard(String(content.file))
+      return
+    } else if ('html' in content) {
+      textContent = content.text || content.html
+    } else {
+      throw new Error('Invalid clipboard content type')
+    }
+
+    await copyToClipboard(textContent, options?.concealed)
+  },
+
+  async clear(): Promise<void> {
+    await copyToClipboard('', false)
+    logger.log('📋 Clipboard cleared')
+  },
+
+  async paste(content: string | number | Clipboard.Content): Promise<void> {
+    let textContent: string
+
+    if (typeof content === 'string' || typeof content === 'number') {
+      textContent = String(content)
+    } else if ('text' in content) {
+      textContent = content.text || ''
+    } else if ('file' in content) {
+      logger.log(`📝 File paste not yet implemented: ${content.file}`)
+      return
+    } else if ('html' in content) {
+      textContent = content.text || content.html
+    } else {
+      throw new Error('Invalid clipboard content type')
+    }
+
+    await pasteContent(textContent)
+  },
+
+  async read(options?: { offset?: number }): Promise<Clipboard.ReadContent> {
+    if (options?.offset && options.offset > 0) {
+      logger.log('📋 Clipboard history not yet implemented')
+    }
+
+    try {
+      let text = ''
+      let file: string | undefined
+
+      if (platform === 'darwin') {
+        // Try to get file first
+        try {
+          const fileCheckScript = `osascript -e 'try' -e 'get the clipboard as «class furl»' -e 'POSIX path of result' -e 'end try'`
+          const { stdout: filePath } = await execAsync(fileCheckScript)
+          if (filePath && filePath.trim()) {
+            file = filePath.trim()
+          }
+        } catch {
+          // No file in clipboard, try text
+        }
+
+        // Get text content
+        const { stdout } = await execAsync('pbpaste')
+        text = stdout
+      } else if (platform === 'linux') {
+        // Check for file URIs
+        try {
+          const { stdout: fileUri } = await execAsync(
+            'xclip -selection clipboard -t text/uri-list -o',
+          )
+          if (fileUri && fileUri.startsWith('file://')) {
+            file = fileUri.replace('file://', '').trim()
+          }
+        } catch {
+          // No file in clipboard
+        }
+
+        // Get text content
+        try {
+          const { stdout } = await execAsync('xclip -selection clipboard -o')
+          text = stdout
+        } catch {
+          // No text in clipboard
+        }
+      } else if (platform === 'win32') {
+        // Windows: Get clipboard content
+        const { stdout } = await execAsync(
+          'powershell -command "Get-Clipboard"',
+        )
+        text = stdout
+
+        // Check if it's a file path
+        if (text && fs.existsSync(text.trim())) {
+          file = text.trim()
+        }
+      }
+
+      return { text, file }
+    } catch (error) {
+      logger.log(`📋 Failed to read clipboard: ${error}`)
+      return { text: '' }
+    }
+  },
+
+  async readText(options?: { offset?: number }): Promise<string | undefined> {
+    const content = await this.read(options)
+    return content.text || undefined
+  },
+}
+
+export namespace Clipboard {
+  export type ReadContent = {
+    text: string
+    file?: string
+    html?: string
+  }
+
+  export type Content =
+    | {
+        text: string
+      }
+    | {
+        file: PathLike
+      }
+    | {
+        html: string
+        text?: string
+      }
+
+  export type CopyOptions = {
+    concealed?: boolean
+  }
+}
+
+export const copyTextToClipboard = Clipboard.copy
+export const clearClipboard = Clipboard.clear
+export const pasteText = Clipboard.paste

package/src/apis/environment.tsx

@@ -0,0 +1,239 @@
+/**
+ * Environment API - Provides access to environment information and context
+ *
+ * Raycast Docs: https://developers.raycast.com/api-reference/environment
+ *
+ * The environment object provides information about the command's runtime context,
+ * including theme settings, development mode, launch type, and paths. LaunchType enum
+ * indicates whether the command was triggered by user action or background process.
+ *
+ * Key features:
+ * - Access to appearance/theme (dark/light)
+ * - Extension and command metadata
+ * - Launch context (user-initiated vs background)
+ * - Support and assets paths for file storage
+ * - System integration (selected Finder items, selected text)
+ */
+
+import os from 'node:os'
+import path from 'node:path'
+import fs from 'node:fs'
+import { execSync } from 'node:child_process'
+import { useStore } from '../state'
+
+export interface Environment {
+  appearance: 'dark' | 'light'
+  assetsPath: string
+  commandMode: 'view' | 'no-view' | 'menu-bar'
+  commandName: string
+  extensionName: string
+  isDevelopment: boolean
+  launchType: LaunchType
+  ownerOrAuthorName: string
+  raycastVersion: string
+  supportPath: string
+  textSize: 'medium' | 'large'
+  canAccess(api: any): boolean
+  theme: 'dark' | 'light'
+}
+
+export enum LaunchType {
+  UserInitiated = 'userInitiated',
+  Background = 'background',
+}
+
+export interface LaunchProps<
+  T extends Record<string, any> = Record<string, any>,
+> {
+  arguments: T
+  fallbackText?: string
+  launchContext?: { [key: string]: any }
+}
+
+class EnvironmentImpl implements Environment {
+  constructor() {
+    // Bind all methods to this instance
+    this.canAccess = this.canAccess.bind(this)
+  }
+
+  get appearance(): 'dark' | 'light' {
+    // Try to detect system theme on macOS
+    if (process.platform === 'darwin') {
+      try {
+        const result = execSync(
+          'defaults read -g AppleInterfaceStyle 2>/dev/null',
+          { encoding: 'utf8' },
+        )
+        return result.includes('Dark') ? 'dark' : 'light'
+      } catch {
+        return 'light'
+      }
+    }
+    return 'light'
+  }
+
+  get assetsPath(): string {
+    const state = useStore.getState()
+    if (state.extensionPath) {
+      return path.join(state.extensionPath, 'assets')
+    }
+    // TODO: Fallback for non-dev mode extensions
+    return path.join(os.homedir(), '.termcast', 'assets')
+  }
+
+  get commandMode(): 'view' | 'no-view' | 'menu-bar' {
+    const state = useStore.getState()
+    if (state.currentCommandName && state.extensionPackageJson?.commands) {
+      const command = state.extensionPackageJson.commands.find(
+        (cmd) => cmd.name === state.currentCommandName,
+      )
+      if (command) {
+        return command.mode
+      }
+    }
+    return 'view'
+  }
+
+  get commandName(): string {
+    const state = useStore.getState()
+    if (state.currentCommandName) {
+      return state.currentCommandName
+    }
+    return ''
+  }
+
+  get extensionName(): string {
+    const state = useStore.getState()
+    if (state.extensionPackageJson?.name) {
+      return state.extensionPackageJson.name
+    }
+    if (state.extensionPath) {
+      return path.basename(state.extensionPath)
+    }
+    return ''
+  }
+
+  get isDevelopment(): boolean {
+    const state = useStore.getState()
+    // We're in development mode if devElement is set
+    return state.devElement !== null
+  }
+
+  get launchType(): LaunchType {
+    // TODO: Support background commands when implemented
+    return LaunchType.UserInitiated
+  }
+
+  get ownerOrAuthorName(): string {
+    const state = useStore.getState()
+    const pkg = state.extensionPackageJson
+    if (pkg?.author) {
+      return pkg.author
+    }
+    if (pkg?.owner) {
+      return pkg.owner
+    }
+    return ''
+  }
+
+  get raycastVersion(): string {
+    // Return a version that indicates termcast compatibility
+    return '1.0.0-termcast'
+  }
+
+  get supportPath(): string {
+    // Create a support directory in the user's data directory
+    const baseDir = path.join(
+      os.homedir(),
+      '.termcast',
+      'support',
+      this.extensionName,
+    )
+
+    // Ensure the directory exists
+    if (!fs.existsSync(baseDir)) {
+      fs.mkdirSync(baseDir, { recursive: true })
+    }
+
+    return baseDir
+  }
+
+  get textSize(): 'medium' | 'large' {
+    // TODO: Make this configurable via preferences
+    return 'medium'
+  }
+
+  // Alias for appearance to match Raycast API
+  get theme(): 'dark' | 'light' {
+    return this.appearance
+  }
+
+  canAccess(api: any): boolean {
+    // In termcast, all APIs are accessible
+    // This method exists for Raycast compatibility
+    return true
+  }
+}
+
+export const environment = new EnvironmentImpl()
+
+export async function getSelectedFinderItems(): Promise<string[]> {
+  // TODO: Improve cross-platform support
+  // Currently only works on macOS using AppleScript
+  // Should add support for:
+  // 1. Windows Explorer selection (via PowerShell or COM)
+  // 2. Linux file managers (Nautilus, Dolphin, etc.)
+  if (process.platform === 'darwin') {
+    try {
+      // Use AppleScript to get selected Finder items
+      const script = `
+        tell application "Finder"
+          set theSelection to selection
+          set thePaths to {}
+          repeat with theItem in theSelection
+            set end of thePaths to POSIX path of (theItem as alias)
+          end repeat
+          return thePaths
+        end tell
+      `
+      const result = execSync(`osascript -e '${script}'`, {
+        encoding: 'utf8',
+      })
+      return result.trim().split(', ').filter(Boolean)
+    } catch {
+      return []
+    }
+  }
+  // TODO: Implement for other platforms
+  return []
+}
+
+export async function getSelectedText(): Promise<string> {
+  // TODO: Improve implementation and cross-platform support
+  // Current implementation has issues:
+  // 1. Modifies the clipboard (should preserve original content)
+  // 2. Uses delay which may not be reliable
+  // 3. Only works on macOS
+  // Should add support for Windows and Linux
+  if (process.platform === 'darwin') {
+    try {
+      // TODO: Save and restore clipboard contents to avoid side effects
+      // Use AppleScript to get selected text from frontmost application
+      const script = `
+        tell application "System Events"
+          keystroke "c" using command down
+          delay 0.1
+          return (the clipboard)
+        end tell
+      `
+      const result = execSync(`osascript -e '${script}'`, {
+        encoding: 'utf8',
+      })
+      return result.trim()
+    } catch {
+      return ''
+    }
+  }
+  // TODO: Implement for Windows (via PowerShell) and Linux (xclip/xsel)
+  return ''
+}

package/src/apis/hud.tsx

@@ -0,0 +1,86 @@
+import React, { useEffect } from 'react'
+import { Theme } from 'termcast/src/theme'
+import { TextAttributes } from '@opentui/core'
+import { logger } from 'termcast/src/logger'
+import { useStore } from 'termcast/src/state'
+import { useTerminalDimensions } from '@opentui/react'
+import { Toast } from 'termcast/src/apis/toast'
+import { PopToRootType } from 'termcast/src/apis/window'
+
+// Re-export PopToRootType from window module
+export { PopToRootType } from 'termcast/src/apis/window'
+
+interface HUDComponentProps {
+  title: string
+  onHide: () => void
+}
+
+function HUDComponent({ title, onHide }: HUDComponentProps): any {
+  const dimensions = useTerminalDimensions()
+
+  useEffect(() => {
+    // HUD displays for 2 seconds then automatically hides
+    const timer = setTimeout(() => {
+      onHide()
+    }, 2000)
+    return () => clearTimeout(timer)
+  }, [onHide])
+
+  // Center the HUD message
+  const padding = Math.max(
+    0,
+    Math.floor((dimensions.width - title.length - 4) / 2),
+  )
+
+  return (
+    <box
+      borderColor={Theme.border}
+      paddingLeft={1}
+      paddingRight={1}
+      flexDirection='row'
+      alignItems='center'
+    >
+      <text paddingLeft={padding}>✓ </text>
+      <text fg={Theme.text} attributes={TextAttributes.BOLD}>
+        {title}
+      </text>
+    </box>
+  )
+}
+
+// Create a custom Toast class for HUD that displays with HUD styling
+class HUDToast extends Toast {
+  constructor(title: string) {
+    super({
+      title,
+      style: Toast.Style.Success,
+    })
+  }
+}
+
+export async function showHUD(
+  title: string,
+  options?: {
+    clearRootSearch?: boolean
+    popToRootType?: PopToRootType
+  },
+): Promise<void> {
+  // Show the HUD component in the toast area (bottom of screen)
+  useStore.setState({
+    toast: (
+      <HUDComponent
+        title={title}
+        onHide={() => {
+          useStore.setState({ toast: null })
+        }}
+      />
+    ),
+  })
+
+  // TODO: Handle closeMainWindow behavior with clearRootSearch and popToRootType options
+  // This would need to be implemented based on the actual window management system
+
+  logger.log('showHUD:', title, options)
+
+  return Promise.resolve()
+}

package/src/apis/localstorage.test.ts

@@ -0,0 +1,164 @@
+import { describe, test, expect, beforeEach, afterAll } from 'bun:test'
+import { LocalStorage } from './localstorage'
+import * as os from 'os'
+import * as path from 'path'
+import * as fs from 'fs'
+
+describe('LocalStorage', () => {
+  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)
+    // }
+  })
+
+  describe('setItem and getItem', () => {
+    test('stores and retrieves string values', async () => {
+      await LocalStorage.setItem('test-key', 'test-value')
+      const result = await LocalStorage.getItem<string>('test-key')
+      expect(result).toBe('test-value')
+    })
+
+    test('stores and retrieves number values', async () => {
+      await LocalStorage.setItem('number-key', 42)
+      const result = await LocalStorage.getItem<number>('number-key')
+      expect(result).toBe(42)
+      expect(typeof result).toBe('number')
+    })
+
+    test('stores and retrieves boolean values', async () => {
+      await LocalStorage.setItem('bool-key-true', true)
+      await LocalStorage.setItem('bool-key-false', false)
+
+      const resultTrue = await LocalStorage.getItem<boolean>('bool-key-true')
+      const resultFalse = await LocalStorage.getItem<boolean>('bool-key-false')
+
+      expect(resultTrue).toBe(true)
+      expect(resultFalse).toBe(false)
+      expect(typeof resultTrue).toBe('boolean')
+      expect(typeof resultFalse).toBe('boolean')
+    })
+
+    test('returns undefined for non-existent keys', async () => {
+      const result = await LocalStorage.getItem('non-existent')
+      expect(result).toBeUndefined()
+    })
+
+    test('overwrites existing values', async () => {
+      await LocalStorage.setItem('key', 'initial')
+      await LocalStorage.setItem('key', 'updated')
+      const result = await LocalStorage.getItem('key')
+      expect(result).toBe('updated')
+    })
+  })
+
+  describe('removeItem', () => {
+    test('removes stored items', async () => {
+      await LocalStorage.setItem('to-remove', 'value')
+      let result = await LocalStorage.getItem('to-remove')
+      expect(result).toBe('value')
+
+      await LocalStorage.removeItem('to-remove')
+      result = await LocalStorage.getItem('to-remove')
+      expect(result).toBeUndefined()
+    })
+
+    test('does not throw when removing non-existent key', async () => {
+      // Should complete without throwing
+      await LocalStorage.removeItem('non-existent')
+      expect(true).toBe(true) // Test passes if we reach here
+    })
+  })
+
+  describe('allItems', () => {
+    test('returns all stored items', async () => {
+      await LocalStorage.setItem('key1', 'value1')
+      await LocalStorage.setItem('key2', 42)
+      await LocalStorage.setItem('key3', true)
+
+      const items = await LocalStorage.allItems()
+      expect(items).toEqual({
+        key1: 'value1',
+        key2: 42,
+        key3: true,
+      })
+    })
+
+    test('returns empty object when no items stored', async () => {
+      const items = await LocalStorage.allItems()
+      expect(items).toEqual({})
+    })
+
+    test('supports typed interface', async () => {
+      interface TestValues {
+        todo: string
+        priority: number
+        completed: boolean
+      }
+
+      await LocalStorage.setItem('todo', 'Write tests')
+      await LocalStorage.setItem('priority', 1)
+      await LocalStorage.setItem('completed', false)
+
+      const items = await LocalStorage.allItems<TestValues>()
+      expect(items.todo).toBe('Write tests')
+      expect(items.priority).toBe(1)
+      expect(items.completed).toBe(false)
+    })
+  })
+
+  describe('clear', () => {
+    test('removes all stored items', async () => {
+      await LocalStorage.setItem('key1', 'value1')
+      await LocalStorage.setItem('key2', 'value2')
+      await LocalStorage.setItem('key3', 'value3')
+
+      let items = await LocalStorage.allItems()
+      expect(Object.keys(items).length).toBe(3)
+
+      await LocalStorage.clear()
+      items = await LocalStorage.allItems()
+      expect(items).toEqual({})
+    })
+  })
+
+  describe('edge cases', () => {
+    test('handles special characters in keys', async () => {
+      const specialKey = 'key-with-!@#$%^&*()_+={}[]|\\:";\'<>?,./spaces'
+      await LocalStorage.setItem(specialKey, 'special')
+      const result = await LocalStorage.getItem(specialKey)
+      expect(result).toBe('special')
+    })
+
+    test('handles special characters in string values', async () => {
+      const specialValue = 'value with !@#$%^&*()_+={}[]|\\:";\'<>?,./\n\t\r'
+      await LocalStorage.setItem('key', specialValue)
+      const result = await LocalStorage.getItem('key')
+      expect(result).toBe(specialValue)
+    })
+
+    test('handles large numbers', async () => {
+      const largeNumber = Number.MAX_SAFE_INTEGER
+      await LocalStorage.setItem('large', largeNumber)
+      const result = await LocalStorage.getItem<number>('large')
+      expect(result).toBe(largeNumber)
+    })
+
+    test('handles negative numbers', async () => {
+      await LocalStorage.setItem('negative', -42.5)
+      const result = await LocalStorage.getItem<number>('negative')
+      expect(result).toBe(-42.5)
+    })
+
+    test('handles empty string values', async () => {
+      await LocalStorage.setItem('empty', '')
+      const result = await LocalStorage.getItem<string>('empty')
+      expect(result).toBe('')
+    })
+  })
+})