@web42/w42 0.1.0

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/auth.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const authCommand: Command;

package/dist/commands/auth.js

@@ -0,0 +1,86 @@
+import { randomBytes } from "crypto";
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { apiPost } from "../utils/api.js";
+import { clearAuth, getConfig, setAuth } from "../utils/config.js";
+export const authCommand = new Command("auth").description("Authenticate with the Web42 Network");
+authCommand
+    .command("login")
+    .description("Sign in via GitHub OAuth in the browser")
+    .action(async () => {
+    const config = getConfig();
+    const code = randomBytes(16).toString("hex");
+    const spinner = ora("Registering auth code...").start();
+    try {
+        await apiPost("/api/auth/cli", { action: "register", code });
+        spinner.stop();
+        const loginUrl = `${config.apiUrl}/login?cli_code=${code}`;
+        console.log();
+        console.log(chalk.bold("Open this URL in your browser to authenticate:"));
+        console.log();
+        console.log(chalk.cyan(loginUrl));
+        console.log();
+        // Try to open browser automatically
+        const { exec } = await import("child_process");
+        const platform = process.platform;
+        const openCmd = platform === "darwin"
+            ? "open"
+            : platform === "win32"
+                ? "start"
+                : "xdg-open";
+        exec(`${openCmd} "${loginUrl}"`);
+        const pollSpinner = ora("Waiting for authentication...").start();
+        // Poll for confirmation
+        const maxAttempts = 60;
+        for (let i = 0; i < maxAttempts; i++) {
+            await new Promise((resolve) => setTimeout(resolve, 2000));
+            try {
+                const result = await apiPost("/api/auth/cli", { action: "poll", code });
+                if (result.status === "authenticated" && result.user_id && result.token) {
+                    pollSpinner.succeed("Authenticated!");
+                    setAuth({
+                        userId: result.user_id,
+                        username: result.username ?? "",
+                        token: result.token,
+                        fullName: result.full_name,
+                        avatarUrl: result.avatar_url,
+                    });
+                    console.log();
+                    console.log(chalk.green(`Logged in as ${chalk.bold(`@${result.username}`)}`));
+                    return;
+                }
+            }
+            catch {
+                // Continue polling
+            }
+        }
+        pollSpinner.fail("Authentication timed out. Please try again.");
+    }
+    catch (error) {
+        spinner.fail("Failed to start auth flow");
+        console.error(error);
+        process.exit(1);
+    }
+});
+authCommand
+    .command("logout")
+    .description("Sign out and clear saved credentials")
+    .action(() => {
+    clearAuth();
+    console.log(chalk.green("Logged out successfully."));
+});
+authCommand
+    .command("whoami")
+    .description("Show the currently authenticated user")
+    .action(() => {
+    const config = getConfig();
+    if (!config.authenticated || !config.username) {
+        console.log(chalk.yellow("Not authenticated. Run `w42 auth login`."));
+        return;
+    }
+    console.log(chalk.green(`@${config.username}`));
+    if (config.fullName) {
+        console.log(chalk.dim(config.fullName));
+    }
+});

package/dist/commands/register.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const registerCommand: Command;

package/dist/commands/register.js

