@rip-lang/stamp 0.1.1

package/directives/pool.rip

@@ -0,0 +1,53 @@
+export name        = "pool"
+export description = "Ensures a ZFS pool exists with specified properties"
+export positional  = ["name", "device"]
+export properties  =
+  ashift:      { description: "Pool ashift value (default: 12)" }
+  compression: { description: "Compression algorithm (default: zstd)" }
+  atime:       { description: "Access time tracking (default: off)" }
+  mountpoint:  { description: "Pool mountpoint (default: /<name>)" }
+
+export check = (name, props) ->
+  return 'missing' unless ok $"zpool list #{name}"
+  'ok'
+
+export apply = (name, props) ->
+  device = props.args?[0]
+  raise "pool '#{name}' requires a device argument" unless device
+
+  unless ok $"zpool list #{name}"
+    raise "Block device not found: #{device}" unless ok $"test -b #{device}"
+    raise "Device #{device} has existing data. Run 'wipefs -a #{device}' first." if ok $"blkid #{device}"
+
+    ashift = props.ashift?[0]?.args?[0] or '12'
+    sh $"zpool create -f -o ashift=#{ashift} #{name} #{device}"
+
+  compression = props.compression?[0]?.args?[0] or 'zstd'
+  sh $"zfs set compression=#{compression} #{name}"
+
+  atime = props.atime?[0]?.args?[0] or 'off'
+  sh $"zfs set atime=#{atime} #{name}"
+
+  if mp = props.mountpoint?[0]?.args?[0]
+    sh $"zfs set mountpoint=#{mp} #{name}"
+
+export verify = (name, props) ->
+  results = []
+  unless ok $"zpool list #{name}"
+    results.push { status: 'fail', message: "pool #{name} missing" }
+    return results
+  results.push { status: 'pass', message: "pool #{name} exists" }
+
+  if want = props.compression?[0]?.args?[0]
+    if want is (have = sh $"zfs get -H -o value compression #{name}")
+      results.push { status: 'pass', message: "#{name} compression is #{want}" }
+    else
+      results.push { status: 'warn', message: "#{name} compression is #{have}, expected #{want}" }
+
+  if want = props.atime?[0]?.args?[0]
+    if want is (have = sh $"zfs get -H -o value atime #{name}")
+      results.push { status: 'pass', message: "#{name} atime is #{want}" }
+    else
+      results.push { status: 'warn', message: "#{name} atime is #{have}, expected #{want}" }
+
+  results

package/directives/profile.rip

@@ -0,0 +1,29 @@
+export name        = "profile"
+export description = "Ensures an Incus profile exists with declared configuration"
+export positional  = ["name"]
+
+export check = (name, props) ->
+  return 'missing' unless ok $"incus profile show #{name}"
+  for own key, entries of props when key != 'args'
+    want = entries[0].args[0]
+    return 'drift' if want isnt ((run $"incus profile get #{name} #{key}").stdout or '')
+  'ok'
+
+export apply = (name, props) ->
+  sh $"incus profile create #{name}" unless ok $"incus profile show #{name}"
+  for own key, entries of props when key != 'args'
+    sh $"incus profile set #{name} #{key} #{entries[0].args[0]}"
+
+export verify = (name, props) ->
+  results = []
+  unless ok $"incus profile show #{name}"
+    results.push { status: 'fail', message: "profile #{name} missing" }
+    return results
+  results.push { status: 'pass', message: "profile #{name} exists" }
+  for own key, entries of props when key != 'args'
+    want = entries[0].args[0]
+    if want is (have = (run $"incus profile get #{name} #{key}").stdout or '')
+      results.push { status: 'pass', message: "#{name} #{key} is #{want}" }
+    else
+      results.push { status: 'fail', message: "#{name} #{key} is #{have}, expected #{want}" }
+  results

package/directives/service.rip

