@wji.ai/cli 0.7.0 → 0.7.1

package/dist/commands/gen.js

@@ -1,356 +0,0 @@
-import { Command } from 'commander';
-import { WjiClient } from '../core/client.js';
-import { confirm, parseKeyValues, readJson, readValue } from '../core/prompt.js';
-import { color, detail, detailLevel, info, isJsonMode, printJson, render, success, table, truncate, warn } from '../core/output.js';
-const READY = 1;
-const CANCELLED = -1;
-/** `--ref abc123`, `--ref abc123:hero`, `--ref abc123:hero:0.6` */
-function parseReference(token) {
-    const [assetId, label, weight] = token.split(':');
-    if (!assetId)
-        throw new Error(`Invalid reference "${token}"`);
-    return {
-        assetId,
-        label: label || undefined,
-        weight: weight ? Number(weight) : undefined,
-    };
-}
-const refs = (tokens) => (tokens?.length ? tokens.map(parseReference) : undefined);
-function assetIdsOf(history) {
-    const images = history?.images;
-    const list = Array.isArray(images) ? images : Array.isArray(images?.items) ? images.items : [];
-    return list.map((a) => (typeof a === 'string' ? a : a?.id)).filter(Boolean);
-}
-/**
- * A history entry only carries asset *ids* — `images` is `[{id}]` with no
- * status or url — so the real state has to be fetched separately. Polling on
- * the history alone would report "complete" the instant the entry exists.
- */
-export async function resolveAssets(client, history) {
-    const ids = assetIdsOf(history);
-    if (!ids.length)
-        return [];
-    return client.checkAssetStatus(ids);
-}
-export const stateOf = (a) => a?.status === CANCELLED || a?.error ? 'failed' : a?.status === READY ? 'ready' : 'pending';
-export async function pollHistory(client, id, { timeoutMs, intervalMs }) {
-    const started = Date.now();
-    let lastReport = 0;
-    while (Date.now() - started < timeoutMs) {
-        const history = await client.get(`/ai/assets/history/list/${id}`);
-        const assets = await resolveAssets(client, history);
-        const pending = assets.filter((a) => stateOf(a) === 'pending');
-        if (assets.length && !pending.length) {
-            const failed = assets.filter((a) => stateOf(a) === 'failed');
-            if (failed.length === assets.length) {
-                throw new Error(`Generation failed: ${failed
-                    .map((a) => a.error?.message || a.error || 'cancelled')
-                    .join('; ')}`);
-            }
-            if (failed.length) {
-                warn(`${failed.length}/${assets.length} outputs failed`);
-            }
-            return { history, assets };
-        }
-        const elapsed = Math.round((Date.now() - started) / 1000);
-        if (elapsed - lastReport >= 10) {
-            lastReport = elapsed;
-            const ready = assets.length - pending.length;
-            info(color.dim(`  …${elapsed}s (${ready}/${assets.length || '?'} ready)`));
-        }
-        await new Promise((r) => setTimeout(r, intervalMs));
-    }
-    throw new Error(`Timed out after ${Math.round(timeoutMs / 1000)}s. The task may still finish — check \`wji history get ${id}\`.`);
-}
-export function reportHistory(history, assets) {
-    detail([
-        ['history', history.id],
-        ['type', history.type],
-        ['prompt', truncate(history.prompt, 70)],
-        ['credits', history.chargedCredits],
-        ['assets', assets.length || assetIdsOf(history).length],
-    ]);
-    if (!assets.length)
-        return;
-    table(assets, [
-        { header: 'assetId', value: (a) => a.id },
-        { header: 'state', value: (a) => stateOf(a) },
-        { header: 'name', value: (a) => truncate(a.name, 28) },
-        { header: 'url', value: (a) => a.url || a.error?.message },
-    ]);
-}
-async function submit(client, kind, body, opts) {
-    // Always the history endpoint: the raw one silently drops fsnode, scope,
-    // scopeId and tags, and returns no id to poll with.
-    const result = await client.post(`/ai/assets/history/${kind}/generations`, body);
-    if (!opts.wait) {
-        if (isJsonMode())
-            return printJson(result);
-        success(`Submitted ${kind} generation`);
-        reportHistory(result, await resolveAssets(client, result));
-        info(color.dim(`Poll with: wji history get ${result.id} --wait`));
-        return;
-    }
-    info(color.dim(`Submitted ${result.id}, waiting…`));
-    const { history, assets } = await pollHistory(client, result.id, {
-        timeoutMs: Number(opts.timeout) * 1000,
-        intervalMs: Number(opts.interval) * 1000,
-    });
-    if (isJsonMode())
-        return printJson({ ...history, images: assets });
-    success(`${kind} generation complete`);
-    reportHistory(history, assets);
-}
-function withCommonOptions(cmd) {
-    return cmd
-        .requiredOption('-m, --model <name>', 'model name (see `wji models list`)')
-        .option('-p, --prompt <text>', 'prompt text (@file / - for stdin)')
-        .option('-n, --n <count>', 'number of outputs', '1')
-        .option('-w, --workspace <id>', 'workspace to bill and file the result under')
-        .option('--fsnode <id>', 'file the history entry under an fsnode (does not add the asset to its images)')
-        .option('--scope <scope>', 'history scope, e.g. workspace | canvas')
-        .option('--scope-id <id>', 'history scope id')
-        .option('-r, --ratio <ratio>', 'aspect ratio, e.g. 16:9')
-        .option('--tags <tag...>', 'tags for the history entry')
-        .option('--values <json>', 'model-specific form values (@file / - supported)')
-        .option('--set <key=value...>', 'model-specific form values as key=value')
-        .option('--wait', 'block until the task finishes')
-        .option('--timeout <seconds>', 'wait timeout', '900')
-        .option('--interval <seconds>', 'poll interval', '5');
-}
-export function genCommand(globals) {
-    const gen = new Command('gen').description('Generate images, video and audio');
-    withCommonOptions(gen
-        .command('image')
-        .description('Generate images')
-        .option('--ref <ref...>', 'reference images as assetId[:label[:weight]]')
-        .option('--omni <ref...>', 'omni reference images as assetId[:label[:weight]]')
-        .option('--style-ref <ref...>', 'style reference images as assetId[:label[:weight]]')
-        .option('--reference-weight <n>', 'weight for --ref')
-        .option('--stylize <n>', 'stylize strength')
-        .option('--model-options <json>', 'raw modelOptions JSON')).action(async (opts) => {
-        const client = new WjiClient(globals());
-        await submit(client, 'image', {
-            model: opts.model,
-            prompt: opts.prompt ? await readValue(opts.prompt) : '',
-            n: Number(opts.n),
-            workspace: client.workspace(opts.workspace),
-            fsnode: opts.fsnode,
-            scope: opts.scope,
-            scopeId: opts.scopeId,
-            aspectRatio: opts.ratio,
-            tags: opts.tags,
-            referenceImages: refs(opts.ref),
-            omniReferenceImages: refs(opts.omni),
-            styleReferenceImages: refs(opts.styleRef),
-            referenceWeight: opts.referenceWeight ? Number(opts.referenceWeight) : undefined,
-            stylize: opts.stylize ? Number(opts.stylize) : undefined,
-            modelOptions: await readJson(opts.modelOptions),
-            values: { ...((await readJson(opts.values)) || {}), ...parseKeyValues(opts.set) },
-        }, opts);
-    });
-    withCommonOptions(gen
-        .command('video')
-        .description('Generate video')
-        .option('-d, --duration <seconds>', 'clip duration')
-        .option('--start-image <ref>', 'first frame as assetId[:label]')
-        .option('--end-image <ref>', 'last frame as assetId[:label]')
-        .option('--ref <ref...>', 'reference images as assetId[:label[:weight]]')
-        .option('--ref-video <ref...>', 'motion reference videos as assetId[:label[:weight]]')
-        .option('--ref-audio <ref...>', 'audio references as assetId[:label[:weight]]')).action(async (opts) => {
-        const client = new WjiClient(globals());
-        await submit(client, 'video', {
-            model: opts.model,
-            prompt: opts.prompt ? await readValue(opts.prompt) : '',
-            n: Number(opts.n),
-            workspace: client.workspace(opts.workspace),
-            fsnode: opts.fsnode,
-            scope: opts.scope,
-            scopeId: opts.scopeId,
-            aspectRatio: opts.ratio,
-            tags: opts.tags,
-            duration: opts.duration ? Number(opts.duration) : undefined,
-            startImage: opts.startImage ? parseReference(opts.startImage) : undefined,
-            endImage: opts.endImage ? parseReference(opts.endImage) : undefined,
-            referenceImages: refs(opts.ref),
-            referenceVideos: refs(opts.refVideo),
-            referenceAudios: refs(opts.refAudio),
-            values: { ...((await readJson(opts.values)) || {}), ...parseKeyValues(opts.set) },
-        }, opts);
-    });
-    withCommonOptions(gen
-        .command('audio')
-        .description('Generate audio')
-        .option('-d, --duration <seconds>', 'duration')
-        .option('--ref-audio <ref...>', 'audio references as assetId[:label[:weight]]')
-        .option('--ref <ref...>', 'reference image, e.g. a headshot for a Seed Audio voice sample (not with --ref-audio)')).action(async (opts) => {
-        if (opts.ref?.length && opts.refAudio?.length)
-            throw new Error('Use --ref or --ref-audio, not both');
-        const client = new WjiClient(globals());
-        await submit(client, 'audio', {
-            model: opts.model,
-            prompt: opts.prompt ? await readValue(opts.prompt) : '',
-            n: Number(opts.n),
-            workspace: client.workspace(opts.workspace),
-            fsnode: opts.fsnode,
-            scope: opts.scope,
-            scopeId: opts.scopeId,
-            tags: opts.tags,
-            referenceAudios: refs(opts.refAudio),
-            referenceImages: refs(opts.ref),
-            values: {
-                ...((await readJson(opts.values)) || {}),
-                ...parseKeyValues(opts.set),
-                ...(opts.duration ? { duration: Number(opts.duration) } : {}),
-            },
-        }, opts);
-    });
-    gen
-        .command('cost')
-        .description('Estimate the credit cost of a generation before running it')
-        .requiredOption('-t, --type <type>', 'image | video | audio')
-        .requiredOption('-m, --model <name>', 'model name')
-        .option('-n, --n <count>', 'number of outputs', '1')
-        .option('-p, --prompt <text>', 'prompt (some models price by length)')
-        .option('-d, --duration <seconds>', 'duration for video/audio')
-        .option('-r, --ratio <ratio>', 'aspect ratio')
-        .option('--refs <n>', 'number of reference images')
-        .option('--values <json>', 'model-specific form values')
-        .action(async (opts) => {
-        const client = new WjiClient(globals());
-        const result = await client.post('/ai/assets/preComputeCost', {
-            type: opts.type,
-            model: opts.model,
-            n: Number(opts.n),
-            prompt: opts.prompt,
-            duration: opts.duration ? Number(opts.duration) : undefined,
-            aspectRatio: opts.ratio,
-            referenceImageCount: opts.refs ? Number(opts.refs) : undefined,
-            values: await readJson(opts.values),
-        });
-        render(result, (r) => typeof r === 'object' ? detail(Object.entries(r)) : process.stdout.write(`${r}\n`));
-    });
-    return gen;
-}
-export function historyCommand(globals) {
-    const history = new Command('history').description('Browse generation history');
-    history
-        .command('list', { isDefault: true })
-        .description('Search generation history')
-        .option('-w, --workspace <id>', 'workspace scope')
-        .option('--mode <mode>', 'image | video | audio')
-        .option('--fsnode <id>', 'filter by fsnode')
-        .option('--scope <scope>', 'workspace | canvas | …')
-        .option('--scope-id <id>', 'scope id')
-        .option('--tags <tag...>', 'filter by tags')
-        .option('--bookmarked', 'only bookmarked entries')
-        .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('/ai/assets/history/search', {
-            workspace: client.workspace(opts.workspace),
-            mode: opts.mode,
-            fsnodeId: opts.fsnode,
-            scope: opts.scope,
-            scopeId: opts.scopeId,
-            tags: opts.tags,
-            bookmarked: opts.bookmarked ? true : undefined,
-            page: Number(opts.page),
-            limit: Number(opts.limit),
-            detail: detailLevel(),
-        });
-        render(result, (r) => {
-            table(r.data || [], [
-                { header: 'id', value: (h) => h.id },
-                { header: 'type', value: (h) => h.type },
-                { header: 'assets', value: (h) => assetIdsOf(h).length },
-                { header: 'prompt', value: (h) => truncate(h.prompt, 48) },
-                { header: 'created', value: (h) => h.createdAt?.slice?.(0, 19)?.replace('T', ' ') },
-            ]);
-            info(color.dim(`${r.pagination?.total ?? 0} total`));
-        });
-    });
-    history
-        .command('get <id>')
-        .description('Show one history entry')
-        .option('--wait', 'poll until the task finishes')
-        .option('--timeout <seconds>', 'wait timeout', '900')
-        .option('--interval <seconds>', 'poll interval', '5')
-        .action(async (id, opts) => {
-        const client = new WjiClient(globals());
-        let history;
-        let assets;
-        if (opts.wait) {
-            ;
-            ({ history, assets } = await pollHistory(client, id, {
-                timeoutMs: Number(opts.timeout) * 1000,
-                intervalMs: Number(opts.interval) * 1000,
-            }));
-        }
-        else {
-            history = await client.get(`/ai/assets/history/list/${id}`, { detail: detailLevel() });
-            assets = await resolveAssets(client, history);
-        }
-        render({ ...history, images: assets }, () => reportHistory(history, assets));
-    });
-    history
-        .command('bookmark <id>')
-        .description('Bookmark or unbookmark an entry')
-        .option('--off', 'remove the bookmark')
-        .action(async (id, opts) => {
-        const client = new WjiClient(globals());
-        const result = await client.put(`/ai/assets/history/list/${id}/bookmark`, {
-            bookmarked: !opts.off,
-        });
-        render(result, () => success(opts.off ? 'Bookmark removed' : 'Bookmarked'));
-    });
-    history
-        .command('rm <id>')
-        .description('Delete a history entry')
-        .option('-y, --yes', 'skip confirmation')
-        .action(async (id, opts) => {
-        const client = new WjiClient(globals());
-        const h = await client.get(`/ai/assets/history/list/${id}`).catch(() => null);
-        const about = [h?.mode, h?.model, h?.prompt ? `"${truncate(h.prompt, 40)}"` : undefined]
-            .filter(Boolean)
-            .join(' · ');
-        if (!(await confirm(`Delete history entry ${id}${about ? ` (${about})` : ''}?`, opts.yes))) {
-            return info('Aborted');
-        }
-        const result = await client.delete(`/ai/assets/history/list/${id}`);
-        render(result, () => success(`Deleted ${id}`));
-    });
-    history
-        .command('download <id>')
-        .description('Download every finished asset in a history entry')
-        .option('-o, --out <dir>', 'output directory', '.')
-        .action(async (id, opts) => {
-        const client = new WjiClient(globals());
-        const entry = await client.get(`/ai/assets/history/list/${id}`);
-        const ready = (await resolveAssets(client, entry)).filter((a) => a.url && stateOf(a) === 'ready');
-        if (!ready.length)
-            return warn('Nothing to download yet');
-        const { createWriteStream } = await import('node:fs');
-        const { Readable } = await import('node:stream');
-        const { pipeline } = await import('node:stream/promises');
-        const { join } = await import('node:path');
-        const saved = [];
-        for (const a of ready) {
-            const res = await fetch(a.url);
-            if (!res.ok || !res.body) {
-                warn(`Skipped ${a.id}: ${res.status}`);
-                continue;
-            }
-            const ext = /\.([a-z0-9]{2,5})(?:\?|$)/i.exec(a.url)?.[1] || 'bin';
-            const target = join(opts.out, `${a.id}.${ext}`);
-            await pipeline(Readable.fromWeb(res.body), createWriteStream(target));
-            saved.push(target);
-            if (!isJsonMode())
-                success(`Saved ${target}`);
-        }
-        if (isJsonMode())
-            printJson({ id, files: saved });
-    });
-    return history;
-}

