@learnpack/learnpack 5.0.355 → 5.0.357

package/lib/services/ingest/http/zipPackageReader.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSafeEntryPath = isSafeEntryPath;
+exports.readPackageZip = readPackageZip;
+const JSZip = require("jszip");
+const errors_1 = require("../errors");
+/**
+ * Rejects an entry whose path could escape the course prefix.
+ *
+ * Every entry eventually becomes a bucket key under `courses/{slug}/`. A zip is
+ * attacker-controlled input, and an entry named `../../other-course/learn.json`
+ * would land outside the prefix the caller was authorized for — the storage
+ * layer concatenates, it does not resolve.
+ * Exported for its own test: JSZip's writer normalizes `..` away, so a zip
+ * built through that API cannot express the traversal case, while an archive
+ * from any other tool can — its reader passes entry names through untouched.
+ * @param path - Entry name as stored in the zip.
+ * @returns True when the entry is safe to keep.
+ */
+function isSafeEntryPath(path) {
+    if (path.startsWith("/") || /^[a-z]:/i.test(path)) {
+        return false;
+    }
+    return !path.split("/").includes("..");
+}
+/**
+ * Reads a course package zip into memory.
+ *
+ * Lives beside the router rather than in `core/` on purpose: this is decoding a
+ * transport format, and the core is meant to know nothing about how a package
+ * reached it — not even that it arrived compressed.
+ * @param buffer - The uploaded zip.
+ * @returns Entry path relative to the package root → text contents.
+ * @throws IngestError `INVALID_PACKAGE` when the archive cannot be read.
+ */
+async function readPackageZip(buffer) {
+    let archive;
+    try {
+        archive = await JSZip.loadAsync(buffer);
+    }
+    catch (error) {
+        throw new errors_1.IngestError("INVALID_PACKAGE", `The uploaded file is not a readable zip: ${error.message}`, error);
+    }
+    const files = {};
+    const unsafe = [];
+    const entries = Object.values(archive.files).filter(entry => !entry.dir);
+    await Promise.all(entries.map(async (entry) => {
+        const path = entry.name.replace(/\\/g, "/");
+        if (!isSafeEntryPath(path)) {
+            unsafe.push(entry.name);
+            return;
+        }
+        files[path] = await entry.async("string");
+    }));
+    if (unsafe.length > 0) {
+        throw new errors_1.IngestError("INVALID_PACKAGE", `The zip contains ${unsafe.length} entr${unsafe.length === 1 ? "y" : "ies"} pointing outside the package: ${unsafe.slice(0, 3).join(", ")}`);
+    }
+    if (Object.keys(files).length === 0) {
+        throw new errors_1.IngestError("INVALID_PACKAGE", "The zip holds no files");
+    }
+    return files;
+}

package/lib/services/ingest/ports/courseStorage.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Where an ingested course's files live.
+ *
+ * Object-level operations only: the ingest core decides *what* the course
+ * layout is, and this port only knows how to put bytes somewhere and take them
+ * back. Keeping it this small is what lets the core run against an in-memory
+ * double in tests, with no credentials and no network.
+ */
+export interface CourseStorage {
+    /** Writes (or overwrites) a text object at `path`. */
+    write(path: string, content: string): Promise<void>;
+    /** Reads an object, or null when it does not exist. */
+    read(path: string): Promise<string | null>;
+    /** Lists every object path under `prefix`. */
+    list(prefix: string): Promise<string[]>;
+    /**
+     * Deletes the given paths.
+     *
+     * Re-ingesting with `--overwrite` has to remove lessons the regenerated
+     * course no longer has: the IDE derives its exercise list from whatever files
+     * it finds, so an upsert would leave the old folders behind as phantom
+     * lessons.
+     */
+    deleteMany(paths: string[]): Promise<void>;
+}

package/lib/services/ingest/ports/courseStorage.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/services/ingest/ports/packageRegistry.d.ts

