termcast 1.3.9

package/src/store-api/search.tsx

@@ -0,0 +1,146 @@
+// curl -H 'accept: application/json' \
+//      -H 'content-type: application/json' \
+//      -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/store_listings/search?per_page=25&q=notion&include_native=true&page=1&platform=macOS'
+
+export async function searchStoreListings({
+  query,
+  page = 1,
+  perPage = 25,
+  includeNative = true,
+  platform = 'macOS',
+}: {
+  query: string
+  page?: number
+  perPage?: number
+  includeNative?: boolean
+  platform?: string
+}): Promise<StoreSearchResponse> {
+  const params = new URLSearchParams({
+    q: query,
+    page: page.toString(),
+    per_page: perPage.toString(),
+    include_native: includeNative.toString(),
+    platform: platform,
+  })
+
+  const response = await fetch(
+    `https://backend.raycast.com/api/v1/store_listings/search?${params}`,
+    {
+      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(`HTTP error! status: ${response.status}`)
+  }
+
+  return (await response.json()) as StoreSearchResponse
+}
+
+interface StoreSearchResponse {
+  data: StoreListing[]
+}
+
+interface StoreListing {
+  id: string
+  name: string
+  native_id: string | null
+  seo_categories: string[]
+  platforms: string[] | null
+  created_at: number
+  author: User
+  owner:
+    | User
+    | {
+        id: string
+        name: string
+        handle: string
+        initials: string
+        avatar_placeholder_color: string
+        avatar: string
+      }
+  status: string
+  is_new: boolean
+  access: string
+  store_url: string
+  download_count: number
+  kill_listed_at: number | null
+  title: string
+  description: string
+  commit_sha: string
+  relative_path: string
+  api_version: string
+  categories: string[]
+  prompt_examples: string[]
+  metadata_count: number
+  updated_at: number
+  source_url: string
+  readme_url: string
+  readme_assets_path: string
+  icons: {
+    light: string | null
+    dark: string | null
+  }
+  download_url: string
+  commands: Command[]
+  contributors: User[]
+  tools: Tool[]
+}
+
+interface User {
+  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
+  website_anchor: string | null
+  created_at: number
+  website: string | null
+  username: string
+  avatar: 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: {
+    light: string | null
+    dark: string | null
+  }
+}
+
+interface Tool {
+  id: string
+  name: string
+  title: string
+  description: string
+  keywords: string[]
+  functionalities: unknown[]
+  mode: string | null
+  side_effects: boolean
+  icons: {
+    light: string | null
+    dark: string | null
+  }
+}

package/src/theme.tsx

@@ -0,0 +1,31 @@
+export const Theme = {
+  // Text colors
+  text: '#FFFFFF',
+  textMuted: '#999999',
+
+  // Background colors
+  background: '#000000',
+  backgroundPanel: '#1E1E1E', // Dark gray panel background
+
+  // Primary/accent colors
+  primary: '#0080FF', // Blue
+  accent: '#00FF80', // Light green (was using this for dates)
+
+  // Accessory colors (from List component)
+  info: '#0080FF', // Blue for text accessories
+  success: '#00FF80', // Green for date accessories
+  warning: '#FF8000', // Orange for tag accessories
+  error: '#FF0000', // Red for errors
+
+  // Additional UI colors
+  border: '#333333',
+  highlight: '#0080FF',
+  selected: '#0080FF',
+  yellow: '#FFFF00', // Yellow for icons
+  link: '#0080FF', // Blue for links
+
+  // Transparent
+  transparent: undefined, // Use undefined for no background color
+} as const
+
+export default Theme

package/src/utils/file-system.ts

@@ -0,0 +1,87 @@
+import * as fs from 'fs/promises'
+import * as path from 'path'
+import * as os from 'os'
+
+export interface FileSystemItem {
+  name: string
+  path: string
+  isDirectory: boolean
+}
+
+export async function searchFiles(
+  searchPath: string,
+  prefix: string,
+): Promise<FileSystemItem[]> {
+  try {
+    // Resolve ~ to home directory
+    if (searchPath.startsWith('~')) {
+      searchPath = searchPath.replace('~', os.homedir())
+    }
+
+    // Handle absolute vs relative paths
+    const basePath = path.isAbsolute(searchPath)
+      ? searchPath
+      : path.resolve(process.cwd(), searchPath || '.')
+
+    // Check if directory exists
+    try {
+      await fs.access(basePath)
+    } catch {
+      return []
+    }
+
+    // List files and directories
+    const entries = await fs.readdir(basePath, { withFileTypes: true })
+
+    const items: FileSystemItem[] = []
+
+    for (const entry of entries) {
+      // Skip hidden files unless prefix starts with .
+      if (entry.name.startsWith('.') && !prefix.startsWith('.')) continue
+
+      // Case-insensitive prefix matching
+      if (
+        prefix === '' ||
+        entry.name.toLowerCase().startsWith(prefix.toLowerCase())
+      ) {
+        items.push({
+          name: entry.name,
+          path: path.join(basePath, entry.name),
+          isDirectory: entry.isDirectory(),
+        })
+      }
+    }
+
+    // Sort directories first, then files
+    items.sort((a, b) => {
+      if (a.isDirectory === b.isDirectory) {
+        return a.name.localeCompare(b.name)
+      }
+      return a.isDirectory ? -1 : 1
+    })
+
+    return items.slice(0, 10) // Limit results
+  } catch (error) {
+    return []
+  }
+}
+
+export function parsePath(input: string): { basePath: string; prefix: string } {
+  // Handle ~ expansion
+  if (input.startsWith('~')) {
+    input = input.replace('~', os.homedir())
+  }
+
+  const lastSlashIndex = input.lastIndexOf('/')
+
+  if (lastSlashIndex === -1) {
+    // No slash, search in current directory
+    return { basePath: '.', prefix: input }
+  }
+
+  // Extract base path and prefix
+  const basePath = input.substring(0, lastSlashIndex + 1) || '/'
+  const prefix = input.substring(lastSlashIndex + 1)
+
+  return { basePath, prefix }
+}

package/src/utils.test.tsx

@@ -0,0 +1,204 @@
+import { describe, test, expect, beforeEach, afterEach } from 'vitest'
+import {
+  createDeeplink,
+  DeeplinkType,
+  LaunchType,
+  executeSQL,
+  runAppleScript,
+} from './utils'
+import { Database } from 'bun:sqlite'
+import * as fs from 'fs'
+import * as os from 'os'
+import * as path from 'path'
+
+describe('createDeeplink', () => {
+  test('creates extension deeplink without options', () => {
+    const url = createDeeplink({
+      command: 'my-command',
+    })
+    expect(url).toMatchInlineSnapshot(`"raycast://extensions/my-command"`)
+  })
+
+  test('creates extension deeplink with all options', () => {
+    const url = createDeeplink({
+      command: 'my-command',
+      launchType: LaunchType.Background,
+      arguments: { foo: 'bar', count: 42 },
+      fallbackText: 'Fallback text',
+      ownerOrAuthorName: 'john-doe',
+      extensionName: 'my-extension',
+    })
+    expect(url).toMatchInlineSnapshot(
+      `"raycast://extensions/john-doe/my-extension/my-command?fallbackText=Fallback+text&launchType=background&arguments=%257B%2522foo%2522%253A%2522bar%2522%252C%2522count%2522%253A42%257D"`,
+    )
+  })
+
+  test('creates extension deeplink with only extension name', () => {
+    const url = createDeeplink({
+      command: 'my-command',
+      extensionName: 'my-extension',
+      fallbackText: 'Open extension',
+    })
+    expect(url).toMatchInlineSnapshot(
+      `"raycast://extensions/my-extension/my-command?fallbackText=Open+extension"`,
+    )
+  })
+
+  test('creates script command deeplink', () => {
+    const url = createDeeplink({
+      type: DeeplinkType.ScriptCommand,
+      command: 'my-script',
+      arguments: ['arg1', 'arg2', 'arg3'],
+    })
+    expect(url).toMatchInlineSnapshot(
+      `"raycast://script-commands/my-script?name=my-script&arguments=arg1%09arg2%09arg3"`,
+    )
+  })
+
+  test('creates script command deeplink without arguments', () => {
+    const url = createDeeplink({
+      type: DeeplinkType.ScriptCommand,
+      command: 'my-script',
+    })
+    expect(url).toMatchInlineSnapshot(
+      `"raycast://script-commands/my-script?name=my-script"`,
+    )
+  })
+})
+
+describe('executeSQL', () => {
+  const testDbPath = path.join(os.tmpdir(), 'test-db.sqlite')
+
+  beforeEach(() => {
+    // Create a test database
+    const db = new Database(testDbPath)
+    db.exec(`
+      CREATE TABLE users (
+        id INTEGER PRIMARY KEY,
+        name TEXT NOT NULL,
+        age INTEGER
+      )
+    `)
+    db.exec(`
+      INSERT INTO users (name, age) VALUES
+      ('Alice', 30),
+      ('Bob', 25),
+      ('Charlie', 35)
+    `)
+    db.close()
+  })
+
+  afterEach(() => {
+    // Clean up test database
+    if (fs.existsSync(testDbPath)) {
+      fs.unlinkSync(testDbPath)
+    }
+  })
+
+  test('executes SELECT query', async () => {
+    const results = await executeSQL(
+      testDbPath,
+      'SELECT * FROM users ORDER BY age',
+    )
+    expect(results).toMatchInlineSnapshot(`
+      [
+        {
+          "age": 25,
+          "id": 2,
+          "name": "Bob",
+        },
+        {
+          "age": 30,
+          "id": 1,
+          "name": "Alice",
+        },
+        {
+          "age": 35,
+          "id": 3,
+          "name": "Charlie",
+        },
+      ]
+    `)
+  })
+
+  test('executes query with WHERE clause', async () => {
+    const results = await executeSQL(
+      testDbPath,
+      'SELECT name FROM users WHERE age > 30',
+    )
+    expect(results).toMatchInlineSnapshot(`
+      [
+        {
+          "name": "Charlie",
+        },
+      ]
+    `)
+  })
+
+  test('throws error for non-existent database', async () => {
+    await expect(
+      executeSQL('/non/existent/path.db', 'SELECT 1'),
+    ).rejects.toThrow('Database file not found')
+  })
+
+  test('throws error for invalid SQL', async () => {
+    await expect(executeSQL(testDbPath, 'INVALID SQL QUERY')).rejects.toThrow(
+      'SQL execution failed',
+    )
+  })
+})
+
+describe('runAppleScript', () => {
+  test('throws error on non-macOS platforms', async () => {
+    if (process.platform !== 'darwin') {
+      await expect(runAppleScript('return "Hello"')).rejects.toThrow(
+        'runAppleScript is only supported on macOS',
+      )
+    }
+  })
+
+  // These tests will only run on macOS
+  if (process.platform === 'darwin') {
+    test('executes simple AppleScript', async () => {
+      const result = await runAppleScript('return "Hello World"')
+      expect(result).toBe('Hello World')
+    })
+
+    test('executes AppleScript with arguments', async () => {
+      const script = `return "Hello " & item 1 of argv & " " & item 2 of argv`
+      const result = await runAppleScript(script, ['John', 'Doe'])
+      expect(result).toBe('Hello John, Doe')
+    })
+
+    test('executes JavaScript for Automation', async () => {
+      const result = await runAppleScript('return "Hello from JS"', undefined, {
+        language: 'JavaScript',
+      })
+      expect(result).toBe('Hello from JS')
+    })
+
+    test('parses custom output', async () => {
+      interface CustomResult {
+        message: string
+        count: number
+      }
+
+      const result = await runAppleScript<CustomResult>(
+        'return "{\\"message\\": \\"Test\\", \\"count\\": 42}"',
+        undefined,
+        {
+          humanReadableOutput: false, // Keep the raw quoted output for JSON parsing
+          parseOutput: ({ stdout }) => {
+            // Remove surrounding quotes from AppleScript output
+            const jsonStr =
+              stdout.startsWith('"') && stdout.endsWith('"')
+                ? stdout.slice(1, -1).replace(/\\"/g, '"')
+                : stdout
+            return JSON.parse(jsonStr)
+          },
+        },
+      )
+      expect(result).toEqual({ message: 'Test', count: 42 })
+    })
+  }
+})