dsh-multimodal-node 0.0.0-stage → 0.2.2

package/lib/tiers.js

@@ -0,0 +1,283 @@
+/**
+ * Content tiers: SFW / NSFW, and who may see what.
+ *
+ * Three things are classified, because a remote console that filters only one of
+ * them is worse than one that filters none — a SFW account reading an adult
+ * workflow's *name* in the picker is already a leak:
+ *
+ *   text       — the strings inside a prompt graph (positive and negative alike)
+ *   workflow   — its graph, plus its name and tags, because "NSFW_xxx" as a title
+ *                is a disclosure even when the graph is a resized cat
+ *   run/asset  — the workflow that produced it, plus whatever the run recorded
+ *
+ * The gate is a **keyword gate, not a classifier**. It is tuned to be broad on
+ * the terms that actually appear in generation prompts and silent on medical,
+ * anatomical and art-history vocabulary, because a false positive blocks
+ * legitimate work every day while a false negative on inventive euphemism is
+ * rare. Where it cannot decide, it decides *against* disclosure: an SFW account
+ * sees a workflow only when nothing in it matched.
+ */
+import tagdata from './tagdata.json' with { type: 'json' };
+
+/**
+ * Adult terms, grouped by why they are here so a later reader can judge whether
+ * a rule still belongs instead of treating the list as a magic block.
+ */
+export const ADULT_TERMS = [
+    // Explicit sexual acts — the words an actual request for adult imagery uses.
+    '性交', '性行为', '做爱', '口交', '肛交', '性爱', '交媾', '性高潮', '高潮脸', '自慰', '手淫', '性器',
+    'sex act', 'sexual intercourse', 'intercourse', 'fellatio', 'cunnilingus', 'masturbation',
+    'anal sex', 'oral sex', 'orgasm', 'cumshot', 'creampie', 'gangbang', 'clothed sex', 'after sex',
+
+    // Genitals and nudity stated plainly.
+    '裸体', '全裸', '裸照', '胴体', '生殖器', '阴茎', '阴道', '阴部', '阴蒂', '乳房', '乳头', '乳晕', '臀部特写',
+    'nude', 'naked', 'topless', 'bottomless', 'genitals', 'penis', 'vagina', 'vulva', 'clitoris',
+    'nipples', 'areola', 'pubic', 'anus', 'testicles', 'cameltoe', 'crotchless',
+
+    // Pornographic framing and industry vocabulary.
+    '色情', '成人视频', '成人图片', '黄片', '毛片', '情色', '淫', '骚', '嫖',
+    'porn', 'porno', 'pornographic', 'xxx', 'nsfw', 'hentai', 'erotic',
+    'explicit sex', 'adult video', 'adult content', 'onlyfans',
+
+    // Genre labels that exist only to mark content adult.
+    '无码', '有码', '里番', '工口', '痴女', '痴汉', '露出play',
+    'uncensored hentai', 'rule34', 'lewd', 'r18', 'nsfl',
+
+    // Bodily-fluids framing that appears in adult prompts specifically.
+    '精液', '淫水', '爱液', 'semen', 'pussy', 'cum',
+];
+
+const LATIN = /[a-z]/;
+
+/** Does one lower-cased string contain an adult term? Returns the term. */
+function matchIn(text) {
+    for (const term of ADULT_TERMS) {
+        const needle = term.toLowerCase();
+        if (!LATIN.test(needle)) {
+            if (text.includes(needle)) return term;
+            continue;
+        }
+        // Latin terms need a boundary: `cum` must not fire on `circumference`.
+        let from = 0;
+        for (;;) {
+            const at = text.indexOf(needle, from);
+            if (at === -1) break;
+            const before = at === 0 ? '' : text[at - 1];
+            const after = text[at + needle.length] ?? '';
+            if ((before === '' || !/[a-z0-9]/.test(before)) && (after === '' || !/[a-z0-9]/.test(after))) return term;
+            from = at + 1;
+        }
+    }
+    return undefined;
+}
+
+/** Tags from the verified dictionary that are themselves adult. */
+const ADULT_TAGS = new Set(tagdata.filter((row) => row.n === 1).map((row) => row.t));
+/** Every known tag, so `tag`-shaped findings can be recognised inside a string. */
+const KNOWN_TAGS = new Map(tagdata.map((row) => [row.t, row]));
+
+export function detectAdult(value) {
+    if (typeof value !== 'string' || value === '') return { hit: false };
+    const text = value.toLowerCase();
+    const term = matchIn(text);
+    if (term !== undefined) return { hit: true, matched: term };
+    // A prompt is a list of underscore tags; the dictionary knows which of those
+    // are adult even when the plain word is not in ADULT_TERMS (e.g. `sideboob`).
+    for (const word of text.split(/[,\n]/)) {
+        const tag = word.replace(/[()\[\]{}]/g, ' ').trim().split(/\s+/).find((part) => KNOWN_TAGS.has(part));
+        if (tag !== undefined && ADULT_TAGS.has(tag)) return { hit: true, matched: tag };
+    }
+    return { hit: false };
+}
+
+/** Scan every string in an arbitrary value; returns the first hit with its path. */
+export function scanStrings(value, path = '') {
+    if (typeof value === 'string') {
+        const result = detectAdult(value);
+        return result.hit ? { hit: true, matched: result.matched, path } : { hit: false };
+    }
+    if (Array.isArray(value)) {
+        for (let index = 0; index < value.length; index += 1) {
+            const result = scanStrings(value[index], `${path}[${index}]`);
+            if (result.hit) return result;
+        }
+        return { hit: false };
+    }
+    if (value !== null && typeof value === 'object') {
+        for (const [key, entry] of Object.entries(value)) {
+            const keyHit = detectAdult(key);
+            if (keyHit.hit) return { hit: true, matched: keyHit.matched, path: `${path}.${key}` };
+            const result = scanStrings(entry, `${path}.${key}`);
+            if (result.hit) return result;
+        }
+    }
+    return { hit: false };
+}
+
+/**
+ * Classify one workflow record.
+ *
+ * `declared` in the library lets an author mark a workflow NSFW explicitly; the
+ * scan can only add to that, never subtract — "I said this is safe" is not a
+ * defence when the prompt strings say otherwise.
+ */
+export function classifyWorkflow(record) {
+    const nameHit = detectAdult(String(record?.name ?? ''));
+    if (nameHit.hit) return { tier: 'nsfw', reason: `name:${nameHit.matched}` };
+    for (const tag of Array.isArray(record?.tags) ? record.tags : []) {
+        const tagHit = detectAdult(String(tag));
+        if (tagHit.hit) return { tier: 'nsfw', reason: `tag:${tagHit.matched}` };
+    }
+    if (record?.declared === 'nsfw') return { tier: 'nsfw', reason: 'declared' };
+    /**
+     * Only the POSITIVE side counts.
+     *
+     * Every Pony-family workflow carries `rating_explicit, nsfw, nude, ...` in its NEGATIVE
+     * encoder — that is how it excludes those results, and the terms are there *because* it
+     * is safe. Scanning the whole graph therefore classified essentially every SFW workflow
+     * on this machine as adult, which hides them from every SFW account now that the library
+     * is shared.
+     *
+     * Positive-only is the honest reading of "what does this workflow produce".
+     */
+    const graphHit = scanPositiveText(record?.api ?? record?.graph ?? {});
+    if (graphHit.hit) return { tier: 'nsfw', reason: `prompt:${graphHit.matched}` };
+    return { tier: 'sfw', reason: null };
+}
+
+/**
+ * Scan only the text a graph feeds into its positive encoder.
+ *
+ * A negative encoder is identified by being the target of a sampler input whose name
+ * mentions "negative". Everything else counts as positive. When there is no such link to
+ * follow (a bare node map), every text node counts — erring toward disclosure rather than
+ * hiding content the operator meant to be visible.
+ */
+export function scanPositiveText(graph) {
+    if (graph === null || typeof graph !== 'object') return { hit: false };
+    const negativeIds = new Set();
+    for (const node of Object.values(graph)) {
+        for (const [key, value] of Object.entries(node?.inputs ?? {})) {
+            if (!/negative/i.test(key)) continue;
+            if (Array.isArray(value) && value.length > 0) negativeIds.add(String(value[0]));
+        }
+    }
+    const positive = {};
+    for (const [id, node] of Object.entries(graph)) {
+        if (negativeIds.has(String(id))) continue;
+        positive[id] = node;
+    }
+    return scanStrings(positive);
+}
+
+/** Classify one queued/finished run from what it carried. */
+export function classifyRun(task) {
+    const workflowName = detectAdult(String(task?.extraData?.workflowName ?? ''));
+    if (workflowName.hit) return 'nsfw';
+    const stored = task?.extraData?.tier;
+    if (stored === 'nsfw') return 'nsfw';
+    const hit = scanStrings(task?.prompt ?? {});
+    return hit.hit ? 'nsfw' : 'sfw';
+}
+
+/**
+ * May this tier see this classification?
+ *
+ * SFW sees SFW only. NSFW sees everything — the tier is a *ceiling*, not a
+ * preference: an account that is allowed adult content still wants to use the
+ * family-friendly workflows.
+ */
+export function visibleTo(accountTier, classification) {
+    if (accountTier === 'nsfw') return true;
+    return classification !== 'nsfw';
+}
+
+export function normalizeTier(value) {
+    return value === 'nsfw' ? 'nsfw' : 'sfw';
+}
+
+/** The dictionary, for the prompt assistant and the console's tag browser. */
+export function tagDictionary() {
+    return tagdata;
+}
+
+export function isAdultTag(tag) {
+    return ADULT_TAGS.has(String(tag));
+}
+
+const IMAGE_SYSTEM = [
+    'You classify one image for a content filter.',
+    'Answer with exactly one word on the first line: NSFW or SFW.',
+    'Then, on the second line, one short reason in Chinese.',
+    '',
+    'NSFW means: visible nudity, exposed genitals or buttocks, sexual acts, or explicit erotic framing.',
+    'SFW means everything else, including swimwear, lingerie worn as clothing, cleavage,',
+    'medical or anatomical diagrams, classical nude sculpture, and artistic figure studies',
+    'that do not show genitals.',
+    'When genuinely unsure, answer SFW — a false block stops legitimate work every day,',
+    'and the operator can see the reason either way.',
+].join('\n');
+
+/**
+ * Ask the model whether an uploaded image is adult.
+ *
+ * Returns { nsfw, reason, checked }. `checked: false` means the question could not be put
+ * to a model at all (no llm service, no route, or the call failed) — the caller decides
+ * what to do with that, which is the important part: a broken classifier must not silently
+ * pass everything, and must not silently block everything either.
+ *
+ * This is deliberately one pass, no second opinion, no ensemble: the operator asked for a
+ * simple judgement, and a filter that argues with itself costs more than it catches.
+ */
+export async function screenImage(llm, route, imageBuffer, mime = 'image/png') {
+    if (llm === undefined || route === undefined || route.provider === undefined || route.model === undefined) {
+        return { nsfw: false, reason: '没有可用的模型，未做图片判定', checked: false };
+    }
+    if (!Buffer.isBuffer(imageBuffer) || imageBuffer.length === 0) {
+        return { nsfw: false, reason: '图片为空', checked: false };
+    }
+    try {
+        // `maxTokens`/`temperature` belong to preparation, not only to dispatch:
+        // `prepareCall()` freezes a config and `stream()` rejects a request that
+        // differs from it (`INVALID_PREPARED_CALL`), so pinning them here as well
+        // keeps the two halves identical. Sending them only at dispatch time made
+        // every screening call fail before reaching the adapter.
+        const controls = { maxTokens: 120, temperature: 0 };
+        const prepared = await llm.prepareCall(
+            { provider: route.provider, model: route.model, ...controls },
+            AbortSignal.timeout(60_000),
+        );
+        const options = {
+            ...prepared.config,
+            messages: [
+                {
+                    role: 'user',
+                    content: [
+                        { type: 'text', text: '判断这张图片是否属于成人内容。' },
+                        { type: 'image', image: imageBuffer.toString('base64'), mimeType: mime },
+                    ],
+                },
+            ],
+            system: IMAGE_SYSTEM,
+            ...controls,
+        };
+        let out = '';
+        for await (const chunk of prepared.stream(options)) {
+            if (chunk.type === 'text-delta') out += chunk.text;
+            if (chunk.type === 'finish' && chunk.reason?.kind === 'error') {
+                throw new Error(chunk.reason.failure?.message ?? 'model error');
+            }
+        }
+        const text = out.trim();
+        if (text === '') return { nsfw: false, reason: '模型没有回答，未做判定', checked: false };
+        const firstLine = text.split(/\r?\n/)[0].toUpperCase();
+        // Only an explicit NSFW blocks. Anything else — including a malformed answer — is
+        // treated as SFW, because blocking on an unparseable reply would make the filter
+        // fire on its own failures.
+        const nsfw = /\bNSFW\b/.test(firstLine) && !/\bSFW\b(?!.*NSFW)/.test(firstLine.replace('NSFW', ''));
+        const reason = text.split(/\r?\n/).slice(1).join(' ').trim().slice(0, 120);
+        return { nsfw, reason: reason || firstLine.slice(0, 60), checked: true };
+    } catch (error) {
+        return { nsfw: false, reason: `图片判定失败：${error instanceof Error ? error.message : String(error)}`, checked: false };
+    }
+}