@@ -0,0 +1,58 @@
+/**
+ * The subset of a Rigobot learning package the ingest service reads.
+ *
+ * Deliberately not the full payload: naming only what is used keeps the
+ * contract honest about what a replacement registry would have to provide.
+ */
+export type RigoPackage = {
+    id: number;
+    package_slug: string;
+    /**
+     * Organization **id**, or null when Rigobot could not auto-detect one.
+     *
+     * An id rather than a slug because that is what comes back: the field is a
+     * plain ForeignKey on a ModelSerializer, so it serializes to the primary key.
+     * The assignment endpoint accepts either form, but nothing ever reads a slug
+     * back, which is why ids are the only representation the two ends share.
+     */
+    organization: number | null;
+    status: string;
+};
+/** One of the organizations the calling user belongs to. */
+export type RigoOrganization = {
+    id: number;
+    name: string;
+};
+/**
+ * The registry that owns course slugs and their ownership.
+ *
+ * Slugs are globally unique across every Rigobot user, and in practice
+ * immutable — the rename endpoint does not update the package on Rigobot's
+ * side — so the ingest resolves availability *before* writing anything.
+ */
+export interface PackageRegistry {
+    /** True when no package holds this slug yet. */
+    isSlugAvailable(slug: string): Promise<boolean>;
+    /**
+     * Registers a new package.
+     * @throws IngestError `SLUG_TAKEN` when the slug is already registered.
+     */
+    createPackage(slug: string, config: unknown): Promise<RigoPackage>;
+    /** Reads a package, or null when it does not exist or is not ours. */
+    getPackageBySlug(slug: string): Promise<RigoPackage | null>;
+    /**
+     * Attaches a package to an organization.
+     *
+     * One-shot: Rigobot only accepts this while the package's organization is
+     * still null, and offers no way to detach it afterwards.
+     */
+    assignOrganization(packageId: number, organizationId: number): Promise<void>;
+    /**
+     * The organizations the calling user belongs to.
+     *
+     * Needed because configuration names an organization the way a human would,
+     * while packages report it as an id. This is the only lookup that bridges
+     * the two — and it doubles as the list to show when the name matches none.
+     */
+    listOrganizations(): Promise<RigoOrganization[]>;
+}

package/lib/services/ingest/ports/packageRegistry.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/services/ingest/ports/requestAuthenticator.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Who is making an ingest request.
+ *
+ * Carried as data through the core, never re-read from headers or the
+ * environment further in: the moment the core reaches for a credential itself,
+ * swapping the auth scheme stops being a one-file change.
+ */
+export type Identity = {
+    rigoToken: string;
+};
+/**
+ * Resolves an identity from a request's headers.
+ *
+ * Takes headers rather than a request object on purpose — the port must not
+ * know that Express exists, so the day this service moves behind a different
+ * transport only the adapter changes. Today the credential is a Rigobot user
+ * token; when the machine-to-machine token arrives, it is a second adapter
+ * here and nothing else moves.
+ */
+export interface RequestAuthenticator {
+    /**
+     * @throws IngestError `INVALID_TOKEN` when the credential is missing or rejected.
+     */
+    authenticate(headers: Record<string, string | string[] | undefined>): Promise<Identity>;
+}

package/lib/services/ingest/ports/requestAuthenticator.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/utils/coursePackage/bucketIo.d.ts

@@ -0,0 +1,23 @@
+import { Buffer } from "buffer";
+import { Bucket } from "@google-cloud/storage";
+/**
+ * Writes a text file to the course bucket.
+ *
+ * READMEs are sanitized on the way in: the newline collapsing has to happen at
+ * the single write path, otherwise a caller that forgets it stores content the
+ * translation step later chokes on.
+ * @param bucket - Target GCS bucket.
+ * @param file - File contents as a string.
+ * @param path - Full object path inside the bucket.
+ * @returns Resolves once the object is stored.
+ */
+export declare const uploadFileToBucket: (bucket: Bucket, file: string, path: string) => Promise<void>;
+/**
+ * Writes a binary file (images, assets) to the course bucket.
+ * @param bucket - Target GCS bucket.
+ * @param buffer - File contents as a buffer.
+ * @param path - Full object path inside the bucket.
+ * @param contentType - Optional MIME type to store alongside the object.
+ * @returns Resolves once the object is stored.
+ */
+export declare const uploadBinaryToBucket: (bucket: Bucket, buffer: Buffer, path: string, contentType?: string) => Promise<void>;

