npm - shraga - Versions diffs - 0.1.80 → 0.1.82 - Mend

shraga 0.1.80 → 0.1.82

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/dist/client/assets/{index-h0IKxLlQ.js → index-yDX1hxfO.js} +223 -223
package/dist/client/index.html +1 -1
package/package.json +1 -1
package/src/client/components/MachineStats.tsx +34 -2
package/src/client/lib/ws.ts +1 -1
package/src/server/background-jobs.ts +51 -1
package/src/server/claude.ts +1 -1
package/src/server/stats.ts +102 -0
package/src/shared/disk.ts +23 -0

package/dist/client/index.html CHANGED Viewed

@@ -13,7 +13,7 @@
     <link rel="preconnect" href="https://fonts.googleapis.com" />
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
     <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600&display=swap" rel="stylesheet" />
-    <script type="module" crossorigin src="/assets/index-h0IKxLlQ.js"></script>
+    <script type="module" crossorigin src="/assets/index-yDX1hxfO.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-J2NH6FvE.css">
   </head>
   <body>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "shraga",
-  "version": "0.1.80",
+  "version": "0.1.82",
   "description": "The teammate you delegate coding to — a self-hostable, multi-user AI coding agent web UI (Claude Code, with a pluggable engine seam).",
   "type": "module",
   "main": "./src/index.ts",

package/src/client/components/MachineStats.tsx CHANGED Viewed

@@ -2,6 +2,7 @@ import { useCallback, useEffect, useRef, useState } from 'react';
 import type { AgentSocket, ServerEvent } from '@/lib/ws';
 import { cn } from '@/lib/utils';
 import { Popover, PopoverContent, PopoverTrigger } from './ui/popover';
+import { DISK_WARN_PCT, DISK_CRIT_PCT, formatBytes } from '../../shared/disk';
 type Sample = Extract<ServerEvent, { type: 'stats' }>['sample'];
@@ -69,6 +70,12 @@ export function MachineStats({ socket, getToken }: Props) {
     <div className="w-full flex flex-wrap items-center justify-center gap-x-2 gap-y-0.5 text-[10px] text-muted-foreground/60">
       <Metric label="cpu" value={latest.cpu} series={samples.map(s => s.cpu)} />
       <Metric label="mem" value={latest.mem} series={samples.map(s => s.mem)} />
+      {latest.disk >= 0 && (
+        // Gauge, not sparkline: the server refreshes disk once a minute, so a 10-min trend line would
+        // be a near-flat 10-point stair that reads as broken. A current-value bar is the honest shape.
+        <Metric label="disk" value={latest.disk} severity={diskSeverity(latest.disk)}
+                title={diskTip(latest)} />
+      )}
       <ClaudeUsageMetric getToken={getToken} />
     </div>
   );
