@dfy-plugins/dsh-wallpaper 0.1.2

package/lib/index.d.ts

@@ -0,0 +1,5 @@
+/** dsh-wallpaper Host 半区：持久化设置、图片并提供同源 HTTP 接口。 */
+import type { Context } from '@deepseek-ai/cordis';
+export declare const name = "wallpaper";
+export declare const inject: string[];
+export declare function apply(ctx: Context): void;

package/lib/index.js

@@ -0,0 +1,331 @@
+import { writeFileAtomic } from '@deepseek-ai/dsh-atomic-write';
+import { dshHomePath } from '@deepseek-ai/dsh-home-paths';
+import { randomUUID } from 'node:crypto';
+import { createReadStream } from 'node:fs';
+import { mkdir, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { DEFAULT_SETTINGS, normalizeSettings, wallpaperTarget } from './logic.js';
+export const name = 'wallpaper';
+export const inject = ['webServer'];
+const DATA_DIR = dshHomePath('storages', 'dfy-plugins', 'wallpaper');
+const LEGACY_DATA_DIR = dshHomePath('storages', 'xiao443', 'dsh-wallpaper');
+const CONFIG_FILE = join(DATA_DIR, 'config.json');
+const IMAGE_FILE = join(DATA_DIR, 'assets', 'current');
+const MAX_JSON_BYTES = 64 * 1024;
+const MAX_IMAGE_BYTES = 64 * 1024 * 1024;
+const DEFAULT_CONFIG = {
+    settings: { ...DEFAULT_SETTINGS },
+    imageMime: null,
+    imageVersion: 0,
+    regionImages: { settings: { imageMime: null, imageVersion: 0 }, sidebar: { imageMime: null, imageVersion: 0 } },
+};
+function imageFile(target) {
+    return target === 'global' ? IMAGE_FILE : join(DATA_DIR, 'assets', target, 'current');
+}
+function storedImage(value) {
+    const item = typeof value === 'object' && value !== null ? value : {};
+    return {
+        imageMime: typeof item.imageMime === 'string' && /^image\/[a-z0-9.+-]+$/i.test(item.imageMime) ? item.imageMime : null,
+        imageVersion: typeof item.imageVersion === 'number' && Number.isFinite(item.imageVersion) ? Math.max(0, Math.floor(item.imageVersion)) : 0,
+    };
+}
+function withImage(config, target, image, imageName) {
+    if (target === 'global')
+        return {
+            ...config, ...image,
+            settings: normalizeSettings({ ...config.settings, enabled: imageName !== null, imageName }),
+        };
+    return {
+        ...config,
+        regionImages: { ...config.regionImages, [target]: image },
+        settings: normalizeSettings({ ...config.settings, regions: {
+                ...config.settings.regions,
+                [target]: { ...config.settings.regions[target], imageName, source: imageName === null ? 'none' : 'custom' },
+            } }),
+    };
+}
+let storageReady;
+async function migrateLegacyStorage() {
+    try {
+        await stat(DATA_DIR);
+        return;
+    }
+    catch (error) {
+        if (errorCode(error) !== 'ENOENT')
+            throw error;
+    }
+    await mkdir(dirname(DATA_DIR), { recursive: true, mode: 0o700 });
+    try {
+        await rename(LEGACY_DATA_DIR, DATA_DIR);
+    }
+    catch (error) {
+        const code = errorCode(error);
+        if (code !== 'ENOENT' && code !== 'EEXIST')
+            throw error;
+    }
+}
+function ensureStorageReady() {
+    storageReady ??= migrateLegacyStorage();
+    return storageReady;
+}
+function errorCode(error) {
+    return typeof error === 'object' && error !== null && 'code' in error
+        ? String(error.code)
+        : undefined;
+}
+async function readConfig() {
+    await ensureStorageReady();
+    try {
+        const parsed = JSON.parse(await readFile(CONFIG_FILE, 'utf8'));
+        return {
+            settings: normalizeSettings(parsed.settings),
+            ...storedImage(parsed),
+            regionImages: {
+                settings: storedImage(parsed.regionImages?.settings),
+                sidebar: storedImage(parsed.regionImages?.sidebar),
+            },
+        };
+    }
+    catch (error) {
+        if (errorCode(error) === 'ENOENT')
+            return { ...DEFAULT_CONFIG, settings: { ...DEFAULT_SETTINGS } };
+        throw error;
+    }
+}
+async function writeConfig(config) {
+    await ensureStorageReady();
+    await writeFileAtomic(CONFIG_FILE, `${JSON.stringify(config, null, 2)}\n`, {
+        mode: 0o600,
+        dirMode: 0o700,
+    });
+}
+async function imageExists(target) {
+    await ensureStorageReady();
+    try {
+        return (await stat(imageFile(target))).isFile();
+    }
+    catch (error) {
+        if (errorCode(error) === 'ENOENT')
+            return false;
+        throw error;
+    }
+}
+async function toClientState(config) {
+    const state = async (target) => {
+        const image = target === 'global' ? config : config.regionImages[target];
+        const settings = target === 'global' ? config.settings : config.settings.regions[target];
+        const hasImage = settings.imageName !== null && image.imageMime !== null && await imageExists(target);
+        return { hasImage, imageUrl: hasImage ? `/api/dsh-wallpaper/image?region=${target}&v=${image.imageVersion}` : null };
+    };
+    const [global, settingsImage, sidebarImage] = await Promise.all([state('global'), state('settings'), state('sidebar')]);
+    const { hasImage } = global;
+    const settings = hasImage
+        ? config.settings
+        : normalizeSettings({ ...config.settings, enabled: false, imageName: null });
+    return {
+        settings,
+        ...global,
+        regionImages: { settings: settingsImage, sidebar: sidebarImage },
+    };
+}
+function sendJson(res, status, body) {
+    const payload = JSON.stringify(body);
+    res.writeHead(status, {
+        'content-type': 'application/json; charset=utf-8',
+        'content-length': Buffer.byteLength(payload),
+        'cache-control': 'no-store',
+    });
+    res.end(payload);
+}
+function readBody(req, limit) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let size = 0;
+        let settled = false;
+        req.on('data', (chunk) => {
+            if (settled)
+                return;
+            const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            size += buffer.length;
+            if (size > limit) {
+                settled = true;
+                chunks.length = 0;
+                reject(new Error('payload too large'));
+                return;
+            }
+            chunks.push(buffer);
+        });
+        req.on('end', () => {
+            if (!settled)
+                resolve(Buffer.concat(chunks));
+        });
+        req.on('error', (error) => {
+            if (!settled)
+                reject(error);
+        });
+    });
+}
+function decodeFileName(value) {
+    const raw = Array.isArray(value) ? value[0] : value;
+    if (raw === undefined)
+        return 'wallpaper';
+    try {
+        const decoded = decodeURIComponent(raw).trim();
+        return decoded.length > 0 ? decoded.slice(0, 260) : 'wallpaper';
+    }
+    catch {
+        return 'wallpaper';
+    }
+}
+async function writeImageAtomic(content, target) {
+    await ensureStorageReady();
+    const file = imageFile(target);
+    await mkdir(dirname(file), { recursive: true, mode: 0o700 });
+    const temporary = `${file}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+        await writeFile(temporary, content, { flag: 'wx', mode: 0o600 });
+        await rename(temporary, file);
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+}
+export function apply(ctx) {
+    let mutationTail = Promise.resolve();
+    const mutate = (operation) => {
+        const result = mutationTail.then(operation, operation);
+        mutationTail = result.then(() => undefined, () => undefined);
+        return result;
+    };
+    const stateRoute = {
+        kind: 'exact',
+        path: '/api/dsh-wallpaper/state',
+        async handler(req, res) {
+            if (req.method !== 'GET')
+                return sendJson(res, 405, { error: 'method not allowed' });
+            try {
+                sendJson(res, 200, await toClientState(await readConfig()));
+            }
+            catch (error) {
+                sendJson(res, 500, { error: String(error) });
+            }
+        },
+    };
+    const settingsRoute = {
+        kind: 'exact',
+        path: '/api/dsh-wallpaper/settings',
+        async handler(req, res) {
+            if (req.method !== 'PUT')
+                return sendJson(res, 405, { error: 'method not allowed' });
+            try {
+                const body = JSON.parse((await readBody(req, MAX_JSON_BYTES)).toString('utf8'));
+                const state = await mutate(async () => {
+                    const current = await readConfig();
+                    const requested = normalizeSettings(body);
+                    const next = {
+                        ...current,
+                        settings: { ...requested, imageName: current.settings.imageName, regions: {
+                                settings: { ...requested.regions.settings, imageName: current.settings.regions.settings.imageName },
+                                sidebar: { ...requested.regions.sidebar, imageName: current.settings.regions.sidebar.imageName },
+                            } },
+                    };
+                    await writeConfig(next);
+                    return toClientState(next);
+                });
+                sendJson(res, 200, await state);
+            }
+            catch (error) {
+                sendJson(res, 400, { error: String(error) });
+            }
+        },
+    };
+    const imageRoute = {
+        kind: 'exact',
+        path: '/api/dsh-wallpaper/image',
+        async handler(req, res) {
+            const target = wallpaperTarget(new URL(req.url ?? '/api/dsh-wallpaper/image', 'http://localhost').searchParams.get('region'));
+            if (target === undefined)
+                return sendJson(res, 400, { error: 'invalid wallpaper region' });
+            if (req.method === 'GET') {
+                try {
+                    const config = await readConfig();
+                    const image = target === 'global' ? config : config.regionImages[target];
+                    if (image.imageMime === null || !(await imageExists(target))) {
+                        sendJson(res, 404, { error: 'wallpaper not found' });
+                        return;
+                    }
+                    const info = await stat(imageFile(target));
+                    res.writeHead(200, {
+                        'content-type': image.imageMime,
+                        'content-length': info.size,
+                        'cache-control': 'private, max-age=31536000, immutable',
+                    });
+                    const stream = createReadStream(imageFile(target));
+                    stream.on('error', (error) => res.destroy(error));
+                    stream.pipe(res);
+                }
+                catch (error) {
+                    if (!res.headersSent)
+                        sendJson(res, 500, { error: String(error) });
+                }
+                return;
+            }
+            if (req.method === 'PUT') {
+                try {
+                    const mime = String(req.headers['content-type'] ?? '').split(';', 1)[0].trim().toLowerCase();
+                    if (!/^image\/[a-z0-9.+-]+$/.test(mime)) {
+                        sendJson(res, 415, { error: 'content-type must be image/*' });
+                        return;
+                    }
+                    const content = await readBody(req, MAX_IMAGE_BYTES);
+                    if (content.length === 0) {
+                        sendJson(res, 400, { error: 'empty image' });
+                        return;
+                    }
+                    const state = await mutate(async () => {
+                        await writeImageAtomic(content, target);
+                        const current = await readConfig();
+                        const previous = target === 'global' ? current : current.regionImages[target];
+                        const next = withImage(current, target, {
+                            imageMime: mime,
+                            imageVersion: Math.max(Date.now(), previous.imageVersion + 1),
+                        }, decodeFileName(req.headers['x-dsh-wallpaper-filename']));
+                        await writeConfig(next);
+                        return toClientState(next);
+                    });
+                    sendJson(res, 200, await state);
+                }
+                catch (error) {
+                    sendJson(res, error instanceof Error && error.message === 'payload too large' ? 413 : 500, {
+                        error: String(error),
+                    });
+                }
+                return;
+            }
+            if (req.method === 'DELETE') {
+                try {
+                    const state = await mutate(async () => {
+                        await rm(imageFile(target), { force: true });
+                        const current = await readConfig();
+                        const previous = target === 'global' ? current : current.regionImages[target];
+                        const next = withImage(current, target, {
+                            imageMime: null,
+                            imageVersion: Math.max(Date.now(), previous.imageVersion + 1),
+                        }, null);
+                        await writeConfig(next);
+                        return toClientState(next);
+                    });
+                    sendJson(res, 200, await state);
+                }
+                catch (error) {
+                    sendJson(res, 500, { error: String(error) });
+                }
+                return;
+            }
+            sendJson(res, 405, { error: 'method not allowed' });
+        },
+    };
+    ctx.webServer.register(stateRoute);
+    ctx.webServer.register(settingsRoute);
+    ctx.webServer.register(imageRoute);
+}

package/lib/logic.d.ts

@@ -0,0 +1,41 @@
+export declare const WALLPAPER_MODES: readonly ["cover", "contain", "stretch", "fit-width", "fit-height", "center", "tile"];
+export type WallpaperMode = (typeof WALLPAPER_MODES)[number];
+export declare const WALLPAPER_POSITIONS: readonly ["left top", "center top", "right top", "left center", "center center", "right center", "left bottom", "center bottom", "right bottom"];
+export type WallpaperPosition = (typeof WALLPAPER_POSITIONS)[number];
+export declare const WALLPAPER_REGIONS: readonly ["settings", "sidebar"];
+export type WallpaperRegion = (typeof WALLPAPER_REGIONS)[number];
+export type WallpaperTarget = 'global' | WallpaperRegion;
+export type WallpaperSource = 'none' | 'global' | 'custom';
+export interface WallpaperSurfaceSettings {
+    enabled: boolean;
+    imageName: string | null;
+    mode: WallpaperMode;
+    position: WallpaperPosition;
+    offsetXPercent: number;
+    offsetYPercent: number;
+    imageOpacity: number;
+    blur: number;
+    maskColor: string;
+    maskOpacity: number;
+    surfaceOpacity: number;
+}
+export interface WallpaperRegionSettings extends Omit<WallpaperSurfaceSettings, 'enabled'> {
+    source: WallpaperSource;
+}
+export interface WallpaperSettings extends WallpaperSurfaceSettings {
+    regions: Record<WallpaperRegion, WallpaperRegionSettings>;
+}
+export declare function defaultRegionSettings(): WallpaperRegionSettings;
+export declare const DEFAULT_SETTINGS: WallpaperSettings;
+export interface WallpaperModeStyle {
+    size: string;
+    repeat: 'no-repeat' | 'repeat';
+}
+export declare function normalizeSettings(value: unknown): WallpaperSettings;
+/** Only these named image stores can be selected by an HTTP request. */
+export declare function wallpaperTarget(value: string | null): WallpaperTarget | undefined;
+/** 把九宫格锚点与相对视口的百分比微调组合成 background-position。 */
+export declare function backgroundPositionWithOffset(position: WallpaperPosition, offsetXPercent: number, offsetYPercent: number): string;
+export declare function modeStyle(mode: WallpaperMode): WallpaperModeStyle;
+export declare function hexToRgb(value: string): [number, number, number];
+export declare function surfaceLayerAlphas(base: number, maxOpacity?: number): [number, number, number];

package/lib/logic.js

@@ -0,0 +1,145 @@
+export const WALLPAPER_MODES = [
+    'cover',
+    'contain',
+    'stretch',
+    'fit-width',
+    'fit-height',
+    'center',
+    'tile',
+];
+export const WALLPAPER_POSITIONS = [
+    'left top',
+    'center top',
+    'right top',
+    'left center',
+    'center center',
+    'right center',
+    'left bottom',
+    'center bottom',
+    'right bottom',
+];
+export const WALLPAPER_REGIONS = ['settings', 'sidebar'];
+const DEFAULT_SURFACE_SETTINGS = {
+    enabled: true,
+    imageName: null,
+    mode: 'cover',
+    position: 'center center',
+    offsetXPercent: 0,
+    offsetYPercent: 0,
+    imageOpacity: 1,
+    blur: 0,
+    maskColor: '#000000',
+    maskOpacity: 0.18,
+    surfaceOpacity: 0.56,
+};
+export function defaultRegionSettings() {
+    const { enabled: _enabled, ...appearance } = DEFAULT_SURFACE_SETTINGS;
+    return { ...appearance, source: 'none', imageOpacity: 0.45, blur: 8, maskOpacity: 0, surfaceOpacity: 0.95 };
+}
+export const DEFAULT_SETTINGS = {
+    ...DEFAULT_SURFACE_SETTINGS,
+    regions: { settings: defaultRegionSettings(), sidebar: defaultRegionSettings() },
+};
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function clamp(value, fallback, min, max) {
+    const parsed = typeof value === 'number' ? value : Number.NaN;
+    if (!Number.isFinite(parsed))
+        return fallback;
+    return Math.min(max, Math.max(min, parsed));
+}
+function isMode(value) {
+    return typeof value === 'string' && WALLPAPER_MODES.includes(value);
+}
+function isPosition(value) {
+    return typeof value === 'string' && WALLPAPER_POSITIONS.includes(value);
+}
+function normalizeHexColor(value) {
+    if (typeof value !== 'string')
+        return DEFAULT_SETTINGS.maskColor;
+    const trimmed = value.trim();
+    if (/^#[0-9a-f]{6}$/i.test(trimmed))
+        return trimmed.toLowerCase();
+    if (/^#[0-9a-f]{3}$/i.test(trimmed)) {
+        const [r, g, b] = trimmed.slice(1).split('');
+        return `#${r}${r}${g}${g}${b}${b}`.toLowerCase();
+    }
+    return DEFAULT_SETTINGS.maskColor;
+}
+function normalizeSurface(value, maxSurfaceOpacity = 0.95) {
+    const input = isRecord(value) ? value : {};
+    const rawName = typeof input.imageName === 'string' ? input.imageName.trim() : '';
+    return {
+        enabled: typeof input.enabled === 'boolean' ? input.enabled : DEFAULT_SETTINGS.enabled,
+        imageName: rawName.length > 0 ? rawName.slice(0, 260) : null,
+        mode: isMode(input.mode) ? input.mode : DEFAULT_SETTINGS.mode,
+        position: isPosition(input.position) ? input.position : DEFAULT_SETTINGS.position,
+        offsetXPercent: clamp(input.offsetXPercent, DEFAULT_SETTINGS.offsetXPercent, -100, 100),
+        offsetYPercent: clamp(input.offsetYPercent, DEFAULT_SETTINGS.offsetYPercent, -100, 100),
+        imageOpacity: clamp(input.imageOpacity, DEFAULT_SETTINGS.imageOpacity, 0, 1),
+        blur: clamp(input.blur, DEFAULT_SETTINGS.blur, 0, 40),
+        maskColor: normalizeHexColor(input.maskColor),
+        maskOpacity: clamp(input.maskOpacity, DEFAULT_SETTINGS.maskOpacity, 0, 0.9),
+        surfaceOpacity: clamp(input.surfaceOpacity, DEFAULT_SETTINGS.surfaceOpacity, 0, maxSurfaceOpacity),
+    };
+}
+export function normalizeSettings(value) {
+    const input = isRecord(value) ? value : {};
+    const regions = isRecord(input.regions) ? input.regions : {};
+    const region = (key) => {
+        const value = isRecord(regions[key]) ? regions[key] : {};
+        const { enabled: _enabled, ...appearance } = normalizeSurface({ ...defaultRegionSettings(), ...value }, 1);
+        return { ...appearance, source: value.source === 'global' || value.source === 'custom' ? value.source : 'none' };
+    };
+    return { ...normalizeSurface(input), regions: { settings: region('settings'), sidebar: region('sidebar') } };
+}
+/** Only these named image stores can be selected by an HTTP request. */
+export function wallpaperTarget(value) {
+    return value === null || value === 'global' ? 'global'
+        : value === 'settings' || value === 'sidebar' ? value : undefined;
+}
+function offsetAxis(anchor, offset, viewportUnit) {
+    if (offset === 0)
+        return anchor;
+    const operator = offset < 0 ? '-' : '+';
+    return `calc(${anchor} ${operator} ${Math.abs(offset)}${viewportUnit})`;
+}
+/** 把九宫格锚点与相对视口的百分比微调组合成 background-position。 */
+export function backgroundPositionWithOffset(position, offsetXPercent, offsetYPercent) {
+    const [horizontal, vertical] = position.split(' ');
+    const horizontalAnchor = { left: '0%', center: '50%', right: '100%' }[horizontal];
+    const verticalAnchor = { top: '0%', center: '50%', bottom: '100%' }[vertical];
+    return `${offsetAxis(horizontalAnchor, offsetXPercent, 'vw')} ${offsetAxis(verticalAnchor, offsetYPercent, 'vh')}`;
+}
+export function modeStyle(mode) {
+    switch (mode) {
+        case 'contain':
+            return { size: 'contain', repeat: 'no-repeat' };
+        case 'stretch':
+            return { size: '100% 100%', repeat: 'no-repeat' };
+        case 'fit-width':
+            return { size: '100% auto', repeat: 'no-repeat' };
+        case 'fit-height':
+            return { size: 'auto 100%', repeat: 'no-repeat' };
+        case 'center':
+            return { size: 'auto', repeat: 'no-repeat' };
+        case 'tile':
+            return { size: 'auto', repeat: 'repeat' };
+        case 'cover':
+        default:
+            return { size: 'cover', repeat: 'no-repeat' };
+    }
+}
+export function hexToRgb(value) {
+    const color = normalizeHexColor(value).slice(1);
+    return [
+        Number.parseInt(color.slice(0, 2), 16),
+        Number.parseInt(color.slice(2, 4), 16),
+        Number.parseInt(color.slice(4, 6), 16),
+    ];
+}
+export function surfaceLayerAlphas(base, maxOpacity = 0.95) {
+    const normalized = clamp(base, DEFAULT_SETTINGS.surfaceOpacity, 0, maxOpacity);
+    return [normalized, Math.max(normalized, Math.min(0.97, normalized + 0.1)), Math.max(normalized, Math.min(0.99, normalized + 0.2))];
+}

