@wji.ai/cli 0.7.0 → 0.7.1

package/dist/commands/class.js

@@ -1,395 +0,0 @@
-import { mkdir, stat } from 'node:fs/promises';
-import { createWriteStream } from 'node:fs';
-import { join } from 'node:path';
-import { Readable } from 'node:stream';
-import { pipeline } from 'node:stream/promises';
-import { Command } from 'commander';
-import { WjiClient } from '../core/client.js';
-import { confirm } from '../core/prompt.js';
-import { color, info, isJsonMode, relativeTime, render, success, table, truncate, warn } from '../core/output.js';
-import { loadMembers, mapLimit, memberLabel, resolveMember } from '../core/members.js';
-import { COLOR_TAGS, canvasesFolders, copyNodes, copyPlacement, copySource, createCanvasFolder, describe, linkedState, listCanvases, loadCanvas, parseVisibility, tagText, updateCanvasFolder, } from './canvas.js';
-const WORKERS = 4;
-async function loadClass(c, wsId) {
-    const [{ workspace, members }, canvases] = await Promise.all([loadMembers(c, wsId), listCanvases(c, wsId)]);
-    const students = members.filter((m) => m.role !== 'owner');
-    const seats = students.map((member) => ({
-        member,
-        canvases: canvases.filter((cv) => cv.ownerUserId === member.userId),
-    }));
-    return { workspace, members, canvases, seats };
-}
-/** `--student` narrows the roster; otherwise every non-owner member. */
-function pickSeats(seats, members, tokens) {
-    if (!tokens?.length)
-        return seats;
-    const wanted = new Set(tokens.map((t) => resolveMember(members, t).userId));
-    const picked = seats.filter((s) => wanted.has(s.member.userId));
-    const owners = members.filter((m) => m.role === 'owner' && wanted.has(m.userId));
-    if (owners.length)
-        warn(`${owners.map(memberLabel).join(', ')} is the teacher (workspace owner), not a student — skipped`);
-    return picked;
-}
-function seatCanvas(seat) {
-    if (seat.canvases.length > 1) {
-        warn(`${memberLabel(seat.member)} owns ${seat.canvases.length} canvases — using the most recently updated "${[...seat.canvases].sort(byUpdated)[0].name}"`);
-    }
-    return [...seat.canvases].sort(byUpdated)[0];
-}
-const byUpdated = (a, b) => Date.parse(b.updatedAt || '0') - Date.parse(a.updatedAt || '0');
-/** Color ids a `--tag` value means on this canvas; a label the canvas lacks matches nothing (no error per student). */
-function tagColors(canvas, tags) {
-    if (!tags?.length)
-        return undefined;
-    const colors = new Set();
-    for (const raw of tags) {
-        const v = raw.trim().toLowerCase();
-        for (const t of COLOR_TAGS) {
-            if (t.id === v || t.alias === v || canvas.tagNames[t.id]?.toLowerCase() === v)
-                colors.add(t.id);
-        }
-    }
-    return colors;
-}
-function parseSince(value) {
-    if (!value)
-        return undefined;
-    const m = /^(\d+)\s*(m|h|d)$/i.exec(value.trim());
-    if (m) {
-        const unit = { m: 60_000, h: 3_600_000, d: 86_400_000 }[m[2].toLowerCase()];
-        return Date.now() - Number(m[1]) * unit;
-    }
-    const t = Date.parse(value);
-    if (Number.isNaN(t))
-        throw new Error('--since takes 30m, 2h, 1d or a date');
-    return t;
-}
-function requireStudents(seats, filtered) {
-    if (seats.length)
-        return;
-    if (filtered?.length)
-        throw new Error('No student matches --student');
-    throw new Error('No students in this workspace yet. Invite them with `wji ws member invite <emails...>`.');
-}
-export function classCommand(globals) {
-    const cls = new Command('class')
-        .aliases(['classroom'])
-        .description('Teach with a workspace: one canvas per student, copy work to everyone, check progress and results');
-    const client = () => new WjiClient(globals());
-    const workspaceOf = async (c, explicit) => explicit || (await linkedState(c))?.workspaceId || c.requireWorkspace();
-    cls
-        .command('roster')
-        .description('Students (non-owner members) with their role and canvas')
-        .option('-w, --workspace <id>', 'class workspace (defaults to the linked one, then the profile default)')
-        .action(async (opts) => {
-        const c = client();
-        const wsId = await workspaceOf(c, opts.workspace);
-        const { workspace, members, seats } = await loadClass(c, wsId);
-        const teacher = members.filter((m) => m.role === 'owner').map(memberLabel).join(', ');
-        const rows = seats.map((s) => ({
-            userId: s.member.userId,
-            name: s.member.name,
-            email: s.member.email,
-            role: s.member.role,
-            canvases: s.canvases.map(({ folder, ...cv }) => cv),
-        }));
-        render({ workspace: { id: wsId, name: workspace.name }, teacher, students: rows }, () => {
-            info(color.dim(`${workspace.name} (${wsId}) · teacher ${teacher} · ${rows.length} student(s)`));
-            table(rows, [
-                { header: 'name', value: (r) => r.name },
-                { header: 'email', value: (r) => r.email },
-                { header: 'role', value: (r) => (r.role === 'viewer' ? color.yellow('viewer') : r.role) },
-                { header: 'canvas', value: (r) => (r.canvases.length ? r.canvases.map((cv) => cv.name).join(', ') : color.red('none')) },
-                { header: 'visibility', value: (r) => r.canvases.map((cv) => (cv.visibility === 'owner' ? 'private' : 'shared')).join(', ') },
-            ]);
-            if (rows.some((r) => r.role === 'viewer'))
-                info(color.dim('Viewers cannot generate; make them editors with `wji ws member role <name> editor`.'));
-            if (rows.some((r) => !r.canvases.length))
-                info(color.dim('Give everyone a canvas with `wji class canvases --create`.'));
-        });
-    });
-    cls
-        .command('canvases')
-        .description('Each student\'s own canvas; --create makes the missing ones (named after the student, owned by them)')
-        .option('-w, --workspace <id>', 'class workspace (defaults to the linked one, then the profile default)')
-        .option('--create', 'create a canvas for every student who has none')
-        .option('--visibility <v>', 'owner (private: the student and the teacher) | members (the whole class sees it)', 'owner')
-        .option('--update', 'also apply --visibility to the students\' existing canvases')
-        .option('--name <template>', 'canvas name; {name} and {email} are filled in', '{name}')
-        .option('--student <members...>', 'only these students (name, email or user id)')
-        .option('--app <appId>', 'InfiniteCanvas app when the workspace has several')
-        .action(async (opts) => {
-        const c = client();
-        const wsId = await workspaceOf(c, opts.workspace);
-        const visibility = parseVisibility(opts.visibility);
-        const { members, seats: all } = await loadClass(c, wsId);
-        const seats = pickSeats(all, members, opts.student);
-        requireStudents(seats, opts.student);
-        const created = [];
-        const updated = [];
-        if (opts.create && seats.some((s) => !s.canvases.length)) {
-            const folders = await canvasesFolders(c, wsId);
-            const target = opts.app ? folders.find((f) => f.appId === opts.app) : folders[0];
-            if (!target)
-                throw new Error(`Workspace ${wsId} has no InfiniteCanvas app${opts.app ? ` ${opts.app}` : ''}. Add one with \`wji ws app add canvas\`.`);
-            for (const seat of seats.filter((s) => !s.canvases.length)) {
-                const m = seat.member;
-                const name = opts.name.replace(/\{name\}/g, m.name || m.email || m.userId).replace(/\{email\}/g, m.email);
-                const raw = await createCanvasFolder(c, target.folderId, name, { ownerUserId: m.userId, visibility });
-                seat.canvases.push({ id: raw.id, name: raw.name, appId: target.appId, ownerUserId: m.userId, visibility, updatedAt: raw.updatedAt, folder: raw });
-                created.push({ userId: m.userId, canvasId: raw.id, name: raw.name });
-            }
-        }
-        if (opts.update) {
-            for (const seat of seats) {
-                for (const cv of seat.canvases.filter((x) => x.visibility !== visibility && !created.some((k) => k.canvasId === x.id))) {
-                    await updateCanvasFolder(c, cv.id, (env) => {
-                        env.metadata.visibility = visibility;
-                    });
-                    cv.visibility = visibility;
-                    updated.push(cv.id);
-                }
-            }
-        }
-        const rows = seats.map((s) => ({ student: memberLabel(s.member), userId: s.member.userId, canvases: s.canvases.map(({ folder, ...cv }) => cv) }));
-        render({ created, updated, students: rows }, () => {
-            if (created.length)
-                success(`Created ${created.length} canvas(es)`);
-            if (updated.length)
-                success(`Set ${updated.length} canvas(es) to ${visibility === 'owner' ? 'private' : 'shared'}`);
-            table(rows, [
-                { header: 'student', value: (r) => r.student },
-                { header: 'canvas', value: (r) => (r.canvases.length ? r.canvases.map((cv) => cv.name).join(', ') : color.red('none')) },
-                { header: 'id', value: (r) => color.dim(r.canvases.map((cv) => cv.id).join(', ')) },
-                { header: 'visibility', value: (r) => r.canvases.map((cv) => (cv.visibility === 'owner' ? 'private' : 'shared')).join(', ') },
-            ]);
-            if (!opts.create && rows.some((r) => !r.canvases.length))
-                info(color.dim('Pass --create to give the others a canvas.'));
-        });
-    });
-    cls
-        .command('copy [nodeIds...]')
-        .description('Copy nodes into every student\'s canvas (default: the nodes selected in the linked browser canvas). ' +
-        'Connections between them come along; finished media is shared, generate nodes keep their prompt and settings.')
-        .option('-c, --canvas <id>', 'source canvas (defaults to the linked canvas)')
-        .option('--selected', 'add the linked browser selection to the node ids given')
-        .option('--student <members...>', 'only these students (name, email or user id)')
-        .option('--at <x,y>', 'top-left of the copied group in each canvas; default is right of what is already there')
-        .option('--same-position', 'keep the original coordinates')
-        .option('-y, --yes', 'skip confirmation')
-        .action(async (ids, opts) => {
-        const c = client();
-        const { source, nodes } = await copySource(c, ids, opts);
-        const { members, seats: all } = await loadClass(c, source.workspaceId);
-        const seats = pickSeats(all, members, opts.student);
-        requireStudents(seats, opts.student);
-        const missing = seats.filter((s) => !s.canvases.length);
-        if (missing.length)
-            warn(`No canvas yet, skipped: ${missing.map((s) => memberLabel(s.member)).join(', ')} (create them with \`wji class canvases --create\`)`);
-        const targets = seats
-            .filter((s) => s.canvases.length)
-            .map((s) => ({ seat: s, canvas: seatCanvas(s) }))
-            .filter((t) => t.canvas.id !== source.id);
-        if (!targets.length)
-            throw new Error('No student canvas to copy into');
-        const list = nodes.map((n) => `${n.kind} "${n.name}"`).join(', ');
-        const question = `Copy ${nodes.length} node(s) (${truncate(list, 120)}) from "${source.name}" into ${targets.length} student canvas(es)?`;
-        if (!(await confirm(question, opts.yes)))
-            return info('Aborted');
-        const placement = copyPlacement(opts);
-        const results = await mapLimit(targets, WORKERS, async ({ seat, canvas }) => {
-            try {
-                const target = await loadCanvas(c, canvas.id);
-                const r = await copyNodes(c, source, nodes, target, placement);
-                if (!isJsonMode())
-                    success(`${memberLabel(seat.member)}: ${r.nodes.length} node(s), ${r.edges} connection(s) → ${canvas.name}`);
-                return { student: memberLabel(seat.member), userId: seat.member.userId, ok: true, ...r };
-            }
-            catch (err) {
-                if (!isJsonMode())
-                    warn(`${memberLabel(seat.member)}: ${err.message}`);
-                return { student: memberLabel(seat.member), userId: seat.member.userId, ok: false, canvasId: canvas.id, error: err.message };
-            }
-        });
-        const failed = results.filter((r) => !r.ok);
-        render(results, () => {
-            const skipped = results.find((r) => r.ok)?.skippedEdges;
-            if (skipped)
-                info(color.dim(`${skipped} connection(s) from nodes outside the copy were left out`));
-            if (failed.length)
-                warn(`${failed.length} failed — rerun with --student ${failed.map((r) => JSON.stringify(r.student)).join(' ')}`);
-            else
-                success(`Copied into ${results.length} canvas(es)`);
-        });
-        if (failed.length)
-            process.exitCode = 1;
-    });
-    cls
-        .command('status')
-        .description('Progress per student: generate nodes done / running / failed / not started, generations and credits')
-        .option('-w, --workspace <id>', 'class workspace (defaults to the linked one, then the profile default)')
-        .option('--tag <tags...>', 'only count nodes with these color tags (label like HW1, or a color)')
-        .option('-k, --kind <kind>', 'only count this node kind (image | video | audio)')
-        .option('--student <members...>', 'only these students')
-        .option('-s, --sort <by>', 'name | recent (last generation first) | progress (fewest done first)', 'name')
-        .action(async (opts) => {
-        const c = client();
-        const wsId = await workspaceOf(c, opts.workspace);
-        const { members, seats: all } = await loadClass(c, wsId);
-        const seats = pickSeats(all, members, opts.student);
-        requireStudents(seats, opts.student);
-        const usage = await c.get(`/workspace/list/${wsId}/quota-usage`).catch(() => null);
-        const credits = new Map((usage?.byUserTotal || []).map((u) => [String(u.userId), Number(u.amount) || 0]));
-        const rows = await mapLimit(seats, WORKERS, async (seat) => {
-            const base = { student: memberLabel(seat.member), userId: seat.member.userId, email: seat.member.email, credits: credits.get(seat.member.userId) ?? 0 };
-            if (!seat.canvases.length)
-                return { ...base, canvas: null, nodes: 0, done: 0, running: 0, failed: 0, todo: 0, generations: 0, lastGeneratedAt: null };
-            const cvRow = seatCanvas(seat);
-            const cv = await loadCanvas(c, cvRow.id);
-            const colors = tagColors(cv, opts.tag);
-            const nodes = cv.nodes
-                .filter((n) => !opts.kind || n.kind === opts.kind)
-                .filter((n) => !colors || colors.has(n.content.colorTag?.colorId))
-                .map((n) => describe(cv, n));
-            const gen = nodes.filter((n) => n.mode === 'generate');
-            const history = await c.getFresh('/ai/assets/history/search', {
-                workspace: wsId,
-                scope: 'canvas',
-                scopeId: cv.id,
-                page: 1,
-                limit: 1,
-                sort: { createdAt: 'desc' },
-            });
-            return {
-                ...base,
-                canvas: { id: cv.id, name: cv.name },
-                nodes: nodes.length,
-                done: gen.filter((n) => n.status === 'done').length,
-                running: gen.filter((n) => n.status === 'generating' || n.status === 'pending').length,
-                failed: gen.filter((n) => n.status === 'failed').length,
-                todo: gen.filter((n) => !n.status).length,
-                generations: Number(history?.pagination?.total ?? history?.data?.length ?? 0),
-                lastGeneratedAt: history?.data?.[0]?.createdAt || null,
-            };
-        });
-        const sorters = {
-            name: (a, b) => a.student.localeCompare(b.student),
-            recent: (a, b) => Date.parse(b.lastGeneratedAt || '0') - Date.parse(a.lastGeneratedAt || '0'),
-            progress: (a, b) => a.done - b.done || a.student.localeCompare(b.student),
-        };
-        if (!sorters[opts.sort])
-            throw new Error('--sort must be name, recent or progress');
-        rows.sort(sorters[opts.sort]);
-        render(rows, () => {
-            if (opts.tag)
-                info(color.dim(`Counting nodes tagged ${opts.tag.join(', ')}`));
-            table(rows, [
-                { header: 'student', value: (r) => r.student },
-                { header: 'canvas', value: (r) => (r.canvas ? truncate(r.canvas.name, 20) : color.red('none')) },
-                { header: 'nodes', value: (r) => String(r.nodes) },
-                { header: 'done', value: (r) => (r.done ? color.green(String(r.done)) : '0') },
-                { header: 'running', value: (r) => (r.running ? color.yellow(String(r.running)) : '') },
-                { header: 'failed', value: (r) => (r.failed ? color.red(String(r.failed)) : '') },
-                { header: 'not run', value: (r) => (r.todo ? String(r.todo) : '') },
-                { header: 'gens', value: (r) => String(r.generations) },
-                { header: 'last gen', value: (r) => (r.lastGeneratedAt ? relativeTime(r.lastGeneratedAt) : '') },
-                { header: 'credits', value: (r) => (r.credits ? String(Math.round(r.credits * 10) / 10) : '') },
-            ]);
-            if (!usage)
-                info(color.dim('Credits hidden: this account cannot read the workspace credit usage.'));
-        });
-    });
-    cls
-        .command('results')
-        .description('Finished generations across student canvases, newest first; --download saves them into one folder per student')
-        .option('-w, --workspace <id>', 'class workspace (defaults to the linked one, then the profile default)')
-        .option('--student <members...>', 'only these students')
-        .option('--tag <tags...>', 'only nodes with these color tags (label like HW1, or a color)')
-        .option('-k, --kind <kind>', 'image | video | audio')
-        .option('-n, --name <regex>', 'only nodes whose name matches (case-insensitive)')
-        .option('--since <when>', 'finished after: 30m, 2h, 1d or a date')
-        .option('--all', 'include display nodes (uploaded or copied media), not only generate nodes')
-        .option('-s, --sort <by>', 'recent | name (student, then newest)', 'recent')
-        .option('-l, --limit <n>', 'at most this many rows (0 = all)', '0')
-        .option('-d, --download <dir>', 'save every listed file to <dir>/<student>/')
-        .action(async (opts) => {
-        const c = client();
-        const wsId = await workspaceOf(c, opts.workspace);
-        const since = parseSince(opts.since);
-        const nameRe = opts.name ? new RegExp(opts.name, 'i') : undefined;
-        const { members, seats: all } = await loadClass(c, wsId);
-        const seats = pickSeats(all, members, opts.student).filter((s) => s.canvases.length);
-        requireStudents(seats, opts.student);
-        const perSeat = await mapLimit(seats, WORKERS, async (seat) => {
-            const cv = await loadCanvas(c, seatCanvas(seat).id);
-            const colors = tagColors(cv, opts.tag);
-            return cv.nodes
-                .filter((n) => ['image', 'video', 'audio'].includes(n.kind))
-                .filter((n) => !opts.kind || n.kind === opts.kind)
-                .filter((n) => !colors || colors.has(n.content.colorTag?.colorId))
-                .filter((n) => !nameRe || nameRe.test(n.name))
-                .map((n) => ({ n: describe(cv, n), asset: n.file ? cv.assets.get(n.file) : undefined }))
-                .filter(({ n }) => !!n.url && n.status !== 'generating' && (opts.all || n.mode === 'generate'))
-                .map(({ n, asset }) => ({
-                student: memberLabel(seat.member),
-                userId: seat.member.userId,
-                canvasId: cv.id,
-                canvasName: cv.name,
-                nodeId: n.id,
-                kind: n.kind,
-                name: n.name,
-                tag: n.tag,
-                model: n.generate?.model,
-                prompt: n.generate?.prompt,
-                assetId: n.assetId,
-                url: n.url,
-                finishedAt: (asset?.updatedAt || asset?.createdAt || null),
-            }))
-                .filter((r) => !since || Date.parse(r.finishedAt || '0') >= since);
-        });
-        let rows = perSeat.flat();
-        const newest = (a, b) => Date.parse(b.finishedAt || '0') - Date.parse(a.finishedAt || '0');
-        rows.sort(opts.sort === 'name' ? (a, b) => a.student.localeCompare(b.student) || newest(a, b) : newest);
-        const limit = Number(opts.limit) || 0;
-        if (limit > 0)
-            rows = rows.slice(0, limit);
-        if (opts.download) {
-            const isDir = await stat(opts.download).then((s) => s.isDirectory()).catch(() => false);
-            if (!isDir)
-                await mkdir(opts.download, { recursive: true });
-            await mapLimit(rows, WORKERS, async (r) => {
-                const dir = join(opts.download, safeName(r.student));
-                await mkdir(dir, { recursive: true });
-                const res = await fetch(r.url);
-                if (!res.ok || !res.body)
-                    return warn(`${r.student} ${r.name}: download failed (${res.status})`);
-                const file = join(dir, `${safeName(r.name || r.kind)}-${r.nodeId.slice(-6)}${extensionOf(r.url)}`);
-                await pipeline(Readable.fromWeb(res.body), createWriteStream(file));
-                r.path = file;
-            });
-        }
-        render(rows, () => {
-            if (!rows.length)
-                return info('No finished results match');
-            table(rows, [
-                { header: 'student', value: (r) => r.student },
-                { header: 'kind', value: (r) => r.kind },
-                { header: 'name', value: (r) => truncate(r.name, 18) },
-                { header: 'tag', value: (r) => truncate(tagText(r.tag), 12) },
-                { header: 'when', value: (r) => relativeTime(r.finishedAt) },
-                { header: 'model', value: (r) => truncate(r.model || '', 18) },
-                { header: opts.download ? 'saved' : 'url', value: (r) => truncate(r.path || r.url, 60) },
-            ]);
-            if (opts.download)
-                success(`Saved ${rows.filter((r) => r.path).length} file(s) under ${opts.download}`);
-        });
-    });
-    return cls;
-}
-function safeName(value) {
-    return value.replace(/[\\/:*?"<>|\s]+/g, '_').slice(0, 60) || 'untitled';
-}
-function extensionOf(url) {
-    const match = /\.([a-z0-9]{2,5})(?:\?|$)/i.exec(url);
-    return match ? `.${match[1]}` : '';
-}

package/dist/commands/config.js

@@ -1,113 +0,0 @@
-import { Command } from 'commander';
-import { WjiClient } from '../core/client.js';
-import { DEFAULT_ENDPOINT, configPath, getProfile, readConfig, updateProfile, writeConfig, } from '../core/config.js';
-import { confirm } from '../core/prompt.js';
-import { color, detail, info, render, success, table } from '../core/output.js';
-const REDACTED_KEYS = new Set(['accessToken', 'refreshToken', 'apiKey']);
-function redact(profile) {
-    const out = {};
-    for (const [k, v] of Object.entries(profile)) {
-        out[k] = REDACTED_KEYS.has(k) && typeof v === 'string' ? `${v.slice(0, 8)}…` : v;
-    }
-    return out;
-}
-export function configCommand(globals) {
-    const config = new Command('config').description('Manage CLI profiles and defaults');
-    config
-        .command('show', { isDefault: true })
-        .description('Show the active profile (secrets redacted)')
-        .action(() => {
-        const g = globals();
-        const { name, profile } = getProfile(g.profile);
-        const view = redact(profile);
-        // The endpoint is resolved at request time from flag > env > profile >
-        // built-in default, so show what will actually be used, not just what is
-        // stored — an unset profile would otherwise print nothing here.
-        const client = new WjiClient(g);
-        const effective = client.endpoint + (profile.endpoint ? '' : ` ${color.dim('(default)')}`);
-        render({ profile: name, path: configPath(), endpoint: client.endpoint, ...view }, () => {
-            detail([
-                ['profile', name],
-                ['file', configPath()],
-                ['endpoint', effective],
-                ...Object.entries(view).filter(([k]) => k !== 'endpoint'),
-                ['org', client.orgId || 'personal'],
-            ]);
-        });
-    });
-    config
-        .command('set <key> <value>')
-        .description('Set a profile field (endpoint, orgId, workspace, locale, apiKey)')
-        .action((key, value) => {
-        const allowed = ['endpoint', 'orgId', 'workspace', 'locale', 'apiKey', 'email', 'name'];
-        if (!allowed.includes(key)) {
-            throw new Error(`Unknown key "${key}". Allowed: ${allowed.join(', ')}`);
-        }
-        updateProfile(globals().profile, { [key]: value === 'null' ? null : value });
-        success(`${key} = ${value}`);
-    });
-    config
-        .command('unset <key>')
-        .description('Remove a profile field')
-        .action((key) => {
-        updateProfile(globals().profile, { [key]: undefined });
-        success(`Cleared ${key}`);
-    });
-    config
-        .command('profiles')
-        .description('List all profiles')
-        .action(() => {
-        const file = readConfig();
-        // Spread first: a profile's own `name` field is the account display name,
-        // which must not shadow the profile key.
-        const rows = Object.entries(file.profiles).map(([key, p]) => ({ ...p, key }));
-        render({ current: file.current, profiles: rows.map((r) => redact(r)) }, () => table(rows, [
-            { header: '', value: (r) => (r.key === file.current ? color.green('*') : ' ') },
-            { header: 'profile', value: (r) => r.key },
-            { header: 'endpoint', value: (r) => r.endpoint || `${DEFAULT_ENDPOINT} (default)` },
-            { header: 'account', value: (r) => r.email },
-            { header: 'org', value: (r) => r.orgId || 'personal' },
-        ]));
-    });
-    config
-        .command('use <profile>')
-        .description('Switch the active profile (creates it when new)')
-        .action((name) => {
-        const file = readConfig();
-        if (!file.profiles[name])
-            file.profiles[name] = {};
-        file.current = name;
-        writeConfig(file);
-        success(`Using profile ${name}`);
-    });
-    config
-        .command('rm <profile>')
-        .description('Delete a profile')
-        .option('-y, --yes', 'skip confirmation')
-        .action(async (name, opts) => {
-        const file = readConfig();
-        if (!file.profiles[name])
-            throw new Error(`No such profile: ${name}`);
-        const p = file.profiles[name];
-        // A profile is often the only copy of an sk_ secret — say so before it goes.
-        const holds = [p.apiKey && 'API key', p.refreshToken && 'login'].filter(Boolean).join(' and ');
-        const prompt = `Delete profile "${name}"${holds ? ` and the ${holds} stored in it` : ''}?`;
-        if (!(await confirm(prompt, opts.yes)))
-            return info('Aborted');
-        delete file.profiles[name];
-        if (file.current === name)
-            file.current = Object.keys(file.profiles)[0] || 'default';
-        if (!file.profiles[file.current])
-            file.profiles[file.current] = {};
-        writeConfig(file);
-        success(`Deleted profile ${name}`);
-        info(color.dim(`Active profile is now ${file.current}`));
-    });
-    config
-        .command('path')
-        .description('Print the config file path')
-        .action(() => {
-        process.stdout.write(configPath() + '\n');
-    });
-    return config;
-}