codify-plugin-lib 1.0.182-beta2 → 1.0.182-beta21

package/src/pty/background-pty.ts

@@ -7,7 +7,7 @@ import stripAnsi from 'strip-ansi';
 
 import { debugLog } from '../utils/debug.js';
 import { Shell, Utils } from '../utils/index.js';
-import { VerbosityLevel } from '../utils/internal-utils.js';
+import { VerbosityLevel } from '../utils/verbosity-level.js';
 import { IPty, SpawnError, SpawnOptions, SpawnResult } from './index.js';
 import { PromiseQueue } from './promise-queue.js';
 
@@ -20,8 +20,10 @@ 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 },
+    name: nanoid(6),
     handleFlowControl: true
   });
 
@@ -102,7 +104,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 +130,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

@@ -28,8 +28,10 @@ export enum SpawnStatus {
  */
 export interface SpawnOptions {
   cwd?: string;
-  env?: Record<string, unknown>,
-  interactive?: boolean,
+  env?: Record<string, unknown>;
+  interactive?: boolean;
+  requiresRoot?: boolean;
+  stdin?: boolean;
 }
 
 export class SpawnError extends Error {

package/src/pty/seqeuntial-pty.ts

@@ -1,13 +1,21 @@
 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/internal-utils.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
@@ -26,11 +34,19 @@ export class SequentialPty implements IPty {
   }
 
   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
@@ -39,14 +55,15 @@ 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;
       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,10 +81,6 @@ 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);
@@ -75,12 +88,9 @@ export class SequentialPty implements IPty {
 
       // 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 +109,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/internal-utils.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.
     })
   });
 
