@qpjoy/electron-launcher 0.2.0

package/dist/network-ownership-registry.d.ts

@@ -0,0 +1,68 @@
+export type ElectronLauncherNetworkOwnerState = 'connecting' | 'active' | 'stale' | 'released';
+export type ElectronLauncherNetworkOwnershipResource = 'dns-host' | 'dns-zone' | 'route-cidr' | 'reverse-proxy-route';
+export interface ElectronLauncherNetworkOwnershipRoute {
+    routeId?: string | null;
+    host: string;
+    dnsTarget?: string | null;
+    targetUrl?: string | null;
+    tlsMode?: string | null;
+    authRequired?: boolean | null;
+    enabled?: boolean | null;
+}
+export interface ElectronLauncherNetworkOwnershipClaim {
+    ownerId: string;
+    productId?: string | null;
+    instanceId?: string | null;
+    displayName?: string | null;
+    state?: ElectronLauncherNetworkOwnerState | null;
+    priority?: number | null;
+    leaseIp?: string | null;
+    gatewayIp?: string | null;
+    dnsHosts?: string[] | null;
+    dnsZones?: string[] | null;
+    routeCidrs?: string[] | null;
+    reverseProxyRoutes?: ElectronLauncherNetworkOwnershipRoute[] | null;
+    metadata?: Record<string, unknown> | null;
+    updatedAt?: string | null;
+}
+export interface ElectronLauncherNetworkOwner {
+    ownerId: string;
+    productId: string | null;
+    instanceId: string | null;
+    displayName: string | null;
+    state: ElectronLauncherNetworkOwnerState;
+    priority: number;
+    leaseIp: string | null;
+    gatewayIp: string | null;
+    metadata: Record<string, unknown> | null;
+    updatedAt: string | null;
+}
+export interface ElectronLauncherNetworkOwnershipEntry {
+    resource: ElectronLauncherNetworkOwnershipResource;
+    key: string;
+    ownerId: string;
+    productId: string | null;
+    priority: number;
+    state: ElectronLauncherNetworkOwnerState;
+    value: string;
+    target?: string | null;
+    route?: ElectronLauncherNetworkOwnershipRoute | null;
+}
+export interface ElectronLauncherNetworkOwnershipConflict {
+    resource: ElectronLauncherNetworkOwnershipResource;
+    key: string;
+    owners: string[];
+    reason: string;
+}
+export interface ElectronLauncherNetworkOwnershipRegistry {
+    owners: ElectronLauncherNetworkOwner[];
+    dnsHosts: ElectronLauncherNetworkOwnershipEntry[];
+    dnsZones: ElectronLauncherNetworkOwnershipEntry[];
+    routeCidrs: ElectronLauncherNetworkOwnershipEntry[];
+    reverseProxyRoutes: ElectronLauncherNetworkOwnershipEntry[];
+    conflicts: ElectronLauncherNetworkOwnershipConflict[];
+}
+export declare function buildElectronLauncherNetworkOwnershipRegistry(claims: ElectronLauncherNetworkOwnershipClaim[]): ElectronLauncherNetworkOwnershipRegistry;
+export declare function resolveElectronLauncherDnsOwner(registry: ElectronLauncherNetworkOwnershipRegistry, hostname: string): ElectronLauncherNetworkOwnershipEntry | null;
+export declare function mergedElectronLauncherDnsZones(registry: ElectronLauncherNetworkOwnershipRegistry): string[];
+export declare function mergedElectronLauncherReverseProxyRoutes(registry: ElectronLauncherNetworkOwnershipRegistry): ElectronLauncherNetworkOwnershipRoute[];

package/dist/network-ownership-registry.js

