modwright 0.1.0 → 0.1.2

package/dist/core/project/schema.js

@@ -68,6 +68,7 @@ const buildStepSchema = z.discriminatedUnion("step", [
         .object({
         ...stepBase,
         step: z.literal("zip"),
+        allowOutsideRoot: z.boolean().optional(),
         from: z.string(),
         name: z.string(),
     })
@@ -94,6 +95,7 @@ const buildStepSchema = z.discriminatedUnion("step", [
         .object({
         ...stepBase,
         step: z.literal("wolvenkit-pack"),
+        allowOutsideRoot: z.boolean().optional(),
         from: z.string(),
         out: z.string(),
         verbosity: z.enum(["Minimal", "Normal", "Diagnostic"]).default("Minimal"),
@@ -120,6 +122,7 @@ const buildStepSchema = z.discriminatedUnion("step", [
         .object({
         ...stepBase,
         step: z.literal("divine-create-package"),
+        allowOutsideRoot: z.boolean().optional(),
         from: z.string(),
         out: z.string(),
     })
@@ -137,6 +140,7 @@ const buildStepSchema = z.discriminatedUnion("step", [
         .object({
         ...stepBase,
         step: z.literal("exec"),
+        allowOutsideRoot: z.boolean().optional(),
         command: z.string(),
         args: z.array(z.string()).default([]),
         cwd: z.string().optional(),
@@ -166,6 +170,7 @@ const deployTargetSchema = z
     .object({
     rootId: z.string().min(1),
     from: z.string().min(1),
+    allowOutsideRoot: z.boolean().optional(),
     into: z.string().optional(),
     waitForGameExit: z.boolean().optional(),
     backup: z.boolean().optional(),
@@ -179,6 +184,7 @@ const deployTargetSchema = z
 const junctionSchema = z
     .object({
     linkPath: z.string().min(1),
+    allowOutsideRoot: z.boolean().optional(),
     rootId: z.string().min(1),
     target: z.string().min(1),
 })
@@ -240,6 +246,37 @@ export const modProjectSchema = z
     testPlans: z.array(z.string().min(1)).optional(),
 })
     .strict();
+function checkVariantGates(doc, ctx) {
+    const build = doc.build;
+    if (!build?.steps)
+        return;
+    const known = Object.keys(build.variants ?? {});
+    const knownText = known.length > 0 ? `declared build.variants: ${known.join(", ")}` : "build.variants declares none";
+    build.steps.forEach((step, i) => {
+        if (typeof step === "string")
+            return;
+        const label = step.id ? `"${step.id}"` : `#${i} (${step.step})`;
+        if (step.variant !== undefined && !known.includes(step.variant)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["build", "steps", i, "variant"],
+                message: `step ${label} is gated on variant "${step.variant}", which no build.variants entry declares (${knownText}); it could never run`,
+            });
+        }
+        if (step.step !== "stage")
+            return;
+        step.sources.forEach((entry, j) => {
+            if (typeof entry === "string" || entry.variant === undefined || known.includes(entry.variant))
+                return;
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["build", "steps", i, "sources", j, "variant"],
+                message: `stage step ${label} source entry "${entry.source ?? entry.output}" is gated on variant "${entry.variant}", which no build.variants entry declares (${knownText}); it could never be staged`,
+            });
+        });
+    });
+}
+const modProjectSchemaChecked = modProjectSchema.superRefine((doc, ctx) => checkVariantGates(doc, ctx));
 function formatPath(segments) {
     if (segments.length === 0)
         return "(root)";
@@ -255,7 +292,7 @@ function formatPath(segments) {
     return out;
 }
 export function parseProject(json) {
-    const result = modProjectSchema.safeParse(json);
+    const result = modProjectSchemaChecked.safeParse(json);
     if (!result.success) {
         const lines = result.error.issues.map((issue) => `${formatPath(issue.path)}: ${issue.message}`);
         throw new Error(`Invalid modwright.json:\n${lines.join("\n")}`);

package/dist/core/safety/backup.js

@@ -113,7 +113,7 @@ export class ManifestWriter {
     async addFile(originalAbsPath) {
         const dest = backupDestFor(this.backupDir, originalAbsPath);
         await copyFilePreservingMtime(originalAbsPath, dest);
-        const { sha256, sizeBytes } = await sha256File(originalAbsPath);
+        const { sha256, sizeBytes } = await sha256File(dest);
         const backupPath = path.relative(this.backupDir, dest).split(path.sep).join("/");
         this.entries.push({ originalPath: originalAbsPath, backupPath, sizeBytes, sha256 });
     }
@@ -159,7 +159,7 @@ export class ManifestWriter {
     }
     async flush(now) {
         const manifest = { purpose: this.purpose, time: now.toISOString(), entries: this.entries };
-        await fs.writeFile(path.join(this.backupDir, MANIFEST_FILE), JSON.stringify(manifest, null, 2), "utf8");
+        await writeFileAtomic(path.join(this.backupDir, MANIFEST_FILE), JSON.stringify(manifest, null, 2));
     }
 }
 export async function readManifest(backupDir) {

package/dist/core/safety/execute.js

@@ -1,6 +1,5 @@
 import { promises as fs } from "node:fs";
 import * as path from "node:path";
-import { pathExists } from "../fsutil.js";
 import { userDataDir } from "../home.js";
 import { normalizePlan } from "./plan.js";
 import { isLockError } from "./restore.js";
@@ -41,7 +40,7 @@ async function applyOp(nop, ensureBackup) {
             if (nop.skipEligible)
                 return { op, status: "skipped" };
             let backedUpTo;
-            if (await pathExists(op.to)) {
+            if (await lstatExists(op.to)) {
                 backedUpTo = await (await ensureBackup()).addPath(op.to);
             }
             await copyTreePreservingMtime(op.from, op.to);
@@ -157,8 +156,14 @@ export async function executePlan(plan, options) {
             results.push({ op, status: "failed", error: errorMessage(err) });
         }
     }
+    let manifestError;
     if (manifestWriter?.hasEntries) {
-        await manifestWriter.flush(now());
+        try {
+            await manifestWriter.flush(now());
+        }
+        catch (err) {
+            manifestError = errorMessage(err);
+        }
     }
     else if (backupDir) {
         await fs.rm(backupDir, { recursive: true, force: true }).catch(() => { });
@@ -183,6 +188,9 @@ export async function executePlan(plan, options) {
         operations: results,
         backupDir,
         confidence: options.confidence,
-        next,
+        next: manifestError
+            ? `The operations above ran, but the backup's manifest could not be written (${manifestError}). The replaced files are under ${backupDir}; rollback cannot restore them without a manifest.${next ? ` ${next}` : ""}`
+            : next,
+        ...(manifestError ? { manifestError } : {}),
     };
 }

package/dist/core/safety/restore.js

@@ -2,6 +2,13 @@ import { promises as fs } from "node:fs";
 import * as path from "node:path";
 import { copyFilePreservingMtime, readManifest, sha256File } from "./backup.js";
 import { isDirectory } from "../fsutil.js";
+function outsideConfinement(entries, roots) {
+    const fold = (p) => (process.platform === "win32" ? path.resolve(p).toLowerCase() : path.resolve(p));
+    const folded = roots.map(fold);
+    return entries
+        .map((e) => e.originalPath)
+        .filter((p) => !folded.some((root) => isUnder(root, fold(p))));
+}
 export async function listBackups(backupRoot) {
     let entries;
     try {
@@ -86,6 +93,14 @@ export async function restoreBackup(backupDir, options = {}) {
         if (!("kind" in entry))
             backupFileFor(backupDir, entry.backupPath);
     }
+    if (options.confineTo) {
+        const outside = outsideConfinement(manifest.entries, options.confineTo);
+        if (outside.length > 0) {
+            const shown = outside.slice(0, 5).join(", ") + (outside.length > 5 ? ` and ${outside.length - 5} more` : "");
+            throw new Error(`safety: this backup would write outside the project and the game's mod roots (${shown}); nothing was restored. ` +
+                `Allowed: ${options.confineTo.join(", ")}. If the manifest is yours and the paths are right, pass allowOutsideRoots: true.`);
+        }
+    }
     if (mode === "dry-run") {
         const operations = [];
         for (const entry of manifest.entries) {
@@ -110,6 +125,7 @@ export async function restoreBackup(backupDir, options = {}) {
     const results = [];
     const locked = [];
     let stopped = false;
+    const commonRoot = commonAncestor(manifest.entries.filter((e) => !("kind" in e)).map((e) => path.dirname(e.originalPath)));
     for (const entry of manifest.entries) {
         if ("kind" in entry) {
             const op = { kind: "junction", path: entry.originalPath, target: entry.linkTarget };
@@ -141,6 +157,16 @@ export async function restoreBackup(backupDir, options = {}) {
             if (sha256 !== entry.sha256) {
                 throw new Error(`backup of ${entry.originalPath} is corrupted: manifest says sha256 ${entry.sha256}, file on disk hashes to ${sha256}`);
             }
+            const link = await linkAncestor(entry.originalPath, commonRoot);
+            if (link) {
+                results.push({
+                    op,
+                    status: "failed",
+                    error: `${link} is now a junction/symlink, so restoring ${entry.originalPath} would write through it into ${await fs.realpath(link).catch(() => "its target")}. ` +
+                        `Remove the link first (deploy --deployMode pak --unlink, or by hand) and run the restore again.`,
+                });
+                continue;
+            }
             await copyFilePreservingMtime(src, entry.originalPath);
             results.push({ op, status: "applied" });
         }
@@ -170,3 +196,39 @@ export async function restoreBackup(backupDir, options = {}) {
                 : "An integrity check failed before that file was restored; the backup itself is untouched, so fix the problem and retry."),
     };
 }
+function commonAncestor(dirs) {
+    if (dirs.length === 0)
+        return undefined;
+    let common = path.resolve(dirs[0]);
+    for (const dir of dirs.slice(1)) {
+        let candidate = path.resolve(dir);
+        while (candidate !== common && !isUnder(common, candidate)) {
+            const parent = path.dirname(common);
+            if (parent === common)
+                return undefined;
+            common = parent;
+        }
+    }
+    return common;
+}
+function isUnder(parent, child) {
+    const rel = path.relative(parent, child);
+    return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+}
+async function linkAncestor(file, stopAt) {
+    let dir = path.dirname(path.resolve(file));
+    for (;;) {
+        try {
+            if ((await fs.lstat(dir)).isSymbolicLink())
+                return dir;
+        }
+        catch {
+        }
+        if (stopAt === undefined || dir === stopAt || !isUnder(stopAt, dir))
+            return undefined;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return undefined;
+        dir = parent;
+    }
+}

package/dist/core/text/converters/index.js

@@ -221,7 +221,7 @@ export async function convert(id, sourceAbs, destAbs, options = {}) {
         const plan = {
             purpose: `text convert ${entry.id}: ${path.basename(sourceAbs)} -> ${path.basename(destAbs)}`,
             operations: [planFile(destAbs, content)],
-            backupRoot: path.join(path.dirname(destAbs), ".modwright", "backups"),
+            ...(options.backupRoot ? { backupRoot: options.backupRoot } : {}),
         };
         const writeReport = await executePlan(plan, {
             mode: "apply",

package/dist/core/text/toolchain.js

@@ -1,5 +1,5 @@
 import { locateTool as coreLocateTool, TOOL_SPECS } from "../toolchain/index.js";
-export function defaultLocateTool(projectOverrides, probe = "all") {
+export function defaultLocateTool(projectOverrides, probe = "all", projectTrust) {
     return async (id) => {
         const spec = TOOL_SPECS.find((s) => s.id === id);
         if (!spec) {
@@ -11,6 +11,6 @@ export function defaultLocateTool(projectOverrides, probe = "all") {
                 hint: `"${id}" is not a known tool id in ModWright's toolchain catalog (see core/toolchain/specs.ts).`,
             };
         }
-        return coreLocateTool(spec, { projectOverrides, probe });
+        return coreLocateTool(spec, { projectOverrides, probe, ...(projectTrust ? { projectTrust } : {}) });
     };
 }

package/dist/core/toolchain/locate.js

@@ -1,9 +1,11 @@
 import { spawn } from "node:child_process";
+import { killTree } from "./run.js";
 import { promises as fs } from "node:fs";
 import * as path from "node:path";
 import { StringDecoder } from "node:string_decoder";
 import { pathExists } from "../fsutil.js";
 import { userDataDir } from "../home.js";
+import { trustRefusal } from "../trust.js";
 import { loadUserConfig } from "../userconfig.js";
 import { toolEnvironment } from "./env.js";
 import { TOOL_SPECS } from "./specs.js";
@@ -145,7 +147,7 @@ async function runVersionProbe(execPath, versionArgs, versionPattern) {
             resolve(result);
         };
         const timer = setTimeout(() => {
-            child.kill();
+            killTree(child);
             finish(out);
         }, VERSION_PROBE_TIMEOUT_MS);
         const outDecoder = new StringDecoder("utf8");
@@ -227,6 +229,16 @@ export async function locateTool(spec, options = {}) {
         return found(fromEnv, "env");
     const override = options.projectOverrides?.[spec.id];
     const fromProject = override ? await resolveOverride(override, spec) : undefined;
+    if (fromProject && options.projectTrust && !options.projectTrust.trusted) {
+        return {
+            ...base,
+            found: false,
+            path: fromProject,
+            source: "project",
+            untrusted: true,
+            hint: trustRefusal(options.projectTrust.root, `its modwright.json points ${spec.id} at ${fromProject}`),
+        };
+    }
     if (fromProject)
         return found(fromProject, "project");
     const userTools = options.userTools === undefined ? (await loadUserConfig()).config.tools : options.userTools;

package/dist/core/toolchain/run.js

@@ -3,6 +3,7 @@ import { promises as fs } from "node:fs";
 import * as path from "node:path";
 import { StringDecoder } from "node:string_decoder";
 import { toolEnvironment } from "./env.js";
+import { DEFAULT_TOOL_TIMEOUT_MS } from "./types.js";
 const MAX_CAPTURE_BYTES = 1_000_000;
 const TRUNCATION_NOTE = "\n...[truncated]";
 export function assertAbsolute(paths) {
@@ -86,7 +87,7 @@ export function batchFileArgv(file, args, env = process.env) {
 export function isBatchFile(p) {
     return /\.(bat|cmd)$/i.test(p);
 }
-function killTree(child) {
+export function killTree(child) {
     if (process.platform === "win32" && child.pid !== undefined) {
         try {
             spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], { stdio: "ignore", windowsHide: true }).on("error", () => child.kill());
@@ -151,7 +152,8 @@ export async function runTool(location, options) {
             resolve(spawnFailed(location, command, args, started, err));
             return;
         }
-        const timer = options.timeoutMs
+        const timeoutMs = options.timeoutMs ?? DEFAULT_TOOL_TIMEOUT_MS;
+        const timer = timeoutMs
             ? setTimeout(() => {
                 if (settled)
                     return;
@@ -171,10 +173,10 @@ export async function runTool(location, options) {
                     stderrTruncated: stderrTruncated.value,
                     error: {
                         code: "timeout",
-                        message: `${location.label} did not finish within ${options.timeoutMs}ms.`,
+                        message: `${location.label} did not finish within ${timeoutMs}ms.`,
                     },
                 });
-            }, options.timeoutMs)
+            }, timeoutMs)
             : undefined;
         const cap = options.maxCaptureBytes ?? MAX_CAPTURE_BYTES;
         const stdoutDecoder = new StringDecoder("utf8");

package/dist/core/toolchain/types.js

@@ -1 +1 @@
-export {};
+export const DEFAULT_TOOL_TIMEOUT_MS = 30 * 60 * 1000;

package/dist/core/trust.js

@@ -0,0 +1,105 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { z } from "zod";
+import { userConfigDir, userDataDir } from "./home.js";
+import { planFile, planMkdir } from "./safety/index.js";
+export const TRUST_SCHEMA_VERSION = 1;
+export const TRUST_ALL_ENV = "MODWRIGHT_TRUST_ALL";
+const trustEntrySchema = z.object({
+    root: z.string().min(1),
+    name: z.string().optional(),
+    trustedAt: z.string().optional(),
+});
+const trustFileSchema = z.object({
+    schemaVersion: z.literal(TRUST_SCHEMA_VERSION),
+    projects: z.record(trustEntrySchema).default({}),
+});
+export function trustFilePath() {
+    return path.join(userConfigDir(), "trusted-projects.json");
+}
+export function trustKey(root, platform = process.platform) {
+    const resolved = path.resolve(root).replace(/[\\/]+$/, "");
+    return platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+export async function loadTrust(file = trustFilePath()) {
+    const empty = { schemaVersion: TRUST_SCHEMA_VERSION, projects: {} };
+    let text;
+    try {
+        text = await fs.readFile(file, "utf8");
+    }
+    catch (error) {
+        const missing = error.code === "ENOENT";
+        return { trust: empty, file, exists: !missing, problems: missing ? [] : [`${file} could not be read: ${error.message}`] };
+    }
+    let raw;
+    try {
+        raw = JSON.parse(text.replace(/^/, ""));
+    }
+    catch (error) {
+        return { trust: empty, file, exists: true, problems: [`${file} is not valid JSON (${error.message}); no project is trusted until it is fixed.`] };
+    }
+    const parsed = trustFileSchema.safeParse(raw);
+    if (!parsed.success) {
+        const issues = parsed.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ");
+        return { trust: empty, file, exists: true, problems: [`${file} does not match schemaVersion ${TRUST_SCHEMA_VERSION} (${issues}); no project is trusted until it is fixed.`] };
+    }
+    return { trust: parsed.data, file, exists: true, problems: [] };
+}
+export async function isProjectTrusted(root, options = {}) {
+    if ((options.env ?? process.env)[TRUST_ALL_ENV] === "1")
+        return true;
+    const loaded = await loadTrust(options.file);
+    return trustKey(root) in loaded.trust.projects;
+}
+export function projectTrustNeeds(project) {
+    const toolchain = Object.keys(project.toolchain ?? {});
+    const exec = [];
+    (project.build?.steps ?? []).forEach((step, i) => {
+        if (typeof step === "string" || step.step !== "exec")
+            return;
+        exec.push(step.id ? `"${step.id}" (${step.command})` : `#${i} (${step.command})`);
+    });
+    return { toolchain, exec };
+}
+export function trustRefusal(root, what) {
+    return (`${root} is not a trusted project, and ${what}. ModWright runs a project's own executables and commands only after ` +
+        `you trust it once on this machine. Read its modwright.json first, then: check_toolchain action=trust projectPath=${JSON.stringify(root)} mode=apply. ` +
+        `(${TRUST_ALL_ENV}=1 trusts every project, for CI.)`);
+}
+export function describeNeeds(needs) {
+    const parts = [];
+    if (needs.exec.length > 0)
+        parts.push(`its build runs exec step(s) ${needs.exec.join(", ")}`);
+    if (needs.toolchain.length > 0)
+        parts.push(`its modwright.json overrides the tool path(s) for ${needs.toolchain.join(", ")}`);
+    return parts.length > 0 ? parts.join("; ") : undefined;
+}
+export async function planTrust(action, root, name, options = {}) {
+    const file = options.file ?? trustFilePath();
+    const loaded = await loadTrust(file);
+    if (loaded.problems.length > 0)
+        return { ok: false, error: `${loaded.problems.join(" ")} Fix or remove ${file} before changing it through ModWright.` };
+    const key = trustKey(root);
+    const previous = loaded.trust.projects[key];
+    const write = (trust, purpose) => ({
+        purpose,
+        operations: [planMkdir(path.dirname(file)), planFile(file, JSON.stringify(trust, null, 2) + "\n")],
+        backupRoot: path.join(userDataDir(), "backups"),
+    });
+    if (action === "untrust") {
+        if (!previous)
+            return { ok: false, error: `${root} is not in ${file}; nothing to untrust.` };
+        const { [key]: _dropped, ...rest } = loaded.trust.projects;
+        return { ok: true, action, root: path.resolve(root), file, plan: write({ ...loaded.trust, projects: rest }, `stop trusting ${root}`), previous };
+    }
+    const entry = { root: path.resolve(root), ...(name ? { name } : {}), trustedAt: (options.now ?? (() => new Date()))().toISOString() };
+    return {
+        ok: true,
+        action,
+        root: entry.root,
+        file,
+        plan: write({ ...loaded.trust, projects: { ...loaded.trust.projects, [key]: entry } }, `trust ${root} to run its toolchain overrides and exec steps`),
+        entry,
+        ...(previous ? { previous } : {}),
+    };
+}

package/dist/index.js

@@ -8,7 +8,7 @@ const here = path.dirname(fileURLToPath(import.meta.url));
 const SERVER_ENTRY = process.env.MODWRIGHT_SERVER_ENTRY ?? path.join(here, "server.js");
 const STAMP_FILE = process.env.MODWRIGHT_BUILD_STAMP ?? path.join(here, ".build-stamp");
 const STAMP_POLL_MS = Number(process.env.MODWRIGHT_STAMP_POLL_MS ?? 2000);
-const RETIRE_GRACE_MS = Number(process.env.MODWRIGHT_RETIRE_GRACE_MS ?? 30_000);
+const RETIRE_GRACE_MS = Number(process.env.MODWRIGHT_RETIRE_GRACE_MS ?? 15 * 60_000);
 const INIT_TIMEOUT_MS = 20_000;
 const RESTART_BASE_MS = Number(process.env.MODWRIGHT_RESTART_BASE_MS ?? 500);
 const RESTART_MAX_DELAY_MS = 30_000;
@@ -68,15 +68,31 @@ class ServerProcess {
         this.child.on("exit", () => {
             this.exited = true;
         });
+        this.child.stdin.on("error", (err) => {
+            this.stdinBroken = true;
+            log(`server generation ${this.generation}: stdin ${err.code ?? err.message}; treating it as gone`);
+        });
+        this.child.on("error", (err) => {
+            this.exited = true;
+            log(`server generation ${this.generation}: ${err.message}`);
+        });
     }
+    stdinBroken = false;
     onMessage(listener) {
         this.listeners.add(listener);
         return () => this.listeners.delete(listener);
     }
     send(raw) {
-        if (this.exited || !this.child.stdin || this.child.stdin.destroyed)
+        if (this.exited || this.stdinBroken || !this.child.stdin || this.child.stdin.destroyed)
             return false;
-        this.child.stdin.write(`${raw}\n`);
+        try {
+            this.child.stdin.write(`${raw}\n`);
+        }
+        catch (err) {
+            this.stdinBroken = true;
+            log(`server generation ${this.generation}: write failed (${err.message}); treating it as gone`);
+            return false;
+        }
         return true;
     }
     kill() {
@@ -157,7 +173,7 @@ class Supervisor {
                 }
             }
         }
-        if (!active || active.exited) {
+        const answerNotRunning = () => {
             if (msg.id !== undefined && msg.id !== null && msg.method !== undefined) {
                 const response = {
                     jsonrpc: "2.0",
@@ -171,14 +187,23 @@ class Supervisor {
                 };
                 process.stdout.write(`${JSON.stringify(response)}\n`);
             }
+        };
+        if (!active || active.exited) {
+            answerNotRunning();
             return;
         }
-        if (msg.id !== undefined && msg.id !== null && msg.method !== undefined) {
-            const key = idKey(msg.id);
+        const key = msg.id !== undefined && msg.id !== null && msg.method !== undefined ? idKey(msg.id) : undefined;
+        if (key !== undefined) {
             this.routes.set(key, active);
             active.pending.add(key);
         }
-        active.send(raw);
+        if (!active.send(raw)) {
+            if (key !== undefined) {
+                this.routes.delete(key);
+                active.pending.delete(key);
+            }
+            answerNotRunning();
+        }
     }
     fromServer(server, msg, raw) {
         if (msg.id !== undefined && msg.id !== null && msg.method === undefined) {
@@ -285,6 +310,7 @@ class Supervisor {
             }
             if (this.initializedSeen) {
                 process.stdout.write(`${JSON.stringify({ jsonrpc: "2.0", method: "notifications/tools/list_changed" })}\n`);
+                process.stdout.write(`${JSON.stringify({ jsonrpc: "2.0", method: "notifications/prompts/list_changed" })}\n`);
             }
         }
         finally {