mirror of
https://github.com/willmiao/ComfyUI-Lora-Manager.git
synced 2026-10-08 02:22:12 -03:00
Will Miao
470d85cca6
Refreshing had no way to say "scan only this drive": a user with three external
drives had to spin all of them up for every refresh, and switching a drive off
made the next refresh treat its whole library as deleted (rows pruned from the
memory cache and the SQLite cache, preview_url stripped on the next scroll).
Backend (py/services/model_scanner.py, py/config.py):
* ReconcileScope(roots, folder) + _reconcile_cache(scope=...): files inside the
scope reconcile normally, everything outside is neither re-read nor removed.
The folder half is plumbing for the sidebar entry in the next change.
* Path-level pruning guard: cached entries under a path this walk could not
read are kept and reported instead of removed. Sources: a configured root that
is not reachable (drive switched off while LM runs), a directory os.walk
failed to enter (permissions / I/O error / Windows junction to an offline
drive), and a known first-level symlink whose target is gone
(Config.iter_path_mappings()).
* The recorded folder list is unioned instead of replaced whenever the scan did
not verify every root, so a scoped scan cannot empty the sidebar.
* _reconcile_cache returns a summary (added / removed / repaired /
scanned_roots / skipped_roots / unavailable_paths / kept_unreachable),
exposed as ModelScanner.last_reconcile_summary, returned by
BaseModelService.scan_models() and broadcast in the completed WS payload.
* _root_display_labels(): set-aware labels ("G: loras", "usb/loras") grown
leftwards with real parent segments until unique, shared by the walk-progress
line and the roots API.
* GET /scan accepts repeated `roots` (400 for unknown roots, 400 combined with
full_rebuild=true); GET /roots gains root_details (label / reachable / cached
count) while `roots` stays a plain path list for existing callers.
* serve_preview: a 404 no longer clears the cached preview_url when the file's
own directory is unreachable - browsing the grid with a drive off used to
strip preview references from the persistent cache.
Frontend:
* Refresh ▾ gains a "Scan one folder" section listing the page's roots with
their cached counts; offline roots stay clickable and explain themselves; rows
are wired by delegation (new static/js/components/controls/ScanScopeMenu.js).
* A scoped scan reports "Scanned <root>: N new, M removed"; a scan that kept
entries reports "<N> models kept: <paths> not reachable".
* registerAPI() now injects the two cross-page passthroughs (fetchModelRoots and
an argument-forwarding refreshModels) so a page facade cannot drop them: the
first version rendered an empty menu and would have run a full refresh.
* createToastElement whitelists toast types, so a wrong `type` argument degrades
to the info style instead of rendering an unstyled box.
Verified in a sandbox instance with three roots: a scoped scan walks only the
requested root (progress roots=0/1, 240 files); a full refresh with one root
offline reports kept_unreachable=60 and leaves all 420 models cached; /roots
reports the offline root with its cached count. 3699 passed, 7 skipped;
frontend 1488 passed (148 files); vue widgets 96 passed.
73 lines
2.5 KiB
JavaScript
73 lines
2.5 KiB
JavaScript
// ScanScopeMenu.js - per-root entries of the Refresh dropdown (issue #1108)
|
|
import { translate } from '../../utils/i18nHelpers.js';
|
|
|
|
/**
|
|
* Render one row per configured model root.
|
|
*
|
|
* Rows carry the root path in `data-root` and are wired by delegation, because
|
|
* the list is rebuilt every time the root set changes. An offline root stays
|
|
* clickable (the click explains why nothing can be scanned) and is only
|
|
* de-emphasised visually.
|
|
*
|
|
* @param {HTMLElement|null} menu - Container element (#refreshScopeMenu)
|
|
* @param {Array<Object>} details - `root_details` from GET /api/lm/{type}/roots
|
|
*/
|
|
export function renderScanScopeMenu(menu, details = []) {
|
|
if (!menu) {
|
|
return;
|
|
}
|
|
menu.innerHTML = '';
|
|
|
|
details.forEach(detail => {
|
|
if (!detail || !detail.path) {
|
|
return;
|
|
}
|
|
const item = document.createElement('div');
|
|
item.className = `dropdown-item scan-root-item${detail.reachable ? '' : ' is-offline'}`;
|
|
item.dataset.action = 'scan-root';
|
|
item.dataset.root = detail.path;
|
|
item.title = detail.path;
|
|
|
|
const icon = document.createElement('i');
|
|
icon.className = `fas ${detail.reachable ? 'fa-folder-open' : 'fa-plug-circle-xmark'}`;
|
|
item.appendChild(icon);
|
|
|
|
const label = document.createElement('span');
|
|
label.className = 'scan-root-label';
|
|
label.textContent = detail.label || detail.path;
|
|
item.appendChild(label);
|
|
|
|
const meta = document.createElement('span');
|
|
if (detail.reachable) {
|
|
const count = Number(detail.models || 0).toLocaleString();
|
|
meta.className = 'scan-root-count';
|
|
meta.textContent = translate(
|
|
'loras.controls.refresh.rootModels',
|
|
{ count },
|
|
`${count} models`
|
|
);
|
|
} else {
|
|
meta.className = 'scan-root-offline';
|
|
meta.textContent = translate('loras.controls.refresh.rootOffline', {}, 'Offline');
|
|
}
|
|
item.appendChild(meta);
|
|
|
|
menu.appendChild(item);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Read what a clicked row refers to.
|
|
* @param {HTMLElement} item - Row rendered by renderScanScopeMenu
|
|
* @returns {{rootPath: string, label: string, offline: boolean}}
|
|
*/
|
|
export function resolveScanScopeTarget(item) {
|
|
const rootPath = item?.dataset?.root || '';
|
|
const label = item?.querySelector?.('.scan-root-label')?.textContent || rootPath;
|
|
return {
|
|
rootPath,
|
|
label,
|
|
offline: Boolean(item?.classList?.contains('is-offline')),
|
|
};
|
|
}
|