opencode-localhost 0.1.0

package/src/server/llamacpp/models-ini.ts

@@ -0,0 +1,160 @@
+import fs from "fs/promises"
+import path from "path"
+import * as Ini from "../../shared/ini.ts"
+import { configDir } from "../../shared/paths.ts"
+import type { LocalModel } from "./discover.ts"
+
+/**
+ * models.ini — llama.cpp's file, not ours. Handed to
+ * `llama-server --models-preset` verbatim; llama.cpp parses it, we only append.
+ *
+ * The contract with the user: we add a section when a new .gguf appears and
+ * never modify or remove one afterwards. Everything in here is a llama-server
+ * flag, so any flag llama.cpp accepts works whether or not we know about it.
+ */
+
+export const FILE = path.join(configDir("llamacpp"), "models.ini")
+
+const HEADER = `version = 1
+
+# Per-model llama-server settings. YOURS TO EDIT.
+# New models get a section appended; existing sections are never touched.
+# Any llama-server flag works as a key, without the leading dashes:
+#
+#   ctx-size = 32768          context window, in tokens
+#   gpu-layers = 99           layers on GPU (99 = all)
+#   tensor-split = 0.6,0.4    split across multiple GPUs
+#   cache-type-k = q8_0       KV cache quantisation: f16 | q8_0 | q4_0
+#   flash-attn = on
+#   temp = 0.7                sampling; sent per-request, no reload needed
+#
+# Launch flags apply on the next model load. Sampling applies immediately.`
+
+/**
+ * Conservative on purpose: these must not OOM on a machine we know nothing
+ * about. 32k context with a quantised KV cache fits alongside most models on
+ * a single mid-range card. Tune upward per model; that is what the file is for.
+ */
+const DEFAULTS: Record<string, string> = {
+  "ctx-size": "32768",
+  "gpu-layers": "99",
+  "flash-attn": "on",
+  "cache-type-k": "q8_0",
+  "cache-type-v": "q8_0",
+  jinja: "true",
+}
+
+export type ModelSettings = {
+  context: number
+  sampling: Record<string, number>
+}
+
+const SAMPLING_KEYS = ["temp", "top-p", "top-k", "min-p", "repeat-penalty", "presence-penalty"] as const
+
+/** llama.cpp flag names -> OpenAI request body fields. */
+const SAMPLING_WIRE: Record<string, string> = {
+  temp: "temperature",
+  "top-p": "top_p",
+  "top-k": "top_k",
+  "min-p": "min_p",
+  "repeat-penalty": "repetition_penalty",
+  "presence-penalty": "presence_penalty",
+}
+
+function section(model: LocalModel): string {
+  const lines = [`[${model.id}]`, `model = ${model.file}`]
+  if (model.mmproj) lines.push(`mmproj = ${model.mmproj}`)
+  for (const [key, value] of Object.entries(DEFAULTS)) lines.push(`${key} = ${value}`)
+  return lines.join("\n")
+}
+
+export type SyncResult = {
+  preset: string
+  /** Discovered file -> the section name that actually governs it. */
+  names: Map<string, string>
+}
+
+/**
+ * Append sections for models that do not have one yet.
+ *
+ * The section name IS the model id, so a section the user renamed keeps
+ * winning: we match on the `model =` path first and only fall back to the
+ * proposed name for genuinely new files. Getting this backwards would append a
+ * duplicate default section beside a hand-tuned one and then read `ctx-size`
+ * from the wrong one — silently compacting far below the real window.
+ */
+export async function sync(models: LocalModel[]): Promise<SyncResult> {
+  const existing = await fs.readFile(FILE, "utf8").catch(() => "")
+  const doc = Ini.parse(existing)
+  const names = new Set(doc.sections.map((item) => item.name))
+
+  const byFile = new Map<string, string>()
+  for (const item of doc.sections) {
+    const file = Ini.get(item, "model")?.trim()
+    if (file) byFile.set(file, item.name)
+  }
+
+  const added: string[] = []
+  const resolved = new Map<string, string>()
+  for (const model of models) {
+    const owner = byFile.get(model.file)
+    if (owner) {
+      resolved.set(model.file, owner)
+      continue
+    }
+    // a section named for this model but pointing elsewhere still owns the name
+    let id = model.id
+    for (let n = 2; names.has(id); n++) id = `${model.id}#${n}`
+    names.add(id)
+    resolved.set(model.file, id)
+    added.push(section({ ...model, id }))
+  }
+
+  const body = existing.trim().length > 0 ? existing.replace(/\s+$/, "") : HEADER
+  const next = added.length > 0 ? [body, "", added.join("\n\n"), ""].join("\n") : body + "\n"
+
+  await fs.mkdir(path.dirname(FILE), { recursive: true }).catch(() => {})
+  await fs.writeFile(FILE, next).catch(() => {})
+  return { preset: FILE, names: resolved }
+}
+
+/**
+ * Per-model context and sampling, read back out of the file.
+ *
+ * Context matters beyond display: opencode compacts a conversation against the
+ * model's advertised window, so if we reported a default while the model
+ * actually loaded with 245k, it would compact at a fraction of the real limit.
+ */
+export async function settings(): Promise<Record<string, ModelSettings>> {
+  const text = await fs.readFile(FILE, "utf8").catch(() => "")
+  const out: Record<string, ModelSettings> = {}
+  for (const item of Ini.parse(text).sections) {
+    const raw = Ini.entries(item)
+    const context = Number.parseInt(raw["ctx-size"] ?? "", 10)
+    const sampling: Record<string, number> = {}
+    for (const key of SAMPLING_KEYS) {
+      const value = Number.parseFloat(raw[key] ?? "")
+      if (Number.isFinite(value)) sampling[SAMPLING_WIRE[key]] = value
+    }
+    out[item.name] = {
+      context: Number.isFinite(context) && context > 0 ? context : 0,
+      sampling,
+    }
+  }
+  return out
+}
+
+/** Reset one section to the shipped defaults, keeping model/mmproj paths. */
+export async function restoreDefaults(id: string): Promise<boolean> {
+  const text = await fs.readFile(FILE, "utf8").catch(() => "")
+  const doc = Ini.parse(text)
+  const target = Ini.find(doc, id)
+  if (!target) return false
+  const raw = Ini.entries(target)
+  const lines = [`model = ${raw["model"] ?? ""}`]
+  if (raw["mmproj"]) lines.push(`mmproj = ${raw["mmproj"]}`)
+  for (const [key, value] of Object.entries(DEFAULTS)) lines.push(`${key} = ${value}`)
+  target.lines = lines
+  await fs.writeFile(FILE, Ini.serialize(doc)).catch(() => {})
+  return true
+}

