@saws/core 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/index.js

@@ -1,6 +1,7 @@
-export * from "./context.js";
+export * from "./ServiceDefinition.js";
 export * from "./find-service-definition.js";
 export * from "./get-saws-config.js";
-export * from "./service-commands.js";
-export * from "./service-definition.js";
-export * from "./service-types.js";
+export * from "./Host.js";
+export * from "./global-hosts.js";
+export * from "./host-readiness.js";
+export * from "./secrets-manager.js";

package/dist/secrets-manager.d.ts

@@ -0,0 +1,66 @@
+export interface SecretsManagerConfig {
+    /** Overrides the stage derived from the command's runtime context or STAGE. */
+    stage?: string;
+    rootDir?: string;
+    /** Overrides the directory containing secrets state. Defaults to `<rootDir>/.saws`. */
+    sawsDirectory?: string;
+    /** Overrides SAWS_SECRETS_PASSCODE and the project-root .env file. */
+    passcode?: string;
+}
+export type SecretScope = "stage" | "global";
+export interface SecretResolutionContext {
+    stage: string;
+    rootDir?: string;
+}
+export declare class ParameterNotFoundError extends Error {
+    constructor(name: string);
+}
+export declare class SecretsDecryptionError extends Error {
+    constructor();
+}
+/**
+ * A lazy reference to either a stage-aware or global secret.
+ *
+ * References can safely be created while saws.ts is loaded, before the CLI
+ * knows which runtime stage will consume a stage-aware secret.
+ */
+export declare class SecretReference {
+    readonly name: string;
+    readonly scope: SecretScope;
+    private readonly manager;
+    constructor(manager: SecretsManager, name: string, scope: SecretScope);
+    resolve(context?: SecretResolutionContext): Promise<string>;
+    /** @internal */
+    isManagedBy(manager: SecretsManager): boolean;
+}
+export declare class GlobalSecrets {
+    private readonly manager;
+    constructor(manager: SecretsManager);
+    reference(name: string): SecretReference;
+    get(name: string): Promise<string>;
+    set(name: string, value: string): Promise<void>;
+    get secretsFilePath(): string;
+}
+export declare class SecretsManager {
+    readonly global: GlobalSecrets;
+    readonly rootDir: string;
+    readonly sawsDirectory: string;
+    private readonly configuredStage?;
+    private readonly configuredPasscode?;
+    constructor(config?: SecretsManagerConfig);
+    get stage(): string;
+    reference(name: string): SecretReference;
+    get(name: string): Promise<string>;
+    set(name: string, value: string): Promise<void>;
+    get secretsFilePath(): string;
+    /** @internal */
+    getFromScope(name: string, scope: SecretScope, resolutionStage?: string): Promise<string>;
+    /** @internal */
+    setInScope(name: string, value: string, scope: SecretScope, resolutionStage?: string): Promise<void>;
+    /** @internal */
+    getSecretsFilePath(scope: SecretScope, resolutionStage?: string): string;
+    private resolveStage;
+    private readSecrets;
+    private writeSecrets;
+    private getPasscode;
+}

package/dist/secrets-manager.js

