kitowall 1.0.0

package/dist/core/logs.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLogsPath = getLogsPath;
+exports.redactUrl = redactUrl;
+exports.appendSystemLog = appendSystemLog;
+exports.listSystemLogs = listSystemLogs;
+exports.clearSystemLogs = clearSystemLogs;
+// Persistent system logs for requests/downloads and diagnostics.
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const fs_2 = require("../utils/fs");
+const LOG_DIR = path_1.default.join(os_1.default.homedir(), '.local', 'state', 'kitowall');
+const LOG_FILE = path_1.default.join(LOG_DIR, 'logs.jsonl');
+const MAX_LINES = 5000;
+function getLogsPath() {
+    return LOG_FILE;
+}
+function redactUrl(rawUrl) {
+    if (!rawUrl)
+        return rawUrl;
+    try {
+        const u = new URL(rawUrl);
+        const sensitive = new Set([
+            'api_key',
+            'apikey',
+            'key',
+            'token',
+            'access_token',
+            'client_id',
+            'client_secret',
+            'authorization'
+        ]);
+        for (const key of Array.from(u.searchParams.keys())) {
+            if (sensitive.has(key.toLowerCase())) {
+                u.searchParams.set(key, '***');
+            }
+        }
+        return u.toString();
+    }
+    catch {
+        return rawUrl;
+    }
+}
+function appendSystemLog(entry) {
+    try {
+        (0, fs_2.ensureDir)(LOG_DIR);
+        const row = {
+            ts: entry.ts ?? Date.now(),
+            level: entry.level,
+            source: entry.source,
+            pack: entry.pack,
+            action: entry.action,
+            message: entry.message,
+            url: redactUrl(entry.url),
+            status: entry.status,
+            meta: entry.meta
+        };
+        fs_1.default.appendFileSync(LOG_FILE, `${JSON.stringify(row)}\n`, 'utf8');
+        trimLogsIfNeeded();
+    }
+    catch {
+        // Logging must never break core features.
+    }
+}
+function listSystemLogs(opts) {
+    if (!fs_1.default.existsSync(LOG_FILE))
+        return [];
+    const raw = fs_1.default.readFileSync(LOG_FILE, 'utf8');
+    const rows = raw.split('\n').filter(Boolean);
+    const parsed = [];
+    for (const line of rows) {
+        try {
+            const item = JSON.parse(line);
+            parsed.push(item);
+        }
+        catch {
+            // ignore invalid lines
+        }
+    }
+    let out = parsed.sort((a, b) => b.ts - a.ts);
+    if (opts?.source)
+        out = out.filter(e => (e.source ?? '') === opts.source);
+    if (opts?.pack)
+        out = out.filter(e => (e.pack ?? '') === opts.pack);
+    if (opts?.level)
+        out = out.filter(e => e.level === opts.level);
+    if (opts?.q) {
+        const q = opts.q.toLowerCase();
+        out = out.filter(e => {
+            const blob = [
+                e.source ?? '',
+                e.pack ?? '',
+                e.action ?? '',
+                e.message ?? '',
+                e.url ?? '',
+                JSON.stringify(e.meta ?? {})
+            ].join(' ').toLowerCase();
+            return blob.includes(q);
+        });
+    }
+    const limit = Math.max(1, Math.floor(opts?.limit ?? 200));
+    return out.slice(0, limit);
+}
+function clearSystemLogs() {
+    try {
+        if (!fs_1.default.existsSync(LOG_FILE))
+            return { ok: true, removed: 0 };
+        const raw = fs_1.default.readFileSync(LOG_FILE, 'utf8');
+        const removed = raw.split('\n').filter(Boolean).length;
+        fs_1.default.unlinkSync(LOG_FILE);
+        return { ok: true, removed };
+    }
+    catch {
+        return { ok: true, removed: 0 };
+    }
+}
+function trimLogsIfNeeded() {
+    try {
+        if (!fs_1.default.existsSync(LOG_FILE))
+            return;
+        const raw = fs_1.default.readFileSync(LOG_FILE, 'utf8');
+        const rows = raw.split('\n').filter(Boolean);
+        if (rows.length <= MAX_LINES)
+            return;
+        const keep = rows.slice(rows.length - MAX_LINES);
+        fs_1.default.writeFileSync(LOG_FILE, `${keep.join('\n')}\n`, 'utf8');
+    }
+    catch {
+        // best effort
+    }
+}