package/src/server/llamacpp/server-ini.ts

@@ -0,0 +1,110 @@
+import fs from "fs/promises"
+import path from "path"
+import * as Ini from "../../shared/ini.ts"
+import { configDir, expandHome, collapseHome } from "../../shared/paths.ts"
+
+/**
+ * server.ini — ours, not llama.cpp's. We read it and build llama-server's
+ * command line from it. llama-server never sees this file.
+ *
+ * Two values have no safe default and are left empty until set:
+ *   bin        — filled from $PATH if llama-server is there, else empty
+ *   models-dir — always empty on a fresh install; only the user knows this
+ *
+ * Empty is not a failure mode to hide. The panel reads it and asks.
+ */
+
+export const BACKEND = "llamacpp"
+export const FILE = path.join(configDir(BACKEND), "server.ini")
+
+const TEMPLATE = `# llama-server settings for opencode-localhost.
+# Changing anything here restarts the server.
+#
+#   bin         path to llama-server. empty = look on $PATH
+#   models-dir  where your .gguf files live. REQUIRED, no default
+#   host        127.0.0.1 keeps it on this machine.
+#               0.0.0.0 exposes it to your network — set api-key if you do
+#   port        llama-server listen port
+#   models-max  how many models may sit in VRAM at once. 1 swaps instead of stacking
+#   api-key     required by the server when set. leave empty for localhost-only
+
+[server]
+bin =
+models-dir =
+host = 127.0.0.1
+port = 9337
+models-max = 1
+api-key =
+`
+
+export type ServerSettings = {
+  bin: string
+  modelsDir: string
+  host: string
+  port: number
+  modelsMax: number
+  apiKey: string
+}
+
+const DEFAULTS: ServerSettings = {
+  bin: "",
+  modelsDir: "",
+  host: "127.0.0.1",
+  port: 9337,
+  modelsMax: 1,
+  apiKey: "",
+}
+
+function number(value: string | undefined, fallback: number) {
+  const parsed = Number.parseInt((value ?? "").trim(), 10)
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback
+}
+
+/** Creates the file on first call so there is always something to point at. */
+export async function load(): Promise<ServerSettings> {
+  let text = await fs.readFile(FILE, "utf8").catch(() => undefined)
+  if (text === undefined) {
+    await fs.mkdir(path.dirname(FILE), { recursive: true }).catch(() => {})
+    await fs.writeFile(FILE, TEMPLATE).catch(() => {})
+    text = TEMPLATE
+  }
+  const section = Ini.find(Ini.parse(text), "server")
+  if (!section) return { ...DEFAULTS }
+  const raw = Ini.entries(section)
+  return {
+    bin: expandHome((raw["bin"] ?? "").trim()),
+    modelsDir: expandHome((raw["models-dir"] ?? "").trim()),
+    host: (raw["host"] || DEFAULTS.host).trim(),
+    port: number(raw["port"], DEFAULTS.port),
+    modelsMax: number(raw["models-max"], DEFAULTS.modelsMax),
+    apiKey: (raw["api-key"] ?? "").trim(),
+  }
+}
+
+/** Writes one key back, preserving comments and everything else in the file. */
+export async function update(key: "bin" | "models-dir", value: string): Promise<void> {
+  const text = await fs.readFile(FILE, "utf8").catch(() => TEMPLATE)
+  const doc = Ini.parse(text)
+  const section = Ini.find(doc, "server")
+  if (!section) return
+  Ini.set(section, key, collapseHome(value))
+  await fs.mkdir(path.dirname(FILE), { recursive: true }).catch(() => {})
+  await fs.writeFile(FILE, Ini.serialize(doc)).catch(() => {})
+}
+
+/** llama-server's command line, built from the settings plus the preset file. */
+export function argv(settings: ServerSettings, preset: string): string[] {
+  return [
+    "--models-dir",
+    settings.modelsDir,
+    "--models-preset",
+    preset,
+    "--models-max",
+    String(settings.modelsMax),
+    "--host",
+    settings.host,
+    "--port",
+    String(settings.port),
+    ...(settings.apiKey ? ["--api-key", settings.apiKey] : []),
+  ]
+}

