@kradle/cli 0.0.16 → 0.1.0

package/dist/lib/challenge.d.ts

@@ -1,17 +1,10 @@
 import type { ApiClient } from "./api-client.js";
-import type { Config } from "./config.js";
-import { type ChallengeSchemaType } from "./schemas.js";
+import { type ChallengeConfigSchemaType } from "./schemas.js";
 export declare const SOURCE_FOLDER = ".src";
 export declare class Challenge {
-    readonly name: string;
-    private readonly config;
-    constructor(name: string, config: Config);
-    private get kradleChallengesPath();
-    /**
-     * Get the short slug without username prefix
-     * e.g., "florianernst:challenge" -> "challenge"
-     */
-    get shortSlug(): string;
+    readonly shortSlug: string;
+    private readonly kradleChallengesPath;
+    constructor(shortSlug: string, kradleChallengesPath: string);
     /**
      * Get the path to the challenge directory
      */
@@ -47,22 +40,24 @@ export declare class Challenge {
     /**
      * Load the challenge configuration from config.ts
      */
-    loadConfig(): Promise<ChallengeSchemaType>;
+    loadConfig(): Promise<ChallengeConfigSchemaType>;
     /**
-     * Upload the challenge datapack to Google Cloud Storage
+     * Build the challenge datapack and upload it to the cloud.
+     * @param api - The API client to use.
+     * @param asPublic - Whether the challenge should be uploaded as public.
+     * @returns The config and datapack hash.
      */
-    upload(apiClient: ApiClient): Promise<void>;
-    buildAndUpload(api: ApiClient): Promise<{
-        config: ChallengeSchemaType;
+    buildAndUpload(api: ApiClient, asPublic: boolean): Promise<{
+        config: ChallengeConfigSchemaType;
         datapackHash: string;
     }>;
     /**
      * Get all local challenges from the challenges directory
      */
-    static getLocalChallenges(): Promise<Record<string, boolean>>;
+    static getLocalChallenges(): Promise<string[]>;
     /**
      * Create a new local challenge folder with challenge.ts template
      * Note: config.ts is NOT created here - it should be generated later via `challenge config download`
      */
-    static createLocal(slug: string, config: Config): Promise<void>;
+    static createLocal(slug: string, kradleChallengesPath: string): Promise<void>;
 }

package/dist/lib/challenge.js

@@ -4,25 +4,15 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import pc from "picocolors";
 import * as tar from "tar";
-import { ChallengeSchema } from "./schemas.js";
+import { ChallengeConfigSchema } from "./schemas.js";
 import { executeNodeCommand, executeTypescriptFile, getStaticResourcePath, readDirSorted } from "./utils.js";
 export const SOURCE_FOLDER = ".src";
 export class Challenge {
-    name;
-    config;
-    constructor(name, config) {
-        this.name = name;
-        this.config = config;
-    }
-    get kradleChallengesPath() {
-        return path.resolve(this.config.KRADLE_CHALLENGES_PATH);
-    }
-    /**
-     * Get the short slug without username prefix
-     * e.g., "florianernst:challenge" -> "challenge"
-     */
-    get shortSlug() {
-        return this.name.includes(":") ? this.name.split(":")[1] : this.name;
+    shortSlug;
+    kradleChallengesPath;
+    constructor(shortSlug, kradleChallengesPath) {
+        this.shortSlug = shortSlug;
+        this.kradleChallengesPath = path.resolve(kradleChallengesPath);
     }
     /**
      * Get the path to the challenge directory
@@ -94,15 +84,27 @@ export class Challenge {
             throw new Error(`Challenge file not found at ${this.challengePath}`);
         }
         try {
-            await executeTypescriptFile(this.challengePath, this.config, { silent });
+            await executeTypescriptFile(this.challengePath, {
+                KRADLE_CHALLENGES_PATH: this.kradleChallengesPath,
+                NAMESPACE: "kradle",
+            }, { silent });
         }
         catch (error) {
             throw new Error(`Failed to build datapack: ${error instanceof Error ? error.message : error}`);
         }
         // @TODO - re-enable once we have a proper build pipeline
         // Copy challenge.ts and config.ts to the src directory
-        await fs.cp(path.join(this.challengeDir, "challenge.ts"), path.join(this.config.KRADLE_CHALLENGES_PATH, this.shortSlug, SOURCE_FOLDER, "challenge.ts"));
-        await fs.cp(path.join(this.challengeDir, "config.ts"), path.join(this.config.KRADLE_CHALLENGES_PATH, this.shortSlug, SOURCE_FOLDER, "config.ts"));
+        await fs.cp(path.join(this.challengeDir, "challenge.ts"), path.join(this.kradleChallengesPath, this.shortSlug, SOURCE_FOLDER, "challenge.ts"));
+        await fs.cp(path.join(this.challengeDir, "config.ts"), path.join(this.kradleChallengesPath, this.shortSlug, SOURCE_FOLDER, "config.ts"));
+        // Create tarball
+        // We need to use the cwd option to make sure the structure of the tarball uses paths relative to the challenge directory
+        await tar.create({
+            "no-mtime": true,
+            file: this.tarballPath, // Output file name
+            gzip: true,
+            cwd: this.datapackPath, // Input directory
+            strict: true,
+        }, ["datapack", SOURCE_FOLDER]);
     }
     /**
      * Load the challenge configuration from config.ts
@@ -118,60 +120,54 @@ export class Challenge {
             "--no-warnings",
             "-e",
             `console.log(JSON.stringify(require("${this.configPath}").config));`,
-        ], this.config);
-        return ChallengeSchema.parse(JSON.parse(stdout));
+        ], {
+            KRADLE_CHALLENGES_PATH: this.kradleChallengesPath,
+            NAMESPACE: "kradle",
+        });
+        return ChallengeConfigSchema.parse(JSON.parse(stdout));
     }
     /**
-     * Upload the challenge datapack to Google Cloud Storage
+     * Build the challenge datapack and upload it to the cloud.
+     * @param api - The API client to use.
+     * @param asPublic - Whether the challenge should be uploaded as public.
+     * @returns The config and datapack hash.
      */
-    async upload(apiClient) {
-        // Create tarball
-        // We need to use the cwd option to make sure the structure of the tarball uses paths relative to the challenge directory
-        await tar.create({
-            "no-mtime": true,
-            file: this.tarballPath, // Output file name
-            gzip: true,
-            cwd: this.datapackPath, // Input directory
-            strict: true,
-        }, ["datapack", SOURCE_FOLDER]);
-        const uploadUrl = await apiClient.getChallengeUploadUrl(this);
-        const fileBuffer = await fs.readFile(this.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 buildAndUpload(api) {
+    async buildAndUpload(api, asPublic) {
         // Ensure challenge exists locally
         if (!this.exists()) {
-            throw new Error(`Challenge "${this.name}" does not exist locally. Make sure both the challenge.ts file and the config.ts file exist.`);
+            throw new Error(`Challenge "${this.shortSlug}" does not exist locally. Make sure both the challenge.ts file and the config.ts file exist.`);
         }
         // Ensure challenge exists in the cloud
-        if (!(await api.challengeExists(this.name))) {
-            console.log(pc.yellow(`Challenge not found in cloud: ${this.name}`));
-            console.log(pc.yellow(`Creating challenge: ${this.name}`));
-            await api.createChallenge(this.name);
+        if (!(await api.challengeExists(this.shortSlug))) {
+            console.log(pc.yellow(`Challenge not found in cloud: ${this.shortSlug}`));
+            console.log(pc.yellow(`Creating challenge: ${this.shortSlug}`));
+            await api.createChallenge(this.shortSlug);
             console.log(pc.green(`✓ Challenge created in cloud`));
         }
-        // Load config
         const config = await this.loadConfig();
+        // Ensure challenge's visibility is set to private - else, temporarily set it to private
+        const cloudChallengeVisibility = (await api.getChallenge(this.shortSlug)).visibility;
+        if (cloudChallengeVisibility === "public") {
+            console.log(pc.yellow(`⚠️  Cloud challenge is currently public. Setting its visibility to private...`));
+            await api.updateChallengeVisibility(this.shortSlug, "private");
+            console.log(pc.yellow(`✓  Challenge visibility set to private\n`));
+        }
         // Upload config
         console.log(pc.blue(`>> Uploading config: ${this.shortSlug}`));
-        await api.updateChallenge(this, config);
-        console.log(pc.green(`✓ Config uploaded`));
+        // We have to set it to private because we cannot update public challenges
+        await api.updateChallenge(this.shortSlug, config, "private");
+        console.log(pc.green(`✓  Config uploaded\n`));
         // Build and upload datapack
         console.log(pc.blue(`>> Building datapack: ${this.shortSlug}`));
         await this.build();
         console.log(pc.blue(`>> Uploading datapack: ${this.shortSlug}`));
-        await this.upload(api);
-        console.log(pc.green(`✓ Build & upload complete for ${this.shortSlug}`));
+        await api.uploadChallengeDatapack(this.shortSlug, this.tarballPath);
+        console.log(pc.green(`✓  Build & upload complete for ${this.shortSlug}\n`));
+        if (asPublic) {
+            console.log(pc.green(`👀 Setting challenge visibility to public...`));
+            await api.updateChallengeVisibility(this.shortSlug, "public");
+            console.log(pc.green(`✓  Challenge visibility set to public\n`));
+        }
         const datapackHash = await this.getDatapackHash();
         return { config, datapackHash };
     }
@@ -180,14 +176,17 @@ export class Challenge {
      */
     static async getLocalChallenges() {
         const challengesDir = path.resolve(process.cwd(), "challenges");
+        if (!existsSync(challengesDir)) {
+            return [];
+        }
         const entries = await readDirSorted(challengesDir);
-        const challenges = {};
+        const challenges = [];
         for (const entry of entries) {
             if (entry.isDirectory()) {
                 // Check if it has a challenge.ts file
                 const challengePath = path.join(challengesDir, entry.name, "challenge.ts");
                 if (existsSync(challengePath)) {
-                    challenges[entry.name] = true;
+                    challenges.push(entry.name);
                 }
             }
         }
@@ -197,8 +196,8 @@ export class Challenge {
      * Create a new local challenge folder with challenge.ts template
      * Note: config.ts is NOT created here - it should be generated later via `challenge config download`
      */
-    static async createLocal(slug, config) {
-        const challenge = new Challenge(slug, config);
+    static async createLocal(slug, kradleChallengesPath) {
+        const challenge = new Challenge(slug, kradleChallengesPath);
         const challengeTemplatePath = getStaticResourcePath("challenge.ts");
         // Create challenge directory
         await fs.mkdir(challenge.challengeDir, { recursive: true });

package/dist/lib/experiment/experimenter.d.ts

@@ -0,0 +1,87 @@
+import type { ApiClient } from "../api-client.js";
+import type { ExperimentMetadata, ExperimentOptions, Manifest, Progress } from "./types.js";
+export declare class Experimenter {
+    private name;
+    private webUrl;
+    private api;
+    experimentDir: string;
+    metadataPath: string;
+    private runner?;
+    private tui?;
+    private currentVersion?;
+    constructor(name: string, webUrl: string, api: ApiClient);
+    /**
+     * Get paths for a specific version
+     */
+    private getVersionPaths;
+    get configPath(): string;
+    /**
+     * Get the current version directory path
+     */
+    getCurrentVersionDir(): string;
+    /**
+     * Check if experiment exists
+     */
+    exists(): Promise<boolean>;
+    /**
+     * Check if config.ts exists (master config)
+     */
+    configExists(): Promise<boolean>;
+    /**
+     * Load experiment metadata
+     */
+    loadMetadata(): Promise<ExperimentMetadata | null>;
+    /**
+     * Save experiment metadata
+     */
+    saveMetadata(metadata: ExperimentMetadata): Promise<void>;
+    /**
+     * Get the current version number, or -1 if none exists
+     */
+    getCurrentVersionNumber(): Promise<number>;
+    /**
+     * Create a new version
+     */
+    createNewVersion(): Promise<number>;
+    /**
+     * Get or create a version
+     * @param createNew - If true, always create a new version. Otherwise, use current version or create first one if none exists.
+     */
+    getOrCreateVersion(createNew: boolean): Promise<number>;
+    /**
+     * Load manifest from version
+     */
+    loadManifest(version: number): Promise<Manifest>;
+    /**
+     * Load progress from version
+     */
+    loadProgress(version: number): Promise<Progress | null>;
+    /**
+     * Save progress to current version
+     */
+    saveProgress(): Promise<void>;
+    /**
+     * Execute config.ts to generate manifest
+     */
+    generateManifest(configPath: string): Promise<Manifest>;
+    /**
+     * Execute config.ts file and return the manifest
+     */
+    private executeConfigFile;
+    /**
+     * Run the experiment
+     */
+    run(options: ExperimentOptions): Promise<void>;
+    /**
+     * Handle state change from runner
+     */
+    private onRunStateChange;
+    /**
+     * Handle quit request
+     */
+    private handleQuit;
+    /**
+     * Open run in browser
+     */
+    private openRun;
+}

package/dist/lib/{evaluation/evaluator.js → experiment/experimenter.js}

@@ -1,55 +1,56 @@
 import fs from "node:fs/promises";
 import path from "node:path";
+import pc from "picocolors";
 import { executeNodeCommand, openInBrowser } from "../utils.js";
 import { Runner } from "./runner.js";
 import { TUI } from "./tui.js";
-import { EvaluationMetadataSchema, ManifestSchema, ProgressSchema } from "./types.js";
-export class Evaluator {
+import { ExperimentMetadataSchema, ManifestSchema, ProgressSchema } from "./types.js";
+export class Experimenter {
     name;
-    config;
+    webUrl;
     api;
-    evaluationDir;
+    experimentDir;
     metadataPath;
     runner;
     tui;
-    currentIteration;
-    constructor(name, config, api) {
+    currentVersion;
+    constructor(name, webUrl, api) {
         this.name = name;
-        this.config = config;
+        this.webUrl = webUrl;
         this.api = api;
-        this.evaluationDir = path.resolve(process.cwd(), "evaluations", name);
-        this.metadataPath = path.join(this.evaluationDir, ".evaluation.json");
+        this.experimentDir = path.resolve(process.cwd(), "experiments", name);
+        this.metadataPath = path.join(this.experimentDir, ".experiment.json");
     }
     /**
-     * Get paths for a specific iteration
+     * Get paths for a specific version
      */
-    getIterationPaths(iteration) {
-        const iterationDir = path.join(this.evaluationDir, "iterations", iteration.toString().padStart(3, "0"));
+    getVersionPaths(version) {
+        const versionDir = path.join(this.experimentDir, "versions", version.toString().padStart(3, "0"));
         return {
-            iterationDir,
-            configPath: path.join(iterationDir, "config.ts"),
-            manifestPath: path.join(iterationDir, "manifest.json"),
-            progressPath: path.join(iterationDir, "progress.json"),
+            versionDir,
+            configPath: path.join(versionDir, "config.ts"),
+            manifestPath: path.join(versionDir, "manifest.json"),
+            progressPath: path.join(versionDir, "progress.json"),
         };
     }
     get configPath() {
-        return path.join(this.evaluationDir, "config.ts");
+        return path.join(this.experimentDir, "config.ts");
     }
     /**
-     * Get the current iteration directory path
+     * Get the current version directory path
      */
-    getCurrentIterationDir() {
-        if (this.currentIteration === undefined) {
-            throw new Error("No iteration set");
+    getCurrentVersionDir() {
+        if (this.currentVersion === undefined) {
+            throw new Error("No version set");
         }
-        return this.getIterationPaths(this.currentIteration).iterationDir;
+        return this.getVersionPaths(this.currentVersion).versionDir;
     }
     /**
-     * Check if evaluation exists
+     * Check if experiment exists
      */
     async exists() {
         try {
-            await fs.access(this.evaluationDir);
+            await fs.access(this.experimentDir);
             return true;
         }
         catch {
@@ -69,81 +70,81 @@ export class Evaluator {
         }
     }
     /**
-     * Load evaluation metadata
+     * Load experiment metadata
      */
     async loadMetadata() {
         try {
             const content = await fs.readFile(this.metadataPath, "utf-8");
             const data = JSON.parse(content);
-            return EvaluationMetadataSchema.parse(data);
+            return ExperimentMetadataSchema.parse(data);
         }
         catch {
             return null;
         }
     }
     /**
-     * Save evaluation metadata
+     * Save experiment metadata
      */
     async saveMetadata(metadata) {
         await fs.writeFile(this.metadataPath, JSON.stringify(metadata, null, 2));
     }
     /**
-     * Get the current iteration number, or -1 if none exists
+     * Get the current version number, or -1 if none exists
      */
-    async getCurrentIterationNumber() {
+    async getCurrentVersionNumber() {
         const metadata = await this.loadMetadata();
-        return metadata?.currentIteration ?? -1;
+        return metadata?.currentVersion ?? -1;
     }
     /**
-     * Create a new iteration
+     * Create a new version
      */
-    async createNewIteration() {
-        const currentIteration = await this.getCurrentIterationNumber();
-        const newIteration = currentIteration + 1;
-        const paths = this.getIterationPaths(newIteration);
-        // Create iteration directory
-        await fs.mkdir(paths.iterationDir, { recursive: true });
-        // Copy master config to iteration
-        const masterConfigPath = path.join(this.evaluationDir, "config.ts");
+    async createNewVersion() {
+        const currentVersion = await this.getCurrentVersionNumber();
+        const newVersion = currentVersion + 1;
+        const paths = this.getVersionPaths(newVersion);
+        // Create version directory
+        await fs.mkdir(paths.versionDir, { recursive: true });
+        // Copy master config to version
+        const masterConfigPath = path.join(this.experimentDir, "config.ts");
         await fs.copyFile(masterConfigPath, paths.configPath);
         // Generate manifest from config
         const manifest = await this.generateManifest(paths.configPath);
         await fs.writeFile(paths.manifestPath, JSON.stringify(manifest, null, 2));
         // Update metadata
-        await this.saveMetadata({ currentIteration: newIteration });
-        this.currentIteration = newIteration;
-        return newIteration;
+        await this.saveMetadata({ currentVersion: newVersion });
+        this.currentVersion = newVersion;
+        return newVersion;
     }
     /**
-     * Get or create an iteration
-     * @param createNew - If true, always create a new iteration. Otherwise, use current iteration or create first one if none exists.
+     * Get or create a version
+     * @param createNew - If true, always create a new version. Otherwise, use current version or create first one if none exists.
      */
-    async getOrCreateIteration(createNew) {
+    async getOrCreateVersion(createNew) {
         if (createNew) {
-            return await this.createNewIteration();
+            return await this.createNewVersion();
         }
-        const currentIteration = await this.getCurrentIterationNumber();
-        if (currentIteration < 0) {
-            return await this.createNewIteration();
+        const currentVersion = await this.getCurrentVersionNumber();
+        if (currentVersion < 0) {
+            return await this.createNewVersion();
         }
-        this.currentIteration = currentIteration;
-        return currentIteration;
+        this.currentVersion = currentVersion;
+        return currentVersion;
     }
     /**
-     * Load manifest from iteration
+     * Load manifest from version
      */
-    async loadManifest(iteration) {
-        const paths = this.getIterationPaths(iteration);
+    async loadManifest(version) {
+        const paths = this.getVersionPaths(version);
         const content = await fs.readFile(paths.manifestPath, "utf-8");
         const data = JSON.parse(content);
         return ManifestSchema.parse(data);
     }
     /**
-     * Load progress from iteration
+     * Load progress from version
      */
-    async loadProgress(iteration) {
+    async loadProgress(version) {
         try {
-            const paths = this.getIterationPaths(iteration);
+            const paths = this.getVersionPaths(version);
             const content = await fs.readFile(paths.progressPath, "utf-8");
             const data = JSON.parse(content);
             return ProgressSchema.parse(data);
@@ -153,12 +154,12 @@ export class Evaluator {
         }
     }
     /**
-     * Save progress to current iteration
+     * Save progress to current version
      */
     async saveProgress() {
-        if (!this.runner || this.currentIteration === undefined)
+        if (!this.runner || this.currentVersion === undefined)
             return;
-        const paths = this.getIterationPaths(this.currentIteration);
+        const paths = this.getVersionPaths(this.currentVersion);
         const progress = {
             entries: this.runner.getProgressEntries(),
             lastUpdated: Date.now(),
@@ -183,34 +184,34 @@ export class Evaluator {
             "--no-warnings",
             "-e",
             `console.log(JSON.stringify(require("${configPath}").main()));`,
-        ], this.config);
+        ], {});
         return JSON.parse(stdout.trim());
     }
     /**
-     * Run the evaluation
+     * Run the experiment
      */
     async run(options) {
-        const iteration = await this.getOrCreateIteration(options.new);
+        const version = await this.getOrCreateVersion(options.new);
         // Load manifest
-        const manifest = await this.loadManifest(iteration);
-        // We have 2 mandatory tags: "eval-<evaluation-name>" and "eval-<evaluation-name>-iteration-<iteration>"
-        const evaluationTag = `eval-${this.name}`;
-        const iterationTag = `${evaluationTag}-iteration-${iteration}`;
-        const tags = [evaluationTag, iterationTag, ...(manifest.tags ?? [])];
+        const manifest = await this.loadManifest(version);
+        // We have 2 mandatory tags: "exp-<experiment-name>" and "exp-<experiment-name>-v<version>"
+        const experimentTag = `exp-${this.name}`;
+        const versionTag = `${experimentTag}-v${version}`;
+        const tags = [experimentTag, versionTag, ...(manifest.tags ?? [])];
         // Create runner
-        this.runner = new Runner(manifest.runs, this.api, this.config.WEB_URL, {
+        this.runner = new Runner(manifest.runs, this.api, this.webUrl, {
             maxConcurrent: options.maxConcurrent,
             tags: tags,
             onStateChange: () => this.onRunStateChange(),
         });
         // Restore progress if applicable
-        const progress = await this.loadProgress(iteration);
+        const progress = await this.loadProgress(version);
         if (progress) {
             this.runner.restoreProgress(progress.entries);
         }
         // Create TUI
         this.tui = new TUI({
-            evaluationName: `${this.name} (iteration ${iteration})`,
+            experimentName: `${this.name} (v${version})`,
             onQuit: () => this.handleQuit(),
             onOpenRun: (index) => this.openRun(index),
         });
@@ -230,7 +231,7 @@ export class Evaluator {
             console.log("");
         }
         if (options.openMetabase ?? true) {
-            openInBrowser(`https://daunt-fair.metabaseapp.com/dashboard/10-runs-analysis?tags=${iterationTag}`);
+            openInBrowser(`https://daunt-fair.metabaseapp.com/dashboard/10-runs-analysis?run_tags=${versionTag}`);
         }
         const errors = this.runner?.getAllStates().filter((state) => state.status === "error");
         if (errors?.length > 0) {
@@ -254,6 +255,7 @@ export class Evaluator {
     handleQuit() {
         this.runner?.stop();
         this.tui?.stop();
+        console.log(pc.yellow(`\nThe experiment has been interrupted. You can resume it later by running "kradle experiment run ${this.name}".`));
         process.exit(0);
     }
     /**

package/dist/lib/{evaluation → experiment}/index.d.ts

@@ -1,4 +1,4 @@
-export { Evaluator } from "./evaluator.js";
+export { Experimenter } from "./experimenter.js";
 export { Runner } from "./runner.js";
 export { TUI } from "./tui.js";
 export * from "./types.js";

package/dist/lib/{evaluation → experiment}/index.js

@@ -1,4 +1,4 @@
-export { Evaluator } from "./evaluator.js";
+export { Experimenter } from "./experimenter.js";
 export { Runner } from "./runner.js";
 export { TUI } from "./tui.js";
 export * from "./types.js";

package/dist/lib/{evaluation → experiment}/runner.js

@@ -157,7 +157,8 @@ export class Runner {
             const runId = response.runIds[0];
             this.updateState(index, { runId, status: "running" });
             // Tag the run with all configured tags
-            await Promise.all(this.tags.map((tag) => this.api.tagRun(runId, tag)));
+            const tags = [...this.tags, ...(state.config.tags ?? [])];
+            await Promise.all(tags.map((tag) => this.api.tagRun(runId, tag)));
             // Poll for completion
             await this.pollRunStatus(index, runId);
         }

package/dist/lib/{evaluation → experiment}/tui.d.ts

@@ -1,6 +1,6 @@
 import type { RunState, StatusCounts } from "./types.js";
 export interface TUIOptions {
-    evaluationName: string;
+    experimentName: string;
     onQuit: () => void;
     onOpenRun: (index: number) => void;
 }