@talex-touch/utils 1.0.42 → 1.0.45

package/transport/sdk/domains/notification.ts

@@ -0,0 +1,62 @@
+import type {
+  NotificationActionPayload,
+  NotificationDismissPayload,
+  NotificationDismissRequest,
+  NotificationInboxArchiveRequest,
+  NotificationInboxClearRequest,
+  NotificationInboxClearResponse,
+  NotificationInboxDeleteRequest,
+  NotificationInboxDeleteResponse,
+  NotificationInboxEntry,
+  NotificationInboxListRequest,
+  NotificationInboxListResponse,
+  NotificationInboxMarkReadRequest,
+  NotificationInboxUpdatedPayload,
+  NotificationPushPayload,
+  NotificationRequest,
+  NotificationResult,
+  NotificationUpdatePayload,
+  NotificationUpdateRequest,
+} from '../../events/types'
+import type { ITuffTransport } from '../../types'
+import { NotificationEvents } from '../../events'
+
+export interface NotificationSdk {
+  notify: (request: NotificationRequest) => Promise<NotificationResult>
+  update: (request: NotificationUpdateRequest) => Promise<NotificationResult>
+  dismiss: (request: NotificationDismissRequest) => Promise<NotificationResult>
+  reportAction: (payload: NotificationActionPayload) => Promise<void>
+
+  listInbox: (request?: NotificationInboxListRequest) => Promise<NotificationInboxListResponse>
+  markRead: (request: NotificationInboxMarkReadRequest) => Promise<NotificationInboxEntry | null>
+  archive: (request: NotificationInboxArchiveRequest) => Promise<NotificationInboxEntry | null>
+  delete: (request: NotificationInboxDeleteRequest) => Promise<NotificationInboxDeleteResponse>
+  clear: (request?: NotificationInboxClearRequest) => Promise<NotificationInboxClearResponse>
+
+  onNotify: (handler: (payload: NotificationPushPayload) => void) => () => void
+  onUpdate: (handler: (payload: NotificationUpdatePayload) => void) => () => void
+  onDismiss: (handler: (payload: NotificationDismissPayload) => void) => () => void
+  onAction: (handler: (payload: NotificationActionPayload) => void) => () => void
+  onInboxUpdated: (handler: (payload: NotificationInboxUpdatedPayload) => void) => () => void
+}
+
+export function createNotificationSdk(transport: ITuffTransport): NotificationSdk {
+  return {
+    notify: request => transport.send(NotificationEvents.api.notify, request),
+    update: request => transport.send(NotificationEvents.api.update, request),
+    dismiss: request => transport.send(NotificationEvents.api.dismiss, request),
+    reportAction: payload => transport.send(NotificationEvents.api.action, payload),
+
+    listInbox: request => transport.send(NotificationEvents.inbox.list, request ?? {}),
+    markRead: request => transport.send(NotificationEvents.inbox.markRead, request),
+    archive: request => transport.send(NotificationEvents.inbox.archive, request),
+    delete: request => transport.send(NotificationEvents.inbox.delete, request),
+    clear: request => transport.send(NotificationEvents.inbox.clear, request ?? {}),
+
+    onNotify: handler => transport.on(NotificationEvents.push.notify, handler),
+    onUpdate: handler => transport.on(NotificationEvents.push.update, handler),
+    onDismiss: handler => transport.on(NotificationEvents.push.dismiss, handler),
+    onAction: handler => transport.on(NotificationEvents.push.action, handler),
+    onInboxUpdated: handler => transport.on(NotificationEvents.push.inboxUpdated, handler),
+  }
+}

package/transport/sdk/domains/permission.ts

