Skip to content

armgit / muxin

Public Imported from GitHub
0

All your machines, one app. For you and your AI agents: agent sessions, desktops, files, logs and GitHub across your Macs, Linux and Windows machines, with an MCP server.

12.3 KB
Raw Blame
# Muxin machine probe (macOS / Linux). Read-only.
# Prints key=value lines; runner N is reported as rN.<key>=<value>.
# OR_DIRS (newline-separated glob patterns) is prepended by Muxin.

LC_ALL=C
export LC_ALL
PATH="$PATH:/usr/sbin:/sbin:/usr/bin:/bin:/usr/local/bin"

kv() { printf '%s=%s\n' "$1" "$2"; }

os=$(uname -s 2>/dev/null | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz')
now=$(date +%s)
kv probe 1
kv os "$os"
kv arch "$(uname -m 2>/dev/null)"
kv hostname "$(hostname 2>/dev/null)"

case "$os" in
darwin)
  kv os_version "macOS $(sw_vers -productVersion 2>/dev/null)"
  # A battery means a laptop.
  if pmset -g batt 2>/dev/null | grep -q InternalBattery; then kv form_factor laptop; else kv form_factor desktop; fi
  kv cores "$(sysctl -n hw.ncpu 2>/dev/null)"
  kv load "$(sysctl -n vm.loadavg 2>/dev/null | tr -d '{}')"
  boot=$(sysctl -n kern.boottime 2>/dev/null | sed -n 's/^{ sec = \([0-9]*\),.*/\1/p')
  [ -n "$boot" ] && kv uptime_s "$((now - boot))"
  memsize=$(sysctl -n hw.memsize 2>/dev/null)
  kv mem_total "$memsize"
  # "Memory used" as Activity Monitor shows it: app memory + wired + compressed.
  vm_stat 2>/dev/null | awk -v total="$memsize" '
    function n(s) { sub(/\.$/, "", s); return s + 0 }
    /page size of/                 { ps = $8 }
    /^Anonymous pages/             { anon = n($3) }
    /^Pages purgeable/             { purg = n($3) }
    /^Pages active/                { active = n($3) }
    /^Pages wired down/            { wired = n($4) }
    /^Pages occupied by compressor/ { comp = n($5) }
    END {
      if (!ps) exit
      used = (anon > 0) ? (anon - purg + wired + comp) * ps : (active + wired + comp) * ps
      if (total > 0 && used > total) used = total
      printf "mem_used=%.0f\n", used
    }'
  # Second sample of top is the CPU usage over the last second.
  top -l 2 -n 0 -s 1 2>/dev/null | awk '/CPU usage/ { idle = $7 } END { sub(/%/, "", idle); if (idle != "") printf "cpu_pct=%.1f\n", 100 - idle }'
  disk=/
  [ -d /System/Volumes/Data ] && disk=/System/Volumes/Data
  ;;
