@talex-touch/utils 1.0.40 → 1.0.42

package/plugin/providers/tpex-provider.ts

@@ -0,0 +1,283 @@
+import type { IManifest } from '..'
+import type {
+  PluginInstallRequest,
+  PluginInstallResult,
+  PluginProvider,
+  PluginProviderContext,
+} from './types'
+import { PluginProviderType } from './types'
+
+const DEFAULT_TPEX_API = 'https://tuff.tagzxia.com'
+
+/**
+ * Check if source is a .tpex file path or URL
+ */
+function isTpexFile(source: string): boolean {
+  return source.trim().toLowerCase().endsWith('.tpex')
+}
+
+/**
+ * Check if source is a remote URL
+ */
+function isRemoteUrl(source: string): boolean {
+  return /^https?:\/\//i.test(source)
+}
+
+export interface TpexPluginInfo {
+  id: string
+  slug: string
+  name: string
+  summary: string
+  category: string
+  installs: number
+  homepage?: string | null
+  isOfficial: boolean
+  badges: string[]
+  author?: { name: string, avatarColor?: string } | null
+  iconUrl?: string | null
+  latestVersion?: {
+    id: string
+    version: string
+    channel: string
+    packageUrl: string
+    packageSize: number
+    manifest?: Record<string, unknown> | null
+    changelog?: string | null
+  }
+}
+
+export interface TpexListResponse {
+  plugins: TpexPluginInfo[]
+  total: number
+}
+
+export interface TpexDetailResponse {
+  plugin: TpexPluginInfo & {
+    versions?: Array<{
+      id: string
+      version: string
+      channel: string
+      packageUrl: string
+      packageSize: number
+      manifest?: Record<string, unknown> | null
+      changelog?: string | null
+    }>
+  }
+}
+
+/**
+ * Parse TPEX source string to extract slug and optional version
+ * Formats: "tpex:slug", "tpex:slug@version", "slug" (when hintType is TPEX)
+ */
+function parseTpexSource(source: string): { slug: string, version?: string } | null {
+  const tpexMatch = source.match(/^tpex:([a-z0-9][a-z0-9\-_.]{1,62}[a-z0-9])(?:@(.+))?$/i)
+  if (tpexMatch) {
+    return { slug: tpexMatch[1], version: tpexMatch[2] }
+  }
+
+  const slugMatch = source.match(/^([a-z0-9][a-z0-9\-_.]{1,62}[a-z0-9])(?:@(.+))?$/i)
+  if (slugMatch) {
+    return { slug: slugMatch[1], version: slugMatch[2] }
+  }
+
+  return null
+}
+
+export class TpexProvider implements PluginProvider {
+  readonly type = PluginProviderType.TPEX
+  private apiBase: string
+
+  constructor(apiBase: string = DEFAULT_TPEX_API) {
+    this.apiBase = apiBase.replace(/\/$/, '')
+  }
+
+  canHandle(request: PluginInstallRequest): boolean {
+    // Handle .tpex file paths (local or remote URL)
+    if (isTpexFile(request.source)) {
+      return true
+    }
+
+    if (request.hintType === PluginProviderType.TPEX) {
+      return parseTpexSource(request.source) !== null
+    }
+    return request.source.startsWith('tpex:')
+  }
+
+  async install(
+    request: PluginInstallRequest,
+    context?: PluginProviderContext,
+  ): Promise<PluginInstallResult> {
+    // Handle .tpex file directly (local path or remote URL)
+    if (isTpexFile(request.source)) {
+      return this.installFromFile(request, context)
+    }
+
+    // Handle tpex:slug format - fetch from API
+    return this.installFromRegistry(request, context)
+  }
+
+  /**
+   * Install from a .tpex file (local path or remote URL)
+   */
+  private async installFromFile(
+    request: PluginInstallRequest,
+    context?: PluginProviderContext,
+  ): Promise<PluginInstallResult> {
+    let filePath = request.source
+    let arrayBuffer: ArrayBuffer | undefined
+
+    if (isRemoteUrl(request.source)) {
+      // Download remote .tpex file
+      const downloadRes = await fetch(request.source)
+      if (!downloadRes.ok) {
+        throw new Error(`Failed to download TPEX file: ${downloadRes.statusText}`)
+      }
+
+      arrayBuffer = await downloadRes.arrayBuffer()
+      const tempDir = context?.tempDir ?? '/tmp'
+      const fileName = `tpex-${Date.now()}.tpex`
+      filePath = `${tempDir}/${fileName}`
+
+      if (typeof globalThis.process !== 'undefined') {
+        const fs = await import('node:fs/promises')
+        await fs.writeFile(filePath, Buffer.from(arrayBuffer))
+      }
+    }
+
+    // For local files, just return the path - manifest extraction happens in core-app
+    return {
+      provider: PluginProviderType.TPEX,
+      filePath,
+      official: false,
+      metadata: {
+        sourceType: 'file',
+        originalSource: request.source,
+      },
+    }
+  }
+
+  /**
+   * Install from TPEX registry (tpex:slug format)
+   */
+  private async installFromRegistry(
+    request: PluginInstallRequest,
+    context?: PluginProviderContext,
+  ): Promise<PluginInstallResult> {
+    const parsed = parseTpexSource(request.source)
+    if (!parsed) {
+      throw new Error(`Invalid TPEX source format: ${request.source}`)
+    }
+
+    const { slug, version } = parsed
+
+    const detailRes = await fetch(`${this.apiBase}/api/market/plugins/${slug}`)
+    if (!detailRes.ok) {
+      if (detailRes.status === 404) {
+        throw new Error(`Plugin not found: ${slug}`)
+      }
+      throw new Error(`Failed to fetch plugin details: ${detailRes.statusText}`)
+    }
+
+    const detail: TpexDetailResponse = await detailRes.json()
+    const plugin = detail.plugin
+
+    let targetVersion = plugin.latestVersion
+    if (version && plugin.versions) {
+      targetVersion = plugin.versions.find(v => v.version === version) ?? targetVersion
+    }
+
+    if (!targetVersion?.packageUrl) {
+      throw new Error(`No downloadable version found for plugin: ${slug}`)
+    }
+
+    const downloadUrl = targetVersion.packageUrl.startsWith('http')
+      ? targetVersion.packageUrl
+      : `${this.apiBase}${targetVersion.packageUrl}`
+
+    const downloadRes = await fetch(downloadUrl)
+    if (!downloadRes.ok) {
+      throw new Error(`Failed to download plugin package: ${downloadRes.statusText}`)
+    }
+
+    const arrayBuffer = await downloadRes.arrayBuffer()
+    const tempDir = context?.tempDir ?? '/tmp'
+    const fileName = `${slug}-${targetVersion.version}.tpex`
+    const filePath = `${tempDir}/${fileName}`
+
+    if (typeof globalThis.process !== 'undefined') {
+      const fs = await import('node:fs/promises')
+      await fs.writeFile(filePath, Buffer.from(arrayBuffer))
+    }
+
+    const manifest: IManifest | undefined = targetVersion.manifest
+      ? {
+          id: plugin.slug,
+          name: plugin.name,
+          version: targetVersion.version,
+          description: plugin.summary,
+          author: plugin.author?.name ?? 'Unknown',
+          main: (targetVersion.manifest as Record<string, unknown>).main as string ?? 'index.js',
+          icon: plugin.iconUrl ?? undefined,
+          ...targetVersion.manifest,
+        }
+      : undefined
+
+    return {
+      provider: PluginProviderType.TPEX,
+      filePath,
+      official: plugin.isOfficial,
+      manifest,
+      metadata: {
+        sourceType: 'registry',
+        slug: plugin.slug,
+        version: targetVersion.version,
+        channel: targetVersion.channel,
+        packageSize: targetVersion.packageSize,
+        installs: plugin.installs,
+      },
+    }
+  }
+
+  /**
+   * List all available plugins from TPEX registry
+   */
+  async listPlugins(): Promise<TpexPluginInfo[]> {
+    const res = await fetch(`${this.apiBase}/api/market/plugins`)
+    if (!res.ok) {
+      throw new Error(`Failed to fetch plugin list: ${res.statusText}`)
+    }
+
+    const data: TpexListResponse = await res.json()
+    return data.plugins
+  }
+
+  /**
+   * Get plugin details by slug
+   */
+  async getPlugin(slug: string): Promise<TpexDetailResponse['plugin'] | null> {
+    const res = await fetch(`${this.apiBase}/api/market/plugins/${slug}`)
+    if (!res.ok) {
+      if (res.status === 404) return null
+      throw new Error(`Failed to fetch plugin: ${res.statusText}`)
+    }
+
+    const data: TpexDetailResponse = await res.json()
+    return data.plugin
+  }
+
+  /**
+   * Search plugins by keyword
+   */
+  async searchPlugins(keyword: string): Promise<TpexPluginInfo[]> {
+    const plugins = await this.listPlugins()
+    const lowerKeyword = keyword.toLowerCase()
+
+    return plugins.filter(plugin =>
+      plugin.name.toLowerCase().includes(lowerKeyword)
+      || plugin.slug.toLowerCase().includes(lowerKeyword)
+      || plugin.summary.toLowerCase().includes(lowerKeyword),
+    )
+  }
+}
+
+export const tpexProvider = new TpexProvider()

