@web42/cli 0.1.0

package/dist/commands/pull.js

@@ -0,0 +1,63 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { apiGet } from "../utils/api.js";
+import { requireAuth } from "../utils/config.js";
+export const pullCommand = new Command("pull")
+    .description("Pull latest agent files from the Web42 marketplace into the current directory")
+    .action(async () => {
+    const config = requireAuth();
+    const cwd = process.cwd();
+    const manifestPath = join(cwd, "manifest.json");
+    if (!existsSync(manifestPath)) {
+        console.log(chalk.red("No manifest.json found. Are you in an agent directory?"));
+        process.exit(1);
+    }
+    const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+    if (!manifest.name) {
+        console.log(chalk.red("manifest.json is missing a name field."));
+        process.exit(1);
+    }
+    const spinner = ora(`Pulling @${config.username}/${manifest.name}...`).start();
+    try {
+        const agents = await apiGet(`/api/agents?username=${config.username}`);
+        const agent = agents.find((a) => a.slug === manifest.name);
+        if (!agent) {
+            spinner.fail(`Agent @${config.username}/${manifest.name} not found on the marketplace. Run \`web42 push\` first.`);
+            process.exit(1);
+        }
+        const files = await apiGet(`/api/agents/${agent.id}/files?include_content=true`);
+        if (files.length === 0) {
+            spinner.succeed("Agent is up to date (no files on remote).");
+            return;
+        }
+        let written = 0;
+        let skipped = 0;
+        for (const file of files) {
+            if (file.content === null || file.content === undefined) {
+                skipped++;
+                continue;
+            }
+            // Skip packaging artifacts that are regenerated on push
+            if (file.path === ".openclaw/config.json") {
+                skipped++;
+                continue;
+            }
+            const filePath = join(cwd, file.path);
+            mkdirSync(dirname(filePath), { recursive: true });
+            writeFileSync(filePath, file.content, "utf-8");
+            written++;
+        }
+        if (agent.manifest) {
+            writeFileSync(manifestPath, JSON.stringify(agent.manifest, null, 2) + "\n");
+        }
+        spinner.succeed(`Pulled ${chalk.bold(`@${config.username}/${manifest.name}`)} (${written} files written${skipped > 0 ? `, ${skipped} skipped` : ""})`);
+    }
+    catch (error) {
+        spinner.fail("Pull failed");
+        console.error(chalk.red(error.message));
+        process.exit(1);
+    }
+});

package/dist/commands/push.d.ts

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

package/dist/commands/push.js

