dsh-comfyui 0.3.0-beta.2 → 0.3.0-beta.4

package/lib/routes.js

@@ -1,6 +1,104 @@
 import { errorMessage, readJsonBody, readRawBody, sameOrigin, sendJson } from './http.js';
-import { analyzeWorkflowParameters, comboChildInfo, inputOptions, uploadKindOf } from './params.js';
-import { collectMedia, historyErrorMessage } from './comfyui.js';
+import { analyzeWorkflowParameters, comboChildInfo, inputOptions, numberSpecOf, uploadKindOf } from './params.js';
+import { collectMedia, historyErrorMessage, mediaProxyUrl } from './comfyui.js';
+import { unlink } from 'node:fs/promises';
+import { isAbsolute, join, relative, resolve, sep } from 'node:path';
+/**
+ * Rebuild an asset's media URLs from the stored file references.
+ *
+ * Records written before the media proxy addressed files directly carry
+ * prompt/node/index URLs, which only resolve while ComfyUI still has that run
+ * in its in-memory /history — a server restart or a "clear history" click
+ * makes every one of them 404 ("source file evicted"), even though the files
+ * are untouched in the output directory. Healing them on read fixes the whole
+ * back catalogue without rewriting the stored index.
+ */
+function healAssetUrls(assets) {
+    return assets.map((asset) => ({
+        ...asset,
+        media: asset.media.map((item) => (item.filename === '' ? item : { ...item, url: mediaProxyUrl(item) })),
+    }));
+}
+/**
+ * Where ComfyUI writes its outputs on this machine.
+ *
+ * ComfyUI has no API that deletes an output file (its own asset routes only
+ * soft-delete a database row and keep the content), so removing a generated
+ * file means touching the filesystem directly. The configured `outputDir`
+ * wins; otherwise it is inferred from the absolute path some nodes report
+ * with their results (`fullpath`), by stripping the subfolder/filename tail
+ * the record already carries. When neither is available — a ComfyUI on
+ * another host, for instance — deletion degrades to dropping the index
+ * record and says so.
+ */
+function resolveOutputDir(configured, assets) {
+    if (configured !== '' && isAbsolute(configured))
+        return resolve(configured);
+    for (const asset of assets) {
+        for (const item of asset.media) {
+            const full = item.fullpath;
+            if (typeof full !== 'string' || full === '' || item.filename === '')
+                continue;
+            const tail = item.subfolder !== '' ? `${item.subfolder}/${item.filename}` : item.filename;
+            const normalized = full.replace(/\\/g, '/');
+            if (!normalized.endsWith(tail))
+                continue;
+            const root = normalized.slice(0, normalized.length - tail.length).replace(/[/]+$/, '');
+            if (root !== '')
+                return resolve(root);
+        }
+    }
+    return undefined;
+}
+/** Delete one generated file under the output directory. Returns 'deleted',
+ * 'missing' (already gone — the record still goes), or 'skipped' when the
+ * reference does not resolve inside the output directory. */
+async function deleteOutputFile(outputDir, ref) {
+    // 'temp' and 'input' live in sibling directories that this mapping does not
+    // cover; only outputs are ours to remove.
+    if (ref.filename === '' || (ref.type !== '' && ref.type !== 'output'))
+        return 'skipped';
+    const target = resolve(join(outputDir, ref.subfolder, ref.filename));
+    // Path-traversal guard: a crafted subfolder/filename must not reach outside.
+    const rel = relative(outputDir, target);
+    if (rel === '' || rel.startsWith('..') || isAbsolute(rel) || rel.split(sep).includes('..'))
+        return 'skipped';
+    try {
+        await unlink(target);
+        return 'deleted';
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return 'missing';
+        throw error;
+    }
+}
+const VIDEO_EXT = /\.(mp4|webm|mov|mkv|avi|m4v)$/i;
+const AUDIO_EXT = /\.(mp3|wav|ogg|flac|m4a|aac|opus)$/i;
+const IMAGE_EXT = /\.(png|jpe?g|gif|webp|bmp|tiff?|avif)$/i;
+/** The media kind of a file name, falling back to the loader's own kind when
+ * the extension says nothing. */
+function mediaKindOfName(name, fallback) {
+    if (VIDEO_EXT.test(name))
+        return 'video';
+    if (AUDIO_EXT.test(name))
+        return 'audio';
+    if (IMAGE_EXT.test(name))
+        return 'image';
+    return fallback;
+}
+/** The file-picker input key of a loader node class, taken from its
+ * object_info upload flag (image_upload / video_upload / audio_upload) so a
+ * renamed key does not silently empty the load area. */
+function loaderInputKey(objectInfo, classType) {
+    const def = objectInfo?.[classType];
+    const inputs = { ...def?.input?.required, ...def?.input?.optional };
+    for (const key of Object.keys(inputs)) {
+        if (uploadKindOf(objectInfo, classType, key) !== undefined)
+            return key;
+    }
+    return undefined;
+}
 function generatedUrlOf(assets, name) {
     for (const asset of assets) {
         for (const item of asset.media) {
@@ -227,7 +325,10 @@ export function mountComfyUIRoutes(ctx, runtime) {
                 ? comboChildInfo(objectInfo, classType, inputKey, body.parentValue)
                 : undefined;
             const upload = uploadKindOf(objectInfo, classType, inputKey);
-            sendJson(response, 200, { ok: true, options: options ?? [], child, upload });
+            // Declared INT/FLOAT type: the editor uses it to allow (or round away)
+            // decimals instead of assuming every number input is an integer.
+            const number = numberSpecOf(objectInfo, classType, inputKey);
+            sendJson(response, 200, { ok: true, options: options ?? [], child, upload, number });
         }),
     }));
     disposers.push(webServer.register({
@@ -240,29 +341,40 @@ export function mountComfyUIRoutes(ctx, runtime) {
             }
             try {
                 const client = runtime.createClient(await runtime.getApiKey());
-                const [objectInfo, current, assets, sizes] = await Promise.all([
+                const [objectInfo, slots, assets, sizes] = await Promise.all([
                     client.objectInfo().catch(() => undefined),
-                    runtime.loadCurrentImage(),
-                    runtime.listAssets(),
+                    runtime.loadSlots(),
+                    runtime.listAssets().then(healAssetUrls),
                     runtime.listMediaSizes(),
                 ]);
                 const files = [];
                 const seen = new Set();
-                // imported: files visible to the ComfyUI loader nodes (input dir)
+                // imported: files visible to the ComfyUI loader nodes (input dir).
+                // The input key is read from object_info rather than hard-coded —
+                // LoadImage calls it "image", LoadVideo "file", LoadAudio "audio",
+                // and guessing wrong silently drops that whole media type from the
+                // load area (which is what happened to video).
                 const loaderSpecs = [
-                    ['LoadImage', 'image', 'image'],
-                    ['LoadVideo', 'video', 'video'],
-                    ['LoadAudio', 'audio', 'audio'],
+                    ['LoadImage', 'image'],
+                    ['LoadVideo', 'video'],
+                    ['LoadAudio', 'audio'],
                 ];
-                for (const [classType, inputKey, kind] of loaderSpecs) {
+                for (const [classType, fallbackKind] of loaderSpecs) {
+                    const inputKey = loaderInputKey(objectInfo, classType);
+                    if (inputKey === undefined)
+                        continue;
                     for (const option of inputOptions(objectInfo, classType, inputKey) ?? []) {
                         const name = String(option);
                         if (seen.has(name))
                             continue;
                         seen.add(name);
                         files.push({
+                            // Classify by extension first: ComfyUI lists an .mp4 under
+                            // LoadAudio too (it can pull the audio track), and whichever
+                            // loader happened to be scanned first would otherwise decide
+                            // the file's type in the picker.
                             name,
-                            kind,
+                            kind: mediaKindOfName(name, fallbackKind),
                             source: 'imported',
                             url: `/comfyui/media?file=${encodeURIComponent(name)}&type=input`,
                             width: sizes[name]?.width,
@@ -286,21 +398,26 @@ export function mountComfyUIRoutes(ctx, runtime) {
                         });
                     }
                 }
-                let currentEntry = null;
-                if (current !== undefined) {
-                    const url = current.source === 'generated'
-                        ? generatedUrlOf(assets, current.name) ?? `/comfyui/media?file=${encodeURIComponent(current.name)}&type=output`
-                        : `/comfyui/media?file=${encodeURIComponent(current.name)}&type=input`;
-                    currentEntry = {
-                        name: current.name,
-                        kind: current.kind,
-                        source: current.source,
+                // Every slot in order; `null` entries are empty slots the user added.
+                const slotEntries = slots.map((slot) => {
+                    if (slot === null)
+                        return null;
+                    const url = slot.source === 'generated'
+                        ? generatedUrlOf(assets, slot.name) ?? `/comfyui/media?file=${encodeURIComponent(slot.name)}&type=output`
+                        : `/comfyui/media?file=${encodeURIComponent(slot.name)}&type=input`;
+                    return {
+                        name: slot.name,
+                        kind: slot.kind,
+                        source: slot.source,
                         url,
-                        width: sizes[current.name]?.width,
-                        height: sizes[current.name]?.height,
+                        width: sizes[slot.name]?.width,
+                        height: sizes[slot.name]?.height,
                     };
-                }
-                sendJson(response, 200, { ok: true, current: currentEntry, files });
+                });
+                // `current` stays in the payload as the first filled slot: it is the
+                // primary source image, and older clients read only this field.
+                const currentEntry = slotEntries.find((entry) => entry !== null) ?? null;
+                sendJson(response, 200, { ok: true, current: currentEntry, slots: slotEntries, files });
             }
             catch (error) {
                 sendJson(response, 500, { error: errorMessage(error) });
@@ -318,27 +435,77 @@ export function mountComfyUIRoutes(ctx, runtime) {
             const body = await readSameOriginPost(request, response);
             if (body === undefined)
                 return;
-            const name = typeof body.name === 'string' && body.name !== '' ? body.name : '';
-            const kind = body.kind === 'video' ? 'video' : body.kind === 'audio' ? 'audio' : 'image';
-            const source = body.source === 'generated' ? 'generated' : 'imported';
-            if (name === '') {
-                sendJson(response, 400, { error: 'name is required' });
-                return;
-            }
+            // Slot operations of the load area. `pick` (the default, and the body
+            // shape older clients send) puts a file into a slot; the others manage
+            // the slots themselves.
+            const action = typeof body.action === 'string' ? body.action : 'pick';
+            const slots = await runtime.loadSlots();
+            const index = typeof body.index === 'number' && Number.isInteger(body.index) && body.index >= 0
+                ? body.index
+                : undefined;
             try {
-                if (source === 'generated') {
-                    // Generated outputs live in ComfyUI's output dir; copy the selected
-                    // one into the input dir (same name) so loader nodes can use it.
-                    const assets = await runtime.listAssets();
-                    const ref = findOutputRef(assets, name);
-                    if (ref !== undefined) {
-                        const client = runtime.createClient(await runtime.getApiKey());
-                        const { bytes, contentType } = await client.fetchView(ref);
-                        await client.uploadFile(bytes, contentType);
+                switch (action) {
+                    case 'addSlot':
+                        slots.push(null);
+                        break;
+                    case 'clear': {
+                        // "清除素材": the slot stays, its file is dropped.
+                        if (index === undefined || index >= slots.length) {
+                            sendJson(response, 400, { error: 'index is required and must point at an existing slot' });
+                            return;
+                        }
+                        slots[index] = null;
+                        break;
+                    }
+                    case 'removeSlot': {
+                        // "删除加载区": the slot itself goes away.
+                        if (index === undefined || index >= slots.length) {
+                            sendJson(response, 400, { error: 'index is required and must point at an existing slot' });
+                            return;
+                        }
+                        slots.splice(index, 1);
+                        break;
+                    }
+                    case 'pick': {
+                        const name = typeof body.name === 'string' ? body.name : '';
+                        if (name === '') {
+                            sendJson(response, 400, { error: 'name is required' });
+                            return;
+                        }
+                        const kind = body.kind === 'video' ? 'video' : body.kind === 'audio' ? 'audio' : 'image';
+                        const source = body.source === 'generated' ? 'generated' : 'imported';
+                        // No index: fill the first empty slot, or open a new one. This is
+                        // what the picker sends when the user adds material to the load
+                        // area without targeting a particular slot. Resolve and validate
+                        // the target before copying anything, so a bad index cannot leave
+                        // a file copied into ComfyUI with no slot to show for it.
+                        const firstEmpty = slots.findIndex((slot) => slot === null);
+                        const target = index ?? (firstEmpty === -1 ? slots.length : firstEmpty);
+                        if (target > slots.length) {
+                            sendJson(response, 400, { error: 'index is out of range' });
+                            return;
+                        }
+                        if (source === 'generated') {
+                            // Generated outputs live in ComfyUI's output dir; copy the
+                            // selected one into the input dir (same name) so loader nodes
+                            // can use it.
+                            const assets = await runtime.listAssets();
+                            const ref = findOutputRef(assets, name);
+                            if (ref !== undefined) {
+                                const client = runtime.createClient(await runtime.getApiKey());
+                                const { bytes, contentType } = await client.fetchView(ref);
+                                await client.uploadMedia(bytes, name, contentType);
+                            }
+                        }
+                        slots[target] = { name, kind, source };
+                        break;
                     }
+                    default:
+                        sendJson(response, 400, { error: `unknown action "${action}"` });
+                        return;
                 }
-                await runtime.saveCurrentImage({ name, kind, source });
-                sendJson(response, 200, { ok: true });
+                await runtime.saveSlots(slots);
+                sendJson(response, 200, { ok: true, slots: slots.length, loaded: slots.filter((slot) => slot !== null).length });
             }
             catch (error) {
                 sendJson(response, 500, { error: errorMessage(error) });
@@ -586,7 +753,73 @@ export function mountComfyUIRoutes(ctx, runtime) {
             // Sweep completed tracked runs into the index before listing, so the
             // panel sees results as soon as the next poll lands.
             await runtime.sweep();
-            sendJson(response, 200, { ok: true, assets: await runtime.listAssets() });
+            sendJson(response, 200, { ok: true, assets: healAssetUrls(await runtime.listAssets()) });
+        }),
+    }));
+    disposers.push(webServer.register({
+        kind: 'exact',
+        path: '/comfyui/assets/delete',
+        handler: withHint(async (request, response) => {
+            if (!methodIs(request, 'POST')) {
+                sendJson(response, 405, { error: 'method not allowed' });
+                return;
+            }
+            const body = await readSameOriginPost(request, response);
+            if (body === undefined)
+                return;
+            const promptId = typeof body.promptId === 'string' ? body.promptId : '';
+            if (promptId === '') {
+                sendJson(response, 400, { error: 'promptId is required' });
+                return;
+            }
+            try {
+                // Resolve the output directory from the index *before* the record is
+                // removed: the path hint may live on the very record being deleted.
+                const assets = await runtime.listAssets();
+                const outputDir = resolveOutputDir(runtime.getConfig().outputDir, assets);
+                const removed = await runtime.deleteAsset(promptId);
+                if (removed === undefined) {
+                    sendJson(response, 404, { error: `asset ${promptId} not found` });
+                    return;
+                }
+                let deleted = 0;
+                let missing = 0;
+                let skipped = 0;
+                const failures = [];
+                if (outputDir !== undefined) {
+                    for (const item of removed.media) {
+                        try {
+                            const result = await deleteOutputFile(outputDir, { filename: item.filename, subfolder: item.subfolder, type: item.type });
+                            if (result === 'deleted')
+                                deleted += 1;
+                            else if (result === 'missing')
+                                missing += 1;
+                            else
+                                skipped += 1;
+                        }
+                        catch (error) {
+                            // The record is already gone; report which files survived it.
+                            failures.push(`${item.filename}: ${errorMessage(error)}`);
+                        }
+                    }
+                }
+                else {
+                    skipped = removed.media.length;
+                }
+                sendJson(response, 200, {
+                    ok: true,
+                    promptId,
+                    files: removed.media.length,
+                    deleted,
+                    missing,
+                    skipped,
+                    outputDir: outputDir ?? null,
+                    failures,
+                });
+            }
+            catch (error) {
+                sendJson(response, 500, { error: errorMessage(error) });
+            }
         }),
     }));
     disposers.push(webServer.register({

package/lib/skill.js

@@ -41,15 +41,15 @@ comfyui_workflow 的 \`action: list\` 会同时返回：插件库中的 API 工
 ## 可调参数（运行传参）
 
 - 每个运行工作流带一组**可调参数**：提取时自动识别 提示词（文本输入）、分辨率（EmptyLatentImage 宽高）、步数（KSampler.steps）、种子（KSampler.seed，默认每次随机）、时长（duration/length/frames）、宽高比（aspect_ratio）、加载节点（LoadImage/LoadVideo/LoadAudio 的图片/视频/音频文件，值填服务器上的文件名，用户在面板可拖拽上传）。识别是**通用规则**（对象信息里的 upload 标记/文件列表），不针对具体节点；像 MiniMaxH3 综合加载（media_state JSON）这类通用规则识别不到的输入，让用户在面板"高级参数"里手动添加——值若形如媒体 JSON 数组，会自动拆成 \`media_1/media_2/...\` 参考位（值填子目录文件名，空字符串 = 移除该参考位）。cfg/denoise 与模型选择不在其中，保持工作流原样。用户可在面板"编辑工作流"里改默认值/随机开关，或添加高级参数（任意节点输入）。
-- \`action: list\` 输出每个工作流的 \`parameters\` 字段就是结构化参数清单（\`name\` 是英文参数名、\`label\` 是中文含义、\`default\` 是默认值、\`random\` 表示是否每次随机、\`options\` 是下拉选项列表、\`upload\` 表示加载节点上传类型），用之前先看它。带 \`options\` 的参数必须从选项里取值（加载节点可从文件列表选，也可提示用户拖拽上传新文件）。
+- \`action: list\` 输出每个工作流的 \`parameters\` 字段就是结构化参数清单（\`name\` 是英文参数名、\`label\` 是中文含义、\`default\` 是默认值、\`random\` 表示是否每次随机、\`numberKind\` 是数字参数的类型（\`int\` 只接受整数，传小数会四舍五入；\`float\` 可传小数如 cfg 7.5、denoise 0.6；没有该字段表示类型未知，按小数传即可）、\`options\` 是下拉选项列表、\`upload\` 表示加载节点上传类型），用之前先看它。带 \`options\` 的参数必须从选项里取值（加载节点可从文件列表选，也可提示用户拖拽上传新文件）。
 - 运行时可传 \`parameters\` 覆盖：\`{"prompt": "新提示词", "seed": 42, "width": 1024}\`。显式传值优先于默认；seed 类参数不传时按工作流设置随机（每次不同）。**参数名必须用清单里的英文 \`name\`**（prompt/seed/width/height/steps/duration/aspect_ratio），不要自造；带 \`options\` 的参数传值必须落在选项内，否则会报错。\`aspect_ratio\` 这类联动参数：只传它时 \`size\` 会自动跟随新比例的默认尺寸（如 9:16 → 768×1376），也可显式传 \`size\` 覆盖。
 
 ## 加载区与上传（给用户）
 
-- 工作流库页面（运行主题）**最底部**有一个"**加载区**"（类似 ComfyUI 的 LoadImage 节点）：大图显示当前选中的图像，点击打开选择窗口——顶部"全部 / 已导入 / 已生成"导航条 + 右侧粘贴/点击上传区，下面是瀑布流图像列表。
-- **已导入** = ComfyUI input 目录里的文件；**已生成** = 之前工作流产出的图像（output）；**全部** = 两者合并。
-- 粘贴/上传新图 → 自动上传 → 列表刷新出现该图；点击任意图像 → 选定并关闭窗口，加载区大图更新为该图（像素尺寸在**上传时**自动记录并显示在大图下方；历史旧图若无记录则不显示尺寸、也不参与尺寸匹配）。
-- **默认源图**：加载区选中的图像会成为图生图的**默认源图**——你 run 含 \`image\`（LoadImage）参数的工作流时，如果**没显式传 image**，插件自动用加载区选中的文件名（显式传 \`image\` 则优先）。聊天消息里出现 \`[已上传图片: 文件名]\` 标记同理：文件已由"贴图"按钮上传到 ComfyUI 的 input 目录，直接可用；文件名带 \`subfolder/\` 前缀的按原样传。
+- 工作流库页面（运行主题）**最底部**有一个"**加载区**"（类似 ComfyUI 的 LoadImage 节点）：由若干**加载位**组成（只有一个时铺满面板，多个时等宽排列），点击任一加载位打开选择窗口——顶部"全部 / 已导入 / 已生成"导航条 + 右侧粘贴/点击上传区，下面是瀑布流列表。用户可用"添加加载区"增加加载位，鼠标悬停加载位右上角的 × 删除该位，选择窗口第一格的"空"用于清空该位但保留它。
+- **已导入** = ComfyUI input 目录里可被加载节点使用的图像/视频/音频；**已生成** = 之前工作流产出的结果（output，选中时自动复制进 input）；**全部** = 两者合并。选择窗口里视频与音频可直接播放试听。
+- 粘贴/上传新图 → 自动上传 → 列表刷新出现该图；点击文件名 → 放入该加载位并关闭窗口（像素尺寸在**上传时**自动记录并显示在大图下方；历史旧图若无记录则不显示尺寸、也不参与尺寸匹配）。
+- **默认源素材**：加载区里已放入素材的加载位会按顺序填进工作流里**未显式传值**的加载参数——第 1 个加载位 → 第 1 个图片参数，第 2 个 → 第 2 个，视频/音频参数各自取同类型的加载位；显式传值永远优先，没有对应加载位的参数保持工作流原值。\`comfyui_workflow action: list\` 的输出里有 \`loadArea\`（\`slots\` 加载位数、\`loaded\` 已放入素材数、\`items\` 文件清单），**要知道用户加载了几个素材就看它**，不要反复问用户。聊天消息里出现 \`[已上传图片: 文件名]\` 标记同理：文件已由"贴图"按钮上传到 ComfyUI 的 input 目录，直接可用；文件名带 \`subfolder/\` 前缀的按原样传。
 - **尺寸自动匹配**：面板上传/加载时插件会记录图片像素尺寸。图生图 run 时如果**没显式传 width/height**，插件自动用源图分辨率作为输出尺寸（显式传值优先）。加载区大图下方会显示选中图的尺寸（如 \`1024×768\`）。
 - **命名与去重**：上传文件按内容哈希命名（\`原名_短哈希.ext\`，如 \`image_3f9a2b1c0d.png\`），同一张图重复上传会直接复用已有文件（不会产生 \`image(1).png\` 之类的重复文件）。
 - 选中"已生成"的图后，插件会自动把它从 output 复制到 input 目录（同名），保证加载节点可用。

package/lib/store.d.ts

@@ -38,6 +38,8 @@ export interface AssetRecord {
     source: string;
     media: AssetMediaRef[];
 }
+/** One load-area slot: a picked file, or `null` for an empty slot. */
+export type LoadSlot = CurrentImage | null;
 /** The load-area selection: the image the user picked for image-to-image.
  * `name` is always a file name ComfyUI can load (generated outputs are copied
  * into the input dir on selection). */
@@ -85,9 +87,16 @@ export declare class ComfyUIStore {
     loadMediaHashes(): Promise<Record<string, string>>;
     lookupMediaHash(hash: string): Promise<string | undefined>;
     saveMediaHash(hash: string, name: string): Promise<void>;
-    /** The load-area selection (survives restarts so image-to-image keeps its default source image). */
-    loadCurrentImage(): Promise<CurrentImage | undefined>;
-    saveCurrentImage(image: CurrentImage): Promise<void>;
+    /** The load-area slots: an ordered list where each entry is either a picked
+     * file or `null` for an empty slot the user added but has not filled yet.
+     * Slot 0 is the primary source (the big preview, and the default source
+     * image for image-to-image).
+     *
+     * The file held a single `{name,kind,source}` object before the load area
+     * had more than one slot; that shape is still read and lifted into a
+     * one-slot list, so an existing selection survives the upgrade. */
+    loadSlots(): Promise<LoadSlot[]>;
+    saveSlots(slots: LoadSlot[]): Promise<void>;
     listWorkflows(): Promise<StoredWorkflow[]>;
     getWorkflow(id: string): Promise<StoredWorkflow | undefined>;
     private writeWorkflows;
@@ -112,6 +121,9 @@ export declare class ComfyUIStore {
     deleteWorkflow(id: string): Promise<boolean>;
     listAssets(): Promise<AssetRecord[]>;
     /** Prepend an asset record (deduplicated by promptId, capped at maxAssets). */
+    /** Drop one asset record from the index; returns the record that was
+     * removed so the caller can delete the files it referenced. */
+    deleteAsset(promptId: string): Promise<AssetRecord | undefined>;
     appendAsset(record: AssetRecord): Promise<void>;
     /** Load the persisted queue-tracker state (empty when absent/corrupt). */
     loadTracked(): Promise<TrackedState>;

package/lib/store.js

@@ -7,6 +7,8 @@
 import { randomUUID } from 'node:crypto';
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
+/** Trailing newline for the JSON files this store writes. */
+const NEWLINE = '\n';
 /** Validate a workflow-shaped value; returns an error message or undefined. */
 export function validateWorkflow(value) {
     if (typeof value !== 'object' || value === null || Array.isArray(value)) {
@@ -87,21 +89,44 @@ export class ComfyUIStore {
         hashes[hash] = name;
         await writeFile(this.mediaHashesPath, `${JSON.stringify(hashes, null, 2)}\n`, 'utf8');
     }
-    /** The load-area selection (survives restarts so image-to-image keeps its default source image). */
-    async loadCurrentImage() {
+    /** The load-area slots: an ordered list where each entry is either a picked
+     * file or `null` for an empty slot the user added but has not filled yet.
+     * Slot 0 is the primary source (the big preview, and the default source
+     * image for image-to-image).
+     *
+     * The file held a single `{name,kind,source}` object before the load area
+     * had more than one slot; that shape is still read and lifted into a
+     * one-slot list, so an existing selection survives the upgrade. */
+    async loadSlots() {
         const parsed = await readJsonFile(this.currentImagePath, undefined);
         if (typeof parsed !== 'object' || parsed === null)
-            return undefined;
-        if (typeof parsed.name !== 'string' || parsed.name === '')
-            return undefined;
-        return {
-            name: parsed.name,
-            kind: parsed.kind === 'video' || parsed.kind === 'audio' ? parsed.kind : 'image',
-            source: parsed.source === 'generated' ? 'generated' : 'imported',
-        };
+            return [];
+        const raw = Array.isArray(parsed.items)
+            ? parsed.items
+            : [parsed];
+        const slots = [];
+        for (const entry of raw) {
+            if (entry === null) {
+                slots.push(null);
+                continue;
+            }
+            if (typeof entry !== 'object')
+                continue;
+            const { name, kind, source } = entry;
+            if (typeof name !== 'string' || name === '') {
+                slots.push(null);
+                continue;
+            }
+            slots.push({
+                name,
+                kind: kind === 'video' || kind === 'audio' ? kind : 'image',
+                source: source === 'generated' ? 'generated' : 'imported',
+            });
+        }
+        return slots;
     }
-    async saveCurrentImage(image) {
-        await writeFile(this.currentImagePath, `${JSON.stringify(image, null, 2)}\n`, 'utf8');
+    async saveSlots(slots) {
+        await writeFile(this.currentImagePath, JSON.stringify({ items: slots }, null, 2) + NEWLINE, 'utf8');
     }
     async listWorkflows() {
         const list = await readJsonFile(this.workflowsPath, []);
@@ -169,6 +194,17 @@ export class ComfyUIStore {
         return Array.isArray(list) ? list : [];
     }
     /** Prepend an asset record (deduplicated by promptId, capped at maxAssets). */
+    /** Drop one asset record from the index; returns the record that was
+     * removed so the caller can delete the files it referenced. */
+    async deleteAsset(promptId) {
+        const list = await this.listAssets();
+        const index = list.findIndex((record) => record.promptId === promptId);
+        if (index === -1)
+            return undefined;
+        const [removed] = list.splice(index, 1);
+        await writeFile(this.assetsPath, JSON.stringify(list, null, 2) + NEWLINE, 'utf8');
+        return removed;
+    }
     async appendAsset(record) {
         const list = await this.listAssets();
         if (list.some((entry) => entry.promptId === record.promptId))

package/lib/tools.d.ts

@@ -8,7 +8,7 @@
 import type { Context } from '@deepseek-ai/cordis';
 import type { Config } from './config.js';
 import { ComfyUIClient } from './comfyui.js';
-import type { AssetRecord, StoredWorkflow } from './store.js';
+import type { AssetRecord, LoadSlot, StoredWorkflow } from './store.js';
 import type { GraphAnalysis } from './analyze.js';
 import type { RunProgress } from './progress.js';
 import type { QueuedRun } from './queue.js';
@@ -96,20 +96,15 @@ export interface ComfyUIRuntime {
     lookupMediaHash(hash: string): Promise<string | undefined>;
     /** Record a content hash → file name pair for dedup. */
     saveMediaHash(hash: string, name: string): Promise<void>;
-    /** The load-area selection (default source image for image-to-image). */
-    loadCurrentImage(): Promise<{
-        name: string;
-        kind: 'image' | 'video' | 'audio';
-        source: 'imported' | 'generated';
-    } | undefined>;
-    /** Persist the load-area selection. */
-    saveCurrentImage(image: {
-        name: string;
-        kind: 'image' | 'video' | 'audio';
-        source: 'imported' | 'generated';
-    }): Promise<void>;
+    /** The load-area slots, in order; `null` is an empty slot the user added.
+     * Filled slots are the default source media for loader parameters. */
+    loadSlots(): Promise<Array<LoadSlot>>;
+    /** Persist the load-area slots. */
+    saveSlots(slots: Array<LoadSlot>): Promise<void>;
     /** The asset index (newest first). */
     listAssets(): Promise<AssetRecord[]>;
+    /** Remove one asset record from the index, returning what was removed. */
+    deleteAsset(promptId: string): Promise<AssetRecord | undefined>;
     /** Move completed tracked runs into the asset index. */
     sweep(): Promise<AssetRecord[]>;
     /** Workflows the user saved on the ComfyUI server, with extract status. */

package/lib/tools.js

@@ -338,6 +338,13 @@ function workflowDefinition(runtime, ctx) {
                             lines.push(`  ${param.name}(${param.label}${param.random === true ? '，随机' : ''}，默认 ${def}${options}${upload})`);
                         }
                     }
+                    const loadArea = data.loadArea;
+                    if (loadArea !== undefined && loadArea.slots > 0) {
+                        lines.push(`用户加载区（${loadArea.slots} 个加载位，已放入 ${loadArea.loaded} 个素材，未显式传值的加载参数按顺序取用）:`);
+                        for (const [index, item] of loadArea.items.entries()) {
+                            lines.push(`  ${index + 1}. ${item.name}（${item.kind}）`);
+                        }
+                    }
                     const comfyui = data.comfyuiWorkflows ?? [];
                     if (comfyui.length > 0) {
                         lines.push(`ComfyUI 端保存的图工作流（${comfyui.length} 个，UI 图格式，不能直接运行）:`);
@@ -371,22 +378,36 @@ function workflowDefinition(runtime, ctx) {
                 throw new Error(`comfyui_workflow: action must be list, run, or get, got ${String(action)}`);
             }
             if (action === 'list') {
-                const [workflows, comfyui] = await Promise.all([
+                const [workflows, comfyui, slots] = await Promise.all([
                     runtime.listWorkflows(),
                     runtime.listComfyWorkflows().catch(() => []),
+                    runtime.loadSlots().catch(() => []),
                 ]);
+                // What the user currently has loaded in the panel's load area. Unset
+                // loader parameters take these files in slot order, so the model can
+                // see how many references a run will pick up without asking.
+                const loaded = slots.filter((slot) => slot !== null);
                 return {
                     action: 'list',
+                    loadArea: {
+                        slots: slots.length,
+                        loaded: loaded.length,
+                        items: loaded.map(({ name, kind, source }) => ({ name, kind, source })),
+                    },
                     workflows: workflows.map(({ id, name, description, parameters, updatedAt }) => ({
                         id,
                         name,
                         description,
-                        parameters: (parameters ?? []).map(({ name: pname, label, type, default: def, random, options, upload }) => {
+                        parameters: (parameters ?? []).map(({ name: pname, label, type, default: def, random, numberKind, options, upload }) => {
                             // DSH validates tool output as lossless JSON: JSON.stringify drops
                             // undefined keys, so omit optional fields instead of passing undefined.
                             const entry = { name: pname, label, type, default: def };
                             if (random !== undefined)
                                 entry.random = random;
+                            // Tells the model whether decimals are accepted; absent means the
+                            // node's declared type is unknown and a float is safe.
+                            if (numberKind !== undefined)
+                                entry.numberKind = numberKind;
                             if (options !== undefined)
                                 entry.options = options;
                             if (upload !== undefined)

package/package.json

@@ -1,7 +1,11 @@
 {
   "name": "dsh-comfyui",
-  "version": "0.3.0-beta.2",
+  "version": "0.3.0-beta.4",
   "description": "Drive ComfyUI from DeepSeek Harness: generate and process images and videos through agent tools, with a workflow/asset/queue panel, in-chat results and a settings page. / 让 DeepSeek Harness 的 Agent 直接驱动 ComfyUI 生成与处理图像、视频，带工作流/资产/队列面板。",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fandc520/dsh-comfyui.git"
+  },
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",