termcast 1.3.9

package/src/logger.tsx

@@ -0,0 +1,84 @@
+import * as fs from 'fs'
+import * as path from 'path'
+import { useEffect } from 'react'
+
+const LOG_FILE = path.join(process.cwd(), 'app.log')
+
+// Delete log file on process start
+if (fs.existsSync(LOG_FILE)) {
+  fs.unlinkSync(LOG_FILE)
+}
+
+function serialize(msg: any): string {
+  if (msg instanceof Error) {
+    return `${msg.message}\n${msg.stack}`
+  }
+  if (typeof msg === 'string') {
+    return msg
+  }
+  return Bun.inspect(msg, { depth: 3 })
+}
+
+export const logger = {
+  log: (...messages: any[]) => {
+    const timestamp = new Date().toISOString()
+    const formattedMessages = messages.map(serialize).join(' ')
+    const logEntry = `[${timestamp}] ${formattedMessages}\n`
+    fs.appendFileSync(LOG_FILE, logEntry)
+  },
+  error: (...messages: any[]) => {
+    const timestamp = new Date().toISOString()
+    const formattedMessages = messages.map(serialize).join(' ')
+    const logEntry = `[${timestamp}] ERROR: ${formattedMessages}\n`
+    fs.appendFileSync(LOG_FILE, logEntry)
+  },
+  warn: (...messages: any[]) => {
+    const timestamp = new Date().toISOString()
+    const formattedMessages = messages.map(serialize).join(' ')
+    const logEntry = `[${timestamp}] WARN: ${formattedMessages}\n`
+    fs.appendFileSync(LOG_FILE, logEntry)
+  },
+  trace: (...messages: any[]) => {
+    const timestamp = new Date().toISOString()
+    let stack: string = ''
+    try {
+      throw new Error()
+    } catch (err: any) {
+      if (err instanceof Error && err.stack) {
+        stack = err.stack.split('\n').slice(2).join('\n')
+      }
+    }
+    const formattedMessages = messages.map(serialize).join(' ')
+    const logEntry = `[${timestamp}] TRACE: ${formattedMessages}\n${stack}\n`
+    fs.appendFileSync(LOG_FILE, logEntry)
+  },
+}
+
+// Catch unhandled errors and exceptions
+process.on('uncaughtException', (error: Error) => {
+  if (error instanceof Error) {
+    logger.error('Uncaught Exception:', error.message, error.stack)
+  } else {
+    logger.error('Uncaught Exception:', serialize(error))
+  }
+  process.exit(1)
+})
+
+process.on('unhandledRejection', async (reason: any, promise: Promise<any>) => {
+  if (reason instanceof Error) {
+    logger.error(
+      'Unhandled Rejection at:',
+      promise,
+      'reason:',
+      reason.message,
+      reason.stack,
+    )
+  } else {
+    logger.error(
+      'Unhandled Rejection at:',
+      promise,
+      'reason:',
+      serialize(reason),
+    )
+  }
+})

package/src/package-json.tsx

