@wji.ai/cli 0.4.0 → 0.5.0

package/dist/commands/class.js

@@ -0,0 +1,395 @@
+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]}` : '';
+}