@camunda8/cli 3.1.0 → 3.2.0-alpha.10

package/dist/{deployments.js → commands/helpers/deploy-helpers.js}

@@ -1,23 +1,22 @@
 /**
- * Deployment commands with building-block folder prioritization
+ * Shared deployment helpers — resource collection, deployment execution,
+ * and process-application detection.
+ *
+ * Consumed by:
+ * - `src/commands/deploy.ts` (the `deployCommand` handler)
+ * - `src/commands/watch.ts` (change-triggered re-deploys)
  */
-import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import { basename, dirname, extname, join, relative } from "node:path";
+import { existsSync, readdirSync, readFileSync, realpathSync, statSync, } from "node:fs";
+import { basename, dirname, extname, join, relative, resolve } from "node:path";
 import { TenantId } from "@camunda8/orchestration-cluster-api";
-import { createClient } from "./client.js";
-import { defineCommand, dryRun } from "./command-framework.js";
-import { ALL_DEPLOYABLE_EXTENSIONS, DEPLOYABLE_EXTENSIONS, } from "./commands/resource-extensions.js";
-import { resolveTenantId } from "./config.js";
-import { normalizeToError, SilentError } from "./errors.js";
-import { isIgnored, loadIgnoreRules, resolveIgnoreBaseDir } from "./ignore.js";
-import { getLogger, isRecord } from "./logger.js";
-import { c8ctl } from "./runtime.js";
+import { createClient, getLogger, isRecord, normalizeToError, resolveTenantId, SilentError, } from "../../core/index.js";
+import { DEPLOYABLE_EXTENSIONS, isIgnored, loadDeployAlwaysRules, loadIgnoreRules, meetsMinExtensionVersion, resolveIgnoreBaseDir, } from "../../utils/index.js";
 const PROCESS_APPLICATION_FILE = ".process-application";
 /**
  * Helper to output messages that respect JSON mode for Unix pipe compatibility
  */
