track-cli 3.0.0-rc

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

@@ -0,0 +1,54 @@
+export declare const FileType: {
+    readonly UTF8: "utf8";
+    readonly URL: "url";
+    readonly Base64: "base64";
+};
+export type FileType = (typeof FileType)[keyof typeof FileType];
+export type CodeFile = {
+    name: string;
+    content: string;
+    type: FileType;
+};
+export type PrepareCommand = {
+    imageName: string;
+    interactive: boolean;
+    cacheDirs: string[];
+    username?: string;
+    baseDir?: string;
+};
+export type SimpleRunCommand = {
+    id: string;
+    imageName: string;
+    workingDir: string;
+    shellCmd: string;
+    attachVolume: boolean;
+    files: CodeFile[];
+    envVars: Record<string, string>;
+    tarballUrls: string[];
+};
+export type EnvVarsCommand = {
+    envVars: Record<string, string>;
+};
+export type StdOutData = {
+    id: string;
+    l: string;
+};
+export type StdErrData = {
+    id: string;
+    l: string;
+};
+export type CommandDoneData = {
+    id: string;
+    reason: string;
+    exitCode: number;
+};
+type Msg<E extends string, D> = {
+    e: E;
+    data: D;
+};
+export type OrcaMsg = Msg<"prepare", PrepareCommand> | Msg<"simple_run", SimpleRunCommand> | Msg<"env_vars", EnvVarsCommand> | Msg<"env_vars_done", void> | Msg<"stdout", StdOutData> | Msg<"stderr", StdErrData> | Msg<"cmd_done", CommandDoneData>;
+export type LineHandler = {
+    handleLine(line: string): void;
+};
+export declare function convertToCodeFile(fileName: string, fileContent: string): CodeFile;
+export {};

package/esm/src/orca/types.js

@@ -0,0 +1,12 @@
+export const FileType = {
+    UTF8: "utf8",
+    URL: "url",
+    Base64: "base64",
+};
+export function convertToCodeFile(fileName, fileContent) {
+    return {
+        name: fileName,
+        content: fileContent,
+        type: FileType.UTF8,
+    };
+}

package/esm/src/shared/config.d.ts

@@ -0,0 +1,24 @@
+import { BasicAuth } from "../track/client.js";
+import { ProgrammingLanguage } from "../track/types.js";
+export declare const CONFIG_FILE_PATH = ".track/config.json";
+export interface TrackConfig {
+    scheme: string;
+    host: string;
+    orgName: string;
+    basicAuth?: BasicAuth;
+    examToken: string;
+    applicantExamId: number;
+    challengeId: number;
+    challengeResultId: number;
+    cookies: Record<string, string>;
+    programmingLanguage?: ProgrammingLanguage;
+}
+export type SaveConfigOptions = {
+    path?: string;
+};
+export declare function save(config: TrackConfig, options?: SaveConfigOptions): Promise<void>;
+export type LoadConfigOptions = {
+    path?: string;
+};
+export declare function load(options?: LoadConfigOptions): Promise<TrackConfig>;
+export declare function webUrl(config: TrackConfig): string;

package/esm/src/shared/config.js

@@ -0,0 +1,24 @@
+import * as dntShim from "../../_dnt.shims.js";
+import { MissingConfigFile } from "./errors.js";
+import { ensureFile } from "../../deps/deno.land/std@0.195.0/fs/ensure_file.js";
+export const CONFIG_FILE_PATH = ".track/config.json";
+export async function save(config, options) {
+    const jsonStr = JSON.stringify(config, null, 2);
+    const configFilePath = options?.path ?? CONFIG_FILE_PATH;
+    await ensureFile(configFilePath);
+    await dntShim.Deno.writeFile(configFilePath, new TextEncoder().encode(jsonStr));
+}
+export async function load(options) {
+    let data;
+    try {
+        data = await dntShim.Deno.readFile(options?.path ?? CONFIG_FILE_PATH);
+    }
+    catch (_e) {
+        throw new MissingConfigFile();
+    }
+    const configStr = new TextDecoder().decode(data);
+    return JSON.parse(configStr);
+}
+export function webUrl(config) {
+    return `${config.scheme}://${config.host}/${config.orgName}/exams/${config.examToken}`;
+}