package/src/shared/backends.ts

@@ -0,0 +1,97 @@
+import fs from "fs/promises"
+import path from "path"
+import os from "os"
+
+/**
+ * The backends this plugin knows about.
+ *
+ * Only llama.cpp is implemented. The others are listed anyway so the setup
+ * screen can tell you what it found and what installing them would take —
+ * a greyed row with a real install command is more use than pretending the
+ * option does not exist.
+ *
+ * Note these are not the same kind of thing: llama.cpp ships a native binary
+ * with prebuilt releases, while vLLM, MLX and OpenVINO are Python packages.
+ * That is why this plugin never installs anything for you — "install" means
+ * something different for each, and picking the wrong llama.cpp build (CUDA
+ * version, GPU arch) silently costs a large multiple of performance.
+ */
+
+export type BackendSpec = {
+  id: string
+  name: string
+  /** Executable to look for on $PATH. */
+  binary: string
+  /** What a user would actually run to get it. */
+  install: string
+  /** Restricts availability; MLX is Apple Silicon only. */
+  requires?: { platform: NodeJS.Platform; arch: string }
+  implemented: boolean
+}
+
+export const BACKENDS: BackendSpec[] = [
+  {
+    id: "llamacpp",
+    name: "llama.cpp",
+    binary: "llama-server",
+    install: "build from source, or: brew install llama.cpp",
+    implemented: true,
+  },
+  {
+    id: "vllm",
+    name: "vLLM",
+    binary: "vllm",
+    install: "pip install vllm",
+    implemented: false,
+  },
+  {
+    id: "mlx",
+    name: "MLX",
+    binary: "mlx_lm.server",
+    install: "pip install mlx-lm",
+    requires: { platform: "darwin", arch: "arm64" },
+    implemented: false,
+  },
+  {
+    id: "openvino",
+    name: "OpenVINO",
+    binary: "ovms",
+    install: "pip install openvino-genai",
+    implemented: false,
+  },
+]
+
+export function supported(spec: BackendSpec): boolean {
+  if (!spec.requires) return true
+  return process.platform === spec.requires.platform && process.arch === spec.requires.arch
+}
+
+/** First match on $PATH, or undefined. We never guess at build directories. */
+export async function onPath(binary: string): Promise<string | undefined> {
+  const dirs = (process.env["PATH"] || "").split(path.delimiter).filter(Boolean)
+  for (const dir of dirs) {
+    const candidate = path.join(dir, binary)
+    const stat = await fs.stat(candidate).catch(() => undefined)
+    if (stat?.isFile()) return candidate
+  }
+  return undefined
+}
+
+/** Every match on $PATH — several llama.cpp builds commonly coexist. */
+export async function allOnPath(binary: string): Promise<string[]> {
+  const dirs = (process.env["PATH"] || "").split(path.delimiter).filter(Boolean)
+  const found: string[] = []
+  for (const dir of dirs) {
+    const candidate = path.join(dir, binary)
+    const stat = await fs.stat(candidate).catch(() => undefined)
+    if (stat?.isFile() && !found.includes(candidate)) found.push(candidate)
+  }
+  return found
+}
+
+export function expand(value: string): string {
+  const trimmed = value.trim()
+  if (trimmed === "~") return os.homedir()
+  if (trimmed.startsWith("~/")) return path.join(os.homedir(), trimmed.slice(2))
+  return trimmed
+}