package/plugin/providers/tpex-types.ts

@@ -0,0 +1,34 @@
+/**
+ * Metadata extracted from a .tpex package file
+ */
+export interface TpexMetadata {
+  readmeMarkdown?: string | null
+  manifest?: Record<string, unknown> | null
+}
+
+/**
+ * Result of package preview operation
+ */
+export interface TpexPackagePreviewResult {
+  manifest: Record<string, unknown> | null
+  readmeMarkdown: string | null
+}
+
+/**
+ * Extracted manifest fields from tpex package
+ */
+export interface TpexExtractedManifest {
+  id?: string
+  name?: string
+  description?: string
+  version?: string
+  homepage?: string
+  changelog?: string
+  channel?: string
+  category?: string
+  icon?: {
+    type?: string
+    value?: string
+  }
+  [key: string]: unknown
+}

package/plugin/sdk/hooks/bridge.ts

@@ -3,11 +3,23 @@ import { ensureRendererChannel } from '../channel'
 
 export type BridgeEvent = BridgeEventForCoreBox
 
-/**
- * Defines the shape of a bridge hook function.
- * @template T The type of data the hook will receive.
- */
-export type BridgeHook<T = any> = (data: T) => void
+export interface BridgeEventMeta {
+  timestamp: number
+  fromCache: boolean
+}
+
+export interface BridgeEventPayload<T = any> {
+  data: T
+  meta: BridgeEventMeta
+}
+
+/** @template T The type of data the hook will receive. */
+export type BridgeHook<T = any> = (payload: BridgeEventPayload<T>) => void
+
+interface CachedEvent<T = any> {
+  data: T
+  timestamp: number
+}
 
 const __hooks: Record<BridgeEvent, Array<BridgeHook>> = {
   [BridgeEventForCoreBox.CORE_BOX_INPUT_CHANGE]: [],
@@ -15,42 +27,85 @@ const __hooks: Record<BridgeEvent, Array<BridgeHook>> = {
   [BridgeEventForCoreBox.CORE_BOX_KEY_EVENT]: [],
 }
 
-/**
- * Injects a hook for a given bridge event.
- * @param type The bridge event type.
- * @param hook The hook function to inject.
- * @returns The wrapped hook function.
- * @internal
- * @template T The type of data the hook will receive.
- */
-export function injectBridgeEvent<T>(type: BridgeEvent, hook: BridgeHook<T>) {
-  const hooks: Array<BridgeHook<T>> = __hooks[type] || (__hooks[type] = [])
+const __eventCache: Map<BridgeEvent, CachedEvent[]> = new Map()
+const __channelRegistered = new Set<BridgeEvent>()
 
-  // Only register the channel listener once per event type
-  if (hooks.length === 0) {
-    const channel = ensureRendererChannel('[TouchSDK] Bridge channel not available. Make sure hooks run in plugin renderer context.')
+const CACHE_MAX_SIZE: Record<BridgeEvent, number> = {
+  [BridgeEventForCoreBox.CORE_BOX_INPUT_CHANGE]: 1,
+  [BridgeEventForCoreBox.CORE_BOX_CLIPBOARD_CHANGE]: 1,
+  [BridgeEventForCoreBox.CORE_BOX_KEY_EVENT]: 10,
+}
+
+function invokeHook<T>(hook: BridgeHook<T>, data: T, fromCache: boolean, timestamp: number): void {
+  try {
+    hook({ data, meta: { timestamp, fromCache } })
+  }
+  catch (e) {
+    console.error('[TouchSDK] Bridge hook error:', e)
+  }
+}
+
+function registerEarlyListener(type: BridgeEvent): void {
+  if (__channelRegistered.has(type)) return
+
+  try {
+    const channel = ensureRendererChannel()
     channel.regChannel(type, ({ data }) => {
-      console.debug(`[TouchSDK] ${type} event received: `, data)
-      // When the event is received, call all registered hooks for this type
-      const registeredHooks = __hooks[type]
-      if (registeredHooks) {
-        registeredHooks.forEach(h => h(data))
+      const timestamp = Date.now()
+      const hooks = __hooks[type]
+
+      if (hooks && hooks.length > 0) {
+        hooks.forEach(h => invokeHook(h, data, false, timestamp))
+      }
+      else {
+        if (!__eventCache.has(type)) __eventCache.set(type, [])
+        const cache = __eventCache.get(type)!
+        const maxSize = CACHE_MAX_SIZE[type] ?? 1
+        cache.push({ data, timestamp })
+        while (cache.length > maxSize) cache.shift()
+        console.debug(`[TouchSDK] ${type} cached, size: ${cache.length}`)
       }
     })
+    __channelRegistered.add(type)
+  }
+  catch {
+    // Channel not ready yet
   }
+}
 
-  const wrappedHook = (data: T) => {
-    try {
-      hook(data)
-    }
-    catch (e) {
-      console.error(`[TouchSDK] ${type} hook error: `, e)
-    }
+/** Clears the event cache for a specific event type or all types. */
+export function clearBridgeEventCache(type?: BridgeEvent): void {
+  if (type) {
+    __eventCache.delete(type)
   }
+  else {
+    __eventCache.clear()
+  }
+}
+
+// Auto-init on module load
+;(function initBridgeEventCache() {
+  setTimeout(() => {
+    Object.values(BridgeEventForCoreBox).forEach(e => registerEarlyListener(e as BridgeEvent))
+  }, 0)
+})()
 
-  hooks.push(wrappedHook)
+/** @internal Injects a hook for a given bridge event with cache replay. */
+export function injectBridgeEvent<T>(type: BridgeEvent, hook: BridgeHook<T>) {
+  const hooks: Array<BridgeHook<T>> = __hooks[type] || (__hooks[type] = [])
+
+  // Ensure channel listener is registered
+  registerEarlyListener(type)
 
-  return wrappedHook
+  // Replay cached events to this new hook
+  const cached = __eventCache.get(type)
+  if (cached && cached.length > 0) {
+    cached.forEach(({ data, timestamp }) => invokeHook(hook, data as T, true, timestamp))
+    __eventCache.delete(type)
+  }
+
+  hooks.push(hook)
+  return hook
 }
 
 /**
@@ -61,22 +116,11 @@ export function injectBridgeEvent<T>(type: BridgeEvent, hook: BridgeHook<T>) {
  */
 export const createBridgeHook = <T>(type: BridgeEvent) => (hook: BridgeHook<T>) => injectBridgeEvent<T>(type, hook)
 
-/**
- * Hook for when the core box input changes.
- * The hook receives the new input value as a string.
- * @param data The input change data (string).
- */
-export const onCoreBoxInputChange = createBridgeHook<{ query: { inputs: Array<any>, text: string } }>(BridgeEventForCoreBox.CORE_BOX_INPUT_CHANGE)
-
-export const onCoreBoxClipboardChange = createBridgeHook<{ item: any }>(BridgeEventForCoreBox.CORE_BOX_CLIPBOARD_CHANGE)
+export interface CoreBoxInputData {
+  query: { inputs: Array<any>, text: string }
+}
 
-/**
- * Hook for when a keyboard event is forwarded from CoreBox.
- * This is triggered when the plugin's UI view is attached and the user
- * presses certain keys (Enter, Arrow keys, Meta+key combinations).
- * @param data The forwarded keyboard event data.
- */
-export const onCoreBoxKeyEvent = createBridgeHook<{
+export interface CoreBoxKeyEventData {
   key: string
   code: string
   metaKey: boolean
@@ -84,4 +128,17 @@ export const onCoreBoxKeyEvent = createBridgeHook<{
   altKey: boolean
   shiftKey: boolean
   repeat: boolean
-}>(BridgeEventForCoreBox.CORE_BOX_KEY_EVENT)
+}
+
+export interface CoreBoxClipboardData {
+  item: any
+}
+
+/** Hook for CoreBox input changes. Payload includes `data` and `meta` (timestamp, fromCache). */
+export const onCoreBoxInputChange = createBridgeHook<CoreBoxInputData>(BridgeEventForCoreBox.CORE_BOX_INPUT_CHANGE)
+
+/** Hook for CoreBox clipboard changes. Payload includes `data` and `meta` (timestamp, fromCache). */
+export const onCoreBoxClipboardChange = createBridgeHook<CoreBoxClipboardData>(BridgeEventForCoreBox.CORE_BOX_CLIPBOARD_CHANGE)
+
+/** Hook for keyboard events forwarded from CoreBox. Payload includes `data` and `meta` (timestamp, fromCache). */
+export const onCoreBoxKeyEvent = createBridgeHook<CoreBoxKeyEventData>(BridgeEventForCoreBox.CORE_BOX_KEY_EVENT)

package/plugin/sdk/performance.ts

@@ -5,24 +5,9 @@
  * and storage statistics.
  */
 import type { ITouchClientChannel } from '@talex-touch/utils/channel'
+import type { StorageStats } from '../../types/storage'
 import { ensureRendererChannel } from './channel'
 
-/**
- * Storage statistics interface
- */
-export interface StorageStats {
-  /** Total size in bytes */
-  totalSize: number
-  /** Number of files */
-  fileCount: number
-  /** Number of directories */
-  dirCount: number
-  /** Maximum allowed size in bytes */
-  maxSize: number
-  /** Usage percentage (0-100) */
-  usagePercent: number
-}
-
 /**
  * Performance metrics interface
  */

package/renderer/hooks/arg-mapper.ts

@@ -5,6 +5,8 @@
 export interface IArgMapperOptions {
   /** The type of touch window - either main window or core-box popup */
   touchType?: 'main' | 'core-box'
+  /** The sub-type for core-box windows (e.g., division-box) */
+  coreType?: 'division-box'
   /** User data directory path */
   userDataDir?: string
   /** Application path */
@@ -32,22 +34,17 @@ declare global {
  * @returns Mapped command line arguments as key-value pairs
  */
 export function useArgMapper(args: string[] = process.argv): IArgMapperOptions {
-  if (window.$argMapper) {
-    return window.$argMapper
-  }
+  if (window.$argMapper) return window.$argMapper
 
   const mapper: IArgMapperOptions = {}
-
   for (const arg of args) {
     if (arg.startsWith('--') && arg.includes('=')) {
       const [key, ...valueParts] = arg.slice(2).split('=')
       const value = valueParts.join('=')
-
       const camelCaseKey = key.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase())
       mapper[camelCaseKey] = value
     }
   }
-
   return window.$argMapper = mapper
 }
 
@@ -76,3 +73,20 @@ export function isMainWindow() {
 export function isCoreBox() {
   return useTouchType() === 'core-box'
 }
+
+/**
+ * Gets the core-box sub-type from command line arguments
+ * @returns The core type ('division-box') or undefined
+ */
+export function useCoreType() {
+  const argMapper = useArgMapper()
+  return argMapper.coreType
+}
+
+/**
+ * Checks if the current window is a division-box window
+ * @returns True if the current window is a division-box
+ */
+export function isDivisionBox() {
+  return isCoreBox() && useCoreType() === 'division-box'
+}