codify-plugin-lib 1.0.178 → 1.0.180

package/dist/resource/stateful-parameter.d.ts

@@ -0,0 +1,165 @@
+import { StringIndexedObject } from 'codify-schemas';
+import { Plan } from '../plan/plan.js';
+import { ArrayParameterSetting, ParameterSetting } from './resource-settings.js';
+/**
+ * A stateful parameter represents a parameter that holds state on the system (can be created, destroyed) but
+ * is still tied to the overall lifecycle of a resource.
+ *
+ * **Examples include:**
+ * 1. Homebrew formulas are stateful parameters. They can be installed and uninstalled but they are still tied to the
+ * overall lifecycle of homebrew
+ * 2. Nvm installed node versions are stateful parameters. Nvm can install and uninstall different versions of Node but
+ * these versions are tied to the lifecycle of nvm. If nvm is uninstalled then so are the Node versions.
+ */
+export declare abstract class StatefulParameter<T extends StringIndexedObject, V extends T[keyof T]> {
+    /**
+     * Parameter settings for the stateful parameter. Stateful parameters share the same parameter settings as
+     * regular parameters except that they cannot be of type 'stateful'. See {@link ParameterSetting} for more
+     * information on available settings.
+     *
+     * @return The parameter settings
+     */
+    getSettings(): ParameterSetting;
+    /**
+     * Refresh the status of the stateful parameter on the system. This method works similarly to {@link Resource.refresh}.
+     * Return the value of the stateful parameter or null if not found.
+     *
+     * @param desired The desired value of the user.
+     * @param config The desired config
+     *
+     * @return The value of the stateful parameter currently on the system or null if not found
+     */
+    abstract refresh(desired: V | null, config: Partial<T>): Promise<V | null>;
+    /**
+     * Create the stateful parameter on the system. This method is similar {@link Resource.create} except that its only
+     * applicable to the stateful parameter. For resource `CREATE` operations, this method will be called after the
+     * resource is successfully created. The add method is called when a ParameterChange is ADD in a plan. The add
+     * method is only called when the stateful parameter does not currently exist.
+     *
+     * **Example (Homebrew formula):**
+     * 1. Add is called with a value of:
+     * ```
+     * ['jq', 'jenv']
+     * ```
+     * 2. Add handles the request by calling `brew install --formulae jq jenv`
+     *
+     * @param valueToAdd The desired value of the stateful parameter.
+     * @param plan The overall plan that contains the ADD
+     */
+    abstract add(valueToAdd: V, plan: Plan<T>): Promise<void>;
+    /**
+     * Modify the state of a stateful parameter on the system. This method is similar to {@link Resource.modify} except that its only
+     * applicable to the stateful parameter.
+     *
+     * **Example (Git email parameter):**
+     * 1. Add is called with a value of:
+     * ```
+     * newValue: 'email+new@gmail.com', previousValue: 'email+old@gmail.com'
+     * ```
+     * 2. Modify handles the request by calling `git config --global user.email email+new@gmail.com`
+     *
+     * @param newValue The desired value of the stateful parameter
+     * @param previousValue The current value of the stateful parameter
+     * @param plan The overall plan
+     */
+    abstract modify(newValue: V, previousValue: V, plan: Plan<T>): Promise<void>;
+    /**
+     * Create the stateful parameter on the system. This method is similar {@link Resource.destroy} except that its only
+     * applicable to the stateful parameter. The remove method is only called when the stateful parameter already currently exist.
+     * This method corresponds to REMOVE parameter operations in a plan.
+     * For resource `DESTORY`, this method is only called if the {@link ResourceSettings.removeStatefulParametersBeforeDestroy}
+     * is set to true. This method will be called before the resource is destroyed.
+     *
+     * **Example (Homebrew formula):**
+     * 1. Remove is called with a value of:
+     * ```
+     * ['jq', 'jenv']
+     * ```
+     * 2. Remove handles the request by calling `brew uninstall --formulae jq jenv`
+     *
+     * @param valueToRemove The value to remove from the stateful parameter.
+     * @param plan The overall plan that contains the REMOVE
+     */
+    abstract remove(valueToRemove: V, plan: Plan<T>): Promise<void>;
+}
+/**
+ * A specialized version of {@link StatefulParameter } that is used for stateful parameters which are arrays.
+ * A stateful parameter represents a parameter that holds state on the system (can be created, destroyed) but
+ * is still tied to the overall lifecycle of a resource.
+ *
+ * **Examples:**
+ * - Homebrew formulas are arrays
+ * - Pyenv python versions are arrays
+ */
+export declare abstract class ArrayStatefulParameter<T extends StringIndexedObject, V> extends StatefulParameter<T, any> {
+    /**
+     * Parameter level settings. Type must be 'array'.
+     */
+    getSettings(): ArrayParameterSetting;
+    /**
+     * It is not recommended to override the `add` method. A addItem helper method is available to operate on
+     * individual elements of the desired array. See {@link StatefulParameter.add} for more info.
+     *
+     * @param valuesToAdd The array of values to add
+     * @param plan The overall plan
+     *
+     */
+    add(valuesToAdd: V[], plan: Plan<T>): Promise<void>;
+    /**
+     * It is not recommended to override the `modify` method. `addItem` and `removeItem` will be called accordingly based
+     * on the modifications. See {@link StatefulParameter.modify} for more info.
+     *
+     * @param newValues The new array value
+     * @param previousValues The previous array value
+     * @param plan The overall plan
+     */
+    modify(newValues: V[], previousValues: V[], plan: Plan<T>): Promise<void>;
+    /**
+     * It is not recommended to override the `remove` method. A removeItem helper method is available to operate on
+     * individual elements of the desired array. See {@link StatefulParameter.remove} for more info.
+     *
+     * @param valuesToAdd The array of values to add
+     * @param plan The overall plan
+     *
+     */
+    remove(valuesToRemove: V[], plan: Plan<T>): Promise<void>;
+    /**
+     * See {@link StatefulParameter.refresh} for more info.
+     *
+     * @param desired The desired value to refresh
+     * @return The current value on the system or null if not found.
+     */
+    abstract refresh(desired: V[] | null, config: Partial<T>): Promise<V[] | null>;
+    /**
+     * Helper method that gets called when individual elements of the array need to be added. See {@link StatefulParameter.add}
+     * for more information.
+     *
+     * Example (Homebrew formula):
+     * 1. The stateful parameter receives an input of:
+     * ```
+     * ['jq', 'jenv', 'docker']
+     * ```
+     * 2. Internally the stateful parameter will iterate the array and call `addItem` for each element
+     * 3. Override addItem and install each formula using `brew install --formula jq`
+     *
+     * @param item The item to add (install)
+     * @param plan The overall plan
+     */
+    abstract addItem(item: V, plan: Plan<T>): Promise<void>;
+    /**
+     * Helper method that gets called when individual elements of the array need to be removed. See {@link StatefulParameter.remove}
+     * for more information.
+     *
+     * Example (Homebrew formula):
+     * 1. The stateful parameter receives an input of:
+     * ```
+     * ['jq', 'jenv', 'docker']
+     * ```
+     * 2. Internally the stateful parameter will iterate the array and call `removeItem` for each element
+     * 3. Override removeItem and uninstall each formula using `brew uninstall --formula jq`
+     *
+     * @param item The item to remove (uninstall)
+     * @param plan The overall plan
+     */
+    abstract removeItem(item: V, plan: Plan<T>): Promise<void>;
+}

