@plumpslabs/fennec-cli 1.11.0 → 1.11.2

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.2")}
      ${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.2")}`;
 function printBanner() {
   if (process.stdout.isTTY) {
     console.error(FOX);
@@ -42,33 +46,43 @@ 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 Fennec-tracked apps (like PM2)")}
+                     ${pc2.dim("--system, -a")}  Show all system processes
+                     ${pc2.dim("--name")}    Filter by app name
+                     ${pc2.dim("-w, --watch")}  Watch mode ${pc2.dim("(system processes refresh every 3s)")}
+
     ${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 +234,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 +279,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 +488,309 @@ 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) {
+  return [];
+}
+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 +819,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.2")}`);
   } else if (command === "help" || command === "--help" || command === "-h") {
     console.log(pc4.dim("\n  Use 'fennec help' for more information.\n"));
     printBanner();
@@ -555,20 +853,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 +880,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 +892,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 +929,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 +947,166 @@ async function runCommand(args2) {
     process.exit(1);
   }
 }
-async function statusCommand(_args) {
-  const watchFlag = _args.includes("-w") || _args.includes("--watch");
-  if (watchFlag) {
-    await watchStatus();
+async function psCommand(args2) {
+  const watchFlag = args2.includes("-w") || args2.includes("--watch");
+  const systemFlag = args2.includes("--system") || args2.includes("-a") || args2.includes("--all");
+  const nameFilter = args2.includes("--name") ? args2[args2.indexOf("--name") + 1] : void 0;
+  const sortBy = args2.includes("--sort") ? args2[args2.indexOf("--sort") + 1] : "name";
+  if (watchFlag && systemFlag) {
+    await watchSystemProcesses(sortBy, 15);
+    return;
+  }
+  if (systemFlag) {
+    const spinner = createSpinner("Scanning system processes...");
+    try {
+      const processes = getSystemProcesses({
+        name: nameFilter,
+        userOnly: true,
+        sortBy,
+        limit: 30
+      });
+      spinner.stop();
+      process.stdout.write("\r\x1B[K");
+      if (processes.length === 0) {
+        console.error(`
+  ${pc4.dim("No system processes found.")}
+`);
+        return;
+      }
+      const columns2 = [
+        { 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);
+        } }
+      ];
+      const rows2 = processes.map((p) => ({
+        pid: p.pid,
+        name: p.name,
+        cpu: p.cpuPercent,
+        mem: p.memPercent,
+        state: formatProcessState(p.state)
+      }));
+      console.error(`
+  ${symbols.fox} ${pc4.bold("System Processes")} ${pc4.dim(`(top ${processes.length} by ${sortBy})`)}
+`);
+      console.error(renderTable(columns2, rows2));
+      console.error();
+    } catch (error) {
+      spinner.fail("Failed to scan processes");
+      console.error(renderError("Process scan failed", String(error)));
+    }
+    return;
+  }
+  const tracked = readTracked();
+  if (tracked.length === 0) {
+    console.error(`
+  ${pc4.dim("No tracked processes.")}`);
+    console.error(`  ${pc4.dim("Start an app with:")} ${pc4.cyan("fennec start <command> --name <name>")}
+`);
     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 }
+    { key: "name", label: "App", format: (v) => pc4.bold(String(v)) },
+    { key: "pid", label: "PID", align: "right" },
+    { key: "status", label: "Status", format: (v) => {
+      const s = v;
+      if (s === "running") return pc4.green("\u25CF running");
+      return pc4.red("\u25CB stopped");
+    } },
+    { key: "port", label: "Port", format: (v) => {
+      const p = v;
+      return p ? pc4.yellow(`:${p}`) : pc4.dim("-");
+    } },
+    { key: "command", label: "Command", format: (v) => {
+      const c = String(v);
+      return c.length > 50 ? c.slice(0, 50) + "\u2026" : c;
+    } },
+    { key: "uptime", label: "Uptime", format: (v) => pc4.dim(String(v)) }
   ];
+  const rows = tracked.map((t) => {
+    const running = isProcessRunning(t.pid);
+    const uptime = running ? formatUptime(Math.floor((Date.now() - new Date(t.startedAt).getTime()) / 1e3)) : "-";
+    return {
+      name: t.name,
+      pid: running ? String(t.pid) : pc4.dim(String(t.pid)),
+      status: running ? "running" : "stopped",
+      port: t.port ?? null,
+      command: t.command,
+      uptime
+    };
+  });
+  const runningCount = tracked.filter((t) => isProcessRunning(t.pid)).length;
   console.error(`
-  ${symbols.fox} ${pc4.bold("Observed Processes")}
+  ${symbols.fox} ${pc4.bold("Fennec Apps")} ${pc4.dim(`(${runningCount}/${tracked.length} running)`)}
 `);
   console.error(renderTable(columns, rows));
+  console.error(`  ${pc4.dim("Use")} ${pc4.cyan("fennec start <command> --name <name> --port <port>")} ${pc4.dim("to add more apps.")}`);
+  console.error(`  ${pc4.dim("Use")} ${pc4.cyan("fennec log <name>")} ${pc4.dim("to view logs.")}`);
+  console.error(`  ${pc4.dim("Use")} ${pc4.cyan("fennec kill <name>")} ${pc4.dim("to stop an app.")}`);
   console.error();
 }
-async function watchStatus() {
+function formatUptime(seconds) {
+  if (seconds < 60) return `${seconds}s`;
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+  const h = Math.floor(seconds / 3600);
+  const m = Math.floor(seconds % 3600 / 60);
+  if (h >= 24) {
+    const d = Math.floor(h / 24);
+    return `${d}d ${h % 24}h ${m}m`;
+  }
+  return `${h}h ${m}m`;
+}
+async function watchSystemProcesses(sortBy, limit) {
   console.error(`
-  ${pc4.bold("Watching status")} ${pc4.dim("(Ctrl+C to stop)")}
+  ${pc4.bold("Watching system 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" }
-    ];
-    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" }
+      { 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" }
     ];
-    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 +1114,284 @@ 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");
+async function statusCommand(_args) {
+  const watchFlag = _args.includes("-w") || _args.includes("--watch");
+  const tracked = readTracked();
+  const topSystem = getSystemProcesses({ userOnly: true, sortBy: "cpu", limit: 5 });
+  const totalUserProcs = getSystemProcesses({ userOnly: true }).length;
   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) {
-    console.error(`
-  ${pc4.dim("Following... (Ctrl+C to stop)")}
+  ${symbols.fox} ${pc4.bold("Fennec Status")}
+`);
+  if (tracked.length > 0) {
+    const runningCount = tracked.filter((t) => isProcessRunning(t.pid)).length;
+    console.error(`  ${pc4.bold("Managed Apps")} ${pc4.dim(`(${runningCount}/${tracked.length} running)`)}
+`);
+    for (const t of tracked) {
+      const running = isProcessRunning(t.pid);
+      const statusIcon = running ? pc4.green("\u25CF") : pc4.red("\u25CB");
+      const portStr = t.port ? ` ${pc4.yellow(`:${t.port}`)}` : "";
+      const uptime = running ? pc4.dim(formatUptime(Math.floor((Date.now() - new Date(t.startedAt).getTime()) / 1e3))) : pc4.red("stopped");
+      console.error(`  ${statusIcon} ${pc4.bold(t.name)}${portStr} ${pc4.dim(`(PID ${t.pid})`)} \u2014 ${uptime}`);
+    }
+    console.error();
+  } else {
+    console.error(`  ${pc4.dim("No managed apps.")} ${pc4.cyan("fennec start <command> --name <name>")}
 `);
-    await new Promise(() => {
-    });
+  }
+  console.error(`  ${pc4.bold("System")} ${pc4.dim(`(${totalUserProcs} user processes)`)}`);
+  for (const p of topSystem) {
+    const cpuStr = p.cpuPercent > 10 ? pc4.red(`${p.cpuPercent}%`) : p.cpuPercent > 5 ? pc4.yellow(`${p.cpuPercent}%`) : pc4.dim(`${p.cpuPercent}%`);
+    const memStr = p.memPercent > 10 ? pc4.red(`${p.memPercent}%`) : p.memPercent > 5 ? pc4.yellow(`${p.memPercent}%`) : pc4.dim(`${p.memPercent}%`);
+    console.error(`  ${pc4.dim(`PID ${p.pid}`)} ${pc4.bold(p.name)} \u2014 CPU: ${cpuStr} MEM: ${memStr}`);
+  }
+  if (watchFlag) {
+    await watchSystemProcesses("cpu", 15);
   }
   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 +1489,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 +1507,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