kitowall 1.0.0

package/dist/utils/fs.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expandTilde = expandTilde;
+exports.ensureDir = ensureDir;
+exports.readJson = readJson;
+exports.writeJson = writeJson;
+exports.listImagesRecursive = listImagesRecursive;
+exports.shuffle = shuffle;
+// Filesystem helpers.
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const IMAGE_EXTENSIONS = new Set([
+    '.jpg', '.jpeg', '.png', '.webp', '.bmp', '.gif'
+]);
+function expandTilde(inputPath) {
+    if (inputPath.startsWith('~/'))
+        return path_1.default.join(os_1.default.homedir(), inputPath.slice(2));
+    if (inputPath === '~')
+        return os_1.default.homedir();
+    return inputPath;
+}
+function ensureDir(dirPath) {
+    fs_1.default.mkdirSync(dirPath, { recursive: true });
+}
+function readJson(filePath, fallback) {
+    if (!fs_1.default.existsSync(filePath))
+        return fallback;
+    const raw = fs_1.default.readFileSync(filePath, 'utf8');
+    return JSON.parse(raw);
+}
+function writeJson(filePath, data) {
+    ensureDir(path_1.default.dirname(filePath));
+    fs_1.default.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf8');
+}
+function listImagesRecursive(pathsToScan) {
+    const results = [];
+    const walk = (currentPath) => {
+        if (!fs_1.default.existsSync(currentPath))
+            return;
+        const stat = fs_1.default.statSync(currentPath);
+        if (stat.isFile()) {
+            const ext = path_1.default.extname(currentPath).toLowerCase();
+            if (IMAGE_EXTENSIONS.has(ext))
+                results.push(currentPath);
+            return;
+        }
+        if (!stat.isDirectory())
+            return;
+        const entries = fs_1.default.readdirSync(currentPath);
+        for (const entry of entries) {
+            const full = path_1.default.join(currentPath, entry);
+            walk(full);
+        }
+    };
+    for (const p of pathsToScan)
+        walk(expandTilde(p));
+    return results;
+}
+function shuffle(arr) {
+    const copy = [...arr];
+    for (let i = copy.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [copy[i], copy[j]] = [copy[j], copy[i]];
+    }
+    return copy;
+}

package/dist/utils/hash.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sha256Hex = sha256Hex;
+// Hash helpers.
+const crypto_1 = __importDefault(require("crypto"));
+function sha256Hex(input) {
+    return crypto_1.default.createHash('sha256').update(input).digest('hex');
+}

package/dist/utils/jsonPath.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTarget = getTarget;
+exports.replaceRandomInPath = replaceRandomInPath;
+// Minimal JSONPath helper with @random support.
+const crypto_1 = require("crypto");
+function getTarget(inputObject, inputString) {
+    if (!inputObject)
+        return [null, ''];
+    if (inputString.length === 0)
+        return [inputObject, inputString];
+    let startDot = inputString.indexOf('.');
+    if (startDot === -1)
+        startDot = inputString.length;
+    let keyString = inputString.slice(0, startDot);
+    const inputStringTail = inputString.slice(startDot + 1);
+    const startParentheses = keyString.indexOf('[');
+    if (startParentheses === -1) {
+        const targetObject = getObjectMember(inputObject, keyString);
+        if (!targetObject)
+            return [null, ''];
+        const [object, path] = getTarget(targetObject, inputStringTail);
+        return [object, inputString.slice(0, inputString.length - inputStringTail.length) + path];
+    }
+    else {
+        const indexString = keyString.slice(startParentheses + 1, keyString.length - 1);
+        keyString = keyString.slice(0, startParentheses);
+        const targetObject = getObjectMember(inputObject, keyString);
+        if (!targetObject || !Array.isArray(targetObject))
+            return [null, ''];
+        switch (indexString) {
+            case '@random': {
+                const [chosenElement, chosenNumber] = randomElement(targetObject);
+                const [object, path] = getTarget(chosenElement, inputStringTail);
+                return [object, inputString
+                        .slice(0, inputString.length - inputStringTail.length)
+                        .replace('@random', String(chosenNumber)) + path];
+            }
+            default: {
+                const [object, path] = getTarget(targetObject[parseInt(indexString)], inputStringTail);
+                return [object, inputString.slice(0, inputString.length - inputStringTail.length) + path];
+            }
+        }
+    }
+}
+function replaceRandomInPath(randomPath, resolvedPath) {
+    if (!randomPath.includes('@random'))
+        return randomPath;
+    let newPath = randomPath;
+    while (newPath.includes('@random')) {
+        const startRandom = newPath.indexOf('@random');
+        if (newPath.substring(0, startRandom) !== resolvedPath.substring(0, startRandom))
+            break;
+        const endParenthesis = resolvedPath.indexOf(']', startRandom);
+        newPath = newPath.replace('@random', resolvedPath.substring(startRandom, endParenthesis));
+    }
+    return newPath;
+}
+function getObjectMember(inputObject, keyString) {
+    if (keyString === '$')
+        return inputObject;
+    for (const [key, value] of Object.entries(inputObject)) {
+        if (key === keyString)
+            return value;
+    }
+    return null;
+}
+function randomElement(array) {
+    const randomNumber = (0, crypto_1.randomInt)(array.length);
+    return [array[randomNumber], randomNumber];
+}