package/esm/src/shared/errors.d.ts

@@ -0,0 +1,82 @@
+/// <reference types="node" />
+import * as dntShim from "../../_dnt.shims.js";
+export declare class TrackError extends Error {
+    constructor(message: string);
+}
+export declare class APIError extends TrackError {
+    constructor(message: string);
+    static fromResponse(res: dntShim.Response): Promise<APIError>;
+    static serializationError(body: string): APIError;
+}
+export declare class IOError extends TrackError {
+    error: Error | string;
+    constructor(error: Error | string);
+}
+export declare class JSONError extends TrackError {
+    error: Error;
+    constructor(error: Error);
+}
+export declare class WebsocketError extends TrackError {
+    error: Error | Event;
+    constructor(error: Error | Event);
+}
+export declare class ChallengeDirectoryExists extends TrackError {
+    path: string;
+    constructor(path: string);
+}
+export declare class ExamUnread extends TrackError {
+    webUrl: string;
+    constructor(webUrl: string);
+}
+export declare class ExamExpired extends TrackError {
+    constructor();
+}
+export declare class ExamCanceled extends TrackError {
+    constructor();
+}
+export declare class ExamSubmitted extends TrackError {
+    constructor();
+}
+export declare class MissingConfigFile extends TrackError {
+    constructor();
+}
+export declare class ChallengeAlreadyFinished extends TrackError {
+    constructor();
+}
+export declare class InvalidChallengeId extends TrackError {
+    challengeId: number;
+    constructor(challengeId: number);
+}
+export declare class CantChooseLanguage extends TrackError {
+    constructor();
+}
+export declare class NotASingleResponse extends TrackError {
+    constructor();
+}
+export declare class BadTarballURL extends TrackError {
+    url: string;
+    reason: string;
+    constructor(url: string, reason: string);
+}
+export declare class CantReadFile extends TrackError {
+    fileName: string;
+    constructor(fileName: string);
+}
+export declare class FileMissingOrOutsideDirectory extends TrackError {
+    fileName: string;
+    constructor(fileName: string);
+}
+export declare class NewFilesNotAllowed extends TrackError {
+    constructor();
+}
+export declare class DeleteFilesNotAllowed extends TrackError {
+    constructor();
+}
+export declare class LocalExamNotAllowed extends TrackError {
+    url: string;
+    constructor(url: string);
+}
+export declare class OtherError extends TrackError {
+    message: string;
+    constructor(message: string);
+}

package/esm/src/shared/errors.js

