codify-plugin-lib 1.0.182-beta7 → 1.0.182-beta70

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.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,12 +326,18 @@ 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) {
+    // 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) {
       return filteredCurrent;
     }
 
+    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)
@@ -337,6 +345,8 @@ export class Plan<T extends StringIndexedObject> {
         .map(([k, v]) => [k, filterArrayStatefulParameter(k, v)])
     )
 
+    console.log('Result', { ...filteredCurrent, ...arrayStatefulParameters });
+
     return { ...filteredCurrent, ...arrayStatefulParameters }
 
     function filterCurrent(): Partial<T> | null {

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!;
   }

package/src/pty/sequential-pty.test.ts

@@ -1,6 +1,8 @@
 import { describe, expect, it } from 'vitest';
 import { SequentialPty } from './seqeuntial-pty.js';
 import { VerbosityLevel } from '../utils/verbosity-level.js';
+import { MessageStatus, SpawnStatus } from 'codify-schemas/src/types/index.js';
+import { IpcMessageV2, MessageCmd } from 'codify-schemas';
 
 describe('SequentialPty tests', () => {
   it('Can launch a simple command', async () => {
@@ -33,8 +35,8 @@ describe('SequentialPty tests', () => {
     const resultFailed = await pty.spawnSafe('which sjkdhsakjdhjkash');
     expect(resultFailed).toMatchObject({
       status: 'error',
-      exitCode: 127,
-      data: 'zsh:1: command not found: which sjkdhsakjdhjkash' // This might change on different os or shells. Keep for now.
+      exitCode: 1,
+      data: 'sjkdhsakjdhjkash not found' // This might change on different os or shells. Keep for now.
     })
   });
 
@@ -49,13 +51,144 @@ describe('SequentialPty tests', () => {
     })
   });
 
-  it('It can launch a command in interactive mode', async () => {
+
+  it('Can use multi-line commands', async () => {
     const pty = new SequentialPty();
 
-    const resultSuccess = await pty.spawnSafe('ls', { interactive: true });
+    const resultSuccess = await pty.spawnSafe([
+      'pwd',
+      '&& ls',
+    ], { cwd: '/tmp' });
     expect(resultSuccess).toMatchObject({
       status: 'success',
       exitCode: 0,
     })
   });
+
+
+  it('It can launch a command in interactive mode', async () => {
+    const originalSend = process.send;
+    process.send = (req: IpcMessageV2) => {
+      expect(req).toMatchObject({
+        cmd: MessageCmd.COMMAND_REQUEST,
+        requestId: expect.any(String),
+        data: {
+          command: 'ls',
+          options: {
+            cwd: '/tmp',
+            interactive: true,
+          }
+        }
+      })
+
+      // This may look confusing but what we're doing here is directly finding the process listener and calling it without going through serialization
+      const listeners = process.listeners('message');
+      listeners[2](({
+        cmd: MessageCmd.COMMAND_REQUEST,
+        requestId: req.requestId,
+        status: MessageStatus.SUCCESS,
+        data: {
+          status: SpawnStatus.SUCCESS,
+          exitCode: 0,
+          data: 'My data',
+        }
+      }))
+
+      return true;
+    }
+
+    const $ = new SequentialPty();
+    const resultSuccess = await $.spawnSafe('ls', { interactive: true, cwd: '/tmp' });
+
+    expect(resultSuccess).toMatchObject({
+      status: 'success',
+      exitCode: 0,
+    });
+
+    process.send = originalSend;
+  });
+
+  it('It can work with root (sudo)', async () => {
+    const originalSend = process.send;
+    process.send = (req: IpcMessageV2) => {
+      expect(req).toMatchObject({
+        cmd: MessageCmd.COMMAND_REQUEST,
+        requestId: expect.any(String),
+        data: {
+          command: 'ls',
+          options: {
+            interactive: true,
+            requiresRoot: true,
+          }
+        }
+      })
+
+      // This may look confusing but what we're doing here is directly finding the process listener and calling it without going through serialization
+      const listeners = process.listeners('message');
+      listeners[2](({
+        cmd: MessageCmd.COMMAND_REQUEST,
+        requestId: req.requestId,
+        status: MessageStatus.SUCCESS,
+        data: {
+          status: SpawnStatus.SUCCESS,
+          exitCode: 0,
+          data: 'My data',
+        }
+      }))
+
+      return true;
+    }
+
+    const $ = new SequentialPty();
+    const resultSuccess = await $.spawn('ls', { interactive: true, requiresRoot: true });
+
+    expect(resultSuccess).toMatchObject({
+      status: 'success',
+      exitCode: 0,
+    });
+
+    process.send = originalSend;
+  })
+
+  it('It can handle errors when in sudo', async () => {
+    const originalSend = process.send;
+    process.send = (req: IpcMessageV2) => {
+      expect(req).toMatchObject({
+        cmd: MessageCmd.COMMAND_REQUEST,
+        requestId: expect.any(String),
+        data: {
+          command: 'ls',
+          options: {
+            requiresRoot: true,
+            interactive: true,
+          }
+        }
+      })
+
+      // This may look confusing but what we're doing here is directly finding the process listener and calling it without going through serialization
+      const listeners = process.listeners('message');
+      listeners[2](({
+        cmd: MessageCmd.COMMAND_REQUEST,
+        requestId: req.requestId,
+        status: MessageStatus.SUCCESS,
+        data: {
+          status: SpawnStatus.ERROR,
+          exitCode: 127,
+          data: 'My data',
+        }
+      }))
+
+      return true;
+    }
+
+    const $ = new SequentialPty();
+    const resultSuccess = await $.spawnSafe('ls', { interactive: true, requiresRoot: true });
+
+    expect(resultSuccess).toMatchObject({
+      status: SpawnStatus.ERROR,
+      exitCode: 127,
+    });
+
+    process.send = originalSend;
+  })
 })

package/src/resource/parsed-resource-settings.test.ts

@@ -2,6 +2,8 @@ import { describe, expect, it } from 'vitest';
 import { ResourceSettings } from './resource-settings.js';
 import { ParsedResourceSettings } from './parsed-resource-settings.js';
 import { TestConfig } from '../utils/test-utils.test.js';
+import { z } from 'zod';
+import { OS } from 'codify-schemas';
 
 describe('Resource options parser tests', () => {
   it('Parses default values from options', () => {
@@ -159,4 +161,26 @@ describe('Resource options parser tests', () => {
 
     expect(() => new ParsedResourceSettings(option)).toThrowError()
   })
+
+  it('Can handle a zod schema', () => {
+
+    const schema = z.object({
+      propA: z.string(),
+      repository: z.string(),
+    })
+
+    const option: ResourceSettings<z.infer<typeof schema>> = {
+      id: 'typeId',
+      operatingSystems: [OS.Darwin],
+      schema,
+      importAndDestroy: {
+        defaultRefreshValues: {
+          repository: 'abc'
+        }
+      }
+    }
+
+    console.log(new ParsedResourceSettings(option))
+
+  })
 })