dsh-local-sd 0.5.0 → 0.6.0

package/README.md

@@ -186,6 +186,18 @@ SD 后端占用较高显存，闲置时自动关闭。
 
 配置写在 `$DSH_HOME/local-sd.json`（Windows 是 `C:\Users\<你>\.dsh\local-sd.json`）。**每次调用都重新读取**，改完不用重启 DSH；手改这个 JSON 也一样有效。
 
+### 启动进度和命令行输出
+
+后端启动时**不再弹出黑色控制台窗口**，进度和输出都搬到设置页里：
+
+- **进度条**：读绘图程序自己的输出（加载扩展、加载权重、起 API），大致对应当前阶段；没有新输出时会缓慢爬升，不会看起来卡死。
+- **查看命令行输出**：展开后就是绘图程序真实打印的内容，出错时能看到完整的 traceback，不用再手动跑一遍 `run.bat` 找原因。
+- 日志同时写在 `$DSH_HOME/local-sd-startup.log`，每次启动覆盖。
+
+> **`--nowebui` 必须配 `--port`**：Forge 在 `--nowebui` 下如果没指定端口会默认绑 **7861**
+> （`webui.py` 里 `port=cmd_opts.port if cmd_opts.port else 7861`），而插件默认找 7860。
+> 想在后台只跑 API 不弹网页，启动参数要写 `--api --nowebui --port 7860`。
+
 ---
 
 ## 用法

package/lib/client.js

