@camunda8/cli 2.6.1 → 2.7.0-alpha.10

package/dist/commands/search.js

@@ -1,136 +1,10 @@
 /**
  * Search commands
  */
-import { createClient, DEFAULT_PAGE_SIZE, emitDryRun, fetchAllPages, } from "../client.js";
-import { resolveTenantId } from "../config.js";
+import { DEFAULT_PAGE_SIZE, fetchAllPages } from "../client.js";
+import { defineCommand, dryRun } from "../command-framework.js";
 import { buildDateFilter, parseBetween } from "../date-filter.js";
-import { handleCommandError } from "../errors.js";
-import { getLogger, sortTableData, } from "../logger.js";
-/**
- * CLI infrastructure flags — valid for every command, never passed to search APIs.
- */
-const CLI_FLAGS = new Set(["profile", "help", "version"]);
-/**
- * Search behavior flags consumed by shared infrastructure (fetchAllPages / buildDateFilter / sort)
- * for ALL search resources. A flag belongs here only if every search handler consumes it
- * via shared code paths — never for flags consumed by a subset of handlers.
- *
- * If a flag is only relevant to some resources, put it in SEARCH_RESOURCE_FLAGS instead.
- */
-const SHARED_SEARCH_FLAGS = new Set([
-    "sortBy",
-    "asc",
-    "desc",
-    "between",
-    "dateField",
-]);
-/**
- * Union of CLI_FLAGS and SHARED_SEARCH_FLAGS — exported for use in detectUnknownSearchFlags.
- * Do NOT add resource-specific flags here; add them to SEARCH_RESOURCE_FLAGS instead.
- */
-export const GLOBAL_FLAGS = new Set([...CLI_FLAGS, ...SHARED_SEARCH_FLAGS]);
-/**
- * Valid search filter flags per resource (values keys that are consumed by the search handler).
- * This map is used to detect when a user passes a flag that looks valid but is not recognized
- * for the specific resource, causing silent filter drops.
- */
-export const SEARCH_RESOURCE_FLAGS = {
-    "process-definition": new Set([
-        "bpmnProcessId",
-        "id",
-        "processDefinitionId",
-        "name",
-        "key",
-        "iid",
-        "iname",
-    ]),
-    "process-instance": new Set([
-        "bpmnProcessId",
-        "id",
-        "processDefinitionId",
-        "processDefinitionKey",
-        "state",
-        "key",
-        "parentProcessInstanceKey",
-        "iid",
-    ]),
-    "user-task": new Set([
-        "state",
-        "assignee",
-        "processInstanceKey",
-        "processDefinitionKey",
-        "elementId",
-        "iassignee",
-    ]),
-    incident: new Set([
-        "state",
-        "processInstanceKey",
-        "processDefinitionKey",
-        "bpmnProcessId",
-        "id",
-        "processDefinitionId",
-        "errorType",
-        "errorMessage",
-        "ierrorMessage",
-        "iid",
-    ]),
-    jobs: new Set([
-        "state",
-        "type",
-        "processInstanceKey",
-        "processDefinitionKey",
-        "itype",
-    ]),
-    variable: new Set([
-        "name",
-        "value",
-        "processInstanceKey",
-        "scopeKey",
-        "fullValue",
-        "iname",
-        "ivalue",
-        "limit",
-    ]),
-    user: new Set(["username", "name", "email", "limit"]),
-    role: new Set(["roleId", "name", "limit"]),
-    group: new Set(["groupId", "name", "limit"]),
-    tenant: new Set(["tenantId", "name", "limit"]),
-    authorization: new Set([
-        "ownerId",
-        "ownerType",
-        "resourceType",
-        "resourceId",
-        "limit",
-    ]),
-    "mapping-rule": new Set([
-        "mappingRuleId",
-        "name",
-        "claimName",
-        "claimValue",
-        "limit",
-    ]),
-};
-/**
- * Detect flags the user set that are not recognized for the given search resource.
- * Returns the list of unknown flag names (without the --prefix).
- */
-export function detectUnknownSearchFlags(values, normalizedResource) {
-    const validFlags = SEARCH_RESOURCE_FLAGS[normalizedResource] ||
-        SEARCH_RESOURCE_FLAGS[normalizedResource.replace(/s$/, "")];
-    if (!validFlags)
-        return [];
-    const unknown = [];
-    for (const [key, val] of Object.entries(values)) {
-        if (val === undefined || val === false)
-            continue; // not set by the user
-        if (GLOBAL_FLAGS.has(key))
-            continue;
-        if (validFlags.has(key))
-            continue;
-        unknown.push(key);
-    }
-    return unknown;
-}
+import { sortTableData } from "../logger.js";
 /**
  * Detect wildcard characters (* or ?) in a string value and return
  * a $like filter object for the API. Returns the plain string for exact match.
@@ -270,661 +144,623 @@ export function logResultCount(logger, count, resourceName, hasFilters) {
 /**
  * Search process definitions
  */
