@codifycli/plugin-core 1.0.0-beta1

package/dist/entities/resource.js

@@ -0,0 +1,303 @@
+import { Ajv } from 'ajv';
+import { ParameterOperation, ResourceOperation, } from 'codify-schemas';
+import { setsEqual, splitUserConfig } from '../utils/utils.js';
+import { Plan } from './plan.js';
+import { ResourceOptionsParser } from './resource-options.js';
+export class Resource {
+    typeId;
+    statefulParameters;
+    transformParameters;
+    resourceParameters;
+    statefulParameterOrder;
+    transformParameterOrder;
+    dependencies;
+    parameterOptions;
+    options;
+    defaultValues;
+    ajv;
+    schemaValidator;
+    constructor(options) {
+        this.typeId = options.type;
+        this.dependencies = options.dependencies ?? [];
+        this.options = options;
+        if (this.options.schema) {
+            this.ajv = new Ajv({
+                allErrors: true,
+                strict: true,
+                strictRequired: false,
+            });
+            this.schemaValidator = this.ajv.compile(this.options.schema);
+        }
+        const parser = new ResourceOptionsParser(options);
+        this.statefulParameters = parser.statefulParameters;
+        this.transformParameters = parser.transformParameters;
+        this.resourceParameters = parser.resourceParameters;
+        this.parameterOptions = parser.changeSetParameterOptions;
+        this.defaultValues = parser.defaultValues;
+        this.statefulParameterOrder = parser.statefulParameterOrder;
+        this.transformParameterOrder = parser.transformParameterOrder;
+    }
+    async onInitialize() { }
+    async validate(parameters, resourceMetaData) {
+        if (this.schemaValidator) {
+            const isValid = this.schemaValidator(parameters);
+            if (!isValid) {
+                return {
+                    isValid: false,
+                    resourceName: resourceMetaData.name,
+                    resourceType: resourceMetaData.type,
+                    schemaValidationErrors: this.schemaValidator?.errors ?? [],
+                };
+            }
+        }
+        let isValid = true;
+        let customValidationErrorMessage;
+        try {
+            await this.customValidation(parameters);
+        }
+        catch (error) {
+            isValid = false;
+            customValidationErrorMessage = error.message;
+        }
+        if (!isValid) {
+            return {
+                customValidationErrorMessage,
+                isValid: false,
+                resourceName: resourceMetaData.name,
+                resourceType: resourceMetaData.type,
+                schemaValidationErrors: this.schemaValidator?.errors ?? [],
+            };
+        }
+        return {
+            isValid: true,
+            resourceName: resourceMetaData.name,
+            resourceType: resourceMetaData.type,
+            schemaValidationErrors: [],
+        };
+    }
+    async plan(desiredConfig, currentConfig = null, statefulMode = false) {
+        this.validatePlanInputs(desiredConfig, currentConfig, statefulMode);
+        const planOptions = {
+            parameterOptions: this.parameterOptions,
+            statefulMode,
+        };
+        this.addDefaultValues(desiredConfig);
+        await this.applyTransformParameters(desiredConfig);
+        const parsedConfig = new ConfigParser(desiredConfig, currentConfig, this.statefulParameters, this.transformParameters);
+        const { desiredParameters, nonStatefulParameters, resourceMetadata, statefulParameters, } = parsedConfig;
+        const currentParameters = await this.refreshNonStatefulParameters(nonStatefulParameters);
+        if (currentParameters === null || currentParameters === undefined) {
+            return Plan.create(desiredParameters, null, resourceMetadata, planOptions);
+        }
+        const statefulCurrentParameters = await this.refreshStatefulParameters(statefulParameters, planOptions.statefulMode);
+        return Plan.create(desiredParameters, { ...currentParameters, ...statefulCurrentParameters }, resourceMetadata, planOptions);
+    }
+    async apply(plan) {
+        if (plan.getResourceType() !== this.typeId) {
+            throw new Error(`Internal error: Plan set to wrong resource during apply. Expected ${this.typeId} but got: ${plan.getResourceType()}`);
+        }
+        switch (plan.changeSet.operation) {
+            case ResourceOperation.CREATE: {
+                return this._applyCreate(plan);
+            }
+            case ResourceOperation.MODIFY: {
+                return this._applyModify(plan);
+            }
+            case ResourceOperation.RECREATE: {
+                await this._applyDestroy(plan);
+                return this._applyCreate(plan);
+            }
+            case ResourceOperation.DESTROY: {
+                return this._applyDestroy(plan);
+            }
+        }
+    }
+    async _applyCreate(plan) {
+        await this.applyCreate(plan);
+        const statefulParameterChanges = plan.changeSet.parameterChanges
+            .filter((pc) => this.statefulParameters.has(pc.name))
+            .sort((a, b) => this.statefulParameterOrder.get(a.name) - this.statefulParameterOrder.get(b.name));
+        for (const parameterChange of statefulParameterChanges) {
+            const statefulParameter = this.statefulParameters.get(parameterChange.name);
+            await statefulParameter.applyAdd(parameterChange.newValue, plan);
+        }
+    }
+    async _applyModify(plan) {
+        const parameterChanges = plan
+            .changeSet
+            .parameterChanges
+            .filter((c) => c.operation !== ParameterOperation.NOOP);
+        const statelessParameterChanges = parameterChanges
+            .filter((pc) => !this.statefulParameters.has(pc.name));
+        for (const pc of statelessParameterChanges) {
+            await this.applyModify(pc, plan);
+        }
+        const statefulParameterChanges = parameterChanges
+            .filter((pc) => this.statefulParameters.has(pc.name))
+            .sort((a, b) => this.statefulParameterOrder.get(a.name) - this.statefulParameterOrder.get(b.name));
+        for (const parameterChange of statefulParameterChanges) {
+            const statefulParameter = this.statefulParameters.get(parameterChange.name);
+            switch (parameterChange.operation) {
+                case ParameterOperation.ADD: {
+                    await statefulParameter.applyAdd(parameterChange.newValue, plan);
+                    break;
+                }
+                case ParameterOperation.MODIFY: {
+                    await statefulParameter.applyModify(parameterChange.newValue, parameterChange.previousValue, false, plan);
+                    break;
+                }
+                case ParameterOperation.REMOVE: {
+                    await statefulParameter.applyRemove(parameterChange.previousValue, plan);
+                    break;
+                }
+            }
+        }
+    }
+    async _applyDestroy(plan) {
+        if (this.options.callStatefulParameterRemoveOnDestroy) {
+            const statefulParameterChanges = plan.changeSet.parameterChanges
+                .filter((pc) => this.statefulParameters.has(pc.name))
+                .sort((a, b) => this.statefulParameterOrder.get(a.name) - this.statefulParameterOrder.get(b.name));
+            for (const parameterChange of statefulParameterChanges) {
+                const statefulParameter = this.statefulParameters.get(parameterChange.name);
+                await statefulParameter.applyRemove(parameterChange.previousValue, plan);
+            }
+        }
+        await this.applyDestroy(plan);
+    }
+    validateRefreshResults(refresh, desired) {
+        if (!refresh) {
+            return;
+        }
+        const desiredKeys = new Set(Object.keys(refresh));
+        const refreshKeys = new Set(Object.keys(refresh));
+        if (!setsEqual(desiredKeys, refreshKeys)) {
+            throw new Error(`Resource ${this.typeId}
+refresh() must return back exactly the keys that were provided
+Missing: ${[...desiredKeys].filter((k) => !refreshKeys.has(k))};
+Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`);
+        }
+    }
+    async applyTransformParameters(desired) {
+        if (!desired) {
+            return;
+        }
+        const transformParameters = [...this.transformParameters.entries()]
+            .sort(([keyA], [keyB]) => this.transformParameterOrder.get(keyA) - this.transformParameterOrder.get(keyB));
+        for (const [key, transformParameter] of transformParameters) {
+            if (desired[key] === undefined) {
+                continue;
+            }
+            const transformedValue = await transformParameter.transform(desired[key]);
+            if (Object.keys(transformedValue).some((k) => desired[k] !== undefined)) {
+                throw new Error(`Transform parameter ${key} is attempting to override existing values ${JSON.stringify(transformedValue, null, 2)}`);
+            }
+            delete desired[key];
+            for (const [tvKey, tvValue] of Object.entries(transformedValue)) {
+                desired[tvKey] = tvValue;
+            }
+        }
+    }
+    addDefaultValues(desired) {
+        if (!desired) {
+            return;
+        }
+        for (const [key, defaultValue] of Object.entries(this.defaultValues)) {
+            if (defaultValue !== undefined && desired[key] === undefined) {
+                desired[key] = defaultValue;
+            }
+        }
+    }
+    async refreshNonStatefulParameters(resourceParameters) {
+        const currentParameters = await this.refresh(resourceParameters);
+        this.validateRefreshResults(currentParameters, resourceParameters);
+        return currentParameters;
+    }
+    async refreshStatefulParameters(statefulParametersConfig, isStatefulMode) {
+        const currentParameters = {};
+        const sortedEntries = Object.entries(statefulParametersConfig)
+            .sort(([key1], [key2]) => this.statefulParameterOrder.get(key1) - this.statefulParameterOrder.get(key2));
+        for (const [key, desiredValue] of sortedEntries) {
+            const statefulParameter = this.statefulParameters.get(key);
+            if (!statefulParameter) {
+                throw new Error(`Stateful parameter ${key} was not found`);
+            }
+            let currentValue = await statefulParameter.refresh(desiredValue ?? null);
+            if (Array.isArray(currentValue)
+                && Array.isArray(desiredValue)
+                && !isStatefulMode
+                && !statefulParameter.options.disableStatelessModeArrayFiltering) {
+                currentValue = currentValue.filter((c) => desiredValue?.some((d) => {
+                    const parameterOptions = statefulParameter.options;
+                    if (parameterOptions && parameterOptions.isElementEqual) {
+                        return parameterOptions.isElementEqual(d, c);
+                    }
+                    return d === c;
+                }));
+            }
+            currentParameters[key] = currentValue;
+        }
+        return currentParameters;
+    }
+    validatePlanInputs(desired, current, statefulMode) {
+        if (!desired && !current) {
+            throw new Error('Desired config and current config cannot both be missing');
+        }
+        if (!statefulMode && !desired) {
+            throw new Error('Desired config must be provided in non-stateful mode');
+        }
+    }
+    async customValidation(parameters) { }
+    ;
+    async applyModify(pc, plan) { }
+    ;
+}
+class ConfigParser {
+    desiredConfig;
+    currentConfig;
+    statefulParametersMap;
+    transformParametersMap;
+    constructor(desiredConfig, currentConfig, statefulParameters, transformParameters) {
+        this.desiredConfig = desiredConfig;
+        this.currentConfig = currentConfig;
+        this.statefulParametersMap = statefulParameters;
+        this.transformParametersMap = transformParameters;
+    }
+    get resourceMetadata() {
+        const desiredMetadata = this.desiredConfig ? splitUserConfig(this.desiredConfig).resourceMetadata : undefined;
+        const currentMetadata = this.currentConfig ? splitUserConfig(this.currentConfig).resourceMetadata : undefined;
+        if (!desiredMetadata && !currentMetadata) {
+            throw new Error(`Unable to parse resource metadata from ${this.desiredConfig}, ${this.currentConfig}`);
+        }
+        if (currentMetadata && desiredMetadata && (Object.keys(desiredMetadata).length !== Object.keys(currentMetadata).length
+            || Object.entries(desiredMetadata).some(([key, value]) => currentMetadata[key] !== value))) {
+            throw new Error(`The metadata for the current config does not match the desired config. 
+Desired metadata:
+${JSON.stringify(desiredMetadata, null, 2)}
+
+Current metadata:
+${JSON.stringify(currentMetadata, null, 2)}`);
+        }
+        return desiredMetadata ?? currentMetadata;
+    }
+    get desiredParameters() {
+        if (!this.desiredConfig) {
+            return null;
+        }
+        const { parameters } = splitUserConfig(this.desiredConfig);
+        return parameters;
+    }
+    get parameters() {
+        const desiredParameters = this.desiredConfig ? splitUserConfig(this.desiredConfig).parameters : undefined;
+        const currentParameters = this.currentConfig ? splitUserConfig(this.currentConfig).parameters : undefined;
+        return { ...desiredParameters, ...currentParameters };
+    }
+    get nonStatefulParameters() {
+        const { parameters } = this;
+        return Object.fromEntries(Object.entries(parameters).filter(([key]) => !(this.statefulParametersMap.has(key) || this.transformParametersMap.has(key))));
+    }
+    get statefulParameters() {
+        const { parameters } = this;
+        return Object.fromEntries(Object.entries(parameters).filter(([key]) => this.statefulParametersMap.has(key)));
+    }
+}

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

