sandstone-cli 2.1.2 → 2.2.0

package/scripts/test-harness.ts

@@ -0,0 +1,341 @@
+#!/usr/bin/env bun
+/**
+ * Test harness for the Sandstone CLI.
+ * Uses node-pty to allow pre-programming responses for interactive prompts.
+ *
+ * Usage:
+ *   bun test:harness create [project-name] --responses '<json>'
+ *   bun test:harness sand <args...>
+ *   bun test:harness cleanup
+ *   bun test:harness list
+ *
+ * Response format (array of keystrokes/text to send):
+ *   ["n", "enter"]                    - Type 'n' then press enter (for confirm)
+ *   ["enter"]                         - Press enter (accept default)
+ *   ["down", "down", "enter"]         - Arrow down twice, then enter (for select)
+ *   ["My Pack Name", "enter"]         - Type text then enter (for input)
+ *
+ * Special keys: enter, up, down, space, tab, escape
+ */
+
+import * as pty from 'node-pty'
+import { mkdirSync, rmSync, readdirSync, existsSync, writeFileSync } from 'fs'
+import { join, dirname } from 'path'
+import { fileURLToPath } from 'url'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const CLI_ROOT = join(__dirname, '..')
+const CREATE_SCRIPT = join(CLI_ROOT, 'lib', 'create.js')
+const SAND_SCRIPT = join(CLI_ROOT, 'lib', 'index.js')
+const TEST_RUNS_DIR = join(CLI_ROOT, '.test-runs')
+
+// Handle errors from node-pty by exiting cleanly
+process.on('unhandledRejection', (err) => {
+  if (err instanceof Error && err.message.includes('Socket is closed')) {
+    process.exit(0)
+  }
+  console.error('Unhandled rejection:', err)
+  process.exit(1)
+})
+
+process.on('uncaughtException', (err) => {
+  if (err.message.includes('Socket is closed')) {
+    process.exit(0)
+  }
+  console.error('Uncaught exception:', err)
+  process.exit(1)
+})
+
+const KEY_MAP: Record<string, string> = {
+  enter: '\r\n',
+  up: '\x1B[A',
+  down: '\x1B[B',
+  right: '\x1B[C',
+  left: '\x1B[D',
+  space: ' ',
+  tab: '\t',
+  escape: '\x1B',
+  backspace: '\x7F',
+}
+
+// Strip ANSI escape codes from text
+function stripAnsi(text: string): string {
+  // eslint-disable-next-line no-control-regex
+  return text.replace(/\x1B\[[0-9;]*[A-Za-z]|\x1B\][^\x07]*\x07|\x1B\[\?[0-9;]*[hl]|\x07/g, '')
+}
+
+// Clean up output: strip ANSI, normalize whitespace, remove empty lines
+function cleanOutput(text: string): string {
+  return stripAnsi(text)
+    .split('\n')
+    .map(line => line.trimEnd())
+    .filter(line => line.length > 0)
+    .join('\n')
+}
+
+function ensureTestRunsDir(): void {
+  if (!existsSync(TEST_RUNS_DIR)) {
+    mkdirSync(TEST_RUNS_DIR, { recursive: true })
+  }
+}
+
+function getTestRunDirs(): string[] {
+  if (!existsSync(TEST_RUNS_DIR)) return []
+  return readdirSync(TEST_RUNS_DIR, { withFileTypes: true })
+    .filter(d => d.isDirectory())
+    .map(d => join(TEST_RUNS_DIR, d.name))
+}
+
+function createTestRunDir(name: string): string {
+  ensureTestRunsDir()
+  const dir = join(TEST_RUNS_DIR, name)
+  if (existsSync(dir)) {
+    rmSync(dir, { recursive: true, force: true })
+  }
+  mkdirSync(dir, { recursive: true })
+  return dir
+}
+
+function parseResponses(responsesJson: string): string[][] {
+  try {
+    const parsed = JSON.parse(responsesJson)
+    if (!Array.isArray(parsed)) {
+      throw new Error('Responses must be an array')
+    }
+    return parsed
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e)
+    console.error(`Failed to parse responses: ${message}`)
+    process.exit(1)
+  }
+}
+
+function keystrokeToBytes(key: string): string {
+  return KEY_MAP[key.toLowerCase()] ?? key
+}
+
+interface RunResult {
+  output: string
+  exitCode: number | null
+  projectPath?: string
+}
+
+async function runWithPty(
+  command: string,
+  args: string[],
+  cwd: string,
+  responses: string[][]
+): Promise<RunResult> {
+  return new Promise((resolve) => {
+    const fullCommand = `${command} ${args.map(a => a.includes(' ') ? `"${a}"` : a).join(' ')}`
+
+    const shell = process.platform === 'win32' ? 'powershell.exe' : '/bin/bash'
+    const shellArgs = process.platform === 'win32'
+      ? ['-NoProfile', '-Command', fullCommand]
+      : ['-c', fullCommand]
+
+    const env: Record<string, string> = {}
+    for (const [key, value] of Object.entries(process.env)) {
+      if (value !== undefined && key !== 'CI') {
+        env[key] = value
+      }
+    }
+    env.FORCE_COLOR = '1'
+    env.TERM = 'xterm-256color'
+
+    const proc = pty.spawn(shell, shellArgs, {
+      name: 'xterm-256color',
+      cols: 120,
+      rows: 30,
+      cwd,
+      env,
+    })
+
+    let responseIndex = 0
+    let outputBuffer = ''
+    let fullOutput = ''
+    let exited = false
+
+    proc.onExit(({ exitCode }) => {
+      exited = true
+      resolve({ output: fullOutput, exitCode })
+    })
+
+    proc.onData((data) => {
+      fullOutput += data
+      outputBuffer += data
+
+      if (!exited && responseIndex < responses.length && outputBuffer.includes('?')) {
+        outputBuffer = ''
+        setTimeout(() => {
+          if (!exited && responseIndex < responses.length) {
+            const response = responses[responseIndex]
+            const bytes = response.map(keystrokeToBytes).join('')
+            try {
+              proc.write(bytes)
+            } catch {
+              exited = true
+              resolve({ output: fullOutput, exitCode: null })
+              return
+            }
+            responseIndex++
+          }
+        }, 100)
+      }
+    })
+
+    setTimeout(() => {
+      if (!exited) {
+        proc.kill()
+        resolve({ output: fullOutput + '\n[TIMEOUT]', exitCode: null })
+      }
+    }, 30000)
+  })
+}
+
+function writeLog(logPath: string, content: string): void {
+  writeFileSync(logPath, content, 'utf-8')
+  console.log(`Log written to: ${logPath}`)
+}
+
+const commands: Record<string, (args: string[]) => Promise<void> | void> = {
+  async create(args) {
+    const responsesIdx = args.indexOf('--responses')
+    let responses: string[][] = []
+    let projectArgs = args
+
+    if (responsesIdx !== -1) {
+      const responsesJson = args[responsesIdx + 1]
+      responses = parseResponses(responsesJson)
+      projectArgs = [...args.slice(0, responsesIdx), ...args.slice(responsesIdx + 2)]
+    }
+
+    const projectName = projectArgs[0] || `test-${Date.now()}`
+    const remainingArgs = projectArgs.slice(1)
+
+    const testRunDir = createTestRunDir(projectName)
+    const projectPath = join(testRunDir, projectName)
+
+    console.log(`Creating project: ${projectName}`)
+    console.log(`Directory: ${testRunDir}`)
+
+    const result = await runWithPty('bun', [CREATE_SCRIPT, projectName, ...remainingArgs], testRunDir, responses)
+
+    const cleanedOutput = cleanOutput(result.output)
+    const logPath = join(testRunDir, 'test-run.log')
+
+    const logContent = [
+      `# Test Run: ${projectName}`,
+      `Date: ${new Date().toISOString()}`,
+      `Exit Code: ${result.exitCode}`,
+      `Project Path: ${projectPath}`,
+      '',
+      '## Output',
+      cleanedOutput,
+    ].join('\n')
+
+    writeLog(logPath, logContent)
+
+    console.log(`Exit code: ${result.exitCode}`)
+    console.log(`Project: ${projectPath}`)
+  },
+
+  async sand(args) {
+    const result = await runWithPty('bun', [SAND_SCRIPT, ...args], process.cwd(), [])
+    console.log(cleanOutput(result.output))
+    console.log(`Exit code: ${result.exitCode}`)
+  },
+
+  async run(args) {
+    const responsesIdx = args.indexOf('--responses')
+    let responses: string[][] = []
+    let cmdArgs = args
+
+    if (responsesIdx !== -1) {
+      const responsesJson = args[responsesIdx + 1]
+      responses = parseResponses(responsesJson)
+      cmdArgs = [...args.slice(0, responsesIdx), ...args.slice(responsesIdx + 2)]
+    }
+
+    const [cmd, ...rest] = cmdArgs
+    const result = await runWithPty(cmd, rest, process.cwd(), responses)
+    console.log(cleanOutput(result.output))
+    console.log(`Exit code: ${result.exitCode}`)
+  },
+
+  cleanup() {
+    const dirs = getTestRunDirs()
+    if (dirs.length === 0) {
+      console.log('No test runs to clean up')
+      return
+    }
+
+    console.log(`Cleaning up ${dirs.length} test runs:`)
+    for (const dir of dirs) {
+      console.log(`  - ${dir}`)
+      rmSync(dir, { recursive: true, force: true })
+    }
+    console.log('Done')
+  },
+
+  list() {
+    const dirs = getTestRunDirs()
+    if (dirs.length === 0) {
+      console.log('No test runs')
+      return
+    }
+
+    console.log(`Test runs (${dirs.length}):`)
+    for (const dir of dirs) {
+      const name = dir.split(/[/\\]/).pop()
+      const logExists = existsSync(join(dir, 'test-run.log'))
+      console.log(`  ${name}${logExists ? ' (has log)' : ''}`)
+    }
+  },
+
+  help() {
+    console.log(`
+Sandstone CLI Test Harness
+
+Commands:
+  bun test:harness create [name] [--responses '<json>']
+    Create a project with pre-programmed responses
+    Output saved to .test-runs/<name>/
+
+  bun test:harness run <cmd> [args...] [--responses '<json>']
+    Run arbitrary command with responses
+
+  bun test:harness sand <args...>
+    Run sand command
+
+  bun test:harness list
+    List test runs in .test-runs/
+
+  bun test:harness cleanup
+    Remove all test runs
+
+Response Format:
+  [
+    ["n", "enter"],           # confirm: type 'n', press enter
+    ["enter"],                # select: accept default
+    ["down", "down", "enter"],# select: navigate and select
+    ["My Pack", "enter"],     # input: type text, press enter
+  ]
+
+  Special keys: enter, up, down, space, tab, escape, backspace
+`)
+  },
+}
+
+// Main
+const [cmd = 'help', ...args] = process.argv.slice(2)
+
+const handler = commands[cmd]
+if (handler) {
+  await handler(args)
+} else {
+  console.log(`Unknown command: ${cmd}`)
+  commands.help([])
+}
+
+process.exit(0)

