kradle 0.6.6 → 0.6.8

package/dist/lib/local-runner.js

@@ -0,0 +1,432 @@
+import { execFileSync, execSync, spawn } from "node:child_process";
+import crypto from "node:crypto";
+import { existsSync } from "node:fs";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import pc from "picocolors";
+import * as tar from "tar";
+import { MINECRAFT_ARENA_MANAGER_TAG } from "../config/releases/arena-minecraft.js";
+const MC_SERVER_IMAGE = "marctv/minecraft-papermc-server:1.20.4";
+const DEFAULT_ARENA_IMAGE_TEMPLATE = "us-central1-docker.pkg.dev/kradle-prod-449119/prod-arenas/minecraft:{SHA}";
+const MC_PORT = 25565;
+const SERVER_READY_TIMEOUT_MS = 120_000;
+const SERVER_READY_POLL_MS = 3_000;
+const CONTAINER_NAME_PREFIX_MC = "kradle-mc-server";
+const CONTAINER_NAME_PREFIX_ARENA = "kradle-arena";
+export class LocalRunner {
+    config;
+    mcContainerId = null;
+    arenaContainerId = null;
+    logProcess = null;
+    tempDir = null;
+    shutdownInProgress = false;
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Main orchestration — starts MC server + arena, streams logs, waits for completion.
+     */
+    async run(log) {
+        this.ensureDockerAvailable();
+        const arenaImage = this.resolveArenaImage();
+        log(`Arena image: ${arenaImage}`);
+        // Pull images
+        log("Pulling Docker images (this may take a while on first run)...");
+        this.pullImageIfNeeded(MC_SERVER_IMAGE, log);
+        this.pullImageIfNeeded(arenaImage, log);
+        // Clean up orphaned containers from previous runs
+        LocalRunner.cleanupOrphans(log);
+        // Prepare server directory (marctv image mounts entire /data)
+        this.tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "kradle-local-run-"));
+        const serverDir = path.join(this.tempDir, "server");
+        const worldDir = path.join(serverDir, "world");
+        await fs.mkdir(worldDir, { recursive: true });
+        // Download world
+        const worldSlug = this.config.challengeData.world;
+        if (worldSlug) {
+            log(`Downloading world: ${worldSlug}...`);
+            await this.downloadWorld(worldDir);
+        }
+        else {
+            log("No world specified, using empty world.");
+        }
+        // Start Minecraft server
+        log("Starting Minecraft server...");
+        this.mcContainerId = await this.startMinecraftServer(serverDir, worldDir);
+        log(`MC server container: ${this.mcContainerId.slice(0, 12)}`);
+        // Wait for server to be ready
+        log("Waiting for Minecraft server to be ready...");
+        await this.waitForServerReady(log);
+        log("");
+        log(pc.green("========================================"));
+        log(pc.green("  Minecraft server is ready!"));
+        log(pc.green(`  Connect to localhost:${MC_PORT} to join the live game`));
+        log(pc.green("  You will be automatically OP'd on join"));
+        log(pc.green("========================================"));
+        log("");
+        // Start arena-minecraft
+        log("Starting arena-minecraft...");
+        this.arenaContainerId = this.startArena(arenaImage);
+        log(`Arena container: ${this.arenaContainerId.slice(0, 12)}`);
+        // Stream arena logs
+        log("\n--- Arena logs ---\n");
+        this.logProcess = this.streamLogs(this.arenaContainerId, log);
+        // Wait for arena to finish
+        await this.waitForCompletion();
+        log("\n--- Arena finished ---\n");
+    }
+    /**
+     * Gracefully shut down all containers and clean up temp files.
+     */
+    async cleanup() {
+        if (this.shutdownInProgress)
+            return;
+        this.shutdownInProgress = true;
+        // Kill log streaming
+        if (this.logProcess) {
+            this.logProcess.kill();
+            this.logProcess = null;
+        }
+        // Graceful arena shutdown
+        if (this.arenaContainerId) {
+            try {
+                await fetch(`http://localhost:3002/shutdown`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({ reason: "CLI shutdown" }),
+                    signal: AbortSignal.timeout(10_000),
+                });
+                await new Promise((r) => setTimeout(r, 3_000));
+            }
+            catch {
+                // Arena may already be stopped
+            }
+            this.stopContainer(this.arenaContainerId);
+            this.arenaContainerId = null;
+        }
+        // Stop MC server
+        if (this.mcContainerId) {
+            this.stopContainer(this.mcContainerId);
+            this.mcContainerId = null;
+        }
+        // Clean up temp directory
+        if (this.tempDir) {
+            await fs.rm(this.tempDir, { recursive: true, force: true });
+            this.tempDir = null;
+        }
+    }
+    // --- Private methods ---
+    ensureDockerAvailable() {
+        try {
+            this.docker("info", { stdio: "ignore" });
+        }
+        catch {
+            throw new Error("Docker is required for --local runs but is not available.\n" +
+                "Make sure Docker Desktop is running, or install it from https://docker.com");
+        }
+    }
+    resolveArenaImage() {
+        if (this.config.arenaImageOverride) {
+            return this.config.arenaImageOverride;
+        }
+        return DEFAULT_ARENA_IMAGE_TEMPLATE.replace("{SHA}", MINECRAFT_ARENA_MANAGER_TAG);
+    }
+    pullImageIfNeeded(image, log) {
+        try {
+            this.docker(`inspect --type=image ${image}`, { stdio: "ignore" });
+        }
+        catch {
+            log(`Pulling ${image}...`);
+            this.docker(`pull ${image}`, { stdio: "inherit" });
+        }
+    }
+    async downloadWorld(worldDir) {
+        const worldSlug = this.config.challengeData.world;
+        if (!worldSlug)
+            return;
+        const api = new (await import("./api-client.js")).ApiClient(this.config.apiUrl, this.config.apiKey);
+        const { downloadUrl } = await api.getWorldDownloadUrl(worldSlug);
+        const response = await fetch(downloadUrl);
+        if (!response.ok) {
+            throw new Error(`Failed to download world "${worldSlug}": ${response.status} ${response.statusText}`);
+        }
+        // Save and extract tarball
+        const tarballPath = path.join(worldDir, "world.tar.gz");
+        const buffer = await response.arrayBuffer();
+        await fs.writeFile(tarballPath, Buffer.from(buffer));
+        // Extract to temp, then find level.dat root
+        const extractDir = path.join(worldDir, "_extract");
+        await fs.mkdir(extractDir, { recursive: true });
+        await tar.extract({ file: tarballPath, cwd: extractDir });
+        // Find the directory containing level.dat (may be nested under an ID folder)
+        const levelDatDir = await this.findLevelDat(extractDir);
+        // Move world files to worldDir root
+        const entries = await fs.readdir(levelDatDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const src = path.join(levelDatDir, entry.name);
+            const dst = path.join(worldDir, entry.name);
+            await fs.rename(src, dst);
+        }
+        // Clean up extraction artifacts
+        await fs.rm(extractDir, { recursive: true, force: true });
+        await fs.rm(tarballPath, { force: true });
+    }
+    async findLevelDat(dir) {
+        if (existsSync(path.join(dir, "level.dat"))) {
+            return dir;
+        }
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                const sub = path.join(dir, entry.name);
+                if (existsSync(path.join(sub, "level.dat"))) {
+                    return sub;
+                }
+            }
+        }
+        throw new Error(`Could not find level.dat in downloaded world`);
+    }
+    async startMinecraftServer(serverDir, worldDir) {
+        const containerName = `${CONTAINER_NAME_PREFIX_MC}-${crypto.randomUUID().slice(0, 8)}`;
+        const gameMode = this.config.challengeConfig.challengeConfig?.gameMode ?? "survival";
+        // Write server.properties (marctv image has no env vars for these)
+        const serverProperties = [
+            `server-port=${MC_PORT}`,
+            `max-players=10`,
+            `gamemode=${gameMode}`,
+            `difficulty=normal`,
+            `spawn-protection=0`,
+            `online-mode=false`,
+            `enable-command-block=false`,
+            `enable-rcon=true`,
+            `rcon.password=minecraft`,
+            `rcon.port=25575`,
+            `level-name=world`,
+            `function-permission-level=4`,
+        ].join("\n");
+        await fs.writeFile(path.join(serverDir, "server.properties"), serverProperties);
+        // Write ops.json with offline-mode UUIDs for watcher/viewer
+        const operators = [
+            { name: "watcher", uuid: this.generateOfflineUUID("watcher") },
+            { name: "KradleWebViewer", uuid: this.generateOfflineUUID("KradleWebViewer") },
+        ];
+        const opsJson = operators.map((op) => ({
+            uuid: op.uuid,
+            name: op.name,
+            level: 4,
+            bypassesPlayerLimit: false,
+        }));
+        await fs.writeFile(path.join(serverDir, "ops.json"), JSON.stringify(opsJson, null, 2));
+        // Copy datapack into world dir
+        const datapackDst = path.join(worldDir, "datapacks", "kradle");
+        if (existsSync(this.config.datapackPath)) {
+            execSync(`cp -r "${this.config.datapackPath}" "${datapackDst}"`);
+        }
+        // Add auto-op datapack — ops any player who joins (local dev convenience)
+        await this.writeAutoOpDatapack(path.join(worldDir, "datapacks", "kradle-local-ops"));
+        const args = [
+            "run",
+            "-d",
+            "--name",
+            containerName,
+            "-p",
+            `${MC_PORT}:${MC_PORT}`,
+            "-v",
+            `${serverDir}:/data`,
+            "-e",
+            "MEMORYSIZE=2G",
+            MC_SERVER_IMAGE,
+        ];
+        return this.docker(args.join(" ")).trim();
+    }
+    async waitForServerReady(log) {
+        const start = Date.now();
+        while (Date.now() - start < SERVER_READY_TIMEOUT_MS) {
+            try {
+                const logs = this.docker(`logs ${this.mcContainerId}`).toString();
+                if (logs.includes("Done (")) {
+                    return;
+                }
+            }
+            catch {
+                // Container may not be ready yet
+            }
+            const elapsed = Math.round((Date.now() - start) / 1000);
+            log(`  Waiting... (${elapsed}s)`);
+            await new Promise((r) => setTimeout(r, SERVER_READY_POLL_MS));
+        }
+        throw new Error(`Minecraft server did not become ready within ${SERVER_READY_TIMEOUT_MS / 1000}s`);
+    }
+    startArena(arenaImage) {
+        const containerName = `${CONTAINER_NAME_PREFIX_ARENA}-${crypto.randomUUID().slice(0, 8)}`;
+        // Pass the full backend job response directly to the arena — same as Studio.
+        const jobPayload = JSON.stringify(this.config.jobPayload);
+        // Arena prepends /v0 to all API paths, so strip it from our URL to avoid /v0/v0
+        const arenaApiUrl = this.config.apiUrl.replace(/\/v0\/?$/, "");
+        // Derive agent URL from API URL (dev-api → dev-agents, api → agents, etc.)
+        const agentBaseUrl = arenaApiUrl.replace("api.kradle.ai", "agents.kradle.ai");
+        const args = [
+            "run",
+            "-d",
+            "--name",
+            containerName,
+            `--net=container:${this.mcContainerId}`,
+            "-e",
+            "PORT=3002",
+            "-e",
+            `KRADLE_API_URL=${arenaApiUrl}`,
+            "-e",
+            `PROMPT_AGENT_BASE_URL=${agentBaseUrl}`,
+            "-e",
+            "MAX_IDLE_TIME=-1",
+            arenaImage,
+            `--job=${jobPayload}`,
+        ];
+        // Use execFileSync to bypass shell — the JSON payload contains quotes,
+        // parentheses, and other characters that break shell parsing.
+        const result = execFileSync("docker", args, {
+            encoding: "utf-8",
+            env: this.getDockerEnv(),
+        });
+        return (result ?? "").trim();
+    }
+    /**
+     * Write a small datapack that auto-ops any player who joins.
+     * Uses a tick function with function-permission-level=4 to run /op on new players.
+     */
+    async writeAutoOpDatapack(datapackDir) {
+        const functionsDir = path.join(datapackDir, "data", "kradle_local", "functions");
+        const tagsDir = path.join(datapackDir, "data", "minecraft", "tags", "functions");
+        await fs.mkdir(functionsDir, { recursive: true });
+        await fs.mkdir(tagsDir, { recursive: true });
+        await fs.writeFile(path.join(datapackDir, "pack.mcmeta"), JSON.stringify({ pack: { pack_format: 26, description: "Auto-OP for local dev" } }));
+        // Tick function: op any player not yet tagged, then tag them so it only runs once
+        await fs.writeFile(path.join(functionsDir, "auto_op.mcfunction"), "execute as @a[tag=!kradle_opped] run op @s[type=player]\nexecute as @a[tag=!kradle_opped] run tag @s add kradle_opped\n");
+        // Register as a tick function
+        await fs.writeFile(path.join(tagsDir, "tick.json"), JSON.stringify({ values: ["kradle_local:auto_op"] }));
+    }
+    /**
+     * Generate an offline-mode UUID from a Minecraft username.
+     * Replicates the Java algorithm: UUID.nameUUIDFromBytes("OfflinePlayer:" + name)
+     */
+    generateOfflineUUID(username) {
+        const md5 = crypto.createHash("md5").update(`OfflinePlayer:${username}`).digest();
+        const bytes = [...md5];
+        bytes[6] = (bytes[6] & 0x0f) | 0x30; // version 3
+        bytes[8] = (bytes[8] & 0x3f) | 0x80; // variant 2
+        const hex = bytes.map((b) => b.toString(16).padStart(2, "0"));
+        return [
+            hex.slice(0, 4).join(""),
+            hex.slice(4, 6).join(""),
+            hex.slice(6, 8).join(""),
+            hex.slice(8, 10).join(""),
+            hex.slice(10, 16).join(""),
+        ].join("-");
+    }
+    streamLogs(containerId, log) {
+        const proc = spawn("docker", ["logs", "-f", containerId], {
+            stdio: ["ignore", "pipe", "pipe"],
+            env: this.getDockerEnv(),
+        });
+        proc.stdout?.on("data", (data) => {
+            for (const line of data.toString().split("\n")) {
+                if (line.trim())
+                    log(line);
+            }
+        });
+        proc.stderr?.on("data", (data) => {
+            for (const line of data.toString().split("\n")) {
+                if (line.trim())
+                    log(line);
+            }
+        });
+        return proc;
+    }
+    async waitForCompletion() {
+        // Wait for the arena container to exit
+        return new Promise((resolve) => {
+            const check = () => {
+                try {
+                    const result = this.docker(`inspect --format={{.State.Running}} ${this.arenaContainerId}`).trim();
+                    if (result === "false") {
+                        resolve();
+                        return;
+                    }
+                }
+                catch {
+                    // Container removed or not found — treat as finished
+                    resolve();
+                    return;
+                }
+                setTimeout(check, 3_000);
+            };
+            // Start checking after a brief delay
+            setTimeout(check, 5_000);
+        });
+    }
+    stopContainer(containerId) {
+        try {
+            this.docker(`stop ${containerId}`, { timeout: 30_000 });
+        }
+        catch {
+            // May already be stopped
+        }
+        try {
+            this.docker(`rm -f ${containerId}`);
+        }
+        catch {
+            // May already be removed
+        }
+    }
+    /**
+     * Find and remove orphaned containers from previous local runs.
+     */
+    static cleanupOrphans(log) {
+        const env = { ...process.env, PATH: `${process.env.PATH}:/opt/homebrew/bin:/usr/local/bin` };
+        for (const prefix of [CONTAINER_NAME_PREFIX_MC, CONTAINER_NAME_PREFIX_ARENA]) {
+            try {
+                const output = execSync(`docker ps -a --filter "name=${prefix}" --format "{{.ID}}"`, {
+                    encoding: "utf-8",
+                    env,
+                }).trim();
+                if (output) {
+                    for (const id of output.split("\n")) {
+                        if (id.trim()) {
+                            log?.(`Cleaning up orphaned container: ${id.trim().slice(0, 12)}`);
+                            try {
+                                execSync(`docker rm -f ${id.trim()}`, { env, stdio: "ignore" });
+                            }
+                            catch {
+                                // Ignore
+                            }
+                        }
+                    }
+                }
+            }
+            catch {
+                // Docker not available or no containers found
+            }
+        }
+    }
+    /**
+     * Run a Docker command with PATH augmented for macOS Docker Desktop.
+     */
+    docker(args, options) {
+        const env = this.getDockerEnv();
+        const stdio = options?.stdio ?? "pipe";
+        const result = execSync(`docker ${args}`, {
+            encoding: "utf-8",
+            env,
+            stdio,
+            timeout: options?.timeout,
+        });
+        return result ?? "";
+    }
+    getDockerEnv() {
+        return {
+            ...process.env,
+            PATH: `${process.env.PATH}:/opt/homebrew/bin:/usr/local/bin`,
+        };
+    }
+}

