@gtkx/cli 1.2.0 → 1.2.2

package/src/deploy/notices/node-runtime.ts

@@ -0,0 +1,101 @@
+import { warn } from "@gtkx/utils";
+import type { DeploySettings, NodeRuntime, NoticeSection } from "../types.js";
+import { sourcePathFor } from "../node-runtime/index.js";
+import { licenseBesideNode } from "../node-runtime/license.js";
+import { NODE_FILENAME } from "../payload/launcher.js";
+import { nodeLicenseDestination } from "../payload/stage.js";
+import { copyrightLines, readLicenseText } from "./text.js";
+
+const TITLE = "Node.js runtime";
+const LICENSE_NAME = "Node.js";
+const SOURCE_URL = "https://github.com/nodejs/node";
+const LICENSE_URL = "https://github.com/nodejs/node/blob/main/LICENSE";
+
+const SUMMARY = [
+    "This package carries the Node.js runtime that runs the application. Its license is the one Node.js",
+    "publishes as a single document, covering Node.js itself under the MIT terms together with the",
+    "components it embeds under theirs, among them V8, OpenSSL, ICU, libuv, zlib, brotli and llhttp.",
+];
+
+const CARRIED_SUMMARY = ["The notice below is that document, reproduced from the release this package bundles."];
+
+const MISSING_SUMMARY = [
+    "This run had no copy of that document at hand, so the notice below names it and it is published at",
+    `${LICENSE_URL}.`,
+];
+
+const MISSING_LICENSE =
+    "Cannot read a license file for the Node.js runtime this deploy bundles. An official release unpacks it " +
+    'next to the binary, so point `deploy.node.path` at one, or use `deploy.node.source: "download"`, and ' +
+    "the notices carry it.";
+
+const isSourceMode = (settings: DeploySettings): boolean => settings.deploy.flatpak?.mode === "source";
+
+const versionFor = (settings: DeploySettings, node: NodeRuntime | null): string =>
+    node?.version ?? settings.deploy.node?.version ?? process.versions.node;
+
+const licenseFileFor = (settings: DeploySettings, node: NodeRuntime | null): string | null => {
+    if (node !== null) {
+        return node.licenseFile;
+    }
+
+    if ((settings.deploy.node?.source ?? "download") === "download") {
+        return null;
+    }
+
+    return licenseBesideNode(sourcePathFor(settings));
+};
+
+const textFor = (settings: DeploySettings, node: NodeRuntime | null): string | null => {
+    const licenseFile = licenseFileFor(settings, node);
+
+    return licenseFile === null ? null : readLicenseText(licenseFile);
+};
+
+const extensionSummary = (settings: DeploySettings): string[] => [
+    "The flatpak built from source copies its runtime out of the Node SDK extension in the build sandbox.",
+    `That build installs the license file the extension ships as ${nodeLicenseDestination(settings)}, and`,
+    "installs nothing when the extension ships none, so read the text at the address above if that file is",
+    "not in the package you received.",
+];
+
+const carriedSummary = (settings: DeploySettings, text: string | null): string[] => {
+    if (isSourceMode(settings)) {
+        return [...MISSING_SUMMARY, ...extensionSummary(settings)];
+    }
+
+    return text === null ? MISSING_SUMMARY : CARRIED_SUMMARY;
+};
+
+const summaryFor = (settings: DeploySettings, text: string | null): string[] => [
+    ...SUMMARY,
+    ...carriedSummary(settings, text),
+];
+
+const warnMissingLicense = (node: NodeRuntime | null, text: string | null): void => {
+    if (node === null || text !== null) {
+        return;
+    }
+
+    warn(MISSING_LICENSE);
+};
+
+const nodeNotices = (settings: DeploySettings, node: NodeRuntime | null): NoticeSection => {
+    const text = textFor(settings, node);
+    warnMissingLicense(node, text);
+
+    return {
+        title: TITLE,
+        files: [`lib/${settings.binaryName}/${NODE_FILENAME}`],
+        summary: summaryFor(settings, text),
+        notices: [{
+            subject: `Node.js ${versionFor(settings, node)}`,
+            license: LICENSE_NAME,
+            source: SOURCE_URL,
+            copyright: copyrightLines(text),
+            text,
+        }],
+    };
+};
+
+export { nodeNotices };