@@ -0,0 +1,286 @@
+import { isIP } from 'node:net';
+export function buildElectronLauncherNetworkOwnershipRegistry(claims) {
+    const normalized = claims
+        .map(normalizeClaim)
+        .filter((claim) => Boolean(claim));
+    const owners = normalized.map((claim) => claim.owner);
+    const dnsHosts = sortEntries(normalized.flatMap((claim) => claim.dnsHosts));
+    const dnsZones = sortEntries(normalized.flatMap((claim) => claim.dnsZones));
+    const routeCidrs = sortEntries(normalized.flatMap((claim) => claim.routeCidrs));
+    const reverseProxyRoutes = sortEntries(normalized.flatMap((claim) => claim.reverseProxyRoutes));
+    const conflicts = [
+        ...duplicateKeyConflicts('dns-host', dnsHosts),
+        ...duplicateKeyConflicts('dns-zone', dnsZones),
+        ...duplicateRouteConflicts(routeCidrs),
+        ...duplicateReverseProxyRouteConflicts(reverseProxyRoutes)
+    ];
+    return {
+        owners,
+        dnsHosts,
+        dnsZones,
+        routeCidrs,
+        reverseProxyRoutes,
+        conflicts
+    };
+}
+export function resolveElectronLauncherDnsOwner(registry, hostname) {
+    const host = normalizeDomain(hostname);
+    if (!host)
+        return null;
+    const exact = sortEntries(registry.dnsHosts.filter((entry) => entry.key === host))[0];
+    if (exact)
+        return exact;
+    const zones = registry.dnsZones
+        .filter((entry) => host === entry.key || host.endsWith(`.${entry.key}`))
+        .sort((left, right) => right.key.length - left.key.length || entrySort(left, right));
+    return zones[0] || null;
+}
+export function mergedElectronLauncherDnsZones(registry) {
+    return uniqueStrings(registry.dnsZones.map((entry) => entry.key));
+}
+export function mergedElectronLauncherReverseProxyRoutes(registry) {
+    const byHost = new Map();
+    for (const entry of sortEntries(registry.reverseProxyRoutes)) {
+        if (!entry.route || byHost.has(entry.key))
+            continue;
+        byHost.set(entry.key, entry.route);
+    }
+    return [...byHost.values()];
+}
+function normalizeClaim(input) {
+    const ownerId = normalizeOwnerId(input.ownerId);
+    if (!ownerId)
+        return null;
+    const state = normalizeState(input.state);
+    if (state === 'released')
+        return null;
+    const priority = normalizePriority(input.priority);
+    const productId = nullableString(input.productId);
+    const owner = {
+        ownerId,
+        productId,
+        instanceId: nullableString(input.instanceId),
+        displayName: nullableString(input.displayName),
+        state,
+        priority,
+        leaseIp: normalizeIpv4(input.leaseIp),
+        gatewayIp: normalizeIpv4(input.gatewayIp),
+        metadata: input.metadata && typeof input.metadata === 'object' ? input.metadata : null,
+        updatedAt: nullableString(input.updatedAt)
+    };
+    const entryBase = {
+        ownerId,
+        productId,
+        priority,
+        state
+    };
+    return {
+        owner,
+        dnsHosts: uniqueStrings((input.dnsHosts || []).map(normalizeDomain))
+            .map((host) => ({
+            ...entryBase,
+            resource: 'dns-host',
+            key: host,
+            value: host,
+            target: owner.gatewayIp || owner.leaseIp
+        })),
+        dnsZones: uniqueStrings((input.dnsZones || []).map(normalizeDomain))
+            .map((zone) => ({
+            ...entryBase,
+            resource: 'dns-zone',
+            key: zone,
+            value: zone,
+            target: owner.gatewayIp || owner.leaseIp
+        })),
+        routeCidrs: uniqueStrings((input.routeCidrs || []).map(normalizeIpv4Cidr))
+            .map((cidr) => ({
+            ...entryBase,
+            resource: 'route-cidr',
+            key: cidr,
+            value: cidr,
+            target: owner.leaseIp
+        })),
+        reverseProxyRoutes: normalizeRoutes(input.reverseProxyRoutes).map((route) => ({
+            ...entryBase,
+            resource: 'reverse-proxy-route',
+            key: route.host,
+            value: route.host,
+            target: route.targetUrl || route.dnsTarget || owner.gatewayIp || owner.leaseIp,
+            route
+        }))
+    };
+}
+function duplicateKeyConflicts(resource, entries) {
+    const conflicts = [];
+    for (const group of groupEntries(entries).values()) {
+        const owners = uniqueStrings(group.map((entry) => entry.ownerId));
+        if (owners.length <= 1)
+            continue;
+        const highest = group[0]?.priority ?? 0;
+        const samePriorityOwners = uniqueStrings(group.filter((entry) => entry.priority === highest).map((entry) => entry.ownerId));
+        if (samePriorityOwners.length > 1) {
+            conflicts.push({
+                resource,
+                key: group[0].key,
+                owners,
+                reason: 'same-priority owners claim the same resource'
+            });
+        }
+    }
+    return conflicts;
+}
+function duplicateRouteConflicts(entries) {
+    const conflicts = duplicateKeyConflicts('route-cidr', entries);
+    for (let i = 0; i < entries.length; i += 1) {
+        for (let j = i + 1; j < entries.length; j += 1) {
+            const left = entries[i];
+            const right = entries[j];
+            if (left.ownerId === right.ownerId || left.key === right.key)
+                continue;
+            if (cidrOverlaps(left.key, right.key)) {
+                conflicts.push({
+                    resource: 'route-cidr',
+                    key: `${left.key} <> ${right.key}`,
+                    owners: uniqueStrings([left.ownerId, right.ownerId]),
+                    reason: 'route CIDRs overlap'
+                });
+            }
+        }
+    }
+    return conflicts;
+}
+function duplicateReverseProxyRouteConflicts(entries) {
+    const conflicts = [];
+    for (const group of groupEntries(entries).values()) {
+        const owners = uniqueStrings(group.map((entry) => entry.ownerId));
+        if (owners.length <= 1)
+            continue;
+        const targets = uniqueStrings(group
+            .map((entry) => nullableString(entry.target))
+            .filter((target) => Boolean(target)));
+        if (targets.length > 1) {
+            conflicts.push({
+                resource: 'reverse-proxy-route',
+                key: group[0].key,
+                owners,
+                reason: 'same host maps to different upstream targets'
+            });
+        }
+    }
+    return conflicts;
+}
+function groupEntries(entries) {
+    const groups = new Map();
+    for (const entry of sortEntries(entries)) {
+        const group = groups.get(entry.key) || [];
+        group.push(entry);
+        groups.set(entry.key, group);
+    }
+    return groups;
+}
+function sortEntries(entries) {
+    return [...entries].sort(entrySort);
+}
+function entrySort(left, right) {
+    return right.priority - left.priority
+        || stateRank(right.state) - stateRank(left.state)
+        || left.key.localeCompare(right.key)
+        || left.ownerId.localeCompare(right.ownerId);
+}
+function stateRank(state) {
+    if (state === 'active')
+        return 3;
+    if (state === 'connecting')
+        return 2;
+    if (state === 'stale')
+        return 1;
+    return 0;
+}
+function normalizeRoutes(routes) {
+    return (routes || [])
+        .map((route) => {
+        const host = normalizeDomain(route?.host);
+        if (!host || route.enabled === false)
+            return null;
+        return {
+            ...route,
+            host,
+            dnsTarget: normalizeIpv4(route.dnsTarget) || nullableString(route.dnsTarget),
+            targetUrl: nullableString(route.targetUrl),
+            tlsMode: nullableString(route.tlsMode),
+            authRequired: route.authRequired === true,
+            enabled: true
+        };
+    })
+        .filter((route) => route !== null);
+}
+function normalizeOwnerId(value) {
+    const text = nullableString(value);
+    if (!text)
+        return null;
+    return text.replace(/[^a-zA-Z0-9_.:-]/g, '-').slice(0, 160) || null;
+}
+function normalizeState(value) {
+    if (value === 'connecting' || value === 'active' || value === 'stale' || value === 'released')
+        return value;
+    return 'active';
+}
+function normalizePriority(value) {
+    const number = typeof value === 'number' ? value : Number(value);
+    return Number.isFinite(number) ? Math.trunc(number) : 100;
+}
+function normalizeDomain(value) {
+    return typeof value === 'string'
+        ? value.trim().toLowerCase().replace(/^\.+|\.+$/g, '')
+        : '';
+}
+function normalizeIpv4(value) {
+    const text = nullableString(value);
+    return text && isIP(text) === 4 ? text : null;
+}
+function normalizeIpv4Cidr(value) {
+    const text = nullableString(value);
+    if (!text)
+        return '';
+    const [rawIp, rawPrefix] = text.split('/');
+    if (isIP(rawIp) !== 4)
+        return '';
+    const prefix = rawPrefix === undefined ? 32 : Number(rawPrefix);
+    if (!Number.isInteger(prefix) || prefix < 0 || prefix > 32)
+        return '';
+    return `${rawIp}/${prefix}`;
+}
+function cidrOverlaps(left, right) {
+    const leftRange = cidrRange(left);
+    const rightRange = cidrRange(right);
+    if (!leftRange || !rightRange)
+        return false;
+    return leftRange.start <= rightRange.end && rightRange.start <= leftRange.end;
+}
+function cidrRange(cidr) {
+    const [ip, rawPrefix] = cidr.split('/');
+    if (isIP(ip) !== 4)
+        return null;
+    const prefix = Number(rawPrefix);
+    if (!Number.isInteger(prefix) || prefix < 0 || prefix > 32)
+        return null;
+    const base = ipv4ToNumber(ip);
+    const mask = prefix === 0 ? 0 : (0xffffffff << (32 - prefix)) >>> 0;
+    const start = (base & mask) >>> 0;
+    const hostMask = (~mask) >>> 0;
+    return {
+        start,
+        end: (start | hostMask) >>> 0
+    };
+}
+function ipv4ToNumber(ip) {
+    return ip.split('.')
+        .map((part) => Number(part))
+        .reduce((acc, part) => ((acc << 8) + part) >>> 0, 0);
+}
+function uniqueStrings(values) {
+    return [...new Set(values.filter(Boolean))];
+}
+function nullableString(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : null;
+}