package/src/commands/create.ts

@@ -9,6 +9,7 @@ import { confirm, select, input } from '@inquirer/prompts'
 
 import { CLI_VERSION } from '../version.js'
 import { capitalize, getWorldsList, hasBun, hasPnpm, hasYarn } from '../utils.js'
+import { discoverAllInstances, type MinecraftInstance } from '../launchers/index.js'
 
 type CreateOptions = {
   // Flags
@@ -31,6 +32,92 @@ function toJson(obj: any, pretty = false): string {
   })
 }
 
+/** Parse Minecraft version from metadata (not from name) */
+function parseVersion(version: string | undefined): number[] | null {
+  if (!version) return null
+  // Match version patterns like 1.21.6, 1.20
+  const match = version.match(/^(\d+)\.(\d+)(?:\.(\d+))?/)
+  if (match) {
+    return [parseInt(match[1]), parseInt(match[2]), parseInt(match[3] || '0')]
+  }
+  // Snapshot format like 24w12a
+  const snapshotMatch = version.match(/^(\d+)w(\d+)/)
+  if (snapshotMatch) {
+    return [1, parseInt(snapshotMatch[1]), parseInt(snapshotMatch[2])]
+  }
+  return null
+}
+
+/** Compare two version arrays (descending - newer first) */
+function compareVersions(a: number[] | null, b: number[] | null): number {
+  if (!a && !b) return 0
+  if (!a) return 1  // null versions go to end
+  if (!b) return -1
+  for (let i = 0; i < 3; i++) {
+    if (a[i] !== b[i]) return b[i] - a[i]  // descending
+  }
+  return 0
+}
+
+/** Prompt user to select a Minecraft installation from detected instances */
+async function selectClientInstance(): Promise<string | undefined> {
+  const { instances } = await discoverAllInstances()
+
+  if (instances.length === 0) {
+    return await input({ message: 'No Minecraft installations detected. Enter path to .minecraft folder:' })
+  }
+
+  // Separate vanilla from other instances
+  const vanilla = instances.find(i => i.launcher === 'vanilla')
+  const otherInstances = instances.filter(i => i.launcher !== 'vanilla')
+
+  // Sort by version metadata (newest first), then alphabetically by name
+  otherInstances.sort((a, b) => {
+    const versionCmp = compareVersions(parseVersion(a.version), parseVersion(b.version))
+    if (versionCmp !== 0) return versionCmp
+    return a.name.localeCompare(b.name)
+  })
+
+  type ChoiceValue = MinecraftInstance | 'none' | 'custom'
+  const choices: Array<{ name: string; value: ChoiceValue; short: string }> = []
+
+  // Add Custom and None at top
+  choices.push({ name: 'Custom path...', value: 'custom', short: 'Custom' })
+  choices.push({ name: 'None (configure later)', value: 'none', short: 'None' })
+
+  // Add Vanilla (default)
+  if (vanilla) {
+    choices.push({
+      name: `${vanilla.name} [${vanilla.launcher}]`,
+      value: vanilla,
+      short: vanilla.name,
+    })
+  }
+
+  // Add sorted instances (newest version first)
+  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',  // Vanilla is default, or None if Vanilla not present
+  })
+
+  if (selected === 'none') {
+    return undefined
+  }
+  if (selected === 'custom') {
+    return await input({ message: 'Enter path to .minecraft folder:' })
+  }
+  return selected.minecraftPath
+}
+
 export async function createCommand(_project: string, opts: CreateOptions) {
 
   const projectPath = path.resolve(_project)
@@ -125,23 +212,33 @@ export async function createCommand(_project: string, opts: CreateOptions) {
       })
 
       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
       }
     }
