@web42/cli 0.2.7 → 0.2.8

package/dist/commands/push.js

@@ -1,374 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync, statSync, readdirSync } from "fs";
-import path, { join } from "path";
-import { Command } from "commander";
-import chalk from "chalk";
-import ora from "ora";
-import { apiPost, apiFormData } from "../utils/api.js";
-import { requireAuth } from "../utils/config.js";
-import { resolvePlatform } from "../platforms/registry.js";
-import { parseSkillMd } from "../utils/skill.js";
-import { buildLocalSnapshot, computeHashFromSnapshot, findLocalAvatar, findAgentAvatar, discoverResources, readResourcesMeta, readSyncState, writeSyncState, } from "../utils/sync.js";
-function mimeFromExtension(ext) {
-    const map = {
-        png: "image/png",
-        jpg: "image/jpeg",
-        jpeg: "image/jpeg",
-        webp: "image/webp",
-        svg: "image/svg+xml",
-        mp4: "video/mp4",
-        webm: "video/webm",
-        pdf: "application/pdf",
-    };
-    return map[ext.toLowerCase()] ?? "application/octet-stream";
-}
-/**
- * Push a single agent to the marketplace.
- * This encapsulates steps 1-8 of the push flow.
- */
-async function pushSingleAgent(opts) {
-    const { cwd, config, spinner, distDir, syncDir } = opts;
-    let manifest = opts.manifest;
-    // -----------------------------------------------------------------------
-    // Step 1: Pack into dist/ (if not already packed)
-    // -----------------------------------------------------------------------
-    if (existsSync(distDir)) {
-        const packedManifestPath = join(distDir, "manifest.json");
-        if (existsSync(packedManifestPath)) {
-            manifest = JSON.parse(readFileSync(packedManifestPath, "utf-8"));
-        }
-    }
-    else {
-        spinner.text = `Packing ${opts.agentName ?? "agent"}...`;
-        const result = await opts.adapter.pack({
-            cwd,
-            outputDir: distDir.startsWith(cwd) ? distDir.slice(cwd.length + 1) : distDir,
-            agentName: opts.agentName,
-        });
-        const internalPrefixes = [];
-        for (const f of result.files) {
-            const skillMatch = f.path.match(/^skills\/([^/]+)\/SKILL\.md$/);
-            if (skillMatch) {
-                const parsed = parseSkillMd(f.content, skillMatch[1]);
-                if (parsed.internal)
-                    internalPrefixes.push(`skills/${skillMatch[1]}/`);
-            }
-        }
-        if (internalPrefixes.length > 0) {
-            result.files = result.files.filter((f) => !internalPrefixes.some((p) => f.path.startsWith(p)));
-        }
-        const configVars = Array.isArray(manifest.configVariables) ? manifest.configVariables : [];
-        const existingKeys = new Set(configVars.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);
-            }
-        }
-        mkdirSync(distDir, { recursive: true });
-        for (const file of result.files) {
-            const filePath = join(distDir, file.path);
-            mkdirSync(join(filePath, ".."), { recursive: true });
-            writeFileSync(filePath, file.content, "utf-8");
-        }
-        writeFileSync(join(distDir, "manifest.json"), JSON.stringify(manifest, null, 2) + "\n");
-    }
-    // -----------------------------------------------------------------------
-    // Step 2: Resolve agent ID (create if first push)
-    // -----------------------------------------------------------------------
-    spinner.text = `Resolving ${opts.agentName ?? "agent"}...`;
-    let syncState = readSyncState(syncDir);
-    let agentId = syncState?.agent_id ?? null;
-    let isCreated = false;
-    // Always resolve agent metadata (README, marketplace config, avatar)
-    // and upsert the agent record so metadata updates propagate on every push.
-    {
-        let readme = "";
-        // Check per-agent README first (syncDir/README.md), then cwd/README.md
-        const agentReadmePath = join(syncDir, "README.md");
-        const cwdReadmePath = join(cwd, "README.md");
-        if (existsSync(agentReadmePath)) {
-            readme = readFileSync(agentReadmePath, "utf-8");
-        }
-        else if (existsSync(cwdReadmePath)) {
-            readme = readFileSync(cwdReadmePath, "utf-8");
-        }
-        // Note: visibility, license, price, and tags are managed exclusively
-        // through the dashboard UI — the CLI never sends these fields.
-        let profile_image_data = undefined;
-        if (!agentId) {
-            // Only upload avatar on first push (subsequent avatar updates use step 6)
-            const avatarSearchPaths = [
-                join(cwd, "avatar/avatar.png"),
-                join(cwd, "avatars/avatar.png"),
-                join(cwd, "avatar.png"),
-                join(syncDir, "avatar.png"),
-            ];
-            for (const ap of avatarSearchPaths) {
-                if (existsSync(ap)) {
-                    try {
-                        const stats = statSync(ap);
-                        if (stats.size <= 5 * 1024 * 1024) {
-                            profile_image_data = readFileSync(ap).toString("base64");
-                            break;
-                        }
-                    }
-                    catch {
-                        // Skip
-                    }
-                }
-            }
-        }
-        const name = manifest.name ?? "";
-        const agentResult = await apiPost("/api/agents", {
-            slug: name,
-            name,
-            description: manifest.description ?? "",
-            readme,
-            manifest,
-            demo_video_url: manifest.demoVideoUrl,
-            profile_image_data,
-        });
-        agentId = agentResult.agent.id;
-        isCreated = !!agentResult.created;
-    }
-    // -----------------------------------------------------------------------
-    // Step 3: Build local snapshot and compute hash
-    // -----------------------------------------------------------------------
-    spinner.text = "Building snapshot...";
-    // Determine whether syncDir is a .web42 subdirectory using path semantics,
-    // not string matching (avoids false positives when project path itself contains ".web42").
-    const relSyncDir = path.relative(cwd, syncDir);
-    const syncDirIsWeb42Subdir = Boolean(relSyncDir) &&
-        !relSyncDir.startsWith("..") &&
-        !path.isAbsolute(relSyncDir) &&
-        relSyncDir.split(path.sep).includes(".web42");
-    const snapshot = buildLocalSnapshot(syncDirIsWeb42Subdir ? syncDir : cwd, distDir);
-    const localHash = computeHashFromSnapshot(snapshot);
-    // -----------------------------------------------------------------------
-    // Step 4: Compare hashes (unless --force)
-    // -----------------------------------------------------------------------
-    const name = manifest.name ?? "";
-    if (!opts.force && !opts.forceAvatar && !isCreated && syncState?.last_local_hash) {
-        if (localHash === syncState.last_local_hash) {
-            spinner.succeed(`${chalk.bold(`@${config.username}/${name}`)} has no local changes since last sync.`);
-            return;
-        }
-    }
-    // -----------------------------------------------------------------------
-    // Step 5: Push snapshot
-    // -----------------------------------------------------------------------
-    spinner.text = `Pushing ${snapshot.files.length} files...`;
-    const pushResult = await apiPost(`/api/agents/${agentId}/sync/push`, snapshot);
-    let finalHash = pushResult.hash;
-    // -----------------------------------------------------------------------
-    // Step 6: Upload avatar if present
-    // -----------------------------------------------------------------------
-    const avatarPath = findLocalAvatar(syncDir) || findAgentAvatar(cwd);
-    if (avatarPath) {
-        spinner.text = "Uploading avatar...";
-        const ext = avatarPath.split(".").pop() ?? "png";
-        const avatarBuffer = readFileSync(avatarPath);
-        const avatarBlob = new Blob([avatarBuffer], {
-            type: mimeFromExtension(ext),
-        });
-        const avatarForm = new FormData();
-        avatarForm.append("avatar", avatarBlob, `avatar.${ext}`);
-        const avatarResult = await apiFormData(`/api/agents/${agentId}/sync/avatar`, avatarForm);
-        finalHash = avatarResult.hash;
-    }
-    // -----------------------------------------------------------------------
-    // Step 7: Upload resources if present
-    // -----------------------------------------------------------------------
-    const resourcesMeta = readResourcesMeta(syncDir);
-    const discoveredResources = discoverResources(cwd);
-    const allResources = [...resourcesMeta, ...discoveredResources];
-    if (allResources.length > 0) {
-        spinner.text = "Uploading resources...";
-        const resForm = new FormData();
-        const metadataForApi = allResources.map((meta, i) => ({
-            file_key: `resource_${i}`,
-            title: meta.title,
-            description: meta.description,
-            type: meta.type,
-            sort_order: meta.sort_order,
-        }));
-        resForm.append("metadata", JSON.stringify(metadataForApi));
-        for (let i = 0; i < allResources.length; i++) {
-            const meta = allResources[i];
-            let resFilePath = join(syncDir, "resources", meta.file);
-            if (!existsSync(resFilePath)) {
-                resFilePath = join(cwd, ".web42", "resources", meta.file);
-            }
-            if (!existsSync(resFilePath)) {
-                resFilePath = join(cwd, "resources", meta.file);
-            }
-            if (existsSync(resFilePath)) {
-                const resBuffer = readFileSync(resFilePath);
-                const ext = meta.file.split(".").pop() ?? "";
-                const blob = new Blob([resBuffer], {
-                    type: mimeFromExtension(ext),
-                });
-                resForm.append(`resource_${i}`, blob, meta.file);
-            }
-        }
-        const resResult = await apiFormData(`/api/agents/${agentId}/sync/resources`, resForm);
-        finalHash = resResult.hash;
-    }
-    // -----------------------------------------------------------------------
-    // Step 8: Save sync state
-    // -----------------------------------------------------------------------
-    writeSyncState(syncDir, {
-        agent_id: agentId,
-        last_remote_hash: finalHash,
-        last_local_hash: localHash,
-        synced_at: new Date().toISOString(),
-    });
-    const siteUrl = config.apiUrl ? config.apiUrl.replace("https://", "") : "web42.ai";
-    if (isCreated) {
-        console.log(chalk.green(`  New agent created: @${config.username}/${name}`));
-    }
-    else {
-        console.log(chalk.green(`  Updated: @${config.username}/${name}`));
-    }
-    console.log(chalk.dim(`  View at: ${siteUrl}/${config.username}/${name}`));
-    console.log(chalk.dim(`  Sync hash: ${finalHash.slice(0, 12)}...`));
-}
-// ---------------------------------------------------------------------------
-// Command
-// ---------------------------------------------------------------------------
-export const pushCommand = new Command("push")
-    .description("Push your agent package to the Web42 marketplace")
-    .option("--force", "Skip hash comparison and always push")
-    .option("--force-avatar", "Explicitly upload avatar even if no other changes")
-    .option("--agent <name>", "Push a specific agent (for multi-agent workspaces)")
-    .option("--url <url>", "Register as a live A2A agent at this public URL (e.g. ngrok URL)")
-    .action(async (opts) => {
-    const config = requireAuth();
-    const cwd = process.cwd();
-    // Detect multi-agent workspace (per-agent manifests in .web42/{name}/)
-    const web42Dir = join(cwd, ".web42");
-    const agentManifests = new Map();
-    let platform = "openclaw";
-    if (existsSync(web42Dir)) {
-        try {
-            const entries = readdirSync(web42Dir, { withFileTypes: true });
-            for (const entry of entries) {
-                if (!entry.isDirectory())
-                    continue;
-                const agentManifestPath = join(web42Dir, entry.name, "manifest.json");
-                if (existsSync(agentManifestPath)) {
-                    try {
-                        const m = JSON.parse(readFileSync(agentManifestPath, "utf-8"));
-                        agentManifests.set(entry.name, m);
-                        if (m.platform)
-                            platform = m.platform;
-                    }
-                    catch {
-                        // skip
-                    }
-                }
-            }
-        }
-        catch {
-            // .web42 not readable
-        }
-    }
-    const isMultiAgent = agentManifests.size > 0;
-    // Single-agent mode (e.g., OpenClaw)
-    if (!isMultiAgent) {
-        const manifestPath = join(cwd, "manifest.json");
-        if (!existsSync(manifestPath)) {
-            console.log(chalk.red("No manifest.json found. Run `web42 init` first."));
-            process.exit(1);
-        }
-        const 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);
-        }
-        if (manifest.platform)
-            platform = manifest.platform;
-        const adapter = resolvePlatform(platform);
-        const spinner = ora("Preparing agent package...").start();
-        try {
-            await pushSingleAgent({
-                cwd,
-                manifest,
-                distDir: join(cwd, ".web42", "dist"),
-                syncDir: cwd,
-                config,
-                force: opts.force,
-                forceAvatar: opts.forceAvatar,
-                spinner,
-                adapter,
-            });
-            spinner.succeed(`Pushed ${chalk.bold(`@${config.username}/${manifest.name}`)}`);
-            // Register as live A2A agent if --url provided
-            if (opts.url) {
-                const a2aSpinner = ora("Registering live agent URL...").start();
-                try {
-                    await apiPost(`/api/agents/${manifest.name}/a2a`, {
-                        a2a_url: opts.url,
-                        a2a_enabled: true,
-                        gateway_status: "live",
-                    });
-                    a2aSpinner.succeed(`Agent live at ${chalk.cyan(opts.url)}`);
-                }
-                catch (err) {
-                    a2aSpinner.fail("Failed to register live URL");
-                    console.error(chalk.red(err instanceof Error ? err.message : String(err)));
-                }
-            }
-        }
-        catch (error) {
-            spinner.fail("Push failed");
-            console.error(chalk.red(error instanceof Error ? error.message : String(error)));
-            process.exit(1);
-        }
-        return;
-    }
-    // Multi-agent mode
-    const adapter = resolvePlatform(platform);
-    let agentsToPush;
-    if (opts.agent) {
-        const manifest = agentManifests.get(opts.agent);
-        if (!manifest) {
-            console.log(chalk.red(`Agent "${opts.agent}" not found. Available: ${[...agentManifests.keys()].join(", ")}`));
-            process.exit(1);
-        }
-        agentsToPush = [[opts.agent, manifest]];
-    }
-    else {
-        agentsToPush = [...agentManifests.entries()];
-    }
-    const spinner = ora(`Pushing ${agentsToPush.length} agent(s)...`).start();
-    try {
-        let successCount = 0;
-        for (const [agentName, manifest] of agentsToPush) {
-            spinner.text = `Pushing ${agentName}...`;
-            const agentWeb42Dir = join(web42Dir, agentName);
-            const distDir = join(agentWeb42Dir, "dist");
-            await pushSingleAgent({
-                cwd,
-                manifest,
-                distDir,
-                syncDir: agentWeb42Dir,
-                config,
-                force: opts.force,
-                forceAvatar: opts.forceAvatar,
-                spinner,
-                adapter,
-                agentName,
-            });
-            successCount++;
-        }
-        spinner.succeed(`Pushed ${successCount} agent(s)`);
-    }
-    catch (error) {
-        spinner.fail("Push failed");
-        console.error(chalk.red(error.message));
-        process.exit(1);
-    }
-});