package/lib/utils/coursePackage/bucketIo.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadBinaryToBucket = exports.uploadFileToBucket = void 0;
+const buffer_1 = require("buffer");
+const readmeSanitizer_1 = require("../readmeSanitizer");
+/**
+ * Writes a text file to the course bucket.
+ *
+ * READMEs are sanitized on the way in: the newline collapsing has to happen at
+ * the single write path, otherwise a caller that forgets it stores content the
+ * translation step later chokes on.
+ * @param bucket - Target GCS bucket.
+ * @param file - File contents as a string.
+ * @param path - Full object path inside the bucket.
+ * @returns Resolves once the object is stored.
+ */
+const uploadFileToBucket = async (bucket, file, path) => {
+    const isReadme = /readme(\.\w+)?\.md$/i.test(path);
+    const content = isReadme ? (0, readmeSanitizer_1.sanitizeReadmeNewlines)(file) : file;
+    const fileRef = bucket.file(path);
+    await fileRef.save(buffer_1.Buffer.from(content, "utf8"));
+};
+exports.uploadFileToBucket = uploadFileToBucket;
+/**
+ * Writes a binary file (images, assets) to the course bucket.
+ * @param bucket - Target GCS bucket.
+ * @param buffer - File contents as a buffer.
+ * @param path - Full object path inside the bucket.
+ * @param contentType - Optional MIME type to store alongside the object.
+ * @returns Resolves once the object is stored.
+ */
+const uploadBinaryToBucket = async (bucket, buffer, path, contentType) => {
+    const fileRef = bucket.file(path);
+    await fileRef.save(buffer, Object.assign({ resumable: false }, (contentType && { contentType })));
+};
+exports.uploadBinaryToBucket = uploadBinaryToBucket;

package/lib/utils/coursePackage/learnJson.d.ts

@@ -0,0 +1,26 @@
+import { FormState } from "../../models/creator";
+/**
+ * Builds the `learn.json` for a freshly created course.
+ *
+ * The preview URL is derived from the slug rather than stored: the published
+ * package always lives at `{slug}.learn-pack.com`, so deriving it keeps the two
+ * from drifting apart when the slug changes.
+ * @param courseInfo - Course metadata collected by the creator wizard.
+ * @returns The `learn.json` object, ready to be serialized.
+ */
+export declare const createLearnJson: (courseInfo: FormState) => {
+    slug: string;
+    title: {
+        [x: string]: string;
+    };
+    technologies: string[];
+    difficulty: string;
+    description: {
+        [x: string]: string;
+    };
+    grading: string;
+    telemetry: {
+        batch: string;
+    };
+    preview: string;
+};

package/lib/utils/coursePackage/learnJson.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLearnJson = void 0;
+const api_1 = require("../api");
+/**
+ * Builds the `learn.json` for a freshly created course.
+ *
+ * The preview URL is derived from the slug rather than stored: the published
+ * package always lives at `{slug}.learn-pack.com`, so deriving it keeps the two
+ * from drifting apart when the slug changes.
+ * @param courseInfo - Course metadata collected by the creator wizard.
+ * @returns The `learn.json` object, ready to be serialized.
+ */
+const createLearnJson = (courseInfo) => {
+    // console.log("courseInfo to create learn json", courseInfo)
+    const expectedPreviewUrl = `https://${courseInfo.slug}.learn-pack.com/preview.png`;
+    const language = courseInfo.language || "en";
+    const learnJson = {
+        slug: courseInfo.slug,
+        title: {
+            [language]: courseInfo.title,
+        },
+        technologies: courseInfo.technologies || [],
+        difficulty: "beginner",
+        description: {
+            [language]: courseInfo.description,
+        },
+        grading: "isolated",
+        telemetry: {
+            batch: api_1.BREATHECODE_TELEMETRY_URL,
+        },
+        preview: expectedPreviewUrl,
+    };
+    return learnJson;
+};
+exports.createLearnJson = createLearnJson;

package/lib/utils/coursePackage/sidebar.d.ts

@@ -0,0 +1,15 @@
+import { TSidebar } from "../sidebarGenerator";
+/**
+ * Builds the initial sidebar for a course whose lessons have no title yet.
+ *
+ * Each entry maps to its own slug as a placeholder: at creation time the
+ * generator has not produced titles, and the sidebar is rewritten once it does.
+ *
+ * Unlike the helpers in `sidebarGenerator`, this one is pure — it returns the
+ * sidebar instead of writing it to disk, because the bucket path persists it
+ * through the storage layer rather than through the local filesystem.
+ * @param slugs - Exercise slugs, in the order they should appear.
+ * @param initialLanguage - Language code the placeholder titles are filed under.
+ * @returns The sidebar object, ready to be serialized.
+ */
+export declare const createInitialSidebar: (slugs: string[], initialLanguage?: string) => Promise<TSidebar>;

