termcast 1.3.9

package/src/build.tsx

@@ -0,0 +1,273 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import type { BunPlugin } from 'bun'
+import { logger } from './logger'
+import { getCommandsWithFiles, CommandWithFile } from './package-json'
+import * as termcastApi from 'termcast'
+import * as opentuiReact from '@opentui/react'
+import * as opentuiCore from '@opentui/core'
+import * as react from 'react'
+
+const GLOBALS_NAMESPACE = 'globals'
+
+const aliasPlugin: BunPlugin = {
+  name: 'alias-raycast-to-termcast',
+  async setup(build) {
+    // Import packages once at setup time
+    const packages = [
+      {
+        path: 'termcast',
+        module: termcastApi,
+        globalName: 'termcastApi',
+      },
+      {
+        path: '@opentui/react',
+        module: opentuiReact,
+        globalName: 'opentuiReact',
+      },
+      {
+        path: '@opentui/core',
+        module: opentuiCore,
+        globalName: 'opentuiCore',
+      },
+      {
+        path: 'react',
+        module: react,
+        globalName: 'react',
+      },
+    ]
+
+    // Alias @raycast/api to termcast using namespace
+    build.onResolve({ filter: /@raycast\/api/ }, () => {
+      logger.log('Resolving @raycast/api to termcast')
+      return {
+        path: 'termcast',
+        namespace: GLOBALS_NAMESPACE,
+      }
+    })
+
+    // Resolve external packages to globals namespace
+    build.onResolve({ filter: /^@termcast\/cli/ }, (args) => {
+      return {
+        path: 'termcast',
+        namespace: GLOBALS_NAMESPACE,
+      }
+    })
+
+    build.onResolve({ filter: /^@opentui\/react/ }, (args) => {
+      // Handle @opentui/react/jsx-dev-runtime specifically
+      if (args.path.includes('jsx')) {
+        return {
+          path: 'react/jsx-runtime',
+          namespace: GLOBALS_NAMESPACE,
+        }
+      }
+      return {
+        path: '@opentui/react',
+        namespace: GLOBALS_NAMESPACE,
+      }
+    })
+
+    build.onResolve({ filter: /^@opentui\/core/ }, () => {
+      return {
+        path: '@opentui/core',
+        namespace: GLOBALS_NAMESPACE,
+      }
+    })
+
+    build.onResolve({ filter: /^react\/jsx-runtime/ }, () => {
+      return {
+        path: 'react/jsx-runtime',
+        namespace: GLOBALS_NAMESPACE,
+      }
+    })
+
+    build.onResolve({ filter: /^react($|\/|$)/ }, (args) => {
+      if (args.path === 'react' || args.path === 'react/') {
+        return {
+          path: 'react',
+          namespace: GLOBALS_NAMESPACE,
+        }
+      }
+      // For jsx-dev-runtime
+      if (args.path.includes('jsx')) {
+        return {
+          path: 'react/jsx-runtime',
+          namespace: GLOBALS_NAMESPACE,
+        }
+      }
+      return null
+    })
+
+    // Handle loading from globals namespace
+    build.onLoad(
+      { filter: /.*/, namespace: GLOBALS_NAMESPACE },
+      async (args) => {
+        // Handle regular packages
+        const pkg = packages.find((p) => p.path === args.path)
+        if (pkg) {
+          const exports: string[] = []
+
+          for (const key in pkg.module) {
+            if (key === 'default') {
+              // Special handling for react default export
+              if (pkg.path === 'react') {
+                exports.push(
+                  `export default /* @__PURE__ */ globalThis.${pkg.globalName};`,
+                )
+              } else {
+                exports.push(
+                  `export default /* @__PURE__ */ globalThis.${pkg.globalName}.default;`,
+                )
+              }
+            } else {
+              exports.push(
+                `export const ${key} = /* @__PURE__ */ globalThis.${pkg.globalName}.${key};`,
+              )
+            }
+          }
+
+          return {
+            contents: exports.join('\n'),
+            loader: 'js',
+            pure: true,
+          }
+        }
+
+        // Special handling for react/jsx-runtime
+        if (args.path === 'react/jsx-runtime') {
+          const jsxRuntime = await import('react/jsx-runtime')
+          const jsxDevRuntime = await import('react/jsx-dev-runtime')
+          const exports: string[] = []
+
+          // Export from jsx-runtime
+          for (const key in jsxRuntime) {
+            if (key === 'default') {
+              // Skip default export for jsx-runtime
+              continue
+            }
+            exports.push(
+              `export const ${key} = /* @__PURE__ */ globalThis.reactJsxRuntime.${key};`,
+            )
+          }
+
+          // Also export jsxDEV from jsx-dev-runtime
+          exports.push(
+            `export const jsxDEV = /* @__PURE__ */ (globalThis.reactJsxRuntime.jsxDEV || globalThis.reactJsxRuntime.jsx);`,
+          )
+
+          return {
+            contents: exports.join('\n'),
+            loader: 'js',
+            pure: true,
+          }
+        }
+
+        logger.error(
+          `matched a file that had no handling for exports plugin ${args.path}`,
+        )
+        return {
+          contents: 'export {}',
+          loader: 'js',
+          pure: true,
+        }
+      },
+    )
+  },
+}
+
+interface BundledCommand extends CommandWithFile {
+  bundledPath: string
+}
+
+export interface BuildResult {
+  commands: BundledCommand[]
+  bundleDir: string
+}
+
+export async function buildExtensionCommands({
+  extensionPath,
+  format = 'cjs',
+  target,
+}: {
+  extensionPath: string
+  format?: 'cjs' | 'esm'
+  target?: 'node' | 'bun'
+}): Promise<BuildResult> {
+  const resolvedPath = path.resolve(extensionPath)
+  const bundleDir = path.join(resolvedPath, '.termcast-bundle')
+
+  // Ensure bundle directory exists
+  if (!fs.existsSync(bundleDir)) {
+    fs.mkdirSync(bundleDir, { recursive: true })
+  }
+
+  const commandsData = getCommandsWithFiles({
+    packageJsonPath: path.join(resolvedPath, 'package.json'),
+  })
+
+  // Filter existing command files as entrypoints
+  const entrypoints = commandsData.commands
+    .filter((cmd) => cmd.exists)
+    .map((cmd) => cmd.filePath)
+
+  if (entrypoints.length === 0) {
+    throw new Error('No command files found to build')
+  }
+
+  logger.log(`Building ${entrypoints.length} commands...`)
+
+  const result = await Bun.build({
+    entrypoints,
+    outdir: bundleDir,
+    target: target || (format === 'cjs' ? 'node' : 'bun'),
+    format,
+    // external: [],
+    plugins: [aliasPlugin],
+    naming: '[name].js',
+    throw: false,
+  })
+
+  if (!result.success) {
+    const errorMessage = result.logs
+      .map((log: any) => log.message || log)
+      .join('\n')
+    throw new Error(`Build failed: ${errorMessage}`)
+  }
+
+  // Map outputs back to commands
+  const bundledCommands: BundledCommand[] = commandsData.commands.map(
+    (command) => {
+      if (!command.exists) {
+        return {
+          ...command,
+          bundledPath: '',
+        }
+      }
+
+      // Find the corresponding output for this command
+      const outputFileName = `${command.name}.js`
+      const output = result.outputs.find((out) => {
+        return path.basename(out.path) === outputFileName
+      })
+
+      if (output) {
+        const bundledPath = path.join(bundleDir, outputFileName)
+        logger.log(`Built ${command.name} -> ${bundledPath}`)
+        return {
+          ...command,
+          bundledPath,
+        }
+      } else {
+        throw new Error(`No output found for command: ${command.name}`)
+      }
+    },
+  )
+
+  logger.log(`Successfully built ${result.outputs.length} files`)
+
+  return {
+    commands: bundledCommands,
+    bundleDir,
+  }
+}

