@wji.ai/cli 0.3.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]}` : '';
+}

package/dist/commands/crew.js

@@ -0,0 +1,205 @@
+import { Command } from 'commander';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { confirm } from '../core/prompt.js';
+import { color, detail, info, isJsonMode, printJson, render, success, table, warn } from '../core/output.js';
+import { CREW_REGISTRY, TARGETS, applyOps, describeOp, fetchPack, findOpenclaw, grokZip, loadPackFromDir, pathState, planClaude, planCodex, planOpenclaw, readInstalled, relOrAbs, uninstallPaths, validatePack, writeInstalled, } from '../core/crew.js';
+/**
+ * `wji crew` — install a crew pack (skills + agent seats) into the hosts that
+ * run them: Claude Code, OpenAI Codex, OpenClaw, and the Grok bot platform
+ * (as an import zip). One pack, one command per host.
+ */
+function parseTargets(value) {
+    if (!value || value === 'all')
+        return ['claude', 'codex', 'openclaw', 'grok'];
+    const out = [];
+    for (const raw of value.split(',').map((s) => s.trim().toLowerCase()).filter(Boolean)) {
+        if (!TARGETS.includes(raw))
+            throw new Error(`Unknown target "${raw}". Use: ${TARGETS.join(', ')} or all`);
+        out.push(raw);
+    }
+    return out;
+}
+function requireValid(pack) {
+    const errors = validatePack(pack);
+    if (errors.length)
+        throw new Error(`Pack ${pack.crew.name} is not valid:\n  - ${errors.join('\n  - ')}`);
+}
+export function crewCommand(_globals) {
+    const crew = new Command('crew').description('Install crew packs (skills + agent seats) into Claude Code, Codex, OpenClaw or a Grok bot export');
+    crew
+        .command('install [name]')
+        .description(`Install a crew for one or more hosts (known crews: ${Object.keys(CREW_REGISTRY).join(', ')})`)
+        .option('--for <targets>', 'comma-separated: claude, codex, openclaw, grok, or all', 'all')
+        .option('--from <source>', 'a local pack folder, a .zip / .tar.gz, or an http(s) URL instead of the registry')
+        .option('--ref <ref>', 'git branch or tag when fetching from the registry')
+        .option('--project <dir>', 'install into this project (.claude/, .agents/, .codex/, openclaw/) instead of your home directory')
+        .option('--link', 'symlink skills and Claude agents to a local --from folder instead of copying')
+        .option('--out <zip>', 'where to write the Grok export zip (default ./<crew>-export.zip)')
+        .option('--no-register', 'openclaw: only write the workspaces and config fragment; do not run `openclaw agents add`')
+        .option('--dry-run', 'print what would be written and stop')
+        .option('-y, --yes', 'skip the confirmation')
+        .action(async (name, opts) => {
+        const targets = parseTargets(opts.for);
+        const pack = await fetchPack(name || 'short-drama', { from: opts.from, ref: opts.ref });
+        requireValid(pack);
+        if (opts.link && (!opts.from || /^https?:/.test(opts.from) || !pack.root.startsWith(resolve(opts.from)))) {
+            throw new Error('--link needs a local --from <folder>');
+        }
+        const io = { project: opts.project, link: !!opts.link, out: opts.out };
+        const plans = {};
+        for (const t of targets) {
+            if (t === 'claude')
+                plans.claude = planClaude(pack, io);
+            if (t === 'codex')
+                plans.codex = planCodex(pack, io);
+            if (t === 'openclaw')
+                plans.openclaw = planOpenclaw(pack, io, { register: opts.register !== false });
+        }
+        // codex and openclaw share ~/.agents/skills — write each skill once
+        if (plans.codex && plans.openclaw) {
+            const seen = new Set(plans.codex.filter((o) => o.kind !== 'exec').map((o) => o.path));
+            plans.openclaw = plans.openclaw.filter((o) => o.kind === 'exec' || !seen.has(o.path));
+        }
+        const grokOut = targets.includes('grok') ? resolve(opts.out || `${pack.crew.name}-export.zip`) : undefined;
+        info(`${color.bold(pack.crew.title || pack.crew.name)} — ${Object.keys(pack.agents).length} seat(s), ${pack.skills.size} skill(s) from ${pack.source}${pack.ref ? ` @ ${pack.ref}` : ''}`);
+        for (const t of targets) {
+            info('');
+            info(color.bold(`[${t}]`));
+            if (t === 'grok')
+                info(`  zip   ${relOrAbs(grokOut)}`);
+            for (const op of plans[t] || [])
+                info(`  ${describeOp(op).replace(/^(\w+)/, (m) => color.dim(m))}`);
+        }
+        if (opts.dryRun)
+            return info(color.dim('\n--dry-run: nothing written'));
+        info('');
+        if (!(await confirm('Write these?', opts.yes)))
+            return info('Aborted');
+        const installed = readInstalled();
+        const record = installed[pack.crew.name] || { source: pack.source, ref: pack.ref, installedAt: '', targets: {} };
+        record.source = pack.source;
+        record.ref = pack.ref;
+        record.installedAt = new Date().toISOString();
+        const summary = {};
+        for (const t of targets) {
+            info(color.bold(`[${t}]`));
+            if (t === 'grok') {
+                const { zip, entries } = grokZip(pack);
+                mkdirSync(dirname(grokOut), { recursive: true });
+                writeFileSync(grokOut, zip);
+                info(`  ✓ ${entries} entries → ${relOrAbs(grokOut)}`);
+                record.targets.grok = { paths: [grokOut], notes: [] };
+                summary.grok = { zip: grokOut, entries };
+                continue;
+            }
+            const previous = record.targets[t]?.paths || [];
+            const result = applyOps(plans[t] || [], info);
+            // paths from an earlier install of this crew that this run did not touch are stale — drop them
+            const stale = previous.filter((p) => !result.paths.includes(p));
+            if (stale.length)
+                uninstallPaths(stale);
+            record.targets[t] = result;
+            summary[t] = { written: result.paths.length, notes: result.notes };
+        }
+        installed[pack.crew.name] = record;
+        writeInstalled(installed);
+        if (targets.includes('openclaw')) {
+            const frag = (record.targets.openclaw?.paths || []).find((p) => p.endsWith('openclaw.agents.json5'));
+            warn(`openclaw: merge ${frag} into ~/.openclaw/openclaw.json (skills allowlists, tools, subagents, channel bindings) — the CLI never rewrites that file.`);
+            if (!findOpenclaw())
+                info(color.dim('  openclaw binary not found; the agents were not registered — run `openclaw agents add <seat> --workspace <dir>` for each seat.'));
+        }
+        if (targets.includes('codex')) {
+            info(color.dim('codex: the wji-operator seat needs network — set [sandbox_workspace_write] network_access = true in ~/.codex/config.toml.'));
+        }
+        if (isJsonMode())
+            return printJson({ crew: pack.crew.name, targets: summary });
+        success(`Installed ${pack.crew.name} for ${targets.join(', ')}`);
+    });
+    crew
+        .command('status [name]')
+        .description('What `wji crew install` wrote, per host, and whether it is still there')
+        .action((name) => {
+        const installed = readInstalled();
+        const names = name ? [name] : Object.keys(installed);
+        const rows = [];
+        for (const n of names) {
+            const rec = installed[n];
+            if (!rec) {
+                warn(`${n}: not installed by wji crew`);
+                continue;
+            }
+            for (const [target, data] of Object.entries(rec.targets)) {
+                for (const p of data?.paths || [])
+                    rows.push({ crew: n, target, path: p, state: pathState(p) });
+            }
+        }
+        render({ installed, rows }, () => {
+            if (!rows.length)
+                return info('Nothing installed by `wji crew`. Try `wji crew install short-drama --for claude`.');
+            for (const n of names) {
+                const rec = installed[n];
+                if (!rec)
+                    continue;
+                detail([
+                    ['crew', n],
+                    ['source', `${rec.source}${rec.ref ? ` @ ${rec.ref}` : ''}`],
+                    ['installed', rec.installedAt],
+                ]);
+            }
+            info('');
+            table(rows, [
+                { header: 'target', value: (r) => r.target },
+                { header: '', value: (r) => (r.state === 'missing' ? color.red('✗') : r.state === 'link' ? color.dim('↗') : color.green('✓')) },
+                { header: 'path', value: (r) => relOrAbs(r.path) },
+            ]);
+        });
+    });
+    crew
+        .command('uninstall <name>')
+        .description('Remove what `wji crew install` wrote for a crew (only the recorded paths)')
+        .option('--for <targets>', 'comma-separated targets, default all recorded', 'all')
+        .option('-y, --yes', 'skip the confirmation')
+        .action(async (name, opts) => {
+        const installed = readInstalled();
+        const rec = installed[name];
+        if (!rec)
+            throw new Error(`${name} was not installed by wji crew`);
+        const targets = parseTargets(opts.for).filter((t) => rec.targets[t]);
+        const paths = targets.flatMap((t) => rec.targets[t]?.paths || []);
+        if (!paths.length)
+            return info('Nothing to remove');
+        for (const p of paths)
+            info(`  rm ${relOrAbs(p)}`);
+        if (!(await confirm(`Remove ${paths.length} path(s)?`, opts.yes)))
+            return info('Aborted');
+        uninstallPaths(paths);
+        for (const t of targets)
+            delete rec.targets[t];
+        if (!Object.keys(rec.targets).length)
+            delete installed[name];
+        writeInstalled(installed);
+        if (targets.includes('openclaw'))
+            warn('openclaw: remove the agents.entries / bindings you merged into ~/.openclaw/openclaw.json, and `openclaw agents delete <seat>` for each seat.');
+        success(`Removed ${paths.length} path(s)`);
+    });
+    crew
+        .command('check <dir>')
+        .description('Validate a local crew pack (crew.json, agents/*.md, skills/*/SKILL.md, links)')
+        .action((dir) => {
+        const pack = loadPackFromDir(dir);
+        const errors = validatePack(pack);
+        render({ crew: pack.crew.name, agents: Object.keys(pack.agents), skills: [...pack.skills.keys()], errors }, () => {
+            if (errors.length) {
+                for (const e of errors)
+                    info(`  ✗ ${e}`);
+                throw new Error(`${errors.length} problem(s) in ${dir}`);
+            }
+            success(`${pack.crew.name}: ${Object.keys(pack.agents).length} seat(s), ${pack.skills.size} skill(s), all links resolve`);
+        });
+        if (errors.length)
+            process.exitCode = 1;
+    });
+    return crew;
+}