@@ -0,0 +1,228 @@
+import { HttpStatus } from "./mod.js";
+export class TrackError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "TrackError";
+    }
+}
+export class APIError extends TrackError {
+    constructor(message) {
+        super(message);
+        this.name = "APIError";
+    }
+    static async fromResponse(res) {
+        const body = await res.text();
+        if (HttpStatus.isClientError(res)) {
+            return new APIError(`A client error occurred (${res.status}): ${body}`);
+        }
+        else if (HttpStatus.isServerError(res)) {
+            return new APIError(`A server error occurred (${res.status}): ${body}`);
+        }
+        else {
+            return new APIError(`An unknown error occurred (${res.status}): ${body}`);
+        }
+    }
+    static serializationError(body) {
+        return new APIError(`A serialization error occurred: ${body}`);
+    }
+}
+export class IOError extends TrackError {
+    constructor(error) {
+        super(`An unexpected IO error occurred: ${error}`);
+        Object.defineProperty(this, "error", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: error
+        });
+        this.name = "IOError";
+    }
+}
+export class JSONError extends TrackError {
+    constructor(error) {
+        super(`Error with JSON (de)serialization: ${error}`);
+        Object.defineProperty(this, "error", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: error
+        });
+        this.name = "JSONError";
+    }
+}
+export class WebsocketError extends TrackError {
+    constructor(error) {
+        super(`Websocket Error: ${error}`);
+        Object.defineProperty(this, "error", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: error
+        });
+        this.name = "WebsocketError";
+    }
+}
+export class ChallengeDirectoryExists extends TrackError {
+    constructor(path) {
+        super(`The destination path '${path}' already exists and is not an empty directory`);
+        Object.defineProperty(this, "path", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: path
+        });
+        this.name = "ChallengeDirectoryExists";
+    }
+}
+export class ExamUnread extends TrackError {
+    constructor(webUrl) {
+        super(`This exam has not started yet, please start it in your browser at: ${webUrl}`);
+        Object.defineProperty(this, "webUrl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: webUrl
+        });
+        this.name = "ExamUnread";
+    }
+}
+export class ExamExpired extends TrackError {
+    constructor() {
+        super("This exam is no longer available because the deadline has expired");
+        this.name = "ExamExpired";
+    }
+}
+export class ExamCanceled extends TrackError {
+    constructor() {
+        super("This exam has been canceled");
+        this.name = "ExamCanceled";
+    }
+}
+export class ExamSubmitted extends TrackError {
+    constructor() {
+        super("This exam has already been submitted");
+        this.name = "ExamSubmitted";
+    }
+}
+export class MissingConfigFile extends TrackError {
+    constructor() {
+        super("Could not load track config file - are you in a track challenge directory?");
+        this.name = "MissingConfigFile";
+    }
+}
+export class ChallengeAlreadyFinished extends TrackError {
+    constructor() {
+        super("This challenge has already been finished");
+        this.name = "ChallengeAlreadyFinished";
+    }
+}
+export class InvalidChallengeId extends TrackError {
+    constructor(challengeId) {
+        super(`The challenge id specified in your URL (${challengeId}), is invalid`);
+        Object.defineProperty(this, "challengeId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: challengeId
+        });
+        this.name = "InvalidChallengeId";
+    }
+}
+export class CantChooseLanguage extends TrackError {
+    constructor() {
+        super("This challenge does not support changing programming languages");
+        this.name = "CantChooseLanguage";
+    }
+}
+export class NotASingleResponse extends TrackError {
+    constructor() {
+        super("Tried to extract a single result from an API response with no result");
+        this.name = "NotASingleResponse";
+    }
+}
+export class BadTarballURL extends TrackError {
+    constructor(url, reason) {
+        super(`The challenge tarball URL did not return a 200 response.\n\nReason = ${reason}\n\nURL = ${url}\n\nPlease try the command again`);
+        Object.defineProperty(this, "url", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: url
+        });
+        Object.defineProperty(this, "reason", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: reason
+        });
+        this.name = "BadTarballURL";
+    }
+}
+// export class CantOpenFile extends TrackError {
+//   constructor(public fileName: string) {
+//     super(
+//       `Could not open file - ${fileName}\n\nIf you changed your submission in the web editor, try running \`track pull\` to pull your latest changes.`,
+//     );
+//     this.name = "CantOpenFile";
+//   }
+// }
+export class CantReadFile extends TrackError {
+    constructor(fileName) {
+        super(`Could not read file - ${fileName} - Please make sure it is saved with a UTF-8 encoding.`);
+        Object.defineProperty(this, "fileName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: fileName
+        });
+        this.name = "CantReadFile";
+    }
+}
+export class FileMissingOrOutsideDirectory extends TrackError {
+    constructor(fileName) {
+        super(`File missing or located outside of the challenge directory - ${fileName}`);
+        Object.defineProperty(this, "fileName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: fileName
+        });
+        this.name = "FileMissingOrOutsideDirectory";
+    }
+}
+export class NewFilesNotAllowed extends TrackError {
+    constructor() {
+        super("This challenge does not allow the addition of new files");
+        this.name = "NewFilesNotAllowed";
+    }
+}
+export class DeleteFilesNotAllowed extends TrackError {
+    constructor() {
+        super("This challenge does not allow the deletion of files");
+        this.name = "DeleteFilesNotAllowed";
+    }
+}
+export class LocalExamNotAllowed extends TrackError {
+    constructor(url) {
+        super(`You are not allowed to take this challenge in your local CLI.\nPlease continue your exam on tracks.run:\n\n${url}`);
+        Object.defineProperty(this, "url", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: url
+        });
+        this.name = "LocalExamNotAllowed";
+    }
+}
+export class OtherError extends TrackError {
+    constructor(message) {
+        super(message);
+        Object.defineProperty(this, "message", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: message
+        });
+        this.name = "OtherError";
+    }
+}