package/dist/release-updater.d.ts

@@ -0,0 +1,129 @@
+import type { FetchLike } from '@qpjoy/mx-launcher-core';
+export type ElectronLauncherReleaseUpdateMode = 'none' | 'automatic' | 'manual' | 'mandatory';
+export type ElectronLauncherReleaseActivationMode = 'hot-auto' | 'hot-manual' | 'restart-auto' | 'restart-manual' | 'installer-manual';
+export interface ElectronLauncherReleasePolicyDecision {
+    componentKind: string;
+    componentId: string;
+    currentVersion: string;
+    targetVersion: string;
+    updateAvailable: boolean;
+    updateMode: ElectronLauncherReleaseUpdateMode;
+    canSkip: boolean;
+    canDefer: boolean;
+    requiresGate: boolean;
+    rollbackRequired: boolean;
+    reason: string;
+}
+export interface ElectronLauncherReleaseArtifactRef {
+    artifactId: string;
+    kind: string;
+    componentId: string;
+    version: string;
+    source: string;
+    url: string | null;
+    digest: string | null;
+    signature: string | null;
+    sizeBytes: number | null;
+    platform?: string | null;
+    activation: ElectronLauncherReleaseActivationMode;
+    autoApply: boolean;
+    restartRequired: boolean;
+    requiredAppRestart: boolean;
+    notes: string[];
+}
+export interface ElectronLauncherReleasePlan {
+    planId: string;
+    releaseId: string;
+    environment: string;
+    channel: string;
+    installId: string | null;
+    userId: string | null;
+    createdBy: string;
+    components: {
+        launcher?: ElectronLauncherReleasePolicyDecision;
+        app?: ElectronLauncherReleasePolicyDecision;
+    };
+    artifacts: ElectronLauncherReleaseArtifactRef[];
+    rollout?: {
+        strategy?: string;
+        percentage?: number;
+        segmentId?: string;
+        rings?: string[];
+        featureKeys?: string[];
+        channels?: string[];
+        allowAutoPromote?: boolean;
+        canaryMetricGate?: string;
+    };
+    activation?: {
+        checkSource?: string;
+        hotUpdateAuto?: boolean;
+        hotUpdateToast?: boolean;
+        majorUpdateRequiresInstaller?: boolean;
+        restartAfterApply?: boolean;
+        manualConfirmRequired?: boolean;
+        connectionSafeMode?: boolean;
+    };
+    test?: {
+        suiteId?: string;
+        gate?: {
+            verdict?: string;
+            reason?: string;
+        };
+    };
+    decisions?: {
+        readyToPromote?: boolean;
+        requiresApproval?: boolean;
+        canaryAllowed?: boolean;
+        rollbackRequired?: boolean;
+        nextActions?: string[];
+    };
+    createdAt: string;
+}
+export interface ElectronLauncherUpdateCheckInput {
+    componentId: string;
+    componentKind?: string;
+    currentVersion: string;
+    channel: string;
+    installId?: string | null;
+    userId?: string | null;
+    platform?: string | null;
+}
+export interface ElectronLauncherUpdateCheckResult {
+    checkedAt: string;
+    baseUrl: string;
+    status: 'up-to-date' | 'update-available' | 'blocked' | 'failed';
+    plan: ElectronLauncherReleasePlan | null;
+    decision: ElectronLauncherReleasePolicyDecision;
+    artifacts: ElectronLauncherReleaseArtifactRef[];
+    reason: string;
+}
+export interface ElectronLauncherReleaseUpdaterOptions {
+    baseUrl: string;
+    fetchImpl?: FetchLike;
+    reportInstallId?: string | null;
+}
+export interface ElectronLauncherReleaseReportInput {
+    taskId?: string | null;
+    installId?: string | null;
+    status: string;
+    error?: string | null;
+    metadata?: Record<string, unknown>;
+}
+export interface ElectronLauncherArtifactDownloadInput {
+    artifact: ElectronLauncherReleaseArtifactRef;
+    targetPath: string;
+    maxRedirects?: number;
+}
+export interface ElectronLauncherArtifactDownloadResult {
+    ok: boolean;
+    targetPath: string;
+    digest: string | null;
+    expectedDigest: string | null;
+    bytes: number;
+}
+export interface ElectronLauncherReleaseUpdater {
+    check(input: ElectronLauncherUpdateCheckInput): Promise<ElectronLauncherUpdateCheckResult>;
+    report(input: ElectronLauncherReleaseReportInput): Promise<Record<string, unknown>>;
+}
+export declare function createElectronLauncherReleaseUpdater(options: ElectronLauncherReleaseUpdaterOptions): ElectronLauncherReleaseUpdater;
+export declare function downloadElectronLauncherReleaseArtifactToFile(input: ElectronLauncherArtifactDownloadInput): Promise<ElectronLauncherArtifactDownloadResult>;

