@web42/w42 0.1.4 → 0.1.9

package/LICENSE.md

@@ -0,0 +1,116 @@
+# EULA (End User License Agreement)
+
+## Personal License
+
+NewCult.co grants you an on-going, non-exclusive license to use this template.
+
+The license grants permission to **one individual** (the Licensee) to access and use this template.
+
+### You **can**:
+
+- Use this template to create unlimited End Products.
+- Modify this template to create derivative components and templates. Those components and templates are subject to this license.
+- Use this template to create unlimited End Products for unlimited clients.
+- Use this template to create End Products where the End Product is sold to End Users.
+- Use this template to create End Products that are open source and freely available to End Users.
+
+### You **cannot**:
+
+- Use this template to create End Products that are designed to allow an End User to build their own End Products using this template or derivatives of this template.
+- Re-distribute this template or derivatives of this template separately from an End Product, neither in code nor as design assets.
+- Share your access to this template with any other individuals.
+- Use this template to produce anything that may be deemed by NewCult.co, in their sole and absolute discretion, to be competitive or in conflict with the business of NewCult.co.
+
+### Example Usage
+
+**Allowed** by the license:
+
+- Creating a personal website by yourself.
+- Creating a website or web application for a client that will be owned by that client.
+- Creating a commercial SaaS application (like an invoicing app) where end users have to pay a fee to use the application.
+- Creating a commercial self-hosted web application that is sold to end users for a one-time fee.
+- Creating a web application that is free and open source, where the primary purpose is not to simply re-distribute the template and the source code is publicly available.
+
+**Not allowed** by the license:
+
+- Creating a repository of your favorite NewCult.co components or templates (or derivatives based on NewCult.co components or templates) and publishing it publicly.
+- Creating a React or Vue version of NewCult.co and making it available either for sale or for free.
+- Creating a Figma or Sketch UI kit based on the NewCult.co component designs.
+- Creating a "website builder" project where end users can build their own websites using components or templates included with or derived from NewCult.co.
+- Creating a theme, template, or project starter kit using the components or templates and making it available either for sale or for free.
+- Creating an admin panel tool that is made available either for sale or for free.
+
+In simple terms, use NewCult.co for anything you like as long as it doesn't compete with NewCult.co.
+
+### Personal License Definitions
+
+- **Licensee**: The individual who has purchased a Personal License.
+- **Components and Templates**: The source code and design assets made available to the Licensee after purchasing a NewCult.co license.
+- **End Product**: Any artifact produced that incorporates the Components or Templates or derivatives of the Components or Templates.
+- **End User**: A user of an End Product.
+- **Client**: An individual or entity receiving custom professional services directly from the Licensee, produced specifically for that individual or entity. Customers of software-as-a-service products are not considered clients for the purpose of this document.
+
+## Team License
+
+NewCult.co grants you an on-going, non-exclusive license to use this template.
+
+The license grants permission for **up to 25 Employees and Contractors of the Licensee** to access and use this template.
+
+### You **can**:
+
+- Use this template to create unlimited End Products.
+- Modify this template to create derivative components and templates. Those components and templates are subject to this license.
+- Use this template to create unlimited End Products for unlimited clients.
+- Use this template to create End Products where the End Product is sold to End Users.
+- Use this template to create End Products that are open source and freely available to End Users.
+
+### You **cannot**:
+
+- Use the Components or Templates to create End Products that are designed to allow an End User to build their own End Products using the Components or Templates or derivatives of the Components or Templates.
+- Re-distribute the Components or Templates or derivatives of the Components or Templates separately from an End Product.
+- Use the Components or Templates to create End Products that are the property of any individual or entity other than the Licensee or clients of the Licensee.
+- Use the Components or Templates to produce anything that may be deemed by NewCult.co, in their sole and absolute discretion, to be competitive or in conflict with the business of NewCult.co.
+
+### Example Usage
+
+**Allowed** by the license:
+
+- Creating a website for your company.
+- Creating a website or web application for a client that will be owned by that client.
+- Creating a commercial SaaS application (like an invoicing app) where end users have to pay a fee to use the application.
+- Creating a commercial self-hosted web application that is sold to end users for a one-time fee.
+- Creating a web application that is free and open source, where the primary purpose is not to simply re-distribute the components or templates and the source code is publicly available.
+
+**Not allowed** by the license:
+
+- Creating a repository of your favorite NewCult.co components or templates (or derivatives based on NewCult.co components or templates) and publishing it publicly.
+- Creating a React or Vue version of NewCult.co and making it available either for sale or for free.
+- Creating a "website builder" project where end users can build their own websites using components or templates included with or derived from NewCult.co.
+- Creating a theme or template using the components or templates and making it available either for sale or for free.
+- Creating any End Product that is not the sole property of either your company or a client of your company. For example, your employees/contractors can't use your company NewCult.co license to build their own websites or side projects.
+
+### Team License Definitions
+
+- **Licensee**: The business entity who has purchased a Team License.
+- **Components and Templates**: The source code and design assets made available to the Licensee after purchasing a NewCult.co license.
+- **End Product**: Any artifact produced that incorporates the Components or Templates or derivatives of the Components or Templates.
+- **End User**: A user of an End Product.
+- **Employee**: A full-time or part-time employee of the Licensee.
+- **Contractor**: An individual or business entity contracted to perform services for the Licensee.
+- **Client**: An individual or entity receiving custom professional services directly from the Licensee, produced specifically for that individual or entity. Customers of software-as-a-service products are not considered clients for the purpose of this document.
+
+## Enforcement
+
+If you are found to be in violation of the license, access to your NewCult.co account will be terminated, and a refund may be issued at our discretion. When license violation is blatant and malicious (such as intentionally redistributing the Components or Templates through private warez channels), no refund will be issued.
+
+The copyright of this template is owned by NewCult.co. You are granted only the permissions described in this license; all other rights are reserved. NewCult.co reserves the right to pursue legal remedies for any unauthorized use of the Components or Templates outside the scope of this license.
+
+## Liability
+
+NewCult.co’s liability to you for any costs, damages, or other losses arising from your use of the Components or Templates, including third-party claims against you, is limited to a refund of your license fee. NewCult.co is not liable for any consequential damages related to your use of the Components or Templates.
+
+This Agreement is governed by the laws of the State of North Carolina, USA. Legal proceedings related to this Agreement may only be brought in the courts of North Carolina. You agree to service of process at the e-mail address on your original order.
+
+## Questions?
+
+Unsure which license you need, or have questions about your use case? Contact us on Twitter at [x.com/nolansym](https://x.com/nolansym).

package/README.md

@@ -1,73 +1,101 @@
 # @web42/cli
 
-CLI for the Web42 Agent Marketplace - push, install, and remix OpenClaw agent packages.
+CLI for the Web42 Agent Network — authenticate, publish, discover, and interact with A2A agents.
 
 ## Installation
 
-To install the CLI globally, run:
-
-```
+```bash
 npm install -g @web42/cli
 ```
 
 ## Authentication
 
-Authenticate with the marketplace by running:
+```bash
+web42 auth login     # Sign in via GitHub OAuth
+web42 auth logout    # Sign out
+web42 auth whoami    # Show current user
+```
+
+## Commands
 
+### `web42 search <query>`
+
+Search the network for agents.
+
+```bash
+web42 search "data analysis"
+web42 search "image processing" --limit 20
 ```
-web42 login
+
+| Option | Description |
+|---|---|
+| `-l, --limit <number>` | Max results to show (default: 10) |
+
+---
+
+### `web42 send <agent> <message>`
+
+Send a message to an A2A agent. `<agent>` can be a slug (`@user/agent`) or a direct URL (`http://localhost:3001`).
+
+```bash
+web42 send @alice/summarizer "Summarize this document"
+web42 send http://localhost:3001 "Hello"
 ```
 
-## Supported Platforms
+| Option | Description |
+|---|---|
+| `--new` | Start a new conversation (clears saved context) |
+| `--context <id>` | Use a specific context ID |
+| `--task-id <id>` | Reply to a specific task (e.g. one in `input-required` state) |
 
-| Platform  | Status       |
-|-----------|--------------|
-| openclaw  | Fully Supported  |
-| claude    | Fully Supported  |
+---
 
-## CLI Commands Reference
+### `web42 serve`
 
-### General Commands
+Start a local A2A server for your agent, bridging to an OpenClaw gateway.
 
-| 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 |
+```bash
+web42 serve
+web42 serve --port 3001 --url https://my-agent.ngrok.io --verbose
+```
 
-### Claude-Specific Examples
+| Option | Description |
+|---|---|
+| `--port <port>` | Port to listen on (default: 4000) |
+| `--url <url>` | Public URL for registration and AgentCard (e.g. from ngrok) |
+| `--openclaw-port <port>` | OpenClaw gateway port (default: 18789) |
+| `--openclaw-token <token>` | OpenClaw gateway auth token (or `OPENCLAW_GATEWAY_TOKEN`) |
+| `--openclaw-agent <id>` | OpenClaw agent ID to target (default: `main`) |
+| `--client-id <id>` | Developer app client ID (or `W42_CLIENT_ID`) |
+| `--client-secret <secret>` | Developer app client secret (or `W42_CLIENT_SECRET`) |
+| `--visibility <vis>` | Marketplace visibility: `public` or `private` |
+| `--verbose` | Enable verbose request/response logging |
 
-- **Initialize a Project:**
-  ```
-  web42 init
-  ```
+---
 
-- **Pack an Agent:**
-  ```
-  web42 pack --agent <name>
-  ```
+### `web42 register <url>`
 
-- **Push an Agent:**
-  ```
-  web42 push --agent <name>
-  ```
+Register an agent with the Web42 Network. The URL must serve `/.well-known/agent-card.json`.
 
-- **Install an Agent Globally:**
-  ```
-  web42 claude install @user/agent
-  ```
+```bash
+web42 register https://my-agent.example.com
+web42 register https://my-agent.example.com --visibility private --tags "nlp,summarization"
+```
+
+| Option | Description |
+|---|---|
+| `--price <cents>` | Price in cents (default: 0 = free) |
+| `--license <license>` | License (e.g. `MIT`, `Apache-2.0`) |
+| `--visibility <vis>` | `public` or `private` (default: `public`) |
+| `--tags <tags>` | Comma-separated tags |
+| `--categories <cats>` | Comma-separated categories |
 
-- **Install an Agent Locally:**
-  ```
-  web42 claude install -g @user/agent
-  ```
+---
 
-## Versioning
+## Environment variables
 
-Version `0.2.0` introduces Claude Code support.
+```bash
+W42_CLIENT_ID=your-client-id
+W42_CLIENT_SECRET=your-client-secret
+OPENCLAW_GATEWAY_TOKEN=your-openclaw-token
+```

package/dist/commands/send.js

@@ -1,18 +1,41 @@
-import { Command } from "commander";
+import { ClientFactory, ClientFactoryOptions, JsonRpcTransportFactory, } from "@a2a-js/sdk/client";
 import chalk from "chalk";
+import { Command } from "commander";
 import ora from "ora";
 import { v4 as uuidv4 } from "uuid";
-import { requireAuth, setConfigValue, getConfigValue } from "../utils/config.js";
 import { apiPost } from "../utils/api.js";
+import { getConfigValue, requireAuth, setConfigValue } from "../utils/config.js";
 function isUrl(s) {
     return s.startsWith("http://") || s.startsWith("https://");
 }
+function printPart(part) {
+    if (part.kind === "text") {
+        if (part.text)
+            process.stdout.write(part.text);
+    }
+    else if (part.kind === "file") {
+        const f = part.file;
+        const label = [f.name, f.mimeType].filter(Boolean).join(" ");
+        process.stdout.write(`\n[file${label ? `: ${label}` : ""}]\n`);
+        if ("uri" in f) {
+            process.stdout.write(f.uri + "\n");
+        }
+        else {
+            process.stdout.write(`<${f.bytes.length} base64 chars>\n`);
+        }
+    }
+    else if (part.kind === "data") {
+        process.stdout.write("\n" + JSON.stringify(part.data, null, 2) + "\n");
+    }
+}
 function getCachedToken(slug) {
     const raw = getConfigValue(`agentTokens.${slug}`);
     if (!raw)
         return null;
     try {
-        const cached = typeof raw === "string" ? JSON.parse(raw) : raw;
+        const cached = typeof raw === "string"
+            ? JSON.parse(raw)
+            : raw;
         if (new Date(cached.expiresAt) <= new Date())
             return null;
         return cached;
@@ -27,6 +50,7 @@ export const sendCommand = new Command("send")
     .argument("<message>", "Message to send")
     .option("--new", "Start a new conversation (clears saved context)")
     .option("--context <id>", "Use a specific context ID")
+    .option("--task-id <id>", "Reply to a specific task (e.g. one in input-required state)")
     .action(async (rawAgent, userMessage, opts) => {
     // Normalize slug: @user/name → @user~name (DB format)
     const agent = rawAgent.includes("/") && !isUrl(rawAgent)
@@ -37,10 +61,30 @@ export const sendCommand = new Command("send")
     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, "-");
+        const cached = getCachedToken(agentKey);
+        if (cached) {
+            bearerToken = cached.token;
+        }
+        else {
+            const spinner = ora("Getting auth token...").start();
+            try {
+                const res = await apiPost("/api/auth/token", {});
+                bearerToken = res.token;
+                setConfigValue(`agentTokens.${agentKey}`, JSON.stringify({
+                    token: res.token,
+                    agentUrl,
+                    expiresAt: res.expiresAt,
+                }));
+                spinner.stop();
+            }
+            catch (err) {
+                spinner.fail("Failed to get auth token");
+                console.error(chalk.red(String(err)));
+                process.exit(1);
+            }
+        }
     }
     else {
         // Slug mode — handshake with Web42 Network platform
@@ -85,20 +129,6 @@ export const sendCommand = new Command("send")
         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)
@@ -119,8 +149,7 @@ export const sendCommand = new Command("send")
                 interceptors: [bearerInterceptor],
             },
         }));