@@ -0,0 +1,325 @@
+import { appendFile, chmod, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { createCipheriv, createDecipheriv, randomBytes, scrypt } from "node:crypto";
+import path from "node:path";
+const PASSCODE_ENV_NAME = "SAWS_SECRETS_PASSCODE";
+const GLOBAL_SCOPE = "global";
+const ENCRYPTION_VERSION = 1;
+const KEY_LENGTH = 32;
+const SCRYPT_COST = 16_384;
+const SCRYPT_BLOCK_SIZE = 8;
+const SCRYPT_PARALLELIZATION = 1;
+export class ParameterNotFoundError extends Error {
+    constructor(name) {
+        super(`Secret not found: ${name}`);
+        this.name = "ParameterNotFound";
+    }
+}
+export class SecretsDecryptionError extends Error {
+    constructor() {
+        super(`Unable to decrypt secrets. Check ${PASSCODE_ENV_NAME} in the project-root .env file.`);
+        this.name = "SecretsDecryptionError";
+    }
+}
+/**
+ * A lazy reference to either a stage-aware or global secret.
+ *
+ * References can safely be created while saws.ts is loaded, before the CLI
+ * knows which runtime stage will consume a stage-aware secret.
+ */
+export class SecretReference {
+    name;
+    scope;
+    manager;
+    constructor(manager, name, scope) {
+        if (name.trim().length === 0) {
+            throw new Error("Secret reference name cannot be empty");
+        }
+        this.manager = manager;
+        this.name = name;
+        this.scope = scope;
+    }
+    resolve(context) {
+        if (this.scope === "stage" && context == null) {
+            return this.manager.getFromScope(this.name, this.scope);
+        }
+        return this.manager.getFromScope(this.name, this.scope, context?.stage);
+    }
+    /** @internal */
+    isManagedBy(manager) {
+        return this.manager === manager;
+    }
+}
+export class GlobalSecrets {
+    manager;
+    constructor(manager) {
+        this.manager = manager;
+    }
+    reference(name) {
+        return new SecretReference(this.manager, name, GLOBAL_SCOPE);
+    }
+    async get(name) {
+        return this.manager.getFromScope(name, GLOBAL_SCOPE);
+    }
+    async set(name, value) {
+        await this.manager.setInScope(name, value, GLOBAL_SCOPE);
+    }
+    get secretsFilePath() {
+        return this.manager.getSecretsFilePath(GLOBAL_SCOPE);
+    }
+}
+export class SecretsManager {
+    global;
+    rootDir;
+    sawsDirectory;
+    configuredStage;
+    configuredPasscode;
+    constructor(config = {}) {
+        this.configuredStage = config.stage == null ? undefined : requireValidStage(config.stage);
+        this.rootDir = config.rootDir ?? process.cwd();
+        this.sawsDirectory = config.sawsDirectory ?? path.resolve(this.rootDir, ".saws");
+        this.configuredPasscode = config.passcode;
+        this.global = new GlobalSecrets(this);
+    }
+    get stage() {
+        return this.resolveStage();
+    }
+    reference(name) {
+        return new SecretReference(this, name, "stage");
+    }
+    async get(name) {
+        return this.getFromScope(name, "stage");
+    }
+    async set(name, value) {
+        await this.setInScope(name, value, "stage");
+    }
+    get secretsFilePath() {
+        return this.getSecretsFilePath("stage");
+    }
+    /** @internal */
+    async getFromScope(name, scope, resolutionStage) {
+        const secrets = await this.readSecrets(scope, resolutionStage);
+        const value = secrets[name];
+        if (value == null)
+            throw new ParameterNotFoundError(name);
+        return value;
+    }
+    /** @internal */
+    async setInScope(name, value, scope, resolutionStage) {
+        const secrets = await this.readSecrets(scope, resolutionStage);
+        secrets[name] = value;
+        await this.writeSecrets(secrets, scope, resolutionStage);
+    }
+    /** @internal */
+    getSecretsFilePath(scope, resolutionStage) {
+        const fileName = scope === GLOBAL_SCOPE ? "global.env" : `${this.resolveStage(resolutionStage)}.env`;
+        return path.resolve(this.sawsDirectory, "secrets", fileName);
+    }
+    resolveStage(resolutionStage) {
+        const stage = this.configuredStage ?? resolutionStage ?? process.env.STAGE;
+        if (stage == null || stage.length === 0) {
+            throw new Error("Unable to determine the secrets stage. Run the command with --stage or set STAGE.");
+        }
+        return requireValidStage(stage);
+    }
+    async readSecrets(scope, resolutionStage) {
+        const secretsFilePath = this.getSecretsFilePath(scope, resolutionStage);
+        let contents;
+        try {
+            contents = await readFile(secretsFilePath, "utf8");
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+            return {};
+        }
+        const encrypted = parseEncryptedFile(contents);
+        if (encrypted != null) {
+            const passcode = await this.getPasscode(false);
+            if (passcode == null) {
+                throw new Error(`${PASSCODE_ENV_NAME} is required to decrypt ${secretsFilePath}`);
+            }
+            return decryptSecrets(encrypted, passcode);
+        }
+        // Migrate files written by older SAWS versions as soon as they are used.
+        const secrets = parseEnvFile(contents);
+        await this.writeSecrets(secrets, scope, resolutionStage);
+        return secrets;
+    }
+    async writeSecrets(secrets, scope, resolutionStage) {
+        const passcode = await this.getPasscode(true);
+        if (passcode == null) {
+            throw new Error(`Unable to create ${PASSCODE_ENV_NAME}`);
+        }
+        const secretsFilePath = this.getSecretsFilePath(scope, resolutionStage);
+        await mkdir(path.dirname(secretsFilePath), { recursive: true });
+        const temporaryPath = `${secretsFilePath}.${randomBytes(8).toString("hex")}.tmp`;
+        try {
+            await writeFile(temporaryPath, JSON.stringify(await encryptSecrets(secrets, passcode), null, 2).concat("\n"), { mode: 0o600 });
+            await rename(temporaryPath, secretsFilePath);
+            await chmod(secretsFilePath, 0o600);
+        }
+        finally {
+            await rm(temporaryPath, { force: true });
+        }
+    }
+    async getPasscode(createIfMissing) {
+        if (this.configuredPasscode != null) {
+            return requireNonemptyPasscode(this.configuredPasscode);
+        }
+        if (process.env[PASSCODE_ENV_NAME] != null) {
+            return requireNonemptyPasscode(process.env[PASSCODE_ENV_NAME]);
+        }
+        const envFilePath = path.resolve(this.rootDir, ".env");
+        try {
+            const environment = parseEnvFile(await readFile(envFilePath, "utf8"));
+            if (environment[PASSCODE_ENV_NAME] != null) {
+                return requireNonemptyPasscode(environment[PASSCODE_ENV_NAME]);
+            }
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        if (!createIfMissing)
+            return undefined;
+        const passcode = randomBytes(32).toString("base64url");
+        let needsLeadingNewline = false;
+        try {
+            const contents = await readFile(envFilePath, "utf8");
+            needsLeadingNewline = contents.length > 0 && !contents.endsWith("\n");
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        await appendFile(envFilePath, `${needsLeadingNewline ? "\n" : ""}${PASSCODE_ENV_NAME}=${passcode}\n`, { mode: 0o600 });
+        await chmod(envFilePath, 0o600);
+        return passcode;
+    }
+}
+function requireValidStage(stage) {
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(stage)) {
+        throw new Error("Secrets stage must start with a letter or number and contain only letters, numbers, underscores, and hyphens");
+    }
+    if (stage.toLowerCase() === GLOBAL_SCOPE) {
+        throw new Error(`Secrets stage "${GLOBAL_SCOPE}" is reserved for global secrets`);
+    }
+    return stage;
+}
+function requireNonemptyPasscode(passcode) {
+    if (passcode.length === 0) {
+        throw new Error(`${PASSCODE_ENV_NAME} cannot be empty`);
+    }
+    return passcode;
+}
+function parseEncryptedFile(contents) {
+    let value;
+    try {
+        value = JSON.parse(contents);
+    }
+    catch {
+        return undefined;
+    }
+    if (value == null || typeof value !== "object" || !("version" in value)) {
+        return undefined;
+    }
+    const encrypted = value;
+    if (encrypted.version !== ENCRYPTION_VERSION ||
+        encrypted.kdf?.name !== "scrypt" ||
+        typeof encrypted.kdf.salt !== "string" ||
+        encrypted.kdf.cost !== SCRYPT_COST ||
+        encrypted.kdf.blockSize !== SCRYPT_BLOCK_SIZE ||
+        encrypted.kdf.parallelization !== SCRYPT_PARALLELIZATION ||
+        encrypted.cipher?.name !== "aes-256-gcm" ||
+        typeof encrypted.cipher.iv !== "string" ||
+        typeof encrypted.cipher.authTag !== "string" ||
+        typeof encrypted.ciphertext !== "string") {
+        throw new Error("Unsupported or invalid encrypted secrets file");
+    }
+    return encrypted;
+}
+async function encryptSecrets(secrets, passcode) {
+    const salt = randomBytes(16);
+    const iv = randomBytes(12);
+    const key = await deriveKey(passcode, salt);
+    const cipher = createCipheriv("aes-256-gcm", key, iv);
+    const ciphertext = Buffer.concat([
+        cipher.update(stringifyEnvFile(secrets), "utf8"),
+        cipher.final(),
+    ]);
+    return {
+        version: ENCRYPTION_VERSION,
+        kdf: {
+            name: "scrypt",
+            salt: salt.toString("base64"),
+            cost: SCRYPT_COST,
+            blockSize: SCRYPT_BLOCK_SIZE,
+            parallelization: SCRYPT_PARALLELIZATION,
+        },
+        cipher: {
+            name: "aes-256-gcm",
+            iv: iv.toString("base64"),
+            authTag: cipher.getAuthTag().toString("base64"),
+        },
+        ciphertext: ciphertext.toString("base64"),
+    };
+}
+async function decryptSecrets(encrypted, passcode) {
+    try {
+        const salt = Buffer.from(encrypted.kdf.salt, "base64");
+        const key = await deriveKey(passcode, salt);
+        const decipher = createDecipheriv("aes-256-gcm", key, Buffer.from(encrypted.cipher.iv, "base64"));
+        decipher.setAuthTag(Buffer.from(encrypted.cipher.authTag, "base64"));
+        const plaintext = Buffer.concat([
+            decipher.update(Buffer.from(encrypted.ciphertext, "base64")),
+            decipher.final(),
+        ]).toString("utf8");
+        return parseEnvFile(plaintext);
+    }
+    catch {
+        throw new SecretsDecryptionError();
+    }
+}
+function deriveKey(passcode, salt) {
+    return new Promise((resolve, reject) => {
+        scrypt(passcode, salt, KEY_LENGTH, {
+            N: SCRYPT_COST,
+            r: SCRYPT_BLOCK_SIZE,
+            p: SCRYPT_PARALLELIZATION,
+        }, (error, key) => {
+            if (error != null)
+                reject(error);
+            else
+                resolve(key);
+        });
+    });
+}
+function parseEnvFile(contents) {
+    const values = {};
+    for (const line of contents.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (trimmed.length === 0 || trimmed.startsWith("#"))
+            continue;
+        const separatorIndex = trimmed.indexOf("=");
+        if (separatorIndex === -1)
+            continue;
+        const key = trimmed.slice(0, separatorIndex).trim();
+        const rawValue = trimmed.slice(separatorIndex + 1).trim();
+        values[key] = parseEnvValue(rawValue);
+    }
+    return values;
+}
+function parseEnvValue(value) {
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+        return value.slice(1, -1).replaceAll("\\n", "\n").replaceAll('\\"', '"');
+    }
+    return value;
+}
+function stringifyEnvFile(values) {
+    return Object.entries(values)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, value]) => `${key}=${JSON.stringify(value)}`)
+        .join("\n")
+        .concat("\n");
+}