package/src/shared/ini.ts

@@ -0,0 +1,97 @@
+/**
+ * INI reader/writer that preserves everything it does not understand.
+ *
+ * These files are hand-edited — comments explaining why a model needs
+ * `ubatch-size = 2048` are the most valuable thing in them. A parse/serialize
+ * round trip that drops comments, ordering, or blank lines would quietly
+ * destroy that, so sections keep their raw lines and are only rewritten when a
+ * key in them actually changes.
+ */
+
+export type Section = {
+  name: string
+  /** Raw lines between this header and the next, verbatim. */
+  lines: string[]
+}
+
+export type Document = {
+  /** Lines before the first section header. */
+  preamble: string[]
+  sections: Section[]
+}
+
+const HEADER = /^\s*\[([^\]]+)\]\s*$/
+/** Keys may repeat (llama.cpp allows it); we address the first occurrence. */
+const entry = (key: string) => new RegExp(`^(\\s*)${escape(key)}(\\s*=\\s*)(.*?)(\\s*)$`)
+
+function escape(value: string) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+}
+
+export function parse(text: string): Document {
+  const doc: Document = { preamble: [], sections: [] }
+  let current: Section | undefined
+  for (const line of text.split("\n")) {
+    const header = line.match(HEADER)
+    if (header) {
+      current = { name: header[1], lines: [] }
+      doc.sections.push(current)
+      continue
+    }
+    if (current) current.lines.push(line)
+    else doc.preamble.push(line)
+  }
+  return doc
+}
+
+export function serialize(doc: Document): string {
+  const out: string[] = [...doc.preamble]
+  for (const section of doc.sections) {
+    out.push(`[${section.name}]`)
+    out.push(...section.lines)
+  }
+  return out.join("\n").replace(/\n*$/, "\n")
+}
+
+export function get(section: Section, key: string): string | undefined {
+  for (const line of section.lines) {
+    const match = line.match(entry(key))
+    if (match) return match[3]
+  }
+  return undefined
+}
+
+/**
+ * Set a key in place, keeping its original spacing. Undefined removes it.
+ * Appends after the last existing entry rather than at the very end, so a
+ * trailing comment block stays at the bottom where the user put it.
+ */
+export function set(section: Section, key: string, value: string | undefined): void {
+  const pattern = entry(key)
+  for (let i = 0; i < section.lines.length; i++) {
+    const match = section.lines[i].match(pattern)
+    if (!match) continue
+    if (value === undefined) section.lines.splice(i, 1)
+    else section.lines[i] = `${match[1]}${key}${match[2]}${value}`
+    return
+  }
+  if (value === undefined) return
+  let insert = section.lines.length
+  while (insert > 0 && !section.lines[insert - 1].includes("=")) insert--
+  section.lines.splice(insert, 0, `${key} = ${value}`)
+}
+
+export function find(doc: Document, name: string): Section | undefined {
+  return doc.sections.find((section) => section.name === name)
+}
+
+/** Every `key = value` in a section, first occurrence wins. Comments skipped. */
+export function entries(section: Section): Record<string, string> {
+  const out: Record<string, string> = {}
+  for (const line of section.lines) {
+    if (/^\s*[#;]/.test(line)) continue
+    const match = line.match(/^\s*([^=\s]+)\s*=\s*(.*?)\s*$/)
+    if (match && !(match[1] in out)) out[match[1]] = match[2]
+  }
+  return out
+}

package/src/shared/paths.ts

@@ -0,0 +1,37 @@
+import os from "os"
+import path from "path"
+
+/**
+ * Where a backend's files live. Config is what you edit; state is what we own.
+ *
+ * Config follows XDG so it sits next to opencode's own config, which is where
+ * people look for it. State holds pidfiles and logs — things you never edit and
+ * that should not survive in a dotfiles repo.
+ */
+
+const xdg = (envVar: string, fallback: string) => process.env[envVar] || path.join(os.homedir(), fallback)
+
+export const CONFIG_ROOT = path.join(xdg("XDG_CONFIG_HOME", ".config"), "opencode", "providers")
+export const STATE_ROOT = path.join(xdg("XDG_STATE_HOME", ".local/state"), "opencode", "providers")
+
+export function configDir(backend: string) {
+  return path.join(CONFIG_ROOT, backend)
+}
+
+export function stateDir(backend: string) {
+  return path.join(STATE_ROOT, backend)
+}
+
+/** `~/models` and `$HOME/models` both appear in hand-edited config files. */
+export function expandHome(value: string): string {
+  if (value === "~") return os.homedir()
+  if (value.startsWith("~/")) return path.join(os.homedir(), value.slice(2))
+  if (value.startsWith("$HOME/")) return path.join(os.homedir(), value.slice(6))
+  return value
+}
+
+/** Written back to config so paths stay readable rather than machine-specific. */
+export function collapseHome(value: string): string {
+  const home = os.homedir()
+  return value.startsWith(home + path.sep) ? "~" + value.slice(home.length) : value
+}

package/src/shared/types.ts

@@ -0,0 +1,51 @@
+/** Shapes the panel renders. Deliberately backend-agnostic. */
+
+export type GpuStat = {
+  index: number
+  usedMiB: number
+  totalMiB: number
+  /** Percent 0-100. Undefined when the driver does not report it. */
+  utilization?: number
+}
+
+export type SystemStat = {
+  usedMiB: number
+  totalMiB: number
+  utilization?: number
+}
+
+export type LoadedModel = {
+  id: string
+  /** Launch flags the server reports, e.g. ctx-size, cache-type-k, gpu-layers. */
+  args: Record<string, string>
+  loading?: boolean
+  /** 0-1 while weights stream in. */
+  progress?: number
+}
+
+/**
+ * "unconfigured" is a first-class state, not an error: a fresh install has no
+ * models directory and the panel is where the user is told so.
+ */
+export type ProviderStatus =
+  | { state: "unconfigured"; missing: "binary" | "models-dir"; message: string; hint?: string }
+  | { state: "stopped" }
+  | { state: "starting" }
+  | { state: "running"; endpoint: string; loaded?: LoadedModel }
+  | { state: "failed"; message: string; hint?: string }
+
+export type PanelData = {
+  backend: { id: string; name: string }
+  status: ProviderStatus
+  /**
+   * Whether opencode has actually picked up the provider. False while the
+   * server is up but opencode has not re-read its config — the one case where
+   * a restart is genuinely required, so the panel has to say so.
+   */
+  registered?: boolean
+  gpus: GpuStat[]
+  memory?: SystemStat
+  cpu?: SystemStat
+  /** Tokens per second, while generating. */
+  throughput?: number
+}

package/src/tui/hardware/nvidia.ts

@@ -0,0 +1,52 @@
+import { execFile } from "child_process"
+import type { GpuStat } from "../../shared/types.ts"
+
+/**
+ * GPU stats via nvidia-smi. There is no push interface, so this is polled —
+ * but only while the panel is visible.
+ *
+ * Absent nvidia-smi is a normal state, not an error: plenty of machines run
+ * llama.cpp on CPU, Metal, or ROCm. We return nothing and the panel omits the
+ * GPU rows rather than showing a failure.
+ */
+
+const QUERY = "index,memory.used,memory.total,utilization.gpu"
+const TIMEOUT = 2_000
+
+let available = true
+
+function run(): Promise<string | undefined> {
+  return new Promise((resolve) => {
+    execFile(
+      "nvidia-smi",
+      [`--query-gpu=${QUERY}`, "--format=csv,noheader,nounits"],
+      { timeout: TIMEOUT },
+      (error, stdout) => {
+        if (error) {
+          // ENOENT means no NVIDIA tooling at all; stop trying every tick
+          if ((error as NodeJS.ErrnoException).code === "ENOENT") available = false
+          return resolve(undefined)
+        }
+        resolve(stdout)
+      },
+    )
+  })
+}
+
+export async function gpus(): Promise<GpuStat[]> {
+  if (!available) return []
+  const output = await run()
+  if (!output) return []
+  const stats: GpuStat[] = []
+  for (const line of output.trim().split("\n")) {
+    const parts = line.split(",").map((value) => Number.parseInt(value.trim(), 10))
+    if (parts.length < 3 || parts.some((value, index) => index < 3 && !Number.isFinite(value))) continue
+    stats.push({
+      index: parts[0],
+      usedMiB: parts[1],
+      totalMiB: parts[2],
+      utilization: Number.isFinite(parts[3]) ? parts[3] : undefined,
+    })
+  }
+  return stats
+}

package/src/tui/hardware/system.ts

@@ -0,0 +1,68 @@
+import fs from "fs/promises"
+import os from "os"
+import type { SystemStat } from "../../shared/types.ts"
+
+/**
+ * System RAM and CPU.
+ *
+ * RAM uses MemAvailable rather than os.freemem(): free memory excludes page
+ * cache, so on a box that has just mmap'd a 20GB model it reads as almost
+ * nothing and looks alarming. MemAvailable is what "how much can I still use"
+ * actually means.
+ */
+
+const MIB = 1024 * 1024
+
+type CpuSample = { idle: number; total: number }
+
+let previous: CpuSample | undefined
+
+async function meminfo(): Promise<SystemStat | undefined> {
+  const text = await fs.readFile("/proc/meminfo", "utf8").catch(() => undefined)
+  if (!text) {
+    // non-Linux: free memory is the best available approximation
+    const total = os.totalmem() / MIB
+    const used = (os.totalmem() - os.freemem()) / MIB
+    return { usedMiB: Math.round(used), totalMiB: Math.round(total) }
+  }
+  const read = (key: string) => {
+    const match = text.match(new RegExp(`^${key}:\\s+(\\d+) kB`, "m"))
+    return match ? Number.parseInt(match[1], 10) / 1024 : undefined
+  }
+  const total = read("MemTotal")
+  const availableKiB = read("MemAvailable")
+  if (total === undefined || availableKiB === undefined) return undefined
+  return { usedMiB: Math.round(total - availableKiB), totalMiB: Math.round(total) }
+}
+
+/** Utilisation between the previous call and now; undefined on the first. */
+async function cpuUtilisation(): Promise<number | undefined> {
+  const text = await fs.readFile("/proc/stat", "utf8").catch(() => undefined)
+  let sample: CpuSample | undefined
+  if (text) {
+    const line = text.split("\n")[0]
+    const values = line.split(/\s+/).slice(1).map(Number).filter(Number.isFinite)
+    if (values.length >= 5) {
+      const total = values.reduce((sum, value) => sum + value, 0)
+      sample = { idle: values[3] + (values[4] ?? 0), total }
+    }
+  }
+  if (!sample) {
+    const load = os.loadavg()[0]
+    const cores = os.cpus().length || 1
+    return Math.min(100, Math.round((load / cores) * 100))
+  }
+  const last = previous
+  previous = sample
+  if (!last) return undefined
+  const totalDelta = sample.total - last.total
+  const idleDelta = sample.idle - last.idle
+  if (totalDelta <= 0) return undefined
+  return Math.max(0, Math.min(100, Math.round(((totalDelta - idleDelta) / totalDelta) * 100)))
+}
+
+export async function system(): Promise<SystemStat | undefined> {
+  const memory = await meminfo()
+  if (!memory) return undefined
+  return { ...memory, utilization: await cpuUtilisation() }
+}