@@ -302,8 +309,20 @@ export function untilLabel(iso: string | null): string | null {
 /** Only severities we have actually SEEN mean something here. The vendor's vocabulary is not
  *  documented and not fully observed, so an unrecognised value falls through to the percentage
  *  thresholds — treating "anything that isn't normal" as elevated would paint the widget a
- *  permanent amber the first time the endpoint adds a benign new word. */
-const ELEVATED: Record<string, string> = { critical: 'text-red-500', exceeded: 'text-red-500', warning: 'text-amber-500', warn: 'text-amber-500' };
+ *  permanent amber the first time the endpoint adds a benign new word. 'ok' is ours, not the
+ *  vendor's: it lets a metric with its OWN bands (disk) say "fine" instead of inheriting 75/90. */
+// Thresholds come from the one shared module the server reads too (src/shared/disk.ts) — re-exported
+// here so existing importers of this component keep their import site. Not re-declared: a second
+// literal is a drift waiting to happen.
+export { DISK_WARN_PCT, DISK_CRIT_PCT };
+/** Disk has its own bands: 80% full is unremarkable for a disk, so it must NOT inherit the generic
+ *  75/90 percent colouring — hence an explicit 'ok' rather than falling through to those. */
+export function diskSeverity(pct: number): string {
+  return pct >= DISK_CRIT_PCT ? 'critical' : pct >= DISK_WARN_PCT ? 'warning' : 'ok';
+}
+const ELEVATED: Record<string, string> = { critical: 'text-red-500', exceeded: 'text-red-500', warning: 'text-amber-500', warn: 'text-amber-500', ok: 'text-emerald-500' };
 function level(v: number, severity?: string) {
   const known = severity ? ELEVATED[severity] : undefined;
@@ -311,6 +330,19 @@ function level(v: number, severity?: string) {
   return v >= 90 ? 'text-red-500' : v >= 75 ? 'text-amber-500' : 'text-emerald-500';
 }
+/**
+ * Hover text. The percentage alone cannot tell you whether 93% is 3GB or 300GB left, which is the
+ * first thing anyone asks when they see it amber — so the tooltip carries the actual figures. Falls
+ * back to the bare percentage on a sample from a server too old to send the byte fields.
+ */
+function diskTip(s: { disk: number; diskUsedBytes?: number; diskTotalBytes?: number }): string {
+  const bounds = `warn at ${DISK_WARN_PCT}%, critical at ${DISK_CRIT_PCT}%`;
+  if (s.diskUsedBytes == null || s.diskTotalBytes == null) return `disk ${s.disk}% used — ${bounds}`;
+  const free = Math.max(0, s.diskTotalBytes - s.diskUsedBytes);
+  return `disk ${s.disk}% used — ${formatBytes(s.diskUsedBytes)} of ${formatBytes(s.diskTotalBytes)}, `
+    + `${formatBytes(free)} free — ${bounds}`;
+}
 function Metric({ label, value, series, title, severity }: { label: string; value: number; series?: number[]; title?: string; severity?: string }) {
   const tone = level(value, severity);
   // Plain-text fallback only where nothing richer exists (cpu/mem). The usage metric passes no title:

package/src/client/lib/ws.ts CHANGED Viewed

@@ -48,7 +48,7 @@ export type ServerEvent =
   | { type: 'unread_cleared'; sessionId: string }
   | { type: 'pty_list_changed'; sessionId: string }
   | { type: 'workspace_layout_changed' }
-  | { type: 'stats'; sample: { t: number; cpu: number; mem: number; load: number } };
+  | { type: 'stats'; sample: { t: number; cpu: number; mem: number; load: number; disk: number; diskUsedBytes?: number; diskTotalBytes?: number } };
 type Listener = (event: ServerEvent) => void;

package/src/server/background-jobs.ts CHANGED Viewed

@@ -231,7 +231,15 @@ export async function startJob(owner: JobOwner, command: string): Promise<string
     // stdin is /dev/null so a child can never block on (or steal) input; stdout+stderr go straight
     // to the fd — nothing is buffered in this process, so a chatty job costs disk, not memory.
     const proc = spawn('/bin/sh', ['-c', buildShell(id, cmd)], {
-      cwd: owner.cwd, env: { ...childEnv(), ...owner.env },
+      cwd: owner.cwd,
+      env: {
+        ...childEnv(),
+        ...owner.env,
+        // A long-running launcher can gate on these: only a REGISTERED job gets a completion wake,
+        // so one started in the foreground orphans silently when its 60s tool call is killed.
+        SHRAGA_JOB_ID: id,
+        SHRAGA_BG_JOB: '1',
+      },
       detached: true, stdio: ['ignore', fd, fd],
     });
     j.pid = proc.pid;
@@ -251,6 +259,47 @@ export async function startJob(owner: JobOwner, command: string): Promise<string
   return id;
 }
+/** The little of a spawned child this module needs to adopt one (node's ChildProcess satisfies it). */
+type AdoptableProcess = {
+  pid?: number | null;
+  stdout?: { on(ev: 'data', cb: (chunk: unknown) => void): void } | null;
+  stderr?: { on(ev: 'data', cb: (chunk: unknown) => void): void } | null;
+  on(ev: 'close' | 'error', cb: (arg: never) => void): void;
+  unref?: () => void;
+};
+/**
+ * Register an ALREADY-RUNNING child as a background job. The Shell tool hands a foreground command
+ * over at its deadline instead of killing it: the work continues, and from here it is an ordinary job
+ * — polled with ShellOutput, and reported back to the session when it ends. Without this the deadline
+ * stays a kill, which is what abandoned a scheduled run midway.
+ */
+export function adoptJob(owner: JobOwner, command: string, proc: AdoptableProcess, seed = ''): string {
+  const id = `job-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+  const j: JobRecord = {
+    id, sessionId: owner.sessionId, uid: owner.uid, userEmail: owner.userEmail,
+    command: command.trim(), cwd: owner.cwd, startedAt: Date.now(), status: 'running',
+    pid: proc.pid ?? undefined,
+  };
+  // The child was spawned with pipes by the caller, so output is appended here rather than dup'd to
+  // an fd the way a job we spawn ourselves does it.
+  const append = (chunk: unknown) => {
+    const text = typeof chunk === 'string' ? chunk : String(chunk ?? '');
+    if (!text) return;
+    try { writeFileSync(logFile(id), text, { flag: 'a' }); } catch { /* the job outlives its log */ }
+  };
+  if (seed) append(seed);
+  proc.stdout?.on('data', append);
+  proc.stderr?.on('data', append);
+  proc.on('error', ((err: Error) => finish(id, 'error', undefined, `adopted job error: ${err?.message ?? err}`)) as never);
+  proc.on('close', ((code: number | null) => finish(id, 'exited', code ?? undefined)) as never);
+  proc.unref?.();
+  records.set(id, j);
+  save(j);
+  console.log(`${PREFIX} adopted ${id} pid=${j.pid} session=${j.sessionId.slice(0, 8)} cmd=${j.command.slice(0, 120)}`);
+  return id;
+}
 /** Record a terminal state exactly once, then schedule the follow-up. */
 function finish(id: string, status: JobStatus, exitCode?: number, note?: string): void {
   const j = records.get(id);
@@ -479,6 +528,7 @@ export function sessionJobRegistry(owner: JobOwner) {
   };
   return {
     start: (command: string) => startJob(owner, command),
+    adopt: (command: string, proc: AdoptableProcess, seed?: string) => adoptJob(owner, command, proc, seed),
     output(id: string): string | null {
       const j = mine(id);
       if (!j) return null;

package/src/server/claude.ts CHANGED Viewed

@@ -83,7 +83,7 @@ export type WsEvent =
   | { type: 'done'; sessionId: string; stopReason?: 'end_turn' | 'max_turns_reached' | (string & {}); builtinHandled?: boolean }
   | { type: 'model_resolved'; sessionId: string; model: string }
   | { type: 'error'; message: string }
-  | { type: 'stats'; sample: { t: number; cpu: number; mem: number; load: number } };
+  | { type: 'stats'; sample: { t: number; cpu: number; mem: number; load: number; disk: number; diskUsedBytes?: number; diskTotalBytes?: number } };
 // Add-on engines/features emit their OWN events (e.g. a duplex voice brain's `duplex_*`) through the
 // object-typed `emitToSession()` bus (session-bus.ts) — NOT this union. So the core names none of them
 // here, yet forwards them verbatim to clients. Keep this union the closed set of core-owned events.

package/src/server/stats.ts CHANGED Viewed

@@ -3,6 +3,7 @@
 // they seed from getStats() and then receive live points over WS. N users = 1 sampler.
 import os from 'node:os';
 import { readFileSync } from 'node:fs';
+import { statfs } from 'node:fs/promises';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
@@ -13,13 +14,27 @@ export interface StatSample {
   cpu: number; // 0-100, host CPU utilization since last sample
   mem: number; // 0-100, used / total memory
   load: number; // 1-min load average
+  disk: number; // 0-100, used of the root filesystem (cached, refreshed slowly — see refreshDisk)
+  /** Bytes used / total, for the hover tooltip. Omitted until the first successful refresh. */
+  diskUsedBytes?: number;
+  diskTotalBytes?: number;
 }
+/** Hourly ceiling on the disk-failure warning, so a permanently broken mount cannot flood the log. */
+const DISK_FAIL_LOG_INTERVAL_MS = 60 * 60 * 1000;
 export class StatsSamplerOptions {
   intervalMs = 5000;
   window = 120; // ring-buffer length (120 × 5s = 10 min trend)
+  // Disk moves in minutes, not seconds, and statfs() stats the whole filesystem — no reason to pay
+  // for it on every 5s tick. Refreshed on its own slow cadence into a cache the sample just reads.
+  diskIntervalMs = 60_000;
 }
+// Single source in ../shared/disk.ts, imported by the client widget too — re-exported here so
+// server-side callers (and the tests) keep the same import site.
+export { DISK_WARN_PCT, DISK_CRIT_PCT } from '../shared/disk';
 export class StatsSampler {
   public options: StatsSamplerOptions;
   private buffer: StatSample[] = [];
@@ -30,6 +45,17 @@ export class StatsSampler {
   // ~1-2s (longer under load) every 5s — stalling /api/version long enough to trip the health watchdog
   // into false-restarting a live server. Seed from the cheap os.freemem fallback until the first refresh.
   private memPct = 100 * (1 - os.freemem() / os.totalmem());
+  // Cached disk %, refreshed on the slow diskIntervalMs cadence. -1 until the first refresh lands, so
+  // an unread disk renders as "unknown" rather than a confident 0% (an empty disk) — and a failed
+  // refresh keeps the LAST known value rather than resetting it.
+  private diskPct = -1;
+  private diskUsedBytes: number | undefined;
+  private diskTotalBytes: number | undefined;
+  /** One refresh at a time — see refreshDisk. */
+  private diskInFlight = false;
+  /** Epoch ms of the last logged disk failure; 0 = none since the last success. */
+  private diskFailLoggedAt = 0;
+  private diskTimer: ReturnType<typeof setInterval> | null = null;
   public constructor(options?: Partial<StatsSamplerOptions>) {
     this.options = { ...new StatsSamplerOptions(), ...options };
@@ -38,6 +64,9 @@ export class StatsSampler {
   start(broadcast: (data: object) => void) {
     if (this.timer) return; // singleton — already running
     void this.refreshMem(); // prime the cache; each tick refreshes it async for the NEXT sample
+    void this.refreshDisk();
+    this.diskTimer = setInterval(() => { void this.refreshDisk(); }, this.options.diskIntervalMs);
+    if (typeof this.diskTimer.unref === 'function') this.diskTimer.unref();
     this.timer = setInterval(() => {
       void this.refreshMem(); // async, non-blocking — updates this.memPct without stalling the loop
       const sample = this.sample();
@@ -51,6 +80,7 @@ export class StatsSampler {
   stop() {
     if (this.timer) { clearInterval(this.timer); this.timer = null; }
+    if (this.diskTimer) { clearInterval(this.diskTimer); this.diskTimer = null; }
   }
   getStats(): StatSample[] {
@@ -68,12 +98,46 @@ export class StatsSampler {
       cpu: Math.round(cpu),
       mem: Math.round(this.memPct), // cached; refreshed async each tick (never blocks the loop)
       load: Math.round(os.loadavg()[0] * 100) / 100,
+      disk: this.diskPct, // cached; refreshed every diskIntervalMs — already an integer (see diskUsedPct)
+      diskUsedBytes: this.diskUsedBytes,
+      diskTotalBytes: this.diskTotalBytes,
     };
   }
   // Refresh the cached memory %. os.freemem() counts reclaimable memory (page cache on Linux,
   // inactive/purgeable pages on macOS) as "used", so it reads ~95-99% even when healthy — use each OS's
   // notion of *available* (free + reclaimable) instead. Async + bounded so it can NEVER stall the loop.
+  // Refresh the cached disk %. statfs() is the node-native stat — no `df` subprocess, same call on
+  // macOS and Linux. Any failure (unreadable mount, permission) leaves the previous value in place.
+  private async refreshDisk(): Promise<void> {
+    // A hung filesystem must not let refreshes PILE UP: without this guard a never-resolving statfs
+    // accumulates one stuck threadpool task per tick (measured: 5 in-flight at a 50ms cadence),
+    // which starves Bun's fs threadpool for every other async fs consumer.
+    if (this.diskInFlight) return;
+    this.diskInFlight = true;
+    try {
+      const fs = await statfs('/');
+      const pct = diskUsedPct(fs, process.platform);
+      if (pct != null) this.diskPct = pct;
+      const bytes = diskBytes(fs, process.platform);
+      if (bytes) { this.diskUsedBytes = bytes.used; this.diskTotalBytes = bytes.total; }
+      this.diskFailLoggedAt = 0; // a success re-arms the log, so a NEW outage is still reported
+    } catch (err) {
+      // Keep the last known value — a stale number beats a wrong 0. Never swallow silently...
+      // ...but never at one line per tick either: a permission-denied or vanished mount would emit
+      // 1440 identical warnings a day and bury everything else. Log the first failure, then at most
+      // hourly while it persists. (`fs.statfs` also does not exist before Bun 1.2.x, and this
+      // package's engines still allow >=1.0.0 — on such a host this would warn forever from boot.)
+      const now = Date.now();
+      if (now - this.diskFailLoggedAt >= DISK_FAIL_LOG_INTERVAL_MS) {
+        this.diskFailLoggedAt = now;
+        console.warn('[stats] disk refresh failed, keeping last value', err);
+      }
+    } finally {
+      this.diskInFlight = false;
+    }
+  }
   private async refreshMem(): Promise<void> {
     try {
       if (process.platform === 'linux') {
@@ -94,6 +158,44 @@ export class StatsSampler {
   }
 }
+/** Percent USED of a filesystem, from a statfs() result. Exported (and platform passed in) so BOTH
+ *  branches are testable from either OS — the Linux one cannot otherwise be exercised in dev.
+ *  Per-platform on purpose, like refreshMem: each OS's honest notion of "how full is it".
+ *  Linux — exactly `df`'s formula, used/(used+available), so this meter and the box's df-parsing
+ *  watchdog report the same number (both exclude the root-reserved margin from both sides).
+ *  macOS — APFS volumes SHARE one container, so `df /`'s per-volume "used" reads ~25% on a disk that
+ *  is genuinely 92% full; only free-against-container-total tells the truth there.
+ *  Rounding is CEIL, not nearest, because `df` ceils its capacity column: exact 24.6515 prints as
+ *  `25%`, exact 3.2258 prints as `4%`. Nearest would put the meter one point BELOW df on ~half of all
+ *  values, so a root at exact 91.2% would show 91% in emerald "fine" while the df-parsing watchdog
+ *  (which tests df's own `92`) is already paging Slack. Ceiling on the Linux path is what makes the
+ *  two literally the same integer. Darwin ceils too: its number is a container reading that has no df
+ *  column to match, but rounding the same way keeps one rule for both platforms and errs toward
+ *  reporting a disk as fuller, never emptier, than it is.
+ *  Returns null for a nonsense stat, so the caller keeps its last known value. */
+export function diskUsedPct(fs: { blocks: bigint | number; bfree: bigint | number; bavail: bigint | number }, platform: string): number | null {
+  const blocks = Number(fs.blocks), bfree = Number(fs.bfree), bavail = Number(fs.bavail);
+  if (!(blocks > 0)) return null;
+  const pct = platform === 'darwin'
+    ? 100 * (1 - bavail / blocks)
+    : 100 * ((blocks - bfree) / Math.max(1, blocks - bfree + bavail));
+  return Math.ceil(Math.max(0, Math.min(100, pct)));
+}
+/**
+ * The same per-platform definition as `diskUsedPct`, in BYTES, for the hover tooltip. Kept adjacent
+ * and derived from the identical numerator/denominator so the percentage and the "X of Y" can never
+ * describe different quantities — on darwin the denominator is the APFS container, on linux it is
+ * df's `used + available` (which excludes root-reserved blocks).
+ */
+export function diskBytes(fs: { bsize: bigint | number; blocks: bigint | number; bfree: bigint | number; bavail: bigint | number }, platform: string): { used: number; total: number } | null {
+  const bsize = Number(fs.bsize), blocks = Number(fs.blocks), bfree = Number(fs.bfree), bavail = Number(fs.bavail);
+  if (!(blocks > 0) || !(bsize > 0)) return null;
+  const used = platform === 'darwin' ? blocks - bavail : blocks - bfree;
+  const total = platform === 'darwin' ? blocks : blocks - bfree + bavail;
+  return { used: used * bsize, total: total * bsize };
+}
 function cpuTotals() {
   let idle = 0, total = 0;
   for (const c of os.cpus()) {

package/src/shared/disk.ts ADDED Viewed

@@ -0,0 +1,23 @@
+// Disk-meter values that BOTH halves need. Dependency-free on purpose (no node:*, no react) so the
+// server can import it and vite can bundle it into the client — the only way a threshold change is
+// physically one edit instead of two that can drift.
+// Percent-USED thresholds for the disk meter. Kept identical to the box's Slack alerting
+// (tools/ec2/box-disk-watchdog.sh in shraga-circles, BOX_DISK_WARN_PCT/BOX_DISK_CRIT_PCT) so the
+// widget and the pager agree on what "in trouble" means — 92% is where that box's pushes started
+// timing out. This file is the single source: the server re-exports it, the client imports it.
+export const DISK_WARN_PCT = 92;
+export const DISK_CRIT_PCT = 96;
+/**
+ * Human byte size for the tooltip. Dependency-free and deliberately identical in both halves so the
+ * hover text and any server-side log read the same. Binary units, because that is what `df -h`
+ * prints and the whole point of this meter is agreeing with `df`.
+ */
+export function formatBytes(n: number): string {
+	if (!Number.isFinite(n) || n < 0) return '?';
+	const units = ['B', 'KB', 'MB', 'GB', 'TB', 'PB'];
+	let i = 0;
+	while (n >= 1024 && i < units.length - 1) { n /= 1024; i++; }
+	return `${n < 10 && i > 0 ? n.toFixed(1) : Math.round(n)} ${units[i]}`;
+}