wao 0.41.3 → 0.41.5

package/src/cli.js

@@ -0,0 +1,561 @@
+#!/usr/bin/env node
+import pm2 from "pm2"
+import { dirname } from "./utils.js"
+import { resolve } from "path"
+const args = process.argv.slice(2)
+import util from "node:util"
+import { exec as _exec } from "node:child_process"
+const exec = util.promisify(_exec)
+import { cpSync, existsSync, writeFileSync } from "fs"
+import { createInterface } from "readline"
+import Arweave from "arweave"
+
+const cmds = {
+  wao: { script: "run.js" },
+  hub: { script: "hub/index.js" },
+  fs: { script: "hub/fs.js" },
+  proxy: { script: "hub/ws-proxy.js" },
+  create: { script: "create.js" },
+  build: { handler: "build" },
+}
+
+const cmd = cmds[args[0]] ?? cmds["wao"]
+const isCreate = args[0] === "create"
+const isBuild = args[0] === "build"
+if (cmds[args[0]]) args.shift()
+
+if (!cmd) {
+  console.log("The wrong command")
+  process.exit()
+}
+
+const dim = t => `\x1b[2m${t}\x1b[22m`
+const bold = t => `\x1b[1m${t}\x1b[22m`
+const cyan = t => `\x1b[36m${t}\x1b[39m`
+const green = t => `\x1b[32m${t}\x1b[39m`
+const red = t => `\x1b[31m${t}\x1b[39m`
+const yellow = t => `\x1b[33m${t}\x1b[39m`
+const magenta = t => `\x1b[35m${t}\x1b[39m`
+
+const splash = () => {
+  const logo = [
+    "██╗    ██╗ █████╗  ██████╗ ",
+    "██║    ██║██╔══██╗██╔═══██╗",
+    "██║ █╗ ██║███████║██║   ██║",
+    "██║███╗██║██╔══██║██║   ██║",
+    "╚███╔███╔╝██║  ██║╚██████╔╝",
+    " ╚══╝╚══╝ ╚═╝  ╚═╝ ╚═════╝ ",
+  ]
+  console.log()
+  for (const line of logo) console.log(`  ${cyan(line)}`)
+  console.log(`  ${dim("WizardAO SDK for Vibe Engineering")}`)
+  console.log()
+}
+
+const tree = title => {
+  const frames = ["◒", "◐", "◓", "◑"]
+  const steps = []
+  let active = null
+  let intervalId = null
+  let startTime = Date.now()
+
+  const elapsed = from => {
+    const ms = Date.now() - from
+    return ms < 1000 ? `${ms}ms` : `${(ms / 1000).toFixed(1)}s`
+  }
+
+  const render = () => {
+    const lines = []
+    lines.push("")
+    lines.push(`  ${bold(title)}`)
+    lines.push("")
+    for (let i = 0; i < steps.length; i++) {
+      const s = steps[i]
+      const isLast = i === steps.length - 1 && !active
+      const branch = isLast ? "  └" : "  │"
+      if (s.status === "done") {
+        lines.push(`${branch}  ${green("✔")} ${s.label}`)
+      } else if (s.status === "fail") {
+        lines.push(`${branch}  ${red("✘")} ${red(s.label)}`)
+      }
+      if (s.children) {
+        for (const c of s.children) {
+          const childBranch = isLast ? "   " : "  │"
+          lines.push(`${childBranch}    ${dim(c)}`)
+        }
+      }
+    }
+    if (active) {
+      const frame = frames[active.tick++ % frames.length]
+      const isLast = true
+      lines.push(`  └  ${cyan(frame)} ${active.label}${dim("...")}`)
+    }
+    lines.push("")
+    return lines.join("\n")
+  }
+
+  const clear = lineCount => {
+    process.stdout.write(`\x1b[${lineCount}A\x1b[0J`)
+  }
+
+  let lastLineCount = 0
+
+  const paint = () => {
+    if (lastLineCount > 0) clear(lastLineCount)
+    const output = render()
+    process.stdout.write(output)
+    lastLineCount = output.split("\n").length - 1
+  }
+
+  const startSpin = () => {
+    paint()
+    intervalId = setInterval(paint, 120)
+  }
+
+  const stopSpin = () => {
+    if (intervalId) {
+      clearInterval(intervalId)
+      intervalId = null
+    }
+  }
+
+  return {
+    step: label => {
+      stopSpin()
+      if (active) {
+        active.status = "done"
+        steps.push(active)
+      }
+      active = {
+        label,
+        status: "active",
+        tick: 0,
+        start: Date.now(),
+        children: null,
+      }
+      startSpin()
+    },
+
+    sub: text => {
+      if (active) {
+        active.children = active.children || []
+        active.children.push(text)
+      }
+      paint()
+    },
+
+    done: () => {
+      stopSpin()
+      if (active) {
+        active.status = "done"
+        steps.push(active)
+        active = null
+      }
+      paint()
+    },
+
+    fail: label => {
+      stopSpin()
+      if (active) {
+        active.status = "fail"
+        if (label) active.label = label
+        steps.push(active)
+        active = null
+      }
+      paint()
+    },
+
+    summary: fn => {
+      stopSpin()
+      if (active) {
+        active.status = "done"
+        steps.push(active)
+        active = null
+      }
+      paint()
+      const total = elapsed(startTime)
+      console.log(dim(`  Completed in ${total}`))
+      console.log()
+      fn()
+    },
+  }
+}
+
+const ask = question =>
+  new Promise(res => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout })
+    rl.question(question, answer => {
+      rl.close()
+      res(answer.trim().toLowerCase())
+    })
+  })
+
+
+const HB_REPO = "https://github.com/permaweb/HyperBEAM.git"
+const HB_TAG = "v0.9-FINAL"
+
+const which = async cmd => {
+  try {
+    const { stdout } = await exec(`which ${cmd} 2>/dev/null`)
+    return stdout.trim()
+  } catch {
+    return null
+  }
+}
+
+const getVersion = async (cmd, flag = "--version") => {
+  try {
+    const { stdout } = await exec(`${cmd} ${flag} 2>&1`)
+    return stdout.trim().split("\n")[0]
+  } catch {
+    return null
+  }
+}
+
+const detectGCC = async () => {
+  for (const v of [14, 13, 12, 11]) {
+    if (await which(`gcc-${v}`)) return v
+  }
+  if (await which("gcc")) return null
+  return false
+}
+
+const detectHBEnv = async () => {
+  const deps = {}
+  const missing = []
+
+  // Erlang/OTP
+  const erlPath = await which("erl")
+  if (erlPath) {
+    const ver = await getVersion(
+      "erl",
+      '-eval \'{ok, V} = file:read_file(filename:join([code:root_dir(), "releases", erlang:system_info(otp_release), "OTP_VERSION"])), io:fwrite(V), halt().\' -noshell'
+    )
+    deps.erl = { path: erlPath, version: ver }
+  } else {
+    missing.push("erlang (OTP 27+ required)")
+  }
+
+  // Rebar3
+  const rebar3Path = await which("rebar3")
+  if (rebar3Path) {
+    deps.rebar3 = { path: rebar3Path }
+  } else {
+    missing.push("rebar3")
+  }
+
+  // GCC
+  const gccVersion = await detectGCC()
+  if (gccVersion === false) {
+    missing.push("gcc")
+  } else {
+    deps.gcc = gccVersion
+  }
+
+  // CMake
+  const cmakePath = await which("cmake")
+  if (cmakePath) {
+    deps.cmake = { path: cmakePath }
+  } else {
+    missing.push("cmake (>= 3.5)")
+  }
+
+  return { deps, missing }
+}
+
+const create = async () => {
+  const appname = args[0] ?? "waoapp"
+  const appdir = resolve(process.cwd(), appname)
+  if (existsSync(appdir))
+    return console.error(
+      `\n  ${red("✘")} Directory already exists: ${bold(appdir)}\n`
+    )
+  const app = resolve(await dirname(), "workspace")
+
+  console.log()
+  console.log(`  ${bold("HyperBEAM:")}`)
+  const col = 6 + HB_TAG.length
+  const pad = " ".repeat(col - "Use existing".length)
+  const pad2 = " ".repeat(col - "Skip".length)
+  console.log(`    ${dim("1.")} Clone ${cyan(HB_TAG)}  ${dim("(from GitHub)")}`)
+  console.log(`    ${dim("2.")} Use existing${pad}  ${dim("(path to local dir)")}`)
+  console.log(`    ${dim("3.")} Skip${pad2}  ${dim("(in-memory AOS only)")}`)
+  console.log()
+  const hbChoice = await ask(`  Choose ${dim("(1/2/3)")} [1]: `)
+  const hbMode = hbChoice === "2" ? "existing" : hbChoice === "3" ? "skip" : "clone"
+
+  let hbPath = null
+  if (hbMode === "existing") {
+    hbPath = await ask(`  Path to HyperBEAM directory: `)
+    const absPath = resolve(process.cwd(), hbPath)
+    if (!existsSync(absPath)) {
+      console.error(`\n  ${red("✘")} Directory not found: ${bold(absPath)}\n`)
+      process.exit(1)
+    }
+    hbPath = absPath
+  }
+
+  console.log()
+  console.log(`  ${bold("Frontend:")}`)
+  console.log(`    ${dim("1.")} Skip             ${dim("(backend only)")}`)
+  console.log(
+    `    ${dim("2.")} Vite + wao/web   ${dim("(React SPA with ArConnect)")}`
+  )
+  console.log()
+  const feChoice = await ask(`  Choose ${dim("(1/2)")} [1]: `)
+  const withFrontend = feChoice === "2"
+
+  console.log()
+
+  const t = tree(`Creating ${cyan(appname)}`)
+
+  try {
+    t.step("Scaffolding project files")
+    cpSync(app, appdir, {
+      recursive: true,
+      filter: src => {
+        if (!withFrontend && src.includes("/frontend")) return false
+        return true
+      },
+    })
+    t.sub("src/counter.lua, token.lua, registry.lua")
+    t.sub("test/ (aos, token, registry, hyperbeam)")
+    t.sub("scripts/deploy.js")
+    if (withFrontend) t.sub("frontend/ (Vite + React + wao/web)")
+    t.done()
+
+    t.step("Setting up Claude Code toolchain")
+    t.sub("CLAUDE.md")
+    t.sub(".claude/rules/ (lua, testing, deploy)")
+    t.sub(".claude/skills/ (test, deploy, create-handler)")
+    t.sub(".claude/agents/ (builder, tester)")
+    t.done()
+
+    t.step("Generating admin wallet")
+    const arweave = Arweave.init()
+    const jwk = await arweave.wallets.generate()
+    const addr = await arweave.wallets.jwkToAddress(jwk)
+    writeFileSync(resolve(appdir, ".wallet.json"), JSON.stringify(jwk))
+    t.sub(`address: ${addr}`)
+    t.done()
+
+    t.step("Installing dependencies")
+    const { error } = await exec(`cd ${appdir} && yarn --ignore-engines`)
+    if (error) {
+      t.fail("Failed to install dependencies")
+      return
+    }
+    t.done()
+
+    t.step("Installing HyperADD dashboard")
+    await exec(`cd "${resolve(appdir, "dashboard")}" && npm install --silent`)
+    t.sub("dashboard/ (Vite + React)")
+    t.sub("MCP server (.claude/mcp/dashboard/)")
+    t.done()
+
+    let hbWarnings = []
+
+    if (hbMode !== "skip") {
+      t.step("Detecting HyperBEAM environment")
+      const { deps, missing } = await detectHBEnv()
+
+      const hbCwd = hbMode === "existing" ? hbPath : "./HyperBEAM"
+      const envLines = [`CWD=${hbCwd}`]
+
+      if (deps.erl) t.sub(`${green("✔")} erlang ${deps.erl.version || ""}`)
+      if (deps.rebar3) t.sub(`${green("✔")} rebar3`)
+      if (deps.gcc) {
+        t.sub(`${green("✔")} gcc-${deps.gcc}`)
+        envLines.push(`CC=gcc-${deps.gcc}`)
+        envLines.push(`CXX=g++-${deps.gcc}`)
+      } else if (deps.gcc === null) {
+        t.sub(`${yellow("~")} gcc found (no versioned binary, using default)`)
+      }
+      if (deps.cmake) {
+        t.sub(`${green("✔")} cmake`)
+        envLines.push(`CMAKE_POLICY_VERSION_MINIMUM=3.5`)
+      }
+
+      for (const m of missing) {
+        t.sub(`${red("✘")} ${m} — not found`)
+        hbWarnings.push(m)
+      }
+
+      writeFileSync(
+        resolve(appdir, ".env.hyperbeam"),
+        envLines.join("\n") + "\n"
+      )
+      t.sub(`.env.hyperbeam → CWD=${hbCwd}`)
+      t.done()
+
+      if (hbMode === "clone") {
+        t.step("Cloning HyperBEAM")
+        t.sub(`tag: ${HB_TAG}`)
+        await exec(
+          `cd "${appdir}" && git clone --depth 1 --branch ${HB_TAG} ${HB_REPO} HyperBEAM`,
+          { maxBuffer: 50 * 1024 * 1024, timeout: 600000 }
+        )
+        t.done()
+
+        if (deps.erl && deps.rebar3 && missing.length === 0) {
+          t.step("Compiling HyperBEAM (with genesis-wasm)")
+          try {
+            const envParts = []
+            if (deps.gcc) {
+              envParts.push(`CC=gcc-${deps.gcc}`, `CXX=g++-${deps.gcc}`)
+            }
+            if (deps.cmake) {
+              envParts.push(`CMAKE_POLICY_VERSION_MINIMUM=3.5`)
+            }
+            const envPrefix = envParts.join(" ")
+            await exec(
+              `cd "${appdir}/HyperBEAM" && ${envPrefix} rebar3 as genesis_wasm compile`,
+              { maxBuffer: 50 * 1024 * 1024, timeout: 600000 }
+            )
+            t.sub("genesis-wasm device compiled")
+            t.done()
+          } catch (e) {
+            t.fail("Compile failed — check .env.hyperbeam and run manually")
+          }
+        } else if (missing.length > 0) {
+          t.step("Skipping compilation (missing dependencies)")
+          t.sub(
+            "Run 'cd HyperBEAM && rebar3 compile' after installing dependencies"
+          )
+          t.done()
+        }
+      }
+
+      // Generate wallet in HyperBEAM directory
+      const hbWalletDir = resolve(appdir, hbCwd)
+      t.step("Generating HyperBEAM wallet")
+      const hbArweave = Arweave.init()
+      const hbJwk = await hbArweave.wallets.generate()
+      const hbAddr = await hbArweave.wallets.jwkToAddress(hbJwk)
+      writeFileSync(resolve(hbWalletDir, ".wallet.json"), JSON.stringify(hbJwk))
+      t.sub(`address: ${hbAddr}`)
+      t.done()
+    }
+
+    if (withFrontend) {
+      t.step("Setting up frontend")
+      t.sub("Vite + React + wao/web")
+      t.sub("vitest unit tests + Playwright E2E")
+      t.done()
+    }
+
+    t.summary(() => {
+      splash()
+      console.log(`  ${green("🎉")} ${bold(appname)} is ready!`)
+
+      if (hbWarnings.length > 0) {
+        console.log()
+        console.log(
+          `  ${yellow("⚠")}  ${bold("Missing HyperBEAM dependencies:")}`
+        )
+        for (const w of hbWarnings) console.log(`     ${dim("•")} ${w}`)
+        console.log(
+          `     ${dim("Install these before running HyperBEAM tests")}`
+        )
+      }
+
+      console.log()
+      console.log(`  ${bold("1. Build")}  ${dim("claude")}`)
+      console.log()
+      console.log(`    ${dim("$")} cd ${appname}`)
+      console.log(`    ${dim("$")} ${bold(`claude`)}`)
+      console.log(`    ${dim("Tell the agent what to build, or run")} ${cyan("/build")} ${dim("for the full workflow.")}`)
+      console.log()
+      console.log(`    ${dim("Quality gates (enforced automatically):")}`)
+      console.log(
+        `      ${dim("① Unit tests        in-memory AOS (mainnet WASM device)")}`
+      )
+      if (hbMode !== "skip")
+        console.log(
+          `      ${dim("② Integration test  HyperBEAM (requires Erlang)")}`
+        )
+      if (withFrontend)
+        console.log(
+          `      ${dim(`${hbMode !== "skip" ? "③" : "②"} Frontend tests    vitest + Playwright`)}`
+        )
+      console.log(
+        `    ${dim("Agent cannot complete tasks until all gates pass.")}`
+      )
+      console.log()
+      console.log(`  ${bold("2. Deploy to mainnet")}`)
+      console.log()
+      console.log(
+        `    ${dim("$")} yarn deploy src/counter.lua --wallet .wallet.json`
+      )
+      console.log()
+    })
+  } catch (e) {
+    t.fail(e.message)
+  }
+}
+
+const build = async () => {
+  if (!(await which("claude"))) {
+    console.error(
+      "Claude Code not found. Install: npm i -g @anthropic-ai/claude-code"
+    )
+    process.exit(1)
+  }
+  const { spawn } = await import("child_process")
+  const feature = args.join(" ")
+  const claudeArgs = ["--dangerously-skip-permissions"]
+  if (feature) {
+    claudeArgs.push(`/build ${feature}`)
+  } else if (existsSync("tasks.json") && existsSync("plan.md")) {
+    claudeArgs.push("resume /build")
+  } else {
+    claudeArgs.push("/build")
+  }
+  const child = spawn("claude", claudeArgs, {
+    stdio: "inherit",
+    env: { ...process.env, CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: "1" },
+  })
+  child.on("exit", code => process.exit(code ?? 0))
+}
+
+if (isBuild) build()
+else if (isCreate) create()
+else {
+  pm2.connect(false, async err => {
+    if (err) {
+      console.error("Error connecting to PM2:", err)
+      process.exit(2)
+    }
+
+    // Node 24+ enables wasm-memory64 by default and rejects the
+    // experimental flag at startup; older Node still needs it.
+    const _nodeMajor = parseInt((process.versions.node || "0").split(".")[0], 10)
+    const _wasm64Flag = _nodeMajor >= 24 ? "" : "--experimental-wasm-memory64"
+    pm2.start(
+      {
+        script: resolve(await dirname(), cmd.script),
+        nodeArgs: _wasm64Flag,
+        instances: 1,
+        force: true,
+        args: args,
+        daemon: false,
+        name: "wao",
+      },
+      err => {
+        if (err) {
+          console.error("Error starting process:", err)
+          pm2.disconnect()
+          process.exit(2)
+        }
+      }
+    )
+    pm2.streamLogs("all", 0, false)
+  })
+
+  process.on("SIGINT", () => {
+    pm2.delete("wao", err => {
+      pm2.disconnect()
+      process.exit(err ? 1 : 0)
+    })
+  })
+}