@@ -0,0 +1,85 @@
+import type {
+  PermissionCheckRequest,
+  PermissionCheckResponse,
+  PermissionGetAllResponse,
+  PermissionGetAuditLogsRequest,
+  PermissionGetAuditLogsResponse,
+  PermissionGetPerformanceResponse,
+  PermissionGetPluginRequest,
+  PermissionGetPluginResponse,
+  PermissionGetRegistryResponse,
+  PermissionGetStatusRequest,
+  PermissionGetStatusResponse,
+  PermissionGrantMultipleRequest,
+  PermissionGrantRequest,
+  PermissionOperationResult,
+  PermissionRevokeAllRequest,
+  PermissionRevokeRequest,
+  PermissionStartupRequestPayload,
+  PermissionUpdatedPayload,
+} from '../../events/types/permission'
+import type { ITuffTransport } from '../../types'
+import { PermissionEvents } from '../../events'
+
+export interface PermissionSdk {
+  getPlugin: (payload: PermissionGetPluginRequest) => Promise<PermissionGetPluginResponse>
+  getStatus: (payload: PermissionGetStatusRequest) => Promise<PermissionGetStatusResponse>
+  grant: (payload: PermissionGrantRequest) => Promise<PermissionOperationResult>
+  revoke: (payload: PermissionRevokeRequest) => Promise<PermissionOperationResult>
+  grantMultiple: (payload: PermissionGrantMultipleRequest) => Promise<PermissionOperationResult>
+  grantSession: (payload: PermissionGrantMultipleRequest) => Promise<PermissionOperationResult>
+  revokeAll: (payload: PermissionRevokeAllRequest) => Promise<PermissionOperationResult>
+  check: (payload: PermissionCheckRequest) => Promise<PermissionCheckResponse>
+  getAll: () => Promise<PermissionGetAllResponse>
+  getRegistry: () => Promise<PermissionGetRegistryResponse>
+  getAuditLogs: (payload?: PermissionGetAuditLogsRequest) => Promise<PermissionGetAuditLogsResponse>
+  clearAuditLogs: () => Promise<PermissionOperationResult>
+  getPerformance: () => Promise<PermissionGetPerformanceResponse>
+  resetPerformance: () => Promise<PermissionOperationResult>
+  onUpdated: (handler: (payload: PermissionUpdatedPayload) => void) => () => void
+  onStartupRequest: (handler: (payload: PermissionStartupRequestPayload) => void) => () => void
+}
+
+export type PermissionSdkTransport = Pick<ITuffTransport, 'send' | 'on'>
+
+export function createPermissionSdk(transport: PermissionSdkTransport): PermissionSdk {
+  return {
+    getPlugin: payload => transport.send(PermissionEvents.api.getPlugin, payload),
+    getStatus: payload => transport.send(PermissionEvents.api.getStatus, payload),
+    grant: payload => transport.send(PermissionEvents.api.grant, payload),
+    revoke: payload => transport.send(PermissionEvents.api.revoke, payload),
+    grantMultiple: payload => transport.send(PermissionEvents.api.grantMultiple, payload),
+    grantSession: payload => transport.send(PermissionEvents.api.grantSession, payload),
+    revokeAll: payload => transport.send(PermissionEvents.api.revokeAll, payload),
+    check: payload => transport.send(PermissionEvents.api.check, payload),
+    getAll: () => transport.send(PermissionEvents.api.getAll),
+    getRegistry: () => transport.send(PermissionEvents.api.getRegistry),
+    getAuditLogs: payload => transport.send(PermissionEvents.api.getAuditLogs, payload),
+    clearAuditLogs: () => transport.send(PermissionEvents.api.clearAuditLogs),
+    getPerformance: () => transport.send(PermissionEvents.api.getPerformance),
+    resetPerformance: () => transport.send(PermissionEvents.api.resetPerformance),
+    onUpdated: handler => transport.on(PermissionEvents.push.updated, handler),
+    onStartupRequest: handler => transport.on(PermissionEvents.push.startupRequest, handler),
+  }
+}
+
+export type {
+  PermissionCheckRequest,
+  PermissionCheckResponse,
+  PermissionGetAllResponse,
+  PermissionGetAuditLogsRequest,
+  PermissionGetAuditLogsResponse,
+  PermissionGetPerformanceResponse,
+  PermissionGetPluginRequest,
+  PermissionGetPluginResponse,
+  PermissionGetRegistryResponse,
+  PermissionGetStatusRequest,
+  PermissionGetStatusResponse,
+  PermissionGrantMultipleRequest,
+  PermissionGrantRequest,
+  PermissionOperationResult,
+  PermissionRevokeAllRequest,
+  PermissionRevokeRequest,
+  PermissionStartupRequestPayload,
+  PermissionUpdatedPayload,
+}

