@automatify-au/cli 0.1.4 → 0.1.6

package/README.md

@@ -76,6 +76,16 @@ Minimum:
 - `TESTOPS_FORGE_ENDPOINT` for commands that call Forge contracts (`doctor`, `ingest`, `run`, `sync`)
 - `TESTOPS_FORGE_AUTH_TOKEN` from the one-time token shown in Forge `Operations -> CLI access`
 
+Local config helper:
+```bash
+automatify testops config set baseUrl https://automatify-com-au.atlassian.net
+automatify testops config set projectKey DEV
+automatify testops config set forgeEndpoint "<webtrigger-url>"
+printf "%s" "$TESTOPS_FORGE_AUTH_TOKEN" | automatify testops config set forgeAuthToken --stdin
+```
+
+`forgeAuthToken` local storage currently uses macOS Keychain. On Windows, Linux, and CI, keep the token in `TESTOPS_FORGE_AUTH_TOKEN` instead. `.testops-cli.json` should store non-secret values only.
+
 Optional:
 - `TESTOPS_FORGE_TIMEOUT_MS`
 - `TESTOPS_FORGE_MAX_RETRIES`
@@ -91,10 +101,13 @@ All TestOps commands are invoked as `automatify testops <command>`:
 - `bdd`
   - `automatify testops bdd scenarios show --id <SCENARIO_ID>`
   - `automatify testops bdd scenarios show --id <SCENARIO_ID> --format feature`
+  - `automatify testops bdd scenarios show --id <SCENARIO_ID|SC-4> --feature`
   - `automatify testops bdd scenarios export --id <SCENARIO_ID|SC-4> --output-dir ./scenario-export`
   - `automatify testops bdd scenarios export --all --output-dir ./scenario-export`
   - `automatify testops bdd scenarios import --file ./scenario-export/SC-4.feature`
+  - `automatify testops bdd scenarios import --file ./scenario-export/SC-4.feature --dry-run`
   - `automatify testops bdd scenarios import --input-dir ./scenario-export`
+  - `automatify testops bdd scenarios import --input-dir ./scenario-export --dry-run`
   - `automatify testops bdd features export --output-dir ./features-export`
   - `automatify testops bdd features export --output-dir ./features-export --zip`
   - `automatify testops bdd features export --output-dir ./features-export --feature-id <FEATURE_ID>`
@@ -169,6 +182,19 @@ export JIRA_BASE_URL="https://automatify-com-au.atlassian.net"
 export JIRA_PROJECT_KEY="DEV"
 ```
 
+Or store the non-secret values in `.testops-cli.json` and, on macOS, the token in Keychain:
+```bash
+automatify testops config set baseUrl https://automatify-com-au.atlassian.net
+automatify testops config set projectKey DEV
+automatify testops config set forgeEndpoint "<webtrigger-url>"
+printf "%s" "$TESTOPS_FORGE_AUTH_TOKEN" | automatify testops config set forgeAuthToken --stdin
+```
+
+Windows, Linux, and CI should keep the token in environment variables:
+```bash
+export TESTOPS_FORGE_AUTH_TOKEN="<one-time-token-from-forge-ui>"
+```
+
 Transport notes:
 - Bearer auth is required for operator/CI use. Forge stores only the token hash plus metadata.
 - Tokens are project-scoped, shown once at creation time, and can be revoked from the Forge UI.
@@ -307,6 +333,7 @@ automatify testops bdd scenarios import --project-key DEV --file ./artifacts/sce
 
 # Export every visible SC-* file and import the whole folder back later
 automatify testops bdd scenarios export --project-key DEV --all --output-dir ./artifacts/scenario-bulk
+automatify testops bdd scenarios import --project-key DEV --input-dir ./artifacts/scenario-bulk --dry-run
 automatify testops bdd scenarios import --project-key DEV --input-dir ./artifacts/scenario-bulk
 
 # Re-import one exported file later
@@ -314,7 +341,7 @@ automatify testops ingest feature --project-key DEV --file ./artifacts/features-
 ```
 
 Feature export notes:
-- `bdd scenarios show --format feature` renders one scenario in feature-style text.
+- `bdd scenarios show --format feature` and `bdd scenarios show --feature` render one scenario in feature-style text.
 - `bdd scenarios export` writes a single-scenario `SC-*.feature` file with a reserved `@testops-scenario-SC-*` tag.
 - Jira issue links are exported as normal Gherkin tags like `@DEV-2`; on import they are written back to `linkedIssueKeys`.
 - current model has `linked issues`, not a separate persisted `primary issue`, so all exported issue-key tags are treated as equal links.

