codify-plugin-lib 1.0.181 → 1.0.182-beta10

package/src/pty/seqeuntial-pty.ts

@@ -0,0 +1,148 @@
+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';
+
+import { Shell, Utils } from '../utils/index.js';
+import { VerbosityLevel } from '../utils/verbosity-level.js';
+import { IPty, SpawnError, SpawnOptions, SpawnResult, 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
+ * to listen to stdout and stderr. One limitation of the BackgroundPty is that the tasks run
+ * 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> {
+    const spawnResult = await this.spawnSafe(cmd, options);
+
+    if (spawnResult.status !== 'success') {
+      throw new SpawnError(cmd, spawnResult.exitCode, spawnResult.data);
+    }
+
+    return spawnResult;
+  }
+
+  async spawnSafe(cmd: string, options?: SpawnOptions): Promise<SpawnResult> {
+    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: ${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
+      // in the response.
+      const env = {
+        ...process.env, ...options?.env,
+        TERM_PROGRAM: 'codify',
+        COMMAND_MODE: 'unix2003',
+        COLORTERM: 'truecolor',
+        ...historyIgnore
+      }
+
+      // Initial terminal dimensions
+      const initialCols = process.stdout.columns ?? 80;
+      const initialRows = process.stdout.rows ?? 24;
+
+      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,
+        cols: initialCols,
+        rows: initialRows,
+        env
+      });
+
+      mPty.onData((data) => {
+        if (VerbosityLevel.get() > 0) {
+          process.stdout.write(data);
+        }
+
+        output.push(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);
+
+      mPty.onExit((result) => {
+        process.stdout.off('resize', resizeListener);
+
+        resolve({
+          status: result.exitCode === 0 ? SpawnStatus.SUCCESS : SpawnStatus.ERROR,
+          exitCode: result.exitCode,
+          data: stripAnsi(output.join('\n').trim()),
+        })
+      })
+    })
+  }
+
+  async kill(): Promise<{ exitCode: number, signal?: number | undefined }> {
+    // No-op here. Each pty instance is stand alone and tied to the parent process. Everything should be killed as expected.
+    return {
+      exitCode: 0,
+      signal: 0,
+    }
+  }
+
+  // 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

@@ -0,0 +1,179 @@
+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 () => {
+    const pty = new SequentialPty();
+
+    VerbosityLevel.set(1);
+
+    const result = await pty.spawnSafe('ls');
+    expect(result).toMatchObject({
+      status: 'success',
+      exitCode: 0,
+      data: expect.any(String),
+    })
+
+    const exitCode = await pty.kill();
+    expect(exitCode).toMatchObject({
+      exitCode: 0,
+    });
+  })
+
+  it('Reports back the correct exit code and status', async () => {
+    const pty = new SequentialPty();
+
+    const resultSuccess = await pty.spawnSafe('ls');
+    expect(resultSuccess).toMatchObject({
+      status: 'success',
+      exitCode: 0,
+    })
+
+    const resultFailed = await pty.spawnSafe('which sjkdhsakjdhjkash');
+    expect(resultFailed).toMatchObject({
+      status: 'error',
+      exitCode: 1,
+      data: 'sjkdhsakjdhjkash not found' // This might change on different os or shells. Keep for now.
+    })
+  });
+
+  it('Can use a different cwd', async () => {
+    const pty = new SequentialPty();
+
+    const resultSuccess = await pty.spawnSafe('pwd', { cwd: '/tmp' });
+    expect(resultSuccess).toMatchObject({
+      status: 'success',
+      exitCode: 0,
+      data: '/tmp'
+    })
+  });
+
+  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.ts

@@ -1,5 +1,5 @@
 import { JSONSchemaType } from 'ajv';
