@web42/cli 0.1.16 → 0.2.3

package/README.md

@@ -0,0 +1,73 @@
+# @web42/cli
+
+CLI for the Web42 Agent Marketplace - push, install, and remix OpenClaw agent packages.
+
+## Installation
+
+To install the CLI globally, run:
+
+```
+npm install -g @web42/cli
+```
+
+## Authentication
+
+Authenticate with the marketplace by running:
+
+```
+web42 login
+```
+
+## Supported Platforms
+
+| Platform  | Status       |
+|-----------|--------------|
+| openclaw  | Fully Supported  |
+| claude    | Fully Supported  |
+
+## CLI Commands Reference
+
+### General Commands
+
+| Command      | Description                             |
+|--------------|-----------------------------------------|
+| `web42 install <agent>` | Install an agent package from the marketplace |
+| `web42 push` | Push your agent package to the marketplace |
+| `web42 pull` | Pull the latest agent state from the marketplace |
+| `web42 list` | List installed agents                   |
+| `web42 update <agent>` | Update an installed agent to the latest version |
+| `web42 uninstall <agent>` | Uninstall an agent                   |
+| `web42 search <query>` | Search the marketplace for agents      |
+| `web42 remix <agent>` | Remix an agent package to your account |
+| `web42 sync` | Check sync status between local workspace and the marketplace |
+
+### Claude-Specific Examples
+
+- **Initialize a Project:**
+  ```
+  web42 init
+  ```
+
+- **Pack an Agent:**
+  ```
+  web42 pack --agent <name>
+  ```
+
+- **Push an Agent:**
+  ```
+  web42 push --agent <name>
+  ```
+
+- **Install an Agent Globally:**
+  ```
+  web42 claude install @user/agent
+  ```
+
+- **Install an Agent Locally:**
+  ```
+  web42 claude install -g @user/agent
+  ```
+
+## Versioning
+
+Version `0.2.0` introduces Claude Code support.

package/dist/commands/init.js

@@ -35,12 +35,222 @@ function detectWorkspaceSkills(cwd) {
     }
     return skills.sort((a, b) => a.name.localeCompare(b.name));
 }