@@ -0,0 +1,61 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { requireAuth } from "../utils/config.js";
+export const registerCommand = new Command("register")
+    .description("Register an agent with the Web42 Network")
+    .argument("<url>", "Public URL of the running agent (must serve /.well-known/agent-card.json)")
+    .option("--price <cents>", "Price in cents (default: 0 = free)")
+    .option("--license <license>", "License (e.g. MIT, Apache-2.0)")
+    .option("--visibility <vis>", "Visibility: public or private", "public")
+    .option("--tags <tags>", "Comma-separated tags")
+    .option("--categories <cats>", "Comma-separated categories")
+    .action(async (url, opts) => {
+    const config = requireAuth();
+    const web42ApiUrl = config.apiUrl ?? "http://localhost:3000";
+    const spinner = ora("Registering agent...").start();
+    const body = { url };
+    if (opts.price !== undefined)
+        body.price_cents = parseInt(opts.price, 10);
+    if (opts.license)
+        body.license = opts.license;
+    if (opts.visibility)
+        body.visibility = opts.visibility;
+    if (opts.tags)
+        body.tags = opts.tags.split(",").map((t) => t.trim());
+    if (opts.categories)
+        body.categories = opts.categories.split(",").map((c) => c.trim());
+    try {
+        const res = await fetch(`${web42ApiUrl}/api/agents`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${config.token}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            const errBody = (await res.json().catch(() => ({})));
+            spinner.fail("Registration failed");
+            console.error(chalk.red(errBody.error ?? `HTTP ${res.status}`));
+            process.exit(1);
+        }
+        const data = (await res.json());
+        const slug = data.agent?.slug ?? "unknown";
+        const name = data.agent?.agent_card?.name ?? slug;
+        const displaySlug = slug.replace("~", "/");
+        if (data.created) {
+            spinner.succeed(`Registered "${name}" (${displaySlug})`);
+        }
+        else {
+            spinner.succeed(`Updated "${name}" (${displaySlug})`);
+        }
+        console.log(chalk.dim(`  Send:  w42 send ${slug} "hello"`));
+        console.log(chalk.dim(`  View:  ${web42ApiUrl}/${displaySlug.replace("@", "")}`));
+    }
+    catch (err) {
+        spinner.fail("Registration failed");
+        console.error(chalk.red(String(err)));
+        process.exit(1);
+    }
+});

package/dist/commands/search.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const searchCommand: Command;

package/dist/commands/search.js

@@ -0,0 +1,143 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { apiGet } from "../utils/api.js";
+import { getConfig } from "../utils/config.js";
+function getCardName(card) {
+    return card?.name ?? "Untitled Agent";
+}
+function getCardDescription(card) {
+    return card?.description ?? "";
+}
+function getSecurityLevel(gatewayStatus) {
+    if (gatewayStatus === "live") {
+        return "🔐 W42 Auth";
+    }
+    return "⚠️  Offline";
+}
+function terminalLink(text, url) {
+    return `\x1b]8;;${url}\x07${text}\x1b]8;;\x07`;
+}
+function wrapText(text, maxWidth, maxLines) {
+    const lines = [];
+    let currentLine = "";
+    const words = text.split(/\s+/);
+    for (const word of words) {
+        if (currentLine.length === 0) {
+            currentLine = word;
+        }
+        else if ((currentLine + " " + word).length <= maxWidth) {
+            currentLine += " " + word;
+        }
+        else {
+            lines.push(currentLine);
+            currentLine = word;
+            if (lines.length >= maxLines) {
+                break;
+            }
+        }
+    }
+    if (currentLine.length > 0) {
+        if (lines.length >= maxLines) {
+            if (lines[lines.length - 1].length + 1 + currentLine.length > maxWidth) {
+                lines[lines.length - 1] = lines[lines.length - 1].slice(0, maxWidth - 1) + "\u2026";
+            }
+            else {
+                lines[lines.length - 1] += " " + currentLine;
+            }
+        }
+        else {
+            lines.push(currentLine);
+        }
+    }
+    return lines.slice(0, maxLines);
+}
+function printAsciiLogo() {
+    const logo = chalk.bold.yellow(`$$$$$$$$ $$$$$$$ $$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ \n` +
+        `$$$$$$$$ $$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ \n` +
+        `$$$$$$$$ $$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ \n` +
+        `$$$$$$$$ $$$$$$$$$$$$ $$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ \n` +
+        `$$$$$$$$ $$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$ $$$$$$$$ \n` +
+        `$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ \n` +
+        `$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ \n` +
+        `$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ \n` +
+        `$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$ $$$$$$$$ \n` +
+        `$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ \n` +
+        `$$$$$$$$$$$$ $$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ \n` +
+        `$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ \n` +
+        ` $$$$$$$$ \n` +
+        ` $$$$$$$$ \n` +
+        ` $$$$$$$$ `);
+    console.log(logo);
+    console.log();
+}
+function printGlobalHint() {
+    const hint = `  Talk to any agent with  ${chalk.cyan(`npx @web42/w42 send <owner/agent> "your message"`)}`;
+    console.log(hint);
+    console.log();
+}
+function formatSkills(skills) {
+    if (!skills || skills.length === 0) {
+        return "";
+    }
+    const skillNames = skills.map((s) => `${s.name}`);
+    return `Skills: ${skillNames.join(" • ")}`;
+}
+export const searchCommand = new Command("search")
+    .description("Search the network for agents")
+    .argument("<query>", "Search query")
+    .option("-l, --limit <number>", "Max results to show", "10")
+    .action(async (query, opts) => {
+    const config = getConfig();
+    const spinner = ora(`Searching for "${query}"...`).start();
+    try {
+        const agents = await apiGet(`/api/agents?search=${encodeURIComponent(query)}`);
+        spinner.stop();
+        if (agents.length === 0) {
+            console.log(chalk.yellow(`No agents found for "${query}".`));
+            return;
+        }
+        const limit = parseInt(opts.limit, 10) || 10;
+        const results = agents.slice(0, limit);
+        printAsciiLogo();
+        printGlobalHint();
+        for (const agent of results) {
+            const name = getCardName(agent.agent_card);
+            const description = getCardDescription(agent.agent_card);
+            const username = agent.owner.username;
+            const security = getSecurityLevel(agent.gateway_status);
+            const stars = agent.stars_count > 0 ? `★ ${agent.stars_count}` : "";
+            const skills = formatSkills(agent.agent_card.skills);
+            // Header: - <name (link)> | <@username (link)> | <security> | <stars>
+            const nameLink = chalk.bold.cyan(terminalLink(name, `${config.apiUrl}/${username}/${agent.slug.split("~")[1] ?? agent.slug}`));
+            const usernameLink = chalk.dim(terminalLink(`@${username}`, `${config.apiUrl}/${username}`));
+            const separator = chalk.dim(" | ");
+            const headerParts = [nameLink, usernameLink, security];
+            if (stars)
+                headerParts.push(chalk.yellow(stars));
+            console.log(`- ${headerParts.join(separator)}`);
+            // Description (2 lines max, 72 chars wide)
+            if (description) {
+                const wrapped = wrapText(description, 72, 2);
+                for (const line of wrapped) {
+                    console.log(`  ${line}`);
+                }
+            }
+            // Skills
+            if (skills) {
+                console.log(`  ${skills}`);
+            }
+            // Send command
+            console.log(`  ${chalk.dim("└")} ${chalk.cyan(`w42 send ${agent.slug} "hello"`)}`);
+            console.log();
+        }
+        if (agents.length > limit) {
+            console.log(chalk.dim(`  ... and ${agents.length - limit} more. Use --limit to see more.`));
+        }
+    }
+    catch (error) {
+        spinner.fail("Search failed");
+        console.error(chalk.red(String(error)));
+        process.exit(1);
+    }
+});

