modwright 0.1.0

package/dist/surfaces/stardewvalley/mods.js

@@ -0,0 +1,182 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+export const SLUG_RE = /^[a-zA-Z0-9_.-]+$/;
+export const SLUG_RUNTIME_RE = /^[\p{L}\d_.-]+$/u;
+export const SEMANTIC_VERSION_RE = /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:\.(?:0|[1-9]\d*))?(?:-(?:[a-zA-Z0-9]+[-.]?)+)?$/;
+export const SEMANTIC_VERSION_RUNTIME_RE = /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:\.(?:0|[1-9]\d*))?(?:-(?:[a-zA-Z0-9]+[-.]?)+)?(?:\+[a-zA-Z0-9.-]+)?$/;
+export const ENTRY_DLL_RE = /^[a-zA-Z0-9_.-]+\.dll$/;
+export const UPDATE_KEY_RE = /^(Chucklefish:\d+|Nexus:\d+|GitHub:[A-Za-z0-9_\-.]+\/[A-Za-z0-9_\-]+|ModDrop:\d+|CurseForge:\d+)(?: *@ *[a-zA-Z0-9_]+ *)?$/i;
+export const PROJECT_VERSION_TOKEN = "%ProjectVersion%";
+export const MANIFEST_FIELDS = ["Name", "Author", "Version", "Description", "UniqueID", "MinimumApiVersion", "MinimumGameVersion", "EntryDll", "ContentPackFor", "Dependencies", "UpdateKeys"];
+export function relaxJson(text) {
+    let out = "";
+    let i = 0;
+    const t = text.replace(/^\uFEFF/, "");
+    while (i < t.length) {
+        const c = t[i];
+        if (c === '"') {
+            let j = i + 1;
+            while (j < t.length && t[j] !== '"') {
+                if (t[j] === "\\")
+                    j++;
+                j++;
+            }
+            out += t.slice(i, j + 1);
+            i = j + 1;
+            continue;
+        }
+        if (c === "/" && t[i + 1] === "/") {
+            while (i < t.length && t[i] !== "\n")
+                i++;
+            continue;
+        }
+        if (c === "/" && t[i + 1] === "*") {
+            const end = t.indexOf("*/", i + 2);
+            i = end < 0 ? t.length : end + 2;
+            continue;
+        }
+        out += c;
+        i++;
+    }
+    return out.replace(/,(\s*[}\]])/g, "$1");
+}
+export function parseManifest(text) {
+    const parsed = JSON.parse(relaxJson(text));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        throw new TypeError("manifest.json is not a JSON object");
+    const raw = parsed;
+    const known = new Set(MANIFEST_FIELDS);
+    const out = { extraFields: {}, raw };
+    for (const [k, v] of Object.entries(raw)) {
+        if (known.has(k))
+            out[k] = v;
+        else
+            out.extraFields[k] = v;
+    }
+    return out;
+}
+export function manifestType(m) {
+    const isSmapi = typeof m.EntryDll === "string" && m.EntryDll.trim().length > 0;
+    const cpf = m.ContentPackFor;
+    const isContentPack = !!cpf && typeof cpf === "object" && typeof cpf.UniqueID === "string" && cpf.UniqueID.trim().length > 0;
+    if (isSmapi === isContentPack)
+        return "invalid";
+    return isSmapi ? "smapi" : "content-pack";
+}
+export const IGNORED_NAMES = [/^__folder_managed_by_vortex$/i, /(?:^\._|^\.DS_Store$|^__MACOSX$|^mcs$)/i, /^(?:desktop\.ini|Thumbs\.db)$/i];
+export const IGNORED_EXTENSIONS = new Set([".doc", ".docx", ".md", ".rtf", ".txt", ".bmp", ".gif", ".ico", ".jpeg", ".jpg", ".png", ".psd", ".tif", ".xcf", ".rar", ".zip", ".7z", ".tar", ".tar.gz", ".backup", ".bak", ".old", ".url", ".lnk"]);
+export const VORTEX_MARKER = "__folder_managed_by_vortex";
+const CONFIG_FILE_NAME = "config.json";
+const INSTALLER_NAMES = ["install on Linux.sh", "install on macOS.command", "install on Windows.bat"];
+export const XNB_EXTENSIONS = new Set([".xgs", ".xnb", ".xsb", ".xwb"]);
+const XNB_SIDE_EXTENSIONS = new Set([".json", ".yaml"]);
+function isIgnoredName(name) {
+    return IGNORED_NAMES.some((re) => re.test(name));
+}
+function isRelevantFile(name) {
+    return !IGNORED_EXTENSIONS.has(path.extname(name).toLowerCase()) && !name.startsWith(".") && !isIgnoredName(name);
+}
+function isRelevantDir(name) {
+    return !isIgnoredName(name);
+}
+export async function scanMods(modsDir) {
+    const walk = async (dir, rel) => {
+        const isRoot = rel === "";
+        if (!isRoot) {
+            const name = path.basename(dir);
+            if (name.startsWith("."))
+                return [{ path: dir, relative: rel, kind: "ignored", reason: "ignored folder because its name starts with a dot.", error: "ignored-folder" }];
+            if (!isRelevantDir(name))
+                return [];
+        }
+        const entries = await readDir(dir);
+        const dirs = entries.filter((e) => e.isDirectory() && isRelevantDir(e.name)).sort((a, b) => a.name.localeCompare(b.name));
+        const files = entries.filter((e) => e.isFile() && isRelevantFile(e.name));
+        if (isRoot || (dirs.length > 0 && files.length === 0)) {
+            const found = [];
+            for (const d of dirs)
+                found.push(...(await walk(path.join(dir, d.name), isRoot ? d.name : `${rel}/${d.name}`)));
+            return isRoot ? found : consolidate(dir, rel, found);
+        }
+        return [await readFolder(dir, rel, entries)];
+    };
+    const consolidate = (dir, rel, subfolders) => {
+        if (subfolders.length > 1) {
+            if (subfolders.every((s) => s.error === "empty-folder"))
+                return [{ path: dir, relative: rel, kind: "not-a-mod", reason: subfolders[0].reason, error: "empty-folder" }];
+            if (subfolders.every((s) => s.kind === "xnb" || s.error === "empty-folder"))
+                return [{ path: dir, relative: rel, kind: "xnb", reason: subfolders[0].reason, error: "xnb-mod" }];
+        }
+        return subfolders;
+    };
+    const readFolder = async (dir, rel, entries) => {
+        const manifest = entries.find((e) => e.isFile() && e.name.toLowerCase() === "manifest.json");
+        if (manifest) {
+            const file = path.join(dir, manifest.name);
+            try {
+                const m = parseManifest(await fs.readFile(file, "utf8"));
+                const type = manifestType(m);
+                return { path: dir, relative: rel, kind: type, manifest: m, ...(type === "invalid" ? { reason: "its manifest is invalid.", error: "manifest-invalid" } : {}) };
+            }
+            catch (err) {
+                return { path: dir, relative: rel, kind: "invalid", reason: `parsing its manifest failed: ${err.message}`, error: "manifest-invalid" };
+            }
+        }
+        const allFiles = await filesBelow(dir);
+        const relevant = allFiles.filter((f) => isRelevantFile(path.basename(f)));
+        if (isEmptyVortexFolder(allFiles))
+            return { path: dir, relative: rel, kind: "not-a-mod", reason: "it's an empty Vortex folder (is the mod disabled in Vortex?).", error: "empty-vortex-folder" };
+        if (relevant.length === 0)
+            return { path: dir, relative: rel, kind: "not-a-mod", reason: "it's an empty folder.", error: "empty-folder" };
+        if (isXnbMod(relevant))
+            return { path: dir, relative: rel, kind: "xnb", reason: "it's not a SMAPI mod (see https://smapi.io/xnb for info).", error: "xnb-mod" };
+        if (relevant.some((f) => INSTALLER_NAMES.some((n) => n.toLowerCase() === path.basename(f).toLowerCase()))) {
+            return { path: dir, relative: rel, kind: "not-a-mod", reason: "the SMAPI installer isn't a mod (you can delete this folder after running the installer file).", error: "manifest-missing" };
+        }
+        return { path: dir, relative: rel, kind: "not-a-mod", reason: "it contains files, but none of them are manifest.json.", error: "manifest-missing" };
+    };
+    const isXnbMod = (files) => {
+        const exts = files.map((f) => path.extname(f).toLowerCase());
+        return exts.some((x) => XNB_EXTENSIONS.has(x)) && exts.every((x) => XNB_EXTENSIONS.has(x) || XNB_SIDE_EXTENSIONS.has(x));
+    };
+    const isEmptyVortexFolder = (files) => {
+        let hasMarker = false;
+        for (const f of files) {
+            const name = path.basename(f);
+            if (name === VORTEX_MARKER) {
+                hasMarker = true;
+                continue;
+            }
+            if (isRelevantFile(name) && name !== CONFIG_FILE_NAME)
+                return false;
+        }
+        return hasMarker;
+    };
+    const filesBelow = async (dir) => {
+        const found = [];
+        const walkDir = async (d) => {
+            for (const e of await readDir(d)) {
+                if (e.isDirectory()) {
+                    if (isRelevantDir(e.name))
+                        await walkDir(path.join(d, e.name));
+                }
+                else if (e.isFile())
+                    found.push(path.join(d, e.name));
+            }
+        };
+        await walkDir(dir);
+        return found;
+    };
+    const readDir = async (dir) => {
+        try {
+            return await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return [];
+        }
+    };
+    return walk(modsDir, "");
+}
+export function displayName(m) {
+    return typeof m.Name === "string" ? m.Name.trim().replace(/[\r\n]/g, " ").replace(/\[/g, "(").replace(/\]/g, ")") : undefined;
+}

