@tolinax/ayoune-cli 2026.3.1 → 2026.5.0

package/lib/commands/createProgram.js

@@ -0,0 +1,217 @@
+//Defines the main program structure for command line interface
+import { Command, Option } from "commander";
+import chalk from "chalk";
+import path from "path";
+import os from "os";
+import { spinner } from "../../index.js";
+import { createModulesCommand } from "./createModulesCommand.js";
+import { createListCommand } from "./createListCommand.js";
+import { createGetCommand } from "./createGetCommand.js";
+import { createEditCommand } from "./createEditCommand.js";
+import { createLoginCommand } from "./createLoginCommand.js";
+import { createDescribeCommand } from "./createDescribeCommand.js";
+import { createCopyCommand } from "./createCopyCommand.js";
+import { createCreateCommand } from "./createCreateCommand.js";
+import { createStorageCommand } from "./createStorageCommand.js";
+import { createAuditCommand } from "./createAuditCommand.js";
+import { createStreamCommand } from "./createStreamCommand.js";
+import { createEventsCommand } from "./createEventsCommand.js";
+import { createWhoAmICommand } from "./createWhoAmICommand.js";
+import { createLogoutCommand } from "./createLogoutCommand.js";
+import { createCompletionsCommand } from "./createCompletionsCommand.js";
+import { createAliasCommand, registerUserAliases } from "./createAliasCommand.js";
+import { createConfigCommand } from "./createConfigCommand.js";
+import { createActionsCommand } from "./createActionsCommand.js";
+import { createExecCommand } from "./createExecCommand.js";
+import { createAiCommand } from "./createAiCommand.js";
+import { enableDebug } from "../api/apiClient.js";
+import { enableDryRun } from "../api/apiCallHandler.js";
+import { setJsonErrorsEnabled } from "../helpers/cliError.js";
+import { disableContext } from "../helpers/contextInjector.js";
+import { createServicesCommand } from "./createServicesCommand.js";
+import { createDeployCommand } from "./createDeployCommand.js";
+import { createMonitorCommand } from "./createMonitorCommand.js";
+import { createDeleteCommand } from "./createDeleteCommand.js";
+import { createUpdateCommand } from "./createUpdateCommand.js";
+import { createBatchCommand } from "./createBatchCommand.js";
+import { createSearchCommand } from "./createSearchCommand.js";
+import { createWebhooksCommand } from "./createWebhooksCommand.js";
+import { createJobsCommand } from "./createJobsCommand.js";
+import { createExportCommand } from "./createExportCommand.js";
+import { createUsersCommand } from "./createUsersCommand.js";
+import { createSyncCommand } from "./createSyncCommand.js";
+import { createPermissionsCommand } from "./createPermissionsCommand.js";
+import { createTemplateCommand } from "./createTemplateCommand.js";
+import { createSetupCommand } from "./createSetupCommand.js";
+import { createStatusCommand } from "./createStatusCommand.js";
+import { createSelfHostUpdateCommand } from "./createSelfHostUpdateCommand.js";
+import { createContextCommand } from "./createContextCommand.js";
+import { createAccessCommand } from "./createAccessCommand.js";
+import { secureStorage } from "../helpers/secureStorage.js";
+import { login } from "../api/login.js";
+import { loadConfig } from "../helpers/configLoader.js";
+import { getLogo, getDescription, BRAND_BLUE } from "../helpers/logo.js";
+import { checkForUpdates } from "../helpers/updateNotifier.js";
+import { createRequire } from "module";
+const require = createRequire(import.meta.url);
+let pkg;
+try {
+    pkg = require("../../package.json"); // dist/ and npm install
+}
+catch (_a) {
+    pkg = require("../../../package.json"); // source tree (tests)
+}
+export function createProgram(program) {
+    program
+        .version(pkg.version || "0.0.0")
+        .addOption(new Option("-r, --responseFormat <format>", "Set the output format")
+        .choices(["json", "csv", "yaml", "table"])
+        .default("json"))
+        .addOption(new Option("-v, --verbosity <level>", "Set the verbosity level of the returned meta information")
+        .choices(["default", "extended", "minimal"])
+        .default("default")
+        .conflicts("hideMeta"))
+        .addOption(new Option("-m, --hideMeta", "Returns only the payload without meta information. ")
+        .default(false)
+        .conflicts("verbosity"))
+        .addOption(new Option("-s, --save", "Saves the response as file"))
+        .addOption(new Option("-d, --debug", "Show detailed request/response information"))
+        .addOption(new Option("-o, --outPath [filePath]", "Lets you set a path").default(path.join(os.homedir(), "aYOUne")))
+        .addOption(new Option("-n, --name [fileName]", "Lets you set a filename"))
+        .addOption(new Option("-q, --quiet", "Suppress all output except errors and results"))
+        .addOption(new Option("--force", "Skip confirmation prompts for destructive actions"))
+        .addOption(new Option("--dry-run", "Preview what a command would do without executing"))
+        .addOption(new Option("--jq <expression>", "Filter JSON output using JMESPath expression"))
+        .addOption(new Option("--columns <fields>", "Comma-separated list of columns to display"))
+        .addOption(new Option("--no-color", "Disable colored output"))
+        .addOption(new Option("--json-errors", "Output errors as JSON to stderr (for AI agents/scripts)"))
+        .addOption(new Option("--token <jwt>", "Authenticate with a JWT token for this session"))
+        .addOption(new Option("--no-context", "Disable context injection for this command"))
+        .description(getDescription());
+    program.showHelpAfterError();
+    program.showSuggestionAfterError(true);
+    createModulesCommand(program);
+    createListCommand(program);
+    createGetCommand(program);
+    createEditCommand(program);
+    createCopyCommand(program);
+    createDescribeCommand(program);
+    createCreateCommand(program);
+    createStorageCommand(program);
+    createAuditCommand(program);
+    createStreamCommand(program);
+    createEventsCommand(program);
+    createWhoAmICommand(program);
+    createLogoutCommand(program);
+    createActionsCommand(program);
+    createExecCommand(program);
+    createAiCommand(program);
+    createServicesCommand(program);
+    createDeployCommand(program);
+    createMonitorCommand(program);
+    createDeleteCommand(program);
+    createUpdateCommand(program);
+    createBatchCommand(program);
+    createSearchCommand(program);
+    createWebhooksCommand(program);
+    createJobsCommand(program);
+    createExportCommand(program);
+    createUsersCommand(program);
+    createSyncCommand(program);
+    createPermissionsCommand(program);
+    createTemplateCommand(program);
+    createAccessCommand(program);
+    createSetupCommand(program);
+    createStatusCommand(program);
+    createSelfHostUpdateCommand(program);
+    createContextCommand(program);
+    createCompletionsCommand(program);
+    createAliasCommand(program);
+    createConfigCommand(program);
+    registerUserAliases(program);
+    createLoginCommand(program);
+    program.addHelpText("beforeAll", getLogo());
+    program.addHelpText("afterAll", chalk.dim("\n  Run ay <command> --help for more info\n"));
+    program.configureHelp({
+        sortOptions: true,
+        sortSubcommands: true,
+        showGlobalOptions: true,
+        formatHelp: (cmd, helper) => {
+            const defaultHelp = Command.prototype.createHelp().formatHelp(cmd, helper);
+            return defaultHelp.replace(/^(Usage:|Commands:|Options:|Global Options:)/gm, (match) => chalk.hex(BRAND_BLUE).bold(match));
+        },
+    });
+    // Respect NO_COLOR env var (no-color.org standard)
+    if (process.env.NO_COLOR !== undefined) {
+        chalk.level = 0;
+    }
+    program.hook("preAction", async (thisCommand) => {
+        var _a;
+        // Apply saved defaults — only when the user didn't pass the flag explicitly
+        const config = loadConfig();
+        const defaults = (_a = config.defaults) !== null && _a !== void 0 ? _a : {};
+        const rawArgs = process.argv.slice(2);
+        if (defaults.responseFormat && !rawArgs.some(a => ["-r", "--responseFormat"].includes(a)))
+            program.setOptionValue("responseFormat", defaults.responseFormat);
+        if (defaults.verbosity && !rawArgs.some(a => ["-v", "--verbosity"].includes(a)))
+            program.setOptionValue("verbosity", defaults.verbosity);
+        if (defaults.outPath && !rawArgs.some(a => ["-o", "--outPath"].includes(a)))
+            program.setOptionValue("outPath", defaults.outPath);
+        if (defaults.hideMeta && !rawArgs.some(a => ["-m", "--hideMeta"].includes(a)))
+            program.setOptionValue("hideMeta", defaults.hideMeta);
+        if (defaults.quiet && !rawArgs.some(a => ["-q", "--quiet"].includes(a)))
+            program.setOptionValue("quiet", defaults.quiet);
+        if (defaults.force && !rawArgs.some(a => ["--force"].includes(a)))
+            program.setOptionValue("force", defaults.force);
+        if (defaults.dryRun && !rawArgs.some(a => ["--dry-run"].includes(a)))
+            program.setOptionValue("dryRun", defaults.dryRun);
+        const opts = program.opts();
+        if (opts.color === false) {
+            chalk.level = 0;
+        }
+        if (opts.debug) {
+            enableDebug();
+        }
+        if (opts.dryRun) {
+            enableDryRun();
+        }
+        if (opts.jsonErrors) {
+            setJsonErrorsEnabled(true);
+        }
+        if (opts.context === false) {
+            disableContext();
+        }
+        if (opts.quiet) {
+            spinner.start = () => spinner;
+            spinner.update = () => spinner;
+            spinner.success = () => spinner;
+            spinner.stop = () => spinner;
+            // spinner.error left intact
+        }
+        // Token from --token flag (highest priority), then env var, then stored token
+        if (opts.token) {
+            secureStorage.setItem("token", opts.token);
+        }
+        else {
+            const envToken = process.env.AYOUNE_TOKEN;
+            if (envToken && !secureStorage.getItem("token")) {
+                secureStorage.setItem("token", envToken);
+            }
+        }
+        // First-run onboarding: auto-login if no token stored
+        const cmdName = thisCommand.name();
+        const skipAuth = ["login", "logout", "whoami", "completions", "alias", "config", "help", "setup", "status", "self-host-update", "context"];
+        if (!skipAuth.includes(cmdName) && process.stdin.isTTY) {
+            const token = secureStorage.getItem("token");
+            if (!token) {
+                console.error(chalk.hex('#2B8DC6').bold("\n  Welcome to aYOUne CLI!\n"));
+                console.error(chalk.dim("  You need to authenticate before using this command.\n"));
+                await login();
+            }
+        }
+        // Non-blocking update check (throttled, silent on errors)
+        checkForUpdates(pkg.version || "0.0.0");
+    });
+    //Parse command line arguments
+    program.parse(process.argv);
+}

