@plumpslabs/fennec-cli 1.12.3 → 1.13.0

package/dist/index.js

@@ -1958,6 +1958,9 @@ function renderKV(key, value, options) {
   const pad = " ".repeat(indent);
   return `${pad}${pc.dim(key + sep)} ${value}`;
 }
+function renderKVColor(key, value, color = pc.bold) {
+  return `  ${pc.dim(key + ":")} ${color(value)}`;
+}
 function createSpinner(text) {
   const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
   let i = 0;
@@ -2010,10 +2013,10 @@ async function selectPrompt(message, options) {
   console.log(`  ${pc.dim("0)  Cancel")}
 `);
   const rl = createInterface({ input: process.stdin, output: process.stdout });
-  const answer = await new Promise((resolve8) => {
+  const answer = await new Promise((resolve12) => {
     rl.question(`  ${pc.bold("Enter number")} ${pc.dim("(0-" + options.length + ")")}: `, (ans) => {
       rl.close();
-      resolve8(ans.trim());
+      resolve12(ans.trim());
     });
   });
   const num = parseInt(answer, 10);
@@ -2028,11 +2031,11 @@ async function selectPrompt(message, options) {
 async function confirmPrompt(message, defaultValue = false) {
   const hint = defaultValue ? pc.bold("Y") + pc.dim("/n") : pc.dim("y/") + pc.bold("N");
   const rl = createInterface({ input: process.stdin, output: process.stdout });
-  const answer = await new Promise((resolve8) => {
+  const answer = await new Promise((resolve12) => {
     rl.question(`
   ${message} ${pc.dim("(" + hint + ")")}: `, (ans) => {
       rl.close();
-      resolve8(ans.trim().toLowerCase());
+      resolve12(ans.trim().toLowerCase());
     });
   });
   if (!answer) return defaultValue;
@@ -2088,7 +2091,7 @@ function hexColor(color) {
 }
 var fennecOrange2 = hexColor("#FF6432");
 var fennecGold = hexColor("#FFB347");
-var VERSION = "1.12.3";
+var VERSION = "1.13.0";
 var cachedBanner = null;
 var cachedCompact = null;
 function generateBanner() {
@@ -2681,8 +2684,13 @@ import pc4 from "picocolors";
 async function psCommand(args2) {
   const watchFlag = args2.includes("-w") || args2.includes("--watch");
   const systemFlag = args2.includes("--system") || args2.includes("-a") || args2.includes("--all");
+  const jsonFlag = args2.includes("--json");
   const nameFilter = args2.includes("--name") ? args2[args2.indexOf("--name") + 1] : void 0;
   const sortBy = args2.includes("--sort") ? args2[args2.indexOf("--sort") + 1] : "name";
+  if (jsonFlag) {
+    await psJson();
+    return;
+  }
   if (watchFlag && systemFlag) {
     await watchSystemProcesses(sortBy, 15);
     return;
@@ -2767,9 +2775,28 @@ async function psCommand(args2) {
   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(`  ${pc4.dim("Use")} ${pc4.cyan("fennec stop <name>")} ${pc4.dim("to pause an app.")}`);
+  console.error(`  ${pc4.dim("Use")} ${pc4.cyan("fennec spawn <name>")} ${pc4.dim("to resume a paused app.")}`);
+  console.error(`  ${pc4.dim("Use")} ${pc4.cyan("fennec kill <name>")} ${pc4.dim("to permanently remove an app.")}`);
   console.error();
 }
+async function psJson() {
+  const tracked = readTracked();
+  const data = tracked.map((t) => {
+    const running = isProcessRunning(t.pid);
+    return {
+      name: t.name,
+      pid: t.pid,
+      status: running ? "running" : "stopped",
+      port: t.port ?? null,
+      command: t.command,
+      cwd: t.cwd ?? null,
+      startedAt: t.startedAt,
+      uptime: running ? Math.floor((Date.now() - new Date(t.startedAt).getTime()) / 1e3) : null
+    };
+  });
+  console.log(JSON.stringify(data, null, 2));
+}
 async function statusCommand(_args) {
   const watchFlag = _args.includes("-w") || _args.includes("--watch");
   const tracked = readTracked();
@@ -2831,11 +2858,11 @@ ${renderTable(columns, rows, { compact: true })}`;
     process.stdout.write("\x1B[J");
     console.error(render());
   }, 3e3);
-  await new Promise((resolve8) => {
+  await new Promise((resolve12) => {
     process.once("SIGINT", () => {
       clearInterval(interval);
       process.stdout.write("\x1B[J");
-      resolve8();
+      resolve12();
     });
   });
 }
@@ -2876,12 +2903,13 @@ async function runCommand(args2) {
   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>]"));
+    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";
@@ -2904,20 +2932,21 @@ async function runCommand(args2) {
   console.error(`  ${renderKV("Command", cmd)}`);
   if (port) console.error(`  ${renderKV("Port", String(port))}`);
   if (cwd) console.error(`  ${renderKV("Directory", cwd)}`);
+  if (restartFlag) console.error(`  ${renderKV("Auto-restart", pc5.green("enabled"))}`);
   console.error(`  ${divider()}`);
   try {
-    const child = spawn(cmdParts[0], cmdParts.slice(1), {
+    let currentChild = spawn(cmdParts[0], cmdParts.slice(1), {
       cwd,
       env: { ...process.env },
       stdio: ["ignore", "pipe", "pipe"],
       detached: true
     });
-    const pid = child.pid ?? 0;
+    const pid = currentChild.pid ?? 0;
     rotateLogFile(logFilePath);
     const logStream = createWriteStream(logFilePath, { flags: "a" });
-    if (child.stdout) child.stdout.pipe(logStream);
-    if (child.stderr) child.stderr.pipe(logStream);
-    child.unref();
+    if (currentChild.stdout) currentChild.stdout.pipe(logStream);
+    if (currentChild.stderr) currentChild.stderr.pipe(logStream);
+    currentChild.unref();
     addTracked({
       name: appName,
       pid,
@@ -2927,7 +2956,44 @@ async function runCommand(args2) {
       startedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
     console.error(`  ${pc5.green("\u2713")} ${pc5.bold(appName)} ${pc5.dim(`started (PID: ${pid})`)}`);
-    await psCommand([]);
+    if (restartFlag) {
+      let setupRestartWatch2 = function(c) {
+        c.on("exit", (code, signal) => {
+          if (code !== 0 && signal !== "SIGTERM" && signal !== "SIGKILL") {
+            console.error(`  ${pc5.yellow("\u26A0")} ${pc5.bold(appName)} ${pc5.dim(`exited with code ${code}, restarting...`)}`);
+            const restarted = spawn(cmdParts[0], cmdParts.slice(1), {
+              cwd,
+              env: { ...process.env },
+              stdio: ["ignore", "pipe", "pipe"],
+              detached: true
+            });
+            const newPid = restarted.pid ?? 0;
+            rotateLogFile(logFilePath);
+            const rs = createWriteStream(logFilePath, { flags: "a" });
+            if (restarted.stdout) restarted.stdout.pipe(rs);
+            if (restarted.stderr) restarted.stderr.pipe(rs);
+            restarted.unref();
+            addTracked({ name: appName, pid: newPid, command: cmd, port, cwd, startedAt: (/* @__PURE__ */ new Date()).toISOString() });
+            console.error(`  ${pc5.green("\u2713")} ${pc5.bold(appName)} ${pc5.dim(`restarted (PID: ${newPid})`)}`);
+            currentChild = restarted;
+            setupRestartWatch2(restarted);
+          }
+        });
+      };
+      var setupRestartWatch = setupRestartWatch2;
+      console.error(`  ${pc5.dim("Auto-restart enabled \u2014 watching for crashes...")}
+`);
+      setupRestartWatch2(currentChild);
+      await new Promise((resolve12) => {
+        process.once("SIGINT", () => {
+          currentChild.kill("SIGTERM");
+          resolve12();
+        });
+      });
+    }
+    if (!restartFlag) {
+      await psCommand([]);
+    }
   } catch (error) {
     console.error(renderError(`Failed to start ${appName}`, String(error)));
     process.exit(1);
@@ -3103,12 +3169,295 @@ async function killAll(signal) {
   if (failed > 0) console.error(`  ${pc6.yellow(`${failed} process(es) could not be killed`)} ${pc6.dim("(try with sudo)")}`);
 }
 
-// src/commands/restart.ts
+// src/commands/stop.ts
 import pc7 from "picocolors";
-import { mkdirSync as mkdirSync3, createWriteStream as createWriteStream2 } from "fs";
+async function stopCommand(args2) {
+  const stopAll = args2.includes("--all") || args2.includes("-a");
+  if (stopAll) {
+    await stopAllTracked();
+    return;
+  }
+  const rawTarget = args2[0];
+  if (!rawTarget) {
+    console.error(renderError("Missing name", "Usage: fennec stop <name|--all>"));
+    process.exit(1);
+  }
+  const tracked = readTracked();
+  const trackedMatch = tracked.find((t) => t.name === rawTarget);
+  if (!trackedMatch) {
+    console.error(renderError("Not found", `No tracked process named "${rawTarget}". Use ${pc7.cyan("fennec kill <pid>")} to kill a system process.`));
+    process.exit(1);
+  }
+  if (!isProcessRunning(trackedMatch.pid)) {
+    console.error(`
+  ${pc7.yellow("\u26A0")} ${pc7.bold(rawTarget)} ${pc7.dim("is already stopped")}`);
+    console.error();
+    process.exit(0);
+  }
+  const displayName = `${trackedMatch.name} (PID ${trackedMatch.pid})`;
+  const confirmed = await confirmPrompt(`Stop ${pc7.bold(displayName)}? ${pc7.dim("It can be re-spawned later via fennec spawn")}`, false);
+  if (!confirmed) {
+    console.error(`  ${pc7.dim("Cancelled")}`);
+    return;
+  }
+  await stopSingleProcess(trackedMatch.pid, trackedMatch.name);
+}
+async function stopAllTracked() {
+  const tracked = readTracked();
+  const running = tracked.filter((t) => isProcessRunning(t.pid));
+  if (running.length === 0) {
+    console.error(`
+  ${pc7.dim("No running tracked processes to stop.")}
+`);
+    return;
+  }
+  console.error(`
+  ${pc7.yellow("\u26A0")} ${pc7.bold(`Stop all ${running.length} running process(es)?`)} ${pc7.dim("(They can be re-spawned later)")}
+`);
+  for (const t of running) {
+    console.error(`  ${pc7.green("\u25CF")} ${pc7.bold(t.name)} ${pc7.dim(`(PID ${t.pid})`)}`);
+  }
+  console.error();
+  const confirmed = await confirmPrompt("Stop all?", false);
+  if (!confirmed) {
+    console.error(`  ${pc7.dim("Cancelled")}
+`);
+    return;
+  }
+  const spinner = createSpinner(`Stopping ${running.length} process(es)...`);
+  let stopped = 0;
+  let failed = 0;
+  for (const t of running) {
+    if (killProcess(t.pid, "SIGTERM")) {
+      stopped++;
+    } else {
+      failed++;
+    }
+  }
+  await new Promise((r) => setTimeout(r, 300));
+  spinner.stop();
+  process.stdout.write("\r\x1B[K");
+  if (stopped > 0) {
+    console.error(`  ${pc7.green("\u2713")} ${pc7.bold(`Stopped ${stopped} process(es)`)} ${pc7.dim("(kept in tracked.json)")}`);
+  }
+  if (failed > 0) {
+    console.error(`  ${pc7.red("\u2717")} ${pc7.bold(`${failed} process(es) failed to stop`)}`);
+  }
+  console.error();
+  await psCommand([]);
+}
+async function stopSingleProcess(pid, name) {
+  const displayName = `${name} (PID ${pid})`;
+  const spinner = createSpinner(`Stopping ${displayName}...`);
+  const success = killProcess(pid, "SIGTERM");
+  if (success) {
+    await new Promise((r) => setTimeout(r, 200));
+    const stillRunning = isProcessRunning(pid);
+    if (stillRunning) {
+      spinner.warn(`${displayName} did not respond to SIGTERM`);
+      const forceKill = await confirmPrompt(`Send ${pc7.red("SIGKILL")} to force stop?`, true);
+      if (forceKill) {
+        const forceSpinner = createSpinner(`Sending SIGKILL to ${displayName}...`);
+        killProcess(pid, "SIGKILL");
+        await new Promise((r) => setTimeout(r, 300));
+        isProcessRunning(pid) ? forceSpinner.fail(`${displayName} could not be stopped (permission denied?)`) : forceSpinner.succeed(`${displayName} force stopped`);
+      } else {
+        console.error(`  ${pc7.yellow("\u26A0")} ${displayName} ${pc7.dim("may still be running")}`);
+      }
+    } else {
+      spinner.succeed(`${displayName} stopped`);
+    }
+    console.error();
+    await psCommand([]);
+  } else {
+    spinner.fail(`Failed to stop ${displayName}`);
+    console.error(renderError("Permission denied", "Try running with sudo or use fennec kill."));
+  }
+}
+
+// src/commands/spawn.ts
+import pc8 from "picocolors";
+import { createWriteStream as createWriteStream2, mkdirSync as mkdirSync3 } from "fs";
 import { resolve as resolve4 } from "path";
 import { homedir as homedir3 } from "os";
 import { spawn as spawn2 } from "child_process";
+async function spawnCommand(args2) {
+  const spawnAll = args2.includes("--all") || args2.includes("-a");
+  const name = args2[0];
+  if (spawnAll) {
+    await spawnAllStopped();
+    return;
+  }
+  if (!name) {
+    await spawnList();
+    return;
+  }
+  const tracked = readTracked();
+  const match = tracked.find((t) => t.name === name);
+  if (!match) {
+    console.error(renderError("Not found", `No tracked process named "${name}". Use ${pc8.cyan("fennec spawn")} to see available processes, or ${pc8.cyan("fennec start <command> --name <name>")} to create a new one.`));
+    process.exit(1);
+  }
+  if (isProcessRunning(match.pid)) {
+    console.error(`
+  ${pc8.yellow("\u26A0")} ${pc8.bold(name)} ${pc8.dim("is already running (PID:")} ${match.pid}${pc8.dim(")")}`);
+    console.error(`  ${pc8.dim("Use")} ${pc8.cyan(`fennec stop ${name}`)} ${pc8.dim("to stop it first.")}`);
+    console.error();
+    process.exit(0);
+  }
+  if (!match.command) {
+    console.error(renderError("No command saved", `"${name}" has no saved command and cannot be re-spawned.`));
+    process.exit(1);
+  }
+  await respawnProcess(match);
+}
+async function spawnAllStopped() {
+  const tracked = readTracked();
+  const toSpawn = tracked.filter((t) => !isProcessRunning(t.pid) && t.command);
+  if (toSpawn.length === 0) {
+    console.error(`
+  ${pc8.dim("No stopped processes with saved commands to spawn.")}
+`);
+    return;
+  }
+  console.error(`
+  ${symbols.fox} ${pc8.bold(`Spawning ${toSpawn.length} process(es)...`)}
+`);
+  for (const t of toSpawn) {
+    console.error(`  ${pc8.dim("\xB7")} ${pc8.bold(t.name)} ${pc8.dim(`(${t.command})`)}`);
+  }
+  console.error();
+  const spinner = createSpinner("Spawning...");
+  let spawned = 0;
+  let failed = 0;
+  for (const proc of toSpawn) {
+    try {
+      const cmdParts = proc.command.split(/\s+/);
+      const logDir = resolve4(homedir3(), ".fennec", "logs");
+      mkdirSync3(logDir, { recursive: true });
+      const logFilePath = resolve4(logDir, `${proc.name}.log`);
+      const child = spawn2(cmdParts[0], cmdParts.slice(1), {
+        cwd: proc.cwd,
+        env: { ...process.env },
+        stdio: ["ignore", "pipe", "pipe"],
+        detached: true
+      });
+      const pid = child.pid ?? 0;
+      rotateLogFile(logFilePath);
+      const logStream = createWriteStream2(logFilePath, { flags: "a" });
+      if (child.stdout) child.stdout.pipe(logStream);
+      if (child.stderr) child.stderr.pipe(logStream);
+      child.unref();
+      addTracked({
+        name: proc.name,
+        pid,
+        command: proc.command,
+        port: proc.port,
+        cwd: proc.cwd,
+        startedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      spawned++;
+    } catch {
+      failed++;
+    }
+  }
+  spinner.stop();
+  process.stdout.write("\r\x1B[K");
+  if (spawned > 0) {
+    console.error(`  ${pc8.green("\u2713")} ${pc8.bold(`Spawned ${spawned} process(es)`)}`);
+  }
+  if (failed > 0) {
+    console.error(`  ${pc8.red("\u2717")} ${pc8.bold(`${failed} process(es) failed to spawn`)}`);
+  }
+  console.error();
+  await psCommand([]);
+}
+async function spawnList() {
+  const tracked = readTracked();
+  if (tracked.length === 0) {
+    console.error(`
+  ${pc8.dim("No tracked processes found.")}`);
+    console.error(`  ${pc8.dim("Start an app first:")} ${pc8.cyan("fennec start <command> --name <name>")}`);
+    console.error();
+    return;
+  }
+  const stopped = tracked.filter((t) => !isProcessRunning(t.pid));
+  const running = tracked.filter((t) => isProcessRunning(t.pid));
+  if (stopped.length === 0) {
+    console.error(`
+  ${pc8.dim("All tracked processes are running. Nothing to spawn.")}`);
+    console.error();
+    return;
+  }
+  console.error(`
+  ${symbols.fox} ${pc8.bold("Available to spawn")} ${pc8.dim(`(${stopped.length}/${tracked.length} stopped)`)}`);
+  if (running.length > 0) {
+    console.error(`  ${pc8.dim("Running (use stop first):")}`);
+    for (const r of running) {
+      console.error(`    ${pc8.green("\u25CF")} ${pc8.bold(r.name)} ${pc8.dim(`(PID ${r.pid})`)}`);
+    }
+    console.error();
+  }
+  const selected = await selectPrompt("Select a process to spawn:", stopped.map((t) => ({
+    value: t.name,
+    label: t.name,
+    description: t.command.length > 80 ? t.command.slice(0, 80) + "..." : t.command
+  })));
+  if (selected === null) {
+    console.error(`  ${pc8.dim("Cancelled")}`);
+    return;
+  }
+  const match = stopped.find((t) => t.name === selected);
+  if (match) {
+    await respawnProcess(match);
+  }
+}
+async function respawnProcess(proc) {
+  const cmdParts = proc.command.split(/\s+/);
+  const logDir = resolve4(homedir3(), ".fennec", "logs");
+  mkdirSync3(logDir, { recursive: true });
+  const logFilePath = resolve4(logDir, `${proc.name}.log`);
+  console.error(`
+  ${symbols.fox} ${pc8.bold("Spawning")} ${renderAppName(proc.name)} ${pc8.dim("(from saved config)")}
+`);
+  console.error(`  ${renderKV("Command", proc.command)}`);
+  if (proc.cwd) console.error(`  ${renderKV("Directory", proc.cwd)}`);
+  if (proc.port) console.error(`  ${renderKV("Port", String(proc.port))}`);
+  try {
+    const child = spawn2(cmdParts[0], cmdParts.slice(1), {
+      cwd: proc.cwd,
+      env: { ...process.env },
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: true
+    });
+    const pid = child.pid ?? 0;
+    rotateLogFile(logFilePath);
+    const logStream = createWriteStream2(logFilePath, { flags: "a" });
+    if (child.stdout) child.stdout.pipe(logStream);
+    if (child.stderr) child.stderr.pipe(logStream);
+    child.unref();
+    addTracked({
+      name: proc.name,
+      pid,
+      command: proc.command,
+      port: proc.port,
+      cwd: proc.cwd,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    console.error(`  ${pc8.green("\u2713")} ${pc8.bold(proc.name)} ${pc8.dim(`spawned (PID: ${pid})`)}`);
+    await psCommand([]);
+  } catch (error) {
+    console.error(renderError(`Failed to spawn ${proc.name}`, String(error)));
+    process.exit(1);
+  }
+}
+
+// src/commands/restart.ts
+import pc9 from "picocolors";
+import { mkdirSync as mkdirSync4, createWriteStream as createWriteStream3 } from "fs";
+import { resolve as resolve5 } from "path";
+import { homedir as homedir4 } from "os";
+import { spawn as spawn3 } from "child_process";
 async function restartCommand(args2) {
   const name = args2[0];
   if (!name) {
@@ -3133,9 +3482,9 @@ async function restartCommand(args2) {
       targetPid = processes[0].pid;
     }
   }
-  const confirmed = await confirmPrompt(`Restart ${pc7.bold(`${name} (PID ${targetPid})`)}?`, false);
+  const confirmed = await confirmPrompt(`Restart ${pc9.bold(`${name} (PID ${targetPid})`)}?`, false);
   if (!confirmed) {
-    console.error(`  ${pc7.dim("Cancelled")}`);
+    console.error(`  ${pc9.dim("Cancelled")}`);
     return;
   }
   const spinner = createSpinner(`Stopping PID ${targetPid}...`);
@@ -3155,17 +3504,17 @@ async function restartCommand(args2) {
     const respawnSpinner = createSpinner(`Re-spawning ${trackedEntry.name}...`);
     try {
       const cmdParts = trackedEntry.command.split(" ");
-      const logDir = resolve4(homedir3(), ".fennec", "logs");
-      mkdirSync3(logDir, { recursive: true });
-      const logFilePath = resolve4(logDir, `${trackedEntry.name}.log`);
-      const child = spawn2(cmdParts[0], cmdParts.slice(1), {
+      const logDir = resolve5(homedir4(), ".fennec", "logs");
+      mkdirSync4(logDir, { recursive: true });
+      const logFilePath = resolve5(logDir, `${trackedEntry.name}.log`);
+      const child = spawn3(cmdParts[0], cmdParts.slice(1), {
         cwd: trackedEntry.cwd,
         env: { ...process.env },
         stdio: ["ignore", "pipe", "pipe"],
         detached: true
       });
       rotateLogFile(logFilePath);
-      const logStream = createWriteStream2(logFilePath, { flags: "a" });
+      const logStream = createWriteStream3(logFilePath, { flags: "a" });
       if (child.stdout) child.stdout.pipe(logStream);
       if (child.stderr) child.stderr.pipe(logStream);
       child.unref();
@@ -3181,35 +3530,41 @@ async function restartCommand(args2) {
       respawnSpinner.succeed(`${trackedEntry.name} restarted (PID: ${child.pid})`);
     } catch (error) {
       respawnSpinner.fail(`Failed to re-spawn ${trackedEntry.name}: ${String(error)}`);
-      console.error(`  ${pc7.dim("Config preserved. Re-run manually:")} ${renderCommand(trackedEntry.command)}`);
+      console.error(`  ${pc9.dim("Config preserved. Re-run manually:")} ${renderCommand(trackedEntry.command)}`);
     }
   } else {
-    console.error(`  ${pc7.dim("No tracked config found. Re-run manually:")} ${renderCommand(name)}`);
+    console.error(`  ${pc9.dim("No tracked config found. Re-run manually:")} ${renderCommand(name)}`);
   }
 }
 
 // src/commands/log.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
-import { resolve as resolve5 } from "path";
-import { homedir as homedir4 } from "os";
-import { spawn as spawn3, execSync as execSync2 } from "child_process";
-import pc8 from "picocolors";
+import { existsSync as existsSync4, readFileSync as readFileSync3, unlinkSync } from "fs";
+import { resolve as resolve6 } from "path";
+import { homedir as homedir5 } from "os";
+import { spawn as spawn4, execSync as execSync2 } from "child_process";
+import pc10 from "picocolors";
 async function logCommand(args2) {
   const target = args2[0];
   if (!target) {
-    console.error(renderError("Missing process name/pid", "Usage: fennec log <name|pid> [--lines N] [-f]"));
+    console.error(renderError("Missing process name/pid", "Usage: fennec log <name|pid> [--lines N] [-f] [--clear] [--level error|warn|info|debug]"));
     process.exit(1);
   }
+  const clearFlag = args2.includes("--clear");
   const linesIndex = args2.indexOf("--lines");
   const lineCount = linesIndex !== -1 ? parseInt(args2[linesIndex + 1], 10) : 30;
   const followFlag = args2.includes("-f") || args2.includes("--follow");
+  const levelFilter = args2.includes("--level") ? args2[args2.indexOf("--level") + 1]?.toLowerCase() : void 0;
+  if (levelFilter && !["error", "warn", "info", "debug"].includes(levelFilter)) {
+    console.error(renderError("Invalid level", `"${levelFilter}" is not a valid level. Use: error, warn, info, debug`));
+    process.exit(1);
+  }
   let logFilePath = null;
   let displayName = target;
   const tracked = readTracked();
   const trackedMatch = tracked.find((t) => t.name === target || parseInt(target, 10) === t.pid && !isNaN(parseInt(target, 10)));
   if (trackedMatch) {
     displayName = trackedMatch.name;
-    logFilePath = resolve5(homedir4(), ".fennec", "logs", `${trackedMatch.name}.log`);
+    logFilePath = resolve6(homedir5(), ".fennec", "logs", `${trackedMatch.name}.log`);
   } else {
     const pid = parseInt(target, 10);
     if (!isNaN(pid) && String(pid) === target) {
@@ -3217,6 +3572,24 @@ async function logCommand(args2) {
       if (existsSync4(procPath)) logFilePath = procPath;
     }
   }
+  if (clearFlag) {
+    if (!logFilePath || !existsSync4(logFilePath)) {
+      console.error(`
+  ${pc10.yellow("\u26A0")} ${pc10.dim("No log file found for")} ${pc10.bold(displayName)}
+`);
+      process.exit(0);
+    }
+    try {
+      unlinkSync(logFilePath);
+      console.error(`
+  ${pc10.green("\u2713")} ${pc10.bold("Log cleared")} ${pc10.dim(`\u2014 ${logFilePath}`)}
+`);
+    } catch (err) {
+      console.error(renderError("Failed to clear log", String(err)));
+      process.exit(1);
+    }
+    return;
+  }
   const spinner = createSpinner(`Reading logs for ${displayName}...`);
   try {
     let logLines = [];
@@ -3236,31 +3609,55 @@ async function logCommand(args2) {
         logLines = ["(no logs available)"];
       }
     }
+    if (levelFilter) {
+      const levelRegex = new RegExp(`\\b(${levelFilter.toUpperCase()})\\b`, "i");
+      logLines = logLines.filter((line) => levelRegex.test(line));
+    }
     spinner.stop();
     process.stdout.write("\r\x1B[K");
     console.error(`
-  ${symbols.fox} ${pc8.bold("Logs")} ${renderAppName(displayName)} ${pc8.dim(`(last ${logLines.length} lines)`)}
-`);
+  ${symbols.fox} ${pc10.bold("Logs")} ${renderAppName(displayName)} ${pc10.dim(`(last ${logLines.length} line${logLines.length !== 1 ? "s" : ""})`)}`);
     const sliced = logLines.slice(-lineCount);
     for (const line of sliced) {
       const display = line.length > 300 ? line.slice(0, 300) + "\u2026" : line;
-      if (line.toLowerCase().includes("error") || line.toLowerCase().includes("fail")) console.error(`  ${pc8.red(display)}`);
-      else if (line.toLowerCase().includes("warn")) console.error(`  ${pc8.yellow(display)}`);
-      else if (line.toLowerCase().includes("info") || line.includes("[")) console.error(`  ${pc8.cyan(display)}`);
-      else console.error(`  ${display}`);
+      const prefix = followFlag ? `${timestamp()} ` : "";
+      if (line.toLowerCase().includes("error") || line.toLowerCase().includes("fail") || line.toLowerCase().includes("fatal")) {
+        console.error(`  ${pc10.red(prefix + display)}`);
+      } else if (line.toLowerCase().includes("warn")) {
+        console.error(`  ${pc10.yellow(prefix + display)}`);
+      } else if (line.toLowerCase().includes("info") || line.includes("[")) {
+        console.error(`  ${pc10.cyan(prefix + display)}`);
+      } else {
+        console.error(`  ${prefix}${display}`);
+      }
     }
     if (followFlag && logFilePath) {
-      console.error(`
-  ${pc8.dim("Following... (Ctrl+C to stop)")}
+      const tailArgs = ["-n", "0", "-f"];
+      if (levelFilter) {
+        const tail = spawn4("tail", ["-n", "0", "-f", logFilePath], { stdio: ["ignore", "pipe", "pipe"] });
+        const grep = spawn4("grep", ["--line-buffered", "-i", levelFilter], { stdio: ["pipe", "inherit", "inherit"] });
+        if (tail.stdout) tail.stdout.pipe(grep.stdin);
+        await new Promise((resolve12) => {
+          tail.on("exit", () => resolve12());
+          process.once("SIGINT", () => {
+            tail.kill("SIGTERM");
+            grep.kill("SIGTERM");
+            resolve12();
+          });
+        });
+      } else {
+        console.error(`
+  ${pc10.dim("Following... (Ctrl+C to stop)")}
 `);
-      const tail = spawn3("tail", ["-n", "0", "-f", logFilePath], { stdio: "inherit" });
-      await new Promise((resolve8) => {
-        tail.on("exit", () => resolve8());
-        process.once("SIGINT", () => {
-          tail.kill("SIGTERM");
-          resolve8();
+        const tail = spawn4("tail", tailArgs.concat([logFilePath]), { stdio: "inherit" });
+        await new Promise((resolve12) => {
+          tail.on("exit", () => resolve12());
+          process.once("SIGINT", () => {
+            tail.kill("SIGTERM");
+            resolve12();
+          });
         });
-      });
+      }
     }
     console.error();
   } catch (error) {
@@ -3271,7 +3668,7 @@ async function logCommand(args2) {
 
 // src/commands/attach.ts
 import { PortDetector as PortDetector3 } from "@plumpslabs/fennec-core";
-import pc9 from "picocolors";
+import pc11 from "picocolors";
 async function attachCommand(args2) {
   const port = parseInt(args2[0], 10);
   if (isNaN(port)) {
@@ -3289,7 +3686,7 @@ async function attachCommand(args2) {
       spinner.succeed(`Attached to :${port}`);
       console.error(`  ${renderKV("Name", renderAppName(name))}`);
       console.error(`  ${renderKV("PID", String(info.pid))}`);
-      console.error(`  ${renderKV("Command", info.command || pc9.dim("unknown"))}`);
+      console.error(`  ${renderKV("Command", info.command || pc11.dim("unknown"))}`);
     } else {
       spinner.fail(`No process found on port ${port}`);
       process.exit(1);
@@ -3303,35 +3700,35 @@ async function attachCommand(args2) {
 
 // src/commands/sessions.ts
 import { SessionStore } from "@plumpslabs/fennec-core";
-import pc10 from "picocolors";
+import pc12 from "picocolors";
 async function sessionsCommand() {
   const store = new SessionStore("./.fennec/sessions");
   const sessions = store.list();
   if (sessions.length === 0) {
     console.error(`
-  ${pc10.dim("No saved sessions found.")}
+  ${pc12.dim("No saved sessions found.")}
 `);
     return;
   }
   const columns = [
-    { key: "name", label: "Name", format: (v) => pc10.bold(String(v)) },
+    { key: "name", label: "Name", format: (v) => pc12.bold(String(v)) },
     { key: "origin", label: "Origin" },
-    { key: "savedAt", label: "Saved", format: (v) => pc10.dim(String(v)) }
+    { key: "savedAt", label: "Saved", format: (v) => pc12.dim(String(v)) }
   ];
   const rows = sessions.map((s) => ({ name: s.name, origin: s.origin, savedAt: new Date(s.savedAt).toLocaleString() }));
   console.error(`
-  ${symbols.fox} ${pc10.bold("Saved Sessions")}
+  ${symbols.fox} ${pc12.bold("Saved Sessions")}
 `);
   console.error(renderTable(columns, rows));
-  console.error(`  ${pc10.dim(`${sessions.length} session(s)`)}
+  console.error(`  ${pc12.dim(`${sessions.length} session(s)`)}
 `);
 }
 
 // src/commands/setup.ts
-import pc11 from "picocolors";
+import pc13 from "picocolors";
 async function setupCommand() {
   console.error(`
-  ${symbols.fox} ${pc11.bold("Fennec Setup")}
+  ${symbols.fox} ${pc13.bold("Fennec Setup")}
 `);
   const mcpClient = await selectPrompt("Which MCP client are you using?", [
     { value: "claude", label: "Claude Desktop", description: "Anthropic's AI desktop app" },
@@ -3340,12 +3737,12 @@ async function setupCommand() {
     { value: "other", label: "Other MCP client", description: "Any MCP-compatible client" }
   ]);
   if (!mcpClient) {
-    console.error(`  ${pc11.dim("Setup cancelled.")}
+    console.error(`  ${pc13.dim("Setup cancelled.")}
 `);
     return;
   }
   console.error(`
-  ${pc11.green("\u2713")} Selected: ${pc11.bold(mcpClient)}
+  ${pc13.green("\u2713")} Selected: ${pc13.bold(mcpClient)}
 `);
   const configSnippet = `{
   "mcpServers": {
@@ -3355,24 +3752,24 @@ async function setupCommand() {
     }
   }
 }`;
-  console.error(`  ${pc11.bold("Add this to your MCP client config:")}
+  console.error(`  ${pc13.bold("Add this to your MCP client config:")}
 `);
-  console.error(`  ${pc11.dim("```")}`);
+  console.error(`  ${pc13.dim("```")}`);
   console.error(configSnippet.split("\n").map((l) => `  ${l}`).join("\n"));
-  console.error(`  ${pc11.dim("```")}
+  console.error(`  ${pc13.dim("```")}
 `);
-  console.error(`  ${renderSuccess("Setup complete!")} ${pc11.dim("Run")} ${renderCommand("fennec start")} ${pc11.dim("to begin.")}
+  console.error(`  ${renderSuccess("Setup complete!")} ${pc13.dim("Run")} ${renderCommand("fennec start")} ${pc13.dim("to begin.")}
 `);
 }
 
 // src/commands/management.ts
 import { existsSync as existsSync5, writeFileSync as writeFileSync2 } from "fs";
-import { resolve as resolve6 } from "path";
+import { resolve as resolve7 } from "path";
 import { execSync as execSync3 } from "child_process";
-import pc12 from "picocolors";
+import pc14 from "picocolors";
 async function installBrowsersCommand() {
   console.error(`
-  ${pc12.bold("Installing Browser Engines")}
+  ${pc14.bold("Installing Browser Engines")}
 `);
   const spinner = createSpinner("Installing Chromium...");
   try {
@@ -3380,21 +3777,21 @@ async function installBrowsersCommand() {
     spinner.succeed("Chromium installed successfully");
   } catch {
     spinner.fail("Failed to install Chromium");
-    console.error(`  ${pc12.yellow("\u2192")} Try running: ${renderCommand("npx playwright install chromium")}`);
+    console.error(`  ${pc14.yellow("\u2192")} Try running: ${renderCommand("npx playwright install chromium")}`);
   }
   console.error(`
-  ${pc12.green("\u2713")} Browser installation complete.
+  ${pc14.green("\u2713")} Browser installation complete.
 `);
 }
 async function initCommand() {
   console.error(`
-  ${pc12.bold("Initialize Fennec Configuration")}
+  ${pc14.bold("Initialize Fennec Configuration")}
 `);
-  const configFile = resolve6("./fennec.config.yaml");
+  const configFile = resolve7("./fennec.config.yaml");
   if (existsSync5(configFile)) {
-    const overwrite = await confirmPrompt(`${pc12.yellow("fennec.config.yaml")} already exists. Overwrite?`, false);
+    const overwrite = await confirmPrompt(`${pc14.yellow("fennec.config.yaml")} already exists. Overwrite?`, false);
     if (!overwrite) {
-      console.error(`  ${pc12.dim("Cancelled.")}
+      console.error(`  ${pc14.dim("Cancelled.")}
 `);
       return;
     }
@@ -3474,21 +3871,21 @@ logging:
   file: null
 `;
   writeFileSync2(configFile, config, "utf-8");
-  spinner.succeed(`Configuration written to ${pc12.bold(configFile)}`);
+  spinner.succeed(`Configuration written to ${pc14.bold(configFile)}`);
   console.error(`
-  ${pc12.dim("Edit the file to customize Fennec behavior.")}
+  ${pc14.dim("Edit the file to customize Fennec behavior.")}
 `);
 }
 
 // src/commands/health.ts
 import { existsSync as existsSync6, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
 import { execSync as execSync4 } from "child_process";
-import { resolve as resolve7 } from "path";
-import { homedir as homedir5 } from "os";
-import pc13 from "picocolors";
+import { resolve as resolve8 } from "path";
+import { homedir as homedir6 } from "os";
+import pc15 from "picocolors";
 async function healthCommand() {
   printBanner();
-  console.error(`  ${pc13.bold("Fennec Health Check")}
+  console.error(`  ${pc15.bold("Fennec Health Check")}
 `);
   let adbStatus = "unknown";
   try {
@@ -3498,20 +3895,20 @@ async function healthCommand() {
       stdio: ["ignore", "pipe", "pipe"]
     });
     const version = result.split("\n")[0]?.trim() ?? "installed";
-    adbStatus = pc13.green(version);
+    adbStatus = pc15.green(version);
   } catch {
-    adbStatus = pc13.dim("not found") + " (optional)";
+    adbStatus = pc15.dim("not found") + " (optional)";
   }
   const tracked = readTracked();
   const runningCount = tracked.filter((t) => isProcessRunning(t.pid)).length;
-  const logDir = resolve7(homedir5(), ".fennec", "logs");
+  const logDir = resolve8(homedir6(), ".fennec", "logs");
   let logSize = "0 B";
   try {
     if (existsSync6(logDir)) {
       const files = readdirSync2(logDir);
       let totalBytes = 0;
       for (const f of files) {
-        const fStat = statSync2(resolve7(logDir, f));
+        const fStat = statSync2(resolve8(logDir, f));
         totalBytes += fStat.size;
       }
       logSize = totalBytes > 1024 * 1024 ? `${(totalBytes / (1024 * 1024)).toFixed(1)} MB` : `${(totalBytes / 1024).toFixed(1)} KB`;
@@ -3524,7 +3921,7 @@ async function healthCommand() {
     memoryInfo = `${(mem.rss / (1024 * 1024)).toFixed(0)} MB RSS / ${(mem.heapUsed / (1024 * 1024)).toFixed(0)} MB heap`;
   } catch {
   }
-  console.error(`  ${symbols.fox} ${pc13.bold("System")}
+  console.error(`  ${symbols.fox} ${pc15.bold("System")}
 `);
   console.error(`  ${renderKV("Node.js", process.version)}`);
   console.error(`  ${renderKV("Platform", `${process.platform} ${process.arch}`)}`);
@@ -3532,7 +3929,7 @@ async function healthCommand() {
   console.error(`  ${renderKV("ADB", adbStatus)}`);
   console.error(`  ${renderKV("PID", String(process.pid))}`);
   console.error();
-  console.error(`  ${symbols.fox} ${pc13.bold("Processes")}
+  console.error(`  ${symbols.fox} ${pc15.bold("Processes")}
 `);
   console.error(`  ${renderKV("Tracked", String(tracked.length))}`);
   console.error(`  ${renderKV("Running", String(runningCount))}`);
@@ -3540,15 +3937,238 @@ async function healthCommand() {
   console.error();
   const allHealthy = runningCount === tracked.length || tracked.length === 0;
   if (allHealthy) {
-    console.error(`  ${pc13.green("\u2713")} ${pc13.bold("All systems healthy")}
+    console.error(`  ${pc15.green("\u2713")} ${pc15.bold("All systems healthy")}
 `);
   } else {
     const stopped = tracked.length - runningCount;
-    console.error(`  ${pc13.yellow("\u26A0")} ${pc13.bold(`${stopped} process(es) stopped`)}  ${pc13.dim("fennec ps")}
+    console.error(`  ${pc15.yellow("\u26A0")} ${pc15.bold(`${stopped} process(es) stopped`)}  ${pc15.dim("fennec ps")}
 `);
   }
 }
 
+// src/commands/cleanup.ts
+import pc16 from "picocolors";
+async function cleanupCommand() {
+  const tracked = readTracked();
+  if (tracked.length === 0) {
+    console.error(`
+  ${pc16.dim("No tracked processes to clean up.")}
+`);
+    return;
+  }
+  const toRemove = tracked.filter((t) => !isProcessRunning(t.pid) && !t.command);
+  if (toRemove.length === 0) {
+    console.error(`
+  ${pc16.green("\u2713")} ${pc16.bold("All clean")} ${pc16.dim("\u2014 no dead entries without saved commands.")}
+`);
+    return;
+  }
+  console.error(`
+  ${pc16.yellow("\u26A0")} ${pc16.bold(`Found ${toRemove.length} dead entr${toRemove.length > 1 ? "ies" : "y"} without saved commands`)}
+`);
+  for (const entry of toRemove) {
+    console.error(`  ${pc16.dim("\xB7")} ${pc16.bold(entry.name)} ${pc16.dim(`(PID ${entry.pid})`)}`);
+  }
+  console.error();
+  const confirmed = await confirmPrompt(`Remove ${toRemove.length} entr${toRemove.length > 1 ? "ies" : "y"}?`, false);
+  if (!confirmed) {
+    console.error(`  ${pc16.dim("Cancelled")}
+`);
+    return;
+  }
+  const remaining = tracked.filter((t) => !toRemove.includes(t));
+  saveTracked(remaining);
+  console.error(`
+  ${pc16.green("\u2713")} ${pc16.bold(`Removed ${toRemove.length} entr${toRemove.length > 1 ? "ies" : "y"}`)} ${pc16.dim(`(${remaining.length} remaining)`)}
+`);
+}
+
+// src/commands/info.ts
+import pc17 from "picocolors";
+import { resolve as resolve9 } from "path";
+import { homedir as homedir7 } from "os";
+async function infoCommand(args2) {
+  const name = args2[0];
+  if (!name) {
+    console.error(renderError("Missing name", "Usage: fennec info <name>"));
+    process.exit(1);
+  }
+  const tracked = readTracked();
+  const match = tracked.find((t) => t.name === name);
+  if (!match) {
+    console.error(renderError("Not found", `No tracked process named "${name}".`));
+    process.exit(1);
+  }
+  const running = isProcessRunning(match.pid);
+  const statusIcon = running ? pc17.green("\u25CF") : pc17.red("\u25CB");
+  const statusText = running ? pc17.green("running") : pc17.red("stopped");
+  const uptime = running ? formatUptime(Math.floor((Date.now() - new Date(match.startedAt).getTime()) / 1e3)) : "-";
+  const logPath = resolve9(homedir7(), ".fennec", "logs", `${match.name}.log`);
+  console.error(`
+  ${symbols.fox} ${pc17.bold(match.name)} ${pc17.dim("\u2014 Process Info")}
+`);
+  console.error(`  ${renderKVColor("Name", match.name, pc17.bold)}`);
+  console.error(`  ${renderKVColor("Status", `${statusIcon} ${statusText}`)}`);
+  console.error(`  ${renderKVColor("PID", String(match.pid))}`);
+  console.error(`  ${renderKVColor("Port", match.port ? String(match.port) : "-")}`);
+  console.error(`  ${renderKVColor("Command", match.command || pc17.dim("(none)"))}`);
+  if (match.cwd) console.error(`  ${renderKVColor("CWD", match.cwd)}`);
+  console.error(`  ${renderKVColor("Started", new Date(match.startedAt).toLocaleString())}`);
+  console.error(`  ${renderKVColor("Uptime", uptime)}`);
+  console.error(`  ${renderKVColor("Log Path", logPath)}`);
+  if (!running && match.command) {
+    console.error(`
+  ${pc17.dim("Re-spawn with:")} ${pc17.cyan(`fennec spawn ${match.name}`)}`);
+  }
+  console.error();
+}
+
+// src/commands/rename.ts
+import pc18 from "picocolors";
+import { existsSync as existsSync7, renameSync as renameSync2 } from "fs";
+import { resolve as resolve10 } from "path";
+import { homedir as homedir8 } from "os";
+async function renameCommand(args2) {
+  const [oldName, newName] = args2;
+  if (!oldName || !newName) {
+    console.error(renderError("Missing arguments", "Usage: fennec rename <old-name> <new-name>"));
+    process.exit(1);
+  }
+  if (oldName === newName) {
+    console.error(`
+  ${pc18.yellow("\u26A0")} ${pc18.dim("Old and new names are the same.")}
+`);
+    process.exit(0);
+  }
+  const tracked = readTracked();
+  const match = tracked.find((t) => t.name === oldName);
+  if (!match) {
+    console.error(renderError("Not found", `No tracked process named "${oldName}".`));
+    process.exit(1);
+  }
+  if (tracked.some((t) => t.name === newName)) {
+    console.error(renderError("Name taken", `A process named "${newName}" already exists.`));
+    process.exit(1);
+  }
+  console.error(`
+  ${symbols.fox} ${pc18.bold("Rename Process")}
+`);
+  console.error(`  ${renderKVColor("From", oldName)}`);
+  console.error(`  ${renderKVColor("To", newName)}`);
+  if (isProcessRunning(match.pid)) {
+    console.error(`  ${pc18.yellow("\u26A0")} ${pc18.dim("Process is still running \u2014 log entries will go to the old file until stopped.")}`);
+  }
+  console.error();
+  const confirmed = await confirmPrompt(`Rename ${pc18.bold(oldName)} ${pc18.dim("\u2192")} ${pc18.bold(newName)}?`, true);
+  if (!confirmed) {
+    console.error(`  ${pc18.dim("Cancelled")}
+`);
+    return;
+  }
+  const spinner = createSpinner(`Renaming ${oldName} \u2192 ${newName}...`);
+  const logDir = resolve10(homedir8(), ".fennec", "logs");
+  const oldLog = resolve10(logDir, `${oldName}.log`);
+  const newLog = resolve10(logDir, `${newName}.log`);
+  if (existsSync7(oldLog) && !existsSync7(newLog)) {
+    try {
+      renameSync2(oldLog, newLog);
+    } catch {
+    }
+  }
+  match.name = newName;
+  saveTracked(tracked);
+  spinner.succeed(`${pc18.bold(oldName)} ${pc18.dim("\u2192")} ${pc18.bold(newName)}`);
+  console.error();
+}
+
+// src/commands/export-import.ts
+import pc19 from "picocolors";
+import { existsSync as existsSync8, writeFileSync as writeFileSync3, readFileSync as readFileSync4 } from "fs";
+import { resolve as resolve11 } from "path";
+async function exportCommand(args2) {
+  const tracked = readTracked();
+  const fileIndex = args2.indexOf("--file");
+  const filePath = fileIndex !== -1 ? args2[fileIndex + 1] : void 0;
+  if (fileIndex !== -1 && !filePath) {
+    console.error(renderError("Missing file path", "Usage: fennec export --file <path>"));
+    process.exit(1);
+  }
+  if (tracked.length === 0) {
+    console.error(`
+  ${pc19.dim("No tracked processes to export.")}
+`);
+    return;
+  }
+  const json = JSON.stringify(tracked, null, 2);
+  if (filePath) {
+    try {
+      writeFileSync3(resolve11(filePath), json, "utf-8");
+      console.error(`
+  ${pc19.green("\u2713")} ${pc19.bold(`Exported ${tracked.length} process(es)`)} ${pc19.dim(`\u2192 ${filePath}`)}
+`);
+    } catch (err) {
+      console.error(renderError("Export failed", String(err)));
+      process.exit(1);
+    }
+  } else {
+    console.log(json);
+  }
+}
+async function importCommand(args2) {
+  const filePath = args2[0];
+  if (!filePath) {
+    console.error(renderError("Missing file", "Usage: fennec import <file>"));
+    process.exit(1);
+  }
+  const resolvedPath = resolve11(filePath);
+  if (!existsSync8(resolvedPath)) {
+    console.error(renderError("File not found", `"${filePath}" does not exist.`));
+    process.exit(1);
+  }
+  let imported;
+  try {
+    imported = JSON.parse(readFileSync4(resolvedPath, "utf-8"));
+    if (!Array.isArray(imported) || imported.length === 0) {
+      console.error(renderError("Invalid file", "File must contain a non-empty JSON array of process objects."));
+      process.exit(1);
+    }
+  } catch (err) {
+    console.error(renderError("Invalid JSON", String(err)));
+    process.exit(1);
+  }
+  const existing = readTracked();
+  console.error(`
+  ${symbols.fox} ${pc19.bold("Import Processes")}
+`);
+  console.error(`  ${renderKVColor("File", resolvedPath)}`);
+  console.error(`  ${renderKVColor("Importing", `${imported.length} process(es)`)}`);
+  console.error(`  ${renderKVColor("Existing", `${existing.length} process(es)`)}`);
+  console.error(`
+  ${pc19.bold("Processes to import:")}`);
+  for (const p of imported) {
+    console.error(`  ${pc19.green("+")} ${pc19.bold(p.name)} ${pc19.dim(`(${p.command})`)}`);
+  }
+  console.error();
+  const confirmed = await confirmPrompt("Merge into tracked.json? Existing processes with the same name will be overwritten.", true);
+  if (!confirmed) {
+    console.error(`  ${pc19.dim("Cancelled")}
+`);
+    return;
+  }
+  const merged = [...existing];
+  for (const proc of imported) {
+    const idx = merged.findIndex((t) => t.name === proc.name);
+    if (idx !== -1) {
+      merged[idx] = { ...merged[idx], ...proc };
+    } else {
+      merged.push(proc);
+    }
+  }
+  saveTracked(merged);
+  console.error(`  ${pc19.green("\u2713")} ${pc19.bold(`Imported ${imported.length} process(es)`)} ${pc19.dim(`(${merged.length} total)`)}
+`);
+}
+
 // src/index.ts
 var [, , command, ...args] = process.argv;
 async function main() {
@@ -3568,10 +4188,26 @@ async function main() {
     await statusCommand(args);
   } else if (command === "log") {
     await logCommand(args);
+  } else if (command === "spawn") {
+    await spawnCommand(args);
+  } else if (command === "stop") {
+    await stopCommand(args);
   } else if (command === "kill") {
     await killCommand(args);
   } else if (command === "restart") {
     await restartCommand(args);
+  } else if (command === "info") {
+    printBanner();
+    await infoCommand(args);
+  } else if (command === "cleanup") {
+    printBanner();
+    await cleanupCommand();
+  } else if (command === "rename") {
+    await renameCommand(args);
+  } else if (command === "export") {
+    await exportCommand(args);
+  } else if (command === "import") {
+    await importCommand(args);
   } else if (command === "attach") {
     await attachCommand(args);
   } else if (command === "pipe") {