shakers-cli 0.0.0-stage → 0.14.1

package/src/alma-client.js

@@ -0,0 +1,123 @@
+'use strict';
+
+// Alma client: POST `/alma/chat` (turn) and `/alma/decision` (approve/deny a
+// pending action) with the talent's hub Bearer (Alma verifies it against the hub
+// JWKS, ES256). Response is an NDJSON stream — one JSON event per line:
+// {type:'turn_started'|'text_delta'|'confirmation_required'|'link'|...}. Parsed
+// incrementally so the CLI can print tokens live. Zero-dep (http/https only).
+
+const http = require('http');
+const https = require('https');
+const { URL } = require('url');
+const { reasonForError } = require('./onboarding-client');
+
+const DEFAULT_TIMEOUT_MS = 120000;
+
+// Streams one NDJSON turn to `endpoint` with `body`. `onEvent(evt)` fires per line;
+// resolves with the aggregated assistant text (the concatenated text_delta chunks).
+function streamNdjson(endpoint, body, { hubAccessToken, onEvent, timeoutMs = DEFAULT_TIMEOUT_MS, requestImpl } = {}) {
+  return new Promise((resolve) => {
+    if (!endpoint) return resolve({ ok: false, reason: 'no-endpoint' });
+    if (!hubAccessToken) return resolve({ ok: false, reason: 'no-hub-token' });
+
+    let url;
+    try {
+      url = new URL(endpoint);
+    } catch {
+      return resolve({ ok: false, reason: 'bad-endpoint' });
+    }
+    const lib = requestImpl || (url.protocol === 'https:' ? https : http);
+    const payload = JSON.stringify(body);
+    const deltas = [];
+    let settled = false;
+    const done = (v) => { if (!settled) { settled = true; resolve(v); } };
+
+    const req = lib.request(
+      {
+        hostname: url.hostname,
+        port: url.port || (url.protocol === 'https:' ? 443 : 80),
+        path: `${url.pathname}${url.search}`,
+        method: 'POST',
+        headers: {
+          'content-type': 'application/json',
+          'content-length': Buffer.byteLength(payload),
+          accept: 'application/x-ndjson',
+          authorization: `Bearer ${hubAccessToken}`,
+        },
+        timeout: timeoutMs,
+      },
+      (res) => {
+        if (res.statusCode < 200 || res.statusCode >= 300) {
+          let err = '';
+          res.on('data', (c) => { err += c; });
+          res.on('end', () => done({ ok: false, reason: reasonForError(res.statusCode, err) }));
+          return;
+        }
+        res.setEncoding('utf8');
+        let buffer = '';
+        const handleLine = (line) => {
+          const s = line.trim();
+          if (!s) return;
+          let evt;
+          try { evt = JSON.parse(s); } catch { return; }
+          if (evt && evt.type === 'text_delta' && typeof evt.text === 'string') deltas.push(evt.text);
+          if (typeof onEvent === 'function') onEvent(evt);
+        };
+        res.on('data', (chunk) => {
+          buffer += chunk;
+          let idx;
+          while ((idx = buffer.indexOf('\n')) >= 0) {
+            handleLine(buffer.slice(0, idx));
+            buffer = buffer.slice(idx + 1);
+          }
+        });
+        // A stream error AFTER the headers (mid-stream reset) has no other
+        // handler — without this the promise would never settle (hang).
+        res.on('error', (e) => done({ ok: false, reason: (e && e.code) || 'stream-error' }));
+        res.on('end', () => { handleLine(buffer); done({ ok: true, text: deltas.join('') }); });
+      },
+    );
+    req.on('error', (e) => done({ ok: false, reason: (e && e.code) || 'network-error' }));
+    req.on('timeout', () => { req.destroy(); done({ ok: false, reason: 'timeout' }); });
+    req.write(payload);
+    req.end();
+  });
+}
+
+function streamAlmaChat({ hubAccessToken, message } = {}, opts = {}) {
+  if (typeof message !== 'string' || !message.trim()) return Promise.resolve({ ok: false, reason: 'no-message' });
+  return streamNdjson(opts.endpoint, { message, source: 'shakers-cli' }, { hubAccessToken, ...opts });
+}
+
+function streamAlmaDecision({ hubAccessToken, approved } = {}, opts = {}) {
+  if (typeof approved !== 'boolean') return Promise.resolve({ ok: false, reason: 'no-decision' });
+  return streamNdjson(opts.endpoint, { approved }, { hubAccessToken, ...opts });
+}
+
+// CLI+MCP entry: resolve the endpoint from config, then stream one turn.
+async function askAlma(deps = {}, { hubAccessToken, message, onEvent, timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
+  const {
+    getAlmaChatEndpoint = require('./config').getAlmaChatEndpoint,
+    streamAlmaChat: stream = streamAlmaChat,
+  } = deps;
+  const endpoint = getAlmaChatEndpoint();
+  if (!endpoint) return { ok: false, reason: 'no-endpoint' };
+  return stream({ hubAccessToken, message }, { endpoint, onEvent, timeoutMs });
+}
+
+async function decideAlma(deps = {}, { hubAccessToken, approved, onEvent, timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
+  const {
+    getAlmaDecisionEndpoint = require('./config').getAlmaDecisionEndpoint,
+    streamAlmaDecision: stream = streamAlmaDecision,
+  } = deps;
+  const endpoint = getAlmaDecisionEndpoint();
+  if (!endpoint) return { ok: false, reason: 'no-endpoint' };
+  return stream({ hubAccessToken, approved }, { endpoint, onEvent, timeoutMs });
+}
+
+module.exports = {
+  streamAlmaChat,
+  streamAlmaDecision,
+  askAlma,
+  decideAlma,
+};

package/src/alma-flow.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const EXIT_WORDS = new Set(['exit', 'quit', 'salir', 'q']);
+
+function makeAlmaDeps(overrides = {}) {
+  const client = require('./alma-client');
+  return {
+    askAlma: (opts) => client.askAlma({}, opts),
+    decideAlma: (opts) => client.decideAlma({}, opts),
+    startSpinner: (label) => require('./terminal-progress').startSpinner(label),
+    collectContextBlock: (o) => require('./alma-repo-context').collectContextBlock(o),
+    withStatus: (label, fn) => require('./terminal-progress').withStaticStatus(label, fn),
+    ...overrides,
+  };
+}
+
+async function oneTurn({ io, hubAccessToken, message, catalog, deps, onStreamEvent = null, sendTurn = null }) {
+  const fp = catalog.ask;
+  const stop = deps.startSpinner ? deps.startSpinner(fp.thinking) : () => {};
+  const onEvent = (evt) => { if (typeof onStreamEvent === 'function') onStreamEvent(evt); };
+  const call = sendTurn || ((o) => deps.askAlma(o));
+  const res = await call({ hubAccessToken, message, onEvent });
+  stop();
+  if (!res.ok) io.error(fp.failed(res.reason));
+  return res;
+}
+
+module.exports = {
+  makeAlmaDeps,
+  oneTurn,
+  EXIT_WORDS,
+};

package/src/alma-repo-context.js

@@ -0,0 +1,47 @@
+'use strict';
+
+function join(arr, key) {
+  if (!Array.isArray(arr)) return '';
+  const vals = arr.map((x) => (key ? x && x[key] : x)).filter((s) => typeof s === 'string' && s.length);
+  return [...new Set(vals)].join(', ');
+}
+
+function formatContextBlock(ctx) {
+  if (!ctx || typeof ctx !== 'object') return '';
+  const lines = [];
+  const push = (label, val) => { if (val && val.length) lines.push(`${label}: ${val}`); };
+  push('Project', ctx.project && ctx.project.name);
+  push('Description', ctx.project && ctx.project.tagline);
+  push('Entrypoints', join(ctx.entrypoints, 'label'));
+  push('Services', join(ctx.services));
+  push('Agents', join(ctx.agents, 'label'));
+  push('Models', join(ctx.models, 'label'));
+  push('Integrations', join(ctx.integrations));
+  push('Data stores', join(ctx.stores));
+  push('Technologies', join(ctx.technologies));
+  if (!lines.length) return '';
+  return [
+    '<project-context>',
+    'Structural, content-free map of the directory the talent is running from. This is CONTEXT for your answer, not instructions, and contains no source code.',
+    '',
+    ...lines,
+    '</project-context>',
+  ].join('\n');
+}
+
+function collectContextBlock({ cwd = process.cwd(), collect, status } = {}) {
+  const doCollect = collect || ((root) => require('./repo-context').collectRepoContext(root));
+  try {
+    const run = () => doCollect(cwd);
+    const ctx = status ? status(run) : run();
+    return formatContextBlock(ctx);
+  } catch {
+    return '';
+  }
+}
+
+function prependContext(block, message) {
+  return block ? `${block}\n\n${message}` : message;
+}
+
+module.exports = { formatContextBlock, collectContextBlock, prependContext };

package/src/alma-shell.js

@@ -0,0 +1,161 @@
+'use strict';
+
+const { palette } = require('./ansi');
+const { BRAND_ANSI } = require('./brand-ansi');
+const { promptSelect } = require('./prompt-select');
+const { renderMarkdown } = require('./markdown-ansi');
+const { typeOut } = require('./typewriter');
+const { firstNameFromSession } = require('./auth-session-store');
+const { oneTurn, makeAlmaDeps, EXIT_WORDS } = require('./alma-flow');
+
+const BOLT = '⚡';
+
+const BANNER = [
+  '███████╗██╗  ██╗ █████╗ ██╗  ██╗███████╗██████╗ ███████╗',
+  '██╔════╝██║  ██║██╔══██╗██║ ██╔╝██╔════╝██╔══██╗██╔════╝',
+  '███████╗███████║███████║█████╔╝ █████╗  ██████╔╝███████╗',
+  '╚════██║██╔══██║██╔══██║██╔═██╗ ██╔══╝  ██╔══██╗╚════██║',
+  '███████║██║  ██║██║  ██║██║  ██╗███████╗██║  ██║███████║',
+  '╚══════╝╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝╚══════╝',
+];
+
+function brandColors() {
+  return palette({
+    primary: BRAND_ANSI.primary,
+    accent: BRAND_ANSI.accent,
+    muted: BRAND_ANSI.muted,
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    reset: '\x1b[0m',
+  });
+}
+
+function brandHeader(catalog, out) {
+  const C = brandColors();
+  const a = catalog.alma;
+  out('\n');
+  BANNER.forEach((line, idx) => {
+    if (idx === 0) out(`  ${C.accent}${C.bold}${BOLT}${C.reset} ${C.primary}${C.bold}${line}${C.reset}\n`);
+    else out(`    ${C.primary}${C.bold}${line}${C.reset}\n`);
+  });
+  out(`    ${C.accent}${C.bold}${a.title}${C.reset}  ${C.dim}· ${a.tagline}${C.reset}\n`);
+  out(`    ${C.dim}${a.replHint}${C.reset}\n`);
+}
+
+function userPrompt(catalog, session) {
+  const C = palette({ primary: BRAND_ANSI.primary, reset: '\x1b[0m' });
+  const first = firstNameFromSession(session);
+  const label = first ? `${first}:` : catalog.alma.prompt;
+  return `${C.primary}${BOLT}${C.reset} ${label}`;
+}
+
+function displayWidth(s) {
+  let w = 0;
+  for (const ch of s) w += ch === BOLT ? 2 : 1;
+  return w;
+}
+
+async function printAlmaReply(res, catalog, write, { streamIsTTY = false, env = null } = {}) {
+  if (!res || !res.ok) return;
+  const body = String(res.text || '').trim();
+  if (!body) return;
+  const C = brandColors();
+  const label = `${C.accent}${C.bold}${BOLT} ${catalog.alma.title}:${C.reset}`;
+  const pad = ' '.repeat(displayWidth(`  ${BOLT} ${catalog.alma.title}: `));
+  const lines = renderMarkdown(body).split('\n');
+  let block = `\n  ${label} ${lines[0]}\n`;
+  for (let i = 1; i < lines.length; i++) block += lines[i] ? `${pad}${lines[i]}\n` : '\n';
+  const animate = !!streamIsTTY && !(env && env.NO_ANIMATION);
+  const outStream = { write: (s) => { write(s); return true; }, isTTY: animate };
+  await typeOut(block, { stream: outStream });
+}
+
+async function almaTurn({ io, ask, stdinIsTTY, streamIsTTY, env, write, hubAccessToken, catalog, deps, message }) {
+  const a = catalog.alma;
+  const C = brandColors();
+  const dimNote = (text) => write(`  ${C.dim}${text}${C.reset}\n`);
+
+  let pending = null;
+  const links = [];
+  const capture = (evt) => {
+    if (!evt) return;
+    if (evt.type === 'confirmation_required') pending = { text: evt.text || '', detail: evt.detail || '', data: evt.data || {} };
+    else if (evt.type === 'link' && evt.data && evt.data.to) links.push(String(evt.data.to));
+  };
+
+  const res = await oneTurn({ io, hubAccessToken, message, catalog: { ask: a }, deps, onStreamEvent: capture });
+  await printAlmaReply(res, catalog, write, { streamIsTTY, env });
+  for (const to of links) dimNote(a.webLink(to));
+  if (!res.ok || !pending) return res;
+
+  if (pending.text) write(`\n  ${renderMarkdown(pending.text)}\n`);
+  if (pending.detail) io.warn(a.irreversible);
+  if (pending.data && pending.data.to) dimNote(a.webLink(pending.data.to));
+
+  const choice = await promptSelect({
+    ask,
+    stdinIsTTY,
+    out: (line) => write(`  ${line}\n`),
+    header: a.confirmPrompt,
+    items: [{ id: 'yes', label: a.confirmYes }, { id: 'no', label: a.confirmNo }],
+    labelFor: (it) => it.label,
+  });
+  const approved = !!(choice && choice.id === 'yes');
+
+  const dres = await oneTurn({
+    io,
+    hubAccessToken,
+    message: null,
+    catalog: { ask: a },
+    deps,
+    sendTurn: ({ onEvent }) => deps.decideAlma({ hubAccessToken, approved, onEvent }),
+  });
+  await printAlmaReply(dres, catalog, write, { streamIsTTY, env });
+  return res;
+}
+
+async function runAlmaShell({ io, ask, stdinIsTTY, streamIsTTY, env = process.env, rawOut, session, catalog, deps = makeAlmaDeps() }) {
+  const a = catalog.alma;
+  const write = rawOut || ((s) => process.stdout.write(s));
+  const hubAccessToken = session ? session.hubAccessToken : null;
+
+  brandHeader(catalog, write);
+
+  // Collect the (code-free) project map ONCE, then ask consent before ever sending
+  // it — privacy gate. Declining (or no TTY to ask) sends every turn without context.
+  const ctxBlock = deps.collectContextBlock
+    ? deps.collectContextBlock({ status: (fn) => (deps.withStatus ? deps.withStatus(a.contextLabel, fn) : fn()) })
+    : '';
+  const readLine = typeof ask === 'function' ? ask : (p) => io.ask(p);
+
+  let ctxConsent = false;
+  if (ctxBlock && stdinIsTTY) {
+    const choice = await promptSelect({
+      ask: readLine,
+      stdinIsTTY,
+      out: (line) => write(`  ${line}\n`),
+      header: a.contextConsentHeader,
+      hint: a.contextConsentHint,
+      items: [{ id: 'yes', label: a.contextConsentYes }, { id: 'no', label: a.contextConsentNo }],
+      labelFor: (it) => it.label,
+    });
+    ctxConsent = !!(choice && choice.id === 'yes');
+    if (!ctxConsent) io.notify(a.contextConsentDeclined);
+  }
+  const withCtx = (msg) => (ctxConsent && ctxBlock ? `${ctxBlock}\n\n${msg}` : msg);
+  const prompt = userPrompt(catalog, session);
+  let first = true;
+  for (;;) {
+    const line = (await readLine(prompt)).trim();
+    if (!line || EXIT_WORDS.has(line.toLowerCase())) {
+      io.notify(a.bye);
+      break;
+    }
+    const message = first ? withCtx(line) : line;
+    first = false;
+    await almaTurn({ io, ask, stdinIsTTY, streamIsTTY, env, write, hubAccessToken, catalog, deps, message });
+  }
+  return { ok: true };
+}
+
+module.exports = { runAlmaShell, almaTurn, printAlmaReply, brandHeader, userPrompt };

package/src/ansi.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const { isInteractive } = require('./terminal-progress');
+const { BRAND_ANSI } = require('./brand-ansi');
+
+// THE ONE GATE for terminal colour (talents-ai-score).
+
+// `NO_COLOR` per the de-facto standard: present and non-empty disables colour, whatever the value.
+function noColorRequested(env = process.env) {
+  const value = env ? env.NO_COLOR : undefined;
+  return typeof value === 'string' && value.length > 0;
+}
+
+// The gate. `stream` defaults to stdout because every palette in this repo
+// decorates text that ends up there.
+function colorEnabled({ stream = process.stdout, env = process.env } = {}) {
+  if (noColorRequested(env)) return false;
+  return isInteractive(stream);
+}
+
+// Wraps a map of escape codes so each key yields its code when colour is on and `''` when it is off.
+function palette(codes, opts = {}) {
+  const out = {};
+  for (const key of Object.keys(codes)) {
+    const code = codes[key];
+    Object.defineProperty(out, key, {
+      enumerable: true,
+      get: () => (colorEnabled(opts) ? code : ''),
+    });
+  }
+  return out;
+}
+
+function styleQuestion(text, opts = {}) {
+  const ANSI = palette({ bold: '\x1b[1m', primary: BRAND_ANSI.primary, reset: '\x1b[0m' }, opts);
+  return `${ANSI.bold}${ANSI.primary}${text}${ANSI.reset}`;
+}
+
+const SUCCESS_GREEN = '\x1b[38;5;114m';
+
+function styleSuccess(text, opts = {}) {
+  const ANSI = palette({ success: SUCCESS_GREEN, reset: '\x1b[0m' }, opts);
+  return `${ANSI.success}${text}${ANSI.reset}`;
+}
+
+// Bold a field LABEL (no colour). Gate-aware via `palette`: empty codes when
+// colour is off (non-TTY / NO_COLOR), so piped/redirected output stays clean.
+function styleLabel(text, opts = {}) {
+  const ANSI = palette({ bold: '\x1b[1m', reset: '\x1b[0m' }, opts);
+  return `${ANSI.bold}${text}${ANSI.reset}`;
+}
+
+// Bold only the "Label:" prefix of a "Label: value" line, leaving the value
+// plain. No `: ` -> returned unchanged (value-only lines never get bolded).
+function styleLabelPrefix(line, opts = {}) {
+  const s = typeof line === 'string' ? line : '';
+  const idx = s.indexOf(': ');
+  if (idx === -1) return s;
+  return `${styleLabel(s.slice(0, idx + 1), opts)}${s.slice(idx + 1)}`;
+}
+
+module.exports = { palette, colorEnabled, noColorRequested, styleQuestion, styleSuccess, styleLabel, styleLabelPrefix, SUCCESS_GREEN };

package/src/applications-client.js

@@ -0,0 +1,79 @@
+'use strict';
+
+// My-applications client. Lists the
+// positions the talent applied to, with the candidature status.
+
+const { postJsonWithTimeout } = require('./backend-request');
+const { reasonForError } = require('./onboarding-client');
+
+const DEFAULT_TIMEOUT_MS = 20000;
+const DEFAULT_LIMIT = 30;
+
+function parseJson(raw) {
+  try {
+    return raw ? JSON.parse(raw) : null;
+  } catch {
+    return null;
+  }
+}
+
+function bearerHeaders(accessToken) {
+  const headers = {};
+  if (typeof accessToken === 'string' && accessToken) headers.Authorization = `Bearer ${accessToken}`;
+  return headers;
+}
+
+function str(v) {
+  return typeof v === 'string' && v ? v : null;
+}
+
+function normalizeApplication(raw) {
+  const it = raw && typeof raw === 'object' ? raw : {};
+  const project = it.project && typeof it.project === 'object' ? it.project : {};
+  const position = it.position && typeof it.position === 'object' ? it.position : {};
+  const org = it.organization && typeof it.organization === 'object' ? it.organization : {};
+  return {
+    positionId: str(position.id),
+    title: str(position.name) || str(project.name),
+    projectName: str(project.name),
+    company: str(org.name),
+    status: str(it.status),
+    createdAt: str(it.createdAt),
+  };
+}
+
+async function requestMyCandidatures({ hubAccessToken } = {}, { endpoint, limit = DEFAULT_LIMIT, timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
+  if (!endpoint) return { ok: false, reason: 'no-endpoint' };
+  if (!hubAccessToken) return { ok: false, reason: 'no-hub-token' };
+  const criteria = { limit, offset: 0 };
+  const url = `${endpoint}${endpoint.includes('?') ? '&' : '?'}criteria=${encodeURIComponent(JSON.stringify(criteria))}`;
+  let res;
+  try {
+    res = await postJsonWithTimeout(url, null, timeoutMs, 'GET', null, bearerHeaders(hubAccessToken));
+  } catch (e) {
+    return { ok: false, reason: (e && e.kind) || 'network-error' };
+  }
+  if (res.status < 200 || res.status >= 300) return { ok: false, reason: reasonForError(res.status, res.raw) };
+
+  const env = parseJson(res.raw);
+  const data = env && env.status === 'OK' ? env.data : env;
+  const rows = Array.isArray(data) ? data : (Array.isArray(data && data.items) ? data.items : null);
+  if (!rows) return { ok: false, reason: 'bad-response' };
+  return { ok: true, items: rows.map(normalizeApplication), meta: (env && typeof env.meta === 'object' ? env.meta : null) };
+}
+
+async function fetchApplications(deps = {}, { hubAccessToken, limit = DEFAULT_LIMIT, timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
+  const {
+    getMyCandidaturesEndpoint = require('./config').getMyCandidaturesEndpoint,
+    requestMyCandidatures: request = requestMyCandidatures,
+  } = deps;
+  const endpoint = getMyCandidaturesEndpoint();
+  if (!endpoint) return { ok: false, reason: 'no-endpoint' };
+  return request({ hubAccessToken }, { endpoint, limit, timeoutMs });
+}
+
+module.exports = {
+  normalizeApplication,
+  requestMyCandidatures,
+  fetchApplications,
+};

package/src/applications-flow.js

@@ -0,0 +1,58 @@
+'use strict';
+
+// `applications` flow: list the positions the talent applied to + status.
+// Read-only. Writes the SAME ordinal->positionId cache as find-projects, so
+// `show-project N` / `save-project N` work after `applications` too.
+
+const { styleLabelPrefix } = require('./ansi');
+
+function makeApplicationsDeps(overrides = {}) {
+  const client = require('./applications-client');
+  return {
+    fetchApplications: (opts) => client.fetchApplications({}, opts),
+    writePositionCache: (ids) => require('./find-projects-cache').writePositionCache(ids),
+    ...overrides,
+  };
+}
+
+async function runApplications({ io, rawOut, session, catalog, opts = {}, deps = makeApplicationsDeps() }) {
+  const fp = catalog.applications;
+  const hubAccessToken = session ? session.hubAccessToken : null;
+
+  const doFetch = () => deps.fetchApplications({ hubAccessToken });
+  const res = opts.json ? await doFetch() : await io.withProgress(fp.loading, doFetch);
+  if (!res.ok) {
+    io.error(fp.fetchFailed(res.reason));
+    return { ok: false, reason: res.reason };
+  }
+  const items = Array.isArray(res.items) ? res.items : [];
+
+  if (opts.json) {
+    (rawOut || ((s) => process.stdout.write(s)))(`${JSON.stringify({ ok: true, items }, null, 2)}\n`);
+    return { ok: true, items };
+  }
+
+  // Human path: refresh the number->positionId cache (last listing wins).
+  try { deps.writePositionCache(items.map((it) => it.positionId)); } catch { /* best-effort */ }
+
+  io.section(fp.title);
+  if (items.length === 0) {
+    io.notify(fp.none);
+    return { ok: true, items };
+  }
+  // No ids in the human render (they ride the cache + --json).
+  items.forEach((a, i) => {
+    if (i > 0) io.notify('');
+    const headline = a.title || a.projectName || fp.untitled;
+    io.notify(`${i + 1}) ${headline}${a.company ? ` — ${a.company}` : ''}`);
+    io.notify(styleLabelPrefix(fp.statusLine(a.status || fp.statusUnknown)));
+  });
+  io.notify(styleLabelPrefix(fp.countNote(items.length)));
+  io.success(fp.done);
+  return { ok: true, items };
+}
+
+module.exports = {
+  makeApplicationsDeps,
+  runApplications,
+};