@@ -0,0 +1,52 @@
+export name        = "service"
+export description = "Ensures a systemd service is enabled and running"
+export positional  = ["name"]
+export properties  =
+  enabled: { description: "Whether the service should be enabled (default: true)" }
+  running: { description: "Whether the service should be running (default: true)" }
+
+export check = (name, props) ->
+  wantEnabled = props.enabled?[0]?.args?[0] != 'false'
+  wantRunning = props.running?[0]?.args?[0] != 'false'
+
+  isEnabled = ok $"systemctl is-enabled #{name}"
+  isRunning = ok $"systemctl is-active #{name}"
+
+  return 'drift' if wantEnabled isnt isEnabled
+  return 'drift' if wantRunning isnt isRunning
+
+  'ok'
+
+export apply = (name, props) ->
+  wantEnabled = props.enabled?[0]?.args?[0] != 'false'
+  wantRunning = props.running?[0]?.args?[0] != 'false'
+
+  if wantEnabled
+    sh $"systemctl enable #{name}" unless ok $"systemctl is-enabled #{name}"
+  else
+    sh $"systemctl disable #{name}" if ok $"systemctl is-enabled #{name}"
+
+  if wantRunning
+    sh $"systemctl start #{name}" unless ok $"systemctl is-active #{name}"
+  else
+    sh $"systemctl stop #{name}" if ok $"systemctl is-active #{name}"
+
+export verify = (name, props) ->
+  results = []
+  wantEnabled = props.enabled?[0]?.args?[0] != 'false'
+  wantRunning = props.running?[0]?.args?[0] != 'false'
+
+  isEnabled = ok $"systemctl is-enabled #{name}"
+  isRunning = ok $"systemctl is-active #{name}"
+
+  if wantEnabled
+    results.push { status: (if isEnabled then 'pass' else 'fail'), message: "#{name} #{if isEnabled then 'enabled' else 'not enabled'}" }
+  else
+    results.push { status: (if not isEnabled then 'pass' else 'fail'), message: "#{name} #{if isEnabled then 'should be disabled' else 'disabled'}" }
+
+  if wantRunning
+    results.push { status: (if isRunning then 'pass' else 'fail'), message: "#{name} #{if isRunning then 'running' else 'not running'}" }
+  else
+    results.push { status: (if not isRunning then 'pass' else 'fail'), message: "#{name} #{if isRunning then 'should be stopped' else 'stopped'}" }
+
+  results

package/directives/ssh.rip

@@ -0,0 +1,64 @@
+import * as fs from 'fs'
+
+export name        = "ssh"
+export description = "Ensures the SSH daemon is configured"
+export positional  = []
+export properties  =
+  'password-auth':     { description: "Enable password authentication (yes/no)" }
+  'permit-root-login': { description: "Root login policy (yes/no/prohibit-password)" }
+  'pubkey-auth':       { description: "Enable pubkey authentication (yes/no)" }
+
+CONF_PATH = '/etc/ssh/sshd_config.d/99-stamp.conf'
+
+OPTION_MAP =
+  'password-auth':     'PasswordAuthentication'
+  'permit-root-login': 'PermitRootLogin'
+  'pubkey-auth':       'PubkeyAuthentication'
+
+export check = (name, props) ->
+  out = run $"sshd -T"
+  return 'missing' unless out.ok
+
+  for own key, entries of props when key != 'args'
+    want = entries[0].args[0]
+    sshdKey = OPTION_MAP[key]?.toLowerCase()
+    continue unless sshdKey
+    match = out.stdout.match new RegExp "^#{sshdKey}\\s+(\\S+)", 'mi'
+    return 'drift' if match?[1] != want
+
+  'ok'
+
+export apply = (name, props) ->
+  lines = ["# Managed by stamp"]
+  for own key, entries of props when key != 'args'
+    sshdKey = OPTION_MAP[key]
+    continue unless sshdKey
+    lines.push "#{sshdKey} #{entries[0].args[0]}"
+
+  fs.writeFileSync CONF_PATH, lines.join('\n') + '\n'
+
+  if ok $"systemctl is-active ssh"
+    sh $"systemctl reload ssh"
+  else if ok $"systemctl is-active sshd"
+    sh $"systemctl reload sshd"
+
+export verify = (name, props) ->
+  results = []
+  out = run $"sshd -T"
+
+  unless out.ok
+    results.push { status: 'fail', message: "sshd not running or not installed" }
+    return results
+
+  for own key, entries of props when key != 'args'
+    want = entries[0].args[0]
+    sshdKey = OPTION_MAP[key]?.toLowerCase()
+    continue unless sshdKey
+    match = out.stdout.match new RegExp "^#{sshdKey}\\s+(\\S+)", 'mi'
+    actual = match?[1]
+    if actual == want
+      results.push { status: 'pass', message: "#{key} is #{want}" }
+    else
+      results.push { status: 'fail', message: "#{key} is #{actual or 'unset'}, expected #{want}" }
+
+  results

