sandstone-cli 2.1.3 → 2.2.1

package/CLAUDE.md

@@ -0,0 +1,107 @@
+# Sandstone CLI
+
+Command-line interface for Sandstone projects. Provides `sand` (project commands) and `create-sandstone` (project scaffolding).
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `sand create <name>` | Create a new Sandstone project |
+| `sand build` | Build the datapack/resourcepack |
+| `sand watch` | Build and rebuild on file changes |
+| `sand install` | Install Smithed libraries |
+| `sand uninstall` | Remove Smithed libraries |
+| `sand refresh` | Clear library cache |
+
+## Project Structure
+
+```
+sandstone-cli/
+├── src/
+│   ├── commands/          # CLI command implementations
+│   │   ├── create.ts      # create-sandstone command
+│   │   ├── build.ts       # sand build
+│   │   ├── watch.ts       # sand watch (uses hot-hook for HMR in Node, modifies require.cache in Bun)
+│   │   └── dependency.ts  # install/uninstall/refresh
+│   ├── launchers/         # Minecraft installation detection
+│   │   ├── types.ts       # LauncherProvider interface
+│   │   ├── registry.ts    # Provider registry
+│   │   ├── index.ts       # Auto-registers all providers
+│   │   └── providers/     # Vanilla, Prism, Modrinth
+│   ├── ui/                # Terminal UI components (Ink/React)
+│   ├── utils.ts           # Shared utilities
+│   └── index.ts           # Main CLI entry (Commander.js)
+├── lib/                   # Built output (gitignored)
+├── scripts/
+│   └── test-harness.ts    # Interactive CLI testing tool
+└── .test-runs/            # Test output directory (gitignored)
+```
+
+## Build Commands
+
+```bash
+bun dev:build    # Compile TypeScript and bundle
+bun bundle       # Bundle only (after tsc, don't use this one directly)
+```
+
+## Test Harness
+
+The test harness allows programmatic testing of interactive CLI prompts using node-pty.
+
+```bash
+# Create a project with pre-programmed responses
+bun test:harness create my-pack --responses '[
+  ["n", "enter"],           # Not a library
+  ["enter"],                # Default version
+  ["My Pack", "enter"],     # Pack name
+  ["mypack", "enter"],      # Namespace
+  ["up", "enter"],  # Save location: None
+  ["enter"]                 # Package manager: bun
+]'
+
+# View test runs
+bun test:harness list
+
+# Clean up
+bun test:harness cleanup
+```
+
+Test runs are saved to `.test-runs/<name>/` with a `test-run.log` containing cleaned output.
+
+**Response format:**
+- `["text", "enter"]` - Type text and press enter
+- `["enter"]` - Accept default
+- `["down", "enter"]` - Navigate and select
+- Special keys: `enter`, `up`, `down`, `space`, `tab`, `escape`, `backspace`
+
+## Launcher Detection
+
+The CLI detects Minecraft installations across multiple launchers.
+
+Paths are platform-aware (Windows, macOS, Linux including Flatpak).
+
+### Adding a New Launcher
+
+1. Create `src/launchers/providers/<name>.ts` implementing `LauncherProvider`
+2. Export and register in `src/launchers/index.ts`
+
+## Dependencies
+
+- `commander` - CLI argument parsing
+- `@inquirer/prompts` - Interactive prompts
+- `ink` + `react` - Terminal UI components
+- `@sandstone-mc/hot-hook` - HMR for watch mode
+- `@parcel/watcher` - File system watching
+
+## Create Command Flow
+
+1. Ask if library or pack
+2. Select Sandstone version
+3. Enter pack name and namespace
+4. Select save location (triggers launcher detection)
+5. Select Minecraft instance (if root/world chosen)
+6. Select world (if world chosen)
+7. Select package manager
+8. Clone template, install deps, configure
+
+The `--root`, `--world`, `--client-path`, `--server-path` flags skip relevant prompts.

package/bun.lock