package/dist/commands/model.js

@@ -1,136 +0,0 @@
-import { Command } from 'commander';
-import { WjiClient } from '../core/client.js';
-import { color, detail, detailLevel, info, render, table, truncate, warn } from '../core/output.js';
-const FEATURES = [
-    'text',
-    'image',
-    'video',
-    'audio',
-    'tts',
-    'web',
-    'thinking',
-    'function_calling',
-    'image_vision',
-    'video_vision',
-    'structured_output',
-    'digital_host',
-    'upscale_video',
-];
-/**
- * The endpoint filters with `features.some(...)`, so an empty feature list
- * matches nothing. Asking for every feature is the only way to "list all".
- */
-export async function fetchModels(client, opts) {
-    const features = opts.features?.length ? opts.features : FEATURES;
-    const list = await client.get(`/ai/model/list/${features.join(',')}`, {
-        workspaceId: client.workspace(opts.workspace),
-        detail: opts.detail,
-    });
-    return Array.isArray(list) ? list : list?.data || [];
-}
-export function modelCommand(globals) {
-    const models = new Command('models').aliases(['model']).description('List available AI models');
-    models
-        .command('list', { isDefault: true })
-        .description('List models, optionally filtered by feature')
-        .option('-f, --feature <feature...>', `filter: ${FEATURES.join(', ')}`)
-        .option('-w, --workspace <id>', 'resolve pricing/access for a workspace')
-        .option('-k, --keyword <text>', 'match name, nickname or description')
-        .option('--all', 'include hidden and disabled models')
-        .action(async (opts) => {
-        const client = new WjiClient(globals());
-        let rows = await fetchModels(client, {
-            features: opts.feature,
-            workspace: opts.workspace,
-            detail: detailLevel(),
-        });
-        if (!opts.all)
-            rows = rows.filter((m) => m.enabled !== false && !m.hidden);
-        if (opts.keyword) {
-            const needle = opts.keyword.toLowerCase();
-            rows = rows.filter((m) => [m.name, m.nickname, m.description].some((v) => String(v || '').toLowerCase().includes(needle)));
-        }
-        // The client endpoint returns a curated model view — no rate, tags or id —
-        // so the useful columns come out of the form schema instead.
-        render(rows, () => {
-            table(rows, [
-                { header: 'model', value: (m) => m.nickname },
-                { header: 'name', value: (m) => (m.name === m.nickname ? '' : m.name) },
-                { header: 'features', value: (m) => truncate((m.features || []).join(','), 22) },
-                { header: 'ratios', value: (m) => truncate((m.form?.aspectRatio || []).join(' '), 30) },
-                { header: 'max n', value: (m) => m.form?.batch?.max },
-                { header: 'refs', value: (m) => (m.form?.reference?.enable ? m.form.reference.max : '') },
-                { header: 'duration', value: (m) => durationLabel(m.form?.video?.duration) },
-                { header: 'params', value: (m) => truncate(Object.keys(m.form?.other || {}).join(','), 34) },
-            ]);
-            info(color.dim(`${rows.length} models · pass the MODEL column to \`-m\``));
-        });
-    });
-    models
-        .command('get <name>')
-        .description('Show a model, including its form parameter schema')
-        .option('-w, --workspace <id>', 'resolve pricing/access for a workspace')
-        .action(async (name, opts) => {
-        const client = new WjiClient(globals());
-        const rows = await fetchModels(client, { workspace: opts.workspace, detail: detailLevel() });
-        // `name` is not unique across providers; `nickname` is, so prefer it.
-        const matches = rows.filter((m) => m.nickname === name || m.name === name);
-        if (!matches.length)
-            throw new Error(`No model named "${name}". Try \`wji models list\`.`);
-        const model = matches.find((m) => m.nickname === name) ?? matches[0];
-        if (matches.length > 1) {
-            warn(`${matches.length} models share the name "${name}" — showing "${model.nickname}". ` +
-                `Others: ${matches
-                    .filter((m) => m !== model)
-                    .map((m) => m.nickname)
-                    .join(', ')}`);
-        }
-        render(model, (m) => {
-            const form = m.form || {};
-            detail([
-                ['name', m.name],
-                ['nickname', m.nickname],
-                ['description', m.description],
-                ['features', (m.features || []).join(', ')],
-                ['aspectRatio', (form.aspectRatio || []).join(' ')],
-                ['n (--n)', form.batch ? `${form.batch.min}-${form.batch.max} (default ${form.batch.default})` : null],
-                ['references', form.reference?.enable ? `up to ${form.reference.max}` : 'not supported'],
-                ['duration (-d)', durationLabel(form.video?.duration)],
-                ['video frames', (form.video?.support || []).join(', ')],
-                ['accepted', (form.props?.filter || []).join(', ')],
-                ['required', (form.props?.required || []).join(', ')],
-            ]);
-            printOtherParams(form.other);
-        });
-    });
-    models
-        .command('features')
-        .description('List the feature flags accepted by --feature')
-        .action(() => render(FEATURES, (f) => f.forEach((x) => process.stdout.write(x + '\n'))));
-    return models;
-}
-function durationLabel(duration) {
-    if (!duration?.enable)
-        return null;
-    return `${duration.min}-${duration.max}s (default ${duration.default})`;
-}
-/** `form.other` holds the model-specific knobs reachable through `--set`. */
-function printOtherParams(other) {
-    const entries = Object.entries(other || {});
-    if (!entries.length)
-        return;
-    info('');
-    info(color.bold('model parameters (pass as --set <key>=<value>):'));
-    for (const [key, raw] of entries) {
-        const spec = raw;
-        const options = spec?.options
-            ? ` [${spec.options.map((o) => o?.value ?? o).join(' | ')}]`
-            : spec?.type === 'boolean'
-                ? ' [true | false]'
-                : '';
-        const fallback = spec?.default != null ? ` (default ${spec.default})` : '';
-        process.stdout.write(`  ${color.cyan(key)}${options}${color.dim(fallback)}\n`);
-        if (spec?.description)
-            process.stdout.write(`    ${color.dim(spec.description)}\n`);
-    }
-}