@@ -0,0 +1,197 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+interface RaycastPreference {
+  name: string
+  title: string
+  description: string
+  type:
+    | 'textfield'
+    | 'password'
+    | 'checkbox'
+    | 'dropdown'
+    | 'appPicker'
+    | 'file'
+    | 'directory'
+  required: boolean
+  placeholder?: string
+  default?: any
+  label?: string
+  data?: Array<{ title: string; value: string }>
+}
+
+interface RaycastArgument {
+  name: string
+  type: 'text' | 'password' | 'dropdown'
+  placeholder: string
+  required?: boolean
+  data?: Array<{ title: string; value: string }>
+}
+
+interface RaycastCommand {
+  name: string
+  title: string
+  subtitle?: string
+  description: string
+  icon?: string
+  mode: 'view' | 'no-view' | 'menu-bar'
+  interval?: string
+  keywords?: string[]
+  arguments?: RaycastArgument[]
+  preferences?: RaycastPreference[]
+  disabledByDefault?: boolean
+}
+
+interface RaycastTool {
+  name: string
+  title: string
+  description: string
+  icon?: string
+}
+
+interface RaycastPackageJson {
+  name: string
+  title: string
+  description: string
+  icon?: string
+  author?: string
+  categories?: string[]
+  license?: string
+  commands?: RaycastCommand[]
+  tools?: RaycastTool[]
+  platforms?: string[]
+  ai?: {
+    instructions?: string
+    evals?: any
+  }
+  owner?: string
+  access?: 'public' | 'private'
+  contributors?: string[]
+  pastContributors?: string[]
+  keywords?: string[]
+  preferences?: RaycastPreference[]
+  external?: string[]
+}
+
+export function parsePackageJson({
+  packageJsonPath,
+}: {
+  packageJsonPath?: string
+} = {}): RaycastPackageJson {
+  const resolvedPath =
+    packageJsonPath || path.join(process.cwd(), 'package.json')
+
+  if (!fs.existsSync(resolvedPath)) {
+    throw new Error(`Package.json not found at: ${resolvedPath}`)
+  }
+
+  const rawContent = fs.readFileSync(resolvedPath, 'utf-8')
+  const packageJson = JSON.parse(rawContent)
+
+  const raycastConfig: RaycastPackageJson = {
+    name: packageJson.name || '',
+    title: packageJson.title || packageJson.name || '',
+    description: packageJson.description || '',
+    icon: packageJson.icon,
+    author: packageJson.author,
+    categories: packageJson.categories || [],
+    license: packageJson.license,
+    commands: packageJson.commands || [],
+    tools: packageJson.tools || [],
+    platforms: packageJson.platforms,
+    ai: packageJson.ai,
+    owner: packageJson.owner,
+    access: packageJson.access,
+    contributors: packageJson.contributors || [],
+    pastContributors: packageJson.pastContributors || [],
+    keywords: packageJson.keywords || [],
+    preferences: packageJson.preferences || [],
+    external: packageJson.external || [],
+  }
+
+  return raycastConfig
+}
+
+interface CommandWithFile extends RaycastCommand {
+  filePath: string
+  exists: boolean
+}
+
+interface CommandsWithFiles {
+  packageJson: RaycastPackageJson
+  packageJsonPath: string
+  projectRoot: string
+  commands: CommandWithFile[]
+}
+export function getCommandsWithFiles({
+  packageJsonPath,
+}: {
+  packageJsonPath?: string
+} = {}): CommandsWithFiles {
+  const resolvedPath =
+    packageJsonPath || path.join(process.cwd(), 'package.json')
+  const projectRoot = path.dirname(resolvedPath)
+  const packageJson = parsePackageJson({ packageJsonPath: resolvedPath })
+
+  const commands: CommandWithFile[] = (packageJson.commands || []).map(
+    (command) => {
+      const possibleExtensions = ['.tsx', '.ts', '.jsx', '.js']
+      let filePath = ''
+      let exists = false
+
+      // First, look for the file outside "src"
+      for (const ext of possibleExtensions) {
+        const candidatePath = path.join(projectRoot, `${command.name}${ext}`)
+        if (fs.existsSync(candidatePath)) {
+          filePath = candidatePath
+          exists = true
+          break
+        }
+      }
+
+      // If not found, look for the file inside "src"
+      if (!exists) {
+        for (const ext of possibleExtensions) {
+          const candidatePath = path.join(
+            projectRoot,
+            'src',
+            `${command.name}${ext}`,
+          )
+          if (fs.existsSync(candidatePath)) {
+            filePath = candidatePath
+            exists = true
+            break
+          }
+        }
+      }
+
+      // If still not found, default to "src/commandName.tsx"
+      if (!filePath) {
+        filePath = path.join(projectRoot, 'src', `${command.name}.tsx`)
+      }
+
+      return {
+        ...command,
+        filePath,
+        exists,
+      }
+    },
+  )
+
+  return {
+    packageJson,
+    packageJsonPath: resolvedPath,
+    projectRoot,
+    commands,
+  }
+}
+
+export type {
+  RaycastPreference,
+  RaycastArgument,
+  RaycastCommand,
+  RaycastTool,
+  RaycastPackageJson,
+  CommandWithFile,
+  CommandsWithFiles,
+}

