@kradle/cli 0.2.5 → 0.2.7

package/dist/commands/challenge/pull.js

@@ -100,7 +100,7 @@ export default class Pull extends Command {
         const tempTarballPath = path.join(flags["challenges-path"], `${challenge.shortSlug}-pull-temp.tar.gz`);
         const tasks = new Listr([
             {
-                title: "Downloading challenge tarball",
+                title: "Downloading challenge",
                 task: async (_, task) => {
                     const { downloadUrl } = await api.getChallengeDownloadUrl(challengeSlug);
                     const response = await fetch(downloadUrl);
@@ -110,7 +110,7 @@ export default class Pull extends Command {
                     const buffer = await response.arrayBuffer();
                     await fs.mkdir(path.dirname(tempTarballPath), { recursive: true });
                     await fs.writeFile(tempTarballPath, Buffer.from(buffer));
-                    task.title = "Downloaded challenge tarball";
+                    task.title = "Downloaded challenge";
                 },
             },
             {

package/dist/commands/world/delete.d.ts

@@ -0,0 +1,14 @@
+import { Command } from "@oclif/core";
+export default class Delete extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        worldSlug: import("@oclif/core/interfaces").Arg<string>;
+    };
+    static flags: {
+        "api-key": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        "api-url": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/world/delete.js

@@ -0,0 +1,80 @@
+import fs from "node:fs/promises";
+import { Command, Flags } from "@oclif/core";
+import enquirer from "enquirer";
+import pc from "picocolors";
+import { ApiClient } from "../../lib/api-client.js";
+import { getWorldSlugArgument } from "../../lib/arguments.js";
+import { getConfigFlags } from "../../lib/flags.js";
+import { World } from "../../lib/world.js";
+export default class Delete extends Command {
+    static description = "Delete a world locally, from the cloud, or both";
+    static examples = [
+        "<%= config.bin %> <%= command.id %> my-world",
+        "<%= config.bin %> <%= command.id %> my-world --yes",
+    ];
+    static args = {
+        worldSlug: getWorldSlugArgument({ description: "World slug to delete" }),
+    };
+    static flags = {
+        yes: Flags.boolean({ char: "y", description: "Skip confirmation prompts", default: false }),
+        ...getConfigFlags("api-key", "api-url"),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Delete);
+        const api = new ApiClient(flags["api-url"], flags["api-key"]);
+        const world = new World(args.worldSlug);
+        const existsLocally = world.exists();
+        const existsInCloud = await api.worldExists(args.worldSlug);
+        if (!existsLocally && !existsInCloud) {
+            this.error(pc.red(`World "${args.worldSlug}" does not exist locally or in the cloud.`));
+        }
+        this.log(pc.bold(`\nWorld: ${pc.cyan(args.worldSlug)}`));
+        if (existsLocally) {
+            this.log(`  📁 Local: ${pc.green("exists")} at ${world.worldDir}`);
+        }
+        else {
+            this.log(`  📁 Local: ${pc.dim("not found")}`);
+        }
+        if (existsInCloud) {
+            this.log(`  ☁  Cloud: ${pc.green("exists")}`);
+        }
+        else {
+            this.log(`  ☁  Cloud: ${pc.dim("not found")}`);
+        }
+        this.log("");
+        let deleteLocal = existsLocally;
+        let deleteCloud = existsInCloud;
+        if (!flags.yes) {
+            if (existsLocally) {
+                const response = await enquirer.prompt({
+                    type: "confirm",
+                    name: "confirm",
+                    message: `Delete local world files? ${pc.red("This cannot be undone.")}`,
+                    initial: true,
+                });
+                deleteLocal = response.confirm;
+            }
+            if (existsInCloud) {
+                const response = await enquirer.prompt({
+                    type: "confirm",
+                    name: "confirm",
+                    message: `Delete world from cloud? ${pc.red("This cannot be undone.")}`,
+                    initial: true,
+                });
+                deleteCloud = response.confirm;
+            }
+        }
+        if (!deleteLocal && !deleteCloud) {
+            this.log(pc.yellow("✗ Nothing deleted"));
+            return;
+        }
+        if (deleteLocal) {
+            await fs.rm(world.worldDir, { recursive: true, force: true });
+            this.log(pc.green(`✓ Deleted local: ${world.worldDir}`));
+        }
+        if (deleteCloud) {
+            await api.deleteWorld(args.worldSlug);
+            this.log(pc.green(`✓ Deleted from cloud: ${args.worldSlug}`));
+        }
+    }
+}

package/dist/commands/world/import.d.ts

@@ -0,0 +1,14 @@
+import { Command } from "@oclif/core";
+export default class Import extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        path: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        "api-key": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        "api-url": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        as: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/world/import.js

@@ -0,0 +1,122 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { Args, Command, Flags } from "@oclif/core";
+import enquirer from "enquirer";
+import { Listr } from "listr2";
+import pc from "picocolors";
+import { ApiClient } from "../../lib/api-client.js";
+import { getConfigFlags } from "../../lib/flags.js";
+import { World } from "../../lib/world.js";
+export default class Import extends Command {
+    static description = "Import a Minecraft world folder and package it as a tarball";
+    static examples = [
+        "<%= config.bin %> <%= command.id %> ~/minecraft/saves/MyWorld",
+        "<%= config.bin %> <%= command.id %> ~/minecraft/saves/MyWorld --as my-world",
+    ];
+    static args = {
+        path: Args.string({
+            description: "Path to the Minecraft world folder",
+            required: true,
+        }),
+    };
+    static flags = {
+        as: Flags.string({
+            description: "Slug for the world (defaults to folder name converted to slug)",
+        }),
+        ...getConfigFlags("api-key", "api-url"),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Import);
+        const sourcePath = path.resolve(args.path);
+        if (!existsSync(sourcePath)) {
+            this.error(pc.red(`Source path does not exist: ${sourcePath}`));
+        }
+        const levelDatPath = path.join(sourcePath, "level.dat");
+        if (!existsSync(levelDatPath)) {
+            this.error(pc.red(`Invalid Minecraft world: level.dat not found in ${sourcePath}`));
+        }
+        let slug = flags.as;
+        if (!slug) {
+            const folderName = path.basename(sourcePath);
+            const suggestedSlug = World.toSlug(folderName);
+            const response = await enquirer.prompt({
+                type: "input",
+                name: "slug",
+                message: "World slug:",
+                initial: suggestedSlug,
+                validate: (input) => {
+                    if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(input)) {
+                        return "Slug must be lowercase alphanumeric with hyphens, not starting/ending with hyphen";
+                    }
+                    return true;
+                },
+            });
+            slug = response.slug;
+        }
+        const world = new World(slug);
+        const isReimport = world.exists();
+        if (isReimport) {
+            this.log(`World "${slug}" already exists. Re-import will update the tarball but preserve config.ts.`);
+        }
+        const api = new ApiClient(flags["api-url"], flags["api-key"]);
+        const tasks = new Listr([
+            {
+                title: "Creating world directory",
+                enabled: () => !isReimport,
+                task: async (_ctx, task) => {
+                    const name = path.basename(sourcePath);
+                    const config = {
+                        name: name,
+                        description: "no description",
+                        visibility: "private",
+                        domain: "minecraft",
+                    };
+                    await World.createLocal(slug, config);
+                    task.title = `Created worlds/${slug}/`;
+                },
+            },
+            {
+                title: isReimport ? "Updating tarball" : "Packaging world as tarball",
+                task: async (_ctx, task) => {
+                    await World.createTarballFrom(sourcePath, slug);
+                    task.title = isReimport ? `Updated worlds/${slug}/world.tar.gz` : `Created worlds/${slug}/world.tar.gz`;
+                },
+            },
+            {
+                title: "Creating world in cloud",
+                enabled: () => !isReimport,
+                task: async (_ctx, task) => {
+                    const exists = await api.worldExists(slug);
+                    if (exists) {
+                        task.title = "World already exists in cloud";
+                        return;
+                    }
+                    const config = {
+                        name: slug,
+                        visibility: "private",
+                        domain: "minecraft",
+                    };
+                    await api.createWorld(slug, config);
+                    task.title = "Created world in cloud";
+                },
+            },
+            {
+                title: "Uploading world to cloud",
+                task: async (_ctx, task) => {
+                    await api.uploadWorldFile(slug, world.tarballPath);
+                    task.title = "Uploaded world to cloud";
+                },
+            },
+        ]);
+        await tasks.run();
+        if (isReimport) {
+            this.log(pc.green(`\n✓ World re-imported & uploaded: ${slug}`));
+            this.log(pc.dim(`  → world.tar.gz updated (config.ts preserved)`));
+        }
+        else {
+            this.log(pc.green(`\n✓ World imported & uploaded: ${slug}`));
+            this.log(pc.dim(`  → config.ts: ${world.configPath}`));
+            this.log(pc.dim(`  → world.tar.gz: ${world.tarballPath}`));
+        }
+    }
+}

package/dist/commands/world/list.d.ts

@@ -0,0 +1,10 @@
+import { Command } from "@oclif/core";
+export default class List extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        "api-key": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        "api-url": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/world/list.js

@@ -0,0 +1,46 @@
+import { Command } from "@oclif/core";
+import pc from "picocolors";
+import { ApiClient } from "../../lib/api-client.js";
+import { getConfigFlags } from "../../lib/flags.js";
+import { World } from "../../lib/world.js";
+export default class List extends Command {
+    static description = "List all worlds (local and cloud)";
+    static examples = ["<%= config.bin %> <%= command.id %>"];
+    static flags = {
+        ...getConfigFlags("api-key", "api-url"),
+    };
+    async run() {
+        const { flags } = await this.parse(List);
+        const api = new ApiClient(flags["api-url"], flags["api-key"]);
+        this.log(pc.blue(">> Loading worlds..."));
+        const [cloudWorlds, localWorlds, human] = await Promise.all([
+            api.listWorlds(),
+            World.getLocalWorlds(),
+            api.getHuman(),
+        ]);
+        const cloudMap = new Map(cloudWorlds.map((w) => [w.slug, w]));
+        const allSlugs = new Set([...cloudMap.keys(), ...localWorlds.map((slug) => `${human.username}:${slug}`)]);
+        this.log(pc.bold("\nWorlds:\n"));
+        this.log(`${"Status".padEnd(15)} ${"Slug".padEnd(40)} ${"Name".padEnd(30)}`);
+        this.log("-".repeat(90));
+        for (const slug of Array.from(allSlugs).sort()) {
+            const inCloud = cloudMap.has(slug);
+            const shortSlug = slug.includes(":") ? slug.split(":")[1] : slug;
+            const inLocal = localWorlds.includes(shortSlug);
+            let status;
+            if (inCloud && inLocal) {
+                status = pc.green("✓ synced");
+            }
+            else if (inCloud) {
+                status = pc.yellow("☁ cloud only");
+            }
+            else {
+                status = pc.blue("⊡ local only");
+            }
+            const cloudWorld = cloudMap.get(slug);
+            const name = cloudWorld?.name || "-";
+            this.log(`${status.padEnd(24)} ${slug.padEnd(40)} ${name.padEnd(30)}`);
+        }
+        this.log(pc.dim(`\nTotal: ${allSlugs.size} worlds`));
+    }
+}

package/dist/commands/world/pull.d.ts

@@ -0,0 +1,14 @@
+import { Command } from "@oclif/core";
+export default class Pull extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        worldSlug: import("@oclif/core/interfaces").Arg<string | undefined>;
+    };
+    static flags: {
+        "api-key": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        "api-url": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/world/pull.js

@@ -0,0 +1,135 @@
+import { existsSync } from "node:fs";
+import fs from "node:fs/promises";
+import { Command, Flags } from "@oclif/core";
+import enquirer from "enquirer";
+import { Listr } from "listr2";
+import pc from "picocolors";
+import { ApiClient } from "../../lib/api-client.js";
+import { extractShortSlug, getWorldSlugArgument } from "../../lib/arguments.js";
+import { getConfigFlags } from "../../lib/flags.js";
+import { World } from "../../lib/world.js";
+export default class Pull extends Command {
+    static description = "Download a world from the cloud";
+    static examples = [
+        "<%= config.bin %> <%= command.id %>",
+        "<%= config.bin %> <%= command.id %> my-world",
+        "<%= config.bin %> <%= command.id %> username:my-world",
+        "<%= config.bin %> <%= command.id %> my-world --yes",
+    ];
+    static args = {
+        worldSlug: getWorldSlugArgument({
+            description: "World slug to pull (interactive selection if omitted)",
+            required: false,
+            allowTeam: true,
+        }),
+    };
+    static flags = {
+        yes: Flags.boolean({ char: "y", description: "Skip confirmation prompts", default: false }),
+        ...getConfigFlags("api-key", "api-url"),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Pull);
+        const api = new ApiClient(flags["api-url"], flags["api-key"]);
+        let worldSlug = args.worldSlug;
+        if (!worldSlug) {
+            const [kradleWorlds, cloudWorlds, localWorlds] = await Promise.all([
+                api.listKradleWorlds(),
+                api.listWorlds(),
+                World.getLocalWorlds(),
+            ]);
+            const allWorlds = [...kradleWorlds, ...cloudWorlds];
+            if (allWorlds.length === 0) {
+                this.error(pc.red("No worlds found in the cloud."));
+            }
+            const localSet = new Set(localWorlds);
+            const choices = allWorlds
+                .map((w) => w.slug)
+                .toSorted()
+                .map((slug) => {
+                const shortSlug = extractShortSlug(slug);
+                const isLocal = localSet.has(shortSlug);
+                const status = isLocal ? pc.yellow(" (local)") : "";
+                return {
+                    name: slug,
+                    message: `${slug}${status}`,
+                };
+            });
+            const response = await enquirer.prompt({
+                type: "select",
+                name: "world",
+                message: "Select a world to pull",
+                choices,
+            });
+            worldSlug = response.world;
+        }
+        const shortSlug = extractShortSlug(worldSlug);
+        const world = new World(shortSlug);
+        const existsInCloud = await api.worldExists(worldSlug);
+        if (!existsInCloud) {
+            this.error(pc.red(`World "${worldSlug}" does not exist in the cloud.`));
+        }
+        const existsLocally = world.exists();
+        if (existsLocally && !flags.yes) {
+            this.log(pc.bold(`\nWorld: ${pc.cyan(worldSlug)}`));
+            this.log(`  📁 Local folder exists: ${pc.yellow(world.worldDir)}`);
+            if (world.tarballExists()) {
+                this.log(`  📦 world.tar.gz: ${pc.yellow("exists (will be overwritten)")}`);
+            }
+            if (existsSync(world.configPath)) {
+                this.log(`  📄 config.ts: ${pc.yellow("exists (will be overwritten)")}`);
+            }
+            this.log("");
+            const confirmResponse = await enquirer.prompt({
+                type: "confirm",
+                name: "confirm",
+                message: `Overwrite local world files? ${pc.red("This cannot be undone.")}`,
+                initial: false,
+            });
+            if (!confirmResponse.confirm) {
+                this.log(pc.yellow("✗ Pull cancelled"));
+                return;
+            }
+        }
+        const cloudWorld = await api.getWorld(worldSlug);
+        const tasks = new Listr([
+            {
+                title: "Creating world directory",
+                task: async () => {
+                    await fs.mkdir(world.worldDir, { recursive: true });
+                },
+            },
+            {
+                title: "Downloading world",
+                task: async (_ctx, task) => {
+                    const { downloadUrl } = await api.getWorldDownloadUrl(worldSlug);
+                    const response = await fetch(downloadUrl);
+                    if (!response.ok) {
+                        throw new Error(`Failed to download: ${response.status} ${response.statusText}`);
+                    }
+                    const buffer = await response.arrayBuffer();
+                    await fs.writeFile(world.tarballPath, Buffer.from(buffer));
+                    task.title = "Downloaded world";
+                },
+            },
+            {
+                title: "Creating config.ts",
+                task: async (_ctx, task) => {
+                    const config = {
+                        name: cloudWorld.name,
+                        description: cloudWorld.description ?? "no description",
+                        visibility: cloudWorld.visibility,
+                        domain: "minecraft",
+                    };
+                    const configContent = `export const config = ${JSON.stringify(config, null, "\t").replace(/"([a-zA-Z_][a-zA-Z0-9_]*)"\s*:/g, "$1:")};
+`;
+                    await fs.writeFile(world.configPath, configContent);
+                    task.title = "Created config.ts";
+                },
+            },
+        ]);
+        await tasks.run();
+        this.log(pc.green(`\n✓ World pulled: ${worldSlug}`));
+        this.log(pc.dim(`  → config.ts: ${world.configPath}`));
+        this.log(pc.dim(`  → world.tar.gz: ${world.tarballPath}`));
+    }
+}

package/dist/commands/world/push.d.ts

@@ -0,0 +1,13 @@
+import { Command } from "@oclif/core";
+export default class Push extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        worldSlug: import("@oclif/core/interfaces").Arg<string>;
+    };
+    static flags: {
+        "api-key": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        "api-url": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/world/push.js

@@ -0,0 +1,64 @@
+import { Command } from "@oclif/core";
+import { Listr } from "listr2";
+import pc from "picocolors";
+import { ApiClient } from "../../lib/api-client.js";
+import { getWorldSlugArgument } from "../../lib/arguments.js";
+import { getConfigFlags } from "../../lib/flags.js";
+import { World } from "../../lib/world.js";
+export default class Push extends Command {
+    static description = "Upload a world (config + tarball) to the cloud";
+    static examples = ["<%= config.bin %> <%= command.id %> my-world"];
+    static args = {
+        worldSlug: getWorldSlugArgument({ description: "World slug to push" }),
+    };
+    static flags = {
+        ...getConfigFlags("api-key", "api-url"),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Push);
+        const world = new World(args.worldSlug);
+        if (!world.exists()) {
+            this.error(pc.red(`World "${args.worldSlug}" does not exist locally.`));
+        }
+        if (!world.tarballExists()) {
+            this.error(pc.red(`World tarball not found at ${world.tarballPath}`));
+        }
+        const isValid = await world.validateTarball();
+        if (!isValid) {
+            this.error(pc.red(`Invalid world tarball: level.dat not found in ${world.tarballPath}`));
+        }
+        const api = new ApiClient(flags["api-url"], flags["api-key"]);
+        const config = await world.loadConfig();
+        const tasks = new Listr([
+            {
+                title: "Ensuring world exists in cloud",
+                task: async (_ctx, task) => {
+                    const exists = await api.worldExists(args.worldSlug);
+                    if (!exists) {
+                        await api.createWorld(args.worldSlug, config);
+                        task.title = "Created world in cloud";
+                    }
+                    else {
+                        task.title = "World exists in cloud";
+                    }
+                },
+            },
+            {
+                title: "Uploading config",
+                task: async (_ctx, task) => {
+                    await api.updateWorld(args.worldSlug, config);
+                    task.title = "Config uploaded";
+                },
+            },
+            {
+                title: "Uploading world",
+                task: async (_ctx, task) => {
+                    await api.uploadWorldFile(args.worldSlug, world.tarballPath);
+                    task.title = "World uploaded";
+                },
+            },
+        ]);
+        await tasks.run();
+        this.log(pc.green(`\n✓ World pushed: ${args.worldSlug}`));
+    }
+}

