dsh-comfyui 0.3.0-beta.0

package/lib/proxy.js

@@ -0,0 +1,89 @@
+import { errorMessage, sendJson } from './http.js';
+/**
+ * Mount the media proxy route on the host web server.
+ * @returns the disposer, or undefined when no web server is present.
+ */
+export function mountComfyUIProxy(ctx, runtime) {
+    const webServer = ctx.get('webServer');
+    if (webServer === undefined)
+        return undefined;
+    return webServer.register({
+        kind: 'exact',
+        path: '/comfyui/media',
+        handler: async (request, response) => {
+            runtime.hostHint.record(request);
+            if (request.method !== 'GET' && request.method !== 'HEAD') {
+                sendJson(response, 405, { error: 'method not allowed' });
+                return;
+            }
+            const url = new URL(request.url ?? '/', 'http://localhost');
+            const prompt = url.searchParams.get('prompt');
+            const node = url.searchParams.get('node');
+            const indexText = url.searchParams.get('index');
+            const file = url.searchParams.get('file');
+            if (file !== null) {
+                // Direct file lookup (e.g. job preview_output thumbnails).
+                const ref = { filename: file, subfolder: url.searchParams.get('subfolder') ?? '', type: url.searchParams.get('type') ?? 'output' };
+                try {
+                    const client = runtime.createClient(await runtime.getApiKey());
+                    const { bytes, contentType } = await client.fetchView(ref);
+                    response.writeHead(200, {
+                        'content-type': contentType,
+                        'content-length': bytes.byteLength,
+                        'cache-control': 'private, max-age=3600',
+                    });
+                    if (request.method === 'HEAD') {
+                        response.end();
+                        return;
+                    }
+                    response.end(Buffer.from(bytes));
+                    return;
+                }
+                catch (error) {
+                    sendJson(response, 502, { error: errorMessage(error) });
+                    return;
+                }
+            }
+            if (prompt === null || node === null || indexText === null) {
+                sendJson(response, 400, { error: 'prompt, node, and index query parameters are required (or file + subfolder + type)' });
+                return;
+            }
+            const index = Number(indexText);
+            if (!Number.isInteger(index) || index < 0) {
+                sendJson(response, 400, { error: 'index must be a non-negative integer' });
+                return;
+            }
+            try {
+                const client = runtime.createClient(await runtime.getApiKey());
+                const entry = await client.getHistory(prompt);
+                const outputs = entry?.outputs ?? {};
+                const nodeOutput = outputs[node];
+                const collections = [
+                    nodeOutput?.images,
+                    nodeOutput?.videos,
+                    nodeOutput?.gifs,
+                ];
+                const ref = collections
+                    .flatMap((items) => items ?? [])[index];
+                if (ref === undefined) {
+                    sendJson(response, 404, { error: `no media item ${node}[${index}] for prompt ${prompt} (history may be evicted)` });
+                    return;
+                }
+                const { bytes, contentType } = await client.fetchView(ref);
+                response.writeHead(200, {
+                    'content-type': contentType,
+                    'content-length': bytes.byteLength,
+                    'cache-control': 'private, max-age=3600',
+                });
+                if (request.method === 'HEAD') {
+                    response.end();
+                    return;
+                }
+                response.end(Buffer.from(bytes));
+            }
+            catch (error) {
+                sendJson(response, 502, { error: errorMessage(error) });
+            }
+        },
+    });
+}

package/lib/queue.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Queue tracking: remembers every prompt this plugin queued (from tools or
+ * the panel) so the panel can show "ours" in the ComfyUI queue and move
+ * completed runs into the asset index. Sweeps run on read (queue/assets
+ * routes), so no background timers leak into the fiber lifecycle.
+ */
+import { ComfyUIClient } from './comfyui.js';
+import type { AssetRecord, ComfyUIStore, TrackedState } from './store.js';
+/** A prompt this plugin queued. Kept after completion so the task center
+ * can still show its workflow name and "ours" marker. */
+export interface QueuedRun {
+    promptId: string;
+    ts: string;
+    workflowName: string | null;
+    source: string;
+}
+/** Tracks queued prompts until they complete or vanish. */
+export declare class QueueTracker {
+    private readonly persisted?;
+    private readonly runs;
+    /** Prompt ids already swept into the asset index, so sweep is idempotent. */
+    private readonly archived;
+    /**
+     * Optional durable backing: the tracked memory is persisted so completed
+     * runs still land in the asset index after a web-server restart.
+     */
+    constructor(persisted?: {
+        load(): Promise<TrackedState>;
+        save(state: TrackedState): Promise<void>;
+    } | undefined);
+    /** Restore persisted runs/archived state; call once before tracking. */
+    init(): Promise<void>;
+    /** Fire-and-forget persistence; failures must not break queueing. */
+    private persistNow;
+    track(run: QueuedRun): void;
+    untrack(promptId: string): void;
+    get(promptId: string): QueuedRun | undefined;
+    list(): QueuedRun[];
+    /**
+     * Move completed tracked runs into the asset store. Runs already archived
+     * are skipped; failed runs stay tracked so their task rows keep a name.
+     * @returns the records newly appended.
+     */
+    sweep(opts: {
+        client: ComfyUIClient;
+        store: ComfyUIStore;
+        maxItems: number;
+        proxyBase: string | undefined;
+    }): Promise<AssetRecord[]>;
+}