package/dist/resource/stateful-parameter.js

@@ -0,0 +1,94 @@
+/**
+ * A stateful parameter represents a parameter that holds state on the system (can be created, destroyed) but
+ * is still tied to the overall lifecycle of a resource.
+ *
+ * **Examples include:**
+ * 1. Homebrew formulas are stateful parameters. They can be installed and uninstalled but they are still tied to the
+ * overall lifecycle of homebrew
+ * 2. Nvm installed node versions are stateful parameters. Nvm can install and uninstall different versions of Node but
+ * these versions are tied to the lifecycle of nvm. If nvm is uninstalled then so are the Node versions.
+ */
+export class StatefulParameter {
+    /**
+     * Parameter settings for the stateful parameter. Stateful parameters share the same parameter settings as
+     * regular parameters except that they cannot be of type 'stateful'. See {@link ParameterSetting} for more
+     * information on available settings.
+     *
+     * @return The parameter settings
+     */
+    getSettings() {
+        return {};
+    }
+}
+/**
+ * A specialized version of {@link StatefulParameter } that is used for stateful parameters which are arrays.
+ * A stateful parameter represents a parameter that holds state on the system (can be created, destroyed) but
+ * is still tied to the overall lifecycle of a resource.
+ *
+ * **Examples:**
+ * - Homebrew formulas are arrays
+ * - Pyenv python versions are arrays
+ */
+export class ArrayStatefulParameter extends StatefulParameter {
+    /**
+     * Parameter level settings. Type must be 'array'.
+     */
+    getSettings() {
+        return { type: 'array' };
+    }
+    /**
+     * It is not recommended to override the `add` method. A addItem helper method is available to operate on
+     * individual elements of the desired array. See {@link StatefulParameter.add} for more info.
+     *
+     * @param valuesToAdd The array of values to add
+     * @param plan The overall plan
+     *
+     */
+    async add(valuesToAdd, plan) {
+        for (const value of valuesToAdd) {
+            await this.addItem(value, plan);
+        }
+    }
+    /**
+     * It is not recommended to override the `modify` method. `addItem` and `removeItem` will be called accordingly based
+     * on the modifications. See {@link StatefulParameter.modify} for more info.
+     *
+     * @param newValues The new array value
+     * @param previousValues The previous array value
+     * @param plan The overall plan
+     */
+    async modify(newValues, previousValues, plan) {
+        // TODO: I don't think this works with duplicate elements. Solve at another time
+        const valuesToAdd = newValues.filter((n) => !previousValues.some((p) => {
+            if (this.getSettings()?.isElementEqual) {
+                return this.getSettings().isElementEqual(n, p);
+            }
+            return n === p;
+        }));
+        const valuesToRemove = previousValues.filter((p) => !newValues.some((n) => {
+            if (this.getSettings().isElementEqual) {
+                return this.getSettings().isElementEqual(n, p);
+            }
+            return n === p;
+        }));
+        for (const value of valuesToAdd) {
+            await this.addItem(value, plan);
+        }
+        for (const value of valuesToRemove) {
+            await this.removeItem(value, plan);
+        }
+    }
+    /**
+     * It is not recommended to override the `remove` method. A removeItem helper method is available to operate on
+     * individual elements of the desired array. See {@link StatefulParameter.remove} for more info.
+     *
+     * @param valuesToAdd The array of values to add
+     * @param plan The overall plan
+     *
+     */
+    async remove(valuesToRemove, plan) {
+        for (const value of valuesToRemove) {
+            await this.removeItem(value, plan);
+        }
+    }
+}