package/directives/user.rip

@@ -0,0 +1,61 @@
+export name        = "user"
+export description = "Ensures a system user exists on the host"
+export positional  = ["name", "uid:gid"]
+export properties  =
+  shell:  { description: "User shell (default: /bin/bash)" }
+  groups: { description: "Supplementary group memberships" }
+  home:   { description: "Home directory (default: /home/<name>)" }
+
+export check = (name, props) ->
+  return 'missing' unless ok $"id -u #{name}"
+
+  if props.args?[0]
+    [wantUid, wantGid] = props.args[0].split ':'
+    return 'drift' if wantUid isnt sh $"id -u #{name}"
+    return 'drift' if wantGid isnt sh $"id -g #{name}"
+
+  'ok'
+
+export apply = (name, props) ->
+  uidgid = props.args?[0]
+  shell  = props.shell?[0]?.args?[0] or '/bin/bash'
+  home   = props.home?[0]?.args?[0] or "/home/#{name}"
+
+  unless ok $"id -u #{name}"
+    if uidgid
+      [uid, gid] = uidgid.split ':'
+      sh $"groupadd -g #{gid} #{name}" unless ok $"getent group #{gid}"
+      sh $"useradd -m -u #{uid} -g #{gid} -s #{shell} -d #{home} #{name}"
+    else
+      sh $"useradd -m -s #{shell} -d #{home} #{name}"
+
+  if props.groups
+    groupList = props.groups[0].args.join ','
+    sh $"usermod -aG #{groupList} #{name}"
+
+export verify = (name, props) ->
+  results = []
+
+  unless ok $"id -u #{name}"
+    results.push { status: 'fail', message: "user #{name} missing" }
+    return results
+  results.push { status: 'pass', message: "user #{name} exists" }
+
+  if props.args?[0]
+    [wantUid, wantGid] = props.args[0].split ':'
+    if wantUid is (haveUid = sh $"id -u #{name}")
+      results.push { status: 'pass', message: "#{name} uid is #{wantUid}" }
+    else
+      results.push { status: 'fail', message: "#{name} uid is #{haveUid}, expected #{wantUid}" }
+    if wantGid is (haveGid = sh $"id -g #{name}")
+      results.push { status: 'pass', message: "#{name} gid is #{wantGid}" }
+    else
+      results.push { status: 'fail', message: "#{name} gid is #{haveGid}, expected #{wantGid}" }
+
+  if want = props.shell?[0]?.args?[0]
+    if want is (have = (sh $"getent passwd #{name}").split(':')[6])
+      results.push { status: 'pass', message: "#{name} shell is #{want}" }
+    else
+      results.push { status: 'warn', message: "#{name} shell is #{have}, expected #{want}" }
+
+  results

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@rip-lang/stamp",
+  "version": "0.1.1",
+  "description": "Declarative host provisioning — no state file, no agent, no YAML",
+  "type": "module",
+  "main": "src/cli.rip",
+  "bin": {
+    "stamp": "./bin/stamp"
+  },
+  "scripts": {
+    "test": "bun --preload ../../rip-loader.js test/runner.rip"
+  },
+  "keywords": [
+    "provisioning",
+    "declarative",
+    "infrastructure",
+    "idempotent",
+    "incus",
+    "zfs",
+    "containers",
+    "bun",
+    "rip",
+    "rip-lang"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shreeve/rip-lang.git",
+    "directory": "packages/stamp"
+  },
+  "homepage": "https://github.com/shreeve/rip-lang/tree/main/packages/stamp#readme",
+  "bugs": {
+    "url": "https://github.com/shreeve/rip-lang/issues"
+  },
+  "author": "Steve Shreeve <steve.shreeve@gmail.com>",
+  "license": "MIT",
+  "dependencies": {
+    "rip-lang": ">=3.13.102"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "directives/",
+    "README.md"
+  ]
+}

package/src/cli.rip