package/esm/src/shared/file.d.ts

@@ -0,0 +1,30 @@
+import * as dntShim from "../../_dnt.shims.js";
+export declare const _internals: {
+    SEP: string;
+};
+export type PathsToFilenameSetOptions = {
+    recursive?: boolean;
+    allowNonExistent?: boolean;
+    root?: string;
+};
+/**
+ * Given a user-supplied Vec of file paths, this function will
+ * iterate over each one, optionally verify it exists, and optionally recursively
+ * add files in subdirectories if the supplied path is a directory
+ * It will also transform the path to be relative to the working directory
+ */
+export declare function pathsToFilenameSet(paths: string[], options?: PathsToFilenameSetOptions): Promise<Set<string>>;
+export declare function stat(p: string): Promise<dntShim.Deno.FileInfo | null>;
+export declare function isEmptyDirectory(p: string): Promise<boolean>;
+/**
+ * Given a path, will return an array with all files and sub-files recursively.
+ * If the given path is a file, just a Vec with the file will be returned.
+ */
+export declare function getAllDirFiles(p: string): Promise<string[]>;
+export declare function toNixStyle(p: string): string;
+export declare function toNativeStyle(p: string): string;
+export declare function untgz(compressed: Uint8Array, dest: string): Promise<void>;
+export type GetUniqueDirNameOptions = {
+    root?: string;
+};
+export declare function getUniqueDirName(base: string, options?: GetUniqueDirNameOptions): Promise<string>;

package/esm/src/shared/file.js

@@ -0,0 +1,110 @@
+import * as dntShim from "../../_dnt.shims.js";
+import * as path from "../../deps/deno.land/std@0.195.0/path/mod.js";
+import { Foras, gunzip } from "@hazae41/foras";
+import tar from "tar";
+import * as fs from "../../deps/deno.land/std@0.195.0/fs/mod.js";
+export const _internals = {
+    SEP: path.SEP,
+};
+/**
+ * Given a user-supplied Vec of file paths, this function will
+ * iterate over each one, optionally verify it exists, and optionally recursively
+ * add files in subdirectories if the supplied path is a directory
+ * It will also transform the path to be relative to the working directory
+ */
+export async function pathsToFilenameSet(paths, options) {
+    const files = [];
+    const root = options?.root ?? dntShim.Deno.cwd();
+    for (const p of paths.map((p) => `${root}/${p}`)) {
+        const f = await stat(p);
+        const rp = toNixStyle(path.relative(root, p));
+        if (options?.recursive && f) {
+            const dirFiles = await getAllDirFiles(p);
+            dirFiles.forEach((file) => files.push(toNixStyle(path.relative(root, file))));
+        }
+        else if (f?.isFile) {
+            files.push(rp);
+        }
+        else if (options?.allowNonExistent) {
+            files.push(toNixStyle(path.relative(root, p)));
+        }
+    }
+    return new Set(files);
+}
+export async function stat(p) {
+    try {
+        return await dntShim.Deno.stat(p);
+    }
+    catch (_e) {
+        return null;
+    }
+}
+export async function isEmptyDirectory(p) {
+    const f = await stat(p);
+    if (!f) {
+        return false;
+    }
+    else if (!f.isDirectory) {
+        return false;
+    }
+    else {
+        for await (const _dirEntry of dntShim.Deno.readDir(p)) {
+            return false;
+        }
+        return true;
+    }
+}
+/**
+ * Given a path, will return an array with all files and sub-files recursively.
+ * If the given path is a file, just a Vec with the file will be returned.
+ */
+export async function getAllDirFiles(p) {
+    const allPaths = [];
+    async function addFilesRecursive(p) {
+        const f = await stat(p);
+        if (!f) {
+            return [];
+        }
+        if (f.isDirectory) {
+            for await (const dirEntry of dntShim.Deno.readDir(p)) {
+                await addFilesRecursive(`${p}/${dirEntry.name}`);
+            }
+        }
+        else {
+            allPaths.push(p);
+        }
+        return allPaths;
+    }
+    await addFilesRecursive(p);
+    return allPaths;
+}
+export function toNixStyle(p) {
+    return p.replaceAll(/[\\\/]/g, "/");
+}
+export function toNativeStyle(p) {
+    return p.replaceAll(/[\\\/]/g, _internals.SEP);
+}
+export async function untgz(compressed, dest) {
+    Foras.initSyncBundledOnce();
+    const decompressed = gunzip(compressed);
+    const tmpTarFile = await dntShim.Deno.makeTempFile();
+    await dntShim.Deno.writeFile(tmpTarFile, decompressed);
+    await tar.x({
+        file: tmpTarFile,
+        cwd: dest,
+    });
+}
+export async function getUniqueDirName(base, options) {
+    let counter = 1;
+    const root = options?.root ?? dntShim.Deno.cwd();
+    let uniqueDirName;
+    while (true) {
+        uniqueDirName = `${base}_${counter}`;
+        if (await fs.exists(`${root}/${uniqueDirName}`)) {
+            counter++;
+        }
+        else {
+            return uniqueDirName;
+        }
+    }
+}