package/dist/utils/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const SAWS_DIR: string;
+export declare const BUILD_DIR: string;
+export declare const DB_PASSWORD_PARAMETER_NAME = "db-password";
+export declare const DEV_USER_PASSWORD_PARAMETER_NAME = "dev-user-password";

package/dist/utils/constants.js

@@ -0,0 +1,5 @@
+import * as path from "node:path";
+export const SAWS_DIR = path.resolve("./.saws");
+export const BUILD_DIR = path.resolve(SAWS_DIR, "build");
+export const DB_PASSWORD_PARAMETER_NAME = "db-password";
+export const DEV_USER_PASSWORD_PARAMETER_NAME = "dev-user-password";

package/dist/utils/create-directories.d.ts

@@ -0,0 +1,2 @@
+export declare const createCacheDir: () => Promise<void>;
+export declare const createSawsDir: () => Promise<void>;

package/dist/utils/create-directories.js

@@ -0,0 +1,20 @@
+import { promises as fs, constants } from "node:fs";
+import { BUILD_DIR, SAWS_DIR } from "./constants.js";
+export const createCacheDir = async () => {
+    // check if the cache dir exists already or not
+    // if not create it
+    try {
+        await fs.access(BUILD_DIR, constants.F_OK);
+    }
+    catch (err) {
+        await fs.mkdir(BUILD_DIR, { recursive: true });
+    }
+};
+export const createSawsDir = async () => {
+    try {
+        await fs.access(SAWS_DIR, constants.F_OK);
+    }
+    catch (err) {
+        await fs.mkdir(SAWS_DIR, { recursive: true });
+    }
+};

