termcast 1.3.10 → 1.3.18

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "termcast",
-  "version": "1.3.10",
+  "version": "1.3.18",
   "description": "Raycast for the terminal",
   "repository": "https://github.com/remorses/termcast",
   "scripts": {
     "build": "tsc && bun run binary",
+    "prepublishOnly": "tsc",
     "release": "cd .. && bun changeset version && /Users/morse/Documents/GitHub/changesets/packages/cli/bin.js publish # my own fork to support github releases",
     "binary": "bun build ./src/cli.tsx --env-file=\"\" --compile --outfile bin",
     "see-raycast-types": "zed node_modules/@raycast/api/types/index.d.ts",
@@ -29,8 +30,8 @@
   "author": "Tommaso De Rossi, morse <beats.by.morse@gmail.com>",
   "license": "",
   "dependencies": {
-    "@opentui/core": "0.1.23",
-    "@opentui/react": "0.1.23",
+    "@opentui/core": "0.1.60",
+    "@opentui/react": "0.1.60",
     "@tanstack/react-query": "^5.85.5",
     "@tanstack/react-query-persist-client": "^5.85.5",
     "cac": "^6.7.14",
@@ -40,19 +41,21 @@
     "jszip": "^3.10.1",
     "nanoid": "^5.1.5",
     "node-pty": "^1.1.0-beta34",
-    "react": "^19.1.1",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
     "react-hook-form": "^7.62.0",
     "string-dedent": "^3.0.2",
     "zustand": "^5.0.8"
   },
   "devDependencies": {
+    "tuistory": "workspace:*",
     "@types/bun": "^1.2.21",
-    "@types/node": "^24.3.0",
+    "@types/node": "^25.0.1",
     "@raycast/api": "^1.102.5",
     "@raycast/utils": "^2.2.1",
     "@xterm/addon-serialize": "^0.13.0",
     "@xterm/headless": "^5.5.0",
-    "bun-pty": "^0.3.2",
-    "vitest": "^3.2.4"
+    "bun-pty": "^0.4.2",
+    "vitest": "^4.0.15"
   }
 }

package/src/apis/toast.tsx

@@ -121,12 +121,12 @@ export class Toast {
   }
 }
 
