termcast 1.3.30 → 1.3.32

package/src/cli.tsx

@@ -1,10 +1,14 @@
 #!/usr/bin/env bun
 
+// CRITICAL: Import react-refresh-init FIRST before anything that imports @opentui/react
+// This ensures the devtools hook exists before the reconciler calls injectIntoDevTools()
+import './extensions/react-refresh-init'
+
 import fs from 'node:fs'
 import path from 'node:path'
 import { execSync, spawn } from 'node:child_process'
 import { cac } from 'cac'
-import * as watcher from '@parcel/watcher'
+import { getWatcher } from './watcher'
 import { buildExtensionCommands } from './build'
 import { logger } from './logger'
 import { installExtension } from './utils'
@@ -32,7 +36,7 @@ async function checkForUpdates() {
       return
     }
 
-    const latestRelease = await response.json()
+    const latestRelease = (await response.json()) as { tag_name?: string }
     const latestVersion =
       latestRelease.tag_name?.replace('termcast@', '') ||
       latestRelease.tag_name?.replace('v', '')
@@ -40,10 +44,14 @@ async function checkForUpdates() {
     // 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',
-      })
+      const updateProcess = spawn(
+        'bash',
+        ['-c', 'curl -sf https://termcast.app/install | bash'],
+        {
+          detached: true,
+          stdio: 'ignore',
+        },
+      )
 
       updateProcess.on('exit', async (code) => {
         if (code === 0) {
@@ -64,20 +72,22 @@ async function checkForUpdates() {
   }
 }
 
-// Check for updates when CLI starts
-checkForUpdates()
+// TODO: re-enable auto-update check once install script temp dir issue is fixed
+// checkForUpdates()
 
 cli
   .command('dev [path]', 'Run the extension in the current working directory')
   .action(async (rawExtensionPath, options) => {
     try {
       // Check if the provided arg looks like a path (contains / or . or is existing dir)
-      const looksLikePath = rawExtensionPath && (
-        rawExtensionPath.includes('/') ||
-        rawExtensionPath.startsWith('.') ||
-        fs.existsSync(rawExtensionPath)
+      const looksLikePath =
+        rawExtensionPath &&
+        (rawExtensionPath.includes('/') ||
+          rawExtensionPath.startsWith('.') ||
+          fs.existsSync(rawExtensionPath))
+      const extensionPath = path.resolve(
+        looksLikePath ? rawExtensionPath : process.cwd(),
       )
-      const extensionPath = path.resolve(looksLikePath ? rawExtensionPath : process.cwd())
       let isBuilding = false
 
       // Start dev mode with initial render
@@ -96,16 +106,57 @@ cli
       console.log('\nWatching for file changes...')
 
       // Watch entire extension directory using @parcel/watcher
+      // Single source of truth for ignored patterns
+      const IGNORED_DIRS = [
+        'node_modules',
+        '.termcast-bundle',
+        '.git',
+        '.build', // Swift build output
+        '.cache',
+        'tmp',
+        '.tmp',
+        'dist',
+        'build',
+      ]
+      const IGNORED_EXTENSIONS = ['.log', '.db', '.sqlite']
+
+      // Glob patterns for @parcel/watcher (matched against relative paths using micromatch)
       const ignoredPatterns = [
-        '**/node_modules/**',
-        '**/.termcast-bundle/**',
-        '**/.git/**',
-        '**/.build/**',  // Swift build output
-        '**/*.log',
-        '**/dist/**',
-        '**/build/**',
+        ...IGNORED_DIRS.map((dir) => `**/${dir}/**`),
+        ...IGNORED_EXTENSIONS.map((ext) => `**/*${ext}`),
+        // SQLite creates .db-wal and .db-shm alongside .db
+        '**/*.db-*',
+        '**/*.sqlite-*',
       ]
 
+      // Backup filter for files that should never trigger rebuild
+      // This catches cases where @parcel/watcher ignore doesn't work as expected
+      const shouldIgnoreFile = (filePath: string): boolean => {
+        const relativePath = path.relative(extensionPath, filePath)
+        // Ignore files outside the extension directory
+        if (relativePath.startsWith('..')) {
+          return true
+        }
+        // Check if path contains any ignored directory
+        const hasIgnoredDir = IGNORED_DIRS.some(
+          (dir) =>
+            relativePath.includes(`/${dir}/`) ||
+            relativePath.startsWith(`${dir}/`),
+        )
+        if (hasIgnoredDir) {
+          return true
+        }
+        // Check if file has ignored extension
+        if (IGNORED_EXTENSIONS.some((ext) => relativePath.endsWith(ext))) {
+          return true
+        }
+        // Also catch .db-* and .sqlite-* patterns
+        if (/\.db-|\.sqlite-/.test(relativePath)) {
+          return true
+        }
+        return false
+      }
+
       const rebuild = async (filePath: string) => {
         if (isBuilding) {
           logger.log('Build already in progress, skipping...')
@@ -125,19 +176,24 @@ cli
         }
       }
 
-      const subscription = await watcher.subscribe(
+      const subscription = await getWatcher().subscribe(
         extensionPath,
         (err, events) => {
           if (err) {
             logger.error('Watcher error:', err)
             return
           }
-          // Trigger rebuild for any event (create, update, delete)
-          if (events.length > 0) {
-            rebuild(events[0].path)
+
+          // Filter out events for files that should be ignored
+          const relevantEvents = events.filter(
+            (event) => !shouldIgnoreFile(event.path),
+          )
+
+          if (relevantEvents.length > 0) {
+            rebuild(relevantEvents[0].path)
           }
         },
-        { ignore: ignoredPatterns }
+        { ignore: ignoredPatterns },
       )
 
       // Clean up watcher on exit signals
@@ -182,6 +238,7 @@ cli
         extensionSourcePath: extensionPath,
       })
       console.log(`\nExtension installed to store as '${extensionName}'`)
+      process.exit(0)
     } catch (error: any) {
       console.error('Build failed:', error.message)
       process.exit(1)
@@ -205,6 +262,7 @@ cli
 
       console.log(`\nExecutable created: ${result.outfile}`)
       console.log(`Run it with: ${result.outfile}`)
+      process.exit(0)
     } catch (error: any) {
       console.error('Compile failed:', error.message)
       process.exit(1)
@@ -234,7 +292,10 @@ cli
   })
 
 cli
-  .command('pr <prNumber>', 'Download extension from a GitHub PR in Raycast extensions repo. To test it with Termcast')
+  .command(
+    'raycast-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
@@ -254,13 +315,34 @@ cli
       )
 
       if (!prResponse.ok) {
-        console.error(
-          `Failed to fetch PR #${parsedPrNumber}: ${prResponse.statusText}`,
-        )
+        if (prResponse.status === 403) {
+          const rateLimitRemaining = prResponse.headers.get(
+            'x-ratelimit-remaining',
+          )
+          if (rateLimitRemaining === '0') {
+            const resetTime = prResponse.headers.get('x-ratelimit-reset')
+            const resetDate = resetTime
+              ? new Date(parseInt(resetTime) * 1000).toLocaleTimeString()
+              : 'soon'
+            console.error(
+              `GitHub API rate limit exceeded. Resets at ${resetDate}`,
+            )
+          } else {
+            console.error(`Access forbidden for PR #${parsedPrNumber}`)
+          }
+        } else if (prResponse.status === 404) {
+          console.error(`PR #${parsedPrNumber} not found`)
+        } else {
+          console.error(
+            `Failed to fetch PR #${parsedPrNumber}: ${prResponse.status} ${prResponse.statusText}`,
+          )
+        }
         process.exit(1)
       }
 
-      const prData = await prResponse.json()
+      const prData = (await prResponse.json()) as {
+        head: { user: { login: string }; ref: string; repo: { clone_url: string } }
+      }
       const prAuthor = prData.head.user.login
       const branch = prData.head.ref
       const forkUrl = prData.head.repo.clone_url
@@ -376,8 +458,76 @@ cli
   })
 
 cli
-  .command('raycast-search <query>', 'Search for extensions in the Raycast store')
-  .option('-n, --limit <number>', 'Number of results to show', { default: '10' })
+  .command(
+    'raycast-pr-diff <prNumber>',
+    'Show the diff of a PR in Raycast extensions repo',
+  )
+  .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.error(`Fetching diff for PR #${parsedPrNumber}...`)
+
+      // Fetch diff directly from GitHub API
+      const response = await fetch(
+        `https://api.github.com/repos/raycast/extensions/pulls/${parsedPrNumber}`,
+        {
+          headers: {
+            Accept: 'application/vnd.github.v3.diff',
+          },
+        },
+      )
+
+      if (!response.ok) {
+        if (response.status === 403) {
+          const rateLimitRemaining = response.headers.get(
+            'x-ratelimit-remaining',
+          )
+          if (rateLimitRemaining === '0') {
+            const resetTime = response.headers.get('x-ratelimit-reset')
+            const resetDate = resetTime
+              ? new Date(parseInt(resetTime) * 1000).toLocaleTimeString()
+              : 'soon'
+            console.error(
+              `GitHub API rate limit exceeded. Resets at ${resetDate}`,
+            )
+          } else {
+            console.error(`Access forbidden for PR #${parsedPrNumber}`)
+          }
+        } else if (response.status === 404) {
+          console.error(`PR #${parsedPrNumber} not found`)
+        } else {
+          console.error(
+            `Failed to fetch PR #${parsedPrNumber}: ${response.status} ${response.statusText}`,
+          )
+        }
+        process.exit(1)
+      }
+
+      const diff = await response.text()
+      console.log(diff)
+      process.exit(0)
+    } catch (error) {
+      console.error('Error fetching PR diff:', error)
+      process.exit(1)
+    }
+  })
+
+cli
+  .command(
+    'raycast-search <query>',
+    'Search for extensions in the Raycast store',
+  )
+  .option('-n, --limit <number>', 'Number of results to show', {
+    default: '10',
+  })
   .action(async (query: string, options: { limit: string }) => {
     try {
       const limit = parseInt(options.limit, 10)
@@ -394,14 +544,18 @@ cli
         const downloads = ext.download_count.toLocaleString()
         const commands = ext.commands.map((c) => c.name).join(', ')
         console.log(`  ${ext.name}`)
-        console.log(`    Path: extensions/${ext.relative_path.replace('extensions/', '')}`)
+        console.log(
+          `    Path: extensions/${ext.relative_path.replace('extensions/', '')}`,
+        )
         console.log(`    Downloads: ${downloads}`)
         console.log(`    Commands: ${commands || 'none'}`)
-        console.log(`    Description: ${ext.description.slice(0, 100)}${ext.description.length > 100 ? '...' : ''}`)
+        console.log(
+          `    Description: ${ext.description.slice(0, 100)}${ext.description.length > 100 ? '...' : ''}`,
+        )
         console.log()
       }
 
-      console.log(`Download with: termcast download <extension-name>`)
+      console.log(`Download with: termcast raycast-download <extension-name>`)
       process.exit(0)
     } catch (error: any) {
       console.error('Search failed:', error.message)
@@ -410,98 +564,206 @@ cli
   })
 
 cli