@@ -177,7 +274,7 @@ export async function createCommand(_project: string, opts: CreateOptions) {
 
   exec(`git checkout ${projectType}-${version[0]}`)
 
-  await fs.rm('.git', { force: true, recursive: true })
+  await fs.rm(path.join(projectPath, '.git'), { force: true, recursive: true })
 
   exec(`${packageManager} install`)
 

package/src/launchers/index.ts

@@ -0,0 +1,15 @@
+// Re-export types
+export type { LauncherType, MinecraftInstance, LauncherProvider, DiscoveryResult } from './types.js'
+
+// Re-export registry functions
+export { registerProvider, getProviders, getProvider, discoverAllInstances } from './registry.js'
+
+// Import and register all built-in providers
+import { registerProvider } from './registry.js'
+import { vanillaProvider } from './providers/vanilla.js'
+import { prismProvider } from './providers/prism.js'
+import { modrinthProvider } from './providers/modrinth.js'
+
+registerProvider(vanillaProvider)
+registerProvider(prismProvider)
+registerProvider(modrinthProvider)

package/src/launchers/providers/modrinth.ts

@@ -0,0 +1,134 @@
+import fs from 'fs'
+import path from 'path'
+import os from 'os'
+import { Database } from 'bun:sqlite'
+import type { LauncherProvider, MinecraftInstance } from '../types.js'
+
+function getModrinthCandidatePaths(): string[] {
+  const home = os.homedir()
+  const paths: string[] = []
+
+  switch (os.platform()) {
+    case 'win32':
+      paths.push(path.join(os.homedir(), 'AppData/Roaming/ModrinthApp'))
+      break
+    case 'darwin':
+      paths.push(path.join(home, 'Library/Application Support/ModrinthApp'))
+      break
+    case 'linux':
+    default: {
+      // Check XDG_DATA_HOME first
+      const xdgDataHome = process.env.XDG_DATA_HOME
+      if (xdgDataHome) {
+        paths.push(path.join(xdgDataHome, 'ModrinthApp'))
+      }
+      // Standard location
+      paths.push(path.join(home, '.local/share/ModrinthApp'))
+      // Flatpak location
+      paths.push(path.join(home, '.var/app/com.modrinth.ModrinthApp/data/ModrinthApp'))
+      break
+    }
+  }
+
+  return paths
+}
+
+function getModrinthDataPath(): string | null {
+  for (const candidate of getModrinthCandidatePaths()) {
+    if (fs.existsSync(candidate)) {
+      return candidate
+    }
+  }
+  return null
+}
+
+interface ProfileRow {
+  path: string
+  name: string
+  game_version: string | null
+}
+
+/** Query app.db for profile metadata */
+function getProfilesFromDb(dataPath: string): Map<string, { name: string; version?: string }> {
+  const profiles = new Map<string, { name: string; version?: string }>()
+  const dbPath = path.join(dataPath, 'app.db')
+
+  if (!fs.existsSync(dbPath)) return profiles
+
+  try {
+    const db = new Database(dbPath, { readonly: true })
+    const rows = db.query<ProfileRow, []>('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 {
+    // Database read failed
+  }
+
+  return profiles
+}
+
+export const modrinthProvider: LauncherProvider = {
+  type: 'modrinth',
+  displayName: 'Modrinth App',
+
+  async isInstalled(): Promise<boolean> {
+    return getModrinthDataPath() !== null
+  },
+
+  getDataPath(): string | null {
+    return getModrinthDataPath()
+  },
+
+  async discoverInstances(): Promise<MinecraftInstance[]> {
+    const dataPath = getModrinthDataPath()
+    if (!dataPath) return []
+
+    const profilesDir = path.join(dataPath, 'profiles')
+    if (!fs.existsSync(profilesDir)) return []
+
+    // Get profile metadata from database
+    const profileMetadata = getProfilesFromDb(dataPath)
+
+    const instances: MinecraftInstance[] = []
+
+    try {
+      const entries = fs.readdirSync(profilesDir, { withFileTypes: true })
+
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue
+        // Skip hidden folders
+        if (entry.name.startsWith('.')) continue
+
+        // Modrinth profiles ARE the minecraft directory (no subdirectory)
+        const minecraftPath = path.join(profilesDir, entry.name)
+
+        // Verify it looks like a minecraft directory (has saves or mods folder)
+        const hasSaves = fs.existsSync(path.join(minecraftPath, 'saves'))
+        const hasMods = fs.existsSync(path.join(minecraftPath, 'mods'))
+        if (!hasSaves && !hasMods) continue
+
+        // Get metadata from database
+        const metadata = profileMetadata.get(entry.name)
+
+        instances.push({
+          id: `modrinth-${entry.name}`,
+          name: metadata?.name || entry.name,
+          launcher: 'modrinth',
+          minecraftPath,
+          version: metadata?.version,
+        })
+      }
+    } catch {
+      // Directory read failed
+    }
+
+    return instances
+  },
+}