@talex-touch/utils 1.0.40 → 1.0.42

package/core-box/tuff/tuff-dsl.ts

@@ -803,6 +803,65 @@ export interface TuffContext {
   tags?: string[]
 }
 
+// ==================== Footer Hints 配置 ====================
+
+/**
+ * Footer hint 单项配置
+ */
+export interface TuffFooterHintItem {
+  /** 快捷键显示文本 */
+  key: string
+  /** 提示标签 */
+  label: string
+  /** 是否显示此提示 */
+  visible?: boolean
+  /** 触发的事件名称 */
+  event?: string
+  /** 事件携带的数据 */
+  eventData?: Record<string, unknown>
+}
+
+/**
+ * Footer hints 配置
+ * @description 控制 CoreBox 底部快捷键提示的显示和行为
+ */
+export interface TuffFooterHints {
+  /**
+   * 主操作提示（回车键）
+   * @description 自定义回车键的文案，如 "发送"、"执行"、"打开" 等
+   */
+  primary?: {
+    /** 自定义标签文案 */
+    label?: string
+    /** 是否显示 */
+    visible?: boolean
+  }
+
+  /**
+   * 辅助操作提示（Meta+K）
+   * @description 控制 Meta+K 快捷键的显示和行为
+   */
+  secondary?: {
+    /** 自定义标签文案 */
+    label?: string
+    /** 是否显示，默认 false（隐藏） */
+    visible?: boolean
+    /** 触发的事件名称 */
+    event?: string
+    /** 事件携带的数据 */
+    eventData?: Record<string, unknown>
+  }
+
+  /**
+   * 快速选择提示（Meta+1-0）
+   * @description 控制快速选择快捷键的显示
+   */
+  quickSelect?: {
+    /** 是否显示，默认根据场景自动判断 */
+    visible?: boolean
+  }
+}
+
 // ==================== 扩展元数据 ====================
 
 /**
@@ -1030,6 +1089,12 @@ export interface TuffMeta {
    * @warning 不建议添加太多关键词（建议 <= 10），过多会影响搜索性能
    */
   keywords?: string[]
+
+  /**
+   * Footer hints 配置
+   * @description 控制 CoreBox 底部快捷键提示的显示和行为
+   */
+  footerHints?: TuffFooterHints
 }
 
 // ==================== 前端展示结构 ====================

package/intelligence/client.ts

