@kradle/cli 0.0.17 → 0.2.0

package/dist/lib/flags.js

@@ -0,0 +1,63 @@
+import { Flags } from "@oclif/core";
+import { untildify } from "./utils.js";
+/**
+ * All available config flags that can be used by commands.
+ * Each flag has an `env` property that allows it to be set via environment variable.
+ */
+export const ALL_CONFIG_FLAGS = {
+    "api-url": Flags.string({
+        description: "Kradle Web API URL",
+        env: "KRADLE_API_URL",
+        required: true,
+        default: "https://api.kradle.ai/v0",
+    }),
+    "web-url": Flags.string({
+        description: "Kradle Web URL, used to display the run URL",
+        env: "KRADLE_WEB_URL",
+        required: true,
+        default: "https://kradle.ai",
+    }),
+    "studio-api-url": Flags.string({
+        description: "Kradle Studio API URL, used to communicate with the Studio API",
+        env: "KRADLE_STUDIO_API_URL",
+        required: true,
+        default: "http://localhost:2999/api/v0",
+    }),
+    "studio-url": Flags.string({
+        description: "Kradle Studio URL, used to display the run URL in Studio",
+        env: "KRADLE_STUDIO_URL",
+        required: true,
+        default: "kradle://open",
+    }),
+    "api-key": Flags.string({
+        description: "Kradle API key",
+        env: "KRADLE_API_KEY",
+        required: true,
+    }),
+    "challenges-path": Flags.string({
+        description: "Absolute path to the challenges directory",
+        env: "KRADLE_CHALLENGES_PATH",
+        default: "~/Documents/kradle-studio/challenges",
+        parse: async (input) => untildify(input),
+    }),
+};
+/**
+ * Returns a subset of config flags for use in a command's static flags definition.
+ *
+ * @example
+ * // In a command file:
+ * static override flags = {
+ *   ...getConfigFlags("api-key", "web-api-url", "studio-api-url"),
+ *   // other command-specific flags
+ * };
+ *
+ * @param keys - The config flag keys to include.
+ * @returns An object containing only the specified flags
+ */
+export function getConfigFlags(...keys) {
+    const result = {};
+    for (const key of keys) {
+        result[key] = ALL_CONFIG_FLAGS[key];
+    }
+    return result;
+}

package/dist/lib/schemas.d.ts