@@ -0,0 +1,29 @@
+import { Plan } from './plan.js';
+import { StringIndexedObject } from 'codify-schemas';
+export interface StatefulParameterOptions<V> {
+    isEqual?: (desired: any, current: any) => boolean;
+    disableStatelessModeArrayFiltering?: boolean;
+    default?: V;
+}
+export interface ArrayStatefulParameterOptions<V> extends StatefulParameterOptions<V> {
+    isEqual?: (desired: any[], current: any[]) => boolean;
+    isElementEqual?: (desired: any, current: any) => boolean;
+}
+export declare abstract class StatefulParameter<T extends StringIndexedObject, V extends T[keyof T]> {
+    readonly options: StatefulParameterOptions<V>;
+    constructor(options?: StatefulParameterOptions<V>);
+    abstract refresh(desired: V | null): Promise<V | null>;
+    abstract applyAdd(valueToAdd: V, plan: Plan<T>): Promise<void>;
+    abstract applyModify(newValue: V, previousValue: V, allowDeletes: boolean, plan: Plan<T>): Promise<void>;
+    abstract applyRemove(valueToRemove: V, plan: Plan<T>): Promise<void>;
+}
+export declare abstract class ArrayStatefulParameter<T extends StringIndexedObject, V> extends StatefulParameter<T, any> {
+    options: ArrayStatefulParameterOptions<V>;
+    constructor(options?: ArrayStatefulParameterOptions<V>);
+    applyAdd(valuesToAdd: V[], plan: Plan<T>): Promise<void>;
+    applyModify(newValues: V[], previousValues: V[], allowDeletes: boolean, plan: Plan<T>): Promise<void>;
+    applyRemove(valuesToRemove: V[], plan: Plan<T>): Promise<void>;
+    abstract refresh(desired: V[] | null): Promise<V[] | null>;
+    abstract applyAddItem(item: V, plan: Plan<T>): Promise<void>;
+    abstract applyRemoveItem(item: V, plan: Plan<T>): Promise<void>;
+}

