@tolinax/ayoune-cli 2026.9.0 → 2026.10.0

package/lib/commands/provision/gcp.js

@@ -0,0 +1,118 @@
+// `ay provision gcp` — deploy aYOUne to Google Kubernetes Engine via the
+// marketplace gke-app spec at infrastructure/marketplace/gcp/gke-app.yaml.
+import path from "path";
+import { existsSync } from "fs";
+import chalk from "chalk";
+import { spawn } from "child_process";
+import { spinner } from "../../../index.js";
+import { cliError } from "../../helpers/cliError.js";
+import { EXIT_GENERAL_ERROR } from "../../exitCodes.js";
+import { requireTool } from "./_detectTools.js";
+import { runBaseWizard } from "./_wizard.js";
+import { writeState } from "./_stateFile.js";
+const GCP_REGIONS = ["us-central1", "us-east1", "europe-west1", "europe-west3", "asia-southeast1"];
+const GKE_MACHINE_TYPES = ["e2-standard-2", "e2-standard-4", "n2-standard-4", "n2-standard-8"];
+function streamCmd(cmd, args) {
+    return new Promise((resolve) => {
+        const child = spawn(cmd, args, {
+            stdio: "inherit",
+            shell: process.platform === "win32",
+        });
+        child.on("exit", (code) => resolve(code !== null && code !== void 0 ? code : 0));
+        child.on("error", () => resolve(1));
+    });
+}
+export function addGcpSubcommand(prov) {
+    prov
+        .command("gcp")
+        .description("Provision aYOUne to Google Kubernetes Engine")
+        .option("--project <id>", "GCP project ID")
+        .option("--cluster <name>", "GKE cluster name", "ayoune")
+        .option("--region <region>", "GCP region")
+        .option("--dry-run", "Print the commands without running them", false)
+        .action(async (options) => {
+        var _a, _b;
+        try {
+            requireTool("gcloud");
+            const spec = findMarketplaceFile("gcp", "gke-app.yaml");
+            if (!spec) {
+                cliError("Could not find infrastructure/marketplace/gcp/gke-app.yaml — run from the monorepo.", EXIT_GENERAL_ERROR);
+            }
+            const base = await runBaseWizard({
+                regionChoices: GCP_REGIONS,
+                defaultRegion: (_a = options.region) !== null && _a !== void 0 ? _a : "europe-west1",
+                instanceChoices: GKE_MACHINE_TYPES,
+                defaultInstance: "e2-standard-4",
+            });
+            const inquirer = (await import("inquirer")).default;
+            const projectAns = await inquirer.prompt([
+                {
+                    type: "input",
+                    name: "project",
+                    message: "GCP project ID:",
+                    default: options.project,
+                    when: !options.project,
+                    validate: (v) => v.length > 0 || "Required",
+                },
+            ]);
+            const project = (_b = options.project) !== null && _b !== void 0 ? _b : projectAns.project;
+            const createCmd = [
+                "container",
+                "clusters",
+                "create",
+                options.cluster,
+                "--region",
+                base.region,
+                "--project",
+                project,
+                "--machine-type",
+                base.instanceSize,
+                "--num-nodes",
+                "3",
+                "--release-channel",
+                "regular",
+            ];
+            if (options.dryRun) {
+                console.log(chalk.yellow("\n  --dry-run set — would run:"));
+                console.log(chalk.dim(`    gcloud ${createCmd.join(" ")}`));
+                console.log(chalk.dim(`    kubectl apply -f ${spec}`));
+                return;
+            }
+            spinner.start({ text: `Creating GKE cluster ${options.cluster}...`, color: "cyan" });
+            const clusterCode = await streamCmd("gcloud", createCmd);
+            if (clusterCode !== 0)
+                cliError("Cluster creation failed", EXIT_GENERAL_ERROR);
+            spinner.success({ text: "Cluster ready" });
+            spinner.start({ text: "Applying GKE app spec...", color: "cyan" });
+            const applyCode = await streamCmd("kubectl", ["apply", "-f", spec]);
+            if (applyCode !== 0)
+                cliError("kubectl apply failed", EXIT_GENERAL_ERROR);
+            spinner.success({ text: "App deployed" });
+            const file = await writeState({
+                provider: "gcp",
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                region: base.region,
+                domain: base.domain,
+                modules: base.modules,
+                params: { project, cluster: options.cluster, machineType: base.instanceSize },
+            });
+            console.log(chalk.dim(`  State file: ${file}`));
+        }
+        catch (e) {
+            cliError(e.message || "GCP provisioning failed", EXIT_GENERAL_ERROR);
+        }
+    });
+}
+function findMarketplaceFile(provider, file) {
+    let dir = process.cwd();
+    while (true) {
+        const candidate = path.join(dir, "infrastructure", "marketplace", provider, file);
+        if (existsSync(candidate))
+            return candidate;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}

package/lib/commands/provision/hetzner.js

@@ -0,0 +1,220 @@
+// `ay provision hetzner` — provision aYOUne to Hetzner Cloud via Terraform.
+//
+// Wraps `infrastructure/marketplace/hetzner/terraform/`. Steps:
+//   1. Verify terraform is installed.
+//   2. Run the shared wizard for domain/license/modules/region/instance.
+//   3. Ask for the Hetzner-specific Cloud API token + node count.
+//   4. Render a `terraform.tfvars` from the answers in a temp working dir
+//      (we copy the marketplace terraform files there to avoid polluting
+//      the monorepo's existing tfstate).
+//   5. Run `terraform init && terraform plan` (always) and `terraform apply`
+//      (unless --dry-run).
+//   6. Capture `terraform output -json` and write provision state.
+import path from "path";
+import os from "os";
+import { mkdir, writeFile, copyFile, readdir } from "fs/promises";
+import { existsSync } from "fs";
+import chalk from "chalk";
+import { spinner } from "../../../index.js";
+import { cliError } from "../../helpers/cliError.js";
+import { EXIT_GENERAL_ERROR } from "../../exitCodes.js";
+import { runCommand } from "../../helpers/dockerCompose.js";
+import { requireTool } from "./_detectTools.js";
+import { runBaseWizard } from "./_wizard.js";
+import { writeState } from "./_stateFile.js";
+import { spawn } from "child_process";
+const HETZNER_REGIONS = ["nbg1", "fsn1", "hel1", "ash", "hil", "sin"];
+const HETZNER_INSTANCE_SIZES = ["cax21", "cax31", "cax41", "ccx13", "ccx23", "ccx33"];
+/** Stream a command (NOT docker compose) to the user's terminal. */
+function streamCmd(cmd, args, cwd) {
+    return new Promise((resolve) => {
+        const child = spawn(cmd, args, {
+            cwd,
+            stdio: "inherit",
+            shell: process.platform === "win32",
+        });
+        child.on("exit", (code) => resolve(code !== null && code !== void 0 ? code : 0));
+        child.on("error", () => resolve(1));
+    });
+}
+export function addHetznerSubcommand(prov) {
+    prov
+        .command("hetzner")
+        .description("Provision aYOUne on Hetzner Cloud via Terraform")
+        .option("--token <token>", "Hetzner Cloud API token (or set HCLOUD_TOKEN)")
+        .option("--region <region>", `Hetzner location (${HETZNER_REGIONS.join(", ")})`, "nbg1")
+        .option("--size <size>", `Server type (${HETZNER_INSTANCE_SIZES.join(", ")})`, "cax21")
+        .option("--servers <n>", "Number of worker nodes", (v) => parseInt(v, 10), 3)
+        .option("--dry-run", "Render terraform.tfvars and run `terraform plan` only", false)
+        .option("-y, --yes", "Skip the final apply confirmation prompt", false)
+        .action(async (options) => {
+        var _a;
+        try {
+            requireTool("terraform");
+            const sourceDir = findHetznerTerraformDir();
+            if (!sourceDir) {
+                cliError("Could not locate infrastructure/marketplace/hetzner/terraform/ — run from the monorepo or use `ay setup` first.", EXIT_GENERAL_ERROR);
+            }
+            // Wizard for the cross-cutting params.
+            const base = await runBaseWizard({
+                defaultRegion: options.region,
+                regionChoices: HETZNER_REGIONS,
+                defaultInstance: options.size,
+                instanceChoices: HETZNER_INSTANCE_SIZES,
+            });
+            // Hetzner-specific.
+            const inquirer = (await import("inquirer")).default;
+            const hcloudToken = options.token || process.env.HCLOUD_TOKEN;
+            const extra = await inquirer.prompt([
+                {
+                    type: "password",
+                    name: "hcloudToken",
+                    message: "Hetzner Cloud API token:",
+                    default: hcloudToken,
+                    when: !hcloudToken,
+                    validate: (v) => v.length > 10 || "Token required",
+                },
+                {
+                    type: "number",
+                    name: "serverCount",
+                    message: "Number of worker nodes:",
+                    default: options.servers,
+                },
+            ]);
+            const token = hcloudToken || extra.hcloudToken;
+            const serverCount = (_a = extra.serverCount) !== null && _a !== void 0 ? _a : options.servers;
+            // Build a fresh working dir under ~/.ayoune/provision/hetzner-<ts>/.
+            const workDir = path.join(os.homedir(), ".ayoune", "provision", `hetzner-${Date.now()}`);
+            await mkdir(workDir, { recursive: true });
+            spinner.start({ text: "Copying Terraform module...", color: "cyan" });
+            await copyTerraformFiles(sourceDir, workDir);
+            const tfvars = renderTfvars({
+                token,
+                region: base.region,
+                instanceSize: base.instanceSize,
+                serverCount,
+                domain: base.domain,
+                contactEmail: base.contactEmail,
+                modules: base.modules,
+                licenseKey: base.licenseKey,
+            });
+            await writeFile(path.join(workDir, "terraform.tfvars"), tfvars, "utf-8");
+            spinner.success({ text: `Working dir ready: ${workDir}` });
+            // terraform init
+            spinner.start({ text: "Running `terraform init`...", color: "cyan" });
+            const initCode = await streamCmd("terraform", ["init", "-input=false"], workDir);
+            if (initCode !== 0)
+                cliError("terraform init failed", EXIT_GENERAL_ERROR);
+            spinner.success({ text: "Terraform initialized" });
+            // terraform plan
+            spinner.start({ text: "Running `terraform plan`...", color: "cyan" });
+            const planCode = await streamCmd("terraform", ["plan", "-input=false", "-out=tfplan"], workDir);
+            if (planCode !== 0)
+                cliError("terraform plan failed", EXIT_GENERAL_ERROR);
+            spinner.success({ text: "Plan generated" });
+            if (options.dryRun) {
+                console.log(chalk.yellow("\n  --dry-run set — skipping `terraform apply`."));
+                console.log(chalk.dim(`  To apply later: cd ${workDir} && terraform apply tfplan\n`));
+                return;
+            }
+            if (!options.yes) {
+                const { ok } = await inquirer.prompt([
+                    {
+                        type: "confirm",
+                        name: "ok",
+                        message: "Apply the plan now? (this will create real cloud resources)",
+                        default: false,
+                    },
+                ]);
+                if (!ok) {
+                    console.log(chalk.dim("  Aborted. Working dir kept at " + workDir));
+                    return;
+                }
+            }
+            // terraform apply
+            spinner.start({ text: "Running `terraform apply`...", color: "cyan" });
+            const applyCode = await streamCmd("terraform", ["apply", "-input=false", "tfplan"], workDir);
+            if (applyCode !== 0)
+                cliError("terraform apply failed", EXIT_GENERAL_ERROR);
+            spinner.success({ text: "Apply complete" });
+            // Capture outputs.
+            const outputsRaw = runCommand("terraform output -json", { cwd: workDir, silent: false });
+            let outputs = {};
+            try {
+                outputs = JSON.parse(outputsRaw);
+            }
+            catch (_b) {
+                outputs = { raw: outputsRaw };
+            }
+            const file = await writeState({
+                provider: "hetzner",
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                region: base.region,
+                domain: base.domain,
+                modules: base.modules,
+                outputs,
+                params: {
+                    workDir,
+                    instanceSize: base.instanceSize,
+                    serverCount,
+                },
+            });
+            console.log(chalk.green("\n  aYOUne deployed to Hetzner Cloud!"));
+            console.log(chalk.dim(`  State file: ${file}`));
+            console.log(chalk.dim(`  Working dir: ${workDir}`));
+            console.log(chalk.dim("  Next: point your domain at the load balancer IP from the outputs."));
+        }
+        catch (e) {
+            cliError(e.message || "Hetzner provisioning failed", EXIT_GENERAL_ERROR);
+        }
+    });
+}
+function findHetznerTerraformDir() {
+    // Walk up looking for infrastructure/marketplace/hetzner/terraform/main.tf.
+    let dir = process.cwd();
+    while (true) {
+        const candidate = path.join(dir, "infrastructure", "marketplace", "hetzner", "terraform", "main.tf");
+        if (existsSync(candidate))
+            return path.dirname(candidate);
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+async function copyTerraformFiles(srcDir, destDir) {
+    const entries = await readdir(srcDir, { withFileTypes: true });
+    for (const entry of entries) {
+        // Skip state, plans, and credentials — those are per-deployment.
+        if (entry.name.endsWith(".tfstate") ||
+            entry.name.endsWith(".tfstate.backup") ||
+            entry.name === "tfplan" ||
+            entry.name === "tfplan-lb" ||
+            entry.name === "terraform.tfvars" ||
+            entry.name === "gar-key.json" ||
+            entry.name === "kubeconfig.yaml" ||
+            entry.name === ".terraform" ||
+            entry.isDirectory()) {
+            continue;
+        }
+        await copyFile(path.join(srcDir, entry.name), path.join(destDir, entry.name));
+    }
+}
+function renderTfvars(input) {
+    const lines = [
+        `# Generated by \`ay provision hetzner\` on ${new Date().toISOString()}`,
+        `hcloud_token       = "${escape(input.token)}"`,
+        `location           = "${input.region}"`,
+        `server_type        = "${input.instanceSize}"`,
+        `server_count       = ${input.serverCount}`,
+        `domain             = "${input.domain}"`,
+        `contact_email      = "${input.contactEmail}"`,
+        `license_key        = "${escape(input.licenseKey)}"`,
+        `modules            = [${input.modules.map((m) => `"${m}"`).join(", ")}]`,
+    ];
+    return lines.join("\n") + "\n";
+}
+function escape(v) {
+    return v.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}

package/lib/commands/provision/index.js

@@ -0,0 +1,44 @@
+// `ay provision` parent command — wraps the provider templates in
+// `infrastructure/marketplace/{aws,gcp,azure,digitalocean,hetzner}/` so
+// end-customers can deploy aYOUne to a cloud account from a single CLI.
+//
+// Each provider has different artefacts (CloudFormation, ARM, Helm app spec,
+// Terraform), so we use a thin provider-strategy pattern: each `*.ts` file
+// in this directory exports `addXxxSubcommand(provision, root)` that knows
+// how to invoke the provider-native binary against the relevant template.
+//
+// The CLI does NOT bundle aws-cli / gcloud / az / doctl / terraform — it
+// detects them via `_detectTools.ts` and prints install instructions if
+// missing. Provision state (parameters, outputs) is persisted to
+// `~/.ayoune/provision/<provider>.json` via `_stateFile.ts` so `status` and
+// `destroy` can find their way back without re-prompting.
+import { addHetznerSubcommand } from "./hetzner.js";
+import { addAwsSubcommand } from "./aws.js";
+import { addGcpSubcommand } from "./gcp.js";
+import { addAzureSubcommand } from "./azure.js";
+import { addDigitalOceanSubcommand } from "./digitalocean.js";
+import { addStatusSubcommand } from "./status.js";
+import { addDestroySubcommand } from "./destroy.js";
+export function createProvisionCommand(program) {
+    const prov = program
+        .command("provision")
+        .alias("prov")
+        .description("Provision aYOUne to a cloud provider (AWS / GCP / Azure / DigitalOcean / Hetzner)")
+        .addHelpText("after", `
+Examples:
+  ay provision hetzner                Wizard: provision aYOUne on Hetzner Cloud (Terraform)
+  ay provision aws --dry-run          Wizard: preview AWS CloudFormation deployment
+  ay provision gcp                    Wizard: deploy to Google Kubernetes Engine
+  ay provision azure                  Wizard: deploy via ARM template
+  ay provision digitalocean           Wizard: deploy via App Platform spec
+  ay provision status hetzner         Show current provisioning state
+  ay provision destroy hetzner        Tear down a provisioned environment`);
+    addHetznerSubcommand(prov);
+    addAwsSubcommand(prov);
+    addGcpSubcommand(prov);
+    addAzureSubcommand(prov);
+    addDigitalOceanSubcommand(prov);
+    addStatusSubcommand(prov);
+    addDestroySubcommand(prov);
+}
+export default createProvisionCommand;

package/lib/commands/provision/status.js

@@ -0,0 +1,44 @@
+// `ay provision status [provider]` — show provisioning state for one or
+// every provider, read from `~/.ayoune/provision/<provider>.json`.
+import chalk from "chalk";
+import { cliError } from "../../helpers/cliError.js";
+import { EXIT_GENERAL_ERROR } from "../../exitCodes.js";
+import { readState } from "./_stateFile.js";
+const PROVIDERS = ["hetzner", "aws", "gcp", "azure", "digitalocean"];
+export function addStatusSubcommand(prov) {
+    prov
+        .command("status [provider]")
+        .description("Show provisioning state for one or all providers")
+        .action(async (provider) => {
+        var _a, _b, _c;
+        try {
+            const targets = provider
+                ? [provider]
+                : PROVIDERS;
+            let any = false;
+            for (const p of targets) {
+                const state = await readState(p);
+                if (!state)
+                    continue;
+                any = true;
+                console.log("");
+                console.log(chalk.cyan.bold(`  ${p}`));
+                console.log(chalk.dim(`    domain:     ${(_a = state.domain) !== null && _a !== void 0 ? _a : "?"}`));
+                console.log(chalk.dim(`    region:     ${(_b = state.region) !== null && _b !== void 0 ? _b : "?"}`));
+                console.log(chalk.dim(`    modules:    ${((_c = state.modules) !== null && _c !== void 0 ? _c : []).join(", ") || "?"}`));
+                console.log(chalk.dim(`    created:    ${state.createdAt}`));
+                console.log(chalk.dim(`    updated:    ${state.updatedAt}`));
+                if (state.params) {
+                    console.log(chalk.dim(`    params:     ${JSON.stringify(state.params)}`));
+                }
+            }
+            if (!any) {
+                console.log(chalk.yellow(`\n  No provisioning state found${provider ? ` for "${provider}"` : ""}.`));
+                console.log(chalk.dim("  Run `ay provision <provider>` to provision a new environment.\n"));
+            }
+        }
+        catch (e) {
+            cliError(e.message || "Failed to read provisioning state", EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/helpers/dockerCompose.js

@@ -0,0 +1,143 @@
+// Cross-platform Docker Compose helper.
+//
+// Two consumers today: `ay self-host-update` (compose vs k8s detection +
+// pull/up loops) and `ay local` (the new dev-environment wrapper that
+// replaces `infrastructure/local/dev.ps1`). Both need the same primitives:
+//   - run a shell command and capture stdout (`runCommand`)
+//   - detect whether we're on a docker-compose host or a kubernetes host
+//     (`detectRuntime`)
+//   - run docker compose with the right base flags (`runCompose`,
+//     `streamCompose`)
+//
+// `ay local` always passes through the project's `infrastructure/local/`
+// override files when run from inside the monorepo, so the same `dev.ps1`
+// composition is reproduced on macOS/Linux without any PowerShell. When run
+// outside the monorepo (i.e. an end-user's customer install), it falls back
+// to the local directory's `docker-compose.yml`.
+import { execSync, spawn } from "child_process";
+import { existsSync } from "fs";
+import path from "path";
+/**
+ * Run a shell command synchronously and return its trimmed stdout.
+ * Returns "" on failure when `silent` is true (the default), so callers can
+ * use truthiness to detect "command available / command produced output".
+ */
+export function runCommand(cmd, opts = {}) {
+    const { cwd, timeout = 30000, silent = true } = opts;
+    try {
+        return execSync(cmd, { encoding: "utf-8", timeout, cwd }).trim();
+    }
+    catch (e) {
+        if (silent)
+            return "";
+        throw e;
+    }
+}
+/**
+ * Detect what self-hosting runtime is available on this machine.
+ * Prefers Docker Compose, falls back to Kubernetes (kubectl), then unknown.
+ */
+export function detectRuntime() {
+    const composeResult = runCommand("docker compose version 2>&1");
+    if (composeResult.includes("Docker Compose"))
+        return "compose";
+    const kubectlResult = runCommand("kubectl version --client 2>&1");
+    if (kubectlResult.includes("Client Version"))
+        return "kubernetes";
+    return "unknown";
+}
+/**
+ * Locate the monorepo's `infrastructure/local/` directory by walking up from
+ * `start`. Returns null when not found (i.e. the user is running `ay local`
+ * from outside the monorepo on a customer install — in that case we just use
+ * the current directory's docker-compose.yml).
+ */
+export function findLocalInfraDir(start = process.cwd()) {
+    let dir = path.resolve(start);
+    while (true) {
+        const candidate = path.join(dir, "infrastructure", "local", "docker-compose.local.yml");
+        if (existsSync(candidate))
+            return path.dirname(candidate);
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+/**
+ * Build a ComposeContext that mirrors what `infrastructure/local/dev.ps1`
+ * passes to `docker compose`. Returns null when no monorepo infra dir is
+ * found — caller decides whether to fall back to plain `docker compose` in
+ * the current directory or to error out.
+ */
+export function resolveLocalContext(start = process.cwd()) {
+    const localDir = findLocalInfraDir(start);
+    if (!localDir)
+        return null;
+    const rootDir = path.resolve(localDir, "..", "..");
+    const files = [
+        path.join(rootDir, "docker-compose.yml"),
+        path.join(localDir, "docker-compose.local.yml"),
+    ].filter((f) => existsSync(f));
+    const devActive = path.join(localDir, "docker-compose.dev-active.yml");
+    if (existsSync(devActive))
+        files.push(devActive);
+    const envFile = path.join(localDir, ".env.local");
+    return {
+        projectName: "ayoune",
+        cwd: rootDir,
+        files,
+        envFile: existsSync(envFile) ? envFile : undefined,
+    };
+}
+/**
+ * Build the array of args that prefix every `docker compose` invocation
+ * (project name, -f files, --env-file). Used by both runCompose and streamCompose.
+ */
+export function buildComposeBaseArgs(ctx) {
+    const args = [];
+    if (ctx.projectName)
+        args.push("-p", ctx.projectName);
+    for (const file of ctx.files)
+        args.push("-f", file);
+    if (ctx.envFile)
+        args.push("--env-file", ctx.envFile);
+    return args;
+}
+/**
+ * Run `docker compose <args>` synchronously, returning trimmed stdout.
+ * Used for short non-streaming commands (ps, pull --dry-run, etc.).
+ */
+export function runCompose(ctx, args, opts = {}) {
+    const base = buildComposeBaseArgs(ctx);
+    const cmd = ["docker", "compose", ...base, ...args].map(shellQuote).join(" ");
+    return runCommand(cmd, { cwd: ctx.cwd, ...opts });
+}
+/**
+ * Stream `docker compose <args>` to the user's terminal (inherits stdio).
+ * Resolves with the exit code so callers can decide whether to spinner.error.
+ * Used for long-running interactive commands (up, down, logs -f, exec).
+ */
+export function streamCompose(ctx, args, opts = {}) {
+    const base = buildComposeBaseArgs(ctx);
+    return new Promise((resolve) => {
+        const child = spawn("docker", ["compose", ...base, ...args], {
+            cwd: ctx.cwd,
+            stdio: "inherit",
+            shell: process.platform === "win32",
+            ...opts.extraSpawnOptions,
+        });
+        child.on("exit", (code) => resolve(code !== null && code !== void 0 ? code : 0));
+        child.on("error", () => resolve(1));
+    });
+}
+/**
+ * Quote a single shell token. Whitespace, quotes, glob characters trigger
+ * double-quoting; we keep the quoting cheap because docker compose paths and
+ * profile names are tame in practice.
+ */
+function shellQuote(token) {
+    if (/^[A-Za-z0-9_./:=@+-]+$/.test(token))
+        return token;
+    return `"${token.replace(/"/g, '\\"')}"`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tolinax/ayoune-cli",
-  "version": "2026.9.0",
+  "version": "2026.10.0",
   "description": "CLI for the aYOUne Business-as-a-Service platform",
   "type": "module",
   "main": "./index.js",