beauticode-dsh 1.0.0

package/vendor/core/media-validation.js

@@ -0,0 +1,244 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { IMAGE_EXTENSIONS, MAX_IMAGE_BYTES, MAX_VIDEO_BYTES, VIDEO_EXTENSION, } from "./constants.js";
+const JPEG_MAGIC = Buffer.from([0xff, 0xd8, 0xff]);
+const PNG_MAGIC = Buffer.from([
+    0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
+]);
+// WEBP: RIFF....WEBP
+function isWebp(buf) {
+    return (buf.length >= 12 &&
+        buf.subarray(0, 4).toString("ascii") === "RIFF" &&
+        buf.subarray(8, 12).toString("ascii") === "WEBP");
+}
+/** AVIF is an ISO-BMFF image. Some downloaders save it with a .png suffix. */
+export function isAvifContainer(bytes, totalSize = bytes?.byteLength ?? 0) {
+    if (!(bytes instanceof Uint8Array) || bytes.length < 16)
+        return false;
+    const view = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const firstBoxSize = view.readUInt32BE(0);
+    if (firstBoxSize < 16 ||
+        firstBoxSize > totalSize ||
+        view.subarray(4, 8).toString("ascii") !== "ftyp") {
+        return false;
+    }
+    const brands = [view.subarray(8, 12)];
+    for (let offset = 16; offset + 4 <= Math.min(firstBoxSize, view.length); offset += 4) {
+        brands.push(view.subarray(offset, offset + 4));
+    }
+    return brands.some((brand) => brand.toString("ascii") === "avif" || brand.toString("ascii") === "avis");
+}
+export class MediaValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "MediaValidationError";
+    }
+}
+async function assertNoSymbolicLinkSegments(filePath) {
+    const root = path.parse(filePath).root;
+    const relative = path.relative(root, filePath);
+    let current = root;
+    for (const segment of relative.split(path.sep)) {
+        if (!segment)
+            continue;
+        current = path.join(current, segment);
+        const segmentStat = await fs.lstat(current);
+        if (segmentStat.isSymbolicLink()) {
+            throw new MediaValidationError("Media path must not traverse a symbolic link or reparse point.");
+        }
+    }
+}
+export function isMp4Container(bytes, totalSize = bytes?.byteLength ?? 0) {
+    if (!(bytes instanceof Uint8Array) || bytes.length < 16)
+        return false;
+    const view = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const firstBoxSize = view.readUInt32BE(0);
+    return (firstBoxSize >= 16 &&
+        firstBoxSize <= totalSize &&
+        view.subarray(4, 8).toString("ascii") === "ftyp");
+}
+async function assertRegularFile(filePath) {
+    const resolvedInput = path.resolve(filePath);
+    let lstat;
+    try {
+        lstat = await fs.lstat(resolvedInput);
+    }
+    catch {
+        throw new MediaValidationError(`Media file not found: ${resolvedInput}`);
+    }
+    if (lstat.isSymbolicLink()) {
+        throw new MediaValidationError("Media file must not be a symbolic link.");
+    }
+    // On Windows, reject reparse points that are not ordinary files.
+    // lstat.isSymbolicLink covers symlinks; directory junctions won't be files.
+    const realPath = await fs.realpath(resolvedInput);
+    const normalizeForCompare = (value) => {
+        const resolved = path.resolve(value);
+        return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+    };
+    if (normalizeForCompare(realPath) !== normalizeForCompare(resolvedInput)) {
+        // realpath can also expand a harmless Windows 8.3 path alias. Inspect each
+        // segment so only an actual symlink or junction is rejected.
+        await assertNoSymbolicLinkSegments(resolvedInput);
+    }
+    const stat = await fs.stat(realPath);
+    if (!stat.isFile()) {
+        throw new MediaValidationError("Media path must be a regular file.");
+    }
+    return { resolved: realPath, size: stat.size };
+}
+async function inspectAndHash(filePath, expectedSize) {
+    const handle = await fs.open(filePath, "r");
+    try {
+        const before = await handle.stat();
+        if (!before.isFile() || before.size !== expectedSize) {
+            throw new MediaValidationError("Media file changed during validation.");
+        }
+        const head = Buffer.alloc(Math.min(64, expectedSize));
+        const hash = createHash("sha256");
+        const chunk = Buffer.allocUnsafe(1024 * 1024);
+        let position = 0;
+        let headOffset = 0;
+        while (position < expectedSize) {
+            const length = Math.min(chunk.byteLength, expectedSize - position);
+            const { bytesRead } = await handle.read(chunk, 0, length, position);
+            if (bytesRead <= 0) {
+                throw new MediaValidationError("Media file ended during validation.");
+            }
+            const bytes = chunk.subarray(0, bytesRead);
+            hash.update(bytes);
+            if (headOffset < head.byteLength) {
+                const take = Math.min(bytesRead, head.byteLength - headOffset);
+                bytes.copy(head, headOffset, 0, take);
+                headOffset += take;
+            }
+            position += bytesRead;
+        }
+        const after = await handle.stat();
+        if (after.size !== before.size ||
+            after.mtimeMs !== before.mtimeMs ||
+            after.ctimeMs !== before.ctimeMs) {
+            throw new MediaValidationError("Media file changed during validation.");
+        }
+        return {
+            head,
+            identity: hash.digest("hex"),
+            device: after.dev,
+            inode: after.ino,
+            mtimeMs: after.mtimeMs,
+            ctimeMs: after.ctimeMs,
+        };
+    }
+    finally {
+        await handle.close();
+    }
+}
+export function detectImageMime(buf, extension, totalSize = buf.byteLength) {
+    if (buf.length >= 3 && buf.subarray(0, 3).equals(JPEG_MAGIC)) {
+        if (extension === ".jpg" || extension === ".jpeg") {
+            return { mime: "image/jpeg" };
+        }
+        // Allow jpeg magic even if extension is jpeg family only
+        return null;
+    }
+    if (buf.length >= 8 && buf.subarray(0, 8).equals(PNG_MAGIC)) {
+        if (extension === ".png")
+            return { mime: "image/png" };
+        return null;
+    }
+    if (isWebp(buf)) {
+        if (extension === ".webp")
+            return { mime: "image/webp" };
+        return null;
+    }
+    // Keep compatibility with files such as the supplied "*.png" whose
+    // contents are AVIF. Do not make unrelated JPEG/PNG/WebP mismatches valid.
+    if (isAvifContainer(buf, totalSize)) {
+        if (extension === ".avif" || extension === ".png") {
+            return { mime: "image/avif" };
+        }
+        return null;
+    }
+    return null;
+}
+export async function validateImageFile(filePath, opts = {}) {
+    const maxBytes = opts.maxBytes ?? MAX_IMAGE_BYTES;
+    const ext = path.extname(filePath).toLowerCase();
+    if (!IMAGE_EXTENSIONS.includes(ext)) {
+        throw new MediaValidationError(`Image must use one of: ${IMAGE_EXTENSIONS.join(", ")}`);
+    }
+    const { resolved, size } = await assertRegularFile(filePath);
+    if (size < 1 || size > maxBytes) {
+        throw new MediaValidationError(`Image must be a non-empty file no larger than ${maxBytes} bytes.`);
+    }
+    const inspected = await inspectAndHash(resolved, size);
+    const detected = detectImageMime(inspected.head, ext, size);
+    if (!detected) {
+        throw new MediaValidationError("Image content does not match a supported JPEG/PNG/WEBP/AVIF signature.");
+    }
+    return {
+        kind: "image",
+        filePath: resolved,
+        size,
+        extension: ext,
+        mime: detected.mime,
+        identity: inspected.identity,
+        device: inspected.device,
+        inode: inspected.inode,
+        mtimeMs: inspected.mtimeMs,
+        ctimeMs: inspected.ctimeMs,
+    };
+}
+export async function validateVideoFile(filePath, opts = {}) {
+    const maxBytes = opts.maxBytes ?? MAX_VIDEO_BYTES;
+    const ext = path.extname(filePath).toLowerCase();
+    if (ext !== VIDEO_EXTENSION) {
+        throw new MediaValidationError("Video backgrounds must use an MP4 file.");
+    }
+    const { resolved, size } = await assertRegularFile(filePath);
+    if (size < 1 || size > maxBytes) {
+        throw new MediaValidationError(`Video background must be a non-empty MP4 no larger than ${maxBytes} bytes.`);
+    }
+    const inspected = await inspectAndHash(resolved, size);
+    if (!isMp4Container(inspected.head, size)) {
+        throw new MediaValidationError("Video background is not a valid MP4 container.");
+    }
+    return {
+        kind: "video",
+        filePath: resolved,
+        size,
+        identity: inspected.identity,
+        device: inspected.device,
+        inode: inspected.inode,
+        mtimeMs: inspected.mtimeMs,
+        ctimeMs: inspected.ctimeMs,
+    };
+}
+/** Basename-only guard for names stored inside active/staging trees. */
+export function assertSafeBasename(name, label) {
+    if (typeof name !== "string" || name.length < 1 || name.length > 128) {
+        throw new MediaValidationError(`${label} must be a basename string.`);
+    }
+    if (name !== path.basename(name) || name === "." || name === "..") {
+        throw new MediaValidationError(`${label} must be a basename only.`);
+    }
+    if (name.includes("/") || name.includes("\\") || name.includes("\0")) {
+        throw new MediaValidationError(`${label} contains illegal path characters.`);
+    }
+    if (/[<>:"|?*]/.test(name) || /[. ]$/.test(name)) {
+        throw new MediaValidationError(`${label} contains characters invalid in Windows basenames.`);
+    }
+    const stem = name.split(".", 1)[0] ?? "";
+    if (/^(con|prn|aux|nul|com[1-9]|lpt[1-9])$/i.test(stem)) {
+        throw new MediaValidationError(`${label} uses a reserved device name.`);
+    }
+    for (let i = 0; i < name.length; i += 1) {
+        const code = name.charCodeAt(i);
+        if (code < 32 || code === 127) {
+            throw new MediaValidationError(`${label} contains control characters.`);
+        }
+    }
+    return name;
+}
+//# sourceMappingURL=media-validation.js.map

package/vendor/core/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "@beauticode/core",
+  "type": "module",
+  "main": "./index.js"
+}

