cloak22 2.2.0

package/dist/cookies.js

@@ -0,0 +1,95 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeCookie = normalizeCookie;
+exports.parseCookieFile = parseCookieFile;
+exports.readCookiesFromFile = readCookiesFromFile;
+const node_fs_1 = __importDefault(require("node:fs"));
+function normalizeSameSite(sameSite) {
+    if (!sameSite)
+        return undefined;
+    switch (sameSite.toLowerCase()) {
+        case "strict":
+            return "Strict";
+        case "lax":
+            return "Lax";
+        case "none":
+        case "no_restriction":
+            return "None";
+        case "unspecified":
+            return undefined;
+        default:
+            return undefined;
+    }
+}
+function normalizeCookie(raw) {
+    const cookie = {
+        name: raw.name,
+        value: raw.value,
+        domain: raw.domain,
+        path: raw.path,
+    };
+    if (typeof raw.httpOnly === "boolean") {
+        cookie.httpOnly = raw.httpOnly;
+    }
+    if (typeof raw.secure === "boolean") {
+        cookie.secure = raw.secure;
+    }
+    if ("expires" in raw && typeof raw.expires === "number") {
+        cookie.expires = Math.trunc(raw.expires);
+    }
+    else if ("expirationDate" in raw &&
+        typeof raw.expirationDate === "number") {
+        cookie.expires = Math.trunc(raw.expirationDate);
+    }
+    const sameSite = normalizeSameSite(raw.sameSite);
+    if (sameSite) {
+        cookie.sameSite = sameSite;
+    }
+    return cookie;
+}
+function isCookieEntry(value) {
+    return (Boolean(value) &&
+        typeof value === "object" &&
+        typeof value.name === "string" &&
+        typeof value.value === "string" &&
+        typeof value.domain === "string" &&
+        typeof value.path === "string");
+}
+function parseCookieFileContents(value, sourceLabel) {
+    let entries;
+    if (Array.isArray(value)) {
+        entries = value;
+    }
+    else if (value &&
+        typeof value === "object" &&
+        "cookies" in value &&
+        Array.isArray(value.cookies)) {
+        entries = value.cookies;
+    }
+    if (!entries) {
+        throw new Error(`${sourceLabel} must contain a JSON array of cookies or a JSON object with a cookies array`);
+    }
+    return entries.map((entry, index) => {
+        if (!isCookieEntry(entry)) {
+            throw new Error(`${sourceLabel} contains an invalid cookie at index ${index}`);
+        }
+        return entry;
+    });
+}
+function parseCookieFile(contents, sourceLabel = "cookie file") {
+    let parsed;
+    try {
+        parsed = JSON.parse(contents);
+    }
+    catch {
+        throw new Error(`${sourceLabel} must contain valid JSON`);
+    }
+    return parseCookieFileContents(parsed, sourceLabel).map(normalizeCookie);
+}
+function readCookiesFromFile(filePath, readFile = node_fs_1.default.readFileSync) {
+    const contents = readFile(filePath, "utf8");
+    return parseCookieFile(contents, filePath);
+}

