@rynx-ai/daemon 0.1.0 → 0.1.9

package/dist/chrome-for-testing-release-resolver.js

@@ -0,0 +1,214 @@
+/**
+ * Resolves an explicit Chrome for Testing channel or full version through the
+ * public GoogleChromeLabs JSON API.
+ *
+ * The upstream manifests intentionally contain download URLs but no archive
+ * digest. A resolved release therefore does not claim a SHA-256. The artifact
+ * store computes and records the archive digest when it installs these bytes.
+ */
+import { resolveChromeForTestingPlatform, } from "./chrome-for-testing-store.js";
+const MANIFEST_BASE_URL = "https://googlechromelabs.github.io/chrome-for-testing/";
+const CHANNEL_MANIFEST_URL = `${MANIFEST_BASE_URL}last-known-good-versions-with-downloads.json`;
+const ARTIFACT_BASE_URL = "https://storage.googleapis.com/chrome-for-testing-public/";
+const MAX_MANIFEST_BYTES = 64 * 1024;
+const MAX_CHROME_DOWNLOADS = 16;
+const MAX_URL_BYTES = 2 * 1024;
+const VERSION_PATTERN = /^\d{1,6}\.\d{1,6}\.\d{1,6}\.\d{1,6}$/;
+const REVISION_PATTERN = /^\d{1,20}$/;
+export async function resolveChromeForTestingRelease(selector, options = {}) {
+    const platform = resolveChromeForTestingPlatform(options.platform ?? process.platform, options.arch ?? process.arch);
+    const normalizedSelector = validateSelector(selector);
+    const manifestUrl = normalizedSelector.kind === "channel"
+        ? CHANNEL_MANIFEST_URL
+        : `${MANIFEST_BASE_URL}${normalizedSelector.version}.json`;
+    const manifest = await fetchManifest(manifestUrl, options.fetchMetadata ?? defaultFetchMetadata, options.signal);
+    const release = normalizedSelector.kind === "channel"
+        ? selectChannelRelease(manifest, normalizedSelector.channel)
+        : selectVersionRelease(manifest, normalizedSelector.version);
+    const url = selectChromeDownload(release, platform.artifactPlatform);
+    return {
+        version: release.version,
+        platform: platform.artifactPlatform,
+        url,
+        manifestUrl,
+    };
+}
+function validateSelector(selector) {
+    if (!isRecord(selector)) {
+        throw new Error("Chrome for Testing release selector must be an object");
+    }
+    if (selector.kind === "channel") {
+        if (!isReleaseChannel(selector.channel)) {
+            throw new Error("Chrome for Testing channel must be Stable, Beta, Dev, or Canary");
+        }
+        return { kind: "channel", channel: selector.channel };
+    }
+    if (selector.kind === "version") {
+        if (typeof selector.version !== "string" || !VERSION_PATTERN.test(selector.version)) {
+            throw new Error("Chrome for Testing version must be an explicit four-part build version");
+        }
+        return { kind: "version", version: selector.version };
+    }
+    throw new Error("Chrome for Testing release selector kind must be channel or version");
+}
+async function fetchManifest(manifestUrl, fetchMetadata, signal) {
+    assertManifestUrl(manifestUrl);
+    const response = await fetchMetadata(manifestUrl, {
+        signal,
+        redirect: "error",
+        headers: { accept: "application/json" },
+    });
+    if (!response.ok) {
+        throw new Error(`Chrome for Testing metadata request failed: HTTP ${response.status}${response.statusText ? ` ${response.statusText}` : ""}`);
+    }
+    if (!response.body)
+        throw new Error("Chrome for Testing metadata response has no body");
+    const contentLength = parseContentLength(response.headers.get("content-length"));
+    if (contentLength !== undefined && contentLength > MAX_MANIFEST_BYTES) {
+        throw new Error(`Chrome for Testing metadata exceeds ${MAX_MANIFEST_BYTES} bytes`);
+    }
+    const reader = response.body.getReader();
+    const chunks = [];
+    let bytes = 0;
+    try {
+        while (true) {
+            const next = await reader.read();
+            if (next.done)
+                break;
+            bytes += next.value.byteLength;
+            if (bytes > MAX_MANIFEST_BYTES) {
+                await reader.cancel("Chrome for Testing metadata exceeds its transfer limit");
+                throw new Error(`Chrome for Testing metadata exceeds ${MAX_MANIFEST_BYTES} bytes`);
+            }
+            chunks.push(Buffer.from(next.value));
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    let text;
+    try {
+        text = new TextDecoder("utf-8", { fatal: true }).decode(Buffer.concat(chunks, bytes));
+    }
+    catch {
+        throw new Error("Chrome for Testing metadata is not valid UTF-8");
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new Error("Chrome for Testing metadata is invalid JSON");
+    }
+}
+function selectChannelRelease(manifest, channel) {
+    if (!isRecord(manifest))
+        throw invalidManifest();
+    if (typeof manifest.timestamp !== "string" ||
+        !Number.isFinite(Date.parse(manifest.timestamp)) ||
+        !isRecord(manifest.channels)) {
+        throw invalidManifest();
+    }
+    const release = manifest.channels[channel];
+    const parsed = validateRelease(release);
+    if (parsed.channel !== channel)
+        throw invalidManifest();
+    return parsed;
+}
+function selectVersionRelease(manifest, expectedVersion) {
+    const release = validateRelease(manifest);
+    if (release.version !== expectedVersion || release.channel !== undefined)
+        throw invalidManifest();
+    return release;
+}
+function validateRelease(value) {
+    if (!isRecord(value))
+        throw invalidManifest();
+    if (typeof value.version !== "string" ||
+        !VERSION_PATTERN.test(value.version) ||
+        typeof value.revision !== "string" ||
+        !REVISION_PATTERN.test(value.revision) ||
+        !isRecord(value.downloads) ||
+        !Array.isArray(value.downloads.chrome) ||
+        value.downloads.chrome.length === 0 ||
+        value.downloads.chrome.length > MAX_CHROME_DOWNLOADS) {
+        throw invalidManifest();
+    }
+    if ("channel" in value && !isReleaseChannel(value.channel))
+        throw invalidManifest();
+    return {
+        version: value.version,
+        channel: value.channel,
+        chromeDownloads: value.downloads.chrome,
+    };
+}
+function selectChromeDownload(release, platform) {
+    let selected;
+    for (const entry of release.chromeDownloads) {
+        if (!isRecord(entry) ||
+            typeof entry.platform !== "string" ||
+            entry.platform.length > 32 ||
+            typeof entry.url !== "string" ||
+            Buffer.byteLength(entry.url, "utf8") > MAX_URL_BYTES) {
+            throw invalidManifest();
+        }
+        if (entry.platform !== platform)
+            continue;
+        if (selected !== undefined) {
+            throw new Error(`Chrome for Testing metadata contains duplicate ${platform} downloads`);
+        }
+        selected = validateArtifactUrl(entry.url, release.version, platform);
+    }
+    if (selected === undefined) {
+        throw new Error(`Chrome for Testing metadata has no Chrome download for ${platform}`);
+    }
+    return selected;
+}
+function assertManifestUrl(value) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new Error("Chrome for Testing manifest URL is invalid");
+    }
+    if (url.origin !== "https://googlechromelabs.github.io" ||
+        !url.pathname.startsWith("/chrome-for-testing/") ||
+        url.username ||
+        url.password ||
+        url.search ||
+        url.hash) {
+        throw new Error("Chrome for Testing manifest URL is not an allowed official URL");
+    }
+}
+function validateArtifactUrl(value, version, platform) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new Error("Chrome for Testing metadata contains an invalid artifact URL");
+    }
+    const expected = `${ARTIFACT_BASE_URL}${version}/${platform}/chrome-${platform}.zip`;
+    if (url.href !== expected || url.username || url.password || url.search || url.hash) {
+        throw new Error("Chrome for Testing metadata contains a non-official artifact URL");
+    }
+    return url.href;
+}
+function parseContentLength(raw) {
+    if (raw === null || !/^\d+$/.test(raw))
+        return undefined;
+    const value = Number(raw);
+    return Number.isSafeInteger(value) ? value : undefined;
+}
+function invalidManifest() {
+    return new Error("invalid Chrome for Testing release metadata");
+}
+function isReleaseChannel(value) {
+    return value === "Stable" || value === "Beta" || value === "Dev" || value === "Canary";
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function defaultFetchMetadata(url, init) {
+    return fetch(url, init);
+}

package/dist/chrome-for-testing-store.d.ts

@@ -0,0 +1,85 @@
+export type ChromeForTestingHostPlatform = "darwin-arm64" | "darwin-x64" | "linux-x64";
+export type ChromeForTestingArtifactPlatform = "mac-arm64" | "mac-x64" | "linux64";
+export interface ChromeForTestingPlatformDescriptor {
+    hostPlatform: ChromeForTestingHostPlatform;
+    artifactPlatform: ChromeForTestingArtifactPlatform;
+    executableRelativePath: string;
+}
+/** Exact release metadata supplied by configuration or an explicit install/update command. */
+export interface ChromeForTestingBuildMetadata {
+    version: string;
+    platform: ChromeForTestingArtifactPlatform;
+    url: string;
+    /** Lowercase hexadecimal SHA-256 of the downloaded ZIP archive. */
+    sha256: string;
+}
+/**
+ * A release resolved from the official Chrome for Testing manifest.
+ *
+ * The upstream manifest has no digest. `installResolved` computes the archive
+ * SHA-256 during the first HTTPS download and records it as the immutable local
+ * build identity; this is not represented as an upstream authenticity proof.
+ */
+export interface ResolvedChromeForTestingBuildMetadata {
+    version: string;
+    platform: ChromeForTestingArtifactPlatform;
+    url: string;
+}
+export interface InstalledChromeForTestingBuild {
+    version: string;
+    hostPlatform: ChromeForTestingHostPlatform;
+    artifactPlatform: ChromeForTestingArtifactPlatform;
+    sha256: string;
+    sourceUrl: string;
+    installedAt: string;
+    installPath: string;
+    executablePath: string;
+}
+export type ChromeForTestingArtifactFetcher = (url: string, init: {
+    signal?: AbortSignal;
+}) => Promise<Response>;
+export type ChromeForTestingZipExtractor = (archivePath: string, destination: string) => Promise<void>;
+export interface ChromeForTestingArtifactStoreOptions {
+    /** Defaults to ~/.rynx/cache/browser/chrome-for-testing. */
+    rootDir?: string;
+    /** Injectable only so platform behavior can be tested on any build host. */
+    platform?: string;
+    /** Injectable only so platform behavior can be tested on any build host. */
+    arch?: string;
+    fetchArtifact?: ChromeForTestingArtifactFetcher;
+    extractZip?: ChromeForTestingZipExtractor;
+    maxArchiveBytes?: number;
+    now?: () => Date;
+    /** Defaults to ~/.rynx/browser/profiles/headless-chromium. */
+    headlessProfileRoot?: string;
+    /** Injectable only for deterministic live-process lease tests. */
+    isProcessLive?: (pid: number) => boolean;
+}
+export interface InstallChromeForTestingOptions {
+    signal?: AbortSignal;
+    onProgress?: (message: string) => void;
+}
+export interface PruneChromeForTestingStagingOptions {
+    olderThanMs?: number;
+}
+export interface PruneChromeForTestingBuildsResult {
+    removedBuilds: InstalledChromeForTestingBuild[];
+    retainedBuilds: InstalledChromeForTestingBuild[];
+}
+export interface ChromeForTestingLaunchReservation {
+    build: InstalledChromeForTestingBuild;
+    /** Release after the Browser process lease has been published, or launch fails. */
+    release(): void;
+}
+export interface ChromeForTestingArtifactStore {
+    install(build: ChromeForTestingBuildMetadata, options?: InstallChromeForTestingOptions): Promise<InstalledChromeForTestingBuild>;
+    installResolved(build: ResolvedChromeForTestingBuildMetadata, options?: InstallChromeForTestingOptions): Promise<InstalledChromeForTestingBuild>;
+    readActive(): InstalledChromeForTestingBuild | undefined;
+    reserveActiveForLaunch(): Promise<ChromeForTestingLaunchReservation | undefined>;
+    pruneBuilds(): PruneChromeForTestingBuildsResult;
+    pruneStaging(options?: PruneChromeForTestingStagingOptions): number;
+}
+/** The support matrix is deliberately explicit; adding a host requires tests and a known layout. */
+export declare function resolveChromeForTestingPlatform(platform?: string, arch?: string): ChromeForTestingPlatformDescriptor;
+export declare function isChromeForTestingHostSupported(platform?: string, arch?: string): boolean;
+export declare function createChromeForTestingArtifactStore(options?: ChromeForTestingArtifactStoreOptions): ChromeForTestingArtifactStore;