kitowall 2.1.0 → 2.3.0

package/dist/cli.js

@@ -118,6 +118,8 @@ Commands:
                                          Show system logs (requests/downloads/errors)
   logs clear                             Clear system logs
   we config set-api-key <key>            Save Steam Web API key (~/.config/kitowall/we.json)
+  we config get-steam-roots              Show configured manual Steam roots
+  we config set-steam-roots <a,b,c>      Save manual Steam roots (steam root or workshop/content/431960)
   we search [--text <q>] [--tags <a,b>] [--sort <top|newest|trend|subscribed|updated>] [--page <n>] [--page-size <n>] [--days <n>] [--fixtures]
                                          Search Wallpaper Engine workshop items (appid 431960)
   we details <publishedfileid> [--fixtures]
@@ -127,6 +129,11 @@ Commands:
   we job <job_id>                        Show one download job
   we jobs [--limit <n>]                  List recent download jobs
   we library                             List downloaded workshop items
+  we scan-steam                          Detect Steam workshop folders and list downloaded ids
+  we sync-steam                          Sync local Steam Workshop 431960 items into Kitsune downloads
+  we app-status                          Detect if Wallpaper Engine (AppID 431960) is installed
+  we active                              Show current livewallpaper authority/lock state
+  we stop [--monitor <name> | --all]     Stop livewallpaper instances and restore previous services
   we coexist enter|exit|status           Temporarily stop/restore wallpaper rotation services
   check [--namespace <ns>] [--json]        Quick system check (no changes)
 