package/dist/core/outputs.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectOutputs = detectOutputs;
+// Output detection via hyprctl or swww.
+const exec_1 = require("../utils/exec");
+async function outputsFromHyprctl() {
+    const result = await (0, exec_1.run)('hyprctl', ['monitors', '-j']);
+    const parsed = JSON.parse(result.stdout);
+    return parsed.map(m => ({ name: m.name }));
+}
+async function outputsFromSwwwQuery() {
+    const result = await (0, exec_1.run)('swww', ['query']);
+    const lines = result.stdout.split('\n').map(l => l.trim()).filter(Boolean);
+    const outputs = [];
+    for (const line of lines) {
+        const idx = line.indexOf(':');
+        if (idx > 0)
+            outputs.push({ name: line.slice(0, idx).trim() });
+    }
+    return outputs;
+}
+async function detectOutputs() {
+    try {
+        const outputs = await outputsFromHyprctl();
+        if (outputs.length > 0)
+            return outputs;
+    }
+    catch {
+        // ignore and fallback
+    }
+    try {
+        const outputs = await outputsFromSwwwQuery();
+        if (outputs.length > 0)
+            return outputs;
+    }
+    catch {
+        // ignore
+    }
+    return [];
+}

package/dist/core/remotePack.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/scheduler.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scheduler = void 0;
+class Scheduler {
+    constructor(options) {
+        this.timer = null;
+        this.intervalMs = Math.max(options.intervalSeconds, 1) * 1000;
+        this.onTick = options.onTick;
+    }
+    start() {
+        if (this.timer)
+            return;
+        this.timer = setInterval(() => {
+            void this.onTick();
+        }, this.intervalMs);
+    }
+    stop() {
+        if (!this.timer)
+            return;
+        clearInterval(this.timer);
+        this.timer = null;
+    }
+}
+exports.Scheduler = Scheduler;

package/dist/core/state.js

