@automatify-au/cli 0.1.15 → 0.1.16

package/dist/automatify.cjs

@@ -16172,6 +16172,504 @@ function createIngestFeatureHandler(deps = {}) {
   };
 }
 
+// src/profiles.ts
+var CONFIG_FLAGS7 = /* @__PURE__ */ new Set([
+  "--config",
+  "--base-url",
+  "--project-key",
+  "--issue-key",
+  "--auth-mode",
+  "--jira-email",
+  "--jira-api-token"
+]);
+function parseArgs8(args) {
+  const flags = {};
+  const boolFlags = /* @__PURE__ */ new Set();
+  const unknownFlags = [];
+  const supportedValueFlags = /* @__PURE__ */ new Set(["--id", ...CONFIG_FLAGS7]);
+  const supportedBoolFlags = /* @__PURE__ */ new Set(["--json", "--dry-run", "--confirm", "--detach"]);
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index];
+    if (!token.startsWith("--")) {
+      unknownFlags.push(token);
+      continue;
+    }
+    if (supportedBoolFlags.has(token)) {
+      boolFlags.add(token);
+      continue;
+    }
+    if (!supportedValueFlags.has(token)) {
+      unknownFlags.push(token);
+      continue;
+    }
+    const value = args[index + 1];
+    if (!value || value.startsWith("--")) {
+      unknownFlags.push(token);
+      continue;
+    }
+    flags[token] = value;
+    index += 1;
+  }
+  return { flags, boolFlags, unknownFlags };
+}
+function pickConfigArgs7(parsed) {
+  const args = [];
+  for (const [flag, value] of Object.entries(parsed.flags)) {
+    if (CONFIG_FLAGS7.has(flag)) {
+      args.push(flag, value);
+    }
+  }
+  return args;
+}
+function normalizeError6(error) {
+  if (error instanceof ForgeClientError) {
+    return `${error.code}: ${error.message}`;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return "Unknown profiles command error.";
+}
+function missingProjectResponse3() {
+  return {
+    exitCode: ExitCode.ValidationError,
+    stderr: ["ERROR: Missing project context. Set JIRA_PROJECT_KEY or pass --project-key."]
+  };
+}
+function confirmationRequiredResponse(command) {
+  return {
+    exitCode: ExitCode.ValidationError,
+    stderr: [`ERROR: ${command} is destructive and requires --confirm. Use --dry-run first to preview the cleanup.`]
+  };
+}
+function remoteErrorResponse(code, message, stdout = []) {
+  return {
+    exitCode: ExitCode.RemoteError,
+    stdout,
+    stderr: [`ERROR: ${code}: ${message}`]
+  };
+}
+function toJsonProfile(profile) {
+  return {
+    id: profile.id,
+    label: profile.label,
+    provider: profile.provider,
+    endpointSummary: profile.endpointSummary,
+    enabled: profile.enabled,
+    isProjectDefault: profile.isProjectDefault ?? false,
+    hasSecret: profile.hasSecret,
+    createdAt: profile.createdAt,
+    updatedAt: profile.updatedAt,
+    lastUsedAt: profile.lastUsedAt ?? null
+  };
+}
+function toJsonBinding(automation) {
+  return {
+    id: automation.id,
+    scenarioId: automation.scenarioId,
+    label: automation.label,
+    profileId: automation.profileId ?? null,
+    profileLabel: automation.profileLabel ?? null,
+    materializedFromProjectDefault: automation.materializedFromProjectDefault ?? false,
+    enabled: automation.enabled
+  };
+}
+function profileLines(profiles) {
+  if (profiles.length === 0) {
+    return ["Automation profiles: 0", "No automation profiles found for the selected project."];
+  }
+  return [
+    `Automation profiles: ${profiles.length}`,
+    ...profiles.map((profile) => {
+      const flags = [profile.isProjectDefault ? "default" : "", profile.enabled ? "enabled" : "disabled"].filter(
+        Boolean
+      );
+      return `- ${profile.id} [${flags.join(", ")}] ${profile.label} (${profile.provider}) ${profile.endpointSummary}`;
+    })
+  ];
+}
+function bindingLines(bindings) {
+  return bindings.map(
+    (binding) => `- ${binding.id} scenario=${binding.scenarioId} ${binding.label}` + (binding.materializedFromProjectDefault ? " [project-default materialized]" : "")
+  );
+}
+function profileBindings(automations, profileId) {
+  return automations.filter((automation) => automation.mode === "profile" && automation.profileId === profileId);
+}
+function allProfileBindings(automations) {
+  return automations.filter((automation) => automation.mode === "profile");
+}
+function createProfilesHandler(deps = {}) {
+  const cwd = deps.cwd ?? process.cwd();
+  const env = deps.env ?? process.env;
+  return async (request, context) => {
+    const [subcommand, ...restArgs] = request.args;
+    const parsed = parseArgs8(restArgs);
+    const useJson = parsed.boolFlags.has("--json");
+    const dryRun = parsed.boolFlags.has("--dry-run");
+    const confirmed = parsed.boolFlags.has("--confirm");
+    const detach = parsed.boolFlags.has("--detach");
+    const profileId = parsed.flags["--id"]?.trim() ?? "";
+    const config = resolveCliConfig(pickConfigArgs7(parsed), env, cwd);
+    const projectKey = config.values.projectKey;
+    const issueKey = config.values.issueKey;
+    const forgeContext = {
+      projectKey: projectKey || void 0,
+      issueKey: issueKey || void 0
+    };
+    if (parsed.unknownFlags.length > 0) {
+      return {
+        exitCode: ExitCode.UsageError,
+        stderr: [`ERROR: Unknown or invalid arguments: ${parsed.unknownFlags.join(", ")}`]
+      };
+    }
+    if (!projectKey) {
+      return missingProjectResponse3();
+    }
+    if (dryRun && confirmed) {
+      return {
+        exitCode: ExitCode.UsageError,
+        stderr: ["ERROR: Use either --dry-run or --confirm, not both."]
+      };
+    }
+    if (subcommand === "list") {
+      if (dryRun || confirmed || detach || profileId) {
+        return {
+          exitCode: ExitCode.UsageError,
+          stderr: ["ERROR: profiles list accepts only configuration flags and optional --json."]
+        };
+      }
+      try {
+        const result = await context.invokeForgeContract("listScenarioAutomationProfiles", {
+          context: forgeContext
+        });
+        if (!result.ok) {
+          return remoteErrorResponse(result.error.code, result.error.message);
+        }
+        if (useJson) {
+          return {
+            exitCode: ExitCode.Success,
+            stdout: toJsonLine({
+              action: "profiles-list",
+              projectKey,
+              count: result.data.length,
+              items: result.data.map(toJsonProfile)
+            })
+          };
+        }
+        return {
+          exitCode: ExitCode.Success,
+          stdout: profileLines(result.data)
+        };
+      } catch (error) {
+        return {
+          exitCode: ExitCode.TransportError,
+          stderr: [`ERROR: ${normalizeError6(error)}`]
+        };
+      }
+    }
+    if (subcommand === "detach") {
+      if (!profileId) {
+        return {
+          exitCode: ExitCode.ValidationError,
+          stderr: ["ERROR: Missing required --id <PROFILE_ID> for profiles detach."]
+        };
+      }
+      if (detach) {
+        return {
+          exitCode: ExitCode.UsageError,
+          stderr: [
+            "ERROR: --detach is only valid with profiles delete; profiles detach already performs that operation."
+          ]
+        };
+      }
+      if (!dryRun && !confirmed) {
+        return confirmationRequiredResponse("profiles detach");
+      }
+      try {
+        const result = await context.invokeForgeContract("listScenarioAutomations", {
+          context: forgeContext
+        });
+        if (!result.ok) {
+          return remoteErrorResponse(result.error.code, result.error.message);
+        }
+        const bindings = profileBindings(result.data, profileId);
+        if (dryRun) {
+          if (useJson) {
+            return {
+              exitCode: ExitCode.Success,
+              stdout: toJsonLine({
+                action: "profiles-detach",
+                dryRun: true,
+                projectKey,
+                profileId,
+                bindingCount: bindings.length,
+                bindings: bindings.map(toJsonBinding)
+              })
+            };
+          }
+          return {
+            exitCode: ExitCode.Success,
+            stdout: [
+              `Dry run: profile ${profileId} has ${bindings.length} automation binding(s) to detach.`,
+              ...bindingLines(bindings),
+              "No changes made."
+            ]
+          };
+        }
+        const deletedIds = [];
+        for (const binding of bindings) {
+          const deleted = await context.invokeForgeContract("deleteScenarioAutomation", {
+            context: forgeContext,
+            automationId: binding.id
+          });
+          if (!deleted.ok) {
+            return remoteErrorResponse(deleted.error.code, deleted.error.message, [
+              `Detached ${deletedIds.length} of ${bindings.length} automation binding(s) before the failure.`
+            ]);
+          }
+          deletedIds.push(binding.id);
+        }
+        if (useJson) {
+          return {
+            exitCode: ExitCode.Success,
+            stdout: toJsonLine({
+              action: "profiles-detach",
+              dryRun: false,
+              projectKey,
+              profileId,
+              detachedCount: deletedIds.length,
+              detachedAutomationIds: deletedIds
+            })
+          };
+        }
+        return {
+          exitCode: ExitCode.Success,
+          stdout: [`Detached ${deletedIds.length} automation binding(s) from profile ${profileId}.`]
+        };
+      } catch (error) {
+        return {
+          exitCode: ExitCode.TransportError,
+          stderr: [`ERROR: ${normalizeError6(error)}`]
+        };
+      }
+    }
+    if (subcommand === "delete") {
+      if (!profileId) {
+        return {
+          exitCode: ExitCode.ValidationError,
+          stderr: ["ERROR: Missing required --id <PROFILE_ID> for profiles delete."]
+        };
+      }
+      if (!dryRun && !confirmed) {
+        return confirmationRequiredResponse("profiles delete");
+      }
+      try {
+        let bindings = [];
+        if (detach || dryRun) {
+          const automations = await context.invokeForgeContract("listScenarioAutomations", {
+            context: forgeContext
+          });
+          if (!automations.ok) {
+            return remoteErrorResponse(automations.error.code, automations.error.message);
+          }
+          bindings = profileBindings(automations.data, profileId);
+        }
+        if (dryRun) {
+          if (useJson) {
+            return {
+              exitCode: ExitCode.Success,
+              stdout: toJsonLine({
+                action: "profiles-delete",
+                dryRun: true,
+                projectKey,
+                profileId,
+                detach,
+                bindingCount: bindings.length,
+                bindings: bindings.map(toJsonBinding)
+              })
+            };
+          }
+          return {
+            exitCode: ExitCode.Success,
+            stdout: [
+              `Dry run: profile ${profileId} would be deleted.`,
+              detach ? `The command would first detach ${bindings.length} automation binding(s).` : `The command would not detach ${bindings.length} automation binding(s); Forge will block deletion if the profile is in use.`,
+              ...bindingLines(bindings),
+              "No changes made."
+            ]
+          };
+        }
+        const detachedIds = [];
+        if (detach) {
+          for (const binding of bindings) {
+            const deletedBinding = await context.invokeForgeContract("deleteScenarioAutomation", {
+              context: forgeContext,
+              automationId: binding.id
+            });
+            if (!deletedBinding.ok) {
+              return remoteErrorResponse(deletedBinding.error.code, deletedBinding.error.message, [
+                `Detached ${detachedIds.length} of ${bindings.length} automation binding(s); profile ${profileId} was not deleted.`
+              ]);
+            }
+            detachedIds.push(binding.id);
+          }
+        }
+        const deletedProfile = await context.invokeForgeContract("deleteScenarioAutomationProfile", {
+          context: forgeContext,
+          profileId
+        });
+        if (!deletedProfile.ok) {
+          return remoteErrorResponse(deletedProfile.error.code, deletedProfile.error.message, [
+            `Detached ${detachedIds.length} automation binding(s) before profile deletion was rejected.`
+          ]);
+        }
+        if (useJson) {
+          return {
+            exitCode: ExitCode.Success,
+            stdout: toJsonLine({
+              action: "profiles-delete",
+              dryRun: false,
+              projectKey,
+              profileId,
+              detachedCount: detachedIds.length,
+              detachedAutomationIds: detachedIds,
+              deleted: true
+            })
+          };
+        }
+        return {
+          exitCode: ExitCode.Success,
+          stdout: [
+            `Deleted automation profile ${profileId}.`,
+            detach ? `Detached ${detachedIds.length} automation binding(s) first.` : "No automatic detach was requested."
+          ]
+        };
+      } catch (error) {
+        return {
+          exitCode: ExitCode.TransportError,
+          stderr: [`ERROR: ${normalizeError6(error)}`]
+        };
+      }
+    }
+    if (subcommand === "clear") {
+      if (profileId || detach) {
+        return {
+          exitCode: ExitCode.UsageError,
+          stderr: [
+            "ERROR: profiles clear clears every profile and profile-based binding; do not pass --id or --detach."
+          ]
+        };
+      }
+      if (!dryRun && !confirmed) {
+        return confirmationRequiredResponse("profiles clear");
+      }
+      try {
+        const [profilesResult, automationsResult] = await Promise.all([
+          context.invokeForgeContract("listScenarioAutomationProfiles", {
+            context: forgeContext
+          }),
+          context.invokeForgeContract("listScenarioAutomations", {
+            context: forgeContext
+          })
+        ]);
+        if (!profilesResult.ok) {
+          return remoteErrorResponse(profilesResult.error.code, profilesResult.error.message);
+        }
+        if (!automationsResult.ok) {
+          return remoteErrorResponse(automationsResult.error.code, automationsResult.error.message);
+        }
+        const profiles = profilesResult.data;
+        const bindings = allProfileBindings(automationsResult.data);
+        if (dryRun) {
+          if (useJson) {
+            return {
+              exitCode: ExitCode.Success,
+              stdout: toJsonLine({
+                action: "profiles-clear",
+                dryRun: true,
+                projectKey,
+                profileCount: profiles.length,
+                bindingCount: bindings.length,
+                profiles: profiles.map(toJsonProfile),
+                bindings: bindings.map(toJsonBinding)
+              })
+            };
+          }
+          return {
+            exitCode: ExitCode.Success,
+            stdout: [
+              `Dry run: would detach ${bindings.length} profile-based automation binding(s) and delete ${profiles.length} automation profile(s).`,
+              ...bindingLines(bindings),
+              ...profiles.map((profile) => `- profile ${profile.id} ${profile.label}`),
+              "Direct (non-profile) scenario automations are preserved.",
+              "No changes made."
+            ]
+          };
+        }
+        const detachedIds = [];
+        for (const binding of bindings) {
+          const deletedBinding = await context.invokeForgeContract("deleteScenarioAutomation", {
+            context: forgeContext,
+            automationId: binding.id
+          });
+          if (!deletedBinding.ok) {
+            return remoteErrorResponse(deletedBinding.error.code, deletedBinding.error.message, [
+              `Detached ${detachedIds.length} of ${bindings.length} profile-based automation binding(s). No profiles were deleted after the failure.`
+            ]);
+          }
+          detachedIds.push(binding.id);
+        }
+        const deletedProfileIds = [];
+        for (const profile of profiles) {
+          const deletedProfile = await context.invokeForgeContract("deleteScenarioAutomationProfile", {
+            context: forgeContext,
+            profileId: profile.id
+          });
+          if (!deletedProfile.ok) {
+            return remoteErrorResponse(deletedProfile.error.code, deletedProfile.error.message, [
+              `Detached ${detachedIds.length} profile-based automation binding(s).`,
+              `Deleted ${deletedProfileIds.length} of ${profiles.length} automation profile(s) before the failure.`
+            ]);
+          }
+          deletedProfileIds.push(profile.id);
+        }
+        if (useJson) {
+          return {
+            exitCode: ExitCode.Success,
+            stdout: toJsonLine({
+              action: "profiles-clear",
+              dryRun: false,
+              projectKey,
+              detachedCount: detachedIds.length,
+              detachedAutomationIds: detachedIds,
+              deletedProfileCount: deletedProfileIds.length,
+              deletedProfileIds
+            })
+          };
+        }
+        return {
+          exitCode: ExitCode.Success,
+          stdout: [
+            `Detached ${detachedIds.length} profile-based automation binding(s).`,
+            `Deleted ${deletedProfileIds.length} automation profile(s).`,
+            "Direct (non-profile) scenario automations were preserved."
+          ]
+        };
+      } catch (error) {
+        return {
+          exitCode: ExitCode.TransportError,
+          stderr: [`ERROR: ${normalizeError6(error)}`]
+        };
+      }
+    }
+    return {
+      exitCode: ExitCode.UsageError,
+      stderr: ["ERROR: Unsupported profiles subcommand. Use: list, detach, delete, or clear."]
+    };
+  };
+}
+
 // src/runUpload.ts
 var import_node_fs13 = require("node:fs");
 var import_node_path13 = __toESM(require("node:path"), 1);
@@ -16181,7 +16679,7 @@ var STEP_RESULTS = [
   StepResult.Skipped,
   StepResult.Blocked
 ];
-var CONFIG_FLAGS7 = /* @__PURE__ */ new Set([
+var CONFIG_FLAGS8 = /* @__PURE__ */ new Set([
   "--config",
   "--base-url",
   "--project-key",
@@ -16190,7 +16688,7 @@ var CONFIG_FLAGS7 = /* @__PURE__ */ new Set([
   "--jira-email",
   "--jira-api-token"
 ]);
-function parseArgs8(args) {
+function parseArgs9(args) {
   const flags = {};
   const boolFlags = /* @__PURE__ */ new Set();
   const unknownFlags = [];
@@ -16201,7 +16699,7 @@ function parseArgs8(args) {
     "--feature-name",
     "--scenario-name",
     "--executed-at",
-    ...CONFIG_FLAGS7
+    ...CONFIG_FLAGS8
   ]);
   const supportedBoolFlags = /* @__PURE__ */ new Set(["--stdin", "--json"]);
   for (let i = 0; i < args.length; i += 1) {
@@ -16227,16 +16725,16 @@ function parseArgs8(args) {
   }
   return { flags, boolFlags, unknownFlags };
 }
-function pickConfigArgs7(parsed) {
+function pickConfigArgs8(parsed) {
   const configArgs = [];
   for (const [flag, value] of Object.entries(parsed.flags)) {
-    if (CONFIG_FLAGS7.has(flag)) {
+    if (CONFIG_FLAGS8.has(flag)) {
       configArgs.push(flag, value);
     }
   }
   return configArgs;
 }
-function normalizeError6(error) {
+function normalizeError7(error) {
   if (error instanceof ForgeClientError) {
     return `${error.code}: ${error.message}`;
   }
@@ -16321,8 +16819,8 @@ function createRunUploadHandler(deps = {}) {
   const env = deps.env ?? process.env;
   return async (request, context) => {
     const [, ...subArgs] = request.args;
-    const parsed = parseArgs8(subArgs);
-    const configArgs = pickConfigArgs7(parsed);
+    const parsed = parseArgs9(subArgs);
+    const configArgs = pickConfigArgs8(parsed);
     const config = resolveCliConfig(configArgs, env, cwd);
     const projectKey = config.values.projectKey;
     const issueKey = config.values.issueKey;
@@ -16355,7 +16853,7 @@ function createRunUploadHandler(deps = {}) {
     } catch (error) {
       return {
         exitCode: ExitCode.InternalError,
-        stderr: [`ERROR: Failed to read run payload source: ${normalizeError6(error)}`]
+        stderr: [`ERROR: Failed to read run payload source: ${normalizeError7(error)}`]
       };
     }
     const payloadFromSource = parseRunPayload(raw);
@@ -16385,7 +16883,7 @@ function createRunUploadHandler(deps = {}) {
       } catch (error) {
         return {
           exitCode: ExitCode.TransportError,
-          stderr: [`ERROR: ${normalizeError6(error)}`]
+          stderr: [`ERROR: ${normalizeError7(error)}`]
         };
       }
     }
@@ -16465,7 +16963,7 @@ function createRunUploadHandler(deps = {}) {
             featureName: runInput.featureName,
             scenarioName: runInput.scenarioName,
             executedAt: runInput.executedAt,
-            errorMessage: normalizeError6(error)
+            errorMessage: normalizeError7(error)
           })
         };
       }
@@ -16477,14 +16975,14 @@ function createRunUploadHandler(deps = {}) {
           `Scenario: ${runInput.scenarioName}`,
           `ExecutedAt: ${runInput.executedAt}`
         ],
-        stderr: [`ERROR: ${normalizeError6(error)}`]
+        stderr: [`ERROR: ${normalizeError7(error)}`]
       };
     }
   };
 }
 
 // src/runs.ts
-var CONFIG_FLAGS8 = /* @__PURE__ */ new Set([
+var CONFIG_FLAGS9 = /* @__PURE__ */ new Set([
   "--config",
   "--base-url",
   "--project-key",
@@ -16493,11 +16991,11 @@ var CONFIG_FLAGS8 = /* @__PURE__ */ new Set([
   "--jira-email",
   "--jira-api-token"
 ]);
-function parseArgs9(args) {
+function parseArgs10(args) {
   const flags = {};
   const boolFlags = /* @__PURE__ */ new Set();
   const unknownFlags = [];
-  const supportedValueFlags = /* @__PURE__ */ new Set(["--id", ...CONFIG_FLAGS8]);
+  const supportedValueFlags = /* @__PURE__ */ new Set(["--id", ...CONFIG_FLAGS9]);
   const supportedBoolFlags = /* @__PURE__ */ new Set(["--json"]);
   for (let index = 0; index < args.length; index += 1) {
     const token = args[index];
@@ -16522,16 +17020,16 @@ function parseArgs9(args) {
   }
   return { flags, boolFlags, unknownFlags };
 }
-function pickConfigArgs8(parsed) {
+function pickConfigArgs9(parsed) {
   const args = [];
   for (const [flag, value] of Object.entries(parsed.flags)) {
-    if (CONFIG_FLAGS8.has(flag)) {
+    if (CONFIG_FLAGS9.has(flag)) {
       args.push(flag, value);
     }
   }
   return args;
 }
-function normalizeError7(error) {
+function normalizeError8(error) {
   if (error instanceof ForgeClientError) {
     return `${error.code}: ${error.message}`;
   }
@@ -16584,7 +17082,7 @@ function runToLines(run) {
   }
   return lines;
 }
-function missingProjectResponse3() {
+function missingProjectResponse4() {
   return {
     exitCode: ExitCode.ValidationError,
     stderr: ["ERROR: Missing project context. Set JIRA_PROJECT_KEY or pass --project-key."]
@@ -16595,9 +17093,9 @@ function createRunsHandler(deps = {}) {
   const env = deps.env ?? process.env;
   return async (request, context) => {
     const [subcommand, ...restArgs] = request.args;
-    const parsed = parseArgs9(restArgs);
+    const parsed = parseArgs10(restArgs);
     const useJson = parsed.boolFlags.has("--json");
-    const config = resolveCliConfig(pickConfigArgs8(parsed), env, cwd);
+    const config = resolveCliConfig(pickConfigArgs9(parsed), env, cwd);
     const projectKey = config.values.projectKey;
     const issueKey = config.values.issueKey;
     if (parsed.unknownFlags.length > 0) {
@@ -16607,7 +17105,7 @@ function createRunsHandler(deps = {}) {
       };
     }
     if (!projectKey) {
-      return missingProjectResponse3();
+      return missingProjectResponse4();
     }
     if (subcommand === "show") {
       const runId = parsed.flags["--id"]?.trim() ?? "";
@@ -16649,7 +17147,7 @@ function createRunsHandler(deps = {}) {
       } catch (error) {
         return {
           exitCode: ExitCode.TransportError,
-          stderr: [`ERROR: ${normalizeError7(error)}`]
+          stderr: [`ERROR: ${normalizeError8(error)}`]
         };
       }
     }
@@ -17629,7 +18127,7 @@ function defaultReadStdin() {
     process.stdin.on("error", reject);
   });
 }
-function parseArgs10(args, valueFlags, boolFlags, allowApplyCollections = false) {
+function parseArgs11(args, valueFlags, boolFlags, allowApplyCollections = false) {
   const flags = {};
   const enabled = /* @__PURE__ */ new Set();
   const approvals = [];
@@ -18239,7 +18737,7 @@ async function inspectPlan(plan, repoRoot, secrets, context, deps) {
   };
 }
 function planCommand(args, deps) {
-  const parsed = parseArgs10(args, PLAN_VALUE_FLAGS, /* @__PURE__ */ new Set(["--set-default", "--disabled"]));
+  const parsed = parseArgs11(args, PLAN_VALUE_FLAGS, /* @__PURE__ */ new Set(["--set-default", "--disabled"]));
   if (parsed.errors.length > 0) {
     return jsonResponse(
       errorPayload("USAGE_ERROR", "Invalid setup plan arguments.", parsed.errors),
@@ -18298,7 +18796,7 @@ function planCommand(args, deps) {
   }
 }
 async function applyCommand(args, context, deps) {
-  const parsed = parseArgs10(args, APPLY_VALUE_FLAGS, APPLY_BOOL_FLAGS, true);
+  const parsed = parseArgs11(args, APPLY_VALUE_FLAGS, APPLY_BOOL_FLAGS, true);
   if (parsed.errors.length > 0) {
     return jsonResponse(
       errorPayload("USAGE_ERROR", "Invalid setup apply arguments.", parsed.errors),
@@ -18541,7 +19039,7 @@ async function applyAzureCommand(plan, parsed, context, deps, secrets) {
   });
 }
 async function doctorCommand(args, context, deps) {
-  const parsed = parseArgs10(args, APPLY_VALUE_FLAGS, /* @__PURE__ */ new Set(["--secrets-stdin"]), true);
+  const parsed = parseArgs11(args, APPLY_VALUE_FLAGS, /* @__PURE__ */ new Set(["--secrets-stdin"]), true);
   if (parsed.approvals.length > 0) {
     return jsonResponse(errorPayload("USAGE_ERROR", "setup doctor does not accept --approve."), ExitCode.UsageError);
   }
@@ -18654,7 +19152,7 @@ function createSetupHandler(overrides = {}) {
 }
 
 // src/suites.ts
-var CONFIG_FLAGS9 = /* @__PURE__ */ new Set([
+var CONFIG_FLAGS10 = /* @__PURE__ */ new Set([
   "--config",
   "--base-url",
   "--project-key",
@@ -18663,11 +19161,11 @@ var CONFIG_FLAGS9 = /* @__PURE__ */ new Set([
   "--jira-email",
   "--jira-api-token"
 ]);
-function parseArgs11(args) {
+function parseArgs12(args) {
   const flags = {};
   const boolFlags = /* @__PURE__ */ new Set();
   const unknownFlags = [];
-  const supportedValueFlags = /* @__PURE__ */ new Set(["--key", ...CONFIG_FLAGS9]);
+  const supportedValueFlags = /* @__PURE__ */ new Set(["--key", ...CONFIG_FLAGS10]);
   const supportedBoolFlags = /* @__PURE__ */ new Set(["--json"]);
   for (let index = 0; index < args.length; index += 1) {
     const token = args[index];
@@ -18692,16 +19190,16 @@ function parseArgs11(args) {
   }
   return { flags, boolFlags, unknownFlags };
 }
-function pickConfigArgs9(parsed) {
+function pickConfigArgs10(parsed) {
   const args = [];
   for (const [flag, value] of Object.entries(parsed.flags)) {
-    if (CONFIG_FLAGS9.has(flag)) {
+    if (CONFIG_FLAGS10.has(flag)) {
       args.push(flag, value);
     }
   }
   return args;
 }
-function normalizeError8(error) {
+function normalizeError9(error) {
   if (error instanceof ForgeClientError) {
     return `${error.code}: ${error.message}`;
   }
@@ -18763,7 +19261,7 @@ function suiteCasesToLines(suite, items) {
     ...items.map((item) => `- ${item.key} [${item.status}] ${item.title}`)
   ];
 }
-function missingProjectResponse4() {
+function missingProjectResponse5() {
   return {
     exitCode: ExitCode.ValidationError,
     stderr: ["ERROR: Missing project context. Set JIRA_PROJECT_KEY or pass --project-key."]
@@ -18780,9 +19278,9 @@ function createSuitesHandler(deps = {}) {
   const env = deps.env ?? process.env;
   return async (request, context) => {
     const [subcommand, ...restArgs] = request.args;
-    const parsed = parseArgs11(restArgs);
+    const parsed = parseArgs12(restArgs);
     const useJson = parsed.boolFlags.has("--json");
-    const config = resolveCliConfig(pickConfigArgs9(parsed), env, cwd);
+    const config = resolveCliConfig(pickConfigArgs10(parsed), env, cwd);
     const projectKey = config.values.projectKey;
     const issueKey = config.values.issueKey;
     if (parsed.unknownFlags.length > 0) {
@@ -18792,7 +19290,7 @@ function createSuitesHandler(deps = {}) {
       };
     }
     if (!projectKey) {
-      return missingProjectResponse4();
+      return missingProjectResponse5();
     }
     if (subcommand === "list") {
       try {
@@ -18827,7 +19325,7 @@ function createSuitesHandler(deps = {}) {
       } catch (error) {
         return {
           exitCode: ExitCode.TransportError,
-          stderr: [`ERROR: ${normalizeError8(error)}`]
+          stderr: [`ERROR: ${normalizeError9(error)}`]
         };
       }
     }
@@ -18868,7 +19366,7 @@ function createSuitesHandler(deps = {}) {
       } catch (error) {
         return {
           exitCode: ExitCode.TransportError,
-          stderr: [`ERROR: ${normalizeError8(error)}`]
+          stderr: [`ERROR: ${normalizeError9(error)}`]
         };
       }
     }
@@ -18932,7 +19430,7 @@ function createSuitesHandler(deps = {}) {
       } catch (error) {
         return {
           exitCode: ExitCode.TransportError,
-          stderr: [`ERROR: ${normalizeError8(error)}`]
+          stderr: [`ERROR: ${normalizeError9(error)}`]
         };
       }
     }
@@ -18944,7 +19442,7 @@ function createSuitesHandler(deps = {}) {
 }
 
 // src/sync.ts
-var CONFIG_FLAGS10 = /* @__PURE__ */ new Set([
+var CONFIG_FLAGS11 = /* @__PURE__ */ new Set([
   "--config",
   "--base-url",
   "--project-key",
@@ -18954,11 +19452,11 @@ var CONFIG_FLAGS10 = /* @__PURE__ */ new Set([
   "--jira-api-token"
 ]);
 var RECONCILE_CONFIRM_TOKEN = "RECONCILE";
-function parseArgs12(args) {
+function parseArgs13(args) {
   const flags = {};
   const boolFlags = /* @__PURE__ */ new Set();
   const unknownFlags = [];
-  const supportedValueFlags = /* @__PURE__ */ new Set(["--confirm", ...CONFIG_FLAGS10]);
+  const supportedValueFlags = /* @__PURE__ */ new Set(["--confirm", ...CONFIG_FLAGS11]);
   const supportedBoolFlags = /* @__PURE__ */ new Set(["--json"]);
   for (let i = 0; i < args.length; i += 1) {
     const token = args[i];
@@ -18983,16 +19481,16 @@ function parseArgs12(args) {
   }
   return { flags, boolFlags, unknownFlags };
 }
-function pickConfigArgs10(parsed) {
+function pickConfigArgs11(parsed) {
   const args = [];
   for (const [flag, value] of Object.entries(parsed.flags)) {
-    if (CONFIG_FLAGS10.has(flag)) {
+    if (CONFIG_FLAGS11.has(flag)) {
       args.push(flag, value);
     }
   }
   return args;
 }
-function normalizeError9(error) {
+function normalizeError10(error) {
   if (error instanceof ForgeClientError) {
     return `${error.code}: ${error.message}`;
   }
@@ -19043,9 +19541,9 @@ function createSyncHandler(deps = {}) {
   const env = deps.env ?? process.env;
   return async (request, context) => {
     const [subcommand, ...restArgs] = request.args;
-    const parsed = parseArgs12(restArgs);
+    const parsed = parseArgs13(restArgs);
     const useJson = parsed.boolFlags.has("--json");
-    const config = resolveCliConfig(pickConfigArgs10(parsed), env, cwd);
+    const config = resolveCliConfig(pickConfigArgs11(parsed), env, cwd);
     const projectKey = config.values.projectKey;
     const issueKey = config.values.issueKey;
     if (parsed.unknownFlags.length > 0) {
@@ -19095,7 +19593,7 @@ function createSyncHandler(deps = {}) {
       } catch (error) {
         return {
           exitCode: ExitCode.TransportError,
-          stderr: [`ERROR: ${normalizeError9(error)}`]
+          stderr: [`ERROR: ${normalizeError10(error)}`]
         };
       }
     }
@@ -19141,7 +19639,7 @@ function createSyncHandler(deps = {}) {
       } catch (error) {
         return {
           exitCode: ExitCode.TransportError,
-          stderr: [`ERROR: ${normalizeError9(error)}`]
+          stderr: [`ERROR: ${normalizeError10(error)}`]
         };
       }
     }
@@ -19197,6 +19695,12 @@ var COMMAND_REGISTRY = [
     subcommands: ["feature"],
     handler: createIngestFeatureHandler()
   },
+  {
+    name: "profiles",
+    description: "Automation profile inspection, detach, delete, and demo cleanup commands",
+    subcommands: ["list", "detach", "delete", "clear"],
+    handler: createProfilesHandler()
+  },
   {
     name: "run",
     description: "Execution result upload commands",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@automatify-au/cli",
-  "version": "0.1.15",
+  "version": "0.1.16",
   "description": "Forge-first CLI for Automatify Jira TestOps",
   "type": "module",
   "bin": {