@gtkx/cli 1.0.0 → 1.2.0

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

@@ -0,0 +1,68 @@
+import { isRecord } from "@gtkx/utils";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+type ManifestAuthor = {
+    name: string | null;
+    email: string | null;
+};
+
+type PackageManifest = {
+    name: string | null;
+    version: string | null;
+    description: string | null;
+    license: string | null;
+    homepage: string | null;
+    packageManager: string | null;
+    author: ManifestAuthor;
+};
+
+const AUTHOR_PATTERN = /^(?<name>[^<(]*)(?:\([^)]*\)\s*)?(?:<(?<email>[^>]*)>)?/;
+const EMPTY_AUTHOR: ManifestAuthor = { name: null, email: null };
+
+const optionalString = (value: unknown): string | null =>
+    typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+
+const parseAuthorString = (author: string): ManifestAuthor => {
+    const groups = AUTHOR_PATTERN.exec(author)?.groups;
+
+    return { name: optionalString(groups?.name), email: optionalString(groups?.email) };
+};
+
+const parseAuthor = (author: unknown): ManifestAuthor => {
+    if (typeof author === "string") {
+        return parseAuthorString(author);
+    }
+
+    if (!isRecord(author)) {
+        return EMPTY_AUTHOR;
+    }
+
+    return { name: optionalString(author.name), email: optionalString(author.email) };
+};
+
+const readManifestJson = (root: string): Record<string, unknown> => {
+    try {
+        const parsed: unknown = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+
+        return isRecord(parsed) ? parsed : {};
+    } catch {
+        return {};
+    }
+};
+
+const readPackageManifest = (root: string): PackageManifest => {
+    const manifest = readManifestJson(root);
+
+    return {
+        name: optionalString(manifest.name),
+        version: optionalString(manifest.version),
+        description: optionalString(manifest.description),
+        license: optionalString(manifest.license),
+        homepage: optionalString(manifest.homepage),
+        packageManager: optionalString(manifest.packageManager),
+        author: parseAuthor(manifest.author),
+    };
+};
+
+export { type PackageManifest, readPackageManifest };

package/src/deploy/settings/paths.ts

