redscript-mc 1.0.0

package/src/mc-validator/index.ts

@@ -0,0 +1,367 @@
+import * as fs from 'fs'
+
+interface BrigadierFile {
+  root: BrigadierNode
+}
+
+interface BrigadierNode {
+  type?: 'literal' | 'argument' | 'root'
+  name?: string
+  executable?: boolean
+  children?: BrigadierNode[]
+  redirects?: string[]
+  parser?: {
+    parser: string
+    modifier?: {
+      type?: string
+    } | null
+  }
+}
+
+export interface ValidationResult {
+  valid: boolean
+  error?: string
+}
+
+const FUNCTION_ID_RE = /^[0-9a-z_.-]+:[0-9a-z_./-]+$/i
+const INTEGER_RE = /^-?\d+$/
+const SCORE_RANGE_RE = /^-?\d+\.\.$|^\.\.-?\d+$|^-?\d+\.\.-?\d+$|^-?\d+$/
+const COMMENT_PREFIXES = [
+  '# RedScript runtime init',
+  '# block:',
+  '# RedScript tick dispatcher',
+]
+const SCOREBOARD_PLAYER_ACTIONS = new Set(['set', 'add', 'remove', 'get', 'operation', 'enable'])
+const SCOREBOARD_OPERATIONS = new Set(['=', '+=', '-=', '*=', '/=', '%=', '<', '>', '><'])
+
+export class MCCommandValidator {
+  private readonly root: BrigadierNode
+  private readonly rootChildren: BrigadierNode[]
+
+  constructor(commandsPath: string) {
+    const parsed = JSON.parse(fs.readFileSync(commandsPath, 'utf-8')) as BrigadierFile
+    this.root = parsed.root
+    this.rootChildren = parsed.root.children ?? []
+  }
+
+  validate(line: string): ValidationResult {
+    const trimmed = line.trim()
+    if (!trimmed || trimmed.startsWith('#') || COMMENT_PREFIXES.some(prefix => trimmed.startsWith(prefix))) {
+      return { valid: true }
+    }
+
+    const tokens = tokenize(trimmed)
+    if (tokens.length === 0) {
+      return { valid: true }
+    }
+
+    if (!this.hasRootCommand(tokens[0])) {
+      return { valid: false, error: `Unknown root command: ${tokens[0]}` }
+    }
+
+    switch (tokens[0]) {
+      case 'execute':
+        return this.validateExecute(tokens)
+      case 'scoreboard':
+        return this.validateScoreboard(tokens)
+      case 'function':
+        return this.validateFunction(tokens)
+      case 'data':
+        return this.validateData(tokens)
+      case 'return':
+        return this.validateReturn(tokens)
+      default:
+        return this.validateAgainstTree(tokens)
+    }
+  }
+
+  private hasRootCommand(command: string): boolean {
+    return this.rootChildren.some(child => child.type === 'literal' && child.name === command)
+  }
+
+  private validateExecute(tokens: string[]): ValidationResult {
+    const runIndex = tokens.indexOf('run')
+    if (runIndex === 1 || runIndex === tokens.length - 1) {
+      return { valid: false, error: 'Malformed execute run clause' }
+    }
+
+    if (runIndex !== -1) {
+      const chainResult = this.validateAgainstTree(tokens.slice(0, runIndex))
+      if (!chainResult.valid) {
+        return chainResult
+      }
+
+      return this.validate(tokens.slice(runIndex + 1).join(' '))
+    }
+
+    return this.validateAgainstTree(tokens)
+  }
+
+  private validateScoreboard(tokens: string[]): ValidationResult {
+    if (tokens[1] === 'objectives' && tokens[2] === 'add') {
+      if (tokens.length < 5) {
+        return { valid: false, error: 'scoreboard objectives add requires name and criteria' }
+      }
+      return this.validateAgainstTree(tokens)
+    }
+
+    if (tokens[1] !== 'players' || !SCOREBOARD_PLAYER_ACTIONS.has(tokens[2] ?? '')) {
+      return this.validateAgainstTree(tokens)
+    }
+
+    const action = tokens[2]
+    if (action === 'enable') {
+      if (tokens.length !== 5) {
+        return { valid: false, error: 'scoreboard players enable requires target and objective' }
+      }
+      return this.validateAgainstTree(tokens)
+    }
+
+    if (action === 'get') {
+      if (tokens.length !== 5) {
+        return { valid: false, error: 'scoreboard players get requires target and objective' }
+      }
+      return this.validateAgainstTree(tokens)
+    }
+
+    if (action === 'operation') {
+      if (tokens.length !== 8) {
+        return { valid: false, error: 'scoreboard players operation requires 5 operands' }
+      }
+      if (!SCOREBOARD_OPERATIONS.has(tokens[5])) {
+        return { valid: false, error: `Unknown scoreboard operation: ${tokens[5]}` }
+      }
+      return this.validateAgainstTree(tokens)
+    }
+
+    if (tokens.length !== 6) {
+      return { valid: false, error: `scoreboard players ${action} requires target, objective, and value` }
+    }
+
+    if (!INTEGER_RE.test(tokens[5])) {
+      return { valid: false, error: `Expected integer value, got: ${tokens[5]}` }
+    }
+
+    return this.validateAgainstTree(tokens)
+  }
+
+  private validateFunction(tokens: string[]): ValidationResult {
+    if (tokens.length !== 2 || !FUNCTION_ID_RE.test(tokens[1])) {
+      return { valid: false, error: 'function requires a namespaced function id' }
+    }
+
+    return this.validateAgainstTree(tokens)
+  }
+
+  private validateData(tokens: string[]): ValidationResult {
+    if (tokens.length < 5) {
+      return { valid: false, error: 'data command is incomplete' }
+    }
+
+    const action = tokens[1]
+    if (!['get', 'modify', 'merge', 'remove'].includes(action)) {
+      return this.validateAgainstTree(tokens)
+    }
+
+    const targetType = tokens[2]
+    if (!['storage', 'entity', 'block'].includes(targetType)) {
+      return { valid: false, error: `Unsupported data target: ${targetType}` }
+    }
+
+    if (action === 'get') {
+      if (tokens.length < 5) {
+        return { valid: false, error: 'data get requires target and path' }
+      }
+      if (tokens[5] && !isNumberish(tokens[5])) {
+        return { valid: false, error: `Invalid data get scale: ${tokens[5]}` }
+      }
+      return this.validateAgainstTree(tokens)
+    }
+
+    if (action === 'modify') {
+      if (tokens.length < 7) {
+        return { valid: false, error: 'data modify is incomplete' }
+      }
+      if (!['set', 'append', 'prepend', 'insert', 'merge'].includes(tokens[5])) {
+        return { valid: false, error: `Unsupported data modify mode: ${tokens[5]}` }
+      }
+      return this.validateAgainstTree(tokens)
+    }
+
+    return this.validateAgainstTree(tokens)
+  }
+
+  private validateReturn(tokens: string[]): ValidationResult {
+    if (tokens.length < 2) {
+      return { valid: false, error: 'return requires a value or run clause' }
+    }
+
+    if (tokens[1] === 'run') {
+      if (tokens.length < 3) {
+        return { valid: false, error: 'return run requires an inner command' }
+      }
+      return this.validate(tokens.slice(2).join(' '))
+    }
+
+    if (!INTEGER_RE.test(tokens[1])) {
+      return { valid: false, error: `Invalid return value: ${tokens[1]}` }
+    }
+
+    return this.validateAgainstTree(tokens)
+  }
+
+  private validateAgainstTree(tokens: string[]): ValidationResult {
+    const memo = new Map<string, boolean>()
+    const isValid = walk(this.root, tokens, 0, memo, this.rootChildren)
+
+    return isValid
+      ? { valid: true }
+      : { valid: false, error: `Command does not match Brigadier tree: ${tokens.join(' ')}` }
+  }
+}
+
+function walk(
+  node: BrigadierNode,
+  tokens: string[],
+  index: number,
+  memo: Map<string, boolean>,
+  rootChildren: BrigadierNode[]
+): boolean {
+  const key = `${node.name ?? '<root>'}:${index}`
+  const cached = memo.get(key)
+  if (cached !== undefined) {
+    return cached
+  }
+
+  if (index === tokens.length) {
+    const done = node.executable === true || (node.children ?? []).length === 0
+    memo.set(key, done)
+    return done
+  }
+
+  const children = node.children ?? []
+  for (const child of children) {
+    if (child.type === 'literal') {
+      if (child.name === tokens[index] && walk(child, tokens, index + 1, memo, rootChildren)) {
+        memo.set(key, true)
+        return true
+      }
+      continue
+    }
+
+    if (child.type !== 'argument') {
+      continue
+    }
+
+    const parser = child.parser?.parser
+    const modifier = child.parser?.modifier?.type
+    if (parserConsumesRest(parser, modifier)) {
+      const done = child.executable === true || (child.children ?? []).length === 0
+      if (done) {
+        memo.set(key, true)
+        return true
+      }
+    }
+
+    const width = parserTokenWidth(parser, tokens, index)
+    if (width === null) {
+      continue
+    }
+
+    const nextIndex = index + width
+    if (walk(child, tokens, nextIndex, memo, rootChildren)) {
+      memo.set(key, true)
+      return true
+    }
+
+    for (const redirect of child.redirects ?? []) {
+      const target = rootChildren.find(candidate => candidate.name === redirect)
+      if (target && walk(target, tokens, nextIndex, memo, rootChildren)) {
+        memo.set(key, true)
+        return true
+      }
+    }
+  }
+
+  memo.set(key, false)
+  return false
+}
+
+function parserConsumesRest(parser?: string, modifier?: string): boolean {
+  return (
+    (parser === 'brigadier:string' && modifier === 'greedy') ||
+    parser === 'minecraft:message'
+  )
+}
+
+function parserTokenWidth(parser: string | undefined, tokens: string[], index: number): number | null {
+  switch (parser) {
+    case 'minecraft:vec3':
+    case 'minecraft:block_pos':
+      return index + 3 <= tokens.length ? 3 : null
+    case 'minecraft:vec2':
+    case 'minecraft:column_pos':
+    case 'minecraft:rotation':
+      return index + 2 <= tokens.length ? 2 : null
+    default:
+      return index < tokens.length ? 1 : null
+  }
+}
+
+function tokenize(line: string): string[] {
+  const tokens: string[] = []
+  let current = ''
+  let quote: '"' | '\'' | null = null
+  let escape = false
+  let bracketDepth = 0
+  let braceDepth = 0
+
+  for (const char of line) {
+    if (escape) {
+      current += char
+      escape = false
+      continue
+    }
+
+    if (quote) {
+      current += char
+      if (char === '\\') {
+        escape = true
+      } else if (char === quote) {
+        quote = null
+      }
+      continue
+    }
+
+    if (char === '"' || char === '\'') {
+      quote = char
+      current += char
+      continue
+    }
+
+    if (char === '[') bracketDepth += 1
+    if (char === ']') bracketDepth = Math.max(0, bracketDepth - 1)
+    if (char === '{') braceDepth += 1
+    if (char === '}') braceDepth = Math.max(0, braceDepth - 1)
+
+    if (/\s/.test(char) && bracketDepth === 0 && braceDepth === 0) {
+      if (current) {
+        tokens.push(current)
+        current = ''
+      }
+      continue
+    }
+
+    current += char
+  }
+
+  if (current) {
+    tokens.push(current)
+  }
+
+  return tokens
+}
+
+function isNumberish(value: string): boolean {
+  return /^-?\d+(\.\d+)?$/.test(value) || SCORE_RANGE_RE.test(value)
+}

