@wji.ai/cli 0.3.0 → 0.5.0

package/README.md

@@ -96,17 +96,21 @@ wji --no-org ws list                 # one-off personal call
 | `wji auth` | login / signup / token / whoami / refresh / logout, `auth key` for API keys |
 | `wji config` | profiles, endpoint, defaults |
 | `wji org` | organization context, members |
-| `wji ws` | workspaces, apps, members, quota, stats, templates |
+| `wji ws` | workspaces, apps, members and invitations (email, share link), quota, stats, templates |
 | `wji fs` | fsnode tree: ls, tree, get, mkdir, touch, set, describe, rm, sort, batch |
 | `wji dataset` | dataset nodes (character / location / prop / …) and dataset records |
 | `wji asset` | upload, import from URL, search, status, download, summary |
-| `wji canvas` | Infinite Canvas: linked canvas + selection, nodes, references, generate nodes, submit |
+| `wji canvas` | Infinite Canvas: linked canvas + selection, nodes, references, generate nodes, submit, owners, color tags, copy between canvases |
+| `wji class` | teach with a workspace: roster, one canvas per student, copy nodes to every student, progress, collect results |
+| `wji npc` | NPC City NPCs you own: profile, publish, work history (jobs), soul, character document, transfers |
+| `wji backreel` | Backreel posts: drafts, publish, cast and crew credits (NPCs included) |
 | `wji gen` | `image` / `video` / `audio` generation plus `cost` estimation |
 | `wji history` | generation history: search, poll, bookmark, download |
 | `wji models` | list models and their form parameters |
 | `wji agent` | browse and manage AI agents |
 | `wji preset` | prompt presets: yours, public, workspace; fork and copy |
 | `wji skill` | agent skills: system list, push/pull SKILL.md bundles, import zip, update, rm |
+| `wji crew` | install crew packs (skills + agent seats) into Claude Code, Codex, OpenClaw, or export for Grok bot |
 | `wji profile` | account profile, password, wallet, login history |
 
 Run `wji <group> --help` for the full option list.
@@ -161,6 +165,7 @@ wji canvas status                                   # what is linked and selecte
 wji canvas add video --from <img1> <img2> -m seedance-2.0-fast-ref -r 16:9 -d 8 \
   -p "@image1 paddles across the lake while @image2 waits on the shore"
 wji canvas set <node> --resolution 720p --set seed=42
