@web42/cli 0.1.16 → 0.2.3

package/dist/commands/pack.js

@@ -3,92 +3,204 @@ import { join } from "path";
 import { Command } from "commander";
 import chalk from "chalk";
 import ora from "ora";
-import { openclawAdapter, HARDCODED_EXCLUDES } from "../platforms/openclaw/adapter.js";
+import { resolvePlatform } from "../platforms/registry.js";
 import { parseSkillMd } from "../utils/skill.js";
-const HARDCODED_EXCLUDES_SET = new Set(HARDCODED_EXCLUDES);
+/**
+ * Pack a single agent: run adapter.pack(), detect skills, write to dist.
+ */
+async function packSingleAgent(opts) {
+    const { cwd, adapter, agentName, dryRun } = opts;
+    // Clone manifest so per-agent enrichment doesn't leak
+    const manifest = JSON.parse(JSON.stringify(opts.manifest));
+    const result = await adapter.pack({
+        cwd,
+        outputDir: opts.outputDir,
+        agentName,
+    });
+    // Detect skills from packed files and strip internal ones
+    const internalSkillPrefixes = [];
+    const detectedSkills = [];
+    for (const f of result.files) {
+        const match = f.path.match(/^skills\/([^/]+)\/SKILL\.md$/);
+        if (match) {
+            const parsed = parseSkillMd(f.content, match[1]);
+            if (parsed.internal) {
+                internalSkillPrefixes.push(`skills/${match[1]}/`);
+            }
+            else {
+                detectedSkills.push({ name: parsed.name, description: parsed.description });
+            }
+        }
+    }
+    if (internalSkillPrefixes.length > 0) {
+        result.files = result.files.filter((f) => !internalSkillPrefixes.some((prefix) => f.path.startsWith(prefix)));
+    }
+    if (detectedSkills.length > 0) {
+        manifest.skills = detectedSkills.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    // Merge auto-generated config variables into manifest
+    const existingKeys = new Set((manifest.configVariables ?? []).map((v) => v.key));
+    for (const cv of result.configVariables) {
+        if (!existingKeys.has(cv.key)) {
+            if (!manifest.configVariables)
+                manifest.configVariables = [];
+            manifest.configVariables.push(cv);
+            existingKeys.add(cv.key);
+        }
+    }
+    if (dryRun) {
+        const label = agentName ? `Dry run for ${chalk.bold(agentName)}` : "Dry run";
+        console.log(chalk.bold(`${label} — would pack:`));
+        console.log();
+        for (const f of result.files) {
+            console.log(chalk.dim(`  ${f.path} (${f.content.length} bytes)`));
+        }
+        console.log();
+        console.log(chalk.dim(`${result.files.length} files, ${result.configVariables.length} config variable(s)`));
+        return { manifest, result };
+    }
+    const outputDir = join(cwd, opts.outputDir);
+    mkdirSync(outputDir, { recursive: true });
+    for (const file of result.files) {
+        const filePath = join(outputDir, file.path);
+        mkdirSync(join(filePath, ".."), { recursive: true });
+        writeFileSync(filePath, file.content, "utf-8");
+    }
+    writeFileSync(join(outputDir, "manifest.json"), JSON.stringify(manifest, null, 2) + "\n");
+    return { manifest, result };
+}
 export const packCommand = new Command("pack")
     .description("Pack your agent workspace into a distributable artifact")
     .option("-o, --output <dir>", "Output directory", ".web42/dist")
     .option("--dry-run", "Preview what would be packed without writing files")
+    .option("--agent <name>", "Pack a specific agent (for multi-agent workspaces)")
     .action(async (opts) => {
     const cwd = process.cwd();
-    const manifestPath = join(cwd, "manifest.json");
-    if (!existsSync(manifestPath)) {
-        console.log(chalk.red("No manifest.json found. Run `web42 init` first."));
-        process.exit(1);
-    }
-    const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
-    if (!manifest.name || !manifest.version || !manifest.author) {
-        console.log(chalk.red("Invalid manifest.json. Must have name, version, and author."));
-        process.exit(1);
-    }
-    const spinner = ora("Packing agent...").start();
-    try {
-        const result = await openclawAdapter.pack({ cwd, outputDir: opts.output });
-        // Detect skills from packed files and strip internal ones
-        const internalSkillPrefixes = [];
-        const detectedSkills = [];
-        for (const f of result.files) {
-            const match = f.path.match(/^skills\/([^/]+)\/SKILL\.md$/);
-            if (match) {
-                const parsed = parseSkillMd(f.content, match[1]);
-                if (parsed.internal) {
-                    internalSkillPrefixes.push(`skills/${match[1]}/`);
-                }
-                else {
-                    detectedSkills.push({ name: parsed.name, description: parsed.description });
+    // Determine platform: check for per-agent manifests first, then root manifest
+    let platform = "openclaw"; // default
+    let isMultiAgent = false;
+    const agentManifests = new Map();
+    // Check if this is a multi-agent workspace (per-agent manifests in .web42/{name}/)
+    const web42Dir = join(cwd, ".web42");
+    if (existsSync(web42Dir)) {
+        const { readdirSync } = await import("fs");
+        try {
+            const entries = readdirSync(web42Dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                const agentManifestPath = join(web42Dir, entry.name, "manifest.json");
+                if (existsSync(agentManifestPath)) {
+                    try {
+                        const m = JSON.parse(readFileSync(agentManifestPath, "utf-8"));
+                        agentManifests.set(entry.name, m);
+                        if (m.platform)
+                            platform = m.platform;
+                    }
+                    catch {
+                        // skip invalid manifests
+                    }
                 }
             }
         }
-        if (internalSkillPrefixes.length > 0) {
-            result.files = result.files.filter((f) => !internalSkillPrefixes.some((prefix) => f.path.startsWith(prefix)));
+        catch {
+            // .web42 not readable
         }
-        if (detectedSkills.length > 0) {
-            manifest.skills = detectedSkills.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    isMultiAgent = agentManifests.size > 0;
+    // Fall back to root manifest.json (single-agent, e.g., OpenClaw)
+    if (!isMultiAgent) {
+        const manifestPath = join(cwd, "manifest.json");
+        if (!existsSync(manifestPath)) {
+            console.log(chalk.red("No manifest.json found. Run `web42 init` first."));
+            process.exit(1);
         }
-        // Merge auto-generated config variables into manifest
-        const existingKeys = new Set((manifest.configVariables ?? []).map((v) => v.key));
-        for (const cv of result.configVariables) {
-            if (!existingKeys.has(cv.key)) {
-                if (!manifest.configVariables)
-                    manifest.configVariables = [];
-                manifest.configVariables.push(cv);
-                existingKeys.add(cv.key);
-            }
+        const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+        if (!manifest.name || !manifest.version || !manifest.author) {
+            console.log(chalk.red("Invalid manifest.json. Must have name, version, and author."));
+            process.exit(1);
         }
-        if (opts.dryRun) {
-            spinner.stop();
-            const userPatterns = (result.ignorePatterns ?? []).filter((p) => !HARDCODED_EXCLUDES_SET.has(p));
-            if (userPatterns.length > 0) {
-                console.log(chalk.bold("Ignore patterns from .web42ignore:"));
-                for (const p of userPatterns) {
-                    console.log(chalk.yellow(`  ✕ ${p}`));
-                }
-                console.log();
+        if (manifest.platform)
+            platform = manifest.platform;
+        const adapter = resolvePlatform(platform);
+        const spinner = ora("Packing agent...").start();
+        try {
+            const { manifest: enriched, result } = await packSingleAgent({
+                cwd,
+                manifest,
+                manifestPath,
+                adapter,
+                outputDir: opts.output,
+                dryRun: opts.dryRun,
+            });
+            if (opts.dryRun) {
+                spinner.stop();
+                return;
             }
-            console.log(chalk.bold("Dry run — would pack:"));
-            console.log();
-            for (const f of result.files) {
-                console.log(chalk.dim(`  ${f.path} (${f.content.length} bytes)`));
+            spinner.succeed(`Packed ${chalk.bold(enriched.name)} (${result.files.length} files) → ${opts.output}/`);
+            if (result.configVariables.length > 0) {
+                console.log(chalk.dim(`  ${result.configVariables.length} config variable(s) detected`));
             }
             console.log();
-            console.log(chalk.dim(`${result.files.length} files, ${result.configVariables.length} config variable(s)`));
-            return;
+            console.log(chalk.dim("Run `web42 push` to publish to the marketplace."));
         }
-        const outputDir = join(cwd, opts.output);
-        mkdirSync(outputDir, { recursive: true });
-        for (const file of result.files) {
-            const filePath = join(outputDir, file.path);
-            mkdirSync(join(filePath, ".."), { recursive: true });
-            writeFileSync(filePath, file.content, "utf-8");
+        catch (error) {
+            spinner.fail("Pack failed");
+            console.error(chalk.red(error.message));
+            process.exit(1);
         }
-        writeFileSync(join(outputDir, "manifest.json"), JSON.stringify(manifest, null, 2) + "\n");
-        spinner.succeed(`Packed ${chalk.bold(manifest.name)} (${result.files.length} files) → ${opts.output}/`);
-        if (result.configVariables.length > 0) {
-            console.log(chalk.dim(`  ${result.configVariables.length} config variable(s) detected`));
+        return;
+    }
+    // Multi-agent mode
+    const adapter = resolvePlatform(platform);
+    // Determine which agents to pack
+    let agentsToPack;
+    if (opts.agent) {
+        const manifest = agentManifests.get(opts.agent);
+        if (!manifest) {
+            console.log(chalk.red(`Agent "${opts.agent}" not found. Available: ${[...agentManifests.keys()].join(", ")}`));
+            process.exit(1);
+        }
+        agentsToPack = [[opts.agent, manifest]];
+    }
+    else {
+        agentsToPack = [...agentManifests.entries()];
+    }
+    const spinner = ora(`Packing ${agentsToPack.length} agent(s)...`).start();
+    try {
+        for (const [agentName, manifest] of agentsToPack) {
+            const agentOutputDir = join(".web42", agentName, "dist");
+            spinner.text = `Packing ${agentName}...`;
+            if (opts.dryRun) {
+                spinner.stop();
+            }
+            const { manifest: enriched, result } = await packSingleAgent({
+                cwd,
+                manifest,
+                manifestPath: join(web42Dir, agentName, "manifest.json"),
+                adapter,
+                agentName,
+                outputDir: agentOutputDir,
+                dryRun: opts.dryRun,
+            });
+            if (!opts.dryRun) {
+                // Also write the enriched manifest back
+                writeFileSync(join(web42Dir, agentName, "manifest.json"), JSON.stringify(enriched, null, 2) + "\n");
+                console.log(chalk.green(`  Packed ${chalk.bold(agentName)} (${result.files.length} files) → ${agentOutputDir}/`));
+            }
+            if (opts.dryRun) {
+                console.log(); // spacing between agents
+                spinner.start();
+            }
+        }
+        if (opts.dryRun) {
+            spinner.stop();
+        }
+        else {
+            spinner.succeed(`Packed ${agentsToPack.length} agent(s)`);
+            console.log();
+            console.log(chalk.dim("Run `web42 push` to publish to the marketplace."));
         }
-        console.log();
-        console.log(chalk.dim("Run `web42 push` to publish to the marketplace."));
     }
     catch (error) {
         spinner.fail("Pack failed");

package/dist/commands/pull.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "fs";
 import { dirname, join } from "path";
 import { Command } from "commander";
 import chalk from "chalk";
@@ -6,125 +6,193 @@ import ora from "ora";
 import { apiGet } from "../utils/api.js";
 import { requireAuth } from "../utils/config.js";
 import { buildLocalSnapshot, computeHashFromSnapshot, readSyncState, writeSyncState, writeMarketplace, writeResourcesMeta, } from "../utils/sync.js";
+/**
+ * Pull a single agent from the marketplace into a local directory.
+ */
+async function pullSingleAgent(opts) {
+    const { manifest, manifestPath, syncDir, writeDir, distDir, config, spinner } = opts;
+    const name = manifest.name ?? "";
+    // Step 1: Resolve agent ID
+    let syncState = readSyncState(syncDir);
+    let agentId = syncState?.agent_id ?? null;
+    if (!agentId) {
+        spinner.text = `Looking up ${name}...`;
+        const agents = await apiGet(`/api/agents?username=${config.username}`);
+        const agent = agents.find((a) => a.slug === name);
+        if (!agent) {
+            spinner.fail(`Agent @${config.username}/${name} not found on the marketplace. Run \`web42 push\` first.`);
+            process.exit(1);
+        }
+        agentId = agent.id;
+    }
+    // Step 2: Compare remote hash with last known remote hash (unless --force)
+    if (!opts.force && syncState?.last_remote_hash) {
+        spinner.text = `Checking remote state for ${name}...`;
+        const remote = await apiGet(`/api/agents/${agentId}/sync`);
+        if (remote.hash === syncState.last_remote_hash) {
+            console.log(chalk.dim(`  ${chalk.bold(`@${config.username}/${name}`)} is already in sync.`));
+            return;
+        }
+    }
+    // Step 3: Pull full snapshot
+    spinner.text = `Downloading ${name}...`;
+    const pullResult = await apiGet(`/api/agents/${agentId}/sync/pull`);
+    const { snapshot } = pullResult;
+    let written = 0;
+    // Step 4a: Write manifest.json
+    const updatedManifest = {
+        ...manifest,
+        ...snapshot.manifest,
+        name: snapshot.identity.slug,
+        description: snapshot.identity.description,
+    };
+    writeFileSync(manifestPath, JSON.stringify(updatedManifest, null, 2) + "\n");
+    written++;
+    // Step 4b: Write README.md
+    if (snapshot.readme) {
+        writeFileSync(join(writeDir, "README.md"), snapshot.readme, "utf-8");
+        written++;
+    }
+    // Step 4c: Write marketplace.json
+    writeMarketplace(writeDir, snapshot.marketplace);
+    written++;
+    // Step 4d: Write agent files into dist/
+    let skipped = 0;
+    mkdirSync(distDir, { recursive: true });
+    for (const file of snapshot.files) {
+        if (file.content === null || file.content === undefined) {
+            skipped++;
+            continue;
+        }
+        if (file.path === ".openclaw/config.json") {
+            skipped++;
+            continue;
+        }
+        const filePath = join(distDir, file.path);
+        mkdirSync(dirname(filePath), { recursive: true });
+        writeFileSync(filePath, file.content, "utf-8");
+        written++;
+    }
+    // Step 4e: Write resources metadata
+    if (snapshot.resources.length > 0) {
+        const resourcesMeta = snapshot.resources.map((r, i) => ({
+            file: `resource-${i}-${r.title.replace(/[^a-zA-Z0-9.-]/g, "_")}`,
+            title: r.title,
+            description: r.description ?? undefined,
+            type: r.type,
+            sort_order: r.sort_order,
+        }));
+        writeResourcesMeta(writeDir, resourcesMeta);
+        written++;
+    }
+    // Step 5: Save sync state
+    const localSnapshot = buildLocalSnapshot(syncDir, distDir);
+    const localHash = computeHashFromSnapshot(localSnapshot);
+    writeSyncState(syncDir, {
+        agent_id: agentId,
+        last_remote_hash: pullResult.hash,
+        last_local_hash: localHash,
+        synced_at: new Date().toISOString(),
+    });
+    console.log(chalk.green(`  Pulled @${config.username}/${name} (${written} files${skipped > 0 ? `, ${skipped} skipped` : ""})`));
+    console.log(chalk.dim(`  Sync hash: ${pullResult.hash.slice(0, 12)}...`));
+}
 export const pullCommand = new Command("pull")
     .description("Pull latest agent state from the Web42 marketplace into the current directory")
     .option("--force", "Skip hash comparison and always pull")
+    .option("--agent <name>", "Pull a specific agent (for multi-agent workspaces)")
     .action(async (opts) => {
     const config = requireAuth();
     const cwd = process.cwd();
-    const manifestPath = join(cwd, "manifest.json");
-    if (!existsSync(manifestPath)) {
-        console.log(chalk.red("No manifest.json found. Are you in an agent directory?"));
-        process.exit(1);
-    }
-    const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
-    if (!manifest.name) {
-        console.log(chalk.red("manifest.json is missing a name field."));
-        process.exit(1);
-    }
-    const spinner = ora(`Pulling @${config.username}/${manifest.name}...`).start();
-    try {
-        // -------------------------------------------------------------------
-        // Step 1: Resolve agent ID
-        // -------------------------------------------------------------------
-        let syncState = readSyncState(cwd);
-        let agentId = syncState?.agent_id ?? null;
-        if (!agentId) {
-            spinner.text = "Looking up agent...";
-            const agents = await apiGet(`/api/agents?username=${config.username}`);
-            const agent = agents.find((a) => a.slug === manifest.name);
-            if (!agent) {
-                spinner.fail(`Agent @${config.username}/${manifest.name} not found on the marketplace. Run \`web42 push\` first.`);
-                process.exit(1);
+    // Detect multi-agent workspace (.web42/{name}/manifest.json)
+    const web42Dir = join(cwd, ".web42");
+    const agentManifests = new Map();
+    if (existsSync(web42Dir)) {
+        try {
+            const entries = readdirSync(web42Dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                const agentManifestPath = join(web42Dir, entry.name, "manifest.json");
+                if (existsSync(agentManifestPath)) {
+                    try {
+                        const m = JSON.parse(readFileSync(agentManifestPath, "utf-8"));
+                        agentManifests.set(entry.name, m);
+                    }
+                    catch {
+                        // skip
+                    }
+                }
             }
-            agentId = agent.id;
         }
-        // -------------------------------------------------------------------
-        // Step 2: Compare remote hash with last known remote hash (unless --force)
-        // -------------------------------------------------------------------
-        if (!opts.force && syncState?.last_remote_hash) {
-            spinner.text = "Checking remote state...";
-            const remote = await apiGet(`/api/agents/${agentId}/sync`);
-            if (remote.hash === syncState.last_remote_hash) {
-                spinner.succeed(`${chalk.bold(`@${config.username}/${manifest.name}`)} is already in sync (no remote changes).`);
-                return;
-            }
+        catch {
+            // .web42 not readable
         }
-        // -------------------------------------------------------------------
-        // Step 3: Pull full snapshot
-        // -------------------------------------------------------------------
-        spinner.text = "Downloading snapshot...";
-        const pullResult = await apiGet(`/api/agents/${agentId}/sync/pull`);
-        const { snapshot } = pullResult;
-        let written = 0;
-        // -------------------------------------------------------------------
-        // Step 4a: Write manifest.json (merge identity into existing manifest)
-        // -------------------------------------------------------------------
-        const updatedManifest = {
-            ...manifest,
-            ...snapshot.manifest,
-            name: snapshot.identity.slug,
-            description: snapshot.identity.description,
-        };
-        writeFileSync(manifestPath, JSON.stringify(updatedManifest, null, 2) + "\n");
-        written++;
-        // -------------------------------------------------------------------
-        // Step 4b: Write README.md
-        // -------------------------------------------------------------------
-        if (snapshot.readme) {
-            writeFileSync(join(cwd, "README.md"), snapshot.readme, "utf-8");
-            written++;
+    }
+    const isMultiAgent = agentManifests.size > 0;
+    // Single-agent mode
+    if (!isMultiAgent) {
+        const manifestPath = join(cwd, "manifest.json");
+        if (!existsSync(manifestPath)) {
+            console.log(chalk.red("No manifest.json found. Are you in an agent directory?"));
+            process.exit(1);
         }
-        // -------------------------------------------------------------------
-        // Step 4c: Write .web42/marketplace.json
-        // -------------------------------------------------------------------
-        writeMarketplace(cwd, snapshot.marketplace);
-        written++;
-        // -------------------------------------------------------------------
-        // Step 4d: Write agent files
-        // -------------------------------------------------------------------
-        let skipped = 0;
-        for (const file of snapshot.files) {
-            if (file.content === null || file.content === undefined) {
-                skipped++;
-                continue;
-            }
-            if (file.path === ".openclaw/config.json") {
-                skipped++;
-                continue;
-            }
-            const filePath = join(cwd, file.path);
-            mkdirSync(dirname(filePath), { recursive: true });
-            writeFileSync(filePath, file.content, "utf-8");
-            written++;
+        const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+        if (!manifest.name) {
+            console.log(chalk.red("manifest.json is missing a name field."));
+            process.exit(1);
         }
-        // -------------------------------------------------------------------
-        // Step 4e: Write resources metadata
-        // -------------------------------------------------------------------
-        if (snapshot.resources.length > 0) {
-            const resourcesMeta = snapshot.resources.map((r, i) => ({
-                file: `resource-${i}-${r.title.replace(/[^a-zA-Z0-9.-]/g, "_")}`,
-                title: r.title,
-                description: r.description ?? undefined,
-                type: r.type,
-                sort_order: r.sort_order,
-            }));
-            writeResourcesMeta(cwd, resourcesMeta);
-            written++;
+        const spinner = ora(`Pulling @${config.username}/${manifest.name}...`).start();
+        try {
+            await pullSingleAgent({
+                manifest,
+                manifestPath,
+                syncDir: cwd,
+                writeDir: cwd,
+                distDir: join(cwd, ".web42", "dist"),
+                config,
+                force: opts.force,
+                spinner,
+            });
+            spinner.succeed(`Pull complete`);
+        }
+        catch (error) {
+            spinner.fail("Pull failed");
+            console.error(chalk.red(error.message));
+            process.exit(1);
+        }
+        return;
+    }
+    // Multi-agent mode
+    let agentsToPull;
+    if (opts.agent) {
+        const manifest = agentManifests.get(opts.agent);
+        if (!manifest) {
+            console.log(chalk.red(`Agent "${opts.agent}" not found. Available: ${[...agentManifests.keys()].join(", ")}`));
+            process.exit(1);
+        }
+        agentsToPull = [[opts.agent, manifest]];
+    }
+    else {
+        agentsToPull = [...agentManifests.entries()];
+    }
+    const spinner = ora(`Pulling ${agentsToPull.length} agent(s)...`).start();
+    try {
+        for (const [agentName, manifest] of agentsToPull) {
+            spinner.text = `Pulling ${agentName}...`;
+            const agentWeb42Dir = join(web42Dir, agentName);
+            await pullSingleAgent({
+                manifest,
+                manifestPath: join(agentWeb42Dir, "manifest.json"),
+                syncDir: agentWeb42Dir,
+                writeDir: agentWeb42Dir,
+                distDir: join(agentWeb42Dir, "dist"),
+                config,
+                force: opts.force,
+                spinner,
+            });
         }
-        // -------------------------------------------------------------------
-        // Step 5: Save sync state (compute local hash from what we just wrote)
-        // -------------------------------------------------------------------
-        const localSnapshot = buildLocalSnapshot(cwd);
-        const localHash = computeHashFromSnapshot(localSnapshot);
-        writeSyncState(cwd, {
-            agent_id: agentId,
-            last_remote_hash: pullResult.hash,
-            last_local_hash: localHash,
-            synced_at: new Date().toISOString(),
-        });
-        spinner.succeed(`Pulled ${chalk.bold(`@${config.username}/${manifest.name}`)} (${written} files written${skipped > 0 ? `, ${skipped} skipped` : ""})`);
-        console.log(chalk.dim(`  Sync hash: ${pullResult.hash.slice(0, 12)}...`));
+        spinner.succeed(`Pulled ${agentsToPull.length} agent(s)`);
     }
     catch (error) {
         spinner.fail("Pull failed");