package/dist/utils/spawn-2.d.ts

@@ -0,0 +1,5 @@
+import { Shell } from 'zx';
+export declare class ShellContext implements Shell {
+    zx: Shell;
+    static create(): ShellContext;
+}

package/dist/utils/spawn-2.js

@@ -0,0 +1,7 @@
+import { $ } from 'zx';
+export class ShellContext {
+    zx = $({ shell: true });
+    static create() {
+        return new ShellContext();
+    }
+}

package/dist/utils/spawn.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" resolution-mode="require"/>
+import { SpawnOptions } from 'node:child_process';
+export declare enum SpawnStatus {
+    SUCCESS = "success",
+    ERROR = "error"
+}
+export interface SpawnResult {
+    status: SpawnStatus;
+    data: string;
+}
+type CodifySpawnOptions = {
+    cwd?: string;
+    throws?: boolean;
+    requiresRoot?: boolean;
+} & Omit<SpawnOptions, 'detached' | 'shell' | 'stdio'>;
+/**
+ *
+ * @param cmd Command to run. Ex: `rm -rf`
+ * @param opts Standard options for node spawn. Additional argument:
+ * throws determines if a shell will throw a JS error. Defaults to true
+ *
+ * @see promiseSpawn
+ * @see spawn
+ *
+ * @returns SpawnResult { status: SUCCESS | ERROR; data: string }
+ */
+export declare function $(cmd: string, opts?: CodifySpawnOptions): Promise<SpawnResult>;
+export declare function isDebug(): boolean;
+export {};

package/dist/utils/spawn.js

