@examplary/cli 1.14.0 → 1.17.0

package/dist/lib/build-current-app.d.ts

@@ -0,0 +1,4 @@
+import { Uploader } from "./build-app.js";
+export declare const dryUpload: Uploader;
+/** Builds the app in the current directory, exiting on any error so a partial app is never published. */
+export declare const buildCurrentApp: (upload: Uploader, quiet?: boolean) => Promise<Record<string, any>>;

package/dist/lib/build-current-app.js

@@ -0,0 +1,21 @@
+import { cwd, exit } from "process";
+import { buildAppManifest, findAppFile, loadAppDefinition, } from "./build-app.js";
+export const dryUpload = async (fileName) => `https://validate.invalid/${fileName}`;
+/** Builds the app in the current directory, exiting on any error so a partial app is never published. */
+export const buildCurrentApp = async (upload, quiet = false) => {
+    try {
+        const file = await findAppFile(cwd());
+        const definition = await loadAppDefinition(file);
+        if (!quiet)
+            console.log(`Building app: ${definition.id}...`);
+        const manifest = await buildAppManifest(file, definition, upload);
+        if (!quiet) {
+            console.log(`• Bundled ${manifest.components.length} component(s), ${manifest.hooks.length} hook(s) and ${manifest.questionTypes.length} question type(s)`);
+        }
+        return manifest;
+    }
+    catch (e) {
+        console.error(`🚫 ${e.message}`);
+        exit(1);
+    }
+};

package/dist/lib/build-question-type.d.ts

@@ -0,0 +1,8 @@
+import type { Uploader } from "./build-app.js";
+/**
+ * Checks a question type of an app (incl. its response processing test cases),
+ * bundles its components, and uploads them with its icon, README
+ * and preview image, all by paths relative to the app's directory `dir`.
+ * Returns the definition `POST /apps` takes.
+ */
+export declare const buildQuestionType: (questionType: Record<string, any>, dir: string, uploadFile: Uploader) => Promise<Record<string, any>>;

package/dist/lib/build-question-type.js

@@ -0,0 +1,48 @@
+import { uploadTranslatablePath } from "./build-app.js";
+import { isValid, printValidationResult, validateDefinition, } from "./validate.js";
+/** Uploads a bundle, with its source map next to it. */
+const uploadBundle = async (name, { js, sourcemap }, upload) => {
+    const sourcemapUrl = sourcemap && (await upload(`${name}.map`, sourcemap, "application/json"));
+    return upload(name, sourcemapUrl ? `${js}\n//# sourceMappingURL=${sourcemapUrl}` : js, "application/javascript");
+};
+/** Uploaded files by language, e.g. a `readme` given as one path or one per language. */
+const uploadByLanguage = async (dir, paths, upload) => {
+    const urls = await uploadTranslatablePath(dir, paths, upload);
+    return typeof urls === "string" ? { en: urls } : urls;
+};
+/**
+ * Checks a question type of an app (incl. its response processing test cases),
+ * bundles its components, and uploads them with its icon, README
+ * and preview image, all by paths relative to the app's directory `dir`.
+ * Returns the definition `POST /apps` takes.
+ */
+export const buildQuestionType = async (questionType, dir, uploadFile) => {
+    // A copy: the app's own definition is hashed without the upload URLs
+    const { readme, previewImage, ...definition } = structuredClone(questionType);
+    // An app has several question types, all with files like `component-print.js`
+    const prefix = definition.id?.split(".").pop();
+    const upload = (name, contents, contentType) => uploadFile(`${prefix}.${name}`, contents, contentType);
+    const result = await validateDefinition(definition, dir);
+    if (!isValid(result)) {
+        printValidationResult(result);
+        throw new Error(`Question type ${definition.id} isn't valid`);
+    }
+    const components = {};
+    for (const [type, output] of Object.entries(result.bundles)) {
+        components[type] = await uploadBundle(`component-${type}.js`, output, upload);
+    }
+    definition.components = components;
+    if (result.styles) {
+        definition.stylesheet = await upload("styles.css", result.styles, "text/css");
+    }
+    if (definition.icon && result.iconContents) {
+        definition.icon = await upload("icon.svg", result.iconContents, "image/svg+xml");
+    }
+    definition.readmeUrls = await uploadByLanguage(dir, readme, upload);
+    definition.readme = definition.readmeUrls?.en;
+    definition.previewImageUrls = await uploadByLanguage(dir, previewImage, upload);
+    definition.previewImage = definition.previewImageUrls?.en;
+    // Test cases have run during validation, they don't need storing
+    delete definition.responseProcessing?.testCases;
+    return definition;
+};