package/src/preload.tsx

@@ -0,0 +1,32 @@
+import { plugin } from 'bun'
+import path from 'node:path'
+import { logger } from './logger'
+
+plugin({
+  name: 'alias-raycast-to-termcast',
+  setup(build) {
+    build.onResolve({ filter: /@raycast\/api/ }, () => {
+      return {
+        path: require.resolve('termcast'),
+      }
+    })
+    // build.onResolve({ filter: /@raycast\/utils/ }, (args) => {
+    //     return {
+    //         path: require.resolve('@raycast/utils', {
+    //             paths: [args.importer],
+    //         }),
+
+    //     }
+    // })
+    // build.onLoad({ filter: /@raycast\/utils/ }, (args) => {
+    //     const filePath = require
+    //         .resolve(args.path.replace('file:', ''))
+    //         .replace('file:', '')
+    //     return {
+    //         contents: require('fs').readFileSync(filePath, 'utf8'),
+
+    //         loader: 'js',
+    //     }
+    // })
+  },
+})

package/src/state.tsx

@@ -0,0 +1,49 @@
+import { create } from 'zustand'
+import { type ReactNode } from 'react'
+import type { RaycastPackageJson } from './package-json'
+
+export type DialogPosition = 'center' | 'top-right' | 'bottom-right'
+
+export interface DialogStackItem {
+  element: ReactNode
+  position?: DialogPosition
+}
+
+export interface NavigationStackItem {
+  element: ReactNode
+  onPop?: () => void
+}
+
+interface AppState {
+  toast: ReactNode | null
+  dialogStack: DialogStackItem[]
+  // Navigation state
+  navigationStack: NavigationStackItem[]
+  // Dev mode state
+  devElement: ReactNode | null
+  devRebuildCount: number
+  // Extension and command state
+  extensionPath: string | null
+  extensionPackageJson: RaycastPackageJson | null
+  currentCommandName: string | null
+  // OAuth state
+  googleAccessToken?: string
+  googleIdToken?: string
+}
+
+export const useStore = create<AppState>(() => ({
+  toast: null,
+  dialogStack: [],
+  // Navigation state
+  navigationStack: [],
+  // Dev mode state
+  devElement: null,
+  devRebuildCount: 0,
+  // Extension and command state
+  extensionPath: null,
+  extensionPackageJson: null,
+  currentCommandName: null,
+  // OAuth state
+  googleAccessToken: undefined,
+  googleIdToken: undefined,
+}))

package/src/store-api/download.test.tsx

@@ -0,0 +1,38 @@
+import { describe, test, expect } from 'bun:test'
+import { downloadExtension } from './download'
+describe('downloadExtension', () => {
+  test('downloads a real raycast extension and returns filenames', async () => {
+    // Test with a timeout since it needs to download from the API
+    const files = await downloadExtension({
+      author: 'xmorse',
+      extension: 'spiceblow-database',
+    })
+
+    const filenames = files.map((f) => f.filename).sort()
+
+    // Just check we get some files
+    expect(filenames).toMatchInlineSnapshot(`
+          [
+            "assets/extension-icon.png",
+            "package.json",
+            "search-database.js",
+            "search-database.js.map",
+          ]
+        `)
+    expect(filenames.length).toBeGreaterThan(0)
+
+    // Check package.json commands field
+    const packageJson = files.find((f) => f.filename === 'package.json')
+    const packageData = JSON.parse(packageJson?.buffer.toString()!)
+    expect(packageData.commands).toMatchInlineSnapshot(`
+          [
+            {
+              "description": "Search and update your PostgreSQL or MySQL database",
+              "mode": "view",
+              "name": "search-database",
+              "title": "Manage Database",
+            },
+          ]
+        `)
+  }, 10000)
+})

