@gtkx/cli 1.6.0 → 2.0.0-beta.2

package/src/deploy/payload/stage.ts

@@ -27,7 +27,6 @@ type StagedMetadata = {
 };
 
 const DIST_ICONS_DIR = "icons";
-const LEGACY_PACKAGES_MANIFEST_FILENAME = "gtkx-packages.json";
 const NOTICES_FILENAME = "THIRD-PARTY-NOTICES";
 const NODE_LICENSE_FILENAME = "LICENSE";
 const SHARE_APPLICATIONS = "share/applications";
@@ -50,10 +49,6 @@ const licenseDirFor = (settings: DeploySettings): string => `${SHARE_LICENSES}/$
 const licenseDestination = (settings: DeploySettings): string => `${licenseDirFor(settings)}/LICENSE`;
 const noticesDestination = (settings: DeploySettings): string => `${licenseDirFor(settings)}/${NOTICES_FILENAME}`;
 const isIconAsset = (rel: string): boolean => rel === DIST_ICONS_DIR || rel.startsWith(`${DIST_ICONS_DIR}/`);
-
-const isBuildMetadata = (rel: string): boolean =>
-    rel === BUILD_MANIFEST_FILENAME || rel === LEGACY_PACKAGES_MANIFEST_FILENAME;
-
 const isLocaleAsset = (rel: string): boolean => rel === LOCALE_DIRNAME || rel.startsWith(`${LOCALE_DIRNAME}/`);
 
 const nodeLicenseDestination = (settings: DeploySettings): string =>
@@ -67,7 +62,8 @@ const stageRuntimeFiles = (settings: DeploySettings, root: string): StagedFile[]
     }
 
     return listFilesRecursive(dist)
-        .filter((file) => !isIconAsset(file.rel) && !isBuildMetadata(file.rel) && !isLocaleAsset(file.rel))
+        .filter((file) =>
+            !isIconAsset(file.rel) && file.rel !== BUILD_MANIFEST_FILENAME && !isLocaleAsset(file.rel))
         .map((file) => copyInto(root, join(libDirFor(settings), file.rel), file.absPath));
 };
 
@@ -112,10 +108,10 @@ const stagePayload = ({ settings, node, metadata }: StageRequest): StagedFile[]
         ...stageNodeBinary(settings, root, node),
         ...stageRuntimeFiles(settings, root),
         ...stageCatalogs(settings, root),
+        ...stageExtraFiles(settings, root),
         ...stageMetadata(settings, root, metadata),
         ...stageIcons(settings, root),
         ...stageSchemas(settings, root),
-        ...stageExtraFiles(settings, root),
     ]);
 };
 

package/src/deploy/run-deploy.ts

@@ -1,4 +1,4 @@
-import { loadConfig } from "@gtkx/config";
+import { type Config, loadConfig } from "@gtkx/config";
 import { info, warn } from "@gtkx/utils";
 import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join, relative } from "node:path";
@@ -22,6 +22,7 @@ import {
     synchronizeCatalogs,
 } from "../i18n/catalogs.js";
 import { extractSourceCatalogTo } from "../i18n/source-messages.js";
+import { prepareBuildOutDir, resolveBuildOutDir } from "../internal/build-output.js";
 import { discoverSourceFiles } from "../internal/source-imports.js";
 import { renderDesktopEntry } from "./freedesktop/desktop-entry.js";
 import { extractMetadataMessages, localizeMetadata } from "./freedesktop/localize.js";
@@ -35,6 +36,7 @@ import { DEFAULT_TARGETS, parseTargetList, targetsFor } from "./registry.js";
 import { readBuildManifest } from "./settings/build-manifest.js";
 import { resolveDeploySettings } from "./settings/index.js";
 import { readPackageManifest } from "./settings/package-manifest.js";
+import { prepareDeployOutDir } from "./settings/paths.js";
 import { missingDeployError } from "./settings/starter.js";
 import { finishArgsFor, hasDisplaySocket, runtimeLabelFor } from "./targets/flatpak-manifest.js";
 import { detectPackageManager } from "./targets/flatpak-sources.js";
@@ -58,6 +60,7 @@ import {
 type DeployOptions = {
     entry: string;
     cwd: string;
+    configFile?: string | undefined;
     targets?: string | undefined;
     outDir?: string | undefined;
     shouldPrintManifests: boolean;
@@ -72,6 +75,20 @@ type PreflightRequest = {
     shouldSkipBuild: boolean;
 };
 
+type LoadedDeploySettings = {
+    config: Config;
+    configFile: string;
+    settings: DeploySettings;
+};
+
+type BuildPayloadRequest = {
+    options: DeployOptions;
+    loaded: LoadedDeploySettings;
+    targets: DeployTarget[];
+    project: CatalogProject | null;
+    buildOutDir: string | null;
+};
+
 const BUILD_MODE = "production";
 const BYTES_PER_MIB = 1024 * 1024;
 const WEBKIT_LIBRARY = "WebKit-6.0";
@@ -282,14 +299,26 @@ const resolveTargetNames = (options: DeployOptions, settings: DeploySettings): s
     return settings.deploy.targets ?? DEFAULT_TARGETS;
 };
 
-const loadSettings = async (options: DeployOptions): Promise<DeploySettings> => {
-    const { config, root } = await loadConfig(options.cwd, { mode: BUILD_MODE });
+const loadSettings = async (options: DeployOptions): Promise<LoadedDeploySettings> => {
+    const { config, configFile, root } = await loadConfig(options.cwd, {
+        mode: BUILD_MODE,
+        configFile: options.configFile,
+    });
 
     if (config.deploy === undefined) {
         throw missingDeployError(config.applicationId, readPackageManifest(root));
     }
 
-    return resolveDeploySettings({ root, config, outDirOverride: options.outDir });
+    return {
+        config,
+        configFile,
+        settings: resolveDeploySettings({
+            root,
+            config,
+            configFile,
+            outDirOverride: options.outDir,
+        }),
+    };
 };
 
 const synchronizeMetadataCatalogs = async (
@@ -318,22 +347,27 @@ const synchronizeMetadataCatalogs = async (
     }
 };
 
-const buildPayload = async (
-    options: DeployOptions,
-    settings: DeploySettings,
-    targets: DeployTarget[],
-    project: CatalogProject | null,
-): Promise<DeployPayload> => {
+const buildPayload = async ({
+    options,
+    loaded,
+    targets,
+    project,
+    buildOutDir,
+}: BuildPayloadRequest): Promise<DeployPayload> => {
+    const settings = loaded.settings;
     const templates = renderMetadata(settings);
 
-    if (!options.shouldSkipBuild) {
+    if (buildOutDir !== null) {
         info(`Building ${options.entry}`);
+        using preparedOutput = prepareBuildOutDir(settings.paths.root, buildOutDir);
 
         await buildApp({
             entry: options.entry,
-            vite: { root: options.cwd },
+            configFile: options.configFile,
+            vite: { root: options.cwd, build: { outDir: preparedOutput.path, emptyOutDir: false } },
         });
 
+        preparedOutput.commit();
         await synchronizeMetadataCatalogs(settings, templates, project);
     } else if (project !== null) {
         compileCatalogs(project, join(settings.paths.dist, LOCALE_DIRNAME));
@@ -341,7 +375,7 @@ const buildPayload = async (
 
     const metadata = localizeMetadata(templates, project);
     validateMetadata(settings, metadata, isFlathubSubmission(settings, targets));
-    const buildManifest = readBuildManifest(settings);
+    const buildManifest = readBuildManifest(settings, loaded);
 
     const builtSettings: DeploySettings = {
         ...settings,
@@ -411,9 +445,11 @@ const announce = (settings: DeploySettings, targets: DeployTarget[]): void => {
 };
 
 const runDeploy = async (options: DeployOptions): Promise<void> => {
-    let settings = await loadSettings(options);
+    let loaded = await loadSettings(options);
+    let settings = loaded.settings;
     let project = resolveCatalogProject(settings.paths.root, settings.applicationId);
     let targets = targetsFor(resolveTargetNames(options, settings));
+    let buildOutDir = options.shouldSkipBuild ? null : resolveBuildOutDir(settings.paths.root, settings.paths.dist);
     announce(settings, targets);
 
     preflight({
@@ -428,14 +464,18 @@ const runDeploy = async (options: DeployOptions): Promise<void> => {
         await ensureGenerated(options.cwd, {
             shouldAnnounce: true,
             mode: BUILD_MODE,
+            configFile: options.configFile,
         });
 
-        settings = await loadSettings(options);
+        loaded = await loadSettings(options);
+        settings = loaded.settings;
         project = resolveCatalogProject(settings.paths.root, settings.applicationId);
         targets = targetsFor(resolveTargetNames(options, settings));
+        buildOutDir = resolveBuildOutDir(settings.paths.root, settings.paths.dist);
     }
 
-    const payload = await buildPayload(options, settings, targets, project);
+    prepareDeployOutDir(settings.paths.root, settings.paths.outDir);
+    const payload = await buildPayload({ options, loaded, targets, project, buildOutDir });
     const rendered = renderTargetManifests(targets, payload);
 
     if (options.shouldPrintManifests) {

package/src/deploy/settings/build-manifest.ts

@@ -1,12 +1,14 @@
-import { isRecord, sortStrings } from "@gtkx/utils";
+import type { Config } from "@gtkx/config";
+import { isPathInside, isRecord, sortStrings, toPosixPath } from "@gtkx/utils";
 import { existsSync, readFileSync, statSync } from "node:fs";
-import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { isAbsolute, join, relative, resolve } from "node:path";
 import type { DeploySettings } from "../types.js";
 import {
     BUILD_MANIFEST_FILENAME,
     BUILD_MANIFEST_FORMAT_VERSION,
     BUILD_MANIFEST_GENERATOR,
     type BuildManifest,
+    configDigest,
     type RecordedPackage,
 } from "../../internal/build-manifest.js";
 import {
@@ -20,6 +22,11 @@ type ResolvedBuildManifest = {
     schemaFiles: string[];
 };
 
+type ExpectedBuildConfig = {
+    config: Config;
+    configFile: string;
+};
+
 const invalidManifest = (path: string): Error =>
     new Error(`Cannot deploy: ${path} is not a valid GTKX build manifest. Run \`gtkx build\` again.`);
 
