Compare commits

...
25 Commits
Author SHA1 Message Date
ketle-manandClaude Sonnet 4.6 8c98eabf59 fix: GenUI ModelでLoRA適用後にModelサブタブ再表示で値がリセットされるバグ修正 (v0.3.52)
renderLoraPaneがModelサブタブ切替のたびにel.innerHTMLを再構築する際、
currentValをcurrentAnalysis(古いanalysis)から取得していたため、
applyToGenUIでcurrentWorkflowを更新してもサブタブ再表示時に元の値に戻っていた。
currentWorkflowから直接読み取るよう修正し、syntax/trigger wordsも保存・復元する。

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-06-24 21:45:39 +09:00
ketle-manandClaude Sonnet 4.6 8b3be02600 chore: bump version to v0.3.51; update README and DEVLOG
- pyproject.toml: 0.3.50 → 0.3.51
- README: version badge updated, Input/Model tab and GenUI Model button
  descriptions updated; v0.3.51 Changelog entry added
- DEVLOG: v0.3.50 → v0.3.51 for all new-feature entries added this session

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-06-24 18:57:16 +09:00
ketle-manandClaude Sonnet 4.6 e82808e16a docs(help): update help for Embedding GenUI PP/NP and Hypernetwork in Gen UI
- gen-4: describe Embeddings selector + Paste button in Prompt tab
- gen-5: add Hypernetwork (with Strength field) to Model tab list
- models-8: add Hypernetwork to GenUI Model list; add Embedding GenUI PP/NP button description
- All three languages updated (EN/JP/ZH)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-06-24 18:53:40 +09:00
ketle-manandClaude Sonnet 4.6 751f507f91 fix(genui): reduce Positive Prompt textarea height by 2 rows (~45px)
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-06-24 18:49:50 +09:00
ketle-manandClaude Sonnet 4.6 9ece4b3549 feat(embedding): add GenUI PP/NP buttons for Embeddings + Paste in Prompt tab
- Models tab: show GenUI PP / GenUI NP buttons for Embedding type in side panel nav, info panel, and detail modal
- Generate UI > Prompt tab: add Embeddings section with filter/select/weight + Paste button (inserts at cursor position of last focused textarea)
- comfyEditor: appendEmbeddingToPrompt() updates both workflow JSON and textarea
- closeSidePanel(): hides nav buttons to prevent stale state on model type switch

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-06-24 18:34:25 +09:00
ketle-manandClaude Sonnet 4.6 8af4a05a48 feat(genui): add Hypernetwork support to GenerateUI Model tab
GenerateUIのModelタブ最下部にHypernetworkセクションを追加。
ワークフロー解析でHypernetworkLoaderを検出し、
strength入力フィールドも含めてApply対応。
ModelsタブGenUI ModelボタンもHypernetworkタイプで有効化。

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-06-24 17:59:33 +09:00
ketle-manandClaude Sonnet 4.6 87c805c51d fix(models): fix Embedding not showing via WFS backend API
ComfyUIの/embeddingsエンドポイントへの直接fetchがHTMLを返す問題を修正。
WFSバックエンドの/api/wfm/models/files?type=embeddingを新設し、
folder_pathsからモデルファイルを確実に取得するよう変更。

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-06-24 17:29:59 +09:00
ketle-manandClaude Sonnet 4.6 22ed57efb3 fix(models): support V3 ComfyNode Combo format in _fetchModelList
HypernetworkLoaderがV3形式(options)でComboを返すため
Hypernetworkモデルが空になっていたバグを修正。
fetchEmbeddingsにエラーログを追加しデバッグを容易にした。

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-06-24 17:15:11 +09:00
ketle-manandClaude Sonnet 4.6 070015ea3d feat(models): add GenUI Model button to side panel tab nav
CivitAIタブ横のタブナビゲーション右端にGenUI Modelボタンを追加。
GenUI非対応タイプでは自動的に非表示になる。モーダルの既存ボタンは維持。

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-06-24 15:01:03 +09:00
ketle-manandClaude Sonnet 4.6 474dea9e7f fix: gallery prompt search hang — background indexer + asyncio.to_thread (v0.3.50)
- Remove on-demand metadata read from list_images() (root cause of hang)
- Wrap list_images() route in asyncio.to_thread() to free the event loop
- Add background indexer (start_background_index / _bg_index_folder):
  processes uncached images 10 at a time with 50ms sleep between batches;
  auto-starts on folder load; cancellable on folder switch

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-06-22 12:36:33 +09:00
ketle-manandClaude Sonnet 4.6 465871b9f8 feat: GenerateUI A1111-style wildcard expansion + Gallery bug fixes (v0.3.49)
- GenerateUI: SPA-side __name__ wildcard expansion for non-ImpactWildcard nodes
  (CLIPTextEncode etc.); nested expansion up to 5 passes; ImpactWildcard* skipped
  (server-side); works in single and batch generation
- Gallery: fix Export button missing text label in bulk action bar
- Gallery: fix prompt search missing images with no cached prompt index —
  on-demand metadata read + cache build when search is active
- Help text updated (EN/JA/ZH): helpGen16 added
- Version bumped to 0.3.49

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-06-22 11:43:17 +09:00
ketle-manandClaude Sonnet 4.6 c3bee0ee09 docs: ギャラリータブの画像ダウンロード・エクスポート機能のドキュメント更新
- README.md: Gallery Tabセクションに機能説明を追加
- DEVLOG.md: v0.3.48エントリを追加(新機能の実装詳細)
- templates/index.html: ヘルプテキストを更新(wfm-help-gallery-6, -7)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-06-22 10:57:11 +09:00
ketle-manandClaude Sonnet 4.6 3dc593da4e feat: ギャラリータブに画像ダウンロードと一括エクスポート機能を追加
- 詳細パネルのプレビュー画像にマウスホバーでダウンロードアイコンをオーバーレイ表示
- 詳細パネルから単一画像をダウンロード可能に
- 複数選択メニューに「エクスポート」ボタンを追加
- 複数選択した画像をZIPファイルにしてエクスポート
- Backend: POST /wfm/gallery/images/export-zip エンドポイント実装
- Frontend: ダウンロード・ZIPエクスポート機能実装
- i18n対応: 英語/日本語/中国語

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-06-22 10:36:09 +09:00
ketle-manandClaude Sonnet 4.6 aa8c8f73fe fix: update JS group state after model file move (v0.3.47)
When models were moved to a subdirectory via bulkMoveModels, state.modelGroups
was not updated to reflect the new model paths, causing moved models to
disappear from group filter views immediately after the operation.

Added in-place rename of group members (from → to) inside the moved.forEach
loop, mirroring the server-side rename already performed by move_models in
models_service.py. Generate tab Batch groups are unaffected as they fetch
fresh from the server on each tab open.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-06-22 08:34:59 +09:00
ketle-manandClaude Sonnet 4.6 281fba373c feat: Prompt tab AI Assistant LM Studio support + Settings AI Assistant section (v0.3.46)
- Settings tab: rename "Ollama Settings" to "AI Assistant Settings (Prompt Tab)";
  add backend selector (Ollama / LM Studio), URL input, model select, Test button;
  save to localStorage wfm_prompt_ai_settings (independent of AI TOOL tab)
- Prompt tab: replace Python proxy (/api/wfm/ollama/*) with direct browser-to-backend
  calls; supports Ollama (/api/chat) and LM Studio (/v1/chat/completions);
  image attachments auto-converted to correct format per backend
- Auto-refresh model list when backend changes: sendMessage() detects mismatch
  between current backend setting and what was used to populate the dropdown,
  then re-fetches before sending to avoid stale model name errors
- i18n (EN/JA/ZH): ollamaSettings, ollamaUrl, saveOllama, ollamaSaved,
  helpPrompt1, helpSettings5, helpTrouble2 updated for dual-backend support

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-06-21 18:17:12 +09:00
ketle-manandClaude Sonnet 4.6 2b84c69ef9 feat: group stale-entry auto-cleanup + Gallery Shift+click range select (v0.3.45)
- Models tab: scan valid model files on group load, remove stale entries;
  move_models() also updates group membership for moved models
- Gallery tab (folder view): cleanup stale metadata entries after each
  folder scan, synced with 60s TTL + folder-mtime cache
- Gallery tab (group list): list_images_in_group() filters non-existent
  paths and removes them from the group in a single write
- Gallery tab: Shift+click range-selects from the last anchor item;
  works in both thumbnail and table views; anchor resets on folder
  change, reload, and Deselect All; help updated (EN/JA/ZH)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-06-21 17:16:45 +09:00
ketle-manandClaude Sonnet 4.6 7523892bc2 feat: Gallery tab performance + compare mode + bulk API + help improvements (v0.3.44)
Phase 2 — Performance:
- Server-side 256px JPEG thumbnail generation (Pillow, disk cache data/thumb_cache/)
- Infinite-scroll paging: 50 images/page with IntersectionObserver sentinel
- Cache TTL extended 30s → 60s

Phase 3 — Features:
- Bulk API endpoints: POST /wfm/gallery/bulk/favorite and /wfm/gallery/bulk/group
  replace N-parallel individual requests with single-request batch operations
- Image compare mode: Ctrl+click 2–4 images → Compare button → side-by-side lightbox
  (position:fixed close button avoids overflow:auto clipping)
- Prompt search: A1111 parameters text cached as prompt_cache on detail-panel open,
  included in list_images() text search alongside filename/tag/memo

Bulk bar UI cleanup:
- Dropdown placeholder: "Add to Group..." → "Select Group"
- Button: "Add" → "Add to Group"
- New "Remove from Group" button (uses POST /wfm/gallery/bulk/group action:remove)
- Button: "Delete" → "Delete File"

Help tab (Gallery page):
- helpGallery4/6/7 updated to reflect prompt search, compare, Remove from Group,
  Delete File; EN/JA/ZH all updated

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-06-21 14:07:49 +09:00
ketle-manandClaude Sonnet 4.6 d8fc1b62a3 feat: Send to Canvas direct load via window.opener + API-format DnD enabled (v0.3.43)
- node_sets_menu.js: register window.wfmReceiveWorkflow() so SPA can call
  app.handleFile() directly via window.opener; remove API-format grayout
  from W-tab items (all formats now draggable and double-clickable)
- workflow-tab.js: sendToCanvas() prefers window.opener.wfmReceiveWorkflow
  over localStorage fallback; remove API-format disabled state from side
  panel and detail modal Send to Canvas buttons
- gallery-tab.js: Copy & Send Canvas prefers window.opener; remove API-
  format disabled state from _updateCopyCanvasBtn
- i18n.js: add apiFormatCanvasNoOpener key (EN/JA/ZH); update helpGallery8
  and helpSidepanel17 to reflect new direct-send behaviour
- comfyui-client.js: queuePrompt() accepts extraData; generate() passes
  extra_pnginfo so SaveImage embeds workflow metadata in output PNGs

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-06-21 00:09:34 +09:00
ketle-manandClaude Sonnet 4.6 f2162844fb feat: Gallery Feeder mode + WFS_GalleryFeeder node + security fixes (v0.3.42)
- Add WFS_GalleryFeeder custom node (group_name/index/sort_mode/seed → IMAGE)
- Add Feeder tab Gallery mode ([Image Loop]/[Gallery] toggle, node selector,
  group picker, image grid with click-to-set-index, Run/Stop loop)
- Add gallery_feeder_extension.js: After Gen combo + Run/Stop widgets on
  WFS_GalleryFeeder node in ComfyUI canvas (serialize:false, waitForExecution)
- Add Gallery thumbnail F button to toggle __Feeder__ group membership (cyan overlay)
- Add __Feeder__ reserved group: rename/delete blocked (403 server + disabled UI);
  FC toolbar button clears members; ensure_group auto-creates on Feeder init
- Security: escapeHtml() applied to tag names, filenames, error messages in gallery-tab.js;
  single-quote escaping added to util.js escapeHtml
- Security: _check_path_allowed() added to save_image_meta, toggle_favorite,
  add_to_group, remove_from_group in gallery_service.py
- Security/bugfix: _init_allowed_root() in gallery_routes.py initializes _allowed_root
  at module load (settings.json → ComfyUI default); fixes serve_image 404 in
  Feeder Gallery mode and prevents list_folder_tree from overriding _allowed_root
- Bugfix: WFS_GalleryFeeder seed max 0x7FFFFFFF → 0xffffffffffffffff (KSampler parity)
- Update README, DEVLOG, pyproject.toml to v0.3.42

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-06-20 18:16:09 +09:00
ketle-manandClaude Sonnet 4.6 272de3d168 fix: ImpactWildcardEncode/Processor prompt not shown in Generate UI (v0.3.41)
- Add CLIPTextEncodeEditPlus BFS role propagation (text1/text2 inputs)
- Skip empty text_edit in CLIPTextEncodeEditPlus prompt_nodes to prevent
  blank textarea when upstream ImpactWildcard nodes supply the prompt
- Always overwrite wildcard_text from widgets[0] in convertUiToApi to
  guard against object_info widget-order differences between impact-pack versions
- Add static fallback mapping for ImpactWildcardProcessor/Encode

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-06-19 22:04:42 +09:00
ketle-manandClaude Sonnet 4.6 7181f4e20a feat: add Chat pane and Wildcard generation to AI TOOL tab (v0.3.40)
- AI TOOL tab: 3-pane layout expanded to 4-pane (Translation | Chat | TOOLS | Settings)
- Chat pane: multi-turn LLM conversation with history; Enter to send, Shift+Enter for newline; Clear resets history; Ollama /api/chat, LM Studio /v1/chat/completions
- TOOLS pane: new "Create wildcards" task — enter category name and count, generates plain-text entries one per line (no markdown, no numbering)
- Both features added to the Library side panel A tab (Chat sub-tab + wildcard dropdown option)
- i18n: aiStatusChatting / aiToastChatFailed / aiToastWcNoName added in EN/JA/ZH
- Help: AI TOOL tab card updated to 6 items; helpSidepanel16 updated in EN/JA/ZH

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-06-19 14:43:03 +09:00
ketle-manandClaude Sonnet 4.6 735e8ba876 feat: Send to Canvas button + Library title drag-to-canvas (v0.3.39)
- Workflow tab: replaced "Open in ComfyUI" with "Send to Canvas" (toolbar
  and detail modal); stores workflow JSON in localStorage for title-drag
- Gallery tab: renamed "Copy Workflow" to "Copy & Send Canvas"; copies to
  clipboard and stores for title-drag simultaneously
- Workflow Studio Library: panel title turns blue with green indicator when
  a pending workflow is stored; drag title onto canvas to load via
  app.loadGraphData(); title resets automatically after loading
- i18n: sendToCanvas / copyAndSendCanvas / workflowSentToCanvas (EN/JA/ZH)
- Help: helpWf6, helpGallery8 updated; helpSidepanel17 added (EN/JA/ZH)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-06-18 21:33:13 +09:00
ketle-manandClaude Sonnet 4.6 c5a2662bef feat: add Tagger tab + GenUI:P button + ZIT workflow fix (v0.3.38)
### Tagger tab (new)
- WD Tagger (ONNX/NCHW/NHWC), SwinV2, DeepDanbooru (.h5/TF optional), Ollama VLM
- Single subtab: drag & drop / upload, 5 output targets (GenUI:P / Prompt / Gallery / File / DB)
- Batch subtab: folder processing, Save DB / Write to File / Write .txt output options
- DB subtab: searchable SQLite, row edit, CSV export
- Backend: tagger_service.py, tagger_db_service.py, tagger_routes.py (17 endpoints)
- Security: model name validation, extension allowlist, path traversal fix in gallery_service

### Tagger single — GenUI:P button
- Appends generated tags to GenerateUI positive prompt and applies to loaded workflow immediately

### GenerateUI — ZIT/Lumina2 workflow prompt fix
- Remove ConditioningZeroOut from COND_PASSTHROUGH; shared CLIPTextEncode now correctly
  gets role "positive" instead of "unknown" in ZIT workflows
- workflow_analyzer: add lumina2 → Z-IMAGE to _CLIP_TYPE_TO_MODEL

### Gallery detail panel
- Split tab row (Info/JSON/Groups) and action row (Metadata/Load GenUI/Tagger) to separate rows
- Add Tagger button (purple) to open selected image in Tagger tab
- Fix Save to Gallery: tags now stored as array (was string, broke forEach on refresh)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-06-15 15:04:42 +09:00
ketle-manandClaude Sonnet 4.6 127d85d913 feat: Select All button for Models & Gallery bulk bars, Gallery bulk bar i18n (v0.3.37)
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-06-15 09:22:04 +09:00
ketle-manandClaude Fable 5 85ce2e05df fix: review fixes (Save safety, help i18n), util.js refactor, toast i18n, README refresh (v0.3.36)
- GenerateUI Save: overwrite confirmation with UI-format warning, Raw JSON
  sync, HTML-injection-safe filename input, double-submit guard
- Help i18n: v0.3.35 help updates were overwritten by stale i18n strings;
  synced helpGen2/helpModels2/helpGallery8/10 in 3 languages, registered
  missing helpIdMap entries, added helpGallery12/13
- Toast i18n: ~115 hard-coded English toasts replaced with t() (+~60 shared
  keys in EN/JA/ZH); fixed undefined Settings keys (textSize*/jsonColor*)
- Refactor: new shared util.js (escapeHtml unified across 5 files,
  readJsonStorage/getSettings replace 15 localStorage parses); sortModels
  precomputes sort keys; Gallery action buttons split from tab-button class
  (all !important CSS removed)
- README: intro rewritten around 3 pillars (Management / GenerateUI /
  Library side panel); new screenshots (LoRA Stack, Batch, Multi-select);
  WS Library image updated; pyproject description aligned

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-06-10 21:37:06 +09:00
44 changed files with 7103 additions and 663 deletions
+825
View File
@@ -1,5 +1,830 @@
# DEVLOG - ComfyUI-Workflow-Studio
## 2026-06-24: GenUI ModelでLoRA適用後、Modelサブタブ再表示時に値がリセットされるバグ修正
**変更ファイル**: `static/js/comfyui-editor.js`
### 問題
ModelsタブのGenUI ModelボタンでLoRAをGenerate UIタブのLORA Singleに適用後、別サブタブ(Prompt/Image/Settings等)に移動してModelサブタブに戻ると、LoRAセレクトが元のワークフロー読み込み時の値にリセットされていた。
### 原因
`renderLoraPane()`はModelサブタブに切り替えるたびに`el.innerHTML`を完全再構築する(Stackグループ変更を反映するため)。その際に`currentVal`を`analysis.lora_nodes[0]?.lora_name`(ワークフロー読み込み時点の`currentAnalysis`の値)から取得していた。`applyToGenUI()`は`currentWorkflow`を更新するが`currentAnalysis`は更新しないため、再描画時に古い値が使われて元に戻っていた。syntax表示とtrigger wordsも`innerHTML`リセットで消えていた。
### 修正
- **currentVal取得ロジックを修正**: `analysis.lora_nodes[0]?.lora_name`の代わりに`comfyUI.currentWorkflow`から直接読み取る。標準LoraLoaderは`inputs.lora_name`、LoraManagerは`inputs.loras.__value__[0].name`からstemを取得してフルパスに復元。
- **syntax/trigger wordsを再描画をまたいで保持**: `el.innerHTML`設定前に`wfm-lora-single-syntax`と`wfm-lora-single-triggers`の現在値を保存し、HTML再構築後に復元。
---
## 2026-06-24: v0.3.51 — Embedding GenUI PP/NP対応 + GenerateUIプロンプトタブEmbeddingセレクタ追加
**変更ファイル**: `templates/index.html`, `static/js/comfyui-editor.js`, `static/js/models-tab.js`
### 変更内容
**ModelsタブEmbeddingタイプにGenUI PP / GenUI NPボタンを追加**
- `templates/index.html`: サイドパネルナビに `#wfm-side-genui-np-btn` を追加(Embeddingタイプ時のNP用ボタン)
- `models-tab.js`:
- `applyEmbeddingToPrompt(modelName, promptType)` 関数を追加。モデルstemから `(embedding:Stem:1.0)` を生成し `comfyEditor.appendEmbeddingToPrompt()` を呼ぶ
- サイドパネルナビ: Embeddingタイプ時は "GenUI PP" / "GenUI NP" を表示、他タイプは従来の "GenUI Model" のみ表示
- `renderSideInfo()`: Embeddingタイプ時は PP/NP ボタンを表示
- `openDetailModal()`: Embeddingタイプ時は PP/NP ボタンを表示
- `closeSidePanel()`: ナビボタンをすべて非表示にする(タイプ切替時の残留防止)
**GenerateUI PrompタブにEmbeddingセレクタ追加**
- `comfyui-editor.js`:
- `models.embeddings: []` を追加、`loadModelLists()` に `fetchEmbeddings()` を追加
- `_lastPromptFocus` モジュール変数を追加(最後にフォーカスしたpromptテキストエリアのIDと選択位置を保持)
- `renderPromptTab()`: PromptタブのPositive/Negativeの下にEmbeddingsセクションを追加
- Filter入力 + Selectドロップダウン(埋め込みモデル一覧)+ Weight入力(デフォルト1.0) + Pasteボタン
- Pasteボタン: 最後にフォーカスしたテキストエリアのカーソル位置に `(embedding:Stem:weight)` を挿入
- テキストエリアにblur/click/keyupリスナーを追加してカーソル位置を追跡
- `appendEmbeddingToPrompt(syntax, promptType)` メソッドを追加: ワークフローの対応ノードとテキストエリア両方を更新してプロンプト末尾に追加
---
## 2026-06-24: v0.3.51 — GenerateUIタブ Hypernetwork対応 + ModelsタブGenUI Modelボタン追加
**変更ファイル**: `static/js/comfyui-workflow.js`, `static/js/comfyui-editor.js`, `static/js/models-tab.js`
### 変更内容
**GenerateUI → Model タブに Hypernetwork セクション追加**
- `comfyui-workflow.js` `analyzeWorkflow()`: `hypernetwork_nodes: []` を追加。`HypernetworkLoader` ノードを検出し `hypernetwork_name` / `strength` を収集。
- `comfyui-editor.js`:
- `models.hypernetworks: []` を追加、`loadModelLists()` に `fetchHypernetworks()` を追加
- `renderModelTab()` の `sections` 末尾に Hypernetwork を追加。`extras` プロパティで `strength`(数値フィールド)を表示・Apply 時に反映
- `models-tab.js` `GENUI_TYPE_MAP`: `hypernetwork: { key: "hypernetworks", inputKey: "hypernetwork_name" }` を追加。これにより詳細パネル・モーダルの GenUI Model ボタンが Hypernetwork タイプでも有効になる。
---
## 2026-06-24: v0.3.51 — Hypernetwork/Embeddingモデル未表示バグ修正
**変更ファイル**: `static/js/comfyui-client.js`
### 原因
`_fetchModelList` が ComfyUI V3ノード(`IO.ComfyNode`)の `object_info` レスポンス形式に未対応だった。
- V1形式: `[["model1.pt", ...], {}]` → 配列チェックで対応済み
- V2形式: `["COMBO", {"values": [...]}]` → `values`キーで対応済み
- **V3形式**: `["COMBO", {"options": [...]}]` → **未対応** ← `HypernetworkLoader` がこの形式
`HypernetworkLoader` は V3 `IO.ComfyNode` で実装されており、`options` キーを使う。`_fetchModelList` が `values` しか見ていなかったため、常に空配列を返してHypernetworkモデルが一切表示されなかった。
### 修正内容
**`comfyui-client.js`**
- `_fetchModelList`: V3形式 `inputDef[1]?.options` の取得ケースを追加
- `fetchEmbeddings`: ComfyUIの `/embeddings` エンドポイントへの直接アクセスをやめ、WFSバックエンドAPI `/api/wfm/models/files?type=embedding` を使うよう変更(SPAのURLによっては `/embeddings` がHTMLを返す問題があったため)
**`py/services/models_service.py`**
- `_MODEL_EXTENSIONS` 定数を追加(`.safetensors`, `.ckpt`, `.pt`, `.pth`, `.bin`, `.gguf`, `.pt2`)
- `list_model_files(model_type)` メソッドを追加: モデルファイルのみをフィルタリングしてソート済みリストを返す
**`py/routes/models_routes.py`**
- `GET /api/wfm/models/files?type=<type>` エンドポイントを追加
---
## 2026-06-24: v0.3.51 — ModelsタブサイドパネルにGenUI Modelボタン追加
**変更ファイル**: `templates/index.html`, `static/js/models-tab.js`
### 変更内容
モデルタブのサイドパネル(詳細パネル)のタブナビゲーション(Info / Group / CivitAI)に、CivitAIタブの右横へ **GenUI Model** ボタンを追加した。
- `index.html`: `wfm-side-tab-nav` 内にボタン(`#wfm-side-genui-nav-btn`)を追加。`margin-left:auto` で右端寄せ、初期状態は非表示。
- `models-tab.js` `showSidePanel()`: モデル選択時に `GENUI_TYPE_MAP` で対応タイプ(checkpoint / lora / vae 等)なら表示、非対応なら非表示に切り替え。ボタンテキストとtitleもi18nで設定。
- `models-tab.js` init: ボタンクリックで `applyToGenUI(selectedModel, activeModelType)` を呼び出すイベントを追加。
モーダル内の既存 GenUI Model ボタン(`#wfm-modal-genui-model`)はそのまま維持。
---
## 2026-06-22: v0.3.50 — ギャラリータブ プロンプト検索負荷改善(バックグラウンドインデックス)
**変更ファイル**: `py/services/gallery_service.py`, `py/routes/gallery_routes.py`
### 問題
v0.3.49で導入したプロンプト検索の未キャッシュ画像オンデマンド読み込みが、大量の画像フォルダで深刻な負荷問題を引き起こしていた。
- `list_images()`が`asyncio.to_thread()`なしでaiohttpイベントループ上で同期実行されていたため、全未キャッシュ画像のファイルI/O+DB書き込みがComfyUIのイベントループをブロックし、ハングアップが発生していた。
### 修正内容
**`gallery_routes.py`**
- `list_images`ルートで`_service.list_images()`を`asyncio.to_thread()`でスレッドプールに投げるよう変更(イベントループブロック解消)
- 検索なしのフォルダロード時に`_service.start_background_index()`を呼び出してバックグラウンドインデックスを自動起動
**`gallery_service.py`**
- `import threading`を追加
- `__init__`にバックグラウンドインデックス用キャンセルイベント(`_bg_cancel`)を追加
- `list_images()`からオンデマンド読み込みを完全に削除(`prompt_cache`が空の場合の読み込み処理を除去)
- `start_background_index(folder_path)`メソッドを追加:前回のスレッドをキャンセルして新しいdaemonスレッドを起動
- `_bg_index_folder(folder_path, cancel)`メソッドを追加:
- 未キャッシュ画像のみを対象(`prompt_cache`が存在する画像はスキップ)
- 10枚処理するたびにバッチDB保存 + 50msスリープでメインスレッドへの影響を最小化
- キャンセルイベントで即座に中断可能(フォルダ切替時など)
### 新しい動作フロー
```
フォルダ選択(検索なし)
→ asyncio.to_thread で list_images() をスレッド実行(ノンブロッキング)
→ 画像一覧を即返却
→ バックグラウンドスレッドが自動起動
→ 未キャッシュ画像を10枚ずつ処理、50msスリープを挟んで低負荷で順次インデックス
→ インデックス完了後の検索でA1111画像等もヒットするようになる
プロンプト検索
→ asyncio.to_thread で list_images() をスレッド実行(ノンブロッキング)
→ キャッシュ済み画像のみ検索(重いI/O処理なし)
```
---
## 2026-06-22: v0.3.49 — 生成UIタブ A1111風ワイルドカード展開・ギャラリータブ バグ修正2件
**変更ファイル**: `static/js/generate-tab.js`, `static/js/app.js`, `py/services/gallery_service.py`, `static/js/i18n.js`, `templates/index.html`
### 生成UIタブ — A1111風SPAサイドワイルドカード展開
ImpactWildcardEncode/Processor以外のノード(CLIPTextEncodeなど)のテキスト入力に`__name__`構文が含まれる場合、ComfyUIへの送信前にSPA側でワイルドカードを展開する機能を追加。
- `generate-tab.js` に `_fetchWildcardLines()`, `_expandWildcardText()`, `_expandWildcardsInWorkflow()` を追加
- `_coreGenerate()` 内の `comfyUI.generate()` 呼び出し前にワイルドカード展開を実行
- ワイルドカードファイルは既存の `/api/wfm/wildcards/content` API経由で取得(WFS wildcard フォルダ参照)
- ファイル内容はセッション中キャッシュ(`_wcLineCache`);ランダム選択は毎回独立して実行
- ネスト展開対応(最大5パス);見つからないワイルドカードはそのまま通過
- ImpactWildcardEncode/ProcessorノードはスキップしてComfyUIサーバー側(Impact Pack)に委ねる
- 単体生成・バッチ生成どちらも `_coreGenerate()` を経由するため両方で機能する
- ヘルプ更新(EN/JA/ZH): `helpGen16` を追加(`index.html`, `app.js`, `i18n.js` 3言語)
### ギャラリータブ — エクスポートボタンのラベル欠落を修正
`app.js` の `updateUITexts()` に `wfm-gallery-bulk-export` ボタンへの `textContent` 設定が抜けていた。`galleryBulkMove` と `galleryBulkDelete` の間に `galleryBulkExport` の設定を追加。
### ギャラリータブ — プロンプト検索で未キャッシュ画像にヒットしない問題を修正
`prompt_cache` は詳細パネルで一度開いた画像にのみ構築されていた。A1111など外部ツールで生成した画像をWFS外から追加した場合、一度も開かれていない画像はプロンプト検索にヒットしなかった。
- `gallery_service.py` の `list_images()` で検索実行時、`prompt_cache` が空の画像をその場でメタデータ読み込み(`_read_png_metadata` / `_read_jpeg_metadata`)してキャッシュに保存してから検索対象に含める
- A1111形式PNG(tEXtチャンク `parameters` キー)も正しく検索対象になる
- 初回検索時のみ読み込みが発生;以降はキャッシュから即時検索
---
## 2026-06-22: v0.3.48 — ギャラリータブ 画像ダウンロード・一括エクスポート機能追加
**変更ファイル**: `templates/index.html`, `static/js/gallery-tab.js`, `static/css/gallery-tab.css`, `py/routes/gallery_routes.py`, `static/js/i18n.js`
### 詳細パネルの画像プレビューにダウンロード機能を追加
- プレビュー画像にマウスホバーでダウンロードアイコン(⬇)をオーバーレイ表示
- クリックで単一画像をダウンロード(ファイル名はオリジナルを保持)
- CSS: `.wfm-gallery-preview-wrapper`, `.wfm-gallery-preview-overlay`, `.wfm-gallery-download-btn` を追加
### 複数選択バーに「エクスポート」ボタンを追加
- 複数選択した画像をZIPファイルにしてダウンロード可能
- ファイル名: `gallery_export_<タイムスタンプ>.zip`
- Backend: `POST /wfm/gallery/images/export-zip` エンドポイント実装
- リクエスト: `{ "paths": [...] }` (画像パスリスト)
- レスポンス: ZIP ファイルをバイナリで返送
- セキュリティ: `_check_path_allowed()` でパストラバーサル防止
### i18n対応
- 英語: "Export" / "Download started" / "Export completed. ZIP file is downloading."
- 日本語: "エクスポート" / "ダウンロード開始" / "エクスポート完了。ZIPファイルをダウンロード中です。"
- 中国語: "导出" / "下载开始" / "导出完成。正在下载 ZIP 文件。"
### ヘルプテキスト更新
- ヘルプ wfm-help-gallery-6: 複数選択バー説明に "Export" を追加
- ヘルプ wfm-help-gallery-7: 詳細パネル説明にダウンロードアイコンについての記述を追加
---
## 2026-06-22: v0.3.47 — モデルタブ ファイル移動後グループ状態修正
**変更ファイル**: `static/js/models-tab.js`
### モデル移動後のグループ状態不整合を修正
`bulkMoveModels` でモデルをサブディレクトリ間移動した際、Python側(`move_models`)はグループメンバーの名前を `from → to` に更新していたが、JS の `state.modelGroups` が更新されていなかった。
このため移動直後にグループフィルターで絞り込むと、移動したモデルが消えてしまう(旧名で参照されるため一致しなくなる)問題があった。
- `data.moved.forEach` ループ内で `state.modelGroups` の各グループメンバーを `from → to` でリネーム
- サーバーが `_groups` を更新する処理と対称的なクライアント側更新
- `state.modelGroups` と `state.allModelGroups[type]` は同一オブジェクト参照のためインプレース更新で両方に反映される
- Generate タブ Batch の `_batchGroupState.groups` はサーバーから毎回取得するため影響なし
---
## 2026-06-21: v0.3.46 — プロンプトタブ AI Assistant LM Studio対応・設定タブ AI Assistant設定に変更
**変更ファイル**: `static/js/settings-tab.js`, `static/js/prompt-tab.js`, `static/js/i18n.js`, `templates/index.html`
### 設定タブ「AI Assistant設定(プロンプトタブ)」
設定タブの「Ollama設定(プロンプトタブ)」セクションを AI TOOL タブの SETTINGS ペインと同等の内容に変更。
- セクション名を **「AI Assistant設定(プロンプトタブ)」** に変更
- **バックエンド選択ラジオ(Ollama / LM Studio)** を追加
- **API URL 入力** — バックエンド切替時にプレースホルダーが自動変更(Ollama: `http://localhost:11434`、LM Studio: `http://localhost:1234`)
- **モデル選択 + Refresh** — 選択中のバックエンドへ直接接続してモデル一覧を取得
- **Test ボタン** — バックエンドへ直接接続テスト
- **Save ボタン** — 設定を localStorage `wfm_prompt_ai_settings` に保存(サーバーAPI不要)
- AI TOOL タブの設定(`wfm_ai_settings`)とは独立した設定キーを使用
### プロンプトタブ AI Assistant LM Studio対応
Python プロキシルート(`/api/wfm/ollama/*`)依存を廃止し、AI TOOL タブと同方式のブラウザから直接バックエンドAPIを呼び出す実装に変更。
- Ollama: `{url}/api/tags`(モデル一覧)、`{url}/api/chat`(チャット)
- LM Studio: `{url}/v1/models`(モデル一覧)、`{url}/v1/chat/completions`(チャット)
- 画像添付(ビジョンモデル)も両バックエンド対応 — Ollama形式(`images`フィールド)を LM Studio形式(`content`配列の`image_url`)に自動変換
- 設定タブで保存したモデルを初期選択として表示
- ウェルカムメッセージの "AI Assistant (Ollama)" 表記を削除
### バックエンド変更時の自動モデル再取得
設定タブでバックエンドを変更した後にプロンプトタブですぐ送信しようとすると、ドロップダウンに旧バックエンドのモデル名が残ったまま送信されモデル未認識エラーが発生する問題を修正。
- `_promptAiBackendForModels` 変数にモデル一覧取得時のバックエンドを記録
- `sendMessage()` の冒頭で現在設定と比較し、バックエンドが変わっていた場合は自動でモデル一覧をリフレッシュしてから送信
- モデル一覧表示に `[ollama]` / `[lmstudio]` のバックエンド名を付記
### i18n 更新(EN/JA/ZH)
- `ollamaSettings` → "AI Assistant Settings (Prompt Tab)"
- `ollamaUrl` → "API URL"(汎用)
- `saveOllama` → "Save AI Assistant Settings"
- `ollamaSaved` → "AI Assistant settings saved"
- `helpPrompt1` — "Ollama" → "Ollama / LM Studio"・設定場所の説明を追記
- `helpSettings5` — バックエンド選択・URL・モデル・接続テストの説明に更新
- `helpTrouble2` — "Ollamaに接続できない" → "AIアシスタントに接続できない(Ollama/LM Studio両対応)"
---
## 2026-06-21: v0.3.45 — グループ孤立エントリ自動クリーンアップ・Galleryタブ Shift+クリック範囲選択
**変更ファイル**: `py/services/models_service.py`, `py/services/gallery_service.py`, `py/services/gallery_metadata.py`, `static/js/gallery-tab.js`, `static/js/i18n.js`
### グループ孤立エントリ自動クリーンアップ
ファイルをアプリ外(OS)で移動・削除した際にグループデータに残る孤立エントリを自動的に除去する仕組みを追加。
#### Modelsタブ
- `models_service.py` に `_scan_model_names(model_type)` を追加 — `_get_model_dirs` の全ディレクトリを `rglob` で走査し、有効なモデルファイル名のセットを返す(`.disabled` サフィックスを除いた相対パス)
- `get_model_groups(model_type)` に自動クリーンアップを追加 — タイプ指定時にファイルスキャンを実行し、存在しないモデル名をグループから除去;変更があった場合のみ保存
- `move_models()` でグループエントリを即時更新 — アプリ内での移動時に `renames` リストを収集し、`_groups[model_type]` 内の旧パスを新パスに一括書き換え
#### Galleryタブ(フォルダ表示)
- `gallery_metadata.py` に `cleanup_stale_images(folder_path, existing_paths)` を追加 — `folder_path` 配下のメタデータキーのうち `existing_paths` に含まれないものを削除して保存
- `gallery_service.py` の `list_images()` で `_scan_folder` 直後にクリーンアップを呼ぶ — スキャン結果の `abs_path` セットを渡すため、60秒 TTL キャッシュとフォルダ mtime 変化検知に連動して自動実行
#### Galleryタブ(グループ画像一覧)
- `gallery_metadata.py` に `remove_stale_paths_from_group(group_name, stale_paths)` を追加 — 孤立パスをグループから一括削除し1回の保存で完結
- `gallery_service.py` の `list_images_in_group()` で `Path.is_file()` チェックを追加 — FeederタブのGalleryモード(`GET /wfm/gallery/groups/{name}/images`)呼び出し時に孤立パスをグループから自動除去して既存ファイルのみ返す
#### 各タブのクリーンアップトリガー
| タブ | トリガー | 対象 |
|---|---|---|
| Modelsタブ | タブ切替・モデルタイプ変更時 | 全グループから存在しないモデル名を削除 |
| Modelsタブ(アプリ内移動) | `move_models` API 呼び出し時 | グループ内パスを即時更新 |
| Galleryタブ(フォルダUI) | フォルダ表示時(mtime 変化 or 60秒後) | フォルダ内の孤立メタデータエントリを削除 |
| Galleryタブ(Feederモード) | グループ画像一覧取得時 | グループから孤立パスを削除 |
### GalleryタブのShift+クリック範囲選択
- `state` に `lastSelectionIndex: -1` を追加(Shift 選択のアンカーインデックス)
- `createThumbCard()` / `createTable()` に `data-path` 属性を追加
- `_applySelectionToDOM()` ヘルパーを追加 — `state.selectedImages` を元に描画済み要素の `multi-selected` クラスを一括同期;ページング未描画の要素はスクロールで描画される際に `createThumbCard` が自動で反映
- サムネイルビュー・テーブルビューのクリックハンドラを更新:
- Shift+クリック: アンカーから現在位置まで `state.images` のインデックス範囲で一括追加
- Ctrl+クリック: 個別トグル(既存)+アンカー更新
- 通常クリック: 詳細表示(既存)+アンカー更新
- `lastSelectionIndex` リセット箇所: フォルダ切替時・`loadImages()` 完了時(ソート/フィルタ変更後も含む)・一括解除ボタン押下時
- `i18n.js` の `helpGallery6`(EN/JA/ZH)を更新して Shift+クリック範囲選択を追記
---
## 2026-06-21: v0.3.44 — Galleryタブ高速化・比較モード・バルク強化・バルクバーUI整理
**変更ファイル**: `py/services/gallery_service.py`, `py/routes/gallery_routes.py`, `static/js/gallery-tab.js`, `static/css/gallery-tab.css`, `templates/index.html`, `static/js/app.js`, `static/js/i18n.js`
### フェーズ2-A: サーバーサイドサムネイル生成
- `gallery_service.py` に `serve_thumbnail(path, width=256)` を追加
- Pillow で画像を 256px JPEG に縮小し `data/thumb_cache/` にキャッシュ(キー: `md5(path:mtime:width)`)
- GIF はアニメーション保持のため元ファイルをそのまま返す;Pillow 未インストール時は元ファイルにフォールバック
- `GET /wfm/gallery/image/thumb?path=...&w=256` エンドポイントを `gallery_routes.py` に追加(Cache-Control 24時間)
- `gallery-tab.js` のサムネイルビュー・テーブルビューを `/image/serve` → `/image/thumb` に切り替え;ライトボックス・詳細プレビューは引き続き元画像を使用
### フェーズ2-B: 無限スクロールページング
- モジュールレベル変数 `PAGE_SIZE=50`, `_renderedCount`, `_scrollObserver` を追加
- `renderImages()` をリファクタリング: 初回は50枚のみ DOM に追加し、末尾にセンチネル div を配置
- `IntersectionObserver`(rootMargin 300px)がセンチネルを検出するたびに次の50枚を追加
- 全枚数を描画し終えたらオブザーバーを切断してセンチネルを削除
- `renderImages()` 呼び出し(フォルダ切替・フィルタ変更・ソート変更)のたびに自動リセット
### フェーズ3-A: バルクAPIエンドポイント
- `gallery_service.py` に `bulk_set_favorite(paths, value)` と `bulk_group_op(paths, group, action)` を追加
- `POST /wfm/gallery/bulk/favorite`, `POST /wfm/gallery/bulk/group` を `gallery_routes.py` に追加
- フロントエンドの `bulkSetFavorite()` / `bulkAddToGroup()` を N並列個別リクエスト → 単一バルクリクエストに変更
### フェーズ3-B: 画像比較モード
- Ctrl+クリックで2〜4枚選択すると Bulk Bar に「比較」ボタンが出現
- `openCompare(paths)` 関数を追加: `--compare-cols` CSS カスタムプロパティで列数を動的制御した CSS Grid サイドバイサイドライトボックス
- 閉じるボタンは `position:fixed; top:16px; right:16px` で配置し `overflow:auto` コンテナによるクリッピングを防止
- i18n: `galleryBulkCompare`(EN/JA/ZH)追加
### フェーズ3-C: プロンプト全文検索
- `get_image_metadata()` 実行時に PNG/JPEG 埋め込みテキスト(`workflow` キーを除く文字列フィールド)を連結して `metadata.json` の `prompt_cache` に保存
- `list_images()` の検索フィルタに `prompt_cache` を追加(ファイル名・メモ・タグに加えて)
- 検索プレースホルダを「名前・タグ・プロンプトで検索...」に更新(EN/JA/ZH)
- ヘルプ `helpGallery4` を更新して prompt 検索対応を明記
### バルクバーUI整理
- ドロップダウンプレースホルダ「グループに追加...」→「グループ選択」
- 「追加」ボタン → 「グループに追加」
- 「グループから削除」ボタンを「グループに追加」の右隣に新規追加
- `bulkRemoveFromGroup()` 関数を追加(`POST /wfm/gallery/bulk/group` の `action:"remove"` を使用)
- `removedNImagesFromGroup` i18n キー追加(EN/JA/ZH)
- 「削除」ボタン → 「ファイル削除」(グループ削除との混同を防ぐ)
- ヘルプ `helpGallery6`, `helpGallery7` を更新
---
## 2026-06-21: ヘルプタブ改善 — Gallery mode 多言語対応・フォント拡大・検索機能追加
**変更ファイル**: `templates/index.html`, `static/js/app.js`, `static/js/i18n.js`, `static/css/main.css`
### Gallery mode の多言語対応
Feeder サブタブの Gallery mode セクション(h4 見出し・説明文・リスト6項目)が英語のハードコードのままだったのを i18n 対応に変更。
**修正(`templates/index.html`)**
- `<h4 id="wfm-help-feeder-imgloop-title">` と `<p id="wfm-help-feeder-imgloop-desc">` を追加(Image Loop mode 見出し・説明文を i18n 化)
- `<h4 id="wfm-help-feeder-gal-title">` と `<p id="wfm-help-feeder-gal-desc">` を追加
- Gallery mode 6項目に `id="wfm-help-feeder-gal-1"` 〜 `id="wfm-help-feeder-gal-6"` を付与
**修正(`static/js/app.js`)**
- `helpIdMap` に `helpFeederImgloopTitle` / `helpFeederImgloopDesc` / `helpFeederGalTitle` / `helpFeederGalDesc` / `helpFeederGal1`〜`helpFeederGal6` を追加
**修正(`static/js/i18n.js`)**
- `helpFeederDesc`: 「2モード切り替え」の説明に EN/JA/ZH で更新
- `helpFeederImgloopTitle` / `helpFeederImgloopDesc`: Image Loop mode 見出し・説明を EN/JA/ZH で追加
- `helpFeederGalTitle` / `helpFeederGalDesc` / `helpFeederGal1`〜`helpFeederGal6`: Gallery mode 全項目を EN/JA/ZH で追加
- `helpSearchPlaceholder`: 検索ボックスのプレースホルダーを EN/JA/ZH で追加
### ヘルプ全体フォントを 1.5 倍に変更
**修正(`static/css/main.css`)**
- `.wfm-help-nav-item`: 12px → 18px
- `.wfm-help-sidebar` 幅: 170px → 220px(フォント拡大に伴う調整)
- `.wfm-help-card h3`: 14px → 21px
- `.wfm-help-card h4`: 18px(新規追加)
- `.wfm-help-card p`: 20px(新規追加)
- `.wfm-help-card li`: 13px → 20px
- `.wfm-help-link-title`: 15px → 23px
- `.wfm-help-link-desc`: 12px → 18px
- `.wfm-help-thanks`: 13px → 20px
- `.wfm-help-support-card > p`: 14px → 21px
### ヘルプタブに検索機能を追加
**修正(`templates/index.html`)**
- サイドバーの `.wfm-help-nav` 上部に `<input id="wfm-help-search">` を追加
**修正(`static/js/app.js`)**
- `_onHelpSearch()`: 入力テキストで全ヘルプページの `textContent` を検索。マッチしないナビゲーションボタンは `search-hidden` クラスで非表示。マッチするページが1つでもあれば最初にマッチしたページを自動表示
**修正(`static/css/main.css`)**
- `.wfm-help-search-wrap` / `.wfm-help-search` / `.wfm-help-search:focus` / `.wfm-help-nav-item.search-hidden` のスタイルを追加
---
## 2026-06-21: Send to Canvas — window.opener経由のキャンバス直接ロード対応
**背景**: SPAは `window.open(url, "_blank")` でComfyUIとは別タブとして開かれる。同一オリジンの別タブでは `window.opener` 経由でComfyUIウィンドウのJavaScriptに直接アクセスできる。従来の「タイトルドラッグ(Send to Canvas)」はSPAウィンドウ→ComfyUIウィンドウのクロスウィンドウDnDだったが、`dragover` イベント中はブラウザのセキュリティ制限でカスタムMIMEタイプが `DataTransfer.types` に含まれず `e.preventDefault()` が呼ばれないため `drop` イベントがキャンバスに届かなかった(Wタブ内DnDは同一ウィンドウなので `app.handleFile` が機能していた)。
**修正(`web/comfyui/node_sets_menu.js`)**
- `window.wfmReceiveWorkflow(data)` グローバル関数を追加: `loadDataOnCanvas(data)` → `app.handleFile(file)` 経由でワークフローをキャンバスにロード(UI/API形式どちらも対応)
- WタブのAPI形式アイテムのグレーアウト(`wfm-nlp-item--disabled` クラス・`draggable=false`・title属性)を削除 → 全フォーマットでDnD・ダブルクリック対応
**修正(`static/js/workflow-tab.js`)**
- `sendToCanvas()`: `window.opener.wfmReceiveWorkflow` が存在する場合は直接呼び出す(UI/API形式両対応)。存在しない場合(ブックマーク等から直接開いた場合)はlocalStorageフォールバック(UI形式のみ、API形式はエラートーストで案内)
- サイドパネル・詳細モーダルのSend to CanvasボタンのAPI形式 `disabled` 属性を削除
**修正(`static/js/gallery-tab.js`)**
- `_updateCopyCanvasBtn()`: API形式による `disabled` 制限を削除(workflow存在チェックのみ)
- Copy & Send Canvasクリックハンドラ: `window.opener.wfmReceiveWorkflow` 優先に変更(フォールバックはlocalStorage + タイトルドラッグ)
**修正(`static/js/i18n.js`)**
- `apiFormatCanvasNoOpener` キーを追加(EN/JA/ZH): window.openerなしでAPI形式を送ろうとした場合のエラーガイドメッセージ
- `helpGallery8` / `helpSidepanel17` を新しい動作(直接送信・フォールバック説明)に合わせて更新(3言語)
---
## 2026-06-20: API形式ワークフローのキャンバス読み込み修正・画像メタデータ埋め込み修正
### API形式ワークフローをキャンバスへドラッグすると空になる問題を修正
**症状**: Workflowタブ「Send to Canvas」やLibraryからのDnDで、API形式(`_api.json`)のワークフローをComfyUIキャンバスへドロップすると空のグラフになる。ファイルエクスプローラーからのドロップは正常。
**原因**: `app.loadGraphData()` はUIフォーマット(`{nodes:[...], links:[...]}`)を期待するが、API形式(`{nodeId: {class_type, inputs}}`)が渡されていた。
**修正(`web/comfyui/node_sets_menu.js`)**
- `isApiWorkflowFormat(data)`: API形式かUI形式かを判定するヘルパーを追加
- `convertApiToUiWorkflow(api)`: API形式→UI形式に変換するヘルパーを追加(ノードはグリッド自動配置、リンクタイプは `"*"`、`last_node_id`/`last_link_id` を正しく設定)
- `loadWorkflowOnCanvas`: `fetchWorkflowRaw` 後にAPI形式を検出・変換してから `app.loadGraphData()` を呼ぶよう修正
- `pendingRaw` ドロップハンドラ: Send to Canvas経由のタイトルDnD時にも同様の変換を挿入
**修正(`static/js/workflow-tab.js`)**
- `sendToCanvas()`: `comfyWorkflow.detectFormat` でフォーマット判定し、API形式なら `comfyWorkflow.convertApiToUi()` でUI形式に変換してからlocalStorageに保存
**修正(`static/js/gallery-tab.js`)**
- `comfyWorkflow` を `comfyui-workflow.js` からimport追加
- 「Copy & Send Canvas」ハンドラ: クリップボードにはオリジナルJSON(API形式のまま)をコピーしつつ、localStorage保存前にAPI→UI変換を適用
---
### 生成UIタブから生成した画像にワークフローメタデータが含まれない問題を修正
**症状**: 生成UIタブ(およびFeederタブ)から実行した画像生成で、SaveImageノードが保存するPNGに `workflow` テキストチャンクが埋め込まれず、GalleryタブでのWorkflow表示や他ツールでのメタデータ読み込みができない。
**原因**: `comfyui-client.js` の `queuePrompt()` が ComfyUI の `/prompt` エンドポイントに `extra_data` を渡していなかった。ComfyUIのSaveImageノードは `extra_data.extra_pnginfo.workflow` を受け取ってPNGの `workflow` テキストチャンクに埋め込むが、これが未設定のため埋め込みが行われなかった。
**修正(`static/js/comfyui-client.js`)**
- `queuePrompt(workflow, extraData = null)`: `extraData` 引数を追加。存在する場合に `body.extra_data` として `/prompt` リクエストに含める
- `generate()`: `queuePrompt` 呼び出し時に `{ extra_pnginfo: { workflow } }` を渡し、SaveImageノードがワークフロー(API形式)をPNGメタデータとして埋め込むよう修正
---
## 2026-06-20: セキュリティ修正(XSS・パスバリデーション)
### 修正内容
**XSS — タグ名がエスケープなしで `innerHTML` に挿入される(`static/js/gallery-tab.js`)**
- `createTable` (L425): `tdTags.innerHTML` のタグ名を `escapeHtml` でエスケープ
- `renderTagsDisplay` (L605): タグ名と `data-tag` 属性を `escapeHtml` でエスケープ
- 悪意あるタグ名(例: `<img onerror=...>`)を保存→表示したときに JS が実行される問題
**XSS — ファイル名がエスケープなしで `innerHTML` に挿入される(`static/js/gallery-tab.js`)**
- `loadImageDetail` (L566): `alt="${img.filename}"` を `escapeHtml` でエスケープ
- `openLightbox` (L1175-1176): `alt` 属性とライトボックスフッターの両方をエスケープ
**XSS — エラーメッセージが `innerHTML` に未エスケープ(`static/js/gallery-tab.js`)**
- フォルダツリーエラー (L139, L155) と 画像グリッドエラー (L263) を `escapeHtml` でエスケープ
- サーバーエラーメッセージにパス名等の特殊文字が含まれる場合の対策
**メタデータ書き込みエンドポイントにパスバリデーション追加(`py/services/gallery_service.py`)**
- `save_image_meta`, `toggle_favorite`, `add_to_group`, `remove_from_group` に `_check_path_allowed()` を追加
- delete/move など他の書き込みエンドポイントには既にあったが、これら4メソッドのみ漏れていた
- 修正により `gallery_metadata.json` に許可ルート外のパス文字列が書き込まれるのを防止
**`list_folder_tree` が `_allowed_root` を任意パスで上書きできる問題(`py/routes/gallery_routes.py`)**
- `gallery_routes.py` のモジュールロード時に `_init_allowed_root()` を呼び出し、保存済み `gallery_output_dir`(なければ ComfyUI デフォルト output ディレクトリ)で `_allowed_root` を初期化
- `_allowed_root` が起動直後に設定済みになるため、`list_folder_tree` の `if self._allowed_root is None` ブランチが発火せず、任意パスによる上書き不可
- 副次効果として、Gallery タブを一度も開かない状態でも `serve_image` が正常動作(→ Feeder Gallery モードでの 404 バグ修正に直結)
**`escapeHtml` にシングルクォートのエスケープを追加(`static/js/util.js`)**
- `'` → `&#x27;` を追加
- 現在の使用箇所はすべて二重引用符属性のため即時影響はないが、将来の誤用を防止
---
## 2026-06-20: WFS_GalleryFeeder — ComfyUI キャンバス上コントロール追加
### 新規ファイル(`web/comfyui/gallery_feeder_extension.js`)
`app.registerExtension` を使い、ComfyUI キャンバス上の `WFS_GalleryFeeder` ノードに直接コントロールを追加。
- **After Gen** コンボ(`loop` / `increment` / `fixed`): `serialize: false` で prompt には含まれない
- **▶ Run ボタン**: グループ画像を取得 → `index` ウィジェットを更新 → `app.queuePrompt` → 完了待ち → 繰り返し
- **■ Stop ボタン**: `app.api.interrupt()` で現在の生成を中断し、ループフラグをクリア
- `waitForExecution()`: `executing` (null)・`execution_interrupted`・`execution_error` の3イベントを購読して1プロンプトの完了を Promise で待つ
- `onRemoved` フックでノード削除時にループを自動停止・状態をクリーンアップ
---
## 2026-06-20: __Feeder__ グループ保護 + サムネイル F ボタン + seed バグ修正
### `__Feeder__` グループの予約済み保護
**サーバーサイド(`py/routes/gallery_routes.py`)**
- `_RESERVED_GROUPS = {"__Feeder__"}` 定数を追加
- `rename_group` / `delete_group` エンドポイントで予約グループへの操作を 403 で拒否
**クライアントサイド(`static/js/gallery-tab.js`)**
- グループ管理ドロップダウンで `__Feeder__` を選択したとき、リネーム・削除ボタンを `disabled` に
- セレクトオプションに 🔒 プレフィックスを追加して視覚的に区別
- `change` イベントリスナーで動的に切り替え
### ギャラリーサムネイル「F」オーバーレイボタン(`static/js/gallery-tab.js`, `static/css/gallery-tab.css`)
- モデルタブの「B」バッチ登録ボタンと同様の位置(カード左上)に「F」ボタンを追加
- `inFeeder` 初期状態は `img.groups` 配列から判定(`list_images()` が返す `groups` フィールドを使用)
- クリックで `__Feeder__` グループへの追加 / 除外をトグル(APIコール + in-memory キャッシュ更新)
- アクティブ時はシアン色 (`#38bdf8`)、ホバー時のみ表示(active 時は常時表示)
**i18n(`static/js/i18n.js`)**
- 英/日/中に `addedToFeeder` / `removedFromFeeder` キーを追加
### seed バリデーションエラー修正(`py/nodes/gallery_feeder_node.py`)
**症状**: Feeder run 実行時に "Prompt outputs failed validation" エラーが発生
**原因**: `comfyui-client.js` の `applySeedToWorkflow()` がグラフ内の全ノードの seed を `Number.MAX_SAFE_INTEGER`(約 9×10¹⁵)以下のランダム値に上書きする。`WFS_GalleryFeeder` が宣言していた `max: 0x7FFFFFFF`(約 2.1×10⁹)を大幅に超えるため、ComfyUI の `validate_prompt()` が `value_bigger_than_max` でリジェクト。
**修正**: seed の `max` を `0x7FFFFFFF` → `0xffffffffffffffff`(KSampler と同値)に変更。
---
## 2026-06-20: Gallery Feeder 機能追加(WFS_GalleryFeeder ノード)
### 概要
Feeder タブにギャラリー連携モードを追加。外部プラグイン(comfyui-image-feeder)に依存せず、本プラグイン単独でギャラリーグループの画像を連続生成ループに利用できるようになった。
### 新規ノード(`py/nodes/gallery_feeder_node.py`)
- **`WFS_GalleryFeeder`**(Workflow Studio カテゴリ)
- 入力: `group_name` (STRING), `index` (INT), `sort_mode` (COMBO: filename_asc/filename_desc/random), `seed` (INT)
- 出力: `IMAGE`
- `gallery_metadata.json` を直接読み込み、指定グループの画像を `index % len(images)` で1枚出力
- ファイルの存在チェックつき(削除済み画像はスキップ)
- `IS_CHANGED` で毎回実行(インデックスが変わるためキャッシュ無効化)
- データファイルの場所は `Path(__file__)` ベースで自動解決(ComfyUI のパス構成に依存しない)
### ノード登録(`__init__.py`)
- `WFS_GalleryFeeder` を `_NODE_MODULES` に追加(`"Gallery Feeder (WFS)"` として表示)
- あわせて既存の `WFS_PromptText` のディスプレイ名がハードコードされていたバグを修正(`_NODE_MODULES` にディスプレイ名を持たせる構造に変更)
### Feeder グループ管理(`py/services/gallery_metadata.py`, `py/services/gallery_service.py`)
- `clear_group(group_name)`: グループ内の全画像を除外(グループ自体は残す)
- `ensure_group(name)`: グループが存在しない場合のみ作成
### API エンドポイント(`py/routes/gallery_routes.py`)
- `POST /wfm/gallery/groups/{name}/clear` — グループの全画像を除外(FC ボタン用)
- `POST /wfm/gallery/groups/ensure` — グループが存在しない場合のみ作成(Feeder タブ初期化時に `__Feeder__` を自動作成)
### ギャラリータブ FC ボタン(`static/js/gallery-tab.js`, `templates/index.html`)
- `FEEDER_GROUP = "__Feeder__"` 定数を export
- `ensureFeederGroup()` を export(Feeder タブ初期化時に呼び出す)
- `clearFeederGroup()`: `/wfm/gallery/groups/__Feeder__/clear` を呼び出してグループをクリア
- ギャラリーツールバーのグループフィルタ横に **[FC]** ボタンを追加(BC/SC ボタンと同様の位置)
- API 定数に `groupEnsure`, `groupClear`, `groupImages` を追加
### Feeder タブ Gallery モード(`static/js/feeder-tab.js`, `templates/index.html`)
- 左ペイン上部に **[Image Loop] / [Gallery]** のモード切り替えボタンを追加(`localStorage` に保存)
- **Image Loop モード**(既存機能): 変更なし
- **Gallery モード**(新機能):
- 左ペイン: `WFS_GalleryFeeder` ノード選択・Apply・グループ選択・Sort Mode / Index / Seed・After gen (Loop/Increment/Fixed)・Run/Stop
- 中央ペイン: 選択グループの画像グリッド(`/wfm/gallery/image/serve` でサムネイル表示)。クリックで Index を更新
- 右ペイン: プレビュー(既存と共通)
- Run ループ: JS 側でインデックスを管理(WebSocket sync 不要)。Increment モードで末尾到達時に自動停止
- タブ初期化時に `ensureFeederGroup()` を呼び出して `__Feeder__` グループを自動作成
### i18n(`static/js/i18n.js`)
- 英・日・中に3キー追加: `feederGalNoNode`, `feederGalEmptyGroup`, `feederGroupCleared`
---
## 2026-06-19: Generate UI — ImpactWildcardEncode/Processor プロンプト検出バグ修正(v0.3.41)
### 修正内容(`static/js/comfyui-workflow.js`)
**症状**:comfy-impact-pack の `ImpactWildcardEncode` / `ImpactWildcardProcessor` ノードを含むワークフローを Generate UI に読み込んだとき、Prompt タブにプロンプトが表示されない(ID は正しく表示されていた)。
**原因1: CLIPTextEncodeEditPlus 経由の BFS ロール伝播漏れ**
- これらのワークフローでは ImpactWildcard ノードの出力が `CLIPTextEncodeEditPlus` の `text2` 入力に接続され、CLIPTextEncodeEditPlus が KSampler の positive に繋がる構成。
- BFS 伝播で `CLIPTextEncodeEditPlus` の STRING 入力(text1, text2)に positive/negative ロールを伝播するコードが未実装だったため、上流の ImpactWildcard ノードのロールが `unknown` のままになっていた。
- **修正**: BFS ループに `CLIPTextEncodeEditPlus` の `text1` / `text2` への伝播を追加。
**原因2: CLIPTextEncodeEditPlus が空の text_edit で prompt_nodes の先頭に入り込む**
- CLIPTextEncodeEditPlus 自体も positive ロールとして検出され、`text_edit = ""` でノードIDが小さいため `positiveNodes[0]` になっていた。
- これによりテキストエリアに空文字が表示され、ImpactWildcard ノードのプロンプトが埋もれていた。
- **修正**: `text_edit` が空文字列の場合は `prompt_nodes` に追加しないよう条件を追加(`textVal !== ""`)。空の text_edit は「上流ノードからプロンプトが来る場合のデフォルト状態」であり、UI で表示する必要がない。
**原因3: object_info マッピングの不確実性**
- `convertUiToApi()` で impact-pack バージョンによる `object_info` のウィジェット順序差異が発生した場合、`wildcard_text` が正しくマッピングされない可能性があった。
- **修正1**: ポストプロセスで `widgets[0]` を常に `wildcard_text` として上書き(`!("wildcard_text" in inputs)` ガードを除去)。
- **修正2**: `_getWidgetMapping()` フォールバックに `ImpactWildcardProcessor: ["wildcard_text"]`、`ImpactWildcardEncode: ["wildcard_text"]` を追加(ComfyUI オフライン時の対応)。
---
## 2026-06-19: AI TOOL タブ Chat ペイン・ワイルドカード生成追加(v0.3.40)
### Chat ペイン(`templates/index.html`, `static/css/main.css`, `static/js/ai-tab.js`, `web/comfyui/node_sets_menu.js`)
- AI TOOL タブを 3ペイン → **4ペイン**(Translation | Chat | TOOLS | Settings)に変更
- Chat ペイン: LLM とのマルチターン会話;会話履歴を毎回送信;Enter で送信、Shift+Enter で改行;Clear ボタンで履歴リセット
- Ollama: `/api/chat` エンドポイント(`messages` 配列)、LM Studio: `/v1/chat/completions`(同形式)
- 送信失敗時は入力テキストを復元してリトライ可能
- サイドパネル Aタブにも Chat サブタブを追加(Translation → **Chat** → TOOLS → Settings の4タブ構成)
- CSS: `.wfm-ai-chat-*` / `.wfm-nlp-ai-chat-*` でユーザーバブル(右)・アシスタントバブル(左)スタイル追加
### ワイルドカード生成(`templates/index.html`, `static/css/main.css`, `static/js/ai-tab.js`, `web/comfyui/node_sets_menu.js`)
- TOOLS ペインのドロップダウンに「Create wildcards」オプションを追加
- タスク切替で UI を動的切り替え:VLM選択時→ドロップゾーン表示、Wildcard選択時→Name・Count入力フォームを表示
- プロンプト: `Generate ${count} wildcard entries for the category "${name}". Output only plain text in English, one entry per line, no numbers, no markdown, no asterisks, no bold, nothing else.`
- 後処理: `**` / 行頭 `*` / 行頭数字(`\d+\.\s*`)を除去してプレーンテキストを保証
- SPA(`static/js/ai-tab.js`)とサイドパネル(`web/comfyui/node_sets_menu.js`)両方に実装
### ヘルプ・i18n(`static/js/i18n.js`, `static/js/app.js`, `templates/index.html`)
- AI TOOL タブヘルプを5項目→6項目に再構成(ai-3: Chat、ai-4: VLM、ai-5: Wildcards、ai-6: 設定)
- `helpSidepanel16` を EN/JA/ZH 更新(Chat・ワイルドカード機能を追記)
- `helpAi1`〜`helpAi6` を EN/JA/ZH 全更新
- 新 i18n キー追加(3言語): `aiStatusChatting`, `aiToastChatFailed`, `aiToastWcNoName`
---
## 2026-06-18: Send to Canvas機能追加(ワークフロータブ・ギャラリータブ→LibraryタイトルDnD)
### ワークフロータブ — Send to Canvas(`static/js/workflow-tab.js`, `static/js/app.js`, `templates/index.html`)
- ツールバーおよび詳細モーダルの **Open in ComfyUI** ボタンを **Send to Canvas** に変更
- `sendToCanvas(workflowData)`: ワークフローJSONを `localStorage["wfm_pending_workflow"]` に保存してトースト表示(新しいブラウザタブを開かない)
- `openInComfyUI()` 関数は後方互換のため残置
### ギャラリータブ — Copy & Send Canvas(`static/js/gallery-tab.js`, `templates/index.html`)
- **Copy Workflow** ボタンを **Copy & Send Canvas** にリネーム
- クリック時にクリップボードコピーと `localStorage["wfm_pending_workflow"]` への保存を同時実行
### Workflow Studio Library — タイトルドラッグ(`web/comfyui/node_sets_menu.js`)
- `createPanel()` 内でタイトル要素(`.wfm-nlp-title`)にドラッグロジックを追加
- `updateTitlePendingState()`: `localStorage` の `wfm_pending_workflow` 有無を検出して `draggable` 属性・CSS クラス・`title` 属性を動的切り替え
- `panel.mouseenter` / `window.storage` イベントで状態を自動更新(メインアプリ→ComfyUI切り替え後も検出)
- `dragstart`: pending JSON を `application/x-wfm-pending` MIME タイプにセット
- `installCanvasDropHandler()`: `application/x-wfm-pending` を dragover と drop の両ハンドラに追加
- drop 時に `JSON.parse` → `app.loadGraphData()` → localStorage削除 → タイトルリセット
- CSS: `.wfm-nlp-title-pending { color: #66aaff; cursor: grab }` + `::after` で緑●インジケーター表示
### i18n・ヘルプ(`static/js/i18n.js`, `static/js/app.js`, `templates/index.html`)
- `sendToCanvas` / `copyAndSendCanvas` / `workflowSentToCanvas` を EN/JA/ZH に追加
- ヘルプ: `helpWf6`(send to canvas)・`helpGallery8`(Copy & Send Canvas説明)を3言語更新
- ヘルプ: `helpSidepanel17` 新規追加(タイトルドラッグ機能説明)を3言語で追加、app.jsマッピング・index.html li要素も追加
---
## 2026-06-15: TaggerシングルGenUI:Pボタン追加+生成UIのZITワークフロープロンプト解析修正
### TaggerシングルGenUI:Pボタン(`templates/index.html`, `static/js/tagger-tab.js`, `static/js/i18n.js`)
- Single タブの結果アクション行に **GenUI:P** ボタンを追加(「プロンプトに送信」の左隣)
- クリックすると生成UIタブの `#wfm-prompt-pos-text`(ポジティブプロンプトtextarea)末尾にタグを追記し、`#wfm-prompt-pos-apply` を自動クリックしてワークフローへ即時反映
- 生成UIにワークフローが読み込まれていない場合は警告トーストを表示
- i18n: `taggerSendToGenUI` / `taggerSentToGenUI` / `taggerNoGenUI` を EN/JA/ZH に追加
- ヘルプ: `helpTagger6` を5項目に更新(GenUI:P を先頭に追加)
### 生成UIのZIT/Lumina2ワークフロープロンプト解析修正(`static/js/comfyui-workflow.js`, `py/services/workflow_analyzer.py`)
- `comfyui-workflow.js` の `COND_PASSTHROUGH` から `"ConditioningZeroOut"` を除外
- ZITワークフローでは KSampler.negative → ConditioningZeroOut → CLIPTextEncode という接続を持つが、ConditioningZeroOut は上流テキストを完全に破棄するため negative ロールを上流に伝播すべきでない
- 修正前: CLIPTextEncode が positive / negative 両ロール付与 → `getRole()` が "unknown" → Generate UI のプロンプト欄に表示されない
- 修正後: CLIPTextEncode は positive ロールのみ → 正常にポジティブプロンプトとして表示
- `workflow_analyzer.py` の `_CLIP_TYPE_TO_MODEL` に `"lumina2": "Z-IMAGE"` を追加
- CLIPLoader の `type` フィールドが `"lumina2"` のワークフローを Z-IMAGE として正確に分類
---
## 2026-06-15: Taggerバッチ.txt出力追加+Galleryタグ保存バグ修正
### Taggerバッチ.txt出力(`templates/index.html`, `static/js/tagger-tab.js`, `static/js/i18n.js`, `py/routes/tagger_routes.py`, `py/services/tagger_service.py`)
- バッチ出力オプションに **Write .txt** チェックボックスを追加
- 有効にすると処理した各画像と同一フォルダに `<ファイル名>.txt`(UTF-8)を生成、Interrogator + VLM タグのカンマ区切り文字列を書き込む
- `batch_start()` シグネチャに `write_txt: bool` パラメータを追加、ルート・フロントエンドも連動更新
- i18n: `taggerBatchWriteTxt` キーを EN/JA/ZH に追加
### Galleryタグ保存バグ修正(`static/js/tagger-tab.js`)
- `_saveToGallery()` がタグをカンマ区切り文字列のまま POST していたため、Gallery が `img.tags.forEach is not a function` エラーで更新不能になっていた
- 修正: 送信前に `tags.split(",").map(s => s.trim()).filter(Boolean)` で配列に変換
---
## 2026-06-15: Taggerタブ新規実装+ギャラリー詳細パネルUI改善+パストラバーサル修正
### Taggerタブ新規実装
#### バックエンド(`py/config.py`, `py/services/tagger_service.py`, `py/services/tagger_db_service.py`, `py/routes/tagger_routes.py`, `py/wfm.py`)
- `py/config.py`: `TAGGER_DB_FILE` / `TAGGER_SETTINGS_FILE` / `TAGGER_MODELS_DIR`(`ComfyUI/models/tagger/`)定数追加
- `TaggerService`: WD Tagger(ONNX)・SwinV2・DeepDanbooru(.h5 / TensorFlow optional)推論、Ollama VLM連携(`/api/chat`)、JPEGへのpiexif EXIF書込・PNGへのPngInfo書込・サイドカー.tags.json書込、スレッドベースバッチ処理(`batch_start` / `batch_stop` / `batch_status`)、設定の永続化
- `TaggerDbService`: SQLite(`tagger.db`)によるタグ保存・一覧・検索・更新・削除・CSV出力
- `tagger_routes.py`: `/wfm/tagger/` 配下に17エンドポイントを登録(models・predict・ollama/models・ollama/predict・batch/start/status/stop・db CRUD・write_meta・settings)、全CPU処理を `asyncio.to_thread()` でラップ
- `py/wfm.py`: `tagger_routes.setup_routes(app)` を追加
- `requirements.txt` 新規作成: `onnxruntime>=1.16`・`piexif>=1.1.3` を必須、TensorFlow をオプション(コメントアウト)として記載
#### フロントエンド(`templates/index.html`, `static/css/tagger-tab.css`, `static/js/tagger-tab.js`, `static/js/i18n.js`, `static/js/app.js`)
- `templates/index.html`: Taggerタブナビボタン追加、`<section id="wfm-tab-tagger">` を追加(Single / Batch / DBの3サブタブ構成)
- `static/css/tagger-tab.css` 新規作成: サブタブナビ・シングルレイアウト・プレビューエリア(破線ボーダー+ドラッグオーバーハイライト)・バッチ進行状況バー・DBテーブルのスタイル
- `static/js/tagger-tab.js` 新規作成:
- `initTaggerTab()`: i18n適用・サブタブ切り替え・スライダー連動・Ollamaトグル・各種イベント登録・モデル一覧ロード・設定読み込み
- `openImageInTaggerTab(img)`: Gallery→Taggerタブ遷移+画像ロード(`/wfm/gallery/image/serve` 経由でbase64変換)
- Single: ドラッグ&ドロップ・ファイルアップロード・タグ生成(WD Tagger+Ollama並行)・4出力先(Prompt送信・Gallery保存・ファイル書込・DB保存)
- Batch: バッチ開始/停止・1秒間隔ポーリングによるリアルタイム進行状況更新
- DB: 一覧表示・検索・行選択編集・保存・削除・CSV出力
- `static/js/i18n.js`: `tabTagger`・Taggerタブ関連キー約50件を EN/JA/ZH 3言語で追加
- `static/js/app.js`: `tabMap` に `tagger` 追加、`initTaggerTab()` インポート&呼び出し追加
### ギャラリー詳細パネルUI改善(`templates/index.html`, `static/css/gallery-tab.css`, `static/js/gallery-tab.js`, `static/js/app.js`)
- タブ行(Info / JSON / Groups)とアクションボタン行(Metadata / Load GenUI / Tagger)を分離: タブは `wfm-side-tab-nav`、ボタンは新設の `wfm-gallery-detail-action-row` へ移動
- `.wfm-gallery-detail-action-row` のCSSを `gallery-tab.css` に追加(`flex`・`flex-wrap`・`padding`)
- Galleryの詳細パネルに **Tagger** ボタン(`wfm-gallery-open-tagger-btn`、紫)追加: クリックで選択画像を `openImageInTaggerTab()` へ渡してTaggerタブへ遷移・画像ロード
- `.wfm-gallery-action-btn-tagger` スタイル(`gallery-tab.css`)追加
- `app.js` の `applyI18nToHtml()` でTaggerボタンのテキストを `t("tabTagger")` に設定
### セキュリティ修正: パストラバーサル対策(`py/services/tagger_service.py`, `py/services/gallery_service.py`)
- `TaggerService._validate_model_name()`: モデル名に `/` `\` `..` `\x00` が含まれる場合はロード拒否(`mdir / model_name` のパストラバーサルを防止)
- `TaggerService.write_meta_to_file()`: ユーザー指定パスを `resolve()` した上で許可拡張子(`.jpg/.jpeg/.png/.webp/.bmp/.gif`)のみ処理、それ以外はエラー返却
- `GalleryService._check_path_allowed()`: `_allowed_root is None` のときに tautology(`resolved == path.resolve()`、常にTrue)だった判定を `return False` に修正(`list_folder_tree` 呼び出し前に全パスが通る問題を解消)
### ヘルプ更新(`templates/index.html`, `static/js/i18n.js`, `static/js/app.js`)
- ヘルプナビに「Tagger Tab」追加
- Taggerタブのヘルプページ新設(9項目: モデル配置・Single操作・閾値・Ollama・出力先・Batch・DB・インストール手順)EN/JA/ZH
- Galleryタブヘルプに `helpGallery14`(Taggerボタン説明)を EN/JA/ZH で追加
- トラブルシューティングに `helpTrouble7`(Taggerモデル未表示時の対処)を EN/JA/ZH で追加
---
## 2026-06-15: 全選択ボタン追加+ギャラリーバルクバーi18n対応
### 変更内容
#### Modelsタブ: 複数選択バーに「全選択」ボタン追加(`static/js/models-tab.js`, `static/js/i18n.js`)
- `selectAll()` 関数を追加: `filterModels()` の結果(フィルター・検索適用後の表示中モデル)を `state.selectedModels` に一括追加して `renderModelGrid()` / `renderBulkActionBar()` を呼び出す
- `renderBulkActionBar()` のバーHTMLに `wfm-bulk-select-all-btn` を Deselect All ボタンの右隣に追加
- イベントリスナーを追加(`"wfm-bulk-select-all-btn"` → `selectAll`)
- i18n: `modelBulkSelectAll` を英語 "Select All" / 日本語 "全選択" / 中国語 "全选" で追加
#### Galleryタブ: 複数選択バーに「全選択」ボタン追加+全ボタンi18n対応(`templates/index.html`, `static/js/gallery-tab.js`, `static/js/app.js`, `static/js/i18n.js`)
- `wfm-gallery-bulk-select-all` ボタンを Deselect All ボタンの右隣に追加(`templates/index.html`)
- クリックリスナー: `state.images` の全パスを `state.selectedImages` に追加し `renderImages()` / `updateBulkBar()` を呼び出す
- バルクバーの全ボタン・セレクトのテキストを空にして `applyI18nToHtml()` 経由で `t()` 設定に変更(ハードコード英語文字列を排除)
- `updateBulkBar()` の選択件数表示を `t("galleryBulkSelected")` でi18n化(`"${count} selected"` → `"${count} ${t(...)}"` )
- グループセレクトの初期オプションを `t("galleryBulkAddToGroup")` でi18n化
- `app.js` の `applyI18nToHtml()` にギャラリーバルクバー全要素のi18n設定処理を追加
- i18n: 英語 / 日本語 / 中国語の3言語でギャラリーバルクバー用キー10個を新規追加: `galleryBulkSelected` / `galleryBulkDeselectAll` / `galleryBulkSelectAll` / `galleryBulkAddToGroup` / `galleryBulkAdd` / `galleryBulkFavAll` / `galleryBulkUnfavAll` / `galleryBulkMoveTo` / `galleryBulkDelete`
---
## 2026-06-10: v0.3.36 — コードレビュー修正+リファクタリング+README刷新
### コードレビュー修正(v0.3.35の不具合10件)
#### ヘルプi18n配線の修正(`static/js/i18n.js`, `static/js/app.js`, `templates/index.html`)
- **バグ**: `applyI18nToHtml()` が起動時に全言語でヘルプ文を上書きするため、v0.3.35でindex.htmlに追記したヘルプ更新(Saveボタン・ソート・JSONタブ改名)が一切表示されなかった
- `helpGen2` / `helpModels2` / `helpGallery8` / `helpGallery10` を3言語ともindex.htmlの新文言に同期
- `helpGallery12` / `helpGallery13` キーを3言語で新規追加(Metadata / Load GenUI ボタン説明)
- `helpIdMap` に `wfm-help-models-12` / `wfm-help-trouble-6` / `wfm-help-gallery-12` / `wfm-help-gallery-13` を登録
- index.html の「Thumbnail, Card, and Table」誤記を修正(カードビューはv0.3.22で廃止済み)
#### GenerateUI Save の安全化(`static/js/generate-tab.js`)
- **上書き確認**: 保存前に `GET /api/wfm/workflows` で既存ファイルを照会し、同名があれば confirm 表示。保存先が **UI形式**(`analysis.format === "ui"`)の場合はAPI形式上書きでノード配置が失われる旨の専用警告
- **Raw JSON同期**: Raw JSONテキストエリアに未Applyの編集があればパースして保存対象に反映し、保存後エディタへ同期。不正JSONはエラーで中断(従来は古い内容を黙って保存していた)
- **HTML注入防止**: ファイル名を `value="${...}"` 属性埋め込みからDOM経由の `input.value` 設定に変更
- **デフォルト名**: 拡張子除去を `.json` のみ→画像拡張子(.png/.jpg/.jpeg/.webp/.gif)にも拡大
- **二重送信ガード**: `saving` フラグでEnter連打・多重POSTを防止
#### その他
- `sortModels` を decorate-sort-undecorate 方式に変更(`sortKeyOf()` で1モデル1回だけキー計算。比較ごとの `parseModelPath` 再計算を解消)(`static/js/models-tab.js`)
- ギャラリーの Metadata / Load GenUI ボタンを `.wfm-gallery-detail-tab-btn` から専用の `.wfm-gallery-action-btn` に分離し、CSSの `!important` 16箇所を全廃(`templates/index.html`, `static/css/gallery-tab.css`)
- Save関連・ギャラリーの新規文字列をi18n化(`saveWorkflowTitle` / `savedAs` / `overwriteConfirm` / `gallerySelectImageFirst` 等を3言語追加)
### リファクタリング
#### util.js 新設(`static/js/util.js` 新規)
- `escapeHtml()`: 5ファイル(gallery / metadata / models / nodes / workflow)の重複定義を統一。metadata-tab版は `"` エスケープが抜けており属性値でHTML注入の恐れがあった(修正済み)
- `readJsonStorage(key, fallback)` / `getSettings()`: `JSON.parse(localStorage.getItem(...))` の直書き15箇所(8ファイル)を置換。try/catchの重複も削減
#### トーストi18n化(全タブJS, `static/js/i18n.js`)
- ハードコード英語トースト約115箇所をすべて `t()` 化(残り0件)
- 共通キー約60個を3言語(EN/JA/ZH)で追加: `errorWithMsg` / `groupCreated` / `presetSavedName` / `batchNoneSelected` / `generationComplete` など
- 既存キーとの衝突回避: 文字列型の既存 `importError` / `presetSaved` と重複したため、新関数型キーは `importErrorMsg` / `presetSavedName` に命名
- 既存バグ修正: Settings画面の `textSizeLabel` / `jsonColor*` 系11キーが未定義で生キー名が表示されていた(v0.3.14由来。`t() || "fallback"` はt()がキー名を返すため機能しない)→ 3言語で定義追加
- ZHブロックに欠落していた `copyPositivePrompt` / `copyNegativePrompt` / `copiedToClipboard` / `noTextToCopy` を追加
- 検証: 全 `t()` 呼び出しキーの定義確認・3言語のキー完全一致・重複キーなし・全JS構文チェック通過
### README刷新(`README.md`, `pyproject.toml`, `docs/`)
- 冒頭説明文を3本柱構成に書き換え: 📁 Management(ワークフロー/モデル/画像/プロンプト管理、AIプロンプト支援・翻訳・タグ生成、ファイルドロップ&ギャラリー連携メタデータ)/ ⚡ GenerateUI(全タブ連携、モデル・サンプラー等バッチ生成、Image Feeder)/ 📚 Workflow Studio Library(キャンバスドロップ、画像/JSONメタデータ表示&ドロップ、AIツール)
- スクリーンショット差し替え・追加: `6_ws_library.png` 差し替え、`9_GenUI_LoraStack.png`(GenUI LoRA Stack)・`10_GenUI_Batch.png`(GenUI Batch)・`11_multiple_select_menu.png`(Models Multi-select Menu)を新規追加し、生成UI系3枚が連続するよう表を再配置
- `pyproject.toml` の `description` をREADME新説明文と整合する内容に更新
---
## 2026-06-10: v0.3.35 — テーブルソート・Load GenUI・ワークフロー保存
### 変更内容
+188 -26
View File
@@ -1,11 +1,24 @@
# ComfyUI-Workflow-Studio
A comprehensive workflow management and generation UI plugin for [ComfyUI](https://github.com/comfyanonymous/ComfyUI).
A comprehensive workflow, asset management, and generation UI plugin for [ComfyUI](https://github.com/comfyanonymous/ComfyUI).
Browse, organize, and execute workflows directly from a dedicated studio interface — without switching between windows or manually editing JSON.
**📁 Management** — organize all your assets in one studio
- Workflow, model, image, and prompt management
- AI-powered prompt writing assistance, translation, and tag generation
- File drop & Gallery-linked metadata viewing — inspect and reuse generation settings instantly
**⚡ GenerateUI** — a productivity-focused generation tab connected to every other tab
- Batch generation across models, samplers, prompts, and workflows
- Image Feeder for continuous folder-based generation
**📚 Workflow Studio Library** — a multi-function side panel for smooth ComfyUI integration
- Drag & drop models, nodes, prompts, and workflows straight onto the canvas
- **Send to Canvas**: click "Send to Canvas" (Workflow tab) or "Copy & Send Canvas" (Gallery tab) to send the workflow directly to the ComfyUI canvas — UI and API formats both supported
- View metadata from images / JSON, then drop the detected models and prompts onto the canvas
- Built-in AI tools (translation and more)
![Workflow Studio](https://img.shields.io/badge/ComfyUI-Custom_Node-blue)
![Version](https://img.shields.io/badge/version-0.3.35-green)
![Version](https://img.shields.io/badge/version-0.3.52-green)
## Screenshots
@@ -17,13 +30,21 @@ Browse, organize, and execute workflows directly from a dedicated studio interfa
|:---:|:---:|
| ![Prompt Input Assistance](docs/3_PromptInputAssistance.png) | ![Gen UI Feeder](docs/4_GenUI_feeder.png) |
| Top Bar | WS Library |
| GenUI LoRA Stack | GenUI Batch |
|:---:|:---:|
| ![Top Bar](docs/5_topbar.png) | ![WS Library](docs/6_ws_library.png) |
| ![GenUI LoRA Stack](docs/9_GenUI_LoraStack.png) | ![GenUI Batch](docs/10_GenUI_Batch.png) |
| Library Information | Customize |
| Models Multi-select Menu | Top Bar |
|:---:|:---:|
| ![Library Information](docs/7_library_Infomation.png) | ![Customize](docs/8_Customize.png) |
| ![Models Multi-select Menu](docs/11_multiple_select_menu.png) | ![Top Bar](docs/5_topbar.png) |
| WS Library | Library Information |
|:---:|:---:|
| ![WS Library](docs/6_ws_library.png) | ![Library Information](docs/7_library_Infomation.png) |
| Customize | |
|:---:|:---:|
| ![Customize](docs/8_Customize.png) | |
---
@@ -37,7 +58,7 @@ Browse, organize, and execute workflows directly from a dedicated studio interfa
- **Side panel tabs** — Thumbnail preview, JSON viewer with syntax highlighting, and Group management
- **Badge management** — add, rename, delete badges with custom colors shared with the Models tab (⚙ Badge button)
- **AI summary** — generate workflow descriptions using Ollama
- **Import / Export** — import workflows from files or clipboard, open in ComfyUI directly
- **Import / Export** — import workflows from files or clipboard; **Send to Canvas** button sends the selected workflow directly to the ComfyUI canvas (UI and API formats both supported)
- **Default view setting** — persist your preferred view mode (Thumbnail / Table)
### Canvas Snapshot (v0.1.2)
@@ -49,8 +70,8 @@ Browse, organize, and execute workflows directly from a dedicated studio interfa
### GenerateUI Tab (v0.3.5)
- **5-tab layout** — Input / Model / Settings / Feeder / Batch tabs; Input, Model, and Settings each include a Raw JSON column on the right for instant preview and direct editing
- **Save button** — located at the right end of the subtab row; opens a filename dialog (default: current workflow name) and saves the current workflow as a `.json` file to the Workflow tab via the import API
- **Input tab** — Prompt (top) and Image drag-and-drop (bottom) in the left column; Raw JSON (540px) in the right column
- **Model tab** — Checkpoint, VAE, LoRA, ControlNet, UNET, TextEncoder selectors with filter; Raw JSON on the right
- **Input tab** — Prompt and Image inner tabs (drag-and-drop upload); Prompt tab shows Positive Prompt and Negative Prompt textareas, plus an **Embeddings selector** at the bottom (Filter + Select + Weight input + Paste button); Paste inserts `(embedding:Name:weight)` at the cursor position of the last focused textarea (defaults to Positive when neither is focused); Raw JSON (540px) in the right column
- **Model tab** — Checkpoint, VAE, LoRA, ControlNet, UNET, TextEncoder, **Hypernetwork** (with Strength field) selectors with filter; Raw JSON on the right
- **Settings tab** — KSampler and Latent Image side by side at 50% width each; Raw JSON on the right
- **Always-visible Raw JSON** — edit the API-format JSON directly from any tab with syntax highlighting; Apply button reloads the workflow; built-in **search bar** (always shown) finds all matches as you type with count display (`3/12`); navigate with ↑/↓ buttons or Enter / Shift+Enter; Escape or ✕ clears; current match highlighted in orange, other matches in yellow
- **One-click generation** — queue prompts to ComfyUI without leaving the studio
@@ -63,8 +84,10 @@ Browse, organize, and execute workflows directly from a dedicated studio interfa
- **UI-to-API conversion** — automatic conversion supporting subgraphs (nested workflows), COMBO types, and display-only node exclusion; improved analysis covers SDXL multi-hop CONDITIONING chains, CLIPTextEncodeSDXL, SDXLPromptStyler, KSamplerAdvanced, and more
- **Eagle integration** — auto-save generated images to [Eagle](https://eagle.cool/) with metadata
### Feeder subtab (v0.3.5)
Requires the **[comfyui-image-feeder](https://github.com/ketle-man/comfyui-image-feeder)** custom node.
### Feeder subtab (v0.3.5 / v0.3.42)
Two independent modes selectable via **[Image Loop] / [Gallery]** toggle buttons at the top of the left pane (persisted in `localStorage`).
**Image Loop mode** — requires the **[comfyui-image-feeder](https://github.com/ketle-man/comfyui-image-feeder)** custom node.
- **ImageFeeder node control** — select the target node from a dropdown auto-populated from the loaded workflow; edit all node parameters (Directory, Sort Mode, Index, Start/End Index, Batch Size, Seed, Use Selection) and Apply to the workflow
- **Image library** — 3-pane layout: folder tree (left) browsing `user/default/image-loop-data/`, image grid with checkbox selection (center), preview panel with resolution and file size (right)
- **Selection management** — check individual images; All / None buttons for the current folder; selected files are reflected in `selected_files` on Apply
@@ -76,6 +99,13 @@ Requires the **[comfyui-image-feeder](https://github.com/ketle-man/comfyui-image
- **Index sync** — after each generation the node returns `next_index` via WebSocket (`image_loop_node_sync`); the Index field updates automatically
- **Seed** — Run loop uses the right-pane seed setting (Random / Fixed / Increment / Decrement); the node's own Seed field only affects random sort order
**Gallery mode** (v0.3.42) — no external plugin required; uses the built-in **WFS_GalleryFeeder** custom node.
- **WFS_GalleryFeeder node** — reads images directly from a Gallery group and outputs them one at a time; inputs: `group_name`, `index`, `sort_mode` (filename_asc / filename_desc / random), `seed`
- **Node & group selector** — pick the WFS_GalleryFeeder node from the loaded workflow and choose which Gallery group to feed images from; `__Feeder__` group is auto-created on first open
- **Image grid** — center pane shows all images in the selected group; click any image to update the Index to that position
- **After Gen modes** — Loop (wrap at end and continue indefinitely), Increment (stop automatically when last image is reached), Fixed (always use the same index)
- **Run / Stop controls** — left pane Run / Stop buttons manage the generation loop; After Gen combo (loop / increment / fixed), ▶ Run, and ■ Stop widgets are also available directly on the WFS_GalleryFeeder node in the ComfyUI canvas (`gallery_feeder_extension.js`)
### Prompt Tab
- **3-column layout** — AI Assistant (left), Presets/Preset Manager tab-panel (center), Wildcard support (right)
- **AI chat assistant** — powered by [Ollama](https://ollama.com/), generate and refine prompts interactively
@@ -117,21 +147,25 @@ Requires the **[comfyui-image-feeder](https://github.com/ketle-man/comfyui-image
- **Wildcard Integration** — link the WFS wildcard directory to ComfyUI-Impact-Pack's `wildcards/` directory (directory junction on Windows, symlink on other OS); existing WFS wildcard files are automatically migrated; requires [ComfyUI-Impact-Pack](https://github.com/ltdrdata/ComfyUI-Impact-Pack)
- **Language** — English / Japanese / Chinese
### Gallery Tab (v0.3.1)
### Gallery Tab (v0.3.44)
- **Image browser** — browse ComfyUI output images (Thumbnail / Table views) with server-side scanning optimized for 6,000+ image libraries
- **Thumbnail / Table views** — switch view modes; Favorites column shown leftmost in Table view
- **Folder management** — create subfolders ("+ New") or delete the selected folder with all contents ("Del") from the folder tree header
- **File operations** — move or delete individual images from the detail panel's Info tab; bulk Move To... and Delete from the multi-select bar
- **Multi-select** — Ctrl+click to select multiple images; Bulk Bar appears for batch operations (group, favorite, move, delete)
- **File operations** — move or delete individual images from the detail panel's Info tab; bulk Move To..., Export, and Delete File from the multi-select bar
- **Download** — hover over the image preview in the detail panel to reveal a download icon (⬇); click to download the single image
- **Multi-select** — Ctrl+click to select multiple images; Bulk Bar appears for batch operations: select group → "Add to Group" / "Remove from Group"; Favorite All / Unfavorite All; Compare (2–4 images); Move To...; **Export** (downloads all selected images as a ZIP file); Delete File
- **Image Compare** — select 2–4 images with Ctrl+click, then click "Compare" in the Bulk Bar to open a side-by-side lightbox; grid adapts to the number of selected images
- **Prompt search** — text search covers filename, tags, memo, and prompt text (A1111 `parameters` field cached on first detail panel open)
- **Server-side filtering** — filter by group, favorites, or tags with fast server-side set lookup (no full rescan)
- **Group management** — create, rename, delete groups and assign/remove images using the same 4-section panel as Models tab
- **Group management** — create, rename, delete groups and assign/remove images using the same 4-section panel as Models tab; **`__Feeder__`** is a reserved group (🔒 prefix) that cannot be renamed or deleted; used by the Feeder Gallery mode to define the generation queue; **FC** button in the toolbar clears all members without deleting the group
- **Thumbnail F button** — cyan overlay button (top-left of each image card) toggles the image's membership in the `__Feeder__` group; cyan and always-visible when the image is in the group; visible on hover only when inactive
- **Favorites** — star images inline without reopening the detail panel
- **Detail panel** — view filename, path, tags, groups, and metadata in a slide-out panel
- **Workflow viewer** — Metadata tab displays workflow JSON from PNG embedded data (`prompt` / `workflow` keys) or from workflow saved by the Generate UI tab
- **Workflow viewer** — Metadata tab displays workflow JSON from PNG embedded data (`prompt` / `workflow` keys) or from workflow saved by the Generate UI tab; **Copy & Send Canvas** button copies the JSON to the clipboard and sends the workflow directly to the ComfyUI canvas (UI and API formats both supported)
- **Load GenUI button** — loads the embedded ComfyUI workflow from the selected image directly into the GenerateUI tab; shows a warning toast if no workflow is embedded or the format is unsupported; Metadata button is styled green, Load GenUI button uses the primary accent color
- **Workflow auto-save** — images generated from the Generate UI tab have their workflow automatically saved to gallery metadata
- **Output folder configurable** — set the scanned output folder from Settings tab
- **Performance** — folder-level mtime cache (30s TTL) for fast incremental refresh; tree expansion state preserved across folder operations
- **Performance** — server-side 256px JPEG thumbnail generation with disk cache (`data/thumb_cache/`); infinite-scroll paging (50 images per page, IntersectionObserver); folder-level mtime cache (60s TTL); bulk operations use single-request API endpoints
### Nodes Tab (v0.1.7)
- **Node Browser** — browse all installed ComfyUI nodes from `/object_info` API with Card/Table views
@@ -153,7 +187,7 @@ Requires the **[comfyui-image-feeder](https://github.com/ketle-man/comfyui-image
- **CivitAI panel states** — three distinct states: not yet checked (fetch button), checked but not found on CivitAI (re-check button with notice), and found (full info display); clicking the CivitAI tab always refreshes to the latest state
- **Batch CivitAI fetch** — one-click batch fetch using `POST /model-versions/by-hash` (up to 100 models per request) with SSE progress streaming; previews are auto-saved for models without one
- **Detail modal** — preview image, CivitAI info, thumbnail change via file upload; **Delete** button permanently removes the model file and all associated sidecar files (preview images, `.json`, `.civitai.info`, `.metadata.json`, `.cm-info.json`)
- **GenUI Model button** — apply the selected model directly to the corresponding node in GenerateUI's current workflow (Checkpoint, LoRA, VAE, ControlNet, UNET, TextEncoder)
- **GenUI Model button** — apply the selected model directly to the corresponding node in GenerateUI's current workflow (Checkpoint, LoRA, VAE, ControlNet, UNET, TextEncoder, Hypernetwork); **Embedding** type shows **GenUI PP** / **GenUI NP** buttons instead — appends `(embedding:Name:1.0)` to the Positive or Negative prompt of the loaded workflow; also accessible from the side panel nav bar and the detail modal
- **Group management** — create, rename, delete groups and assign/remove models; groups are scoped per model type (checkpoint groups only appear in the Checkpoint tab); Checkpoint and LoRA tabs include **B (Batch)** and **S (Stack)** quick-assign buttons per card/row for one-click group membership toggle without grid re-render
- **Table view memo** — memo column displayed in table view for quick reference
- **Preview images** — auto-detect `{model_stem}.preview.png` next to model files
@@ -163,13 +197,26 @@ Requires the **[comfyui-image-feeder](https://github.com/ketle-man/comfyui-image
- **Badge row** — select a badge and **+Badge** / **−Badge** to apply or remove from all selected
- **File row** — select a destination subfolder (or type a new folder name and create it) then **Move** to relocate the model file with all sidecar files; **Delete Files** (right end) permanently removes selected models and all associated files
### Tagger Tab (v0.3.38)
- **3 sub-tabs** — Single / Batch / DB for single-image tagging, folder batch processing, and tag database management
- **Model support** — WD Tagger (ONNX, NCHW/NHWC auto-detect), SwinV2 (ONNX), DeepDanbooru (.h5, requires TensorFlow); place each model in its own subfolder under `ComfyUI/models/tagger/<model-name>/` containing the `.onnx` + `selected_tags.csv` (or `.h5` + label file)
- **Threshold sliders** — General threshold (default 0.35) and Character threshold for `character:` prefix tags (default 0.85); sliders update the display value in real time
- **Ollama VLM** — optional vision model alongside WD Tagger; set API URL and select model (↻ to refresh list); results from both models are merged into one comma-separated tag string
- **Single tab** — drag & drop an image onto the preview area or click Upload; Gallery detail panel **Tagger** button opens the selected image directly here
- **Single output options** — (1) **GenUI:P** — appends tags to the GenerateUI tab's positive prompt and immediately applies to the loaded workflow; (2) **Send to Prompt** — appends tags to the Prompt tab's positive textarea; (3) **Save to Gallery** — saves tags to Gallery image metadata (requires image opened from Gallery); (4) **Write to File** — embeds tags into JPEG EXIF (`ImageDescription`) or PNG `tEXt` chunk (`Tags` key), other formats get a `.tags.json` sidecar; (5) **Save to DB** — stores in internal SQLite database
- **Batch tab** — enter a folder path, configure WD Tagger and Ollama settings; output options: **Save to DB** (default on), **Write to File** (EXIF/PNG metadata), **Write .txt** (creates `<filename>.txt` alongside each image with all tags); real-time progress bar and log; Stop cancels after the current image
- **DB tab** — searchable SQLite database of all tagged images; click a row to open the edit panel and modify WD Tags / VLM Tags; Save updates the record, Delete removes it; Export CSV downloads all records
- **Dependencies** — install into ComfyUI's embedded Python: `python_embedded\python.exe -m pip install -r requirements.txt`; for GPU inference use `onnxruntime-gpu`; TensorFlow (DeepDanbooru) is optional and commented out in `requirements.txt`
### AI TOOL Tab (v0.3.14)
- **3-pane layout** — Translation (40%) | TOOLS (40%) | Settings (20%); all panes always visible simultaneously; no sub-tab switching required
- **4-pane layout** — Translation | Chat | TOOLS | Settings; all panes always visible simultaneously; no sub-tab switching required
- **Translation pane** — translate text between Japanese, English, Chinese, or a custom Free language using Ollama or LM Studio; language selectors with ⇄ swap button (swaps both language selectors and text content); selections saved automatically
- **Chat pane** (v0.3.40) — multi-turn conversation with the LLM; full conversation history sent each turn for context; Enter to send, Shift+Enter for a newline; Clear button resets history; Ollama uses `/api/chat`, LM Studio uses `/v1/chat/completions`
- **TOOLS pane (VLM)** — drop an image into the 110px drop zone, select a task (Describe Image / Create Prompt / Create Tags), and click Run to analyze with a vision model; result shown in the output area with a Copy button
- **TOOLS pane (Wildcards)** (v0.3.40) — select "Create wildcards" from the task dropdown; enter a category name and count; click Run to generate plain-text wildcard entries one per line (no markdown, no numbering); result can be copied directly into wildcard `.txt` files
- **Settings pane** — choose backend (Ollama / LM Studio), set the API URL, test connection, select a model (with refresh button), and configure Free language names for translation source and destination
- **Settings shared** — settings saved to `localStorage` under `wfm_ai_settings`; shared with the Library panel's AI TOOL tab so configuration is consistent across both interfaces
- **Backend support** — Ollama (`/api/generate` for text, `/api/tags` for model list); LM Studio OpenAI-compatible API (`/v1/chat/completions`, `/v1/models`); VLM images sent as base64 (`images:[]` for Ollama, `image_url` content block for LM Studio)
- **Backend support** — Ollama (`/api/generate` for text, `/api/chat` for conversations, `/api/tags` for model list); LM Studio OpenAI-compatible API (`/v1/chat/completions`, `/v1/models`); VLM images sent as base64 (`images:[]` for Ollama, `image_url` content block for LM Studio)
- **URL security** — backend URL validated via `new URL()` to enforce `http://` or `https://` scheme
### Workflow Studio Library (ComfyUI Side Panel) (v0.3.9)
@@ -181,13 +228,14 @@ Requires the **[comfyui-image-feeder](https://github.com/ketle-man/comfyui-image
- **M — Models tab** — browse installed models (All / ★ Favorites / Groups / By Type sub-tabs); LoRA groups show an **All N LoRAs** item — drag to canvas to place a `Lora Loader (LoraManager)` node with all LoRAs pre-loaded
- **P — Prompts tab** — browse prompt presets with All / ★ Favorites / Categories sub-tabs; **Groups sub-tab** (row 2) — view presets by group (shared with the Batch tab's `wfm_prompt_preset_groups`)
- **I — Information tab** — drop a ComfyUI-generated PNG/WebP or workflow JSON in the side panel to view its metadata; detects LoRAs from `LoraLoader`, `LoraLoaderModelOnly`, and `Lora Loader (LoraManager)` nodes (API format supported); supports `UnetLoaderGGUF` and `QuadrupleCLIPLoader` node types; preview area fixed at 110px
- **A — AI TOOL tab** — 3-pane layout (Translation | TOOLS | Settings) always visible; Translation and TOOLS (VLM) powered by Ollama or LM Studio; settings (backend, URL, model) shared with the SPA AI TOOL tab via `localStorage`
- **A — AI TOOL tab** — Translation, Chat, TOOLS, and Settings sub-tabs powered by Ollama or LM Studio; Chat supports multi-turn conversations (full history sent each turn); TOOLS includes VLM image analysis and wildcard generation; settings (backend, URL, model) shared with the SPA AI TOOL tab via `localStorage`
- **model sub-tab** — Checkpoint, VAE, Diffusion Model, and Text Encoder; drag items to canvas to place the corresponding loader node (Checkpoint → `CheckpointLoaderSimple`, VAE → `VAELoader`, Diffusion Model → `UNETLoader`, Text Encoder → `CLIPLoader`); double-click also places at canvas center
- **lora sub-tab** — detects LoRAs from `LoraLoader`, `LoraLoaderModelOnly`, and `Lora Loader (LoraManager)` nodes (API format `inputs.loras.__value__` supported); shows `strength_model / strength_clip` values; drag individual LoRA to place `LoraLoader`; **Multiple LORA** section (appears for 1+ LoRAs) drags all LoRAs into a single `Lora Loader (LoraManager)` node with LoRA syntax pre-filled
- **Prompts sub-tab** — POS / NEG badge list; drag a prompt to place `CLIPTextEncode` with text pre-filled; click any entry to view full text + Copy button
- **Drag & drop workflows** — drag a workflow onto the canvas to load it
- **Drag & drop nodes** — drag nodes/node sets onto the canvas to place them
- **Drag & drop prompts** — drag a preset onto the canvas to create a WFS_PromptText node with positive/negative prompts
- **Send to Canvas** — clicking "Send to Canvas" (Workflow tab toolbar / detail modal) or "Copy & Send Canvas" (Gallery tab JSON panel) sends the workflow directly to the ComfyUI canvas via `window.opener` (UI and API formats both supported); if Workflow Studio was opened from a bookmark instead of the ComfyUI toolbar, UI-format workflows fall back to title drag (panel title highlights blue with a green ● — drag it onto the canvas to load)
- **Copy prompts** — copy individual positive (P) or negative (N) prompts from sidebar items
- **Double-click** — load workflows or place nodes without dragging
- **Search** — search within each sub-tab to quickly find items
@@ -286,6 +334,112 @@ Click the **camera icon** (next to the W button) in ComfyUI's top bar to capture
## Changelog
### v0.3.52
- **GenerateUI Model tab — fix LoRA selection reset when switching subtabs** — applying a LoRA via "GenUI Model" button and then switching to another subTab (Prompt/Image/Settings) and back to Model caused the LoRA selector, syntax display, and trigger words to revert to the original workflow values; fixed by reading `currentVal` directly from `currentWorkflow` instead of the stale `currentAnalysis`, and by saving/restoring the Single tab's syntax and trigger words across re-renders
### v0.3.51
- **Models tab — Embedding type: GenUI PP / GenUI NP buttons** — Embedding models now show two buttons ("GenUI PP" and "GenUI NP") in the side panel nav, detail side panel, and detail modal (replacing the single "GenUI Model" button); clicking either appends `(embedding:Name:1.0)` to the Positive or Negative prompt of the loaded workflow
- **GenerateUI Prompt tab — Embeddings selector** — new section at the bottom of the Prompt tab: Filter input, model select dropdown, Weight input (default 1.0), and Paste button; Paste inserts `(embedding:Stem:weight)` at the cursor position of the last focused textarea (Positive or Negative); focus state is tracked on click/keyup/blur so the button works even after clicking away
- **GenerateUI Model tab — Hypernetwork support** — Hypernetwork section added with model selector (filter) and Strength field; applies to `HypernetworkLoader` nodes in the workflow; GenUI Model button in Models tab also triggers Hypernetwork apply
- **Models tab — fix Embedding and Hypernetwork models not shown** — `_fetchModelList` now handles the ComfyUI V3 node format (`options` key) in addition to V1/V2 formats; `fetchEmbeddings` switched from the `/embeddings` ComfyUI endpoint to the WFS backend API (`/api/wfm/models/files?type=embedding`) to avoid SPA URL routing conflicts
- **Models tab — GenUI Model button in side panel nav** — "GenUI Model" button added to the tab navigation bar (Info / Group / CivitAI) of the side panel; appears for supported model types (Checkpoint, LoRA, VAE, etc.) and hides for unsupported types; Embedding type shows PP/NP nav buttons instead
### v0.3.50
- **Gallery tab — fix prompt search causing ComfyUI hang under large folders** — the v0.3.49 on-demand metadata read ran synchronously on the aiohttp event loop, blocking ComfyUI when folders contained many uncached images; fixed by: (1) removing on-demand reads from `list_images()`; (2) wrapping `list_images()` in `asyncio.to_thread()` to keep the event loop free; (3) adding a background indexer (`start_background_index`) that automatically indexes uncached images after a folder is loaded — processes 10 images per batch with a 50 ms sleep between batches; cancellable on folder switch
### v0.3.49
- **GenerateUI tab — A1111-style SPA-side wildcard expansion** — when prompt text in non-ImpactWildcard nodes (e.g. CLIPTextEncode) contains `__name__` syntax, the SPA expands it at generation time by randomly picking a line from the matching file in the WFS wildcard folder; nested wildcards are re-expanded up to 5 passes; unresolved wildcards are passed through unchanged; ImpactWildcardEncode/Processor nodes are skipped (handled server-side by Impact Pack); works in both single and batch generation
- **Gallery tab — fix Export button missing label** — the bulk action bar's Export button had no text label because the `textContent` assignment was missing from `updateUITexts()`; fixed by adding the `galleryBulkExport` i18n key assignment alongside the existing Move/Delete entries
- **Gallery tab — fix prompt search not matching images with no cached index** — `prompt_cache` was only built when an image was opened in the detail panel; A1111 images (or any images never opened) were invisible to prompt search; now when search is active and `prompt_cache` is empty, the image file is read on-demand and the cache is populated and persisted for future searches
### v0.3.48
- **Gallery tab — single image download** — hover over a detail-panel preview image to reveal a download overlay (⬇ icon); click to download the original file with its original filename preserved
- **Gallery tab — bulk export to ZIP** — multiple selected images can be exported as a ZIP archive via the "Export" button in the bulk action bar; filename: `gallery_export_<timestamp>.zip`; backend: `POST /wfm/gallery/images/export-zip` with path-traversal protection
### v0.3.47
- **Models tab — fix stale group state after file move** — when models were moved to a subdirectory via "Move To...", `state.modelGroups` in the JS client was not updated to reflect the new model paths; the group filter view would lose the moved models immediately after the operation. Now the client-side group membership is updated in sync with the server-side rename (mirrors the existing Python `move_models` logic). Generate tab Batch groups are unaffected as they always fetch fresh from the server.
### v0.3.46
- **Prompt tab AI Assistant — LM Studio support** — switched from Python proxy (`/api/wfm/ollama/*`) to direct browser-to-backend API calls (same pattern as the AI TOOL tab); supports Ollama (`/api/chat`) and LM Studio (`/v1/chat/completions`); image attachments are automatically converted to the correct format per backend
- **Settings tab — AI Assistant Settings (Prompt Tab)** — renamed from "Ollama Settings"; added backend selector (Ollama / LM Studio), URL input with per-backend placeholder, model select with Refresh, and Test button; settings saved to localStorage `wfm_prompt_ai_settings` (independent of AI TOOL tab settings)
- **Auto-refresh on backend change** — if the backend is switched in Settings tab while Prompt tab is already open, `sendMessage()` now detects the mismatch and automatically re-fetches the model list before sending; model status shows the active backend name (`[ollama]` / `[lmstudio]`)
- **Help text updated** (EN/JA/ZH) — Prompt tab, Settings tab, and Troubleshooting sections updated to reflect Ollama / LM Studio dual-backend support
### v0.3.45
- **Group auto-cleanup — Models tab** — stale group entries (models that no longer exist on disk) are automatically removed when the Models tab is loaded or the model type is switched; models moved within the app via "Move To..." also update their group membership immediately
- **Group auto-cleanup — Gallery tab (folder view)** — metadata entries for missing files are cleaned up each time a folder is scanned (`list_images`), synchronized with the 60s TTL + folder-mtime cache
- **Group auto-cleanup — Gallery tab (group image list)** — `list_images_in_group` (used by the Feeder tab Gallery mode) now filters out non-existent paths and removes them from the group in a single write operation
- **Gallery tab — Shift+click range selection** — Shift+click selects all images between the last clicked item (anchor) and the current item; works in both thumbnail and table views; anchor is updated on Ctrl+click and regular click; resets on folder change, image reload, and Deselect All; help text updated (EN/JA/ZH)
### v0.3.44
- **Gallery tab — server-side thumbnail generation** — `GET /wfm/gallery/image/thumb?path=...&w=256` endpoint generates 256px JPEG thumbnails via Pillow and caches them to `data/thumb_cache/` keyed by `md5(path:mtime:width)`; GIF served as-is to preserve animation; falls back to the original file if Pillow is unavailable; thumbnail view and table view both switched from `/image/serve` to `/image/thumb`
- **Gallery tab — infinite-scroll paging** — thumbnail view renders 50 images initially; an IntersectionObserver sentinel (rootMargin 300px) appends the next page on scroll; sentinel is disconnected and removed when all images are rendered; paging resets on every `renderImages()` call (folder change, filter, sort)
- **Gallery tab — bulk API endpoints** — `POST /wfm/gallery/bulk/favorite` and `POST /wfm/gallery/bulk/group` handle favorite set and group add/remove for any number of images in a single request; replaced N-parallel individual fetches in `bulkSetFavorite()` and `bulkAddToGroup()`
- **Gallery tab — image compare mode** — Ctrl+click 2–4 images, then click "Compare" in the Bulk Bar to open a side-by-side lightbox; CSS grid adapts to the image count via `--compare-cols` custom property; close button is `position:fixed` at the top-right corner to avoid `overflow:auto` clipping
- **Gallery tab — "Remove from Group" bulk button** — new button in the Bulk Bar (right of "Add to Group"); uses the same group selector dropdown; calls `POST /wfm/gallery/bulk/group` with `action:"remove"`
- **Gallery tab — bulk bar UI labels** — dropdown placeholder "Add to Group..." → "Select Group"; "Add" button → "Add to Group"; "Delete" button → "Delete File" (distinguishes file deletion from group removal)
- **Gallery tab — prompt search** — text search now covers A1111 `parameters` text embedded in PNG/JPEG metadata; prompt text is extracted on first detail-panel open and stored as `prompt_cache` in `metadata.json`; subsequent `list_images` searches include `prompt_cache` without re-reading image files
- **Help tab — Gallery mode i18n** — Feeder subtab Gallery mode section (h4, description, 6 bullet points) now translated to Japanese and Chinese via `i18n.js`
- **Help tab — font size ×1.5** — nav items, headings, body text, link cards, and support card text all scaled up in `main.css`
- **Help tab — search box** — live search input above the nav sidebar filters matching pages and auto-clicks the first result; placeholder text localized (EN/JA/ZH)
### v0.3.43
- **Send to Canvas — direct canvas load via `window.opener`** — clicking "Send to Canvas" (Workflow tab) or "Copy & Send Canvas" (Gallery tab) now sends the workflow directly to the ComfyUI canvas without requiring a title drag; uses `window.opener.wfmReceiveWorkflow()` registered by `node_sets_menu.js` via `app.handleFile()`; both UI and API formats are supported; fallback to localStorage + title drag when `window.opener` is unavailable (e.g. opened from a bookmark), UI-format only
- **Workflow Studio Library — API-format DnD enabled** — API-format workflows in the W (Workflows) sub-tab are no longer grayed out; drag & drop and double-click now work for all formats via `app.handleFile()`
### v0.3.42
- **Feeder tab — Gallery mode** — new [Image Loop] / [Gallery] toggle in the Feeder tab; Gallery mode drives a WFS_GalleryFeeder node without any external plugin: node selector, group select, sort mode / index / seed, After Gen (Loop / Increment / Fixed), Run / Stop; center pane shows the selected group's images — click any image to jump to that index; `__Feeder__` group is auto-created on first open
- **WFS_GalleryFeeder custom node** — new ComfyUI node (Workflow Studio category) that reads images from a Gallery group and outputs one `IMAGE` at a time; inputs: `group_name`, `index`, `sort_mode` (filename_asc / filename_desc / random), `seed`; skips missing files; `IS_CHANGED` ensures re-execution on every queue
- **WFS_GalleryFeeder — ComfyUI canvas controls** — `gallery_feeder_extension.js` adds After Gen combo (loop / increment / fixed), ▶ Run button, and ■ Stop button as non-serialized widgets directly on the node in the ComfyUI canvas; manages per-node loop state with `waitForExecution()` Promise pattern; `onRemoved` hook auto-stops the loop on node deletion
- **Gallery tab — thumbnail F button** — cyan overlay button (top-left of each image card) toggles `__Feeder__` group membership; active state is always visible in cyan, inactive shows only on hover; initial state derived from `img.groups` returned by `list_images()`
- **Gallery tab — `__Feeder__` reserved group** — shown with 🔒 prefix in group dropdowns; rename and delete blocked server-side (403) and client-side (buttons disabled); **FC** toolbar button clears all group members without deleting the group
- **Security: XSS fixes in `gallery-tab.js`** — tag names, filenames, and server error messages now escaped via `escapeHtml()` before insertion into `innerHTML` (tag badge list, detail panel `alt` attributes, lightbox footer, folder tree errors, grid errors); `util.js` `escapeHtml` updated to also escape single quotes (`'` → `&#x27;`)
- **Security: path validation in `gallery_service.py`** — `save_image_meta`, `toggle_favorite`, `add_to_group`, `remove_from_group` now call `_check_path_allowed()` before any file operation; previously these four methods were missing the guard that other write methods already had
- **Security: `_init_allowed_root()` in `gallery_routes.py`** — `_allowed_root` is now initialized at module load from saved `gallery_output_dir` (falls back to ComfyUI default output dir); prevents `list_folder_tree` from overriding `_allowed_root` via a crafted `?root=` request, and also fixes serve_image returning 404 in Feeder Gallery mode before the Gallery tab is opened
- **Bug fix: WFS_GalleryFeeder seed validation error** — seed `max` changed from `0x7FFFFFFF` to `0xffffffffffffffff` (matching KSampler); `applySeedToWorkflow()` was writing values exceeding the old max, causing `value_bigger_than_max` validation failures
### v0.3.41
- **Generate UI — ImpactWildcardEncode / ImpactWildcardProcessor prompt detection** — fixed: wildcard text inputs from comfy-impact-pack nodes were not shown in the Prompt tab of Generate UI
- `CLIPTextEncodeEditPlus` node (used as the text encoder in these workflows) now correctly propagates positive/negative roles upstream to ImpactWildcard nodes via BFS
- `CLIPTextEncodeEditPlus` with an empty `text_edit` field is no longer added to `prompt_nodes` ahead of the upstream ImpactWildcard node, preventing a blank text area
- `widgets[0]` is now always written to `wildcard_text` in the API conversion step, regardless of `object_info` widget-order differences between impact-pack versions
- Static fallback mapping added for `ImpactWildcardProcessor` and `ImpactWildcardEncode` so detection works even when the ComfyUI server is offline
### v0.3.40
- **AI TOOL tab — Chat pane** — new pane (between Translation and TOOLS) for multi-turn conversation with the LLM; full conversation history sent each turn for context; Enter to send, Shift+Enter for newline; Clear button resets history; Ollama uses `/api/chat`, LM Studio uses `/v1/chat/completions`
- **AI TOOL tab — Wildcard generation** — new "Create wildcards" task in the TOOLS pane dropdown; enter a category name and count, click Run to generate plain-text entries one per line (no markdown, no numbering); output can be pasted directly into wildcard `.txt` files
- **Library A tab — Chat and Wildcards** — both features added to the side panel's A tab: Chat as a new sub-tab (Translation → Chat → TOOLS → Settings), wildcard generation as a new option in the TOOLS sub-tab dropdown
- **Help updated** — AI TOOL tab help card updated to 6 items (Chat and Wildcards added); Library panel sidepanel-16 updated; EN/JA/ZH
### v0.3.39
- **Workflow tab — Send to Canvas button** — replaced "Open in ComfyUI" (toolbar and detail modal) with "Send to Canvas"; stores the selected workflow in `localStorage` for title-drag to the canvas without opening a new browser tab
- **Gallery tab — Copy & Send Canvas button** — renamed "Copy Workflow" to "Copy & Send Canvas"; copies the embedded workflow JSON to the clipboard and simultaneously stores it for title-drag
- **Workflow Studio Library — title drag** — after "Send to Canvas" or "Copy & Send Canvas" is clicked, the "Workflow Studio Library" panel title turns blue with a green ● indicator; drag the title onto the ComfyUI canvas to load the workflow; title resets automatically after loading
### v0.3.38
- **Tagger tab** — new tab for automatic image tagging; supports WD Tagger (ONNX), SwinV2, DeepDanbooru (.h5), and Ollama VLM; 3 sub-tabs: Single (drag & drop / upload, 5 output targets), Batch (folder processing with real-time progress), DB (searchable SQLite database with CSV export)
- **Tagger single — GenUI:P button** — new button (left of "Send to Prompt") that appends generated tags to the GenerateUI positive prompt and immediately applies them to the loaded workflow; shows a warning if no workflow is loaded in GenerateUI
- **Tagger batch — Write .txt output** — new output option that creates `<filename>.txt` alongside each processed image containing all generated tags (comma-separated)
- **Gallery detail panel — Tagger button** — new action button in the Gallery detail panel opens the selected image directly in the Tagger tab for instant single-image tagging
- **Gallery detail panel layout** — tabs (Info / JSON / Groups) and action buttons (Metadata / Load GenUI / Tagger) are now on separate rows, preventing button overflow on narrow panels
- **Gallery — Save to Gallery tags fix** — tags saved from the Tagger tab were stored as a string instead of an array, causing `forEach is not a function` errors on the next Gallery refresh; now correctly stored as a string array
- **GenerateUI — ZIT/Lumina2 workflow prompt fix** — `ConditioningZeroOut` removed from the CONDITIONING passthrough set; previously it propagated the "negative" role upstream through the shared CLIPTextEncode node, marking it as "unknown" and hiding the positive prompt in the GenerateUI Input tab; ZIT (Z-Image Turbo) workflows now correctly show the positive prompt
- **Workflow analyzer — lumina2 model type** — CLIPLoader `type: "lumina2"` is now correctly classified as Z-IMAGE in the workflow type detector
### v0.3.37
- **Models tab — Select All button** — new button added to the right of "Deselect All" in the multi-select action bar; selects all models currently visible after applying the active search / filter / group filters
- **Gallery tab — Select All button** — new button added to the right of "Deselect All" in the bulk action bar; selects all images in the current folder view
- **Gallery bulk bar — i18n** — all bulk action bar buttons and the selection count were hard-coded English strings; they now use the `t()` translation system (EN / JA / ZH) so the bar respects the selected UI language
### v0.3.36
- **GenerateUI Save — overwrite protection** — saving now checks for an existing file and asks for confirmation before overwriting; if the target file is in UI format, a dedicated warning explains that saving in API format will lose the node layout
- **GenerateUI Save — Raw JSON sync** — unapplied Raw JSON edits are now included in the save (parsed and synced back to the editor); invalid JSON aborts the save with an error instead of silently saving stale content
- **GenerateUI Save — hardening** — filename is set via DOM (no HTML-attribute injection), image extensions (`.png` etc.) are stripped from the default name, and a double-submit guard prevents duplicate POSTs
- **Help i18n fixed** — v0.3.35 help text updates (Save button, table sort, JSON tab rename) were being overwritten at startup by stale i18n strings and never displayed; all help keys synced in EN / JA / ZH and new entries registered in the help ID map
- **Toast i18n** — ~115 hard-coded English toasts replaced with translated messages (~60 new shared keys in EN / JA / ZH); Settings labels for Text Size / RAW JSON Colors that displayed raw key names are now properly defined
- **Refactoring** — new shared `util.js` (`escapeHtml` unified across 5 files — the Metadata tab copy was missing `"` escaping; `readJsonStorage` / `getSettings` replace 15 direct `localStorage` parses); Models table sort now precomputes sort keys (faster on large libraries); Gallery action buttons moved off the tab-button class, removing all `!important` CSS overrides
- **README refreshed** — intro rewritten around the three pillars (Management / GenerateUI / Library side panel); new screenshots: GenUI LoRA Stack, GenUI Batch, Models Multi-select Menu; WS Library image updated
### v0.3.35
- **Models tab — Table column sort** — click any column header to sort ascending (▲), click again for descending (▼), click a third time to clear; active column name highlighted in accent color; Enable/Disable column header now labeled **E/D**
- **Gallery tab — Load GenUI button** — new button to the right of the Metadata button in the detail panel; loads the embedded ComfyUI workflow from the selected image directly into the GenerateUI tab; warning toast shown if no workflow is embedded or the format is unsupported; Metadata button restyled green, Load GenUI uses primary accent color
@@ -578,7 +732,8 @@ ComfyUI-Workflow-Studio/
│ ├── wfm.py # Main class & route registration
│ ├── config.py # Path configuration
│ ├── nodes/
│ │ └── prompt_text.py # WFS_PromptText custom node (positive/negative prompt)
│ │ ├── prompt_text.py # WFS_PromptText custom node (positive/negative prompt)
│ │ └── gallery_feeder_node.py # WFS_GalleryFeeder custom node (gallery group → IMAGE)
│ ├── routes/
│ │ ├── workflow_routes.py # Workflow CRUD & analysis API
│ │ ├── nodes_routes.py # Nodes metadata & node sets API
@@ -605,21 +760,25 @@ ComfyUI-Workflow-Studio/
│ ├── app.js # App initialization & routing
│ ├── workflow-tab.js # Workflow browser
│ ├── generate-tab.js # Generation UI
│ ├── feeder-tab.js # Feeder subtab (ImageFeeder node control + image library)
│ ├── feeder-tab.js # Feeder subtab (Image Loop + Gallery modes)
│ ├── gallery-tab.js # Gallery tab (image browser, groups, metadata)
│ ├── tagger-tab.js # Tagger tab (WD Tagger, DeepDanbooru, Ollama VLM)
│ ├── prompt-tab.js # AI assistant & presets
│ ├── metadata-tab.js # Metadata extraction & display (PNG/WebP/JSON)
│ ├── settings-tab.js # Settings panel
│ ├── comfyui-client.js # ComfyUI WebSocket/API client
│ ├── nodes-tab.js # Node browser & node sets
│ ├── models-tab.js # Model browser & CivitAI integration
│ ├── ai-tab.js # AI TOOL tab (Translation | TOOLS/VLM | Settings — Ollama / LM Studio)
│ ├── ai-tab.js # AI TOOL tab (Translation | Chat | TOOLS/VLM | Settings)
│ ├── comfyui-workflow.js # UI-to-API format conversion
│ ├── comfyui-editor.js # Dynamic parameter editor
│ ├── json-highlight.js # JSON syntax highlighting
│ ├── util.js # Shared utilities (escapeHtml, readJsonStorage, getSettings)
│ └── i18n.js # Internationalization
├── web/comfyui/
│ ├── top_menu_extension.js # ComfyUI menu bar integration
│ └── node_sets_menu.js # Workflow Studio Library side panel
│ ├── node_sets_menu.js # Workflow Studio Library side panel
│ └── gallery_feeder_extension.js # WFS_GalleryFeeder canvas widgets (After Gen / Run / Stop)
└── data/ # Fallback data dir (used when ComfyUI user/default/ is not found)
```
@@ -638,3 +797,6 @@ MIT License
- [ComfyUI-Lora-Manager](https://github.com/willmiao/ComfyUI-Lora-Manager) — Plugin architecture and UI pattern reference
- [Ollama](https://ollama.com/) for local LLM inference
- [Eagle](https://eagle.cool/) for image management
- [Pillow (PIL Fork)](https://python-pillow.org/) — server-side thumbnail generation (`data/thumb_cache/`)
- [ComfyUI-Gallery](https://github.com/PanicTitan/ComfyUI-Gallery) by PanicTitan — thumbnail grid UX reference
- [infinite-image-browsing](https://github.com/zanllp/sd-webui-infinite-image-browsing) by zanllp — thumbnail caching and index strategy reference
+4 -3
View File
@@ -9,15 +9,16 @@ WorkflowStudio.add_routes()
# Register custom nodes (isolated loading)
_NODE_MODULES = {
"WFS_PromptText": (".py.nodes.prompt_text", "WFS_PromptText"),
"WFS_PromptText": (".py.nodes.prompt_text", "WFS_PromptText", "Prompt Text (WFS)"),
"WFS_GalleryFeeder": (".py.nodes.gallery_feeder_node", "WFS_GalleryFeeder", "Gallery Feeder (WFS)"),
}
for _name, (_mod_path, _cls_name) in _NODE_MODULES.items():
for _name, (_mod_path, _cls_name, _display_name) in _NODE_MODULES.items():
try:
import importlib
_mod = importlib.import_module(_mod_path, package=__name__)
NODE_CLASS_MAPPINGS[_name] = getattr(_mod, _cls_name)
NODE_DISPLAY_NAME_MAPPINGS[_name] = "Prompt Text (WFS)"
NODE_DISPLAY_NAME_MAPPINGS[_name] = _display_name
except Exception as _e:
print(f"[WARNING] Workflow Studio: Failed to load '{_name}': {_e}")
Binary file not shown.

After

Width:  |  Height:  |  Size: 193 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 16 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 16 KiB

After

Width:  |  Height:  |  Size: 64 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 48 KiB

+5
View File
@@ -69,3 +69,8 @@ NODE_SETS_FILE = DATA_DIR / "node_sets.json"
PROMPTS_FILE = DATA_DIR / "prompts.json"
MODEL_METADATA_FILE = DATA_DIR / "model_metadata.json"
WILDCARD_DIR = DATA_DIR / "wildcard"
# Tagger
TAGGER_DB_FILE = DATA_DIR / "tagger.db"
TAGGER_SETTINGS_FILE = DATA_DIR / "tagger_settings.json"
TAGGER_MODELS_DIR = _COMFYUI_ROOT / "models" / "tagger"
+95
View File
@@ -0,0 +1,95 @@
"""WFS_GalleryFeeder – Feeds images from a gallery group into a workflow."""
import json
import random
import logging
from pathlib import Path
logger = logging.getLogger(__name__)
# Feeder専用グループ名(gallery_metadata.json 内で予約される)
FEEDER_GROUP = "__Feeder__"
class WFS_GalleryFeeder:
"""Gallery グループ内の画像をインデックス順に1枚ずつ出力するノード。"""
@classmethod
def INPUT_TYPES(cls):
return {
"required": {
"group_name": ("STRING", {"default": FEEDER_GROUP}),
"index": ("INT", {"default": 0, "min": 0, "max": 99999}),
"sort_mode": (["filename_asc", "filename_desc", "random"],),
"seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
},
}
RETURN_TYPES = ("IMAGE",)
RETURN_NAMES = ("image",)
FUNCTION = "execute"
CATEGORY = "Workflow Studio"
OUTPUT_NODE = False
@classmethod
def IS_CHANGED(cls, **kwargs):
# 毎回実行させる(インデックスが変わるため)
return float("NaN")
def execute(self, group_name: str, index: int, sort_mode: str, seed: int):
import torch
import numpy as np
from PIL import Image as PILImage
paths = self._get_sorted_paths(group_name, sort_mode, seed)
if not paths:
logger.warning("WFS_GalleryFeeder: group '%s' is empty or not found", group_name)
return (torch.zeros(1, 64, 64, 3),)
img_path = paths[index % len(paths)]
try:
img = PILImage.open(img_path).convert("RGB")
except Exception as e:
logger.error("WFS_GalleryFeeder: failed to load '%s': %s", img_path, e)
return (torch.zeros(1, 64, 64, 3),)
arr = np.array(img, dtype=np.float32) / 255.0
tensor = torch.from_numpy(arr).unsqueeze(0)
return (tensor,)
# ── 内部ヘルパー ──────────────────────────────────────────────
def _get_sorted_paths(self, group_name: str, sort_mode: str, seed: int) -> list[str]:
metadata_file = self._find_metadata_file()
if not metadata_file.exists():
return []
try:
with open(metadata_file, "r", encoding="utf-8") as f:
data = json.load(f)
except Exception as e:
logger.error("WFS_GalleryFeeder: metadata read error: %s", e)
return []
paths = [
key for key, meta in data.get("images", {}).items()
if group_name in meta.get("groups", []) and Path(key).exists()
]
if sort_mode == "filename_asc":
paths.sort(key=lambda p: Path(p).name.lower())
elif sort_mode == "filename_desc":
paths.sort(key=lambda p: Path(p).name.lower(), reverse=True)
elif sort_mode == "random":
rng = random.Random(seed)
rng.shuffle(paths)
return paths
@staticmethod
def _find_metadata_file() -> Path:
# py/nodes/ -> py/ -> plugin root -> ComfyUI/custom_nodes/ -> ComfyUI root
plugin_root = Path(__file__).resolve().parent.parent.parent
comfyui_root = plugin_root.parent.parent
user_default = comfyui_root / "user" / "default"
if user_default.is_dir():
return user_default / "Workflow-Studio" / "gallery_metadata.json"
return plugin_root / "data" / "gallery_metadata.json"
+169 -1
View File
@@ -1,6 +1,7 @@
"""
Gallery Routes - ギャラリータブ用APIエンドポイント
"""
import asyncio
import json
import mimetypes
import logging
@@ -15,26 +16,62 @@ logger = logging.getLogger(__name__)
_service = GalleryService(DATA_DIR)
def _init_allowed_root() -> None:
"""起動時に保存済みの出力ディレクトリで _allowed_root を初期化する。
Gallery タブを開く前に Feeder タブの Gallery モードが serve_image を呼んでも
404 にならないようにするために必要。"""
try:
settings_file = DATA_DIR / "settings.json"
if settings_file.exists():
with open(settings_file, "r", encoding="utf-8") as f:
settings = json.load(f)
saved_root = settings.get("gallery_output_dir", "").strip()
if saved_root and Path(saved_root).is_dir():
_service.update_output_root(saved_root)
return
except Exception as e:
logger.warning("GalleryRoutes: failed to load saved gallery root: %s", e)
# フォールバック: ComfyUI のデフォルト output フォルダ
try:
import folder_paths # type: ignore
output_dir = folder_paths.get_output_directory()
if output_dir and Path(output_dir).is_dir():
_service.update_output_root(output_dir)
except Exception as e:
logger.warning("GalleryRoutes: failed to get ComfyUI output dir: %s", e)
_init_allowed_root()
def setup_routes(app: web.Application):
app.router.add_get("/wfm/gallery/folders", list_folders)
app.router.add_get("/wfm/gallery/images", list_images)
app.router.add_get("/wfm/gallery/image/meta", get_image_meta)
app.router.add_get("/wfm/gallery/image/workflow", get_image_workflow)
app.router.add_get("/wfm/gallery/image/serve", serve_image)
app.router.add_get("/wfm/gallery/image/thumb", serve_thumb)
app.router.add_post("/wfm/gallery/image/meta", save_image_meta)
app.router.add_post("/wfm/gallery/image/favorite", toggle_favorite)
app.router.add_get("/wfm/gallery/groups", list_groups)
app.router.add_post("/wfm/gallery/groups", create_group)
app.router.add_put("/wfm/gallery/groups/{name}", rename_group)
app.router.add_delete("/wfm/gallery/groups/{name}", delete_group)
app.router.add_post("/wfm/gallery/groups/ensure", ensure_group)
app.router.add_post("/wfm/gallery/groups/{name}/add", add_to_group)
app.router.add_post("/wfm/gallery/groups/{name}/remove", remove_from_group)
app.router.add_post("/wfm/gallery/groups/{name}/clear", clear_group_images)
app.router.add_get("/wfm/gallery/groups/{name}/images", list_group_images)
# バルク操作
app.router.add_post("/wfm/gallery/bulk/favorite", bulk_favorite)
app.router.add_post("/wfm/gallery/bulk/group", bulk_group)
# フォルダ・ファイル操作
app.router.add_post("/wfm/gallery/folder", create_folder_route)
app.router.add_delete("/wfm/gallery/folder", delete_folder_route)
app.router.add_post("/wfm/gallery/images/delete", delete_images_route)
app.router.add_post("/wfm/gallery/images/move", move_images_route)
app.router.add_post("/wfm/gallery/images/export-zip", export_images_zip)
# ──────────────────────────────────────────────────────────────
@@ -69,7 +106,8 @@ async def list_images(request: web.Request) -> web.Response:
return web.json_response({"error": "folder parameter required"}, status=400)
try:
images = _service.list_images(
images = await asyncio.to_thread(
_service.list_images,
folder,
search=search,
sort_by=sort_by,
@@ -77,6 +115,9 @@ async def list_images(request: web.Request) -> web.Response:
tag_filter=tag_filter,
group_filter=group_filter,
)
# 検索なしのフォルダロード時にバックグラウンドインデックスを起動
if not search:
_service.start_background_index(folder)
return web.json_response({"images": images, "total": len(images)})
except Exception as e:
logger.error("list_images error: %s", e)
@@ -127,6 +168,70 @@ async def serve_image(request: web.Request) -> web.Response:
})
async def serve_thumb(request: web.Request) -> web.Response:
"""サムネイル配信。Pillowで縮小したJPEGをディスクキャッシュして返す。"""
path = request.rel_url.query.get("path", "")
if not path:
return web.Response(status=400)
try:
width = int(request.rel_url.query.get("w", "256"))
width = max(32, min(512, width))
except ValueError:
width = 256
thumb_path = _service.serve_thumbnail(path, width)
if thumb_path is None:
return web.Response(status=404)
ext = thumb_path.suffix.lower()
if ext in (".jpg", ".jpeg"):
content_type = "image/jpeg"
elif ext == ".gif":
content_type = "image/gif"
else:
content_type = mimetypes.guess_type(str(thumb_path))[0] or "image/jpeg"
return web.FileResponse(thumb_path, headers={
"Content-Type": content_type,
"Cache-Control": "max-age=86400",
})
# ──────────────────────────────────────────────────────────────
# バルク操作
# ──────────────────────────────────────────────────────────────
async def bulk_favorite(request: web.Request) -> web.Response:
"""POST /wfm/gallery/bulk/favorite — 複数画像のお気に入りを一括設定"""
try:
body = await request.json()
paths = body.get("paths", [])
value = bool(body.get("value", True))
if not paths:
return web.json_response({"error": "paths required"}, status=400)
result = _service.bulk_set_favorite(paths, value)
return web.json_response(result)
except Exception as e:
return web.json_response({"error": str(e)}, status=500)
async def bulk_group(request: web.Request) -> web.Response:
"""POST /wfm/gallery/bulk/group — 複数画像のグループ追加/削除を一括処理"""
try:
body = await request.json()
paths = body.get("paths", [])
group = body.get("group", "").strip()
action = body.get("action", "add") # "add" or "remove"
if not paths or not group:
return web.json_response({"error": "paths and group required"}, status=400)
if action not in ("add", "remove"):
return web.json_response({"error": "action must be 'add' or 'remove'"}, status=400)
result = _service.bulk_group_op(paths, group, action)
return web.json_response(result)
except Exception as e:
return web.json_response({"error": str(e)}, status=500)
async def save_image_meta(request: web.Request) -> web.Response:
try:
body = await request.json()
@@ -174,10 +279,15 @@ async def create_group(request: web.Request) -> web.Response:
return web.json_response({"error": str(e)}, status=500)
_RESERVED_GROUPS = {"__Feeder__"}
async def rename_group(request: web.Request) -> web.Response:
"""PUT /wfm/gallery/groups/{name} - グループ名変更"""
try:
old_name = request.match_info.get("name", "")
if old_name in _RESERVED_GROUPS:
return web.json_response({"error": f"Group '{old_name}' is reserved and cannot be renamed"}, status=403)
body = await request.json()
new_name = body.get("new_name", "").strip()
if not old_name or not new_name:
@@ -192,6 +302,8 @@ async def rename_group(request: web.Request) -> web.Response:
async def delete_group(request: web.Request) -> web.Response:
name = request.match_info.get("name", "")
if name in _RESERVED_GROUPS:
return web.json_response({"error": f"Group '{name}' is reserved and cannot be deleted"}, status=403)
ok = _service.delete_group(name)
return web.json_response({"ok": ok})
@@ -224,6 +336,28 @@ async def list_group_images(request: web.Request) -> web.Response:
return web.json_response({"images": images})
async def clear_group_images(request: web.Request) -> web.Response:
"""POST /wfm/gallery/groups/{name}/clear - グループ内の全画像を除外"""
name = request.match_info.get("name", "")
if not name:
return web.json_response({"error": "name required"}, status=400)
ok = _service.clear_group(name)
return web.json_response({"ok": ok})
async def ensure_group(request: web.Request) -> web.Response:
"""POST /wfm/gallery/groups/ensure - グループが存在しない場合のみ作成"""
try:
body = await request.json()
name = body.get("name", "").strip()
if not name:
return web.json_response({"error": "name required"}, status=400)
_service.ensure_group(name)
return web.json_response({"ok": True})
except Exception as e:
return web.json_response({"error": str(e)}, status=500)
# ──────────────────────────────────────────────────────────────
# フォルダ・ファイル操作
# ──────────────────────────────────────────────────────────────
@@ -280,3 +414,37 @@ async def move_images_route(request: web.Request) -> web.Response:
return web.json_response(result)
except Exception as e:
return web.json_response({"moved": [], "errors": [str(e)]}, status=500)
async def export_images_zip(request: web.Request) -> web.Response:
"""POST /wfm/gallery/images/export-zip - 複数画像をZIPファイルにしてダウンロード"""
import zipfile
import io
try:
body = await request.json()
paths = body.get("paths", [])
if not paths:
return web.json_response({"error": "paths required"}, status=400)
# ZIPファイルをメモリ上に作成
zip_buffer = io.BytesIO()
with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zf:
for path in paths:
file_path = Path(path)
# セキュリティ: 許可されたディレクトリ内のみ
if not _service._check_path_allowed(file_path):
continue
if file_path.exists() and file_path.is_file():
# ファイル名のみをアーカイブに入れる(パス情報は含めない)
zf.write(file_path, arcname=file_path.name)
zip_buffer.seek(0)
return web.Response(
body=zip_buffer.getvalue(),
content_type="application/zip",
headers={"Content-Disposition": "attachment; filename=gallery_export.zip"}
)
except Exception as e:
logger.error("Error exporting images to ZIP: %s", e)
return web.json_response({"error": str(e)}, status=500)
+21
View File
@@ -33,6 +33,7 @@ def setup_routes(app: web.Application):
app.router.add_post("/api/wfm/models/delete", handle_delete_models)
app.router.add_get("/api/wfm/models/subdirs", handle_get_subdirs)
app.router.add_post("/api/wfm/models/move", handle_move_models)
app.router.add_get("/api/wfm/models/files", handle_list_model_files)
# ── Model Metadata ─────────────────────────────────────────
@@ -616,3 +617,23 @@ async def handle_move_models(request: web.Request) -> web.Response:
except Exception as e:
logger.error("Error in move_models: %s", e)
return web.json_response({"error": str(e)}, status=500)
# ── Model File List ───────────────────────────────────────
async def handle_list_model_files(request: web.Request) -> web.Response:
"""GET /api/wfm/models/files?type=<model_type>
Returns sorted list of model file names (with extension) for the given type.
Used as a fallback when ComfyUI's /embeddings endpoint is not accessible.
"""
from ..services.models_service import MODEL_TYPE_FOLDER_KEYS
model_type = request.query.get("type", "")
if not model_type or model_type not in MODEL_TYPE_FOLDER_KEYS:
return web.json_response({"error": "invalid type"}, status=400)
try:
result = await asyncio.to_thread(_service.list_model_files, model_type)
return web.json_response(result)
except Exception as e:
logger.error("Error listing model files for %s: %s", model_type, e)
return web.json_response({"error": str(e)}, status=500)
+214
View File
@@ -0,0 +1,214 @@
"""Tagger API routes."""
import asyncio
import logging
from aiohttp import web
from ..config import TAGGER_DB_FILE, TAGGER_MODELS_DIR, TAGGER_SETTINGS_FILE
from ..services.tagger_db_service import TaggerDbService
from ..services.tagger_service import TaggerService
logger = logging.getLogger(__name__)
_svc = TaggerService(TAGGER_MODELS_DIR, TAGGER_SETTINGS_FILE)
_db = TaggerDbService(TAGGER_DB_FILE)
def setup_routes(app: web.Application):
app.router.add_get("/wfm/tagger/models", handle_models)
app.router.add_post("/wfm/tagger/predict", handle_predict)
app.router.add_get("/wfm/tagger/ollama/models", handle_ollama_models)
app.router.add_post("/wfm/tagger/ollama/predict", handle_ollama_predict)
app.router.add_post("/wfm/tagger/batch/start", handle_batch_start)
app.router.add_get("/wfm/tagger/batch/status", handle_batch_status)
app.router.add_post("/wfm/tagger/batch/stop", handle_batch_stop)
app.router.add_get("/wfm/tagger/db/list", handle_db_list)
app.router.add_get("/wfm/tagger/db/search", handle_db_search)
app.router.add_put("/wfm/tagger/db/{id}", handle_db_update)
app.router.add_delete("/wfm/tagger/db/{id}", handle_db_delete)
app.router.add_get("/wfm/tagger/db/export", handle_db_export)
app.router.add_post("/wfm/tagger/db/save", handle_db_save)
app.router.add_post("/wfm/tagger/write_meta", handle_write_meta)
app.router.add_get("/wfm/tagger/settings", handle_settings_get)
app.router.add_post("/wfm/tagger/settings", handle_settings_save)
async def handle_models(request: web.Request) -> web.Response:
try:
models = await asyncio.to_thread(_svc.list_models)
return web.json_response({"models": models})
except Exception as e:
logger.error("handle_models: %s", e)
return web.json_response({"error": str(e)}, status=500)
async def handle_predict(request: web.Request) -> web.Response:
try:
body = await request.json()
b64 = body.get("image_b64", "")
model = body.get("model", "")
if not b64 or not model:
return web.json_response({"error": "image_b64 and model required"}, status=400)
result = await asyncio.to_thread(
_svc.predict, b64, model,
float(body.get("threshold", 0.35)),
float(body.get("char_threshold", 0.85)),
)
return web.json_response(result)
except Exception as e:
logger.error("handle_predict: %s", e)
return web.json_response({"error": str(e)}, status=500)
async def handle_ollama_models(request: web.Request) -> web.Response:
api_url = request.rel_url.query.get("api_url", "http://127.0.0.1:11434")
try:
models = await asyncio.to_thread(_svc.ollama_models, api_url)
return web.json_response({"models": models})
except Exception as e:
return web.json_response({"error": str(e)}, status=500)
async def handle_ollama_predict(request: web.Request) -> web.Response:
try:
body = await request.json()
result = await asyncio.to_thread(
_svc.ollama_predict,
body.get("image_b64", ""),
body.get("api_url", "http://127.0.0.1:11434"),
body.get("model", ""),
body.get("prompt", ""),
int(body.get("max_tags", 40)),
)
return web.json_response(result)
except Exception as e:
return web.json_response({"error": str(e)}, status=500)
async def handle_batch_start(request: web.Request) -> web.Response:
try:
body = await request.json()
result = await asyncio.to_thread(
_svc.batch_start,
body.get("folder", ""),
body.get("model", ""),
float(body.get("threshold", 0.35)),
float(body.get("char_threshold", 0.85)),
bool(body.get("use_ollama", False)),
body.get("ollama_api", "http://127.0.0.1:11434"),
body.get("ollama_model", ""),
body.get("ollama_prompt", ""),
int(body.get("ollama_max_tags", 40)),
bool(body.get("save_db", True)),
bool(body.get("write_file", False)),
bool(body.get("write_txt", False)),
_db,
)
return web.json_response(result)
except Exception as e:
return web.json_response({"error": str(e)}, status=500)
async def handle_batch_status(request: web.Request) -> web.Response:
return web.json_response(_svc.batch_status())
async def handle_batch_stop(request: web.Request) -> web.Response:
_svc.batch_stop()
return web.json_response({"ok": True})
async def handle_db_list(request: web.Request) -> web.Response:
try:
limit = int(request.rel_url.query.get("limit", 100))
offset = int(request.rel_url.query.get("offset", 0))
rows = await asyncio.to_thread(_db.list, limit, offset)
total = await asyncio.to_thread(_db.total)
return web.json_response({"rows": rows, "total": total})
except Exception as e:
return web.json_response({"error": str(e)}, status=500)
async def handle_db_search(request: web.Request) -> web.Response:
try:
q = request.rel_url.query.get("q", "")
rows = await asyncio.to_thread(_db.search, q)
return web.json_response({"rows": rows})
except Exception as e:
return web.json_response({"error": str(e)}, status=500)
async def handle_db_update(request: web.Request) -> web.Response:
try:
row_id = int(request.match_info["id"])
body = await request.json()
await asyncio.to_thread(
_db.update, row_id,
body.get("interrogator_tags", ""),
body.get("vlm_tags", ""),
)
return web.json_response({"ok": True})
except Exception as e:
return web.json_response({"error": str(e)}, status=500)
async def handle_db_delete(request: web.Request) -> web.Response:
try:
row_id = int(request.match_info["id"])
await asyncio.to_thread(_db.delete, row_id)
return web.json_response({"ok": True})
except Exception as e:
return web.json_response({"error": str(e)}, status=500)
async def handle_db_export(request: web.Request) -> web.Response:
try:
csv_data = await asyncio.to_thread(_db.export_csv)
return web.Response(
body=csv_data.encode("utf-8"),
content_type="text/csv",
headers={"Content-Disposition": "attachment; filename=tagger_tags.csv"},
)
except Exception as e:
return web.json_response({"error": str(e)}, status=500)
async def handle_db_save(request: web.Request) -> web.Response:
try:
body = await request.json()
row_id = await asyncio.to_thread(
_db.save,
body.get("filename", ""),
body.get("interrogator_tags", ""),
body.get("vlm_tags", ""),
)
return web.json_response({"ok": True, "id": row_id})
except Exception as e:
return web.json_response({"error": str(e)}, status=500)
async def handle_write_meta(request: web.Request) -> web.Response:
try:
body = await request.json()
result = await asyncio.to_thread(
_svc.write_meta_to_file,
body.get("path", ""),
body.get("tags", ""),
)
return web.json_response(result)
except Exception as e:
return web.json_response({"error": str(e)}, status=500)
async def handle_settings_get(request: web.Request) -> web.Response:
return web.json_response(_svc.load_settings())
async def handle_settings_save(request: web.Request) -> web.Response:
try:
body = await request.json()
await asyncio.to_thread(_svc.save_settings, body)
return web.json_response({"ok": True})
except Exception as e:
return web.json_response({"error": str(e)}, status=500)
+44
View File
@@ -117,6 +117,18 @@ class GalleryMetadataStore:
result.append(key)
return result
def remove_stale_paths_from_group(self, group_name: str, stale_paths: list) -> int:
"""存在しないパスをグループから一括削除する(1回の保存で完結)"""
stale_set = {self._normalize_path(p) for p in stale_paths}
count = 0
for key, meta in self._data["images"].items():
if key in stale_set and group_name in meta.get("groups", []):
meta["groups"] = [g for g in meta["groups"] if g != group_name]
count += 1
if count:
self._save_to_disk()
return count
def get_group_member_set(self, group_name: str) -> set:
"""グループメンバーのパスをsetで返す(高速フィルタ用)"""
return {
@@ -124,6 +136,19 @@ class GalleryMetadataStore:
if group_name in meta.get("groups", [])
}
def clear_group(self, group_name: str) -> bool:
"""グループ内の全画像を除外する(グループ自体は残す)"""
for meta in self._data["images"].values():
if group_name in meta.get("groups", []):
meta["groups"] = [g for g in meta["groups"] if g != group_name]
return self._save_to_disk()
def ensure_group(self, name: str) -> bool:
"""グループが存在しない場合のみ作成する"""
if any(g["name"] == name for g in self._data.get("groups", [])):
return True
return self.create_group(name)
def delete(self, image_path: str) -> bool:
"""画像のメタデータエントリを削除する"""
key = self._normalize_path(image_path)
@@ -140,3 +165,22 @@ class GalleryMetadataStore:
self._data["images"][new_key] = self._data["images"].pop(old_key)
return self._save_to_disk()
return True
def cleanup_stale_images(self, folder_path: str, existing_paths: set) -> int:
"""folder_path 配下の存在しないファイルのメタデータを削除する。
existing_paths: そのフォルダの現在のファイルパス集合(_normalize_path 済み)
"""
folder_key = self._normalize_path(folder_path)
if not folder_key.endswith("/"):
folder_key += "/"
stale = [
key for key in self._data["images"]
if key.startswith(folder_key) and key not in existing_paths
]
if not stale:
return 0
for key in stale:
del self._data["images"][key]
self._save_to_disk()
logger.info("Cleaned up %d stale metadata entries from %s", len(stale), folder_path)
return len(stale)
+172 -5
View File
@@ -1,12 +1,14 @@
"""
Gallery Service - outputフォルダの画像管理、メタデータ閲覧
"""
import hashlib
import json
import logging
import mimetypes
import os
import re
import struct
import threading
import time
from pathlib import Path
from typing import Any
@@ -26,7 +28,7 @@ _PNG_CHUNK_MAX = 32 * 1024 * 1024
_JPEG_READ_MAX = 64 * 1024 * 1024
# フォルダキャッシュのTTL秒(フォルダmtimeが同じでも念のため)
_CACHE_TTL = 30.0
_CACHE_TTL = 60.0
class _FolderCache:
@@ -72,17 +74,82 @@ class GalleryService:
self.metadata_store = GalleryMetadataStore(data_dir / "gallery_metadata.json")
self._allowed_root: Path | None = None
self._folder_cache = _FolderCache()
self._bg_cancel = threading.Event()
self._bg_cancel.set() # 初期状態: キャンセル済み
def update_output_root(self, root_path: str) -> None:
"""許可するルートパスを更新する(Settings変更時に呼ぶ)"""
p = Path(root_path).resolve() if root_path else None
self._allowed_root = p
# ──────────────────────────────────────────────────────────────
# バックグラウンドインデックス
# ──────────────────────────────────────────────────────────────
def start_background_index(self, folder_path: str) -> None:
"""フォルダ内の未キャッシュ画像をバックグラウンドでインデックスする。
フォルダロード時に呼び出す。前回のインデックス処理は自動キャンセル。"""
self._bg_cancel.set() # 前のスレッドをキャンセル
cancel = threading.Event()
self._bg_cancel = cancel
t = threading.Thread(
target=self._bg_index_folder,
args=(folder_path, cancel),
daemon=True,
)
t.start()
def _bg_index_folder(self, folder_path: str, cancel: threading.Event) -> None:
"""バックグラウンドスレッドで未キャッシュ画像のprompt_cacheを構築する。
10枚処理するたびに50msスリープしてメインスレッドへの影響を最小化。"""
try:
folder = Path(folder_path).resolve()
if not folder.is_dir() or not self._check_path_allowed(folder):
return
entries = self._scan_folder(folder)
batch: dict[str, dict] = {}
processed = 0
for name, abs_path, _, _ in entries:
if cancel.is_set():
return
ext = Path(name).suffix.lower()
if ext not in (".png", ".jpg", ".jpeg"):
continue
meta = self.metadata_store.get(abs_path)
if meta.get("prompt_cache"):
continue
embedded: dict = {}
if ext == ".png":
embedded = self._read_png_metadata(Path(abs_path))
else:
embedded = self._read_jpeg_metadata(Path(abs_path))
if not embedded:
continue
prompt_cache = " ".join(
str(v) for k, v in embedded.items()
if k != "workflow" and isinstance(v, str) and len(v) < 50_000
).strip()
if not prompt_cache:
continue
batch[abs_path] = {"prompt_cache": prompt_cache}
processed += 1
if len(batch) >= 10:
for p, d in batch.items():
self.metadata_store.save(p, d)
batch = {}
time.sleep(0.05) # 50ms 他の処理に譲る
if batch and not cancel.is_set():
for p, d in batch.items():
self.metadata_store.save(p, d)
if processed:
logger.debug("BG index done: %s (%d indexed)", folder_path, processed)
except Exception as e:
logger.debug("BG index error: %s", e)
def _check_path_allowed(self, path: Path) -> bool:
"""パスが許可ルート配下かチェック(パストラバーサル防止)"""
if self._allowed_root is None:
resolved = path.resolve()
return resolved == path.resolve()
return False
try:
path.resolve().relative_to(self._allowed_root)
return True
@@ -188,6 +255,10 @@ class GalleryService:
# os.scandir() でファイル情報を一括取得(stat()の個別呼び出しを排除)
raw_entries = self._scan_folder(folder)
# 孤立メタデータを自動クリーンアップ(移動・削除されたファイルの残骸を除去)
existing_paths = {abs_path for _, abs_path, _, _ in raw_entries}
self.metadata_store.cleanup_stale_images(str(folder), existing_paths)
results = []
for name, abs_path, size, mtime in raw_entries:
# グループフィルタ(サーバーサイド)
@@ -218,13 +289,14 @@ class GalleryService:
"groups": meta.get("groups", []),
}
# 検索フィルタ
# 検索フィルタ(ファイル名・メモ・タグ・キャッシュ済みプロンプト)
if search:
s = search.lower()
if not (
s in name.lower()
or s in item["memo"].lower()
or any(s in t.lower() for t in tags)
or s in meta.get("prompt_cache", "").lower()
):
continue
@@ -263,6 +335,14 @@ class GalleryService:
saved = self.metadata_store.get(str(path))
# workflow キーを除く文字列フィールドをプロンプトキャッシュとして保存(検索用)
prompt_text = " ".join(
str(v) for k, v in embedded.items()
if k != "workflow" and isinstance(v, str) and len(v) < 50_000
).strip()
if prompt_text and prompt_text != saved.get("prompt_cache", ""):
self.metadata_store.save(str(path), {"prompt_cache": prompt_text})
stat = path.stat()
return {
"filename": path.name,
@@ -385,14 +465,42 @@ class GalleryService:
# ──────────────────────────────────────────────────────────────
def save_image_meta(self, image_path: str, data: dict) -> bool:
if not self._check_path_allowed(Path(image_path).resolve()):
return False
return self.metadata_store.save(image_path, data)
def toggle_favorite(self, image_path: str) -> bool:
if not self._check_path_allowed(Path(image_path).resolve()):
return False
meta = self.metadata_store.get(image_path)
new_val = not meta.get("favorite", False)
self.metadata_store.save(image_path, {"favorite": new_val})
return new_val
def bulk_set_favorite(self, paths: list[str], value: bool) -> dict:
"""複数画像のお気に入りを一括設定する"""
ok = fail = 0
for p in paths:
if not self._check_path_allowed(Path(p).resolve()):
fail += 1
continue
if self.metadata_store.save(p, {"favorite": value}):
ok += 1
else:
fail += 1
return {"ok": ok, "fail": fail}
def bulk_group_op(self, paths: list[str], group_name: str, action: str = "add") -> dict:
"""複数画像のグループ追加 / 削除を一括処理する。action は "add" または "remove"。"""
ok = fail = 0
for p in paths:
success = self.add_to_group(p, group_name) if action == "add" else self.remove_from_group(p, group_name)
if success:
ok += 1
else:
fail += 1
return {"ok": ok, "fail": fail}
# ──────────────────────────────────────────────────────────────
# グループ管理
# ──────────────────────────────────────────────────────────────
@@ -410,6 +518,8 @@ class GalleryService:
return self.metadata_store.delete_group(name)
def add_to_group(self, image_path: str, group_name: str) -> bool:
if not self._check_path_allowed(Path(image_path).resolve()):
return False
meta = self.metadata_store.get(image_path)
groups = meta.get("groups", [])
if group_name not in groups:
@@ -418,12 +528,26 @@ class GalleryService:
return True
def remove_from_group(self, image_path: str, group_name: str) -> bool:
if not self._check_path_allowed(Path(image_path).resolve()):
return False
meta = self.metadata_store.get(image_path)
groups = [g for g in meta.get("groups", []) if g != group_name]
return self.metadata_store.save(image_path, {"groups": groups})
def list_images_in_group(self, group_name: str) -> list[str]:
return self.metadata_store.list_images_in_group(group_name)
all_paths = self.metadata_store.list_images_in_group(group_name)
existing = [p for p in all_paths if Path(p).is_file()]
stale = [p for p in all_paths if not Path(p).is_file()]
if stale:
self.metadata_store.remove_stale_paths_from_group(group_name, stale)
logger.info("Cleaned up %d stale paths from group '%s'", len(stale), group_name)
return existing
def clear_group(self, group_name: str) -> bool:
return self.metadata_store.clear_group(group_name)
def ensure_group(self, name: str) -> bool:
return self.metadata_store.ensure_group(name)
# ──────────────────────────────────────────────────────────────
# 画像配信
@@ -540,3 +664,46 @@ class GalleryService:
logger.warning("serve_image: path not allowed: %s", p)
return None
return p
def serve_thumbnail(self, image_path: str, width: int = 256) -> Path | None:
"""縮小サムネイルのPathを返す。
ディスクキャッシュがあればそれを返し、なければPillowで生成して保存する。
GIFはアニメーション保持のため元ファイルをそのまま返す。
Pillowが使えない場合は元ファイルにフォールバック。
"""
p = Path(image_path).resolve()
if not p.is_file():
return None
if p.suffix.lower() not in IMAGE_EXTENSIONS:
return None
if not self._check_path_allowed(p):
logger.warning("serve_thumbnail: path not allowed: %s", p)
return None
# GIF はアニメーション保持のためそのまま返す
if p.suffix.lower() == ".gif":
return p
try:
mtime = int(p.stat().st_mtime * 1000)
except OSError:
return None
cache_key = hashlib.md5(f"{p}:{mtime}:{width}".encode()).hexdigest()
cache_dir = self.data_dir / "thumb_cache"
cache_dir.mkdir(exist_ok=True)
thumb_path = cache_dir / f"{cache_key}.jpg"
if thumb_path.exists():
return thumb_path
try:
from PIL import Image
with Image.open(p) as img:
img = img.convert("RGB")
img.thumbnail((width, width), Image.LANCZOS)
img.save(thumb_path, "JPEG", quality=85, optimize=True)
return thumb_path
except Exception as e:
logger.warning("serve_thumbnail: failed for %s: %s", p, e)
return p # フォールバック: 元ファイル
+81 -1
View File
@@ -23,6 +23,8 @@ _SIDECAR_EXTENSIONS = [
_DISABLED_SUFFIX = ".disabled"
_MODEL_EXTENSIONS = {".safetensors", ".ckpt", ".pt", ".pth", ".bin", ".gguf", ".pt2"}
# ComfyUI model type → folder_paths key mapping
MODEL_TYPE_FOLDER_KEYS = {
"checkpoint": "checkpoints",
@@ -110,6 +112,50 @@ class ModelsService:
self._save_metadata(data)
return entry
def _scan_model_names(self, model_type: str) -> set:
"""モデルタイプの全ファイル名をスキャンして返す(相対パス、/区切り、.disabled除く)"""
dirs = _get_model_dirs(model_type)
names = set()
for d in dirs:
if not d.is_dir():
continue
for f in d.rglob("*"):
if not f.is_file():
continue
try:
rel = str(f.relative_to(d)).replace("\\", "/")
if rel.endswith(_DISABLED_SUFFIX):
rel = rel[: -len(_DISABLED_SUFFIX)]
names.add(rel)
except ValueError:
pass
return names
def list_model_files(self, model_type: str) -> list:
"""モデルタイプのモデルファイル名をソートして返す(拡張子付き、/区切り)。
プレビュー画像やサイドカーファイルを除外し、モデル拡張子のみを返す。"""
dirs = _get_model_dirs(model_type)
seen = set()
for d in dirs:
if not d.is_dir():
continue
for f in d.rglob("*"):
if not f.is_file():
continue
name = f.name
if name.endswith(_DISABLED_SUFFIX):
name = name[: -len(_DISABLED_SUFFIX)]
if Path(name).suffix.lower() not in _MODEL_EXTENSIONS:
continue
try:
rel = str(f.relative_to(d)).replace("\\", "/")
if rel.endswith(_DISABLED_SUFFIX):
rel = rel[: -len(_DISABLED_SUFFIX)]
seen.add(rel)
except ValueError:
pass
return sorted(seen)
def get_model_groups(self, model_type=None):
data = self._load_metadata()
raw = data.get("_groups", {})
@@ -123,7 +169,23 @@ class ModelsService:
raw = {}
if model_type:
return raw.get(model_type, {})
groups = raw.get(model_type, {})
valid_names = self._scan_model_names(model_type)
cleaned = {}
dirty = False
for g_name, members in groups.items():
filtered = [m for m in members if m in valid_names]
cleaned[g_name] = filtered
if len(filtered) != len(members):
dirty = True
if dirty:
removed = sum(len(groups[g]) - len(cleaned[g]) for g in groups)
logger.info("Cleaned up %d stale group entries for model_type=%s", removed, model_type)
if not isinstance(data.get("_groups"), dict):
data["_groups"] = {}
data["_groups"][model_type] = cleaned
self._save_metadata(data)
return cleaned
return raw
def save_model_groups(self, groups, model_type):
@@ -311,6 +373,7 @@ class ModelsService:
meta_data = self._load_metadata()
meta_changed = False
renames = [] # [(old_name, new_name)]
for model_name in model_names:
if ".." in model_name:
@@ -389,11 +452,28 @@ class ModelsService:
meta_changed = True
moved.append({"from": model_name, "to": new_rel})
renames.append((model_name, new_rel))
except Exception as e:
logger.error("Error moving model %s: %s", model_name, e)
errors.append({"model": model_name, "error": str(e)})
# Update group entries for renamed/moved models
if renames:
groups_for_type = meta_data.get("_groups", {}).get(model_type, {})
groups_dirty = False
for old_name, new_name in renames:
for members in groups_for_type.values():
for i, m in enumerate(members):
if m == old_name:
members[i] = new_name
groups_dirty = True
if groups_dirty:
if not isinstance(meta_data.get("_groups"), dict):
meta_data["_groups"] = {}
meta_data["_groups"][model_type] = groups_for_type
meta_changed = True
if meta_changed:
self._save_metadata(meta_data)
+108
View File
@@ -0,0 +1,108 @@
"""Tagger タグ DB サービス(SQLite)。"""
import csv
import io
import logging
import sqlite3
from pathlib import Path
logger = logging.getLogger(__name__)
class TaggerDbService:
def __init__(self, db_file: Path):
self.db_file = db_file
self._init_db()
def _conn(self) -> sqlite3.Connection:
return sqlite3.connect(str(self.db_file))
def _init_db(self):
self.db_file.parent.mkdir(parents=True, exist_ok=True)
with self._conn() as conn:
conn.execute("""
CREATE TABLE IF NOT EXISTS images (
id INTEGER PRIMARY KEY AUTOINCREMENT,
filename TEXT,
interrogator_tags TEXT,
vlm_tags TEXT,
all_tags TEXT,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
)
""")
for sql in [
"CREATE INDEX IF NOT EXISTS idx_all_tags ON images(all_tags)",
"CREATE INDEX IF NOT EXISTS idx_filename ON images(filename)",
"CREATE INDEX IF NOT EXISTS idx_created_at ON images(created_at DESC)",
]:
conn.execute(sql)
conn.commit()
def save(self, filename: str, interrogator_tags: str, vlm_tags: str) -> int:
all_tags = ", ".join(filter(None, [interrogator_tags, vlm_tags]))
with self._conn() as conn:
cur = conn.execute(
"INSERT INTO images (filename, interrogator_tags, vlm_tags, all_tags) VALUES (?, ?, ?, ?)",
(filename, interrogator_tags, vlm_tags, all_tags),
)
conn.commit()
return cur.lastrowid
def list(self, limit: int = 100, offset: int = 0) -> list:
with self._conn() as conn:
rows = conn.execute(
"SELECT id, filename, interrogator_tags, vlm_tags, all_tags, created_at "
"FROM images ORDER BY id DESC LIMIT ? OFFSET ?",
(limit, offset),
).fetchall()
return [self._row(r) for r in rows]
def total(self) -> int:
with self._conn() as conn:
return conn.execute("SELECT COUNT(*) FROM images").fetchone()[0]
def search(self, q: str) -> list:
pattern = f"%{q}%"
with self._conn() as conn:
rows = conn.execute(
"SELECT id, filename, interrogator_tags, vlm_tags, all_tags, created_at "
"FROM images WHERE all_tags LIKE ? OR filename LIKE ? ORDER BY id DESC LIMIT 200",
(pattern, pattern),
).fetchall()
return [self._row(r) for r in rows]
def update(self, row_id: int, interrogator_tags: str, vlm_tags: str):
all_tags = ", ".join(filter(None, [interrogator_tags, vlm_tags]))
with self._conn() as conn:
conn.execute(
"UPDATE images SET interrogator_tags=?, vlm_tags=?, all_tags=? WHERE id=?",
(interrogator_tags, vlm_tags, all_tags, row_id),
)
conn.commit()
def delete(self, row_id: int):
with self._conn() as conn:
conn.execute("DELETE FROM images WHERE id=?", (row_id,))
conn.commit()
def export_csv(self) -> str:
with self._conn() as conn:
rows = conn.execute(
"SELECT id, filename, interrogator_tags, vlm_tags, all_tags, created_at FROM images ORDER BY id"
).fetchall()
buf = io.StringIO()
writer = csv.writer(buf)
writer.writerow(["id", "filename", "interrogator_tags", "vlm_tags", "all_tags", "created_at"])
writer.writerows(rows)
return buf.getvalue()
@staticmethod
def _row(r) -> dict:
return {
"id": r[0],
"filename": r[1] or "",
"interrogator_tags": r[2] or "",
"vlm_tags": r[3] or "",
"all_tags": r[4] or "",
"created_at": r[5] or "",
}
+402
View File
@@ -0,0 +1,402 @@
"""WD Tagger / DeepDanbooru / Ollama VLM 推論サービス。"""
import base64
import csv
import io
import json
import logging
import tempfile
import threading
import urllib.request
from pathlib import Path
from typing import Optional
import numpy as np
from PIL import Image, ImageOps, PngImagePlugin
logger = logging.getLogger(__name__)
_model_lock = threading.Lock()
class TaggerService:
def __init__(self, models_dir: Path, settings_file: Path):
self.models_dir = models_dir
self.settings_file = settings_file
self._cache: dict = {}
self._batch_state: dict = {
"running": False, "total": 0, "done": 0, "log": [], "stop": False,
}
# ── 設定 ──────────────────────────────────────────────────
def load_settings(self) -> dict:
if self.settings_file.exists():
try:
with open(self.settings_file, "r", encoding="utf-8") as f:
return json.load(f)
except Exception:
pass
return {}
def save_settings(self, data: dict):
self.settings_file.parent.mkdir(parents=True, exist_ok=True)
with open(self.settings_file, "w", encoding="utf-8") as f:
json.dump(data, f, ensure_ascii=False, indent=2)
def _effective_models_dir(self) -> Path:
custom = self.load_settings().get("models_dir", "").strip()
if custom:
p = Path(custom)
if p.is_dir():
return p
return self.models_dir
# ── モデル一覧 ─────────────────────────────────────────────
def list_models(self) -> list:
mdir = self._effective_models_dir()
models = []
if not mdir.is_dir():
return models
for item in sorted(mdir.iterdir()):
if not item.is_dir():
continue
exts = {f.suffix.lower() for f in item.iterdir() if f.is_file()}
if ".onnx" in exts:
models.append({"name": item.name, "type": "onnx"})
elif ".h5" in exts:
models.append({"name": item.name, "type": "deepdanbooru"})
return models
# ── モデルロード ──────────────────────────────────────────
@staticmethod
def _validate_model_name(name: str) -> bool:
"""パストラバーサル防止: セパレータ・NUL・相対参照を拒否"""
return bool(name) and "/" not in name and "\\" not in name and "\x00" not in name and name not in (".", "..")
def _load_model(self, model_name: str) -> Optional[dict]:
if not self._validate_model_name(model_name):
logger.error("Invalid model name rejected: %r", model_name)
return None
if model_name in self._cache:
return self._cache[model_name]
with _model_lock:
if model_name in self._cache:
return self._cache[model_name]
mdir = self._effective_models_dir()
model_dir = mdir / model_name
if not model_dir.is_dir():
logger.error("Model dir not found: %s", model_dir)
return None
files = list(model_dir.iterdir())
onnx = next((f for f in files if f.suffix == ".onnx"), None)
h5 = next((f for f in files if f.suffix == ".h5"), None)
if onnx:
return self._load_onnx(model_name, onnx, model_dir)
if h5:
return self._load_deepdanbooru(model_name, h5, model_dir)
logger.error("No .onnx or .h5 in %s", model_dir)
return None
def _load_onnx(self, name: str, onnx_file: Path, model_dir: Path) -> Optional[dict]:
try:
import onnxruntime as ort
providers = []
try:
import torch
if torch.cuda.is_available():
providers.append("CUDAExecutionProvider")
except ImportError:
pass
providers.append("CPUExecutionProvider")
session = ort.InferenceSession(str(onnx_file), providers=providers)
labels = self._load_labels(model_dir)
data = {
"session": session,
"labels": labels,
"input_name": session.get_inputs()[0].name,
"input_shape": session.get_inputs()[0].shape,
"type": "onnx",
}
self._cache[name] = data
logger.info("ONNX loaded: %s (%d labels)", name, len(labels))
return data
except ImportError:
logger.error("onnxruntime not installed")
return None
except Exception as e:
logger.error("ONNX load error %s: %s", name, e)
return None
def _load_deepdanbooru(self, name: str, h5_file: Path, model_dir: Path) -> Optional[dict]:
try:
import tensorflow as tf
except ImportError:
logger.warning("TensorFlow not installed — DeepDanbooru unavailable")
return None
try:
model = tf.keras.models.load_model(str(h5_file))
labels = self._load_labels(model_dir)
data = {"session": model, "labels": labels, "type": "deepdanbooru"}
self._cache[name] = data
logger.info("DeepDanbooru loaded: %s (%d labels)", name, len(labels))
return data
except Exception as e:
logger.error("DeepDanbooru load error %s: %s", name, e)
return None
def _load_labels(self, model_dir: Path) -> list:
for fname in ("selected_tags.csv", "tags.csv", "tags.txt", "tags-general.txt"):
p = model_dir / fname
if not p.exists():
continue
try:
if p.suffix == ".csv":
with open(p, "r", encoding="utf-8-sig", newline="") as f:
reader = csv.reader(f)
next(reader, None)
return [row[1] for row in reader if len(row) > 1]
else:
with open(p, "r", encoding="utf-8") as f:
return [ln.strip() for ln in f if ln.strip()]
except Exception as e:
logger.warning("Label load failed %s: %s", p, e)
return []
# ── 推論(WD Tagger / DeepDanbooru) ────────────────────
def predict(self, image_b64: str, model_name: str, threshold: float = 0.35, char_threshold: float = 0.85) -> dict:
img = self._decode_b64(image_b64)
data = self._load_model(model_name)
if data is None:
return {"error": f"Model '{model_name}' could not be loaded"}
try:
if data["type"] == "deepdanbooru":
tags = self._predict_dd(img, data, threshold, char_threshold)
else:
tags = self._predict_onnx(img, data, threshold, char_threshold)
return {"tags": ", ".join(tags), "count": len(tags)}
except Exception as e:
logger.error("predict error: %s", e)
return {"error": str(e)}
def _predict_onnx(self, img: Image.Image, data: dict, thr: float, char_thr: float) -> list:
shape = data["input_shape"]
fmt = "NHWC"
size = (224, 224)
if len(shape) == 4:
if shape[1] == 3 and isinstance(shape[2], int) and shape[2] > 0:
fmt = "NCHW"
size = (int(shape[3]), int(shape[2]))
elif shape[3] == 3 and isinstance(shape[1], int) and shape[1] > 0:
fmt = "NHWC"
size = (int(shape[2]), int(shape[1]))
img = ImageOps.exif_transpose(img)
if img.mode != "RGB":
img = img.convert("RGB")
arr = np.array(img.resize(size, Image.Resampling.LANCZOS), dtype=np.float32) / 255.0
if fmt == "NCHW":
arr = arr.transpose((2, 0, 1))
arr = np.expand_dims(arr, 0)
preds = data["session"].run(None, {data["input_name"]: arr})[0][0]
return self._filter_tags(preds, data["labels"], thr, char_thr)
def _predict_dd(self, img: Image.Image, data: dict, thr: float, char_thr: float) -> list:
img = ImageOps.exif_transpose(img)
if img.mode != "RGB":
img = img.convert("RGB")
arr = np.array(img.resize((512, 512), Image.Resampling.LANCZOS), dtype=np.float32) / 255.0
arr = np.expand_dims(arr, 0)
preds = data["session"].predict(arr)[0]
return self._filter_tags(preds, data["labels"], thr, char_thr)
def _filter_tags(self, preds, labels: list, thr: float, char_thr: float) -> list:
tags = []
for i, score in enumerate(preds):
if i >= len(labels):
break
label = labels[i]
if float(score) >= (char_thr if label.startswith("character:") else thr):
tags.append(label.replace("character:", ""))
return tags
# ── Ollama VLM ────────────────────────────────────────────
def ollama_models(self, api_url: str) -> list:
try:
req = urllib.request.Request(api_url.rstrip("/") + "/api/tags")
with urllib.request.urlopen(req, timeout=5) as resp:
data = json.loads(resp.read().decode("utf-8"))
return sorted(m["name"] for m in data.get("models", []))
except Exception as e:
logger.error("ollama_models: %s", e)
return []
def ollama_predict(self, image_b64: str, api_url: str, model: str, prompt: str, max_tags: int = 40) -> dict:
payload = json.dumps({
"model": model,
"messages": [{"role": "user", "content": prompt, "images": [image_b64]}],
"stream": False,
"options": {"temperature": 0.7, "num_ctx": 4096},
}).encode("utf-8")
try:
req = urllib.request.Request(
api_url.rstrip("/") + "/api/chat",
data=payload,
headers={"Content-Type": "application/json"},
method="POST",
)
with urllib.request.urlopen(req, timeout=180) as resp:
data = json.loads(resp.read().decode("utf-8"))
content = data.get("message", {}).get("content", "")
tags = [t.strip() for t in content.split(",") if t.strip()][:max_tags]
return {"tags": ", ".join(tags), "count": len(tags)}
except Exception as e:
logger.error("ollama_predict: %s", e)
return {"error": str(e)}
# ── ファイルメタデータ書込 ────────────────────────────────
_ALLOWED_WRITE_EXTS = {".jpg", ".jpeg", ".png", ".webp", ".bmp", ".gif"}
def write_meta_to_file(self, image_path: str, tags: str) -> dict:
path = Path(image_path).resolve()
if path.suffix.lower() not in self._ALLOWED_WRITE_EXTS:
return {"error": "Unsupported file type"}
if not path.is_file():
return {"error": f"File not found: {image_path}"}
try:
import piexif
except ImportError:
piexif = None
try:
with Image.open(path) as img:
img.load()
ext = path.suffix.lower()
if ext in (".jpg", ".jpeg") and piexif:
self._write_jpeg(img, path, tags, piexif)
elif ext == ".png":
self._write_png(img, path, tags)
else:
self._write_sidecar(path, tags)
return {"ok": True}
except Exception as e:
logger.error("write_meta: %s", e)
return {"error": str(e)}
def _write_jpeg(self, img: Image.Image, path: Path, tags: str, piexif):
exif_data = img.info.get("exif")
if exif_data:
try:
exif_dict = piexif.load(exif_data)
except Exception:
exif_dict = {"0th": {}, "Exif": {}, "1st": {}, "GPS": {}, "Interop": {}}
else:
exif_dict = {"0th": {}, "Exif": {}, "1st": {}, "GPS": {}, "Interop": {}}
exif_dict["0th"][piexif.ImageIFD.ImageDescription] = tags.encode("utf-8")
exif_bytes = piexif.dump(exif_dict)
with tempfile.NamedTemporaryFile(delete=False, suffix=path.suffix) as tmp:
tmp_path = Path(tmp.name)
img.save(str(tmp_path), "JPEG", quality=95, exif=exif_bytes)
tmp_path.replace(path)
def _write_png(self, img: Image.Image, path: Path, tags: str):
meta = PngImagePlugin.PngInfo()
for k, v in img.info.items():
if isinstance(k, str) and isinstance(v, str):
meta.add_text(k, v)
meta.add_text("Tags", tags)
with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmp:
tmp_path = Path(tmp.name)
img.save(str(tmp_path), "PNG", pnginfo=meta)
tmp_path.replace(path)
def _write_sidecar(self, path: Path, tags: str):
sidecar = path.with_suffix(".tags.json")
with open(sidecar, "w", encoding="utf-8") as f:
json.dump({"tags": tags}, f, ensure_ascii=False, indent=2)
# ── バッチ処理 ────────────────────────────────────────────
def batch_status(self) -> dict:
s = self._batch_state
return {
"running": s["running"],
"total": s["total"],
"done": s["done"],
"log": s["log"][-50:],
}
def batch_stop(self):
self._batch_state["stop"] = True
def batch_start(self, folder: str, model_name: str, threshold: float, char_threshold: float,
use_ollama: bool, ollama_api: str, ollama_model: str, ollama_prompt: str,
ollama_max_tags: int, save_db: bool, write_file: bool, write_txt: bool, db_service) -> dict:
if self._batch_state["running"]:
return {"error": "Batch already running"}
folder_path = Path(folder)
if not folder_path.is_dir():
return {"error": f"Folder not found: {folder}"}
exts = {".jpg", ".jpeg", ".png", ".webp", ".bmp", ".gif"}
files = sorted(f for f in folder_path.iterdir() if f.is_file() and f.suffix.lower() in exts)
if not files:
return {"error": "No image files found"}
self._batch_state = {
"running": True, "total": len(files), "done": 0, "log": [], "stop": False,
}
def _run():
for fpath in files:
if self._batch_state["stop"]:
self._batch_state["log"].append("Stopped.")
break
try:
with Image.open(fpath) as img:
img.load()
buf = io.BytesIO()
img.save(buf, format="PNG")
b64 = base64.b64encode(buf.getvalue()).decode("utf-8")
interrogator_tags = ""
if model_name:
res = self.predict(b64, model_name, threshold, char_threshold)
interrogator_tags = res.get("tags", "")
vlm_tags = ""
if use_ollama and ollama_model:
res2 = self.ollama_predict(b64, ollama_api, ollama_model, ollama_prompt, ollama_max_tags)
vlm_tags = res2.get("tags", "")
all_tags = ", ".join(filter(None, [interrogator_tags, vlm_tags]))
if save_db:
db_service.save(str(fpath), interrogator_tags, vlm_tags)
if write_file and all_tags:
self.write_meta_to_file(str(fpath), all_tags)
if write_txt and all_tags:
txt_path = fpath.with_suffix(".txt")
with open(txt_path, "w", encoding="utf-8") as f:
f.write(all_tags)
n = len([t for t in all_tags.split(",") if t.strip()])
self._batch_state["log"].append(f"✓ {fpath.name}: {n} tags")
except Exception as e:
self._batch_state["log"].append(f"✗ {fpath.name}: {e}")
self._batch_state["done"] += 1
self._batch_state["running"] = False
threading.Thread(target=_run, daemon=True).start()
return {"ok": True, "total": len(files)}
# ── ユーティリティ ────────────────────────────────────────
@staticmethod
def _decode_b64(b64: str) -> Image.Image:
return Image.open(io.BytesIO(base64.b64decode(b64)))
+1
View File
@@ -18,6 +18,7 @@ _CLIP_TYPE_TO_MODEL = {
"wan": "Wan",
"cosmos": "Cosmos",
"lumina": "Lumina",
"lumina2": "Z-IMAGE",
}
+2 -1
View File
@@ -61,7 +61,7 @@ class WorkflowStudio:
app.router.add_get("/wfm", serve_index_page)
# API routes
from .routes import workflow_routes, settings_routes, ollama_routes, eagle_routes, nodes_routes, prompts_routes, models_routes, gallery_routes, wildcard_routes
from .routes import workflow_routes, settings_routes, ollama_routes, eagle_routes, nodes_routes, prompts_routes, models_routes, gallery_routes, wildcard_routes, tagger_routes
workflow_routes.setup_routes(app)
settings_routes.setup_routes(app)
@@ -72,5 +72,6 @@ class WorkflowStudio:
models_routes.setup_routes(app)
gallery_routes.setup_routes(app)
wildcard_routes.setup_routes(app)
tagger_routes.setup_routes(app)
logger.info("Workflow Studio: Routes registered successfully")
+2 -2
View File
@@ -1,7 +1,7 @@
[project]
name = "comfyui-workflow-studio"
description = "A comprehensive workflow management and generation UI plugin for ComfyUI. Browse, organize, and execute workflows from a dedicated studio interface."
version = "0.3.35"
description = "A comprehensive workflow, asset management, and generation UI plugin for ComfyUI. Manage workflows, models, images, and prompts; batch generation and Image Feeder in the GenerateUI tab; library side panel with canvas drag & drop and AI tools."
version = "0.3.52"
license = "MIT"
requires-python = ">= 3.10"
dependencies = ["jinja2"]
+21
View File
@@ -0,0 +1,21 @@
# ComfyUI-Workflow-Studio - Tagger tab dependencies
#
# numpy and Pillow are already bundled with ComfyUI and do not need to be installed.
# torch is managed by ComfyUI and must NOT be pinned here.
#
# Install into ComfyUI's embedded Python:
# python_embeded\python.exe -m pip install -r requirements.txt
#
# For GPU-accelerated ONNX inference, install onnxruntime-gpu instead of onnxruntime:
# python_embeded\python.exe -m pip install onnxruntime-gpu
# -- Required for WD Tagger / SwinV2 ONNX inference --
onnxruntime>=1.16
# -- Required for JPEG EXIF tag writing --
piexif>=1.1.3
# -- Optional: DeepDanbooru (.h5 model) support --
# Omit if you do not use DeepDanbooru models.
# TensorFlow is large (~600MB) and conflicts with some CUDA setups.
# tensorflow>=2.10
+170 -19
View File
@@ -219,6 +219,43 @@
color: #fbbf24;
}
/* Feederグループボタン(サムネイルカード左上) */
.wfm-gallery-thumb-feeder-btn {
position: absolute;
top: 4px;
left: 4px;
background: rgba(0,0,0,0.5);
border: none;
border-radius: 50%;
width: 24px;
height: 24px;
font-size: 11px;
font-weight: bold;
line-height: 1;
padding: 0;
cursor: pointer;
color: rgba(255,255,255,0.6);
display: flex;
align-items: center;
justify-content: center;
opacity: 0;
transition: opacity 0.15s, color 0.15s;
}
.wfm-gallery-thumb-card:hover .wfm-gallery-thumb-feeder-btn {
opacity: 1;
}
.wfm-gallery-thumb-feeder-btn.active {
color: #38bdf8;
opacity: 1;
}
.wfm-gallery-thumb-feeder-btn:hover {
background: rgba(0,0,0,0.75);
color: #38bdf8;
}
/* テーブルビューのお気に入りボタン */
.wfm-gallery-table-fav-btn {
background: none;
@@ -378,6 +415,15 @@
flex-shrink: 0;
}
.wfm-gallery-preview-wrapper {
position: relative;
width: 100%;
height: 100%;
display: flex;
align-items: center;
justify-content: center;
}
.wfm-gallery-detail-img {
max-width: 100%;
max-height: 200px;
@@ -385,6 +431,43 @@
cursor: pointer;
}
.wfm-gallery-preview-overlay {
position: absolute;
top: 0;
left: 0;
right: 0;
bottom: 0;
background: rgba(0,0,0,0.5);
display: flex;
align-items: center;
justify-content: center;
opacity: 0;
transition: opacity 0.2s;
}
.wfm-gallery-preview-wrapper:hover .wfm-gallery-preview-overlay {
opacity: 1;
}
.wfm-gallery-download-btn {
background: var(--wfm-accent, #4f8ef7);
border: none;
border-radius: 50%;
width: 40px;
height: 40px;
font-size: 20px;
cursor: pointer;
display: flex;
align-items: center;
justify-content: center;
color: #fff;
transition: background 0.2s;
}
.wfm-gallery-download-btn:hover {
background: var(--wfm-accent-hover, #3f7fe7);
}
/* タブコンテンツ */
.wfm-gallery-detail-tab-content {
flex: 1;
@@ -602,39 +685,107 @@
background: rgba(255,255,255,0.2);
}
/* ── 詳細パネル アクションボタン (タブナビ内) ────────────────── */
/* ── 画像比較ライトボックス ──────────────────────────────────── */
.wfm-gallery-action-btn-green,
.wfm-gallery-action-btn-primary {
padding: 4px 10px !important;
border-radius: 4px !important;
border-style: solid !important;
border-width: 1px !important;
cursor: pointer !important;
font-size: 12px !important;
.wfm-lightbox-compare .wfm-lightbox-compare-inner {
position: relative;
display: flex;
flex-direction: column;
align-items: center;
max-width: 96vw;
max-height: 92vh;
overflow: auto;
}
.wfm-lightbox-compare-grid {
display: grid;
grid-template-columns: repeat(var(--compare-cols, 2), 1fr);
gap: 12px;
padding: 16px;
}
.wfm-lightbox-compare-item {
display: flex;
flex-direction: column;
align-items: center;
gap: 6px;
}
.wfm-lightbox-compare-img {
max-width: calc(92vw / var(--compare-cols, 2) - 12px);
max-height: 78vh;
object-fit: contain;
border-radius: 4px;
cursor: default;
}
.wfm-lightbox-compare-label {
color: rgba(255,255,255,0.75);
font-size: 12px;
text-align: center;
max-width: 100%;
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
}
.wfm-lightbox-compare-close {
position: fixed;
top: 16px;
right: 16px;
z-index: 10001;
}
/* ── 詳細パネル アクションボタン行 ───────────────────────────── */
.wfm-gallery-detail-action-row {
display: flex;
gap: 6px;
padding: 4px 8px;
border-bottom: 1px solid var(--wfm-border);
flex-shrink: 0;
flex-wrap: wrap;
}
/* ── 詳細パネル アクションボタン ─────────────────────────────── */
.wfm-gallery-action-btn {
padding: 4px 10px;
border-radius: 4px;
border: 1px solid;
cursor: pointer;
font-size: 12px;
white-space: nowrap;
align-self: center;
margin: 2px 3px;
color: #fff;
}
.wfm-gallery-action-btn-green {
background: var(--wfm-success, #22c55e) !important;
color: #fff !important;
border-color: var(--wfm-success, #22c55e) !important;
background: var(--wfm-success, #22c55e);
border-color: var(--wfm-success, #22c55e);
}
.wfm-gallery-action-btn-green:hover {
background: #16a34a !important;
border-color: #16a34a !important;
background: #16a34a;
border-color: #16a34a;
}
.wfm-gallery-action-btn-primary {
background: var(--wfm-primary) !important;
color: #fff !important;
border-color: var(--wfm-primary) !important;
background: var(--wfm-primary);
border-color: var(--wfm-primary);
}
.wfm-gallery-action-btn-primary:hover {
background: var(--wfm-primary-hover) !important;
border-color: var(--wfm-primary-hover) !important;
background: var(--wfm-primary-hover);
border-color: var(--wfm-primary-hover);
}
.wfm-gallery-action-btn-tagger {
background: var(--wfm-accent, #7c5cfc);
border-color: var(--wfm-accent, #7c5cfc);
}
.wfm-gallery-action-btn-tagger:hover {
background: #6a4de0;
border-color: #6a4de0;
}
/* ── ファイル操作ボタン (詳細パネル) ─────────────────────────── */
+142 -11
View File
@@ -2992,7 +2992,7 @@ body {
}
.wfm-help-sidebar {
width: 170px;
width: 220px;
flex-shrink: 0;
display: flex;
flex-direction: column;
@@ -3006,12 +3006,36 @@ body {
padding: 8px 0;
}
.wfm-help-search-wrap {
padding: 8px 8px 4px;
}
.wfm-help-search {
width: 100%;
box-sizing: border-box;
background: var(--wfm-bg);
border: 1px solid var(--wfm-border);
color: var(--wfm-text);
border-radius: 4px;
padding: 5px 8px;
font-size: 16px;
outline: none;
}
.wfm-help-search:focus {
border-color: var(--wfm-primary);
}
.wfm-help-nav-item.search-hidden {
display: none;
}
.wfm-help-nav-item {
display: block;
width: 100%;
text-align: left;
padding: 7px 14px;
font-size: 12px;
font-size: 18px;
background: none;
border: none;
border-left: 2px solid transparent;
@@ -3065,19 +3089,28 @@ body {
}
.wfm-help-card h3 {
font-size: 14px;
font-size: 21px;
font-weight: 600;
color: var(--wfm-primary);
margin-bottom: 8px;
}
.wfm-help-card h4 {
font-size: 18px;
}
.wfm-help-card p {
font-size: 20px;
line-height: 1.7;
}
.wfm-help-card ul {
margin: 0;
padding-left: 20px;
}
.wfm-help-card li {
font-size: 13px;
font-size: 20px;
color: var(--wfm-text-secondary);
line-height: 1.8;
}
@@ -3088,7 +3121,7 @@ body {
}
.wfm-help-support-card > p {
font-size: 14px;
font-size: 21px;
color: var(--wfm-text-secondary);
margin-bottom: 20px;
}
@@ -3135,18 +3168,18 @@ body {
}
.wfm-help-link-title {
font-size: 15px;
font-size: 23px;
font-weight: 600;
}
.wfm-help-link-desc {
font-size: 12px;
font-size: 18px;
color: var(--wfm-text-secondary);
margin-top: 2px;
}
.wfm-help-thanks {
font-size: 13px;
font-size: 20px;
color: var(--wfm-text-secondary);
font-style: italic;
}
@@ -5116,7 +5149,7 @@ body {
display: flex;
}
/* 3-pane layout */
/* 4-pane layout */
.wfm-ai-pane {
display: flex;
flex-direction: column;
@@ -5124,8 +5157,9 @@ body {
min-width: 0;
}
.wfm-ai-pane-translate { flex: 4; }
.wfm-ai-pane-tools { flex: 4; }
.wfm-ai-pane-translate { flex: 3; }
.wfm-ai-pane-chat { flex: 4; }
.wfm-ai-pane-tools { flex: 3; }
.wfm-ai-pane-settings { flex: 2; }
.wfm-ai-pane-header {
@@ -5300,6 +5334,25 @@ body {
margin-left: 4px;
}
/* Wildcard inputs */
.wfm-ai-wc-inputs {
display: flex;
flex-direction: column;
gap: 6px;
flex-shrink: 0;
}
.wfm-ai-wc-row {
display: flex;
align-items: center;
gap: 8px;
}
.wfm-ai-wc-count {
width: 70px;
flex-shrink: 0;
}
/* VLM Tab */
.wfm-ai-vlm-container {
display: flex;
@@ -5369,3 +5422,81 @@ body {
align-self: flex-end;
flex-shrink: 0;
}
/* Chat pane */
.wfm-ai-chat-container {
display: flex;
flex-direction: column;
flex: 1;
overflow: hidden;
min-height: 0;
padding: 8px;
gap: 8px;
}
.wfm-ai-chat-messages {
flex: 1;
overflow-y: auto;
display: flex;
flex-direction: column;
gap: 8px;
min-height: 0;
padding: 4px;
}
.wfm-ai-chat-msg {
max-width: 90%;
padding: 8px 10px;
border-radius: 8px;
font-size: 13px;
line-height: 1.5;
word-break: break-word;
white-space: pre-wrap;
}
.wfm-ai-chat-msg-user {
align-self: flex-end;
background: var(--wfm-primary);
color: #fff;
}
.wfm-ai-chat-msg-assistant {
align-self: flex-start;
background: var(--wfm-surface);
border: 1px solid var(--wfm-border);
color: var(--wfm-text);
}
.wfm-ai-chat-input-area {
display: flex;
flex-direction: column;
gap: 6px;
flex-shrink: 0;
}
.wfm-ai-chat-input {
width: 100%;
min-height: 60px;
max-height: 120px;
padding: 8px 10px;
background: var(--wfm-bg);
border: 1px solid var(--wfm-border);
border-radius: var(--wfm-radius-sm);
color: var(--wfm-text);
font-size: 13px;
font-family: inherit;
resize: none;
line-height: 1.5;
box-sizing: border-box;
}
.wfm-ai-chat-input:focus {
outline: none;
border-color: var(--wfm-primary);
}
.wfm-ai-chat-actions {
display: flex;
align-items: center;
gap: 6px;
}
+294
View File
@@ -0,0 +1,294 @@
/* ============================================================
Tagger Tab Styles
============================================================ */
/* ── サブタブナビ ────────────────────────────────────────────── */
.wfm-tagger-subtab-nav {
display: flex;
gap: 0;
border-bottom: 1px solid var(--wfm-border);
background: var(--wfm-bg-secondary);
flex-shrink: 0;
}
.wfm-tagger-subtab-btn {
padding: 8px 20px;
font-size: 13px;
font-weight: 500;
background: transparent;
border: none;
border-bottom: 2px solid transparent;
color: var(--wfm-text-secondary);
cursor: pointer;
transition: color 0.15s, border-color 0.15s;
white-space: nowrap;
}
.wfm-tagger-subtab-btn:hover {
color: var(--wfm-text);
}
.wfm-tagger-subtab-btn.active {
color: var(--wfm-primary);
border-bottom-color: var(--wfm-primary);
}
/* ── サブタブ共通 ────────────────────────────────────────────── */
.wfm-tagger-subtab {
flex: 1;
overflow-y: auto;
padding: 12px;
}
/* ── セクション ─────────────────────────────────────────────── */
.wfm-tagger-section {
background: var(--wfm-surface);
border: 1px solid var(--wfm-border);
border-radius: var(--wfm-radius);
padding: 10px 12px;
margin-bottom: 10px;
}
.wfm-tagger-section-header {
font-size: 12px;
font-weight: 600;
color: var(--wfm-text-secondary);
text-transform: uppercase;
letter-spacing: 0.05em;
margin-bottom: 8px;
}
/* ── フォームレイアウト ─────────────────────────────────────── */
.wfm-tagger-form-row {
display: flex;
align-items: center;
gap: 8px;
margin-bottom: 6px;
}
.wfm-tagger-form-row:last-child {
margin-bottom: 0;
}
.wfm-tagger-label {
font-size: 12px;
color: var(--wfm-text-secondary);
min-width: 80px;
white-space: nowrap;
}
.wfm-tagger-select {
flex: 1;
min-width: 0;
}
/* ── スライダー ─────────────────────────────────────────────── */
.wfm-tagger-slider {
flex: 1;
min-width: 0;
accent-color: var(--wfm-primary);
cursor: pointer;
}
.wfm-tagger-slider-val {
font-size: 12px;
color: var(--wfm-text-secondary);
min-width: 36px;
text-align: right;
}
/* ── Single サブタブ ─────────────────────────────────────────── */
.wfm-tagger-single-layout {
display: flex;
gap: 12px;
height: calc(100vh - var(--wfm-header-height, 96px) - 80px);
min-height: 0;
}
.wfm-tagger-image-pane {
width: 300px;
min-width: 240px;
display: flex;
flex-direction: column;
gap: 8px;
flex-shrink: 0;
}
.wfm-tagger-image-sources {
display: flex;
gap: 6px;
flex-wrap: wrap;
}
.wfm-tagger-preview-wrap {
flex: 1;
min-height: 0;
background: var(--wfm-surface);
border: 2px dashed var(--wfm-border);
border-radius: var(--wfm-radius);
display: flex;
align-items: center;
justify-content: center;
overflow: hidden;
position: relative;
transition: border-color 0.15s, background 0.15s;
cursor: pointer;
}
.wfm-tagger-preview-wrap.drag-over {
border-color: var(--wfm-primary);
background: rgba(74, 158, 255, 0.08);
}
.wfm-tagger-image-name {
font-size: 11px;
color: var(--wfm-text-secondary);
text-align: center;
word-break: break-all;
min-height: 16px;
}
.wfm-tagger-controls-pane {
flex: 1;
min-width: 0;
overflow-y: auto;
display: flex;
flex-direction: column;
gap: 0;
}
.wfm-tagger-result-actions {
display: flex;
gap: 6px;
margin-top: 6px;
flex-wrap: wrap;
}
/* ── Batch サブタブ ──────────────────────────────────────────── */
.wfm-tagger-batch-layout {
max-width: 900px;
}
.wfm-tagger-batch-cols {
display: grid;
grid-template-columns: 1fr 1fr;
gap: 10px;
}
.wfm-tagger-progress-bar-wrap {
height: 6px;
background: var(--wfm-border);
border-radius: 3px;
overflow: hidden;
}
.wfm-tagger-progress-bar {
height: 100%;
background: var(--wfm-primary);
border-radius: 3px;
transition: width 0.3s ease;
}
/* ── DB サブタブ ─────────────────────────────────────────────── */
.wfm-tagger-db-layout {
display: flex;
flex-direction: column;
height: calc(100vh - var(--wfm-header-height, 96px) - 80px);
min-height: 0;
}
.wfm-tagger-db-toolbar {
display: flex;
gap: 6px;
align-items: center;
margin-bottom: 10px;
flex-shrink: 0;
}
.wfm-tagger-db-table-wrap {
flex: 1;
overflow: auto;
border: 1px solid var(--wfm-border);
border-radius: var(--wfm-radius);
min-height: 0;
}
.wfm-tagger-db-table {
width: 100%;
border-collapse: collapse;
font-size: 12px;
}
.wfm-tagger-db-table th,
.wfm-tagger-db-table td {
padding: 6px 10px;
text-align: left;
border-bottom: 1px solid var(--wfm-border);
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis;
max-width: 220px;
}
.wfm-tagger-db-table th {
background: var(--wfm-bg-secondary);
color: var(--wfm-text-secondary);
font-weight: 600;
text-transform: uppercase;
font-size: 11px;
letter-spacing: 0.04em;
position: sticky;
top: 0;
z-index: 1;
}
.wfm-tagger-db-table tbody tr {
cursor: pointer;
transition: background 0.1s;
}
.wfm-tagger-db-table tbody tr:hover {
background: var(--wfm-surface-hover);
}
.wfm-tagger-db-table tbody tr.selected {
background: rgba(74, 158, 255, 0.15);
}
.wfm-tagger-db-edit-panel {
flex-shrink: 0;
margin-top: 10px;
background: var(--wfm-surface);
border: 1px solid var(--wfm-border);
border-radius: var(--wfm-radius);
padding: 10px 12px;
}
/* ── ユーティリティ ─────────────────────────────────────────── */
#wfm-tab-tagger {
display: none;
flex-direction: column;
height: calc(100vh - var(--wfm-header-height, 56px));
overflow: hidden;
}
#wfm-tab-tagger.active {
display: flex;
}
.wfm-placeholder {
color: var(--wfm-text-secondary);
font-size: 13px;
text-align: center;
padding: 20px;
pointer-events: none;
}
+154 -12
View File
@@ -5,6 +5,7 @@
import { showToast } from "./app.js";
import { t } from "./i18n.js";
import { readJsonStorage } from "./util.js";
const SETTINGS_KEY = "wfm_ai_settings";
@@ -19,11 +20,7 @@ const LANG_NAMES = {
// ============================================
function loadAiSettings() {
try {
return JSON.parse(localStorage.getItem(SETTINGS_KEY) || "{}");
} catch {
return {};
}
return readJsonStorage(SETTINGS_KEY);
}
function saveAiSettings(patch) {
@@ -367,6 +364,111 @@ function initSettingsTab() {
}
}
// ============================================
// Chat tab
// ============================================
async function callChat(url, backend, model, messages) {
if (backend === "ollama") {
const res = await fetch(`${url}/api/chat`, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ model, messages, stream: false }),
});
if (!res.ok) throw new Error(`HTTP ${res.status}`);
return (await res.json()).message?.content || "";
} else {
const res = await fetch(`${url}/v1/chat/completions`, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ model, messages, stream: false }),
});
if (!res.ok) throw new Error(`HTTP ${res.status}`);
return (await res.json()).choices?.[0]?.message?.content || "";
}
}
function appendChatBubble(messagesEl, role, content) {
const div = document.createElement("div");
div.className = `wfm-ai-chat-msg wfm-ai-chat-msg-${role}`;
div.textContent = content;
messagesEl.appendChild(div);
messagesEl.scrollTop = messagesEl.scrollHeight;
return div;
}
function initChatTab() {
const messagesEl = document.getElementById("wfm-ai-chat-messages");
const inputEl = document.getElementById("wfm-ai-chat-input");
const sendBtn = document.getElementById("wfm-ai-chat-send-btn");
const clearBtn = document.getElementById("wfm-ai-chat-clear-btn");
const statusEl = document.getElementById("wfm-ai-chat-status");
if (!messagesEl || !inputEl || !sendBtn) return;
let chatHistory = [];
async function sendMessage() {
const text = inputEl.value.trim();
if (!text) return;
const settings = loadAiSettings();
const { backend = "ollama", backendUrl, model } = settings;
const url = backendUrl || (backend === "ollama" ? "http://localhost:11434" : "http://localhost:1234");
if (!isValidBackendUrl(url)) {
showToast(t("aiToastInvalidUrl"), "error");
return;
}
if (!model) {
showToast(t("aiToastNoModel"), "error");
return;
}
inputEl.value = "";
inputEl.style.height = "";
chatHistory.push({ role: "user", content: text });
appendChatBubble(messagesEl, "user", text);
sendBtn.disabled = true;
statusEl.textContent = t("aiStatusChatting");
statusEl.className = "wfm-ai-trans-status wfm-ai-status-working";
try {
const reply = await callChat(url, backend, model, chatHistory);
chatHistory.push({ role: "assistant", content: reply });
appendChatBubble(messagesEl, "assistant", reply);
statusEl.textContent = "";
statusEl.className = "wfm-ai-trans-status";
} catch (err) {
chatHistory.pop();
if (messagesEl.lastChild) messagesEl.removeChild(messagesEl.lastChild);
inputEl.value = text;
statusEl.textContent = `${t("aiStatusConnectFail")}${err.message}`;
statusEl.className = "wfm-ai-trans-status wfm-ai-status-error";
showToast(t("aiToastChatFailed") + err.message, "error");
} finally {
sendBtn.disabled = false;
}
}
sendBtn.addEventListener("click", sendMessage);
inputEl.addEventListener("keydown", (e) => {
if (e.key === "Enter" && !e.shiftKey) {
e.preventDefault();
sendMessage();
}
});
clearBtn.addEventListener("click", () => {
chatHistory = [];
messagesEl.innerHTML = "";
statusEl.textContent = "";
statusEl.className = "wfm-ai-trans-status";
});
}
// ============================================
// VLM tab
// ============================================
@@ -381,11 +483,22 @@ function initVlmTab() {
const statusEl = document.getElementById("wfm-ai-vlm-status");
const resultEl = document.getElementById("wfm-ai-vlm-result");
const copyBtn = document.getElementById("wfm-ai-vlm-copy");
const wcInputs = document.getElementById("wfm-ai-wc-inputs");
const wcNameEl = document.getElementById("wfm-ai-wc-name");
const wcCountEl = document.getElementById("wfm-ai-wc-count");
if (!dropEl) return;
let vlmImage = null; // { base64, mimeType }
function updateTaskUI() {
const isWildcard = taskSel?.value === "wildcard";
dropEl.style.display = isWildcard ? "none" : "";
if (wcInputs) wcInputs.style.display = isWildcard ? "" : "none";
}
taskSel?.addEventListener("change", updateTaskUI);
updateTaskUI();
const loadImage = async (file) => {
if (!file || !file.type.startsWith("image/")) return;
vlmImage = await fileToBase64(file);
@@ -405,19 +518,47 @@ function initVlmTab() {
});
runBtn.addEventListener("click", async () => {
if (!vlmImage) { showToast(t("aiToastNoImage"), "error"); return; }
const task = taskSel?.value || "describe";
const settings = loadAiSettings();
const { backend = "ollama", backendUrl, model } = settings;
const url = backendUrl || (backend === "ollama" ? "http://localhost:11434" : "http://localhost:1234");
if (!isValidBackendUrl(url)) {
showToast(t("aiToastInvalidUrl"), "error");
return;
}
if (!isValidBackendUrl(url)) { showToast(t("aiToastInvalidUrl"), "error"); return; }
if (!model) { showToast(t("aiToastNoModel"), "error"); return; }
const task = taskSel?.value || "describe";
if (task === "wildcard") {
const name = wcNameEl?.value.trim() || "";
const count = Math.max(1, parseInt(wcCountEl?.value) || 20);
if (!name) { showToast(t("aiToastWcNoName"), "error"); return; }
runBtn.disabled = true;
statusEl.textContent = t("aiStatusRunning");
statusEl.className = "wfm-ai-trans-status wfm-ai-status-working";
resultEl.value = "";
const prompt = `Generate ${count} wildcard entries for the category "${name}". Output only plain text in English, one entry per line, no numbers, no markdown, no asterisks, no bold, nothing else.`;
try {
const result = await callLLM(url, backend, model, prompt);
resultEl.value = result.trim()
.split("\n")
.map(l => l.replace(/\*\*/g, "").replace(/^\*\s*/, "").replace(/^\d+\.\s*/, "").trim())
.filter(l => l.length > 0)
.join("\n");
statusEl.textContent = t("aiStatusDone");
statusEl.className = "wfm-ai-trans-status wfm-ai-status-ok";
} catch (err) {
statusEl.textContent = `${t("aiStatusConnectFail")}${err.message}`;
statusEl.className = "wfm-ai-trans-status wfm-ai-status-error";
showToast(t("aiToastVlmFailed") + err.message, "error");
} finally {
runBtn.disabled = false;
}
return;
}
if (!vlmImage) { showToast(t("aiToastNoImage"), "error"); return; }
runBtn.disabled = true;
statusEl.textContent = t("aiStatusRunning");
statusEl.className = "wfm-ai-trans-status wfm-ai-status-working";
@@ -450,6 +591,7 @@ function initVlmTab() {
export function initAiTab() {
initTranslateTab();
initChatTab();
initVlmTab();
initSettingsTab();
}
+87 -13
View File
@@ -4,6 +4,7 @@
*/
import { initI18n, t } from "./i18n.js";
import { getSettings } from "./util.js";
// Initialize i18n before anything else
initI18n();
@@ -90,7 +91,7 @@ function initTabs() {
function applyI18nToHtml() {
// Tab labels
const tabMap = { workflow: "tabWorkflow", nodes: "tabNodes", models: "tabModels", generate: "tabGenerate", prompt: "tabPrompt", metadata: "tabMetadata", gallery: "tabGallery", settings: "tabSettings", help: "tabHelp", ai: "tabAi" };
const tabMap = { workflow: "tabWorkflow", nodes: "tabNodes", models: "tabModels", generate: "tabGenerate", prompt: "tabPrompt", metadata: "tabMetadata", gallery: "tabGallery", settings: "tabSettings", help: "tabHelp", ai: "tabAi", tagger: "tabTagger" };
document.querySelectorAll(".wfm-tab").forEach((tab) => {
const key = tabMap[tab.dataset.tab];
if (key) tab.textContent = t(key);
@@ -114,7 +115,7 @@ function applyI18nToHtml() {
const listOpenComfyBtn = document.getElementById("wfm-list-open-comfyui-btn");
if (listOpenComfyBtn) {
listOpenComfyBtn.textContent = t("openInComfyUI");
listOpenComfyBtn.textContent = t("sendToCanvas");
if (listOpenComfyBtn.disabled) listOpenComfyBtn.title = t("selectCardFirst");
}
@@ -195,6 +196,31 @@ function applyI18nToHtml() {
if (btn.dataset.detailTab === "meta") btn.textContent = t("gallerySideMetadata");
if (btn.dataset.detailTab === "group") btn.textContent = t("modelsSideGroup");
});
const galleryBulkDeselect = document.getElementById("wfm-gallery-bulk-deselect");
if (galleryBulkDeselect) galleryBulkDeselect.textContent = t("galleryBulkDeselectAll");
const galleryBulkSelectAll = document.getElementById("wfm-gallery-bulk-select-all");
if (galleryBulkSelectAll) galleryBulkSelectAll.textContent = t("galleryBulkSelectAll");
const galleryBulkGroupSelect = document.getElementById("wfm-gallery-bulk-group-select");
if (galleryBulkGroupSelect) {
const opt = galleryBulkGroupSelect.querySelector("option[value='']");
if (opt) opt.textContent = t("galleryBulkAddToGroup");
}
const galleryBulkGroupAdd = document.getElementById("wfm-gallery-bulk-group-add");
if (galleryBulkGroupAdd) galleryBulkGroupAdd.textContent = t("galleryBulkAdd");
const galleryBulkGroupRemove = document.getElementById("wfm-gallery-bulk-group-remove");
if (galleryBulkGroupRemove) galleryBulkGroupRemove.textContent = t("galleryBulkGroupRemove");
const galleryBulkFav = document.getElementById("wfm-gallery-bulk-fav");
if (galleryBulkFav) galleryBulkFav.textContent = t("galleryBulkFavAll");
const galleryBulkUnfav = document.getElementById("wfm-gallery-bulk-unfav");
if (galleryBulkUnfav) galleryBulkUnfav.textContent = t("galleryBulkUnfavAll");
const galleryBulkMove = document.getElementById("wfm-gallery-bulk-move");
if (galleryBulkMove) galleryBulkMove.textContent = t("galleryBulkMoveTo");
const galleryBulkExport = document.getElementById("wfm-gallery-bulk-export");
if (galleryBulkExport) galleryBulkExport.textContent = t("galleryBulkExport");
const galleryBulkDelete = document.getElementById("wfm-gallery-bulk-delete");
if (galleryBulkDelete) galleryBulkDelete.textContent = t("galleryBulkDelete");
const galleryOpenTaggerBtn = document.getElementById("wfm-gallery-open-tagger-btn");
if (galleryOpenTaggerBtn) galleryOpenTaggerBtn.textContent = t("tabTagger");
// Prompt tab
const assistantHeader = document.querySelector(".wfm-prompt-split-left .wfm-prompt-split-header");
@@ -328,14 +354,21 @@ function applyI18nToHtml() {
"wfm-help-gen-8": "helpGen8", "wfm-help-gen-9": "helpGen9", "wfm-help-gen-10": "helpGen10",
"wfm-help-gen-11": "helpGen11", "wfm-help-gen-12": "helpGen12",
"wfm-help-gen-13": "helpGen13", "wfm-help-gen-14": "helpGen14",
"wfm-help-gen-15": "helpGen15",
"wfm-help-gen-15": "helpGen15", "wfm-help-gen-16": "helpGen16",
"wfm-help-feeder-title": "helpFeederTitle",
"wfm-help-feeder-desc": "helpFeederDesc",
"wfm-help-feeder-imgloop-title": "helpFeederImgloopTitle",
"wfm-help-feeder-imgloop-desc": "helpFeederImgloopDesc",
"wfm-help-feeder-1": "helpFeeder1", "wfm-help-feeder-2": "helpFeeder2",
"wfm-help-feeder-3": "helpFeeder3", "wfm-help-feeder-4": "helpFeeder4",
"wfm-help-feeder-5": "helpFeeder5", "wfm-help-feeder-6": "helpFeeder6",
"wfm-help-feeder-7": "helpFeeder7", "wfm-help-feeder-8": "helpFeeder8",
"wfm-help-feeder-9": "helpFeeder9",
"wfm-help-feeder-gal-title": "helpFeederGalTitle",
"wfm-help-feeder-gal-desc": "helpFeederGalDesc",
"wfm-help-feeder-gal-1": "helpFeederGal1", "wfm-help-feeder-gal-2": "helpFeederGal2",
"wfm-help-feeder-gal-3": "helpFeederGal3", "wfm-help-feeder-gal-4": "helpFeederGal4",
"wfm-help-feeder-gal-5": "helpFeederGal5", "wfm-help-feeder-gal-6": "helpFeederGal6",
"wfm-help-prompt-1": "helpPrompt1", "wfm-help-prompt-2": "helpPrompt2",
"wfm-help-prompt-3": "helpPrompt3", "wfm-help-prompt-4": "helpPrompt4",
"wfm-help-prompt-5": "helpPrompt5", "wfm-help-prompt-6": "helpPrompt6",
@@ -356,14 +389,21 @@ function applyI18nToHtml() {
"wfm-help-models-5": "helpModels5", "wfm-help-models-6": "helpModels6",
"wfm-help-models-7": "helpModels7", "wfm-help-models-8": "helpModels8",
"wfm-help-models-9": "helpModels9", "wfm-help-models-10": "helpModels10",
"wfm-help-models-11": "helpModels11",
"wfm-help-models-11": "helpModels11", "wfm-help-models-12": "helpModels12",
"wfm-help-gallery-title": "helpGalleryTitle",
"wfm-help-gallery-1": "helpGallery1", "wfm-help-gallery-2": "helpGallery2",
"wfm-help-gallery-3": "helpGallery3", "wfm-help-gallery-4": "helpGallery4",
"wfm-help-gallery-5": "helpGallery5", "wfm-help-gallery-6": "helpGallery6",
"wfm-help-gallery-7": "helpGallery7", "wfm-help-gallery-8": "helpGallery8",
"wfm-help-gallery-9": "helpGallery9", "wfm-help-gallery-10": "helpGallery10",
"wfm-help-gallery-11": "helpGallery11",
"wfm-help-gallery-11": "helpGallery11", "wfm-help-gallery-12": "helpGallery12",
"wfm-help-gallery-13": "helpGallery13", "wfm-help-gallery-14": "helpGallery14",
"wfm-help-tagger-title": "helpTaggerTitle",
"wfm-help-tagger-1": "helpTagger1", "wfm-help-tagger-2": "helpTagger2",
"wfm-help-tagger-3": "helpTagger3", "wfm-help-tagger-4": "helpTagger4",
"wfm-help-tagger-5": "helpTagger5", "wfm-help-tagger-6": "helpTagger6",
"wfm-help-tagger-7": "helpTagger7", "wfm-help-tagger-8": "helpTagger8",
"wfm-help-tagger-9": "helpTagger9",
"wfm-help-sidepanel-title": "helpSidepanelTitle",
"wfm-help-sidepanel-1": "helpSidepanel1", "wfm-help-sidepanel-2": "helpSidepanel2",
"wfm-help-sidepanel-3": "helpSidepanel3", "wfm-help-sidepanel-4": "helpSidepanel4",
@@ -374,6 +414,7 @@ function applyI18nToHtml() {
"wfm-help-sidepanel-13": "helpSidepanel13",
"wfm-help-sidepanel-14": "helpSidepanel14", "wfm-help-sidepanel-15": "helpSidepanel15",
"wfm-help-sidepanel-16": "helpSidepanel16",
"wfm-help-sidepanel-17": "helpSidepanel17",
"wfm-help-ai-title": "helpAiTitle",
"wfm-help-ai-1": "helpAi1", "wfm-help-ai-2": "helpAi2", "wfm-help-ai-3": "helpAi3",
"wfm-help-ai-4": "helpAi4", "wfm-help-ai-5": "helpAi5", "wfm-help-ai-6": "helpAi6",
@@ -383,7 +424,8 @@ function applyI18nToHtml() {
"wfm-help-trouble-title": "helpTroubleTitle",
"wfm-help-trouble-1": "helpTrouble1", "wfm-help-trouble-2": "helpTrouble2",
"wfm-help-trouble-3": "helpTrouble3", "wfm-help-trouble-4": "helpTrouble4",
"wfm-help-trouble-5": "helpTrouble5",
"wfm-help-trouble-5": "helpTrouble5", "wfm-help-trouble-6": "helpTrouble6",
"wfm-help-trouble-7": "helpTrouble7",
"wfm-help-support-title": "helpSupportTitle",
"wfm-help-support-desc": "helpSupportDesc",
"wfm-help-github-desc": "helpGithubDesc",
@@ -394,6 +436,41 @@ function applyI18nToHtml() {
const el = document.getElementById(id);
if (el) el.textContent = t(key);
}
// Search box placeholder
const helpSearch = document.getElementById("wfm-help-search");
if (helpSearch) {
helpSearch.placeholder = t("helpSearchPlaceholder");
helpSearch.addEventListener("input", _onHelpSearch);
}
}
function _onHelpSearch(e) {
const q = e.target.value.trim().toLowerCase();
const navItems = document.querySelectorAll("[data-help-page]");
if (!q) {
navItems.forEach(btn => btn.classList.remove("search-hidden"));
return;
}
const matchedPages = new Set();
document.querySelectorAll(".wfm-help-page").forEach(page => {
const pageId = page.id.replace("wfm-help-page-", "");
if (page.textContent.toLowerCase().includes(q)) matchedPages.add(pageId);
});
let firstBtn = null;
navItems.forEach(btn => {
const pageId = btn.dataset.helpPage;
if (matchedPages.has(pageId)) {
btn.classList.remove("search-hidden");
if (!firstBtn) firstBtn = btn;
} else {
btn.classList.add("search-hidden");
}
});
if (firstBtn && !firstBtn.classList.contains("active")) firstBtn.click();
}
// ============================================
@@ -436,19 +513,15 @@ import { initModelsTab } from "./models-tab.js";
import { initGalleryTab } from "./gallery-tab.js";
import { initMetadataTab } from "./metadata-tab.js";
import { initAiTab } from "./ai-tab.js";
import { initTaggerTab } from "./tagger-tab.js";
// Apply saved theme immediately to prevent flash of default theme
applyTheme(getSavedTheme());
// Apply saved textarea font size
// Apply saved textarea font size & JSON highlight colors
try {
const _s = JSON.parse(localStorage.getItem("wfm_settings") || "{}");
const _s = getSettings();
if (_s.textareaFontSize) applyTextareaFontSize(_s.textareaFontSize);
} catch {}
// Apply saved JSON highlight colors
try {
const _s = JSON.parse(localStorage.getItem("wfm_settings") || "{}");
applyJsonColors(_s.jsonColors);
} catch {}
@@ -478,6 +551,7 @@ document.addEventListener("DOMContentLoaded", () => {
initMetadataTab();
initGalleryTab();
initAiTab();
initTaggerTab();
console.log("Workflow Studio: App initialized");
});
+21 -11
View File
@@ -90,11 +90,16 @@ export const comfyUI = {
if (info?.[cls]?.input?.required?.[inputKey]) {
const inputDef = info[cls].input.required[inputKey];
const first = inputDef[0];
// V1: [["model1", "model2"], {}]
if (Array.isArray(first)) return first;
// Newer ComfyUI format: ["COMBO", { "values": [...] }]
// V2: ["COMBO", { "values": [...] }]
if (typeof first === "string" && Array.isArray(inputDef[1]?.values)) {
return inputDef[1].values;
}
// V3 ComfyNode: ["COMBO", { "options": [...] }]
if (typeof first === "string" && Array.isArray(inputDef[1]?.options)) {
return inputDef[1].options;
}
}
} catch {}
}
@@ -148,14 +153,17 @@ export const comfyUI = {
},
async fetchEmbeddings() {
// ComfyUI exposes embeddings via /embeddings endpoint
// Use WFS backend API (reliable, goes through same aiohttp server)
try {
const res = await fetch(`${this.baseUrl}/embeddings`);
const res = await fetch("/api/wfm/models/files?type=embedding");
if (res.ok) {
const list = await res.json();
return Array.isArray(list) ? list : [];
}
} catch {}
console.warn("[WFS] /api/wfm/models/files?type=embedding returned", res.status);
} catch (e) {
console.error("[WFS] fetchEmbeddings error:", e);
}
return [];
},
@@ -168,14 +176,16 @@ export const comfyUI = {
},
// Generation
async queuePrompt(workflow) {
async queuePrompt(workflow, extraData = null) {
const body = {
prompt: workflow,
client_id: this.clientId,
};
if (extraData) body.extra_data = extraData;
const res = await fetch(`${this.baseUrl}/prompt`, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
prompt: workflow,
client_id: this.clientId,
}),
body: JSON.stringify(body),
});
if (!res.ok) {
const err = await res.json().catch(() => ({}));
@@ -275,8 +285,8 @@ export const comfyUI = {
throw new Error("Failed to connect WebSocket");
}
// Queue prompt
const result = await this.queuePrompt(workflow);
// Queue prompt — pass workflow as extra_pnginfo so SaveImage embeds it in PNG metadata
const result = await this.queuePrompt(workflow, { extra_pnginfo: { workflow } });
this.currentPromptId = result.prompt_id;
// Track progress
+158 -4
View File
@@ -10,6 +10,8 @@ import { syncJsonHighlight } from "./json-highlight.js";
let _stackStrengths = {};
// { modelFullPath: boolean } — true = active (default)
let _stackActive = {};
// { id: string|null, selStart: number, selEnd: number }
let _lastPromptFocus = { id: null, selStart: 0, selEnd: 0 };
function _loraBasename(fullPath) {
const name = (fullPath || "").replace(/\\/g, "/").split("/").pop() || fullPath;
@@ -123,6 +125,8 @@ export const comfyEditor = {
diffusionModels: [],
textEncoders: [],
controlNets: [],
hypernetworks: [],
embeddings: [],
samplers: [],
schedulers: [],
lastError: null,
@@ -130,13 +134,15 @@ export const comfyEditor = {
async loadModelLists() {
try {
const [ckpt, vae, lora, diff, enc, cn, samp, sched] = await Promise.all([
const [ckpt, vae, lora, diff, enc, cn, hn, emb, samp, sched] = await Promise.all([
comfyUI.fetchCheckpoints(),
comfyUI.fetchVaes(),
comfyUI.fetchLoras(),
comfyUI.fetchDiffusionModels(),
comfyUI.fetchTextEncoders(),
comfyUI.fetchControlNets(),
comfyUI.fetchHypernetworks(),
comfyUI.fetchEmbeddings(),
comfyUI.fetchSamplers(),
comfyUI.fetchSchedulers(),
]);
@@ -146,6 +152,8 @@ export const comfyEditor = {
this.models.diffusionModels = diff;
this.models.textEncoders = enc;
this.models.controlNets = cn;
this.models.hypernetworks = hn;
this.models.embeddings = emb;
this.models.samplers = samp;
this.models.schedulers = sched;
this.models.lastError = null;
@@ -171,6 +179,7 @@ export const comfyEditor = {
const positiveNodes = (analysis.prompt_nodes || []).filter((n) => n.role === "positive");
const negativeNodes = (analysis.prompt_nodes || []).filter((n) => n.role === "negative");
const nodeOpts = _nodeOptions(analysis.all_nodes);
const embeddings = this.models.embeddings || [];
el.innerHTML = `
<div class="wfm-form-group">
@@ -182,7 +191,7 @@ export const comfyEditor = {
</select>
<button class="wfm-btn wfm-btn-sm" id="wfm-prompt-pos-apply">Apply</button>
</div>
<textarea class="wfm-textarea" id="wfm-prompt-pos-text" rows="8">${positiveNodes[0]?.text || ""}</textarea>
<textarea class="wfm-textarea" id="wfm-prompt-pos-text" rows="6">${positiveNodes[0]?.text || ""}</textarea>
</div>
<div class="wfm-form-group">
<label>Negative Prompt</label>
@@ -195,6 +204,18 @@ export const comfyEditor = {
</div>
<textarea class="wfm-textarea" id="wfm-prompt-neg-text" rows="6">${negativeNodes[0]?.text || ""}</textarea>
</div>
<div class="wfm-form-group" style="border-top:1px solid var(--wfm-border);margin-top:12px;padding-top:12px;">
<label>Embeddings</label>
<input type="text" class="wfm-input" id="wfm-embedding-filter" placeholder="Filter..." style="margin-bottom:4px;">
<select class="wfm-select" id="wfm-embedding-select" style="margin-bottom:4px;">
${embeddings.map((m) => `<option value="${m}">${m}</option>`).join("")}
</select>
<div style="display:flex;gap:6px;align-items:center;margin-top:4px;">
<label style="font-size:12px;white-space:nowrap;color:var(--wfm-text-secondary);">Weight</label>
<input type="number" class="wfm-input" id="wfm-embedding-weight" value="1.0" step="0.1" min="-10" max="10" style="width:70px;">
<button class="wfm-btn wfm-btn-sm" id="wfm-embedding-paste">Paste</button>
</div>
</div>
`;
document.getElementById("wfm-prompt-pos-apply")?.addEventListener("click", () => {
@@ -218,6 +239,63 @@ export const comfyEditor = {
_syncRawJson();
}
});
// Track last focused prompt textarea for Paste button
["wfm-prompt-pos-text", "wfm-prompt-neg-text"].forEach((taId) => {
const ta = document.getElementById(taId);
if (!ta) return;
["click", "keyup", "blur"].forEach((evt) => {
ta.addEventListener(evt, () => {
_lastPromptFocus = { id: taId, selStart: ta.selectionStart, selEnd: ta.selectionEnd };
});
});
});
// Embedding filter
document.getElementById("wfm-embedding-filter")?.addEventListener("input", (e) => {
const filter = e.target.value.toLowerCase();
const select = document.getElementById("wfm-embedding-select");
if (!select) return;
select.innerHTML = (this.models.embeddings || [])
.filter((m) => m.toLowerCase().includes(filter))
.map((m) => `<option value="${m}">${m}</option>`)
.join("");
});
// Embedding Paste button — inserts at cursor position of last focused prompt textarea
document.getElementById("wfm-embedding-paste")?.addEventListener("click", () => {
const select = document.getElementById("wfm-embedding-select");
if (!select?.value) return;
const rawWeight = parseFloat(document.getElementById("wfm-embedding-weight")?.value);
const weight = isNaN(rawWeight) ? 1.0 : rawWeight;
const stem = select.value.replace(/\\/g, "/").split("/").pop().replace(/\.[^.]+$/, "");
const weightStr = Number.isInteger(weight) ? `${weight}.0` : String(weight);
const syntax = `(embedding:${stem}:${weightStr})`;
const targetId = _lastPromptFocus.id === "wfm-prompt-neg-text" ? "wfm-prompt-neg-text" : "wfm-prompt-pos-text";
const promptType = targetId === "wfm-prompt-neg-text" ? "negative" : "positive";
const ta = document.getElementById(targetId);
if (!ta) return;
const selStart = _lastPromptFocus.id === targetId ? _lastPromptFocus.selStart : ta.value.length;
const selEnd = _lastPromptFocus.id === targetId ? _lastPromptFocus.selEnd : ta.value.length;
const before = ta.value.substring(0, selStart);
const after = ta.value.substring(selEnd);
const sep = before && !/[,\s]$/.test(before) ? ", " : "";
const newText = before + sep + syntax + after;
ta.value = newText;
const newCursor = selStart + sep.length + syntax.length;
ta.focus();
ta.setSelectionRange(newCursor, newCursor);
_lastPromptFocus = { id: targetId, selStart: newCursor, selEnd: newCursor };
const wfNode = (comfyUI.currentAnalysis?.prompt_nodes || []).find((n) => n.role === promptType);
if (wfNode && comfyUI.currentWorkflow?.[wfNode.id]) {
comfyUI.currentWorkflow[wfNode.id].inputs[wfNode.textKey || "text"] = newText;
_syncRawJson();
}
});
},
renderModelTab(analysis, containerId) {
@@ -230,6 +308,10 @@ export const comfyEditor = {
{ label: "Diffusion Model", key: "diffusionModels", nodes: analysis.diffusion_model_nodes, inputKey: "unet_name" },
{ label: "Text Encoder", key: "textEncoders", nodes: analysis.text_encoder_nodes, inputKey: "clip_name1" },
{ label: "ControlNet", key: "controlNets", nodes: analysis.controlnet_nodes, inputKey: "control_net_name" },
{
label: "Hypernetwork", key: "hypernetworks", nodes: analysis.hypernetwork_nodes, inputKey: "hypernetwork_name",
extras: [{ label: "Strength", inputKey: "strength", type: "number", defaultVal: 1.0, step: 0.01, min: -10, max: 10 }],
},
];
el.innerHTML = sections
@@ -239,6 +321,16 @@ export const comfyEditor = {
const targetOpts = s.nodes
.map((n) => `<option value="${n.id}">ID:${n.id} (${n.title})</option>`)
.join("");
const extrasHtml = (s.extras || []).map((ex) => {
const curVal = s.nodes?.[0]?.[ex.inputKey] ?? ex.defaultVal;
return `<div style="display:flex;gap:6px;align-items:center;margin-top:4px;">
<label style="font-size:12px;white-space:nowrap;color:var(--wfm-text-secondary);">${ex.label}</label>
<input type="${ex.type}" class="wfm-input wfm-model-extra" id="wfm-model-${s.key}-${ex.inputKey}"
data-key="${s.key}" data-input-key="${ex.inputKey}"
value="${curVal}" step="${ex.step}" min="${ex.min}" max="${ex.max}"
style="width:80px;">
</div>`;
}).join("");
return `
<div class="wfm-form-group" style="border-bottom:1px solid var(--wfm-border);padding-bottom:12px;">
@@ -247,7 +339,8 @@ export const comfyEditor = {
<select class="wfm-select" id="wfm-model-${s.key}" style="margin-bottom:4px;">
${models.map((m) => `<option value="${m}" ${m === currentVal ? "selected" : ""}>${m}</option>`).join("")}
</select>
<div style="display:flex;gap:8px;align-items:center;">
${extrasHtml}
<div style="display:flex;gap:8px;align-items:center;margin-top:4px;">
<select class="wfm-select" id="wfm-model-${s.key}-target" style="flex:1;">${targetOpts}</select>
<button class="wfm-btn wfm-btn-sm wfm-model-apply" data-key="${s.key}" data-input="${s.inputKey}">Apply</button>
</div>
@@ -284,6 +377,12 @@ export const comfyEditor = {
const nodeId = targetSelect.value;
if (nodeId && comfyUI.currentWorkflow?.[nodeId]) {
comfyUI.currentWorkflow[nodeId].inputs[inputKey] = value;
// Apply extras (e.g. strength for Hypernetwork)
el.querySelectorAll(`.wfm-model-extra[data-key="${key}"]`).forEach((ex) => {
const exInputKey = ex.dataset.inputKey;
const exVal = parseFloat(ex.value);
if (!isNaN(exVal)) comfyUI.currentWorkflow[nodeId].inputs[exInputKey] = exVal;
});
_syncRawJson();
}
});
@@ -303,7 +402,23 @@ export const comfyEditor = {
const stackTargetOpts = loraNodes
.map((n) => `<option value="${n.id}" ${String(n.id) === String(defaultStackTarget) ? "selected" : ""}>ID:${n.id} (${n.title})</option>`)
.join("");
const currentVal = loraNodes[0]?.lora_name || "";
// currentWorkflowから直接取得(applyToGenUIによる変更を正確に反映)
let currentVal = loraNodes[0]?.lora_name || "";
const _firstLoraNode = loraNodes[0];
if (_firstLoraNode && comfyUI.currentWorkflow?.[_firstLoraNode.id]) {
const _wfNode = comfyUI.currentWorkflow[_firstLoraNode.id];
if (!_firstLoraNode.is_lora_manager) {
currentVal = _wfNode.inputs?.lora_name || currentVal;
} else {
// LoraManager: loras.__value__[0].nameからフルパスを復元
const _wfLoras = _wfNode.inputs?.loras?.__value__;
if (Array.isArray(_wfLoras) && _wfLoras.length > 0) {
const _stem = _wfLoras[0].name;
const _found = (this.models.loras || []).find(m => _loraBasename(m) === _stem);
currentVal = _found || _stem;
}
}
}
// Fetch Stack group, metadata, CivitAI cache in parallel
let stackModels = [];
@@ -360,6 +475,9 @@ export const comfyEditor = {
}).join("");
const _prevActiveTab = el.querySelector(".wfm-lora-tab-btn.active")?.dataset?.tab || "single";
// applyToGenUIで設定したSingle表示の状態を保存(再描画後に復元)
const _prevSingleSyntax = document.getElementById("wfm-lora-single-syntax")?.textContent || "";
const _prevSingleTriggers = document.getElementById("wfm-lora-single-triggers")?.innerHTML || "";
el.innerHTML = `
<div class="wfm-lora-tab-header">
@@ -439,6 +557,16 @@ export const comfyEditor = {
const _synEl = document.getElementById("wfm-lora-stack-syntax");
if (_synEl) _synEl.textContent = stackLoraSyntax || "—";
// Single: applyToGenUIで設定したsyntax/triggersを復元
if (_prevSingleSyntax && _prevSingleSyntax !== "—") {
const _sEl = document.getElementById("wfm-lora-single-syntax");
if (_sEl) _sEl.textContent = _prevSingleSyntax;
}
if (_prevSingleTriggers) {
const _tEl = document.getElementById("wfm-lora-single-triggers");
if (_tEl && !_prevSingleTriggers.includes(">—<")) _tEl.innerHTML = _prevSingleTriggers;
}
// ── Tab switching ────────────────────────────────────
el.querySelectorAll(".wfm-lora-tab-btn").forEach((btn) => {
btn.addEventListener("click", () => {
@@ -917,6 +1045,32 @@ export const comfyEditor = {
});
},
appendEmbeddingToPrompt(syntax, promptType) {
const promptNodes = (comfyUI.currentAnalysis?.prompt_nodes || []).filter((n) => n.role === promptType);
const textareaId = promptType === "positive" ? "wfm-prompt-pos-text" : "wfm-prompt-neg-text";
const textarea = document.getElementById(textareaId);
if (promptNodes.length > 0 && comfyUI.currentWorkflow) {
const node = promptNodes[0];
const wfNode = comfyUI.currentWorkflow[node.id];
if (wfNode) {
const textKey = node.textKey || "text";
const current = wfNode.inputs[textKey] || "";
const newText = current ? `${current}, ${syntax}` : syntax;
wfNode.inputs[textKey] = newText;
if (textarea) textarea.value = newText;
_syncRawJson();
return;
}
}
// Fallback: update textarea only
if (textarea) {
const current = textarea.value;
textarea.value = current ? `${current}, ${syntax}` : syntax;
}
},
switchLoraSingleTab() {
const container = document.getElementById("wfm-gen-lora-fields");
if (!container) return;
+40 -3
View File
@@ -399,6 +399,14 @@ export const comfyWorkflow = {
} // end else (non-LoraManager path)
}
// ImpactWildcardEncode / ImpactWildcardProcessor: widgets[0] is always wildcard_text.
// Always overwrite: object_info ordering may misalign when widget order differs between
// impact-pack versions; widgets[0] is stable across all known versions.
if ((node.type === "ImpactWildcardEncode" || node.type === "ImpactWildcardProcessor")
&& widgets.length > 0) {
inputs["wildcard_text"] = widgets[0];
}
api[nodeId] = {
class_type: node.type,
inputs,
@@ -482,6 +490,7 @@ export const comfyWorkflow = {
text_encoder_nodes: [],
diffusion_model_nodes: [],
controlnet_nodes: [],
hypernetwork_nodes: [],
all_nodes: [],
};
@@ -520,7 +529,10 @@ export const comfyWorkflow = {
// Nodes that pass CONDITIONING through without changing positive/negative role
const COND_PASSTHROUGH = new Set([
"ConditioningCombine", "ConditioningConcat", "ConditioningAverage",
"ConditioningZeroOut", "ConditioningSetTimestepRange",
"ConditioningSetTimestepRange",
// ConditioningZeroOut is intentionally excluded: it discards upstream text entirely
// (used as a no-text negative in ZIT/Lumina2 workflows). Propagating the negative
// role upstream would incorrectly mark the shared positive CLIPTextEncode as "unknown".
"ControlNetApply", "ControlNetApplyAdvanced",
"IPAdapterApply", "IPAdapterApplyFaceID",
"StyleModelApply",
@@ -568,6 +580,16 @@ export const comfyWorkflow = {
if (isNeg) samplerNegativeRef[tv[0]] = true;
}
}
// CLIPTextEncodeEditPlus — propagate role to its STRING inputs (text1, text2)
if (ct === "CLIPTextEncodeEditPlus") {
for (const key of ["text1", "text2"]) {
const tv = inputs[key];
if (Array.isArray(tv)) {
if (isPos) samplerPositiveRef[tv[0]] = true;
if (isNeg) samplerNegativeRef[tv[0]] = true;
}
}
}
}
}
@@ -642,10 +664,12 @@ export const comfyWorkflow = {
}
}
// CLIPTextEncodeEditPlus — text_edit is the locally editable override; text1 is always a link
// CLIPTextEncodeEditPlus — text_edit is the locally editable override; text1 is always a link.
// Skip when text_edit is empty: it means upstream nodes (ImpactWildcardEncode etc.) supply
// the actual prompt text and the edit field is just an optional local override.
if (ct === "CLIPTextEncodeEditPlus") {
const textVal = inputs.text_edit;
if (typeof textVal === "string") {
if (typeof textVal === "string" && textVal !== "") {
result.prompt_nodes.push({
id, type: ct, title, role: getRole(),
text: textVal, textKey: "text_edit",
@@ -792,6 +816,15 @@ export const comfyWorkflow = {
control_net_name: inputs.control_net_name,
});
}
// --- Hypernetwork loader nodes ---
if (ct === "HypernetworkLoader") {
result.hypernetwork_nodes.push({
id, type: ct, title,
hypernetwork_name: inputs.hypernetwork_name,
strength: inputs.strength ?? 1.0,
});
}
}
result.all_nodes.sort((a, b) => Number(a.id) - Number(b.id));
@@ -851,6 +884,10 @@ function _getWidgetMapping(nodeType) {
CLIPLoader: ["clip_name", "type", "device"],
FluxGuidance: ["guidance"],
CFGNorm: ["strength"],
// Impact Pack wildcard nodes — only map wildcard_text (index 0); remaining widgets
// vary between versions and include frontend-only extras, so we leave them unmapped.
ImpactWildcardProcessor: ["wildcard_text"],
ImpactWildcardEncode: ["wildcard_text"],
};
return mappings[nodeType] || null;
}
+383 -39
View File
@@ -1,17 +1,29 @@
/**
* Feeder Tab - ImageFeeder node control with embedded image library
* Feeder Tab - ImageFeeder node control (Image Loop mode)
* + WFS_GalleryFeeder node control (Gallery mode)
*/
import { comfyUI } from "./comfyui-client.js";
import { showToast } from "./app.js";
import { t } from "./i18n.js";
import { FEEDER_GROUP, ensureFeederGroup } from "./gallery-tab.js";
// ── Module State ──────────────────────────────────────────────────
const _s = {
dir: "", // current folder relative path
images: [], // filenames in current folder
selected: new Set(),// selected filenames (across all interactions)
dir: "", // current folder relative path (loop mode)
images: [], // filenames in current folder (loop mode)
selected: new Set(),// selected filenames (loop mode)
presets: {}, // {presetName: {directory, selected_files}}
running: false, // feeder run loop active
mode: localStorage.getItem("wfm_feeder_mode") || "loop", // "loop" | "gallery"
};
// Gallery mode state
const _gs = {
groups: [], // [{name}]
group: FEEDER_GROUP, // selected group name
images: [], // absolute paths in selected group
idx: 0, // current index
};
// ── Node helpers ──────────────────────────────────────────────────
@@ -24,12 +36,40 @@ function _feederNodes() {
.map(([id, n]) => ({ id, title: n._meta?.title || `ImageFeeder` }));
}
function _galFeederNodes() {
const wf = comfyUI.currentWorkflow;
if (!wf) return [];
return Object.entries(wf)
.filter(([, n]) => n?.class_type === "WFS_GalleryFeeder")
.map(([id, n]) => ({ id, title: n._meta?.title || `GalleryFeeder` }));
}
export function refreshFeederNodeList() {
const sel = document.getElementById("wfm-feeder-node-sel");
if (_s.mode === "gallery") {
_refreshGalNodeList();
} else {
const sel = document.getElementById("wfm-feeder-node-sel");
if (!sel) return;
const nodes = _feederNodes();
if (nodes.length === 0) {
sel.innerHTML = `<option value="">-- No ImageFeeder node --</option>`;
return;
}
const prevVal = sel.value;
sel.innerHTML = nodes.map(n =>
`<option value="${n.id}">${n.title} (ID:${n.id})</option>`
).join("");
if (prevVal && nodes.find(n => n.id === prevVal)) sel.value = prevVal;
_loadFromNode(sel.value || nodes[0].id);
}
}
function _refreshGalNodeList() {
const sel = document.getElementById("wfm-feeder-gal-node-sel");
if (!sel) return;
const nodes = _feederNodes();
const nodes = _galFeederNodes();
if (nodes.length === 0) {
sel.innerHTML = `<option value="">-- No ImageFeeder node --</option>`;
sel.innerHTML = `<option value="">-- No WFS_GalleryFeeder node --</option>`;
return;
}
const prevVal = sel.value;
@@ -37,7 +77,7 @@ export function refreshFeederNodeList() {
`<option value="${n.id}">${n.title} (ID:${n.id})</option>`
).join("");
if (prevVal && nodes.find(n => n.id === prevVal)) sel.value = prevVal;
_loadFromNode(sel.value || nodes[0].id);
_loadFromGalNode(sel.value || nodes[0].id);
}
function _loadFromNode(nodeId) {
@@ -54,7 +94,6 @@ function _loadFromNode(nodeId) {
_setVal("wfm-feeder-seed", inp.seed ?? 0);
_setCheck("wfm-feeder-use-sel", inp.use_selection ?? true);
// Restore selected_files
_s.selected.clear();
try {
const arr = JSON.parse(inp.selected_files || "[]");
@@ -72,15 +111,44 @@ function _loadFromNode(nodeId) {
_updateStatus();
}
function _loadFromGalNode(nodeId) {
const wf = comfyUI.currentWorkflow;
if (!wf?.[nodeId]) return;
const inp = wf[nodeId].inputs || {};
const group = inp.group_name || FEEDER_GROUP;
_setVal("wfm-feeder-gal-sort", inp.sort_mode || "filename_asc");
_setVal("wfm-feeder-gal-index", inp.index ?? 0);
_setVal("wfm-feeder-gal-seed", inp.seed ?? 0);
_gs.idx = inp.index ?? 0;
if (_gs.group !== group) {
_gs.group = group;
_setGalGroupSelect(group);
_loadGalImages(group);
}
}
function _applyToWorkflow() {
const nodeId = document.getElementById("wfm-feeder-node-sel")?.value;
const wf = comfyUI.currentWorkflow;
if (!nodeId || !wf?.[nodeId]) {
showToast("No ImageFeeder node selected", "error");
showToast(t("feederNoNode"), "error");
return;
}
_applyToNode(nodeId);
showToast("Applied to workflow", "success");
showToast(t("appliedToWorkflow"), "success");
}
function _applyGalToWorkflow() {
const nodeId = document.getElementById("wfm-feeder-gal-node-sel")?.value;
const wf = comfyUI.currentWorkflow;
if (!nodeId || !wf?.[nodeId]) {
showToast(t("feederGalNoNode"), "error");
return;
}
_applyToGalNode(nodeId);
showToast(t("appliedToWorkflow"), "success");
}
// ── Run Loop ──────────────────────────────────────────────────────
@@ -92,6 +160,13 @@ function _setRunUI(running) {
if (stopBtn) stopBtn.disabled = !running;
}
function _setGalRunUI(running) {
const runBtn = document.getElementById("wfm-feeder-gal-run-btn");
const stopBtn = document.getElementById("wfm-feeder-gal-stop-btn");
if (runBtn) runBtn.disabled = running;
if (stopBtn) stopBtn.disabled = !running;
}
function _applyToNode(nodeId) {
const wf = comfyUI.currentWorkflow;
const inp = wf[nodeId].inputs;
@@ -106,20 +181,28 @@ function _applyToNode(nodeId) {
inp.selected_files = JSON.stringify([..._s.selected]);
}
function _applyToGalNode(nodeId) {
const wf = comfyUI.currentWorkflow;
const inp = wf[nodeId].inputs;
inp.group_name = _gs.group;
inp.index = _gs.idx;
inp.sort_mode = document.getElementById("wfm-feeder-gal-sort")?.value || "filename_asc";
inp.seed = parseInt(document.getElementById("wfm-feeder-gal-seed")?.value) || 0;
}
async function _startRun() {
if (_s.running) return;
if (!comfyUI.currentWorkflow) { showToast("No workflow loaded", "error"); return; }
if (!comfyUI.connected) { showToast("Not connected to ComfyUI", "error"); return; }
if (!comfyUI.currentWorkflow) { showToast(t("noWorkflowLoaded"), "error"); return; }
if (!comfyUI.connected) { showToast(t("notConnectedToComfyUI"), "error"); return; }
const nodeId = document.getElementById("wfm-feeder-node-sel")?.value;
if (!nodeId || !comfyUI.currentWorkflow[nodeId]) {
showToast("No ImageFeeder node selected", "error");
showToast(t("feederNoNode"), "error");
return;
}
// WebSocket を先に接続してノード sync メッセージを受け取れるようにする
const wsOk = await comfyUI.connectWebSocket();
if (!wsOk) { showToast("WebSocket connection failed", "error"); return; }
if (!wsOk) { showToast(t("wsConnectionFailed"), "error"); return; }
_s.running = true;
_setRunUI(true);
@@ -128,7 +211,6 @@ async function _startRun() {
const progressText = document.getElementById("wfm-gen-progress-text");
const resultImg = document.getElementById("wfm-gen-result-img");
// image_loop_node_sync メッセージを捕捉するリスナー
let _lastSync = null;
const _syncHandler = (ev) => {
try {
@@ -156,7 +238,6 @@ async function _startRun() {
if (progressBar) progressBar.style.width = "0%";
if (progressText) progressText.textContent = `#${++count} 0%`;
// 右ペインのseed設定を使用(KSamplerに適用される)
const seedMode = document.getElementById("wfm-gen-seed-mode")?.value || "random";
const seedValue = parseInt(document.getElementById("wfm-gen-seed-value")?.value) || -1;
@@ -172,7 +253,6 @@ async function _startRun() {
}
);
// 右ペインのseed表示を更新(通常の生成と同じ挙動)
const seedEl = document.getElementById("wfm-gen-seed-value");
if (seedEl) seedEl.value = seed;
@@ -186,7 +266,6 @@ async function _startRun() {
if (!_s.running) break;
// control after generate: ノードから返された next_index を反映
const control = document.getElementById("wfm-feeder-control-after")?.value || "loop";
if (control === "fixed") {
// index を変えない
@@ -195,14 +274,13 @@ async function _startRun() {
if (indexEl) indexEl.value = _lastSync.next_index;
if (control === "increment" && !_lastSync.has_next) {
_s.running = false;
showToast(`Feeder complete (${count} generated)`, "success");
showToast(t("feederComplete", count), "success");
break;
}
// loop: has_next=false でも次は index=0 からなので続行
}
}
} catch (err) {
if (_s.running) showToast("Feeder run error: " + err.message, "error");
if (_s.running) showToast(t("feederRunError", err.message), "error");
} finally {
comfyUI.socket?.removeEventListener("message", _syncHandler);
_s.running = false;
@@ -215,10 +293,107 @@ async function _stopRun() {
_s.running = false;
try { await comfyUI.interrupt(); } catch {}
_setRunUI(false);
showToast("Feeder stopped", "info");
showToast(t("feederStopped"), "info");
}
// ── Folder Tree ───────────────────────────────────────────────────
// ── Gallery Mode Run Loop ─────────────────────────────────────────
async function _startGalRun() {
if (_s.running) return;
if (!comfyUI.currentWorkflow) { showToast(t("noWorkflowLoaded"), "error"); return; }
if (!comfyUI.connected) { showToast(t("notConnectedToComfyUI"), "error"); return; }
const nodeId = document.getElementById("wfm-feeder-gal-node-sel")?.value;
if (!nodeId || !comfyUI.currentWorkflow[nodeId]) {
showToast(t("feederGalNoNode"), "error");
return;
}
if (_gs.images.length === 0) {
showToast(t("feederGalEmptyGroup"), "error");
return;
}
const wsOk = await comfyUI.connectWebSocket();
if (!wsOk) { showToast(t("wsConnectionFailed"), "error"); return; }
_s.running = true;
_setGalRunUI(true);
const progressBar = document.getElementById("wfm-gen-progress-bar");
const progressText = document.getElementById("wfm-gen-progress-text");
const resultImg = document.getElementById("wfm-gen-result-img");
const indexEl = document.getElementById("wfm-feeder-gal-index");
const total = _gs.images.length;
let count = 0;
try {
while (_s.running) {
_applyToGalNode(nodeId);
if (progressBar) progressBar.style.width = "0%";
if (progressText) progressText.textContent = `#${++count} [${_gs.idx + 1}/${total}] 0%`;
const seedMode = document.getElementById("wfm-gen-seed-mode")?.value || "random";
const seedValue = parseInt(document.getElementById("wfm-gen-seed-value")?.value) || -1;
const { images, seed } = await comfyUI.generate(
{ ...comfyUI.currentWorkflow },
{
seedMode,
seedValue,
onProgress: (pct) => {
if (progressBar) progressBar.style.width = `${(pct * 100).toFixed(1)}%`;
if (progressText) progressText.textContent = `#${count} [${_gs.idx + 1}/${total}] ${(pct * 100).toFixed(0)}%`;
},
}
);
const seedEl = document.getElementById("wfm-gen-seed-value");
if (seedEl) seedEl.value = seed;
if (progressBar) progressBar.style.width = "100%";
if (images.length > 0 && resultImg) {
const blob = await comfyUI.getImageBlob(images[0]);
resultImg.src = URL.createObjectURL(blob);
resultImg.style.display = "block";
}
if (!_s.running) break;
const control = document.getElementById("wfm-feeder-gal-control-after")?.value || "loop";
const nextIdx = (_gs.idx + 1) % total;
const isLast = _gs.idx === total - 1;
if (control === "fixed") {
// idx を変えない
} else if (control === "increment" && isLast) {
_s.running = false;
showToast(t("feederComplete", count), "success");
break;
} else {
_gs.idx = nextIdx;
if (indexEl) indexEl.value = _gs.idx;
_highlightGalCard(_gs.images[_gs.idx]);
}
}
} catch (err) {
if (_s.running) showToast(t("feederRunError", err.message), "error");
} finally {
_s.running = false;
_setGalRunUI(false);
if (progressText) progressText.textContent = `Done (${count} generated)`;
}
}
async function _stopGalRun() {
_s.running = false;
try { await comfyUI.interrupt(); } catch {}
_setGalRunUI(false);
showToast(t("feederStopped"), "info");
}
// ── Folder Tree (loop mode) ───────────────────────────────────────
async function _loadTree() {
const container = document.getElementById("wfm-feeder-tree");
@@ -275,7 +450,7 @@ function _highlightTreeRow(path) {
});
}
// ── Image Grid ────────────────────────────────────────────────────
// ── Image Grid (loop mode) ────────────────────────────────────────
async function _loadImages(dir) {
const grid = document.getElementById("wfm-feeder-grid");
@@ -366,8 +541,6 @@ function _deselectAll() {
_updateStatus();
}
// ── Status Bar ───────────────────────────────────────────────────
function _updateStatus() {
const el = document.getElementById("wfm-feeder-status");
if (!el) return;
@@ -375,6 +548,104 @@ function _updateStatus() {
el.textContent = `📂 ${_s.dir || "(root)"} | ${inCurrent} / ${_s.images.length} selected`;
}
// ── Gallery Mode: Group & Image Grid ─────────────────────────────
async function _loadGalGroups() {
try {
const res = await fetch("/wfm/gallery/groups");
if (!res.ok) throw new Error(res.status);
const data = await res.json();
_gs.groups = data.groups || [];
_renderGalGroupSelect();
} catch (err) {
console.warn("[Feeder] loadGalGroups failed:", err);
}
}
function _renderGalGroupSelect() {
const sel = document.getElementById("wfm-feeder-gal-group");
if (!sel) return;
sel.innerHTML = _gs.groups
.map(g => `<option value="${g.name}"${g.name === _gs.group ? " selected" : ""}>${g.name}</option>`)
.join("");
if (!_gs.groups.find(g => g.name === _gs.group) && _gs.groups.length > 0) {
_gs.group = _gs.groups[0].name;
}
}
function _setGalGroupSelect(group) {
const sel = document.getElementById("wfm-feeder-gal-group");
if (sel) sel.value = group;
}
async function _loadGalImages(group) {
const grid = document.getElementById("wfm-feeder-gal-grid");
const statusEl = document.getElementById("wfm-feeder-gal-status");
if (!grid) return;
grid.innerHTML = `<div class="wfm-feeder-grid-msg">Loading...</div>`;
try {
const res = await fetch(`/wfm/gallery/groups/${encodeURIComponent(group)}/images`);
if (!res.ok) throw new Error(res.status);
const data = await res.json();
_gs.images = data.images || [];
_gs.idx = 0;
const idxEl = document.getElementById("wfm-feeder-gal-index");
if (idxEl) idxEl.value = 0;
_renderGalGrid();
if (statusEl) statusEl.textContent = `${_gs.images.length} image(s) in "${group}"`;
} catch (err) {
_gs.images = [];
grid.innerHTML = `<div class="wfm-feeder-grid-msg" style="color:var(--wfm-danger)">Load failed: ${err.message}</div>`;
if (statusEl) statusEl.textContent = "";
}
}
function _renderGalGrid() {
const grid = document.getElementById("wfm-feeder-gal-grid");
if (!grid) return;
if (_gs.images.length === 0) {
grid.innerHTML = `<div class="wfm-feeder-grid-msg">No images in this group</div>`;
return;
}
grid.innerHTML = "";
_gs.images.forEach((absPath, i) => grid.appendChild(_makeGalCard(absPath, i)));
}
function _makeGalCard(absPath, idx) {
const fname = absPath.replace(/\\/g, "/").split("/").pop();
const card = document.createElement("div");
card.className = "wfm-feeder-card" + (idx === _gs.idx ? " selected" : "");
card.dataset.path = absPath;
card.dataset.idx = idx;
const img = document.createElement("img");
img.className = "wfm-feeder-card-img";
img.loading = "lazy";
img.src = `/wfm/gallery/image/serve?path=${encodeURIComponent(absPath)}`;
img.onerror = () => { img.style.display = "none"; card.style.minHeight = "110px"; };
const name = document.createElement("div");
name.className = "wfm-feeder-card-name";
name.textContent = fname;
name.title = fname;
card.append(img, name);
card.addEventListener("click", () => {
_gs.idx = idx;
const idxEl = document.getElementById("wfm-feeder-gal-index");
if (idxEl) idxEl.value = idx;
_highlightGalCard(absPath);
_showGalPreview(absPath, fname);
});
return card;
}
function _highlightGalCard(absPath) {
document.querySelectorAll("#wfm-feeder-gal-grid .wfm-feeder-card").forEach(c => {
c.classList.toggle("selected", c.dataset.path === absPath);
});
}
// ── Preview Panel ────────────────────────────────────────────────
async function _showPreview(relPath, fname) {
@@ -399,7 +670,20 @@ async function _showPreview(relPath, fname) {
} catch { if (infoEl) infoEl.textContent = ""; }
}
// ── Presets ──────────────────────────────────────────────────────
async function _showGalPreview(absPath, fname) {
const imgEl = document.getElementById("wfm-feeder-preview-img");
const nameEl = document.getElementById("wfm-feeder-preview-name");
const infoEl = document.getElementById("wfm-feeder-preview-info");
if (imgEl) {
imgEl.src = `/wfm/gallery/image/serve?path=${encodeURIComponent(absPath)}`;
imgEl.style.display = "block";
}
if (nameEl) nameEl.textContent = fname;
if (infoEl) infoEl.textContent = "";
}
// ── Presets (loop mode) ───────────────────────────────────────────
async function _loadPresets() {
try {
@@ -420,7 +704,7 @@ function _renderPresets() {
async function _savePreset() {
const name = document.getElementById("wfm-feeder-preset-name")?.value.trim();
if (!name) { showToast("Enter a preset name", "error"); return; }
if (!name) { showToast(t("enterPresetName"), "error"); return; }
const sel = _s.images.filter(f => _s.selected.has(f));
try {
const res = await fetch("/image_feeder/presets", {
@@ -429,20 +713,20 @@ async function _savePreset() {
body: JSON.stringify({ name, directory: _s.dir, selected_files: sel }),
});
if (res.ok) {
showToast(`Preset saved: ${name}`, "success");
showToast(t("presetSavedName", name), "success");
const nameInput = document.getElementById("wfm-feeder-preset-name");
if (nameInput) nameInput.value = "";
await _loadPresets();
const selEl = document.getElementById("wfm-feeder-preset-sel");
if (selEl) selEl.value = name;
} else { showToast("Save failed", "error"); }
} catch (err) { showToast("Save error: " + err.message, "error"); }
} else { showToast(t("saveFailed"), "error"); }
} catch (err) { showToast(t("saveFailed", err.message), "error"); }
}
async function _applyPreset() {
const selEl = document.getElementById("wfm-feeder-preset-sel");
const name = selEl?.value;
if (!name || !_s.presets[name]) { showToast("Select a preset first", "error"); return; }
if (!name || !_s.presets[name]) { showToast(t("selectPresetFirst"), "error"); return; }
const preset = _s.presets[name];
const dir = preset.directory || "";
@@ -457,7 +741,7 @@ async function _applyPreset() {
}
_refreshGridCbs();
_updateStatus();
showToast(`Preset loaded: ${name}`, "success");
showToast(t("presetLoaded", name), "success");
}
async function _deletePreset() {
@@ -465,9 +749,37 @@ async function _deletePreset() {
if (!name) return;
try {
await fetch(`/image_feeder/presets/${encodeURIComponent(name)}`, { method: "DELETE" });
showToast(`Preset deleted: ${name}`, "info");
showToast(t("presetDeleted", name), "info");
await _loadPresets();
} catch (err) { showToast("Delete error", "error"); }
} catch (err) { showToast(t("deleteFailed"), "error"); }
}
// ── Mode Switch ───────────────────────────────────────────────────
function _setMode(mode) {
_s.mode = mode;
localStorage.setItem("wfm_feeder_mode", mode);
const loopBtn = document.getElementById("wfm-feeder-mode-loop");
const galBtn = document.getElementById("wfm-feeder-mode-gallery");
const loopSec = document.getElementById("wfm-feeder-loop-section");
const galSec = document.getElementById("wfm-feeder-gal-section");
const loopLib = document.getElementById("wfm-feeder-loop-library");
const galLib = document.getElementById("wfm-feeder-gal-library");
const isGallery = mode === "gallery";
if (loopBtn) loopBtn.classList.toggle("wfm-btn-primary", !isGallery);
if (galBtn) galBtn.classList.toggle("wfm-btn-primary", isGallery);
if (loopSec) loopSec.style.display = isGallery ? "none" : "";
if (galSec) galSec.style.display = isGallery ? "" : "none";
if (loopLib) loopLib.style.display = isGallery ? "none" : "";
if (galLib) galLib.style.display = isGallery ? "" : "none";
if (isGallery) {
_loadGalGroups().then(() => _loadGalImages(_gs.group));
_refreshGalNodeList();
}
}
// ── Helpers ───────────────────────────────────────────────────────
@@ -484,6 +796,11 @@ function _setCheck(id, val) {
// ── Init ─────────────────────────────────────────────────────────
export async function initFeederTab() {
// Mode toggle
document.getElementById("wfm-feeder-mode-loop")?.addEventListener("click", () => _setMode("loop"));
document.getElementById("wfm-feeder-mode-gallery")?.addEventListener("click", () => _setMode("gallery"));
// ── Image Loop mode events ──
document.getElementById("wfm-feeder-node-sel")?.addEventListener("change", e => {
_loadFromNode(e.target.value);
});
@@ -510,6 +827,33 @@ export async function initFeederTab() {
document.getElementById("wfm-feeder-run-btn")?.addEventListener("click", _startRun);
document.getElementById("wfm-feeder-stop-btn")?.addEventListener("click", _stopRun);
await Promise.all([_loadTree(), _loadPresets()]);
_selectDir("");
// ── Gallery mode events ──
document.getElementById("wfm-feeder-gal-node-sel")?.addEventListener("change", e => {
_loadFromGalNode(e.target.value);
});
document.getElementById("wfm-feeder-gal-apply-btn")?.addEventListener("click", _applyGalToWorkflow);
document.getElementById("wfm-feeder-gal-group")?.addEventListener("change", e => {
_gs.group = e.target.value;
_gs.idx = 0;
_loadGalImages(_gs.group);
});
document.getElementById("wfm-feeder-gal-index")?.addEventListener("change", e => {
_gs.idx = Math.max(0, parseInt(e.target.value) || 0);
if (_gs.images[_gs.idx]) _highlightGalCard(_gs.images[_gs.idx]);
});
document.getElementById("wfm-feeder-gal-run-btn")?.addEventListener("click", _startGalRun);
document.getElementById("wfm-feeder-gal-stop-btn")?.addEventListener("click", _stopGalRun);
// 初期化
await ensureFeederGroup();
_setMode(_s.mode);
if (_s.mode === "loop") {
await Promise.all([_loadTree(), _loadPresets()]);
_selectDir("");
}
}
+462 -105
View File
File diff suppressed because it is too large Load Diff
+167 -61
View File
@@ -9,21 +9,18 @@ import { comfyEditor } from "./comfyui-editor.js";
import { t } from "./i18n.js";
import { syncJsonHighlight, syncScroll } from "./json-highlight.js";
import { initFeederTab, refreshFeederNodeList } from "./feeder-tab.js";
import { getSettings, readJsonStorage } from "./util.js";
// ============================================
// Eagle Auto-Save
// ============================================
function getEagleSettings() {
try {
const s = JSON.parse(localStorage.getItem("wfm_settings") || "{}");
return {
url: s.eagleUrl || "http://localhost:41595",
autoSave: !!s.eagleAutoSave,
};
} catch {
return { url: "http://localhost:41595", autoSave: false };
}
const s = getSettings();
return {
url: s.eagleUrl || "http://localhost:41595",
autoSave: !!s.eagleAutoSave,
};
}
async function saveToEagle(imageUrl, name, tags = []) {
@@ -109,48 +106,77 @@ function updateStatus(connected) {
async function saveCurrentWorkflow() {
if (!comfyUI.currentWorkflow) {
showToast("No workflow loaded", "warning");
showToast(t("noWorkflowLoaded"), "warning");
return;
}
const currentFilename = document.getElementById("wfm-gen-wf-name")?.dataset?.filename || "";
const defaultStem = currentFilename.replace(/\.json$/, "") || "workflow";
const defaultStem = currentFilename.replace(/\.(json|png|jpg|jpeg|webp|gif)$/i, "") || "workflow";
const html = `
<div style="display:flex;flex-direction:column;gap:14px;min-width:300px;">
<div>
<label style="font-size:12px;color:var(--wfm-text-secondary);display:block;margin-bottom:4px;">Filename</label>
<label style="font-size:12px;color:var(--wfm-text-secondary);display:block;margin-bottom:4px;">${t("filenameLabel")}</label>
<div style="display:flex;align-items:center;gap:6px;">
<input type="text" id="wfm-save-wf-name" class="wfm-input" value="${defaultStem}" style="flex:1;" placeholder="workflow name">
<input type="text" id="wfm-save-wf-name" class="wfm-input" style="flex:1;" placeholder="workflow name">
<span style="color:var(--wfm-text-secondary);font-size:13px;">.json</span>
</div>
</div>
<div style="display:flex;gap:8px;justify-content:flex-end;">
<button class="wfm-btn wfm-btn-sm" id="wfm-save-wf-cancel-btn">Cancel</button>
<button class="wfm-btn wfm-btn-sm wfm-btn-primary" id="wfm-save-wf-confirm-btn">Save</button>
<button class="wfm-btn wfm-btn-sm" id="wfm-save-wf-cancel-btn">${t("cancel")}</button>
<button class="wfm-btn wfm-btn-sm wfm-btn-primary" id="wfm-save-wf-confirm-btn">${t("save")}</button>
</div>
</div>`;
openModal("Save Workflow", html);
openModal(t("saveWorkflowTitle"), html);
// 属性値に埋め込まず DOM 経由で初期値を設定(ファイル名中の引用符等によるHTML注入防止)
const input = document.getElementById("wfm-save-wf-name");
if (input) input.value = defaultStem;
setTimeout(() => {
const input = document.getElementById("wfm-save-wf-name");
if (input) { input.focus(); input.select(); }
}, 50);
document.getElementById("wfm-save-wf-cancel-btn")?.addEventListener("click", () => closeModal());
let saving = false;
const doSave = async () => {
const input = document.getElementById("wfm-save-wf-name");
if (saving) return;
const stem = input?.value?.trim();
if (!stem) {
showToast("Please enter a filename", "warning");
showToast(t("pleaseEnterFilename"), "warning");
return;
}
const filename = stem.endsWith(".json") ? stem : `${stem}.json`;
saving = true;
try {
// Raw JSON に未適用の編集があれば保存対象に反映する
let workflow = comfyUI.currentWorkflow;
const rawText = document.getElementById("wfm-gen-raw-json")?.value ?? "";
if (rawText.trim() && rawText !== JSON.stringify(workflow, null, 2)) {
try {
workflow = JSON.parse(rawText);
} catch {
showToast(t("rawJsonUnappliedInvalid"), "error");
return;
}
}
// 上書き確認(保存先がUI形式ならAPI形式化でレイアウトが失われる旨を警告)
try {
const listRes = await fetch("/api/wfm/workflows");
const listData = await listRes.json();
const existing = (Array.isArray(listData) ? listData : []).find(w => w.filename === filename);
if (existing) {
const msg = existing.analysis?.format === "ui"
? t("uiFormatOverwriteWarn")
: t("overwriteConfirm", filename);
if (!confirm(msg)) return;
}
} catch { /* 一覧取得失敗時は確認をスキップして保存を続行 */ }
const blob = new Blob(
[JSON.stringify(comfyUI.currentWorkflow, null, 2)],
[JSON.stringify(workflow, null, 2)],
{ type: "application/json" }
);
const file = new File([blob], filename, { type: "application/json" });
@@ -160,23 +186,30 @@ async function saveCurrentWorkflow() {
const data = await res.json();
const ng = (data.results || []).filter(r => r.status === "error");
if (ng.length) {
showToast(`Save failed: ${ng[0].message || "unknown error"}`, "error");
showToast(t("saveFailed", ng[0].message || "unknown error"), "error");
return;
}
closeModal();
const nameEl = document.getElementById("wfm-gen-wf-name");
if (nameEl) {
nameEl.textContent = filename;
nameEl.dataset.filename = filename;
if (workflow !== comfyUI.currentWorkflow) {
// Raw JSON の編集を保存した場合はエディタにも反映して同期する
await loadWorkflowIntoEditor(workflow, filename);
} else {
const nameEl = document.getElementById("wfm-gen-wf-name");
if (nameEl) {
nameEl.textContent = filename;
nameEl.dataset.filename = filename;
}
}
showToast(`Saved: ${filename}`, "success");
showToast(t("savedAs", filename), "success");
} catch (err) {
showToast(`Save error: ${err.message}`, "error");
showToast(t("saveFailed", err.message), "error");
} finally {
saving = false;
}
};
document.getElementById("wfm-save-wf-confirm-btn")?.addEventListener("click", doSave);
document.getElementById("wfm-save-wf-name")?.addEventListener("keydown", (e) => {
input?.addEventListener("keydown", (e) => {
if (e.key === "Enter") doSave();
});
}
@@ -195,7 +228,7 @@ export async function loadWorkflowIntoEditor(workflow, filename) {
} else if (format === "ui") {
apiWorkflow = await comfyWorkflow.convertUiToApi(workflow);
} else if (format === "unknown") {
showToast("Unknown workflow format", "error");
showToast(t("unknownWorkflowFormat"), "error");
return false;
}
@@ -227,7 +260,7 @@ export async function loadWorkflowIntoEditor(workflow, filename) {
refreshFeederNodeList();
showToast(`Workflow loaded: ${filename || ""}`, "success");
showToast(t("workflowLoadedName", filename || ""), "success");
return true;
}
@@ -884,9 +917,7 @@ async function _loadPromptGroupsForBatch() {
const res = await fetch("/api/wfm/prompts");
_batchGroupState.promptPresets = res.ok ? await res.json() : [];
} catch { _batchGroupState.promptPresets = []; }
try {
_batchGroupState.promptGroups = JSON.parse(localStorage.getItem("wfm_prompt_preset_groups") || "{}");
} catch { _batchGroupState.promptGroups = {}; }
_batchGroupState.promptGroups = readJsonStorage("wfm_prompt_preset_groups");
const validIds = new Set(_batchGroupState.promptPresets.map((p) => p.id));
for (const g of Object.keys(_batchGroupState.promptGroups)) {
@@ -922,9 +953,7 @@ function _renderBatchPromptGroupList() {
// Workflow グループ
// ============================================
function _loadWorkflowGroupsForBatch() {
try {
_batchGroupState.wfGroups = JSON.parse(localStorage.getItem("wfm_groups") || "{}");
} catch { _batchGroupState.wfGroups = {}; }
_batchGroupState.wfGroups = readJsonStorage("wfm_groups");
const currentNames = new Set(Object.keys(_batchGroupState.wfGroups));
for (const name of _batchGroupState.wfSelectedGroups) {
@@ -1164,6 +1193,82 @@ function initCheckpointBatch() {
});
}
// ============================================
// SPA-side wildcard expansion (A1111-style __name__ syntax)
// Applies to non-ImpactWildcard nodes only; ImpactWildcard* nodes expand server-side.
// ============================================
const _wcLineCache = new Map(); // filename → string[] | null
async function _fetchWildcardLines(name) {
if (_wcLineCache.has(name)) return _wcLineCache.get(name);
try {
const res = await fetch(`/api/wfm/wildcards/content?filename=${encodeURIComponent(name + ".txt")}`);
if (!res.ok) { _wcLineCache.set(name, null); return null; }
const data = await res.json();
const lines = (data.content || "")
.split("\n")
.map(l => l.trim())
.filter(l => l && !l.startsWith("#"));
const result = lines.length > 0 ? lines : null;
_wcLineCache.set(name, result);
return result;
} catch {
_wcLineCache.set(name, null);
return null;
}
}
async function _expandWildcardText(text) {
for (let pass = 0; pass < 5; pass++) {
const matches = [...text.matchAll(/__([^_\s][^_]*)__/g)];
if (matches.length === 0) break;
let changed = false;
let offset = 0;
let result = text;
for (const match of matches) {
const lines = await _fetchWildcardLines(match[1]);
if (lines) {
const replacement = lines[Math.floor(Math.random() * lines.length)];
const pos = match.index + offset;
result = result.slice(0, pos) + replacement + result.slice(pos + match[0].length);
offset += replacement.length - match[0].length;
changed = true;
}
}
if (!changed) break;
text = result;
}
return text;
}
const _IMPACT_WC_TYPES = new Set(["ImpactWildcardEncode", "ImpactWildcardProcessor"]);
async function _expandWildcardsInWorkflow(workflow) {
let hasWildcard = false;
outer: for (const node of Object.values(workflow)) {
if (_IMPACT_WC_TYPES.has(node.class_type)) continue;
for (const val of Object.values(node.inputs || {})) {
if (typeof val === "string" && /__[^_\s][^_]*__/.test(val)) {
hasWildcard = true;
break outer;
}
}
}
if (!hasWildcard) return workflow;
const expanded = JSON.parse(JSON.stringify(workflow));
for (const node of Object.values(expanded)) {
if (_IMPACT_WC_TYPES.has(node.class_type)) continue;
for (const [key, val] of Object.entries(node.inputs || {})) {
if (typeof val === "string" && /__[^_\s][^_]*__/.test(val)) {
node.inputs[key] = await _expandWildcardText(val);
}
}
}
return expanded;
}
// ============================================
// Generation (core — throws on error)
// ============================================
@@ -1180,8 +1285,9 @@ async function _coreGenerate(silent = false) {
if (progressBar) progressBar.style.width = "0%";
if (progressText) progressText.textContent = "Starting...";
const workflowForGenerate = await _expandWildcardsInWorkflow({ ...comfyUI.currentWorkflow });
const { images, seed } = await comfyUI.generate(
{ ...comfyUI.currentWorkflow },
workflowForGenerate,
{
seedMode,
seedValue,
@@ -1235,7 +1341,7 @@ async function _coreGenerate(silent = false) {
saveGeneratedImagesMeta(images, { ...comfyUI.currentWorkflow }).catch(() => {});
}
if (!silent) showToast("Generation complete", "success");
if (!silent) showToast(t("generationComplete"), "success");
}
// ============================================
@@ -1283,7 +1389,7 @@ async function _runBatchLoop(items, applyFn, labelFn = (x) => String(x)) {
} catch (err) {
if (_ckptBatch.aborted) break;
failed++;
showToast(`[${i + 1}/${items.length}] Failed: ${err.message}`, "error");
showToast(t("batchItemFailed", i + 1, items.length, err.message), "error");
}
}
} finally {
@@ -1301,7 +1407,7 @@ async function _runBatchLoop(items, applyFn, labelFn = (x) => String(x)) {
if (batchCurrentName) batchCurrentName.textContent = _ckptBatch.aborted ? "Stopped" : "Done";
if (_ckptBatch.aborted) {
showToast(`Batch stopped — ${completed} completed, ${failed} failed`, "info");
showToast(t("batchStopped", completed, failed), "info");
} else {
showToast(
`Batch complete: ${completed}/${items.length}${failed > 0 ? ` (${failed} failed)` : ""}`,
@@ -1315,9 +1421,9 @@ async function _runBatchGenerate() {
switch (_activeBatchType) {
case "checkpoint": {
const ckptNodes = comfyUI.currentAnalysis?.checkpoint_nodes || [];
if (ckptNodes.length === 0) { showToast("No checkpoint node found in workflow", "error"); return; }
if (ckptNodes.length === 0) { showToast(t("modelsGenUINoNode", "checkpoint"), "error"); return; }
const list = _getSelectedCheckpoints();
if (list.length === 0) { showToast("No checkpoints selected", "error"); return; }
if (list.length === 0) { showToast(t("batchNoneSelected", "checkpoints"), "error"); return; }
await _runBatchLoop(list, (model) => {
for (const node of ckptNodes) {
if (comfyUI.currentWorkflow?.[node.id])
@@ -1328,9 +1434,9 @@ async function _runBatchGenerate() {
}
case "lora": {
const loraNodes = comfyUI.currentAnalysis?.lora_nodes || [];
if (loraNodes.length === 0) { showToast("No LoRA node found in workflow", "error"); return; }
if (loraNodes.length === 0) { showToast(t("modelsGenUINoNode", "LoRA"), "error"); return; }
const list = [..._getSelectedLoraGroupItems()];
if (list.length === 0) { showToast("No LoRAs selected", "error"); return; }
if (list.length === 0) { showToast(t("batchNoneSelected", "LoRAs"), "error"); return; }
await _runBatchLoop(list, (loraName) => {
for (const node of loraNodes) {
if (!comfyUI.currentWorkflow?.[node.id]) continue;
@@ -1351,11 +1457,11 @@ async function _runBatchGenerate() {
const positiveNodes = (comfyUI.currentAnalysis?.prompt_nodes || []).filter((n) => n.role === "positive");
const negativeNodes = (comfyUI.currentAnalysis?.prompt_nodes || []).filter((n) => n.role === "negative");
if (positiveNodes.length === 0 && negativeNodes.length === 0) {
showToast("No prompt node found in workflow", "error"); return;
showToast(t("modelsGenUINoNode", "prompt"), "error"); return;
}
// _getSelectedPromptGroupItems() はすでにプリセットオブジェクトの配列を返す
const list = _getSelectedPromptGroupItems();
if (list.length === 0) { showToast("No prompts selected", "error"); return; }
if (list.length === 0) { showToast(t("batchNoneSelected", "prompts"), "error"); return; }
await _runBatchLoop(list, (preset) => {
for (const node of positiveNodes) {
if (comfyUI.currentWorkflow?.[node.id])
@@ -1370,7 +1476,7 @@ async function _runBatchGenerate() {
}
case "workflow": {
const list = [..._getSelectedWfGroupItems()];
if (list.length === 0) { showToast("No workflows selected", "error"); return; }
if (list.length === 0) { showToast(t("batchNoneSelected", "workflows"), "error"); return; }
const savedWorkflow = comfyUI.currentWorkflow ? JSON.stringify(comfyUI.currentWorkflow) : null;
const savedFilename = document.getElementById("wfm-gen-workflow-name")?.textContent || "";
try {
@@ -1389,9 +1495,9 @@ async function _runBatchGenerate() {
}
case "sampler": {
const samplerNodes = comfyUI.currentAnalysis?.sampler_nodes || [];
if (samplerNodes.length === 0) { showToast("No KSampler node found in workflow", "error"); return; }
if (samplerNodes.length === 0) { showToast(t("modelsGenUINoNode", "KSampler"), "error"); return; }
const list = [..._samplerSelected].sort();
if (list.length === 0) { showToast("No samplers selected", "error"); return; }
if (list.length === 0) { showToast(t("batchNoneSelected", "samplers"), "error"); return; }
await _runBatchLoop(list, (samplerName) => {
for (const node of samplerNodes) {
if (comfyUI.currentWorkflow?.[node.id])
@@ -1402,9 +1508,9 @@ async function _runBatchGenerate() {
}
case "scheduler": {
const samplerNodes = comfyUI.currentAnalysis?.sampler_nodes || [];
if (samplerNodes.length === 0) { showToast("No KSampler node found in workflow", "error"); return; }
if (samplerNodes.length === 0) { showToast(t("modelsGenUINoNode", "KSampler"), "error"); return; }
const list = [..._schedulerSelected].sort();
if (list.length === 0) { showToast("No schedulers selected", "error"); return; }
if (list.length === 0) { showToast(t("batchNoneSelected", "schedulers"), "error"); return; }
await _runBatchLoop(list, (schedulerName) => {
for (const node of samplerNodes) {
if (comfyUI.currentWorkflow?.[node.id])
@@ -1422,7 +1528,7 @@ async function _runBatchGenerate() {
async function handleGenerate() {
if (!comfyUI.currentWorkflow) {
showToast("No workflow loaded", "error");
showToast(t("noWorkflowLoaded"), "error");
return;
}
if (comfyUI.generating) return;
@@ -1449,7 +1555,7 @@ async function handleGenerate() {
} catch (err) {
const progressText = document.getElementById("wfm-gen-progress-text");
if (progressText) progressText.textContent = "Error";
showToast("Generation error: " + err.message, "error");
showToast(t("generationError", err.message), "error");
}
}
} finally {
@@ -1472,9 +1578,9 @@ export async function initGenerateTab() {
updateStatus(connected);
if (connected) {
await comfyEditor.loadModelLists();
showToast("Connected to ComfyUI", "success");
showToast(t("connectedToComfyUI"), "success");
} else {
showToast("Failed to connect", "error");
showToast(t("failedToConnect"), "error");
}
});
@@ -1484,7 +1590,7 @@ export async function initGenerateTab() {
if (comfyUI.currentAnalysis) {
comfyEditor.renderAll(comfyUI.currentAnalysis, comfyUI.currentWorkflow);
}
showToast("Model lists refreshed", "success");
showToast(t("modelListsRefreshed"), "success");
_rebuildSamplerList();
_rebuildSchedulerList();
_renderBatchPreview();
@@ -1496,7 +1602,7 @@ export async function initGenerateTab() {
document.getElementById("wfm-gen-reset-workflow-btn")?.addEventListener("click", async () => {
const filename = document.getElementById("wfm-gen-wf-name")?.dataset?.filename;
if (!filename || !filename.endsWith(".json")) {
showToast("No file-based workflow loaded", "warning");
showToast(t("noFileWorkflowLoaded"), "warning");
return;
}
try {
@@ -1505,7 +1611,7 @@ export async function initGenerateTab() {
const data = await resp.json();
await loadWorkflowIntoEditor(data, filename);
} catch (err) {
showToast("Reset failed: " + err.message, "error");
showToast(t("resetFailed", err.message), "error");
}
});
@@ -1522,7 +1628,7 @@ export async function initGenerateTab() {
_ckptBatch._resumeResolve = null;
}
await comfyUI.interrupt();
showToast("Interrupted", "info");
showToast(t("interrupted"), "info");
});
// Move shared Raw JSON widget into the active tab's rawjson-col
@@ -1585,7 +1691,7 @@ export async function initGenerateTab() {
const wf = JSON.parse(textarea.value);
await loadWorkflowIntoEditor(wf, "Raw JSON");
} catch (err) {
showToast("Invalid JSON: " + err.message, "error");
showToast(t("invalidJsonMsg", err.message), "error");
}
});
@@ -1740,7 +1846,7 @@ export async function initGenerateTab() {
// Auto-load default workflow (doesn't require ComfyUI connection)
if (!comfyUI.currentWorkflow) {
try {
const settings = JSON.parse(localStorage.getItem("wfm_settings") || "{}");
const settings = getSettings();
if (settings.defaultWorkflow && settings.defaultWorkflowData) {
await loadWorkflowIntoEditor(settings.defaultWorkflowData, settings.defaultWorkflow);
console.log("Workflow Studio: Auto-loaded default workflow:", settings.defaultWorkflow);
+687 -86
View File
File diff suppressed because it is too large Load Diff
+1 -1
View File
@@ -5,6 +5,7 @@
*/
import { t } from "./i18n.js";
import { escapeHtml } from "./util.js";
// ── File size limit ───────────────────────────────────────────
const MAX_FILE_SIZE = 50 * 1024 * 1024;
@@ -504,7 +505,6 @@ async function extractAllMetadata(file) {
}
// ── UI helpers ────────────────────────────────────────────────
function escapeHtml(s) { return String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;"); }
function buildModelItem(label) {
const el = document.createElement("div");
+137 -69
View File
@@ -7,6 +7,7 @@ import { showToast, openModal, closeModal } from "./app.js";
import { t } from "./i18n.js";
import { comfyUI } from "./comfyui-client.js";
import { comfyEditor } from "./comfyui-editor.js";
import { escapeHtml, readJsonStorage } from "./util.js";
// ── Constants ─────────────────────────────────────────────
const RESERVED_GROUPS = ["Batch", "Stack"];
@@ -76,12 +77,13 @@ const TYPE_LABELS = {
// Mapping from models-tab type → comfyui-editor key + inputKey
const GENUI_TYPE_MAP = {
checkpoint: { key: "checkpoints", inputKey: "ckpt_name" },
lora: { key: "loras", inputKey: "lora_name" },
vae: { key: "vaes", inputKey: "vae_name" },
controlnet: { key: "controlNets", inputKey: "control_net_name" },
unet: { key: "diffusionModels",inputKey: "unet_name" },
textencoder: { key: "textEncoders", inputKey: "clip_name1" },
checkpoint: { key: "checkpoints", inputKey: "ckpt_name" },
lora: { key: "loras", inputKey: "lora_name" },
vae: { key: "vaes", inputKey: "vae_name" },
controlnet: { key: "controlNets", inputKey: "control_net_name" },
unet: { key: "diffusionModels",inputKey: "unet_name" },
textencoder: { key: "textEncoders", inputKey: "clip_name1" },
hypernetwork: { key: "hypernetworks", inputKey: "hypernetwork_name" },
};
function applyToGenUI(modelName, modelType) {
@@ -187,12 +189,21 @@ function applyToGenUI(modelName, modelType) {
showToast(`${TYPE_LABELS[modelType]}: ${modelName.split("/").pop().split("\\").pop()}`, "success");
}
function applyEmbeddingToPrompt(modelName, promptType) {
if (!comfyUI.currentWorkflow) {
showToast(t("modelsGenUINoWorkflow"), "warning");
return;
}
const stem = modelName.replace(/\\/g, "/").split("/").pop().replace(/\.[^.]+$/, "");
const syntax = `(embedding:${stem}:1.0)`;
comfyEditor.appendEmbeddingToPrompt(syntax, promptType);
showToast(`Embedding → ${promptType === "positive" ? "PP" : "NP"}: ${stem}`, "success");
}
// User-defined badge colors (stored in metadata per model)
// Global badge palette: label → color, stored in localStorage
function getBadgePalette() {
try {
return JSON.parse(localStorage.getItem("wfm_models_badge_palette") || "{}");
} catch { return {}; }
return readJsonStorage("wfm_models_badge_palette");
}
function saveBadgePalette(palette) {
@@ -201,13 +212,6 @@ function saveBadgePalette(palette) {
// ── Helpers ───────────────────────────────────────────────
function escapeHtml(s) {
return String(s)
.replace(/&/g, "&amp;")
.replace(/</g, "&lt;")
.replace(/>/g, "&gt;")
.replace(/"/g, "&quot;");
}
function parseModelPath(fullName) {
const lastSlash = Math.max(fullName.lastIndexOf("/"), fullName.lastIndexOf("\\"));
@@ -322,6 +326,12 @@ function clearSelection() {
renderBulkActionBar();
}
function selectAll() {
filterModels().forEach(m => state.selectedModels.add(m));
renderModelGrid();
renderBulkActionBar();
}
function renderBulkActionBar() {
const bar = document.getElementById("wfm-models-bulk-bar");
if (!bar) return;
@@ -348,6 +358,7 @@ function renderBulkActionBar() {
<div class="wfm-bulk-header">
<span class="wfm-bulk-count">${count} ${t("modelSelected")}</span>
<button class="wfm-btn wfm-btn-sm" id="wfm-bulk-deselect-all-btn">${t("modelBulkDeselectAll")}</button>
<button class="wfm-btn wfm-btn-sm" id="wfm-bulk-select-all-btn">${t("modelBulkSelectAll")}</button>
<span class="wfm-bulk-sep"></span>
<button class="wfm-btn wfm-btn-sm" id="wfm-bulk-fav-add-btn">${t("modelBulkFavAdd")}</button>
<button class="wfm-btn wfm-btn-sm" id="wfm-bulk-fav-remove-btn">${t("modelBulkFavRemove")}</button>
@@ -385,6 +396,7 @@ function renderBulkActionBar() {
`;
document.getElementById("wfm-bulk-deselect-all-btn")?.addEventListener("click", clearSelection);
document.getElementById("wfm-bulk-select-all-btn")?.addEventListener("click", selectAll);
document.getElementById("wfm-bulk-fav-add-btn")?.addEventListener("click", () => bulkSetFavorite(true));
document.getElementById("wfm-bulk-fav-remove-btn")?.addEventListener("click", () => bulkSetFavorite(false));
document.getElementById("wfm-bulk-add-btn")?.addEventListener("click", () => {
@@ -556,6 +568,10 @@ async function bulkMoveModels(destSubdir) {
const ds = state.disabledModels[state.activeModelType];
if (ds && ds.has(from)) { ds.delete(from); ds.add(to); }
state.selectedModels.delete(from);
for (const members of Object.values(state.modelGroups)) {
const gi = members.indexOf(from);
if (gi !== -1) members[gi] = to;
}
});
if (state.selectedModel && data.moved.some((m) => m.from === state.selectedModel)) {
state.selectedModel = null;
@@ -670,7 +686,7 @@ async function saveModelMetadata(modelName, updates) {
}
return data;
} catch (err) {
showToast("Error saving metadata: " + err.message, "error");
showToast(t("saveFailed", err.message), "error");
return null;
}
}
@@ -742,50 +758,44 @@ function filterModels() {
return sortModels(models);
}
function sortKeyOf(modelName) {
const meta = state.modelMetadata[modelName] || {};
switch (state.sortColumn) {
case "fav":
return meta.favorite ? 1 : 0;
case "filename":
return parseModelPath(modelName).name.toLowerCase();
case "subdir":
return parseModelPath(modelName).dir.toLowerCase();
case "civtype": {
const civ = meta.sha256 && state.civitaiCache[meta.sha256];
return (civ?.type || "").toLowerCase();
}
case "basemodel": {
const civ = meta.sha256 && state.civitaiCache[meta.sha256];
return (civ?.baseModel || "").toLowerCase();
}
case "ext":
return getExtension(parseModelPath(modelName).name).toLowerCase();
case "tags":
return (meta.tags || []).join(", ").toLowerCase();
case "memo":
return (meta.memo || "").toLowerCase();
case "enabled":
return isModelDisabled(modelName) ? 1 : 0;
default:
return 0;
}
}
function sortModels(models) {
if (!state.sortColumn) return models;
return [...models].sort((a, b) => {
const metaA = state.modelMetadata[a] || {};
const metaB = state.modelMetadata[b] || {};
let va, vb;
switch (state.sortColumn) {
case "fav":
va = metaA.favorite ? 1 : 0; vb = metaB.favorite ? 1 : 0; break;
case "filename": {
const pa = parseModelPath(a); const pb = parseModelPath(b);
va = pa.name.toLowerCase(); vb = pb.name.toLowerCase(); break;
}
case "subdir": {
const pa = parseModelPath(a); const pb = parseModelPath(b);
va = pa.dir.toLowerCase(); vb = pb.dir.toLowerCase(); break;
}
case "civtype": {
const civA = metaA.sha256 && state.civitaiCache[metaA.sha256];
const civB = metaB.sha256 && state.civitaiCache[metaB.sha256];
va = (civA?.type || "").toLowerCase(); vb = (civB?.type || "").toLowerCase(); break;
}
case "basemodel": {
const civA = metaA.sha256 && state.civitaiCache[metaA.sha256];
const civB = metaB.sha256 && state.civitaiCache[metaB.sha256];
va = (civA?.baseModel || "").toLowerCase(); vb = (civB?.baseModel || "").toLowerCase(); break;
}
case "ext": {
const pa = parseModelPath(a); const pb = parseModelPath(b);
va = getExtension(pa.name).toLowerCase(); vb = getExtension(pb.name).toLowerCase(); break;
}
case "tags":
va = (metaA.tags || []).join(", ").toLowerCase();
vb = (metaB.tags || []).join(", ").toLowerCase(); break;
case "memo":
va = (metaA.memo || "").toLowerCase(); vb = (metaB.memo || "").toLowerCase(); break;
case "enabled":
va = isModelDisabled(a) ? 1 : 0; vb = isModelDisabled(b) ? 1 : 0; break;
default: return 0;
}
if (va < vb) return state.sortDir === "asc" ? -1 : 1;
if (va > vb) return state.sortDir === "asc" ? 1 : -1;
return 0;
});
// ソートキーを1モデル1回だけ計算(比較ごとのparseModelPath等の再計算を回避)
const dir = state.sortDir === "asc" ? 1 : -1;
return models
.map((m) => [sortKeyOf(m), m])
.sort((a, b) => (a[0] < b[0] ? -dir : a[0] > b[0] ? dir : 0))
.map((pair) => pair[1]);
}
function getAllTags() {
@@ -1283,7 +1293,7 @@ async function clearStackGroup() {
state.allModelGroups[state.activeModelType] = state.modelGroups;
await saveModelGroups(state.modelGroups);
renderModelGrid();
showToast("Stack cleared", "success");
showToast(t("stackCleared"), "success");
}
// ── Favorite toggle ───────────────────────────────────────
@@ -1351,9 +1361,12 @@ function openDetailModal(modelName) {
</section>
<div class="wfm-modal-actions">
<button class="wfm-btn wfm-btn-primary wfm-btn-sm" id="wfm-modal-model-save">${t("modelsSave")}</button>
${GENUI_TYPE_MAP[state.activeModelType]
? `<button class="wfm-btn wfm-btn-sm" id="wfm-modal-genui-model" title="${t("modelsGenUITitle")}">${t("modelsGenUIBtn")}</button>`
: ""}
${state.activeModelType === "embedding"
? `<button class="wfm-btn wfm-btn-sm" id="wfm-modal-genui-pp" title="Positive Promptにエンベッディング追加">GenUI PP</button>
<button class="wfm-btn wfm-btn-sm" id="wfm-modal-genui-np" title="Negative Promptにエンベッディング追加">GenUI NP</button>`
: (GENUI_TYPE_MAP[state.activeModelType]
? `<button class="wfm-btn wfm-btn-sm" id="wfm-modal-genui-model" title="${t("modelsGenUITitle")}">${t("modelsGenUIBtn")}</button>`
: "")}
<button class="wfm-btn wfm-btn-sm wfm-btn-danger" id="wfm-modal-model-delete" style="margin-left:auto;">${t("modelsDelete")}</button>
</div>
</div>
@@ -1404,10 +1417,16 @@ function openDetailModal(modelName) {
renderModelGrid();
});
// GenUI Model button
// GenUI Model / Embedding buttons
document.getElementById("wfm-modal-genui-model")?.addEventListener("click", () => {
applyToGenUI(modelName, state.activeModelType);
});
document.getElementById("wfm-modal-genui-pp")?.addEventListener("click", () => {
applyEmbeddingToPrompt(modelName, "positive");
});
document.getElementById("wfm-modal-genui-np")?.addEventListener("click", () => {
applyEmbeddingToPrompt(modelName, "negative");
});
// Delete model button
document.getElementById("wfm-modal-model-delete")?.addEventListener("click", async () => {
@@ -1502,6 +1521,29 @@ function showSidePanel(modelName) {
const civitaiEl = document.getElementById("wfm-models-side-civitai");
if (civitaiEl) civitaiEl.style.display = "block";
const genuiNavBtn = document.getElementById("wfm-side-genui-nav-btn");
const genuiNpBtn = document.getElementById("wfm-side-genui-np-btn");
if (genuiNavBtn) {
if (state.activeModelType === "embedding") {
genuiNavBtn.textContent = "GenUI PP";
genuiNavBtn.title = "Positive Promptにエンベッディング追加";
genuiNavBtn.style.display = "";
if (genuiNpBtn) {
genuiNpBtn.textContent = "GenUI NP";
genuiNpBtn.title = "Negative Promptにエンベッディング追加";
genuiNpBtn.style.display = "";
}
} else if (GENUI_TYPE_MAP[state.activeModelType]) {
genuiNavBtn.textContent = t("modelsGenUIBtn");
genuiNavBtn.title = t("modelsGenUITitle");
genuiNavBtn.style.display = "";
if (genuiNpBtn) genuiNpBtn.style.display = "none";
} else {
genuiNavBtn.style.display = "none";
if (genuiNpBtn) genuiNpBtn.style.display = "none";
}
}
renderSideInfo(modelName);
renderSideGroup(modelName);
renderSideCivitai(modelName);
@@ -1514,6 +1556,10 @@ function closeSidePanel() {
document.querySelectorAll("#wfm-models-grid .wfm-card, #wfm-models-grid .wfm-models-table-row").forEach((el) => {
el.classList.remove("wfm-card-selected");
});
const npBtn = document.getElementById("wfm-side-genui-np-btn");
if (npBtn) npBtn.style.display = "none";
const ppBtn = document.getElementById("wfm-side-genui-nav-btn");
if (ppBtn) ppBtn.style.display = "none";
}
// ── Side Panel: Info Tab ──────────────────────────────────
@@ -1563,9 +1609,12 @@ function renderSideInfo(modelName) {
</div>
<div class="wfm-node-detail-section" style="display:flex;gap:6px;">
<button id="wfm-models-side-save-btn" class="wfm-btn wfm-btn-sm wfm-btn-primary">${t("modelsSave")}</button>
${GENUI_TYPE_MAP[state.activeModelType]
? `<button id="wfm-models-side-genui-btn" class="wfm-btn wfm-btn-sm" title="${t("modelsGenUITitle")}">${t("modelsGenUIBtn")}</button>`
: ""}
${state.activeModelType === "embedding"
? `<button id="wfm-models-side-genui-pp-btn" class="wfm-btn wfm-btn-sm" title="Positive Promptにエンベッディング追加">GenUI PP</button>
<button id="wfm-models-side-genui-np-btn" class="wfm-btn wfm-btn-sm" title="Negative Promptにエンベッディング追加">GenUI NP</button>`
: (GENUI_TYPE_MAP[state.activeModelType]
? `<button id="wfm-models-side-genui-btn" class="wfm-btn wfm-btn-sm" title="${t("modelsGenUITitle")}">${t("modelsGenUIBtn")}</button>`
: "")}
</div>`;
// Load preview image
@@ -1620,10 +1669,16 @@ function renderSideInfo(modelName) {
});
});
// GenUI Model button
// GenUI Model / Embedding buttons
el.querySelector("#wfm-models-side-genui-btn")?.addEventListener("click", () => {
applyToGenUI(modelName, state.activeModelType);
});
el.querySelector("#wfm-models-side-genui-pp-btn")?.addEventListener("click", () => {
applyEmbeddingToPrompt(modelName, "positive");
});
el.querySelector("#wfm-models-side-genui-np-btn")?.addEventListener("click", () => {
applyEmbeddingToPrompt(modelName, "negative");
});
}
// ── Side Panel: Group Tab ─────────────────────────────────
@@ -2089,7 +2144,7 @@ async function loadModelsForCurrentType() {
} catch (err) {
console.error("Failed to load models:", err);
if (placeholder) placeholder.textContent = t("modelsLoadError");
showToast("Error: " + err.message, "error");
showToast(t("errorWithMsg", err.message), "error");
}
}
@@ -2380,6 +2435,19 @@ export function initModelsTab() {
});
});
// GenUI Model / Embedding buttons in side tab nav
document.getElementById("wfm-side-genui-nav-btn")?.addEventListener("click", () => {
if (!state.selectedModel) return;
if (state.activeModelType === "embedding") {
applyEmbeddingToPrompt(state.selectedModel, "positive");
} else {
applyToGenUI(state.selectedModel, state.activeModelType);
}
});
document.getElementById("wfm-side-genui-np-btn")?.addEventListener("click", () => {
if (state.selectedModel) applyEmbeddingToPrompt(state.selectedModel, "negative");
});
// Initialize badge filter bar
renderBadgeFilter();
+5 -7
View File
@@ -5,6 +5,7 @@
import { showToast } from "./app.js";
import { comfyUI } from "./comfyui-client.js";
import { t } from "./i18n.js";
import { escapeHtml } from "./util.js";
// ── State ─────────────────────────────────────────────────
@@ -50,9 +51,6 @@ function categoryBadgeHtml(cat) {
return `<span class="wfm-badge wfm-badge-category">${cat}</span>`;
}
function escapeHtml(s) {
return String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
}
// ── API ───────────────────────────────────────────────────
@@ -586,7 +584,7 @@ function renderSideGroups(node) {
const name = input?.value?.trim();
if (!name) return;
if (state.nodeGroups[name]) {
showToast("Group already exists", "warning");
showToast(t("groupExists"), "warning");
return;
}
state.nodeGroups[name] = [node.name];
@@ -604,7 +602,7 @@ function renderSideGroups(node) {
const newName = prompt(`Rename group "${oldName}" to:`, oldName);
if (!newName || newName === oldName) return;
if (state.nodeGroups[newName] !== undefined) {
showToast("Group name already exists", "warning");
showToast(t("groupNameExists"), "warning");
return;
}
state.nodeGroups[newName] = state.nodeGroups[oldName];
@@ -613,7 +611,7 @@ function renderSideGroups(node) {
if (state.groupFilter === oldName) state.groupFilter = newName;
renderSideGroups(node);
renderFilters();
showToast(`Renamed to "${newName}"`, "success");
showToast(t("renamedTo", newName), "success");
});
// グループ削除
@@ -627,7 +625,7 @@ function renderSideGroups(node) {
if (state.groupFilter === name) state.groupFilter = "";
renderSideGroups(node);
renderFilters();
showToast(`Group "${name}" deleted`, "success");
showToast(t("groupDeleted", name), "success");
});
}
+119 -68
View File
@@ -4,6 +4,7 @@
import { showToast } from "./app.js";
import { t } from "./i18n.js";
import { readJsonStorage } from "./util.js";
// ============================================
// State
@@ -115,9 +116,7 @@ async function loadAllPresets() {
promptPresets = await fetchPresets();
// Load groups from localStorage
try {
pmGroups = JSON.parse(localStorage.getItem(PM_GROUPS_KEY) || "{}");
} catch { pmGroups = {}; }
pmGroups = readJsonStorage(PM_GROUPS_KEY);
// Clean stale entries from groups (preserve reserved groups even if empty)
const validIds = new Set(promptPresets.map(p => p.id));
@@ -379,26 +378,70 @@ function renderPmGroups(container) {
}
// ============================================
// Ollama API helpers
// AI Assistant helpers (Ollama / LM Studio)
// ============================================
async function ollamaModels() {
const res = await fetch("/api/wfm/ollama/models");
return await res.json();
const PROMPT_AI_KEY = "wfm_prompt_ai_settings";
function loadPromptAiSettings() {
try { return JSON.parse(localStorage.getItem(PROMPT_AI_KEY) || "{}"); } catch { return {}; }
}
async function ollamaTest() {
const res = await fetch("/api/wfm/ollama/test", { method: "POST" });
return await res.json();
// バックエンド変更検知用: モデル一覧を取得した時点のバックエンド名を記録
let _promptAiBackendForModels = null;
function getPromptAiConfig() {
const s = loadPromptAiSettings();
const backend = s.backend || "ollama";
const url = (s.backendUrl || (backend === "ollama" ? "http://localhost:11434" : "http://localhost:1234")).replace(/\/$/, "");
return { backend, url };
}
async function ollamaChat(model, messages) {
const res = await fetch("/api/wfm/ollama/chat", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ model, messages }),
});
return await res.json();
async function fetchAiModels() {
const { backend, url } = getPromptAiConfig();
if (backend === "ollama") {
const res = await fetch(`${url}/api/tags`);
if (!res.ok) throw new Error(`HTTP ${res.status}`);
return (await res.json()).models?.map(m => m.name) || [];
} else {
const res = await fetch(`${url}/v1/models`);
if (!res.ok) throw new Error(`HTTP ${res.status}`);
return ((await res.json()).data || []).map(m => m.id);
}
}
async function chatWithAi(model, messages) {
const { backend, url } = getPromptAiConfig();
if (backend === "ollama") {
const res = await fetch(`${url}/api/chat`, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ model, messages, stream: false }),
});
if (!res.ok) throw new Error(`HTTP ${res.status}`);
return (await res.json()).message?.content || "";
} else {
// LM Studio: convert Ollama-style messages (with .images) to OpenAI content arrays
const openAiMessages = messages.map(msg => {
if (msg.images?.length) {
return {
role: msg.role,
content: [
{ type: "text", text: msg.content },
...msg.images.map(b64 => ({ type: "image_url", image_url: { url: `data:image/jpeg;base64,${b64}` } })),
],
};
}
return { role: msg.role, content: msg.content };
});
const res = await fetch(`${url}/v1/chat/completions`, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ model, messages: openAiMessages, stream: false }),
});
if (!res.ok) throw new Error(`HTTP ${res.status}`);
return (await res.json()).choices?.[0]?.message?.content || "";
}
}
// ============================================
@@ -463,7 +506,7 @@ function clearChat() {
if (chat) {
chat.innerHTML = `
<div class="wfm-ollama-welcome">
<p>AI Assistant (Ollama)</p>
<p>AI Assistant</p>
<p>${t("assistantWelcome")}</p>
</div>
`;
@@ -527,6 +570,24 @@ async function sendMessage() {
const message = input.value.trim();
if (!message) return;
// バックエンドが変更されていたらモデル一覧を自動更新
const { backend } = getPromptAiConfig();
if (backend !== _promptAiBackendForModels) {
const status = document.getElementById("wfm-ollama-status");
if (status) { status.textContent = `Switching to ${backend}...`; status.className = "wfm-ollama-status"; }
try {
const models = await fetchAiModels();
const savedModel = loadPromptAiSettings().model || "";
modelSelect.innerHTML = models.length
? models.map(name => `<option value="${name}" ${name === savedModel ? "selected" : ""}>${name}</option>`).join("")
: `<option value="">${t("noModelsFound")}</option>`;
_promptAiBackendForModels = backend;
if (status) { status.textContent = `${models.length} models [${backend}]`; status.className = "wfm-ollama-status connected"; }
} catch {
if (status) { status.textContent = t("failedConnect"); status.className = "wfm-ollama-status error"; }
}
}
const model = modelSelect.value;
if (!model) {
showToast(t("selectModelFirst"), "error");
@@ -546,16 +607,11 @@ async function sendMessage() {
if (sendBtn) sendBtn.disabled = true;
try {
const data = await ollamaChat(model, ollamaState.chatHistory);
if (data.status === "success" && data.message) {
const reply = data.message.content;
addChatMessage("assistant", reply);
ollamaState.chatHistory.push({ role: "assistant", content: reply });
ollamaState.attachedImage = null;
updateAttachmentDisplay();
} else {
showToast(t("error") + ": " + (data.error || data.message || "No response"), "error");
}
const reply = await chatWithAi(model, ollamaState.chatHistory);
addChatMessage("assistant", reply);
ollamaState.chatHistory.push({ role: "assistant", content: reply });
ollamaState.attachedImage = null;
updateAttachmentDisplay();
} catch (err) {
showToast(t("error") + ": " + err.message, "error");
} finally {
@@ -598,12 +654,8 @@ async function sendTranslate(direction) {
};
const prompt = prompts[direction];
const data = await ollamaChat(model, [{ role: "user", content: prompt }]);
if (data.status === "success" && data.message) {
addChatMessage("assistant", data.message.content);
} else {
showToast(t("error") + ": No response", "error");
}
const reply = await chatWithAi(model, [{ role: "user", content: prompt }]);
addChatMessage("assistant", reply);
} catch (err) {
showToast(t("error") + ": " + err.message, "error");
} finally {
@@ -859,20 +911,23 @@ function wcUpdateFilePicker() {
// ============================================
export function initPromptTab() {
// Ollama model refresh
// AI model refresh
async function refreshModels() {
const select = document.getElementById("wfm-ollama-model");
const status = document.getElementById("wfm-ollama-status");
const { backend } = getPromptAiConfig();
try {
const data = await ollamaModels();
if (data.status === "success" && data.models) {
select.innerHTML = data.models
.map((m) => `<option value="${m.name}">${m.name}</option>`)
.join("");
if (status) {
status.textContent = `${data.models.length} models`;
status.className = "wfm-ollama-status connected";
}
const models = await fetchAiModels();
const savedModel = loadPromptAiSettings().model || "";
if (select) {
select.innerHTML = models.length
? models.map(name => `<option value="${name}" ${name === savedModel ? "selected" : ""}>${name}</option>`).join("")
: `<option value="">${t("noModelsFound")}</option>`;
}
_promptAiBackendForModels = backend;
if (status) {
status.textContent = `${models.length} models [${backend}]`;
status.className = "wfm-ollama-status connected";
}
} catch {
if (status) {
@@ -892,15 +947,11 @@ export function initPromptTab() {
const status = document.getElementById("wfm-ollama-status");
if (status) { status.textContent = "Testing..."; status.className = "wfm-ollama-status"; }
try {
const data = await ollamaTest();
if (data.connected) {
if (status) { status.textContent = t("connected"); status.className = "wfm-ollama-status connected"; }
await refreshModels();
} else {
if (status) { status.textContent = t("failedConnect"); status.className = "wfm-ollama-status error"; }
}
await fetchAiModels();
if (status) { status.textContent = t("connectedCheck"); status.className = "wfm-ollama-status connected"; }
await refreshModels();
} catch {
if (status) { status.textContent = t("error"); status.className = "wfm-ollama-status error"; }
if (status) { status.textContent = t("failedConnect"); status.className = "wfm-ollama-status error"; }
}
});
@@ -1050,43 +1101,43 @@ export function initPromptTab() {
if (!name || !name.trim()) return;
const key = name.trim();
if (pmGroups[key]) {
showToast("Group already exists", "error");
showToast(t("groupExists"), "error");
return;
}
pmGroups[key] = [];
saveGroups();
renderPresetManager();
showToast(`Group "${key}" created`, "success");
showToast(t("groupCreated", key), "success");
});
document.getElementById("wfm-preset-add-to-group-btn")?.addEventListener("click", () => {
const groupSelect = document.getElementById("wfm-preset-group-select");
const groupName = groupSelect?.value;
if (!groupName) {
showToast("Select a group first", "error");
showToast(t("selectGroupFirst"), "error");
return;
}
const id = presetSelect?.value;
if (!id) {
showToast("Select a preset first", "error");
showToast(t("selectPresetFirst"), "error");
return;
}
if (!pmGroups[groupName]) pmGroups[groupName] = [];
if (pmGroups[groupName].includes(id)) {
showToast("Already in this group", "info");
showToast(t("alreadyInGroup"), "info");
return;
}
pmGroups[groupName].push(id);
saveGroups();
renderPresetManager();
showToast("Added to group", "success");
showToast(t("addedToGroup"), "success");
});
document.getElementById("wfm-preset-del-group-btn")?.addEventListener("click", () => {
const groupSelect = document.getElementById("wfm-preset-group-select");
const groupName = groupSelect?.value;
if (!groupName) {
showToast("Select a group first", "error");
showToast(t("selectGroupFirst"), "error");
return;
}
if (PROMPT_RESERVED_GROUPS.includes(groupName)) {
@@ -1097,7 +1148,7 @@ export function initPromptTab() {
delete pmGroups[groupName];
saveGroups();
renderPresetManager();
showToast(`Group "${groupName}" deleted`, "success");
showToast(t("groupDeleted", groupName), "success");
});
// --- Preset Manager ---
@@ -1160,7 +1211,7 @@ export function initPromptTab() {
const n = prompt("Number of items to pick (n):", "2");
if (n === null) return;
const num = parseInt(n, 10);
if (isNaN(num) || num < 1) { showToast("Enter a positive integer", "error"); return; }
if (isNaN(num) || num < 1) { showToast(t("enterPositiveInt"), "error"); return; }
const template = "{" + num + "$$|}";
const start = ta.selectionStart;
wcInsertAtCursor(ta, template);
@@ -1198,7 +1249,7 @@ export function initPromptTab() {
if (!src || !dst) return;
dst.value = src.value;
dst.dispatchEvent(new Event("input", { bubbles: true }));
showToast("Sent to Positive Prompt", "success");
showToast(t("sentToPositive"), "success");
});
document.getElementById("wfm-wc-to-neg-btn")?.addEventListener("click", () => {
@@ -1207,7 +1258,7 @@ export function initPromptTab() {
if (!src || !dst) return;
dst.value = src.value;
dst.dispatchEvent(new Event("input", { bubbles: true }));
showToast("Sent to Negative Prompt", "success");
showToast(t("sentToNegative"), "success");
});
document.getElementById("wfm-wc-clear-btn")?.addEventListener("click", () => {
@@ -1235,22 +1286,22 @@ export function initPromptTab() {
const ext = extSelect?.value || "txt";
const content = contentTA?.value || "";
if (!rawName) { showToast("Enter a filename", "error"); return; }
if (!rawName) { showToast(t("pleaseEnterFilename"), "error"); return; }
// Validate each path component (allow letters, numbers, -, _, ., space)
const nameParts = rawName.split("/");
if (nameParts.some(p => !p || !/^[\w\-. ]+$/.test(p))) {
showToast("Invalid path. Use folder/name format, each part: letters, numbers, -, _, . only", "error");
showToast(t("invalidPathFormat"), "error");
return;
}
const name = rawName;
const filename = `${name}.${ext}`;
const saved = await wcSaveFile(filename, content);
if (saved) {
showToast(`Saved: ${filename}`, "success");
showToast(t("savedAs", filename), "success");
wcCloseEditor();
wcRefreshFiles();
} else {
showToast("Failed to save file", "error");
showToast(t("saveFailed"), "error");
}
});
@@ -1259,7 +1310,7 @@ export function initPromptTab() {
if (!wcEditingFilename) return;
if (!confirm(`Delete "${wcEditingFilename}"?`)) return;
await wcDeleteFile(wcEditingFilename);
showToast(`Deleted: ${wcEditingFilename}`, "success");
showToast(t("deletedName", wcEditingFilename), "success");
wcCloseEditor();
wcRefreshFiles();
});
+93 -49
View File
@@ -6,6 +6,8 @@ import { showToast } from "./app.js";
import { comfyUI } from "./comfyui-client.js";
import { t, getLang, getSummaryLang, setLang, setSummaryLang, getLanguageOptions, getSummaryLanguageOptions } from "./i18n.js";
import { getSettings, readJsonStorage } from "./util.js";
const SETTINGS_KEY = "wfm_settings";
function rgbToHex(rgb) {
@@ -15,11 +17,7 @@ function rgbToHex(rgb) {
}
function loadLocalSettings() {
try {
return JSON.parse(localStorage.getItem(SETTINGS_KEY) || "{}");
} catch {
return {};
}
return readJsonStorage(SETTINGS_KEY);
}
function saveLocalSettings(patch) {
@@ -639,28 +637,38 @@ export async function initSettingsTab() {
<div id="wfm-settings-url-status" style="font-size:12px;margin-top:4px;"></div>
</details>
<!-- Ollama Settings -->
<!-- AI Assistant Settings (Prompt Tab) -->
<details class="wfm-settings-section">
<summary class="wfm-settings-summary">${t("ollamaSettings")}</summary>
<div class="wfm-form-group">
<label>${t("aiSettingsBackend")}</label>
<div class="wfm-ai-backend-row">
<label class="wfm-ai-radio-label">
<input type="radio" name="wfm-prompt-ai-backend" value="ollama"> Ollama
</label>
<label class="wfm-ai-radio-label">
<input type="radio" name="wfm-prompt-ai-backend" value="lmstudio"> LM Studio
</label>
</div>
</div>
<div class="wfm-form-group">
<label>${t("ollamaUrl")}</label>
<input type="text" class="wfm-input" id="wfm-settings-ollama-url"
value="${serverSettings.ollama_url || "http://localhost:11434"}"
<input type="text" class="wfm-input" id="wfm-settings-prompt-ai-url"
placeholder="http://localhost:11434">
</div>
<div class="wfm-form-group">
<label>${t("ollamaDefaultModel")}</label>
<div style="display:flex;gap:8px;">
<select class="wfm-select" id="wfm-settings-ollama-model" style="flex:1;">
<select class="wfm-select" id="wfm-settings-prompt-ai-model" style="flex:1;">
<option value="">${t("selectModel")}</option>
</select>
<button class="wfm-btn wfm-btn-sm" id="wfm-settings-ollama-refresh">${t("refresh")}</button>
<button class="wfm-btn wfm-btn-sm" id="wfm-settings-prompt-ai-refresh">${t("refresh")}</button>
</div>
</div>
<div style="display:flex;gap:8px;margin-top:8px;">
<button class="wfm-btn wfm-btn-primary wfm-btn-sm" id="wfm-settings-ollama-save">${t("saveOllama")}</button>
<button class="wfm-btn wfm-btn-sm" id="wfm-settings-ollama-test">${t("testConnection")}</button>
<span id="wfm-settings-ollama-status" style="font-size:12px;line-height:28px;"></span>
<button class="wfm-btn wfm-btn-primary wfm-btn-sm" id="wfm-settings-prompt-ai-save">${t("saveOllama")}</button>
<button class="wfm-btn wfm-btn-sm" id="wfm-settings-prompt-ai-test">${t("testConnection")}</button>
<span id="wfm-settings-prompt-ai-status" style="font-size:12px;line-height:28px;"></span>
</div>
</details>
@@ -960,7 +968,7 @@ export async function initSettingsTab() {
setLang(lang);
saveLocalSettings({ ...loadLocalSettings(), uiLang: lang });
// Re-render the entire page to apply new language
showToast("Language changed. Reloading...", "success");
showToast(t("languageChanged"), "success");
setTimeout(() => location.reload(), 500);
});
@@ -1056,54 +1064,90 @@ export async function initSettingsTab() {
}
});
// --- Ollama model list loader ---
async function loadOllamaModels() {
const select = document.getElementById("wfm-settings-ollama-model");
// --- AI Assistant (Prompt Tab) settings ---
const PROMPT_AI_KEY = "wfm_prompt_ai_settings";
const loadPromptAiCfg = () => {
try { return JSON.parse(localStorage.getItem(PROMPT_AI_KEY) || "{}"); } catch { return {}; }
};
const savePromptAiCfg = (patch) => {
const data = { ...loadPromptAiCfg(), ...patch };
localStorage.setItem(PROMPT_AI_KEY, JSON.stringify(data));
};
// Restore saved values into UI
const promptAiSaved = loadPromptAiCfg();
const promptAiBackendSaved = promptAiSaved.backend || "ollama";
document.querySelectorAll('input[name="wfm-prompt-ai-backend"]').forEach(r => {
r.checked = r.value === promptAiBackendSaved;
});
const promptAiUrlEl = document.getElementById("wfm-settings-prompt-ai-url");
if (promptAiUrlEl) {
promptAiUrlEl.value = promptAiSaved.backendUrl || "";
promptAiUrlEl.placeholder = promptAiBackendSaved === "ollama" ? "http://localhost:11434" : "http://localhost:1234";
}
// Backend change → update URL placeholder
document.querySelectorAll('input[name="wfm-prompt-ai-backend"]').forEach(r => {
r.addEventListener("change", () => {
const backend = document.querySelector('input[name="wfm-prompt-ai-backend"]:checked')?.value || "ollama";
if (promptAiUrlEl) promptAiUrlEl.placeholder = backend === "ollama" ? "http://localhost:11434" : "http://localhost:1234";
});
});
// Load models directly from the selected backend
async function loadPromptAiModels() {
const select = document.getElementById("wfm-settings-prompt-ai-model");
if (!select) return;
const backend = document.querySelector('input[name="wfm-prompt-ai-backend"]:checked')?.value || "ollama";
const url = (promptAiUrlEl?.value.trim() || (backend === "ollama" ? "http://localhost:11434" : "http://localhost:1234")).replace(/\/$/, "");
try {
const res = await fetch("/api/wfm/ollama/models");
const data = await res.json();
const models = data.models || [];
const savedModel = serverSettings.ollama_model || "llava";
let models = [];
if (backend === "ollama") {
const res = await fetch(`${url}/api/tags`);
models = (await res.json()).models?.map(m => m.name) || [];
} else {
const res = await fetch(`${url}/v1/models`);
models = ((await res.json()).data || []).map(m => m.id);
}
const saved = loadPromptAiCfg().model || "";
select.innerHTML = models.length
? models.map((m) => `<option value="${m.name}" ${m.name === savedModel ? "selected" : ""}>${m.name}</option>`).join("")
? models.map(name => `<option value="${name}" ${name === saved ? "selected" : ""}>${name}</option>`).join("")
: `<option value="">${t("noModelsFound")}</option>`;
} catch {
select.innerHTML = `<option value="">${t("failedLoadModels")}</option>`;
}
}
await loadOllamaModels();
await loadPromptAiModels();
// Refresh Ollama models
document.getElementById("wfm-settings-ollama-refresh")?.addEventListener("click", loadOllamaModels);
document.getElementById("wfm-settings-prompt-ai-refresh")?.addEventListener("click", loadPromptAiModels);
// Test Ollama connection
document.getElementById("wfm-settings-ollama-test")?.addEventListener("click", async () => {
const statusEl = document.getElementById("wfm-settings-ollama-status");
statusEl.textContent = "Testing...";
statusEl.style.color = "var(--wfm-text-secondary)";
document.getElementById("wfm-settings-prompt-ai-test")?.addEventListener("click", async () => {
const statusEl = document.getElementById("wfm-settings-prompt-ai-status");
const backend = document.querySelector('input[name="wfm-prompt-ai-backend"]:checked')?.value || "ollama";
const url = (promptAiUrlEl?.value.trim() || (backend === "ollama" ? "http://localhost:11434" : "http://localhost:1234")).replace(/\/$/, "");
if (statusEl) { statusEl.textContent = t("aiStatusConnecting"); statusEl.style.color = "var(--wfm-text-secondary)"; }
try {
const res = await fetch("/api/wfm/ollama/test", { method: "POST" });
const data = await res.json();
statusEl.textContent = data.connected ? t("ollamaConnected") : `${t("ollamaFailed")}: ${data.message}`;
statusEl.style.color = data.connected ? "var(--wfm-success)" : "var(--wfm-danger)";
let count = 0;
if (backend === "ollama") {
const res = await fetch(`${url}/api/tags`);
count = ((await res.json()).models || []).length;
} else {
const res = await fetch(`${url}/v1/models`);
count = ((await res.json()).data || []).length;
}
if (statusEl) { statusEl.textContent = `${t("ollamaConnected")} (${count} models)`; statusEl.style.color = "var(--wfm-success)"; }
await loadPromptAiModels();
} catch (err) {
statusEl.textContent = `${t("error")}: ${err.message}`;
statusEl.style.color = "var(--wfm-danger)";
if (statusEl) { statusEl.textContent = `${t("ollamaFailed")}: ${err.message}`; statusEl.style.color = "var(--wfm-danger)"; }
}
});
// Save Ollama settings (to server)
document.getElementById("wfm-settings-ollama-save")?.addEventListener("click", async () => {
const ollamaUrl = document.getElementById("wfm-settings-ollama-url")?.value.trim() || "http://localhost:11434";
const ollamaModel = document.getElementById("wfm-settings-ollama-model")?.value || "";
try {
await saveServerSettings({ ollama_url: ollamaUrl, ollama_model: ollamaModel });
serverSettings.ollama_url = ollamaUrl;
serverSettings.ollama_model = ollamaModel;
showToast(t("ollamaSaved"), "success");
} catch (err) {
showToast(`${t("saveError")}: ${err.message}`, "error");
}
document.getElementById("wfm-settings-prompt-ai-save")?.addEventListener("click", () => {
const backend = document.querySelector('input[name="wfm-prompt-ai-backend"]:checked')?.value || "ollama";
const url = promptAiUrlEl?.value.trim() || "";
const model = document.getElementById("wfm-settings-prompt-ai-model")?.value || "";
savePromptAiCfg({ backend, backendUrl: url, model });
showToast(t("ollamaSaved"), "success");
});
// CivitAI host select
@@ -1176,7 +1220,7 @@ export async function initSettingsTab() {
// Clear default workflow
document.getElementById("wfm-settings-clear-wf")?.addEventListener("click", () => {
const s = JSON.parse(localStorage.getItem("wfm_settings") || "{}");
const s = getSettings();
delete s.defaultWorkflow;
delete s.defaultWorkflowData;
localStorage.setItem("wfm_settings", JSON.stringify(s));
+667
View File
@@ -0,0 +1,667 @@
/**
* Tagger Tab
* Handles WD Tagger / DeepDanbooru + Ollama VLM single/batch tagging.
*/
import { t } from "./i18n.js";
import { showToast } from "./app.js";
// ── 状態 ────────────────────────────────────────────────────────
const state = {
/** @type {string|null} 現在の画像 base64 (data URI prefix を除く) */
imageB64: null,
/** @type {string} 元のファイルパス (Galleryから来た場合) */
imagePath: "",
/** @type {string} 表示名 */
imageName: "",
/** @type {NodeJS.Timeout|null} バッチポーリングタイマー */
batchPollTimer: null,
/** @type {number|null} DB編集中の行ID */
dbEditId: null,
};
// ── 初期化 ──────────────────────────────────────────────────────
export function initTaggerTab() {
_applyI18n();
_setupSubtabs();
_setupSliders();
_setupOllamaToggle();
_setupSingleActions();
_setupBatchActions();
_setupDbActions();
_loadModels();
_loadSettings();
}
/** GalleryタブからTaggerタブへ画像を渡す */
export function openImageInTaggerTab(img) {
// タブを切り替え
document.querySelectorAll(".wfm-tab").forEach(b => b.classList.remove("active"));
document.querySelectorAll(".wfm-tab-content").forEach(s => s.classList.remove("active"));
const btn = document.querySelector('.wfm-tab[data-tab="tagger"]');
const sec = document.getElementById("wfm-tab-tagger");
if (btn) btn.classList.add("active");
if (sec) sec.classList.add("active");
// 画像を読み込む (Gallery APIから取得)
if (!img?.path) return;
const url = `/wfm/gallery/image/serve?path=${encodeURIComponent(img.path)}`;
fetch(url)
.then(r => {
if (!r.ok) throw new Error(`HTTP ${r.status}`);
return r.blob();
})
.then(blob => {
const reader = new FileReader();
reader.onload = e => {
_setPreviewFromDataUrl(e.target.result, img.filename || img.path.split(/[\\/]/).pop());
state.imagePath = img.path;
};
reader.readAsDataURL(blob);
})
.catch(() => showToast(t("taggerNoImage"), "error"));
}
// ── i18n ─────────────────────────────────────────────────────────
function _applyI18n() {
const map = {
"wfm-tagger-from-gallery-btn": "taggerFromGallery",
"wfm-tagger-upload-label": "taggerUpload",
"wfm-tagger-threshold-label": "taggerThreshold",
"wfm-tagger-char-threshold-label": "taggerCharThreshold",
"wfm-tagger-generate-btn": "taggerGenerateTags",
"wfm-tagger-ollama-header-label": "taggerOllamaEnable",
"wfm-tagger-ollama-url-label": "taggerOllamaUrl",
"wfm-tagger-ollama-model-label": "taggerOllamaModel",
"wfm-tagger-ollama-prompt-label": "taggerOllamaPrompt",
"wfm-tagger-ollama-max-label": "taggerOllamaMaxTags",
"wfm-tagger-result-header": "taggerResult",
"wfm-tagger-send-genui-btn": "taggerSendToGenUI",
"wfm-tagger-send-prompt-btn": "taggerSendToPrompt",
"wfm-tagger-save-gallery-btn": "taggerSaveToGallery",
"wfm-tagger-write-file-btn": "taggerWriteToFile",
"wfm-tagger-save-db-btn": "taggerSaveToDB",
"wfm-tagger-batch-folder-header": "taggerBatchFolder",
"wfm-tagger-batch-threshold-label": "taggerThreshold",
"wfm-tagger-batch-char-threshold-label": "taggerCharThreshold",
"wfm-tagger-batch-url-label": "taggerOllamaUrl",
"wfm-tagger-batch-model-label": "taggerOllamaModel",
"wfm-tagger-batch-prompt-label": "taggerOllamaPrompt",
"wfm-tagger-batch-output-header": "taggerBatchOutput",
"wfm-tagger-batch-save-db-label": "taggerSaveToDB",
"wfm-tagger-batch-write-file-label": "taggerWriteToFile",
"wfm-tagger-batch-write-txt-label": "taggerBatchWriteTxt",
"wfm-tagger-batch-start-btn": "taggerBatchStart",
"wfm-tagger-batch-stop-btn": "taggerBatchStop",
"wfm-tagger-db-search-btn": "taggerDbSearch",
"wfm-tagger-db-show-all-btn": "taggerDbShowAll",
"wfm-tagger-db-export-btn": "taggerDbExport",
"wfm-tagger-db-th-file": "taggerDbFile",
"wfm-tagger-db-th-interrogator": "taggerDbInterrogator",
"wfm-tagger-db-th-vlm": "taggerDbVlm",
"wfm-tagger-db-th-date": "taggerDbDate",
"wfm-tagger-db-edit-interr-label": "taggerDbInterrogator",
"wfm-tagger-db-edit-vlm-label": "taggerDbVlm",
"wfm-tagger-db-save-btn": "taggerDbSave",
"wfm-tagger-db-delete-btn": "taggerDbDelete",
};
for (const [id, key] of Object.entries(map)) {
const el = document.getElementById(id);
if (el) el.textContent = t(key);
}
// サブタブボタン
const subtabKeys = ["taggerSingleTab", "taggerBatchTab", "taggerDbTab"];
document.querySelectorAll(".wfm-tagger-subtab-btn").forEach((btn, i) => {
btn.textContent = t(subtabKeys[i] || "");
});
// プレースホルダー
const ph = document.getElementById("wfm-tagger-preview-placeholder");
if (ph) ph.textContent = t("taggerNoImage");
}
// ── サブタブ切り替え ─────────────────────────────────────────────
function _setupSubtabs() {
document.querySelectorAll(".wfm-tagger-subtab-btn").forEach(btn => {
btn.addEventListener("click", () => {
document.querySelectorAll(".wfm-tagger-subtab-btn").forEach(b => b.classList.remove("active"));
btn.classList.add("active");
const tab = btn.dataset.taggerTab;
document.querySelectorAll(".wfm-tagger-subtab").forEach(s => {
s.style.display = s.id === `wfm-tagger-${tab}` ? "" : "none";
});
if (tab === "db") _dbLoad();
});
});
}
// ── スライダー ───────────────────────────────────────────────────
function _setupSliders() {
[
["wfm-tagger-threshold", "wfm-tagger-threshold-val"],
["wfm-tagger-char-threshold", "wfm-tagger-char-threshold-val"],
["wfm-tagger-batch-threshold", "wfm-tagger-batch-threshold-val"],
["wfm-tagger-batch-char-threshold", "wfm-tagger-batch-char-threshold-val"],
].forEach(([sliderId, valId]) => {
const slider = document.getElementById(sliderId);
const val = document.getElementById(valId);
if (!slider || !val) return;
val.textContent = slider.value;
slider.addEventListener("input", () => { val.textContent = slider.value; });
});
}
// ── Ollama トグル ────────────────────────────────────────────────
function _setupOllamaToggle() {
const chk = document.getElementById("wfm-tagger-ollama-enable");
const wrap = document.getElementById("wfm-tagger-ollama-settings");
if (chk && wrap) {
chk.addEventListener("change", () => {
wrap.style.display = chk.checked ? "" : "none";
});
wrap.style.display = chk.checked ? "" : "none";
}
}
// ── モデル一覧ロード ─────────────────────────────────────────────
async function _loadModels() {
try {
const res = await fetch("/wfm/tagger/models");
const data = await res.json();
const models = data.models || [];
["wfm-tagger-model", "wfm-tagger-batch-model"].forEach(selId => {
const sel = document.getElementById(selId);
if (!sel) return;
sel.innerHTML = `<option value="">${t("taggerNoModel")}</option>` +
models.map(m => `<option value="${m.name}">[${m.type}] ${m.name}</option>`).join("");
});
} catch (e) {
console.warn("tagger: _loadModels error", e);
}
}
// ── Ollamaモデル一覧ロード ───────────────────────────────────────
async function _loadOllamaModels(urlId, selId) {
const urlEl = document.getElementById(urlId);
const selEl = document.getElementById(selId);
if (!urlEl || !selEl) return;
const api = urlEl.value || "http://127.0.0.1:11434";
try {
const res = await fetch(`/wfm/tagger/ollama/models?api_url=${encodeURIComponent(api)}`);
const data = await res.json();
const models = data.models || [];
if (models.length === 0) {
selEl.innerHTML = `<option value="">(${t("taggerNoModel")})</option>`;
} else {
selEl.innerHTML = models.map(m => `<option value="${m}">${m}</option>`).join("");
}
} catch {
selEl.innerHTML = `<option value="">(${t("taggerNoModel")})</option>`;
}
}
// ── 設定の読み込み/保存 ─────────────────────────────────────────
async function _loadSettings() {
try {
const res = await fetch("/wfm/tagger/settings");
const data = await res.json();
if (data.ollama_url) {
const el = document.getElementById("wfm-tagger-ollama-url");
if (el) el.value = data.ollama_url;
}
if (data.batch_ollama_url) {
const el = document.getElementById("wfm-tagger-batch-ollama-url");
if (el) el.value = data.batch_ollama_url;
}
} catch {
// 初回は無視
}
}
async function _saveSettings() {
try {
await fetch("/wfm/tagger/settings", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
ollama_url: document.getElementById("wfm-tagger-ollama-url")?.value || "",
batch_ollama_url: document.getElementById("wfm-tagger-batch-ollama-url")?.value || "",
}),
});
} catch {
// サイレントに失敗
}
}
// ── Single サブタブ ─────────────────────────────────────────────
function _setupSingleActions() {
// ファイルアップロード
document.getElementById("wfm-tagger-upload")?.addEventListener("change", e => {
const file = e.target.files?.[0];
if (!file) return;
_loadImageFile(file);
e.target.value = "";
});
// ドラッグ&ドロップ
const dropZone = document.getElementById("wfm-tagger-drop-zone");
if (dropZone) {
dropZone.addEventListener("dragover", e => {
e.preventDefault();
dropZone.classList.add("drag-over");
});
dropZone.addEventListener("dragleave", e => {
if (!dropZone.contains(e.relatedTarget)) {
dropZone.classList.remove("drag-over");
}
});
dropZone.addEventListener("drop", e => {
e.preventDefault();
dropZone.classList.remove("drag-over");
const file = e.dataTransfer.files?.[0];
if (file && file.type.startsWith("image/")) {
_loadImageFile(file);
}
});
}
// タグ生成
document.getElementById("wfm-tagger-generate-btn")?.addEventListener("click", _generateTags);
// Ollamaリフレッシュ
document.getElementById("wfm-tagger-ollama-refresh-btn")?.addEventListener("click", () => {
_loadOllamaModels("wfm-tagger-ollama-url", "wfm-tagger-ollama-model");
});
// 結果アクション
document.getElementById("wfm-tagger-send-genui-btn")?.addEventListener("click", _sendToGenUI);
document.getElementById("wfm-tagger-send-prompt-btn")?.addEventListener("click", _sendToPrompt);
document.getElementById("wfm-tagger-save-gallery-btn")?.addEventListener("click", _saveToGallery);
document.getElementById("wfm-tagger-write-file-btn")?.addEventListener("click", _writeToFile);
document.getElementById("wfm-tagger-save-db-btn")?.addEventListener("click", _saveToDb);
}
function _loadImageFile(file) {
const reader = new FileReader();
reader.onload = e => {
_setPreviewFromDataUrl(e.target.result, file.name);
state.imagePath = "";
};
reader.readAsDataURL(file);
}
function _setPreviewFromDataUrl(dataUrl, name) {
state.imageB64 = dataUrl.replace(/^data:[^;]+;base64,/, "");
state.imageName = name;
const img = document.getElementById("wfm-tagger-preview");
const ph = document.getElementById("wfm-tagger-preview-placeholder");
const nameEl = document.getElementById("wfm-tagger-image-name");
if (img) { img.src = dataUrl; img.style.display = ""; }
if (ph) ph.style.display = "none";
if (nameEl) nameEl.textContent = name;
}
async function _generateTags() {
if (!state.imageB64) {
showToast(t("taggerNoImage"), "warning");
return;
}
const model = document.getElementById("wfm-tagger-model")?.value || "";
const threshold = parseFloat(document.getElementById("wfm-tagger-threshold")?.value || "0.35");
const charThreshold = parseFloat(document.getElementById("wfm-tagger-char-threshold")?.value || "0.85");
const useOllama = document.getElementById("wfm-tagger-ollama-enable")?.checked || false;
const ollamaUrl = document.getElementById("wfm-tagger-ollama-url")?.value || "http://127.0.0.1:11434";
const ollamaModel = document.getElementById("wfm-tagger-ollama-model")?.value || "";
const ollamaPrompt = document.getElementById("wfm-tagger-ollama-prompt")?.value || "";
const maxTags = parseInt(document.getElementById("wfm-tagger-ollama-max-tags")?.value || "40");
const generateBtn = document.getElementById("wfm-tagger-generate-btn");
if (generateBtn) { generateBtn.disabled = true; generateBtn.textContent = "..."; }
try {
let tags = "";
if (model) {
const res = await fetch("/wfm/tagger/predict", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ image_b64: state.imageB64, model, threshold, char_threshold: charThreshold }),
});
const data = await res.json();
if (data.error) throw new Error(data.error);
tags = data.tags || "";
}
if (useOllama && ollamaModel) {
const res2 = await fetch("/wfm/tagger/ollama/predict", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
image_b64: state.imageB64, api_url: ollamaUrl,
model: ollamaModel, prompt: ollamaPrompt, max_tags: maxTags,
}),
});
const data2 = await res2.json();
if (data2.error) throw new Error(data2.error);
const vlm = data2.tags || "";
tags = [tags, vlm].filter(Boolean).join(", ");
}
if (!tags) { showToast(t("taggerNoTags"), "warning"); return; }
document.getElementById("wfm-tagger-result").value = tags;
showToast(t("taggerDone"), "success");
_saveSettings();
} catch (e) {
showToast(e.message, "error");
} finally {
if (generateBtn) { generateBtn.disabled = false; generateBtn.textContent = t("taggerGenerateTags"); }
}
}
function _sendToGenUI() {
const tags = document.getElementById("wfm-tagger-result")?.value || "";
if (!tags) { showToast(t("taggerNoTags"), "warning"); return; }
const ta = document.getElementById("wfm-prompt-pos-text");
if (!ta) { showToast(t("taggerNoGenUI"), "warning"); return; }
const cur = ta.value;
ta.value = cur ? `${cur}, ${tags}` : tags;
ta.dispatchEvent(new Event("input", { bubbles: true }));
document.getElementById("wfm-prompt-pos-apply")?.click();
showToast(t("taggerSentToGenUI"), "success");
}
function _sendToPrompt() {
const tags = document.getElementById("wfm-tagger-result")?.value || "";
if (!tags) { showToast(t("taggerNoTags"), "warning"); return; }
const ta = document.getElementById("wfm-preset-pos");
if (!ta) { showToast(t("taggerNoGalleryImage"), "warning"); return; }
const cur = ta.value;
ta.value = cur ? `${cur}, ${tags}` : tags;
ta.dispatchEvent(new Event("input", { bubbles: true }));
showToast(t("taggerSentToPrompt"), "success");
}
async function _saveToGallery() {
const tags = document.getElementById("wfm-tagger-result")?.value || "";
if (!tags || !state.imagePath) {
showToast(t("taggerNoGalleryImage"), "warning");
return;
}
try {
const tagsArray = tags.split(",").map(s => s.trim()).filter(Boolean);
const res = await fetch("/wfm/gallery/image/meta", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ path: state.imagePath, tags: tagsArray }),
});
const data = await res.json();
if (data.error) throw new Error(data.error);
showToast(t("taggerSavedToGallery"), "success");
} catch (e) {
showToast(e.message, "error");
}
}
async function _writeToFile() {
const tags = document.getElementById("wfm-tagger-result")?.value || "";
if (!tags || !state.imagePath) {
showToast(t("taggerNoGalleryImage"), "warning");
return;
}
try {
const res = await fetch("/wfm/tagger/write_meta", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ path: state.imagePath, tags }),
});
const data = await res.json();
if (data.error) throw new Error(data.error);
showToast(t("taggerWrittenToFile"), "success");
} catch (e) {
showToast(e.message, "error");
}
}
async function _saveToDb() {
const tags = document.getElementById("wfm-tagger-result")?.value || "";
if (!tags) { showToast(t("taggerNoTags"), "warning"); return; }
try {
const res = await fetch("/wfm/tagger/db/save", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ filename: state.imageName, interrogator_tags: tags, vlm_tags: "" }),
});
const data = await res.json();
if (data.error) throw new Error(data.error);
showToast(t("taggerSavedToDB"), "success");
} catch (e) {
showToast(e.message, "error");
}
}
// ── Batch サブタブ ───────────────────────────────────────────────
function _setupBatchActions() {
document.getElementById("wfm-tagger-batch-ollama-refresh-btn")?.addEventListener("click", () => {
_loadOllamaModels("wfm-tagger-batch-ollama-url", "wfm-tagger-batch-ollama-model");
});
document.getElementById("wfm-tagger-batch-start-btn")?.addEventListener("click", _batchStart);
document.getElementById("wfm-tagger-batch-stop-btn")?.addEventListener("click", _batchStop);
}
async function _batchStart() {
const folder = document.getElementById("wfm-tagger-batch-folder")?.value || "";
if (!folder) { showToast(t("taggerBatchFolder"), "warning"); return; }
const body = {
folder,
model: document.getElementById("wfm-tagger-batch-model")?.value || "",
threshold: parseFloat(document.getElementById("wfm-tagger-batch-threshold")?.value || "0.35"),
char_threshold: parseFloat(document.getElementById("wfm-tagger-batch-char-threshold")?.value || "0.85"),
use_ollama: document.getElementById("wfm-tagger-batch-ollama-enable")?.checked || false,
ollama_api: document.getElementById("wfm-tagger-batch-ollama-url")?.value || "http://127.0.0.1:11434",
ollama_model: document.getElementById("wfm-tagger-batch-ollama-model")?.value || "",
ollama_prompt: document.getElementById("wfm-tagger-batch-ollama-prompt")?.value || "",
save_db: document.getElementById("wfm-tagger-batch-save-db")?.checked ?? true,
write_file: document.getElementById("wfm-tagger-batch-write-file")?.checked || false,
write_txt: document.getElementById("wfm-tagger-batch-write-txt")?.checked || false,
};
try {
const res = await fetch("/wfm/tagger/batch/start", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify(body),
});
const data = await res.json();
if (data.error) throw new Error(data.error);
document.getElementById("wfm-tagger-batch-start-btn").disabled = true;
document.getElementById("wfm-tagger-batch-stop-btn").disabled = false;
document.getElementById("wfm-tagger-batch-log").value = "";
_startBatchPoll();
} catch (e) {
showToast(e.message, "error");
}
}
async function _batchStop() {
await fetch("/wfm/tagger/batch/stop", { method: "POST" });
}
function _startBatchPoll() {
if (state.batchPollTimer) clearInterval(state.batchPollTimer);
state.batchPollTimer = setInterval(_pollBatch, 1000);
}
async function _pollBatch() {
try {
const res = await fetch("/wfm/tagger/batch/status");
const data = await res.json();
const total = data.total || 0;
const done = data.done || 0;
const pct = total > 0 ? Math.round((done / total) * 100) : 0;
const bar = document.getElementById("wfm-tagger-batch-progress-bar");
const txt = document.getElementById("wfm-tagger-batch-progress-text");
if (bar) bar.style.width = pct + "%";
if (txt) txt.textContent = `${done} / ${total} (${pct}%)`;
const logEl = document.getElementById("wfm-tagger-batch-log");
if (logEl && data.log?.length) {
logEl.value = data.log.join("\n");
logEl.scrollTop = logEl.scrollHeight;
}
if (!data.running) {
clearInterval(state.batchPollTimer);
state.batchPollTimer = null;
document.getElementById("wfm-tagger-batch-start-btn").disabled = false;
document.getElementById("wfm-tagger-batch-stop-btn").disabled = true;
showToast(t("taggerDone"), "success");
}
} catch {
// 無視
}
}
// ── DB サブタブ ──────────────────────────────────────────────────
function _setupDbActions() {
document.getElementById("wfm-tagger-db-search-btn")?.addEventListener("click", _dbSearch);
document.getElementById("wfm-tagger-db-show-all-btn")?.addEventListener("click", _dbLoad);
document.getElementById("wfm-tagger-db-export-btn")?.addEventListener("click", _dbExport);
document.getElementById("wfm-tagger-db-search-input")?.addEventListener("keydown", e => {
if (e.key === "Enter") _dbSearch();
});
document.getElementById("wfm-tagger-db-save-btn")?.addEventListener("click", _dbSave);
document.getElementById("wfm-tagger-db-delete-btn")?.addEventListener("click", _dbDelete);
}
async function _dbLoad() {
try {
const res = await fetch("/wfm/tagger/db/list?limit=200&offset=0");
const data = await res.json();
_renderDbTable(data.rows || []);
} catch (e) {
showToast(e.message, "error");
}
}
async function _dbSearch() {
const q = document.getElementById("wfm-tagger-db-search-input")?.value || "";
if (!q) { _dbLoad(); return; }
try {
const res = await fetch(`/wfm/tagger/db/search?q=${encodeURIComponent(q)}`);
const data = await res.json();
_renderDbTable(data.rows || []);
} catch (e) {
showToast(e.message, "error");
}
}
function _renderDbTable(rows) {
const tbody = document.getElementById("wfm-tagger-db-tbody");
if (!tbody) return;
if (!rows.length) {
tbody.innerHTML = `<tr><td colspan="5" style="text-align:center;padding:20px;color:var(--wfm-text-secondary)">${t("taggerDbEmpty")}</td></tr>`;
return;
}
tbody.innerHTML = rows.map(row => `
<tr data-id="${row.id}" title="${_esc(row.all_tags)}">
<td>${row.id}</td>
<td>${_esc(row.filename)}</td>
<td>${_esc(_truncate(row.interrogator_tags, 60))}</td>
<td>${_esc(_truncate(row.vlm_tags, 60))}</td>
<td>${_esc(row.created_at?.split("T")[0] || row.created_at || "")}</td>
</tr>
`).join("");
tbody.querySelectorAll("tr").forEach(tr => {
tr.addEventListener("click", () => {
tbody.querySelectorAll("tr").forEach(r => r.classList.remove("selected"));
tr.classList.add("selected");
const row = rows.find(r => r.id === parseInt(tr.dataset.id));
if (row) _openDbEdit(row);
});
});
}
function _openDbEdit(row) {
state.dbEditId = row.id;
const panel = document.getElementById("wfm-tagger-db-edit-panel");
const header = document.getElementById("wfm-tagger-db-edit-header");
const interrEl = document.getElementById("wfm-tagger-db-edit-interrogator");
const vlmEl = document.getElementById("wfm-tagger-db-edit-vlm");
if (!panel) return;
if (header) header.textContent = `ID: ${row.id} ${row.filename}`;
if (interrEl) interrEl.value = row.interrogator_tags;
if (vlmEl) vlmEl.value = row.vlm_tags;
panel.style.display = "";
}
async function _dbSave() {
if (state.dbEditId == null) return;
const interrogator_tags = document.getElementById("wfm-tagger-db-edit-interrogator")?.value || "";
const vlm_tags = document.getElementById("wfm-tagger-db-edit-vlm")?.value || "";
try {
const res = await fetch(`/wfm/tagger/db/${state.dbEditId}`, {
method: "PUT",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ interrogator_tags, vlm_tags }),
});
const data = await res.json();
if (data.error) throw new Error(data.error);
showToast(t("taggerDbSaved"), "success");
_dbLoad();
} catch (e) {
showToast(e.message, "error");
}
}
async function _dbDelete() {
if (state.dbEditId == null) return;
if (!confirm(`Delete DB record #${state.dbEditId}?`)) return;
try {
const res = await fetch(`/wfm/tagger/db/${state.dbEditId}`, { method: "DELETE" });
const data = await res.json();
if (data.error) throw new Error(data.error);
document.getElementById("wfm-tagger-db-edit-panel").style.display = "none";
state.dbEditId = null;
showToast(t("taggerDbDeleted"), "success");
_dbLoad();
} catch (e) {
showToast(e.message, "error");
}
}
function _dbExport() {
const a = document.createElement("a");
a.href = "/wfm/tagger/db/export";
a.download = "tagger_tags.csv";
a.click();
}
// ── ユーティリティ ───────────────────────────────────────────────
function _esc(str) {
return String(str || "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
}
function _truncate(str, len) {
if (!str) return "";
return str.length > len ? str.slice(0, len) + "…" : str;
}
+28
View File
@@ -0,0 +1,28 @@
/**
* Shared utilities
*/
// HTMLエスケープ(属性値・テキストコンテンツ両方で安全に使える)
export function escapeHtml(s) {
return String(s)
.replace(/&/g, "&amp;")
.replace(/</g, "&lt;")
.replace(/>/g, "&gt;")
.replace(/"/g, "&quot;")
.replace(/'/g, "&#x27;");
}
// localStorage からJSONを安全に読む(不正JSON・未設定時はfallback)
export function readJsonStorage(key, fallback = {}) {
try {
const raw = localStorage.getItem(key);
return raw ? JSON.parse(raw) : fallback;
} catch {
return fallback;
}
}
// プラグイン共通設定 (wfm_settings)
export function getSettings() {
return readJsonStorage("wfm_settings");
}
+44 -30
View File
@@ -10,6 +10,7 @@ import { loadWorkflowIntoEditor } from "./generate-tab.js";
import { t, getSummaryPrompt } from "./i18n.js";
import { highlightJSON } from "./json-highlight.js";
import { openBadgeEditModal } from "./models-tab.js";
import { escapeHtml, getSettings, readJsonStorage } from "./util.js";
// ============================================
// Constants
@@ -33,26 +34,39 @@ const state = {
function getBadgePalette() {
try { return JSON.parse(localStorage.getItem("wfm_models_badge_palette") || "{}"); }
catch { return {}; }
return readJsonStorage("wfm_models_badge_palette");
}
function saveBadgePalette(palette) {
localStorage.setItem("wfm_models_badge_palette", JSON.stringify(palette));
}
function escapeHtml(s) {
return String(s)
.replace(/&/g, "&amp;")
.replace(/</g, "&lt;")
.replace(/>/g, "&gt;")
.replace(/"/g, "&quot;");
}
// ============================================
// Open in ComfyUI
// Open in ComfyUI / Send to Canvas
// ============================================
function sendToCanvas(workflowData) {
try {
// window.opener経由でComfyUIキャンバスに直接ロード(推奨)
if (window.opener && typeof window.opener.wfmReceiveWorkflow === "function") {
window.opener.wfmReceiveWorkflow(workflowData);
showToast(t("workflowSentToCanvas"), "success");
return;
}
// フォールバック: localStorage + タイトルドラッグ(UI形式のみ)
const fmt = comfyWorkflow.detectFormat(workflowData);
if (fmt === "api") {
showToast(t("apiFormatCanvasNoOpener"), "error");
return;
}
localStorage.setItem("wfm_pending_workflow", JSON.stringify(workflowData));
showToast(t("workflowSentToCanvas"), "success");
} catch (err) {
showToast(t("errorWithMsg", err.message), "error");
}
}
function openInComfyUI(workflowData) {
// Open ComfyUI frontend in a new tab and load the workflow.
// Same-origin, so we can access the child window's app object.
@@ -94,7 +108,7 @@ const groups = {
load() {
try {
this._data = JSON.parse(localStorage.getItem("wfm_groups") || "{}");
this._data = readJsonStorage("wfm_groups");
} catch {
this._data = {};
}
@@ -501,7 +515,7 @@ async function toggleFavorite(wf, btnEl) {
btnEl.textContent = newVal ? "\u2605" : "\u2606";
btnEl.classList.toggle("active", newVal);
} catch (err) {
showToast("Error: " + err.message, "error");
showToast(t("errorWithMsg", err.message), "error");
}
}
@@ -677,7 +691,7 @@ function renderSideGroup(wf) {
groups.remove(filename, btn.dataset.group);
renderSideGroup(wf);
_refreshGroupFilter();
showToast(`Removed from "${btn.dataset.group}"`, "success");
showToast(t("removedFromGroupName", btn.dataset.group), "success");
});
});
@@ -687,7 +701,7 @@ function renderSideGroup(wf) {
if (!g) return;
groups.assign(filename, g);
renderSideGroup(wf);
showToast(`Added to "${g}"`, "success");
showToast(t("addedToGroupName", g), "success");
});
// グループ作成(作成後に現在のWFに追加)
@@ -696,14 +710,14 @@ function renderSideGroup(wf) {
const name = input?.value.trim();
if (!name) return;
if (!groups.createGroup(name)) {
showToast(`"${name}" already exists`, "warning");
showToast(t("nameAlreadyExists", name), "warning");
return;
}
groups.assign(filename, name);
input.value = "";
renderSideGroup(wf);
_refreshGroupFilter();
showToast(`Group "${name}" created`, "success");
showToast(t("groupCreated", name), "success");
});
// グループ名変更
@@ -717,13 +731,13 @@ function renderSideGroup(wf) {
const newName = prompt(`Rename group "${oldName}" to:`, oldName);
if (!newName || newName === oldName) return;
if (!groups.renameGroup(oldName, newName)) {
showToast("Rename failed", "error");
showToast(t("renameFailed"), "error");
return;
}
if (state.groupFilter === oldName) state.groupFilter = newName;
renderSideGroup(wf);
_refreshGroupFilter();
showToast(`Renamed to "${newName}"`, "success");
showToast(t("renamedTo", newName), "success");
});
// グループ削除
@@ -743,7 +757,7 @@ function renderSideGroup(wf) {
}
renderSideGroup(wf);
_refreshGroupFilter();
showToast(`Group "${name}" deleted`, "success");
showToast(t("groupDeleted", name), "success");
});
_refreshGroupFilter();
@@ -865,7 +879,7 @@ function openDetailModal(wf) {
</section>
<div class="wfm-modal-actions">
<button class="wfm-btn wfm-btn-primary" id="wfm-detail-load">${t("loadInGenerate")}</button>
<button class="wfm-btn wfm-btn-sm" id="wfm-detail-open-comfyui">${t("openInComfyUI")}</button>
<button class="wfm-btn wfm-btn-sm" id="wfm-detail-open-comfyui">${t("sendToCanvas")}</button>
<button class="wfm-btn wfm-btn-sm" id="wfm-detail-set-default">${t("setAsDefault")}</button>
<button class="wfm-btn wfm-btn-sm" id="wfm-detail-change-thumb">${t("changeThumbnail")}</button>
<input type="file" id="wfm-detail-thumb-file" accept="image/png,image/webp,image/jpeg" style="display:none">
@@ -903,7 +917,7 @@ function openDetailModal(wf) {
favBtn.classList.toggle("active", newVal);
renderGrid();
} catch (err) {
showToast("Error: " + err.message, "error");
showToast(t("errorWithMsg", err.message), "error");
}
});
titleEl.parentNode.insertBefore(favBtn, titleEl);
@@ -1015,11 +1029,11 @@ function openDetailModal(wf) {
}
});
// Open in ComfyUI
// Send to Canvas
document.getElementById("wfm-detail-open-comfyui")?.addEventListener("click", async () => {
try {
const wfData = await getRawWorkflow(wf.filename);
openInComfyUI(wfData);
sendToCanvas(wfData);
} catch (err) {
showToast(t("loadError") + ": " + err.message, "error");
}
@@ -1036,7 +1050,7 @@ function openDetailModal(wf) {
apiData = await comfyWorkflow.convertUiToApi(wfData);
}
// Save to localStorage
const settings = JSON.parse(localStorage.getItem("wfm_settings") || "{}");
const settings = getSettings();
settings.defaultWorkflow = wf.filename;
settings.defaultWorkflowData = apiData;
localStorage.setItem("wfm_settings", JSON.stringify(settings));
@@ -1186,7 +1200,7 @@ export function initWorkflowTab() {
showToast(msg, ng.length ? "error" : "success");
await loadWorkflows();
} catch (err) {
showToast("Import error: " + err.message, "error");
showToast(t("importErrorMsg", err.message), "error");
}
e.target.value = "";
});
@@ -1229,10 +1243,10 @@ export function initWorkflowTab() {
const data = await importFiles(files);
const ok =
data.results?.filter((r) => r.status === "success").length ?? 0;
showToast(`${ok} file(s) imported via drag & drop`, "success");
showToast(t("importedViaDrop", ok), "success");
await loadWorkflows();
} catch (err) {
showToast("Import error: " + err.message, "error");
showToast(t("importErrorMsg", err.message), "error");
}
});
}
@@ -1292,12 +1306,12 @@ export function initWorkflowTab() {
}
});
// Toolbar: Open in ComfyUI button
// Toolbar: Send to Canvas button
document.getElementById("wfm-list-open-comfyui-btn")?.addEventListener("click", async () => {
if (!state.selectedWf) return;
try {
const wfData = await getRawWorkflow(state.selectedWf.filename);
openInComfyUI(wfData);
sendToCanvas(wfData);
} catch (err) {
showToast(t("loadError") + ": " + err.message, "error");
}
@@ -1306,7 +1320,7 @@ export function initWorkflowTab() {
// Toolbar: Refresh button
document.getElementById("wfm-refresh-btn")?.addEventListener("click", async () => {
await loadWorkflows();
showToast("Refreshed", "success");
showToast(t("refreshed"), "success");
});
// Toolbar: ⚙ settings button (view settings panel)
+395 -30
View File
@@ -7,6 +7,7 @@
<link rel="icon" type="image/svg+xml" href="/wfm_static/favicon.svg">
<link rel="stylesheet" href="/wfm_static/css/main.css">
<link rel="stylesheet" href="/wfm_static/css/gallery-tab.css">
<link rel="stylesheet" href="/wfm_static/css/tagger-tab.css">
</head>
<body>
<!-- Header -->
@@ -22,6 +23,7 @@
<button class="wfm-tab" data-tab="prompt">Prompt</button>
<button class="wfm-tab" data-tab="metadata">Metadata</button>
<button class="wfm-tab" data-tab="gallery">Gallery</button>
<button class="wfm-tab" data-tab="tagger">Tagger</button>
<button class="wfm-tab" data-tab="settings">Settings</button>
<button class="wfm-tab" data-tab="help">Help</button>
<button class="wfm-tab" data-tab="ai">AI TOOL</button>
@@ -47,7 +49,7 @@
<option value="">All Groups</option>
</select>
<button id="wfm-list-load-btn" class="wfm-btn wfm-btn-sm wfm-btn-primary" disabled title="Select a card first">Load in GenerateUI</button>
<button id="wfm-list-open-comfyui-btn" class="wfm-btn wfm-btn-sm" disabled title="Select a card first">Open in ComfyUI</button>
<button id="wfm-list-open-comfyui-btn" class="wfm-btn wfm-btn-sm" disabled title="Select a card first">Send to Canvas</button>
<div class="wfm-view-btns">
<button class="wfm-view-btn active" data-view="thumb" title="Thumbnail">&#8862;</button>
<button class="wfm-view-btn" data-view="table" title="Table">&#8801;</button>
@@ -231,6 +233,8 @@
<button class="wfm-models-side-tab-btn active" data-side-tab="info">Info</button>
<button class="wfm-models-side-tab-btn" data-side-tab="group">Group</button>
<button class="wfm-models-side-tab-btn" data-side-tab="civitai">CivitAI</button>
<button id="wfm-side-genui-nav-btn" class="wfm-btn wfm-btn-sm" style="display:none;margin-left:auto;align-self:center;margin-right:4px;"></button>
<button id="wfm-side-genui-np-btn" class="wfm-btn wfm-btn-sm" style="display:none;align-self:center;margin-right:6px;"></button>
</div>
<!-- Info Tab -->
<div id="wfm-models-side-info" class="wfm-models-side-content active" style="overflow-y:auto;padding:12px;">
@@ -451,6 +455,14 @@
<div class="wfm-feeder-layout">
<!-- Left: Node selector + params + presets -->
<div class="wfm-feeder-settings">
<!-- Mode toggle -->
<div style="display:flex;gap:4px;margin-bottom:10px;">
<button id="wfm-feeder-mode-loop" class="wfm-btn wfm-btn-sm wfm-btn-primary" data-mode="loop">Image Loop</button>
<button id="wfm-feeder-mode-gallery" class="wfm-btn wfm-btn-sm" data-mode="gallery">Gallery</button>
</div>
<!-- Image Loop mode section -->
<div id="wfm-feeder-loop-section">
<div class="wfm-feeder-pane-header">ImageFeeder Node</div>
<div style="display:flex;gap:6px;align-items:center;margin-bottom:8px;">
<select id="wfm-feeder-node-sel" class="wfm-select" style="flex:1;min-width:0;"></select>
@@ -517,10 +529,56 @@
<button id="wfm-feeder-run-btn" class="wfm-btn wfm-btn-primary" style="flex:1;">▶ Run</button>
<button id="wfm-feeder-stop-btn" class="wfm-btn wfm-btn-danger" style="flex:1;" disabled>■ Stop</button>
</div>
</div><!-- /wfm-feeder-loop-section -->
<!-- Gallery mode section -->
<div id="wfm-feeder-gal-section" style="display:none;">
<div class="wfm-feeder-pane-header">Gallery Feeder Node</div>
<div style="display:flex;gap:6px;align-items:center;margin-bottom:8px;">
<select id="wfm-feeder-gal-node-sel" class="wfm-select" style="flex:1;min-width:0;"></select>
<button id="wfm-feeder-gal-apply-btn" class="wfm-btn wfm-btn-primary" style="white-space:nowrap;">Apply</button>
</div>
<div class="wfm-feeder-field-row">
<label class="wfm-feeder-label">Group</label>
<select id="wfm-feeder-gal-group" class="wfm-select wfm-feeder-input"></select>
</div>
<div class="wfm-feeder-field-row">
<label class="wfm-feeder-label">Sort Mode</label>
<select id="wfm-feeder-gal-sort" class="wfm-select wfm-feeder-input">
<option value="filename_asc">Filename A-Z</option>
<option value="filename_desc">Filename Z-A</option>
<option value="random">Random</option>
</select>
</div>
<div class="wfm-feeder-field-row">
<label class="wfm-feeder-label">Index</label>
<input type="number" id="wfm-feeder-gal-index" class="wfm-input wfm-feeder-input" value="0" min="0">
</div>
<div class="wfm-feeder-field-row">
<label class="wfm-feeder-label">Seed</label>
<input type="number" id="wfm-feeder-gal-seed" class="wfm-input wfm-feeder-input" value="0">
</div>
<div class="wfm-feeder-pane-header" style="margin-top:12px;">Run</div>
<div class="wfm-feeder-field-row">
<label class="wfm-feeder-label">After gen</label>
<select id="wfm-feeder-gal-control-after" class="wfm-select wfm-feeder-input">
<option value="loop">Loop</option>
<option value="increment">Increment</option>
<option value="fixed">Fixed</option>
</select>
</div>
<div style="display:flex;gap:8px;margin-top:4px;">
<button id="wfm-feeder-gal-run-btn" class="wfm-btn wfm-btn-primary" style="flex:1;">▶ Run</button>
<button id="wfm-feeder-gal-stop-btn" class="wfm-btn wfm-btn-danger" style="flex:1;" disabled>■ Stop</button>
</div>
<div id="wfm-feeder-gal-status" style="font-size:11px;color:var(--wfm-text-secondary);margin-top:6px;"></div>
</div><!-- /wfm-feeder-gal-section -->
</div>
<!-- Center: Image Library -->
<div class="wfm-feeder-library">
<!-- Image Loop library -->
<div id="wfm-feeder-loop-library">
<!-- Status bar -->
<div id="wfm-feeder-status" class="wfm-feeder-status-bar">Select a folder</div>
@@ -550,6 +608,17 @@
</div>
</div>
</div>
</div><!-- /wfm-feeder-loop-library -->
<!-- Gallery mode library -->
<div id="wfm-feeder-gal-library" style="display:none;height:100%;">
<div class="wfm-feeder-pane-header" style="display:flex;align-items:center;justify-content:space-between;">
<span>Group Images</span>
</div>
<div id="wfm-feeder-gal-grid" class="wfm-feeder-grid" style="flex:1;overflow-y:auto;">
<div class="wfm-feeder-grid-msg">Select a group</div>
</div>
</div><!-- /wfm-feeder-gal-library -->
</div>
<!-- Right: Preview -->
@@ -669,7 +738,7 @@
<div id="wfm-ollama-attachments" class="wfm-ollama-attachments"></div>
<div id="wfm-ollama-chat" class="wfm-ollama-chat">
<div class="wfm-ollama-welcome">
<p>AI Assistant (Ollama)</p>
<p>AI Assistant</p>
<p>Attach images, generate prompts, translate, or ask for improvements.</p>
</div>
</div>
@@ -907,6 +976,9 @@
<div class="wfm-help-layout">
<!-- Left Sidebar -->
<nav class="wfm-help-sidebar">
<div class="wfm-help-search-wrap">
<input id="wfm-help-search" class="wfm-help-search" type="text" placeholder="Search help...">
</div>
<div class="wfm-help-nav">
<button class="wfm-help-nav-item active" data-help-page="about">About</button>
<button class="wfm-help-nav-item" data-help-page="workflow">Workflow Tab</button>
@@ -920,6 +992,7 @@
<button class="wfm-help-nav-item" data-help-page="models">Models Tab</button>
<button class="wfm-help-nav-item" data-help-page="sidepanel">Library (Side Panel)</button>
<button class="wfm-help-nav-item" data-help-page="aitool">AI TOOL Tab</button>
<button class="wfm-help-nav-item" data-help-page="tagger">Tagger Tab</button>
<button class="wfm-help-nav-item" data-help-page="shortcuts">Keyboard Shortcuts</button>
<button class="wfm-help-nav-item" data-help-page="trouble">Troubleshooting</button>
</div>
@@ -950,7 +1023,7 @@
<li id="wfm-help-wf-3">Create, rename, delete groups and assign/remove workflows</li>
<li id="wfm-help-wf-4">Import JSON/PNG files via button or drag &amp; drop</li>
<li id="wfm-help-wf-5">Side panel: thumbnail, JSON viewer (format badge: UI/API/App), clipboard copy, group management</li>
<li id="wfm-help-wf-6">Detail modal: rename, favorite, thumbnail change, badge assignment, tags, memo, AI summary, open in ComfyUI, load in GenerateUI, set as default, delete</li>
<li id="wfm-help-wf-6">Detail modal: rename, favorite, thumbnail change, badge assignment, tags, memo, AI summary, send to canvas, load in GenerateUI, set as default, delete</li>
<li id="wfm-help-wf-7">Badge management: add, rename, delete badges with custom colors shared with the Models tab (⚙ Badge button)</li>
</ul>
</div>
@@ -963,8 +1036,8 @@
<li id="wfm-help-gen-1">Connect/disconnect ComfyUI and check connection status</li>
<li id="wfm-help-gen-2">Load workflows from Workflow tab (App format .app.json not supported); Reset Workflow button re-reads the current workflow file from disk and reloads the editor; <b>Save</b> button (right end of the tab bar) saves the current workflow — including any edits made in the editor — as a new .json file to the Workflow tab; a filename dialog appears with the current workflow name as the default</li>
<li id="wfm-help-gen-3">5-tab layout — Input (Prompt + Image), Model, Settings, Feeder, Batch — Input/Model/Settings each include a Raw JSON column for instant preview and direct editing</li>
<li id="wfm-help-gen-4">Input tab: inner tabs — Prompt (positive/negative textboxes with doubled height) and Image (drag-and-drop upload); switch between tabs with the tab bar at the top of the left column</li>
<li id="wfm-help-gen-5">Model tab: Checkpoint, VAE, LoRA, ControlNet, UNET, TextEncoder selectors with filter; LoRA Stack — Apply writes all active LoRAs to the target node and simultaneously inserts LoRA syntax and CivitAI trigger words into the Positive prompt; re-applying updates the prompt by removing inactive LoRAs and re-adding active ones</li>
<li id="wfm-help-gen-4">Input tab: inner tabs — <b>Prompt</b> and <b>Image</b> (drag-and-drop upload); Prompt tab has Positive Prompt, Negative Prompt, and an <b>Embeddings</b> selector at the bottom — select a model, set Weight (default 1.0), then click <b>Paste</b> to insert <code>(embedding:Name:weight)</code> at the cursor position of the last focused textarea (defaults to Positive if neither is focused)</li>
<li id="wfm-help-gen-5">Model tab: Checkpoint, VAE, LoRA, ControlNet, UNET, TextEncoder, <b>Hypernetwork</b> (with Strength field) selectors with filter; LoRA Stack — Apply writes all active LoRAs to the target node and simultaneously inserts LoRA syntax and CivitAI trigger words into the Positive prompt; re-applying updates the prompt by removing inactive LoRAs and re-adding active ones</li>
<li id="wfm-help-gen-6">Settings tab: KSampler and Latent Image side by side, each at 50% width</li>
<li id="wfm-help-gen-7">Raw JSON always visible in the right column of each tab — edit directly and Apply to reload the workflow</li>
<li id="wfm-help-gen-8">Seed control: random, fixed, increment, decrement — seed input and mode selector stacked vertically for readability</li>
@@ -975,6 +1048,7 @@
<li id="wfm-help-gen-13">Batch tab — Center pane: group-based selection with inner tabs (Checkpoint | Lora | Prompt | Workflow); Checkpoint tab shows groups defined in the Models tab — check a group header to select all its members, or expand ▶ to check individual models; group membership always reflects the current Models tab state</li>
<li id="wfm-help-gen-14">Batch tab — Right pane (Batch Queue): 6 columns — Checkpoint, Lora, Prompt, Workflow, Sampler, Scheduler; each column has an enable checkbox; only one type active at a time; count shown per column</li>
<li id="wfm-help-gen-15">Sampler/Scheduler batch: select one or more samplers or schedulers from the left pane, enable the column in Batch Queue, then Generate to run each value through the KSampler node sequentially; sampler/scheduler lists are fetched from ComfyUI (requires connection)</li>
<li id="wfm-help-gen-16">SPA-side wildcard expansion (A1111-style): when prompt text in non-ImpactWildcard nodes (e.g. CLIPTextEncode) contains __name__ syntax, the SPA expands it at generation time by randomly picking a line from the matching file in the WFS wildcard folder; nested wildcards are re-expanded up to 5 passes; unresolved wildcards are passed through unchanged; ImpactWildcardEncode/Processor nodes are skipped (handled server-side by Impact Pack); works in both single and batch generation</li>
</ul>
</div>
</div>
@@ -982,7 +1056,10 @@
<div class="wfm-help-page" id="wfm-help-page-feeder">
<div class="wfm-help-card">
<h3 id="wfm-help-feeder-title">GenerateUI Tab — Feeder subtab</h3>
<p id="wfm-help-feeder-desc">Requires the comfyui-image-feeder custom node. Controls ImageFeeder nodes and runs continuous generation loops over an image library stored in user/default/image-loop-data/.</p>
<p id="wfm-help-feeder-desc">Two modes switchable via the [Image Loop] / [Gallery] toggle at the top of the left pane.</p>
<h4 id="wfm-help-feeder-imgloop-title" style="margin:10px 0 4px;color:var(--wfm-accent)">Image Loop mode</h4>
<p id="wfm-help-feeder-imgloop-desc">Requires the comfyui-image-feeder custom node. Controls ImageFeeder nodes and runs continuous generation loops over an image library stored in user/default/image-loop-data/.</p>
<ul>
<li id="wfm-help-feeder-1">Left pane — Node settings: select the target ImageFeeder node from the dropdown; edit all node parameters (Directory, Sort Mode, Index, Start/End Index, Batch Size, Seed, Use Selection); click Apply to write changes to the loaded workflow</li>
<li id="wfm-help-feeder-2">Left pane — Presets: save the current directory + selection as a named preset; load or delete saved presets</li>
@@ -994,6 +1071,17 @@
<li id="wfm-help-feeder-8">Seed during Run: uses the right-pane seed setting (Random / Fixed / Increment / Decrement) — the ImageFeeder's own Seed field controls random sort order only</li>
<li id="wfm-help-feeder-9">Index sync: after each generation the node returns the next index via WebSocket; the Index field updates automatically so the display stays in sync</li>
</ul>
<h4 id="wfm-help-feeder-gal-title" style="margin:14px 0 4px;color:var(--wfm-accent)">Gallery mode</h4>
<p id="wfm-help-feeder-gal-desc">Uses the built-in WFS_GalleryFeeder node (no external plugin required). Feeds images from a Gallery group into a continuous generation loop.</p>
<ul>
<li id="wfm-help-feeder-gal-1">Left pane — Node: select a WFS_GalleryFeeder node from the dropdown and click Apply to link it to the workflow; select the source group (defaults to <b>__Feeder__</b>), Sort Mode, Index (current image position), and Seed</li>
<li id="wfm-help-feeder-gal-2">Left pane — Run controls: <b>After gen</b> — Loop (wrap to start and repeat), Increment (advance and stop at last image), Fixed (always use the same index); click <b>Run</b> to start the loop, <b>Stop</b> to interrupt after the current generation</li>
<li id="wfm-help-feeder-gal-3">Center pane — Group image grid: shows all images in the selected group; click a thumbnail to select it and jump to that index; the selected image is highlighted</li>
<li id="wfm-help-feeder-gal-4">Right pane — Preview: displays the currently selected input image; updates when a thumbnail is clicked</li>
<li id="wfm-help-feeder-gal-5"><b>__Feeder__ group</b>: reserved group pre-created automatically; cannot be renamed or deleted; add images to it from the Gallery tab using the <b>F</b> overlay button on each thumbnail</li>
<li id="wfm-help-feeder-gal-6"><b>WFS_GalleryFeeder canvas controls</b>: the node also has Run / Stop / After Gen widgets added directly on the ComfyUI canvas — these work the same as the WFM UI controls and allow running the gallery feeder loop without opening WFM</li>
</ul>
</div>
</div>
@@ -1070,16 +1158,18 @@
<li id="wfm-help-gallery-1">Browse images in the ComfyUI output folder — set the folder path in Settings &gt; Gallery Output Folder</li>
<li id="wfm-help-gallery-2">3-column layout: folder tree (left) | image grid (center) | detail panel (right)</li>
<li id="wfm-help-gallery-3">Thumbnail and Table view modes; double-click any image to open fullscreen lightbox</li>
<li id="wfm-help-gallery-4">Toolbar filters: favorites (★), text search, tag filter, group filter, sort by date/name</li>
<li id="wfm-help-gallery-4">Toolbar filters: favorites (★), text search (filename / tag / prompt), tag filter, group filter, sort by date/name</li>
<li id="wfm-help-gallery-5">Folder tree: click to load images, expand with ▶; "+ New" creates a subfolder inside the selected folder, "Del" deletes it with all contents</li>
<li id="wfm-help-gallery-6">Multi-select with Ctrl+click — bulk operations: Add to Group, Favorite All, Unfavorite All, Move To..., Delete</li>
<li id="wfm-help-gallery-7">Detail panel — Info tab: filename, size, date, tags (add/remove), memo; "Move To..." moves the image to another folder, "Delete" removes it permanently</li>
<li id="wfm-help-gallery-8">Detail panel — JSON tab: displays workflow JSON from PNG embedded data (prompt / workflow keys) or from metadata saved by the Generate UI tab; one-click clipboard copy</li>
<li id="wfm-help-gallery-9">Detail panel — Groups tab: create, assign, remove, rename, and delete groups per image</li>
<li id="wfm-help-gallery-6">Multi-select with Ctrl+click — bulk bar: select group → 'Add to Group' / 'Remove from Group'; 'Favorite All' / 'Unfavorite All'; 'Compare' (2–4 images); 'Move To...'; '<b>Export</b>' (downloads all selected images as a ZIP file); 'Delete File'</li>
<li id="wfm-help-gallery-7">Detail panel — Info tab: filename, size, date, tags (add/remove), memo; <b>download icon</b> (on image hover) to download the single image; "Move To..." moves the image to another folder, "Delete File" removes it permanently</li>
<li id="wfm-help-gallery-8">Detail panel — JSON tab: displays workflow JSON from PNG embedded data (prompt / workflow keys) or from metadata saved by the Generate UI tab; 'Copy &amp; Send Canvas' button copies to clipboard and stores the workflow for title-drag to canvas</li>
<li id="wfm-help-gallery-9">Detail panel — Groups tab: create, assign, remove, rename, and delete groups per image; the <b>__Feeder__</b> group is reserved (shown with 🔒) and cannot be renamed or deleted — rename and delete buttons are disabled when it is selected</li>
<li id="wfm-help-gallery-15"><b>F button</b> (cyan overlay, top-left of each thumbnail): toggle the image in/out of the <b>__Feeder__</b> group with a single click; active state stays visible (cyan) when the image is already in the group; use this to quickly queue images for the Feeder tab Gallery mode</li>
<li id="wfm-help-gallery-10">Workflow auto-save: images generated in the Generate UI tab automatically have their workflow saved to gallery metadata and shown in the JSON tab</li>
<li id="wfm-help-gallery-11">Supports PNG (tEXt/iTXt), JPEG, WebP, GIF; workflow extraction reads ComfyUI prompt and workflow keys embedded in PNG metadata</li>
<li id="wfm-help-gallery-12"><b>Metadata</b> button (green, in the detail panel tab bar): opens the selected image in the Metadata tab for full embedded-data inspection; Alt+click on any image thumbnail has the same effect</li>
<li id="wfm-help-gallery-13"><b>Load GenUI</b> button (blue, in the detail panel tab bar): loads the embedded ComfyUI workflow from the selected image directly into the GenerateUI tab and switches to it; shows a warning toast if no workflow is embedded or the format is not supported</li>
<li id="wfm-help-gallery-14"><b>Tagger</b> button (purple, in the detail panel action row): opens the selected image directly in the Tagger tab's Single mode for instant tagging</li>
</ul>
</div>
</div>
@@ -1089,13 +1179,13 @@
<h3>Models Tab</h3>
<ul>
<li id="wfm-help-models-1">Browse installed models: Checkpoint, LoRA, VAE, ControlNet, UNET, TextEncoder, Hypernetwork, Embedding with sub-tab switching</li>
<li id="wfm-help-models-2">Thumbnail, Card, and Table view modes with pagination; Table view shows Type and Base Model columns sourced from CivitAI data alongside filename, subdirectory, and extension; <b>column headers are clickable to sort</b> — click once for ascending (▲), again for descending (▼), a third time to clear the sort; the <b>E/D</b> column sorts by enable/disable status</li>
<li id="wfm-help-models-2">Thumbnail and Table view modes with pagination; Table view shows Type and Base Model columns sourced from CivitAI data alongside filename, subdirectory, and extension; <b>column headers are clickable to sort</b> — click once for ascending (▲), again for descending (▼), a third time to clear the sort; the <b>E/D</b> column sorts by enable/disable status</li>
<li id="wfm-help-models-3">Search, tag filter, group filter, favorites filter, and status filter (All / Enabled only / Disabled only)</li>
<li id="wfm-help-models-4">Side panel: opens to CivitAI tab by default when a model is selected; Info (file path, tags, memo), Groups management, CivitAI integration</li>
<li id="wfm-help-models-5">CivitAI integration: fetch model info by SHA256 hash, batch fetch per model type</li>
<li id="wfm-help-models-6">Detail modal: preview image, CivitAI info (base model, trained words, tags), thumbnail change — upload any image format to replace the preview; changes take effect immediately without restarting ComfyUI; broken/empty preview files are automatically skipped; Delete button permanently removes the model file and all associated sidecar files</li>
<li id="wfm-help-models-7">Group management: create, rename, delete groups and assign/remove models; Checkpoint and LoRA tabs support B (Batch) and S (Stack) quick-assign buttons per model in both card and table views</li>
<li id="wfm-help-models-8">GenUI Model button: apply the selected model to the corresponding node in GenerateUI's current workflow (Checkpoint / LoRA / VAE / ControlNet / UNET / TextEncoder)</li>
<li id="wfm-help-models-8">GenUI Model button: apply the selected model to the corresponding node in GenerateUI's current workflow (Checkpoint / LoRA / VAE / ControlNet / UNET / TextEncoder / Hypernetwork); <b>Embedding</b> tab shows <b>GenUI PP</b> / <b>GenUI NP</b> buttons instead — appends <code>(embedding:Name:1.0)</code> to the Positive or Negative prompt of the loaded workflow</li>
<li id="wfm-help-models-9">User-defined badges: assign free-label badges with custom colors shared with the Workflow tab</li>
<li id="wfm-help-models-10">Enable/Disable models: toggle visibility in ComfyUI by renaming file extension (.disabled suffix). Disable per model (⏸ button on each card) or per group (Enable All / Disable All in Group panel). Changes take effect after ComfyUI refresh.</li>
<li id="wfm-help-models-11">Multi-select &amp; bulk operations: click Select (green) to enter selection mode, then check multiple models; the bulk action bar is organized into three rows — <b>Group row:</b> select an existing group and Add/Remove, or type a new name and Create &amp; Add; <b>Badge row:</b> select a badge and +Badge / −Badge to apply or remove; <b>File row:</b> select a destination subfolder (or type a new folder name) and Move to relocate model files with all sidecar files (.preview.png, .json, .civitai.info, etc.), Delete Files to permanently remove selected models; header row provides Deselect All and ★/☆ Favorite toggles</li>
@@ -1123,7 +1213,8 @@
<li id="wfm-help-sidepanel-13">I tab (Information): drop a ComfyUI PNG/WebP/JSON to inspect model, LoRA, and prompt metadata in the side panel — sub-tabs: model / lora / Prompts; supports UnetLoaderGGUF and QuadrupleCLIPLoader node types</li>
<li id="wfm-help-sidepanel-14">Information tab — drag items to canvas: model sub-tab places the loader node (Checkpoint → CheckpointLoaderSimple, VAE → VAELoader, Diffusion Model → UNETLoader, Text Encoder → CLIPLoader); double-click also places at canvas center</li>
<li id="wfm-help-sidepanel-15">Information tab — LoRA sub-tab: drag individual LoRA to place LoraLoader; "Multiple LORA" section at bottom places all LoRAs in a single Lora Loader (LoraManager) node; Prompts sub-tab: drag a prompt to place CLIPTextEncode node with text pre-filled; click prompt to view full text and copy</li>
<li id="wfm-help-sidepanel-16">AI TOOL tab: Translation and TOOLS (VLM) panes powered by Ollama or LM Studio; 3-pane layout (Translation | TOOLS | Settings) always visible; settings (backend, URL, model) are shared with the SPA AI TOOL tab via localStorage</li>
<li id="wfm-help-sidepanel-16">AI TOOL tab: Translation, Chat, TOOLS, and Settings sub-tabs powered by Ollama or LM Studio; Chat supports multi-turn conversations; TOOLS includes VLM image analysis and wildcard generation; settings shared with the SPA AI TOOL tab via localStorage</li>
<li id="wfm-help-sidepanel-17">Title drag (Send to Canvas): after clicking 'Send to Canvas' (Workflow tab) or 'Copy &amp; Send Canvas' (Gallery tab), the 'Workflow Studio Library' title turns blue with a green ● — drag it onto the canvas to load the workflow; title resets automatically after loading</li>
</ul>
</div>
</div>
@@ -1132,11 +1223,29 @@
<div class="wfm-help-card">
<h3 id="wfm-help-ai-title">AI TOOL Tab</h3>
<ul>
<li id="wfm-help-ai-1">3-pane layout — Translation (40%) | TOOLS (40%) | Settings (20%) — all panes are always visible simultaneously</li>
<li id="wfm-help-ai-2">Translation pane: translate text between Japanese, English, Chinese, or a custom Free language using Ollama or LM Studio; language selectors with ⇄ swap button; text content is also swapped on swap; selections are saved automatically</li>
<li id="wfm-help-ai-3">TOOLS pane (VLM): drop an image into the drop zone and select a task — Describe Image or Create Prompt — then click Run to analyze with a vision model; result displayed with Copy button</li>
<li id="wfm-help-ai-4">Settings pane: choose backend (Ollama / LM Studio), set the API URL, test connection, select model, and configure Free language names for translation</li>
<li id="wfm-help-ai-5">Settings are saved to localStorage and shared with the Library panel's AI TOOL tab</li>
<li id="wfm-help-ai-1">4-pane layout — Translation | Chat | TOOLS | Settings — all panes are always visible simultaneously</li>
<li id="wfm-help-ai-2">Translation pane: translate text between Japanese, English, Chinese, or a custom Free language using Ollama or LM Studio; ⇄ swap button swaps both language selectors and text content; selections are saved automatically</li>
<li id="wfm-help-ai-3">Chat pane: multi-turn conversation with the LLM; Enter to send a message, Shift+Enter for a newline; Clear button resets the conversation history</li>
<li id="wfm-help-ai-4">TOOLS pane — VLM: drop an image (PNG/JPG/WebP) and select a task (Describe Image, Create Prompt, Create Tags), then click Run to analyze with a vision model; result shown with Copy button</li>
<li id="wfm-help-ai-5">TOOLS pane — Wildcards: select "Create wildcards" from the dropdown, enter a category name and count, click Run to generate plain-text wildcard entries one per line</li>
<li id="wfm-help-ai-6">Settings pane: choose backend (Ollama / LM Studio), set API URL, test connection, select model, configure Free language names; settings are shared with the Library panel's A tab via localStorage</li>
</ul>
</div>
</div>
<div class="wfm-help-page" id="wfm-help-page-tagger">
<div class="wfm-help-card">
<h3 id="wfm-help-tagger-title">Tagger Tab</h3>
<ul>
<li id="wfm-help-tagger-1"></li>
<li id="wfm-help-tagger-2"></li>
<li id="wfm-help-tagger-3"></li>
<li id="wfm-help-tagger-4"></li>
<li id="wfm-help-tagger-5"></li>
<li id="wfm-help-tagger-6"></li>
<li id="wfm-help-tagger-7"></li>
<li id="wfm-help-tagger-8"></li>
<li id="wfm-help-tagger-9"></li>
</ul>
</div>
</div>
@@ -1163,6 +1272,7 @@
<li id="wfm-help-trouble-4">Image generation fails: Check if specified models exist in ComfyUI, verify connection, try restarting</li>
<li id="wfm-help-trouble-5">LoRA Stack fails with "No such file or directory" error: The LoRA may not be recognized by comfyui-lora-manager (known issue). Try a different LoRA or check if the file appears in Lora Manager's own UI</li>
<li id="wfm-help-trouble-6">Model loading error after moving or deleting models: ComfyUI caches file paths and may still reference old locations. Perform a Hard Reset from the ComfyUI menu (Queue → Hard Reset) or restart ComfyUI to clear the cache.</li>
<li id="wfm-help-trouble-7"></li>
</ul>
</div>
</div>
@@ -1208,6 +1318,7 @@
<select id="wfm-gallery-group-filter" class="wfm-select wfm-toolbar-select">
<option value="">All Groups</option>
</select>
<button id="wfm-gallery-fc-btn" class="wfm-btn wfm-btn-sm" title="Clear Feeder Group (__Feeder__)">FC</button>
<select id="wfm-gallery-sort" class="wfm-select wfm-toolbar-select">
<option value="date_desc">Date (Newest)</option>
<option value="date_asc">Date (Oldest)</option>
@@ -1224,15 +1335,19 @@
<!-- 複数選択時の一括操作バー -->
<div id="wfm-gallery-bulk-bar" class="wfm-gallery-bulk-bar" style="display:none;">
<span id="wfm-gallery-bulk-count" class="wfm-gallery-bulk-count"></span>
<button id="wfm-gallery-bulk-deselect" class="wfm-btn wfm-btn-sm">Deselect All</button>
<button id="wfm-gallery-bulk-deselect" class="wfm-btn wfm-btn-sm"></button>
<button id="wfm-gallery-bulk-select-all" class="wfm-btn wfm-btn-sm"></button>
<select id="wfm-gallery-bulk-group-select" class="wfm-select" style="font-size:12px;padding:3px 6px;">
<option value="">Add to Group...</option>
<option value=""></option>
</select>
<button id="wfm-gallery-bulk-group-add" class="wfm-btn wfm-btn-sm wfm-btn-primary">Add</button>
<button id="wfm-gallery-bulk-fav" class="wfm-btn wfm-btn-sm">★ Favorite All</button>
<button id="wfm-gallery-bulk-unfav" class="wfm-btn wfm-btn-sm">☆ Unfavorite All</button>
<button id="wfm-gallery-bulk-move" class="wfm-btn wfm-btn-sm">Move To...</button>
<button id="wfm-gallery-bulk-delete" class="wfm-btn wfm-btn-sm wfm-btn-danger">Delete</button>
<button id="wfm-gallery-bulk-group-add" class="wfm-btn wfm-btn-sm wfm-btn-primary"></button>
<button id="wfm-gallery-bulk-group-remove" class="wfm-btn wfm-btn-sm"></button>
<button id="wfm-gallery-bulk-fav" class="wfm-btn wfm-btn-sm"></button>
<button id="wfm-gallery-bulk-unfav" class="wfm-btn wfm-btn-sm"></button>
<button id="wfm-gallery-bulk-compare" class="wfm-btn wfm-btn-sm" style="display:none;"></button>
<button id="wfm-gallery-bulk-move" class="wfm-btn wfm-btn-sm"></button>
<button id="wfm-gallery-bulk-export" class="wfm-btn wfm-btn-sm"></button>
<button id="wfm-gallery-bulk-delete" class="wfm-btn wfm-btn-sm wfm-btn-danger"></button>
</div>
</div>
@@ -1265,7 +1380,7 @@
<span id="wfm-gallery-detail-filename" class="wfm-gallery-detail-filename"></span>
</div>
<!-- サムネイルプレビュー -->
<div id="wfm-gallery-detail-preview" class="wfm-gallery-detail-preview">
<div id="wfm-gallery-detail-preview" class="wfm-gallery-detail-preview wfm-gallery-preview-container">
<span class="wfm-placeholder">No selection</span>
</div>
<!-- タブナビ -->
@@ -1273,8 +1388,11 @@
<button class="wfm-gallery-detail-tab-btn active" data-detail-tab="info">Info</button>
<button class="wfm-gallery-detail-tab-btn" data-detail-tab="meta">JSON</button>
<button class="wfm-gallery-detail-tab-btn" data-detail-tab="group">Groups</button>
<button id="wfm-gallery-open-metadata-btn" class="wfm-gallery-detail-tab-btn wfm-gallery-action-btn-green" title="Open in Metadata tab (or Alt+click image)">Metadata</button>
<button id="wfm-gallery-load-genui-btn" class="wfm-gallery-detail-tab-btn wfm-gallery-action-btn-primary" title="Load workflow into GenerateUI">Load GenUI</button>
</div>
<div class="wfm-gallery-detail-action-row">
<button id="wfm-gallery-open-metadata-btn" class="wfm-gallery-action-btn wfm-gallery-action-btn-green" title="Open in Metadata tab (or Alt+click image)">Metadata</button>
<button id="wfm-gallery-load-genui-btn" class="wfm-gallery-action-btn wfm-gallery-action-btn-primary" title="Load workflow into GenerateUI">Load GenUI</button>
<button id="wfm-gallery-open-tagger-btn" class="wfm-gallery-action-btn wfm-gallery-action-btn-tagger" title="Open in Tagger"></button>
</div>
<!-- Info タブ -->
<div id="wfm-gallery-detail-info" class="wfm-gallery-detail-tab-content active">
@@ -1311,7 +1429,7 @@
<div id="wfm-gallery-detail-meta" class="wfm-gallery-detail-tab-content wfm-gallery-meta-tab" style="display:none;">
<div class="wfm-gallery-meta-toolbar">
<span id="wfm-gallery-meta-status" class="wfm-gallery-meta-status"></span>
<button id="wfm-gallery-copy-workflow-btn" class="wfm-btn wfm-btn-sm wfm-btn-primary" disabled title="Copy embedded workflow JSON">Copy Workflow</button>
<button id="wfm-gallery-copy-workflow-btn" class="wfm-btn wfm-btn-sm wfm-btn-primary" disabled title="Copy to clipboard and send to canvas">Copy &amp; Send Canvas</button>
</div>
<pre id="wfm-gallery-workflow-json" class="wfm-gallery-workflow-json">No workflow found in this image.</pre>
</div>
@@ -1324,6 +1442,226 @@
</div>
</section>
<!-- Tagger Tab -->
<section id="wfm-tab-tagger" class="wfm-tab-content">
<div class="wfm-tagger-subtab-nav">
<button class="wfm-tagger-subtab-btn active" data-tagger-tab="single"></button>
<button class="wfm-tagger-subtab-btn" data-tagger-tab="batch"></button>
<button class="wfm-tagger-subtab-btn" data-tagger-tab="db"></button>
</div>
<!-- Single サブタブ -->
<div id="wfm-tagger-single" class="wfm-tagger-subtab">
<div class="wfm-tagger-single-layout">
<!-- 左: 画像 -->
<div class="wfm-tagger-image-pane">
<div class="wfm-tagger-image-sources">
<label class="wfm-btn wfm-btn-sm" style="cursor:pointer">
<span id="wfm-tagger-upload-label"></span>
<input type="file" id="wfm-tagger-upload" accept="image/*" style="display:none">
</label>
</div>
<div class="wfm-tagger-preview-wrap" id="wfm-tagger-drop-zone">
<img id="wfm-tagger-preview" style="display:none; max-width:100%; max-height:100%; object-fit:contain;">
<div id="wfm-tagger-preview-placeholder" class="wfm-placeholder"></div>
</div>
<div id="wfm-tagger-image-name" class="wfm-tagger-image-name"></div>
</div>
<!-- 右: 設定・結果 -->
<div class="wfm-tagger-controls-pane">
<!-- WD Tagger -->
<div class="wfm-tagger-section">
<div class="wfm-tagger-section-header">WD Tagger / DeepDanbooru</div>
<div class="wfm-form-row wfm-tagger-form-row">
<label class="wfm-tagger-label"></label>
<select id="wfm-tagger-model" class="wfm-select wfm-tagger-select"></select>
</div>
<div class="wfm-form-row wfm-tagger-form-row">
<label class="wfm-tagger-label" id="wfm-tagger-threshold-label"></label>
<input type="range" id="wfm-tagger-threshold" min="0" max="1" step="0.01" value="0.35" class="wfm-tagger-slider">
<span id="wfm-tagger-threshold-val" class="wfm-tagger-slider-val">0.35</span>
</div>
<div class="wfm-form-row wfm-tagger-form-row">
<label class="wfm-tagger-label" id="wfm-tagger-char-threshold-label"></label>
<input type="range" id="wfm-tagger-char-threshold" min="0" max="1" step="0.01" value="0.85" class="wfm-tagger-slider">
<span id="wfm-tagger-char-threshold-val" class="wfm-tagger-slider-val">0.85</span>
</div>
<button id="wfm-tagger-generate-btn" class="wfm-btn wfm-btn-primary" style="width:100%;margin-top:6px;"></button>
</div>
<!-- Ollama VLM -->
<div class="wfm-tagger-section">
<div class="wfm-tagger-section-header">
<label style="display:flex;align-items:center;gap:6px;cursor:pointer;font-weight:600;">
<input type="checkbox" id="wfm-tagger-ollama-enable">
<span id="wfm-tagger-ollama-header-label">Ollama VLM</span>
</label>
</div>
<div id="wfm-tagger-ollama-settings" style="display:none">
<div class="wfm-form-row wfm-tagger-form-row">
<label class="wfm-tagger-label" id="wfm-tagger-ollama-url-label"></label>
<input type="text" id="wfm-tagger-ollama-url" class="wfm-search-input" value="http://127.0.0.1:11434" style="flex:1;">
</div>
<div class="wfm-form-row wfm-tagger-form-row">
<label class="wfm-tagger-label" id="wfm-tagger-ollama-model-label"></label>
<select id="wfm-tagger-ollama-model" class="wfm-select wfm-tagger-select"></select>
<button id="wfm-tagger-ollama-refresh-btn" class="wfm-btn wfm-btn-sm" title="Refresh models">↻</button>
</div>
<div class="wfm-form-row wfm-tagger-form-row" style="align-items:flex-start">
<label class="wfm-tagger-label" id="wfm-tagger-ollama-prompt-label" style="padding-top:4px;"></label>
<textarea id="wfm-tagger-ollama-prompt" class="wfm-textarea" rows="3" style="flex:1;resize:vertical;">Output danbooru-style, comma-separated, English tags for this image. ONLY output the tags. Do not use double quotes or hyphens in the tags.</textarea>
</div>
<div class="wfm-form-row wfm-tagger-form-row">
<label class="wfm-tagger-label" id="wfm-tagger-ollama-max-label"></label>
<input type="number" id="wfm-tagger-ollama-max-tags" class="wfm-search-input" value="40" min="1" max="500" style="width:70px;">
</div>
</div>
</div>
<!-- 結果 -->
<div class="wfm-tagger-section">
<div class="wfm-tagger-section-header" id="wfm-tagger-result-header"></div>
<textarea id="wfm-tagger-result" class="wfm-textarea" rows="5" style="width:100%;resize:vertical;" placeholder="Tags will appear here..."></textarea>
<div class="wfm-tagger-result-actions">
<button id="wfm-tagger-send-genui-btn" class="wfm-btn wfm-btn-sm"></button>
<button id="wfm-tagger-send-prompt-btn" class="wfm-btn wfm-btn-sm"></button>
<button id="wfm-tagger-save-gallery-btn" class="wfm-btn wfm-btn-sm"></button>
<button id="wfm-tagger-write-file-btn" class="wfm-btn wfm-btn-sm"></button>
<button id="wfm-tagger-save-db-btn" class="wfm-btn wfm-btn-sm"></button>
</div>
</div>
</div>
</div>
</div>
<!-- Batch サブタブ -->
<div id="wfm-tagger-batch" class="wfm-tagger-subtab" style="display:none">
<div class="wfm-tagger-batch-layout">
<div class="wfm-tagger-section">
<div class="wfm-tagger-section-header" id="wfm-tagger-batch-folder-header"></div>
<div class="wfm-form-row wfm-tagger-form-row">
<input type="text" id="wfm-tagger-batch-folder" class="wfm-search-input" style="flex:1;" placeholder="C:\path\to\images">
</div>
</div>
<div class="wfm-tagger-batch-cols">
<!-- WD Tagger 設定 -->
<div class="wfm-tagger-section">
<div class="wfm-tagger-section-header">WD Tagger / DeepDanbooru</div>
<div class="wfm-form-row wfm-tagger-form-row">
<label class="wfm-tagger-label"></label>
<select id="wfm-tagger-batch-model" class="wfm-select wfm-tagger-select"></select>
</div>
<div class="wfm-form-row wfm-tagger-form-row">
<label class="wfm-tagger-label" id="wfm-tagger-batch-threshold-label"></label>
<input type="range" id="wfm-tagger-batch-threshold" min="0" max="1" step="0.01" value="0.35" class="wfm-tagger-slider">
<span id="wfm-tagger-batch-threshold-val" class="wfm-tagger-slider-val">0.35</span>
</div>
<div class="wfm-form-row wfm-tagger-form-row">
<label class="wfm-tagger-label" id="wfm-tagger-batch-char-threshold-label"></label>
<input type="range" id="wfm-tagger-batch-char-threshold" min="0" max="1" step="0.01" value="0.85" class="wfm-tagger-slider">
<span id="wfm-tagger-batch-char-threshold-val" class="wfm-tagger-slider-val">0.85</span>
</div>
</div>
<!-- Ollama 設定 -->
<div class="wfm-tagger-section">
<div class="wfm-tagger-section-header">
<label style="display:flex;align-items:center;gap:6px;cursor:pointer;font-weight:600;">
<input type="checkbox" id="wfm-tagger-batch-ollama-enable">
Ollama VLM
</label>
</div>
<div id="wfm-tagger-batch-ollama-settings">
<div class="wfm-form-row wfm-tagger-form-row">
<label class="wfm-tagger-label" id="wfm-tagger-batch-url-label"></label>
<input type="text" id="wfm-tagger-batch-ollama-url" class="wfm-search-input" value="http://127.0.0.1:11434" style="flex:1;">
</div>
<div class="wfm-form-row wfm-tagger-form-row">
<label class="wfm-tagger-label" id="wfm-tagger-batch-model-label"></label>
<select id="wfm-tagger-batch-ollama-model" class="wfm-select wfm-tagger-select"></select>
<button id="wfm-tagger-batch-ollama-refresh-btn" class="wfm-btn wfm-btn-sm">↻</button>
</div>
<div class="wfm-form-row wfm-tagger-form-row" style="align-items:flex-start">
<label class="wfm-tagger-label" id="wfm-tagger-batch-prompt-label" style="padding-top:4px;"></label>
<textarea id="wfm-tagger-batch-ollama-prompt" class="wfm-textarea" rows="3" style="flex:1;resize:vertical;">Output danbooru-style, comma-separated, English tags for this image. ONLY output the tags.</textarea>
</div>
</div>
</div>
</div>
<!-- 出力設定 -->
<div class="wfm-tagger-section">
<div class="wfm-tagger-section-header" id="wfm-tagger-batch-output-header"></div>
<div style="display:flex;gap:16px;">
<label style="display:flex;align-items:center;gap:6px;cursor:pointer;">
<input type="checkbox" id="wfm-tagger-batch-save-db" checked>
<span id="wfm-tagger-batch-save-db-label"></span>
</label>
<label style="display:flex;align-items:center;gap:6px;cursor:pointer;">
<input type="checkbox" id="wfm-tagger-batch-write-file">
<span id="wfm-tagger-batch-write-file-label"></span>
</label>
<label style="display:flex;align-items:center;gap:6px;cursor:pointer;">
<input type="checkbox" id="wfm-tagger-batch-write-txt">
<span id="wfm-tagger-batch-write-txt-label"></span>
</label>
</div>
</div>
<!-- ボタン + プログレス -->
<div style="display:flex;gap:8px;align-items:center;margin-bottom:8px;">
<button id="wfm-tagger-batch-start-btn" class="wfm-btn wfm-btn-primary"></button>
<button id="wfm-tagger-batch-stop-btn" class="wfm-btn wfm-btn-danger" disabled></button>
<span id="wfm-tagger-batch-progress-text" style="font-size:12px;color:var(--wfm-text-muted);"></span>
</div>
<div class="wfm-tagger-progress-bar-wrap">
<div id="wfm-tagger-batch-progress-bar" class="wfm-tagger-progress-bar" style="width:0%"></div>
</div>
<textarea id="wfm-tagger-batch-log" class="wfm-textarea" rows="10" readonly style="width:100%;margin-top:8px;font-family:monospace;font-size:11px;"></textarea>
</div>
</div>
<!-- DB サブタブ -->
<div id="wfm-tagger-db" class="wfm-tagger-subtab" style="display:none">
<div class="wfm-tagger-db-layout">
<div class="wfm-tagger-db-toolbar">
<input type="text" id="wfm-tagger-db-search-input" class="wfm-search-input" style="flex:1;" placeholder="Search tags or filename...">
<button id="wfm-tagger-db-search-btn" class="wfm-btn wfm-btn-sm wfm-btn-primary"></button>
<button id="wfm-tagger-db-show-all-btn" class="wfm-btn wfm-btn-sm"></button>
<button id="wfm-tagger-db-export-btn" class="wfm-btn wfm-btn-sm"></button>
</div>
<div id="wfm-tagger-db-table-wrap" class="wfm-tagger-db-table-wrap">
<table id="wfm-tagger-db-table" class="wfm-table wfm-tagger-db-table">
<thead>
<tr>
<th>ID</th>
<th id="wfm-tagger-db-th-file"></th>
<th id="wfm-tagger-db-th-interrogator"></th>
<th id="wfm-tagger-db-th-vlm"></th>
<th id="wfm-tagger-db-th-date"></th>
</tr>
</thead>
<tbody id="wfm-tagger-db-tbody"></tbody>
</table>
</div>
<!-- 編集パネル -->
<div id="wfm-tagger-db-edit-panel" class="wfm-tagger-db-edit-panel" style="display:none">
<div class="wfm-tagger-section-header" id="wfm-tagger-db-edit-header"></div>
<div class="wfm-form-row wfm-tagger-form-row">
<label class="wfm-tagger-label" id="wfm-tagger-db-edit-interr-label"></label>
<textarea id="wfm-tagger-db-edit-interrogator" class="wfm-textarea" rows="3" style="flex:1;resize:vertical;"></textarea>
</div>
<div class="wfm-form-row wfm-tagger-form-row">
<label class="wfm-tagger-label" id="wfm-tagger-db-edit-vlm-label"></label>
<textarea id="wfm-tagger-db-edit-vlm" class="wfm-textarea" rows="3" style="flex:1;resize:vertical;"></textarea>
</div>
<div style="display:flex;gap:8px;margin-top:6px;">
<button id="wfm-tagger-db-save-btn" class="wfm-btn wfm-btn-sm wfm-btn-primary"></button>
<button id="wfm-tagger-db-delete-btn" class="wfm-btn wfm-btn-sm wfm-btn-danger"></button>
</div>
</div>
</div>
</div>
</section>
<!-- AI Tab -->
<section id="wfm-tab-ai" class="wfm-tab-content">
<!-- Translation pane -->
@@ -1355,6 +1693,22 @@
</div>
</div>
<div class="wfm-ai-pane-divider"></div>
<!-- Chat pane -->
<div class="wfm-ai-pane wfm-ai-pane-chat">
<div class="wfm-ai-pane-header">Chat</div>
<div class="wfm-ai-chat-container">
<div class="wfm-ai-chat-messages" id="wfm-ai-chat-messages"></div>
<div class="wfm-ai-chat-input-area">
<textarea id="wfm-ai-chat-input" class="wfm-ai-chat-input" placeholder="Type a message... (Enter to send, Shift+Enter for newline)"></textarea>
<div class="wfm-ai-chat-actions">
<button id="wfm-ai-chat-send-btn" class="wfm-btn wfm-btn-primary">Send</button>
<button id="wfm-ai-chat-clear-btn" class="wfm-btn">Clear</button>
<span id="wfm-ai-chat-status" class="wfm-ai-trans-status"></span>
</div>
</div>
</div>
</div>
<div class="wfm-ai-pane-divider"></div>
<!-- TOOLS pane -->
<div class="wfm-ai-pane wfm-ai-pane-tools">
<div class="wfm-ai-pane-header">TOOLS</div>
@@ -1364,11 +1718,22 @@
<span id="wfm-ai-vlm-label" class="wfm-ai-vlm-label">Drop or click PNG / JPG / WebP</span>
<input type="file" id="wfm-ai-vlm-file" accept="image/png,image/jpeg,image/webp" style="display:none;">
</div>
<div class="wfm-ai-wc-inputs" id="wfm-ai-wc-inputs" style="display:none">
<div class="wfm-ai-wc-row">
<label class="wfm-ai-label">Name</label>
<input type="text" id="wfm-ai-wc-name" class="wfm-input" placeholder="e.g. sports, emotions, colors">
</div>
<div class="wfm-ai-wc-row">
<label class="wfm-ai-label">Count</label>
<input type="number" id="wfm-ai-wc-count" class="wfm-input wfm-ai-wc-count" value="20" min="1" max="200">
</div>
</div>
<div class="wfm-ai-vlm-task-row">
<select id="wfm-ai-vlm-task" class="wfm-select">
<option value="describe">Describe image</option>
<option value="prompt">Create prompt</option>
<option value="tags">Create tags</option>
<option value="wildcard">Create wildcards</option>
</select>
<button id="wfm-ai-vlm-run" class="wfm-btn wfm-btn-primary">Run</button>
</div>
+178
View File
@@ -0,0 +1,178 @@
/**
* WFS_GalleryFeeder – ComfyUI canvas extension
* Adds "After Gen", Run, and Stop controls directly on the node widget area.
*/
import { app } from "../../scripts/app.js";
const FEEDER_GROUP = "__Feeder__";
// Per-node runtime state (keyed by node.id)
const _ns = new Map();
// ── Helpers ───────────────────────────────────────────────────────────
async function fetchGroupImages(groupName) {
try {
const res = await fetch(`/wfm/gallery/groups/${encodeURIComponent(groupName)}/images`);
if (!res.ok) return [];
return (await res.json()).images || [];
} catch { return []; }
}
function getOrCreate(nodeId) {
if (!_ns.has(nodeId)) {
_ns.set(nodeId, { running: false, stopFlag: false, idx: 0, images: [] });
}
return _ns.get(nodeId);
}
function getInputWidget(node, name) {
return node.widgets?.find(w => w.name === name);
}
function setWidgetValue(node, name, value) {
const w = getInputWidget(node, name);
if (!w) return;
w.value = value;
if (w.callback) w.callback(value);
app.canvas?.setDirty(true, true);
}
/** Resolves when the current prompt finishes (executing=null, interrupted), rejects on error. */
function waitForExecution() {
return new Promise((resolve, reject) => {
const cleanup = () => {
app.api.removeEventListener("executing", onExecuting);
app.api.removeEventListener("execution_error", onError);
app.api.removeEventListener("execution_interrupted", onInterrupted);
};
const onExecuting = ({ detail }) => { if (detail === null) { cleanup(); resolve(); } };
const onError = ({ detail }) => { cleanup(); reject(new Error(detail?.exception_message || "Execution error")); };
const onInterrupted = () => { cleanup(); resolve(); }; // treat interrupt as "done"
app.api.addEventListener("executing", onExecuting);
app.api.addEventListener("execution_error", onError);
app.api.addEventListener("execution_interrupted", onInterrupted);
});
}
function updateRunBtn(node) {
const st = getOrCreate(node.id);
if (node._wfsRunWidget) node._wfsRunWidget.name = st.running ? "⏳ Running..." : "▶ Run";
app.canvas?.setDirty(true, true);
}
function wfsToast(msg, severity = "warn") {
try {
const tm = app.extensionManager?.toast;
if (tm?.add) { tm.add({ severity, summary: "Gallery Feeder", detail: msg, life: 4000 }); return; }
} catch {}
console[severity === "error" ? "error" : "warn"]("[WFS_GalleryFeeder]", msg);
}
// ── Run / Stop ────────────────────────────────────────────────────────
async function startLoop(node) {
const st = getOrCreate(node.id);
if (st.running) return;
// Re-fetch images for the current group each Run
const groupName = getInputWidget(node, "group_name")?.value || FEEDER_GROUP;
const images = await fetchGroupImages(groupName);
if (images.length === 0) {
wfsToast(`No images in group "${groupName}"`, "warn");
return;
}
st.running = true;
st.stopFlag = false;
st.images = images;
st.idx = Math.max(0, Math.min(
parseInt(getInputWidget(node, "index")?.value) || 0,
images.length - 1
));
updateRunBtn(node);
// Queue first generation with current index
setWidgetValue(node, "index", st.idx);
app.queuePrompt(0, 1);
while (st.running && !st.stopFlag) {
try {
await waitForExecution();
} catch (err) {
if (st.running) wfsToast(err.message, "error");
break;
}
if (!st.running || st.stopFlag) break;
const afterGen = node._wfsAfterGenWidget?.value || "loop";
const total = st.images.length;
// Increment mode: stop after the last image
if (afterGen === "increment" && st.idx >= total - 1) break;
if (afterGen !== "fixed") {
st.idx = (st.idx + 1) % total;
setWidgetValue(node, "index", st.idx);
}
app.queuePrompt(0, 1);
}
st.running = false;
updateRunBtn(node);
}
function stopLoop(node) {
const st = getOrCreate(node.id);
if (!st.running) return;
st.stopFlag = true;
st.running = false;
try { app.api.interrupt(); } catch {}
updateRunBtn(node);
}
// ── Extension registration ────────────────────────────────────────────
app.registerExtension({
name: "WorkflowStudio.GalleryFeeder",
async beforeRegisterNodeDef(nodeType, nodeData) {
if (nodeData.name !== "WFS_GalleryFeeder") return;
const origCreated = nodeType.prototype.onNodeCreated;
nodeType.prototype.onNodeCreated = function () {
origCreated?.call(this);
const node = this;
// ── After Gen selector ────────────────────────────────────
// serialize:false → not included in widgets_values / prompt inputs
const afterGenW = node.addWidget("combo", "wfs_after_gen", "loop", () => {}, {
values: ["loop", "increment", "fixed"],
serialize: false,
});
node._wfsAfterGenWidget = afterGenW;
// ── Run button ────────────────────────────────────────────
const runW = node.addWidget("button", "▶ Run", null, () => startLoop(node));
runW.serialize = false;
node._wfsRunWidget = runW;
// ── Stop button ───────────────────────────────────────────
const stopW = node.addWidget("button", "■ Stop", null, () => stopLoop(node));
stopW.serialize = false;
node._wfsStopWidget = stopW;
};
// Clean up when node is removed from graph
const origRemoved = nodeType.prototype.onRemoved;
nodeType.prototype.onRemoved = function () {
stopLoop(this);
_ns.delete(this.id);
origRemoved?.call(this);
};
},
});
+317 -6
View File
@@ -61,7 +61,7 @@ const state = {
infoSubTab: "info-model", // "info-model" | "info-lora" | "info-prompt"
infoMeta: null, // parsed metadata from dropped file
// AI tab
aiSubTab: "ai-translate", // "ai-translate" | "ai-vlm" | "ai-settings"
aiSubTab: "ai-translate", // "ai-translate" | "ai-chat" | "ai-vlm" | "ai-settings"
};
// ============================================
@@ -241,6 +241,52 @@ const fetchWorkflowRaw = async (filename) => {
} catch { return null; }
};
// Returns true if the JSON is in ComfyUI API format (dict of nodeId→{class_type, inputs})
// rather than the UI format (has nodes[] and links[] arrays).
const isApiWorkflowFormat = (data) => {
if (!data || typeof data !== "object" || Array.isArray(data)) return false;
if (Array.isArray(data.nodes)) return false;
const keys = Object.keys(data);
return keys.length > 0 && keys.every((k) => data[k]?.class_type);
};
// Minimal API→UI conversion so app.loadGraphData() can handle API-format workflows.
// Nodes are arranged in a grid; link types use "*" since object_info is not queried here.
const convertApiToUiWorkflow = (api) => {
const nodes = [];
const links = [];
let linkId = 1;
const sortedIds = Object.keys(api).sort((a, b) => Number(a) - Number(b));
sortedIds.forEach((id, idx) => {
const node = api[id];
const col = idx % 5;
const row = Math.floor(idx / 5);
const uiNode = {
id: Number(id),
type: node.class_type,
title: node._meta?.title || node.class_type,
pos: [col * 300 + 50, row * 250 + 50],
size: [250, 200],
inputs: [],
outputs: [],
widgets_values: [],
mode: 0,
};
for (const [key, val] of Object.entries(node.inputs || {})) {
if (Array.isArray(val) && val.length === 2 && typeof val[0] === "string" && typeof val[1] === "number") {
uiNode.inputs.push({ name: key, type: "*", link: linkId });
links.push([linkId, Number(val[0]), val[1], Number(id), uiNode.inputs.length - 1, "*"]);
linkId++;
} else {
uiNode.widgets_values.push(val);
}
}
nodes.push(uiNode);
});
const maxNodeId = Math.max(0, ...sortedIds.map(Number));
return { nodes, links, groups: [], config: {}, extra: {}, version: 0.4, last_node_id: maxNodeId, last_link_id: linkId };
};
const loadWfData = async () => {
const workflows = await fetchWorkflows();
state.wfList = workflows.filter(w => w.filename !== ".index.json");
@@ -513,6 +559,30 @@ const placeLoraMgrNode = (loras, pos) => {
// Workflow canvas loading
// ============================================
/**
* Load workflow JSON onto the ComfyUI canvas.
* Delegates to app.handleFile() so ComfyUI's native path handles both UI and API
* formats (identical to dragging a file from Explorer). Falls back to
* convertApiToUiWorkflow() + loadGraphData() if handleFile is unavailable.
*/
const loadDataOnCanvas = async (data) => {
if (typeof app?.handleFile === "function") {
const blob = new Blob([JSON.stringify(data)], { type: "application/json" });
const file = new File([blob], "workflow.json", { type: "application/json" });
await app.handleFile(file);
} else {
if (isApiWorkflowFormat(data)) data = convertApiToUiWorkflow(data);
await app.loadGraphData(data);
}
};
// ============================================
// Cross-window receiver for SPA Send-to-Canvas
// ============================================
window.wfmReceiveWorkflow = async (data) => {
await loadDataOnCanvas(data);
};
const loadWorkflowOnCanvas = async (filename) => {
const displayName = filename.replace(/\.json$/i, "");
showToast(`Loading "${displayName}"...`, "info");
@@ -522,7 +592,7 @@ const loadWorkflowOnCanvas = async (filename) => {
return;
}
try {
await app.loadGraphData(data);
await loadDataOnCanvas(data);
showToast(`Loaded: ${displayName}`, "success");
} catch (err) {
showToast("Failed to load: " + err.message, "error");
@@ -548,7 +618,8 @@ const installCanvasDropHandler = () => {
e.dataTransfer.types.includes("application/x-wfm-prompt") ||
e.dataTransfer.types.includes("application/x-wfm-model") ||
e.dataTransfer.types.includes("application/x-wfm-lora-multi") ||
e.dataTransfer.types.includes("application/x-wfm-clip-text")) {
e.dataTransfer.types.includes("application/x-wfm-clip-text") ||
e.dataTransfer.types.includes("application/x-wfm-pending")) {
e.preventDefault();
e.dataTransfer.dropEffect = "copy";
}
@@ -595,6 +666,31 @@ const installCanvasDropHandler = () => {
return;
}
// Handle pending workflow drop (from Gallery / Workflow tab "Send to Canvas")
const pendingRaw = e.dataTransfer.getData("application/x-wfm-pending");
if (pendingRaw) {
e.preventDefault();
(async () => {
try {
const wfData = JSON.parse(pendingRaw);
await loadDataOnCanvas(wfData);
localStorage.removeItem("wfm_pending_workflow");
if (panelEl) {
const titleEl = panelEl.querySelector(".wfm-nlp-title");
if (titleEl) {
titleEl.draggable = false;
titleEl.classList.remove("wfm-nlp-title-pending");
titleEl.title = "Workflow Studio Library";
}
}
showToast("Workflow loaded on canvas", "success");
} catch (err) {
showToast("Failed to load workflow: " + err.message, "error");
}
})();
return;
}
// Handle workflow drop
const wfRaw = e.dataTransfer.getData("application/x-wfm-workflow");
if (wfRaw) {
@@ -763,6 +859,28 @@ const createPanel = () => {
});
});
// Pending workflow drag-to-canvas
const titleEl = panel.querySelector(".wfm-nlp-title");
const updateTitlePendingState = () => {
const hasPending = !!localStorage.getItem("wfm_pending_workflow");
titleEl.draggable = hasPending;
titleEl.classList.toggle("wfm-nlp-title-pending", hasPending);
titleEl.title = hasPending
? "Drag to canvas to load workflow"
: "Workflow Studio Library";
};
updateTitlePendingState();
panel.addEventListener("mouseenter", updateTitlePendingState);
window.addEventListener("storage", (e) => {
if (e.key === "wfm_pending_workflow") updateTitlePendingState();
});
titleEl.addEventListener("dragstart", (e) => {
const pendingRaw = localStorage.getItem("wfm_pending_workflow");
if (!pendingRaw) { e.preventDefault(); return; }
e.dataTransfer.effectAllowed = "copy";
e.dataTransfer.setData("application/x-wfm-pending", pendingRaw);
});
// Close
panel.querySelector(".wfm-nlp-close").addEventListener("click", () => togglePanel());
@@ -833,6 +951,7 @@ const rebuildSubTabs = () => {
if (state.topTab === "ai") {
const row1Tabs = [
{ key: "ai-translate", label: "Translation" },
{ key: "ai-chat", label: "Chat" },
{ key: "ai-vlm", label: "TOOLS" },
{ key: "ai-settings", label: "Settings" },
];
@@ -2959,6 +3078,24 @@ async function aiCallVLM(url, backend, model, prompt, base64Image, mimeType) {
}
}
async function aiCallChat(url, backend, model, messages) {
if (backend === "ollama") {
const r = await fetch(`${url}/api/chat`, {
method: "POST", headers: { "Content-Type": "application/json" },
body: JSON.stringify({ model, messages, stream: false }),
});
if (!r.ok) throw new Error(`HTTP ${r.status}`);
return (await r.json()).message?.content || "";
} else {
const r = await fetch(`${url}/v1/chat/completions`, {
method: "POST", headers: { "Content-Type": "application/json" },
body: JSON.stringify({ model, messages, stream: false }),
});
if (!r.ok) throw new Error(`HTTP ${r.status}`);
return (await r.json()).choices?.[0]?.message?.content || "";
}
}
async function aiFetchModels(url, backend) {
if (backend === "ollama") {
const r = await fetch(`${url}/api/tags`);
@@ -3000,6 +3137,16 @@ const renderAiTab = (container) => {
</div>
<textarea id="wfm-nlp-ai-output" class="wfm-nlp-ai-textarea wfm-nlp-ai-output" placeholder="Translation result..." readonly></textarea>
</div>
<!-- Chat sub -->
<div id="wfm-nlp-ai-chat" class="wfm-nlp-ai-pane" style="display:none;">
<div class="wfm-nlp-ai-chat-msgs" id="wfm-nlp-ai-chat-msgs"></div>
<textarea id="wfm-nlp-ai-chat-input" class="wfm-nlp-ai-textarea wfm-nlp-ai-chat-input" placeholder="Type a message..."></textarea>
<div class="wfm-nlp-ai-actions">
<button id="wfm-nlp-ai-chat-send" class="wfm-nlp-ai-btn wfm-nlp-ai-btn-primary">Send</button>
<button id="wfm-nlp-ai-chat-clear" class="wfm-nlp-ai-btn">Clear</button>
<span id="wfm-nlp-ai-chat-status" class="wfm-nlp-ai-status"></span>
</div>
</div>
<!-- TOOLS sub -->
<div id="wfm-nlp-ai-vlm" class="wfm-nlp-ai-pane" style="display:none;">
<div class="wfm-nlp-ai-vlm-drop" id="wfm-nlp-ai-vlm-drop">
@@ -3007,11 +3154,22 @@ const renderAiTab = (container) => {
<span id="wfm-nlp-ai-vlm-label" class="wfm-nlp-ai-vlm-label">Drop PNG / JPG / WebP</span>
<input type="file" id="wfm-nlp-ai-vlm-file" accept="image/png,image/jpeg,image/webp" style="display:none;">
</div>
<div id="wfm-nlp-ai-wc-inputs" style="display:none;flex-direction:column;gap:5px;">
<div class="wfm-nlp-ai-row">
<span class="wfm-nlp-ai-lbl">Name</span>
<input type="text" id="wfm-nlp-ai-wc-name" class="wfm-nlp-ai-input" style="flex:1;" placeholder="e.g. sports">
</div>
<div class="wfm-nlp-ai-row">
<span class="wfm-nlp-ai-lbl">Count</span>
<input type="number" id="wfm-nlp-ai-wc-count" class="wfm-nlp-ai-input wfm-nlp-ai-wc-count" value="20" min="1" max="200">
</div>
</div>
<div class="wfm-nlp-ai-row">
<select id="wfm-nlp-ai-vlm-task" class="wfm-nlp-ai-sel" style="flex:1;">
<option value="describe">Describe image</option>
<option value="prompt">Create prompt</option>
<option value="tags">Create tags</option>
<option value="wildcard">Create wildcards</option>
</select>
<button id="wfm-nlp-ai-vlm-run" class="wfm-nlp-ai-btn wfm-nlp-ai-btn-primary">Run</button>
</div>
@@ -3069,7 +3227,7 @@ const renderAiTab = (container) => {
const renderAiSubContent = () => {
if (!panelEl) return;
const panes = { "ai-translate": "wfm-nlp-ai-translate", "ai-vlm": "wfm-nlp-ai-vlm", "ai-settings": "wfm-nlp-ai-settings" };
const panes = { "ai-translate": "wfm-nlp-ai-translate", "ai-chat": "wfm-nlp-ai-chat", "ai-vlm": "wfm-nlp-ai-vlm", "ai-settings": "wfm-nlp-ai-settings" };
for (const [key, id] of Object.entries(panes)) {
const el = panelEl.querySelector(`#${id}`);
if (el) el.style.display = state.aiSubTab === key ? "flex" : "none";
@@ -3224,6 +3382,67 @@ const setupAiHandlers = (container) => {
// Auto-load models if settings exist
if (cfg.backendUrl && cfg.backend) refreshModels().catch(() => {});
// ---- Chat handlers ----
let chatHistory = [];
const chatMsgsEl = container.querySelector("#wfm-nlp-ai-chat-msgs");
const chatInputEl = container.querySelector("#wfm-nlp-ai-chat-input");
const chatSendBtn = container.querySelector("#wfm-nlp-ai-chat-send");
const chatClearBtn= container.querySelector("#wfm-nlp-ai-chat-clear");
const chatStatusEl= container.querySelector("#wfm-nlp-ai-chat-status");
const appendChatBubble = (role, content) => {
const div = document.createElement("div");
div.className = `wfm-nlp-ai-chat-msg wfm-nlp-ai-chat-msg-${role}`;
div.textContent = content;
chatMsgsEl.appendChild(div);
chatMsgsEl.scrollTop = chatMsgsEl.scrollHeight;
};
const sendChatMessage = async () => {
const text = chatInputEl?.value?.trim();
if (!text) return;
const c = loadAiCfg();
const backend = c.backend || "ollama";
const url = c.backendUrl || (backend === "ollama" ? "http://localhost:11434" : "http://localhost:1234");
const model = c.model;
if (!isValidAiUrl(url)) { showToast("URLは http:// または https:// で始まる必要があります", "error"); return; }
if (!model) { showToast("Please select a model in Settings", "error"); return; }
chatInputEl.value = "";
chatHistory.push({ role: "user", content: text });
appendChatBubble("user", text);
chatSendBtn.disabled = true;
chatStatusEl.textContent = "Thinking...";
chatStatusEl.className = "wfm-nlp-ai-status wfm-nlp-ai-working";
try {
const reply = await aiCallChat(url, backend, model, chatHistory);
chatHistory.push({ role: "assistant", content: reply });
appendChatBubble("assistant", reply);
chatStatusEl.textContent = "";
chatStatusEl.className = "wfm-nlp-ai-status";
} catch (err) {
chatHistory.pop();
if (chatMsgsEl.lastChild) chatMsgsEl.removeChild(chatMsgsEl.lastChild);
chatInputEl.value = text;
chatStatusEl.textContent = `エラー: ${err.message}`;
chatStatusEl.className = "wfm-nlp-ai-status wfm-nlp-ai-err";
} finally {
chatSendBtn.disabled = false;
}
};
chatSendBtn?.addEventListener("click", sendChatMessage);
chatInputEl?.addEventListener("keydown", e => {
if (e.key === "Enter" && !e.shiftKey) { e.preventDefault(); sendChatMessage(); }
});
chatClearBtn?.addEventListener("click", () => {
chatHistory = [];
if (chatMsgsEl) chatMsgsEl.innerHTML = "";
if (chatStatusEl) { chatStatusEl.textContent = ""; chatStatusEl.className = "wfm-nlp-ai-status"; }
});
// ---- VLM handlers ----
let vlmImage = null; // { base64, mimeType }
@@ -3231,10 +3450,22 @@ const setupAiHandlers = (container) => {
const vlmPreview = container.querySelector("#wfm-nlp-ai-vlm-preview");
const vlmLabel = container.querySelector("#wfm-nlp-ai-vlm-label");
const vlmFile = container.querySelector("#wfm-nlp-ai-vlm-file");
const vlmTaskSel = container.querySelector("#wfm-nlp-ai-vlm-task");
const vlmRunBtn = container.querySelector("#wfm-nlp-ai-vlm-run");
const vlmStatus = container.querySelector("#wfm-nlp-ai-vlm-status");
const vlmResult = container.querySelector("#wfm-nlp-ai-vlm-result");
const vlmCopy = container.querySelector("#wfm-nlp-ai-vlm-copy");
const wcInputs = container.querySelector("#wfm-nlp-ai-wc-inputs");
const wcNameEl = container.querySelector("#wfm-nlp-ai-wc-name");
const wcCountEl = container.querySelector("#wfm-nlp-ai-wc-count");
const updateVlmTaskUI = () => {
const isWc = vlmTaskSel?.value === "wildcard";
if (vlmDrop) vlmDrop.style.display = isWc ? "none" : "";
if (wcInputs) wcInputs.style.display = isWc ? "flex" : "none";
};
vlmTaskSel?.addEventListener("change", updateVlmTaskUI);
updateVlmTaskUI();
const loadVlmImage = async (file) => {
if (!file || !file.type.startsWith("image/")) return;
@@ -3263,7 +3494,7 @@ const setupAiHandlers = (container) => {
};
vlmRunBtn?.addEventListener("click", async () => {
if (!vlmImage) { showToast("Please drop an image", "error"); return; }
const task = vlmTaskSel?.value || "describe";
const c = loadAiCfg();
const backend = c.backend || "ollama";
const url = c.backendUrl || (backend === "ollama" ? "http://localhost:11434" : "http://localhost:1234");
@@ -3271,7 +3502,37 @@ const setupAiHandlers = (container) => {
if (!isValidAiUrl(url)) { showToast("URLは http:// または https:// で始まる必要があります", "error"); return; }
if (!model) { showToast("Please select a model in Settings", "error"); return; }
const task = container.querySelector("#wfm-nlp-ai-vlm-task")?.value || "describe";
if (task === "wildcard") {
const name = wcNameEl?.value?.trim() || "";
const count = Math.max(1, parseInt(wcCountEl?.value) || 20);
if (!name) { showToast("Please enter a wildcard name", "error"); return; }
vlmRunBtn.disabled = true;
vlmStatus.textContent = "Running...";
vlmStatus.className = "wfm-nlp-ai-status wfm-nlp-ai-working";
vlmResult.value = "";
const prompt = `Generate ${count} wildcard entries for the category "${name}". Output only plain text in English, one entry per line, no numbers, no markdown, no asterisks, no bold, nothing else.`;
try {
const result = await aiCallLLM(url, backend, model, prompt);
vlmResult.value = result.trim()
.split("\n")
.map(l => l.replace(/\*\*/g, "").replace(/^\*\s*/, "").replace(/^\d+\.\s*/, "").trim())
.filter(l => l.length > 0)
.join("\n");
vlmStatus.textContent = "完了";
vlmStatus.className = "wfm-nlp-ai-status wfm-nlp-ai-ok";
} catch (err) {
vlmStatus.textContent = `エラー: ${err.message}`;
vlmStatus.className = "wfm-nlp-ai-status wfm-nlp-ai-err";
} finally {
vlmRunBtn.disabled = false;
}
return;
}
if (!vlmImage) { showToast("Please drop an image", "error"); return; }
vlmRunBtn.disabled = true;
vlmStatus.textContent = "Running...";
vlmStatus.className = "wfm-nlp-ai-status wfm-nlp-ai-working";
@@ -3427,6 +3688,16 @@ const injectStyles = () => {
font-size: 14px;
flex: 1;
}
.wfm-nlp-title-pending {
cursor: grab;
color: #66aaff;
}
.wfm-nlp-title-pending::after {
content: " ●";
font-size: 7px;
color: #4caf50;
vertical-align: super;
}
.wfm-nlp-close {
background: none;
border: none;
@@ -4128,6 +4399,46 @@ const injectStyles = () => {
color: var(--descrip-text, #999);
pointer-events: none;
}
/* Chat */
.wfm-nlp-ai-chat-msgs {
flex: 1;
overflow-y: auto;
display: flex;
flex-direction: column;
gap: 6px;
min-height: 0;
padding: 2px;
}
.wfm-nlp-ai-chat-msg {
max-width: 92%;
padding: 6px 8px;
border-radius: 6px;
font-size: 11px;
line-height: 1.5;
word-break: break-word;
white-space: pre-wrap;
}
.wfm-nlp-ai-chat-msg-user {
align-self: flex-end;
background: var(--p-button-background, #4a9eff);
color: #fff;
}
.wfm-nlp-ai-chat-msg-assistant {
align-self: flex-start;
background: var(--comfy-input-bg, #2a2a2a);
border: 1px solid var(--border-color, #4e4e4e);
color: var(--input-text, #ddd);
}
.wfm-nlp-ai-chat-input {
min-height: 50px;
max-height: 100px;
flex: none;
flex-shrink: 0;
}
/* Wildcard count */
.wfm-nlp-ai-wc-count {
width: 60px;
}
`;
document.head.appendChild(style);
};