@wji.ai/cli 0.7.0 → 0.8.0

package/dist/commands/auth.js

@@ -1,216 +0,0 @@
-import { Command } from 'commander';
-import { ApiError, WjiClient } from '../core/client.js';
-import { getProfile, updateProfile } from '../core/config.js';
-import { askSecret, ask, confirm } from '../core/prompt.js';
-import { color, detail, info, isJsonMode, printJson, relativeTime, render, success, table, warn } from '../core/output.js';
-export function authCommand(globals) {
-    const auth = new Command('auth').description('Sign in and manage credentials');
-    auth
-        .command('login')
-        .description('Sign in with email + password and store the tokens')
-        .option('-e, --email <email>', 'account email')
-        .option('-p, --password <password>', 'account password (prompted when omitted)')
-        .action(async (opts) => {
-        const g = globals();
-        const client = new WjiClient(g);
-        const email = opts.email || (await ask('Email: '));
-        const password = opts.password || (await askSecret('Password: '));
-        const result = await client.request('POST', '/auth/signin', {
-            body: { email, password },
-            anonymous: true,
-        });
-        updateProfile(g.profile, {
-            endpoint: client.endpoint,
-            accessToken: result.tokens.accessToken,
-            refreshToken: result.tokens.refreshToken,
-            userId: result.user.id,
-            email: result.user.email,
-            name: result.user.name,
-        });
-        if (isJsonMode())
-            return printJson(result);
-        success(`Signed in as ${result.user.name || result.user.email} (profile: ${client.profileName})`);
-        info(color.dim(`Endpoint ${client.endpoint} · balance ${result.user.balance ?? '-'}`));
-    });
-    auth
-        .command('signup')
-        .description('Register a new account (needs an email verification code)')
-        .requiredOption('-e, --email <email>', 'account email')
-        .requiredOption('-n, --name <name>', 'display name')
-        .requiredOption('-c, --code <code>', 'email verification code')
-        .option('-p, --password <password>', 'password (prompted when omitted)')
-        .action(async (opts) => {
-        const g = globals();
-        const client = new WjiClient(g);
-        const password = opts.password || (await askSecret('Password: '));
-        const result = await client.request('POST', '/auth/signup', {
-            body: { email: opts.email, name: opts.name, code: opts.code, password },
-            anonymous: true,
-        });
-        updateProfile(g.profile, {
-            endpoint: client.endpoint,
-            accessToken: result.tokens.accessToken,
-            refreshToken: result.tokens.refreshToken,
-            userId: result.user.id,
-            email: result.user.email,
-            name: result.user.name,
-        });
-        render(result, () => success(`Registered and signed in as ${result.user.email}`));
-    });
-    auth
-        .command('token')
-        .description('Print the active bearer token (use for scripting)')
-        .action(() => {
-        const client = new WjiClient(globals());
-        process.stdout.write(client.requireToken() + '\n');
-    });
-    auth
-        .command('whoami')
-        .description('Show the signed-in account')
-        .action(async () => {
-        const client = new WjiClient(globals());
-        const me = await client.get('/user/me');
-        render(me, (u) => detail([
-            ['id', u.id],
-            ['name', u.name],
-            ['email', u.email],
-            ['balance', u.balance],
-            ['vip', u.vip?.level],
-            ['endpoint', client.endpoint],
-            ['org', client.orgId || 'personal'],
-            ['profile', client.profileName],
-            ['credential', client.usingApiKey ? 'api key' : 'jwt'],
-        ]));
-    });
-    auth
-        .command('refresh')
-        .description('Exchange the stored refresh token for a fresh access token')
-        .action(async () => {
-        const client = new WjiClient(globals());
-        // Goes through the same locked path as the automatic refresh, so a manual
-        // refresh can't race a parallel command into replaying the old token.
-        const profile = await client.refreshSession();
-        render({ accessToken: profile.accessToken, refreshToken: profile.refreshToken }, () => success('Access token refreshed'));
-    });
-    auth
-        .command('logout')
-        .description('Clear stored credentials for the current profile')
-        .action(async () => {
-        const g = globals();
-        const { profile } = getProfile(g.profile);
-        if (profile.refreshToken && profile.accessToken) {
-            // POST with the token in the body — `GET /auth/signout?rt=` is deprecated
-            // and put the refresh token into access logs.
-            const client = new WjiClient(g);
-            const signout = (refreshToken) => client.request('POST', '/auth/signout', { body: { refreshToken }, noRetry: true });
-            try {
-                try {
-                    await signout(profile.refreshToken);
-                }
-                catch (err) {
-                    // An expired access token: refreshing rotates the refresh token, so the
-                    // one to revoke is the new one — revoking the old one would be a no-op.
-                    if (!(err instanceof ApiError && err.status === 401))
-                        throw err;
-                    const rotated = await client.refreshSession();
-                    if (rotated.refreshToken)
-                        await signout(rotated.refreshToken);
-                }
-            }
-            catch {
-                // Server-side signout is best effort; local credentials still go.
-            }
-        }
-        updateProfile(g.profile, {
-            accessToken: undefined,
-            refreshToken: undefined,
-            apiKey: undefined,
-            userId: undefined,
-            email: undefined,
-            name: undefined,
-        });
-        success('Signed out');
-    });
-    // ── API keys ───────────────────────────────────────────────────────────────
-    const key = auth.command('key').description('Manage long-lived sk_ API keys');
-    key
-        .command('list')
-        .description('List your API keys')
-        .option('--limit <n>', 'page size', '20')
-        .action(async (opts) => {
-        const client = new WjiClient(globals());
-        const result = await client.get('/api-key/search', { limit: Number(opts.limit) });
-        render(result, (r) => table(r.data || [], [
-            { header: 'id', value: (k) => k.id },
-            { header: 'name', value: (k) => k.name },
-            { header: 'prefix', value: (k) => k.keyPrefix },
-            { header: 'revoked', value: (k) => (k.revokedAt ? 'yes' : '') },
-            { header: 'last used', value: (k) => relativeTime(k.lastUsedAt) },
-            { header: 'created', value: (k) => relativeTime(k.createdAt) },
-        ]));
-    });
-    key
-        .command('create <name>')
-        .description('Create an API key; the secret is shown once')
-        .option('--expires <iso>', 'expiry date, e.g. 2027-01-01')
-        .option('--save', 'store the new key in this profile and use it for future calls')
-        .action(async (name, opts) => {
-        const g = globals();
-        const client = new WjiClient(g);
-        // The endpoint answers { apiKey, secret }; the plaintext secret is only ever
-        // returned here.
-        const created = await client.post('/api-key/create', {
-            name,
-            expiresAt: opts.expires ? new Date(opts.expires).toISOString() : undefined,
-        });
-        const secret = created.secret;
-        if (opts.save && secret)
-            updateProfile(g.profile, { apiKey: secret });
-        if (isJsonMode())
-            return printJson(created);
-        success(`Created API key "${name}" (${created.apiKey?.id ?? ''})`);
-        if (secret) {
-            process.stdout.write(secret + '\n');
-            info(color.dim('Store this now — it is not retrievable later.'));
-        }
-        else {
-            warn('The server did not return a secret.');
-        }
-        if (opts.save)
-            info(color.dim(`Saved to profile ${client.profileName}`));
-    });
-    key
-        .command('revoke <id>')
-        .description('Revoke an API key')
-        .option('-y, --yes', 'skip confirmation')
-        .action(async (id, opts) => {
-        const prompt = `Revoke API key ${id}? Anything still using it stops working immediately.`;
-        if (!(await confirm(prompt, opts.yes)))
-            return info('Aborted');
-        const client = new WjiClient(globals());
-        const result = await client.post(`/api-key/list/${id}/revoke`);
-        render(result, () => success(`Revoked ${id}`));
-    });
-    key
-        .command('rm <id>')
-        .description('Delete an API key')
-        .option('-y, --yes', 'skip confirmation')
-        .action(async (id, opts) => {
-        if (!(await confirm(`Delete API key ${id}?`, opts.yes)))
-            return info('Aborted');
-        const client = new WjiClient(globals());
-        const result = await client.delete(`/api-key/list/${id}`);
-        render(result, () => success(`Deleted ${id}`));
-    });
-    key
-        .command('use <secret>')
-        .description('Store an existing sk_ key in this profile')
-        .action((secret) => {
-        const g = globals();
-        if (!secret.startsWith('sk_'))
-            throw new Error('An API key must start with sk_');
-        updateProfile(g.profile, { apiKey: secret });
-        success('API key saved');
-    });
-    return auth;
-}