package/dist/daemon.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRunArguments = buildRunArguments;
+exports.spawnDaemonProcess = spawnDaemonProcess;
+exports.isProcessRunning = isProcessRunning;
+exports.stopProcess = stopProcess;
+const node_child_process_1 = __importDefault(require("node:child_process"));
+const node_fs_1 = __importDefault(require("node:fs"));
+function buildRunArguments(command) {
+    const args = ["run"];
+    if (!command.headless) {
+        args.push("--window");
+    }
+    if (command.profile) {
+        args.push("--profile", command.profile);
+    }
+    if (command.cookieFile) {
+        args.push("--cookie-file", command.cookieFile);
+    }
+    for (const url of command.cookieUrls) {
+        args.push("--cookie-url", url);
+    }
+    return args;
+}
+function spawnDaemonProcess(options) {
+    const spawnProcess = options.spawnProcess ?? node_child_process_1.default.spawn;
+    const openFile = options.openFile ?? node_fs_1.default.openSync;
+    const logFd = openFile(options.logPath, "a");
+    const child = spawnProcess(options.execPath, [
+        ...options.execArgv,
+        options.scriptPath,
+        ...buildRunArguments(options.command),
+    ], {
+        detached: true,
+        stdio: ["ignore", logFd, logFd],
+    });
+    child.unref();
+    if (typeof child.pid !== "number") {
+        throw new Error("Failed to start cloak daemon.");
+    }
+    return child.pid;
+}
+function isProcessRunning(pid, killProcess = process.kill) {
+    try {
+        killProcess(pid, 0);
+        return true;
+    }
+    catch (error) {
+        if (error &&
+            typeof error === "object" &&
+            "code" in error &&
+            error.code === "ESRCH") {
+            return false;
+        }
+        throw error;
+    }
+}
+async function stopProcess(pid, dependencies = {}) {
+    const killProcess = dependencies.killProcess ?? process.kill;
+    const processIsRunning = dependencies.isProcessRunning ?? ((candidatePid) => isProcessRunning(candidatePid, killProcess));
+    const sleep = dependencies.sleep ?? ((milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)));
+    const timeoutMs = dependencies.timeoutMs ?? 5000;
+    const intervalMs = dependencies.intervalMs ?? 100;
+    if (!processIsRunning(pid)) {
+        return false;
+    }
+    try {
+        killProcess(pid, "SIGTERM");
+    }
+    catch (error) {
+        if (error &&
+            typeof error === "object" &&
+            "code" in error &&
+            error.code === "ESRCH") {
+            return false;
+        }
+        throw error;
+    }
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (!processIsRunning(pid)) {
+            return true;
+        }
+        await sleep(intervalMs);
+    }
+    if (processIsRunning(pid)) {
+        killProcess(pid, "SIGKILL");
+    }
+    return !processIsRunning(pid);
+}

package/dist/extension.js

