@remotedraw/cli 0.1.0

package/dist/setup-wizard.js

@@ -0,0 +1,469 @@
+import { spawn } from "node:child_process";
+import { emitKeypressEvents } from "node:readline";
+export function initialWizardState(definition) {
+    return {
+        screen: "field",
+        fieldIndex: 0,
+        values: { ...definition.defaults },
+        editedFields: [],
+        confirmCreate: false,
+    };
+}
+function activeField(state, definition) {
+    return definition.fields[state.fieldIndex];
+}
+function fieldError(state, definition) {
+    const field = activeField(state, definition);
+    return field.validate?.(state.values[field.key]);
+}
+function updateField(state, definition, value) {
+    const field = activeField(state, definition);
+    const values = definition.normalize({ ...state.values, [field.key]: value }, field.key);
+    return { ...state, values, error: undefined };
+}
+export function transitionWizard(state, action, definition) {
+    if (["success", "cancelled", "interrupted"].includes(state.screen)) {
+        return state;
+    }
+    if (action.type === "interrupt")
+        return { ...state, screen: "interrupted" };
+    if (action.type === "cancel" && state.screen !== "executing") {
+        return { ...state, screen: "cancelled" };
+    }
+    if (action.type === "executionSucceeded" && state.screen === "executing") {
+        return {
+            ...state,
+            screen: "success",
+            createdPath: action.path,
+            nextCommand: action.nextCommand,
+        };
+    }
+    if (action.type === "executionFailed" && state.screen === "executing") {
+        return { ...state, screen: "error", error: action.message };
+    }
+    if (state.screen === "error")
+        return state;
+    if (state.screen === "review") {
+        if (action.type === "back") {
+            return {
+                ...state,
+                screen: "field",
+                fieldIndex: definition.fields.length - 1,
+            };
+        }
+        if (action.type === "forward") {
+            return { ...state, screen: "confirm", confirmCreate: false };
+        }
+        return state;
+    }
+    if (state.screen === "confirm") {
+        if (action.type === "back")
+            return { ...state, screen: "review" };
+        if (action.type === "previousChoice" || action.type === "nextChoice") {
+            return { ...state, confirmCreate: !state.confirmCreate };
+        }
+        if (action.type === "forward") {
+            return state.confirmCreate
+                ? { ...state, screen: "executing" }
+                : { ...state, screen: "cancelled" };
+        }
+        return state;
+    }
+    if (state.screen !== "field")
+        return state;
+    const field = activeField(state, definition);
+    if (action.type === "character" &&
+        action.value.length > 0 &&
+        field.kind === "text") {
+        const editedFields = state.editedFields.includes(field.key)
+            ? state.editedFields
+            : [...state.editedFields, field.key];
+        const next = updateField(state, definition, state.editedFields.includes(field.key)
+            ? state.values[field.key] + action.value
+            : action.value);
+        return { ...next, editedFields };
+    }
+    if (action.type === "backspace" && field.kind === "text") {
+        const wasEdited = state.editedFields.includes(field.key);
+        const next = updateField(state, definition, wasEdited ? state.values[field.key].slice(0, -1) : "");
+        return {
+            ...next,
+            editedFields: wasEdited
+                ? state.editedFields
+                : [...state.editedFields, field.key],
+        };
+    }
+    if ((action.type === "previousChoice" || action.type === "nextChoice") &&
+        field.kind === "select") {
+        const choices = field.choices?.(state.values) ?? [];
+        if (choices.length === 0)
+            return state;
+        const current = Math.max(0, choices.findIndex((choice) => choice.value === state.values[field.key]));
+        const offset = action.type === "nextChoice" ? 1 : -1;
+        const next = (current + offset + choices.length) % choices.length;
+        return updateField(state, definition, choices[next].value);
+    }
+    if (action.type === "back") {
+        return state.fieldIndex === 0
+            ? { ...state, screen: "cancelled" }
+            : { ...state, fieldIndex: state.fieldIndex - 1, error: undefined };
+    }
+    if (action.type === "forward") {
+        const validation = fieldError(state, definition);
+        if (validation)
+            return { ...state, error: validation };
+        return state.fieldIndex === definition.fields.length - 1
+            ? { ...state, screen: "review", error: undefined }
+            : { ...state, fieldIndex: state.fieldIndex + 1, error: undefined };
+    }
+    return state;
+}
+export function wizardSemanticView(state, definition) {
+    if (state.screen === "field") {
+        const field = activeField(state, definition);
+        const choices = field.choices?.(state.values);
+        const selectedChoice = choices?.find((choice) => choice.value === state.values[field.key]);
+        return {
+            screen: state.screen,
+            title: "Een RemoteDraw-project maken",
+            progress: {
+                current: state.fieldIndex + 1,
+                total: definition.fields.length,
+            },
+            activeLabel: field.label,
+            value: state.values[field.key],
+            valueIsDefault: field.kind === "text" && !state.editedFields.includes(field.key),
+            choices,
+            selectedChoice: state.values[field.key],
+            selectedDetails: selectedChoice?.details,
+            validation: state.error,
+            controls: field.kind === "text"
+                ? [
+                    !state.editedFields.includes(field.key)
+                        ? "Typ om de standaardnaam te vervangen"
+                        : "Typ om te wijzigen",
+                    "←/→ stappen",
+                    "Enter volgende",
+                    "Esc terug",
+                    "Ctrl+C stoppen",
+                ]
+                : [
+                    "↑/↓ kiezen",
+                    ...(selectedChoice?.details ? ["d docs openen"] : []),
+                    "←/→ stappen",
+                    "Enter volgende",
+                    "Esc terug",
+                    "q stoppen",
+                ],
+        };
+    }
+    if (state.screen === "review") {
+        return {
+            screen: state.screen,
+            title: "Project controleren",
+            review: definition.review(state.values),
+            controls: ["→/Enter doorgaan", "←/Esc terug", "q stoppen"],
+        };
+    }
+    if (state.screen === "confirm") {
+        return {
+            screen: state.screen,
+            title: "Projectbestanden maken?",
+            choices: [
+                { value: "no", label: "Nee, annuleren" },
+                { value: "yes", label: "Ja, project maken" },
+            ],
+            selectedChoice: state.confirmCreate ? "yes" : "no",
+            controls: ["↑/↓ kiezen", "Enter bevestigen", "←/Esc terug"],
+        };
+    }
+    return {
+        screen: state.screen,
+        title: state.screen === "executing"
+            ? "Project wordt gemaakt…"
+            : state.screen === "success"
+                ? "RemoteDraw-project gemaakt"
+                : state.screen === "error"
+                    ? "Project maken mislukt"
+                    : state.screen === "interrupted"
+                        ? "Installatie onderbroken"
+                        : "Installatie geannuleerd",
+        controls: [],
+        createdPath: state.createdPath,
+        nextCommand: state.nextCommand,
+        error: state.error,
+    };
+}
+export async function runSetupWizard(options) {
+    let state = initialWizardState(options.definition);
+    try {
+        await options.terminal.enter();
+        if (options.terminal.color) {
+            for (let frame = 0; frame < BANNER_ANIMATION_FRAMES; frame += 1) {
+                options.terminal.write(renderWizard(state, options.definition, options.terminal, frame));
+                if (frame < BANNER_ANIMATION_FRAMES - 1) {
+                    await pause(BANNER_ANIMATION_DELAY_MS);
+                }
+            }
+        }
+        while (true) {
+            options.terminal.write(renderWizard(state, options.definition, options.terminal, BANNER_ANIMATION_FRAMES - 1));
+            if (state.screen === "executing") {
+                try {
+                    const result = await options.execute(state.values);
+                    state = transitionWizard(state, { type: "executionSucceeded", ...result }, options.definition);
+                }
+                catch (error) {
+                    state = transitionWizard(state, {
+                        type: "executionFailed",
+                        message: `${error instanceof Error ? error.message : String(error)}\nControleer de doelmap en de toegangsrechten.`,
+                    }, options.definition);
+                }
+                continue;
+            }
+            if (state.screen === "success" || state.screen === "cancelled") {
+                return { exitCode: 0, state };
+            }
+            if (state.screen === "error")
+                return { exitCode: 1, state };
+            if (state.screen === "interrupted")
+                return { exitCode: 130, state };
+            const key = await options.terminal.readKey();
+            const selectedDetails = wizardSemanticView(state, options.definition).selectedDetails;
+            if (key.name === "d" && selectedDetails) {
+                if (!options.terminal.openUrl) {
+                    state = {
+                        ...state,
+                        error: `Open de documentatie via ${selectedDetails.docsUrl}`,
+                    };
+                    continue;
+                }
+                try {
+                    await options.terminal.openUrl(selectedDetails.docsUrl);
+                }
+                catch {
+                    state = {
+                        ...state,
+                        error: `Kon de documentatie niet openen. Gebruik ${selectedDetails.docsUrl}`,
+                    };
+                }
+                continue;
+            }
+            state = transitionWizard(state, actionForKey(key, state), options.definition);
+        }
+    }
+    finally {
+        await options.terminal.restore();
+    }
+}
+export function actionForKey(key, state) {
+    if (key.ctrl && key.name === "c")
+        return { type: "interrupt" };
+    if (key.name === "escape")
+        return { type: "back" };
+    if (key.name === "return" || key.name === "enter")
+        return { type: "forward" };
+    if (key.name === "left") {
+        return state.screen === "field" && state.fieldIndex === 0
+            ? { type: "character", value: "" }
+            : { type: "back" };
+    }
+    if (key.name === "right")
+        return { type: "forward" };
+    if (key.name === "up")
+        return { type: "previousChoice" };
+    if (key.name === "down")
+        return { type: "nextChoice" };
+    if (key.name === "backspace")
+        return { type: "backspace" };
+    if (key.name === "q" && (state.screen !== "field" || state.fieldIndex > 0)) {
+        return { type: "cancel" };
+    }
+    if (state.screen === "field" &&
+        key.sequence &&
+        !key.ctrl &&
+        key.sequence >= " ") {
+        return { type: "character", value: key.sequence };
+    }
+    return { type: "character", value: "" };
+}
+function paint(enabled, code, value) {
+    return enabled ? `\x1b[${code}m${value}\x1b[0m` : value;
+}
+function hyperlink(enabled, url, label) {
+    return enabled ? `\x1b]8;;${url}\x1b\\${label}\x1b]8;;\x1b\\` : label;
+}
+async function openExternalUrl(url) {
+    const parsed = new URL(url);
+    if (parsed.protocol !== "https:") {
+        throw new Error("Only HTTPS documentation links can be opened.");
+    }
+    const [command, args] = process.platform === "darwin"
+        ? ["open", [url]]
+        : process.platform === "win32"
+            ? ["cmd", ["/c", "start", "", url]]
+            : ["xdg-open", [url]];
+    await new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            detached: true,
+            stdio: "ignore",
+            windowsHide: true,
+        });
+        child.once("error", reject);
+        child.once("spawn", () => {
+            child.unref();
+            resolve();
+        });
+    });
+}
+function wrapText(value, width) {
+    const words = value.trim().split(/\s+/);
+    const lines = [];
+    let line = "";
+    for (const word of words) {
+        if (word.length > width) {
+            if (line) {
+                lines.push(line);
+                line = "";
+            }
+            let remainder = word;
+            while (remainder.length > width) {
+                lines.push(remainder.slice(0, width));
+                remainder = remainder.slice(width);
+            }
+            line = remainder;
+            continue;
+        }
+        if (line.length > 0 && line.length + word.length + 1 > width) {
+            lines.push(line);
+            line = word;
+        }
+        else {
+            line = line ? `${line} ${word}` : word;
+        }
+    }
+    if (line)
+        lines.push(line);
+    return lines;
+}
+function renderChoiceDetails(details, terminal) {
+    const width = Math.max(20, Math.min(72, terminal.columns - 4));
+    const border = (value) => paint(terminal.color, "36", value);
+    const contentLine = (value = "", rendered = value) => `${border("│")} ${rendered}${" ".repeat(Math.max(0, width - value.length))} ${border("│")}`;
+    const button = `[ ${details.docsLabel} ↗ ]`;
+    const header = "─ Keuzehulp ";
+    const lines = [
+        `${border("┌")}${paint(terminal.color, "1;36", header)}${border("─".repeat(width + 2 - header.length))}${border("┐")}`,
+        ...wrapText(details.summary, width).map((line) => contentLine(line, paint(terminal.color, "1", line))),
+        contentLine(),
+        ...wrapText(details.explanation, width).map((line) => contentLine(line)),
+        contentLine(),
+        contentLine(button, hyperlink(terminal.hyperlinks === true, details.docsUrl, paint(terminal.color, "1;96", button))),
+    ];
+    if (terminal.hyperlinks !== true) {
+        lines.push(...wrapText(details.docsUrl, width).map((line) => contentLine(line, paint(terminal.color, "2", line))));
+    }
+    lines.push(`${border("└")}${border("─".repeat(width + 2))}${border("┘")}`);
+    return lines;
+}
+const BANNER_COLORS = ["36", "96", "94", "34"];
+const BANNER_ANIMATION_FRAMES = BANNER_COLORS.length;
+const BANNER_ANIMATION_DELAY_MS = 45;
+function pause(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+export function renderWizard(state, definition, terminal, bannerFrame = 0) {
+    const view = wizardSemanticView(state, definition);
+    const narrow = terminal.columns < 60;
+    const wordmark = narrow
+        ? ["RemoteDraw", "telefoon → canvas"]
+        : [
+            " ____                      _       ____                    ",
+            "|  _ \\ ___ _ __ ___   ___ | |_ ___|  _ \\ _ __ __ ___      __",
+            "| |_) / _ \\ '_ ` _ \\ / _ \\| __/ _ \\ | | | '__/ _` \\ \\ /\\ / /",
+            "|  _ <  __/ | | | | | (_) | ||  __/ |_| | | | (_| |\\ V  V / ",
+            "|_| \\_\\___|_| |_| |_|\\___/ \\__\\___|____/|_|  \\__,_| \\_/\\_/  ",
+        ];
+    const lines = [
+        "\x1b[2J\x1b[H",
+        ...wordmark.map((line, index) => paint(terminal.color, BANNER_COLORS[(index + bannerFrame) % BANNER_COLORS.length], line)),
+        "",
+    ];
+    if (view.progress) {
+        lines.push(`Stap ${view.progress.current}/${view.progress.total} · ${view.title}`, "");
+    }
+    else {
+        lines.push(view.title, "");
+    }
+    if (view.activeLabel) {
+        if (view.choices) {
+            lines.push(paint(terminal.color, "1;36", view.activeLabel));
+            for (const choice of view.choices) {
+                const selected = choice.value === view.selectedChoice;
+                lines.push(paint(terminal.color && selected, "1;96", `${selected ? ">" : " "} [${selected ? "x" : " "}] ${choice.label}`));
+                if (!narrow && choice.hint)
+                    lines.push(`      ${choice.hint}`);
+            }
+        }
+        else {
+            lines.push(paint(terminal.color, "1;36", view.activeLabel), `${paint(terminal.color, "36", "│")} ${paint(terminal.color, view.valueIsDefault ? "2" : "1", view.value || "_")}${paint(terminal.color, "96", "▌")}${view.valueIsDefault
+                ? ` ${paint(terminal.color, "2", "(standaard)")}`
+                : ""}`);
+        }
+        if (view.selectedDetails) {
+            lines.push("", ...renderChoiceDetails(view.selectedDetails, terminal));
+        }
+        if (view.validation)
+            lines.push("", `! ${view.validation}`);
+    }
+    if (view.review) {
+        for (const [label, value] of view.review)
+            lines.push(`${label}: ${value}`);
+    }
+    if (view.choices && !view.activeLabel) {
+        for (const choice of view.choices) {
+            const selected = choice.value === view.selectedChoice;
+            lines.push(`${selected ? ">" : " "} [${selected ? "x" : " "}] ${choice.label}`);
+        }
+    }
+    if (view.createdPath)
+        lines.push(`Gemaakt in: ${view.createdPath}`);
+    if (view.nextCommand)
+        lines.push("", "Volgende opdracht:", `  ${view.nextCommand}`);
+    if (view.error)
+        lines.push(view.error);
+    if (view.controls.length)
+        lines.push("", view.controls.join(" · "));
+    return `${lines.join("\n")}\n`;
+}
+export function createWizardTerminal(input, output, env) {
+    const wasRaw = input.isRaw === true;
+    const wasFlowing = input.readableFlowing === true;
+    return {
+        columns: output.columns || 80,
+        color: env.NO_COLOR == null && output.hasColors?.() !== false,
+        hyperlinks: env.TERM !== "dumb" && env.NO_HYPERLINKS == null,
+        write(value) {
+            output.write(value);
+        },
+        enter() {
+            emitKeypressEvents(input);
+            input.setRawMode?.(true);
+            input.resume();
+            output.write("\x1b[?25l");
+        },
+        async readKey() {
+            return await new Promise((resolve) => {
+                input.once("keypress", (_text, key) => resolve(key));
+            });
+        },
+        openUrl: openExternalUrl,
+        restore() {
+            if (!wasRaw)
+                input.setRawMode?.(false);
+            if (!wasFlowing)
+                input.pause();
+            output.write("\x1b[?25h\x1b[0m\n");
+        },
+    };
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@remotedraw/cli",
+  "version": "0.1.0",
+  "description": "Command-line tools for creating and inspecting RemoteDraw integrations.",
+  "type": "module",
+  "bin": {
+    "remotedraw": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AxioSOzo/RemoteDraw.git",
+    "directory": "packages/cli"
+  },
+  "bugs": {
+    "url": "https://github.com/AxioSOzo/RemoteDraw/issues"
+  },
+  "homepage": "https://github.com/AxioSOzo/RemoteDraw#readme",
+  "keywords": [
+    "remotedraw",
+    "drawing",
+    "cli"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "bun run src/index.ts",
+    "test": "bun test tests/*.test.ts",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "verify:publish": "bun run build && bun run typecheck && bun run test && node dist/index.js --help && node dist/index.js --version",
+    "prepack": "bun run verify:publish"
+  },
+  "devDependencies": {
+    "@types/node": "25.6.2",
+    "typescript": "6.0.3"
+  }
+}