+wji canvas add text --text-file prompt.txt --plain --size 600,900   # text nodes are Markdown; --plain keeps line breaks
 wji canvas gen <node> --yes --wait                  # spends credits
 ```
 
@@ -169,6 +174,44 @@ canvas that is not linked (`wji canvas list`); `wji canvas create <name>` adds
 an empty canvas, `wji canvas add image --asset <id>` shows an existing asset
 and `wji canvas add dataset --dataset <id>` places a dataset card.
 
+## Classes (`wji class`)
+
+A workspace you own can be a class: students are members, each with a
+private canvas of their own.
+
+```bash
+wji ws create "Art 101" -a canvas && wji ws use <id>
+wji ws member invite alice@school.edu bob@school.edu    # registered users join at once
+wji ws member link                                      # or share a join link (replaces the old one)
+wji class canvases --create                             # one private canvas per student
+wji canvas tag red <nodeIds…> -l HW1                    # mark the assignment on your canvas
+wji class copy --selected -y                            # copy your selected nodes to every student
+wji class status --tag HW1 --sort progress              # who is done, running, failed, not started
+wji class results --tag HW1 -d ./hw1                    # collect finished work, one folder per student
+```
+
+Workspace prompt presets (`wji preset create <name> -p … -w <id>`) show up for
+students when they press `/` on the canvas. The `wji-classroom` skill walks an
+agent through the whole flow.
+
+## NPC City and Backreel
+
+```bash
+wji npc list                                               # your NPCs (org ones with --org)
+wji npc create "Mika" --role Singer --genre "City pop" --handle mika.npc
+wji npc job add @mika -t concert --title "Neon Night" --date 2026-10-01
+wji npc doc export @mika -o mika.md                        # edit, then:
+wji npc doc apply @mika @mika.md --dry-run
+wji npc publish @mika
+
+wji backreel create "Harbour" -d @synopsis.txt --cover <assetId>
+wji backreel credit add <postId> --npc @mika --role "飾 阿明" --job appearance
+wji backreel publish <postId>
+```
+
+Creating NPCs needs NPC City spawn permission on your account. Admin actions
+(spawn permission, featured slots, moderation) are not part of `wji`.
+
 ## Skills
 
 Skills are SKILL.md bundles (markdown only — scripts don't persist server-side).
@@ -249,3 +292,34 @@ stages are checked by `skill/short-drama/scripts/short-drama.mjs validate`,
 with the data stored as workspace datasets and the work laid out on canvases.
 Install it the same way (`cp -r skill/short-drama ~/.claude/skills/short-drama`)
 next to `wji`; `node skill/short-drama/scripts/selftest.mjs` runs its self-test.
+
+`skill/wji-classroom/` is a teacher's skill on top of `wji`: set up a class
+workspace, invite students, give each a canvas, hand out prompts and starter
+nodes, and check or collect their work. Install it the same way
+(`cp -r skill/wji-classroom ~/.claude/skills/wji-classroom`).
+
+## Crews (`wji crew`)
+
+A **crew pack** is a repository of Agent Skills plus agent seats (`crew.json` +
+`agents/<seat>.md`) — the multi-agent form of a pipeline. `wji crew install`
+puts one where each host discovers it, writing that host's agent format from
+the same persona files:
+
+```bash
+wji crew install short-drama --for claude        # ~/.claude/skills + ~/.claude/agents/<seat>.md
+wji crew install short-drama --for codex         # ~/.agents/skills + ~/.codex/agents/<seat>.toml
+wji crew install short-drama --for openclaw      # ~/.agents/skills + ~/.openclaw/workspaces/<crew>/<seat>/{AGENTS,SOUL}.md
+wji crew install short-drama --for grok          # ./<crew>-export.zip in the Grok bot import layout
+wji crew install short-drama --for all --dry-run # show the plan only
+wji crew install --from ../short-drama-crew --for claude --link   # symlink a local checkout
+wji crew status                                  # what was written, and whether it is still there
+wji crew uninstall short-drama-crew --for codex  # remove exactly the recorded paths
+wji crew check ./short-drama-crew                # validate a pack before publishing it
+```
+
+Known crews: `short-drama` ([ultra-instinct-ai/short-drama-crew](https://github.com/ultra-instinct-ai/short-drama-crew)).
+`--from` also takes a `.zip`, a `.tar.gz` or a URL; `--ref` picks a branch or tag;
+`--project <dir>` installs into a project instead of your home directory. The
+installer never edits `~/.openclaw/openclaw.json` — it writes a JSON5 fragment
+to merge — and it warns that the Codex `wji-operator` seat needs
+`[sandbox_workspace_write] network_access = true`.

package/dist/commands/backreel.js

@@ -0,0 +1,260 @@
+import { Command } from 'commander';
+import { WjiClient } from '../core/client.js';
+import { confirm, readJson, readValue } from '../core/prompt.js';
+import { color, detail, info, render, relativeTime, success, table, truncate } from '../core/output.js';
+import { NPC_JOB_TYPES, npcLabel, parseJob, parsePositions, resolveNpc, today, updateJobs } from '../core/npc.js';
+const POSTS = '/backreel/post';
+const KINDS = ['showcase', 'crowdfunding'];
+const PROJECT_STATUSES = ['planning', 'pre_production', 'in_production', 'post_production', 'completed'];
+const CREDIT_KINDS = ['creative', 'crew', 'cast'];
+/** Credit fields the create / update DTO accepts; the rest of a read-back credit is dropped. */
+const CREDIT_FIELDS = ['kind', 'name', 'role', 'user', 'photo', 'avatarUrl', 'link', 'source', 'npcId', 'order'];
+export function backreelCommand(globals) {
+    const br = new Command('backreel')
+        .aliases(['br'])
+        .description('Manage your Backreel posts (works) and their credits, including NPC cast');
+    br.command('list', { isDefault: true })
+        .description('Your posts, drafts included; --all for everyone\'s published posts')
+        .option('--all', 'search all published posts instead of yours')
+        .option('-k, --keyword <text>', 'search text')
+        .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(`${POSTS}/${opts.all ? 'search' : 'search/my'}`, {
+            keyword: opts.keyword,
+            page: Number(opts.page),
+            limit: Number(opts.limit),
+        });
+        render(result, (r) => {
+            table(r?.data || [], [
+                { header: 'id', value: (p) => p.id },
+                { header: 'title', value: (p) => truncate(p.title, 28) },
+                { header: 'kind', value: (p) => p.kind },
+                { header: 'publish', value: (p) => p.publishStatus },
+                { header: 'project', value: (p) => p.projectStatus },
+                { header: 'credits', value: (p) => (p.credits || []).length },
+                { header: 'updated', value: (p) => relativeTime(p.updatedAt) },
+            ]);
+            const p = r?.pagination;
+            if (p)
+                info(color.dim(`${p.total} total · page ${p.page}${p.hasNext ? ` · more: --page ${p.page + 1}` : ''}`));
+        });
+    });
+    br.command('get <postId>')
+        .description('Show a post and its credits')
+        .action(async (id) => {
+        const client = new WjiClient(globals());
+        const post = await client.getFresh(`${POSTS}/list/${id}`);
+        render(post, () => printPost(post));
+    });
+    postOptions(br.command('create <title>').description('Create a post (always a draft until `backreel publish`)')).action(async (title, opts) => {
+        const client = new WjiClient(globals());
+        // The create DTO validates kind and description although the entity has defaults.
+        const body = { kind: 'showcase', description: '', ...(await postBody(opts)), title };
+        const created = await client.post(`${POSTS}/create`, body);
+        render(created, (p) => success(`Created draft "${p.title}" — ${p.id}`));
+    });
+    postOptions(br.command('set <postId>')
+        .description('Update a post; only the fields you pass change')
+        .option('--title <text>', 'title')).action(async (id, opts) => {
+        const client = new WjiClient(globals());
+        const body = await postBody(opts);
+        if (opts.title)
+            body.title = opts.title;
+        if (!Object.keys(body).length)
+            throw new Error('Nothing to change — pass at least one field flag');
+        const updated = await client.put(`${POSTS}/list/${id}`, body);
+        render(updated, () => success(`Updated "${updated.title}": ${Object.keys(body).join(', ')}`));
+    });
+    for (const action of ['publish', 'unpublish']) {
+        br.command(`${action} <postId>`)
+            .description(action === 'publish' ? 'Publish a post' : 'Take a post offline')
+            .action(async (id) => {
+            const client = new WjiClient(globals());
+            const post = await client.post(`${POSTS}/list/${id}/${action}`);
+            render(post, (p) => success(`"${p.title}" is now ${p.publishStatus}`));
+        });
+    }
+    br.command('rm <postId>')
+        .description('Delete a post')
+        .option('-y, --yes', 'skip confirmation')
+        .action(async (id, opts) => {
+        const client = new WjiClient(globals());
+        const post = await client.getFresh(`${POSTS}/list/${id}`);
+        if (!(await confirm(`Delete post "${post.title}" (${id})?`, opts.yes)))
+            return info('Aborted');
+        const result = await client.delete(`${POSTS}/list/${id}`);
+        render(result, () => success(`Deleted "${post.title}"`));
+    });
+    // ── credits ────────────────────────────────────────────────────────────
+    const credit = br.command('credit').aliases(['credits']).description('Cast and crew of a post (max 30)');
+    credit
+        .command('list <postId>', { isDefault: true })
+        .description('Numbered credits')
+        .action(async (id) => {
+        const client = new WjiClient(globals());
+        const post = await client.getFresh(`${POSTS}/list/${id}`);
+        render(post.credits || [], (credits) => printCredits(credits));
+    });
+    credit
+        .command('add <postId>')
+        .description('Add a credit; --npc casts one of your NPCs')
+        .option('--name <name>', 'display name (defaults to the NPC or user name)')
+        .requiredOption('--role <role>', 'job or character, e.g. 導演 or 飾 阿明')
+        .option('--kind <kind>', CREDIT_KINDS.join(' | '), 'cast')
+        .option('--npc <npc>', 'link an NPC City NPC (id, @handle or name)')
+        .option('--user <userId>', 'link a WJI user (their name and avatar win)')
+        .option('--link <url>', 'profile link')
+        .option('--job <type>', `also add a work-history job to the NPC: ${NPC_JOB_TYPES.join(' | ')}`)
+        .action(async (id, opts) => {
+        if (!CREDIT_KINDS.includes(opts.kind))
+            throw new Error(`--kind must be one of ${CREDIT_KINDS.join(', ')}`);
+        if (opts.job && !opts.npc)
+            throw new Error('--job needs --npc');
+        if (opts.job && !NPC_JOB_TYPES.includes(opts.job)) {
+            throw new Error(`--job must be one of ${NPC_JOB_TYPES.join(', ')}`);
+        }
+        const client = new WjiClient(globals());
+        const npc = opts.npc ? await resolveNpc(client, opts.npc) : undefined;
+        // Any public NPC can be credited, but only your own gets a job. The soul
+        // route is owner-only, so it checks that before anything is written.
+        if (npc && opts.job) {
+            await client.get(`/npc-city/residents/${npc.id}/soul`).catch(() => {
+                throw new Error(`${npcLabel(npc)} is not yours, so --job can't add to its work history (the credit alone works without --job)`);
+            });
+        }
+        const name = opts.name || npc?.name;
+        if (!name && !opts.user)
+            throw new Error('Pass --name, --npc or --user');
+        const entry = { kind: opts.kind, name: name || '-', role: opts.role };
+        if (opts.user)
+            entry.user = opts.user;
+        if (opts.link)
+            entry.link = opts.link;
+        if (npc) {
+            entry.npcId = npc.id;
+            if (npc.image)
+                entry.avatarUrl = npc.image;
+        }
+        const post = await updateCredits(client, id, (credits) => [...credits, entry]);
+        // The job is written after the credit, dated today and titled after the post.
+        let job;
+        if (npc && opts.job) {
+            job = parseJob({ type: opts.job, title: post.title, detail: opts.role, date: today() });
+            await updateJobs(client, npc.id, (jobs) => [...jobs, job]);
+        }
+        render({ post: post.id, credits: post.credits, job: job ?? null }, () => {
+            success(`Credited ${name || opts.user} as ${opts.role} on "${post.title}" (#${post.credits.length})`);
+            if (job)
+                success(`Added ${job.type} "${job.title}" to ${npcLabel(npc)}'s work history`);
+        });
+    });
+    credit
+        .command('rm <postId> <n...>')
+        .description('Remove credits by number')
+        .option('-y, --yes', 'skip confirmation')
+        .action(async (id, ns, opts) => {
+        const client = new WjiClient(globals());
+        const post = await client.getFresh(`${POSTS}/list/${id}`);
+        const credits = post.credits || [];
+        const positions = parsePositions(ns, credits.length);
+        const names = positions.map((i) => `#${i + 1} ${credits[i].name}`).join(', ');
+        if (!(await confirm(`Remove ${names} from "${post.title}"?`, opts.yes)))
+            return info('Aborted');
+        const updated = await updateCredits(client, id, (current) => {
+            if (JSON.stringify(current) !== JSON.stringify(credits.map(toCreditDto))) {
+                throw new Error('The credits changed since they were read — list them again and retry');
+            }
+            return current.filter((_, i) => !positions.includes(i));
+        });
+        render(updated.credits, () => success(`Removed ${positions.length} credit(s); ${updated.credits.length} left`));
+    });
+    return br;
+}
+// ── helpers ──────────────────────────────────────────────────────────────
+function postOptions(cmd) {
+    return cmd
+        .option('--kind <kind>', KINDS.join(' | '))
+        .option('--category <category>', 'category')
+        .option('--project-status <status>', PROJECT_STATUSES.join(' | '))
+        .option('--tags <tags>', 'comma-separated tags (replaces the list)')
+        .option('-d, --description <text>', 'description, plain text or HTML (@file / - supported)')
+        .option('--cover <assetId>', 'landscape cover asset')
+        .option('--cover-portrait <assetId>', 'portrait cover asset')
+        .option('--trailer <assetId>', 'trailer video asset')
+        .option('--body <json>', 'any other post fields as JSON (@file / - supported); flags win');
+}
+async function postBody(opts) {
+    const body = { ...((await readJson(opts.body)) || {}) };
+    if (opts.kind)
+        body.kind = oneOf(opts.kind, KINDS, '--kind');
+    if (opts.category)
+        body.category = opts.category;
+    if (opts.projectStatus)
+        body.projectStatus = oneOf(opts.projectStatus, PROJECT_STATUSES, '--project-status');
+    if (opts.tags !== undefined)
+        body.tags = String(opts.tags).split(',').map((t) => t.trim()).filter(Boolean);
+    if (opts.description !== undefined)
+        body.description = toHtml(await readValue(opts.description));
+    if (opts.cover)
+        body.cover = opts.cover;
+    if (opts.coverPortrait)
+        body.coverPortrait = opts.coverPortrait;
+    if (opts.trailer)
+        body.trailer = opts.trailer;
+    return body;
+}
+/** Descriptions are stored as sanitized HTML; plain text becomes paragraphs. */
+function toHtml(text) {
+    if (/<\/?(p|br|h[1-6]|ul|ol|li|strong|em|b|i|u|s|a|blockquote|div|span|img|hr)\b[^>]*>/i.test(text))
+        return text;
+    const escape = (s) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+    return text
+        .trim()
+        .split(/\n{2,}/)
+        .map((para) => `<p>${escape(para).replace(/\n/g, '<br>')}</p>`)
+        .join('');
+}
+const toCreditDto = (c) => Object.fromEntries(CREDIT_FIELDS.filter((k) => c[k] !== undefined && c[k] !== null).map((k) => [k, c[k]]));
+/** Credits have no ids: read fresh, change, write the whole array back in order. */
+async function updateCredits(client, id, fn) {
+    const post = await client.getFresh(`${POSTS}/list/${id}`);
+    const next = fn((post.credits || []).map(toCreditDto)).map((c, i) => ({ ...c, order: i }));
+    if (next.length > 30)
+        throw new Error('A post can have at most 30 credits');
+    return client.put(`${POSTS}/list/${id}`, { credits: next });
+}
+function oneOf(value, allowed, flag) {
+    if (!allowed.includes(value))
+        throw new Error(`${flag} must be one of ${allowed.join(', ')}`);
+    return value;
+}
+function printPost(p) {
+    detail([
+        ['id', p.id],
+        ['title', p.title],
+        ['kind', p.kind],
+        ['publish', p.publishStatus],
+        ['project', p.projectStatus],
+        ['category', p.category],
+        ['tags', (p.tags || []).join(', ')],
+        ['description', truncate(p.descriptionText || p.description, 120)],
+        ['cover', p.cover?.url || p.cover?.id || p.cover],
+        ['creator', p.creator?.name],
+        ['likes', p.likeCount],
+        ['updated', relativeTime(p.updatedAt)],
+    ]);
+    process.stdout.write('\n');
+    printCredits(p.credits || []);
+}
+function printCredits(credits) {
+    table(credits.map((c, i) => ({ ...c, n: i + 1 })), [
+        { header: '#', value: (c) => c.n },
+        { header: 'kind', value: (c) => c.kind },
+        { header: 'name', value: (c) => truncate(c.name, 20) },
+        { header: 'role', value: (c) => truncate(c.role, 24) },
+        { header: 'source', value: (c) => c.source },
+        { header: 'npc / user', value: (c) => c.npcId || c.user },
+    ]);
+}