@@ -1,4 +1,4 @@
-import type { AiInvokeOptions, AiInvokeResult, AiProviderConfig } from '../types/intelligence'
+import type { IntelligenceInvokeOptions, IntelligenceInvokeResult, IntelligenceProviderConfig } from '../types/intelligence'
 
 export interface IntelligenceClientChannel {
   send: (eventName: string, payload: unknown) => Promise<any>
@@ -50,10 +50,10 @@ async function assertResponse<T>(promise: Promise<ChannelResponse<T>>): Promise<
 }
 
 export interface IntelligenceClient {
-  invoke: <T = any>(capabilityId: string, payload: any, options?: AiInvokeOptions) => Promise<AiInvokeResult<T>>
-  testProvider: (config: AiProviderConfig) => Promise<unknown>
+  invoke: <T = any>(capabilityId: string, payload: any, options?: IntelligenceInvokeOptions) => Promise<IntelligenceInvokeResult<T>>
+  testProvider: (config: IntelligenceProviderConfig) => Promise<unknown>
   testCapability: (params: Record<string, any>) => Promise<unknown>
-  fetchModels: (config: AiProviderConfig) => Promise<{ success: boolean, models?: string[], message?: string }>
+  fetchModels: (config: IntelligenceProviderConfig) => Promise<{ success: boolean, models?: string[], message?: string }>
 }
 
 export function createIntelligenceClient(channel?: IntelligenceClientChannel, resolvers?: IntelligenceChannelResolver[]): IntelligenceClient {
@@ -63,12 +63,12 @@ export function createIntelligenceClient(channel?: IntelligenceClientChannel, re
   }
 
   return {
-    invoke<T = any>(capabilityId: string, payload: any, options?: AiInvokeOptions) {
-      return assertResponse<AiInvokeResult<T>>(
+    invoke<T = any>(capabilityId: string, payload: any, options?: IntelligenceInvokeOptions) {
+      return assertResponse<IntelligenceInvokeResult<T>>(
         resolvedChannel.send('intelligence:invoke', { capabilityId, payload, options }),
       )
     },
-    testProvider(config: AiProviderConfig) {
+    testProvider(config: IntelligenceProviderConfig) {
       return assertResponse(
         resolvedChannel.send('intelligence:test-provider', { provider: config }),
       )
@@ -78,7 +78,7 @@ export function createIntelligenceClient(channel?: IntelligenceClientChannel, re
         resolvedChannel.send('intelligence:test-capability', params),
       )
     },
-    fetchModels(config: AiProviderConfig) {
+    fetchModels(config: IntelligenceProviderConfig) {
       return assertResponse<{ success: boolean, models?: string[], message?: string }>(
         resolvedChannel.send('intelligence:fetch-models', { provider: config }),
       )

package/market/constants.ts

@@ -21,6 +21,20 @@ function defineProvider(
 }
 
 export const DEFAULT_MARKET_PROVIDERS: MarketProviderDefinition[] = [
+  defineProvider({
+    id: 'tuff-nexus',
+    name: 'Tuff Nexus',
+    type: 'tpexApi',
+    url: 'https://tuff.tagzxia.com',
+    description: 'Tuff 官方插件市场，提供经过审核的插件。',
+    enabled: true,
+    priority: 110,
+    trustLevel: 'official',
+    readOnly: true,
+    config: {
+      apiUrl: 'https://tuff.tagzxia.com/api/market/plugins',
+    },
+  }),
   defineProvider({
     id: 'talex-official',
     name: 'Talex Official',

package/market/types.ts

@@ -1,6 +1,6 @@
 import type { StorageList } from '../common/storage/constants'
 
-export type MarketProviderType = 'repository' | 'nexusStore' | 'npmPackage'
+export type MarketProviderType = 'repository' | 'nexusStore' | 'npmPackage' | 'tpexApi'
 
 export type MarketProviderTrustLevel = 'official' | 'verified' | 'unverified'
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@talex-touch/utils",
-  "version": "1.0.40",
+  "version": "1.0.42",
   "private": false,
   "description": "Tuff series utils",
   "author": "TalexDreamSoul",

package/plugin/index.ts

@@ -134,7 +134,8 @@ export interface ITouchPlugin extends IPluginBaseInfo {
 export interface IFeatureCommand {
   type: 'match' | 'contain' | 'regex' | 'function' | 'over' | 'image' | 'files' | 'directory' | 'window'
   value: string | string[] | RegExp | Function
-  onTrigger: () => void
+  /** Optional trigger callback - not serialized over IPC */
+  onTrigger?: () => void
 }
 
 export interface IPluginFeature {

package/plugin/providers/index.ts

@@ -1,2 +1,6 @@
 export * from './registry'
 export * from './types'
+export * from './tpex-types'
+export * from './tpex-provider'
+export * from './npm-provider'
+export * from './market-client'

package/plugin/providers/market-client.ts

@@ -0,0 +1,215 @@
+import type { NpmPackageInfo } from './npm-provider'
+import type { TpexPluginInfo } from './tpex-provider'
+import { NpmProvider } from './npm-provider'
+import { TpexProvider } from './tpex-provider'
+import { PluginProviderType } from './types'
+
+export type PluginSourceType = 'tpex' | 'npm' | 'all'
+
+export interface MarketPluginInfo {
+  id: string
+  name: string
+  slug: string
+  version: string
+  description: string
+  author: string
+  icon?: string
+  source: PluginSourceType
+  isOfficial: boolean
+  downloads?: number
+  category?: string
+  keywords?: string[]
+  homepage?: string
+  packageUrl?: string
+  raw: TpexPluginInfo | NpmPackageInfo
+}
+
+export interface MarketSearchOptions {
+  keyword?: string
+  source?: PluginSourceType
+  category?: string
+  limit?: number
+  offset?: number
+}
+
+export interface MarketSearchResult {
+  plugins: MarketPluginInfo[]
+  total: number
+  sources: {
+    tpex: number
+    npm: number
+  }
+}
+
+function normalizeTpexPlugin(plugin: TpexPluginInfo): MarketPluginInfo {
+  return {
+    id: plugin.id,
+    name: plugin.name,
+    slug: plugin.slug,
+    version: plugin.latestVersion?.version ?? '0.0.0',
+    description: plugin.summary,
+    author: plugin.author?.name ?? 'Unknown',
+    icon: plugin.iconUrl ?? undefined,
+    source: 'tpex',
+    isOfficial: plugin.isOfficial,
+    downloads: plugin.installs,
+    category: plugin.category,
+    homepage: plugin.homepage ?? undefined,
+    packageUrl: plugin.latestVersion?.packageUrl,
+    raw: plugin,
+  }
+}
+
+function normalizeNpmPlugin(pkg: NpmPackageInfo): MarketPluginInfo {
+  const authorName = typeof pkg.author === 'string'
+    ? pkg.author
+    : pkg.author?.name ?? 'Unknown'
+
+  return {
+    id: pkg.name,
+    name: pkg.name.replace(/^tuff-plugin-/, '').replace(/^@tuff\//, ''),
+    slug: pkg.name,
+    version: pkg.version,
+    description: pkg.description ?? '',
+    author: authorName,
+    icon: pkg.tuff?.icon,
+    source: 'npm',
+    isOfficial: pkg.name.startsWith('@tuff/'),
+    keywords: pkg.keywords,
+    packageUrl: pkg.dist.tarball,
+    raw: pkg,
+  }
+}
+
+/**
+ * Unified plugin market client supporting multiple sources
+ */
+export class PluginMarketClient {
+  private tpexProvider: TpexProvider
+  private npmProvider: NpmProvider
+
+  constructor(options?: {
+    tpexApiBase?: string
+    npmRegistry?: string
+  }) {
+    this.tpexProvider = new TpexProvider(options?.tpexApiBase)
+    this.npmProvider = new NpmProvider(options?.npmRegistry)
+  }
+
+  /**
+   * Search plugins from all sources
+   */
+  async search(options: MarketSearchOptions = {}): Promise<MarketSearchResult> {
+    const { keyword, source = 'all', limit = 50, offset = 0 } = options
+    const results: MarketPluginInfo[] = []
+    let tpexCount = 0
+    let npmCount = 0
+
+    if (source === 'all' || source === 'tpex') {
+      try {
+        const tpexPlugins = keyword
+          ? await this.tpexProvider.searchPlugins(keyword)
+          : await this.tpexProvider.listPlugins()
+
+        const normalized = tpexPlugins.map(normalizeTpexPlugin)
+        results.push(...normalized)
+        tpexCount = normalized.length
+      }
+      catch (error) {
+        console.warn('[MarketClient] TPEX search failed:', error)
+      }
+    }
+
+    if (source === 'all' || source === 'npm') {
+      try {
+        const npmPlugins = await this.npmProvider.searchPlugins(keyword)
+        const normalized = npmPlugins.map(normalizeNpmPlugin)
+        results.push(...normalized)
+        npmCount = normalized.length
+      }
+      catch (error) {
+        console.warn('[MarketClient] NPM search failed:', error)
+      }
+    }
+
+    const sorted = results.sort((a, b) => {
+      if (a.isOfficial !== b.isOfficial) return a.isOfficial ? -1 : 1
+      return (b.downloads ?? 0) - (a.downloads ?? 0)
+    })
+
+    const paginated = sorted.slice(offset, offset + limit)
+
+    return {
+      plugins: paginated,
+      total: results.length,
+      sources: {
+        tpex: tpexCount,
+        npm: npmCount,
+      },
+    }
+  }
+
+  /**
+   * Get plugin details by identifier
+   */
+  async getPlugin(identifier: string, source?: PluginSourceType): Promise<MarketPluginInfo | null> {
+    if (source === 'tpex' || (!source && !identifier.includes('/'))) {
+      try {
+        const plugin = await this.tpexProvider.getPlugin(identifier)
+        if (plugin) return normalizeTpexPlugin(plugin)
+      }
+      catch {
+        // Fall through to npm
+      }
+    }
+
+    if (source === 'npm' || !source) {
+      try {
+        const pkg = await this.npmProvider.getPackageInfo(identifier)
+        if (pkg) return normalizeNpmPlugin(pkg)
+      }
+      catch {
+        // Not found
+      }
+    }
+
+    return null
+  }
+
+  /**
+   * Get install source string for a plugin
+   */
+  getInstallSource(plugin: MarketPluginInfo): string {
+    if (plugin.source === 'tpex') {
+      return `tpex:${plugin.slug}`
+    }
+    return `npm:${plugin.id}`
+  }
+
+  /**
+   * Get provider type for a plugin
+   */
+  getProviderType(plugin: MarketPluginInfo): PluginProviderType {
+    return plugin.source === 'tpex'
+      ? PluginProviderType.TPEX
+      : PluginProviderType.NPM
+  }
+
+  /**
+   * List all plugins from official source (TPEX)
+   */
+  async listOfficialPlugins(): Promise<MarketPluginInfo[]> {
+    const plugins = await this.tpexProvider.listPlugins()
+    return plugins.map(normalizeTpexPlugin)
+  }
+
+  /**
+   * List all plugins from npm
+   */
+  async listNpmPlugins(): Promise<MarketPluginInfo[]> {
+    const plugins = await this.npmProvider.listPlugins()
+    return plugins.map(normalizeNpmPlugin)
+  }
+}
+
+export const defaultMarketClient = new PluginMarketClient()

package/plugin/providers/npm-provider.ts

@@ -0,0 +1,213 @@
+import type { IManifest } from '..'
+import type {
+  PluginInstallRequest,
+  PluginInstallResult,
+  PluginProvider,
+  PluginProviderContext,
+} from './types'
+import { PluginProviderType } from './types'
+
+const NPM_REGISTRY = 'https://registry.npmjs.org'
+const TUFF_PLUGIN_PREFIX = 'tuff-plugin-'
+const TUFF_PLUGIN_SCOPE = '@tuff/'
+
+export interface NpmPackageInfo {
+  name: string
+  version: string
+  description?: string
+  author?: string | { name: string, email?: string }
+  main?: string
+  keywords?: string[]
+  dist: {
+    tarball: string
+    shasum: string
+    integrity?: string
+  }
+  tuff?: {
+    icon?: string
+    activationKeywords?: string[]
+  }
+}
+
+export interface NpmPackageVersions {
+  name: string
+  'dist-tags': {
+    latest: string
+    [tag: string]: string
+  }
+  versions: Record<string, NpmPackageInfo>
+}
+
+/**
+ * Parse NPM source string to extract package name and optional version
+ * Formats:
+ * - "npm:package-name"
+ * - "npm:package-name@version"
+ * - "npm:@scope/package-name"
+ * - "npm:@scope/package-name@version"
+ * - "tuff-plugin-xxx" (when hintType is NPM)
+ * - "@tuff/xxx" (when hintType is NPM)
+ */
+function parseNpmSource(source: string): { packageName: string, version?: string } | null {
+  const npmMatch = source.match(/^npm:(@?[a-z0-9][\w\-.]*(?:\/[a-z0-9][\w\-.]*)?)(?:@(.+))?$/i)
+  if (npmMatch) {
+    return { packageName: npmMatch[1], version: npmMatch[2] }
+  }
+
+  const scopedMatch = source.match(/^(@tuff\/[a-z0-9][\w\-.]*)(?:@(.+))?$/i)
+  if (scopedMatch) {
+    return { packageName: scopedMatch[1], version: scopedMatch[2] }
+  }
+
+  const prefixMatch = source.match(/^(tuff-plugin-[a-z0-9][\w\-.]*)(?:@(.+))?$/i)
+  if (prefixMatch) {
+    return { packageName: prefixMatch[1], version: prefixMatch[2] }
+  }
+
+  return null
+}
+
+/**
+ * Check if a package name looks like a Tuff plugin
+ */
+function isTuffPluginPackage(name: string): boolean {
+  return name.startsWith(TUFF_PLUGIN_PREFIX) || name.startsWith(TUFF_PLUGIN_SCOPE)
+}
+
+export class NpmProvider implements PluginProvider {
+  readonly type = PluginProviderType.NPM
+  private registry: string
+
+  constructor(registry: string = NPM_REGISTRY) {
+    this.registry = registry.replace(/\/$/, '')
+  }
+
+  canHandle(request: PluginInstallRequest): boolean {
+    if (request.hintType === PluginProviderType.NPM) {
+      return parseNpmSource(request.source) !== null
+    }
+
+    if (request.source.startsWith('npm:')) {
+      return true
+    }
+
+    const parsed = parseNpmSource(request.source)
+    return parsed !== null && isTuffPluginPackage(parsed.packageName)
+  }
+
+  async install(
+    request: PluginInstallRequest,
+    context?: PluginProviderContext,
+  ): Promise<PluginInstallResult> {
+    const parsed = parseNpmSource(request.source)
+    if (!parsed) {
+      throw new Error(`Invalid NPM source format: ${request.source}`)
+    }
+
+    const { packageName, version } = parsed
+    const packageInfo = await this.getPackageInfo(packageName, version)
+
+    if (!packageInfo) {
+      throw new Error(`Package not found: ${packageName}`)
+    }
+
+    const tarballUrl = packageInfo.dist.tarball
+    const downloadRes = await fetch(tarballUrl)
+    if (!downloadRes.ok) {
+      throw new Error(`Failed to download package: ${downloadRes.statusText}`)
+    }
+
+    const arrayBuffer = await downloadRes.arrayBuffer()
+    const tempDir = context?.tempDir ?? '/tmp'
+    const safePackageName = packageName.replace(/[@/]/g, '-')
+    const fileName = `${safePackageName}-${packageInfo.version}.tgz`
+    const filePath = `${tempDir}/${fileName}`
+
+    if (typeof globalThis.process !== 'undefined') {
+      const fs = await import('node:fs/promises')
+      await fs.writeFile(filePath, Buffer.from(arrayBuffer))
+    }
+
+    const authorName = typeof packageInfo.author === 'string'
+      ? packageInfo.author
+      : packageInfo.author?.name ?? 'Unknown'
+
+    const manifest: IManifest = {
+      id: packageInfo.name,
+      name: packageInfo.name.replace(TUFF_PLUGIN_PREFIX, '').replace(TUFF_PLUGIN_SCOPE, ''),
+      version: packageInfo.version,
+      description: packageInfo.description ?? '',
+      author: authorName,
+      main: packageInfo.main ?? 'index.js',
+      icon: packageInfo.tuff?.icon,
+      activationKeywords: packageInfo.tuff?.activationKeywords ?? packageInfo.keywords,
+    }
+
+    return {
+      provider: PluginProviderType.NPM,
+      filePath,
+      official: packageName.startsWith(TUFF_PLUGIN_SCOPE),
+      manifest,
+      metadata: {
+        packageName: packageInfo.name,
+        version: packageInfo.version,
+        tarball: tarballUrl,
+        shasum: packageInfo.dist.shasum,
+        integrity: packageInfo.dist.integrity,
+      },
+    }
+  }
+
+  /**
+   * Get package info from npm registry
+   */
+  async getPackageInfo(packageName: string, version?: string): Promise<NpmPackageInfo | null> {
+    const encodedName = encodeURIComponent(packageName).replace('%40', '@')
+    const res = await fetch(`${this.registry}/${encodedName}`)
+
+    if (!res.ok) {
+      if (res.status === 404) return null
+      throw new Error(`Failed to fetch package info: ${res.statusText}`)
+    }
+
+    const data: NpmPackageVersions = await res.json()
+    const targetVersion = version ?? data['dist-tags'].latest
+
+    return data.versions[targetVersion] ?? null
+  }
+
+  /**
+   * Search for Tuff plugins on npm
+   */
+  async searchPlugins(keyword?: string): Promise<NpmPackageInfo[]> {
+    const searchTerms = [
+      `keywords:tuff-plugin`,
+      keyword ? `${keyword}` : '',
+    ].filter(Boolean).join('+')
+
+    const res = await fetch(
+      `${this.registry}/-/v1/search?text=${encodeURIComponent(searchTerms)}&size=100`,
+    )
+
+    if (!res.ok) {
+      throw new Error(`Failed to search packages: ${res.statusText}`)
+    }
+
+    const data = await res.json() as {
+      objects: Array<{ package: NpmPackageInfo }>
+    }
+
+    return data.objects
+      .map(obj => obj.package)
+      .filter(pkg => isTuffPluginPackage(pkg.name))
+  }
+
+  /**
+   * List all available Tuff plugins from npm
+   */
+  async listPlugins(): Promise<NpmPackageInfo[]> {
+    return this.searchPlugins()
+  }
+}
+
+export const npmProvider = new NpmProvider()