@vtstech/pi-diag 1.2.2 → 1.2.3

package/diag.js

@@ -1,34 +1,607 @@
-// .build-npm/diag/diag.temp.ts
+// extensions/diag.ts
+import * as fs4 from "node:fs";
+import * as os4 from "node:os";
+import * as path4 from "node:path";
+
+// shared/format.ts
+function section(title) {
+  return `
+\u2500\u2500 ${title} ${"\u2500".repeat(Math.max(1, 60 - title.length - 4))}`;
+}
+function ok(msg) {
+  return `  \u2705 ${msg}`;
+}
+function fail(msg) {
+  return `  \u274C ${msg}`;
+}
+function warn(msg) {
+  return `  \u26A0\uFE0F  ${msg}`;
+}
+function info(msg) {
+  return `  \u2139\uFE0F  ${msg}`;
+}
+function bytesHuman(bytes) {
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  let i = 0;
+  let b = bytes;
+  while (b >= 1024 && i < units.length - 1) {
+    b /= 1024;
+    i++;
+  }
+  return `${b.toFixed(1)}${units[i]}`;
+}
+function msHuman(ms) {
+  if (ms < 1e3) return `${ms.toFixed(0)}ms`;
+  if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+  return `${(ms / 6e4).toFixed(1)}m`;
+}
+function pct(used, total) {
+  if (total === 0) return "0.0%";
+  return `${(used / total * 100).toFixed(1)}%`;
+}
+
+// shared/ollama.ts
 import * as fs from "node:fs";
-import * as os from "node:os";
 import * as path from "node:path";
