@kradle/cli 0.0.17 → 0.1.0

package/dist/commands/challenge/watch.js

@@ -6,27 +6,27 @@ import pc from "picocolors";
 import { ApiClient } from "../../lib/api-client.js";
 import { getChallengeSlugArgument } from "../../lib/arguments.js";
 import { Challenge, SOURCE_FOLDER } from "../../lib/challenge.js";
-import { loadConfig } from "../../lib/config.js";
+import { getConfigFlags } from "../../lib/flags.js";
 import { clearScreen, debounced } from "../../lib/utils.js";
 export default class Watch extends Command {
     static description = "Watch a challenge for changes and auto-rebuild/upload";
     static examples = ["<%= config.bin %> <%= command.id %> my-challenge"];
     static flags = {
         verbose: Flags.boolean({ description: "Enable verbose output", default: false }),
+        ...getConfigFlags("api-key", "api-url", "challenges-path"),
     };
     static args = {
-        challenge: getChallengeSlugArgument({ description: "Challenge slug to watch" }),
+        challengeSlug: getChallengeSlugArgument({ description: "Challenge slug to watch" }),
     };
     async run() {
         const { args, flags } = await this.parse(Watch);
-        const config = loadConfig();
-        const challenge = new Challenge(args.challenge, config);
-        const api = new ApiClient(config);
+        const challenge = new Challenge(args.challengeSlug, flags["challenges-path"]);
+        const api = new ApiClient(flags["api-url"], flags["api-key"]);
         const debounceSeconds = 1;
         let building = false;
         // Perform the initial build and upload
         this.log(pc.blue(`Performing initial build and upload...`));
-        let { config: lastConfig, datapackHash: lastHash } = await challenge.buildAndUpload(api);
+        let { config: lastConfig, datapackHash: lastHash } = await challenge.buildAndUpload(api, false);
         this.log(pc.green(`✓ Initial build and upload complete`));
         const executeRebuild = async () => {
             building = true;
@@ -40,7 +40,7 @@ export default class Watch extends Command {
                         const newConfig = await challenge.loadConfig();
                         if (JSON.stringify(newConfig) !== JSON.stringify(lastConfig)) {
                             task.title = "Uploading configuration";
-                            await api.updateChallenge(challenge, newConfig);
+                            await api.updateChallenge(challenge.shortSlug, newConfig, "private");
                             lastConfig = newConfig;
                             task.title = "Configuration uploaded";
                         }
@@ -63,7 +63,7 @@ export default class Watch extends Command {
                         const newHash = await challenge.getDatapackHash();
                         if (newHash !== lastHash) {
                             task.title = "Uploading datapack";
-                            await challenge.upload(api);
+                            await api.uploadChallengeDatapack(challenge.shortSlug, challenge.tarballPath);
                             lastHash = newHash;
                             task.title = "Datapack uploaded";
                         }

package/dist/commands/{evaluation → experiment}/create.d.ts

@@ -5,5 +5,9 @@ export default class Create extends Command {
     static args: {
         name: 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>;
+    };
     run(): Promise<void>;
 }

package/dist/commands/{evaluation → experiment}/create.js

@@ -5,35 +5,36 @@ import { Args, Command } from "@oclif/core";
 import enquirer from "enquirer";
 import pc from "picocolors";
 import { ApiClient } from "../../lib/api-client.js";
-import { loadConfig } from "../../lib/config.js";
+import { getConfigFlags } from "../../lib/flags.js";
 import { getStaticResourcePath } from "../../lib/utils.js";
 export default class Create extends Command {
-    static description = "Create a new evaluation";
-    static examples = ["<%= config.bin %> <%= command.id %> my-evaluation"];
+    static description = "Create a new experiment";
+    static examples = ["<%= config.bin %> <%= command.id %> my-experiment"];
     static args = {
         name: Args.string({
-            description: "Name of the evaluation",
+            description: "Name of the experiment",
             required: true,
         }),
     };
+    static flags = {
+        ...getConfigFlags("api-key", "api-url"),
+    };
     async run() {
-        const { args } = await this.parse(Create);
-        loadConfig(); // Validate config is available
-        const evaluationDir = path.resolve(process.cwd(), "evaluations", args.name);
-        const configPath = path.join(evaluationDir, "config.ts");
-        // Check if evaluation already exists
+        const { args, flags } = await this.parse(Create);
+        const experimentDir = path.resolve(process.cwd(), "experiments", args.name);
+        const configPath = path.join(experimentDir, "config.ts");
+        // Check if experiment already exists
         try {
-            await fs.access(evaluationDir);
-            this.error(pc.red(`Evaluation '${args.name}' already exists at ${evaluationDir}`));
+            await fs.access(experimentDir);
+            this.error(pc.red(`Experiment '${args.name}' already exists at ${experimentDir}`));
         }
         catch {
             // Directory doesn't exist, which is what we want
         }
-        // Create evaluation directory
-        await fs.mkdir(evaluationDir, { recursive: true });
-        // Ask for the slug of the challenge to evaluate
-        const config = loadConfig();
-        const api = new ApiClient(config);
+        // Create experiment directory
+        await fs.mkdir(experimentDir, { recursive: true });
+        // Ask for the slug of the challenge to run the experiment on
+        const api = new ApiClient(flags["api-url"], flags["api-key"]);
         const [kradleChallenges, cloudChallenges] = await Promise.all([api.listKradleChallenges(), api.listChallenges()]);
         const choices = [...kradleChallenges, ...cloudChallenges]
             .map((c) => c.slug)
@@ -45,15 +46,15 @@ export default class Create extends Command {
         const response = await enquirer.prompt({
             type: "select",
             name: "challenge",
-            message: "Select the challenge to evaluate",
+            message: "Select the challenge for this experiment",
             choices: choices,
         });
         // Read template file and fill in the challenge slug, then write to config file
-        const templatePath = getStaticResourcePath("evaluation_template.ts");
+        const templatePath = getStaticResourcePath("experiment_template.ts");
         const template = await fs.readFile(templatePath, "utf-8");
         const filledTemplate = template.replace("[INSERT CHALLENGE SLUG HERE]", response.challenge);
         await fs.writeFile(configPath, filledTemplate);
-        this.log(pc.green(`✓ Created evaluation '${args.name}'`));
+        this.log(pc.green(`✓ Created experiment '${args.name}'`));
         this.log(pc.dim(`  Config: ${configPath}`));
         // Offer to open in editor on macOS
         if (process.platform === "darwin") {
@@ -73,7 +74,7 @@ export default class Create extends Command {
         }
         this.log("");
         this.log(pc.blue(">> Next steps:"));
-        this.log(pc.dim(`   1. Edit ${path.basename(configPath)} to define your evaluation runs`));
-        this.log(pc.dim(`   2. Run: kradle evaluation run ${args.name}`));
+        this.log(pc.dim(`   1. Edit ${path.basename(configPath)} to define your experiment runs`));
+        this.log(pc.dim(`   2. Run: kradle experiment run ${args.name}`));
     }
 }

package/dist/commands/{evaluation → experiment}/list.js

@@ -2,29 +2,27 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { Command } from "@oclif/core";
 import pc from "picocolors";
-import { loadConfig } from "../../lib/config.js";
 export default class List extends Command {
-    static description = "List all evaluations";
+    static description = "List all experiments";
     static examples = ["<%= config.bin %> <%= command.id %>"];
     async run() {
-        this.parse(List);
-        loadConfig(); // Validate config is available
-        const evaluationsDir = path.resolve(process.cwd(), "evaluations");
+        await this.parse(List);
+        const experimentsDir = path.resolve(process.cwd(), "experiments");
         try {
-            const entries = await fs.readdir(evaluationsDir, { withFileTypes: true });
-            const evaluations = entries.filter((e) => e.isDirectory());
-            if (evaluations.length === 0) {
-                this.log(pc.yellow("No evaluations found."));
-                this.log(pc.dim(`  Run 'kradle evaluation init <name>' to create one.`));
+            const entries = await fs.readdir(experimentsDir, { withFileTypes: true });
+            const experiments = entries.filter((e) => e.isDirectory());
+            if (experiments.length === 0) {
+                this.log(pc.yellow("No experiments found."));
+                this.log(pc.dim(`  Run 'kradle experiment create <name>' to create one.`));
                 return;
             }
-            this.log(pc.blue(">> Evaluations:"));
+            this.log(pc.blue(">> Experiments:"));
             this.log("");
-            for (const evaluation of evaluations) {
-                const evalDir = path.join(evaluationsDir, evaluation.name);
-                const hasConfig = await this.fileExists(path.join(evalDir, "config.ts"));
-                const hasManifest = await this.fileExists(path.join(evalDir, "manifest.json"));
-                const hasProgress = await this.fileExists(path.join(evalDir, "progress.json"));
+            for (const experiment of experiments) {
+                const expDir = path.join(experimentsDir, experiment.name);
+                const hasConfig = await this.fileExists(path.join(expDir, "config.ts"));
+                const hasManifest = await this.fileExists(path.join(expDir, "manifest.json"));
+                const hasProgress = await this.fileExists(path.join(expDir, "progress.json"));
                 let status = "";
                 if (hasProgress) {
                     status = pc.yellow(" (in progress)");
@@ -35,12 +33,12 @@ export default class List extends Command {
                 else if (hasConfig) {
                     status = pc.dim(" (config only)");
                 }
-                this.log(`  ${pc.bold(evaluation.name)}${status}`);
+                this.log(`  ${pc.bold(experiment.name)}${status}`);
             }
         }
         catch {
-            this.log(pc.yellow("No evaluations directory found."));
-            this.log(pc.dim(`  Run 'kradle evaluation init <name>' to create your first evaluation.`));
+            this.log(pc.yellow("No experiments directory found."));
+            this.log(pc.dim(`  Run 'kradle experiment create <name>' to create your first experiment.`));
         }
     }
     async fileExists(filePath) {

package/dist/commands/{evaluation → experiment}/run.d.ts

@@ -6,7 +6,10 @@ export default class Run extends Command {
         name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
     static flags: {
-        new: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "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>;
+        "web-url": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        "new-version": import("@oclif/core/interfaces").BooleanFlag<boolean>;
         "max-concurrent": import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;

package/dist/commands/experiment/run.js

@@ -0,0 +1,61 @@
+import { Args, Command, Flags } from "@oclif/core";
+import pc from "picocolors";
+import { ApiClient } from "../../lib/api-client.js";
+import { Experimenter } from "../../lib/experiment/experimenter.js";
+import { getConfigFlags } from "../../lib/flags.js";
+const DEFAULT_MAX_CONCURRENT = 5;
+export default class Run extends Command {
+    static description = "Run an experiment. If the experiment had an ongoing version, it will resume from the last state.";
+    static examples = [
+        "<%= config.bin %> <%= command.id %> my-experiment",
+        "<%= config.bin %> <%= command.id %> my-experiment --new-version",
+        "<%= config.bin %> <%= command.id %> my-experiment --max-concurrent 10",
+    ];
+    static args = {
+        name: Args.string({
+            description: "Name of the experiment to run",
+            required: true,
+        }),
+    };
+    static flags = {
+        "new-version": Flags.boolean({
+            char: "n",
+            description: "Start a new version of the experiment",
+            default: false,
+        }),
+        "max-concurrent": Flags.integer({
+            char: "m",
+            description: "Maximum concurrent runs",
+            default: DEFAULT_MAX_CONCURRENT,
+        }),
+        ...getConfigFlags("api-key", "api-url", "web-url"),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Run);
+        const api = new ApiClient(flags["api-url"], flags["api-key"]);
+        const experimenter = new Experimenter(args.name, flags["web-url"], api);
+        // Check if experiment exists
+        if (!(await experimenter.exists())) {
+            this.error(pc.red(`Experiment '${args.name}' does not exist. Run 'kradle experiment create ${args.name}' first.`));
+        }
+        // Check if config.ts exists
+        if (!(await experimenter.configExists())) {
+            this.error(pc.red(`Config file not found at ${experimenter.configPath}`));
+        }
+        this.log(pc.blue(`>> Starting experiment: ${args.name}`));
+        if (flags["new-version"]) {
+            this.log(pc.yellow("   Starting a new version of the experiment."));
+        }
+        try {
+            await experimenter.run({
+                new: flags["new-version"],
+                maxConcurrent: flags["max-concurrent"],
+                openMetabase: true,
+            });
+            this.log(pc.green("\n✓ Experiment complete!"));
+        }
+        catch (error) {
+            this.error(pc.red(`Experiment failed: ${error instanceof Error ? error.message : String(error)}`));
+        }
+    }
+}

package/dist/commands/init.js

@@ -34,10 +34,10 @@ export default class Init extends Command {
             const nonHiddenFiles = files.filter((f) => !f.startsWith("."));
             const useCurrentDir = nonHiddenFiles.length === 0;
             if (useCurrentDir) {
-                this.log(pc.yellow("Current directory is empty, it will be used to store challenges and evaluations."));
+                this.log(pc.yellow("Current directory is empty, it will be used to store challenges and experiments."));
             }
             else {
-                this.log(pc.yellow("Current directory is not empty, a subdirectory will be created to store challenges and evaluations."));
+                this.log(pc.yellow("Current directory is not empty, a subdirectory will be created to store challenges and experiments."));
             }
             let projectName;
             if (flags.name) {

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

@@ -1,10 +1,9 @@
 import type z from "zod";
-import type { Challenge } from "./challenge.js";
-import type { Config } from "./config.js";
-import { type AgentSchemaType, type ChallengeSchemaType, HumanSchema, type RunStatusSchemaType } from "./schemas.js";
+import { type AgentSchemaType, type ChallengeConfigSchemaType, type ChallengeSchemaType, HumanSchema, type RunStatusSchemaType } from "./schemas.js";
 export declare class ApiClient {
-    private config;
-    constructor(config: Config);
+    private apiUrl;
+    private kradleApiKey;
+    constructor(apiUrl: string, kradleApiKey: string);
     private request;
     private get;
     private post;
@@ -40,16 +39,36 @@ export declare class ApiClient {
     createChallenge(slug: string): Promise<unknown>;
     /**
      * Update a challenge definition in the cloud.
-     * @param challenge - The challenge to update.
-     * @param challengeConfig - The challenge config to upload. If not provided, the config will be loaded from the challenge.
+     * @param challengeSlug - The slug of the challenge.
+     * @param challengeConfig - The challenge config to upload.
+     * @param visibility - The visibility to set.
      * @returns The updated challenge.
      */
-    updateChallenge(challenge: Challenge, challengeConfig?: ChallengeSchemaType): Promise<void>;
-    getChallengeUploadUrl(challenge: Challenge): Promise<string>;
+    updateChallenge(challengeSlug: string, challengeConfig: ChallengeConfigSchemaType, visibility: "private" | "public"): Promise<void>;
+    /**
+     * Update the visibility of a challenge.
+     * @param challengeSlug - The slug of the challenge.
+     * @param visibility - The visibility to set.
+     * @returns The updated challenge.
+     */
+    updateChallengeVisibility(challengeSlug: string, visibility: "private" | "public"): Promise<void>;
+    /**
+     * Upload a challenge datapack to Google Cloud Storage.
+     * @param slug - The slug of the challenge.
+     * @param tarballPath - The path to the tarball file.
+     * @returns The upload URL.
+     */
+    uploadChallengeDatapack(slug: string, tarballPath: string): Promise<void>;
+    /**
+     * Get the upload URL for a challenge datapack.
+     * @param slug - The slug of the challenge.
+     * @returns The upload URL.
+     */
+    getChallengeUploadUrl(slug: string): Promise<string>;
     runChallenge(runData: {
         challenge: string;
         participants: unknown[];
-    }, studio?: boolean): Promise<{
+    }): Promise<{
         runIds?: string[] | undefined;
     }>;
     deleteChallenge(challengeId: string): Promise<void>;

package/dist/lib/api-client.js

@@ -1,3 +1,5 @@
+import { existsSync } from "node:fs";
+import fs from "node:fs/promises";
 import { AgentsResponseSchema, ChallengeSchema, ChallengesResponseSchema, HumanSchema, RunResponseSchema, RunStatusSchema, UploadUrlResponseSchema, } from "./schemas.js";
 const DEFAULT_PAGE_SIZE = 30;
 const DEFAULT_CHALLENGE_SCHEMA = {
@@ -21,37 +23,38 @@ const DEFAULT_CHALLENGE_SCHEMA = {
     },*/,
 };
 export class ApiClient {
-    config;
-    constructor(config) {
-        this.config = config;
-    }
-    async request(target, url, options) {
-        const baseUrl = target === "web" ? this.config.WEB_API_URL : this.config.STUDIO_API_URL;
-        const fullUrl = `${baseUrl}/${url}`;
+    apiUrl;
+    kradleApiKey;
+    constructor(apiUrl, kradleApiKey) {
+        this.apiUrl = apiUrl;
+        this.kradleApiKey = kradleApiKey;
+    }
+    async request(endpoint, options) {
+        const fullUrl = `${this.apiUrl}/${endpoint}`;
         const response = await fetch(fullUrl, {
             ...options,
             headers: {
-                Authorization: `Bearer ${this.config.KRADLE_API_KEY}`,
+                Authorization: `Bearer ${this.kradleApiKey}`,
                 "Content-Type": "application/json",
                 ...options.headers,
             },
         });
         if (!response.ok) {
             const text = await response.text();
-            throw new Error(`API call failed: ${url} - ${response.status} ${response.statusText}\n${text}`);
+            throw new Error(`API call failed: ${fullUrl} - ${response.status} ${response.statusText}\n${text}`);
         }
         return response;
     }
-    async get(target, url, options = {}, schema) {
-        const response = await this.request(target, url, {
+    async get(url, options = {}, schema) {
+        const response = await this.request(url, {
             method: "GET",
             ...options,
         });
         const data = await response.json();
         return schema ? schema.parse(data) : data;
     }
-    async post(target, url, options = {}, schema) {
-        const response = await this.request(target, url, {
+    async post(url, options = {}, schema) {
+        const response = await this.request(url, {
             method: "POST",
             ...options,
         });
@@ -62,14 +65,14 @@ export class ApiClient {
         const data = JSON.parse(text);
         return schema ? schema.parse(data) : data;
     }
-    async put(target, url, options = {}) {
-        return await this.request(target, url, {
+    async put(url, options = {}) {
+        return await this.request(url, {
             method: "PUT",
             ...options,
         });
     }
-    async delete(target, url, options = {}) {
-        return await this.request(target, url, {
+    async delete(url, options = {}) {
+        return await this.request(url, {
             method: "DELETE",
             ...options,
         });
@@ -97,7 +100,7 @@ export class ApiClient {
             if (pageToken)
                 params.set("page_token", pageToken);
             params.set("page_size", String(pageSize));
-            const response = await this.get("web", `${url}?${params}`, {
+            const response = await this.get(`${url}?${params}`, {
                 headers: {
                     "Content-Type": "application/json",
                 },
@@ -109,7 +112,7 @@ export class ApiClient {
     }
     async getHuman() {
         const url = "human";
-        return this.get("web", url, {}, HumanSchema);
+        return this.get(url, {}, HumanSchema);
     }
     async listChallenges() {
         return this.listResource("challenges", "challenges", ChallengesResponseSchema);
@@ -122,7 +125,7 @@ export class ApiClient {
     }
     async getChallenge(challengeId) {
         const url = `challenges/${challengeId}`;
-        return this.get("web", url, {}, ChallengeSchema);
+        return this.get(url, {}, ChallengeSchema);
     }
     /**
      * Check if a challenge exists in the cloud.
@@ -132,7 +135,7 @@ export class ApiClient {
     async challengeExists(slug) {
         const url = `challenges/${slug}`;
         try {
-            const res = await this.get("web", url, {});
+            const res = await this.get(url, {});
             return res !== null && res !== undefined;
         }
         catch (error) {
@@ -142,37 +145,78 @@ export class ApiClient {
     async createChallenge(slug) {
         const challenge = { ...DEFAULT_CHALLENGE_SCHEMA, slug: slug, name: slug };
         const url = "challenges";
-        return this.post("web", url, {
+        return this.post(url, {
             body: JSON.stringify(challenge),
         });
     }
     /**
      * Update a challenge definition in the cloud.
-     * @param challenge - The challenge to update.
-     * @param challengeConfig - The challenge config to upload. If not provided, the config will be loaded from the challenge.
+     * @param challengeSlug - The slug of the challenge.
+     * @param challengeConfig - The challenge config to upload.
+     * @param visibility - The visibility to set.
+     * @returns The updated challenge.
+     */
+    async updateChallenge(challengeSlug, challengeConfig, visibility) {
+        const url = `challenges/${challengeSlug}`;
+        const fullConfig = { ...challengeConfig, slug: challengeSlug, visibility };
+        await this.put(url, {
+            body: JSON.stringify(fullConfig),
+        });
+    }
+    /**
+     * Update the visibility of a challenge.
+     * @param challengeSlug - The slug of the challenge.
+     * @param visibility - The visibility to set.
      * @returns The updated challenge.
      */
-    async updateChallenge(challenge, challengeConfig) {
-        const url = `challenges/${challenge.shortSlug}`;
-        console.log(url);
-        const config = challengeConfig ?? (await challenge.loadConfig());
-        await this.put("web", url, {
-            body: JSON.stringify(config),
+    async updateChallengeVisibility(challengeSlug, visibility) {
+        const url = `challenges/${challengeSlug}/visibility`;
+        await this.post(url, {
+            body: JSON.stringify({ visibility }),
+        });
+    }
+    /**
+     * Upload a challenge datapack to Google Cloud Storage.
+     * @param slug - The slug of the challenge.
+     * @param tarballPath - The path to the tarball file.
+     * @returns The upload URL.
+     */
+    async uploadChallengeDatapack(slug, tarballPath) {
+        const uploadUrl = await this.getChallengeUploadUrl(slug);
+        if (!existsSync(tarballPath)) {
+            throw new Error(`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 datapack: ${response.statusText}`);
+        }
     }
-    async getChallengeUploadUrl(challenge) {
-        const response = await this.get("web", `challenges/${challenge.shortSlug}/datapackUploadUrl`, {}, UploadUrlResponseSchema);
+    /**
+     * Get the upload URL for a challenge datapack.
+     * @param slug - The slug of the challenge.
+     * @returns The upload URL.
+     */
+    async getChallengeUploadUrl(slug) {
+        const response = await this.get(`challenges/${slug}/datapackUploadUrl`, {}, UploadUrlResponseSchema);
         return response.uploadUrl;
     }
-    async runChallenge(runData, studio = false) {
+    async runChallenge(runData) {
         const url = "jobs";
-        return this.post(studio ? "studio" : "web", url, {
+        return this.post(url, {
             body: JSON.stringify(runData),
         }, RunResponseSchema);
     }
     async deleteChallenge(challengeId) {
         const url = `challenges/${challengeId}`;
-        await this.delete("web", url);
+        await this.delete(url);
     }
     /**
      * Get the status of a run.
@@ -181,7 +225,7 @@ export class ApiClient {
      */
     async getRunStatus(runId) {
         const url = `runs/${runId}`;
-        return this.get("web", url, {}, RunStatusSchema);
+        return this.get(url, {}, RunStatusSchema);
     }
     /**
      * Add a tag to a run.
@@ -191,7 +235,7 @@ export class ApiClient {
      */
     async tagRun(runId, tag) {
         const url = `runs/${runId}/tag`;
-        await this.post("web", url, {
+        await this.post(url, {
             body: JSON.stringify({ tag }),
         });
     }

package/dist/lib/arguments.d.ts

@@ -2,6 +2,7 @@ import type { Arg } from "@oclif/core/interfaces";
 /**
  * Returns a "challenge slug" argument, and validates it to be a valid challenge slug.
  */
-export declare function getChallengeSlugArgument({ description }: {
+export declare function getChallengeSlugArgument<R extends boolean = true>({ description, required, }: {
     description: string;
-}): Arg<string>;
+    required?: R;
+}): Arg<R extends true ? string : string | undefined>;

package/dist/lib/arguments.js

@@ -3,10 +3,10 @@ const CHALLENGE_SLUG_REGEX = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 /**
  * Returns a "challenge slug" argument, and validates it to be a valid challenge slug.
  */
-export function getChallengeSlugArgument({ description }) {
-    return Args.string({
+export function getChallengeSlugArgument({ description, required, }) {
+    const arg = Args.string({
         description,
-        required: true,
+        required: required ?? true,
         parse: async (input) => {
             if (!CHALLENGE_SLUG_REGEX.test(input)) {
                 throw new Error(`Invalid challenge slug: ${input}. Challenge slugs must be lowercase alphanumeric characters and hyphens, and must not start or end with a hyphen.`);
@@ -14,4 +14,6 @@ export function getChallengeSlugArgument({ description }) {
             return input;
         },
     });
+    // biome-ignore lint/suspicious/noExplicitAny: Typescript can't handle the conditional "required"
+    return arg;
 }