@codifycli/plugin-core 1.0.0-beta1

package/dist/plugin/plugin.js

@@ -0,0 +1,200 @@
+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 { ptyLocalStorage } from '../utils/pty-local-storage.js';
+import { VerbosityLevel } from '../utils/verbosity-level.js';
+export class Plugin {
+    name;
+    resourceControllers;
+    planStorage;
+    planPty = new BackgroundPty();
+    constructor(name, resourceControllers) {
+        this.name = name;
+        this.resourceControllers = resourceControllers;
+        this.planStorage = new Map();
+    }
+    static create(name, resources) {
+        const controllers = resources
+            .map((resource) => new ResourceController(resource));
+        const controllersMap = new Map(controllers.map((r) => [r.typeId, r]));
+        return new Plugin(name, controllersMap);
+    }
+    async initialize(data) {
+        if (data.verbosityLevel) {
+            VerbosityLevel.set(data.verbosityLevel);
+        }
+        for (const controller of this.resourceControllers.values()) {
+            await controller.initialize();
+        }
+        return {
+            resourceDefinitions: [...this.resourceControllers.values()]
+                .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,
+                    operatingSystems: r.settings.operatingSystems,
+                    linuxDistros: r.settings.linuxDistros,
+                };
+            })
+        };
+    }
+    getResourceInfo(data) {
+        if (!this.resourceControllers.has(data.type)) {
+            throw new Error(`Cannot get info for resource ${data.type}, resource doesn't exist`);
+        }
+        const resource = this.resourceControllers.get(data.type);
+        const schema = resource.parsedSettings.schema;
+        const requiredPropertyNames = (resource.settings.importAndDestroy?.requiredParameters
+            ?? (typeof resource.settings.allowMultiple === 'object' ? resource.settings.allowMultiple.identifyingParameters : null)
+            ?? schema?.required
+            ?? undefined);
+        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,
+            dependencies: resource.dependencies,
+            schema: schema,
+            importAndDestroy: {
+                preventImport: resource.settings.importAndDestroy?.preventImport,
+                requiredParameters: requiredPropertyNames,
+            },
+            import: {
+                requiredParameters: requiredPropertyNames,
+            },
+            operatingSystems: resource.settings.operatingSystems,
+            linuxDistros: resource.settings.linuxDistros,
+            sensitiveParameters,
+            allowMultiple
+        };
+    }
+    async match(data) {
+        const { resource: resourceConfig, array } = data;
+        const resource = this.resourceControllers.get(resourceConfig.core.type);
+        if (!resource) {
+            throw new Error(`Resource of type ${resourceConfig.core.type} could not be found for match`);
+        }
+        const match = await resource.match(resourceConfig, array);
+        return { match };
+    }
+    async import(data) {
+        const { core, parameters, autoSearchAll } = data;
+        if (!this.resourceControllers.has(core.type)) {
+            throw new Error(`Cannot get info for resource ${core.type}, resource doesn't exist`);
+        }
+        const result = await ptyLocalStorage.run(this.planPty, () => this.resourceControllers
+            .get(core.type)
+            ?.import(core, parameters, autoSearchAll));
+        return {
+            request: data,
+            result: result ?? [],
+        };
+    }
+    async validate(data) {
+        const validationResults = [];
+        for (const config of data.configs) {
+            const { core, parameters } = config;
+            if (!this.resourceControllers.has(core.type)) {
+                throw new Error(`Resource type not found: ${core.type}`);
+            }
+            const validation = await this.resourceControllers
+                .get(core.type)
+                .validate(core, parameters);
+            validationResults.push(validation);
+        }
+        // Validate that if allow multiple is false, then only 1 of each resource exists
+        const countMap = data.configs.reduce((map, resource) => {
+            if (!map.has(resource.core.type)) {
+                map.set(resource.core.type, 0);
+            }
+            const count = map.get(resource.core.type);
+            map.set(resource.core.type, count + 1);
+            return map;
+        }, new Map());
+        const invalidMultipleConfigs = [...countMap.entries()].filter(([k, v]) => {
+            const controller = this.resourceControllers.get(k);
+            return !controller.parsedSettings.allowMultiple && v > 1;
+        });
+        if (invalidMultipleConfigs.length > 0) {
+            throw new Error(`Multiples of the following configs were found but only 1 is allowed. [${invalidMultipleConfigs.map(([k, v]) => `${v}x ${k}`).join(', ')}] found.`);
+        }
+        await this.crossValidateResources(data.configs);
+        return {
+            resourceValidations: validationResults
+        };
+    }
+    async plan(data) {
+        const { type } = data.core;
+        if (!this.resourceControllers.has(type)) {
+            throw new Error(`Resource type not found: ${type}`);
+        }
+        const plan = await ptyLocalStorage.run(this.planPty, async () => this.resourceControllers.get(type).plan(data.core, data.desired ?? null, data.state ?? null, data.isStateful));
+        this.planStorage.set(plan.id, plan);
+        return plan.toResponse();
+    }
+    async apply(data) {
+        if (!data.planId && !data.plan) {
+            throw new Error('For applies either plan or planId must be supplied');
+        }
+        const plan = this.resolvePlan(data);
+        const resource = this.resourceControllers.get(plan.getResourceType());
+        if (!resource) {
+            throw new Error('Malformed plan with resource that cannot be found');
+        }
+        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 () => {
+            const result = await resource.plan(plan.coreParameters, plan.desiredConfig, plan.desiredConfig ?? plan.currentConfig, plan.isStateful, 'validationPlan');
+            await getPty().kill();
+            return result;
+        });
+        if (validationPlan.requiresChanges()) {
+            throw new ApplyValidationError(plan);
+        }
+    }
+    async setVerbosityLevel(data) {
+        VerbosityLevel.set(data.verbosityLevel);
+    }
+    async kill() {
+        await this.planPty.kill();
+    }
+    resolvePlan(data) {
+        const { plan: planRequest, planId } = data;
+        if (planId) {
+            if (!this.planStorage.has(planId)) {
+                throw new Error(`Plan with id: ${planId} was not found`);
+            }
+            return this.planStorage.get(planId);
+        }
+        if (!planRequest?.resourceType || !this.resourceControllers.has(planRequest.resourceType)) {
+            throw new Error('Malformed plan. Resource type must be supplied or resource type was not found');
+        }
+        const resource = this.resourceControllers.get(planRequest.resourceType);
+        return Plan.fromResponse(planRequest, resource.parsedSettings.defaultValues);
+    }
+    async crossValidateResources(resources) {
+    }
+}

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