@@ -50,12 +52,128 @@ describe('SequentialPty tests', () => {
   });
 
   it('It can launch a command in interactive mode', async () => {
-    const pty = new SequentialPty();
+    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' });
 
-    const resultSuccess = await pty.spawnSafe('ls', { interactive: false });
     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/resource-controller.test.ts

@@ -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/internal-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';

package/src/resource/resource-settings.ts

@@ -10,7 +10,7 @@ import {
   resolvePathWithVariables,
   tildify,
   untildify
-} from '../utils/internal-utils.js';
+} from '../utils/functions.js';
 import { RefreshContext } from './resource.js';
 
 export interface InputTransformation {

package/src/utils/file-utils.test.ts

@@ -0,0 +1,7 @@
+import { describe, it } from 'vitest';
+
+describe('File utils tests', { timeout: 100_000_000 }, () => {
+  it('Can download a file', async () => {
+    // await FileUtils.downloadFile('https://download.jetbrains.com/webstorm/WebStorm-2025.3.1-aarch64.dmg?_gl=1*1huoi7o*_gcl_aw*R0NMLjE3NjU3NDAwMTcuQ2p3S0NBaUEzZm5KQmhBZ0Vpd0F5cW1ZNVhLVENlbHJOcTk2YXdjZVlfMS1wdE91MXc0WDk2bFJkVDM3QURhUFNJMUtwNVVSVUhxWTJob0NuZ0FRQXZEX0J3RQ..*_gcl_au*MjA0MDQ0MjE2My4xNzYzNjQzNzMz*FPAU*MjA0MDQ0MjE2My4xNzYzNjQzNzMz*_ga*MTYxMDg4MTkzMi4xNzYzNjQzNzMz*_ga_9J976DJZ68*czE3NjYzNjI5ODAkbzEyJGcxJHQxNzY2MzYzMDQwJGo2MCRsMCRoMA..', path.join(process.cwd(), 'google.html'));
+  })
+})

package/src/utils/file-utils.ts

@@ -0,0 +1,231 @@
+import * as fsSync from 'node:fs';
+import * as fs from 'node:fs/promises';
+import path from 'node:path';
+import { Readable } from 'node:stream';
+import { finished } from 'node:stream/promises';
+
+import { Utils } from './index.js';
+
+const SPACE_REGEX = /^\s*$/
+
+export class FileUtils {
+  static async downloadFile(url: string, destination: string): Promise<void> {
+    console.log(`Downloading file from ${url} to ${destination}`);
+    const { body } = await fetch(url)
+
+    const dirname = path.dirname(destination);
+    if (!await fs.stat(dirname).then((s) => s.isDirectory()).catch(() => false)) {
+      await fs.mkdir(dirname, { recursive: true });
+    }
+
+    const ws = fsSync.createWriteStream(destination)
+    // Different type definitions here for readable stream (NodeJS vs DOM). Small hack to fix that
+    await finished(Readable.fromWeb(body as never).pipe(ws));
+
+    console.log(`Finished downloading to ${destination}`);
+  }
+
+  static async addToShellRc(line: string): Promise<void> {
+    const lineToInsert = addLeadingSpacer(
+      addTrailingSpacer(line)
+    );
+
+    await fs.appendFile(Utils.getPrimaryShellRc(), lineToInsert)
+
+    function addLeadingSpacer(line: string): string {
+      return line.startsWith('\n')
+        ? line
+        : '\n' + line;
+    }
+
+    function addTrailingSpacer(line: string): string {
+      return line.endsWith('\n')
+        ? line
+        : line + '\n';
+    }
+  }
+
+  static async addAllToShellRc(lines: string[]): Promise<void> {
+    const formattedLines = '\n' + lines.join('\n') + '\n';
+    const shellRc = Utils.getPrimaryShellRc();
+
+    console.log(`Adding to ${path.basename(shellRc)}:
+${lines.join('\n')}`)
+
+    await fs.appendFile(shellRc, formattedLines)
+  }
+
+  /**
+   * 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 async addPathToShellRc(value: string, prepend: boolean): Promise<void> {
+    if (await Utils.isDirectoryOnPath(value)) {
+      return;
+    }
+
+    const shellRc = Utils.getPrimaryShellRc();
+    console.log(`Saving path: ${value} to ${shellRc}`);
+
+    if (prepend) {
+      await fs.appendFile(shellRc, `\nexport PATH=$PATH:${value};`, { encoding: 'utf8' });
+      return;
+    }
+
+    await fs.appendFile(shellRc, `\nexport PATH=${value}:$PATH;`, { encoding: 'utf8' });
+  }
+
+  static async removeFromFile(filePath: string, search: string): Promise<void> {
+    const contents = await fs.readFile(filePath, 'utf8');
+    const newContents = contents.replaceAll(search, '');
+
+    await fs.writeFile(filePath, newContents, 'utf8');
+  }
+
+  static async removeLineFromFile(filePath: string, search: RegExp | string): Promise<void> {
+    const file = await fs.readFile(filePath, 'utf8')
+    const lines = file.split('\n');
+
+    let searchRegex;
+    let searchString;
+
+    if (typeof search === 'object') {
+      const startRegex = /^([\t ]*)?/;
+      const endRegex = /([\t ]*)?/;
+
+      // Augment regex with spaces criteria to make sure this function is not deleting lines that are comments or has other content.
+      searchRegex = search
+        ? new RegExp(
+          startRegex.source + search.source + endRegex.source,
+          search.flags
+        )
+        : search;
+    }
+
+    if (typeof search === 'string') {
+      searchString = search;
+    }
+
+    for (let counter = lines.length; counter >= 0; counter--) {
+      if (!lines[counter]) {
+        continue;
+      }
+
+      if (searchString && lines[counter].includes(searchString)) {
+        lines.splice(counter, 1);
+        continue;
+      }
+
+      if (searchRegex && lines[counter].search(searchRegex) !== -1) {
+        lines.splice(counter, 1);
+      }
+    }
+
+    await fs.writeFile(filePath, lines.join('\n'));
+    console.log(`Removed line: ${search} from ${filePath}`)
+  }
+
+  static async removeLineFromShellRc(search: RegExp | string): Promise<void> {
+    return FileUtils.removeLineFromFile(Utils.getPrimaryShellRc(), search);
+  }
+
+  static async removeAllLinesFromShellRc(searches: Array<RegExp | string>): Promise<void> {
+    for (const search of searches) {
+      await FileUtils.removeLineFromFile(Utils.getPrimaryShellRc(), search);
+    }
+  }
+
+  // Append the string to the end of a file ensuring at least 1 lines of space between.
+  // Ex result:
+  // something something;
+  //
+  // newline;
+  static appendToFileWithSpacing(file: string, textToInsert: string): string {
+    const lines = file.trimEnd().split(/\n/);
+    if (lines.length === 0) {
+      return textToInsert;
+    }
+
+    const endingNewLines = FileUtils.calculateEndingNewLines(lines);
+    const numNewLines = endingNewLines === -1
+      ? 0
+      : Math.max(0, 2 - endingNewLines);
+    return lines.join('\n') + '\n'.repeat(numNewLines) + textToInsert
+  }
+
+  static async dirExists(path: string): Promise<boolean> {
+    let stat;
+    try {
+      stat = await fs.stat(path);
+      return stat.isDirectory();
+    } catch {
+      return false;
+    }
+  }
+
+  static async fileExists(path: string): Promise<boolean> {
+    let stat;
+    try {
+      stat = await fs.stat(path);
+      return stat.isFile();
+    } catch {
+      return false;
+    }
+  }
+
+  static async exists(path: string): Promise<boolean> {
+    try {
+      await fs.stat(path);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  static async checkDirExistsOrThrowIfFile(path: string): Promise<boolean> {
+    let stat;
+    try {
+      stat = await fs.stat(path);
+    } catch {
+      return false;
+    }
+
+    if (stat.isDirectory()) {
+      return true;
+    }
+
+    throw new Error(`Directory ${path} already exists and is a file`);
+  }
+
+  static async createDirIfNotExists(path: string): Promise<void> {
+    if (!fsSync.existsSync(path)) {
+      await fs.mkdir(path, { recursive: true });
+    }
+  }
+
+  // This is overly complicated but it can be used to insert into any
+  // position in the future
+  private static calculateEndingNewLines(lines: string[]): number {
+    let counter = 0;
+    while (true) {
+      const line = lines.at(-counter - 1);
+
+      if (!line) {
+        return -1
+      }
+
+      if (!SPACE_REGEX.test(line)) {
+        return counter;
+      }
+
+      counter++;
+
+      // Short circuit here because we don't need to check over 2;
+      if (counter > 2) {
+        return counter;
+      }
+    }
+  }
+}

package/src/utils/{internal-utils.ts → functions.ts}

@@ -2,22 +2,6 @@ import { ResourceConfig, StringIndexedObject } from 'codify-schemas';
 import os from 'node:os';
 import path from 'node:path';
 
-export const VerbosityLevel = new class {
-  level = 0;
-
-  get() {
-    return this.level;
-  }
-
-  set(level: number) {
-    this.level = level;
-  }
-}
-
-export function isDebug(): boolean {
-  return process.env.DEBUG != null && process.env.DEBUG.includes('codify'); // TODO: replace with debug library
-}
-
 export function splitUserConfig<T extends StringIndexedObject>(
   config: ResourceConfig & T
 ): { parameters: T; coreParameters: ResourceConfig } {

package/src/utils/index.ts

@@ -1,6 +1,11 @@
 import { OS } from 'codify-schemas';
 import os from 'node:os';
 import path from 'node:path';
+import { getPty } from '../pty/index.js';
+
+export function isDebug(): boolean {
+  return process.env.DEBUG != null && process.env.DEBUG.includes('codify'); // TODO: replace with debug library
+}
 
 export enum Shell {
   ZSH = 'zsh',
@@ -134,6 +139,13 @@ export const Utils = {
       path.join(homeDir, '.profile'),
     ];
   },
+
+  async isDirectoryOnPath(directory: string): Promise<boolean> {
+    const $ = getPty();
+    const { data: pathQuery } = await $.spawn('echo $PATH', { interactive: true });
+    const lines = pathQuery.split(':');
+    return lines.includes(directory);
+  },
 };
 
 

package/src/utils/internal-utils.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { addVariablesToPath, resolvePathWithVariables, splitUserConfig } from './internal-utils.js';
+import { addVariablesToPath, resolvePathWithVariables, splitUserConfig } from './functions.js';
 import os from 'node:os';
 
 describe('Utils tests', () => {

package/src/utils/verbosity-level.ts

@@ -0,0 +1,11 @@
+export const VerbosityLevel = new class {
+  level = 0;
+
+  get() {
+    return this.level;
+  }
+
+  set(level: number) {
+    this.level = level;
+  }
+}