@web42/cli 0.1.17 → 0.2.4

package/dist/commands/push.js

@@ -1,11 +1,11 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync, statSync } from "fs";
-import { join } from "path";
+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 { openclawAdapter } from "../platforms/openclaw/adapter.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) {
@@ -21,40 +21,28 @@ function mimeFromExtension(ext) {
     };
     return map[ext.toLowerCase()] ?? "application/octet-stream";
 }
-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")
-    .action(async (opts) => {
-    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();
+/**
+ * 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 .web42/dist/
+    // Step 1: Pack into dist/ (if not already packed)
     // -----------------------------------------------------------------------
-    const distDir = join(cwd, ".web42", "dist");
     if (existsSync(distDir)) {
-        spinner.text = "Reading packed artifact from .web42/dist/...";
         const packedManifestPath = join(distDir, "manifest.json");
         if (existsSync(packedManifestPath)) {
             manifest = JSON.parse(readFileSync(packedManifestPath, "utf-8"));
         }
     }
     else {
-        spinner.text = "Packing agent into .web42/dist/...";
-        const result = await openclawAdapter.pack({
+        spinner.text = `Packing ${opts.agentName ?? "agent"}...`;
+        const result = await opts.adapter.pack({
             cwd,
-            outputDir: ".web42/dist",
+            outputDir: distDir.startsWith(cwd) ? distDir.slice(cwd.length + 1) : distDir,
+            agentName: opts.agentName,
         });
         const internalPrefixes = [];
         for (const f of result.files) {
@@ -68,7 +56,8 @@ export const pushCommand = new Command("push")
         if (internalPrefixes.length > 0) {
             result.files = result.files.filter((f) => !internalPrefixes.some((p) => f.path.startsWith(p)));
         }
-        const existingKeys = new Set((manifest.configVariables ?? []).map((v) => v.key));
+        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)
@@ -88,42 +77,53 @@ export const pushCommand = new Command("push")
     // -----------------------------------------------------------------------
     // Step 2: Resolve agent ID (create if first push)
     // -----------------------------------------------------------------------
-    spinner.text = "Resolving agent...";
-    let syncState = readSyncState(cwd);
+    spinner.text = `Resolving ${opts.agentName ?? "agent"}...`;
+    let syncState = readSyncState(syncDir);
     let agentId = syncState?.agent_id ?? null;
     let isCreated = false;
-    if (!agentId) {
+    // Always resolve agent metadata (README, marketplace config, avatar)
+    // and upsert the agent record so metadata updates propagate on every push.
+    {
         let readme = "";
-        const readmePath = join(cwd, "README.md");
-        if (existsSync(readmePath)) {
-            readme = readFileSync(readmePath, "utf-8");
+        // 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;
-        // Check for avatar/avatar.png or avatars/avatar.png
-        const avatarSearchPaths = [
-            join(cwd, "avatar/avatar.png"),
-            join(cwd, "avatars/avatar.png"),
-            join(cwd, "avatar.png"),
-            // Also check .web42/ for the one managed by build/pack
-            join(cwd, ".web42/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;
+        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
                     }
-                }
-                catch (e) {
-                    // Skip
                 }
             }
         }
+        const name = manifest.name ?? "";
         const agentResult = await apiPost("/api/agents", {
-            slug: manifest.name,
-            name: manifest.name,
+            slug: name,
+            name,
             description: manifest.description ?? "",
             readme,
             manifest,
@@ -137,14 +137,22 @@ export const pushCommand = new Command("push")
     // Step 3: Build local snapshot and compute hash
     // -----------------------------------------------------------------------
     spinner.text = "Building snapshot...";
-    const snapshot = buildLocalSnapshot(cwd);
+    // 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 local hash with last known local hash (unless --force)
+    // 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}/${manifest.name}`)} has no local changes since last sync.`);
+            spinner.succeed(`${chalk.bold(`@${config.username}/${name}`)} has no local changes since last sync.`);
             return;
         }
     }
@@ -152,79 +160,211 @@ export const pushCommand = new Command("push")
     // Step 5: Push snapshot
     // -----------------------------------------------------------------------
     spinner.text = `Pushing ${snapshot.files.length} files...`;
-    try {
-        const pushResult = await apiPost(`/api/agents/${agentId}/sync/push`, snapshot);
-        let finalHash = pushResult.hash;
-        // -------------------------------------------------------------------
-        // Step 6: Upload avatar if present
-        // -------------------------------------------------------------------
-        const avatarPath = findLocalAvatar(cwd) || 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(cwd);
-        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];
-                // Try .web42/resources/ first (legacy/tracked), then root resources/
-                let resFilePath = join(cwd, ".web42", "resources", meta.file);
-                if (!existsSync(resFilePath)) {
-                    resFilePath = join(cwd, "resources", meta.file);
+    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
+                    }
                 }
-                if (existsSync(resFilePath)) {
-                    const resBuffer = readFileSync(resFilePath);
-                    const ext = meta.file.split(".").pop() ?? "";
-                    const blob = new Blob([resBuffer], {
-                        type: mimeFromExtension(ext),
+            }
+        }
+        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",
                     });
-                    resForm.append(`resource_${i}`, blob, meta.file);
+                    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)));
                 }
             }
-            const resResult = await apiFormData(`/api/agents/${agentId}/sync/resources`, resForm);
-            finalHash = resResult.hash;
-        }
-        // -------------------------------------------------------------------
-        // Step 8: Save sync state
-        // -------------------------------------------------------------------
-        writeSyncState(cwd, {
-            agent_id: agentId,
-            last_remote_hash: finalHash,
-            last_local_hash: localHash,
-            synced_at: new Date().toISOString(),
-        });
-        spinner.succeed(`Pushed ${chalk.bold(`@${config.username}/${manifest.name}`)} (${snapshot.files.length} files)`);
-        if (isCreated) {
-            console.log(chalk.green("  New agent created!"));
         }
-        else {
-            console.log(chalk.green("  Agent updated."));
+        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++;
         }
-        console.log(chalk.dim(`  View at: ${config.apiUrl ? config.apiUrl.replace("https://", "") : "web42.ai"}/${config.username}/${manifest.name}`));
-        console.log(chalk.dim(`  Sync hash: ${finalHash.slice(0, 12)}...`));
+        spinner.succeed(`Pushed ${successCount} agent(s)`);
     }
     catch (error) {
         spinner.fail("Push failed");

package/dist/commands/send.d.ts

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

package/dist/commands/send.js

@@ -0,0 +1,124 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { v4 as uuidv4 } from "uuid";
+import { requireAuth, setConfigValue, getConfigValue } from "../utils/config.js";
+import { apiGet } from "../utils/api.js";
+export const sendCommand = new Command("send")
+    .description("Send a message to a live web42 agent")
+    .argument("<agent>", "Agent handle, e.g. @javier/gilfoyle")
+    .argument("<message>", "Message to send")
+    .option("--new", "Start a new conversation (clears saved context)")
+    .action(async (agentHandle, userMessage, opts) => {
+    const config = requireAuth();
+    // 1. Parse @user/slug
+    const match = agentHandle.match(/^@?([\w-]+)\/([\w-]+)$/);
+    if (!match) {
+        console.error(chalk.red("Invalid agent handle. Expected format: @user/agent-slug"));
+        process.exit(1);
+    }
+    const [, username, slug] = match;
+    // 2. Look up agent A2A URL from marketplace
+    const spinner = ora(`Looking up @${username}/${slug}...`).start();
+    let a2aData;
+    try {
+        a2aData = await apiGet(`/api/agents/${slug}/a2a`);
+    }
+    catch {
+        spinner.fail(`Agent @${username}/${slug} not found`);
+        process.exit(1);
+    }
+    if (!a2aData.a2a_enabled || !a2aData.a2a_url) {
+        spinner.fail(`@${username}/${slug} is not live. Publisher must run: web42 serve --url <url>`);
+        process.exit(1);
+    }
+    spinner.stop();
+    // 3. Resolve contextId — reuse existing session or start fresh
+    const contextKey = `context.${username}.${slug}`;
+    let contextId = getConfigValue(contextKey) ?? uuidv4();
+    if (opts.new) {
+        contextId = uuidv4();
+    }
+    setConfigValue(contextKey, contextId);
+    // 4. Dynamically import @a2a-js/sdk client (ESM)
+    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);
+    }
+    // 5. Bearer token interceptor
+    const token = config.token;
+    const bearerInterceptor = {
+        before: async (args) => {
+            if (!args.options) {
+                args.options = {};
+            }
+            args.options.serviceParameters = {
+                ...(args.options.serviceParameters ?? {}),
+                Authorization: `Bearer ${token}`,
+            };
+        },
+        after: async () => { },
+    };
+    // 6. Create A2A client
+    const connectSpinner = ora(`Connecting to @${username}/${slug}...`).start();
+    let client;
+    try {
+        const factory = new ClientFactory(ClientFactoryOptions.createFrom(ClientFactoryOptions.default, {
+            transports: [new JsonRpcTransportFactory()],
+            clientConfig: {
+                interceptors: [bearerInterceptor],
+            },
+        }));
+        client = await factory.createFromUrl(a2aData.a2a_url);
+        connectSpinner.stop();
+    }
+    catch {
+        connectSpinner.fail(`Could not reach agent at ${a2aData.a2a_url}`);
+        console.error(chalk.dim("Is the publisher running web42 serve? Is ngrok still active?"));
+        process.exit(1);
+    }
+    // 7. Stream response to stdout
+    try {
+        const stream = client.sendMessageStream({
+            message: {
+                messageId: uuidv4(),
+                role: "user",
+                parts: [{ kind: "text", text: userMessage }],
+                kind: "message",
+                contextId,
+            },
+        });
+        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 === "status-update") {
+                const update = event;
+                if (update.status?.state === "failed") {
+                    console.error(chalk.red("\nAgent returned an error."));
+                    process.exit(1);
+                }
+            }
+        }
+        process.stdout.write("\n");
+    }
+    catch (err) {
+        console.error(chalk.red("\nConnection lost."), chalk.dim(String(err)));
+        process.exit(1);
+    }
+});

package/dist/commands/serve.d.ts

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