mixdog 0.9.3 → 0.9.5

package/src/ui/statusline-segments.mjs

@@ -0,0 +1,148 @@
+/**
+ * src/ui/statusline-segments.mjs — filesystem-backed L2 segment sources.
+ *
+ * Extracted verbatim from statusline.mjs: the shell-jobs segment (owner-scoped
+ * job scan + liveness) and the memory-cycle segment (daemon state file). Both
+ * keep their own 1s process-local caches. No behavior change.
+ */
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { formatElapsed } from './statusline-format.mjs';
+
+const DEFAULT_MIXDOG_HOME = process.env.MIXDOG_HOME || join(homedir(), '.mixdog');
+const DEFAULT_STANDALONE_DATA_DIR = join(DEFAULT_MIXDOG_HOME, 'data');
+const SHELL_JOBS_SEGMENT_CACHE_MS = 1000;
+
+let _shellJobsSegmentCache = { ownerPid: 0, at: 0, value: { count: 0, elapsedLabel: '' } };
+
+function dataDir() {
+  return process.env.MIXDOG_DATA_DIR || DEFAULT_STANDALONE_DATA_DIR;
+}
+
+export function shellJobsStatus({ clientHostPid } = {}) {
+  return _shellJobsStatusImpl({ clientHostPid });
+}
+
+// Memory cycle L2 segment source. The memory daemon writes
+// data/memory-cycle-state.json on every cycle start/finish (index.mjs
+// _writeCycleStateFile) — no HTTP call from the statusline path. Cached at
+// the same 1s cadence as the shell segment. Shows a single unified "Memory"
+// segment: running (spinner + elapsed) or backlog warning (yellow count).
+let _memoryCycleSegmentCache = { at: 0, value: null };
+const MEMORY_CYCLE_SEGMENT_CACHE_MS = 1000;
+const MEMORY_CYCLE_BACKLOG_WARN = 500;
+export function memoryCycleStatus() {
+  const now = Date.now();
+  if (now - _memoryCycleSegmentCache.at < MEMORY_CYCLE_SEGMENT_CACHE_MS) {
+    return _memoryCycleSegmentCache.value;
+  }
+  let value = null;
+  try {
+    const p = join(dataDir(), 'memory-cycle-state.json');
+    if (existsSync(p)) {
+      const state = JSON.parse(readFileSync(p, 'utf-8'));
+      const running = state?.running || null;
+      const backlog = state?.backlog || {};
+      // Stale-file guard: a daemon that died mid-run leaves running set —
+      // ignore anything not refreshed in the last 10 minutes.
+      const fresh = Number(state?.updatedAt) > now - 10 * 60_000;
+      if (fresh && running?.cycle && Number(running.started_at) > 0) {
+        value = { kind: 'running', startedAt: Number(running.started_at) };
+      } else if (fresh) {
+        const pending = Math.max(Number(backlog?.unchunked) || 0, Number(backlog?.cycle2_pending) || 0);
+        if (pending > MEMORY_CYCLE_BACKLOG_WARN) value = { kind: 'backlog', pending };
+      }
+    }
+  } catch { value = null; }
+  _memoryCycleSegmentCache = { at: now, value };
+  return value;
+}
+
+function _shellJobsStatusImpl({ clientHostPid } = {}) {
+  const ownerPid = positiveInt(clientHostPid);
+  const empty = { count: 0, elapsedLabel: '' };
+  if (!ownerPid) return empty;
+  const now = Date.now();
+  if (_shellJobsSegmentCache.ownerPid === ownerPid && now - _shellJobsSegmentCache.at < SHELL_JOBS_SEGMENT_CACHE_MS) {
+    return _shellJobsSegmentCache.value || empty;
+  }
+  let value = empty;
+  try {
+    const dir = join(dataDir(), 'shell-jobs');
+    if (!existsSync(dir)) {
+      _shellJobsSegmentCache = { ownerPid, at: now, value };
+      return value;
+    }
+    const names = readdirSync(dir);
+    const done = new Set(names.filter((n) => n.endsWith('.done')).map((n) => n.slice(0, -5)));
+    const ownerByJob = new Map();
+    for (const n of names) {
+      const i = n.lastIndexOf('.owner-');
+      if (i > 0) {
+        const pid = positiveInt(n.slice(i + 7));
+        if (pid) ownerByJob.set(n.slice(0, i), pid);
+      }
+    }
+    const ids = names
+      .filter((n) => n.endsWith('.json'))
+      .map((n) => n.slice(0, -5))
+      .filter((id) => !done.has(id) && ownerByJob.get(id) === ownerPid)
+      .sort((a, b) => jobStampMs(b) - jobStampMs(a))
+      .slice(0, 30);
+    let count = 0;
+    let oldestMs = Infinity;
+    for (const id of ids) {
+      const p = join(dir, `${id}.json`);
+      let detail;
+      try { detail = JSON.parse(readFileSync(p, 'utf-8')); } catch { continue; }
+      if (!isShellJobAlive(detail, p, dir, id)) continue;
+      count++;
+      try {
+        const st = statSync(p);
+        if (st.mtimeMs < oldestMs) oldestMs = st.mtimeMs;
+      } catch {}
+    }
+    if (!count) {
+      _shellJobsSegmentCache = { ownerPid, at: now, value };
+      return value;
+    }
+    const elapsedLabel = Number.isFinite(oldestMs) ? formatElapsed(Date.now() - oldestMs) : '';
+    value = { count, elapsedLabel };
+  } catch {
+    value = empty;
+  }
+  _shellJobsSegmentCache = { ownerPid, at: now, value };
+  return value;
+}
+
+function isShellJobAlive(detail, detailPath, dir, id) {
+  const pid = positiveInt(detail?.pid);
+  if (!pid) return false;
+  try {
+    const st = statSync(detailPath);
+    const timeoutMs = Number(detail?.timeoutMs);
+    const enforced = detail?.timeoutEnforced === true || existsSync(join(dir, `${id}.enforced`));
+    if (enforced && Number.isFinite(timeoutMs) && timeoutMs > 0 && Date.now() - st.mtimeMs > timeoutMs + 30 * 60_000) {
+      return false;
+    }
+  } catch {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e?.code === 'EPERM';
+  }
+}
+
+function jobStampMs(id) {
+  const m = /^job_(\d+)/.exec(String(id || ''));
+  return m ? Number(m[1]) : 0;
+}
+
+function positiveInt(value) {
+  const n = Number(value);
+  return Number.isInteger(n) && n > 0 ? n : 0;
+}