codify-plugin-lib 1.0.182-beta4 → 1.0.182-beta40

package/dist/index.d.ts

@@ -10,7 +10,8 @@ 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 './utils/functions.js';
 export declare function runPlugin(plugin: Plugin): Promise<void>;

package/dist/index.js

@@ -10,9 +10,10 @@ 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 './utils/functions.js';
 export async function runPlugin(plugin) {
     const messageHandler = new MessageHandler(plugin);
     process.on('message', (message) => messageHandler.onMessage(message));

package/dist/plugin/plugin.d.ts

@@ -1,15 +1,15 @@
 import { ApplyRequestData, GetResourceInfoRequestData, GetResourceInfoResponseData, ImportRequestData, ImportResponseData, InitializeRequestData, InitializeResponseData, MatchRequestData, MatchResponseData, PlanRequestData, PlanResponseData, ResourceConfig, ResourceJson, ValidateRequestData, ValidateResponseData } from 'codify-schemas';
 import { Plan } from '../plan/plan.js';
 import { BackgroundPty } from '../pty/background-pty.js';
-import { Resource } from '../resource/resource.js';
 import { ResourceController } from '../resource/resource-controller.js';
 export declare class Plugin {
     name: string;
+    version: string;
     resourceControllers: Map<string, ResourceController<ResourceConfig>>;
     planStorage: Map<string, Plan<any>>;
     planPty: BackgroundPty;
-    constructor(name: string, resourceControllers: Map<string, ResourceController<ResourceConfig>>);
-    static create(name: string, resources: Resource<any>[]): Plugin;
+    constructor(name: string, version: string, resourceControllers: Map<string, ResourceController<ResourceConfig>>);
+    static create(): Promise<Plugin>;
     initialize(data: InitializeRequestData): Promise<InitializeResponseData>;
     getResourceInfo(data: GetResourceInfoRequestData): GetResourceInfoResponseData;
     match(data: MatchRequestData): Promise<MatchResponseData>;

package/dist/plugin/plugin.js

@@ -4,23 +4,37 @@ 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 { listAllResources } from '../utils/load-resources.js';
+import { readNearestPackageJson } from '../utils/package-json-utils.js';
 import { ptyLocalStorage } from '../utils/pty-local-storage.js';
 import { VerbosityLevel } from '../utils/verbosity-level.js';
 export class Plugin {
     name;
+    version;
     resourceControllers;
     planStorage;
     planPty = new BackgroundPty();
-    constructor(name, resourceControllers) {
+    constructor(name, version, resourceControllers) {
         this.name = name;
+        this.version = version;
         this.resourceControllers = resourceControllers;
         this.planStorage = new Map();
     }
-    static create(name, resources) {
+    static async create() {
+        const packageJson = readNearestPackageJson();
+        if (!packageJson) {
+            throw new Error('Failed to read nearest package.json');
+        }
+        const { name, version } = packageJson;
+        const resourceLocations = await listAllResources();
+        const resources = await Promise.all(resourceLocations.map((l) => {
+            return import(l).then((r) => r.default ?? r);
+        }));
+        console.log(resources);
         const controllers = resources
             .map((resource) => new ResourceController(resource));
         const controllersMap = new Map(controllers.map((r) => [r.typeId, r]));
-        return new Plugin(name, controllersMap);
+        return new Plugin(name, version, controllersMap);
     }
     async initialize(data) {
         if (data.verbosityLevel) {
@@ -55,7 +69,7 @@ export class Plugin {
             throw new Error(`Cannot get info for resource ${data.type}, resource doesn't exist`);
         }
         const resource = this.resourceControllers.get(data.type);
-        const schema = resource.settings.schema;
+        const schema = resource.parsedSettings.schema;
         const requiredPropertyNames = (resource.settings.importAndDestroy?.requiredParameters
             ?? (typeof resource.settings.allowMultiple === 'object' ? resource.settings.allowMultiple.identifyingParameters : null)
             ?? schema?.required

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

@@ -6,11 +6,12 @@ import { IPty, SpawnOptions, SpawnResult } from './index.js';
  * 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, options?: SpawnOptions): Promise<SpawnResult>;
-    spawnSafe(cmd: string, options?: SpawnOptions): Promise<SpawnResult>;
+    spawn(cmd: string | string[], options?: SpawnOptions): Promise<SpawnResult>;
+    spawnSafe(cmd: string | string[], options?: SpawnOptions): Promise<SpawnResult>;
     kill(): Promise<{
         exitCode: number;
         signal?: number | undefined;

package/dist/pty/background-pty.js

@@ -17,8 +17,10 @@ EventEmitter.defaultMaxListeners = 1000;
  * 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, name: nanoid(6),
+        env: { ...process.env, ...this.historyIgnore },
+        name: nanoid(6),
         handleFlowControl: true
     });
     promiseQueue = new PromiseQueue();
@@ -28,11 +30,12 @@ export class BackgroundPty {
     async spawn(cmd, options) {
         const spawnResult = await this.spawnSafe(cmd, options);
         if (spawnResult.status !== 'success') {
-            throw new SpawnError(cmd, spawnResult.exitCode, spawnResult.data);
+            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);
@@ -84,7 +87,7 @@ export class BackgroundPty {
                         resolve(null);
                     }
                 });
-                console.log(`Running command ${cmd}${options?.cwd ? ` (cwd: ${options.cwd})` : ''}`);
+                console.log(`Running command: ${cmd}${options?.cwd ? ` (cwd: ${options.cwd})` : ''}`);
                 this.basePty.write(`${command}\r`);
             }));
         }).finally(async () => {
@@ -104,17 +107,6 @@ export class BackgroundPty {
         await this.promiseQueue.run(async () => {
             let outputBuffer = '';
             return new Promise(resolve => {
-                // zsh-specific commands
-                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');
                 this.basePty.write(' echo setup complete\\"\n');

package/dist/pty/index.d.ts

@@ -26,6 +26,8 @@ export interface SpawnOptions {
     cwd?: string;
     env?: Record<string, unknown>;
     interactive?: boolean;
+    requiresRoot?: boolean;
+    stdin?: boolean;
 }
 export declare class SpawnError extends Error {
     data: string;
@@ -34,8 +36,8 @@ export declare class SpawnError extends Error {
     constructor(cmd: string, exitCode: number, data: string);
 }
 export interface IPty {
-    spawn(cmd: string, options?: SpawnOptions): Promise<SpawnResult>;
-    spawnSafe(cmd: string, options?: SpawnOptions): Promise<SpawnResult>;
+    spawn(cmd: string | string[], options?: SpawnOptions): Promise<SpawnResult>;
+    spawnSafe(cmd: string | string[], options?: SpawnOptions): Promise<SpawnResult>;
     kill(): Promise<{
         exitCode: number;
         signal?: number | undefined;

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

@@ -6,11 +6,12 @@ import { IPty, SpawnOptions, SpawnResult } from './index.js';
  * 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>;
+    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

@@ -1,10 +1,17 @@
 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
@@ -15,12 +22,20 @@ 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);
+            throw new SpawnError(Array.isArray(cmd) ? cmd.join('\n') : cmd, spawnResult.exitCode, spawnResult.data);
         }
         return spawnResult;
     }
     async spawnSafe(cmd, options) {
-        console.log(`Running command: ${cmd}` + (options?.cwd ? `(${options?.cwd})` : ''));
+        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: '*' };
@@ -30,12 +45,13 @@ export class SequentialPty {
                 ...process.env, ...options?.env,
                 TERM_PROGRAM: 'codify',
                 COMMAND_MODE: 'unix2003',
-                COLORTERM: 'truecolor', ...historyIgnore
+                COLORTERM: 'truecolor',
+                ...historyIgnore
             };
             // Initial terminal dimensions
             const initialCols = process.stdout.columns ?? 80;
             const initialRows = process.stdout.rows ?? 24;
-            const args = (options?.interactive ?? false) ? ['-i', '-c', `"${cmd}"`] : ['-c', `"${cmd}"`];
+            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,
@@ -49,20 +65,14 @@ export class SequentialPty {
                 }
                 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,
@@ -78,6 +88,30 @@ export class SequentialPty {
             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/resource/parsed-resource-settings.d.ts

@@ -18,10 +18,12 @@ export type ParsedParameterSetting = {
 export declare class ParsedResourceSettings<T extends StringIndexedObject> implements ResourceSettings<T> {
     private cache;
     id: string;
+    description?: string;
     schema?: Partial<JSONSchemaType<T | any>>;
     allowMultiple?: {
+        identifyingParameters?: string[];
         matcher?: (desired: Partial<T>, current: Partial<T>) => boolean;
-        requiredParameters?: string[];
+        findAllParameters?: () => Promise<Array<Partial<T>>>;
     } | boolean;
     removeStatefulParametersBeforeDestroy?: boolean | undefined;
     dependencies?: string[] | undefined;

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

@@ -1,8 +1,10 @@
+import { ZodObject, z } from 'zod';
 import { StatefulParameterController } from '../stateful-parameter/stateful-parameter-controller.js';
 import { resolveElementEqualsFn, resolveEqualsFn, resolveMatcher, resolveParameterTransformFn } from './resource-settings.js';
 export class ParsedResourceSettings {
     cache = new Map();
     id;
+    description;
     schema;
     allowMultiple;
     removeStatefulParametersBeforeDestroy;
@@ -13,8 +15,19 @@ export class ParsedResourceSettings {
     settings;
     constructor(settings) {
         this.settings = settings;
-        const { parameterSettings, ...rest } = settings;
+        const { parameterSettings, schema, ...rest } = settings;
         Object.assign(this, rest);
+        if (schema) {
+            this.schema = schema instanceof ZodObject
+                ? z.toJSONSchema(schema.strict(), {
+                    target: 'draft-7',
+                    override(ctx) {
+                        ctx.jsonSchema.title = settings.id;
+                        ctx.jsonSchema.description = settings.description ?? `${settings.id} resource. Can be used to manage ${settings.id}`;
+                    }
+                })
+                : schema;
+        }
         this.validateSettings();
     }
     get typeId() {
@@ -118,7 +131,7 @@ export class ParsedResourceSettings {
             && typeof this.settings.allowMultiple === 'object' && this.settings.allowMultiple?.identifyingParameters?.includes(k))) {
             throw new Error(`Resource: ${this.id}. Stateful parameters are not allowed to be identifying parameters for allowMultiple.`);
         }
-        const schema = this.settings.schema;
+        const schema = this.schema;
         if (!this.settings.importAndDestroy && (schema?.oneOf
             && Array.isArray(schema.oneOf)
             && schema.oneOf.some((s) => s.required))

package/dist/resource/resource-controller.js

@@ -17,16 +17,16 @@ export class ResourceController {
         this.settings = resource.getSettings();
         this.typeId = this.settings.id;
         this.dependencies = this.settings.dependencies ?? [];
-        if (this.settings.schema) {
+        this.parsedSettings = new ParsedResourceSettings(this.settings);
+        if (this.parsedSettings.schema) {
             this.ajv = new Ajv({
                 allErrors: true,
                 strict: true,
                 strictRequired: false,
                 allowUnionTypes: true
             });
-            this.schemaValidator = this.ajv.compile(this.settings.schema);
+            this.schemaValidator = this.ajv.compile(this.parsedSettings.schema);
         }
-        this.parsedSettings = new ParsedResourceSettings(this.settings);
     }
     async initialize() {
         return this.resource.initialize();
@@ -374,8 +374,8 @@ ${JSON.stringify(refresh, null, 2)}
             .sort((a, b) => this.parsedSettings.statefulParameterOrder.get(a.name) - this.parsedSettings.statefulParameterOrder.get(b.name));
     }
     getAllParameterKeys() {
-        return this.settings.schema
-            ? Object.keys(this.settings.schema?.properties)
+        return this.parsedSettings.schema
+            ? Object.keys(this.parsedSettings.schema?.properties)
             : Object.keys(this.parsedSettings.parameterSettings);
     }
     getParametersToRefreshForImport(parameters, context) {

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

@@ -1,6 +1,8 @@
 import { JSONSchemaType } from 'ajv';
 import { OS, StringIndexedObject } from 'codify-schemas';
+import { ZodObject } from 'zod';
 import { ArrayStatefulParameter, StatefulParameter } from '../stateful-parameter/stateful-parameter.js';
+import { ParsedResourceSettings } from './parsed-resource-settings.js';
 import { RefreshContext } from './resource.js';
 export interface InputTransformation {
     to: (input: any) => Promise<any> | any;
@@ -21,12 +23,16 @@ export interface ResourceSettings<T extends StringIndexedObject> {
     /**
      * Schema to validate user configs with. Must be in the format JSON Schema draft07
      */
-    schema?: Partial<JSONSchemaType<T | any>>;
+    schema?: Partial<JSONSchemaType<T | any>> | ZodObject;
     /**
      * Mark the resource as sensitive. Defaults to false. This prevents the resource from automatically being imported by init and import.
      * This differs from the parameter level sensitivity which also prevents the parameter value from being displayed in the plan.
      */
     isSensitive?: boolean;
+    /**
+     * An optional description of the resource. This does not affect the behavior of the resource.
+     */
+    description?: string;
     /**
      * Allow multiple of the same resource to unique. Set truthy if
      * multiples are allowed, for example for applications, there can be multiple copy of the same application installed
@@ -290,4 +296,4 @@ export declare function resolveEqualsFn(parameter: ParameterSetting): (desired:
 export declare function resolveElementEqualsFn(parameter: ArrayParameterSetting): (desired: unknown, current: unknown) => boolean;
 export declare function resolveFnFromEqualsFnOrString(fnOrString: ((a: unknown, b: unknown) => boolean) | ParameterSettingType | undefined): ((a: unknown, b: unknown) => boolean) | undefined;
 export declare function resolveParameterTransformFn(parameter: ParameterSetting): InputTransformation | undefined;
-export declare function resolveMatcher<T extends StringIndexedObject>(settings: ResourceSettings<T>): (desired: Partial<T>, current: Partial<T>) => boolean;
+export declare function resolveMatcher<T extends StringIndexedObject>(settings: ParsedResourceSettings<T>): (desired: Partial<T>, current: Partial<T>) => boolean;

package/dist/resource/resource-settings.js

@@ -3,7 +3,7 @@ import path from 'node:path';
 import { addVariablesToPath, areArraysEqual, resolvePathWithVariables, tildify, untildify } from '../utils/functions.js';
 const ParameterEqualsDefaults = {
     'boolean': (a, b) => Boolean(a) === Boolean(b),
-    'directory': (a, b) => {
+    'directory'(a, b) {
         let transformedA = resolvePathWithVariables(untildify(String(a)));
         let transformedB = resolvePathWithVariables(untildify(String(b)));
         if (transformedA.startsWith('.')) { // Only relative paths start with '.'
@@ -65,7 +65,7 @@ export function resolveFnFromEqualsFnOrString(fnOrString) {
 const ParameterTransformationDefaults = {
     'directory': {
         to: (a) => resolvePathWithVariables((untildify(String(a)))),
-        from: (a, original) => {
+        from(a, original) {
             if (ParameterEqualsDefaults.directory(a, original)) {
                 return original;
             }

package/dist/test.d.ts

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

package/dist/test.js

@@ -0,0 +1,5 @@
+import { SequentialPty } from './pty/seqeuntial-pty.js';
+import { VerbosityLevel } from './utils/verbosity-level.js';
+VerbosityLevel.set(1);
+const $ = new SequentialPty();
+await $.spawn('sudo ls', { interactive: true });

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

@@ -0,0 +1,23 @@
+export declare class FileUtils {
+    static downloadFile(url: string, destination: string): Promise<void>;
+    static addToShellRc(line: string): Promise<void>;
+    static addAllToShellRc(lines: string[]): Promise<void>;
+    /**
+     * This method adds a directory path to the shell rc file if it doesn't already exist.
+     *
+     * @param value - The directory path to add.
+     * @param prepend - Whether to prepend the path to the existing PATH variable.
+     */
+    static addPathToShellRc(value: string, prepend: boolean): Promise<void>;
+    static removeFromFile(filePath: string, search: string): Promise<void>;
+    static removeLineFromFile(filePath: string, search: RegExp | string): Promise<void>;
+    static removeLineFromShellRc(search: RegExp | string): Promise<void>;
+    static removeAllLinesFromShellRc(searches: Array<RegExp | string>): Promise<void>;
+    static appendToFileWithSpacing(file: string, textToInsert: string): string;
+    static dirExists(path: string): Promise<boolean>;
+    static fileExists(path: string): Promise<boolean>;
+    static exists(path: string): Promise<boolean>;
+    static checkDirExistsOrThrowIfFile(path: string): Promise<boolean>;
+    static createDirIfNotExists(path: string): Promise<void>;
+    private static calculateEndingNewLines;
+}