@@ -0,0 +1,127 @@
+import { createHash } from "crypto";
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync, } from "fs";
+import { join, relative } from "path";
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { apiPost } from "../utils/api.js";
+import { requireAuth } from "../utils/config.js";
+import { openclawAdapter } from "../platforms/openclaw/adapter.js";
+function hashContent(content) {
+    return createHash("sha256").update(content).digest("hex");
+}
+function readPackedFiles(dir) {
+    const files = [];
+    function walk(currentDir) {
+        const entries = readdirSync(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = join(currentDir, entry.name);
+            if (entry.isDirectory()) {
+                walk(fullPath);
+            }
+            else {
+                if (entry.name === "manifest.json" && currentDir === dir)
+                    continue;
+                const stat = statSync(fullPath);
+                if (stat.size > 1024 * 1024)
+                    continue;
+                try {
+                    const content = readFileSync(fullPath, "utf-8");
+                    const relPath = relative(dir, fullPath);
+                    files.push({ path: relPath, content, hash: hashContent(content) });
+                }
+                catch {
+                    // Skip binary files
+                }
+            }
+        }
+    }
+    walk(dir);
+    return files;
+}
+export const pushCommand = new Command("push")
+    .description("Push your agent package to the Web42 marketplace")
+    .action(async () => {
+    const config = requireAuth();
+    const cwd = process.cwd();
+    const manifestPath = join(cwd, "manifest.json");
+    if (!existsSync(manifestPath)) {
+        console.log(chalk.red("No manifest.json found. Run `web42 init` first."));
+        process.exit(1);
+    }
+    let manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+    if (!manifest.name || !manifest.version || !manifest.author) {
+        console.log(chalk.red("Invalid manifest.json. Must have name, version, and author."));
+        process.exit(1);
+    }
+    const spinner = ora("Preparing agent package...").start();
+    const web42Dir = join(cwd, ".web42");
+    let processedFiles;
+    if (existsSync(web42Dir)) {
+        spinner.text = "Reading packed artifact...";
+        processedFiles = readPackedFiles(web42Dir);
+        const packedManifestPath = join(web42Dir, "manifest.json");
+        if (existsSync(packedManifestPath)) {
+            manifest = JSON.parse(readFileSync(packedManifestPath, "utf-8"));
+        }
+    }
+    else {
+        spinner.text = "No .web42/ found, packing automatically...";
+        const result = await openclawAdapter.pack({ cwd, outputDir: ".web42" });
+        processedFiles = result.files;
+        const existingKeys = new Set((manifest.configVariables ?? []).map((v) => v.key));
+        for (const cv of result.configVariables) {
+            if (!existingKeys.has(cv.key)) {
+                if (!manifest.configVariables)
+                    manifest.configVariables = [];
+                manifest.configVariables.push(cv);
+                existingKeys.add(cv.key);
+            }
+        }
+        // Write the packed artifact so it can be inspected later
+        mkdirSync(web42Dir, { recursive: true });
+        for (const file of result.files) {
+            const filePath = join(web42Dir, file.path);
+            mkdirSync(join(filePath, ".."), { recursive: true });
+            writeFileSync(filePath, file.content, "utf-8");
+        }
+        writeFileSync(join(web42Dir, "manifest.json"), JSON.stringify(manifest, null, 2) + "\n");
+    }
+    spinner.text = `Pushing ${processedFiles.length} files...`;
+    let readme = "";
+    const readmePath = join(cwd, "README.md");
+    if (existsSync(readmePath)) {
+        readme = readFileSync(readmePath, "utf-8");
+    }
+    try {
+        const agentResult = await apiPost("/api/agents", {
+            slug: manifest.name,
+            name: manifest.name,
+            description: manifest.description,
+            readme,
+            manifest,
+            demo_video_url: manifest.demoVideoUrl,
+        });
+        const agentId = agentResult.agent.id;
+        const fileEntries = processedFiles.map((f) => ({
+            path: f.path,
+            content: f.content,
+            content_hash: f.hash,
+            storage_url: `agent-files/${config.username}/${manifest.name}/${f.path}`,
+        }));
+        await apiPost(`/api/agents/${agentId}/files`, { files: fileEntries });
+        spinner.succeed(`Pushed ${chalk.bold(`@${config.username}/${manifest.name}`)} (${processedFiles.length} files)`);
+        if (agentResult.created) {
+            console.log(chalk.green("  New agent created!"));
+        }
+        else {
+            console.log(chalk.green("  Agent updated."));
+        }
+        console.log(chalk.dim(`  View at: ${config.apiUrl ? config.apiUrl.replace("https://", "") : "agents.web42.ai"}/${config.username}/${manifest.name}`));
+    }
+    catch (error) {
+        spinner.fail("Push failed");
+        console.error(chalk.red(error.message));
+        process.exit(1);
+    }
+});

package/dist/commands/remix.d.ts

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

package/dist/commands/remix.js

@@ -0,0 +1,49 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import inquirer from "inquirer";
+import ora from "ora";
+import { apiGet, apiPost } from "../utils/api.js";
+import { requireAuth } from "../utils/config.js";
+export const remixCommand = new Command("remix")
+    .description("Remix an agent package to your account")
+    .argument("<agent>", "Agent to remix (e.g. @user/agent-name)")
+    .action(async (agentRef) => {
+    const config = requireAuth();
+    const match = agentRef.match(/^@?([^/]+)\/(.+)$/);
+    if (!match) {
+        console.log(chalk.red("Invalid agent reference. Use @user/agent-name format."));
+        process.exit(1);
+    }
+    const [, username, agentSlug] = match;
+    const { confirm } = await inquirer.prompt([
+        {
+            type: "confirm",
+            name: "confirm",
+            message: `Remix @${username}/${agentSlug} to @${config.username}/${agentSlug}?`,
+            default: true,
+        },
+    ]);
+    if (!confirm) {
+        console.log(chalk.yellow("Aborted."));
+        return;
+    }
+    const spinner = ora("Remixing...").start();
+    try {
+        // Find the agent
+        const agents = await apiGet(`/api/agents?username=${username}`);
+        const agent = agents.find((a) => a.slug === agentSlug);
+        if (!agent) {
+            spinner.fail(`Agent @${username}/${agentSlug} not found`);
+            process.exit(1);
+        }
+        await apiPost(`/api/agents/${agent.id}/remix`, {});
+        spinner.succeed(`Remixed to ${chalk.bold(`@${config.username}/${agentSlug}`)}`);
+        console.log();
+        console.log(chalk.dim(`Run \`web42 install @${config.username}/${agentSlug}\` to install locally.`));
+    }
+    catch (error) {
+        spinner.fail("Remix failed");
+        console.error(chalk.red(error.message));
+        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,58 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { apiGet } from "../utils/api.js";
+function truncate(str, max) {
+    if (str.length <= max)
+        return str;
+    return str.slice(0, max - 1) + "\u2026";
+}
+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();
+    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);
+        console.log(chalk.bold(`Found ${agents.length} agent(s) for "${query}":`));
+        console.log();
+        for (const agent of results) {
+            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)}`)
+                : chalk.dim(" Free");
+            console.log(`  ${chalk.cyan.bold(agent.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://marketplace.web42.ai";
+                console.log(chalk.dim(`  Purchase: ${siteUrl}/${agent.owner.username}/${agent.slug}`));
+            }
+            else {
+                console.log(chalk.dim(`  Install: web42 ${platform} install ${ref}`));
+            }
+            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(error.message));
+        process.exit(1);
+    }
+});