package/src/deploy/notices/packages.ts

@@ -0,0 +1,168 @@
+import { isRecord, sortStringsBy, warn } from "@gtkx/utils";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { join, resolve } from "node:path";
+import type { DeploySettings } from "../types.js";
+import { BUNDLED_PACKAGES_FILENAME } from "../../vite-plugins/bundled-packages.js";
+import { type PackageManifest, readPackageManifest } from "../settings/package-manifest.js";
+import { copyrightLines, licenseTextIn } from "./text.js";
+
+type RecordedPackage = {
+    name: string;
+    version: string | null;
+    dir: string;
+};
+
+type BundledPackage = {
+    name: string;
+    version: string | null;
+    license: string | null;
+    source: string | null;
+    copyright: string[];
+    text: string | null;
+    isPresent: boolean;
+};
+
+const MANIFEST_FILENAME = "package.json";
+const GIT_PREFIX = /^git\+/;
+const GIT_SUFFIX = /\.git$/;
+const GIT_SCHEME = /^git:\/\//;
+const GITHUB_SLUG = /^(?:github:)?(?<slug>[\w.-]+\/[\w.-]+)$/;
+
+const realPath = (path: string): string => {
+    try {
+        return realpathSync(path);
+    } catch {
+        return path;
+    }
+};
+
+const optionalString = (value: unknown): string | null => (typeof value === "string" ? value : null);
+
+const recordedPackage = (entry: unknown): RecordedPackage | null => {
+    if (!isRecord(entry) || typeof entry.name !== "string" || typeof entry.dir !== "string") {
+        return null;
+    }
+
+    return { name: entry.name, version: optionalString(entry.version), dir: entry.dir };
+};
+
+const recordedList = (value: unknown): RecordedPackage[] => {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+
+    const entries: unknown[] = value;
+
+    return entries.map((entry) => recordedPackage(entry)).filter((entry) => entry !== null);
+};
+
+const readRecordedPackages = (settings: DeploySettings): RecordedPackage[] => {
+    const path = join(settings.paths.dist, BUNDLED_PACKAGES_FILENAME);
+
+    if (!existsSync(path)) {
+        throw new Error(`Cannot deploy: ${path} is missing. Run \`gtkx build\` first.`);
+    }
+
+    const parsed: unknown = JSON.parse(readFileSync(path, "utf8"));
+
+    return recordedList(isRecord(parsed) ? parsed.packages : null);
+};
+
+const authorLine = (manifest: PackageManifest): string[] => {
+    const { name, email } = manifest.author;
+
+    if (name === null) {
+        return [];
+    }
+
+    return [email === null ? name : `${name} <${email}>`];
+};
+
+const sourceUrl = (manifest: PackageManifest): string | null => {
+    const configured = manifest.repository ?? manifest.homepage;
+
+    if (configured === null) {
+        return null;
+    }
+
+    const url = configured.replace(GIT_PREFIX, "").replace(GIT_SUFFIX, "").replace(GIT_SCHEME, "https://");
+    const slug = GITHUB_SLUG.exec(url)?.groups?.slug;
+
+    if (slug !== undefined) {
+        return `https://github.com/${slug}`;
+    }
+
+    return url.startsWith("http") ? url : null;
+};
+
+const missingPackage = (entry: RecordedPackage): BundledPackage => ({
+    name: entry.name,
+    version: entry.version,
+    license: null,
+    source: null,
+    copyright: [],
+    text: null,
+    isPresent: false,
+});
+
+const packageIn = (entry: RecordedPackage, dir: string): BundledPackage => {
+    if (!existsSync(join(dir, MANIFEST_FILENAME))) {
+        return missingPackage(entry);
+    }
+
+    const manifest = readPackageManifest(dir);
+    const text = licenseTextIn(dir);
+    const copyright = copyrightLines(text);
+
+    return {
+        name: manifest.name ?? entry.name,
+        version: manifest.version ?? entry.version,
+        license: manifest.license,
+        source: sourceUrl(manifest),
+        copyright: copyright.length === 0 ? authorLine(manifest) : copyright,
+        text,
+        isPresent: true,
+    };
+};
+
+const keyFor = (entry: BundledPackage): string => `${entry.name}@${entry.version ?? ""}`;
+
+const dedupe = (entries: BundledPackage[]): BundledPackage[] => {
+    const unique: Map<string, BundledPackage> = new Map();
+
+    for (const entry of entries) {
+        unique.set(keyFor(entry), entry);
+    }
+
+    return sortStringsBy(unique.values(), keyFor);
+};
+
+const warnMissing = (entries: BundledPackage[]): void => {
+    const missing = entries.filter((entry) => !entry.isPresent);
+
+    if (missing.length === 0) {
+        return;
+    }
+
+    warn(
+        `The third-party notices name ${missing.map((entry) => keyFor(entry)).join(", ")} without any license: ` +
+        "`gtkx build` recorded where each package was installed and those directories are no longer there. " +
+        "Deploy from the tree the build ran in, or build again, so the notices carry their terms.",
+    );
+};
+
+const bundledPackages = (settings: DeploySettings): BundledPackage[] => {
+    const root = realPath(settings.paths.root);
+
+    const entries = readRecordedPackages(settings)
+        .map((entry) => ({ entry, dir: resolve(settings.paths.dist, entry.dir) }))
+        .filter(({ dir }) => realPath(dir) !== root)
+        .map(({ entry, dir }) => packageIn(entry, dir));
+
+    const bundled = dedupe(entries);
+    warnMissing(bundled);
+
+    return bundled;
+};
+
+export { type BundledPackage, bundledPackages };

