reslop 0.2.5 → 0.2.6

package/lib/session/npm.js

@@ -1,469 +1,452 @@
 'use strict';
 
+const metautil = require('metautil');
+const { bytesToSize } = metautil;
 const commands = require('../npm-commands.js');
 const npm = require('../render/npm.js');
-const { logViewRows } = npm;
-
-const { listCommands, reduceOutput, writeLog } = commands;
-const { staleLogFiles, removeStaleLogs, formatSize } = commands;
+const { logViewRows, expandLogLines } = npm;
+const ansi = require('../ansi.js');
+const { stripAnsi } = ansi;
+const reportParse = require('../report-parse.js');
+const { buildDocument } = reportParse;
+const reportRender = require('../report-render.js');
+const { renderDocument, loggedText } = reportRender;
+const reportView = require('../render/report.js');
+const { renderReport } = reportView;
+
+const { listCommands, reduceOutput, nextLogFile, saveLogs } = commands;
+const { staleLogFiles, removeStaleLogs, startNpm } = commands;
 const { saveScript, removeScript, reorderScript } = commands;
 
 const NAME_RE = /^[\w:.-]+$/;
-const { startNpm } = commands;
-
-const selected = (api) => {
-  const cursor = api.ui.nav.npmCursor;
-  return api.state.commands[cursor];
+const TESTS_RE = /^(?:TAP version \d+|\s*(?:not )?ok\b|[ℹi]\s+tests\s+\d+)/m;
+
+const logRowCount = (text, width, running) => {
+  const visual = width > 0 ? expandLogLines(text, width).length : 0;
+  const extra = running ? 1 : 0;
+  if (visual) return visual + extra;
+  const lines = `${text ?? ''}`.split('\n');
+  const count = lines.at(-1) === '' ? lines.length - 1 : lines.length;
+  return count + extra;
+};
+
+const filteredOutput = (raw, root, status, rawFile) => {
+  const text = stripAnsi(`${raw ?? ''}`);
+  if (status === '' || !TESTS_RE.test(text)) {
+    const output = reduceOutput(raw, root, status);
+    return { output, log: output };
+  }
+  const doc = buildDocument(raw, '', root, status, 'test');
+  return { output: renderReport(doc), log: renderDocument(doc, rawFile) };
 };
 
-const clampCursor = (api) => {
-  const last = api.state.commands.length - 1;
-  const nav = api.ui.nav;
-  if (nav.npmCursor > last) nav.npmCursor = Math.max(0, last);
-  if (nav.npmCursor < 0) nav.npmCursor = 0;
-};
+const runLabel = (entry) =>
+  entry.kind === 'bin' ? `npm exec ${entry.name}` : `npm run ${entry.name}`;
 
-const refresh = (api) => {
-  api.state.commands = listCommands(api.ui.top);
-  clampCursor(api);
+const withNotice = (text, notice) => {
+  const body = `${text ?? ''}`;
+  if (body.endsWith(`${notice}\n`)) return body;
+  if (!body) return `${notice}\n`;
+  if (body.endsWith('\n')) return `${body}${notice}\n`;
+  return `${body}\n${notice}\n`;
 };
 
-const canEdit = (ui) => {
-  if (ui.capabilities && ui.capabilities.changes === false) return false;
-  if (ui.readOnly) return false;
-  return true;
+const withNewline = (text) => {
+  const body = `${text ?? ''}`;
+  if (!body || body.endsWith('\n')) return body;
+  return `${body}\n`;
 };
 
-const refreshLogs = (api) => {
-  try {
-    const found = staleLogFiles(api.ui.top);
-    api.state.logBytes = found.bytes;
-  } catch (error) {
-    api.state.logBytes = 0;
-    api.ui.status = error.message;
+class NpmController {
+  constructor(ui) {
+    this.ui = ui;
+    this.child = null;
+    this.running = false;
+    this.reset();
   }
-};
-
-const open = (api) => {
-  if (api.ui.mode === 'compose') return;
-  refresh(api);
-  refreshLogs(api);
-  api.state.viewing = false;
-  api.state.output = '';
-  const nav = api.ui.nav;
-  nav.pane = 'npm';
-  nav.resetListScroll('npm');
-  api.ui.status = '';
-  nav.clearSelection();
-};
 
-const scrollLog = (api, delta) => {
-  const lines = api.state.output.split('\n');
-  let count = lines.at(-1) === '' ? lines.length - 1 : lines.length;
-  if (api.state.running) count += 1;
-  const frame = api.ui.lastFrame;
-  const bodyH = frame && frame.bodyH ? frame.bodyH : 1;
-  const max = Math.max(0, count - logViewRows(bodyH));
-  let start = api.state.followEnd ? max : api.state.logScroll;
-  start = Math.min(max, Math.max(0, start + delta));
-  api.state.followEnd = start === max;
-  api.state.logScroll = start;
-};
+  reset() {
+    if (this.child) this.child.kill();
+    this.stopRun();
+    this.commands = [];
+    this.viewing = false;
+    this.output = '';
+    this.followEnd = true;
+    this.logScroll = 0;
+    this.editName = '';
+    this.editField = '';
+    this.draftName = '';
+    this.draftCommand = '';
+    this.verbose = false;
+    this.raw = '';
+    this.exitStatus = '';
+    this.dropName = '';
+    this.dropKind = '';
+    this.logBytes = 0;
+    this.stopping = false;
+    this.runLabel = '';
+    this.startedAt = 0;
+    this.endedAt = 0;
+  }
 
-const move = (api, delta) => {
-  if (api.state.viewing) return void scrollLog(api, delta);
-  if (!api.state.commands.length) return;
-  const nav = api.ui.nav;
-  const last = api.state.commands.length - 1;
-  const next = Math.min(last, Math.max(0, nav.npmCursor + delta));
-  if (next === nav.npmCursor) return;
-  nav.npmCursor = next;
-  api.ui.status = '';
-};
+  get logLabel() {
+    if (!this.logBytes) return '';
+    return `old logs ${bytesToSize(this.logBytes)}`;
+  }
 
-const stopRun = (api) => {
-  api.state.running = false;
-  api.state.child = null;
-  api.ui.progress.stop('npm');
-};
+  get lastRun() {
+    if (!this.startedAt) return null;
+    return {
+      label: this.runLabel,
+      running: this.running,
+      exit: this.exitStatus,
+      startedAt: this.startedAt,
+      endedAt: this.endedAt,
+    };
+  }
 
-const shownOutput = (api, raw, status) => {
-  if (!api.state.verbose) return reduceOutput(raw, api.ui.top, status);
-  const text = `${raw ?? ''}`;
-  if (!text) return '';
-  if (text.endsWith('\n')) return text;
-  return `${text}\n`;
-};
+  selected() {
+    return this.commands[this.ui.nav.npmCursor];
+  }
 
-const showOutput = (api, text) => {
-  if (!api.state.viewing || !api.state.running) return;
-  if (api.state.stopping) return;
-  api.state.raw = text;
-  api.state.output = shownOutput(api, text, '');
-  api.ui.paint();
-};
+  refresh() {
+    this.commands = listCommands(this.ui.top);
+    const last = this.commands.length - 1;
+    const nav = this.ui.nav;
+    nav.npmCursor = Math.max(0, Math.min(nav.npmCursor, last));
+  }
 
-const withNotice = (text, notice) => {
-  const body = `${text ?? ''}`;
-  if (body.endsWith(`${notice}\n`)) return body;
-  if (!body) return `${notice}\n`;
-  if (body.endsWith('\n')) return `${body}${notice}\n`;
-  return `${body}\n${notice}\n`;
-};
+  refreshLogs() {
+    try {
+      this.logBytes = staleLogFiles(this.ui.top).bytes;
+    } catch (error) {
+      this.logBytes = 0;
+      this.ui.status = error.message;
+    }
+  }
 
-const finishRun = (api, entry, result) => {
-  const stopped = api.state.stopping === true;
-  const raw = stopped ? withNotice(api.state.raw, 'terminated') : result.text;
-  const reduced = stopped
-    ? withNotice(reduceOutput(api.state.raw, api.ui.top, ''), 'terminated')
-    : reduceOutput(result.text, api.ui.top, result.status);
-  api.state.raw = raw;
-  api.state.exitStatus = stopped ? '' : result.status;
-  api.state.output = api.state.verbose ? shownOutput(api, raw, '') : reduced;
-  api.state.stopping = false;
-  stopRun(api);
-  try {
-    writeLog(api.ui.top, entry.name, reduced);
-  } catch (error) {
-    api.ui.status = error.message;
-    api.ui.paint();
-    return;
-  }
-  if (stopped && api.state.viewing) api.ui.status = 'terminated';
-  api.ui.paint();
-};
+  open() {
+    if (this.ui.mode === 'compose') return;
+    this.refresh();
+    this.refreshLogs();
+    this.viewing = false;
+    this.output = '';
+    const nav = this.ui.nav;
+    nav.pane = 'npm';
+    nav.resetListScroll('npm');
+    this.ui.status = '';
+    nav.clearSelection();
+  }
 
-const startRun = (api, entry) => {
-  api.state.output = '';
-  api.state.raw = '';
-  api.state.exitStatus = '';
-  api.state.viewing = true;
-  api.state.followEnd = true;
-  api.state.logScroll = 0;
-  api.state.running = true;
-  api.state.stopping = false;
-  api.ui.status = '';
-  api.ui.progress.start('npm');
-  const runner = api.ui.repo && api.ui.repo.runNpmCommand;
-  const start = typeof runner === 'function' ? runner : startNpm;
-  const child = start(
-    api.ui.top,
-    entry,
-    (text) => showOutput(api, text),
-    (result) => finishRun(api, entry, result),
-  );
-  if (api.state.running) api.state.child = child;
-  api.ui.paint();
-};
+  scrollLog(delta) {
+    const { lastFrame, lastSize } = this.ui;
+    const width = lastSize && lastSize.width ? lastSize.width : 0;
+    const count = logRowCount(this.output, width, this.running);
+    const bodyH = lastFrame && lastFrame.bodyH ? lastFrame.bodyH : 1;
+    const max = Math.max(0, count - logViewRows(bodyH));
+    const from = this.followEnd ? max : this.logScroll;
+    const start = Math.min(max, Math.max(0, from + delta));
+    this.followEnd = start === max;
+    this.logScroll = start;
+  }
 
-const runSelected = (api) => {
-  if (api.state.viewing || api.state.child) return;
-  const entry = selected(api);
-  if (!entry) return;
-  api.state.verbose = false;
-  startRun(api, entry);
-};
+  move(delta) {
+    if (this.viewing) return void this.scrollLog(delta);
+    if (!this.commands.length) return;
+    const nav = this.ui.nav;
+    const last = this.commands.length - 1;
+    const next = Math.min(last, Math.max(0, nav.npmCursor + delta));
+    if (next === nav.npmCursor) return;
+    nav.npmCursor = next;
+    this.ui.status = '';
+  }
 
-const rerun = (api) => {
-  if (!api.state.viewing || api.state.running) return;
-  const entry = selected(api);
-  if (!entry) return;
-  startRun(api, entry);
-};
+  stopRun() {
+    if (this.running) this.endedAt = Date.now();
+    this.running = false;
+    this.child = null;
+    this.ui.progress.stop('npm');
+  }
 
-const closeView = (api) => {
-  if (api.state.running) {
-    api.state.stopping = true;
-    if (api.state.child) api.state.child.kill();
-    if (!api.state.running) return;
-    api.state.raw = withNotice(api.state.raw, 'terminated');
-    api.state.output = api.state.verbose
-      ? shownOutput(api, api.state.raw, '')
-      : withNotice(api.state.output, 'terminated');
-    stopRun(api);
-    api.ui.status = 'terminated';
-    api.ui.paint();
-    return;
-  }
-  api.state.viewing = false;
-  api.state.verbose = false;
-  api.ui.status = '';
-  api.ui.paint();
-};
+  shownOutput(raw, status) {
+    if (this.verbose) return withNewline(raw);
+    return filteredOutput(raw, this.ui.top, status).output;
+  }
 
-const toggleVerbose = (api) => {
-  if (!api.state.viewing) return;
-  api.state.verbose = !api.state.verbose;
-  const status = api.state.running ? '' : api.state.exitStatus;
-  api.state.output = shownOutput(api, api.state.raw, status);
-  api.ui.status = api.state.verbose ? 'verbose' : 'filtered';
-  api.ui.paint();
-};
+  showOutput(text) {
+    if (!this.viewing || !this.running || this.stopping) return;
+    this.raw = text;
+    this.output = this.shownOutput(text, '');
+    this.ui.paint();
+  }
 
-const editable = (api) => {
-  if (api.state.viewing) return false;
-  if (canEdit(api.ui)) return true;
-  api.ui.status = 'read only';
-  return false;
-};
+  async finishRun(entry, result) {
+    const ui = this.ui;
+    const stopped = this.stopping === true;
+    const raw = stopped ? withNotice(this.raw, 'terminated') : result.text;
+    let slot = null;
+    try {
+      slot = nextLogFile(ui.top, entry.name);
+    } catch (error) {
+      ui.status = error.message;
+    }
+    const rawFile = slot ? slot.rawName : '';
+    const stoppedOutput = () => {
+      const output = withNotice(
+        reduceOutput(this.raw, ui.top, ''),
+        'terminated',
+      );
+      return { output, log: output };
+    };
+    const filtered = stopped
+      ? stoppedOutput()
+      : filteredOutput(result.text, ui.top, result.status, rawFile);
+    this.raw = raw;
+    this.exitStatus = stopped ? '' : result.status;
+    this.output = this.verbose ? this.shownOutput(raw, '') : filtered.output;
+    this.stopping = false;
+    this.stopRun();
+    if (stopped && this.viewing) ui.status = 'terminated';
+    ui.paint();
+    if (!slot) return;
+    try {
+      await saveLogs(slot, loggedText(filtered.log, slot.rawName), raw);
+    } catch (error) {
+      ui.status = error.message;
+      ui.paint();
+    }
+  }
 
-const selectedScript = (api) => {
-  if (!editable(api)) return null;
-  const entry = selected(api);
-  if (entry && entry.kind === 'script') return entry;
-  api.ui.status = 'not a script';
-  return null;
-};
+  startRun(entry) {
+    const ui = this.ui;
+    this.output = '';
+    this.raw = '';
+    this.exitStatus = '';
+    this.viewing = true;
+    this.followEnd = true;
+    this.logScroll = 0;
+    this.running = true;
+    this.stopping = false;
+    this.runLabel = runLabel(entry);
+    this.startedAt = Date.now();
+    this.endedAt = 0;
+    ui.status = '';
+    ui.progress.start('npm');
+    const start = (ui.repo && ui.repo.runNpmCommand) || startNpm;
+    const child = start(
+      ui.top,
+      entry,
+      (text) => this.showOutput(text),
+      (result) => this.finishRun(entry, result),
+    );
+    if (this.running) this.child = child;
+    ui.paint();
+    return child;
+  }
 
-const focusScript = (api, name) => {
-  const at = api.state.commands.findIndex((entry) => entry.name === name);
-  if (at >= 0) api.ui.nav.npmCursor = at;
-};
+  run() {
+    if (this.viewing || this.child) return null;
+    const entry = this.selected();
+    if (!entry) return null;
+    this.verbose = false;
+    return this.startRun(entry);
+  }
 
-const editSelected = (api) => {
-  const entry = selectedScript(api);
-  if (!entry) return;
-  api.state.editName = entry.name;
-  api.state.editField = 'name';
-  api.state.draftName = entry.name;
-  api.state.draftCommand = entry.command ?? '';
-  api.ui.composer.openCompose('npm', entry.name);
-};
+  rerun() {
+    if (!this.viewing || this.running) return;
+    const entry = this.selected();
+    if (entry) this.startRun(entry);
+  }
 
-const newCommand = (api) => {
-  if (!editable(api)) return;
-  api.state.editName = '';
-  api.state.editField = 'name';
-  api.state.draftName = '';
-  api.state.draftCommand = '';
-  api.ui.composer.openCompose('npm', '');
-};
+  closeView() {
+    const ui = this.ui;
+    if (!this.running) {
+      this.viewing = false;
+      this.verbose = false;
+      ui.status = '';
+      return void ui.paint();
+    }
+    this.stopping = true;
+    if (this.child) this.child.kill();
+    if (!this.running) return;
+    this.raw = withNotice(this.raw, 'terminated');
+    this.output = this.verbose
+      ? this.shownOutput(this.raw, '')
+      : withNotice(this.output, 'terminated');
+    this.stopRun();
+    ui.status = 'terminated';
+    ui.paint();
+  }
 
-const switchField = (api, editor, field, text) => {
-  api.state.editField = field;
-  editor.replace(text);
-  api.ui.status = '';
-};
+  toggleVerbose() {
+    if (!this.viewing) return;
+    this.verbose = !this.verbose;
+    const status = this.running ? '' : this.exitStatus;
+    this.output = this.shownOutput(this.raw, status);
+    this.ui.status = this.verbose ? 'verbose' : 'filtered';
+    this.ui.paint();
+  }
 
-const finishName = (api, editor) => {
-  const name = editor.text.trim();
-  if (!name || !NAME_RE.test(name)) {
-    api.ui.status = 'name';
+  editable() {
+    if (this.viewing) return false;
+    const ui = this.ui;
+    const caps = ui.capabilities;
+    if (!ui.readOnly && (!caps || caps.changes !== false)) return true;
+    ui.status = 'read only';
     return false;
   }
-  api.state.draftName = name;
-  switchField(api, editor, 'command', api.state.draftCommand);
-  return true;
-};
 
-const focusField = (api, field) => {
-  const editor = api.ui.editor;
-  if (!editor) return false;
-  if (field === api.state.editField) return true;
-  if (field === 'command') return finishName(api, editor);
-  api.state.draftCommand = editor.text;
-  switchField(api, editor, 'name', api.state.draftName ?? '');
-  return true;
-};
+  selectedScript() {
+    if (!this.editable()) return null;
+    const entry = this.selected();
+    if (entry && entry.kind === 'script') return entry;
+    this.ui.status = 'not a script';
+    return null;
+  }
 
-const finishEdit = (api) => {
-  const editor = api.ui.composer.state.editor;
-  if (!editor) return;
-  if (api.state.editField !== 'command') return void finishName(api, editor);
-  const command = editor.text.trim();
-  if (!command) {
-    api.ui.status = 'command';
-    return;
-  }
-  const parsed = { name: api.state.draftName, command };
-  try {
-    api.ui.ignoreWatch();
-    saveScript(api.ui.top, api.state.editName, parsed);
-  } catch (error) {
-    api.ui.status = error.message;
-    return;
-  }
-  api.state.editField = '';
-  api.ui.composer.closeCompose();
-  refresh(api);
-  focusScript(api, parsed.name);
-  api.ui.status = 'saved';
-};
+  focusScript(name) {
+    const at = this.commands.findIndex((entry) => entry.name === name);
+    if (at >= 0) this.ui.nav.npmCursor = at;
+  }
 
-const askDrop = (api) => {
-  const entry = selectedScript(api);
-  if (!entry) return;
-  api.state.dropKind = 'script';
-  api.state.dropName = entry.name;
-  api.ui.mode = 'confirmDrop';
-  api.ui.status = '';
-};
+  startEdit(name, command) {
+    this.editName = name;
+    this.editField = 'name';
+    this.draftName = name;
+    this.draftCommand = command;
+    this.ui.composer.openCompose('npm', name);
+  }
 
-const askLogs = (api) => {
-  if (!editable(api)) return;
-  refreshLogs(api);
-  if (!api.state.logBytes) return;
-  api.state.dropKind = 'logs';
-  const size = formatSize(api.state.logBytes);
-  api.state.dropName = `logs older than 5 days (${size})`;
-  api.ui.mode = 'confirmDrop';
-  api.ui.status = '';
-};
+  edit() {
+    const entry = this.selectedScript();
+    if (entry) this.startEdit(entry.name, entry.command ?? '');
+  }
 
-const confirmDrop = (api) => {
-  const kind = api.state.dropKind;
-  const name = api.state.dropName;
-  api.state.dropName = '';
-  api.state.dropKind = '';
-  api.ui.mode = 'review';
-  if (kind === 'logs') {
+  create() {
+    if (this.editable()) this.startEdit('', '');
+  }
+
+  switchField(editor, field, text) {
+    this.editField = field;
+    editor.replace(text);
+    this.ui.status = '';
+  }
+
+  finishName(editor) {
+    const name = editor.text.trim();
+    if (!name || !NAME_RE.test(name)) {
+      this.ui.status = 'name';
+      return false;
+    }
+    this.draftName = name;
+    this.switchField(editor, 'command', this.draftCommand);
+    return true;
+  }
+
+  focusField(field) {
+    const editor = this.ui.editor;
+    if (!editor) return false;
+    if (field === this.editField) return true;
+    if (field === 'command') return this.finishName(editor);
+    this.draftCommand = editor.text;
+    this.switchField(editor, 'name', this.draftName);
+    return true;
+  }
+
+  writeScripts(write) {
     try {
-      removeStaleLogs(api.ui.top);
+      this.ui.ignoreWatch();
+      write(this.ui.top);
+      return true;
     } catch (error) {
-      api.ui.status = error.message;
-      refreshLogs(api);
+      this.ui.status = error.message;
+      return false;
+    }
+  }
+
+  finishEdit() {
+    const ui = this.ui;
+    const editor = ui.composer.editor;
+    if (!editor) return;
+    if (this.editField !== 'command') return void this.finishName(editor);
+    const command = editor.text.trim();
+    if (!command) {
+      ui.status = 'command';
       return;
     }
-    refreshLogs(api);
-    api.ui.status = 'dropped logs';
-    return;
-  }
-  if (!name) return;
-  try {
-    api.ui.ignoreWatch();
-    removeScript(api.ui.top, name);
-  } catch (error) {
-    api.ui.status = error.message;
-    return;
-  }
-  refresh(api);
-  api.ui.status = `dropped ${name}`;
-};
+    const parsed = { name: this.draftName, command };
+    const write = (top) => saveScript(top, this.editName, parsed);
+    if (!this.writeScripts(write)) return;
+    this.editField = '';
+    ui.composer.closeCompose();
+    this.refresh();
+    this.focusScript(parsed.name);
+    ui.status = 'saved';
+  }
 
-const cancelDrop = (api) => {
-  api.state.dropName = '';
-  api.state.dropKind = '';
-  api.ui.mode = 'review';
-  api.ui.status = '';
-};
+  confirm(kind, name) {
+    this.dropKind = kind;
+    this.dropName = name;
+    this.ui.mode = 'confirmDrop';
+    this.ui.status = '';
+  }
 
-const reorder = (api, delta) => {
-  const entry = selectedScript(api);
-  if (!entry) return;
-  try {
-    api.ui.ignoreWatch();
-    if (!reorderScript(api.ui.top, entry.name, delta)) return;
-  } catch (error) {
-    api.ui.status = error.message;
-    return;
-  }
-  refresh(api);
-  focusScript(api, entry.name);
-  api.ui.status = '';
-};
+  askDrop() {
+    const entry = this.selectedScript();
+    if (entry) this.confirm('script', entry.name);
+  }
 
-const npmState = () => ({
-  commands: [],
-  viewing: false,
-  output: '',
-  followEnd: true,
-  logScroll: 0,
-  editName: '',
-  editField: '',
-  draftName: '',
-  draftCommand: '',
-  verbose: false,
-  raw: '',
-  exitStatus: '',
-  dropName: '',
-  dropKind: '',
-  logBytes: 0,
-  running: false,
-  stopping: false,
-  child: null,
-});
-
-const createNpmController = (ui) => {
-  const state = npmState();
-  const api = { ui, state };
-  return {
-    state,
-    get commands() {
-      return state.commands;
-    },
-    get viewing() {
-      return state.viewing;
-    },
-    get output() {
-      return state.output;
-    },
-    get dropName() {
-      return state.dropName;
-    },
-    get logLabel() {
-      if (!state.logBytes) return '';
-      return `old logs ${formatSize(state.logBytes)}`;
-    },
-    get followEnd() {
-      return state.followEnd;
-    },
-    get logScroll() {
-      return state.logScroll;
-    },
-    get editName() {
-      return state.editName;
-    },
-    get editField() {
-      return state.editField;
-    },
-    get draftName() {
-      return state.draftName;
-    },
-    get draftCommand() {
-      return state.draftCommand;
-    },
-    get verbose() {
-      return state.verbose;
-    },
-    get running() {
-      return state.running;
-    },
-    reset() {
-      if (state.child) state.child.kill();
-      stopRun(api);
-      state.commands = [];
-      state.viewing = false;
-      state.output = '';
-      state.followEnd = true;
-      state.logScroll = 0;
-      state.editName = '';
-      state.editField = '';
-      state.draftName = '';
-      state.draftCommand = '';
-      state.verbose = false;
-      state.raw = '';
-      state.exitStatus = '';
-      state.dropName = '';
-      state.dropKind = '';
-      state.logBytes = 0;
-      state.stopping = false;
-    },
-    open: () => open(api),
-    move: (delta) => move(api, delta),
-    run: () => runSelected(api),
-    rerun: () => rerun(api),
-    closeView: () => closeView(api),
-    toggleVerbose: () => toggleVerbose(api),
-    edit: () => editSelected(api),
-    create: () => newCommand(api),
-    finishEdit: () => finishEdit(api),
-    focusField: (field) => focusField(api, field),
-    askDrop: () => askDrop(api),
-    askLogs: () => askLogs(api),
-    confirmDrop: () => confirmDrop(api),
-    cancelDrop: () => cancelDrop(api),
-    reorder: (delta) => reorder(api, delta),
-  };
-};
+  askLogs() {
+    if (!this.editable()) return;
+    this.refreshLogs();
+    if (!this.logBytes) return;
+    const size = bytesToSize(this.logBytes);
+    this.confirm('logs', `logs older than 5 days (${size})`);
+  }
+
+  cancelDrop() {
+    this.dropName = '';
+    this.dropKind = '';
+    this.ui.mode = 'review';
+    this.ui.status = '';
+  }
+
+  confirmDrop() {
+    const ui = this.ui;
+    const kind = this.dropKind;
+    const name = this.dropName;
+    this.dropName = '';
+    this.dropKind = '';
+    ui.mode = 'review';
+    if (kind === 'logs') {
+      try {
+        removeStaleLogs(ui.top);
+      } catch (error) {
+        ui.status = error.message;
+        return void this.refreshLogs();
+      }
+      this.refreshLogs();
+      ui.status = 'dropped logs';
+      return;
+    }
+    if (!name) return;
+    if (!this.writeScripts((top) => removeScript(top, name))) return;
+    this.refresh();
+    ui.status = `dropped ${name}`;
+  }
+
+  reorder(delta) {
+    const entry = this.selectedScript();
+    if (!entry) return;
+    let moved = false;
+    const write = (top) => {
+      moved = reorderScript(top, entry.name, delta);
+    };
+    if (!this.writeScripts(write) || !moved) return;
+    this.refresh();
+    this.focusScript(entry.name);
+    this.ui.status = '';
+  }
+}
 
-module.exports = { createNpmController };
+module.exports = { NpmController };