@@ -0,0 +1,115 @@
+import { type Stats, statSync } from "node:fs";
+import { isAbsolute, join, relative, resolve } from "node:path";
+import type { DeployConfig, DeployPaths } from "../types.js";
+import { resolveDataDir } from "../../internal/data-dir.js";
+import { findSchemaFiles } from "../../settings/schema.js";
+
+type PathsRequest = {
+    root: string;
+    deploy: DeployConfig;
+    outDirOverride: string | undefined;
+};
+
+type ResolvedIcons = {
+    iconsDir: string | null;
+    iconFile: string | null;
+};
+
+const DEFAULT_OUT_DIR = "build";
+const DIST_DIR = "dist";
+const ICONS_DIR = "icons";
+const LICENSE_CANDIDATES = ["LICENSE", "LICENSE.md", "LICENSE.txt", "COPYING", "COPYING.md"];
+
+const isInside = (parent: string, candidate: string): boolean => {
+    const rel = relative(parent, candidate);
+
+    return rel.length > 0 && !rel.startsWith("..") && !isAbsolute(rel);
+};
+
+const resolveOutDir = ({ root, deploy, outDirOverride }: PathsRequest): string => {
+    const configured = outDirOverride ?? deploy.outDir ?? DEFAULT_OUT_DIR;
+    const outDir = resolve(root, configured);
+
+    if (!isInside(root, outDir)) {
+        throw new Error(`Cannot use "${configured}" as the deploy output directory: it is outside ${root}`);
+    }
+
+    return outDir;
+};
+
+const getStats = (path: string): Stats | undefined => {
+    try {
+        return statSync(path, { throwIfNoEntry: false });
+    } catch {
+        return undefined;
+    }
+};
+
+const existingFile = (path: string): string | null => (getStats(path)?.isFile() === true ? path : null);
+const existingDir = (path: string): string | null => (getStats(path)?.isDirectory() === true ? path : null);
+
+const resolveLicenseFile = (root: string, configured: string | undefined): string | null => {
+    if (configured !== undefined) {
+        const path = resolve(root, configured);
+
+        if (existingFile(path) === null) {
+            throw new Error(`Cannot read the license file "${configured}": no such file under ${root}`);
+        }
+
+        return path;
+    }
+
+    return LICENSE_CANDIDATES.map((name) => existingFile(join(root, name))).find((path) => path !== null) ?? null;
+};
+
+const configuredIcons = (root: string, configured: string): ResolvedIcons => {
+    const path = resolve(root, configured);
+
+    if (!isInside(root, path)) {
+        throw new Error(`Cannot use "${configured}" as the icon path: it is outside ${root}`);
+    }
+
+    if (existingDir(path) !== null) {
+        return { iconsDir: path, iconFile: null };
+    }
+
+    if (existingFile(path) === null) {
+        throw new Error(`Cannot read the icon path "${configured}": no such file or directory under ${root}`);
+    }
+
+    return { iconsDir: null, iconFile: path };
+};
+
+const defaultIcons = (root: string, dataDir: string | null): ResolvedIcons => ({
+    iconsDir: dataDir === null ? null : existingDir(join(root, dataDir, ICONS_DIR)),
+    iconFile: null,
+});
+
+const resolveIcons = (root: string, dataDir: string | null, configured: string | undefined): ResolvedIcons =>
+    configured === undefined ? defaultIcons(root, dataDir) : configuredIcons(root, configured);
+
+const resolvePaths = (request: PathsRequest): DeployPaths => {
+    const { root, deploy } = request;
+    const outDir = resolveOutDir(request);
+    const dataDir = resolveDataDir(root);
+    const { iconsDir, iconFile } = resolveIcons(root, dataDir, deploy.icons);
+
+    return {
+        root,
+        dist: join(root, DIST_DIR),
+        outDir,
+        metadata: join(outDir, "metadata"),
+        runtime: join(outDir, "runtime"),
+        stage: join(outDir, "stage"),
+        overlay: join(outDir, "overlay"),
+        targets: join(outDir, "targets"),
+        output: join(outDir, "out"),
+        dataDir,
+        iconsDir,
+        iconFile,
+        licenseFile: resolveLicenseFile(root, deploy.licenseFile),
+        schemaFiles: dataDir === null ? [] : findSchemaFiles(join(root, dataDir)),
+    };
+};
+
+export { resolvePaths };

package/src/deploy/settings/screenshots.ts