linux)
  if [ -r /etc/os-release ]; then
    kv os_version "$(. /etc/os-release 2>/dev/null; printf '%s' "${PRETTY_NAME:-Linux}")"
  else
    kv os_version "Linux $(uname -r 2>/dev/null)"
  fi
  # SMBIOS chassis type: 8-10, 14, 31, 32 are portables.
  case "$(cat /sys/class/dmi/id/chassis_type 2>/dev/null)" in
  8 | 9 | 10 | 14 | 31 | 32) kv form_factor laptop ;;
  "") ;;
  *) kv form_factor desktop ;;
  esac
  # An X server (Xorg, or Xwayland under a Wayland desktop): Show desktop needs one.
  if ls /tmp/.X11-unix/X* >/dev/null 2>&1; then kv desktop yes; else kv desktop no; fi
  kv cores "$(getconf _NPROCESSORS_ONLN 2>/dev/null || nproc 2>/dev/null)"
  kv load "$(cut -d' ' -f1-3 /proc/loadavg 2>/dev/null)"
  kv uptime_s "$(cut -d. -f1 /proc/uptime 2>/dev/null)"
  awk '/^MemTotal:/ { t = $2 } /^MemAvailable:/ { a = $2 }
       END { if (t) printf "mem_total=%.0f\nmem_used=%.0f\n", t * 1024, (t - a) * 1024 }' /proc/meminfo 2>/dev/null
  # A container sees its host's /proc: its own share comes from its cgroup.
  incontainer=
  if [ -f /.dockerenv ] || [ -f /run/.containerenv ] || systemd-detect-virt -cq 2>/dev/null; then incontainer=1; fi
  cg=/sys/fs/cgroup
  u1=
  [ -n "$incontainer" ] && u1=$(awk '/^usage_usec / { print $2 }' "$cg/cpu.stat" 2>/dev/null)
  s1=$(head -n1 /proc/stat 2>/dev/null)
  sleep 1
  s2=$(head -n1 /proc/stat 2>/dev/null)
  printf '%s\n%s\n' "$s1" "$s2" | awk '
    { t = 0; for (i = 2; i <= NF; i++) t += $i; idle = $5 + $6 }
    NR == 1 { t1 = t; i1 = idle }
    NR == 2 { dt = t - t1; if (dt > 0) printf "cpu_pct=%.1f\n", (1 - (idle - i1) / dt) * 100 }'
  if [ -n "$incontainer" ]; then
    # Its CPUs ("400000 100000": 4) and memory limits, when it has them
    # (these lines take the place of the host's), and its own uptime.
    c=$(getconf _NPROCESSORS_ONLN 2>/dev/null || nproc 2>/dev/null)
    if read -r quota period < "$cg/cpu.max" 2>/dev/null && [ "$quota" != max ] && [ "${period:-0}" -gt 0 ]; then
      c=$(( (quota + period - 1) / period ))
      kv cores "$c"
    fi
    u2=$(awk '/^usage_usec / { print $2 }' "$cg/cpu.stat" 2>/dev/null)
    if [ -n "$u1" ] && [ -n "$u2" ] && [ "${c:-0}" -gt 0 ]; then
      awk -v a="$u1" -v b="$u2" -v c="$c" 'BEGIN { p = (b - a) / 10000 / c; if (p > 100) p = 100; printf "cpu_pct=%.1f\n", p }'
    fi
    m=$(cat "$cg/memory.max" 2>/dev/null)
    if [ -n "$m" ] && [ "$m" != max ]; then
      cur=$(cat "$cg/memory.current" 2>/dev/null)
      cache=$(awk '/^inactive_file / { print $2 }' "$cg/memory.stat" 2>/dev/null)
      kv mem_total "$m"
      [ -n "$cur" ] && kv mem_used "$(( cur - ${cache:-0} ))"
    fi
    st=$(cut -d' ' -f22 /proc/1/stat 2>/dev/null)
    hz=$(getconf CLK_TCK 2>/dev/null)
    up=$(cut -d. -f1 /proc/uptime 2>/dev/null)
    [ -n "$st" ] && [ -n "$hz" ] && [ -n "$up" ] && kv uptime_s "$(( up - st / hz ))"
    # The host's load says nothing about this container.
    kv load ""
  fi
  disk=/
  ;;
*)
  kv os_version "$(uname -sr 2>/dev/null)"
  disk=/
  ;;
esac

df -kP "$disk" 2>/dev/null | awk 'NR == 2 { printf "disk_total=%.0f\ndisk_free=%.0f\ndisk_path=%s\n", $2 * 1024, $4 * 1024, $6 }'

# --- Runners -----------------------------------------------------------------
# A runner is a folder with a .runner config. Find them from running
# Runner.Listener / Runner.Worker processes and from the usual install places.

procs=$(ps -A -o pid= -o command= 2>/dev/null | grep -E '/bin/Runner\.(Listener|Worker)( |$)' | grep -v grep)

candidates() {
  printf '%s\n' "$procs" | awk '{
    for (i = 2; i <= NF; i++) if ($i ~ /^\/.*\/bin\/Runner\.(Listener|Worker)$/) { sub(/\/bin\/Runner\.[A-Za-z]*$/, "", $i); print $i; break }
  }'
  # Other users' homes: /Users on macOS. Never touch /home there: it's an
  # automount point, and looking inside asks for network-volume access.
  case "$(uname -s)" in
    Darwin) homes='/Users/*/actions-runner*' ;;
    *) homes='/home/*/actions-runner*' ;;
  esac
  old_ifs=$IFS
  IFS='
