@web42/cli 0.2.6 → 0.2.8

package/dist/commands/search.js

@@ -2,6 +2,16 @@ import { Command } from "commander";
 import chalk from "chalk";
 import ora from "ora";
 import { apiGet } from "../utils/api.js";
+function getCardName(card) {
+    return card?.name ?? "Untitled Agent";
+}
+function getCardDescription(card) {
+    return card?.description ?? "";
+}
+function getMarketplacePrice(card) {
+    const ext = card?.capabilities?.extensions?.find((e) => e.uri === "https://web42.ai/ext/marketplace/v1");
+    return ext?.params?.price_cents ?? 0;
+}
 function truncate(str, max) {
     if (str.length <= max)
         return str;
@@ -10,7 +20,6 @@ function truncate(str, max) {
 export const searchCommand = new Command("search")
     .description("Search the marketplace for agents")
     .argument("<query>", "Search query")
-    .option("-p, --platform <platform>", "Filter results by platform (e.g. openclaw)")
     .option("-l, --limit <number>", "Max results to show", "10")
     .action(async (query, opts) => {
     const spinner = ora(`Searching for "${query}"...`).start();
@@ -26,24 +35,20 @@ export const searchCommand = new Command("search")
         console.log(chalk.bold(`Found ${agents.length} agent(s) for "${query}":`));
         console.log();
         for (const agent of results) {
+            const name = getCardName(agent.agent_card);
+            const description = getCardDescription(agent.agent_card);
+            const priceCents = getMarketplacePrice(agent.agent_card);
             const ref = `@${agent.owner.username}/${agent.slug}`;
             const stars = agent.stars_count > 0 ? chalk.yellow(` \u2605 ${agent.stars_count}`) : "";
-            const price = agent.price_cents > 0
-                ? chalk.green(` $${(agent.price_cents / 100).toFixed(2)}`)
+            const price = priceCents > 0
+                ? chalk.green(` $${(priceCents / 100).toFixed(2)}`)
                 : chalk.dim(" Free");
-            console.log(`  ${chalk.cyan.bold(agent.name)}${stars}${price}`);
+            console.log(`  ${chalk.cyan.bold(name)}${stars}${price}`);
             console.log(`  ${chalk.dim(ref)}`);
-            if (agent.description) {
-                console.log(`  ${truncate(agent.description, 80)}`);
-            }
-            const platform = agent.manifest?.platform ?? "openclaw";
-            if (agent.price_cents > 0) {
-                const siteUrl = process.env.WEB42_API_URL ?? "https://web42.ai";
-                console.log(chalk.dim(`  Purchase: ${siteUrl}/${agent.owner.username}/${agent.slug}`));
-            }
-            else {
-                console.log(chalk.dim(`  Install: web42 ${platform} install ${ref}`));
+            if (description) {
+                console.log(`  ${truncate(description, 80)}`);
             }
+            console.log(chalk.dim(`  Send: web42 send ${agent.slug} "hello"`));
             console.log();
         }
         if (agents.length > limit) {
@@ -52,7 +57,7 @@ export const searchCommand = new Command("search")
     }
     catch (error) {
         spinner.fail("Search failed");
-        console.error(chalk.red(error.message));
+        console.error(chalk.red(String(error)));
         process.exit(1);
     }
 });

package/dist/commands/send.js

@@ -3,44 +3,85 @@ import chalk from "chalk";
 import ora from "ora";
 import { v4 as uuidv4 } from "uuid";
 import { requireAuth, setConfigValue, getConfigValue } from "../utils/config.js";
-import { apiGet } from "../utils/api.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 a live web42 agent")
-    .argument("<agent>", "Agent handle, e.g. @javier/gilfoyle")
+    .description("Send a message to an A2A agent")
+    .argument("<agent>", "Agent slug (e.g. my-agent) or direct URL (http://localhost:3001)")
     .argument("<message>", "Message to send")
     .option("--new", "Start a new conversation (clears saved context)")
-    .action(async (agentHandle, userMessage, opts) => {
+    .option("--context <id>", "Use a specific context ID")
+    .action(async (agent, userMessage, opts) => {
     const config = requireAuth();
-    // 1. Parse @user/slug
-    const match = agentHandle.match(/^@?([\w-]+)\/([\w-]+)$/);
-    if (!match) {
-        console.error(chalk.red("Invalid agent handle. Expected format: @user/agent-slug"));
-        process.exit(1);
-    }
-    const [, username, slug] = match;
-    // 2. Look up agent A2A URL from marketplace
-    const spinner = ora(`Looking up @${username}/${slug}...`).start();
-    let a2aData;
-    try {
-        a2aData = await apiGet(`/api/agents/${slug}/a2a`);
+    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, "-");
     }
-    catch {
-        spinner.fail(`Agent @${username}/${slug} not found`);
-        process.exit(1);
+    else {
+        // Slug mode — handshake with Web42 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);
+            }
+        }
     }
-    if (!a2aData.a2a_enabled || !a2aData.a2a_url) {
-        spinner.fail(`@${username}/${slug} is not live. Publisher must run: web42 serve --url <url>`);
-        process.exit(1);
+    // Resolve contextId
+    const contextKey = `context.${agentKey}`;
+    let contextId;
+    if (opts.context) {
+        contextId = opts.context;
     }
-    spinner.stop();
-    // 3. Resolve contextId — reuse existing session or start fresh
-    const contextKey = `context.${username}.${slug}`;
-    let contextId = getConfigValue(contextKey) ?? uuidv4();
-    if (opts.new) {
+    else if (opts.new) {
         contextId = uuidv4();
     }
+    else {
+        contextId = getConfigValue(contextKey) ?? uuidv4();
+    }
     setConfigValue(contextKey, contextId);
-    // 4. Dynamically import @a2a-js/sdk client (ESM)
+    // Dynamically import @a2a-js/sdk client
     let ClientFactory;
     let JsonRpcTransportFactory;
     let ClientFactoryOptions;
@@ -54,22 +95,18 @@ export const sendCommand = new Command("send")
         console.error(chalk.red("Failed to load @a2a-js/sdk. Run: pnpm add @a2a-js/sdk"));
         process.exit(1);
     }
-    // 5. Bearer token interceptor
-    const token = config.token;
     const bearerInterceptor = {
         before: async (args) => {
-            if (!args.options) {
+            if (!args.options)
                 args.options = {};
-            }
             args.options.serviceParameters = {
                 ...(args.options.serviceParameters ?? {}),
-                Authorization: `Bearer ${token}`,
+                Authorization: `Bearer ${bearerToken}`,
             };
         },
         after: async () => { },
     };
-    // 6. Create A2A client
-    const connectSpinner = ora(`Connecting to @${username}/${slug}...`).start();
+    const connectSpinner = ora(`Connecting to ${agentKey}...`).start();
     let client;
     try {
         const factory = new ClientFactory(ClientFactoryOptions.createFrom(ClientFactoryOptions.default, {
@@ -78,18 +115,15 @@ export const sendCommand = new Command("send")
                 interceptors: [bearerInterceptor],
             },
         }));
-        // a2aData.a2a_url is the full JSON-RPC endpoint, e.g. https://foo.ngrok.dev/a2a/jsonrpc
-        // createFromUrl needs the base URL; it will append /.well-known/agent-card.json itself
-        const a2aBaseUrl = new URL(a2aData.a2a_url).origin;
+        const a2aBaseUrl = new URL(agentUrl).origin;
         client = await factory.createFromUrl(a2aBaseUrl);
         connectSpinner.stop();
     }
     catch {
-        connectSpinner.fail(`Could not reach agent at ${a2aData.a2a_url}`);
-        console.error(chalk.dim("Is the publisher running web42 serve? Is ngrok still active?"));
+        connectSpinner.fail(`Could not reach agent at ${agentUrl}`);
+        console.error(chalk.dim("Is the agent server running?"));
         process.exit(1);
     }
-    // 7. Stream response to stdout
     try {
         const stream = client.sendMessageStream({
             message: {

package/dist/commands/serve.d.ts

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

package/dist/commands/serve.js

@@ -1,105 +1,32 @@
-import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-import { Command } from 'commander';
-import chalk from 'chalk';
-import ora from 'ora';
-import express from 'express';
-import { agentCardHandler, jsonRpcHandler, } from '@a2a-js/sdk/server/express';
-import { DefaultRequestHandler, InMemoryTaskStore, } from '@a2a-js/sdk/server';
-import { requireAuth } from '../utils/config.js';
-import { getConfig } from '../utils/config.js';
-class OpenClawAgentExecutor {
-    opts;
-    verbose;
-    constructor(opts) {
-        this.opts = opts;
-        this.verbose = opts.verbose ?? false;
-    }
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+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 {
     async execute(requestContext, eventBus) {
         const { taskId, contextId, userMessage } = requestContext;
         const userText = userMessage.parts
-            .find((p) => p.kind === 'text')?.text ?? '';
-        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': 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`));
-        }
+            .find((p) => p.kind === "text")?.text ?? "";
         eventBus.publish({
-            kind: 'status-update',
+            kind: "artifact-update",
             taskId,
             contextId,
-            status: { state: 'completed', timestamp: new Date().toISOString() },
+            artifact: {
+                artifactId: "response",
+                parts: [{ kind: "text", text: `Echo: ${userText}` }],
+            },
+        });
+        eventBus.publish({
+            kind: "status-update",
+            taskId,
+            contextId,
+            status: { state: "completed", timestamp: new Date().toISOString() },
             final: true,
         });
         eventBus.finished();
@@ -107,174 +34,150 @@ class OpenClawAgentExecutor {
     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) {
-            console.warn(chalk.yellow(`⚠ Could not register URL with marketplace: ${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('--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('--verbose', 'Enable verbose request/response logging')
+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("--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();
         token = authConfig.token;
     }
     catch {
-        console.error(chalk.red('Not authenticated. Run `web42 auth login` first.'));
-        process.exit(1);
-    }
-    const cwd = process.cwd();
-    const port = parseInt(opts.port, 10);
-    const openClawPort = parseInt(opts.openclawPort, 10);
-    const openClawToken = opts.openclawToken ?? process.env.OPENCLAW_GATEWAY_TOKEN ?? '';
-    const openClawAgent = opts.openclawAgent;
-    const publicUrl = opts.url;
-    // 2. Read manifest.json
-    const manifestPath = join(cwd, 'manifest.json');
-    if (!existsSync(manifestPath)) {
-        console.error(chalk.red('No manifest.json found in current directory.'));
-        console.error(chalk.dim('Run `web42 init` to create one.'));
-        process.exit(1);
-    }
-    let manifest;
-    try {
-        manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
-    }
-    catch {
-        console.error(chalk.red('Failed to parse manifest.json.'));
+        console.error(chalk.red("Not authenticated. Run `web42 auth login` first."));
         process.exit(1);
     }
-    if (!manifest.name) {
-        console.error(chalk.red('manifest.json must have a "name" field.'));
+    const clientId = opts.clientId ?? process.env.WEB42_CLIENT_ID;
+    const clientSecret = opts.clientSecret ?? process.env.WEB42_CLIENT_SECRET;
+    if (!clientId || !clientSecret) {
+        console.error(chalk.red("Developer app credentials required.\n" +
+            "  Provide --client-id and --client-secret flags,\n" +
+            "  or set WEB42_CLIENT_ID and WEB42_CLIENT_SECRET env vars.\n" +
+            "  Create them at: https://web42.ai/settings/developer-apps"));
         process.exit(1);
     }
+    const port = parseInt(opts.port, 10);
+    const publicUrl = opts.url;
     const config = getConfig();
-    const web42ApiUrl = config.apiUrl ?? 'https://web42.ai';
-    const spinner = ora('Starting A2A server...').start();
-    // 3. Build AgentCard from manifest
+    const web42ApiUrl = config.apiUrl ?? "https://web42.ai";
+    const agentName = "Local Agent";
+    const agentDescription = "";
+    const agentVersion = "1.0.0";
+    const skills = [];
+    const spinner = ora("Starting A2A server...").start();
     const agentCard = {
-        name: manifest.name,
-        description: manifest.description ?? '',
-        protocolVersion: '0.3.0',
-        version: manifest.version ?? '1.0.0',
+        name: agentName,
+        description: agentDescription,
+        protocolVersion: "0.3.0",
+        version: agentVersion,
         url: `${publicUrl ?? `http://localhost:${port}`}/a2a/jsonrpc`,
-        skills: (manifest.skills ?? []).map((s) => ({
-            id: s.name.toLowerCase().replace(/\s+/g, '-'),
-            name: s.name,
-            description: s.description ?? '',
-            tags: [],
-        })),
+        skills,
         capabilities: {
             streaming: true,
             pushNotifications: false,
         },
-        defaultInputModes: ['text'],
-        defaultOutputModes: ['text'],
+        defaultInputModes: ["text"],
+        defaultOutputModes: ["text"],
         securitySchemes: {
-            Web42Bearer: { type: 'http', scheme: 'bearer' },
+            Web42Bearer: { type: "http", scheme: "bearer" },
         },
         security: [{ Web42Bearer: [] }],
     };
-    // 4. Start Express server
     const app = express();
-    // Auth: validate caller's web42 Bearer token against marketplace introspect endpoint
+    // Auth: validate caller's Bearer token via Web42 introspection with Basic auth
+    const basicAuth = `Basic ${Buffer.from(`${clientId}:${clientSecret}`).toString("base64")}`;
     const userBuilder = async (req) => {
-        const callerToken = req.headers.authorization?.split(' ')[1];
+        const callerToken = req.headers.authorization?.split(" ")[1];
         if (!callerToken)
-            throw new Error('Missing token');
+            throw new Error("Missing token");
         if (verbose) {
-            const masked = `${callerToken.slice(0, 8)}...`;
-            console.log(chalk.gray(`[verbose] userBuilder: token=${masked} → introspecting...`));
+            console.log(chalk.gray(`[verbose] Introspecting token ${callerToken.slice(0, 8)}...`));
         }
         const res = await fetch(`${web42ApiUrl}/api/auth/introspect`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ token: callerToken }),
+            method: "POST",
+            headers: {
+                Authorization: basicAuth,
+                "Content-Type": "application/x-www-form-urlencoded",
+            },
+            body: new URLSearchParams({ token: callerToken }),
         });
         if (!res.ok)
-            throw new Error('Introspect call failed');
+            throw new Error("Introspect call failed");
         const result = (await res.json());
         if (verbose) {
-            console.log(chalk.gray(`[verbose] userBuilder: token=${callerToken.slice(0, 8)}... → active=${result.active} sub=${result.sub ?? '(none)'}`));
+            console.log(chalk.gray(`[verbose] active=${result.active} sub=${result.sub ?? "(none)"}`));
         }
         if (!result.active)
-            throw new Error('Unauthorized');
-        const userId = result.sub ?? '';
+            throw new Error("Unauthorized");
         return {
             get isAuthenticated() { return true; },
-            get userName() { return userId; },
+            get userName() { return result.sub ?? ""; },
         };
     };
-    const executor = new OpenClawAgentExecutor({ openClawPort, openClawToken, openClawAgent, verbose });
+    const executor = new EchoExecutor();
     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 }));
+    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`;
-    // 6. Start listening
+    // 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"));
+    }
     app.listen(port, async () => {
         spinner.stop();
-        console.log(chalk.green(`\n✓ Agent "${manifest.name}" is live`));
-        console.log(chalk.dim(`  Local:  http://localhost:${port}`));
+        console.log(chalk.green(`\n Agent "${agentName}" is live`));
+        console.log(chalk.dim(`  Local:      http://localhost:${port}`));
         if (publicUrl)
-            console.log(chalk.dim(`  Public: ${publicUrl}`));
+            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`));
-        if (verbose) {
-            console.log(chalk.gray(`[verbose] agent card url: http://localhost:${port}/.well-known/agent-card.json`));
-            console.log(chalk.gray(`[verbose] openclaw target: http://localhost:${openClawPort}/v1/chat/completions agent=${openClawAgent}`));
+        // Register live URL with marketplace
+        try {
+            await fetch(`${web42ApiUrl}/api/agents/${agentName}/a2a`, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    a2a_url: a2aUrl,
+                    a2a_enabled: true,
+                    gateway_status: "live",
+                }),
+            });
+            console.log(chalk.dim("  Registered with marketplace"));
         }
-        await publishLiveUrl({
-            apiUrl: web42ApiUrl,
-            token,
-            slug: manifest.name,
-            a2aUrl,
-            enabled: true,
-            gatewayStatus: 'live',
-        });
-        if (!publicUrl) {
-            console.log(chalk.yellow('  ⚠ No --url provided. Registered localhost URL is not publicly reachable; buyers cannot connect.'));
+        catch {
+            console.warn(chalk.yellow("  Could not register with marketplace"));
         }
-        console.log(chalk.dim('\nWaiting for requests... (Ctrl+C to stop)\n'));
+        console.log(chalk.dim("\nWaiting for requests... (Ctrl+C to stop)\n"));
     });
-    // 7. Keep process alive
-    process.on('SIGINT', async () => {
-        console.log(chalk.dim('\nShutting down...'));
-        await fetch(`${web42ApiUrl}/api/agents/${manifest.name}/a2a`, {
-            method: 'POST',
-            headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
-            body: JSON.stringify({ a2a_url: null, a2a_enabled: false, gateway_status: 'offline' }),
-        }).catch(() => { }); // best-effort
+    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);
     });
 });