kradle 0.6.0 → 0.6.1

package/README.md

@@ -335,6 +335,32 @@ kradle world delete my-world          # Interactive confirmation
 kradle world delete my-world --yes    # Skip confirmation
 ```
 
+### World Configuration
+
+Each world has a `config.ts` file in `worlds/<slug>/config.ts`. You can define named locations with coordinates:
+
+```typescript
+export const config = {
+  name: "My World",
+  description: "A custom Minecraft world",
+  domain: "minecraft",
+  worldConfig: {
+    locations: {
+      spawn: {
+        name: "Spawn Point",
+        coordinates: { x: 0, y: 64, z: 0 }
+      },
+      goal: {
+        name: "Goal Location",
+        coordinates: { x: 100, y: 70, z: 200 }
+      }
+    }
+  }
+};
+```
+
+Locations are synced to the cloud when you push the world.
+
 ## Agent Commands
 
 ### List Agents
@@ -404,8 +430,7 @@ The repository provides the `kradle` CLI command. It runs compiled JavaScript fr
 ```bash
 npm run build              # Compile TypeScript to dist/
 npm run lint               # Check for linting issues
-npm run lint:fix           # Auto-fix linting issues
-npm run format             # Format code with Biome
+npm run format             # Format code + auto-fix linting issues with Biome
 ```
 
 ### Running Tests

package/dist/commands/challenge/create.js

@@ -7,6 +7,7 @@ import { getChallengeSlugArgument } from "../../lib/arguments.js";
 import { Challenge } from "../../lib/challenge.js";
 import { getConfigFlags } from "../../lib/flags.js";
 import { ChallengeConfigSchema } from "../../lib/schemas.js";
+import { formatError } from "../../lib/zod-errors.js";
 export default class Create extends Command {
     static description = "Create a new challenge locally and in the cloud";
     static examples = ["<%= config.bin %> <%= command.id %> my-challenge"];
@@ -51,7 +52,13 @@ export default class Create extends Command {
                 task: async (_, task) => {
                     const challengeData = await api.getChallenge(args.challengeSlug);
                     // Remove fields that shouldn't be in the config file
-                    const config = ChallengeConfigSchema.parse(challengeData);
+                    let config;
+                    try {
+                        config = ChallengeConfigSchema.parse(challengeData);
+                    }
+                    catch (error) {
+                        throw new Error(formatError(error, "challenge config"));
+                    }
                     // Remove quotes from keys
                     const configStr = JSON.stringify(config, null, 2).replace(/"([a-zA-Z0-9_]+)":/g, "$1:");
                     await fs.writeFile(challenge.configPath, `

package/dist/commands/world/pull.js

@@ -124,6 +124,7 @@ export default class Pull extends Command {
                         name: cloudWorld.name,
                         description: cloudWorld.description ?? "no description",
                         domain: "minecraft",
+                        ...(cloudWorld.worldConfig && { worldConfig: cloudWorld.worldConfig }),
                     };
                     const configContent = `export const config = ${JSON.stringify(config, null, "\t").replace(/"([a-zA-Z_][a-zA-Z0-9_]*)"\s*:/g, "$1:")};
 `;

package/dist/lib/api-client.js

@@ -4,6 +4,7 @@ import os from "node:os";
 import path from "node:path";
 import * as tar from "tar";
 import { AgentsResponseSchema, ChallengeSchema, ChallengesResponseSchema, DashboardUrlResponseSchema, DownloadUrlResponseSchema, HumanSchema, JobResponseSchema, ListRunsResponseSchema, RecordingsListResponseSchema, RunLogsResponseSchema, RunResultResponseSchema, RunStatusSchema, UploadUrlResponseSchema, WorldSchema, WorldsResponseSchema, } from "./schemas.js";
