@tolinax/ayoune-cli 2026.9.0 → 2026.10.0

package/lib/commands/_registry.js

@@ -223,6 +223,23 @@ export const COMMAND_REGISTRY = [
         description: "Check for and apply updates to a self-hosted aYOUne deployment",
         loader: async () => (await import("./createSelfHostUpdateCommand.js")).createSelfHostUpdateCommand,
     },
+    {
+        name: "local",
+        description: "Run a self-hosted aYOUne instance locally via Docker Compose",
+        loader: async () => (await import("./local/index.js")).createLocalCommand,
+    },
+    {
+        name: "functions",
+        aliases: ["fns"],
+        description: "Manage Custom Functions (sandboxed FaaS) for this customer",
+        loader: async () => (await import("./functions/index.js")).createFunctionsCommand,
+    },
+    {
+        name: "provision",
+        aliases: ["prov"],
+        description: "Provision aYOUne to a cloud provider (AWS / GCP / Azure / DigitalOcean / Hetzner)",
+        loader: async () => (await import("./provision/index.js")).createProvisionCommand,
+    },
     {
         name: "context",
         aliases: ["ctx"],

package/lib/commands/createSelfHostUpdateCommand.js

@@ -2,26 +2,7 @@ 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";
-}
+import { runCommand, detectRuntime } from "../helpers/dockerCompose.js";
 function getRunningComposeServices() {
     const output = runCommand('docker compose ps --format "{{.Name}}" 2>&1');
     if (!output)

package/lib/commands/createSetupCommand.js

@@ -3,9 +3,11 @@ import inquirer from "inquirer";
 import { writeFile, mkdir } from "fs/promises";
 import { existsSync } from "fs";
 import path from "path";
+import { spawn } from "child_process";
 import { spinner } from "../../index.js";
 import { EXIT_GENERAL_ERROR } from "../exitCodes.js";
 import { cliError } from "../helpers/cliError.js";
+import { detectRuntime } from "../helpers/dockerCompose.js";
 const AVAILABLE_MODULES = [
     { name: "CRM", value: "crm", description: "Customer Relationship Management" },
     { name: "Marketing", value: "marketing", description: "Marketing automation & campaigns" },
@@ -152,6 +154,36 @@ function generateRandomString(length) {
 function capitalize(s) {
     return s.charAt(0).toUpperCase() + s.slice(1);
 }
+/**
+ * Launch the freshly-generated compose stack from the output dir, then poll
+ * the status command until services come up healthy or we time out. Wired
+ * into `ay setup` so the first-run experience is "answer questions →
+ * everything is running" instead of "answer questions → here's the next
+ * shell command to type".
+ */
+async function launchComposeStack(outputDir, profiles) {
+    spinner.start({ text: `Starting docker compose with profiles: ${profiles.join(", ")}`, color: "cyan" });
+    const profileArgs = profiles.flatMap((p) => ["--profile", p]);
+    const args = [...profileArgs, "up", "-d"];
+    const code = await new Promise((resolve) => {
+        const child = spawn("docker", ["compose", ...args], {
+            cwd: outputDir,
+            stdio: "inherit",
+            shell: process.platform === "win32",
+        });
+        child.on("exit", (c) => resolve(c !== null && c !== void 0 ? c : 0));
+        child.on("error", () => resolve(1));
+    });
+    if (code !== 0) {
+        spinner.error({ text: "docker compose up failed" });
+        cliError("Could not start the stack — check the docker compose output above.", EXIT_GENERAL_ERROR);
+    }
+    spinner.success({ text: "Stack started" });
+    console.log("");
+    console.log(chalk.green("  aYOUne is starting up."));
+    console.log(chalk.dim("  Run `ay status` to verify all services are healthy."));
+    console.log("");
+}
 export function createSetupCommand(program) {
     program
         .command("setup")
@@ -285,13 +317,33 @@ Examples:
             else {
                 spinner.success({ text: "Configuration files generated!" });
                 spinner.stop();
-                const profiles = ["core", ...answers.modules].join(",");
+                const profiles = ["core", ...answers.modules];
                 console.log(chalk.green("\n  Generated files:"));
                 console.log(chalk.dim(`    ${envPath}`));
-                console.log(chalk.cyan("\n  Next steps:"));
-                console.log(chalk.dim("    1. Review and adjust the .env file"));
-                console.log(chalk.dim(`    2. docker compose --profile ${profiles} up -d`));
-                console.log(chalk.dim("    3. ay status  — verify all services are healthy\n"));
+                // Offer to launch the stack right away. Skipped non-interactively
+                // (CI / piped) — that path keeps the original "next steps" output.
+                const canLaunch = process.stdin.isTTY && detectRuntime() === "compose";
+                let launched = false;
+                if (canLaunch) {
+                    const { launchNow } = await inquirer.prompt([
+                        {
+                            type: "confirm",
+                            name: "launchNow",
+                            message: "Start aYOUne now?",
+                            default: true,
+                        },
+                    ]);
+                    if (launchNow) {
+                        await launchComposeStack(outputDir, profiles);
+                        launched = true;
+                    }
+                }
+                if (!launched) {
+                    console.log(chalk.cyan("\n  Next steps:"));
+                    console.log(chalk.dim("    1. Review and adjust the .env file"));
+                    console.log(chalk.dim(`    2. docker compose --profile ${profiles.join(" --profile ")} up -d`));
+                    console.log(chalk.dim("    3. ay status  — verify all services are healthy\n"));
+                }
             }
             if (!answers.licenseKey) {
                 console.log(chalk.yellow("  Note: Running in 14-day trial mode.") +

package/lib/commands/functions/_shared.js

@@ -0,0 +1,38 @@
+// Shared helpers for the `ay functions *` subcommands.
+//
+// Centralizes the user-functions resource path and the id-or-slug resolver
+// so each subcommand stays small and consistent. The custom-functions API
+// accepts both `_id` (Mongo) and `slug` in path params, but list/get/etc.
+// vary in which they prefer — wrapping the resolution here keeps the
+// per-subcommand files focused on their actual verb.
+import { apiCallHandler } from "../../api/apiCallHandler.js";
+/** Module that hosts the userfunctions collection. */
+export const FN_MODULE = "config";
+/** Collection segment used in URL paths. */
+export const FN_COLLECTION = "userfunctions";
+/**
+ * Resolve a user-supplied identifier (slug or _id) to a concrete function
+ * record. Returns the full doc; throws if nothing matches.
+ *
+ * The userfunctions list endpoint supports `?slug=` and `?_id=` filters.
+ * Many subcommands need the full record (e.g. invoke needs the entry id +
+ * latest version) — fetching it once via the resolver keeps every callsite
+ * uniform and gives consistent error messages.
+ */
+export async function resolveFunction(idOrSlug) {
+    // Try direct GET first — works when the user passed a Mongo _id.
+    if (/^[a-f0-9]{24}$/i.test(idOrSlug)) {
+        const direct = await apiCallHandler(FN_MODULE, `${FN_COLLECTION}/${idOrSlug}`, "get");
+        if (direct === null || direct === void 0 ? void 0 : direct.payload)
+            return direct.payload;
+    }
+    // Otherwise treat it as a slug + filter the list endpoint.
+    const res = await apiCallHandler(FN_MODULE, FN_COLLECTION, "get", null, {
+        slug: idOrSlug,
+        limit: 1,
+    });
+    const hit = Array.isArray(res === null || res === void 0 ? void 0 : res.payload) ? res.payload[0] : res === null || res === void 0 ? void 0 : res.payload;
+    if (!hit)
+        throw new Error(`No function found for "${idOrSlug}"`);
+    return hit;
+}

package/lib/commands/functions/_validateSource.js

@@ -0,0 +1,50 @@
+// Light source validation for `ay functions deploy`.
+//
+// We can't actually run the code (the sandbox lives in
+// platform/custom-functions-worker via isolated-vm), but we can catch the
+// most common end-user mistakes that would otherwise produce confusing
+// runtime errors:
+//   - importing Node builtins like `fs` / `child_process` / `net` (sandbox
+//     forbids them — surface that early instead of after publishing)
+//   - using `import` syntax (the sandbox is CommonJS, isolated-vm doesn't
+//     run an ESM loader)
+//   - missing `module.exports = async function ...`
+//
+// Returns a list of warnings; the deploy subcommand prints them and asks
+// for confirmation if any are present.
+const FORBIDDEN_BUILTINS = [
+    "fs",
+    "child_process",
+    "net",
+    "tls",
+    "dgram",
+    "dns",
+    "http",
+    "https",
+    "cluster",
+    "worker_threads",
+    "vm",
+    "os",
+    "process",
+    "v8",
+];
+export function validateFunctionSource(source) {
+    const warnings = [];
+    // ESM imports — sandbox is CJS.
+    if (/^\s*import\s+/m.test(source)) {
+        warnings.push("Detected `import` syntax. The Custom Functions sandbox runs CommonJS — use `const x = require(...)` instead.");
+    }
+    // Forbidden builtins via require().
+    const requireMatches = source.matchAll(/require\(\s*['"]([^'"]+)['"]\s*\)/g);
+    for (const m of requireMatches) {
+        const mod = m[1];
+        if (FORBIDDEN_BUILTINS.includes(mod)) {
+            warnings.push(`Importing Node builtin "${mod}" — the sandbox does not expose this module. Use the platform SDK (\`ay\`) instead.`);
+        }
+    }
+    // Module.exports check.
+    if (!/module\.exports\s*=/.test(source) && !/exports\.\w+\s*=/.test(source)) {
+        warnings.push("Source does not export anything. The sandbox expects `module.exports = async (input, ay) => {...}`.");
+    }
+    return warnings;
+}

package/lib/commands/functions/create.js

@@ -0,0 +1,109 @@
+// `ay functions create` — interactive wizard to scaffold a new user function.
+//
+// Walks the user through name, slug, trigger type, and starter template, then
+// either opens $EDITOR for them to write the body or accepts `--source <path>`
+// for a file. Once the function exists, it's saved as a draft (publish via
+// `ay functions deploy` or the editor).
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import path from "path";
+import os from "os";
+import { spawnSync } from "child_process";
+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 } from "./_shared.js";
+const TRIGGER_TYPES = ["http", "cron", "event", "queue", "manual"];
+const STARTER_TEMPLATE = `// Custom Function — runs in an isolated-vm sandbox.
+// The platform SDK is exposed as 'ay'. Return a JSON-serializable value.
+
+module.exports = async function handler(input, ay) {
+  ay.log.info("hello from ay functions", { input });
+  return { ok: true, input };
+};
+`;
+export function addCreateSubcommand(fns, rootProgram) {
+    fns
+        .command("create")
+        .description("Create a new user function (interactive wizard or via flags)")
+        .option("--name <name>", "Function name")
+        .option("--slug <slug>", "URL-safe slug")
+        .option("--trigger <type>", `Trigger type (${TRIGGER_TYPES.join(", ")})`)
+        .option("--source <path>", "Path to a local source file")
+        .option("--description <text>", "Description")
+        .action(async (options) => {
+        var _a, _b;
+        try {
+            let { name, slug, trigger, source, description } = options;
+            // Wizard mode when running in TTY without enough flags.
+            if (process.stdin.isTTY && (!name || !trigger)) {
+                const inquirer = (await import("inquirer")).default;
+                const answers = await inquirer.prompt([
+                    { type: "input", name: "name", message: "Function name:", default: name, when: !name,
+                        validate: (v) => v.length > 0 || "Required" },
+                    { type: "input", name: "slug", message: "Slug:", default: (a) => { var _a; return slug || ((_a = a.name) !== null && _a !== void 0 ? _a : name).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, ""); } },
+                    { type: "list", name: "trigger", message: "Trigger type:", choices: [...TRIGGER_TYPES], default: trigger !== null && trigger !== void 0 ? trigger : "manual", when: !trigger },
+                    { type: "input", name: "description", message: "Description (optional):", default: description !== null && description !== void 0 ? description : "", when: !description },
+                    { type: "confirm", name: "openEditor", message: "Open $EDITOR with the starter template?", default: true, when: !source },
+                ]);
+                name = name !== null && name !== void 0 ? name : answers.name;
+                slug = slug !== null && slug !== void 0 ? slug : answers.slug;
+                trigger = trigger !== null && trigger !== void 0 ? trigger : answers.trigger;
+                description = description !== null && description !== void 0 ? description : answers.description;
+                if (!source && answers.openEditor) {
+                    source = await editInTempFile(STARTER_TEMPLATE);
+                }
+            }
+            if (!name)
+                cliError("--name is required (or run interactively)", EXIT_MISUSE);
+            if (!trigger)
+                cliError("--trigger is required (or run interactively)", EXIT_MISUSE);
+            if (!TRIGGER_TYPES.includes(trigger)) {
+                cliError(`Invalid trigger "${trigger}" — expected one of: ${TRIGGER_TYPES.join(", ")}`, EXIT_MISUSE);
+            }
+            let code = STARTER_TEMPLATE;
+            if (source) {
+                if (typeof source !== "string") {
+                    cliError("--source must be a file path", EXIT_MISUSE);
+                }
+                if (!existsSync(source)) {
+                    cliError(`Source file not found: ${source}`, EXIT_MISUSE);
+                }
+                code = await readFile(source, "utf-8");
+            }
+            if (!slug) {
+                slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+            }
+            spinner.start({ text: `Creating function "${name}"...`, color: "cyan" });
+            const body = {
+                name,
+                slug,
+                triggerType: trigger,
+                description: description !== null && description !== void 0 ? description : "",
+                source: code,
+                status: "draft",
+            };
+            const res = await apiCallHandler(FN_MODULE, FN_COLLECTION, "post", body);
+            spinner.success({ text: `Function created (id: ${(_b = (_a = res === null || res === void 0 ? void 0 : res.payload) === null || _a === void 0 ? void 0 : _a._id) !== null && _b !== void 0 ? _b : "?"})` });
+        }
+        catch (e) {
+            cliError(e.message || "Failed to create function", EXIT_GENERAL_ERROR);
+        }
+    });
+}
+/**
+ * Write the starter template to a temp file, open `$EDITOR` (or `vi`/`notepad`)
+ * synchronously, then read it back. Returns the (possibly empty) edited body.
+ */
+async function editInTempFile(initial) {
+    const dir = path.join(os.tmpdir(), "ay-functions");
+    await mkdir(dir, { recursive: true });
+    const file = path.join(dir, `function-${Date.now()}.js`);
+    await writeFile(file, initial, "utf-8");
+    const editor = process.env.VISUAL ||
+        process.env.EDITOR ||
+        (process.platform === "win32" ? "notepad" : "vi");
+    spawnSync(editor, [file], { stdio: "inherit", shell: process.platform === "win32" });
+    return readFile(file, "utf-8");
+}

package/lib/commands/functions/delete.js

@@ -0,0 +1,40 @@
+// `ay functions delete <id-or-slug>` — delete a user function with confirmation.
+import { spinner } from "../../../index.js";
+import { apiCallHandler } from "../../api/apiCallHandler.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 addDeleteSubcommand(fns, _rootProgram) {
+    fns
+        .command("delete <id-or-slug>")
+        .alias("rm")
+        .description("Delete a user function")
+        .option("-y, --yes", "Skip confirmation prompt", false)
+        .action(async (idOrSlug, options) => {
+        var _a, _b;
+        try {
+            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: `Delete function "${(_a = fn.name) !== null && _a !== void 0 ? _a : fn.slug}" (${fn._id})?`,
+                        default: false,
+                    },
+                ]);
+                if (!ok)
+                    return;
+            }
+            spinner.start({ text: `Deleting ${(_b = fn.name) !== null && _b !== void 0 ? _b : fn.slug}...`, color: "red" });
+            await apiCallHandler(FN_MODULE, `${FN_COLLECTION}/${fn._id}`, "delete");
+            spinner.success({ text: "Function deleted" });
+        }
+        catch (e) {
+            cliError(e.message || "Delete failed", EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/functions/deploy.js

@@ -0,0 +1,91 @@
+// `ay functions deploy <path> [--name <name>]` — upload a local source file
+// as a function and publish it.
+//
+// If a function with the matching slug already exists, this updates its
+// source and triggers a publish; otherwise it creates a new function first.
+// Validates the source up-front and asks the user to confirm if any
+// warnings come back.
+import { readFile } from "fs/promises";
+import { existsSync } from "fs";
+import path from "path";
+import chalk from "chalk";
+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 } from "./_shared.js";
+import { validateFunctionSource } from "./_validateSource.js";
+export function addDeploySubcommand(fns, _rootProgram) {
+    fns
+        .command("deploy <path>")
+        .description("Upload a local source file as a function and publish it")
+        .option("--name <name>", "Override the function name (defaults to filename)")
+        .option("--slug <slug>", "Override the slug (defaults to slugified name)")
+        .option("--trigger <type>", "Trigger type if creating a new function", "manual")
+        .option("--no-publish", "Upload as draft only, do not publish")
+        .option("-y, --yes", "Skip warning confirmation prompt", false)
+        .action(async (filePath, options) => {
+        var _a, _b, _c;
+        try {
+            if (!filePath)
+                cliError("Path to source file is required", EXIT_MISUSE);
+            if (!existsSync(filePath))
+                cliError(`Source file not found: ${filePath}`, EXIT_MISUSE);
+            const source = await readFile(filePath, "utf-8");
+            const warnings = validateFunctionSource(source);
+            if (warnings.length > 0) {
+                console.log(chalk.yellow("\n  Source validation warnings:"));
+                for (const w of warnings)
+                    console.log(chalk.yellow(`    - ${w}`));
+                console.log("");
+                if (!options.yes && process.stdin.isTTY) {
+                    const inquirer = (await import("inquirer")).default;
+                    const { ok } = await inquirer.prompt([
+                        { type: "confirm", name: "ok", message: "Deploy anyway?", default: false },
+                    ]);
+                    if (!ok)
+                        return;
+                }
+            }
+            const baseName = path.basename(filePath, path.extname(filePath));
+            const name = (_a = options.name) !== null && _a !== void 0 ? _a : baseName;
+            const slug = (_b = options.slug) !== null && _b !== void 0 ? _b : name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+            spinner.start({ text: `Looking up "${slug}"...`, color: "cyan" });
+            // Check whether a function with this slug already exists.
+            const existingRes = await apiCallHandler(FN_MODULE, FN_COLLECTION, "get", null, {
+                slug,
+                limit: 1,
+            });
+            const existing = Array.isArray(existingRes === null || existingRes === void 0 ? void 0 : existingRes.payload) ? existingRes.payload[0] : existingRes === null || existingRes === void 0 ? void 0 : existingRes.payload;
+            let fnId;
+            if (existing === null || existing === void 0 ? void 0 : existing._id) {
+                spinner.update({ text: `Updating "${slug}" (${existing._id})...` });
+                await apiCallHandler(FN_MODULE, `${FN_COLLECTION}/${existing._id}`, "put", { source });
+                fnId = existing._id;
+            }
+            else {
+                spinner.update({ text: `Creating "${slug}"...` });
+                const created = await apiCallHandler(FN_MODULE, FN_COLLECTION, "post", {
+                    name,
+                    slug,
+                    triggerType: options.trigger,
+                    source,
+                    status: "draft",
+                });
+                fnId = (_c = created === null || created === void 0 ? void 0 : created.payload) === null || _c === void 0 ? void 0 : _c._id;
+                if (!fnId)
+                    cliError("Could not determine function id after create", EXIT_GENERAL_ERROR);
+            }
+            if (options.publish !== false) {
+                spinner.update({ text: "Publishing..." });
+                await apiCallHandler(FN_MODULE, `${FN_COLLECTION}/${fnId}/actions/publish`, "post");
+            }
+            spinner.success({
+                text: options.publish === false ? `Uploaded "${slug}" as draft` : `Deployed "${slug}"`,
+            });
+        }
+        catch (e) {
+            cliError(e.message || "Deploy failed", EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/functions/get.js

@@ -0,0 +1,31 @@
+// `ay functions get <id-or-slug>` — show metadata + source for a function.
+import { spinner } from "../../../index.js";
+import { handleResponseFormatOptions } from "../../helpers/handleResponseFormatOptions.js";
+import { cliError } from "../../helpers/cliError.js";
+import { EXIT_GENERAL_ERROR } from "../../exitCodes.js";
+import { resolveFunction } from "./_shared.js";
+export function addGetSubcommand(fns, rootProgram) {
+    fns
+        .command("get <id-or-slug>")
+        .description("Show metadata and source for a single function")
+        .option("--source-only", "Print only the source code (no metadata)", false)
+        .action(async (idOrSlug, options) => {
+        var _a, _b, _c, _d;
+        try {
+            const opts = { ...rootProgram.opts(), ...options };
+            spinner.start({ text: `Fetching ${idOrSlug}...`, color: "cyan" });
+            const fn = await resolveFunction(idOrSlug);
+            spinner.stop();
+            if (options.sourceOnly) {
+                process.stdout.write((_b = (_a = fn.source) !== null && _a !== void 0 ? _a : fn.code) !== null && _b !== void 0 ? _b : "");
+                if (!((_d = (_c = fn.source) !== null && _c !== void 0 ? _c : fn.code) !== null && _d !== void 0 ? _d : "").endsWith("\n"))
+                    process.stdout.write("\n");
+                return;
+            }
+            handleResponseFormatOptions(opts, { payload: fn, meta: {} });
+        }
+        catch (e) {
+            cliError(e.message || "Failed to fetch function", EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/functions/index.js

@@ -0,0 +1,48 @@
+// `ay functions` parent command — manage Custom Functions (sandboxed FaaS).
+//
+// Custom Functions live in the `userfunctions` collection on config-api with
+// a custom routerUserFunctionsCustom that adds /actions/{execute,publish,...}
+// endpoints, /versions, /logs, and /env CRUD. The CLI surface mirrors what
+// the user-functions-editor frontend exposes so platform customers can manage
+// their FaaS code from a terminal without opening the editor.
+//
+// Subcommand layout follows the same pattern as ay aggregate / ay deploy:
+// each verb is its own file, registered onto the parent here. The shared
+// `_validateSource` lives alongside the deploy subcommand and is reused by
+// `create` (template scaffolding) when the editor pre-populates a stub.
+import { addListSubcommand } from "./list.js";
+import { addGetSubcommand } from "./get.js";
+import { addCreateSubcommand } from "./create.js";
+import { addDeploySubcommand } from "./deploy.js";
+import { addInvokeSubcommand } from "./invoke.js";
+import { addLogsSubcommand } from "./logs.js";
+import { addDeleteSubcommand } from "./delete.js";
+import { addVersionsSubcommand } from "./versions.js";
+import { addRollbackSubcommand } from "./rollback.js";
+export function createFunctionsCommand(program) {
+    const fns = program
+        .command("functions")
+        .alias("fns")
+        .description("Manage Custom Functions (sandboxed FaaS) for this customer")
+        .addHelpText("after", `
+Examples:
+  ay functions list                       List all functions
+  ay functions get my-fn                  Show metadata + source for one function
+  ay functions create                     Wizard: name, trigger, code template
+  ay functions deploy ./hello.ts          Upload a local file as a function
+  ay functions invoke my-fn --data '{}'   Test-invoke with input
+  ay functions logs my-fn -f              Tail execution logs
+  ay functions versions my-fn             Show version history
+  ay functions rollback my-fn 3           Roll back to version 3
+  ay functions delete my-fn               Delete (with confirmation)`);
+    addListSubcommand(fns, program);
+    addGetSubcommand(fns, program);
+    addCreateSubcommand(fns, program);
+    addDeploySubcommand(fns, program);
+    addInvokeSubcommand(fns, program);
+    addLogsSubcommand(fns, program);
+    addDeleteSubcommand(fns, program);
+    addVersionsSubcommand(fns, program);
+    addRollbackSubcommand(fns, program);
+}
+export default createFunctionsCommand;

package/lib/commands/functions/invoke.js

@@ -0,0 +1,75 @@
+// `ay functions invoke <id-or-slug>` — test-invoke a function with input data.
+//
+// Hits the custom action `POST /userfunctions/:id/actions/execute` which
+// runs the function in the worker sandbox and returns its output. Input can
+// come from `--data <json>`, `--file <path>` (json), or stdin pipe.
+import { readFile } from "fs/promises";
+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, EXIT_MISUSE } from "../../exitCodes.js";
+import { FN_MODULE, FN_COLLECTION, resolveFunction } from "./_shared.js";
+async function readStdin() {
+    if (process.stdin.isTTY)
+        return "";
+    return new Promise((resolve) => {
+        let data = "";
+        process.stdin.setEncoding("utf-8");
+        process.stdin.on("data", (chunk) => (data += chunk));
+        process.stdin.on("end", () => resolve(data));
+    });
+}
+export function addInvokeSubcommand(fns, rootProgram) {
+    fns
+        .command("invoke <id-or-slug>")
+        .description("Test-invoke a function with input data")
+        .option("-d, --data <json>", "Input data as a JSON string")
+        .option("-f, --file <path>", "Input data from a JSON file")
+        .option("--async", "Run async (return jobId instead of waiting for output)", false)
+        .action(async (idOrSlug, options) => {
+        var _a;
+        try {
+            const opts = { ...rootProgram.opts(), ...options };
+            let inputJson = null;
+            if (options.data) {
+                try {
+                    inputJson = JSON.parse(options.data);
+                }
+                catch (e) {
+                    cliError(`Invalid JSON in --data: ${e.message}`, EXIT_MISUSE);
+                }
+            }
+            else if (options.file) {
+                const raw = await readFile(options.file, "utf-8");
+                try {
+                    inputJson = JSON.parse(raw);
+                }
+                catch (e) {
+                    cliError(`Invalid JSON in ${options.file}: ${e.message}`, EXIT_MISUSE);
+                }
+            }
+            else if (!process.stdin.isTTY) {
+                const raw = await readStdin();
+                if (raw.trim()) {
+                    try {
+                        inputJson = JSON.parse(raw);
+                    }
+                    catch (e) {
+                        cliError(`Invalid JSON on stdin: ${e.message}`, EXIT_MISUSE);
+                    }
+                }
+            }
+            spinner.start({ text: `Resolving ${idOrSlug}...`, color: "cyan" });
+            const fn = await resolveFunction(idOrSlug);
+            spinner.update({ text: `Invoking ${(_a = fn.name) !== null && _a !== void 0 ? _a : fn.slug}...` });
+            const action = options.async ? "execute-async" : "execute";
+            const res = await apiCallHandler(FN_MODULE, `${FN_COLLECTION}/${fn._id}/actions/${action}`, "post", { input: inputJson });
+            spinner.success({ text: options.async ? "Function queued" : "Function executed" });
+            handleResponseFormatOptions(opts, res);
+        }
+        catch (e) {
+            cliError(e.message || "Invoke failed", EXIT_GENERAL_ERROR);
+        }
+    });
+}