package/vendor/core/paths.js

@@ -0,0 +1,168 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import crypto from "node:crypto";
+import { ACTIVE_DIR_NAME, MANIFEST_NAME, RUNTIME_MEDIA_DIR_NAME, SAVED_DIR_NAME, SCHEMA_ID, SNAPSHOTS_DIR_NAME, STAGING_DIR_NAME, } from "./constants.js";
+const DATA_ROOT_MARKER_NAME = ".beauticode-root.json";
+const DATA_ROOT_SCHEMA = "beauticode.data-root/v1";
+export function defaultDataRoot() {
+    if (process.platform === "win32") {
+        const base = process.env.LOCALAPPDATA ?? path.join(os.homedir(), "AppData", "Local");
+        return path.join(base, "beautiCode");
+    }
+    if (process.platform === "darwin") {
+        return path.join(os.homedir(), "Library", "Application Support", "beautiCode");
+    }
+    const xdg = process.env.XDG_DATA_HOME ?? path.join(os.homedir(), ".local", "share");
+    return path.join(xdg, "beautiCode");
+}
+export function resolveDataPaths(root = defaultDataRoot()) {
+    const resolved = path.resolve(root);
+    return {
+        root: resolved,
+        activeDir: path.join(resolved, ACTIVE_DIR_NAME),
+        stagingDir: path.join(resolved, STAGING_DIR_NAME),
+        snapshotsDir: path.join(resolved, SNAPSHOTS_DIR_NAME),
+        savedDir: path.join(resolved, SAVED_DIR_NAME),
+        runtimeMediaDir: path.join(resolved, RUNTIME_MEDIA_DIR_NAME),
+    };
+}
+export async function ensureDataLayout(paths) {
+    let rootExists = true;
+    try {
+        const stat = await fs.lstat(paths.root);
+        if (!stat.isDirectory() || stat.isSymbolicLink()) {
+            throw new Error("beautiCode data root must be a real directory.");
+        }
+    }
+    catch (error) {
+        const code = error && typeof error === "object" && "code" in error
+            ? String(error.code)
+            : "";
+        if (code !== "ENOENT")
+            throw error;
+        rootExists = false;
+        await fs.mkdir(paths.root, { recursive: true });
+    }
+    const markerPath = path.join(paths.root, DATA_ROOT_MARKER_NAME);
+    let markerValid = false;
+    try {
+        const raw = await fs.readFile(markerPath, "utf8");
+        const marker = JSON.parse(raw);
+        markerValid = marker?.schema === DATA_ROOT_SCHEMA;
+        if (!markerValid) {
+            throw new Error("beautiCode data-root ownership marker is invalid.");
+        }
+    }
+    catch (error) {
+        const code = error && typeof error === "object" && "code" in error
+            ? String(error.code)
+            : "";
+        if (code !== "ENOENT")
+            throw error;
+    }
+    if (!markerValid) {
+        const entries = rootExists ? await fs.readdir(paths.root) : [];
+        const allowedLegacyEntry = (entry) => entry === ACTIVE_DIR_NAME ||
+            entry === STAGING_DIR_NAME ||
+            entry === SNAPSHOTS_DIR_NAME ||
+            entry === SAVED_DIR_NAME ||
+            entry === RUNTIME_MEDIA_DIR_NAME ||
+            entry === "logs" ||
+            entry === "engine-launcher.log" ||
+            entry === "injector.lock" ||
+            entry === "store.lock" ||
+            entry === "dsh-control.json" ||
+            entry === "session-host.json" ||
+            entry === "tray-claim.json" ||
+            entry === "dsh-bridge.token" ||
+            entry === ".beauticode-commit.json" ||
+            entry === ".beauticode-commit-in-progress" ||
+            entry.startsWith("active-backup-");
+        let hasLegacyManifest = false;
+        try {
+            const raw = await fs.readFile(path.join(paths.activeDir, MANIFEST_NAME), "utf8");
+            const manifest = JSON.parse(raw);
+            hasLegacyManifest = manifest?.schema === SCHEMA_ID;
+        }
+        catch {
+            hasLegacyManifest = false;
+        }
+        if (entries.length > 0 &&
+            !hasLegacyManifest &&
+            !entries.every(allowedLegacyEntry)) {
+            throw new Error("Refusing to adopt a non-empty directory without beautiCode data. Choose an empty --data-root.");
+        }
+        const marker = `${JSON.stringify({
+            schema: DATA_ROOT_SCHEMA,
+            createdAt: new Date().toISOString(),
+        }, null, 2)}\n`;
+        try {
+            const handle = await fs.open(markerPath, "wx", 0o600);
+            try {
+                await handle.writeFile(marker, "utf8");
+                await handle.sync();
+            }
+            finally {
+                await handle.close();
+            }
+        }
+        catch (error) {
+            const code = error && typeof error === "object" && "code" in error
+                ? String(error.code)
+                : "";
+            if (code !== "EEXIST")
+                throw error;
+            const raw = await fs.readFile(markerPath, "utf8");
+            const existing = JSON.parse(raw);
+            if (existing?.schema !== DATA_ROOT_SCHEMA) {
+                throw new Error("beautiCode data-root ownership marker is invalid.");
+            }
+        }
+    }
+    await fs.mkdir(paths.stagingDir, { recursive: true });
+    await fs.mkdir(paths.snapshotsDir, { recursive: true });
+    await fs.mkdir(paths.savedDir, { recursive: true });
+    await fs.mkdir(paths.runtimeMediaDir, { recursive: true });
+}
+/** True iff `candidate` is equal to or strictly inside `root`. */
+export function isPathInsideRoot(root, candidate) {
+    const rootResolved = path.resolve(root);
+    const candResolved = path.resolve(candidate);
+    if (rootResolved === candResolved)
+        return true;
+    const rel = path.relative(rootResolved, candResolved);
+    return rel !== "" && !rel.startsWith("..") && !path.isAbsolute(rel);
+}
+export async function rmrf(target) {
+    await fs.rm(target, { recursive: true, force: true });
+}
+export async function emptyDir(target) {
+    await rmrf(target);
+    await fs.mkdir(target, { recursive: true });
+}
+export async function copyFileAtomic(source, destination) {
+    const dir = path.dirname(destination);
+    await fs.mkdir(dir, { recursive: true });
+    const tmp = `${destination}.${process.pid}.${crypto.randomUUID()}.tmp`;
+    await fs.copyFile(source, tmp);
+    await fs.rename(tmp, destination);
+}
+/**
+ * Snapshot helper: use a same-volume hard link to avoid copying large media,
+ * with an atomic-copy fallback for filesystems that do not support links.
+ */
+export async function linkOrCopyFileAtomic(source, destination) {
+    const dir = path.dirname(destination);
+    await fs.mkdir(dir, { recursive: true });
+    const tmp = `${destination}.${process.pid}.${crypto.randomUUID()}.tmp`;
+    try {
+        await fs.link(source, tmp);
+        await fs.rename(tmp, destination);
+    }
+    catch {
+        await fs.rm(tmp, { force: true }).catch(() => { });
+        await copyFileAtomic(source, destination);
+    }
+}
+//# sourceMappingURL=paths.js.map

package/vendor/core/types.js

@@ -0,0 +1,15 @@
+export function normalizeBackgroundEffects(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const preset = value.preset;
+    if (preset !== "internal" &&
+        preset !== "infernal" &&
+        preset !== "gallery") {
+        return null;
+    }
+    return { preset, rain: true, overlay: true, water: true };
+}
+export function effectsForPreset(preset) {
+    return { preset, rain: true, overlay: true, water: true };
+}
+//# sourceMappingURL=types.js.map