@vtstech/pi-status 1.2.2 → 1.2.3

package/package.json

@@ -1,9 +1,14 @@
 {
   "name": "@vtstech/pi-status",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "description": "System monitor / status bar extension for Pi Coding Agent",
   "main": "status.js",
-  "keywords": ["pi-package", "pi", "pi-coding-agent", "pi-extensions"],
+  "keywords": [
+    "pi-package",
+    "pi",
+    "pi-coding-agent",
+    "pi-extensions"
+  ],
   "license": "MIT",
   "access": "public",
   "type": "module",
@@ -13,13 +18,12 @@
     "type": "git",
     "url": "https://github.com/VTSTech/pi-coding-agent"
   },
-  "dependencies": {
-    "@vtstech/pi-shared": "1.2.2"
-  },
   "peerDependencies": {
     "@mariozechner/pi-coding-agent": ">=0.66"
   },
   "pi": {
-    "extensions": ["./status.js"]
+    "extensions": [
+      "./status.js"
+    ]
   }
 }

package/status.js

@@ -1,16 +1,395 @@
-// .build-npm/status/status.temp.ts
-import * as fs from "node:fs";
+// extensions/status.ts
+import * as fs3 from "node:fs";
 import { exec } from "node:child_process";
 import { promisify } from "node:util";
+import os4 from "node:os";
+
+// shared/ollama.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
 import os from "node:os";
