track-cli 3.0.0-rc

package/esm/src/track/client.js

@@ -0,0 +1,268 @@
+import { VERSION } from "../meta.js";
+import { HttpStatus } from "../shared/mod.js";
+import { APIError, OtherError } from "../shared/errors.js";
+// @ts-ignore: has no exported member
+import { CookieJar, fetch } from "node-fetch-cookies";
+import ProxyAgent from "proxy-agent";
+export const FormType = {
+    URLEncoded: "urlencoded",
+    JSON: "json",
+};
+export class TrackClient {
+    constructor(scheme, hostname, basic, authData) {
+        Object.defineProperty(this, "baseUrl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "headers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cookies", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "authData", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cookieExpired", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "agent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new ProxyAgent()
+        });
+        this.baseUrl = `${scheme}://${hostname}`;
+        this.headers = {};
+        this.headers["X-Requested-With"] = "codecheck";
+        this.headers["User-Agent"] = `track-cli-${VERSION}`;
+        if (basic) {
+            this.headers["Authorization"] = `Basic ${btoa(`${basic.username}:${basic.password}`)}`;
+        }
+        this.cookies = new CookieJar();
+        this.authData = authData;
+    }
+    getCookies() {
+        const cookies = {};
+        for (const cookie of this.cookies.cookiesAll()) {
+            if (cookie.name && cookie.value) {
+                cookies[cookie.name] = cookie.value;
+            }
+        }
+        return cookies;
+    }
+    authCookieExpired() {
+        return this.cookieExpired;
+    }
+    static fromTrackConfig(config) {
+        const authData = {
+            examToken: config.examToken,
+            orgName: config.orgName,
+        };
+        const client = new TrackClient(config.scheme, config.host, config.basicAuth, authData);
+        if (config.cookies) {
+            for (const [name, value] of Object.entries(config.cookies)) {
+                client.cookies.addCookie(`${name}=${value}`, client.baseUrl);
+            }
+        }
+        return client;
+    }
+    async authenticate() {
+        this.cookies = new CookieJar();
+        if (this.authData) {
+            const authUrl = `${this.baseUrl}/${this.authData.orgName}/exams/${this.authData.examToken}`;
+            const res = await fetch(this.cookies, authUrl, {
+                headers: this.headers,
+                agent: this.agent,
+            });
+            if (!HttpStatus.isSuccess(res)) {
+                throw new OtherError(`Failed to authenticate: ${res.status}\n${await res.text()}`);
+            }
+        }
+    }
+    async _get(path, asText = false) {
+        const url = `${this.baseUrl}${path}`;
+        const response1 = await fetch(this.cookies, url, {
+            method: "GET",
+            headers: this.headers,
+            agent: this.agent,
+        });
+        if (response1.status !== HttpStatus.Unauthorized) {
+            return await this._result(response1, asText);
+        }
+        await this.authenticate();
+        this.cookieExpired = true;
+        const response2 = await fetch(this.cookies, url, {
+            method: "GET",
+            headers: this.headers,
+            agent: this.agent,
+        });
+        return await this._result(response2, asText);
+    }
+    async _post(path, formType, body) {
+        const url = `${this.baseUrl}${path}`;
+        const headers = Object.assign({}, this.headers);
+        let bodyData;
+        switch (formType) {
+            case FormType.URLEncoded:
+                bodyData = new URLSearchParams();
+                for (const [key, value] of Object.entries(body)) {
+                    bodyData.append(key, value);
+                }
+                break;
+            case FormType.JSON:
+                bodyData = JSON.stringify(body);
+                headers["Content-Type"] = "application/json";
+                break;
+        }
+        const response1 = await fetch(this.cookies, url, {
+            method: "POST",
+            headers: headers,
+            body: bodyData,
+            agent: this.agent,
+        });
+        if (response1.status !== HttpStatus.Unauthorized) {
+            return await this._result(response1);
+        }
+        await this.authenticate();
+        this.cookieExpired = true;
+        const response2 = await fetch(this.cookies, url, {
+            method: "POST",
+            headers: headers,
+            body: bodyData,
+            agent: this.agent,
+        });
+        return await this._result(response2);
+    }
+    async _put(path, formType, body) {
+        const url = `${this.baseUrl}${path}`;
+        const headers = Object.assign({}, this.headers);
+        let bodyData;
+        switch (formType) {
+            case FormType.URLEncoded:
+                bodyData = new URLSearchParams();
+                for (const [key, value] of Object.entries(body)) {
+                    bodyData.append(key, value);
+                }
+                break;
+            case FormType.JSON:
+                bodyData = JSON.stringify(body);
+                headers["Content-Type"] = "application/json";
+                break;
+        }
+        const response1 = await fetch(this.cookies, url, {
+            method: "PUT",
+            headers: headers,
+            body: bodyData,
+            agent: this.agent,
+        });
+        if (response1.status !== HttpStatus.Unauthorized) {
+            return await this._result(response1);
+        }
+        await this.authenticate();
+        this.cookieExpired = true;
+        const response2 = await fetch(this.cookies, url, {
+            method: "PUT",
+            headers: headers,
+            body: bodyData,
+            agent: this.agent,
+        });
+        return await this._result(response2);
+    }
+    async _result(response, asText = false) {
+        if (HttpStatus.isSuccess(response)) {
+            if (asText) {
+                return (await response.text());
+            }
+            else {
+                const json = await response.json();
+                if (json.result) {
+                    return json.result;
+                }
+                else {
+                    throw APIError.serializationError(await response.text());
+                }
+            }
+        }
+        else {
+            throw await APIError.fromResponse(response);
+        }
+    }
+    async getApplicantExamNoAuth(token) {
+        return await this._get(`/api/applicants/exams/${token}/min`);
+    }
+    async getExamSession(applicantExamId) {
+        return await this._get(`/api/applicants/exams/${applicantExamId}`);
+    }
+    async getProgrammingLanguages() {
+        return await this._get(`/api/enum/challenges/programminglanguages`);
+    }
+    async findProgrammingLanguage(programmingLanguage) {
+        return (await this.getProgrammingLanguages())
+            .find((pl, _) => pl.value === programmingLanguage);
+    }
+    async switchChallengeLanguage(applicantExamId, resultId, language) {
+        return await this._put(`/api/applicants/exams/${applicantExamId}/results/${resultId}/language`, FormType.URLEncoded, {
+            programmingLanguage: language,
+        });
+    }
+    async startChallenge(applicantExamId, resultId) {
+        return await this._put(`/api/applicants/exams/${applicantExamId}/results/${resultId}/start`, FormType.URLEncoded, {
+            takenBy: 3, // 3 = LocalMachine
+        });
+    }
+    async prepareChallenge(applicantExamId, challengeId) {
+        return await this._post(`/api/applicants/exams/${applicantExamId}/results`, FormType.URLEncoded, {
+            challengeId: challengeId,
+        });
+    }
+    async timeLeft(applicantExamId, resultId) {
+        return await this._get(`/api/applicants/exams/${applicantExamId}/results/${resultId}/timeleft`);
+    }
+    async getChallengeCodingContext(applicantExamId, resultId) {
+        return await this._get(`/api/applicants/exams/${applicantExamId}/results/${resultId}/context`);
+    }
+    async getPresignedUrls(applicantExamId, resultId, files) {
+        return await this._post(`/api/applicants/exams/${applicantExamId}/results/${resultId}/presigned`, FormType.JSON, {
+            files: files,
+        });
+    }
+    async orcaToken(url) {
+        return await this._get(url);
+    }
+    /**
+     * Temporary code to retrieve the Orca host.
+     * Will be able to get from CodingContext in the future.
+     */
+    async orcaHost() {
+        const asText = true;
+        const editorHtml = await this._get("/editor/1.0/coding", asText);
+        return (/data-orca-host="([^"]+)"/.exec(editorHtml) ||
+            ["", "track-prod-frontend.orca.run"])[1];
+    }
+    async saveFiles(applicantExamId, resultId, saveFilesRequest) {
+        return await this._put(`/api/applicants/exams/${applicantExamId}/results/${resultId}/save`, FormType.JSON, saveFilesRequest);
+    }
+    async updateEditorScore(applicantExamId, resultId, editorScore) {
+        return await this._put(`/api/applicants/exams/${applicantExamId}/results/${resultId}/editorScore`, FormType.URLEncoded, {
+            editorScore: editorScore,
+        });
+    }
+    async reset(applicantExamId, resultId) {
+        return await this._put(`/api/applicants/exams/${applicantExamId}/results/${resultId}/reset`, FormType.URLEncoded, {});
+    }
+}

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

