termcast 1.3.9

package/src/apis/preferences.tsx

@@ -0,0 +1,140 @@
+import React from 'react'
+import { useStore } from 'termcast/src/state'
+import { logger } from 'termcast/src/logger'
+import { LocalStorage } from 'termcast/src/apis/localstorage'
+import { ExtensionPreferences } from 'termcast/src/components/extension-preferences'
+
+export type PreferenceValues = {
+  [preferenceName: string]: any
+}
+
+/**
+ * A function to access the preference values that have been passed to the command.
+ * Each preference name is mapped to its value, and the defined default values are used as fallback values.
+ *
+ * @returns An object with the preference names as property key and the typed value as property value.
+ */
+export function getPreferenceValues<
+  Values extends PreferenceValues = PreferenceValues,
+>(): Values {
+  const state = useStore.getState()
+  const { extensionPackageJson, currentCommandName, extensionPath } = state
+
+  // Determine the extension name from package.json or path
+  let extensionName: string | null = null
+  if (extensionPackageJson?.name) {
+    extensionName = extensionPackageJson.name
+  } else if (extensionPath) {
+    // Extract extension name from path if package.json not available
+    const pathParts = extensionPath.split('/')
+    extensionName = pathParts[pathParts.length - 1]
+  }
+
+  if (!extensionName) {
+    logger.log('No extension context found for preferences')
+    return {} as Values
+  }
+
+  try {
+    // First try to load command-specific preferences, then fall back to extension preferences
+    if (currentCommandName) {
+      const commandPreferencesKey = `preferences.${extensionName}.${currentCommandName}`
+      const commandPreferences = LocalStorage.getItemSync(commandPreferencesKey)
+
+      if (commandPreferences && typeof commandPreferences === 'string') {
+        try {
+          const parsed = JSON.parse(commandPreferences)
+          logger.log(
+            `Loaded command preferences for ${extensionName}/${currentCommandName}:`,
+            parsed,
+          )
+          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
+}
+
+/**
+ * Opens the extension's preferences screen.
+ *
+ * @returns A Promise that resolves when the extensions preferences screen is opened.
+ */
+export async function openExtensionPreferences(): Promise<void> {
+  const state = useStore.getState()
+  const { extensionPackageJson, navigationStack } = state
+
+  if (!extensionPackageJson?.name) {
+    throw new Error('No current extension found')
+  }
+
+  logger.log(`Opening extension preferences for ${extensionPackageJson.name}`)
+
+  // Push the preferences component to the navigation stack
+  const preferencesComponent = (
+    <ExtensionPreferences extensionName={extensionPackageJson.name} />
+  )
+
+  useStore.setState({
+    navigationStack: [...navigationStack, { element: preferencesComponent }],
+    dialogStack: [],
+  })
+
+  return Promise.resolve()
+}
+
+/**
+ * Opens the command's preferences screen.
+ *
+ * @returns A Promise that resolves when the command's preferences screen is opened.
+ */
+export async function openCommandPreferences(): Promise<void> {
+  const state = useStore.getState()
+  const { extensionPackageJson, currentCommandName, navigationStack } = state
+
+  if (!extensionPackageJson?.name || !currentCommandName) {
+    throw new Error('No current command found')
+  }
+
+  logger.log(
+    `Opening command preferences for ${extensionPackageJson.name}/${currentCommandName}`,
+  )
+
+  // Push the preferences component to the navigation stack
+  const preferencesComponent = (
+    <ExtensionPreferences
+      extensionName={extensionPackageJson.name}
+      commandName={currentCommandName}
+    />
+  )
+
+  useStore.setState({
+    navigationStack: [...navigationStack, { element: preferencesComponent }],
+    dialogStack: [],
+  })
+
+  return Promise.resolve()
+}

package/src/apis/toast.tsx

@@ -0,0 +1,388 @@
+import React, { useEffect, useState } 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 { useKeyboard, useTerminalDimensions } from '@opentui/react'
+import { useIsInFocus } from 'termcast/src/internal/focus-context'
+
+export namespace Toast {
+  export interface Options {
+    title: string
+    message?: string
+    style?: Style
+    primaryAction?: ActionOptions
+    secondaryAction?: ActionOptions
+  }
+
+  export interface ActionOptions {
+    title: string
+    shortcut?: any
+    onAction: (toast: Toast) => void
+  }
+
+  export type Style = 'SUCCESS' | 'FAILURE' | 'ANIMATED'
+}
+
+export class Toast {
+  private options: Toast.Options
+  private id: string
+  private callbacks: {
+    onUpdate?: (toast: Toast) => void
+    onHide?: () => void
+  } = {}
+
+  static Style = {
+    Success: 'SUCCESS' as Toast.Style,
+    Failure: 'FAILURE' as Toast.Style,
+    Animated: 'ANIMATED' as Toast.Style,
+  }
+
+  constructor(props: Toast.Options) {
+    this.options = { ...props }
+    this.id = Math.random().toString(36).substring(7)
+
+    // Bind all methods to this instance
+    this.show = this.show.bind(this)
+    this.hide = this.hide.bind(this)
+    this.update = this.update.bind(this)
+    this._setCallbacks = this._setCallbacks.bind(this)
+    this._getId = this._getId.bind(this)
+  }
+
+  get style(): Toast.Style {
+    return this.options.style || Toast.Style.Success
+  }
+
+  set style(style: Toast.Style) {
+    this.options.style = style
+    this.update()
+  }
+
+  get title(): string {
+    return this.options.title
+  }
+
+  set title(title: string) {
+    this.options.title = title
+    this.update()
+  }
+
+  get message(): string | undefined {
+    return this.options.message
+  }
+
+  set message(message: string | undefined) {
+    this.options.message = message
+    this.update()
+  }
+
+  get primaryAction(): Toast.ActionOptions | undefined {
+    return this.options.primaryAction
+  }
+
+  set primaryAction(action: Toast.ActionOptions | undefined) {
+    this.options.primaryAction = action
+    this.update()
+  }
+
+  get secondaryAction(): Toast.ActionOptions | undefined {
+    return this.options.secondaryAction
+  }
+
+  set secondaryAction(action: Toast.ActionOptions | undefined) {
+    this.options.secondaryAction = action
+    this.update()
+  }
+
+  async show(): Promise<void> {
+    showToastInternal(this)
+  }
+
+  async hide(): Promise<void> {
+    useStore.setState({ toast: null })
+    if (this.callbacks.onHide) {
+      this.callbacks.onHide()
+    }
+  }
+
+  private update(): void {
+    if (this.callbacks.onUpdate) {
+      this.callbacks.onUpdate(this)
+    }
+  }
+
+  _setCallbacks(callbacks: typeof this.callbacks): void {
+    this.callbacks = callbacks
+  }
+
+  _getId(): string {
+    return this.id
+  }
+}
+
+export interface ToastComponentProps {
+  toast: Toast
+  onHide: () => void
+}
+
+export function ToastComponent({ toast, onHide }: ToastComponentProps): any {
+  const [, forceUpdate] = useState(0)
+  const dimensions = useTerminalDimensions()
+  const inFocus = useIsInFocus()
+
+  useEffect(() => {
+    const onUpdate = () => {
+      forceUpdate((n) => n + 1)
+    }
+    toast._setCallbacks({ onUpdate, onHide })
+    return () => {
+      toast._setCallbacks({})
+    }
+  }, [toast, onHide])
+
+  const getIcon = () => {
+    switch (toast.style) {
+      case Toast.Style.Success:
+        return '✓'
+      case Toast.Style.Failure:
+        return '✗'
+      case Toast.Style.Animated:
+        return '⣾⣽⣻⢿⡿⣟⣯⣷'
+      default:
+        return '✓'
+    }
+  }
+
+  const getIconColor = () => {
+    switch (toast.style) {
+      case Toast.Style.Success:
+        return Theme.success
+      case Toast.Style.Failure:
+        return Theme.error
+      case Toast.Style.Animated:
+        return Theme.primary
+      default:
+        return Theme.success
+    }
+  }
+
+  const [animationFrame, setAnimationFrame] = useState(0)
+
+  useEffect(() => {
+    if (toast.style === Toast.Style.Animated) {
+      const interval = setInterval(() => {
+        setAnimationFrame((prev) => (prev + 1) % 8)
+      }, 100)
+      return () => clearInterval(interval)
+    }
+  }, [toast.style])
+
+  useEffect(() => {
+    if (toast.style !== Toast.Style.Animated) {
+      // Use longer duration for error toasts
+      const duration = toast.style === Toast.Style.Failure ? 8000 : 5000
+      const timer = setTimeout(() => {
+        onHide()
+      }, duration)
+      return () => clearTimeout(timer)
+    }
+  }, [toast.style, onHide])
+
+  const icon =
+    toast.style === Toast.Style.Animated ? getIcon()[animationFrame] : getIcon()
+
+  useKeyboard((evt) => {
+    if (!inFocus) return
+
+    if (evt.name === 'escape') {
+      onHide()
+    } else if (toast.primaryAction && evt.name === 'enter') {
+      toast.primaryAction.onAction(toast)
+    } else if (toast.secondaryAction && evt.name === 'tab') {
+      toast.secondaryAction.onAction(toast)
+    }
+  })
+
+  // TODO use flexWrap when implemented
+  const wrapText = (text: string, maxWidth: number): string[] => {
+    if (!text) return []
+
+    const words = text.split(' ')
+    const lines: string[] = []
+    let currentLine = ''
+
+    for (const word of words) {
+      const testLine = currentLine ? `${currentLine} ${word}` : word
+      if (testLine.length <= maxWidth) {
+        currentLine = testLine
+      } else {
+        if (currentLine) {
+          lines.push(currentLine)
+        }
+        currentLine = word
+      }
+    }
+
+    if (currentLine) {
+      lines.push(currentLine)
+    }
+
+    return lines.slice(0, 3)
+  }
+
+  const iconLength = 2
+  const titleLength = toast.title.length
+  const actionsLength = (() => {
+    let length = 0
+    if (toast.primaryAction) {
+      length += toast.primaryAction.title.length + 4
+    }
+    if (toast.secondaryAction) {
+      length += toast.secondaryAction.title.length + 4
+    }
+    return length
+  })()
+
+  const availableWidth =
+    dimensions.width - iconLength - titleLength - actionsLength - 8
+  const messageLines = toast.message
+    ? wrapText(toast.message, Math.max(20, availableWidth))
+    : []
+
+  return (
+    <box
+      borderColor={Theme.border}
+      paddingLeft={1}
+      paddingRight={1}
+      flexDirection='column'
+    >
+      <box flexDirection='row' alignItems='center'>
+        <text fg={getIconColor()}>{icon} </text>
+        <text fg={Theme.text} attributes={TextAttributes.BOLD}>
+          {toast.title}
+        </text>
+        {messageLines.length > 0 && (
+          <text fg={Theme.textMuted}> - {messageLines[0]}</text>
+        )}
+        {toast.primaryAction && (
+          <text fg={Theme.primary}> [{toast.primaryAction.title} ↵]</text>
+        )}
+        {toast.secondaryAction && (
+          <text fg={Theme.textMuted}> [{toast.secondaryAction.title} ⇥]</text>
+        )}
+      </box>
+      {messageLines.slice(1).map((line, index) => (
+        <box key={index} paddingLeft={iconLength + titleLength + 3}>
+          <text fg={Theme.textMuted}>{line}</text>
+        </box>
+      ))}
+    </box>
+  )
+}
+
+let currentToastInstance: Toast | null = null
+
+export function showToastInternal(toast: Toast): void {
+  currentToastInstance = toast
+  useStore.setState({
+    toast: (
+      <ToastComponent
+        toast={toast}
+        onHide={() => {
+          useStore.setState({ toast: null })
+          currentToastInstance = null
+        }}
+      />
+    ),
+  })
+}
+
+export async function showToast(options: Toast.Options): Promise<Toast>
+export async function showToast(
+  style: Toast.Style,
+  title: string,
+  message?: string,
+): Promise<Toast>
+export async function showToast(
+  optionsOrStyle: Toast.Options | Toast.Style,
+  title?: string,
+  message?: string,
+): Promise<Toast> {
+  let options: Toast.Options
+
+  if (typeof optionsOrStyle === 'string') {
+    options = {
+      style: optionsOrStyle,
+      title: title!,
+      message,
+    }
+  } else {
+    options = optionsOrStyle
+  }
+
+  const toast = new Toast(options)
+  await toast.show()
+  return toast
+}
+
+/**
+ * Creates and shows a failure toast for error scenarios.
+ *
+ * This is a convenience function that automatically creates a toast with failure styling
+ * and extracts error messages from various error types.
+ *
+ * @param error - The error to display. Can be an Error object, string, or any object with a message property
+ * @param options - Optional configuration
+ * @param options.title - Custom title for the toast (defaults to error name or "Something went wrong")
+ * @param options.primaryAction - Optional action button to display on the toast
+ * @returns A Promise that resolves to the created Toast instance
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await riskyOperation()
+ * } catch (error) {
+ *   await showFailureToast(error, {
+ *     title: "Operation Failed",
+ *     primaryAction: {
+ *       title: "Retry",
+ *       onAction: () => retryOperation()
+ *     }
+ *   })
+ * }
+ * ```
+ */
+export async function showFailureToast(
+  error: unknown,
+  options?: {
+    title?: string
+    primaryAction?: Toast.ActionOptions
+  },
+): Promise<Toast> {
+  let errorMessage: string
+  let errorTitle: string
+
+  if (error instanceof Error) {
+    errorMessage = error.message
+    errorTitle = options?.title || error.name || 'Something went wrong'
+  } else if (typeof error === 'string') {
+    errorMessage = error
+    errorTitle = options?.title || 'Something went wrong'
+  } else if (error && typeof error === 'object' && 'message' in error) {
+    errorMessage = String(error.message)
+    errorTitle = options?.title || 'Something went wrong'
+  } else {
+    errorMessage = String(error)
+    errorTitle = options?.title || 'Something went wrong'
+  }
+
+  const toastOptions: Toast.Options = {
+    title: errorTitle,
+    message: errorMessage,
+    style: Toast.Style.Failure,
+    primaryAction: options?.primaryAction,
+  }
+
+  return showToast(toastOptions)
+}

package/src/apis/window.tsx

@@ -0,0 +1,61 @@
+export enum PopToRootType {
+  Default = 'default',
+  Immediate = 'immediate',
+  Suspended = 'suspended',
+}
+
+interface CloseMainWindowOptions {
+  clearRootSearch?: boolean
+  popToRootType?: PopToRootType
+}
+
+// TODO does not do anything
+export async function closeMainWindow({
+  clearRootSearch,
+  popToRootType = PopToRootType.Default,
+}: CloseMainWindowOptions = {}): Promise<void> {
+  return
+  // try {
+  //     const currentPid = process.pid
+
+  //     // On macOS, request accessibility permissions if needed
+  //     if (process.platform === 'darwin') {
+  //         windowManager.requestAccessibility()
+  //     }
+
+  //     // Get all windows
+  //     const windows = windowManager.getWindows()
+
+  //     // Find a window that's not the current process
+  //     const previousWindow = windows.find((win) => {
+  //         try {
+  //             if (!win.isVisible) return false
+  //             if (overlayWindows.includes(win.getTitle())) return false
+
+  //             return win.processId !== currentPid
+  //         } catch {
+  //             return false
+  //         }
+  //     })
+
+  //     if (previousWindow) {
+  //         // Bring the previous window to focus
+  //         previousWindow.bringToTop()
+  //         logger.log(`Switched focus to window: ${previousWindow.getTitle()}`)
+  //     } else {
+  //         logger.log('No previous window found to focus')
+  //     }
+
+  //     // Minimize or hide the current window
+  //     // const currentWindow = windowManager.getActiveWindow()
+  //     // if (currentWindow) {
+  //     //     currentWindow.minimize()
+  //     // }
+
+  //     // TODO: Handle clearRootSearch behavior when main window functionality is implemented
+  //     // TODO: Handle popToRootType behavior when navigation stack is implemented
+  // } catch (error) {
+  //     logger.error('Failed to close main window:', error)
+  //     throw error
+  // }
+}

package/src/build.test.tsx

@@ -0,0 +1,78 @@
+import { describe, test, expect } from 'bun:test'
+import path from 'node:path'
+import { buildExtensionCommands } from './build'
+
+describe('buildExtensionCommands', () => {
+  test('builds a simple extension with multiple commands', async () => {
+    const fixtureDir = path.join(process.cwd(), 'fixtures/simple-extension')
+    const result = await buildExtensionCommands({
+      extensionPath: fixtureDir,
+      target: 'node',
+    })
+
+    // Replace the user-specific base path with a constant placeholder
+    const resultString = JSON.stringify(result, null, 2)
+    const normalizedString = resultString.replaceAll(
+      process.cwd(),
+      '/BASE_PATH',
+    )
+
+    expect(normalizedString).toMatchInlineSnapshot(`
+      "{
+        "commands": [
+          {
+            "name": "list-items",
+            "title": "List Items",
+            "subtitle": "Shows a list of items",
+            "description": "Displays a simple list with some items",
+            "mode": "view",
+            "filePath": "/BASE_PATH/fixtures/simple-extension/src/list-items.tsx",
+            "exists": true,
+            "bundledPath": "/BASE_PATH/fixtures/simple-extension/.termcast-bundle/list-items.js"
+          },
+          {
+            "name": "search-items",
+            "title": "Search Items",
+            "subtitle": "Search through items",
+            "description": "Search and filter through a list of items",
+            "mode": "view",
+            "filePath": "/BASE_PATH/fixtures/simple-extension/src/search-items.tsx",
+            "exists": true,
+            "bundledPath": "/BASE_PATH/fixtures/simple-extension/.termcast-bundle/search-items.js"
+          },
+          {
+            "name": "oauth",
+            "title": "Google Oauth",
+            "subtitle": "auth",
+            "description": "",
+            "mode": "view",
+            "filePath": "/BASE_PATH/fixtures/simple-extension/src/oauth.tsx",
+            "exists": true,
+            "bundledPath": "/BASE_PATH/fixtures/simple-extension/.termcast-bundle/oauth.js"
+          },
+          {
+            "name": "use-promise-demo",
+            "title": "usePromise Demo",
+            "subtitle": "Demonstrates usePromise hook",
+            "description": "Shows how to use the usePromise hook from @raycast/utils",
+            "mode": "view",
+            "filePath": "/BASE_PATH/fixtures/simple-extension/src/use-promise-demo.tsx",
+            "exists": true,
+            "bundledPath": "/BASE_PATH/fixtures/simple-extension/.termcast-bundle/use-promise-demo.js"
+          },
+          {
+            "name": "show-state",
+            "title": "Show State",
+            "subtitle": "Display current state as JSON",
+            "description": "Shows the current application state in JSON format",
+            "mode": "view",
+            "filePath": "/BASE_PATH/fixtures/simple-extension/src/show-state.tsx",
+            "exists": true,
+            "bundledPath": "/BASE_PATH/fixtures/simple-extension/.termcast-bundle/show-state.js"
+          }
+        ],
+        "bundleDir": "/BASE_PATH/fixtures/simple-extension/.termcast-bundle"
+      }"
+    `)
+  })
+})