track-cli 3.0.0-rc

package/esm/src/action/pull.js

@@ -0,0 +1,22 @@
+import * as dntShim from "../../_dnt.shims.js";
+import { save as saveConfig } from "../shared/config.js";
+import { archiveExistingChallengeFiles, downloadChallengeFilesTo, getCommonChallengeContext, } from "../shared/mod.js";
+export async function pull() {
+    const trackContext = await getCommonChallengeContext();
+    const { api, codingContext, applicantExam, challengeResult, config, challengePosition, } = trackContext;
+    const configLang = config.programmingLanguage;
+    const currentLang = challengeResult.programmingLanguage;
+    const currentDir = dntShim.Deno.cwd();
+    if (configLang && currentLang && configLang !== currentLang) {
+        console.log("Your programming language has changed elsewhere since you last ran this challenge");
+        const selectedLanguage = await api.findProgrammingLanguage(configLang);
+        await archiveExistingChallengeFiles(config.orgName, challengePosition, { selectedLanguage, challengeDir: currentDir });
+        const updatedConfig = Object.assign({}, config, {
+            programmingLanguage: currentLang,
+        });
+        await saveConfig(updatedConfig);
+    }
+    const showFileDiff = true;
+    const includeTarball = false;
+    await downloadChallengeFilesTo(codingContext, currentDir, api, applicantExam.id, challengeResult.id, showFileDiff, includeTarball);
+}

package/esm/src/action/remove.d.ts

@@ -0,0 +1,4 @@
+export interface RemoveOptions {
+    recursive?: boolean;
+}
+export declare function remove(filePaths: string[], options?: RemoveOptions): Promise<void>;

package/esm/src/action/remove.js

@@ -0,0 +1,67 @@
+import * as dntShim from "../../_dnt.shims.js";
+import { DeleteFilesNotAllowed, OtherError } from "../shared/errors.js";
+import { isEmptyDirectory, pathsToFilenameSet, toNativeStyle, } from "../shared/file.js";
+import { getCommonChallengeContext, listFileNames, printWorkingFileSet, } from "../shared/mod.js";
+import { FileListType } from "../track/types.js";
+import * as colors from "../../deps/deno.land/std@0.195.0/fmt/colors.js";
+export async function remove(filePaths, options) {
+    const trackContext = await getCommonChallengeContext();
+    const { config, api, codingContext } = trackContext;
+    if (!codingContext.settings.allowNewFile) {
+        throw new DeleteFilesNotAllowed();
+    }
+    const requestedPathsToDelete = await pathsToFilenameSet(filePaths, {
+        recursive: options?.recursive,
+        allowNonExistent: false,
+    });
+    const filesToDelete = [];
+    const filesToKeep = [];
+    for (const path of listFileNames(codingContext, FileListType.UserAddedFiles)) {
+        if (requestedPathsToDelete.has(path)) {
+            filesToDelete.push(path);
+        }
+        else {
+            filesToKeep.push(path);
+        }
+    }
+    if (filesToDelete.length > 0) {
+        console.log(colors.green("Deleting:"));
+        for (const file of filesToDelete) {
+            console.log(`\t${toNativeStyle(file)}`);
+        }
+        console.log();
+        const saveFilesRequest = {
+            versionId: codingContext.challengeVersionId,
+            addedFiles: filesToKeep,
+            updatedFiles: {},
+        };
+        await api.saveFiles(config.applicantExamId, config.challengeResultId, saveFilesRequest);
+        await Promise.all(filesToDelete.map((file) => dntShim.Deno.remove(file)))
+            .catch((e) => Promise.reject(new OtherError(`An error occurred while deleting files: ${e}`)));
+        // For each file to delete, walk the file's parents and delete directories
+        // if they are empty, stopping at the first non-empty one.
+        for (const file of filesToDelete) {
+            let current = file;
+            const re = /\/[^/]+$/;
+            while (true) {
+                const parent = current.replace(re, "");
+                if (parent === current || parent === "." || parent === "/" ||
+                    parent === "") {
+                    break;
+                }
+                if (await isEmptyDirectory(parent)) {
+                    await dntShim.Deno.remove(parent);
+                }
+                current = parent;
+            }
+        }
+        const newCodingContext = await api.getChallengeCodingContext(config.applicantExamId, config.challengeResultId);
+        printWorkingFileSet(newCodingContext);
+    }
+    else {
+        console.log("No files to delete.");
+        console.log(colors.red("Use --recursive or -r to delete directories"));
+        console.log();
+        printWorkingFileSet(codingContext);
+    }
+}

