dsh-comfyui 0.3.0-beta.0

package/cordis.patch.yml

@@ -0,0 +1,4 @@
+# dsh-comfyui bundle patch: inserts the plugin into a profile's layer stack.
+- insert:
+    - id: comfyui
+      name: 'dsh-comfyui'

package/lib/analyze.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Canvas analysis for ComfyUI UI-graph workflows. A saved canvas is often a
+ * test bench holding several independent flows at once: `groups` are visual
+ * rectangles only, and the executable unit is a connected component over the
+ * graph links (with bypassed and dangling nodes excluded). The analysis feeds
+ * the extract (拆分) choices in the panel and the agent-facing skill.
+ */
+export interface GraphNodeLike {
+    id: number;
+    type: string;
+    mode?: number;
+    inputs?: Array<{
+        link: number | null;
+    }>;
+    pos?: [number, number] | number[];
+}
+export interface GraphGroupLike {
+    title?: string;
+    bounding: [number, number, number, number] | number[];
+}
+export interface GraphLike {
+    nodes: GraphNodeLike[];
+    links: Array<[number, number, number, number, number, string] | number[]>;
+    groups?: GraphGroupLike[];
+}
+export interface IsolatedNode {
+    id: number;
+    type: string;
+}
+export interface ComponentInfo {
+    /** 1-based index, ordered largest first. */
+    index: number;
+    nodeIds: number[];
+    size: number;
+    /** Group titles that contain at least one node of the component. */
+    groups: string[];
+    /** Distinct node class types in the component (preview). */
+    nodeTypes: string[];
+}
+export interface GraphAnalysis {
+    ok: true;
+    /** Executable components, largest first. */
+    components: ComponentInfo[];
+    /** Dangling nodes ignored by extraction (Markdown, UI-only, unused primitives). */
+    isolated: IsolatedNode[];
+    /** Count of bypassed (mode 4) nodes skipped by extraction. */
+    bypassedCount: number;
+    /** 'single' when at most one component exists; 'multi' when several. */
+    mode: 'single' | 'multi';
+}
+/**
+ * Analyze a saved ComfyUI graph: split its active nodes into connected
+ * components, associate group titles, and list the dangling nodes that
+ * extraction ignores.
+ * @param graph - parsed ComfyUI UI graph (v0.4 format).
+ * @returns the analysis, or an error object when the graph is not readable.
+ */
+export declare function analyzeGraph(graph: unknown): GraphAnalysis | {
+    ok: false;
+    error: string;
+};

package/lib/analyze.js

@@ -0,0 +1,96 @@
+/**
+ * Canvas analysis for ComfyUI UI-graph workflows. A saved canvas is often a
+ * test bench holding several independent flows at once: `groups` are visual
+ * rectangles only, and the executable unit is a connected component over the
+ * graph links (with bypassed and dangling nodes excluded). The analysis feeds
+ * the extract (拆分) choices in the panel and the agent-facing skill.
+ */
+function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function nodeInGroup(node, group) {
+    const [gx, gy, gw, gh] = group.bounding;
+    const pos = node.pos ?? [0, 0];
+    const nx = pos[0] ?? 0;
+    const ny = pos[1] ?? 0;
+    return nx >= gx && ny >= gy && nx <= gx + gw && ny <= gy + gh;
+}
+/**
+ * Analyze a saved ComfyUI graph: split its active nodes into connected
+ * components, associate group titles, and list the dangling nodes that
+ * extraction ignores.
+ * @param graph - parsed ComfyUI UI graph (v0.4 format).
+ * @returns the analysis, or an error object when the graph is not readable.
+ */
+export function analyzeGraph(graph) {
+    if (!isObject(graph) || !Array.isArray(graph.nodes) || !Array.isArray(graph.links)) {
+        return { ok: false, error: '无法解析图文件（缺少 nodes/links）' };
+    }
+    const nodes = graph.nodes;
+    const links = graph.links;
+    const groups = Array.isArray(graph.groups) ? graph.groups : [];
+    const active = nodes.filter((node) => node.mode !== 4);
+    const activeById = new Map(active.map((node) => [node.id, node]));
+    const bypassedCount = nodes.length - active.length;
+    // Dangling nodes: active but touching no link at all.
+    const linkedIds = new Set();
+    for (const link of links) {
+        if (typeof link[1] === 'number' && activeById.has(link[1]))
+            linkedIds.add(link[1]);
+        if (typeof link[3] === 'number' && activeById.has(link[3]))
+            linkedIds.add(link[3]);
+    }
+    const isolated = active
+        .filter((node) => !linkedIds.has(node.id))
+        .map((node) => ({ id: node.id, type: node.type }));
+    // Connected components over linked active nodes.
+    const adjacency = new Map();
+    for (const node of active)
+        adjacency.set(node.id, new Set());
+    for (const link of links) {
+        const a = link[1];
+        const b = link[3];
+        if (typeof a !== 'number' || typeof b !== 'number')
+            continue;
+        if (!adjacency.has(a) || !adjacency.has(b))
+            continue;
+        adjacency.get(a).add(b);
+        adjacency.get(b).add(a);
+    }
+    const seen = new Set();
+    const components = [];
+    for (const node of active) {
+        if (!linkedIds.has(node.id) || seen.has(node.id))
+            continue;
+        const stack = [node.id];
+        const memberIds = [];
+        while (stack.length > 0) {
+            const current = stack.pop();
+            if (seen.has(current))
+                continue;
+            seen.add(current);
+            memberIds.push(current);
+            for (const next of adjacency.get(current) ?? []) {
+                if (!seen.has(next))
+                    stack.push(next);
+            }
+        }
+        const members = memberIds.map((id) => activeById.get(id));
+        const groupTitles = groups
+            .filter((group) => members.some((member) => nodeInGroup(member, group)))
+            .map((group) => group.title ?? '(未命名组)');
+        const nodeTypes = [...new Set(members.map((member) => member.type).filter((type) => type !== ''))];
+        components.push({ index: components.length + 1, nodeIds: memberIds, size: memberIds.length, groups: groupTitles, nodeTypes });
+    }
+    components.sort((a, b) => b.size - a.size);
+    components.forEach((component, position) => {
+        component.index = position + 1;
+    });
+    return {
+        ok: true,
+        components,
+        isolated,
+        bypassedCount,
+        mode: components.length > 1 ? 'multi' : 'single',
+    };
+}