package/dist/commands/remix.d.ts

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

package/dist/commands/remix.js

@@ -1,49 +0,0 @@
-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/sync.d.ts

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

package/dist/commands/sync.js

@@ -1,98 +0,0 @@
-import { existsSync, readFileSync } from "fs";
-import { join } 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";
-import { buildLocalSnapshot, computeHashFromSnapshot, readSyncState, } from "../utils/sync.js";
-export const syncCommand = new Command("sync")
-    .description("Check sync status between local workspace and the 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. 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("Checking sync status...").start();
-    try {
-        // Resolve agent ID
-        const syncState = readSyncState(cwd);
-        let agentId = syncState?.agent_id ?? null;
-        if (!agentId) {
-            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);
-            }
-            agentId = agent.id;
-        }
-        // Compute local hash
-        const distDir = join(cwd, ".web42", "dist");
-        let localHash = null;
-        if (existsSync(distDir)) {
-            const snapshot = buildLocalSnapshot(cwd);
-            localHash = computeHashFromSnapshot(snapshot);
-        }
-        // Fetch remote hash
-        const remote = await apiGet(`/api/agents/${agentId}/sync`);
-        const remoteHash = remote.hash;
-        const lastRemoteHash = syncState?.last_remote_hash ?? null;
-        const lastLocalHash = syncState?.last_local_hash ?? null;
-        spinner.stop();
-        console.log();
-        console.log(chalk.bold(`  Sync status for @${config.username}/${manifest.name}`));
-        console.log();
-        console.log(`  Remote hash:  ${chalk.cyan(remoteHash.slice(0, 12))}...`);
-        if (localHash) {
-            console.log(`  Local hash:   ${chalk.cyan(localHash.slice(0, 12))}...`);
-        }
-        else {
-            console.log(`  Local hash:   ${chalk.dim("(not packed yet — run web42 pack first)")}`);
-        }
-        if (lastRemoteHash) {
-            console.log(`  Last synced:  ${chalk.dim(syncState.synced_at)}`);
-        }
-        else {
-            console.log(`  Last synced:  ${chalk.dim("never")}`);
-        }
-        console.log();
-        // Determine sync status by comparing each side against its last-known hash
-        if (!lastRemoteHash || !lastLocalHash) {
-            console.log(chalk.yellow("  Status: Never synced — run `web42 push` or `web42 pull`"));
-        }
-        else {
-            const localChanged = localHash !== null && localHash !== lastLocalHash;
-            const remoteChanged = remoteHash !== lastRemoteHash;
-            if (localChanged && remoteChanged) {
-                console.log(chalk.red("  Status: Both local and remote have changed since last sync"));
-                console.log(chalk.dim("  Use `web42 push --force` or `web42 pull --force` to resolve"));
-            }
-            else if (localChanged) {
-                console.log(chalk.yellow("  Status: Local changes (push to sync)"));
-                console.log(chalk.dim("  Run `web42 push` to update the marketplace"));
-            }
-            else if (remoteChanged) {
-                console.log(chalk.yellow("  Status: Remote changes (pull to sync)"));
-                console.log(chalk.dim("  Run `web42 pull` to update local files"));
-            }
-            else {
-                console.log(chalk.green("  Status: In sync"));
-            }
-        }
-        console.log();
-    }
-    catch (error) {
-        spinner.fail("Sync status check failed");
-        console.error(chalk.red(error.message));
-        process.exit(1);
-    }
-});

package/dist/commands/uninstall.d.ts

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

package/dist/commands/uninstall.js

@@ -1,54 +0,0 @@
-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

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

package/dist/commands/update.js

@@ -1,59 +0,0 @@
-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);
-        }
-    });
-}