-import { StringIndexedObject } from 'codify-schemas';
+import { OS, StringIndexedObject } from 'codify-schemas';
 
 import { StatefulParameterController } from '../stateful-parameter/stateful-parameter-controller.js';
 import {
@@ -46,16 +46,17 @@ export class ParsedResourceSettings<T extends StringIndexedObject> implements Re
   removeStatefulParametersBeforeDestroy?: boolean | undefined;
   dependencies?: string[] | undefined;
   transformation?: InputTransformation;
+
+  operatingSystems!: Array<OS>;
+  isSensitive?: boolean;
+
   private settings: ResourceSettings<T>;
 
   constructor(settings: ResourceSettings<T>) {
     this.settings = settings;
-    this.id = settings.id;
-    this.schema = settings.schema;
-    this.allowMultiple = settings.allowMultiple;
-    this.removeStatefulParametersBeforeDestroy = settings.removeStatefulParametersBeforeDestroy;
-    this.dependencies = settings.dependencies;
-    this.transformation = settings.transformation;
+
+    const { parameterSettings, ...rest } = settings;
+    Object.assign(this, rest);
 
     this.validateSettings();
   }

package/src/resource/resource-controller-stateful-mode.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { ParameterOperation, ResourceOperation } from 'codify-schemas';
+import { OS, ParameterOperation, ResourceOperation } from 'codify-schemas';
 import { TestConfig, TestResource, TestStatefulParameter } from '../utils/test-utils.test.js';
 import { ResourceSettings } from './resource-settings.js';
 import { ResourceController } from './resource-controller.js';
@@ -179,6 +179,7 @@ describe('Resource tests for stateful plans', () => {
       getSettings(): ResourceSettings<TestConfig> {
         return {
           id: 'type',
+          operatingSystems: [OS.Darwin],
           parameterSettings: {
             propD: { type: 'stateful', definition: statefulParameter },
           }

package/src/resource/resource-controller.test.ts

@@ -1,5 +1,5 @@
 import { Resource } from './resource.js';
-import { ResourceOperation } from 'codify-schemas';
+import { OS, ResourceOperation } from 'codify-schemas';
 import { spy } from 'sinon';
 import { describe, expect, it } from 'vitest'
 import { ArrayParameterSetting, ParameterSetting, ResourceSettings } from './resource-settings.js';
@@ -7,7 +7,7 @@ import { CreatePlan, DestroyPlan, ModifyPlan } from '../plan/plan-types.js';
 import { ParameterChange } from '../plan/change-set.js';
 import { ResourceController } from './resource-controller.js';
 import { TestConfig, testPlan, TestResource, TestStatefulParameter } from '../utils/test-utils.test.js';
-import { tildify, untildify } from '../utils/utils.js';
+import { tildify, untildify } from '../utils/functions.js';
 import { ArrayStatefulParameter, StatefulParameter } from '../stateful-parameter/stateful-parameter.js';
 import { Plan } from '../plan/plan.js';
 import os from 'node:os';
@@ -19,6 +19,7 @@ describe('Resource tests', () => {
       getSettings(): ResourceSettings<TestConfig> {
         return {
           id: 'type',
+          operatingSystems: [OS.Darwin],
           dependencies: ['homebrew', 'python'],
           parameterSettings: {
             propA: {
@@ -197,6 +198,7 @@ describe('Resource tests', () => {
       getSettings(): ResourceSettings<TestConfig> {
         return {
           id: 'resource',
+          operatingSystems: [OS.Darwin],
           parameterSettings: {
             propA: { canModify: true },
             propB: { canModify: true },
@@ -232,6 +234,7 @@ describe('Resource tests', () => {
       getSettings(): ResourceSettings<TestConfig> {
         return {
           id: 'type',
+          operatingSystems: [OS.Darwin],
           dependencies: ['homebrew', 'python'],
           parameterSettings: {
             propA: { canModify: true },
@@ -254,6 +257,7 @@ describe('Resource tests', () => {
       getSettings(): ResourceSettings<TestConfig> {
         return {
           id: 'type',
+          operatingSystems: [OS.Darwin],
           dependencies: ['homebrew', 'python'],
           parameterSettings: {
             propA: { canModify: true },
@@ -270,6 +274,7 @@ describe('Resource tests', () => {
       getSettings(): ResourceSettings<TestConfig> {
         return {
           id: 'type',
+          operatingSystems: [OS.Darwin],
           parameterSettings: {
             propA: { default: 'propADefault' }
           }
@@ -298,6 +303,7 @@ describe('Resource tests', () => {
       getSettings(): ResourceSettings<TestConfig> {
         return {
           id: 'type',
+          operatingSystems: [OS.Darwin],
           parameterSettings: {
             propE: { default: 'propEDefault' }
           }
@@ -325,6 +331,7 @@ describe('Resource tests', () => {
       getSettings(): ResourceSettings<TestConfig> {
         return {
           id: 'type',
+          operatingSystems: [OS.Darwin],
           parameterSettings: {
             propE: { default: 'propEDefault' }
           }
@@ -348,6 +355,7 @@ describe('Resource tests', () => {
       getSettings(): ResourceSettings<TestConfig> {
         return {
           id: 'type',
+          operatingSystems: [OS.Darwin],
           parameterSettings: {
             propA: { default: 'propADefault' }
           }
@@ -376,6 +384,7 @@ describe('Resource tests', () => {
       getSettings(): ResourceSettings<TestConfig> {
         return {
           id: 'type',
+          operatingSystems: [OS.Darwin],
           parameterSettings: {
             propA: { default: 'propADefault' }
           }
@@ -392,7 +401,7 @@ describe('Resource tests', () => {
   it('Has the correct typing for applys', () => {
     const resource = new class extends Resource<TestConfig> {
       getSettings(): ResourceSettings<TestConfig> {
-        return { id: 'type' }
+        return { id: 'type', operatingSystems: [OS.Darwin], }
       }
 
       async refresh(): Promise<Partial<TestConfig> | null> {
@@ -418,7 +427,8 @@ describe('Resource tests', () => {
     const parameter1 = new class extends StatefulParameter<any, any> {
       getSettings(): ParameterSetting {
         return {
-          type: 'version'
+          type: 'version',
+          operatingSystems: [OS.Darwin],
         }
       }
 
@@ -462,6 +472,7 @@ describe('Resource tests', () => {
       getSettings(): ResourceSettings<TestConfig> {
         return {
           id: 'nvm',
+          operatingSystems: [OS.Darwin],
           parameterSettings: {
             global: { type: 'stateful', definition: parameter1, order: 2 },
             nodeVersions: { type: 'stateful', definition: parameter2, order: 1 },
@@ -514,6 +525,7 @@ describe('Resource tests', () => {
       getSettings(): ResourceSettings<TestConfig> {
         return {
           id: 'nvm',
+          operatingSystems: [OS.Darwin],
           parameterSettings: {
             global: { type: 'stateful', definition: parameter1, order: 2 },
             nodeVersions: { type: 'stateful', definition: parameter2, order: 1 },
@@ -546,6 +558,7 @@ describe('Resource tests', () => {
       getSettings(): ResourceSettings<TestConfig> {
         return {
           id: 'resourceType',
+          operatingSystems: [OS.Darwin],
           parameterSettings: {
             propD: {
               type: 'array',
@@ -630,6 +643,7 @@ describe('Resource tests', () => {
       getSettings(): ResourceSettings<TestConfig> {
         return {
           id: 'resourceType',
+          operatingSystems: [OS.Darwin],
           parameterSettings: {
             propD: {
               type: 'array',
@@ -720,6 +734,7 @@ describe('Resource tests', () => {
       getSettings(): ResourceSettings<TestConfig> {
         return {
           id: 'resourceType',
+          operatingSystems: [OS.Darwin],
           parameterSettings: {
             propA: { type: 'string', default: 'defaultValue' },
             propB: { type: 'boolean', default: true }
@@ -755,6 +770,7 @@ describe('Resource tests', () => {
       getSettings(): ResourceSettings<any> {
         return {
           id: 'path',
+          operatingSystems: [OS.Darwin],
           parameterSettings: {
             path: { type: 'string', isEqual: 'directory' },
             paths: { canModify: true, type: 'array', isElementEqual: 'directory' },
@@ -797,6 +813,7 @@ describe('Resource tests', () => {
       getSettings(): ResourceSettings<any> {
         return {
           id: 'path',
+          operatingSystems: [OS.Darwin],
           parameterSettings: {
             path: { type: 'string', isEqual: 'directory' },
             paths: { canModify: true, type: 'array', isElementEqual: 'directory' },
@@ -840,6 +857,7 @@ describe('Resource tests', () => {
       getSettings(): ResourceSettings<any> {
         return {
           id: 'path',
+          operatingSystems: [OS.Darwin],
           parameterSettings: {
             path: { type: 'directory' },
             paths: { canModify: true, type: 'array', itemType: 'directory' },