@clawscarf/cli 0.1.0-alpha.1

package/scripts/installation/configure.js

@@ -0,0 +1,122 @@
+import { defaultInstallationDirectory } from "./location.js";
+import { resolve } from "node:path";
+import { setupContext, assertReleaseCapabilities } from "./setup.js";
+import { readJson, readInputFile, fingerprint } from "./files.js";
+import { isDeepStrictEqual } from "node:util";
+import { SetupInputs } from "./save.js";
+import { installationSchema } from "./configuration.js";
+import { InstallationError } from "./errors.js";
+import { selectedDraft, selectionSchema, } from "./options.js";
+import { packRequirements } from "./requirements.js";
+import { newDirectory } from "./installer/inputs.js";
+/** Resolve input references against the settings document; state stays relative to the output. */
+export function resolveConfigurationInputs(value, base) {
+    const config = structuredClone(value);
+    const path = (input) => (input ? resolve(base, input) : input);
+    config.releaseFile = path(config.releaseFile);
+    if (config.access.mode === "hosted")
+        config.access.registrationFile = path(config.access.registrationFile);
+    if (config.access.mode === "oidc")
+        config.access.clientSecretFile = path(config.access.clientSecretFile);
+    if (config.exposure.mode === "https") {
+        config.exposure.certificateFile = path(config.exposure.certificateFile);
+        config.exposure.keyFile = path(config.exposure.keyFile);
+    }
+    if (config.models) {
+        config.models.configurationFile = path(config.models.configurationFile);
+        if (config.models.mode === "external") {
+            config.models.credentialFile = path(config.models.credentialFile);
+            if (config.models.caFile)
+                config.models.caFile = path(config.models.caFile);
+        }
+        else
+            config.models.upstreamEnvironmentFile = path(config.models.upstreamEnvironmentFile);
+    }
+    config.connections.registrationFile = path(config.connections.registrationFile);
+    for (const pack of config.packs) {
+        pack.directory = path(pack.directory);
+        if (pack.bindingsFile)
+            pack.bindingsFile = path(pack.bindingsFile);
+    }
+    if (config.packOperator)
+        config.packOperator.pythonExecutable = path(config.packOperator.pythonExecutable);
+    return config;
+}
+/** Collect the same choices as the menu without prompting or writing any files. */
+export async function prepareConfiguration(options) {
+    if (options.reapply)
+        throw new InstallationError("invalid_configuration", "--reapply requires an existing installation.");
+    if (!options.recipe)
+        throw new InstallationError("invalid_configuration", "Unattended new configuration requires --recipe <name-or-file>.");
+    const directory = resolve(options.directory ?? defaultInstallationDirectory);
+    await newDirectory(directory);
+    const context = await setupContext(options);
+    const inputs = new SetupInputs(directory);
+    const draft = await selectedDraft(context, context.recipeId ?? options.recipe, options, inputs);
+    const config = await validateSelections(context, draft);
+    return { directory, config, inputs };
+}
+export async function validateSelections(context, draft) {
+    if (!draft.models)
+        throw new InstallationError("invalid_configuration", "Choose --model or a recipe with a default model.");
+    if (draft.models.mode === "litellm" && !draft.models.upstreamEnvironmentFile)
+        throw new InstallationError("invalid_configuration", "Supply --llm-key-file or --provider-env-file for the selected model provider.");
+    if (draft.models.mode === "external" && !draft.models.credentialFile)
+        throw new InstallationError("invalid_configuration", "Supply --model-gateway-key-file.");
+    if (draft.access.mode === "oidc" && !draft.access.clientSecretFile)
+        throw new InstallationError("invalid_configuration", "Supply --oidc-secret-file.");
+    if (draft.exposure.mode === "https" && !draft.exposure.keyFile)
+        throw new InstallationError("invalid_configuration", "Supply --tls-key-file.");
+    if (draft.packs.length && !draft.packOperator)
+        throw new InstallationError("invalid_configuration", "Selected experimental packs require --pack-python.");
+    const config = installationSchema.parse(draft);
+    assertReleaseCapabilities(context, config);
+    const issues = await packRequirements(config);
+    if (issues.length)
+        throw new InstallationError("invalid_configuration", issues.join(" "));
+    return config;
+}
+export async function savedSetup(options) {
+    const configFile = resolve(options.directory ?? defaultInstallationDirectory, "installation.json");
+    try {
+        const config = installationSchema.parse(await readJson(configFile));
+        return { configFile, config };
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+}
+export function rejectNewSelections(options) {
+    if (options.recipe ||
+        options.cloudUrl ||
+        Object.values(selectionSchema.parse(options)).some((value) => value !== undefined))
+        throw new InstallationError("change_unsupported", "Setup is unfinished. Resume with configure --directory before changing selections.");
+}
+/** Compare accepted contents, not the private copy paths created by the menu. */
+export async function configurationChanges(before, after) {
+    const secret = async (path) => path ? fingerprint(await readInputFile(path, true)) : undefined;
+    const models = async (config) => ({
+        mode: config.models.mode,
+        catalog: await readJson(config.models.configurationFile),
+        key: await secret(config.models.mode === "litellm"
+            ? config.models.upstreamEnvironmentFile
+            : config.models.credentialFile),
+        ca: config.models.mode === "external" && config.models.caFile
+            ? fingerprint(await readInputFile(config.models.caFile))
+            : undefined,
+    });
+    const packs = async (config) => ({
+        operator: config.packOperator,
+        selections: await Promise.all(config.packs.map(async ({ bindingsFile, ...pack }) => ({
+            ...pack,
+            bindings: bindingsFile ? await readJson(bindingsFile) : undefined,
+        }))),
+    });
+    return {
+        models: !isDeepStrictEqual(await models(before), await models(after)),
+        connections: !isDeepStrictEqual(before.connections, after.connections),
+        packs: !isDeepStrictEqual(await packs(before), await packs(after)),
+    };
+}

package/scripts/installation/delete.js

@@ -0,0 +1,111 @@
+import { rm } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { z } from "zod";
+import { run } from "../deployment/process.js";
+import { readInstallationIdentity, resourceNames, withInstallationLock, } from "../deployment/state.js";
+import { InstallationError } from "./errors.js";
+import { InstallerCancelled, SectionCancelled, terminalPrompts, } from "./installer/prompts.js";
+export async function confirmDeletion(directory, options, prompts = terminalPrompts) {
+    if (options.confirmDelete !== undefined || options.acceptDataLoss) {
+        if (options.confirmDelete !== resolve(directory) || !options.acceptDataLoss)
+            throw new InstallationError("invalid_configuration", "Unattended deletion requires --confirm-delete with the exact absolute installation directory and --accept-data-loss.");
+        return;
+    }
+    if (options.json ||
+        (prompts === terminalPrompts &&
+            (!process.stdin.isTTY || !process.stdout.isTTY)))
+        throw new InstallationError("invalid_configuration", "Deletion requires two confirmations in a terminal, or --confirm-delete <absolute-installation-directory> --accept-data-loss.");
+    try {
+        if (!(await prompts.confirm(`Stop and delete the installation at ${directory}?`, false)) ||
+            !(await prompts.confirm("Permanently delete ALL installation data, including chats, files, accounts and settings stored in Docker? This cannot be undone.", false)))
+            throw new InstallerCancelled();
+    }
+    catch (error) {
+        if (error instanceof SectionCancelled)
+            throw new InstallerCancelled();
+        throw error;
+    }
+}
+/** Delete exact owned resources, including failed/partially started installations. Never prune. */
+export async function deleteInstallation(directory, signal) {
+    directory = resolve(directory);
+    return withInstallationLock(directory, async () => {
+        const state = await readInstallationIdentity(directory);
+        const names = resourceNames(state);
+        const list = async (kind, filter) => (await run("docker", [
+            kind,
+            "ls",
+            ...(kind === "container" ? ["--all"] : []),
+            "--quiet",
+            "--filter",
+            `label=${filter}`,
+        ]))
+            .trim()
+            .split("\n")
+            .filter(Boolean);
+        const label = `clawscarf.installation=${state.ownerId}`;
+        const managed = await list("container", label);
+        const containers = [
+            ...new Set([
+                ...managed,
+                ...(await list("container", `com.docker.compose.project=${names.project}`)),
+                ...(await list("container", `openshell.ai/sandbox-namespace=${names.sandbox}`)),
+            ]),
+        ];
+        // OpenShell carries its namespace rather than our installation label into Docker.
+        // Confirm its controller mount as well, before stopping or deleting anything.
+        if (containers.length) {
+            const inspected = z
+                .array(z.object({
+                Config: z.object({
+                    Labels: z.record(z.string(), z.string()).nullable(),
+                }),
+                Mounts: z.array(z.object({
+                    Type: z.string(),
+                    Source: z.string(),
+                    Destination: z.string(),
+                })),
+            }))
+                .parse(JSON.parse(await run("docker", [
+                "container",
+                "inspect",
+                "--format",
+                '{"Config":{"Labels":{{json .Config.Labels}}},"Mounts":{{json .Mounts}}}',
+                ...containers,
+            ]).then((output) => `[${output.trim().split("\n").join(",")}]`)));
+            for (const container of inspected) {
+                const labels = container.Config.Labels ?? {};
+                if (labels["clawscarf.installation"] === state.ownerId)
+                    continue;
+                if (labels["openshell.ai/managed-by"] !== "openshell" ||
+                    labels["openshell.ai/sandbox-namespace"] !== names.sandbox ||
+                    !container.Mounts.some((mount) => mount.Type === "bind" &&
+                        mount.Source === join(directory, "controller/tls/ca.crt") &&
+                        mount.Destination === "/etc/openshell/tls/client/ca.crt"))
+                    throw new InstallationError("invalid_configuration", "A matching Docker container does not belong to this installation. Nothing was deleted.");
+            }
+        }
+        const volumes = await list("volume", label);
+        const networks = await list("network", label);
+        signal?.throwIfAborted();
+        // Prevent restart after partial deletion; retain ownership records so deletion can resume.
+        await rm(join(directory, "prepared.json"), { force: true });
+        if (managed.length)
+            await run("docker", ["container", "stop", "--time", "20", ...managed], {
+                timeout: 120_000,
+            });
+        signal?.throwIfAborted();
+        if (containers.length) {
+            await run("docker", ["container", "stop", "--time", "20", ...containers], { timeout: 120_000 });
+            signal?.throwIfAborted();
+            await run("docker", ["container", "rm", ...containers]);
+        }
+        signal?.throwIfAborted();
+        if (volumes.length)
+            await run("docker", ["volume", "rm", ...volumes]);
+        signal?.throwIfAborted();
+        if (networks.length)
+            await run("docker", ["network", "rm", ...networks]);
+        return { state: "deleted", stateDirectory: directory };
+    });
+}

package/scripts/installation/doctor.js

@@ -0,0 +1,8 @@
+import { checkHost, checkInstallationPrerequisites } from "./prerequisites.js";
+import { allocatePorts, resolveInstallation } from "./resolve.js";
+export async function doctorInstallation(configFile) {
+    await checkHost();
+    const result = await checkInstallationPrerequisites(configFile);
+    await resolveInstallation(configFile, await allocatePorts());
+    return result;
+}

package/scripts/installation/errors.js

@@ -0,0 +1,8 @@
+export class InstallationError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "InstallationError";
+    }
+}