package/esm/src/action/reset.d.ts

@@ -0,0 +1 @@
+export declare function reset(): Promise<void>;

package/esm/src/action/reset.js

@@ -0,0 +1,21 @@
+import * as dntShim from "../../_dnt.shims.js";
+import { archiveExistingChallengeFiles, downloadChallengeFilesTo, getCommonChallengeContext, } from "../shared/mod.js";
+export async function reset() {
+    const trackContext = await getCommonChallengeContext();
+    const { config, api, codingContext, applicantExam, challengeResult, challengePosition, } = trackContext;
+    console.log("Your existing code will be archived in this directory and the original challenge code will be downloaded");
+    const shouldContinue = dntShim.confirm("Are you sure you want to reset this challenge?");
+    if (!shouldContinue) {
+        return;
+    }
+    const currentDir = dntShim.Deno.cwd();
+    const selectedLanguage = codingContext.selectedLanguage
+        ? await api.findProgrammingLanguage(codingContext.selectedLanguage)
+        : undefined;
+    await archiveExistingChallengeFiles(config.orgName, challengePosition, { selectedLanguage, challengeDir: currentDir });
+    await api.reset(config.applicantExamId, config.challengeResultId);
+    const newCodingContext = await api.getChallengeCodingContext(config.applicantExamId, config.challengeResultId);
+    const showFileDiff = false;
+    const includeTarball = true;
+    await downloadChallengeFilesTo(newCodingContext, currentDir, api, applicantExam.id, challengeResult.id, showFileDiff, includeTarball);
+}

package/esm/src/action/run.d.ts

@@ -0,0 +1,4 @@
+export interface RunOptions {
+    noSave?: boolean;
+}
+export declare function run(options?: RunOptions): Promise<void>;

package/esm/src/action/run.js