package/src/nbt/index.ts

@@ -0,0 +1,321 @@
+export const enum TagType {
+  End = 0,
+  Byte = 1,
+  Short = 2,
+  Int = 3,
+  Long = 4,
+  Float = 5,
+  Double = 6,
+  ByteArray = 7,
+  String = 8,
+  List = 9,
+  Compound = 10,
+  IntArray = 11,
+  LongArray = 12,
+}
+
+export type EndTag = { type: TagType.End }
+export type ByteTag = { type: TagType.Byte; value: number }
+export type ShortTag = { type: TagType.Short; value: number }
+export type IntTag = { type: TagType.Int; value: number }
+export type LongTag = { type: TagType.Long; value: bigint }
+export type FloatTag = { type: TagType.Float; value: number }
+export type DoubleTag = { type: TagType.Double; value: number }
+export type ByteArrayTag = { type: TagType.ByteArray; value: Int8Array }
+export type StringTag = { type: TagType.String; value: string }
+export type ListTag = { type: TagType.List; elementType: TagType; items: NbtTag[] }
+export type CompoundTag = { type: TagType.Compound; entries: Map<string, NbtTag> }
+export type IntArrayTag = { type: TagType.IntArray; value: Int32Array }
+export type LongArrayTag = { type: TagType.LongArray; value: BigInt64Array }
+
+export type NbtTag =
+  | EndTag
+  | ByteTag
+  | ShortTag
+  | IntTag
+  | LongTag
+  | FloatTag
+  | DoubleTag
+  | ByteArrayTag
+  | StringTag
+  | ListTag
+  | CompoundTag
+  | IntArrayTag
+  | LongArrayTag
+
+function encodeModifiedUtf8(value: string): Buffer {
+  const bytes: number[] = []
+
+  for (let i = 0; i < value.length; i++) {
+    const codeUnit = value.charCodeAt(i)
+
+    if (codeUnit !== 0 && codeUnit <= 0x7f) {
+      bytes.push(codeUnit)
+      continue
+    }
+
+    if (codeUnit <= 0x07ff) {
+      bytes.push(
+        0xc0 | ((codeUnit >> 6) & 0x1f),
+        0x80 | (codeUnit & 0x3f)
+      )
+      continue
+    }
+
+    bytes.push(
+      0xe0 | ((codeUnit >> 12) & 0x0f),
+      0x80 | ((codeUnit >> 6) & 0x3f),
+      0x80 | (codeUnit & 0x3f)
+    )
+  }
+
+  if (bytes.length > 0xffff) {
+    throw new Error(`NBT string is too long: ${bytes.length} bytes`)
+  }
+
+  const buffer = Buffer.allocUnsafe(2 + bytes.length)
+  buffer.writeUInt16BE(bytes.length, 0)
+  for (let i = 0; i < bytes.length; i++) {
+    buffer[2 + i] = bytes[i]
+  }
+  return buffer
+}
+
+function decodeModifiedUtf8(buffer: Buffer, offset: number): { value: string; offset: number } {
+  const byteLength = buffer.readUInt16BE(offset)
+  offset += 2
+
+  const codeUnits: number[] = []
+  const end = offset + byteLength
+
+  while (offset < end) {
+    const first = buffer[offset++]
+
+    if ((first & 0x80) === 0) {
+      codeUnits.push(first)
+      continue
+    }
+
+    if ((first & 0xe0) === 0xc0) {
+      const second = buffer[offset++]
+      codeUnits.push(((first & 0x1f) << 6) | (second & 0x3f))
+      continue
+    }
+
+    const second = buffer[offset++]
+    const third = buffer[offset++]
+    codeUnits.push(
+      ((first & 0x0f) << 12) |
+      ((second & 0x3f) << 6) |
+      (third & 0x3f)
+    )
+  }
+
+  return {
+    value: String.fromCharCode(...codeUnits),
+    offset,
+  }
+}
+
+function writePayload(tag: NbtTag): Buffer {
+  switch (tag.type) {
+    case TagType.End:
+      return Buffer.alloc(0)
+    case TagType.Byte: {
+      const buffer = Buffer.allocUnsafe(1)
+      buffer.writeInt8(tag.value, 0)
+      return buffer
+    }
+    case TagType.Short: {
+      const buffer = Buffer.allocUnsafe(2)
+      buffer.writeInt16BE(tag.value, 0)
+      return buffer
+    }
+    case TagType.Int: {
+      const buffer = Buffer.allocUnsafe(4)
+      buffer.writeInt32BE(tag.value, 0)
+      return buffer
+    }
+    case TagType.Long: {
+      const buffer = Buffer.allocUnsafe(8)
+      buffer.writeBigInt64BE(tag.value, 0)
+      return buffer
+    }
+    case TagType.Float: {
+      const buffer = Buffer.allocUnsafe(4)
+      buffer.writeFloatBE(tag.value, 0)
+      return buffer
+    }
+    case TagType.Double: {
+      const buffer = Buffer.allocUnsafe(8)
+      buffer.writeDoubleBE(tag.value, 0)
+      return buffer
+    }
+    case TagType.ByteArray: {
+      const header = Buffer.allocUnsafe(4)
+      header.writeInt32BE(tag.value.length, 0)
+      return Buffer.concat([header, Buffer.from(tag.value)])
+    }
+    case TagType.String:
+      return encodeModifiedUtf8(tag.value)
+    case TagType.List: {
+      const header = Buffer.allocUnsafe(5)
+      header.writeUInt8(tag.elementType, 0)
+      header.writeInt32BE(tag.items.length, 1)
+      return Buffer.concat([header, ...tag.items.map(writePayload)])
+    }
+    case TagType.Compound: {
+      const parts: Buffer[] = []
+      for (const [name, entry] of tag.entries) {
+        parts.push(writeNamedTag(entry, name))
+      }
+      parts.push(Buffer.from([TagType.End]))
+      return Buffer.concat(parts)
+    }
+    case TagType.IntArray: {
+      const header = Buffer.allocUnsafe(4 + tag.value.length * 4)
+      header.writeInt32BE(tag.value.length, 0)
+      for (let i = 0; i < tag.value.length; i++) {
+        header.writeInt32BE(tag.value[i], 4 + i * 4)
+      }
+      return header
+    }
+    case TagType.LongArray: {
+      const header = Buffer.allocUnsafe(4 + tag.value.length * 8)
+      header.writeInt32BE(tag.value.length, 0)
+      for (let i = 0; i < tag.value.length; i++) {
+        header.writeBigInt64BE(tag.value[i], 4 + i * 8)
+      }
+      return header
+    }
+  }
+}
+
+function writeNamedTag(tag: NbtTag, name: string): Buffer {
+  if (tag.type === TagType.End) {
+    throw new Error('TAG_End cannot be written as a named tag')
+  }
+
+  const nameBuffer = encodeModifiedUtf8(name)
+  return Buffer.concat([
+    Buffer.from([tag.type]),
+    nameBuffer,
+    writePayload(tag),
+  ])
+}
+
+function readPayload(type: TagType, buffer: Buffer, offset: number): { tag: NbtTag; offset: number } {
+  switch (type) {
+    case TagType.End:
+      return { tag: { type: TagType.End }, offset }
+    case TagType.Byte:
+      return { tag: { type: type, value: buffer.readInt8(offset) }, offset: offset + 1 }
+    case TagType.Short:
+      return { tag: { type: type, value: buffer.readInt16BE(offset) }, offset: offset + 2 }
+    case TagType.Int:
+      return { tag: { type: type, value: buffer.readInt32BE(offset) }, offset: offset + 4 }
+    case TagType.Long:
+      return { tag: { type: type, value: buffer.readBigInt64BE(offset) }, offset: offset + 8 }
+    case TagType.Float:
+      return { tag: { type: type, value: buffer.readFloatBE(offset) }, offset: offset + 4 }
+    case TagType.Double:
+      return { tag: { type: type, value: buffer.readDoubleBE(offset) }, offset: offset + 8 }
+    case TagType.ByteArray: {
+      const length = buffer.readInt32BE(offset)
+      offset += 4
+      const value = new Int8Array(length)
+      for (let i = 0; i < length; i++) {
+        value[i] = buffer.readInt8(offset + i)
+      }
+      return { tag: { type, value }, offset: offset + length }
+    }
+    case TagType.String: {
+      const decoded = decodeModifiedUtf8(buffer, offset)
+      return { tag: { type, value: decoded.value }, offset: decoded.offset }
+    }
+    case TagType.List: {
+      const elementType = buffer.readUInt8(offset) as TagType
+      const length = buffer.readInt32BE(offset + 1)
+      offset += 5
+      const items: NbtTag[] = []
+      for (let i = 0; i < length; i++) {
+        const parsed = readPayload(elementType, buffer, offset)
+        items.push(parsed.tag)
+        offset = parsed.offset
+      }
+      return { tag: { type, elementType, items }, offset }
+    }
+    case TagType.Compound: {
+      const entries = new Map<string, NbtTag>()
+      while (true) {
+        const entryType = buffer.readUInt8(offset) as TagType
+        offset += 1
+        if (entryType === TagType.End) break
+        const name = decodeModifiedUtf8(buffer, offset)
+        offset = name.offset
+        const parsed = readPayload(entryType, buffer, offset)
+        entries.set(name.value, parsed.tag)
+        offset = parsed.offset
+      }
+      return { tag: { type, entries }, offset }
+    }
+    case TagType.IntArray: {
+      const length = buffer.readInt32BE(offset)
+      offset += 4
+      const value = new Int32Array(length)
+      for (let i = 0; i < length; i++) {
+        value[i] = buffer.readInt32BE(offset + i * 4)
+      }
+      return { tag: { type, value }, offset: offset + length * 4 }
+    }
+    case TagType.LongArray: {
+      const length = buffer.readInt32BE(offset)
+      offset += 4
+      const value = new BigInt64Array(length)
+      for (let i = 0; i < length; i++) {
+        value[i] = buffer.readBigInt64BE(offset + i * 8)
+      }
+      return { tag: { type, value }, offset: offset + length * 8 }
+    }
+    default:
+      throw new Error(`Unsupported NBT tag type: ${type}`)
+  }
+}
+
+export function writeNbt(tag: NbtTag, name: string): Buffer {
+  return writeNamedTag(tag, name)
+}
+
+export function readNbt(buffer: Buffer): { name: string; tag: NbtTag } {
+  let offset = 0
+  const type = buffer.readUInt8(offset) as TagType
+  offset += 1
+
+  if (type === TagType.End) {
+    throw new Error('Invalid root tag: TAG_End')
+  }
+
+  const decodedName = decodeModifiedUtf8(buffer, offset)
+  offset = decodedName.offset
+  const parsed = readPayload(type, buffer, offset)
+
+  return {
+    name: decodedName.value,
+    tag: parsed.tag,
+  }
+}
+
+export const nbt = {
+  byte: (value: number): ByteTag => ({ type: TagType.Byte, value }),
+  short: (value: number): ShortTag => ({ type: TagType.Short, value }),
+  int: (value: number): IntTag => ({ type: TagType.Int, value }),
+  long: (value: bigint): LongTag => ({ type: TagType.Long, value }),
+  float: (value: number): FloatTag => ({ type: TagType.Float, value }),
+  double: (value: number): DoubleTag => ({ type: TagType.Double, value }),
+  string: (value: string): StringTag => ({ type: TagType.String, value }),
+  list: (elementType: TagType, items: NbtTag[]): ListTag => ({ type: TagType.List, elementType, items }),
+  compound: (entries: Record<string, NbtTag>): CompoundTag =>
+    ({ type: TagType.Compound, entries: new Map(Object.entries(entries)) }),
+  intArray: (values: number[]): IntArrayTag => ({ type: TagType.IntArray, value: Int32Array.from(values) }),
+  byteArray: (values: number[]): ByteArrayTag => ({ type: TagType.ByteArray, value: Int8Array.from(values) }),
+}