@gtkx/cli 1.0.0-rc.4 → 1.1.0

package/src/cli.ts

@@ -1,8 +1,10 @@
-import { packageVersion } from "@gtkx/utils";
 import { defineCommand, runMain } from "citty";
+import packageManifest from "../package.json" with { type: "json" };
+import { splitApplicationArgs } from "./internal/application-args.js";
 import { withErrorBoundary } from "./internal/errors.js";
 
-const version = packageVersion(import.meta.url);
+const version = packageManifest.version;
+const { cliArgs } = splitApplicationArgs(process.argv.slice(2));
 
 const main = defineCommand({
     meta: {
@@ -21,6 +23,11 @@ const main = defineCommand({
 
             return withErrorBoundary(build);
         },
+        deploy: async () => {
+            const { deploy } = await import("./commands/deploy.js");
+
+            return withErrorBoundary(deploy);
+        },
         codegen: async () => {
             const { codegen } = await import("./commands/codegen.js");
 
@@ -39,4 +46,4 @@ const main = defineCommand({
     },
 });
 
-await runMain(main);
+await runMain(main, { rawArgs: cliArgs });

package/src/codegen/freshness.ts

@@ -27,12 +27,10 @@ const namespaceBarrelPath = (giStoreDir: string, library: string): string => {
     return join(giStoreDir, namespace, "index.js");
 };
 
-// The manifest is what makes the store resolvable as a package, and npm's prune of a generated store
-// removes the link while leaving the directory behind, so both have to be checked.
 const hasManifest = (storeDir: string): boolean => existsSync(join(storeDir, "package.json"));
 
 const isGiStoreStale = (store: CodegenStore, libraries: string[]): boolean => {
-    if (!existsSync(store.giLinkDir) || !hasManifest(store.giStoreDir)) {
+    if (!hasManifest(store.giStoreDir)) {
         return true;
     }
 
@@ -44,7 +42,7 @@ const isReactStoreStale = (store: CodegenStore): boolean => {
         return false;
     }
 
-    if (!existsSync(store.jsxLinkDir) || !hasManifest(store.jsxStoreDir)) {
+    if (!hasManifest(store.jsxStoreDir)) {
         return true;
     }
 

package/src/codegen/run-codegen.ts

@@ -1,4 +1,5 @@
 import { runCodegen as runCodegenCore } from "@gtkx/codegen";
+import { getShadowingStorePaths, sweepProjectStaging } from "@gtkx/codegen/internal";
 import { type Config, loadConfig } from "@gtkx/config";
 import {
     resolveElementComponents,
@@ -12,7 +13,7 @@ import { resolve } from "node:path";
 import { resolveDataDir } from "../internal/data-dir.js";
 import { emitSchemaEnv } from "../settings/schema.js";
 import { type CodegenInputs, isCodegenStale, resolveCodegenInputs } from "./freshness.js";
-import { type CodegenStore, resolveCodegenContext } from "./store-resolver.js";
+import { type CodegenContext, type CodegenStore, resolveCodegenContext } from "./store-resolver.js";
 
 type RunCodegenOptions = {
     cwd?: string;
@@ -45,6 +46,7 @@ type CodegenOptionsInput = {
 };
 
 type PreparedCodegen = CodegenInputs & { isForced: boolean };
+type EnsureGeneratedOptions = { shouldAnnounce?: boolean; mode?: string };
 
 type RunOptionsInput = {
     root: string;
@@ -58,17 +60,17 @@ const GIR_PATH_MISSING_MESSAGE =
     "(Linux: `sudo dnf install gobject-introspection-devel` or `sudo apt install libgirepository1.0-dev`), " +
     "or set `girPath` in gtkx.config.ts.";
 
-const removeSharedStoreShadow = (cwd: string): void => {
-    for (const path of [
-        resolve(cwd, "node_modules/.gtkx/gi"),
-        resolve(cwd, "node_modules/.gtkx/jsx"),
-        resolve(cwd, "node_modules/@gtkx/gi"),
-        resolve(cwd, "node_modules/@gtkx/jsx"),
-    ]) {
+const removeStores = (paths: string[]): void => {
+    for (const path of paths) {
         rmSync(path, { recursive: true, force: true });
     }
 };
 
+const removeShadowingStores = (cwd: string): void => {
+    sweepProjectStaging(cwd);
+    removeStores(getShadowingStorePaths(cwd));
+};
+
 const codegenOptions = ({ store, libraries, girPath, elements }: CodegenOptionsInput) => ({
     libraries,
     girPath,
@@ -102,10 +104,16 @@ const disabledCodegenResult = (configFile: string): RunCodegenResult => ({
     libraries: [],
 });
 
-const clearGeneratedStores = (store: CodegenStore): void => {
-    for (const path of [store.giStoreDir, store.giLinkDir, store.jsxStoreDir, store.jsxLinkDir]) {
-        rmSync(path, { recursive: true, force: true });
+const regeneratedStorePaths = (store: CodegenStore): string[] => {
+    if (store.react === null) {
+        return [store.giStoreDir, store.giLinkDir];
     }
+
+    return [store.giStoreDir, store.giLinkDir, store.jsxStoreDir, store.jsxLinkDir];
+};
+
+const clearGeneratedStores = (store: CodegenStore): void => {
+    removeStores(regeneratedStorePaths(store));
 };
 
 const resolveLoadedConfig = async (options: RunCodegenOptions, cwd: string): Promise<LoadedConfig> =>
@@ -128,7 +136,7 @@ const runCodegen = async (options: RunCodegenOptions = {}): Promise<RunCodegenRe
     const { config, configFile } = await resolveLoadedConfig(options, cwd);
 
     if (config.codegen === false) {
-        removeSharedStoreShadow(cwd);
+        removeShadowingStores(cwd);
 
         return disabledCodegenResult(configFile);
     }
@@ -200,19 +208,15 @@ const getRunOptions = ({ root, mode, inputs, resolved }: RunOptionsInput): RunCo
     return { cwd: root, mode, inputs, resolved };
 };
 
-const ensureGenerated = async (
-    cwd: string,
-    options: { shouldAnnounce?: boolean; mode?: string } = {},
-): Promise<boolean> => {
-    if (options.shouldAnnounce && process.env.GTKX_DISABLE_PREFLIGHT === "1") {
-        return false;
-    }
+const isPreflightSkipped = (options: EnsureGeneratedOptions): boolean =>
+    options.shouldAnnounce === true && process.env.GTKX_DISABLE_PREFLIGHT === "1";
 
-    const context = await resolveCodegenContext(cwd, options.mode);
-    syncSchemaEnv(cwd);
+/* eslint-disable-next-line unicorn/consistent-boolean-name -- the boolean reports whether codegen ran */
+const generate = async (context: CodegenContext, options: EnsureGeneratedOptions): Promise<boolean> => {
+    syncSchemaEnv(context.root);
 
     if (context.config.codegen === false) {
-        removeSharedStoreShadow(context.root);
+        removeShadowingStores(context.root);
 
         return false;
     }
@@ -225,6 +229,16 @@ const ensureGenerated = async (
     return result.isRegenerated;
 };
 
+/* eslint-disable-next-line unicorn/consistent-boolean-name -- the boolean reports whether codegen ran */
+const ensureGeneratedIn = async (
+    context: CodegenContext,
+    options: EnsureGeneratedOptions = {},
+): Promise<boolean> => (isPreflightSkipped(options) ? false : generate(context, options));
+
+/* eslint-disable-next-line unicorn/consistent-boolean-name -- the boolean reports whether codegen ran */
+const ensureGenerated = async (cwd: string, options: EnsureGeneratedOptions = {}): Promise<boolean> =>
+    isPreflightSkipped(options) ? false : generate(await resolveCodegenContext(cwd, options.mode), options);
+
 const resolveConfigWatch = async (
     cwd: string,
     mode?: string,
@@ -244,7 +258,7 @@ export {
     isCodegenDisabled,
     syncSchemaEnv,
     ensureGenerated,
+    ensureGeneratedIn,
     resolveConfigWatch,
-    type RunCodegenOptions,
     type RunCodegenResult,
 };

package/src/codegen/store-resolver.ts

@@ -83,4 +83,4 @@ const resolveCodegenContext = async (cwd: string, mode?: string): Promise<Codege
     return { root: cwd, config, configFile };
 };
 
-export { resolveCodegenStore, resolveCodegenContext, type CodegenStore, type CodegenContext };
+export { resolveCodegenStore, resolveCodegenContext, type CodegenContext, type CodegenStore };

package/src/commands/build.ts

@@ -1,8 +1,8 @@
 import { info } from "@gtkx/utils";
 import { defineCommand } from "citty";
 import { build as buildApp } from "../builder.js";
-import { ensureGenerated } from "../codegen/run-codegen.js";
-import { entryArg, resolveEntry } from "../internal/entry-arg.js";
+import { entryArg } from "../internal/entry-arg.js";
+import { prepareProject } from "../internal/prepare-project.js";
 
 const BUILD_MODE = "production";
 
@@ -19,11 +19,10 @@ const build = defineCommand({
         },
     },
     async run({ args }) {
-        const { cwd, entry } = resolveEntry(args);
+        const { cwd, entry } = await prepareProject(args, BUILD_MODE);
         info(`Building ${entry}`);
-        await ensureGenerated(cwd, { shouldAnnounce: true, mode: BUILD_MODE });
 
-        await buildApp({
+        const bundlePath = await buildApp({
             entry,
             assetBase: args["asset-base"],
             vite: {
@@ -31,7 +30,7 @@ const build = defineCommand({
             },
         });
 
-        info("Build complete: dist/bundle.js");
+        info(`Build complete: ${bundlePath}`);
     },
 });
 

package/src/commands/codegen.ts

@@ -4,6 +4,11 @@ import { formatCodegenResult } from "../codegen/report.js";
 import { ensureGenerated, isCodegenDisabled, runCodegen, syncSchemaEnv } from "../codegen/run-codegen.js";
 import { cwdArg, resolveCwd } from "../internal/entry-arg.js";
 
+const FORCED_WHILE_DISABLED_MESSAGE =
+    "codegen is disabled for this project, so --force has no store to regenerate here. " +
+    "Remove `codegen: false` from gtkx.config.ts, or run `gtkx codegen --force` where the installed " +
+    "binding store is generated.";
+
 const codegen = defineCommand({
     meta: {
         name: "codegen",
@@ -19,8 +24,10 @@ const codegen = defineCommand({
     },
     async run({ args }) {
         const cwd = resolveCwd(args);
+        const isDisabled = await isCodegenDisabled(cwd);
+        checkForce(isDisabled, args.force);
 
-        if (await isCodegenDisabled(cwd)) {
+        if (isDisabled) {
             await runCodegen({ cwd });
             syncSchemaEnv(cwd);
             info("codegen: disabled for this project; reusing an installed binding store");
@@ -46,4 +53,10 @@ const codegen = defineCommand({
     },
 });
 
+const checkForce = (isDisabled: boolean, isForced: boolean): void => {
+    if (isDisabled && isForced) {
+        throw new Error(FORCED_WHILE_DISABLED_MESSAGE);
+    }
+};
+
 export { codegen };

package/src/commands/deploy.ts

@@ -0,0 +1,47 @@
+import { defineCommand } from "citty";
+import { KNOWN_NAMES } from "../deploy/registry.js";
+import { runDeploy } from "../deploy/run-deploy.js";
+import { entryArg } from "../internal/entry-arg.js";
+import { resolveProject } from "../internal/prepare-project.js";
+
+const DEPLOY_MODE = "production";
+
+const deploy = defineCommand({
+    meta: {
+        name: "deploy",
+        description: "Package the application for distribution",
+    },
+    args: {
+        ...entryArg,
+        target: {
+            type: "string",
+            description: `Comma-separated package formats to build (${KNOWN_NAMES})`,
+        },
+        out: {
+            type: "string",
+            description: "Output directory relative to the project root (default: build)",
+        },
+        "print-manifests": {
+            type: "boolean",
+            description: "Write the generated manifests and metadata, then stop without packaging",
+        },
+        "skip-build": {
+            type: "boolean",
+            description: "Package what is already in dist/ instead of rebuilding",
+        },
+    },
+    async run({ args }) {
+        const { cwd, entry } = await resolveProject(args, DEPLOY_MODE);
+
+        await runDeploy({
+            entry,
+            cwd,
+            targets: args.target,
+            outDir: args.out,
+            shouldPrintManifests: args["print-manifests"] === true,
+            shouldSkipBuild: args["skip-build"] === true,
+        });
+    },
+});
+
+export { deploy };

package/src/commands/dev.ts

@@ -1,7 +1,9 @@
 import { defineCommand } from "citty";
-import { ensureGenerated, resolveConfigWatch } from "../codegen/run-codegen.js";
+import { resolveConfigWatch } from "../codegen/run-codegen.js";
 import { type DevWatch, runDevSupervisor } from "../dev/supervisor.js";
-import { entryArg, resolveEntry } from "../internal/entry-arg.js";
+import { splitApplicationArgs } from "../internal/application-args.js";
+import { entryArg } from "../internal/entry-arg.js";
+import { prepareProject } from "../internal/prepare-project.js";
 
 const DEV_MODE = "development";
 
@@ -14,10 +16,10 @@ const dev = defineCommand({
         ...entryArg,
     },
     async run({ args }) {
-        const { cwd, entry: entryPath } = resolveEntry(args);
-        await ensureGenerated(cwd, { shouldAnnounce: true, mode: DEV_MODE });
+        const { cwd, entry: entryPath } = await prepareProject(args, DEV_MODE);
         const watch: DevWatch | undefined = await resolveConfigWatch(cwd, DEV_MODE);
-        await runDevSupervisor(entryPath, cwd, watch);
+        const { applicationArgs } = splitApplicationArgs(process.argv.slice(2));
+        await runDevSupervisor({ entryPath, cwd, args: applicationArgs, watch });
     },
 });
 

package/src/commands/docs.ts

@@ -13,7 +13,7 @@ import { resolveOmittedProps } from "@gtkx/config/internal";
 import { info } from "@gtkx/utils";
 import { defineCommand } from "citty";
 import { existsSync } from "node:fs";
-import { resolve } from "node:path";
+import { isAbsolute, relative, resolve, sep } from "node:path";
 import { cwdArg, resolveCwd } from "../internal/entry-arg.js";
 
 const docs = defineCommand({
@@ -25,7 +25,9 @@ const docs = defineCommand({
     args: {
         out: {
             type: "string",
-            description: "Output directory for the generated markdown pages, relative to the project root",
+            description:
+                "Output directory for the generated markdown pages, below the project root. It must be empty " +
+                "or hold an earlier `gtkx docs` run, whose pages are replaced",
             default: "docs/reference",
         },
         "base-path": {
@@ -35,7 +37,9 @@ const docs = defineCommand({
         },
         force: {
             type: "boolean",
-            description: "Regenerate even when the pages are up to date with the GIR libraries",
+            description:
+                "Regenerate even when the pages are up to date with the GIR libraries, the base path, " +
+                "and the element props the project configures",
             default: false,
         },
         ...cwdArg,
@@ -63,7 +67,7 @@ const docs = defineCommand({
 
         const libraries = resolveLibraries(config.libraries, girPath);
         const startedAt = Date.now();
-        const outDir = resolve(cwd, args.out);
+        const outDir = resolveOutDir(cwd, args.out);
         const builtin = await resolveDocsElements(cwd);
 
         const { isRegenerated, namespaces } = writeDocs({
@@ -91,6 +95,37 @@ const docs = defineCommand({
     },
 });
 
+const isBelow = (parent: string, child: string): boolean => {
+    const path = relative(parent, child);
+
+    return path !== "" && path !== ".." && !path.startsWith(`..${sep}`) && !isAbsolute(path);
+};
+
+const outDirReason = (cwd: string, out: string, outDir: string): string => {
+    if (out.trim() === "") {
+        return "it was empty, which names the project root itself";
+    }
+
+    if (outDir === cwd) {
+        return "it names the project root itself";
+    }
+
+    return `${outDir} is outside it`;
+};
+
+const resolveOutDir = (cwd: string, out: string): string => {
+    const outDir = out.trim() === "" ? cwd : resolve(cwd, out);
+
+    if (isBelow(cwd, outDir)) {
+        return outDir;
+    }
+
+    throw new Error(
+        `--out must name a directory below the project root ${cwd}, and ${outDirReason(cwd, out, outDir)}. ` +
+        "Pass a path such as --out=docs/reference.",
+    );
+};
+
 const resolveDocsElements = async (cwd: string): Promise<{ props: ElementProps; omittedProps: OmittedProps }> => {
     const { gi, reactSubexports } = resolveStore(cwd);
 

package/src/deploy/depends.ts

@@ -0,0 +1,42 @@
+import type { DeployConfig } from "./types.js";
+
+type Relations = {
+    deb: string[];
+    rpm: string[];
+};
+
+const GLES_SONAME = "libGLESv2.so.2()(64bit)";
+
+const BASE_DEPENDS: Relations = {
+    deb: ["hicolor-icon-theme", "adwaita-icon-theme", "gsettings-desktop-schemas"],
+    rpm: ["hicolor-icon-theme", "adwaita-icon-theme", "gsettings-desktop-schemas"],
+};
+
+const DEPENDS_BY_LIBRARY: Record<string, Relations> = {
+    "Adw-1": { deb: ["libadwaita-1-0"], rpm: ["libadwaita"] },
+    "Gtk-4.0": { deb: ["libgtk-4-1"], rpm: ["gtk4", GLES_SONAME] },
+    "GtkSource-5": { deb: ["libgtksourceview-5-0"], rpm: ["gtksourceview5"] },
+    "WebKit-6.0": { deb: ["libwebkitgtk-6.0-4"], rpm: ["webkitgtk6.0"] },
+};
+
+const libraryDepends = (libraries: string[]): Relations => ({
+    deb: libraries.flatMap((library) => DEPENDS_BY_LIBRARY[library]?.deb ?? []),
+    rpm: libraries.flatMap((library) => DEPENDS_BY_LIBRARY[library]?.rpm ?? []),
+});
+
+const glibcDepends = (glibcFloor: string | null): Relations =>
+    glibcFloor === null ? { deb: [], rpm: [] } : { deb: [`libc6 (>= ${glibcFloor})`], rpm: [`glibc >= ${glibcFloor}`] };
+
+const dedupe = (entries: string[]): string[] => [...new Set(entries)];
+
+const resolveDepends = (deploy: DeployConfig, libraries: string[], glibcFloor: string | null): Relations => {
+    const fromLibraries = libraryDepends(libraries);
+    const fromGlibc = glibcDepends(glibcFloor);
+
+    return {
+        deb: dedupe([...fromLibraries.deb, ...BASE_DEPENDS.deb, ...fromGlibc.deb, ...(deploy.depends?.deb ?? [])]),
+        rpm: dedupe([...fromLibraries.rpm, ...BASE_DEPENDS.rpm, ...fromGlibc.rpm, ...(deploy.depends?.rpm ?? [])]),
+    };
+};
+
+export { resolveDepends };

package/src/deploy/download.ts

@@ -0,0 +1,148 @@
+import { info, warn } from "@gtkx/utils";
+import { createHash } from "node:crypto";
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+type DigestRequest = {
+    url: string;
+    dest: string;
+    assetName: string;
+    subject: string;
+};
+
+type DownloadRequest = {
+    url: string;
+    dest: string;
+    label: string;
+    sha256: string;
+    freshSha256?: (() => Promise<string>) | undefined;
+    mode?: number | undefined;
+};
+
+const CACHE_NAMESPACE = "gtkx";
+const DIGEST_PATTERN = /^[\da-f]{64}$/;
+
+const cacheRoot = (): string => {
+    const base = process.env.XDG_CACHE_HOME;
+
+    return join(base !== undefined && base.length > 0 ? base : join(homedir(), ".cache"), CACHE_NAMESPACE);
+};
+
+const cacheDir = (segments: string[]): string => {
+    const dir = join(cacheRoot(), ...segments);
+    mkdirSync(dir, { recursive: true });
+
+    return dir;
+};
+
+const getDigest = (contents: Buffer): string => createHash("sha256").update(contents).digest("hex");
+
+const assertDigest = (url: string, contents: Buffer, expected: string): void => {
+    const actual = getDigest(contents);
+
+    if (actual !== expected) {
+        throw new Error(`Checksum mismatch for ${url}\n  expected ${expected}\n  received ${actual}`);
+    }
+};
+
+const fetchBytes = async (url: string): Promise<Buffer> => {
+    const response = await fetch(url);
+
+    if (!response.ok) {
+        throw new Error(`Cannot download ${url}: HTTP ${String(response.status)} ${response.statusText}`);
+    }
+
+    return Buffer.from(await response.arrayBuffer());
+};
+
+const fetchText = async (url: string): Promise<string> => {
+    const bytes = await fetchBytes(url);
+
+    return bytes.toString("utf8");
+};
+
+const readCachedDigest = (dest: string): string | undefined => {
+    try {
+        const cached = readFileSync(dest, "utf8").trim();
+
+        return DIGEST_PATTERN.test(cached) ? cached : undefined;
+    } catch {
+        return undefined;
+    }
+};
+
+const writeAtomically = (dest: string, contents: string): void => {
+    const staging = `${dest}.partial`;
+    writeFileSync(staging, contents);
+    renameSync(staging, dest);
+};
+
+const publishedDigest = async (request: DigestRequest): Promise<string> => {
+    const checksums = await fetchText(request.url);
+    const digest = digestFromChecksums(checksums, request.assetName, request.subject);
+
+    if (!DIGEST_PATTERN.test(digest)) {
+        throw new Error(`${request.subject} published a malformed checksum for ${request.assetName}: "${digest}"`);
+    }
+
+    writeAtomically(request.dest, digest);
+
+    return digest;
+};
+
+const cachedDigest = async (request: DigestRequest): Promise<string> => {
+    const cached = readCachedDigest(request.dest);
+
+    return cached ?? publishedDigest(request);
+};
+
+const isCacheUsable = (dest: string, sha256: string): boolean => {
+    if (!existsSync(dest)) {
+        return false;
+    }
+
+    if (getDigest(readFileSync(dest)) === sha256) {
+        return true;
+    }
+
+    warn(`Discarding the cached ${dest}: its checksum no longer matches`);
+
+    return false;
+};
+
+const downloadFile = async (request: DownloadRequest): Promise<string> => {
+    const { url, dest, label, sha256, mode } = request;
+
+    if (isCacheUsable(dest, sha256)) {
+        return dest;
+    }
+
+    info(`Downloading ${label}`);
+    const expected = request.freshSha256 === undefined ? sha256 : await request.freshSha256();
+    const contents = await fetchBytes(url);
+    assertDigest(url, contents, expected);
+    const staging = `${dest}.partial`;
+    writeFileSync(staging, contents);
+
+    if (mode !== undefined) {
+        chmodSync(staging, mode);
+    }
+
+    renameSync(staging, dest);
+
+    return dest;
+};
+
+const digestFromChecksums = (checksums: string, assetName: string, subject: string): string => {
+    const line = checksums.split("\n").find((entry) => entry.trim().endsWith(` ${assetName}`));
+    const digest = line?.trim().split(/\s+/, 1)[0];
+
+    if (digest === undefined) {
+        throw new Error(`${subject} publishes no checksum for ${assetName}`);
+    }
+
+    return digest;
+};
+
+export { cacheDir, cachedDigest, type DigestRequest, downloadFile, publishedDigest };

package/src/deploy/freedesktop/copyright.ts

@@ -0,0 +1,41 @@
+import { readFileSync } from "node:fs";
+import type { DeploySettings } from "../types.js";
+
+const FORMAT_URL = "https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/";
+const CONTINUATION_BLANK = " .";
+
+const indentLicenseBody = (body: string): string[] =>
+    body
+        .split("\n")
+        .map((line) => (line.trim().length === 0 ? CONTINUATION_BLANK : ` ${line}`));
+
+const licenseBody = (licenseFile: string | null): string[] => {
+    if (licenseFile === null) {
+        return [];
+    }
+
+    try {
+        return indentLicenseBody(readFileSync(licenseFile, "utf8").trimEnd());
+    } catch {
+        return [];
+    }
+};
+
+const headerLines = (settings: DeploySettings): string[] => [
+    `Format: ${FORMAT_URL}`,
+    `Upstream-Name: ${settings.name}`,
+    ...(settings.homepage === null ? [] : [`Source: ${settings.homepage}`]),
+];
+
+const renderCopyright = (settings: DeploySettings): string =>
+    [
+        ...headerLines(settings),
+        "",
+        "Files: *",
+        `Copyright: ${settings.copyright}`,
+        `License: ${settings.license}`,
+        ...licenseBody(settings.paths.licenseFile),
+        "",
+    ].join("\n");
+
+export { renderCopyright };

package/src/deploy/freedesktop/dbus-service.ts

@@ -0,0 +1,19 @@
+import { posix } from "node:path";
+import type { DeploySettings } from "../types.js";
+import { renderIni } from "./ini.js";
+
+const SERVICE_GROUP = "D-BUS Service";
+const SERVICE_FLAG = "--gapplication-service";
+
+const renderDbusService = (settings: DeploySettings, prefix: string): string =>
+    renderIni([
+        {
+            name: SERVICE_GROUP,
+            entries: [
+                ["Name", settings.applicationId],
+                ["Exec", `${posix.join(prefix, "bin", settings.binaryName)} ${SERVICE_FLAG}`],
+            ],
+        },
+    ]);
+
+export { renderDbusService };