@@ -0,0 +1,163 @@
+import * as dntShim from "../../_dnt.shims.js";
+import { webUrl } from "../shared/config.js";
+import { CantReadFile } from "../shared/errors.js";
+import { getCommonChallengeContext, listFileNames, printTimeLeft, } from "../shared/mod.js";
+import { EnvSettings, FileListType, } from "../track/types.js";
+import { OrcaClient } from "../orca/client.js";
+import { FileType } from "../orca/types.js";
+import * as colors from "../../deps/deno.land/std@0.195.0/fmt/colors.js";
+export async function run(options) {
+    const trackContext = await getCommonChallengeContext();
+    const api = trackContext.api;
+    const config = trackContext.config;
+    const codingContext = trackContext.codingContext;
+    // const orcaHost = Deno.env.get("ORCA_HOST") || "track-prod-frontend.orca.run";
+    // Temporary code to retrieve the Orca host. Will be able to get from CodingContext in the future.
+    const orcaHost = await api.orcaHost();
+    const token = await api.orcaToken(codingContext.urlForOrcaToken);
+    const orca = new OrcaClient(orcaHost, token);
+    await orca.connect();
+    const envConfig = codingContext.answers.envConfig || EnvSettings.default;
+    await orca.prepare({
+        imageName: envConfig.imageName,
+        interactive: false,
+        cacheDirs: envConfig.cacheDirs,
+        username: envConfig.username,
+        baseDir: envConfig.baseDir,
+    });
+    const envVars = Object.assign({}, envConfig.variables);
+    envVars["CHALLENGE_LANGUAGE"] = codingContext.challengeLanguage;
+    if (codingContext.answers.appCommand) {
+        envVars["APP_COMMAND"] = codingContext.answers.appCommand;
+    }
+    await orca.envVars(envVars);
+    const files = Object.entries(await getAllEditableFileContent(codingContext))
+        .map(([name, content]) => ({
+        name,
+        content,
+        type: FileType.UTF8,
+    }));
+    let saveFilesRequest;
+    if (!options?.noSave) {
+        const updatedFiles = await getAllEditableFileContent(codingContext);
+        saveFilesRequest = {
+            versionId: codingContext.challengeVersionId,
+            addedFiles: codingContext.answers.addedFiles || [],
+            updatedFiles: updatedFiles,
+        };
+        console.log("Saving challenge files");
+        await api.saveFiles(config.applicantExamId, config.challengeResultId, saveFilesRequest);
+        console.log(colors.green("Challenge files saved"));
+    }
+    console.log();
+    console.log("Running Tests");
+    console.log("-".repeat(50));
+    console.log();
+    let buildRan = false;
+    const runId = dntShim.crypto.randomUUID();
+    // Run the initialize/build commands if they exist
+    let buildDoneData;
+    if ((codingContext.answers.build?.length || 0) > 0 ||
+        codingContext.settings.initialize.length > 0) {
+        const shellCommand = []
+            .concat(codingContext.settings.initialize)
+            .concat(codingContext.answers.build || [])
+            .filter((s) => s && s.length > 0);
+        const runCmd = {
+            id: `${runId}-build`,
+            imageName: envConfig.imageName,
+            workingDir: envConfig.workingDir ?? "",
+            shellCmd: shellCommand.join(" && "),
+            attachVolume: true,
+            files,
+            envVars: {},
+            tarballUrls: codingContext.tarballUrls,
+        };
+        buildRan = true;
+        buildDoneData = await orca.simpleRunCommand(runCmd);
+    }
+    // Run the actual command
+    if (!buildDoneData || buildDoneData.exitCode === 0) {
+        const runCmd = {
+            id: `${runId}-run`,
+            imageName: envConfig.imageName,
+            workingDir: envConfig.workingDir ?? "",
+            shellCmd: codingContext.settings.test,
+            attachVolume: true,
+            files: buildRan ? [] : files,
+            envVars: {},
+            tarballUrls: buildRan ? [] : codingContext.tarballUrls,
+        };
+        const scoreCounter = new CountPassingLineHandler();
+        const runDoneData = await orca.simpleRunCommand(runCmd, scoreCounter);
+        console.log(`exit_code = ${runDoneData.exitCode}, reason = ${runDoneData.reason}`);
+        console.log();
+        console.log("Test Results");
+        console.log("-".repeat(50));
+        console.log();
+        if (trackContext.challenge.openTestcases) {
+            const totalPassed = scoreCounter.totalPassed();
+            const scoreStr = `${totalPassed}/${trackContext.challenge.openTestcases}`;
+            console.log(`Score: ${colors.green(scoreStr)}`);
+            await api.updateEditorScore(config.applicantExamId, config.challengeResultId, totalPassed);
+        }
+        const timeLeft = await api.timeLeft(config.applicantExamId, config.challengeResultId);
+        printTimeLeft(timeLeft);
+    }
+    else {
+        console.log();
+        console.log(colors.red("Build error!"));
+    }
+    // If we saved the files, print out the files we actually saved
+    // and where the user can find them in the web editor
+    if (saveFilesRequest) {
+        const updatedDisplayFiles = Object.keys(saveFilesRequest.updatedFiles);
+        updatedDisplayFiles.sort();
+        console.log();
+        console.log("Saved:");
+        console.log();
+        for (const file of updatedDisplayFiles) {
+            console.log(colors.green(`\t${file}`));
+        }
+        const url = `${webUrl(config)}/challenges/${config.challengeId}`;
+        console.log();
+        console.log(`Files uploaded successfully to ${url}`);
+    }
+}
+async function getAllEditableFileContent(context) {
+    const result = {};
+    for (const filePath of listFileNames(context, FileListType.Editable)) {
+        try {
+            const fileStr = await dntShim.Deno.readFile(filePath);
+            result[filePath] = new TextDecoder().decode(fileStr);
+        }
+        catch (_e) {
+            throw new CantReadFile(filePath);
+        }
+    }
+    return result;
+}
+class CountPassingLineHandler {
+    constructor() {
+        Object.defineProperty(this, "_totalPassed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "_passPattern", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: /^ok \d+/
+        });
+    }
+    totalPassed() {
+        return this._totalPassed;
+    }
+    handleLine(line) {
+        if (this._passPattern.test(line)) {
+            this._totalPassed += 1;
+        }
+    }
+}

package/esm/src/action/status.d.ts