package/transport/sdk/domains/platform.ts

@@ -0,0 +1,19 @@
+import type {
+  PlatformCapabilityListRequest,
+  PlatformCapabilityListResponse,
+} from '../../events/types'
+import type { ITuffTransport } from '../../types'
+import { PlatformEvents } from '../../events'
+
+export interface PlatformSdk {
+  listCapabilities: (
+    payload?: PlatformCapabilityListRequest,
+  ) => Promise<PlatformCapabilityListResponse>
+}
+
+export function createPlatformSdk(transport: ITuffTransport): PlatformSdk {
+  return {
+    listCapabilities: payload =>
+      transport.send(PlatformEvents.capabilities.list, payload ?? undefined),
+  }
+}

package/transport/sdk/domains/plugin.ts

@@ -0,0 +1,144 @@
+import type {
+  PluginApiFeatureInputChangedRequest,
+  PluginApiGetManifestRequest,
+  PluginApiGetManifestResponse,
+  PluginApiGetOfficialListRequest,
+  PluginApiGetOfficialListResponse,
+  PluginApiGetPathsRequest,
+  PluginApiGetPathsResponse,
+  PluginApiGetPerformanceRequest,
+  PluginApiGetPerformanceResponse,
+  PluginApiGetRequest,
+  PluginApiGetResponse,
+  PluginApiGetRuntimeStatsRequest,
+  PluginApiGetRuntimeStatsResponse,
+  PluginApiGetStatusRequest,
+  PluginApiGetStatusResponse,
+  PluginApiInstallRequest,
+  PluginApiInstallResponse,
+  PluginApiListRequest,
+  PluginApiListResponse,
+  PluginApiOpenFolderRequest,
+  PluginApiOpenPathRequest,
+  PluginApiOpenPathResponse,
+  PluginApiRevealPathRequest,
+  PluginApiRevealPathResponse,
+  PluginApiRegisterWidgetRequest,
+  PluginApiRegisterWidgetResponse,
+  PluginApiOperationRequest,
+  PluginApiOperationResponse,
+  PluginApiSaveManifestRequest,
+  PluginApiSaveManifestResponse,
+  PluginApiSaveWidgetFileRequest,
+  PluginApiSaveWidgetFileResponse,
+  PluginApiTriggerFeatureRequest,
+  PluginDevServerStatusRequest,
+  PluginDevServerStatusResponse,
+  PluginInstallConfirmPayload,
+  PluginInstallConfirmResponsePayload,
+  PluginInstallProgressPayload,
+  PluginInstallSourceRequest,
+  PluginInstallSourceResponse,
+  PluginPushStateChangedPayload,
+  PluginPushStatusUpdatedPayload,
+  PluginReconnectDevServerRequest,
+  PluginReconnectDevServerResponse,
+} from '../../events/types'
+import type { ITuffTransport } from '../../types'
+import { PluginEvents } from '../../events'
+
+export interface PluginSdk {
+  list: (request?: PluginApiListRequest) => Promise<PluginApiListResponse>
+  get: (request: PluginApiGetRequest) => Promise<PluginApiGetResponse>
+  getStatus: (request: PluginApiGetStatusRequest) => Promise<PluginApiGetStatusResponse>
+
+  enable: (request: PluginApiOperationRequest) => Promise<PluginApiOperationResponse>
+  disable: (request: PluginApiOperationRequest) => Promise<PluginApiOperationResponse>
+  reload: (request: PluginApiOperationRequest) => Promise<PluginApiOperationResponse>
+  install: (request: PluginApiInstallRequest) => Promise<PluginApiInstallResponse>
+  uninstall: (request: PluginApiOperationRequest) => Promise<PluginApiOperationResponse>
+
+  triggerFeature: (request: PluginApiTriggerFeatureRequest) => Promise<unknown>
+  registerWidget: (request: PluginApiRegisterWidgetRequest) => Promise<PluginApiRegisterWidgetResponse>
+  featureInputChanged: (request: PluginApiFeatureInputChangedRequest) => Promise<void>
+
+  openFolder: (request: PluginApiOpenFolderRequest) => Promise<void>
+
+  getOfficialList: (request?: PluginApiGetOfficialListRequest) => Promise<PluginApiGetOfficialListResponse>
+  getManifest: (request: PluginApiGetManifestRequest) => Promise<PluginApiGetManifestResponse>
+  saveManifest: (request: PluginApiSaveManifestRequest) => Promise<PluginApiSaveManifestResponse>
+  saveWidgetFile: (request: PluginApiSaveWidgetFileRequest) => Promise<PluginApiSaveWidgetFileResponse>
+  getPaths: (request: PluginApiGetPathsRequest) => Promise<PluginApiGetPathsResponse>
+  openPath: (request: PluginApiOpenPathRequest) => Promise<PluginApiOpenPathResponse>
+  revealPath: (request: PluginApiRevealPathRequest) => Promise<PluginApiRevealPathResponse>
+  getPerformance: (request: PluginApiGetPerformanceRequest) => Promise<PluginApiGetPerformanceResponse>
+  getRuntimeStats: (request: PluginApiGetRuntimeStatsRequest) => Promise<PluginApiGetRuntimeStatsResponse>
+
+  reconnectDevServer: (request: PluginReconnectDevServerRequest) => Promise<PluginReconnectDevServerResponse>
+  getDevServerStatus: (request: PluginDevServerStatusRequest) => Promise<PluginDevServerStatusResponse>
+
+  onStateChanged: (handler: (payload: PluginPushStateChangedPayload) => void) => () => void
+  onStatusUpdated: (handler: (payload: PluginPushStatusUpdatedPayload) => void) => () => void
+
+  onInstallProgress: (handler: (payload: PluginInstallProgressPayload) => void) => () => void
+  onInstallConfirm: (handler: (payload: PluginInstallConfirmPayload) => void) => () => void
+  sendInstallConfirmResponse: (payload: PluginInstallConfirmResponsePayload) => Promise<void>
+
+  installFromSource: (payload: PluginInstallSourceRequest) => Promise<PluginInstallSourceResponse>
+}
+
+export function createPluginSdk(transport: ITuffTransport): PluginSdk {
+  return {
+    list: async request => transport.send(PluginEvents.api.list, request ?? {}),
+    get: async request => transport.send(PluginEvents.api.get, request),
+    getStatus: async request => transport.send(PluginEvents.api.getStatus, request),
+
+    enable: async request => transport.send(PluginEvents.api.enable, request),
+    disable: async request => transport.send(PluginEvents.api.disable, request),
+    reload: async request => transport.send(PluginEvents.api.reload, request),
+    install: async request => transport.send(PluginEvents.api.install, request),
+    uninstall: async request => transport.send(PluginEvents.api.uninstall, request),
+
+    triggerFeature: async request => transport.send(PluginEvents.api.triggerFeature, request),
+    registerWidget: async request => transport.send(PluginEvents.api.registerWidget, request),
+    featureInputChanged: async request => transport.send(PluginEvents.api.featureInputChanged, request),
+
+    openFolder: async request => transport.send(PluginEvents.api.openFolder, request),
+
+    getOfficialList: async request => transport.send(PluginEvents.api.getOfficialList, request ?? {}),
+    getManifest: async request => transport.send(PluginEvents.api.getManifest, request),
+    saveManifest: async request => transport.send(PluginEvents.api.saveManifest, request),
+    saveWidgetFile: async request => transport.send(PluginEvents.api.saveWidgetFile, request),
+    getPaths: async request => transport.send(PluginEvents.api.getPaths, request),
+    openPath: async request => transport.send(PluginEvents.api.openPath, request),
+    revealPath: async request => transport.send(PluginEvents.api.revealPath, request),
+    getPerformance: async request => transport.send(PluginEvents.api.getPerformance, request),
+    getRuntimeStats: async request => transport.send(PluginEvents.api.getRuntimeStats, request),
+
+    reconnectDevServer: async request => transport.send(PluginEvents.devServer.reconnect, request),
+    getDevServerStatus: async request => transport.send(PluginEvents.devServer.status, request),
+
+    onStateChanged: handler =>
+      transport.on(PluginEvents.push.stateChanged, (payload) => {
+        handler(payload)
+      }),
+    onStatusUpdated: handler =>
+      transport.on(PluginEvents.push.statusUpdated, (payload) => {
+        handler(payload)
+      }),
+
+    onInstallProgress: handler =>
+      transport.on(PluginEvents.install.progress, (payload) => {
+        handler(payload)
+      }),
+    onInstallConfirm: handler =>
+      transport.on(PluginEvents.install.confirm, (payload) => {
+        handler(payload)
+      }),
+    sendInstallConfirmResponse: async (payload) => {
+      await transport.send(PluginEvents.install.confirmResponse, payload)
+    },
+
+    installFromSource: async payload => transport.send(PluginEvents.install.source, payload),
+  }
+}