-export interface ToastComponentProps {
+interface ToastContentProps {
   toast: Toast
   onHide: () => void
 }
 
-export function ToastComponent({ toast, onHide }: ToastComponentProps): any {
+function ToastContent({ toast, onHide }: ToastContentProps): any {
   const [, forceUpdate] = useState(0)
   const dimensions = useTerminalDimensions()
   const inFocus = useIsInFocus()
@@ -141,6 +141,18 @@ export function ToastComponent({ toast, onHide }: ToastComponentProps): any {
     }
   }, [toast, onHide])
 
+  useKeyboard((evt) => {
+    if (!inFocus) return
+
+    if (evt.name === 'escape') {
+      onHide()
+    } else if (toast.primaryAction && evt.name === 'return') {
+      toast.primaryAction.onAction(toast)
+    } else if (toast.secondaryAction && evt.name === 'tab') {
+      toast.secondaryAction.onAction(toast)
+    }
+  })
+
   const getIcon = () => {
     switch (toast.style) {
       case Toast.Style.Success:
@@ -180,7 +192,6 @@ export function ToastComponent({ toast, onHide }: ToastComponentProps): any {
 
   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()
@@ -192,19 +203,6 @@ export function ToastComponent({ toast, onHide }: ToastComponentProps): any {
   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 []
 
@@ -281,13 +279,36 @@ export function ToastComponent({ toast, onHide }: ToastComponentProps): any {
   )
 }
 
+export function ToastOverlay(): any {
+  const dimensions = useTerminalDimensions()
+  const toastElement = useStore((state) => state.toast)
+
+  if (!toastElement) {
+    return null
+  }
+
+  return (
+    <box
+      position='absolute'
+      left={0}
+      top={dimensions.height - 3}
+      width={dimensions.width}
+      height={3}
+      justifyContent='flex-end'
+      alignItems='center'
+    >
+      {toastElement}
+    </box>
+  )
+}
+
 let currentToastInstance: Toast | null = null
 
 export function showToastInternal(toast: Toast): void {
   currentToastInstance = toast
   useStore.setState({
     toast: (
-      <ToastComponent
+      <ToastContent
         toast={toast}
         onHide={() => {
           useStore.setState({ toast: null })

package/src/build.tsx

@@ -1,16 +1,18 @@
 import fs from 'node:fs'
 import path from 'node:path'
+import { execSync } from 'node:child_process'
 import type { BunPlugin } from 'bun'
 import { logger } from './logger'
 import { getCommandsWithFiles, CommandWithFile } from './package-json'
-import * as termcastApi from 'termcast'
+import * as termcastApi from './index'
 import * as opentuiReact from '@opentui/react'
 import * as opentuiCore from '@opentui/core'
 import * as react from 'react'
 
 const GLOBALS_NAMESPACE = 'globals'
+const VIRTUAL_ENTRY_NAMESPACE = 'virtual-entry'
 
-const aliasPlugin: BunPlugin = {
+export const aliasPlugin: BunPlugin = {
   name: 'alias-raycast-to-termcast',
   async setup(build) {
     // Import packages once at setup time
@@ -47,7 +49,7 @@ const aliasPlugin: BunPlugin = {
     })
 
     // Resolve external packages to globals namespace
-    build.onResolve({ filter: /^@termcast\/cli/ }, (args) => {
+    build.onResolve({ filter: /^termcast/ }, (args) => {
       return {
         path: 'termcast',
         namespace: GLOBALS_NAMESPACE,

package/src/cli.tsx

@@ -8,6 +8,8 @@ import { logger } from './logger'
 import { installExtension } from './utils'
 import './globals'
 import { startDevMode, triggerRebuild } from './extensions/dev'
+import { compileExtension } from './compile'
+import { releaseExtension } from './release'
 import { runHomeCommand } from './extensions/home'
 import { showToast, Toast } from './apis/toast'
 import packageJson from '../package.json'
@@ -176,6 +178,50 @@ cli
     }
   })
 
+cli
+  .command('compile [path]', 'Compile the extension to a standalone executable')
+  .option('-o, --outfile <path>', 'Output file path for the executable')
+  .option('--minify', 'Minify the output')
+  .action(async (extensionPath, options) => {
+    extensionPath = path.resolve(extensionPath || process.cwd())
+
+    console.log('Compiling extension to executable...')
+    try {
+      const result = await compileExtension({
+        extensionPath,
+        outfile: options.outfile,
+        minify: options.minify,
+      })
+
+      console.log(`\nExecutable created: ${result.outfile}`)
+      console.log(`Run it with: ${result.outfile}`)
+    } catch (error: any) {
+      console.error('Compile failed:', error.message)
+      process.exit(1)
+    }
+  })
+
+cli
+  .command('release <path>', 'Build and publish extension to GitHub releases')
+  .option('--single', 'Only compile for the current platform')
+  .action(async (extensionPath: string, options: { single?: boolean }) => {
+    extensionPath = path.resolve(extensionPath)
+
+    console.log('Building and releasing extension...')
+    try {
+      const result = await releaseExtension({
+        extensionPath,
+        single: options.single,
+      })
+
+      console.log(`\nRelease complete: v${result.version}`)
+      console.log(`Uploaded ${result.uploadedFiles.length} binaries`)
+    } catch (error: any) {
+      console.error('Release failed:', error.message)
+      process.exit(1)
+    }
+  })
+
 cli
   .command('pr <prNumber>', 'Download extension from a GitHub PR in Raycast extensions repo. To test it with Termcast')
   .action(async (prNumber: string) => {

package/src/colors.tsx

@@ -11,5 +11,26 @@ export enum Color {
 }
 
 export namespace Color {
-  export type ColorLike = Color | string
+  export interface Dynamic {
+    light: string
+    dark: string
+    adjustContrast?: boolean
+  }
+
+  export type Raw = string
+
+  export type ColorLike = Color | Dynamic | Raw
+}
+
+export function resolveColor(color: Color.ColorLike | undefined | null): string | undefined {
+  if (!color) {
+    return undefined
+  }
+  if (typeof color === 'string') {
+    return color
+  }
+  if (typeof color === 'object' && 'dark' in color) {
+    return color.dark
+  }
+  return undefined
 }

package/src/compile.tsx

@@ -0,0 +1,219 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import type { BunPlugin } from 'bun'
+import { logger } from './logger'
+import { getCommandsWithFiles } from './package-json'
+
+const raycastAliasPlugin: BunPlugin = {
+  name: 'raycast-to-termcast',
+  setup(build) {
+    build.onResolve({ filter: /@raycast\/api/ }, () => ({
+      path: require.resolve('termcast/src/index'),
+    }))
+
+    build.onResolve({ filter: /^termcast/ }, (args) => ({
+      path: require.resolve(args.path),
+    }))
+  },
+}
+
+export function generateEntryCode({
+  extensionPath,
+  commands,
+}: {
+  extensionPath: string
+  commands: Array<{ name: string; bundledPath: string }>
+}): string {
+  const commandImports = commands
+    .map(
+      (cmd, i) =>
+        `  const { default: Command${i} } = await import(${JSON.stringify(cmd.bundledPath)});`,
+    )
+    .join('\n')
+
+  const commandsArray = commands
+    .map(
+      (cmd, i) => `    {
+      name: ${JSON.stringify(cmd.name)},
+      Component: Command${i},
+    }`,
+    )
+    .join(',\n')
+
+  return `
+async function main() {
+${commandImports}
+
+  const compiledCommands = [
+${commandsArray}
+  ];
+
+  const { startCompiledExtension } = await import('termcast/src/extensions/dev');
+
+  await startCompiledExtension({
+    extensionPath: ${JSON.stringify(extensionPath)},
+    compiledCommands,
+  });
+}
+
+main().catch((err) => {
+  console.error('Failed to start:', err);
+  console.error('Stack:', err.stack);
+  process.exit(1);
+});
+`
+}
+
+export interface CompileTarget {
+  os: 'linux' | 'darwin' | 'win32'
+  arch: 'arm64' | 'x64'
+  abi?: 'musl'
+  avx2?: false
+}
+
+export function targetToString(target: CompileTarget): string {
+  return [
+    'bun',
+    target.os === 'win32' ? 'windows' : target.os,
+    target.arch,
+    target.avx2 === false ? 'baseline' : undefined,
+    target.abi,
+  ]
+    .filter(Boolean)
+    .join('-')
+}
+
+export function targetToFileSuffix(target: CompileTarget): string {
+  const os = target.os === 'win32' ? 'windows' : target.os === 'darwin' ? 'darwin' : 'linux'
+  const ext = target.os === 'win32' ? '.exe' : ''
+  const parts = [os, target.arch]
+  if (target.abi) {
+    parts.push(target.abi)
+  }
+  if (target.avx2 === false) {
+    parts.push('baseline')
+  }
+  return parts.join('-') + ext
+}
+
+export function getArchiveExtension(target: CompileTarget): string {
+  return target.os === 'linux' ? '.tar.gz' : '.zip'
+}
+
+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: 'darwin', arch: 'arm64' },
+  { os: 'darwin', arch: 'x64' },
+  { os: 'darwin', arch: 'x64', avx2: false },
+  { os: 'win32', arch: 'x64' },
+  { os: 'win32', arch: 'x64', avx2: false },
+]
+
+export function getCurrentTarget(): CompileTarget {
+  const platform = process.platform as 'linux' | 'darwin' | 'win32'
+  const arch = process.arch === 'arm64' ? 'arm64' : 'x64'
+  return { os: platform, arch }
+}
+
+export interface CompileOptions {
+  extensionPath: string
+  outfile?: string
+  minify?: boolean
+  target?: CompileTarget
+}
+
+export interface CompileResult {
+  success: boolean
+  outfile: string
+}
+
+export async function compileExtension({
+  extensionPath,
+  outfile,
+  minify = false,
+  target,
+}: CompileOptions): Promise<CompileResult> {
+  const resolvedPath = path.resolve(extensionPath)
+
+  if (!fs.existsSync(resolvedPath)) {
+    throw new Error(`Extension path does not exist: ${resolvedPath}`)
+  }
+
+  const packageJsonPath = path.join(resolvedPath, 'package.json')
+  if (!fs.existsSync(packageJsonPath)) {
+    throw new Error(`No package.json found at: ${packageJsonPath}`)
+  }
+
+  const { packageJson, commands } = getCommandsWithFiles({ packageJsonPath })
+
+  const existingCommands = commands.filter((cmd) => cmd.exists)
+  if (existingCommands.length === 0) {
+    throw new Error('No command files found to build')
+  }
+
+  logger.log(`Compiling ${existingCommands.length} commands...`)
+
+  const bundleDir = path.join(resolvedPath, '.termcast-bundle')
+  if (!fs.existsSync(bundleDir)) {
+    fs.mkdirSync(bundleDir, { recursive: true })
+  }
+
+  const entryCode = generateEntryCode({
+    extensionPath: resolvedPath,
+    commands: existingCommands.map((cmd) => ({
+      name: cmd.name,
+      bundledPath: cmd.filePath,
+    })),
+  })
+
+  const tempEntryPath = path.join(bundleDir, '_entry.tsx')
+  fs.writeFileSync(tempEntryPath, entryCode)
+
+  const bunTarget = target ? targetToString(target) : 'bun'
+  const defaultOutfile =
+    outfile || path.join(resolvedPath, packageJson.name || 'extension')
+
+  try {
+    const result = await Bun.build({
+      entrypoints: [tempEntryPath],
+      target: bunTarget as 'bun',
+      minify,
+      compile: {
+        outfile: defaultOutfile,
+      },
+      plugins: [raycastAliasPlugin],
+      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'}`)
+    }
+
+    logger.log('Build outputs:', result.outputs?.map((o) => o.path))
+
+    if (!fs.existsSync(defaultOutfile)) {
+      throw new Error(
+        `Compiled executable not found at ${defaultOutfile}. Outputs: ${result.outputs?.map((o) => o.path).join(', ')}`,
+      )
+    }
+
+    logger.log(`Successfully compiled: ${defaultOutfile}`)
+
+    return {
+      success: true,
+      outfile: defaultOutfile,
+    }
+  } finally {
+    if (fs.existsSync(tempEntryPath)) {
+      fs.unlinkSync(tempEntryPath)
+    }
+  }
+}

package/src/components/actions.tsx

@@ -22,7 +22,7 @@ import { useIsInFocus } from 'termcast/src/internal/focus-context'
 import { CommonProps } from 'termcast/src/utils'
 import { showToast, Toast } from 'termcast/src/apis/toast'
 import { createDescendants } from 'termcast/src/descendants'
-import { useFormSubmit } from 'termcast'
+import { useFormSubmit } from 'termcast/src/components/form/index'
 import { logger } from '../logger'
 
 export enum ActionStyle {
@@ -54,6 +54,7 @@ export interface ActionPanelSectionProps extends CommonProps {
 
 interface ActionType {
   (props: ActionProps): any
+  Style: typeof ActionStyle
   Push: (props: PushActionProps) => any
   CopyToClipboard: (props: CopyToClipboardProps) => any
   OpenInBrowser: (props: OpenInBrowserProps) => any
@@ -172,6 +173,8 @@ const Action: ActionType = (props) => {
     execute: () => props.onAction?.(),
   })
 
+  const isDestructive = props.style === ActionStyle.Destructive
+
   // Render as Dropdown.Item
   return (
     <Dropdown.Item
@@ -179,10 +182,13 @@ const Action: ActionType = (props) => {
       value={props.title}
       icon={props.icon}
       label={formatShortcut(props.shortcut)}
+      color={isDestructive ? Theme.error : undefined}
     />
   )
 }
 
+Action.Style = ActionStyle
+
 Action.Push = (props) => {
   const dialog = useDialog()
 

package/src/components/command-arguments.tsx

@@ -0,0 +1,81 @@
+import React from 'react'
+import { Form } from './form'
+import { ActionPanel, Action } from './actions'
+import type { RaycastArgument } from 'termcast/src/package-json'
+
+interface CommandArgumentsProps {
+  arguments: RaycastArgument[]
+  commandTitle: string
+  onSubmit: (values: Record<string, string>) => void
+}
+
+export function CommandArguments({
+  arguments: args,
+  commandTitle,
+  onSubmit,
+}: CommandArgumentsProps): any {
+  const handleSubmit = (values: Record<string, any>) => {
+    onSubmit(values as Record<string, string>)
+  }
+
+  return (
+    <Form
+      actions={
+        <ActionPanel>
+          <Action.SubmitForm title='Run Command' onSubmit={handleSubmit} />
+        </ActionPanel>
+      }
+      navigationTitle={commandTitle}
+    >
+      <Form.Description
+        title={commandTitle}
+        text='Enter the arguments to run this command.'
+      />
+
+      {args.map((arg) => {
+        switch (arg.type) {
+          case 'text':
+            return (
+              <Form.TextField
+                key={arg.name}
+                id={arg.name}
+                title={arg.placeholder}
+                placeholder={arg.placeholder}
+              />
+            )
+
+          case 'password':
+            return (
+              <Form.PasswordField
+                key={arg.name}
+                id={arg.name}
+                title={arg.placeholder}
+                placeholder={arg.placeholder}
+              />
+            )
+
+          case 'dropdown':
+            return (
+              <Form.Dropdown
+                key={arg.name}
+                id={arg.name}
+                title={arg.placeholder}
+                placeholder={arg.placeholder}
+              >
+                {arg.data?.map((item) => (
+                  <Form.Dropdown.Item
+                    key={item.value}
+                    value={item.value}
+                    title={item.title}
+                  />
+                ))}
+              </Form.Dropdown>
+            )
+
+          default:
+            return null
+        }
+      })}
+    </Form>
+  )
+}