package/src/deploy/notices/render.ts

@@ -0,0 +1,52 @@
+import type { DeploySettings, Notice, NoticeSection } from "../types.js";
+
+const RULE_WIDTH = 100;
+const HEADING = "THIRD-PARTY NOTICES";
+const SECTION_RULE = "=".repeat(RULE_WIDTH);
+const NOTICE_RULE = "-".repeat(RULE_WIDTH);
+const FILE_SEPARATOR = ", ";
+
+const introFor = (settings: DeploySettings): string[] => [
+    HEADING,
+    `${settings.name} ${settings.versions.upstream}`,
+    "",
+    `This file lists the software that ships inside ${settings.name} without having been written by its`,
+    "authors, and the terms each piece of it is distributed under.",
+];
+
+const headerFor = (section: NoticeSection): string[] => [
+    SECTION_RULE,
+    section.title,
+    ...(section.files.length === 0 ? [] : [`Files: ${section.files.join(FILE_SEPARATOR)}`]),
+    SECTION_RULE,
+    "",
+];
+
+const detailLines = (notice: Notice): string[] => [
+    `License: ${notice.license}`,
+    ...(notice.source === null ? [] : [`Source: ${notice.source}`]),
+];
+
+const bodyLines = (notice: Notice): string[] =>
+    notice.text === null ? notice.copyright : ["", notice.text];
+
+const renderNotice = (notice: Notice): string[] => [
+    NOTICE_RULE,
+    notice.subject,
+    ...detailLines(notice),
+    NOTICE_RULE,
+    ...bodyLines(notice),
+    "",
+];
+
+const renderSection = (section: NoticeSection): string[] => [
+    ...headerFor(section),
+    ...section.summary,
+    "",
+    ...section.notices.flatMap((notice) => renderNotice(notice)),
+];
+
+const renderNotices = (settings: DeploySettings, sections: NoticeSection[]): string =>
+    [...introFor(settings), "", ...sections.flatMap((section) => renderSection(section)), ""].join("\n");
+
+export { renderNotices };

package/src/deploy/notices/text.ts