@@ -0,0 +1,125 @@
+import * as fs from 'fs'
+import * as path from 'path'
+import { parse } from './parser.rip'
+import { execute } from './engine.rip'
+
+VERSION = '0.1.0'
+
+# ── Default file resolution ──────────────────────────────────────────────────
+
+findStampfile = (dir = '.') ->
+  for name in ['Stampfile', 'Hostfile', 'Containerfile']
+    candidate = path.resolve dir, name
+    return candidate if fs.existsSync candidate
+  null
+
+# ── CLI ──────────────────────────────────────────────────────────────────────
+
+showHelp = ->
+  p """
+  stamp #{VERSION} — declarative host provisioning
+
+  Usage:
+    stamp apply [file]           Reconcile system to match Stampfile
+    stamp verify [file]          Check current state, report PASS/WARN/FAIL
+    stamp plan [file]            Dry-run: show what apply would do
+
+    stamp list                   Show all available directives
+    stamp info <directive>       Show a directive's syntax and properties
+
+    stamp version                Print stamp version
+    stamp help                   Show this help
+  """
+
+showVersion = ->
+  p "stamp #{VERSION}"
+
+# ── Subcommands ──────────────────────────────────────────────────────────────
+
+runMode = (mode, file) ->
+  stampfile = file or findStampfile!
+
+  unless stampfile
+    warn "No Stampfile found. Provide a file or create Stampfile, Hostfile, or Containerfile."
+    exit 2
+
+  unless fs.existsSync stampfile
+    warn "File not found: #{stampfile}"
+    exit 2
+
+  source   = fs.readFileSync stampfile, 'utf-8'
+  stampDir = path.dirname path.resolve stampfile
+  parsed   = parse source, process.env
+
+  try
+    result = execute! mode, parsed, stampDir
+
+    if mode == 'verify'
+      exit 1 if result.fail > 0
+    else if mode == 'plan'
+      exit 1 if result > 0
+  catch err
+    warn "\n  Error: #{err.message}"
+    exit 1
+
+listDirectives = ->
+  builtins = ['brew', 'packages', 'pool', 'dataset', 'profile', 'container', 'incus', 'multipass', 'user', 'group', 'firewall', 'ssh', 'service']
+  p "\nBuilt-in directives:\n"
+  for name in builtins
+    p "  #{name}"
+  p ""
+
+infoDirective = (name) ->
+  unless name
+    warn "Usage: stamp info <directive>"
+    exit 2
+
+  dirPath = path.join import.meta.dir, '..', 'directives', "#{name}.rip"
+  unless fs.existsSync dirPath
+    warn "Unknown directive: #{name}"
+    exit 2
+
+  try
+    mod = import! dirPath
+    p "\n#{mod.name or name}"
+    p "  #{mod.description}" if mod.description
+    if mod.positional
+      p "  Positional: #{mod.positional.join ', '}"
+    if mod.properties
+      p "  Properties:"
+      for own k, v of mod.properties
+        flags = []
+        flags.push 'multi' if v.multi
+        flags.push 'arrow' if v.arrow
+        desc = v.description or ''
+        flagStr = if flags.length then " (#{flags.join ', '})" else ''
+        p "    #{k}#{flagStr} — #{desc}"
+    p ""
+  catch err
+    warn "Failed to load directive '#{name}': #{err.message}"
+    exit 1
+
+# ── Main ─────────────────────────────────────────────────────────────────────
+
+do ->
+  args = process.argv[2..]
+  command = args[0]
+  rest = args[1..]
+
+  switch command
+    when 'apply'           then runMode 'apply', rest[0]
+    when 'verify'          then runMode 'verify', rest[0]
+    when 'plan'            then runMode 'plan', rest[0]
+    when 'list'            then listDirectives!
+    when 'info'            then infoDirective! rest[0]
+    when 'version', '-v'   then showVersion!
+    when 'help', '-h'      then showHelp!
+    when undefined         then showHelp!
+    else
+      # If the first arg is a file path, treat it as `stamp apply <file>`
+      if fs.existsSync command
+        runMode 'apply', command
+      else
+        warn "Unknown command: #{command}"
+        showHelp!
+        exit 2

package/src/engine.rip