-import {
-  section,
-  ok,
-  fail,
-  warn,
-  info,
-  bytesHuman,
-  msHuman,
-  pct
-} from "@vtstech/pi-shared/format";
-import { MODELS_JSON_PATH, getOllamaBaseUrl, BUILTIN_PROVIDERS, readModelsJson, EXTENSION_VERSION, isLocalProvider } from "@vtstech/pi-shared/ollama";
-import {
-  BLOCKED_COMMANDS,
-  BLOCKED_URL_PATTERNS,
-  CRITICAL_COMMANDS,
-  EXTENDED_COMMANDS,
-  BLOCKED_URL_ALWAYS,
-  BLOCKED_URL_MAX_ONLY,
-  getSecurityMode,
-  validatePath,
-  isSafeUrl,
-  sanitizeCommand,
-  readRecentAuditEntries,
-  AUDIT_LOG_PATH
-} from "@vtstech/pi-shared/security";
-import { readSettings } from "@vtstech/pi-shared/config-io";
-import { debugLog } from "@vtstech/pi-shared/debug";
+import os from "node:os";
+
+// 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 EXTENSION_VERSION = "1.2.3";
+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 BUILTIN_PROVIDERS = {
+  openrouter: { api: "openai-completions", baseUrl: "https://openrouter.ai/api/v1", envKey: "OPENROUTER_API_KEY" },
+  anthropic: { api: "anthropic-messages", baseUrl: "https://api.anthropic.com/v1", envKey: "ANTHROPIC_API_KEY" },
+  google: { api: "gemini", baseUrl: "https://generativelanguage.googleapis.com", envKey: "GOOGLE_API_KEY" },
+  openai: { api: "openai-completions", baseUrl: "https://api.openai.com/v1", envKey: "OPENAI_API_KEY" },
+  groq: { api: "openai-completions", baseUrl: "https://api.groq.com/v1", envKey: "GROQ_API_KEY" },
+  deepseek: { api: "openai-completions", baseUrl: "https://api.deepseek.com/v1", envKey: "DEEPSEEK_API_KEY" },
+  mistral: { api: "openai-completions", baseUrl: "https://api.mistral.ai/v1", envKey: "MISTRAL_API_KEY" },
+  xai: { api: "openai-completions", baseUrl: "https://api.x.ai/v1", envKey: "XAI_API_KEY" },
+  together: { api: "openai-completions", baseUrl: "https://api.together.xyz/v1", envKey: "TOGETHER_API_KEY" },
+  fireworks: { api: "openai-completions", baseUrl: "https://api.fireworks.ai/inference/v1", envKey: "FIREWORKS_API_KEY" },
+  cohere: { api: "cohere-chat", baseUrl: "https://api.cohere.com/v1", envKey: "COHERE_API_KEY" },
+  zai: { api: "openai-completions", baseUrl: "https://open.bigmodel.cn/api/paas/v4", envKey: "ZAI_API_KEY" }
+};
+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/security.ts
+import * as fs3 from "node:fs";
+import * as path3 from "node:path";
+import os3 from "node:os";
+
+// shared/config-io.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import os2 from "os";
+var PI_AGENT_DIR = path2.join(os2.homedir(), ".pi", "agent");
+function readJsonConfig(filePath, defaultValue = {}) {
+  try {
+    if (fs2.existsSync(filePath)) {
+      return JSON.parse(fs2.readFileSync(filePath, "utf-8"));
+    }
+  } catch (err) {
+    debugLog("config-io", `failed to read config: ${filePath}`, err);
+  }
+  return defaultValue;
+}
+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");
+function readSettings() {
+  return readJsonConfig(SETTINGS_PATH);
+}
+
+// shared/security.ts
+var SETTINGS_PATH2 = SETTINGS_PATH;
+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 (!fs3.existsSync(SECURITY_CONFIG_PATH)) {
+      securityModeCache = "max";
+      securityModeCacheTime = now;
+      return "max";
+    }
+    const raw = fs3.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 CRITICAL_SYSTEM_DIRS = [
+  "/etc",
+  "/root",
+  "/var",
+  "/usr",
+  "/bin",
+  "/sbin",
+  "/boot",
+  "/dev",
+  "/proc",
+  "/sys"
+];
+function validatePath(filePath, allowedDirs) {
+  if (!filePath) return { valid: false, error: "Path cannot be empty" };
+  if (filePath.startsWith("\\\\")) {
+    return { valid: false, error: "UNC paths not allowed" };
+  }
+  if (filePath.includes("../") || filePath.includes("..\\")) {
+    return { valid: false, error: "Path traversal detected: parent directory access not allowed" };
+  }
+  let resolved;
+  try {
+    resolved = path3.resolve(filePath);
+    try {
+      resolved = fs3.realpathSync(resolved);
+    } catch {
+    }
+  } catch {
+    return { valid: false, error: "Invalid path format" };
+  }
+  for (const critical of CRITICAL_SYSTEM_DIRS) {
+    if (resolved.startsWith(critical + "/") || resolved === critical) {
+      return { valid: false, error: `Access to system directory denied: ${critical}` };
+    }
+  }
+  const sensitivePaths = [
+    "/etc/shadow",
+    "/etc/passwd",
+    "/.ssh/",
+    "/.gnupg/",
+    path3.join(os3.homedir(), ".ssh"),
+    path3.join(os3.homedir(), ".gnupg"),
+    SETTINGS_PATH2,
+    SECURITY_CONFIG_PATH
+    // NOTE: models.json is intentionally excluded from sensitivePaths.
+    // Extensions use readModelsJson()/writeModelsJson() from shared/ollama.ts
+    // for direct file I/O — not via Pi's tool system — so blocking it here
+    // would prevent legitimate model configuration updates.
+  ];
+  for (const sensitive of sensitivePaths) {
+    if (resolved.startsWith(sensitive) || resolved === sensitive) {
+      return { valid: false, error: `Access to sensitive path denied: ${sensitive}` };
+    }
+  }
+  const cwd = process.cwd();
+  const safePrefixes = ["/home", "/tmp", cwd];
+  for (const prefix of safePrefixes) {
+    if (resolved.startsWith(prefix + "/") || resolved === prefix) return { valid: true, error: "" };
+  }
+  if (allowedDirs) {
+    for (const dir of allowedDirs) {
+      try {
+        const absDir = path3.resolve(dir);
+        if (resolved.startsWith(absDir)) return { valid: true, error: "" };
+      } catch {
+      }
+    }
+  }
+  return { valid: false, error: `Path not in allowed directories: ${filePath}` };
+}
+function isSafeUrl(url, blockSsrf = true, mode = "max") {
+  if (!url) return { safe: false, error: "URL cannot be empty" };
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return { safe: false, error: `Invalid URL format: ${msg}` };
+  }
+  const scheme = parsed.protocol.replace(":", "").toLowerCase();
+  if (scheme !== "http" && scheme !== "https") {
+    return { safe: false, error: `URL scheme not allowed: ${parsed.protocol}` };
+  }
+  if (!parsed.hostname) {
+    return { safe: false, error: "URL must have a hostname" };
+  }
+  const hostname = parsed.hostname.toLowerCase();
+  const normalized = hostname.replace(/\.$/, "");
+  if (/[^\x00-\x7F]/.test(normalized)) {
+    return { safe: false, error: "URL hostname contains non-ASCII characters" };
+  }
+  if (/^0x[0-9a-f]+$/i.test(normalized) || /^0[0-7]+$/i.test(normalized)) {
+    return { safe: false, error: "URL hostname uses non-decimal IP format" };
+  }
+  if (blockSsrf) {
+    if (mode === "off") {
+      return { safe: true, error: "" };
+    }
+    for (const pattern of BLOCKED_URL_ALWAYS) {
+      if (normalized === pattern || normalized.endsWith("." + pattern) || normalized.startsWith(pattern)) {
+        if (/^\d|^::/.test(pattern)) {
+          const nextChar = normalized[pattern.length];
+          if (nextChar && nextChar !== "/" && nextChar !== ":" && !/\d/.test(nextChar)) {
+            continue;
+          }
+        }
+        return { safe: false, error: `SSRF protection: blocked hostname pattern '${pattern}'` };
+      }
+    }
+    if (mode === "max") {
+      for (const pattern of BLOCKED_URL_MAX_ONLY) {
+        if (normalized === pattern || normalized.endsWith("." + pattern) || normalized.startsWith(pattern)) {
+          if (/^\d|^::/.test(pattern)) {
+            const nextChar = normalized[pattern.length];
+            if (nextChar && nextChar !== "/" && nextChar !== ":" && !/\d/.test(nextChar)) {
+              continue;
+            }
+          }
+          return { safe: false, error: `SSRF protection: blocked hostname pattern '${pattern}' (max mode)` };
+        }
+      }
+    }
+  }
+  return { safe: true, error: "" };
+}
+var INJECTION_PATTERNS = [
+  // Semicolon chaining to dangerous commands — mode-independent.
+  // Unlike && (conditional), ; ALWAYS runs the second command.
+  /;\s*(rm|sudo|chmod|chown|mkfs|dd|shred|kill|pkill)\b/i,
+  // Command substitution (backticks) — still dangerous
+  /`[^`]+`/,
+  // Command substitution ($()) — still dangerous
+  /\$\([^)]+\)/,
+  // Variable expansion targeting sensitive env vars
+  /\$\{?(?:HOME|USER|PATH|SHELL|PWD|SSH|GPG|API_KEY|TOKEN|SECRET|PASSWORD)\}?/i
+];
+function checkSingleCommand(command, mode) {
+  const trimmed = command.trim();
+  if (!trimmed) return { isSafe: true, error: "", command: "" };
+  const parts = trimmed.split(/\s+/);
+  let baseCmd = parts[0].toLowerCase();
+  if (baseCmd.includes("/")) baseCmd = baseCmd.split("/").pop();
+  if (baseCmd.includes("\\")) baseCmd = baseCmd.split("\\").pop();
+  for (const raw of parts) {
+    let word = raw.toLowerCase();
+    if (word.includes("/")) word = word.split("/").pop();
+    if (word.includes("\\")) word = word.split("\\").pop();
+    if (CRITICAL_COMMANDS.has(word)) {
+      return { isSafe: false, error: `Blocked command: ${word} (critical)`, command: "" };
+    }
+  }
+  if (mode === "max" && EXTENDED_COMMANDS.has(baseCmd)) {
+    return { isSafe: false, error: `Blocked command: ${baseCmd} (max mode)`, command: "" };
+  }
+  for (const pattern of INJECTION_PATTERNS) {
+    if (pattern.test(trimmed)) {
+      return { isSafe: false, error: `Potential injection pattern detected in: ${trimmed}`, command: "" };
+    }
+  }
+  return { isSafe: true, error: "", command: trimmed };
+}
+function sanitizeCommand(command) {
+  if (!command) return { isSafe: false, error: "Command cannot be empty", command: "" };
+  let normalizedCmd = command.normalize("NFKC");
+  normalizedCmd = normalizedCmd.replace(/[\u0000-\u001f\u007f-\u009f\u200b-\u200f\u2028-\u202e\ufeff\u2060-\u2069]/g, "");
+  const strippedForCompare = command.replace(/[\u0000-\u001f\u007f-\u009f\u200b-\u200f\u2028-\u202e\ufeff\u2060-\u2069]/g, "").normalize("NFKC");
+  if (normalizedCmd !== strippedForCompare) {
+    return { isSafe: false, error: `Command rejected: Unicode normalization variance detected (possible homoglyph bypass)`, command: "" };
+  }
+  command = normalizedCmd;
+  const trimmed = command.trim();
+  if (!trimmed) return { isSafe: false, error: "Command cannot be empty", command: "" };
+  const newlineStripped = command.replace(/\n/g, " ").replace(/\r/g, " ");
+  if (newlineStripped !== command) {
+    return { isSafe: false, error: "Newline characters detected: potential command injection", command: "" };
+  }
+  for (const pattern of INJECTION_PATTERNS) {
+    if (pattern.test(trimmed)) {
+      return { isSafe: false, error: `Potential injection pattern detected`, command: "" };
+    }
+  }
+  const subCommands = [];
+  let remaining = trimmed;
+  const chainRegex = /&&|\|\||(?<!\|)\|(?!\|)/g;
+  let match;
+  let lastIndex = 0;
+  while ((match = chainRegex.exec(remaining)) !== null) {
+    subCommands.push(remaining.slice(lastIndex, match.index));
+    lastIndex = match.index + match[0].length;
+  }
+  subCommands.push(remaining.slice(lastIndex));
+  const mode = getSecurityMode();
+  for (const subCmd of subCommands) {
+    const result = checkSingleCommand(subCmd, mode);
+    if (!result.isSafe) {
+      return { isSafe: false, error: result.error, command: "" };
+    }
+  }
+  return { isSafe: true, error: "", command };
+}
+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 (!fs3.existsSync(AUDIT_DIR)) {
+      fs3.mkdirSync(AUDIT_DIR, { recursive: true });
+    }
+    const batch = _auditBuffer.join("");
+    fs3.appendFileSync(AUDIT_LOG_PATH, batch, "utf-8");
+  } catch (err) {
+    debugLog("security", "audit buffer flush failure", err);
+  }
+  _auditBuffer = [];
+}
+function readRecentAuditEntries(count = 50) {
+  try {
+    if (!fs3.existsSync(AUDIT_LOG_PATH)) return [];
+    const fileSize = fs3.statSync(AUDIT_LOG_PATH).size;
+    if (fileSize === 0) return [];
+    const fd = fs3.openSync(AUDIT_LOG_PATH, "r");
+    const bufferSize = 8192;
+    const buffer = Buffer.alloc(bufferSize);
+    const lines = [];
+    let pos = fileSize;
+    let partial = "";
+    while (pos > 0 && lines.length < count) {
+      const readSize = Math.min(bufferSize, pos);
+      pos -= readSize;
+      fs3.readSync(fd, buffer, 0, readSize, pos);
+      const chunk = buffer.slice(0, readSize).toString("utf-8");
+      partial = chunk + partial;
+      const lineBreak = partial.lastIndexOf("\n");
+      if (lineBreak !== -1) {
+        const complete = partial.slice(lineBreak + 1);
+        if (complete.trim()) lines.unshift(complete);
+        partial = partial.slice(0, lineBreak);
+      }
+    }
+    fs3.closeSync(fd);
+    if (partial.trim() && lines.length < count) {
+      lines.unshift(partial);
+    }
+    const recent = lines.slice(-count);
+    return recent.map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return {};
+      }
+    });
+  } catch (err) {
+    debugLog("security", "failed to read audit log", err);
+    return [];
+  }
+}
+process.on("exit", () => {
+  flushAuditBuffer();
+});
+process.on("SIGTERM", () => {
+  flushAuditBuffer();
+});
+
+// extensions/diag.ts
 var SECRET_KEY_PATTERNS = [
   /key/i,
   /token/i,
@@ -45,7 +618,7 @@ function redactValue(key, value) {
   if (value.length > 20 && !value.includes(" ") && /^[A-Za-z0-9_\-+/=]+$/.test(value)) return value.slice(0, 8) + "...";
   return value;
 }
-function diag_temp_default(pi) {
+function diag_default(pi) {
   let cachedSystemPrompt = null;
   let cachedPayload = null;
   pi.on("before_provider_request", (event) => {
@@ -79,15 +652,15 @@ function diag_temp_default(pi) {
       }
     };
     lines.push(section("SYSTEM"));
-    const cpus2 = os.cpus();
-    const totalMem = os.totalmem();
-    const freeMem = os.freemem();
+    const cpus2 = os4.cpus();
+    const totalMem = os4.totalmem();
+    const freeMem = os4.freemem();
     const usedMem = totalMem - freeMem;
     const memPct = pct(usedMem, totalMem);
-    lines.push(info(`OS: ${os.type()} ${os.release()} ${os.arch()}`));
+    lines.push(info(`OS: ${os4.type()} ${os4.release()} ${os4.arch()}`));
     lines.push(info(`CPU: ${cpus2.length}x ${cpus2[0]?.model || "unknown"}`));
     lines.push(info(`RAM: ${bytesHuman(usedMem)} / ${bytesHuman(totalMem)} (${memPct})`));
-    lines.push(info(`Uptime: ${msHuman(os.uptime() * 1e3)}`));
+    lines.push(info(`Uptime: ${msHuman(os4.uptime() * 1e3)}`));
     lines.push(info(`Node.js: ${process.version}`));
     check(
       totalMem >= 4 * 1024 * 1024 * 1024,
@@ -212,7 +785,7 @@ function diag_temp_default(pi) {
       }
     }
     lines.push(section("MODELS.JSON"));
-    const agentDir = path.join(os.homedir(), ".pi", "agent");
+    const agentDir = path4.join(os4.homedir(), ".pi", "agent");
     let configuredModels = [];
     const modelsJson = readModelsJson();
     if (modelsJson && Object.keys(modelsJson.providers || {}).length > 0) {
@@ -273,12 +846,12 @@ function diag_temp_default(pi) {
       lines.push(fail(`settings.json read error: ${e.message}`));
     }
     lines.push(section("EXTENSIONS"));
-    const extensionsDir = path.join(agentDir, "extensions");
+    const extensionsDir = path4.join(agentDir, "extensions");
     const activeTools = pi.getActiveTools();
     const allTools = pi.getAllTools();
     const builtinTools = /* @__PURE__ */ new Set(["read", "bash", "edit", "write"]);
     const extensionToolCount = activeTools.filter((t) => !builtinTools.has(t)).length;
-    const localExtFiles = fs.existsSync(extensionsDir) ? fs.readdirSync(extensionsDir).filter((f) => f.endsWith(".ts") || f.endsWith(".js")) : [];
+    const localExtFiles = fs4.existsSync(extensionsDir) ? fs4.readdirSync(extensionsDir).filter((f) => f.endsWith(".ts") || f.endsWith(".js")) : [];
     lines.push(info(`Extension files in ${extensionsDir}: ${localExtFiles.length}`));
     localExtFiles.forEach((f) => lines.push(info(`  \u2022 ${f}`)));
     if (localExtFiles.length > 0) {
@@ -295,15 +868,15 @@ function diag_temp_default(pi) {
     }
     lines.push(info(`Registered tools (all): ${allTools.length}`));
     lines.push(section("THEMES"));
-    const themesDir = path.join(agentDir, "themes");
-    if (fs.existsSync(themesDir)) {
-      const themeFiles = fs.readdirSync(themesDir).filter(
+    const themesDir = path4.join(agentDir, "themes");
+    if (fs4.existsSync(themesDir)) {
+      const themeFiles = fs4.readdirSync(themesDir).filter(
         (f) => f.endsWith(".json")
       );
       lines.push(info(`Theme files: ${themeFiles.length}`));
       themeFiles.forEach((f) => {
         try {
-          const theme = JSON.parse(fs.readFileSync(path.join(themesDir, f), "utf-8"));
+          const theme = JSON.parse(fs4.readFileSync(path4.join(themesDir, f), "utf-8"));
           lines.push(info(`  \u2022 ${f} (name: "${theme.name || "unnamed"}")`));
         } catch {
           lines.push(warn(`  \u2022 ${f} \u2014 INVALID JSON`));
@@ -402,7 +975,7 @@ function diag_temp_default(pi) {
     }
     lines.push(info("Audit log status:"));
     const auditEntries = readRecentAuditEntries(50);
-    if (fs.existsSync(AUDIT_LOG_PATH)) {
+    if (fs4.existsSync(AUDIT_LOG_PATH)) {
       lines.push(ok(`Audit log exists: ${AUDIT_LOG_PATH}`));
       if (auditEntries.length > 0) {
         lines.push(info(`  Recent entries: ${auditEntries.length} (last 50)`));
@@ -577,5 +1150,5 @@ function diag_temp_default(pi) {
   });
 }
 export {
-  diag_temp_default as default
+  diag_default as default
 };

package/package.json

@@ -1,9 +1,14 @@
 {
   "name": "@vtstech/pi-diag",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "description": "Diagnostics extension for Pi Coding Agent",
   "main": "diag.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": ["./diag.js"]
+    "extensions": [
+      "./diag.js"
+    ]
   }
 }