@@ -51,6 +58,8 @@ const parseBuildManifest = (value: unknown, path: string): BuildManifest => {
         !isRecord(value) ||
         value.generator !== BUILD_MANIFEST_GENERATOR ||
         value.formatVersion !== BUILD_MANIFEST_FORMAT_VERSION ||
+        typeof value.configFile !== "string" ||
+        typeof value.configDigest !== "string" ||
         !Array.isArray(value.schemas) ||
         !Array.isArray(value.packages)
     ) {
@@ -62,24 +71,14 @@ const parseBuildManifest = (value: unknown, path: string): BuildManifest => {
     return {
         generator: BUILD_MANIFEST_GENERATOR,
         formatVersion: BUILD_MANIFEST_FORMAT_VERSION,
+        configFile: value.configFile,
+        configDigest: value.configDigest,
         schemas: recordedSchemas(value.schemas, path),
         packages: packages.map((entry) => recordedPackage(entry, path)),
     };
 };
 
-const isFile = (path: string): boolean => {
-    try {
-        return statSync(path, { throwIfNoEntry: false })?.isFile() === true;
-    } catch {
-        return false;
-    }
-};
-
-const isInsideProject = (root: string, filePath: string): boolean => {
-    const rel = relative(root, filePath);
-
-    return rel.length > 0 && rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
-};
+const isFile = (path: string): boolean => statSync(path, { throwIfNoEntry: false })?.isFile() === true;
 
 const resolveRecordedSchema = (root: string, manifestPath: string, entry: string): string => {
     if (isAbsolute(entry) || !entry.endsWith(SCHEMA_SUFFIX)) {
@@ -88,7 +87,7 @@ const resolveRecordedSchema = (root: string, manifestPath: string, entry: string
 
     const filePath = resolve(root, entry);
 
-    if (!isInsideProject(root, filePath)) {
+    if (!isPathInside(root, filePath)) {
         throw new Error(`Cannot deploy: ${manifestPath} records a GSettings schema outside the project.`);
     }
 
@@ -103,7 +102,20 @@ const resolveRecordedSchema = (root: string, manifestPath: string, entry: string
     return filePath;
 };
 
-const readBuildManifest = (settings: DeploySettings): ResolvedBuildManifest => {
+const assertBuildConfig = (
+    settings: DeploySettings,
+    manifestPath: string,
+    manifest: BuildManifest,
+    expected: ExpectedBuildConfig,
+): void => {
+    const expectedFile = toPosixPath(relative(settings.paths.root, expected.configFile));
+
+    if (manifest.configFile !== expectedFile || manifest.configDigest !== configDigest(expected.config)) {
+        throw new Error(`Cannot deploy: ${manifestPath} was built from a different GTKX configuration.`);
+    }
+};
+
+const readBuildManifest = (settings: DeploySettings, expected: ExpectedBuildConfig): ResolvedBuildManifest => {
     const manifestPath = join(settings.paths.dist, BUILD_MANIFEST_FILENAME);
 
     if (!existsSync(manifestPath)) {
@@ -112,6 +124,7 @@ const readBuildManifest = (settings: DeploySettings): ResolvedBuildManifest => {
 
     const parsed: unknown = JSON.parse(readFileSync(manifestPath, "utf8"));
     const manifest = parseBuildManifest(parsed, manifestPath);
+    assertBuildConfig(settings, manifestPath, manifest, expected);
     const files = manifest.schemas.map((entry) => resolveRecordedSchema(settings.paths.root, manifestPath, entry));
     const unique = sortStrings(new Set(files));
     assertUniqueSchemaBasenames(unique);

package/src/deploy/settings/extra-files.ts

@@ -1,3 +1,5 @@
+import { statSync } from "node:fs";
+import { resolve } from "node:path";
 import type { DeployConfig, DeployExtraFile } from "../types.js";
 
 type ExtraFiles = NonNullable<DeployConfig["extraFiles"]>;
@@ -5,6 +7,20 @@ type ExtraFileEntry = NonNullable<ExtraFiles[string]>;
 
 const OCTAL_RADIX = 8;
 
+const assertSourceFile = (root: string, file: DeployExtraFile): void => {
+    const source = resolve(root, file.source);
+
+    try {
+        if (statSync(source).isFile()) {
+            return;
+        }
+    } catch {
+        throw new Error(`Cannot install "${file.destination}": its source file "${file.source}" does not exist`);
+    }
+
+    throw new Error(`Cannot install "${file.destination}": its source "${file.source}" is not a file`);
+};
+
 const resolveExtraFile = (destination: string, entry: ExtraFileEntry): DeployExtraFile => {
     if (typeof entry === "string") {
         return { destination, source: entry, mode: null };
@@ -15,7 +31,15 @@ const resolveExtraFile = (destination: string, entry: ExtraFileEntry): DeployExt
     return { destination, source: entry.source, mode };
 };
 
-const resolveExtraFiles = (deploy: DeployConfig): DeployExtraFile[] =>
-    Object.entries(deploy.extraFiles ?? {}).map(([destination, entry]) => resolveExtraFile(destination, entry));
+const resolveExtraFiles = (root: string, deploy: DeployConfig): DeployExtraFile[] => {
+    const files = Object.entries(deploy.extraFiles ?? {})
+        .map(([destination, entry]) => resolveExtraFile(destination, entry));
+
+    for (const file of files) {
+        assertSourceFile(root, file);
+    }
+
+    return files;
+};
 
 export { resolveExtraFiles };

package/src/deploy/settings/index.ts

@@ -31,6 +31,7 @@ import { resolveVersions } from "./version.js";
 type SettingsRequest = {
     root: string;
     config: Config;
+    configFile: string;
     outDirOverride?: string | undefined;
     now?: Date | undefined;
 };
@@ -174,10 +175,11 @@ const resolveDeploySettings = (request: SettingsRequest): DeploySettings => {
     const deploy = core.identity.deploy;
 
     return {
+        configFile: request.configFile,
         ...identitySlice(core),
         ...metadataSlice(request.root, core),
         ...desktopSlice(deploy),
-        extraFiles: resolveExtraFiles(deploy),
+        extraFiles: resolveExtraFiles(request.root, deploy),
         versions: core.versions,
         arch: resolveArch(),
         paths: resolvePaths({

package/src/deploy/settings/libraries.ts

@@ -3,10 +3,8 @@ import {
     resolveLibraries as expandLibraries,
     type GeneratedLibraries,
     readGeneratedLibraries,
-    resolveGirPath,
     resolveStore,
 } from "@gtkx/codegen";
-import { resolveFuture } from "@gtkx/config/internal";
 
 type ResolvedLibraries = {
     libraries: string[];
@@ -21,28 +19,9 @@ const generatedLibraries = (root: string): GeneratedLibraries | null => {
     }
 };
 
-const discoveredLibraries = (config: Config, isAdwaitaDefault: boolean): string[] | null => {
-    try {
-        return expandLibraries(config.libraries, resolveGirPath(config.girPath), isAdwaitaDefault);
-    } catch {
-        return null;
-    }
-};
-
-const configLibraries = (config: Config): string[] => {
-    const { isAdwaitaDefault } = resolveFuture(config.future);
-    const libraries = config.libraries;
-
-    if (Array.isArray(libraries)) {
-        return expandLibraries(libraries, [], isAdwaitaDefault);
-    }
-
-    return discoveredLibraries(config, isAdwaitaDefault) ?? expandLibraries(undefined, [], isAdwaitaDefault);
-};
-
 const resolveLibraries = (root: string, config: Config): ResolvedLibraries => {
     const generated = generatedLibraries(root);
-    const libraries = generated?.libraries ?? configLibraries(config);
+    const libraries = generated?.libraries ?? expandLibraries(config.libraries);
     const deploy = config.deploy ?? {};
 
     return {

package/src/deploy/settings/paths.ts

@@ -1,8 +1,10 @@
 import type { Config } from "@gtkx/config";
-import { statSync } from "node:fs";
-import { isAbsolute, join, relative, resolve } from "node:path";
+import { isPathInside } from "@gtkx/utils";
+import { lstatSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { join, relative, resolve, sep } from "node:path";
 import type { DeployConfig, DeployPaths } from "../types.js";
 import { resolveApplicationIcon } from "../../internal/icon-path.js";
+import { prepareOutputDirectory, readRegularFile } from "../../internal/output-directory.js";
 
 type PathsRequest = {
     root: string;
@@ -14,33 +16,86 @@ type PathsRequest = {
 
 const DEFAULT_OUT_DIR = "build";
 const DIST_DIR = "dist";
+const DEPLOY_MARKER_FILENAME = ".gtkx-deploy.json";
+const DEPLOY_MARKER = `${JSON.stringify({ generator: "gtkx-deploy", formatVersion: 1 })}\n`;
 const LICENSE_CANDIDATES = ["LICENSE", "LICENSE.md", "LICENSE.txt", "COPYING", "COPYING.md"];
 
-const isInside = (parent: string, candidate: string): boolean => {
-    const rel = relative(parent, candidate);
+const hasSymlinkComponent = (root: string, target: string): boolean => {
+    let current = root;
 
-    return rel.length > 0 && !rel.startsWith("..") && !isAbsolute(rel);
+    for (const segment of relative(root, target).split(sep)) {
+        current = join(current, segment);
+
+        if (lstatSync(current, { throwIfNoEntry: false })?.isSymbolicLink() === true) {
+            return true;
+        }
+    }
+
+    return false;
+};
+
+const isDeployMarker = (path: string): boolean => {
+    return readRegularFile(path) === DEPLOY_MARKER;
+};
+
+const isReusableDeployDirectory = (path: string): boolean => {
+    const entry = lstatSync(path, { throwIfNoEntry: false });
+
+    if (entry === undefined) {
+        return true;
+    }
+
+    return entry.isDirectory() &&
+        (readdirSync(path).length === 0 || isDeployMarker(join(path, DEPLOY_MARKER_FILENAME)));
+};
+
+const deployOutputError = (root: string, configured: string): Error =>
+    new Error(
+        `Cannot use "${configured}" as the deploy output directory: choose an empty directory or an ` +
+        `earlier GTKX deploy directory below ${root}`,
+    );
+
+const assertSafeDeployOutDir = (root: string, outDir: string, configured: string): void => {
+    const dist = join(root, DIST_DIR);
+
+    if (
+        outDir === dist ||
+        !isPathInside(root, outDir) ||
+        isPathInside(dist, outDir) ||
+        hasSymlinkComponent(root, outDir)
+    ) {
+        throw deployOutputError(root, configured);
+    }
 };
 
 const resolveOutDir = ({ root, deploy, outDirOverride }: PathsRequest): string => {
     const configured = outDirOverride ?? deploy.outDir ?? DEFAULT_OUT_DIR;
     const outDir = resolve(root, configured);
+    assertSafeDeployOutDir(root, outDir, configured);
 
-    if (!isInside(root, outDir)) {
-        throw new Error(`Cannot use "${configured}" as the deploy output directory: it is outside ${root}`);
+    if (!isReusableDeployDirectory(outDir)) {
+        throw deployOutputError(root, configured);
     }
 
     return outDir;
 };
 
-const existingFile = (path: string): string | null => {
-    try {
-        return statSync(path, { throwIfNoEntry: false })?.isFile() === true ? path : null;
-    } catch {
-        return null;
+const prepareDeployOutDir = (root: string, outDir: string): void => {
+    assertSafeDeployOutDir(root, outDir, outDir);
+    const prepared = prepareOutputDirectory(root, outDir, isReusableDeployDirectory);
+
+    if (prepared.status === "unsafe") {
+        throw deployOutputError(root, outDir);
     }
+
+    using transaction = prepared.transaction;
+    transaction.commit();
+    writeFileSync(join(outDir, DEPLOY_MARKER_FILENAME), DEPLOY_MARKER, { flag: "wx" });
 };
 
+const existingFile = (path: string): string | null =>
+    statSync(path, { throwIfNoEntry: false })?.isFile() === true ? path : null;
+
 const resolveLicenseFile = (root: string, configured: string | undefined): string | null => {
     if (configured !== undefined) {
         const path = resolve(root, configured);
@@ -75,4 +130,4 @@ const resolvePaths = (request: PathsRequest): DeployPaths => {
     };
 };
 
-export { isInside, resolvePaths };
+export { prepareDeployOutDir, resolvePaths };

package/src/deploy/settings/screenshots.ts

@@ -1,3 +1,4 @@
+import hostedGitInfo from "hosted-git-info";
 import type { DeployConfig, DeployScreenshot } from "../types.js";
 import { gitRemoteUrl, runGit } from "../git.js";
 
@@ -6,23 +7,9 @@ type ScreenshotRequest = {
     deploy: DeployConfig;
 };
 
-type RemoteParts = {
-    host: string;
-    owner: string;
-    repo: string;
-};
-
 const DEFAULT_BRANCH = "main";
-const GIT_SUFFIX = ".git";
-const PORTED_HOST = /^([^/]*):\d+(?=\/|$)/;
-const SCHEME_SEPARATOR = "://";
 const TRAILING_SLASH = "/";
 
-const RAW_BASE_BY_HOST: Record<string, (owner: string, repo: string, branch: string) => string> = {
-    "github.com": (owner, repo, branch) => `https://raw.githubusercontent.com/${owner}/${repo}/${branch}`,
-    "gitlab.com": (owner, repo, branch) => `https://gitlab.com/${owner}/${repo}/-/raw/${branch}`,
-};
-
 const readRepositoryPrefix = (root: string): string =>
     trimTrailingSlash(runGit(root, ["rev-parse", "--show-prefix"]) ?? "");
 
@@ -35,29 +22,6 @@ const trimLeadingSlash = (value: string): string => {
     return withoutDot.startsWith(TRAILING_SLASH) ? withoutDot.slice(1) : withoutDot;
 };
 
-const afterMarker = (value: string, marker: string): string => {
-    const index = value.indexOf(marker);
-
-    return index === -1 ? value : value.slice(index + marker.length);
-};
-
-const normalizeLocation = (trimmed: string): string => {
-    const location = afterMarker(afterMarker(trimmed, SCHEME_SEPARATOR), "@");
-
-    return trimmed.includes(SCHEME_SEPARATOR) ? location.replace(PORTED_HOST, "$1") : location.replace(":", "/");
-};
-
-const parseRemote = (remote: string): RemoteParts | null => {
-    const trimmed = remote.endsWith(GIT_SUFFIX) ? remote.slice(0, -GIT_SUFFIX.length) : remote;
-    const [host, owner, repo, ...extra] = normalizeLocation(trimmed).split("/");
-
-    if (repo === undefined || extra.length > 0) {
-        return null;
-    }
-
-    return { host: host ?? "", owner: owner ?? "", repo };
-};
-
 const readDefaultBranch = (root: string): string => {
     const head = runGit(root, ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"]);
 
@@ -70,16 +34,16 @@ const readDefaultBranch = (root: string): string => {
     return separator === -1 ? head : head.slice(separator + 1);
 };
 
-const baseForRemote = (remote: string, branch: string): string | null => {
-    const parts = parseRemote(remote);
+const baseForRemote = (root: string, remote: string): string | null => {
+    const repository = hostedGitInfo.fromUrl(remote);
 
-    if (parts === null) {
+    if (repository === undefined || (repository.type !== "github" && repository.type !== "gitlab")) {
         return null;
     }
 
-    const build = RAW_BASE_BY_HOST[parts.host];
-
-    return build === undefined ? null : build(parts.owner, parts.repo, branch);
+    return trimTrailingSlash(
+        repository.file(readRepositoryPrefix(root), { committish: readDefaultBranch(root) }),
+    );
 };
 
 const resolveScreenshotBaseUrl = ({ root, deploy }: ScreenshotRequest): string | null => {
@@ -88,10 +52,8 @@ const resolveScreenshotBaseUrl = ({ root, deploy }: ScreenshotRequest): string |
     }
 
     const remote = gitRemoteUrl(root);
-    const base = remote === null ? null : baseForRemote(remote, readDefaultBranch(root));
-    const prefix = base === null ? "" : readRepositoryPrefix(root);
 
-    return base === null || prefix.length === 0 ? base : `${base}/${prefix}`;
+    return remote === null ? null : baseForRemote(root, remote);
 };
 
 const urlForScreenshot = (file: string, baseUrl: string | null): string => {

package/src/deploy/targets/flatpak-pnpm.ts

@@ -9,12 +9,12 @@ type PnpmPin = {
     sha512: string;
 };
 
-const PNPM_VERSION = "11.22.0";
+const PNPM_VERSION = "11.25.0";
 const PNPM_MAJOR = 11;
-const PNPM_MINOR = 22;
+const PNPM_MINOR = 25;
 
-const PNPM_SHA512 = "1ff870c4c6133dfd88fb2afc46dd13d47f09c9794b438c6fdb47ca98caf3bc16381ee0be9" +
-    "3a091b8e3824cf01f889f46d7d9e20910fb0be1ab0fb5baa80dd621";
+const PNPM_SHA512 = "5cde925b4f075f725eb71fbae18a42ffe784524789f19b61c731cb8721ec28aaee160e01a" +
+    "8d5af4fedb2a42cdbf300efe23db356b0d4a17b4d63e11f8ab7c956";
 
 const PNPM_DIR = "flatpak-pnpm";
 const PNPM_COMMAND = "pnpm";