-export const initCommand = new Command("init")
-    .description("Create a manifest.json for your agent package")
-    .option("--with-skills [names...]", "Add bundled starter skills (omit names to install all)")
-    .action(async (opts) => {
-    const config = requireAuth();
-    const cwd = process.cwd();
+const WEB42_IGNORE_CONTENT = [
+    "# .web42ignore — files excluded from web42 pack / push",
+    "# Syntax: glob patterns, one per line. Lines starting with # are comments.",
+    "# NOTE: .git, node_modules, .web42/, manifest.json, and other internals",
+    "#       are always excluded automatically.",
+    "",
+    "# Working notes & drafts",
+    "TODO.md",
+    "NOTES.md",
+    "drafts/**",
+    "",
+    "# Environment & secrets",
+    ".env",
+    ".env.*",
+    "",
+    "# IDE / editor",
+    ".vscode/**",
+    ".idea/**",
+    ".cursor/**",
+    "",
+    "# Test & CI",
+    "tests/**",
+    "__tests__/**",
+    ".github/**",
+    "",
+    "# Build artifacts",
+    "dist/**",
+    "build/**",
+    "",
+    "# Large media not needed at runtime",
+    "# *.mp4",
+    "# *.mov",
+    "",
+].join("\n");
+// ---------------------------------------------------------------------------
+// Claude-specific init flow
+// ---------------------------------------------------------------------------
+async function initClaude(cwd, config, adapter) {
+    // Discover agents
+    if (!adapter.discoverAgents) {
+        console.log(chalk.red("Claude adapter missing discoverAgents method."));
+        process.exit(1);
+    }
+    const agents = adapter.discoverAgents(cwd);
+    if (agents.length === 0) {
+        console.log(chalk.red("No agents found.\n" +
+            "Create an agent in ~/.claude/agents/ or ./agents/ first."));
+        process.exit(1);
+    }
+    // Agent picker (multi-select)
+    let selectedAgents = agents;
+    if (agents.length > 1) {
+        const { chosen } = await inquirer.prompt([
+            {
+                type: "checkbox",
+                name: "chosen",
+                message: "Which agents do you want to init for the marketplace?",
+                choices: agents.map((a) => ({
+                    name: `${a.name}${a.description ? ` — ${a.description}` : ""}`,
+                    value: a.name,
+                    checked: true,
+                })),
+                validate: (val) => val.length > 0 || "Select at least one agent",
+            },
+        ]);
+        selectedAgents = agents.filter((a) => chosen.includes(a.name));
+    }
+    else {
+        console.log();
+        console.log(chalk.dim(`  Found agent: ${chalk.bold(agents[0].name)}${agents[0].description ? ` — ${agents[0].description}` : ""}`));
+    }
+    // Check for existing .web42/ agents that are already init'd
+    const web42Dir = join(cwd, ".web42");
+    const existingInits = new Set();
+    if (existsSync(web42Dir)) {
+        try {
+            const entries = readdirSync(web42Dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory() && existsSync(join(web42Dir, entry.name, "manifest.json"))) {
+                    existingInits.add(entry.name);
+                }
+            }
+        }
+        catch {
+            // skip
+        }
+    }
+    const toInit = selectedAgents.filter((a) => !existingInits.has(a.name));
+    const alreadyInit = selectedAgents.filter((a) => existingInits.has(a.name));
+    if (alreadyInit.length > 0) {
+        console.log(chalk.dim(`  Already initialized: ${alreadyInit.map((a) => a.name).join(", ")}`));
+    }
+    if (toInit.length === 0 && alreadyInit.length > 0) {
+        // Ask if they want to re-init
+        const { reinit } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "reinit",
+                message: "All selected agents are already initialized. Re-initialize?",
+                default: false,
+            },
+        ]);
+        if (!reinit) {
+            console.log(chalk.yellow("Aborted."));
+            return;
+        }
+        toInit.push(...alreadyInit);
+    }
+    // For each agent: resolve skills, prompt, create .web42/{name}/ metadata
+    for (const agent of toInit.length > 0 ? toInit : selectedAgents) {
+        console.log();
+        console.log(chalk.bold(`Initializing ${agent.name}...`));
+        // Resolve skills
+        let resolvedSkills = [];
+        if (agent.skills.length > 0 && adapter.resolveSkills) {
+            const resolved = adapter.resolveSkills(agent.skills, cwd);
+            const found = resolved.filter((s) => s.found);
+            const missing = resolved.filter((s) => !s.found);
+            if (found.length > 0) {
+                // Read SKILL.md for descriptions
+                resolvedSkills = found.map((s) => {
+                    const skillMd = join(s.sourcePath, "SKILL.md");
+                    if (existsSync(skillMd)) {
+                        const content = readFileSync(skillMd, "utf-8");
+                        const parsed = parseSkillMd(content, s.name);
+                        return { name: parsed.name, description: parsed.description };
+                    }
+                    return { name: s.name, description: `Skill: ${s.name}` };
+                });
+                console.log(chalk.dim(`  Resolved ${found.length} skill(s): ${found.map((s) => s.name).join(", ")}`));
+            }
+            if (missing.length > 0) {
+                console.log(chalk.yellow(`  Skills not found: ${missing.map((s) => s.name).join(", ")}`));
+            }
+        }
+        // Also detect workspace skills (in case agent references skills in cwd/skills/)
+        const workspaceSkills = detectWorkspaceSkills(cwd);
+        const existingNames = new Set(resolvedSkills.map((s) => s.name));
+        for (const ws of workspaceSkills) {
+            if (!existingNames.has(ws.name)) {
+                resolvedSkills.push(ws);
+            }
+        }
+        // Prompt for description and version
+        const defaults = {
+            description: agent.description ?? "",
+            version: "1.0.0",
+        };
+        // Check if manifest already exists for this agent
+        const agentWeb42Dir = join(web42Dir, agent.name);
+        const existingManifestPath = join(agentWeb42Dir, "manifest.json");
+        let existingManifest = null;
+        if (existsSync(existingManifestPath)) {
+            try {
+                existingManifest = JSON.parse(readFileSync(existingManifestPath, "utf-8"));
+            }
+            catch {
+                // ignore
+            }
+        }
+        const answers = await inquirer.prompt([
+            {
+                type: "input",
+                name: "description",
+                message: `  Description for ${agent.name}:`,
+                default: existingManifest?.description ?? defaults.description,
+                validate: (val) => (val.length > 0 && val.length <= 500) || "1-500 characters",
+            },
+            {
+                type: "input",
+                name: "version",
+                message: "  Version:",
+                default: existingManifest?.version ?? defaults.version,
+                validate: (val) => /^\d+\.\d+\.\d+$/.test(val) || "Must follow semver (e.g. 1.0.0)",
+            },
+        ]);
+        // Create per-agent .web42/{name}/ directory
+        mkdirSync(agentWeb42Dir, { recursive: true });
+        // Write manifest
+        const manifest = {
+            format: "agentpkg/1",
+            platform: "claude",
+            name: agent.name,
+            description: answers.description,
+            version: answers.version,
+            author: config.username ?? "",
+            skills: resolvedSkills,
+            plugins: [],
+            modelPreferences: agent.model
+                ? { primary: agent.model }
+                : undefined,
+            configVariables: [],
+        };
+        writeFileSync(join(agentWeb42Dir, "manifest.json"), JSON.stringify(manifest, null, 2) + "\n");
+        console.log(chalk.green(`  Created .web42/${agent.name}/manifest.json`));
+        // Write marketplace.json
+        const marketplacePath = join(agentWeb42Dir, "marketplace.json");
+        if (!existsSync(marketplacePath)) {
+            writeFileSync(marketplacePath, JSON.stringify(DEFAULT_MARKETPLACE, null, 2) + "\n");
+            console.log(chalk.green(`  Created .web42/${agent.name}/marketplace.json`));
+        }
+        // Write .web42ignore
+        const ignorePath = join(agentWeb42Dir, ".web42ignore");
+        if (!existsSync(ignorePath)) {
+            writeFileSync(ignorePath, WEB42_IGNORE_CONTENT, "utf-8");
+            console.log(chalk.green(`  Created .web42/${agent.name}/.web42ignore`));
+        }
+    }
+    console.log();
+    console.log(chalk.dim("Edit .web42/{agent}/marketplace.json to set price, tags, license, and visibility."));
+    console.log(chalk.dim("Run `web42 pack` to bundle your agents, or `web42 push` to pack and publish."));
+}
+// ---------------------------------------------------------------------------
+// OpenClaw init flow (existing behavior)
+// ---------------------------------------------------------------------------
+async function initOpenclaw(cwd, config, adapter, platform, opts) {
     const manifestPath = join(cwd, "manifest.json");
     let existingManifest = null;
     if (existsSync(manifestPath)) {
@@ -60,20 +270,9 @@ export const initCommand = new Command("init")
             existingManifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
         }
         catch {
-            // ignore parse errors from existing manifest
+            // ignore
         }
     }
