signing-enclave
Version:
A code signing and notarization tool for macOS and Windows applications. Uses Azure Key Vault for secret and certificate management.
119 lines • 5.12 kB
JavaScript
;
// src/signingEnclave.ts
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.WATCH_FOLDER = void 0;
exports.createRequestFile = createRequestFile;
exports.moveFileOrFolderToWatchFolder = moveFileOrFolderToWatchFolder;
exports.waitForReceipt = waitForReceipt;
const path_1 = __importDefault(require("path"));
const promises_1 = __importDefault(require("fs/promises"));
const child_process_1 = require("child_process");
const util_1 = require("util");
const utils_1 = require("../utils");
const execPromise = (0, util_1.promisify)(child_process_1.exec);
// Configuration: Paths to watched and receipts folders
exports.WATCH_FOLDER = path_1.default.resolve(process.cwd(), "watched_folder");
// Define the possible timeout durations
const RECEIPT_TIMEOUT_MS = 3600000; // 1 hour
// Helper to create a request file
async function createRequestFile(request, id) {
const requestFileName = `${id}.request.json`;
const requestFilePath = path_1.default.join(exports.WATCH_FOLDER, requestFileName);
await promises_1.default.writeFile(requestFilePath, JSON.stringify(request, null, 2));
console.log(`Request file created: ${requestFileName}`);
return requestFilePath;
}
// Helper to copy a file to the watch folder
async function moveFileOrFolderToWatchFolder(sourcePath, destFileName) {
const destPath = path_1.default.join(exports.WATCH_FOLDER, destFileName);
// await nativeCopy(sourcePath, destPath);
// await fs.rename(sourcePath, destPath);
// console.log(`File/Folder moved to watch folder: ${destFileName}`);
const stats = await promises_1.default.stat(sourcePath);
if (stats.isDirectory()) {
await promises_1.default.cp(sourcePath, destPath, { recursive: true });
console.log(`Folder copied to watch folder: ${destFileName}`);
}
else {
await promises_1.default.copyFile(sourcePath, destPath);
console.log(`File copied to watch folder: ${destFileName}`);
}
return destPath;
}
async function copyFolder(src, dest) {
await promises_1.default.mkdir(dest, { recursive: true });
const entries = await promises_1.default.readdir(src, { withFileTypes: true });
for (const entry of entries) {
const srcPath = path_1.default.join(src, entry.name);
const destPath = path_1.default.join(dest, entry.name);
if (entry.isDirectory()) {
await copyFolder(srcPath, destPath);
}
else {
await promises_1.default.copyFile(srcPath, destPath);
}
}
}
/**
* Copies a directory from sourcePath to destinationPath using the `ditto` command.
* @param sourcePath - The path of the source directory.
* @param destinationPath - The path of the destination directory.
* @returns A promise that resolves when the copy is complete.
*/
async function nativeCopy(sourcePath, destinationPath) {
return new Promise((resolve, reject) => {
const ditto = (0, child_process_1.spawn)("ditto", [sourcePath, destinationPath], {
shell: true,
});
// Capture stdout data
ditto.stdout.on("data", (data) => {
console.log(`stdout: ${data}`);
});
// Capture stderr data
ditto.stderr.on("data", (data) => {
console.error(`stderr: ${data}`);
});
// Listen for the close event to determine when the process has finished
ditto.on("close", (code) => {
if (code === 0) {
console.log(`Folder copied from ${sourcePath} to ${destinationPath} using ditto.`);
(0, utils_1.delay)(5000).then(() => resolve());
// resolve();
}
else {
reject(new Error(`ditto process exited with code ${code}`));
}
});
// Handle any errors that occur during spawning
ditto.on("error", (err) => {
console.error("Error spawning ditto process:", err);
reject(err);
});
});
}
// Helper to wait for receipt file to be created and reach desired status
async function waitForReceipt(id, timeout = RECEIPT_TIMEOUT_MS) {
const receiptFileName = `${id}.receipt.json`;
const receiptPath = path_1.default.join(exports.WATCH_FOLDER, receiptFileName);
const pollInterval = 250; // ms
let elapsed = 0;
while (elapsed < timeout) {
try {
const receiptData = await promises_1.default.readFile(receiptPath, "utf-8");
const receipt = JSON.parse(receiptData);
if (receipt.status === "Completed" || receipt.status === "Failed") {
return receipt;
}
}
catch (err) {
// Receipt file might not exist yet
}
await new Promise((resolve) => setTimeout(resolve, pollInterval));
elapsed += pollInterval;
}
throw new Error(`Receipt ${receiptFileName} was not created within ${timeout / 1000} seconds.`);
}
//# sourceMappingURL=utils.js.map