package/lib/commands/createSearchCommand.js

@@ -0,0 +1,251 @@
+import { resolveCollectionArgs } from "../helpers/resolveCollectionArgs.js";
+import { getModuleFromCollection } from "../models/getModuleFromCollection.js";
+import { apiCallHandler } from "../api/apiCallHandler.js";
+import { searchModel, searchOne, searchGlobal } from "../api/searchClient.js";
+import { handleResponseFormatOptions } from "../helpers/handleResponseFormatOptions.js";
+import { saveFile } from "../helpers/saveFile.js";
+import { localStorage } from "../helpers/localStorage.js";
+import { spinner } from "../../index.js";
+import { EXIT_GENERAL_ERROR } from "../exitCodes.js";
+import { cliError } from "../helpers/cliError.js";
+import { sanitizeFields } from "../helpers/sanitizeFields.js";
+import { getContextFilterParams } from "../helpers/contextInjector.js";
+export function createSearchCommand(program) {
+    program
+        .command("search [collectionOrModule] [collectionOrQuery] [query]")
+        .alias("find")
+        .description("Search entries via the aYOUne Search Service")
+        .addHelpText("after", `
+Examples:
+  ay search consumers "John"                       Search via search service
+  ay search crm consumers "John"                   Search with explicit module
+  ay search -g "John"                              Global search across all collections (SSE)
+  ay search consumers "John" --one                 Find first match
+  ay search consumers "John" --field name          Search specific field
+  ay search contacts --filter "status=active"      Filter by field
+  ay search orders --filter "status=paid" --sort "-createdAt"
+  ay search consumers "John" --legacy              Use legacy module API
+  ay find invoices --filter "total>500" --count    Just count matches`)
+        .option("-g, --global <query>", "Global search across all collections (SSE streaming)")
+        .option("--field <name>", "Search in a specific field")
+        .option("--one", "Return only the first matching entry", false)
+        .option("--legacy", "Use legacy module API instead of search service", false)
+        .option("--filter <filters>", "Comma-separated key=value filters (supports =, !=, >, <, >=, <=)")
+        .option("--fields <fields>", "Comma-separated fields to return (projection)")
+        .option("--sort <field>", "Sort by field (prefix with - for descending)", "-createdAt")
+        .option("--count", "Only return count of matching entries", false)
+        .option("-l, --limit <number>", "Limit results", parseInt, 25)
+        .option("-p, --page <number>", "Page number", parseInt, 1)
+        .action(async (collectionOrModule, collectionOrQuery, query, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            // Mode 1: Global SSE search
+            if (opts.global) {
+                return await handleGlobalSearch(opts);
+            }
+            // For all other modes, we need a collection
+            if (!collectionOrModule) {
+                cliError("Collection name is required (or use --global for global search)", EXIT_GENERAL_ERROR);
+                return;
+            }
+            // Detect if first arg is a module: ay search crm consumers "John"
+            let resolved;
+            let searchQuery = query;
+            const m = getModuleFromCollection(collectionOrModule.toLowerCase());
+            if (!m && collectionOrQuery) {
+                resolved = resolveCollectionArgs(collectionOrModule, collectionOrQuery);
+            }
+            else {
+                resolved = resolveCollectionArgs(collectionOrModule);
+                searchQuery = collectionOrQuery;
+            }
+            const collection = resolved.collection;
+            // Mode 4: Legacy module API search
+            if (opts.legacy) {
+                return await handleLegacySearch(resolved, searchQuery, opts);
+            }
+            // Mode 3: FindOne via search service
+            if (opts.one) {
+                return await handleFindOneSearch(resolved, searchQuery, opts);
+            }
+            // Mode 2: Single-model search via search service
+            return await handleModelSearch(resolved, searchQuery, opts);
+        }
+        catch (e) {
+            cliError(e.message || "Search failed", EXIT_GENERAL_ERROR);
+        }
+    });
+}
+async function handleGlobalSearch(opts) {
+    const query = opts.global;
+    spinner.start({ text: `Global search for "${query}"...`, color: "magenta" });
+    const results = await searchGlobal(query, opts.limit, {
+        onResult: (result) => {
+            spinner.update({
+                text: `Searching... found ${result.total} in ${result.collection}`,
+            });
+        },
+        onError: (error) => {
+            spinner.update({ text: `Search warning: ${error}` });
+        },
+    });
+    // Flatten results into a grouped response for handleResponseFormatOptions
+    const totalEntries = results.reduce((sum, r) => sum + r.total, 0);
+    const allEntries = results.flatMap((r) => r.entries.map((e) => ({ ...e, _collection: r.collection })));
+    const res = {
+        payload: allEntries,
+        meta: {
+            responseTime: 0,
+            pageInfo: { totalEntries: totalEntries, page: 1, totalPages: 1 },
+            collections: results.map((r) => ({ name: r.collection, count: r.total })),
+        },
+    };
+    if (opts.count) {
+        spinner.success({ text: `${totalEntries} matching entries across ${results.length} collections` });
+        spinner.stop();
+        console.log(totalEntries);
+        return;
+    }
+    handleResponseFormatOptions(opts, res);
+    spinner.success({
+        text: `Found ${totalEntries} entries across ${results.length} collections`,
+    });
+    spinner.stop();
+    if (opts.save)
+        await saveFile("search-global", opts, res);
+}
+async function handleModelSearch(resolved, searchQuery, opts) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+    const collection = resolved.collection;
+    spinner.start({ text: `Searching ${collection}...`, color: "magenta" });
+    const params = {
+        limit: opts.limit,
+        skip: (opts.page - 1) * opts.limit,
+    };
+    if (searchQuery)
+        params.q = searchQuery;
+    if (opts.field)
+        params.field = opts.field;
+    if (opts.fields)
+        params.fields = sanitizeFields(opts.fields).join(",");
+    if (opts.sort)
+        params.sort = opts.sort;
+    // Inject context params
+    const contextParams = getContextFilterParams(collection);
+    Object.assign(params, contextParams);
+    // Parse filters
+    applyFilters(params, opts.filter);
+    const res = await searchModel(collection, params);
+    if (opts.count) {
+        const total = (_c = (_b = (_a = res.meta) === null || _a === void 0 ? void 0 : _a.pageInfo) === null || _b === void 0 ? void 0 : _b.totalEntries) !== null && _c !== void 0 ? _c : 0;
+        spinner.success({ text: `${total} matching entries in ${collection}` });
+        spinner.stop();
+        console.log(total);
+        return;
+    }
+    handleResponseFormatOptions(opts, res);
+    const total = (_f = (_e = (_d = res.meta) === null || _d === void 0 ? void 0 : _d.pageInfo) === null || _e === void 0 ? void 0 : _e.totalEntries) !== null && _f !== void 0 ? _f : 0;
+    const page = (_j = (_h = (_g = res.meta) === null || _g === void 0 ? void 0 : _g.pageInfo) === null || _h === void 0 ? void 0 : _h.page) !== null && _j !== void 0 ? _j : 1;
+    const totalPages = (_m = (_l = (_k = res.meta) === null || _k === void 0 ? void 0 : _k.pageInfo) === null || _l === void 0 ? void 0 : _l.totalPages) !== null && _m !== void 0 ? _m : 1;
+    spinner.success({
+        text: `Found ${total} entries in ${collection} (page ${page}/${totalPages})`,
+    });
+    spinner.stop();
+    localStorage.setItem("lastModule", resolved.module);
+    localStorage.setItem("lastCollection", resolved.collection);
+    if (opts.save)
+        await saveFile("search", opts, res);
+}
+async function handleFindOneSearch(resolved, searchQuery, opts) {
+    const collection = resolved.collection;
+    spinner.start({ text: `Finding one in ${collection}...`, color: "magenta" });
+    const params = {};
+    if (searchQuery)
+        params.q = searchQuery;
+    if (opts.field)
+        params.field = opts.field;
+    if (opts.fields)
+        params.fields = sanitizeFields(opts.fields).join(",");
+    const contextParams = getContextFilterParams(collection);
+    Object.assign(params, contextParams);
+    applyFilters(params, opts.filter);
+    const res = await searchOne(collection, params);
+    handleResponseFormatOptions(opts, res);
+    spinner.success({
+        text: `Found match in ${collection}`,
+    });
+    spinner.stop();
+    localStorage.setItem("lastModule", resolved.module);
+    localStorage.setItem("lastCollection", resolved.collection);
+    if (opts.save)
+        await saveFile("search-one", opts, res);
+}
+async function handleLegacySearch(resolved, searchQuery, opts) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+    const collection = resolved.collection;
+    spinner.start({ text: `Searching ${collection} (legacy)...`, color: "magenta" });
+    const params = {
+        page: opts.page,
+        limit: opts.limit,
+        sort: opts.sort,
+        responseFormat: opts.responseFormat,
+        verbosity: opts.verbosity,
+        hideMeta: opts.hideMeta,
+    };
+    const contextParams = getContextFilterParams(collection);
+    Object.assign(params, contextParams);
+    if (searchQuery)
+        params.q = searchQuery;
+    if (opts.fields)
+        params.fields = sanitizeFields(opts.fields).join(",");
+    applyFilters(params, opts.filter);
+    const res = await apiCallHandler(resolved.module, collection, "get", null, params);
+    if (opts.count) {
+        const total = (_c = (_b = (_a = res.meta) === null || _a === void 0 ? void 0 : _a.pageInfo) === null || _b === void 0 ? void 0 : _b.totalEntries) !== null && _c !== void 0 ? _c : 0;
+        spinner.success({ text: `${total} matching entries in ${collection}` });
+        spinner.stop();
+        console.log(total);
+        return;
+    }
+    handleResponseFormatOptions(opts, res);
+    const total = (_f = (_e = (_d = res.meta) === null || _d === void 0 ? void 0 : _d.pageInfo) === null || _e === void 0 ? void 0 : _e.totalEntries) !== null && _f !== void 0 ? _f : 0;
+    const page = (_j = (_h = (_g = res.meta) === null || _g === void 0 ? void 0 : _g.pageInfo) === null || _h === void 0 ? void 0 : _h.page) !== null && _j !== void 0 ? _j : 1;
+    const totalPages = (_m = (_l = (_k = res.meta) === null || _k === void 0 ? void 0 : _k.pageInfo) === null || _l === void 0 ? void 0 : _l.totalPages) !== null && _m !== void 0 ? _m : 1;
+    spinner.success({
+        text: `Found ${total} entries in ${collection} (page ${page}/${totalPages})`,
+    });
+    spinner.stop();
+    localStorage.setItem("lastModule", resolved.module);
+    localStorage.setItem("lastCollection", resolved.collection);
+    if (opts.save)
+        await saveFile("search", opts, res);
+}
+function applyFilters(params, filter) {
+    if (!filter)
+        return;
+    const filters = filter.split(",");
+    for (const f of filters) {
+        const match = f.match(/^(\w+)(!=|>=|<=|>|<|=)(.+)$/);
+        if (match) {
+            const [, key, op, value] = match;
+            if (op === "=") {
+                params[key] = value;
+            }
+            else if (op === "!=") {
+                params[`${key}[ne]`] = value;
+            }
+            else if (op === ">") {
+                params[`${key}[gt]`] = value;
+            }
+            else if (op === "<") {
+                params[`${key}[lt]`] = value;
+            }
+            else if (op === ">=") {
+                params[`${key}[gte]`] = value;
+            }
+            else if (op === "<=") {
+                params[`${key}[lte]`] = value;
+            }
+        }
+    }
+}