@@ -303,14 +310,26 @@ async function main() {
         }
         if (action === 'config') {
             const sub = cleanOpt(args[2] ?? null);
-            if (sub !== 'set-api-key')
-                throw new Error('Usage: we config set-api-key <key>');
-            const key = cleanOpt(args[3] ?? null);
-            if (!key)
-                throw new Error('Usage: we config set-api-key <key>');
-            (0, workshop_1.setWorkshopApiKey)(key);
-            console.log(JSON.stringify({ ok: true, updated: 'steamWebApiKey' }, null, 2));
-            return;
+            if (sub === 'set-api-key') {
+                const key = cleanOpt(args[3] ?? null);
+                if (!key)
+                    throw new Error('Usage: we config set-api-key <key>');
+                (0, workshop_1.setWorkshopApiKey)(key);
+                console.log(JSON.stringify({ ok: true, updated: 'steamWebApiKey' }, null, 2));
+                return;
+            }
+            if (sub === 'get-steam-roots') {
+                console.log(JSON.stringify({ ok: true, ...(0, workshop_1.workshopGetSteamRoots)() }, null, 2));
+                return;
+            }
+            if (sub === 'set-steam-roots') {
+                const raw = cleanOpt(args[3] ?? null) ?? '';
+                const roots = raw ? raw.split(',').map(v => v.trim()).filter(Boolean) : [];
+                const out = (0, workshop_1.workshopSetSteamRoots)(roots);
+                console.log(JSON.stringify(out, null, 2));
+                return;
+            }
+            throw new Error('Usage: we config <set-api-key|get-steam-roots|set-steam-roots> ...');
         }
         if (action === 'search') {
             const text = cleanOpt(getOptionValue(args, '--text'));
@@ -386,6 +405,35 @@ async function main() {
             console.log(JSON.stringify(out, null, 2));
             return;
         }
+        if (action === 'scan-steam') {
+            const out = (0, workshop_1.workshopScanSteamDownloads)();
+            console.log(JSON.stringify({ ok: true, ...out }, null, 2));
+            return;
+        }
+        if (action === 'sync-steam') {
+            const out = (0, workshop_1.workshopSyncSteamDownloads)();
+            console.log(JSON.stringify(out, null, 2));
+            return;
+        }
+        if (action === 'app-status') {
+            const out = (0, workshop_1.workshopWallpaperEngineStatus)();
+            console.log(JSON.stringify(out, null, 2));
+            return;
+        }
+        if (action === 'active') {
+            const out = (0, workshop_1.workshopActiveStatus)();
+            console.log(JSON.stringify(out, null, 2));
+            return;
+        }
+        if (action === 'stop') {
+            const monitor = cleanOpt(getOptionValue(args, '--monitor'));
+            const out = await (0, workshop_1.workshopStop)({
+                monitor,
+                all: args.includes('--all') || !monitor
+            });
+            console.log(JSON.stringify(out, null, 2));
+            return;
+        }
         if (action === 'coexist') {
             const sub = cleanOpt(args[2] ?? null);
             if (sub === 'enter') {
@@ -405,7 +453,7 @@ async function main() {
             }
             throw new Error('Usage: we coexist <enter|exit|status>');
         }
-        throw new Error('Usage: we <config|search|details|download|job|jobs|library|run-job|coexist> ...');
+        throw new Error('Usage: we <config|search|details|download|job|jobs|library|scan-steam|sync-steam|app-status|active|stop|run-job|coexist> ...');
     }
     // Regular commands (need config/state)
     const config = (0, config_1.loadConfig)();

package/dist/core/workshop.js

@@ -4,12 +4,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setWorkshopApiKey = setWorkshopApiKey;
+exports.workshopGetSteamRoots = workshopGetSteamRoots;
+exports.workshopSetSteamRoots = workshopSetSteamRoots;
+exports.workshopWallpaperEngineStatus = workshopWallpaperEngineStatus;
+exports.workshopScanSteamDownloads = workshopScanSteamDownloads;
+exports.workshopSyncSteamDownloads = workshopSyncSteamDownloads;
 exports.workshopSearch = workshopSearch;
 exports.workshopDetails = workshopDetails;
 exports.workshopQueueDownload = workshopQueueDownload;
+exports.workshopActiveStatus = workshopActiveStatus;
+exports.workshopSetActive = workshopSetActive;
 exports.workshopCoexistenceEnter = workshopCoexistenceEnter;
 exports.workshopCoexistenceExit = workshopCoexistenceExit;
 exports.workshopCoexistenceStatus = workshopCoexistenceStatus;
+exports.workshopStop = workshopStop;
 exports.workshopRunJob = workshopRunJob;
 exports.workshopGetJob = workshopGetJob;
 exports.workshopListJobs = workshopListJobs;
@@ -59,6 +67,7 @@ function ensureWePaths(paths) {
     (0, fs_1.ensureDir)(paths.runtime);
     (0, fs_1.ensureDir)(node_path_1.default.join(paths.cache, 'search'));
     (0, fs_1.ensureDir)(node_path_1.default.join(paths.steamcmd, 'logs'));
+    (0, fs_1.ensureDir)(node_path_1.default.join(paths.root, 'coexistence', 'snapshots'));
 }
 function getWeConfigPath() {
     return node_path_1.default.join(node_os_1.default.homedir(), '.config', 'kitowall', 'we.json');
@@ -74,6 +83,16 @@ function readWeConfig() {
         return {};
     }
 }
+function normalizePath(input) {
+    const raw = clean(input) ?? '';
+    if (!raw)
+        return '';
+    if (raw === '~')
+        return node_os_1.default.homedir();
+    if (raw.startsWith('~/'))
+        return node_path_1.default.join(node_os_1.default.homedir(), raw.slice(2));
+    return raw;
+}
 function setWorkshopApiKey(apiKey) {
     const key = clean(apiKey);
     if (!key)
@@ -84,6 +103,20 @@ function setWorkshopApiKey(apiKey) {
     (0, fs_1.writeJson)(p, current);
     return { ok: true };
 }
+function workshopGetSteamRoots() {
+    const cfg = readWeConfig();
+    const steamRoots = Array.isArray(cfg.steamRoots)
+        ? cfg.steamRoots.map(v => normalizePath(String(v))).filter(Boolean)
+        : [];
+    return { steam_roots: Array.from(new Set(steamRoots)) };
+}
+function workshopSetSteamRoots(roots) {
+    const cfg = readWeConfig();
+    const normalized = roots.map(v => normalizePath(String(v))).filter(Boolean);
+    cfg.steamRoots = Array.from(new Set(normalized));
+    (0, fs_1.writeJson)(getWeConfigPath(), cfg);
+    return { ok: true, steam_roots: cfg.steamRoots };
+}
 function getSteamWebApiKey() {
     const envKey = clean(process.env.STEAM_WEB_API_KEY) ?? clean(process.env.KITOWALL_STEAM_WEB_API_KEY);
     if (envKey)
@@ -322,6 +355,281 @@ function writeMetaFile(meta) {
         cached_at: now()
     });
 }
+function normalizeWallpaperType(raw) {
+    const t = clean(raw)?.toLowerCase();
+    if (!t)
+        return 'unknown';
+    if (t === 'video')
+        return 'video';
+    if (t === 'scene')
+        return 'scene';
+    if (t === 'web')
+        return 'web';
+    if (t === 'application')
+        return 'application';
+    return 'unknown';
+}
+function detectAudioReactiveFromText(text) {
+    return /(audio|spectrum|visualizer|now[\s_-]?playing|media[\s_-]?integration|fft|bass|reactive)/i.test(text);
+}
+function readProjectInfo(dir) {
+    const projectPath = node_path_1.default.join(dir, 'project.json');
+    if (!node_fs_1.default.existsSync(projectPath)) {
+        return { type: 'unknown', audioReactive: false };
+    }
+    try {
+        const raw = node_fs_1.default.readFileSync(projectPath, 'utf8');
+        const json = JSON.parse(raw);
+        const type = normalizeWallpaperType(json.type);
+        const title = clean(json.title) ?? '';
+        const audioReactive = detectAudioReactiveFromText(`${title}\n${raw}`);
+        return { type, audioReactive };
+    }
+    catch {
+        return { type: 'unknown', audioReactive: false };
+    }
+}
+function readLibraryFoldersVdf(vdfPath) {
+    if (!node_fs_1.default.existsSync(vdfPath))
+        return [];
+    const raw = node_fs_1.default.readFileSync(vdfPath, 'utf8');
+    const out = [];
+    const lines = raw.split('\n');
+    for (const line of lines) {
+        const m = line.match(/"path"\s+"([^"]+)"/);
+        if (!m || !m[1])
+            continue;
+        const candidate = m[1].replace(/\\\\/g, '\\');
+        out.push(candidate);
+    }
+    return out;
+}
+function getDefaultSteamRoots() {
+    const home = node_os_1.default.homedir();
+    const roots = [
+        node_path_1.default.join(home, '.steam', 'steam'),
+        node_path_1.default.join(home, '.local', 'share', 'Steam'),
+        node_path_1.default.join(home, '.var', 'app', 'com.valvesoftware.Steam', '.local', 'share', 'Steam')
+    ];
+    return Array.from(new Set(roots));
+}
+function getManualSteamRoots() {
+    const cfg = readWeConfig();
+    if (!Array.isArray(cfg.steamRoots))
+        return [];
+    return cfg.steamRoots.map(v => normalizePath(String(v))).filter(Boolean);
+}
+function detectSteamappsDirs() {
+    const steamappsSet = new Set();
+    const candidateRoots = [...getDefaultSteamRoots(), ...getManualSteamRoots()];
+    for (const root of candidateRoots) {
+        const p = normalizePath(root);
+        if (!p || !node_fs_1.default.existsSync(p))
+            continue;
+        if (node_path_1.default.basename(p) === 'steamapps' && node_fs_1.default.existsSync(p)) {
+            steamappsSet.add(p);
+        }
+        const directSteamapps = node_path_1.default.join(p, 'steamapps');
+        if (node_fs_1.default.existsSync(directSteamapps)) {
+            steamappsSet.add(directSteamapps);
+        }
+        const marker = `${node_path_1.default.sep}steamapps${node_path_1.default.sep}workshop${node_path_1.default.sep}content${node_path_1.default.sep}${WE_APP_ID}`;
+        const idx = p.indexOf(marker);
+        if (idx >= 0) {
+            const steamapps = p.slice(0, idx + `${node_path_1.default.sep}steamapps`.length);
+            if (node_fs_1.default.existsSync(steamapps))
+                steamappsSet.add(steamapps);
+        }
+        const markerNoSteamapps = `${node_path_1.default.sep}workshop${node_path_1.default.sep}content${node_path_1.default.sep}${WE_APP_ID}`;
+        const idx2 = p.indexOf(markerNoSteamapps);
+        if (idx2 >= 0) {
+            const steamappsMaybe = p.slice(0, idx2);
+            if (node_path_1.default.basename(steamappsMaybe) === 'steamapps' && node_fs_1.default.existsSync(steamappsMaybe)) {
+                steamappsSet.add(steamappsMaybe);
+            }
+        }
+    }
+    const baseSteamapps = Array.from(steamappsSet);
+    for (const steamapps of baseSteamapps) {
+        const vdf = node_path_1.default.join(steamapps, 'libraryfolders.vdf');
+        for (const lib of readLibraryFoldersVdf(vdf)) {
+            const candidate = node_path_1.default.join(lib, 'steamapps');
+            if (node_fs_1.default.existsSync(candidate))
+                steamappsSet.add(candidate);
+        }
+    }
+    return Array.from(steamappsSet);
+}
+function toWorkshopAppContentDir(inputPath) {
+    const p = normalizePath(inputPath);
+    if (!p)
+        return '';
+    const direct = p;
+    const asSteamRoot = node_path_1.default.join(p, 'steamapps', 'workshop', 'content', String(WE_APP_ID));
+    const asSteamappsRoot = node_path_1.default.join(p, 'workshop', 'content', String(WE_APP_ID));
+    const asContentRoot = node_path_1.default.join(p, String(WE_APP_ID));
+    if (node_fs_1.default.existsSync(direct) && direct.endsWith(`${node_path_1.default.sep}${WE_APP_ID}`))
+        return direct;
+    if (node_fs_1.default.existsSync(direct) && direct.includes(`${node_path_1.default.sep}workshop${node_path_1.default.sep}content${node_path_1.default.sep}${WE_APP_ID}`))
+        return direct;
+    if (node_fs_1.default.existsSync(asSteamRoot))
+        return asSteamRoot;
+    if (node_fs_1.default.existsSync(asSteamappsRoot))
+        return asSteamappsRoot;
+    if (node_fs_1.default.existsSync(asContentRoot))
+        return asContentRoot;
+    return '';
+}
+function detectSteamWorkshopContentDirs() {
+    const discovered = new Set();
+    for (const root of getManualSteamRoots()) {
+        const fromManual = toWorkshopAppContentDir(root);
+        if (fromManual && node_fs_1.default.existsSync(fromManual))
+            discovered.add(fromManual);
+    }
+    for (const steamapps of detectSteamappsDirs()) {
+        const candidate = node_path_1.default.join(steamapps, 'workshop', 'content', String(WE_APP_ID));
+        if (node_fs_1.default.existsSync(candidate)) {
+            discovered.add(candidate);
+        }
+    }
+    return Array.from(discovered);
+}
+function workshopWallpaperEngineStatus() {
+    const manifests = [];
+    const steamapps = detectSteamappsDirs();
+    for (const dir of steamapps) {
+        const manifest = node_path_1.default.join(dir, `appmanifest_${WE_APP_ID}.acf`);
+        if (node_fs_1.default.existsSync(manifest))
+            manifests.push(manifest);
+    }
+    return {
+        ok: true,
+        installed: manifests.length > 0,
+        manifests,
+        steamapps
+    };
+}
+function findPreviewCandidate(dir) {
+    if (!node_fs_1.default.existsSync(dir))
+        return undefined;
+    const entries = node_fs_1.default.readdirSync(dir, { withFileTypes: true });
+    const preferred = ['preview.gif', 'preview.webm', 'preview.mp4', 'preview.jpg', 'preview.png', 'preview.webp'];
+    for (const name of preferred) {
+        const full = node_path_1.default.join(dir, name);
+        if (node_fs_1.default.existsSync(full) && node_fs_1.default.statSync(full).isFile())
+            return full;
+    }
+    for (const entry of entries) {
+        if (!entry.isFile())
+            continue;
+        const lower = entry.name.toLowerCase();
+        if (lower.startsWith('preview.') || lower.startsWith('thumbnail.')) {
+            return node_path_1.default.join(dir, entry.name);
+        }
+    }
+    return undefined;
+}
+function workshopScanSteamDownloads() {
+    const sources = detectSteamWorkshopContentDirs();
+    const idsSet = new Set();
+    for (const source of sources) {
+        if (!node_fs_1.default.existsSync(source))
+            continue;
+        const entries = node_fs_1.default.readdirSync(source, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const id = clean(entry.name);
+            if (!id)
+                continue;
+            idsSet.add(id);
+        }
+    }
+    const ids = Array.from(idsSet).sort();
+    return { sources, count: ids.length, ids };
+}
+function workshopSyncSteamDownloads() {
+    const app = workshopWallpaperEngineStatus();
+    if (!app.installed) {
+        throw new Error('Wallpaper Engine (AppID 431960) is not installed in Steam. Install it first to sync downloads.');
+    }
+    const paths = getWePaths();
+    ensureWePaths(paths);
+    const sources = detectSteamWorkshopContentDirs();
+    let imported = 0;
+    let skipped = 0;
+    const seen = new Set();
+    for (const source of sources) {
+        if (!node_fs_1.default.existsSync(source))
+            continue;
+        const entries = node_fs_1.default.readdirSync(source, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const id = clean(entry.name);
+            if (!id || seen.has(id))
+                continue;
+            seen.add(id);
+            const sourceDir = node_path_1.default.join(source, id);
+            const targetDir = node_path_1.default.join(paths.downloads, id);
+            if (node_fs_1.default.existsSync(targetDir)) {
+                skipped += 1;
+            }
+            else {
+                node_fs_1.default.cpSync(sourceDir, targetDir, { recursive: true });
+                imported += 1;
+            }
+            const metadataFile = node_path_1.default.join(paths.metadata, `${id}.json`);
+            const info = readProjectInfo(sourceDir);
+            if (!node_fs_1.default.existsSync(metadataFile)) {
+                const previewCandidate = findPreviewCandidate(sourceDir);
+                let thumbLocal;
+                if (previewCandidate && node_fs_1.default.existsSync(previewCandidate)) {
+                    const ext = node_path_1.default.extname(previewCandidate) || '.jpg';
+                    const previewDir = node_path_1.default.join(paths.previews, id);
+                    (0, fs_1.ensureDir)(previewDir);
+                    thumbLocal = node_path_1.default.join(previewDir, `thumb${ext}`);
+                    if (!node_fs_1.default.existsSync(thumbLocal)) {
+                        node_fs_1.default.copyFileSync(previewCandidate, thumbLocal);
+                    }
+                }
+                writeMetaFile({
+                    id,
+                    title: `Wallpaper ${id}`,
+                    tags: [],
+                    preview_thumb_local: thumbLocal,
+                    author_name: 'Steam Workshop',
+                    time_updated: Math.floor(Date.now() / 1000),
+                    wallpaper_type: info.type,
+                    audio_reactive: info.audioReactive
+                });
+            }
+            else {
+                try {
+                    const current = JSON.parse(node_fs_1.default.readFileSync(metadataFile, 'utf8'));
+                    if (!current.wallpaper_type || current.wallpaper_type === 'unknown' || current.audio_reactive === undefined) {
+                        writeMetaFile({
+                            ...current,
+                            wallpaper_type: current.wallpaper_type ?? info.type,
+                            audio_reactive: current.audio_reactive ?? info.audioReactive
+                        });
+                    }
+                }
+                catch {
+                    // ignore malformed metadata
+                }
+            }
+        }
+    }
+    return {
+        ok: true,
+        sources,
+        imported,
+        skipped,
+        total: imported + skipped
+    };
+}
 async function workshopSearch(input) {
     const paths = getWePaths();
     ensureWePaths(paths);
@@ -561,6 +869,78 @@ async function copyDownloadedContent(job) {
 function snapshotFile(paths) {
     return node_path_1.default.join(paths.runtime, 'coexistence.snapshot.json');
 }
+function snapshotDir(paths) {
+    return node_path_1.default.join(paths.root, 'coexistence', 'snapshots');
+}
+function activeLockFile(paths) {
+    return node_path_1.default.join(paths.runtime, 'active.lock');
+}
+function activeStateFile(paths) {
+    return node_path_1.default.join(paths.runtime, 'active.json');
+}
+function readActiveState() {
+    const paths = getWePaths();
+    ensureWePaths(paths);
+    const p = activeStateFile(paths);
+    if (!node_fs_1.default.existsSync(p))
+        return null;
+    try {
+        return JSON.parse(node_fs_1.default.readFileSync(p, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function writeActiveState(state) {
+    const paths = getWePaths();
+    ensureWePaths(paths);
+    (0, fs_1.writeJson)(activeStateFile(paths), state);
+    node_fs_1.default.writeFileSync(activeLockFile(paths), `${state.mode}:${state.started_at}\n`, 'utf8');
+}
+function clearActiveState() {
+    const paths = getWePaths();
+    ensureWePaths(paths);
+    try {
+        node_fs_1.default.unlinkSync(activeStateFile(paths));
+    }
+    catch {
+        // ignore
+    }
+    try {
+        node_fs_1.default.unlinkSync(activeLockFile(paths));
+    }
+    catch {
+        // ignore
+    }
+}
+function killPid(pid) {
+    if (!pid || !Number.isFinite(pid) || pid <= 1)
+        return false;
+    try {
+        process.kill(pid, 'SIGTERM');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function workshopActiveStatus() {
+    const paths = getWePaths();
+    ensureWePaths(paths);
+    const state = readActiveState();
+    const lock = node_fs_1.default.existsSync(activeLockFile(paths));
+    return {
+        ok: true,
+        active: lock && !!state,
+        lock_path: activeLockFile(paths),
+        state_path: activeStateFile(paths),
+        state: state ?? undefined
+    };
+}
+function workshopSetActive(state) {
+    writeActiveState(state);
+    return { ok: true, active: true, state };
+}
 async function isUnitActive(unit) {
     try {
         const out = await (0, exec_1.run)('systemctl', ['--user', 'show', unit, '--property', 'ActiveState', '--value']);
@@ -587,8 +967,11 @@ async function workshopCoexistenceEnter() {
             // best effort
         }
     }
-    (0, fs_1.writeJson)(snapshotFile(paths), { ts: now(), active });
-    return { ok: true, stopped: active, snapshot: active };
+    const snapshotId = String(now());
+    const snap = { id: snapshotId, ts: now(), active };
+    (0, fs_1.writeJson)(node_path_1.default.join(snapshotDir(paths), `${snapshotId}.json`), snap);
+    (0, fs_1.writeJson)(snapshotFile(paths), { id: snapshotId, ts: snap.ts });
+    return { ok: true, stopped: active, snapshot: active, snapshot_id: snapshotId };
 }
 async function workshopCoexistenceExit() {
     const paths = getWePaths();
@@ -597,7 +980,19 @@ async function workshopCoexistenceExit() {
     if (!node_fs_1.default.existsSync(snapPath))
         return { ok: true, restored: [] };
     const raw = JSON.parse(node_fs_1.default.readFileSync(snapPath, 'utf8'));
-    const active = Array.isArray(raw.active) ? raw.active.map(v => String(v)) : [];
+    let active = Array.isArray(raw.active) ? raw.active.map(v => String(v)) : [];
+    if ((!active || active.length === 0) && raw.id) {
+        const historical = node_path_1.default.join(snapshotDir(paths), `${raw.id}.json`);
+        if (node_fs_1.default.existsSync(historical)) {
+            try {
+                const snap = JSON.parse(node_fs_1.default.readFileSync(historical, 'utf8'));
+                active = Array.isArray(snap.active) ? snap.active.map(v => String(v)) : [];
+            }
+            catch {
+                active = [];
+            }
+        }
+    }
     const restored = [];
     for (const unit of active) {
         try {
@@ -630,6 +1025,42 @@ async function workshopCoexistenceStatus() {
     }
     return { ok: true, snapshot, current };
 }
+async function workshopStop(options) {
+    const state = readActiveState();
+    const hadActive = !!state;
+    const stopped = [];
+    if (state?.instances) {
+        if (options?.monitor) {
+            const inst = state.instances[options.monitor];
+            if (killPid(inst?.pid))
+                stopped.push(options.monitor);
+            delete state.instances[options.monitor];
+            if (Object.keys(state.instances).length > 0 && !options?.all) {
+                writeActiveState(state);
+            }
+            else {
+                clearActiveState();
+            }
+        }
+        else {
+            for (const [monitor, inst] of Object.entries(state.instances)) {
+                if (killPid(inst?.pid))
+                    stopped.push(monitor);
+            }
+            clearActiveState();
+        }
+    }
+    else if (options?.all) {
+        clearActiveState();
+    }
+    const coexist = await workshopCoexistenceExit();
+    return {
+        ok: true,
+        stopped_instances: stopped,
+        restored_units: coexist.restored,
+        had_active: hadActive
+    };
+}
 async function workshopRunJob(jobId) {
     const job = readJob(jobId);
     if (!job)
@@ -728,6 +1159,13 @@ function workshopLibrary() {
                 meta = undefined;
             }
         }
+        const info = readProjectInfo(p);
+        if (meta) {
+            meta.wallpaper_type = meta.wallpaper_type ?? info.type;
+            if (meta.audio_reactive === undefined) {
+                meta.audio_reactive = info.audioReactive;
+            }
+        }
         items.push({
             id,
             path: p,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kitowall",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "description": "CLI/daemon for Hyprland wallpapers using swww with pack-based rotation.",
   "license": "SEE LICENSE IN LICENSE.md",
   "type": "commonjs",