@@ -0,0 +1,125 @@
+import type { DeployConfig, DeployScreenshot } from "../types.js";
+import { gitRemoteUrl, runGit } from "../git.js";
+
+type ScreenshotRequest = {
+    root: string;
+    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"]) ?? "");
+
+const trimTrailingSlash = (value: string): string =>
+    value.endsWith(TRAILING_SLASH) ? trimTrailingSlash(value.slice(0, -1)) : value;
+
+const trimLeadingSlash = (value: string): string => {
+    const withoutDot = value.startsWith("./") ? value.slice(2) : value;
+
+    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"]);
+
+    if (head === null || head.length === 0) {
+        return DEFAULT_BRANCH;
+    }
+
+    const separator = head.indexOf(TRAILING_SLASH);
+
+    return separator === -1 ? head : head.slice(separator + 1);
+};
+
+const baseForRemote = (remote: string, branch: string): string | null => {
+    const parts = parseRemote(remote);
+
+    if (parts === null) {
+        return null;
+    }
+
+    const build = RAW_BASE_BY_HOST[parts.host];
+
+    return build === undefined ? null : build(parts.owner, parts.repo, branch);
+};
+
+const resolveScreenshotBaseUrl = ({ root, deploy }: ScreenshotRequest): string | null => {
+    if (deploy.screenshotBaseUrl !== undefined) {
+        return trimTrailingSlash(deploy.screenshotBaseUrl);
+    }
+
+    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}`;
+};
+
+const urlForScreenshot = (file: string, baseUrl: string | null): string => {
+    if (baseUrl === null) {
+        throw new Error(
+            `Cannot turn the screenshot "${file}" into a URL: a software center fetches screenshots over the ` +
+            "network. Set `deploy.screenshotBaseUrl`, or give the screenshot an absolute `url`.",
+        );
+    }
+
+    return `${baseUrl}/${trimLeadingSlash(file)}`;
+};
+
+const resolveScreenshots = (request: ScreenshotRequest): DeployScreenshot[] => {
+    const configured = request.deploy.screenshots ?? [];
+
+    if (configured.length === 0) {
+        return [];
+    }
+
+    const baseUrl = resolveScreenshotBaseUrl(request);
+    const defaultIndex = configured.findIndex((entry) => entry.isDefault === true);
+
+    return configured.map((entry, index) => ({
+        url: entry.url ?? urlForScreenshot(entry.file ?? "", baseUrl),
+        caption: entry.caption ?? null,
+        isDefault: index === defaultIndex,
+    }));
+};
+
+export { resolveScreenshots };

package/src/deploy/settings/starter.ts

@@ -0,0 +1,41 @@
+import type { PackageManifest } from "./package-manifest.js";
+
+const INDENT = " ".repeat(4);
+const DOCS_URL = "https://gtkx.dev/guide/deploying";
+
+const quoted = (value: string): string => JSON.stringify(value);
+
+const titleFor = (applicationId: string): string => {
+    const segment = applicationId.split(".").at(-1) ?? applicationId;
+
+    return segment.charAt(0).toUpperCase() + segment.slice(1);
+};
+
+const developerLine = (manifest: PackageManifest): string => {
+    const name = manifest.author.name ?? "Your Name";
+    const email = manifest.author.email;
+    const parts = email === null ? [`name: ${quoted(name)}`] : [`name: ${quoted(name)}`, `email: ${quoted(email)}`];
+
+    return `${INDENT.repeat(2)}developer: { ${parts.join(", ")} },`;
+};
+
+const starterBlock = (applicationId: string, manifest: PackageManifest): string =>
+    [
+        `${INDENT}deploy: {`,
+        `${INDENT.repeat(2)}name: ${quoted(manifest.name ?? titleFor(applicationId))},`,
+        `${INDENT.repeat(2)}summary: ${quoted(manifest.description ?? "What the app does, in one line")},`,
+        `${INDENT.repeat(2)}categories: ["Utility"],`,
+        developerLine(manifest),
+        `${INDENT.repeat(2)}license: ${quoted(manifest.license ?? "MIT")},`,
+        `${INDENT}},`,
+    ].join("\n");
+
+const missingDeployError = (applicationId: string, manifest: PackageManifest): Error =>
+    new Error(
+        "gtkx.config.ts: no `deploy` section, so there is nothing to package.\n" +
+        "Add this to gtkx.config.ts and adjust it:\n\n" +
+        `${starterBlock(applicationId, manifest)}\n\n` +
+        `Every value above was derived from package.json; see ${DOCS_URL}.`,
+    );
+
+export { missingDeployError };

package/src/deploy/settings/version.ts

@@ -0,0 +1,59 @@
+import { warn } from "@gtkx/utils";
+import type { DeployVersions } from "../types.js";
+
+type VersionRequest = {
+    version: string;
+    release: string | undefined;
+    epoch: number | undefined;
+};
+
+const DEFAULT_RELEASE = "1";
+const BUILD_METADATA_SEPARATOR = "+";
+const LEADING_V = /^v/;
+const PRERELEASE_SEPARATOR = "-";
+const UPSTREAM_PATTERN = /^\d[\d.]*$/;
+const PACKAGE_VERSION_PATTERN = /^\d[\w.+~]*$/;
+const RELEASE_PATTERN = /^\w[\w.+~]*$/;
+
+const stripBuildMetadata = (version: string): string => {
+    const index = version.indexOf(BUILD_METADATA_SEPARATOR);
+
+    if (index === -1) {
+        return version;
+    }
+
+    const stripped = version.slice(0, index);
+
+    warn(
+        `Dropping the build metadata from version "${version}": Debian and RPM cannot express it. ` +
+        `Packaging ${stripped} instead; set \`deploy.release\` to distinguish rebuilds.`,
+    );
+
+    return stripped;
+};
+
+const packageVersionFor = (upstream: string, prerelease: string | undefined): string =>
+    prerelease === undefined ? upstream : `${upstream}~${prerelease.replaceAll("-", ".")}`;
+
+const assertMatches = (value: string, pattern: RegExp, subject: string, key: string): void => {
+    if (!pattern.test(value)) {
+        throw new Error(
+            `Cannot package "${value}" as ${subject}: it does not match ${String(pattern)}. Set \`${key}\`.`,
+        );
+    }
+};
+
+const resolveVersions = ({ version, release, epoch }: VersionRequest): DeployVersions => {
+    const normalized = stripBuildMetadata(version.trim().replace(LEADING_V, ""));
+    const [upstream = "", ...rest] = normalized.split(PRERELEASE_SEPARATOR);
+    const prerelease = rest.length > 0 ? rest.join(PRERELEASE_SEPARATOR) : undefined;
+    assertMatches(upstream, UPSTREAM_PATTERN, "an upstream version", "deploy.version");
+    const packageVersion = packageVersionFor(upstream, prerelease);
+    assertMatches(packageVersion, PACKAGE_VERSION_PATTERN, "a package version", "deploy.version");
+    const revision = release ?? DEFAULT_RELEASE;
+    assertMatches(revision, RELEASE_PATTERN, "a packaging revision", "deploy.release");
+
+    return { upstream, packageVersion, debRevision: revision, rpmRelease: revision, epoch: epoch ?? null };
+};
+
+export { resolveVersions };