@@ -0,0 +1,42 @@
+import { readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const LICENSE_FILE = /^(?:licen[cs]e|copying|notice)(?:[-._].*)?$/i;
+const COPYRIGHT_LINE = /^(?:Copyright\b|©)/;
+const MAX_COPYRIGHT_LINES = 20;
+const MORE_COPYRIGHT = "and the other holders named in the license text";
+
+const readLicenseText = (path: string): string | null => {
+    try {
+        return readFileSync(path, "utf8").trimEnd();
+    } catch {
+        return null;
+    }
+};
+
+const licenseFilesIn = (dir: string): string[] =>
+    readdirSync(dir, { withFileTypes: true })
+        .filter((entry) => entry.isFile() && LICENSE_FILE.test(entry.name))
+        .map((entry) => entry.name)
+        .toSorted((left, right) => left.localeCompare(right));
+
+const licenseTextIn = (dir: string): string | null => {
+    const texts = licenseFilesIn(dir)
+        .map((name) => readLicenseText(join(dir, name)))
+        .filter((text) => text !== null);
+
+    return texts.length === 0 ? null : texts.join("\n\n");
+};
+
+const copyrightLines = (text: string | null): string[] => {
+    const found = (text ?? "")
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => COPYRIGHT_LINE.test(line));
+
+    const unique = [...new Set(found)];
+
+    return unique.length > MAX_COPYRIGHT_LINES ? [...unique.slice(0, MAX_COPYRIGHT_LINES), MORE_COPYRIGHT] : unique;
+};
+
+export { copyrightLines, licenseTextIn, readLicenseText };

package/src/deploy/payload/copy-tree.ts

@@ -7,6 +7,7 @@ const EXECUTABLE_MODE = 0o755;
 const READABLE_MODE = 0o644;
 const EXECUTABLE_SUFFIXES = [".node", ".so"];
 const MODE_MASK = 0o7777;
