agent-session-kill 0.1.0

package/src/format.js

@@ -0,0 +1,114 @@
+import chalk from "chalk";
+
+const ANSI_ESCAPE_PATTERN = /\u001b\[[0-9;]*m/g;
+
+function normalizeResults(input) {
+  if (Array.isArray(input)) {
+    return { entries: input, errors: [] };
+  }
+
+  return {
+    entries: Array.isArray(input?.entries) ? input.entries : [],
+    errors: Array.isArray(input?.errors) ? input.errors : [],
+  };
+}
+
+export function decorateEntry(entry) {
+  const protectedRow = Boolean(entry.protected);
+  const cacheRisk = entry.category === "cache";
+  const delegateRisk = entry.action === "delegate";
+  const risk = protectedRow ? "protected" : delegateRisk ? "delegate" : cacheRisk ? "cache" : "none";
+
+  return {
+    ...entry,
+    selectable: !protectedRow && (entry.action === "trash" || entry.action === "delete"),
+    risk,
+  };
+}
+
+export function decorateResults(input) {
+  const results = normalizeResults(input);
+  return { ...results, entries: results.entries.map(decorateEntry) };
+}
+
+function colorAction(value, color) {
+  if (!color) return value;
+  if (value === "trash") return chalk.yellow(value);
+  if (value === "delete") return chalk.red(value);
+  if (value === "keep") return chalk.dim(value);
+  if (value === "delegate") return chalk.cyan(value);
+  return value;
+}
+
+function colorRisk(value, color) {
+  if (!color) return value;
+  if (value === "protected") return chalk.red(value);
+  if (value === "delegate") return chalk.cyan(value);
+  if (value === "cache") return chalk.yellow(value);
+  if (value === "none") return chalk.dim(value);
+  return value;
+}
+
+function valueFor(entry, column, color) {
+  if (column.key === "modified") {
+    return Number.isFinite(entry.modifiedMs) ? new Date(entry.modifiedMs).toISOString() : "";
+  }
+
+  if (column.key === "action") {
+    return colorAction(String(entry.action ?? ""), color);
+  }
+
+  if (column.key === "risk") {
+    return colorRisk(String(entry.risk ?? ""), color);
+  }
+
+  const value = entry[column.key];
+  return value === undefined || value === null ? "" : String(value);
+}
+
+function visibleLength(value) {
+  return value.replace(ANSI_ESCAPE_PATTERN, "").length;
+}
+
+export function formatTable(input, { color } = {}) {
+  const results = decorateResults(input);
+  const useColor = color !== false;
+  const columns = [
+    { key: "tool", label: "Tool" },
+    { key: "category", label: "Category" },
+    { key: "action", label: "Action" },
+    { key: "risk", label: "Risk" },
+    { key: "sizeBytes", label: "Bytes" },
+    { key: "modified", label: "Modified" },
+    { key: "path", label: "Path" },
+    { key: "reason", label: "Reason" },
+  ];
+
+  const rows = results.entries.map((entry) => columns.map((column) => valueFor(entry, column, useColor)));
+  const widths = columns.map((column, index) =>
+    Math.max(column.label.length, ...rows.map((row) => visibleLength(row[index]))),
+  );
+
+  const renderRow = (cells) =>
+    cells
+      .map((cell, index) => `${cell}${" ".repeat(Math.max(0, widths[index] - visibleLength(cell)))}`)
+      .join("  ")
+      .trimEnd();
+
+  const lines = [
+    renderRow(columns.map((column) => column.label)),
+    renderRow(widths.map((width) => "-".repeat(width))),
+    ...rows.map(renderRow),
+  ];
+
+  if (results.errors.length > 0) {
+    lines.push("", "Errors:", ...results.errors.map((error) => `- ${error}`));
+  }
+
+  return lines.join("\n");
+}
+
+export function formatJson(entries) {
+  return `${JSON.stringify(normalizeResults(entries), null, 2)}\n`;
+}
+

package/src/interactive.js

@@ -0,0 +1,215 @@
+import process from "node:process";
+import readline from "node:readline";
+import chalk from "chalk";
+import { scanRemnants } from "./scanner.js";
+import { applyManifest } from "./apply.js";
+import { createTuiState, handleTuiKey, selectedRows, visibleRows } from "./tui-state.js";
+
+function formatBytes(value) {
+  const size = Number.isFinite(value) ? Math.max(0, value) : 0;
+  if (size < 1024) return `${size} B`;
+  if (size < 1024 ** 2) return `${(size / 1024).toFixed(1)} KB`;
+  if (size < 1024 ** 3) return `${(size / (1024 ** 2)).toFixed(1)} MB`;
+  return `${(size / (1024 ** 3)).toFixed(1)} GB`;
+}
+
+function colorAction(action) {
+  if (action === "delete") return chalk.red(action);
+  if (action === "trash") return chalk.yellow(action);
+  if (action === "delegate") return chalk.cyan(action);
+  return chalk.dim(action);
+}
+
+function colorRisk(risk) {
+  if (risk === "protected") return chalk.red(risk);
+  if (risk === "cache") return chalk.yellow(risk);
+  if (risk === "delegate") return chalk.cyan(risk);
+  return chalk.dim(risk);
+}
+
+function renderRow(row, active, selected) {
+  const pointer = active ? chalk.cyan("›") : " ";
+  const marker = selected ? chalk.green("●") : row.selectable ? "○" : "·";
+  const tool = String(row.tool ?? "").padEnd(6);
+  const category = String(row.category ?? "").padEnd(16);
+  const actionText = colorAction(String(row.action ?? "")).padEnd(8);
+  const size = formatBytes(row.sizeBytes).padStart(9);
+  const risk = colorRisk(String(row.risk ?? "none")).padEnd(9);
+  const line = `${pointer} ${marker} ${tool} ${category} ${actionText} ${size} ${risk} ${row.path ?? ""}`;
+
+  return row.selectable ? line : chalk.dim(line);
+}
+
+function render(state, io) {
+  const rows = visibleRows(state);
+  const windowSize = 20;
+  const start = Math.max(0, Math.min(state.cursor - Math.floor(windowSize / 2), Math.max(0, rows.length - windowSize)));
+  const end = Math.min(rows.length, start + windowSize);
+
+  io.stdout.write("\x1b[2J\x1b[H");
+  io.stdout.write(`${chalk.bold("Agent Session Kill")}\n`);
+  io.stdout.write(`${chalk.dim("↑/↓ j/k move · space toggle · a all · d/delete apply selected · r rescan · q/esc quit")}\n\n`);
+
+  if (rows.length === 0) {
+    io.stdout.write(`${chalk.dim("No rows match the current filter.")}\n`);
+  } else {
+    for (let index = start; index < end; index += 1) {
+      const row = rows[index];
+      io.stdout.write(`${renderRow(row, index === state.cursor, state.selected.has(row.path))}\n`);
+    }
+  }
+
+  io.stdout.write(`\nSelected: ${selectedRows(state).length} / ${rows.filter((row) => row.selectable).length}\n`);
+}
+
+async function confirmDelete(rows, io) {
+  io.stdout.write("\nSelected paths:\n");
+  for (const row of rows) {
+    io.stdout.write(`- ${row.path}\n`);
+  }
+  io.stdout.write("Type delete to confirm: ");
+
+  return await new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: io.stdin,
+      output: io.stdout,
+      terminal: Boolean(io.stdin?.isTTY && io.stdout?.isTTY),
+    });
+
+    rl.question("", (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase() === "delete");
+    });
+  });
+}
+
+function asScanOptions(options) {
+  return {
+    homeDir: options.homeDir,
+    tempDir: options.tempDir,
+    nowMs: Date.now(),
+    olderThanMs: options.olderThanMs,
+    includeCache: options.includeCache,
+    apply: false,
+    permanent: options.permanent,
+    tools: options.tools,
+  };
+}
+
+function maybeSetRawMode(input, value) {
+  if (input?.isTTY && typeof input.setRawMode === "function") {
+    input.setRawMode(value);
+    return true;
+  }
+
+  return false;
+}
+
+export async function runInteractive(
+  options,
+  io = { stdin: process.stdin, stdout: process.stdout, stderr: process.stderr },
+) {
+  const streams = {
+    stdin: io.stdin ?? process.stdin,
+    stdout: io.stdout ?? process.stdout,
+    stderr: io.stderr ?? process.stderr,
+  };
+
+  let scan = await scanRemnants(asScanOptions(options));
+  let state = createTuiState(scan.entries);
+
+  let rawModeEnabled = false;
+  let busy = false;
+
+  try {
+    readline.emitKeypressEvents(streams.stdin);
+    if (typeof streams.stdin.resume === "function") {
+      streams.stdin.resume();
+    }
+
+    rawModeEnabled = maybeSetRawMode(streams.stdin, true);
+    render(state, streams);
+  } catch (error) {
+    if (rawModeEnabled) {
+      maybeSetRawMode(streams.stdin, false);
+    }
+    throw error;
+  }
+
+  return await new Promise((resolve) => {
+    const finish = (code) => {
+      if (rawModeEnabled) {
+        maybeSetRawMode(streams.stdin, false);
+      }
+      streams.stdin.off("keypress", onKeypress);
+      resolve(code);
+    };
+
+    const onKeypress = async (_chunk, key = {}) => {
+      if (busy) return;
+      busy = true;
+
+      try {
+        state = handleTuiKey(state, key);
+
+        if (state.intent === "quit") {
+          finish(0);
+          return;
+        }
+
+        if (state.intent === "rescan") {
+          scan = await scanRemnants(asScanOptions(options));
+          state = createTuiState(scan.entries);
+          render(state, streams);
+          return;
+        }
+
+        if (state.intent === "delete-selected") {
+          const rows = selectedRows(state);
+          if (rows.length === 0) {
+            render(state, streams);
+            return;
+          }
+
+          if (rawModeEnabled) {
+            maybeSetRawMode(streams.stdin, false);
+            rawModeEnabled = false;
+          }
+
+          const confirmed = await confirmDelete(rows, streams);
+          if (!confirmed) {
+            rawModeEnabled = maybeSetRawMode(streams.stdin, true);
+            state = { ...state, intent: "none" };
+            render(state, streams);
+            return;
+          }
+
+          const applyResult = await applyManifest({ entries: rows, errors: [] }, {
+            homeDir: options.homeDir,
+            permanent: options.permanent,
+          });
+
+          if (applyResult.errors.length > 0) {
+            for (const error of applyResult.errors) {
+              streams.stderr.write(`${error}\n`);
+            }
+            finish(1);
+            return;
+          }
+
+          finish(0);
+          return;
+        }
+
+        render(state, streams);
+      } catch (error) {
+        streams.stderr.write(`${error.message}\n`);
+        finish(1);
+      } finally {
+        busy = false;
+      }
+    };
+
+    streams.stdin.on("keypress", onKeypress);
+  });
+}