@@ -0,0 +1,21 @@
+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 BackgroundPty implements IPty {
+    private historyIgnore;
+    private basePty;
+    private promiseQueue;
+    constructor();
+    spawn(cmd: string | string[], options?: SpawnOptions): Promise<SpawnResult>;
+    spawnSafe(cmd: string | string[], options?: SpawnOptions): Promise<SpawnResult>;
+    kill(): Promise<{
+        exitCode: number;
+        signal?: number | undefined;
+    }>;
+    private initialize;
+    private getDefaultShell;
+}

package/dist/pty/background-pty.js

@@ -0,0 +1,127 @@
+import pty from '@homebridge/node-pty-prebuilt-multiarch';
+import { nanoid } from 'nanoid';
+import * as cp from 'node:child_process';
+import { EventEmitter } from 'node:events';
+import * as fs from 'node:fs/promises';
+import stripAnsi from 'strip-ansi';
+import { debugLog } from '../utils/debug.js';
+import { Shell, Utils } from '../utils/index.js';
+import { VerbosityLevel } from '../utils/verbosity-level.js';
+import { SpawnError } from './index.js';
+import { PromiseQueue } from './promise-queue.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 BackgroundPty {
+    historyIgnore = Utils.getShell() === Shell.ZSH ? { HISTORY_IGNORE: '*' } : { HISTIGNORE: '*' };
+    basePty = pty.spawn(this.getDefaultShell(), ['-i'], {
+        env: { ...process.env, ...this.historyIgnore },
+        cols: 10_000, // Set to a really large value to prevent wrapping
+        name: nanoid(6),
+        handleFlowControl: true
+    });
+    promiseQueue = new PromiseQueue();
+    constructor() {
+        this.initialize();
+    }
+    async spawn(cmd, options) {
+        const spawnResult = await this.spawnSafe(cmd, options);
+        if (spawnResult.status !== 'success') {
+            throw new SpawnError(Array.isArray(cmd) ? cmd.join(' ') : cmd, spawnResult.exitCode, spawnResult.data);
+        }
+        return spawnResult;
+    }
+    async spawnSafe(cmd, options) {
+        cmd = Array.isArray(cmd) ? cmd.join('\\\n') : cmd;
+        // cid is command id
+        const cid = nanoid(10);
+        debugLog(cid);
+        await new Promise((resolve) => {
+            // 600 permissions means only the current user will be able to rw from the FIFO
+            // Create in /tmp so it could be automatically cleaned up if the clean-up was missed
+            const mkfifoSpawn = cp.spawn('mkfifo', ['-m', '600', `/tmp/${cid}`]);
+            mkfifoSpawn.on('close', () => {
+                resolve(null);
+            });
+        });
+        return new Promise((resolve) => {
+            const cat = cp.spawn('cat', [`/tmp/${cid}`]);
+            let output = '';
+            cat.stdout.on('data', (data) => {
+                output += data.toString();
+                if (output.includes('%%%done%%%"')) {
+                    const truncOutput = output.replace('%%%done%%%"\n', '');
+                    const [data, exit] = truncOutput.split('%%%');
+                    // Clean up trailing \n newline if it exists
+                    let strippedData = stripAnsi(data);
+                    if (strippedData.endsWith('\n')) {
+                        strippedData = strippedData.slice(0, -1);
+                    }
+                    resolve({
+                        status: Number.parseInt(exit ?? 1, 10) === 0 ? 'success' : 'error',
+                        exitCode: Number.parseInt(exit ?? 1, 10),
+                        data: strippedData,
+                    });
+                }
+                else {
+                    // Print to stdout if the verbosity level is above 0
+                    if (VerbosityLevel.get() > 0) {
+                        process.stdout.write(data);
+                    }
+                }
+            });
+            this.promiseQueue.run(async () => new Promise((resolve) => {
+                const cdCommand = options?.cwd ? `cd ${options.cwd}; ` : '';
+                // Redirecting everything to the pipe and running in theb background avoids most if not all back-pressure problems
+                // Done is used to denote the end of the command
+                // Use the \\" at the end differentiate between command and response. \\" will evaluate to " in the terminal
+                const command = ` ((${cdCommand}${cmd}; echo %%%$?%%%done%%%\\") > "/tmp/${cid}" 2>&1 &); echo %%%done%%%${cid}\\";`;
+                let output = '';
+                const listener = this.basePty.onData((data) => {
+                    output += data;
+                    if (output.includes(`%%%done%%%${cid}"`)) {
+                        listener.dispose();
+                        resolve(null);
+                    }
+                });
+                console.log(`Running command: ${cmd}${options?.cwd ? ` (cwd: ${options.cwd})` : ''}`);
+                this.basePty.write(`${command}\r`);
+            }));
+        }).finally(async () => {
+            await fs.rm(`/tmp/${cid}`);
+        });
+    }
+    async kill() {
+        return new Promise((resolve) => {
+            this.basePty.onExit((status) => {
+                resolve(status);
+            });
+            this.basePty.kill('SIGKILL');
+        });
+    }
+    async initialize() {
+        // this.basePty.onData((data: string) => process.stdout.write(data));
+        await this.promiseQueue.run(async () => {
+            let outputBuffer = '';
+            return new Promise(resolve => {
+                this.basePty.write(' unset PS1;\n');
+                this.basePty.write(' unset PS0;\n');
+                this.basePty.write(' echo setup complete\\"\n');
+                const listener = this.basePty.onData((data) => {
+                    outputBuffer += data;
+                    if (outputBuffer.includes('setup complete"')) {
+                        listener.dispose();
+                        resolve(null);
+                    }
+                });
+            });
+        });
+    }
+    getDefaultShell() {
+        return process.env.SHELL;
+    }
+}

