@prowl-ai/prowl-skill 0.4.0

package/plugins/prowl/hooks/pre-tool-use.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * `PreToolUse` — a Prowl call started, and now something knows it.
+ *
+ * This hook decides nothing. It never returns a permission decision, never blocks a
+ * call and never prints: an observer that can refuse is an observer somebody
+ * eventually turns off. It opens one record keyed by `tool_use_id` and exits.
+ *
+ * The matcher in `hooks.json` is a coarse filter and is documented to be
+ * best-effort; the precise question — *is this one of Prowl's tools, under either of
+ * the two names it can have* — is answered by `lib/prowl.js`, which is pure and
+ * fixtured. Nothing here rests on the filter being exact.
+ *
+ * Fails silent, always exits 0. A widget is never worth costing someone their turn.
+ */
+
+const path = require('path');
+const os = require('os');
+
+const LIB = path.join(__dirname, '..', 'lib');
+
+let raw = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (c) => { raw += c; });
+process.stdin.on('end', () => {
+  try {
+    // Assert the input arrived before acting on it. A hook that received nothing has
+    // observed nothing, and writing a record for it would invent one.
+    if (!raw.trim().startsWith('{')) return process.exit(0);
+    const data = JSON.parse(raw);
+
+    const rec = require(path.join(LIB, 'prowl.js')).classify(data);
+    if (!rec || rec.kind !== 'open') return process.exit(0);
+
+    require(path.join(LIB, 'state.js')).openCall(os.homedir(), data.session_id, {
+      id: rec.id,
+      tool: rec.tool,
+      at: new Date().toISOString(),
+    });
+  } catch (e) {
+    /* Silence, deliberately: the turn matters more than the widget. */
+  }
+  process.exit(0);
+});

package/plugins/prowl/hooks/session-start.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * `SessionStart` — the sweep, and nothing else.
+ *
+ * One small file per session accumulates forever otherwise: the kind of litter nobody
+ * notices until it is thousands of files in a directory that also holds an API token.
+ *
+ * It prints **nothing**. A plugin that announces itself at the start of every session
+ * is the 854-token cost that got another pack switched off on this machine, and this
+ * one has nothing to say that the status line does not say better, later, and only
+ * when there is something to report.
+ *
+ * Fails silent, always exits 0.
+ */
+
+const path = require('path');
+const os = require('os');
+
+const RETENTION_MS = 1000 * 60 * 60 * 24 * 7;
+
+let raw = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (c) => { raw += c; });
+process.stdin.on('end', () => {
+  try {
+    require(path.join(__dirname, '..', 'lib', 'state.js'))
+      .prune(os.homedir(), Date.now(), RETENTION_MS);
+  } catch (e) {
+    /* Nothing to prune is the normal case, and a failed sweep is not worth a word. */
+  }
+  process.exit(0);
+});

package/plugins/prowl/lib/osc.js