package/scripts/installation/files.js

@@ -0,0 +1,51 @@
+import { constants } from "node:fs";
+import { open } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { InstallationError } from "./errors.js";
+export function fingerprint(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+export async function readInputFile(path, secret = false) {
+    const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    try {
+        const info = await file.stat();
+        if (!info.isFile() ||
+            info.size > 8 * 1024 * 1024 ||
+            (secret && ((info.mode & 0o077) !== 0 || info.uid !== process.getuid?.())))
+            throw new InstallationError("invalid_configuration", "Configuration and release files must be bounded regular files; credentials must be private and owned by you.");
+        return await file.readFile();
+    }
+    finally {
+        await file.close();
+    }
+}
+export async function readJson(path) {
+    const input = await readInputFile(path);
+    try {
+        return JSON.parse(input.toString("utf8"));
+    }
+    catch (error) {
+        if (!(error instanceof SyntaxError))
+            throw error;
+        throw new InstallationError("invalid_configuration", `Invalid JSON in ${JSON.stringify(path)}.`);
+    }
+}
+export async function verifyReleaseTool(path, checksum) {
+    const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+        const stat = await file.stat();
+        if (!stat.isFile() || !(stat.mode & 0o111))
+            throw new InstallationError("release_mismatch", "A release tool is not an executable file.");
+        const hash = createHash("sha256");
+        for await (const chunk of file.createReadStream({ autoClose: false })) {
+            if (!Buffer.isBuffer(chunk))
+                throw Error("Invalid file stream");
+            hash.update(chunk);
+        }
+        if (hash.digest("hex") !== checksum)
+            throw new InstallationError("release_mismatch", "A release tool does not match its checksum.");
+    }
+    finally {
+        await file.close();
+    }
+}

