44r0n7/privacy.sexy
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fix script deletion during execution on desktop

Browse Source 
This commit fixes an issue seen on certain Windows environments (Windows
10 22H2 and 11 23H2 Pro Azure VMs) where scripts were being deleted
during execution due to temporary directory usage. To resolve this,
scripts are now stored in a persistent directory, enhancing reliability
for long-running scripts and improving auditability along with
troubleshooting.

Key changes:

- Move script execution logic to the `main` process from `preloader` to
  utilize Electron's `app.getPath`.
- Improve runtime environment detection for non-browser environments to
  allow its usage in Electron main process.
- Introduce a secure module to expose IPC channels from the main process
  to the renderer via the preloader process.

Supporting refactorings include:

- Simplify `CodeRunner` interface by removing the `tempScriptFolderName`
  parameter.
- Rename `NodeSystemOperations` to `NodeElectronSystemOperations` as it
  now wraps electron APIs too, and convert it to class for simplicity.
- Rename `TemporaryFileCodeRunner` to `ScriptFileCodeRunner` to reflect
  its new functinoality.
- Rename `SystemOperations` folder to `System` for simplicity.
- Rename `HostRuntimeEnvironment` to `BrowserRuntimeEnvironment` for
  clarity.
- Refactor main Electron process configuration to align with latest
  Electron documentation/recommendations.
- Refactor unit tests `BrowserRuntimeEnvironment` to simplify singleton
  workaround.
- Use alias imports like `electron/main` and `electron/common` for
  better clarity.
This commit is contained in:
undergroundwires
2024-01-06 18:47:58 +01:00
parent bf7fb0732c
commit c84a1bb74c
75 changed files with 1809 additions and 574 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
src/infrastructure/CodeRunner/Creation/Directory/PersistentDirectoryProvider.ts Normal file
View File

@@ -0,0 +1,40 @@
import { Logger } from '@/application/Common/Log/Logger';
import { ElectronLogger } from '@/infrastructure/Log/ElectronLogger';
import { SystemOperations } from '../../System/SystemOperations';
import { NodeElectronSystemOperations } from '../../System/NodeElectronSystemOperations';
import { ScriptDirectoryProvider } from './ScriptDirectoryProvider';
export const ExecutionSubdirectory = 'runs';
export class PersistentDirectoryProvider implements ScriptDirectoryProvider {
constructor(
private readonly system: SystemOperations = new NodeElectronSystemOperations(),
private readonly logger: Logger = ElectronLogger,
) { }
async provideScriptDirectory(): Promise<string> {
const scriptsDirectory = this.system.location.combinePaths(
/*
Switched from temporary to persistent directory for script storage for improved reliability.
Temporary directories in some environments, such certain Windows Pro Azure VMs, showed
issues where scripts were interrupted due to directory cleanup during script execution.
This was observed with system temp directories (e.g., `%LOCALAPPDATA%\Temp`).
Persistent directories offer better stability during long executions and aid in auditability
and troubleshooting.
*/
this.system.operatingSystem.getUserDataDirectory(),
ExecutionSubdirectory,
);
this.logger.info(`Attempting to create script directory at path: ${scriptsDirectory}`);
try {
await this.system.fileSystem.createDirectory(scriptsDirectory, true);
this.logger.info(`Script directory successfully created at: ${scriptsDirectory}`);
} catch (error) {
this.logger.error(`Error creating script directory at ${scriptsDirectory}: ${error.message}`, error);
throw error;
}
return scriptsDirectory;
}
}

3
src/infrastructure/CodeRunner/Creation/Directory/ScriptDirectoryProvider.ts Normal file
View File

@@ -0,0 +1,3 @@
export interface ScriptDirectoryProvider {
provideScriptDirectory(): Promise<string>;
}

0
src/infrastructure/CodeRunner/Filename/FilenameGenerator.ts → src/infrastructure/CodeRunner/Creation/Filename/FilenameGenerator.ts
View File

4
src/infrastructure/CodeRunner/Filename/OsTimestampedFilenameGenerator.ts → src/infrastructure/CodeRunner/Creation/Filename/OsTimestampedFilenameGenerator.ts
View File