@@ -0,0 +1,181 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STATE_SCHEMA_VERSION = void 0;
+exports.setMode = setMode;
+exports.cleanupDisconnectedOutputs = cleanupDisconnectedOutputs;
+exports.commitSelection = commitSelection;
+exports.getStatePath = getStatePath;
+exports.defaultState = defaultState;
+exports.loadState = loadState;
+exports.saveState = saveState;
+// Runtime state persistence.
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const fs_2 = require("../utils/fs");
+exports.STATE_SCHEMA_VERSION = 1;
+function setMode(state, mode) {
+    state.mode = mode;
+    state.last_updated = Date.now();
+}
+function deepEqual(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+}
+const RECENT_LIMIT = 10;
+// Cola LRU simple: dedupe + push + cap
+function pushRecent(queue, value, limit = RECENT_LIMIT) {
+    const next = (queue ?? []).filter(v => v !== value);
+    next.push(value);
+    return next.slice(Math.max(0, next.length - limit));
+}
+// Anti-growth hard: recorta TODO a RECENT_LIMIT siempre
+function trimRecentState(state, limit = RECENT_LIMIT) {
+    // Global
+    if (!Array.isArray(state.recent_global))
+        state.recent_global = [];
+    state.recent_global = state.recent_global.slice(-limit);
+    // Por output
+    if (typeof state.recent_by_output !== 'object' || state.recent_by_output === null) {
+        state.recent_by_output = {};
+    }
+    for (const out of Object.keys(state.recent_by_output)) {
+        const q = state.recent_by_output[out];
+        if (!Array.isArray(q)) {
+            state.recent_by_output[out] = [];
+        }
+        else {
+            state.recent_by_output[out] = q.slice(-limit);
+        }
+    }
+}
+/**
+ * Borra state de outputs que ya no existen (hotplug cleanup).
+ * Llamar en cada tick con la lista de outputs actuales.
+ */
+function cleanupDisconnectedOutputs(state, currentOutputs) {
+    const alive = new Set(currentOutputs);
+    // last_set
+    if (!state.last_set)
+        state.last_set = {};
+    for (const out of Object.keys(state.last_set)) {
+        if (!alive.has(out))
+            delete state.last_set[out];
+    }
+    // recent_by_output
+    if (!state.recent_by_output)
+        state.recent_by_output = {};
+    for (const out of Object.keys(state.recent_by_output)) {
+        if (!alive.has(out))
+            delete state.recent_by_output[out];
+    }
+    state.last_outputs = [...currentOutputs];
+    // seguridad extra
+    trimRecentState(state);
+}
+/**
+ * Registra lo que se aplicó para un output y actualiza colas recientes.
+ * Llamar DESPUÉS de aplicar con swww.
+ */
+function commitSelection(state, output, pathStr, now = Date.now()) {
+    if (!state.last_set)
+        state.last_set = {};
+    if (!state.recent_by_output)
+        state.recent_by_output = {};
+    if (!state.recent_global)
+        state.recent_global = [];
+    state.last_set[output] = pathStr;
+    state.recent_by_output[output] = pushRecent(state.recent_by_output[output] ?? [], pathStr);
+    state.recent_global = pushRecent(state.recent_global ?? [], pathStr);
+    state.last_updated = now;
+    // anti-growth hard
+    trimRecentState(state);
+}
+function getStatePath() {
+    return path_1.default.join(os_1.default.homedir(), '.local', 'state', 'kitowall', 'state.json');
+}
+function ensureStateDir() {
+    const dir = path_1.default.dirname(getStatePath());
+    if (!fs_1.default.existsSync(dir))
+        fs_1.default.mkdirSync(dir, { recursive: true });
+}
+function defaultState() {
+    return {
+        schemaVersion: exports.STATE_SCHEMA_VERSION,
+        mode: 'manual',
+        current_pack: null,
+        last_outputs: [],
+        last_set: {},
+        last_updated: 0,
+        recent_by_output: {},
+        recent_global: []
+    };
+}
+function loadState() {
+    const statePath = getStatePath();
+    const fallback = defaultState();
+    const stateFileExists = fs_1.default.existsSync(statePath);
+    const state = (0, fs_2.readJson)(statePath, fallback);
+    if (!stateFileExists || !state || Object.keys(state).length === 0) {
+        ensureStateDir();
+        (0, fs_2.writeJson)(statePath, fallback);
+        return fallback;
+    }
+    // Snapshot antes de migraciones para decidir si guardar o no
+    const originalState = JSON.parse(JSON.stringify(state));
+    // Freeze schema contract: only migrate missing/invalid to current version.
+    if (typeof state.schemaVersion !== 'number' || !Number.isFinite(state.schemaVersion)) {
+        state.schemaVersion = exports.STATE_SCHEMA_VERSION;
+    }
+    else if (state.schemaVersion > exports.STATE_SCHEMA_VERSION) {
+        throw new Error(`Unsupported state schemaVersion ${state.schemaVersion}. This build supports up to ${exports.STATE_SCHEMA_VERSION}.`);
+    }
+    else if (state.schemaVersion < exports.STATE_SCHEMA_VERSION) {
+        state.schemaVersion = exports.STATE_SCHEMA_VERSION;
+    }
+    // Migraciones / defaults
+    if (state.mode !== 'manual' && state.mode !== 'rotate')
+        state.mode = 'manual';
+    if (typeof state.current_pack === 'undefined')
+        state.current_pack = null;
+    if (!state.last_outputs)
+        state.last_outputs = [];
+    if (!state.last_set)
+        state.last_set = {};
+    if (typeof state.last_updated !== 'number')
+        state.last_updated = 0;
+    if (!state.recent_by_output)
+        state.recent_by_output = {};
+    if (!state.recent_global)
+        state.recent_global = [];
+    // Normalización básica (por si vienen corruptos)
+    if (!Array.isArray(state.recent_global))
+        state.recent_global = [];
+    if (typeof state.recent_by_output !== 'object' || state.recent_by_output === null) {
+        state.recent_by_output = {};
+    }
+    // Anti-growth hard (Fase 2B): recorta colas a 10 siempre
+    trimRecentState(state);
+    // Persistir solo si hubo cambios por migración
+    if (!deepEqual(state, originalState)) {
+        ensureStateDir();
+        (0, fs_2.writeJson)(statePath, state);
+    }
+    return state;
+}
+function saveState(state) {
+    if (typeof state.schemaVersion !== 'number' || !Number.isFinite(state.schemaVersion)) {
+        state.schemaVersion = exports.STATE_SCHEMA_VERSION;
+    }
+    if (state.schemaVersion !== exports.STATE_SCHEMA_VERSION) {
+        throw new Error(`Invalid state schemaVersion ${state.schemaVersion}. Expected ${exports.STATE_SCHEMA_VERSION}.`);
+    }
+    ensureStateDir();
+    const statePath = getStatePath();
+    const existing = fs_1.default.existsSync(statePath) ? (0, fs_2.readJson)(statePath, defaultState()) : null;
+    if (existing && deepEqual(existing, state))
+        return;
+    (0, fs_2.writeJson)(statePath, state);
+}