package/dist/lib/api-client.d.ts

@@ -1,5 +1,5 @@
 import type z from "zod";
-import { type AgentSchemaType, type ChallengeConfigSchemaType, type ChallengeSchemaType, HumanSchema, type RecordingDownloadUrlResponse, type RecordingMetadata, type RunStatusSchemaType } from "./schemas.js";
+import { type AgentSchemaType, type ChallengeConfigSchemaType, type ChallengeSchemaType, type DownloadUrlResponse, HumanSchema, type RecordingMetadata, type RunStatusSchemaType, type WorldConfigSchemaType, type WorldSchemaType } from "./schemas.js";
 export declare class ApiClient {
     private apiUrl;
     private kradleApiKey;
@@ -66,12 +66,7 @@ export declare class ApiClient {
      * @returns The upload URL.
      */
     getChallengeUploadUrl(slug: string): Promise<string>;
-    /**
-     * Get the download URL for a challenge datapack.
-     * @param slug - The slug of the challenge.
-     * @returns The download URL and expiration time.
-     */
-    getChallengeDownloadUrl(slug: string): Promise<RecordingDownloadUrlResponse>;
+    getChallengeDownloadUrl(slug: string): Promise<DownloadUrlResponse>;
     runChallenge(runData: {
         challenge: string;
         participants: unknown[];
@@ -112,5 +107,15 @@ export declare class ApiClient {
      * @param timestamp - The timestamp of the recording.
      * @returns Download URL and expiration time.
      */
-    getRecordingDownloadUrl(runId: string, participantId: string, timestamp: string): Promise<RecordingDownloadUrlResponse>;
+    getRecordingDownloadUrl(runId: string, participantId: string, timestamp: string): Promise<DownloadUrlResponse>;
+    listWorlds(): Promise<WorldSchemaType[]>;
+    listKradleWorlds(): Promise<WorldSchemaType[]>;
+    getWorld(slug: string): Promise<WorldSchemaType>;
+    worldExists(slug: string): Promise<boolean>;
+    createWorld(slug: string, config: WorldConfigSchemaType): Promise<WorldSchemaType>;
+    updateWorld(slug: string, config: WorldConfigSchemaType): Promise<void>;
+    deleteWorld(slug: string): Promise<void>;
+    getWorldUploadUrl(slug: string): Promise<string>;
+    getWorldDownloadUrl(slug: string): Promise<DownloadUrlResponse>;
+    uploadWorldFile(slug: string, tarballPath: string): Promise<void>;
 }

package/dist/lib/api-client.js

@@ -1,6 +1,6 @@
 import { existsSync } from "node:fs";
 import fs from "node:fs/promises";
-import { AgentsResponseSchema, ChallengeSchema, ChallengesResponseSchema, HumanSchema, JobResponseSchema, RecordingDownloadUrlResponseSchema, RecordingsListResponseSchema, RunStatusSchema, UploadUrlResponseSchema, } from "./schemas.js";
+import { AgentsResponseSchema, ChallengeSchema, ChallengesResponseSchema, DownloadUrlResponseSchema, HumanSchema, JobResponseSchema, RecordingsListResponseSchema, RunStatusSchema, UploadUrlResponseSchema, WorldSchema, WorldsResponseSchema, } from "./schemas.js";
 const DEFAULT_PAGE_SIZE = 30;
 const DEFAULT_CHALLENGE_SCHEMA = {
     slug: "",
@@ -210,13 +210,8 @@ export class ApiClient {
         const response = await this.get(`challenges/${slug}/datapackUploadUrl`, {}, UploadUrlResponseSchema);
         return response.uploadUrl;
     }
-    /**
-     * Get the download URL for a challenge datapack.
-     * @param slug - The slug of the challenge.
-     * @returns The download URL and expiration time.
-     */
     async getChallengeDownloadUrl(slug) {
-        return this.get(`challenges/${slug}/datapackDownloadUrl`, {}, RecordingDownloadUrlResponseSchema);
+        return this.get(`challenges/${slug}/datapackDownloadUrl`, {}, DownloadUrlResponseSchema);
     }
     async runChallenge(runData) {
         const url = "jobs";
@@ -270,6 +265,60 @@ export class ApiClient {
      */
     async getRecordingDownloadUrl(runId, participantId, timestamp) {
         const url = `runs/${runId}/recordings/${participantId}/downloadUrl?timestamp=${encodeURIComponent(timestamp)}`;
-        return this.get(url, {}, RecordingDownloadUrlResponseSchema);
+        return this.get(url, {}, DownloadUrlResponseSchema);
+    }
+    async listWorlds() {
+        return this.listResource("worlds", "worlds", WorldsResponseSchema);
+    }
+    async listKradleWorlds() {
+        return this.listResource("humans/team-kradle/worlds", "worlds", WorldsResponseSchema);
+    }
+    async getWorld(slug) {
+        return this.get(`worlds/${slug}`, {}, WorldSchema);
+    }
+    async worldExists(slug) {
+        try {
+            const res = await this.get(`worlds/${slug}`, {});
+            return res !== null && res !== undefined;
+        }
+        catch {
+            return false;
+        }
+    }
+    async createWorld(slug, config) {
+        return this.post("worlds", { body: JSON.stringify({ slug, ...config }) }, WorldSchema);
+    }
+    async updateWorld(slug, config) {
+        await this.put(`worlds/${slug}`, {
+            body: JSON.stringify({ slug, ...config }),
+        });
+    }
+    async deleteWorld(slug) {
+        await this.delete(`worlds/${slug}`);
+    }
+    async getWorldUploadUrl(slug) {
+        const response = await this.get(`worlds/${slug}/uploadUrl`, {}, UploadUrlResponseSchema);
+        return response.uploadUrl;
+    }
+    async getWorldDownloadUrl(slug) {
+        return this.get(`worlds/${slug}/downloadUrl`, {}, DownloadUrlResponseSchema);
+    }
+    async uploadWorldFile(slug, tarballPath) {
+        const uploadUrl = await this.getWorldUploadUrl(slug);
+        if (!existsSync(tarballPath)) {
+            throw new Error(`World tarball not found at ${tarballPath}`);
+        }
+        const fileBuffer = await fs.readFile(tarballPath);
+        const response = await fetch(uploadUrl, {
+            method: "PUT",
+            headers: {
+                "Content-Type": "application/gzip",
+                "Content-Length": fileBuffer.length.toString(),
+            },
+            body: fileBuffer,
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to upload world: ${response.statusText}`);
+        }
     }
 }

package/dist/lib/arguments.d.ts

@@ -5,3 +5,8 @@ export declare function getChallengeSlugArgument<R extends boolean = true>({ des
     required?: R;
     allowTeam?: boolean;
 }): Arg<R extends true ? string : string | undefined>;
+export declare function getWorldSlugArgument<R extends boolean = true>({ description, required, allowTeam, }: {
+    description: string;
+    required?: R;
+    allowTeam?: boolean;
+}): Arg<R extends true ? string : string | undefined>;

package/dist/lib/arguments.js

@@ -26,3 +26,21 @@ export function getChallengeSlugArgument({ description, required, allowTeam = fa
     // biome-ignore lint/suspicious/noExplicitAny: Typescript can't handle the conditional "required"
     return arg;
 }
+export function getWorldSlugArgument({ description, required, allowTeam = false, }) {
+    const regex = allowTeam ? NAMESPACED_SLUG_REGEX : LOCAL_SLUG_REGEX;
+    const errorMessage = allowTeam
+        ? "World slugs must be lowercase alphanumeric characters and hyphens, and must not start or end with a hyphen. Optionally, a team prefix can be provided (e.g., 'team-name:my-world')."
+        : "World slugs must be lowercase alphanumeric characters and hyphens, and must not start or end with a hyphen.";
+    const arg = Args.string({
+        description,
+        required: required ?? true,
+        parse: async (input) => {
+            if (!regex.test(input)) {
+                throw new Error(`Invalid world slug: ${input}. ${errorMessage}`);
+            }
+            return input;
+        },
+    });
+    // biome-ignore lint/suspicious/noExplicitAny: Typescript can't handle the conditional "required"
+    return arg;
+}

package/dist/lib/challenge.d.ts

@@ -37,9 +37,6 @@ export declare class Challenge {
      * Build the challenge datapack
      */
     build(silent?: boolean): Promise<void>;
-    /**
-     * Load the challenge configuration from config.ts
-     */
     loadConfig(): Promise<ChallengeConfigSchemaType>;
     /**
      * Build the challenge datapack and upload it to the cloud.

package/dist/lib/challenge.js

@@ -5,7 +5,7 @@ import path from "node:path";
 import pc from "picocolors";
 import * as tar from "tar";
 import { ChallengeConfigSchema } from "./schemas.js";
-import { executeNodeCommand, executeTypescriptFile, getStaticResourcePath, readDirSorted } from "./utils.js";
+import { executeTypescriptFile, getStaticResourcePath, loadTypescriptExport, readDirSorted } from "./utils.js";
 export const SOURCE_FOLDER = ".src";
 export class Challenge {
     shortSlug;
@@ -106,25 +106,15 @@ export class Challenge {
             strict: true,
         }, ["datapack", SOURCE_FOLDER]);
     }
-    /**
-     * Load the challenge configuration from config.ts
-     */
     async loadConfig() {
         if (!existsSync(this.configPath)) {
             throw new Error(`Config file not found at ${this.configPath}`);
         }
-        // We spawn a new NodeJS process to execute & log the config file.
-        // We can't directly import the file because it would be cached, and import cache can't be invalidated.
-        const stdout = await executeNodeCommand([
-            "--experimental-transform-types",
-            "--no-warnings",
-            "-e",
-            `console.log(JSON.stringify(require("${this.configPath}").config));`,
-        ], {
+        const config = await loadTypescriptExport(this.configPath, "config", {
             KRADLE_CHALLENGES_PATH: this.kradleChallengesPath,
             NAMESPACE: "kradle",
         });
-        return ChallengeConfigSchema.parse(JSON.parse(stdout));
+        return ChallengeConfigSchema.parse(config);
     }
     /**
      * Build the challenge datapack and upload it to the cloud.

package/dist/lib/schemas.d.ts

@@ -143,6 +143,10 @@ export declare const UploadUrlResponseSchema: z.ZodObject<{
     uploadUrl: z.ZodString;
     expiresAt: z.ZodString;
 }, z.core.$strip>;
+export declare const DownloadUrlResponseSchema: z.ZodObject<{
+    downloadUrl: z.ZodString;
+    expiresAt: z.ZodString;
+}, z.core.$strip>;
 export declare const AgentSchema: z.ZodObject<{
     username: z.ZodOptional<z.ZodString>;
     name: z.ZodOptional<z.ZodString>;
@@ -186,9 +190,44 @@ export declare const RecordingsListResponseSchema: z.ZodObject<{
         sizeBytes: z.ZodNumber;
     }, z.core.$strip>>;
 }, z.core.$strip>;
-export declare const RecordingDownloadUrlResponseSchema: z.ZodObject<{
-    downloadUrl: z.ZodString;
-    expiresAt: z.ZodString;
+export declare const WorldSchema: z.ZodObject<{
+    id: z.ZodString;
+    slug: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    visibility: z.ZodEnum<{
+        private: "private";
+        public: "public";
+    }>;
+    creationTime: z.ZodString;
+    updateTime: z.ZodString;
+    creator: z.ZodString;
+}, z.core.$strip>;
+export declare const WorldConfigSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    visibility: z.ZodEnum<{
+        private: "private";
+        public: "public";
+    }>;
+    domain: z.ZodDefault<z.ZodLiteral<"minecraft">>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export declare const WorldsResponseSchema: z.ZodObject<{
+    worlds: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        slug: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        visibility: z.ZodEnum<{
+            private: "private";
+            public: "public";
+        }>;
+        creationTime: z.ZodString;
+        updateTime: z.ZodString;
+        creator: z.ZodString;
+    }, z.core.$strip>>;
+    nextPageToken: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type ChallengeSchemaType = z.infer<typeof ChallengeSchema>;
 export type ChallengeConfigSchemaType = z.infer<typeof ChallengeConfigSchema>;
@@ -200,5 +239,8 @@ export type AgentSchemaType = z.infer<typeof AgentSchema>;
 export type AgentsResponseType = z.infer<typeof AgentsResponseSchema>;
 export type RecordingMetadata = z.infer<typeof RecordingMetadataSchema>;
 export type RecordingsListResponse = z.infer<typeof RecordingsListResponseSchema>;
-export type RecordingDownloadUrlResponse = z.infer<typeof RecordingDownloadUrlResponseSchema>;
 export type RunParticipant = z.infer<typeof RunParticipantSchema>;
+export type DownloadUrlResponse = z.infer<typeof DownloadUrlResponseSchema>;
+export type WorldSchemaType = z.infer<typeof WorldSchema>;
+export type WorldConfigSchemaType = z.infer<typeof WorldConfigSchema>;
+export type WorldsResponseType = z.infer<typeof WorldsResponseSchema>;

package/dist/lib/schemas.js

@@ -64,6 +64,10 @@ export const UploadUrlResponseSchema = z.object({
     uploadUrl: z.string(),
     expiresAt: z.string(),
 });
+export const DownloadUrlResponseSchema = z.object({
+    downloadUrl: z.string(),
+    expiresAt: z.string(),
+});
 export const AgentSchema = z.object({
     username: z.string().optional(),
     name: z.string().optional(),
@@ -86,7 +90,24 @@ export const RecordingMetadataSchema = z.object({
 export const RecordingsListResponseSchema = z.object({
     recordings: z.array(RecordingMetadataSchema),
 });
-export const RecordingDownloadUrlResponseSchema = z.object({
-    downloadUrl: z.string(),
-    expiresAt: z.string(),
+export const WorldSchema = z.object({
+    id: z.string(),
+    slug: z.string(),
+    name: z.string(),
+    description: z.string().nullish(),
+    visibility: z.enum(["private", "public"]),
+    creationTime: z.string(),
+    updateTime: z.string(),
+    creator: z.string(),
+});
+export const WorldConfigSchema = z.object({
+    name: z.string(),
+    description: z.string().optional(),
+    visibility: z.enum(["private", "public"]),
+    domain: z.literal("minecraft").default("minecraft"),
+    metadata: z.record(z.string(), z.string()).optional(),
+});
+export const WorldsResponseSchema = z.object({
+    worlds: z.array(WorldSchema),
+    nextPageToken: z.string().optional(),
 });

package/dist/lib/utils.d.ts

@@ -86,6 +86,7 @@ export declare function executeCommand(command: string, args: string[], options?
  * @returns A promise that resolves with the stdout of the command.
  */
 export declare function executeNodeCommand(args: string[], env: Record<string, string>): Promise<string>;
+export declare function loadTypescriptExport(filePath: string, exportName: string, env?: Record<string, string>): Promise<unknown>;
 /**
  * Open a URL in the default browser.
  * This is fire-and-forget, so we don't wait for it to complete.

package/dist/lib/utils.js

@@ -168,6 +168,15 @@ export async function executeCommand(command, args, options) {
 export async function executeNodeCommand(args, env) {
     return executeCommand(process.execPath, args, { env });
 }
+export async function loadTypescriptExport(filePath, exportName, env = {}) {
+    const stdout = await executeNodeCommand([
+        "--experimental-transform-types",
+        "--no-warnings",
+        "-e",
+        `console.log(JSON.stringify(require("${filePath}").${exportName}));`,
+    ], env);
+    return JSON.parse(stdout);
+}
 /**
  * Open a URL in the default browser.
  * This is fire-and-forget, so we don't wait for it to complete.

package/dist/lib/world.d.ts

@@ -0,0 +1,21 @@
+import { type WorldConfigSchemaType } from "./schemas.js";
+/**
+ * Represents a Minecraft world stored locally as:
+ *   worlds/<slug>/config.ts    - metadata (name, visibility, etc.)
+ *   worlds/<slug>/world.tar.gz - the packaged world files
+ */
+export declare class World {
+    readonly shortSlug: string;
+    constructor(shortSlug: string);
+    get worldDir(): string;
+    get configPath(): string;
+    get tarballPath(): string;
+    exists(): boolean;
+    tarballExists(): boolean;
+    validateTarball(): Promise<boolean>;
+    loadConfig(): Promise<WorldConfigSchemaType>;
+    static getLocalWorlds(): Promise<string[]>;
+    static createLocal(slug: string, config: WorldConfigSchemaType): Promise<void>;
+    static createTarballFrom(sourcePath: string, slug: string): Promise<void>;
+    static toSlug(folderName: string): string;
+}

package/dist/lib/world.js

@@ -0,0 +1,102 @@
+import { existsSync } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import * as tar from "tar";
+import { WorldConfigSchema } from "./schemas.js";
+import { loadTypescriptExport, readDirSorted } from "./utils.js";
+/**
+ * Represents a Minecraft world stored locally as:
+ *   worlds/<slug>/config.ts    - metadata (name, visibility, etc.)
+ *   worlds/<slug>/world.tar.gz - the packaged world files
+ */
+export class World {
+    shortSlug;
+    constructor(shortSlug) {
+        this.shortSlug = shortSlug;
+    }
+    get worldDir() {
+        return path.resolve(process.cwd(), "worlds", this.shortSlug);
+    }
+    get configPath() {
+        return path.join(this.worldDir, "config.ts");
+    }
+    get tarballPath() {
+        return path.join(this.worldDir, "world.tar.gz");
+    }
+    exists() {
+        return existsSync(this.worldDir) && existsSync(this.configPath);
+    }
+    tarballExists() {
+        return existsSync(this.tarballPath);
+    }
+    // Validates that the tarball contains level.dat (required for valid Minecraft worlds)
+    async validateTarball() {
+        if (!this.tarballExists()) {
+            return false;
+        }
+        const entries = [];
+        await tar.list({
+            file: this.tarballPath,
+            onReadEntry: (entry) => {
+                entries.push(entry.path);
+            },
+        });
+        return entries.some((entry) => entry === "level.dat" || entry.endsWith("/level.dat"));
+    }
+    async loadConfig() {
+        if (!existsSync(this.configPath)) {
+            throw new Error(`Config file not found at ${this.configPath}`);
+        }
+        const config = await loadTypescriptExport(this.configPath, "config");
+        return WorldConfigSchema.parse(config);
+    }
+    static async getLocalWorlds() {
+        const worldsDir = path.resolve(process.cwd(), "worlds");
+        if (!existsSync(worldsDir)) {
+            return [];
+        }
+        const entries = await readDirSorted(worldsDir);
+        const worlds = [];
+        for (const entry of entries) {
+            if (entry.isDirectory() && entry.parentPath === worldsDir) {
+                const configPath = path.join(worldsDir, entry.name, "config.ts");
+                if (existsSync(configPath)) {
+                    worlds.push(entry.name);
+                }
+            }
+        }
+        return worlds;
+    }
+    static async createLocal(slug, config) {
+        const world = new World(slug);
+        await fs.mkdir(world.worldDir, { recursive: true });
+        const configContent = `export const config = ${JSON.stringify(config, null, "\t").replace(/"([a-zA-Z_][a-zA-Z0-9_]*)"\s*:/g, "$1:")};
+`;
+        await fs.writeFile(world.configPath, configContent);
+    }
+    static async createTarballFrom(sourcePath, slug) {
+        const resolvedSource = path.resolve(sourcePath);
+        if (!existsSync(resolvedSource)) {
+            throw new Error(`Source path does not exist: ${resolvedSource}`);
+        }
+        const levelDatPath = path.join(resolvedSource, "level.dat");
+        if (!existsSync(levelDatPath)) {
+            throw new Error(`Invalid Minecraft world: level.dat not found in ${resolvedSource}`);
+        }
+        const world = new World(slug);
+        await fs.mkdir(world.worldDir, { recursive: true });
+        await tar.create({
+            file: world.tarballPath,
+            gzip: true,
+            cwd: resolvedSource,
+        }, ["."]);
+    }
+    // Converts folder name to valid slug: "My World 2" -> "my-world-2"
+    static toSlug(folderName) {
+        return folderName
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, "-")
+            .replace(/^-+|-+$/g, "")
+            .replace(/-+/g, "-");
+    }
+}

package/oclif.manifest.json

@@ -867,7 +867,277 @@
         "experiment",
         "run.js"
       ]
+    },
+    "world:delete": {
+      "aliases": [],
+      "args": {
+        "worldSlug": {
+          "description": "World slug to delete",
+          "name": "worldSlug",
+          "required": true
+        }
+      },
+      "description": "Delete a world locally, from the cloud, or both",
+      "examples": [
+        "<%= config.bin %> <%= command.id %> my-world",
+        "<%= config.bin %> <%= command.id %> my-world --yes"
+      ],
+      "flags": {
+        "yes": {
+          "char": "y",
+          "description": "Skip confirmation prompts",
+          "name": "yes",
+          "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"
+        },
+        "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": "world:delete",
+      "pluginAlias": "@kradle/cli",
+      "pluginName": "@kradle/cli",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "world",
+        "delete.js"
+      ]
+    },
+    "world:import": {
+      "aliases": [],
+      "args": {
+        "path": {
+          "description": "Path to the Minecraft world folder",
+          "name": "path",
+          "required": true
+        }
+      },
+      "description": "Import a Minecraft world folder and package it as a tarball",
+      "examples": [
+        "<%= config.bin %> <%= command.id %> ~/minecraft/saves/MyWorld",
+        "<%= config.bin %> <%= command.id %> ~/minecraft/saves/MyWorld --as my-world"
+      ],
+      "flags": {
+        "as": {
+          "description": "Slug for the world (defaults to folder name converted to slug)",
+          "name": "as",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "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": "world:import",
+      "pluginAlias": "@kradle/cli",
+      "pluginName": "@kradle/cli",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "world",
+        "import.js"
+      ]
+    },
+    "world:list": {
+      "aliases": [],
+      "args": {},
+      "description": "List all worlds (local and cloud)",
+      "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": "world:list",
+      "pluginAlias": "@kradle/cli",
+      "pluginName": "@kradle/cli",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "world",
+        "list.js"
+      ]
+    },
+    "world:pull": {
+      "aliases": [],
+      "args": {
+        "worldSlug": {
+          "description": "World slug to pull (interactive selection if omitted)",
+          "name": "worldSlug",
+          "required": false
+        }
+      },
+      "description": "Download a world from the cloud",
+      "examples": [
+        "<%= config.bin %> <%= command.id %>",
+        "<%= config.bin %> <%= command.id %> my-world",
+        "<%= config.bin %> <%= command.id %> username:my-world",
+        "<%= config.bin %> <%= command.id %> my-world --yes"
+      ],
+      "flags": {
+        "yes": {
+          "char": "y",
+          "description": "Skip confirmation prompts",
+          "name": "yes",
+          "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"
+        },
+        "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": "world:pull",
+      "pluginAlias": "@kradle/cli",
+      "pluginName": "@kradle/cli",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "world",
+        "pull.js"
+      ]
+    },
+    "world:push": {
+      "aliases": [],
+      "args": {
+        "worldSlug": {
+          "description": "World slug to push",
+          "name": "worldSlug",
+          "required": true
+        }
+      },
+      "description": "Upload a world (config + tarball) to the cloud",
+      "examples": [
+        "<%= config.bin %> <%= command.id %> my-world"
+      ],
+      "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": "world:push",
+      "pluginAlias": "@kradle/cli",
+      "pluginName": "@kradle/cli",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "world",
+        "push.js"
+      ]
     }
   },
-  "version": "0.2.5"
+  "version": "0.2.7"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@kradle/cli",
-	"version": "0.2.5",
+	"version": "0.2.7",
 	"description": "Kradle's CLI. Manage challenges, experiments, agents and more!",
 	"keywords": [
 		"cli"
@@ -84,6 +84,9 @@
 			},
 			"ai-docs": {
 				"description": "Output LLM reference documentation"
+			},
+			"world": {
+				"description": "Manage worlds"
 			}
 		}
 	}