package/src/compress.js

@@ -0,0 +1,112 @@
+function toBase256(n) {
+  let result = []
+  while (n > 0) {
+    result.unshift(n % 256)
+    n = Math.floor(n / 256)
+  }
+  return [result.length, ...result]
+}
+
+const _comp = (arr, _arr, mode) => {
+  let _nums = null
+  let _elms = null
+  let len = _arr.length
+  let flag = 0
+  if (mode === 1 && _arr[0] !== 0) {
+    flag += 100
+    _elms = [_arr[0]]
+  } else if (mode === 2) {
+    flag += 200
+    _elms = _arr
+  }
+  if (len < 10) flag += len
+  else if (len !== 10) {
+    const [elm, ...nums] = toBase256(len)
+    _nums = nums
+    flag += elm * 10
+    if (_nums[0] < 10) flag += _nums.shift()
+  }
+  arr.push(flag)
+  if (_nums) for (const n of _nums) arr.push(n)
+  if (_elms) for (const n of _elms) arr.push(n)
+}
+
+export const compress = d => {
+  let _arr = []
+  let mode = 1
+  let prev = null
+  let max = 0
+  let arr = []
+  for (const v of d) {
+    if (prev === null) _arr.push(v)
+    else if (_arr.length === 1) {
+      mode = prev !== v ? 2 : 1
+      _arr.push(v)
+    } else {
+      if (prev !== v && mode === 1) {
+        _comp(arr, _arr, mode)
+        _arr = [v]
+        mode = 2
+      } else if (prev === v && mode === 2) {
+        const last = _arr.pop()
+        _comp(arr, _arr, mode)
+        _arr = [last, v]
+        mode = 1
+      } else {
+        _arr.push(v)
+      }
+    }
+    prev = v
+  }
+  if (_arr.length > 0) _comp(arr, _arr, mode)
+  return arr
+}
+
+export const decompress = d => {
+  let arr = []
+  let flag = null
+  let elm = 0
+  let sum = 0
+  let nums = []
+  let first = null
+  let second = null
+  let third = null
+  for (let v of d) {
+    if (flag === null) {
+      flag = v
+      first = Math.floor(flag / 100)
+      second = Math.floor((flag - first * 100) / 10)
+      third = flag - first * 100 - second * 10
+      nums = []
+      if (second === 0) {
+        nums.push(third === 0 ? 10 : third)
+        elm = 0
+      } else if (third !== 0) {
+        nums.push(third)
+        elm = second - 1
+      } else elm = second
+    } else if (sum === 0) {
+      elm -= 1
+      nums.push(v)
+    }
+    if (sum > 0) {
+      if (first === 2) arr.push(v)
+      else if (first === 1) for (let i = 0; i < to10(nums); i++) arr.push(v)
+      sum -= 1
+      if (sum === 0) flag = null
+    } else if (elm === 0) {
+      if (first === 0) {
+        for (let i = 0; i < to10(nums); i++) arr.push(0)
+        flag = null
+      } else if (first === 2) sum = to10(nums)
+      else sum = 1
+    }
+  }
+  return new Uint8Array(arr)
+}
+
+function to10(arr) {
+  let num = 0
+  for (let i = 0; i < arr.length; i++) num = num * 256 + arr[i]
+  return num
+}