package/dist/utils/create-file-if-not-exists.d.ts

@@ -0,0 +1 @@
+export declare function createFileIfNotExists(path: string, contents: string): Promise<false | undefined>;

package/dist/utils/create-file-if-not-exists.js

@@ -0,0 +1,12 @@
+import * as fs from "node:fs/promises";
+export async function createFileIfNotExists(path, contents) {
+    try {
+        await fs.writeFile(path, contents, { flag: "wx" });
+    }
+    catch (err) {
+        if (typeof err === "object" && err !== null && "code" in err && err.code === "EEXIST") {
+            return false;
+        }
+        throw err;
+    }
+}

package/dist/utils/dependency-management.d.ts

@@ -0,0 +1,16 @@
+import type { RuntimeLogSink } from "../ServiceDefinition.js";
+export interface InstallDependenciesOptions {
+    /**
+     * The package or workspace root. Defaults to the current working directory.
+     */
+    cwd?: string;
+    /**
+     * A workspace directory, relative to `cwd`.
+     */
+    workspace?: string;
+    development?: boolean;
+    logSink?: RuntimeLogSink;
+    serviceName?: string;
+}
+export declare function installDependencies(dependencies: string[], options?: InstallDependenciesOptions): Promise<void>;
+export declare function hasDependency(dependency: string, cwd?: string): Promise<boolean>;