@@ -0,0 +1,133 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REQUIRED_EXTENSION_SHA256 = exports.REQUIRED_EXTENSION_ARCHIVE_NAME = exports.REQUIRED_EXTENSION_URL = void 0;
+exports.validateExtensionArchive = validateExtensionArchive;
+exports.downloadRequiredExtensionArchive = downloadRequiredExtensionArchive;
+exports.ensureRequiredExtensionArchive = ensureRequiredExtensionArchive;
+exports.prepareRequiredExtension = prepareRequiredExtension;
+exports.installRequiredExtension = installRequiredExtension;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const adm_zip_1 = __importDefault(require("adm-zip"));
+const app_paths_js_1 = require("./app-paths.js");
+const output_js_1 = require("./output.js");
+exports.REQUIRED_EXTENSION_URL = "https://github.com/jackwener/opencli/releases/download/v1.6.8/opencli-extension.zip";
+exports.REQUIRED_EXTENSION_ARCHIVE_NAME = "opencli-extension.zip";
+exports.REQUIRED_EXTENSION_SHA256 = "a5f51d111e49e7215191a80c2dc822d4ea94950c9e239dc077862a8044bc8d2e";
+function validateExtensionArchive(archivePath) {
+    let zip;
+    try {
+        zip = new adm_zip_1.default(archivePath);
+    }
+    catch (error) {
+        throw new Error(`Invalid required extension archive at ${archivePath}`, {
+            cause: error,
+        });
+    }
+    const entryNames = zip
+        .getEntries()
+        .filter((entry) => !entry.isDirectory)
+        .map((entry) => normalizeZipEntryName(entry.entryName));
+    if (entryNames.length === 0) {
+        throw new Error(`Required extension archive is empty: ${archivePath}`);
+    }
+    if (!findManifestEntry(entryNames)) {
+        throw new Error(`Required extension archive must contain manifest.json at the root or one directory deep: ${archivePath}`);
+    }
+    const archiveDigest = (0, node_crypto_1.createHash)("sha256")
+        .update(node_fs_1.default.readFileSync(archivePath))
+        .digest("hex");
+    if (archiveDigest !== exports.REQUIRED_EXTENSION_SHA256) {
+        throw new Error(`Required extension archive digest mismatch at ${archivePath}: expected ${exports.REQUIRED_EXTENSION_SHA256}, got ${archiveDigest}`);
+    }
+}
+async function downloadRequiredExtensionArchive(extensionsDir, dependencies = {}) {
+    const fetchImpl = dependencies.fetchImpl ?? fetch;
+    const validateArchive = dependencies.validateExtensionArchive ?? validateExtensionArchive;
+    const log = dependencies.log ?? ((message) => console.log((0, output_js_1.formatInfo)(message)));
+    const archivePath = node_path_1.default.join(extensionsDir, exports.REQUIRED_EXTENSION_ARCHIVE_NAME);
+    const tempArchivePath = node_path_1.default.join(extensionsDir, `${exports.REQUIRED_EXTENSION_ARCHIVE_NAME}.download-${process.pid}-${Date.now()}`);
+    node_fs_1.default.mkdirSync(extensionsDir, { recursive: true });
+    const response = await fetchImpl(exports.REQUIRED_EXTENSION_URL);
+    if (!response.ok) {
+        throw new Error(`Failed to download required extension: ${response.status} ${response.statusText}`);
+    }
+    const archiveBody = Buffer.from(await response.arrayBuffer());
+    node_fs_1.default.writeFileSync(tempArchivePath, archiveBody);
+    try {
+        validateArchive(tempArchivePath);
+        node_fs_1.default.rmSync(archivePath, { force: true });
+        node_fs_1.default.renameSync(tempArchivePath, archivePath);
+    }
+    catch (error) {
+        node_fs_1.default.rmSync(tempArchivePath, { force: true });
+        throw error;
+    }
+    log(`Prepared required extension archive at ${archivePath}`);
+    return archivePath;
+}
+async function ensureRequiredExtensionArchive(extensionsDir, dependencies = {}) {
+    const validateArchive = dependencies.validateExtensionArchive ?? validateExtensionArchive;
+    const downloadRequiredExtension = dependencies.downloadRequiredExtension ?? downloadRequiredExtensionArchive;
+    const log = dependencies.log ?? ((message) => console.log((0, output_js_1.formatInfo)(message)));
+    const archivePath = node_path_1.default.join(extensionsDir, exports.REQUIRED_EXTENSION_ARCHIVE_NAME);
+    if (node_fs_1.default.existsSync(archivePath)) {
+        try {
+            validateArchive(archivePath);
+            return archivePath;
+        }
+        catch {
+            log(`Repairing required extension archive at ${archivePath}`);
+        }
+    }
+    else {
+        log(`Downloading required extension archive to ${archivePath}`);
+    }
+    const refreshedArchivePath = await downloadRequiredExtension(extensionsDir, {
+        validateExtensionArchive: validateArchive,
+        log,
+    });
+    validateArchive(refreshedArchivePath);
+    return refreshedArchivePath;
+}
+async function prepareRequiredExtension(extensionsDir, dependencies = {}) {
+    const ensureArchive = dependencies.ensureRequiredExtensionArchive ?? ensureRequiredExtensionArchive;
+    const makeTempDir = dependencies.makeTempDir ?? node_fs_1.default.mkdtempSync;
+    const archivePath = await ensureArchive(extensionsDir);
+    const tempDir = makeTempDir(node_path_1.default.join(node_os_1.default.tmpdir(), "cloak-ext-"));
+    new adm_zip_1.default(archivePath).extractAllTo(tempDir, true);
+    return resolveExtractedExtensionRoot(tempDir);
+}
+async function installRequiredExtension(extensionsDir = (0, app_paths_js_1.defaultAppRootDir)(), dependencies = {}) {
+    return ensureRequiredExtensionArchive(extensionsDir, dependencies);
+}
+function normalizeZipEntryName(entryName) {
+    return entryName.replace(/\\/g, "/").replace(/^\/+/, "");
+}
+function findManifestEntry(entryNames) {
+    return entryNames.find((entryName) => {
+        if (entryName === "manifest.json") {
+            return true;
+        }
+        const segments = entryName.split("/");
+        return segments.length === 2 && segments[1] === "manifest.json";
+    });
+}
+function resolveExtractedExtensionRoot(extractedDir) {
+    if (node_fs_1.default.existsSync(node_path_1.default.join(extractedDir, "manifest.json"))) {
+        return extractedDir;
+    }
+    const nestedExtension = node_fs_1.default
+        .readdirSync(extractedDir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .find((entry) => node_fs_1.default.existsSync(node_path_1.default.join(extractedDir, entry.name, "manifest.json")));
+    if (!nestedExtension) {
+        throw new Error(`Required extension archive did not extract a manifest.json: ${extractedDir}`);
+    }
+    return node_path_1.default.join(extractedDir, nestedExtension.name);
+}

package/dist/install-extension.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const extension_js_1 = require("./extension.js");
+const output_js_1 = require("./output.js");
+async function run() {
+    const archivePath = await (0, extension_js_1.installRequiredExtension)();
+    console.log((0, output_js_1.formatSuccess)(`Required extension ready at ${archivePath}`));
+}
+run().catch((error) => {
+    console.error((0, output_js_1.formatError)(String(error)));
+    process.exit(1);
+});