diff --git a/src/main/index.ts b/src/main/index.ts index 94cfa0e52..ac8fc6b0d 100644 --- a/src/main/index.ts +++ b/src/main/index.ts @@ -32,6 +32,7 @@ import { flushLastSessionSync, recordDashboardSurface } from './lib/lastSession' import { registerProcessErrorHandlers } from './lib/processErrorHandlers' import { registerAppsIpc } from './apps/appsView' import { initAppsSwitch, isAppsEnabled } from './apps/appsSwitch' +import { registerOutputFilesScheme, registerOutputFolderHandlers } from './lib/outputFolders' import { initAppLog, flushOperationOutput } from './lib/appLog' import { pruneCrashDumps } from './lib/crashDumps' import { createStartupReentryGate } from './lib/startupReentryGate' @@ -194,6 +195,8 @@ if (settings.get('hardwareAcceleration') === false) { app.disableHardwareAcceleration() } +registerOutputFilesScheme() + todesktop.init({ autoUpdater: false }) const APP_VERSION = getAppVersion() @@ -937,6 +940,7 @@ if (app.isPackaged && !app.requestSingleInstanceLock()) { setHostFactories({ createChooser: openChooserHostWindow }) registerPanelViewIpc() registerAppsIpc() + registerOutputFolderHandlers() migrateXdgPaths() persistWinDataRootChoice() diff --git a/src/main/lib/ipc/sessionActions/launch.ts b/src/main/lib/ipc/sessionActions/launch.ts index ec4028df4..f400ad996 100644 --- a/src/main/lib/ipc/sessionActions/launch.ts +++ b/src/main/lib/ipc/sessionActions/launch.ts @@ -167,6 +167,7 @@ import { writeCampaignRecord } from '../../coreBetaCampaignFlags' import { getIdClass } from '../../deviceId' +import { outputDirOverride } from '../../outputFolders' import type { ComfyArgsSchema } from '../../comfy-args' export function desktopFeatureFlags( @@ -512,7 +513,6 @@ export function applyStorageLaunchArgs( } if (argsAvailable) { const useSharedInput = (inst.useSharedInput as boolean | undefined) !== false - const useSharedOutput = (inst.useSharedOutput as boolean | undefined) !== false if (useSharedInput) { const inputDir = storage.inputDir || settings.defaults.inputDir fs.mkdirSync(inputDir, { recursive: true }) @@ -524,16 +524,10 @@ export function applyStorageLaunchArgs( launchCmd.args!.push('--input-directory', perInstallInput) } } - if (useSharedOutput) { - const outputDir = storage.outputDir || settings.defaults.outputDir + const outputDir = outputDirOverride(inst, storage.outputDir || settings.defaults.outputDir) + if (outputDir) { fs.mkdirSync(outputDir, { recursive: true }) launchCmd.args!.push('--output-directory', outputDir) - } else { - const perInstallOutput = inst.outputDir as string | undefined - if (perInstallOutput) { - fs.mkdirSync(perInstallOutput, { recursive: true }) - launchCmd.args!.push('--output-directory', perInstallOutput) - } } } diff --git a/src/main/lib/outputFolders.test.ts b/src/main/lib/outputFolders.test.ts new file mode 100644 index 000000000..89714f45f --- /dev/null +++ b/src/main/lib/outputFolders.test.ts @@ -0,0 +1,276 @@ +import fs from 'node:fs' +import path from 'node:path' +import { afterAll, beforeEach, describe, expect, it, vi } from 'vitest' + +const { + root, + sharedDir, + ownDir, + installDir, + outsideDir, + installs, + fetchFile, + thumbnailImage, + fullImage +} = await vi.hoisted(async () => { + const nodeFs = await import('node:fs') + const nodeOs = await import('node:os') + const nodePath = await import('node:path') + const base = nodeFs.realpathSync( + nodeFs.mkdtempSync(nodePath.join(nodeOs.tmpdir(), 'output-folders-')) + ) + return { + root: base, + sharedDir: nodePath.join(base, 'shared-output'), + ownDir: nodePath.join(base, 'own-output'), + installDir: nodePath.join(base, 'install'), + outsideDir: nodePath.join(base, 'outside'), + installs: vi.fn(), + fetchFile: vi.fn(async (url: string) => new Response(`file ${url}`)), + thumbnailImage: vi.fn(), + fullImage: vi.fn() + } +}) + +vi.mock('electron', () => ({ + ipcMain: { handle: vi.fn() }, + protocol: { handle: vi.fn(), registerSchemesAsPrivileged: vi.fn() }, + net: { fetch: (url: string) => fetchFile(url) }, + nativeImage: { + createThumbnailFromPath: (file: string) => thumbnailImage(file), + createFromPath: (file: string) => fullImage(file) + } +})) +vi.mock('../installations', () => ({ list: () => installs() })) +vi.mock('../settings', () => ({ + get: (key: string) => (key === 'outputDir' ? sharedDir : undefined), + defaults: { outputDir: path.join(root, 'default-output') } +})) +vi.mock('./ipc/shared', () => ({ + sourceMap: { + standalone: { category: 'local', getLaunchCommand: () => ({ cmd: 'python' }) }, + desktop: { + category: 'local', + getLaunchCommand: () => ({ cmd: 'open', skipSharedPaths: true }) + }, + cloud: { category: 'cloud' } + } +})) +vi.mock('./models', () => ({ + installOutputDir: (installPath: string) => path.join(installPath, 'ComfyUI', 'output') +})) +vi.mock('./assets', () => ({ + assetKind: (name: string) => + ({ png: 'image', mp4: 'video', wav: 'audio', glb: '3d' })[name.split('.').pop() ?? ''] ?? null +})) + +import type { InstallationRecord } from '../installations' +import { + MAX_FILES, + listOutputFolder, + listOutputFolders, + outputDirOverride, + outputFileUrl, + serveOutputFile +} from './outputFolders' + +function install(name: string, extra: Record = {}): InstallationRecord { + return { + id: name, + name, + sourceId: 'standalone', + installPath: installDir, + createdAt: '2026-11-01T00:00:00Z', + ...extra + } +} + +function write(file: string, body = 'x', modified = new Date('2026-11-01T00:00:00Z')): void { + fs.mkdirSync(path.dirname(file), { recursive: true }) + fs.writeFileSync(file, body) + fs.utimesSync(file, modified, modified) +} + +beforeEach(() => { + vi.clearAllMocks() + for (const dir of [sharedDir, ownDir, outsideDir, path.join(installDir, 'ComfyUI', 'output')]) + fs.mkdirSync(dir, { recursive: true }) + installs.mockResolvedValue([ + install('Test Instance'), + install('My Local 1'), + install('Apps', { useSharedOutput: false, outputDir: ownDir }), + install('Bare', { useSharedOutput: false }), + install('Cloud', { sourceId: 'cloud' }), + install('Old Desktop', { sourceId: 'desktop' }) + ]) +}) + +afterAll(() => fs.rmSync(root, { recursive: true, force: true })) + +describe('outputDirOverride', () => { + it('uses the shared folder unless the build turned sharing off', () => { + expect(outputDirOverride(install('a'), sharedDir)).toBe(sharedDir) + expect( + outputDirOverride(install('a', { useSharedOutput: false, outputDir: ownDir }), sharedDir) + ).toBe(ownDir) + expect(outputDirOverride(install('a', { useSharedOutput: false }), sharedDir)).toBeNull() + }) +}) + +describe('listOutputFolders', () => { + it('lists each output folder once with the local builds that save there', async () => { + expect(await listOutputFolders()).toEqual([ + { path: sharedDir, shared: true, builds: ['Test Instance', 'My Local 1'] }, + { path: ownDir, shared: false, builds: ['Apps'] }, + { path: path.join(installDir, 'ComfyUI', 'output'), shared: false, builds: ['Bare'] } + ]) + }) + + it('leaves out folders that do not exist yet', async () => { + installs.mockResolvedValue([ + install('Gone', { useSharedOutput: false, outputDir: path.join(root, 'missing') }) + ]) + expect(await listOutputFolders()).toEqual([{ path: sharedDir, shared: true, builds: [] }]) + }) +}) + +describe('listOutputFolder', () => { + it('lists folders and media files newest first, with links that change when a file does', async () => { + write(path.join(sharedDir, 'old.png'), 'x', new Date('2026-10-01T00:00:00Z')) + write(path.join(sharedDir, 'new.mp4'), 'xx', new Date('2026-11-05T00:00:00Z')) + write(path.join(sharedDir, 'notes.txt')) + write(path.join(sharedDir, '.hidden.png')) + fs.mkdirSync(path.join(sharedDir, 'apps'), { recursive: true }) + await listOutputFolders() + + const listing = await listOutputFolder(sharedDir) + + expect(listing!.truncated).toBe(false) + expect(listing!.entries.map((e) => e.name)).not.toContain('.hidden.png') + const byName = Object.fromEntries(listing!.entries.map((e) => [e.name, e])) + expect(byName['apps']).toMatchObject({ + isFolder: true, + kind: null, + sizeBytes: null, + previewUrl: null + }) + expect(byName['new.mp4']).toMatchObject({ + isFolder: false, + kind: 'video', + sizeBytes: 2, + previewUrl: outputFileUrl(path.join(sharedDir, 'new.mp4')), + thumbnailUrl: outputFileUrl( + path.join(sharedDir, 'new.mp4'), + fs.statSync(path.join(sharedDir, 'new.mp4')).mtimeMs + ) + }) + expect(byName['notes.txt']).toBeUndefined() + const files = listing!.entries.filter((e) => !e.isFolder).map((e) => e.name) + expect(files.indexOf('new.mp4')).toBeLessThan(files.indexOf('old.png')) + }) + + it('keeps every subfolder and only the newest files when a folder is very large', async () => { + const big = path.join(sharedDir, 'big') + fs.mkdirSync(path.join(big, 'old-folder'), { recursive: true }) + fs.utimesSync(path.join(big, 'old-folder'), new Date('2020-01-01'), new Date('2020-01-01')) + for (let i = 0; i <= MAX_FILES; i++) fs.writeFileSync(path.join(big, `f${i}.png`), '') + await listOutputFolders() + + const listing = await listOutputFolder(big) + + expect(listing!.truncated).toBe(true) + expect(listing!.entries.filter((e) => e.isFolder).map((e) => e.name)).toEqual(['old-folder']) + expect(listing!.entries.filter((e) => !e.isFolder)).toHaveLength(MAX_FILES) + fs.rmSync(big, { recursive: true }) + }) + + it('refuses folders outside the output folders, and links that climb out of them', async () => { + write(path.join(outsideDir, 'secret.png')) + fs.symlinkSync(outsideDir, path.join(sharedDir, 'escape')) + await listOutputFolders() + + expect(await listOutputFolder(outsideDir)).toBeNull() + expect(await listOutputFolder(path.join(sharedDir, '..', 'outside'))).toBeNull() + expect(await listOutputFolder(path.join(sharedDir, 'escape'))).toBeNull() + expect(await listOutputFolder('relative/path')).toBeNull() + expect(await listOutputFolder(42)).toBeNull() + fs.rmSync(path.join(sharedDir, 'escape')) + }) +}) + +describe('serveOutputFile', () => { + it('serves a file inside an output folder and refuses one outside', async () => { + write(path.join(sharedDir, 'picture.png')) + write(path.join(outsideDir, 'secret.png')) + await listOutputFolders() + + const ok = await serveOutputFile( + new Request(outputFileUrl(path.join(sharedDir, 'picture.png'))) + ) + expect(ok.status).toBe(200) + expect(fetchFile).toHaveBeenCalledWith(expect.stringMatching(/^file:\/\/.*picture\.png$/)) + + expect(ok.headers.get('X-Content-Type-Options')).toBe('nosniff') + expect(ok.headers.get('Content-Security-Policy')).toBe('sandbox') + + const refused = await serveOutputFile( + new Request(outputFileUrl(path.join(outsideDir, 'secret.png'))) + ) + expect(refused.status).toBe(404) + expect(fetchFile).toHaveBeenCalledOnce() + }) + + it('answers 404 for files it does not show, broken addresses and files that are gone', async () => { + write(path.join(sharedDir, 'page.html')) + write(path.join(sharedDir, 'gone.png')) + await listOutputFolders() + + const html = await serveOutputFile( + new Request(outputFileUrl(path.join(sharedDir, 'page.html'))) + ) + expect(html.status).toBe(404) + const broken = await serveOutputFile(new Request('comfy-output://file/%')) + expect(broken.status).toBe(404) + fetchFile.mockRejectedValueOnce(new Error('ENOENT')) + const gone = await serveOutputFile(new Request(outputFileUrl(path.join(sharedDir, 'gone.png')))) + expect(gone.status).toBe(404) + }) + + it('serves a small JPEG thumbnail and answers 404 when none can be made', async () => { + write(path.join(sharedDir, 'thumb.png')) + await listOutputFolders() + const resize = vi.fn(() => ({ toJPEG: () => Buffer.from('small') })) + const big = { isEmpty: () => false, getSize: () => ({ width: 2000, height: 1000 }), resize } + thumbnailImage.mockResolvedValueOnce(big) + fullImage.mockReturnValueOnce(big) + + const thumb = await serveOutputFile( + new Request(outputFileUrl(path.join(sharedDir, 'thumb.png'), 1)) + ) + expect(thumb.headers.get('Content-Type')).toBe('image/jpeg') + expect(await thumb.text()).toBe('small') + expect(resize).toHaveBeenCalledWith({ width: 480, height: 240 }) + expect(thumb.headers.get('X-Content-Type-Options')).toBe('nosniff') + + write(path.join(sharedDir, 'blank.png')) + const blank = { + isEmpty: () => false, + getSize: () => ({ width: 10, height: 10 }), + toJPEG: () => Buffer.alloc(0) + } + thumbnailImage.mockResolvedValueOnce(blank) + fullImage.mockReturnValueOnce(blank) + const empty = await serveOutputFile( + new Request(outputFileUrl(path.join(sharedDir, 'blank.png'), 1)) + ) + expect(empty.status).toBe(404) + + write(path.join(sharedDir, 'broken.png')) + thumbnailImage.mockRejectedValueOnce(new Error('no thumbnail')) + fullImage.mockReturnValueOnce({ isEmpty: () => true }) + const none = await serveOutputFile( + new Request(outputFileUrl(path.join(sharedDir, 'broken.png'), 1)) + ) + expect(none.status).toBe(404) + }) +}) diff --git a/src/main/lib/outputFolders.ts b/src/main/lib/outputFolders.ts new file mode 100644 index 000000000..187dc2009 --- /dev/null +++ b/src/main/lib/outputFolders.ts @@ -0,0 +1,237 @@ +import fsp from 'fs/promises' +import path from 'path' +import { pathToFileURL } from 'url' +import { ipcMain, nativeImage, net, protocol } from 'electron' +import * as installations from '../installations' +import type { InstallationRecord } from '../installations' +import * as settings from '../settings' +import { isInside } from '../apps/guards' +import { assetKind } from './assets' +import { runPool } from '../sources/standalone/templateDownloadCore' +import { installOutputDir } from './models' +import { sourceMap } from './ipc/shared' +import type { OutputEntry, OutputFolder, OutputFolderListing } from '../../types/ipc' + +export const OUTPUT_FILES_SCHEME = 'comfy-output' + +const LIST_FOLDERS_CHANNEL = 'assets:output-folders' +const LIST_FOLDER_CHANNEL = 'assets:output-folder' +export const MAX_FILES = 2000 +const THUMBNAIL_SIZE = 480 +const MAX_CACHED_THUMBNAILS = 400 +const THUMBNAILS_AT_ONCE = 2 +const STATS_AT_ONCE = 32 +const ROOTS_FRESH_MS = 5000 +const MAX_LINUX_THUMBNAIL_SOURCE_BYTES = 40 * 1024 * 1024 +const SERVED_KINDS = new Set(['image', 'video', 'audio']) + +const thumbnails = new Map() +const thumbnailQueue: (() => void)[] = [] +let thumbnailsRunning = 0 +let allowedRoots: string[] = [] +let allowedRootsAt = 0 + +export function sharedOutputDir(): string { + return (settings.get('outputDir') as string | undefined) || settings.defaults.outputDir +} + +export function outputDirOverride(inst: InstallationRecord, sharedDir: string): string | null { + if ((inst.useSharedOutput as boolean | undefined) !== false) return sharedDir + return (inst.outputDir as string | undefined) || null +} + +function outputDirFor(inst: InstallationRecord, sharedDir: string): string | null { + const source = sourceMap[inst.sourceId] + if (source?.category !== 'local' || source.getLaunchCommand(inst)?.skipSharedPaths) return null + return outputDirOverride(inst, sharedDir) ?? installOutputDir(inst.installPath) +} + +async function realDir(dir: string): Promise { + const real = await fsp.realpath(dir).catch(() => null) + if (!real) return null + const stat = await fsp.stat(real).catch(() => null) + return stat?.isDirectory() ? real : null +} + +export async function listOutputFolders(): Promise { + const shared = sharedOutputDir() + const sharedReal = await realDir(shared) + const byPath = new Map() + if (sharedReal) byPath.set(sharedReal, { path: sharedReal, shared: true, builds: [] }) + for (const inst of await installations.list()) { + const dir = outputDirFor(inst, shared) + const real = dir ? await realDir(dir) : null + if (!real) continue + const folder = byPath.get(real) ?? { path: real, shared: false, builds: [] } + folder.builds.push(inst.name) + byPath.set(real, folder) + } + allowedRoots = [...byPath.keys()] + allowedRootsAt = Date.now() + return [...byPath.values()] +} + +async function allowedPath(target: string): Promise { + if (!path.isAbsolute(target)) return null + if (Date.now() - allowedRootsAt > ROOTS_FRESH_MS) await listOutputFolders() + const real = await fsp.realpath(target).catch(() => null) + if (!real) return null + return allowedRoots.some((root) => real === root || isInside(real, root, path.sep)) ? real : null +} + +export function outputFileUrl(file: string, thumbnailOf?: number): string { + const url = `${OUTPUT_FILES_SCHEME}://file/${encodeURIComponent(file)}` + return thumbnailOf === undefined ? url : `${url}?thumbnail=${Math.round(thumbnailOf)}` +} + +export async function listOutputFolder(target: unknown): Promise { + if (typeof target !== 'string') return null + const dir = await allowedPath(target) + if (!dir) return null + const names = await fsp.readdir(dir, { withFileTypes: true }).catch(() => null) + if (!names) return null + const candidates = names.filter( + (dirent) => + !dirent.name.startsWith('.') && + (dirent.isDirectory() || dirent.isSymbolicLink() || assetKind(dirent.name) !== null) + ) + const found: OutputEntry[] = [] + await runPool(candidates, STATS_AT_ONCE, async (dirent) => { + const full = path.join(dir, dirent.name) + const stat = await fsp.stat(full).catch(() => null) + if (!stat) return + const isFolder = stat.isDirectory() + const kind = isFolder ? null : assetKind(dirent.name) + if (!isFolder && !kind) return + const modifiedMs = Number.isFinite(stat.mtimeMs) ? stat.mtimeMs : 0 + found.push({ + name: dirent.name, + path: full, + isFolder, + kind, + sizeBytes: isFolder ? null : stat.size, + modifiedAt: new Date(modifiedMs).toISOString(), + previewUrl: kind && SERVED_KINDS.has(kind) ? outputFileUrl(full) : null, + thumbnailUrl: kind === 'image' || kind === 'video' ? outputFileUrl(full, modifiedMs) : null + }) + }) + const files = found + .filter((entry) => !entry.isFolder) + .sort((a, b) => b.modifiedAt.localeCompare(a.modifiedAt)) + return { + entries: [...found.filter((entry) => entry.isFolder), ...files.slice(0, MAX_FILES)], + truncated: files.length > MAX_FILES + } +} + +function linuxThumbnailSource(file: string, sizeBytes: number): Electron.NativeImage | null { + if (assetKind(file) !== 'image' || sizeBytes > MAX_LINUX_THUMBNAIL_SOURCE_BYTES) return null + try { + return nativeImage.createFromPath(file) + } catch { + return null + } +} + +async function makeThumbnail(file: string, sizeBytes: number): Promise { + const size = { width: THUMBNAIL_SIZE, height: THUMBNAIL_SIZE } + const image = + process.platform === 'linux' + ? linuxThumbnailSource(file, sizeBytes) + : await nativeImage.createThumbnailFromPath(file, size).catch(() => null) + if (!image || image.isEmpty()) return null + const { width, height } = image.getSize() + const scale = Math.min(1, THUMBNAIL_SIZE / Math.max(width, height)) + const scaled = + scale < 1 + ? image.resize({ + width: Math.max(1, Math.round(width * scale)), + height: Math.max(1, Math.round(height * scale)) + }) + : image + const jpeg = scaled.toJPEG(82) + return jpeg.length > 0 ? jpeg : null +} + +async function fewAtATime(work: () => Promise): Promise { + while (thumbnailsRunning >= THUMBNAILS_AT_ONCE) + await new Promise((resolve) => thumbnailQueue.push(resolve)) + thumbnailsRunning++ + try { + return await work() + } finally { + thumbnailsRunning-- + thumbnailQueue.shift()?.() + } +} + +async function thumbnailFor(file: string): Promise { + const stat = await fsp.stat(file).catch(() => null) + if (!stat) return null + const key = `${file}\n${stat.mtimeMs}` + const cached = thumbnails.get(key) + if (cached) return cached + const made = await fewAtATime(() => makeThumbnail(file, stat.size)) + if (!made) return null + thumbnails.set(key, made) + if (thumbnails.size > MAX_CACHED_THUMBNAILS) thumbnails.delete(thumbnails.keys().next().value!) + return made +} + +function decodedPath(url: URL): string | null { + if (url.host !== 'file') return null + try { + return decodeURIComponent(url.pathname.slice(1)) + } catch { + return null + } +} + +async function fetchFile(file: string, request: Request): Promise { + const res = await net + .fetch(pathToFileURL(file).toString(), { headers: request.headers }) + .catch(() => null) + if (!res) return notFound() + const headers = new Headers(res.headers) + headers.set('X-Content-Type-Options', 'nosniff') + headers.set('Content-Security-Policy', 'sandbox') + return new Response(res.body, { status: res.status, statusText: res.statusText, headers }) +} + +function notFound(): Response { + return new Response(null, { status: 404 }) +} + +export async function serveOutputFile(request: Request): Promise { + const url = new URL(request.url) + const target = decodedPath(url) + const kind = target ? assetKind(target) : null + const file = target && kind && SERVED_KINDS.has(kind) ? await allowedPath(target) : null + if (!file) return notFound() + if (!url.searchParams.has('thumbnail')) return fetchFile(file, request) + const jpeg = await thumbnailFor(file) + return jpeg + ? new Response(new Uint8Array(jpeg), { + headers: { + 'Content-Type': 'image/jpeg', + 'Cache-Control': 'private, max-age=3600', + 'X-Content-Type-Options': 'nosniff' + } + }) + : notFound() +} + +export function registerOutputFilesScheme(): void { + protocol.registerSchemesAsPrivileged([ + { + scheme: OUTPUT_FILES_SCHEME, + privileges: { standard: true, secure: true, stream: true } + } + ]) +} + +export function registerOutputFolderHandlers(): void { + protocol.handle(OUTPUT_FILES_SCHEME, serveOutputFile) + ipcMain.handle(LIST_FOLDERS_CHANNEL, () => listOutputFolders()) + ipcMain.handle(LIST_FOLDER_CHANNEL, (_event, target: unknown) => listOutputFolder(target)) +} diff --git a/src/preload/api.ts b/src/preload/api.ts index 7119a9189..db2c4f421 100644 --- a/src/preload/api.ts +++ b/src/preload/api.ts @@ -99,6 +99,8 @@ export function buildElectronApi(): ElectronApi { signalOverlayReady: () => ipcRenderer.send('comfy-window:overlay-ready'), navigatePanel: (page) => ipcRenderer.send('comfy-window:navigate-panel', page), listAssets: (installationId) => ipcRenderer.invoke('assets:list', installationId), + listOutputFolders: () => ipcRenderer.invoke('assets:output-folders'), + listOutputFolder: (folderPath) => ipcRenderer.invoke('assets:output-folder', folderPath), downloadAsset: (installationId, assetId, fileName) => ipcRenderer.invoke('assets:download', installationId, assetId, fileName), showApps: (rect) => ipcRenderer.send('comfy-apps:show', rect), diff --git a/src/renderer/csp.test.ts b/src/renderer/csp.test.ts index 9603f3164..af2db3d0f 100644 --- a/src/renderer/csp.test.ts +++ b/src/renderer/csp.test.ts @@ -63,6 +63,11 @@ describe('Content-Security-Policy: panel.html', () => { expect(csp['img-src']).toContain('blob:') expect(csp['media-src']).toContain('blob:') }) + + it('shows files from the output folders on this computer', () => { + expect(csp['img-src']).toContain('comfy-output:') + expect(csp['media-src']).toContain('comfy-output:') + }) }) describe.each(TELEMETRY_RENDERER_HTMLS)( diff --git a/src/renderer/panel.html b/src/renderer/panel.html index 40445fbe3..87c034c64 100644 --- a/src/renderer/panel.html +++ b/src/renderer/panel.html @@ -5,7 +5,7 @@ Comfy Desktop — Panel