package/dist/entities/stateful-parameter.js

@@ -0,0 +1,46 @@
+export class StatefulParameter {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+}
+export class ArrayStatefulParameter extends StatefulParameter {
+    options;
+    constructor(options = {}) {
+        super(options);
+        this.options = options;
+    }
+    async applyAdd(valuesToAdd, plan) {
+        for (const value of valuesToAdd) {
+            await this.applyAddItem(value, plan);
+        }
+    }
+    async applyModify(newValues, previousValues, allowDeletes, plan) {
+        const options = this.options;
+        const valuesToAdd = newValues.filter((n) => !previousValues.some((p) => {
+            if (options.isElementEqual) {
+                return options.isElementEqual(n, p);
+            }
+            return n === p;
+        }));
+        const valuesToRemove = previousValues.filter((p) => !newValues.some((n) => {
+            if (options.isElementEqual) {
+                return options.isElementEqual(n, p);
+            }
+            return n === p;
+        }));
+        for (const value of valuesToAdd) {
+            await this.applyAddItem(value, plan);
+        }
+        if (allowDeletes) {
+            for (const value of valuesToRemove) {
+                await this.applyRemoveItem(value, plan);
+            }
+        }
+    }
+    async applyRemove(valuesToRemove, plan) {
+        for (const value of valuesToRemove) {
+            await this.applyRemoveItem(value, plan);
+        }
+    }
+}