package/dist/commands/send.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const sendCommand: Command;

package/dist/commands/send.js

@@ -0,0 +1,165 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { v4 as uuidv4 } from "uuid";
+import { requireAuth, setConfigValue, getConfigValue } from "../utils/config.js";
+import { apiPost } from "../utils/api.js";
+function isUrl(s) {
+    return s.startsWith("http://") || s.startsWith("https://");
+}
+function getCachedToken(slug) {
+    const raw = getConfigValue(`agentTokens.${slug}`);
+    if (!raw)
+        return null;
+    try {
+        const cached = typeof raw === "string" ? JSON.parse(raw) : raw;
+        if (new Date(cached.expiresAt) <= new Date())
+            return null;
+        return cached;
+    }
+    catch {
+        return null;
+    }
+}
+export const sendCommand = new Command("send")
+    .description("Send a message to an A2A agent")
+    .argument("<agent>", "Agent slug (e.g. @yan/richard) or direct URL (http://localhost:3001)")
+    .argument("<message>", "Message to send")
+    .option("--new", "Start a new conversation (clears saved context)")
+    .option("--context <id>", "Use a specific context ID")
+    .action(async (rawAgent, userMessage, opts) => {
+    // Normalize slug: @user/name → @user~name (DB format)
+    const agent = rawAgent.includes("/") && !isUrl(rawAgent)
+        ? rawAgent.replace("/", "~")
+        : rawAgent;
+    const config = requireAuth();
+    let agentUrl;
+    let bearerToken;
+    let agentKey;
+    if (isUrl(agent)) {
+        // Direct URL mode — local development, no handshake needed
+        agentUrl = agent;
+        bearerToken = config.token;
+        agentKey = new URL(agent).host.replace(/[.:]/g, "-");
+    }
+    else {
+        // Slug mode — handshake with Web42 Network platform
+        agentKey = agent;
+        const cached = getCachedToken(agent);
+        if (cached) {
+            agentUrl = cached.agentUrl;
+            bearerToken = cached.token;
+        }
+        else {
+            const spinner = ora(`Authenticating with ${agent}...`).start();
+            try {
+                const res = await apiPost("/api/auth/handshake", {
+                    agentSlug: agent,
+                });
+                agentUrl = res.agentUrl;
+                bearerToken = res.token;
+                setConfigValue(`agentTokens.${agent}`, JSON.stringify({
+                    token: res.token,
+                    agentUrl: res.agentUrl,
+                    expiresAt: res.expiresAt,
+                }));
+                spinner.succeed(`Authenticated with ${agent}`);
+            }
+            catch (err) {
+                spinner.fail(`Failed to authenticate with ${agent}`);
+                console.error(chalk.red(String(err)));
+                process.exit(1);
+            }
+        }
+    }
+    // Resolve contextId
+    const contextKey = `context.${agentKey}`;
+    let contextId;
+    if (opts.context) {
+        contextId = opts.context;
+    }
+    else if (opts.new) {
+        contextId = uuidv4();
+    }
+    else {
+        contextId = getConfigValue(contextKey) ?? uuidv4();
+    }
+    setConfigValue(contextKey, contextId);
+    // Dynamically import @a2a-js/sdk client
+    let ClientFactory;
+    let JsonRpcTransportFactory;
+    let ClientFactoryOptions;
+    try {
+        const clientModule = await import("@a2a-js/sdk/client");
+        ClientFactory = clientModule.ClientFactory;
+        JsonRpcTransportFactory = clientModule.JsonRpcTransportFactory;
+        ClientFactoryOptions = clientModule.ClientFactoryOptions;
+    }
+    catch {
+        console.error(chalk.red("Failed to load @a2a-js/sdk. Run: pnpm add @a2a-js/sdk"));
+        process.exit(1);
+    }
+    const bearerInterceptor = {
+        before: async (args) => {
+            if (!args.options)
+                args.options = {};
+            args.options.serviceParameters = {
+                ...(args.options.serviceParameters ?? {}),
+                Authorization: `Bearer ${bearerToken}`,
+            };
+        },
+        after: async () => { },
+    };
+    const connectSpinner = ora(`Connecting to ${agentKey}...`).start();
+    let client;
+    try {
+        const factory = new ClientFactory(ClientFactoryOptions.createFrom(ClientFactoryOptions.default, {
+            transports: [new JsonRpcTransportFactory()],
+            clientConfig: {
+                interceptors: [bearerInterceptor],
+            },
+        }));
+        const a2aBaseUrl = new URL(agentUrl).origin;
+        client = await factory.createFromUrl(a2aBaseUrl);
+        connectSpinner.stop();
+    }
+    catch {
+        connectSpinner.fail(`Could not reach agent at ${agentUrl}`);
+        console.error(chalk.dim("Is the agent server running?"));
+        process.exit(1);
+    }
+    try {
+        const stream = client.sendMessageStream({
+            message: {
+                messageId: uuidv4(),
+                role: "user",
+                parts: [{ kind: "text", text: userMessage }],
+                kind: "message",
+                contextId,
+            },
+        });
+        for await (const event of stream) {
+            if (event.kind === "artifact-update") {
+                const artifact = event.artifact;
+                const text = (artifact.parts ?? [])
+                    .filter((p) => p.kind === "text")
+                    .map((p) => p.text ?? "")
+                    .join("");
+                if (text)
+                    process.stdout.write(text);
+            }
+            if (event.kind === "status-update") {
+                const update = event;
+                if (update.status?.state === "failed") {
+                    console.error(chalk.red("\nAgent returned an error."));
+                    process.exit(1);
+                }
+            }
+        }
+        process.stdout.write("\n");
+    }
+    catch (err) {
+        console.error(chalk.red("\nConnection lost."), chalk.dim(String(err)));
+        process.exit(1);
+    }
+});

package/dist/commands/serve.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const serveCommand: Command;