codify-plugin-lib 1.0.181 → 1.0.182-beta1

package/dist/index.d.ts

@@ -10,5 +10,5 @@ export * from './resource/parsed-resource-settings.js';
 export * from './resource/resource.js';
 export * from './resource/resource-settings.js';
 export * from './stateful-parameter/stateful-parameter.js';
-export * from './utils/utils.js';
+export * from './utils/index.js';
 export declare function runPlugin(plugin: Plugin): Promise<void>;

package/dist/index.js

@@ -10,7 +10,7 @@ export * from './resource/parsed-resource-settings.js';
 export * from './resource/resource.js';
 export * from './resource/resource-settings.js';
 export * from './stateful-parameter/stateful-parameter.js';
-export * from './utils/utils.js';
+export * from './utils/index.js';
 export async function runPlugin(plugin) {
     const messageHandler = new MessageHandler(plugin);
     process.on('message', (message) => messageHandler.onMessage(message));

package/dist/plugin/plugin.js

@@ -2,9 +2,10 @@ import { ApplyValidationError } from '../common/errors.js';
 import { Plan } from '../plan/plan.js';
 import { BackgroundPty } from '../pty/background-pty.js';
 import { getPty } from '../pty/index.js';
+import { SequentialPty } from '../pty/seqeuntial-pty.js';
 import { ResourceController } from '../resource/resource-controller.js';
+import { VerbosityLevel } from '../utils/internal-utils.js';
 import { ptyLocalStorage } from '../utils/pty-local-storage.js';
-import { VerbosityLevel } from '../utils/utils.js';
 export class Plugin {
     name;
     resourceControllers;
@@ -44,6 +45,7 @@ export class Plugin {
                     dependencies: r.dependencies,
                     type: r.typeId,
                     sensitiveParameters,
+                    operatingSystems: r.settings.operatingSystems,
                 };
             })
         };
@@ -81,6 +83,7 @@ export class Plugin {
             import: {
                 requiredParameters: requiredPropertyNames,
             },
+            operatingSystems: resource.settings.operatingSystems,
             sensitiveParameters,
             allowMultiple
         };
