@wji.ai/cli 0.6.0 → 0.7.0

package/dist/commands/backreel-fund.js

@@ -0,0 +1,299 @@
+import { Command } from 'commander';
+import { POSTS, backreelClient, idOf, loadPost, oneOf } from '../core/backreel.js';
+import { color, detail, info, render, relativeTime, success, table, truncate } from '../core/output.js';
+import { confirm } from '../core/prompt.js';
+const CURRENCIES = ['hkd', 'usd', 'twd', 'sgd', 'eur', 'gbp'];
+const MAX_TIERS = 10;
+const num = (value, flag, min = 0) => {
+    const n = Number(value);
+    if (!Number.isFinite(n) || n < min)
+        throw new Error(`${flag} must be a number ≥ ${min}`);
+    return n;
+};
+/** The server rejects a tier below the minimum donation (and below 1) with a bare 500. */
+function tierAmount(value, minAmount) {
+    const floor = Math.max(1, minAmount || 0);
+    const n = num(value, '--amount');
+    if (n < floor)
+        throw new Error(`--amount must be at least ${floor} (the minimum donation)`);
+    return Math.round(n);
+}
+function itemIndex(n, count, what) {
+    const i = Number(n);
+    if (!Number.isInteger(i) || i < 1 || i > count)
+        throw new Error(`${what} ${n} does not exist — there are ${count}`);
+    return i - 1;
+}
+/** campaign as the update DTO takes it: the owner view plus avatar ids, minus derived totals. */
+function campaignDto(c) {
+    return {
+        goalAmount: c?.goalAmount ?? 0,
+        offlineRaisedAmount: c?.offlineRaisedAmount ?? 0,
+        deadline: c?.deadline ?? null,
+        offlineSupporters: (c?.offlineSupporters || []).map((s, i) => ({
+            name: s.name,
+            amount: s.amount ?? 0,
+            sort: i,
+            avatar: idOf(s.avatar) ?? null,
+            avatarUrl: s.avatarUrl ?? null,
+        })),
+    };
+}
+/** donation config as the update DTO takes it (the read view adds `remaining` per tier). */
+function donationDto(d) {
+    return {
+        enabled: !!d?.enabled,
+        currency: d?.currency || 'hkd',
+        minAmount: d?.minAmount ?? 0,
+        tiers: (d?.tiers || []).map((t) => ({ id: t.id, title: t.title, amount: t.amount, perks: t.perks || '', limit: t.limit ?? null })),
+    };
+}
+function requireCampaign(post) {
+    if (post.kind !== 'crowdfunding') {
+        throw new Error(`"${post.title}" is a ${post.kind} post — campaign fields need --kind crowdfunding (which drops its episodes)`);
+    }
+}
+const put = (client, id, body) => client.put(`${POSTS}/list/${id}`, body);
+function printFund(post) {
+    const c = post.campaign;
+    const d = post.donation || {};
+    // The campaign view reports the stats currency, which reads HKD until the first donation;
+    // the configured donation currency is the real one (it cannot change after that).
+    const cur = (d.currency || c?.currency || 'hkd').toUpperCase();
+    if (c) {
+        const pct = c.goalAmount ? ` (${Math.round(((c.raisedAmount || 0) / c.goalAmount) * 100)}%)` : '';
+        detail([
+            ['goal', `${c.goalAmount} ${cur}`],
+            ['raised', `${c.raisedAmount} ${cur}${pct} = offline ${c.offlineRaisedAmount ?? 0} + online ${(c.raisedAmount || 0) - (c.offlineRaisedAmount || 0)}`],
+            ['supporters', c.supporterCount],
+            ['deadline', c.deadline || color.dim('none')],
+        ]);
+        process.stdout.write('\n');
+    }
+    else {
+        info(color.dim(`${post.kind} post — no campaign (goal / offline supporters are crowdfunding-only); donations still work`));
+    }
+    detail([
+        ['donations', d.enabled ? color.green('on') : 'off'],
+        ['currency', (d.currency || 'hkd').toUpperCase()],
+        ['minimum', d.minAmount ?? 0],
+    ]);
+    if ((d.tiers || []).length) {
+        process.stdout.write('\n');
+        table(d.tiers.map((t, i) => ({ ...t, n: i + 1 })), [
+            { header: '#', value: (t) => t.n },
+            { header: 'tier', value: (t) => truncate(t.title, 24) },
+            { header: 'amount', value: (t) => t.amount },
+            { header: 'left', value: (t) => (t.limit ? `${t.remaining}/${t.limit}` : '∞') },
+            { header: 'perks', value: (t) => truncate(t.perks, 40) },
+        ]);
+    }
+}
+function printSupporters(post) {
+    table((post.campaign?.offlineSupporters || []).map((s, i) => ({ ...s, n: i + 1 })), [
+        { header: '#', value: (s) => s.n },
+        { header: 'name', value: (s) => s.name },
+        { header: 'amount', value: (s) => s.amount },
+        { header: 'avatar', value: (s) => idOf(s.avatar) || '' },
+    ]);
+}
+export function fundCommand(globals) {
+    const fund = new Command('fund')
+        .aliases(['funding', 'campaign'])
+        .description('Crowdfunding campaign, donation settings and tiers, offline supporters, donation records');
+    fund.command('show <postId>', { isDefault: true })
+        .description('Campaign progress, donation settings and tiers')
+        .action(async (postId) => {
+        const client = backreelClient(globals);
+        const post = await loadPost(client, postId);
+        render({ campaign: post.campaign, donation: post.donation, kind: post.kind }, () => printFund(post));
+    });
+    fund.command('set <postId>')
+        .description('Campaign goal / offline total / deadline and donation switches; only what you pass changes')
+        .option('--goal <amount>', 'campaign goal (≥1 to publish a crowdfunding post)')
+        .option('--offline-raised <amount>', 'money raised outside Backreel, added to the progress bar')
+        .option('--deadline <date>', 'ISO date (e.g. 2026-12-31); "none" clears — donations stop after it')
+        .option('--donations <on|off>', 'accept online donations (Stripe)')
+        .option('--currency <code>', `${CURRENCIES.join(' | ')} — locked once a donation exists`)
+        .option('--min <amount>', 'minimum donation')
+        .action(async (postId, opts) => {
+        const client = backreelClient(globals);
+        const post = await loadPost(client, postId);
+        const body = {};
+        if (opts.goal !== undefined || opts.offlineRaised !== undefined || opts.deadline !== undefined) {
+            requireCampaign(post);
+            const campaign = campaignDto(post.campaign);
+            if (opts.goal !== undefined)
+                campaign.goalAmount = num(opts.goal, '--goal');
+            if (opts.offlineRaised !== undefined)
+                campaign.offlineRaisedAmount = num(opts.offlineRaised, '--offline-raised');
+            if (opts.deadline !== undefined) {
+                if (['none', ''].includes(String(opts.deadline).toLowerCase()))
+                    campaign.deadline = null;
+                else {
+                    const date = new Date(opts.deadline);
+                    if (Number.isNaN(date.getTime()))
+                        throw new Error('--deadline must be a date like 2026-12-31');
+                    campaign.deadline = date.toISOString();
+                }
+            }
+            body.campaign = campaign;
+        }
+        if (opts.donations !== undefined || opts.currency !== undefined || opts.min !== undefined) {
+            const donation = donationDto(post.donation);
+            if (opts.donations !== undefined)
+                donation.enabled = oneOf(String(opts.donations).toLowerCase(), ['on', 'off'], '--donations') === 'on';
+            if (opts.currency !== undefined)
+                donation.currency = oneOf(String(opts.currency).toLowerCase(), CURRENCIES, '--currency');
+            if (opts.min !== undefined)
+                donation.minAmount = Math.round(num(opts.min, '--min'));
+            body.donation = donation;
+        }
+        if (!Object.keys(body).length)
+            throw new Error('Nothing to change — see `wji backreel fund set --help`');
+        const updated = await put(client, postId, body);
+        render(updated, (p) => {
+            success(`Updated ${Object.keys(body).join(' and ')} of "${p.title}"`);
+            printFund(p);
+        });
+    });
+    // ── donation tiers ─────────────────────────────────────────────────────────
+    const tier = fund.command('tier').description(`Donation tiers (≤${MAX_TIERS}): a title, an amount, perks, an optional cap`);
+    tier.command('add <postId>')
+        .requiredOption('--title <text>', 'tier name (≤60)')
+        .requiredOption('--amount <n>', 'price, ≥ the minimum donation')
+        .option('--perks <text>', 'what supporters get (≤1000)')
+        .option('--limit <n>', 'number of slots (default unlimited)')
+        .action(async (postId, opts) => {
+        const client = backreelClient(globals);
+        const post = await loadPost(client, postId);
+        const donation = donationDto(post.donation);
+        if (donation.tiers.length >= MAX_TIERS)
+            throw new Error(`Already ${MAX_TIERS} tiers`);
+        donation.tiers.push({ id: undefined, title: opts.title, amount: tierAmount(opts.amount, donation.minAmount), perks: opts.perks || '', limit: opts.limit ? num(opts.limit, '--limit', 1) : null });
+        const updated = await put(client, postId, { donation });
+        render(updated.donation, () => {
+            success(`Added tier "${opts.title}"${donation.enabled ? '' : color.dim(' — donations are off; `fund set --donations on`')}`);
+            printFund(updated);
+        });
+    });
+    tier.command('set <postId> <n>')
+        .option('--title <text>', 'tier name')
+        .option('--amount <n>', 'price')
+        .option('--perks <text>', 'perks')
+        .option('--limit <n>', 'slots; 0 = unlimited')
+        .action(async (postId, n, opts) => {
+        const client = backreelClient(globals);
+        const post = await loadPost(client, postId);
+        const donation = donationDto(post.donation);
+        const t = donation.tiers[itemIndex(n, donation.tiers.length, 'Tier')];
+        if (opts.title !== undefined)
+            t.title = opts.title;
+        if (opts.amount !== undefined)
+            t.amount = tierAmount(opts.amount, donation.minAmount);
+        if (opts.perks !== undefined)
+            t.perks = opts.perks;
+        if (opts.limit !== undefined)
+            t.limit = Number(opts.limit) > 0 ? num(opts.limit, '--limit', 1) : null;
+        const updated = await put(client, postId, { donation });
+        render(updated.donation, () => {
+            success(`Updated tier ${n}`);
+            printFund(updated);
+        });
+    });
+    tier.command('rm <postId> <n...>')
+        .option('-y, --yes', 'skip confirmation')
+        .action(async (postId, ns, opts) => {
+        const client = backreelClient(globals);
+        const post = await loadPost(client, postId);
+        const donation = donationDto(post.donation);
+        const drop = new Set(ns.map((n) => itemIndex(n, donation.tiers.length, 'Tier')));
+        const names = [...drop].map((i) => donation.tiers[i].title).join(', ');
+        if (!(await confirm(`Remove tier(s) ${names}? Past donations keep their snapshot.`, opts.yes)))
+            return info('Aborted');
+        donation.tiers = donation.tiers.filter((_, i) => !drop.has(i));
+        const updated = await put(client, postId, { donation });
+        render(updated.donation, () => {
+            success(`Removed ${drop.size} tier(s)`);
+            printFund(updated);
+        });
+    });
+    // ── offline supporters ─────────────────────────────────────────────────────
+    const sup = fund.command('supporter').aliases(['supporters']).description('Supporters who paid outside Backreel (crowdfunding posts)');
+    sup.command('list <postId>', { isDefault: true }).action(async (postId) => {
+        const client = backreelClient(globals);
+        const post = await loadPost(client, postId);
+        requireCampaign(post);
+        render(post.campaign?.offlineSupporters || [], () => printSupporters(post));
+    });
+    sup.command('add <postId>')
+        .requiredOption('--name <name>', 'display name')
+        .option('--amount <n>', 'amount (shown next to the name)', '0')
+        .option('--avatar <assetId>', 'square image asset (see `backreel image --slot photo`)')
+        .action(async (postId, opts) => {
+        const client = backreelClient(globals);
+        const post = await loadPost(client, postId);
+        requireCampaign(post);
+        const campaign = campaignDto(post.campaign);
+        campaign.offlineSupporters.push({ name: opts.name, amount: num(opts.amount, '--amount'), sort: campaign.offlineSupporters.length, avatar: opts.avatar ?? null, avatarUrl: null });
+        const updated = await put(client, postId, { campaign });
+        render(updated.campaign, () => {
+            success(`Added supporter ${opts.name}`);
+            info(color.dim('The supporter count rises; offline money only counts once you raise --offline-raised'));
+            printSupporters(updated);
+        });
+    });
+    sup.command('rm <postId> <n...>')
+        .option('-y, --yes', 'skip confirmation')
+        .action(async (postId, ns, opts) => {
+        const client = backreelClient(globals);
+        const post = await loadPost(client, postId);
+        requireCampaign(post);
+        const campaign = campaignDto(post.campaign);
+        const drop = new Set(ns.map((n) => itemIndex(n, campaign.offlineSupporters.length, 'Supporter')));
+        const names = [...drop].map((i) => campaign.offlineSupporters[i].name).join(', ');
+        if (!(await confirm(`Remove ${names}?`, opts.yes)))
+            return info('Aborted');
+        campaign.offlineSupporters = campaign.offlineSupporters.filter((_, i) => !drop.has(i));
+        const updated = await put(client, postId, { campaign });
+        render(updated.campaign, () => {
+            success(`Removed ${drop.size} supporter(s)`);
+            printSupporters(updated);
+        });
+    });
+    // ── donation records ───────────────────────────────────────────────────────
+    fund.command('donations <postId>')
+        .description('Online donations, balance and payouts (anonymous donors stay hidden)')
+        .option('--page <n>', 'page number', '1')
+        .option('--limit <n>', 'page size (≤200)', '50')
+        .action(async (postId, opts) => {
+        const client = backreelClient(globals);
+        const r = await client.get(`/backreel/donation/post/${postId}/manage`, { page: Number(opts.page), limit: Number(opts.limit) });
+        render(r, () => {
+            const s = r.summary || {};
+            const cur = (s.currency || '').toUpperCase();
+            detail([
+                ['raised', `${s.raised} ${cur}`],
+                ['paid out', `${s.paidOut} ${cur}`],
+                ['balance', `${s.balance} ${cur}`],
+                ['supporters', r.stats?.supporterCount ?? 0],
+                ['donations', r.stats?.donationCount ?? 0],
+            ]);
+            process.stdout.write('\n');
+            table(r.data || [], [
+                { header: 'when', value: (d) => relativeTime(d.paidAt || d.createdAt) },
+                { header: 'donor', value: (d) => (d.isAnonymous ? color.dim('anonymous') : truncate(d.donor?.name, 20)) },
+                { header: 'amount', value: (d) => `${d.amount} ${(d.currency || '').toUpperCase()}` },
+                { header: 'tier', value: (d) => truncate(d.tier?.title, 16) },
+                { header: 'status', value: (d) => d.status + (d.refundedAmount ? ` (-${d.refundedAmount})` : '') + (d.disputed ? color.red(' disputed') : '') },
+                { header: 'message', value: (d) => truncate(d.message, 30) },
+            ]);
+            const p = r.pagination;
+            if (p)
+                info(color.dim(`${p.total} donations · page ${p.page}${p.hasNext ? ` · more: --page ${p.page + 1}` : ''}`));
+            if ((r.payouts || []).length)
+                info(color.dim(`${r.payouts.length} payout(s) — payouts and refunds are handled by Backreel staff`));
+        });
+    });
+    return fund;
+}

