@youkno/edge-cli 1.20.2314

package/dist/lib/auth.js

@@ -0,0 +1,451 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listLogins = listLogins;
+exports.setDefaultLogin = setDefaultLogin;
+exports.logout = logout;
+exports.login = login;
+exports.resolveAccessToken = resolveAccessToken;
+exports.resolveAuthHeader = resolveAuthHeader;
+exports.getAuthHeaderFromOverride = getAuthHeaderFromOverride;
+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_child_process_1 = require("node:child_process");
+const node_http_1 = __importDefault(require("node:http"));
+const AUTH_DIR = process.env.EDGE_CLI_AUTH_DIR
+    ? node_path_1.default.resolve(process.env.EDGE_CLI_AUTH_DIR)
+    : node_path_1.default.join(node_os_1.default.homedir(), ".edge-cli-auth");
+const AUTH_FILE = node_path_1.default.join(AUTH_DIR, "accounts.json");
+const DEFAULT_DEVICE_NAME = "edge-cli";
+function scopeKey(cfg) {
+    return `${cfg.product}/${cfg.env}`;
+}
+function ensureAuthDir() {
+    if (!node_fs_1.default.existsSync(AUTH_DIR)) {
+        node_fs_1.default.mkdirSync(AUTH_DIR, { recursive: true, mode: 0o700 });
+    }
+}
+function readDb() {
+    ensureAuthDir();
+    if (!node_fs_1.default.existsSync(AUTH_FILE)) {
+        return { scopes: {} };
+    }
+    try {
+        const raw = node_fs_1.default.readFileSync(AUTH_FILE, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!parsed.scopes || typeof parsed.scopes !== "object") {
+            return { scopes: {} };
+        }
+        return parsed;
+    }
+    catch {
+        return { scopes: {} };
+    }
+}
+function writeDb(db) {
+    ensureAuthDir();
+    node_fs_1.default.writeFileSync(AUTH_FILE, `${JSON.stringify(db, null, 2)}\n`, { mode: 0o600 });
+}
+function getScope(db, cfg) {
+    const key = scopeKey(cfg);
+    if (!db.scopes[key]) {
+        db.scopes[key] = { default: "", accounts: {} };
+    }
+    if (!db.scopes[key].accounts) {
+        db.scopes[key].accounts = {};
+    }
+    return db.scopes[key];
+}
+function nowEpoch() {
+    return Math.floor(Date.now() / 1000);
+}
+function listLogins(cfg) {
+    const db = readDb();
+    const scope = getScope(db, cfg);
+    return Object.keys(scope.accounts)
+        .sort((a, b) => a.localeCompare(b))
+        .map((email) => ({ email, isDefault: scope.default === email }));
+}
+function setDefaultLogin(cfg, email) {
+    const db = readDb();
+    const scope = getScope(db, cfg);
+    if (!scope.accounts[email]) {
+        throw new Error(`Account not found for ${cfg.product}/${cfg.env}: ${email}`);
+    }
+    scope.default = email;
+    writeDb(db);
+}
+function authStateHeader(cfg) {
+    return `${cfg.product}.${cfg.env}`;
+}
+function authDeviceId() {
+    return `edge-cli:${node_os_1.default.hostname() || "unknown-host"}`;
+}
+function decodeJwtPayload(token) {
+    const parts = token.split(".");
+    if (parts.length < 2) {
+        return {};
+    }
+    const b64 = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+    const pad = b64.length % 4 === 0 ? "" : "=".repeat(4 - (b64.length % 4));
+    const decoded = Buffer.from(b64 + pad, "base64").toString("utf8");
+    try {
+        return JSON.parse(decoded);
+    }
+    catch {
+        return {};
+    }
+}
+function extractEmailFromToken(accessToken) {
+    const payload = decodeJwtPayload(accessToken);
+    const email = payload.email;
+    if (typeof email === "string" && email.trim()) {
+        return email.trim();
+    }
+    return "unknown@local";
+}
+function getAuthHeaderFromOverride(auth) {
+    if (!auth) {
+        return undefined;
+    }
+    return `Basic ${Buffer.from(auth).toString("base64")}`;
+}
+async function requestTokenEndpoint(cfg, endpoint, payload) {
+    const url = `${cfg.baseUrl.replace(/\/$/, "")}/api/v1/auth/${endpoint}`;
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "X-edge-state": authStateHeader(cfg)
+        },
+        body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+        const body = await response.text();
+        throw new Error(`Auth ${endpoint} failed (${response.status}): ${body}`);
+    }
+    if (endpoint === "logout") {
+        return undefined;
+    }
+    return (await response.json());
+}
+async function authExchangeFirebaseToken(cfg, firebaseToken) {
+    const resp = await requestTokenEndpoint(cfg, "exchange", {
+        firebaseToken,
+        deviceId: authDeviceId(),
+        deviceName: DEFAULT_DEVICE_NAME
+    });
+    if (!resp?.accessToken) {
+        throw new Error("Token exchange did not return accessToken");
+    }
+    return resp;
+}
+async function authRefreshToken(cfg, refreshToken) {
+    const resp = await requestTokenEndpoint(cfg, "refresh", {
+        refreshToken,
+        deviceId: authDeviceId(),
+        deviceName: DEFAULT_DEVICE_NAME
+    });
+    if (!resp?.accessToken) {
+        throw new Error("Token refresh did not return accessToken");
+    }
+    return resp;
+}
+async function authLogoutRefreshToken(cfg, refreshToken) {
+    await requestTokenEndpoint(cfg, "logout", { refreshToken });
+}
+async function logout(cfg, email) {
+    const db = readDb();
+    const scope = getScope(db, cfg);
+    const target = email ?? scope.default;
+    if (!target) {
+        throw new Error(`No account to logout for ${cfg.product}/${cfg.env}`);
+    }
+    const account = scope.accounts[target];
+    if (!account) {
+        throw new Error(`Account not found for ${cfg.product}/${cfg.env}: ${target}`);
+    }
+    if (account.refreshToken) {
+        try {
+            await authLogoutRefreshToken(cfg, account.refreshToken);
+        }
+        catch {
+            // best effort
+        }
+    }
+    delete scope.accounts[target];
+    if (scope.default === target) {
+        const left = Object.keys(scope.accounts).sort((a, b) => a.localeCompare(b));
+        scope.default = left[0] ?? "";
+    }
+    writeDb(db);
+    return target;
+}
+function storeTokens(cfg, email, tokenResp) {
+    const db = readDb();
+    const scope = getScope(db, cfg);
+    const now = nowEpoch();
+    scope.accounts[email] = {
+        accessToken: tokenResp.accessToken,
+        refreshToken: tokenResp.refreshToken,
+        accessExpEpoch: now + (tokenResp.accessTokenExpiresInSec ?? 0),
+        refreshExpEpoch: tokenResp.refreshToken ? now + (tokenResp.refreshTokenExpiresInSec ?? 0) : 0
+    };
+    scope.default = email;
+    writeDb(db);
+}
+function parseCallbackQuery(queryString) {
+    const query = queryString.startsWith("?") ? queryString.slice(1) : queryString;
+    const params = new URLSearchParams(query);
+    const read = (...keys) => {
+        for (const k of keys) {
+            const value = params.get(k);
+            if (value) {
+                return value;
+            }
+        }
+        return undefined;
+    };
+    return {
+        email: read("email", "user", "username", "userEmail"),
+        accessToken: read("accessToken", "access_token", "jwt", "token"),
+        refreshToken: read("refreshToken", "refresh_token"),
+        firebaseToken: read("firebaseToken", "firebase_token", "idToken", "id_token"),
+        code: read("code", "authCode")
+    };
+}
+function openBrowser(url) {
+    const platform = process.platform;
+    let command;
+    let args;
+    if (platform === "darwin") {
+        command = "open";
+        args = [url];
+    }
+    else if (platform === "win32") {
+        command = "cmd";
+        args = ["/c", "start", "", url];
+    }
+    else {
+        command = "xdg-open";
+        args = [url];
+    }
+    try {
+        const child = (0, node_child_process_1.spawn)(command, args, { stdio: "ignore", detached: true });
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function startAuthListener(timeoutSec) {
+    const tokenKeys = new Set([
+        "accessToken",
+        "access_token",
+        "jwt",
+        "token",
+        "refreshToken",
+        "refresh_token",
+        "firebaseToken",
+        "firebase_token",
+        "idToken",
+        "id_token",
+        "code",
+        "authCode"
+    ]);
+    return new Promise((resolve, reject) => {
+        let callbackResolved = false;
+        let callbackSettled = false;
+        let startupSettled = false;
+        let callbackResolve = () => { };
+        let callbackReject = () => { };
+        const callback = new Promise((res, rej) => {
+            callbackResolve = res;
+            callbackReject = rej;
+        });
+        const server = node_http_1.default.createServer((req, res) => {
+            const reqUrl = new URL(req.url ?? "/", "http://127.0.0.1");
+            const hasToken = Array.from(reqUrl.searchParams.keys()).some((k) => tokenKeys.has(k));
+            if (hasToken) {
+                callbackResolved = true;
+                clearTimeout(timeout);
+                res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+                res.end("<html><body><h3>Authentication successful.</h3>You can close this tab.</body></html>");
+                const query = reqUrl.search;
+                server.close(() => {
+                    if (!callbackSettled) {
+                        callbackSettled = true;
+                        callbackResolve(query);
+                    }
+                });
+                return;
+            }
+            res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+            res.end(`<html><body><h3>Completing authentication...</h3>
+<script>
+const hash = window.location.hash ? window.location.hash.substring(1) : "";
+if (hash && !window.location.search) {
+  window.location.replace(window.location.pathname + "?" + hash);
+}
+</script>
+You can close this tab.</body></html>`);
+        });
+        const timeout = setTimeout(() => {
+            if (!callbackResolved) {
+                server.close(() => {
+                    if (!callbackSettled) {
+                        callbackSettled = true;
+                        callbackReject(new Error("Authentication timed out or callback not received."));
+                    }
+                });
+            }
+        }, timeoutSec * 1000);
+        let redirectUrl = "";
+        server.listen(0, "127.0.0.1", () => {
+            const address = server.address();
+            if (!address || typeof address === "string") {
+                clearTimeout(timeout);
+                server.close(() => {
+                    if (!startupSettled) {
+                        startupSettled = true;
+                        reject(new Error("Unable to acquire callback listener port."));
+                    }
+                });
+                return;
+            }
+            redirectUrl = `http://127.0.0.1:${address.port}/callback`;
+            if (!startupSettled) {
+                startupSettled = true;
+                resolve({ redirectUrl, callback });
+            }
+        });
+    });
+}
+async function login(cfg) {
+    if (!cfg.consoleBaseUrl) {
+        throw new Error(`No console URL configured for ${cfg.product}/${cfg.env}.`);
+    }
+    const listener = await startAuthListener(180);
+    const redirectUrl = listener.redirectUrl;
+    const loginUrl = new URL(`${cfg.consoleBaseUrl.replace(/\/$/, "")}/admin/sign-in`);
+    loginUrl.searchParams.set("redirect_url", redirectUrl);
+    loginUrl.searchParams.set("redirectUrl", redirectUrl);
+    loginUrl.searchParams.set("redirect_uri", redirectUrl);
+    process.stdout.write("Opening browser for authentication...\n");
+    process.stdout.write(`Login URL: ${loginUrl.toString()}\n`);
+    if (!openBrowser(loginUrl.toString())) {
+        process.stdout.write("Open this URL in your browser to continue:\n");
+        process.stdout.write(`${loginUrl.toString()}\n`);
+    }
+    const query = await listener.callback;
+    const parsed = parseCallbackQuery(query);
+    if (parsed.code) {
+        throw new Error("Authentication callback returned code-based response, exchange not implemented.");
+    }
+    let tokenResp;
+    if (parsed.firebaseToken) {
+        tokenResp = await authExchangeFirebaseToken(cfg, parsed.firebaseToken);
+    }
+    else if (parsed.accessToken) {
+        tokenResp = {
+            accessToken: parsed.accessToken,
+            refreshToken: parsed.refreshToken,
+            accessTokenExpiresInSec: 3600,
+            refreshTokenExpiresInSec: parsed.refreshToken ? 2_592_000 : 0
+        };
+    }
+    if (!tokenResp?.accessToken) {
+        throw new Error("Authentication callback did not include usable token data.");
+    }
+    const email = parsed.email ?? extractEmailFromToken(tokenResp.accessToken);
+    storeTokens(cfg, email, tokenResp);
+    return email;
+}
+async function validateAccessToken(cfg, accessToken) {
+    const url = new URL(`${cfg.baseUrl.replace(/\/$/, "")}/shell`);
+    url.searchParams.set("cmd", "help");
+    const response = await fetch(url, {
+        method: "GET",
+        headers: {
+            "X-edge-state": authStateHeader(cfg),
+            Authorization: `Bearer ${accessToken}`
+        }
+    });
+    return response.status === 200 || response.status === 204;
+}
+async function refreshDefaultToken(cfg) {
+    const db = readDb();
+    const scope = getScope(db, cfg);
+    const email = scope.default;
+    if (!email) {
+        return undefined;
+    }
+    const account = scope.accounts[email];
+    if (!account?.refreshToken) {
+        return undefined;
+    }
+    const refreshed = await authRefreshToken(cfg, account.refreshToken);
+    const merged = {
+        accessToken: refreshed.accessToken,
+        refreshToken: refreshed.refreshToken || account.refreshToken,
+        accessTokenExpiresInSec: refreshed.accessTokenExpiresInSec,
+        refreshTokenExpiresInSec: refreshed.refreshTokenExpiresInSec
+    };
+    storeTokens(cfg, email, merged);
+    return merged.accessToken;
+}
+async function resolveAccessToken(cfg, forceRefresh = false) {
+    const override = getAuthHeaderFromOverride(cfg.auth);
+    if (override) {
+        throw new Error("Cannot derive JWT token when --auth basic credentials are used.");
+    }
+    const db = readDb();
+    const scope = getScope(db, cfg);
+    const email = scope.default;
+    if (!email) {
+        throw new Error(`No JWT session for ${cfg.product}/${cfg.env}. Run 'edge-cli login'.`);
+    }
+    const account = scope.accounts[email];
+    if (!account?.accessToken) {
+        throw new Error(`No access token for ${email}. Run 'edge-cli login'.`);
+    }
+    let accessToken = account.accessToken;
+    const expiry = account.accessExpEpoch ?? 0;
+    const now = nowEpoch();
+    if (forceRefresh && account.refreshToken) {
+        const refreshed = await refreshDefaultToken(cfg);
+        if (refreshed) {
+            return refreshed;
+        }
+    }
+    if (expiry > 0 && expiry <= now + 60 && account.refreshToken) {
+        try {
+            const refreshed = await refreshDefaultToken(cfg);
+            if (refreshed) {
+                accessToken = refreshed;
+            }
+        }
+        catch {
+            // continue with existing token
+        }
+    }
+    if (!(await validateAccessToken(cfg, accessToken)) && account.refreshToken) {
+        const refreshed = await refreshDefaultToken(cfg);
+        if (refreshed) {
+            accessToken = refreshed;
+        }
+    }
+    return accessToken;
+}
+async function resolveAuthHeader(cfg) {
+    const override = getAuthHeaderFromOverride(cfg.auth);
+    if (override) {
+        return override;
+    }
+    const accessToken = await resolveAccessToken(cfg);
+    return `Bearer ${accessToken}`;
+}

package/dist/lib/config.js

@@ -0,0 +1,216 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveEffectiveConfig = resolveEffectiveConfig;
+exports.setDefaultProduct = setDefaultProduct;
+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 promises_1 = __importDefault(require("node:readline/promises"));
+const default_edge_api_config_json_1 = __importDefault(require("../default-edge-api-config.json"));
+const EDGE_API_CONFIG_URL = "https://cdn.youkno.ai/tools/edge-api-config.json";
+const DEFAULT_EDGE_API_PATH = node_path_1.default.join(node_os_1.default.homedir(), ".edge-api");
+const FILE_KEYS = ["PRODUCT", "ENV", "BASE_URL", "CLIENT_ID", "CLIENT_AUTH"];
+function expandPath(inputPath) {
+    if (inputPath.startsWith("~/")) {
+        return node_path_1.default.join(node_os_1.default.homedir(), inputPath.slice(2));
+    }
+    if (inputPath === "~") {
+        return node_os_1.default.homedir();
+    }
+    return inputPath;
+}
+function parseEdgeApiFile(filePath) {
+    const out = {};
+    if (!node_fs_1.default.existsSync(filePath)) {
+        return out;
+    }
+    const content = node_fs_1.default.readFileSync(filePath, "utf8");
+    const lines = content.split(/\r?\n/);
+    for (const lineRaw of lines) {
+        const line = lineRaw.trim();
+        if (!line || line.startsWith("#")) {
+            continue;
+        }
+        const eqIndex = line.indexOf("=");
+        if (eqIndex <= 0) {
+            continue;
+        }
+        const key = line.slice(0, eqIndex).trim();
+        if (!FILE_KEYS.includes(key)) {
+            continue;
+        }
+        let value = line.slice(eqIndex + 1).trim();
+        if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        out[key] = value;
+    }
+    return out;
+}
+function toCliEnv(env) {
+    if (env === "devlocal" || env === "devel" || env === "prod") {
+        return env;
+    }
+    return "prod";
+}
+function resolveProductsConfig() {
+    const candidatePaths = [
+        process.env.EDGE_API_CONFIG_PATH ? node_path_1.default.resolve(expandPath(process.env.EDGE_API_CONFIG_PATH)) : undefined,
+        node_path_1.default.resolve(process.cwd(), "edge-api-config.json"),
+        node_path_1.default.resolve(process.cwd(), "..", "edge-api-config.json"),
+        node_path_1.default.resolve(__dirname, "..", "..", "..", "edge-api-config.json")
+    ].filter((p) => Boolean(p));
+    for (const candidatePath of candidatePaths) {
+        if (!node_fs_1.default.existsSync(candidatePath)) {
+            continue;
+        }
+        try {
+            const content = node_fs_1.default.readFileSync(candidatePath, "utf8");
+            return JSON.parse(content);
+        }
+        catch {
+            // Try next candidate
+        }
+    }
+    return default_edge_api_config_json_1.default;
+}
+function findProduct(product, config) {
+    const products = config.api?.products ?? {};
+    if (products[product]) {
+        return products[product];
+    }
+    for (const productConfig of Object.values(products)) {
+        const aliases = productConfig.aliases ?? [];
+        if (aliases.includes(product)) {
+            return productConfig;
+        }
+    }
+    return undefined;
+}
+function listProducts(config) {
+    const products = config.api?.products ?? {};
+    return Object.entries(products)
+        .filter(([, value]) => value.active !== false)
+        .map(([key]) => key)
+        .sort((a, b) => a.localeCompare(b));
+}
+async function selectProductInteractively(products) {
+    const rl = promises_1.default.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    try {
+        process.stdout.write("Select product:\n");
+        products.forEach((p, idx) => {
+            process.stdout.write(`  ${idx + 1}) ${p}\n`);
+        });
+        while (true) {
+            const inputRaw = await rl.question("Choose product number or name: ");
+            const input = inputRaw.trim().toLowerCase();
+            if (!input) {
+                continue;
+            }
+            if (/^\d+$/.test(input)) {
+                const index = Number(input) - 1;
+                if (index >= 0 && index < products.length) {
+                    return products[index];
+                }
+            }
+            if (products.includes(input)) {
+                return input;
+            }
+            process.stdout.write("Invalid selection.\n");
+        }
+    }
+    finally {
+        rl.close();
+    }
+}
+function resolveProductBaseUrl(product, config) {
+    const resolved = findProduct(product, config);
+    return resolved?.baseUrl ?? config.api?.defaultBaseUrl;
+}
+function resolveConsoleBaseUrl(product, env, config) {
+    const resolved = findProduct(product, config);
+    if (!resolved) {
+        return undefined;
+    }
+    return env === "prod" ? resolved.consoleBaseProd : resolved.consoleBaseTest;
+}
+function readMergedFileConfig(options) {
+    const configFiles = [
+        "/etc/edge-api",
+        node_path_1.default.resolve(process.cwd(), ".edge-api"),
+        node_path_1.default.join(node_os_1.default.homedir(), ".edge-api")
+    ];
+    if (options.configPath) {
+        configFiles.unshift(node_path_1.default.resolve(process.cwd(), options.configPath));
+    }
+    const fileConfig = configFiles
+        .filter((filePath, index, arr) => arr.indexOf(filePath) === index)
+        .map((filePath) => ({ filePath, cfg: parseEdgeApiFile(filePath) }))
+        .filter((entry) => Object.keys(entry.cfg).length > 0);
+    const merged = {};
+    for (const entry of fileConfig) {
+        Object.assign(merged, entry.cfg);
+    }
+    return {
+        merged,
+        usedFiles: fileConfig.map((entry) => entry.filePath)
+    };
+}
+async function resolveEffectiveConfig(options) {
+    const { merged, usedFiles } = readMergedFileConfig(options);
+    const env = toCliEnv(options.env ?? merged.ENV);
+    const productsConfig = resolveProductsConfig();
+    let product = (options.product ?? merged.PRODUCT ?? "").trim().toLowerCase();
+    if (!product) {
+        if (process.stdin.isTTY && process.stdout.isTTY) {
+            const available = listProducts(productsConfig);
+            if (available.length > 0) {
+                product = await selectProductInteractively(available);
+            }
+        }
+    }
+    if (!product) {
+        throw new Error("No product specified. Pass --product <name>, set PRODUCT in ~/.edge-api, or run 'edge-cli product:default <name>'.");
+    }
+    let baseUrl = options.baseUrl ?? merged.BASE_URL;
+    if (!baseUrl) {
+        if (env === "devlocal") {
+            baseUrl = "http://localhost:8080";
+        }
+        else {
+            baseUrl = resolveProductBaseUrl(product, productsConfig);
+        }
+    }
+    if (!baseUrl) {
+        throw new Error(`Unable to resolve base URL. Set --base-url, BASE_URL in .edge-api, or configure product '${product}' in edge-api-config.json (${EDGE_API_CONFIG_URL}).`);
+    }
+    return {
+        product,
+        env,
+        baseUrl,
+        consoleBaseUrl: resolveConsoleBaseUrl(product, env, productsConfig),
+        clientId: options.clientId ?? merged.CLIENT_ID,
+        auth: options.auth ?? merged.CLIENT_AUTH,
+        configFiles: usedFiles
+    };
+}
+function setDefaultProduct(product, filePath) {
+    const targetFile = node_path_1.default.resolve(expandPath(filePath ?? DEFAULT_EDGE_API_PATH));
+    const targetDir = node_path_1.default.dirname(targetFile);
+    node_fs_1.default.mkdirSync(targetDir, { recursive: true });
+    const existing = node_fs_1.default.existsSync(targetFile) ? node_fs_1.default.readFileSync(targetFile, "utf8") : "";
+    const lines = existing ? existing.split(/\r?\n/) : [];
+    const kept = lines.filter((line) => !line.trim().startsWith("PRODUCT="));
+    if (product && product.trim()) {
+        kept.push(`PRODUCT=${product.trim().toLowerCase()}`);
+    }
+    const content = kept.filter((line, idx, arr) => !(idx === arr.length - 1 && line === "")).join("\n");
+    node_fs_1.default.writeFileSync(targetFile, content ? `${content}\n` : "", "utf8");
+    return targetFile;
+}

package/dist/lib/http.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.basicAuthHeader = basicAuthHeader;
+exports.getText = getText;
+function basicAuthHeader(username, password) {
+    return `Basic ${Buffer.from(`${username}:${password}`).toString("base64")}`;
+}
+async function getText(url, headers) {
+    const response = await fetch(url, {
+        method: "GET",
+        headers
+    });
+    const body = await response.text();
+    return { status: response.status, body };
+}