-  .command('download <extensionName>', 'Download extension from Raycast extensions repo')
+  .command(
+    'raycast-download <extensionName>',
+    'Download extension from Raycast extensions repo',
+  )
   .option('-o, --output <path>', 'Output directory', { default: '.' })
-  .option('--no-dir', 'Put files directly in output directory instead of creating extension subdirectory')
-  .action(async (extensionName: string, options: { output: string; dir: boolean }) => {
-    try {
-      const destPath = path.resolve(options.output)
-      // When --no-dir is passed, dir is false; put files directly in destPath
-      const extensionDir = options.dir ? path.join(destPath, extensionName) : destPath
-      const tempCloneDir = path.join(destPath, `.tmp-${extensionName}-${Date.now()}`)
+  .option(
+    '--no-dir',
+    'Put files directly in output directory instead of creating extension subdirectory',
+  )
+  .action(
+    async (
+      extensionName: string,
+      options: { output: string; dir: boolean },
+    ) => {
+      try {
+        const destPath = path.resolve(options.output)
+        // When --no-dir is passed, dir is false; put files directly in destPath
+        const extensionDir = options.dir
+          ? path.join(destPath, extensionName)
+          : destPath
+        const tempCloneDir = path.join(
+          destPath,
+          `.tmp-${extensionName}-${Date.now()}`,
+        )
 
-      console.log(`Downloading extension '${extensionName}' from raycast/extensions...`)
+        console.log(
+          `Downloading extension '${extensionName}' from raycast/extensions...`,
+        )
 
-      if (options.dir && fs.existsSync(extensionDir)) {
-        console.log(`Removing existing directory: ${extensionDir}`)
-        fs.rmSync(extensionDir, { recursive: true, force: true })
-      }
+        if (options.dir && fs.existsSync(extensionDir)) {
+          console.log(`Removing existing directory: ${extensionDir}`)
+          fs.rmSync(extensionDir, { recursive: true, force: true })
+        }
 
-      fs.mkdirSync(destPath, { recursive: true })
+        fs.mkdirSync(destPath, { recursive: true })
 
-      const repoUrl = 'https://github.com/raycast/extensions.git'
-      const cloneDirName = path.basename(tempCloneDir)
-      const cloneCmd = `git clone -n --depth=1 --filter=tree:0 "${repoUrl}" "${cloneDirName}"`
-      console.log(`Running: ${cloneCmd}`)
-      try {
-        execSync(cloneCmd, {
-          cwd: destPath,
-          stdio: 'inherit',
-        })
-      } catch (error) {
-        console.error(`Failed to clone repository`)
-        process.exit(1)
-      }
+        const repoUrl = 'https://github.com/raycast/extensions.git'
+        const cloneDirName = path.basename(tempCloneDir)
+        const cloneCmd = `git clone -n --depth=1 --filter=tree:0 "${repoUrl}" "${cloneDirName}"`
+        console.log(`Running: ${cloneCmd}`)
+        try {
+          execSync(cloneCmd, {
+            cwd: destPath,
+            stdio: 'inherit',
+          })
+        } catch (error) {
+          console.error(`Failed to clone repository`)
+          process.exit(1)
+        }
 
-      const sparseCmd = `git sparse-checkout set --no-cone "extensions/${extensionName}"`
-      console.log(`Running: ${sparseCmd}`)
-      try {
-        execSync(sparseCmd, {
-          cwd: tempCloneDir,
-          stdio: 'inherit',
-        })
-      } catch (error) {
-        console.error(`Failed to set sparse-checkout`)
+        const sparseCmd = `git sparse-checkout set --no-cone "extensions/${extensionName}"`
+        console.log(`Running: ${sparseCmd}`)
+        try {
+          execSync(sparseCmd, {
+            cwd: tempCloneDir,
+            stdio: 'inherit',
+          })
+        } catch (error) {
+          console.error(`Failed to set sparse-checkout`)
+          fs.rmSync(tempCloneDir, { recursive: true, force: true })
+          process.exit(1)
+        }
+
+        const checkoutCmd = 'git checkout'
+        console.log(`Running: ${checkoutCmd}`)
+        try {
+          execSync(checkoutCmd, {
+            cwd: tempCloneDir,
+            stdio: 'inherit',
+          })
+        } catch (error) {
+          console.error(`Failed to checkout files`)
+          fs.rmSync(tempCloneDir, { recursive: true, force: true })
+          process.exit(1)
+        }
+
+        const extensionPath = path.join(
+          tempCloneDir,
+          'extensions',
+          extensionName,
+        )
+
+        if (!fs.existsSync(extensionPath)) {
+          console.error(
+            `Extension '${extensionName}' not found in raycast/extensions repo`,
+          )
+          fs.rmSync(tempCloneDir, { recursive: true, force: true })
+          process.exit(1)
+        }
+
+        // Move files to final destination
+        if (options.dir) {
+          fs.mkdirSync(extensionDir, { recursive: true })
+        }
+        const filesToMove = fs.readdirSync(extensionPath)
+        for (const file of filesToMove) {
+          const src = path.join(extensionPath, file)
+          const dest = path.join(extensionDir, file)
+          fs.renameSync(src, dest)
+        }
+
+        // Clean up temp clone directory
         fs.rmSync(tempCloneDir, { recursive: true, force: true })
-        process.exit(1)
-      }
 
-      const checkoutCmd = 'git checkout'
-      console.log(`Running: ${checkoutCmd}`)
-      try {
-        execSync(checkoutCmd, {
-          cwd: tempCloneDir,
+        console.log(`\nInstalling dependencies...`)
+        execSync('npm install', {
+          cwd: extensionDir,
           stdio: 'inherit',
         })
+
+        console.log(`\n✅ Extension downloaded successfully!`)
+        console.log(`📁 Path: ${extensionDir}`)
+        process.exit(0)
       } catch (error) {
-        console.error(`Failed to checkout files`)
-        fs.rmSync(tempCloneDir, { recursive: true, force: true })
+        console.error('Error downloading extension:', error)
         process.exit(1)
       }
+    },
+  )
 
-      const extensionPath = path.join(tempCloneDir, 'extensions', extensionName)
+cli
+  .command('new <name>', 'Create a new termcast extension')
+  .action(async (name: string) => {
+    try {
+      const targetDir = path.resolve(name)
 
-      if (!fs.existsSync(extensionPath)) {
-        console.error(`Extension '${extensionName}' not found in raycast/extensions repo`)
-        fs.rmSync(tempCloneDir, { recursive: true, force: true })
+      if (fs.existsSync(targetDir)) {
+        console.error(`Directory "${name}" already exists`)
         process.exit(1)
       }
 
-      // Move files to final destination
-      if (options.dir) {
-        fs.mkdirSync(extensionDir, { recursive: true })
+      console.log(`Creating new extension "${name}"...`)
+
+      // Download template from GitHub
+      const templateUrl =
+        'https://github.com/remorses/termcast/archive/refs/heads/main.zip'
+
+      console.log('Downloading template...')
+      const response = await fetch(templateUrl)
+      if (!response.ok) {
+        throw new Error(`Failed to download template: ${response.status}`)
       }
-      const filesToMove = fs.readdirSync(extensionPath)
-      for (const file of filesToMove) {
-        const src = path.join(extensionPath, file)
-        const dest = path.join(extensionDir, file)
-        fs.renameSync(src, dest)
+
+      console.log('Extracting...')
+      const JSZip = (await import('jszip')).default
+      const zip = await JSZip.loadAsync(await response.arrayBuffer())
+
+      // Find the template folder in the zip
+      const templatePrefix = 'termcast-main/termcast/template/'
+      const templateFiles = Object.keys(zip.files).filter((name) =>
+        name.startsWith(templatePrefix),
+      )
+
+      if (templateFiles.length === 0) {
+        throw new Error('Template not found in downloaded archive')
       }
 
-      // Clean up temp clone directory
-      fs.rmSync(tempCloneDir, { recursive: true, force: true })
+      // Extract template files to target directory
+      fs.mkdirSync(targetDir, { recursive: true })
 
-      console.log(`\nInstalling dependencies...`)
-      execSync('npm install', {
-        cwd: extensionDir,
-        stdio: 'inherit',
-      })
+      for (const filePath of templateFiles) {
+        const relativePath = filePath.slice(templatePrefix.length)
+        if (!relativePath) {
+          continue
+        }
 
-      console.log(`\n✅ Extension downloaded successfully!`)
-      console.log(`📁 Path: ${extensionDir}`)
+        const targetPath = path.join(targetDir, relativePath)
+        const zipEntry = zip.files[filePath]
+
+        if (zipEntry.dir) {
+          fs.mkdirSync(targetPath, { recursive: true })
+        } else {
+          fs.mkdirSync(path.dirname(targetPath), { recursive: true })
+          const content = await zipEntry.async('nodebuffer')
+          fs.writeFileSync(targetPath, content)
+        }
+      }
+
+      // Replace placeholders in package.json
+      const packageJsonPath = path.join(targetDir, 'package.json')
+      let packageJsonContent = fs.readFileSync(packageJsonPath, 'utf-8')
+      const title = name
+        .split('-')
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(' ')
+      packageJsonContent = packageJsonContent
+        .replace(/\{\{name\}\}/g, name)
+        .replace(/\{\{title\}\}/g, title)
+      fs.writeFileSync(packageJsonPath, packageJsonContent)
+
+      console.log('\nInstalling dependencies...')
+      execSync('bun install', { cwd: targetDir, stdio: 'inherit' })
+
+      console.log(`\n✅ Created "${name}" successfully!`)
+      console.log(`\nNext steps:`)
+      console.log(`  cd ${name}`)
+      console.log(`  termcast dev`)
       process.exit(0)
-    } catch (error) {
-      console.error('Error downloading extension:', error)
+    } catch (error: any) {
+      console.error('Failed to create extension:', error.message)
       process.exit(1)
     }
   })

package/src/colors.tsx

@@ -30,6 +30,7 @@ export function resolveColor(color: Color.ColorLike | undefined | null): string
     return color
   }
   if (typeof color === 'object' && 'dark' in color) {
+    // Color.Dynamic - just use dark variant (light themes should use flat colors)
     return color.dark
   }
   return undefined