package/src/cli.tsx

@@ -0,0 +1,328 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { execSync, spawn } from 'node:child_process'
+import { cac } from 'cac'
+import chokidar from 'chokidar'
+import { buildExtensionCommands } from './build'
+import { logger } from './logger'
+import { installExtension } from './utils'
+import './globals'
+import { startDevMode, triggerRebuild } from './extensions/dev'
+import { runHomeCommand } from './extensions/home'
+import { showToast, Toast } from './apis/toast'
+import packageJson from '../package.json'
+
+const cli = cac('termcast')
+
+// Auto-update check
+async function checkForUpdates() {
+  try {
+    const currentVersion = packageJson.version
+
+    // Fetch latest release info from GitHub
+    const response = await fetch(
+      'https://api.github.com/repos/remorses/termcast/releases/latest',
+    )
+    if (!response.ok) {
+      return
+    }
+
+    const latestRelease = await response.json()
+    const latestVersion =
+      latestRelease.tag_name?.replace('termcast@', '') ||
+      latestRelease.tag_name?.replace('v', '')
+
+    // Compare versions
+    if (latestVersion && latestVersion !== currentVersion) {
+      // Run the install script in background
+      const updateProcess = spawn('bash', ['-c', 'curl -sf https://termcast.app/install | bash'], {
+        detached: true,
+        stdio: 'ignore',
+      })
+
+      updateProcess.on('exit', async (code) => {
+        if (code === 0) {
+          // Show toast notification only on successful completion
+          await showToast({
+            title: 'Update available',
+            message: `Restart to use the new version ${latestVersion}`,
+            style: Toast.Style.Success,
+          })
+        }
+      })
+
+      // updateProcess.unref()
+    }
+  } catch (error) {
+    // Silently fail - don't interrupt the user's workflow
+    logger.log('Failed to check for updates:', error)
+  }
+}
+
+// Check for updates when CLI starts
+checkForUpdates()
+
+cli
+  .command('dev [path]', 'Run the extension in the current working directory')
+  .action(async (extensionPath, options) => {
+    try {
+      extensionPath = path.resolve(extensionPath || process.cwd())
+      let isBuilding = false
+
+      // Start dev mode with initial render
+      await startDevMode({ extensionPath })
+
+      logger.log(`dev mode started`)
+      // Only watch if running in a TTY (interactive terminal)
+      if (!process.stdout.isTTY) {
+        console.log('Not running in interactive terminal, watching disabled')
+        return
+      }
+
+      console.log('\nWatching for file changes...')
+
+      // Watch entire extension directory
+      const watcher = chokidar.watch(extensionPath, {
+        persistent: true,
+        ignoreInitial: true,
+        awaitWriteFinish: {
+          stabilityThreshold: 300,
+          pollInterval: 100,
+        },
+      })
+
+      const ignoredPatterns = [
+        'node_modules',
+        '.termcast-bundle',
+        '.git',
+        'app.log',
+        'dist',
+        'build',
+      ]
+
+      const shouldIgnore = (filePath: string) => {
+        const relativePath = path.relative(extensionPath, filePath)
+        return ignoredPatterns.some(
+          (pattern) =>
+            relativePath.includes(pattern) || filePath.endsWith('.log'),
+        )
+      }
+
+      const rebuild = async (filePath: string) => {
+        if (shouldIgnore(filePath)) {
+          return
+        }
+
+        if (isBuilding) {
+          logger.log('Build already in progress, skipping...')
+          return
+        }
+
+        isBuilding = true
+        logger.log('File changed, rebuilding...')
+        logger.log(filePath)
+        try {
+          await triggerRebuild({ extensionPath })
+          logger.log('Rebuild complete')
+        } catch (error: any) {
+          logger.error('Failed to trigger rebuild:', error.message)
+        } finally {
+          isBuilding = false
+        }
+      }
+
+      watcher
+        .on('change', rebuild)
+        .on('add', rebuild)
+        .on('unlink', rebuild)
+        .on('error', (error) => logger.error('Watcher error:', error))
+    } catch (e) {
+      logger.error(e)
+      logger.log(`failed to start dev`, e)
+    }
+  })
+
+cli
+  .command('build [path]', 'Build and install the extension to user store')
+  .action(async (extensionPath, options) => {
+    extensionPath = path.resolve(extensionPath || process.cwd())
+
+    console.log('Building extension...')
+    try {
+      const buildResult = await buildExtensionCommands({
+        extensionPath,
+        format: 'esm',
+        target: 'bun',
+      })
+      console.log(`Successfully built ${buildResult.commands.length} commands`)
+
+      for (const cmd of buildResult.commands) {
+        if (cmd.bundledPath) {
+          console.log(`  ✓ ${cmd.name}`)
+        }
+      }
+
+      const packageJsonPath = path.join(extensionPath, 'package.json')
+      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'))
+      const extensionName = packageJson.name || path.basename(extensionPath)
+      installExtension({
+        extensionName,
+        extensionSourcePath: extensionPath,
+      })
+      console.log(`\nExtension installed to store as '${extensionName}'`)
+    } catch (error: any) {
+      console.error('Build 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) => {
+    try {
+      // Parse PR number from URL if provided
+      let parsedPrNumber = prNumber
+      const urlMatch = prNumber.match(
+        /github\.com\/raycast\/extensions\/pull\/(\d+)/,
+      )
+      if (urlMatch) {
+        parsedPrNumber = urlMatch[1]
+      }
+
+      console.log(`Fetching PR #${parsedPrNumber} from GitHub...`)
+
+      // Fetch PR data from GitHub API
+      const prResponse = await fetch(
+        `https://api.github.com/repos/raycast/extensions/pulls/${parsedPrNumber}`,
+      )
+
+      if (!prResponse.ok) {
+        console.error(
+          `Failed to fetch PR #${parsedPrNumber}: ${prResponse.statusText}`,
+        )
+        process.exit(1)
+      }
+
+      const prData = await prResponse.json()
+      const prAuthor = prData.head.user.login
+      const branch = prData.head.ref
+      const forkUrl = prData.head.repo.clone_url
+
+      console.log(`PR Author: ${prAuthor}`)
+      console.log(`Branch: ${branch}`)
+
+      // Extract extension name from branch name (usually format: "ext/extension-name")
+      let extensionName = ''
+      if (branch.startsWith('ext/')) {
+        extensionName = branch.substring(4) // Remove "ext/" prefix
+      } else {
+        // Fallback to last part of branch name
+        const branchParts = branch.split('/')
+        extensionName = branchParts[branchParts.length - 1]
+      }
+
+      console.log(`Extension name: ${extensionName}`)
+
+      // Sanitize branch name for directory name (remove special characters)
+      const sanitizedBranch = branch.replace(/[\/\\:*?"<>|]/g, '-')
+
+      // Create directory for PR
+      const homeDir = process.env.HOME || process.env.USERPROFILE || ''
+      const prsDir = path.join(homeDir, '.termcast', 'prs')
+      const prDir = path.join(
+        prsDir,
+        `${prAuthor}-${sanitizedBranch}-${parsedPrNumber}`,
+      )
+
+      // Create directories if they don't exist
+      if (!fs.existsSync(prsDir)) {
+        fs.mkdirSync(prsDir, { recursive: true })
+      }
+
+      // Clean up existing directory if it exists
+      if (fs.existsSync(prDir)) {
+        console.log(`Removing existing directory: ${prDir}`)
+        fs.rmSync(prDir, { recursive: true, force: true })
+      }
+
+      // Clone the extension using sparse-checkout
+      console.log(`\nCloning extension from ${forkUrl}...`)
+
+      // Step 1: Clone with sparse-checkout
+      const dirName = path.basename(prDir)
+      const cloneCmd = `git clone -n --depth=1 --filter=tree:0 -b "${branch}" "${forkUrl}" "${dirName}"`
+      console.log(`Running: ${cloneCmd}`)
+      try {
+        execSync(cloneCmd, {
+          cwd: prsDir,
+          stdio: 'inherit',
+        })
+      } catch (error) {
+        console.error(`Failed to clone repository`)
+        process.exit(1)
+      }
+
+      // Step 2: Set up sparse-checkout
+      const sparseCmd = `git sparse-checkout set --no-cone "extensions/${extensionName}"`
+      console.log(`Running: ${sparseCmd}`)
+      try {
+        execSync(sparseCmd, {
+          cwd: prDir,
+          stdio: 'inherit',
+        })
+      } catch (error) {
+        console.error(`Failed to set sparse-checkout`)
+        process.exit(1)
+      }
+
+      // Step 3: Checkout the files
+      const checkoutCmd = 'git checkout'
+      console.log(`Running: ${checkoutCmd}`)
+      try {
+        execSync(checkoutCmd, {
+          cwd: prDir,
+          stdio: 'inherit',
+        })
+      } catch (error) {
+        console.error(`Failed to checkout files`)
+        process.exit(1)
+      }
+
+      // Navigate to the extension directory
+      const extensionPath = path.join(prDir, 'extensions', extensionName)
+
+      if (!fs.existsSync(extensionPath)) {
+        console.error(`Extension directory not found: ${extensionPath}`)
+        console.log('Available extensions:')
+        const extensionsDir = path.join(prDir, 'extensions')
+        if (fs.existsSync(extensionsDir)) {
+          const dirs = fs.readdirSync(extensionsDir)
+          dirs.forEach((dir) => console.log(`  - ${dir}`))
+        }
+        process.exit(1)
+      }
+
+      // Install dependencies
+      console.log(`\nInstalling dependencies...`)
+      execSync('npm install', {
+        cwd: extensionPath,
+        stdio: 'inherit',
+      })
+
+      console.log(`\n✅ Extension downloaded successfully!`)
+      console.log(`📁 Path: ${extensionPath}`)
+      process.exit(0)
+    } catch (error) {
+      console.error('Error downloading PR:', error)
+      process.exit(1)
+    }
+  })
+
+cli.command('', 'List and run installed extensions').action(async () => {
+  await runHomeCommand()
+})
+
+cli.help()
+cli.version('0.1.0')
+
+cli.parse()

package/src/colors.tsx

@@ -0,0 +1,15 @@
+export enum Color {
+  Blue = '#0080FF',
+  Green = '#00FF80',
+  Magenta = '#FF00FF',
+  Orange = '#FF8000',
+  Purple = '#8000FF',
+  Red = '#FF0000',
+  Yellow = '#FFFF00',
+  PrimaryText = '#FFFFFF',
+  SecondaryText = '#999999',
+}
+
+export namespace Color {
+  export type ColorLike = Color | string
+}