-import { getOllamaBaseUrl, fetchModelContextLength, readModelsJson, isLocalProvider } from "@vtstech/pi-shared/ollama";
-import { fmtBytes, fmtDur } from "@vtstech/pi-shared/format";
-import { debugLog } from "@vtstech/pi-shared/debug";
-import { getSecurityMode } from "@vtstech/pi-shared/security";
+
+// shared/debug.ts
+var DEBUG_ENABLED = process?.env?.PI_EXTENSIONS_DEBUG === "1";
+function debugLog(module, message, ...args) {
+  if (!DEBUG_ENABLED) return;
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  console.debug(`[pi-ext:${module}] ${timestamp} ${message}`, ...args);
+}
+
+// shared/ollama.ts
+var MODELS_JSON_PATH = path.join(os.homedir(), ".pi", "agent", "models.json");
+var _modelsJsonCache = null;
+var _ollamaBaseUrlCache = null;
+var CACHE_TTL_MS = 2e3;
+function getOllamaBaseUrl() {
+  const now = Date.now();
+  if (_ollamaBaseUrlCache && now - _ollamaBaseUrlCache.ts < CACHE_TTL_MS) return _ollamaBaseUrlCache.data;
+  try {
+    if (fs.existsSync(MODELS_JSON_PATH)) {
+      const raw = fs.readFileSync(MODELS_JSON_PATH, "utf-8");
+      const config = JSON.parse(raw);
+      const baseUrl = config?.providers?.["ollama"]?.baseUrl;
+      if (baseUrl) {
+        const result = baseUrl.replace(/\/v1\/?$/, "");
+        _ollamaBaseUrlCache = { data: result, ts: now };
+        return result;
+      }
+    }
+  } catch (err) {
+    debugLog("ollama", "failed to parse models.json for base URL", err);
+  }
+  if (process.env.OLLAMA_HOST) {
+    const result = `http://${process.env.OLLAMA_HOST.replace(/^https?:\/\//, "")}`;
+    _ollamaBaseUrlCache = { data: result, ts: now };
+    return result;
+  }
+  const fallback = "http://localhost:11434";
+  _ollamaBaseUrlCache = { data: fallback, ts: now };
+  return fallback;
+}
+function readModelsJson() {
+  const now = Date.now();
+  if (_modelsJsonCache && now - _modelsJsonCache.ts < CACHE_TTL_MS) return _modelsJsonCache.data;
+  try {
+    if (fs.existsSync(MODELS_JSON_PATH)) {
+      const raw = fs.readFileSync(MODELS_JSON_PATH, "utf-8");
+      const data = JSON.parse(raw);
+      _modelsJsonCache = { data, ts: now };
+      return data;
+    }
+  } catch (err) {
+    debugLog("ollama", "failed to read/parse models.json", err);
+  }
+  const empty = { providers: {} };
+  _modelsJsonCache = { data: empty, ts: now };
+  return empty;
+}
+var DEFAULT_RETRY_OPTIONS = {
+  maxRetries: 2,
+  baseDelayMs: 1e3,
+  maxDelayMs: 1e4,
+  retryOnTimeout: true,
+  retryOnConnectionError: true
+};
+function backoffDelay(attempt, baseDelayMs, maxDelayMs) {
+  const delay = Math.min(baseDelayMs * Math.pow(2, attempt), maxDelayMs);
+  const jitter = delay * 0.25 * (Math.random() * 2 - 1);
+  return Math.max(0, Math.round(delay + jitter));
+}
+var RETRYABLE_ERROR_PATTERNS = [
+  "ECONNREFUSED",
+  "ECONNRESET",
+  "ENOTFOUND",
+  "ETIMEDOUT",
+  "fetch failed",
+  "network error",
+  "socket hang up",
+  "Empty response"
+];
+function isRetryableError(error, opts) {
+  if (error instanceof Error) {
+    if (error.name === "AbortError" && opts.retryOnTimeout) return true;
+    const msg = error.message;
+    if (opts.retryOnConnectionError && RETRYABLE_ERROR_PATTERNS.some((p) => msg.includes(p))) {
+      return true;
+    }
+  }
+  return false;
+}
+async function withRetry(fn, options) {
+  const opts = { ...DEFAULT_RETRY_OPTIONS, ...options };
+  let lastError;
+  for (let attempt = 0; attempt <= opts.maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt < opts.maxRetries && isRetryableError(error, opts)) {
+        const delay = backoffDelay(attempt, opts.baseDelayMs, opts.maxDelayMs);
+        debugLog("ollama", `Retry ${attempt + 1}/${opts.maxRetries} after ${delay}ms: ${error instanceof Error ? error.message : String(error)}`);
+        await new Promise((r) => setTimeout(r, delay));
+        continue;
+      }
+      throw error;
+    }
+  }
+  throw lastError;
+}
+async function fetchModelContextLength(baseUrl, modelName) {
+  return withRetry(async () => {
+    try {
+      const res = await fetch(`${baseUrl}/api/show`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ name: modelName }),
+        signal: AbortSignal.timeout(3e4)
+      });
+      if (!res.ok) return void 0;
+      const data = await res.json();
+      for (const key of Object.keys(data?.model_info ?? {})) {
+        if (key.endsWith(".context_length")) {
+          const val = data.model_info[key];
+          if (typeof val === "number") return val;
+        }
+      }
+      const numCtx = data?.model_info?.["num_ctx"];
+      if (typeof numCtx === "number") return numCtx;
+    } catch (err) {
+      debugLog("ollama", `failed to fetch context length for ${modelName}`, err);
+      return void 0;
+    }
+    return void 0;
+  });
+}
+function isLocalProvider(baseUrl, providerName) {
+  if (providerName === "ollama") return true;
+  const url = baseUrl || "";
+  return url.includes("localhost") || url.includes("127.0.0.1") || url.includes("0.0.0.0");
+}
+
+// shared/format.ts
+function fmtBytes(b) {
+  if (b === 0) return "0B";
+  if (b < 1024) return `${b}B`;
+  if (b >= 1073741824) return `${(b / 1073741824).toFixed(1)}G`;
+  if (b >= 1048576) return `${(b / 1048576).toFixed(0)}M`;
+  return `${(b / 1024).toFixed(0)}K`;
+}
+function fmtDur(ms) {
+  if (ms < 1e3) return `${Math.round(ms)}ms`;
+  if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+  return `${Math.floor(ms / 6e4)}m${Math.round(ms % 6e4 / 1e3)}s`;
+}
+
+// shared/security.ts
+import * as fs2 from "node:fs";
+import * as path3 from "node:path";
+import os3 from "node:os";
+
+// shared/config-io.ts
+import * as path2 from "path";
+import os2 from "os";
+var PI_AGENT_DIR = path2.join(os2.homedir(), ".pi", "agent");
+var SETTINGS_PATH = path2.join(PI_AGENT_DIR, "settings.json");
+var SECURITY_PATH = path2.join(PI_AGENT_DIR, "security.json");
+var REACT_MODE_PATH = path2.join(PI_AGENT_DIR, "react-mode.json");
+var MODEL_TEST_CONFIG_PATH = path2.join(PI_AGENT_DIR, "model-test-config.json");
+
+// shared/security.ts
+var SECURITY_CONFIG_PATH = SECURITY_PATH;
+var securityModeCache = null;
+var securityModeCacheTime = 0;
+var SECURITY_CACHE_DURATION_MS = 3e4;
+function getSecurityMode() {
+  const now = Date.now();
+  if (securityModeCache && now - securityModeCacheTime < SECURITY_CACHE_DURATION_MS) {
+    return securityModeCache;
+  }
+  try {
+    if (!fs2.existsSync(SECURITY_CONFIG_PATH)) {
+      securityModeCache = "max";
+      securityModeCacheTime = now;
+      return "max";
+    }
+    const raw = fs2.readFileSync(SECURITY_CONFIG_PATH, "utf-8");
+    const config = JSON.parse(raw);
+    if (config.mode === "basic" || config.mode === "max" || config.mode === "off") {
+      securityModeCache = config.mode;
+      securityModeCacheTime = now;
+      return config.mode;
+    }
+    securityModeCache = "max";
+    securityModeCacheTime = now;
+    return "max";
+  } catch (err) {
+    debugLog("security", `failed to read security config at ${SECURITY_CONFIG_PATH}`, err);
+    securityModeCache = "max";
+    securityModeCacheTime = now;
+    return "max";
+  }
+}
+var CRITICAL_COMMANDS = /* @__PURE__ */ new Set([
+  // Filesystem destruction (irrecoverable)
+  "mkfs",
+  "dd",
+  "shred",
+  "wipe",
+  "srm",
+  "format",
+  "fdisk",
+  // Privilege escalation (non-sudo)
+  "su",
+  "doas",
+  "pkexec",
+  "gksudo",
+  "kdesu",
+  // Network attack tools
+  "nmap",
+  "nc",
+  "netcat",
+  "telnet",
+  // Remote access
+  "ssh",
+  "scp",
+  "sftp",
+  "rsync",
+  // Process killing
+  "kill",
+  "killall",
+  "pkill",
+  "xkill",
+  // User management
+  "useradd",
+  "userdel",
+  "usermod",
+  "passwd",
+  "adduser",
+  "deluser",
+  // Dangerous shell features
+  "exec",
+  "eval",
+  "source",
+  ".",
+  "alias",
+  // Filesystem control
+  "mount",
+  "umount",
+  "chattr",
+  "lsattr",
+  // Permission modification
+  "chown",
+  "chmod"
+]);
+var EXTENDED_COMMANDS = /* @__PURE__ */ new Set([
+  // File deletion
+  "rm",
+  "rmdir",
+  "del",
+  // Privilege escalation
+  "sudo",
+  // Download tools
+  "wget",
+  "curl",
+  // Package management
+  "apt",
+  "apt-get",
+  "yum",
+  "dnf",
+  "pacman",
+  "pip",
+  "npm",
+  "yarn",
+  "cargo",
+  // System service control
+  "systemctl",
+  "service",
+  // Interactive editors (shell escape risk)
+  "vi",
+  "vim",
+  "nano",
+  "emacs",
+  "less",
+  "more",
+  "man",
+  // Version control
+  "git"
+]);
+var BLOCKED_COMMANDS = /* @__PURE__ */ new Set([
+  ...CRITICAL_COMMANDS,
+  ...EXTENDED_COMMANDS
+]);
+var BLOCKED_URL_ALWAYS = /* @__PURE__ */ new Set([
+  // Cloud metadata endpoints
+  "169.254.169.254",
+  // RFC1918 private ranges
+  "10.",
+  "192.168.",
+  "172.16.",
+  "172.17.",
+  "172.18.",
+  "172.19.",
+  "172.20.",
+  "172.21.",
+  "172.22.",
+  "172.23.",
+  "172.24.",
+  "172.25.",
+  "172.26.",
+  "172.27.",
+  "172.28.",
+  "172.29.",
+  "172.30.",
+  "172.31.",
+  // IPv6-mapped IPv4 cloud metadata (always blocked)
+  "::ffff:169.254.169.254",
+  // Internal service patterns
+  "internal.",
+  "private.",
+  "intranet."
+]);
+var BLOCKED_URL_MAX_ONLY = /* @__PURE__ */ new Set([
+  // Loopback addresses (full 127.0.0.0/8 range)
+  "localhost",
+  "127.",
+  "0.0.0.0",
+  "::1",
+  "::ffff:127.0.0.1",
+  "::ffff:0.0.0.0",
+  // IPv6-mapped IPv4 private ranges (always blocked in max mode)
+  "::ffff:10.",
+  "::ffff:192.168.",
+  "::ffff:172.16.",
+  "::ffff:172.17.",
+  "::ffff:172.18.",
+  "::ffff:172.19.",
+  "::ffff:172.20.",
+  "::ffff:172.21.",
+  "::ffff:172.22.",
+  "::ffff:172.23.",
+  "::ffff:172.24.",
+  "::ffff:172.25.",
+  "::ffff:172.26.",
+  "::ffff:172.27.",
+  "::ffff:172.28.",
+  "::ffff:172.29.",
+  "::ffff:172.30.",
+  "::ffff:172.31.",
+  // Local/internal patterns
+  "local."
+]);
+var BLOCKED_URL_PATTERNS = /* @__PURE__ */ new Set([
+  ...BLOCKED_URL_ALWAYS,
+  ...BLOCKED_URL_MAX_ONLY
+]);
+var AUDIT_DIR = path3.join(os3.homedir(), ".pi", "agent");
+var AUDIT_LOG_PATH = path3.join(AUDIT_DIR, "audit.log");
+var _auditBuffer = [];
+function flushAuditBuffer() {
+  if (_auditBuffer.length === 0) return;
+  try {
+    if (!fs2.existsSync(AUDIT_DIR)) {
+      fs2.mkdirSync(AUDIT_DIR, { recursive: true });
+    }
+    const batch = _auditBuffer.join("");
+    fs2.appendFileSync(AUDIT_LOG_PATH, batch, "utf-8");
+  } catch (err) {
+    debugLog("security", "audit buffer flush failure", err);
+  }
+  _auditBuffer = [];
+}
+process.on("exit", () => {
+  flushAuditBuffer();
+});
+process.on("SIGTERM", () => {
+  flushAuditBuffer();
+});
+
+// extensions/status.ts
 var execAsync = promisify(exec);
 var STATUS_UPDATE_INTERVAL_MS = 5e3;
 var TOOL_TIMER_INTERVAL_MS = 1e3;