@@ -1,6 +1,6 @@
import { OperatingSystem } from '@/domain/OperatingSystem';
import { RuntimeEnvironment } from '@/infrastructure/RuntimeEnvironment/RuntimeEnvironment';
import { HostRuntimeEnvironment } from '@/infrastructure/RuntimeEnvironment/HostRuntimeEnvironment';
import { CurrentEnvironment } from '@/infrastructure/RuntimeEnvironment/RuntimeEnvironmentFactory';
import { FilenameGenerator } from './FilenameGenerator';
/**
@@ -14,7 +14,7 @@ export class OsTimestampedFilenameGenerator implements FilenameGenerator {
private readonly currentOs?: OperatingSystem;
constructor(
environment: RuntimeEnvironment = HostRuntimeEnvironment.CurrentEnvironment,
environment: RuntimeEnvironment = CurrentEnvironment,
) {
this.currentOs = environment.os;
}

37
src/infrastructure/CodeRunner/Creation/ScriptFileCreationOrchestrator.ts Normal file
View File

@@ -0,0 +1,37 @@
import { ElectronLogger } from '@/infrastructure/Log/ElectronLogger';
import { Logger } from '@/application/Common/Log/Logger';
import { SystemOperations } from '../System/SystemOperations';
import { NodeElectronSystemOperations } from '../System/NodeElectronSystemOperations';
import { FilenameGenerator } from './Filename/FilenameGenerator';
import { ScriptFileCreator } from './ScriptFileCreator';
import { OsTimestampedFilenameGenerator } from './Filename/OsTimestampedFilenameGenerator';
import { ScriptDirectoryProvider } from './Directory/ScriptDirectoryProvider';
import { PersistentDirectoryProvider } from './Directory/PersistentDirectoryProvider';
export class ScriptFileCreationOrchestrator implements ScriptFileCreator {
constructor(
private readonly system: SystemOperations = new NodeElectronSystemOperations(),
private readonly filenameGenerator: FilenameGenerator = new OsTimestampedFilenameGenerator(),
private readonly directoryProvider: ScriptDirectoryProvider = new PersistentDirectoryProvider(),
private readonly logger: Logger = ElectronLogger,
) { }
public async createScriptFile(contents: string): Promise<string> {
const filePath = await this.provideFilePath();
await this.createFile(filePath, contents);
return filePath;
}
private async provideFilePath(): Promise<string> {
const filename = this.filenameGenerator.generateFilename();
const directoryPath = await this.directoryProvider.provideScriptDirectory();
const filePath = this.system.location.combinePaths(directoryPath, filename);
return filePath;
}
private async createFile(filePath: string, contents: string): Promise<void> {
this.logger.info(`Creating file at ${filePath}, size: ${contents.length} characters`);
await this.system.fileSystem.writeToFile(filePath, contents);
this.logger.info(`File created successfully at ${filePath}`);
}
}

3
src/infrastructure/CodeRunner/Creation/ScriptFileCreator.ts Normal file
View File

@@ -0,0 +1,3 @@
export interface ScriptFileCreator {
createScriptFile(contents: string): Promise<string>;
}

10
src/infrastructure/CodeRunner/Execution/VisibleTerminalScriptFileExecutor.ts
View File

@@ -1,17 +1,17 @@
import { OperatingSystem } from '@/domain/OperatingSystem';
import { CommandOps, SystemOperations } from '@/infrastructure/CodeRunner/SystemOperations/SystemOperations';
import { CommandOps, SystemOperations } from '@/infrastructure/CodeRunner/System/SystemOperations';
import { Logger } from '@/application/Common/Log/Logger';
import { ElectronLogger } from '@/infrastructure/Log/ElectronLogger';
import { RuntimeEnvironment } from '@/infrastructure/RuntimeEnvironment/RuntimeEnvironment';
import { HostRuntimeEnvironment } from '@/infrastructure/RuntimeEnvironment/HostRuntimeEnvironment';
import { createNodeSystemOperations } from '@/infrastructure/CodeRunner/SystemOperations/NodeSystemOperations';
import { NodeElectronSystemOperations } from '@/infrastructure/CodeRunner/System/NodeElectronSystemOperations';
import { CurrentEnvironment } from '@/infrastructure/RuntimeEnvironment/RuntimeEnvironmentFactory';
import { ScriptFileExecutor } from './ScriptFileExecutor';
export class VisibleTerminalScriptExecutor implements ScriptFileExecutor {
constructor(
private readonly system: SystemOperations = createNodeSystemOperations(),
private readonly system: SystemOperations = new NodeElectronSystemOperations(),
private readonly logger: Logger = ElectronLogger,
private readonly environment: RuntimeEnvironment = HostRuntimeEnvironment.CurrentEnvironment,
private readonly environment: RuntimeEnvironment = CurrentEnvironment,
) { }
public async executeScriptFile(filePath: string): Promise<void> {

29
src/infrastructure/CodeRunner/ScriptFileCodeRunner.ts Normal file
View File

@@ -0,0 +1,29 @@
import { CodeRunner } from '@/application/CodeRunner';
import { Logger } from '@/application/Common/Log/Logger';
import { ElectronLogger } from '../Log/ElectronLogger';
import { ScriptFileExecutor } from './Execution/ScriptFileExecutor';
import { VisibleTerminalScriptExecutor } from './Execution/VisibleTerminalScriptFileExecutor';
import { ScriptFileCreator } from './Creation/ScriptFileCreator';
import { ScriptFileCreationOrchestrator } from './Creation/ScriptFileCreationOrchestrator';
export class ScriptFileCodeRunner implements CodeRunner {
constructor(
private readonly scriptFileExecutor: ScriptFileExecutor = new VisibleTerminalScriptExecutor(),
private readonly scriptFileCreator: ScriptFileCreator = new ScriptFileCreationOrchestrator(),
private readonly logger: Logger = ElectronLogger,
) { }
public async runCode(
code: string,
): Promise<void> {
this.logger.info('Initiating script running process.');
try {
const scriptFilePath = await this.scriptFileCreator.createScriptFile(code);
await this.scriptFileExecutor.executeScriptFile(scriptFilePath);
this.logger.info(`Successfully ran script at ${scriptFilePath}`);
} catch (error) {
this.logger.error(`Error running script: ${error.message}`, error);
throw error;
}
}
}

65
src/infrastructure/CodeRunner/System/NodeElectronSystemOperations.ts Normal file
View File

@@ -0,0 +1,65 @@
import { join } from 'node:path';
import { chmod, mkdir, writeFile } from 'node:fs/promises';
import { exec } from 'node:child_process';
import { app } from 'electron/main';
import {
CommandOps, FileSystemOps, LocationOps, OperatingSystemOps, SystemOperations,
} from './SystemOperations';
export class NodeElectronSystemOperations implements SystemOperations {
public readonly operatingSystem: OperatingSystemOps = {
/*
This method returns the directory for storing app's configuration files.
It appends your app's name to the default appData directory.
Conventionally, you should store user data files in this directory.
However, avoid writing large files here as some environments might back up this directory
to cloud storage, potentially causing issues with file size.
Based on tests it returns:
- Windows: `%APPDATA%\privacy.sexy`
- Linux: `$HOME/.config/privacy.sexy/runs`
- macOS: `$HOME/Library/Application Support/privacy.sexy/runs`
For more details, refer to the Electron documentation: https://web.archive.org/web/20240104154857/https://www.electronjs.org/docs/latest/api/app#appgetpathname
*/
getUserDataDirectory: () => {
return app.getPath('userData');
},
};
public readonly location: LocationOps = {
combinePaths: (...pathSegments) => join(...pathSegments),
};
public readonly fileSystem: FileSystemOps = {
setFilePermissions: (
filePath: string,
mode: string | number,
) => chmod(filePath, mode),
createDirectory: async (
directoryPath: string,
isRecursive?: boolean,
) => {
await mkdir(directoryPath, { recursive: isRecursive });
// Ignoring the return value from `mkdir`, which is the first directory created
// when `recursive` is true, or empty return value.
// See https://github.com/nodejs/node/pull/31530
},
writeToFile: (
filePath: string,
data: string,
) => writeFile(filePath, data),
};
public readonly command: CommandOps = {
exec: (command) => new Promise((resolve, reject) => {
exec(command, (error) => {
if (error) {
reject(error);
}
resolve();
});
}),
};
}

