@codifycli/plugin-core 1.2.5-beta.3 → 1.2.5-beta.4

package/.claude/settings.local.json

@@ -0,0 +1,13 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(grep -r \"COMMAND_REQUEST\\\\|PRESS_KEY_TO_CONTINUE_REQUEST\\\\|CODIFY_CREDENTIALS_REQUEST\" /Users/kevinwang/Projects/codify-parent/codify/src --include=\"*.ts\" ! -name \"*.test.ts\")",
+      "Read(//Users/kevinwang/Projects/codify-parent/codify-schemas/**)",
+      "Bash(npm run *)"
+    ]
+  },
+  "disabledMcpjsonServers": [
+    "supabase",
+    "codify"
+  ]
+}

package/dist/bin/build.d.ts

@@ -0,0 +1 @@
+export declare function build(): Promise<void>;

package/dist/bin/build.js

@@ -0,0 +1,80 @@
+import { Ajv } from 'ajv';
+import { IpcMessageSchema, MessageStatus, ResourceSchema } from 'codify-schemas';
+// @ts-ignore
+import mergeJsonSchemas from 'merge-json-schemas';
+import { fork } from 'node:child_process';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import * as url from 'node:url';
+import { codifySpawn } from '../utils/codify-spawn.js';
+const ajv = new Ajv({
+    strict: true
+});
+const ipcMessageValidator = ajv.compile(IpcMessageSchema);
+function sendMessageAndAwaitResponse(process, message) {
+    return new Promise((resolve, reject) => {
+        process.on('message', (response) => {
+            if (!ipcMessageValidator(response)) {
+                throw new Error(`Invalid message from plugin. ${JSON.stringify(message, null, 2)}`);
+            }
+            // Wait for the message response. Other messages such as sudoRequest may be sent before the response returns
+            if (response.cmd === message.cmd + '_Response') {
+                if (response.status === MessageStatus.SUCCESS) {
+                    resolve(response.data);
+                }
+                else {
+                    reject(new Error(String(response.data)));
+                }
+            }
+        });
+        // Send message last to ensure listeners are all registered
+        process.send(message);
+    });
+}
+export async function build() {
+    await fs.rm('./dist', { force: true, recursive: true });
+    await codifySpawn('npm run rollup -- -f es');
+    const plugin = fork('./dist/index.js', [], {
+        // Use default true to test plugins in secure mode (un-able to request sudo directly)
+        detached: true,
+        env: { ...process.env },
+        execArgv: ['--import', 'tsx/esm'],
+    });
+    const initializeResult = await sendMessageAndAwaitResponse(plugin, {
+        cmd: 'initialize',
+        data: {}
+    });
+    const { resourceDefinitions } = initializeResult;
+    const resourceTypes = resourceDefinitions.map((i) => i.type);
+    const schemasMap = new Map();
+    for (const type of resourceTypes) {
+        const resourceInfo = await sendMessageAndAwaitResponse(plugin, {
+            cmd: 'getResourceInfo',
+            data: { type }
+        });
+        schemasMap.set(type, resourceInfo.schema);
+    }
+    const mergedSchemas = [...schemasMap.entries()].map(([type, schema]) => {
+        // const resolvedSchema = await $RefParser.dereference(schema)
+        const resourceSchema = JSON.parse(JSON.stringify(ResourceSchema));
+        delete resourceSchema.$id;
+        delete resourceSchema.$schema;
+        delete resourceSchema.title;
+        delete resourceSchema.oneOf;
+        delete resourceSchema.properties.type;
+        if (schema) {
+            delete schema.$id;
+            delete schema.$schema;
+            delete schema.title;
+            delete schema.oneOf;
+        }
+        return mergeJsonSchemas([schema ?? {}, resourceSchema, { properties: { type: { const: type, type: 'string' } } }]);
+    });
+    await fs.rm('./dist', { force: true, recursive: true });
+    await codifySpawn('npm run rollup'); // re-run rollup without building for es
+    console.log('Generated JSON Schemas for all resources');
+    const distFolder = path.resolve(path.dirname(url.fileURLToPath(import.meta.url)), '..', 'dist');
+    const schemaOutputPath = path.resolve(distFolder, 'schemas.json');
+    await fs.writeFile(schemaOutputPath, JSON.stringify(mergedSchemas, null, 2));
+    console.log('Successfully wrote schema to ./dist/schemas.json');
+}