package/dist/pty/index.d.ts

@@ -0,0 +1,50 @@
+export interface SpawnResult {
+    status: 'error' | 'success';
+    exitCode: number;
+    data: string;
+}
+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.
+ *
+ * @property {boolean} [disableWrapping] - Forces the terminal width to 10_000 to disable wrapping.
+ * In applys, this is off by default while it is on during plans.
+ */
+export interface SpawnOptions {
+    cwd?: string;
+    env?: Record<string, unknown>;
+    interactive?: boolean;
+    requiresRoot?: boolean;
+    stdin?: boolean;
+    disableWrapping?: boolean;
+}
+export declare class SpawnError extends Error {
+    data: string;
+    cmd: string;
+    exitCode: number;
+    constructor(cmd: string, exitCode: number, data: string);
+}
+export interface IPty {
+    spawn(cmd: string | string[], options?: SpawnOptions): Promise<SpawnResult>;
+    spawnSafe(cmd: string | string[], options?: SpawnOptions): Promise<SpawnResult>;
+    kill(): Promise<{
+        exitCode: number;
+        signal?: number | undefined;
+    }>;
+}
+export declare function getPty(): IPty;

package/dist/pty/index.js

@@ -0,0 +1,20 @@
+import { ptyLocalStorage } from '../utils/pty-local-storage.js';
+export var SpawnStatus;
+(function (SpawnStatus) {
+    SpawnStatus["SUCCESS"] = "success";
+    SpawnStatus["ERROR"] = "error";
+})(SpawnStatus || (SpawnStatus = {}));
+export class SpawnError extends Error {
+    data;
+    cmd;
+    exitCode;
+    constructor(cmd, exitCode, data) {
+        super(`Spawn Error: on command "${cmd}" with exit code: ${exitCode}\nOutput:\n${data}`);
+        this.data = data;
+        this.cmd = cmd;
+        this.exitCode = exitCode;
+    }
+}
+export function getPty() {
+    return ptyLocalStorage.getStore();
+}