package/dist/core/systemd.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installSystemd = installSystemd;
+exports.uninstallSystemd = uninstallSystemd;
+exports.systemdStatus = systemdStatus;
+// src/core/systemd.ts
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const exec_1 = require("../utils/exec");
+function ensureDir(path) {
+    (0, node_fs_1.mkdirSync)(path, { recursive: true });
+}
+function systemdInterval(every) {
+    // Acepta: 30s / 10m / 1h / 1d  -> systemd: 30s / 10min / 1h / 1day
+    const m = every.trim().match(/^(\d+)\s*([smhd])$/i);
+    if (!m)
+        throw new Error(`Invalid --every value: ${every} (use like 30s, 10m, 1h)`);
+    const n = Number(m[1]);
+    const u = m[2].toLowerCase();
+    if (!Number.isFinite(n) || n <= 0)
+        throw new Error(`Invalid --every value: ${every}`);
+    if (u === 's')
+        return `${n}s`;
+    if (u === 'm')
+        return `${n}min`;
+    if (u === 'h')
+        return `${n}h`;
+    return `${n}day`;
+}
+/**
+ * installSystemd: instala/actualiza SOLO el TIMER.
+ * Para compatibilidad, acepta pack/namespace pero no los usa.
+ */
+async function installSystemd(opts) {
+    const userDir = (0, node_path_1.join)((0, node_os_1.homedir)(), '.config', 'systemd', 'user');
+    ensureDir(userDir);
+    const every = systemdInterval(opts.every);
+    const kitowallTimer = `
+        [Unit]
+        Description=Run kitowall-next periodically
+        
+        [Timer]
+        OnBootSec=2s
+        OnStartupSec=2s
+        AccuracySec=1s
+        RandomizedDelaySec=0
+        OnUnitActiveSec=${every}
+        Unit=kitowall-next.service
+        Persistent=true
+        
+        [Install]
+        WantedBy=timers.target
+    `.trimStart();
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(userDir, 'kitowall-next.timer'), kitowallTimer, 'utf8');
+    await (0, exec_1.run)('systemctl', ['--user', 'daemon-reload']);
+    await (0, exec_1.run)('systemctl', ['--user', 'enable', '--now', 'kitowall-next.timer']);
+}
+async function uninstallSystemd() {
+    await (0, exec_1.run)('systemctl', ['--user', 'disable', '--now', 'kitowall-next.timer']).catch(() => { });
+    await (0, exec_1.run)('systemctl', ['--user', 'daemon-reload']).catch(() => { });
+}
+async function systemdStatus() {
+    await (0, exec_1.run)('systemctl', ['--user', 'status', 'kitowall-next.timer']);
+}

