diff --git a/e2e/apps-local.test.ts b/e2e/apps-local.test.ts
new file mode 100644
index 000000000..5460573ee
--- /dev/null
+++ b/e2e/apps-local.test.ts
@@ -0,0 +1,280 @@
+import { createServer, type IncomingMessage, type Server, type ServerResponse } from 'node:http'
+import type { AddressInfo } from 'node:net'
+import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import { expect, test } from '@playwright/test'
+import { launchApp, type AppContext } from './launchApp'
+import { waitForWebContents, WebContentsPage } from './support/cdpPages'
+import { getRunningSessionSnapshot } from './support/devHooks'
+import {
+ FAKE_COMFY_API_SERVER,
+ FAKE_OUTPUT_TEXT,
+ SOMEONE_ELSES_RUN,
+ type FakeComfySeen
+} from './support/fakeComfyApi'
+import { reserveFreePort, writeFakeComfyInstall } from './support/fakeComfyInstall'
+
+const BUILD_ID = 'inst-apps-local'
+const BUILD_NAME = 'Apps Test Build'
+const SIDEBAR_APPS = '[data-testid="app-sidebar-apps"]'
+const CUTOUT_CARD = '[data-testid="app-card-remove-background"]'
+const CUTOUT_PAGE = '/apps/remove-background/desktop.html'
+const LONG_WAIT = { timeout: 30_000 }
+
+const APP_PAGE = `
+
+
Remove Background page
+
+ All apps
+ pending
+
+
+
+
+
+
+
+`
+
+class FakeAppsSite {
+ port = 0
+ private server: Server | null = null
+
+ get url(): string {
+ return `http://127.0.0.1:${this.port}`
+ }
+
+ async start(): Promise {
+ const server = createServer((req, res) => this.route(req, res))
+ this.server = server
+ await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve))
+ this.port = (server.address() as AddressInfo).port
+ }
+
+ async stop(): Promise {
+ const server = this.server
+ if (!server) return
+ this.server = null
+ server.closeAllConnections()
+ await new Promise((resolve) => server.close(resolve))
+ }
+
+ private route(req: IncomingMessage, res: ServerResponse): void {
+ const { pathname } = new URL(req.url ?? '/', this.url)
+ if (pathname === '/apps/apps.json') {
+ res.writeHead(200, { 'content-type': 'application/json' })
+ res.end(
+ JSON.stringify([
+ { id: 'remove-background', page: CUTOUT_PAGE, title: 'Remove Background', blurb: '' }
+ ])
+ )
+ return
+ }
+ res.writeHead(pathname === CUTOUT_PAGE ? 200 : 404, {
+ 'content-type': 'text/html; charset=utf-8'
+ })
+ res.end(pathname === CUTOUT_PAGE ? APP_PAGE : 'Not found')
+ }
+}
+
+let site: FakeAppsSite
+let ctx: AppContext
+let profileDir = ''
+let installPath = ''
+let comfyPort = 0
+let inheritedAppsUrl: string | undefined
+
+function appPage(): WebContentsPage {
+ return new WebContentsPage(ctx.app, CUTOUT_PAGE)
+}
+
+function windowCount(): Promise {
+ return ctx.app.evaluate(({ BrowserWindow }) => BrowserWindow.getAllWindows().length)
+}
+
+async function whatComfySaw(): Promise {
+ const port = (await getRunningSessionSnapshot(ctx.app, BUILD_ID))?.port
+ return (await (await fetch(`http://127.0.0.1:${port}/e2e/seen`)).json()) as FakeComfySeen
+}
+
+test.describe.configure({ mode: 'serial' })
+test.setTimeout(180_000)
+
+test.beforeAll(async () => {
+ inheritedAppsUrl = process.env['COMFY_APPS_URL']
+ site = new FakeAppsSite()
+ await site.start()
+ process.env['COMFY_APPS_URL'] = `${site.url}/apps/`
+ profileDir = await mkdtemp(path.join(os.tmpdir(), 'comfy-apps-local-profile-'))
+ installPath = await mkdtemp(path.join(os.tmpdir(), 'comfy-apps-local-build-'))
+ comfyPort = await reserveFreePort()
+ await writeFakeComfyInstall({ installPath, port: comfyPort, serverScript: FAKE_COMFY_API_SERVER })
+ await writeFile(
+ path.join(installPath, 'ComfyUI', 'comfyui_version.py'),
+ '__version__ = "0.42.1"\n'
+ )
+ ctx = await launchApp(
+ {
+ profileDir,
+ settings: { firstUseCompleted: true, telemetryEnabled: false, language: 'en' },
+ installations: [
+ {
+ id: BUILD_ID,
+ name: BUILD_NAME,
+ sourceId: 'comfybuilder',
+ sourceLabel: 'ComfyBuilder',
+ installPath,
+ status: 'installed',
+ launchArgs: `--port ${comfyPort}`,
+ seen: true
+ }
+ ]
+ },
+ { stayOnHome: true }
+ )
+})
+
+test.afterAll(async () => {
+ await ctx?.panel.evaluate(`window.api.stopComfyUI(${JSON.stringify(BUILD_ID)})`).catch(() => {})
+ await ctx?.cleanup()
+ await site?.stop()
+ if (profileDir) await rm(profileDir, { recursive: true, force: true })
+ if (installPath) await rm(installPath, { recursive: true, force: true })
+ if (inheritedAppsUrl === undefined) delete process.env['COMFY_APPS_URL']
+ else process.env['COMFY_APPS_URL'] = inheritedAppsUrl
+})
+
+test('An app page is offered the build on this computer, stopped, by name and version @linux', async () => {
+ await ctx.panel.waitForVisible(SIDEBAR_APPS)
+ expect(await ctx.panel.click(SIDEBAR_APPS)).toBe(true)
+ await ctx.panel.waitForVisible(CUTOUT_CARD)
+ expect(await ctx.panel.click(CUTOUT_CARD)).toBe(true)
+ await waitForWebContents(ctx.app, CUTOUT_PAGE)
+
+ await expect
+ .poll(() => appPage().textOf('#local'), LONG_WAIT)
+ .toBe(`stopped | ${BUILD_NAME} | 0.42.1`)
+ expect(await getRunningSessionSnapshot(ctx.app, BUILD_ID)).toBeNull()
+})
+
+test('Starting from the page runs that build with no ComfyUI window @linux', async () => {
+ const windowsBefore = await windowCount()
+
+ expect(await appPage().click('#start')).toBe(true)
+
+ await expect
+ .poll(() => appPage().textOf('#local'), { timeout: 120_000 })
+ .toBe(`running | ${BUILD_NAME} | 0.42.1`)
+ expect(await getRunningSessionSnapshot(ctx.app, BUILD_ID)).not.toBeNull()
+ expect(await windowCount(), 'no window was opened for ComfyUI').toBe(windowsBefore)
+})
+
+test('A run goes from a picture to its result, with updates on the way, through Desktop only @linux', async () => {
+ expect(await appPage().click('#run')).toBe(true)
+
+ await expect.poll(() => appPage().textOf('#result'), LONG_WAIT).toContain('"result"')
+ const result = JSON.parse((await appPage().textOf('#result')) ?? '{}') as Record
+ expect(result).toEqual({
+ image: 'comfy-apps/photo.png',
+ result: FAKE_OUTPUT_TEXT,
+ type: 'image/png',
+ updates: ['execution_start', 'executing', 'execution_success'],
+ queue: { running: [{ n: 1, id: null, app: null, seconds: null }], pending: [] }
+ })
+
+ const seen = await whatComfySaw()
+ expect(seen.sockets, 'Desktop listens as one client').toHaveLength(1)
+ expect(seen.prompts).toEqual([
+ { id: 'e2e-run-1', clientId: seen.sockets[0], app: 'Remove Background', nodes: ['load'] }
+ ])
+ expect(seen.uploads).toEqual([
+ { name: 'photo.png', subfolder: 'comfy-apps', overwrite: false, bytes: expect.any(Number) }
+ ])
+})
+
+test('The page cannot reach anything that is not its own run @linux', async () => {
+ expect(await appPage().click('#pry')).toBe(true)
+
+ await expect.poll(() => appPage().textOf('#pried'), LONG_WAIT).toBe('403,403,403,403,403')
+ const seen = await whatComfySaw()
+ expect(seen.asked).not.toContain('GET /system_stats')
+ expect(seen.asked).not.toContain(`GET /history/${SOMEONE_ELSES_RUN}`)
+ expect(
+ seen.asked.filter((asked) => asked === 'GET /view'),
+ 'only the run fetched its own file'
+ ).toHaveLength(1)
+ expect(seen.interrupted).toEqual([])
+})
diff --git a/e2e/support/fakeComfyApi.ts b/e2e/support/fakeComfyApi.ts
new file mode 100644
index 000000000..7cb71fee5
--- /dev/null
+++ b/e2e/support/fakeComfyApi.ts
@@ -0,0 +1,6 @@
+export {
+ FAKE_COMFY_API_SERVER,
+ FAKE_OUTPUT_TEXT,
+ SOMEONE_ELSES_RUN
+} from '../../src/main/apps/__fixtures__/fakeComfyApi'
+export type { FakeComfySeen } from '../../src/main/apps/__fixtures__/fakeComfyApi'
diff --git a/e2e/support/fakeComfyInstall.ts b/e2e/support/fakeComfyInstall.ts
index b024dd1d5..ad786085d 100644
--- a/e2e/support/fakeComfyInstall.ts
+++ b/e2e/support/fakeComfyInstall.ts
@@ -116,13 +116,14 @@ export interface FakeComfyInstall {
export async function writeFakeComfyInstall(opts: {
installPath: string
port: number
+ serverScript?: string
}): Promise {
- const { installPath, port } = opts
+ const { installPath, port, serverScript = SERVER_JS } = opts
await mkdir(path.join(installPath, 'ComfyUI'), { recursive: true })
await writeFile(path.join(installPath, 'ComfyUI', 'main.py'), '# e2e stub\n')
const serverPath = path.join(installPath, 'stub-server.cjs')
- await writeFile(serverPath, SERVER_JS)
+ await writeFile(serverPath, serverScript)
if (process.platform !== 'linux') {
throw new Error(
diff --git a/locales/en.json b/locales/en.json
index 3a04d1660..f61869e9a 100644
--- a/locales/en.json
+++ b/locales/en.json
@@ -42,7 +42,15 @@
"noMatches": "No apps match “{query}”",
"allApps": "All apps",
"pageLoading": "Loading {app}",
- "pageFailedTitle": "{app} didn't load"
+ "pageFailedTitle": "{app} didn't load",
+ "local": {
+ "noBuilds": "Add a local build in Comfy Desktop to run apps on this computer.",
+ "tooOld": "This app needs ComfyUI {version} or newer. Update a local build in Comfy Desktop.",
+ "couldNotStart": "Comfy Desktop could not start {name}.",
+ "notRunning": "ComfyUI is not running on this computer.",
+ "notForwarded": "Comfy Desktop does not pass this request to ComfyUI.",
+ "modelRefused": "Comfy Desktop only downloads safetensors models from Hugging Face."
+ }
},
"assets": {
"kindLabel": "Asset type",
diff --git a/locales/zh.json b/locales/zh.json
index 160650679..af34d1e45 100644
--- a/locales/zh.json
+++ b/locales/zh.json
@@ -42,7 +42,15 @@
"noMatches": "没有与“{query}”匹配的应用",
"allApps": "全部应用",
"pageLoading": "正在加载{app}",
- "pageFailedTitle": "{app}未能加载"
+ "pageFailedTitle": "{app}未能加载",
+ "local": {
+ "noBuilds": "请先在 Comfy Desktop 中添加一个本地构建,才能在这台电脑上运行应用。",
+ "tooOld": "此应用需要 ComfyUI {version} 或更高版本。请在 Comfy Desktop 中更新一个本地构建。",
+ "couldNotStart": "Comfy Desktop 无法启动{name}。",
+ "notRunning": "这台电脑上的 ComfyUI 没有在运行。",
+ "notForwarded": "Comfy Desktop 不会把这个请求转给 ComfyUI。",
+ "modelRefused": "Comfy Desktop 只从 Hugging Face 下载 safetensors 模型。"
+ }
},
"assets": {
"kindLabel": "资产类型",
diff --git a/packages/comfyui-desktop-bridge-types/README.md b/packages/comfyui-desktop-bridge-types/README.md
index 57d38f99e..3ad762678 100644
--- a/packages/comfyui-desktop-bridge-types/README.md
+++ b/packages/comfyui-desktop-bridge-types/README.md
@@ -41,15 +41,20 @@ while omitting part of it.
## Comfy pages hosted in Desktop's Apps view
-A Comfy page that Desktop shows in its Apps view gets `window.comfyDesktopAuth`
-instead: Desktop's account session, and nothing else of the bridge above.
+A Comfy page that Desktop shows in its Apps view gets two objects instead, and
+nothing else of the bridge above: `window.comfyDesktopAuth`, Desktop's account
+session, and `window.comfyDesktopLocal`, a ComfyUI on this computer.
```ts
-import type { ComfyDesktopHostedAuthBridge } from '@comfyorg/comfyui-desktop-bridge-types'
+import type {
+ ComfyDesktopHostedAuthBridge,
+ ComfyDesktopHostedLocalBridge
+} from '@comfyorg/comfyui-desktop-bridge-types'
declare global {
interface Window {
comfyDesktopAuth?: ComfyDesktopHostedAuthBridge
+ comfyDesktopLocal?: ComfyDesktopHostedLocalBridge
}
}
```
@@ -57,8 +62,17 @@ declare global {
The page reads the session with `getState()`, follows it with `onChanged()`,
asks for the workspace credential with `getWorkspaceToken(workspaceId)` each
time it calls Comfy Cloud, and starts a sign-in with `requestSignIn()`. It
-cannot sign Desktop out or switch workspace. The object is absent in a
-browser, so a page keeps its own sign-in as the fallback.
+cannot sign Desktop out or switch workspace.
+
+For a run on this computer the page asks `getLocal({ minVersion })` which of
+the person's builds Desktop would use, starts it with `startLocal()`, and then
+talks to it through `localFetch()`. Desktop forwards only the calls a run
+needs, and only for runs the page started; `onLocalEvent()` carries ComfyUI's
+updates for those runs. `localDownload()` saves a safetensors model from
+Hugging Face into that build's models folder.
+
+Both objects are absent in a browser, so a page keeps its own sign-in and its
+own way to reach a local ComfyUI as the fallback.
## Provenance
diff --git a/packages/comfyui-desktop-bridge-types/comfyDesktopBridge.d.ts b/packages/comfyui-desktop-bridge-types/comfyDesktopBridge.d.ts
index de1d49231..9eddd9d9b 100644
--- a/packages/comfyui-desktop-bridge-types/comfyDesktopBridge.d.ts
+++ b/packages/comfyui-desktop-bridge-types/comfyDesktopBridge.d.ts
@@ -187,6 +187,85 @@ export type ComfyDesktopHostedAuthBridge = Required<
'getState' | 'getWorkspaceToken' | 'getPartnerNodeToken' | 'requestSignIn' | 'onChanged'
>
>
+/** What a hosted page needs from the ComfyUI on this computer. */
+export interface ComfyDesktopLocalRequirements {
+ /** The oldest ComfyUI the page can run on, such as `0.41.0`. */
+ minVersion?: string
+}
+/**
+ * The ComfyUI on this computer that Desktop uses for a hosted page.
+ * `running`: it answers now. `stopped`: one of the person's builds fits and
+ * `startLocal` starts it. `unsupported`: no build here can run the page, and
+ * `error` says why in words for the person.
+ */
+export interface ComfyDesktopLocalComfy {
+ state: 'running' | 'stopped' | 'unsupported'
+ /** True when it is one of the person's own builds. */
+ own?: boolean
+ name?: string
+ version?: string
+ /** The `client_id` Desktop listens with; updates for runs sent through `localFetch` arrive on `onLocalEvent`. */
+ clientId?: string
+ error?: string
+}
+/**
+ * One call to that ComfyUI. Desktop forwards only what a run needs:
+ * `GET /queue`, `GET /history/`, `GET /view`, `GET /object_info/`,
+ * `POST /prompt`, `POST /upload/image`, `POST /queue` to take a run out, and
+ * `POST /interrupt` to stop one. History, files, removal and stopping work
+ * only for runs the page started through this bridge.
+ */
+export interface ComfyDesktopLocalRequest {
+ method?: 'GET' | 'POST'
+ path: string
+ /** JSON text, or a file's bytes for `/upload/image`. */
+ body?: string | Uint8Array
+ /** The name to save an upload under. */
+ fileName?: string
+}
+/** ComfyUI's answer, or status 403 for a call Desktop does not forward. */
+export interface ComfyDesktopLocalAnswer {
+ status: number
+ contentType: string
+ body: Uint8Array
+}
+/** A safetensors file on Hugging Face to save as `name` in the models folder `folder`. */
+export interface ComfyDesktopLocalModel {
+ url: string
+ folder: string
+ name: string
+}
+export interface ComfyDesktopLocalDownload {
+ state: 'done' | 'failed' | 'cancelled'
+ error?: string
+}
+/**
+ * A model download's progress (`type: 'download'`, with `name`, `done` and
+ * `total` bytes in `data`), or one ComfyUI socket message about a run the page
+ * started (`execution_start`, `executing`, `progress`, `progress_state`,
+ * `execution_success`, `execution_error`, `execution_interrupted`).
+ */
+export interface ComfyDesktopLocalEvent {
+ type: string
+ data?: Record
+}
+/**
+ * A ComfyUI on this computer, run by Desktop, for a Comfy page hosted in
+ * Desktop's Apps view. Desktop exposes it to that page as
+ * `window.comfyDesktopLocal`. The page builds and follows its own runs;
+ * Desktop finds or starts the ComfyUI, forwards the page's calls to it and
+ * downloads a model the page asks for.
+ */
+export interface ComfyDesktopHostedLocalBridge {
+ getLocal(want?: ComfyDesktopLocalRequirements): Promise
+ /** Starts the ComfyUI if it is stopped and resolves once it answers, or with the state and `error` if it could not start. */
+ startLocal(want?: ComfyDesktopLocalRequirements): Promise
+ /** Rejects when no ComfyUI is running to forward to. */
+ localFetch(request: ComfyDesktopLocalRequest): Promise
+ /** Downloads into the running ComfyUI's models folder and resolves when the file is there. */
+ localDownload(model: ComfyDesktopLocalModel): Promise
+ onLocalEvent(callback: (event: ComfyDesktopLocalEvent) => void): () => void
+}
export interface ComfyDesktop2TerminalBridge {
subscribe(installationId?: string): Promise
unsubscribe(installationId?: string): Promise
diff --git a/packages/comfyui-desktop-bridge-types/package.json b/packages/comfyui-desktop-bridge-types/package.json
index acdb84d2c..7ce9e477e 100644
--- a/packages/comfyui-desktop-bridge-types/package.json
+++ b/packages/comfyui-desktop-bridge-types/package.json
@@ -1,6 +1,6 @@
{
"name": "@comfyorg/comfyui-desktop-bridge-types",
- "version": "0.9.0",
+ "version": "0.10.0",
"description": "TypeScript definitions for the Comfy Desktop hosted frontend bridge",
"type": "module",
"main": "./index.js",
diff --git a/src/main/apps/__fixtures__/fakeComfyApi.ts b/src/main/apps/__fixtures__/fakeComfyApi.ts
new file mode 100644
index 000000000..78b6bfe00
--- /dev/null
+++ b/src/main/apps/__fixtures__/fakeComfyApi.ts
@@ -0,0 +1,144 @@
+export const FAKE_OUTPUT_TEXT = 'e2e cutout bytes'
+export const SOMEONE_ELSES_RUN = 'someone-elses-run'
+
+export interface FakeComfySeen {
+ asked: string[]
+ sockets: string[]
+ prompts: { id: string; clientId: string; app: string | null; nodes: string[] }[]
+ uploads: { name: string; subfolder: string; overwrite: boolean; bytes: number }[]
+ interrupted: string[]
+}
+
+export const FAKE_COMFY_API_SERVER = `
+const http = require('node:http')
+const crypto = require('node:crypto')
+const args = process.argv.slice(2)
+const portIndex = args.indexOf('--port')
+const port = portIndex === -1 ? 8188 : Number(args[portIndex + 1])
+const seen = { asked: [], sockets: [], prompts: [], uploads: [], interrupted: [] }
+const sockets = new Map()
+const history = {}
+const OUTPUT = Buffer.from(${JSON.stringify(FAKE_OUTPUT_TEXT)})
+const WS_GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
+
+function frame(text) {
+ const payload = Buffer.from(text)
+ const header =
+ payload.length < 126
+ ? Buffer.from([0x81, payload.length])
+ : Buffer.from([0x81, 126, payload.length >> 8, payload.length & 0xff])
+ return Buffer.concat([header, payload])
+}
+
+function tell(clientId, message) {
+ const socket = sockets.get(clientId)
+ if (socket) socket.write(frame(JSON.stringify(message)))
+}
+
+function readBody(req) {
+ return new Promise((resolve) => {
+ const chunks = []
+ req.on('data', (chunk) => chunks.push(chunk))
+ req.on('end', () => resolve(Buffer.concat(chunks)))
+ })
+}
+
+function json(res, value, status = 200) {
+ res.writeHead(status, { 'content-type': 'application/json' })
+ res.end(JSON.stringify(value))
+}
+
+async function upload(req, res) {
+ const body = await readBody(req)
+ const text = body.toString('latin1')
+ const name = (/filename="([^"]+)"/.exec(text) || [])[1] || ''
+ const subfolder = (/name="subfolder"\\r\\n\\r\\n([^\\r]*)/.exec(text) || [])[1] || ''
+ seen.uploads.push({ name, subfolder, overwrite: /name="overwrite"/.test(text), bytes: body.length })
+ json(res, { name, subfolder, type: 'input' })
+}
+
+async function prompt(req, res) {
+ const sent = JSON.parse((await readBody(req)).toString('utf8'))
+ const id = 'e2e-run-' + (seen.prompts.length + 1)
+ const tag = (sent.extra_data && sent.extra_data.comfy_app) || {}
+ seen.prompts.push({
+ id,
+ clientId: sent.client_id,
+ app: typeof tag.name === 'string' ? tag.name : null,
+ nodes: Object.keys(sent.prompt || {})
+ })
+ json(res, { prompt_id: id, number: seen.prompts.length, node_errors: {} })
+ setTimeout(() => {
+ tell(sent.client_id, { type: 'execution_start', data: { prompt_id: id, timestamp: Date.now() } })
+ tell(sent.client_id, { type: 'executing', data: { prompt_id: id, node: 'cut' } })
+ tell(sent.client_id, { type: 'executing', data: { prompt_id: ${JSON.stringify(SOMEONE_ELSES_RUN)}, node: 'private' } })
+ history[id] = {
+ status: { status_str: 'success', completed: true },
+ outputs: { save: { images: [{ filename: 'cutout_00001_.png', subfolder: 'apps', type: 'output' }] } }
+ }
+ tell(sent.client_id, { type: 'execution_success', data: { prompt_id: id } })
+ }, 150)
+}
+
+const server = http.createServer((req, res) => {
+ const url = new URL(req.url, 'http://127.0.0.1')
+ if (url.pathname === '/e2e/seen') return json(res, seen)
+ seen.asked.push(req.method + ' ' + url.pathname)
+ if (url.pathname === '/queue' && req.method === 'GET') {
+ return json(res, {
+ queue_running: [[1, ${JSON.stringify(SOMEONE_ELSES_RUN)}, { 3: { class_type: 'KSampler' } }, { client_id: 'their-window' }]],
+ queue_pending: []
+ })
+ }
+ if (url.pathname === '/upload/image' && req.method === 'POST') return void upload(req, res)
+ if (url.pathname === '/prompt' && req.method === 'POST') return void prompt(req, res)
+ if (url.pathname === '/interrupt' && req.method === 'POST') {
+ return void readBody(req).then((body) => {
+ seen.interrupted.push(JSON.parse(body.toString('utf8')).prompt_id)
+ json(res, {})
+ })
+ }
+ const run = /^\\/history\\/([\\w-]+)$/.exec(url.pathname)
+ if (run) return json(res, history[run[1]] ? { [run[1]]: history[run[1]] } : {})
+ if (url.pathname === '/view') {
+ res.writeHead(200, { 'content-type': 'image/png' })
+ return res.end(OUTPUT)
+ }
+ if (url.pathname.startsWith('/object_info/')) return json(res, {})
+ if (url.pathname === '/system_stats') return json(res, { system: { comfyui_version: '0.42.1' } })
+ res.writeHead(200, { 'content-type': 'text/html; charset=utf-8' })
+ res.end('ComfyUI (e2e stub)ComfyUI stub
')
+})
+
+server.on('upgrade', (req, socket) => {
+ const url = new URL(req.url, 'http://127.0.0.1')
+ const accept = crypto
+ .createHash('sha1')
+ .update(req.headers['sec-websocket-key'] + WS_GUID)
+ .digest('base64')
+ socket.write(
+ 'HTTP/1.1 101 Switching Protocols\\r\\nUpgrade: websocket\\r\\nConnection: Upgrade\\r\\n' +
+ 'Sec-WebSocket-Accept: ' + accept + '\\r\\n\\r\\n'
+ )
+ const clientId = url.searchParams.get('clientId') || ''
+ sockets.set(clientId, socket)
+ seen.sockets.push(clientId)
+ socket.on('data', () => {})
+ socket.on('error', () => {})
+ socket.on('close', () => {
+ if (sockets.get(clientId) === socket) sockets.delete(clientId)
+ })
+})
+
+let attemptsLeft = 40
+server.on('error', (err) => {
+ if (err.code !== 'EADDRINUSE' || attemptsLeft <= 0) throw err
+ attemptsLeft -= 1
+ setTimeout(() => server.listen(port, '127.0.0.1'), 250)
+})
+server.on('listening', () => {
+ console.log('Starting server\\n')
+ console.log('To see the GUI go to: http://127.0.0.1:' + port)
+})
+server.listen(port, '127.0.0.1')
+`
diff --git a/src/main/apps/localBuild.test.ts b/src/main/apps/localBuild.test.ts
new file mode 100644
index 000000000..082321219
--- /dev/null
+++ b/src/main/apps/localBuild.test.ts
@@ -0,0 +1,207 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mocks = vi.hoisted(() => ({
+ records: [] as Record[],
+ sessions: new Map>(),
+ launching: new Set(),
+ operations: new Map(),
+ versionFiles: new Map()
+}))
+
+vi.mock('fs', () => ({
+ promises: {
+ readFile: async (file: string) => {
+ const text = mocks.versionFiles.get(file)
+ if (text === undefined) throw new Error('ENOENT')
+ return text
+ }
+ }
+}))
+vi.mock('../installations', () => ({ list: async () => mocks.records }))
+vi.mock('../lib/ipc/shared', () => ({
+ _hasActiveLaunch: (id: string) => mocks.launching.has(id),
+ _operationAborts: mocks.operations,
+ _runningSessions: mocks.sessions,
+ sourceMap: {
+ standalone: { category: 'local' },
+ portable: { category: 'local' },
+ desktop: { category: 'local' },
+ cloud: { category: 'cloud' },
+ remote: { category: 'remote' }
+ }
+}))
+vi.mock('../lib/models', () => ({
+ resolveComfyDir: (installPath: string) => `${installPath}/ComfyUI`
+}))
+
+import { chooseLocalBuild, runningPortOf, usableLocalBuilds, wantedVersion } from './localBuild'
+import type { LocalBuild } from './localBuild'
+
+function record(over: Record = {}): Record {
+ return {
+ id: 'studio',
+ name: 'Studio',
+ sourceId: 'standalone',
+ installPath: '/builds/studio',
+ status: 'installed',
+ version: 'v0.42.1',
+ lastLaunchedAt: 100,
+ ...over
+ }
+}
+
+function build(over: Partial = {}): LocalBuild {
+ return {
+ id: 'studio',
+ name: 'Studio',
+ version: '0.42.1',
+ port: null,
+ starting: false,
+ lastLaunchedAt: 0,
+ ...over
+ }
+}
+
+beforeEach(() => {
+ mocks.records = []
+ mocks.sessions.clear()
+ mocks.launching.clear()
+ mocks.operations.clear()
+ mocks.versionFiles.clear()
+})
+
+describe('the ComfyUI version a page asks for', () => {
+ it.each([
+ [{ minVersion: '0.41.0' }, '0.41.0'],
+ [{ minVersion: 'v0.37.0' }, '0.37.0'],
+ [{ minVersion: '0.21' }, '0.21.0'],
+ [{ minVersion: '' }, null],
+ [{ minVersion: 41 }, null],
+ [{}, null],
+ [undefined, null],
+ ['0.41.0', null]
+ ])('reads %j as %j', (want, version) => {
+ expect(wantedVersion(want)).toBe(version)
+ })
+})
+
+describe('the builds on this computer an app can run on', () => {
+ it('are the installed local builds, each with its version and whether it is running', async () => {
+ mocks.records = [record(), record({ id: 'lab', name: 'Lab', installPath: '/builds/lab' })]
+ mocks.sessions.set('lab', { port: 8190 })
+
+ expect(await usableLocalBuilds()).toEqual([
+ build({ lastLaunchedAt: 100 }),
+ build({ id: 'lab', name: 'Lab', port: 8190, lastLaunchedAt: 100 })
+ ])
+ })
+
+ it('leave out Comfy Cloud, remote servers, the legacy app and unfinished installs', async () => {
+ mocks.records = [
+ record({ id: 'cloud', sourceId: 'cloud' }),
+ record({ id: 'remote', sourceId: 'remote' }),
+ record({ id: 'legacy', sourceId: 'desktop' }),
+ record({ id: 'unknown-kind', sourceId: 'mystery' }),
+ record({ id: 'installing', status: 'installing' }),
+ record({ id: 'updating', status: 'updating' }),
+ record({ id: 'nowhere', installPath: '' })
+ ]
+
+ expect(await usableLocalBuilds()).toEqual([])
+ })
+
+ it('leave out a build that is being updated or copied, but keep one that is starting', async () => {
+ mocks.records = [record({ id: 'updating-now' }), record({ id: 'starting-now' })]
+ mocks.operations.set('updating-now', {})
+ mocks.operations.set('starting-now', {})
+ mocks.launching.add('starting-now')
+
+ expect((await usableLocalBuilds()).map(({ id, starting }) => ({ id, starting }))).toEqual([
+ { id: 'starting-now', starting: true }
+ ])
+ })
+
+ it('read the version from the ComfyUI on disk before the one recorded at install', async () => {
+ mocks.records = [record({ version: 'v0.30.0' })]
+ mocks.versionFiles.set(
+ '/builds/studio/ComfyUI/comfyui_version.py',
+ '# generated\n__version__ = "0.42.1"\n'
+ )
+
+ expect((await usableLocalBuilds())[0]?.version).toBe('0.42.1')
+ })
+
+ it('have no version when neither the disk nor the record gives one', async () => {
+ mocks.records = [record({ version: undefined })]
+
+ expect((await usableLocalBuilds())[0]?.version).toBeNull()
+ })
+})
+
+describe('a running build', () => {
+ it('is one with a port on this computer', () => {
+ mocks.sessions.set('studio', { port: 8188 })
+
+ expect(runningPortOf('studio')).toBe(8188)
+ expect(runningPortOf('lab')).toBeNull()
+ })
+
+ it('is not a remote session, one with no port yet, or another session of the same build', () => {
+ mocks.sessions.set('remote', { port: 443, url: 'https://comfy.example' })
+ mocks.sessions.set('external', { port: 0 })
+ mocks.sessions.set('performance-test:studio', { port: 8200, sourceInstallationId: 'studio' })
+
+ expect(runningPortOf('remote')).toBeNull()
+ expect(runningPortOf('external')).toBeNull()
+ expect(runningPortOf('performance-test:studio')).toBeNull()
+ })
+})
+
+describe('choosing the build for a run', () => {
+ it('says there are no builds', () => {
+ expect(chooseLocalBuild([], '0.41.0')).toEqual({ kind: 'no-builds' })
+ })
+
+ it('says every build is too old, or of unknown age, for the page', () => {
+ const builds = [build({ version: '0.37.0' }), build({ id: 'lab', version: null })]
+
+ expect(chooseLocalBuild(builds, '0.41.0')).toEqual({ kind: 'too-old', wanted: '0.41.0' })
+ })
+
+ it('takes any build when the page names no version', () => {
+ expect(chooseLocalBuild([build({ version: null })], null)).toMatchObject({ kind: 'build' })
+ })
+
+ it('prefers the build that is already running', () => {
+ const builds = [
+ build({ id: 'newest', version: '0.45.0', lastLaunchedAt: 900 }),
+ build({ id: 'running', version: '0.41.0', port: 8188, lastLaunchedAt: 1 })
+ ]
+
+ expect(chooseLocalBuild(builds, '0.41.0')).toMatchObject({ build: { id: 'running' } })
+ })
+
+ it('then the one that is starting, then the one used last, then the newest', () => {
+ const starting = build({ id: 'starting', starting: true })
+ const usedLast = build({ id: 'used-last', lastLaunchedAt: 500 })
+ const newest = build({ id: 'newest', version: '0.45.0' })
+ const older = build({ id: 'older', version: '0.41.0' })
+
+ expect(chooseLocalBuild([older, usedLast, starting], null)).toMatchObject({
+ build: { id: 'starting' }
+ })
+ expect(chooseLocalBuild([older, newest, usedLast], null)).toMatchObject({
+ build: { id: 'used-last' }
+ })
+ expect(chooseLocalBuild([older, newest], null)).toMatchObject({ build: { id: 'newest' } })
+ })
+
+ it('never takes a running build that is too old over a stopped one that fits', () => {
+ const builds = [
+ build({ id: 'old-running', version: '0.30.0', port: 8188 }),
+ build({ id: 'fits', version: '0.42.0' })
+ ]
+
+ expect(chooseLocalBuild(builds, '0.41.0')).toMatchObject({ build: { id: 'fits' } })
+ })
+})
diff --git a/src/main/apps/localBuild.ts b/src/main/apps/localBuild.ts
new file mode 100644
index 000000000..2641be3d5
--- /dev/null
+++ b/src/main/apps/localBuild.ts
@@ -0,0 +1,113 @@
+import { promises as fsp } from 'fs'
+import path from 'path'
+import semver from 'semver'
+
+import * as installations from '../installations'
+import type { InstallationRecord } from '../installations'
+import { _hasActiveLaunch, _operationAborts, _runningSessions, sourceMap } from '../lib/ipc/shared'
+import { resolveComfyDir } from '../lib/models'
+import { coreSemver, coreVerifiedSemver } from '../lib/version'
+
+const LEGACY_DESKTOP_SOURCE = 'desktop'
+const VERSION_FILE = 'comfyui_version.py'
+const VERSION_LINE = /^__version__\s*=\s*['"]([^'"]+)['"]/m
+
+export interface LocalBuild {
+ id: string
+ name: string
+ version: string | null
+ port: number | null
+ starting: boolean
+ lastLaunchedAt: number
+}
+
+export type LocalChoice =
+ | { kind: 'build'; build: LocalBuild }
+ | { kind: 'no-builds' }
+ | { kind: 'too-old'; wanted: string }
+
+function releaseVersion(value: unknown): string | null {
+ if (typeof value !== 'string') return null
+ return semver.valid(semver.coerce(value.trim().replace(/^v/, ''), { includePrerelease: false }))
+}
+
+export function wantedVersion(want: unknown): string | null {
+ if (typeof want !== 'object' || want === null) return null
+ return releaseVersion((want as { minVersion?: unknown }).minVersion)
+}
+
+async function versionOnDisk(inst: InstallationRecord): Promise {
+ const file = path.join(resolveComfyDir(inst.installPath), VERSION_FILE)
+ const text = await fsp.readFile(file, 'utf8').catch(() => null)
+ return text === null ? null : releaseVersion(VERSION_LINE.exec(text)?.[1])
+}
+
+async function installedVersion(inst: InstallationRecord): Promise {
+ return (await versionOnDisk(inst)) ?? coreVerifiedSemver(inst) ?? coreSemver(inst)
+}
+
+export function runningPortOf(installationId: string): number | null {
+ const session = _runningSessions.get(installationId)
+ if (!session || session.url || session.port <= 0) return null
+ return (session.sourceInstallationId ?? installationId) === installationId ? session.port : null
+}
+
+function runsOnThisComputer(inst: InstallationRecord): boolean {
+ return (
+ sourceMap[inst.sourceId]?.category === 'local' &&
+ inst.sourceId !== LEGACY_DESKTOP_SOURCE &&
+ inst.status === 'installed' &&
+ typeof inst.installPath === 'string' &&
+ inst.installPath !== ''
+ )
+}
+
+function isBeingChanged(installationId: string): boolean {
+ if (runningPortOf(installationId) !== null || _hasActiveLaunch(installationId)) return false
+ return _operationAborts.has(installationId)
+}
+
+export async function usableLocalBuilds(): Promise {
+ const usable = (await installations.list()).filter(
+ (inst) => runsOnThisComputer(inst) && !isBeingChanged(inst.id)
+ )
+ return Promise.all(
+ usable.map(async (inst) => ({
+ id: inst.id,
+ name: inst.name,
+ version: await installedVersion(inst),
+ port: runningPortOf(inst.id),
+ starting: _hasActiveLaunch(inst.id),
+ lastLaunchedAt: typeof inst.lastLaunchedAt === 'number' ? inst.lastLaunchedAt : 0
+ }))
+ )
+}
+
+function fits(build: LocalBuild, wanted: string | null): boolean {
+ if (wanted === null) return true
+ return build.version !== null && semver.gte(build.version, wanted)
+}
+
+function newerFirst(one: LocalBuild, other: LocalBuild): number {
+ if (one.version === null || other.version === null) {
+ return Number(other.version !== null) - Number(one.version !== null)
+ }
+ return semver.rcompare(one.version, other.version)
+}
+
+export function chooseLocalBuild(
+ builds: readonly LocalBuild[],
+ wanted: string | null
+): LocalChoice {
+ if (builds.length === 0) return { kind: 'no-builds' }
+ const fitting = builds.filter((build) => fits(build, wanted))
+ if (fitting.length === 0) return { kind: 'too-old', wanted: wanted ?? '' }
+ const [build] = [...fitting].sort(
+ (one, other) =>
+ Number(other.port !== null) - Number(one.port !== null) ||
+ Number(other.starting) - Number(one.starting) ||
+ other.lastLaunchedAt - one.lastLaunchedAt ||
+ newerFirst(one, other)
+ )
+ return build ? { kind: 'build', build } : { kind: 'no-builds' }
+}
diff --git a/src/main/apps/localCalls.test.ts b/src/main/apps/localCalls.test.ts
new file mode 100644
index 000000000..e4b71c0a6
--- /dev/null
+++ b/src/main/apps/localCalls.test.ts
@@ -0,0 +1,282 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+ MAX_JSON_BODY_CHARS,
+ MAX_UPLOAD_BYTES,
+ outputFileKey,
+ outputFilesOf,
+ queueViewOf,
+ readLocalCall
+} from './localCalls'
+
+const RUN = '0b1c2d3e-aaaa-bbbb-cccc-0123456789ab'
+const picture = new Uint8Array([1, 2, 3])
+
+describe('what an app page may ask the ComfyUI on this computer', () => {
+ it('reads the queue', () => {
+ expect(readLocalCall({ path: '/queue' })).toEqual({ kind: 'queue' })
+ expect(readLocalCall({ method: 'GET', path: '/queue' })).toEqual({ kind: 'queue' })
+ })
+
+ it('reads how one run went', () => {
+ expect(readLocalCall({ path: `/history/${RUN}` })).toEqual({ kind: 'history', promptId: RUN })
+ })
+
+ it('reads one result file, in a folder or not', () => {
+ const query = new URLSearchParams({
+ filename: 'cutout_00001_.png',
+ subfolder: 'apps/remove-background',
+ type: 'output'
+ })
+
+ expect(readLocalCall({ path: `/view?${query}` })).toEqual({
+ kind: 'view',
+ file: { filename: 'cutout_00001_.png', subfolder: 'apps/remove-background', type: 'output' }
+ })
+ expect(readLocalCall({ path: '/view?filename=preview.webm&type=temp' })).toEqual({
+ kind: 'view',
+ file: { filename: 'preview.webm', subfolder: '', type: 'temp' }
+ })
+ })
+
+ it('reads what one node offers, such as its model files', () => {
+ expect(readLocalCall({ path: '/object_info/LoadBackgroundRemovalModel' })).toEqual({
+ kind: 'object-info',
+ node: 'LoadBackgroundRemovalModel'
+ })
+ })
+
+ it('reads a run to start, with the tag that names the app in the queue', () => {
+ const prompt = { load: { class_type: 'LoadImage', inputs: { image: 'a.png' } } }
+ const extraData = { comfy_app: { name: 'Remove Background', seconds: 12 } }
+ const body = JSON.stringify({ prompt, client_id: 'the-page', extra_data: extraData })
+
+ expect(readLocalCall({ method: 'POST', path: '/prompt', body })).toEqual({
+ kind: 'prompt',
+ prompt,
+ extraData
+ })
+ expect(
+ readLocalCall({ method: 'POST', path: '/prompt', body: JSON.stringify({ prompt }) })
+ ).toEqual({ kind: 'prompt', prompt, extraData: {} })
+ })
+
+ it('reads a picture or clip to send', () => {
+ expect(
+ readLocalCall({
+ method: 'POST',
+ path: '/upload/image',
+ body: picture,
+ fileName: 'My_photo-1.PNG'
+ })
+ ).toEqual({ kind: 'upload', bytes: picture, fileName: 'My_photo-1.PNG' })
+ expect(
+ readLocalCall({
+ method: 'POST',
+ path: '/upload/image',
+ body: picture.buffer,
+ fileName: 'clip.mp4'
+ })
+ ).toEqual({ kind: 'upload', bytes: picture, fileName: 'clip.mp4' })
+ })
+
+ it('reads a run to take out of the queue and a run to stop', () => {
+ expect(
+ readLocalCall({ method: 'POST', path: '/queue', body: JSON.stringify({ delete: [RUN] }) })
+ ).toEqual({ kind: 'leave-queue', promptIds: [RUN] })
+ expect(
+ readLocalCall({
+ method: 'POST',
+ path: '/interrupt',
+ body: JSON.stringify({ prompt_id: RUN })
+ })
+ ).toEqual({ kind: 'interrupt', promptId: RUN })
+ })
+})
+
+describe('what an app page may not ask', () => {
+ it.each([
+ '/system_stats',
+ '/free',
+ '/history',
+ '/object_info',
+ '/userdata/workflows%2Fmine.json',
+ '/api/userdata',
+ '/internal/logs',
+ '/manager/reboot',
+ '/extensions',
+ '/',
+ '',
+ 'queue',
+ '//127.0.0.1:9000/queue',
+ 'http://127.0.0.1:9000/queue',
+ '/history/../userdata',
+ '/history/a/b',
+ '/object_info/..',
+ '/object_info/%2e%2e',
+ '/view/../queue',
+ '/queue\\..\\free',
+ `/history/${RUN}#/free`
+ ])('refuses GET %s', (path) => {
+ expect(readLocalCall({ path })).toBeNull()
+ })
+
+ it.each(['/free', '/history', '/userdata/x', '/upload/mask', '/view', '/object_info/Node'])(
+ 'refuses POST %s',
+ (path) => {
+ expect(
+ readLocalCall({
+ method: 'POST',
+ path,
+ body: JSON.stringify({ prompt: {}, delete: [RUN], prompt_id: RUN, clear: true })
+ })
+ ).toBeNull()
+ }
+ )
+
+ it.each(['PUT', 'DELETE', 'PATCH', 'get', 42, null])('refuses the method %j', (method) => {
+ expect(readLocalCall({ method, path: '/queue' })).toBeNull()
+ })
+
+ it.each([null, undefined, 'queue', 7, ['/queue'], { path: 7 }, {}])(
+ 'refuses the malformed request %j',
+ (raw) => {
+ expect(readLocalCall(raw)).toBeNull()
+ }
+ )
+
+ it.each([
+ '/view',
+ '/view?filename=',
+ '/view?filename=a%2Fb.png',
+ '/view?filename=a.png&subfolder=..%2F..%2Fuser',
+ '/view?filename=a.png&subfolder=ok%5C..',
+ '/view?filename=a.png&type=input',
+ '/view?filename=a.png&type=..'
+ ])('refuses the file request %s', (path) => {
+ expect(readLocalCall({ path })).toBeNull()
+ })
+
+ it('refuses a run that is not a graph', () => {
+ const post = (body: unknown) => readLocalCall({ method: 'POST', path: '/prompt', body })
+
+ expect(post(JSON.stringify({ prompt: 'run this' }))).toBeNull()
+ expect(post(JSON.stringify({ prompt: [] }))).toBeNull()
+ expect(post(JSON.stringify([{ prompt: {} }]))).toBeNull()
+ expect(post('{ not json')).toBeNull()
+ expect(post({ prompt: {} })).toBeNull()
+ expect(post(undefined)).toBeNull()
+ expect(post(`{"prompt":{},"pad":"${'x'.repeat(MAX_JSON_BODY_CHARS)}"}`)).toBeNull()
+ })
+
+ it('refuses an upload that is empty, too big, or not a picture, clip or sound by name', () => {
+ const isRefused = (body: unknown, fileName: unknown): boolean =>
+ readLocalCall({ method: 'POST', path: '/upload/image', body, fileName }) === null
+
+ expect(isRefused(picture, 'a.png')).toBe(false)
+ expect(isRefused(new Uint8Array(MAX_UPLOAD_BYTES), 'a.png')).toBe(false)
+ expect(isRefused(new Uint8Array(MAX_UPLOAD_BYTES + 1), 'a.png')).toBe(true)
+ expect(isRefused(new Uint8Array(0), 'a.png')).toBe(true)
+ expect(isRefused('not bytes', 'a.png')).toBe(true)
+ expect(isRefused(picture, undefined)).toBe(true)
+ expect(isRefused(picture, 'run.py')).toBe(true)
+ expect(isRefused(picture, 'model.safetensors')).toBe(true)
+ expect(isRefused(picture, '../a.png')).toBe(true)
+ expect(isRefused(picture, 'folder/a.png')).toBe(true)
+ expect(isRefused(picture, '.hidden.png')).toBe(true)
+ expect(isRefused(picture, 'a b.png')).toBe(true)
+ })
+
+ it('refuses to clear the whole queue or to stop whatever is running', () => {
+ const post = (path: string, body: unknown) =>
+ readLocalCall({ method: 'POST', path, body: JSON.stringify(body) })
+
+ expect(post('/queue', { clear: true })).toBeNull()
+ expect(post('/queue', { delete: [] })).toBeNull()
+ expect(post('/queue', { delete: [RUN, 7] })).toBeNull()
+ expect(post('/queue', { delete: [RUN, '../x'] })).toBeNull()
+ expect(post('/interrupt', {})).toBeNull()
+ expect(post('/interrupt', { prompt_id: '' })).toBeNull()
+ expect(readLocalCall({ method: 'POST', path: '/interrupt' })).toBeNull()
+ })
+})
+
+describe('the files a finished run made', () => {
+ it('are every file its nodes list, with the folder and kind each is in', () => {
+ const entry = {
+ status: { completed: true },
+ outputs: {
+ save: {
+ images: [{ filename: 'cutout_00001_.png', subfolder: 'apps', type: 'output' }],
+ animated: [false]
+ },
+ preview: { images: [{ filename: 'p.png', type: 'temp' }, { filename: 7 }, 'junk'] },
+ text: { text: ['hello'] },
+ broken: null
+ }
+ }
+
+ expect(outputFilesOf(entry)).toEqual([
+ { filename: 'cutout_00001_.png', subfolder: 'apps', type: 'output' },
+ { filename: 'p.png', subfolder: '', type: 'temp' }
+ ])
+ })
+
+ it('are none for a run with no outputs yet', () => {
+ expect(outputFilesOf(undefined)).toEqual([])
+ expect(outputFilesOf({ status: {} })).toEqual([])
+ expect(outputFilesOf({ outputs: [] })).toEqual([])
+ })
+
+ it('tell two files apart by kind, folder and name', () => {
+ const file = { filename: 'a.png', subfolder: 'x', type: 'output' }
+
+ expect(outputFileKey(file)).toBe(outputFileKey({ ...file }))
+ expect(outputFileKey(file)).not.toBe(outputFileKey({ ...file, subfolder: '' }))
+ expect(outputFileKey(file)).not.toBe(outputFileKey({ ...file, type: 'temp' }))
+ expect(outputFileKey({ filename: 'b', subfolder: 'a/', type: 'output' })).not.toBe(
+ outputFileKey({ filename: '/b', subfolder: 'a', type: 'output' })
+ )
+ })
+})
+
+describe('the queue as an app page sees it', () => {
+ const someoneElsesGraph = { 3: { class_type: 'KSampler', inputs: { seed: 1 } } }
+ const queue = {
+ queue_running: [[4, 'other-run', someoneElsesGraph, { client_id: 'their-window' }, ['9']]],
+ queue_pending: [
+ [6, RUN, { 1: {} }, { comfy_app: { name: 'Remove Background', seconds: 12 } }, []],
+ [5, 'tagged-run', { 1: {} }, { comfy_app: { name: 'Upscale', seconds: 90 } }, []],
+ 'junk'
+ ]
+ }
+
+ it('shows where its own run stands and what is ahead of it, in order', () => {
+ expect(queueViewOf(queue, (id) => id === RUN)).toEqual({
+ running: [{ n: 4, id: null, app: null, seconds: null }],
+ pending: [
+ { n: 5, id: null, app: 'Upscale', seconds: 90 },
+ { n: 6, id: RUN, app: 'Remove Background', seconds: 12 }
+ ]
+ })
+ })
+
+ it("never carries another run's id, graph or settings", () => {
+ const seen = JSON.stringify(queueViewOf(queue, (id) => id === RUN))
+
+ expect(seen).not.toContain('other-run')
+ expect(seen).not.toContain('tagged-run')
+ expect(seen).not.toContain('KSampler')
+ expect(seen).not.toContain('their-window')
+ })
+
+ it('drops an app name too long to be one, and reads an unreadable queue as empty', () => {
+ const long = { queue_running: [[1, 'x', {}, { comfy_app: { name: 'n'.repeat(41) } }]] }
+
+ expect(queueViewOf(long, () => false).running).toEqual([
+ { n: 1, id: null, app: null, seconds: null }
+ ])
+ expect(queueViewOf(null, () => true)).toEqual({ running: [], pending: [] })
+ expect(queueViewOf({ queue_running: 'no' }, () => true)).toEqual({ running: [], pending: [] })
+ })
+})
diff --git a/src/main/apps/localCalls.ts b/src/main/apps/localCalls.ts
new file mode 100644
index 000000000..161b36925
--- /dev/null
+++ b/src/main/apps/localCalls.ts
@@ -0,0 +1,191 @@
+export const MAX_UPLOAD_BYTES = 50_000_000
+export const MAX_JSON_BODY_CHARS = 4_000_000
+export const UPLOAD_SUBFOLDER = 'comfy-apps'
+
+const PATHNAME = /^(\/[A-Za-z0-9_.+-]+){1,2}$/
+const PROMPT_ID = /^[A-Za-z0-9-]{1,64}$/
+const NODE_CLASS = /^[A-Za-z0-9_][A-Za-z0-9_.+-]{0,127}$/
+const FILE_NAME = /^[^\\/\0]{1,255}$/
+const SUBFOLDER = /^[^\\\0]{0,255}$/
+const UPLOAD_NAME =
+ /^[A-Za-z0-9][A-Za-z0-9._-]{0,119}\.(png|jpe?g|webp|gif|mp4|mov|m4v|webm|mp3|wav|flac|ogg|m4a)$/i
+const FILE_TYPES: ReadonlySet = new Set(['output', 'temp'])
+const APP_NAME_MAX_CHARS = 40
+
+export interface OutputFile {
+ filename: string
+ subfolder: string
+ type: string
+}
+
+export type LocalCall =
+ | { kind: 'queue' }
+ | { kind: 'history'; promptId: string }
+ | { kind: 'view'; file: OutputFile }
+ | { kind: 'object-info'; node: string }
+ | { kind: 'prompt'; prompt: Record; extraData: Record }
+ | { kind: 'upload'; bytes: Uint8Array; fileName: string }
+ | { kind: 'leave-queue'; promptIds: string[] }
+ | { kind: 'interrupt'; promptId: string }
+
+function isRecord(value: unknown): value is Record {
+ return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function jsonBody(body: unknown): Record | null {
+ if (typeof body !== 'string' || body.length > MAX_JSON_BODY_CHARS) return null
+ try {
+ const parsed: unknown = JSON.parse(body)
+ return isRecord(parsed) ? parsed : null
+ } catch {
+ return null
+ }
+}
+
+function bytesOf(body: unknown): Uint8Array | null {
+ if (body instanceof Uint8Array) return body
+ if (body instanceof ArrayBuffer) return new Uint8Array(body)
+ return null
+}
+
+function hasParentStep(subfolder: string): boolean {
+ return subfolder.split('/').includes('..')
+}
+
+function viewCall(query: URLSearchParams): LocalCall | null {
+ const filename = query.get('filename') ?? ''
+ const subfolder = query.get('subfolder') ?? ''
+ const type = query.get('type') ?? 'output'
+ if (!FILE_NAME.test(filename) || !SUBFOLDER.test(subfolder) || hasParentStep(subfolder)) {
+ return null
+ }
+ return FILE_TYPES.has(type) ? { kind: 'view', file: { filename, subfolder, type } } : null
+}
+
+function readGet(pathname: string, query: URLSearchParams): LocalCall | null {
+ if (pathname === '/queue') return { kind: 'queue' }
+ if (pathname === '/view') return viewCall(query)
+ const [, area, name = ''] = pathname.split('/')
+ if (area === 'history' && PROMPT_ID.test(name)) return { kind: 'history', promptId: name }
+ if (area === 'object_info' && NODE_CLASS.test(name)) return { kind: 'object-info', node: name }
+ return null
+}
+
+function promptCall(body: unknown): LocalCall | null {
+ const sent = jsonBody(body)
+ if (!sent || !isRecord(sent['prompt'])) return null
+ const extraData = isRecord(sent['extra_data']) ? sent['extra_data'] : {}
+ return { kind: 'prompt', prompt: sent['prompt'], extraData }
+}
+
+function uploadCall(body: unknown, fileName: unknown): LocalCall | null {
+ const bytes = bytesOf(body)
+ if (!bytes || bytes.byteLength === 0 || bytes.byteLength > MAX_UPLOAD_BYTES) return null
+ if (typeof fileName !== 'string' || !UPLOAD_NAME.test(fileName)) return null
+ return { kind: 'upload', bytes, fileName }
+}
+
+function leaveQueueCall(body: unknown): LocalCall | null {
+ const ids = jsonBody(body)?.['delete']
+ if (!Array.isArray(ids) || ids.length === 0) return null
+ const promptIds = ids.filter((id): id is string => typeof id === 'string' && PROMPT_ID.test(id))
+ return promptIds.length === ids.length ? { kind: 'leave-queue', promptIds } : null
+}
+
+function interruptCall(body: unknown): LocalCall | null {
+ const promptId = jsonBody(body)?.['prompt_id']
+ return typeof promptId === 'string' && PROMPT_ID.test(promptId)
+ ? { kind: 'interrupt', promptId }
+ : null
+}
+
+function readPost(pathname: string, body: unknown, fileName: unknown): LocalCall | null {
+ if (pathname === '/prompt') return promptCall(body)
+ if (pathname === '/upload/image') return uploadCall(body, fileName)
+ if (pathname === '/queue') return leaveQueueCall(body)
+ if (pathname === '/interrupt') return interruptCall(body)
+ return null
+}
+
+export function readLocalCall(raw: unknown): LocalCall | null {
+ if (!isRecord(raw)) return null
+ const { method = 'GET', path, body, fileName } = raw
+ if (typeof path !== 'string') return null
+ const queryAt = path.indexOf('?')
+ const pathname = queryAt < 0 ? path : path.slice(0, queryAt)
+ if (!PATHNAME.test(pathname)) return null
+ const query = new URLSearchParams(queryAt < 0 ? '' : path.slice(queryAt + 1))
+ if (method === 'GET') return readGet(pathname, query)
+ if (method === 'POST') return readPost(pathname, body, fileName)
+ return null
+}
+
+export function outputFilesOf(historyEntry: unknown): OutputFile[] {
+ if (!isRecord(historyEntry) || !isRecord(historyEntry['outputs'])) return []
+ const files: OutputFile[] = []
+ for (const nodeOutput of Object.values(historyEntry['outputs'])) {
+ if (!isRecord(nodeOutput)) continue
+ for (const list of Object.values(nodeOutput)) {
+ if (!Array.isArray(list)) continue
+ for (const file of list) {
+ if (!isRecord(file) || typeof file['filename'] !== 'string') continue
+ files.push({
+ filename: file['filename'],
+ subfolder: typeof file['subfolder'] === 'string' ? file['subfolder'] : '',
+ type: typeof file['type'] === 'string' ? file['type'] : 'output'
+ })
+ }
+ }
+ }
+ return files
+}
+
+export function outputFileKey(file: OutputFile): string {
+ return JSON.stringify([file.type, file.subfolder, file.filename])
+}
+
+export interface QueuedRun {
+ n: number
+ id: string | null
+ app: string | null
+ seconds: number | null
+}
+
+export interface QueueView {
+ running: QueuedRun[]
+ pending: QueuedRun[]
+}
+
+function appTagOf(extraData: unknown): Pick {
+ const tag = isRecord(extraData) ? extraData['comfy_app'] : null
+ if (!isRecord(tag)) return { app: null, seconds: null }
+ const name = tag['name']
+ const seconds = tag['seconds']
+ return {
+ app: typeof name === 'string' && name.length <= APP_NAME_MAX_CHARS ? name : null,
+ seconds: typeof seconds === 'number' && seconds > 0 ? seconds : null
+ }
+}
+
+function queuedRuns(list: unknown, isOwn: (promptId: string) => boolean): QueuedRun[] {
+ if (!Array.isArray(list)) return []
+ return list
+ .filter((entry): entry is unknown[] => Array.isArray(entry))
+ .map((entry) => {
+ const promptId = typeof entry[1] === 'string' ? entry[1] : null
+ return {
+ n: typeof entry[0] === 'number' ? entry[0] : 0,
+ id: promptId !== null && isOwn(promptId) ? promptId : null,
+ ...appTagOf(entry[3])
+ }
+ })
+ .sort((one, other) => one.n - other.n)
+}
+
+export function queueViewOf(queue: unknown, isOwn: (promptId: string) => boolean): QueueView {
+ const body = isRecord(queue) ? queue : {}
+ return {
+ running: queuedRuns(body['queue_running'], isOwn),
+ pending: queuedRuns(body['queue_pending'], isOwn)
+ }
+}
diff --git a/src/main/apps/localComfy.integration.test.ts b/src/main/apps/localComfy.integration.test.ts
new file mode 100644
index 000000000..0d1599982
--- /dev/null
+++ b/src/main/apps/localComfy.integration.test.ts
@@ -0,0 +1,177 @@
+import { spawn } from 'node:child_process'
+import type { ChildProcess } from 'node:child_process'
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { createServer } from 'node:net'
+import type { AddressInfo } from 'node:net'
+import os from 'node:os'
+import path from 'node:path'
+import type { WebContents } from 'electron'
+import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest'
+
+import {
+ FAKE_COMFY_API_SERVER,
+ FAKE_OUTPUT_TEXT,
+ SOMEONE_ELSES_RUN
+} from './__fixtures__/fakeComfyApi'
+import type { FakeComfySeen } from './__fixtures__/fakeComfyApi'
+
+const mocks = vi.hoisted(() => ({
+ sessions: new Map>(),
+ pages: [] as { send: (channel: string, event: unknown) => void }[]
+}))
+
+vi.mock('../host/registry', () => ({ getEntryByInstallationId: () => undefined }))
+vi.mock('../installations', () => ({
+ list: async () => [
+ {
+ id: 'studio',
+ name: 'Studio',
+ sourceId: 'standalone',
+ installPath: '/builds/studio',
+ status: 'installed',
+ version: 'v0.42.1'
+ }
+ ],
+ get: async () => null
+}))
+vi.mock('../lib/comfyDownloadManager', () => ({ startManagedModelJob: vi.fn() }))
+vi.mock('../lib/comfyProcessRecord', () => ({ probeQueue: async () => null }))
+vi.mock('../lib/i18n', () => ({ t: (key: string) => key }))
+vi.mock('../lib/ipc/sessionActions/launch', () => ({ handleLaunch: vi.fn() }))
+vi.mock('../lib/ipc/shared', async () => {
+ const { EventEmitter } = await import('node:events')
+ return {
+ _hasActiveLaunch: () => false,
+ _operationAborts: new Map(),
+ _runningSessions: mocks.sessions,
+ sessionLifecycleEvents: new EventEmitter(),
+ sourceMap: { standalone: { category: 'local' } },
+ stopRunning: vi.fn()
+ }
+})
+vi.mock('../lib/models', () => ({ resolveComfyDir: (installPath: string) => installPath }))
+vi.mock('../lib/process', () => ({ COMFY_BOOT_TIMEOUT_MS: 300_000 }))
+vi.mock('./appsPages', () => ({ liveAppsPages: () => mocks.pages }))
+
+import * as local from './localComfy'
+
+const WANT = { minVersion: '0.41.0' }
+const PAGE = {} as WebContents
+const localState = (want: unknown) => local.localState(PAGE, want)
+const localFetch = (raw: unknown) => local.localFetch(PAGE, raw)
+
+let comfy: ChildProcess
+let scriptDir = ''
+let port = 0
+
+function freePort(): Promise {
+ return new Promise((resolve) => {
+ const probe = createServer()
+ probe.listen(0, '127.0.0.1', () => {
+ const { port: free } = probe.address() as AddressInfo
+ probe.close(() => resolve(free))
+ })
+ })
+}
+
+function textOf(answer: { body: Uint8Array }): Record {
+ return JSON.parse(new TextDecoder().decode(answer.body)) as Record
+}
+
+async function whatComfySaw(): Promise {
+ return (await (await fetch(`http://127.0.0.1:${port}/e2e/seen`)).json()) as FakeComfySeen
+}
+
+beforeAll(async () => {
+ port = await freePort()
+ scriptDir = mkdtempSync(path.join(os.tmpdir(), 'comfy-apps-local-'))
+ const script = path.join(scriptDir, 'fake-comfy.cjs')
+ writeFileSync(script, FAKE_COMFY_API_SERVER)
+ comfy = spawn(process.execPath, [script, '--port', String(port)], {
+ stdio: ['ignore', 'pipe', 'inherit']
+ })
+ await new Promise((resolve) => {
+ comfy.stdout?.on('data', (line: Buffer) => {
+ if (String(line).includes('To see the GUI')) resolve()
+ })
+ })
+ mocks.sessions.set('studio', { port })
+})
+
+afterAll(() => {
+ local._resetForTest()
+ comfy?.kill()
+ if (scriptDir) rmSync(scriptDir, { recursive: true, force: true })
+})
+
+describe('a run on a ComfyUI that really answers and really talks over its socket', () => {
+ it("goes from a picture to its result, with ComfyUI's updates reaching the page on the way", async () => {
+ const updates: string[] = []
+ mocks.pages = [{ send: (_channel, event) => updates.push((event as { type: string }).type) }]
+
+ const state = await localState(WANT)
+ const uploaded = textOf(
+ await localFetch({
+ method: 'POST',
+ path: '/upload/image',
+ body: new Uint8Array([1, 2, 3, 4]),
+ fileName: 'photo.png'
+ })
+ )
+ const started = textOf(
+ await localFetch({
+ method: 'POST',
+ path: '/prompt',
+ body: JSON.stringify({
+ prompt: { load: { class_type: 'LoadImage', inputs: { image: 'comfy-apps/photo.png' } } },
+ client_id: 'the-page',
+ extra_data: { comfy_app: { name: 'Remove Background' } }
+ })
+ })
+ )
+ const run = String(started['prompt_id'])
+ await vi.waitFor(() => expect(updates).toContain('execution_success'), { timeout: 10_000 })
+ const history = textOf(await localFetch({ path: `/history/${run}` }))
+ const entry = history[run] as { outputs: { save: { images: Record[] } } }
+ const file = entry.outputs.save.images[0] ?? {}
+ const result = await localFetch({ path: `/view?${new URLSearchParams(file)}` })
+
+ expect(state).toMatchObject({ state: 'running', name: 'Studio', version: '0.42.1' })
+ expect(uploaded).toEqual({ name: 'photo.png', subfolder: 'comfy-apps', type: 'input' })
+ expect(updates).toEqual(['execution_start', 'executing', 'execution_success'])
+ expect(new TextDecoder().decode(result.body)).toBe(FAKE_OUTPUT_TEXT)
+ expect(result.contentType).toBe('image/png')
+
+ const seen = await whatComfySaw()
+ expect(seen.sockets).toEqual([state.clientId])
+ expect(seen.prompts).toEqual([
+ { id: run, clientId: state.clientId, app: 'Remove Background', nodes: ['load'] }
+ ])
+ expect(seen.uploads).toEqual([
+ { name: 'photo.png', subfolder: 'comfy-apps', overwrite: false, bytes: expect.any(Number) }
+ ])
+ })
+
+ it('shows the queue without the other run in it, and can stop only its own run', async () => {
+ const queue = textOf(await localFetch({ path: '/queue' }))
+ const own = (await whatComfySaw()).prompts[0]?.id ?? ''
+ const stopOf = (promptId: string) =>
+ localFetch({
+ method: 'POST',
+ path: '/interrupt',
+ body: JSON.stringify({ prompt_id: promptId })
+ })
+
+ expect(queue).toEqual({ running: [{ n: 1, id: null, app: null, seconds: null }], pending: [] })
+ expect((await stopOf(SOMEONE_ELSES_RUN)).status).toBe(403)
+ expect((await stopOf(own)).status).toBe(200)
+ expect((await whatComfySaw()).interrupted).toEqual([own])
+ })
+
+ it('never lets a request outside the list reach ComfyUI', async () => {
+ const refused = await localFetch({ path: '/system_stats' })
+
+ expect(refused.status).toBe(403)
+ expect((await whatComfySaw()).asked).not.toContain('GET /system_stats')
+ })
+})
diff --git a/src/main/apps/localComfy.test.ts b/src/main/apps/localComfy.test.ts
new file mode 100644
index 000000000..e38f12e2f
--- /dev/null
+++ b/src/main/apps/localComfy.test.ts
@@ -0,0 +1,760 @@
+import type { WebContents } from 'electron'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mocks = vi.hoisted(() => ({
+ records: [] as Record[],
+ sessions: new Map>(),
+ launching: new Set(),
+ windows: new Map(),
+ pages: [] as { send: (channel: string, event: unknown) => void }[],
+ handleLaunch: (_ctx: unknown): Promise> => Promise.resolve({ ok: false }),
+ stopRunning: (_id: string): Promise => Promise.resolve(),
+ probeQueue: (_port: number): Promise => Promise.resolve({ running: 0, pending: 0 }),
+ startModelJob: (_options: Record): Promise => Promise.resolve(null),
+ makeRelay: (): unknown => null,
+ hearFromComfy: (_message: unknown): void => {}
+}))
+
+vi.mock('fs', () => ({
+ promises: { readFile: async () => Promise.reject(new Error('ENOENT')) }
+}))
+vi.mock('../host/registry', () => ({
+ getEntryByInstallationId: (id: string) => mocks.windows.get(id)
+}))
+vi.mock('../installations', () => ({
+ list: async () => mocks.records,
+ get: async (id: string) => mocks.records.find((record) => record['id'] === id) ?? null
+}))
+vi.mock('../lib/comfyDownloadManager', () => ({
+ startManagedModelJob: (options: Record) => mocks.startModelJob(options)
+}))
+vi.mock('../lib/comfyProcessRecord', () => ({
+ probeQueue: (port: number) => mocks.probeQueue(port)
+}))
+vi.mock('../lib/i18n', () => ({
+ t: (key: string, params?: Record) =>
+ params ? `${key} ${Object.values(params).join(' ')}` : key
+}))
+vi.mock('../lib/ipc/sessionActions/launch', () => ({
+ handleLaunch: (ctx: unknown) => mocks.handleLaunch(ctx)
+}))
+vi.mock('../lib/ipc/shared', async () => {
+ const { EventEmitter: Emitter } = await import('node:events')
+ return {
+ _hasActiveLaunch: (id: string) => mocks.launching.has(id),
+ _operationAborts: new Map(),
+ _runningSessions: mocks.sessions,
+ sessionLifecycleEvents: new Emitter(),
+ sourceMap: { standalone: { category: 'local' } },
+ stopRunning: (id: string) => mocks.stopRunning(id)
+ }
+})
+vi.mock('../lib/models', () => ({
+ resolveComfyDir: (installPath: string) => `${installPath}/ComfyUI`
+}))
+vi.mock('../lib/process', () => ({ COMFY_BOOT_TIMEOUT_MS: 300_000 }))
+vi.mock('./appsPages', () => ({ liveAppsPages: () => mocks.pages }))
+vi.mock('./localRelay', () => ({
+ createLocalRelay: (onMessage: (message: unknown) => void) => {
+ mocks.hearFromComfy = onMessage
+ return mocks.makeRelay()
+ }
+}))
+
+import { sessionLifecycleEvents } from '../lib/ipc/shared'
+import * as local from './localComfy'
+
+const { LOCAL_EVENT_CHANNEL, LOCAL_IDLE_STOP_MS, _resetForTest } = local
+
+const STUDIO = 'studio'
+const PORT = 8190
+const LAB = 'lab'
+const LAB_PORT = 8191
+const RUN = '0b1c2d3e-aaaa-bbbb-cccc-0123456789ab'
+const OTHER_RUN = 'ffffffff-aaaa-bbbb-cccc-0123456789ab'
+const WANT = { minVersion: '0.41.0' }
+const CUTOUT = { filename: 'cutout_00001_.png', subfolder: 'apps', type: 'output' }
+const BIREFNET = {
+ url: 'https://huggingface.co/Comfy-Org/BiRefNet/resolve/main/background_removal/birefnet.safetensors',
+ folder: 'background_removal',
+ name: 'birefnet.safetensors'
+}
+
+interface Asked {
+ port: number
+ method: string
+ path: string
+ body: unknown
+}
+
+class FakeComfy {
+ asked: Asked[] = []
+ queue = {
+ queue_running: [[4, OTHER_RUN, { 3: { class_type: 'KSampler' } }, { client_id: 'theirs' }]],
+ queue_pending: [[5, RUN, { 1: {} }, { comfy_app: { name: 'Remove Background' } }]]
+ }
+ promptAnswer: { status: number; body: unknown } = {
+ status: 200,
+ body: { prompt_id: RUN, number: 5, node_errors: {} }
+ }
+
+ answer = async (input: string | URL | Request, init: RequestInit = {}): Promise => {
+ const url = new URL(String(input))
+ const path = url.pathname + url.search
+ const body =
+ typeof init.body === 'string' ? (JSON.parse(init.body) as unknown) : (init.body ?? null)
+ this.asked.push({ port: Number(url.port), method: init.method ?? 'GET', path, body })
+ const json = (value: unknown, status = 200) =>
+ new Response(JSON.stringify(value), {
+ status,
+ headers: { 'content-type': 'application/json' }
+ })
+ if (![PORT, LAB_PORT].includes(Number(url.port))) throw new TypeError('fetch failed')
+ if (url.pathname === '/queue' && init.method !== 'POST') return json(this.queue)
+ if (url.pathname === '/prompt') return json(this.promptAnswer.body, this.promptAnswer.status)
+ if (url.pathname === `/history/${RUN}`) {
+ return json({
+ [RUN]: { status: { completed: true }, outputs: { save: { images: [CUTOUT] } } }
+ })
+ }
+ if (url.pathname === '/view') {
+ return new Response(new Uint8Array([137, 80, 78, 71]), {
+ headers: { 'content-type': 'image/png' }
+ })
+ }
+ if (url.pathname === '/upload/image') {
+ return json({ name: 'photo.png', subfolder: 'comfy-apps', type: 'input' })
+ }
+ return json({})
+ }
+
+ calls(path: string): Asked[] {
+ return this.asked.filter((asked) => asked.path === path)
+ }
+}
+
+interface FakeRelay {
+ clientId: string
+ follow: ReturnType
+ whenOpen: ReturnType
+ stop: ReturnType
+}
+
+type FakePage = { send: ReturnType void>> }
+
+let comfy: FakeComfy
+let relay: FakeRelay
+let page: FakePage
+
+const asContents = (from: FakePage): WebContents => from as unknown as WebContents
+const localState = (want: unknown, from: FakePage = page) =>
+ local.localState(asContents(from), want)
+const startLocal = (want: unknown, from: FakePage = page) =>
+ local.startLocal(asContents(from), want)
+const localFetch = (raw: unknown, from: FakePage = page) => local.localFetch(asContents(from), raw)
+const localDownload = (raw: unknown, from: FakePage = page) =>
+ local.localDownload(asContents(from), raw)
+
+function fakeRelay(clientId: string): FakeRelay {
+ return { clientId, follow: vi.fn(), whenOpen: vi.fn(async () => true), stop: vi.fn() }
+}
+let launches: Record[]
+let stopped: string[]
+
+function build(over: Record = {}): Record {
+ return {
+ id: STUDIO,
+ name: 'Studio',
+ sourceId: 'standalone',
+ installPath: '/builds/studio',
+ status: 'installed',
+ version: 'v0.42.1',
+ ...over
+ }
+}
+
+function running(id = STUDIO, port = PORT): void {
+ mocks.sessions.set(id, { port })
+}
+
+function startsWhenLaunched(port = PORT): void {
+ mocks.handleLaunch = async (ctx) => {
+ const launch = ctx as { installationId: string }
+ launches.push(ctx as Record)
+ running(launch.installationId, port)
+ return { ok: true, mode: 'console', port }
+ }
+}
+
+function textOf(answer: { body: Uint8Array }): unknown {
+ return JSON.parse(new TextDecoder().decode(answer.body))
+}
+
+function post(path: string, body: unknown): Promise<{ status: number; body: Uint8Array }> {
+ return localFetch({ method: 'POST', path, body: JSON.stringify(body) })
+}
+
+async function startARun(): Promise {
+ await post('/prompt', { prompt: { 1: { class_type: 'LoadImage', inputs: {} } } })
+}
+
+function sentToPage(): unknown[] {
+ return page.send.mock.calls
+ .filter(([channel]) => channel === LOCAL_EVENT_CHANNEL)
+ .map(([, event]) => event)
+}
+
+beforeEach(() => {
+ vi.useFakeTimers()
+ _resetForTest()
+ comfy = new FakeComfy()
+ vi.stubGlobal('fetch', vi.fn(comfy.answer))
+ relay = fakeRelay('desktop-client')
+ page = { send: vi.fn<(channel: string, event: unknown) => void>() }
+ launches = []
+ stopped = []
+ mocks.makeRelay = () => relay
+ mocks.pages = [page]
+ mocks.records = [build()]
+ mocks.sessions.clear()
+ mocks.launching.clear()
+ mocks.windows.clear()
+ mocks.handleLaunch = async () => ({ ok: false })
+ mocks.stopRunning = async (id) => {
+ stopped.push(id)
+ mocks.sessions.delete(id)
+ }
+ mocks.probeQueue = async () => ({ running: 0, pending: 0 })
+ mocks.startModelJob = async () => null
+})
+
+afterEach(() => {
+ _resetForTest()
+ vi.unstubAllGlobals()
+ vi.useRealTimers()
+})
+
+describe('finding a ComfyUI on this computer for an app', () => {
+ it('says to add a build when there is none', async () => {
+ mocks.records = []
+
+ expect(await localState(WANT)).toEqual({
+ state: 'unsupported',
+ error: 'apps.local.noBuilds'
+ })
+ })
+
+ it('says which ComfyUI the app needs when every build is older', async () => {
+ mocks.records = [build({ version: 'v0.37.0' })]
+
+ expect(await localState(WANT)).toEqual({
+ state: 'unsupported',
+ error: 'apps.local.tooOld 0.41.0'
+ })
+ })
+
+ it('offers a stopped build that fits, by its name and version', async () => {
+ expect(await localState(WANT)).toEqual({
+ state: 'stopped',
+ own: true,
+ name: 'Studio',
+ version: '0.42.1'
+ })
+ expect(relay.follow).not.toHaveBeenCalled()
+ })
+
+ it('says a build is running and follows it, without starting anything', async () => {
+ running()
+
+ expect(await localState(WANT)).toEqual({
+ state: 'running',
+ own: true,
+ name: 'Studio',
+ version: '0.42.1',
+ clientId: 'desktop-client'
+ })
+ expect(relay.follow).toHaveBeenCalledWith(PORT)
+ expect(launches).toEqual([])
+ })
+})
+
+describe('starting it', () => {
+ it('starts the build without a window and answers once Desktop is listening to it', async () => {
+ startsWhenLaunched()
+
+ expect(await startLocal(WANT)).toEqual({
+ state: 'running',
+ own: true,
+ name: 'Studio',
+ version: '0.42.1',
+ clientId: 'desktop-client'
+ })
+ expect(launches).toHaveLength(1)
+ expect(launches[0]).toMatchObject({
+ installationId: STUDIO,
+ inst: { id: STUDIO },
+ actionData: { launchModeOverride: 'console', autoPortOnConflict: true }
+ })
+ expect(relay.follow).toHaveBeenCalledWith(PORT)
+ expect(relay.whenOpen).toHaveBeenCalled()
+ })
+
+ it('starts it once when two pages ask together', async () => {
+ startsWhenLaunched()
+
+ const [one, other] = await Promise.all([startLocal(WANT), startLocal(WANT)])
+
+ expect(one.state).toBe('running')
+ expect(other.state).toBe('running')
+ expect(launches).toHaveLength(1)
+ })
+
+ it('leaves a running build as it is', async () => {
+ running()
+ startsWhenLaunched()
+
+ expect((await startLocal(WANT)).state).toBe('running')
+ expect(launches).toEqual([])
+ })
+
+ it('waits for a start the person already began instead of starting it again', async () => {
+ mocks.launching.add(STUDIO)
+ startsWhenLaunched()
+
+ const starting = startLocal(WANT)
+ await vi.advanceTimersByTimeAsync(1_200)
+ running()
+ mocks.launching.delete(STUDIO)
+ await vi.advanceTimersByTimeAsync(600)
+
+ expect((await starting).state).toBe('running')
+ expect(launches).toEqual([])
+ })
+
+ it('says why when the build does not start', async () => {
+ mocks.handleLaunch = async () => ({ ok: false, message: 'Port 8188 is in use.' })
+
+ expect(await startLocal(WANT)).toEqual({
+ state: 'stopped',
+ own: true,
+ name: 'Studio',
+ version: '0.42.1',
+ error: 'Port 8188 is in use.'
+ })
+ })
+
+ it('names the build when the launch gives no reason, or throws', async () => {
+ mocks.handleLaunch = async () => ({ ok: false })
+ expect((await startLocal(WANT)).error).toBe('apps.local.couldNotStart Studio')
+
+ mocks.handleLaunch = async () => {
+ throw new Error('spawn failed')
+ }
+ expect((await startLocal(WANT)).error).toBe('spawn failed')
+ })
+
+ it('starts nothing when no build fits', async () => {
+ mocks.records = []
+ startsWhenLaunched()
+
+ expect((await startLocal(WANT)).state).toBe('unsupported')
+ expect(launches).toEqual([])
+ })
+})
+
+describe('a run from an app page', () => {
+ beforeEach(async () => {
+ running()
+ await localState(WANT)
+ })
+
+ it("is sent as Desktop's client, whatever client the page named", async () => {
+ const prompt = { 1: { class_type: 'LoadImage', inputs: { image: 'a.png' } } }
+ const extraData = { comfy_app: { name: 'Remove Background', seconds: 12 } }
+
+ const answer = await post('/prompt', {
+ prompt,
+ client_id: 'the-page',
+ extra_data: extraData
+ })
+
+ expect(answer.status).toBe(200)
+ expect(textOf(answer)).toMatchObject({ prompt_id: RUN })
+ expect(comfy.calls('/prompt')).toEqual([
+ {
+ port: PORT,
+ method: 'POST',
+ path: '/prompt',
+ body: { prompt, client_id: 'desktop-client', extra_data: extraData }
+ }
+ ])
+ expect(relay.whenOpen).toHaveBeenCalled()
+ })
+
+ it('can then be read, and its result files fetched', async () => {
+ await startARun()
+
+ const history = await localFetch({ path: `/history/${RUN}` })
+ const file = await localFetch({ path: `/view?${new URLSearchParams(CUTOUT)}` })
+
+ expect(textOf(history)).toMatchObject({ [RUN]: { status: { completed: true } } })
+ expect(file).toMatchObject({ status: 200, contentType: 'image/png' })
+ expect([...file.body]).toEqual([137, 80, 78, 71])
+ expect(comfy.calls(`/view?${new URLSearchParams(CUTOUT)}`)).toHaveLength(1)
+ })
+
+ it('can be taken out of the queue and stopped', async () => {
+ await startARun()
+
+ expect((await post('/queue', { delete: [RUN] })).status).toBe(200)
+ expect((await post('/interrupt', { prompt_id: RUN })).status).toBe(200)
+ expect(comfy.asked.slice(-2)).toEqual([
+ { port: PORT, method: 'POST', path: '/queue', body: { delete: [RUN] } },
+ { port: PORT, method: 'POST', path: '/interrupt', body: { prompt_id: RUN } }
+ ])
+ })
+
+ it("passes ComfyUI's own refusal of a graph back to the page", async () => {
+ comfy.promptAnswer = { status: 400, body: { error: { type: 'prompt_no_outputs' } } }
+
+ const answer = await post('/prompt', { prompt: {} })
+
+ expect(answer.status).toBe(400)
+ expect(textOf(answer)).toEqual({ error: { type: 'prompt_no_outputs' } })
+ })
+})
+
+describe("what is not the page's own", () => {
+ beforeEach(async () => {
+ running()
+ await localState(WANT)
+ })
+
+ it('cannot be read, fetched, removed or stopped', async () => {
+ await startARun()
+ const before = comfy.asked.length
+
+ const refused = [
+ await localFetch({ path: `/history/${OTHER_RUN}` }),
+ await localFetch({ path: '/view?filename=someone-elses.png&type=output' }),
+ await post('/queue', { delete: [RUN, OTHER_RUN] }),
+ await post('/interrupt', { prompt_id: OTHER_RUN })
+ ]
+
+ expect(refused.map((answer) => answer.status)).toEqual([403, 403, 403, 403])
+ expect(textOf(refused[0]!)).toEqual({ error: 'apps.local.notForwarded' })
+ expect(comfy.asked).toHaveLength(before)
+ })
+
+ it('cannot be fetched before the run that made it was read', async () => {
+ await startARun()
+
+ const early = await localFetch({ path: `/view?${new URLSearchParams(CUTOUT)}` })
+
+ expect(early.status).toBe(403)
+ })
+
+ it('shows in the queue only as something ahead, with no id or graph', async () => {
+ await startARun()
+
+ const queue = await localFetch({ path: '/queue' })
+
+ expect(textOf(queue)).toEqual({
+ running: [{ n: 4, id: null, app: null, seconds: null }],
+ pending: [{ n: 5, id: RUN, app: 'Remove Background', seconds: null }]
+ })
+ expect(new TextDecoder().decode(queue.body)).not.toContain('KSampler')
+ })
+
+ it('is out of reach through any other request, which never gets to ComfyUI', async () => {
+ const refused = [
+ await localFetch({ path: '/system_stats' }),
+ await localFetch({ path: '/history' }),
+ await localFetch({ path: '/userdata/workflows' }),
+ await post('/free', { unload_models: true }),
+ await post('/queue', { clear: true }),
+ await localFetch({ method: 'DELETE', path: '/queue' }),
+ await localFetch(null)
+ ]
+
+ expect(refused.map((answer) => answer.status)).toEqual([403, 403, 403, 403, 403, 403, 403])
+ expect(comfy.asked).toEqual([])
+ })
+})
+
+describe('two app pages open in two windows', () => {
+ it('each reach the ComfyUI their own app was given, as its own client', async () => {
+ const other: FakePage = { send: vi.fn<(channel: string, event: unknown) => void>() }
+ const relays = [fakeRelay('client-for-studio'), fakeRelay('client-for-lab')]
+ mocks.makeRelay = () => relays.shift()
+ mocks.records = [
+ build({ version: 'v0.30.0', lastLaunchedAt: 900 }),
+ build({ id: LAB, name: 'Lab', installPath: '/builds/lab', lastLaunchedAt: 100 })
+ ]
+ running(STUDIO, PORT)
+ running(LAB, LAB_PORT)
+
+ const forOlderApp = await localState({ minVersion: '0.21.0' })
+ const forNewerApp = await localState({ minVersion: '0.41.0' }, other)
+ await post('/prompt', { prompt: { 1: {} } })
+ await localFetch(
+ { method: 'POST', path: '/prompt', body: JSON.stringify({ prompt: { 2: {} } }) },
+ other
+ )
+
+ expect(forOlderApp).toMatchObject({ name: 'Studio', clientId: 'client-for-studio' })
+ expect(forNewerApp).toMatchObject({ name: 'Lab', clientId: 'client-for-lab' })
+ expect(comfy.calls('/prompt').map(({ port, body }) => [port, body])).toEqual([
+ [PORT, { prompt: { 1: {} }, client_id: 'client-for-studio', extra_data: {} }],
+ [LAB_PORT, { prompt: { 2: {} }, client_id: 'client-for-lab', extra_data: {} }]
+ ])
+ })
+})
+
+describe('sending a picture', () => {
+ it("puts it in the apps folder of ComfyUI's input, without replacing a file of that name", async () => {
+ running()
+ await localState(WANT)
+
+ const answer = await localFetch({
+ method: 'POST',
+ path: '/upload/image',
+ body: new Uint8Array([1, 2, 3]),
+ fileName: 'photo.png'
+ })
+
+ const [sent] = comfy.calls('/upload/image')
+ const form = sent?.body as FormData
+ const file = form.get('image') as File
+ expect(textOf(answer)).toEqual({ name: 'photo.png', subfolder: 'comfy-apps', type: 'input' })
+ expect(file.name).toBe('photo.png')
+ expect([...new Uint8Array(await file.arrayBuffer())]).toEqual([1, 2, 3])
+ expect(form.get('subfolder')).toBe('comfy-apps')
+ expect(form.get('type')).toBe('input')
+ expect(form.has('overwrite')).toBe(false)
+ })
+})
+
+describe('when ComfyUI is not there', () => {
+ it('rejects, so the page can say Desktop could not reach it', async () => {
+ await localState(WANT)
+
+ await expect(localFetch({ path: '/queue' })).rejects.toThrow('apps.local.notRunning')
+ expect(comfy.asked).toEqual([])
+ })
+
+ it('rejects before any build was chosen', async () => {
+ await expect(localFetch({ path: '/queue' })).rejects.toThrow('apps.local.notRunning')
+ })
+
+ it('rejects when the build stopped answering', async () => {
+ running(STUDIO, 9_999)
+ await localState(WANT)
+
+ await expect(localFetch({ path: '/queue' })).rejects.toThrow()
+ })
+
+ it('stops following a build that has stopped', async () => {
+ running()
+ await localState(WANT)
+
+ mocks.sessions.delete(STUDIO)
+ sessionLifecycleEvents.emit('changed')
+
+ expect(relay.stop).toHaveBeenCalled()
+ })
+})
+
+describe('what ComfyUI says about a run', () => {
+ beforeEach(async () => {
+ running()
+ await localState(WANT)
+ await startARun()
+ })
+
+ it("reaches the app page for the page's own run", () => {
+ mocks.hearFromComfy({ type: 'execution_start', data: { prompt_id: RUN, timestamp: 1 } })
+ mocks.hearFromComfy({
+ type: 'progress',
+ data: { prompt_id: RUN, node: 'cut', value: 2, max: 8 }
+ })
+
+ expect(sentToPage()).toEqual([
+ { type: 'execution_start', data: { prompt_id: RUN, timestamp: 1 } },
+ { type: 'progress', data: { prompt_id: RUN, node: 'cut', value: 2, max: 8 } }
+ ])
+ })
+
+ it('does not reach it for another run, or for anything that is not a run update', () => {
+ mocks.hearFromComfy({ type: 'executing', data: { prompt_id: OTHER_RUN, node: '3' } })
+ mocks.hearFromComfy({ type: 'status', data: { status: { exec_info: { queue_remaining: 2 } } } })
+ mocks.hearFromComfy({ type: 'logs', data: { prompt_id: RUN, entries: ['secret path'] } })
+ mocks.hearFromComfy({ type: 'executing' })
+ mocks.hearFromComfy('junk')
+ mocks.hearFromComfy(null)
+
+ expect(sentToPage()).toEqual([])
+ })
+})
+
+describe('downloading a model for an app', () => {
+ function modelJob(outcome: unknown) {
+ const release = vi.fn()
+ const started: Record[] = []
+ mocks.startModelJob = async (options) => {
+ started.push(options)
+ return { id: 'job', url: BIREFNET.url, savePath: '/models/x', release, completion: outcome }
+ }
+ return { release, started }
+ }
+
+ beforeEach(async () => {
+ running()
+ await localState(WANT)
+ })
+
+ it('saves it into the build the app runs on, and says when it is there', async () => {
+ const job = modelJob(Promise.resolve({ status: 'completed', savePath: '/models/x' }))
+
+ expect(await localDownload(BIREFNET)).toEqual({ state: 'done' })
+ expect(job.started).toEqual([
+ expect.objectContaining({
+ url: BIREFNET.url,
+ filename: 'birefnet.safetensors',
+ directory: 'background_removal',
+ installationId: STUDIO
+ })
+ ])
+ expect(job.release).toHaveBeenCalledTimes(1)
+ })
+
+ it('tells the app page how far along it is, without flooding it', async () => {
+ const job = modelJob(new Promise(() => {}))
+ void localDownload(BIREFNET)
+ await vi.advanceTimersByTimeAsync(0)
+ const progress = job.started[0]?.['onProgress'] as (done: number, total: number) => void
+
+ progress(10, 400)
+ progress(20, 400)
+ await vi.advanceTimersByTimeAsync(300)
+ progress(200, 400)
+ progress(400, 400)
+
+ expect(sentToPage()).toEqual([
+ { type: 'download', data: { name: 'birefnet.safetensors', done: 10, total: 400 } },
+ { type: 'download', data: { name: 'birefnet.safetensors', done: 200, total: 400 } },
+ { type: 'download', data: { name: 'birefnet.safetensors', done: 400, total: 400 } }
+ ])
+ })
+
+ it('says why a download failed, and when the person cancelled it', async () => {
+ const failed = modelJob(Promise.resolve({ status: 'error', error: 'Disk is full.' }))
+ expect(await localDownload(BIREFNET)).toEqual({ state: 'failed', error: 'Disk is full.' })
+ expect(failed.release).toHaveBeenCalledTimes(1)
+
+ modelJob(Promise.resolve({ status: 'cancelled' }))
+ expect(await localDownload(BIREFNET)).toEqual({ state: 'cancelled' })
+ })
+
+ it('downloads nothing that is not a safetensors file on Hugging Face', async () => {
+ const job = modelJob(Promise.resolve({ status: 'completed', savePath: '/x' }))
+
+ expect(
+ await localDownload({ ...BIREFNET, url: 'https://evil.example/birefnet.safetensors' })
+ ).toEqual({ state: 'failed', error: 'apps.local.modelRefused' })
+ expect(await localDownload({ ...BIREFNET, folder: '../custom_nodes' })).toMatchObject({
+ state: 'failed'
+ })
+ expect(job.started).toEqual([])
+ })
+
+ it('downloads nothing while no ComfyUI is running for apps', async () => {
+ const job = modelJob(Promise.resolve({ status: 'completed', savePath: '/x' }))
+ mocks.sessions.clear()
+
+ expect(await localDownload(BIREFNET)).toEqual({
+ state: 'failed',
+ error: 'apps.local.notRunning'
+ })
+ expect(job.started).toEqual([])
+ })
+})
+
+describe('a ComfyUI that Desktop started for apps', () => {
+ beforeEach(async () => {
+ startsWhenLaunched()
+ await startLocal(WANT)
+ })
+
+ it('is stopped once it has sat unused for ten minutes with nothing queued', async () => {
+ await vi.advanceTimersByTimeAsync(LOCAL_IDLE_STOP_MS - 1)
+ expect(stopped).toEqual([])
+
+ await vi.advanceTimersByTimeAsync(1)
+
+ expect(stopped).toEqual([STUDIO])
+ })
+
+ it('keeps running while an app page keeps using it', async () => {
+ await vi.advanceTimersByTimeAsync(LOCAL_IDLE_STOP_MS - 1_000)
+ await localFetch({ path: '/queue' })
+ await vi.advanceTimersByTimeAsync(LOCAL_IDLE_STOP_MS - 1_000)
+
+ expect(stopped).toEqual([])
+ })
+
+ it('keeps running while it has work queued, and is stopped after that', async () => {
+ mocks.probeQueue = async () => ({ running: 1, pending: 0 })
+ await vi.advanceTimersByTimeAsync(LOCAL_IDLE_STOP_MS)
+ expect(stopped).toEqual([])
+
+ mocks.probeQueue = async () => ({ running: 0, pending: 0 })
+ await vi.advanceTimersByTimeAsync(LOCAL_IDLE_STOP_MS)
+
+ expect(stopped).toEqual([STUDIO])
+ })
+
+ it('keeps running when its queue cannot be read', async () => {
+ mocks.probeQueue = async () => null
+ await vi.advanceTimersByTimeAsync(LOCAL_IDLE_STOP_MS)
+
+ expect(stopped).toEqual([])
+ })
+
+ it('keeps running while a model is still downloading for an app, however long that takes', async () => {
+ let finish: (outcome: unknown) => void = () => {}
+ mocks.startModelJob = async () => ({
+ id: 'job',
+ release: vi.fn(),
+ completion: new Promise((resolve) => (finish = resolve))
+ })
+ const downloading = localDownload(BIREFNET)
+ await vi.advanceTimersByTimeAsync(LOCAL_IDLE_STOP_MS * 3)
+ expect(stopped).toEqual([])
+
+ finish({ status: 'completed', savePath: '/models/x' })
+ await downloading
+ await vi.advanceTimersByTimeAsync(LOCAL_IDLE_STOP_MS)
+
+ expect(stopped).toEqual([STUDIO])
+ })
+
+ it('is left alone for good once the person opens its window', async () => {
+ mocks.windows.set(STUDIO, { window: {} })
+ await vi.advanceTimersByTimeAsync(LOCAL_IDLE_STOP_MS * 3)
+
+ expect(stopped).toEqual([])
+ })
+})
+
+describe('a ComfyUI the person started themselves', () => {
+ it('is never stopped by apps, however long it sits unused', async () => {
+ running()
+ await startLocal(WANT)
+ await localFetch({ path: '/queue' })
+
+ await vi.advanceTimersByTimeAsync(LOCAL_IDLE_STOP_MS * 3)
+
+ expect(stopped).toEqual([])
+ })
+})
diff --git a/src/main/apps/localComfy.ts b/src/main/apps/localComfy.ts
new file mode 100644
index 000000000..d1439bd2b
--- /dev/null
+++ b/src/main/apps/localComfy.ts
@@ -0,0 +1,446 @@
+import type { IpcMainInvokeEvent, WebContents } from 'electron'
+
+import type {
+ ComfyDesktopLocalAnswer,
+ ComfyDesktopLocalComfy,
+ ComfyDesktopLocalDownload,
+ ComfyDesktopLocalEvent
+} from '../../types/comfyDesktopBridge'
+import { getEntryByInstallationId } from '../host/registry'
+import * as installations from '../installations'
+import { startManagedModelJob } from '../lib/comfyDownloadManager'
+import { probeQueue } from '../lib/comfyProcessRecord'
+import * as i18n from '../lib/i18n'
+import { handleLaunch } from '../lib/ipc/sessionActions/launch'
+import type { ActionResult } from '../lib/ipc/sessionActions/types'
+import { _hasActiveLaunch, sessionLifecycleEvents, stopRunning } from '../lib/ipc/shared'
+import { COMFY_BOOT_TIMEOUT_MS } from '../lib/process'
+import { liveAppsPages } from './appsPages'
+import { chooseLocalBuild, runningPortOf, usableLocalBuilds, wantedVersion } from './localBuild'
+import type { LocalBuild, LocalChoice } from './localBuild'
+import {
+ outputFileKey,
+ outputFilesOf,
+ queueViewOf,
+ readLocalCall,
+ UPLOAD_SUBFOLDER
+} from './localCalls'
+import type { LocalCall } from './localCalls'
+import { readModelRequest } from './localModelRequest'
+import type { ModelRequest } from './localModelRequest'
+import { createLocalRelay } from './localRelay'
+import type { LocalRelay } from './localRelay'
+
+export const LOCAL_EVENT_CHANNEL = 'apps-local:event'
+export const LOCAL_IDLE_STOP_MS = 10 * 60_000
+
+const CALL_TIMEOUT_MS = 60_000
+const FILE_TIMEOUT_MS = 5 * 60_000
+const MAX_ANSWER_BYTES = 512 * 1024 * 1024
+const MAX_RUNS_REMEMBERED = 200
+const MAX_FILES_REMEMBERED = 2_000
+const RELAY_READY_MS = 5_000
+const OTHER_LAUNCH_POLL_MS = 500
+const DOWNLOAD_EVENT_GAP_MS = 250
+const REFUSED = 403
+const JSON_TYPE = 'application/json'
+const RUN_UPDATES: ReadonlySet = new Set([
+ 'execution_start',
+ 'executing',
+ 'progress',
+ 'progress_state',
+ 'execution_success',
+ 'execution_error',
+ 'execution_interrupted'
+])
+
+interface Target {
+ id: string
+ name: string
+}
+
+let idleTimer: ReturnType | null = null
+let watchingSessions = false
+let downloadsUnderWay = 0
+const targetByPage = new WeakMap()
+const relayByBuild = new Map()
+const startedHere = new Set()
+const launches = new Map>()
+const ownRuns = new Set()
+const ownFiles = new Set()
+
+function isRecord(value: unknown): value is Record {
+ return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function rememberBounded(set: Set, value: string, limit: number): void {
+ set.delete(value)
+ set.add(value)
+ for (const oldest of set) {
+ if (set.size <= limit) break
+ set.delete(oldest)
+ }
+}
+
+function sendToPages(event: ComfyDesktopLocalEvent): void {
+ for (const page of liveAppsPages()) page.send(LOCAL_EVENT_CHANNEL, event)
+}
+
+function relayRunUpdate(message: unknown): void {
+ if (!isRecord(message) || typeof message['type'] !== 'string') return
+ if (!RUN_UPDATES.has(message['type']) || !isRecord(message['data'])) return
+ const promptId = message['data']['prompt_id']
+ if (typeof promptId !== 'string' || !ownRuns.has(promptId)) return
+ sendToPages({ type: message['type'], data: message['data'] })
+}
+
+function relayFor(installationId: string, port: number): LocalRelay {
+ const relay = relayByBuild.get(installationId) ?? createLocalRelay(relayRunUpdate)
+ relayByBuild.set(installationId, relay)
+ relay.follow(port)
+ return relay
+}
+
+function stopFollowingStoppedBuilds(): void {
+ for (const id of startedHere) if (runningPortOf(id) === null) startedHere.delete(id)
+ for (const [id, relay] of relayByBuild) {
+ if (runningPortOf(id) !== null) continue
+ relay.stop()
+ relayByBuild.delete(id)
+ }
+}
+
+function watchSessions(): void {
+ if (watchingSessions) return
+ watchingSessions = true
+ sessionLifecycleEvents.on('changed', stopFollowingStoppedBuilds)
+}
+
+async function stopIdleBuilds(): Promise {
+ idleTimer = null
+ if (downloadsUnderWay > 0) return noteUse()
+ for (const id of [...startedHere]) {
+ const port = runningPortOf(id)
+ if (port === null || getEntryByInstallationId(id)) {
+ startedHere.delete(id)
+ continue
+ }
+ const queue = await probeQueue(port)
+ const isIdle = queue !== null && queue !== 'not_queue' && queue.running + queue.pending === 0
+ if (!isIdle) continue
+ startedHere.delete(id)
+ await stopRunning(id)
+ }
+ if (startedHere.size > 0) noteUse()
+}
+
+function noteUse(): void {
+ if (idleTimer) clearTimeout(idleTimer)
+ idleTimer =
+ startedHere.size > 0 ? setTimeout(() => void stopIdleBuilds(), LOCAL_IDLE_STOP_MS) : null
+}
+
+function whyNoBuild(choice: Exclude): string {
+ return choice.kind === 'too-old'
+ ? i18n.t('apps.local.tooOld', { version: choice.wanted })
+ : i18n.t('apps.local.noBuilds')
+}
+
+function describe(build: LocalBuild): ComfyDesktopLocalComfy {
+ return {
+ state: build.port === null ? 'stopped' : 'running',
+ own: true,
+ name: build.name,
+ ...(build.version ? { version: build.version } : {}),
+ ...(build.port === null ? {} : { clientId: relayFor(build.id, build.port).clientId })
+ }
+}
+
+async function chooseTarget(page: WebContents, want: unknown): Promise {
+ const choice = chooseLocalBuild(await usableLocalBuilds(), wantedVersion(want))
+ if (choice.kind !== 'build') return whyNoBuild(choice)
+ targetByPage.set(page, { id: choice.build.id, name: choice.build.name })
+ return choice.build
+}
+
+export async function localState(
+ page: WebContents,
+ want: unknown
+): Promise {
+ const build = await chooseTarget(page, want)
+ if (typeof build === 'string') return { state: 'unsupported', error: build }
+ watchSessions()
+ return describe(build)
+}
+
+function pause(ms: number): Promise {
+ return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+async function waitForOtherLaunch(installationId: string): Promise {
+ const giveUpAt = Date.now() + COMFY_BOOT_TIMEOUT_MS
+ while (_hasActiveLaunch(installationId) && Date.now() < giveUpAt) {
+ await pause(OTHER_LAUNCH_POLL_MS)
+ }
+ return { ok: runningPortOf(installationId) !== null }
+}
+
+const QUIET_SENDER = { isDestroyed: () => false, send: () => {} } as unknown as WebContents
+const QUIET_EVENT = { sender: QUIET_SENDER } as unknown as IpcMainInvokeEvent
+
+async function launchWithoutWindow(installationId: string): Promise {
+ if (_hasActiveLaunch(installationId)) return waitForOtherLaunch(installationId)
+ const inst = await installations.get(installationId)
+ if (!inst) return { ok: false }
+ const result = await handleLaunch({
+ event: QUIET_EVENT,
+ installationId,
+ inst,
+ actionData: { launchModeOverride: 'console', autoPortOnConflict: true }
+ })
+ if (result.ok) startedHere.add(installationId)
+ return result
+}
+
+function launchOnce(installationId: string): Promise {
+ const pending = launches.get(installationId)
+ if (pending) return pending
+ const launch = launchWithoutWindow(installationId)
+ .catch((err: unknown): ActionResult => ({ ok: false, message: (err as Error)?.message }))
+ .finally(() => launches.delete(installationId))
+ launches.set(installationId, launch)
+ return launch
+}
+
+export async function startLocal(
+ page: WebContents,
+ want: unknown
+): Promise {
+ const build = await chooseTarget(page, want)
+ if (typeof build === 'string') return { state: 'unsupported', error: build }
+ watchSessions()
+ const launched = build.port === null ? await launchOnce(build.id) : null
+ const port = runningPortOf(build.id)
+ if (port === null) {
+ return {
+ ...describe({ ...build, port: null }),
+ error: launched?.message || i18n.t('apps.local.couldNotStart', { name: build.name })
+ }
+ }
+ await relayFor(build.id, port).whenOpen(RELAY_READY_MS)
+ noteUse()
+ return describe({ ...build, port })
+}
+
+function jsonAnswer(status: number, value: unknown): ComfyDesktopLocalAnswer {
+ return { status, contentType: JSON_TYPE, body: new TextEncoder().encode(JSON.stringify(value)) }
+}
+
+function refusal(): ComfyDesktopLocalAnswer {
+ return jsonAnswer(REFUSED, { error: i18n.t('apps.local.notForwarded') })
+}
+
+async function readCapped(response: Response): Promise {
+ if (Number(response.headers.get('content-length') ?? 0) > MAX_ANSWER_BYTES) {
+ throw new Error('The answer is too large to hand to the page.')
+ }
+ if (!response.body) return new Uint8Array(0)
+ const chunks: Uint8Array[] = []
+ let size = 0
+ for await (const chunk of response.body as unknown as AsyncIterable) {
+ size += chunk.byteLength
+ if (size > MAX_ANSWER_BYTES) throw new Error('The answer is too large to hand to the page.')
+ chunks.push(chunk)
+ }
+ const body = new Uint8Array(size)
+ let offset = 0
+ for (const chunk of chunks) {
+ body.set(chunk, offset)
+ offset += chunk.byteLength
+ }
+ return body
+}
+
+interface Forwarded {
+ method?: 'POST'
+ json?: unknown
+ form?: FormData
+ timeoutMs?: number
+}
+
+async function forward(
+ port: number,
+ path: string,
+ { method, json, form, timeoutMs = CALL_TIMEOUT_MS }: Forwarded = {}
+): Promise {
+ const response = await fetch(`http://127.0.0.1:${port}${path}`, {
+ method: method ?? 'GET',
+ redirect: 'error',
+ signal: AbortSignal.timeout(timeoutMs),
+ ...(json === undefined
+ ? {}
+ : { headers: { 'Content-Type': JSON_TYPE }, body: JSON.stringify(json) }),
+ ...(form ? { body: form } : {})
+ })
+ return {
+ status: response.status,
+ contentType: response.headers.get('content-type') ?? 'application/octet-stream',
+ body: await readCapped(response)
+ }
+}
+
+function parsed(answer: ComfyDesktopLocalAnswer): unknown {
+ if (answer.status !== 200) return null
+ try {
+ return JSON.parse(new TextDecoder().decode(answer.body))
+ } catch {
+ return null
+ }
+}
+
+function uploadForm(call: Extract): FormData {
+ const form = new FormData()
+ form.append('image', new Blob([call.bytes as BlobPart]), call.fileName)
+ form.append('type', 'input')
+ form.append('subfolder', UPLOAD_SUBFOLDER)
+ return form
+}
+
+async function sendRun(
+ port: number,
+ relay: LocalRelay,
+ call: Extract
+): Promise {
+ await relay.whenOpen(RELAY_READY_MS)
+ const answer = await forward(port, '/prompt', {
+ method: 'POST',
+ json: { prompt: call.prompt, client_id: relay.clientId, extra_data: call.extraData }
+ })
+ const started = parsed(answer)
+ if (isRecord(started) && typeof started['prompt_id'] === 'string') {
+ rememberBounded(ownRuns, started['prompt_id'], MAX_RUNS_REMEMBERED)
+ }
+ return answer
+}
+
+async function readRun(port: number, promptId: string): Promise {
+ const answer = await forward(port, `/history/${promptId}`)
+ const history = parsed(answer)
+ for (const file of outputFilesOf(isRecord(history) ? history[promptId] : null)) {
+ rememberBounded(ownFiles, outputFileKey(file), MAX_FILES_REMEMBERED)
+ }
+ return answer
+}
+
+async function answerCall(
+ port: number,
+ relay: LocalRelay,
+ call: LocalCall
+): Promise {
+ switch (call.kind) {
+ case 'queue':
+ return jsonAnswer(
+ 200,
+ queueViewOf(parsed(await forward(port, '/queue')), (id) => ownRuns.has(id))
+ )
+ case 'object-info':
+ return forward(port, `/object_info/${call.node}`)
+ case 'upload':
+ return forward(port, '/upload/image', { method: 'POST', form: uploadForm(call) })
+ case 'prompt':
+ return sendRun(port, relay, call)
+ case 'history':
+ return ownRuns.has(call.promptId) ? readRun(port, call.promptId) : refusal()
+ case 'view':
+ return ownFiles.has(outputFileKey(call.file))
+ ? forward(port, `/view?${new URLSearchParams({ ...call.file })}`, {
+ timeoutMs: FILE_TIMEOUT_MS
+ })
+ : refusal()
+ case 'leave-queue':
+ return call.promptIds.every((id) => ownRuns.has(id))
+ ? forward(port, '/queue', { method: 'POST', json: { delete: call.promptIds } })
+ : refusal()
+ case 'interrupt':
+ return ownRuns.has(call.promptId)
+ ? forward(port, '/interrupt', { method: 'POST', json: { prompt_id: call.promptId } })
+ : refusal()
+ }
+}
+
+export async function localFetch(
+ page: WebContents,
+ raw: unknown
+): Promise {
+ const call = readLocalCall(raw)
+ if (!call) return refusal()
+ const target = targetByPage.get(page)
+ const port = target ? runningPortOf(target.id) : null
+ if (!target || port === null) throw new Error(i18n.t('apps.local.notRunning'))
+ noteUse()
+ return answerCall(port, relayFor(target.id, port), call)
+}
+
+function downloadProgress(name: string): (done: number, total: number) => void {
+ let lastSentAt = 0
+ return (done, total) => {
+ const now = Date.now()
+ if (now - lastSentAt < DOWNLOAD_EVENT_GAP_MS && done < total) return
+ lastSentAt = now
+ sendToPages({ type: 'download', data: { name, done, total } })
+ }
+}
+
+async function downloadInto(
+ installationId: string,
+ model: ModelRequest
+): Promise {
+ const job = await startManagedModelJob({
+ url: model.url,
+ filename: model.name,
+ directory: model.folder,
+ installationId,
+ onProgress: downloadProgress(model.name)
+ })
+ try {
+ const outcome = await job.completion
+ if (outcome.status === 'completed') return { state: 'done' }
+ if (outcome.status === 'cancelled') return { state: 'cancelled' }
+ return { state: 'failed', error: outcome.error }
+ } finally {
+ job.release()
+ }
+}
+
+export async function localDownload(
+ page: WebContents,
+ raw: unknown
+): Promise {
+ const model = readModelRequest(raw)
+ if (!model) return { state: 'failed', error: i18n.t('apps.local.modelRefused') }
+ const target = targetByPage.get(page)
+ if (!target || runningPortOf(target.id) === null) {
+ return { state: 'failed', error: i18n.t('apps.local.notRunning') }
+ }
+ downloadsUnderWay += 1
+ try {
+ return await downloadInto(target.id, model)
+ } finally {
+ downloadsUnderWay -= 1
+ noteUse()
+ }
+}
+
+export function _resetForTest(): void {
+ if (idleTimer) clearTimeout(idleTimer)
+ idleTimer = null
+ downloadsUnderWay = 0
+ for (const relay of relayByBuild.values()) relay.stop()
+ relayByBuild.clear()
+ if (watchingSessions) sessionLifecycleEvents.off('changed', stopFollowingStoppedBuilds)
+ watchingSessions = false
+ startedHere.clear()
+ launches.clear()
+ ownRuns.clear()
+ ownFiles.clear()
+}
diff --git a/src/main/apps/localModelRequest.test.ts b/src/main/apps/localModelRequest.test.ts
new file mode 100644
index 000000000..27650e9f0
--- /dev/null
+++ b/src/main/apps/localModelRequest.test.ts
@@ -0,0 +1,74 @@
+import { describe, expect, it } from 'vitest'
+
+import { readModelRequest } from './localModelRequest'
+
+const BIREFNET = {
+ url: 'https://huggingface.co/Comfy-Org/BiRefNet/resolve/main/background_removal/birefnet.safetensors',
+ folder: 'background_removal',
+ name: 'birefnet.safetensors'
+}
+
+describe('a model an app page may ask Desktop to download', () => {
+ it('is a safetensors file on Hugging Face, saved under its own name in a models folder', () => {
+ expect(readModelRequest(BIREFNET)).toEqual(BIREFNET)
+ expect(
+ readModelRequest({
+ url: 'https://huggingface.co/Comfy-Org/Qwen-Image-2.1/resolve/main/text_encoders/qwen3vl_8b_int8_convrot.safetensors?download=true',
+ folder: 'text_encoders',
+ name: 'qwen3vl_8b_int8_convrot.safetensors'
+ })
+ ).toMatchObject({ folder: 'text_encoders', name: 'qwen3vl_8b_int8_convrot.safetensors' })
+ })
+
+ it.each([
+ [
+ 'another host',
+ { url: BIREFNET.url.replace('huggingface.co', 'huggingface.co.evil.example') }
+ ],
+ [
+ 'a look-alike host',
+ { url: BIREFNET.url.replace('huggingface.co', 'evil.example/huggingface.co') }
+ ],
+ ['plain http', { url: BIREFNET.url.replace('https:', 'http:') }],
+ ['a file on this computer', { url: 'file:///models/birefnet.safetensors' }],
+ ['sign-in details in the address', { url: BIREFNET.url.replace('https://', 'https://me:pw@') }],
+ ['another port', { url: BIREFNET.url.replace('huggingface.co', 'huggingface.co:8443') }],
+ ['a page that is not a file', { url: 'https://huggingface.co/Comfy-Org/birefnet.safetensors' }],
+ ['an address that is not one', { url: 'birefnet.safetensors' }]
+ ])('refuses %s', (_what, change) => {
+ expect(readModelRequest({ ...BIREFNET, ...change })).toBeNull()
+ })
+
+ it.each([
+ 'birefnet.ckpt',
+ 'birefnet.pt',
+ 'birefnet.safetensors.py',
+ 'run.py',
+ '../birefnet.safetensors',
+ 'sub/birefnet.safetensors',
+ '.safetensors',
+ 'bire fnet.safetensors'
+ ])('refuses to save it as %s', (name) => {
+ expect(
+ readModelRequest({ ...BIREFNET, name, url: BIREFNET.url.replace(BIREFNET.name, name) })
+ ).toBeNull()
+ })
+
+ it('refuses a name that is not the file the address points at', () => {
+ expect(readModelRequest({ ...BIREFNET, name: 'other.safetensors' })).toBeNull()
+ })
+
+ it.each(['', '..', '../custom_nodes', 'checkpoints/sub', '/abs', 'Check Points', 'custom-nodes'])(
+ 'refuses the folder %j',
+ (folder) => {
+ expect(readModelRequest({ ...BIREFNET, folder })).toBeNull()
+ }
+ )
+
+ it.each([null, undefined, 'birefnet', 7, {}, { url: 7, folder: 'vae', name: 'a.safetensors' }])(
+ 'refuses the malformed request %j',
+ (raw) => {
+ expect(readModelRequest(raw)).toBeNull()
+ }
+ )
+})
diff --git a/src/main/apps/localModelRequest.ts b/src/main/apps/localModelRequest.ts
new file mode 100644
index 000000000..fcbef2369
--- /dev/null
+++ b/src/main/apps/localModelRequest.ts
@@ -0,0 +1,40 @@
+const MODEL_HOST = 'huggingface.co'
+const MODEL_FOLDER = /^[a-z0-9][a-z0-9_]{0,39}$/
+const MODEL_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,150}\.safetensors$/
+const RESOLVE_PATH = /^\/[^/]+\/[^/]+\/resolve\/[^/]+\/.+$/
+
+export interface ModelRequest {
+ url: string
+ folder: string
+ name: string
+}
+
+function parseUrl(value: string): URL | null {
+ try {
+ return new URL(value)
+ } catch {
+ return null
+ }
+}
+
+function isPlainHuggingFaceFile(url: URL): boolean {
+ return (
+ url.protocol === 'https:' &&
+ url.hostname === MODEL_HOST &&
+ url.port === '' &&
+ url.username === '' &&
+ url.password === '' &&
+ RESOLVE_PATH.test(url.pathname)
+ )
+}
+
+export function readModelRequest(raw: unknown): ModelRequest | null {
+ if (typeof raw !== 'object' || raw === null) return null
+ const { url, folder, name } = raw as Record
+ if (typeof url !== 'string' || typeof folder !== 'string' || typeof name !== 'string') return null
+ if (!MODEL_FOLDER.test(folder) || !MODEL_NAME.test(name)) return null
+ const source = parseUrl(url)
+ if (!source || !isPlainHuggingFaceFile(source)) return null
+ if (!source.pathname.endsWith(`/${name}`)) return null
+ return { url: source.href, folder, name }
+}
diff --git a/src/main/apps/localRelay.test.ts b/src/main/apps/localRelay.test.ts
new file mode 100644
index 000000000..67e1ac581
--- /dev/null
+++ b/src/main/apps/localRelay.test.ts
@@ -0,0 +1,177 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { createLocalRelay } from './localRelay'
+import type { RelaySocket } from './localRelay'
+
+class FakeSocket implements RelaySocket {
+ closed = false
+ private listeners = new Map void)[]>()
+
+ constructor(readonly url: string) {}
+
+ addEventListener(type: string, listener: (event: { data: unknown }) => void): void {
+ this.listeners.set(type, [...(this.listeners.get(type) ?? []), listener])
+ }
+
+ close(): void {
+ this.closed = true
+ }
+
+ emit(type: 'open' | 'close' | 'error' | 'message', data?: unknown): void {
+ for (const listener of this.listeners.get(type) ?? []) listener({ data })
+ }
+}
+
+let sockets: FakeSocket[]
+let heard: unknown[]
+
+function relayUnderTest() {
+ return createLocalRelay(
+ (message) => heard.push(message),
+ (url) => {
+ const socket = new FakeSocket(url)
+ sockets.push(socket)
+ return socket
+ }
+ )
+}
+
+function lastSocket(): FakeSocket {
+ const socket = sockets.at(-1)
+ if (!socket) throw new Error('No socket was opened')
+ return socket
+}
+
+beforeEach(() => {
+ vi.useFakeTimers()
+ sockets = []
+ heard = []
+})
+
+afterEach(() => {
+ vi.useRealTimers()
+})
+
+describe("following a ComfyUI's socket", () => {
+ it('connects as one client and hands over each message it can read', () => {
+ const relay = relayUnderTest()
+
+ relay.follow(8188)
+ lastSocket().emit('open')
+ lastSocket().emit('message', '{"type":"executing","data":{"node":"3"}}')
+ lastSocket().emit('message', 'not json')
+ lastSocket().emit('message', new ArrayBuffer(8))
+
+ expect(sockets.map((socket) => socket.url)).toEqual([
+ `ws://127.0.0.1:8188/ws?clientId=${relay.clientId}`
+ ])
+ expect(heard).toEqual([{ type: 'executing', data: { node: '3' } }])
+ })
+
+ it('keeps one connection while it is asked to follow the same ComfyUI again', () => {
+ const relay = relayUnderTest()
+
+ relay.follow(8188)
+ relay.follow(8188)
+ lastSocket().emit('open')
+ relay.follow(8188)
+
+ expect(sockets).toHaveLength(1)
+ })
+
+ it('connects again, waiting longer each time, while the ComfyUI is away', () => {
+ const relay = relayUnderTest()
+ relay.follow(8188)
+
+ lastSocket().emit('error')
+ lastSocket().emit('close')
+ vi.advanceTimersByTime(999)
+ expect(sockets).toHaveLength(1)
+ vi.advanceTimersByTime(1)
+ expect(sockets).toHaveLength(2)
+
+ lastSocket().emit('close')
+ vi.advanceTimersByTime(1_999)
+ expect(sockets).toHaveLength(2)
+ vi.advanceTimersByTime(1)
+ expect(sockets).toHaveLength(3)
+
+ lastSocket().emit('open')
+ lastSocket().emit('close')
+ vi.advanceTimersByTime(1_000)
+ expect(sockets).toHaveLength(4)
+ })
+
+ it('moves to another ComfyUI and ignores what the old connection still says', () => {
+ const relay = relayUnderTest()
+ relay.follow(8188)
+ const old = lastSocket()
+ old.emit('open')
+
+ relay.follow(8190)
+ old.emit('message', '{"type":"executing"}')
+ old.emit('close')
+ vi.advanceTimersByTime(60_000)
+
+ expect(old.closed).toBe(true)
+ expect(sockets.map((socket) => socket.url)).toEqual([
+ `ws://127.0.0.1:8188/ws?clientId=${relay.clientId}`,
+ `ws://127.0.0.1:8190/ws?clientId=${relay.clientId}`
+ ])
+ expect(heard).toEqual([])
+ })
+
+ it('stops for good when told to', () => {
+ const relay = relayUnderTest()
+ relay.follow(8188)
+ const socket = lastSocket()
+
+ relay.stop()
+ socket.emit('close')
+ vi.advanceTimersByTime(60_000)
+
+ expect(socket.closed).toBe(true)
+ expect(sockets).toHaveLength(1)
+ })
+})
+
+describe('waiting for the socket to be open', () => {
+ it('answers at once when it is', async () => {
+ const relay = relayUnderTest()
+ relay.follow(8188)
+ lastSocket().emit('open')
+
+ await expect(relay.whenOpen(5_000)).resolves.toBe(true)
+ })
+
+ it('answers as soon as it opens', async () => {
+ const relay = relayUnderTest()
+ relay.follow(8188)
+ const waiting = relay.whenOpen(5_000)
+
+ lastSocket().emit('open')
+
+ await expect(waiting).resolves.toBe(true)
+ })
+
+ it('gives up after the wait, and when nothing is being followed', async () => {
+ const relay = relayUnderTest()
+ await expect(relay.whenOpen(5_000)).resolves.toBe(false)
+
+ relay.follow(8188)
+ const waiting = relay.whenOpen(5_000)
+ vi.advanceTimersByTime(5_000)
+
+ await expect(waiting).resolves.toBe(false)
+ })
+
+ it('gives up when the relay stops', async () => {
+ const relay = relayUnderTest()
+ relay.follow(8188)
+ const waiting = relay.whenOpen(5_000)
+
+ relay.stop()
+
+ await expect(waiting).resolves.toBe(false)
+ })
+})
diff --git a/src/main/apps/localRelay.ts b/src/main/apps/localRelay.ts
new file mode 100644
index 000000000..8e131c7c0
--- /dev/null
+++ b/src/main/apps/localRelay.ts
@@ -0,0 +1,113 @@
+import { randomUUID } from 'crypto'
+
+const FIRST_RETRY_MS = 1_000
+const LONGEST_RETRY_MS = 30_000
+
+export interface RelaySocket {
+ addEventListener(type: 'open' | 'close' | 'error', listener: () => void): void
+ addEventListener(type: 'message', listener: (event: { data: unknown }) => void): void
+ close(): void
+}
+
+export interface LocalRelay {
+ readonly clientId: string
+ follow(port: number): void
+ whenOpen(timeoutMs: number): Promise
+ stop(): void
+}
+
+function parseMessage(data: unknown): unknown {
+ if (typeof data !== 'string') return null
+ try {
+ return JSON.parse(data)
+ } catch {
+ return null
+ }
+}
+
+export function createLocalRelay(
+ onMessage: (message: unknown) => void,
+ openSocket: (url: string) => RelaySocket = (url) => new WebSocket(url)
+): LocalRelay {
+ const clientId = randomUUID()
+ let followedPort: number | null = null
+ let socket: RelaySocket | null = null
+ let isOpen = false
+ let retryMs = FIRST_RETRY_MS
+ let retryTimer: ReturnType | null = null
+ let waiters: ((open: boolean) => void)[] = []
+
+ function tellWaiters(open: boolean): void {
+ const waiting = waiters
+ waiters = []
+ for (const tell of waiting) tell(open)
+ }
+
+ function forget(): void {
+ if (retryTimer) clearTimeout(retryTimer)
+ retryTimer = null
+ const closing = socket
+ socket = null
+ isOpen = false
+ closing?.close()
+ }
+
+ function connect(port: number): void {
+ const connecting = openSocket(`ws://127.0.0.1:${port}/ws?clientId=${clientId}`)
+ socket = connecting
+ connecting.addEventListener('open', () => {
+ if (socket !== connecting) return
+ isOpen = true
+ retryMs = FIRST_RETRY_MS
+ tellWaiters(true)
+ })
+ connecting.addEventListener('message', (event) => {
+ if (socket !== connecting) return
+ const message = parseMessage(event.data)
+ if (message !== null) onMessage(message)
+ })
+ const retryLater = (): void => {
+ if (socket !== connecting) return
+ socket = null
+ isOpen = false
+ retryTimer = setTimeout(() => {
+ retryTimer = null
+ if (followedPort === port) connect(port)
+ }, retryMs)
+ retryMs = Math.min(retryMs * 2, LONGEST_RETRY_MS)
+ }
+ connecting.addEventListener('close', retryLater)
+ connecting.addEventListener('error', retryLater)
+ }
+
+ return {
+ clientId,
+ follow(port) {
+ if (followedPort === port) return
+ forget()
+ followedPort = port
+ retryMs = FIRST_RETRY_MS
+ connect(port)
+ },
+ whenOpen(timeoutMs) {
+ if (isOpen) return Promise.resolve(true)
+ if (followedPort === null) return Promise.resolve(false)
+ return new Promise((resolve) => {
+ const tell = (open: boolean): void => {
+ clearTimeout(timer)
+ resolve(open)
+ }
+ const timer = setTimeout(() => {
+ waiters = waiters.filter((waiter) => waiter !== tell)
+ resolve(false)
+ }, timeoutMs)
+ waiters.push(tell)
+ })
+ },
+ stop() {
+ followedPort = null
+ forget()
+ tellWaiters(false)
+ }
+ }
+}
diff --git a/src/main/lib/ipc/index.ts b/src/main/lib/ipc/index.ts
index 4bfd4c3e7..62f7dcd5b 100644
--- a/src/main/lib/ipc/index.ts
+++ b/src/main/lib/ipc/index.ts
@@ -39,6 +39,7 @@ import { registerAssetsHandlers } from '../assets'
import { registerEmbeddedSessionHandlers } from './registerEmbeddedSessionHandlers'
import { registerCatalogHandlers } from './registerCatalogHandlers'
import { registerAppsHandlers } from './registerAppsHandlers'
+import { registerAppsLocalHandlers } from './registerAppsLocalHandlers'
import { reconcileAdoptedSettings } from '../desktopAdopt'
import {
finalizeComfyBuilderRecovery,
@@ -285,5 +286,6 @@ export function register(callbacks: RegisterCallbacks = {}): Promise {
registerEmbeddedSessionHandlers()
registerCatalogHandlers()
registerAppsHandlers()
+ registerAppsLocalHandlers()
return startupRecovery.then(() => undefined)
}
diff --git a/src/main/lib/ipc/registerAppsLocalHandlers.test.ts b/src/main/lib/ipc/registerAppsLocalHandlers.test.ts
new file mode 100644
index 000000000..be505d19c
--- /dev/null
+++ b/src/main/lib/ipc/registerAppsLocalHandlers.test.ts
@@ -0,0 +1,86 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+type Handler = (event: unknown, ...args: unknown[]) => Promise
+
+const mocks = vi.hoisted(() => ({
+ handlers: new Map(),
+ isAppsPage: true,
+ appsEnabled: true,
+ localState: vi.fn(),
+ startLocal: vi.fn(),
+ localFetch: vi.fn(),
+ localDownload: vi.fn()
+}))
+
+vi.mock('electron', () => ({
+ ipcMain: {
+ handle: (channel: string, handler: Handler) => mocks.handlers.set(channel, handler)
+ }
+}))
+vi.mock('../../apps/appsConfig', () => ({ areAppsEnabled: async () => mocks.appsEnabled }))
+vi.mock('../../apps/appsPages', () => ({ isAppsPageSender: () => mocks.isAppsPage }))
+vi.mock('../../apps/localComfy', () => ({
+ localState: mocks.localState,
+ startLocal: mocks.startLocal,
+ localFetch: mocks.localFetch,
+ localDownload: mocks.localDownload
+}))
+vi.mock('../i18n', () => ({ t: (key: string) => key }))
+
+import { APPS_LOCAL_CHANNELS, registerAppsLocalHandlers } from './registerAppsLocalHandlers'
+
+const EVENT = { sender: {}, senderFrame: {} }
+const WANT = { minVersion: '0.41.0' }
+const RUNNING = { state: 'running', own: true, name: 'Studio', clientId: 'desktop-client' }
+
+function call(channel: string, ...args: unknown[]): Promise {
+ const handler = mocks.handlers.get(channel)
+ if (!handler) throw new Error(`No handler for ${channel}`)
+ return handler(EVENT, ...args)
+}
+
+beforeEach(() => {
+ vi.clearAllMocks()
+ mocks.handlers.clear()
+ mocks.isAppsPage = true
+ mocks.appsEnabled = true
+ mocks.localState.mockResolvedValue({ state: 'stopped', own: true, name: 'Studio' })
+ mocks.startLocal.mockResolvedValue(RUNNING)
+ mocks.localFetch.mockResolvedValue({ status: 200, contentType: 'application/json', body: null })
+ mocks.localDownload.mockResolvedValue({ state: 'done' })
+ registerAppsLocalHandlers()
+})
+
+describe('the ComfyUI on this computer, for the hosted Apps page', () => {
+ it('is found, started, called and given a model on behalf of the page', async () => {
+ const request = { path: '/queue' }
+ const model = { url: 'https://huggingface.co/a/b/resolve/main/vae/x.safetensors' }
+
+ expect(await call(APPS_LOCAL_CHANNELS.get, WANT)).toMatchObject({ state: 'stopped' })
+ expect(await call(APPS_LOCAL_CHANNELS.start, WANT)).toEqual(RUNNING)
+ expect(await call(APPS_LOCAL_CHANNELS.fetch, request)).toMatchObject({ status: 200 })
+ expect(await call(APPS_LOCAL_CHANNELS.download, model)).toEqual({ state: 'done' })
+
+ expect(mocks.localState).toHaveBeenCalledWith(EVENT.sender, WANT)
+ expect(mocks.startLocal).toHaveBeenCalledWith(EVENT.sender, WANT)
+ expect(mocks.localFetch).toHaveBeenCalledWith(EVENT.sender, request)
+ expect(mocks.localDownload).toHaveBeenCalledWith(EVENT.sender, model)
+ })
+
+ it.each([
+ ['a sender that is not the hosted Apps page', { isAppsPage: false, appsEnabled: true }],
+ ['the Apps page while Apps is switched off', { isAppsPage: true, appsEnabled: false }]
+ ])('does nothing for %s', async (_who, state) => {
+ Object.assign(mocks, state)
+
+ expect(await call(APPS_LOCAL_CHANNELS.get, WANT)).toMatchObject({ state: 'unsupported' })
+ expect(await call(APPS_LOCAL_CHANNELS.start, WANT)).toMatchObject({ state: 'unsupported' })
+ await expect(call(APPS_LOCAL_CHANNELS.fetch, { path: '/queue' })).rejects.toThrow()
+ expect(await call(APPS_LOCAL_CHANNELS.download, {})).toMatchObject({ state: 'failed' })
+
+ expect(mocks.localState).not.toHaveBeenCalled()
+ expect(mocks.startLocal).not.toHaveBeenCalled()
+ expect(mocks.localFetch).not.toHaveBeenCalled()
+ expect(mocks.localDownload).not.toHaveBeenCalled()
+ })
+})
diff --git a/src/main/lib/ipc/registerAppsLocalHandlers.ts b/src/main/lib/ipc/registerAppsLocalHandlers.ts
new file mode 100644
index 000000000..db3a2d198
--- /dev/null
+++ b/src/main/lib/ipc/registerAppsLocalHandlers.ts
@@ -0,0 +1,49 @@
+import { ipcMain } from 'electron'
+import type { IpcMainInvokeEvent } from 'electron'
+
+import { areAppsEnabled } from '../../apps/appsConfig'
+import { isAppsPageSender } from '../../apps/appsPages'
+import { localDownload, localFetch, localState, startLocal } from '../../apps/localComfy'
+import type {
+ ComfyDesktopLocalComfy,
+ ComfyDesktopLocalDownload
+} from '../../../types/comfyDesktopBridge'
+import * as i18n from '../i18n'
+
+export const APPS_LOCAL_CHANNELS = {
+ get: 'apps-local:get',
+ start: 'apps-local:start',
+ fetch: 'apps-local:fetch',
+ download: 'apps-local:download'
+} as const
+
+async function isFromAppsPage(event: IpcMainInvokeEvent): Promise {
+ return isAppsPageSender(event.sender, event.senderFrame) && (await areAppsEnabled())
+}
+
+function notOffered(): ComfyDesktopLocalComfy {
+ return { state: 'unsupported', error: i18n.t('apps.local.notRunning') }
+}
+
+export function registerAppsLocalHandlers(): void {
+ ipcMain.handle(APPS_LOCAL_CHANNELS.get, async (event, want: unknown) =>
+ (await isFromAppsPage(event)) ? localState(event.sender, want) : notOffered()
+ )
+
+ ipcMain.handle(APPS_LOCAL_CHANNELS.start, async (event, want: unknown) =>
+ (await isFromAppsPage(event)) ? startLocal(event.sender, want) : notOffered()
+ )
+
+ ipcMain.handle(APPS_LOCAL_CHANNELS.fetch, async (event, request: unknown) => {
+ if (!(await isFromAppsPage(event))) throw new Error(i18n.t('apps.local.notRunning'))
+ return localFetch(event.sender, request)
+ })
+
+ ipcMain.handle(
+ APPS_LOCAL_CHANNELS.download,
+ async (event, model: unknown): Promise =>
+ (await isFromAppsPage(event))
+ ? localDownload(event.sender, model)
+ : { state: 'failed', error: i18n.t('apps.local.notRunning') }
+ )
+}
diff --git a/src/preload/appsPreload.ts b/src/preload/appsPreload.ts
index 7015af8d0..30ff5f225 100644
--- a/src/preload/appsPreload.ts
+++ b/src/preload/appsPreload.ts
@@ -2,7 +2,9 @@ import { contextBridge, ipcRenderer } from 'electron'
import type { IpcRendererEvent } from 'electron'
import type {
ComfyDesktop2AuthState,
- ComfyDesktopHostedAuthBridge
+ ComfyDesktopHostedAuthBridge,
+ ComfyDesktopHostedLocalBridge,
+ ComfyDesktopLocalEvent
} from '../types/comfyDesktopBridge'
const auth: ComfyDesktopHostedAuthBridge = {
@@ -20,4 +22,18 @@ const auth: ComfyDesktopHostedAuthBridge = {
}
}
+const local: ComfyDesktopHostedLocalBridge = {
+ getLocal: (want) => ipcRenderer.invoke('apps-local:get', want),
+ startLocal: (want) => ipcRenderer.invoke('apps-local:start', want),
+ localFetch: (request) => ipcRenderer.invoke('apps-local:fetch', request),
+ localDownload: (model) => ipcRenderer.invoke('apps-local:download', model),
+ onLocalEvent: (callback) => {
+ const handler = (_event: IpcRendererEvent, update: ComfyDesktopLocalEvent): void =>
+ callback(update)
+ ipcRenderer.on('apps-local:event', handler)
+ return () => ipcRenderer.removeListener('apps-local:event', handler)
+ }
+}
+
contextBridge.exposeInMainWorld('comfyDesktopAuth', auth)
+contextBridge.exposeInMainWorld('comfyDesktopLocal', local)
diff --git a/src/types/comfyDesktopBridge.ts b/src/types/comfyDesktopBridge.ts
index b5d71c456..b2ef44388 100644
--- a/src/types/comfyDesktopBridge.ts
+++ b/src/types/comfyDesktopBridge.ts
@@ -180,6 +180,93 @@ export type ComfyDesktopHostedAuthBridge = Required<
>
>
+/** What a hosted page needs from the ComfyUI on this computer. */
+export interface ComfyDesktopLocalRequirements {
+ /** The oldest ComfyUI the page can run on, such as `0.41.0`. */
+ minVersion?: string
+}
+
+/**
+ * The ComfyUI on this computer that Desktop uses for a hosted page.
+ * `running`: it answers now. `stopped`: one of the person's builds fits and
+ * `startLocal` starts it. `unsupported`: no build here can run the page, and
+ * `error` says why in words for the person.
+ */
+export interface ComfyDesktopLocalComfy {
+ state: 'running' | 'stopped' | 'unsupported'
+ /** True when it is one of the person's own builds. */
+ own?: boolean
+ name?: string
+ version?: string
+ /** The `client_id` Desktop listens with; updates for runs sent through `localFetch` arrive on `onLocalEvent`. */
+ clientId?: string
+ error?: string
+}
+
+/**
+ * One call to that ComfyUI. Desktop forwards only what a run needs:
+ * `GET /queue`, `GET /history/`, `GET /view`, `GET /object_info/`,
+ * `POST /prompt`, `POST /upload/image`, `POST /queue` to take a run out, and
+ * `POST /interrupt` to stop one. History, files, removal and stopping work
+ * only for runs the page started through this bridge.
+ */
+export interface ComfyDesktopLocalRequest {
+ method?: 'GET' | 'POST'
+ path: string
+ /** JSON text, or a file's bytes for `/upload/image`. */
+ body?: string | Uint8Array
+ /** The name to save an upload under. */
+ fileName?: string
+}
+
+/** ComfyUI's answer, or status 403 for a call Desktop does not forward. */
+export interface ComfyDesktopLocalAnswer {
+ status: number
+ contentType: string
+ body: Uint8Array
+}
+
+/** A safetensors file on Hugging Face to save as `name` in the models folder `folder`. */
+export interface ComfyDesktopLocalModel {
+ url: string
+ folder: string
+ name: string
+}
+
+export interface ComfyDesktopLocalDownload {
+ state: 'done' | 'failed' | 'cancelled'
+ error?: string
+}
+
+/**
+ * A model download's progress (`type: 'download'`, with `name`, `done` and
+ * `total` bytes in `data`), or one ComfyUI socket message about a run the page
+ * started (`execution_start`, `executing`, `progress`, `progress_state`,
+ * `execution_success`, `execution_error`, `execution_interrupted`).
+ */
+export interface ComfyDesktopLocalEvent {
+ type: string
+ data?: Record
+}
+
+/**
+ * A ComfyUI on this computer, run by Desktop, for a Comfy page hosted in
+ * Desktop's Apps view. Desktop exposes it to that page as
+ * `window.comfyDesktopLocal`. The page builds and follows its own runs;
+ * Desktop finds or starts the ComfyUI, forwards the page's calls to it and
+ * downloads a model the page asks for.
+ */
+export interface ComfyDesktopHostedLocalBridge {
+ getLocal(want?: ComfyDesktopLocalRequirements): Promise
+ /** Starts the ComfyUI if it is stopped and resolves once it answers, or with the state and `error` if it could not start. */
+ startLocal(want?: ComfyDesktopLocalRequirements): Promise
+ /** Rejects when no ComfyUI is running to forward to. */
+ localFetch(request: ComfyDesktopLocalRequest): Promise
+ /** Downloads into the running ComfyUI's models folder and resolves when the file is there. */
+ localDownload(model: ComfyDesktopLocalModel): Promise
+ onLocalEvent(callback: (event: ComfyDesktopLocalEvent) => void): () => void
+}
+
export interface ComfyDesktop2TerminalBridge {
subscribe(installationId?: string): Promise
unsubscribe(installationId?: string): Promise