package/lib/utils/coursePackage/sidebar.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInitialSidebar = void 0;
+/**
+ * Builds the initial sidebar for a course whose lessons have no title yet.
+ *
+ * Each entry maps to its own slug as a placeholder: at creation time the
+ * generator has not produced titles, and the sidebar is rewritten once it does.
+ *
+ * Unlike the helpers in `sidebarGenerator`, this one is pure — it returns the
+ * sidebar instead of writing it to disk, because the bucket path persists it
+ * through the storage layer rather than through the local filesystem.
+ * @param slugs - Exercise slugs, in the order they should appear.
+ * @param initialLanguage - Language code the placeholder titles are filed under.
+ * @returns The sidebar object, ready to be serialized.
+ */
+const createInitialSidebar = async (slugs, initialLanguage = "en") => {
+    const sidebar = {};
+    for (const slug of slugs) {
+        sidebar[slug] = {
+            [initialLanguage]: slug,
+        };
+    }
+    return sidebar;
+};
+exports.createInitialSidebar = createInitialSidebar;

package/lib/utils/creatorSocket.js

@@ -5,8 +5,9 @@ exports.emitToCourse = emitToCourse;
 exports.emitToNotification = emitToNotification;
 exports.getSocketIO = getSocketIO;
 const socket_io_1 = require("socket.io");
