kitowall 3.5.16 → 3.5.36

package/README.md

@@ -55,6 +55,13 @@ chmod +x ./Kitowall-*.AppImage
 ```bash
 ./scripts/bootstrap-host.sh
 ```
+If `bootstrap-host.sh` fails on Arch with errors like `zstd: undefined symbol: POOL_free` or `bsdtar: Write error`, repair core compression/archive libs and retry:
+```bash
+sudo pacman -Syu
+sudo pacman -S --overwrite '*' zstd libarchive
+```
+Reason: this fixes host library mismatches (partial/out-of-sync updates) that break AUR package builds and package compression.
+
 4) Initialize services:
 ```bash
 kitowall init --namespace kitowall --apply --force

package/dist/core/live.js

@@ -1042,6 +1042,158 @@ function syncRendercoreEnv(defaults) {
     }
     node_fs_1.default.writeFileSync(p, `${lines.join('\n')}\n`, 'utf8');
 }
+function shSingleQuote(v) {
+    return `'${String(v).replace(/'/g, `'\\''`)}'`;
+}
+async function hostCommandExists(cmd) {
+    try {
+        await (0, exec_1.run)('sh', ['-lc', `command -v ${cmd} >/dev/null 2>&1`], { timeoutMs: 5000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function resolveHostExecutablePath(bin) {
+    const raw = clean(bin);
+    if (!raw)
+        throw new Error('empty binary name');
+    if (raw.includes('/')) {
+        if (!node_fs_1.default.existsSync(raw))
+            throw new Error(`binary not found: ${raw}`);
+        return raw;
+    }
+    const out = await (0, exec_1.run)('sh', ['-lc', `command -v ${raw}`], { timeoutMs: 5000 });
+    const resolved = clean(out.stdout.split('\n')[0]);
+    if (!resolved)
+        throw new Error(`binary not found in PATH: ${raw}`);
+    return resolved;
+}
+async function installHostPackagesArch(packages) {
+    if (packages.length === 0)
+        return;
+    const quoted = packages.map(shSingleQuote).join(' ');
+    const cmd = `if command -v sudo >/dev/null 2>&1; then ` +
+        `(sudo -n pacman -S --needed --noconfirm ${quoted} || sudo pacman -S --needed ${quoted}); ` +
+        `else pacman -S --needed ${quoted}; fi`;
+    await (0, exec_1.run)('sh', ['-lc', cmd], { timeoutMs: 240000 });
+}
+async function ensureRendercoreHostRuntimeDeps() {
+    const missing = [];
+    if (!(await hostCommandExists('ffmpeg')))
+        missing.push('ffmpeg');
+    if (!(await hostCommandExists('hyprctl')))
+        missing.push('hyprctl');
+    if (!(await hostCommandExists('systemctl')))
+        missing.push('systemctl');
+    if (missing.length === 0)
+        return { installed: [], missing: [] };
+    const canPacman = await hostCommandExists('pacman');
+    const toInstall = new Set();
+    if (missing.includes('ffmpeg'))
+        toInstall.add('ffmpeg');
+    if (missing.includes('hyprctl'))
+        toInstall.add('hyprland');
+    if (canPacman && toInstall.size > 0) {
+        await installHostPackagesArch(Array.from(toInstall));
+    }
+    const afterMissing = [];
+    if (!(await hostCommandExists('ffmpeg')))
+        afterMissing.push('ffmpeg');
+    if (!(await hostCommandExists('hyprctl')))
+        afterMissing.push('hyprctl');
+    if (!(await hostCommandExists('systemctl')))
+        afterMissing.push('systemctl');
+    return { installed: Array.from(toInstall), missing: afterMissing };
+}
+function rendercoreVideoMapPath() {
+    return node_path_1.default.join(node_os_1.default.homedir(), '.config', 'kitsune-rendercore', 'video-map.conf');
+}
+function rendercoreUserServicePath() {
+    return node_path_1.default.join(node_os_1.default.homedir(), '.config', 'systemd', 'user', 'kitsune-rendercore.service');
+}
+function readEnvPairs(p) {
+    const out = {};
+    if (!node_fs_1.default.existsSync(p))
+        return out;
+    const raw = node_fs_1.default.readFileSync(p, 'utf8');
+    for (const line of raw.split('\n')) {
+        const t = line.trim();
+        if (!t || t.startsWith('#'))
+            continue;
+        const eq = t.indexOf('=');
+        if (eq <= 0)
+            continue;
+        out[t.slice(0, eq).trim()] = t.slice(eq + 1).trim();
+    }
+    return out;
+}
+function writeEnvPairs(p, pairs) {
+    const keys = Object.keys(pairs).sort((a, b) => a.localeCompare(b));
+    const lines = keys.map((k) => `${k}=${pairs[k]}`);
+    node_fs_1.default.writeFileSync(p, `${lines.join('\n')}\n`, 'utf8');
+}
+function ensureRendercoreServiceFiles(bin, defaults) {
+    const envPath = rendercoreEnvPath();
+    const mapPath = rendercoreVideoMapPath();
+    const servicePath = rendercoreUserServicePath();
+    (0, fs_1.ensureDir)(node_path_1.default.dirname(envPath));
+    (0, fs_1.ensureDir)(node_path_1.default.dirname(servicePath));
+    if (!node_fs_1.default.existsSync(mapPath))
+        node_fs_1.default.writeFileSync(mapPath, '', 'utf8');
+    const envPairs = readEnvPairs(envPath);
+    envPairs.KRC_VIDEO_MAP_FILE = mapPath;
+    envPairs.KRC_VIDEO_FPS = String(defaults.video_fps);
+    envPairs.KRC_VIDEO_SPEED = String(defaults.video_speed);
+    envPairs.KRC_HWACCEL = defaults.hwaccel;
+    envPairs.KRC_QUALITY = defaults.quality;
+    envPairs.KRC_PAUSE_ON_STEAM_GAME = defaults.pause_on_steam_game ? 'true' : 'false';
+    envPairs.KRC_STEAM_POLL_MS = String(defaults.steam_poll_ms);
+    writeEnvPairs(envPath, envPairs);
+    const home = node_os_1.default.homedir();
+    const pathEnv = `${home}/.local/bin:${home}/.cargo/bin:/usr/local/bin:/usr/bin:/bin`;
+    const serviceBody = [
+        '[Unit]',
+        'Description=Kitsune RenderCore Live Wallpaper',
+        'After=graphical-session.target',
+        'Wants=graphical-session.target',
+        '',
+        '[Service]',
+        'Type=simple',
+        `Environment=PATH=${pathEnv}`,
+        `EnvironmentFile=-${envPath}`,
+        `ExecStart=${bin}`,
+        'Restart=on-failure',
+        'RestartSec=1',
+        '',
+        '[Install]',
+        'WantedBy=default.target',
+        ''
+    ].join('\n');
+    node_fs_1.default.writeFileSync(servicePath, serviceBody, 'utf8');
+    return { service_path: servicePath, env_path: envPath, map_path: mapPath };
+}
+function extractExecResult(err) {
+    const result = err?.result;
+    if (!result)
+        return null;
+    return {
+        stdout: String(result.stdout ?? ''),
+        stderr: String(result.stderr ?? ''),
+        code: Number(result.code ?? 1)
+    };
+}
+async function runSystemctlUser(args, acceptNonZero = false) {
+    try {
+        return await (0, exec_1.run)('systemctl', ['--user', ...args], { timeoutMs: 30000 });
+    }
+    catch (err) {
+        const partial = extractExecResult(err);
+        if (acceptNonZero && partial)
+            return partial;
+        throw err;
+    }
+}
 async function resolvePost(provider, pageUrl) {
     const html = await fetchHtml(pageUrl, pageUrl);
     const parsed = liveParsePostFromHtml(provider, pageUrl, html);
@@ -1655,8 +1807,16 @@ async function liveApply(opts) {
         integratedRendercoreStart(bin);
     }
     else {
-        await (0, exec_1.run)(bin, ['service', 'install'], { timeoutMs: 20000 });
-        await (0, exec_1.run)(bin, ['service', 'enable'], { timeoutMs: 20000 });
+        const deps = await ensureRendercoreHostRuntimeDeps();
+        if (deps.missing.length > 0) {
+            throw new Error(`Missing host dependencies: ${deps.missing.join(', ')}. ` +
+                'Install on host (Arch): sudo pacman -S --needed ffmpeg hyprland');
+        }
+        const binPath = await resolveHostExecutablePath(bin);
+        ensureRendercoreServiceFiles(binPath, index.apply_defaults);
+        await runSystemctlUser(['daemon-reload']);
+        await runSystemctlUser(['enable', 'kitsune-rendercore.service']);
+        await runSystemctlUser(['start', 'kitsune-rendercore.service']);
     }
     withLiveLock(() => {
         const current = readIndex();
@@ -1816,10 +1976,15 @@ async function liveDoctor(opts) {
     if (!deps.runner_bin) {
         fix.push(`Install ${runnerBin} and ensure it is available in PATH`);
     }
-    if (opts?.fix && deps.runner_bin) {
+    if (opts?.fix) {
         try {
-            await (0, exec_1.run)(runnerBin, ['install-deps'], { timeoutMs: 180000 });
-            fix.push(`Executed: ${runnerBin} install-deps`);
+            const ensured = await ensureRendercoreHostRuntimeDeps();
+            if (ensured.installed.length > 0) {
+                fix.push(`Installed host packages: ${ensured.installed.join(', ')}`);
+            }
+            if (ensured.missing.length > 0) {
+                fix.push(`Still missing host dependencies: ${ensured.missing.join(', ')}`);
+            }
             try {
                 await (0, exec_1.run)('ffmpeg', ['-version'], { timeoutMs: 4000 });
                 deps.ffmpeg = true;
@@ -1836,11 +2001,11 @@ async function liveDoctor(opts) {
             }
         }
         catch (e) {
-            fix.push(`Failed to execute '${index.runner.bin_name} install-deps': ${String(e)}`);
+            fix.push(`Failed to install host dependencies: ${String(e)}`);
         }
     }
     else if (!deps.ffmpeg || !deps.hyprctl) {
-        fix.push(`Run '${runnerBin} install-deps' to install missing runtime dependencies`);
+        fix.push('Run `kitowall live doctor --fix` to install missing runtime dependencies');
     }
     return {
         ok: Object.values(deps).every(Boolean) || (deps.hyprctl === false && Object.keys(deps).filter(k => k !== 'hyprctl').every(k => deps[k])),
@@ -1878,62 +2043,55 @@ async function liveServiceAutostart(action) {
         };
     }
     let out;
-    const extractResult = (err) => {
-        const result = err?.result;
-        if (!result)
-            return null;
-        return {
-            stdout: String(result.stdout ?? ''),
-            stderr: String(result.stderr ?? ''),
-            code: Number(result.code ?? 1)
-        };
-    };
-    try {
-        out = await (0, exec_1.run)(bin, ['service', action], { timeoutMs: 30000 });
-    }
-    catch (err) {
-        const partial = extractResult(err);
-        if (action === 'status' && partial) {
-            out = partial;
-            return {
-                ok: true,
-                action,
-                runner: bin,
-                stdout: out.stdout.trim(),
-                stderr: out.stderr.trim(),
-                code: out.code
-            };
-        }
-        // Legacy compatibility: if user still points to kitsune-livewallpaper,
-        // map to its older subcommand to avoid hard failure.
-        if (clean(bin) === 'kitsune-livewallpaper') {
-            try {
-                out = await (0, exec_1.run)(bin, ['service-autostart', action], { timeoutMs: 30000 });
-            }
-            catch (legacyErr) {
-                const legacyPartial = extractResult(legacyErr);
-                if (action === 'status' && legacyPartial) {
-                    out = legacyPartial;
-                    return {
-                        ok: true,
-                        action,
-                        runner: bin,
-                        stdout: out.stdout.trim(),
-                        stderr: out.stderr.trim(),
-                        code: out.code
-                    };
-                }
-                throw legacyErr;
-            }
+    if (action === 'install') {
+        const deps = await ensureRendercoreHostRuntimeDeps();
+        if (deps.missing.length > 0) {
+            const message = `Missing host dependencies: ${deps.missing.join(', ')}. ` +
+                'Install on host (Arch): sudo pacman -S --needed ffmpeg hyprland';
+            out = { stdout: '', stderr: message, code: 1 };
         }
         else {
-            throw err;
+            const binPath = await resolveHostExecutablePath(bin);
+            const installed = ensureRendercoreServiceFiles(binPath, index.apply_defaults);
+            await runSystemctlUser(['daemon-reload']);
+            out = {
+                stdout: `Installed user service at ${installed.service_path}`,
+                stderr: '',
+                code: 0
+            };
         }
     }
+    else if (action === 'status') {
+        out = await runSystemctlUser(['status', '--no-pager', 'kitsune-rendercore.service'], true);
+    }
+    else if (action === 'enable') {
+        const binPath = await resolveHostExecutablePath(bin);
+        ensureRendercoreServiceFiles(binPath, index.apply_defaults);
+        await runSystemctlUser(['daemon-reload']);
+        out = await runSystemctlUser(['enable', 'kitsune-rendercore.service']);
+    }
+    else if (action === 'disable') {
+        out = await runSystemctlUser(['disable', '--now', 'kitsune-rendercore.service'], true);
+    }
+    else if (action === 'start') {
+        const binPath = await resolveHostExecutablePath(bin);
+        ensureRendercoreServiceFiles(binPath, index.apply_defaults);
+        await runSystemctlUser(['daemon-reload']);
+        out = await runSystemctlUser(['start', 'kitsune-rendercore.service']);
+    }
+    else if (action === 'stop') {
+        out = await runSystemctlUser(['stop', 'kitsune-rendercore.service'], true);
+    }
+    else {
+        const binPath = await resolveHostExecutablePath(bin);
+        ensureRendercoreServiceFiles(binPath, index.apply_defaults);
+        await runSystemctlUser(['daemon-reload']);
+        out = await runSystemctlUser(['restart', 'kitsune-rendercore.service']);
+    }
     return {
         ok: true,
         action,
-        runner: bin,
+        runner: `${bin} (systemd-user)`,
         stdout: out.stdout.trim(),
         stderr: out.stderr.trim(),
         code: out.code

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kitowall",
-  "version": "3.5.16",
+  "version": "3.5.36",
   "description": "CLI/daemon for Hyprland wallpapers using swww with pack-based rotation.",
   "repository": {
     "type": "git",