package/scripts/installation/installer/cloud.js

@@ -0,0 +1,22 @@
+import { readInputFile } from "../files.js";
+import { styleText } from "node:util";
+import { registerCloudServices } from "../../cloud/registration.js";
+import { authorizeCloud } from "../../cloud/login.js";
+import { terminalLink, } from "./prompts.js";
+export function registerWithBrowser(configFile, ui, task, register = registerCloudServices) {
+    return task("Connecting selected cloud services", (signal) => register(configFile, (url, file, administrator) => authorizeCloud(url, file, {
+        wait: true,
+        present: async (link, code, expiresAt) => {
+            ui.note(`${administrator ? "Sign in or create an account to set up this installation and become its first administrator." : "Sign in or create an account to authorize the selected cloud services."}\n\n${terminalLink(link)}\n\nApproval code: ${code} — check that it matches the website.\n\nExpires at ${expiresAt}. Return to this terminal after approval.`, styleText(["bold", "yellow"], "ACTION REQUIRED — Sign in to ClawScarf"));
+            await ui.openBrowser(link);
+        },
+        signal,
+    })));
+}
+export async function registerUnattended(configFile, credentialFile, register = registerCloudServices) {
+    await register(configFile, async (url, file) => {
+        if (!credentialFile)
+            return authorizeCloud(url, file, { wait: false });
+        return (await readInputFile(credentialFile, true)).toString("utf8").trim();
+    });
+}