package/dist/lib/schemas.d.ts

@@ -192,6 +192,7 @@ export declare const JobResponseSchema: z.ZodObject<{
         inputOrder: z.ZodNumber;
     }, z.core.$strip>>>;
     id: z.ZodOptional<z.ZodString>;
+    jobApiKey: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const RunStatusSchema: z.ZodObject<{
     id: z.ZodString;

package/dist/lib/schemas.js

@@ -73,6 +73,7 @@ export const JobResponseSchema = z.object({
     runIds: z.array(z.string()).optional(),
     participants: z.record(z.string(), RunParticipantSchema).optional(),
     id: z.string().optional(),
+    jobApiKey: z.string().optional(),
 });
 export const RunStatusSchema = z.object({
     id: z.string(),

package/dist/lib/validator.js

@@ -12,6 +12,8 @@ import pc from "picocolors";
  */
 const FILTERED_ERROR_MESSAGES = [
     "Fake names cannot be longer than 40 characters", // Actually they can be longer
+    "Objective names cannot be longer than 16 characters", // Actually they can be longer
+    "Player names cannot be longer than 16 characters", // Actually they can be longer
 ];
 /**
  * Get a human-readable severity label with color

package/oclif.manifest.json

@@ -87,50 +87,6 @@
         "update.js"
       ]
     },
-    "agent:list": {
-      "aliases": [],
-      "args": {},
-      "description": "List all agents",
-      "examples": [
-        "<%= config.bin %> <%= command.id %>"
-      ],
-      "flags": {
-        "api-key": {
-          "description": "Kradle API key",
-          "env": "KRADLE_API_KEY",
-          "name": "api-key",
-          "required": true,
-          "hasDynamicHelp": false,
-          "multiple": false,
-          "type": "option"
-        },
-        "api-url": {
-          "description": "Kradle Web API URL",
-          "env": "KRADLE_API_URL",
-          "name": "api-url",
-          "required": true,
-          "default": "https://api.kradle.ai/v0",
-          "hasDynamicHelp": false,
-          "multiple": false,
-          "type": "option"
-        }
-      },
-      "hasDynamicHelp": false,
-      "hiddenAliases": [],
-      "id": "agent:list",
-      "pluginAlias": "kradle",
-      "pluginName": "kradle",
-      "pluginType": "core",
-      "strict": true,
-      "enableJsonFlag": false,
-      "isESM": true,
-      "relativePath": [
-        "dist",
-        "commands",
-        "agent",
-        "list.js"
-      ]
-    },
     "ai-docs:challenges-sdk": {
       "aliases": [],
       "args": {
@@ -215,12 +171,12 @@
       "aliases": [],
       "args": {
         "challengeSlug": {
-          "description": "Challenge slug to build and upload. Can be used multiple times to build and upload multiple challenges at once. Incompatible with --all flag.",
+          "description": "Challenge slug to build. Can be used multiple times to build multiple challenges at once. Incompatible with --all flag.",
           "name": "challengeSlug",
           "required": false
         }
       },
-      "description": "Build and upload challenge datapack and config",
+      "description": "Build challenge datapack locally, with optional upload",
       "examples": [
         "<%= config.bin %> <%= command.id %> my-challenge",
         "<%= config.bin %> <%= command.id %> my-challenge my-other-challenge",
@@ -242,30 +198,34 @@
           "type": "boolean"
         },
         "no-validate": {
-          "description": "Skip datapack validation before upload",
+          "description": "Skip datapack validation",
           "name": "no-validate",
           "allowNo": false,
           "type": "boolean"
         },
-        "api-key": {
-          "description": "Kradle API key",
-          "env": "KRADLE_API_KEY",
-          "name": "api-key",
-          "required": true,
-          "hasDynamicHelp": false,
-          "multiple": false,
-          "type": "option"
+        "no-upload": {
+          "description": "Build datapack locally only (skip cloud config/datapack upload)",
+          "name": "no-upload",
+          "allowNo": false,
+          "type": "boolean"
         },
         "api-url": {
           "description": "Kradle Web API URL",
           "env": "KRADLE_API_URL",
           "name": "api-url",
-          "required": true,
           "default": "https://api.kradle.ai/v0",
           "hasDynamicHelp": false,
           "multiple": false,
           "type": "option"
         },
+        "api-key": {
+          "description": "Kradle API key",
+          "env": "KRADLE_API_KEY",
+          "name": "api-key",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
         "challenges-path": {
           "description": "Absolute path to the challenges directory",
           "env": "KRADLE_CHALLENGES_PATH",
@@ -575,7 +535,10 @@
         "<%= config.bin %> <%= command.id %> my-challenge --no-open",
         "<%= config.bin %> <%= command.id %> my-challenge --no-wait",
         "<%= config.bin %> <%= command.id %> my-challenge team-kradle:gemini-3-flash,team-kradle:grok-4-1-fast",
-        "<%= config.bin %> <%= command.id %> capture-the-flag red=team-kradle:gemini-3-flash blue=team-kradle:grok-4-1-fast"
+        "<%= config.bin %> <%= command.id %> capture-the-flag red=team-kradle:gemini-3-flash blue=team-kradle:grok-4-1-fast",
+        "<%= config.bin %> <%= command.id %> my-challenge --local",
+        "<%= config.bin %> <%= command.id %> my-challenge --local team-kradle:gemini-3-flash,team-kradle:grok-4-1-fast",
+        "<%= config.bin %> <%= command.id %> my-challenge --local --arena-image us-central1-docker.pkg.dev/mckradle-3c267/dev-arenas/minecraft:abc1234"
       ],
       "flags": {
         "studio": {
@@ -592,6 +555,21 @@
           "allowNo": false,
           "type": "boolean"
         },
+        "local": {
+          "char": "l",
+          "description": "Run the challenge locally using Docker (spins up MC server + arena-minecraft)",
+          "name": "local",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "arena-image": {
+          "description": "Override arena-minecraft Docker image URL (for testing dev/staging builds)",
+          "env": "KRADLE_ARENA_IMAGE",
+          "name": "arena-image",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
         "no-open": {
           "description": "Don't open the run URL in the browser",
           "name": "no-open",
@@ -664,6 +642,15 @@
           "hasDynamicHelp": false,
           "multiple": false,
           "type": "option"
+        },
+        "challenges-path": {
+          "description": "Absolute path to the challenges directory",
+          "env": "KRADLE_CHALLENGES_PATH",
+          "name": "challenges-path",
+          "default": "~/Documents/kradle-studio/challenges",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
         }
       },
       "hasDynamicHelp": false,
@@ -1403,6 +1390,50 @@
         "push.js"
       ]
     },
+    "agent:list": {
+      "aliases": [],
+      "args": {},
+      "description": "List all agents",
+      "examples": [
+        "<%= config.bin %> <%= command.id %>"
+      ],
+      "flags": {
+        "api-key": {
+          "description": "Kradle API key",
+          "env": "KRADLE_API_KEY",
+          "name": "api-key",
+          "required": true,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "api-url": {
+          "description": "Kradle Web API URL",
+          "env": "KRADLE_API_URL",
+          "name": "api-url",
+          "required": true,
+          "default": "https://api.kradle.ai/v0",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "agent:list",
+      "pluginAlias": "kradle",
+      "pluginName": "kradle",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "agent",
+        "list.js"
+      ]
+    },
     "challenge:runs:get": {
       "aliases": [],
       "args": {
@@ -1524,5 +1555,5 @@
       ]
     }
   },
-  "version": "0.6.6"
+  "version": "0.6.8"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "kradle",
-	"version": "0.6.6",
+	"version": "0.6.8",
 	"description": "Kradle's CLI. Manage challenges, experiments, agents and more!",
 	"keywords": [
 		"cli"