@@ -114,6 +114,28 @@ window.__ModuleLoader__.load({
 .lsd-entry:disabled{opacity:.5;cursor:default}
 .lsd-browser-foot{display:flex;flex-direction:column;gap:8px;align-items:flex-start}
 .lsd-browser-foot .lsd-actions{padding-top:0}
+/* ── startup progress + live log ────────────────────────────────────── */
+.lsd-prog{display:flex;flex-direction:column;gap:7px;padding:11px 13px;border-radius:10px;
+  border:1px solid var(--dsw-alias-border-l1,rgba(128,128,128,.26));background:var(--dsw-alias-bg-base,rgba(128,128,128,.05))}
+.lsd-prog-head{display:flex;align-items:center;gap:8px;font-size:12px}
+.lsd-prog-phase{flex:1;min-width:0;font-weight:500;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.lsd-prog-pct{flex:none;font-variant-numeric:tabular-nums;color:var(--dsw-alias-label-secondary,rgba(128,128,128,.95))}
+.lsd-bar{position:relative;height:7px;border-radius:4px;overflow:hidden;background:rgba(128,128,128,.22)}
+.lsd-bar-fill{position:absolute;inset:0 auto 0 0;border-radius:4px;
+  background:var(--dsw-alias-brand-primary,#4a9eff);transition:width .45s ease}
+.lsd-bar-fill.ok{background:var(--dsw-alias-state-success-primary,#2ea043)}
+.lsd-bar-fill.err{background:var(--dsw-alias-state-error-primary,#f85149)}
+/* Indeterminate: the launcher is alive but has not printed anything yet. */
+.lsd-bar-fill.indet{width:35% !important;animation:lsd-slide 1.3s ease-in-out infinite}
+@keyframes lsd-slide{0%{left:-35%}100%{left:100%}}
+.lsd-log{margin:0;padding:9px 11px;border-radius:8px;max-height:260px;overflow:auto;
+  font-family:ui-monospace,SFMono-Regular,Menlo,monospace;font-size:11px;line-height:1.55;
+  white-space:pre-wrap;word-break:break-word;background:var(--dsw-alias-bg-base,rgba(0,0,0,.18));
+  border:1px solid var(--dsw-alias-border-l1,rgba(128,128,128,.22));
+  color:var(--dsw-alias-label-secondary,rgba(128,128,128,.95))}
+.lsd-log .err{color:var(--dsw-alias-state-error-primary,#f85149)}
+.lsd-log .info{color:var(--dsw-alias-brand-primary,#4a9eff)}
+.lsd-log-empty{font-size:11px;color:var(--dsw-alias-label-secondary,rgba(128,128,128,.8))}
 /* ── hardware readout ───────────────────────────────────────────────── */
 .lsd-hw{display:flex;flex-direction:column;gap:5px;padding:10px 12px;border-radius:10px;
   border:1px solid var(--dsw-alias-border-l1,rgba(128,128,128,.24));background:var(--dsw-alias-bg-base,rgba(128,128,128,.05))}
@@ -148,6 +170,86 @@ window.__ModuleLoader__.load({
 				return Math.round(ms / 60000) + " 分钟";
 			}
 
+			function fmtElapsed(ms) {
+				if (typeof ms !== "number" || !isFinite(ms) || ms <= 0) return "0s";
+				var s = Math.round(ms / 1000);
+				if (s < 60) return s + "s";
+				return Math.floor(s / 60) + "m " + (s % 60) + "s";
+			}
+
+			/**
+			 * Startup progress + the launcher's real console output.
+			 *
+			 * The whole point is that the user never has to look at a console
+			 * window: the bar says roughly where the boot is, and the log can be
+			 * expanded to see exactly what the launcher printed — including the
+			 * error when it dies, which used to require re-running it by hand.
+			 */
+			function StartupPanel(props) {
+				var st = props.startup;
+				var openS = React.useState(false);
+				var open = openS[0];
+				var setOpen = openS[1];
+				var tailS = React.useRef(null);
+
+				// Keep the newest line in view while it is streaming.
+				React.useEffect(function() {
+					if (open && tailS.current) tailS.current.scrollTop = tailS.current.scrollHeight;
+				}, [open, st && st.lines ? st.lines.length : 0]);
+
+				if (!st) return null;
+				var starting = st.state === "starting";
+				var failed = st.state === "failed";
+				var ready = st.state === "ready";
+				if (st.state === "idle" && (!st.lines || st.lines.length === 0)) return null;
+
+				var pct = Math.round((st.progress || 0) * 100);
+				var fillClass = "lsd-bar-fill" + (ready ? " ok" : failed ? " err" : "");
+				// No output yet: show motion rather than a bar pinned at 2%.
+				var indet = starting && (!st.lines || st.lines.length === 0);
+				var label = failed ? "启动失败" : ready ? "已就绪" : st.state === "stopped" ? "已关闭" : (st.phase || "启动中");
+
+				return h("div", { className: "lsd-prog" },
+					h("div", { className: "lsd-prog-head" },
+						h("span", { className: "lsd-prog-phase" }, label),
+						st.elapsedMs > 0
+							? h("span", { className: "lsd-prog-pct" }, fmtElapsed(st.elapsedMs))
+							: null,
+						starting ? h("span", { className: "lsd-prog-pct" }, pct + "%") : null
+					),
+					h("div", { className: "lsd-bar" },
+						h("div", {
+							className: fillClass + (indet ? " indet" : ""),
+							style: indet ? undefined : { width: (ready ? 100 : pct) + "%" }
+						})
+					),
+					failed && st.error
+						? h("div", { className: "lsd-msg err" }, st.error)
+						: null,
+					h("div", { className: "lsd-actions" },
+						h("button", {
+							className: "lsd-btn", disabled: props.busy,
+							onClick: function() { setOpen(!open); }
+						}, open ? "收起命令行输出" : "查看命令行输出"),
+						st.logFile
+							? h("span", { className: "lsd-footer" }, "日志：" + st.logFile)
+							: null
+					),
+					open
+						? (st.lines && st.lines.length > 0
+							? h("pre", { className: "lsd-log", ref: tailS },
+								st.lines.map(function(line, i) {
+									return h("div", {
+										key: i,
+										className: line.stream === "err" ? "err" : line.stream === "info" ? "info" : ""
+									}, line.text);
+								})
+							)
+							: h("div", { className: "lsd-log-empty" }, "还没有输出。绘图程序刚启动，稍等一下…"))
+						: null
+				);
+			}
+
 			/* ── the settings page ──────────────────────────────────────── */
 
 			function SettingsPage() {
@@ -220,6 +322,10 @@ window.__ModuleLoader__.load({
 				var hwPhaseS = React.useState("idle");
 				var hwPhase = hwPhaseS[0];
 				var setHwPhase = hwPhaseS[1];
+				// Startup progress + launcher output, polled while a boot runs.
+				var startupS = React.useState(null);
+				var startupState = startupS[0];
+				var setStartupState = startupS[1];
 
 				function adopt(s) {
 					setState(s);
@@ -243,6 +349,7 @@ window.__ModuleLoader__.load({
 						if (cancelled) return;
 						if (res && res.ok) {
 							adopt(res.state);
+							if (res.state && res.state.startup) setStartupState(res.state.startup);
 							setPhase("ready");
 						} else {
 							setPhase("error");
@@ -252,6 +359,30 @@ window.__ModuleLoader__.load({
 					return function() { cancelled = true; };
 				}, []);
 
+				// Poll the startup state once a second. Only while something is
+				// actually happening: a settled page should not keep a timer alive.
+				React.useEffect(function() {
+					var cancelled = false;
+					var timer = null;
+					var tick = function() {
+						callApi({ method: "startup" }).then(function(res) {
+							if (cancelled) return;
+							if (res && res.ok && res.startup) {
+								setStartupState(res.startup);
+								var live = res.startup.state === "starting";
+								timer = setTimeout(tick, live ? 1000 : 4000);
+							} else {
+								timer = setTimeout(tick, 8000);
+							}
+						});
+					};
+					timer = setTimeout(tick, 1200);
+					return function() {
+						cancelled = true;
+						if (timer !== null) clearTimeout(timer);
+					};
+				}, []);
+
 				/** Probe the GPU. Slow (nvidia-smi + registry walk), so it runs
 				 *  after the page is already on screen. */
 				function loadHardware() {
@@ -389,9 +520,21 @@ window.__ModuleLoader__.load({
 				function backend(action) {
 					setBusy(true);
 					setMsg(null);
+					// A cold boot takes minutes. Show the panel immediately with a
+					// pending state instead of leaving the page looking frozen while
+					// the request is in flight — the poll picks up real progress.
+					if (action === "start") {
+						setStartupState({
+							state: "starting", phase: "启动绘图程序", progress: 0.02,
+							startedAt: Date.now(), endedAt: 0, error: "", lines: [], elapsedMs: 0
+						});
+					}
 					callApi({ method: action }).then(function(res) {
 						setBusy(false);
-						if (res && res.state) adopt(res.state);
+						if (res && res.state) {
+							adopt(res.state);
+							if (res.state.startup) setStartupState(res.state.startup);
+						}
 						if (res && res.ok) {
 							setMsg({ kind: "ok", text: action === "start" ? "后端已就绪" : "后端已关闭，显存释放" });
 						} else {
@@ -456,7 +599,10 @@ window.__ModuleLoader__.load({
 								className: "lsd-btn", disabled: busy,
 								onClick: function() { callApi({ method: "get" }).then(function(r) { if (r && r.ok) adopt(r.state); }); }
 							}, "刷新")
-						)
+						),
+						// Progress + the launcher's real output, so the console
+						// window never has to be looked at (or clicked into).
+						h(StartupPanel, { startup: startupState, busy: busy })
 					),
 
 					// ── directories ──────────────────────────────────────

package/lib/index.js

@@ -50,7 +50,7 @@
 
 import { homedir, tmpdir } from "node:os";
 import { mkdir, writeFile, readFile, readdir, stat } from "node:fs/promises";
-import { openSync, closeSync, readFileSync, unlinkSync } from "node:fs";
+import { openSync, closeSync, readFileSync, unlinkSync, createWriteStream, existsSync, statSync } from "node:fs";
 import { spawn } from "node:child_process";
 import { join, dirname, basename, relative, isAbsolute, resolve as resolvePath } from "node:path";
 
@@ -82,7 +82,7 @@ export const internals = { recommendFor, detectGpu, resolveLauncher, detectForge
  * indistinguishable from a broken feature. Showing this value in the page makes
  * "you need to restart DSH" a visible fact instead of a guess.
  */
-const PLUGIN_BUILD = "0.5.0";
+const PLUGIN_BUILD = "0.6.0";
 
 /** Forge and A1111 both listen here. */
 const DEFAULT_ENDPOINT = "http://127.0.0.1:7860";
@@ -714,8 +714,94 @@ const lifecycle = {
 	lastUsedAt: 0,
 	idleTimer: null,
 	starting: null, // Promise while a spawn+wait is in flight
+	// Startup log + progress, so the settings page can show what the launcher
+	// is actually doing instead of a bare "starting…". Kept in memory: it is
+	// diagnostic for the current attempt, not a durable log.
+	startup: {
+		state: "idle", // idle | starting | ready | failed | stopped
+		startedAt: 0,
+		endedAt: 0,
+		progress: 0, // 0..1
+		phase: "", // human-readable current step
+		lines: [], // ring buffer of {t, stream, text}
+		error: "",
+		logFile: "", // path of the captured log on disk
+	},
 };
 
+/** How many launcher lines to keep in memory for the settings panel. */
+const STARTUP_LOG_LIMIT = 400;
+
+/**
+ * Append one launcher output line to the startup ring buffer.
+ * @param stream - "out" | "err" | "info"
+ */
+function pushStartupLine(stream, text) {
+	const entry = { t: Date.now(), stream, text: String(text).replace(/\r$/, "") };
+	if (entry.text.length === 0) return;
+	const lines = lifecycle.startup.lines;
+	lines.push(entry);
+	if (lines.length > STARTUP_LOG_LIMIT) lines.splice(0, lines.length - STARTUP_LOG_LIMIT);
+}
+
+/** Move the startup state machine forward. */
+function setStartupState(state, phase, progress, error) {
+	const s = lifecycle.startup;
+	s.state = state;
+	if (typeof phase === "string") s.phase = phase;
+	if (typeof progress === "number") s.progress = Math.max(0, Math.min(1, progress));
+	if (typeof error === "string") s.error = error;
+	if (state === "starting" && s.startedAt === 0) s.startedAt = Date.now();
+	if (state === "ready" || state === "failed" || state === "stopped") s.endedAt = Date.now();
+	if (state === "idle") {
+		s.startedAt = 0;
+		s.endedAt = 0;
+		s.progress = 0;
+		s.phase = "";
+		s.error = "";
+		s.lines = [];
+		s.logFile = "";
+	}
+}
+
+/**
+ * Guess how far along a cold Forge boot is from its own output.
+ *
+ * Forge prints a fairly stable sequence: python import → loading extensions →
+ * loading the checkpoint → starting the API. Matching those markers gives a
+ * real progress bar instead of a spinner that means nothing. The weights are
+ * deliberately coarse: the point is "roughly where are we", not a measurement.
+ */
+const STARTUP_MARKERS = [
+	{ re: /Python\s+3\.\d+/i, progress: 0.08, phase: "启动 Python" },
+	{ re: /Launching Web UI|Running on local URL/i, progress: 0.9, phase: "启动 Web 服务" },
+	{ re: /Startup time:|Model loaded in|Loaded a model/i, progress: 0.95, phase: "模型就绪" },
+	{ re: /Loading extensions|Installing|extensions/i, progress: 0.25, phase: "加载扩展" },
+	{ re: /Loading (?:stable-diffusion|weights)|Loading checkpoint/i, progress: 0.55, phase: "加载模型权重" },
+	{ re: /Applying (?:attention|xformers)|xformers/i, progress: 0.4, phase: "优化注意力" },
+	{ re: /VAE|vae/i, progress: 0.7, phase: "加载 VAE" },
+	{ re: /API|api/i, progress: 0.85, phase: "启动 API" },
+	{ re: /error|traceback|exception|failed/i, progress: null, phase: "出错" },
+];
+
+/** Advance progress from one launcher line, never moving backwards. */
+function noteStartupLine(text) {
+	const s = lifecycle.startup;
+	for (const marker of STARTUP_MARKERS) {
+		if (!marker.re.test(text)) continue;
+		if (marker.progress === null) {
+			s.phase = marker.phase;
+			return;
+		}
+		if (marker.progress > s.progress) {
+			s.progress = marker.progress;
+			s.phase = marker.phase;
+		}
+		return;
+	}
+}
+
+
 /** Is this endpoint a live sdapi backend? */
 async function probe(endpoint, signal) {
 	try {
@@ -751,13 +837,20 @@ function stopOwnedBackend() {
 	lifecycle.pid = null;
 	lifecycle.endpoint = null;
 	if (pid === null) return false;
+	// Reflect the shutdown in the panel: a bar frozen at 60% with no process
+	// behind it is worse than no bar at all.
+	if (lifecycle.startup.state === "starting" || lifecycle.startup.state === "ready") {
+		setStartupState("stopped", "已关闭", 0);
+		pushStartupLine("info", "后端已关闭，显存已释放");
+	}
 	try {
 		if (process.platform === "win32") {
 			// Forge's run.bat spawns python.exe; /T takes the whole tree.
+			// No `detached`: on Windows that creates a console for taskkill
+			// itself, which is another black window flashing on screen.
 			spawn("taskkill", ["/PID", String(pid), "/T", "/F"], {
 				stdio: "ignore",
 				windowsHide: true,
-				detached: true,
 			}).unref();
 		} else {
 			try {
@@ -876,19 +969,69 @@ async function spawnBackend(settings, signal) {
 		windowsVerbatimArguments = true;
 	}
 
+	// Where the launcher's own stdout/stderr go. A pipe is not an option: the
+	// sandbox forbids the parent from reading a child's pipe (EPERM), which is
+	// why runCapture above already writes to a temp file. A real file is both
+	// allowed and better here — the settings panel can re-read it any time.
+	const logFile = join(dshHome(), "local-sd-startup.log");
+	let logFd = null;
+	try {
+		await mkdir(dirname(logFile), { recursive: true });
+		// Truncate: this log describes one launch attempt, and a stale tail from
+		// the previous boot would make the progress markers lie.
+		logFd = openSync(logFile, "w");
+	} catch {
+		logFd = null; // Read-only home: still start, just without a log.
+	}
+	lifecycle.startup.logFile = logFile;
+
 	const child = spawn(spawnCommand, spawnArgs, {
 		cwd: spawnCwd,
-		detached: true,
-		stdio: "ignore",
+		// detached is needed on POSIX to kill the whole process group, but on
+		// Windows DETACHED_PROCESS gives the launcher its own console — that is
+		// the black window the user sees. windowsHide alone does not win against
+		// it, so Windows stays attached and relies on `taskkill /T` instead.
+		detached: process.platform !== "win32",
+		stdio: logFd === null ? "ignore" : ["ignore", logFd, logFd],
 		windowsHide: true,
 		windowsVerbatimArguments,
 		env: sanitizedEnv(),
 	});
 	child.unref();
+	if (logFd !== null) {
+		// The child holds its own duplicate; ours is only needed to create it.
+		try { closeSync(logFd); } catch { /* already closed */ }
+	}
 
 	lifecycle.child = child;
 	lifecycle.pid = child.pid ?? null;
 
+	setStartupState("starting", "启动绘图程序", 0.02);
+	pushStartupLine("info", "$ " + command);
+	if (logFile.length > 0) pushStartupLine("info", "日志文件：" + logFile);
+
+	// Tail the log into the in-memory ring buffer so the panel can show real
+	// output without re-reading the file on every poll.
+	let logOffset = 0;
+	const pumpLog = () => {
+		if (logFile.length === 0) return;
+		let text;
+		try {
+			const size = statSync(logFile).size;
+			if (size <= logOffset) return;
+			const buf = readFileSync(logFile);
+			text = buf.subarray(logOffset).toString("utf8");
+			logOffset = buf.length;
+		} catch {
+			return;
+		}
+		for (const line of text.split(/\r?\n/)) {
+			if (line.trim().length === 0) continue;
+			pushStartupLine("out", line);
+			noteStartupLine(line);
+		}
+	};
+
 	// If the launcher dies immediately, fail fast instead of waiting 4 minutes.
 	let exitCode = null;
 	child.once("exit", (code) => {
@@ -901,32 +1044,61 @@ async function spawnBackend(settings, signal) {
 			stopOwnedBackend();
 			throw new Error("cancelled while starting the local SD backend");
 		}
+		pumpLog();
 		if (exitCode !== null && exitCode !== 0) {
+			pumpLog();
 			stopOwnedBackend();
+			const tail = lifecycle.startup.lines.slice(-8).map((l) => l.text).join("\n");
 			throw new Error(
 				"The local SD launcher exited with code " +
 					exitCode +
-					" before the API came up. Run " +
-					command +
-					" by hand to see its error output.",
+					" before the API came up." +
+					(tail.length > 0 ? "\n最后几行输出：\n" + tail : "\n（启动日志：" + logFile + "）"),
 			);
 		}
 		const live = await findLiveEndpoint(settings, signal);
 		if (live !== null) {
+			pumpLog();
 			lifecycle.endpoint = live;
+			setStartupState("ready", "已就绪", 1);
+			pushStartupLine("info", "后端就绪：" + live);
 			return live;
 		}
+		// Keep the bar creeping while nothing new is printed: a cold Forge can
+		// sit on "loading checkpoint" for a minute, and a frozen bar reads as a
+		// hang.
+		if (lifecycle.startup.progress < 0.92) {
+			lifecycle.startup.progress = Math.min(0.92, lifecycle.startup.progress + 0.01);
+		}
 		await new Promise((r) => setTimeout(r, 2000));
 	}
 
+	pumpLog();
 	stopOwnedBackend();
+	// A very common self-inflicted failure: `--nowebui` without `--port`.
+	// Forge then binds 7861 (webui.py: `port=cmd_opts.port if cmd_opts.port
+	// else 7861`), the plugin keeps probing 7860, and the timeout message says
+	// nothing useful. Detect it from the captured output and say it plainly.
+	const sawApiPort = lifecycle.startup.lines
+		.map((l) => l.text)
+		.join("\n")
+		.match(/Uvicorn running on http:\/\/[^:]+:(\d+)/);
+	const portHint =
+		sawApiPort !== null && Number(sawApiPort[1]) !== Number(new URL(settings.endpoint).port || 80)
+			? "\n后端实际监听在 " +
+				sawApiPort[1] +
+				" 端口，但插件在等 " +
+				settings.endpoint +
+				"。如果用 --nowebui，记得同时加 --port 7860（否则 Forge 会默认用 7861）。"
+			: "";
 	throw new Error(
 		"The local SD backend did not answer within " +
 			Math.round(startupTimeoutMs / 1000) +
 			"s of launching " +
 			command +
 			". First start is slow (dependencies, model load); raise 启动超时 in 设置 → 本地绘图 " +
-			"if this is a cold boot on a slow disk.",
+			"if this is a cold boot on a slow disk." +
+			portHint,
 	);
 }
 
@@ -1778,6 +1950,29 @@ function writeJson(res, status, value) {
 	res.end(JSON.stringify(value));
 }
 
+/**
+ * Startup progress + the launcher's real output.
+ *
+ * Deliberately a separate poll endpoint: the settings page polls it every
+ * second while a backend boots, and folding this into `get` would re-probe
+ * every endpoint (and re-run the hardware walk) once per second.
+ */
+function startupSnapshot() {
+	const s = lifecycle.startup;
+	return {
+		state: s.state,
+		phase: s.phase,
+		progress: s.progress,
+		startedAt: s.startedAt,
+		endedAt: s.endedAt,
+		error: s.error,
+		logFile: s.logFile,
+		// Only the tail matters to the panel; the full log is on disk.
+		lines: s.lines.slice(-200),
+		elapsedMs: s.startedAt > 0 ? (s.endedAt > 0 ? s.endedAt : Date.now()) - s.startedAt : 0,
+	};
+}
+
 /** The state the settings page renders. Never leaks anything secret — there is none. */
 async function settingsSnapshot(ctx) {
 	const settings = await resolveSettings();
@@ -1795,6 +1990,7 @@ async function settingsSnapshot(ctx) {
 		candidates: settings.candidates,
 		liveEndpoint: live,
 		launcher: launcher !== null && launcher.command.length > 0 ? launcher : null,
+		startup: startupSnapshot(),
 		autoStart: {
 			enabled: settings.autoStart.enabled,
 			command: settings.autoStart.command,
@@ -1842,6 +2038,14 @@ async function handleSettingsApi(ctx, req, res) {
 		return;
 	}
 
+	// Polled once a second by the settings page while a backend boots. Cheap on
+	// purpose: no endpoint probing, no filesystem walk, just the in-memory
+	// state machine plus the ring buffer.
+	if (method === "startup") {
+		writeJson(res, 200, { ok: true, startup: startupSnapshot() });
+		return;
+	}
+
 	// Hardware probe is its own method: nvidia-smi + a PowerShell registry walk
 	// take a second or two, and the page should render before that lands.
 	if (method === "hardware") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-local-sd",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "本地 Stable Diffusion 桥接插件：在「设置 → 本地绘图」里选一下 WebUI / Forge 目录就能用，注册 generate_image_local / generate_image_batch / sd_backend_status / sd_backend_control 四个工具，把本机 sdapi 后端直接接到模型手上。完全本地、零内容过滤、断网可用、后端按需启停。",
   "type": "module",
   "main": "lib/index.js",