'
  for pattern in $OR_DIRS \
    "$HOME"/actions-runner/* "$HOME"/actions-runner* "$HOME"/runners/* "$HOME"/actions-runners/* "$HOME"/actions/* \
    /opt/actions-runner* /opt/runners/* /opt/actions-runners/* /srv/actions-runner* /srv/runners/* \
    /var/lib/actions-runner* $homes; do
    case "$pattern" in "~"|"~/"*) pattern="$HOME${pattern#\~}" ;; esac
    for d in $pattern; do
      [ -f "$d/.runner" ] && printf '%s\n' "${d%/}"
    done
  done
  IFS=$old_ifs
}

pid_of() { printf '%s\n' "$procs" | awk -v bin="$1" '{ for (i = 2; i <= NF; i++) if ($i == bin) { print $1; exit } }'; }

candidates | sort -u | {
  i=0
  while IFS= read -r d; do
    [ -n "$d" ] && [ -f "$d/.runner" ] || continue
    p="r$i"
    kv "$p.dir" "$d"
    kv "$p.config" "$(tr -d '\r\n' < "$d/.runner" 2>/dev/null)"
    kv "$p.listener" "$(pid_of "$d/bin/Runner.Listener")"
    kv "$p.worker" "$(pid_of "$d/bin/Runner.Worker")"
    if [ -x "$d/bin/Runner.Listener" ]; then
      # Some builds print log lines too; the version is the bare x.y.z line.
      kv "$p.version" "$("$d/bin/Runner.Listener" --version 2>/dev/null | grep -E '^v?[0-9]+\.[0-9]+\.[0-9]+' | tail -n1)"
    fi
    if [ -f "$d/.service" ]; then
      svc=$(head -n1 "$d/.service" 2>/dev/null)
      kv "$p.service" "$svc"
      state=unknown
      case "$os" in
        darwin)
          svc_name=$(basename "$svc" .plist)
          if launchctl list "$svc_name" >/dev/null 2>&1; then state=active; else state=inactive; fi ;;
        linux)
          if command -v systemctl >/dev/null 2>&1; then
            if systemctl is-active --quiet "$svc" 2>/dev/null; then state=active; else state=inactive; fi
          fi ;;
      esac
      kv "$p.service_state" "$state"
    fi
    i=$((i + 1))
  done
}

# --- sudo (Linux) --------------------------------------------------------------
# Whether a systemd service can be installed without a password prompt.
if [ "$os" = linux ]; then
  if [ "$(id -u)" = 0 ]; then
    kv sudo root
  elif command -v sudo >/dev/null 2>&1 && sudo -n true 2>/dev/null; then
    kv sudo passwordless
  else
    kv sudo password
  fi
fi

# --- What it runs in, when it's virtual -----------------------------------------
# "kvm", "qemu", "vmware", "docker", ...: a VM or a container on another machine.
case "$os" in
darwin)
  [ "$(sysctl -n kern.hv_vmm_present 2>/dev/null)" = 1 ] && kv virt apple ;;
linux)
  v=$(systemd-detect-virt 2>/dev/null)
  [ "$v" = none ] && v=
  if [ -z "$v" ]; then
    if [ -f /.dockerenv ]; then v=docker
    elif [ -f /run/.containerenv ]; then v=podman
    else
      case "$(cat /sys/class/dmi/id/sys_vendor /sys/class/dmi/id/product_name 2>/dev/null)" in
      *QEMU*) v=qemu ;;
      *VMware*) v=vmware ;;
      *VirtualBox* | *innotek*) v=oracle ;;
      *Parallels*) v=parallels ;;
      *Xen*) v=xen ;;
      *"Virtual Machine"*) v=microsoft ;;
      esac
    fi
  fi
  [ -n "$v" ] && kv virt "$v"
  # It can run VMs itself (Windows in Docker needs this).
  [ -e /dev/kvm ] && kv kvm yes ;;
esac

# --- Docker -------------------------------------------------------------------
# Runner containers: the ones Muxin made (label muxen.runner, or
# openrunner.runner from before the rename) and any other container running
# GitHub's actions-runner image.
if command -v docker >/dev/null 2>&1; then
  dv=$(docker version --format '{{.Server.Version}}' 2>/dev/null)
  if [ -n "$dv" ]; then
    kv docker "$dv"
    docker ps -a --no-trunc --format '{{.Names}}|{{.State}}|{{.Image}}|{{.Label "muxen.runner"}}{{.Label "openrunner.runner"}}|{{.Label "muxen.scope"}}{{.Label "openrunner.scope"}}' 2>/dev/null | {
      j=0
      while IFS='|' read -r cname cstate cimage rname rscope; do
        case "$cimage" in
          *actions-runner*) ;;
          *) [ -n "$rname" ] || continue ;;
        esac
        p="c$j"
        kv "$p.container" "$cname"
        kv "$p.state" "$cstate"
        kv "$p.image" "$cimage"
        kv "$p.name" "$rname"
        kv "$p.scope" "$rscope"
        kv "$p.restarts" "$(docker inspect -f '{{.RestartCount}}' "$cname" 2>/dev/null)"
        if [ "$cstate" = running ]; then
          top=$(docker top "$cname" -o pid,args 2>/dev/null)
          kv "$p.listener" "$(printf '%s\n' "$top" | awk '/Runner\.Listener/ { print $1; exit }')"
          kv "$p.worker" "$(printf '%s\n' "$top" | awk '/Runner\.Worker/ { print $1; exit }')"
          kv "$p.config" "$(docker exec "$cname" sh -c 'cat /home/runner/.runner 2>/dev/null' 2>/dev/null | tr -d '\r\n')"
          kv "$p.version" "$(docker exec "$cname" sh -c '/home/runner/bin/Runner.Listener --version 2>/dev/null' 2>/dev/null | grep -E '^[0-9]+\.[0-9]+\.[0-9]+$' | tail -n1)"
        fi
        j=$((j + 1))
      done
    }
    # Containers that publish ports here, running or not: a machine Muxin
    # reaches through one (a VM in Docker, say) runs in it.
    ids=$(docker ps -aq 2>/dev/null)
    if [ -n "$ids" ]; then
      # shellcheck disable=SC2086
      docker inspect --format '{{.Name}}|{{.State.Status}}|{{.Config.Image}}|{{range $p, $b := .HostConfig.PortBindings}}{{range $b}}{{.HostIp}}:{{.HostPort}}->{{$p}} {{end}}{{end}}' $ids 2>/dev/null | while IFS='|' read -r cname cstate cimage cports; do
        [ -n "$cports" ] && kv published "${cname#/}|$cstate|$cimage|$cports"
      done
    fi
  else
    kv docker_error "$(docker version 2>&1 | grep -i -m1 -E 'permission denied|cannot connect|error' | cut -c1-200)"
  fi
fi

# The network card it's reached by (to wake it later), and what wants a look.
case "$os" in
  linux)
    nic=$(ip route show default 2>/dev/null | awk '{ for (i = 1; i < NF; i++) if ($i == "dev") { print $(i + 1); exit } }')
    if [ -n "$nic" ]; then
      kv mac "$(cat "/sys/class/net/$nic/address" 2>/dev/null)"
      kv lan "$(ip -o -4 addr show dev "$nic" 2>/dev/null | awk '{ for (i = 1; i < NF; i++) { if ($i == "inet") a = $(i + 1); if ($i == "brd") b = $(i + 1) } } END { if (a != "") print a " " b }')"
    fi
    [ -f /var/run/reboot-required ] && kv reboot_required yes
    command -v systemctl >/dev/null 2>&1 && kv failed_units "$(systemctl --failed --no-legend --plain 2>/dev/null | awk '{ print $1 }' | head -n 5 | tr '\n' ' ')"
    ;;
  darwin)
    nic=$(route -n get default 2>/dev/null | awk '/interface:/ { print $2 }')
    if [ -n "$nic" ]; then
      kv mac "$(ifconfig "$nic" 2>/dev/null | awk '/ether / { print $2; exit }')"
      kv lan "$(ifconfig "$nic" 2>/dev/null | awk '/inet / { for (i = 1; i < NF; i++) { if ($i == "inet") a = $(i + 1); if ($i == "broadcast") b = $(i + 1) } print a " " b; exit }')"
    fi
    ;;
esac

kv elapsed_s "$(( $(date +%s) - now ))"