+const EXECUTE_MASK = 0o111;
 
 const modeFor = (rel: string): number => {
     const name = rel.split("/").at(-1) ?? rel;
@@ -44,8 +45,11 @@ const writeInto = (root: string, rel: string, contents: string, mode = READABLE_
 
 const sourceMode = (path: string): number => statSync(path).mode & MODE_MASK;
 
+const executableModeFor = (path: string): number =>
+    (sourceMode(path) & EXECUTE_MASK) === 0 ? READABLE_MODE : EXECUTABLE_MODE;
+
 const copyTree = (root: string, relBase: string, sourceDir: string): StagedFile[] =>
     listFilesRecursive(sourceDir)
         .map((file) => copyInto(root, join(relBase, file.rel), file.absPath, sourceMode(file.absPath)));
 
-export { copyInto, copyTree, EXECUTABLE_MODE, writeInto };
+export { copyInto, copyTree, EXECUTABLE_MODE, executableModeFor, writeInto };

package/src/deploy/payload/stage.ts

@@ -1,13 +1,15 @@
 import { sortStringsBy } from "@gtkx/utils";
 import { existsSync, rmSync } from "node:fs";
 import { join, resolve } from "node:path";
-import type { DeploySettings, DeployTargetName, NodeRuntime, StagedFile } from "../types.js";
+import type { DeploySettings, DeployTargetName, NodeRuntime, NoticeSection, StagedFile } from "../types.js";
 import { listFilesRecursive } from "../../internal/list-files.js";
+import { BUNDLED_PACKAGES_FILENAME } from "../../vite-plugins/bundled-packages.js";
 import { BUNDLE_FILENAME } from "../../vite-plugins/esm-extension.js";
 import { renderCopyright } from "../freedesktop/copyright.js";
 import { renderDbusService } from "../freedesktop/dbus-service.js";
 import { renderDesktopEntry } from "../freedesktop/desktop-entry.js";
-import { copyInto, EXECUTABLE_MODE, writeInto } from "./copy-tree.js";
+import { renderNotices } from "../notices/render.js";
+import { copyInto, EXECUTABLE_MODE, executableModeFor, writeInto } from "./copy-tree.js";
 import { stageIcons } from "./icons.js";
 import { NODE_FILENAME, renderLauncher } from "./launcher.js";
 import { stageSchemas } from "./schemas.js";
@@ -25,6 +27,8 @@ type StagedMetadata = {
 };
 
 const DIST_ICONS_DIR = "icons";
+const NOTICES_FILENAME = "THIRD-PARTY-NOTICES";
+const NODE_LICENSE_FILENAME = "LICENSE";
 const SHARE_APPLICATIONS = "share/applications";
 const SHARE_METAINFO = "share/metainfo";
 const SHARE_MIME_PACKAGES = "share/mime/packages";
@@ -40,7 +44,14 @@ const PREFIX_FOR: Record<DeployTargetName, string> = {
 };
 
 const libDirFor = (settings: DeploySettings): string => `lib/${settings.binaryName}`;
+const licenseDirFor = (settings: DeploySettings): string => `${SHARE_LICENSES}/${settings.binaryName}`;
+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 === BUNDLED_PACKAGES_FILENAME;
+
+const nodeLicenseDestination = (settings: DeploySettings): string =>
+    `${licenseDirFor(settings)}/${NODE_FILENAME}/${NODE_LICENSE_FILENAME}`;
 
 const stageRuntimeFiles = (settings: DeploySettings, root: string): StagedFile[] => {
     const dist = settings.paths.dist;
@@ -50,7 +61,7 @@ const stageRuntimeFiles = (settings: DeploySettings, root: string): StagedFile[]
     }
 
     return listFilesRecursive(dist)
-        .filter((file) => !isIconAsset(file.rel))
+        .filter((file) => !isIconAsset(file.rel) && !isBuildMetadata(file.rel))
         .map((file) => copyInto(root, join(libDirFor(settings), file.rel), file.absPath));
 };
 
@@ -66,8 +77,11 @@ const stageMetadata = (settings: DeploySettings, root: string, metadata: StagedM
 ];
 
 const stageExtraFiles = (settings: DeploySettings, root: string): StagedFile[] =>
-    Object.entries(settings.extraFiles).map(([destination, source]) =>
-        copyInto(root, destination, resolve(settings.paths.root, source)));
+    settings.extraFiles.map((file) => {
+        const source = resolve(settings.paths.root, file.source);
+
+        return copyInto(root, file.destination, source, file.mode ?? executableModeFor(source));
+    });
 
 const byRelativePath = (files: StagedFile[]): StagedFile[] => {
     const latest: Map<string, StagedFile> = new Map();
@@ -114,7 +128,7 @@ const stageActivation = (settings: DeploySettings, root: string, target: DeployT
     )];
 };
 
