sandstone-cli 2.3.2 → 2.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sandstone-cli",
-  "version": "2.3.2",
+  "version": "2.4.1",
   "description": "The CLI for Sandstone - the minecraft pack creation library.",
   "type": "module",
   "exports": "./lib/index.js",
@@ -9,7 +9,7 @@
     "create-sandstone": "./lib/create.js"
   },
   "scripts": {
-    "bundle": "bun scripts/version.ts && bun build src/index.ts --outfile=lib/index.js --target=bun --external=@parcel/watcher --external=figlet --external=@inquirer/prompts && bun build src/create.ts --outfile=lib/create.js --target=bun --external=@parcel/watcher --external=figlet --external=@inquirer/prompts",
+    "bundle": "bun scripts/version.ts && bun build src/index.ts --outdir=lib --sourcemap=external --target=bun --external=@parcel/watcher --external=figlet --external=@inquirer/prompts && bun build src/create.ts --outdir=lib --sourcemap=external --target=bun --external=@parcel/watcher --external=figlet --external=@inquirer/prompts",
     "dev:build": "tsc && bun bundle",
     "test:harness": "npx tsx scripts/test-harness.ts"
   },
@@ -59,7 +59,8 @@
     "node-fetch": "^3.3.2",
     "obliterator": "^2.0.5",
     "react": "^19.2.4",
-    "semver": "^7.5.4"
+    "semver": "^7.5.4",
+    "source-map-js": "^1.2.1"
   },
   "devDependencies": {
     "@types/adm-zip": "^0.5.2",
@@ -69,10 +70,11 @@
     "@types/semver": "^7.5.3",
     "bun-types": "^1.3.9",
     "node-pty": "^1.1.0",
-    "sandstone": "^1.0.0-beta.3",
+    "sandstone": "^1.0.0-beta.5",
     "typescript": "^5.2.2"
   },
   "trustedDependencies": [
-    "@parcel/watcher"
+    "@parcel/watcher",
+    "node-pty"
   ]
 }

package/src/commands/build/export.ts

