@vtstech/pi-status 1.0.3

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@vtstech/pi-status",
+  "version": "1.0.3",
+  "description": "System monitor / status bar extension for Pi Coding Agent",
+  "main": "status.js",
+  "keywords": ["pi-package", "pi-extensions"],
+  "license": "MIT",
+  "access": "public",
+  "author": "VTSTech",
+  "homepage": "https://www.vts-tech.org",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/VTSTech/pi-coding-agent"
+  },
+  "dependencies": {
+    "@vtstech/pi-shared": "1.0.3"
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-coding-agent": ">=0.66"
+  },
+  "pi": {
+    "extensions": ["./status.js"]
+  }
+}

package/status.js

@@ -0,0 +1,327 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// .build-npm/status/status.temp.ts
+var status_temp_exports = {};
+__export(status_temp_exports, {
+  default: () => status_temp_default
+});
+module.exports = __toCommonJS(status_temp_exports);
+var import_node_os = __toESM(require("node:os"));
+var import_node_child_process = require("node:child_process");
+var import_ollama = require("@vtstech/pi-shared/ollama");
+var import_format = require("@vtstech/pi-shared/format");
+var import_security = require("@vtstech/pi-shared/security");
+function status_temp_default(pi) {
+  let lastResponseTime = null;
+  let agentStartTime = null;
+  let updateInterval = null;
+  let currentCtx = null;
+  let ctxUi = null;
+  let prevCpuInfo = getCpuSnapshot();
+  let lastPayload = null;
+  let tuiRef = null;
+  let gitBranchCache = "";
+  let cpuUsage = 0;
+  let memUsed = 0;
+  let memTotal = 0;
+  let swapUsed = 0;
+  let swapTotal = 0;
+  let hasSwap = false;
+  let ollamaLoaded = "";
+  let footerModel = "";
+  let footerThinking = "";
+  let footerCtxPct = "";
+  let securityFlashTool = "";
+  let securityFlashUntil = 0;
+  let activeTool = "";
+  let activeToolStart = 0;
+  let blockedCount = 0;
+  function getCpuSnapshot() {
+    return import_node_os.default.cpus().map((c) => ({
+      user: c.times.user,
+      nice: c.times.nice,
+      sys: c.times.sys,
+      idle: c.times.idle
+    }));
+  }
+  function getCpuUsage() {
+    const cpus = import_node_os.default.cpus();
+    const n = cpus.length;
+    let totalUsed = 0, totalDelta = 0;
+    for (let i = 0; i < n; i++) {
+      const prev = prevCpuInfo[i];
+      const curr = cpus[i].times;
+      const prevTotal = prev.user + prev.nice + prev.sys + prev.idle;
+      const currTotal = curr.user + curr.nice + curr.sys + curr.idle;
+      const d = currTotal - prevTotal;
+      if (d > 0) {
+        totalUsed += d - (curr.idle - prev.idle);
+        totalDelta += d;
+      }
+    }
+    prevCpuInfo = getCpuSnapshot();
+    return totalDelta > 0 ? totalUsed / totalDelta * 100 : 0;
+  }
+  function getMem() {
+    const total = import_node_os.default.totalmem();
+    const used = total - import_node_os.default.freemem();
+    return { used, total };
+  }
+  function getSwap() {
+    try {
+      const out = (0, import_node_child_process.execSync)("cat /proc/meminfo", { encoding: "utf-8", timeout: 3e3 });
+      const swapTotal2 = Number(out.match(/SwapTotal:\s+(\d+)/)?.[1]) * 1024;
+      const swapFree = Number(out.match(/SwapFree:\s+(\d+)/)?.[1]) * 1024;
+      if (swapTotal2 > 0) return { used: swapTotal2 - swapFree, total: swapTotal2 };
+    } catch {
+    }
+    return null;
+  }
+  let ollamaLoadedCache = "";
+  let ollamaLoadedLastCheck = 0;
+  const OLLAMA_LOADED_INTERVAL = 15e3;
+  function getOllamaLoadedModel() {
+    const now = Date.now();
+    if (now - ollamaLoadedLastCheck < OLLAMA_LOADED_INTERVAL) return ollamaLoadedCache;
+    ollamaLoadedLastCheck = now;
+    try {
+      const ollamaBase = (0, import_ollama.getOllamaBaseUrl)();
+      const out = (0, import_node_child_process.execSync)(`curl -s "${ollamaBase}/api/ps"`, { encoding: "utf-8", timeout: 5e3 });
+      if (out.trim()) {
+        const data = JSON.parse(out.trim());
+        const models = data?.models || [];
+        if (Array.isArray(models) && models.length > 0) {
+          ollamaLoadedCache = models[0].name || models[0].model || "unknown";
+          return ollamaLoadedCache;
+        }
+      }
+    } catch {
+    }
+    ollamaLoadedCache = "";
+    return "";
+  }
+  function extractParams(payload) {
+    const params = [];
+    if (payload.temperature !== void 0) params.push(`temp:${payload.temperature}`);
+    if (payload.top_p !== void 0) params.push(`top_p:${payload.top_p}`);
+    if (payload.top_k !== void 0) params.push(`top_k:${payload.top_k}`);
+    if (payload.max_completion_tokens !== void 0) params.push(`max:${payload.max_completion_tokens}`);
+    else if (payload.max_tokens !== void 0) params.push(`max:${payload.max_tokens}`);
+    if (payload.num_predict !== void 0) params.push(`predict:${payload.num_predict}`);
+    if (payload.num_ctx !== void 0) params.push(`ctx:${payload.num_ctx}`);
+    if (payload.reasoning_effort !== void 0) params.push(`think:${payload.reasoning_effort}`);
+    return params;
+  }
+  function getPwd() {
+    const cwd = process.cwd();
+    if (cwd.startsWith(import_node_os.default.homedir())) return "~" + cwd.slice(import_node_os.default.homedir().length);
+    return cwd;
+  }
+  function getGitBranch() {
+    if (gitBranchCache) return gitBranchCache;
+    try {
+      const branch = (0, import_node_child_process.execSync)("git rev-parse --abbrev-ref HEAD 2>/dev/null", {
+        encoding: "utf-8",
+        timeout: 3e3
+      }).trim();
+      if (branch) gitBranchCache = branch;
+    } catch {
+    }
+    return gitBranchCache;
+  }
+  function refreshBlockedCount() {
+    try {
+      const entries = (0, import_security.readRecentAuditEntries)(50);
+      blockedCount = 0;
+      for (const entry of entries) {
+        if (entry.blocked === true || entry.safe === false || entry.action === "block") {
+          blockedCount++;
+        }
+      }
+    } catch {
+      blockedCount = 0;
+    }
+  }
+  function updateMetrics() {
+    cpuUsage = getCpuUsage();
+    const mem = getMem();
+    memUsed = mem.used;
+    memTotal = mem.total;
+    const swap = getSwap();
+    if (swap) {
+      swapUsed = swap.used;
+      swapTotal = swap.total;
+      hasSwap = true;
+    } else {
+      hasSwap = false;
+    }
+    ollamaLoaded = getOllamaLoadedModel();
+    if (currentCtx) {
+      footerModel = currentCtx.model?.id || "";
+      footerThinking = pi.getThinkingLevel?.() ?? "";
+      const usage = currentCtx.getContextUsage?.();
+      if (usage && usage.contextWindow > 0) {
+        const pct = (usage.tokens / usage.contextWindow * 100).toFixed(1);
+        footerCtxPct = `${pct}%/${(usage.contextWindow / 1e3).toFixed(0)}k`;
+      } else {
+        footerCtxPct = "";
+      }
+    }
+    refreshBlockedCount();
+  }
+  pi.on("session_start", async (_event, ctx) => {
+    currentCtx = ctx;
+    ctxUi = ctx.ui;
+    prevCpuInfo = getCpuSnapshot();
+    updateMetrics();
+    ctx.ui.setFooter((tui, theme, footerData) => {
+      tuiRef = tui;
+      const dim = (s) => theme?.fg?.("dim", s) ?? s;
+      const red = (s) => theme?.fg?.("red", s) ?? s;
+      const yellow = (s) => theme?.fg?.("yellow", s) ?? s;
+      const sep = dim(" \xB7 ");
+      return {
+        render(width) {
+          const lines = [];
+          const parts = [];
+          parts.push(getPwd());
+          let branch = "";
+          try {
+            branch = footerData?.getGitBranch?.() || "";
+          } catch {
+          }
+          if (!branch) branch = getGitBranch();
+          if (branch) parts.push(dim(branch));
+          if (footerModel) parts.push(dim(footerModel));
+          if (footerThinking && footerThinking !== "off") parts.push(dim(footerThinking));
+          if (footerCtxPct) parts.push(footerCtxPct);
+          parts.push(dim(`CPU ${cpuUsage.toFixed(0)}%`));
+          parts.push(`RAM ${(0, import_format.fmtBytes)(memUsed)}/${(0, import_format.fmtBytes)(memTotal)}`);
+          if (hasSwap && swapUsed > 0) {
+            parts.push(`Swap ${(0, import_format.fmtBytes)(swapUsed)}/${(0, import_format.fmtBytes)(swapTotal)}`);
+          }
+          if (ollamaLoaded) parts.push(`${ollamaLoaded}`);
+          if (lastResponseTime !== null) parts.push(`Resp ${(0, import_format.fmtDur)(lastResponseTime)}`);
+          if (lastPayload) {
+            const params = extractParams(lastPayload);
+            if (params.length > 0) parts.push(...params.map((p) => dim(p)));
+          }
+          const now = Date.now();
+          if (securityFlashTool && now < securityFlashUntil) {
+            parts.push(red(`BLOCKED:${securityFlashTool}`));
+          }
+          if (blockedCount > 0) {
+            parts.push(red(`SEC:${blockedCount}`));
+          }
+          let line = parts.join(sep);
+          const visible = line.replace(/\x1b\[[0-9;]*m/g, "");
+          if (visible.length > width) {
+            let vis = 0, cut = 0;
+            for (let i = 0; i < line.length && vis < width - 3; i++) {
+              if (line[i] === "\x1B") {
+                while (i < line.length && line[i] !== "m") i++;
+              } else {
+                vis++;
+              }
+              cut = i + 1;
+            }
+            line = line.slice(0, cut) + dim("...");
+          }
+          lines.push(line);
+          if (activeTool && activeToolStart > 0) {
+            const elapsed = performance.now() - activeToolStart;
+            lines.push(`${yellow("\u23F3")} ${activeTool}: ${(0, import_format.fmtDur)(elapsed)}`);
+          }
+          return lines;
+        },
+        invalidate() {
+        },
+        dispose() {
+        }
+      };
+    });
+    if (updateInterval) clearInterval(updateInterval);
+    updateInterval = setInterval(() => {
+      updateMetrics();
+      if (tuiRef) tuiRef.requestRender();
+    }, 3e3);
+  });
+  pi.on("session_shutdown", async () => {
+    if (updateInterval) clearInterval(updateInterval);
+    updateInterval = null;
+    tuiRef = null;
+    if (ctxUi) {
+      ctxUi.setFooter(void 0);
+      ctxUi = null;
+    }
+    currentCtx = null;
+    securityFlashTool = "";
+    securityFlashUntil = 0;
+    activeTool = "";
+    activeToolStart = 0;
+    blockedCount = 0;
+  });
+  pi.on("before_provider_request", (event) => {
+    lastPayload = event.payload;
+  });
+  pi.on("agent_start", async () => {
+    agentStartTime = performance.now();
+  });
+  pi.on("agent_end", async () => {
+    if (agentStartTime !== null) {
+      lastResponseTime = performance.now() - agentStartTime;
+      agentStartTime = null;
+    }
+    activeTool = "";
+    activeToolStart = 0;
+    updateMetrics();
+    if (tuiRef) tuiRef.requestRender();
+  });
+  pi.on("tool_call", (event) => {
+    if (!event) return;
+    const isBlocked = event.blocked === true || event.blocked === "true" || event.result?.blocked === true || event.error?.includes("blocked");
+    if (isBlocked) {
+      securityFlashTool = event.tool ?? event.name ?? "unknown";
+      securityFlashUntil = Date.now() + 3e3;
+      refreshBlockedCount();
+      if (tuiRef) tuiRef.requestRender();
+    }
+  });
+  pi.on("tool_execution_start", (event) => {
+    if (!event) return;
+    activeTool = event.tool ?? event.name ?? "tool";
+    activeToolStart = performance.now();
+    if (tuiRef) tuiRef.requestRender();
+  });
+  pi.on("tool_execution_end", () => {
+    activeTool = "";
+    activeToolStart = 0;
+    if (tuiRef) tuiRef.requestRender();
+  });
+}