package/transport/sdk/domains/settings.ts

@@ -0,0 +1,102 @@
+import type {
+  AnalyticsExportPayload,
+  AnalyticsExportResult,
+  AnalyticsMessage,
+  AnalyticsMessageListRequest,
+  AnalyticsMessageUpdateRequest,
+  AnalyticsRangeRequest,
+  AnalyticsSnapshot,
+  AnalyticsWindowType,
+} from '../../../analytics'
+import type {
+  AppIndexAddPathRequest,
+  AppIndexAddPathResult,
+  AppIndexSettings,
+} from '../../events/types/app-index'
+import type { AnalyticsToggleRequest, CurrentMetrics, PerformanceHistoryEntry, PerformanceSummary } from '../../events/types/app'
+import type { DeviceIdleSettings } from '../../events/types/device-idle'
+import type {
+  FileIndexAddPathRequest,
+  FileIndexAddPathResult,
+  FileIndexBatteryStatus,
+  FileIndexFailedFile,
+  FileIndexProgress,
+  FileIndexRebuildRequest,
+  FileIndexRebuildResult,
+  FileIndexStats,
+  FileIndexStatus,
+} from '../../events/types/file-index'
+import type { ITuffTransport, StreamController, StreamOptions } from '../../types'
+import { AppEvents } from '../../events'
+
+export interface SettingsSdk {
+  fileIndex: {
+    getStatus: () => Promise<FileIndexStatus>
+    getStats: () => Promise<FileIndexStats>
+    getBatteryLevel: () => Promise<FileIndexBatteryStatus | null>
+    rebuild: (request?: FileIndexRebuildRequest) => Promise<FileIndexRebuildResult>
+    streamProgress: (
+      options: StreamOptions<FileIndexProgress>,
+    ) => Promise<StreamController>
+    getFailedFiles: () => Promise<FileIndexFailedFile[]>
+    addPath: (payload: FileIndexAddPathRequest) => Promise<FileIndexAddPathResult>
+  }
+  deviceIdle: {
+    getSettings: () => Promise<DeviceIdleSettings>
+    updateSettings: (settings: Partial<DeviceIdleSettings>) => Promise<DeviceIdleSettings>
+  }
+  appIndex: {
+    getSettings: () => Promise<AppIndexSettings>
+    updateSettings: (settings: Partial<AppIndexSettings>) => Promise<AppIndexSettings>
+    addPath: (payload: AppIndexAddPathRequest) => Promise<AppIndexAddPathResult>
+  }
+  analytics: {
+    getSnapshot: (windowType: AnalyticsWindowType) => Promise<AnalyticsSnapshot>
+    getRange: (payload: AnalyticsRangeRequest) => Promise<AnalyticsSnapshot[]>
+    export: (payload: AnalyticsExportPayload) => Promise<AnalyticsExportResult>
+    toggleReporting: (payload: AnalyticsToggleRequest) => Promise<{ enabled: boolean }>
+    getCurrent: () => Promise<CurrentMetrics>
+    getHistory: () => Promise<PerformanceHistoryEntry[]>
+    getSummary: () => Promise<PerformanceSummary>
+    messages: {
+      list: (payload?: AnalyticsMessageListRequest) => Promise<AnalyticsMessage[]>
+      mark: (payload: AnalyticsMessageUpdateRequest) => Promise<AnalyticsMessage | null>
+    }
+  }
+}
+
+export function createSettingsSdk(transport: ITuffTransport): SettingsSdk {
+  return {
+    fileIndex: {
+      getStatus: () => transport.send(AppEvents.fileIndex.status),
+      getStats: () => transport.send(AppEvents.fileIndex.stats),
+      getBatteryLevel: () => transport.send(AppEvents.fileIndex.batteryLevel),
+      rebuild: request => transport.send(AppEvents.fileIndex.rebuild, request),
+      streamProgress: options => transport.stream(AppEvents.fileIndex.progress, undefined, options),
+      getFailedFiles: () => transport.send(AppEvents.fileIndex.failedFiles),
+      addPath: payload => transport.send(AppEvents.fileIndex.addPath, payload),
+    },
+    deviceIdle: {
+      getSettings: () => transport.send(AppEvents.deviceIdle.getSettings),
+      updateSettings: settings => transport.send(AppEvents.deviceIdle.updateSettings, settings),
+    },
+    appIndex: {
+      getSettings: () => transport.send(AppEvents.appIndex.getSettings),
+      updateSettings: settings => transport.send(AppEvents.appIndex.updateSettings, settings),
+      addPath: payload => transport.send(AppEvents.appIndex.addPath, payload),
+    },
+    analytics: {
+      getSnapshot: windowType => transport.send(AppEvents.analytics.getSnapshot, { windowType }),
+      getRange: payload => transport.send(AppEvents.analytics.getRange, payload),
+      export: payload => transport.send(AppEvents.analytics.export, payload),
+      toggleReporting: payload => transport.send(AppEvents.analytics.toggleReporting, payload),
+      getCurrent: () => transport.send(AppEvents.analytics.getCurrent),
+      getHistory: () => transport.send(AppEvents.analytics.getHistory),
+      getSummary: () => transport.send(AppEvents.analytics.getSummary),
+      messages: {
+        list: payload => transport.send(AppEvents.analytics.messages.list, payload ?? {}),
+        mark: payload => transport.send(AppEvents.analytics.messages.mark, payload),
+      },
+    },
+  }
+}