package/dist/release-updater.js

@@ -0,0 +1,195 @@
+import { createHash } from 'node:crypto';
+import { createWriteStream } from 'node:fs';
+import { mkdir, rename, rm } from 'node:fs/promises';
+import { get as httpGet } from 'node:http';
+import { get as httpsGet } from 'node:https';
+import { dirname } from 'node:path';
+import { pipeline } from 'node:stream/promises';
+export function createElectronLauncherReleaseUpdater(options) {
+    const baseUrl = normalizeBaseUrl(options.baseUrl);
+    const fetchImpl = options.fetchImpl ?? globalFetch();
+    return {
+        async check(input) {
+            const checkedAt = new Date().toISOString();
+            const plansPayload = await requestJson(fetchImpl, joinUrl(baseUrl, '/internal/v1/release-management/plans'), 'GET');
+            const plans = Array.isArray(plansPayload.plans) ? plansPayload.plans : [];
+            const plan = selectReleasePlan(plans, input);
+            const planDecision = plan ? selectPlanDecision(plan, input) : null;
+            const fallbackTargetVersion = planDecision?.targetVersion || input.currentVersion;
+            const decisionPayload = await requestJson(fetchImpl, joinUrl(baseUrl, '/internal/v1/releases/policy/evaluate'), 'POST', {
+                componentKind: planDecision?.componentKind || input.componentKind || 'app-managed',
+                componentId: input.componentId,
+                currentVersion: input.currentVersion,
+                targetVersion: fallbackTargetVersion,
+                channel: input.channel,
+                installId: input.installId ?? null,
+                userId: input.userId ?? null
+            });
+            const decision = decisionPayload.decision;
+            const artifacts = plan ? matchingArtifacts(plan, input.componentId, input.platform) : [];
+            const gateVerdict = plan?.test?.gate?.verdict;
+            const status = !decision.updateAvailable
+                ? 'up-to-date'
+                : gateVerdict && gateVerdict !== 'passed'
+                    ? 'blocked'
+                    : 'update-available';
+            return {
+                checkedAt,
+                baseUrl,
+                status,
+                plan,
+                decision,
+                artifacts,
+                reason: status === 'blocked'
+                    ? plan?.test?.gate?.reason || `release gate is ${gateVerdict}`
+                    : decision.reason
+            };
+        },
+        async report(input) {
+            const installId = input.installId ?? options.reportInstallId ?? null;
+            return requestJson(fetchImpl, joinUrl(baseUrl, '/internal/v1/release/reports'), 'POST', {
+                taskId: input.taskId ?? undefined,
+                installId: installId ?? undefined,
+                status: input.status,
+                error: input.error ?? null,
+                metadata: input.metadata ?? {}
+            });
+        }
+    };
+}
+export async function downloadElectronLauncherReleaseArtifactToFile(input) {
+    const url = input.artifact.url?.trim();
+    if (!url)
+        throw new Error(`Release artifact ${input.artifact.artifactId} has no URL`);
+    await mkdir(dirname(input.targetPath), { recursive: true });
+    const tempPath = `${input.targetPath}.download`;
+    await rm(tempPath, { force: true });
+    const hash = createHash('sha256');
+    let bytes = 0;
+    let digest = null;
+    const expectedDigest = normalizeDigest(input.artifact.digest);
+    try {
+        const response = await openDownloadStream(url, input.maxRedirects ?? 3);
+        response.stream.on('data', (chunk) => {
+            bytes += chunk.length;
+            hash.update(chunk);
+        });
+        await pipeline(response.stream, createWriteStream(tempPath, { flags: 'wx' }));
+        digest = `sha256:${hash.digest('hex')}`;
+        if (Number.isFinite(input.artifact.sizeBytes) && bytes !== input.artifact.sizeBytes) {
+            throw new Error(`Release artifact size mismatch: expected ${input.artifact.sizeBytes}, got ${bytes}`);
+        }
+        if (expectedDigest && digest !== expectedDigest) {
+            throw new Error(`Release artifact digest mismatch: expected ${expectedDigest}, got ${digest}`);
+        }
+    }
+    catch (error) {
+        await rm(tempPath, { force: true });
+        throw error;
+    }
+    await rename(tempPath, input.targetPath);
+    return {
+        ok: true,
+        targetPath: input.targetPath,
+        digest,
+        expectedDigest,
+        bytes
+    };
+}
+function selectReleasePlan(plans, input) {
+    return plans.find((plan) => {
+        if (plan.channel !== input.channel)
+            return false;
+        if (plan.installId && plan.installId !== input.installId)
+            return false;
+        if (plan.userId && plan.userId !== input.userId)
+            return false;
+        return Boolean(selectPlanDecision(plan, input));
+    }) ?? null;
+}
+function selectPlanDecision(plan, input) {
+    const decisions = [plan.components?.launcher, plan.components?.app].filter(Boolean);
+    return decisions.find((decision) => {
+        if (!decision)
+            return false;
+        if (decision.componentId !== input.componentId)
+            return false;
+        if (input.componentKind && decision.componentKind !== input.componentKind)
+            return false;
+        if (decision.currentVersion && decision.currentVersion !== input.currentVersion)
+            return true;
+        return decision.targetVersion !== input.currentVersion;
+    }) ?? null;
+}
+function matchingArtifacts(plan, componentId, platform) {
+    const normalizedPlatform = platform?.trim() || null;
+    return (Array.isArray(plan.artifacts) ? plan.artifacts : [])
+        .filter((artifact) => artifact.componentId === componentId || !artifact.componentId)
+        .filter((artifact) => !artifact.platform || !normalizedPlatform || artifact.platform === normalizedPlatform);
+}
+async function requestJson(fetchImpl, url, method, body) {
+    const response = await fetchImpl(url, {
+        method,
+        headers: {
+            accept: 'application/json',
+            ...(body ? { 'content-type': 'application/json' } : {})
+        },
+        ...(body ? { body: JSON.stringify(body) } : {})
+    });
+    const text = await response.text();
+    const payload = text.trim() ? JSON.parse(text) : null;
+    if (!response.ok) {
+        throw new Error(`Release Center request failed: ${response.status}${response.statusText ? ` ${response.statusText}` : ''}`);
+    }
+    return payload;
+}
+async function openDownloadStream(url, redirectsLeft) {
+    const parsed = new URL(url);
+    const getter = parsed.protocol === 'https:' ? httpsGet : parsed.protocol === 'http:' ? httpGet : null;
+    if (!getter)
+        throw new Error(`Unsupported release artifact URL protocol: ${parsed.protocol}`);
+    return new Promise((resolve, reject) => {
+        const req = getter(parsed, (response) => {
+            const status = response.statusCode || 0;
+            const location = response.headers.location;
+            if (status >= 300 && status < 400 && location) {
+                response.resume();
+                if (redirectsLeft <= 0) {
+                    reject(new Error(`Too many redirects while downloading release artifact: ${url}`));
+                    return;
+                }
+                const redirected = new URL(location, parsed).toString();
+                openDownloadStream(redirected, redirectsLeft - 1).then(resolve, reject);
+                return;
+            }
+            if (status < 200 || status >= 300) {
+                response.resume();
+                reject(new Error(`Release artifact download failed: HTTP ${status}`));
+                return;
+            }
+            resolve({ stream: response });
+        });
+        req.on('error', reject);
+    });
+}
+function normalizeBaseUrl(value) {
+    const trimmed = value.trim().replace(/\/+$/, '');
+    if (!trimmed)
+        throw new Error('Release Center baseUrl is required');
+    return trimmed;
+}
+function joinUrl(baseUrl, pathName) {
+    return `${baseUrl}${pathName.startsWith('/') ? pathName : `/${pathName}`}`;
+}
+function normalizeDigest(value) {
+    const normalized = value?.trim().toLowerCase();
+    if (!normalized)
+        return null;
+    return normalized.startsWith('sha256:') ? normalized : `sha256:${normalized}`;
+}
+function globalFetch() {
+    const maybeFetch = globalThis.fetch;
+    if (!maybeFetch)
+        throw new Error('No fetch implementation available for Electron Launcher updater');
+    return maybeFetch.bind(globalThis);
+}