@@ -0,0 +1 @@
+export declare function status(): Promise<void>;

package/esm/src/action/status.js

@@ -0,0 +1,5 @@
+import { getCommonChallengeContext, printChallengeInfo } from "../shared/mod.js";
+export async function status() {
+    const trackContext = await getCommonChallengeContext();
+    await printChallengeInfo(trackContext);
+}

package/esm/src/main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../_dnt.polyfills.js";

package/esm/src/main.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+import "../_dnt.polyfills.js";
+import * as dntShim from "../_dnt.shims.js";
+import { clone as cloneAction } from "./action/clone.js";
+import { run as runAction } from "./action/run.js";
+import { lang as langAction } from "./action/lang.js";
+import { reset as resetAction } from "./action/reset.js";
+import { pull as pullAction } from "./action/pull.js";
+import { add as addAction } from "./action/add.js";
+import { remove as removeAction } from "./action/remove.js";
+import { status as statusAction } from "./action/status.js";
+import { checkUpdates, DESCRIPTION, VERSION } from "./meta.js";
+import { TrackError } from "./shared/errors.js";
+import { red } from "../deps/deno.land/std@0.195.0/fmt/colors.js";
+import { Command } from "../deps/deno.land/x/cliffy@v0.25.7/command/mod.js";
+(async () => {
+    const cloneCommand = new Command()
+        .description("Clone challenge result from tracks.run")
+        .arguments("<url:string> [target_dir:string]")
+        .option("--basic-auth-user <user:string>", "The basic auth username if this server requires Basic Authentication")
+        .option("--basic-auth-password <password:string>", "The basic auth password if this server requires Basic Authentication (leave blank to type in manually)")
+        .action(async ({ basicAuthUser, basicAuthPassword }, ...[url, targetDir]) => {
+        await cloneAction(url, {
+            targetDir,
+            basicAuthUser,
+            basicAuthPassword,
+        });
+    });
+    const runCommand = new Command()
+        .description("Save and run the challenge on the remote code execution server")
+        .option("--no-save", "If this flag is specified, your files will not be uploaded to track after running the challenge tests")
+        .action(async ({ save }) => {
+        await runAction({ noSave: !save });
+    });
+    const langCommand = new Command()
+        .description("Change the programming language used for this challenge.")
+        .action(async () => {
+        await langAction();
+    });
+    const resetCommand = new Command()
+        .description("Reset the challenge files back to their starting point and archive your current challenge files")
+        .action(async () => {
+        await resetAction();
+    });
+    const pullCommand = new Command()
+        .description("Pull your most recent changes into this directory (caution: overwrites existing files)")
+        .action(async () => {
+        await pullAction();
+    });
+    const addCommand = new Command()
+        .description("Add a file to be included in your challenge submission")
+        .arguments("<file_paths...:string>")
+        .action(async (_, ...filePaths) => {
+        await addAction(filePaths);
+    });
+    const removeCommand = new Command()
+        .description("Remove files from your challenge submission")
+        .arguments("<file_paths...:string>")
+        .option("-r --recursive", "Allow recursive removal when a directory is given")
+        .action(async ({ recursive }, ...filePaths) => {
+        await removeAction(filePaths, { recursive });
+    });
+    const statusCommand = new Command()
+        .description("Display the current status for this challenge")
+        .action(async () => {
+        await statusAction();
+    });
+    if (!await checkUpdates()) {
+        dntShim.Deno.exit(1);
+    }
+    await new Command()
+        .name("track")
+        .description(DESCRIPTION)
+        .version(`v${VERSION}`)
+        .action(function () {
+        this.showHelp();
+    })
+        .command("clone", cloneCommand)
+        .command("run", runCommand)
+        .command("lang", langCommand)
+        .command("reset", resetCommand)
+        .command("pull", pullCommand)
+        .command("add", addCommand)
+        .command("rm", removeCommand)
+        .command("status", statusCommand)
+        .parse(dntShim.Deno.args);
+    dntShim.Deno.exit(0);
+})().catch((err) => {
+    if (err instanceof TrackError) {
+        console.error(`${red("[ERROR]")} ${err.message}`);
+        dntShim.Deno.exit(1);
+    }
+    else {
+        throw err;
+    }
+});

package/esm/src/meta.d.ts

