@wji.ai/cli 0.2.0 → 0.4.0

package/README.md

@@ -107,6 +107,7 @@ wji --no-org ws list                 # one-off personal call
 | `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 +162,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
 ```
 
@@ -249,3 +251,29 @@ 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.
+
+## 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/canvas.js

@@ -46,6 +46,22 @@ const INITIAL_CANVAS_CONTENT = {
 const MEDIA_BASE = 250;
 const PLACE_GAP = 80;
 const PENDING = 0;
+/**
+ * The canvas's color tags (nodeColorTags.ts on the web). A node stores only
+ * `content.colorTag {colorId}`; the label is shared per color on the canvas
+ * folder as `content.colorTagNames {<colorId>: label}`. `alias` is the plain
+ * color name the tag reads as, so `--tag red` finds `rose`.
+ */
+const COLOR_TAGS = [
+    { id: 'rose', alias: 'red', hex: '#f43f5e' },
+    { id: 'orange', alias: 'orange', hex: '#f97316' },
+    { id: 'amber', alias: 'yellow', hex: '#eab308' },
+    { id: 'lime', alias: 'green', hex: '#84cc16' },
+    { id: 'teal', alias: 'teal', hex: '#14b8a6' },
+    { id: 'sky', alias: 'blue', hex: '#0ea5e9' },
+    { id: 'violet', alias: 'purple', hex: '#8b5cf6' },
+    { id: 'fuchsia', alias: 'pink', hex: '#d946ef' },
+];
 const idOf = (value) => value == null ? undefined : typeof value === 'string' ? value : value.id;
 function toList(result) {
     return Array.isArray(result) ? result : result?.data || [];
@@ -110,8 +126,62 @@ async function loadCanvas(client, canvasId) {
         edges,
         byId: new Map(nodes.map((n) => [n.id, n])),
         assets,
+        tagNames: parseTagNames(folder.content?.colorTagNames),
     };
 }
+// ── color tags ──────────────────────────────────────────────────────────────
+function parseTagNames(raw) {
+    const out = {};
+    if (!raw || typeof raw !== 'object')
+        return out;
+    for (const { id } of COLOR_TAGS) {
+        const value = raw[id];
+        if (typeof value === 'string' && value.trim())
+            out[id] = value.trim();
+    }
+    return out;
+}
+/** The node's tag with the canvas label (never the node's own legacy `name`, as on the web). */
+function tagOf(canvas, node) {
+    const colorId = node.content.colorTag?.colorId;
+    const tag = COLOR_TAGS.find((t) => t.id === colorId);
+    if (!tag)
+        return undefined;
+    return { color: tag.id, alias: tag.alias, hex: tag.hex, label: canvas.tagNames[tag.id] };
+}
+/**
+ * Colors a `--tag` value means: a color id (`rose`), its plain name (`red`),
+ * or a label (`C01`, case-insensitive), so several colors can match one label.
+ */
+function resolveTagFilter(canvas, values) {
+    const colors = new Set();
+    for (const value of values) {
+        const v = value.trim().toLowerCase();
+        const matched = COLOR_TAGS.filter((t) => t.id === v || t.alias === v || canvas.tagNames[t.id]?.toLowerCase() === v);
+        if (!matched.length) {
+            const known = COLOR_TAGS.map((t) => (canvas.tagNames[t.id] ? `${t.alias} "${canvas.tagNames[t.id]}"` : t.alias));
+            throw new Error(`No color tag "${value}" on canvas "${canvas.name}". Tags: ${known.join(', ')}`);
+        }
+        for (const t of matched)
+            colors.add(t.id);
+    }
+    return colors;
+}
+/** `C0[1-3]` is case-insensitive; `/C0[1-3]$/` keeps exactly the flags given. */
+function parseRegex(value, flag) {
+    const slashed = /^\/(.*)\/([a-z]*)$/s.exec(value);
+    try {
+        return slashed ? new RegExp(slashed[1], slashed[2].replace(/[gy]/g, '')) : new RegExp(value, 'i');
+    }
+    catch (err) {
+        throw new Error(`${flag}: invalid regex ${value} — ${err.message}`);
+    }
+}
+function tagText(tag) {
+    if (!tag)
+        return '';
+    return tag.label ? `${tag.alias} "${tag.label}"` : tag.alias;
+}
 /** The `canvases` folder of every InfiniteCanvas app in a workspace. */
 async function canvasesFolders(client, wsId) {
     const ws = await client.get(`/workspace/list/${wsId}`);
@@ -158,7 +228,9 @@ function describe(canvas, node) {
         id: node.id,
         kind: node.kind,
         name: node.name,
+        tag: tagOf(canvas, node),
         position: node.content.position,
+        size: Number(node.content.width) > 0 && Number(node.content.height) > 0 ? { width: Number(node.content.width), height: Number(node.content.height) } : undefined,
         mode: MEDIA_KINDS.has(node.kind) ? node.content.mode || 'display' : undefined,
         text: TEXT_KINDS.has(node.kind) ? node.content.text ?? '' : undefined,
         assetId: node.file,
@@ -270,6 +342,10 @@ function applyModelDefaults(model, kind, generate, opts) {
 // ── writes ──────────────────────────────────────────────────────────────────
 /** Short side 250, like the canvas; text-ish nodes use a typical card size. */
 function estimateSize(canvas, node) {
+    const w = Number(node.content.width);
+    const h = Number(node.content.height);
+    if (w > 0 && h > 0)
+        return { width: w, height: h };
     if (node.kind === 'dataset')
         return { width: 480, height: 220 };
     if (!MEDIA_KINDS.has(node.kind))
@@ -380,6 +456,7 @@ function nodeTable(rows) {
         { header: 'id', value: (n) => n.id },
         { header: 'kind', value: (n) => (n.mode === 'generate' ? `${n.kind}*` : n.kind) },
         { header: 'name', value: (n) => truncate(n.name, 20) },
+        { header: 'tag', value: (n) => truncate(tagText(n.tag), 16) },
         { header: 'refs', value: (n) => n.references.map((r) => r.label).join(',') },
         { header: 'summary', value: (n) => truncate(summary(n), 64) },
     ]);
@@ -390,7 +467,9 @@ function printNode(n) {
         ['id', n.id],
         ['kind', n.mode ? `${n.kind} (${n.mode})` : n.kind],
         ['name', n.name],
+        ['tag', n.tag && `${tagText(n.tag)} ${color.dim(n.tag.color)}`],
         ['position', n.position && `${Math.round(n.position.x)},${Math.round(n.position.y)}`],
+        ['size', n.size && `${n.size.width}×${n.size.height}`],
         ['text', n.text],
         ['dataset', n.dataset && `${n.dataset.type || 'dataset'} "${n.dataset.name || ''}" ${color.dim(n.dataset.id)}${n.dataset.folder ? ` in ${n.dataset.folder}` : ''}`],
         ['asset', n.assetId],
@@ -420,6 +499,46 @@ async function literalOrFile(value, file) {
         return undefined;
     return value === '-' ? readValue('-') : value;
 }
+/**
+ * Text, title and comment nodes are Markdown on the web (a single line break joins the lines into
+ * one paragraph). `--plain` keeps plain text as written: a line break becomes a Markdown hard break
+ * ("  \n"); blank lines stay paragraph breaks and fenced code blocks are left alone.
+ */
+export function plainToMarkdown(text) {
+    let fenced = false;
+    const lines = text.replace(/\r\n?/g, '\n').split('\n');
+    return lines
+        .map((line, i) => {
+        const fence = /^\s*(```|~~~)/.test(line);
+        if (fence)
+            fenced = !fenced;
+        const next = lines[i + 1];
+        const hard = !fence && !fenced && i < lines.length - 1 && line.trim() !== '' && next !== undefined && next.trim() !== '' && !/^\s*(```|~~~)/.test(next);
+        return hard ? `${line.replace(/\s+$/, '')}  ` : line;
+    })
+        .join('\n');
+}
+/** True when a single line break would be joined away by the web's Markdown rendering. */
+export function hasSoftBreaks(text) {
+    return /[^\s\n][ \t]?\n(?![ \t]*\n)[ \t]*\S/.test(text.replace(/\r\n?/g, '\n').replace(/ {2,}\n/g, '\n\n'));
+}
+async function nodeText(kind, opts) {
+    const text = await literalOrFile(opts.text, opts.textFile);
+    if (text === undefined)
+        return undefined;
+    if (opts.plain)
+        return plainToMarkdown(text);
+    if (TEXT_KINDS.has(kind) && hasSoftBreaks(text) && !isJsonMode()) {
+        warn('text nodes render as Markdown on the web — single line breaks join into one paragraph; pass --plain to keep them');
+    }
+    return text;
+}
+function parseSize(value) {
+    const [width, height] = value.split(/[,x×]/i).map((v) => Number(v.trim()));
+    if (!(width > 0 && height > 0))
+        throw new Error('--size must look like width,height (e.g. 600,900)');
+    return { width: Math.round(width), height: Math.round(height) };
+}
 function parsePoint(value, label) {
     const [x, y] = value.split(',').map((v) => Number(v.trim()));
     if (!Number.isFinite(x) || !Number.isFinite(y))
@@ -684,15 +803,53 @@ export function canvasCommand(globals) {
         .description('Nodes with references and a content summary (* = generate node)')
         .option('-c, --canvas <id>', 'canvas id (defaults to the linked canvas)')
         .option('-k, --kind <kind>', 'only this kind')
+        .option('--tag <tags...>', 'only nodes with one of these color tags: label (C01), color (red) or id (rose)')
+        .option('--untagged', 'only nodes without a color tag')
+        .option('-n, --name <regex>', 'only nodes whose name matches this regex (case-insensitive; /re/flags for your own flags)')
         .action(async (opts) => {
+        if (opts.tag && opts.untagged)
+            throw new Error('Pass --tag or --untagged, not both');
+        const nameRe = opts.name !== undefined ? parseRegex(opts.name, '--name') : undefined;
         const c = client();
         const cv = await loadCanvas(c, await resolveCanvasId(c, opts.canvas));
-        const rows = cv.nodes.filter((n) => !opts.kind || n.kind === opts.kind).map((n) => describe(cv, n));
+        const colors = opts.tag ? resolveTagFilter(cv, opts.tag) : undefined;
+        const rows = cv.nodes
+            .filter((n) => !opts.kind || n.kind === opts.kind)
+            .filter((n) => !nameRe || nameRe.test(n.name))
+            .map((n) => describe(cv, n))
+            .filter((n) => (colors ? !!n.tag && colors.has(n.tag.color) : opts.untagged ? !n.tag : true));
         render({ canvas: { id: cv.id, name: cv.name, workspaceId: cv.workspaceId }, nodes: rows }, () => {
             info(color.dim(`${cv.name} (${cv.id}) · ${rows.length} node(s) · ${cv.edges.length} edge(s)`));
             nodeTable(rows);
         });
     });
+    canvas
+        .command('tags')
+        .description('The canvas color tags: color, label and how many nodes carry each')
+        .option('-c, --canvas <id>', 'canvas id (defaults to the linked canvas)')
+        .option('-a, --all', 'also colors no node uses and that have no label')
+        .action(async (opts) => {
+        const c = client();
+        const cv = await loadCanvas(c, await resolveCanvasId(c, opts.canvas));
+        const rows = COLOR_TAGS.map((t) => ({
+            color: t.id,
+            alias: t.alias,
+            hex: t.hex,
+            label: cv.tagNames[t.id],
+            nodes: cv.nodes.filter((n) => n.content.colorTag?.colorId === t.id).length,
+        })).filter((r) => opts.all || r.nodes || r.label);
+        render({ canvas: { id: cv.id, name: cv.name }, tags: rows }, () => {
+            info(color.dim(`${cv.name} (${cv.id})`));
+            if (!rows.length)
+                return info('No color tags on this canvas (--all lists the colors)');
+            table(rows, [
+                { header: 'color', value: (r) => r.alias },
+                { header: 'id', value: (r) => color.dim(r.color) },
+                { header: 'label', value: (r) => r.label || '' },
+                { header: 'nodes', value: (r) => String(r.nodes) },
+            ]);
+        });
+    });
     canvas
         .command('get <nodeId>')
         .description('One node in full, with its references')
@@ -726,6 +883,8 @@ export function canvasCommand(globals) {
         .option('-n, --name <name>', 'node name')
         .option('-t, --text <text>', 'text for text/title/comment (- reads stdin)')
         .option('--text-file <path>', 'read the text from a file')
+        .option('--plain', 'text is plain, not Markdown: keep every line break (the web renders text nodes as Markdown)')
+        .option('--size <w,h>', 'node width and height in canvas pixels (e.g. 600,900)')
         .option('--asset <assetId>', 'show an existing asset (display node)')
         .option('--dataset <fsnodeId>', 'for `add dataset`: the workspace dataset node to show on the canvas')
         .option('--from <nodeIds...>', 'connect these nodes in as references, in order (@image1, @image2…)')
@@ -746,7 +905,7 @@ export function canvasCommand(globals) {
         };
         let model;
         if (TEXT_KINDS.has(kind)) {
-            const text = await literalOrFile(opts.text, opts.textFile);
+            const text = await nodeText(kind, opts);
             if (text === undefined)
                 throw new Error(`${kind} nodes need --text`);
             content.text = text;
@@ -792,6 +951,8 @@ export function canvasCommand(globals) {
                 content.generate = applyModelDefaults(model, kind, patch, { workspaceRatio: ws.aspectRatio, explicit });
             }
         }
+        if (opts.size)
+            Object.assign(content, parseSize(opts.size));
         if (opts.at)
             content.position = parsePoint(opts.at, '--at');
         else {
@@ -822,7 +983,9 @@ export function canvasCommand(globals) {
         .option('-n, --name <name>', 'rename')
         .option('-t, --text <text>', 'replace the text of a text/title/comment node (- reads stdin)')
         .option('--text-file <path>', 'read the text from a file')
-        .option('--move <x,y>', 'move to this position')).action(async (id, opts) => {
+        .option('--plain', 'text is plain, not Markdown: keep every line break')
+        .option('--move <x,y>', 'move to this position')
+        .option('--size <w,h>', 'resize: width and height in canvas pixels')).action(async (id, opts) => {
         const c = client();
         const cv = await loadCanvas(c, await resolveCanvasId(c, opts.canvas));
         const node = requireNode(cv, id);
@@ -831,7 +994,7 @@ export function canvasCommand(globals) {
         let changed = false;
         if (opts.name !== undefined)
             (body.name = opts.name), (changed = true);
-        const text = await literalOrFile(opts.text, opts.textFile);
+        const text = await nodeText(node.kind, opts);
         if (text !== undefined) {
             if (!TEXT_KINDS.has(node.kind))
                 throw new Error(`${node.kind} nodes have no text`);
@@ -840,6 +1003,8 @@ export function canvasCommand(globals) {
         }
         if (opts.move)
             (content.position = parsePoint(opts.move, '--move')), (changed = true);
+        if (opts.size)
+            Object.assign(content, parseSize(opts.size)), (changed = true);
         const { patch, explicit } = await generateOptions(opts);
         if (Object.keys(patch).length) {
             if (!MEDIA_KINDS.has(node.kind))

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;
+}

package/dist/core/archive.js

@@ -0,0 +1,95 @@
+import { gunzipSync, inflateRawSync } from 'node:zlib';
+/**
+ * Minimal archive readers — enough to open a GitHub source tarball
+ * (`codeload.github.com/.../tar.gz/...`) and a plain zip, without a dependency.
+ * Both return forward-slash paths → file contents; directories are dropped.
+ */
+/** ustar / GNU tar, gzipped. Handles GNU long names (`L`) and skips pax headers. */
+export function readTarGz(buffer) {
+    const tar = gunzipSync(buffer);
+    const files = new Map();
+    let offset = 0;
+    let longName;
+    const field = (start, len) => tar.subarray(offset + start, offset + start + len).toString('utf8').replace(/\0.*$/s, '');
+    while (offset + 512 <= tar.length) {
+        const header = tar.subarray(offset, offset + 512);
+        if (header.every((b) => b === 0))
+            break;
+        const size = parseInt(field(124, 12).trim() || '0', 8);
+        const type = field(156, 1);
+        const prefix = field(345, 155);
+        let name = field(0, 100);
+        if (prefix)
+            name = `${prefix}/${name}`;
+        if (longName)
+            (name = longName), (longName = undefined);
+        const body = tar.subarray(offset + 512, offset + 512 + size);
+        offset += 512 + Math.ceil(size / 512) * 512;
+        if (type === 'L') {
+            longName = body.toString('utf8').replace(/\0.*$/s, '');
+            continue;
+        }
+        if (type === 'x' || type === 'g' || type === '5')
+            continue; // pax headers, directories
+        if (/(^|\/)\._[^/]*$/.test(name))
+            continue; // AppleDouble metadata from macOS tar
+        if (type === '0' || type === '' || type === '\0')
+            files.set(name, Buffer.from(body));
+    }
+    return files;
+}
+/** Zip with stored or deflated entries, read from the central directory. */
+export function readZip(buffer) {
+    const files = new Map();
+    // End of central directory record: signature 0x06054b50, search backwards (comment ≤ 64 KiB)
+    let eocd = -1;
+    for (let i = buffer.length - 22; i >= Math.max(0, buffer.length - 65558); i--) {
+        if (buffer.readUInt32LE(i) === 0x06054b50) {
+            eocd = i;
+            break;
+        }
+    }
+    if (eocd < 0)
+        throw new Error('Not a zip file (no central directory)');
+    const count = buffer.readUInt16LE(eocd + 10);
+    let p = buffer.readUInt32LE(eocd + 16);
+    for (let n = 0; n < count; n++) {
+        if (buffer.readUInt32LE(p) !== 0x02014b50)
+            throw new Error('Corrupt zip central directory');
+        const method = buffer.readUInt16LE(p + 10);
+        const compressed = buffer.readUInt32LE(p + 20);
+        const nameLen = buffer.readUInt16LE(p + 28);
+        const extraLen = buffer.readUInt16LE(p + 30);
+        const commentLen = buffer.readUInt16LE(p + 32);
+        const localOffset = buffer.readUInt32LE(p + 42);
+        const name = buffer.subarray(p + 46, p + 46 + nameLen).toString('utf8');
+        p += 46 + nameLen + extraLen + commentLen;
+        if (name.endsWith('/') || /(^|\/)\._[^/]*$/.test(name) || name.startsWith('__MACOSX/'))
+            continue;
+        // local header: 30 bytes + name + extra (the local extra length can differ from the central one)
+        const lNameLen = buffer.readUInt16LE(localOffset + 26);
+        const lExtraLen = buffer.readUInt16LE(localOffset + 28);
+        const start = localOffset + 30 + lNameLen + lExtraLen;
+        const data = buffer.subarray(start, start + compressed);
+        if (method === 0)
+            files.set(name, Buffer.from(data));
+        else if (method === 8)
+            files.set(name, inflateRawSync(data));
+        else
+            throw new Error(`Unsupported zip compression method ${method} for ${name}`);
+    }
+    return files;
+}
+/**
+ * Source archives wrap everything in one top-level folder (`repo-ref/…`,
+ * `short-drama-crew-export/…`). Strip it when every path shares it.
+ */
+export function stripCommonRoot(files) {
+    const roots = new Set([...files.keys()].map((p) => p.split('/')[0]));
+    if (roots.size !== 1 || ![...files.keys()].every((p) => p.includes('/')))
+        return files;
+    const out = new Map();
+    for (const [path, content] of files)
+        out.set(path.slice(path.indexOf('/') + 1), content);
+    return out;
+}