codify-plugin-lib 1.0.182-beta7 → 1.0.182-beta71

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codify-plugin-lib",
-  "version": "1.0.182-beta7",
+  "version": "1.0.182-beta71",
   "description": "Library plugin library",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -11,7 +11,7 @@
     "prepublishOnly": "tsc"
   },
   "bin": {
-    "codify-deploy": "./dist/bin/deploy-plugin.js"
+    "codify-build": "./bin/build.js"
   },
   "keywords": [],
   "author": "",
@@ -22,11 +22,12 @@
     "ajv": "^8.12.0",
     "ajv-formats": "^2.1.1",
     "clean-deep": "^3.4.0",
-    "codify-schemas": "1.0.86",
+    "codify-schemas": "1.0.86-beta11",
     "lodash.isequal": "^4.5.0",
     "nanoid": "^5.0.9",
     "strip-ansi": "^7.1.0",
-    "uuid": "^10.0.0"
+    "uuid": "^10.0.0",
+    "zod": "4.1.13"
   },
   "devDependencies": {
     "@apidevtools/json-schema-ref-parser": "^11.7.2",

package/rollup.config.js

@@ -0,0 +1,24 @@
+import commonjs from '@rollup/plugin-commonjs';
+import json from '@rollup/plugin-json';
+import nodeResolve from '@rollup/plugin-node-resolve';
+import terser from '@rollup/plugin-terser';
+import typescript from '@rollup/plugin-typescript';
+
+export default {
+  input: 'src/index.ts',
+  output: {
+    dir: 'dist',
+    format: 'cjs',
+    inlineDynamicImports: true,
+  },
+  external: ['@homebridge/node-pty-prebuilt-multiarch'],
+  plugins: [
+    json(),
+    nodeResolve({ exportConditions: ['node'] }),
+    typescript({
+      exclude: ['**/*.test.ts', '**/*.d.ts', 'test']
+    }),
+    commonjs(),
+    terser()
+  ]
+}

package/src/index.ts

@@ -7,7 +7,9 @@ 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'
@@ -16,6 +18,7 @@ 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: Plugin) {
   const messageHandler = new MessageHandler(plugin);

package/src/messages/handlers.test.ts

@@ -235,6 +235,29 @@ describe('Message handler tests', () => {
     process.send = undefined;
   })
 
+  it('handles changing the verbosity level', async () => {
+    const resource = new TestResource()
+    const plugin = testPlugin(resource);
+    const handler = new MessageHandler(plugin);
+
+    process.send = (message) => {
+      expect(message).toMatchObject({
+        cmd: 'setVerbosityLevel_Response',
+        status: MessageStatus.SUCCESS,
+      })
+      return true;
+    }
+
+    expect(async () => await handler.onMessage({
+      cmd: 'setVerbosityLevel',
+      data: {
+        verbosityLevel: 2,
+      }
+    })).rejects.to.not.throw;
+
+    process.send = undefined;
+  })
+
   it('Supports ipc message v2 (success)', async () => {
     const resource = new TestResource()
     const plugin = testPlugin(resource);

package/src/messages/handlers.ts

@@ -2,7 +2,7 @@ import { Ajv, SchemaObject, ValidateFunction } from 'ajv';
 import addFormats from 'ajv-formats';
 import {
   ApplyRequestDataSchema,
-  ApplyResponseDataSchema,
+  EmptyResponseDataSchema,
   GetResourceInfoRequestDataSchema,
   GetResourceInfoResponseDataSchema,
   ImportRequestDataSchema,
@@ -19,6 +19,7 @@ import {
   PlanRequestDataSchema,
   PlanResponseDataSchema,
   ResourceSchema,
+  SetVerbosityRequestDataSchema,
   ValidateRequestDataSchema,
   ValidateResponseDataSchema
 } from 'codify-schemas';
@@ -42,6 +43,14 @@ const SupportedRequests: Record<string, { handler: (plugin: Plugin, data: any) =
     requestValidator: GetResourceInfoRequestDataSchema,
     responseValidator: GetResourceInfoResponseDataSchema
   },
+  'setVerbosityLevel': {
+    async handler(plugin: Plugin, data: any) {
+      await plugin.setVerbosityLevel(data)
+      return null;
+    },
+    requestValidator: SetVerbosityRequestDataSchema,
+    responseValidator: EmptyResponseDataSchema,
+  },
   'match': {
     handler: async (plugin: Plugin, data: any) => plugin.match(data),
     requestValidator: MatchRequestDataSchema,
@@ -63,7 +72,7 @@ const SupportedRequests: Record<string, { handler: (plugin: Plugin, data: any) =
       return null;
     },
     requestValidator: ApplyRequestDataSchema,
-    responseValidator: ApplyResponseDataSchema
+    responseValidator: EmptyResponseDataSchema
   },
 }
 

package/src/plan/plan.test.ts

@@ -180,6 +180,52 @@ describe('Plan entity tests', () => {
     expect(plan.changeSet.operation).to.eq(ResourceOperation.NOOP);
   })
 
+  it('Filters array parameters in delete mode (when desired is null)', async () => {
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<any> {
+        return {
+          id: 'type',
+          operatingSystems: [OS.Darwin],
+          parameterSettings: {
+            propZ: { type: 'array', isElementEqual: (a, b) => b.includes(a) }
+          }
+        }
+      }
+
+      async refresh(): Promise<Partial<any> | null> {
+        return {
+          propZ: [
+            '20.15.0',
+            '20.15.1'
+          ]
+        }
+      }
+    }
+
+    const controller = new ResourceController(resource);
+    const plan = await controller.plan(
+      { type: 'type' },
+      null,
+      { propZ: ['20.15.0'], } as any,
+      true
+    )
+
+    console.log(JSON.stringify(plan, null, 2));
+    expect(plan).toMatchObject({
+      id: expect.any(String),
+      changeSet: expect.objectContaining({
+        operation: ResourceOperation.DESTROY,
+        parameterChanges: [
+          expect.objectContaining({ operation: 'remove', name: 'propZ', previousValue: ['20.15.0'], newValue: null }),
+        ],
+      }),
+      coreParameters: expect.objectContaining({
+        type: 'type',
+      }),
+      isStateful: true,
+    })
+  })
+
   it('Doesn\'t filters array parameters if filtering is disabled', async () => {
     const resource = new class extends TestResource {
       getSettings(): ResourceSettings<any> {

package/src/plan/plan.ts

@@ -307,6 +307,8 @@ export class Plan<T extends StringIndexedObject> {
     settings: ResourceSettings<T>,
     isStateful: boolean,
   }): Partial<T> | null {
+    console.log('Filter current params', params.desired, params.current, params.state, params.settings, params.isStateful)
+
     const {
       desired,
       current,
@@ -324,19 +326,37 @@ export class Plan<T extends StringIndexedObject> {
       return null
     }
 
+    console.log('Before exit', isStateful, desired);
+
     // For stateful mode, we're done after filtering by the keys of desired + state. Stateless mode
     // requires additional filtering for stateful parameter arrays and objects.
-    if (isStateful) {
+    if (isStateful && desired) {
       return filteredCurrent;
     }
 
+    // We also want to filter parameters when in delete mode. We don't want to delete parameters that
+    // are not specified in the original config.
+    if (isStateful && !desired) {
+      const arrayStatefulParameters = Object.fromEntries(
+        Object.entries(filteredCurrent)
+          .filter(([k, v]) => isArrayParameterWithFiltering(k, v))
+          .map(([k, v]) => [k, filterArrayParameterForDeletes(k, v)])
+      )
+
+      return { ...filteredCurrent, ...arrayStatefulParameters }
+    }
+
+    console.log('Post exit', isStateful, desired);
+
     // TODO: Add object handling here in addition to arrays in the future
     const arrayStatefulParameters = Object.fromEntries(
       Object.entries(filteredCurrent)
         .filter(([k, v]) => isArrayParameterWithFiltering(k, v))
-        .map(([k, v]) => [k, filterArrayStatefulParameter(k, v)])
+        .map(([k, v]) => [k, filterArrayParameterForStatelessMode(k, v)])
     )
 
+    console.log('Result', { ...filteredCurrent, ...arrayStatefulParameters });
+
     return { ...filteredCurrent, ...arrayStatefulParameters }
 
     function filterCurrent(): Partial<T> | null {
@@ -378,7 +398,7 @@ export class Plan<T extends StringIndexedObject> {
 
     function isArrayParameterWithFiltering(k: string, v: T[keyof T]): boolean {
       const filterParameter = getFilterParameter(k);
-      
+
       if (settings.parameterSettings?.[k]?.type === 'stateful') {
         const statefulSetting = settings.parameterSettings[k] as ParsedStatefulParameterSetting;
         return statefulSetting.nestedSettings.type === 'array' &&
@@ -392,7 +412,9 @@ export class Plan<T extends StringIndexedObject> {
     }
 
     // For stateless mode, we must filter the current array so that the diff algorithm will not detect any deletes
-    function filterArrayStatefulParameter(k: string, v: unknown[]): unknown[] {
+    function filterArrayParameterForStatelessMode(k: string, v: unknown[]): unknown[] {
+      console.log('Attempting to filter (key, value)', k, v);
+
       const desiredArray = desired![k] as unknown[];
       const matcher = settings.parameterSettings![k]!.type === 'stateful'
         ? ((settings.parameterSettings![k] as ParsedStatefulParameterSetting)
@@ -427,6 +449,45 @@ export class Plan<T extends StringIndexedObject> {
         ? filterParameter(desiredCopy, currentCopy)
         : defaultFilterMethod(desiredCopy, currentCopy);
     }
+
+    function filterArrayParameterForDeletes(k: string, v: unknown[]): unknown[] {
+      console.log('Attempting to filter (key, value)', k, v);
+
+      const stateArray = state![k] as unknown[];
+      const matcher = settings.parameterSettings![k]!.type === 'stateful'
+        ? ((settings.parameterSettings![k] as ParsedStatefulParameterSetting)
+          .nestedSettings as ParsedArrayParameterSetting)
+          .isElementEqual
+        : (settings.parameterSettings![k] as ParsedArrayParameterSetting)
+          .isElementEqual
+
+      const stateCopy = [...stateArray];
+      const currentCopy = [...v];
+
+      const defaultFilterMethod = ((state: any[], current: any[]) => {
+        const result = [];
+
+        for (let counter = state.length - 1; counter >= 0; counter--) {
+          const idx = currentCopy.findIndex((e2) => matcher(state[counter], e2))
+
+          if (idx === -1) {
+            continue;
+          }
+
+          state.splice(counter, 1)
+          const [element] = current.splice(idx, 1)
+          result.push(element)
+        }
+
+        return result;
+      })
+
+
+      const filterParameter = getFilterParameter(k);
+      return typeof filterParameter === 'function'
+        ? filterParameter(stateCopy, currentCopy)
+        : defaultFilterMethod(stateCopy, currentCopy);
+    }
   }
 
   // TODO: This needs to be revisited. I don't think this is valid anymore.

package/src/plugin/plugin.test.ts

@@ -7,6 +7,7 @@ import { spy } from 'sinon';
 import { ResourceSettings } from '../resource/resource-settings.js';
 import { TestConfig, TestStatefulParameter } from '../utils/test-utils.test.js';
 import { getPty } from '../pty/index.js';
+import { z } from 'zod';
 
 interface TestConfig extends StringIndexedObject {
   propA: string;
@@ -170,6 +171,36 @@ describe('Plugin tests', () => {
     })
   })
 
+  it('Can get resource info (zod schema)', async () => {
+    const schema = z
+      .object({
+        plugins: z
+          .array(z.string())
+          .describe(
+            'Asdf plugins to install. See: https://github.com/asdf-community for a full list'
+          )
+      })
+      .strict()
+
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'typeId',
+          operatingSystems: [OS.Darwin],
+          schema,
+        }
+      }
+    }
+    const testPlugin = Plugin.create('testPlugin', [resource as any])
+
+    const resourceInfo = await testPlugin.getResourceInfo({ type: 'typeId' })
+    expect(resourceInfo.import).toMatchObject({
+      requiredParameters: [
+        'plugins'
+      ]
+    })
+  })
+
   it('Get resource info to default import to the one specified in the resource settings', async () => {
     const schema = {
       '$schema': 'http://json-schema.org/draft-07/schema',

package/src/plugin/plugin.ts

@@ -12,7 +12,7 @@ import {
   PlanRequestData,
   PlanResponseData,
   ResourceConfig,
-  ResourceJson,
+  ResourceJson, SetVerbosityRequestData,
   ValidateRequestData,
   ValidateResponseData
 } from 'codify-schemas';
@@ -77,6 +77,7 @@ export class Plugin {
             type: r.typeId,
             sensitiveParameters,
             operatingSystems: r.settings.operatingSystems,
+            linuxDistros: r.settings.linuxDistros,
           }
         })
     }
@@ -89,7 +90,7 @@ export class Plugin {
 
     const resource = this.resourceControllers.get(data.type)!;
 
-    const schema = resource.settings.schema as JSONSchemaType<any> | undefined;
+    const schema = resource.parsedSettings.schema as JSONSchemaType<any> | undefined;
     const requiredPropertyNames = (
       resource.settings.importAndDestroy?.requiredParameters
       ?? (typeof resource.settings.allowMultiple === 'object' ? resource.settings.allowMultiple.identifyingParameters : null)
@@ -124,6 +125,7 @@ export class Plugin {
         requiredParameters: requiredPropertyNames,
       },
       operatingSystems: resource.settings.operatingSystems,
+      linuxDistros: resource.settings.linuxDistros,
       sensitiveParameters,
       allowMultiple
     }
@@ -257,6 +259,10 @@ export class Plugin {
     }
   }
 
+  async setVerbosityLevel(data: SetVerbosityRequestData): Promise<void> {
+    VerbosityLevel.set(data.verbosityLevel);
+  }
+
   async kill() {
     await this.planPty.kill();
   }

package/src/pty/background-pty.ts

@@ -20,8 +20,11 @@ EventEmitter.defaultMaxListeners = 1000;
  * without a tty (or even a stdin) attached so interactive commands will not work.
  */
 export class BackgroundPty implements IPty {
+  private historyIgnore = Utils.getShell() === Shell.ZSH ? { HISTORY_IGNORE: '*' } : { HISTIGNORE: '*' };
   private basePty = pty.spawn(this.getDefaultShell(), ['-i'], {
-    env: process.env, name: nanoid(6),
+    env: { ...process.env, ...this.historyIgnore },
+    cols: 10_000, // Set to a really large value to prevent wrapping
+    name: nanoid(6),
     handleFlowControl: true
   });
 
@@ -31,17 +34,19 @@ export class BackgroundPty implements IPty {
     this.initialize();
   }
 
-  async spawn(cmd: string, options?: SpawnOptions): Promise<SpawnResult> {
+  async spawn(cmd: string | string[], options?: SpawnOptions): Promise<SpawnResult> {
     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: string, options?: SpawnOptions): Promise<SpawnResult> {
+  async spawnSafe(cmd: string | string[], options?: SpawnOptions): Promise<SpawnResult> {
+    cmd = Array.isArray(cmd) ? cmd.join('\\\n') : cmd;
+
     // cid is command id
     const cid = nanoid(10);
     debugLog(cid);
@@ -102,7 +107,7 @@ export class BackgroundPty implements IPty {
           }
         });
 
-        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`);
 
       }));
@@ -128,19 +133,6 @@ export class BackgroundPty implements IPty {
       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/src/pty/index.ts

@@ -25,11 +25,17 @@ export enum SpawnStatus {
  *
  * @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,
+  env?: Record<string, unknown>;
+  interactive?: boolean;
+  requiresRoot?: boolean;
+  stdin?: boolean;
+  disableWrapping?: boolean;
 }
 
 export class SpawnError extends Error {
@@ -48,9 +54,9 @@ export class SpawnError extends Error {
 }
 
 export interface IPty {
-  spawn(cmd: string, options?: SpawnOptions): Promise<SpawnResult>
+  spawn(cmd: string | string[], options?: SpawnOptions): Promise<SpawnResult>
 
-  spawnSafe(cmd: string, options?: SpawnOptions): Promise<SpawnResult>
+  spawnSafe(cmd: string | string[], options?: SpawnOptions): Promise<SpawnResult>
 
   kill(): Promise<{ exitCode: number, signal?: number | undefined }>
 }

package/src/pty/seqeuntial-pty.ts

@@ -1,4 +1,7 @@
 import pty from '@homebridge/node-pty-prebuilt-multiarch';
+import { Ajv } from 'ajv';
+import { CommandRequestResponseData, CommandRequestResponseDataSchema, IpcMessageV2, MessageCmd } from 'codify-schemas';
+import { nanoid } from 'nanoid';
 import { EventEmitter } from 'node:events';
 import stripAnsi from 'strip-ansi';
 
@@ -8,6 +11,11 @@ import { IPty, SpawnError, SpawnOptions, SpawnResult, SpawnStatus } from './inde
 
 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,22 +23,32 @@ EventEmitter.defaultMaxListeners = 1000;
  * without a tty (or even a stdin) attached so interactive commands will not work.
  */
 export class SequentialPty implements IPty {
-  async spawn(cmd: string, options?: SpawnOptions): Promise<SpawnResult> {
+  async spawn(cmd: string | string[], options?: SpawnOptions): Promise<SpawnResult> {
     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: string, options?: SpawnOptions): Promise<SpawnResult> {
-    console.log(`Running command: ${cmd}` + (options?.cwd ? `(${options?.cwd})` : ''))
+  async spawnSafe(cmd: string | string[], options?: SpawnOptions): Promise<SpawnResult> {
+    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: string[] = [];
-
       const historyIgnore = Utils.getShell() === Shell.ZSH ? { HISTORY_IGNORE: '*' } : { HISTIGNORE: '*' };
 
       // If TERM_PROGRAM=Apple_Terminal is set then ANSI escape characters may be included
@@ -39,14 +57,16 @@ export class SequentialPty implements IPty {
         ...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;
+      // 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 ?? 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, {
@@ -64,23 +84,16 @@ export class SequentialPty implements IPty {
         output.push(data.toString());
       })
 
-      const stdinListener = (data: any) => {
-        mPty.write(data.toString());
-      };
-
       const resizeListener = () => {
         const { columns, rows } = process.stdout;
-        mPty.resize(columns, rows);
+        mPty.resize(columns, options?.disableWrapping ? 10_000 : 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,
@@ -99,6 +112,39 @@ export class SequentialPty implements IPty {
     }
   }
 
+  // For safety reasons, requests that require sudo or are interactive must be run via the main client
+  async externalSpawn(
+    cmd: string,
+    opts: SpawnOptions
+  ): Promise<SpawnResult> {
+    return new Promise((resolve) => {
+      const requestId = nanoid(8);
+
+      const listener = (data: IpcMessageV2) => {
+        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 as unknown as CommandRequestResponseData);
+        }
+      }
+
+      process.on('message', listener);
+
+      process.send!(<IpcMessageV2>{
+        cmd: MessageCmd.COMMAND_REQUEST,
+        data: {
+          command: cmd,
+          options: opts ?? {},
+        },
+        requestId
+      })
+    });
+  }
+
   private getDefaultShell(): string {
     return process.env.SHELL!;
   }