@wji.ai/cli 0.6.1 → 0.7.1

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.js

@@ -1,320 +0,0 @@
-import { Command } from 'commander';
-import { WjiClient } from '../core/client.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'];
-/** 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) {
-    const br = new Command('backreel')
-        .aliases(['br'])
-        .description('Manage your Backreel posts (works) and their credits, including NPC cast');
-    br.command('list', { isDefault: true })
-        .description('Your posts, drafts included; --all for everyone\'s published posts')
-        .option('--all', 'search all published posts instead of yours')
-        .option('-k, --keyword <text>', 'search text')
-        .option('--page <n>', 'page number', '1')
-        .option('--limit <n>', 'page size', '20')
-        .action(async (opts) => {
-        const client = new WjiClient(globals());
-        const result = await client.get(`${POSTS}/${opts.all ? 'search' : 'search/my'}`, {
-            keyword: opts.keyword,
-            page: Number(opts.page),
-            limit: Number(opts.limit),
-        });
-        render(result, (r) => {
-            table(r?.data || [], [
-                { header: 'id', value: (p) => p.id },
-                { header: 'title', value: (p) => truncate(p.title, 28) },
-                { header: 'kind', value: (p) => p.kind },
-                { header: 'publish', value: (p) => p.publishStatus },
-                { header: 'project', value: (p) => p.projectStatus },
-                { header: 'credits', value: (p) => (p.credits || []).length },
-                { header: 'updated', value: (p) => relativeTime(p.updatedAt) },
-            ]);
-            const p = r?.pagination;
-            if (p)
-                info(color.dim(`${p.total} total · page ${p.page}${p.hasNext ? ` · more: --page ${p.page + 1}` : ''}`));
-        });
-    });
-    br.command('get <postId>')
-        .description('Show a post and its credits')
-        .action(async (id) => {
-        const client = new WjiClient(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());
-        // 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);
-        render(created, (p) => success(`Created draft "${p.title}" — ${p.id}`));
-    });
-    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 body = await postBody(opts);
-        if (opts.title)
-            body.title = opts.title;
-        if (!Object.keys(body).length)
-            throw new Error('Nothing to change — pass at least one field flag');
-        const updated = await client.put(`${POSTS}/list/${id}`, body);
-        render(updated, () => success(`Updated "${updated.title}": ${Object.keys(body).join(', ')}`));
-    });
-    for (const action of ['publish', 'unpublish']) {
-        br.command(`${action} <postId>`)
-            .description(action === 'publish' ? 'Publish a post' : 'Take a post offline')
-            .action(async (id) => {
-            const client = new WjiClient(globals());
-            const post = await client.post(`${POSTS}/list/${id}/${action}`);
-            render(post, (p) => success(`"${p.title}" is now ${p.publishStatus}`));
-        });
-    }
-    br.command('rm <postId>')
-        .description('Delete a post')
-        .option('-y, --yes', 'skip confirmation')
-        .action(async (id, opts) => {
-        const client = new WjiClient(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 = new WjiClient(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}`));
-            }
-        });
-    });
-    // ── 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 post = await client.getFresh(`${POSTS}/list/${id}`);
-        render(post.credits || [], (credits) => printCredits(credits));
-    });
-    credit
-        .command('add <postId>')
-        .description('Add a credit; --npc casts one of your NPCs')
-        .option('--name <name>', 'display name (defaults to the NPC or user name)')
-        .requiredOption('--role <role>', 'job or character, e.g. 導演 or 飾 阿明')
-        .option('--kind <kind>', CREDIT_KINDS.join(' | '), 'cast')
-        .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('--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))
-            throw new Error(`--kind must be one of ${CREDIT_KINDS.join(', ')}`);
-        if (opts.job && !opts.npc)
-            throw new Error('--job needs --npc');
-        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 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.
-        if (npc && opts.job) {
-            await client.get(`/npc-city/residents/${npc.id}/soul`).catch(() => {
-                throw new Error(`${npcLabel(npc)} is not yours, so --job can't add to its work history (the credit alone works without --job)`);
-            });
-        }
-        const name = opts.name || npc?.name;
-        if (!name && !opts.user)
-            throw new Error('Pass --name, --npc or --user');
-        const entry = { kind: opts.kind, name: name || '-', role: opts.role };
-        if (opts.user)
-            entry.user = opts.user;
-        if (opts.link)
-            entry.link = opts.link;
-        if (npc) {
-            entry.npcId = npc.id;
-            if (npc.image)
-                entry.avatarUrl = npc.image;
-        }
-        const post = await updateCredits(client, id, (credits) => [...credits, entry]);
-        // The job is written after the credit, dated today and titled after the post.
-        let job;
-        if (npc && opts.job) {
-            job = parseJob({ type: opts.job, title: post.title, detail: opts.role, date: today() });
-            await updateJobs(client, npc.id, (jobs) => [...jobs, job]);
-        }
-        render({ post: post.id, credits: post.credits, job: job ?? null }, () => {
-            success(`Credited ${name || opts.user} as ${opts.role} on "${post.title}" (#${post.credits.length})`);
-            if (job)
-                success(`Added ${job.type} "${job.title}" to ${npcLabel(npc)}'s work history`);
-        });
-    });
-    credit
-        .command('rm <postId> <n...>')
-        .description('Remove credits by number')
-        .option('-y, --yes', 'skip confirmation')
-        .action(async (id, ns, opts) => {
-        const client = new WjiClient(globals());
-        const post = await client.getFresh(`${POSTS}/list/${id}`);
-        const credits = post.credits || [];
-        const positions = parsePositions(ns, credits.length);
-        const names = positions.map((i) => `#${i + 1} ${credits[i].name}`).join(', ');
-        if (!(await confirm(`Remove ${names} from "${post.title}"?`, opts.yes)))
-            return info('Aborted');
-        const updated = await updateCredits(client, id, (current) => {
-            if (JSON.stringify(current) !== JSON.stringify(credits.map(toCreditDto))) {
-                throw new Error('The credits changed since they were read — list them again and retry');
-            }
-            return current.filter((_, i) => !positions.includes(i));
-        });
-        render(updated.credits, () => success(`Removed ${positions.length} credit(s); ${updated.credits.length} left`));
-    });
-    return br;
-}
-// ── helpers ──────────────────────────────────────────────────────────────
-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('--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)
-        body.projectStatus = oneOf(opts.projectStatus, PROJECT_STATUSES, '--project-status');
-    if (opts.tags !== undefined)
-        body.tags = String(opts.tags).split(',').map((t) => t.trim()).filter(Boolean);
-    if (opts.description !== undefined)
-        body.description = toHtml(await readValue(opts.description));
-    if (opts.cover)
-        body.cover = opts.cover;
-    if (opts.coverPortrait)
-        body.coverPortrait = opts.coverPortrait;
-    if (opts.trailer)
-        body.trailer = opts.trailer;
-    return body;
-}
-/** Descriptions are stored as sanitized HTML; plain text becomes paragraphs. */
-function toHtml(text) {
-    if (/<\/?(p|br|h[1-6]|ul|ol|li|strong|em|b|i|u|s|a|blockquote|div|span|img|hr)\b[^>]*>/i.test(text))
-        return text;
-    const escape = (s) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
-    return text
-        .trim()
-        .split(/\n{2,}/)
-        .map((para) => `<p>${escape(para).replace(/\n/g, '<br>')}</p>`)
-        .join('');
-}
-const toCreditDto = (c) => Object.fromEntries(CREDIT_FIELDS.filter((k) => c[k] !== undefined && c[k] !== null).map((k) => [k, c[k]]));
-/** Credits have no ids: read fresh, change, write the whole array back in order. */
-async function updateCredits(client, id, fn) {
-    const post = await client.getFresh(`${POSTS}/list/${id}`);
-    const next = fn((post.credits || []).map(toCreditDto)).map((c, i) => ({ ...c, order: i }));
-    if (next.length > 30)
-        throw new Error('A post can have at most 30 credits');
-    return client.put(`${POSTS}/list/${id}`, { credits: next });
-}
-const assetLabel = (a) => (a ? a.url || a.id || a : undefined);
-function oneOf(value, allowed, flag) {
-    if (!allowed.includes(value))
-        throw new Error(`${flag} must be one of ${allowed.join(', ')}`);
-    return value;
-}
-function printPost(p) {
-    detail([
-        ['id', p.id],
-        ['title', p.title],
-        ['kind', p.kind],
-        ['publish', p.publishStatus],
-        ['project', p.projectStatus],
-        ['category', p.category],
-        ['tags', (p.tags || []).join(', ')],
-        ['logline', p.logline],
-        ['description', truncate(p.descriptionText || p.description, 120)],
-        ['cover', assetLabel(p.cover)],
-        ['coverPortrait', assetLabel(p.coverPortrait)],
-        ['trailer', p.trailer ? `${assetLabel(p.trailer)}${p.trailerDurationSec ? ` (${p.trailerDurationSec}s)` : ''}` : undefined],
-        ['creator', p.creator?.name],
-        ['likes', p.likeCount],
-        ['updated', relativeTime(p.updatedAt)],
-    ]);
-    process.stdout.write('\n');
-    printCredits(p.credits || []);
-}
-function printCredits(credits) {
-    table(credits.map((c, i) => ({ ...c, n: i + 1 })), [
-        { header: '#', value: (c) => c.n },
-        { header: 'kind', value: (c) => c.kind },
-        { header: 'name', value: (c) => truncate(c.name, 20) },
-        { header: 'role', value: (c) => truncate(c.role, 24) },
-        { header: 'source', value: (c) => c.source },
-        { header: 'npc / user', value: (c) => c.npcId || c.user },
-    ]);
-}