-function logMessage(message) {
-    if (c8ctl.outputMode === "json") {
+export function logMessage(message) {
+    if (getLogger().mode === "json") {
         console.error(JSON.stringify({ type: "message", message }));
     }
     else {
@@ -29,13 +28,38 @@ function logMessage(message) {
  * Shared between the dry-run preview and the execute path so the
  * message stays consistent. See https://github.com/camunda/c8ctl/issues/350
  */
-function logSkippedExtensions(skippedExtensions) {
+export function logSkippedExtensions(skippedExtensions) {
     if (skippedExtensions.size === 0)
         return;
     const exts = [...skippedExtensions].sort().join(", ");
     logMessage(`Skipped files with extensions not in the allow-list (${exts}). ` +
         `Use --extensions=<ext> to add specific types, or --all-extensions to include all server-supported types.`);
 }
+/**
+ * Check whether the connected Camunda server supports extended file extensions.
+ * Returns `true` for 8.10+, `false` for older versions.
+ * Falls back to `false` on any error (network, auth, unparseable version)
+ * so unsupported resource types are not deployed to older clusters.
+ */
+export async function checkServerSupportsExtensions(client) {
+    const logger = getLogger();
+    try {
+        const topology = await client.getTopology();
+        const version = String(topology.gatewayVersion ?? "");
+        const result = meetsMinExtensionVersion(version);
+        if (result === null) {
+            logger.warn(`Could not parse server version "${version}" — assuming extended extensions are NOT supported.`);
+            return false;
+        }
+        return result;
+    }
+    catch {
+        logger.warn("Could not reach the server to check its version (topology call failed).");
+        logger.warn("This can happen with OAuth/SaaS clusters before the first token is fetched, " +
+            "or if the server is not yet ready. Assuming extended extensions are NOT supported.");
+        return false;
+    }
+}
 /**
  * Extract process/decision IDs from BPMN/DMN files to detect duplicates
  */
@@ -68,7 +92,12 @@ function isBuildingBlockFolder(path) {
  */
 function hasProcessApplicationFile(dirPath) {
     const paFilePath = join(dirPath, PROCESS_APPLICATION_FILE);
-    return existsSync(paFilePath);
+    try {
+        return statSync(paFilePath).isFile();
+    }
+    catch {
+        return false;
+    }
 }
 /**
  * Find the root building block or process application folder by traversing up the path
@@ -78,11 +107,6 @@ function findGroupRoot(filePath, basePath) {
     let currentDir = dirname(filePath);
     // Traverse up the directory tree until we reach or go outside basePath
     while (true) {
-        // Check if we've gone outside the basePath
-        const rel = relative(basePath, currentDir);
-        if (rel.startsWith("..") || rel === "") {
-            break;
-        }
         // Check if this directory is a building block
         if (isBuildingBlockFolder(currentDir)) {
             return { type: "bb", root: currentDir };
@@ -91,6 +115,11 @@ function findGroupRoot(filePath, basePath) {
         if (hasProcessApplicationFile(currentDir)) {
             return { type: "pa", root: currentDir };
         }
+        // Check if we've reached or gone outside the basePath
+        const rel = relative(basePath, currentDir);
+        if (rel.startsWith("..") || rel === "") {
+            break;
+        }
         // Move up one level
         const parentDir = dirname(currentDir);
         if (parentDir === currentDir)
@@ -99,6 +128,33 @@ function findGroupRoot(filePath, basePath) {
     }
     return { type: null, root: null };
 }
+/**
+ * Walk up from `startDir` looking for a `.process-application` marker
+ * file. Returns the directory that contains the marker, or `null` if
+ * none is found before reaching the filesystem root.
+ *
+ * `startDir` may be a file path — the walk starts from its parent
+ * directory in that case (the initial `hasProcessApplicationFile` call
+ * harmlessly returns false for non-directories).
+ *
+ * Unlike `findGroupRoot()` (which tags individual files for display),
+ * this function determines the *deploy scope*: when a PA root is found,
+ * `collectResourcesForPaths` expands the input to the PA root so that
+ * the entire application is deployed.
+ */
+export function findProcessApplicationRoot(startDir) {
+    let currentDir = resolve(startDir);
+    while (true) {
+        if (hasProcessApplicationFile(currentDir)) {
+            return currentDir;
+        }
+        const parentDir = dirname(currentDir);
+        if (parentDir === currentDir)
+            break; // Reached filesystem root
+        currentDir = parentDir;
+    }
+    return null;
+}
 /**
  * Recursively collect resource files from a directory.
  *
@@ -109,15 +165,16 @@ function findGroupRoot(filePath, basePath) {
  * @param skippedExtensions - Mutable set that accumulates extensions
  *   skipped during directory walks, so the caller can log them.
  */
-function collectResourceFiles(dirPath, collected = [], basePath, ig, ignoreBaseDir, force, extensionList, skippedExtensions) {
+function collectResourceFiles(dirPath, collected = [], basePath, ig, ignoreBaseDir, force, extensionList, skippedExtensions, skippedFiles, deployAlways) {
     if (!existsSync(dirPath)) {
         return collected;
     }
-    // Set basePath to dirPath on first call
+    const stat = statSync(dirPath);
+    // Set basePath to a directory on first call — when the initial input
+    // is a file, use its parent so findGroupRoot can walk up correctly.
     if (!basePath) {
-        basePath = dirPath;
+        basePath = stat.isFile() ? dirname(dirPath) : dirPath;
     }
-    const stat = statSync(dirPath);
     if (stat.isFile()) {
         if (ig && ignoreBaseDir && isIgnored(ig, dirPath, ignoreBaseDir)) {
             return collected;
@@ -176,10 +233,21 @@ function collectResourceFiles(dirPath, collected = [], basePath, ig, ignoreBaseD
                 if (!force &&
                     extensionList &&
                     !extensionList.includes(extname(fullPath))) {
+                    // Check deploy-always negation rules from .c8ignore
+                    if (deployAlways &&
+                        ignoreBaseDir &&
+                        isIgnored(deployAlways, fullPath, ignoreBaseDir)) {
+                        // File matches a !path negation — include it
+                        files.push(fullPath);
+                        return;
+                    }
                     if (skippedExtensions) {
                         const ext = extname(fullPath);
                         skippedExtensions.add(ext || "<no extension>");
                     }
+                    if (skippedFiles) {
+                        skippedFiles.push(fullPath);
+                    }
                     return;
                 }
                 files.push(fullPath);
@@ -199,11 +267,11 @@ function collectResourceFiles(dirPath, collected = [], basePath, ig, ignoreBaseD
         });
         // Process building block folders first (prioritized)
         bbFolders.forEach((bbFolder) => {
-            collectResourceFiles(bbFolder, collected, basePath, ig, ignoreBaseDir, force, extensionList, skippedExtensions);
+            collectResourceFiles(bbFolder, collected, basePath, ig, ignoreBaseDir, force, extensionList, skippedExtensions, skippedFiles, deployAlways);
         });
         // Then process regular folders
         regularFolders.forEach((regularFolder) => {
-            collectResourceFiles(regularFolder, collected, basePath, ig, ignoreBaseDir, force, extensionList, skippedExtensions);
+            collectResourceFiles(regularFolder, collected, basePath, ig, ignoreBaseDir, force, extensionList, skippedExtensions, skippedFiles, deployAlways);
         });
     }
     return collected;
@@ -235,32 +303,118 @@ function findDuplicateDefinitionIds(resources) {
  * @param extensionList - Active allow-list for directory discovery.
  *   Defaults to `DEPLOYABLE_EXTENSIONS` (.bpmn, .dmn, .form).
  */
-function collectResourcesForPaths(paths, force, extensionList = DEPLOYABLE_EXTENSIONS) {
+export function collectResourcesForPaths(paths, force, extensionList = DEPLOYABLE_EXTENSIONS, 
+/** When false, skip loading deploy-always negation rules from .c8ignore.
+ *  Used to suppress them on servers <8.10 that don't support extended extensions. */
+loadDeployAlways = true) {
     if (paths.length === 0) {
         throw new Error("No paths provided. Use: c8 deploy <path> or c8 deploy (for current directory)");
     }
-    // Load .c8ignore rules from the target directory (not cwd) so that
-    // `c8 deploy <target>` picks up the .c8ignore inside the target. (#258)
-    const ignoreBaseDir = resolveIgnoreBaseDir(paths);
+    // ── Process-application auto-detection (#227) ──────────────────────
+    // For each directory path, walk up looking for a .process-application
+    // marker. If found, expand to the PA root so the entire application
+    // is deployed — matching Desktop Modeler behaviour.
+    // File paths are NOT expanded so that watch-mode single-file deploys
+    // remain scoped to the changed file.
+    const effectivePaths = [];
+    const seenRoots = new Set();
+    for (const p of paths) {
+        const abs = resolve(p);
+        let isFile = false;
+        try {
+            isFile = statSync(abs).isFile();
+        }
+        catch {
+            // Path does not exist — skip PA detection and keep the
+            // absolute path so collectResourceFiles (which silently
+            // skips missing paths) falls through to the "No deployable
+            // files found" guard.
+            effectivePaths.push(abs);
+            continue;
+        }
+        if (isFile) {
+            effectivePaths.push(abs);
+            continue;
+        }
+        const paRoot = findProcessApplicationRoot(abs);
+        if (paRoot) {
+            // Deduplicate: multiple input dirs inside the same PA should
+            // only trigger one resource walk from the PA root. Use
+            // realpathSync for the dedup key to handle symlinks/case.
+            let canonical = paRoot;
+            try {
+                canonical = realpathSync(paRoot);
+            }
+            catch {
+                // Best-effort fallback.
+            }
+            if (!seenRoots.has(canonical)) {
+                seenRoots.add(canonical);
+                effectivePaths.push(paRoot);
+            }
+        }
+        else {
+            effectivePaths.push(abs);
+        }
+    }
+    // Load .c8ignore rules from the effective target directory (which may
+    // be the PA root) so that `c8 deploy <target>` picks up the .c8ignore
+    // inside the target. (#258)
+    const ignoreBaseDir = resolveIgnoreBaseDir(effectivePaths);
     const ig = loadIgnoreRules(ignoreBaseDir);
+    // Load !path negation patterns from .c8ignore. Files matching a
+    // negation bypass extension filtering ("deploy them always").
+    // Skipped on servers <8.10 where extended extensions aren't supported.
+    const deployAlways = loadDeployAlways
+        ? loadDeployAlwaysRules(ignoreBaseDir)
+        : null;
     const resources = [];
     const skippedExtensions = new Set();
-    paths.forEach((path) => {
-        collectResourceFiles(path, resources, undefined, ig, ignoreBaseDir, force, extensionList, skippedExtensions);
+    const skippedFiles = [];
+    effectivePaths.forEach((path) => {
+        collectResourceFiles(path, resources, undefined, ig, ignoreBaseDir, force, extensionList, skippedExtensions, skippedFiles, deployAlways ?? undefined);
     });
-    if (resources.length === 0) {
+    // Deduplicate resources by canonical path — can happen when an explicit
+    // file path is also covered by a PA-root or scoped-directory walk, or
+    // when the same file is reachable via symlinks. The canonical path is
+    // used only as the dedup key; the original path/name are preserved for
+    // display and relative-path calculations.
+    const seen = new Set();
+    const deduped = [];
+    for (const r of resources) {
+        let canonical = r.path;
+        try {
+            canonical = realpathSync(r.path);
+        }
+        catch {
+            // Best-effort: fall back to the original path if realpath
+            // fails (e.g. broken symlink).
+        }
+        if (!seen.has(canonical)) {
+            seen.add(canonical);
+            deduped.push(r);
+        }
+    }
+    if (deduped.length === 0) {
         logSkippedExtensions(skippedExtensions);
-        throw new Error("No deployable files found in the specified paths");
+        throw new Error(skippedFiles.length > 0
+            ? `No files with allowed extensions found. ${skippedFiles.length} file(s) were skipped (${[...skippedExtensions].sort().join(", ")}). Use --force to include all files, or --extensions to expand the allow-list.`
+            : "No deployable files found in the specified paths");
     }
-    return { resources, skippedExtensions };
+    return {
+        resources: deduped,
+        skippedExtensions,
+        skippedFiles,
+        effectivePaths,
+    };
 }
 /**
  * Internal helper: deploy the given paths to the cluster and render the
  * result table. Used by `deployCommand` (the standard CLI entry point)
  * and by `watchCommand` (for change-triggered re-deploys).
  *
- * Does NOT consult `c8ctl.dryRun` — dry-run handling lives in the
- * `deployCommand` handler so the framework's `dryRun()` helper owns
+ * Does NOT consult dry-run state — dry-run handling lives in the
+ * `deployCommand` handler so the context's `ctx.dryRun()` helper owns
  * preview emission. Watch never triggers a dry-run, so this split also
  * removes a footgun where a stale dry-run flag could suppress a watch
  * deploy.
@@ -273,15 +427,16 @@ export async function deployResources(paths, options) {
     // straight to the framework's `handleCommandError`. Only the actual
     // HTTP deploy call (further down) is wrapped in a catch that routes
     // through `handleDeploymentError` for rich Problem-Detail rendering.
-    const { resources, skippedExtensions } = collectResourcesForPaths(paths, options.force, options.extensionList ?? DEPLOYABLE_EXTENSIONS);
-    logSkippedExtensions(skippedExtensions);
-    // Store the base paths for relative path calculation. Safe to assign
-    // directly now: the empty-paths guard inside `collectResourcesForPaths`
-    // has already thrown.
-    const basePaths = paths;
+    const { resources, skippedExtensions, effectivePaths } = collectResourcesForPaths(paths, options.force, options.extensionList ?? DEPLOYABLE_EXTENSIONS, options.loadDeployAlways ?? true);
+    if (!options.suppressSkippedLog) {
+        logSkippedExtensions(skippedExtensions);
+    }
+    // Use the effective paths (which may have been expanded to a PA root)
+    // for relative path calculation so display paths make sense.
+    const basePaths = effectivePaths;
     const client = createClient(options.profile);
     // Calculate relative paths for display
-    const basePath = basePaths.length === 1 ? basePaths[0] : process.cwd();
+    const basePath = options.basePath ?? (basePaths.length === 1 ? basePaths[0] : process.cwd());
     resources.forEach((r) => {
         r.relativePath = relative(basePath, r.path) || r.name;
     });
@@ -341,7 +496,19 @@ export async function deployResources(paths, options) {
     // Create a mapping from definition ID to resource file for later reference
     const definitionIdToResource = new Map();
     const formNameToResource = new Map();
+    // Map basename → ResourceFile[]: multiple files can share a basename
+    // across directories (e.g. sub-a/model.dmn, sub-b/model.dmn). When
+    // the API returns a resourceName, we pop the first matching entry so
+    // each response record resolves to a distinct local file.
+    const resourcesByName = new Map();
     resources.forEach((r) => {
+        const existing = resourcesByName.get(r.name);
+        if (existing) {
+            existing.push(r);
+        }
+        else {
+            resourcesByName.set(r.name, [r]);
+        }
         const ext = extname(r.path);
         if (ext === ".bpmn" || ext === ".dmn") {
             const defId = extractDefinitionId(r.content, ext);
@@ -350,11 +517,28 @@ export async function deployResources(paths, options) {
             }
         }
         else if (ext === ".form") {
-            // Forms are matched by filename (without extension)
-            const formId = basename(r.name, ".form");
+            // Forms are matched by their internal ID from the JSON content.
+            // Fall back to filename (without extension) if the ID can't be parsed.
+            let formId = basename(r.name, ".form");
+            try {
+                const parsed = JSON.parse(r.content.toString("utf-8"));
+                if (isRecord(parsed) && typeof parsed.id === "string") {
+                    formId = parsed.id;
+                }
+            }
+            catch {
+                // Not valid JSON — use filename
+            }
             formNameToResource.set(formId, r);
         }
     });
+    /** Pop the first resource with a matching basename, or return undefined. */
+    function popResourceByName(name) {
+        const bucket = resourcesByName.get(name);
+        if (!bucket || bucket.length === 0)
+            return undefined;
+        return bucket.shift();
+    }
     // ─── API call ────────────────────────────────────────────────────────
     // Only this section is wrapped in a catch that routes through
     // `handleDeploymentError`. Pre-API errors above bubble to the
@@ -408,7 +592,7 @@ export async function deployResources(paths, options) {
         if (options.signal?.aborted) {
             return;
         }
-        handleDeploymentError(error, resources, logger, options.continueOnError, options.continueOnUserError);
+        handleDeploymentError(error, resources, logger, options.continueOnError, options.continueOnUserError, options.verbose === true);
         // `handleDeploymentError` either throws (terminal) or returns
         // (continue-on-error). On the continue path, skip the success
         // render below — there's no result to render.
@@ -417,27 +601,80 @@ export async function deployResources(paths, options) {
     options.signal?.removeEventListener("abort", onAbort);
     logger.success("Deployment successful", result.deploymentKey.toString());
     // Normalize all deployed resources into a common structure
+    const knownResources = new Set();
     const allResources = [
-        ...result.processes.map((proc) => ({
-            type: "Process",
-            id: proc.processDefinitionId,
-            version: proc.processDefinitionVersion,
-            key: proc.processDefinitionKey.toString(),
-            resource: definitionIdToResource.get(proc.processDefinitionId),
-        })),
-        ...result.decisions.map((dec) => ({
-            type: "Decision",
-            id: dec.decisionDefinitionId || "-",
-            version: dec.version ?? "-",
-            key: dec.decisionDefinitionKey?.toString() || "-",
-            resource: definitionIdToResource.get(dec.decisionDefinitionId || ""),
-        })),
-        ...result.forms.map((form) => ({
-            type: "Form",
-            id: form.formId || "-",
-            version: form.version ?? "-",
-            key: form.formKey?.toString() || "-",
-            resource: formNameToResource.get(form.formId || ""),
+        ...result.processes.map((proc) => {
+            const resource = definitionIdToResource.get(proc.processDefinitionId);
+            if (resource)
+                knownResources.add(resource);
+            return {
+                type: "Process",
+                id: proc.processDefinitionId,
+                version: proc.processDefinitionVersion,
+                key: proc.processDefinitionKey.toString(),
+                resource,
+            };
+        }),
+        ...result.decisions.map((dec) => {
+            const resource = definitionIdToResource.get(dec.decisionDefinitionId || "");
+            if (resource)
+                knownResources.add(resource);
+            return {
+                type: "Decision",
+                id: dec.decisionDefinitionId || "-",
+                version: dec.version ?? "-",
+                key: dec.decisionDefinitionKey?.toString() || "-",
+                resource,
+            };
+        }),
+        ...result.decisionRequirements.map((dr) => {
+            const resource = popResourceByName(dr.resourceName || "");
+            if (resource)
+                knownResources.add(resource);
+            return {
+                type: "Decision Requirements",
+                id: dr.decisionRequirementsId || "-",
+                version: dr.version ?? "-",
+                key: dr.decisionRequirementsKey?.toString() || "-",
+                resource,
+            };
+        }),
+        ...result.forms.map((form) => {
+            const resource = formNameToResource.get(form.formId || "");
+            if (resource)
+                knownResources.add(resource);
+            return {
+                type: "Form",
+                id: form.formId || "-",
+                version: form.version ?? "-",
+                key: form.formKey?.toString() || "-",
+                resource,
+            };
+        }),
+        // Generic resources (not processes, decisions, or forms)
+        // are returned in the `resources` array by 8.10+.
+        ...result.resources.map((res) => {
+            const resource = popResourceByName(res.resourceName || "");
+            if (resource)
+                knownResources.add(resource);
+            return {
+                type: "Resource",
+                id: res.resourceId || "-",
+                version: res.version ?? "-",
+                key: res.resourceKey?.toString() || "-",
+                resource,
+            };
+        }),
+        // Supplementary resources not returned in any response array.
+        // Show them in the table so the user knows they were deployed.
+        ...resources
+            .filter((r) => !knownResources.has(r))
+            .map((r) => ({
+            type: "Resource",
+            id: "-",
+            version: "-",
+            key: "-",
+            resource: r,
         })),
     ];
     const tableData = allResources.map(({ type, id, version, key, resource }) => {
@@ -479,13 +716,13 @@ export async function deployResources(paths, options) {
 /**
  * Format and display deployment errors with actionable guidance
  */
-function handleDeploymentError(error, resources, logger, continueOnError, continueOnUserError) {
+function handleDeploymentError(error, resources, logger, continueOnError, continueOnUserError, verbose) {
     // Extract problem title early to determine whether this is a user-fixable error
     const raw = isRecord(error) ? error : {};
     const problemTitle = typeof raw.title === "string" ? raw.title : undefined;
     const isUserFixable = problemTitle === "INVALID_ARGUMENT";
     const shouldContinue = continueOnError || (continueOnUserError && isUserFixable);
-    if (c8ctl.verbose) {
+    if (verbose) {
         if (shouldContinue) {
             throw error;
         }
@@ -645,89 +882,4 @@ function printDeploymentHints(title, detail, status, resources) {
         logMessage(h);
     });
 }
-// ─── defineCommand ───────────────────────────────────────────────────────────
-/**
- * Resolve the effective extension allow-list from the deploy flags.
- *
- * Priority: --force (no filtering) > --all-extensions > --extensions > default
- *
- * When `--extensions` is provided, the custom list is *merged* with the
- * default (.bpmn, .dmn, .form) so users add to the baseline rather than
- * replacing it.
- */
-function resolveExtensionList(flags) {
-    // When --force is set the allow-list is irrelevant — downstream code
-    // skips filtering entirely. Return the default so callers always get a
-    // valid list, but the value is never consulted.
-    if (flags.force)
-        return DEPLOYABLE_EXTENSIONS;
-    // --all-extensions: use the full server-supported list
-    if (flags["all-extensions"])
-        return ALL_DEPLOYABLE_EXTENSIONS;
-    // --extensions: merge custom extensions with the default set
-    if (flags.extensions && String(flags.extensions).trim()) {
-        const custom = String(flags.extensions)
-            .split(",")
-            .map((e) => e.trim())
-            .filter(Boolean)
-            .map((e) => (e.startsWith(".") ? e : `.${e}`));
-        const merged = [...new Set([...DEPLOYABLE_EXTENSIONS, ...custom])];
-        return merged;
-    }
-    return DEPLOYABLE_EXTENSIONS;
-}
-/**
- * Side-effectful: collects files, validates, deploys, and renders its own
- * table output.
- *
- * The body lives directly in the handler (per #288): argument-shape
- * resolution, dry-run preview via the framework's `dryRun()` helper,
- * and the call into the shared `deployResources` helper that watch also
- * uses for change-triggered re-deploys.
- */
-export const deployCommand = defineCommand("deploy", "", async (ctx, flags) => {
-    // Argument shape: `c8 deploy [path...]`. With no positional, default
-    // to cwd. Pinned by tests/unit/deploy-behaviour.test.ts.
-    const paths = ctx.resource
-        ? [ctx.resource, ...ctx.positionals]
-        : ctx.positionals.length > 0
-            ? ctx.positionals
-            : ["."];
-    // Resolve the active extension allow-list from flags.
-    // Priority: --force (no filtering) > --all-extensions > --extensions > default
-    const extensionList = resolveExtensionList(flags);
-    // Dry-run preview. Collect resources first so the preview body
-    // reflects what would actually be sent — and so the empty-paths /
-    // no-files guards still surface as thrown errors before we emit.
-    // Uses `ctx.dryRun` and `ctx.tenantId` from the framework rather
-    // than reaching into the global runtime/config layer.
-    if (ctx.dryRun) {
-        const { resources: previewResources, skippedExtensions } = collectResourcesForPaths(paths, flags.force, extensionList);
-        logSkippedExtensions(skippedExtensions);
-        const dr = dryRun({
-            command: "deploy",
-            method: "POST",
-            endpoint: "/deployments",
-            profile: ctx.profile,
-            body: {
-                tenantId: ctx.tenantId,
-                resources: previewResources.map((r) => ({ name: r.name })),
-            },
-        });
-        if (dr)
-            return dr;
-    }
-    // Execute path: only reached when not in dry-run mode (the branch
-    // above returns early). `deployResources` runs its own
-    // `collectResourcesForPaths` internally and renders the success
-    // table. Keeping the helper self-contained avoids threading
-    // pre-collected state between the handler and the shared helper
-    // used by `watch`.
-    await deployResources(paths, {
-        profile: ctx.profile,
-        force: flags.force,
-        extensionList,
-    });
-    return { kind: "none" };
-});
-//# sourceMappingURL=deployments.js.map
+//# sourceMappingURL=deploy-helpers.js.map