@@ -0,0 +1,3 @@
+export declare const VERSION = "3.0.0-rc1";
+export declare const DESCRIPTION = "A CLI for interacting with tracks.run and running code tests on track's servers";
+export declare function checkUpdates(): Promise<boolean>;

package/esm/src/meta.js

@@ -0,0 +1,51 @@
+import * as colors from "../deps/deno.land/std@0.195.0/fmt/colors.js";
+// @ts-ignore: has no exported member
+import { CookieJar, fetch } from "node-fetch-cookies";
+export const VERSION = "3.0.0-rc1";
+export const DESCRIPTION = "A CLI for interacting with tracks.run and running code tests on track's servers";
+const VERSION_RE = /^(\d+)\.(\d+)\.(\d+)(?:-?(.*))$/;
+function parseSemver(s) {
+    const match = VERSION_RE.exec(s);
+    if (!match) {
+        return;
+    }
+    return [
+        parseInt(match[1]),
+        parseInt(match[2]),
+        parseInt(match[3]),
+        match[4],
+    ];
+}
+export async function checkUpdates() {
+    const res = await fetch(new CookieJar(), "https://track-cli.s3-ap-northeast-1.amazonaws.com/version.json");
+    const publishedVersion = await res.json();
+    const supportedFrom = parseSemver(publishedVersion.supported_from) ??
+        [1, 0, 0, ""];
+    const latest = parseSemver(publishedVersion.latest) ?? [1, 0, 0, ""];
+    const current = parseSemver(VERSION);
+    // deno-fmt-ignore
+    if (parseSemver(VERSION) < supportedFrom) {
+        console.log("╭─────────────────────────────────────────────────────────────────────────────────────────────╮");
+        console.log("|                                                                                             |");
+        console.log(`|                                      ${colors.bold(colors.red("!!! OUTDATED !!!"))}                                       |`);
+        console.log("|                       This version of Track CLI is no more supported.                       |");
+        console.log(`|                                  Current version: ${VERSION.padEnd(20)}                      |`);
+        console.log(`|                                  Latest version:  ${publishedVersion.latest.padEnd(20)}                      |`);
+        console.log("|                                                                                             |");
+        console.log("╰─────────────────────────────────────────────────────────────────────────────────────────────╯");
+        return false;
+    }
+    else if (current < latest) {
+        console.log("╭─────────────────────────────────────────────────────────────────────────────────────────────╮");
+        console.log("|                                                                                             |");
+        console.log("|                           New version of Track CLI is available!                            |");
+        console.log(`|                                  Current version: ${VERSION.padEnd(20)}                      |`);
+        console.log(`|                                  Latest version:  ${publishedVersion.latest.padEnd(20)}                      |`);
+        console.log("|                                                                                             |");
+        console.log("╰─────────────────────────────────────────────────────────────────────────────────────────────╯");
+        return true;
+    }
+    else {
+        return true;
+    }
+}

package/esm/src/orca/client.d.ts

@@ -0,0 +1,20 @@
+import { CommandDoneData, LineHandler, PrepareCommand, SimpleRunCommand } from "./types.js";
+export declare class OrcaClient {
+    private hostname;
+    private token?;
+    private socket?;
+    private eventEmitter;
+    constructor(hostname: string, token?: string | undefined);
+    connect(): Promise<void>;
+    private handleMessage;
+    private handleStdOut;
+    private handleStdErr;
+    private handleCommandDone;
+    private printCommandResultWithColor;
+    on(eventName: string, func: (...args: unknown[]) => void): void;
+    off(eventName: string, func: (...args: unknown[]) => void): void;
+    private send;
+    prepare(request: PrepareCommand): Promise<void>;
+    envVars(envVars: Record<string, string>): Promise<void>;
+    simpleRunCommand(request: SimpleRunCommand, lineHandler?: LineHandler): Promise<CommandDoneData>;
+}

package/esm/src/orca/client.js