-    const platforms = listPlatforms();
-    const { platform } = await inquirer.prompt([
-        {
-            type: "list",
-            name: "platform",
-            message: "Platform:",
-            choices: platforms,
-            default: platforms[0],
-        },
-    ]);
-    const adapter = resolvePlatform(platform);
     const initConfig = adapter.extractInitConfig(cwd);
     if (!initConfig) {
         console.log(chalk.red(`No agent entry found in ${adapter.name} config for this directory.\n` +
@@ -112,7 +311,7 @@ export const initCommand = new Command("init")
         name: initConfig.name,
         description: answers.description,
         version: answers.version,
-        author: config.username,
+        author: config.username ?? "",
         skills: detectedSkills,
         plugins: [],
         modelPreferences: initConfig.model
@@ -171,40 +370,7 @@ export const initCommand = new Command("init")
     mkdirSync(join(web42Dir, "resources"), { recursive: true });
     const ignorePath = join(cwd, ".web42ignore");
     if (!existsSync(ignorePath)) {
-        writeFileSync(ignorePath, [
-            "# .web42ignore — files excluded from web42 pack / push",
-            "# Syntax: glob patterns, one per line. Lines starting with # are comments.",
-            "# NOTE: .git, node_modules, .web42/, manifest.json, and other internals",
-            "#       are always excluded automatically.",
-            "",
-            "# Working notes & drafts",
-            "TODO.md",
-            "NOTES.md",
-            "drafts/**",
-            "",
-            "# Environment & secrets",
-            ".env",
-            ".env.*",
-            "",
-            "# IDE / editor",
-            ".vscode/**",
-            ".idea/**",
-            ".cursor/**",
-            "",
-            "# Test & CI",
-            "tests/**",
-            "__tests__/**",
-            ".github/**",
-            "",
-            "# Build artifacts",
-            "dist/**",
-            "build/**",
-            "",
-            "# Large media not needed at runtime",
-            "# *.mp4",
-            "# *.mov",
-            "",
-        ].join("\n"), "utf-8");
+        writeFileSync(ignorePath, WEB42_IGNORE_CONTENT, "utf-8");
         console.log(chalk.green(`  Created ${chalk.bold(".web42ignore")}`));
     }
     else {
@@ -255,4 +421,31 @@ export const initCommand = new Command("init")
     console.log();
     console.log(chalk.dim("Edit .web42/marketplace.json to set price, tags, license, and visibility."));
     console.log(chalk.dim("Run `web42 pack` to bundle your agent, or `web42 push` to pack and publish."));
+}
+// ---------------------------------------------------------------------------
+// Command
+// ---------------------------------------------------------------------------
+export const initCommand = new Command("init")
+    .description("Create a manifest.json for your agent package")
+    .option("--with-skills [names...]", "Add bundled starter skills (omit names to install all)")
+    .action(async (opts) => {
+    const config = requireAuth();
+    const cwd = process.cwd();
+    const platforms = listPlatforms();
+    const { platform } = await inquirer.prompt([
+        {
+            type: "list",
+            name: "platform",
+            message: "Platform:",
+            choices: platforms,
+            default: platforms[0],
+        },
+    ]);
+    const adapter = resolvePlatform(platform);
+    if (platform === "claude") {
+        await initClaude(cwd, config, adapter);
+    }
+    else {
+        await initOpenclaw(cwd, config, adapter, platform, opts);
+    }
 });

package/dist/commands/install.js

@@ -1,4 +1,4 @@
-import { appendFileSync, existsSync, readFileSync, writeFileSync } from "fs";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { join } from "path";
 import { Command } from "commander";
 import chalk from "chalk";
@@ -44,6 +44,7 @@ export function makeInstallCommand(adapter) {
         .argument("<agent>", "Agent to install (e.g. @user/agent-name)")
         .option("--as <name>", "Install under a different local agent name")
         .option("--no-prompt", "Skip config variable prompts, use defaults")
+        .option("-g, --global", "Install globally to ~/.claude/ instead of project-local .claude/")
         .action(async (agentRef, opts) => {
         const match = agentRef.match(/^@?([^/]+)\/(.+)$/);
         if (!match) {
@@ -153,7 +154,11 @@ export function makeInstallCommand(adapter) {
                 }
             }
             const localName = opts.as ?? agentSlug;
-            const workspacePath = join(adapter.home, `workspace-${localName}`);
+            const workspacePath = adapter.resolveInstallPath
+                ? adapter.resolveInstallPath(localName, opts.global)
+                : opts.global
+                    ? join(adapter.home, `workspace-${localName}`)
+                    : join(process.cwd(), ".claude");
             const installResult = await adapter.install({
                 agentSlug: localName,
                 username,
@@ -161,6 +166,7 @@ export function makeInstallCommand(adapter) {
                 files: result.files,
                 configTemplate,
                 configAnswers,
+                version: result.agent.manifest.version,
             });
             const web42Config = {
                 source: `@${username}/${agentSlug}`,
@@ -169,11 +175,28 @@ export function makeInstallCommand(adapter) {
             const configPath = join(workspacePath, ".web42.config.json");
             writeFileSync(configPath, JSON.stringify(web42Config, null, 2) + "\n");
             spinner.stop();
+            const profileImageUrl = result.agent.profile_image_url;
+            if (profileImageUrl) {
+                try {
+                    const avatarsDir = join(workspacePath, "avatars");
+                    mkdirSync(avatarsDir, { recursive: true });
+                    const avatarPath = join(avatarsDir, "avatar.png");
+                    const avatarResponse = await fetch(profileImageUrl);
+                    if (avatarResponse.ok) {
+                        const buffer = Buffer.from(await avatarResponse.arrayBuffer());
+                        writeFileSync(avatarPath, buffer);
+                    }
+                }
+                catch {
+                    // Non-fatal — avatar download failure shouldn't block install
+                }
+            }
             console.log();
             console.log(chalk.green(`Installed ${chalk.bold(`@${username}/${agentSlug}`)} as agent "${localName}"`));
             console.log(chalk.dim(`  Workspace: ${workspacePath}`));
             if (manifest.skills && manifest.skills.length > 0) {
-                console.log(chalk.dim(`  Skills: ${manifest.skills.join(", ")}`));
+                const skillNames = manifest.skills.map((s) => typeof s === "string" ? s : s.name);
+                console.log(chalk.dim(`  Skills: ${skillNames.join(", ")}`));
             }
             console.log(chalk.dim(`  ${installResult.filesWritten} files written`));
             const pendingVars = (manifest.configVariables ?? []).filter((v) => v.required && !configAnswers[v.key]);
@@ -185,9 +208,19 @@ export function makeInstallCommand(adapter) {
                 }
             }
             console.log();
-            console.log(chalk.dim("  Next steps:"));
-            console.log(chalk.dim(`    1. Set up channel bindings:  ${adapter.name} config`));
-            console.log(chalk.dim(`    2. Restart the gateway:      ${adapter.name} gateway restart`));
+            if (adapter.name === "claude") {
+                if (opts.global) {
+                    console.log(chalk.dim("  Next: Open Claude Code — the agent is available globally."));
+                }
+                else {
+                    console.log(chalk.dim("  Next: Open Claude Code in this project — the agent is available locally."));
+                }
+            }
+            else {
+                console.log(chalk.dim("  Next steps:"));
+                console.log(chalk.dim(`    1. Set up channel bindings:  ${adapter.name} config`));
+                console.log(chalk.dim(`    2. Restart the gateway:      ${adapter.name} gateway restart`));
+            }
         }
         catch (error) {
             spinner.fail("Install failed");