@talex-touch/utils 1.0.42 → 1.0.44

package/renderer/storage/intelligence-storage.ts

@@ -1,20 +1,23 @@
-import type { IntelligenceProviderConfig, AISDKGlobalConfig, AISDKStorageData } from '../../types/intelligence'
+import type {
+  IntelligenceGlobalConfig,
+  IntelligenceProviderConfig,
+  IntelligenceStorageData,
+} from '../../types/intelligence'
+import { getLogger } from '../../common/logger'
 import { StorageList } from '../../common/storage/constants'
 import {
-
-  IntelligenceProviderType,
-
   DEFAULT_CAPABILITIES,
   DEFAULT_GLOBAL_CONFIG,
   DEFAULT_PROVIDERS,
+  IntelligenceProviderType,
 } from '../../types/intelligence'
-import { createStorageProxy, TouchStorage } from './base-storage'
+import { createStorageDataProxy, createStorageProxy, TouchStorage } from './base-storage'
 
 // Re-export types for convenience
 export { IntelligenceProviderType }
-export type { IntelligenceProviderConfig, AISDKGlobalConfig }
+export type { IntelligenceGlobalConfig, IntelligenceProviderConfig }
 
-const defaultIntelligenceData: AISDKStorageData = {
+const defaultIntelligenceData: IntelligenceStorageData = {
   providers: [...DEFAULT_PROVIDERS],
   globalConfig: { ...DEFAULT_GLOBAL_CONFIG },
   capabilities: { ...DEFAULT_CAPABILITIES },
@@ -22,8 +25,9 @@ const defaultIntelligenceData: AISDKStorageData = {
 }
 
 const INTELLIGENCE_STORAGE_KEY = `storage:${StorageList.IntelligenceConfig}`
+const intelligenceStorageLog = getLogger('intelligence-storage')
 
-class IntelligenceStorage extends TouchStorage<AISDKStorageData> {
+class IntelligenceStorage extends TouchStorage<IntelligenceStorageData> {
   constructor() {
     super(StorageList.IntelligenceConfig, defaultIntelligenceData)
     this.setAutoSave(true)
@@ -50,8 +54,11 @@ class IntelligenceStorage extends TouchStorage<AISDKStorageData> {
 
     if (providerIndex !== -1) {
       const updatedProviders = [...currentData.providers]
+      const currentProvider = updatedProviders[providerIndex]
+      if (!currentProvider)
+        return
       updatedProviders[providerIndex] = {
-        ...updatedProviders[providerIndex],
+        ...currentProvider,
         ...updatedProvider,
       }
 
@@ -78,7 +85,7 @@ class IntelligenceStorage extends TouchStorage<AISDKStorageData> {
   /**
    * 更新全局配置
    */
-  updateGlobalConfig(config: Partial<AISDKGlobalConfig>): void {
+  updateGlobalConfig(config: Partial<IntelligenceGlobalConfig>): void {
     const currentData = this.get()
 
     this.set({
@@ -129,25 +136,19 @@ export const intelligenceStorage = createStorageProxy<IntelligenceStorage>(
   () => new IntelligenceStorage(),
 )
 
-/**
- * Alias for backward compatibility
- * @deprecated Use intelligenceStorage instead
- */
-export const aisdkStorage = intelligenceStorage
+export const intelligenceData = createStorageDataProxy(intelligenceStorage)
 
-/**
- * Alias for backward compatibility
- * @deprecated Use intelligenceStorage instead
- */
 export const intelligenceSettings = intelligenceStorage
 
+export const intelligenceSettingsData = intelligenceData
+
 export async function migrateIntelligenceSettings(): Promise<void> {
-  console.log('[Intelligence Storage] Starting migration check...')
+  intelligenceStorageLog.info('Starting migration check...')
   const currentData = intelligenceStorage.data
 
   // Version 2: Force update capabilities to include all new ones
   if (!currentData.version || currentData.version < 2) {
-    console.log('[Intelligence Storage] Migrating settings to version 2')
+    intelligenceStorageLog.info('Migrating settings to version 2')
 
     const migratedProviders = currentData.providers.map(provider => ({
       ...provider,
@@ -163,7 +164,7 @@ export async function migrateIntelligenceSettings(): Promise<void> {
     const normalizedStrategy
       = storedStrategy === 'priority' ? 'rule-based-default' : storedStrategy ?? 'adaptive-default'
 
-    const migratedGlobalConfig: AISDKGlobalConfig = {
+    const migratedGlobalConfig: IntelligenceGlobalConfig = {
       defaultStrategy: normalizedStrategy,
       enableAudit: currentData.globalConfig?.enableAudit ?? false,
       enableCache: currentData.globalConfig?.enableCache ?? true,
@@ -171,8 +172,8 @@ export async function migrateIntelligenceSettings(): Promise<void> {
     }
 
     // Force update to latest DEFAULT_CAPABILITIES (version 2)
-    console.log('[Intelligence Storage] Updating capabilities to latest defaults')
-    
+    intelligenceStorageLog.info('Updating capabilities to latest defaults')
+
     intelligenceStorage.applyData({
       providers: migratedProviders,
       globalConfig: migratedGlobalConfig,
@@ -182,23 +183,18 @@ export async function migrateIntelligenceSettings(): Promise<void> {
 
     await intelligenceStorage.saveToRemote({ force: true })
 
-    console.log('[Intelligence Storage] Migration to v2 complete, capabilities count:', Object.keys(DEFAULT_CAPABILITIES).length)
+    intelligenceStorageLog.info(`Migration to v2 complete, capabilities count: ${Object.keys(DEFAULT_CAPABILITIES).length}`)
   }
   else {
-    console.log('[Intelligence Storage] No migration needed, current version:', currentData.version)
+    intelligenceStorageLog.info(`No migration needed, current version: ${currentData.version}`)
   }
 
-  console.log('[Intelligence Storage] Final providers count:', intelligenceStorage.data.providers.length)
-  console.log('[Intelligence Storage] Final capabilities count:', Object.keys(intelligenceStorage.data.capabilities).length)
+  intelligenceStorageLog.info(`Final providers count: ${intelligenceStorage.data.providers.length}`)
+  intelligenceStorageLog.info(`Final capabilities count: ${Object.keys(intelligenceStorage.data.capabilities).length}`)
 }
 
-/**
- * @deprecated Use migrateIntelligenceSettings instead
- */
-export const migrateAISDKSettings = migrateIntelligenceSettings
-
 export async function resetIntelligenceConfig(): Promise<void> {
-  console.log('[Intelligence Storage] Resetting to default configuration')
+  intelligenceStorageLog.info('Resetting to default configuration')
 
   intelligenceStorage.applyData({
     providers: [...DEFAULT_PROVIDERS],
@@ -209,10 +205,5 @@ export async function resetIntelligenceConfig(): Promise<void> {
 
   await intelligenceStorage.saveToRemote({ force: true })
 
-  console.log('[Intelligence Storage] Reset complete')
+  intelligenceStorageLog.info('Reset complete')
 }
-
-/**
- * @deprecated Use resetIntelligenceConfig instead
- */
-export const resetAISDKConfig = resetIntelligenceConfig

package/renderer/storage/openers.ts

@@ -1,6 +1,6 @@
 import type { OpenersMap } from '../..'
 import { openersOriginData, StorageList } from '../..'
-import { createStorageProxy, TouchStorage } from './base-storage'
+import { createStorageDataProxy, createStorageProxy, TouchStorage } from './base-storage'
 
 class OpenersStorage extends TouchStorage<OpenersMap> {
   constructor() {
@@ -19,3 +19,5 @@ export const openersStorage = createStorageProxy<OpenersStorage>(
   OPENERS_STORAGE_KEY,
   () => new OpenersStorage(),
 )
+
+export const openersData = createStorageDataProxy(openersStorage)

package/renderer/storage/storage-subscription.ts

@@ -1,4 +1,8 @@
+import type { ITuffTransport } from '../../transport'
+import type { StorageUpdateNotification } from '../../transport/events/types'
 import type { IStorageChannel } from './base-storage'
+import { defineRawEvent } from '../../transport/event/builder'
+import { StorageEvents } from '../../transport/events'
 
 /**
  * Storage subscription callback type
@@ -11,34 +15,68 @@ export type StorageSubscriptionCallback = (data: any) => void
  */
 class StorageSubscriptionManager {
   private channel: IStorageChannel | null = null
+  private transport: ITuffTransport | null = null
   private subscribers = new Map<string, Set<StorageSubscriptionCallback>>()
   private channelListenerRegistered = false
   private pendingUpdates = new Map<string, NodeJS.Timeout>()
   private configVersions = new Map<string, number>()
+  private cachedData = new Map<string, unknown>()
 
   /**
    * Initialize the subscription manager with a channel
    */
-  init(channel: IStorageChannel): void {
-    this.channel = channel
+  init(channel?: IStorageChannel, transport?: ITuffTransport): void {
+    if (channel) {
+      this.channel = channel
+    }
+    if (transport) {
+      this.transport = transport
+    }
 
     if (!this.channelListenerRegistered) {
-      // Listen to storage:update events from main process
-      this.channel.regChannel('storage:update', ({ data }) => {
-        const { name, version } = data as { name: string, version?: number }
-        // Only handle update if version is newer or unknown
-        const currentVersion = this.configVersions.get(name) ?? 0
-        if (version === undefined || version > currentVersion) {
-          if (version !== undefined) {
-            this.configVersions.set(name, version)
-          }
-          this.handleStorageUpdate(name)
-        }
-      })
+      if (this.transport) {
+        this.transport
+          .stream(StorageEvents.app.updated, undefined, {
+            onData: (payload: StorageUpdateNotification) => {
+              this.handleVersionedUpdate(payload.key, payload.version)
+            },
+          })
+          .catch((error) => {
+            console.error('[StorageSubscription] Failed to subscribe to storage updates:', error)
+          })
+
+        const legacyStorageUpdateEvent = defineRawEvent<{ name: string; version?: number }, void>(
+          StorageEvents.legacy.update.toEventName()
+        )
+        this.transport.on(legacyStorageUpdateEvent, (payload) => {
+          if (!payload || typeof payload !== 'object') return
+          const { name, version } = payload as { name?: string; version?: number }
+          if (!name) return
+          this.handleVersionedUpdate(name, version)
+        })
+      }
+
+      if (this.channel) {
+        // Listen to storage:update events from main process
+        this.channel.regChannel(StorageEvents.legacy.update.toEventName(), ({ data }) => {
+          const { name, version } = data as { name: string, version?: number }
+          this.handleVersionedUpdate(name, version)
+        })
+      }
       this.channelListenerRegistered = true
     }
   }
 
+  private handleVersionedUpdate(name: string, version?: number): void {
+    const currentVersion = this.configVersions.get(name) ?? 0
+    if (version === undefined || version > currentVersion) {
+      if (version !== undefined) {
+        this.configVersions.set(name, version)
+      }
+      void this.handleStorageUpdate(name)
+    }
+  }
+
   /**
    * Subscribe to storage changes for a specific config
    * @param configName - The configuration file name (e.g., 'app-setting.ini')
@@ -62,18 +100,51 @@ class StorageSubscriptionManager {
 
     this.subscribers.get(configName)!.add(callback)
 
-    // Immediately load and call with current data
-    if (this.channel) {
-      const currentData = this.channel.sendSync('storage:get', configName)
-      if (currentData) {
-        try {
-          callback(currentData)
-        }
-        catch (error) {
-          console.error(`[StorageSubscription] Callback error for "${configName}":`, error)
-        }
+    const cached = this.cachedData.get(configName)
+    if (cached !== undefined) {
+      try {
+        callback(cached)
+      }
+      catch (error) {
+        console.error(`[StorageSubscription] Callback error for "${configName}":`, error)
       }
     }
+    else if (this.channel) {
+      this.channel
+        .send('storage:get', configName)
+        .then((data) => {
+          if (data === undefined || data === null)
+            return
+          this.cachedData.set(configName, data)
+          try {
+            callback(data)
+          }
+          catch (error) {
+            console.error(`[StorageSubscription] Callback error for "${configName}":`, error)
+          }
+        })
+        .catch((error) => {
+          console.error(`[StorageSubscription] Failed to load "${configName}":`, error)
+        })
+    }
+    else if (this.transport) {
+      this.transport
+        .send(StorageEvents.app.get, { key: configName })
+        .then((data) => {
+          if (data === undefined || data === null)
+            return
+          this.cachedData.set(configName, data)
+          try {
+            callback(data)
+          }
+          catch (error) {
+            console.error(`[StorageSubscription] Callback error for "${configName}":`, error)
+          }
+        })
+        .catch((error) => {
+          console.error(`[StorageSubscription] Failed to load "${configName}":`, error)
+        })
+    }
 
     // Return unsubscribe function
     return () => {
@@ -92,6 +163,7 @@ class StorageSubscriptionManager {
       callbacks.delete(callback)
       if (callbacks.size === 0) {
         this.subscribers.delete(configName)
+        this.cachedData.delete(configName)
       }
     }
   }
@@ -106,7 +178,7 @@ class StorageSubscriptionManager {
       return
     }
 
-    if (!this.channel) {
+    if (!this.channel && !this.transport) {
       return
     }
 
@@ -117,24 +189,35 @@ class StorageSubscriptionManager {
     }
 
     const timer = setTimeout(async () => {
-      // Fetch latest data
-      const data = await this.channel!.send('storage:get', configName)
-      if (!data) {
-        this.pendingUpdates.delete(configName)
-        return
-      }
+      try {
+        // Fetch latest data
+        const data = this.channel
+          ? await this.channel.send('storage:get', configName)
+          : await this.transport!.send(StorageEvents.app.get, { key: configName })
 
-      // Notify all subscribers
-      callbacks.forEach((callback) => {
-        try {
-          callback(data)
-        }
-        catch (error) {
-          console.error(`[StorageSubscription] Callback error for "${configName}":`, error)
+        if (data === undefined || data === null) {
+          this.pendingUpdates.delete(configName)
+          return
         }
-      })
 
-      this.pendingUpdates.delete(configName)
+        this.cachedData.set(configName, data)
+
+        // Notify all subscribers
+        callbacks.forEach((callback) => {
+          try {
+            callback(data)
+          }
+          catch (error) {
+            console.error(`[StorageSubscription] Callback error for "${configName}":`, error)
+          }
+        })
+      }
+      catch (error) {
+        console.error(`[StorageSubscription] Failed to reload "${configName}":`, error)
+      }
+      finally {
+        this.pendingUpdates.delete(configName)
+      }
     }, 50) // 50ms debounce window
 
     this.pendingUpdates.set(configName, timer)
@@ -154,6 +237,7 @@ class StorageSubscriptionManager {
    */
   clear(): void {
     this.subscribers.clear()
+    this.cachedData.clear()
   }
 }
 
@@ -166,8 +250,8 @@ const subscriptionManager = new StorageSubscriptionManager()
  *
  * @param channel - The storage channel
  */
-export function initStorageSubscription(channel: IStorageChannel): void {
-  subscriptionManager.init(channel)
+export function initStorageSubscription(channel?: IStorageChannel, transport?: ITuffTransport): void {
+  subscriptionManager.init(channel, transport)
 }
 
 /**

package/renderer/touch-sdk/env.ts

@@ -1,11 +1,11 @@
-import type { ITouchClientChannel } from '@talex-touch/utils/channel'
+import type { ITuffTransport } from '@talex-touch/utils/transport'
 import { Terminal } from './terminal'
 
 export class EnvDetector {
-  private static channel: ITouchClientChannel
+  private static transport: ITuffTransport
 
-  public static init(channel: ITouchClientChannel) {
-    this.channel = channel
+  public static init(transport: ITuffTransport) {
+    this.transport = transport
   }
 
   private static async checkCommand(
@@ -13,11 +13,11 @@ export class EnvDetector {
     versionArgs: string = '--version',
     versionRegex: RegExp = /(\d+\.\d+\.\d+)/,
   ): Promise<string | false> {
-    if (!this.channel) {
-      throw new Error('EnvDetector not initialized. Call EnvDetector.init(channel) first.')
+    if (!this.transport) {
+      throw new Error('EnvDetector not initialized. Call EnvDetector.init(transport) first.')
     }
     return new Promise((resolve) => {
-      const terminal = new Terminal(this.channel)
+      const terminal = new Terminal(this.transport)
       let output = ''
       let resolved = false
 
@@ -68,11 +68,11 @@ export class EnvDetector {
   }
 
   static async getDegit(): Promise<boolean> {
-    if (!this.channel) {
-      throw new Error('EnvDetector not initialized. Call EnvDetector.init(channel) first.')
+    if (!this.transport) {
+      throw new Error('EnvDetector not initialized. Call EnvDetector.init(transport) first.')
     }
     return new Promise((resolve) => {
-      const terminal = new Terminal(this.channel)
+      const terminal = new Terminal(this.transport)
       let receivedOutput = false
       let resolved = false
 

package/renderer/touch-sdk/index.ts

@@ -1,7 +1,32 @@
 import type { ITouchClientChannel } from '@talex-touch/utils/channel'
+import type { ITuffTransport, TuffEvent } from '@talex-touch/utils/transport'
+import { defineRawEvent } from '@talex-touch/utils/transport/event/builder'
+
+const legacyCloseEvent = defineRawEvent<void, void>('close')
+const legacyHideEvent = defineRawEvent<void, void>('hide')
+const legacyMinimizeEvent = defineRawEvent<void, void>('minimize')
+const legacyDevToolsEvent = defineRawEvent<void, void>('dev-tools')
+const legacyCwdEvent = defineRawEvent<void, string>('common:cwd')
+const legacyPackageEvent = defineRawEvent<void, any>('get-package')
+const legacyOsEvent = defineRawEvent<void, any>('get-os')
+const legacyFolderOpenEvent = defineRawEvent<FolderOpenOptions, void>('folder:open')
+const legacyExecuteCmdEvent = defineRawEvent<ExecuteCommandOptions, void>('execute:cmd')
+const legacyAppOpenEvent = defineRawEvent<AppOpenOptions, void>('app:open')
+const legacyOpenExternalEvent = defineRawEvent<ExternalUrlOptions, void>('open-external')
+const legacyTempFileCreateEvent = defineRawEvent<TempFileCreateOptions, TempFileCreateResult>(
+  'temp-file:create',
+)
+const legacyTempFileDeleteEvent = defineRawEvent<TempFileDeleteOptions, TempFileDeleteResult>(
+  'temp-file:delete',
+)
+const legacyPluginFolderEvent = defineRawEvent<string, void>('plugin:explorer')
+const legacyPluginDevToolsEvent = defineRawEvent<string, void>('plugin:open-devtools')
+const legacyPluginReloadEvent = defineRawEvent<{ name: string }, void>('reload-plugin')
+const legacyModuleFolderEvent = defineRawEvent<{ name?: string }, void>('module:folder')
 
 export interface TouchSDKOptions {
-  channel: ITouchClientChannel
+  transport?: ITuffTransport
+  channel?: ITouchClientChannel
 }
 
 export interface FolderOpenOptions {
@@ -21,68 +46,130 @@ export interface ExternalUrlOptions {
   url: string
 }
 
+export interface TempFileCreateOptions {
+  namespace: string
+  ext?: string
+  text?: string
+  base64?: string
+  prefix?: string
+  retentionMs?: number
+}
+
+export interface TempFileCreateResult {
+  url: string
+  sizeBytes: number
+  createdAt: number
+}
+
+export interface TempFileDeleteOptions {
+  url?: string
+  path?: string
+}
+
+export interface TempFileDeleteResult {
+  success: boolean
+}
+
 export class TouchSDK {
-  private channel: ITouchClientChannel
+  private transport: ITuffTransport | null
+  private channel: ITouchClientChannel | null
 
   constructor(options: TouchSDKOptions) {
-    this.channel = options.channel
+    this.transport = options.transport ?? null
+    this.channel = options.channel ?? null
+  }
+
+  private async sendEvent<TReq, TRes>(event: TuffEvent<TReq, TRes>, payload?: TReq): Promise<TRes> {
+    if (this.transport) {
+      const shouldPassPayload = payload !== undefined
+      if (shouldPassPayload) {
+        return this.transport.send(event, payload)
+      }
+      return this.transport.send(event as TuffEvent<void, TRes>)
+    }
+
+    if (this.channel) {
+      return this.channel.send(event.toEventName(), payload as any) as Promise<TRes>
+    }
+
+    throw new Error('[TouchSDK] Transport or channel not initialized.')
   }
 
   /**
    * System Operations
    */
   async closeApp(): Promise<void> {
-    return this.channel.send('close')
+    return this.sendEvent(legacyCloseEvent)
   }
 
   async hideApp(): Promise<void> {
-    return this.channel.send('hide')
+    return this.sendEvent(legacyHideEvent)
   }
 
   async minimizeApp(): Promise<void> {
-    return this.channel.send('minimize')
+    return this.sendEvent(legacyMinimizeEvent)
   }
 
   async openDevTools(): Promise<void> {
-    return this.channel.send('dev-tools')
+    return this.sendEvent(legacyDevToolsEvent)
   }
 
   async getCurrentWorkingDirectory(): Promise<string> {
-    return this.channel.send('common:cwd')
+    return this.sendEvent(legacyCwdEvent)
   }
 
   async getPackageInfo(): Promise<any> {
-    return this.channel.send('get-package')
+    return this.sendEvent(legacyPackageEvent)
   }
 
   async getOSInfo(): Promise<any> {
-    return this.channel.send('get-os')
+    return this.sendEvent(legacyOsEvent)
   }
 
   /**
    * File & Folder Operations
    */
   async openFolder(options: FolderOpenOptions): Promise<void> {
-    return this.channel.send('folder:open', options)
+    return this.sendEvent(legacyFolderOpenEvent, options)
   }
 
   async executeCommand(options: ExecuteCommandOptions): Promise<void> {
-    return this.channel.send('execute:cmd', options)
+    return this.sendEvent(legacyExecuteCmdEvent, options)
   }
 
   async openApp(options: AppOpenOptions): Promise<void> {
-    return this.channel.send('app:open', options)
+    return this.sendEvent(legacyAppOpenEvent, options)
   }
 
   async openExternalUrl(options: ExternalUrlOptions): Promise<void> {
-    return this.channel.send('open-external', options)
+    return this.sendEvent(legacyOpenExternalEvent, options)
+  }
+
+  /**
+   * Temp file operations
+   */
+  async createTempFile(options: TempFileCreateOptions): Promise<TempFileCreateResult> {
+    return this.sendEvent(legacyTempFileCreateEvent, options)
+  }
+
+  async deleteTempFile(options: TempFileDeleteOptions): Promise<TempFileDeleteResult> {
+    return this.sendEvent(legacyTempFileDeleteEvent, options)
   }
 
   /**
    * Plugin Operations
    */
   async openPluginFolder(pluginName: string): Promise<void> {
-    return this.channel.send('plugin:explorer', pluginName)
+    return this.sendEvent(legacyPluginFolderEvent, pluginName)
+  }
+
+  /**
+   * Opens the DevTools for a plugin's Surface WebContents
+   * @param pluginName - The name of the plugin to open DevTools for
+   * @returns Promise that resolves when DevTools is opened
+   */
+  async openPluginDevTools(pluginName: string): Promise<void> {
+    return this.sendEvent(legacyPluginDevToolsEvent, pluginName)
   }
 
   /**
@@ -91,27 +178,36 @@ export class TouchSDK {
    * @returns Promise that resolves when the reload operation completes
    */
   async reloadPlugin(pluginName: string): Promise<void> {
-    return this.channel.send('reload-plugin', { name: pluginName })
+    return this.sendEvent(legacyPluginReloadEvent, { name: pluginName })
   }
 
   /**
    * Module Operations
    */
   async openModuleFolder(moduleName?: string): Promise<void> {
-    return this.channel.send('module:folder', { name: moduleName })
+    return this.sendEvent(legacyModuleFolderEvent, { name: moduleName })
   }
 
   /**
    * Event Registration
    */
   onChannelEvent(eventName: string, callback: (data: any) => void): () => void {
-    return this.channel.regChannel(eventName, callback)
+    if (this.transport) {
+      return this.transport.on(defineRawEvent<any, any>(eventName), callback)
+    }
+    if (this.channel) {
+      return this.channel.regChannel(eventName, callback)
+    }
+    throw new Error('[TouchSDK] Transport or channel not initialized.')
   }
 
   /**
    * Raw channel access for advanced usage
    */
   get rawChannel(): ITouchClientChannel {
+    if (!this.channel) {
+      throw new Error('[TouchSDK] Channel not initialized.')
+    }
     return this.channel
   }
 }