package/dist/commands/backreel-enquiry.js

@@ -1,171 +0,0 @@
-import { writeFile } from 'node:fs/promises';
-import { basename } from 'node:path';
-import { Command } from 'commander';
-import { backreelClient, oneOf } from '../core/backreel.js';
-import { color, detail, info, render, relativeTime, success, table, truncate } from '../core/output.js';
-import { readValue } from '../core/prompt.js';
-const ENQ = '/backreel/enquiry';
-const TYPES = ['collaboration', 'new_project', 'investment', 'licensing', 'access_request', 'general'];
-const STATUSES = ['new', 'in_discussion', 'accepted', 'declined', 'archived', 'withdrawn'];
-/** What the recipient (post owner) may set; the sender may only withdraw. */
-const SETTABLE = ['in_discussion', 'accepted', 'declined', 'archived', 'withdrawn'];
-const MAX_ATTACHMENTS = 5;
-const MESSAGE_MAX = 4000;
-const person = (p) => (p ? `${p.name || p.id}${p.verifiedKinds?.length ? color.dim(` ✓${p.verifiedKinds.join(',')}`) : ''}` : color.dim('system'));
-/** Enquiry attachments are private Backreel files (purpose=enquiry: documents and images ≤20 MB). */
-async function uploadAttachments(client, files = []) {
-    if (files.length > MAX_ATTACHMENTS)
-        throw new Error(`At most ${MAX_ATTACHMENTS} attachments per message`);
-    const ids = [];
-    for (const file of files) {
-        info(color.dim(`Uploading ${basename(file)}…`));
-        const uploaded = await client.upload('/backreel/file/upload?purpose=enquiry', file, {});
-        ids.push(uploaded.id);
-    }
-    return ids;
-}
-function printSummaryTable(rows) {
-    table(rows, [
-        { header: 'id', value: (e) => e.id },
-        { header: '', value: (e) => (e.unread ? color.yellow('●') : '') },
-        { header: 'type', value: (e) => e.type },
-        { header: 'status', value: (e) => e.status + (e.archived && e.status !== 'archived' ? color.dim(' (archived)') : '') },
-        { header: 'from', value: (e) => truncate(e.side === 'sender' ? `→ ${e.recipient?.name}` : e.sender?.name, 20) },
-        { header: 'post', value: (e) => truncate(e.post?.title, 20) },
-        { header: 'last', value: (e) => truncate(e.lastMessagePreview || e.subject, 36) },
-        { header: 'when', value: (e) => relativeTime(e.lastMessageAt) },
-    ]);
-}
-function printEnquiry(e, messages) {
-    const extra = [];
-    if (e.projectInvite) {
-        const p = e.projectInvite;
-        const budget = p.budgetMin || p.budgetMax ? `${p.budgetMin ?? '?'}–${p.budgetMax ?? '?'} ${p.currency || ''}` : '';
-        extra.push(['project', [p.projectType, p.title, budget, p.location, p.roleNeeded].filter(Boolean).join(' · ')]);
-        if (p.timelineStart || p.timelineEnd)
-            extra.push(['timeline', `${p.timelineStart ?? '?'} → ${p.timelineEnd ?? '?'}`]);
-    }
-    if (e.licensing)
-        extra.push(['licensing', [e.licensing.territory, e.licensing.media, e.licensing.term].filter(Boolean).join(' · ')]);
-    if (e.investment)
-        extra.push(['investment', `${e.investment.ticketSize ?? '?'} ${e.investment.currency || ''}`]);
-    if (e.accessPurpose)
-        extra.push(['access purpose', e.accessPurpose]);
-    const c = e.contact || {};
-    detail([
-        ['id', e.id],
-        ['type', e.type],
-        ['status', e.status + (e.archived && e.status !== 'archived' ? ' (archived)' : '')],
-        ['subject', e.subject],
-        ['post', `${e.post?.title} (${e.post?.id})`],
-        ['from', person(e.sender)],
-        ['to', `${person(e.recipient)} (${e.recipientRole})`],
-        ['contact', [c.name, c.email, c.phone, c.company].filter(Boolean).join(' · ')],
-        ...extra,
-        ['sender access', e.senderAccess ? `${e.senderAccess.partnerState}${e.senderAccess.supporter ? ', supporter' : ''}` : undefined],
-        ['can', Object.entries(e.permissions || {}).filter(([, v]) => v).map(([k]) => k).join(', ')],
-        ['attachments', (e.attachments || []).map((f) => `${f.name} (${f.id})`).join(', ')],
-        ['created', e.createdAt],
-    ]);
-    process.stdout.write('\n');
-    for (const m of messages) {
-        const who = m.kind === 'system' ? color.dim('— system') : color.bold(person(m.sender));
-        process.stdout.write(`${who} ${color.dim(relativeTime(m.createdAt) ?? '')}\n`);
-        if (m.body)
-            process.stdout.write(`${m.body}\n`);
-        for (const f of m.attachments || [])
-            process.stdout.write(color.dim(`  📎 ${f.name} (${f.id})\n`));
-        process.stdout.write('\n');
-    }
-}
-export function enquiryCommand(globals) {
-    const enq = new Command('enquiry')
-        .aliases(['enquiries', 'enq'])
-        .description('Enquiries about your posts: read, reply, accept / decline, grant partner access');
-    enq.command('list', { isDefault: true })
-        .description('Your inbox (received) or what you sent, newest activity first')
-        .option('--box <box>', 'received | sent', 'received')
-        .option('--post <postId>', 'only this post')
-        .option('--status <status>', STATUSES.join(' | '))
-        .option('--type <type>', TYPES.join(' | '))
-        .option('--unread', 'only unread')
-        .option('--archived', 'show the archive instead of the inbox')
-        .option('--page <n>', 'page number', '1')
-        .option('--limit <n>', 'page size', '20')
-        .action(async (opts) => {
-        const client = backreelClient(globals);
-        const result = await client.get(`${ENQ}/search`, {
-            box: oneOf(opts.box, ['received', 'sent'], '--box'),
-            post: opts.post,
-            status: opts.status ? oneOf(opts.status, STATUSES, '--status') : undefined,
-            type: opts.type ? oneOf(opts.type, TYPES, '--type') : undefined,
-            unread: opts.unread ? 'true' : undefined,
-            archived: opts.archived ? 'true' : undefined,
-            page: Number(opts.page),
-            limit: Number(opts.limit),
-        });
-        render(result, (r) => {
-            printSummaryTable(r?.data || []);
-            const p = r?.pagination;
-            if (p)
-                info(color.dim(`${p.total} total · page ${p.page}${p.hasNext ? ` · more: --page ${p.page + 1}` : ''}`));
-        });
-    });
-    enq.command('unread')
-        .description('Unread counts')
-        .action(async () => {
-        const client = backreelClient(globals);
-        const counts = await client.get(`${ENQ}/unread-count`);
-        render(counts, (c) => detail([['received', c.received], ['sent', c.sent], ['total', c.total]]));
-    });
-    enq.command('get <id>')
-        .description('Show an enquiry and its whole thread (marks it read)')
-        .action(async (id) => {
-        const client = backreelClient(globals);
-        const e = await client.getFresh(`${ENQ}/list/${id}`);
-        const messages = await client.getFresh(`${ENQ}/list/${id}/messages`);
-        render({ ...e, messages }, () => printEnquiry(e, messages || []));
-    });
-    enq.command('reply <id> <message>')
-        .description(`Reply in the thread (≤${MESSAGE_MAX} chars; @file / - supported). The other side gets an in-app notice and, at most every 30 min, an email`)
-        .option('-a, --attach <file...>', `attach files (≤${MAX_ATTACHMENTS}; documents / images ≤20 MB)`)
-        .action(async (id, message, opts) => {
-        const client = backreelClient(globals);
-        const body = (await readValue(message)).trim();
-        if (!body && !opts.attach?.length)
-            throw new Error('Empty reply');
-        if (body.length > MESSAGE_MAX)
-            throw new Error(`Reply is ${body.length} chars; the limit is ${MESSAGE_MAX}`);
-        const attachments = await uploadAttachments(client, opts.attach);
-        const sent = await client.post(`${ENQ}/list/${id}/messages`, { body, attachments: attachments.length ? attachments : undefined });
-        render(sent, () => success('Reply sent'));
-    });
-    enq.command('status <id> <status>')
-        .description(`Move an enquiry: ${SETTABLE.join(' | ')} (accepting an access_request grants partner access)`)
-        .action(async (id, status) => {
-        const client = backreelClient(globals);
-        const updated = await client.post(`${ENQ}/list/${id}/status`, { status: oneOf(status, SETTABLE, 'status') });
-        render(updated, (e) => success(`Enquiry ${id} is now ${e.status}`));
-    });
-    enq.command('grant <id>')
-        .description('Give the sender partner access to the post (creator only; also accepts an open enquiry)')
-        .action(async (id) => {
-        const client = backreelClient(globals);
-        const updated = await client.post(`${ENQ}/list/${id}/grant`);
-        render(updated, (e) => success(`Granted partner access to ${e.sender?.name || 'the sender'} — status ${e.status}`));
-    });
-    enq.command('download <fileId>')
-        .description('Download an attachment (private file; the signed link lasts 60 s)')
-        .option('-o, --out <path>', 'output path (default: the original file name)')
-        .action(async (fileId, opts) => {
-        const client = backreelClient(globals);
-        const link = await client.get(`/backreel/file/${fileId}/download`);
-        const res = await fetch(link.url);
-        if (!res.ok)
-            throw new Error(`Download failed: HTTP ${res.status}`);
-        const out = opts.out || basename(link.name || fileId);
-        await writeFile(out, Buffer.from(await res.arrayBuffer()));
-        render({ ...link, path: out }, () => success(`Saved ${out}`));
-    });
-    return enq;
-}

