sandstone-cli 2.1.2 → 2.2.0

package/lib/create.js

@@ -5680,12 +5680,12 @@ var {
 import figlet from "figlet";
 
 // src/version.ts
-var CLI_VERSION = "2.1.2";
+var CLI_VERSION = "2.2.0";
 
 // src/commands/create.ts
 var import_semver = __toESM(require_semver2(), 1);
 var import_fs_extra = __toESM(require_lib(), 1);
-import path2 from "path";
+import path5 from "path";
 
 // node_modules/chalk/source/vendor/ansi-styles/index.js
 var ANSI_BACKGROUND_OFFSET = 10;
@@ -6410,6 +6410,298 @@ function getWorldsList(clientPath) {
   return fs.readdirSync(savesPath, { withFileTypes: true }).filter((f) => f.isDirectory).map((f) => f.name);
 }
 
+// src/launchers/registry.ts
+var providers = new Map;
+function registerProvider(provider) {
+  providers.set(provider.type, provider);
+}
+function getProviders() {
+  return Array.from(providers.values());
+}
+async function discoverAllInstances() {
+  const result = {
+    instances: [],
+    errors: new Map
+  };
+  const discoveries = await Promise.allSettled(getProviders().map(async (provider) => {
+    const instances = await provider.discoverInstances();
+    return { type: provider.type, instances };
+  }));
+  for (const discovery of discoveries) {
+    if (discovery.status === "fulfilled") {
+      result.instances.push(...discovery.value.instances);
+    } else {
+      const error = discovery.reason;
+      console.error("Discovery error:", error.message);
+    }
+  }
+  return result;
+}
+// src/launchers/providers/vanilla.ts
+import fs2 from "fs";
+import path2 from "path";
+import os3 from "os";
+function getVanillaPath() {
+  let mcPath;
+  switch (os3.platform()) {
+    case "win32":
+      mcPath = path2.join(os3.homedir(), "AppData/Roaming/.minecraft");
+      break;
+    case "darwin":
+      mcPath = path2.join(os3.homedir(), "Library/Application Support/minecraft");
+      break;
+    case "linux":
+    default:
+      mcPath = path2.join(os3.homedir(), ".minecraft");
+      break;
+  }
+  return fs2.existsSync(mcPath) ? mcPath : null;
+}
+var vanillaProvider = {
+  type: "vanilla",
+  displayName: "Vanilla Minecraft",
+  async isInstalled() {
+    return getVanillaPath() !== null;
+  },
+  getDataPath() {
+    return getVanillaPath();
+  },
+  async discoverInstances() {
+    const dataPath = getVanillaPath();
+    if (!dataPath)
+      return [];
+    return [{
+      id: "vanilla",
+      name: "Vanilla Minecraft",
+      launcher: "vanilla",
+      minecraftPath: dataPath
+    }];
+  }
+};
+
+// src/launchers/providers/prism.ts
+import fs3 from "fs";
+import path3 from "path";
+import os4 from "os";
+function getPrismCandidatePaths() {
+  const home = os4.homedir();
+  const paths = [];
+  switch (os4.platform()) {
+    case "win32":
+      paths.push(path3.join(os4.homedir(), "AppData/Roaming/PrismLauncher"));
+      break;
+    case "darwin":
+      paths.push(path3.join(home, "Library/Application Support/PrismLauncher"));
+      break;
+    case "linux":
+    default: {
+      const xdgDataHome = process.env.XDG_DATA_HOME;
+      if (xdgDataHome) {
+        paths.push(path3.join(xdgDataHome, "PrismLauncher"));
+      }
+      paths.push(path3.join(home, ".local/share/PrismLauncher"));
+      paths.push(path3.join(home, ".var/app/org.prismlauncher.PrismLauncher/data/PrismLauncher"));
+      break;
+    }
+  }
+  return paths;
+}
+function getPrismDataPath() {
+  for (const candidate of getPrismCandidatePaths()) {
+    if (fs3.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function parseInstanceConfig(configPath) {
+  try {
+    const content = fs3.readFileSync(configPath, "utf-8");
+    const result = {};
+    for (const line of content.split(`
+`)) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("name=")) {
+        result.name = trimmed.slice(5);
+        break;
+      }
+    }
+    return result;
+  } catch {
+    return {};
+  }
+}
+function parsePackJson(packPath) {
+  try {
+    const content = fs3.readFileSync(packPath, "utf-8");
+    const pack = JSON.parse(content);
+    const components = pack.components;
+    if (components) {
+      const minecraft = components.find((c) => c.uid === "net.minecraft");
+      if (minecraft?.version) {
+        return { version: minecraft.version };
+      }
+    }
+    return {};
+  } catch {
+    return {};
+  }
+}
+var prismProvider = {
+  type: "prism",
+  displayName: "Prism Launcher",
+  async isInstalled() {
+    return getPrismDataPath() !== null;
+  },
+  getDataPath() {
+    return getPrismDataPath();
+  },
+  async discoverInstances() {
+    const dataPath = getPrismDataPath();
+    if (!dataPath)
+      return [];
+    const instancesDir = path3.join(dataPath, "instances");
+    if (!fs3.existsSync(instancesDir))
+      return [];
+    const instances = [];
+    try {
+      const entries = fs3.readdirSync(instancesDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory())
+          continue;
+        if (entry.name.startsWith(".") || entry.name.startsWith("_"))
+          continue;
+        const instanceDir = path3.join(instancesDir, entry.name);
+        const minecraftDir = path3.join(instanceDir, "minecraft");
+        const dotMinecraftDir = path3.join(instanceDir, ".minecraft");
+        let minecraftPath = null;
+        if (fs3.existsSync(minecraftDir)) {
+          minecraftPath = minecraftDir;
+        } else if (fs3.existsSync(dotMinecraftDir)) {
+          minecraftPath = dotMinecraftDir;
+        }
+        if (!minecraftPath)
+          continue;
+        const configPath = path3.join(instanceDir, "instance.cfg");
+        const config = parseInstanceConfig(configPath);
+        const packPath = path3.join(instanceDir, "mmc-pack.json");
+        const pack = parsePackJson(packPath);
+        instances.push({
+          id: `prism-${entry.name}`,
+          name: config.name || entry.name,
+          launcher: "prism",
+          minecraftPath,
+          version: pack.version
+        });
+      }
+    } catch {}
+    return instances;
+  }
+};
+
+// src/launchers/providers/modrinth.ts
+import fs4 from "fs";
+import path4 from "path";
+import os5 from "os";
+import { Database } from "bun:sqlite";
+function getModrinthCandidatePaths() {
+  const home = os5.homedir();
+  const paths = [];
+  switch (os5.platform()) {
+    case "win32":
+      paths.push(path4.join(os5.homedir(), "AppData/Roaming/ModrinthApp"));
+      break;
+    case "darwin":
+      paths.push(path4.join(home, "Library/Application Support/ModrinthApp"));
+      break;
+    case "linux":
+    default: {
+      const xdgDataHome = process.env.XDG_DATA_HOME;
+      if (xdgDataHome) {
+        paths.push(path4.join(xdgDataHome, "ModrinthApp"));
+      }
+      paths.push(path4.join(home, ".local/share/ModrinthApp"));
+      paths.push(path4.join(home, ".var/app/com.modrinth.ModrinthApp/data/ModrinthApp"));
+      break;
+    }
+  }
+  return paths;
+}
+function getModrinthDataPath() {
+  for (const candidate of getModrinthCandidatePaths()) {
+    if (fs4.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function getProfilesFromDb(dataPath) {
+  const profiles = new Map;
+  const dbPath = path4.join(dataPath, "app.db");
+  if (!fs4.existsSync(dbPath))
+    return profiles;
+  try {
+    const db = new Database(dbPath, { readonly: true });
+    const rows = db.query("SELECT path, name, game_version FROM profiles").all();
+    for (const row of rows) {
+      profiles.set(row.path, {
+        name: row.name,
+        version: row.game_version ?? undefined
+      });
+    }
+    db.close();
+  } catch {}
+  return profiles;
+}
+var modrinthProvider = {
+  type: "modrinth",
+  displayName: "Modrinth App",
+  async isInstalled() {
+    return getModrinthDataPath() !== null;
+  },
+  getDataPath() {
+    return getModrinthDataPath();
+  },
+  async discoverInstances() {
+    const dataPath = getModrinthDataPath();
+    if (!dataPath)
+      return [];
+    const profilesDir = path4.join(dataPath, "profiles");
+    if (!fs4.existsSync(profilesDir))
+      return [];
+    const profileMetadata = getProfilesFromDb(dataPath);
+    const instances = [];
+    try {
+      const entries = fs4.readdirSync(profilesDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory())
+          continue;
+        if (entry.name.startsWith("."))
+          continue;
+        const minecraftPath = path4.join(profilesDir, entry.name);
+        const hasSaves = fs4.existsSync(path4.join(minecraftPath, "saves"));
+        const hasMods = fs4.existsSync(path4.join(minecraftPath, "mods"));
+        if (!hasSaves && !hasMods)
+          continue;
+        const metadata = profileMetadata.get(entry.name);
+        instances.push({
+          id: `modrinth-${entry.name}`,
+          name: metadata?.name || entry.name,
+          launcher: "modrinth",
+          minecraftPath,
+          version: metadata?.version
+        });
+      }
+    } catch {}
+    return instances;
+  }
+};
+
+// src/launchers/index.ts
+registerProvider(vanillaProvider);
+registerProvider(prismProvider);
+registerProvider(modrinthProvider);
+
 // src/commands/create.ts
 function toJson(obj, pretty = false) {
   return util.inspect(obj, {
@@ -6420,9 +6712,78 @@ function toJson(obj, pretty = false) {
     maxArrayLength: Number(Infinity)
   });
 }
+function parseVersion(version) {
+  if (!version)
+    return null;
+  const match = version.match(/^(\d+)\.(\d+)(?:\.(\d+))?/);
+  if (match) {
+    return [parseInt(match[1]), parseInt(match[2]), parseInt(match[3] || "0")];
+  }
+  const snapshotMatch = version.match(/^(\d+)w(\d+)/);
+  if (snapshotMatch) {
+    return [1, parseInt(snapshotMatch[1]), parseInt(snapshotMatch[2])];
+  }
+  return null;
+}
+function compareVersions(a, b) {
+  if (!a && !b)
+    return 0;
+  if (!a)
+    return 1;
+  if (!b)
+    return -1;
+  for (let i = 0;i < 3; i++) {
+    if (a[i] !== b[i])
+      return b[i] - a[i];
+  }
+  return 0;
+}
+async function selectClientInstance() {
+  const { instances } = await discoverAllInstances();
+  if (instances.length === 0) {
+    return await input({ message: "No Minecraft installations detected. Enter path to .minecraft folder:" });
+  }
+  const vanilla = instances.find((i) => i.launcher === "vanilla");
+  const otherInstances = instances.filter((i) => i.launcher !== "vanilla");
+  otherInstances.sort((a, b) => {
+    const versionCmp = compareVersions(parseVersion(a.version), parseVersion(b.version));
+    if (versionCmp !== 0)
+      return versionCmp;
+    return a.name.localeCompare(b.name);
+  });
+  const choices = [];
+  choices.push({ name: "Custom path...", value: "custom", short: "Custom" });
+  choices.push({ name: "None (configure later)", value: "none", short: "None" });
+  if (vanilla) {
+    choices.push({
+      name: `${vanilla.name} [${vanilla.launcher}]`,
+      value: vanilla,
+      short: vanilla.name
+    });
+  }
+  for (const i of otherInstances) {
+    choices.push({
+      name: `${i.name}${i.version ? ` (${i.version})` : ""} [${i.launcher}]`,
+      value: i,
+      short: i.name
+    });
+  }
+  const selected = await select({
+    message: "Select Minecraft installation:",
+    choices,
+    default: vanilla ?? "none"
+  });
+  if (selected === "none") {
+    return;
+  }
+  if (selected === "custom") {
+    return await input({ message: "Enter path to .minecraft folder:" });
+  }
+  return selected.minecraftPath;
+}
 async function createCommand2(_project, opts) {
-  const projectPath = path2.resolve(_project);
-  const projectName = path2.basename(projectPath);
+  const projectPath = path5.resolve(_project);
+  const projectName = path5.basename(projectPath);
   const projectType = await confirm({
     message: "Whether your project will be a library for use in other Sandstone projects >",
     default: false
@@ -6490,22 +6851,33 @@ async function createCommand2(_project, opts) {
         }]
       });
       switch (saveChoice) {
-        case "root":
+        case "root": {
+          const clientPath = await selectClientInstance();
+          if (clientPath) {
+            saveOptions.clientPath = clientPath;
+          }
           saveOptions.root = true;
           break;
-        case "world":
+        }
+        case "world": {
+          const clientPath = await selectClientInstance();
+          if (clientPath) {
+            saveOptions.clientPath = clientPath;
+          }
           const world = await select({
             message: "What world do you want to save the packs in? >",
             choices: getWorldsList(saveOptions.clientPath)
           });
           saveOptions.world = world;
           break;
-        case "server-path":
+        }
+        case "server-path": {
           const serverPath = await input({
             message: "Where is the server to save the packs in? Relative paths are accepted. >"
           });
           saveOptions.serverPath = serverPath;
           break;
+        }
         case "none":
           break;
       }
@@ -6533,9 +6905,9 @@ async function createCommand2(_project, opts) {
   const exec = (cmd) => child.execSync(cmd, { cwd: projectPath });
   exec("git clone https://github.com/sandstone-mc/sandstone-template.git .");
   exec(`git checkout ${projectType}-${version[0]}`);
-  await import_fs_extra.default.rm(".git", { force: true, recursive: true });
+  await import_fs_extra.default.rm(path5.join(projectPath, ".git"), { force: true, recursive: true });
   exec(`${packageManager} install`);
-  const configPath = path2.join(projectPath, `${projectType === "library" ? "test/" : ""}sandstone.config.ts`);
+  const configPath = path5.join(projectPath, `${projectType === "library" ? "test/" : ""}sandstone.config.ts`);
   let templateConfig = await import_fs_extra.default.readFile(configPath, "utf8");
   templateConfig = templateConfig.replace("packUid: 'kZZpDK67'", `packUid: ${toJson(nanoid(8))}`);
   templateConfig = templateConfig.replace("name: 'template'", `name: ${toJson(packName)}`);