package/dist/bin/deploy-plugin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/deploy-plugin.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import path from 'node:path';
+import * as fs from 'node:fs';
+import { build } from './build.js';
+const packageJson = fs.readFileSync(path.join(process.env['npm_config_local_prefix'], 'package.json'), 'utf8');
+const { name: libraryName, version: libraryVersion } = JSON.parse(packageJson);
+console.log(libraryName, libraryVersion);
+await build();

package/dist/entities/change-set.d.ts

@@ -0,0 +1,24 @@
+import { ParameterOperation, ResourceOperation, StringIndexedObject } from 'codify-schemas';
+import { ParameterOptions } from './plan-types.js';
+export interface ParameterChange<T extends StringIndexedObject> {
+    name: keyof T & string;
+    operation: ParameterOperation;
+    previousValue: any | null;
+    newValue: any | null;
+}
+export declare class ChangeSet<T extends StringIndexedObject> {
+    operation: ResourceOperation;
+    parameterChanges: Array<ParameterChange<T>>;
+    constructor(operation: ResourceOperation, parameterChanges: Array<ParameterChange<T>>);
+    get desiredParameters(): T;
+    get currentParameters(): T;
+    static calculateParameterChangeSet<T extends StringIndexedObject>(desired: T | null, current: T | null, options: {
+        statefulMode: boolean;
+        parameterOptions?: Record<keyof T, ParameterOptions>;
+    }): ParameterChange<T>[];
+    static combineResourceOperations(prev: ResourceOperation, next: ResourceOperation): ResourceOperation;
+    static isSame(desired: unknown, current: unknown, options?: ParameterOptions): boolean;
+    private static calculateStatefulModeChangeSet;
+    private static calculateStatelessModeChangeSet;
+    private static addDefaultValues;
+}

package/dist/entities/change-set.js