@@ -0,0 +1,152 @@
+import * as dntShim from "../../_dnt.shims.js";
+import { OtherError } from "../shared/errors.js";
+import { SnakeCase } from "../shared/mod.js";
+import { green, red } from "../../deps/deno.land/std@0.195.0/fmt/colors.js";
+import { EventEmitter } from "eventemitter3";
+import ProxyAgent from "proxy-agent";
+import WebSocket from "ws";
+const RE_TAP_OK = new RegExp("^ok \\d+ ");
+const RE_TAP_NG = new RegExp("^not ok \\d+ ");
+export class OrcaClient {
+    constructor(hostname, token) {
+        Object.defineProperty(this, "hostname", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: hostname
+        });
+        Object.defineProperty(this, "token", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: token
+        });
+        Object.defineProperty(this, "socket", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "eventEmitter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new EventEmitter()
+        });
+    }
+    connect() {
+        return new Promise((res, _rej) => {
+            const scheme = this.hostname.startsWith("localhost") ? "ws://" : "wss://";
+            const query = this.token ? `?token=${this.token}` : "";
+            const url = `${scheme}${this.hostname}/socket${query}`;
+            const options = { agent: new ProxyAgent() };
+            const socket = new WebSocket(url, options);
+            socket.onmessage = this.handleMessage.bind(this);
+            socket.onopen = () => {
+                console.log("WebSocket connection established");
+                res();
+                this.eventEmitter.emit("connect", url);
+            };
+            socket.onclose = (event) => {
+                console.log(event);
+                console.log(`WebSocket connection closed with code: ${event.code}`);
+                this.eventEmitter.emit("disconnect", event.code);
+            };
+            this.socket = socket;
+        });
+    }
+    handleMessage(event) {
+        if (typeof event.data !== "string")
+            return;
+        const message = JSON.parse(event.data);
+        const data = SnakeCase.from(message.data);
+        switch (message.e) {
+            case "stdout":
+                this.handleStdOut(data);
+                break;
+            case "stderr":
+                this.handleStdErr(data);
+                break;
+            case "cmd_done":
+                this.handleCommandDone(data);
+                break;
+            default:
+                break;
+        }
+        this.eventEmitter.emit(message.e, data);
+    }
+    handleStdOut(data) {
+        this.printCommandResultWithColor(data.l);
+    }
+    handleStdErr(data) {
+        console.log(data.l);
+    }
+    handleCommandDone(data) {
+        const reason = data.reason ? `: ${data.reason}` : "";
+        console.log(`Command ${data.id} done with exit code ${data.exitCode}${reason}`);
+    }
+    printCommandResultWithColor(s) {
+        const lines = s.split("\n");
+        const encoder = new TextEncoder();
+        function print(s, isLast = false) {
+            if (isLast) {
+                dntShim.Deno.stdout.write(encoder.encode(s));
+            }
+            else {
+                dntShim.Deno.stdout.write(encoder.encode(s + "\n"));
+            }
+        }
+        lines.forEach((line, i) => {
+            const isLast = i === lines.length - 1;
+            if (RE_TAP_OK.test(line)) {
+                print(green(line), isLast);
+            }
+            else if (RE_TAP_NG.test(line)) {
+                print(red(line), isLast);
+            }
+            else {
+                print(line, isLast);
+            }
+        });
+    }
+    on(eventName, func) {
+        this.eventEmitter.on(eventName, func);
+    }
+    off(eventName, func) {
+        this.eventEmitter.off(eventName, func);
+    }
+    send(commandName, eventName, data, toSnakeCase = true) {
+        return new Promise((res, rej) => {
+            this.eventEmitter.once(eventName, (e) => {
+                res(SnakeCase.from(e));
+            });
+            try {
+                const d = toSnakeCase ? SnakeCase.to(data) : data;
+                this.socket?.send(JSON.stringify({
+                    e: commandName,
+                    data: d,
+                }));
+            }
+            catch (e) {
+                rej(new OtherError(e.message));
+            }
+        });
+    }
+    prepare(request) {
+        return this.send("prepare", "prepare_done", request);
+    }
+    envVars(envVars) {
+        return this.send("env_vars", "env_vars_done", { env_vars: envVars }, false);
+    }
+    async simpleRunCommand(request, lineHandler) {
+        const handler = lineHandler?.handleLine
+            ? function (e) {
+                e.l.split("\n").forEach((line) => lineHandler.handleLine(line));
+            }
+            : (() => { });
+        this.on("stdout", handler);
+        const result = await this.send("simple_run", "cmd_done", request);
+        this.off("stdout", handler);
+        return result;
+    }
+}