package/transport/sdk/domains/update.ts

@@ -0,0 +1,64 @@
+import type { AppPreviewChannel, CachedUpdateRecord, GitHubRelease, UpdateCheckResult, UpdateSettings, UpdateUserAction } from '../../../types/update'
+import type {
+  UpdateAvailablePayload,
+  UpdateCheckResponse,
+  UpdateGetCachedReleaseResponse,
+  UpdateGetSettingsResponse,
+  UpdateGetStatusResponse,
+  UpdateIgnoreVersionRequest,
+  UpdateInstallRequest,
+  UpdateOpResponse,
+} from '../../events/types/update'
+import type { ITuffTransport } from '../../types'
+import { UpdateEvents } from '../../events'
+
+export interface UpdateSdk {
+  check: (payload?: { force?: boolean }) => Promise<UpdateCheckResponse>
+  getSettings: () => Promise<UpdateGetSettingsResponse>
+  updateSettings: (settings: Partial<UpdateSettings>) => Promise<UpdateOpResponse>
+  getStatus: () => Promise<UpdateGetStatusResponse>
+  clearCache: () => Promise<UpdateOpResponse>
+  getCachedRelease: (payload?: { channel?: AppPreviewChannel }) => Promise<UpdateGetCachedReleaseResponse>
+  recordAction: (payload: { tag: string, action: UpdateUserAction }) => Promise<UpdateOpResponse>
+  download: (release: GitHubRelease) => Promise<UpdateOpResponse<{ taskId?: string }>>
+  install: (payload: UpdateInstallRequest) => Promise<UpdateOpResponse>
+  ignoreVersion: (payload: UpdateIgnoreVersionRequest) => Promise<UpdateOpResponse>
+  setAutoDownload: (enabled: boolean) => Promise<UpdateOpResponse>
+  setAutoCheck: (enabled: boolean) => Promise<UpdateOpResponse>
+  onAvailable: (handler: (payload: UpdateAvailablePayload) => void) => () => void
+}
+
+export function createUpdateSdk(transport: ITuffTransport): UpdateSdk {
+  return {
+    check: payload => transport.send(UpdateEvents.check, payload ?? {}),
+    getSettings: () => transport.send(UpdateEvents.getSettings),
+    updateSettings: settings => transport.send(UpdateEvents.updateSettings, { settings }),
+    getStatus: () => transport.send(UpdateEvents.getStatus),
+    clearCache: () => transport.send(UpdateEvents.clearCache),
+    getCachedRelease: payload => transport.send(UpdateEvents.getCachedRelease, payload ?? {}),
+    recordAction: payload => transport.send(UpdateEvents.recordAction, payload),
+    download: release => transport.send(UpdateEvents.download, release),
+    install: payload => transport.send(UpdateEvents.install, payload),
+    ignoreVersion: payload => transport.send(UpdateEvents.ignoreVersion, payload),
+    setAutoDownload: enabled => transport.send(UpdateEvents.setAutoDownload, { enabled }),
+    setAutoCheck: enabled => transport.send(UpdateEvents.setAutoCheck, { enabled }),
+    onAvailable: handler => transport.on(UpdateEvents.available, handler),
+  }
+}
+
+export type {
+  UpdateAvailablePayload,
+  UpdateCheckResponse,
+  UpdateGetCachedReleaseResponse,
+  UpdateGetSettingsResponse,
+  UpdateGetStatusResponse,
+  UpdateOpResponse,
+}
+
+export type {
+  AppPreviewChannel,
+  CachedUpdateRecord,
+  UpdateCheckResult,
+  UpdateSettings,
+  UpdateUserAction,
+}