+import { formatError } from "./zod-errors.js";
 const DEFAULT_PAGE_SIZE = 30;
 const DEFAULT_CHALLENGE_SCHEMA = {
     slug: "",
@@ -13,7 +14,7 @@ const DEFAULT_CHALLENGE_SCHEMA = {
     world: "team-kradle:flat-world",
     challengeConfig: { cheat: false, datapack: true, gameMode: "survival" },
     task: ".",
-    roles: { "default-role": { description: "default-role", specificTask: "do your best!" } },
+    roles: { defaultrole: { description: "default role", specificTask: "do your best!" } },
     objective: {
         fieldName: "success_rate",
         direction: "maximize",
@@ -54,7 +55,15 @@ export class ApiClient {
             ...options,
         });
         const data = await response.json();
-        return schema ? schema.parse(data) : data;
+        if (schema) {
+            try {
+                return schema.parse(data);
+            }
+            catch (error) {
+                throw new Error(formatError(error, `API response from GET ${url}`));
+            }
+        }
+        return data;
     }
     async post(url, options = {}, schema) {
         const response = await this.request(url, {
@@ -66,7 +75,15 @@ export class ApiClient {
             return undefined;
         }
         const data = JSON.parse(text);
-        return schema ? schema.parse(data) : data;
+        if (schema) {
+            try {
+                return schema.parse(data);
+            }
+            catch (error) {
+                throw new Error(formatError(error, `API response from POST ${url}`));
+            }
+        }
+        return data;
     }
     async put(url, options = {}) {
         return await this.request(url, {

package/dist/lib/challenge.js

@@ -7,6 +7,7 @@ import * as tar from "tar";
 import { extractShortSlug, isNamespacedSlug } from "./arguments.js";
 import { ChallengeConfigSchema } from "./schemas.js";
 import { executeTypescriptFile, findSimilarStrings, getStaticResourcePath, loadTypescriptExport, readDirSorted, } from "./utils.js";
+import { formatError } from "./zod-errors.js";
 export const SOURCE_FOLDER = ".src";
 export class Challenge {
     shortSlug;
@@ -89,14 +90,17 @@ export class Challenge {
         // Load config if not provided (and config file exists)
         let endStates = [];
         let roles = [];
+        let locations = [];
         if (config) {
             endStates = config.endStates ? Object.keys(config.endStates) : [];
             roles = config.roles ? Object.keys(config.roles) : [];
+            locations = config.challengeConfig?.locations ? Object.keys(config.challengeConfig.locations) : [];
         }
         else if (existsSync(this.configPath)) {
             const loadedConfig = await this.loadConfig();
             endStates = loadedConfig.endStates ? Object.keys(loadedConfig.endStates) : [];
             roles = loadedConfig.roles ? Object.keys(loadedConfig.roles) : [];
+            locations = loadedConfig.challengeConfig?.locations ? Object.keys(loadedConfig.challengeConfig.locations) : [];
         }
         try {
             await executeTypescriptFile(this.challengePath, {
@@ -104,6 +108,7 @@ export class Challenge {
                 NAMESPACE: "kradle",
                 KRADLE_CHALLENGE_END_STATES: JSON.stringify(endStates),
                 KRADLE_CHALLENGE_ROLES: JSON.stringify(roles),
+                KRADLE_CHALLENGE_LOCATIONS: JSON.stringify(locations),
             }, { silent });
         }
         catch (error) {
@@ -131,7 +136,12 @@ export class Challenge {
             KRADLE_CHALLENGES_PATH: this.kradleChallengesPath,
             NAMESPACE: "kradle",
         });
-        return ChallengeConfigSchema.parse(config);
+        try {
+            return ChallengeConfigSchema.parse(config);
+        }
+        catch (error) {
+            throw new Error(formatError(error, this.configPath));
+        }
     }
     /**
      * Build the challenge datapack and upload it to the cloud.

package/dist/lib/experiment/experimenter.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import pc from "picocolors";
 import { Challenge } from "../challenge.js";
 import { executeNodeCommand, openInBrowser } from "../utils.js";
+import { formatError } from "../zod-errors.js";
 import { Runner } from "./runner.js";
 import { TUI } from "./tui.js";
 import { ExperimentMetadataSchema, ManifestSchema, ProgressSchema } from "./types.js";
@@ -102,7 +103,12 @@ export class Experimenter {
         try {
             const content = await fs.readFile(this.metadataPath, "utf-8");
             const data = JSON.parse(content);
-            return ExperimentMetadataSchema.parse(data);
+            try {
+                return ExperimentMetadataSchema.parse(data);
+            }
+            catch (error) {
+                throw new Error(formatError(error, this.metadataPath));
+            }
         }
         catch {
             return null;
@@ -164,13 +170,12 @@ export class Experimenter {
     async loadManifest(version) {
         const paths = this.getVersionPaths(version);
         const content = await fs.readFile(paths.manifestPath, "utf-8");
+        const data = JSON.parse(content);
         try {
-            const data = JSON.parse(content);
             return ManifestSchema.parse(data);
         }
         catch (error) {
-            console.error(pc.red(`Error loading manifest for version ${version}: ${error instanceof Error ? error.message : String(error)}`));
-            throw error;
+            throw new Error(formatError(error, paths.manifestPath));
         }
     }
     /**
@@ -181,7 +186,12 @@ export class Experimenter {
             const paths = this.getVersionPaths(version);
             const content = await fs.readFile(paths.progressPath, "utf-8");
             const data = JSON.parse(content);
-            return ProgressSchema.parse(data);
+            try {
+                return ProgressSchema.parse(data);
+            }
+            catch (error) {
+                throw new Error(formatError(error, paths.progressPath));
+            }
         }
         catch {
             return null;
@@ -205,7 +215,12 @@ export class Experimenter {
      */
     async generateManifest(configPath) {
         const manifest = await this.executeConfigFile(configPath);
-        return ManifestSchema.parse(manifest);
+        try {
+            return ManifestSchema.parse(manifest);
+        }
+        catch (error) {
+            throw new Error(formatError(error, configPath));
+        }
     }
     /**
      * Execute config.ts file and return the manifest

package/dist/lib/schemas.d.ts

@@ -1,4 +1,41 @@
 import { z } from "zod";
+export declare const CoordinatesSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    z: z.ZodNumber;
+}, z.core.$strip>;
+export declare const ChallengeLocationValueSchema: z.ZodObject<{
+    world_location: z.ZodOptional<z.ZodString>;
+    coordinates: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        z: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const ChallengeLocationsSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    world_location: z.ZodOptional<z.ZodString>;
+    coordinates: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        z: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>>;
+export declare const WorldLocationValueSchema: z.ZodObject<{
+    name: z.ZodString;
+    coordinates: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        z: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const WorldLocationsSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    name: z.ZodString;
+    coordinates: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        z: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>>;
 export declare const ChallengeSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     slug: z.ZodString;
@@ -19,6 +56,14 @@ export declare const ChallengeSchema: z.ZodObject<{
             adventure: "adventure";
             spectator: "spectator";
         }>;
+        locations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            world_location: z.ZodOptional<z.ZodString>;
+            coordinates: z.ZodOptional<z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+                z: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
     }, z.core.$strip>;
     description: z.ZodOptional<z.ZodString>;
     task: z.ZodOptional<z.ZodString>;
@@ -54,6 +99,14 @@ export declare const ChallengeConfigSchema: z.ZodObject<{
             adventure: "adventure";
             spectator: "spectator";
         }>;
+        locations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            world_location: z.ZodOptional<z.ZodString>;
+            coordinates: z.ZodOptional<z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+                z: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
     }, z.core.$strip>;
     task: z.ZodOptional<z.ZodString>;
     roles: z.ZodRecord<z.ZodString, z.ZodObject<{
@@ -92,6 +145,14 @@ export declare const ChallengesResponseSchema: z.ZodObject<{
                 adventure: "adventure";
                 spectator: "spectator";
             }>;
+            locations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                world_location: z.ZodOptional<z.ZodString>;
+                coordinates: z.ZodOptional<z.ZodObject<{
+                    x: z.ZodNumber;
+                    y: z.ZodNumber;
+                    z: z.ZodNumber;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>>;
         }, z.core.$strip>;
         description: z.ZodOptional<z.ZodString>;
         task: z.ZodOptional<z.ZodString>;
@@ -254,12 +315,32 @@ export declare const WorldSchema: z.ZodObject<{
     creationTime: z.ZodString;
     updateTime: z.ZodString;
     creator: z.ZodString;
+    worldConfig: z.ZodOptional<z.ZodObject<{
+        locations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            name: z.ZodString;
+            coordinates: z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+                z: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const WorldConfigSchema: z.ZodObject<{
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
     domain: z.ZodDefault<z.ZodLiteral<"minecraft">>;
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    worldConfig: z.ZodOptional<z.ZodObject<{
+        locations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            name: z.ZodString;
+            coordinates: z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+                z: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const WorldsResponseSchema: z.ZodObject<{
     worlds: z.ZodArray<z.ZodObject<{
@@ -274,6 +355,16 @@ export declare const WorldsResponseSchema: z.ZodObject<{
         creationTime: z.ZodString;
         updateTime: z.ZodString;
         creator: z.ZodString;
+        worldConfig: z.ZodOptional<z.ZodObject<{
+            locations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                name: z.ZodString;
+                coordinates: z.ZodObject<{
+                    x: z.ZodNumber;
+                    y: z.ZodNumber;
+                    z: z.ZodNumber;
+                }, z.core.$strip>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     nextPageToken: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
@@ -369,6 +460,8 @@ export type RunResultResponse = z.infer<typeof RunResultResponseSchema>;
 export type DownloadUrlResponse = z.infer<typeof DownloadUrlResponseSchema>;
 export type WorldSchemaType = z.infer<typeof WorldSchema>;
 export type WorldConfigSchemaType = z.infer<typeof WorldConfigSchema>;
+export type WorldLocationValue = z.infer<typeof WorldLocationValueSchema>;
+export type WorldLocations = z.infer<typeof WorldLocationsSchema>;
 export type WorldsResponseType = z.infer<typeof WorldsResponseSchema>;
 export type DashboardUrlResponse = z.infer<typeof DashboardUrlResponseSchema>;
 export type Run = z.infer<typeof RunSchema>;

package/dist/lib/schemas.js

@@ -1,4 +1,24 @@
 import { z } from "zod";
+// Coordinates object {x, y, z}
+export const CoordinatesSchema = z.object({
+    x: z.number(),
+    y: z.number(),
+    z: z.number(),
+});
+// Temp - this will change when we have a union type
+export const ChallengeLocationValueSchema = z.object({
+    world_location: z.string().optional(),
+    coordinates: CoordinatesSchema.optional(),
+});
+// Challenge locations: mapping of location key to value
+export const ChallengeLocationsSchema = z.record(z.string(), ChallengeLocationValueSchema);
+// World location value: name (pretty version) and coordinates
+export const WorldLocationValueSchema = z.object({
+    name: z.string(),
+    coordinates: CoordinatesSchema,
+});
+// World locations: mapping of location key to value
+export const WorldLocationsSchema = z.record(z.string(), WorldLocationValueSchema);
 export const ChallengeSchema = z.object({
     id: z.string().optional(),
     slug: z.string(),
@@ -10,6 +30,7 @@ export const ChallengeSchema = z.object({
         cheat: z.boolean(),
         datapack: z.boolean(),
         gameMode: z.enum(["survival", "creative", "adventure", "spectator"]),
+        locations: ChallengeLocationsSchema.optional(),
     }),
     description: z.string().optional(),
     task: z.string().optional(),
@@ -134,12 +155,22 @@ export const WorldSchema = z.object({
     creationTime: z.string(),
     updateTime: z.string(),
     creator: z.string(),
+    worldConfig: z
+        .object({
+        locations: WorldLocationsSchema.optional(),
+    })
+        .optional(),
 });
 export const WorldConfigSchema = z.object({
     name: z.string(),
     description: z.string().optional(),
     domain: z.literal("minecraft").default("minecraft"),
     metadata: z.record(z.string(), z.string()).optional(),
+    worldConfig: z
+        .object({
+        locations: WorldLocationsSchema.optional(),
+    })
+        .optional(),
 });
 export const WorldsResponseSchema = z.object({
     worlds: z.array(WorldSchema),

package/dist/lib/world.js

@@ -5,6 +5,7 @@ import path from "node:path";
 import * as tar from "tar";
 import { WorldConfigSchema } from "./schemas.js";
 import { loadTypescriptExport, readDirSorted } from "./utils.js";
+import { formatError } from "./zod-errors.js";
 /**
  * Represents a Minecraft world stored locally as:
  *   worlds/<slug>/config.ts    - metadata (name, visibility, etc.)
@@ -120,7 +121,12 @@ export class World {
             throw new Error(`Config file not found at ${this.configPath}`);
         }
         const config = await loadTypescriptExport(this.configPath, "config");
-        return WorldConfigSchema.parse(config);
+        try {
+            return WorldConfigSchema.parse(config);
+        }
+        catch (error) {
+            throw new Error(formatError(error, this.configPath));
+        }
     }
     static async getLocalWorlds() {
         const worldsDir = path.resolve(process.cwd(), "worlds");

package/dist/lib/zod-errors.d.ts

@@ -0,0 +1,27 @@
+import { ZodError } from "zod";
+/**
+ * Format a ZodError into a human-readable string for CLI output.
+ *
+ * @param error - The ZodError to format
+ * @param context - Optional context string (e.g., "config.ts", "API response"). If an absolute path, it will be converted to a relative path from cwd.
+ * @returns A formatted error string
+ *
+ * @example
+ * // Output:
+ * // Validation failed for config.ts:
+ * //   ✖ Invalid input at "objective.direction": expected "maximize" | "minimize"
+ */
+export declare function formatZodError(error: ZodError, context?: string): string;
+/**
+ * Check if an error is a ZodError.
+ */
+export declare function isZodError(error: unknown): error is ZodError;
+/**
+ * Wrap an error message, formatting ZodErrors nicely.
+ * For non-Zod errors, returns the original message.
+ *
+ * @param error - The error to format
+ * @param context - Optional context string for Zod errors
+ * @returns A formatted error string
+ */
+export declare function formatError(error: unknown, context?: string): string;

package/dist/lib/zod-errors.js

@@ -0,0 +1,54 @@
+import path from "node:path";
+import pc from "picocolors";
+import { prettifyError, ZodError } from "zod";
+/**
+ * Format a ZodError into a human-readable string for CLI output.
+ *
+ * @param error - The ZodError to format
+ * @param context - Optional context string (e.g., "config.ts", "API response"). If an absolute path, it will be converted to a relative path from cwd.
+ * @returns A formatted error string
+ *
+ * @example
+ * // Output:
+ * // Validation failed for config.ts:
+ * //   ✖ Invalid input at "objective.direction": expected "maximize" | "minimize"
+ */
+export function formatZodError(error, context) {
+    // Convert absolute paths to relative paths from cwd
+    let displayContext = context;
+    if (context && path.isAbsolute(context)) {
+        displayContext = path.relative(process.cwd(), context);
+    }
+    const header = displayContext ? `Validation failed for ${pc.cyan(displayContext)}:` : "Validation failed:";
+    // Use Zod 4's built-in prettifyError and add color/indentation
+    const prettyError = prettifyError(error);
+    // Indent each line and add bullet points for better CLI readability
+    const formattedLines = prettyError
+        .split("\n")
+        .map((line) => `  ${pc.red(line)}`)
+        .join("\n");
+    return `${header}\n${formattedLines}`;
+}
+/**
+ * Check if an error is a ZodError.
+ */
+export function isZodError(error) {
+    return error instanceof ZodError;
+}
+/**
+ * Wrap an error message, formatting ZodErrors nicely.
+ * For non-Zod errors, returns the original message.
+ *
+ * @param error - The error to format
+ * @param context - Optional context string for Zod errors
+ * @returns A formatted error string
+ */
+export function formatError(error, context) {
+    if (isZodError(error)) {
+        return formatZodError(error, context);
+    }
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}

package/oclif.manifest.json

@@ -1378,5 +1378,5 @@
       ]
     }
   },
-  "version": "0.6.0"
+  "version": "0.6.1"
 }

package/package.json

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

package/static/ai_docs/LLM_CLI_REFERENCE.md

@@ -146,7 +146,8 @@ kradle challenge build --all --visibility public
 3. Executes `challenge.ts` to generate the datapack
    - Passes `KRADLE_CHALLENGE_END_STATES` env var containing a JSON array of end state keys from `config.endStates` (e.g., `["victory", "defeat"]`)
    - Passes `KRADLE_CHALLENGE_ROLES` env var containing a JSON array of role names from `config.roles` (e.g., `["attacker", "defender"]`)
-   - The `@kradle/challenges-sdk` uses these to register valid end states and roles at build time
+   - Passes `KRADLE_CHALLENGE_LOCATIONS` env var containing a JSON array of location keys from `config.challengeConfig.locations` (e.g., `["spawn", "goal"]`)
+   - The `@kradle/challenges-sdk` uses these to register valid end states, roles, and locations at build time
 4. Compresses and uploads datapack to cloud storage
 
 **Examples:**
@@ -1003,6 +1004,68 @@ kradle world delete my-world --yes
 
 ---
 
+### World Configuration
+
+Each world has a `config.ts` file located at `worlds/<slug>/config.ts`.
+
+**Config Structure:**
+```typescript
+export const config = {
+  name: string;           // Display name of the world
+  description?: string;   // Optional description
+  domain: "minecraft";    // Always "minecraft"
+  metadata?: Record<string, string>;  // Optional key-value metadata
+  worldConfig?: {
+    locations?: {
+      [key: string]: {
+        name: string;           // Pretty display name for the location
+        coordinates: {
+          x: number;            // X coordinate (integer)
+          y: number;            // Y coordinate (integer)
+          z: number;            // Z coordinate (integer)
+        };
+      };
+    };
+  };
+};
+```
+
+**Example with Locations:**
+```typescript
+export const config = {
+  name: "CTF Arena",
+  description: "A capture the flag arena world",
+  domain: "minecraft",
+  worldConfig: {
+    locations: {
+      red_spawn: {
+        name: "Red Team Spawn",
+        coordinates: { x: 100, y: 64, z: 0 }
+      },
+      blue_spawn: {
+        name: "Blue Team Spawn",
+        coordinates: { x: -100, y: 64, z: 0 }
+      },
+      red_flag: {
+        name: "Red Flag",
+        coordinates: { x: 150, y: 64, z: 0 }
+      },
+      blue_flag: {
+        name: "Blue Flag",
+        coordinates: { x: -150, y: 64, z: 0 }
+      }
+    }
+  }
+};
+```
+
+**Notes:**
+- The config is uploaded when running `kradle world push`
+- Locations are synced to the cloud and can be retrieved via the API
+- When pulling a world, the config is recreated from cloud metadata including locations
+
+---
+
 ## Agent Commands
 
 ### `kradle agent list`

package/static/challenge.ts

@@ -9,7 +9,7 @@ createChallenge({
 	name: challenge_name,
 	kradle_challenge_path: process.env.KRADLE_CHALLENGES_PATH || DEFAULT_CHALLENGE_PATH,
 	GAME_DURATION: GAME_DURATION,
-	roles: ["all"],
+	roles: ["defaultrole"],
 	custom_variables: {},
 })
 	.events(() => ({
@@ -26,6 +26,6 @@ createChallenge({
 		},
 	}))
 	.end_condition(({ alive_players }) => alive_players.equalTo(0))
-	.win_conditions(({ has_never_died }, { all }) => ({
-		[all]: has_never_died.equalTo(1),
+	.win_conditions(({ has_never_died }, { defaultrole }) => ({
+		[defaultrole]: has_never_died.equalTo(1),
 	}));