package/lib/comfyui.d.ts

@@ -0,0 +1,195 @@
+/** One media file produced by a workflow output node. */
+export interface ComfyUIMediaRef {
+    filename: string;
+    subfolder: string;
+    type: string;
+}
+/** A media item with its locating information and proxy URL. */
+export interface ComfyUIMediaItem extends ComfyUIMediaRef {
+    /** Output node id that produced the item. */
+    node: string;
+    /** Index within the node's media collection. */
+    index: number;
+    kind: 'image' | 'video' | 'audio' | 'other';
+    /** Same-origin proxy URL (web profile) or a descriptive placeholder. */
+    url: string;
+}
+/** One entry of the ComfyUI /history map. */
+export interface ComfyUIHistoryEntry {
+    prompt?: unknown;
+    outputs?: Record<string, {
+        images?: ComfyUIMediaRef[];
+        videos?: ComfyUIMediaRef[];
+        gifs?: ComfyUIMediaRef[];
+    }>;
+    status?: {
+        status_str?: string;
+        completed?: boolean;
+        messages?: unknown[];
+    };
+}
+/** One entry of ComfyUI's /queue: server-side generation tasks. */
+export interface ComfyUIQueueItem {
+    number: number;
+    prompt_id: string;
+}
+/** ComfyUI /queue response: the server-side generation queue. */
+export interface ComfyUIQueueView {
+    queue_running: ComfyUIQueueItem[];
+    queue_pending: ComfyUIQueueItem[];
+}
+/** A unified job from ComfyUI /api/jobs (running + pending + history). */
+export interface ComfyUIJob {
+    id: string;
+    status: 'pending' | 'in_progress' | 'completed' | 'failed' | 'cancelled';
+    priority: number;
+    create_time: number | null;
+    execution_start_time?: number | null;
+    execution_end_time?: number | null;
+    execution_error?: {
+        message?: string;
+        exception_message?: string;
+        node_type?: string;
+    } | null;
+    outputs_count: number;
+    previewable_outputs_count: number;
+    preview_output?: {
+        filename?: string;
+        subfolder?: string;
+        type?: string;
+        mediaType?: string;
+    } | null;
+    workflow_id?: string | null;
+    outputs?: Record<string, unknown>;
+    workflow?: {
+        prompt: unknown;
+        extra_data?: Record<string, unknown>;
+    };
+}
+/** /api/jobs list response. */
+export interface ComfyUIJobsResponse {
+    jobs: ComfyUIJob[];
+    pagination: {
+        offset: number;
+        limit: number | null;
+        total: number;
+        has_more: boolean;
+    };
+}
+/** One entry of a user-data directory listing (/v2/userdata). */
+export interface ComfyUIUserDataEntry {
+    name: string;
+    path: string;
+    type: 'file' | 'directory';
+    size?: number;
+    modified?: number;
+}
+/** Failure talking to the ComfyUI server. */
+export declare class ComfyUIError extends Error {
+    readonly status?: number | undefined;
+    constructor(message: string, status?: number | undefined);
+}
+/** The per-process client id ComfyUI uses to correlate queued prompts. */
+export declare const CLIENT_ID: `${string}-${string}-${string}-${string}-${string}`;
+/** HTTP client over the ComfyUI REST API. */
+export declare class ComfyUIClient {
+    private readonly baseUrl;
+    private readonly apiKey;
+    private readonly connectTimeoutMs;
+    private readonly maxMediaBytes;
+    constructor(baseUrl: string, apiKey: string | undefined, connectTimeoutMs: number, maxMediaBytes: number);
+    private endpoint;
+    private request;
+    /** Upload a file (multipart body forwarded verbatim) into ComfyUI's input directory. */
+    uploadFile(body: Uint8Array, contentType: string): Promise<{
+        name?: string;
+        subfolder?: string;
+        type?: string;
+    }>;
+    /** Queue one API-format workflow and return its prompt id. */
+    queuePrompt(workflow: unknown, options?: {
+        promptId?: string;
+        front?: boolean;
+        extraData?: Record<string, unknown>;
+    }): Promise<string>;
+    /** Read one prompt's history entry; undefined while the prompt is unknown or evicted. */
+    getHistory(promptId: string): Promise<ComfyUIHistoryEntry | undefined>;
+    /** The server-side queue: running + pending prompts. */
+    getQueue(): Promise<ComfyUIQueueView>;
+    /** Unified job list with status filters, sorting, and pagination. */
+    getJobs(options?: {
+        status?: Array<ComfyUIJob['status']>;
+        limit?: number;
+        offset?: number;
+        sortBy?: 'created_at' | 'execution_duration';
+        sortOrder?: 'asc' | 'desc';
+    }): Promise<ComfyUIJobsResponse>;
+    /** One job by id, including its workflow prompt and outputs. */
+    getJob(jobId: string): Promise<ComfyUIJob | undefined>;
+    /** Remove specific prompts from the pending queue. */
+    deleteQueueItems(promptIds: string[]): Promise<void>;
+    /** Clear the entire pending queue (running job is unaffected). */
+    clearQueue(): Promise<void>;
+    /** Interrupt the running prompt; without an id, interrupt globally. */
+    interruptPrompt(promptId?: string): Promise<void>;
+    /** Cancel one job regardless of state (running → interrupt, pending → dequeue). */
+    cancelJob(jobId: string): Promise<{
+        cancelled: boolean;
+    }>;
+    /** Best-effort batch cancel; finished or unknown ids are no-ops. */
+    cancelJobs(jobIds: string[]): Promise<{
+        cancelled: boolean;
+    }>;
+    /** Clear or selectively delete history entries. */
+    clearHistory(): Promise<void>;
+    /** Delete specific history entries. */
+    deleteHistory(promptIds: string[]): Promise<void>;
+    /** Ask ComfyUI to unload models / free memory (per /free flags). */
+    freeMemory(options?: {
+        unloadModels?: boolean;
+        freeMemory?: boolean;
+    }): Promise<void>;
+    /** List one user-data subdirectory (e.g. 'workflows') on the ComfyUI server. */
+    listUserData(subdir: string): Promise<ComfyUIUserDataEntry[]>;
+    /** Read one user-data file (path relative to the user root, e.g. 'workflows/x.json'). */
+    getUserDataFile(relPath: string): Promise<unknown>;
+    /** Node definitions for workflow construction (comfyui_object_info). */
+    objectInfo(): Promise<Record<string, unknown>>;
+    /** Server health/version probe. */
+    systemStats(): Promise<{
+        system?: {
+            comfyui_version?: string;
+        };
+    }>;
+    /** Ask ComfyUI to interrupt the running prompt. */
+    interrupt(): Promise<void>;
+    /** Download one generated media file through GET /view. */
+    fetchView(ref: ComfyUIMediaRef): Promise<{
+        bytes: Uint8Array;
+        contentType: string;
+    }>;
+    /**
+     * Poll history until the prompt completes, fails, or the budget/signal ends.
+     * Interrupts the server when the signal aborts before throwing.
+     */
+    waitForCompletion(opts: {
+        promptId: string;
+        timeoutMs: number;
+        pollIntervalMs: number;
+        signal: AbortSignal;
+    }): Promise<ComfyUIHistoryEntry>;
+}
+export declare function hasMedia(entry: ComfyUIHistoryEntry): boolean;
+/** Compose a readable failure message from history status messages. */
+export declare function historyErrorMessage(promptId: string, entry: ComfyUIHistoryEntry): string;
+/**
+ * Collect media items from a completed history entry, in node/output order,
+ * capped by maxItems. The URL is the same-origin proxy route when a web
+ * server is present, otherwise a ComfyUI /view URL (for headless hosts).
+ */
+export declare function collectMedia(opts: {
+    promptId: string;
+    entry: ComfyUIHistoryEntry;
+    maxItems: number;
+    proxyBase: string | undefined;
+}): ComfyUIMediaItem[];