package/dist/commands/backreel-episode.js

@@ -1,243 +0,0 @@
-import { stat } from 'node:fs/promises';
-import { basename, extname } from 'node:path';
-import { Command } from 'commander';
-import { ApiError } from '../core/client.js';
-import { POSTS, TIERS, backreelClient, episodeIndex, idOf, loadPost, oneOf } from '../core/backreel.js';
-import { color, info, render, success, table, truncate, warn } from '../core/output.js';
-import { confirm } from '../core/prompt.js';
-import { uploadToVod } from '../core/vod.js';
-const MAX_EPISODES = 30;
-const VIDEO_EXTS = ['.mp4', '.mov', '.m4v', '.webm'];
-/** /assets/v2/upload cap for video — only the --legacy path goes through it. */
-const ASSET_VIDEO_MAX_BYTES = 200 * 1024 * 1024;
-/** The fields the update DTO takes back; vodStatus / poster / duration are server-owned. */
-function toDto(e, order) {
-    const base = { title: e.title, order, tier: e.tier || 'public' };
-    return e.vodVid ? { ...base, vodVid: e.vodVid } : { ...base, video: idOf(e.video) };
-}
-async function loadEpisodes(client, postId) {
-    const post = await loadPost(client, postId);
-    if (post.kind !== 'showcase') {
-        throw new Error(`"${post.title}" is a ${post.kind} post — only showcase posts have episodes`);
-    }
-    const episodes = [...(post.episodes || [])]
-        .sort((a, b) => (a.order ?? 0) - (b.order ?? 0))
-        .map((e, i) => toDto(e, i));
-    return { post, episodes };
-}
-/** The server re-sorts by `order`, re-indexes, and re-checks every vodVid with VOD. */
-function saveEpisodes(client, postId, episodes) {
-    if (episodes.length > MAX_EPISODES)
-        throw new Error(`A post can have at most ${MAX_EPISODES} episodes`);
-    return client.put(`${POSTS}/list/${postId}`, { episodes: episodes.map((e, i) => ({ ...e, order: i })) });
-}
-/**
- * Turn `[file] / --vid / --asset` into an episode source. A local file goes to
- * Backreel's VOD space by default (signed, expiring play URLs); `--legacy`
- * uploads it as a plain WJI asset with a permanent public URL instead.
- */
-async function resolveSource(client, opts, postId, file) {
-    const given = [file, opts.vid, opts.asset].filter(Boolean).length;
-    if (given > 1)
-        throw new Error('Give one video source: a file, --vid or --asset');
-    if (opts.vid)
-        return { vodVid: opts.vid };
-    if (opts.asset)
-        return { video: opts.asset };
-    if (!file)
-        return null;
-    const ext = extname(file).toLowerCase();
-    if (!VIDEO_EXTS.includes(ext))
-        throw new Error(`${basename(file)}: episodes must be ${VIDEO_EXTS.join(' / ')}`);
-    const size = (await stat(file)).size;
-    if (opts.legacy) {
-        if (size > ASSET_VIDEO_MAX_BYTES)
-            throw new Error(`${basename(file)} is over 200 MB — drop --legacy to upload it to VOD`);
-        info(color.dim(`Uploading ${basename(file)} as a WJI asset…`));
-        const asset = await client.upload('/assets/v2/upload', file, {});
-        return { video: asset.id };
-    }
-    const token = await client.post('/backreel/vod/upload-token');
-    const vid = await uploadToVod(token, file, (step) => info(color.dim(`VOD: ${step}…`)));
-    // claim checks the space, tags it with the post, publishes the media and starts transcoding.
-    const claimed = await client.post('/backreel/vod/claim', { vid, postId, title: opts.title?.slice(0, 128) });
-    info(color.dim(`VOD ${vid}: ${claimed?.status ?? 'claimed'}`));
-    return { vodVid: vid };
-}
-function printEpisodes(post) {
-    const rows = [...(post.episodes || [])].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
-    table(rows, [
-        { header: '#', value: (e) => (e.order ?? 0) + 1 },
-        { header: 'title', value: (e) => truncate(e.title, 32) },
-        { header: 'tier', value: (e) => e.tier },
-        { header: 'source', value: (e) => (e.vodVid ? `vod ${e.vodVid}` : e.video ? `asset ${idOf(e.video)}` : '-') },
-        { header: 'status', value: (e) => (e.vodVid ? e.vodStatus || '?' : e.video ? 'ready' : '') },
-        { header: 'duration', value: (e) => (e.durationSec ? `${Math.round(e.durationSec)}s` : '') },
-    ]);
-}
-const sourceOptions = (cmd) => cmd
-    .option('--vid <vid>', 'a Vid already in the Backreel VOD space')
-    .option('--asset <assetId>', 'an uploaded WJI video asset (legacy path, public URL)')
-    .option('--legacy', 'upload the file as a WJI asset (≤200 MB) instead of VOD');
-export function episodeCommand(globals) {
-    const ep = new Command('episode')
-        .aliases(['episodes', 'ep'])
-        .description('Episodes of a showcase post: upload, reorder, gate by tier, check transcoding');
-    ep.command('list <postId>', { isDefault: true })
-        .description('List the episodes with their tier, source and VOD status')
-        .action(async (postId) => {
-        const client = backreelClient(globals);
-        const post = await loadPost(client, postId);
-        render(post.episodes || [], () => {
-            if (!(post.episodes || []).length)
-                return info(`"${post.title}" has no episodes yet`);
-            printEpisodes(post);
-        });
-    });
-    sourceOptions(ep.command('add <postId> [file]')
-        .description('Add an episode: upload a local video to VOD, or use --vid / --asset')
-        .requiredOption('-t, --title <title>', 'episode title')
-        .option('--tier <tier>', `who can watch: ${TIERS.join(' | ')}`, 'public')
-        .option('--at <n>', 'insert as episode n (default: last)')).action(async (postId, file, opts) => {
-        const client = backreelClient(globals);
-        const tier = oneOf(opts.tier, TIERS, '--tier');
-        const { post, episodes } = await loadEpisodes(client, postId);
-        if (episodes.length >= MAX_EPISODES)
-            throw new Error(`"${post.title}" already has ${MAX_EPISODES} episodes`);
-        const at = opts.at === undefined ? episodes.length : episodeIndex(opts.at, episodes.length + 1);
-        const source = await resolveSource(client, opts, postId, file);
-        if (!source)
-            throw new Error('Give the video: a file, --vid <vid> or --asset <assetId>');
-        episodes.splice(at, 0, { title: opts.title, order: at, tier, ...source });
-        const updated = await saveEpisodes(client, postId, episodes);
-        render(updated.episodes, () => {
-            success(`Added episode ${at + 1} "${opts.title}" to "${updated.title}"`);
-            printEpisodes(updated);
-            if ('vodVid' in source)
-                info(color.dim('VOD transcoding takes a few minutes — `wji backreel episode status` to check'));
-        });
-    });
-    sourceOptions(ep.command('set <postId> <n> [file]')
-        .description('Change episode n: title, tier, or replace its video')
-        .option('-t, --title <title>', 'new title')
-        .option('--tier <tier>', TIERS.join(' | '))).action(async (postId, n, file, opts) => {
-        const client = backreelClient(globals);
-        const { episodes } = await loadEpisodes(client, postId);
-        const i = episodeIndex(n, episodes.length);
-        const source = await resolveSource(client, { ...opts, title: opts.title || episodes[i].title }, postId, file);
-        if (!opts.title && !opts.tier && !source)
-            throw new Error('Nothing to change — pass --title, --tier or a new video');
-        const next = { title: opts.title || episodes[i].title, order: i, tier: opts.tier ? oneOf(opts.tier, TIERS, '--tier') : episodes[i].tier };
-        episodes[i] = source ? { ...next, ...source } : { ...episodes[i], ...next };
-        const updated = await saveEpisodes(client, postId, episodes);
-        render(updated.episodes, () => {
-            success(`Updated episode ${i + 1}`);
-            printEpisodes(updated);
-        });
-    });
-    ep.command('rm <postId> <n...>')
-        .description('Remove episodes (later ones move up)')
-        .option('-y, --yes', 'skip confirmation')
-        .action(async (postId, ns, opts) => {
-        const client = backreelClient(globals);
-        const { episodes } = await loadEpisodes(client, postId);
-        const drop = new Set(ns.map((n) => episodeIndex(n, episodes.length)));
-        const names = [...drop].sort((a, b) => a - b).map((i) => `${i + 1}. ${episodes[i].title}`).join(', ');
-        if (!(await confirm(`Remove ${names}?`, opts.yes)))
-            return info('Aborted');
-        const updated = await saveEpisodes(client, postId, episodes.filter((_, i) => !drop.has(i)));
-        render(updated.episodes, () => {
-            success(`Removed ${drop.size} episode(s)`);
-            printEpisodes(updated);
-        });
-    });
-    ep.command('move <postId> <from> <to>')
-        .description('Move episode <from> to position <to>')
-        .action(async (postId, from, to) => {
-        const client = backreelClient(globals);
-        const { episodes } = await loadEpisodes(client, postId);
-        const a = episodeIndex(from, episodes.length);
-        const b = episodeIndex(to, episodes.length);
-        const [moved] = episodes.splice(a, 1);
-        episodes.splice(b, 0, moved);
-        const updated = await saveEpisodes(client, postId, episodes);
-        render(updated.episodes, () => {
-            success(`Moved "${moved.title}" to episode ${b + 1}`);
-            printEpisodes(updated);
-        });
-    });
-    ep.command('tiers <postId>')
-        .description('Tier ladder: public up to episode N, members up to M, the rest at --rest')
-        .option('--public-to <n>', 'episodes 1..n are public', '0')
-        .option('--member-to <n>', 'then up to episode n for signed-in members')
-        .option('--rest <tier>', `everything after: ${TIERS.join(' | ')}`, 'supporter')
-        .action(async (postId, opts) => {
-        const client = backreelClient(globals);
-        const { episodes } = await loadEpisodes(client, postId);
-        const pub = Number(opts.publicTo);
-        const mem = opts.memberTo === undefined ? pub : Number(opts.memberTo);
-        if (!Number.isInteger(pub) || pub < 0 || !Number.isInteger(mem) || mem < pub) {
-            throw new Error('--public-to and --member-to are episode numbers, with --member-to ≥ --public-to');
-        }
-        const rest = oneOf(opts.rest, TIERS, '--rest');
-        episodes.forEach((e, i) => {
-            e.tier = i < pub ? 'public' : i < mem ? 'member' : rest;
-        });
-        const updated = await saveEpisodes(client, postId, episodes);
-        render(updated.episodes, () => {
-            success('Episode tiers updated');
-            printEpisodes(updated);
-        });
-    });
-    ep.command('status <postId>')
-        .description('Refresh VOD transcoding state (it only updates when someone asks to play)')
-        .action(async (postId) => {
-        const client = backreelClient(globals);
-        const post = await loadPost(client, postId);
-        const results = [];
-        for (const e of [...(post.episodes || [])].sort((a, b) => (a.order ?? 0) - (b.order ?? 0))) {
-            const row = { n: (e.order ?? 0) + 1, title: e.title, source: e.vodVid ? 'vod' : 'asset', status: 'ready', duration: e.durationSec };
-            if (e.vodVid) {
-                try {
-                    const play = await client.get(`${POSTS}/list/${postId}/episodes/${e.order}/play`);
-                    row.duration = play.durationSec ?? row.duration;
-                }
-                catch (err) {
-                    if (err instanceof ApiError && err.status === 409)
-                        row.status = err.body?.status || 'processing';
-                    else
-                        row.status = `error: ${err.message}`;
-                }
-            }
-            results.push(row);
-        }
-        render(results, (rows) => {
-            if (!rows.length)
-                return info(`"${post.title}" has no episodes yet`);
-            table(rows, [
-                { header: '#', value: (r) => r.n },
-                { header: 'title', value: (r) => truncate(r.title, 32) },
-                { header: 'source', value: (r) => r.source },
-                { header: 'status', value: (r) => (r.status === 'ready' ? color.green('ready') : color.yellow(r.status)) },
-                { header: 'duration', value: (r) => (r.duration ? `${Math.round(r.duration)}s` : '') },
-            ]);
-            if (rows.some((r) => r.status === 'failed'))
-                warn('A failed transcode needs a new upload: `episode set <post> <n> <file>`');
-        });
-    });
-    ep.command('play <postId> <n>')
-        .description('Print a short-lived play URL for episode n (as the owner)')
-        .action(async (postId, n) => {
-        const client = backreelClient(globals);
-        const post = await loadPost(client, postId);
-        const i = episodeIndex(n, (post.episodes || []).length);
-        const order = [...post.episodes].sort((a, b) => (a.order ?? 0) - (b.order ?? 0))[i].order ?? i;
-        const play = await client.get(`${POSTS}/list/${postId}/episodes/${order}/play`);
-        render(play, (p) => {
-            process.stdout.write(`${p.url}\n`);
-            if (p.expiresAt)
-                info(color.dim(`expires ${p.expiresAt}`));
-        });
-    });
-    return ep;
-}