package/dist/utils/net.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkError = void 0;
+exports.fetchWithRetry = fetchWithRetry;
+class NetworkError extends Error {
+    constructor(message, opts) {
+        super(message);
+        this.name = 'NetworkError';
+        this.url = opts.url;
+        this.status = opts.status;
+        this.code = opts.code;
+        this.attempt = opts.attempt;
+    }
+}
+exports.NetworkError = NetworkError;
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+function shouldRetryStatus(status, retryOnStatus) {
+    return retryOnStatus.includes(status);
+}
+async function fetchWithRetry(url, init, opts) {
+    const timeoutMs = opts?.timeoutMs ?? 15000;
+    const retries = opts?.retries ?? 2;
+    const backoffMs = opts?.backoffMs ?? 300;
+    const retryOnStatus = opts?.retryOnStatus ?? [429, 500, 502, 503, 504];
+    let lastError = null;
+    for (let attempt = 1; attempt <= retries + 1; attempt++) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const response = await fetch(url, { ...init, signal: controller.signal });
+            if (response.ok)
+                return response;
+            if (attempt <= retries && shouldRetryStatus(response.status, retryOnStatus)) {
+                await sleep(backoffMs * attempt);
+                continue;
+            }
+            const rate = response.headers.get('x-ratelimit-remaining');
+            const reset = response.headers.get('x-ratelimit-reset');
+            const rateHint = rate !== null || reset !== null
+                ? ` (rate=${rate ?? 'n/a'}, reset=${reset ?? 'n/a'})`
+                : '';
+            throw new NetworkError(`HTTP ${response.status}${rateHint}`, {
+                url,
+                status: response.status,
+                attempt
+            });
+        }
+        catch (err) {
+            const e = err;
+            const cause = e?.cause;
+            const code = cause?.code;
+            const msgParts = [e?.message ?? String(err)];
+            if (code)
+                msgParts.push(`code=${code}`);
+            if (cause?.message)
+                msgParts.push(`cause=${cause.message}`);
+            lastError = new NetworkError(msgParts.join(' | '), { url, code, attempt });
+            if (attempt <= retries) {
+                await sleep(backoffMs * attempt);
+                continue;
+            }
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    throw lastError ?? new NetworkError('fetch failed', { url, attempt: retries + 1 });
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "kitowall",
+  "version": "1.0.0",
+  "description": "CLI/daemon for Hyprland wallpapers using swww with pack-based rotation.",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "type": "commonjs",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE.md",
+    "NOTICE.md",
+    "TRADEMARKS.md"
+  ],
+  "bin": {
+    "kitowall": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/cli.js",
+    "dev": "tsc --watch",
+    "lint": "node dist/cli.js --help",
+    "release:check": "npm run build && npm run test:e2e",
+    "package:cli": "npm pack",
+    "package:ui": "npm --prefix ui run tauri:build",
+    "package:all": "npm run release:check && npm run package:cli && npm run package:ui",
+    "test:smoke": "bash ./tests/smoke.e2e.sh",
+    "test:regression": "bash ./tests/regression.e2e.sh",
+    "test:e2e": "npm run test:smoke && npm run test:regression"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "typescript": "^5.4.0"
+  }
+}