@@ -0,0 +1,146 @@
+import * as fs from 'fs'
+import * as path from 'path'
+import { pathToFileURL } from 'url'
+import { sh, ok, run, log } from './helpers.rip'
+
+globalThis.sh  ??= sh
+globalThis.ok  ??= ok
+globalThis.run ??= run
+
+# ── Handler resolution ───────────────────────────────────────────────────────
+
+STAMP_HOME = process.env.STAMP_HOME or path.join(process.env.HOME or '', '.stamp')
+
+resolveHandler = (type, stampDir) ->
+  candidates = [
+    path.join(stampDir, '..', 'directives', "#{type}.rip")       # Built-in
+    path.join(stampDir, 'directives', "#{type}.rip")              # Local (beside Stampfile)
+    path.join(stampDir, 'directives', "#{type}.js")
+    path.join(STAMP_HOME, 'directives', "#{type}.rip")           # Installed
+    path.join(STAMP_HOME, 'directives', "#{type}.js")
+  ]
+
+  for candidate in candidates
+    if fs.existsSync candidate
+      return import! pathToFileURL(candidate).href
+
+  # Try npm resolution
+  for pkg in ["@stamp/#{type}", "stamp-#{type}"]
+    try
+      return import! pkg
+    catch
+      continue
+
+  null
+
+resolveHandlers = (directives, uses, stampDir) ->
+  handlers = {}
+
+  # Pre-resolve `use` declared handlers
+  for source in uses
+    if source.startsWith('http://') or source.startsWith('https://')
+      cacheDir = path.join STAMP_HOME, 'cache'
+      fs.mkdirSync cacheDir, { recursive: true } unless fs.existsSync cacheDir
+      cacheName = source.replace(/[^a-zA-Z0-9.-]/g, '_')
+      cachePath = path.join cacheDir, cacheName
+
+      unless fs.existsSync cachePath
+        log.info "Fetching #{source}..."
+        response = fetch! source
+        unless response.ok
+          throw new Error "Failed to fetch #{source}: #{response.status}"
+        text = response.text!
+        fs.writeFileSync cachePath, text
+      handlers[path.basename(source, path.extname(source))] = import! pathToFileURL(cachePath).href
+    else
+      mod = import! source
+      name = mod.name or path.basename(source, path.extname(source))
+      handlers[name] = mod
+
+  # Resolve handlers for each directive type
+  for dir in directives
+    unless handlers[dir.type]
+      handler = resolveHandler! dir.type, stampDir
+      unless handler
+        throw new Error "Unknown directive '#{dir.type}' (line #{dir.line or '?'})"
+      handlers[dir.type] = handler
+
+  handlers
+
+# ── Execution modes ──────────────────────────────────────────────────────────
+
+propsFor = (dir) ->
+  props = { args: dir.args ?? [], ...dir.properties }
+  props
+
+export apply = (directives, handlers) ->
+  applied = 0
+  total   = directives.length
+
+  for dir in directives
+    handler = handlers[dir.type]
+    props   = propsFor dir
+    result  = handler.check! dir.name, props
+
+    if result == 'ok'
+      log.ok dir.type, dir.name
+    else
+      log.apply dir.type, dir.name
+      handler.apply! dir.name, props
+
+      after = handler.check! dir.name, props
+      if after != 'ok'
+        log.fail dir.type, dir.name, "still not ok after apply"
+        throw new Error "Directive '#{dir.type}#{if dir.name then ' ' + dir.name else ''}' failed post-apply check"
+      applied++
+
+  p "\nApplied #{applied} of #{total} directives."
+  applied
+
+export verify = (directives, handlers) ->
+  counts = { pass: 0, warn: 0, fail: 0 }
+
+  for dir in directives
+    handler = handlers[dir.type]
+    props   = propsFor dir
+    results = handler.verify! dir.name, props
+
+    for result in results
+      switch result.status
+        when 'pass' then log.pass  "#{dir.type}: #{result.message}"; counts.pass++
+        when 'warn' then log.warn  "#{dir.type}: #{result.message}"; counts.warn++
+        when 'fail' then log.error "#{dir.type}: #{result.message}"; counts.fail++
+
+  p "\nPASS=#{counts.pass} WARN=#{counts.warn} FAIL=#{counts.fail}"
+  counts
+
+export plan = (directives, handlers) ->
+  changes = 0
+
+  for dir in directives
+    handler = handlers[dir.type]
+    props   = propsFor dir
+    result  = handler.check! dir.name, props
+
+    switch result
+      when 'ok'      then log.ok dir.type, dir.name
+      when 'drift'   then log.update dir.type, dir.name; changes++
+      when 'missing' then log.create dir.type, dir.name; changes++
+
+  if changes > 0
+    p "\n#{changes} change#{if changes > 1 then 's' else ''} would be applied."
+  else
+    p "\nNothing to do."
+  changes
+
+# ── Main entry point ─────────────────────────────────────────────────────────
+
+export execute = (mode, parsed, stampDir) ->
+  { directives, uses } = parsed
+  handlers = resolveHandlers! directives, uses, stampDir
+
+  switch mode
+    when 'apply'  then apply!  directives, handlers
+    when 'verify' then verify! directives, handlers
+    when 'plan'   then plan!   directives, handlers
+    else throw new Error "Unknown mode: #{mode}"