@@ -0,0 +1,87 @@
+'use strict';
+/**
+ * The two terminal sequences this plugin emits, and the allowlist that keeps them
+ * from being silently dropped.
+ *
+ * Claude Code honours OSC 0, 1, 2, 9, 99, 777 and a bare BEL in a hook's
+ * `terminalSequence`, and **silently ignores** the field when it carries anything
+ * else. Silently is the operative word: a module that built a sequence outside that
+ * set would ship a feature that never fires and never complains, so this validates
+ * before returning rather than trusting itself.
+ *
+ * Every control byte is written as an escape, never as itself — a literal ESC in a
+ * source file survives exactly as long as nothing reformats it.
+ *
+ * Pure: values in, a string out, `''` when there is nothing safe to emit.
+ */
+
+const ALLOWED_OSC = [0, 1, 2, 9, 99, 777];
+
+const ESC = '\u001b';
+const BEL = '\u0007';
+
+/**
+ * Text safe to place inside an OSC payload.
+ *
+ * A semicolon separates an OSC 777 sequence's own fields and a control byte can end
+ * the sequence early. Both turn a notification into terminal garbage, and the second
+ * is an injection — the message is text that came back from a server.
+ */
+function sanitise(text, limit) {
+  return String(text || '')
+    .replace(/[\u0000-\u001f\u007f]/g, ' ')
+    .replace(/;/g, ',')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, limit || 120);
+}
+
+/** Is every sequence in this string inside the allowlist? Every one, not the first. */
+function isAllowed(seq) {
+  let rest = String(seq == null ? '' : seq);
+  if (!rest) return false;
+  while (rest.length) {
+    if (rest[0] === BEL) { rest = rest.slice(1); continue; }
+    const m = new RegExp(`^${ESC}\\](\\d+);[^${ESC}${BEL}]*${BEL}`).exec(rest);
+    if (!m || !ALLOWED_OSC.includes(Number(m[1]))) return false;
+    rest = rest.slice(m[0].length);
+  }
+  return true;
+}
+
+/**
+ * The taskbar/dock progress bar, from a fraction the server actually reported.
+ *
+ * State 1 is "normal progress". The percentage is rounded to an integer because the
+ * sequence carries one, and clamped only inside 0..100 — a value outside 0..1 never
+ * reaches here, because the adapter refuses it rather than guessing whether 42 meant
+ * a percent.
+ */
+function progress(value) {
+  if (typeof value !== 'number' || !Number.isFinite(value) || value < 0 || value > 1) return '';
+  const pct = Math.max(0, Math.min(100, Math.round(value * 100)));
+  const seq = `${ESC}]9;4;1;${pct}${BEL}`;
+  return isAllowed(seq) ? seq : '';
+}
+
+/** Take the bar down. Sent when the thing it was describing has finished. */
+function progressClear() {
+  const seq = `${ESC}]9;4;0;${BEL}`;
+  return isAllowed(seq) ? seq : '';
+}
+
+/**
+ * A desktop notification.
+ *
+ * Reserved for the wallet gate. A ping on every finished call is a ping that gets
+ * muted, and then the one that matters is muted with it.
+ */
+function notify(title, body) {
+  const t = sanitise(title, 60);
+  const b = sanitise(body, 160);
+  if (!b) return '';
+  const seq = `${ESC}]777;notify;${t || 'Prowl'};${b}${BEL}`;
+  return isAllowed(seq) ? seq : '';
+}
+
+module.exports = { progress, progressClear, notify, isAllowed, sanitise, ALLOWED_OSC, ESC, BEL };

package/plugins/prowl/lib/prowl.js