package/dist/commands/backreel.js

@@ -1,12 +1,21 @@
 import { Command } from 'commander';
-import { WjiClient } from '../core/client.js';
+import { POSTS, backreelClient, idOf, oneOf } from '../core/backreel.js';
+import { IMAGE_SLOTS, checkImage } from '../core/image.js';
+import { episodeCommand } from './backreel-episode.js';
+import { enquiryCommand } from './backreel-enquiry.js';
+import { fundCommand } from './backreel-fund.js';
 import { confirm, readJson, readValue } from '../core/prompt.js';
 import { color, detail, info, render, relativeTime, success, table, truncate } from '../core/output.js';
 import { NPC_JOB_TYPES, npcLabel, parseJob, parsePositions, resolveNpc, today, updateJobs } from '../core/npc.js';
-const POSTS = '/backreel/post';
 const KINDS = ['showcase', 'crowdfunding'];
 const PROJECT_STATUSES = ['planning', 'pre_production', 'in_production', 'post_production', 'completed'];
 const CREDIT_KINDS = ['creative', 'crew', 'cast'];
+/** The web's LookBook slot limit (compose/store.ts MEDIA_SLOT_LIMIT); the API itself has no cap. */
+const MEDIA_MAX = 9;
+/** Backend LOGLINE_MAX (src/backreel/post/descriptionHtml.ts). */
+const LOGLINE_MAX = 200;
+/** BackreelVerificationKind — what `creators --role` filters on. */
+const VERIFICATION_KINDS = ['investor', 'production_company', 'brand', 'distributor', 'sales_agent'];
 /** Credit fields the create / update DTO accepts; the rest of a read-back credit is dropped. */
 const CREDIT_FIELDS = ['kind', 'name', 'role', 'user', 'photo', 'avatarUrl', 'link', 'source', 'npcId', 'order'];
 export function backreelCommand(globals) {
@@ -20,7 +29,7 @@ export function backreelCommand(globals) {
         .option('--page <n>', 'page number', '1')
         .option('--limit <n>', 'page size', '20')
         .action(async (opts) => {
-        const client = new WjiClient(globals());
+        const client = backreelClient(globals);
         const result = await client.get(`${POSTS}/${opts.all ? 'search' : 'search/my'}`, {
             keyword: opts.keyword,
             page: Number(opts.page),
@@ -44,12 +53,12 @@ export function backreelCommand(globals) {
     br.command('get <postId>')
         .description('Show a post and its credits')
         .action(async (id) => {
-        const client = new WjiClient(globals());
+        const client = backreelClient(globals);
         const post = await client.getFresh(`${POSTS}/list/${id}`);
         render(post, () => printPost(post));
     });
     postOptions(br.command('create <title>').description('Create a post (always a draft until `backreel publish`)')).action(async (title, opts) => {
-        const client = new WjiClient(globals());
+        const client = backreelClient(globals);
         // The create DTO validates kind and description although the entity has defaults.
         const body = { kind: 'showcase', description: '', ...(await postBody(opts)), title };
         const created = await client.post(`${POSTS}/create`, body);
@@ -58,7 +67,7 @@ export function backreelCommand(globals) {
     postOptions(br.command('set <postId>')
         .description('Update a post; only the fields you pass change')
         .option('--title <text>', 'title')).action(async (id, opts) => {
-        const client = new WjiClient(globals());
+        const client = backreelClient(globals);
         const body = await postBody(opts);
         if (opts.title)
             body.title = opts.title;
@@ -71,7 +80,7 @@ export function backreelCommand(globals) {
         br.command(`${action} <postId>`)
             .description(action === 'publish' ? 'Publish a post' : 'Take a post offline')
             .action(async (id) => {
-            const client = new WjiClient(globals());
+            const client = backreelClient(globals);
             const post = await client.post(`${POSTS}/list/${id}/${action}`);
             render(post, (p) => success(`"${p.title}" is now ${p.publishStatus}`));
         });
@@ -80,20 +89,173 @@ export function backreelCommand(globals) {
         .description('Delete a post')
         .option('-y, --yes', 'skip confirmation')
         .action(async (id, opts) => {
-        const client = new WjiClient(globals());
+        const client = backreelClient(globals);
         const post = await client.getFresh(`${POSTS}/list/${id}`);
         if (!(await confirm(`Delete post "${post.title}" (${id})?`, opts.yes)))
             return info('Aborted');
         const result = await client.delete(`${POSTS}/list/${id}`);
         render(result, () => success(`Deleted "${post.title}"`));
     });
+    br.command('creators')
+        .description('Browse Backreel creators: editor picks, then ranked by recent likes / favorites')
+        .option('-k, --keyword <text>', 'match name or @handle')
+        .option('--role <kind>', `only creators verified as: ${VERIFICATION_KINDS.join(' | ')}`)
+        .option('--verified', 'only verified creators')
+        .option('--no-featured', 'skip the editor-picked creators')
+        .option('--page <n>', 'page number', '1')
+        .option('--limit <n>', 'page size (max 48)', '20')
+        .action(async (opts) => {
+        const client = backreelClient(globals);
+        if (opts.role)
+            oneOf(opts.role, VERIFICATION_KINDS, '--role');
+        const result = await client.get('/backreel/creator/list', {
+            keyword: opts.keyword,
+            role: opts.role,
+            verifiedOnly: opts.verified ? 'true' : undefined,
+            withFeatured: opts.featured ? undefined : 'false',
+            page: Number(opts.page),
+            limit: Number(opts.limit),
+        });
+        render(result, (r) => {
+            const columns = [
+                { header: 'id', value: (c) => c.id },
+                { header: 'name', value: (c) => truncate(c.name, 24) },
+                { header: 'handle', value: (c) => (c.handle ? `@${c.handle}` : '') },
+                { header: 'reels', value: (c) => c.reelCount },
+                { header: 'followers', value: (c) => c.followerCount },
+                { header: 'likes', value: (c) => c.likeCount },
+                { header: 'verified', value: (c) => (c.verifiedKinds || []).join(', ') },
+            ];
+            if (r?.featured?.length) {
+                info(color.bold('Featured'));
+                table(r.featured, [...columns, { header: 'note', value: (c) => truncate(c.featuredNote, 30) }]);
+                process.stdout.write('\n');
+                info(color.bold('Hot'));
+            }
+            table(r?.data || [], columns);
+            const p = r?.pagination;
+            if (p) {
+                const more = p.page * p.limit < p.total ? ` · more: --page ${p.page + 1}` : '';
+                info(color.dim(`${p.total} ranked · page ${p.page}${more}`));
+            }
+        });
+    });
+    br.command('image <file...>')
+        .description('Check image size / ratio for a slot, upload it, and optionally put it on a post')
+        .requiredOption('--slot <slot>', `${Object.keys(IMAGE_SLOTS).join(' | ')} (see \`backreel image-specs\`)`)
+        .option('--post <postId>', 'cover / portrait: set it on the post; media: append to the LookBook')
+        .option('--check', 'only check, do not upload')
+        .action(async (files, opts) => {
+        const slot = oneOf(opts.slot, Object.keys(IMAGE_SLOTS), '--slot');
+        if (files.length > 1 && slot !== 'media')
+            throw new Error(`--slot ${slot} takes one image`);
+        const checks = await Promise.all(files.map((f) => checkImage(f, slot)));
+        for (const c of checks) {
+            const dims = c.dims ? `${c.dims.width}×${c.dims.height} ${c.dims.format}` : '?';
+            info(`${c.file}: ${dims}, ${(c.bytes / 1048576).toFixed(1)} MB → ${slot} (${c.spec.label}, ideal ${c.spec.ideal})`);
+            for (const e of c.errors)
+                info(color.red(`  ✗ ${e}`));
+            for (const w of c.warnings)
+                info(color.yellow(`  ! ${w}`));
+            if (!c.errors.length && !c.warnings.length)
+                info(color.green('  ✓ fits'));
+        }
+        if (checks.some((c) => c.errors.length))
+            throw new Error('Fix the errors above first');
+        if (opts.check)
+            return render(checks, () => { });
+        const client = backreelClient(globals);
+        const ids = [];
+        for (const c of checks) {
+            const asset = await client.upload('/assets/v2/upload', c.file, {
+                width: c.dims ? String(c.dims.width) : undefined,
+                height: c.dims ? String(c.dims.height) : undefined,
+            });
+            ids.push(asset.id);
+            success(`${c.file} → ${asset.id}`);
+        }
+        if (!opts.post)
+            return render({ assets: ids }, () => { });
+        const field = { cover: 'cover', portrait: 'coverPortrait', media: 'assets' }[slot];
+        if (!field)
+            throw new Error('--post works with cover, portrait and media; use the photo id with `credit add --photo` or `fund supporter add --avatar`');
+        let value = ids[0];
+        if (field === 'assets') {
+            const post = await client.getFresh(`${POSTS}/list/${opts.post}`);
+            value = [...(post.assets || []).map(idOf), ...ids];
+            if (value.length > MEDIA_MAX)
+                throw new Error(`The LookBook would have ${value.length} items; the limit is ${MEDIA_MAX}`);
+        }
+        const updated = await client.put(`${POSTS}/list/${opts.post}`, { [field]: value });
+        render(updated, (p) => success(`Set ${field} on "${p.title}"${field === 'assets' ? ` (${value.length} items)` : ''}`));
+    });
+    br.command('image-specs')
+        .description('Recommended image sizes for every Backreel slot')
+        .action(() => {
+        render(IMAGE_SLOTS, () => {
+            table(Object.entries(IMAGE_SLOTS).map(([slot, s]) => ({ slot, ...s })), [
+                { header: 'slot', value: (r) => r.slot },
+                { header: 'ratio', value: (r) => r.label },
+                { header: 'ideal', value: (r) => r.ideal },
+                { header: 'min', value: (r) => r.min.join('×') },
+                { header: 'note', value: (r) => r.note },
+            ]);
+            info(color.dim('JPEG / PNG / WebP, ≤25 MB. Long edge over 3840 px is downsized, files over 10 MB are re-encoded as JPEG.'));
+        });
+    });
+    br.command('check <postId>')
+        .description('Publish readiness and health: required fields, images, episodes, campaign')
+        .action(async (id) => {
+        const client = backreelClient(globals);
+        const p = await client.getFresh(`${POSTS}/list/${id}`);
+        const blockers = [];
+        const advice = [];
+        const hasText = !!(p.descriptionText || '').trim() || /<img\b/i.test(p.description || '');
+        const episodes = p.episodes || [];
+        if (!(p.title || '').trim())
+            blockers.push('title is empty');
+        if (!hasText)
+            blockers.push('description is empty (needs text or an image) — `backreel set -d @synopsis.md`');
+        if (!p.cover && !(p.assets || []).length && !episodes.length)
+            blockers.push('needs a cover, LookBook media or an episode');
+        if (p.kind === 'crowdfunding' && !(p.campaign?.goalAmount >= 1))
+            blockers.push('crowdfunding goal is 0 — `backreel fund set --goal`');
+        if (!p.cover)
+            advice.push('no 16:9 cover — cards and shares fall back to a blank frame');
+        if (!p.coverPortrait)
+            advice.push('no 9:16 portrait cover — mobile crops the 16:9 cover');
+        if (!(p.logline || '').trim())
+            advice.push('no logline — the page falls back to the first sentence of the description');
+        if (!(p.credits || []).length)
+            advice.push('no credits');
+        const pending = episodes.filter((e) => e.vodVid && e.vodStatus !== 'ready');
+        if (pending.length)
+            advice.push(`${pending.length} episode(s) not ready on VOD (${pending.map((e) => `#${(e.order ?? 0) + 1} ${e.vodStatus || '?'}`).join(', ')}) — \`backreel episode status\``);
+        if (p.trailerDurationSec && p.trailerDurationSec > 31)
+            advice.push(`trailer is ${p.trailerDurationSec}s; the limit is 30s`);
+        if (p.donation?.enabled && p.kind === 'crowdfunding' && p.campaign?.deadline && new Date(p.campaign.deadline) < new Date()) {
+            advice.push('the campaign deadline has passed — donations are closed');
+        }
+        render({ id: p.id, publishStatus: p.publishStatus, blockers, advice }, () => {
+            info(`"${p.title}" — ${p.kind}, ${p.publishStatus}`);
+            for (const b of blockers)
+                info(color.red(`  ✗ ${b}`));
+            for (const a of advice)
+                info(color.yellow(`  ! ${a}`));
+            if (!blockers.length)
+                info(color.green(p.publishStatus === 'published' ? '  ✓ published' : '  ✓ ready to publish — `wji backreel publish`'));
+        });
+    });
+    br.addCommand(episodeCommand(globals));
+    br.addCommand(enquiryCommand(globals));
+    br.addCommand(fundCommand(globals));
     // ── credits ────────────────────────────────────────────────────────────
     const credit = br.command('credit').aliases(['credits']).description('Cast and crew of a post (max 30)');
     credit
         .command('list <postId>', { isDefault: true })
         .description('Numbered credits')
         .action(async (id) => {
-        const client = new WjiClient(globals());
+        const client = backreelClient(globals);
         const post = await client.getFresh(`${POSTS}/list/${id}`);
         render(post.credits || [], (credits) => printCredits(credits));
     });
@@ -106,6 +268,7 @@ export function backreelCommand(globals) {
         .option('--npc <npc>', 'link an NPC City NPC (id, @handle or name)')
         .option('--user <userId>', 'link a WJI user (their name and avatar win)')
         .option('--link <url>', 'profile link')
+        .option('--photo <assetId>', 'square photo asset (see `backreel image --slot photo`)')
         .option('--job <type>', `also add a work-history job to the NPC: ${NPC_JOB_TYPES.join(' | ')}`)
         .action(async (id, opts) => {
         if (!CREDIT_KINDS.includes(opts.kind))
@@ -115,7 +278,7 @@ export function backreelCommand(globals) {
         if (opts.job && !NPC_JOB_TYPES.includes(opts.job)) {
             throw new Error(`--job must be one of ${NPC_JOB_TYPES.join(', ')}`);
         }
-        const client = new WjiClient(globals());
+        const client = backreelClient(globals);
         const npc = opts.npc ? await resolveNpc(client, opts.npc) : undefined;
         // Any public NPC can be credited, but only your own gets a job. The soul
         // route is owner-only, so it checks that before anything is written.
@@ -132,6 +295,8 @@ export function backreelCommand(globals) {
             entry.user = opts.user;
         if (opts.link)
             entry.link = opts.link;
+        if (opts.photo)
+            entry.photo = opts.photo;
         if (npc) {
             entry.npcId = npc.id;
             if (npc.image)
@@ -155,7 +320,7 @@ export function backreelCommand(globals) {
         .description('Remove credits by number')
         .option('-y, --yes', 'skip confirmation')
         .action(async (id, ns, opts) => {
-        const client = new WjiClient(globals());
+        const client = backreelClient(globals);
         const post = await client.getFresh(`${POSTS}/list/${id}`);
         const credits = post.credits || [];
         const positions = parsePositions(ns, credits.length);
@@ -176,19 +341,28 @@ export function backreelCommand(globals) {
 function postOptions(cmd) {
     return cmd
         .option('--kind <kind>', KINDS.join(' | '))
+        .option('--logline <text>', `one-line hook, max ${LOGLINE_MAX} chars; public even when the description is locked ("" clears it)`)
         .option('--category <category>', 'category')
         .option('--project-status <status>', PROJECT_STATUSES.join(' | '))
         .option('--tags <tags>', 'comma-separated tags (replaces the list)')
         .option('-d, --description <text>', 'description, plain text or HTML (@file / - supported)')
         .option('--cover <assetId>', 'landscape cover asset')
         .option('--cover-portrait <assetId>', 'portrait cover asset')
-        .option('--trailer <assetId>', 'trailer video asset')
+        .option('--trailer <assetId>', 'trailer video asset (≤30 s)')
+        .option('--media <assetId...>', `LookBook gallery, images or videos in order (replaces it; ≤${MEDIA_MAX}; "none" clears)`)
         .option('--body <json>', 'any other post fields as JSON (@file / - supported); flags win');
 }
 async function postBody(opts) {
     const body = { ...((await readJson(opts.body)) || {}) };
     if (opts.kind)
         body.kind = oneOf(opts.kind, KINDS, '--kind');
+    if (opts.logline !== undefined) {
+        // Same normalisation the server applies: plain text, one line.
+        const logline = String(await readValue(opts.logline)).replace(/<[^>]*>/g, '').replace(/\s+/g, ' ').trim();
+        if (logline.length > LOGLINE_MAX)
+            throw new Error(`--logline is ${logline.length} chars; the limit is ${LOGLINE_MAX}`);
+        body.logline = logline;
+    }
     if (opts.category)
         body.category = opts.category;
     if (opts.projectStatus)
@@ -203,6 +377,12 @@ async function postBody(opts) {
         body.coverPortrait = opts.coverPortrait;
     if (opts.trailer)
         body.trailer = opts.trailer;
+    if (opts.media) {
+        const media = opts.media.filter((m) => m !== 'none');
+        if (media.length > MEDIA_MAX)
+            throw new Error(`--media takes at most ${MEDIA_MAX} items (the web's LookBook limit)`);
+        body.assets = media;
+    }
     return body;
 }
 /** Descriptions are stored as sanitized HTML; plain text becomes paragraphs. */
@@ -225,11 +405,7 @@ async function updateCredits(client, id, fn) {
         throw new Error('A post can have at most 30 credits');
     return client.put(`${POSTS}/list/${id}`, { credits: next });
 }
-function oneOf(value, allowed, flag) {
-    if (!allowed.includes(value))
-        throw new Error(`${flag} must be one of ${allowed.join(', ')}`);
-    return value;
-}
+const assetLabel = (a) => (a ? a.url || a.id || a : undefined);
 function printPost(p) {
     detail([
         ['id', p.id],
@@ -239,8 +415,15 @@ function printPost(p) {
         ['project', p.projectStatus],
         ['category', p.category],
         ['tags', (p.tags || []).join(', ')],
+        ['logline', p.logline],
         ['description', truncate(p.descriptionText || p.description, 120)],
-        ['cover', p.cover?.url || p.cover?.id || p.cover],
+        ['cover', assetLabel(p.cover)],
+        ['coverPortrait', assetLabel(p.coverPortrait)],
+        ['media', (p.assets || []).length ? `${p.assets.length} item(s)` : undefined],
+        ['episodes', (p.episodes || []).length ? `${p.episodes.length} (\`backreel episode list\`)` : undefined],
+        ['campaign', p.campaign ? `${p.campaign.raisedAmount}/${p.campaign.goalAmount} ${(p.campaign.currency || '').toUpperCase()}` : undefined],
+        ['donations', p.donation?.enabled ? 'on' : undefined],
+        ['trailer', p.trailer ? `${assetLabel(p.trailer)}${p.trailerDurationSec ? ` (${p.trailerDurationSec}s)` : ''}` : undefined],
         ['creator', p.creator?.name],
         ['likes', p.likeCount],
         ['updated', relativeTime(p.updatedAt)],