package/lib/tools.js

@@ -0,0 +1,230 @@
+/**
+ * `multimodal_node` —— 智能体面向同一个节点的门。
+ *
+ * 面板上每个动作这里都有，所以一个 agent 可以不开界面地判断：「队列里有什么、
+ * 8189 睡着了吗、把它拉起来、Blender 那边渲染完了没」。
+ *
+ * 参数故意做得比面板窄：agent 是来读状态的，不是来重配整个部署的。
+ * 改设置（换模式、改端口、加 key）仍然只在设置页里做，那里有确认与回显。
+ */
+
+const TIMEOUT_MS = 180_000;
+
+const lines = (rows) => rows.filter((row) => row !== '').join('\n');
+
+export function multimodalDefinition(runtime, helpers) {
+    const status = () => helpers.statusOf();
+
+    const renderStatus = (data) => {
+        const mode = data.mode === 'user' ? '用户节点' : '服务节点';
+        const head = lines([
+            `模式：${mode}${data.mode === 'service' ? ` · API 端口 ${data.gateway.listening ? `监听 ${data.gateway.host}:${data.gateway.port}` : '未监听'} · 网页端口 ${data.remote.listening ? data.remote.port : '未监听'}` : ''}`,
+            data.mode === 'service'
+                ? `队列：排队 ${(data.queue.tasks ?? []).filter((task) => task.state === 'queued').length} · 执行中 ${(data.queue.tasks ?? []).filter((task) => task.state === 'running').length} · 剩余约 ${Math.round((data.queue.estimateMs ?? 0) / 1000)}s · 排序 ${data.queue.dynamic ? '动态（最短总耗时）' : '先后顺序'}`
+                : `服务节点 ${data.node.publicUrl || '（未填地址）'} → ${data.node.serviceNode?.ok === true ? '在线' : `不可用：${data.node.serviceNode?.error ?? '未探测'}`}`,
+        ]);
+        const rows = [];
+        rows.push('ComfyUI 实例：');
+        if ((data.instances ?? []).length === 0) rows.push('- 没有绑定实例');
+        for (const entry of data.instances ?? []) {
+            const vram = (entry.devices ?? [])
+                .map((item) => (item.vramTotal === null || item.vramTotal === undefined ? '?' : `${Math.round((item.vramTotal - (item.vramFree ?? 0)) / 1048576)}/${Math.round(item.vramTotal / 1048576)} MiB`))
+                .join(', ');
+            const bits = [
+                `${entry.id}${entry.label !== entry.id ? ` (${entry.label})` : ''}`,
+                entry.baseUrl,
+                entry.healthy ? '在线' : '离线',
+                entry.enabled ? '派发中' : '派发已停',
+                `并发 ${entry.maxConcurrent}`,
+            ];
+            if (entry.version !== null && entry.version !== undefined) bits.push(`v${entry.version}`);
+            if (vram !== '') bits.push(vram);
+            bits.push(entry.control === 'none' ? '进程非托管' : `进程 ${entry.control}${entry.pid ? ` pid ${entry.pid}` : ''}`);
+            rows.push(`- ${bits.join(' · ')}`);
+            if (entry.lastError) rows.push(`    ${entry.lastError}`);
+        }
+        if (data.blender?.enabled === true) {
+            rows.push('Blender 实例：');
+            if ((data.blender.instances ?? []).length === 0) rows.push('- 没有配置');
+            for (const entry of data.blender.instances ?? []) {
+                const bits = [
+                    `${entry.id} (${entry.label})`,
+                    entry.kind === 'spawn' ? `本机 ${entry.executable || '找不到 blender.exe'}` : entry.baseUrl,
+                    entry.healthy ? '就绪' : `不可用${entry.error ? `：${entry.error}` : ''}`,
+                    `并发 ${entry.maxConcurrent}`,
+                ];
+                if (entry.running > 0) bits.push(`进行中 ${entry.running}`);
+                rows.push(`- ${bits.join(' · ')}`);
+                for (const job of (entry.jobs ?? []).slice(-3)) {
+                    rows.push(`    · ${job.id.slice(0, 8)} ${job.state}${job.error ? ` — ${job.error}` : ''}`);
+                }
+            }
+        }
+        const active = (data.queue.tasks ?? []).filter((task) => task.state === 'queued' || task.state === 'running');
+        if (active.length > 0) {
+            rows.push('队列：');
+            for (const task of active.slice(0, 12)) {
+                rows.push(`- ${task.id.slice(0, 8)} · ${task.state} · ${task.backendId ?? '未分配'} · 代价 ${task.cost} · 优先级 ${task.priority}${task.error ? ` — ${task.error}` : ''}`);
+            }
+        }
+        rows.push(`模型：${data.models.ok ? `${data.models.total} 个文件 · ${data.models.folders.length} 个目录` : `读不到（${data.models.error}）`}`);
+        rows.push(`产物目录：${data.node.outputDir}`);
+        return lines([head, ...rows]);
+    };
+
+    return {
+        name: 'multimodal_node',
+        description: [
+            '管理多模态节点插件：一个插件两种身份。服务节点开门（API 接入端口 + 网页端口），把任务排队分发到绑定的 ComfyUI 实例，并托管本机 Blender 渲染；用户节点不开门，它连服务节点拿工作流模板、当前队列、模型列表，把产物落到本机目录。',
+            '`action: status`（默认）报模式、两个端口、队列与预计剩余时间、每个 ComfyUI 实例的健康/显存/进程归属、Blender 实例与进行中的渲染、模型统计、产物目录。',
+            '`action: instances` 列出 ComfyUI 实例；`start` / `stop` / `restart` 作用于一个实例，且只在 control.type 为 script（本机托管了一个 bat）时有效。',
+            '`action: queue` 给队列快照；`cancel` / `prioritize` 作用一条任务；`free` 让所有实例卸载模型释放显存；`dynamic` 切换排序策略。',
+            '`action: blender` 给 Blender 板块状态；`blenderRender` 提交一次渲染（spawn 模式需要工程文件绝对路径与帧范围）；`blenderCancel` 取消一个渲染任务。',
+            '`action: templates` 列出工作流模板（服务节点看本机库，用户节点问远端）；`models` 给模型清单；`output` 列出本机产物文件夹。',
+            '`action: probe` 立刻重读所有实例与 Blender 的健康状态。',
+            '提交任务前先跑一次 status：它告诉你某个实例是不是睡着了、需不需要先启动。',
+        ].join(' '),
+        parameters: {
+            type: 'object',
+            properties: {
+                action: {
+                    type: 'string',
+                    enum: [
+                        'status',
+                        'instances',
+                        'start',
+                        'stop',
+                        'restart',
+                        'probe',
+                        'queue',
+                        'dynamic',
+                        'cancel',
+                        'prioritize',
+                        'free',
+                        'blender',
+                        'blenderRender',
+                        'blenderCancel',
+                        'templates',
+                        'models',
+                        'output',
+                    ],
+                    description: 'status 报全部；instances 列实例；start/stop/restart 作用于一个 ComfyUI 实例；queue 队列快照；dynamic 切排序；cancel/prioritize 作用一条任务；free 释放显存；blender 板块状态；blenderRender 提交渲染；blenderCancel 取消渲染；templates 工作流模板；models 模型清单；output 本机产物。',
+                },
+                id: {
+                    type: 'string',
+                    description: '实例 id（start/stop/restart/blenderRender/blenderCancel）或任务 id（cancel/prioritize）。',
+                },
+                enabled: { type: 'boolean', description: 'action: dynamic —— true 开自动排序，false 严格先进先出。' },
+                delta: { type: 'number', description: 'action: prioritize —— 优先级增量，默认 1，越大越先跑。' },
+                instanceId: { type: 'string', description: 'action: blenderRender / blenderCancel —— Blender 实例 id。' },
+                blend: { type: 'string', description: 'action: blenderRender —— .blend 工程文件的绝对路径（spawn 模式必需）。' },
+                frames: { type: 'string', description: 'action: blenderRender —— 帧范围，如 "1"、"1-20"、"1,5,9"、"1-20:2"。' },
+                jobId: { type: 'string', description: 'action: blenderCancel —— 要取消的渲染任务 id。' },
+                format: { type: 'string', description: 'action: blenderRender —— 输出格式，默认 PNG。' },
+                engine: { type: 'string', description: 'action: blenderRender —— 渲染引擎覆盖，如 CYCLES / BLENDER_EEVEE_NEXT。' },
+                outputDir: { type: 'string', description: 'action: blenderRender —— 产物目录（绝对路径）。' },
+            },
+            required: [],
+        },
+        output: {
+            schema: { type: 'object' },
+            render(_args, value) {
+                const data = value;
+                if (data === null || typeof data !== 'object') return [{ type: 'text', text: 'multimodal_node: 没有返回值' }];
+                if (data.ok === false && data.error !== undefined && data.mode === undefined) {
+                    return [{ type: 'text', text: `multimodal_node: ${data.error}` }];
+                }
+                if (data.mode !== undefined) return [{ type: 'text', text: renderStatus(data) }];
+                return [{ type: 'text', text: JSON.stringify(data).slice(0, 4000) }];
+            },
+        },
+        timeoutMs: TIMEOUT_MS,
+        async execute(args) {
+            const action = typeof args?.action === 'string' ? args.action : 'status';
+            try {
+                if (action === 'status') return status();
+                if (action === 'probe') {
+                    await runtime.instances.probeAll(true);
+                    await runtime.blender.probeAll(true);
+                    return status();
+                }
+                if (action === 'instances') {
+                    const data = await status();
+                    return { ok: true, instances: data.instances, blender: data.blender };
+                }
+                if (action === 'start' || action === 'stop' || action === 'restart') {
+                    const result = await runtime.instances[action](String(args?.id ?? ''));
+                    return { ok: result.ok !== false, action, ...result, status: await status() };
+                }
+                if (action === 'queue') {
+                    const data = await status();
+                    return { ok: true, queue: data.queue, instances: data.instances };
+                }
+                if (action === 'dynamic') {
+                    runtime.pool.toggleDynamic(args?.enabled !== false);
+                    return { ok: true, dynamic: runtime.settings.get().dynamic, status: await status() };
+                }
+                if (action === 'cancel') {
+                    const result = runtime.pool.cancel(String(args?.id ?? ''));
+                    return { ...result, status: await status() };
+                }
+                if (action === 'prioritize') {
+                    const result = runtime.pool.prioritize(String(args?.id ?? ''), args?.delta ?? 1);
+                    return { ...result, status: await status() };
+                }
+                if (action === 'free') {
+                    await Promise.all(
+                        runtime.instances.enabled().map(async (item) => {
+                            try {
+                                await runtime.pool.backend(item).free({ unload_models: true, free_memory: true });
+                            } catch {
+                                // 停着的实例没有可释放的东西
+                            }
+                        }),
+                    );
+                    return { ok: true, status: await status() };
+                }
+                if (action === 'blender') {
+                    return { ok: true, blender: runtime.blender.statusPayload(), mode: runtime.mode };
+                }
+                if (action === 'blenderRender') {
+                    const instanceId = String(args?.instanceId ?? args?.id ?? '');
+                    if (instanceId === '') return { ok: false, error: 'blenderRender 需要 instanceId' };
+                    const result = await runtime.blender.submit(instanceId, {
+                        blend: String(args?.blend ?? ''),
+                        frames: String(args?.frames ?? '1'),
+                        format: args?.format === undefined ? 'PNG' : String(args.format),
+                        engine: args?.engine === undefined ? '' : String(args.engine),
+                        outputDir: args?.outputDir === undefined ? '' : String(args.outputDir),
+                    });
+                    return { ok: true, job: result, blender: runtime.blender.statusPayload() };
+                }
+                if (action === 'blenderCancel') {
+                    const result = await runtime.blender.cancel(String(args?.instanceId ?? args?.id ?? ''), String(args?.jobId ?? ''));
+                    return { ok: result.ok === true, ...result, blender: runtime.blender.statusPayload() };
+                }
+                if (action === 'templates') {
+                    if (runtime.mode === 'user') return { ok: true, source: 'service-node', templates: await runtime.nodeClient.templates() };
+                    return {
+                        ok: true,
+                        source: 'local',
+                        templates: runtime.library.list('nsfw').map((row) => ({ id: row.id, name: row.name, category: row.category, tier: row.tier })),
+                    };
+                }
+                if (action === 'models') {
+                    if (runtime.mode === 'user') return { ok: true, source: 'service-node', ...(await runtime.nodeClient.models()) };
+                    const { modelInventory } = await import('./models.js');
+                    const inventory = modelInventory(runtime.settings.get(), { withSize: true });
+                    return { ok: inventory.ok !== false, source: 'disk', ...inventory };
+                }
+                if (action === 'output') {
+                    const data = await status();
+                    return { ok: true, dir: data.node.outputDir };
+                }
+                return { ok: false, error: `未知动作 ${action}` };
+            } catch (error) {
+                return { ok: false, error: error instanceof Error ? error.message : String(error) };
+            }
+        },
+    };
+}