@@ -101,9 +101,9 @@ export async function createSymlink(
 
   const comment = `# Sandstone Pack: ${packName}\n`
   try {
-    const currentlyAllowed = await fs.readFile(allowedList, 'utf-8')
+    const currentlyAllowed = (await fs.readFile(allowedList, 'utf-8')).replace(/\r/g, '')
 
-    if (!currentlyAllowed.includes(allowPath)) {
+    if (currentlyAllowed.match(new RegExp(`^${allowPath}$`, 'm')) === null) {
       log('[symlink] Adding workspace to allowed_symlinks.txt. If the game is running please restart it.')
       await fs.writeFile(allowedList, `${currentlyAllowed}\n#\n${comment}${allowPath}`)
     } else {

package/src/commands/build/index.ts

@@ -7,6 +7,7 @@ import { split } from 'obliterator'
 import type { BuildResult, ResourceCounts } from '../../ui/types.js'
 import { log, initLoggerNoFile, setSilent } from '../../ui/logger.js'
 import { hash } from '../../utils.js'
+import { resolveStackTrace } from '../../utils/source-map.js'
 
 import {
   type SandstoneCache,
@@ -173,7 +174,7 @@ export async function loadBuildContext(
     }
   }
 
-  const sandstoneUrl = pathToFileURL(path.join(folder, 'node_modules', 'sandstone', 'dist', 'index.js'))
+  const sandstoneUrl = pathToFileURL(path.join(folder, 'node_modules', 'sandstone', 'dist', 'exports', 'index.js'))
   /* @ts-ignore */
   const { createSandstonePack, resetSandstonePack } = (await import(sandstoneUrl)) as typeof sandstone
 
@@ -512,7 +513,10 @@ export async function _buildCommand(
     const stackLines = cleanedStack.split('\n')
     const traceStart = stackLines.findIndex(line => line.trimStart().startsWith('at '))
     const stackTrace = traceStart >= 0 ? stackLines.slice(traceStart).join('\n') : ''
-    const formattedError = stackTrace ? `${errorMessage}\n${stackTrace}` : errorMessage
+
+    // Resolve source maps for better error locations
+    const resolvedStackTrace = stackTrace ? resolveStackTrace(stackTrace) : ''
+    const formattedError = resolvedStackTrace ? `${errorMessage}\n${resolvedStackTrace}` : errorMessage
     return {
       success: false,
       error: formattedError,
@@ -553,7 +557,10 @@ export async function buildCommand(opts: BuildOptions, _folder?: string, silent
     const stackLines = cleanedStack.split('\n')
     const traceStart = stackLines.findIndex(line => line.trimStart().startsWith('at '))
     const stackTrace = traceStart >= 0 ? stackLines.slice(traceStart).join('\n') : ''
-    const formattedError = stackTrace ? `${errorMessage}\n${stackTrace}` : errorMessage
+
+    // Resolve source maps for better error locations
+    const resolvedStackTrace = stackTrace ? resolveStackTrace(stackTrace) : ''
+    const formattedError = resolvedStackTrace ? `${errorMessage}\n${resolvedStackTrace}` : errorMessage
     if (!silent) {
       log(chalk.bgRed.white('BuildError') + chalk.gray(':'), formattedError)
       process.exit(1)

package/src/commands/create.ts

@@ -130,7 +130,7 @@ export async function createCommand(_project: string, opts: CreateOptions) {
 
   const sv = (v: string) => new SemVer(v)
 
-  const versions = [[sv('1.0.0-beta.3'), sv(CLI_VERSION)]] as const
+  const versions = [[sv('1.0.0-beta.5'), sv(CLI_VERSION)]] as const
 
   const version = await select({
     message: 'Which version of Sandstone do you want to use? These are the only supported versions for new projects.',

package/src/commands/watch.ts

@@ -9,6 +9,7 @@ import { WatchUI, getWatchUIAPI } from '../ui/WatchUI.js'
 import { initLogger, log, logInfo, logWarn, logError, logDebug, logTrace, setLiveLogCallback } from '../ui/logger.js'
 import type { TrackedChange, ChangeCategory } from '../ui/types.js'
 import { hot } from '@sandstone-mc/hot-hook'
+import { resolveStackTrace } from '../utils/source-map.js'
 import fs from 'fs-extra'
 import { join, relative } from 'node:path'
 
@@ -33,7 +34,14 @@ function enableConsoleCapture() {
       .replace(/^Error\n/, '')
       .replace(/\?hot-hook=\d+/g, '')
       .replace(/file:\/\/\/?/g, '')
-    logTrace(...args, '\n' + cleanedStack)
+
+    // Resolve source maps for stack frames
+    const stackLines = cleanedStack.split('\n')
+    const traceStart = stackLines.findIndex(line => line.trimStart().startsWith('at '))
+    const stackTrace = traceStart >= 0 ? stackLines.slice(traceStart).join('\n') : ''
+    const resolvedStack = stackTrace ? resolveStackTrace(stackTrace) : cleanedStack
+
+    logTrace(...args, '\n' + resolvedStack)
   }
 }
 

package/src/ui/logger.ts

@@ -88,13 +88,14 @@ async function logWorkerMain(level: string | false, ...args: unknown[]) {
   const chunks: (string | Buffer | Uint8Array)[] = []
 
   // Timestamp and level prefix
-  chunks.push(`[${new Date().toISOString()}]${level !== false ? ` [${level}]` : ''} `)
+  const prefix = `[${new Date().toISOString()}]${level !== false ? ` [${level}]` : ''} `
+  chunks.push(prefix)
 
   // Process each argument
   for (let i = 0; i < args.length; i++) {
     const arg = args[i]
     if (typeof arg === 'string') {
-      chunks.push(stripVTControlCharacters(arg))
+      chunks.push(stripVTControlCharacters(arg).replaceAll('\n', `\n${' '.repeat(prefix.length)}`))
     } else if (Buffer.isBuffer(arg) || arg instanceof Uint8Array) {
       chunks.push(arg)
     } else if (arg instanceof ArrayBuffer) {
@@ -103,7 +104,7 @@ async function logWorkerMain(level: string | false, ...args: unknown[]) {
       chunks.push(new Uint8Array(await arg.arrayBuffer()))
     } else {
       // Use util.format for objects, numbers, etc.
-      chunks.push(format('%O', arg))
+      chunks.push(stripVTControlCharacters(format('%O', arg)).replaceAll('\n', `\n${' '.repeat(prefix.length)}`))
     }
     // Add space between args (but not after last)
     if (i < args.length - 1) {

package/src/utils/source-map.ts

@@ -0,0 +1,191 @@
+/**
+ * Source map resolution for stack traces.
+ *
+ * Bun doesn't automatically resolve source maps for bundled dependencies,
+ * so we manually parse and resolve them for better error messages.
+ */
+
+import { SourceMapConsumer, type RawSourceMap } from 'source-map-js'
+import { readFileSync } from 'fs'
+import { dirname, resolve } from 'path'
+
+// Cache for loaded source map consumers
+const sourceMapCache = new Map<string, SourceMapConsumer | null>()
+
+/**
+ * Synchronously load a source map for a given JS file.
+ * Returns null if no source map is found or it's invalid.
+ */
+function loadSourceMapSync(jsFilePath: string): SourceMapConsumer | null {
+  // Check cache first
+  if (sourceMapCache.has(jsFilePath)) {
+    return sourceMapCache.get(jsFilePath) ?? null
+  }
+
+  try {
+    // Read the JS file to find the sourceMappingURL
+    const jsContent = readFileSync(jsFilePath, 'utf8')
+
+    // Look for sourceMappingURL comment
+    const match = jsContent.match(/\/\/[#@]\s*sourceMappingURL=(.+)$/m)
+    if (!match) {
+      sourceMapCache.set(jsFilePath, null)
+      return null
+    }
+
+    const sourceMappingURL = match[1].trim()
+    let mapPath: string
+    let mapContent: string
+
+    if (sourceMappingURL.startsWith('data:')) {
+      // Inline source map (base64 encoded)
+      const base64Match = sourceMappingURL.match(/base64,(.+)/)
+      if (!base64Match) {
+        sourceMapCache.set(jsFilePath, null)
+        return null
+      }
+      mapContent = Buffer.from(base64Match[1], 'base64').toString('utf8')
+    } else {
+      // External source map file
+      mapPath = resolve(dirname(jsFilePath), sourceMappingURL)
+      mapContent = readFileSync(mapPath, 'utf8')
+    }
+
+    const rawMap: RawSourceMap = JSON.parse(mapContent)
+    const consumer = new SourceMapConsumer(rawMap)
+    sourceMapCache.set(jsFilePath, consumer)
+    return consumer
+  } catch {
+    sourceMapCache.set(jsFilePath, null)
+    return null
+  }
+}
+
+interface StackFrame {
+  original: string
+  filePath?: string
+  line?: number
+  column?: number
+  functionName?: string
+}
+
+/**
+ * Parse a single stack trace line.
+ */
+function parseStackLine(line: string): StackFrame {
+  // Match patterns like:
+  // "    at functionName (/path/to/file.js:123:45)"
+  // "    at /path/to/file.js:123:45"
+  // "    at async functionName (/path/to/file.js:123:45)"
+  const patterns = [
+    // Standard format: at functionName (file:line:col)
+    /^\s*at\s+(?:async\s+)?(.+?)\s+\((.+?):(\d+):(\d+)\)$/,
+    // Anonymous format: at file:line:col
+    /^\s*at\s+(?:async\s+)?(.+?):(\d+):(\d+)$/,
+    // Format with <anonymous>: at <anonymous> (file:line:col)
+    /^\s*at\s+<anonymous>\s+\((.+?):(\d+):(\d+)\)$/,
+  ]
+
+  for (const pattern of patterns) {
+    const match = line.match(pattern)
+    if (match) {
+      if (match.length === 5) {
+        // Pattern with function name
+        return {
+          original: line,
+          functionName: match[1],
+          filePath: match[2],
+          line: parseInt(match[3], 10),
+          column: parseInt(match[4], 10),
+        }
+      } else if (match.length === 4) {
+        // Pattern without function name or <anonymous>
+        return {
+          original: line,
+          filePath: match[1],
+          line: parseInt(match[2], 10),
+          column: parseInt(match[3], 10),
+        }
+      }
+    }
+  }
+
+  return { original: line }
+}
+
+/**
+ * Resolve a stack frame using source maps (synchronous).
+ */
+function resolveStackFrame(frame: StackFrame): string {
+  if (!frame.filePath || !frame.line || !frame.column) {
+    return frame.original
+  }
+
+  // Skip native or internal frames
+  if (frame.filePath.includes('(native)') || frame.filePath === 'native') {
+    return frame.original
+  }
+
+  try {
+    const consumer = loadSourceMapSync(frame.filePath)
+    if (!consumer) {
+      return frame.original
+    }
+
+    const pos = consumer.originalPositionFor({
+      line: frame.line,
+      column: frame.column - 1, // source-map uses 0-based columns
+    })
+
+    if (pos.source && pos.line !== null) {
+      // Resolve the source path relative to the JS file
+      const sourceDir = dirname(frame.filePath)
+      const originalPath = resolve(sourceDir, pos.source)
+
+      // Use source map name if available, then fall back to frame's function name
+      // The frame's function name comes from the runtime stack and is often correct
+      // even when the source map doesn't have name mappings
+      const functionPart = pos.name ?? frame.functionName ?? '<anonymous>'
+      const location = `${originalPath}:${pos.line}:${(pos.column ?? 0) + 1}`
+
+      if (functionPart) {
+        return `    at ${functionPart} (${location})`
+      }
+      return `    at ${location}`
+    }
+  } catch {
+    // If resolution fails, return original
+  }
+
+  return frame.original
+}
+
+/**
+ * Resolve source maps in a stack trace string (synchronous).
+ * Returns the stack trace with original source locations where possible.
+ */
+export function resolveStackTrace(stack: string): string {
+  const lines = stack.split('\n')
+  const resolvedLines: string[] = []
+
+  for (const line of lines) {
+    // Only process lines that look like stack frames
+    if (line.trimStart().startsWith('at ')) {
+      const frame = parseStackLine(line)
+      const resolved = resolveStackFrame(frame)
+      resolvedLines.push(resolved)
+    } else {
+      resolvedLines.push(line)
+    }
+  }
+
+  return resolvedLines.join('\n')
+}
+
+/**
+ * Clear the source map cache.
+ * Call this between builds if source maps may have changed.
+ */
+export function clearSourceMapCache(): void {
+  sourceMapCache.clear()
+}

package/src/version.ts

@@ -1 +1 @@
-export const CLI_VERSION = '2.3.2'
+export const CLI_VERSION = '2.4.1'