@gtkx/cli 1.1.0 → 1.2.1

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

@@ -1,13 +1,20 @@
-import { posix, relative } from "node:path";
+import { existsSync, realpathSync } from "node:fs";
+import { posix, relative, resolve } from "node:path";
 import type { DeployPayload, DeploySettings } from "../types.js";
 import { listFilesRecursive } from "../../internal/list-files.js";
 import { BUNDLE_FILENAME } from "../../vite-plugins/esm-extension.js";
 import { renderDbusService } from "../freedesktop/dbus-service.js";
 import { renderDesktopEntry } from "../freedesktop/desktop-entry.js";
 import { renderMetainfo } from "../freedesktop/metainfo.js";
+import { renderMimePackage } from "../freedesktop/mime-package.js";
 import { optional } from "../nfpm/optional.js";
+import { renderNotices } from "../notices/render.js";
+import { executableModeFor } from "../payload/copy-tree.js";
 import { iconPathFor } from "../payload/icons.js";
 import { renderLauncher } from "../payload/launcher.js";
+import { licenseDestination, nodeLicenseDestination, NOTICES_FILENAME, noticesDestination } from "../payload/stage.js";
+import { isInside } from "../settings/paths.js";
+import { pnpmPathFor, type PnpmPin, pnpmSources } from "./flatpak-pnpm.js";
 import { DESTINATION, type FlatpakModule, postInstallCommands, validationCommands } from "./flatpak-prebuilt.js";
 import {
     detectPackageManager,
@@ -15,9 +22,16 @@ import {
     installCommandFor,
     nodeExtensionPathFor,
     type PackageManager,
+    pnpmPinFor,
     resolveGitSource,
 } from "./flatpak-sources.js";
 
+type InstalledFile = {
+    destination: string;
+    source: string;
+    resolved: string;
+};
+
 const LAUNCHER_FILENAME = "launcher.sh";
 const MODULE_BUILD_ROOT = "/run/build";
 const RUNTIME_PREFIX = "/app";
@@ -25,6 +39,7 @@ const NPM_CACHE_DIR = "flatpak-node/npm-cache";
 const YARN_MIRROR_DIR = "flatpak-node/yarn-mirror";
 const PLAIN_ARGUMENT = /^[\w./-]+$/;
 const QUOTE_ESCAPE = String.raw`'\''`;
+const OCTAL_RADIX = 8;
 
 const inlineSource = (fileName: string, contents: string): FlatpakModule => ({
     type: "inline",
@@ -72,6 +87,21 @@ const activationInstallCommands = (settings: DeploySettings): string[] =>
             )]
         : [];
 
+const mimeSources = (settings: DeploySettings): FlatpakModule[] => {
+    const contents = renderMimePackage(settings);
+
+    return contents === null ? [] : [inlineSource(`${settings.applicationId}.xml`, contents)];
+};
+
+const mimeInstallCommands = (settings: DeploySettings): string[] =>
+    settings.fileAssociations.length === 0
+        ? []
+        : [installCommand(
+                `${settings.applicationId}.xml`,
+                `${DESTINATION}/share/mime/packages/${settings.applicationId}.xml`,
+                "m644",
+            )];
+
 const metadataInstallCommands = (settings: DeploySettings): string[] => [
     installCommand(
         `${settings.applicationId}.desktop`,
@@ -84,6 +114,7 @@ const metadataInstallCommands = (settings: DeploySettings): string[] => [
         "m644",
     ),
     ...activationInstallCommands(settings),
+    ...mimeInstallCommands(settings),
 ];
 
 const schemaInstallCommands = (settings: DeploySettings): string[] =>
@@ -118,19 +149,81 @@ const iconInstallCommands = (settings: DeploySettings): string[] => {
     return listFilesRecursive(iconsDir).map((icon) => iconInstallCommand(settings, icon.absPath, icon.rel));
 };
 
+const assertInsideProject = (settings: DeploySettings, installed: InstalledFile): void => {
+    const { resolved } = installed;
+    const target = existsSync(resolved) ? realpathSync(resolved) : resolved;
+
+    if (isInside(settings.paths.root, target)) {
+        return;
+    }
+
+    throw new Error(
+        `Cannot install "${installed.destination}" from "${installed.source}": a source-mode manifest builds from ` +
+        `your git checkout, so every file it installs has to live inside ${settings.paths.root} and be committed. ` +
+        "Move it into the project, or drop it from the source build.",
+    );
+};
+
+const licenseInstallCommands = (settings: DeploySettings): string[] => {
+    const licenseFile = settings.paths.licenseFile;
+
+    if (licenseFile === null) {
+        return [];
+    }
+
+    const destination = licenseDestination(settings);
+    assertInsideProject(settings, { destination, source: licenseFile, resolved: licenseFile });
+    const target = `${DESTINATION}/${shellArgument(destination)}`;
+
+    return [installCommand(projectRelative(settings, licenseFile), target, "m644")];
+};
+
+const noticesInstallCommands = (settings: DeploySettings): string[] => {
+    const extensionLicense = `${nodeExtensionPathFor(settings)}/LICENSE`;
+    const nodeTarget = `${DESTINATION}/${shellArgument(nodeLicenseDestination(settings))}`;
+
+    return [
+        installCommand(NOTICES_FILENAME, `${DESTINATION}/${shellArgument(noticesDestination(settings))}`, "m644"),
+        `test ! -f ${extensionLicense} || ${installCommand(extensionLicense, nodeTarget, "m644")}`,
+    ];
+};
+
+const extraFileInstallCommands = (settings: DeploySettings): string[] =>
+    settings.extraFiles.map((file) => {
+        const resolved = resolve(settings.paths.root, file.source);
+        assertInsideProject(settings, { destination: file.destination, source: file.source, resolved });
+        const mode = file.mode ?? executableModeFor(resolved);
+
+        return installCommand(
+            projectRelative(settings, resolved),
+            `${DESTINATION}/${shellArgument(file.destination)}`,
+            `m${mode.toString(OCTAL_RADIX)}`,
+        );
+    });
+
+const moduleDirFor = (settings: DeploySettings): string => `${MODULE_BUILD_ROOT}/${settings.binaryName}`;
+
 const offlineEnvFor = (manager: PackageManager, settings: DeploySettings): Record<string, string> => {
-    const moduleDir = `${MODULE_BUILD_ROOT}/${settings.binaryName}`;
+    if (manager === "pnpm") {
+        return {};
+    }
 
     if (manager === "yarn") {
-        return { YARN_OFFLINE_MIRROR: `${moduleDir}/${YARN_MIRROR_DIR}` };
+        return { YARN_OFFLINE_MIRROR: `${moduleDirFor(settings)}/${YARN_MIRROR_DIR}` };
     }
 
-    return { npm_config_cache: `${moduleDir}/${NPM_CACHE_DIR}`, npm_config_offline: "true" };
+    return { npm_config_cache: `${moduleDirFor(settings)}/${NPM_CACHE_DIR}`, npm_config_offline: "true" };
 };
 
+const appendPathFor = (settings: DeploySettings, pin: PnpmPin | null, nodeExtensionPath: string): string =>
+    pin === null
+        ? `${nodeExtensionPath}/bin`
+        : `${pnpmPathFor(moduleDirFor(settings))}:${nodeExtensionPath}/bin`;
+
 const flatpakSourceModule = (payload: DeployPayload): FlatpakModule => {
     const settings = payload.settings;
     const manager = detectPackageManager(settings);
+    const pin = pnpmPinFor(settings, manager);
     const postInstall = postInstallCommands(payload);
     const nodeExtensionPath = nodeExtensionPathFor(settings);
 
@@ -138,26 +231,32 @@ const flatpakSourceModule = (payload: DeployPayload): FlatpakModule => {
         name: settings.binaryName,
         buildsystem: "simple",
         "build-options": {
-            "append-path": `${nodeExtensionPath}/bin`,
+            "append-path": appendPathFor(settings, pin, nodeExtensionPath),
             env: { npm_config_nodedir: nodeExtensionPath, ...offlineEnvFor(manager, settings) },
             strip: false,
             "no-debuginfo": true,
         },
         sources: [
             resolveGitSource(settings),
+            ...(pin === null ? [] : pnpmSources(pin, moduleDirFor(settings))),
             GENERATED_SOURCES,
             inlineSource(`${settings.applicationId}.desktop`, renderDesktopEntry(settings)),
             inlineSource(`${settings.applicationId}.metainfo.xml`, renderMetainfo(settings)),
+            ...mimeSources(settings),
             inlineSource(LAUNCHER_FILENAME, renderLauncher(settings)),
+            inlineSource(NOTICES_FILENAME, renderNotices(settings, payload.notices)),
             ...activationSource(settings),
         ],
         "build-commands": [
-            installCommandFor(manager),
+            installCommandFor(settings, manager),
             "npx gtkx build",
             ...runtimeInstallCommands(settings, nodeExtensionPath),
             ...metadataInstallCommands(settings),
             ...schemaInstallCommands(settings),
             ...iconInstallCommands(settings),
+            ...licenseInstallCommands(settings),
+            ...noticesInstallCommands(settings),
+            ...extraFileInstallCommands(settings),
             ...(settings.deploy.flatpak?.buildCommands ?? []),
             ...validationCommands(settings),
         ],

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

@@ -5,8 +5,11 @@ import type { DeploySettings } from "../types.js";
 import { runCliTool } from "../../internal/run-cli-tool.js";
 import { gitRemoteUrl, runGit } from "../git.js";
 import { optional } from "../nfpm/optional.js";
+import { FLATPAK_NODE_GENERATOR, GENERATOR_PNPM_OPTION } from "../tools.js";
+import { pnpmInstallCommand, type PnpmPin, pnpmStoreVersionFor, resolvePnpmPin } from "./flatpak-pnpm.js";
 
 type PackageManager = "npm" | "pnpm" | "yarn";
+type VendoredManager = Exclude<PackageManager, "pnpm">;
 
 type GitSource = {
     type: "git";
@@ -21,7 +24,7 @@ type GitRevision = {
 };
 
 const GENERATED_SOURCES = "generated-sources.json";
-const GENERATOR = "flatpak-node-generator";
+const COMMIT_PEEL = "^{commit}";
 const FETCHABLE_URL = /^https?:\/\//;
 const DEFAULT_NODE_EXTENSION = "org.freedesktop.Sdk.Extension.node24";
 const NODE_EXTENSION_PREFIX = "org.freedesktop.Sdk.Extension.";
@@ -33,9 +36,8 @@ const LOCKFILE_BY_MANAGER: Record<PackageManager, string> = {
     yarn: "yarn.lock",
 };
 
-const INSTALL_COMMAND: Record<PackageManager, string> = {
+const INSTALL_COMMAND: Record<VendoredManager, string> = {
     npm: "npm ci --offline",
-    pnpm: "pnpm install --offline --frozen-lockfile",
     yarn: "yarn install --offline",
 };
 
@@ -59,7 +61,11 @@ const detectPackageManager = (settings: DeploySettings): PackageManager => {
     return found;
 };
 
-const installCommandFor = (manager: PackageManager): string => INSTALL_COMMAND[manager];
+const pnpmPinFor = (settings: DeploySettings, manager: PackageManager): PnpmPin | null =>
+    manager === "pnpm" ? resolvePnpmPin(settings) : null;
+
+const installCommandFor = (settings: DeploySettings, manager: PackageManager): string =>
+    manager === "pnpm" ? pnpmInstallCommand(resolvePnpmPin(settings)) : INSTALL_COMMAND[manager];
 
 const nodeExtensionFor = (settings: DeploySettings): string =>
     settings.deploy.flatpak?.nodeExtension ?? DEFAULT_NODE_EXTENSION;
@@ -98,6 +104,19 @@ const resolveSourceUrl = (settings: DeploySettings): string => {
     return url;
 };
 
+const commitForTag = (root: string, tag: string): string => {
+    const commit = runGit(root, ["rev-parse", `${tag}${COMMIT_PEEL}`]);
+
+    if (commit === null) {
+        throw new Error(
+            `Cannot pin the Flathub source to "${tag}": Flathub builds a fixed tree, not a movable tag, and that ` +
+            `tag does not resolve in ${root}. Create or fetch it, or set \`deploy.flatpak.source.commit\`.`,
+        );
+    }
+
+    return commit;
+};
+
 const configuredRevision = (settings: DeploySettings): GitRevision | null => {
     const source = settings.deploy.flatpak?.source ?? {};
 
@@ -105,7 +124,11 @@ const configuredRevision = (settings: DeploySettings): GitRevision | null => {
         return { ...optional("tag", source.tag), commit: source.commit };
     }
 
-    return source.tag === undefined ? null : { tag: source.tag };
+    if (source.tag === undefined) {
+        return null;
+    }
+
+    return { tag: source.tag, commit: commitForTag(settings.paths.root, source.tag) };
 };
 
 const workingTreeRevision = (settings: DeploySettings): GitRevision => {
@@ -141,7 +164,10 @@ const isolateLockfile = (root: string, lockfile: string): string => {
     return dir;
 };
 
-const generateNodeSources = (settings: DeploySettings, manager: PackageManager): void => {
+const storeVersionArgs = (pin: PnpmPin | null): string[] =>
+    pin === null ? [] : [GENERATOR_PNPM_OPTION, pnpmStoreVersionFor(pin)];
+
+const generateNodeSources = (settings: DeploySettings, manager: PackageManager, pin: PnpmPin | null): void => {
     const lockfile = settings.deploy.flatpak?.lockfile ?? LOCKFILE_BY_MANAGER[manager];
     const output = generatedSourcesPath(settings);
     mkdirSync(dirname(output), { recursive: true });
@@ -149,9 +175,9 @@ const generateNodeSources = (settings: DeploySettings, manager: PackageManager):
 
     try {
         runCliTool({
-            tool: GENERATOR,
-            args: [manager, join(isolated, basename(lockfile)), "-o", output],
-            target: "the offline npm sources",
+            tool: FLATPAK_NODE_GENERATOR.command,
+            args: [manager, join(isolated, basename(lockfile)), ...storeVersionArgs(pin), "-o", output],
+            target: "the offline dependency sources",
             shouldStream: true,
         });
     } finally {
@@ -167,5 +193,6 @@ export {
     nodeExtensionFor,
     nodeExtensionPathFor,
     type PackageManager,
+    pnpmPinFor,
     resolveGitSource,
 };

package/src/deploy/targets/flatpak.ts

@@ -6,7 +6,7 @@ import type { DeployArtifact, DeployManifest, DeployPayload, DeploySettings, Dep
 import { runCliTool } from "../../internal/run-cli-tool.js";
 import { APPSTREAMCLI, DESKTOP_FILE_VALIDATE, FLATPAK, FLATPAK_BUILDER } from "../tools.js";
 import { branchFor, renderFlatpakManifest } from "./flatpak-manifest.js";
-import { detectPackageManager, generateNodeSources } from "./flatpak-sources.js";
+import { detectPackageManager, generateNodeSources, pnpmPinFor } from "./flatpak-sources.js";
 
 type BuilderInvocation = {
     tool: string;
@@ -45,7 +45,8 @@ const renderManifests = (payload: DeployPayload): DeployManifest[] => {
     const settings = payload.settings;
 
     if (isSourceMode(settings)) {
-        generateNodeSources(settings, detectPackageManager(settings));
+        const manager = detectPackageManager(settings);
+        generateNodeSources(settings, manager, pnpmPinFor(settings, manager));
     }
 
     return [{

package/src/deploy/tools.ts

@@ -10,6 +10,8 @@ type ToolReport = {
 
 const DETAIL_COLUMN = 26;
 const FLATPAK_BUILDER_REF = "org.flatpak.Builder";
+const FLATPAK_NODE_GENERATOR_COMMAND = "flatpak-node-generator";
+const GENERATOR_PNPM_OPTION = "--pnpm-store-version";
 
 const APPSTREAMCLI: DeployTool = {
     command: "appstreamcli",
@@ -44,11 +46,16 @@ const FLATPAK_BUILDER: DeployTool = {
 };
 
 const FLATPAK_NODE_GENERATOR: DeployTool = {
-    command: "flatpak-node-generator",
-    purpose: "vendors the npm dependencies a Flathub build installs offline",
+    command: FLATPAK_NODE_GENERATOR_COMMAND,
+    purpose: "vendors the dependencies a Flathub build installs offline",
     isOptional: false,
 };
 
+const FLATPAK_NODE_GENERATOR_PNPM: DeployTool = {
+    ...FLATPAK_NODE_GENERATOR,
+    isPresent: () => hasGeneratorPnpmSupport(),
+};
+
 const STRIP: DeployTool = {
     command: "strip",
     purpose: "would shrink the bundled Node.js by removing its symbols",
@@ -71,6 +78,18 @@ const isFlatpakRefInstalled = (ref: string): boolean => {
     return spawnSync(flatpak, ["info", ref], { stdio: "ignore" }).status === 0;
 };
 
+const hasGeneratorPnpmSupport = (): boolean => {
+    const generator = tryResolveExecutable(FLATPAK_NODE_GENERATOR_COMMAND);
+
+    if (generator === undefined) {
+        return false;
+    }
+
+    const help = spawnSync(generator, ["--help"], { encoding: "utf8" });
+
+    return help.error === undefined && help.output.join("").includes(GENERATOR_PNPM_OPTION);
+};
+
 const isToolPresent = (tool: DeployTool): boolean =>
     tool.isPresent === undefined ? tryResolveExecutable(tool.command) !== undefined : tool.isPresent();
 
@@ -123,6 +142,8 @@ const warnMissingOptional = (report: ToolReport): void => {
 export {
     APPSTREAMCLI,
     FLATPAK_NODE_GENERATOR,
+    FLATPAK_NODE_GENERATOR_PNPM,
+    GENERATOR_PNPM_OPTION,
     assertTools,
     DESKTOP_FILE_VALIDATE,
     FILE_TOOL,

package/src/deploy/types.ts

@@ -19,11 +19,27 @@ type StagedFile = {
 
 type NodeRuntime = {
     path: string;
+    licenseFile: string | null;
     version: string;
     glibcFloor: string | null;
     isStripped: boolean;
 };
 
+type Notice = {
+    subject: string;
+    license: string;
+    source: string | null;
+    copyright: string[];
+    text: string | null;
+};
+
+type NoticeSection = {
+    title: string;
+    files: string[];
+    summary: string[];
+    notices: Notice[];
+};
+
 type DeployDeveloper = {
     id: string | null;
     name: string;
@@ -51,6 +67,12 @@ type DeployFileAssociation = {
     description: string | null;
 };
 
+type DeployExtraFile = {
+    destination: string;
+    source: string;
+    mode: number | null;
+};
+
 type DeployDesktopAction = {
     id: string;
     name: string;
@@ -118,7 +140,7 @@ type DeploySettings = {
     desktopActions: DeployDesktopAction[];
     desktopEntry: Record<string, string>;
     isDbusActivatable: boolean;
-    extraFiles: Record<string, string>;
+    extraFiles: DeployExtraFile[];
     versions: DeployVersions;
     arch: DeployArch;
     paths: DeployPaths;
@@ -130,6 +152,7 @@ type DeployPayload = {
     settings: DeploySettings;
     node: NodeRuntime | null;
     stage: StagedFile[];
+    notices: NoticeSection[];
     overlays: Record<DeployTargetName, StagedFile[]>;
 };
 
@@ -157,6 +180,7 @@ export type {
     DeployConfig,
     DeployDesktopAction,
     DeployDeveloper,
+    DeployExtraFile,
     DeployFileAssociation,
     DeployManifest,
     DeployPaths,
@@ -169,6 +193,8 @@ export type {
     DeployTool,
     DeployVersions,
     NodeRuntime,
+    Notice,
+    NoticeSection,
     PackageFamily,
     StagedFile,
 };

package/src/vite-plugins/bundled-packages.ts

@@ -0,0 +1,95 @@
+import type { Plugin } from "vite";
+import { isRecord, sortStringsBy } from "@gtkx/utils";
+import { readFileSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { stripQuery } from "./strip-query.js";
+
+type PackageIdentity = {
+    name: string;
+    version: string | null;
+};
+
+type RecordedPackage = PackageIdentity & {
+    dir: string;
+};
+
+type PackagesState = {
+    outDir: string;
+};
+
+const BUNDLED_PACKAGES_FILENAME = "gtkx-packages.json";
+const MANIFEST_FILENAME = "package.json";
+const DEFAULT_OUT_DIR = "dist";
+const JSON_INDENT = 4;
+
+const identityIn = (dir: string): PackageIdentity | null => {
+    try {
+        const parsed: unknown = JSON.parse(readFileSync(join(dir, MANIFEST_FILENAME), "utf8"));
+
+        if (!isRecord(parsed) || typeof parsed.name !== "string") {
+            return null;
+        }
+
+        return { name: parsed.name, version: typeof parsed.version === "string" ? parsed.version : null };
+    } catch {
+        return null;
+    }
+};
+
+const packageIn = (dir: string): RecordedPackage | null => {
+    const identity = identityIn(dir);
+
+    if (identity !== null) {
+        return { ...identity, dir };
+    }
+
+    const parent = dirname(dir);
+
+    return parent === dir ? null : packageIn(parent);
+};
+
+const packageForModule = (id: string): RecordedPackage | null => {
+    const path = stripQuery(id);
+
+    return path.startsWith("/") ? packageIn(dirname(path)) : null;
+};
+
+const keyFor = (entry: RecordedPackage): string => `${entry.name}@${entry.version ?? ""}`;
+
+const relativeTo = (outDir: string, entry: RecordedPackage): RecordedPackage => ({
+    ...entry,
+    dir: relative(outDir, entry.dir),
+});
+
+const renderPackages = (outDir: string, ids: string[]): string => {
+    const found = ids.map((id) => packageForModule(id)).filter((entry) => entry !== null);
+    const unique: Map<string, RecordedPackage> = new Map(found.map((entry) => [keyFor(entry), entry]));
+    const packages = sortStringsBy(unique.values(), keyFor).map((entry) => relativeTo(outDir, entry));
+
+    return `${JSON.stringify({ packages }, null, JSON_INDENT)}\n`;
+};
+
+function gtkxBundledPackages(root: string): Plugin {
+    const state: PackagesState = { outDir: join(root, DEFAULT_OUT_DIR) };
+
+    return {
+        name: "gtkx:bundled-packages",
+        apply: "build",
+
+        configResolved(config) {
+            state.outDir = resolve(config.root, config.build.outDir);
+        },
+
+        generateBundle(_options, bundle) {
+            const ids = Object.values(bundle).flatMap((output) => (output.type === "chunk" ? output.moduleIds : []));
+
+            this.emitFile({
+                type: "asset",
+                fileName: BUNDLED_PACKAGES_FILENAME,
+                source: renderPackages(state.outDir, ids),
+            });
+        },
+    };
+}
+
+export { BUNDLED_PACKAGES_FILENAME, gtkxBundledPackages };