package/scripts/installation/installer/collect.js

@@ -0,0 +1,245 @@
+import { installationCatalog, readRecipe } from "../recipes/catalog.js";
+import { defaultInstallationDirectory } from "../location.js";
+import { isDeepStrictEqual } from "node:util";
+import { resolve } from "node:path";
+import { localInput } from "../../deployment/configuration.js";
+import { installationSchema, } from "../configuration.js";
+import { InstallationError } from "../errors.js";
+import { installationMenu } from "./menu.js";
+import { packRequirements } from "../requirements.js";
+import { InstallerCancelled, SectionCancelled } from "./prompts.js";
+import { SetupInputs } from "../save.js";
+import { assertReleaseCapabilities, recipeModelFile, setupContext, } from "../setup.js";
+import { absolute, field, newDirectory, inputErrorMessage } from "./inputs.js";
+import { collectAccess, collectExposure } from "./sections/access.js";
+import { collectConnections } from "./sections/connections.js";
+import { collectModels, collectModelCredentials } from "./sections/models.js";
+import { collectPacks, collectPackInputs } from "./sections/packs.js";
+import { selectedDraft } from "../options.js";
+import { installationSummary, modelSummary } from "./summary.js";
+import { secretInput } from "./secrets.js";
+import { collectExternalModels } from "./sections/external-models.js";
+import { inputFile } from "./inputs.js";
+import { collectResources } from "./sections/resources.js";
+export async function collectInstallation(ui, options, retained) {
+    const catalog = await installationCatalog();
+    const customRecipe = options.recipe?.endsWith(".json")
+        ? await readRecipe(resolve(options.recipe))
+        : undefined;
+    if (customRecipe)
+        catalog.recipes = [
+            customRecipe,
+            ...catalog.recipes.filter((recipe) => recipe.id !== customRecipe.id),
+        ];
+    let recipeId = retained
+        ? (retained.config.recipe?.id ?? "custom")
+        : options.recipe;
+    let chooseRecipe = recipeId === undefined;
+    ui.note("Esc: back · Ctrl+C: exit", "Navigation");
+    startingPoint: for (;;) {
+        let directory;
+        try {
+            if (chooseRecipe) {
+                try {
+                    recipeId = await ui.select("Starting point", [
+                        ...catalog.recipes.map((recipe) => ({
+                            value: recipe.id === customRecipe?.id
+                                ? (options.recipe ?? recipe.id)
+                                : recipe.id,
+                            label: recipe.name,
+                            hint: recipe.maturity === "example"
+                                ? "Example defaults; workflow not included"
+                                : recipe.description,
+                        })),
+                    ], recipeId);
+                }
+                catch (error) {
+                    if (error instanceof SectionCancelled)
+                        throw new InstallerCancelled();
+                    throw error;
+                }
+            }
+            directory = absolute(retained?.directory ??
+                options.directory ??
+                defaultInstallationDirectory);
+        }
+        catch (error) {
+            if (!(error instanceof SectionCancelled))
+                throw error;
+            chooseRecipe = true;
+            continue;
+        }
+        if (!options.existing)
+            await newDirectory(directory);
+        const context = await setupContext({ ...options, ...(recipeId ? { recipe: recipeId } : {}) }, options.existing ? retained?.config.releaseFile : undefined);
+        const recipe = context.recipes.find((recipe) => recipe.id === context.recipeId);
+        const selectedId = context.recipeId ?? recipeId;
+        if (selectedId === undefined)
+            throw new InstallationError("invalid_configuration", "Select a starting point.");
+        if (retained && (retained.config.recipe?.id ?? "custom") !== selectedId)
+            retained = undefined;
+        const inputs = retained?.inputs ?? new SetupInputs(directory);
+        let config = retained?.config ??
+            (await selectedDraft(context, selectedId, options, inputs));
+        if (!options.existing && config.access.mode === "hosted")
+            config.access.registrationFile = resolve(directory, "secrets/hosted-login.json");
+        const presetFile = recipe?.models
+            ? recipeModelFile(recipe.models, inputs, context.modelCatalog)
+            : undefined;
+        if (!config.models && presetFile)
+            config.models = {
+                mode: "litellm",
+                configurationFile: presetFile,
+                upstreamEnvironmentFile: "",
+            };
+        const initialConfiguration = JSON.stringify(config);
+        if (recipe)
+            ui.note(recipe.description, recipe.name);
+        for (;;) {
+            const customized = JSON.stringify(config) !== initialConfiguration;
+            const pendingPacks = await packRequirements(config);
+            let choice;
+            try {
+                choice = await ui.select(options.existing
+                    ? `${config.name} — settings`
+                    : `${recipe?.name ?? "Custom"}${customized ? " · customized" : ""} — configure installation`, installationMenu(config, directory, Boolean(context.release.images.browser), pendingPacks, await modelSummary(config, inputs), options.existing), "review");
+            }
+            catch (error) {
+                if (!(error instanceof SectionCancelled))
+                    throw error;
+                if (options.existing)
+                    throw new InstallerCancelled();
+                retained = { directory, config, inputs };
+                chooseRecipe = true;
+                continue startingPoint;
+            }
+            const previousInputs = new Map(inputs.files);
+            const previousConfig = structuredClone(config);
+            const previousDirectory = directory;
+            try {
+                switch (choice) {
+                    case "location": {
+                        const next = absolute(await ui.text("New installation directory", directory));
+                        await newDirectory(next);
+                        directory = next;
+                        break;
+                    }
+                    case "identity": {
+                        const name = await field(ui, "Installation name", localInput.shape.name, config.name);
+                        const administratorName = await field(ui, "Administrator display name", localInput.shape.administratorName, config.access.administratorName);
+                        config = {
+                            ...config,
+                            name,
+                            access: { ...config.access, administratorName },
+                        };
+                        break;
+                    }
+                    case "exposure":
+                        config.exposure = await collectExposure(ui, config);
+                        break;
+                    case "access":
+                        config = {
+                            ...config,
+                            ...(await collectAccess(ui, config, context.cloudUrl)),
+                        };
+                        break;
+                    case "models":
+                        config.models = await collectModels(ui, context.modelCatalog, config.models, inputs, presetFile, options.existing);
+                        break;
+                    case "model-credentials":
+                        if (!config.models)
+                            throw new InstallationError("invalid_configuration", "Select a model first.");
+                        config.models = await collectModelCredentials(ui, config.models.mode === "litellm"
+                            ? { ...config.models, upstreamEnvironmentFile: "" }
+                            : { ...config.models, credentialFile: "" }, inputs);
+                        break;
+                    case "connections":
+                        config.connections = await collectConnections(ui, config.connections);
+                        break;
+                    case "advanced-models": {
+                        const file = await inputFile(ui, "Model catalog file", false);
+                        const mode = await ui.select("Model gateway", [
+                            { value: "bundled", label: "Run with this installation" },
+                            { value: "external", label: "Existing LiteLLM gateway" },
+                        ], "bundled");
+                        config.models =
+                            mode === "external"
+                                ? await collectExternalModels(ui, inputs, file, config.models)
+                                : {
+                                    mode: "litellm",
+                                    configurationFile: file,
+                                    upstreamEnvironmentFile: "",
+                                };
+                        break;
+                    }
+                    case "resources":
+                        config.resources = await collectResources(ui, config.resources);
+                        break;
+                    case "browser":
+                        ui.note("Explicit browser node use works. Ordinary model-selected browsing is not qualified because of an upstream routing issue.", "Experimental browser");
+                        config.browser.enabled =
+                            (await ui.select("Browser", [
+                                { value: "off", label: "Off" },
+                                { value: "on", label: "On (experimental)" },
+                            ], config.browser.enabled ? "on" : "off")) === "on";
+                        break;
+                    case "packs": {
+                        const selection = await collectPacks(ui, config.models, config.connections, config, context.packs);
+                        if (!options.existing)
+                            delete config.packOperator;
+                        config = { ...config, ...selection };
+                        break;
+                    }
+                    case "review": {
+                        if (!config.models)
+                            config.models = await collectModels(ui, context.modelCatalog, undefined, inputs, presetFile, options.existing);
+                        ui.note(await installationSummary(config, inputs), "Selected settings");
+                        config.models = await collectModelCredentials(ui, config.models, inputs);
+                        if (config.exposure.mode === "https" && !config.exposure.keyFile)
+                            config.exposure.keyFile = await inputFile(ui, "TLS private key file", true);
+                        if (config.access.mode === "oidc" &&
+                            !config.access.clientSecretFile)
+                            config.access.clientSecretFile = await secretInput(ui, inputs, "OIDC client secret", "oidc-client-secret");
+                        config = { ...config, ...(await collectPackInputs(ui, config)) };
+                        if (config.access.mode === "hosted" && !options.existing) {
+                            config.access.registrationFile = resolve(directory, "secrets/hosted-login.json");
+                        }
+                        if (!options.existing) {
+                            config.connections.registrationFile = resolve(directory, "secrets/connections-registration.json");
+                        }
+                        const parsed = installationSchema.parse(config);
+                        assertReleaseCapabilities(context, parsed);
+                        const issues = await packRequirements(parsed);
+                        if (issues.length) {
+                            ui.note(issues.join("\n"), "Packs need attention");
+                            continue;
+                        }
+                        return { directory, config: parsed, inputs };
+                    }
+                    default:
+                        throw new InstallationError("invalid_configuration", "Select an installation section.");
+                }
+                if ((!isDeepStrictEqual(config, previousConfig) ||
+                    directory !== previousDirectory ||
+                    !isDeepStrictEqual(inputs.files, previousInputs)) &&
+                    !(await ui.confirm("Save section changes?")))
+                    throw new SectionCancelled();
+            }
+            catch (error) {
+                if (error instanceof InstallerCancelled)
+                    throw error;
+                config = previousConfig;
+                directory = previousDirectory;
+                inputs.files.clear();
+                for (const [path, bytes] of previousInputs)
+                    inputs.files.set(path, bytes);
+                if (error instanceof SectionCancelled)
+                    continue;
+                const message = inputErrorMessage(error);
+                if (!message)
+                    throw error;
+                ui.note(message, "Section needs attention");
+            }
+        }
+    }
+}