@@ -0,0 +1,124 @@
+import { Ajv } from 'ajv';
+import { MessageCmd, SudoRequestResponseDataSchema } from 'codify-schemas';
+import { spawn } from 'node:child_process';
+import { SudoError } from '../errors.js';
+const ajv = new Ajv({
+    strict: true,
+});
+const validateSudoRequestResponse = ajv.compile(SudoRequestResponseDataSchema);
+export var SpawnStatus;
+(function (SpawnStatus) {
+    SpawnStatus["SUCCESS"] = "success";
+    SpawnStatus["ERROR"] = "error";
+})(SpawnStatus || (SpawnStatus = {}));
+/**
+ *
+ * @param cmd Command to run. Ex: `rm -rf`
+ * @param opts Standard options for node spawn. Additional argument:
+ * throws determines if a shell will throw a JS error. Defaults to true
+ *
+ * @see promiseSpawn
+ * @see spawn
+ *
+ * @returns SpawnResult { status: SUCCESS | ERROR; data: string }
+ */
+export async function $(cmd, opts) {
+    const throws = opts?.throws ?? true;
+    console.log(`Running command: ${cmd}`);
+    try {
+        // TODO: Need to benchmark the effects of using sh vs zsh for shell.
+        //  Seems like zsh shells run slower
+        let result;
+        if (!opts?.requiresRoot) {
+            result = await internalSpawn(cmd, opts ?? {});
+        }
+        else {
+            result = await externalSpawnWithSudo(cmd, opts);
+        }
+        if (result.status !== SpawnStatus.SUCCESS) {
+            throw new Error(result.data);
+        }
+        return result;
+    }
+    catch (error) {
+        if (isDebug()) {
+            console.error(`CodifySpawn error for command ${cmd}`, error);
+        }
+        if (error.message?.startsWith('sudo:')) {
+            throw new SudoError(cmd);
+        }
+        if (throws) {
+            throw error;
+        }
+        if (error instanceof Error) {
+            return {
+                status: SpawnStatus.ERROR,
+                data: error.message,
+            };
+        }
+        return {
+            status: SpawnStatus.ERROR,
+            data: error + '',
+        };
+    }
+}
+async function internalSpawn(cmd, opts) {
+    return new Promise((resolve, reject) => {
+        const output = [];
+        // Source start up shells to emulate a users environment vs. a non-interactive non-login shell script
+        // Ignore all stdin
+        const _process = spawn(`source ~/.zshrc; ${cmd}`, [], {
+            ...opts,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            shell: 'zsh',
+        });
+        const { stdout, stderr, stdin } = _process;
+        stdout.setEncoding('utf8');
+        stderr.setEncoding('utf8');
+        stdout.on('data', (data) => {
+            output.push(data.toString());
+        });
+        stderr.on('data', (data) => {
+            output.push(data.toString());
+        });
+        _process.on('error', (data) => {
+        });
+        // please node that this is not a full replacement for 'inherit'
+        // the child process can and will detect if stdout is a pty and change output based on it
+        // the terminal context is lost & ansi information (coloring) etc will be lost
+        if (stdout && stderr) {
+            stdout.pipe(process.stdout);
+            stderr.pipe(process.stderr);
+        }
+        _process.on('close', (code) => {
+            resolve({
+                status: code === 0 ? SpawnStatus.SUCCESS : SpawnStatus.ERROR,
+                data: output.join('\n'),
+            });
+        });
+    });
+}
+async function externalSpawnWithSudo(cmd, opts) {
+    return await new Promise((resolve) => {
+        const listener = (data) => {
+            if (data.cmd === MessageCmd.SUDO_REQUEST + '_Response') {
+                process.removeListener('message', listener);
+                if (!validateSudoRequestResponse(data.data)) {
+                    throw new Error(`Invalid response for sudo request: ${JSON.stringify(validateSudoRequestResponse.errors, null, 2)}`);
+                }
+                resolve(data.data);
+            }
+        };
+        process.on('message', listener);
+        process.send({
+            cmd: MessageCmd.SUDO_REQUEST,
+            data: {
+                command: cmd,
+                options: opts ?? {},
+            }
+        });
+    });
+}
+export function isDebug() {
+    return process.env.DEBUG != null && process.env.DEBUG.includes('codify'); // TODO: replace with debug library
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codify-plugin-lib",
-  "version": "1.0.178",
+  "version": "1.0.180",
   "description": "Library plugin library",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -16,7 +16,7 @@
   "dependencies": {
     "ajv": "^8.12.0",
     "ajv-formats": "^2.1.1",
-    "codify-schemas": "1.0.77",
+    "codify-schemas": "1.0.83",
     "@npmcli/promise-spawn": "^7.0.1",
     "@homebridge/node-pty-prebuilt-multiarch": "^0.12.0-beta.5",
     "uuid": "^10.0.0",

package/src/plan/change-set.test.ts

@@ -87,7 +87,7 @@ describe('Change set tests', () => {
   it('Correctly diffs two resource configs (destory)', () => {
     const cs = ChangeSet.destroy({
       propA: 'prop',
-      propB: 'propB'
+      propB: 'propB',
     });
 
     expect(cs.parameterChanges.length).to.eq(2);

package/src/plan/change-set.ts

@@ -1,6 +1,7 @@
 import { ParameterOperation, ResourceOperation, StringIndexedObject } from 'codify-schemas';
 
 import { ParsedParameterSetting } from '../resource/parsed-resource-settings.js';
+import { ResourceSettings } from '../resource/resource-settings.js';
 
 /**
  * A parameter change describes a parameter level change to a resource.
@@ -25,6 +26,11 @@ export interface ParameterChange<T extends StringIndexedObject> {
    * The new value of the resource (the desired value)
    */
   newValue: any | null;
+
+  /**
+   * Whether the parameter is sensitive
+   */
+  isSensitive: boolean;
 }
 
 // Change set will coerce undefined values to null because undefined is not valid JSON
@@ -60,37 +66,40 @@ export class ChangeSet<T extends StringIndexedObject> {
     return new ChangeSet<T>(ResourceOperation.NOOP, []);
   }
 
-  static create<T extends StringIndexedObject>(desired: Partial<T>): ChangeSet<T> {
+  static create<T extends StringIndexedObject>(desired: Partial<T>, settings?: ResourceSettings<T>): ChangeSet<T> {
     const parameterChanges = Object.entries(desired)
       .map(([k, v]) => ({
         name: k,
         operation: ParameterOperation.ADD,
         previousValue: null,
         newValue: v ?? null,
+        isSensitive: settings?.parameterSettings?.[k]?.isSensitive ?? false,
       }))
 
     return new ChangeSet(ResourceOperation.CREATE, parameterChanges);
   }
 
-  static noop<T extends StringIndexedObject>(parameters: Partial<T>): ChangeSet<T> {
+  static noop<T extends StringIndexedObject>(parameters: Partial<T>, settings?: ResourceSettings<T>): ChangeSet<T> {
     const parameterChanges = Object.entries(parameters)
       .map(([k, v]) => ({
         name: k,
         operation: ParameterOperation.NOOP,
         previousValue: v ?? null,
         newValue: v ?? null,
+        isSensitive: settings?.parameterSettings?.[k]?.isSensitive ?? false,
       }))
 
     return new ChangeSet(ResourceOperation.NOOP, parameterChanges);
   }
 
-  static destroy<T extends StringIndexedObject>(current: Partial<T>): ChangeSet<T> {
+  static destroy<T extends StringIndexedObject>(current: Partial<T>, settings?: ResourceSettings<T>): ChangeSet<T> {
     const parameterChanges = Object.entries(current)
       .map(([k, v]) => ({
         name: k,
         operation: ParameterOperation.REMOVE,
         previousValue: v ?? null,
         newValue: null,
+        isSensitive: settings?.parameterSettings?.[k]?.isSensitive ?? false,
       }))
 
     return new ChangeSet(ResourceOperation.DESTROY, parameterChanges);
@@ -160,6 +169,7 @@ export class ChangeSet<T extends StringIndexedObject> {
           previousValue: current[k] ?? null,
           newValue: desired[k] ?? null,
           operation: ParameterOperation.NOOP,
+          isSensitive: parameterOptions?.[k]?.isSensitive ?? false,
         })
 
         continue;
@@ -171,6 +181,7 @@ export class ChangeSet<T extends StringIndexedObject> {
           previousValue: current[k] ?? null,
           newValue: null,
           operation: ParameterOperation.REMOVE,
+          isSensitive: parameterOptions?.[k]?.isSensitive ?? false,
         })
 
         continue;
@@ -182,6 +193,7 @@ export class ChangeSet<T extends StringIndexedObject> {
           previousValue: null,
           newValue: desired[k] ?? null,
           operation: ParameterOperation.ADD,
+          isSensitive: parameterOptions?.[k]?.isSensitive ?? false,
         })
 
         continue;
@@ -192,6 +204,7 @@ export class ChangeSet<T extends StringIndexedObject> {
         previousValue: current[k] ?? null,
         newValue: desired[k] ?? null,
         operation: ParameterOperation.MODIFY,
+        isSensitive: parameterOptions?.[k]?.isSensitive ?? false,
       })
     }
 

package/src/plan/plan.ts

@@ -118,7 +118,7 @@ export class Plan<T extends StringIndexedObject> {
     if (!filteredCurrentParameters && desired) {
       return new Plan(
         uuidV4(),
-        ChangeSet.create(desired),
+        ChangeSet.create(desired, settings),
         core,
         isStateful,
       )
@@ -130,7 +130,7 @@ export class Plan<T extends StringIndexedObject> {
       if (!settings.canDestroy) {
         return new Plan(
           uuidV4(),
-          ChangeSet.noop(filteredCurrentParameters),
+          ChangeSet.noop(filteredCurrentParameters, settings),
           core,
           isStateful,
         )
@@ -138,7 +138,7 @@ export class Plan<T extends StringIndexedObject> {
 
       return new Plan(
         uuidV4(),
-        ChangeSet.destroy(filteredCurrentParameters),
+        ChangeSet.destroy(filteredCurrentParameters, settings),
         core,
         isStateful,
       )
@@ -171,7 +171,10 @@ export class Plan<T extends StringIndexedObject> {
       uuidV4(),
       new ChangeSet<T>(
         data.operation,
-        data.parameters
+        data.parameters.map((p) => ({
+          ...p,
+          isSensitive: p.isSensitive ?? false,
+        })),
       ),
       {
         type: data.resourceType,

package/src/plugin/plugin.ts

@@ -59,14 +59,28 @@ export class Plugin {
 
     return {
       resourceDefinitions: [...this.resourceControllers.values()]
-        .map((r) => ({
-          dependencies: r.dependencies,
-          type: r.typeId,
-        }))
+        .map((r) => {
+          const sensitiveParameters = Object.entries(r.settings.parameterSettings ?? {})
+            .filter(([, v]) => v?.isSensitive)
+            .map(([k]) => k);
+
+          // Here we add '*' if the resource is sensitive but no sensitive parameters are found. This works because the import
+          // sensitivity check only checks for the existance of a sensitive parameter whereas the parameter blocking one blocks
+          // on a specific sensitive parameter.
+          if (r.settings.isSensitive && sensitiveParameters.length === 0) {
+            sensitiveParameters.push('*');
+          }
+
+          return {
+            dependencies: r.dependencies,
+            type: r.typeId,
+            sensitiveParameters,
+          }
+        })
     }
   }
 
-  async getResourceInfo(data: GetResourceInfoRequestData): Promise<GetResourceInfoResponseData> {
+  getResourceInfo(data: GetResourceInfoRequestData): GetResourceInfoResponseData {
     if (!this.resourceControllers.has(data.type)) {
       throw new Error(`Cannot get info for resource ${data.type}, resource doesn't exist`);
     }
@@ -84,6 +98,17 @@ export class Plugin {
     const allowMultiple = resource.settings.allowMultiple !== undefined
       && resource.settings.allowMultiple !== false;
 
+    // Here we add '*' if the resource is sensitive but no sensitive parameters are found. This works because the import
+    // sensitivity check only checks for the existance of a sensitive parameter whereas the parameter blocking one blocks
+    // on a specific sensitive parameter.
+    const sensitiveParameters = Object.entries(resource.settings.parameterSettings ?? {})
+      .filter(([, v]) => v?.isSensitive)
+      .map(([k]) => k);
+
+    if (resource.settings.isSensitive && sensitiveParameters.length === 0) {
+      sensitiveParameters.push('*');
+    }
+
     return {
       plugin: this.name,
       type: data.type,
@@ -96,6 +121,7 @@ export class Plugin {
       import: {
         requiredParameters: requiredPropertyNames,
       },
+      sensitiveParameters,
       allowMultiple
     }
   }