package/dist/automatify.cjs

@@ -1030,8 +1030,10 @@ var Priority;
 
 // src/config.ts
 var import_node_fs = require("node:fs");
+var import_node_child_process = require("node:child_process");
 var import_node_path = __toESM(require("node:path"), 1);
 var DEFAULT_CONFIG_FILENAME = ".testops-cli.json";
+var KEYCHAIN_SERVICE = "automatify-testops-cli";
 function parseFlags(args) {
   const flags = {};
   const unknownFlags = [];
@@ -1077,6 +1079,11 @@ function readConfigFile(configPath) {
     return {};
   }
 }
+function writeConfigFile(configPath, file) {
+  (0, import_node_fs.writeFileSync)(configPath, `${JSON.stringify(file, null, 2)}
+`, "utf8");
+  (0, import_node_fs.chmodSync)(configPath, 384);
+}
 function normalizeBaseUrl(value) {
   if (value.endsWith("/")) {
     return value.slice(0, -1);
@@ -1086,6 +1093,30 @@ function normalizeBaseUrl(value) {
 function readAuthMode(input) {
   return input === "api-token" ? "api-token" : "none";
 }
+function defaultKeychainAccount(configPath) {
+  return import_node_path.default.resolve(configPath);
+}
+function readKeychainSecret(account) {
+  if (!account || process.platform !== "darwin") {
+    return "";
+  }
+  try {
+    return (0, import_node_child_process.execFileSync)("security", ["find-generic-password", "-s", KEYCHAIN_SERVICE, "-a", account, "-w"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return "";
+  }
+}
+function setKeychainSecret(account, value) {
+  if (process.platform !== "darwin") {
+    throw new Error("Keychain-backed secrets are only supported on macOS.");
+  }
+  (0, import_node_child_process.execFileSync)("security", ["add-generic-password", "-U", "-s", KEYCHAIN_SERVICE, "-a", account, "-w", value], {
+    stdio: ["ignore", "ignore", "pipe"]
+  });
+}
 function valueFromPrecedence(key, flagValue, envValue, fileValue, fallback = "") {
   if (flagValue) {
     return { value: flagValue, source: "flag" };
@@ -1145,6 +1176,22 @@ function resolveCliConfig(args, env = process.env, cwd = process.cwd()) {
     toStringValue(env.JIRA_API_TOKEN),
     toStringValue(file.jiraApiToken ?? file.JIRA_API_TOKEN)
   );
+  const forgeEndpointResolved = valueFromPrecedence(
+    "forgeEndpoint",
+    "",
+    toStringValue(env.TESTOPS_FORGE_ENDPOINT),
+    toStringValue(file.forgeEndpoint ?? file.TESTOPS_FORGE_ENDPOINT)
+  );
+  const forgeAuthTokenKeychainAccountResolved = valueFromPrecedence(
+    "forgeAuthTokenKeychainAccount",
+    "",
+    "",
+    toStringValue(file.forgeAuthTokenKeychainAccount)
+  );
+  const forgeAuthTokenFromEnv = toStringValue(env.TESTOPS_FORGE_AUTH_TOKEN);
+  const forgeAuthTokenFromFile = toStringValue(file.forgeAuthToken ?? file.TESTOPS_FORGE_AUTH_TOKEN);
+  const forgeAuthTokenFromKeychain = forgeAuthTokenFromEnv || forgeAuthTokenFromFile || !forgeAuthTokenKeychainAccountResolved.value ? "" : readKeychainSecret(forgeAuthTokenKeychainAccountResolved.value);
+  const forgeAuthTokenResolved = forgeAuthTokenFromEnv ? { value: forgeAuthTokenFromEnv, source: "env" } : forgeAuthTokenFromFile ? { value: forgeAuthTokenFromFile, source: "file" } : forgeAuthTokenFromKeychain ? { value: forgeAuthTokenFromKeychain, source: "keychain" } : { value: "", source: "default" };
   const config = {
     baseUrl: normalizeBaseUrl(baseUrlResolved.value),
     projectKey: projectKeyResolved.value,
@@ -1152,6 +1199,9 @@ function resolveCliConfig(args, env = process.env, cwd = process.cwd()) {
     authMode: readAuthMode(authModeResolved.value),
     jiraEmail: jiraEmailResolved.value,
     jiraApiToken: jiraApiTokenResolved.value,
+    forgeEndpoint: normalizeBaseUrl(forgeEndpointResolved.value),
+    forgeAuthToken: forgeAuthTokenResolved.value,
+    forgeAuthTokenKeychainAccount: forgeAuthTokenKeychainAccountResolved.value,
     configPath
   };
   const sources = {
@@ -1161,6 +1211,9 @@ function resolveCliConfig(args, env = process.env, cwd = process.cwd()) {
     authMode: authModeResolved.source,
     jiraEmail: jiraEmailResolved.source,
     jiraApiToken: jiraApiTokenResolved.source,
+    forgeEndpoint: forgeEndpointResolved.source,
+    forgeAuthToken: forgeAuthTokenResolved.source,
+    forgeAuthTokenKeychainAccount: forgeAuthTokenKeychainAccountResolved.source,
     configPath: configPathSource
   };
   const warnings = [];
@@ -1218,9 +1271,78 @@ function toDisplayLines(resolution) {
     `  authMode: ${values.authMode} (${sources.authMode})`,
     `  jiraEmail: ${values.jiraEmail || "<unset>"} (${sources.jiraEmail})`,
     `  jiraApiToken: ${values.jiraApiToken ? maskSecret(values.jiraApiToken) : "<unset>"} (${sources.jiraApiToken})`,
+    `  forgeEndpoint: ${values.forgeEndpoint || "<unset>"} (${sources.forgeEndpoint})`,
+    `  forgeAuthToken: ${values.forgeAuthToken ? maskSecret(values.forgeAuthToken) : "<unset>"} (${sources.forgeAuthToken})`,
+    `  forgeAuthTokenKeychainAccount: ${values.forgeAuthTokenKeychainAccount || "<unset>"} (${sources.forgeAuthTokenKeychainAccount})`,
     `  configPath: ${values.configPath} (${sources.configPath})`
   ];
 }
+function normalizeConfigSetKey(input) {
+  switch (input) {
+    case "baseUrl":
+    case "JIRA_BASE_URL":
+      return "baseUrl";
+    case "projectKey":
+    case "JIRA_PROJECT_KEY":
+      return "projectKey";
+    case "issueKey":
+    case "JIRA_ISSUE_KEY":
+      return "issueKey";
+    case "authMode":
+    case "TESTOPS_AUTH_MODE":
+      return "authMode";
+    case "jiraEmail":
+    case "JIRA_EMAIL":
+      return "jiraEmail";
+    case "jiraApiToken":
+    case "JIRA_API_TOKEN":
+      return "jiraApiToken";
+    case "forgeEndpoint":
+    case "TESTOPS_FORGE_ENDPOINT":
+      return "forgeEndpoint";
+    case "forgeAuthToken":
+    case "TESTOPS_FORGE_AUTH_TOKEN":
+      return "forgeAuthToken";
+    default:
+      return "";
+  }
+}
+function applyConfigSet(configPath, rawKey, value) {
+  const key = normalizeConfigSetKey(rawKey);
+  if (!key) {
+    return {
+      exitCode: ExitCode.UsageError,
+      stderr: [
+        "Unsupported config key. Use one of: baseUrl, projectKey, issueKey, authMode, jiraEmail, jiraApiToken, forgeEndpoint, forgeAuthToken."
+      ]
+    };
+  }
+  const file = readConfigFile(configPath);
+  if (key === "forgeAuthToken") {
+    const account = toStringValue(file.forgeAuthTokenKeychainAccount) || defaultKeychainAccount(configPath);
+    setKeychainSecret(account, value);
+    const nextFile2 = {
+      ...file,
+      forgeAuthToken: void 0,
+      TESTOPS_FORGE_AUTH_TOKEN: void 0,
+      forgeAuthTokenKeychainAccount: account
+    };
+    writeConfigFile(configPath, nextFile2);
+    return {
+      exitCode: ExitCode.Success,
+      stdout: [`Config updated: forgeAuthToken stored in macOS Keychain (${account}).`]
+    };
+  }
+  const nextFile = {
+    ...file,
+    [key]: key === "baseUrl" || key === "forgeEndpoint" ? normalizeBaseUrl(value) : value
+  };
+  writeConfigFile(configPath, nextFile);
+  return {
+    exitCode: ExitCode.Success,
+    stdout: [`Config updated: ${rawKey}.`]
+  };
+}
 function createConfigHandler(env = process.env, cwd = process.cwd()) {
   return (request) => {
     const [subcommand, ...subArgs] = request.args;
@@ -1245,6 +1367,18 @@ function createConfigHandler(env = process.env, cwd = process.cwd()) {
         stderr: validation.errors.map((line) => `ERROR: ${line}`)
       };
     }
+    if (subcommand === "set") {
+      const [key, ...valueParts] = subArgs;
+      const readValueFromStdin = key === "forgeAuthToken" && valueParts.length === 1 && valueParts[0] === "--stdin";
+      const value = readValueFromStdin ? (0, import_node_fs.readFileSync)(0, "utf8").trim() : valueParts.join(" ").trim();
+      if (!key || !value) {
+        return {
+          exitCode: ExitCode.UsageError,
+          stderr: ["Usage: automatify testops config set <key> <value>"]
+        };
+      }
+      return applyConfigSet(resolution.values.configPath, key, value);
+    }
     return {
       exitCode: ExitCode.UsageError,
       stderr: [`Unsupported config subcommand: ${subcommand}`]
@@ -2761,7 +2895,7 @@ function parseArgs2(args) {
     "--file",
     ...CONFIG_FLAGS2
   ]);
-  const supportedBoolFlags = /* @__PURE__ */ new Set(["--json", "--zip", "--all"]);
+  const supportedBoolFlags = /* @__PURE__ */ new Set(["--json", "--zip", "--all", "--dry-run", "--feature"]);
   for (let index = 0; index < args.length; index += 1) {
     const token = args[index];
     if (!token.startsWith("--")) {
@@ -2923,6 +3057,39 @@ function scenarioToLines(scenario) {
   }
   return lines;
 }
+async function resolveScenarioId(context, projectKey, issueKey, scenarioSelector) {
+  const scenariosResult = await context.invokeForgeContract("listBddScenarios", {
+    context: {
+      projectKey,
+      issueKey: issueKey || void 0
+    }
+  });
+  if (!scenariosResult.ok) {
+    return {
+      ok: false,
+      response: {
+        exitCode: ExitCode.RemoteError,
+        stderr: [`ERROR: ${scenariosResult.error.code}: ${scenariosResult.error.message}`]
+      }
+    };
+  }
+  const matchedScenario = scenariosResult.data.find(
+    (item) => item.id === scenarioSelector || (item.key ?? "").toUpperCase() === scenarioSelector.toUpperCase()
+  );
+  if (!matchedScenario) {
+    return {
+      ok: false,
+      response: {
+        exitCode: ExitCode.RemoteError,
+        stderr: [`ERROR: NOT_FOUND: BDD scenario ${scenarioSelector} was not found in this project.`]
+      }
+    };
+  }
+  return {
+    ok: true,
+    scenarioId: matchedScenario.id
+  };
+}
 function featureToLines(feature) {
   return [
     `BDD feature: ${feature.payload.name}`,
@@ -3010,7 +3177,7 @@ function createBddHandler(deps = {}) {
     const [subcommand, ...restArgs] = request.args;
     const parsed = parseArgs2(restArgs);
     const requestedFormat = (parsed.flags["--format"] ?? "").trim().toLowerCase();
-    const outputFormat = parsed.boolFlags.has("--json") ? "json" : requestedFormat || "text";
+    const outputFormat = parsed.boolFlags.has("--json") ? "json" : parsed.boolFlags.has("--feature") ? "feature" : requestedFormat || "text";
     const config = resolveCliConfig(pickConfigArgs2(parsed), env, cwd);
     const projectKey = config.values.projectKey;
     const issueKey = config.values.issueKey;
@@ -3152,10 +3319,10 @@ function createBddHandler(deps = {}) {
           };
         }
         if (nested === "export") {
-          const scenarioSelector = parsed.flags["--id"]?.trim() ?? "";
+          const scenarioSelector2 = parsed.flags["--id"]?.trim() ?? "";
           const exportAll = parsed.boolFlags.has("--all");
           const outputDirFlag = parsed.flags["--output-dir"]?.trim() ?? "";
-          if (!scenarioSelector && !exportAll) {
+          if (!scenarioSelector2 && !exportAll) {
             return {
               exitCode: ExitCode.ValidationError,
               stderr: ["ERROR: Provide --id <SCENARIO_ID|SC-4> or --all for testops bdd scenarios export."]
@@ -3183,12 +3350,12 @@ function createBddHandler(deps = {}) {
               };
             }
             const selectedScenarios = exportAll ? [...scenariosResult.data].sort((left, right) => (left.key ?? left.id).localeCompare(right.key ?? right.id)) : scenariosResult.data.filter(
-              (item) => item.id === scenarioSelector || (item.key ?? "").toUpperCase() === scenarioSelector.toUpperCase()
+              (item) => item.id === scenarioSelector2 || (item.key ?? "").toUpperCase() === scenarioSelector2.toUpperCase()
             );
             if (!exportAll && selectedScenarios.length === 0) {
               return {
                 exitCode: ExitCode.RemoteError,
-                stderr: [`ERROR: NOT_FOUND: BDD scenario ${scenarioSelector} was not found in this project.`]
+                stderr: [`ERROR: NOT_FOUND: BDD scenario ${scenarioSelector2} was not found in this project.`]
               };
             }
             if (selectedScenarios.length === 0) {
@@ -3278,6 +3445,7 @@ function createBddHandler(deps = {}) {
         if (nested === "import") {
           const sourceFile = parsed.flags["--file"] ? import_node_path6.default.resolve(cwd, parsed.flags["--file"]) : "";
           const inputDir = parsed.flags["--input-dir"] ? import_node_path6.default.resolve(cwd, parsed.flags["--input-dir"]) : "";
+          const dryRun = parsed.boolFlags.has("--dry-run");
           if (!sourceFile && !inputDir) {
             return {
               exitCode: ExitCode.ValidationError,
@@ -3318,6 +3486,7 @@ function createBddHandler(deps = {}) {
               };
             }
             const updatedItems = [];
+            const plannedItems = [];
             for (const entry of parsedScenarios) {
               const parsedScenario = entry.parsed;
               const scenario = scenariosResult.data.find(
@@ -3330,6 +3499,19 @@ function createBddHandler(deps = {}) {
                 };
               }
               const nextTags = parsedScenario.tags.filter((tag) => !SCENARIO_METADATA_PATTERN.test(tag));
+              if (dryRun) {
+                plannedItems.push({
+                  file: entry.filePath,
+                  scenarioId: scenario.id,
+                  scenarioKey: scenario.key ?? null,
+                  featureName: parsedScenario.featureName,
+                  scenarioName: parsedScenario.scenarioName,
+                  tags: [...nextTags],
+                  linkedIssueKeys: [...parsedScenario.linkedIssueKeys],
+                  steps: [...parsedScenario.steps]
+                });
+                continue;
+              }
               const updateResult = await context.invokeForgeContract("updateScenario", {
                 context: {
                   projectKey,
@@ -3362,16 +3544,43 @@ function createBddHandler(deps = {}) {
                   action: "bdd-scenarios-import",
                   projectKey,
                   issueKey: issueKey || null,
-                  count: updatedItems.length,
+                  dryRun,
+                  count: dryRun ? plannedItems.length : updatedItems.length,
                   file: sourceFile || null,
                   inputDir: inputDir || null,
-                  items: updatedItems.map((entry) => ({
+                  items: dryRun ? plannedItems.map((entry) => ({
+                    file: entry.file,
+                    scenarioId: entry.scenarioId,
+                    scenarioKey: entry.scenarioKey,
+                    featureName: entry.featureName,
+                    scenarioName: entry.scenarioName,
+                    tags: [...entry.tags],
+                    linkedIssueKeys: [...entry.linkedIssueKeys],
+                    steps: entry.steps.map((step) => ({
+                      keyword: step.keyword,
+                      text: step.text
+                    }))
+                  })) : updatedItems.map((entry) => ({
                     file: entry.file,
                     item: toJsonScenario(entry.item)
                   }))
                 })
               };
             }
+            if (dryRun) {
+              return {
+                exitCode: ExitCode.Success,
+                stdout: plannedItems.flatMap((entry) => [
+                  `BDD scenario import dry-run: ${entry.scenarioKey ?? entry.scenarioId}`,
+                  `Source: ${entry.file}`,
+                  `Feature: ${entry.featureName}`,
+                  `Scenario: ${entry.scenarioName}`,
+                  `Tags: ${entry.tags.length > 0 ? entry.tags.join(", ") : "none"}`,
+                  `Linked issues: ${entry.linkedIssueKeys.length > 0 ? entry.linkedIssueKeys.join(", ") : "none"}`,
+                  ...entry.steps.map((step) => `  ${step.keyword} ${step.text}`)
+                ])
+              };
+            }
             return {
               exitCode: ExitCode.Success,
               stdout: updatedItems.flatMap((entry) => [
@@ -3387,9 +3596,9 @@ function createBddHandler(deps = {}) {
             };
           }
         }
-        const scenarioId2 = parsed.flags["--id"]?.trim() ?? "";
+        const scenarioId = parsed.flags["--id"]?.trim() ?? "";
         const testCaseKey = parsed.flags["--test-case-key"]?.trim().toUpperCase() ?? "";
-        if (!scenarioId2 && !testCaseKey) {
+        if (!scenarioId && !testCaseKey) {
           return {
             exitCode: ExitCode.ValidationError,
             stderr: ["ERROR: Provide either --id <SCENARIO_ID> or --test-case-key <TC-197> for testops bdd scenarios run."]
@@ -3397,8 +3606,8 @@ function createBddHandler(deps = {}) {
         }
         try {
           let scenarioIds = [];
-          let scenarioLabel = scenarioId2 || testCaseKey;
-          if (testCaseKey && !scenarioId2) {
+          let scenarioLabel = scenarioId || testCaseKey;
+          if (testCaseKey && !scenarioId) {
             const testCaseResult = await context.invokeForgeContract("getTestCase", {
               context: {
                 projectKey,
@@ -3433,8 +3642,8 @@ function createBddHandler(deps = {}) {
               };
             }
             scenarioLabel = `${testCase.key} (${scenarioIds.length} scenario${scenarioIds.length === 1 ? "" : "s"})`;
-          } else if (scenarioId2) {
-            scenarioIds = [scenarioId2];
+          } else if (scenarioId) {
+            scenarioIds = [scenarioId];
           }
           const runs = [];
           for (const currentScenarioId of scenarioIds) {
@@ -3490,20 +3699,24 @@ function createBddHandler(deps = {}) {
           };
         }
       }
-      const scenarioId = parsed.flags["--id"]?.trim() ?? "";
-      if (!scenarioId) {
+      const scenarioSelector = parsed.flags["--id"]?.trim() ?? "";
+      if (!scenarioSelector) {
         return {
           exitCode: ExitCode.ValidationError,
           stderr: ["ERROR: Missing required --id for testops bdd scenarios show."]
         };
       }
       try {
+        const resolvedScenario = await resolveScenarioId(context, projectKey, issueKey, scenarioSelector);
+        if (!resolvedScenario.ok) {
+          return resolvedScenario.response;
+        }
         const result = await context.invokeForgeContract("getBddScenario", {
           context: {
             projectKey,
             issueKey: issueKey || void 0
           },
-          scenarioId
+          scenarioId: resolvedScenario.scenarioId
         });
         if (!result.ok) {
           return {
@@ -5412,7 +5625,7 @@ var COMMAND_REGISTRY = [
   {
     name: "config",
     description: "Configuration and auth bootstrap commands",
-    subcommands: ["show", "validate"],
+    subcommands: ["show", "validate", "set"],
     handler: createConfigHandler()
   },
   {
@@ -5454,8 +5667,9 @@ var COMMAND_REGISTRY = [
   }
 ];
 function createThinClientContext() {
-  const endpoint = process.env.TESTOPS_FORGE_ENDPOINT?.trim() ?? "";
-  const authToken = process.env.TESTOPS_FORGE_AUTH_TOKEN?.trim() ?? "";
+  const config = resolveCliConfig([], process.env, process.cwd()).values;
+  const endpoint = process.env.TESTOPS_FORGE_ENDPOINT?.trim() || config.forgeEndpoint;
+  const authToken = process.env.TESTOPS_FORGE_AUTH_TOKEN?.trim() || config.forgeAuthToken;
   if (!endpoint) {
     return {
       invokeForgeContract: async (_contractName, _payload) => {

package/package.json

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