@wji.ai/cli 0.7.0 → 0.7.1

package/dist/commands/npc-album.js

@@ -1,201 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { existsSync } from 'node:fs';
-import { basename } from 'node:path';
-import { Command } from 'commander';
-import { WjiClient, isObjectId } from '../core/client.js';
-import { RESIDENTS, npcLabel, resolveNpc } from '../core/npc.js';
-import { color, info, render, success, table, truncate } from '../core/output.js';
-import { confirm } from '../core/prompt.js';
-const LABEL_MAX = 120;
-const DESCRIPTION_MAX = 500;
-async function loadAlbums(client, residentId) {
-    const rows = (await client.getFresh(`${RESIDENTS}/${residentId}/albums`)) || [];
-    return rows.map((a, i) => ({ ...a, n: i + 1 }));
-}
-/** `<album>` is a 1-based number or an album id. */
-function pickAlbum(albums, token) {
-    const album = /^\d+$/.test(token) ? albums[Number(token) - 1] : albums.find((a) => a.id === token);
-    if (!album)
-        throw new Error(`Album ${token} not found — there are ${albums.length}`);
-    return album;
-}
-/**
- * A photo token is `<assetId|local file|https url>[:label]`. Local files are
- * uploaded; asset ids are resolved to their URL (albums store the URL).
- */
-async function toPhoto(client, token) {
-    const m = token.match(/^(https?:\/\/[^\s]+?|[^:]+)(?::(.*))?$/);
-    const source = m?.[1] ?? token;
-    const label = (m?.[2] ?? '').trim();
-    if (/^https?:\/\//.test(source))
-        return { id: `photo_${randomUUID().slice(0, 12)}`, url: source, label };
-    let asset;
-    if (existsSync(source)) {
-        info(color.dim(`Uploading ${basename(source)}…`));
-        asset = await client.upload('/assets/v2/upload', source, {});
-    }
-    else if (isObjectId(source)) {
-        asset = await client.get(`/assets/list/${source}`);
-    }
-    else {
-        throw new Error(`"${source}" is not a file, an asset id or a URL`);
-    }
-    if (!asset?.url)
-        throw new Error(`Asset ${asset?.id ?? source} has no URL yet`);
-    return { id: `photo_${randomUUID().slice(0, 12)}`, assetId: asset.id, url: asset.url, label };
-}
-function printAlbums(albums) {
-    table(albums, [
-        { header: '#', value: (a) => a.n },
-        { header: 'id', value: (a) => a.id },
-        { header: 'name', value: (a) => truncate(a.name, 28) },
-        { header: 'photos', value: (a) => (a.photos || []).length },
-        { header: 'description', value: (a) => truncate(a.description, 44) },
-    ]);
-}
-function printPhotos(album) {
-    info(`${color.bold(album.name)}${album.description ? color.dim(` — ${truncate(album.description, 80)}`) : ''}`);
-    table((album.photos || []).map((p, i) => ({ ...p, n: i + 1 })), [
-        { header: '#', value: (p) => p.n + (album.cover === p.url ? color.green(' ★') : '') },
-        { header: 'label', value: (p) => truncate(p.label, 30) },
-        { header: 'asset', value: (p) => p.assetId || '' },
-        { header: 'url', value: (p) => truncate(p.url, 48) },
-    ]);
-}
-const checkText = (label, description) => {
-    if (label !== undefined && label.length > LABEL_MAX)
-        throw new Error(`--name is ${label.length} chars; the limit is ${LABEL_MAX}`);
-    if (description !== undefined && description.length > DESCRIPTION_MAX) {
-        throw new Error(`--description is ${description.length} chars; the limit is ${DESCRIPTION_MAX}`);
-    }
-};
-export function albumCommand(globals) {
-    const album = new Command('album')
-        .aliases(['albums'])
-        .description("An NPC's photo albums on its profile — each one a moment in its life");
-    album.command('list <npc> [album]', { isDefault: true })
-        .description('List albums, or the photos of one (number or id)')
-        .action(async (token, which) => {
-        const client = new WjiClient(globals());
-        const r = await resolveNpc(client, token);
-        const albums = await loadAlbums(client, r.id);
-        if (which) {
-            const a = pickAlbum(albums, which);
-            return render(a, () => printPhotos(a));
-        }
-        render(albums, () => printAlbums(albums));
-    });
-    album.command('create <npc>')
-        .description('Create an album; photos are asset ids, local files or URLs, each optionally :label')
-        .requiredOption('--name <text>', `album title (≤${LABEL_MAX})`)
-        .option('-d, --description <text>', `what this moment was (≤${DESCRIPTION_MAX})`)
-        .option('--photo <photo...>', 'assetId[:label] | ./file.jpg[:label] | https://…[:label], in order')
-        .action(async (token, opts) => {
-        checkText(opts.name, opts.description);
-        const client = new WjiClient(globals());
-        const r = await resolveNpc(client, token);
-        const photos = [];
-        for (const p of opts.photo || [])
-            photos.push(await toPhoto(client, p));
-        const created = await client.post(`${RESIDENTS}/${r.id}/albums`, {
-            label: opts.name,
-            description: opts.description,
-            photos,
-            cover: photos[0]?.url,
-        });
-        render(created, (a) => {
-            success(`Created album "${a.name}" for ${npcLabel(r)} with ${(a.photos || []).length} photo(s)`);
-            printPhotos(a);
-        });
-    });
-    album.command('add <npc> <album> <photo...>')
-        .description('Append photos (assetId[:label] | file[:label] | url[:label])')
-        .action(async (token, which, tokens) => {
-        const client = new WjiClient(globals());
-        const r = await resolveNpc(client, token);
-        const a = pickAlbum(await loadAlbums(client, r.id), which);
-        const added = [];
-        for (const p of tokens)
-            added.push(await toPhoto(client, p));
-        const updated = await client.patch(`${RESIDENTS}/${r.id}/albums/${a.id}`, { photos: [...(a.photos || []), ...added] });
-        render(updated, (u) => {
-            success(`Added ${added.length} photo(s) to "${u.name}"`);
-            printPhotos(u);
-        });
-    });
-    album.command('set <npc> <album>')
-        .description('Rename, re-describe, pick the cover (photo number) or relabel a photo')
-        .option('--name <text>', 'title')
-        .option('-d, --description <text>', 'description')
-        .option('--cover <n>', 'photo number to use as the cover')
-        .option('--label <n=text...>', 'relabel photos, e.g. --label 2="the night the mic drowned"')
-        .action(async (token, which, opts) => {
-        checkText(opts.name, opts.description);
-        const client = new WjiClient(globals());
-        const r = await resolveNpc(client, token);
-        const a = pickAlbum(await loadAlbums(client, r.id), which);
-        const photos = [...(a.photos || [])];
-        const patch = {};
-        if (opts.name !== undefined)
-            patch.label = opts.name;
-        if (opts.description !== undefined)
-            patch.description = opts.description;
-        if (opts.cover !== undefined) {
-            const p = photos[Number(opts.cover) - 1];
-            if (!p)
-                throw new Error(`Photo ${opts.cover} does not exist`);
-            patch.cover = p.url;
-        }
-        for (const pair of opts.label || []) {
-            const [n, ...rest] = String(pair).split('=');
-            const p = photos[Number(n) - 1];
-            if (!p)
-                throw new Error(`Photo ${n} does not exist`);
-            photos[Number(n) - 1] = { ...p, label: rest.join('=') };
-            patch.photos = photos;
-        }
-        if (!Object.keys(patch).length)
-            throw new Error('Nothing to change');
-        const updated = await client.patch(`${RESIDENTS}/${r.id}/albums/${a.id}`, patch);
-        render(updated, (u) => {
-            success(`Updated "${u.name}"`);
-            printPhotos(u);
-        });
-    });
-    album.command('rm-photo <npc> <album> <n...>')
-        .description('Remove photos by number')
-        .option('-y, --yes', 'skip confirmation')
-        .action(async (token, which, ns, opts) => {
-        const client = new WjiClient(globals());
-        const r = await resolveNpc(client, token);
-        const a = pickAlbum(await loadAlbums(client, r.id), which);
-        const drop = new Set(ns.map((n) => {
-            const i = Number(n) - 1;
-            if (!a.photos?.[i])
-                throw new Error(`Photo ${n} does not exist`);
-            return i;
-        }));
-        if (!(await confirm(`Remove ${drop.size} photo(s) from "${a.name}"?`, opts.yes)))
-            return info('Aborted');
-        const photos = (a.photos || []).filter((_, i) => !drop.has(i));
-        const coverGone = !photos.some((p) => p.url === a.cover);
-        const updated = await client.patch(`${RESIDENTS}/${r.id}/albums/${a.id}`, { photos, ...(coverGone ? { cover: '' } : {}) });
-        render(updated, (u) => {
-            success(`Removed ${drop.size} photo(s)`);
-            printPhotos(u);
-        });
-    });
-    album.command('rm <npc> <album>')
-        .description('Delete an album (the photo assets stay in your library)')
-        .option('-y, --yes', 'skip confirmation')
-        .action(async (token, which, opts) => {
-        const client = new WjiClient(globals());
-        const r = await resolveNpc(client, token);
-        const a = pickAlbum(await loadAlbums(client, r.id), which);
-        if (!(await confirm(`Delete album "${a.name}" (${(a.photos || []).length} photos)?`, opts.yes)))
-            return info('Aborted');
-        const result = await client.delete(`${RESIDENTS}/${r.id}/albums/${a.id}`);
-        render(result, () => success(`Deleted "${a.name}"`));
-    });
-    return album;
-}

package/dist/commands/npc-live.js

@@ -1,316 +0,0 @@
-import { writeFile } from 'node:fs/promises';
-import { Command } from 'commander';
-import { WjiClient } from '../core/client.js';
-import { RESIDENTS, npcLabel, resolveNpc } from '../core/npc.js';
-import { color, detail, info, isJsonMode, render, relativeTime, success, table, truncate, warn } from '../core/output.js';
-import { confirm, readValue } from '../core/prompt.js';
-const LIVE = '/npc-city/live';
-export const MEMORY_TYPES = ['formative', 'trauma', 'joy', 'connection', 'revelation'];
-/** What the live reply prompt actually reads: top memories by weight, content clipped. */
-const PROMPT_MEMORIES = 3;
-const PROMPT_MEMORY_CHARS = 140;
-const onOff = (value, flag) => {
-    const v = String(value).toLowerCase();
-    if (!['on', 'off', 'true', 'false'].includes(v))
-        throw new Error(`${flag} takes on | off`);
-    return v === 'on' || v === 'true';
-};
-function weightOf(value) {
-    const n = Number(value);
-    if (!Number.isInteger(n) || n < 1 || n > 5)
-        throw new Error('--weight must be 1–5');
-    return n;
-}
-function typeOf(value) {
-    if (!MEMORY_TYPES.includes(value))
-        throw new Error(`--type must be one of ${MEMORY_TYPES.join(', ')}`);
-    return value;
-}
-/** Memories in table order (oldest first), with the ones the live prompt sees marked. */
-export async function loadMemories(client, residentId) {
-    const rows = (await client.getFresh(`${RESIDENTS}/${residentId}/memories`)) || [];
-    const top = [...rows]
-        // Same order as the server's prompt query: weight desc, then newest first.
-        .sort((a, b) => (b.emotionalWeight || 0) - (a.emotionalWeight || 0) ||
-        new Date(b.createdAt || 0).getTime() - new Date(a.createdAt || 0).getTime())
-        .slice(0, PROMPT_MEMORIES)
-        .map((m) => m.id);
-    return rows.map((m, i) => ({ ...m, n: i + 1, inPrompt: top.includes(m.id) }));
-}
-function printMemories(rows) {
-    table(rows, [
-        { header: '#', value: (m) => m.n },
-        { header: 'live', value: (m) => (m.inPrompt ? color.green('●') : '') },
-        { header: 'date', value: (m) => m.date },
-        { header: 'type', value: (m) => m.type },
-        { header: 'w', value: (m) => m.emotionalWeight },
-        { header: 'title', value: (m) => truncate(m.title, 28) },
-        { header: 'content', value: (m) => truncate(m.content, 44) },
-    ]);
-    if (rows.length)
-        info(color.dim(`● = among the top ${PROMPT_MEMORIES} by weight — the only memories the live reply model sees (content clipped to ${PROMPT_MEMORY_CHARS} chars)`));
-}
-/** Replace the memory table with `memories` (delete the old rows, create the new ones in order). */
-export async function replaceMemories(client, residentId, memories) {
-    const existing = (await client.getFresh(`${RESIDENTS}/${residentId}/memories`)) || [];
-    // Legacy rows (pre-migration fallback) have no real id and cannot be deleted one by one.
-    for (const m of existing)
-        if (m.id)
-            await client.delete(`/npc-city/memories/${m.id}`);
-    const created = [];
-    for (const m of memories) {
-        created.push(await client.post(`${RESIDENTS}/${residentId}/memories`, {
-            date: String(m.date ?? '').slice(0, 40),
-            title: String(m.title ?? '').slice(0, 200),
-            content: String(m.content ?? ''),
-            emotionalWeight: Math.min(5, Math.max(1, Math.round(Number(m.emotionalWeight) || 3))),
-            type: MEMORY_TYPES.includes(m.type) ? m.type : 'formative',
-        }));
-    }
-    return created;
-}
-export function memoryCommand(globals) {
-    const mem = new Command('memory')
-        .aliases(['memories', 'mem'])
-        .description("An NPC's memories — scenes from its past; the 3 heaviest feed every live reply");
-    mem.command('list <npc>', { isDefault: true }).action(async (token) => {
-        const client = new WjiClient(globals());
-        const r = await resolveNpc(client, token);
-        const rows = await loadMemories(client, r.id);
-        render(rows, () => printMemories(rows));
-    });
-    mem.command('add <npc>')
-        .requiredOption('--title <text>', 'short title (≤200)')
-        .requiredOption('--content <text>', 'the scene: place, one sensory detail, what changed (@file / - supported)')
-        .option('--date <date>', 'date or free text (≤40), e.g. 2025-03-01 or "the winter she turned 17"', '')
-        .option('--type <type>', MEMORY_TYPES.join(' | '), 'formative')
-        .option('--weight <1-5>', 'emotional weight; the top 3 reach the live prompt', '3')
-        .action(async (token, opts) => {
-        const client = new WjiClient(globals());
-        const r = await resolveNpc(client, token);
-        const created = await client.post(`${RESIDENTS}/${r.id}/memories`, {
-            date: opts.date,
-            title: opts.title,
-            content: await readValue(opts.content),
-            type: typeOf(opts.type),
-            emotionalWeight: weightOf(opts.weight),
-        });
-        const rows = await loadMemories(client, r.id);
-        render(created, () => {
-            success(`Added memory "${opts.title}" to ${npcLabel(r)}`);
-            printMemories(rows);
-        });
-    });
-    mem.command('set <npc> <n>')
-        .option('--title <text>', 'title')
-        .option('--content <text>', 'content (@file / - supported)')
-        .option('--date <date>', 'date')
-        .option('--type <type>', MEMORY_TYPES.join(' | '))
-        .option('--weight <1-5>', 'emotional weight')
-        .action(async (token, n, opts) => {
-        const client = new WjiClient(globals());
-        const r = await resolveNpc(client, token);
-        const rows = await loadMemories(client, r.id);
-        const m = rows[Number(n) - 1];
-        if (!m)
-            throw new Error(`Memory ${n} does not exist — ${npcLabel(r)} has ${rows.length}`);
-        if (!m.id)
-            throw new Error('This memory is legacy data without an id — re-create it with `memory add`');
-        const patch = {};
-        if (opts.title !== undefined)
-            patch.title = opts.title;
-        if (opts.content !== undefined)
-            patch.content = await readValue(opts.content);
-        if (opts.date !== undefined)
-            patch.date = opts.date;
-        if (opts.type !== undefined)
-            patch.type = typeOf(opts.type);
-        if (opts.weight !== undefined)
-            patch.emotionalWeight = weightOf(opts.weight);
-        if (!Object.keys(patch).length)
-            throw new Error('Nothing to change');
-        const updated = await client.patch(`/npc-city/memories/${m.id}`, patch);
-        const after = await loadMemories(client, r.id);
-        render(updated, () => {
-            success(`Updated memory ${n}`);
-            printMemories(after);
-        });
-    });
-    mem.command('rm <npc> <n...>')
-        .option('-y, --yes', 'skip confirmation')
-        .action(async (token, ns, opts) => {
-        const client = new WjiClient(globals());
-        const r = await resolveNpc(client, token);
-        const rows = await loadMemories(client, r.id);
-        const targets = ns.map((n) => {
-            const m = rows[Number(n) - 1];
-            if (!m)
-                throw new Error(`Memory ${n} does not exist`);
-            return m;
-        });
-        if (!(await confirm(`Delete ${targets.map((m) => `"${m.title}"`).join(', ')}?`, opts.yes)))
-            return info('Aborted');
-        for (const m of targets)
-            await client.delete(`/npc-city/memories/${m.id}`);
-        render({ removed: targets.map((m) => m.id) }, () => success(`Deleted ${targets.length} memory(ies)`));
-    });
-    return mem;
-}
-export function readinessCommand(globals) {
-    return new Command('readiness')
-        .argument('<npc>')
-        .description('Can this NPC go live? Soul integrity, live gate reasons, scenes, voice, stages')
-        .action(async (token) => {
-        const client = new WjiClient(globals());
-        const r = await resolveNpc(client, token);
-        const ready = await client.getFresh(`${LIVE}/residents/${r.id}/readiness`);
-        render(ready, () => {
-            detail([
-                ['npc', npcLabel(r)],
-                ['soul integrity', `${ready.soulIntegrity ?? '?'}%`],
-                ['can prepare', ready.canPrepare ? color.green('yes') : color.red('no')],
-                ['can go live', ready.canGoLive ? color.green('yes') : 'no'],
-                ['live enabled', ready.liveEnabled ? 'yes' : 'no'],
-                ['scenes', (ready.scenes || []).map((s) => s.name).join(', ') || color.dim('none')],
-                ['outfits', (ready.outfits || []).map((s) => s.name).join(', ') || undefined],
-                ['props', (ready.props || []).map((s) => s.name).join(', ') || undefined],
-                ['voice sample', ready.voiceSample ? ready.voiceSample.label || 'yes' : color.dim('none')],
-                ['stages', (ready.stages || []).map((s) => `${s.label || s.id} (${s.status}${s.enabled ? ', on air' : ''})`).join(', ') || color.dim('none')],
-            ]);
-            for (const reason of ready.reasons || [])
-                info(color.red(`  ✗ ${reason}`));
-        });
-    });
-}
-function printStages(rows) {
-    table(rows, [
-        { header: 'id', value: (s) => s.id },
-        { header: 'label', value: (s) => truncate(s.label, 24) },
-        { header: 'status', value: (s) => s.status },
-        { header: 'on', value: (s) => (s.enabled ? color.green('●') : '') },
-        { header: 'debug', value: (s) => (s.debugMode ? color.yellow('debug') : '') },
-        { header: 'scene', value: (s) => truncate(s.sceneName, 20) },
-        { header: 'ratio', value: (s) => s.aspectRatio },
-        { header: 'credits', value: (s) => s.creditsSpent ?? 0 },
-        { header: 'updated', value: (s) => relativeTime(s.updatedAt) },
-    ]);
-}
-function printChanges(changes, warnings = []) {
-    for (const w of warnings)
-        warn(w);
-    if (!changes.length)
-        return;
-    table(changes, [
-        { header: 'field', value: (c) => c.path },
-        { header: 'from', value: (c) => truncate(typeof c.from === 'string' ? c.from : JSON.stringify(c.from), 36) },
-        { header: 'to', value: (c) => truncate(typeof c.to === 'string' ? c.to : JSON.stringify(c.to), 36) },
-    ]);
-}
-export function stageCommand(globals) {
-    const stage = new Command('stage')
-        .aliases(['stages'])
-        .description('Live stages: list, export / apply / import the stage document, debug mode (no rendering)');
-    stage.command('list <npc>', { isDefault: true }).action(async (token) => {
-        const client = new WjiClient(globals());
-        const r = await resolveNpc(client, token);
-        const rows = await client.getFresh(`${LIVE}/residents/${r.id}/stages`);
-        render(rows, () => printStages(rows || []));
-    });
-    stage.command('export <stageId>')
-        .description('Print or save the stage document')
-        .option('--format <format>', 'md | json', 'md')
-        .option('-o, --out <file>', 'write to a file')
-        .action(async (id, opts) => {
-        const client = new WjiClient(globals());
-        const result = await client.getFresh(`${LIVE}/stages/${id}/document`, { format: opts.format });
-        if (opts.out) {
-            await writeFile(opts.out, result.text);
-            return render({ file: opts.out, format: result.format }, () => success(`Wrote ${opts.out}`));
-        }
-        render(result, () => process.stdout.write(result.text.endsWith('\n') ? result.text : `${result.text}\n`));
-    });
-    stage.command('apply <stageId> <text>')
-        .description('Preview a stage document (@file or -), confirm, apply. Text only — nothing is rendered or charged')
-        .option('--dry-run', 'only show the changes')
-        .option('-y, --yes', 'skip confirmation')
-        .action(async (id, source, opts) => {
-        const client = new WjiClient(globals());
-        const text = await readValue(source);
-        const preview = await client.post(`${LIVE}/stages/${id}/document/preview`, { text });
-        const changes = preview.changes || [];
-        if (opts.dryRun || !changes.length) {
-            return render(preview, () => {
-                printChanges(changes, preview.warnings);
-                if (!changes.length)
-                    info('Nothing to apply');
-            });
-        }
-        if (!isJsonMode())
-            printChanges(changes, preview.warnings);
-        if (!(await confirm(`Apply ${changes.length} change(s) to stage ${id}?`, opts.yes)))
-            return info('Aborted');
-        const applied = await client.post(`${LIVE}/stages/${id}/document`, { text });
-        render(applied, (a) => {
-            for (const w of a.warnings || [])
-                warn(w);
-            success(`Applied ${(a.applied || changes).length} change(s)`);
-            info(color.dim('Changed keyframe / clip text does not re-render anything — regenerate those slots on the web (costs credits)'));
-        });
-    });
-    stage.command('import <npc> <text>')
-        .description('Create a Draft stage from a document (@file or -). Free: nothing is rendered until you generate it on the web')
-        .option('-y, --yes', 'skip confirmation')
-        .action(async (token, source, opts) => {
-        const client = new WjiClient(globals());
-        const r = await resolveNpc(client, token);
-        const text = await readValue(source);
-        if (!(await confirm(`Create a new Draft stage for ${npcLabel(r)} from this document?`, opts.yes)))
-            return info('Aborted');
-        const created = await client.post(`${LIVE}/residents/${r.id}/stages/import`, { text });
-        const s = created.stage ?? created;
-        render(created, () => {
-            for (const w of created.warnings || [])
-                warn(w);
-            success(`Created Draft stage "${s.label || ''}" (${s.id}) for ${npcLabel(r)}`);
-            info(color.dim('Next: render keyframe A and the clips on the web (credits), check them, then enable the stage'));
-        });
-    });
-    stage.command('set <stageId>')
-        .description('Stage switches: --debug runs the reply model without rendering video (free rehearsal); --on puts it on air')
-        .option('--debug <on|off>', 'debug mode — replies come back as text + a trace, no video')
-        .option('--on <on|off>', 'the stage viewers get (one per NPC; only a Ready stage)')
-        .option('--label <text>', 'stage label (≤80)')
-        .action(async (id, opts) => {
-        const client = new WjiClient(globals());
-        const patch = {};
-        if (opts.debug !== undefined)
-            patch.debugMode = onOff(opts.debug, '--debug');
-        if (opts.on !== undefined)
-            patch.enabled = onOff(opts.on, '--on');
-        if (opts.label !== undefined)
-            patch.label = String(opts.label).slice(0, 80);
-        if (!Object.keys(patch).length)
-            throw new Error('Nothing to change — pass --debug, --on or --label');
-        const before = await client.getFresh(`${LIVE}/stages/${id}`);
-        if (patch.debugMode === true && before.enabled) {
-            warn('This stage is on air: viewers will get text-only replies while debug mode is on');
-            if (!(await confirm('Turn debug mode on anyway?')))
-                return info('Aborted');
-        }
-        const updated = await client.patch(`${LIVE}/stages/${id}`, patch);
-        render(updated, (s) => success(`Stage ${s.label || id}: ${s.enabled ? 'on air' : 'off air'}${s.debugMode ? ', debug' : ''}`));
-    });
-    stage.command('rm <stageId>')
-        .description('Delete a stage (its rendered keyframes and clips go with it)')
-        .option('-y, --yes', 'skip confirmation')
-        .action(async (id, opts) => {
-        const client = new WjiClient(globals());
-        const s = await client.getFresh(`${LIVE}/stages/${id}`);
-        const spent = s.creditsSpent ? ` — ${s.creditsSpent} credits of renders are lost` : '';
-        if (!(await confirm(`Delete stage "${s.label || id}" (${s.status})${spent}?`, opts.yes)))
-            return info('Aborted');
-        const result = await client.delete(`${LIVE}/stages/${id}`);
-        render(result, () => success(`Deleted stage ${s.label || id}`));
-    });
-    return stage;
-}