reslop 0.2.7 → 0.3.0

package/lib/runs/output.js

@@ -0,0 +1,174 @@
+'use strict';
+
+const path = require('node:path');
+const { isHashObject } = require('metautil');
+const { stripAnsi, visibleWidth } = require('../term/ansi.js');
+const utilities = require('../common/utilities.js');
+const { unquote } = utilities;
+
+const isPassingTest = (line) => {
+  const plain = stripAnsi(line);
+  const text = plain.trim();
+  if (!text) return false;
+  if (/^\s*[✔✓√] /.test(plain)) return true;
+  if (/^ok \d+ /.test(text)) return true;
+  return /^\s*PASS\b/.test(plain);
+};
+
+const indentStack = (line) => {
+  if (!/^\s*at\s/.test(stripAnsi(line))) return line;
+  return `  ${line.trimStart()}`;
+};
+
+const withoutNodeFrame = (line) => {
+  const plain = stripAnsi(line);
+  if (!plain.includes('(node:')) return line;
+  return /\{\s*$/.test(plain) ? '{' : null;
+};
+
+const withSep = (dir) => {
+  const sep = dir.includes('\\') ? '\\' : '/';
+  if (dir.endsWith(sep)) return dir;
+  return `${dir}${sep}`;
+};
+
+const stripOne = (text, dir) => {
+  if (!dir) return text;
+  let next = text.split(withSep(dir)).join('');
+  if (next.includes(dir)) next = next.split(dir).join('.');
+  return next;
+};
+
+const relativize = (text, root) => {
+  if (!root) return text;
+  const slash = root.replaceAll('\\', '/');
+  const back = slash.replaceAll('/', '\\');
+  const resolved = path.resolve(root).replaceAll('\\', '/');
+  const resolvedBack = resolved.replaceAll('/', '\\');
+  let next = text;
+  for (const dir of [slash, back, resolved, resolvedBack]) {
+    next = stripOne(next, dir);
+  }
+  return next;
+};
+
+const traceLine = (line, root) => {
+  const next = withoutNodeFrame(line);
+  if (next === null) return null;
+  return relativize(indentStack(next), root);
+};
+
+const objectEnd = (lines, start) => {
+  if (stripAnsi(lines[start]).trim() !== '{') return -1;
+  for (let i = start + 1; i < lines.length; i++) {
+    if (stripAnsi(lines[i]).trim() === '}') return i;
+  }
+  return -1;
+};
+
+const parseInspect = (lines) => {
+  const entries = [];
+  for (const line of lines) {
+    const plain = stripAnsi(line).trim().replace(/,$/, '');
+    const match = /^([A-Za-z_][\w]*)\s*:\s*([\s\S]*)$/.exec(plain);
+    if (!match) {
+      if (!entries.length) return null;
+      const last = entries[entries.length - 1];
+      last[1] = `${last[1]}\n${plain}`;
+      continue;
+    }
+    entries.push([match[1], unquote(match[2])]);
+  }
+  return entries.length ? entries : null;
+};
+
+const showValue = (value) => {
+  if (value === null) return 'null';
+  if (typeof value === 'string') return value;
+  if (typeof value === 'number' || typeof value === 'boolean') {
+    return `${value}`;
+  }
+  return JSON.stringify(value);
+};
+
+const parseObject = (lines) => {
+  try {
+    const text = lines.join('\n');
+    const value = JSON.parse(text);
+    if (!isHashObject(value)) return null;
+    const entries = Object.keys(value).map((key) => [
+      key,
+      showValue(value[key]),
+    ]);
+    return entries.length ? entries : null;
+  } catch {
+    return parseInspect(lines.slice(1, -1));
+  }
+};
+
+const TABLE_KEY = '\x1b[900m';
+
+const TABLE_VAL = '\x1b[901m';
+
+const formatTable = (entries) => {
+  const prepared = [];
+  let keyWidth = 0;
+  for (const entry of entries) {
+    const lines = `${entry[1]}`.split('\n').filter((line) => line.trim());
+    if (!lines.length) continue;
+    prepared.push([entry[0], lines]);
+    keyWidth = Math.max(keyWidth, visibleWidth(entry[0]));
+  }
+  const rows = [];
+  for (const entry of prepared) {
+    const lines = entry[1];
+    for (let i = 0; i < lines.length; i++) {
+      const name = i === 0 ? entry[0] : '';
+      const pad = ' '.repeat(Math.max(0, keyWidth - visibleWidth(name)));
+      const key = ` ${pad}${name} `;
+      const value = ` ${lines[i]} `;
+      rows.push(`${TABLE_KEY}${key}${TABLE_VAL}  ${value}`);
+    }
+  }
+  return rows;
+};
+
+const foldObjects = (lines) => {
+  const out = [];
+  for (let i = 0; i < lines.length; i++) {
+    const end = objectEnd(lines, i);
+    const entries = end < 0 ? null : parseObject(lines.slice(i, end + 1));
+    if (!entries) {
+      out.push(lines[i]);
+      continue;
+    }
+    if (out.length && out[out.length - 1] !== '') out.push('');
+    out.push(...formatTable(entries));
+    i = end;
+  }
+  return out;
+};
+
+const reduceOutput = (text, root, status) => {
+  const kept = [];
+  for (const line of `${text ?? ''}`.split(/\r?\n/)) {
+    if (isPassingTest(line)) continue;
+    const next = traceLine(line, root);
+    if (next !== null) kept.push(next);
+  }
+  const folded = foldObjects(kept);
+  while (folded.length && folded[folded.length - 1] === '') folded.pop();
+  if (status !== '') folded.push(`exit ${status ?? 'null'}`);
+  if (!folded.length) return '';
+  return `${folded.join('\n')}\n`;
+};
+
+module.exports = {
+  isPassingTest,
+  relativize,
+  traceLine,
+  TABLE_KEY,
+  TABLE_VAL,
+  formatTable,
+  reduceOutput,
+};

package/lib/runs/process.js

@@ -0,0 +1,113 @@
+'use strict';
+
+const { spawn } = require('node:child_process');
+const { spawnBase } = require('../common/process.js');
+
+const signalPid = (pid, signal) => {
+  try {
+    process.kill(pid, signal);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const killTree = (proc) => {
+  const pid = proc.pid;
+  if (!pid) return;
+  if (process.platform === 'win32') {
+    const killer = spawn(
+      'taskkill',
+      ['/pid', String(pid), '/t', '/f'],
+      spawnBase({ stdio: 'ignore' }),
+    );
+    killer.on('error', () => proc.kill());
+    return;
+  }
+  const group = -pid;
+  if (!signalPid(group, 'SIGTERM')) signalPid(pid, 'SIGTERM');
+  const timer = setTimeout(() => {
+    if (!signalPid(group, 'SIGKILL')) signalPid(pid, 'SIGKILL');
+  }, 200);
+  timer.unref();
+  proc.once('close', () => clearTimeout(timer));
+};
+
+const commandEnv = (base = process.env) => {
+  const env = { ...base };
+  if (!env.NO_COLOR && !env.FORCE_COLOR) env.FORCE_COLOR = '1';
+  if (!env.TERM) env.TERM = 'xterm-256color';
+  env.RESLOP_OUTPUT = 'raw';
+  return env;
+};
+
+class RunProcess {
+  constructor(onData, onClose) {
+    this.onData = onData;
+    this.onClose = onClose;
+    this.child = null;
+    this.text = '';
+    this.settled = false;
+    this.stopped = false;
+  }
+
+  get closed() {
+    return this.stopped || this.settled;
+  }
+
+  show(text) {
+    this.text = text;
+    this.onData(text);
+  }
+
+  finish(status) {
+    if (this.settled) return;
+    this.settled = true;
+    this.onClose({ status, text: this.text });
+  }
+
+  kill() {
+    if (this.closed) return;
+    this.stopped = true;
+    killTree(this.child);
+  }
+
+  raw() {
+    return this.text;
+  }
+}
+
+class PipeProcess extends RunProcess {
+  start(cmd, args, options) {
+    try {
+      this.child = spawn(cmd, args, options);
+    } catch (error) {
+      this.text = `${error.message}\n`;
+      this.finish(1);
+      return this;
+    }
+    const { child } = this;
+    for (const stream of [child.stdout, child.stderr]) {
+      if (!stream) continue;
+      stream.setEncoding('utf8');
+      stream.on('data', (chunk) => this.push(chunk));
+    }
+    child.on('error', (error) => {
+      if (!this.stopped) this.text += `${error.message}\n`;
+      this.finish(1);
+    });
+    child.on('close', (status) => this.finish(status));
+    return this;
+  }
+
+  push(chunk) {
+    if (!this.closed) this.show(this.text + chunk);
+  }
+
+  closeInput() {
+    const stdin = this.child && this.child.stdin;
+    if (stdin) stdin.on('error', () => {}).end();
+  }
+}
+
+module.exports = { commandEnv, RunProcess, PipeProcess };

package/lib/{runs.js → runs/runs.js}

@@ -2,23 +2,33 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
+const { readJson, listDir, trimText } = require('../common/utilities.js');
+const { isHashObject } = require('metautil');
+const { LOG_DIR } = require('../common/files.js');
 
-const ansi = require('./ansi.js');
-const { stripAnsi } = ansi;
-const commands = require('./npm-commands.js');
-const { isPassingTest } = commands;
+const { stripAnsi } = require('../term/ansi.js');
+const { isPassingTest } = require('./output.js');
+const { nextLogFile } = require('./logs.js');
 
-const LOG_DIR = '.log';
 const RUNS_REL = `${LOG_DIR}/.runs`;
 const RUNS_KEEP = 24;
 const WRITE_MS = 150;
 const FAILING_TEST = /^\s*(?:not ok \d+|[✖✗×]) /;
 const LIFECYCLE_EVENT = 'npm_lifecycle_event';
 
+const logDir = (root) => path.join(root, LOG_DIR);
+
 const runsDir = (root) => path.join(root, RUNS_REL);
 
-const isRunsRel = (rel) =>
-  rel === LOG_DIR || rel === RUNS_REL || rel.startsWith(`${RUNS_REL}/`);
+const isRunsRel = (rel) => {
+  if (rel === LOG_DIR || rel === RUNS_REL || rel.startsWith(`${RUNS_REL}/`)) {
+    return true;
+  }
+  if (!rel.startsWith(`${LOG_DIR}/`)) return false;
+  const name = rel.slice(LOG_DIR.length + 1);
+  if (name.includes('/')) return false;
+  return name.endsWith('.json') || name.endsWith('.log');
+};
 
 const commandLabel = (program, args) =>
   [path.basename(program), ...args].join(' ').trim();
@@ -54,42 +64,37 @@ const pidAlive = (pid) => {
 };
 
 const readRecord = (file) => {
-  try {
-    const record = JSON.parse(fs.readFileSync(file, 'utf8'));
-    if (!record || typeof record !== 'object' || !record.id) return null;
-    return record;
-  } catch {
-    return null;
-  }
+  const record = readJson(file);
+  return isHashObject(record) && record.id ? record : null;
 };
 
-const listRunNames = (root) => {
-  try {
-    return fs.readdirSync(runsDir(root)).filter((n) => n.endsWith('.json'));
-  } catch {
-    return [];
-  }
-};
+const listJson = (dir) => listDir(dir).filter((name) => name.endsWith('.json'));
+
+const isCommandRun = (record) =>
+  Boolean(record && record.id && record.progress && !record.cliId);
 
 const settleRecord = (record, alive = pidAlive) => {
   if (record.status !== 'running' || alive(record.pid)) return record;
   return { ...record, status: 'aborted' };
 };
 
-const readRuns = (root) => {
-  const dir = runsDir(root);
-  const records = [];
-  for (const name of listRunNames(root)) {
+const pushRuns = (records, dir, names) => {
+  for (const name of names) {
     const record = readRecord(path.join(dir, name));
-    if (record) records.push(settleRecord(record));
+    if (isCommandRun(record)) records.push(settleRecord(record));
   }
+};
+
+const readRuns = (root) => {
+  const records = [];
+  const dir = logDir(root);
+  pushRuns(records, dir, listJson(dir));
+  pushRuns(records, runsDir(root), listJson(runsDir(root)));
   return records.sort((left, right) => right.startedAt - left.startedAt);
 };
 
-const writeRecord = (root, record) => {
-  const dir = runsDir(root);
-  fs.mkdirSync(dir, { recursive: true });
-  const file = path.join(dir, `${record.id}.json`);
+const writeRecord = (file, record) => {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
   const temp = `${file}.tmp`;
   const text = JSON.stringify(record);
   try {
@@ -100,12 +105,41 @@ const writeRecord = (root, record) => {
   }
 };
 
+const removeStem = (dir, jsonName) => {
+  const stem = jsonName.replace(/\.json$/, '');
+  const suffixes = ['.json', '.log', '.raw', '.raw.log'];
+  for (const suffix of suffixes) {
+    fs.rmSync(path.join(dir, `${stem}${suffix}`), { force: true });
+  }
+};
+
+const byStart = (left, right) => {
+  const order = left.startedAt - right.startedAt;
+  return order || left.name.localeCompare(right.name, 'en');
+};
+
+const commandJson = (root) => {
+  const dir = logDir(root);
+  const found = [];
+  for (const name of listJson(dir)) {
+    if (/-agent-\d+\.json$/.test(name)) continue;
+    const record = readRecord(path.join(dir, name));
+    if (!isCommandRun(record)) continue;
+    found.push({ name, startedAt: Number(record.startedAt) || 0 });
+  }
+  return found.sort(byStart).map((entry) => entry.name);
+};
+
 const pruneRuns = (root) => {
-  const dir = runsDir(root);
-  const names = listRunNames(root).sort();
+  const dir = logDir(root);
+  const names = commandJson(root);
   const extra = names.length - RUNS_KEEP;
-  for (let i = 0; i < extra; i++) {
-    fs.rmSync(path.join(dir, names[i]), { force: true });
+  for (let i = 0; i < extra; i++) removeStem(dir, names[i]);
+  const legacy = runsDir(root);
+  const old = listJson(legacy).sort();
+  const leftover = old.length - RUNS_KEEP;
+  for (let i = 0; i < leftover; i++) {
+    fs.rmSync(path.join(legacy, old[i]), { force: true });
   }
 };
 
@@ -164,6 +198,14 @@ class RunRecorder {
     this.tracker = new Tracker();
     this.lastWrite = 0;
     this.closed = false;
+    this.slot = Object.hasOwn(options, 'slot') ? options.slot : null;
+    if (!Object.hasOwn(options, 'slot')) {
+      try {
+        this.slot = nextLogFile(root, command);
+      } catch {
+        this.slot = null;
+      }
+    }
     const startedAt = this.clock();
     const env = options.env || process.env;
     this.record = {
@@ -171,7 +213,7 @@ class RunRecorder {
       id: `${startedAt}-${process.pid}`,
       pid: process.pid,
       command,
-      script: `${env[LIFECYCLE_EVENT] ?? ''}`.trim(),
+      script: trimText(env[LIFECYCLE_EVENT]),
       cwd: root,
       startedAt,
       endedAt: 0,
@@ -180,6 +222,10 @@ class RunRecorder {
       progress: { ...this.tracker.progress, expected: 0 },
       result: null,
     };
+    if (this.slot) {
+      this.record.log = this.slot.name;
+      this.record.raw = this.slot.rawName;
+    }
     safely(() => {
       this.record.progress.expected = previousTotal(root, command);
       pruneRuns(root);
@@ -188,8 +234,9 @@ class RunRecorder {
   }
 
   write() {
+    if (!this.slot) return;
     Object.assign(this.record.progress, this.tracker.progress);
-    writeRecord(this.root, this.record);
+    writeRecord(this.slot.jsonFull, this.record);
   }
 
   feed(chunk) {
@@ -214,6 +261,7 @@ class RunRecorder {
 }
 
 module.exports = {
+  logDir,
   runsDir,
   isRunsRel,
   commandLabel,

package/lib/runs/scripts.js

@@ -0,0 +1,150 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const utilities = require('../common/utilities.js');
+const { readJson } = utilities;
+const { MANIFEST } = require('../common/files.js');
+
+const SECTIONS = ['dependencies', 'devDependencies', 'optionalDependencies'];
+
+const readManifest = (root) => {
+  const pkg = readJson(path.join(root, MANIFEST));
+  return pkg && typeof pkg === 'object' ? pkg : null;
+};
+
+const writeManifest = (root, pkg) => {
+  const file = path.join(root, MANIFEST);
+  fs.writeFileSync(file, `${JSON.stringify(pkg, null, 2)}\n`);
+};
+
+const scriptEntries = (pkg) => {
+  const scripts = pkg.scripts;
+  if (!scripts || typeof scripts !== 'object') return [];
+  const entries = [];
+  for (const name of Object.keys(scripts)) {
+    const command = scripts[name];
+    if (typeof command !== 'string') continue;
+    entries.push({ name, command, kind: 'script' });
+  }
+  return entries;
+};
+
+const binNames = (pkg) => {
+  if (!pkg || typeof pkg !== 'object') return [];
+  const bin = pkg.bin;
+  if (typeof bin === 'string' && bin) {
+    const raw = `${pkg.name ?? ''}`;
+    const base = raw.startsWith('@') ? raw.split('/')[1] : raw;
+    return base ? [base] : [];
+  }
+  if (!bin || typeof bin !== 'object' || Array.isArray(bin)) return [];
+  const isPath = (name) => typeof bin[name] === 'string' && bin[name] !== '';
+  return Object.keys(bin).filter(isPath);
+};
+
+const declaredNames = (pkg) => {
+  const names = [];
+  for (const section of SECTIONS) {
+    const map = pkg[section];
+    if (!map || typeof map !== 'object') continue;
+    names.push(...Object.keys(map));
+  }
+  return names;
+};
+
+const depManifest = (root, name) => {
+  const parts = name.startsWith('@') ? name.split('/').slice(0, 2) : [name];
+  return path.join(root, 'node_modules', ...parts, MANIFEST);
+};
+
+const binEntries = (root, pkg, taken) => {
+  const entries = [];
+  const seen = new Set(taken);
+  for (const name of declaredNames(pkg)) {
+    const dep = readJson(depManifest(root, name));
+    for (const bin of binNames(dep)) {
+      if (seen.has(bin)) continue;
+      seen.add(bin);
+      entries.push({ name: bin, command: bin, kind: 'bin', package: name });
+    }
+  }
+  entries.sort((left, right) => left.name.localeCompare(right.name));
+  return entries;
+};
+
+const listCommands = (root) => {
+  const pkg = readManifest(root);
+  if (!pkg) return [];
+  const scripts = scriptEntries(pkg);
+  const taken = scripts.map((entry) => entry.name);
+  return [...scripts, ...binEntries(root, pkg, taken)];
+};
+
+const orderedScripts = (pkg) => {
+  const scripts = pkg.scripts;
+  if (!scripts || typeof scripts !== 'object' || Array.isArray(scripts)) {
+    return {};
+  }
+  return scripts;
+};
+
+const pickScripts = (scripts, names) => {
+  const ordered = {};
+  for (const key of names) ordered[key] = scripts[key];
+  return ordered;
+};
+
+const upsertScript = (pkg, prev, next) => {
+  const scripts = orderedScripts(pkg);
+  const names = Object.keys(scripts);
+  if (!prev || !names.includes(prev)) {
+    pkg.scripts = { ...scripts, [next.name]: next.command };
+    return;
+  }
+  const ordered = {};
+  for (const key of names) {
+    if (key === prev) ordered[next.name] = next.command;
+    else if (key !== next.name) ordered[key] = scripts[key];
+  }
+  pkg.scripts = ordered;
+};
+
+const saveScript = (root, prev, next) => {
+  const pkg = readManifest(root) ?? {};
+  upsertScript(pkg, prev, next);
+  writeManifest(root, pkg);
+};
+
+const removeScript = (root, name) => {
+  const pkg = readManifest(root);
+  if (!pkg) return false;
+  const scripts = orderedScripts(pkg);
+  if (!Object.hasOwn(scripts, name)) return false;
+  const names = Object.keys(scripts).filter((key) => key !== name);
+  pkg.scripts = pickScripts(scripts, names);
+  writeManifest(root, pkg);
+  return true;
+};
+
+const reorderScript = (root, name, delta) => {
+  const pkg = readManifest(root);
+  if (!pkg) return false;
+  const scripts = orderedScripts(pkg);
+  const names = Object.keys(scripts);
+  const at = names.indexOf(name);
+  const next = at + delta;
+  if (at < 0 || next < 0 || next >= names.length) return false;
+  names[at] = names[next];
+  names[next] = name;
+  pkg.scripts = pickScripts(scripts, names);
+  writeManifest(root, pkg);
+  return true;
+};
+
+module.exports = {
+  listCommands,
+  saveScript,
+  removeScript,
+  reorderScript,
+};