package/dist/commands/uninstall.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+import type { PlatformAdapter } from "../platforms/base.js";
+export declare function makeUninstallCommand(adapter: PlatformAdapter): Command;

package/dist/commands/uninstall.js

@@ -0,0 +1,54 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import inquirer from "inquirer";
+import ora from "ora";
+export function makeUninstallCommand(adapter) {
+    return new Command("uninstall")
+        .description("Uninstall an agent")
+        .argument("<agent>", "Local agent name to uninstall")
+        .option("-f, --force", "Skip confirmation prompt")
+        .action(async (agentName, opts) => {
+        const installed = await adapter.listInstalled();
+        const found = installed.find((a) => a.name === agentName);
+        if (!found) {
+            console.log(chalk.red(`Agent "${agentName}" is not installed on ${adapter.name}.`));
+            const available = installed.map((a) => a.name);
+            if (available.length > 0) {
+                console.log(chalk.dim(`  Installed agents: ${available.join(", ")}`));
+            }
+            process.exit(1);
+        }
+        if (!opts.force) {
+            const { confirm } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "confirm",
+                    message: `Remove agent "${agentName}" and all its workspace files?`,
+                    default: false,
+                },
+            ]);
+            if (!confirm) {
+                console.log(chalk.dim("Aborted."));
+                return;
+            }
+        }
+        const spinner = ora(`Uninstalling "${agentName}"...`).start();
+        try {
+            const result = await adapter.uninstall({ agentName });
+            if (result.removed) {
+                spinner.succeed(`Uninstalled "${agentName}"`);
+                for (const p of result.paths) {
+                    console.log(chalk.dim(`  Removed: ${p}`));
+                }
+            }
+            else {
+                spinner.warn(`Nothing to remove for "${agentName}"`);
+            }
+        }
+        catch (error) {
+            spinner.fail("Uninstall failed");
+            console.error(chalk.red(error.message));
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/update.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+import type { PlatformAdapter } from "../platforms/base.js";
+export declare function makeUpdateCommand(adapter: PlatformAdapter): Command;

package/dist/commands/update.js

@@ -0,0 +1,59 @@
+import { mkdirSync, writeFileSync } from "fs";
+import { join, dirname } from "path";
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { apiGet, apiPost } from "../utils/api.js";
+function resolveTemplateVars(content, platformHome, workspacePath) {
+    return content
+        .replace(/\{\{OPENCLAW_HOME\}\}/g, platformHome)
+        .replace(/\{\{WORKSPACE\}\}/g, workspacePath);
+}
+export function makeUpdateCommand(adapter) {
+    return new Command("update")
+        .description("Update an installed agent to the latest version")
+        .argument("<agent>", "Agent to update (e.g. @user/agent-name)")
+        .action(async (agentRef) => {
+        const match = agentRef.match(/^@?([^/]+)\/(.+)$/);
+        if (!match) {
+            console.log(chalk.red("Invalid agent reference. Use @user/agent-name format."));
+            process.exit(1);
+        }
+        const [, username, agentSlug] = match;
+        const spinner = ora(`Checking for updates to @${username}/${agentSlug}...`).start();
+        try {
+            const agents = await apiGet(`/api/agents?username=${username}`);
+            const agent = agents.find((a) => a.slug === agentSlug);
+            if (!agent) {
+                spinner.fail(`Agent @${username}/${agentSlug} not found`);
+                process.exit(1);
+            }
+            const result = await apiPost(`/api/agents/${agent.id}/install`, {});
+            spinner.text = "Applying updates...";
+            const workspacePath = join(adapter.home, `workspace-${agentSlug}`);
+            mkdirSync(workspacePath, { recursive: true });
+            let updated = 0;
+            for (const file of result.files) {
+                if (file.path === ".openclaw/config.json")
+                    continue;
+                const filePath = join(workspacePath, file.path);
+                mkdirSync(dirname(filePath), { recursive: true });
+                if (file.content !== null && file.content !== undefined) {
+                    const resolved = resolveTemplateVars(file.content, adapter.home, workspacePath);
+                    writeFileSync(filePath, resolved, "utf-8");
+                    updated++;
+                }
+            }
+            if (result.agent.manifest) {
+                const manifestPath = join(workspacePath, "manifest.json");
+                writeFileSync(manifestPath, JSON.stringify(result.agent.manifest, null, 2) + "\n");
+            }
+            spinner.succeed(`Updated ${chalk.bold(`@${username}/${agentSlug}`)} (${updated} files)`);
+        }
+        catch (error) {
+            spinner.fail("Update failed");
+            console.error(chalk.red(error.message));
+            process.exit(1);
+        }
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { authCommand } from "./commands/auth.js";
+import { configCommand } from "./commands/config.js";
+import { initCommand } from "./commands/init.js";
+import { packCommand } from "./commands/pack.js";
+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 { getAllPlatformCommands } from "./platforms/registry.js";
+import { setApiUrl } from "./utils/config.js";
+import { CLI_VERSION } from "./version.js";
+const program = new Command();
+program
+    .name("web42")
+    .description("Web42 Agent Marketplace CLI — manage, install, and publish agent packages")
+    .version(CLI_VERSION)
+    .option("--api-url <url>", "Override the API URL for this invocation")
+    .hook("preAction", (thisCommand) => {
+    const opts = thisCommand.opts();
+    if (opts.apiUrl) {
+        setApiUrl(opts.apiUrl);
+    }
+});
+program.addCommand(authCommand);
+program.addCommand(configCommand);
+program.addCommand(initCommand);
+program.addCommand(packCommand);
+program.addCommand(pushCommand);
+program.addCommand(pullCommand);
+program.addCommand(remixCommand);
+program.addCommand(searchCommand);
+for (const platformCmd of getAllPlatformCommands()) {
+    program.addCommand(platformCmd);
+}
+program.parse();

package/dist/platforms/base.d.ts

@@ -0,0 +1,58 @@
+export interface ConfigVariable {
+    key: string;
+    label: string;
+    description?: string;
+    required: boolean;
+    default?: string;
+}
+export interface PackOptions {
+    cwd: string;
+    outputDir: string;
+    dryRun?: boolean;
+}
+export interface PackedFile {
+    path: string;
+    content: string;
+    hash: string;
+}
+export interface PackResult {
+    files: PackedFile[];
+    configTemplate: Record<string, unknown> | null;
+    configVariables: ConfigVariable[];
+}
+export interface InstallOptions {
+    agentSlug: string;
+    username: string;
+    workspacePath: string;
+    files: Array<{
+        path: string;
+        content: string | null;
+        content_hash: string;
+    }>;
+    configTemplate: Record<string, unknown> | null;
+    configAnswers: Record<string, string>;
+}
+export interface InstallResult {
+    filesWritten: number;
+    agentDir: string;
+}
+export interface UninstallOptions {
+    agentName: string;
+}
+export interface UninstallResult {
+    removed: boolean;
+    paths: string[];
+}
+export interface InstalledAgent {
+    name: string;
+    source?: string;
+    workspace: string;
+}
+export interface PlatformAdapter {
+    name: string;
+    home: string;
+    pack(options: PackOptions): Promise<PackResult>;
+    install(options: InstallOptions): Promise<InstallResult>;
+    uninstall(options: UninstallOptions): Promise<UninstallResult>;
+    listInstalled(): Promise<InstalledAgent[]>;
+}

package/dist/platforms/base.js

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

package/dist/platforms/openclaw/adapter.d.ts

@@ -0,0 +1,10 @@
+import type { InstalledAgent, InstallOptions, InstallResult, PackOptions, PackResult, PlatformAdapter, UninstallOptions, UninstallResult } from "../base.js";
+export declare class OpenClawAdapter implements PlatformAdapter {
+    name: string;
+    home: string;
+    listInstalled(): Promise<InstalledAgent[]>;
+    uninstall(options: UninstallOptions): Promise<UninstallResult>;
+    pack(options: PackOptions): Promise<PackResult>;
+    install(options: InstallOptions): Promise<InstallResult>;
+}
+export declare const openclawAdapter: OpenClawAdapter;