@@ -0,0 +1,260 @@
+'use strict';
+/**
+ * A hook payload becomes a record, or becomes nothing.
+ *
+ * Pure and total. Every decision this plugin makes about a tool call is a function of
+ * the payload and lives here, so the suite can fixture it without a `HOME`, without a
+ * network and without Claude Code — and so the hook scripts contain no judgement at
+ * all, only plumbing.
+ *
+ * **The server's numbers, and only those.** `usd` appears when the response carried
+ * `actual_cost_usd`; `progress` appears when the response carried a fraction. Neither
+ * is ever estimated. A number this module could not read is an absence, and an
+ * absence renders differently from a zero.
+ */
+
+/** Tools whose responses are worth reading for a fraction. */
+const PROGRESS_TOOLS = new Set(['prowl_session_status', 'prowl_get_session', 'prowl_start_session']);
+
+/** Statuses after which there is nothing left to show progress for. */
+const TERMINAL_STATUS = new Set(['completed', 'complete', 'done', 'failed', 'error', 'cancelled', 'canceled']);
+
+/** How deep to look for a `billing` object before giving up. Envelopes are shallow. */
+const MAX_DEPTH = 6;
+
+/**
+ * Is this one of Prowl's tools, under either name it can have?
+ *
+ * A directly configured server yields `mcp__prowl__prowl_analyze`; the same server
+ * shipped inside this plugin is namespaced by Claude Code and yields
+ * `mcp__plugin_prowl_prowl__prowl_analyze`. Both must be recognised, and neither may
+ * be recognised by a substring test that would also match somebody else's server
+ * called `prowl-mirror`.
+ */
+function parseToolName(name) {
+  if (typeof name !== 'string') return null;
+  const parts = name.split('__');
+  if (parts.length < 3 || parts[0] !== 'mcp') return null;
+  const server = parts[1];
+  const tool = parts.slice(2).join('__');
+  const isProwlServer = server === 'prowl' || /(^|_)prowl$/.test(server);
+  if (!isProwlServer) return null;
+  if (!/^prowl_/.test(tool)) return null;
+  return { server, tool };
+}
+
+/** `prowl_call_tool` → `call_tool`. The prefix is noise once the segment says `prowl`. */
+function shortName(tool) {
+  return typeof tool === 'string' ? tool.replace(/^prowl_/, '') : null;
+}
+
+/** Envelope keys whose value is the real body. Verified against the live server. */
+const ENVELOPE_KEYS = ['result', 'content', 'data', 'response', 'output'];
+
+/** Largest string this will attempt to parse. A report body can be very large. */
+const MAX_PARSE = 512 * 1024;
+
+/** Does this string look like it holds JSON? Cheap test before an expensive parse. */
+function looksJson(s) {
+  if (typeof s !== 'string' || s.length > MAX_PARSE) return false;
+  const t = s.trim();
+  return (t.startsWith('{') && t.endsWith('}')) || (t.startsWith('[') && t.endsWith(']'));
+}
+
+/** Parse if it parses, otherwise `null`. Never throws. */
+function tryParse(s) {
+  if (!looksJson(s)) return null;
+  try {
+    const v = JSON.parse(s);
+    return v && typeof v === 'object' ? v : null;
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Follow single-key envelopes down to the body that actually says something.
+ *
+ * **The live server double-encodes.** `prowl_get_stats` and `prowl_list_tools` both
+ * answer `{"result": "{\n  \"session_id\": …}"}` — an object whose one key holds a
+ * JSON *string*. A walker that treats `result` as a leaf stops at the doorstep, which
+ * is precisely what this module did until the shape was checked against a real
+ * response rather than against a fixture written from the documentation.
+ */
+function unwrap(node, depth) {
+  let cur = node;
+  for (let i = 0; i < (depth || MAX_DEPTH); i += 1) {
+    if (!cur || typeof cur !== 'object' || Array.isArray(cur)) return cur;
+    const keys = Object.keys(cur);
+    if (keys.length !== 1 || !ENVELOPE_KEYS.includes(keys[0])) return cur;
+    const inner = cur[keys[0]];
+    const parsed = typeof inner === 'string' ? tryParse(inner) : inner;
+    if (!parsed || typeof parsed !== 'object') return cur;
+    cur = parsed;
+  }
+  return cur;
+}
+
+/** The response body, parsed and unwrapped. A body that is not JSON is not an error. */
+function parseBody(toolResponse) {
+  if (!toolResponse) return null;
+  const content = typeof toolResponse === 'string' ? toolResponse : toolResponse.content;
+  const parsed = typeof content === 'string'
+    ? tryParse(content)
+    : (content && typeof content === 'object' ? content : null);
+  return parsed ? unwrap(parsed, MAX_DEPTH) : null;
+}
+
+/**
+ * The debited amount, wherever the envelope put it.
+ *
+ * `actual_cost_usd` is the figure the server says it took; `estimated_cost_usd` sits
+ * beside it in the same object and is deliberately NOT read — an estimate displayed
+ * next to real debits is the number that gets believed.
+ */
+function findUsd(node, depth) {
+  if (!node || depth > MAX_DEPTH) return null;
+  // A nested JSON string is a branch, not a leaf: the server encodes bodies that way.
+  if (typeof node === 'string') return findUsd(tryParse(node), depth + 1);
+  if (typeof node !== 'object') return null;
+
+  const billing = typeof node.billing === 'string' ? tryParse(node.billing) : node.billing;
+  if (billing && typeof billing === 'object') {
+    const v = billing.actual_cost_usd;
+    if (typeof v === 'number' && Number.isFinite(v)) return v;
+  }
+  if (typeof node.actual_cost_usd === 'number' && Number.isFinite(node.actual_cost_usd)) {
+    return node.actual_cost_usd;
+  }
+  for (const key of Object.keys(node)) {
+    const found = findUsd(node[key], depth + 1);
+    if (found !== null) return found;
+  }
+  return null;
+}
+
+/**
+ * The server's own accounting, when `prowl_get_stats` is what came back.
+ *
+ * Strictly better than the sum this plugin keeps: it is what Prowl says it charged
+ * and how many tokens its own pipeline burned, rather than what one session happened
+ * to observe. Recorded separately and never merged into the sum — two numbers that
+ * disagree are information, and averaging them away would destroy it.
+ */
+function findServerTotals(body) {
+  if (!body || typeof body !== 'object') return null;
+  const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : null);
+  const out = {
+    usd: num(body.tool_cost_usd),
+    total_usd: num(body.total_cost_usd),
+    tokens: num(body.total_tokens),
+    calls: num(body.tool_calls_count),
+  };
+  return Object.values(out).some((v) => v !== null) ? out : null;
+}
+
+/** A fraction, and only if it really is one. `0` is a real progress value. */
+function findProgress(body) {
+  if (!body || typeof body !== 'object') return null;
+  const v = body.progress;
+  if (typeof v === 'number' && Number.isFinite(v) && v >= 0 && v <= 1) return v;
+  return null;
+}
+
+/**
+ * Did this call fail, and was it the wallet that stopped it?
+ *
+ * The wallet case is recognised by wording **and** by shape, because either alone is
+ * brittle: a code field can be renamed and a message can be rephrased, and a check
+ * resting on one of them silently stops firing when that happens.
+ */
+function findError(toolResponse, body) {
+  const typed = toolResponse && toolResponse.type === 'error';
+  const bodyError = body && (body.error || body.isError === true);
+  if (!typed && !bodyError) return null;
+
+  const text = [
+    toolResponse && typeof toolResponse.content === 'string' ? toolResponse.content : '',
+    body && typeof body.error === 'string' ? body.error : '',
+    body && body.error && typeof body.error.message === 'string' ? body.error.message : '',
+    body && typeof body.message === 'string' ? body.message : '',
+  ].join(' ');
+
+  const code = (body && (body.code || (body.error && body.error.code))) || '';
+  const gate = /insufficient[\s_-]*(balance|funds|credit)/i.test(text)
+    || /\bwallet\b[^.]{0,40}\b(empty|balance|insufficient)\b/i.test(text)
+    || /insufficient[_-]?balance/i.test(String(code));
+
+  return { gate, message: text.trim().slice(0, 300) || 'the call failed with no message' };
+}
+
+/**
+ * A stable fingerprint for "have we already said this?".
+ *
+ * The tool plus the class of failure, never the message: a message carrying an id or
+ * a timestamp would be a new fingerprint every time, and the once-only rule would
+ * quietly become a rule that says everything.
+ */
+function fingerprint(tool, error) {
+  if (!error) return null;
+  return `${tool || 'unknown'}:${error.gate ? 'wallet-gate' : 'error'}`;
+}
+
+/**
+ * The payload, classified.
+ *
+ * Returns `null` for anything that is not a Prowl tool call — which is almost every
+ * payload this process will ever see, and the cheapest possible answer for it.
+ */
+function classify(payload) {
+  if (!payload || typeof payload !== 'object') return null;
+  const parsed = parseToolName(payload.tool_name);
+  if (!parsed) return null;
+
+  const id = typeof payload.tool_use_id === 'string' ? payload.tool_use_id : null;
+  if (!id) return null;
+
+  const base = { tool: parsed.tool, short: shortName(parsed.tool), id };
+
+  if (payload.hook_event_name === 'PreToolUse') {
+    return Object.assign(base, { kind: 'open' });
+  }
+
+  const body = parseBody(payload.tool_response);
+  const error = findError(payload.tool_response, body);
+  const rec = Object.assign(base, {
+    kind: 'close',
+    ok: !error,
+    usd: findUsd(body, 0),
+    error,
+    fingerprint: fingerprint(parsed.tool, error),
+  });
+
+  if (parsed.tool === 'prowl_get_stats') {
+    const server = findServerTotals(body);
+    if (server) rec.server = server;
+  }
+
+  if (PROGRESS_TOOLS.has(parsed.tool)) {
+    const p = findProgress(body);
+    if (p !== null) {
+      rec.progress = p;
+      rec.progress_session = (body && typeof body.session_id === 'string') ? body.session_id : null;
+    }
+    // The bar belongs to the async session, not to the poll that read it. Without a
+    // terminal status the caller would have to guess when to take it down, and the
+    // obvious guess — "when this tool call ends" — takes it down after every poll.
+    const status = body && typeof body.status === 'string' ? body.status.toLowerCase() : null;
+    if (status) {
+      rec.status = status;
+      rec.finished = TERMINAL_STATUS.has(status);
+    }
+  }
+  return rec;
+}
+
+module.exports = {
+  classify, parseToolName, shortName, parseBody, unwrap, tryParse, looksJson,
+  findUsd, findProgress, findError, findServerTotals, fingerprint,
+  PROGRESS_TOOLS, TERMINAL_STATUS, ENVELOPE_KEYS,
+};

package/plugins/prowl/lib/render.js

@@ -0,0 +1,180 @@
+'use strict';
+/**
+ * Records become a line, a notice, or nothing.
+ *
+ * Three rules, inherited rather than invented, because each one has already been got
+ * wrong somewhere and the fix is cheaper than the rediscovery:
+ *
+ * 1. **Every number is borrowed.** Nothing here computes a figure it was not handed.
+ *    The one arithmetic this module does is formatting.
+ * 2. **Absent is a word, never a zero.** `$—` says the server has reported no charge;
+ *    `$0.00` says it charged nothing. A renderer that prints them alike turns "we do
+ *    not know" into "it was free".
+ * 3. **Nothing to say prints nothing.** An empty string is the honest rendering of a
+ *    session that has not called Prowl, and it is better than a line that says `0`
+ *    in a repository where the plugin was never used.
+ *
+ * Pure: state in, string out.
+ */
+
+const SEP = ' · ';
+
+/** `12s`, `1:12`, `1h 05m` — the coarsest unit that is still true. */
+function elapsed(fromISO, nowMs) {
+  const from = Date.parse(fromISO || '');
+  if (!Number.isFinite(from) || !Number.isFinite(nowMs) || nowMs < from) return null;
+  const s = Math.floor((nowMs - from) / 1000);
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}:${String(s % 60).padStart(2, '0')}`;
+  return `${Math.floor(m / 60)}h ${String(m % 60).padStart(2, '0')}m`;
+}
+
+/**
+ * Money, at the precision the amount deserves.
+ *
+ * Two cents of rounding is nothing on a bill and everything on a **unit price**: a
+ * metered call at `$0.0325` shown as `$0.03` is off by seven percent, and a hundred of
+ * them are off by three dollars. So under a dollar the figure keeps four decimals,
+ * trailing zeros trimmed to two so `$0.31` does not become `$0.3100`; above a dollar
+ * the cents are the whole story.
+ *
+ * Caught by a fixture asserting the server's own billed figure and getting `$0.03`
+ * back — the same class as printing an absence as a zero, one decimal place down.
+ */
+function money(v) {
+  if (typeof v !== 'number' || !Number.isFinite(v)) return null;
+  if (v === 0) return '$0.00';
+  if (v >= 1) return `$${v.toFixed(2)}`;
+  const four = v.toFixed(4).replace(/(\.\d\d[1-9]?)0+$/, '$1');
+  return `$${four}`;
+}
+
+/** The in-flight calls, oldest first — the one that has been waiting longest leads. */
+function inFlight(state) {
+  const open = (state && state.open) || {};
+  return Object.keys(open)
+    .map((id) => ({ id, tool: open[id].tool, at: open[id].at }))
+    .sort((a, b) => String(a.at).localeCompare(String(b.at)));
+}
+
+/** `call_tool` from `prowl_call_tool`; whatever it is when it is not that. */
+function short(tool) {
+  return typeof tool === 'string' ? tool.replace(/^prowl_/, '') : '?';
+}
+
+/**
+ * The ticker: the last calls, newest first, each with its verdict.
+ *
+ * Newest first because the question a ticker answers is "what just happened", and
+ * the answer should not be at the end of a line that may be truncated.
+ */
+function ticker(state, limit) {
+  const recent = (state && state.recent) || [];
+  const n = typeof limit === 'number' ? limit : recent.length;
+  return recent.slice(-Math.max(0, n)).reverse()
+    .map((r) => `${short(r.tool)}${r.ok ? '✓' : '✗'}`)
+    .join(' ');
+}
+
+/**
+ * One row, or `''`.
+ *
+ * `opts.cost` and `opts.context` are the status-line payload's own objects; no hook
+ * event carries them, so a caller that has none simply omits those segments rather
+ * than filling them in.
+ */
+function line(state, opts) {
+  const o = opts || {};
+  const s = state || {};
+  const totals = s.totals || {};
+  const running = inFlight(s);
+  const calls = typeof totals.calls === 'number' ? totals.calls : 0;
+
+  // Nothing has happened and nothing is happening: say nothing.
+  if (!calls && !running.length) return '';
+
+  const parts = ['prowl'];
+
+  if (running.length) {
+    const head = running[0];
+    const since = elapsed(head.at, o.now);
+    const more = running.length > 1 ? ` +${running.length - 1}` : '';
+    parts.push(`⟳ ${short(head.tool)}${since ? ` ${since}` : ''}${more}`);
+  }
+
+  if (calls) {
+    const ok = typeof totals.ok === 'number' ? totals.ok : 0;
+    const failed = typeof totals.failed === 'number' ? totals.failed : 0;
+    // "1 calls" is what a widget nobody looked at says. Found by looking at one.
+    parts.push(`${calls} ${calls === 1 ? 'call' : 'calls'} ${ok}✓${failed ? ` ${failed}✗` : ''}`);
+    // The server's own figure wins when it volunteered one — it is what Prowl says it
+    // charged, against what this session happened to observe. Marked, so the two are
+    // never read as the same claim.
+    const server = s.server && typeof s.server.usd === 'number' ? money(s.server.usd) : null;
+    // `$—` is not `$0.00`: the first says no response has reported a charge, the
+    // second says a response reported one and it was nothing.
+    parts.push(server ? `${server} billed` : (money(totals.usd) || '$—'));
+  }
+
+  if (s.progress && typeof s.progress.value === 'number') {
+    parts.push(`${Math.round(s.progress.value * 100)}% done`);
+  }
+
+  const used = o.context && typeof o.context.used_percentage === 'number'
+    ? Math.round(o.context.used_percentage) : null;
+  if (used !== null) parts.push(`ctx ${used}%`);
+
+  const claude = o.cost && typeof o.cost.total_cost_usd === 'number' ? money(o.cost.total_cost_usd) : null;
+  if (claude) parts.push(`claude ${claude}`);
+
+  const tick = ticker(s, o.tickerLimit);
+  if (tick) parts.push(`▸ ${tick}`);
+
+  return fit(parts, o.columns);
+}
+
+/**
+ * Join, and drop from the end until it fits the terminal.
+ *
+ * The status-line reference is explicit that a script cannot read the terminal width
+ * itself and must use `COLUMNS`. Where the caller knows it, the ticker is shed first:
+ * it is the segment whose absence costs the least, and the segments before it answer
+ * questions the ticker does not.
+ */
+function fit(parts, columns) {
+  const width = typeof columns === 'number' && columns > 20 ? columns : null;
+  let out = parts.join(SEP);
+  if (!width) return out;
+  const kept = parts.slice();
+  while (kept.length > 1 && visibleLength(out) > width) {
+    kept.pop();
+    out = kept.join(SEP);
+  }
+  return out;
+}
+
+/** Length as the terminal sees it: the glyphs used here are all single-width. */
+function visibleLength(text) {
+  return Array.from(String(text || '')).length;
+}
+
+/**
+ * The chat notice for the two things worth interrupting for.
+ *
+ * Everything else this plugin knows belongs on the status line, where it costs the
+ * reader nothing. A notice that fires on every finished call is a notice that gets
+ * skimmed, and then the wallet gate is skimmed with it.
+ */
+function block(record) {
+  if (!record || record.ok !== false || !record.error) return '';
+  const tool = short(record.tool);
+  if (record.error.gate) {
+    return `[prowl] \`${tool}\` was stopped before it ran: the wallet has no balance for it. `
+      + 'Nothing was charged. Top up at MCP Home (https://prowl.chat) — or run the free '
+      + 'catalogue tools (`prowl_list_tools`, `prowl_search_tools`, `prowl_tool_info`) meanwhile.';
+  }
+  return `[prowl] \`${tool}\` failed: ${record.error.message}`;
+}
+
+module.exports = { line, block, ticker, elapsed, money, inFlight, short, fit, visibleLength, SEP };