package/dist/surfaces/stardewvalley/surface.js

@@ -0,0 +1,244 @@
+import * as path from "node:path";
+import { readPeFileVersion } from "../../core/compat/pe.js";
+import { compareVersions, parseVersion } from "../../core/compat/version.js";
+import { appData, homePath, pathExists, readTextIfExists } from "../../core/fsutil.js";
+import { readRegistryValue } from "../../core/registry.js";
+import { findInSteam } from "../../core/steam.js";
+import { dedupeByRoot, logs, roots } from "../../core/surfaceutil.js";
+import { SIGNATURES } from "./logs.js";
+import { WIKI_FETCH } from "./index/wiki.js";
+import { parseManifest, scanMods } from "./mods.js";
+import { stardewvalleyCompat } from "./compat.js";
+import { readSmapiConfig, stringList } from "./config.js";
+import { stardewvalleyIndex } from "./index/index.js";
+import { CONTENT_VALIDATORS } from "./validators/content.js";
+import { FIELDS_VALIDATORS } from "./validators/fields.js";
+import { LOADORDER_VALIDATORS } from "./validators/loadorder.js";
+import { MANIFEST_VALIDATORS } from "./validators/manifest.js";
+export const STEAM_APP_ID = "413150";
+export function dataDir() {
+    return appData("StardewValley");
+}
+export const REGISTRY_INSTALL_KEYS = [
+    { keys: [String.raw `HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\Steam App 413150`], value: "InstallLocation", source: "steam" },
+    { keys: [String.raw `HKLM\SOFTWARE\WOW6432Node\GOG.com\Games\1453375253`], value: "PATH", source: "gog" },
+];
+function conventionalPaths() {
+    const out = [];
+    for (const programFiles of ["C:\\Program Files", "C:\\Program Files (x86)"]) {
+        out.push({ root: path.join(programFiles, "GalaxyClient", "Games", "Stardew Valley"), source: "gog" });
+        out.push({ root: path.join(programFiles, "GOG Galaxy", "Games", "Stardew Valley"), source: "gog" });
+        out.push({ root: path.join(programFiles, "GOG Games", "Stardew Valley"), source: "gog" });
+        out.push({ root: path.join(programFiles, "Steam", "steamapps", "common", "Stardew Valley"), source: "steam" });
+    }
+    for (const drive of ["C", "D", "E", "F", "G", "H"])
+        out.push({ root: `${drive}:\\Program Files\\ModifiableWindowsApps\\Stardew Valley`, source: "xbox" });
+    return out;
+}
+export async function gameFolderType(root, readVersion = readPeFileVersion) {
+    if (await pathExists(path.join(root, "Stardew Valley.dll")))
+        return "valid";
+    let found;
+    for (const e of [path.join(root, "Stardew Valley.exe"), path.join(root, "StardewValley.exe")]) {
+        if (await pathExists(e)) {
+            found = e;
+            break;
+        }
+    }
+    if (!found)
+        return "no-game";
+    let version;
+    try {
+        version = await readVersion(found);
+    }
+    catch {
+        version = undefined;
+    }
+    if (!version || !parseVersion(version))
+        return "invalid-unknown";
+    if (compareVersions(version, "1.6") < 0)
+        return "legacy-version";
+    if (!(await pathExists(path.join(root, "MonoGame.Framework.dll"))))
+        return "legacy-compatibility-branch";
+    return "invalid-unknown";
+}
+export async function targetsFileGamePath(file = homePath("stardewvalley.targets")) {
+    const text = await readTextIfExists(file);
+    if (!text)
+        return undefined;
+    const m = /<GamePath>\s*([^<]+?)\s*<\/GamePath>/i.exec(text);
+    return m ? m[1] : undefined;
+}
+export const SMAPI_EXE = "StardewModdingAPI.exe";
+export const MODS_DIR = "Mods";
+export const INTERNAL_DIR = "smapi-internal";
+export function configCandidates(install) {
+    return [path.join(install.root, MODS_DIR, "SMAPI-config.json"), path.join(install.root, INTERNAL_DIR, "config.user.json"), path.join(install.root, INTERNAL_DIR, "config.json")];
+}
+export async function readLoadOrderOverrides(install) {
+    const config = await readSmapiConfig(install);
+    const setters = [config.sources.ModsToLoadEarly, config.sources.ModsToLoadLate].filter((f) => f !== undefined);
+    const file = setters.length > 0 ? setters.sort((a, b) => config.files.indexOf(a) - config.files.indexOf(b)).pop() : config.files[config.files.length - 1];
+    return { ...(file !== undefined ? { file } : {}), early: stringList(config.settings, "ModsToLoadEarly"), late: stringList(config.settings, "ModsToLoadLate") };
+}
+export const stardewvalley = {
+    id: "stardewvalley",
+    name: "Stardew Valley",
+    aliases: ["stardew", "sdv", "stardewvalley"],
+    summary: "ConcernedApe's farming game, modded through SMAPI: C# mods and Content Patcher content packs, " +
+        "one folder per mod under Mods/, launched through StardewModdingAPI.exe.",
+    async detect() {
+        const installs = [];
+        const consider = async (root, source) => {
+            if (!root)
+                return;
+            if ((await gameFolderType(root)) === "valid")
+                installs.push({ gameId: "stardewvalley", root, source });
+        };
+        await consider(process.env.MODWRIGHT_STARDEWVALLEY_ROOT, "env");
+        await consider(await targetsFileGamePath(), "config");
+        for (const root of await findInSteam(["Stardew Valley"]))
+            await consider(root, "steam");
+        for (const { keys, value, source } of REGISTRY_INSTALL_KEYS) {
+            const hit = await readRegistryValue(keys, value);
+            await consider(hit?.value, source);
+        }
+        for (const { root, source } of conventionalPaths())
+            await consider(root, source);
+        return dedupeByRoot(installs);
+    },
+    modRoots(install) {
+        return roots([
+            {
+                id: "mods",
+                label: "SMAPI mods",
+                path: path.join(install.root, MODS_DIR),
+                layout: "directory",
+                conflictScope: "isolated",
+                notes: "Each subfolder holding a manifest.json is one mod, at any depth (grouping folders " +
+                    "are normal); a folder whose name starts with a dot is disabled. Load order is a " +
+                    "topological sort of each manifest's Dependencies plus smapi-internal/config.json's " +
+                    "ModsToLoadEarly/ModsToLoadLate, never folder position. Real collisions are on " +
+                    "UniqueID, not on file path: two folders with the same id load neither.",
+            },
+            {
+                id: "smapi-internal",
+                label: "SMAPI internals",
+                path: path.join(install.root, INTERNAL_DIR),
+                layout: "flat",
+                conflictScope: "merged",
+                notes: "SMAPI's own assemblies, config.json (reset on every SMAPI update; config.user.json survives) and metadata.json. Never a deploy target; where 'is SMAPI installed' is answered.",
+            },
+            {
+                id: "content",
+                label: "Game content (XNB)",
+                path: path.join(install.root, "Content"),
+                layout: "flat",
+                conflictScope: "merged",
+                notes: "The game's compiled XNA assets. Never a deploy target: a folder of .xnb files under Mods/ is the legacy XNB-mod shape SMAPI refuses ('it's not a SMAPI mod').",
+            },
+        ]);
+    },
+    async readManifest(modPath, root) {
+        if (root.id !== "mods")
+            return undefined;
+        const text = await readTextIfExists(path.join(modPath, "manifest.json"));
+        if (text === undefined)
+            return undefined;
+        try {
+            const m = parseManifest(text);
+            const deps = Array.isArray(m.Dependencies) ? m.Dependencies.map((d) => (d && typeof d === "object" ? d.UniqueID : undefined)).filter((d) => typeof d === "string") : [];
+            const cpf = m.ContentPackFor && typeof m.ContentPackFor === "object" ? m.ContentPackFor.UniqueID : undefined;
+            return {
+                format: "smapi-manifest.json",
+                ...(typeof m.Name === "string" ? { name: m.Name } : {}),
+                ...(typeof m.Author === "string" ? { author: m.Author } : {}),
+                ...(typeof m.Version === "string" ? { version: m.Version } : {}),
+                ...(typeof m.Description === "string" ? { description: m.Description } : {}),
+                dependencies: [...(typeof cpf === "string" ? [cpf] : []), ...deps],
+                raw: m.raw,
+            };
+        }
+        catch {
+            return undefined;
+        }
+    },
+    async loadOrder(install) {
+        const overrides = await readLoadOrderOverrides(install);
+        if (overrides.early.length === 0 && overrides.late.length === 0)
+            return [];
+        const mods = await scanMods(path.join(install.root, MODS_DIR));
+        const byId = new Map();
+        for (const m of mods) {
+            const id = typeof m.manifest?.UniqueID === "string" ? m.manifest.UniqueID.toLowerCase() : undefined;
+            if (id && !m.relative.includes("/") && (m.kind === "smapi" || m.kind === "content-pack"))
+                byId.set(id, m.relative);
+        }
+        const entries = [];
+        let index = 0;
+        for (const id of [...overrides.early, ...overrides.late]) {
+            const folder = byId.get(id.toLowerCase());
+            entries.push({ index: index++, name: id, enabled: true, ...(folder ? { modId: `mods:${folder}` } : {}) });
+        }
+        return entries;
+    },
+    loadOrderFile(install) {
+        return path.join(install.root, INTERNAL_DIR, "config.json");
+    },
+    logs() {
+        const dir = path.join(dataDir(), "ErrorLogs");
+        return logs([
+            {
+                id: "smapi",
+                label: "SMAPI log (SMAPI-latest.txt)",
+                candidates: [path.join(dir, "SMAPI-latest.txt"), ...[2, 3, 4, 5].map((n) => path.join(dir, `SMAPI-latest.player-${n}.txt`))],
+                notes: "One fresh file per run, flushed on every line, so it is complete up to the moment it " +
+                    "is read. Lines are '[HH:mm:ss LEVEL source] message' with no date; the one absolute " +
+                    "timestamp is the 'Log started at ... UTC' line. A line without that prefix continues " +
+                    "the previous message (stack traces). The source is the mod's display name, not its " +
+                    "UniqueID. A second running instance writes SMAPI-latest.player-2.txt.",
+            },
+            {
+                id: "smapi-crash",
+                label: "SMAPI crash log",
+                candidates: [path.join(dir, "SMAPI-crash.txt")],
+                notes: "Written only when the game crashed; kept until the next crash.",
+            },
+        ]);
+    },
+    async explainMissing(install) {
+        const reasons = {};
+        if (!(await pathExists(dataDir()))) {
+            reasons.smapi = `${dataDir()} does not exist: the game has never been run on this account, so no SMAPI log can exist yet (SMAPI's install guide has the game run once without SMAPI first).`;
+        }
+        else if (await pathExists(path.join(install.root, SMAPI_EXE))) {
+            reasons.smapi = `SMAPI is installed (${SMAPI_EXE} is beside the game) but has not written a log: it was not launched. On Windows Steam runs it only through a launch-options string that is not readable from disk; run ${SMAPI_EXE} directly to check.`;
+        }
+        else {
+            reasons.smapi = `${SMAPI_EXE} is not in the game folder: SMAPI is not installed, so no SMAPI log exists.`;
+        }
+        reasons["smapi-crash"] = "The crash log exists only after the game has crashed under SMAPI.";
+        return reasons;
+    },
+    logSignatures: SIGNATURES,
+    validators: [...MANIFEST_VALIDATORS, ...CONTENT_VALIDATORS, ...FIELDS_VALIDATORS, ...LOADORDER_VALIDATORS],
+    index: stardewvalleyIndex,
+    compat: stardewvalleyCompat,
+    toolNeeds: [
+        { feature: "index", data: [{ id: "stardewvalley.wiki", envVar: "MODWRIGHT_STARDEWVALLEY_WIKI_DATA", what: "the wiki's Modding: data pages, saved locally (check_toolchain action=install data=stardewvalley.wiki fetches them)", fetch: WIKI_FETCH }], note: "build_index reads saved wiki pages; no tool is needed." },
+        { feature: "build", tools: ["dotnet"], note: "dotnet build compiles SMAPI C# mods (Content Patcher packs need no build)." },
+    ],
+    processNames: ["StardewModdingAPI.exe", "Stardew Valley.exe", "StardewModdingAPI", "StardewValley"],
+    guidance: "Mods load only through SMAPI (StardewModdingAPI.exe); a missing SMAPI log usually means " +
+        "SMAPI was not launched, not that anything is broken, and on Windows whether Steam runs it " +
+        "is decided by a launch-options string that is not on disk. The log lists mods by display " +
+        "name, not UniqueID, and its 'Loaded N mods' list is alphabetical, not the load order; the " +
+        "order is a dependency sort with only smapi-internal/config.json's ModsToLoadEarly and " +
+        "ModsToLoadLate as an editable file. A mod is a folder with manifest.json at any depth under " +
+        "Mods/; a dot-prefixed folder is disabled; a folder of .xnb files is refused. A C# mod cannot " +
+        "compile without the game installed (the build package needs Stardew Valley.dll), so a " +
+        "content pack is the first project to try here. Nothing here has run against an installed game.",
+};
+export async function scanInstallMods(install) {
+    return scanMods(path.join(install.root, MODS_DIR));
+}