package/dist/lib/bundle.d.ts

@@ -1,9 +1,10 @@
-export declare const buildComponent: (file: string) => Promise<{
+/** A bundle built with an inline source map, as the code and the map apart. */
+export declare const splitInlineSourcemap: (output: string) => {
     js: string;
     sourcemap: string;
     sha256: string;
-}>;
-export declare const buildFunction: (file: string) => Promise<{
+};
+export declare const buildComponent: (file: string) => Promise<{
     js: string;
     sourcemap: string;
     sha256: string;

package/dist/lib/bundle.js

@@ -3,6 +3,14 @@ import { build } from "esbuild";
 const calculateHash = (compiled) => {
     return createHash("sha256").update(compiled).digest("hex");
 };
+/** A bundle built with an inline source map, as the code and the map apart. */
+export const splitInlineSourcemap = (output) => {
+    const [js, encoded] = output.split("\n//# sourceMappingURL=data:application/json;base64,");
+    const sourcemap = encoded
+        ? Buffer.from(encoded.trim(), "base64").toString("utf-8")
+        : "";
+    return { js: js.trim(), sourcemap, sha256: calculateHash(js.trim()) };
+};
 export const buildComponent = async (file) => {
     const res = await build({
         entryPoints: [file],
@@ -20,35 +28,5 @@ export const buildComponent = async (file) => {
             "react-dom/client",
         ],
     });
-    let js = res.outputFiles[0].text;
-    let sourcemap = "";
-    const sourceMapStatement = "\n//# sourceMappingURL=data:application/json;base64,";
-    if (js.includes(sourceMapStatement)) {
-        sourcemap = Buffer.from(js.split(sourceMapStatement)[1].trim(), "base64").toString("utf-8");
-        js = js.split(sourceMapStatement)[0].trim();
-    }
-    const sha256 = calculateHash(js);
-    return { js, sourcemap, sha256 };
-};
-export const buildFunction = async (file) => {
-    const res = await build({
-        entryPoints: [file],
-        bundle: true,
-        write: false,
-        minify: true,
-        sourcemap: "inline",
-        platform: "neutral",
-        mainFields: ["module", "main"],
-        format: "iife",
-        globalName: "userFunction",
-    });
-    let js = res.outputFiles[0].text;
-    let sourcemap = "";
-    const sourceMapStatement = "\n//# sourceMappingURL=data:application/json;base64,";
-    if (js.includes(sourceMapStatement)) {
-        sourcemap = Buffer.from(js.split(sourceMapStatement)[1].trim(), "base64").toString("utf-8");
-        js = js.split(sourceMapStatement)[0].trim();
-    }
-    const sha256 = calculateHash(js);
-    return { js, sourcemap, sha256 };
+    return splitInlineSourcemap(res.outputFiles[0].text);
 };

package/dist/lib/styles.d.ts

@@ -1 +1,2 @@
-export declare const buildStyles: () => Promise<string | null>;
+/** The Tailwind classes used by the files in `base`, or null when there are none. */
+export declare const buildStyles: (base?: string) => Promise<string | null>;

package/dist/lib/styles.js

@@ -4,7 +4,8 @@ import tailwindcss from "@tailwindcss/postcss";
 import postcss from "postcss";
 const require = createRequire(import.meta.url);
 const tailwindDir = path.dirname(require.resolve("tailwindcss/package.json"));
-export const buildStyles = async () => {
+/** The Tailwind classes used by the files in `base`, or null when there are none. */
+export const buildStyles = async (base = process.cwd()) => {
     const absolutePath = path.resolve(tailwindDir);
     const inputCSS = `
     @import "${absolutePath}/theme.css" layer(theme);
@@ -12,6 +13,7 @@ export const buildStyles = async () => {
   `;
     const result = await postcss([
         tailwindcss({
+            base,
             optimize: { minify: true },
         }),
     ]).process(inputCSS, { from: "module-css.css" });

package/dist/lib/validate.d.ts

@@ -1,4 +1,4 @@
-import type { QuestionTypeDefinition } from "./read-meta.js";
+import type { QuestionType } from "@examplary/schemas";
 import { TestCaseResult } from "./response-processing.js";
 export type BuiltComponent = {
     js: string;
@@ -18,8 +18,6 @@ export type ValidationResult = {
     styles?: string;
     /** Raw icon file contents, present only when an icon is configured. */
     iconContents?: string;
-    /** Bundled function output, keyed by function name, ready to upload. */
-    functions: Record<string, BuiltComponent>;
 };
 /**
  * Runs every check the `upload` command performs, short of actually uploading:
@@ -27,7 +25,7 @@ export type ValidationResult = {
  * response processing test cases. Bundled artifacts are returned so callers can
  * reuse them for an upload without bundling twice.
  */
-export declare const validateDefinition: (definition: QuestionTypeDefinition, dir: string) => Promise<ValidationResult>;
+export declare const validateDefinition: (definition: Partial<QuestionType>, dir: string) => Promise<ValidationResult>;
 /** Whether the definition is safe to upload. */
 export declare const isValid: (result: ValidationResult) => boolean;
 /** Prints warnings, errors, and a test-case summary to the console. */

package/dist/lib/validate.js

@@ -1,6 +1,6 @@
 import { readFile } from "fs/promises";
-import { resolve } from "path";
-import { buildComponent, buildFunction } from "./bundle.js";
+import { dirname, resolve } from "path";
+import { buildComponent } from "./bundle.js";
 import { deepCompileJsonata } from "./jsonata.js";
 import { runResponseProcessingTestCases, } from "./response-processing.js";
 import { buildStyles } from "./styles.js";
@@ -20,7 +20,6 @@ export const validateDefinition = async (definition, dir) => {
     const errors = [];
     const warnings = [];
     const bundles = {};
-    const functions = {};
     let styles;
     let iconContents;
     if (!definition.id)
@@ -90,24 +89,11 @@ export const validateDefinition = async (definition, dir) => {
             errors.push(`Error bundling component ${componentType} from ${componentPath}: ${error.message}`);
         }
     }
-    // Bundle functions to confirm they build and to capture their output
-    for (const [functionName, functionPath] of Object.entries(definition.functions || {})) {
-        const realPath = resolve(dir, functionPath);
-        try {
-            const output = await buildFunction(realPath);
-            functions[functionName] = output;
-            const sizeInKb = output.js.length / 1000;
-            if (sizeInKb > 100) {
-                errors.push(`Function ${functionName} is larger than the 100 kB limit (${sizeInKb.toFixed(2)} kB)`);
-            }
-        }
-        catch (error) {
-            errors.push(`Error bundling function ${functionName} from ${functionPath}: ${error.message}`);
-        }
-    }
-    // Build styles if any components are present
-    if (Object.keys(bundles).length) {
-        styles = (await buildStyles()) ?? undefined;
+    // The Tailwind classes used in the folder of its components
+    const [componentPath] = Object.values(definition.components || {});
+    if (Object.keys(bundles).length && componentPath) {
+        styles =
+            (await buildStyles(dirname(resolve(dir, componentPath)))) ?? undefined;
     }
     // Validate the icon file
     if (definition.icon) {
@@ -127,7 +113,6 @@ export const validateDefinition = async (definition, dir) => {
         warnings,
         testCaseResults,
         bundles,
-        functions,
         styles,
         iconContents,
     };
@@ -140,10 +125,6 @@ export const printValidationResult = (result) => {
         const sizeInKb = (output.js.length / 1000).toFixed(2);
         console.log(`• Bundled component ${componentType} (${sizeInKb} kB)`);
     }
-    for (const [functionName, output] of Object.entries(result.functions)) {
-        const sizeInKb = (output.js.length / 1000).toFixed(2);
-        console.log(`• Bundled function ${functionName} (${sizeInKb} kB)`);
-    }
     for (const warning of result.warnings) {
         console.warn(`  ⚠️ ${warning.message}`);
         if (warning.file && process.env.GITHUB_ACTIONS) {

package/package.json

@@ -1,17 +1,15 @@
 {
   "name": "@examplary/cli",
-  "description": "Command-line tools for building and publishing Examplary question types.",
+  "description": "Command-line tools for building and publishing Examplary apps.",
   "packageManager": "yarn@4.8.1",
-  "version": "1.14.0",
+  "version": "1.17.0",
   "bin": {
     "exp": "./dist/index.js"
   },
   "scripts": {
     "release": "semantic-release -e semantic-release-monorepo",
-    "build:preview-ui": "vite build",
     "build:js": "tsc --project tsconfig.json",
-    "build": "yarn build:js && yarn build:preview-ui",
-    "dev": "tsx scripts/dev.ts",
+    "build": "yarn build:js",
     "test": "vitest run"
   },
   "publishConfig": {
@@ -22,36 +20,18 @@
   ],
   "dependencies": {
     "@examplary/schemas": "*",
-    "@examplary/ui": "*",
-    "@hono/node-server": "^2.0.10",
     "@tailwindcss/postcss": "^4.3.3",
-    "@tailwindcss/vite": "^4.3.0",
     "esbuild": "^0.28.1",
-    "hono": "^4.13.11",
     "jsonata": "^2.2.0",
-    "lucide-react": "^1.39.0",
-    "open": "^11.0.0",
+    "postcss": "^8.5.28",
     "tailwindcss": "^4.2.1",
-    "ws": "^8.22.0",
-    "yaml": "^2.8.3",
     "yargs": "^18.0.0"
   },
   "devDependencies": {
     "@types/node": "^24.1.0",
     "@types/yargs": "^17.0.35",
-    "@vitejs/plugin-react": "^6.0.1",
-    "i18next": "^26.3.4",
-    "i18next-browser-languagedetector": "^8.2.0",
-    "postcss": "^8.5.28",
-    "react": "^19.2.8",
-    "react-dom": "^19.2.8",
-    "react-error-boundary": "^6.1.6",
-    "react-i18next": "^17.0.8",
-    "swr": "^2.3.6",
     "tsx": "^4.23.15",
     "typescript": "^7.0.2",
-    "use-local-storage": "^3.0.0",
-    "vite": "^8.3.4",
     "vitest": "^5.0.3"
   },
   "homepage": "https://examplary.ai/developers",

package/dist/commands/preview.d.ts

@@ -1,5 +0,0 @@
-#! /usr/bin/env node
-export declare const previewCommand: (argv: {
-    host: string;
-    key: string;
-}) => Promise<void>;

package/dist/commands/preview.js

@@ -1,195 +0,0 @@
-#! /usr/bin/env node
-import { watch } from "fs";
-import { readFile } from "fs/promises";
-import { createServer as createHttpServer } from "http";
-import { resolve } from "path";
-import { cwd, exit } from "process";
-import { serve } from "@hono/node-server";
-import { serveStatic } from "@hono/node-server/serve-static";
-import { Hono } from "hono";
-import open from "open";
-import { WebSocketServer } from "ws";
-import { setApiHost, setApiKey } from "../lib/api.js";
-import { buildComponent } from "../lib/bundle.js";
-import { readJsonOrYamlFile, readMetaFile } from "../lib/read-meta.js";
-import { resolveInside } from "../lib/safe-path.js";
-import { buildStyles } from "../lib/styles.js";
-export const previewCommand = async (argv) => {
-    setApiHost(argv.host);
-    setApiKey(argv.key);
-    const dir = cwd();
-    // Verify a question-type file exists (json or yml)
-    try {
-        await readMetaFile();
-    }
-    catch (e) {
-        console.error(`🚫 ${e.message}`);
-        exit(1);
-    }
-    // Let's start a Vite server to preview the question type
-    const root = resolve(import.meta.dirname, "..", "preview-ui");
-    const app = new Hono();
-    app.get("/api/bundle", async (c) => {
-        const path = c.req.query("path");
-        const sourcemap = c.req.query("sourcemap") === "1";
-        const componentName = c.req.query("componentName");
-        try {
-            const componentOutput = await buildComponent(resolveInside(dir, path));
-            if (sourcemap) {
-                return c.body(componentOutput.sourcemap, 200, {
-                    "Content-Type": "application/json",
-                });
-            }
-            else {
-                const sizeInKb = componentOutput.js.length / 1000;
-                if (sizeInKb > 100) {
-                    console.warn(`⚠️ Component ${componentName} is larger than 100 kB! Consider optimizing it.`);
-                }
-                let output = componentOutput.js;
-                if (componentOutput.sourcemap) {
-                    output += `\n//# sourceMappingURL=/api/bundle?componentName=${componentName}&path=${encodeURIComponent(path || "")}&sourcemap=1`;
-                }
-                return c.body(output, 200, {
-                    "Content-Type": "application/javascript",
-                });
-            }
-        }
-        catch (error) {
-            console.error(`🚫 Error bundling component ${componentName} from ${path}: ${error.message}`);
-            return c.text(`Error bundling component ${componentName}: ${error.message}`, 500);
-        }
-    });
-    app.get("/api/icon", async (c) => {
-        const path = c.req.query("path") || "";
-        let icon;
-        try {
-            icon = await readFile(resolveInside(dir, path), "utf-8");
-        }
-        catch (error) {
-            return c.text(`Error reading icon from ${path}: ${error.message}`, 400);
-        }
-        return c.body(icon, 200, {
-            "Content-Type": "image/svg+xml",
-        });
-    });
-    app.get("/api/stylesheet", async (c) => {
-        const componentName = c.req.query("componentName");
-        try {
-            const componentOutput = await buildStyles();
-            return c.body(componentOutput || "", 200, {
-                "Content-Type": "text/css",
-            });
-        }
-        catch (error) {
-            console.error(`🚫 Error building CSS for component ${componentName}: ${error.message}`);
-            return c.text(`Error building CSS for component ${componentName}: ${error.message}`, 500);
-        }
-    });
-    app.get("/__reload", async (c) => {
-        if (wss) {
-            wss.clients.forEach((client) => {
-                if (client.readyState === 1) {
-                    // WebSocket.OPEN
-                    client.send(JSON.stringify({ type: "reload" }));
-                }
-            });
-        }
-        return c.body(null, 201);
-    });
-    let wsPort; // WebSocket port will be set when server starts
-    app.get("/", async (c) => {
-        let questionType;
-        try {
-            ({ definition: questionType } = await readMetaFile());
-            questionType.components = questionType.components
-                ? Object.entries(questionType.components).reduce((acc, [componentName, componentPath]) => ({
-                    ...acc,
-                    [componentName]: `/api/bundle?componentName=${componentName}&path=${encodeURIComponent(componentPath)}`,
-                }), {})
-                : questionType.components;
-        }
-        catch (e) {
-            return c.text(`Error reading question type definition: ${e.message}`, 500);
-        }
-        // Default question/answer payloads for the preview, if a preview file exists
-        let previewData = null;
-        try {
-            previewData = (await readJsonOrYamlFile(dir, "preview"))?.data ?? null;
-        }
-        catch (e) {
-            console.warn(`⚠️ ${e.message}`);
-        }
-        let template = await readFile(resolve(root, "index.html"), "utf-8");
-        // Inject hot reload script
-        const hotReloadScript = `
-      <script>
-        (function() {
-          const wsPort = ${wsPort || "null"};
-          if (wsPort) {
-            const ws = new WebSocket('ws://localhost:' + wsPort);
-            ws.onmessage = function(event) {
-              const data = JSON.parse(event.data);
-              if (data.type === 'reload') {
-                console.log('🔄 Reloading page due to file change...');
-                window.location.reload();
-              }
-            };
-            ws.onopen = function() {
-              console.log('🔗 Hot reload connected');
-            };
-            ws.onclose = function() {
-              console.log('🔌 Hot reload disconnected');
-            };
-            ws.onerror = function(error) {
-              console.log('❌ Hot reload error:', error);
-            };
-          }
-        })();
-      </script>
-    `;
-        template =
-            "<script>window._questionType = " +
-                JSON.stringify(questionType) +
-                ";window._previewData = " +
-                JSON.stringify(previewData) +
-                `;</script>${template}${hotReloadScript}`;
-        return c.html(template);
-    });
-    app.use("/assets/*", serveStatic({ root }));
-    // Set up file watcher
-    const watchDir = cwd();
-    console.log(`📁 Watching ${watchDir} for changes...`);
-    let wss; // Will be initialized after server starts
-    const watcher = watch(watchDir, { recursive: true }, (filename) => {
-        if (filename && !filename.startsWith(".")) {
-            // Broadcast reload message to all connected clients
-            if (wss) {
-                wss.clients.forEach((client) => {
-                    if (client.readyState === 1) {
-                        // WebSocket.OPEN
-                        client.send(JSON.stringify({ type: "reload" }));
-                    }
-                });
-            }
-        }
-    });
-    // Clean up watcher on process exit
-    process.on("SIGINT", () => {
-        watcher.close();
-        process.exit(0);
-    });
-    serve({
-        fetch: app.fetch,
-        hostname: "localhost",
-        port: 5777,
-    }, (address) => {
-        const port = address.port;
-        wsPort = port + 1234;
-        const wsServer = createHttpServer();
-        wss = new WebSocketServer({ server: wsServer });
-        wsServer.listen(wsPort);
-        const url = `http://localhost:${port}`;
-        console.log(`🚀 Preview server running at ${url}`);
-        open(url);
-    });
-};

package/dist/commands/upload.d.ts

@@ -1,5 +0,0 @@
-#! /usr/bin/env node
-export declare const uploadCommand: (argv: {
-    host: string;
-    key: string;
-}) => Promise<void>;

package/dist/commands/upload.js

@@ -1,114 +0,0 @@
-#! /usr/bin/env node
-import { readFile } from "fs/promises";
-import { join } from "path";
-import { cwd, exit } from "process";
-import { setApiHost, setApiKey, uploadFile } from "../lib/api.js";
-import { readJsonOrYamlFile, readMetaFile } from "../lib/read-meta.js";
-import { isValid, printValidationResult, validateDefinition, } from "../lib/validate.js";
-export const uploadCommand = async (argv) => {
-    setApiHost(argv.host);
-    setApiKey(argv.key);
-    const dir = cwd();
-    let definition = {};
-    try {
-        ({ definition } = await readMetaFile());
-    }
-    catch (e) {
-        console.error(`🚫 ${e.message}`);
-        exit(1);
-    }
-    console.log(`Uploading question type: ${definition.id}...`);
-    // Run all checks (incl. response processing test cases) before uploading
-    const result = await validateDefinition(definition, dir);
-    printValidationResult(result);
-    if (!isValid(result)) {
-        console.error(`\n🚫 Validation failed, aborting upload`);
-        exit(1);
-    }
-    // Upload the bundled components produced during validation
-    const components = {};
-    for (const [componentType, output] of Object.entries(result.bundles)) {
-        // Upload source map first if it exists
-        let sourceMapStatement = "";
-        if (output.sourcemap) {
-            const url = await uploadFile(`component-${componentType}.js.map`, output.sourcemap, "application/json");
-            sourceMapStatement = `\n//# sourceMappingURL=${url}`;
-        }
-        components[componentType] = await uploadFile(`component-${componentType}.js`, output.js + sourceMapStatement, "application/javascript");
-        console.log(`• Uploaded component ${componentType}`);
-    }
-    definition.components = components;
-    // Upload the bundled functions
-    const functions = {};
-    for (const [functionName, output] of Object.entries(result.functions)) {
-        // Upload source map first if it exists
-        let sourceMapStatement = "";
-        if (output.sourcemap) {
-            const url = await uploadFile(`function-${functionName}.js.map`, output.sourcemap, "application/json");
-            sourceMapStatement = `\n//# sourceMappingURL=${url}`;
-        }
-        functions[functionName] = await uploadFile(`function-${functionName}.js`, output.js + sourceMapStatement, "application/javascript");
-        console.log(`• Uploaded function ${functionName}`);
-    }
-    definition.functions = functions;
-    // Upload styles if present
-    if (result.styles) {
-        definition.stylesheet = await uploadFile("styles.css", result.styles, "text/css");
-        const sizeInKb = (result.styles.length / 1000).toFixed(2);
-        console.log(`• Uploaded styles (${sizeInKb} kB)`);
-    }
-    // Upload icon if specified
-    if (definition.icon && result.iconContents) {
-        definition.icon = await uploadFile("icon.svg", result.iconContents, "image/svg+xml");
-        console.log(`• Uploaded icon`);
-    }
-    // Upload the README if present
-    const readme = await readFile(join(dir, "README.md"), "utf-8").catch(() => null);
-    if (readme) {
-        definition.readme = await uploadFile("README.md", readme, "text/markdown");
-        console.log(`• Uploaded README`);
-    }
-    // Upload the preview image if present
-    const previewImage = await readFile(join(dir, "preview.png")).catch(() => null);
-    if (previewImage) {
-        definition.previewImage = await uploadFile("preview.png", previewImage, "image/png");
-        console.log(`• Uploaded preview image`);
-    }
-    // Upload the preview data if present, always converted to JSON
-    try {
-        const preview = await readJsonOrYamlFile(dir, "preview");
-        if (preview) {
-            definition.previewData = await uploadFile("preview.json", JSON.stringify(preview.data), "application/json");
-            console.log(`• Uploaded preview data`);
-        }
-    }
-    catch (e) {
-        console.error(`🚫 ${e.message}`);
-        exit(1);
-    }
-    // Test cases have already run during validation, no need to store them
-    if (definition.responseProcessing?.testCases) {
-        delete definition.responseProcessing?.testCases;
-    }
-    // Upload the main question type definition
-    const res = await fetch(`${argv.host}/question-types`, {
-        headers: {
-            Authorization: `Bearer ${argv.key}`,
-            "Content-Type": "application/json",
-        },
-        method: "POST",
-        body: JSON.stringify(definition),
-    });
-    if (!res.ok) {
-        console.error(`🚫 Uploading question type failed`);
-        try {
-            const errorResponse = await res.json();
-            console.log(errorResponse);
-        }
-        catch (e) {
-            console.log(e);
-        }
-        exit(1);
-    }
-    console.log(`• Finished uploading definition\n`);
-};