package/src/protection.js

@@ -0,0 +1,141 @@
+import path from "node:path";
+
+const PROTECTED_ROOT_NAMES = new Set([
+  "plugins",
+  "skills",
+  "agents",
+  "commands",
+  "managed-skills",
+  "memories",
+  "model",
+  "models",
+  "mcp",
+  "npm",
+  "projects",
+]);
+
+const PROTECTED_FILE_PATTERNS = [
+  /^auth\b/i,
+  /^settings\b/i,
+  /^config\b/i,
+  /^model(s)?\b/i,
+  /^mcp\b/i,
+];
+
+function absolute(input) {
+  return path.resolve(input);
+}
+
+function isInside(candidate, root) {
+  if (!root) {
+    return false;
+  }
+
+  const relative = path.relative(absolute(root), absolute(candidate));
+  return relative === "" || (relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative));
+}
+
+function firstSegment(candidate, root) {
+  if (!isInside(candidate, root)) {
+    return undefined;
+  }
+
+  const relative = path.relative(absolute(root), absolute(candidate));
+  return relative.split(path.sep)[0];
+}
+
+function basename(candidate) {
+  return path.basename(absolute(candidate));
+}
+
+function matchesProtectedFile(candidate) {
+  const name = basename(candidate);
+  return PROTECTED_FILE_PATTERNS.some((pattern) => pattern.test(name));
+}
+
+function isProtectedUnderRoot(candidate, root) {
+  const segment = firstSegment(candidate, root);
+  if (!segment) {
+    return false;
+  }
+
+  return PROTECTED_ROOT_NAMES.has(segment) || matchesProtectedFile(candidate);
+}
+
+function classifyRemnant(candidate, roots) {
+  const remnantRoots = [
+    [roots.claudeDir, "session-env", "session-env"],
+    [roots.claudeDir, "tasks", "tasks"],
+    [roots.claudeDir, "todos", "todos"],
+    [roots.piAgentDir, "sessions", "sessions"],
+    [roots.ompAgentDir, "sessions", "sessions"],
+  ];
+
+  for (const [root, segment, category] of remnantRoots) {
+    if (isInside(candidate, path.join(root, segment))) {
+      return category;
+    }
+  }
+
+  if (isPiSubagentsAsync(candidate, roots.tempDir)) {
+    return "pi-subagents-async";
+  }
+
+  return undefined;
+}
+
+function isPiSubagentsAsync(candidate, tempDir) {
+  if (!isInside(candidate, tempDir)) {
+    return false;
+  }
+
+  const relative = path.relative(absolute(tempDir), absolute(candidate));
+  const parts = relative.split(path.sep);
+  return parts[0]?.startsWith("pi-subagents-") && parts[1] === "async-subagent-runs";
+}
+
+function isCachePath(candidate, roots) {
+  return [
+    path.join(roots.claudeDir, "cache"),
+    path.join(roots.piAgentDir, "cache"),
+    path.join(roots.ompDir, "cache"),
+    path.join(roots.ompAgentDir, "cache"),
+  ].some((root) => isInside(candidate, root));
+}
+
+export function isProtectedPath(candidate, roots) {
+  if (absolute(candidate) === path.join(absolute(roots.homeDir), ".claude.json")) {
+    return true;
+  }
+
+  if (classifyRemnant(candidate, roots)) {
+    return false;
+  }
+
+  return [roots.claudeDir, roots.piAgentDir, roots.ompAgentDir].some((root) => isProtectedUnderRoot(candidate, root));
+}
+
+export function classifyPath(candidate, roots, includeCache) {
+  const remnantCategory = classifyRemnant(candidate, roots);
+  if (remnantCategory) {
+    return {
+      category: remnantCategory,
+      cache: false,
+      protected: false,
+    };
+  }
+
+  if (isCachePath(candidate, roots)) {
+    return {
+      category: "cache",
+      cache: true,
+      protected: !includeCache,
+    };
+  }
+
+  return {
+    category: "unknown",
+    cache: false,
+    protected: isProtectedPath(candidate, roots),
+  };
+}

