termcast 1.4.1 → 1.6.0

package/src/utils.tsx

@@ -13,10 +13,6 @@ import {
   readFileSync,
   ensureDir,
   execCommand,
-  readdirSync,
-  rmSync,
-  mkdirSync,
-  cpSync,
 } from '#platform/runtime'
 import {
   parsePackageJson,
@@ -317,90 +313,11 @@ export function captureException(exception: unknown): void {
   console.error('[captureException] Exception captured:', exception)
 }
 
-export function getExtensionPath(extensionName: string): string {
-  const storeDir = getStoreDirectory()
-  return joinPath(storeDir, extensionName)
-}
-
-export function getExtensionPackageJsonPath(extensionName: string): string {
-  return joinPath(getExtensionPath(extensionName), 'package.json')
-}
-
-export function getExtensionPackageJson(
-  extensionName: string,
-): RaycastPackageJson | null {
-  const packageJsonPath = getExtensionPackageJsonPath(extensionName)
-
-  if (!fileExists(packageJsonPath)) {
-    return null
-  }
-
-  try {
-    return parsePackageJson({ packageJsonPath })
-  } catch (error) {
-    console.error(`Failed to parse package.json for ${extensionName}:`, error)
-    return null
-  }
-}
-
 export interface ExtensionPreferencesInfo {
   hasPreferences: boolean
   hasRequiredPreferences: boolean
 }
 
-export function checkExtensionPreferences(
-  extensionName: string,
-): ExtensionPreferencesInfo {
-  const packageJson = getExtensionPackageJson(extensionName)
-
-  if (!packageJson) {
-    return { hasPreferences: false, hasRequiredPreferences: false }
-  }
-
-  // Check for extension-wide preferences
-  const hasExtensionPreferences =
-    packageJson.preferences && packageJson.preferences.length > 0
-
-  // Check if any command has preferences
-  const commandsWithPreferences = (packageJson.commands || []).filter(
-    (cmd) => cmd.preferences && cmd.preferences.length > 0,
-  )
-
-  const hasPreferences =
-    hasExtensionPreferences || commandsWithPreferences.length > 0
-
-  // Check for required extension-wide preferences
-  const requiredExtensionPrefs = (packageJson.preferences || []).filter(
-    (pref) => pref.required,
-  )
-
-  // Check if any command has required preferences
-  const commandsWithRequiredPrefs = (packageJson.commands || []).filter(
-    (cmd) => {
-      const requiredPrefs = (cmd.preferences || []).filter(
-        (pref) => pref.required,
-      )
-      return requiredPrefs.length > 0
-    },
-  )
-
-  const hasRequiredPreferences =
-    requiredExtensionPrefs.length > 0 || commandsWithRequiredPrefs.length > 0
-
-  return { hasPreferences, hasRequiredPreferences }
-}
-
-// Store management types
-interface BundledCommand extends CommandWithFile {
-  bundledPath: string
-}
-
-interface StoredExtension {
-  name: string
-  packageJsonPath: string
-  commands: BundledCommand[]
-}
-
 export function resolveCommandPath({
   commandName,
   dir,
@@ -425,87 +342,7 @@ export function resolveCommandPath({
   return ''
 }
 
-export function getStoreDirectory(): string {
-  const homeDir = homedir()
-  const storeDir = joinPath(homeDir, '.termcast', 'store')
-
-  // Ensure store directory exists
-  ensureDir(storeDir)
-
-  return storeDir
-}
-
-export function installExtension({
-  extensionName,
-  extensionSourcePath,
-}: {
-  extensionName: string
-  extensionSourcePath: string
-}): void {
-  const storeDir = getStoreDirectory()
-  const extensionDir = joinPath(storeDir, extensionName)
-
-  if (fileExists(extensionDir)) {
-    rmSync(extensionDir)
-  }
-
-  mkdirSync(extensionDir)
-  cpSync(extensionSourcePath, extensionDir)
-
-  logger.log(`Extension '${extensionName}' installed to ${extensionDir}`)
-}
-
-export function getStoredExtensions(): StoredExtension[] {
-  const storeDir = getStoreDirectory()
-  const extensions: StoredExtension[] = []
 
-  if (!fileExists(storeDir)) {
-    return extensions
-  }
-
-  const entries = readdirSync(storeDir)
-
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue
-
-    const extensionDir = joinPath(storeDir, entry.name)
-    const packageJsonPath = joinPath(extensionDir, 'package.json')
-
-    if (!fileExists(packageJsonPath)) {
-      logger.log(`Skipping ${entry.name}: no package.json found`)
-      continue
-    }
-
-    try {
-      const commandsData = getCommandsWithFiles({ packageJsonPath })
-
-      // Map commands to bundled commands using the resolver
-      const bundledCommands: BundledCommand[] = commandsData.commands.map(
-        (command) => {
-          const bundledPath = resolveCommandPath({
-            commandName: command.name,
-            dir: extensionDir,
-          })
-
-          return {
-            ...command,
-            bundledPath,
-          }
-        },
-      )
-
-      extensions.push({
-        name: entry.name,
-        packageJsonPath,
-        commands: bundledCommands,
-      })
-    } catch (error: any) {
-      logger.error(`Failed to load extension ${entry.name}:`, error.message)
-    }
-  }
-
-  return extensions
-}
 
 export type ParseExecOutputHandler<T = any> = (args: { stdout: string }) => T
 

package/src/examples/store.tsx

@@ -1,4 +0,0 @@
-import Store from '../extensions/store'
-import { renderWithProviders } from '../utils'
-
-await renderWithProviders(<Store />)

package/src/examples/store.vitest.tsx

@@ -1,78 +0,0 @@
-import { test, expect, afterEach, beforeEach } from 'vitest'
-import { launchTerminal, Session } from 'tuistory/src'
-
-let session: Session
-
-beforeEach(async () => {
-  session = await launchTerminal({
-    command: 'bun',
-    args: ['src/examples/store.tsx'],
-    cols: 80,
-    rows: 30,
-  })
-})
-
-afterEach(() => {
-  session?.close()
-})
-
-test('Store extension - searching for spiceblow shows Database', async () => {
-  // Wait for store interface to load
-  const initialOutput = await session.text({
-    waitFor: (text) => {
-      // Wait until we see the store title
-      return text.includes('Store - Install Extensions')
-    },
-    timeout: 15000,
-  })
-
-  // Verify the store interface loads
-  expect(initialOutput).toContain('Store - Install Extensions')
-
-  // Type "spiceblow" in the search bar
-  await session.type('spiceblow')
-
-  // Get the output after search, waiting for Database to appear
-  // This will automatically wait for the API request to complete and results to show
-  const afterSearchOutput = await session.text({
-    waitFor: (text) => {
-      return text.includes('Search, update, insert')
-    },
-    timeout: 15000,
-  })
-
-  // Store the snapshot after searching for spiceblow
-  expect(afterSearchOutput).toMatchInlineSnapshot(`
-    "
-
-
-       Store - Install Extensions ───────────────────────────────────────────────
-
-       > spiceblow
-
-      ›Spiceblow - Sql Database Management Search, update, insert and delete rows
-
-
-
-
-
-
-
-       ↵ view details   ↑↓ navigate   ^k actions   :vim   powered by termcast.app
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-    "
-  `)
-}, 30000)

package/src/extensions/home.tsx

@@ -1,227 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-import React from 'react'
-import { List, logger, useStore, renderWithProviders } from 'termcast'
-import { Action, ActionPanel } from 'termcast'
-import { useNavigation } from 'termcast/src/internal/navigation'
-import { showToast, Toast } from 'termcast/src/apis/toast'
-import { Icon } from 'termcast'
-import { getStoredExtensions } from '../utils'
-import Store from './store'
-import { ExtensionPreferences } from '../components/extension-preferences'
-import { runCommand, clearCommandArguments } from '../utils/run-command'
-import '../globals'
-
-interface ExtensionCommand {
-  extensionName: string
-  extensionTitle: string
-  extensionDir?: string
-  command: any
-  bundledPath?: string
-  loadComponent?: () => Promise<(props: any) => any>
-  packageJson?: any
-}
-
-// Built-in extensions available globally
-const builtinExtensions: ExtensionCommand[] = [
-  {
-    extensionName: 'termcast-store',
-    extensionTitle: 'Termcast Store',
-    command: {
-      name: 'store',
-      title: 'Store - Install Extensions',
-      description: 'Browse and install extensions from the Raycast Store',
-      mode: 'view',
-      icon: 'Store',
-    },
-    loadComponent: async () => Store,
-  },
-]
-
-function ExtensionsList({
-  allCommands,
-  initialSearchQuery = '',
-}: {
-  allCommands: ExtensionCommand[]
-  initialSearchQuery?: string
-}): any {
-  const { push, replace } = useNavigation()
-  const [searchText, setSearchText] = React.useState(initialSearchQuery)
-
-  const handleCommandSelect = async (item: ExtensionCommand) => {
-    clearCommandArguments()
-
-    try {
-      await runCommand({
-        command: item.command,
-        extensionName: item.extensionName,
-        packageJson: item.packageJson,
-        bundledPath: item.bundledPath,
-        loadComponent: item.loadComponent,
-        push,
-        replace,
-      })
-    } catch (error: any) {
-      await showToast({
-        style: Toast.Style.Failure,
-        title: 'Failed to load command',
-        message: error.message || String(error),
-      })
-    }
-  }
-
-  // Group commands by extension
-  const groupedByExtension = allCommands.reduce(
-    (acc, cmd) => {
-      if (!acc[cmd.extensionName]) {
-        acc[cmd.extensionName] = {
-          title: cmd.extensionTitle,
-          commands: [],
-        }
-      }
-      acc[cmd.extensionName].commands.push(cmd)
-      return acc
-    },
-    {} as Record<string, { title: string; commands: ExtensionCommand[] }>,
-  )
-
-  return (
-    <List
-      navigationTitle='Installed Extensions'
-      searchBarPlaceholder='Search commands...'
-      filtering={true}
-      onSearchTextChange={setSearchText}
-      searchText={searchText}
-    >
-      {Object.entries(groupedByExtension).map(
-        ([extensionName, { title, commands }]) => (
-          <List.Section key={extensionName} title={title}>
-            {commands.map((item) => (
-              <List.Item
-                key={`${item.extensionName}-${item.command.name}`}
-                id={`${item.extensionName}-${item.command.name}`}
-                title={item.command.title}
-                subtitle={item.command.description}
-                icon={
-                  item.command.icon
-                    ? Icon[item.command.icon as keyof typeof Icon]
-                    : undefined
-                }
-                accessories={
-                  item.command.mode ? [{ text: item.command.mode }] : []
-                }
-                keywords={[
-                  ...(item.command.keywords || []),
-                  item.extensionName,
-                ]}
-                actions={
-                  <ActionPanel>
-                    <Action
-                      title='Run Command'
-                      onAction={() => {
-                        handleCommandSelect(item)
-                      }}
-                    />
-                    <Action
-                      title='Configure Extension'
-                      onAction={() => {
-                        push(
-                          <ExtensionPreferences
-                            extensionName={item.extensionName}
-                            onSubmit={() => {
-                              handleCommandSelect(item)
-                            }}
-                          />,
-                        )
-                      }}
-                    />
-                    <Action
-                      title='Configure Command'
-                      onAction={() => {
-                        push(
-                          <ExtensionPreferences
-                            extensionName={item.extensionName}
-                            commandName={item.command.name}
-                            onSubmit={() => {
-                              handleCommandSelect(item)
-                            }}
-                          />,
-                        )
-                      }}
-                    />
-                    {item.bundledPath && (
-                      <Action.CopyToClipboard
-                        content={item.bundledPath}
-                        title='Copy Bundle Path'
-                      />
-                    )}
-                    <Action.CopyToClipboard
-                      content={JSON.stringify(item.command, null, 2)}
-                      title='Copy Command Info'
-                    />
-                  </ActionPanel>
-                }
-              />
-            ))}
-          </List.Section>
-        ),
-      )}
-
-      {allCommands.length === 0 && (
-        <List.Section title='No Commands'>
-          <List.Item
-            title='No extensions installed'
-            subtitle='Use "termcast build" to install an extension'
-          />
-        </List.Section>
-      )}
-    </List>
-  )
-}
-
-export async function runHomeCommand(): Promise<void> {
-  logger.log(`preparing to render the home command component`)
-  await renderWithProviders(<Home />, { extensionName: 'termcast-home' })
-  logger.log(`rendered home command component`)
-}
-
-export default function Home({
-  initialSearchQuery = '',
-  key,
-}: {
-  initialSearchQuery?: string
-  key?: React.Key
-}): any {
-  const storedExtensions = getStoredExtensions()
-
-  const allCommands: ExtensionCommand[] = []
-
-  allCommands.push(...builtinExtensions)
-
-  for (const extension of storedExtensions) {
-    const packageJson = JSON.parse(
-      fs.readFileSync(extension.packageJsonPath, 'utf-8'),
-    )
-    const extensionPath = path.dirname(extension.packageJsonPath)
-
-    for (const command of extension.commands) {
-      if (command.bundledPath) {
-        allCommands.push({
-          extensionName: extension.name,
-          extensionTitle: packageJson.title || extension.name,
-          extensionDir: extensionPath,
-          command,
-          bundledPath: command.bundledPath,
-          packageJson,
-        })
-      }
-    }
-  }
-
-  return (
-    <ExtensionsList
-      allCommands={allCommands}
-      initialSearchQuery={initialSearchQuery}
-    />
-  )
-}