@plumpslabs/fennec-cli 1.10.0 → 1.11.1

package/dist/index.js

@@ -1,54 +1,128 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { existsSync as existsSync2, writeFileSync } from "fs";
-import { resolve as resolve2 } from "path";
-import { createInterface } from "readline";
-import { execSync } from "child_process";
-import { FennecServer, SessionStore } from "@plumpslabs/fennec-core";
+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) {
+  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.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.11.1")}`;
 function printBanner() {
-  console.error(`
-  /\\   /\\
- (  o o  )    fennec v1.9.0
- =( Y )=      ears everywhere in your stack.
-   )   (
-  `);
+  if (process.stdout.isTTY) {
+    console.error(FOX);
+  } else {
+    console.error(FOX_COMPACT);
+  }
 }
 
 // src/utils/help.ts
+import pc2 from "picocolors";
+var fennecOrange2 = hexColor("#FF6432");
 function showHelp() {
+  const sep = fennecOrange2("\u2500".repeat(50));
   console.error(`
-Usage: fennec <command> [options]
 
-Commands:
-  start              Start the MCP server (default)
-    --transport      Transport type (stdio | sse) [default: stdio]
-    --port           SSE port [default: 3333]
-    --config         Path to config file
+  ${pc2.bold("Usage:")} fennec ${pc2.dim("<command>")} ${pc2.dim("[options]")}
+
+  ${sep}
+  ${pc2.bold("Server")}
+  ${sep}
+
+    ${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("--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 system overview & top processes")}
+                     ${pc2.dim("-w, --watch")}  Watch mode ${pc2.dim("(refresh every 3s)")}
+
+    ${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("<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("<pid|name>")}   ${pc2.dim("Kill + show re-run command")}
+
+  ${sep}
+  ${pc2.bold("Observation")}
+  ${sep}
+
+    ${pc2.cyan("attach")} ${pc2.dim("<port>")}         ${pc2.dim("Observe a process by port")}
+                     ${pc2.dim("--name")}    Process name
 
-  pipe               Pipe stdin to log watcher
-    --name           Watcher name (required)
+    ${pc2.cyan("pipe")}             ${pc2.dim("Pipe stdin to log watcher")}
+                     ${pc2.dim("--name")}    Watcher name ${pc2.dim("(required)")}
 
-  attach-pid         Attach to a running process by PID
-    <pid>            Process ID (required)
-    --name           Name for the process
+    ${pc2.cyan("watch")}            ${pc2.dim("Watch a log file")}
+                     ${pc2.dim("--file")}    File path ${pc2.dim("(required)")}
+                     ${pc2.dim("--name")}    Watcher name
 
-  attach-port        Attach to a process by port
-    <port>           Port number (required)
-    --name           Name for the process
+    ${pc2.cyan("attach-pid")} ${pc2.dim("<pid>")}      ${pc2.dim("Attach to process by PID")}
+    ${pc2.cyan("attach-port")} ${pc2.dim("<port>")}    ${pc2.dim("Attach to process by port")}
 
-  watch              Watch a log file
-    --file           File path (required)
-    --name           Watcher name
+  ${sep}
+  ${pc2.bold("Configuration")}
+  ${sep}
 
-  sessions           List saved auth sessions
-  setup              Configure MCP client (Claude Desktop)
-  install-browsers   Install Playwright browser engines
-  init               Generate fennec.config.yaml
+    ${pc2.cyan("init")}             ${pc2.dim("Generate fennec.config.yaml")}
+    ${pc2.cyan("setup")}            ${pc2.dim("Configure MCP client")}
+    ${pc2.cyan("install-browsers")} ${pc2.dim("Install Playwright browser engines")}
+    ${pc2.cyan("sessions")}         ${pc2.dim("List saved auth sessions")}
 
-  help               Show this help message
+  ${sep}
+  ${pc2.bold("Other")}
+  ${sep}
+
+    ${pc2.cyan("help")}             ${pc2.dim("Show this help message")}
+    ${pc2.cyan("version")}          ${pc2.dim("Show version")}
+
+  ${pc2.dim("\u2500".repeat(50))}
+
+  ${pc2.dim("Learn more:")} ${pc2.cyan("https://github.com/plumpslabs/fennec")}
   `);
 }
 
@@ -159,62 +233,614 @@ async function watchCommand(args2) {
   process.stdin.resume();
 }
 
-// src/index.ts
-var [, , command, ...args] = process.argv;
-function rlQuestion(query) {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve3) => {
-    rl.question(query, (answer) => {
-      rl.close();
-      resolve3(answer.trim());
+// src/utils/format.ts
+import { createInterface } from "readline";
+import pc3 from "picocolors";
+function hex(color) {
+  if (typeof pc3.hex === "function") {
+    return pc3.hex(color);
+  }
+  return (s) => s;
+}
+var fennecOrange3 = hex("#FF6432");
+var blueAccent = hex("#4A90D9");
+var redAccent = hex("#E94560");
+var colors = {
+  // Brand colors
+  primary: fennecOrange3,
+  secondary: blueAccent,
+  accent: redAccent,
+  // Semantic colors
+  success: pc3.green,
+  error: pc3.red,
+  warning: pc3.yellow,
+  info: pc3.cyan,
+  muted: pc3.dim,
+  highlight: pc3.bold,
+  // Backgrounds
+  bgSuccess: (s) => pc3.bgGreen(pc3.black(` ${s} `)),
+  bgError: (s) => pc3.bgRed(pc3.white(` ${s} `)),
+  bgWarning: (s) => pc3.bgYellow(pc3.black(` ${s} `)),
+  bgInfo: (s) => pc3.bgCyan(pc3.black(` ${s} `))
+};
+var symbols = {
+  // Status
+  active: pc3.green("\u25CF"),
+  inactive: pc3.dim("\u25CB"),
+  error: pc3.red("\u2717"),
+  warning: pc3.yellow("\u26A0"),
+  success: pc3.green("\u2713"),
+  info: pc3.cyan("\u2139"),
+  pending: pc3.yellow("\u25CC"),
+  // UI
+  bullet: pc3.dim("\u2502"),
+  dot: pc3.dim("\xB7"),
+  arrow: pc3.cyan("\u2192"),
+  pointer: fennecOrange3("\u25B6"),
+  separator: pc3.dim("\u2500"),
+  // Fennec
+  fox: "\u{1F98A}",
+  ears: "\u23DC"
+};
+function logLevel(label) {
+  const upper = label.toUpperCase().padEnd(5);
+  switch (label.toLowerCase()) {
+    case "error":
+      return pc3.bgRed(pc3.white(` ${upper} `));
+    case "warn":
+      return pc3.bgYellow(pc3.black(` ${upper} `));
+    case "info":
+      return pc3.bgCyan(pc3.black(` ${upper} `));
+    case "debug":
+      return pc3.dim(pc3.italic(upper));
+    case "verbose":
+      return pc3.dim(pc3.italic(upper));
+    default:
+      return pc3.dim(upper);
+  }
+}
+function renderTable(columns, rows, options) {
+  const pad = options?.padding ?? 1;
+  const isCompact = options?.compact ?? false;
+  if (rows.length === 0) {
+    return pc3.dim("  (no data)");
+  }
+  const widths = columns.map((col) => {
+    const headerLen = col.label.length;
+    const maxDataLen = rows.reduce((max, row) => {
+      const val = String(row[col.key] ?? "-");
+      return Math.max(max, val.length);
+    }, 0);
+    return Math.max(headerLen, maxDataLen, col.width ?? 0) + pad * 2;
+  });
+  const hLine = (left, mid, right, fill = "\u2500") => {
+    return pc3.dim(
+      left + widths.map((w) => fill.repeat(w)).join(mid) + right
+    );
+  };
+  const formatCell = (text, colIdx) => {
+    const col = columns[colIdx];
+    const w = widths[colIdx];
+    const display = text.length > w ? text.slice(0, w - 1) + "\u2026" : text;
+    const padded = display.padEnd(w);
+    const align = col.align ?? "left";
+    if (align === "right") return padded.padStart(w);
+    if (align === "center") {
+      const leftPad = Math.floor((w - display.length) / 2);
+      return " ".repeat(leftPad) + display + " ".repeat(w - display.length - leftPad);
+    }
+    return padded;
+  };
+  const renderRow = (row) => {
+    const cells = columns.map((col, i) => {
+      const raw = row[col.key];
+      const formatted = col.format ? col.format(raw) : String(raw ?? "-");
+      return formatCell(formatted, i);
     });
+    return pc3.dim("\u2502") + cells.join(pc3.dim("\u2502")) + pc3.dim("\u2502");
+  };
+  const lines = [];
+  if (!isCompact) {
+    lines.push(hLine("\u250C", "\u252C", "\u2510"));
+  }
+  const headerCells = columns.map((col, i) => {
+    return formatCell(pc3.bold(col.label), i);
   });
+  lines.push(pc3.dim("\u2502") + headerCells.join(pc3.dim("\u2502")) + pc3.dim("\u2502"));
+  if (!isCompact) {
+    lines.push(hLine("\u251C", "\u253C", "\u2524"));
+  } else {
+    lines.push(pc3.dim("\u251C") + widths.map((w) => pc3.dim("\u2500").repeat(w)).join(pc3.dim("\u253C")) + pc3.dim("\u2524"));
+  }
+  for (const row of rows) {
+    const rendered = renderRow(row);
+    if (row._error) {
+      lines.push(colors.error(rendered));
+    } else {
+      lines.push(rendered);
+    }
+  }
+  if (!isCompact) {
+    lines.push(hLine("\u2514", "\u2534", "\u2518"));
+  }
+  return lines.join("\n");
 }
-async function confirmPrompt(message, defaultValue = false) {
-  const hint = defaultValue ? "Y/n" : "y/N";
-  const answer = await rlQuestion(`
-${message} (${hint}): `);
-  if (!answer) return defaultValue;
-  return answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
+function renderKV(key, value, options) {
+  const indent = options?.indent ?? 2;
+  const sep = options?.separator ?? ":";
+  const pad = " ".repeat(indent);
+  return `${pad}${pc3.dim(key + sep)} ${value}`;
+}
+function createSpinner(text) {
+  const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+  let i = 0;
+  let running = true;
+  const interval = setInterval(() => {
+    if (!running) return;
+    process.stdout.write(`\r${pc3.cyan(frames[i])} ${text}`);
+    i = (i + 1) % frames.length;
+  }, 80);
+  return {
+    update(newText) {
+      if (!running) return;
+      process.stdout.write(`\r${pc3.cyan(frames[i])} ${newText}`);
+    },
+    succeed(msg) {
+      running = false;
+      clearInterval(interval);
+      process.stdout.write(`\r${pc3.green("\u2713")} ${msg}
+`);
+    },
+    fail(msg) {
+      running = false;
+      clearInterval(interval);
+      process.stdout.write(`\r${pc3.red("\u2717")} ${msg}
+`);
+    },
+    warn(msg) {
+      running = false;
+      clearInterval(interval);
+      process.stdout.write(`\r${pc3.yellow("\u26A0")} ${msg}
+`);
+    },
+    stop() {
+      running = false;
+      clearInterval(interval);
+    }
+  };
 }
 async function selectPrompt(message, options) {
   console.log(`
-${message}
+  ${pc3.bold(message)}
 `);
   options.forEach((opt, i) => {
-    console.log(`  ${i + 1}) ${opt.label}`);
+    const num2 = pc3.cyan(`  ${i + 1}`);
+    console.log(`${num2}  ${opt.label}`);
+    if (opt.description) {
+      console.log(`     ${pc3.dim(opt.description)}`);
+    }
+  });
+  console.log(`  ${pc3.dim("0)  Cancel")}
+`);
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const answer = await new Promise((resolve3) => {
+    rl.question(`  ${pc3.bold("Enter number")} ${pc3.dim("(0-" + options.length + ")")}: `, (ans) => {
+      rl.close();
+      resolve3(ans.trim());
+    });
   });
-  console.log(`  0) Cancel`);
-  const answer = await rlQuestion(`
-Enter number (0-${options.length}): `);
   const num = parseInt(answer, 10);
-  if (isNaN(num) || num === 0) return /* @__PURE__ */ Symbol("cancel");
+  if (isNaN(num) || num === 0) return null;
   const selected = options[num - 1];
   if (!selected) {
-    console.log("  Invalid selection. Cancelled.");
-    return /* @__PURE__ */ Symbol("cancel");
+    console.log(`  ${pc3.red("Invalid selection.")}`);
+    return null;
   }
   return selected.value;
 }
-function simpleSpinner(text) {
-  const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-  let i = 0;
-  const interval = setInterval(() => {
-    process.stdout.write(`\r${frames[i]} ${text}`);
-    i = (i + 1) % frames.length;
-  }, 80);
-  return {
-    stop(message) {
-      clearInterval(interval);
-      process.stdout.write(`\r${message ? "\u2713" : " "} ${message ?? text}
-`);
+async function confirmPrompt(message, defaultValue = false) {
+  const hint = defaultValue ? pc3.bold("Y") + pc3.dim("/n") : pc3.dim("y/") + pc3.bold("N");
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const answer = await new Promise((resolve3) => {
+    rl.question(`
+  ${message} ${pc3.dim("(" + hint + ")")}: `, (ans) => {
+      rl.close();
+      resolve3(ans.trim().toLowerCase());
+    });
+  });
+  if (!answer) return defaultValue;
+  return answer === "y" || answer === "yes";
+}
+function divider(text) {
+  if (text) {
+    const len = 50 - text.length - 2;
+    const left = Math.floor(len / 2);
+    const right = len - left;
+    return pc3.dim("\u2500".repeat(left) + ` ${text} ` + "\u2500".repeat(right));
+  }
+  return pc3.dim("\u2500".repeat(50));
+}
+function timestamp(date) {
+  const d = date ?? /* @__PURE__ */ new Date();
+  const time = d.toLocaleTimeString("en-US", { hour12: false });
+  return pc3.dim(`[${time}]`);
+}
+function renderCommand(cmd) {
+  return fennecOrange3(`$ ${cmd}`);
+}
+function renderAppName(name) {
+  return fennecOrange3(pc3.bold(name));
+}
+function renderError(title, details, suggestions) {
+  const lines = [];
+  lines.push(`
+  ${pc3.bgRed(pc3.white(" ERROR "))} ${pc3.bold(title)}`);
+  if (details) {
+    lines.push(`  ${pc3.dim(details)}`);
+  }
+  if (suggestions && suggestions.length > 0) {
+    lines.push(`
+  ${pc3.bold("Suggestions:")}`);
+    for (const s of suggestions) {
+      lines.push(`  ${pc3.cyan("\u2192")} ${s}`);
     }
+  }
+  return lines.join("\n") + "\n";
+}
+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
   };
 }
-var isCancel = (v) => v === /* @__PURE__ */ Symbol("cancel");
+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 === "ps") {
+    await psCommand(args);
+  } else if (command === "status") {
+    await statusCommand(args);
+  } else if (command === "log") {
+    await logCommand(args);
+  } else if (command === "kill") {
+    await killCommand(args);
+  } else if (command === "restart") {
+    await restartCommand(args);
+  } else if (command === "attach") {
+    await attachCommand(args);
   } else if (command === "pipe") {
     await pipeCommand(args);
   } else if (command === "attach-pid") {
@@ -233,89 +859,701 @@ async function main() {
   } else if (command === "init") {
     printBanner();
     await initCommand();
+  } else if (command === "version" || command === "--version" || command === "-v") {
+    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();
     showHelp();
   } else {
-    console.error(`Unknown command: ${command}`);
-    console.error("Run 'fennec help' for usage information");
+    console.error(renderError(`Unknown command: ${command}`, "Run 'fennec help' for usage information"));
     process.exit(1);
   }
 }
 async function startServer(args2) {
+  printBanner();
+  console.error(`  ${pc4.dim("Starting Fennec MCP server...")}
+`);
   const configIndex = args2.indexOf("--config");
   const configPath = configIndex !== -1 ? args2[configIndex + 1] : void 0;
-  const server = new FennecServer(configPath);
-  await server.start();
+  const apiPortIndex = args2.indexOf("--api-port");
+  const apiPort = apiPortIndex !== -1 ? parseInt(args2[apiPortIndex + 1], 10) : 3456;
+  try {
+    const server = new FennecServer(configPath);
+    await server.start();
+    console.error(`
+  ${pc4.green("\u2713")} ${pc4.bold("Fennec server is running")}`);
+    console.error(`  ${renderKV("Transport", "stdio")}`);
+    console.error(`  ${renderKV("Management API", `http://localhost:${apiPort}`)}`);
+    console.error(`  ${renderKV("AI Agent", "Connect via MCP protocol")}`);
+    console.error(`
+  ${pc4.dim("Press Ctrl+C to stop")}
+`);
+  } catch (error) {
+    console.error(renderError("Failed to start server", String(error)));
+    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 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 start|run <command> --name <name> [--port <port>] [--cwd <dir>] [--restart]"));
+    process.exit(1);
+  }
+  const appName = name ?? cmdParts[0] ?? "app";
+  console.error(`
+  ${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()}`);
+  const config = {
+    maxProcesses: 10,
+    logBufferLines: 2e3,
+    spawnAllowlist: []
+  };
+  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})`)}${port ? pc4.dim(` :${port}`) : ""}
+`);
+    const stdout = proc.child.stdout;
+    const stderr = proc.child.stderr;
+    if (stdout) {
+      stdout.on("data", (data) => {
+        const lines = data.toString().split("\n").filter(Boolean);
+        for (const line of lines) {
+          const level = line.includes("error") || line.includes("Error") ? "error" : line.includes("warn") || line.includes("WARN") ? "warn" : "info";
+          const time = timestamp();
+          const lvl = logLevel(level);
+          process.stdout.write(`  ${time} ${lvl} ${line}
+`);
+        }
+      });
+    }
+    if (stderr) {
+      stderr.on("data", (data) => {
+        const lines = data.toString().split("\n").filter(Boolean);
+        for (const line of lines) {
+          const time = timestamp();
+          const lvl = logLevel("error");
+          process.stderr.write(`  ${time} ${lvl} ${pc4.red(line)}
+`);
+        }
+      });
+    }
+    proc.child.on("exit", (code, signal) => {
+      removeTracked(appName);
+      if (restartFlag && code !== 0) {
+        console.error(`
+  ${pc4.yellow("\u26A0")} ${appName} ${pc4.dim(`exited (${code}), restarting...`)}`);
+        pm.restart(appName).catch(() => {
+        });
+      } else {
+        console.error(`
+  ${pc4.dim("\u25CB")} ${pc4.bold(appName)} ${pc4.dim(`exited (${code})`)}`);
+      }
+    });
+    await new Promise(() => {
+    });
+  } catch (error) {
+    console.error(renderError(`Failed to run ${appName}`, String(error)));
+    process.exit(1);
+  }
+}
+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 watchProcesses(sortBy, limit);
+    return;
+  }
+  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.")}
+`);
+      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 watchProcesses(sortBy, limit) {
+  console.error(`
+  ${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: "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 = 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[J");
+    console.error(render());
+  }, 3e3);
+  process.on("SIGINT", () => {
+    clearInterval(interval);
+    process.exit(0);
+  });
+  await new Promise(() => {
+  });
+}
+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(`
+  ${symbols.fox} ${pc4.bold("Fennec System Overview")}
+`);
+    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)));
+  }
+}
+async function killCommand(args2) {
+  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(
+    `Kill ${pc4.bold(displayName)} with ${pc4.yellow(signal)}?`,
+    false
+  );
+  if (!confirmed) {
+    console.error(`  ${pc4.dim("Cancelled")}`);
+    return;
+  }
+  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/pid", "Usage: fennec restart <pid|name>"));
+    process.exit(1);
+  }
+  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);
+  if (isNaN(port)) {
+    console.error(renderError("Invalid port", "Usage: fennec attach <port> --name <name>"));
+    process.exit(1);
+  }
+  const nameIndex = args2.indexOf("--name");
+  const rawName = nameIndex !== -1 ? args2[nameIndex + 1] : void 0;
+  const name = rawName ?? `port-${port}`;
+  const spinner = createSpinner(`Attaching to :${port}...`);
+  try {
+    const { PortDetector } = await import("@plumpslabs/fennec-core");
+    const detector = new PortDetector();
+    const info = detector.detectByPort(port);
+    if (info) {
+      spinner.succeed(`Attached to :${port}`);
+      console.error(`  ${renderKV("Name", renderAppName(name))}`);
+      console.error(`  ${renderKV("PID", String(info.pid))}`);
+      console.error(`  ${renderKV("Command", info.command || pc4.dim("unknown"))}`);
+    } else {
+      spinner.fail(`No process found on port ${port}`);
+      process.exit(1);
+    }
+  } catch (error) {
+    spinner.fail(`Failed to attach to :${port}`);
+    console.error(renderError("Error", String(error)));
+    process.exit(1);
+  }
 }
 async function sessionsCommand() {
   const store = new SessionStore("./.fennec/sessions");
   const sessions = store.list();
   if (sessions.length === 0) {
-    console.log("No saved sessions found.");
+    console.error(`
+  ${pc4.dim("No saved sessions found.")}
+`);
     return;
   }
-  console.log("Saved sessions:");
-  for (const s of sessions) {
-    console.log(`  ${s.name} at ${s.origin} (saved: ${new Date(s.savedAt).toLocaleString()})`);
-  }
-  console.log(`
-Total: ${sessions.length} session(s)`);
+  const columns = [
+    { key: "name", label: "Name", format: (v) => pc4.bold(String(v)) },
+    { key: "origin", label: "Origin" },
+    { key: "savedAt", label: "Saved", format: (v) => pc4.dim(String(v)) }
+  ];
+  const rows = sessions.map((s) => ({
+    name: s.name,
+    origin: s.origin,
+    savedAt: new Date(s.savedAt).toLocaleString()
+  }));
+  console.error(`
+  ${symbols.fox} ${pc4.bold("Saved Sessions")}
+`);
+  console.error(renderTable(columns, rows));
+  console.error(`  ${pc4.dim(`${sessions.length} session(s)`)}
+`);
 }
 async function setupCommand() {
-  console.log("\n  Fennec Setup\n");
+  console.error(`
+  ${symbols.fox} ${pc4.bold("Fennec Setup")}
+`);
   const mcpClient = await selectPrompt("Which MCP client are you using?", [
-    { value: "claude", label: "Claude Desktop" },
-    { value: "other", label: "Other MCP client" }
+    { value: "claude", label: "Claude Desktop", description: "Anthropic's AI desktop app" },
+    { value: "cursor", label: "Cursor", description: "AI-powered code editor" },
+    { value: "cline", label: "Cline", description: "VS Code MCP client" },
+    { value: "other", label: "Other MCP client", description: "Any MCP-compatible client" }
   ]);
-  if (isCancel(mcpClient)) {
-    console.log("Setup cancelled");
+  if (!mcpClient) {
+    console.error(`  ${pc4.dim("Setup cancelled.")}
+`);
     return;
   }
-  if (mcpClient === "claude") {
-    console.log(`
-To configure Claude Desktop for Fennec, add to your config:
-
-{
+  console.error(`
+  ${pc4.green("\u2713")} Selected: ${pc4.bold(mcpClient)}
+`);
+  const configSnippet = `{
   "mcpServers": {
     "fennec": {
       "command": "fennec",
       "args": ["start"]
     }
   }
-}
-    `);
-  }
-  console.log("Setup complete! Run 'fennec start' to begin.\n");
+}`;
+  console.error(`  ${pc4.bold("Add this to your MCP client config:")}
+`);
+  console.error(`  ${pc4.dim("```")}`);
+  console.error(configSnippet.split("\n").map((l) => `  ${l}`).join("\n"));
+  console.error(`  ${pc4.dim("```")}
+`);
+  console.error(`  ${renderSuccess("Setup complete!")} ${pc4.dim("Run")} ${renderCommand("fennec start")} ${pc4.dim("to begin.")}
+`);
 }
 async function installBrowsersCommand() {
-  console.log("\n  Installing browser engines\n");
-  const s = simpleSpinner("Installing Chromium...");
+  console.error(`
+  ${pc4.bold("Installing Browser Engines")}
+`);
+  const spinner = createSpinner("Installing Chromium...");
   try {
-    execSync("npx playwright install chromium", {
-      stdio: "inherit",
+    execSync2("npx playwright install chromium", {
+      stdio: "pipe",
       timeout: 12e4
     });
-    s.stop("Chromium installed successfully");
+    spinner.succeed("Chromium installed successfully");
   } catch {
-    s.stop("Failed to install Chromium");
-    console.error("Try running manually: npx playwright install chromium");
+    spinner.fail("Failed to install Chromium");
+    console.error(`  ${pc4.yellow("\u2192")} Try running: ${renderCommand("npx playwright install chromium")}`);
   }
-  console.log("\nBrowser installation complete.\n");
+  console.error(`
+  ${pc4.green("\u2713")} Browser installation complete.
+`);
 }
 async function initCommand() {
-  console.log("\n  Initialize Fennec Configuration\n");
+  console.error(`
+  ${pc4.bold("Initialize Fennec Configuration")}
+`);
   const configFile = resolve2("./fennec.config.yaml");
-  if (existsSync2(configFile)) {
+  if (existsSync3(configFile)) {
     const overwrite = await confirmPrompt(
-      "fennec.config.yaml already exists. Overwrite?",
+      `${pc4.yellow("fennec.config.yaml")} already exists. Overwrite?`,
       false
     );
     if (!overwrite) {
-      console.log("Cancelled");
+      console.error(`  ${pc4.dim("Cancelled.")}
+`);
       return;
     }
   }
+  const spinner = createSpinner("Generating configuration...");
   const config = `# Fennec Configuration
 # Generated by 'fennec init'
 
@@ -390,11 +1628,13 @@ logging:
   file: null
 `;
   writeFileSync(configFile, config, "utf-8");
-  console.log(`Configuration written to ${configFile}
+  spinner.succeed(`Configuration written to ${pc4.bold(configFile)}`);
+  console.error(`
+  ${pc4.dim("Edit the file to customize Fennec behavior.")}
 `);
 }
 main().catch((error) => {
-  console.error("Fatal error:", error);
+  console.error(renderError("Fatal error", String(error)));
   process.exit(1);
 });
 //# sourceMappingURL=index.js.map