track-cli 3.1.0 → 4.0.0-rc0

package/esm/src/shared/mod.js

@@ -1,13 +1,15 @@
 import * as dntShim from "../../_dnt.shims.js";
-import { load as loadConfig, save as saveConfig, webUrl, } from "./config.js";
-import { BadTarballURL, ChallengeAlreadyFinished, ExamCanceled, ExamExpired, ExamSubmitted, ExamUnread, OtherError, } from "./errors.js";
-import { getUniqueDirName, toNativeStyle, untgz } from "./file.js";
-import { TrackClient } from "../track/client.js";
-import { ApplicantExamStatus, ChallengeResultStatus, ChallengeStyle, FileListType, } from "../track/types.js";
+import { save as saveConfig, } from "./config.js";
+import { BadTarballURL, ChallengeAlreadyFinished, OtherError, } from "./errors.js";
+import { toNativeStyle, untgz } from "./file.js";
+import { ChallengeResultStatus, FileListType, TrackApp, } from "./types.js";
+import { TestClient } from "../track/test.js";
+import { TrainingClient } from "../track/training.js";
 import * as datetime from "../../deps/deno.land/std@0.195.0/datetime/mod.js";
 import * as colors from "../../deps/deno.land/std@0.195.0/fmt/colors.js";
 import { format as duration } from "../../deps/deno.land/std@0.195.0/fmt/duration.js";
 import * as fs from "../../deps/deno.land/std@0.195.0/fs/mod.js";