@@ -158,7 +161,7 @@ export class Plugin {
         if (!resource) {
             throw new Error('Malformed plan with resource that cannot be found');
         }
-        await resource.apply(plan);
+        await ptyLocalStorage.run(new SequentialPty(), async () => resource.apply(plan));
         // Validate using desired/desired. If the apply was successful, no changes should be reported back.
         // Default back desired back to current if it is not defined (for destroys only)
         const validationPlan = await ptyLocalStorage.run(new BackgroundPty(), async () => {

package/dist/pty/background-pty.js

@@ -5,7 +5,8 @@ import { EventEmitter } from 'node:events';
 import * as fs from 'node:fs/promises';
 import stripAnsi from 'strip-ansi';
 import { debugLog } from '../utils/debug.js';
-import { VerbosityLevel } from '../utils/utils.js';
+import { Shell, Utils } from '../utils/index.js';
+import { VerbosityLevel } from '../utils/internal-utils.js';
 import { SpawnError } from './index.js';
 import { PromiseQueue } from './promise-queue.js';
 EventEmitter.defaultMaxListeners = 1000;
@@ -104,8 +105,15 @@ export class BackgroundPty {
             let outputBuffer = '';
             return new Promise(resolve => {
                 // zsh-specific commands
-                if (this.getDefaultShell() === 'zsh') {
-                    this.basePty.write('setopt hist_ignore_space;\n');
+                switch (Utils.getShell()) {
+                    case Shell.ZSH: {
+                        this.basePty.write('setopt HIST_NO_STORE;\n');
+                        break;
+                    }
+                    default: {
+                        this.basePty.write('export HISTIGNORE=\'history*\';\n');
+                        break;
+                    }
                 }
                 this.basePty.write(' unset PS1;\n');
                 this.basePty.write(' unset PS0;\n');
@@ -121,6 +129,6 @@ export class BackgroundPty {
         });
     }
     getDefaultShell() {
-        return process.platform === 'darwin' ? 'zsh' : 'bash';
+        return process.env.SHELL;
     }
 }

package/dist/pty/index.d.ts

@@ -1,5 +1,5 @@
 export interface SpawnResult {
-    status: 'success' | 'error';
+    status: 'error' | 'success';
     exitCode: number;
     data: string;
 }
@@ -7,9 +7,25 @@ export declare enum SpawnStatus {
     SUCCESS = "success",
     ERROR = "error"
 }
+/**
+ * Represents the configuration options for spawning a child process.
+ *
+ * @interface SpawnOptions
+ *
+ * @property {string} [cwd] - Specifies the working directory of the child process.
+ * If not provided, the current working directory of the parent process is used.
+ *
+ * @property {Record<string, unknown>} [env] - Defines environment key-value pairs
+ * that will be available to the child process. If not specified, the child process
+ * will inherit the environment variables of the parent process.
+ *
+ * @property {boolean} [interactive] - Indicates whether the spawned process needs
+ * to be interactive. Only works within apply (not plan). Defaults to true.
+ */
 export interface SpawnOptions {
     cwd?: string;
     env?: Record<string, unknown>;
+    interactive?: boolean;
 }
 export declare class SpawnError extends Error {
     data: string;

package/dist/pty/seqeuntial-pty.d.ts

@@ -0,0 +1,16 @@
+import { IPty, SpawnOptions, SpawnResult } from './index.js';
+/**
+ * The background pty is a specialized pty designed for speed. It can launch multiple tasks
+ * in parallel by moving them to the background. It attaches unix FIFO pipes to each process
+ * to listen to stdout and stderr. One limitation of the BackgroundPty is that the tasks run
+ * without a tty (or even a stdin) attached so interactive commands will not work.
+ */
+export declare class SequentialPty implements IPty {
+    spawn(cmd: string, options?: SpawnOptions): Promise<SpawnResult>;
+    spawnSafe(cmd: string, options?: SpawnOptions): Promise<SpawnResult>;
+    kill(): Promise<{
+        exitCode: number;
+        signal?: number | undefined;
+    }>;
+    private getDefaultShell;
+}

package/dist/pty/seqeuntial-pty.js

@@ -0,0 +1,84 @@
+import pty from '@homebridge/node-pty-prebuilt-multiarch';
+import { EventEmitter } from 'node:events';
+import stripAnsi from 'strip-ansi';
+import { Shell, Utils } from '../utils/index.js';
+import { VerbosityLevel } from '../utils/internal-utils.js';
+import { SpawnError, SpawnStatus } from './index.js';
+EventEmitter.defaultMaxListeners = 1000;
+/**
+ * The background pty is a specialized pty designed for speed. It can launch multiple tasks
+ * in parallel by moving them to the background. It attaches unix FIFO pipes to each process
+ * to listen to stdout and stderr. One limitation of the BackgroundPty is that the tasks run
+ * without a tty (or even a stdin) attached so interactive commands will not work.
+ */
+export class SequentialPty {
+    async spawn(cmd, options) {
+        const spawnResult = await this.spawnSafe(cmd, options);
+        if (spawnResult.status !== 'success') {
+            throw new SpawnError(cmd, spawnResult.exitCode, spawnResult.data);
+        }
+        return spawnResult;
+    }
+    async spawnSafe(cmd, options) {
+        console.log(`Running command: ${cmd}` + (options?.cwd ? `(${options?.cwd})` : ''));
+        return new Promise((resolve) => {
+            const output = [];
+            const historyIgnore = Utils.getShell() === Shell.ZSH ? { HISTORY_IGNORE: '*' } : { HISTIGNORE: '*' };
+            // If TERM_PROGRAM=Apple_Terminal is set then ANSI escape characters may be included
+            // in the response.
+            const env = {
+                ...process.env, ...options?.env,
+                TERM_PROGRAM: 'codify',
+                COMMAND_MODE: 'unix2003',
+                COLORTERM: 'truecolor', ...historyIgnore
+            };
+            // Initial terminal dimensions
+            const initialCols = process.stdout.columns ?? 80;
+            const initialRows = process.stdout.rows ?? 24;
+            const args = (options?.interactive ?? true) ? ['-i', '-c', `"${cmd}"`] : ['-c', `"${cmd}"`];
+            // Run the command in a pty for interactivity
+            const mPty = pty.spawn(this.getDefaultShell(), args, {
+                ...options,
+                cols: initialCols,
+                rows: initialRows,
+                env
+            });
+            mPty.onData((data) => {
+                if (VerbosityLevel.get() > 0) {
+                    process.stdout.write(data);
+                }
+                output.push(data.toString());
+            });
+            const stdinListener = (data) => {
+                mPty.write(data.toString());
+            };
+            const resizeListener = () => {
+                const { columns, rows } = process.stdout;
+                mPty.resize(columns, rows);
+            };
+            // Listen to resize events for the terminal window;
+            process.stdout.on('resize', resizeListener);
+            // Listen for user input
+            process.stdin.on('data', stdinListener);
+            mPty.onExit((result) => {
+                process.stdout.off('resize', resizeListener);
+                process.stdin.off('data', stdinListener);
+                resolve({
+                    status: result.exitCode === 0 ? SpawnStatus.SUCCESS : SpawnStatus.ERROR,
+                    exitCode: result.exitCode,
+                    data: stripAnsi(output.join('\n').trim()),
+                });
+            });
+        });
+    }
+    async kill() {
+        // No-op here. Each pty instance is stand alone and tied to the parent process. Everything should be killed as expected.
+        return {
+            exitCode: 0,
+            signal: 0,
+        };
+    }
+    getDefaultShell() {
+        return process.env.SHELL;
+    }
+}

package/dist/resource/parsed-resource-settings.d.ts

@@ -1,5 +1,5 @@
 import { JSONSchemaType } from 'ajv';
-import { StringIndexedObject } from 'codify-schemas';
+import { OS, StringIndexedObject } from 'codify-schemas';
 import { StatefulParameterController } from '../stateful-parameter/stateful-parameter-controller.js';
 import { ArrayParameterSetting, DefaultParameterSetting, InputTransformation, ResourceSettings } from './resource-settings.js';
 export interface ParsedStatefulParameterSetting extends DefaultParameterSetting {
@@ -26,6 +26,8 @@ export declare class ParsedResourceSettings<T extends StringIndexedObject> imple
     removeStatefulParametersBeforeDestroy?: boolean | undefined;
     dependencies?: string[] | undefined;
     transformation?: InputTransformation;
+    operatingSystems: Array<OS>;
+    isSensitive?: boolean;
     private settings;
     constructor(settings: ResourceSettings<T>);
     get typeId(): string;

package/dist/resource/parsed-resource-settings.js

@@ -8,15 +8,13 @@ export class ParsedResourceSettings {
     removeStatefulParametersBeforeDestroy;
     dependencies;
     transformation;
+    operatingSystems;
+    isSensitive;
     settings;
     constructor(settings) {
         this.settings = settings;
-        this.id = settings.id;
-        this.schema = settings.schema;
-        this.allowMultiple = settings.allowMultiple;
-        this.removeStatefulParametersBeforeDestroy = settings.removeStatefulParametersBeforeDestroy;
-        this.dependencies = settings.dependencies;
-        this.transformation = settings.transformation;
+        const { parameterSettings, ...rest } = settings;
+        Object.assign(this, rest);
         this.validateSettings();
     }
     get typeId() {

package/dist/resource/resource-settings.d.ts

@@ -1,5 +1,5 @@
 import { JSONSchemaType } from 'ajv';
-import { StringIndexedObject } from 'codify-schemas';
+import { OS, StringIndexedObject } from 'codify-schemas';
 import { ArrayStatefulParameter, StatefulParameter } from '../stateful-parameter/stateful-parameter.js';
 import { RefreshContext } from './resource.js';
 export interface InputTransformation {
@@ -14,6 +14,10 @@ export interface ResourceSettings<T extends StringIndexedObject> {
      * The typeId of the resource.
      */
     id: string;
+    /**
+     * List of supported operating systems
+     */
+    operatingSystems: Array<OS>;
     /**
      * Schema to validate user configs with. Must be in the format JSON Schema draft07
      */

package/dist/resource/resource-settings.js

@@ -1,6 +1,6 @@
 import isObjectsEqual from 'lodash.isequal';
 import path from 'node:path';
-import { addVariablesToPath, areArraysEqual, resolvePathWithVariables, tildify, untildify } from '../utils/utils.js';
+import { addVariablesToPath, areArraysEqual, resolvePathWithVariables, tildify, untildify } from '../utils/internal-utils.js';
 const ParameterEqualsDefaults = {
     'boolean': (a, b) => Boolean(a) === Boolean(b),
     'directory': (a, b) => {

package/dist/utils/index.d.ts

@@ -0,0 +1,25 @@
+import { OS } from 'codify-schemas';
+export declare enum Shell {
+    ZSH = "zsh",
+    BASH = "bash",
+    SH = "sh",
+    KSH = "ksh",
+    CSH = "csh",
+    FISH = "fish"
+}
+export interface SystemInfo {
+    os: OS;
+    shell: Shell;
+}
+export declare const Utils: {
+    getUser(): string;
+    getSystemInfo(): {
+        os: string;
+        shell: Shell | undefined;
+    };
+    isMacOS(): boolean;
+    isLinux(): boolean;
+    getShell(): Shell | undefined;
+    getPrimaryShellRc(): string;
+    getShellRcFiles(): string[];
+};

package/dist/utils/index.js

@@ -0,0 +1,108 @@
+import os from 'node:os';
+import path from 'node:path';
+export var Shell;
+(function (Shell) {
+    Shell["ZSH"] = "zsh";
+    Shell["BASH"] = "bash";
+    Shell["SH"] = "sh";
+    Shell["KSH"] = "ksh";
+    Shell["CSH"] = "csh";
+    Shell["FISH"] = "fish";
+})(Shell || (Shell = {}));
+export const Utils = {
+    getUser() {
+        return os.userInfo().username;
+    },
+    getSystemInfo() {
+        return {
+            os: os.type(),
+            shell: this.getShell(),
+        };
+    },
+    isMacOS() {
+        return os.platform() === 'darwin';
+    },
+    isLinux() {
+        return os.platform() === 'linux';
+    },
+    getShell() {
+        const shell = process.env.SHELL || '';
+        if (shell.endsWith('bash')) {
+            return Shell.BASH;
+        }
+        if (shell.endsWith('zsh')) {
+            return Shell.ZSH;
+        }
+        if (shell.endsWith('sh')) {
+            return Shell.SH;
+        }
+        if (shell.endsWith('csh')) {
+            return Shell.CSH;
+        }
+        if (shell.endsWith('ksh')) {
+            return Shell.KSH;
+        }
+        if (shell.endsWith('fish')) {
+            return Shell.FISH;
+        }
+        return undefined;
+    },
+    getPrimaryShellRc() {
+        return this.getShellRcFiles()[0];
+    },
+    getShellRcFiles() {
+        const shell = process.env.SHELL || '';
+        const homeDir = os.homedir();
+        if (shell.endsWith('bash')) {
+            // Linux typically uses .bashrc, macOS uses .bash_profile
+            if (Utils.isLinux()) {
+                return [
+                    path.join(homeDir, '.bashrc'),
+                    path.join(homeDir, '.bash_profile'),
+                    path.join(homeDir, '.profile'),
+                ];
+            }
+            return [
+                path.join(homeDir, '.bash_profile'),
+                path.join(homeDir, '.bashrc'),
+                path.join(homeDir, '.profile'),
+            ];
+        }
+        if (shell.endsWith('zsh')) {
+            return [
+                path.join(homeDir, '.zshrc'),
+                path.join(homeDir, '.zprofile'),
+                path.join(homeDir, '.zshenv'),
+            ];
+        }
+        if (shell.endsWith('sh')) {
+            return [
+                path.join(homeDir, '.profile'),
+            ];
+        }
+        if (shell.endsWith('ksh')) {
+            return [
+                path.join(homeDir, '.profile'),
+                path.join(homeDir, '.kshrc'),
+            ];
+        }
+        if (shell.endsWith('csh')) {
+            return [
+                path.join(homeDir, '.cshrc'),
+                path.join(homeDir, '.login'),
+                path.join(homeDir, '.logout'),
+            ];
+        }
+        if (shell.endsWith('fish')) {
+            return [
+                path.join(homeDir, '.config/fish/config.fish'),
+            ];
+        }
+        // Default to bash-style files
+        return [
+            path.join(homeDir, '.bashrc'),
+            path.join(homeDir, '.bash_profile'),
+            path.join(homeDir, '.profile'),
+        ];
+    },
+};

package/dist/utils/internal-utils.d.ts

@@ -0,0 +1,18 @@
+import { ResourceConfig, StringIndexedObject } from 'codify-schemas';
+export declare const VerbosityLevel: {
+    level: number;
+    get(): number;
+    set(level: number): void;
+};
+export declare function isDebug(): boolean;
+export declare function splitUserConfig<T extends StringIndexedObject>(config: ResourceConfig & T): {
+    parameters: T;
+    coreParameters: ResourceConfig;
+};
+export declare function setsEqual(set1: Set<unknown>, set2: Set<unknown>): boolean;
+export declare function untildify(pathWithTilde: string): string;
+export declare function tildify(pathWithTilde: string): string;
+export declare function resolvePathWithVariables(pathWithVariables: string): string;
+export declare function addVariablesToPath(pathWithoutVariables: string): string;
+export declare function unhome(pathWithHome: string): string;
+export declare function areArraysEqual(isElementEqual: ((desired: unknown, current: unknown) => boolean) | undefined, desired: unknown, current: unknown): boolean;

package/dist/utils/internal-utils.js

@@ -0,0 +1,86 @@
+import os from 'node:os';
+import path from 'node:path';
+export const VerbosityLevel = new class {
+    level = 0;
+    get() {
+        return this.level;
+    }
+    set(level) {
+        this.level = level;
+    }
+};
+export function isDebug() {
+    return process.env.DEBUG != null && process.env.DEBUG.includes('codify'); // TODO: replace with debug library
+}
+export function splitUserConfig(config) {
+    const coreParameters = {
+        type: config.type,
+        ...(config.name ? { name: config.name } : {}),
+        ...(config.dependsOn ? { dependsOn: config.dependsOn } : {}),
+    };
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { type, name, dependsOn, ...parameters } = config;
+    return {
+        parameters: parameters,
+        coreParameters,
+    };
+}
+export function setsEqual(set1, set2) {
+    return set1.size === set2.size && [...set1].every((v) => set2.has(v));
+}
+const homeDirectory = os.homedir();
+export function untildify(pathWithTilde) {
+    return homeDirectory ? pathWithTilde.replace(/^~(?=$|\/|\\)/, homeDirectory) : pathWithTilde;
+}
+export function tildify(pathWithTilde) {
+    return homeDirectory ? pathWithTilde.replace(homeDirectory, '~') : pathWithTilde;
+}
+export function resolvePathWithVariables(pathWithVariables) {
+    // @ts-expect-error Ignore this for now
+    return pathWithVariables.replace(/\$([A-Z_]+[A-Z0-9_]*)|\${([A-Z0-9_]*)}/ig, (_, a, b) => process.env[a || b]);
+}
+export function addVariablesToPath(pathWithoutVariables) {
+    let result = pathWithoutVariables;
+    for (const [key, value] of Object.entries(process.env)) {
+        if (!value || !path.isAbsolute(value) || value === '/' || key === 'HOME' || key === 'PATH' || key === 'SHELL' || key === 'PWD') {
+            continue;
+        }
+        result = result.replaceAll(value, `$${key}`);
+    }
+    return result;
+}
+export function unhome(pathWithHome) {
+    return pathWithHome.includes('$HOME') ? pathWithHome.replaceAll('$HOME', os.homedir()) : pathWithHome;
+}
+export function areArraysEqual(isElementEqual, desired, current) {
+    if (!desired || !current) {
+        return false;
+    }
+    if (!Array.isArray(desired) || !Array.isArray(current)) {
+        throw new Error(`A non-array value:
+          
+Desired: ${JSON.stringify(desired, null, 2)}
+
+Current: ${JSON.stringify(desired, null, 2)}
+
+Was provided even though type array was specified.
+`);
+    }
+    if (desired.length !== current.length) {
+        return false;
+    }
+    const desiredCopy = [...desired];
+    const currentCopy = [...current];
+    // Algorithm for to check equality between two un-ordered; un-hashable arrays using
+    // an isElementEqual method. Time: O(n^2)
+    for (let counter = desiredCopy.length - 1; counter >= 0; counter--) {
+        const idx = currentCopy.findIndex((e2) => (isElementEqual
+            ?? ((a, b) => a === b))(desiredCopy[counter], e2));
+        if (idx === -1) {
+            return false;
+        }
+        desiredCopy.splice(counter, 1);
+        currentCopy.splice(idx, 1);
+    }
+    return currentCopy.length === 0;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codify-plugin-lib",
-  "version": "1.0.181",
+  "version": "1.0.182-beta1",
   "description": "Library plugin library",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -22,7 +22,7 @@
     "ajv": "^8.12.0",
     "ajv-formats": "^2.1.1",
     "clean-deep": "^3.4.0",
-    "codify-schemas": "1.0.83",
+    "codify-schemas": "1.0.86",
     "lodash.isequal": "^4.5.0",
     "nanoid": "^5.0.9",
     "strip-ansi": "^7.1.0",

package/src/index.ts

@@ -12,7 +12,7 @@ export * from './resource/parsed-resource-settings.js';
 export * from './resource/resource.js'
 export * from './resource/resource-settings.js'
 export * from './stateful-parameter/stateful-parameter.js'
-export * from './utils/utils.js'
+export * from './utils/index.js'
 
 export async function runPlugin(plugin: Plugin) {
   const messageHandler = new MessageHandler(plugin);

package/src/plan/plan.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import { Plan } from './plan.js';
-import { ParameterOperation, ResourceOperation } from 'codify-schemas';
+import { OS, ParameterOperation, ResourceOperation } from 'codify-schemas';
 import { TestConfig, TestResource } from '../utils/test-utils.test.js';
 import { ResourceController } from '../resource/resource-controller.js';
 import { ParsedResourceSettings } from '../resource/parsed-resource-settings.js';
@@ -152,6 +152,7 @@ describe('Plan entity tests', () => {
       getSettings(): ResourceSettings<any> {
         return {
           id: 'type',
+          operatingSystems: [OS.Darwin],
           parameterSettings: {
             propZ: { type: 'array', isElementEqual: (a, b) => b.includes(a) }
           }
@@ -184,6 +185,7 @@ describe('Plan entity tests', () => {
       getSettings(): ResourceSettings<any> {
         return {
           id: 'type',
+          operatingSystems: [OS.Darwin],
           parameterSettings: {
             propZ: {
               type: 'array',
@@ -236,6 +238,7 @@ describe('Plan entity tests', () => {
       getSettings(): ResourceSettings<TestConfig> {
         return {
           id: 'type',
+          operatingSystems: [OS.Darwin],
           parameterSettings: {
             propA: { type: 'string' },
             propB: { type: 'string', canModify: true },
@@ -289,6 +292,7 @@ describe('Plan entity tests', () => {
       getSettings(): ResourceSettings<TestConfig> {
         return {
           id: 'type',
+          operatingSystems: [OS.Darwin],
           parameterSettings: {
             propA: { type: 'string' },
             propB: { type: 'string', canModify: true },
@@ -351,6 +355,7 @@ function createTestResource() {
     getSettings(): ResourceSettings<TestConfig> {
       return {
         id: 'type',
+        operatingSystems: [OS.Darwin],
         parameterSettings: {
           propA: {
             default: 'defaultA'