@web42/cli 0.1.17 → 0.2.3

package/dist/commands/serve.js

@@ -0,0 +1,206 @@
+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;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    async execute(requestContext, eventBus) {
+        const { taskId, contextId, userMessage } = requestContext;
+        const userText = userMessage.parts
+            .find((p) => p.kind === 'text')?.text ?? '';
+        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 (!response.ok) {
+            throw new Error(`OpenClaw error: ${response.status} ${response.statusText}`);
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        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) {
+                        eventBus.publish({
+                            kind: 'artifact-update',
+                            taskId,
+                            contextId,
+                            artifact: {
+                                artifactId: 'response',
+                                parts: [{ kind: 'text', text: token }],
+                            },
+                        });
+                    }
+                }
+                catch {
+                    // ignore malformed SSE lines
+                }
+            }
+        }
+        eventBus.publish({
+            kind: 'status-update',
+            taskId,
+            contextId,
+            status: { state: 'completed', timestamp: new Date().toISOString() },
+            final: true,
+        });
+        eventBus.finished();
+    }
+    cancelTask = async () => { };
+}
+// ---------------------------------------------------------------------------
+// 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')
+    .action(async (opts) => {
+    // 1. Must be logged into web42
+    try {
+        requireAuth();
+    }
+    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.'));
+        process.exit(1);
+    }
+    if (!manifest.name) {
+        console.error(chalk.red('manifest.json must have a "name" field.'));
+        process.exit(1);
+    }
+    const config = getConfig();
+    const web42ApiUrl = config.apiUrl ?? 'https://web42.ai';
+    const spinner = ora('Starting A2A server...').start();
+    // 3. Build AgentCard from manifest
+    const agentCard = {
+        name: manifest.name,
+        description: manifest.description ?? '',
+        protocolVersion: '0.3.0',
+        version: manifest.version ?? '1.0.0',
+        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: [],
+        })),
+        capabilities: {
+            streaming: true,
+            pushNotifications: false,
+        },
+        defaultInputModes: ['text'],
+        defaultOutputModes: ['text'],
+        securitySchemes: {
+            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
+    const userBuilder = async (req) => {
+        const token = req.headers.authorization?.split(' ')[1];
+        if (!token)
+            throw new Error('Missing token');
+        const res = await fetch(`${web42ApiUrl}/api/auth/introspect`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ token }),
+        });
+        if (!res.ok)
+            throw new Error('Introspect call failed');
+        const result = (await res.json());
+        if (!result.active)
+            throw new Error('Unauthorized');
+        const userId = result.sub ?? '';
+        return {
+            get isAuthenticated() { return true; },
+            get userName() { return userId; },
+        };
+    };
+    const executor = new OpenClawAgentExecutor({ openClawPort, openClawToken, openClawAgent });
+    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 }));
+    // 6. Start listening
+    app.listen(port, () => {
+        spinner.stop();
+        console.log(chalk.green(`\n✓ Agent "${manifest.name}" is live`));
+        console.log(chalk.dim(`  Local:  http://localhost:${port}`));
+        if (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`));
+        console.log(chalk.dim('\nWaiting for requests... (Ctrl+C to stop)\n'));
+    });
+    // 7. Keep process alive
+    process.on('SIGINT', () => {
+        console.log(chalk.dim('\nShutting down...'));
+        process.exit(0);
+    });
+});

package/dist/index.js

@@ -8,6 +8,8 @@ import { pushCommand } from "./commands/push.js";
 import { pullCommand } from "./commands/pull.js";
 import { remixCommand } from "./commands/remix.js";
 import { searchCommand } from "./commands/search.js";
+import { sendCommand } from "./commands/send.js";
+import { serveCommand } from "./commands/serve.js";
 import { syncCommand } from "./commands/sync.js";
 import { getAllPlatformCommands } from "./platforms/registry.js";
 import { setApiUrl } from "./utils/config.js";
@@ -32,6 +34,8 @@ program.addCommand(pushCommand);
 program.addCommand(pullCommand);
 program.addCommand(remixCommand);
 program.addCommand(searchCommand);
+program.addCommand(sendCommand);
+program.addCommand(serveCommand);
 program.addCommand(syncCommand);
 for (const platformCmd of getAllPlatformCommands()) {
     program.addCommand(platformCmd);

package/dist/platforms/base.d.ts

@@ -9,6 +9,7 @@ export interface PackOptions {
     cwd: string;
     outputDir: string;
     dryRun?: boolean;
+    agentName?: string;
 }
 export interface PackedFile {
     path: string;
@@ -32,6 +33,7 @@ export interface InstallOptions {
     }>;
     configTemplate: Record<string, unknown> | null;
     configAnswers: Record<string, string>;
+    version?: string;
 }
 export interface InstallResult {
     filesWritten: number;
@@ -39,6 +41,7 @@ export interface InstallResult {
 }
 export interface UninstallOptions {
     agentName: string;
+    workspacePath?: string;
 }
 export interface UninstallResult {
     removed: boolean;
@@ -53,6 +56,18 @@ export interface InitConfig {
     name: string;
     model?: string;
 }
+export interface AgentCandidate {
+    name: string;
+    description?: string;
+    model?: string;
+    skills: string[];
+    path: string;
+}
+export interface ResolvedSkill {
+    name: string;
+    sourcePath: string;
+    found: boolean;
+}
 export interface PlatformAdapter {
     name: string;
     home: string;
@@ -61,4 +76,7 @@ export interface PlatformAdapter {
     install(options: InstallOptions): Promise<InstallResult>;
     uninstall(options: UninstallOptions): Promise<UninstallResult>;
     listInstalled(): Promise<InstalledAgent[]>;
+    discoverAgents?(cwd: string): AgentCandidate[];
+    resolveSkills?(skillNames: string[], cwd: string): ResolvedSkill[];
+    resolveInstallPath?(localName: string, global?: boolean): string;
 }

package/dist/platforms/claude/__tests__/adapter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/platforms/claude/__tests__/adapter.test.js

@@ -0,0 +1,257 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdirSync, writeFileSync, rmSync, existsSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { ClaudeAdapter } from "../adapter.js";
+function createTempDir() {
+    const dir = join(tmpdir(), `claude-adapter-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}
+describe("ClaudeAdapter", () => {
+    let adapter;
+    let tempDir;
+    beforeEach(() => {
+        adapter = new ClaudeAdapter();
+        tempDir = createTempDir();
+        // Override home so discoverAgents/resolveSkills don't pick up the real
+        // ~/.claude directory during tests, making results fully deterministic.
+        adapter.home = tempDir;
+    });
+    afterEach(() => {
+        if (existsSync(tempDir)) {
+            rmSync(tempDir, { recursive: true, force: true });
+        }
+    });
+    describe("discoverAgents", () => {
+        it("finds agents in cwd/agents/", () => {
+            const agentsDir = join(tempDir, "agents");
+            mkdirSync(agentsDir, { recursive: true });
+            writeFileSync(join(agentsDir, "test-agent.md"), `---
+name: test-agent
+description: A test agent
+model: sonnet
+skills:
+  - skill-one
+---
+
+You are a test agent.
+`);
+            const agents = adapter.discoverAgents(tempDir);
+            expect(agents).toHaveLength(1);
+            expect(agents[0].name).toBe("test-agent");
+            expect(agents[0].description).toBe("A test agent");
+            expect(agents[0].model).toBe("sonnet");
+            expect(agents[0].skills).toEqual(["skill-one"]);
+        });
+        it("parses frontmatter correctly with multiple skills", () => {
+            const agentsDir = join(tempDir, "agents");
+            mkdirSync(agentsDir, { recursive: true });
+            writeFileSync(join(agentsDir, "multi-skill.md"), `---
+name: multi-skill-agent
+description: Agent with many skills
+model: opus
+skills:
+  - flutter-conventions
+  - dart-testing
+  - a11y-flutter
+tools: Read, Grep, Glob, Bash
+---
+
+Body content.
+`);
+            const agents = adapter.discoverAgents(tempDir);
+            expect(agents).toHaveLength(1);
+            expect(agents[0].skills).toEqual([
+                "flutter-conventions",
+                "dart-testing",
+                "a11y-flutter",
+            ]);
+        });
+        it("returns empty for no agents", () => {
+            const agents = adapter.discoverAgents(tempDir);
+            expect(agents).toEqual([]);
+        });
+        it("uses filename as fallback name when no frontmatter name", () => {
+            const agentsDir = join(tempDir, "agents");
+            mkdirSync(agentsDir, { recursive: true });
+            writeFileSync(join(agentsDir, "my-agent.md"), `---
+description: No name in frontmatter
+---
+
+Body.
+`);
+            const agents = adapter.discoverAgents(tempDir);
+            expect(agents[0].name).toBe("my-agent");
+        });
+        it("discovers multiple agents", () => {
+            const agentsDir = join(tempDir, "agents");
+            mkdirSync(agentsDir, { recursive: true });
+            writeFileSync(join(agentsDir, "agent-a.md"), "---\nname: agent-a\n---\nBody.");
+            writeFileSync(join(agentsDir, "agent-b.md"), "---\nname: agent-b\n---\nBody.");
+            const agents = adapter.discoverAgents(tempDir);
+            expect(agents).toHaveLength(2);
+            const names = agents.map((a) => a.name).sort();
+            expect(names).toEqual(["agent-a", "agent-b"]);
+        });
+        it("skips non-.md files", () => {
+            const agentsDir = join(tempDir, "agents");
+            mkdirSync(agentsDir, { recursive: true });
+            writeFileSync(join(agentsDir, "agent.md"), "---\nname: real-agent\n---\nBody.");
+            writeFileSync(join(agentsDir, "notes.txt"), "Just a text file");
+            writeFileSync(join(agentsDir, ".DS_Store"), "");
+            const agents = adapter.discoverAgents(tempDir);
+            expect(agents).toHaveLength(1);
+            expect(agents[0].name).toBe("real-agent");
+        });
+    });
+    describe("resolveSkills", () => {
+        it("finds skills in cwd/skills/", () => {
+            const skillDir = join(tempDir, "skills", "my-skill");
+            mkdirSync(skillDir, { recursive: true });
+            writeFileSync(join(skillDir, "SKILL.md"), "# My Skill\nDescription here.");
+            const resolved = adapter.resolveSkills(["my-skill"], tempDir);
+            expect(resolved).toHaveLength(1);
+            expect(resolved[0].name).toBe("my-skill");
+            expect(resolved[0].found).toBe(true);
+            expect(resolved[0].sourcePath).toBe(skillDir);
+        });
+        it("marks missing skills as not found", () => {
+            const resolved = adapter.resolveSkills(["nonexistent-skill"], tempDir);
+            expect(resolved).toHaveLength(1);
+            expect(resolved[0].found).toBe(false);
+        });
+        it("resolves multiple skills", () => {
+            mkdirSync(join(tempDir, "skills", "skill-a"), { recursive: true });
+            writeFileSync(join(tempDir, "skills", "skill-a", "SKILL.md"), "# Skill A");
+            mkdirSync(join(tempDir, "skills", "skill-b"), { recursive: true });
+            writeFileSync(join(tempDir, "skills", "skill-b", "SKILL.md"), "# Skill B");
+            const resolved = adapter.resolveSkills(["skill-a", "skill-b", "missing"], tempDir);
+            expect(resolved.filter((s) => s.found)).toHaveLength(2);
+            expect(resolved.find((s) => s.name === "missing")?.found).toBe(false);
+        });
+    });
+    describe("extractInitConfig", () => {
+        it("returns config when agent exists", () => {
+            const agentsDir = join(tempDir, "agents");
+            mkdirSync(agentsDir, { recursive: true });
+            writeFileSync(join(agentsDir, "test.md"), "---\nname: test-agent\nmodel: sonnet\n---\nBody.");
+            const config = adapter.extractInitConfig(tempDir);
+            expect(config).not.toBeNull();
+            expect(config.name).toBe("test-agent");
+            expect(config.model).toBe("sonnet");
+        });
+        it("returns null when no agents exist", () => {
+            const config = adapter.extractInitConfig(tempDir);
+            expect(config).toBeNull();
+        });
+    });
+    describe("pack", () => {
+        it("collects agent and referenced skills", async () => {
+            // Set up agent
+            const agentsDir = join(tempDir, "agents");
+            mkdirSync(agentsDir, { recursive: true });
+            writeFileSync(join(agentsDir, "my-agent.md"), `---
+name: my-agent
+skills:
+  - test-skill
+---
+
+Agent body.
+`);
+            // Set up skill
+            const skillDir = join(tempDir, "skills", "test-skill");
+            mkdirSync(skillDir, { recursive: true });
+            writeFileSync(join(skillDir, "SKILL.md"), "# Test Skill\nSkill description.");
+            mkdirSync(join(skillDir, "references"), { recursive: true });
+            writeFileSync(join(skillDir, "references", "ref.md"), "Reference content.");
+            const result = await adapter.pack({
+                cwd: tempDir,
+                outputDir: ".web42/my-agent/dist",
+                agentName: "my-agent",
+            });
+            expect(result.files.length).toBeGreaterThanOrEqual(3);
+            const paths = result.files.map((f) => f.path);
+            expect(paths).toContain("agents/my-agent.md");
+            expect(paths).toContain("skills/test-skill/SKILL.md");
+            expect(paths).toContain("skills/test-skill/references/ref.md");
+        });
+        it("excludes .git and node_modules", async () => {
+            const agentsDir = join(tempDir, "agents");
+            mkdirSync(agentsDir, { recursive: true });
+            writeFileSync(join(agentsDir, "test.md"), "---\nname: test\n---\nBody.");
+            // Create files that should be excluded
+            mkdirSync(join(tempDir, ".git"), { recursive: true });
+            writeFileSync(join(tempDir, ".git", "config"), "git config");
+            mkdirSync(join(tempDir, "node_modules", "pkg"), { recursive: true });
+            writeFileSync(join(tempDir, "node_modules", "pkg", "index.js"), "module.exports = {}");
+            const result = await adapter.pack({
+                cwd: tempDir,
+                outputDir: ".web42/test/dist",
+                agentName: "test",
+            });
+            const paths = result.files.map((f) => f.path);
+            expect(paths.some((p) => p.includes(".git"))).toBe(false);
+            expect(paths.some((p) => p.includes("node_modules"))).toBe(false);
+        });
+        it("applies template var sanitization", async () => {
+            const agentsDir = join(tempDir, "agents");
+            mkdirSync(agentsDir, { recursive: true });
+            writeFileSync(join(agentsDir, "test.md"), "---\nname: test\n---\nPath: ~/.claude/agents/test.md");
+            const result = await adapter.pack({
+                cwd: tempDir,
+                outputDir: ".web42/test/dist",
+                agentName: "test",
+            });
+            const agentFile = result.files.find((f) => f.path === "agents/test.md");
+            expect(agentFile?.content).toContain("{{CLAUDE_HOME}}");
+            expect(agentFile?.content).not.toContain("~/.claude/");
+        });
+        it("throws when agentName is not provided", async () => {
+            await expect(adapter.pack({ cwd: tempDir, outputDir: "dist" })).rejects.toThrow("agentName");
+        });
+        it("throws when agent file not found", async () => {
+            await expect(adapter.pack({ cwd: tempDir, outputDir: "dist", agentName: "nonexistent" })).rejects.toThrow("not found");
+        });
+        it("collects commands if present", async () => {
+            const agentsDir = join(tempDir, "agents");
+            mkdirSync(agentsDir, { recursive: true });
+            writeFileSync(join(agentsDir, "test.md"), "---\nname: test\n---\nBody.");
+            const commandsDir = join(tempDir, "commands");
+            mkdirSync(commandsDir, { recursive: true });
+            writeFileSync(join(commandsDir, "review.md"), "# Review command");
+            const result = await adapter.pack({
+                cwd: tempDir,
+                outputDir: "dist",
+                agentName: "test",
+            });
+            const paths = result.files.map((f) => f.path);
+            expect(paths).toContain("commands/review.md");
+        });
+    });
+    describe("install and uninstall", () => {
+        let installDir;
+        beforeEach(() => {
+            installDir = createTempDir();
+        });
+        afterEach(() => {
+            if (existsSync(installDir)) {
+                rmSync(installDir, { recursive: true, force: true });
+            }
+        });
+        it("rejects path traversal", async () => {
+            // We can't easily test the actual install since it writes to ~/.claude/
+            // but we can test the path traversal check by examining the adapter logic
+            const files = [
+                { path: "../../../etc/passwd", content: "bad content", content_hash: "abc" },
+            ];
+            // The adapter checks: resolve(CLAUDE_HOME, file.path).startsWith(resolve(CLAUDE_HOME))
+            // A path with ../ would resolve outside CLAUDE_HOME
+            const { resolve: pathResolve } = await import("path");
+            const { homedir: getHomedir } = await import("os");
+            const home = join(getHomedir(), ".claude");
+            const resolved = pathResolve(home, "../../../etc/passwd");
+            expect(resolved.startsWith(pathResolve(home))).toBe(false);
+        });
+    });
+});

package/dist/platforms/claude/__tests__/security.test.d.ts

@@ -0,0 +1 @@
+export {};