@wji.ai/cli 0.6.1 → 0.7.1

package/dist/core/crew.js

@@ -1,546 +0,0 @@
-import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, readlinkSync, rmSync, statSync, symlinkSync, writeFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { configDir } from './config.js';
-import { createZip } from './zip.js';
-import { readTarGz, readZip, stripCommonRoot } from './archive.js';
-/**
- * A crew pack is a folder (or archive of one) shaped like:
- *
- *   crew.json            roles, skill allowlists, capabilities, delegation, channels
- *   agents/<slug>.md     one persona per seat: Claude-agent frontmatter + body
- *   skills/<name>/…      Agent Skills (SKILL.md + reference/ + scripts/ …)
- *   AGENTS.md            shared operating rules (optional)
- *
- * `wji crew install` copies the skills where each host discovers them and
- * writes each host's agent format from the same persona files.
- */
-export const TARGETS = ['claude', 'codex', 'openclaw', 'grok'];
-/** Where a named crew is fetched from when no --from is given. */
-export const CREW_REGISTRY = {
-    'short-drama': { repo: 'ultra-instinct-ai/short-drama-crew', defaultRef: 'main' },
-};
-// ── frontmatter ─────────────────────────────────────────────────────────────
-/** The YAML subset the persona files use: `key: value`, `key:` + `  - item` lists, `>-` folded blocks. */
-export function parseFrontmatter(raw) {
-    const m = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(raw);
-    if (!m)
-        return { frontmatter: {}, body: raw };
-    const fm = {};
-    const lines = m[1].split(/\r?\n/);
-    let key;
-    let folded = false;
-    for (const line of lines) {
-        const top = /^([A-Za-z][\w-]*):\s*(.*)$/.exec(line);
-        if (top && !/^\s/.test(line)) {
-            key = top[1];
-            const value = top[2].trim();
-            if (value === '>-' || value === '>' || value === '|' || value === '|-') {
-                fm[key] = '';
-                folded = true;
-            }
-            else if (value === '') {
-                fm[key] = [];
-                folded = false;
-            }
-            else {
-                fm[key] = value.replace(/^["'](.*)["']$/, '$1');
-                folded = false;
-            }
-            continue;
-        }
-        if (!key)
-            continue;
-        const item = /^\s+-\s+(.*)$/.exec(line);
-        if (item && Array.isArray(fm[key]))
-            fm[key].push(item[1].trim());
-        else if (folded && typeof fm[key] === 'string')
-            fm[key] = `${fm[key]}${fm[key] ? ' ' : ''}${line.trim()}`;
-    }
-    return { frontmatter: fm, body: raw.slice(m[0].length).replace(/^\s*\n/, '') };
-}
-const listOf = (v) => Array.isArray(v) ? v : typeof v === 'string' && v ? v.split(',').map((s) => s.trim()).filter(Boolean) : [];
-// ── loading ─────────────────────────────────────────────────────────────────
-function walk(dir, rel = '') {
-    const out = new Map();
-    for (const entry of readdirSync(dir, { withFileTypes: true })) {
-        if (entry.name.startsWith('.') && entry.name !== '.sync-source')
-            continue;
-        const full = join(dir, entry.name);
-        const path = rel ? `${rel}/${entry.name}` : entry.name;
-        if (entry.isDirectory())
-            for (const [p, c] of walk(full, path))
-                out.set(p, c);
-        else if (entry.isFile())
-            out.set(path, readFileSync(full));
-    }
-    return out;
-}
-export function loadPackFromDir(dir, source = dir, ref) {
-    const root = resolve(dir);
-    const manifestPath = join(root, 'crew.json');
-    if (!existsSync(manifestPath))
-        throw new Error(`${dir} is not a crew pack (no crew.json)`);
-    const crew = JSON.parse(readFileSync(manifestPath, 'utf8'));
-    const skillsDir = join(root, crew.skillsDir || 'skills');
-    const skills = new Map();
-    if (existsSync(skillsDir)) {
-        for (const entry of readdirSync(skillsDir, { withFileTypes: true })) {
-            if (!entry.isDirectory() || entry.name.startsWith('.'))
-                continue;
-            skills.set(entry.name, walk(join(skillsDir, entry.name)));
-        }
-    }
-    const agents = {};
-    for (const [slug, spec] of Object.entries(crew.agents || {})) {
-        const file = join(root, spec.prompt);
-        if (!existsSync(file))
-            throw new Error(`crew.json: agent ${slug} points at missing ${spec.prompt}`);
-        const raw = readFileSync(file, 'utf8');
-        const { frontmatter, body } = parseFrontmatter(raw);
-        agents[slug] = { slug, frontmatter, body, raw };
-    }
-    const agentsMdPath = join(root, 'AGENTS.md');
-    return {
-        root,
-        crew,
-        agents,
-        skills,
-        agentsMd: existsSync(agentsMdPath) ? readFileSync(agentsMdPath, 'utf8') : undefined,
-        source,
-        ref,
-    };
-}
-export function crewCacheDir() {
-    return join(configDir(), 'crews');
-}
-function unpackTo(files, dir) {
-    rmSync(dir, { recursive: true, force: true });
-    for (const [path, content] of files) {
-        if (path.includes('..'))
-            continue;
-        const full = join(dir, path);
-        mkdirSync(dirname(full), { recursive: true });
-        writeFileSync(full, content);
-    }
-}
-/**
- * Resolve `--from` (a folder, a .zip / .tar.gz file, or an http(s) URL) or a
- * registry name into a loaded pack. Archives are unpacked into the cache.
- */
-export async function fetchPack(nameOrFrom, opts = {}) {
-    const from = opts.from;
-    if (from && !/^https?:\/\//.test(from)) {
-        const path = resolve(from);
-        if (!existsSync(path))
-            throw new Error(`No such file or directory: ${from}`);
-        if (statSync(path).isDirectory())
-            return loadPackFromDir(path, path);
-        const buffer = readFileSync(path);
-        const files = stripCommonRoot(/\.zip$/i.test(path) ? readZip(buffer) : readTarGz(buffer));
-        const dir = join(crewCacheDir(), basename(path).replace(/\.(zip|tar\.gz|tgz)$/i, ''), 'local');
-        unpackTo(files, dir);
-        return loadPackFromDir(dir, path);
-    }
-    let url = from;
-    let ref = opts.ref;
-    let name = nameOrFrom;
-    if (!url) {
-        const entry = CREW_REGISTRY[nameOrFrom];
-        if (!entry)
-            throw new Error(`Unknown crew "${nameOrFrom}". Known: ${Object.keys(CREW_REGISTRY).join(', ')} — or pass --from <dir|zip|url>.`);
-        ref = ref || entry.defaultRef;
-        const kind = /^v?\d/.test(ref) ? 'tags' : 'heads';
-        url = `https://codeload.github.com/${entry.repo}/tar.gz/refs/${kind}/${ref}`;
-    }
-    else {
-        name = basename(new URL(url).pathname).replace(/\.(zip|tar\.gz|tgz)$/i, '') || nameOrFrom;
-        ref = ref || 'url';
-    }
-    const res = await fetch(url);
-    if (!res.ok)
-        throw new Error(`Download failed: ${res.status} ${res.statusText} — ${url}`);
-    const buffer = Buffer.from(await res.arrayBuffer());
-    const files = stripCommonRoot(/\.zip($|\?)/i.test(url) ? readZip(buffer) : readTarGz(buffer));
-    const dir = join(crewCacheDir(), name, ref);
-    unpackTo(files, dir);
-    return loadPackFromDir(dir, url, ref);
-}
-// ── validation ──────────────────────────────────────────────────────────────
-export function validatePack(pack) {
-    const errors = [];
-    const { crew } = pack;
-    if (!crew.name || !/^[a-z0-9][a-z0-9-]*$/.test(crew.name))
-        errors.push('crew.json: name must be a kebab-case slug');
-    if (!crew.agents || !Object.keys(crew.agents).length)
-        errors.push('crew.json: no agents');
-    for (const [name, files] of pack.skills) {
-        const skill = files.get('SKILL.md');
-        if (!skill) {
-            errors.push(`skills/${name}: no SKILL.md`);
-            continue;
-        }
-        const { frontmatter } = parseFrontmatter(skill.toString('utf8'));
-        if (frontmatter.name !== name)
-            errors.push(`skills/${name}/SKILL.md: name "${frontmatter.name}" must equal the folder name`);
-        const desc = String(frontmatter.description || '');
-        if (!desc)
-            errors.push(`skills/${name}/SKILL.md: description is required`);
-        else if (desc.length > 1024)
-            errors.push(`skills/${name}/SKILL.md: description is ${desc.length} chars (max 1024)`);
-        // relative links must resolve inside the pack
-        const text = skill.toString('utf8');
-        for (const m of text.matchAll(/\]\(((?:\.\.\/|reference\/|scripts\/)[^)#]+)(?:#[^)]*)?\)/g)) {
-            const target = m[1];
-            const parts = target.split('/');
-            const resolved = parts[0] === '..' ? pack.skills.get(parts[1])?.has(parts.slice(2).join('/')) : files.has(target);
-            if (!resolved)
-                errors.push(`skills/${name}/SKILL.md: link ${target} does not resolve`);
-        }
-    }
-    for (const [slug, spec] of Object.entries(crew.agents || {})) {
-        const persona = pack.agents[slug];
-        if (!persona)
-            continue;
-        if (persona.frontmatter.name !== slug)
-            errors.push(`${spec.prompt}: frontmatter name "${persona.frontmatter.name}" must equal the slug ${slug}`);
-        if (!persona.frontmatter.description)
-            errors.push(`${spec.prompt}: description is required`);
-        const fmSkills = listOf(persona.frontmatter.skills).sort().join(',');
-        if (fmSkills !== [...spec.skills].sort().join(','))
-            errors.push(`${spec.prompt}: frontmatter skills [${fmSkills}] differ from crew.json [${spec.skills.join(',')}]`);
-        for (const s of spec.skills)
-            if (!pack.skills.has(s))
-                errors.push(`crew.json: agent ${slug} lists unknown skill ${s}`);
-        for (const d of spec.delegatesTo || [])
-            if (!crew.agents[d])
-                errors.push(`crew.json: agent ${slug} delegates to unknown ${d}`);
-        const tools = listOf(persona.frontmatter.tools);
-        if (!spec.capabilities.write && tools.some((t) => /^(Edit|Write|MultiEdit|NotebookEdit)$/.test(t)))
-            errors.push(`${spec.prompt}: read-only seat lists a write tool`);
-        if (spec.capabilities.spawn && !tools.includes('Agent'))
-            errors.push(`${spec.prompt}: a spawning seat needs the Agent tool`);
-    }
-    for (const [id, ch] of Object.entries(crew.channels || {}))
-        for (const m of ch.members)
-            if (!crew.agents[m])
-                errors.push(`crew.json: channel ${id} has unknown member ${m}`);
-    return errors;
-}
-const home = (o) => o.home || process.env.HOME || homedir();
-export function claudeRoot(o) {
-    return o.project ? join(resolve(o.project), '.claude') : join(home(o), '.claude');
-}
-export function agentsSkillsRoot(o) {
-    return o.project ? join(resolve(o.project), '.agents', 'skills') : join(home(o), '.agents', 'skills');
-}
-export function codexAgentsRoot(o) {
-    return o.project ? join(resolve(o.project), '.codex', 'agents') : join(home(o), '.codex', 'agents');
-}
-export function openclawRoot(pack, o) {
-    return o.project ? join(resolve(o.project), 'openclaw') : join(home(o), '.openclaw', 'workspaces', pack.crew.name);
-}
-function skillOps(pack, root, o, note) {
-    const ops = [];
-    for (const [name, files] of pack.skills) {
-        const path = join(root, name);
-        if (o.link)
-            ops.push({ kind: 'link', path, target: join(pack.root, pack.crew.skillsDir || 'skills', name), note: `${note} skill ${name} (symlink)` });
-        else
-            ops.push({ kind: 'dir', path, files, note: `${note} skill ${name} (${files.size} files)` });
-    }
-    return ops;
-}
-export function planClaude(pack, o) {
-    const root = claudeRoot(o);
-    const ops = skillOps(pack, join(root, 'skills'), o, 'claude');
-    for (const [slug, persona] of Object.entries(pack.agents)) {
-        const path = join(root, 'agents', `${slug}.md`);
-        if (o.link)
-            ops.push({ kind: 'link', path, target: join(pack.root, pack.crew.agents[slug].prompt), note: `claude agent ${slug} (symlink)` });
-        else
-            ops.push({ kind: 'file', path, content: persona.raw, note: `claude agent ${slug}` });
-    }
-    return ops;
-}
-/** Codex `.codex/agents/<slug>.toml` — the persona body becomes developer_instructions. */
-export function codexAgentToml(pack, slug, skillsBase) {
-    const spec = pack.crew.agents[slug];
-    const persona = pack.agents[slug];
-    const q = (s) => JSON.stringify(s);
-    const sandbox = spec.capabilities.write ? 'workspace-write' : 'read-only';
-    const extra = [
-        '',
-        `Skills for this seat live under ${skillsBase}/: ${spec.skills.join(', ')}.`,
-        spec.delegatesTo.length ? `Delegate with spawn_agent to: ${spec.delegatesTo.join(', ')}.` : 'You do not spawn other agents; report back to the seat that assigned you.',
-        spec.capabilities.spend ? 'You may run wji generation commands after the cost has been approved.' : 'You never run wji generation or spend credits.',
-    ].join('\n');
-    const body = `${persona.body.trimEnd()}\n${extra}\n`.replace(/"""/g, '\\"\\"\\"');
-    const lines = [
-        `# GENERATED by \`wji crew install\` from ${pack.crew.name}/agents/${slug}.md — edit the pack, not this file.`,
-        slug === 'wji-operator' || spec.capabilities.network
-            ? `# This seat needs network access: set [sandbox_workspace_write] network_access = true in ~/.codex/config.toml.`
-            : '',
-        `name = ${q(slug)}`,
-        `description = ${q(String(persona.frontmatter.description || spec.name))}`,
-    ];
-    if (spec.model)
-        lines.push(`model = ${q(spec.model)}`);
-    lines.push(`sandbox_mode = ${q(sandbox)}`, `developer_instructions = """`, body, `"""`, '');
-    for (const s of spec.skills)
-        lines.push('[[skills.config]]', `path = ${q(`${skillsBase}/${s}`)}`, 'enabled = true', '');
-    return lines.filter((l) => l !== undefined).join('\n');
-}
-export function planCodex(pack, o) {
-    const skillsRoot = agentsSkillsRoot(o);
-    const ops = skillOps(pack, skillsRoot, o, 'codex');
-    const base = o.project ? '.agents/skills' : skillsRoot;
-    for (const slug of Object.keys(pack.agents)) {
-        ops.push({ kind: 'file', path: join(codexAgentsRoot(o), `${slug}.toml`), content: codexAgentToml(pack, slug, base), note: `codex agent ${slug}` });
-    }
-    return ops;
-}
-/** OpenClaw tool ids per capability; one table so a rename is a one-line fix. */
-const OPENCLAW_TOOLS = {
-    read: ['read'],
-    write: ['write', 'edit'],
-    exec: ['exec'],
-    spawn: ['sessions_spawn', 'sessions_send', 'agents_list'],
-    network: ['web_fetch', 'browser'],
-};
-export function openclawSeatAgentsMd(pack, slug) {
-    const spec = pack.crew.agents[slug];
-    const caps = spec.capabilities;
-    const seat = [
-        `# Seat: ${slug} (${spec.name})`,
-        '',
-        `You are seat \`${slug}\` of the ${pack.crew.title || pack.crew.name} crew.`,
-        `- Skills allowed: ${spec.skills.join(', ')}`,
-        `- May spawn: ${spec.delegatesTo.length ? spec.delegatesTo.join(', ') : 'nobody — report back to the seat that assigned you'}`,
-        `- Spend credits / run generation: ${caps.spend ? 'yes, after the approved cost is relayed' : 'never'}`,
-        caps.exec === 'readonly' ? '- Shell use is read-only (validate / checkup / manifest / grep / diff); never edit files.' : caps.exec === 'engine' ? '- Shell use is the short-drama engine and read-only wji commands only.' : '',
-        !caps.write ? '- You do not write files.' : '',
-        '',
-    ]
-        .filter((l) => l !== '')
-        .join('\n');
-    return `${seat}\n${pack.agentsMd ? `\n---\n\n${pack.agentsMd.trimEnd()}\n` : ''}`;
-}
-export function openclawFragment(pack, workspacesRoot, repoPlaceholder = true) {
-    const ws = (slug) => (repoPlaceholder ? `\${WORKSPACES}/${slug}` : join(workspacesRoot, slug));
-    const entries = [];
-    for (const [slug, spec] of Object.entries(pack.crew.agents)) {
-        const c = spec.capabilities;
-        const allow = [...OPENCLAW_TOOLS.read, ...(c.write ? OPENCLAW_TOOLS.write : []), ...(c.exec ? OPENCLAW_TOOLS.exec : []), ...(c.spawn ? OPENCLAW_TOOLS.spawn : [])];
-        const deny = [...(c.write ? [] : OPENCLAW_TOOLS.write), ...(c.network ? [] : OPENCLAW_TOOLS.network), ...(c.spawn ? [] : ['sessions_spawn'])];
-        const peers = [...new Set([...spec.delegatesTo, ...Object.entries(pack.crew.agents).filter(([, s]) => s.delegatesTo.includes(slug)).map(([id]) => id)])];
-        entries.push(`    ${JSON.stringify(slug)}: {`, `      name: ${JSON.stringify(spec.name)},`, `      workspace: ${JSON.stringify(ws(slug))},`, spec.model ? `      model: ${JSON.stringify(spec.model)},` : '', `      skills: ${JSON.stringify(spec.skills)},`, `      tools: { allow: ${JSON.stringify(allow)}, deny: ${JSON.stringify(deny)} },`, `      subagents: { allowAgents: ${JSON.stringify(spec.delegatesTo)}${spec.delegatesTo.length ? ', delegationMode: "prefer"' : ''} },`, `      // agent-to-agent messaging peers: ${peers.join(', ') || 'none'}`, `    },`);
-    }
-    const bindings = [];
-    for (const [chId, ch] of Object.entries(pack.crew.channels || {})) {
-        bindings.push(`    // channel "${ch.name}" (${chId}): members ${ch.members.join(', ')} — fill in the real channel / group id`);
-        for (const m of ch.members)
-            bindings.push(`    { agentId: ${JSON.stringify(m)}, match: { channel: "TODO", peer: { kind: "group", id: "TODO:${chId}" } } },`);
-    }
-    return [
-        `// GENERATED by \`wji crew install\` from the ${pack.crew.name} pack. Merge into ~/.openclaw/openclaw.json`,
-        `// (agents.entries + bindings). ${repoPlaceholder ? '${WORKSPACES} = ' + workspacesRoot : ''}`,
-        '{',
-        '  agents: {',
-        `    defaults: { subagents: { allowAgents: ["*"], maxConcurrent: 4, maxSpawnDepth: 2 } },`,
-        '    entries: {',
-        ...entries.filter(Boolean),
-        '    },',
-        '  },',
-        `  tools: { agentToAgent: { enabled: true, allow: ${JSON.stringify(Object.keys(pack.crew.agents))} } },`,
-        '  bindings: [',
-        ...bindings,
-        '  ],',
-        '}',
-        '',
-    ].join('\n');
-}
-export function findOpenclaw() {
-    const candidates = [join(homedir(), '.openclaw', 'bin', 'openclaw')];
-    for (const c of candidates)
-        if (existsSync(c))
-            return c;
-    const which = spawnSync('which', ['openclaw'], { encoding: 'utf8' });
-    const path = which.status === 0 ? which.stdout.trim() : '';
-    return path || undefined;
-}
-export function planOpenclaw(pack, o, opts = {}) {
-    const skillsRoot = agentsSkillsRoot(o);
-    const ops = skillOps(pack, skillsRoot, o, 'openclaw');
-    const root = openclawRoot(pack, o);
-    for (const [slug, persona] of Object.entries(pack.agents)) {
-        const ws = join(root, slug);
-        ops.push({ kind: 'file', path: join(ws, 'SOUL.md'), content: `# ${pack.crew.agents[slug].name}\n\n${persona.body.trimEnd()}\n`, note: `openclaw ${slug}/SOUL.md` });
-        ops.push({ kind: 'file', path: join(ws, 'AGENTS.md'), content: openclawSeatAgentsMd(pack, slug), note: `openclaw ${slug}/AGENTS.md` });
-        ops.push({ kind: 'link', path: join(ws, 'skills'), target: skillsRoot, note: `openclaw ${slug}/skills → shared skills` });
-    }
-    ops.push({ kind: 'file', path: join(root, 'openclaw.agents.json5'), content: openclawFragment(pack, root, false), note: 'openclaw config fragment (merge by hand)' });
-    const bin = opts.register ? findOpenclaw() : undefined;
-    if (bin) {
-        const listed = spawnSync(bin, ['agents', 'list', '--json'], { encoding: 'utf8' });
-        const existing = new Set();
-        try {
-            const parsed = JSON.parse(listed.stdout || '[]');
-            for (const a of Array.isArray(parsed) ? parsed : parsed.agents || [])
-                existing.add(String(a.id || a.name));
-        }
-        catch {
-            /* unreadable list — register everything and let openclaw refuse duplicates */
-        }
-        for (const slug of Object.keys(pack.agents)) {
-            if (existing.has(slug))
-                continue;
-            ops.push({ kind: 'exec', argv: [bin, 'agents', 'add', slug, '--workspace', join(root, slug), '--non-interactive'], note: `openclaw agents add ${slug}` });
-        }
-    }
-    return ops;
-}
-/** The export layout the Grok bot platform imports: skills/ + bots/*.json + channels/*.json. */
-export function grokZip(pack) {
-    const entries = [];
-    const rootName = `${pack.crew.name}-export`;
-    const rewrite = (text) => text
-        // sibling-skill links become the platform's skill links
-        .replace(/\]\(\.\.\/([a-z0-9-]+)\/SKILL\.md\)/g, '](sand-workflow:$1)')
-        // sibling paths become the `{skill}/…` placeholder the platform's skills use
-        .replace(/\.\.\/([a-z0-9-]+)\//g, '{$1}/');
-    for (const [name, files] of pack.skills) {
-        for (const [path, content] of files) {
-            const text = /\.(md|mjs|js|json|txt|sh)$/i.test(path) ? rewrite(content.toString('utf8')) : content;
-            entries.push({ path: `${rootName}/skills/${name}/${path}`, content: text });
-        }
-    }
-    const bots = Object.entries(pack.crew.agents).map(([slug, spec]) => {
-        const persona = pack.agents[slug];
-        const description = `${String(persona.frontmatter.description || '')}\n\n${rewrite(persona.body).trim()}`;
-        return { slug, name: spec.name, title: spec.name, description };
-    });
-    for (const bot of bots)
-        entries.push({ path: `${rootName}/bots/${bot.slug}.json`, content: JSON.stringify(bot, null, 2) + '\n' });
-    const channels = Object.entries(pack.crew.channels || {}).map(([slug, ch]) => ({ slug, name: ch.name, memberSlugs: ch.members }));
-    for (const ch of channels)
-        entries.push({ path: `${rootName}/channels/${ch.slug}.json`, content: JSON.stringify(ch, null, 2) + '\n' });
-    const manifest = {
-        version: 2,
-        exportedAt: new Date().toISOString().slice(0, 10),
-        bots: bots.map((b) => ({ slug: b.slug, name: b.name, title: b.title, description: b.description })),
-        channels,
-        skills: [...pack.skills.keys()].sort(),
-        notes: `Portable ${pack.crew.title || pack.crew.name} pack built by \`wji crew install --for grok\`. Recreate bots from bots/*.json (name + description), channels from channels/*.json memberSlugs, copy every skills/<name> folder into the shared skills library. Account-local ids are never included.`,
-    };
-    entries.push({ path: `${rootName}/bots/crew-manifest.json`, content: JSON.stringify(manifest, null, 2) + '\n' });
-    const readme = [
-        `# ${pack.crew.title || pack.crew.name} export`,
-        '',
-        'Portable pack: skill folders + bot personas + channel recipes.',
-        '',
-        '1. **Skills** — copy each folder under `skills/` into the account\'s shared skills library.',
-        '2. **Bots** — create one agent per `bots/*.json` using the same `name` and `description`' + (pack.crew.entry ? ` (start with ${pack.crew.agents[pack.crew.entry]?.name || pack.crew.entry}).` : '.'),
-        '3. **Channels** — create groups from `channels/*.json` and add members by the listed slugs.',
-        '',
-        '| Bot | Owns |',
-        '| --- | --- |',
-        ...bots.map((b) => `| ${b.name} | ${String(pack.agents[b.slug].frontmatter.description || '').split(/[.。]/)[0]} |`),
-        '',
-    ].join('\n');
-    entries.push({ path: `${rootName}/README.md`, content: readme });
-    return { zip: createZip(entries), entries: entries.length };
-}
-export function installedPath() {
-    return join(crewCacheDir(), 'installed.json');
-}
-export function readInstalled() {
-    const p = installedPath();
-    if (!existsSync(p))
-        return {};
-    try {
-        return JSON.parse(readFileSync(p, 'utf8'));
-    }
-    catch {
-        return {};
-    }
-}
-export function writeInstalled(data) {
-    mkdirSync(dirname(installedPath()), { recursive: true });
-    writeFileSync(installedPath(), JSON.stringify(data, null, 2) + '\n');
-}
-function removePath(path) {
-    if (!existsSync(path) && !isSymlink(path))
-        return;
-    if (isSymlink(path) || !lstatSync(path).isDirectory())
-        rmSync(path, { force: true });
-    else
-        rmSync(path, { recursive: true, force: true });
-}
-const isSymlink = (p) => {
-    try {
-        return lstatSync(p).isSymbolicLink();
-    }
-    catch {
-        return false;
-    }
-};
-/** Run the ops; returns every path written plus the notes of executed commands. */
-export function applyOps(ops, log) {
-    const paths = [];
-    const notes = [];
-    for (const op of ops) {
-        if (op.kind === 'exec') {
-            const res = spawnSync(op.argv[0], op.argv.slice(1), { encoding: 'utf8' });
-            const tail = (res.stdout || res.stderr || '').trim().split('\n').slice(-1)[0] || '';
-            notes.push(`${op.note}: ${res.status === 0 ? 'ok' : `exit ${res.status}`}${tail ? ` — ${tail}` : ''}`);
-            log(`  ${res.status === 0 ? '✓' : '✗'} ${op.note}${tail ? ` — ${tail}` : ''}`);
-            continue;
-        }
-        mkdirSync(dirname(op.path), { recursive: true });
-        if (op.kind === 'link') {
-            removePath(op.path);
-            symlinkSync(op.target, op.path);
-        }
-        else if (op.kind === 'file') {
-            writeFileSync(op.path, op.content);
-        }
-        else {
-            removePath(op.path);
-            for (const [rel, content] of op.files) {
-                const full = join(op.path, rel);
-                mkdirSync(dirname(full), { recursive: true });
-                writeFileSync(full, content);
-            }
-        }
-        paths.push(op.path);
-        log(`  ✓ ${op.note} → ${op.path}`);
-    }
-    return { paths, notes };
-}
-export function describeOp(op) {
-    if (op.kind === 'exec')
-        return `run   ${op.argv.join(' ')}`;
-    if (op.kind === 'link')
-        return `link  ${op.path} → ${op.target}`;
-    if (op.kind === 'file')
-        return `write ${op.path}`;
-    return `copy  ${op.path} (${op.files.size} files)`;
-}
-export function pathState(path) {
-    if (isSymlink(path))
-        return existsSync(path) ? 'link' : 'missing';
-    return existsSync(path) ? 'ok' : 'missing';
-}
-export function uninstallPaths(paths) {
-    for (const p of paths)
-        removePath(p);
-}
-export function relOrAbs(path) {
-    const rel = relative(process.cwd(), path);
-    return rel && !rel.startsWith('..') && !isAbsolute(rel) ? rel : path;
-}
-export function linkTarget(path) {
-    return isSymlink(path) ? readlinkSync(path) : undefined;
-}

package/dist/core/members.js

@@ -1,54 +0,0 @@
-export async function loadMembers(client, workspaceId) {
-    const ws = await client.getFresh(`/workspace/list/${workspaceId}`);
-    const members = (ws.members || []).map((m) => ({
-        memberId: String(m.id),
-        userId: String(m.user?.id ?? m.user ?? ''),
-        name: String(m.user?.name || ''),
-        email: String(m.user?.email || ''),
-        role: m.role,
-    }));
-    return { workspace: ws, members };
-}
-/** What people call a member in a list: the name, else the email, else the id. */
-export const memberLabel = (m) => m.name || m.email || m.userId;
-/**
- * One member from what a person would type: user id, membership id, email or
- * name (case-insensitive), else a unique name prefix. Ambiguity is an error,
- * never a guess.
- */
-export function resolveMember(members, token) {
-    const t = token.trim();
-    const lower = t.toLowerCase();
-    const exact = members.find((m) => m.userId === t || m.memberId === t);
-    if (exact)
-        return exact;
-    const byEmail = members.filter((m) => m.email.toLowerCase() === lower);
-    if (byEmail.length === 1)
-        return byEmail[0];
-    const byName = members.filter((m) => m.name.toLowerCase() === lower);
-    if (byName.length === 1)
-        return byName[0];
-    if (byName.length > 1) {
-        throw new Error(`Several members are called "${t}": ${byName.map((m) => `${m.email || m.userId}`).join(', ')} — use the email or user id`);
-    }
-    const prefix = members.filter((m) => m.name.toLowerCase().startsWith(lower) || m.email.toLowerCase().startsWith(lower));
-    if (prefix.length === 1)
-        return prefix[0];
-    if (prefix.length > 1) {
-        throw new Error(`"${t}" matches several members: ${prefix.map(memberLabel).join(', ')}`);
-    }
-    throw new Error(`No member "${t}" in this workspace. See \`wji ws member list\`.`);
-}
-/** Run `fn` over `items` with at most `limit` in flight, keeping input order. */
-export async function mapLimit(items, limit, fn) {
-    const out = new Array(items.length);
-    let next = 0;
-    const worker = async () => {
-        while (next < items.length) {
-            const i = next++;
-            out[i] = await fn(items[i], i);
-        }
-    };
-    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
-    return out;
-}