package/esm/src/shared/mod.d.ts

@@ -0,0 +1,40 @@
+import * as dntShim from "../../_dnt.shims.js";
+import { TrackCLIContext } from "./types.js";
+import { TrackClient } from "../track/client.js";
+import { ApplicantExamForNoAuth, ChallengeResult, ChallengeSettings, CodingContext, ExamSession, ExamSessionChallenge, FileListType, ProgrammingLanguageInfo } from "../track/types.js";
+import { CodingAnswers } from "../track/types.js";
+export declare const _internals: {
+    prompt: (message?: string | undefined, _default?: string | undefined) => string | null;
+};
+export declare const HttpStatus: {
+    readonly OK: 200;
+    readonly Unauthorized: 401;
+    readonly isSuccess: (r: number | dntShim.Response) => boolean;
+    readonly isClientError: (r: number | dntShim.Response) => boolean;
+    readonly isServerError: (r: number | dntShim.Response) => boolean;
+};
+export declare const Prompt: {
+    select(message: string, items: string[]): number | undefined;
+};
+export declare function printTimeLeft(timeLeftSeconds: number): void;
+export declare function ensureExamInProgress(applicantExam: ApplicantExamForNoAuth, webUrlRedirect: string): void;
+export declare function getChallengeFromExamSession(examSession: ExamSession, challengeId: number): ExamSessionChallenge | undefined;
+export declare function tryStartingChallenge(challenge: ExamSessionChallenge, api: TrackClient, applicantExam: ApplicantExamForNoAuth, resultOpt?: ChallengeResult): Promise<ChallengeResult | undefined>;
+export declare function chooseProgrammingLanguage(languages: ProgrammingLanguageInfo[]): ProgrammingLanguageInfo;
+export declare function listFileNames(context: {
+    settings: ChallengeSettings;
+    answers: CodingAnswers;
+}, fileListType: FileListType): string[];
+export declare const SnakeCase: {
+    to<T>(obj: T): T;
+    from<T_1>(obj: T_1): T_1;
+};
+export declare function getCommonChallengeContext(): Promise<TrackCLIContext>;
+export declare function printChallengeInfo(trackContext: TrackCLIContext): Promise<void>;
+export declare function printWorkingFileSet(codingContext: CodingContext): void;
+export declare function downloadChallengeFilesTo(codingContext: CodingContext, dest: string, api: TrackClient, applicantExamId: number, challengeResultId: number, showFileDiff: boolean, includeTarball: boolean): Promise<void>;
+export type ArchiveExistingChallengeFilesOptions = {
+    challengeDir?: string;
+    selectedLanguage?: ProgrammingLanguageInfo;
+};
+export declare function archiveExistingChallengeFiles(orgName: string, challengePosition: number, options?: ArchiveExistingChallengeFilesOptions): Promise<void>;