package/dist/pty/promise-queue.d.ts

@@ -0,0 +1,5 @@
+export declare class PromiseQueue {
+    private queue;
+    private eventBus;
+    run<T>(fn: () => Promise<T> | T): Promise<T>;
+}

package/dist/pty/promise-queue.js

@@ -0,0 +1,26 @@
+import { nanoid } from 'nanoid';
+import EventEmitter from 'node:events';
+export class PromiseQueue {
+    // Cid stands for command id;
+    queue = [];
+    eventBus = new EventEmitter();
+    async run(fn) {
+        const cid = nanoid();
+        this.queue.push({ cid, fn });
+        if (this.queue.length !== 1) {
+            await new Promise((resolve) => {
+                const listener = () => {
+                    if (this.queue[0].cid === cid) {
+                        this.eventBus.removeListener('dequeue', listener);
+                        resolve(null);
+                    }
+                };
+                this.eventBus.on('dequeue', listener);
+            });
+        }
+        const result = await fn();
+        this.queue.shift();
+        this.eventBus.emit('dequeue');
+        return result;
+    }
+}

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

@@ -0,0 +1,17 @@
+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 | string[], options?: SpawnOptions): Promise<SpawnResult>;
+    spawnSafe(cmd: string | string[], options?: SpawnOptions): Promise<SpawnResult>;
+    kill(): Promise<{
+        exitCode: number;
+        signal?: number | undefined;
+    }>;
+    externalSpawn(cmd: string, opts: SpawnOptions): Promise<SpawnResult>;
+    private getDefaultShell;
+}

package/dist/pty/seqeuntial-pty.js

