modwright 0.1.0

package/dist/core/deploy/reload-apply.js

@@ -0,0 +1,361 @@
+import * as path from "node:path";
+import { executePlan, planCopy, planFile, planMkdir } from "../safety/index.js";
+import { armBridge, bridgeCandidateDirs, bridgeStatus, cetLogCandidates, grantAllowsMutation, pollCyberpunk } from "../bridge/index.js";
+import { REAL_FS_FOR_APPLY, redHotToolsDir } from "./reload.js";
+function toPosix(p) {
+    return p.split(path.sep).join("/");
+}
+const SCRIPT_RE = /(^|\/)r6\/scripts\//;
+const TWEAK_RE = /(^|\/)r6\/tweaks\//;
+const ARCHIVE_RE = /(^|\/)archive\/pc\/mod\/.+\.archive$/;
+const XL_RE = /(^|\/)archive\/pc\/mod\/.+\.archive\.xl$/;
+function triggerFor(dest) {
+    const posix = toPosix(dest);
+    if (SCRIPT_RE.test(posix))
+        return "scripts";
+    if (TWEAK_RE.test(posix))
+        return "tweaks";
+    if (XL_RE.test(posix))
+        return "xl";
+    if (ARCHIVE_RE.test(posix))
+        return "archives";
+    return undefined;
+}
+export function planReloadApply(input) {
+    if (input.game !== "cyberpunk2077") {
+        return {
+            refused: { reason: "wrong-game", message: `deploy --reload apply is Cyberpunk 2077 only; this project is ${input.game}.` },
+            operations: [],
+            triggers: [],
+            skipped: [],
+        };
+    }
+    if (!grantAllowsMutation(input.grant, input.allowMutate)) {
+        return {
+            refused: {
+                reason: "session-grant-required",
+                message: "deploy --reload apply writes Red Hot Tools' file triggers into the running game, a session-tier action. " +
+                    'Grant it via bridge.policy mode: workbench, grant: ["session"], or the retired allowMutate.',
+            },
+            operations: [],
+            triggers: [],
+            skipped: [],
+        };
+    }
+    const dir = redHotToolsDir(input.install);
+    const hotDir = path.join(input.install.root, "archive", "pc", "hot");
+    const mesh = new Set((input.meshArchives ?? []).map((m) => path.basename(toPosix(m))));
+    const scriptDests = [];
+    const tweakDests = [];
+    const archives = [];
+    const xls = [];
+    const skipped = [];
+    for (const t of input.targets) {
+        switch (triggerFor(t.to)) {
+            case "scripts":
+                scriptDests.push(t.to);
+                break;
+            case "tweaks":
+                tweakDests.push(t.to);
+                break;
+            case "xl":
+                xls.push(t);
+                break;
+            case "archives":
+                if (mesh.has(path.basename(toPosix(t.to)))) {
+                    skipped.push({ path: t.to, reason: "archive carries a mounted mesh; the hot folder is banned for whole-mesh archives (fact cp2077.process.assetbuild.rht-hot-folder-banned-for-whole-mesh-archives) — restart" });
+                }
+                else {
+                    archives.push(t);
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    const operations = [];
+    const triggers = [];
+    const stamp = (input.now ?? (() => new Date()))().toISOString();
+    if (archives.length > 0) {
+        operations.push(planMkdir(hotDir));
+        const hotPaths = [];
+        for (const a of archives) {
+            const dest = path.join(hotDir, path.basename(toPosix(a.from)));
+            operations.push(planCopy(a.from, dest));
+            hotPaths.push(dest);
+        }
+        for (const xl of xls) {
+            const dest = path.join(hotDir, path.basename(toPosix(xl.from)));
+            operations.push(planCopy(xl.from, dest));
+            hotPaths.push(dest);
+        }
+        triggers.push({ kind: "archives", triggerPath: hotDir, watchPaths: hotPaths, sourcePaths: [...archives.map((a) => a.from), ...xls.map((x) => x.from)] });
+    }
+    else if (xls.length > 0) {
+        for (const xl of xls)
+            skipped.push({ path: xl.to, reason: "an .xl with no .archive alongside reloads via ArchiveXL.Reload() through cp2077.lua.eval, not the hot folder" });
+    }
+    if (tweakDests.length > 0) {
+        const hotTweaks = path.join(dir, ".hot-tweaks");
+        operations.push(planFile(hotTweaks, `modwright reload ${stamp}\n`));
+        triggers.push({ kind: "tweaks", triggerPath: hotTweaks, watchPaths: [hotTweaks], sourcePaths: tweakDests });
+    }
+    if (scriptDests.length > 0) {
+        const hotScripts = path.join(dir, ".hot-scripts");
+        operations.push(planFile(hotScripts, ""));
+        triggers.push({ kind: "scripts", triggerPath: hotScripts, watchPaths: [hotScripts], sourcePaths: scriptDests });
+    }
+    return { operations, triggers, skipped };
+}
+const DEFAULT_DEPS = REAL_FS_FOR_APPLY;
+const DEFAULT_SLEEP = (ms) => new Promise((r) => setTimeout(r, ms));
+async function bridgeTweakReload(ctx) {
+    const method = "TweakXL.Reload() via cp2077.lua.eval";
+    const sleep = ctx.sleep ?? DEFAULT_SLEEP;
+    let status = await bridgeStatus("cyberpunk2077", ctx.install, ctx.surface, { now: ctx.now });
+    const deadline = Date.now() + 6000;
+    while ((!status.found || status.freshness !== "fresh") && Date.now() < deadline) {
+        await sleep(500);
+        status = await bridgeStatus("cyberpunk2077", ctx.install, ctx.surface, { now: ctx.now });
+    }
+    if (!status.found || status.freshness !== "fresh") {
+        return {
+            method,
+            verdict: "absent",
+            detail: `the bridge is not live (no fresh heartbeat after 6s; last ${status.freshness}), so tweaks could not be reloaded through it. ` +
+                "The .hot-tweaks sentinel was written as a fallback but does not drive a reload in RHT 1.3.0.33690 " +
+                "(fact hot-tweaks-consumed-without-reload-1.3.0) — launch with the withBridge bridge, then it reloads automatically.",
+        };
+    }
+    const probe = { id: "tweakxl-reload", kind: "cp2077.lua.eval", context: "cet", effect: "mutate", params: { code: 'TweakXL.Reload(); return "reloaded"' } };
+    const armed = await armBridge({
+        game: "cyberpunk2077",
+        install: ctx.install,
+        surface: ctx.surface,
+        probes: [probe],
+        grant: ctx.grant,
+        allowMutate: ctx.allowMutate,
+        projectRoot: ctx.projectRoot,
+        mode: "apply",
+        now: ctx.now,
+    });
+    if (armed.refused)
+        return { method, verdict: "error", detail: `could not arm TweakXL.Reload(): ${armed.refused.message}` };
+    if (!armed.request)
+        return { method, verdict: "error", detail: "arming TweakXL.Reload() produced no request" };
+    const outcome = await pollCyberpunk({
+        files: await cetLogCandidates(ctx.install, ctx.surface),
+        dirs: bridgeCandidateDirs("cyberpunk2077", ctx.install, ctx.surface),
+        id: armed.request.id,
+        nonce: armed.request.nonce,
+        probeCount: 1,
+        armedAt: ctx.now ? ctx.now() : new Date(),
+        now: ctx.now,
+        sleep: ctx.sleep,
+    });
+    if (outcome.status !== "complete") {
+        return { method, verdict: "absent", detail: `TweakXL.Reload() was armed but no result came back: ${outcome.message}` };
+    }
+    const result = outcome.result.probes[0];
+    if (result && result.status === "pass") {
+        return { method, verdict: "confirmed", detail: `TweakXL.Reload() ran through the bridge (${outcome.transport} transport); re-read the changed flat with a cp2077.tweakdb.flat probe to see the new value` };
+    }
+    return { method, verdict: "error", detail: `TweakXL.Reload() eval did not pass: ${result ? `${result.status}${result.error ? ` — ${result.error}` : ""}` : "no probe result"}` };
+}
+async function newestRhtLog(dir, deps) {
+    return newestLog(dir, /^RedHotTools.*\.log$/i, deps);
+}
+async function newestTweakXlLog(dir, deps) {
+    return newestLog(dir, /^TweakXL.*\.log$/i, deps);
+}
+export function tweakXlErrorsFor(text, deployedPaths, installRoot) {
+    const tweaksRoot = path.join(installRoot, "r6", "tweaks");
+    const norm = (p) => p.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
+    const deployed = deployedPaths.map((p) => norm(path.relative(tweaksRoot, p)));
+    const isDeployed = (file) => deployed.some((d) => file === d || file.startsWith(`${d}/`));
+    const errors = [];
+    let current;
+    for (const line of text.split(/\r?\n/)) {
+        const reading = /Reading "([^"]+)"/.exec(line);
+        if (reading) {
+            current = norm(reading[1]);
+            continue;
+        }
+        if (/\[error\]/i.test(line) && current !== undefined && isDeployed(current))
+            errors.push(line.trim());
+    }
+    return errors;
+}
+async function newestLog(dir, pattern, deps) {
+    let logPath;
+    let newest = -1;
+    try {
+        for (const name of (await deps.readDir(dir)).filter((n) => pattern.test(n))) {
+            const full = path.join(dir, name);
+            const m = await deps.mtimeMs(full).catch(() => -1);
+            if (m > newest) {
+                newest = m;
+                logPath = full;
+            }
+        }
+    }
+    catch {
+    }
+    return logPath;
+}
+async function waitConsumed(paths, timeoutMs, intervalMs, deps, sleep) {
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+        let allGone = true;
+        for (const p of paths) {
+            if (await deps.pathExists(p)) {
+                allGone = false;
+                break;
+            }
+        }
+        if (allGone)
+            return true;
+        if (Date.now() >= deadline)
+            return false;
+        await sleep(intervalMs);
+    }
+}
+async function logCorroboration(logPath, needle, triggerMs, method, deps, baseline) {
+    if (!logPath || !(await deps.pathExists(logPath)))
+        return { ok: false, detail: `${method} not found` };
+    const whole = await deps.readFile(logPath).catch(() => "");
+    const before = baseline.get(logPath) ?? 0;
+    const text = whole.length >= before ? whole.slice(before) : whole;
+    if (!text.includes(needle))
+        return { ok: false, detail: `"${needle}" not in ${path.basename(logPath)} since the trigger yet` };
+    const mtime = await deps.mtimeMs(logPath).catch(() => -1);
+    return mtime >= triggerMs
+        ? { ok: true, detail: `"${needle}" in ${path.basename(logPath)} after the trigger` }
+        : { ok: false, detail: `"${needle}" in ${path.basename(logPath)} but it predates the trigger` };
+}
+export async function runReloadApply(input) {
+    const deps = input.deps ?? DEFAULT_DEPS;
+    const sleep = input.sleep ?? DEFAULT_SLEEP;
+    const mode = input.mode ?? "dry-run";
+    const timeoutMs = input.readBackTimeoutMs ?? 8000;
+    const intervalMs = input.readBackIntervalMs ?? 400;
+    const { refused, operations, triggers, skipped } = planReloadApply(input);
+    if (refused) {
+        return { game: "cyberpunk2077", applied: false, refused, triggers: [], skipped };
+    }
+    const coldSkip = mode === "apply" && input.hotAvailable === false;
+    const confidence = {
+        level: "medium",
+        assumptions: [
+            "A hot reload is confirmed by RHT consuming the trigger (deleting the sentinel / moving the hot archive), then the game log — not assumed.",
+            ...(skipped.length > 0 ? [`${skipped.length} path(s) were left cold (mesh archive or non-hot-folder .xl); they still need a restart.`] : []),
+            ...(coldSkip ? ["Red Hot Tools is not watching this launch, so no trigger was written; deploy the change cold and restart."] : []),
+        ],
+        verifiedBy: [],
+    };
+    const triggerMs = (input.now ?? (() => new Date()))().getTime();
+    const dir = redHotToolsDir(input.install);
+    const tweakXlDir = path.join(input.install.root, "red4ext", "plugins", "TweakXL");
+    const tweakXlLog = (await newestTweakXlLog(tweakXlDir, deps)) ?? path.join(tweakXlDir, "TweakXL.log");
+    const logBaseline = new Map();
+    if (mode === "apply" && !coldSkip) {
+        for (const log of [await newestRhtLog(dir, deps), tweakXlLog]) {
+            if (log && (await deps.pathExists(log)))
+                logBaseline.set(log, (await deps.readFile(log).catch(() => "")).length);
+        }
+    }
+    const write = !coldSkip && operations.length > 0
+        ? await executePlan({
+            purpose: "deploy --reload apply: fire Red Hot Tools triggers",
+            operations,
+            ...(input.projectRoot ? { backupRoot: path.join(input.projectRoot, ".modwright", "backups") } : {}),
+        }, { mode, now: input.now, confidence })
+        : undefined;
+    const tweakLogReadBack = async (ran, deployed) => {
+        if (!(await deps.pathExists(tweakXlLog)))
+            return ran;
+        const appended = async () => {
+            const whole = await deps.readFile(tweakXlLog).catch(() => "");
+            const before = logBaseline.get(tweakXlLog) ?? 0;
+            return whole.length >= before ? whole.slice(before) : whole;
+        };
+        const deadline = Date.now() + timeoutMs;
+        let text = await appended();
+        while (!text.includes("Import completed.") && Date.now() < deadline) {
+            await sleep(intervalMs);
+            text = await appended();
+        }
+        const errors = tweakXlErrorsFor(text, deployed, input.install.root);
+        if (errors.length > 0) {
+            return {
+                method: `${ran.method} + ${path.basename(tweakXlLog)}`,
+                verdict: "error",
+                detail: `TweakXL reloaded but could not read the deployed tweak file(s), so the edit is NOT live: ${errors.slice(0, 3).join(" | ")}${errors.length > 3 ? ` (+${errors.length - 3} more)` : ""}`,
+            };
+        }
+        if (!text.includes("Import completed.")) {
+            return { ...ran, verdict: "triggered", detail: `${ran.detail}; but no "Import completed." in ${path.basename(tweakXlLog)} since the trigger yet` };
+        }
+        return { ...ran, method: `${ran.method} + ${path.basename(tweakXlLog)}`, detail: `${ran.detail}; ${path.basename(tweakXlLog)} shows the import with no error for the deployed file(s)` };
+    };
+    const canDriveBridge = Boolean(input.surface && input.projectRoot);
+    const driveTweaks = input.reloadTweaksViaBridge ?? bridgeTweakReload;
+    const outTriggers = [];
+    for (const t of triggers) {
+        let readBack;
+        if (mode === "dry-run") {
+            readBack = { method: "dry-run", verdict: "pending", detail: "dry-run: nothing was written, so there is no reload to read back — re-run with mode: apply" };
+        }
+        else if (coldSkip) {
+            readBack = { method: "presence", verdict: "absent", detail: "Red Hot Tools is not present/watching this launch; no trigger was written — deploy cold and restart" };
+        }
+        else if (t.kind === "tweaks" && canDriveBridge) {
+            readBack = await driveTweaks({
+                install: input.install,
+                surface: input.surface,
+                projectRoot: input.projectRoot,
+                grant: input.grant,
+                allowMutate: input.allowMutate,
+                now: input.now,
+                sleep: input.sleep,
+            });
+            if (readBack.verdict === "confirmed")
+                readBack = await tweakLogReadBack(readBack, t.sourcePaths);
+        }
+        else {
+            const consumed = await waitConsumed(t.watchPaths, timeoutMs, intervalMs, deps, sleep);
+            if (!consumed) {
+                readBack = {
+                    method: t.kind === "archives" ? "archive/pc/hot moved" : `${path.basename(t.triggerPath)} deleted`,
+                    verdict: "absent",
+                    detail: `RHT did not consume the trigger within ${Math.round(timeoutMs / 1000)}s — is it watching, and is the game at a loaded save and unpaused? (the overlay/console being open can stall the tick)`,
+                };
+            }
+            else if (t.kind === "archives") {
+                const c = await logCorroboration(await newestRhtLog(dir, deps), "Archives reload completed", triggerMs, "RedHotTools.log", deps, logBaseline);
+                readBack = { method: "archive/pc/hot moved + RedHotTools.log", verdict: c.ok ? "confirmed" : "triggered", detail: `RHT moved the archive out of the hot folder; ${c.detail}` };
+            }
+            else if (t.kind === "tweaks") {
+                const c = await logCorroboration(tweakXlLog, "Import completed.", triggerMs, "TweakXL.log", deps, logBaseline);
+                readBack = c.ok
+                    ? await tweakLogReadBack({ method: ".hot-tweaks deleted + TweakXL.log", verdict: "confirmed", detail: `TweakXL re-imported after the trigger (${c.detail})` }, t.sourcePaths)
+                    : {
+                        method: ".hot-tweaks deleted + TweakXL.log",
+                        verdict: "triggered",
+                        detail: "RHT deleted .hot-tweaks, but no TweakXL import followed — in RHT 1.3.0.33690 the .hot-tweaks sentinel does not drive a reload " +
+                            "(fact hot-tweaks-consumed-without-reload-1.3.0), so the edit is NOT live. Reload it with TweakXL.Reload() via cp2077.lua.eval, then re-read the flat.",
+                    };
+            }
+            else {
+                const fn = input.devModule ? `${input.devModule}.BuildStamp()` : "<Mod>Dev.BuildStamp()";
+                readBack = {
+                    method: `.hot-scripts deleted; cp2077.lua.eval ${fn}`,
+                    verdict: "triggered",
+                    detail: `RHT deleted .hot-scripts, so the script reload ran; the definitive read-back is a cp2077.lua.eval of ${fn} (from the mod's dev module). A compile error surfaces as an RHT message box on the game window.`,
+                };
+            }
+        }
+        outTriggers.push({ ...t, readBack });
+    }
+    return { game: "cyberpunk2077", applied: !coldSkip && mode === "apply" && operations.length > 0, triggers: outTriggers, skipped, write };
+}