@@ -0,0 +1,152 @@
+import { ParameterOperation, ResourceOperation } from 'codify-schemas';
+export class ChangeSet {
+    operation;
+    parameterChanges;
+    constructor(operation, parameterChanges) {
+        this.operation = operation;
+        this.parameterChanges = parameterChanges;
+    }
+    get desiredParameters() {
+        return this.parameterChanges
+            .reduce((obj, pc) => ({
+            ...obj,
+            [pc.name]: pc.newValue,
+        }), {});
+    }
+    get currentParameters() {
+        return this.parameterChanges
+            .reduce((obj, pc) => ({
+            ...obj,
+            [pc.name]: pc.previousValue,
+        }), {});
+    }
+    static calculateParameterChangeSet(desired, current, options) {
+        if (options.statefulMode) {
+            return ChangeSet.calculateStatefulModeChangeSet(desired, current, options.parameterOptions);
+        }
+        else {
+            return ChangeSet.calculateStatelessModeChangeSet(desired, current, options.parameterOptions);
+        }
+    }
+    static combineResourceOperations(prev, next) {
+        const orderOfOperations = [
+            ResourceOperation.NOOP,
+            ResourceOperation.MODIFY,
+            ResourceOperation.RECREATE,
+            ResourceOperation.CREATE,
+            ResourceOperation.DESTROY,
+        ];
+        const indexPrev = orderOfOperations.indexOf(prev);
+        const indexNext = orderOfOperations.indexOf(next);
+        return orderOfOperations[Math.max(indexPrev, indexNext)];
+    }
+    static isSame(desired, current, options) {
+        if (options?.isEqual) {
+            return options.isEqual(desired, current);
+        }
+        if (Array.isArray(desired) && Array.isArray(current)) {
+            const sortedDesired = desired.map((x) => x).sort();
+            const sortedCurrent = current.map((x) => x).sort();
+            if (sortedDesired.length !== sortedCurrent.length) {
+                return false;
+            }
+            if (options?.isElementEqual) {
+                return sortedDesired.every((value, index) => options.isElementEqual(value, sortedCurrent[index]));
+            }
+            return JSON.stringify(sortedDesired) === JSON.stringify(sortedCurrent);
+        }
+        return desired === current;
+    }
+    static calculateStatefulModeChangeSet(desired, current, parameterOptions) {
+        const parameterChangeSet = new Array();
+        const _desired = Object.fromEntries(Object.entries(desired ?? {}).filter(([, v]) => v != null));
+        const _current = Object.fromEntries(Object.entries(current ?? {}).filter(([, v]) => v != null));
+        this.addDefaultValues(_desired, parameterOptions);
+        for (const [k, v] of Object.entries(_current)) {
+            if (_desired[k] == null) {
+                parameterChangeSet.push({
+                    name: k,
+                    previousValue: v,
+                    newValue: null,
+                    operation: ParameterOperation.REMOVE,
+                });
+                delete _current[k];
+                continue;
+            }
+            if (!ChangeSet.isSame(_desired[k], _current[k], parameterOptions?.[k])) {
+                parameterChangeSet.push({
+                    name: k,
+                    previousValue: v,
+                    newValue: _desired[k],
+                    operation: ParameterOperation.MODIFY,
+                });
+                delete _current[k];
+                delete _desired[k];
+                continue;
+            }
+            parameterChangeSet.push({
+                name: k,
+                previousValue: v,
+                newValue: _desired[k],
+                operation: ParameterOperation.NOOP,
+            });
+            delete _current[k];
+            delete _desired[k];
+        }
+        if (Object.keys(_current).length !== 0) {
+            throw Error('Diff algorithm error');
+        }
+        for (const [k, v] of Object.entries(_desired)) {
+            parameterChangeSet.push({
+                name: k,
+                previousValue: null,
+                newValue: v,
+                operation: ParameterOperation.ADD,
+            });
+        }
+        return parameterChangeSet;
+    }
+    static calculateStatelessModeChangeSet(desired, current, parameterOptions) {
+        const parameterChangeSet = new Array();
+        const _desired = Object.fromEntries(Object.entries(desired ?? {}).filter(([, v]) => v != null));
+        const _current = Object.fromEntries(Object.entries(current ?? {}).filter(([, v]) => v != null));
+        this.addDefaultValues(_desired, parameterOptions);
+        for (const [k, v] of Object.entries(_desired)) {
+            if (_current[k] == null) {
+                parameterChangeSet.push({
+                    name: k,
+                    previousValue: null,
+                    newValue: v,
+                    operation: ParameterOperation.ADD,
+                });
+                continue;
+            }
+            if (!ChangeSet.isSame(_desired[k], _current[k], parameterOptions?.[k])) {
+                parameterChangeSet.push({
+                    name: k,
+                    previousValue: _current[k],
+                    newValue: _desired[k],
+                    operation: ParameterOperation.MODIFY,
+                });
+                continue;
+            }
+            parameterChangeSet.push({
+                name: k,
+                previousValue: v,
+                newValue: v,
+                operation: ParameterOperation.NOOP,
+            });
+        }
+        return parameterChangeSet;
+    }
+    static addDefaultValues(obj, options) {
+        Object.entries(options ?? {})
+            .filter(([, option]) => option.default !== undefined)
+            .map(([name, option]) => [name, option.default])
+            .forEach(([key, defaultValue]) => {
+            if (obj[key] === undefined) {
+                obj[key] = defaultValue;
+            }
+        });
+    }
+}

package/dist/entities/errors.d.ts

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

package/dist/entities/errors.js

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

