sandstone-cli 2.1.2 → 2.2.0

package/src/launchers/providers/prism.ts

@@ -0,0 +1,150 @@
+import fs from 'fs'
+import path from 'path'
+import os from 'os'
+import type { LauncherProvider, MinecraftInstance } from '../types.js'
+
+function getPrismCandidatePaths(): string[] {
+  const home = os.homedir()
+  const paths: string[] = []
+
+  switch (os.platform()) {
+    case 'win32':
+      paths.push(path.join(os.homedir(), 'AppData/Roaming/PrismLauncher'))
+      break
+    case 'darwin':
+      paths.push(path.join(home, 'Library/Application Support/PrismLauncher'))
+      break
+    case 'linux':
+    default: {
+      // Check XDG_DATA_HOME first
+      const xdgDataHome = process.env.XDG_DATA_HOME
+      if (xdgDataHome) {
+        paths.push(path.join(xdgDataHome, 'PrismLauncher'))
+      }
+      // Standard location
+      paths.push(path.join(home, '.local/share/PrismLauncher'))
+      // Flatpak location
+      paths.push(path.join(home, '.var/app/org.prismlauncher.PrismLauncher/data/PrismLauncher'))
+      break
+    }
+  }
+
+  return paths
+}
+
+function getPrismDataPath(): string | null {
+  for (const candidate of getPrismCandidatePaths()) {
+    if (fs.existsSync(candidate)) {
+      return candidate
+    }
+  }
+  return null
+}
+
+/** Parse INI-style instance.cfg to extract instance name */
+function parseInstanceConfig(configPath: string): { name?: string } {
+  try {
+    const content = fs.readFileSync(configPath, 'utf-8')
+    const result: { name?: string } = {}
+
+    for (const line of content.split('\n')) {
+      const trimmed = line.trim()
+      if (trimmed.startsWith('name=')) {
+        result.name = trimmed.slice(5)
+        break
+      }
+    }
+
+    return result
+  } catch {
+    return {}
+  }
+}
+
+/** Parse mmc-pack.json to extract Minecraft version */
+function parsePackJson(packPath: string): { version?: string } {
+  try {
+    const content = fs.readFileSync(packPath, 'utf-8')
+    const pack = JSON.parse(content)
+
+    // Look for net.minecraft component
+    const components = pack.components as Array<{ uid: string; version: string }> | undefined
+    if (components) {
+      const minecraft = components.find(c => c.uid === 'net.minecraft')
+      if (minecraft?.version) {
+        return { version: minecraft.version }
+      }
+    }
+
+    return {}
+  } catch {
+    return {}
+  }
+}
+
+export const prismProvider: LauncherProvider = {
+  type: 'prism',
+  displayName: 'Prism Launcher',
+
+  async isInstalled(): Promise<boolean> {
+    return getPrismDataPath() !== null
+  },
+
+  getDataPath(): string | null {
+    return getPrismDataPath()
+  },
+
+  async discoverInstances(): Promise<MinecraftInstance[]> {
+    const dataPath = getPrismDataPath()
+    if (!dataPath) return []
+
+    const instancesDir = path.join(dataPath, 'instances')
+    if (!fs.existsSync(instancesDir)) return []
+
+    const instances: MinecraftInstance[] = []
+
+    try {
+      const entries = fs.readdirSync(instancesDir, { withFileTypes: true })
+
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue
+        // Skip hidden folders and special folders
+        if (entry.name.startsWith('.') || entry.name.startsWith('_')) continue
+
+        const instanceDir = path.join(instancesDir, entry.name)
+        const minecraftDir = path.join(instanceDir, 'minecraft')
+        const dotMinecraftDir = path.join(instanceDir, '.minecraft')
+
+        // Prism uses 'minecraft' or '.minecraft' subdirectory
+        let minecraftPath: string | null = null
+        if (fs.existsSync(minecraftDir)) {
+          minecraftPath = minecraftDir
+        } else if (fs.existsSync(dotMinecraftDir)) {
+          minecraftPath = dotMinecraftDir
+        }
+
+        if (!minecraftPath) continue
+
+        // Parse instance.cfg for display name
+        const configPath = path.join(instanceDir, 'instance.cfg')
+        const config = parseInstanceConfig(configPath)
+
+        // Parse mmc-pack.json for Minecraft version
+        const packPath = path.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 {
+      // Directory read failed
+    }
+
+    return instances
+  },
+}

package/src/launchers/providers/vanilla.ts

@@ -0,0 +1,48 @@
+import fs from 'fs'
+import path from 'path'
+import os from 'os'
+import type { LauncherProvider, MinecraftInstance } from '../types.js'
+
+function getVanillaPath(): string | null {
+  let mcPath: string
+
+  switch (os.platform()) {
+    case 'win32':
+      mcPath = path.join(os.homedir(), 'AppData/Roaming/.minecraft')
+      break
+    case 'darwin':
+      mcPath = path.join(os.homedir(), 'Library/Application Support/minecraft')
+      break
+    case 'linux':
+    default:
+      mcPath = path.join(os.homedir(), '.minecraft')
+      break
+  }
+
+  return fs.existsSync(mcPath) ? mcPath : null
+}
+
+export const vanillaProvider: LauncherProvider = {
+  type: 'vanilla',
+  displayName: 'Vanilla Minecraft',
+
+  async isInstalled(): Promise<boolean> {
+    return getVanillaPath() !== null
+  },
+
+  getDataPath(): string | null {
+    return getVanillaPath()
+  },
+
+  async discoverInstances(): Promise<MinecraftInstance[]> {
+    const dataPath = getVanillaPath()
+    if (!dataPath) return []
+
+    return [{
+      id: 'vanilla',
+      name: 'Vanilla Minecraft',
+      launcher: 'vanilla',
+      minecraftPath: dataPath,
+    }]
+  },
+}

package/src/launchers/registry.ts

@@ -0,0 +1,46 @@
+import type { LauncherProvider, LauncherType, DiscoveryResult } from './types.js'
+
+const providers = new Map<LauncherType, LauncherProvider>()
+
+/** Register a launcher provider */
+export function registerProvider(provider: LauncherProvider): void {
+  providers.set(provider.type, provider)
+}
+
+/** Get all registered providers */
+export function getProviders(): LauncherProvider[] {
+  return Array.from(providers.values())
+}
+
+/** Get a specific provider by type */
+export function getProvider(type: LauncherType): LauncherProvider | undefined {
+  return providers.get(type)
+}
+
+/** Discover instances from all registered providers */
+export async function discoverAllInstances(): Promise<DiscoveryResult> {
+  const result: DiscoveryResult = {
+    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 {
+      // Extract the provider type from the error if possible
+      const error = discovery.reason as Error
+      // We can't easily get the type here, so we'll handle errors differently
+      console.error('Discovery error:', error.message)
+    }
+  }
+
+  return result
+}

package/src/launchers/types.ts

@@ -0,0 +1,32 @@
+export type LauncherType = 'vanilla' | 'prism' | 'modrinth'
+
+export interface MinecraftInstance {
+  /** Unique identifier, e.g., "prism-Homestead" */
+  id: string
+  /** Display name from config or folder name */
+  name: string
+  /** Which launcher this instance belongs to */
+  launcher: LauncherType
+  /** Path to minecraft directory (where saves/ lives) */
+  minecraftPath: string
+  /** Optional game version for display */
+  version?: string
+}
+
+export interface LauncherProvider {
+  /** Unique identifier for this launcher */
+  readonly type: LauncherType
+  /** Human-readable name for display */
+  readonly displayName: string
+  /** Check if this launcher is installed on the system */
+  isInstalled(): Promise<boolean>
+  /** Get the data path for this launcher (first valid path found) */
+  getDataPath(): string | null
+  /** Discover all instances for this launcher */
+  discoverInstances(): Promise<MinecraftInstance[]>
+}
+
+export interface DiscoveryResult {
+  instances: MinecraftInstance[]
+  errors: Map<LauncherType, Error>
+}

package/src/version.ts

@@ -1 +1 @@
-export const CLI_VERSION = '2.1.2'
+export const CLI_VERSION = '2.2.0'

package/tsconfig.json

@@ -15,7 +15,7 @@
     "esModuleInterop": true,
     "allowSyntheticDefaultImports": true,
     "jsx": "react-jsx",
-    "types": ["@sandstone-mc/hot-hook/import-meta"]
+    "types": ["bun-types", "@sandstone-mc/hot-hook/import-meta"]
   },
   "include": [
     "src/**/*"