@plumpslabs/fennec-cli 1.11.0 → 1.11.1

package/dist/index.js

@@ -1,26 +1,30 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { existsSync as existsSync2, writeFileSync } from "fs";
-import { resolve as resolve2 } from "path";
-import { execSync } from "child_process";
+import { existsSync as existsSync3, writeFileSync, readFileSync as readFileSync2, mkdirSync } from "fs";
+import { resolve as resolve2, dirname } from "path";
+import { homedir } from "os";
+import { execSync as execSync2 } from "child_process";
 import { FennecServer, SessionStore, ProcessManager } from "@plumpslabs/fennec-core";
 import pc4 from "picocolors";
 
 // src/utils/banner.ts
 import pc from "picocolors";
 function hexColor(color) {
-  return pc.hex(color);
+  if (typeof pc.hex === "function") {
+    return pc.hex(color);
+  }
+  return (s) => s;
 }
 var fennecOrange = hexColor("#FF6432");
 var fennecYellow = hexColor("#FFB347");
 var FOX = `
       ${fennecOrange("/\\\\   /\\\\")}
-     ${fennecOrange("(")} ${fennecYellow("o o")} ${fennecOrange(")       ") + pc.bold("Fennec")} ${pc.dim("v1.10.0")}
+     ${fennecOrange("(")} ${fennecYellow("o o")} ${fennecOrange(")       ") + pc.bold("Fennec")} ${pc.dim("v1.11.1")}
      ${fennecOrange("=(")} ${fennecYellow(" Y ")} ${fennecOrange(")=")}       ${pc.dim("ears everywhere in your stack.")}
        ${fennecOrange(")   (")}
 `;
