@wji.ai/cli 0.1.0

package/dist/commands/gen.js

@@ -0,0 +1,366 @@
+import { Command } from 'commander';
+import { WjiClient } from '../core/client.js';
+import { confirm, parseKeyValues, readJson, readValue } from '../core/prompt.js';
+import { color, detail, info, isJsonMode, printJson, render, success, table, truncate, warn } from '../core/output.js';
+const PENDING = 0;
+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) {
+    const path = opts.history
+        ? `/ai/assets/history/${kind}/generations`
+        : `/ai/assets/${kind}/generations`;
+    const result = await client.post(path, body);
+    if (!opts.history) {
+        // Raw mode returns Asset[] directly; there is no history to poll.
+        return render(result, (assets) => {
+            if (!Array.isArray(assets))
+                return detail(Object.entries(assets || {}));
+            table(assets, [
+                { header: 'assetId', value: (a) => a.id },
+                { header: 'state', value: (a) => (a.status === PENDING ? 'pending' : 'ready') },
+                { header: 'url', value: (a) => a.url },
+            ]);
+        });
+    }
+    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>', 'attach the result to an fsnode')
+        .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('--no-history', 'call the raw endpoint and return assets instead of a history')
+        .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]]')).action(async (opts) => {
+        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),
+            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),
+        });
+        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}`);
+            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

@@ -0,0 +1,134 @@
+import { Command } from 'commander';
+import { WjiClient } from '../core/client.js';
+import { color, detail, 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),
+    });
+    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,
+        });
+        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 });
+        // `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`);
+    }
+}

package/dist/commands/org.js

@@ -0,0 +1,85 @@
+import { Command } from 'commander';
+import { WjiClient } from '../core/client.js';
+import { updateProfile } from '../core/config.js';
+import { color, detail, info, render, success, table } from '../core/output.js';
+/**
+ * Organization context is a request header (X-Org-Id), not a login. Selecting
+ * one here just stores it in the profile; every later call carries it.
+ */
+export function orgCommand(globals) {
+    const org = new Command('org').description('Switch organization context (X-Org-Id)');
+    org
+        .command('list', { isDefault: true })
+        .description('List organizations you belong to')
+        .action(async () => {
+        const client = new WjiClient(globals());
+        const memberships = await client.get('/organization/mine');
+        render(memberships, (rows) => table(rows || [], [
+            {
+                header: '',
+                value: (m) => m.organization?.id === client.orgId ? color.green('*') : ' ',
+            },
+            { header: 'id', value: (m) => m.organization?.id },
+            { header: 'name', value: (m) => m.organization?.name },
+            { header: 'role', value: (m) => m.role },
+            { header: 'status', value: (m) => m.status },
+            { header: 'org status', value: (m) => m.organization?.status },
+        ]));
+    });
+    org
+        .command('use <orgId>')
+        .description('Make this organization the default context')
+        .action(async (orgId) => {
+        updateProfile(globals().profile, { orgId });
+        success(`Org context set to ${orgId}`);
+        info(color.dim('Use `wji org personal` to go back to your personal context.'));
+    });
+    org
+        .command('personal')
+        .description('Clear the organization context')
+        .action(() => {
+        updateProfile(globals().profile, { orgId: null });
+        success('Switched to personal context');
+    });
+    org
+        .command('current')
+        .description('Show the member record for the active org context')
+        .action(async () => {
+        const client = new WjiClient(globals());
+        if (!client.orgId)
+            return info('Personal context (no organization)');
+        const me = await client.get('/organization/me');
+        render(me, (m) => detail([
+            ['org', m.organization?.name],
+            ['orgId', m.organization?.id],
+            ['role', m.role],
+            ['status', m.status],
+            ['monthlyLimit', m.monthlyLimit],
+            ['permanentLimit', m.permanentLimit],
+        ]));
+    });
+    org
+        .command('members')
+        .description('List members of the active org context')
+        .action(async () => {
+        const client = new WjiClient(globals());
+        const members = await client.get('/organization/members');
+        render(members, (rows) => table(rows || [], [
+            { header: 'id', value: (m) => m.id },
+            { header: 'user', value: (m) => m.user?.id },
+            { header: 'name', value: (m) => m.user?.name },
+            { header: 'email', value: (m) => m.user?.email },
+            { header: 'role', value: (m) => m.role },
+            { header: 'status', value: (m) => m.status },
+        ]));
+    });
+    org
+        .command('create <name>')
+        .description('Create an organization')
+        .action(async (name) => {
+        const client = new WjiClient(globals());
+        const created = await client.post('/organization/create', { name });
+        render(created, (o) => success(`Created organization ${o.name} (${o.id})`));
+    });
+    return org;
+}