package/transport/sdk/index.ts

@@ -0,0 +1,60 @@
+/**
+ * @fileoverview TuffTransport SDK entry point
+ * @module @talex-touch/utils/transport/sdk
+ */
+
+import type { ITuffTransport } from '../types'
+import { createPluginTuffTransport } from './plugin-transport'
+import { TuffRendererTransport } from './renderer-transport'
+
+export * from './domains'
+
+// Singleton instance for renderer transport
+let rendererTransportInstance: ITuffTransport | null = null
+
+/**
+ * Gets or creates the singleton TuffTransport instance for renderer processes.
+ *
+ * @returns The TuffTransport instance
+ *
+ * @example
+ * ```typescript
+ * import { useTuffTransport } from '@talex-touch/utils/transport'
+ * import { ClipboardEvents } from '@talex-touch/utils/transport/events'
+ *
+ * const transport = useTuffTransport()
+ * const latest = await transport.send(ClipboardEvents.getLatest)
+ * ```
+ */
+export function useTuffTransport(): ITuffTransport {
+  if (!rendererTransportInstance) {
+    rendererTransportInstance = new TuffRendererTransport()
+  }
+  return rendererTransportInstance
+}
+
+/**
+ * Creates a new TuffTransport instance for renderer processes.
+ *
+ * @param module - Optional module name for namespacing (currently unused, reserved for future use)
+ * @returns A new TuffTransport instance
+ *
+ * @remarks
+ * In most cases, you should use `useTuffTransport()` instead to get the singleton instance.
+ * This function is useful when you need multiple isolated transport instances.
+ *
+ * @example
+ * ```typescript
+ * import { createTuffRendererTransport } from '@talex-touch/utils/transport'
+ *
+ * const transport = createTuffRendererTransport('clipboard')
+ * ```
+ */
+export function createTuffRendererTransport(module?: string): ITuffTransport {
+  // Module parameter is reserved for future namespacing
+  void module
+  // For now, we create a new instance
+  return new TuffRendererTransport()
+}
+
+export { createPluginTuffTransport }