2
src/infrastructure/CodeRunner/SystemOperations/SystemOperations.ts → src/infrastructure/CodeRunner/System/SystemOperations.ts
View File

@@ -6,7 +6,7 @@ export interface SystemOperations {
}
export interface OperatingSystemOps {
getTempDirectory(): string;
getUserDataDirectory(): string;
}
export interface LocationOps {

46
src/infrastructure/CodeRunner/SystemOperations/NodeSystemOperations.ts
View File

@@ -1,46 +0,0 @@
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { chmod, mkdir, writeFile } from 'node:fs/promises';
import { exec } from 'node:child_process';
import { SystemOperations } from './SystemOperations';
export function createNodeSystemOperations(): SystemOperations {
return {
operatingSystem: {
getTempDirectory: () => tmpdir(),
},
location: {
combinePaths: (...pathSegments) => join(...pathSegments),
},
fileSystem: {
setFilePermissions: (
filePath: string,
mode: string | number,
) => chmod(filePath, mode),
createDirectory: async (
directoryPath: string,
isRecursive?: boolean,
) => {
await mkdir(directoryPath, { recursive: isRecursive });
// Ignoring the return value from `mkdir`, which is the first directory created
// when `recursive` is true. The function contract is to not return any value,
// and we avoid handling this inconsistent behavior.
// See https://github.com/nodejs/node/pull/31530
},
writeToFile: (
filePath: string,
data: string,
) => writeFile(filePath, data),
},
command: {
exec: (command) => new Promise((resolve, reject) => {
exec(command, (error) => {
if (error) {
reject(error);
}
resolve();
});
}),
},
};
}

61
src/infrastructure/CodeRunner/TemporaryFileCodeRunner.ts
View File

@@ -1,61 +0,0 @@
import { CodeRunner } from '@/application/CodeRunner';
import { Logger } from '@/application/Common/Log/Logger';
import { ElectronLogger } from '../Log/ElectronLogger';
import { SystemOperations } from './SystemOperations/SystemOperations';
import { createNodeSystemOperations } from './SystemOperations/NodeSystemOperations';
import { FilenameGenerator } from './Filename/FilenameGenerator';
import { ScriptFileExecutor } from './Execution/ScriptFileExecutor';
import { VisibleTerminalScriptExecutor } from './Execution/VisibleTerminalScriptFileExecutor';
import { OsTimestampedFilenameGenerator } from './Filename/OsTimestampedFilenameGenerator';
export class TemporaryFileCodeRunner implements CodeRunner {
constructor(
private readonly system: SystemOperations = createNodeSystemOperations(),
private readonly filenameGenerator: FilenameGenerator = new OsTimestampedFilenameGenerator(),
private readonly logger: Logger = ElectronLogger,
private readonly scriptFileExecutor: ScriptFileExecutor = new VisibleTerminalScriptExecutor(),
) { }
public async runCode(
code: string,
tempScriptFolderName: string,
): Promise<void> {
this.logger.info('Starting running code.');
try {
const filename = this.filenameGenerator.generateFilename();
const filePath = await this.createTemporaryFile(filename, tempScriptFolderName, code);
await this.scriptFileExecutor.executeScriptFile(filePath);
this.logger.info(`Successfully executed script at ${filePath}`);
} catch (error) {
this.logger.error(`Error executing script: ${error.message}`, error);
throw error;
}
}
private async createTemporaryFile(
filename: string,
tempScriptFolderName: string,
contents: string,
): Promise<string> {
const directoryPath = this.system.location.combinePaths(
this.system.operatingSystem.getTempDirectory(),
tempScriptFolderName,
);
await this.createDirectoryIfNotExists(directoryPath);
const filePath = this.system.location.combinePaths(directoryPath, filename);
await this.createFile(filePath, contents);
return filePath;
}
private async createFile(filePath: string, contents: string): Promise<void> {
this.logger.info(`Creating file at ${filePath}, size: ${contents.length} characters`);
await this.system.fileSystem.writeToFile(filePath, contents);
this.logger.info(`File created successfully at ${filePath}`);
}
private async createDirectoryIfNotExists(directoryPath: string): Promise<void> {
this.logger.info(`Checking and ensuring directory exists: ${directoryPath}`);
await this.system.fileSystem.createDirectory(directoryPath, true);
this.logger.info(`Directory confirmed at: ${directoryPath}`);
}
}