@web42/cli 0.2.8 → 0.2.10

package/dist/commands/serve.js

@@ -1,3 +1,5 @@
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
 import { Command } from "commander";
 import chalk from "chalk";
 import ora from "ora";
@@ -5,23 +7,93 @@ import express from "express";
 import { agentCardHandler, jsonRpcHandler, } from "@a2a-js/sdk/server/express";
 import { DefaultRequestHandler, InMemoryTaskStore, } from "@a2a-js/sdk/server";
 import { requireAuth, getConfig } from "../utils/config.js";
-// ---------------------------------------------------------------------------
-// StdinExecutor — generic executor that pipes user messages to a subprocess
-// ---------------------------------------------------------------------------
-class EchoExecutor {
+class OpenClawAgentExecutor {
+    opts;
+    verbose;
+    constructor(opts) {
+        this.opts = opts;
+        this.verbose = opts.verbose ?? false;
+    }
     async execute(requestContext, eventBus) {
         const { taskId, contextId, userMessage } = requestContext;
         const userText = userMessage.parts
             .find((p) => p.kind === "text")?.text ?? "";
-        eventBus.publish({
-            kind: "artifact-update",
-            taskId,
-            contextId,
-            artifact: {
-                artifactId: "response",
-                parts: [{ kind: "text", text: `Echo: ${userText}` }],
-            },
-        });
+        if (this.verbose) {
+            console.log(chalk.gray(`[verbose] → OpenClaw request: agent=${this.opts.openClawAgent} session=${contextId} port=${this.opts.openClawPort}`));
+            console.log(chalk.gray(`[verbose] → message text: "${userText.slice(0, 100)}"`));
+        }
+        let response;
+        try {
+            response = await fetch(`http://localhost:${this.opts.openClawPort}/v1/chat/completions`, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${this.opts.openClawToken}`,
+                    "Content-Type": "application/json",
+                    "x-openclaw-agent-id": this.opts.openClawAgent,
+                    "x-openclaw-session-key": `agent:${this.opts.openClawAgent}:${contextId}`,
+                },
+                body: JSON.stringify({
+                    model: "openclaw",
+                    stream: true,
+                    messages: [{ role: "user", content: userText }],
+                }),
+            });
+        }
+        catch (err) {
+            throw new Error(`OpenClaw is not reachable on port ${this.opts.openClawPort}. ` +
+                `Make sure it is running with chatCompletions enabled. (${String(err)})`);
+        }
+        if (this.verbose) {
+            console.log(chalk.gray(`[verbose] ← OpenClaw response: status=${response.status}`));
+        }
+        if (!response.ok) {
+            if (this.verbose) {
+                const body = await response.text().catch(() => "(unreadable)");
+                console.log(chalk.gray(`[verbose] ← response body: ${body}`));
+            }
+            throw new Error(`OpenClaw error: ${response.status} ${response.statusText}`);
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        let tokenCount = 0;
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+                if (!line.startsWith("data: "))
+                    continue;
+                const data = line.slice(6).trim();
+                if (data === "[DONE]")
+                    continue;
+                try {
+                    const chunk = JSON.parse(data);
+                    const token = chunk.choices?.[0]?.delta?.content;
+                    if (token) {
+                        tokenCount++;
+                        eventBus.publish({
+                            kind: "artifact-update",
+                            taskId,
+                            contextId,
+                            artifact: {
+                                artifactId: "response",
+                                parts: [{ kind: "text", text: token }],
+                            },
+                        });
+                    }
+                }
+                catch {
+                    // ignore malformed SSE lines
+                }
+            }
+        }
+        if (this.verbose) {
+            console.log(chalk.gray(`[verbose] ← stream complete: ${tokenCount} tokens received`));
+        }
         eventBus.publish({
             kind: "status-update",
             taskId,
@@ -34,17 +106,46 @@ class EchoExecutor {
     cancelTask = async () => { };
 }
 // ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+async function publishLiveUrl({ apiUrl, token, slug, a2aUrl, enabled, gatewayStatus, }) {
+    try {
+        const res = await fetch(`${apiUrl}/api/agents/${slug}/a2a`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${token}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ a2a_url: a2aUrl, a2a_enabled: enabled, gateway_status: gatewayStatus }),
+        });
+        if (!res.ok) {
+            const errBody = await res.json().catch(() => ({}));
+            console.warn(chalk.yellow(`  Could not register URL with marketplace: ${errBody.error ?? res.status}`));
+        }
+        else {
+            console.log(chalk.dim("  Registered with marketplace"));
+        }
+    }
+    catch (err) {
+        console.warn(chalk.yellow(`  Could not register URL with marketplace: ${String(err)}`));
+    }
+}
+// ---------------------------------------------------------------------------
 // Command
 // ---------------------------------------------------------------------------
 export const serveCommand = new Command("serve")
     .description("Start a local A2A server for your agent")
     .option("--port <port>", "Port to listen on", "4000")
-    .option("--url <url>", "Public URL (e.g. from ngrok) shown in logs and AgentCard")
+    .option("--url <url>", "Public URL (e.g. from ngrok) for registration and AgentCard")
+    .option("--openclaw-port <port>", "OpenClaw gateway port", "18789")
+    .option("--openclaw-token <token>", "OpenClaw gateway auth token (or set OPENCLAW_GATEWAY_TOKEN)")
+    .option("--openclaw-agent <id>", "OpenClaw agent ID to target", "main")
     .option("--client-id <id>", "Developer app client ID (or set WEB42_CLIENT_ID)")
     .option("--client-secret <secret>", "Developer app client secret (or set WEB42_CLIENT_SECRET)")
     .option("--verbose", "Enable verbose request/response logging")
     .action(async (opts) => {
     const verbose = opts.verbose ?? false;
+    // 1. Must be logged into web42
     let token;
     try {
         const authConfig = requireAuth();
@@ -63,33 +164,56 @@ export const serveCommand = new Command("serve")
             "  Create them at: https://web42.ai/settings/developer-apps"));
         process.exit(1);
     }
+    const openClawPort = parseInt(opts.openclawPort, 10);
+    const openClawToken = opts.openclawToken ?? process.env.OPENCLAW_GATEWAY_TOKEN ?? "";
+    const openClawAgent = opts.openclawAgent;
+    const cwd = process.cwd();
     const port = parseInt(opts.port, 10);
     const publicUrl = opts.url;
     const config = getConfig();
     const web42ApiUrl = config.apiUrl ?? "https://web42.ai";
-    const agentName = "Local Agent";
-    const agentDescription = "";
-    const agentVersion = "1.0.0";
-    const skills = [];
+    // 2. Read agent-card.json from cwd
+    const cardPath = join(cwd, "agent-card.json");
+    if (!existsSync(cardPath)) {
+        console.error(chalk.red("No agent-card.json found in current directory."));
+        console.error(chalk.dim("Create an agent-card.json with your agent's A2A card."));
+        process.exit(1);
+    }
+    let cardData;
+    try {
+        cardData = JSON.parse(readFileSync(cardPath, "utf-8"));
+    }
+    catch {
+        console.error(chalk.red("Failed to parse agent-card.json."));
+        process.exit(1);
+    }
+    const agentName = cardData.name ?? "Untitled Agent";
+    if (!agentName || agentName === "Untitled Agent") {
+        console.error(chalk.red('agent-card.json must have a "name" field.'));
+        process.exit(1);
+    }
     const spinner = ora("Starting A2A server...").start();
+    // 3. Build AgentCard from local file + overrides
     const agentCard = {
         name: agentName,
-        description: agentDescription,
-        protocolVersion: "0.3.0",
-        version: agentVersion,
+        description: cardData.description ?? "",
+        protocolVersion: cardData.protocolVersion ?? "0.3.0",
+        version: cardData.version ?? "1.0.0",
         url: `${publicUrl ?? `http://localhost:${port}`}/a2a/jsonrpc`,
-        skills,
+        skills: cardData.skills ?? [],
         capabilities: {
             streaming: true,
             pushNotifications: false,
+            ...(cardData.capabilities ?? {}),
         },
-        defaultInputModes: ["text"],
-        defaultOutputModes: ["text"],
+        defaultInputModes: cardData.defaultInputModes ?? ["text"],
+        defaultOutputModes: cardData.defaultOutputModes ?? ["text"],
         securitySchemes: {
             Web42Bearer: { type: "http", scheme: "bearer" },
         },
         security: [{ Web42Bearer: [] }],
     };
+    // 4. Start Express server
     const app = express();
     // Auth: validate caller's Bearer token via Web42 introspection with Basic auth
     const basicAuth = `Basic ${Buffer.from(`${clientId}:${clientSecret}`).toString("base64")}`;
@@ -121,27 +245,18 @@ export const serveCommand = new Command("serve")
             get userName() { return result.sub ?? ""; },
         };
     };
-    const executor = new EchoExecutor();
+    const executor = new OpenClawAgentExecutor({
+        openClawPort,
+        openClawToken,
+        openClawAgent,
+        verbose,
+    });
     const requestHandler = new DefaultRequestHandler(agentCard, new InMemoryTaskStore(), executor);
+    // 5. Mount A2A SDK handlers
     app.use("/.well-known/agent-card.json", agentCardHandler({ agentCardProvider: requestHandler }));
     app.use("/a2a/jsonrpc", jsonRpcHandler({ requestHandler, userBuilder }));
     const a2aUrl = `${publicUrl ?? `http://localhost:${port}`}/a2a/jsonrpc`;
-    // Auto-register agent with directory
-    const registrationUrl = opts.url ?? `http://localhost:${port}`;
-    try {
-        await fetch(`${web42ApiUrl}/api/agents`, {
-            method: "POST",
-            headers: {
-                Authorization: `Bearer ${token}`,
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify({ url: registrationUrl }),
-        });
-        console.log(chalk.dim("  Pre-registered with marketplace"));
-    }
-    catch {
-        console.warn(chalk.yellow("  Could not pre-register with marketplace"));
-    }
+    // 6. Start listening, then register
     app.listen(port, async () => {
         spinner.stop();
         console.log(chalk.green(`\n Agent "${agentName}" is live`));
@@ -150,34 +265,63 @@ export const serveCommand = new Command("serve")
             console.log(chalk.dim(`  Public:     ${publicUrl}`));
         console.log(chalk.dim(`  Agent card: http://localhost:${port}/.well-known/agent-card.json`));
         console.log(chalk.dim(`  JSON-RPC:   http://localhost:${port}/a2a/jsonrpc`));
-        // Register live URL with marketplace
+        if (verbose) {
+            console.log(chalk.gray(`[verbose] OpenClaw target: http://localhost:${openClawPort}/v1/chat/completions agent=${openClawAgent}`));
+        }
+        // Register agent with marketplace — API crawls back to fetch the card
+        const registrationUrl = publicUrl ?? `http://localhost:${port}`;
+        let registeredSlug = null;
         try {
-            await fetch(`${web42ApiUrl}/api/agents/${agentName}/a2a`, {
+            const regRes = await fetch(`${web42ApiUrl}/api/agents`, {
                 method: "POST",
                 headers: {
                     Authorization: `Bearer ${token}`,
                     "Content-Type": "application/json",
                 },
-                body: JSON.stringify({
-                    a2a_url: a2aUrl,
-                    a2a_enabled: true,
-                    gateway_status: "live",
-                }),
+                body: JSON.stringify({ url: registrationUrl }),
+            });
+            if (regRes.ok) {
+                const regData = (await regRes.json());
+                registeredSlug = regData.agent?.slug ?? null;
+                console.log(chalk.dim(`  Registered with marketplace (slug: ${registeredSlug})`));
+            }
+            else {
+                const errBody = await regRes.json().catch(() => ({}));
+                console.warn(chalk.yellow(`  Could not register with marketplace: ${errBody.error ?? regRes.status}`));
+            }
+        }
+        catch (err) {
+            console.warn(chalk.yellow(`  Could not register with marketplace: ${String(err)}`));
+        }
+        // Publish live A2A URL
+        if (registeredSlug) {
+            await publishLiveUrl({
+                apiUrl: web42ApiUrl,
+                token,
+                slug: registeredSlug,
+                a2aUrl,
+                enabled: true,
+                gatewayStatus: "live",
             });
-            console.log(chalk.dim("  Registered with marketplace"));
         }
-        catch {
-            console.warn(chalk.yellow("  Could not register with marketplace"));
+        if (!publicUrl) {
+            console.log(chalk.yellow("  No --url provided. Registered localhost URL is not publicly reachable."));
         }
         console.log(chalk.dim("\nWaiting for requests... (Ctrl+C to stop)\n"));
-    });
-    process.on("SIGINT", async () => {
-        console.log(chalk.dim("\nShutting down..."));
-        await fetch(`${web42ApiUrl}/api/agents/${agentName}/a2a`, {
-            method: "POST",
-            headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
-            body: JSON.stringify({ a2a_url: null, a2a_enabled: false, gateway_status: "offline" }),
-        }).catch(() => { });
-        process.exit(0);
+        // 7. Graceful shutdown
+        process.on("SIGINT", async () => {
+            console.log(chalk.dim("\nShutting down..."));
+            if (registeredSlug) {
+                await publishLiveUrl({
+                    apiUrl: web42ApiUrl,
+                    token,
+                    slug: registeredSlug,
+                    a2aUrl: null,
+                    enabled: false,
+                    gatewayStatus: "offline",
+                }).catch(() => { });
+            }
+            process.exit(0);
+        });
     });
 });

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const CLI_VERSION = "0.2.8";
+export declare const CLI_VERSION = "0.2.10";

package/dist/version.js

@@ -1 +1 @@
-export const CLI_VERSION = "0.2.8";
+export const CLI_VERSION = "0.2.10";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@web42/cli",
-  "version": "0.2.8",
+  "version": "0.2.10",
   "description": "CLI for the Web42 Agent Marketplace - push, install, and remix OpenClaw agent packages",
   "type": "module",
   "bin": {