package/lib/queue.js

@@ -0,0 +1,103 @@
+/**
+ * Queue tracking: remembers every prompt this plugin queued (from tools or
+ * the panel) so the panel can show "ours" in the ComfyUI queue and move
+ * completed runs into the asset index. Sweeps run on read (queue/assets
+ * routes), so no background timers leak into the fiber lifecycle.
+ */
+import { collectMedia, hasMedia } from './comfyui.js';
+/** Upper bound on remembered runs; oldest are dropped beyond this. */
+const MAX_TRACKED_RUNS = 500;
+/** Tracks queued prompts until they complete or vanish. */
+export class QueueTracker {
+    persisted;
+    runs = new Map();
+    /** Prompt ids already swept into the asset index, so sweep is idempotent. */
+    archived = new Set();
+    /**
+     * Optional durable backing: the tracked memory is persisted so completed
+     * runs still land in the asset index after a web-server restart.
+     */
+    constructor(persisted) {
+        this.persisted = persisted;
+    }
+    /** Restore persisted runs/archived state; call once before tracking. */
+    async init() {
+        if (this.persisted === undefined)
+            return;
+        const state = await this.persisted.load();
+        for (const run of state.runs) {
+            this.runs.set(run.promptId, {
+                promptId: run.promptId,
+                ts: run.ts,
+                workflowName: run.workflowName,
+                source: run.source,
+            });
+        }
+        for (const id of state.archived)
+            this.archived.add(id);
+    }
+    /** Fire-and-forget persistence; failures must not break queueing. */
+    persistNow() {
+        if (this.persisted === undefined)
+            return;
+        const state = {
+            runs: [...this.runs.values()],
+            archived: [...this.archived],
+        };
+        void this.persisted.save(state).catch(() => undefined);
+    }
+    track(run) {
+        this.runs.set(run.promptId, run);
+        this.persistNow();
+    }
+    untrack(promptId) {
+        this.runs.delete(promptId);
+        this.persistNow();
+    }
+    get(promptId) {
+        return this.runs.get(promptId);
+    }
+    list() {
+        return [...this.runs.values()];
+    }
+    /**
+     * Move completed tracked runs into the asset store. Runs already archived
+     * are skipped; failed runs stay tracked so their task rows keep a name.
+     * @returns the records newly appended.
+     */
+    async sweep(opts) {
+        const completed = [];
+        for (const run of [...this.runs.values()]) {
+            if (this.archived.has(run.promptId))
+                continue;
+            const entry = await opts.client.getHistory(run.promptId).catch(() => undefined);
+            if (entry === undefined)
+                continue;
+            if (isCompleted(entry)) {
+                const media = collectMedia({ promptId: run.promptId, entry, maxItems: opts.maxItems, proxyBase: opts.proxyBase });
+                const record = {
+                    promptId: run.promptId,
+                    ts: run.ts,
+                    workflowName: run.workflowName,
+                    source: run.source,
+                    media,
+                };
+                await opts.store.appendAsset(record);
+                completed.push(record);
+                this.archived.add(run.promptId);
+            }
+        }
+        if (this.runs.size > MAX_TRACKED_RUNS) {
+            const oldest = this.runs.keys().next().value;
+            if (oldest !== undefined)
+                this.runs.delete(oldest);
+        }
+        this.persistNow();
+        return completed;
+    }
+}
+function isCompleted(entry) {
+    return entry.status?.status_str === 'success'
+        || entry.status?.completed === true
+        || hasMedia(entry);
+}

package/lib/routes.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Browser-facing HTTP routes for dsh-comfyui: configuration (read/redacted,
+ * persist through the settings service), a connection probe, the workflow
+ * library (list/save/delete/run), the asset index, and the live ComfyUI
+ * queue view. Writes are same-origin-only.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { ComfyUIRuntime } from './tools.js';
+/**
+ * Mount every dsh-comfyui route on the host web server.
+ * @returns the disposer, or undefined when no web server is present.
+ */
+export declare function mountComfyUIRoutes(ctx: Context, runtime: ComfyUIRuntime): (() => void) | undefined;