package/dist/entities/plan-types.d.ts

@@ -0,0 +1,25 @@
+import { Plan } from './plan.js';
+import { StringIndexedObject } from 'codify-schemas';
+export interface ParameterOptions {
+    modifyOnChange?: boolean;
+    isEqual?: (desired: any, current: any) => boolean;
+    isElementEqual?: (desired: any, current: any) => boolean;
+    default?: unknown;
+    isStatefulParameter?: boolean;
+}
+export interface PlanOptions<T> {
+    statefulMode: boolean;
+    parameterOptions?: Record<keyof T, ParameterOptions>;
+}
+export interface CreatePlan<T extends StringIndexedObject> extends Plan<T> {
+    desiredConfig: T;
+    currentConfig: null;
+}
+export interface DestroyPlan<T extends StringIndexedObject> extends Plan<T> {
+    desiredConfig: null;
+    currentConfig: T;
+}
+export interface ModifyPlan<T extends StringIndexedObject> extends Plan<T> {
+    desiredConfig: T;
+    currentConfig: T;
+}

package/dist/entities/plan-types.js

@@ -0,0 +1 @@
+export {};

package/dist/entities/plan.d.ts

@@ -0,0 +1,15 @@
+import { ChangeSet } from './change-set.js';
+import { ApplyRequestData, PlanResponseData, ResourceConfig, StringIndexedObject } from 'codify-schemas';
+import { PlanOptions } from './plan-types.js';
+export declare class Plan<T extends StringIndexedObject> {
+    id: string;
+    changeSet: ChangeSet<T>;
+    resourceMetadata: ResourceConfig;
+    constructor(id: string, changeSet: ChangeSet<T>, resourceMetadata: ResourceConfig);
+    static create<T extends StringIndexedObject>(desiredParameters: Partial<T> | null, currentParameters: Partial<T> | null, resourceMetadata: ResourceConfig, options: PlanOptions<T>): Plan<T>;
+    getResourceType(): string;
+    static fromResponse<T extends ResourceConfig>(data: ApplyRequestData['plan'], defaultValues?: Partial<Record<keyof T, unknown>>): Plan<T>;
+    get desiredConfig(): T | null;
+    get currentConfig(): T | null;
+    toResponse(): PlanResponseData;
+}

package/dist/entities/plan.js