package/lib/commands/createSelfHostUpdateCommand.js

@@ -0,0 +1,166 @@
+import chalk from "chalk";
+import { spinner } from "../../index.js";
+import { EXIT_GENERAL_ERROR } from "../exitCodes.js";
+import { cliError } from "../helpers/cliError.js";
+import { execSync } from "child_process";
+function runCommand(cmd) {
+    try {
+        return execSync(cmd, { encoding: "utf-8", timeout: 30000 }).trim();
+    }
+    catch (_a) {
+        return "";
+    }
+}
+function detectRuntime() {
+    // Check for docker compose
+    const composeResult = runCommand("docker compose version 2>&1");
+    if (composeResult.includes("Docker Compose"))
+        return "compose";
+    // Check for kubectl
+    const kubectlResult = runCommand("kubectl version --client 2>&1");
+    if (kubectlResult.includes("Client Version"))
+        return "kubernetes";
+    return "unknown";
+}
+function getRunningComposeServices() {
+    const output = runCommand('docker compose ps --format "{{.Name}}" 2>&1');
+    if (!output)
+        return [];
+    return output.split("\n").filter(Boolean);
+}
+function getComposeImageVersions() {
+    const versions = new Map();
+    const output = runCommand('docker compose ps --format "{{.Name}}|{{.Image}}" 2>&1');
+    if (!output)
+        return versions;
+    for (const line of output.split("\n")) {
+        const [name, image] = line.split("|");
+        if (name && image) {
+            const tag = image.split(":").pop() || "unknown";
+            versions.set(name, tag);
+        }
+    }
+    return versions;
+}
+export function createSelfHostUpdateCommand(program) {
+    program
+        .command("self-host-update")
+        .alias("shu")
+        .description("Check for and apply updates to a self-hosted aYOUne deployment")
+        .addHelpText("after", `
+Examples:
+  ay self-host-update                Check for available updates
+  ay self-host-update --apply        Pull new images and restart services
+  ay self-host-update --service crm   Check updates for a specific service`)
+        .option("--apply", "Apply available updates (pull new images, restart services)")
+        .option("--service <name>", "Update only a specific service")
+        .action(async (options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            const runtime = detectRuntime();
+            if (runtime === "unknown") {
+                cliError("Could not detect Docker Compose or Kubernetes. Ensure docker or kubectl is installed and accessible.", EXIT_GENERAL_ERROR);
+            }
+            console.log(chalk.cyan.bold("\n  aYOUne Self-Hosted Update\n"));
+            console.log(chalk.dim(`  Runtime: ${runtime === "compose" ? "Docker Compose" : "Kubernetes"}\n`));
+            if (runtime === "compose") {
+                await handleComposeUpdate(opts);
+            }
+            else {
+                await handleKubernetesUpdate(opts);
+            }
+        }
+        catch (e) {
+            cliError(e.message || "Update check failed", EXIT_GENERAL_ERROR);
+        }
+    });
+}
+async function handleComposeUpdate(opts) {
+    const services = getRunningComposeServices();
+    if (services.length === 0) {
+        console.log(chalk.yellow("  No running aYOUne services found."));
+        console.log(chalk.dim("  Start services first: docker compose --profile core up -d\n"));
+        return;
+    }
+    const versions = getComposeImageVersions();
+    console.log(chalk.white(`  Running services: ${services.length}\n`));
+    for (const [name, version] of versions) {
+        if (opts.service && !name.includes(opts.service))
+            continue;
+        console.log(`  ${chalk.dim("●")} ${name} ${chalk.dim(`(${version})`)}`);
+    }
+    console.log("");
+    if (opts.apply) {
+        spinner.start({ text: "Pulling latest images...", color: "cyan" });
+        const pullTarget = opts.service ? opts.service : "";
+        const pullResult = runCommand(`docker compose pull ${pullTarget} 2>&1`);
+        if (!pullResult) {
+            spinner.error({ text: "Failed to pull images" });
+            return;
+        }
+        spinner.success({ text: "Images pulled successfully" });
+        spinner.start({ text: "Restarting services...", color: "cyan" });
+        const upTarget = opts.service ? opts.service : "";
+        runCommand(`docker compose up -d ${upTarget} 2>&1`);
+        spinner.success({ text: "Services restarted" });
+        spinner.stop();
+        console.log(chalk.green("\n  Update complete!"));
+        console.log(chalk.dim("  Run 'ay status' to verify all services are healthy.\n"));
+    }
+    else {
+        spinner.start({ text: "Checking for new images...", color: "cyan" });
+        const pullTarget = opts.service ? opts.service : "";
+        const dryRunResult = runCommand(`docker compose pull --dry-run ${pullTarget} 2>&1`);
+        spinner.stop();
+        if (dryRunResult) {
+            console.log(chalk.dim("  Image check output:"));
+            for (const line of dryRunResult.split("\n")) {
+                console.log(chalk.dim(`    ${line}`));
+            }
+        }
+        console.log(chalk.cyan("\n  To apply updates, run:"));
+        console.log(chalk.dim("    ay self-host-update --apply\n"));
+    }
+}
+async function handleKubernetesUpdate(opts) {
+    // Check for Helm releases
+    const helmList = runCommand("helm list -n ayoune --output json 2>&1");
+    if (!helmList || helmList.startsWith("[")) {
+        try {
+            const releases = JSON.parse(helmList || "[]");
+            if (releases.length === 0) {
+                console.log(chalk.yellow("  No Helm releases found in 'ayoune' namespace."));
+                console.log(chalk.dim("  Install: helm install ayoune tolinax/ayoune -f values.yaml\n"));
+                return;
+            }
+            for (const release of releases) {
+                console.log(`  ${chalk.white(release.name)} ${chalk.dim(`v${release.app_version} (chart: ${release.chart})`)}`);
+                console.log(`  ${chalk.dim(`Status: ${release.status} | Updated: ${release.updated}`)}`);
+            }
+        }
+        catch (_a) {
+            console.log(chalk.yellow("  Could not parse Helm releases."));
+        }
+    }
+    console.log("");
+    if (opts.apply) {
+        spinner.start({ text: "Updating Helm repo...", color: "cyan" });
+        runCommand("helm repo update 2>&1");
+        spinner.success({ text: "Helm repo updated" });
+        spinner.start({ text: "Upgrading release...", color: "cyan" });
+        const upgradeResult = runCommand("helm upgrade ayoune tolinax/ayoune -n ayoune --reuse-values 2>&1");
+        if (upgradeResult.includes("Error")) {
+            spinner.error({ text: `Helm upgrade failed: ${upgradeResult}` });
+            return;
+        }
+        spinner.success({ text: "Helm release upgraded" });
+        spinner.stop();
+        console.log(chalk.green("\n  Update complete!"));
+        console.log(chalk.dim("  Run 'ay status' to verify all services are healthy.\n"));
+    }
+    else {
+        console.log(chalk.cyan("  To apply updates, run:"));
+        console.log(chalk.dim("    ay self-host-update --apply"));
+        console.log(chalk.dim("    # or manually: helm upgrade ayoune tolinax/ayoune -n ayoune --reuse-values\n"));
+    }
+}