package/src/deploy/targets/appimage.ts

@@ -0,0 +1,140 @@
+import { existsSync, mkdirSync, rmSync, statSync } from "node:fs";
+import { join } from "node:path";
+import type {
+    DeployArtifact,
+    DeployManifest,
+    DeployPayload,
+    DeploySettings,
+    DeployTarget,
+    StagedFile,
+} from "../types.js";
+import { runCliTool } from "../../internal/run-cli-tool.js";
+import { copyInto, copyTree, EXECUTABLE_MODE, writeInto } from "../payload/copy-tree.js";
+import { getIconSize } from "../payload/icons.js";
+import { FILE_TOOL } from "../tools.js";
+import { resolveAppimageTooling } from "../vendored/appimagetool.js";
+
+const PREFIX = "/usr";
+const TARGET_DIR = "appimage";
+const APPRUN_FILENAME = "AppRun";
+const APPDIR_NAME = "AppDir";
+const USR_DIR = "usr";
+const ICON_EXTENSIONS = [".svg", ".png", ".xpm"];
+const EXTRACT_AND_RUN = "APPIMAGE_EXTRACT_AND_RUN";
+const SCALABLE_RANK = Number.MAX_SAFE_INTEGER;
+
+const appimageTarget: DeployTarget = {
+    name: "appimage",
+    prefix: PREFIX,
+    tools: [FILE_TOOL],
+    render: (payload) => renderManifests(payload),
+    pack: (payload) => packAppImage(payload),
+};
+
+const appimageDir = (settings: DeploySettings): string => join(settings.paths.targets, TARGET_DIR);
+const appDirFor = (settings: DeploySettings): string => join(appimageDir(settings), APPDIR_NAME);
+const appRunPathFor = (settings: DeploySettings): string => join(appimageDir(settings), APPRUN_FILENAME);
+
+const renderAppRun = (settings: DeploySettings): string =>
+    [
+        "#!/bin/sh",
+        "set -e",
+        'here=$(dirname "$(readlink -f "$0")")',
+        'XDG_DATA_DIRS="$here/usr/share:${XDG_DATA_DIRS:-/usr/local/share:/usr/share}"',
+        "export XDG_DATA_DIRS",
+        `exec "$here/usr/bin/${settings.binaryName}" "$@"`,
+        "",
+    ].join("\n");
+
+const renderManifests = (payload: DeployPayload): DeployManifest[] => [
+    { path: appRunPathFor(payload.settings), contents: renderAppRun(payload.settings) },
+];
+
+const iconRank = (file: StagedFile): number =>
+    file.rel.endsWith(".svg") ? SCALABLE_RANK : (getIconSize(file.rel) ?? 0);
+
+const largestIcon = (icons: StagedFile[]): StagedFile | undefined => {
+    let best: StagedFile | undefined;
+
+    for (const file of icons) {
+        if (best === undefined || iconRank(file) > iconRank(best)) {
+            best = file;
+        }
+    }
+
+    return best;
+};
+
+const rootIconFor = (payload: DeployPayload): { rel: string; abs: string } => {
+    const { applicationId } = payload.settings;
+    const names = new Set(ICON_EXTENSIONS.map((extension) => `${applicationId}${extension}`));
+    const icon = largestIcon(payload.stage.filter((file) => names.has(file.rel.split("/").at(-1) ?? "")));
+
+    if (icon === undefined) {
+        throw new Error(`Cannot build an AppImage without a ${applicationId} icon in the staged icon tree`);
+    }
+
+    return { rel: icon.rel.split("/").at(-1) ?? "", abs: icon.abs };
+};
+
+const buildAppDir = (payload: DeployPayload): string => {
+    const settings = payload.settings;
+    const appDir = appDirFor(settings);
+    rmSync(appDir, { recursive: true, force: true, maxRetries: 5 });
+    copyTree(appDir, USR_DIR, settings.paths.stage);
+    copyTree(appDir, USR_DIR, join(settings.paths.overlay, TARGET_DIR));
+    writeInto(appDir, APPRUN_FILENAME, renderAppRun(settings), EXECUTABLE_MODE);
+
+    copyInto(appDir, `${settings.applicationId}.desktop`, join(appDir, USR_DIR, "share/applications",
+        `${settings.applicationId}.desktop`));
+
+    const icon = rootIconFor(payload);
+    copyInto(appDir, icon.rel, icon.abs);
+
+    return appDir;
+};
+
+const artifactNameFor = (settings: DeploySettings): string =>
+    settings.deploy.appimage?.fileName ??
+    `${settings.name.replaceAll(" ", "_")}-${settings.versions.packageVersion}-${settings.arch.appimage}.AppImage`;
+
+const toolArgsFor = (settings: DeploySettings, runtime: string, appDir: string, target: string): string[] => {
+    const appimage = settings.deploy.appimage ?? {};
+    const signing = settings.deploy.signing?.appimage;
+
+    return [
+        "--no-appstream",
+        "--runtime-file",
+        appimage.runtimeFile ?? runtime,
+        ...(appimage.compression === undefined ? [] : ["--comp", appimage.compression]),
+        ...(appimage.updateInformation === undefined ? [] : ["-u", appimage.updateInformation]),
+        ...(signing === undefined ? [] : ["-s", "--sign-key", signing.gpgKeyId]),
+        appDir,
+        target,
+    ];
+};
+
+const packAppImage = async (payload: DeployPayload): Promise<DeployArtifact[]> => {
+    const settings = payload.settings;
+    const tooling = await resolveAppimageTooling(settings.arch.appimage);
+    const appDir = buildAppDir(payload);
+    const output = settings.paths.output;
+    mkdirSync(output, { recursive: true });
+    const target = join(output, artifactNameFor(settings));
+
+    runCliTool({
+        tool: tooling.tool,
+        args: toolArgsFor(settings, tooling.runtime, appDir, target),
+        target: "the AppImage",
+        shouldStream: true,
+        options: { env: { ...process.env, ARCH: settings.arch.appimage, [EXTRACT_AND_RUN]: "1" } },
+    });
+
+    if (!existsSync(target)) {
+        throw new Error(`appimagetool reported success but wrote no AppImage at ${target}`);
+    }
+
+    return [{ path: target, size: statSync(target).size }];
+};
+
+export { appimageTarget };

