termcast 1.3.32 → 1.3.34

package/src/apis/cache.tsx

@@ -5,15 +5,27 @@ import * as fs from 'fs'
 import { logger } from '../logger'
 import { useStore } from '../state'
 
+const CACHE_TABLE_NAME = 'cache_entries'
+const DEFAULT_NAMESPACE = '__default__'
+const initializedDatabasePaths = new Set<string>()
+let logicalTimestamp = Date.now()
+
+function nextTimestamp(): number {
+  logicalTimestamp += 1
+  return logicalTimestamp
+}
+
 function getCurrentDatabasePath(): string {
   const { extensionPath } = useStore.getState()
+  const dbSuffix = process.env.TERMCAST_DB_SUFFIX?.replace(/[^a-zA-Z0-9_-]/g, '_')
+  const dbFileName = dbSuffix ? `data-${dbSuffix}.db` : 'data.db'
 
   if (extensionPath) {
-    return path.join(extensionPath, '.termcast-bundle', 'data.db')
+    return path.join(extensionPath, '.termcast-bundle', dbFileName)
   }
 
   // Fallback for examples/tests that don't set extensionPath
-  return path.join(os.homedir(), '.termcast', '.termcast-bundle', 'data.db')
+  return path.join(os.homedir(), '.termcast', '.termcast-bundle', dbFileName)
 }
 
 function getCurrentCacheDir(namespace?: string): string {
@@ -26,6 +38,109 @@ function getCurrentCacheDir(namespace?: string): string {
   return namespace ? path.join(baseDir, namespace) : baseDir
 }
 
+function getNamespace(namespace?: string): string {
+  return namespace || DEFAULT_NAMESPACE
+}
+
+function initializeDatabaseOnce({ db, dbPath }: { db: Database; dbPath: string }): void {
+  if (initializedDatabasePaths.has(dbPath)) {
+    return
+  }
+
+  db.exec('PRAGMA journal_mode = WAL')
+  db.exec('PRAGMA wal_autocheckpoint = 1000')
+  db.exec('PRAGMA synchronous = NORMAL')
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS ${CACHE_TABLE_NAME} (
+      namespace TEXT NOT NULL,
+      key TEXT NOT NULL,
+      data TEXT NOT NULL,
+      size INTEGER NOT NULL,
+      last_accessed_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      PRIMARY KEY(namespace, key)
+    )
+  `)
+
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_${CACHE_TABLE_NAME}_namespace_lru
+    ON ${CACHE_TABLE_NAME}(namespace, last_accessed_at)
+  `)
+
+  cleanupLegacyCacheTables(db)
+  initializedDatabasePaths.add(dbPath)
+}
+
+function cleanupLegacyCacheTables(db: Database): void {
+  const rows = db
+    .prepare(
+      `SELECT name FROM sqlite_master
+       WHERE type = 'table'
+         AND (name = 'cache' OR name LIKE 'cache_%')
+         AND name != ?`,
+    )
+    .all(CACHE_TABLE_NAME) as Array<{ name: string }>
+
+  if (rows.length === 0) {
+    return
+  }
+
+  const tx = db.transaction(() => {
+    const upsert = db.prepare(
+      `INSERT INTO ${CACHE_TABLE_NAME} (namespace, key, data, size, last_accessed_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?)
+       ON CONFLICT(namespace, key)
+       DO UPDATE SET
+         data = excluded.data,
+         size = excluded.size,
+         last_accessed_at = excluded.last_accessed_at,
+         updated_at = excluded.updated_at`,
+    )
+
+    for (const { name } of rows) {
+      const namespace =
+        name === 'cache'
+          ? DEFAULT_NAMESPACE
+          : name === 'cache_tanstack_query'
+            ? 'tanstack-query'
+            : `legacy:${name.slice('cache_'.length)}`
+
+      try {
+        const values = db
+          .prepare(`SELECT key, data, size, rowid FROM ${name}`)
+          .all() as Array<{ key: string; data: string; size: number; rowid: number }>
+
+        values.forEach((entry) => {
+          const timestamp = entry.rowid
+          upsert.run(
+            namespace,
+            entry.key,
+            entry.data,
+            entry.size,
+            timestamp,
+            timestamp,
+          )
+        })
+      } catch {
+        // Ignore invalid legacy tables and continue cleanup.
+      }
+
+      db.exec(`DROP TABLE IF EXISTS ${name}`)
+    }
+  })
+
+  tx()
+}
+
+function hashString(value: string): string {
+  let hash = 0
+  for (let i = 0; i < value.length; i++) {
+    hash = (hash * 31 + value.charCodeAt(i)) | 0
+  }
+  return Math.abs(hash).toString(36)
+}
+
 export class Cache {
   static get STORAGE_DIRECTORY_NAME(): string {
     const extensionPath = useStore.getState().extensionPath
@@ -38,17 +153,14 @@ export class Cache {
 
   private db: Database
   private capacity: number
-  private namespace?: string
-  private tableName: string
+  private namespace: string
   private subscribers: Cache.Subscriber[] = []
   private currentSize: number = 0
 
   constructor(options?: Cache.Options) {
+    const sqliteLoadStart = Date.now()
     this.capacity = options?.capacity || Cache.DEFAULT_CAPACITY
-    this.namespace = options?.namespace
-    // Replace non-alphanumeric characters with underscores for valid SQL table names
-    const safeNamespace = this.namespace?.replace(/[^a-zA-Z0-9]/g, '_')
-    this.tableName = safeNamespace ? `cache_${safeNamespace}` : 'cache'
+    this.namespace = getNamespace(options?.namespace)
 
     const dbPath = getCurrentDatabasePath()
 
@@ -64,32 +176,23 @@ export class Cache {
       readwrite: true,
     })
 
-    // Use WAL mode and optimize for single file usage
-    this.db.exec('PRAGMA journal_mode = WAL')
-    this.db.exec('PRAGMA wal_autocheckpoint = 1000')
-    this.db.exec('PRAGMA synchronous = NORMAL')
-
-    // Use rowid for ordering - it auto-increments and provides natural LRU order
-    this.db.exec(`
-            CREATE TABLE IF NOT EXISTS ${this.tableName} (
-                rowid INTEGER PRIMARY KEY AUTOINCREMENT,
-                key TEXT UNIQUE NOT NULL,
-                data TEXT NOT NULL,
-                size INTEGER NOT NULL
-            )
-        `)
-
-    // Create index on key for fast lookups
-    this.db.exec(`
-            CREATE INDEX IF NOT EXISTS idx_${this.tableName}_key ON ${this.tableName}(key)
-        `)
+    initializeDatabaseOnce({ db: this.db, dbPath })
 
     // Calculate initial size
     const row = this.db
-      .prepare(`SELECT SUM(size) as total FROM ${this.tableName}`)
-      .get() as { total: number | null } | undefined
+      .prepare(
+        `SELECT COALESCE(SUM(size), 0) as total FROM ${CACHE_TABLE_NAME} WHERE namespace = ?`,
+      )
+      .get(this.namespace) as { total: number | null } | undefined
     this.currentSize = row?.total || 0
 
+    const sqliteLoadMs = Date.now() - sqliteLoadStart
+    if (sqliteLoadMs > 500) {
+      logger.log(
+        `[perf] sqlite cache init took ${sqliteLoadMs}ms (namespace=${this.namespace})`,
+      )
+    }
+
     // Bind all methods to this instance
     this.get = this.get.bind(this)
     this.has = this.has.bind(this)
@@ -106,21 +209,19 @@ export class Cache {
   }
 
   get(key: string): string | undefined {
+    const now = nextTimestamp()
     const row = this.db
-      .prepare(`SELECT rowid, data, size FROM ${this.tableName} WHERE key = ?`)
-      .get(key) as { rowid: number; data: string; size: number } | undefined
+      .prepare(
+        `SELECT data, size FROM ${CACHE_TABLE_NAME} WHERE namespace = ? AND key = ?`,
+      )
+      .get(this.namespace, key) as { data: string; size: number } | undefined
 
     if (row) {
-      // Move to end of LRU by deleting and reinserting (gets new rowid)
-      const tx = this.db.transaction(() => {
-        this.db.prepare(`DELETE FROM ${this.tableName} WHERE key = ?`).run(key)
-        this.db
-          .prepare(
-            `INSERT INTO ${this.tableName} (key, data, size) VALUES (?, ?, ?)`,
-          )
-          .run(key, row.data, row.size)
-      })
-      tx()
+      this.db
+        .prepare(
+          `UPDATE ${CACHE_TABLE_NAME} SET last_accessed_at = ? WHERE namespace = ? AND key = ?`,
+        )
+        .run(now, this.namespace, key)
 
       return row.data
     }
@@ -130,25 +231,30 @@ export class Cache {
 
   has(key: string): boolean {
     const row = this.db
-      .prepare(`SELECT 1 FROM ${this.tableName} WHERE key = ?`)
-      .get(key)
+      .prepare(`SELECT 1 FROM ${CACHE_TABLE_NAME} WHERE namespace = ? AND key = ?`)
+      .get(this.namespace, key)
     return !!row
   }
 
   get isEmpty(): boolean {
     const row = this.db
-      .prepare(`SELECT COUNT(*) as count FROM ${this.tableName}`)
-      .get() as { count: number }
+      .prepare(
+        `SELECT COUNT(*) as count FROM ${CACHE_TABLE_NAME} WHERE namespace = ?`,
+      )
+      .get(this.namespace) as { count: number }
     return row.count === 0
   }
 
   set(key: string, data: string): void {
+    const now = nextTimestamp()
     const dataSize = Buffer.byteLength(data, 'utf8')
 
     // Get existing size if any
     const existingRow = this.db
-      .prepare(`SELECT size FROM ${this.tableName} WHERE key = ?`)
-      .get(key) as { size: number } | undefined
+      .prepare(
+        `SELECT size FROM ${CACHE_TABLE_NAME} WHERE namespace = ? AND key = ?`,
+      )
+      .get(this.namespace, key) as { size: number } | undefined
     const oldSize = existingRow?.size || 0
     const newTotalSize = this.currentSize - oldSize + dataSize
 
@@ -159,9 +265,16 @@ export class Cache {
     // Insert or update the cache entry
     this.db
       .prepare(
-        `INSERT OR REPLACE INTO ${this.tableName} (key, data, size) VALUES (?, ?, ?)`,
+        `INSERT INTO ${CACHE_TABLE_NAME} (namespace, key, data, size, last_accessed_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?)
+         ON CONFLICT(namespace, key)
+         DO UPDATE SET
+           data = excluded.data,
+           size = excluded.size,
+           last_accessed_at = excluded.last_accessed_at,
+           updated_at = excluded.updated_at`,
       )
-      .run(key, data, dataSize)
+      .run(this.namespace, key, data, dataSize, now, now)
 
     this.currentSize = this.currentSize - oldSize + dataSize
     this.notifySubscribers(key, data)
@@ -170,12 +283,16 @@ export class Cache {
   remove(key: string): boolean {
     // Check if key exists and get its size
     const row = this.db
-      .prepare(`SELECT size FROM ${this.tableName} WHERE key = ?`)
-      .get(key) as { size: number } | undefined
+      .prepare(
+        `SELECT size FROM ${CACHE_TABLE_NAME} WHERE namespace = ? AND key = ?`,
+      )
+      .get(this.namespace, key) as { size: number } | undefined
 
     if (row) {
       // Delete the key
-      this.db.prepare(`DELETE FROM ${this.tableName} WHERE key = ?`).run(key)
+      this.db
+        .prepare(`DELETE FROM ${CACHE_TABLE_NAME} WHERE namespace = ? AND key = ?`)
+        .run(this.namespace, key)
 
       this.currentSize -= row.size
       this.notifySubscribers(key, undefined)
@@ -186,7 +303,9 @@ export class Cache {
   }
 
   clear(options?: { notifySubscribers: boolean }): void {
-    this.db.exec(`DELETE FROM ${this.tableName}`)
+    this.db
+      .prepare(`DELETE FROM ${CACHE_TABLE_NAME} WHERE namespace = ?`)
+      .run(this.namespace)
     this.currentSize = 0
 
     if (options?.notifySubscribers !== false) {
@@ -205,10 +324,14 @@ export class Cache {
   }
 
   private maintainCapacity(bytesToFree: number): void {
-    // Order by rowid ASC to get oldest entries first
+    // Order by oldest last-access time first to evict least-recently-used rows.
     const rows = this.db
-      .prepare(`SELECT key, size FROM ${this.tableName} ORDER BY rowid ASC`)
-      .all() as Array<{ key: string; size: number }>
+      .prepare(
+        `SELECT key, size FROM ${CACHE_TABLE_NAME}
+         WHERE namespace = ?
+         ORDER BY last_accessed_at ASC`,
+      )
+      .all(this.namespace) as Array<{ key: string; size: number }>
 
     let freedBytes = 0
     const keysToRemove: string[] = []
@@ -224,9 +347,10 @@ export class Cache {
     if (keysToRemove.length > 0) {
       const placeholders = keysToRemove.map(() => '?').join(',')
       const stmt = this.db.prepare(
-        `DELETE FROM ${this.tableName} WHERE key IN (${placeholders})`,
+        `DELETE FROM ${CACHE_TABLE_NAME}
+         WHERE namespace = ? AND key IN (${placeholders})`,
       )
-      stmt.run(...(keysToRemove as [string, ...string[]]))
+      stmt.run(this.namespace, ...(keysToRemove as [string, ...string[]]))
       this.currentSize -= freedBytes
     }
   }
@@ -324,7 +448,8 @@ export function withCache<Fn extends (...args: any[]) => Promise<any>>(
   const validate = options?.validate || (() => true)
 
   if (!functionCacheMap.has(fnKey)) {
-    functionCacheMap.set(fnKey, new Cache({ namespace: `fn-${Date.now()}` }))
+    const functionNamespace = `fn-${hashString(fnKey)}`
+    functionCacheMap.set(fnKey, new Cache({ namespace: functionNamespace }))
     functionCacheData.set(fnKey, new Map())
   }
 

package/src/apis/clipboard.tsx

@@ -12,6 +12,11 @@ const platform = process.platform
 async function copyFileToClipboard(filePath: string): Promise<void> {
   const absolutePath = path.resolve(filePath)
 
+  if (process.env.VITEST) {
+    logger.log(`📋 [VITEST] Skipping copy file to clipboard: ${filePath}`)
+    return
+  }
+
   if (!fs.existsSync(absolutePath)) {
     throw new Error(`File not found: ${absolutePath}`)
   }

package/src/apis/oauth.tsx

@@ -444,11 +444,16 @@ export namespace OAuth {
                   <h1 id="status">Processing...</h1>
                   <div id="message"></div>
                   <script>
-                    // Extract tokens from URL fragment
+                    // Extract tokens from URL fragment (implicit flow) or query params (auth code flow)
                     const hash = window.location.hash.substring(1);
-                    const params = new URLSearchParams(hash);
+                    const hashParams = new URLSearchParams(hash);
+                    const queryParams = new URLSearchParams(window.location.search);
+                    
+                    // Use query params if we have a code (auth code flow), otherwise use hash (implicit flow)
+                    const params = queryParams.get('code') ? queryParams : hashParams;
 
                     const data = {
+                      code: params.get('code'),
                       access_token: params.get('access_token'),
                       id_token: params.get('id_token'),
                       expires_in: params.get('expires_in'),
@@ -458,6 +463,8 @@ export namespace OAuth {
                       error: params.get('error'),
                       error_description: params.get('error_description')
                     };
+                    
+                    console.log('OAuth callback data:', data);
 
                     // Send tokens back to our server
                     fetch('/oauth/implicit-callback', {
@@ -499,6 +506,14 @@ export namespace OAuth {
             req.on('end', () => {
               try {
                 const data = JSON.parse(body)
+                
+                logger.log('OAuth callback received data:', {
+                  hasCode: !!data.code,
+                  hasAccessToken: !!data.access_token,
+                  receivedState: data.state,
+                  expectedState: expectedState,
+                  error: data.error,
+                })
 
                 if (data.error) {
                   res.writeHead(400, {
@@ -516,6 +531,10 @@ export namespace OAuth {
 
                 // Validate state
                 if (data.state !== expectedState) {
+                  logger.error('OAuth state mismatch:', {
+                    received: data.state,
+                    expected: expectedState,
+                  })
                   res.writeHead(400, {
                     'Content-Type': 'application/json',
                   })
@@ -546,6 +565,17 @@ export namespace OAuth {
                   scope: data.scope,
                 }
 
+                // For authorization code flow, return the code for token exchange
+                if (data.code) {
+                  logger.log('Authorization code flow - returning code for token exchange')
+                  resolve({
+                    authorizationCode: data.code,
+                    state: data.state,
+                  })
+                  return
+                }
+
+                // For implicit flow, tokens come directly
                 // Store tokens in memory for later retrieval
                 this.implicitFlowTokens = tokens
 
@@ -554,9 +584,8 @@ export namespace OAuth {
                   .then(() => {
                     logger.log('Implicit flow tokens saved directly')
 
-                    // Return the tokens (authorizationCode is a dummy value for compatibility)
                     resolve({
-                      authorizationCode: 'implicit_flow_dummy_code', // Dummy code for compatibility
+                      authorizationCode: 'implicit_flow_complete',
                       accessToken: data.access_token,
                       idToken: data.id_token,
                       state: data.state,

package/src/build.tsx

@@ -1,8 +1,6 @@
 import fs from 'node:fs'
 import path from 'node:path'
-import { execSync } from 'node:child_process'
 import type { BunPlugin } from 'bun'
-import * as swc from '@swc/core'
 import { logger } from './logger'
 import { getCommandsWithFiles, CommandWithFile } from './package-json'
 import * as termcastApi from './index'
@@ -43,13 +41,23 @@ export const aliasPlugin: BunPlugin = {
 
     // Alias @raycast/api to termcast using namespace
     build.onResolve({ filter: /@raycast\/api/ }, () => {
-      logger.log('Resolving @raycast/api to termcast')
+      // logger.log('Resolving @raycast/api to termcast')
       return {
         path: 'termcast',
         namespace: GLOBALS_NAMESPACE,
       }
     })
 
+    // Alias @raycast/utils to our fork with termcast OAuth proxy URLs
+    build.onResolve({ filter: /@raycast\/utils/ }, () => {
+      // logger.log('Resolving @raycast/utils to termcast fork')
+      return {
+        path: require.resolve('@termcast/utils'),
+
+        // external: true,
+      }
+    })
+
     // Resolve external packages to globals namespace
     build.onResolve({ filter: /^termcast/ }, (args) => {
       return {
@@ -180,62 +188,19 @@ export const aliasPlugin: BunPlugin = {
   },
 }
 
-// React Refresh transform plugin for hot reloading using SWC (Rust-based, ~20x faster than Babel)
-// Transforms extension source files to inject $RefreshReg$ and $RefreshSig$ calls
-export const reactRefreshPlugin: BunPlugin = {
-  name: 'react-refresh-transform',
-  async setup(build) {
-    build.onLoad({ filter: /\.[tj]sx?$/ }, async (args) => {
-      // Skip node_modules
-      if (args.path.includes('node_modules')) {
-        return undefined
-      }
-
-      const code = await Bun.file(args.path).text()
-
-      const isTypeScript =
-        args.path.endsWith('.ts') || args.path.endsWith('.tsx')
-      const hasJsx = args.path.endsWith('.tsx') || args.path.endsWith('.jsx')
-
-      const result = await swc.transform(code, {
-        filename: args.path,
-        jsc: {
-          parser: isTypeScript
-            ? {
-                syntax: 'typescript',
-                tsx: hasJsx,
-              }
-            : {
-                syntax: 'ecmascript',
-                jsx: hasJsx,
-              },
-          transform: {
-            react: {
-              development: true,
-              refresh: true, // Built-in React Refresh support in SWC
-              runtime: 'automatic',
-            },
-          },
-        },
-        sourceMaps: 'inline',
-      })
-
-      if (!result?.code) {
-        return undefined
-      }
 
-      return {
-        contents: result.code,
-        loader: 'js', // SWC transforms JSX to JS
-      }
-    })
-  },
-}
 
 interface BundledCommand extends CommandWithFile {
   bundledPath: string
 }
 
+function sanitizeHotReloadBundle({ code }: { code: string }): string {
+  // Bun reactFastRefresh can emit invalid self-redeclarations like:
+  // `var Component = Component;`
+  // which throws in ESM during import. Strip those lines in hot-reload bundles.
+  return code.replace(/^var\s+([A-Za-z_$][\w$]*)\s*=\s*\1;\s*$/gm, '')
+}
+
 export interface BuildResult {
   commands: BundledCommand[]
   bundleDir: string
@@ -276,20 +241,17 @@ export async function buildExtensionCommands({
 
   logger.log(`Building ${entrypoints.length} commands...`)
 
-  const plugins = [aliasPlugin, swiftLoaderPlugin]
-  if (hotReload) {
-    plugins.push(reactRefreshPlugin)
-  }
+  const plugins: BunPlugin[] = [aliasPlugin, swiftLoaderPlugin]
 
   const result = await Bun.build({
     entrypoints,
     outdir: bundleDir,
     target: target || (format === 'cjs' ? 'node' : 'bun'),
     format,
-    // external: [],
     plugins,
     naming: '[name].js',
     throw: false,
+    reactFastRefresh: hotReload,
   })
 
   if (!result.success) {
@@ -299,6 +261,21 @@ export async function buildExtensionCommands({
     throw new Error(`Build failed: ${errorMessage}`)
   }
 
+  if (hotReload) {
+    for (const output of result.outputs) {
+      const outputPath = output.path
+      if (!outputPath.endsWith('.js')) {
+        continue
+      }
+      const code = fs.readFileSync(outputPath, 'utf-8')
+      const sanitizedCode = sanitizeHotReloadBundle({ code })
+      if (sanitizedCode === code) {
+        continue
+      }
+      fs.writeFileSync(outputPath, sanitizedCode)
+    }
+  }
+
   // Map outputs back to commands
   const bundledCommands: BundledCommand[] = commandsData.commands.map(
     (command) => {