@@ -1,6 +1,6 @@
 {
   "lockfileVersion": 1,
-  "configVersion": 0,
+  "configVersion": 1,
   "workspaces": {
     "": {
       "name": "sandstone-cli",
@@ -29,11 +29,16 @@
         "@types/fs-extra": "^11.0.2",
         "@types/react": "^19.2.10",
         "@types/semver": "^7.5.3",
+        "bun-types": "^1.3.9",
+        "node-pty": "^1.1.0",
         "sandstone": "^1.0.0-beta.1",
         "typescript": "^5.2.2",
       },
     },
   },
+  "trustedDependencies": [
+    "@parcel/watcher",
+  ],
   "packages": {
     "@alcalzone/ansi-tokenize": ["@alcalzone/ansi-tokenize@0.2.4", "", { "dependencies": { "ansi-styles": "^6.2.1", "is-fullwidth-code-point": "^5.0.0" } }, "sha512-HTgrrTgZ9Jgeo6Z3oqbQ7lifOVvRR14vaDuBGPPUxk9Thm+vObaO4QfYYYWw4Zo5CWQDBEfsinFA6Gre+AqwNQ=="],
 
@@ -155,6 +160,8 @@
 
     "buffer": ["buffer@6.0.3", "", { "dependencies": { "base64-js": "^1.3.1", "ieee754": "^1.2.1" } }, "sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA=="],
 
+    "bun-types": ["bun-types@1.3.9", "", { "dependencies": { "@types/node": "*" } }, "sha512-+UBWWOakIP4Tswh0Bt0QD0alpTY8cb5hvgiYeWCMet9YukHbzuruIEeXC2D7nMJPB12kbh8C7XJykSexEqGKJg=="],
+
     "chalk": ["chalk@5.6.2", "", {}, "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA=="],
 
     "chalk-template": ["chalk-template@1.1.2", "", { "dependencies": { "chalk": "^5.2.0" } }, "sha512-2bxTP2yUH7AJj/VAXfcA+4IcWGdQ87HwBANLt5XxGTeomo8yG0y95N1um9i5StvhT/Bl0/2cARA5v1PpPXUxUA=="],
@@ -301,6 +308,8 @@
 
     "node-fetch": ["node-fetch@3.3.2", "", { "dependencies": { "data-uri-to-buffer": "^4.0.0", "fetch-blob": "^3.1.4", "formdata-polyfill": "^4.0.10" } }, "sha512-dRB78srN/l6gqWulah9SrxeYnxeddIG30+GOqK/9OlLVyLg3HPnr6SqOWTWOXKRwC2eGYCkZ59NNuSgvSrpgOA=="],
 
+    "node-pty": ["node-pty@1.1.0", "", { "dependencies": { "node-addon-api": "^7.1.0" } }, "sha512-20JqtutY6JPXTUnL0ij1uad7Qe1baT46lyolh2sSENDd4sTzKZ4nmAFkeAARDKwmlLjPx6XKRlwRUxwjOy+lUg=="],
+
     "normalize-package-data": ["normalize-package-data@8.0.0", "", { "dependencies": { "hosted-git-info": "^9.0.0", "semver": "^7.3.5", "validate-npm-package-license": "^3.0.4" } }, "sha512-RWk+PI433eESQ7ounYxIp67CYuVsS1uYSonX3kA6ps/3LWfjVQa/ptEg6Y3T6uAMq1mWpX9PQ+qx+QaHpsc7gQ=="],
 
     "obliterator": ["obliterator@2.0.5", "", {}, "sha512-42CPE9AhahZRsMNslczq0ctAEtqk8Eka26QofnqC346BZdHDySk3LWka23LI7ULIw11NmltpiLagIq8gBozxTw=="],

package/lib/create.js

@@ -5680,12 +5680,12 @@ var {
 import figlet from "figlet";
 
 // src/version.ts
-var CLI_VERSION = "2.1.3";
+var CLI_VERSION = "2.2.1";
 
 // 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(path2.join(projectPath, ".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)}`);