@@ -0,0 +1,119 @@
+import pty from '@homebridge/node-pty-prebuilt-multiarch';
+import { Ajv } from 'ajv';
+import { CommandRequestResponseDataSchema, MessageCmd } from 'codify-schemas';
+import { nanoid } from 'nanoid';
+import { EventEmitter } from 'node:events';
+import stripAnsi from 'strip-ansi';
+import { Shell, Utils } from '../utils/index.js';
+import { VerbosityLevel } from '../utils/verbosity-level.js';
+import { SpawnError, SpawnStatus } from './index.js';
+EventEmitter.defaultMaxListeners = 1000;
+const ajv = new Ajv({
+    strict: true,
+});
+const validateSudoRequestResponse = ajv.compile(CommandRequestResponseDataSchema);
+/**
+ * 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(Array.isArray(cmd) ? cmd.join('\n') : cmd, spawnResult.exitCode, spawnResult.data);
+        }
+        return spawnResult;
+    }
+    async spawnSafe(cmd, options) {
+        cmd = Array.isArray(cmd) ? cmd.join(' ') : cmd;
+        if (cmd.includes('sudo')) {
+            throw new Error('Do not directly use sudo. Use the option { requiresRoot: true } instead');
+        }
+        // If sudo is required, we must delegate to the main codify process.
+        if (options?.stdin || options?.requiresRoot) {
+            return this.externalSpawn(cmd, options);
+        }
+        console.log(`Running command: ${Array.isArray(cmd) ? cmd.join('\\\n') : 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
+            // Set to a really large value to prevent wrapping
+            const initialCols = options?.disableWrapping ? 10_000 : process.stdout.columns ?? 80;
+            const initialRows = process.stdout.rows ?? 24;
+            const args = options?.interactive ? ['-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 resizeListener = () => {
+                const { columns, rows } = process.stdout;
+                mPty.resize(columns, options?.disableWrapping ? 10_000 : rows);
+            };
+            // Listen to resize events for the terminal window;
+            process.stdout.on('resize', resizeListener);
+            mPty.onExit((result) => {
+                process.stdout.off('resize', resizeListener);
+                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,
+        };
+    }
+    // For safety reasons, requests that require sudo or are interactive must be run via the main client
+    async externalSpawn(cmd, opts) {
+        return new Promise((resolve) => {
+            const requestId = nanoid(8);
+            const listener = (data) => {
+                if (data.requestId === requestId) {
+                    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.COMMAND_REQUEST,
+                data: {
+                    command: cmd,
+                    options: opts ?? {},
+                },
+                requestId
+            });
+        });
+    }
+    getDefaultShell() {
+        return process.env.SHELL;
+    }
+}

package/dist/pty/vitest.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vite").UserConfig;
+export default _default;

package/dist/pty/vitest.config.js

@@ -0,0 +1,11 @@
+import { defaultExclude, defineConfig } from 'vitest/config';
+export default defineConfig({
+    test: {
+        pool: 'forks',
+        fileParallelism: false,
+        exclude: [
+            ...defaultExclude,
+            './src/utils/test-utils.test.ts',
+        ]
+    },
+});

package/dist/resource/config-parser.d.ts

@@ -0,0 +1,11 @@
+import { StringIndexedObject } from 'codify-schemas';
+import { StatefulParameterController } from '../stateful-parameter/stateful-parameter-controller.js';
+export declare class ConfigParser<T extends StringIndexedObject> {
+    private readonly desiredConfig;
+    private readonly stateConfig;
+    private statefulParametersMap;
+    constructor(desiredConfig: Partial<T> | null, stateConfig: Partial<T> | null, statefulParameters: Map<keyof T, StatefulParameterController<T, T[keyof T]>>);
+    get allParameters(): Partial<T>;
+    get allNonStatefulParameters(): Partial<T>;
+    get allStatefulParameters(): Partial<T>;
+}

package/dist/resource/config-parser.js

@@ -0,0 +1,21 @@
+export class ConfigParser {
+    desiredConfig;
+    stateConfig;
+    statefulParametersMap;
+    constructor(desiredConfig, stateConfig, statefulParameters) {
+        this.desiredConfig = desiredConfig;
+        this.stateConfig = stateConfig;
+        this.statefulParametersMap = statefulParameters;
+    }
+    get allParameters() {
+        return { ...this.desiredConfig, ...this.stateConfig };
+    }
+    get allNonStatefulParameters() {
+        const { allParameters, statefulParametersMap, } = this;
+        return Object.fromEntries(Object.entries(allParameters).filter(([key]) => !statefulParametersMap.has(key)));
+    }
+    get allStatefulParameters() {
+        const { allParameters, statefulParametersMap } = this;
+        return Object.fromEntries(Object.entries(allParameters).filter(([key]) => statefulParametersMap.has(key)));
+    }
+}