package/src/store-api/download.tsx

@@ -0,0 +1,52 @@
+import JSZip from 'jszip'
+import path from 'path'
+
+export async function downloadExtension({
+  author,
+  extension,
+}: {
+  author: string
+  extension: string
+}): Promise<{ buffer: Buffer; filename: string }[]> {
+  // curl -H 'cookie: __raycast_session=<SESSION_TOKEN>' \
+  //      -H 'accept: */*' \
+  //      -H 'user-agent: Raycast/1.102.6 (macOS Version 15.6 (Build 24G84))' \
+  //      -H 'accept-language: en-GB,en;q=0.9' \
+  //      -H 'authorization: Bearer <AUTH_TOKEN>' \
+  //      https://backend.raycast.com/api/v1/extensions/mt40/memo/download
+  const url = `https://backend.raycast.com/api/v1/extensions/${author}/${extension}/download`
+
+  const response = await fetch(url, {
+    redirect: 'follow',
+    headers: {
+      accept: '*/*',
+      'user-agent': 'Raycast/1.102.6 (macOS Version 15.6 (Build 24G84))',
+      'accept-language': 'en-GB,en;q=0.9',
+    },
+  })
+
+  const arrayBuffer = await response.arrayBuffer()
+
+  // Check if we got an error response instead of a zip
+  if (!response.ok) {
+    const text = new TextDecoder().decode(arrayBuffer)
+    throw new Error(
+      `Failed to download extension: ${response.status} - ${text}`,
+    )
+  }
+
+  const zip = await JSZip.loadAsync(Buffer.from(arrayBuffer))
+
+  const files: { buffer: Buffer; filename: string }[] = []
+
+  for (const [filename, file] of Object.entries(zip.files)) {
+    if (!file.dir) {
+      const buffer = await file.async('nodebuffer')
+      const pathParts = filename.split('/')
+      const filenameWithoutTopLevel = path.posix.join(...pathParts.slice(1))
+      files.push({ buffer, filename: filenameWithoutTopLevel })
+    }
+  }
+
+  return files
+}

package/src/store-api/extension.test.tsx

@@ -0,0 +1,24 @@
+import { describe, test, expect } from 'bun:test'
+import { fetchExtension } from './extension'
+
+describe('fetchExtension', () => {
+  test('fetches a raycast extension metadata', async () => {
+    const extension = await fetchExtension({
+      author: 'xmorse',
+      extension: 'spiceblow-database',
+    })
+
+    // Check basic structure
+    expect(extension.id).toBeTruthy()
+    expect(extension.name).toBe('spiceblow-database')
+    expect(extension.author.handle).toBe('xmorse')
+
+    // Snapshot the command names
+    const commandNames = extension.commands.map((c) => c.name).sort()
+    expect(commandNames).toMatchInlineSnapshot(`
+          [
+            "search-database",
+          ]
+        `)
+  }, 10000)
+})

package/src/store-api/extension.tsx

