@coreframe/scripts 0.1.0 → 0.1.2

package/dist/deploy/tauri-release.js

@@ -1,512 +1 @@
-import { randomUUID } from "node:crypto";
-import { constants } from "node:fs";
-import { access, cp, mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
-import { basename, dirname, join, relative, resolve, sep } from "node:path";
-import { setTimeout as delay } from "node:timers/promises";
-import nanoSpawn from "nano-spawn";
-import { glob } from "tinyglobby";
-import { tauriReleasePlatforms } from "./config.js";
-const defaultWorkflowName = "tauri-release-artifacts.yml";
-const defaultWorkflowPollIntervalMs = 15_000;
-const defaultWorkflowTimeoutMs = 60 * 60_000;
-const defaultPlatformConfig = {
-    android: {
-        artifactGlobs: ["tauri/src-tauri/target/**/*.sig", "tauri/gen/android/**/*.sig"],
-        buildArgs: ["tauri", "android", "build", "--target", "aarch64-linux-android"],
-        targetTriple: "aarch64-linux-android",
-        updatePlatform: "android-aarch64",
-    },
-    ios: {
-        artifactGlobs: ["tauri/src-tauri/target/**/*.sig", "tauri/gen/apple/**/*.sig"],
-        buildArgs: ["tauri", "ios", "build", "--target", "aarch64-apple-ios"],
-        targetTriple: "aarch64-apple-ios",
-        updatePlatform: "ios-aarch64",
-    },
-    linux: {
-        artifactGlobs: [
-            "tauri/src-tauri/target/x86_64-unknown-linux-gnu/release/bundle/**/*.sig",
-            "tauri/src-tauri/target/release/bundle/**/*.sig",
-            "tauri/src-tauri/target/**/release/bundle/**/*.sig",
-        ],
-        buildArgs: ["tauri", "build", "--target", "x86_64-unknown-linux-gnu", "--", "--locked"],
-        targetTriple: "x86_64-unknown-linux-gnu",
-        updatePlatform: "linux-x86_64",
-    },
-    macos: {
-        artifactGlobs: [
-            "tauri/src-tauri/target/aarch64-apple-darwin/release/bundle/**/*.sig",
-            "tauri/src-tauri/target/release/bundle/**/*.sig",
-            "tauri/src-tauri/target/**/release/bundle/**/*.sig",
-        ],
-        buildArgs: ["tauri", "build", "--target", "aarch64-apple-darwin", "--", "--locked"],
-        targetTriple: "aarch64-apple-darwin",
-        updatePlatform: "darwin-aarch64",
-    },
-    windows: {
-        artifactGlobs: [
-            "tauri/src-tauri/target/x86_64-pc-windows-msvc/release/bundle/**/*.sig",
-            "tauri/src-tauri/target/release/bundle/**/*.sig",
-            "tauri/src-tauri/target/**/release/bundle/**/*.sig",
-        ],
-        buildArgs: ["tauri", "build", "--target", "x86_64-pc-windows-msvc", "--", "--locked"],
-        targetTriple: "x86_64-pc-windows-msvc",
-        updatePlatform: "windows-x86_64",
-    },
-};
-export function parseTauriReleasePlatformList(value) {
-    if (!value) {
-        return [];
-    }
-    return value
-        .split(/[,\s]+/u)
-        .filter(Boolean)
-        .map((platform) => parseTauriReleasePlatform(platform));
-}
-export function parseTauriReleasePlatform(value) {
-    if (isTauriReleasePlatform(value)) {
-        return value;
-    }
-    throw new Error(`Invalid Tauri release platform "${value}". Expected one of: ${tauriReleasePlatforms.join(", ")}.`);
-}
-export function resolveTauriReleasePlan({ args, config = {}, env, }) {
-    const localPlatforms = uniquePlatforms([
-        ...(config.localPlatforms ?? []),
-        ...parseTauriReleasePlatformList(env.TAURI_RELEASE_LOCAL_PLATFORMS),
-        ...args.tauriLocalPlatforms,
-    ]);
-    const workflowPlatforms = uniquePlatforms([
-        ...(config.workflowPlatforms ?? []),
-        ...parseTauriReleasePlatformList(env.TAURI_RELEASE_WORKFLOW_PLATFORMS),
-        ...args.tauriWorkflowPlatforms,
-    ]);
-    const duplicatedPlatforms = localPlatforms.filter((platform) => workflowPlatforms.includes(platform));
-    if (duplicatedPlatforms.length > 0) {
-        throw new Error(`Build each Tauri release platform either locally or through the workflow, not both: ${duplicatedPlatforms.join(", ")}.`);
-    }
-    return {
-        artifactDownloadDir: env.TAURI_RELEASE_ARTIFACT_DOWNLOAD_DIR ??
-            config.artifactDownloadDir ??
-            ".coreframe/tauri-artifacts",
-        b2ApplicationKey: env.B2_APPLICATION_KEY ?? env.B2_SECRET_ACCESS_KEY,
-        b2ApplicationKeyId: env.B2_APPLICATION_KEY_ID ?? env.B2_KEY_ID ?? env.B2_ACCESS_KEY_ID,
-        b2Bucket: config.b2Bucket ?? env.B2_BUCKET,
-        enabled: localPlatforms.length > 0 || workflowPlatforms.length > 0,
-        latestManifestPath: env.TAURI_RELEASE_LATEST_MANIFEST_PATH ?? config.latestManifestPath ?? "latest.json",
-        localPlatforms,
-        platform: resolvePlatformConfig(config.platform, env),
-        publicBaseUrl: config.publicBaseUrl ?? env.TAURI_RELEASE_PUBLIC_BASE_URL ?? env.UPDATE_PUBLIC_BASE_URL,
-        publicPathPrefix: env.TAURI_RELEASE_PUBLIC_PATH_PREFIX ??
-            config.publicPathPrefix ??
-            env.UPDATE_PUBLIC_PATH_PREFIX ??
-            "",
-        releaseNotesPath: env.TAURI_RELEASE_NOTES_FILE ?? config.releaseNotesPath,
-        releasePath: env.TAURI_RELEASE_PATH ?? config.releasePath ?? "releases/${version}",
-        releaseUploadDir: env.TAURI_RELEASE_UPLOAD_DIR ?? config.releaseUploadDir ?? "release-upload",
-        signingPrivateKey: env.TAURI_SIGNING_PRIVATE_KEY,
-        workflowName: args.tauriWorkflowName ??
-            env.TAURI_RELEASE_WORKFLOW_NAME ??
-            config.workflowName ??
-            defaultWorkflowName,
-        workflowPlatforms,
-        workflowPollIntervalMs: parsePositiveInteger(env.TAURI_RELEASE_WORKFLOW_POLL_SECONDS, "TAURI_RELEASE_WORKFLOW_POLL_SECONDS") * 1000 ||
-            config.workflowPollIntervalMs ||
-            defaultWorkflowPollIntervalMs,
-        workflowRef: args.tauriWorkflowRef ?? env.TAURI_RELEASE_WORKFLOW_REF ?? config.workflowRef,
-        workflowTimeoutMs: parsePositiveInteger(env.TAURI_RELEASE_WORKFLOW_TIMEOUT_MINUTES, "TAURI_RELEASE_WORKFLOW_TIMEOUT_MINUTES") * 60_000 ||
-            config.workflowTimeoutMs ||
-            defaultWorkflowTimeoutMs,
-    };
-}
-export async function validateTauriReleasePlan(plan, cwd = process.cwd()) {
-    if (!plan.enabled) {
-        return;
-    }
-    const missing = [
-        ["TAURI_RELEASE_PUBLIC_BASE_URL", plan.publicBaseUrl],
-        ["B2_APPLICATION_KEY_ID", plan.b2ApplicationKeyId],
-        ["B2_APPLICATION_KEY", plan.b2ApplicationKey],
-        ["B2_BUCKET", plan.b2Bucket],
-    ].flatMap(([name, value]) => (value ? [] : [name]));
-    if (missing.length > 0) {
-        throw new Error(`Missing required Tauri release configuration: ${missing.join(", ")}`);
-    }
-    try {
-        new URL(plan.publicBaseUrl);
-    }
-    catch {
-        throw new Error(`Invalid TAURI_RELEASE_PUBLIC_BASE_URL: ${plan.publicBaseUrl}`);
-    }
-    const tauriConfigPath = join(cwd, "tauri/src-tauri/tauri.conf.json");
-    if (!(await pathExists(tauriConfigPath))) {
-        throw new Error("Tauri release platforms were requested, but tauri/src-tauri/tauri.conf.json does not exist.");
-    }
-    if (plan.localPlatforms.length > 0 && !plan.signingPrivateKey) {
-        throw new Error("TAURI_SIGNING_PRIVATE_KEY is required for local Tauri release builds.");
-    }
-    if (plan.workflowPlatforms.length > 0) {
-        await nanoSpawn("gh", ["workflow", "view", plan.workflowName, "--ref", plan.workflowRef ?? (await currentGitRef())], {
-            stdin: "ignore",
-        });
-    }
-    await nanoSpawn("b2", ["version"], { stdin: "ignore" });
-}
-export async function writeTauriReleaseMetadata(plan, version, cwd = process.cwd()) {
-    if (!plan.enabled) {
-        return { files: [] };
-    }
-    const tauriConfigPath = join(cwd, "tauri/src-tauri/tauri.conf.json");
-    const cargoManifestPath = join(cwd, "tauri/src-tauri/Cargo.toml");
-    const cargoLockPath = join(cwd, "tauri/src-tauri/Cargo.lock");
-    const tauriConfigSource = await readFile(tauriConfigPath, "utf8");
-    const cargoManifestSource = await readFile(cargoManifestPath, "utf8");
-    const packageName = readCargoPackageName(cargoManifestSource, cargoManifestPath);
-    const files = [
-        { path: tauriConfigPath, source: tauriConfigSource },
-        { path: cargoManifestPath, source: cargoManifestSource },
-    ];
-    const nextFiles = [];
-    const tauriConfig = JSON.parse(tauriConfigSource);
-    tauriConfig.version = version;
-    tauriConfig.bundle = {
-        ...(tauriConfig.bundle ?? {}),
-        createUpdaterArtifacts: true,
-    };
-    nextFiles.push({ path: tauriConfigPath, source: `${JSON.stringify(tauriConfig, null, 2)}\n` });
-    nextFiles.push({
-        path: cargoManifestPath,
-        source: replaceCargoPackageVersion(cargoManifestSource, packageName, version, cargoManifestPath),
-    });
-    if (await pathExists(cargoLockPath)) {
-        const cargoLockSource = await readFile(cargoLockPath, "utf8");
-        files.push({ path: cargoLockPath, source: cargoLockSource });
-        nextFiles.push({
-            path: cargoLockPath,
-            source: replaceCargoLockPackageVersion(cargoLockSource, packageName, version, cargoLockPath),
-        });
-    }
-    for (const file of nextFiles) {
-        await writeFile(file.path, file.source);
-    }
-    return { files };
-}
-export async function restoreTauriReleaseMetadata(snapshot) {
-    for (const file of snapshot.files) {
-        await writeFile(file.path, file.source);
-    }
-}
-export async function prepareTauriRelease({ env, plan, releaseName, version, }) {
-    if (!plan.enabled) {
-        return undefined;
-    }
-    await resetGeneratedDirectory(plan.artifactDownloadDir);
-    await resetGeneratedDirectory(plan.releaseUploadDir);
-    const workflowRun = plan.workflowPlatforms.length > 0
-        ? await startTauriWorkflowBuild({ plan, releaseName, version })
-        : undefined;
-    for (const platform of plan.localPlatforms) {
-        await buildLocalTauriPlatform(platform, plan, env);
-    }
-    if (workflowRun) {
-        const runId = await waitForTauriWorkflowBuild(plan, workflowRun.runNameMarker);
-        await nanoSpawn("gh", ["run", "download", String(runId), "--dir", plan.artifactDownloadDir], {
-            stdio: "inherit",
-        });
-    }
-    return createTauriReleaseUpload({ plan, version });
-}
-export async function uploadTauriReleaseToB2(plan, release) {
-    await nanoSpawn("b2", ["account", "authorize", plan.b2ApplicationKeyId, plan.b2ApplicationKey], { stdin: "ignore" });
-    const files = await glob("**/*", { cwd: release.uploadDir, onlyFiles: true });
-    const sortedFiles = files.sort((left, right) => {
-        if (left === release.manifestPath) {
-            return 1;
-        }
-        if (right === release.manifestPath) {
-            return -1;
-        }
-        return left.localeCompare(right);
-    });
-    for (const file of sortedFiles) {
-        await nanoSpawn("b2", ["file", "upload", plan.b2Bucket, join(release.uploadDir, file), file], { stdin: "ignore" });
-        console.log(`Uploaded ${file}`);
-    }
-}
-export function createTauriUpdateManifest({ artifacts, notes, pubDate = new Date(), version, }) {
-    return {
-        ...(notes ? { notes } : {}),
-        platforms: Object.fromEntries(artifacts.map((artifact) => [
-            artifact.updatePlatform,
-            { signature: artifact.signature, url: artifact.url },
-        ])),
-        pub_date: pubDate.toISOString(),
-        version,
-    };
-}
-export async function createTauriReleaseUpload({ plan, version, }) {
-    const releasePath = joinRemotePath(plan.publicPathPrefix, formatReleasePath(plan.releasePath, version));
-    const latestManifestPath = joinRemotePath(plan.publicPathPrefix, plan.latestManifestPath);
-    const selectedPlatforms = [...plan.localPlatforms, ...plan.workflowPlatforms];
-    const manifestArtifacts = [];
-    for (const platform of selectedPlatforms) {
-        const platformConfig = plan.platform[platform];
-        const sourceRoot = plan.localPlatforms.includes(platform)
-            ? "."
-            : join(plan.artifactDownloadDir, `tauri-${platform}-${version}`);
-        const artifactPair = await findTauriUpdateArtifact({
-            globs: plan.localPlatforms.includes(platform) ? platformConfig.artifactGlobs : ["**/*.sig"],
-            sourceRoot,
-            version,
-        });
-        const remoteDir = joinRemotePath(releasePath, platformConfig.updatePlatform);
-        const artifactRemotePath = joinRemotePath(remoteDir, basename(artifactPair.artifactPath));
-        const signatureRemotePath = joinRemotePath(remoteDir, basename(artifactPair.signaturePath));
-        const uploadArtifactPath = join(plan.releaseUploadDir, ...artifactRemotePath.split("/"));
-        const uploadSignaturePath = join(plan.releaseUploadDir, ...signatureRemotePath.split("/"));
-        const signature = (await readFile(artifactPair.signaturePath, "utf8")).trim();
-        await mkdir(dirname(uploadArtifactPath), { recursive: true });
-        await cp(artifactPair.artifactPath, uploadArtifactPath);
-        await cp(artifactPair.signaturePath, uploadSignaturePath);
-        manifestArtifacts.push({
-            signature,
-            updatePlatform: platformConfig.updatePlatform,
-            url: joinPublicUrl(plan.publicBaseUrl, artifactRemotePath),
-        });
-    }
-    const notes = plan.releaseNotesPath ? await readFile(plan.releaseNotesPath, "utf8") : undefined;
-    const manifest = createTauriUpdateManifest({ artifacts: manifestArtifacts, notes, version });
-    const manifestPath = join(plan.releaseUploadDir, ...latestManifestPath.split("/"));
-    await mkdir(dirname(manifestPath), { recursive: true });
-    await writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
-    return {
-        manifestPath: latestManifestPath,
-        uploadDir: plan.releaseUploadDir,
-    };
-}
-async function startTauriWorkflowBuild({ plan, releaseName, version, }) {
-    const ref = plan.workflowRef ?? (await currentGitRef());
-    const runNameMarker = `coreframe-${Date.now()}-${randomUUID().slice(0, 8)}`;
-    await nanoSpawn("gh", [
-        "workflow",
-        "run",
-        plan.workflowName,
-        "--ref",
-        ref,
-        "-f",
-        `release_name=${releaseName}`,
-        "-f",
-        `run_id=${runNameMarker}`,
-        "-f",
-        `version=${version}`,
-        ...tauriReleasePlatforms.flatMap((platform) => [
-            "-f",
-            `${platform}=${plan.workflowPlatforms.includes(platform) ? "true" : "false"}`,
-        ]),
-    ], { stdin: "ignore" });
-    return { runNameMarker };
-}
-async function waitForTauriWorkflowBuild(plan, runNameMarker) {
-    const deadline = Date.now() + plan.workflowTimeoutMs;
-    while (Date.now() < deadline) {
-        const run = await findTauriWorkflowRun(plan, runNameMarker);
-        if (run?.status === "completed") {
-            if (run.conclusion === "success") {
-                return run.databaseId;
-            }
-            throw new Error(`Tauri release workflow ${run.databaseId} finished with ${run.conclusion}.`);
-        }
-        await delay(plan.workflowPollIntervalMs);
-    }
-    throw new Error(`Timed out waiting for Tauri release workflow after ${Math.round(plan.workflowTimeoutMs / 60_000)} minutes.`);
-}
-async function findTauriWorkflowRun(plan, runNameMarker) {
-    const { stdout } = await nanoSpawn("gh", [
-        "run",
-        "list",
-        "--workflow",
-        plan.workflowName,
-        "--event",
-        "workflow_dispatch",
-        "--json",
-        "conclusion,databaseId,displayTitle,status",
-        "--limit",
-        "50",
-    ], { stdin: "ignore" });
-    const runs = JSON.parse(stdout);
-    return runs.find((run) => run.displayTitle.includes(runNameMarker));
-}
-async function buildLocalTauriPlatform(platform, plan, env) {
-    await nanoSpawn("pnpm", plan.platform[platform].buildArgs, {
-        env,
-        stdio: "inherit",
-    });
-}
-async function findTauriUpdateArtifact({ globs, sourceRoot, version, }) {
-    const signaturePaths = await glob(globs, { cwd: sourceRoot, absolute: true, onlyFiles: true });
-    const candidatePairs = [];
-    for (const signaturePath of signaturePaths) {
-        const artifactPath = signaturePath.replace(/\.sig$/u, "");
-        if (await isFile(artifactPath)) {
-            candidatePairs.push({ artifactPath, signaturePath });
-        }
-    }
-    if (candidatePairs.length === 0) {
-        throw new Error(`Could not find a Tauri updater artifact and .sig pair under ${sourceRoot}.`);
-    }
-    return candidatePairs.sort((left, right) => {
-        const leftScore = artifactScore(left.artifactPath, version);
-        const rightScore = artifactScore(right.artifactPath, version);
-        return rightScore - leftScore || left.artifactPath.localeCompare(right.artifactPath);
-    })[0];
-}
-function artifactScore(path, version) {
-    let score = 0;
-    if (path.includes(version)) {
-        score += 100;
-    }
-    if (/\.(app\.tar\.gz|AppImage\.tar\.gz|zip)$/u.test(path)) {
-        score += 10;
-    }
-    if (/\.(exe|msi|dmg|AppImage|deb|rpm|apk|aab|ipa)$/u.test(path)) {
-        score += 5;
-    }
-    return score;
-}
-function resolvePlatformConfig(config = {}, env) {
-    return Object.fromEntries(tauriReleasePlatforms.map((platform) => {
-        const override = config[platform] ?? {};
-        const platformConfig = {
-            ...defaultPlatformConfig[platform],
-            ...override,
-        };
-        const envTargetTriple = env[`TAURI_RELEASE_${platform.toUpperCase()}_TARGET_TRIPLE`];
-        const envUpdatePlatform = env[`TAURI_RELEASE_${platform.toUpperCase()}_UPDATE_PLATFORM`];
-        const targetTriple = envTargetTriple ?? platformConfig.targetTriple;
-        const buildArgs = override.buildArgs
-            ? override.buildArgs
-            : defaultBuildArgs(platform, targetTriple);
-        return [
-            platform,
-            {
-                ...platformConfig,
-                artifactGlobs: platformConfig.artifactGlobs ?? defaultPlatformConfig[platform].artifactGlobs,
-                buildArgs,
-                targetTriple,
-                updatePlatform: envUpdatePlatform ?? platformConfig.updatePlatform,
-            },
-        ];
-    }));
-}
-function defaultBuildArgs(platform, targetTriple) {
-    if (platform === "android") {
-        return ["tauri", "android", "build", "--target", targetTriple];
-    }
-    if (platform === "ios") {
-        return ["tauri", "ios", "build", "--target", targetTriple];
-    }
-    return ["tauri", "build", "--target", targetTriple, "--", "--locked"];
-}
-function readCargoPackageName(source, path) {
-    const match = /^\[package\][\s\S]*?^name = "(?<name>[^"]+)"/mu.exec(source);
-    if (!match?.groups?.name) {
-        throw new Error(`${path} is missing a [package] name.`);
-    }
-    return match.groups.name;
-}
-function replaceCargoPackageVersion(source, packageName, version, path) {
-    const pattern = new RegExp(`(^\\[package\\][\\s\\S]*?^name = "${escapeRegExp(packageName)}"[\\s\\S]*?^version = ")[^"]+(")`, "mu");
-    const nextSource = source.replace(pattern, `$1${version}$2`);
-    if (nextSource === source) {
-        throw new Error(`${path} is missing a package version for ${packageName}.`);
-    }
-    return nextSource;
-}
-function replaceCargoLockPackageVersion(source, packageName, version, path) {
-    const pattern = new RegExp(`(\\[\\[package\\]\\]\\nname = "${escapeRegExp(packageName)}"\\nversion = ")[^"]+(")`, "u");
-    const nextSource = source.replace(pattern, `$1${version}$2`);
-    if (nextSource === source) {
-        throw new Error(`${path} is missing a package lock entry for ${packageName}.`);
-    }
-    return nextSource;
-}
-async function currentGitRef() {
-    const { stdout: branch } = await nanoSpawn("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
-        stdin: "ignore",
-    });
-    const trimmedBranch = branch.trim();
-    if (trimmedBranch !== "HEAD") {
-        return trimmedBranch;
-    }
-    const { stdout: commit } = await nanoSpawn("git", ["rev-parse", "HEAD"], {
-        stdin: "ignore",
-    });
-    return commit.trim();
-}
-async function resetGeneratedDirectory(path) {
-    assertSafeGeneratedDirectory(path);
-    await rm(path, { force: true, recursive: true });
-    await mkdir(path, { recursive: true });
-}
-function assertSafeGeneratedDirectory(path) {
-    const resolvedPath = resolve(path);
-    const relativePath = relative(process.cwd(), resolvedPath).split(sep).join("/");
-    if (relativePath === "" ||
-        relativePath === "." ||
-        relativePath.startsWith("../") ||
-        relativePath === "tauri" ||
-        relativePath.startsWith("tauri/")) {
-        throw new Error(`Refusing to reset unsafe Tauri release directory: ${path}`);
-    }
-}
-function formatReleasePath(template, version) {
-    return template.replaceAll("${version}", version);
-}
-function joinPublicUrl(baseUrl, remotePath) {
-    const url = new URL(baseUrl);
-    const basePath = url.pathname.replace(/\/+$/u, "");
-    const nextPath = joinRemotePath(basePath, remotePath);
-    url.pathname = nextPath.startsWith("/") ? nextPath : `/${nextPath}`;
-    return url.toString();
-}
-function joinRemotePath(...parts) {
-    return parts
-        .flatMap((part) => part.split("/"))
-        .map((part) => part.trim())
-        .filter(Boolean)
-        .join("/");
-}
-function parsePositiveInteger(value, name) {
-    if (!value) {
-        return 0;
-    }
-    const parsed = Number(value);
-    if (!Number.isInteger(parsed) || parsed <= 0) {
-        throw new Error(`${name} must be a positive integer.`);
-    }
-    return parsed;
-}
-function uniquePlatforms(platforms) {
-    return [...new Set(platforms)];
-}
-function isTauriReleasePlatform(value) {
-    return tauriReleasePlatforms.includes(value);
-}
-async function pathExists(path) {
-    try {
-        await access(path, constants.F_OK);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function isFile(path) {
-    try {
-        return (await stat(path)).isFile();
-    }
-    catch {
-        return false;
-    }
-}
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
-}
+import{tauriReleasePlatforms as e}from"./config.js";import{access as t,cp as n,mkdir as r,readFile as i,rm as a,stat as o,writeFile as s}from"node:fs/promises";import{basename as c,dirname as l,join as u,relative as d,resolve as f,sep as p}from"node:path";import m from"nano-spawn";import{randomUUID as h}from"node:crypto";import{constants as g}from"node:fs";import{setTimeout as _}from"node:timers/promises";import{glob as v}from"tinyglobby";const y={android:{artifactGlobs:[`tauri/src-tauri/target/**/*.sig`,`tauri/gen/android/**/*.sig`],buildArgs:[`tauri`,`android`,`build`,`--target`,`aarch64-linux-android`],targetTriple:`aarch64-linux-android`,updatePlatform:`android-aarch64`},ios:{artifactGlobs:[`tauri/src-tauri/target/**/*.sig`,`tauri/gen/apple/**/*.sig`],buildArgs:[`tauri`,`ios`,`build`,`--target`,`aarch64-apple-ios`],targetTriple:`aarch64-apple-ios`,updatePlatform:`ios-aarch64`},linux:{artifactGlobs:[`tauri/src-tauri/target/x86_64-unknown-linux-gnu/release/bundle/**/*.sig`,`tauri/src-tauri/target/release/bundle/**/*.sig`,`tauri/src-tauri/target/**/release/bundle/**/*.sig`],buildArgs:[`tauri`,`build`,`--target`,`x86_64-unknown-linux-gnu`,`--`,`--locked`],targetTriple:`x86_64-unknown-linux-gnu`,updatePlatform:`linux-x86_64`},macos:{artifactGlobs:[`tauri/src-tauri/target/aarch64-apple-darwin/release/bundle/**/*.sig`,`tauri/src-tauri/target/release/bundle/**/*.sig`,`tauri/src-tauri/target/**/release/bundle/**/*.sig`],buildArgs:[`tauri`,`build`,`--target`,`aarch64-apple-darwin`,`--`,`--locked`],targetTriple:`aarch64-apple-darwin`,updatePlatform:`darwin-aarch64`},windows:{artifactGlobs:[`tauri/src-tauri/target/x86_64-pc-windows-msvc/release/bundle/**/*.sig`,`tauri/src-tauri/target/release/bundle/**/*.sig`,`tauri/src-tauri/target/**/release/bundle/**/*.sig`],buildArgs:[`tauri`,`build`,`--target`,`x86_64-pc-windows-msvc`,`--`,`--locked`],targetTriple:`x86_64-pc-windows-msvc`,updatePlatform:`windows-x86_64`}};function b(e){return e?e.split(/[,\s]+/u).filter(Boolean).map(e=>x(e)):[]}function x(t){if(Y(t))return t;throw Error(`Invalid Tauri release platform "${t}". Expected one of: ${e.join(`, `)}.`)}function S({args:e,config:t={},env:n}){let r=J([...t.localPlatforms??[],...b(n.TAURI_RELEASE_LOCAL_PLATFORMS),...e.tauriLocalPlatforms]),i=J([...t.workflowPlatforms??[],...b(n.TAURI_RELEASE_WORKFLOW_PLATFORMS),...e.tauriWorkflowPlatforms]),a=r.filter(e=>i.includes(e));if(a.length>0)throw Error(`Build each Tauri release platform either locally or through the workflow, not both: ${a.join(`, `)}.`);return{artifactDownloadDir:n.TAURI_RELEASE_ARTIFACT_DOWNLOAD_DIR??t.artifactDownloadDir??`.coreframe/tauri-artifacts`,b2ApplicationKey:n.B2_APPLICATION_KEY??n.B2_SECRET_ACCESS_KEY,b2ApplicationKeyId:n.B2_APPLICATION_KEY_ID??n.B2_KEY_ID??n.B2_ACCESS_KEY_ID,b2Bucket:t.b2Bucket??n.B2_BUCKET,enabled:r.length>0||i.length>0,latestManifestPath:n.TAURI_RELEASE_LATEST_MANIFEST_PATH??t.latestManifestPath??`latest.json`,localPlatforms:r,platform:I(t.platform,n),publicBaseUrl:t.publicBaseUrl??n.TAURI_RELEASE_PUBLIC_BASE_URL??n.UPDATE_PUBLIC_BASE_URL,publicPathPrefix:n.TAURI_RELEASE_PUBLIC_PATH_PREFIX??t.publicPathPrefix??n.UPDATE_PUBLIC_PATH_PREFIX??``,releaseNotesPath:n.TAURI_RELEASE_NOTES_FILE??t.releaseNotesPath,releasePath:n.TAURI_RELEASE_PATH??t.releasePath??"releases/${version}",releaseUploadDir:n.TAURI_RELEASE_UPLOAD_DIR??t.releaseUploadDir??`release-upload`,signingPrivateKey:n.TAURI_SIGNING_PRIVATE_KEY,workflowName:e.tauriWorkflowName??n.TAURI_RELEASE_WORKFLOW_NAME??t.workflowName??`tauri-release-artifacts.yml`,workflowPlatforms:i,workflowPollIntervalMs:q(n.TAURI_RELEASE_WORKFLOW_POLL_SECONDS,`TAURI_RELEASE_WORKFLOW_POLL_SECONDS`)*1e3||t.workflowPollIntervalMs||15e3,workflowRef:e.tauriWorkflowRef??n.TAURI_RELEASE_WORKFLOW_REF??t.workflowRef,workflowTimeoutMs:q(n.TAURI_RELEASE_WORKFLOW_TIMEOUT_MINUTES,`TAURI_RELEASE_WORKFLOW_TIMEOUT_MINUTES`)*6e4||t.workflowTimeoutMs||36e5}}async function C(e,t=process.cwd()){if(!e.enabled)return;let n=[[`TAURI_RELEASE_PUBLIC_BASE_URL`,e.publicBaseUrl],[`B2_APPLICATION_KEY_ID`,e.b2ApplicationKeyId],[`B2_APPLICATION_KEY`,e.b2ApplicationKey],[`B2_BUCKET`,e.b2Bucket]].flatMap(([e,t])=>t?[]:[e]);if(n.length>0)throw Error(`Missing required Tauri release configuration: ${n.join(`, `)}`);try{new URL(e.publicBaseUrl)}catch{throw Error(`Invalid TAURI_RELEASE_PUBLIC_BASE_URL: ${e.publicBaseUrl}`)}if(!await X(u(t,`tauri/src-tauri/tauri.conf.json`)))throw Error(`Tauri release platforms were requested, but tauri/src-tauri/tauri.conf.json does not exist.`);if(e.localPlatforms.length>0&&!e.signingPrivateKey)throw Error(`TAURI_SIGNING_PRIVATE_KEY is required for local Tauri release builds.`);e.workflowPlatforms.length>0&&await m(`gh`,[`workflow`,`view`,e.workflowName,`--ref`,e.workflowRef??await V()],{stdin:`ignore`}),await m(`b2`,[`version`],{stdin:`ignore`})}async function w(e,t,n=process.cwd()){if(!e.enabled)return{files:[]};let r=u(n,`tauri/src-tauri/tauri.conf.json`),a=u(n,`tauri/src-tauri/Cargo.toml`),o=u(n,`tauri/src-tauri/Cargo.lock`),c=await i(r,`utf8`),l=await i(a,`utf8`),d=R(l,a),f=[{path:r,source:c},{path:a,source:l}],p=[],m=JSON.parse(c);if(m.version=t,m.bundle={...m.bundle??{},createUpdaterArtifacts:!0},p.push({path:r,source:`${JSON.stringify(m,null,2)}\n`}),p.push({path:a,source:z(l,d,t,a)}),await X(o)){let e=await i(o,`utf8`);f.push({path:o,source:e}),p.push({path:o,source:B(e,d,t,o)})}for(let e of p)await s(e.path,e.source);return{files:f}}async function T(e){for(let t of e.files)await s(t.path,t.source)}async function E({env:e,plan:t,releaseName:n,version:r}){if(!t.enabled)return;await H(t.artifactDownloadDir),await H(t.releaseUploadDir);let i=t.workflowPlatforms.length>0?await A({plan:t,releaseName:n,version:r}):void 0;for(let n of t.localPlatforms)await N(n,t,e);if(i){let e=await j(t,i.runNameMarker);await m(`gh`,[`run`,`download`,String(e),`--dir`,t.artifactDownloadDir],{stdio:`inherit`})}return k({plan:t,version:r})}async function D(e,t){await m(`b2`,[`account`,`authorize`,e.b2ApplicationKeyId,e.b2ApplicationKey],{stdin:`ignore`});let n=(await v(`**/*`,{cwd:t.uploadDir,onlyFiles:!0})).sort((e,n)=>e===t.manifestPath?1:n===t.manifestPath?-1:e.localeCompare(n));for(let r of n)await m(`b2`,[`file`,`upload`,e.b2Bucket,u(t.uploadDir,r),r],{stdin:`ignore`}),console.log(`Uploaded ${r}`)}function O({artifacts:e,notes:t,pubDate:n=new Date,version:r}){return{...t?{notes:t}:{},platforms:Object.fromEntries(e.map(e=>[e.updatePlatform,{signature:e.signature,url:e.url}])),pub_date:n.toISOString(),version:r}}async function k({plan:e,version:t}){let a=K(e.publicPathPrefix,W(e.releasePath,t)),o=K(e.publicPathPrefix,e.latestManifestPath),d=[...e.localPlatforms,...e.workflowPlatforms],f=[];for(let o of d){let s=e.platform[o],d=e.localPlatforms.includes(o)?`.`:u(e.artifactDownloadDir,`tauri-${o}-${t}`),p=await P({globs:e.localPlatforms.includes(o)?s.artifactGlobs:[`**/*.sig`],sourceRoot:d,version:t}),m=K(a,s.updatePlatform),h=K(m,c(p.artifactPath)),g=K(m,c(p.signaturePath)),_=u(e.releaseUploadDir,...h.split(`/`)),v=u(e.releaseUploadDir,...g.split(`/`)),y=(await i(p.signaturePath,`utf8`)).trim();await r(l(_),{recursive:!0}),await n(p.artifactPath,_),await n(p.signaturePath,v),f.push({signature:y,updatePlatform:s.updatePlatform,url:G(e.publicBaseUrl,h)})}let p=O({artifacts:f,notes:e.releaseNotesPath?await i(e.releaseNotesPath,`utf8`):void 0,version:t}),m=u(e.releaseUploadDir,...o.split(`/`));return await r(l(m),{recursive:!0}),await s(m,`${JSON.stringify(p,null,2)}\n`),{manifestPath:o,uploadDir:e.releaseUploadDir}}async function A({plan:t,releaseName:n,version:r}){let i=t.workflowRef??await V(),a=`coreframe-${Date.now()}-${h().slice(0,8)}`;return await m(`gh`,[`workflow`,`run`,t.workflowName,`--ref`,i,`-f`,`release_name=${n}`,`-f`,`run_id=${a}`,`-f`,`version=${r}`,...e.flatMap(e=>[`-f`,`${e}=${t.workflowPlatforms.includes(e)?`true`:`false`}`])],{stdin:`ignore`}),{runNameMarker:a}}async function j(e,t){let n=Date.now()+e.workflowTimeoutMs;for(;Date.now()<n;){let n=await M(e,t);if(n?.status===`completed`){if(n.conclusion===`success`)return n.databaseId;throw Error(`Tauri release workflow ${n.databaseId} finished with ${n.conclusion}.`)}await _(e.workflowPollIntervalMs)}throw Error(`Timed out waiting for Tauri release workflow after ${Math.round(e.workflowTimeoutMs/6e4)} minutes.`)}async function M(e,t){let{stdout:n}=await m(`gh`,[`run`,`list`,`--workflow`,e.workflowName,`--event`,`workflow_dispatch`,`--json`,`conclusion,databaseId,displayTitle,status`,`--limit`,`50`],{stdin:`ignore`});return JSON.parse(n).find(e=>e.displayTitle.includes(t))}async function N(e,t,n){await m(`pnpm`,t.platform[e].buildArgs,{env:n,stdio:`inherit`})}async function P({globs:e,sourceRoot:t,version:n}){let r=await v(e,{cwd:t,absolute:!0,onlyFiles:!0}),i=[];for(let e of r){let t=e.replace(/\.sig$/u,``);await Z(t)&&i.push({artifactPath:t,signaturePath:e})}if(i.length===0)throw Error(`Could not find a Tauri updater artifact and .sig pair under ${t}.`);return i.sort((e,t)=>{let r=F(e.artifactPath,n);return F(t.artifactPath,n)-r||e.artifactPath.localeCompare(t.artifactPath)})[0]}function F(e,t){let n=0;return e.includes(t)&&(n+=100),/\.(app\.tar\.gz|AppImage\.tar\.gz|zip)$/u.test(e)&&(n+=10),/\.(exe|msi|dmg|AppImage|deb|rpm|apk|aab|ipa)$/u.test(e)&&(n+=5),n}function I(t={},n){return Object.fromEntries(e.map(e=>{let r=t[e]??{},i={...y[e],...r},a=n[`TAURI_RELEASE_${e.toUpperCase()}_TARGET_TRIPLE`],o=n[`TAURI_RELEASE_${e.toUpperCase()}_UPDATE_PLATFORM`],s=a??i.targetTriple,c=r.buildArgs?r.buildArgs:L(e,s);return[e,{...i,artifactGlobs:i.artifactGlobs??y[e].artifactGlobs,buildArgs:c,targetTriple:s,updatePlatform:o??i.updatePlatform}]}))}function L(e,t){return e===`android`?[`tauri`,`android`,`build`,`--target`,t]:e===`ios`?[`tauri`,`ios`,`build`,`--target`,t]:[`tauri`,`build`,`--target`,t,`--`,`--locked`]}function R(e,t){let n=/^\[package\][\s\S]*?^name = "(?<name>[^"]+)"/mu.exec(e);if(!n?.groups?.name)throw Error(`${t} is missing a [package] name.`);return n.groups.name}function z(e,t,n,r){let i=RegExp(`(^\\[package\\][\\s\\S]*?^name = "${Q(t)}"[\\s\\S]*?^version = ")[^"]+(")`,`mu`),a=e.replace(i,`$1${n}$2`);if(a===e)throw Error(`${r} is missing a package version for ${t}.`);return a}function B(e,t,n,r){let i=RegExp(`(\\[\\[package\\]\\]\\nname = "${Q(t)}"\\nversion = ")[^"]+(")`,`u`),a=e.replace(i,`$1${n}$2`);if(a===e)throw Error(`${r} is missing a package lock entry for ${t}.`);return a}async function V(){let{stdout:e}=await m(`git`,[`rev-parse`,`--abbrev-ref`,`HEAD`],{stdin:`ignore`}),t=e.trim();if(t!==`HEAD`)return t;let{stdout:n}=await m(`git`,[`rev-parse`,`HEAD`],{stdin:`ignore`});return n.trim()}async function H(e){U(e),await a(e,{force:!0,recursive:!0}),await r(e,{recursive:!0})}function U(e){let t=f(e),n=d(process.cwd(),t).split(p).join(`/`);if(n===``||n===`.`||n.startsWith(`../`)||n===`tauri`||n.startsWith(`tauri/`))throw Error(`Refusing to reset unsafe Tauri release directory: ${e}`)}function W(e,t){return e.replaceAll("${version}",t)}function G(e,t){let n=new URL(e),r=K(n.pathname.replace(/\/+$/u,``),t);return n.pathname=r.startsWith(`/`)?r:`/${r}`,n.toString()}function K(...e){return e.flatMap(e=>e.split(`/`)).map(e=>e.trim()).filter(Boolean).join(`/`)}function q(e,t){if(!e)return 0;let n=Number(e);if(!Number.isInteger(n)||n<=0)throw Error(`${t} must be a positive integer.`);return n}function J(e){return[...new Set(e)]}function Y(t){return e.includes(t)}async function X(e){try{return await t(e,g.F_OK),!0}catch{return!1}}async function Z(e){try{return(await o(e)).isFile()}catch{return!1}}function Q(e){return e.replace(/[.*+?^${}()|[\]\\]/gu,`\\$&`)}export{k as createTauriReleaseUpload,O as createTauriUpdateManifest,x as parseTauriReleasePlatform,b as parseTauriReleasePlatformList,E as prepareTauriRelease,S as resolveTauriReleasePlan,T as restoreTauriReleaseMetadata,D as uploadTauriReleaseToB2,C as validateTauriReleasePlan,w as writeTauriReleaseMetadata};

package/dist/deploy/version.d.ts

@@ -1,18 +1,20 @@
+//#region deploy/version.d.ts
 type PackageJson = {
-    name?: string;
-    version?: string;
-    [key: string]: unknown;
+  name?: string;
+  version?: string;
+  [key: string]: unknown;
 };
 type ReleasePackageJson = PackageJson & {
-    name: string;
-    version: string;
+  name: string;
+  version: string;
 };
-export declare function nextReleaseVersion(currentVersion: string, now?: Date): string;
-export declare function releaseName(packageName: string, version: string): string;
-export declare function formatReleaseDate(date: Date): string;
-export declare function readPackageJson(path?: string): Promise<{
-    packageJson: ReleasePackageJson;
-    source: string;
+declare function nextReleaseVersion(currentVersion: string, now?: Date): string;
+declare function releaseName(packageName: string, version: string): string;
+declare function formatReleaseDate(date: Date): string;
+declare function readPackageJson(path?: string): Promise<{
+  packageJson: ReleasePackageJson;
+  source: string;
 }>;
-export declare function writePackageVersion(path: string, packageJson: PackageJson, version: string): Promise<void>;
-export {};
+declare function writePackageVersion(path: string, packageJson: PackageJson, version: string): Promise<void>;
+//#endregion
+export { formatReleaseDate, nextReleaseVersion, readPackageJson, releaseName, writePackageVersion };

package/dist/deploy/version.js

@@ -1,41 +1 @@
-import { readFile, writeFile } from "node:fs/promises";
-export function nextReleaseVersion(currentVersion, now = new Date()) {
-    const current = parseVersion(currentVersion);
-    const releaseDate = formatReleaseDate(now);
-    const patch = current.minor === releaseDate ? current.patch + 1 : 0;
-    return `${current.major}.${releaseDate}.${patch}`;
-}
-export function releaseName(packageName, version) {
-    return `${packageName}@${version}`;
-}
-export function formatReleaseDate(date) {
-    const year = String(date.getFullYear());
-    const month = String(date.getMonth() + 1).padStart(2, "0");
-    const day = String(date.getDate()).padStart(2, "0");
-    return `${year}${month}${day}`;
-}
-export async function readPackageJson(path = "package.json") {
-    const source = await readFile(path, "utf8");
-    const packageJson = JSON.parse(source);
-    if (!packageJson.name) {
-        throw new Error(`${path} is missing a package name.`);
-    }
-    if (!packageJson.version) {
-        throw new Error(`${path} is missing a package version.`);
-    }
-    return { packageJson: packageJson, source };
-}
-export async function writePackageVersion(path, packageJson, version) {
-    await writeFile(path, `${JSON.stringify({ ...packageJson, version }, null, 2)}\n`);
-}
-function parseVersion(version) {
-    const match = /^(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)$/u.exec(version);
-    if (!match?.groups) {
-        throw new Error(`Invalid package version "${version}". Expected major.minor.patch.`);
-    }
-    return {
-        major: Number(match.groups.major),
-        minor: match.groups.minor,
-        patch: Number(match.groups.patch),
-    };
-}
+import{readFile as e,writeFile as t}from"node:fs/promises";function n(e,t=new Date){let n=s(e),r=i(t),a=n.minor===r?n.patch+1:0;return`${n.major}.${r}.${a}`}function r(e,t){return`${e}@${t}`}function i(e){return`${String(e.getFullYear())}${String(e.getMonth()+1).padStart(2,`0`)}${String(e.getDate()).padStart(2,`0`)}`}async function a(t=`package.json`){let n=await e(t,`utf8`),r=JSON.parse(n);if(!r.name)throw Error(`${t} is missing a package name.`);if(!r.version)throw Error(`${t} is missing a package version.`);return{packageJson:r,source:n}}async function o(e,n,r){await t(e,`${JSON.stringify({...n,version:r},null,2)}\n`)}function s(e){let t=/^(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)$/u.exec(e);if(!t?.groups)throw Error(`Invalid package version "${e}". Expected major.minor.patch.`);return{major:Number(t.groups.major),minor:t.groups.minor,patch:Number(t.groups.patch)}}export{i as formatReleaseDate,n as nextReleaseVersion,a as readPackageJson,r as releaseName,o as writePackageVersion};

package/dist/deploy.d.ts

@@ -1,17 +1,18 @@
-#!/usr/bin/env node
-import type { CoreframeConfig } from "./config.ts";
-import type { TauriReleasePlatform } from "./deploy/config.ts";
+import { TauriReleasePlatform } from "./deploy/config.js";
+import { readProjectConfig } from "./config.js";
+
+//#region deploy.d.ts
 type DeployArgs = {
-    runMigrations: boolean;
-    skipMigrations: boolean;
-    skipPostDeployChecks: boolean;
-    tauriLocalPlatforms: TauriReleasePlatform[];
-    tauriWorkflowName?: string;
-    tauriWorkflowPlatforms: TauriReleasePlatform[];
-    tauriWorkflowRef?: string;
-    yes: boolean;
+  runMigrations: boolean;
+  skipMigrations: boolean;
+  skipPostDeployChecks: boolean;
+  tauriLocalPlatforms: TauriReleasePlatform[];
+  tauriWorkflowName?: string;
+  tauriWorkflowPlatforms: TauriReleasePlatform[];
+  tauriWorkflowRef?: string;
+  yes: boolean;
 };
-export declare function deployProject(argv?: string[], env?: NodeJS.ProcessEnv): Promise<void>;
-export declare function readProjectConfig(): Promise<CoreframeConfig>;
-export declare function parseDeployArgs(argv: string[]): DeployArgs;
-export {};
+declare function deployProject(argv?: string[], env?: NodeJS.ProcessEnv): Promise<void>;
+declare function parseDeployArgs(argv: string[]): DeployArgs;
+//#endregion
+export { deployProject, parseDeployArgs, readProjectConfig };