-function status_temp_default(pi) {
+function status_default(pi) {
   let lastResponseTime = null;
   let agentStartTime = null;
   let updateInterval = null;
@@ -38,7 +417,7 @@ function status_temp_default(pi) {
   let activeToolStart = 0;
   let blockedCount = 0;
   function getCpuSnapshot() {
-    return os.cpus().map((c) => ({
+    return os4.cpus().map((c) => ({
       user: c.times.user,
       nice: c.times.nice,
       sys: c.times.sys,
@@ -46,7 +425,7 @@ function status_temp_default(pi) {
     }));
   }
   function getCpuUsage() {
-    const cpus = os.cpus();
+    const cpus = os4.cpus();
     const n = cpus.length;
     let totalUsed = 0, totalDelta = 0;
     for (let i = 0; i < n; i++) {
@@ -64,8 +443,8 @@ function status_temp_default(pi) {
     return totalDelta > 0 ? totalUsed / totalDelta * 100 : 0;
   }
   function getMem() {
-    const total = os.totalmem();
-    const used = total - os.freemem();
+    const total = os4.totalmem();
+    const used = total - os4.freemem();
     return { used, total };
   }
   async function getSwap() {
@@ -74,7 +453,7 @@ function status_temp_default(pi) {
       return null;
     }
     try {
-      const out = await fs.promises.readFile("/proc/meminfo", "utf-8");
+      const out = await fs3.promises.readFile("/proc/meminfo", "utf-8");
       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 };
@@ -347,5 +726,5 @@ function status_temp_default(pi) {
   });
 }
 export {
-  status_temp_default as default
+  status_default as default
 };