package/dist/core/watch.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watchMonitors = watchMonitors;
+// src/core/watch.ts
+const node_net_1 = __importDefault(require("node:net"));
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const config_1 = require("./config");
+const state_1 = require("./state");
+const controller_1 = require("./controller");
+function sleep(ms) {
+    return new Promise(r => setTimeout(r, ms));
+}
+function getSocket2Path() {
+    const xdg = process.env.XDG_RUNTIME_DIR || `/run/user/${process.getuid?.() ?? 1000}`;
+    const sig = process.env.HYPRLAND_INSTANCE_SIGNATURE;
+    if (sig) {
+        const p = (0, node_path_1.join)(xdg, 'hypr', sig, '.socket2.sock');
+        if ((0, node_fs_1.existsSync)(p))
+            return p;
+    }
+    // Fallback: buscar cualquier socket2 (por si el env no está)
+    const base = (0, node_path_1.join)(xdg, 'hypr');
+    if (!(0, node_fs_1.existsSync)(base))
+        throw new Error('Hyprland runtime dir not found');
+    const dirs = (0, node_fs_1.readdirSync)(base, { withFileTypes: true })
+        .filter(d => d.isDirectory())
+        .map(d => (0, node_path_1.join)(base, d.name, '.socket2.sock'))
+        .filter(p => (0, node_fs_1.existsSync)(p));
+    if (dirs.length === 0)
+        throw new Error('Hyprland socket2 not found');
+    return dirs[0];
+}
+function isMonitorEvent(line) {
+    const s = line.toLowerCase();
+    // Hyprland events: monitoradded/monitorremoved, etc.
+    return s.includes('monitoradded') || s.includes('monitorremoved') || s.includes('monitor') && s.includes('added') || s.includes('removed');
+}
+async function watchMonitors(opts) {
+    const config = (0, config_1.loadConfig)();
+    const state = (0, state_1.loadState)();
+    const controller = new controller_1.Controller(config, state);
+    const sockPath = getSocket2Path();
+    const debounceMs = Math.max(100, opts.debounceMs ?? 800);
+    let buf = '';
+    let timer = null;
+    async function trigger() {
+        // pequeño delay para que Hyprland termine de registrar el monitor
+        await sleep(200);
+        await controller.applyNext(undefined);
+    }
+    const client = node_net_1.default.createConnection(sockPath);
+    client.on('data', (data) => {
+        buf += data.toString('utf8');
+        let idx;
+        while ((idx = buf.indexOf('\n')) >= 0) {
+            const line = buf.slice(0, idx).trim();
+            buf = buf.slice(idx + 1);
+            if (!line)
+                continue;
+            if (!isMonitorEvent(line))
+                continue;
+            if (timer)
+                clearTimeout(timer);
+            timer = setTimeout(() => {
+                trigger().catch(() => { });
+            }, debounceMs);
+        }
+    });
+    client.on('error', (err) => {
+        throw err;
+    });
+    // Mantener vivo
+    await new Promise(() => { });
+}