-export async function searchProcessDefinitions(options) {
-    const logger = getLogger();
-    const client = createClient(options.profile);
-    const tenantId = resolveTenantId(options.profile);
-    const hasCiFilter = !!(options.iProcessDefinitionId || options.iName);
+export const searchProcessDefinitionsCommand = defineCommand("search", "process-definition", async (ctx, flags, _args) => {
+    const { client, logger, tenantId, profile } = ctx;
+    const processDefinitionId = flags.id || flags.processDefinitionId || flags.bpmnProcessId;
+    const version = ctx.version;
+    const hasCiFilter = !!(flags.iid || flags.iname);
     // Build search criteria description for user feedback
     const criteria = [];
-    if (options.processDefinitionId) {
-        criteria.push(formatCriterion("Process Definition ID", options.processDefinitionId));
+    if (processDefinitionId) {
+        criteria.push(formatCriterion("Process Definition ID", processDefinitionId));
+    }
+    if (flags.name) {
+        criteria.push(formatCriterion("name", flags.name));
+    }
+    if (version !== undefined) {
+        criteria.push(formatCriterion("version", version));
+    }
+    if (flags.key) {
+        criteria.push(formatCriterion("key", flags.key));
+    }
+    if (flags.iid) {
+        criteria.push(formatCriterion("Process Definition ID", flags.iid, true));
+    }
+    if (flags.iname) {
+        criteria.push(formatCriterion("name", flags.iname, true));
+    }
+    const filter = {
+        filter: {
+            tenantId,
+        },
+    };
+    if (processDefinitionId) {
+        filter.filter.processDefinitionId = toStringFilter(processDefinitionId);
+    }
+    if (flags.name) {
+        filter.filter.name = toStringFilter(flags.name);
+    }
+    if (version !== undefined) {
+        filter.filter.version = version;
+    }
+    if (flags.key) {
+        filter.filter.processDefinitionKey = flags.key;
+    }
+    const dr = dryRun({
+        command: "search process-definitions",
+        method: "POST",
+        endpoint: "/process-definitions/search",
+        profile,
+        body: filter,
+    });
+    if (dr)
+        return dr;
+    logSearchCriteria(logger, "Process Definitions", criteria);
+    const allItems = await fetchAllPages((f, opts) => client.searchProcessDefinitions(f, opts), filter, ...(hasCiFilter ? [CI_PAGE_SIZE] : []));
+    const result = { items: allItems };
+    if (result.items?.length) {
+        result.items = [...result.items].sort((left, right) => {
+            const versionDelta = (Number(right.version) || 0) - (Number(left.version) || 0);
+            if (versionDelta !== 0)
+                return versionDelta;
+            const leftKey = toBigIntSafe(left.processDefinitionKey ?? left.key);
+            const rightKey = toBigIntSafe(right.processDefinitionKey ?? right.key);
+            if (leftKey === rightKey)
+                return 0;
+            return rightKey > leftKey ? 1 : -1;
+        });
+    }
+    // Client-side case-insensitive post-filtering
+    if (hasCiFilter && result.items) {
+        result.items = result.items.filter((pd) => {
+            if (flags.iid &&
+                !matchesCaseInsensitive(pd.processDefinitionId, flags.iid))
+                return false;
+            if (flags.iname && !matchesCaseInsensitive(pd.name, flags.iname))
+                return false;
+            return true;
+        });
+    }
+    if (result.items && result.items.length > 0) {
+        let tableData = result.items.map((pd) => ({
+            Key: pd.processDefinitionKey || pd.key,
+            "Process ID": pd.processDefinitionId,
+            Name: pd.name || "-",
+            Version: pd.version,
+            "Tenant ID": pd.tenantId,
+        }));
+        tableData = sortTableData(tableData, ctx.sortBy, logger, ctx.sortOrder);
+        logger.table(tableData);
+        logResultCount(logger, result.items.length, "process definition(s)", criteria.length > 0);
     }
-    if (options.name) {
-        criteria.push(formatCriterion("name", options.name));
+    else {
+        logNoResults(logger, "process definitions", criteria.length > 0);
     }
-    if (options.version !== undefined) {
-        criteria.push(formatCriterion("version", options.version));
+});
+/**
+ * Search process instances
+ */
+export const searchProcessInstancesCommand = defineCommand("search", "process-instance", async (ctx, flags, _args) => {
+    const { client, logger, tenantId, profile } = ctx;
+    const processDefinitionId = flags.id || flags.processDefinitionId || flags.bpmnProcessId;
+    const version = ctx.version;
+    const hasCiFilter = !!flags.iid;
+    // Build search criteria description for user feedback
+    const criteria = [];
+    if (processDefinitionId) {
+        criteria.push(formatCriterion("Process Definition ID", processDefinitionId));
     }
-    if (options.key) {
-        criteria.push(formatCriterion("key", options.key));
+    if (flags.processDefinitionKey) {
+        criteria.push(formatCriterion("Process Definition Key", flags.processDefinitionKey));
     }
-    if (options.iProcessDefinitionId) {
-        criteria.push(formatCriterion("Process Definition ID", options.iProcessDefinitionId, true));
+    if (flags.state) {
+        criteria.push(formatCriterion("state", flags.state));
     }
-    if (options.iName) {
-        criteria.push(formatCriterion("name", options.iName, true));
+    if (version !== undefined) {
+        criteria.push(formatCriterion("version", version));
     }
-    try {
-        const filter = {
-            filter: {
-                tenantId,
-            },
-        };
-        if (options.processDefinitionId) {
-            filter.filter.processDefinitionId = toStringFilter(options.processDefinitionId);
-        }
-        if (options.name) {
-            filter.filter.name = toStringFilter(options.name);
-        }
-        if (options.version !== undefined) {
-            filter.filter.version = options.version;
-        }
-        if (options.key) {
-            filter.filter.processDefinitionKey = options.key;
-        }
-        if (emitDryRun({
-            command: "search process-definitions",
-            method: "POST",
-            endpoint: "/process-definitions/search",
-            profile: options.profile,
-            body: filter,
-        }))
-            return;
-        logSearchCriteria(logger, "Process Definitions", criteria);
-        const allItems = await fetchAllPages((f, opts) => client.searchProcessDefinitions(f, opts), filter, ...(hasCiFilter ? [CI_PAGE_SIZE] : []));
-        const result = { items: allItems };
-        if (result.items?.length) {
-            result.items = [...result.items].sort((left, right) => {
-                const versionDelta = (Number(right.version) || 0) - (Number(left.version) || 0);
-                if (versionDelta !== 0)
-                    return versionDelta;
-                const leftKey = toBigIntSafe(left.processDefinitionKey ?? left.key);
-                const rightKey = toBigIntSafe(right.processDefinitionKey ?? right.key);
-                if (leftKey === rightKey)
-                    return 0;
-                return rightKey > leftKey ? 1 : -1;
-            });
-        }
-        // Client-side case-insensitive post-filtering
-        if (hasCiFilter && result.items) {
-            result.items = result.items.filter((pd) => {
-                if (options.iProcessDefinitionId &&
-                    !matchesCaseInsensitive(pd.processDefinitionId, options.iProcessDefinitionId))
-                    return false;
-                if (options.iName && !matchesCaseInsensitive(pd.name, options.iName))
-                    return false;
-                return true;
-            });
-        }
-        if (result.items && result.items.length > 0) {
-            let tableData = result.items.map((pd) => ({
-                Key: pd.processDefinitionKey || pd.key,
-                "Process ID": pd.processDefinitionId,
-                Name: pd.name || "-",
-                Version: pd.version,
-                "Tenant ID": pd.tenantId,
-            }));
-            tableData = sortTableData(tableData, options.sortBy, logger, options.sortOrder);
-            logger.table(tableData);
-            logResultCount(logger, result.items.length, "process definition(s)", criteria.length > 0);
-        }
-        else {
-            logNoResults(logger, "process definitions", criteria.length > 0, options._unknownFlags);
-        }
-        return result;
+    if (flags.key) {
+        criteria.push(formatCriterion("key", flags.key));
     }
-    catch (error) {
-        handleCommandError(logger, "Failed to search process definitions", error);
+    if (flags.parentProcessInstanceKey) {
+        criteria.push(formatCriterion("Parent Process Instance Key", flags.parentProcessInstanceKey));
     }
-}
-/**
- * Search process instances
- */
-export async function searchProcessInstances(options) {
-    const logger = getLogger();
-    const client = createClient(options.profile);
-    const tenantId = resolveTenantId(options.profile);
-    const hasCiFilter = !!options.iProcessDefinitionId;
-    // Build search criteria description for user feedback
-    const criteria = [];
-    if (options.processDefinitionId) {
-        criteria.push(formatCriterion("Process Definition ID", options.processDefinitionId));
+    if (flags.iid) {
+        criteria.push(formatCriterion("Process Definition ID", flags.iid, true));
     }
-    if (options.processDefinitionKey) {
-        criteria.push(formatCriterion("Process Definition Key", options.processDefinitionKey));
+    if (ctx.between) {
+        const field = ctx.dateField ?? "startDate";
+        criteria.push(`'${field}' between "${ctx.between}"`);
     }
-    if (options.state) {
-        criteria.push(formatCriterion("state", options.state));
+    const filter = {
+        filter: {
+            tenantId,
+        },
+    };
+    if (processDefinitionId) {
+        filter.filter.processDefinitionId = toStringFilter(processDefinitionId);
     }
-    if (options.version !== undefined) {
-        criteria.push(formatCriterion("version", options.version));
+    if (flags.processDefinitionKey) {
+        filter.filter.processDefinitionKey = flags.processDefinitionKey;
     }
-    if (options.key) {
-        criteria.push(formatCriterion("key", options.key));
+    if (version !== undefined) {
+        filter.filter.processDefinitionVersion = version;
     }
-    if (options.parentProcessInstanceKey) {
-        criteria.push(formatCriterion("Parent Process Instance Key", options.parentProcessInstanceKey));
+    if (flags.state) {
+        filter.filter.state = flags.state;
     }
-    if (options.iProcessDefinitionId) {
-        criteria.push(formatCriterion("Process Definition ID", options.iProcessDefinitionId, true));
+    if (flags.key) {
+        filter.filter.processInstanceKey = flags.key;
     }
-    if (options.between) {
-        const field = options.dateField ?? "startDate";
-        criteria.push(`'${field}' between "${options.between}"`);
+    if (flags.parentProcessInstanceKey) {
+        filter.filter.parentProcessInstanceKey = flags.parentProcessInstanceKey;
     }
-    try {
-        const filter = {
-            filter: {
-                tenantId,
-            },
-        };
-        if (options.processDefinitionId) {
-            filter.filter.processDefinitionId = toStringFilter(options.processDefinitionId);
-        }
-        if (options.processDefinitionKey) {
-            filter.filter.processDefinitionKey = options.processDefinitionKey;
-        }
-        if (options.version !== undefined) {
-            filter.filter.processDefinitionVersion = options.version;
-        }
-        if (options.state) {
-            filter.filter.state = options.state;
-        }
-        if (options.key) {
-            filter.filter.processInstanceKey = options.key;
-        }
-        if (options.parentProcessInstanceKey) {
-            filter.filter.parentProcessInstanceKey = options.parentProcessInstanceKey;
-        }
-        if (options.between) {
-            const parsed = parseBetween(options.between);
-            if (parsed) {
-                const field = options.dateField ?? "startDate";
-                filter.filter[field] = buildDateFilter(parsed.from, parsed.to);
-            }
-            else {
-                logger.error("Invalid --between value. Expected format: <from>..<to> (e.g. 2024-01-01..2024-12-31, ISO 8601 datetimes, or open-ended: ..2024-12-31 or 2024-01-01..)");
-                process.exit(1);
-            }
-        }
-        if (emitDryRun({
-            command: "search process-instances",
-            method: "POST",
-            endpoint: "/process-instances/search",
-            profile: options.profile,
-            body: filter,
-        }))
-            return;
-        logSearchCriteria(logger, "Process Instances", criteria);
-        const allItems = await fetchAllPages((f, opts) => client.searchProcessInstances(f, opts), filter, ...(hasCiFilter ? [CI_PAGE_SIZE] : []));
-        const result = { items: allItems };
-        if (hasCiFilter && result.items) {
-            result.items = result.items.filter((pi) => {
-                if (options.iProcessDefinitionId &&
-                    !matchesCaseInsensitive(pi.processDefinitionId, options.iProcessDefinitionId))
-                    return false;
-                return true;
-            });
-        }
-        if (result.items && result.items.length > 0) {
-            let tableData = result.items.map((pi) => ({
-                Key: pi.processInstanceKey || pi.key,
-                "Process ID": pi.processDefinitionId,
-                State: pi.state,
-                Version: pi.processDefinitionVersion || pi.version,
-                "Start Date": pi.startDate || "-",
-                "Tenant ID": pi.tenantId,
-            }));
-            tableData = sortTableData(tableData, options.sortBy, logger, options.sortOrder);
-            logger.table(tableData);
-            logResultCount(logger, result.items.length, "process instance(s)", criteria.length > 0);
+    if (ctx.between) {
+        const parsed = parseBetween(ctx.between);
+        if (parsed) {
+            const field = ctx.dateField ?? "startDate";
+            filter.filter[field] = buildDateFilter(parsed.from, parsed.to);
         }
         else {
-            logNoResults(logger, "process instances", criteria.length > 0, options._unknownFlags);
-        }
-        return result;
+            logger.error("Invalid --between value. Expected format: <from>..<to> (e.g. 2024-01-01..2024-12-31, ISO 8601 datetimes, or open-ended: ..2024-12-31 or 2024-01-01..)");
+            process.exit(1);
+        }
+    }
+    const dr = dryRun({
+        command: "search process-instances",
+        method: "POST",
+        endpoint: "/process-instances/search",
+        profile,
+        body: filter,
+    });
+    if (dr)
+        return dr;
+    logSearchCriteria(logger, "Process Instances", criteria);
+    const allItems = await fetchAllPages((f, opts) => client.searchProcessInstances(f, opts), filter, ...(hasCiFilter ? [CI_PAGE_SIZE] : []));
+    const result = { items: allItems };
+    if (hasCiFilter && result.items) {
+        result.items = result.items.filter((pi) => {
+            if (flags.iid &&
+                !matchesCaseInsensitive(pi.processDefinitionId, flags.iid))
+                return false;
+            return true;
+        });
+    }
+    if (result.items && result.items.length > 0) {
+        let tableData = result.items.map((pi) => ({
+            Key: pi.processInstanceKey || pi.key,
+            "Process ID": pi.processDefinitionId,
+            State: pi.state,
+            Version: pi.processDefinitionVersion || pi.version,
+            "Start Date": pi.startDate || "-",
+            "Tenant ID": pi.tenantId,
+        }));
+        tableData = sortTableData(tableData, ctx.sortBy, logger, ctx.sortOrder);
+        logger.table(tableData);
+        logResultCount(logger, result.items.length, "process instance(s)", criteria.length > 0);
     }
-    catch (error) {
-        handleCommandError(logger, "Failed to search process instances", error);
+    else {
+        logNoResults(logger, "process instances", criteria.length > 0);
     }
-}
+});
 /**
  * Search user tasks
  */
-export async function searchUserTasks(options) {
-    const logger = getLogger();
-    const client = createClient(options.profile);
-    const tenantId = resolveTenantId(options.profile);
-    const hasCiFilter = !!options.iAssignee;
+export const searchUserTasksCommand = defineCommand("search", "user-task", async (ctx, flags, _args) => {
+    const { client, logger, tenantId, profile } = ctx;
+    const hasCiFilter = !!flags.iassignee;
     // Build search criteria description for user feedback
     const criteria = [];
-    if (options.state) {
-        criteria.push(formatCriterion("state", options.state));
+    if (flags.state) {
+        criteria.push(formatCriterion("state", flags.state));
     }
-    if (options.assignee) {
-        criteria.push(formatCriterion("assignee", options.assignee));
+    if (flags.assignee) {
+        criteria.push(formatCriterion("assignee", flags.assignee));
     }
-    if (options.processInstanceKey) {
-        criteria.push(formatCriterion("Process Instance Key", options.processInstanceKey));
+    if (flags.processInstanceKey) {
+        criteria.push(formatCriterion("Process Instance Key", flags.processInstanceKey));
     }
-    if (options.processDefinitionKey) {
-        criteria.push(formatCriterion("Process Definition Key", options.processDefinitionKey));
+    if (flags.processDefinitionKey) {
+        criteria.push(formatCriterion("Process Definition Key", flags.processDefinitionKey));
     }
-    if (options.elementId) {
-        criteria.push(formatCriterion("Element ID", options.elementId));
+    if (flags.elementId) {
+        criteria.push(formatCriterion("Element ID", flags.elementId));
     }
-    if (options.iAssignee) {
-        criteria.push(formatCriterion("assignee", options.iAssignee, true));
+    if (flags.iassignee) {
+        criteria.push(formatCriterion("assignee", flags.iassignee, true));
     }
-    if (options.between) {
-        const field = options.dateField ?? "creationDate";
-        criteria.push(`'${field}' between "${options.between}"`);
+    if (ctx.between) {
+        const field = ctx.dateField ?? "creationDate";
+        criteria.push(`'${field}' between "${ctx.between}"`);
     }
-    try {
-        const filter = {
-            filter: {
-                tenantId,
-            },
-        };
-        if (options.state) {
-            filter.filter.state = options.state;
-        }
-        if (options.assignee) {
-            filter.filter.assignee = toStringFilter(options.assignee);
-        }
-        if (options.processInstanceKey) {
-            filter.filter.processInstanceKey = options.processInstanceKey;
-        }
-        if (options.processDefinitionKey) {
-            filter.filter.processDefinitionKey = options.processDefinitionKey;
-        }
-        if (options.elementId) {
-            filter.filter.elementId = options.elementId;
-        }
-        if (options.between) {
-            const parsed = parseBetween(options.between);
-            if (parsed) {
-                const field = options.dateField ?? "creationDate";
-                filter.filter[field] = buildDateFilter(parsed.from, parsed.to);
-            }
-            else {
-                logger.error("Invalid --between value. Expected format: <from>..<to> (e.g. 2024-01-01..2024-12-31, ISO 8601 datetimes, or open-ended: ..2024-12-31 or 2024-01-01..)");
-                process.exit(1);
-            }
-        }
-        if (emitDryRun({
-            command: "search user-tasks",
-            method: "POST",
-            endpoint: "/user-tasks/search",
-            profile: options.profile,
-            body: filter,
-        }))
-            return;
-        logSearchCriteria(logger, "User Tasks", criteria);
-        const allItems = await fetchAllPages((f, opts) => client.searchUserTasks(f, opts), filter, ...(hasCiFilter ? [CI_PAGE_SIZE] : []));
-        const result = { items: allItems };
-        if (hasCiFilter && result.items) {
-            result.items = result.items.filter((task) => {
-                if (options.iAssignee &&
-                    !matchesCaseInsensitive(task.assignee, options.iAssignee))
-                    return false;
-                return true;
-            });
-        }
-        if (result.items && result.items.length > 0) {
-            let tableData = result.items.map((task) => ({
-                Key: task.userTaskKey || task.key,
-                Name: task.name || task.elementId,
-                State: task.state,
-                Assignee: task.assignee || "(unassigned)",
-                Created: task.creationDate || "-",
-                "Process Instance": task.processInstanceKey,
-                "Tenant ID": task.tenantId,
-            }));
-            tableData = sortTableData(tableData, options.sortBy, logger, options.sortOrder);
-            logger.table(tableData);
-            logResultCount(logger, result.items.length, "user task(s)", criteria.length > 0);
+    const filter = {
+        filter: {
+            tenantId,
+        },
+    };
+    if (flags.state) {
+        filter.filter.state = flags.state;
+    }
+    if (flags.assignee) {
+        filter.filter.assignee = toStringFilter(flags.assignee);
+    }
+    if (flags.processInstanceKey) {
+        filter.filter.processInstanceKey = flags.processInstanceKey;
+    }
+    if (flags.processDefinitionKey) {
+        filter.filter.processDefinitionKey = flags.processDefinitionKey;
+    }
+    if (flags.elementId) {
+        filter.filter.elementId = flags.elementId;
+    }
+    if (ctx.between) {
+        const parsed = parseBetween(ctx.between);
+        if (parsed) {
+            const field = ctx.dateField ?? "creationDate";
+            filter.filter[field] = buildDateFilter(parsed.from, parsed.to);
         }
         else {
-            logNoResults(logger, "user tasks", criteria.length > 0, options._unknownFlags);
-        }
-        return result;
+            logger.error("Invalid --between value. Expected format: <from>..<to> (e.g. 2024-01-01..2024-12-31, ISO 8601 datetimes, or open-ended: ..2024-12-31 or 2024-01-01..)");
+            process.exit(1);
+        }
+    }
+    const dr = dryRun({
+        command: "search user-tasks",
+        method: "POST",
+        endpoint: "/user-tasks/search",
+        profile,
+        body: filter,
+    });
+    if (dr)
+        return dr;
+    logSearchCriteria(logger, "User Tasks", criteria);
+    const allItems = await fetchAllPages((f, opts) => client.searchUserTasks(f, opts), filter, ...(hasCiFilter ? [CI_PAGE_SIZE] : []));
+    const result = { items: allItems };
+    if (hasCiFilter && result.items) {
+        result.items = result.items.filter((task) => {
+            if (flags.iassignee &&
+                !matchesCaseInsensitive(task.assignee, flags.iassignee))
+                return false;
+            return true;
+        });
+    }
+    if (result.items && result.items.length > 0) {
+        let tableData = result.items.map((task) => ({
+            Key: task.userTaskKey || task.key,
+            Name: task.name || task.elementId,
+            State: task.state,
+            Assignee: task.assignee || "(unassigned)",
+            Created: task.creationDate || "-",
+            "Process Instance": task.processInstanceKey,
+            "Tenant ID": task.tenantId,
+        }));
+        tableData = sortTableData(tableData, ctx.sortBy, logger, ctx.sortOrder);
+        logger.table(tableData);
+        logResultCount(logger, result.items.length, "user task(s)", criteria.length > 0);
     }
-    catch (error) {
-        handleCommandError(logger, "Failed to search user tasks", error);
+    else {
+        logNoResults(logger, "user tasks", criteria.length > 0);
     }
-}
+});
 /**
  * Search incidents
  */
-export async function searchIncidents(options) {
-    const logger = getLogger();
-    const client = createClient(options.profile);
-    const tenantId = resolveTenantId(options.profile);
+export const searchIncidentsCommand = defineCommand("search", "incident", async (ctx, flags, _args) => {
+    const { client, logger, tenantId, profile } = ctx;
+    const processDefinitionId = flags.id || flags.processDefinitionId || flags.bpmnProcessId;
     // The incident API does not support a $like filter for errorMessage; fall back to client-side filtering for wildcard patterns
-    const errorMessageHasWildcard = !!(options.errorMessage && hasUnescapedWildcard(options.errorMessage));
-    const hasCiFilter = !!(options.iErrorMessage ||
-        options.iProcessDefinitionId ||
+    const errorMessageHasWildcard = !!(flags.errorMessage && hasUnescapedWildcard(flags.errorMessage));
+    const hasCiFilter = !!(flags.ierrorMessage ||
+        flags.iid ||
         errorMessageHasWildcard);
     // Build search criteria description for user feedback
     const criteria = [];
-    if (options.state) {
-        criteria.push(formatCriterion("state", options.state));
+    if (flags.state) {
+        criteria.push(formatCriterion("state", flags.state));
     }
-    if (options.processInstanceKey) {
-        criteria.push(formatCriterion("Process Instance Key", options.processInstanceKey));
+    if (flags.processInstanceKey) {
+        criteria.push(formatCriterion("Process Instance Key", flags.processInstanceKey));
     }
-    if (options.processDefinitionKey) {
-        criteria.push(formatCriterion("Process Definition Key", options.processDefinitionKey));
+    if (flags.processDefinitionKey) {
+        criteria.push(formatCriterion("Process Definition Key", flags.processDefinitionKey));
     }
-    if (options.errorType) {
-        criteria.push(formatCriterion("Error Type", options.errorType));
+    if (flags.errorType) {
+        criteria.push(formatCriterion("Error Type", flags.errorType));
     }
-    if (options.errorMessage) {
-        criteria.push(formatCriterion("Error Message", options.errorMessage));
+    if (flags.errorMessage) {
+        criteria.push(formatCriterion("Error Message", flags.errorMessage));
     }
-    if (options.processDefinitionId) {
-        criteria.push(formatCriterion("Process Definition ID", options.processDefinitionId));
+    if (processDefinitionId) {
+        criteria.push(formatCriterion("Process Definition ID", processDefinitionId));
     }
-    if (options.iErrorMessage) {
-        criteria.push(formatCriterion("Error Message", options.iErrorMessage, true));
+    if (flags.ierrorMessage) {
+        criteria.push(formatCriterion("Error Message", flags.ierrorMessage, true));
     }
-    if (options.iProcessDefinitionId) {
-        criteria.push(formatCriterion("Process Definition ID", options.iProcessDefinitionId, true));
+    if (flags.iid) {
+        criteria.push(formatCriterion("Process Definition ID", flags.iid, true));
     }
-    if (options.between) {
-        criteria.push(`'creationTime' between "${options.between}"`);
+    if (ctx.between) {
+        criteria.push(`'creationTime' between "${ctx.between}"`);
     }
-    try {
-        const filter = {
-            filter: {
-                tenantId,
-            },
-        };
-        if (options.state) {
-            filter.filter.state = options.state;
-        }
-        if (options.processInstanceKey) {
-            filter.filter.processInstanceKey = options.processInstanceKey;
-        }
-        if (options.processDefinitionKey) {
-            filter.filter.processDefinitionKey = options.processDefinitionKey;
-        }
-        if (options.errorType) {
-            filter.filter.errorType = options.errorType;
-        }
-        if (options.errorMessage && !errorMessageHasWildcard) {
-            filter.filter.errorMessage = options.errorMessage;
-        }
-        if (options.processDefinitionId) {
-            filter.filter.processDefinitionId = toStringFilter(options.processDefinitionId);
-        }
-        if (options.between) {
-            const parsed = parseBetween(options.between);
-            if (parsed) {
-                filter.filter.creationTime = buildDateFilter(parsed.from, parsed.to);
-            }
-            else {
-                logger.error("Invalid --between value. Expected format: <from>..<to> (e.g. 2024-01-01..2024-12-31, ISO 8601 datetimes, or open-ended: ..2024-12-31 or 2024-01-01..)");
-                process.exit(1);
-            }
-        }
-        if (emitDryRun({
-            command: "search incidents",
-            method: "POST",
-            endpoint: "/incidents/search",
-            profile: options.profile,
-            body: filter,
-        }))
-            return;
-        logSearchCriteria(logger, "Incidents", criteria);
-        const allItems = await fetchAllPages((f, opts) => client.searchIncidents(f, opts), filter, ...(hasCiFilter ? [CI_PAGE_SIZE] : []));
-        const result = { items: allItems };
-        if (hasCiFilter && result.items) {
-            result.items = result.items.filter((incident) => {
-                if (options.iErrorMessage &&
-                    !matchesCaseInsensitive(incident.errorMessage, options.iErrorMessage))
-                    return false;
-                if (options.iProcessDefinitionId &&
-                    !matchesCaseInsensitive(incident.processDefinitionId, options.iProcessDefinitionId))
-                    return false;
-                if (errorMessageHasWildcard &&
-                    options.errorMessage &&
-                    !matchesCaseSensitive(incident.errorMessage, options.errorMessage))
-                    return false;
-                return true;
-            });
-        }
-        if (result.items && result.items.length > 0) {
-            let tableData = result.items.map((incident) => ({
-                Key: incident.incidentKey || incident.key,
-                Type: incident.errorType,
-                Message: typeof incident.errorMessage === "string"
-                    ? incident.errorMessage.substring(0, 50)
-                    : "",
-                State: incident.state,
-                Created: incident.creationTime || "-",
-                "Process Instance": incident.processInstanceKey,
-                "Tenant ID": incident.tenantId,
-            }));
-            tableData = sortTableData(tableData, options.sortBy, logger, options.sortOrder);
-            logger.table(tableData);
-            logResultCount(logger, result.items.length, "incident(s)", criteria.length > 0);
+    const filter = {
+        filter: {
+            tenantId,
+        },
+    };
+    if (flags.state) {
+        filter.filter.state = flags.state;
+    }
+    if (flags.processInstanceKey) {
+        filter.filter.processInstanceKey = flags.processInstanceKey;
+    }
+    if (flags.processDefinitionKey) {
+        filter.filter.processDefinitionKey = flags.processDefinitionKey;
+    }
+    if (flags.errorType) {
+        filter.filter.errorType = flags.errorType;
+    }
+    if (flags.errorMessage && !errorMessageHasWildcard) {
+        filter.filter.errorMessage = flags.errorMessage;
+    }
+    if (processDefinitionId) {
+        filter.filter.processDefinitionId = toStringFilter(processDefinitionId);
+    }
+    if (ctx.between) {
+        const parsed = parseBetween(ctx.between);
+        if (parsed) {
+            filter.filter.creationTime = buildDateFilter(parsed.from, parsed.to);
         }
         else {
-            logNoResults(logger, "incidents", criteria.length > 0, options._unknownFlags);
-        }
-        return result;
+            logger.error("Invalid --between value. Expected format: <from>..<to> (e.g. 2024-01-01..2024-12-31, ISO 8601 datetimes, or open-ended: ..2024-12-31 or 2024-01-01..)");
+            process.exit(1);
+        }
+    }
+    const dr = dryRun({
+        command: "search incidents",
+        method: "POST",
+        endpoint: "/incidents/search",
+        profile,
+        body: filter,
+    });
+    if (dr)
+        return dr;
+    logSearchCriteria(logger, "Incidents", criteria);
+    const allItems = await fetchAllPages((f, opts) => client.searchIncidents(f, opts), filter, ...(hasCiFilter ? [CI_PAGE_SIZE] : []));
+    const result = { items: allItems };
+    if (hasCiFilter && result.items) {
+        result.items = result.items.filter((incident) => {
+            if (flags.ierrorMessage &&
+                !matchesCaseInsensitive(incident.errorMessage, flags.ierrorMessage))
+                return false;
+            if (flags.iid &&
+                !matchesCaseInsensitive(incident.processDefinitionId, flags.iid))
+                return false;
+            if (errorMessageHasWildcard &&
+                flags.errorMessage &&
+                !matchesCaseSensitive(incident.errorMessage, flags.errorMessage))
+                return false;
+            return true;
+        });
+    }
+    if (result.items && result.items.length > 0) {
+        let tableData = result.items.map((incident) => ({
+            Key: incident.incidentKey || incident.key,
+            Type: incident.errorType,
+            Message: typeof incident.errorMessage === "string"
+                ? incident.errorMessage.substring(0, 50)
+                : "",
+            State: incident.state,
+            Created: incident.creationTime || "-",
+            "Process Instance": incident.processInstanceKey,
+            "Tenant ID": incident.tenantId,
+        }));
+        tableData = sortTableData(tableData, ctx.sortBy, logger, ctx.sortOrder);
+        logger.table(tableData);
+        logResultCount(logger, result.items.length, "incident(s)", criteria.length > 0);
     }
-    catch (error) {
-        handleCommandError(logger, "Failed to search incidents", error);
+    else {
+        logNoResults(logger, "incidents", criteria.length > 0);
     }
-}
+});
 /**
  * Search jobs
  */
-export async function searchJobs(options) {
-    const logger = getLogger();
-    const client = createClient(options.profile);
-    const tenantId = resolveTenantId(options.profile);
-    const hasCiFilter = !!options.iType;
+export const searchJobsCommand = defineCommand("search", "jobs", async (ctx, flags, _args) => {
+    const { client, logger, tenantId, profile } = ctx;
+    const hasCiFilter = !!flags.itype;
     // Build search criteria description for user feedback
     const criteria = [];
-    if (options.state) {
-        criteria.push(formatCriterion("state", options.state));
+    if (flags.state) {
+        criteria.push(formatCriterion("state", flags.state));
     }
-    if (options.type) {
-        criteria.push(formatCriterion("type", options.type));
+    if (flags.type) {
+        criteria.push(formatCriterion("type", flags.type));
     }
-    if (options.processInstanceKey) {
-        criteria.push(formatCriterion("Process Instance Key", options.processInstanceKey));
+    if (flags.processInstanceKey) {
+        criteria.push(formatCriterion("Process Instance Key", flags.processInstanceKey));
     }
-    if (options.processDefinitionKey) {
-        criteria.push(formatCriterion("Process Definition Key", options.processDefinitionKey));
+    if (flags.processDefinitionKey) {
+        criteria.push(formatCriterion("Process Definition Key", flags.processDefinitionKey));
     }
-    if (options.iType) {
-        criteria.push(formatCriterion("type", options.iType, true));
+    if (flags.itype) {
+        criteria.push(formatCriterion("type", flags.itype, true));
     }
-    if (options.between) {
-        const field = options.dateField ?? "creationTime";
-        criteria.push(`'${field}' between "${options.between}"`);
+    if (ctx.between) {
+        const field = ctx.dateField ?? "creationTime";
+        criteria.push(`'${field}' between "${ctx.between}"`);
     }
-    try {
-        const filter = {
-            filter: {
-                tenantId,
-            },
-        };
-        if (options.state) {
-            filter.filter.state = options.state;
-        }
-        if (options.type) {
-            filter.filter.type = toStringFilter(options.type);
-        }
-        if (options.processInstanceKey) {
-            filter.filter.processInstanceKey = options.processInstanceKey;
-        }
-        if (options.processDefinitionKey) {
-            filter.filter.processDefinitionKey = options.processDefinitionKey;
-        }
-        if (options.between) {
-            const parsed = parseBetween(options.between);
-            if (parsed) {
-                const field = options.dateField ?? "creationTime";
-                filter.filter[field] = buildDateFilter(parsed.from, parsed.to);
-            }
-            else {
-                logger.error("Invalid --between value. Expected format: <from>..<to> (e.g. 2024-01-01..2024-12-31, ISO 8601 datetimes, or open-ended: ..2024-12-31 or 2024-01-01..)");
-                process.exit(1);
-            }
-        }
-        if (emitDryRun({
-            command: "search jobs",
-            method: "POST",
-            endpoint: "/jobs/search",
-            profile: options.profile,
-            body: filter,
-        }))
-            return;
-        logSearchCriteria(logger, "Jobs", criteria);
-        const allItems = await fetchAllPages((f, opts) => client.searchJobs(f, opts), filter, ...(hasCiFilter ? [CI_PAGE_SIZE] : []));
-        const result = { items: allItems };
-        if (hasCiFilter && result.items) {
-            result.items = result.items.filter((job) => {
-                if (options.iType && !matchesCaseInsensitive(job.type, options.iType))
-                    return false;
-                return true;
-            });
-        }
-        if (result.items && result.items.length > 0) {
-            let tableData = result.items.map((job) => ({
-                Key: job.jobKey || job.key,
-                Type: job.type,
-                State: job.state,
-                Retries: job.retries,
-                Created: job.creationTime || "-",
-                "Process Instance": job.processInstanceKey,
-                "Tenant ID": job.tenantId,
-            }));
-            tableData = sortTableData(tableData, options.sortBy, logger, options.sortOrder);
-            logger.table(tableData);
-            logResultCount(logger, result.items.length, "job(s)", criteria.length > 0);
+    const filter = {
+        filter: {
+            tenantId,
+        },
+    };
+    if (flags.state) {
+        filter.filter.state = flags.state;
+    }
+    if (flags.type) {
+        filter.filter.type = toStringFilter(flags.type);
+    }
+    if (flags.processInstanceKey) {
+        filter.filter.processInstanceKey = flags.processInstanceKey;
+    }
+    if (flags.processDefinitionKey) {
+        filter.filter.processDefinitionKey = flags.processDefinitionKey;
+    }
+    if (ctx.between) {
+        const parsed = parseBetween(ctx.between);
+        if (parsed) {
+            const field = ctx.dateField ?? "creationTime";
+            filter.filter[field] = buildDateFilter(parsed.from, parsed.to);
         }
         else {
-            logNoResults(logger, "jobs", criteria.length > 0, options._unknownFlags);
-        }
-        return result;
+            logger.error("Invalid --between value. Expected format: <from>..<to> (e.g. 2024-01-01..2024-12-31, ISO 8601 datetimes, or open-ended: ..2024-12-31 or 2024-01-01..)");
+            process.exit(1);
+        }
+    }
+    const dr = dryRun({
+        command: "search jobs",
+        method: "POST",
+        endpoint: "/jobs/search",
+        profile,
+        body: filter,
+    });
+    if (dr)
+        return dr;
+    logSearchCriteria(logger, "Jobs", criteria);
+    const allItems = await fetchAllPages((f, opts) => client.searchJobs(f, opts), filter, ...(hasCiFilter ? [CI_PAGE_SIZE] : []));
+    const result = { items: allItems };
+    if (hasCiFilter && result.items) {
+        result.items = result.items.filter((job) => {
+            if (flags.itype && !matchesCaseInsensitive(job.type, flags.itype))
+                return false;
+            return true;
+        });
+    }
+    if (result.items && result.items.length > 0) {
+        let tableData = result.items.map((job) => ({
+            Key: job.jobKey || job.key,
+            Type: job.type,
+            State: job.state,
+            Retries: job.retries,
+            Created: job.creationTime || "-",
+            "Process Instance": job.processInstanceKey,
+            "Tenant ID": job.tenantId,
+        }));
+        tableData = sortTableData(tableData, ctx.sortBy, logger, ctx.sortOrder);
+        logger.table(tableData);
+        logResultCount(logger, result.items.length, "job(s)", criteria.length > 0);
     }
-    catch (error) {
-        handleCommandError(logger, "Failed to search jobs", error);
+    else {
+        logNoResults(logger, "jobs", criteria.length > 0);
     }
-}
+});
 /**
  * Search variables
  */
-export async function searchVariables(options) {
-    const logger = getLogger();
-    const client = createClient(options.profile);
-    const tenantId = resolveTenantId(options.profile);
-    const hasCiFilter = !!(options.iName || options.iValue);
+export const searchVariablesCommand = defineCommand("search", "variable", async (ctx, flags, _args) => {
+    const { client, logger, tenantId, profile } = ctx;
+    const hasCiFilter = !!(flags.iname || flags.ivalue);
     // Build search criteria description for user feedback
     const criteria = [];
-    if (options.name) {
-        criteria.push(formatCriterion("name", options.name));
+    if (flags.name) {
+        criteria.push(formatCriterion("name", flags.name));
     }
-    if (options.value) {
-        criteria.push(formatCriterion("value", options.value));
+    if (flags.value) {
+        criteria.push(formatCriterion("value", flags.value));
     }
-    if (options.processInstanceKey) {
-        criteria.push(formatCriterion("Process Instance Key", options.processInstanceKey));
+    if (flags.processInstanceKey) {
+        criteria.push(formatCriterion("Process Instance Key", flags.processInstanceKey));
     }
-    if (options.scopeKey) {
-        criteria.push(formatCriterion("Scope Key", options.scopeKey));
+    if (flags.scopeKey) {
+        criteria.push(formatCriterion("Scope Key", flags.scopeKey));
     }
-    if (options.iName) {
-        criteria.push(formatCriterion("name", options.iName, true));
+    if (flags.iname) {
+        criteria.push(formatCriterion("name", flags.iname, true));
     }
-    if (options.iValue) {
-        criteria.push(formatCriterion("value", options.iValue, true));
+    if (flags.ivalue) {
+        criteria.push(formatCriterion("value", flags.ivalue, true));
     }
-    if (options.fullValue) {
+    if (flags.fullValue) {
         criteria.push(formatCriterion("fullValue", true));
     }
-    try {
-        const filter = {
-            filter: {
-                tenantId,
-            },
-        };
-        if (options.name) {
-            filter.filter.name = toStringFilter(options.name);
-        }
-        if (options.value) {
-            filter.filter.value = toStringFilter(options.value);
-        }
-        if (options.processInstanceKey) {
-            filter.filter.processInstanceKey = options.processInstanceKey;
-        }
-        if (options.scopeKey) {
-            filter.filter.scopeKey = options.scopeKey;
-        }
-        // By default, truncate values unless --fullValue is specified
-        const truncateValues = !options.fullValue;
-        if (emitDryRun({
-            command: "search variables",
-            method: "POST",
-            endpoint: "/variables/search",
-            profile: options.profile,
-            body: { ...filter, truncateValues },
-        }))
-            return;
-        logSearchCriteria(logger, "Variables", criteria);
-        const allItems = await fetchAllPages((f, opts) => client.searchVariables({ ...f, truncateValues }, opts), filter, hasCiFilter ? CI_PAGE_SIZE : DEFAULT_PAGE_SIZE, options.limit);
-        const result = { items: allItems };
-        if (hasCiFilter && result.items) {
-            result.items = result.items.filter((variable) => {
-                if (options.iName &&
-                    !matchesCaseInsensitive(variable.name, options.iName))
-                    return false;
-                if (options.iValue) {
-                    // Variable values come JSON-encoded from the API (e.g., '"PendingReview"').
-                    // Unwrap the JSON string for comparison so users can match the actual value.
-                    let rawValue = typeof variable.value === "string"
-                        ? variable.value
-                        : String(variable.value ?? "");
-                    try {
-                        const parsed = JSON.parse(rawValue);
-                        if (typeof parsed === "string")
-                            rawValue = parsed;
-                    }
-                    catch {
-                        /* keep original value */
-                    }
-                    if (!matchesCaseInsensitive(rawValue, options.iValue))
-                        return false;
+    const filter = {
+        filter: {
+            tenantId,
+        },
+    };
+    if (flags.name) {
+        filter.filter.name = toStringFilter(flags.name);
+    }
+    if (flags.value) {
+        filter.filter.value = toStringFilter(flags.value);
+    }
+    if (flags.processInstanceKey) {
+        filter.filter.processInstanceKey = flags.processInstanceKey;
+    }
+    if (flags.scopeKey) {
+        filter.filter.scopeKey = flags.scopeKey;
+    }
+    // By default, truncate values unless --fullValue is specified
+    const truncateValues = !flags.fullValue;
+    const dr = dryRun({
+        command: "search variables",
+        method: "POST",
+        endpoint: "/variables/search",
+        profile,
+        body: { ...filter, truncateValues },
+    });
+    if (dr)
+        return dr;
+    logSearchCriteria(logger, "Variables", criteria);
+    const allItems = await fetchAllPages((f, opts) => client.searchVariables({ ...f, truncateValues }, opts), filter, hasCiFilter ? CI_PAGE_SIZE : DEFAULT_PAGE_SIZE, ctx.limit);
+    const result = { items: allItems };
+    if (hasCiFilter && result.items) {
+        result.items = result.items.filter((variable) => {
+            if (flags.iname && !matchesCaseInsensitive(variable.name, flags.iname))
+                return false;
+            if (flags.ivalue) {
+                // Variable values come JSON-encoded from the API (e.g., '"PendingReview"').
+                // Unwrap the JSON string for comparison so users can match the actual value.
+                let rawValue = typeof variable.value === "string"
+                    ? variable.value
+                    : String(variable.value ?? "");
+                try {
+                    const parsed = JSON.parse(rawValue);
+                    if (typeof parsed === "string")
+                        rawValue = parsed;
                 }
-                return true;
-            });
-        }
-        if (result.items && result.items.length > 0) {
-            let tableData = result.items.map((variable) => {
-                const row = {
-                    Name: variable.name,
-                    Value: variable.value || "",
-                    "Process Instance": variable.processInstanceKey,
-                    "Scope Key": variable.scopeKey,
-                    "Tenant ID": variable.tenantId,
-                };
-                if (variable.isTruncated) {
-                    row.Truncated = "✓";
+                catch {
+                    /* keep original value */
                 }
-                return row;
-            });
-            tableData = sortTableData(tableData, options.sortBy, logger, options.sortOrder);
-            logger.table(tableData);
-            logResultCount(logger, result.items.length, "variable(s)", criteria.length > 0);
-            if (!options.fullValue && result.items.some((v) => v.isTruncated)) {
-                logger.info("Some values are truncated. Use --fullValue to see full values.");
+                if (!matchesCaseInsensitive(rawValue, flags.ivalue))
+                    return false;
             }
+            return true;
+        });
+    }
+    if (result.items && result.items.length > 0) {
+        let tableData = result.items.map((variable) => {
+            const row = {
+                Name: variable.name,
+                Value: variable.value || "",
+                "Process Instance": variable.processInstanceKey,
+                "Scope Key": variable.scopeKey,
+                "Tenant ID": variable.tenantId,
+            };
+            if (variable.isTruncated) {
+                row.Truncated = "✓";
+            }
+            return row;
+        });
+        tableData = sortTableData(tableData, ctx.sortBy, logger, ctx.sortOrder);
+        logger.table(tableData);
+        logResultCount(logger, result.items.length, "variable(s)", criteria.length > 0);
+        if (!flags.fullValue && result.items.some((v) => v.isTruncated)) {
+            logger.info("Some values are truncated. Use --fullValue to see full values.");
         }
-        else {
-            logNoResults(logger, "variables", criteria.length > 0, options._unknownFlags);
-        }
-        return result;
     }
-    catch (error) {
-        handleCommandError(logger, "Failed to search variables", error);
+    else {
+        logNoResults(logger, "variables", criteria.length > 0);
     }
-}
+});
 //# sourceMappingURL=search.js.map