-        const a2aBaseUrl = new URL(agentUrl).origin;
-        client = await factory.createFromUrl(a2aBaseUrl);
+        client = await factory.createFromUrl(agentUrl);
         connectSpinner.stop();
     }
     catch {
@@ -136,22 +165,67 @@ export const sendCommand = new Command("send")
                 parts: [{ kind: "text", text: userMessage }],
                 kind: "message",
                 contextId,
+                ...(opts.taskId ? { taskId: opts.taskId } : {}),
             },
         });
         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 === "message" && event.role === "agent") {
+                for (const part of event.parts)
+                    printPart(part);
+            }
+            else if (event.kind === "artifact-update") {
+                // When append is true we're receiving streaming chunks — write inline.
+                // When it's a new artifact (append falsy), separate from prior output.
+                if (!event.append)
+                    process.stdout.write("\n");
+                for (const part of event.artifact.parts ?? [])
+                    printPart(part);
             }
-            if (event.kind === "status-update") {
-                const update = event;
-                if (update.status?.state === "failed") {
-                    console.error(chalk.red("\nAgent returned an error."));
+            else if (event.kind === "status-update") {
+                if (event.status?.message) {
+                    for (const part of event.status.message.parts ?? [])
+                        printPart(part);
+                }
+                const state = event.status?.state;
+                if (state === "input-required") {
+                    process.stdout.write("\n");
+                    console.log(chalk.yellow(`[task ${event.taskId} is awaiting input — reply with --task-id ${event.taskId}]`));
+                }
+                else if (state === "auth-required") {
+                    console.error(chalk.red("\nAgent requires authentication."));
+                    process.exit(1);
+                }
+                else if (state === "failed" ||
+                    state === "canceled" ||
+                    state === "rejected") {
+                    console.error(chalk.red(`\nAgent ${state}.`));
+                    process.exit(1);
+                }
+            }
+            else if (event.kind === "task") {
+                // Non-streaming fallback: server returned the full task object.
+                // Print accumulated artifacts and handle terminal state.
+                const task = event;
+                for (const artifact of task.artifacts ?? []) {
+                    process.stdout.write("\n");
+                    for (const part of artifact.parts ?? [])
+                        printPart(part);
+                }
+                if (task.status?.message) {
+                    for (const part of task.status.message.parts ?? [])
+                        printPart(part);
+                }
+                const taskState = task.status?.state;
+                if (taskState === "input-required") {
+                    process.stdout.write("\n");
+                    console.log(chalk.yellow(`[task ${task.id} is awaiting input — reply with --task-id ${task.id}]`));
+                }
+                else if (taskState === "auth-required") {
+                    console.error(chalk.red("\nAgent requires authentication."));
+                    process.exit(1);
+                }
+                else if (taskState === "failed" || taskState === "canceled" || taskState === "rejected") {
+                    console.error(chalk.red(`\nAgent ${taskState}.`));
                     process.exit(1);
                 }
             }