package/src/deploy/targets/deb.ts

@@ -0,0 +1,6 @@
+import type { DeployTarget } from "../types.js";
+import { nfpmTarget } from "./nfpm-target.js";
+
+const debTarget: DeployTarget = nfpmTarget("deb");
+
+export { debTarget };

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

@@ -0,0 +1,61 @@
+import type { DeployPayload, DeploySettings } from "../types.js";
+import { optional } from "../nfpm/optional.js";
+import { flatpakPrebuiltModule } from "./flatpak-prebuilt.js";
+import { flatpakSourceModule } from "./flatpak-source.js";
+import { nodeExtensionFor } from "./flatpak-sources.js";
+
+type FlatpakManifest = Record<string, unknown>;
+
+const DEFAULT_BRANCH = "stable";
+const DEFAULT_RUNTIME = "org.gnome.Platform";
+const DEFAULT_RUNTIME_VERSION = "50";
+const DEFAULT_SDK = "org.gnome.Sdk";
+const DEFAULT_FINISH_ARGS = ["--share=ipc", "--socket=wayland", "--socket=fallback-x11", "--device=dri"];
+const DEFAULT_CLEANUP = ["/include", "/share/pkgconfig", "*.la", "*.a"];
+
+const branchFor = (settings: DeploySettings): string => settings.deploy.flatpak?.branch ?? DEFAULT_BRANCH;
+const isSourceMode = (settings: DeploySettings): boolean => settings.deploy.flatpak?.mode === "source";
+
+const sdkExtensionsFor = (settings: DeploySettings): string[] => {
+    const flatpak = settings.deploy.flatpak ?? {};
+    const nodeExtension = isSourceMode(settings) ? [nodeExtensionFor(settings)] : [];
+
+    return [...nodeExtension, ...(flatpak.sdkExtensions ?? [])];
+};
+
+const modulesFor = (payload: DeployPayload): unknown[] => {
+    const settings = payload.settings;
+    const own = isSourceMode(settings) ? flatpakSourceModule(payload) : flatpakPrebuiltModule(payload);
+
+    return [...(settings.deploy.flatpak?.modules ?? []), own];
+};
+
+const runtimeKeys = (settings: DeploySettings): FlatpakManifest => {
+    const flatpak = settings.deploy.flatpak ?? {};
+    const extensions = sdkExtensionsFor(settings);
+
+    return {
+        runtime: flatpak.runtime ?? DEFAULT_RUNTIME,
+        "runtime-version": flatpak.runtimeVersion ?? DEFAULT_RUNTIME_VERSION,
+        sdk: flatpak.sdk ?? DEFAULT_SDK,
+        ...optional("base", flatpak.base),
+        ...optional("base-version", flatpak.baseVersion),
+        ...optional("sdk-extensions", extensions.length === 0 ? undefined : extensions),
+    };
+};
+
+const renderFlatpakManifest = (payload: DeployPayload): FlatpakManifest => {
+    const settings = payload.settings;
+    const flatpak = settings.deploy.flatpak ?? {};
+
+    return {
+        id: settings.applicationId,
+        ...runtimeKeys(settings),
+        command: settings.binaryName,
+        "finish-args": flatpak.finishArgs ?? DEFAULT_FINISH_ARGS,
+        cleanup: flatpak.cleanup ?? DEFAULT_CLEANUP,
+        modules: modulesFor(payload),
+    };
+};
+
+export { branchFor, renderFlatpakManifest };