package/dist/utils/dependency-management.js

@@ -0,0 +1,132 @@
+import { spawn } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileExists } from "./file-exists.js";
+export async function installDependencies(dependencies, options = {}) {
+    if (dependencies.length === 0)
+        return;
+    const rootDirectory = path.resolve(options.cwd ?? process.cwd());
+    const packageManager = await detectPackageManager(rootDirectory);
+    const args = installArguments(packageManager, dependencies, options.development ?? false, options.workspace);
+    await new Promise((resolve, reject) => {
+        const captureOutput = options.logSink != null;
+        const serviceName = options.serviceName ?? "system";
+        const child = spawn(packageManager, args, {
+            // Workspace-aware package managers must be run from the workspace root.
+            // Running npm from within a workspace can install into the root package
+            // instead of updating the generated service's package.json.
+            cwd: rootDirectory,
+            env: process.env,
+            stdio: captureOutput ? ["ignore", "pipe", "pipe"] : "inherit",
+        });
+        child.stdout?.on("data", (chunk) => {
+            options.logSink?.({
+                serviceName,
+                stream: "stdout",
+                chunk: chunk.toString("utf8"),
+                timestamp: new Date(),
+            });
+        });
+        child.stderr?.on("data", (chunk) => {
+            options.logSink?.({
+                serviceName,
+                stream: "stderr",
+                chunk: chunk.toString("utf8"),
+                timestamp: new Date(),
+            });
+        });
+        child.once("error", (error) => {
+            reject(new Error(`Unable to run ${packageManager}: ${error.message}`, { cause: error }));
+        });
+        child.once("close", (code, signal) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            const reason = signal == null ? `exit code ${code ?? "unknown"}` : `signal ${signal}`;
+            reject(new Error(`${packageManager} failed to install dependencies with ${reason}`));
+        });
+    });
+}
+export async function hasDependency(dependency, cwd = process.cwd()) {
+    try {
+        const contents = await readFile(path.resolve(cwd, "package.json"), "utf8");
+        const packageJson = JSON.parse(contents);
+        return (packageJson.dependencies?.[dependency] != null ||
+            packageJson.devDependencies?.[dependency] != null);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+async function detectPackageManager(cwd) {
+    for (let directory = cwd;; directory = path.dirname(directory)) {
+        const packageManager = await readPackageManagerField(directory);
+        if (packageManager != null)
+            return packageManager;
+        for (const [lockfile, manager] of LOCKFILES) {
+            if (await fileExists(path.join(directory, lockfile)))
+                return manager;
+        }
+        const parent = path.dirname(directory);
+        if (parent === directory)
+            return "npm";
+    }
+}
+async function readPackageManagerField(directory) {
+    try {
+        const contents = await readFile(path.join(directory, "package.json"), "utf8");
+        const packageJson = JSON.parse(contents);
+        if (typeof packageJson.packageManager !== "string")
+            return undefined;
+        const name = packageJson.packageManager.split("@", 1)[0];
+        return isPackageManager(name) ? name : undefined;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+}
+function installArguments(packageManager, dependencies, development, workspace) {
+    switch (packageManager) {
+        case "npm":
+            return [
+                "install",
+                ...(workspace == null ? [] : ["--workspace", workspace]),
+                development ? "--save-dev" : "--save-prod",
+                ...dependencies,
+            ];
+        case "pnpm":
+            return [
+                ...(workspace == null ? [] : ["--filter", workspace]),
+                "add",
+                ...(development ? ["--dev"] : []),
+                ...dependencies,
+            ];
+        case "yarn":
+            return workspace == null
+                ? ["add", ...(development ? ["--dev"] : []), ...dependencies]
+                : ["workspace", workspace, "add", ...(development ? ["--dev"] : []), ...dependencies];
+        case "bun":
+            return [
+                "add",
+                ...(workspace == null ? [] : ["--filter", workspace]),
+                ...(development ? ["--dev"] : []),
+                ...dependencies,
+            ];
+    }
+}
+function isPackageManager(value) {
+    return value === "npm" || value === "pnpm" || value === "yarn" || value === "bun";
+}
+const LOCKFILES = [
+    ["pnpm-lock.yaml", "pnpm"],
+    ["yarn.lock", "yarn"],
+    ["bun.lock", "bun"],
+    ["bun.lockb", "bun"],
+    ["package-lock.json", "npm"],
+    ["npm-shrinkwrap.json", "npm"],
+];

package/dist/utils/file-exists.d.ts

@@ -0,0 +1 @@
+export declare function fileExists(filePath: string): Promise<boolean>;

package/dist/utils/file-exists.js

@@ -0,0 +1,12 @@
+import { access } from "node:fs/promises";
+export async function fileExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}

package/dist/utils/generate-token.d.ts

@@ -0,0 +1 @@
+export declare const generateToken: () => Promise<string>;

package/dist/utils/generate-token.js

@@ -0,0 +1,13 @@
+import * as crypto from "crypto";
+export const generateToken = async () => {
+    return new Promise((resolve, reject) => {
+        crypto.randomBytes(20, (err, buffer) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            resolve(buffer.toString("hex"));
+            return;
+        });
+    });
+};

package/dist/utils/get-project-name.d.ts

@@ -0,0 +1 @@
+export declare const getProjectName: () => string;

package/dist/utils/get-project-name.js

@@ -0,0 +1,5 @@
+import { default as finder } from "find-package-json";
+export const getProjectName = () => {
+    const pkg = finder(import.meta.dirname).next().value;
+    return pkg.name;
+};

package/dist/utils/get-service-path.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/list-files.d.ts

@@ -0,0 +1 @@
+export declare function listFiles(directory: string): Promise<string[]>;

package/dist/utils/list-files.js

@@ -0,0 +1,17 @@
+import { readdir } from "node:fs/promises";
+import path from "node:path";
+export async function listFiles(directory) {
+    const entries = await readdir(directory, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const fullPath = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...(await listFiles(fullPath)));
+            continue;
+        }
+        if (entry.isFile()) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}

package/dist/utils/on-exit.d.ts

@@ -0,0 +1 @@
+export declare const onProcessExit: (callback: () => void) => void;