@@ -0,0 +1,127 @@
+import { ChangeSet } from './change-set.js';
+import { ParameterOperation, ResourceOperation, } from 'codify-schemas';
+import { randomUUID } from 'crypto';
+export class Plan {
+    id;
+    changeSet;
+    resourceMetadata;
+    constructor(id, changeSet, resourceMetadata) {
+        this.id = id;
+        this.changeSet = changeSet;
+        this.resourceMetadata = resourceMetadata;
+    }
+    static create(desiredParameters, currentParameters, resourceMetadata, options) {
+        const parameterOptions = options.parameterOptions ?? {};
+        const statefulParameterNames = new Set([...Object.entries(parameterOptions)]
+            .filter(([k, v]) => v.isStatefulParameter)
+            .map(([k, v]) => k));
+        const parameterChangeSet = ChangeSet.calculateParameterChangeSet(desiredParameters, currentParameters, { statefulMode: options.statefulMode, parameterOptions });
+        let resourceOperation;
+        if (!currentParameters && desiredParameters) {
+            resourceOperation = ResourceOperation.CREATE;
+        }
+        else if (currentParameters && !desiredParameters) {
+            resourceOperation = ResourceOperation.DESTROY;
+        }
+        else {
+            resourceOperation = parameterChangeSet
+                .filter((change) => change.operation !== ParameterOperation.NOOP)
+                .reduce((operation, curr) => {
+                let newOperation;
+                if (statefulParameterNames.has(curr.name)) {
+                    newOperation = ResourceOperation.MODIFY;
+                }
+                else if (parameterOptions[curr.name]?.modifyOnChange) {
+                    newOperation = parameterOptions[curr.name].modifyOnChange ? ResourceOperation.MODIFY : ResourceOperation.RECREATE;
+                }
+                else {
+                    newOperation = ResourceOperation.RECREATE;
+                }
+                return ChangeSet.combineResourceOperations(operation, newOperation);
+            }, ResourceOperation.NOOP);
+        }
+        return new Plan(randomUUID(), new ChangeSet(resourceOperation, parameterChangeSet), resourceMetadata);
+    }
+    getResourceType() {
+        return this.resourceMetadata.type;
+    }
+    static fromResponse(data, defaultValues) {
+        if (!data) {
+            throw new Error('Data is empty');
+        }
+        addDefaultValues();
+        return new Plan(randomUUID(), new ChangeSet(data.operation, data.parameters), {
+            type: data.resourceType,
+            name: data.resourceName,
+        });
+        function addDefaultValues() {
+            Object.entries(defaultValues ?? {})
+                .forEach(([key, defaultValue]) => {
+                const configValueExists = data
+                    .parameters
+                    .some((p) => p.name === key);
+                if (configValueExists) {
+                    return;
+                }
+                switch (data.operation) {
+                    case ResourceOperation.CREATE: {
+                        data.parameters.push({
+                            name: key,
+                            operation: ParameterOperation.ADD,
+                            previousValue: null,
+                            newValue: defaultValue,
+                        });
+                        break;
+                    }
+                    case ResourceOperation.DESTROY: {
+                        data.parameters.push({
+                            name: key,
+                            operation: ParameterOperation.REMOVE,
+                            previousValue: defaultValue,
+                            newValue: null,
+                        });
+                        break;
+                    }
+                    case ResourceOperation.MODIFY:
+                    case ResourceOperation.RECREATE:
+                    case ResourceOperation.NOOP: {
+                        data.parameters.push({
+                            name: key,
+                            operation: ParameterOperation.NOOP,
+                            previousValue: defaultValue,
+                            newValue: defaultValue,
+                        });
+                        break;
+                    }
+                }
+            });
+        }
+    }
+    get desiredConfig() {
+        if (this.changeSet.operation === ResourceOperation.DESTROY) {
+            return null;
+        }
+        return {
+            ...this.resourceMetadata,
+            ...this.changeSet.desiredParameters,
+        };
+    }
+    get currentConfig() {
+        if (this.changeSet.operation === ResourceOperation.CREATE) {
+            return null;
+        }
+        return {
+            ...this.resourceMetadata,
+            ...this.changeSet.currentParameters,
+        };
+    }
+    toResponse() {
+        return {
+            planId: this.id,
+            operation: this.changeSet.operation,
+            resourceName: this.resourceMetadata.name,
+            resourceType: this.resourceMetadata.type,
+            parameters: this.changeSet.parameterChanges,
+        };
+    }
+}

package/dist/entities/plugin.d.ts

@@ -0,0 +1,16 @@
+import { ApplyRequestData, InitializeResponseData, PlanRequestData, PlanResponseData, ResourceConfig, ValidateRequestData, ValidateResponseData } from 'codify-schemas';
+import { Plan } from './plan.js';
+import { Resource } from './resource.js';
+export declare class Plugin {
+    name: string;
+    resources: Map<string, Resource<ResourceConfig>>;
+    planStorage: Map<string, Plan<any>>;
+    static create(name: string, resources: Resource<any>[]): Plugin;
+    constructor(name: string, resources: Map<string, Resource<ResourceConfig>>);
+    initialize(): Promise<InitializeResponseData>;
+    validate(data: ValidateRequestData): Promise<ValidateResponseData>;
+    plan(data: PlanRequestData): Promise<PlanResponseData>;
+    apply(data: ApplyRequestData): Promise<void>;
+    private resolvePlan;
+    protected crossValidateResources(configs: ResourceConfig[]): Promise<void>;
+}

package/dist/entities/plugin.js