package/src/scanner.js

@@ -0,0 +1,217 @@
+import { lstat, readdir } from "node:fs/promises";
+import path from "node:path";
+import { isOlderThan } from "./age.js";
+import { classifyPath, isProtectedPath } from "./protection.js";
+
+function buildRoots(options) {
+  const homeDir = path.resolve(options.homeDir);
+  const tempDir = path.resolve(options.tempDir);
+  const claudeDir = path.join(homeDir, ".claude");
+  const piAgentDir = path.join(homeDir, ".pi", "agent");
+  const ompDir = path.join(homeDir, ".omp");
+  const ompAgentDir = path.join(ompDir, "agent");
+
+  return {
+    homeDir,
+    tempDir,
+    claudeDir,
+    piAgentDir,
+    ompDir,
+    ompAgentDir,
+  };
+}
+
+function selected(options, tool) {
+  return !options.tools || options.tools.has(tool);
+}
+
+function staticCandidates(options, roots) {
+  const candidates = [];
+
+  if (selected(options, "claude")) {
+    for (const category of ["session-env", "tasks", "todos", "plans", "debug", "cache", "paste-cache", "shell-snapshots", "backups"]) {
+      candidates.push({ tool: "claude", category, root: path.join(roots.claudeDir, category) });
+    }
+  }
+
+  if (selected(options, "pi")) {
+    candidates.push(
+      { tool: "pi", category: "sessions", root: path.join(roots.piAgentDir, "sessions") },
+      { tool: "pi", category: "tmp", root: path.join(roots.piAgentDir, "tmp") },
+      { tool: "pi", category: "session-search-index", root: path.join(roots.homeDir, ".pi", "session-search", "index") },
+      { tool: "pi", category: "cache", root: path.join(roots.piAgentDir, "cache") },
+    );
+  }
+
+  if (selected(options, "omp")) {
+    candidates.push(
+      { tool: "omp", category: "sessions", root: path.join(roots.ompAgentDir, "sessions") },
+      { tool: "omp", category: "terminal-sessions", root: path.join(roots.ompAgentDir, "terminal-sessions") },
+      { tool: "omp", category: "logs", root: path.join(roots.ompDir, "logs") },
+      { tool: "omp", category: "blobs", root: path.join(roots.ompAgentDir, "blobs") },
+      { tool: "omp", category: "cache", root: path.join(roots.ompDir, "cache") },
+      { tool: "omp", category: "cache", root: path.join(roots.ompAgentDir, "cache") },
+    );
+  }
+
+  return candidates;
+}
+
+async function tempCandidates(options, roots, errors) {
+  if (!selected(options, "temp")) {
+    return [];
+  }
+
+  let dirents;
+  try {
+    dirents = await readdir(roots.tempDir, { withFileTypes: true });
+  } catch (error) {
+    if (error?.code !== "ENOENT") {
+      errors.push(`Failed to read ${roots.tempDir}: ${error.message}`);
+    }
+    return [];
+  }
+
+  const candidates = [];
+  for (const dirent of dirents) {
+    if (!dirent.isDirectory() || dirent.isSymbolicLink() || !dirent.name.startsWith("pi-subagents-")) {
+      continue;
+    }
+
+    const root = path.join(roots.tempDir, dirent.name);
+    candidates.push(
+      { tool: "temp", category: "pi-subagents-chain", root: path.join(root, "chain-runs") },
+      { tool: "temp", category: "pi-subagents-async", root: path.join(root, "async-subagent-runs") },
+    );
+  }
+
+  return candidates;
+}
+
+function reasonFor({ cacheOptOut, protectedPath, oldEnough }) {
+  if (cacheOptOut) {
+    return "cache cleanup opt-out";
+  }
+
+  if (protectedPath) {
+    return "protected path";
+  }
+
+  if (!oldEnough) {
+    return "younger than threshold";
+  }
+
+  return "older than threshold";
+}
+
+function entryFor(filePath, stats, candidate, roots, options) {
+  const classification = classifyPath(filePath, roots, options.includeCache);
+  const cacheOptOut = classification.cache && !options.includeCache;
+  const protectedPath = classification.protected || isProtectedPath(filePath, roots);
+  const oldEnough = isOlderThan(stats.mtimeMs, options.nowMs, options.olderThanMs);
+  const action = protectedPath || cacheOptOut || !oldEnough ? "keep" : options.permanent ? "delete" : "trash";
+
+  return {
+    tool: candidate.tool,
+    category: classification.category === "unknown" ? candidate.category : classification.category,
+    path: filePath,
+    type: "file",
+    sizeBytes: stats.size,
+    modifiedMs: stats.mtimeMs,
+    action,
+    reason: reasonFor({ cacheOptOut, protectedPath, oldEnough }),
+    protected: protectedPath,
+  };
+}
+
+async function walkCandidate(candidate, roots, options, entries, errors) {
+  let stats;
+  try {
+    stats = await lstat(candidate.root);
+  } catch (error) {
+    if (error?.code !== "ENOENT") {
+      errors.push(`Failed to stat ${candidate.root}: ${error.message}`);
+    }
+    return;
+  }
+
+  if (stats.isSymbolicLink()) {
+    return;
+  }
+
+  if (stats.isFile()) {
+    entries.push(entryFor(candidate.root, stats, candidate, roots, options));
+    return;
+  }
+
+  if (!stats.isDirectory()) {
+    return;
+  }
+
+  await walkDirectory(candidate.root, candidate, roots, options, entries, errors);
+}
+
+async function walkDirectory(directory, candidate, roots, options, entries, errors) {
+  let dirents;
+  try {
+    dirents = await readdir(directory, { withFileTypes: true });
+  } catch (error) {
+    errors.push(`Failed to read ${directory}: ${error.message}`);
+    return;
+  }
+
+  dirents.sort((a, b) => a.name.localeCompare(b.name));
+
+  for (const dirent of dirents) {
+    const childPath = path.join(directory, dirent.name);
+
+    if (dirent.isSymbolicLink()) {
+      continue;
+    }
+
+    if (dirent.isDirectory()) {
+      await walkDirectory(childPath, candidate, roots, options, entries, errors);
+      continue;
+    }
+
+    if (!dirent.isFile()) {
+      continue;
+    }
+
+    let stats;
+    try {
+      stats = await lstat(childPath);
+    } catch (error) {
+      errors.push(`Failed to stat ${childPath}: ${error.message}`);
+      continue;
+    }
+
+    if (!stats.isSymbolicLink() && stats.isFile()) {
+      entries.push(entryFor(childPath, stats, candidate, roots, options));
+    }
+  }
+}
+
+export async function scanRemnants(options) {
+  const roots = buildRoots(options);
+  const errors = [];
+  const entries = [];
+  const candidates = [
+    ...staticCandidates(options, roots),
+    ...(await tempCandidates(options, roots, errors)),
+  ];
+
+  for (const candidate of candidates) {
+    await walkCandidate(candidate, roots, options, entries, errors);
+  }
+
+  entries.sort((a, b) => a.path.localeCompare(b.path));
+
+  const result = { entries, errors };
+  Object.defineProperty(result, "find", {
+    value: entries.find.bind(entries),
+    enumerable: false,
+  });
+
+  return result;
+}