package/lib/regions.d.ts

@@ -0,0 +1,6 @@
+import { type WallpaperRegion, type WallpaperSettings } from './logic.js';
+export declare const REGIONS_ATTRIBUTE = "data-dsh-wallpaper-regions";
+export declare const REGION_SELECTORS: Record<WallpaperRegion, string>;
+export declare const REGION_VARIABLES: string[];
+export declare function regionVariables(settings: WallpaperSettings, globalUrl: string | null, images: Record<WallpaperRegion, string | null>): Record<string, string>;
+export declare const REGION_STYLES: string;

package/lib/regions.js

@@ -0,0 +1,71 @@
+import { backgroundPositionWithOffset, hexToRgb, modeStyle, surfaceLayerAlphas, WALLPAPER_REGIONS } from './logic.js';
+export const REGIONS_ATTRIBUTE = 'data-dsh-wallpaper-regions';
+export const REGION_SELECTORS = {
+    settings: '[role="dialog"][aria-modal="true"]:has([data-slot="settings.header"])',
+    sidebar: '[data-sidebar-right-panel]',
+};
+const PROPERTIES = ['image', 'size', 'repeat', 'position', 'opacity', 'blur', 'mask-rgb', 'mask-opacity', 'surface-1', 'surface-2', 'surface-3'];
+export const REGION_VARIABLES = WALLPAPER_REGIONS.flatMap((region) => PROPERTIES.map((property) => `--dsh-wallpaper-${region}-${property}`));
+export function regionVariables(settings, globalUrl, images) {
+    const variables = {};
+    for (const region of WALLPAPER_REGIONS) {
+        const value = settings.regions[region];
+        const url = value.source === 'custom' ? images[region] : value.source === 'global' ? globalUrl : null;
+        const style = modeStyle(value.mode);
+        const surfaces = surfaceLayerAlphas(value.surfaceOpacity, 1);
+        const values = [
+            url === null ? 'none' : `url(${JSON.stringify(url)})`, style.size, style.repeat,
+            backgroundPositionWithOffset(value.position, value.offsetXPercent, value.offsetYPercent),
+            String(value.imageOpacity), `${value.blur}px`, hexToRgb(value.maskColor).join(' '),
+            String(url === null ? 0 : value.maskOpacity), ...surfaces.map(String),
+        ];
+        PROPERTIES.forEach((property, index) => { variables[`--dsh-wallpaper-${region}-${property}`] = values[index]; });
+    }
+    return variables;
+}
+export const REGION_STYLES = `
+body[${REGIONS_ATTRIBUTE}] { --dsh-wallpaper-region-rgb: 255 255 255; }
+body[${REGIONS_ATTRIBUTE}][data-ds-dark-theme] { --dsh-wallpaper-region-rgb: 18 22 32; }
+${WALLPAPER_REGIONS.map((region) => {
+    const selector = `body[${REGIONS_ATTRIBUTE}] ${REGION_SELECTORS[region]}`;
+    const variable = (name) => `var(--dsh-wallpaper-${region}-${name})`;
+    return `
+${selector} {
+  isolation: isolate;
+  background: rgb(var(--dsh-wallpaper-region-rgb) / ${variable('surface-1')});
+  --dsh-wallpaper-local-1: rgb(var(--dsh-wallpaper-region-rgb) / ${variable('surface-1')});
+  --dsh-wallpaper-local-2: rgb(var(--dsh-wallpaper-region-rgb) / ${variable('surface-2')});
+  --dsh-wallpaper-local-3: rgb(var(--dsh-wallpaper-region-rgb) / ${variable('surface-3')});
+  --dsw-alias-bg-base: transparent;
+  --dsw-specific-sidebar-fill: transparent;
+  --dsw-alias-bg-layer-1: var(--dsh-wallpaper-local-1);
+  --dsw-alias-bg-layer-2: var(--dsh-wallpaper-local-2);
+  --dsw-alias-bg-layer-3: var(--dsh-wallpaper-local-3);
+  --dsw-alias-bg-module-platform: var(--dsh-wallpaper-local-2);
+  --dsw-specific-input-major: var(--dsh-wallpaper-local-2);
+  --dsw-specific-selector: var(--dsh-wallpaper-local-2);
+  --dsw-specific-tip: var(--dsh-wallpaper-local-2);
+  --dsw-alias-button-elevated-fill: var(--dsh-wallpaper-local-2);
+  --dsw-alias-button-floating-fill: var(--dsh-wallpaper-local-3);
+  --dsw-alias-markdown-code-block: var(--dsh-wallpaper-local-2);
+  --dsw-alias-markdown-code-block-banner: var(--dsh-wallpaper-local-3);
+  --dsw-alias-markdown-inline-code: var(--dsh-wallpaper-local-2);
+}
+${selector}::before, ${selector}::after {
+  content: ''; position: absolute; inset: 0; pointer-events: none; border-radius: inherit;
+}
+${selector}::before {
+  z-index: -2;
+  background-image: ${variable('image')};
+  background-size: ${variable('size')};
+  background-repeat: ${variable('repeat')};
+  background-position: ${variable('position')};
+  opacity: ${variable('opacity')};
+  filter: blur(${variable('blur')});
+  clip-path: inset(0);
+}
+${selector}::after {
+  z-index: -1; background: rgb(${variable('mask-rgb')} / ${variable('mask-opacity')});
+}`;
+}).join('\n')}
+`;

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@dfy-plugins/dsh-wallpaper",
+  "version": "0.1.2",
+  "description": "DeepSeek Harness 可配置图片壁纸：适应模式、位置、透明度、模糊与颜色遮罩。",
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./client": {
+      "default": "./lib/client.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "cordis.patch.yml"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "license": "MIT",
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-atomic-write": "^0.1.1-rc.2 || ^0.1.2-alpha.1 || ^0.1.5-alpha.1",
+    "@deepseek-ai/dsh-home-paths": "^0.1.1-rc.2 || ^0.1.2-alpha.1 || ^0.1.5-alpha.1",
+    "@deepseek-ai/dsh-host-webserver": "^0.1.1-rc.2 || ^0.1.2-alpha.1 || ^0.1.5-alpha.1"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-atomic-write": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-home-paths": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-host-webserver": "^0.1.1-rc.2",
+    "@types/node": "^24.0.0",
+    "@types/react": "^19.0.0",
+    "esbuild": "^0.24.0",
+    "typescript": "^5.5.0"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/xiaoxiao44443/dfy-dsh-plugins.git",
+    "directory": "plugins/wallpaper"
+  },
+  "homepage": "https://github.com/xiaoxiao44443/dfy-dsh-plugins#readme",
+  "bugs": {
+    "url": "https://github.com/xiaoxiao44443/dfy-dsh-plugins/issues"
+  },
+  "keywords": [
+    "deepseek-harness",
+    "dsh-plugin"
+  ],
+  "scripts": {
+    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.client.json --noEmit",
+    "build": "tsc -p tsconfig.json && node scripts/build-client.mjs",
+    "test": "tsc -p tsconfig.json && node --test"
+  }
+}