@@ -40,6 +40,37 @@ export declare const ChallengeSchema: z.ZodObject<{
     updateTime: z.ZodOptional<z.ZodString>;
     creator: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
+export declare const ChallengeConfigSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    domain: z.ZodString;
+    world: z.ZodString;
+    challengeConfig: z.ZodObject<{
+        cheat: z.ZodBoolean;
+        datapack: z.ZodBoolean;
+        gameMode: z.ZodEnum<{
+            survival: "survival";
+            creative: "creative";
+            adventure: "adventure";
+            spectator: "spectator";
+        }>;
+    }, z.core.$strip>;
+    task: z.ZodOptional<z.ZodString>;
+    roles: z.ZodRecord<z.ZodString, z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        specificTask: z.ZodOptional<z.ZodString>;
+        minParticipants: z.ZodOptional<z.ZodNumber>;
+        maxParticipants: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    objective: z.ZodObject<{
+        fieldName: z.ZodString;
+        direction: z.ZodEnum<{
+            maximize: "maximize";
+            minimize: "minimize";
+        }>;
+    }, z.core.$strip>;
+    endStates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
 export declare const ChallengesResponseSchema: z.ZodObject<{
     challenges: z.ZodArray<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
@@ -87,8 +118,19 @@ export declare const ChallengesResponseSchema: z.ZodObject<{
 export declare const HumanSchema: z.ZodObject<{
     username: z.ZodString;
 }, z.core.$strip>;
-export declare const RunResponseSchema: z.ZodObject<{
+export declare const RunParticipantSchema: z.ZodObject<{
+    agent: z.ZodString;
+    role: z.ZodString;
+    inputOrder: z.ZodNumber;
+}, z.core.$strip>;
+export declare const JobResponseSchema: z.ZodObject<{
     runIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    participants: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        agent: z.ZodString;
+        role: z.ZodString;
+        inputOrder: z.ZodNumber;
+    }, z.core.$strip>>>;
+    id: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const RunStatusSchema: z.ZodObject<{
     id: z.ZodString;
@@ -134,10 +176,29 @@ export declare const AgentsResponseSchema: z.ZodObject<{
     }, z.core.$strip>>;
     nextPageToken: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
+export declare const RecordingMetadataSchema: z.ZodObject<{
+    timestamp: z.ZodString;
+    sizeBytes: z.ZodNumber;
+}, z.core.$strip>;
+export declare const RecordingsListResponseSchema: z.ZodObject<{
+    recordings: z.ZodArray<z.ZodObject<{
+        timestamp: z.ZodString;
+        sizeBytes: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const RecordingDownloadUrlResponseSchema: z.ZodObject<{
+    downloadUrl: z.ZodString;
+    expiresAt: z.ZodString;
+}, z.core.$strip>;
 export type ChallengeSchemaType = z.infer<typeof ChallengeSchema>;
+export type ChallengeConfigSchemaType = z.infer<typeof ChallengeConfigSchema>;
 export type ChallengesResponseType = z.infer<typeof ChallengesResponseSchema>;
 export type HumanSchemaType = z.infer<typeof HumanSchema>;
-export type RunResponseType = z.infer<typeof RunResponseSchema>;
+export type JobResponseType = z.infer<typeof JobResponseSchema>;
 export type RunStatusSchemaType = z.infer<typeof RunStatusSchema>;
 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>;

package/dist/lib/schemas.js

@@ -28,6 +28,14 @@ export const ChallengeSchema = z.object({
     updateTime: z.string().optional(),
     creator: z.string().optional(),
 });
+export const ChallengeConfigSchema = ChallengeSchema.omit({
+    slug: true,
+    id: true,
+    visibility: true,
+    creationTime: true,
+    updateTime: true,
+    creator: true,
+});
 export const ChallengesResponseSchema = z.object({
     challenges: z.array(ChallengeSchema),
     nextPageToken: z.string().optional(),
@@ -35,8 +43,15 @@ export const ChallengesResponseSchema = z.object({
 export const HumanSchema = z.object({
     username: z.string(),
 });
-export const RunResponseSchema = z.object({
+export const RunParticipantSchema = z.object({
+    agent: z.string(),
+    role: z.string(),
+    inputOrder: z.number(),
+});
+export const JobResponseSchema = z.object({
     runIds: z.array(z.string()).optional(),
+    participants: z.record(z.string(), RunParticipantSchema).optional(),
+    id: z.string().optional(),
 });
 export const RunStatusSchema = z.object({
     id: z.string(),
@@ -64,3 +79,14 @@ export const AgentsResponseSchema = z.object({
     agents: z.array(AgentSchema),
     nextPageToken: z.string().optional(),
 });
+export const RecordingMetadataSchema = z.object({
+    timestamp: z.string(),
+    sizeBytes: z.number(),
+});
+export const RecordingsListResponseSchema = z.object({
+    recordings: z.array(RecordingMetadataSchema),
+});
+export const RecordingDownloadUrlResponseSchema = z.object({
+    downloadUrl: z.string(),
+    expiresAt: z.string(),
+});

package/dist/lib/utils.d.ts

@@ -1,5 +1,4 @@
 import type { Dirent } from "node:fs";
-import type { Config } from "./config.js";
 export declare function loadTemplateRun(): Promise<Record<string, unknown>>;
 /**
  * Resolve tildes in a path to the home directory
@@ -33,34 +32,34 @@ export declare function getStaticResourcePath(name: string): string;
  */
 export declare function readDirSorted(dir: string): Promise<Dirent[]>;
 /**
- * Runs a NodeJS module. The module is executed in the current working directory, and the environment is set to the given config.
+ * Runs a NodeJS module. The module is executed in the current working directory, and the environment is set to the given env.
  * stdout & stdout are piped to the parent process.
  *
  * Returns a promise that resolves when the module completes.
  *
  * @param file The file to execute.
- * @param config The configuration to use.
+ * @param env The environment variables to set.
  * @param options The options to use.
  * @param options.silent Whether to suppress stdout.
  * @returns A promise that resolves when the command completes.
  */
-export declare function runNodeModule(file: string, config: Config, options?: {
+export declare function runNodeModule(file: string, env: Record<string, string>, options?: {
     silent?: boolean;
 }): Promise<undefined>;
 /**
  * Execute a TypeScript file using NodeJS's built-in TS support.
  *
  * @param filePath The path to the TypeScript file.
- * @param config The configuration to use.
+ * @param env The environment variables to set.
  * @param options The options to use.
  * @param options.silent Whether to suppress stdout.
  * @returns The result of the execution.
  */
-export declare function executeTypescriptFile(filePath: string, config: Config, options?: {
+export declare function executeTypescriptFile(filePath: string, env: Record<string, string>, options?: {
     silent?: boolean;
 }): Promise<unknown>;
 /**
- * Executes an arbitrary command. The command is spawned in the current working directory, and the environment is set to the given config.
+ * Executes an arbitrary command. The command is spawned in the current working directory, and the environment is set to the given env.
  *
  * stdout will be returned as a string.
  * if stderr is not empty, an error will be thrown.
@@ -76,17 +75,17 @@ export declare function executeCommand(command: string, args: string[], options?
     cwd?: string;
 }): Promise<string>;
 /**
- * Executes an arbitrary NodeJS command. The command is spawned in the current working directory, and the environment is set to the given config.
+ * Executes an arbitrary NodeJS command. The command is spawned in the current working directory, and the environment is set to the given env.
  * It will use the process.execPath of the current process to find the NodeJS executable.
  *
  * stdout will be returned as a string.
  * if stderr is not empty, an error will be thrown.
  *
  * @param args The arguments to pass to the command.
- * @param config The configuration to use.
+ * @param env The environment variables to set.
  * @returns A promise that resolves with the stdout of the command.
  */
-export declare function executeNodeCommand(args: string[], config: Config): Promise<string>;
+export declare function executeNodeCommand(args: string[], env: Record<string, string>): Promise<string>;
 /**
  * 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

@@ -75,22 +75,22 @@ export async function readDirSorted(dir) {
     return files.sort((a, b) => a.name.localeCompare(b.name));
 }
 /**
- * Runs a NodeJS module. The module is executed in the current working directory, and the environment is set to the given config.
+ * Runs a NodeJS module. The module is executed in the current working directory, and the environment is set to the given env.
  * stdout & stdout are piped to the parent process.
  *
  * Returns a promise that resolves when the module completes.
  *
  * @param file The file to execute.
- * @param config The configuration to use.
+ * @param env The environment variables to set.
  * @param options The options to use.
  * @param options.silent Whether to suppress stdout.
  * @returns A promise that resolves when the command completes.
  */
-export function runNodeModule(file, config, options = {}) {
+export function runNodeModule(file, env, options = {}) {
     return new Promise((resolve, reject) => {
         const child = fork(file, {
             cwd: path.resolve(process.cwd()),
-            env: { ...process.env, ...config },
+            env: { ...process.env, ...env },
             silent: options.silent,
         });
         child.on("close", (code) => {
@@ -108,16 +108,16 @@ export function runNodeModule(file, config, options = {}) {
  * Execute a TypeScript file using NodeJS's built-in TS support.
  *
  * @param filePath The path to the TypeScript file.
- * @param config The configuration to use.
+ * @param env The environment variables to set.
  * @param options The options to use.
  * @param options.silent Whether to suppress stdout.
  * @returns The result of the execution.
  */
-export async function executeTypescriptFile(filePath, config, options = {}) {
-    return await runNodeModule(filePath, config, options);
+export async function executeTypescriptFile(filePath, env, options = {}) {
+    return await runNodeModule(filePath, env, options);
 }
 /**
- * Executes an arbitrary command. The command is spawned in the current working directory, and the environment is set to the given config.
+ * Executes an arbitrary command. The command is spawned in the current working directory, and the environment is set to the given env.
  *
  * stdout will be returned as a string.
  * if stderr is not empty, an error will be thrown.
@@ -155,18 +155,18 @@ export async function executeCommand(command, args, options) {
     });
 }
 /**
- * Executes an arbitrary NodeJS command. The command is spawned in the current working directory, and the environment is set to the given config.
+ * Executes an arbitrary NodeJS command. The command is spawned in the current working directory, and the environment is set to the given env.
  * It will use the process.execPath of the current process to find the NodeJS executable.
  *
  * stdout will be returned as a string.
  * if stderr is not empty, an error will be thrown.
  *
  * @param args The arguments to pass to the command.
- * @param config The configuration to use.
+ * @param env The environment variables to set.
  * @returns A promise that resolves with the stdout of the command.
  */
-export async function executeNodeCommand(args, config) {
-    return executeCommand(process.execPath, args, { env: config });
+export async function executeNodeCommand(args, env) {
+    return executeCommand(process.execPath, args, { env });
 }
 /**
  * Open a URL in the default browser.