-const courseSocketMap = new Map(); // slug -> Set<socket.id>
-const notificationSocketMap = new Map(); // notificationId -> Set<socket.id>
+const socketRegistry_1 = require("./socketRegistry");
+const courseRegistry = new socketRegistry_1.SocketRegistry(); // courseSlug -> socket ids
+const notificationRegistry = new socketRegistry_1.SocketRegistry(); // notificationId -> socket ids
 const socketStore = new Map(); // socket.id -> socket
 let io = null;
 function initSocketIO(server) {
@@ -21,50 +22,43 @@ function initSocketIO(server) {
         console.log("🧠 Socket connected:", socket.id);
         socketStore.set(socket.id, socket);
         socket.on("register", (data) => {
-            var _a;
             const { courseSlug } = data;
             if (!courseSlug)
                 return;
-            if (!courseSocketMap.has(courseSlug)) {
-                courseSocketMap.set(courseSlug, new Set());
-            }
-            (_a = courseSocketMap.get(courseSlug)) === null || _a === void 0 ? void 0 : _a.add(socket.id);
+            courseRegistry.register(courseSlug, socket.id);
             console.log(`📦 Socket ${socket.id} registered to course: ${courseSlug}`);
         });
         socket.on("registerNotification", (data) => {
-            var _a;
             const { notificationId } = data;
             if (!notificationId)
                 return;
-            if (!notificationSocketMap.has(notificationId)) {
-                notificationSocketMap.set(notificationId, new Set());
-            }
-            (_a = notificationSocketMap.get(notificationId)) === null || _a === void 0 ? void 0 : _a.add(socket.id);
+            notificationRegistry.register(notificationId, socket.id);
             console.log(`📧 Socket ${socket.id} registered to notification: ${notificationId}`);
         });
         socket.on("disconnect", () => {
             console.log("🔥 Socket disconnected:", socket.id);
             socketStore.delete(socket.id);
-            for (const set of courseSocketMap.values()) {
-                set.delete(socket.id);
-            }
+            // Both registries, not just the course one. Leaving the socket in the
+            // notification registry leaked it for the lifetime of the process.
+            courseRegistry.removeSocket(socket.id);
+            notificationRegistry.removeSocket(socket.id);
         });
     });
     return io;
 }
 function emitToCourse(courseSlug, event, payload) {
-    const socketIds = courseSocketMap.get(courseSlug);
-    if (!socketIds || socketIds.size === 0)
-        return;
-    for (const id of socketIds) {
+    for (const id of courseRegistry.listeners(courseSlug)) {
         const socket = socketStore.get(id);
         if (socket)
             socket.emit(event, payload);
     }
 }
 function emitToNotification(notificationId, payload, retry = 0) {
-    const socketIds = notificationSocketMap.get(notificationId);
-    if (!socketIds || socketIds.size === 0) {
+    const socketIds = notificationRegistry.listeners(notificationId);
+    // The webhook can beat the browser to the registration: the creator only
+    // subscribes once the initial POST resolves, and a job that fails fast comes
+    // back sooner than that.
+    if (socketIds.length === 0) {
         if (retry > 3) {
             console.log("❌ Notification", notificationId, "not found");
             return;

package/lib/utils/gcpCredentials.d.ts

@@ -0,0 +1,18 @@
+/**
+ * GCP service-account credentials, required and parsed rather than assumed.
+ *
+ * Every caller today re-reads `GCP_CREDENTIALS_JSON` inline and handles it a
+ * little differently: `serve.ts` exits silently when it is missing and then
+ * parses without a try/catch, so malformed JSON surfaces as a bare
+ * SyntaxError with no hint about which variable produced it. Validating in one
+ * place turns both cases into a message that names the variable.
+ *
+ * Mirrors `requireGcsBucketName` and `requireAwsCredentials`, including their
+ * refusal of the empty-string fallback.
+ */
+export type GcpCredentials = {
+    client_email?: string;
+    private_key?: string;
+    [key: string]: unknown;
+};
+export declare function requireGcpCredentials(): GcpCredentials;

package/lib/utils/gcpCredentials.js

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * GCP service-account credentials, required and parsed rather than assumed.
+ *
+ * Every caller today re-reads `GCP_CREDENTIALS_JSON` inline and handles it a
+ * little differently: `serve.ts` exits silently when it is missing and then
+ * parses without a try/catch, so malformed JSON surfaces as a bare
+ * SyntaxError with no hint about which variable produced it. Validating in one
+ * place turns both cases into a message that names the variable.
+ *
+ * Mirrors `requireGcsBucketName` and `requireAwsCredentials`, including their
+ * refusal of the empty-string fallback.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireGcpCredentials = requireGcpCredentials;
+function requireGcpCredentials() {
+    const raw = (process.env.GCP_CREDENTIALS_JSON || "").trim();
+    if (!raw) {
+        throw new Error("GCP_CREDENTIALS_JSON (env) is required: it holds the service account that reaches the course bucket");
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`GCP_CREDENTIALS_JSON (env) is not valid JSON: ${error.message}`);
+    }
+}

package/lib/utils/rigoActions.d.ts

@@ -21,6 +21,22 @@ type TTranslateInputs = {
     output_language: string;
 };
 export declare const translateExercise: (token: string, inputs: TTranslateInputs, webhookUrl: string) => Promise<any>;
+export type TCompletionJob = {
+    id: number;
+    status: "PENDING" | "SUCCESS" | "ERROR" | string;
+    status_text?: string | null;
+    parsed?: Record<string, any> | null;
+};
+type TTranslateAndWaitOptions = {
+    /** How often the job status is checked while it is still running. */
+    pollIntervalMs?: number;
+    /** How long we keep waiting before giving up on the job. */
+    timeoutMs?: number;
+    /** Called after every successful poll, useful to keep a heartbeat alive. */
+    onPoll?: (job: TCompletionJob) => void | Promise<void>;
+};
+export declare const getCompletionJob: (token: string, completionId: number | string) => Promise<TCompletionJob>;
+export declare const translateExerciseAndWait: (token: string, inputs: TTranslateInputs, options?: TTranslateAndWaitOptions) => Promise<TCompletionJob>;
 type TGenerateCourseIntroductionInputs = {
     course_title: string;
     lessons_context: string;

package/lib/utils/rigoActions.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateStepSlug = exports.generateCodeChallenge = exports.addInteractivity = exports.generateStepDescriptions = exports.initialContentGenerator = exports.getLanguageCodes = exports.isPackageAuthor = exports.fillSidebarJSON = exports.generateCourseShortName = exports.isValidRigoToken = exports.translateCourseMetadata = exports.createStructuredPreviewReadme = exports.readmeCreator = exports.createCodingReadme = exports.createCodeFile = exports.interactiveCreation = exports.generateCourseIntroduction = exports.translateExercise = exports.generateImage = exports.hasCreatorPermission = exports.createReadme = void 0;
+exports.generateStepSlug = exports.generateCodeChallenge = exports.addInteractivity = exports.generateStepDescriptions = exports.initialContentGenerator = exports.getLanguageCodes = exports.isPackageAuthor = exports.fillSidebarJSON = exports.generateCourseShortName = exports.isValidRigoToken = exports.translateCourseMetadata = exports.createStructuredPreviewReadme = exports.readmeCreator = exports.createCodingReadme = exports.createCodeFile = exports.interactiveCreation = exports.generateCourseIntroduction = exports.translateExerciseAndWait = exports.getCompletionJob = exports.translateExercise = exports.generateImage = exports.hasCreatorPermission = exports.createReadme = void 0;
 exports.downloadImage = downloadImage;
 exports.createPreviewReadme = createPreviewReadme;
 exports.makeReadmeReadable = makeReadmeReadable;
@@ -96,6 +96,107 @@ const translateExercise = async (token, inputs, webhookUrl) => {
     return response.data;
 };
 exports.translateExercise = translateExercise;
+const POST_RETRY_DELAYS_MS = [1000, 3000, 6000];
+const MAX_CONSECUTIVE_POLL_ERRORS = 5;
+const sleep = (ms) => new Promise(resolve => {
+    setTimeout(resolve, ms);
+});
+const isFinalStatus = (status) => status === "SUCCESS" || status === "ERROR";
+// Network failures and 5xx are worth retrying, a 4xx is not going to fix itself.
+const isRetriablePostError = (error) => {
+    var _a;
+    const status = (_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.status;
+    return status === undefined || status >= 500;
+};
+const assertJobSucceeded = (job) => {
+    if (job.status === "ERROR") {
+        throw new Error(job.status_text || `Rigobot translation job ${job.id} finished with ERROR`);
+    }
+    return job;
+};
+const getCompletionJob = async (token, completionId) => {
+    const response = await axios_1.default.get(`${api_1.RIGOBOT_HOST}/v1/prompting/completion/${completionId}/`, {
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: "Token " + token,
+        },
+    });
+    return response.data;
+};
+exports.getCompletionJob = getCompletionJob;
+// Translates an exercise as an asynchronous Rigobot job and waits for the
+// result by polling.
+//
+// Running the completion synchronously (execute_async: false) keeps the HTTP
+// request open until the LLM is done, which for a full README takes 28-45s and
+// gets killed by Heroku's 30s router limit. Firing the job asynchronously
+// answers in about a second and moves the waiting to the polling loop, so it
+// is no longer bound to the lifetime of a single request.
+const translateExerciseAndWait = async (token, inputs, options = {}) => {
+    const { pollIntervalMs = 3000, timeoutMs = 6 * 60 * 1000, onPoll } = options;
+    let job;
+    for (let attempt = 0; attempt <= POST_RETRY_DELAYS_MS.length; attempt++) {
+        try {
+            // eslint-disable-next-line no-await-in-loop
+            const response = await axios_1.default.post(`${api_1.RIGOBOT_HOST}/v1/prompting/completion/translate-asset-markdown/`, {
+                inputs: inputs,
+                include_purpose_objective: false,
+                execute_async: true,
+            }, {
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: "Token " + token,
+                },
+            });
+            job = response.data;
+            break;
+        }
+        catch (error) {
+            if (!isRetriablePostError(error) ||
+                attempt === POST_RETRY_DELAYS_MS.length) {
+                throw error;
+            }
+            // eslint-disable-next-line no-await-in-loop
+            await sleep(POST_RETRY_DELAYS_MS[attempt]);
+        }
+    }
+    if (!job) {
+        throw new Error("Rigobot did not return a translation job");
+    }
+    // Rigobot answers straight away with the cached completion when the very
+    // same inputs were translated before, so there is nothing to wait for.
+    if (isFinalStatus(job.status)) {
+        return assertJobSucceeded(job);
+    }
+    const jobId = job.id;
+    const startedAt = Date.now();
+    let consecutivePollErrors = 0;
+    while (Date.now() - startedAt < timeoutMs) {
+        // eslint-disable-next-line no-await-in-loop
+        await sleep(pollIntervalMs);
+        try {
+            // eslint-disable-next-line no-await-in-loop
+            job = await (0, exports.getCompletionJob)(token, jobId);
+            consecutivePollErrors = 0;
+        }
+        catch (error) {
+            consecutivePollErrors++;
+            if (consecutivePollErrors >= MAX_CONSECUTIVE_POLL_ERRORS) {
+                throw new Error(`Could not read the status of the translation job ${jobId} after ${MAX_CONSECUTIVE_POLL_ERRORS} attempts: ${error.message}`);
+            }
+            continue;
+        }
+        if (onPoll) {
+            // eslint-disable-next-line no-await-in-loop
+            await onPoll(job);
+        }
+        if (isFinalStatus(job.status)) {
+            return assertJobSucceeded(job);
+        }
+    }
+    throw new Error(`The translation job ${jobId} did not finish after ${Math.round(timeoutMs / 1000)}s, its last known status was ${job.status}`);
+};
+exports.translateExerciseAndWait = translateExerciseAndWait;
 const generateCourseIntroduction = async (token, inputs) => {
     const response = await axios_1.default.post(`${api_1.RIGOBOT_HOST}/v1/prompting/completion/192/`, {
         inputs: inputs,