package/scripts/installation/installer/inputs.js

@@ -0,0 +1,59 @@
+import { lstat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { ZodError } from "zod";
+import { readInputFile } from "../files.js";
+import { InstallationError } from "../errors.js";
+export function absolute(value) {
+    return resolve(value.startsWith("~/") ? join(homedir(), value.slice(2)) : value);
+}
+export async function newDirectory(path) {
+    try {
+        await lstat(path);
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return;
+        throw error;
+    }
+    throw new InstallationError("change_unsupported", "This directory already exists and is not a recognized installation. Choose a new directory; configure never overwrites unrelated files.");
+}
+export async function field(ui, message, schema, initial) {
+    const value = await ui.text(message, initial, (input) => {
+        const result = schema.safeParse(input);
+        return result.success ? undefined : result.error.issues[0]?.message;
+    });
+    return schema.parse(value);
+}
+export async function inputFile(ui, message, secret = false, initial) {
+    const value = await ui.text(message, initial, async (input) => {
+        if (!input.trim())
+            return "Enter a file path.";
+        try {
+            await readInputFile(absolute(input), secret);
+        }
+        catch (error) {
+            if (!inputErrorMessage(error))
+                throw error;
+            return secret
+                ? "Use a private regular file owned by you (chmod 600)."
+                : "Use an existing regular file (up to 8 MiB).";
+        }
+    });
+    const path = absolute(value);
+    await readInputFile(path, secret);
+    return path;
+}
+/** Recover only invalid input and file access failures; programming errors must escape. */
+export function inputErrorMessage(error) {
+    if (error instanceof InstallationError)
+        return error.message;
+    if (error instanceof ZodError)
+        return "Check the selected configuration fields and their supported values.";
+    if (error instanceof SyntaxError ||
+        (error instanceof Error &&
+            "code" in error &&
+            ["ENOENT", "EACCES", "EPERM", "ENOTDIR", "EISDIR", "ELOOP"].includes(String(error.code))))
+        return "Could not read the selected inputs. Check their paths, contents and permissions.";
+    return undefined;
+}