@@ -0,0 +1,80 @@
+import { splitUserConfig } from '../utils/utils.js';
+import { Plan } from './plan.js';
+export class Plugin {
+    name;
+    resources;
+    planStorage;
+    static create(name, resources) {
+        const resourceMap = new Map(resources.map((r) => [r.typeId, r]));
+        return new Plugin(name, resourceMap);
+    }
+    constructor(name, resources) {
+        this.name = name;
+        this.resources = resources;
+        this.planStorage = new Map();
+    }
+    async initialize() {
+        for (const resource of this.resources.values()) {
+            await resource.onInitialize();
+        }
+        return {
+            resourceDefinitions: [...this.resources.values()]
+                .map((r) => ({
+                dependencies: r.dependencies,
+                type: r.typeId,
+            }))
+        };
+    }
+    async validate(data) {
+        const validationResults = [];
+        for (const config of data.configs) {
+            if (!this.resources.has(config.type)) {
+                throw new Error(`Resource type not found: ${config.type}`);
+            }
+            const { parameters, resourceMetadata } = splitUserConfig(config);
+            const validation = await this.resources
+                .get(config.type)
+                .validate(parameters, resourceMetadata);
+            validationResults.push(validation);
+        }
+        await this.crossValidateResources(data.configs);
+        return {
+            resourceValidations: validationResults
+        };
+    }
+    async plan(data) {
+        const type = data.desired?.type ?? data.state?.type;
+        if (!type || !this.resources.has(type)) {
+            throw new Error(`Resource type not found: ${type}`);
+        }
+        const plan = await this.resources.get(type).plan(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.resources.get(plan.getResourceType());
+        if (!resource) {
+            throw new Error('Malformed plan with resource that cannot be found');
+        }
+        await resource.apply(plan);
+    }
+    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.resources.has(planRequest.resourceType)) {
+            throw new Error('Malformed plan. Resource type must be supplied or resource type was not found');
+        }
+        const resource = this.resources.get(planRequest.resourceType);
+        return Plan.fromResponse(planRequest, resource.defaultValues);
+    }
+    async crossValidateResources(configs) { }
+}

package/dist/entities/resource-options.d.ts

@@ -0,0 +1,31 @@
+import { StringIndexedObject } from 'codify-schemas';
+import { ParameterOptions } from './plan-types.js';
+import { ResourceParameterOptions } from './resource-types.js';
+import { StatefulParameter } from './stateful-parameter.js';
+import { TransformParameter } from './transform-parameter.js';
+export interface ResourceOptions<T extends StringIndexedObject> {
+    callStatefulParameterRemoveOnDestroy?: boolean;
+    dependencies?: string[];
+    parameterOptions?: Partial<Record<keyof T, ResourceParameterOptions | ResourceStatefulParameterOptions<T> | ResourceTransformParameterOptions<T>>>;
+    schema?: unknown;
+    type: string;
+}
+export interface ResourceStatefulParameterOptions<T extends StringIndexedObject> {
+    order?: number;
+    statefulParameter: StatefulParameter<T, T[keyof T]>;
+}
+export interface ResourceTransformParameterOptions<T extends StringIndexedObject> {
+    order?: number;
+    transformParameter: TransformParameter<T>;
+}
+export declare class ResourceOptionsParser<T extends StringIndexedObject> {
+    private options;
+    constructor(options: ResourceOptions<T>);
+    get statefulParameters(): Map<keyof T, StatefulParameter<T, T[keyof T]>>;
+    get transformParameters(): Map<keyof T, TransformParameter<T>>;
+    get resourceParameters(): Map<keyof T, ResourceParameterOptions>;
+    get changeSetParameterOptions(): Record<keyof T, ParameterOptions>;
+    get defaultValues(): Partial<Record<keyof T, unknown>>;
+    get statefulParameterOrder(): Map<keyof T, number>;
+    get transformParameterOrder(): Map<keyof T, number>;
+}