-const stageOverlay = (settings: DeploySettings, target: DeployTargetName): StagedFile[] => {
+const stageOverlay = (settings: DeploySettings, target: DeployTargetName, notices: NoticeSection[]): StagedFile[] => {
     const root = join(settings.paths.overlay, target);
     rmSync(root, { recursive: true, force: true, maxRetries: 5 });
     const licenseFile = settings.paths.licenseFile;
@@ -123,23 +137,33 @@ const stageOverlay = (settings: DeploySettings, target: DeployTargetName): Stage
     if (target === "deb") {
         return [
             ...activation,
-            writeInto(root, join(SHARE_DOC, settings.binaryName, "copyright"), renderCopyright(settings)),
+            writeInto(root, join(SHARE_DOC, settings.binaryName, "copyright"), renderCopyright(settings, notices)),
         ];
     }
 
     return [
         ...activation,
-        ...(licenseFile === null
-            ? []
-            : [copyInto(root, join(SHARE_LICENSES, settings.binaryName, "LICENSE"), licenseFile)]),
+        ...(licenseFile === null ? [] : [copyInto(root, licenseDestination(settings), licenseFile)]),
+        writeInto(root, noticesDestination(settings), renderNotices(settings, notices)),
     ];
 };
 
-const stageOverlays = (settings: DeploySettings): Record<DeployTargetName, StagedFile[]> => ({
-    appimage: stageOverlay(settings, "appimage"),
-    deb: stageOverlay(settings, "deb"),
-    flatpak: stageOverlay(settings, "flatpak"),
-    rpm: stageOverlay(settings, "rpm"),
+const stageOverlays = (
+    settings: DeploySettings,
+    notices: NoticeSection[],
+): Record<DeployTargetName, StagedFile[]> => ({
+    appimage: stageOverlay(settings, "appimage", notices),
+    deb: stageOverlay(settings, "deb", notices),
+    flatpak: stageOverlay(settings, "flatpak", notices),
+    rpm: stageOverlay(settings, "rpm", notices),
 });
 
-export { type StagedMetadata, stageOverlays, stagePayload };
+export {
+    licenseDestination,
+    nodeLicenseDestination,
+    NOTICES_FILENAME,
+    noticesDestination,
+    type StagedMetadata,
+    stageOverlays,
+    stagePayload,
+};

package/src/deploy/run-deploy.ts

@@ -17,11 +17,13 @@ import { renderMetainfo } from "./freedesktop/metainfo.js";
 import { renderMimePackage } from "./freedesktop/mime-package.js";
 import { validateDesktopEntry, validateMetainfo } from "./freedesktop/validate.js";
 import { resolveNodeRuntime } from "./node-runtime/index.js";
+import { collectNotices } from "./notices/collect.js";
 import { type StagedMetadata, stageOverlays, stagePayload } from "./payload/stage.js";
 import { DEFAULT_TARGETS, parseTargetList, targetsFor } from "./registry.js";
 import { resolveDeploySettings } from "./settings/index.js";
 import { readPackageManifest } from "./settings/package-manifest.js";
 import { missingDeployError } from "./settings/starter.js";
+import { finishArgsFor, hasDisplaySocket } from "./targets/flatpak-manifest.js";
 import { detectPackageManager } from "./targets/flatpak-sources.js";
 import {
     APPSTREAMCLI,
@@ -78,10 +80,19 @@ const validateMetadata = (settings: DeploySettings, metadata: StagedMetadata, ar
     info("Validated the desktop entry and the metainfo");
 };
 
-const warnMissingNetwork = (settings: DeploySettings): void => {
-    const finishArgs = settings.deploy.flatpak?.finishArgs;
+const warnMissingDisplay = (settings: DeploySettings, finishArgs: string[]): void => {
+    if (hasDisplaySocket(finishArgs)) {
+        return;
+    }
 
-    if (finishArgs === undefined || finishArgs.includes(NETWORK_ARG)) {
+    warn(
+        `The flatpak permissions grant no display socket, so ${settings.name} will start without a window. ` +
+        "Grant one through `deploy.flatpak.finishArgs`, such as `--socket=wayland`.",
+    );
+};
+
+const warnMissingNetwork = (settings: DeploySettings, finishArgs: string[]): void => {
+    if (settings.deploy.flatpak?.finishArgs === undefined || finishArgs.includes(NETWORK_ARG)) {
         return;
     }
 
@@ -92,6 +103,16 @@ const warnMissingNetwork = (settings: DeploySettings): void => {
     warn(`This app declares ${WEBKIT_LIBRARY} but its flatpak permissions omit ${NETWORK_ARG}, so pages will not load`);
 };
 
+const warnFlatpakPermissions = (targets: DeployTarget[], settings: DeploySettings): void => {
+    if (targets.every((target) => target.name !== "flatpak")) {
+        return;
+    }
+
+    const finishArgs = finishArgsFor(settings);
+    warnMissingDisplay(settings, finishArgs);
+    warnMissingNetwork(settings, finishArgs);
+};
+
 const sourceModeTools = (targets: DeployTarget[], settings: DeploySettings): DeployTool[] => {
     const isFlatpakSource = settings.deploy.flatpak?.mode === "source";
 
@@ -125,7 +146,7 @@ const preflight = (targets: DeployTarget[], settings: DeploySettings, shouldPrin
     const report = probeTools([...required, ...packagerTools]);
     assertTools(report);
     warnMissingOptional(report);
-    warnMissingNetwork(settings);
+    warnFlatpakPermissions(targets, settings);
 };
 
 const resolveTargetNames = (options: DeployOptions, settings: DeploySettings): string[] => {
@@ -165,8 +186,9 @@ const buildPayload = async (
 
     const stage = stagePayload({ settings, node, metadata });
     info(`Staged ${String(stage.length)} files into ${displayPath(settings, settings.paths.stage)}`);
+    const notices = collectNotices({ settings, node });
 
-    return { settings, node, stage, overlays: stageOverlays(settings) };
+    return { settings, node, stage, notices, overlays: stageOverlays(settings, notices) };
 };
 
 const renderTargetManifests = (

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

@@ -0,0 +1,21 @@
+import type { DeployConfig, DeployExtraFile } from "../types.js";
+
+type ExtraFiles = NonNullable<DeployConfig["extraFiles"]>;
+type ExtraFileEntry = NonNullable<ExtraFiles[string]>;
+
+const OCTAL_RADIX = 8;
+
+const resolveExtraFile = (destination: string, entry: ExtraFileEntry): DeployExtraFile => {
+    if (typeof entry === "string") {
+        return { destination, source: entry, mode: null };
+    }
+
+    const mode = entry.mode === undefined ? null : Number.parseInt(entry.mode, OCTAL_RADIX);
+
+    return { destination, source: entry.source, mode };
+};
+
+const resolveExtraFiles = (deploy: DeployConfig): DeployExtraFile[] =>
+    Object.entries(deploy.extraFiles ?? {}).map(([destination, entry]) => resolveExtraFile(destination, entry));
+
+export { resolveExtraFiles };

package/src/deploy/settings/index.ts

@@ -9,6 +9,7 @@ import type {
 } from "../types.js";
 import { resolveArch } from "./arch.js";
 import { resolveExecToken, resolveFileAssociations, resolveMimeTypes } from "./exec.js";
+import { resolveExtraFiles } from "./extra-files.js";
 import {
     type IdentityRequest,
     resolveBinaryName,
@@ -177,7 +178,7 @@ const resolveDeploySettings = (request: SettingsRequest): DeploySettings => {
         ...identitySlice(core),
         ...metadataSlice(request.root, core),
         ...desktopSlice(deploy),
-        extraFiles: deploy.extraFiles ?? {},
+        extraFiles: resolveExtraFiles(deploy),
         versions: core.versions,
         arch: resolveArch(),
         paths: resolvePaths({ root: request.root, deploy, outDirOverride: request.outDirOverride }),

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

@@ -13,6 +13,7 @@ type PackageManifest = {
     description: string | null;
     license: string | null;
     homepage: string | null;
+    repository: string | null;
     packageManager: string | null;
     author: ManifestAuthor;
 };
@@ -29,6 +30,14 @@ const parseAuthorString = (author: string): ManifestAuthor => {
     return { name: optionalString(groups?.name), email: optionalString(groups?.email) };
 };
 
+const parseRepository = (repository: unknown): string | null => {
+    if (isRecord(repository)) {
+        return optionalString(repository.url);
+    }
+
+    return optionalString(repository);
+};
+
 const parseAuthor = (author: unknown): ManifestAuthor => {
     if (typeof author === "string") {
         return parseAuthorString(author);
@@ -60,6 +69,7 @@ const readPackageManifest = (root: string): PackageManifest => {
         description: optionalString(manifest.description),
         license: optionalString(manifest.license),
         homepage: optionalString(manifest.homepage),
+        repository: parseRepository(manifest.repository),
         packageManager: optionalString(manifest.packageManager),
         author: parseAuthor(manifest.author),
     };

package/src/deploy/settings/paths.ts

@@ -112,4 +112,4 @@ const resolvePaths = (request: PathsRequest): DeployPaths => {
     };
 };
 
-export { resolvePaths };
+export { isInside, resolvePaths };