@tolinax/ayoune-cli 2026.9.0 → 2026.10.0

package/lib/commands/functions/list.js

@@ -0,0 +1,41 @@
+// `ay functions list` — list user functions for the current customer.
+import { spinner } from "../../../index.js";
+import { apiCallHandler } from "../../api/apiCallHandler.js";
+import { handleResponseFormatOptions } from "../../helpers/handleResponseFormatOptions.js";
+import { cliError } from "../../helpers/cliError.js";
+import { EXIT_GENERAL_ERROR } from "../../exitCodes.js";
+import { FN_MODULE, FN_COLLECTION } from "./_shared.js";
+export function addListSubcommand(fns, rootProgram) {
+    fns
+        .command("list")
+        .alias("ls")
+        .description("List user functions for the current customer")
+        .option("-l, --limit <n>", "Limit results", (v) => parseInt(v, 10), 50)
+        .option("-p, --page <n>", "Page number", (v) => parseInt(v, 10), 1)
+        .option("--trigger <type>", "Filter by trigger type (cron, http, event, manual, queue)")
+        .option("--search <q>", "Search by name or slug")
+        .action(async (options) => {
+        var _a, _b, _c, _d, _e;
+        try {
+            const opts = { ...rootProgram.opts(), ...options };
+            spinner.start({ text: "Fetching functions...", color: "cyan" });
+            const params = {
+                page: opts.page,
+                limit: opts.limit,
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+            };
+            if (opts.trigger)
+                params.triggerType = opts.trigger;
+            if (opts.search)
+                params.q = opts.search;
+            const res = await apiCallHandler(FN_MODULE, FN_COLLECTION, "get", null, params);
+            handleResponseFormatOptions(opts, res);
+            const total = (_e = (_c = (_b = (_a = res === null || res === void 0 ? void 0 : res.meta) === null || _a === void 0 ? void 0 : _a.pageInfo) === null || _b === void 0 ? void 0 : _b.totalEntries) !== null && _c !== void 0 ? _c : (_d = res === null || res === void 0 ? void 0 : res.payload) === null || _d === void 0 ? void 0 : _d.length) !== null && _e !== void 0 ? _e : 0;
+            spinner.success({ text: `Found ${total} function${total === 1 ? "" : "s"}` });
+        }
+        catch (e) {
+            cliError(e.message || "Failed to list functions", EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/functions/logs.js

@@ -0,0 +1,76 @@
+// `ay functions logs <id-or-slug>` — fetch execution logs.
+//
+// Hits `GET /userfunctions/:id/logs?limit=...`. With `--follow`, polls every
+// 2s and prints any new entries (poor-man's tail -f — the API doesn't expose
+// SSE for function logs yet).
+import chalk from "chalk";
+import { spinner } from "../../../index.js";
+import { apiCallHandler } from "../../api/apiCallHandler.js";
+import { handleResponseFormatOptions } from "../../helpers/handleResponseFormatOptions.js";
+import { cliError } from "../../helpers/cliError.js";
+import { EXIT_GENERAL_ERROR } from "../../exitCodes.js";
+import { FN_MODULE, FN_COLLECTION, resolveFunction } from "./_shared.js";
+function printLogLines(entries) {
+    var _a, _b, _c, _d, _e;
+    for (const entry of entries) {
+        const ts = (_b = (_a = entry.createdAt) !== null && _a !== void 0 ? _a : entry.timestamp) !== null && _b !== void 0 ? _b : "";
+        const level = ((_c = entry.level) !== null && _c !== void 0 ? _c : "info").toUpperCase();
+        const color = level === "ERROR" ? chalk.red : level === "WARN" ? chalk.yellow : chalk.dim;
+        const message = (_e = (_d = entry.message) !== null && _d !== void 0 ? _d : entry.text) !== null && _e !== void 0 ? _e : JSON.stringify(entry);
+        console.log(`${chalk.dim(ts)} ${color(level.padEnd(5))} ${message}`);
+    }
+}
+export function addLogsSubcommand(fns, rootProgram) {
+    fns
+        .command("logs <id-or-slug>")
+        .description("Show execution logs for a function")
+        .option("-f, --follow", "Poll for new log entries every 2s", false)
+        .option("-t, --tail <n>", "Number of recent entries to show", (v) => parseInt(v, 10), 50)
+        .option("--json", "Output raw JSON instead of formatted lines", false)
+        .action(async (idOrSlug, options) => {
+        var _a;
+        try {
+            const opts = { ...rootProgram.opts(), ...options };
+            spinner.start({ text: `Resolving ${idOrSlug}...`, color: "cyan" });
+            const fn = await resolveFunction(idOrSlug);
+            spinner.stop();
+            const fetchLogs = async (since) => {
+                const params = { limit: options.tail };
+                if (since)
+                    params.since = since;
+                const res = await apiCallHandler(FN_MODULE, `${FN_COLLECTION}/${fn._id}/logs`, "get", null, params);
+                return Array.isArray(res === null || res === void 0 ? void 0 : res.payload) ? res.payload : [];
+            };
+            const initial = await fetchLogs();
+            if (options.json) {
+                handleResponseFormatOptions(opts, { payload: initial, meta: {} });
+                if (!options.follow)
+                    return;
+            }
+            else {
+                printLogLines(initial);
+            }
+            if (!options.follow)
+                return;
+            let lastSeen = initial.length > 0 ? initial[initial.length - 1].createdAt : new Date().toISOString();
+            // Plain polling loop. Ctrl-C exits the process.
+            while (true) {
+                await new Promise((r) => setTimeout(r, 2000));
+                const fresh = await fetchLogs(lastSeen);
+                if (fresh.length > 0) {
+                    if (options.json) {
+                        for (const entry of fresh)
+                            console.log(JSON.stringify(entry));
+                    }
+                    else {
+                        printLogLines(fresh);
+                    }
+                    lastSeen = (_a = fresh[fresh.length - 1].createdAt) !== null && _a !== void 0 ? _a : lastSeen;
+                }
+            }
+        }
+        catch (e) {
+            cliError(e.message || "Failed to fetch logs", EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/functions/rollback.js

@@ -0,0 +1,44 @@
+// `ay functions rollback <id-or-slug> <version>` — roll a function back to a
+// previous version. Wraps `POST /userfunctions/:id/actions/rollback`.
+import { spinner } from "../../../index.js";
+import { apiCallHandler } from "../../api/apiCallHandler.js";
+import { cliError } from "../../helpers/cliError.js";
+import { EXIT_GENERAL_ERROR, EXIT_MISUSE } from "../../exitCodes.js";
+import { FN_MODULE, FN_COLLECTION, resolveFunction } from "./_shared.js";
+export function addRollbackSubcommand(fns, _rootProgram) {
+    fns
+        .command("rollback <id-or-slug> <version>")
+        .description("Roll a function back to a previous version")
+        .option("-y, --yes", "Skip confirmation prompt", false)
+        .action(async (idOrSlug, versionRaw, options) => {
+        var _a;
+        try {
+            const version = parseInt(versionRaw, 10);
+            if (Number.isNaN(version) || version < 1) {
+                cliError(`Invalid version "${versionRaw}" — expected a positive integer`, EXIT_MISUSE);
+            }
+            spinner.start({ text: `Resolving ${idOrSlug}...`, color: "cyan" });
+            const fn = await resolveFunction(idOrSlug);
+            spinner.stop();
+            if (!options.yes && process.stdin.isTTY) {
+                const inquirer = (await import("inquirer")).default;
+                const { ok } = await inquirer.prompt([
+                    {
+                        type: "confirm",
+                        name: "ok",
+                        message: `Roll "${(_a = fn.name) !== null && _a !== void 0 ? _a : fn.slug}" back to version ${version}?`,
+                        default: false,
+                    },
+                ]);
+                if (!ok)
+                    return;
+            }
+            spinner.start({ text: `Rolling back to version ${version}...`, color: "yellow" });
+            await apiCallHandler(FN_MODULE, `${FN_COLLECTION}/${fn._id}/actions/rollback`, "post", { version });
+            spinner.success({ text: `Rolled back to version ${version}` });
+        }
+        catch (e) {
+            cliError(e.message || "Rollback failed", EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/functions/versions.js

@@ -0,0 +1,32 @@
+// `ay functions versions <id-or-slug>` — list version history for a function.
+//
+// Hits `GET /userfunctions/:id/versions`. Used as the input for
+// `ay functions rollback`.
+import { spinner } from "../../../index.js";
+import { apiCallHandler } from "../../api/apiCallHandler.js";
+import { handleResponseFormatOptions } from "../../helpers/handleResponseFormatOptions.js";
+import { cliError } from "../../helpers/cliError.js";
+import { EXIT_GENERAL_ERROR } from "../../exitCodes.js";
+import { FN_MODULE, FN_COLLECTION, resolveFunction } from "./_shared.js";
+export function addVersionsSubcommand(fns, rootProgram) {
+    fns
+        .command("versions <id-or-slug>")
+        .description("Show version history for a function")
+        .option("-l, --limit <n>", "Limit results", (v) => parseInt(v, 10), 50)
+        .action(async (idOrSlug, options) => {
+        var _a, _b, _c, _d, _e;
+        try {
+            const opts = { ...rootProgram.opts(), ...options };
+            spinner.start({ text: `Resolving ${idOrSlug}...`, color: "cyan" });
+            const fn = await resolveFunction(idOrSlug);
+            spinner.update({ text: "Fetching versions..." });
+            const res = await apiCallHandler(FN_MODULE, `${FN_COLLECTION}/${fn._id}/versions`, "get", null, { limit: opts.limit });
+            const total = (_e = (_c = (_b = (_a = res === null || res === void 0 ? void 0 : res.meta) === null || _a === void 0 ? void 0 : _a.pageInfo) === null || _b === void 0 ? void 0 : _b.totalEntries) !== null && _c !== void 0 ? _c : (_d = res === null || res === void 0 ? void 0 : res.payload) === null || _d === void 0 ? void 0 : _d.length) !== null && _e !== void 0 ? _e : 0;
+            spinner.success({ text: `Found ${total} version${total === 1 ? "" : "s"}` });
+            handleResponseFormatOptions(opts, res);
+        }
+        catch (e) {
+            cliError(e.message || "Failed to fetch versions", EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/local/_context.js

@@ -0,0 +1,42 @@
+// Shared helpers for the `ay local *` subcommands. Centralized so that
+// every subcommand uses the same compose-context discovery + the same
+// "no docker / no monorepo" error messages — keeps the surface uniform
+// and the per-subcommand files small.
+import chalk from "chalk";
+import { detectRuntime, resolveLocalContext, } from "../../helpers/dockerCompose.js";
+import { cliError } from "../../helpers/cliError.js";
+import { EXIT_GENERAL_ERROR } from "../../exitCodes.js";
+/**
+ * Resolve the compose context to use for a `ay local` subcommand.
+ *
+ * - Verifies docker compose is installed; aborts via `cliError` otherwise.
+ * - Tries to find the monorepo's `infrastructure/local/` overlay first.
+ * - Falls back to a minimal context (cwd, no extra files) for customers who
+ *   run `ay local` against a vanilla `docker-compose.yml` in their own
+ *   directory. The fallback still passes `-p ayoune` so the project name
+ *   stays consistent across the monorepo and customer installs.
+ */
+export function resolveContextOrExit() {
+    const runtime = detectRuntime();
+    if (runtime !== "compose") {
+        cliError("Docker Compose is not available. Install Docker Desktop (or `docker compose` plugin) and try again.", EXIT_GENERAL_ERROR);
+    }
+    const ctx = resolveLocalContext();
+    if (ctx)
+        return ctx;
+    // Customer-install fallback — no monorepo overlay, plain `docker-compose.yml` in cwd.
+    return {
+        projectName: "ayoune",
+        cwd: process.cwd(),
+        files: [],
+    };
+}
+/** Print a green "next steps" footer after a successful `up`. */
+export function printDevToolsBanner() {
+    console.log("");
+    console.log(chalk.green("  Dev tools:"));
+    console.log(chalk.dim("    Traefik Dashboard  http://localhost:8080"));
+    console.log(chalk.dim("    Redis Commander    http://localhost:8081"));
+    console.log(chalk.dim("    Bull Monitor       http://localhost:8082"));
+    console.log("");
+}

package/lib/commands/local/down.js

@@ -0,0 +1,50 @@
+// `ay local down` — stop the local stack.
+//
+// Mirrors `dev.ps1 down` which passes `--profile "*"` so containers from
+// every profile (not just `core`) get cleaned up. Adds a confirmation prompt
+// in TTY mode unless `--force`/`-y` is given.
+import { spinner } from "../../../index.js";
+import { streamCompose } from "../../helpers/dockerCompose.js";
+import { cliError } from "../../helpers/cliError.js";
+import { EXIT_GENERAL_ERROR } from "../../exitCodes.js";
+import { resolveContextOrExit } from "./_context.js";
+export function addDownSubcommand(local) {
+    local
+        .command("down")
+        .description("Stop and remove the local stack containers")
+        .option("-y, --yes", "Skip confirmation prompt", false)
+        .option("--volumes", "Remove named volumes too (DESTRUCTIVE)", false)
+        .option("--remove-orphans", "Remove containers for services not defined in the compose files", false)
+        .action(async (options) => {
+        try {
+            const ctx = resolveContextOrExit();
+            if (!options.yes && process.stdin.isTTY) {
+                const inquirer = (await import("inquirer")).default;
+                const message = options.volumes
+                    ? "Stop the local stack AND delete named volumes?"
+                    : "Stop the local stack?";
+                const ans = await inquirer.prompt([
+                    { type: "confirm", name: "ok", message, default: false },
+                ]);
+                if (!ans.ok)
+                    return;
+            }
+            const args = ["--profile", "*", "down"];
+            if (options.volumes)
+                args.push("--volumes");
+            if (options.removeOrphans)
+                args.push("--remove-orphans");
+            spinner.start({ text: "Stopping local stack...", color: "yellow" });
+            const code = await streamCompose(ctx, args);
+            if (code !== 0) {
+                spinner.error({ text: "docker compose down failed" });
+                cliError("Failed to stop local stack", EXIT_GENERAL_ERROR);
+            }
+            spinner.success({ text: "Local stack stopped" });
+            spinner.stop();
+        }
+        catch (e) {
+            cliError(e.message || "Failed to stop local stack", EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/local/exec.js

@@ -0,0 +1,45 @@
+// `ay local exec <service> <cmd...>` — run a command inside a service container.
+//
+// Forwards everything after the service name as the command + args. Always
+// passes `-T` only when stdin is NOT a TTY (matches `docker compose exec`'s
+// own auto-detection but explicit so this works under nohup/CI).
+import { streamCompose } from "../../helpers/dockerCompose.js";
+import { cliError } from "../../helpers/cliError.js";
+import { EXIT_GENERAL_ERROR, EXIT_MISUSE } from "../../exitCodes.js";
+import { resolveContextOrExit } from "./_context.js";
+export function addExecSubcommand(local) {
+    local
+        .command("exec <service> [args...]")
+        .description("Run a command inside a service container")
+        .allowUnknownOption(true)
+        .option("-u, --user <user>", "Run as a specific user")
+        .option("-w, --workdir <dir>", "Working directory inside the container")
+        .action(async (service, args, options) => {
+        try {
+            if (!service)
+                cliError("Service name is required", EXIT_MISUSE);
+            const ctx = resolveContextOrExit();
+            const composeArgs = ["exec"];
+            if (!process.stdin.isTTY)
+                composeArgs.push("-T");
+            if (options.user)
+                composeArgs.push("-u", options.user);
+            if (options.workdir)
+                composeArgs.push("-w", options.workdir);
+            composeArgs.push(service);
+            if (args && args.length > 0) {
+                composeArgs.push(...args);
+            }
+            else {
+                // Sensible default — drop into a shell. `sh` is more portable than `bash`.
+                composeArgs.push("sh");
+            }
+            const code = await streamCompose(ctx, composeArgs);
+            if (code !== 0)
+                process.exit(code);
+        }
+        catch (e) {
+            cliError(e.message || "Exec failed", EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/local/index.js

@@ -0,0 +1,40 @@
+// `ay local` parent command — cross-platform Docker Compose wrapper that
+// replaces `infrastructure/local/dev.ps1` for end-users on macOS/Linux as
+// well as Windows. Each subcommand wraps a single `docker compose` verb and
+// reuses the shared helper in `src/lib/helpers/dockerCompose.ts` so that the
+// `ay self-host-update` command and these stay in lock-step.
+//
+// All subcommands prefer the monorepo's `infrastructure/local/` overlay
+// (auto-discovered via `resolveLocalContext`) when run from inside the
+// monorepo. When run from a customer install, they fall back to the local
+// directory's `docker-compose.yml`.
+import { addUpSubcommand } from "./up.js";
+import { addDownSubcommand } from "./down.js";
+import { addRestartSubcommand } from "./restart.js";
+import { addLogsSubcommand } from "./logs.js";
+import { addPsSubcommand } from "./ps.js";
+import { addPullSubcommand } from "./pull.js";
+import { addExecSubcommand } from "./exec.js";
+export function createLocalCommand(program) {
+    const local = program
+        .command("local")
+        .description("Run a self-hosted aYOUne instance locally via Docker Compose")
+        .addHelpText("after", `
+Examples:
+  ay local up                       Start core services
+  ay local up crm marketing         Start core + CRM + marketing profiles
+  ay local ps                       Show running services
+  ay local logs api-config -f       Tail config-api logs
+  ay local restart api-crm          Restart a single service
+  ay local pull                     Pull latest images
+  ay local exec api-crm sh          Open a shell in a container
+  ay local down                     Stop everything`);
+    addUpSubcommand(local);
+    addDownSubcommand(local);
+    addRestartSubcommand(local);
+    addLogsSubcommand(local);
+    addPsSubcommand(local);
+    addPullSubcommand(local);
+    addExecSubcommand(local);
+}
+export default createLocalCommand;

package/lib/commands/local/logs.js

@@ -0,0 +1,38 @@
+// `ay local logs [service] [--follow] [--tail N]` — tail compose logs.
+//
+// Without a service, streams logs for the whole stack. With `-f/--follow`,
+// stays attached until the user hits Ctrl-C; otherwise prints the last
+// `--tail N` lines (default 100) and exits.
+import { streamCompose } from "../../helpers/dockerCompose.js";
+import { cliError } from "../../helpers/cliError.js";
+import { EXIT_GENERAL_ERROR } from "../../exitCodes.js";
+import { resolveContextOrExit } from "./_context.js";
+export function addLogsSubcommand(local) {
+    local
+        .command("logs [service]")
+        .description("Tail logs from the local stack")
+        .option("-f, --follow", "Follow log output", false)
+        .option("-t, --tail <n>", "Number of lines to show from the end of each container", "100")
+        .option("--timestamps", "Show timestamps", false)
+        .action(async (service, options) => {
+        try {
+            const ctx = resolveContextOrExit();
+            const args = ["logs"];
+            if (options.follow)
+                args.push("-f");
+            if (options.tail)
+                args.push("--tail", String(options.tail));
+            if (options.timestamps)
+                args.push("--timestamps");
+            if (service)
+                args.push(service);
+            const code = await streamCompose(ctx, args);
+            if (code !== 0 && !options.follow) {
+                cliError("docker compose logs failed", EXIT_GENERAL_ERROR);
+            }
+        }
+        catch (e) {
+            cliError(e.message || "Failed to read logs", EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/local/ps.js

@@ -0,0 +1,41 @@
+// `ay local ps` — list running services.
+//
+// Two modes:
+//   - default: streams `docker compose ps` with a pretty table format
+//     (matches dev.ps1's `--format "table {{.Name}}\t{{.Status}}\t{{.Ports}}"`)
+//   - `--json`: synchronously runs `docker compose ps --format json` and pipes
+//     the output through `handleResponseFormatOptions` so the user can pipe it
+//     into jq / save it. Keeps the CLI's response-format conventions intact
+//     for scripted usage.
+import { runCompose, streamCompose } from "../../helpers/dockerCompose.js";
+import { cliError } from "../../helpers/cliError.js";
+import { EXIT_GENERAL_ERROR } from "../../exitCodes.js";
+import { resolveContextOrExit } from "./_context.js";
+export function addPsSubcommand(local) {
+    local
+        .command("ps")
+        .description("List running services in the local stack")
+        .option("--json", "Output JSON instead of a table", false)
+        .option("-a, --all", "Show stopped containers too", false)
+        .action(async (options) => {
+        try {
+            const ctx = resolveContextOrExit();
+            const args = ["ps"];
+            if (options.all)
+                args.push("-a");
+            if (options.json) {
+                args.push("--format", "json");
+                const out = runCompose(ctx, args, { silent: false });
+                console.log(out);
+                return;
+            }
+            args.push("--format", "table {{.Name}}\t{{.Status}}\t{{.Ports}}");
+            const code = await streamCompose(ctx, args);
+            if (code !== 0)
+                cliError("docker compose ps failed", EXIT_GENERAL_ERROR);
+        }
+        catch (e) {
+            cliError(e.message || "Failed to list services", EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/local/pull.js

@@ -0,0 +1,40 @@
+// `ay local pull [profiles...]` — pull latest images for the local stack.
+//
+// Like `up`, always includes the `core` profile so foundation images are
+// refreshed even when the user only asked for a sub-set. Doesn't restart
+// anything — that's `ay local restart` or `ay local up` after a pull.
+import { spinner } from "../../../index.js";
+import { streamCompose } from "../../helpers/dockerCompose.js";
+import { cliError } from "../../helpers/cliError.js";
+import { EXIT_GENERAL_ERROR } from "../../exitCodes.js";
+import { resolveContextOrExit } from "./_context.js";
+export function addPullSubcommand(local) {
+    local
+        .command("pull [profiles...]")
+        .description("Pull the latest images for the local stack")
+        .option("--quiet", "Suppress per-image progress output", false)
+        .action(async (profiles, options) => {
+        try {
+            const ctx = resolveContextOrExit();
+            const allProfiles = ["core", ...(profiles !== null && profiles !== void 0 ? profiles : [])];
+            const profileArgs = allProfiles.flatMap((p) => ["--profile", p]);
+            const args = [...profileArgs, "pull"];
+            if (options.quiet)
+                args.push("--quiet");
+            spinner.start({
+                text: `Pulling images for: ${allProfiles.join(", ")}`,
+                color: "cyan",
+            });
+            const code = await streamCompose(ctx, args);
+            if (code !== 0) {
+                spinner.error({ text: "docker compose pull failed" });
+                cliError("Image pull failed", EXIT_GENERAL_ERROR);
+            }
+            spinner.success({ text: "Images pulled" });
+            spinner.stop();
+        }
+        catch (e) {
+            cliError(e.message || "Image pull failed", EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/local/restart.js

@@ -0,0 +1,31 @@
+// `ay local restart [service]` — restart the whole stack or a single service.
+import { spinner } from "../../../index.js";
+import { streamCompose } from "../../helpers/dockerCompose.js";
+import { cliError } from "../../helpers/cliError.js";
+import { EXIT_GENERAL_ERROR } from "../../exitCodes.js";
+import { resolveContextOrExit } from "./_context.js";
+export function addRestartSubcommand(local) {
+    local
+        .command("restart [service]")
+        .description("Restart the entire stack or a single service")
+        .action(async (service) => {
+        try {
+            const ctx = resolveContextOrExit();
+            const args = service ? ["restart", service] : ["restart"];
+            spinner.start({
+                text: service ? `Restarting ${service}...` : "Restarting all services...",
+                color: "yellow",
+            });
+            const code = await streamCompose(ctx, args);
+            if (code !== 0) {
+                spinner.error({ text: "docker compose restart failed" });
+                cliError("Failed to restart", EXIT_GENERAL_ERROR);
+            }
+            spinner.success({ text: service ? `${service} restarted` : "All services restarted" });
+            spinner.stop();
+        }
+        catch (e) {
+            cliError(e.message || "Failed to restart", EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/local/up.js

@@ -0,0 +1,80 @@
+// `ay local up [profiles...]` — start the local stack.
+//
+// Always passes `--profile core` so foundation services come up. Extra
+// profiles are appended on top. With no args and a TTY, prompts the user
+// to pick optional profiles via inquirer (wizard-first DX). Non-TTY or
+// when called with explicit profile args, runs non-interactively.
+import chalk from "chalk";
+import { spinner } from "../../../index.js";
+import { streamCompose } from "../../helpers/dockerCompose.js";
+import { cliError } from "../../helpers/cliError.js";
+import { EXIT_GENERAL_ERROR } from "../../exitCodes.js";
+import { resolveContextOrExit, printDevToolsBanner } from "./_context.js";
+const OPTIONAL_PROFILES = [
+    "crm",
+    "marketing",
+    "hr",
+    "ecommerce",
+    "pm",
+    "automation",
+    "accounting",
+    "cms",
+    "monitoring",
+    "observability",
+    "devops",
+    "support",
+    "reporting",
+];
+export function addUpSubcommand(local) {
+    local
+        .command("up [profiles...]")
+        .description("Start the local stack (core profile is always included)")
+        .option("-d, --detach", "Run in detached mode (default)", true)
+        .option("--no-detach", "Run in foreground (stream logs to terminal)")
+        .option("--build", "Build images before starting")
+        .action(async (profiles, options) => {
+        try {
+            const ctx = resolveContextOrExit();
+            // Wizard mode — TTY + no profiles given.
+            let selected = profiles !== null && profiles !== void 0 ? profiles : [];
+            if (selected.length === 0 && process.stdin.isTTY) {
+                const inquirer = (await import("inquirer")).default;
+                const ans = await inquirer.prompt([
+                    {
+                        type: "checkbox",
+                        name: "extras",
+                        message: "Select optional profiles to start (core is always included):",
+                        choices: OPTIONAL_PROFILES.map((p) => ({ name: p, value: p })),
+                    },
+                ]);
+                selected = ans.extras;
+            }
+            const allProfiles = ["core", ...selected];
+            const profileArgs = allProfiles.flatMap((p) => ["--profile", p]);
+            const composeArgs = [...profileArgs, "up"];
+            if (options.detach)
+                composeArgs.push("-d");
+            if (options.build)
+                composeArgs.push("--build");
+            spinner.start({
+                text: `Starting profiles: ${allProfiles.join(", ")}`,
+                color: "cyan",
+            });
+            const code = await streamCompose(ctx, composeArgs);
+            if (code !== 0) {
+                spinner.error({ text: "docker compose up failed" });
+                cliError("Failed to start local stack", EXIT_GENERAL_ERROR);
+            }
+            spinner.success({ text: "Local stack is up" });
+            spinner.stop();
+            if (options.detach) {
+                printDevToolsBanner();
+                console.log(chalk.dim("  Tip: use `ay local ps` to list services and `ay local logs <svc>` to tail logs."));
+                console.log("");
+            }
+        }
+        catch (e) {
+            cliError(e.message || "Failed to start local stack", EXIT_GENERAL_ERROR);
+        }
+    });
+}