package/lib/viewport.js

@@ -0,0 +1,134 @@
+/**
+ * Which layout a page should be painted in.
+ *
+ * Two things decide it, in this order:
+ *
+ *   1. The user agent, on the server, so the first paint is already right. A page
+ *      that renders the desktop grid and then collapses is a visible jump on a
+ *      phone, and on a slow connection the jump is the first thing you notice.
+ *   2. The viewport, in the browser, because a UA is a claim, not a fact: a
+ *      desktop browser resized to phone width, a tablet in split view, and any
+ *      user who has told their browser to request the desktop site all disagree
+ *      with their UA. The script corrects the server's guess.
+ *
+ * The result is one attribute on <html> — `data-layout="phone" | "desktop"` —
+ * and the stylesheet keys off it. No user-agent sniffing reaches into behaviour:
+ * both layouts run the same script and call the same routes.
+ */
+
+/** A phone: an explicit mobile token, and not a tablet. */
+const MOBILE_UA = /iphone|ipod|android.*mobile|windows phone|blackberry|opera mini|iemobile/i;
+/** A tablet is wide enough for the two-column layout at typical zoom. */
+const TABLET_UA = /ipad|android(?!.*mobile)|tablet|kindle|silk/i;
+/** A desktop that happens to be a very small window still gets the grid. */
+const DESKTOP_UA = /windows nt|macintosh|linux x86_64|cros\b/i;
+
+/**
+ * @param {string} userAgent
+ * @returns {'phone' | 'desktop'}
+ */
+export function layoutFor(userAgent) {
+    const ua = String(userAgent ?? '');
+    if (ua === '') return 'desktop';
+    // Check tablet before phone: `Android` without `Mobile` is a tablet, and the
+    // tablet regex would otherwise be shadowed by the phone one.
+    if (TABLET_UA.test(ua)) return 'desktop';
+    if (MOBILE_UA.test(ua)) return 'phone';
+    if (DESKTOP_UA.test(ua)) return 'desktop';
+    // Anything else (a bot, a TV, an embedded webview reporting nothing useful)
+    // gets the layout that degrades better: one column still works everywhere.
+    return 'phone';
+}
+
+/**
+ * Stamp the chosen layout onto a page's <html> element.
+ *
+ * The pages are template strings with `<html lang="zh-CN">` as their root; the
+ * attribute goes there so CSS can key off it before the body exists.
+ */
+export function withLayout(html, layout) {
+    return html.replace('<html lang="zh-CN"', `<html lang="zh-CN" data-layout="${layout}"`);
+}
+
+/**
+ * The browser half: correct the server's guess from the real viewport, and keep
+ * it correct when a window is resized or a device is rotated.
+ *
+ * 720px is the breakpoint both layouts are built around: below it two columns
+ * cannot hold a textarea and a queue at once.
+ */
+export const LAYOUT_SCRIPT = [
+    '<script>',
+    '(function(){',
+    "  var mq = window.matchMedia('(max-width: 720px)');",
+    '  function apply(){',
+    "    var wanted = mq.matches ? 'phone' : 'desktop';",
+    "    if (document.documentElement.dataset.layout !== wanted) {",
+    "      document.documentElement.dataset.layout = wanted;",
+    '    }',
+    '  }',
+    '  apply();',
+    '  // Safari before 14 only has the deprecated listener API.',
+    "  if (mq.addEventListener) mq.addEventListener('change', apply);",
+    "  else if (mq.addListener) mq.addListener(apply);",
+    '})();',
+    '</script>',
+].join('\n');
+
+/**
+ * Theme, applied before first paint.
+ *
+ * This runs in <head>, above the stylesheet-dependent markup, for one reason: reading the
+ * saved choice *after* the body renders shows the dark palette for a frame and then snaps
+ * to light. That flash is worse than either theme.
+ *
+ * The preference is per-browser (localStorage), not per-account: it is a display setting
+ * about this screen, not something another device should inherit. `system` is the third
+ * state and follows `prefers-color-scheme`, so the page is usable before anyone chooses.
+ */
+export const THEME_SCRIPT = [
+    '<script>',
+    '(function(){',
+    "  var KEY = 'cgw-theme';",
+    '  function system(){',
+    "    return window.matchMedia && window.matchMedia('(prefers-color-scheme: light)').matches ? 'light' : 'dark';",
+    '  }',
+    '  function resolve(){',
+    '    var saved = null;',
+    '    try { saved = localStorage.getItem(KEY); } catch (e) { saved = null; }',
+    "    if (saved === 'light' || saved === 'dark') return saved;",
+    '    return system();',
+    '  }',
+    '  function apply(theme){',
+    '    document.documentElement.dataset.theme = theme;',
+    '    document.documentElement.style.colorScheme = theme;',
+    '    var button = document.getElementById("themetoggle");',
+    '    if (button) {',
+    '      button.textContent = theme === "light" ? "☾" : "☀";',
+    '      button.title = theme === "light" ? "切到暗色" : "切到亮色";',
+    '      button.setAttribute("aria-label", button.title);',
+    '    }',
+    '  }',
+    '  apply(resolve());',
+    '  window.__cgwSetTheme = function(theme){',
+    '    apply(theme);',
+    '    try { localStorage.setItem(KEY, theme); } catch (e) {}',
+    '  };',
+    '  window.__cgwToggleTheme = function(){',
+    '    window.__cgwSetTheme(document.documentElement.dataset.theme === "light" ? "dark" : "light");',
+    '  };',
+    '  // Only follow the OS while the person has not chosen explicitly.',
+    '  if (window.matchMedia) {',
+    "    var mq = window.matchMedia('(prefers-color-scheme: light)');",
+    '    var onSystem = function(){',
+    '      var saved = null;',
+    '      try { saved = localStorage.getItem(KEY); } catch (e) { saved = null; }',
+    '      if (saved !== "light" && saved !== "dark") apply(system());',
+    '    };',
+    '    if (mq.addEventListener) mq.addEventListener("change", onSystem);',
+    '    else if (mq.addListener) mq.addListener(onSystem);',
+    '  }',
+    '  document.addEventListener("DOMContentLoaded", function(){ apply(document.documentElement.dataset.theme || resolve()); });',
+    '})();',
+    '</script>',
+].join('\n');