feat(runtime): 即梦本机运行时 - 接入安全生成闭环与桌面本机渠道

Refs #225

Co-authored-by: zkhyww <127009345+zkhyww@users.noreply.github.com>

web/src/pages/create/creation-assets.ts

@@ -1,10 +1,12 @@
 import type { UploadedFile } from "@/services/file-storage";
 import type { UploadedImage } from "@/services/image-storage";
-import type { Asset, ImageAsset, NewAsset } from "@/stores/use-asset-store";
+import type { Asset, AudioAsset, ImageAsset, NewAsset } from "@/stores/use-asset-store";
 import type { ReferenceImage } from "@/types/image";
-import type { ReferenceVideo } from "@/types/media";
+import type { ReferenceAudio, ReferenceVideo } from "@/types/media";
 
-export type CreationAttachment = (ReferenceImage | ReferenceVideo) & { previewUrl: string };
+export type CreationAttachment = (ReferenceImage | ReferenceVideo | ReferenceAudio) & { previewUrl: string };
+export type CreationMode = "text" | "image" | "video";
+export type CreationAttachmentKind = "image" | "video" | "audio";
 
 export type CreationAssetIdentity = {
     taskId?: string;
@@ -12,6 +14,38 @@ export type CreationAssetIdentity = {
     resultIndex?: number;
 };
 
+export function creationUploadAccept(mode: CreationMode) {
+    return mode === "video" ? "image/*,video/*,audio/*" : "image/*";
+}
+
+export function creationFileAccepted(mode: CreationMode, file: Pick<File, "type">) {
+    return file.type.startsWith("image/") || (mode === "video" && (file.type.startsWith("video/") || file.type.startsWith("audio/")));
+}
+
+export function creationAttachmentKind(attachment: Pick<CreationAttachment, "type">): CreationAttachmentKind {
+    if (attachment.type.startsWith("video/")) return "video";
+    if (attachment.type.startsWith("audio/")) return "audio";
+    return "image";
+}
+
+export function splitCreationAttachments(attachments: CreationAttachment[]) {
+    return {
+        referenceImages: attachments.filter((attachment): attachment is CreationAttachment & ReferenceImage => creationAttachmentKind(attachment) === "image"),
+        referenceVideos: attachments.filter((attachment): attachment is CreationAttachment & ReferenceVideo => creationAttachmentKind(attachment) === "video"),
+        referenceAudios: attachments.filter((attachment): attachment is CreationAttachment & ReferenceAudio => creationAttachmentKind(attachment) === "audio"),
+    };
+}
+
+export function creationAttachmentPreview(attachment: CreationAttachment): { kind: CreationAttachmentKind; url: string } {
+    const kind = creationAttachmentKind(attachment);
+    const url = kind === "image" ? attachment.previewUrl || ("dataUrl" in attachment ? attachment.dataUrl : attachment.url) || "" : attachment.url || attachment.previewUrl;
+    return { kind, url };
+}
+
+export function removeCreationAttachment<T extends { id: string }>(attachments: T[], id: string) {
+    return attachments.filter((attachment) => attachment.id !== id);
+}
+
 export function creationAssetKey(identity: CreationAssetIdentity): string | undefined {
     const taskId = identity.taskId?.trim();
     const messageId = identity.messageId?.trim();
@@ -61,6 +95,19 @@ export function creationAttachmentFromVideo(file: File, uploaded: UploadedFile):
     };
 }
 
+export function creationAttachmentFromAudio(file: File, uploaded: UploadedFile): CreationAttachment {
+    return {
+        id: `upload:${file.name}:${uploaded.storageKey}`,
+        name: file.name,
+        type: uploaded.mimeType || file.type || "audio/mpeg",
+        url: uploaded.url,
+        storageKey: uploaded.storageKey,
+        bytes: uploaded.bytes,
+        durationMs: uploaded.durationMs,
+        previewUrl: uploaded.url,
+    };
+}
+
 export function creationAttachmentFromAsset(asset: ImageAsset): CreationAttachment {
     const url = asset.data.dataUrl || asset.coverUrl;
     return {
@@ -92,6 +139,19 @@ export function creationAttachmentFromVideoAsset(asset: Extract<Asset, { kind: "
     };
 }
 
+export function creationAttachmentFromAudioAsset(asset: AudioAsset): CreationAttachment {
+    return {
+        id: `asset:${asset.id}`,
+        name: asset.title || "素材音频",
+        type: asset.data.mimeType || "audio/mpeg",
+        url: asset.data.url,
+        storageKey: asset.data.storageKey,
+        bytes: asset.data.bytes,
+        durationMs: asset.data.durationMs,
+        previewUrl: asset.data.url,
+    };
+}
+
 export function creationImageAsset({ title, uploaded, metadata }: { title: string; uploaded: UploadedImage; metadata?: Record<string, unknown> }): NewAsset {
     return {
         kind: "image",
@@ -112,6 +172,25 @@ export function creationImageAsset({ title, uploaded, metadata }: { title: strin
     };
 }
 
+export function creationAudioAsset({ title, uploaded, metadata }: { title: string; uploaded: UploadedFile; metadata?: Record<string, unknown> }): NewAsset {
+    return {
+        kind: "audio",
+        title: title.trim() || "创作音频",
+        coverUrl: "",
+        tags: ["创作"],
+        status: "confirmed",
+        source: "创作页",
+        metadata: { source: "create-page", ...metadata },
+        data: {
+            url: uploaded.url,
+            storageKey: uploaded.storageKey,
+            durationMs: uploaded.durationMs,
+            bytes: uploaded.bytes,
+            mimeType: uploaded.mimeType || "audio/mpeg",
+        },
+    };
+}
+
 export function creationVideoAsset({ title, uploaded, metadata }: { title: string; uploaded: UploadedFile; metadata?: Record<string, unknown> }): NewAsset {
     return {
         kind: "video",