@@ -0,0 +1,210 @@
+export declare const ApplicantExamStatus: {
+    readonly Unread: 1;
+    readonly InProgress: 2;
+    readonly Submitted: 3;
+    readonly Expired: 4;
+    readonly Canceled: 5;
+    readonly Reviewed: 6;
+};
+export type ApplicantExamStatus = (typeof ApplicantExamStatus)[keyof typeof ApplicantExamStatus];
+export declare const ChallengeStyle: {
+    readonly Quiz: 1;
+    readonly Development: 2;
+    readonly Algorithm: 3;
+    readonly Ai: 4;
+};
+export type ChallengeStyle = (typeof ChallengeStyle)[keyof typeof ChallengeStyle];
+export declare const ChallengeResultStatus: {
+    readonly Prepared: 0;
+    readonly Started: 1;
+    readonly InProgress: 2;
+    readonly Finished: 3;
+    readonly NotModified: 4;
+    readonly CanRestart: 5;
+    readonly ScoringWaiting: 6;
+};
+export type ChallengeResultStatus = (typeof ChallengeResultStatus)[keyof typeof ChallengeResultStatus];
+export declare const SpokenLanguage: {
+    readonly English: "en";
+    readonly Japanese: "ja";
+};
+export type SpokenLanguage = (typeof SpokenLanguage)[keyof typeof SpokenLanguage];
+export type ProgrammingLanguage = number;
+export interface ProgrammingLanguageInfo {
+    value: ProgrammingLanguage;
+    displayOrder: number;
+    messageKey: string;
+    displayString: string;
+}
+export interface ApplicantExamForNoAuth {
+    id: number;
+    applicantId: number;
+    examId: number;
+    organizationId: number;
+    organizationImageUrl?: string;
+    organizationName: string;
+    examName: string;
+    urlToken: string;
+    status: ApplicantExamStatus;
+    openedAt?: string;
+}
+export interface ApplicantExam {
+    id: number;
+    applicantId: number;
+    examId: number;
+    deliveryId: number;
+    deadline: string;
+    urlToken: string;
+    status: ApplicantExamStatus;
+    isTest: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface Applicant {
+    id: number;
+    organizationId: number;
+    userId?: number;
+    email: string;
+    fullName?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ChallengesSet {
+    challenges: ExamSessionChallenge[];
+}
+export interface ExamSession {
+    id: number;
+    deadline: string;
+    urlToken: string;
+    status: ApplicantExamStatus;
+    applicant: Applicant;
+    challengesSets: ChallengesSet[];
+    results: ChallengeResult[];
+}
+export interface ExamSessionChallenge {
+    id: number;
+    challengeVersionId: number;
+    style: ChallengeStyle;
+    title: string;
+    description?: string;
+    timeLimitMinutes?: number;
+    displayOrder: number;
+    weight: number;
+    localExamEnabled: boolean;
+    openTestcases?: number;
+    programmingLanguages: ProgrammingLanguage[];
+}
+export interface ChallengeResult {
+    id: number;
+    challengeId: number;
+    challengeVersionId: number;
+    applicantId: number;
+    applicantExamId: number;
+    dueDate?: string;
+    storageId: string;
+    status: ChallengeResultStatus;
+    openedAt?: string;
+    finishedAt?: string;
+    totalTestcases?: number;
+    successfulTestcases?: number;
+    editorScore?: number;
+    testOutput?: string;
+    lastScoredAt?: string;
+    programmingLanguage?: ProgrammingLanguage;
+    appealComment?: string;
+    createdAt: string;
+    updatedAt: string;
+    style?: ChallengeStyle;
+    weight?: number;
+    score?: number;
+}
+export interface CodingContext {
+    challengeId: number;
+    challengeVersionId: number;
+    challengeResultId: number;
+    title: string;
+    urlForPresign: string;
+    urlForOrcaToken?: string;
+    methodForPresign: string;
+    urlForSave?: string;
+    tarballUrl: string;
+    tarballUrls: string[];
+    allowSave: boolean;
+    allowEdit: boolean;
+    programmingLanguages: ProgrammingLanguage[];
+    selectedLanguage?: ProgrammingLanguage;
+    challengeLanguage: SpokenLanguage;
+    settings: ChallengeSettings;
+    answers: CodingAnswers;
+}
+export declare const FileListType: {
+    readonly All: 0;
+    readonly ReadOnlyChallengeFiles: 1;
+    readonly EditableChallengeFiles: 2;
+    readonly UserAddedFiles: 3;
+    readonly Editable: 4;
+};
+export type FileListType = (typeof FileListType)[keyof typeof FileListType];
+export interface ChallengeSettings {
+    files: FileTree;
+    hiddenFiles: string[];
+    testExcludes: string[];
+    images: string[];
+    build: string[];
+    test: string;
+    mainFile?: string;
+    allowNewFile: boolean;
+    languages: string[];
+    sample?: string;
+    envConfig?: EnvSettings;
+    initialize: string[];
+}
+export type FileTree = {
+    [key: string]: FileTree | boolean;
+};
+export interface EnvSettings {
+    imageName: string;
+    workingDir?: string;
+    baseDir?: string;
+    username?: string;
+    variables?: Record<string, string>;
+    cacheDirs: string[];
+}
+export declare const EnvSettings: {
+    default: EnvSettings;
+};
+export interface TestCases {
+    open: number;
+    secret: number;
+}
+export interface CodingAnswers {
+    build?: string[];
+    appCommand?: string;
+    mainFile?: string;
+    addedFiles?: string[];
+    fileVersions: object;
+    envConfig?: EnvSettings;
+}
+export interface SaveFilesRequest {
+    versionId: number;
+    addedFiles: string[];
+    updatedFiles: Record<string, string>;
+}
+export interface ProgrammingLanguageInfo {
+    value: ProgrammingLanguage;
+    displayOrder: number;
+    messageKey: string;
+    displayString: string;
+}
+export interface ApplicationExamForNoAuth {
+    id: number;
+    applicantId: number;
+    examId: number;
+    organizationId: number;
+    organizationImageUrl?: string;
+    organizationName: string;
+    examName: string;
+    urlToken: string;
+    status: ApplicantExamStatus;
+    openedAt?: string;
+}

package/esm/src/track/types.js

@@ -0,0 +1,40 @@
+export const ApplicantExamStatus = {
+    Unread: 1,
+    InProgress: 2,
+    Submitted: 3,
+    Expired: 4,
+    Canceled: 5,
+    Reviewed: 6,
+};
+export const ChallengeStyle = {
+    Quiz: 1,
+    Development: 2,
+    Algorithm: 3,
+    Ai: 4,
+};
+export const ChallengeResultStatus = {
+    Prepared: 0,
+    Started: 1,
+    InProgress: 2,
+    Finished: 3,
+    NotModified: 4,
+    CanRestart: 5,
+    ScoringWaiting: 6,
+};
+export const SpokenLanguage = {
+    English: "en",
+    Japanese: "ja",
+};
+export const FileListType = {
+    All: 0,
+    ReadOnlyChallengeFiles: 1,
+    EditableChallengeFiles: 2,
+    UserAddedFiles: 3,
+    Editable: 4,
+};
+export const EnvSettings = {
+    default: {
+        imageName: "givery/codecheck:latest",
+        cacheDirs: [],
+    },
+};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "bin": {
+    "track": "./esm/src/main.js"
+  },
+  "name": "track-cli",
+  "version": "3.0.0-rc",
+  "description": "A CLI for interacting with tracks.run and running code tests on track's servers",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/givery-technology/track-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/givery-technology/track-cli/issues"
+  },
+  "scripts": {
+    "test": "node test_runner.js"
+  },
+  "dependencies": {
+    "@hazae41/foras": "*",
+    "eventemitter3": "5.0.1",
+    "node-fetch-cookies": "2.0.4",
+    "proxy-agent": "5.0.0",
+    "tar": "*",
+    "ws": "7.4.6",
+    "@deno/shim-deno": "~0.16.1",
+    "@deno/shim-crypto": "~0.3.1",
+    "@deno/shim-prompts": "~0.1.0",
+    "undici": "^5.21.0"
+  },
+  "devDependencies": {
+    "@types/node": "^18.11.9",
+    "picocolors": "^1.0.0"
+  }
+}