-var FOX_COMPACT = `${pc.redBright("  \u{1F98A}")} ${pc.bold("Fennec")} ${pc.dim("v1.10.0")}`;
+var FOX_COMPACT = `${pc.redBright("  \u{1F98A}")} ${pc.bold("Fennec")} ${pc.dim("v1.11.1")}`;
 function printBanner() {
   if (process.stdout.isTTY) {
     console.error(FOX);
@@ -42,33 +46,46 @@ function showHelp() {
   ${pc2.bold("Server")}
   ${sep}
 
-    ${pc2.cyan("start")}            ${pc2.dim("Start the MCP server (default)")}
+    ${pc2.cyan("start")}            ${pc2.dim("Start Fennec MCP server (default)")}
                      ${pc2.dim("--config")}    Path to config file
                      ${pc2.dim("--transport")} Transport type ${pc2.dim("(stdio | sse) [default: stdio]")}
-                     ${pc2.dim("--port")}      SSE port ${pc2.dim("[default: 3333]")}
                      ${pc2.dim("--api-port")}  Management API port ${pc2.dim("[default: 3456]")}
 
+    ${pc2.cyan("start")} ${pc2.dim("<command>")}         ${pc2.dim("Start an app under Fennec observation (new!)")}
+                     ${pc2.dim("--name")}    App name ${pc2.dim("(required for tracking)")}
+                     ${pc2.dim("--port")}    Port the app listens on ${pc2.dim("(optional)")}
+                     ${pc2.dim("--cwd")}     Working directory
+                     ${pc2.dim("--restart")}  Auto-restart on crash
+
   ${sep}
   ${pc2.bold("Process Management")}
   ${sep}
 
+    ${pc2.cyan("ps")} ${pc2.dim("[options]")}          ${pc2.dim("List real system processes")}
+                     ${pc2.dim("--name")}    Filter by process name
+                     ${pc2.dim("--port")}    Filter by port
+                     ${pc2.dim("--sort")}    Sort by ${pc2.dim("(cpu | mem | pid | name) [default: cpu]")}
+                     ${pc2.dim("-n")}        Max results ${pc2.dim("[default: 30]")}
+                     ${pc2.dim("-w, --watch")}  Watch mode ${pc2.dim("(refresh every 3s)")}
+                     ${pc2.dim("-a, --all")}   Show all processes ${pc2.dim("(not just user)")}
+
     ${pc2.cyan("run")} ${pc2.dim("<command>")}        ${pc2.dim("Run a command under Fennec observation")}
                      ${pc2.dim("--name")}    Process name ${pc2.dim("(required)")}
                      ${pc2.dim("--cwd")}     Working directory
                      ${pc2.dim("--restart")}  Auto-restart on crash
 
-    ${pc2.cyan("status")} ${pc2.dim("[name]")}        ${pc2.dim("Show observed processes")}
-                     ${pc2.dim("-w, --watch")}  Watch mode ${pc2.dim("(refresh every 2s)")}
+    ${pc2.cyan("status")} ${pc2.dim("[name]")}        ${pc2.dim("Show system overview & top processes")}
+                     ${pc2.dim("-w, --watch")}  Watch mode ${pc2.dim("(refresh every 3s)")}
 
-    ${pc2.cyan("log")} ${pc2.dim("<name>")}           ${pc2.dim("Show logs for a process")}
-                     ${pc2.dim("--lines")}   Number of lines ${pc2.dim("[default: 50]")}
-                     ${pc2.dim("--level")}   Filter by level ${pc2.dim("(error | warn | info)")}
-                     ${pc2.dim("-f, --follow")}  Follow mode ${pc2.dim("(tail -f)")}
+    ${pc2.cyan("log")} ${pc2.dim("<pid|name>")}       ${pc2.dim("Show logs for a process")}
+                     ${pc2.dim("--lines")}   Number of lines ${pc2.dim("[default: 30]")}
+                     ${pc2.dim("-f, --follow")}  Follow mode ${pc2.dim("(journalctl --follow)")}
 
-    ${pc2.cyan("kill")} ${pc2.dim("<name>")}           ${pc2.dim("Stop a process")}
+    ${pc2.cyan("kill")} ${pc2.dim("<pid|name|all>")}  ${pc2.dim("Kill process(es) by PID, name, or all")}
                      ${pc2.dim("--signal")}  Signal to send ${pc2.dim("[default: SIGTERM]")}
+                     ${pc2.dim("--all")}     Kill all user processes
 
-    ${pc2.cyan("restart")} ${pc2.dim("<name>")}        ${pc2.dim("Restart a process")}
+    ${pc2.cyan("restart")} ${pc2.dim("<pid|name>")}   ${pc2.dim("Kill + show re-run command")}
 
   ${sep}
   ${pc2.bold("Observation")}
@@ -220,7 +237,10 @@ async function watchCommand(args2) {
 import { createInterface } from "readline";
 import pc3 from "picocolors";
 function hex(color) {
-  return pc3.hex(color);
+  if (typeof pc3.hex === "function") {
+    return pc3.hex(color);
+  }
+  return (s) => s;
 }
 var fennecOrange3 = hex("#FF6432");
 var blueAccent = hex("#4A90D9");
@@ -262,20 +282,6 @@ var symbols = {
   fox: "\u{1F98A}",
   ears: "\u23DC"
 };
-function statusBadge(status) {
-  switch (status) {
-    case "running":
-      return pc3.green("\u25CF running");
-    case "stopped":
-      return pc3.dim("\u25CB stopped");
-    case "error":
-      return pc3.red("\u2717 error");
-    case "starting":
-      return pc3.yellow("\u25CC starting");
-    case "unknown":
-      return pc3.dim("? unknown");
-  }
-}
 function logLevel(label) {
   const upper = label.toUpperCase().padEnd(5);
   switch (label.toLowerCase()) {
@@ -485,14 +491,347 @@ function renderSuccess(message) {
   return `  ${pc3.green("\u2713")} ${message}`;
 }
 
+// src/utils/system-process.ts
+import { readdirSync, readFileSync, existsSync as existsSync2 } from "fs";
+import { execSync } from "child_process";
+import { cpus } from "os";
+function readProcProcesses() {
+  const processes = [];
+  const currentUid = process.getuid?.();
+  const totalMemKb = readTotalMem();
+  try {
+    const pids = readdirSync("/proc").filter((d) => /^\d+$/.test(d));
+    for (const pidStr of pids) {
+      try {
+        const pid = parseInt(pidStr, 10);
+        const proc = readSingleProcProcess(pid, currentUid, totalMemKb);
+        if (proc) processes.push(proc);
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+    return [];
+  }
+  return processes;
+}
+function readSingleProcProcess(pid, currentUid, totalMemKb) {
+  const statPath = `/proc/${pid}/stat`;
+  const statusPath = `/proc/${pid}/status`;
+  const cmdlinePath = `/proc/${pid}/cmdline`;
+  if (!existsSync2(statPath)) return null;
+  const statusText = readSafe(statusPath);
+  if (!statusText) return null;
+  const nameMatch = statusText.match(/Name:\s+(.+)/);
+  const uidMatch = statusText.match(/Uid:\s+(\d+)/);
+  const vmRssMatch = statusText.match(/VmRSS:\s+(\d+)/);
+  const stateMatch = statusText.match(/State:\s+(\S)/);
+  const name = nameMatch?.[1] ?? `pid_${pid}`;
+  const uid = uidMatch ? parseInt(uidMatch[1], 10) : void 0;
+  const vmRss = vmRssMatch ? parseInt(vmRssMatch[1], 10) : 0;
+  const state = stateMatch?.[1] ?? "?";
+  const isUserProcess = uid !== void 0 && currentUid !== void 0 && uid === currentUid;
+  const statText = readSafe(statPath);
+  let cpuPercent = 0;
+  let startedAt = null;
+  if (statText) {
+    const parenEnd = statText.lastIndexOf(")");
+    if (parenEnd > 0) {
+      const fields = statText.slice(parenEnd + 2).split(/\s+/);
+      const utime = parseInt(fields[11] ?? "0", 10);
+      const stime = parseInt(fields[12] ?? "0", 10);
+      const starttime = parseInt(fields[19] ?? "0", 10);
+      const hertz = 100;
+      const uptimeSeconds = readUptime();
+      const totalJiffies = utime + stime;
+      if (uptimeSeconds > 0) {
+        const elapsedJiffies = uptimeSeconds * hertz;
+        const processJiffies = totalJiffies;
+        cpuPercent = Math.min(100, processJiffies / Math.max(1, elapsedJiffies) * 100 * cpus().length);
+      }
+      startedAt = formatStartTime(starttime, uptimeSeconds, hertz);
+    }
+  }
+  const cmdlineRaw = readSafe(cmdlinePath);
+  const command2 = cmdlineRaw ? cmdlineRaw.split("\0").filter(Boolean).join(" ") : name;
+  const ports = detectListeningPorts(pid);
+  const memPercent = totalMemKb > 0 ? vmRss / totalMemKb * 100 : 0;
+  return {
+    pid,
+    name,
+    command: command2.length > 200 ? command2.slice(0, 200) + "\u2026" : command2,
+    cpuPercent: Math.round(cpuPercent * 10) / 10,
+    memPercent: Math.round(memPercent * 10) / 10,
+    memRss: vmRss,
+    state,
+    startedAt,
+    ports,
+    isUserProcess
+  };
+}
+function runPsProcesses() {
+  try {
+    const output = execSync(
+      "ps axo pid,comm,pcpu,pmem,rss,state,etime,user --sort=-pcpu 2>/dev/null | head -200",
+      { encoding: "utf-8", timeout: 5e3 }
+    );
+    const lines = output.trim().split("\n").slice(1);
+    const currentUser = execSync("whoami", { encoding: "utf-8", timeout: 1e3 }).trim();
+    return lines.map((line) => {
+      const parts = line.trim().split(/\s+/);
+      const pid = parseInt(parts[0] ?? "0", 10);
+      const name = parts[1] ?? "";
+      const cpu = parseFloat(parts[2] ?? "0");
+      const mem = parseFloat(parts[3] ?? "0");
+      const rss = parseInt(parts[4] ?? "0", 10);
+      const state = parts[5] ?? "?";
+      const elapsed = parts[6] ?? "";
+      const user = parts[7] ?? "";
+      const command2 = parts.slice(1).join(" ");
+      return {
+        pid,
+        name,
+        command: command2.length > 200 ? command2.slice(0, 200) + "\u2026" : command2,
+        cpuPercent: Math.round(cpu * 10) / 10,
+        memPercent: Math.round(mem * 10) / 10,
+        memRss: rss,
+        state: mapBsdState(state),
+        startedAt: elapsed || null,
+        ports: [],
+        isUserProcess: user === currentUser
+      };
+    });
+  } catch {
+    return [];
+  }
+}
+function mapBsdState(s) {
+  switch (s) {
+    case "R":
+      return "R";
+    case "S":
+      return "S";
+    case "Z":
+      return "Z";
+    case "T":
+      return "T";
+    case "I":
+      return "S";
+    default:
+      return s;
+  }
+}
+function detectListeningPorts(pid) {
+  try {
+    const tcpFile = `/proc/${pid}/net/tcp`;
+    const tcp6File = `/proc/${pid}/net/tcp6`;
+    const ports = [];
+    for (const f of [tcpFile, tcp6File]) {
+      try {
+        const data = readSafe(f);
+        if (data) {
+          for (const port of parseProcNetTcp(data)) {
+            if (!ports.includes(port)) ports.push(port);
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+    return ports.sort((a, b) => a - b);
+  } catch {
+    return [];
+  }
+}
+function parseProcNetTcp(data) {
+  const ports = [];
+  const lines = data.split("\n").slice(1);
+  for (const line of lines) {
+    const parts = line.trim().split(/\s+/);
+    if (parts.length < 3) continue;
+    const localAddr = parts[1] ?? "";
+    const state = parts[3] ?? "";
+    if (state !== "0A") continue;
+    const portMatch = localAddr.match(/:([0-9a-fA-F]+)$/);
+    if (portMatch) {
+      const port = parseInt(portMatch[1], 16);
+      if (port > 0 && port <= 65535) {
+        ports.push(port);
+      }
+    }
+  }
+  return ports;
+}
+function readSafe(path) {
+  try {
+    return readFileSync(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function readTotalMem() {
+  try {
+    const memInfo = readSafe("/proc/meminfo");
+    if (memInfo) {
+      const match = memInfo.match(/MemTotal:\s+(\d+)/);
+      if (match) return parseInt(match[1], 10);
+    }
+  } catch {
+  }
+  return 16e6;
+}
+function readUptime() {
+  try {
+    const data = readSafe("/proc/uptime");
+    if (data) {
+      return parseFloat(data.split(/\s+/)[0] ?? "0");
+    }
+  } catch {
+  }
+  return 0;
+}
+function formatStartTime(starttime, uptimeSeconds, hertz) {
+  try {
+    const bootTime = Date.now() / 1e3 - uptimeSeconds;
+    const processStart = bootTime + starttime / hertz;
+    return new Date(processStart * 1e3).toISOString();
+  } catch {
+    return null;
+  }
+}
+function getSystemProcesses(filter) {
+  let processes;
+  if (existsSync2("/proc")) {
+    processes = readProcProcesses();
+  } else {
+    processes = runPsProcesses();
+  }
+  if (filter) {
+    if (filter.userOnly) {
+      processes = processes.filter((p) => p.isUserProcess);
+    }
+    if (filter.name) {
+      const nameLower = filter.name.toLowerCase();
+      processes = processes.filter(
+        (p) => p.name.toLowerCase().includes(nameLower) || p.command.toLowerCase().includes(nameLower)
+      );
+    }
+    if (filter.pid) {
+      processes = processes.filter((p) => p.pid === filter.pid);
+    }
+    if (filter.port) {
+      processes = processes.filter((p) => p.ports.includes(filter.port));
+    }
+    if (filter.sortBy) {
+      processes.sort((a, b) => {
+        switch (filter.sortBy) {
+          case "cpu":
+            return b.cpuPercent - a.cpuPercent;
+          case "mem":
+            return b.memPercent - a.memPercent;
+          case "pid":
+            return a.pid - b.pid;
+          case "name":
+            return a.name.localeCompare(b.name);
+          default:
+            return b.cpuPercent - a.cpuPercent;
+        }
+      });
+    }
+    if (filter.limit && filter.limit > 0) {
+      processes = processes.slice(0, filter.limit);
+    }
+  }
+  return processes;
+}
+function killProcess(pid, signal = "SIGTERM") {
+  try {
+    process.kill(pid, signal);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function formatProcessState(state) {
+  switch (state) {
+    case "R":
+      return "Running";
+    case "S":
+      return "Sleeping";
+    case "D":
+      return "Disk Sleep";
+    case "Z":
+      return "Zombie";
+    case "T":
+      return "Stopped";
+    case "t":
+      return "Tracing";
+    case "X":
+      return "Dead";
+    case "I":
+      return "Idle";
+    default:
+      return state;
+  }
+}
+
 // src/index.ts
 var [, , command, ...args] = process.argv;
+function getTrackedPath() {
+  const dir = process.env.FENNEC_DATA_DIR ? resolve2(process.env.FENNEC_DATA_DIR) : resolve2(homedir(), ".fennec");
+  return resolve2(dir, "tracked.json");
+}
+function readTracked() {
+  try {
+    const path = getTrackedPath();
+    if (!existsSync3(path)) return [];
+    return JSON.parse(readFileSync2(path, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function saveTracked(processes) {
+  try {
+    const path = getTrackedPath();
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(processes, null, 2), "utf-8");
+  } catch {
+  }
+}
+function addTracked(proc) {
+  const tracked = readTracked();
+  const filtered = tracked.filter((t) => t.name !== proc.name);
+  filtered.push(proc);
+  saveTracked(filtered);
+}
+function removeTracked(name) {
+  const tracked = readTracked();
+  saveTracked(tracked.filter((t) => t.name !== name));
+}
+function removeTrackedByPid(pid) {
+  const tracked = readTracked();
+  saveTracked(tracked.filter((t) => t.pid !== pid));
+}
 async function main() {
   if (!command || command === "start") {
-    await startServer(args);
+    if (args.length === 0 || args[0]?.startsWith("--")) {
+      await startServer(args);
+    } else {
+      await startCommand(args);
+    }
   } else if (command === "run") {
     await runCommand(args);
-  } else if (command === "status" || command === "ps") {
+  } else if (command === "ps") {
+    await psCommand(args);
+  } else if (command === "status") {
     await statusCommand(args);
   } else if (command === "log") {
     await logCommand(args);
@@ -521,7 +860,7 @@ async function main() {
     printBanner();
     await initCommand();
   } else if (command === "version" || command === "--version" || command === "-v") {
-    console.log(`  ${symbols.fox} ${pc4.bold("Fennec")} ${pc4.dim("v1.11.0")}`);
+    console.log(`  ${symbols.fox} ${pc4.bold("Fennec")} ${pc4.dim("v1.11.1")}`);
   } else if (command === "help" || command === "--help" || command === "-h") {
     console.log(pc4.dim("\n  Use 'fennec help' for more information.\n"));
     printBanner();
@@ -555,20 +894,26 @@ async function startServer(args2) {
     process.exit(1);
   }
 }
+async function startCommand(args2) {
+  printBanner();
+  console.error(`  ${pc4.dim("Starting app...")}
+`);
+  await runCommand(args2);
+}
 async function runCommand(args2) {
   const nameIndex = args2.indexOf("--name");
   const name = nameIndex !== -1 ? args2[nameIndex + 1] : void 0;
+  const portIndex = args2.indexOf("--port");
+  const port = portIndex !== -1 ? parseInt(args2[portIndex + 1], 10) : void 0;
   const cwdIndex = args2.indexOf("--cwd");
   const cwd = cwdIndex !== -1 ? args2[cwdIndex + 1] : void 0;
   const restartFlag = args2.includes("--restart");
-  const cmdEnd = Math.min(
-    nameIndex !== -1 ? nameIndex : Infinity,
-    cwdIndex !== -1 ? cwdIndex : Infinity
-  );
+  const stopFlags = [nameIndex, portIndex, cwdIndex].filter((i) => i !== -1);
+  const cmdEnd = Math.min(...stopFlags, Infinity);
   const cmdParts = args2.slice(0, cmdEnd);
   const cmd = cmdParts.join(" ");
   if (!cmd) {
-    console.error(renderError("Missing command", "Usage: fennec run <command> --name <name>"));
+    console.error(renderError("Missing command", "Usage: fennec start|run <command> --name <name> [--port <port>] [--cwd <dir>] [--restart]"));
     process.exit(1);
   }
   const appName = name ?? cmdParts[0] ?? "app";
@@ -576,6 +921,7 @@ async function runCommand(args2) {
   ${symbols.fox} ${pc4.bold("Running")} ${renderAppName(appName)}
 `);
   console.error(`  ${renderKV("Command", cmd)}`);
+  if (port) console.error(`  ${renderKV("Port", String(port))}`);
   if (cwd) console.error(`  ${renderKV("Directory", cwd)}`);
   console.error(`  ${renderKV("Restart", restartFlag ? "on crash" : "off")}`);
   console.error(`  ${divider()}`);
@@ -587,8 +933,16 @@ async function runCommand(args2) {
   const pm = new ProcessManager(config);
   try {
     const proc = pm.spawn(cmdParts[0], cmdParts.slice(1), cwd, void 0, appName);
+    addTracked({
+      name: appName,
+      pid: proc.pid,
+      command: cmd,
+      port,
+      cwd,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
     console.error(`
-  ${pc4.green("\u25CF")} ${pc4.bold(appName)} ${pc4.dim(`started (PID: ${proc.pid})`)}
+  ${pc4.green("\u25CF")} ${pc4.bold(appName)} ${pc4.dim(`started (PID: ${proc.pid})`)}${port ? pc4.dim(` :${port}`) : ""}
 `);
     const stdout = proc.child.stdout;
     const stderr = proc.child.stderr;
@@ -616,6 +970,7 @@ async function runCommand(args2) {
       });
     }
     proc.child.on("exit", (code, signal) => {
+      removeTracked(appName);
       if (restartFlag && code !== 0) {
         console.error(`
   ${pc4.yellow("\u26A0")} ${appName} ${pc4.dim(`exited (${code}), restarting...`)}`);
@@ -633,55 +988,139 @@ async function runCommand(args2) {
     process.exit(1);
   }
 }
-async function statusCommand(_args) {
-  const watchFlag = _args.includes("-w") || _args.includes("--watch");
+async function psCommand(args2) {
+  const watchFlag = args2.includes("-w") || args2.includes("--watch");
+  const nameFilter = args2.includes("--name") ? args2[args2.indexOf("--name") + 1] : void 0;
+  const portFilter = args2.includes("--port") ? parseInt(args2[args2.indexOf("--port") + 1], 10) : void 0;
+  const sortBy = args2.includes("--sort") ? args2[args2.indexOf("--sort") + 1] : args2.includes("-m") ? "mem" : args2.includes("-c") ? "cpu" : "cpu";
+  const limit = args2.includes("-n") ? parseInt(args2[args2.indexOf("-n") + 1], 10) : 30;
+  const allFlag = args2.includes("-a") || args2.includes("--all");
   if (watchFlag) {
-    await watchStatus();
+    await watchProcesses(sortBy, limit);
     return;
   }
-  const columns = [
-    { key: "name", label: "Name", format: (v) => pc4.bold(String(v)) },
-    { key: "source", label: "Source" },
-    { key: "status", label: "Status", format: (v) => statusBadge(v) },
-    { key: "pid", label: "PID" },
-    { key: "uptime", label: "Uptime" },
-    { key: "error", label: "Last Error", format: (v) => v ? pc4.red(String(v)) : pc4.dim("-") }
-  ];
-  const rows = [
-    { name: "backend", source: ":3000", status: "running", pid: "12345", uptime: "2h 15m", error: null },
-    { name: "frontend", source: ":5173", status: "running", pid: "12346", uptime: "2h 15m", error: null },
-    { name: "database", source: ":5432", status: "running", pid: "docker", uptime: "5h 30m", error: null }
-  ];
-  console.error(`
-  ${symbols.fox} ${pc4.bold("Observed Processes")}
+  const spinner = createSpinner("Scanning system processes...");
+  try {
+    const processes = getSystemProcesses({
+      name: nameFilter,
+      port: portFilter,
+      userOnly: !allFlag,
+      sortBy,
+      limit
+    });
+    spinner.stop();
+    process.stdout.write("\r\x1B[K");
+    if (processes.length === 0) {
+      console.error(`
+  ${pc4.dim("No processes found.")}
 `);
-  console.error(renderTable(columns, rows));
-  console.error();
+      return;
+    }
+    const columns = [
+      { key: "pid", label: "PID", align: "right", format: (v) => pc4.dim(String(v).padStart(6)) },
+      { key: "name", label: "Name", format: (v) => pc4.bold(String(v)) },
+      { key: "cpu", label: "CPU%", align: "right", format: (v) => {
+        const num = v;
+        return num > 10 ? pc4.red(String(num)) : num > 5 ? pc4.yellow(String(num)) : pc4.dim(String(num));
+      } },
+      { key: "mem", label: "MEM%", align: "right", format: (v) => {
+        const num = v;
+        return num > 10 ? pc4.red(String(num)) : num > 5 ? pc4.yellow(String(num)) : pc4.dim(String(num));
+      } },
+      { key: "state", label: "State", format: (v) => {
+        const s = String(v);
+        if (s === "R" || s === "Running") return pc4.green(s);
+        if (s === "Z" || s === "Zombie") return pc4.red(s);
+        if (s === "S" || s === "Sleeping") return pc4.cyan(s);
+        return pc4.dim(s);
+      } },
+      { key: "ports", label: "Ports", format: (v) => {
+        const ports = v;
+        return ports.length > 0 ? ports.map((p) => pc4.yellow(`:${p}`)).join(", ") : pc4.dim("-");
+      } }
+    ];
+    const rows = processes.map((p) => ({
+      pid: p.pid,
+      name: p.name,
+      cpu: p.cpuPercent,
+      mem: p.memPercent,
+      state: formatProcessState(p.state),
+      ports: p.ports
+    }));
+    const tracked = readTracked();
+    const managedPids = new Set(tracked.map((t) => t.pid));
+    const managedRows = processes.map((p) => {
+      const isManaged = managedPids.has(p.pid);
+      const trackedInfo = tracked.find((t) => t.pid === p.pid);
+      return {
+        ...{
+          pid: p.pid,
+          name: p.name,
+          cpu: p.cpuPercent,
+          mem: p.memPercent,
+          state: formatProcessState(p.state),
+          ports: p.ports
+        },
+        _managed: isManaged,
+        _trackedPort: trackedInfo?.port
+      };
+    });
+    if (tracked.length > 0) {
+      console.error(`  ${pc4.green("\u25CF")} ${pc4.bold("Managed:")} ${tracked.map((t) => {
+        const running = isProcessRunning(t.pid);
+        const status = running ? pc4.green("running") : pc4.red("stopped");
+        const portStr = t.port ? ` ${pc4.yellow(`:${t.port}`)}` : "";
+        return `${pc4.bold(t.name)}${portStr} (${status})`;
+      }).join(", ")}
+`);
+    }
+    console.error(`  ${symbols.fox} ${pc4.bold("System Processes")} ${pc4.dim(`(${processes.length} shown, sorted by ${sortBy})`)}
+`);
+    console.error(renderTable(columns, managedRows));
+    console.error();
+  } catch (error) {
+    spinner.fail("Failed to scan processes");
+    console.error(renderError("Process scan failed", String(error)));
+  }
 }
-async function watchStatus() {
+async function watchProcesses(sortBy, limit) {
   console.error(`
-  ${pc4.bold("Watching status")} ${pc4.dim("(Ctrl+C to stop)")}
+  ${pc4.bold("Watching processes")} ${pc4.dim("(Ctrl+C to stop, refreshes every 3s)")}
 `);
   const render = () => {
+    const processes = getSystemProcesses({
+      userOnly: true,
+      sortBy,
+      limit
+    });
     const columns = [
+      { key: "pid", label: "PID", align: "right", format: (v) => pc4.dim(String(v).padStart(6)) },
       { key: "name", label: "Name", format: (v) => pc4.bold(String(v)) },
-      { key: "status", label: "Status", format: (v) => statusBadge(v) },
-      { key: "pid", label: "PID" },
-      { key: "uptime", label: "Uptime" },
-      { key: "cpu", label: "CPU" },
-      { key: "mem", label: "Memory" }
+      { key: "cpu", label: "CPU%", align: "right", format: (v) => {
+        const num = v;
+        return num > 10 ? pc4.red(String(num)) : num > 5 ? pc4.yellow(String(num)) : pc4.dim(String(num));
+      } },
+      { key: "mem", label: "MEM%", align: "right", format: (v) => {
+        const num = v;
+        return num > 10 ? pc4.red(String(num)) : num > 5 ? pc4.yellow(String(num)) : pc4.dim(String(num));
+      } },
+      { key: "state", label: "S", align: "center" }
     ];
-    const rows = [
-      { name: "backend", status: "running", pid: "12345", uptime: "2h 15m", cpu: "1.2%", mem: "128MB" },
-      { name: "frontend", status: "running", pid: "12346", uptime: "2h 15m", cpu: "0.8%", mem: "64MB" }
-    ];
-    return renderTable(columns, rows, { compact: true });
+    const rows = processes.map((p) => ({
+      pid: p.pid,
+      name: p.name,
+      cpu: p.cpuPercent,
+      mem: p.memPercent,
+      state: p.state
+    }));
+    return `  ${timestamp()} ${pc4.dim(`${processes.length} processes`)}
+${renderTable(columns, rows, { compact: true })}`;
   };
   console.error(render());
   const interval = setInterval(() => {
-    process.stdout.write("\x1B[6A");
+    process.stdout.write("\x1B[J");
     console.error(render());
-  }, 2e3);
+  }, 3e3);
   process.on("SIGINT", () => {
     clearInterval(interval);
     process.exit(0);
@@ -689,72 +1128,305 @@ async function watchStatus() {
   await new Promise(() => {
   });
 }
-async function logCommand(args2) {
-  const name = args2[0];
-  if (!name) {
-    console.error(renderError("Missing process name", "Usage: fennec log <name> [options]"));
-    process.exit(1);
-  }
-  const linesIndex = args2.indexOf("--lines");
-  const lines = linesIndex !== -1 ? parseInt(args2[linesIndex + 1], 10) : 50;
-  const levelIndex = args2.indexOf("--level");
-  const level = levelIndex !== -1 ? args2[levelIndex + 1] : void 0;
-  const followFlag = args2.includes("-f") || args2.includes("--follow");
-  console.error(`
-  ${symbols.fox} ${pc4.bold("Logs")} ${renderAppName(name)} ${pc4.dim(`(last ${lines} lines)`)}
-`);
-  const mockLogs = [
-    { time: "12:00:00", level: "INFO", msg: "Server started on port 3000" },
-    { time: "12:00:01", level: "INFO", msg: "Database connected" },
-    { time: "12:00:02", level: "WARN", msg: "Deprecation: use express@5" },
-    { time: "12:00:05", level: "ERROR", msg: "POST /api/login \u2192 500" },
-    { time: "12:00:06", level: "ERROR", msg: "JWT_SECRET not set in environment" }
-  ];
-  for (const log of mockLogs) {
-    const time = pc4.dim(`[${log.time}]`);
-    const lvl = logLevel(log.level);
-    const msg = log.level === "ERROR" ? pc4.red(log.msg) : log.level === "WARN" ? pc4.yellow(log.msg) : log.msg;
-    console.error(`  ${time} ${lvl} ${msg}`);
-  }
-  if (followFlag) {
+async function statusCommand(_args) {
+  const watchFlag = _args.includes("-w") || _args.includes("--watch");
+  const spinner = createSpinner("Gathering system status...");
+  try {
+    const topProcesses = getSystemProcesses({ userOnly: true, sortBy: "cpu", limit: 10 });
+    const totalProcesses = getSystemProcesses({ userOnly: true }).length;
+    const services = [
+      { name: "node", label: "Node.js" },
+      { name: "npm", label: "npm" },
+      { name: "pnpm", label: "pnpm" },
+      { name: "vite", label: "Vite" },
+      { name: "next", label: "Next.js" },
+      { name: "webpack", label: "Webpack" },
+      { name: "tsc", label: "TypeScript" },
+      { name: "docker", label: "Docker" },
+      { name: "mysqld", label: "MySQL" },
+      { name: "postgres", label: "PostgreSQL" },
+      { name: "redis", label: "Redis" },
+      { name: "ollama", label: "Ollama" }
+    ];
+    spinner.stop();
+    process.stdout.write("\r\x1B[K");
     console.error(`
-  ${pc4.dim("Following... (Ctrl+C to stop)")}
+  ${symbols.fox} ${pc4.bold("Fennec System Overview")}
 `);
-    await new Promise(() => {
-    });
+    console.error(`  ${renderKV("User Processes", pc4.bold(String(totalProcesses)))}`);
+    console.error(`  ${renderKV("Fennec Version", pc4.dim("v1.11.1"))}`);
+    const activeServices = services.filter((s) => topProcesses.some((p) => p.name.toLowerCase().includes(s.name))).slice(0, 5);
+    if (activeServices.length > 0) {
+      console.error(`  ${renderKV("Detected", activeServices.map((s) => pc4.green(s.label)).join(", "))}`);
+    }
+    console.error();
+    const columns = [
+      { key: "pid", label: "PID", align: "right", format: (v) => pc4.dim(String(v).padStart(6)) },
+      { key: "name", label: "Process", format: (v) => pc4.bold(String(v)) },
+      { key: "cpu", label: "CPU%", align: "right" },
+      { key: "mem", label: "MEM%", align: "right" }
+    ];
+    const rows = topProcesses.map((p) => ({
+      pid: p.pid,
+      name: p.name,
+      cpu: p.cpuPercent,
+      mem: p.memPercent
+    }));
+    console.error(`  ${pc4.bold("Top CPU Processes")}
+`);
+    console.error(renderTable(columns, rows));
+    if (watchFlag) {
+      await watchProcesses("cpu", 15);
+    }
+    console.error();
+  } catch (error) {
+    spinner.fail("Failed to gather system status");
+    console.error(renderError("Status check failed", String(error)));
   }
-  console.error();
 }
 async function killCommand(args2) {
-  const name = args2[0];
-  if (!name) {
-    console.error(renderError("Missing process name", "Usage: fennec kill <name>"));
-    process.exit(1);
-  }
+  const rawTarget = args2[0];
   const signalIndex = args2.indexOf("--signal");
   const signalRaw = signalIndex !== -1 ? args2[signalIndex + 1] : "SIGTERM";
   const signal = signalRaw ?? "SIGTERM";
+  if (rawTarget === "all" || args2.includes("--all") || args2.includes("-a")) {
+    const userProcs = getSystemProcesses({ userOnly: true, sortBy: "cpu", limit: 200 });
+    if (userProcs.length === 0) {
+      console.error(`  ${pc4.dim("No user processes to kill.")}`);
+      return;
+    }
+    console.error(`
+  ${pc4.bold(`Kill ${userProcs.length} user processes?`)}`);
+    console.error(`  ${pc4.dim("This will stop ALL your running processes.")}`);
+    console.error(`  ${pc4.yellow("\u26A0 System processes will not be affected.")}
+`);
+    const confirmed2 = await confirmPrompt(
+      `${pc4.red("Are you sure?")} ${pc4.dim("This cannot be undone")}`,
+      false
+    );
+    if (!confirmed2) {
+      console.error(`  ${pc4.dim("Cancelled.")}`);
+      return;
+    }
+    const spinner2 = createSpinner(`Killing ${userProcs.length} processes...`);
+    let killed = 0;
+    let failed = 0;
+    for (const proc of userProcs) {
+      if (killProcess(proc.pid, signal)) {
+        killed++;
+        removeTrackedByPid(proc.pid);
+      } else {
+        failed++;
+      }
+      if (killed % 10 === 0) await new Promise((r) => setTimeout(r, 50));
+    }
+    await new Promise((r) => setTimeout(r, 500));
+    if (killed > 0) {
+      spinner2.succeed(`${killed} process(es) killed`);
+    } else {
+      spinner2.fail(`Failed to kill processes`);
+    }
+    if (failed > 0) {
+      console.error(`  ${pc4.yellow(`${failed} process(es) could not be killed`)} ${pc4.dim("(try with sudo)")}`);
+    }
+    return;
+  }
+  if (!rawTarget) {
+    console.error(renderError("Missing target", "Usage: fennec kill <pid|name|all> [--signal SIGTERM|SIGKILL|SIGINT]"));
+    process.exit(1);
+  }
+  let targetPid;
+  let displayName;
+  const pid = parseInt(rawTarget, 10);
+  if (!isNaN(pid) && String(pid) === rawTarget) {
+    if (!isProcessRunning(pid)) {
+      console.error(renderError("Process not found", `No process with PID ${pid} is running`));
+      process.exit(1);
+    }
+    targetPid = pid;
+    displayName = `PID ${pid}`;
+  } else {
+    const matches = getSystemProcesses({ name: rawTarget, userOnly: true, sortBy: "cpu" });
+    if (matches.length === 0) {
+      console.error(renderError("Process not found", `No running process matching "${rawTarget}"`));
+      process.exit(1);
+    }
+    if (matches.length > 1) {
+      console.error(`
+  ${pc4.bold(`Multiple processes match "${rawTarget}":`)}`);
+      const selected = await selectPrompt(
+        `Select which to kill:`,
+        matches.map((p, i) => ({
+          value: String(i),
+          label: `${p.name} (PID ${p.pid})`,
+          description: `${p.command.slice(0, 80)} \u2014 CPU: ${p.cpuPercent}% MEM: ${p.memPercent}%`
+        }))
+      );
+      if (selected === null) {
+        console.error(`  ${pc4.dim("Cancelled")}`);
+        return;
+      }
+      const idx = parseInt(selected, 10);
+      targetPid = matches[idx].pid;
+      displayName = `${matches[idx].name} (PID ${targetPid})`;
+    } else {
+      targetPid = matches[0].pid;
+      displayName = `${matches[0].name} (PID ${targetPid})`;
+    }
+  }
   const confirmed = await confirmPrompt(
-    `Stop ${pc4.bold(name)} with ${pc4.yellow(signal)}?`,
+    `Kill ${pc4.bold(displayName)} with ${pc4.yellow(signal)}?`,
     false
   );
   if (!confirmed) {
     console.error(`  ${pc4.dim("Cancelled")}`);
     return;
   }
-  console.error(`
-  ${pc4.green("\u2713")} ${renderAppName(name)} ${pc4.dim(`stopped (${signal})`)}
-`);
+  const spinner = createSpinner(`Sending ${signal} to ${displayName}...`);
+  const success = killProcess(targetPid, signal);
+  if (success) {
+    await new Promise((r) => setTimeout(r, 200));
+    const stillRunning = isProcessRunning(targetPid);
+    if (stillRunning && signal !== "SIGKILL") {
+      spinner.warn(`${displayName} did not respond to ${signal}`);
+      const forceKill = await confirmPrompt(
+        `Send ${pc4.red("SIGKILL")} to force stop?`,
+        true
+      );
+      if (forceKill) {
+        const forceSpinner = createSpinner(`Sending SIGKILL to ${displayName}...`);
+        killProcess(targetPid, "SIGKILL");
+        await new Promise((r) => setTimeout(r, 300));
+        if (!isProcessRunning(targetPid)) {
+          forceSpinner.succeed(`${displayName} force stopped`);
+        } else {
+          forceSpinner.fail(`${displayName} could not be stopped (permission denied?)`);
+        }
+      } else {
+        console.error(`  ${pc4.dim("Retrying with SIGTERM...")}`);
+        killProcess(targetPid, "SIGTERM");
+        console.error(`  ${pc4.yellow("\u26A0")} ${displayName} ${pc4.dim("may still be running")}`);
+      }
+    } else {
+      removeTrackedByPid(targetPid);
+      spinner.succeed(`${displayName} stopped`);
+    }
+  } else {
+    spinner.fail(`Failed to kill ${displayName}`);
+    console.error(renderError("Permission denied", `Try running with sudo or use a different signal.`));
+  }
 }
 async function restartCommand(args2) {
   const name = args2[0];
   if (!name) {
-    console.error(renderError("Missing process name", "Usage: fennec restart <name>"));
+    console.error(renderError("Missing process name/pid", "Usage: fennec restart <pid|name>"));
     process.exit(1);
   }
-  const spinner = createSpinner(`Restarting ${name}...`);
-  await new Promise((resolve3) => setTimeout(resolve3, 1e3));
-  spinner.succeed(`${name} restarted`);
+  let targetPid;
+  const pid = parseInt(name, 10);
+  if (!isNaN(pid) && String(pid) === name) {
+    targetPid = pid;
+  } else {
+    const processes = getSystemProcesses({ name, userOnly: true, limit: 1 });
+    if (processes.length === 0) {
+      console.error(renderError("Process not found", `No process matching "${name}"`));
+      process.exit(1);
+    }
+    targetPid = processes[0].pid;
+  }
+  const confirmed = await confirmPrompt(
+    `Restart ${pc4.bold(`${name} (PID ${targetPid})`)}?`,
+    false
+  );
+  if (!confirmed) {
+    console.error(`  ${pc4.dim("Cancelled")}`);
+    return;
+  }
+  const spinner = createSpinner(`Stopping PID ${targetPid}...`);
+  const killed = killProcess(targetPid, "SIGTERM");
+  if (!killed) {
+    spinner.fail(`Failed to stop PID ${targetPid}`);
+    return;
+  }
+  await new Promise((r) => setTimeout(r, 1e3));
+  const stillRunning = isProcessRunning(targetPid);
+  if (stillRunning) {
+    spinner.warn(`Process didn't stop, sending SIGKILL...`);
+    killProcess(targetPid, "SIGKILL");
+    await new Promise((r) => setTimeout(r, 500));
+  }
+  const procInfo = getSystemProcesses({ pid: targetPid, limit: 1 })[0];
+  let suggestion = "";
+  if (procInfo) {
+    suggestion = `
+  ${pc4.dim("Re-run:")} ${renderCommand(procInfo.command)}`;
+  }
+  spinner.succeed(`${name} stopped${suggestion}`);
+}
+async function logCommand(args2) {
+  const target = args2[0];
+  if (!target) {
+    console.error(renderError("Missing process name/pid", "Usage: fennec log <pid|name> [--lines N] [--level LEVEL] [-f]"));
+    process.exit(1);
+  }
+  const linesIndex = args2.indexOf("--lines");
+  const lines = linesIndex !== -1 ? parseInt(args2[linesIndex + 1], 10) : 30;
+  const followFlag = args2.includes("-f") || args2.includes("--follow");
+  let targetPid;
+  let displayName;
+  const pid = parseInt(target, 10);
+  if (!isNaN(pid) && String(pid) === target) {
+    targetPid = pid;
+    displayName = `PID ${pid}`;
+  } else {
+    const processes = getSystemProcesses({ name: target, userOnly: true, limit: 1 });
+    if (processes.length === 0) {
+      console.error(renderError("Process not found", `No process matching "${target}"`));
+      process.exit(1);
+    }
+    targetPid = processes[0].pid;
+    displayName = `${processes[0].name} (PID ${targetPid})`;
+  }
+  const spinner = createSpinner(`Fetching logs for ${displayName}...`);
+  try {
+    let logLines = [];
+    try {
+      const { execSync: execSync3 } = await import("child_process");
+      const output = execSync3(
+        `journalctl --no-pager -n ${lines} _PID=${targetPid} 2>/dev/null || tail -n ${lines} /proc/${targetPid}/fd/1 2>/dev/null || echo "No logs available"`,
+        { encoding: "utf-8", timeout: 3e3 }
+      );
+      logLines = output.trim().split("\n").filter(Boolean);
+    } catch {
+      logLines = [`  ${pc4.dim("(no log access \u2014 process may not be managed by Fennec)")}`];
+    }
+    spinner.stop();
+    process.stdout.write("\r\x1B[K");
+    console.error(`
+  ${symbols.fox} ${pc4.bold("Logs")} ${renderAppName(displayName)} ${pc4.dim(`(last ${lines} lines)`)}
+`);
+    for (const line of logLines.slice(-lines)) {
+      const display = line.length > 200 ? line.slice(0, 200) + "\u2026" : line;
+      if (line.toLowerCase().includes("error") || line.toLowerCase().includes("fail")) {
+        console.error(`  ${pc4.red(display)}`);
+      } else if (line.toLowerCase().includes("warn")) {
+        console.error(`  ${pc4.yellow(display)}`);
+      } else {
+        console.error(`  ${display}`);
+      }
+    }
+    if (followFlag) {
+      console.error(`
+  ${pc4.dim("Following... (Ctrl+C to stop)")}
+`);
+      await new Promise(() => {
+      });
+    }
+    console.error();
+  } catch (error) {
+    spinner.fail(`Failed to fetch logs for ${displayName}`);
+    console.error(renderError("Log fetch failed", String(error)));
+  }
 }
 async function attachCommand(args2) {
   const port = parseInt(args2[0], 10);
@@ -852,7 +1524,7 @@ async function installBrowsersCommand() {
 `);
   const spinner = createSpinner("Installing Chromium...");
   try {
-    execSync("npx playwright install chromium", {
+    execSync2("npx playwright install chromium", {
       stdio: "pipe",
       timeout: 12e4
     });
@@ -870,7 +1542,7 @@ async function initCommand() {
   ${pc4.bold("Initialize Fennec Configuration")}
 `);
   const configFile = resolve2("./fennec.config.yaml");
-  if (existsSync2(configFile)) {
+  if (existsSync3(configFile)) {
     const overwrite = await confirmPrompt(
       `${pc4.yellow("fennec.config.yaml")} already exists. Overwrite?`,
       false