+import { exists } from "../../deps/deno.land/std@0.195.0/fs/mod.js";
 export const _internals = {
     prompt: dntShim.prompt,
     scoreRatio: scoreRatio,
@@ -19,6 +21,10 @@ export const HttpStatus = {
         const status = typeof r === "number" ? r : r.status;
         return 300 > status && status >= 200;
     },
+    isRedirect(r) {
+        const status = typeof r === "number" ? r : r.status;
+        return 400 > status && status >= 300;
+    },
     isClientError(r) {
         const status = typeof r === "number" ? r : r.status;
         return 500 > status && status >= 400;
@@ -68,30 +74,8 @@ export function printTimeLeft(timeLeftSeconds) {
         console.log("The exam deadline has passed");
     }
 }
-export function ensureExamInProgress(applicantExam, webUrlRedirect) {
-    switch (applicantExam.status) {
-        case ApplicantExamStatus.Submitted:
-        case ApplicantExamStatus.Reviewed:
-            throw new ExamSubmitted();
-        case ApplicantExamStatus.Expired:
-            throw new ExamExpired();
-        case ApplicantExamStatus.Canceled:
-            throw new ExamCanceled();
-        case ApplicantExamStatus.Unread:
-            throw new ExamUnread(webUrlRedirect);
-        case ApplicantExamStatus.InProgress:
-            return;
-    }
-}
-export function getChallengeFromExamSession(examSession, challengeId) {
-    return examSession.challengesSets
-        .flatMap((s) => s.challenges)
-        .find((c) => c.id === challengeId &&
-        (c.style === ChallengeStyle.Development ||
-            c.style === ChallengeStyle.Algorithm));
-}
-export async function tryStartingChallenge(challenge, api, applicantExam, resultOpt) {
-    let result = resultOpt;
+export async function tryStartingChallenge(api, challenge) {
+    let result = challenge.result;
     while (true) {
         if (result) {
             switch (result.status) {
@@ -109,14 +93,14 @@ export async function tryStartingChallenge(challenge, api, applicantExam, result
                         throw new OtherError("Aborted. Challenge was not started.");
                     }
                     if (challenge.programmingLanguages.length > 0) {
-                        const programmingLanguages = (await api.getProgrammingLanguages())
+                        const programmingLanguages = (await api.languages())
                             .filter((pl) => challenge.programmingLanguages.includes(pl.value));
                         const desiredLanguage = chooseProgrammingLanguage(programmingLanguages);
                         if (desiredLanguage.value !== result.programmingLanguage) {
-                            await api.switchChallengeLanguage(applicantExam.id, result.id, desiredLanguage.value);
+                            await api.updateLanguage(desiredLanguage.value);
                         }
                     }
-                    result = await api.startChallenge(applicantExam.id, result.id);
+                    result = await api.start();
                     break;
                 }
                 case ChallengeResultStatus.Started:
@@ -133,13 +117,13 @@ export async function tryStartingChallenge(challenge, api, applicantExam, result
         }
         else {
             // Challenge hasn't been prepared yet
-            result = await api.prepareChallenge(applicantExam.id, challenge.id);
+            result = await api.prepare();
         }
     }
 }
 export function chooseProgrammingLanguage(languages) {
     while (true) {
-        const desiredLanguageIndex = Prompt.select("Please select a programming language:", languages.map((l) => l.displayString));
+        const desiredLanguageIndex = Prompt.select("Please select a programming language:", languages.map((l) => l.name));
         if (desiredLanguageIndex !== undefined) {
             return languages[desiredLanguageIndex];
         }
@@ -244,57 +228,31 @@ export const SnakeCase = {
         }
     },
 };
-export async function getCommonChallengeContext() {
-    const config = await loadConfig();
-    const api = TrackClient.fromTrackConfig(config);
-    const applicantExam = await api.getApplicantExamNoAuth(config.examToken);
-    ensureExamInProgress(applicantExam, webUrl(config));
-    const codingContext = await api.getChallengeCodingContext(config.applicantExamId, config.challengeResultId);
-    const examSession = await api.getExamSession(config.applicantExamId);
-    let result = getResultFromExamSession(examSession, config.challengeId);
-    if (!result) {
-        throw new OtherError(`Cchallenge result for challenge id ${config.challengeId} is missing - has the challenge been started yet?`);
-    }
-    const challenge = getChallengeFromExamSession(examSession, config.challengeId);
-    if (!challenge) {
-        throw new OtherError(`Challenge for challenge id ${config.challengeId} is missing - has the challenge been started yet?`);
+export async function getCommonChallengeContext(config, api) {
+    const challenge = await api.startChallengeSession();
+    if (!challenge.result) {
+        throw new OtherError(`Challenge for challenge id ${challenge.challengeId} is missing - has the challenge been started yet?`);
     }
+    const result = challenge.result;
     switch (result.status) {
         case ChallengeResultStatus.Finished:
         case ChallengeResultStatus.NotModified:
             throw new ChallengeAlreadyFinished();
-        case ChallengeResultStatus.CanRestart:
+        case ChallengeResultStatus.CanRestart: {
             console.log("This challenge can be restarted");
             console.log();
-            result = await tryStartingChallenge(challenge, api, applicantExam, result);
-            if (!result) {
+            const result2 = await tryStartingChallenge(api, challenge);
+            if (!result2) {
                 throw new OtherError("Expected to have a challenge result after preparing and starting");
             }
             break;
+        }
     }
-    const challengePosition = examSession
-        .challengesSets
-        .flatMap((s) => s.challenges)
-        .findIndex((c) => c.id === config.challengeId) +
-        1;
-    if (api.authCookieExpired()) {
-        config.cookies = api.getCookies();
-        await saveConfig(config);
-    }
-    return {
-        config,
-        api,
-        codingContext,
-        applicantExam,
-        challengeResult: result,
-        challenge,
-        challengePosition,
-    };
-}
-function getResultFromExamSession(examSession, challengeId) {
-    return examSession
-        .results
-        .find((cr) => cr.challengeId === challengeId);
+    const codingContext = await api.context();
+    // TODO: 保存条件
+    config.cookies = api.getCookies();
+    await saveConfig(config);
+    return [codingContext, challenge];
 }
 function scoreRatio(editorScore, openTestcases) {
     // @ts-expect-error: isFinite(undefined) === false, isFinite(0) === true. See MDN
@@ -305,16 +263,17 @@ function scoreRatio(editorScore, openTestcases) {
         return "\tN/A - Use 'track run' to save and run your submission";
     }
 }
-export async function printChallengeInfo(trackContext) {
-    const { config, api, challengeResult: result } = trackContext;
-    const timeLeft = await api.timeLeft(config.applicantExamId, config.challengeResultId);
-    printWorkingFileSet(trackContext.codingContext);
+export async function printChallengeInfo(api, codingContext, challenge) {
+    // const { config, api, challengeResult: result } = trackContext;
+    const result = challenge.result;
+    const timeLeft = await api.timeLeft();
+    printWorkingFileSet(codingContext);
     console.log();
     const lastScoredAt = result.lastScoredAt
         ? ` (Ran at ${datetime.format(new Date(result.lastScoredAt), "yyyy-MM-dd HH:mm:ss")})`
         : "";
     console.log(`Latest score${lastScoredAt}`);
-    console.log(colors.green(scoreRatio(result.editorScore, trackContext.challenge.openTestcases)));
+    console.log(colors.green(scoreRatio(result.editorScore, challenge.openTestcases)));
     console.log();
     printTimeLeft(timeLeft);
 }
@@ -338,7 +297,7 @@ export function printWorkingFileSet(codingContext) {
         console.log();
     }
 }
-export async function downloadChallengeFilesTo(codingContext, dest, api, applicantExamId, challengeResultId, showFileDiff, includeTarball) {
+export async function downloadChallengeFilesTo(codingContext, dest, api, showFileDiff, includeTarball) {
     if (includeTarball) {
         console.log("Fetching challenge tarball...");
         const tarballResp = await dntShim.fetch(codingContext.tarballUrl);
@@ -350,7 +309,7 @@ export async function downloadChallengeFilesTo(codingContext, dest, api, applica
     }
     console.log("Downloading editable files");
     const filesToDownload = listFileNames(codingContext, FileListType.Editable);
-    const presignedUrls = Object.entries(await api.getPresignedUrls(applicantExamId, challengeResultId, filesToDownload))
+    const presignedUrls = Object.entries(await api.presigned(filesToDownload))
         .map(([file, url]) => ({ file, url }));
     presignedUrls.sort((a, b) => a.file.localeCompare(b.file));
     const promises = presignedUrls.map(async ({ file, url }) => {
@@ -370,21 +329,42 @@ export async function downloadChallengeFilesTo(codingContext, dest, api, applica
 export /**
  * Archives all files in a challenge directory into a subdirectory of
  * the challenge directory. Ignores .track/ and other existing archival directories
- */ async function archiveExistingChallengeFiles(orgName, challengePosition, options) {
-    const challengeDir = options?.challengeDir ?? dntShim.Deno.cwd();
-    const langString = options?.selectedLanguage?.displayString ?? "";
-    const archivePath = await getUniqueDirName(`${orgName}_challenge_${challengePosition}_old_${langString}`, { root: challengeDir });
-    console.log(`Your old challenge contents will be archived in ${archivePath}`);
-    await fs.ensureDir(archivePath);
-    // Match directories with names like 'ORGNAME_challenge_12_Go_1'
-    const oldArchivePattern = /.*_challenge_\d+_.+_\d+/;
-    // Move all files and directories in the challenge dir into the archive path
-    // Do not copy the track config folder, the archive path, or old archive paths
+ */ async function archiveExistingChallengeFiles(orgName) {
+    const challengeDir = dntShim.Deno.cwd();
+    const base = `${orgName}_challenge_old`;
+    let archiveDir;
+    let i = 1;
+    while (true) {
+        archiveDir = `${base}_${i}`;
+        const pathExists = await exists(archiveDir);
+        if (pathExists) {
+            i++;
+            continue;
+        }
+        break;
+    }
+    console.log(`Your old challenge contents will be archived in ${archiveDir}`);
+    await fs.ensureDir(archiveDir);
+    const oldArchivePattern = /.*_challenge_old_\d+/;
     for await (const dirEntry of dntShim.Deno.readDir(challengeDir)) {
-        if (dirEntry.name === archivePath || dirEntry.name === ".track" ||
+        if (dirEntry.name === archiveDir || dirEntry.name === ".track" ||
             (dirEntry.isDirectory && oldArchivePattern.test(dirEntry.name))) {
             continue;
         }
-        await fs.move(`${challengeDir}/${dirEntry.name}`, `${archivePath}/${dirEntry.name}`);
+        await fs.move(`${challengeDir}/${dirEntry.name}`, `${archiveDir}/${dirEntry.name}`);
+    }
+}
+export function trackClientFromConfig(config) {
+    let api;
+    switch (config.app) {
+        case TrackApp.Test:
+            api = new TestClient(config.baseUrl, config.orgName, config.token, config.challengeId, config.basicAuth, config.cookies);
+            break;
+        case TrackApp.Training:
+            api = new TrainingClient(config.baseUrl, config.orgName, config.token, config.courseMaterialId, config.klassId, config.klassResultId, config.basicAuth, config.cookies);
+            break;
+        default:
+            throw new OtherError(`Unsupported app: ${config.app}`);
     }
+    return api;
 }

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

@@ -1,12 +1,142 @@
-import { TrackConfig } from "./config.js";
-import { TrackClient } from "../track/client.js";
-import { ApplicantExamForNoAuth, ChallengeResult, CodingContext, ExamSessionChallenge } from "../track/types.js";
-export interface TrackCLIContext {
-    config: TrackConfig;
-    api: TrackClient;
-    codingContext: CodingContext;
-    applicantExam: ApplicantExamForNoAuth;
-    challengeResult: ChallengeResult;
-    challenge: ExamSessionChallenge;
-    challengePosition: number;
+export declare const TrackApp: {
+    readonly Test: 1;
+    readonly Training: 2;
+};
+export type TrackApp = typeof TrackApp[keyof typeof TrackApp];
+export declare class CloneUrl {
+    app: TrackApp;
+    baseUrl: string;
+    orgName: string;
+    token: string;
+    id: number;
+    constructor(url: string);
+    toString(): string;
 }
+export interface ProgrammingLanguageInfo {
+    value: ProgrammingLanguage;
+    name: string;
+}
+export interface ChallengeSession {
+    challengeId: number;
+    challengeVersionId: number;
+    style: ChallengeStyle;
+    title: string;
+    description?: string;
+    timeLimitMinutes?: number;
+    displayOrder: number;
+    programmingLanguages: ProgrammingLanguage[];
+    localCodingAllowed: boolean;
+    openTestcases?: number;
+    result?: ChallengeResult;
+}
+export interface ChallengeResult {
+    challengeId: number;
+    challengeVersionId: number;
+    dueDate?: string;
+    storageId: string;
+    status: ChallengeResultStatus;
+    openedAt?: string;
+    finishedAt?: string;
+    totalTestcases?: number;
+    successfulTestcases?: number;
+    editorScore?: number;
+    testOutput?: string;
+    lastScoredAt?: string;
+    programmingLanguage?: ProgrammingLanguage;
+}
+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;
+    orcaHost?: string;
+}
+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 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;

package/esm/src/shared/types.js

@@ -1 +1,100 @@
-export {};
+export const TrackApp = {
+    Test: 1,
+    Training: 2,
+};
+const TRACK_TEST_URL_PATTERN = new RegExp("([^/]+)/exams/([^/]+)/challenges/(\\d+)");
+const TRACK_TRAINING_URL_PATTERN = new RegExp("([^/]+)/train/([^/]+)/challenges/(\\d+)");
+export class CloneUrl {
+    constructor(url) {
+        Object.defineProperty(this, "app", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "baseUrl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "orgName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "token", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        const urlObj = new URL(url);
+        const scheme = urlObj.protocol.slice(0, -1);
+        const host = urlObj.host + (urlObj.port ? ":" + urlObj.port : "");
+        this.baseUrl = `${scheme}://${host}`;
+        let caps;
+        if ((caps = TRACK_TEST_URL_PATTERN.exec(url))) {
+            this.app = TrackApp.Test;
+            this.orgName = caps[1];
+            this.token = caps[2];
+            this.id = parseInt(caps[3]);
+        }
+        else if ((caps = TRACK_TRAINING_URL_PATTERN.exec(url))) {
+            this.app = TrackApp.Training;
+            this.orgName = caps[1];
+            this.token = caps[2];
+            this.id = parseInt(caps[3]);
+        }
+        else {
+            throw new Error(`Invalid URL: ${url}`);
+        }
+    }
+    toString() {
+        switch (this.app) {
+            case TrackApp.Test:
+                return `${this.baseUrl}/${this.orgName}/exams/${this.token}/challenges/${this.id}`;
+            case TrackApp.Training:
+                return `${this.baseUrl}/${this.orgName}/train/${this.token}/challenges/${this.id}`;
+        }
+    }
+}
+export const FileListType = {
+    All: 0,
+    ReadOnlyChallengeFiles: 1,
+    EditableChallengeFiles: 2,
+    UserAddedFiles: 3,
+    Editable: 4,
+};
+export const EnvSettings = {
+    default: {
+        imageName: "givery/codecheck:latest",
+        cacheDirs: [],
+    },
+};
+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",
+};

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

@@ -1,13 +1,12 @@
-import { TrackConfig } from "../shared/config.js";
-import { ApplicantExamForNoAuth, ChallengeResult, CodingContext, ExamSession, ProgrammingLanguage, ProgrammingLanguageInfo, SaveFilesRequest } from "./types.js";
+import * as dntShim from "../../_dnt.shims.js";
+import { TrackTestConfigPart, TrackTrainingConfigPart } from "../shared/config.js";
+import { ChallengeResult, ChallengeSession, CodingContext, ProgrammingLanguage, ProgrammingLanguageInfo, SaveFilesRequest } from "../shared/types.js";
+import { CookieJar } from "node-fetch-cookies";
+import { ProxyAgent } from "proxy-agent";
 export interface BasicAuth {
     username: string;
     password?: string;
 }
-export interface AuthData {
-    examToken: string;
-    orgName: string;
-}
 export interface ApiResponse<T> {
     code: number;
     message?: string[];
@@ -18,43 +17,41 @@ export declare const FormType: {
     JSON: string;
 };
 export type FormType = typeof FormType[keyof typeof FormType];
-export declare class TrackClient {
-    private baseUrl;
-    private headers;
-    private cookies;
-    private authData?;
-    private cookieExpired;
-    private agent;
-    constructor(scheme: string, hostname: string, basic?: BasicAuth, authData?: AuthData);
+export declare abstract class TrackClientBase {
+    protected baseUrl: string;
+    protected headers: Record<string, string>;
+    protected cookies: CookieJar;
+    protected agent: ProxyAgent;
+    private isUnauthorized;
+    abstract authenticate(): Promise<void>;
+    constructor(baseUrl: string, basic?: BasicAuth, cookies?: Record<string, string>, isUnauthorized?: (res: dntShim.Response) => boolean);
+    protected _get<T>(path: string, asText?: boolean): Promise<T>;
+    protected _post<T, F>(path: string, formType: FormType, body: F): Promise<T>;
+    protected _put<T, F>(path: string, formType: FormType, body: F): Promise<T>;
+    private _result;
     getCookies(): {
         [name: string]: string;
     };
-    authCookieExpired(): boolean;
-    static fromTrackConfig(config: TrackConfig): TrackClient;
+}
+export interface TrackClient {
+    config(): TrackTestConfigPart | TrackTrainingConfigPart;
     authenticate(): Promise<void>;
-    private _get;
-    private _post;
-    private _put;
-    private _result;
-    getApplicantExamNoAuth(token: string): Promise<ApplicantExamForNoAuth>;
-    getExamSession(applicantExamId: number): Promise<ExamSession>;
-    getProgrammingLanguages(): Promise<ProgrammingLanguageInfo[]>;
-    findProgrammingLanguage(programmingLanguage: ProgrammingLanguage): Promise<ProgrammingLanguageInfo | undefined>;
-    switchChallengeLanguage(applicantExamId: number, resultId: number, language: ProgrammingLanguage): Promise<ChallengeResult>;
-    startChallenge(applicantExamId: number, resultId: number): Promise<ChallengeResult>;
-    prepareChallenge(applicantExamId: number, challengeId: number): Promise<ChallengeResult>;
-    timeLeft(applicantExamId: number, resultId: number): Promise<number>;
-    getChallengeCodingContext(applicantExamId: number, resultId: number): Promise<CodingContext>;
-    getPresignedUrls(applicantExamId: number, resultId: number, files: string[]): Promise<{
+    getCookies(): {
+        [name: string]: string;
+    };
+    startChallengeSession(): Promise<ChallengeSession>;
+    languages(): Promise<ProgrammingLanguageInfo[]>;
+    start(): Promise<ChallengeResult>;
+    prepare(): Promise<ChallengeResult>;
+    updateLanguage(language: ProgrammingLanguage): Promise<void>;
+    timeLeft(): Promise<number>;
+    context(): Promise<CodingContext>;
+    presigned(files: string[]): Promise<{
         [name: string]: string;
     }>;
-    orcaToken(url: string): Promise<string>;
-    /**
-     * Temporary code to retrieve the Orca host.
-     * Will be able to get from CodingContext in the future.
-     */
     orcaHost(): Promise<string>;
-    saveFiles(applicantExamId: number, resultId: number, saveFilesRequest: SaveFilesRequest): Promise<ChallengeResult>;
-    updateEditorScore(applicantExamId: number, resultId: number, editorScore: number): Promise<ChallengeResult>;
-    reset(applicantExamId: number, resultId: number): Promise<ChallengeResult>;
+    orcaToken(context: CodingContext): Promise<string>;
+    saveFiles(files: SaveFilesRequest): Promise<void>;
+    updateEditorScore(score: number): Promise<void>;
+    reset(): Promise<void>;
 }