package/dist/entities/transform-parameter.d.ts

@@ -0,0 +1,4 @@
+import { StringIndexedObject } from 'codify-schemas';
+export declare abstract class TransformParameter<T extends StringIndexedObject> {
+    abstract transform(value: any): Promise<Partial<T>>;
+}

package/dist/entities/transform-parameter.js

@@ -0,0 +1,2 @@
+export class TransformParameter {
+}

package/dist/errors.d.ts

@@ -0,0 +1,4 @@
+export declare class SudoError extends Error {
+    command: string;
+    constructor(command: string);
+}

package/dist/errors.js

@@ -0,0 +1,7 @@
+export class SudoError extends Error {
+    command;
+    constructor(command) {
+        super();
+        this.command = command;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+import { Plugin } from './plugin/plugin.js';
+export * from './errors.js';
+export * from './messages/sender.js';
+export * from './plan/change-set.js';
+export * from './plan/plan.js';
+export * from './plan/plan-types.js';
+export * from './plugin/plugin.js';
+export * from './pty/background-pty.js';
+export * from './pty/index.js';
+export * from './pty/seqeuntial-pty.js';
+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/file-utils.js';
+export * from './utils/functions.js';
+export * from './utils/index.js';
+export * from './utils/verbosity-level.js';
+export * from 'zod/v4';
+export declare function runPlugin(plugin: Plugin): Promise<void>;

package/dist/index.js

@@ -0,0 +1,26 @@
+import { MessageHandler } from './messages/handlers.js';
+export * from './errors.js';
+export * from './messages/sender.js';
+export * from './plan/change-set.js';
+export * from './plan/plan.js';
+export * from './plan/plan-types.js';
+export * from './plugin/plugin.js';
+export * from './pty/background-pty.js';
+export * from './pty/index.js';
+export * from './pty/seqeuntial-pty.js';
+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/file-utils.js';
+export * from './utils/functions.js';
+export * from './utils/index.js';
+export * from './utils/verbosity-level.js';
+export * from 'zod/v4';
+export async function runPlugin(plugin) {
+    const messageHandler = new MessageHandler(plugin);
+    process.on('message', (message) => messageHandler.onMessage(message));
+    process.on('beforeExit', () => {
+        plugin.kill();
+    });
+}

package/dist/messages/handlers.d.ts

@@ -0,0 +1,14 @@
+import { Plugin } from '../plugin/plugin.js';
+export declare class MessageHandler {
+    private ajv;
+    private readonly plugin;
+    private messageSchemaValidatorV1;
+    private messageSchemaValidatorV2;
+    private requestValidators;
+    private responseValidators;
+    constructor(plugin: Plugin);
+    onMessage(message: unknown): Promise<void>;
+    private validateMessage;
+    private validateMessageV2;
+    private handleErrors;
+}

package/dist/messages/handlers.js

@@ -0,0 +1,134 @@
+import { Ajv } from 'ajv';
+import addFormats from 'ajv-formats';
+import { ApplyRequestDataSchema, EmptyResponseDataSchema, GetResourceInfoRequestDataSchema, GetResourceInfoResponseDataSchema, ImportRequestDataSchema, ImportResponseDataSchema, InitializeRequestDataSchema, InitializeResponseDataSchema, IpcMessageSchema, IpcMessageV2Schema, MatchRequestDataSchema, MatchResponseDataSchema, MessageStatus, PlanRequestDataSchema, PlanResponseDataSchema, ResourceSchema, SetVerbosityRequestDataSchema, ValidateRequestDataSchema, ValidateResponseDataSchema } from 'codify-schemas';
+import { SudoError } from '../errors.js';
+const SupportedRequests = {
+    'initialize': {
+        handler: async (plugin, data) => plugin.initialize(data),
+        requestValidator: InitializeRequestDataSchema,
+        responseValidator: InitializeResponseDataSchema
+    },
+    'validate': {
+        handler: async (plugin, data) => plugin.validate(data),
+        requestValidator: ValidateRequestDataSchema,
+        responseValidator: ValidateResponseDataSchema
+    },
+    'getResourceInfo': {
+        handler: async (plugin, data) => plugin.getResourceInfo(data),
+        requestValidator: GetResourceInfoRequestDataSchema,
+        responseValidator: GetResourceInfoResponseDataSchema
+    },
+    'setVerbosityLevel': {
+        async handler(plugin, data) {
+            await plugin.setVerbosityLevel(data);
+            return null;
+        },
+        requestValidator: SetVerbosityRequestDataSchema,
+        responseValidator: EmptyResponseDataSchema,
+    },
+    'match': {
+        handler: async (plugin, data) => plugin.match(data),
+        requestValidator: MatchRequestDataSchema,
+        responseValidator: MatchResponseDataSchema
+    },
+    'import': {
+        handler: async (plugin, data) => plugin.import(data),
+        requestValidator: ImportRequestDataSchema,
+        responseValidator: ImportResponseDataSchema
+    },
+    'plan': {
+        handler: async (plugin, data) => plugin.plan(data),
+        requestValidator: PlanRequestDataSchema,
+        responseValidator: PlanResponseDataSchema
+    },
+    'apply': {
+        async handler(plugin, data) {
+            await plugin.apply(data);
+            return null;
+        },
+        requestValidator: ApplyRequestDataSchema,
+        responseValidator: EmptyResponseDataSchema
+    },
+};
+export class MessageHandler {
+    ajv;
+    plugin;
+    messageSchemaValidatorV1;
+    messageSchemaValidatorV2;
+    requestValidators;
+    responseValidators;
+    constructor(plugin) {
+        this.ajv = new Ajv({ strict: true, strictRequired: false });
+        addFormats.default(this.ajv);
+        this.ajv.addSchema(ResourceSchema);
+        this.plugin = plugin;
+        this.messageSchemaValidatorV1 = this.ajv.compile(IpcMessageSchema);
+        this.messageSchemaValidatorV2 = this.ajv.compile(IpcMessageV2Schema);
+        this.requestValidators = new Map(Object.entries(SupportedRequests)
+            .map(([k, v]) => [k, this.ajv.compile(v.requestValidator)]));
+        this.responseValidators = new Map(Object.entries(SupportedRequests)
+            .map(([k, v]) => [k, this.ajv.compile(v.responseValidator)]));
+    }
+    async onMessage(message) {
+        try {
+            if (!this.validateMessageV2(message) && !this.validateMessage(message)) {
+                throw new Error(`Plugin: ${this.plugin}. Message is malformed: ${JSON.stringify(this.messageSchemaValidatorV1.errors, null, 2)}`);
+            }
+            if (!this.requestValidators.has(message.cmd)) {
+                throw new Error(`Plugin: ${this.plugin}. Unsupported message: ${message.cmd}`);
+            }
+            const requestValidator = this.requestValidators.get(message.cmd);
+            if (!requestValidator(message.data)) {
+                throw new Error(`Plugin: ${this.plugin}. cmd: ${message.cmd}. Malformed message data: ${JSON.stringify(requestValidator.errors, null, 2)}`);
+            }
+            const result = await SupportedRequests[message.cmd].handler(this.plugin, message.data);
+            const responseValidator = this.responseValidators.get(message.cmd);
+            if (responseValidator && !responseValidator(result)) {
+                throw new Error(`Plugin: ${this.plugin.name}. Malformed response data: ${JSON.stringify(responseValidator.errors, null, 2)}. Received ${JSON.stringify(result, null, 2)}`);
+            }
+            process.send({
+                cmd: message.cmd + '_Response',
+                data: result,
+                // @ts-expect-error TS2239
+                requestId: message.requestId || undefined,
+                status: MessageStatus.SUCCESS,
+            });
+        }
+        catch (error) {
+            this.handleErrors(message, error);
+        }
+    }
+    validateMessage(message) {
+        return this.messageSchemaValidatorV1(message);
+    }
+    validateMessageV2(message) {
+        return this.messageSchemaValidatorV2(message);
+    }
+    handleErrors(message, e) {
+        if (!message) {
+            return;
+        }
+        if (!message.hasOwnProperty('cmd')) {
+            return;
+        }
+        // @ts-expect-error TS2239
+        const cmd = message.cmd + '_Response';
+        if (e instanceof SudoError) {
+            return process.send?.({
+                cmd,
+                // @ts-expect-error TS2239
+                requestId: message.requestId || undefined,
+                data: `Plugin: '${this.plugin.name}'. Forbidden usage of sudo for command '${e.command}'. Please contact the plugin developer to fix this.`,
+                status: MessageStatus.ERROR,
+            });
+        }
+        const isDebug = process.env.DEBUG?.includes('*') ?? false;
+        process.send?.({
+            cmd,
+            // @ts-expect-error TS2239
+            requestId: message.requestId || undefined,
+            data: isDebug ? e.stack : e.message,
+            status: MessageStatus.ERROR,
+        });
+    }
+}

package/dist/messages/sender.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Send requests to the Codify CLI
+ */
+declare class CodifyCliSenderImpl {
+    private readonly validateIpcMessageV2;
+    requestPressKeyToContinuePrompt(message?: string): Promise<void>;
+    getCodifyCliCredentials(): Promise<string>;
+    private sendAndWaitForResponse;
+}
+export declare const CodifyCliSender: CodifyCliSenderImpl;
+export {};

package/dist/messages/sender.js

@@ -0,0 +1,57 @@
+import { Ajv } from 'ajv';
+import { IpcMessageV2Schema, MessageCmd } from 'codify-schemas';
+import { nanoid } from 'nanoid';
+const ajv = new Ajv({
+    strict: true,
+});
+/**
+ * Send requests to the Codify CLI
+ */
+class CodifyCliSenderImpl {
+    validateIpcMessageV2 = ajv.compile(IpcMessageV2Schema);
+    async requestPressKeyToContinuePrompt(message) {
+        await this.sendAndWaitForResponse({
+            cmd: MessageCmd.PRESS_KEY_TO_CONTINUE_REQUEST,
+            data: {
+                promptMessage: message,
+            }
+        });
+    }
+    async getCodifyCliCredentials() {
+        const data = await this.sendAndWaitForResponse({
+            cmd: MessageCmd.CODIFY_CREDENTIALS_REQUEST,
+            data: {},
+        });
+        if (typeof data.data !== 'string') {
+            throw new Error('Expected string back from credentials request');
+        }
+        return data.data;
+    }
+    async sendAndWaitForResponse(message) {
+        return new Promise((resolve) => {
+            const requestId = nanoid(8);
+            const listener = (data) => {
+                if (data.requestId === requestId) {
+                    process.removeListener('message', listener);
+                    if (!this.validateIpcMessageV2(data)) {
+                        throw new Error(`Invalid response for request.
+Request:                        
+${JSON.stringify(message, null, 2)}
+Response:
+${JSON.stringify(data, null, 2)}
+Error:
+${JSON.stringify(this.validateIpcMessageV2.errors, null, 2)}`);
+                    }
+                    resolve(data);
+                }
+            };
+            process.on('message', listener);
+            const ipcMessage = {
+                ...message,
+                requestId,
+            };
+            process.send(ipcMessage);
+        });
+    }
+}
+export const CodifyCliSender = new CodifyCliSenderImpl();