@thomasfarineau/anvil 0.0.1 → 0.0.3

package/dist/cli.cjs

@@ -0,0 +1,554 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+// package.json
+var require_package = __commonJS((exports2, module2) => {
+  module2.exports = {
+    name: "@thomasfarineau/anvil",
+    version: "0.0.3",
+    description: "Zero-config Minecraft launcher framework built on Tauri",
+    keywords: [
+      "launcher",
+      "minecraft",
+      "tauri"
+    ],
+    license: "MIT",
+    bin: {
+      anvil: "dist/cli.cjs",
+      "create-anvil": "dist/cli.cjs"
+    },
+    files: [
+      "dist/",
+      "src/template/",
+      "src/rust/",
+      "src/client/"
+    ],
+    type: "module",
+    scripts: {
+      build: "bun build ./src/cli/index.ts --target node --format cjs --packages external --outfile dist/cli.cjs",
+      prepack: "bun run build",
+      test: "bun test",
+      lint: "oxlint .",
+      format: "oxfmt .",
+      "format:check": "oxfmt --check .",
+      check: "bun run build && bun run lint && bun run format:check && bun test",
+      "docs:dev": "vitepress dev docs",
+      "docs:build": "vitepress build docs",
+      "docs:preview": "vitepress preview docs"
+    },
+    dependencies: {
+      "@clack/prompts": "^1.6.0",
+      "@tauri-apps/cli": "^2",
+      commander: "^15.0.0",
+      sharp: "^0.33.0"
+    },
+    devDependencies: {
+      "@types/node": "^26.1.0",
+      bun: "^1.3.14",
+      oxfmt: "^0.57.0",
+      oxlint: "^1.72.0",
+      vitepress: "^1.6.4"
+    },
+    engines: {
+      node: ">=18"
+    }
+  };
+});
+
+// src/cli/index.ts
+var import_commander = require("commander");
+
+// src/cli/templates.ts
+var { version: VERSION, name: PKG_NAME } = require_package();
+var TEMPLATES = {
+  "vanilla-js": {
+    label: "Vanilla (no build step)",
+    vite: false,
+    dependencies: {},
+    devDependencies: {}
+  },
+  "vanilla-ts": {
+    label: "Vanilla + TypeScript",
+    vite: true,
+    dependencies: {},
+    devDependencies: { typescript: "^6", vite: "^8" }
+  },
+  "react-js": {
+    label: "React",
+    vite: true,
+    dependencies: { react: "^19", "react-dom": "^19" },
+    devDependencies: { "@vitejs/plugin-react": "^6", vite: "^8" }
+  },
+  "react-ts": {
+    label: "React + TypeScript",
+    vite: true,
+    dependencies: { react: "^19", "react-dom": "^19" },
+    devDependencies: {
+      "@types/react": "^19",
+      "@types/react-dom": "^19",
+      "@vitejs/plugin-react": "^6",
+      typescript: "^6",
+      vite: "^8"
+    }
+  },
+  "vue-js": {
+    label: "Vue",
+    vite: true,
+    dependencies: { vue: "^3.5" },
+    devDependencies: { "@vitejs/plugin-vue": "^6", vite: "^8" }
+  },
+  "vue-ts": {
+    label: "Vue + TypeScript",
+    vite: true,
+    dependencies: { vue: "^3.5" },
+    devDependencies: {
+      "@vitejs/plugin-vue": "^6",
+      typescript: "^6",
+      vite: "^8"
+    }
+  },
+  "solid-js": {
+    label: "Solid",
+    vite: true,
+    dependencies: { "solid-js": "^1.9" },
+    devDependencies: { "vite-plugin-solid": "^2", vite: "^8" }
+  },
+  "solid-ts": {
+    label: "Solid + TypeScript",
+    vite: true,
+    dependencies: { "solid-js": "^1.9" },
+    devDependencies: {
+      "vite-plugin-solid": "^2",
+      typescript: "^6",
+      vite: "^8"
+    }
+  }
+};
+async function resolveTemplate(flags) {
+  if (flags.template) {
+    if (!TEMPLATES[flags.template]) {
+      process.stderr.write(`
+Error: unknown template '${flags.template}'.
+Available: ${Object.keys(TEMPLATES).join(", ")}
+
+`);
+      process.exit(1);
+    }
+    return flags.template;
+  }
+  if (flags.yes || !process.stdin.isTTY || !process.stdout.isTTY) {
+    return "vanilla-js";
+  }
+  const clack = require("@clack/prompts");
+  clack.intro(`${PKG_NAME} v${VERSION}`);
+  const lang = await clack.select({
+    message: "Which language?",
+    options: [
+      { value: "ts", label: "TypeScript" },
+      { value: "js", label: "JavaScript" }
+    ]
+  });
+  if (clack.isCancel(lang)) {
+    clack.cancel("Aborted.");
+    process.exit(1);
+  }
+  const fw = await clack.select({
+    message: "Which framework?",
+    options: [
+      { value: "vanilla", label: "Vanilla", hint: "no framework" },
+      { value: "react", label: "React" },
+      { value: "vue", label: "Vue" },
+      { value: "solid", label: "Solid" }
+    ]
+  });
+  if (clack.isCancel(fw)) {
+    clack.cancel("Aborted.");
+    process.exit(1);
+  }
+  const templateId = `${fw}-${lang}`;
+  clack.outro(`Template: ${templateId}`);
+  return templateId;
+}
+
+// src/cli/scaffold.ts
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var __dirname = "/home/runner/work/anvil/anvil/src/cli";
+function resolvePkgDir() {
+  const fromDist = import_path.default.join(__dirname, "..", "src");
+  if (import_fs.default.existsSync(import_path.default.join(fromDist, "template")))
+    return fromDist;
+  return import_path.default.join(__dirname, "..");
+}
+var PKG_DIR = resolvePkgDir();
+var pkgJson = require_package();
+var VERSION2 = pkgJson.version;
+var PKG_NAME2 = pkgJson.name;
+function copyDir(src, dest) {
+  import_fs.default.mkdirSync(dest, { recursive: true });
+  for (const entry of import_fs.default.readdirSync(src, { withFileTypes: true })) {
+    const destName = entry.name === "_gitignore" ? ".gitignore" : entry.name;
+    const s = import_path.default.join(src, entry.name);
+    const d = import_path.default.join(dest, destName);
+    if (entry.isDirectory())
+      copyDir(s, d);
+    else
+      import_fs.default.copyFileSync(s, d);
+  }
+}
+function renderTemplate(filePath, name, identifier) {
+  const safeId = name.replace(/-/g, "_");
+  const id = identifier || `com.launcher.${safeId}`;
+  return import_fs.default.readFileSync(filePath, "utf8").replace(/\{\{name\}\}/g, name).replace(/\{\{safe_id\}\}/g, safeId).replace(/\{\{identifier\}\}/g, id);
+}
+function deriveName(dir) {
+  return import_path.default.basename(dir).toLowerCase().replace(/[^a-z0-9_-]/g, "-").replace(/^-+|-+$/g, "") || "my-launcher";
+}
+function readConfig(projectDir) {
+  const configPath = import_path.default.join(projectDir, "config.json");
+  if (!import_fs.default.existsSync(configPath))
+    return {};
+  try {
+    return JSON.parse(import_fs.default.readFileSync(configPath, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function readIdentifier(projectDir) {
+  return readConfig(projectDir).identifier || "";
+}
+function readConfigField(projectDir, field) {
+  return readConfig(projectDir)[field] || "";
+}
+function usesVite(projectDir) {
+  return ["vite.config.js", "vite.config.ts", "vite.config.mjs"].some((f) => import_fs.default.existsSync(import_path.default.join(projectDir, f)));
+}
+function scaffoldTauri(projectDir, name) {
+  const srcTauri = import_path.default.join(projectDir, "src-anvil");
+  const identifier = readIdentifier(projectDir);
+  copyDir(import_path.default.join(PKG_DIR, "rust"), srcTauri);
+  import_fs.default.writeFileSync(import_path.default.join(srcTauri, "Cargo.toml"), renderTemplate(import_path.default.join(PKG_DIR, "rust", "Cargo.toml"), name, identifier));
+  const conf = JSON.parse(renderTemplate(import_path.default.join(PKG_DIR, "template", "tauri.conf.json"), name, identifier));
+  if (usesVite(projectDir)) {
+    conf.build = {
+      beforeDevCommand: "npm run dev:ui",
+      beforeBuildCommand: "npm run build:ui",
+      devUrl: "http://localhost:5173",
+      frontendDist: "../dist"
+    };
+  }
+  import_fs.default.writeFileSync(import_path.default.join(srcTauri, "tauri.conf.json"), JSON.stringify(conf, null, 2) + `
+`);
+  copyDir(import_path.default.join(PKG_DIR, "template", "capabilities"), import_path.default.join(srcTauri, "capabilities"));
+  copyDir(import_path.default.join(PKG_DIR, "template", "icons"), import_path.default.join(srcTauri, "icons"));
+  import_fs.default.writeFileSync(import_path.default.join(srcTauri, ".lc-version"), VERSION2);
+}
+function copyUserFiles(projectDir, templateId = "vanilla-js") {
+  import_fs.default.mkdirSync(projectDir, { recursive: true });
+  for (const [src, dest] of [
+    [
+      import_path.default.join(PKG_DIR, "template", "config.json"),
+      import_path.default.join(projectDir, "config.json")
+    ],
+    [
+      import_path.default.join(PKG_DIR, "template", "_gitignore"),
+      import_path.default.join(projectDir, ".gitignore")
+    ]
+  ]) {
+    if (!import_fs.default.existsSync(dest))
+      import_fs.default.copyFileSync(src, dest);
+  }
+  const destDir = import_path.default.join(projectDir, "src");
+  if (import_fs.default.existsSync(destDir))
+    return;
+  copyDir(import_path.default.join(PKG_DIR, "template", "frontends", templateId), projectDir);
+  for (const f of ["api.js", "logo.svg", "style.css"]) {
+    import_fs.default.copyFileSync(import_path.default.join(PKG_DIR, "template", "shared", f), import_path.default.join(destDir, f));
+  }
+  if (templateId.endsWith("-ts")) {
+    import_fs.default.copyFileSync(import_path.default.join(PKG_DIR, "client", "index.d.ts"), import_path.default.join(destDir, "api.d.ts"));
+  }
+}
+function writePackageJson(projectDir, name, templateId = "vanilla-js") {
+  const pkgPath = import_path.default.join(projectDir, "package.json");
+  if (import_fs.default.existsSync(pkgPath))
+    return;
+  const tpl = TEMPLATES[templateId];
+  const pkg = {
+    name,
+    version: "1.0.0",
+    private: true,
+    type: "module",
+    scripts: { dev: "anvil dev", build: "anvil build" },
+    devDependencies: {
+      [PKG_NAME2]: `^${VERSION2}`,
+      ...tpl.devDependencies
+    }
+  };
+  if (tpl.vite) {
+    pkg.scripts["dev:ui"] = "vite";
+    pkg.scripts["build:ui"] = "vite build";
+  }
+  if (Object.keys(tpl.dependencies).length > 0) {
+    pkg.dependencies = tpl.dependencies;
+  }
+  import_fs.default.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + `
+`);
+}
+
+// src/cli/commands.ts
+var import_fs3 = __toESM(require("fs"));
+var import_path3 = __toESM(require("path"));
+
+// src/cli/icons.ts
+var import_fs2 = __toESM(require("fs"));
+var import_path2 = __toESM(require("path"));
+var import_crypto = __toESM(require("crypto"));
+var import_child_process = require("child_process");
+function findBin(name, projectDir) {
+  const candidates = [
+    import_path2.default.join(projectDir, "node_modules", ".bin", name),
+    import_path2.default.join(PKG_DIR, "..", "node_modules", ".bin", name)
+  ];
+  for (const bin of candidates) {
+    if (import_fs2.default.existsSync(bin) || import_fs2.default.existsSync(bin + ".exe"))
+      return bin;
+  }
+  return null;
+}
+function generateIcons(projectDir, { force = false } = {}) {
+  if (process.env.ANVIL_SKIP_ICONS === "1" && !force)
+    return;
+  const config = readConfig(projectDir);
+  if (!config.logo) {
+    if (force) {
+      console.warn('  No "logo" field in config.json — nothing to generate.');
+    }
+    return;
+  }
+  const logo = config.logo;
+  const logoPath = import_path2.default.join(projectDir, "src", logo);
+  if (!import_fs2.default.existsSync(logoPath)) {
+    console.warn(`  Warning: logo not found at src/${logo}, skipping icon generation.`);
+    return;
+  }
+  const isSvg = logo.toLowerCase().endsWith(".svg");
+  const isPng = logo.toLowerCase().endsWith(".png");
+  if (!isSvg && !isPng) {
+    console.warn(`  Warning: icon generation requires a .png or .svg logo (got ${logo}), skipping.`);
+    return;
+  }
+  const hashFile = import_path2.default.join(projectDir, "src-anvil", ".logo-hash");
+  const hash = import_crypto.default.createHash("sha256").update(import_fs2.default.readFileSync(logoPath)).digest("hex");
+  if (!force && import_fs2.default.existsSync(hashFile)) {
+    if (import_fs2.default.readFileSync(hashFile, "utf8").trim() === hash)
+      return;
+  }
+  const bin = findBin("tauri", projectDir);
+  if (!bin) {
+    console.warn("  Warning: @tauri-apps/cli not found, skipping icon generation.");
+    return;
+  }
+  let iconSrc = logoPath;
+  let tmpPng = null;
+  if (isSvg) {
+    tmpPng = logoPath.replace(/\.svg$/i, ".tmp.png");
+    console.log(`  Converting src/${logo} to PNG via sharp...`);
+    const sharpBin = require.resolve("sharp");
+    const script = [
+      `const sharp = require(${JSON.stringify(sharpBin)});`,
+      `sharp(${JSON.stringify(logoPath)}, { density: 300 })`,
+      `  .resize(1024, 1024).png()`,
+      `  .toFile(${JSON.stringify(tmpPng)})`,
+      `  .then(() => process.exit(0))`,
+      `  .catch(e => { process.stderr.write(String(e) + '\\n'); process.exit(1); });`
+    ].join(`
+`);
+    const r2 = import_child_process.spawnSync(process.execPath, ["-e", script], { stdio: "inherit" });
+    if (r2.status !== 0) {
+      console.warn("  Warning: SVG→PNG conversion failed, skipping icon generation.");
+      return;
+    }
+    iconSrc = tmpPng;
+  }
+  console.log(`  Generating app icons...`);
+  const r = import_child_process.spawnSync(bin, ["icon", "--output", "icons", import_path2.default.resolve(iconSrc)], {
+    stdio: "inherit",
+    shell: process.platform === "win32",
+    cwd: import_path2.default.join(projectDir, "src-anvil")
+  });
+  if (tmpPng) {
+    try {
+      import_fs2.default.unlinkSync(tmpPng);
+    } catch {}
+  }
+  if (r.status === 0) {
+    import_fs2.default.writeFileSync(hashFile, hash + `
+`);
+    console.log("  App icons updated from " + logo);
+  } else {
+    console.warn("  Warning: icon generation failed.");
+  }
+}
+
+// src/cli/commands.ts
+async function create(target, flags) {
+  const projectDir = import_path3.default.resolve(target);
+  const name = deriveName(projectDir);
+  if (import_fs3.default.existsSync(projectDir)) {
+    const entries = import_fs3.default.readdirSync(projectDir).filter((e) => e !== ".git");
+    if (entries.length > 0) {
+      process.stderr.write(`
+Error: '${target}' already exists and is not empty.
+
+`);
+      process.exit(1);
+    }
+  }
+  const templateId = await resolveTemplate(flags);
+  console.log(`
+Creating ${PKG_NAME2} project: ${name} (${templateId})
+`);
+  copyUserFiles(projectDir, templateId);
+  writePackageJson(projectDir, name, templateId);
+  scaffoldTauri(projectDir, name);
+  generateIcons(projectDir);
+  const cdLine = target !== "." ? `  cd ${target}
+` : "";
+  console.log(`Done!
+
+${cdLine}  npm install
+  # Edit config.json and src/
+  npm run dev
+`);
+}
+function init() {
+  const projectDir = process.cwd();
+  const name = deriveName(projectDir);
+  console.log(`
+Initializing ${PKG_NAME2} in: ${projectDir}
+`);
+  copyUserFiles(projectDir);
+  scaffoldTauri(projectDir, name);
+  generateIcons(projectDir);
+  const pkgPath = import_path3.default.join(projectDir, "package.json");
+  if (import_fs3.default.existsSync(pkgPath)) {
+    const pkg = JSON.parse(import_fs3.default.readFileSync(pkgPath, "utf8"));
+    pkg.scripts = { dev: "anvil dev", build: "anvil build", ...pkg.scripts };
+    import_fs3.default.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + `
+`);
+    console.log("Updated package.json");
+  } else {
+    writePackageJson(projectDir, name);
+  }
+  console.log(`
+Done!
+
+  npm install
+  npm run dev
+`);
+}
+function update() {
+  const projectDir = process.cwd();
+  const srcTauri = import_path3.default.join(projectDir, "src-anvil");
+  if (!import_fs3.default.existsSync(srcTauri)) {
+    process.stderr.write(`
+No src-anvil/ found. Run this from the root of a ${PKG_NAME2} project.
+
+`);
+    process.exit(1);
+  }
+  import_fs3.default.copyFileSync(import_path3.default.join(PKG_DIR, "rust", "src", "lib.rs"), import_path3.default.join(srcTauri, "src", "lib.rs"));
+  const srcDir = import_path3.default.join(projectDir, "src");
+  if (import_fs3.default.existsSync(srcDir)) {
+    import_fs3.default.copyFileSync(import_path3.default.join(PKG_DIR, "template", "shared", "api.js"), import_path3.default.join(srcDir, "api.js"));
+    if (import_fs3.default.existsSync(import_path3.default.join(srcDir, "api.d.ts"))) {
+      import_fs3.default.copyFileSync(import_path3.default.join(PKG_DIR, "client", "index.d.ts"), import_path3.default.join(srcDir, "api.d.ts"));
+    }
+  }
+  import_fs3.default.writeFileSync(import_path3.default.join(srcTauri, ".lc-version"), VERSION2);
+  console.log(`
+Updated to ${PKG_NAME2}@${VERSION2}
+`);
+}
+
+// src/cli/tauri.ts
+var import_fs4 = __toESM(require("fs"));
+var import_path4 = __toESM(require("path"));
+var import_child_process2 = require("child_process");
+function runTauri(tauriCmd) {
+  const projectDir = process.cwd();
+  const srcTauri = import_path4.default.join(projectDir, "src-anvil");
+  if (!import_fs4.default.existsSync(srcTauri)) {
+    console.log(`
+No src-anvil/ found — running anvil init first...
+`);
+    init();
+  }
+  generateIcons(projectDir);
+  const bin = findBin("tauri", projectDir);
+  if (!bin) {
+    process.stderr.write(`
+@tauri-apps/cli not found. Try reinstalling ${PKG_NAME2}.
+
+`);
+    process.exit(1);
+  }
+  const env = { ...process.env };
+  const targetDir = readConfigField(projectDir, "target");
+  if (targetDir)
+    env.CARGO_TARGET_DIR = import_path4.default.resolve(projectDir, targetDir);
+  const result = import_child_process2.spawnSync(bin, [tauriCmd], {
+    stdio: "inherit",
+    shell: process.platform === "win32",
+    cwd: import_path4.default.join(projectDir, "src-anvil"),
+    env
+  });
+  process.exit(result.status ?? 1);
+}
+
+// src/cli/index.ts
+var program = new import_commander.Command;
+program.name("anvil").description("Zero-config Minecraft launcher framework built on Tauri").version(`${PKG_NAME2}@${VERSION2}`, "-v, --version");
+program.command("create [name]", { isDefault: true }).description("Scaffold a new project (interactive)").option("-t, --template <id>", `skip prompts (${Object.keys(TEMPLATES).join(", ")})`).option("-y, --yes", "skip prompts and use the default (vanilla-js)").action((name, opts) => create(name || ".", opts));
+program.command("init").description("Initialize anvil in the current folder").action(init);
+program.command("dev").description("Start the launcher in development mode").action(() => runTauri("dev"));
+program.command("build").description("Compile the launcher for distribution").action(() => runTauri("build"));
+program.command("update").description("Update the Rust backend and api.js to the current version").action(update);
+program.command("icons").description("Regenerate app icons from the logo set in config.json").action(() => generateIcons(process.cwd(), { force: true }));
+program.parseAsync().catch((e) => {
+  process.stderr.write(`
+Error: ${e?.message ?? e}
+`);
+  process.exit(1);
+});

package/package.json

@@ -1,37 +1,50 @@
-{
-  "name": "@thomasfarineau/anvil",
-  "version": "0.0.1",
-  "description": "Zero-config Minecraft launcher framework built on Tauri",
-  "keywords": [
-    "launcher",
-    "minecraft",
-    "tauri"
-  ],
-  "license": "MIT",
-  "bin": {
-    "anvil": "src/cli.cjs",
-    "create-anvil": "src/cli.cjs"
-  },
-  "files": [
-    "src/"
-  ],
-  "type": "module",
-  "scripts": {
-    "test": "bun test",
-    "lint": "oxlint .",
-    "format": "oxfmt .",
-    "check": "bun run lint && bun run format"
-  },
-  "dependencies": {
-    "@tauri-apps/cli": "^2",
-    "sharp": "^0.33.0"
-  },
-  "devDependencies": {
-    "@types/node": "^26.1.0",
-    "oxfmt": "^0.57.0",
-    "oxlint": "^1.72.0"
-  },
-  "engines": {
-    "node": ">=18"
-  }
-}
+{
+  "name": "@thomasfarineau/anvil",
+  "version": "0.0.3",
+  "description": "Zero-config Minecraft launcher framework built on Tauri",
+  "keywords": [
+    "launcher",
+    "minecraft",
+    "tauri"
+  ],
+  "license": "MIT",
+  "bin": {
+    "anvil": "dist/cli.cjs",
+    "create-anvil": "dist/cli.cjs"
+  },
+  "files": [
+    "dist/",
+    "src/template/",
+    "src/rust/",
+    "src/client/"
+  ],
+  "type": "module",
+  "scripts": {
+    "build": "bun build ./src/cli/index.ts --target node --format cjs --packages external --outfile dist/cli.cjs",
+    "prepack": "bun run build",
+    "test": "bun test",
+    "lint": "oxlint .",
+    "format": "oxfmt .",
+    "format:check": "oxfmt --check .",
+    "check": "bun run build && bun run lint && bun run format:check && bun test",
+    "docs:dev": "vitepress dev docs",
+    "docs:build": "vitepress build docs",
+    "docs:preview": "vitepress preview docs"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.6.0",
+    "@tauri-apps/cli": "^2",
+    "commander": "^15.0.0",
+    "sharp": "^0.33.0"
+  },
+  "devDependencies": {
+    "@types/node": "^26.1.0",
+    "bun": "^1.3.14",
+    "oxfmt": "^0.57.0",
+    "oxlint": "^1.72.0",
+    "vitepress": "^1.6.4"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/client/config.schema.json

@@ -10,7 +10,7 @@
     "$schema": {
       "type": "string",
       "description": "JSON schema URL for validation",
-      "default": "./node_modules/anvil/src/client/config.schema.json"
+      "default": "./node_modules/@thomasfarineau/anvil/src/client/config.schema.json"
     },
     "identifier": {
       "type": "string",
@@ -105,6 +105,29 @@
             "maximum": 65535,
             "description": "Server port",
             "default": 25565
+          },
+          "mods": {
+            "type": "array",
+            "description": "Mods downloaded into this instance's mods/ folder during setup",
+            "items": {
+              "type": "object",
+              "required": ["url"],
+              "additionalProperties": false,
+              "properties": {
+                "name": {
+                  "type": "string",
+                  "description": "Display name of the mod"
+                },
+                "url": {
+                  "type": "string",
+                  "description": "Direct download URL of the mod .jar"
+                },
+                "file_name": {
+                  "type": "string",
+                  "description": "Target file name in mods/ (defaults to the URL basename)"
+                }
+              }
+            }
           }
         }
       }