@@ -0,0 +1,123 @@
+// curl -H 'accept: application/json' \
+//      -H 'content-type: application/json' \
+//      -H 'cookie: __raycast_session=REDACTED' \
+//      -H 'user-agent: Raycast/1.102.6 (macOS Version 15.6 (Build 24G84))' \
+//      -H 'authorization: Bearer REDACTED' \
+//      -H 'accept-language: en-GB,en;q=0.9' \
+//      https://backend.raycast.com/api/v1/extensions/mt40/memo
+
+export async function fetchExtension({
+  author,
+  extension,
+}: {
+  author: string
+  extension: string
+}): Promise<ExtensionResponse> {
+  const response = await fetch(
+    `https://backend.raycast.com/api/v1/extensions/${author}/${extension}`,
+    {
+      method: 'GET',
+      headers: {
+        accept: 'application/json',
+        'content-type': 'application/json',
+        'user-agent': 'Raycast/1.102.6 (macOS Version 15.6 (Build 24G84))',
+        'accept-language': 'en-GB,en;q=0.9',
+      },
+    },
+  )
+
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch extension: ${response.status} ${response.statusText}`,
+    )
+  }
+
+  return response.json() as any
+}
+
+interface Author {
+  id: string
+  name: string
+  handle: string
+  bio: string | null
+  twitter_handle: string | null
+  github_handle: string | null
+  location: string | null
+  initials: string
+  avatar_placeholder_color: string
+  slack_community_username: string | null
+  slack_community_user_id: string | null
+  created_at: number
+  website_anchor: string | null
+  website: string | null
+  credits: number
+  username: string
+  avatar: string | null
+}
+
+interface Icons {
+  light: string | null
+  dark: string | null
+}
+
+interface Command {
+  id: string
+  name: string
+  title: string
+  subtitle: string
+  description: string
+  keywords: string[]
+  mode: string
+  disabled_by_default: boolean
+  beta: boolean
+  icons: Icons
+}
+
+interface ChangelogVersion {
+  title: string
+  title_link: string | null
+  date: string
+  markdown: string
+}
+
+interface Changelog {
+  versions: ChangelogVersion[]
+}
+
+interface ExtensionResponse {
+  id: string
+  name: string
+  native_id: string | null
+  seo_categories: string[]
+  platforms: string[] | null
+  author: Author
+  created_at: number
+  kill_listed_at: number
+  owner: Author
+  status: string
+  is_new: boolean
+  access: string
+  store_url: string
+  download_count: number
+  past_contributors: any[]
+  listed: boolean
+  title: string
+  description: string
+  commit_sha: string
+  relative_path: string
+  api_version: string
+  categories: string[]
+  prompt_examples: any[]
+  metadata_count: number
+  updated_at: number
+  source_url: string
+  readme_url: string
+  readme_assets_path: string
+  icons: Icons
+  commands: Command[]
+  tools: any[]
+  download_url: string
+  contributors: any[]
+  metadata: string[]
+  changelog: Changelog
+}

package/src/store-api/search.test.tsx

@@ -0,0 +1,50 @@
+import { describe, test, expect } from 'bun:test'
+import { searchStoreListings } from './search'
+
+describe('searchStoreListings', () => {
+  test('searches for extensions in the store', async () => {
+    const results = await searchStoreListings({
+      query: 'database',
+      perPage: 5,
+    })
+
+    // Check we got results
+    expect(results.data).toBeDefined()
+    expect(results.data.length).toBeGreaterThan(0)
+    expect(results.data.length).toBeLessThanOrEqual(5)
+
+    // Snapshot the extension names
+    const extensionNames = results.data.map((d) => d.name).sort()
+    expect(extensionNames).toMatchInlineSnapshot(`
+          [
+            "discogs",
+            "notion",
+            "spiceblow-database",
+            "tmdb",
+            "turso",
+          ]
+        `)
+  }, 10000)
+
+  test.skip('returns results when searching without a query', async () => {
+    const results = await searchStoreListings({
+      query: '',
+      perPage: 5,
+    })
+
+    expect(results.data).toBeDefined()
+    expect(results.data.length).toBeGreaterThan(0)
+    expect(results.data.length).toBeLessThanOrEqual(5)
+
+    const extensionNames = results.data.map((d) => d.name).sort()
+    expect(extensionNames).toMatchInlineSnapshot(`
+          [
+            "baidu-ocr",
+            "fhir",
+            "gitee",
+            "mobius-materials",
+            "xpf-converter",
+          ]
+        `)
+  }, 10000)
+})