package/dist/managers/swww.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applySwww = applySwww;
+// swww backend for per-output wallpaper application.
+const exec_1 = require("../utils/exec");
+const node_child_process_1 = require("node:child_process");
+function startSwwwDaemon(namespace) {
+    const args = [];
+    if (namespace)
+        args.push('--namespace', namespace);
+    const inFlatpak = Boolean(process.env.FLATPAK_ID);
+    const cmd = inFlatpak ? 'flatpak-spawn' : 'swww-daemon';
+    const spawnArgs = inFlatpak ? ['--host', 'swww-daemon', ...args] : args;
+    const child = (0, node_child_process_1.spawn)(cmd, spawnArgs, {
+        stdio: 'ignore',
+        detached: true
+    });
+    // Avoid crashing caller on missing binary or spawn failures.
+    child.on('error', () => { });
+    child.unref();
+}
+async function ensureSwwwRunning(namespace) {
+    const q = namespace ? ['query', '--namespace', namespace] : ['query'];
+    try {
+        await (0, exec_1.run)('swww', q);
+        return;
+    }
+    catch { }
+    startSwwwDaemon(namespace);
+    // reintenta unas veces
+    for (let i = 0; i < 10; i++) {
+        try {
+            await (0, exec_1.run)('swww', q);
+            return;
+        }
+        catch { }
+        await new Promise(r => setTimeout(r, 150));
+    }
+    throw new Error('No se pudo iniciar swww-daemon.');
+}
+async function applySwww(images, transition, namespace = 'kitowall') {
+    await ensureSwwwRunning(namespace);
+    for (const item of images) {
+        const args = [
+            'img',
+            '--namespace', namespace,
+            '-o',
+            item.output,
+            item.path,
+            '--transition-type',
+            transition.type,
+            '--transition-fps',
+            String(transition.fps),
+            '--transition-duration',
+            String(transition.duration)
+        ];
+        if (transition.angle !== undefined) {
+            args.push('--transition-angle', String(transition.angle));
+        }
+        if (transition.pos) {
+            args.push('--transition-pos', transition.pos);
+        }
+        await (0, exec_1.run)('swww', args);
+    }
+}

package/dist/utils/exec.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+// Shell execution wrapper.
+const child_process_1 = require("child_process");
+function run(cmd, args = [], options = {}) {
+    return new Promise((resolve, reject) => {
+        const isFlatpak = Boolean(process.env.FLATPAK_ID);
+        const hostCommands = new Set(['swww', 'swww-daemon', 'hyprctl', 'systemctl', 'which', 'xdg-open']);
+        const useHost = isFlatpak && hostCommands.has(cmd);
+        const finalCmd = useHost ? 'flatpak-spawn' : cmd;
+        const finalArgs = useHost ? ['--host', cmd, ...args] : args;
+        const child = (0, child_process_1.spawn)(finalCmd, finalArgs, {
+            cwd: options.cwd,
+            env: options.env,
+            stdio: ['ignore', 'pipe', 'pipe']
+        });
+        let stdout = '';
+        let stderr = '';
+        const timeout = options.timeoutMs
+            ? setTimeout(() => {
+                child.kill('SIGKILL');
+                reject(new Error(`Command timed out: ${finalCmd}`));
+            }, options.timeoutMs)
+            : null;
+        child.stdout.on('data', (d) => (stdout += String(d)));
+        child.stderr.on('data', (d) => (stderr += String(d)));
+        child.on('error', (err) => {
+            if (timeout)
+                clearTimeout(timeout);
+            reject(err);
+        });
+        child.on('close', (code) => {
+            if (timeout)
+                clearTimeout(timeout);
+            const result = { stdout, stderr, code: code ?? 0 };
+            if (code && code !== 0) {
+                const err = new Error(`Command failed: ${finalCmd} ${finalArgs.join(' ')}\n` +
+                    `exit=${code}\nstdout=${stdout.trim()}\nstderr=${stderr.trim()}`);
+                err.result = result;
+                reject(err);
+                return;
+            }
+            resolve(result);
+        });
+    });
+}