package/src/helpers.rip

@@ -0,0 +1,83 @@
+# ── Shell execution helpers ──────────────────────────────────────────────────
+#
+# Each function works in two modes:
+#
+#   String mode:    sh "echo hello"           → passes to sh -c (shell)
+#   Template mode:  sh $"echo #{name}"        → builds argv array (no shell)
+#
+#   run(cmd) → { ok, stdout, stderr, code }
+#   sh(cmd)  → stdout string; throws on non-zero exit
+#   ok(cmd)  → boolean; true if exit code is 0
+
+buildArgv = (strings, values) ->
+  argv = []
+  for s, i in strings
+    if s.length
+      if argv.length and not /^\s/.test s
+        parts = s.split /(\s+)/
+        argv[argv.length - 1] += parts[0]
+        for part in parts[1..]
+          argv.push part unless part == '' or /^\s+$/.test part
+      else
+        for word in s.split /\s+/
+          argv.push word unless word == ''
+    if i < values.length and values[i]?
+      val = String values[i]
+      if val.length
+        if s.length and not /\s$/.test s
+          argv[argv.length - 1] += val if argv.length
+          argv.push val unless argv.length
+        else
+          argv.push val
+  argv
+
+toArgv = (args) ->
+  first = args[0]
+  if kind(first) == 'array'
+    if first.raw then buildArgv(first, args[1..]) else first
+  else
+    ['sh', '-c', first]
+
+export run = (...args) ->
+  try
+    out = Bun.spawnSync toArgv(args), { stdout: 'pipe', stderr: 'pipe' }
+    {
+      ok:     out.exitCode == 0
+      stdout: out.stdout.toString().trim()
+      stderr: out.stderr.toString().trim()
+      code:   out.exitCode
+    }
+  catch e
+    { ok: false, stdout: '', stderr: e.message, code: 1 }
+
+export sh = (...args) ->
+  out = run ...args
+  unless out.ok
+    cmd = toArgv(args).join ' '
+    raise "Command failed (exit #{out.code}): #{cmd}\n#{out.stderr}"
+  out.stdout
+
+export ok = (...args) ->
+  (run ...args).ok
+
+# ── Logging ──────────────────────────────────────────────────────────────────
+
+RESET  = "\x1b[0m"
+BOLD   = "\x1b[1m"
+DIM    = "\x1b[2m"
+GREEN  = "\x1b[32m"
+YELLOW = "\x1b[33m"
+RED    = "\x1b[31m"
+CYAN   = "\x1b[36m"
+
+export log =
+  ok:     (type, name) -> p "  #{GREEN}ok#{RESET}     #{type}#{if name then ' ' + name else ''}"
+  apply:  (type, name) -> p "  #{CYAN}apply#{RESET}  #{type}#{if name then ' ' + name else ''}"
+  create: (type, name) -> p "  #{CYAN}create#{RESET} #{type}#{if name then ' ' + name else ''}"
+  update: (type, name) -> p "  #{YELLOW}update#{RESET} #{type}#{if name then ' ' + name else ''}"
+  fail:   (type, name, msg) -> p "  #{RED}FAIL#{RESET}   #{type}#{if name then ' ' + name else ''}#{if msg then ' — ' + msg else ''}"
+  pass:   (msg) -> p "  #{GREEN}PASS#{RESET}  #{msg}"
+  warn:   (msg) -> p "  #{YELLOW}WARN#{RESET}  #{msg}"
+  error:  (msg) -> p "  #{RED}FAIL#{RESET}  #{msg}"
+  info:   (msg) -> p "  #{DIM}#{msg}#{RESET}"
+  header: (msg) -> p "\n#{BOLD}#{msg}#{RESET}"