Merge main into feature

packages/safe-chain/src/config/cliArguments.js

@@ -1,12 +1,12 @@
 const state = {
-  malwareAction: undefined,
+  loggingLevel: undefined,
 };
 
 const SAFE_CHAIN_ARG_PREFIX = "--safe-chain-";
 
 export function initializeCliArguments(args) {
   // Reset state on each call
-  state.malwareAction = undefined;
+  state.loggingLevel = undefined;
 
   const safeChainArgs = [];
   const remainingArgs = [];
@@ -19,21 +19,11 @@ export function initializeCliArguments(args) {
     }
   }
 
-  setMalwareAction(safeChainArgs);
+  setLoggingLevel(safeChainArgs);
 
   return remainingArgs;
 }
 
-function setMalwareAction(args) {
-  const safeChainMalwareActionArg = SAFE_CHAIN_ARG_PREFIX + "malware-action=";
-
-  const action = getLastArgEqualsValue(args, safeChainMalwareActionArg);
-  if (!action) {
-    return;
-  }
-  state.malwareAction = action.toLowerCase();
-}
-
 function getLastArgEqualsValue(args, prefix) {
   for (var i = args.length - 1; i >= 0; i--) {
     const arg = args[i];
@@ -45,6 +35,16 @@ function getLastArgEqualsValue(args, prefix) {
   return undefined;
 }
 
-export function getMalwareAction() {
-  return state.malwareAction;
+function setLoggingLevel(args) {
+  const safeChainLoggingArg = SAFE_CHAIN_ARG_PREFIX + "logging=";
+
+  const level = getLastArgEqualsValue(args, safeChainLoggingArg);
+  if (!level) {
+    return;
+  }
+  state.loggingLevel = level.toLowerCase();
+}
+
+export function getLoggingLevel() {
+  return state.loggingLevel;
 }

packages/safe-chain/src/config/cliArguments.spec.js

@@ -1,6 +1,6 @@
 import { describe, it } from "node:test";
 import assert from "node:assert";
-import { initializeCliArguments, getMalwareAction } from "./cliArguments.js";
+import { initializeCliArguments, getLoggingLevel } from "./cliArguments.js";
 
 describe("initializeCliArguments", () => {
   it("should return all args when no safe-chain args are present", () => {
@@ -57,52 +57,65 @@ describe("initializeCliArguments", () => {
     assert.deepEqual(result, ["install", "my--safe-chain-package", "--save"]);
   });
 
-  it("should not set malwareAction when no safe-chain arguments are passed", () => {
+  it("should not set loggingLevel when no logging argument is passed", () => {
     const args = ["install", "express", "--save"];
-    const result = initializeCliArguments(args);
+    initializeCliArguments(args);
 
-    assert.deepEqual(result, ["install", "express", "--save"]);
-    assert.strictEqual(getMalwareAction(), undefined);
+    assert.strictEqual(getLoggingLevel(), undefined);
   });
 
-  it("should parse malware-action=block and set state", () => {
-    const args = ["--safe-chain-malware-action=block", "install", "package"];
+  it("should parse logging=silent and set state", () => {
+    const args = ["--safe-chain-logging=silent", "install", "package"];
     const result = initializeCliArguments(args);
 
     assert.deepEqual(result, ["install", "package"]);
-    assert.strictEqual(getMalwareAction(), "block");
+    assert.strictEqual(getLoggingLevel(), "silent");
   });
 
-  it("should parse malware-action=prompt and set state", () => {
-    const args = ["--safe-chain-malware-action=prompt", "install", "package"];
+  it("should parse logging=normal and set state", () => {
+    const args = ["--safe-chain-logging=normal", "install", "package"];
     const result = initializeCliArguments(args);
 
     assert.deepEqual(result, ["install", "package"]);
-    assert.strictEqual(getMalwareAction(), "prompt");
+    assert.strictEqual(getLoggingLevel(), "normal");
   });
 
-  it("should handle multiple malware-action args, using the last valid one", () => {
+  it("should handle multiple logging args, using the last one", () => {
     const args = [
-      "--safe-chain-malware-action=block",
-      "--safe-chain-malware-action=prompt",
+      "--safe-chain-logging=normal",
+      "--safe-chain-logging=silent",
       "install",
     ];
     const result = initializeCliArguments(args);
 
     assert.deepEqual(result, ["install"]);
-    assert.strictEqual(getMalwareAction(), "prompt");
+    assert.strictEqual(getLoggingLevel(), "silent");
   });
 
-  it("should handle malware-action with other safe-chain args", () => {
+  it("should handle logging level case-insensitively", () => {
+    const args = ["--safe-chain-logging=SILENT", "install"];
+    initializeCliArguments(args);
+
+    assert.strictEqual(getLoggingLevel(), "silent");
+  });
+
+  it("should capture invalid logging level as-is (lowercased)", () => {
+    const args = ["--safe-chain-logging=invalid", "install"];
+    initializeCliArguments(args);
+
+    assert.strictEqual(getLoggingLevel(), "invalid");
+  });
+
+  it("should handle logging with other safe-chain args", () => {
     const args = [
       "--safe-chain-debug",
+      "--safe-chain-logging=silent",
       "--safe-chain-malware-action=block",
-      "--safe-chain-verbose",
       "install",
     ];
     const result = initializeCliArguments(args);
 
     assert.deepEqual(result, ["install"]);
-    assert.strictEqual(getMalwareAction(), "block");
+    assert.strictEqual(getLoggingLevel(), "silent");
   });
 });

packages/safe-chain/src/config/settings.js

@@ -1,13 +1,13 @@
 import * as cliArguments from "./cliArguments.js";
 
-export function getMalwareAction() {
-  const action = cliArguments.getMalwareAction();
+export function getLoggingLevel() {
+  const level = cliArguments.getLoggingLevel();
 
-  if (action === MALWARE_ACTION_PROMPT) {
-    return MALWARE_ACTION_PROMPT;
+  if (level === LOGGING_SILENT) {
+    return LOGGING_SILENT;
   }
 
-  return MALWARE_ACTION_BLOCK;
+  return LOGGING_NORMAL;
 }
 
 export const MALWARE_ACTION_BLOCK = "block";
@@ -27,3 +27,6 @@ export function getEcoSystem() {
 export function setEcoSystem(setting) {
   ecosystemSettings.ecoSystem = setting;
 }
+
+export const LOGGING_SILENT = "silent";
+export const LOGGING_NORMAL = "normal";