Files
reverse-engineering-anything/src/desktop/LinuxApplicationInventory.test.ts
T
2SinceJulyandgensokyo-dev 4b5d00bebd fix(desktop): ignore relative XDG bases in capture inventory
Desktop capture used XDG_* values without checking that they are
absolute, so a relative XDG_CONFIG_HOME (or data, state, cache) moved
state-directory, desktop-entry and build-secret lookups under the
working directory. The XDG Base Directory Specification says to ignore
a relative value; one xdgBase helper now applies that rule and falls
back to the home default.

Fixes #9702

Squashed from #9705 and rebased onto main. Setup's client registration
paths are left unchanged: each client's own handling of a relative
XDG_CONFIG_HOME has to be verified before REA writes elsewhere.

Co-Authored-By: gensokyo-dev <342580529+gensokyo-dev@users.noreply.github.com>
2026-11-14 14:59:49 +01:00

1025 lines
36 KiB
TypeScript

import {
chmod,
mkdir,
realpath,
stat,
symlink,
writeFile,
} from "node:fs/promises";
import { isAbsolute, join } from "node:path";
import { describe, expect, it, vi } from "vitest";
import { createTestTempDirectory } from "../../tests/fixtures/temporaryDirectory.js";
import { inspectLinuxApplication } from "./LinuxApplicationInventory.js";
import { OwnedFileHandle } from "../filesystem/OwnedFileHandle.js";
import { ArtifactFileCleanupFailure } from "../artifacts/ArtifactFileOperation.js";
import { desktopOperationFailure } from "../application/desktop/DesktopCaptureRefusals.js";
const fixture = async () => {
const root = await createTestTempDirectory("desktop-inventory-");
const home = join(root, "home");
const bin = join(root, "bin");
const share = join(root, "share");
await mkdir(join(home, ".config/Notes"), { recursive: true });
await mkdir(bin);
await mkdir(join(share, "applications"), { recursive: true });
await writeFile(join(bin, "notes-app"), "#!/bin/sh\nexit 0\n");
await chmod(join(bin, "notes-app"), 0o755);
await writeFile(
join(share, "applications/org.example.notes.desktop"),
[
"[Desktop Entry]",
"Type=Application",
"Name=Notes",
"Exec=notes-app --new %F",
"StartupWMClass=NotesWindow",
].join("\n"),
);
return {
home,
bin,
environment: {
PATH: `${bin}:/usr/bin:/bin`,
XDG_DATA_HOME: join(home, ".local/share"),
XDG_DATA_DIRS: share,
},
};
};
describe.skipIf(process.platform === "win32")(
"explicit executable traversal",
() => {
it("refuses a directory symlink as an executable while accepting a file symlink", async () => {
const { home, bin, environment } = await fixture();
const directoryAlias = join(bin, "directory-alias");
const fileAlias = join(bin, "file-alias");
await symlink(home, directoryAlias);
await symlink(join(bin, "notes-app"), fileAlias);
const inspect = (executable: string) =>
inspectLinuxApplication({
desktopEntry: undefined,
executable,
arguments: [],
environment,
home,
callerDirectory: home,
});
expect(await inspect(fileAlias)).toMatchObject({ ok: true });
expect(await inspect(directoryAlias)).toEqual({
ok: false,
error: { reason: "executable_not_found", program: directoryAlias },
});
});
it("preserves symlink and parent traversal for the selected executable", async () => {
const { home, environment } = await fixture();
const physical = join(home, "physical");
const named = join(home, "named");
await mkdir(join(physical, "child"), { recursive: true });
await mkdir(named);
await symlink(join(physical, "child"), join(named, "link"));
await writeFile(join(physical, "app"), "#!/bin/sh\n", { mode: 0o755 });
await writeFile(join(named, "app"), "#!/bin/sh\n", { mode: 0o755 });
const selected = `${named}/link/../app`;
const result = await inspectLinuxApplication({
desktopEntry: undefined,
executable: selected,
arguments: [],
environment,
home,
callerDirectory: home,
});
if (!result.ok) throw new Error(result.error.reason);
expect(result.value.inventory.argv[0]).toBe(selected);
expect(result.value.inventory.executable.resolved_path).toBe(
await realpath(join(physical, "app")),
);
});
},
);
describe.skipIf(process.platform === "win32")(
"desktop entry Unicode values",
() => {
it.each(["\u2028", "\u2029"])(
"retains Unicode separator %j in desktop launch arguments",
async (separator) => {
const { home, bin, environment } = await fixture();
const desktopEntry = join(home, "unicode.desktop");
await writeFile(
desktopEntry,
`[Desktop Entry]\nType=Application\nName=Notes${separator}Editor\nExec=notes-app --title "A${separator}B" %F\n`,
);
const inspected = await inspectLinuxApplication({
desktopEntry,
executable: undefined,
arguments: ["today.md"],
environment,
home,
callerDirectory: home,
});
expect(inspected).toMatchObject({
ok: true,
value: {
inventory: {
argv: ["notes-app", "--title", `A${separator}B`, "today.md"],
desktop_entry: { name: `Notes${separator}Editor` },
executable: { path: join(bin, "notes-app") },
},
},
});
},
);
},
);
describe.skipIf(process.platform === "win32")("inspectLinuxApplication", () => {
it("resolves a desktop entry id into a launch command and state directories", async () => {
const { home, bin, environment } = await fixture();
const inspected = await inspectLinuxApplication({
desktopEntry: "org.example.notes",
executable: undefined,
arguments: ["/tmp/today.md"],
environment,
home,
callerDirectory: home,
});
if (!inspected.ok) throw new Error(inspected.error.reason);
const { inventory } = inspected.value;
expect(inventory.argv).toEqual(["notes-app", "--new", "/tmp/today.md"]);
expect(inventory.desktop_entry).toMatchObject({
id: "org.example.notes",
name: "Notes",
startup_wm_class: "NotesWindow",
});
expect(inventory.executable).toEqual({
path: join(bin, "notes-app"),
resolved_path: expect.stringMatching(/notes-app$/u),
electron_markers: [],
});
expect(inventory.package.kind).toBe("unknown");
const existing = inventory.state_directories
.filter((entry) => entry.exists_at_start)
.map((entry) => entry.path);
// Case-insensitive filesystems also report the lowercase variant.
expect(existing).toContain(join(home, ".config/Notes"));
expect(
existing.every(
(path) =>
path.toLowerCase() === join(home, ".config/notes").toLowerCase(),
),
).toBe(true);
expect(inventory.state_directories.map((entry) => entry.path)).toContain(
join(home, ".config/notes-app"),
);
});
it("resolves a relative executable from the caller's directory and runs it there", async () => {
const { home, bin, environment } = await fixture();
const inspected = await inspectLinuxApplication({
desktopEntry: undefined,
executable: "./notes-app",
arguments: ["today.md"],
environment,
home,
callerDirectory: bin,
});
if (!inspected.ok) throw new Error(inspected.error.reason);
expect(inspected.value.inventory.argv).toEqual([
join(bin, "notes-app"),
"today.md",
]);
expect(inspected.value.inventory.working_directory).toBe(bin);
});
it("finds a desktop entry installed as a link to the file", async () => {
const { home, environment } = await fixture();
const exports = join(home, ".local/share/flatpak/exports/share");
await mkdir(join(exports, "applications"), { recursive: true });
await writeFile(
join(exports, "applications/org.example.linked.desktop"),
"[Desktop Entry]\nType=Application\nName=Linked\nExec=notes-app\n",
);
await mkdir(join(home, ".local/share/applications"), { recursive: true });
await symlink(
join(exports, "applications/org.example.linked.desktop"),
join(home, ".local/share/applications/org.example.linked.desktop"),
);
const inspected = await inspectLinuxApplication({
desktopEntry: "org.example.linked",
executable: undefined,
arguments: [],
environment,
home,
callerDirectory: home,
});
if (!inspected.ok) throw new Error(inspected.error.reason);
expect(inspected.value.inventory.desktop_entry).toMatchObject({
id: "org.example.linked",
name: "Linked",
});
});
it("names a flatpak's state after its application id, not the flatpak launcher", async () => {
const { home, bin, environment } = await fixture();
await writeFile(join(bin, "flatpak"), "#!/bin/sh\nexit 0\n");
await chmod(join(bin, "flatpak"), 0o755);
await mkdir(join(home, ".local/share/applications"), { recursive: true });
await writeFile(
join(home, ".local/share/applications/org.example.Notes.desktop"),
[
"[Desktop Entry]",
"Type=Application",
"Name=Notes",
"Exec=flatpak run --branch=stable --command=notes org.example.Notes @@u %U @@",
].join("\n"),
);
const inspected = await inspectLinuxApplication({
desktopEntry: "org.example.Notes",
executable: undefined,
arguments: [],
environment,
home,
callerDirectory: home,
});
if (!inspected.ok) throw new Error(inspected.error.reason);
const { inventory } = inspected.value;
expect(inventory.package).toMatchObject({
kind: "flatpak",
name: "org.example.Notes",
});
const paths = inventory.state_directories.map((entry) => entry.path);
expect(paths).toContain(join(home, ".var/app/org.example.Notes"));
expect(paths).toContain(join(home, ".config/org.example.Notes"));
expect(paths.filter((path) => /flatpak/iu.test(path))).toEqual([]);
});
it("refuses an unknown entry and an executable that is not on PATH", async () => {
const { home, environment } = await fixture();
const missingEntry = await inspectLinuxApplication({
desktopEntry: "org.example.missing",
executable: undefined,
arguments: [],
environment,
home,
callerDirectory: home,
});
expect(!missingEntry.ok && missingEntry.error.reason).toBe(
"desktop_entry_not_found",
);
const missingProgram = await inspectLinuxApplication({
desktopEntry: undefined,
executable: "not-installed-anywhere",
arguments: [],
environment,
home,
callerDirectory: home,
});
expect(!missingProgram.ok && missingProgram.error).toEqual({
reason: "executable_not_found",
program: "not-installed-anywhere",
});
});
});
describe.skipIf(process.platform === "win32")(
"inspectLinuxApplication desktop file ids",
() => {
it("resolves a nested entry by its desktop file id before a lower-priority flat one", async () => {
const { home, environment } = await fixture();
const share = environment.XDG_DATA_DIRS;
await mkdir(join(home, ".local/share/applications/vendor"), {
recursive: true,
});
await writeFile(
join(
home,
".local/share/applications/vendor/org.example.nested.desktop",
),
"[Desktop Entry]\nType=Application\nName=High\nExec=notes-app --high\n",
);
// The spec's id for the nested entry above, installed at lower priority.
await writeFile(
join(share, "applications/vendor-org.example.nested.desktop"),
"[Desktop Entry]\nType=Application\nName=Low\nExec=notes-app --low\n",
);
const inventory = await inventoryOf("vendor-org.example.nested", {
home,
environment,
});
expect(inventory.desktop_entry).toMatchObject({
id: "vendor-org.example.nested",
name: "High",
});
expect(inventory.argv).toEqual(["notes-app", "--high"]);
});
it("resolves an id whose directory name itself contains a dash", async () => {
const { home, environment } = await fixture();
const directory = join(home, ".local/share/applications/org.example");
await mkdir(directory, { recursive: true });
await writeFile(
join(directory, "my-app.desktop"),
"[Desktop Entry]\nType=Application\nName=Dashed\nExec=notes-app\n",
);
const inventory = await inventoryOf("org.example-my-app", {
home,
environment,
});
expect(inventory.desktop_entry).toMatchObject({
id: "org.example-my-app",
name: "Dashed",
});
});
it("refuses a lower-priority entry when an applicable path cannot be probed", async () => {
const { home, environment } = await fixture();
const share = environment.XDG_DATA_DIRS;
const applications = join(home, ".local/share/applications");
const vendor = join(applications, "vendor");
await mkdir(vendor, { recursive: true });
await writeFile(
join(vendor, "org.example.app.desktop"),
"[Desktop Entry]\nType=Application\nName=High\nExec=notes-app --high\n",
);
await writeFile(
join(share, "applications/vendor-org.example.app.desktop"),
"[Desktop Entry]\nType=Application\nName=Low\nExec=notes-app --low\n",
);
// The exact higher-priority path cannot be examined without directory
// traversal permission; it must remain unknown rather than absent.
await chmod(vendor, 0o000);
try {
const inspected = await inspectLinuxApplication({
desktopEntry: "vendor-org.example.app",
executable: undefined,
arguments: [],
environment,
home,
callerDirectory: home,
});
// Root ignores the mode bits, so the directory stays listable and the
// scenario this asserts cannot be built.
if (inspected.ok) expect(process.getuid?.()).toBe(0);
else
expect(inspected.error.reason).toBe(
"desktop_entry_search_incomplete",
);
} finally {
await chmod(vendor, 0o755);
}
});
},
);
describe.skipIf(process.platform === "win32")(
"unresolved desktop entry link targets",
() => {
it
.skipIf(process.getuid?.() === 0)
.each(["directory", "flat-file", "nested-file"] as const)(
"refuses a lower-priority entry when a %s link target cannot be examined",
async (kind) => {
const { home, environment } = await fixture();
const applications = join(home, ".local/share/applications");
const blocked = join(home, "blocked");
const target = join(blocked, "vendor");
await mkdir(target, { recursive: true });
await mkdir(applications, { recursive: true });
await writeFile(
join(target, "app.desktop"),
"[Desktop Entry]\nType=Application\nName=High\nExec=notes-app\n",
);
await writeFile(
join(environment.XDG_DATA_DIRS, "applications/vendor-app.desktop"),
"[Desktop Entry]\nType=Application\nName=Low\nExec=notes-app\n",
);
let link: string;
if (kind === "directory") {
link = join(applications, "vendor");
await symlink(target, link);
} else {
if (kind === "nested-file") await mkdir(join(applications, "vendor"));
link = join(
applications,
kind === "flat-file" ? "vendor-app.desktop" : "vendor/app.desktop",
);
await symlink(join(target, "app.desktop"), link);
}
await chmod(blocked, 0o000);
try {
const probe = await stat(link).then(
() => undefined,
(cause: unknown) => cause,
);
expect(probe).toMatchObject({ code: "EACCES" });
const result = await inspectLinuxApplication({
desktopEntry: "vendor-app",
executable: undefined,
arguments: [],
environment,
home,
callerDirectory: home,
});
expect(result).toMatchObject({
ok: false,
error: { reason: "desktop_entry_search_incomplete" },
});
} finally {
await chmod(blocked, 0o755);
}
},
);
},
);
describe.skipIf(process.platform === "win32")(
"remaining desktop file id controls",
() => {
it("ignores an unreadable sibling that cannot encode the requested ID", async () => {
const { home, environment } = await fixture();
const applications = join(home, ".local/share/applications");
const found = join(applications, "zz-vendor");
const unreadable = join(applications, "aa-vendor");
await mkdir(found, { recursive: true });
await mkdir(unreadable, { recursive: true });
await writeFile(
join(found, "org.example.app.desktop"),
"[Desktop Entry]\nType=Application\nName=High\nExec=notes-app\n",
);
await chmod(unreadable, 0o000);
try {
const inventory = await inventoryOf("zz-vendor-org.example.app", {
home,
environment,
});
// This sibling cannot encode the requested ID and is irrelevant to
// selecting the known matching path.
expect(inventory.desktop_entry).toMatchObject({
id: "zz-vendor-org.example.app",
name: "High",
});
} finally {
await chmod(unreadable, 0o755);
}
});
it.skipIf(process.getuid?.() === 0)(
"finds a same-root spelling after an applicable probe fails",
async () => {
const { home, environment } = await fixture();
const applications = join(home, ".local/share/applications");
const blocked = join(home, "blocked");
await mkdir(join(blocked, "aa"), { recursive: true });
await mkdir(join(applications, "aa-bb"), { recursive: true });
await symlink(join(blocked, "aa"), join(applications, "aa"));
await writeFile(
join(applications, "aa-bb/app.desktop"),
"[Desktop Entry]\nType=Application\nName=Matched\nExec=notes-app\n",
);
await chmod(blocked, 0o000);
try {
await expect(stat(join(applications, "aa"))).rejects.toMatchObject({
code: "EACCES",
});
const inventory = await inventoryOf("aa-bb-app", {
home,
environment,
});
expect(inventory.desktop_entry).toMatchObject({
id: "aa-bb-app",
name: "Matched",
});
} finally {
await chmod(blocked, 0o755);
}
},
);
it.each(["plain", "vendor-app", "loop-vendor-app"])(
"ignores unrelated directory-link cycles when resolving %s in a later root",
async (id) => {
const { home, environment } = await fixture();
const applications = join(home, ".local/share/applications");
await mkdir(applications, { recursive: true });
await symlink(".", join(applications, "loop"));
await writeFile(
join(environment.XDG_DATA_DIRS, "applications", id + ".desktop"),
"[Desktop Entry]\nType=Application\nName=Selected\nExec=notes-app\n",
);
const inventory = await inventoryOf(id, { home, environment });
expect(inventory.desktop_entry).toMatchObject({ id, name: "Selected" });
},
);
it("keeps an applicable path beyond the depth allowance unresolved", async () => {
const { home, environment } = await fixture();
const applications = join(home, ".local/share/applications");
const directory = join(applications, "one/two/three/four/five");
await mkdir(directory, { recursive: true });
await writeFile(
join(directory, "app.desktop"),
"[Desktop Entry]\nType=Application\nName=High\nExec=notes-app\n",
);
const id = "one-two-three-four-five-app";
await writeFile(
join(environment.XDG_DATA_DIRS, "applications", id + ".desktop"),
"[Desktop Entry]\nType=Application\nName=Low\nExec=notes-app\n",
);
const result = await inspectLinuxApplication({
desktopEntry: id,
executable: undefined,
arguments: [],
environment,
home,
callerDirectory: home,
});
expect(result).toMatchObject({
ok: false,
error: { reason: "desktop_entry_search_incomplete" },
});
});
it("searches a directory whose own name ends in .desktop", async () => {
const { home, environment } = await fixture();
const directory = join(home, ".local/share/applications/vendor.desktop");
await mkdir(directory, { recursive: true });
await writeFile(
join(directory, "app.desktop"),
"[Desktop Entry]\nType=Application\nName=Nested\nExec=notes-app\n",
);
const inventory = await inventoryOf("vendor.desktop-app", {
home,
environment,
});
expect(inventory.desktop_entry).toMatchObject({
id: "vendor.desktop-app",
name: "Nested",
});
});
it("keeps a dash inside a directory name, not only inside the file name", async () => {
const { home, environment } = await fixture();
const directory = join(
home,
".local/share/applications/org.example-tools",
);
await mkdir(directory, { recursive: true });
await writeFile(
join(directory, "my-app.desktop"),
"[Desktop Entry]\nType=Application\nName=Both\nExec=notes-app\n",
);
const inventory = await inventoryOf("org.example-tools-my-app", {
home,
environment,
});
expect(inventory.desktop_entry).toMatchObject({
id: "org.example-tools-my-app",
name: "Both",
});
});
},
);
describe.skipIf(process.platform === "win32")(
"inspectLinuxApplication incomplete desktop file searches",
() => {
it("ignores deep trees that cannot encode the requested desktop ID", async () => {
const { home, environment } = await fixture();
const share = environment.XDG_DATA_DIRS;
const applications = join(home, ".local/share/applications");
// An unrelated deep tree cannot change the requested ID's applicability.
for (let index = 0; index < 6; index += 1)
await mkdir(
join(applications, ...Array<string>(index + 1).fill("deep")),
{ recursive: true },
);
await writeFile(
join(share, "applications/buried-org.example.app.desktop"),
"[Desktop Entry]\nType=Application\nName=Low\nExec=notes-app\n",
);
const inspected = await inspectLinuxApplication({
desktopEntry: "buried-org.example.app",
executable: undefined,
arguments: [],
environment,
home,
callerDirectory: home,
});
expect(inspected).toMatchObject({
ok: true,
value: {
inventory: {
desktop_entry: { id: "buried-org.example.app", name: "Low" },
},
},
});
});
},
);
/** The inventory of an installed desktop entry, launched with no arguments. */
const inventoryOf = async (
desktopEntry: string,
{
home,
environment,
}: {
home: string;
environment: Readonly<Record<string, string | undefined>>;
},
) => {
const inspected = await inspectLinuxApplication({
desktopEntry,
executable: undefined,
arguments: [],
environment,
home,
callerDirectory: home,
});
if (!inspected.ok) throw new Error(inspected.error.reason);
return inspected.value.inventory;
};
describe.skipIf(process.platform === "win32")(
"inspectLinuxApplication state and environment",
() => {
it("finds the program on the PATH an env prefix sets, not the host's", async () => {
const installed = await fixture();
const { home, bin } = installed;
const opt = join(home, "opt/bin");
await mkdir(opt, { recursive: true });
for (const directory of [bin, opt]) {
await writeFile(join(directory, "notes"), "#!/bin/sh\nexit 0\n");
await chmod(join(directory, "notes"), 0o755);
}
await mkdir(join(home, ".local/share/applications"), { recursive: true });
await writeFile(
join(home, ".local/share/applications/org.example.env.desktop"),
`[Desktop Entry]\nType=Application\nName=Env\nExec=env PATH=${opt}/:/usr/bin XDG_CONFIG_HOME=${home}/settings notes\n`,
);
const inventory = await inventoryOf("org.example.env", installed);
expect(inventory.executable.path).toBe(join(opt, "notes"));
expect(inventory.state_directories.map((entry) => entry.path)).toContain(
join(home, "settings/notes"),
);
});
it("reads a relative PATH entry from the folder the entry starts in", async () => {
const installed = await fixture();
const { home } = installed;
const opt = join(home, "opt/bin");
await mkdir(opt, { recursive: true });
await writeFile(join(opt, "notes"), "#!/bin/sh\nexit 0\n");
await chmod(join(opt, "notes"), 0o755);
await mkdir(join(home, ".local/share/applications"), { recursive: true });
await writeFile(
join(home, ".local/share/applications/org.example.dot.desktop"),
`[Desktop Entry]\nType=Application\nName=Dot\nPath=${opt}\nExec=env PATH=. notes\n`,
);
await writeFile(
join(home, ".local/share/applications/org.example.empty.desktop"),
`[Desktop Entry]\nType=Application\nName=Empty\nPath=${opt}\nExec=env PATH= notes\n`,
);
// `..` after a link climbs from the link's target, so the lookup keeps it.
const releases = join(home, "releases");
await mkdir(join(releases, "v2"), { recursive: true });
await mkdir(join(releases, "bin"));
await writeFile(join(releases, "bin/notes"), "#!/bin/sh\nexit 0\n");
await chmod(join(releases, "bin/notes"), 0o755);
await symlink(join(releases, "v2"), join(home, "opt/current"));
const linked = `${home}/opt/current/../bin/notes`;
await writeFile(
join(home, ".local/share/applications/org.example.link.desktop"),
`[Desktop Entry]\nType=Application\nName=Link\nExec=${linked}\n`,
);
const inventory = await inventoryOf("org.example.dot", installed);
const viaEmpty = await inventoryOf("org.example.empty", installed);
const viaLink = await inventoryOf("org.example.link", installed);
// The launch searches the host's relative entries too, but the export cannot.
const hostRelative = await inspectLinuxApplication({
desktopEntry: undefined,
executable: "notes",
arguments: [],
environment: { PATH: "opt/bin" },
home,
callerDirectory: home,
});
expect(inventory.executable.path).toBe(join(opt, "notes"));
expect(viaEmpty.executable.path).toBe(join(opt, "notes"));
expect(viaLink.executable.path).toBe(linked);
expect(hostRelative).toMatchObject({
ok: false,
error: { reason: "executable_on_relative_path" },
});
});
it("names state directories after the entry's full id", async () => {
const installed = await fixture();
const { home } = installed;
await mkdir(join(home, ".config/org.example.notes"), { recursive: true });
const inventory = await inventoryOf("org.example.notes", installed);
expect(inventory.state_directories).toContainEqual({
path: join(home, ".config/org.example.notes"),
exists_at_start: true,
});
});
it("adds a state folder named after the application in another letter case, such as GIMP's", async () => {
const installed = await fixture();
const { home, bin } = installed;
await writeFile(join(bin, "gimp-2.10"), "#!/bin/sh\nexit 0\n");
await chmod(join(bin, "gimp-2.10"), 0o755);
await mkdir(join(home, ".local/share/applications"), { recursive: true });
await writeFile(
join(home, ".local/share/applications/gimp.desktop"),
"[Desktop Entry]\nType=Application\nName=GNU Image Manipulation Program\nExec=gimp-2.10 %U\n",
);
await mkdir(join(home, ".config/GIMP/2.10"), { recursive: true });
await writeFile(join(home, ".config/GIMP/2.10/sessionrc"), "x\n");
await mkdir(join(home, ".Gimp"));
const unrelated = [
".config/GIMPshop",
".config/MyGIMP",
".config/Other/GIMP",
];
for (const folder of unrelated)
await mkdir(join(home, folder), { recursive: true });
const inventory = await inventoryOf("gimp", installed);
expect(inventory.state_directories).toEqual(
expect.arrayContaining([
{ path: join(home, ".config/GIMP"), exists_at_start: true },
{ path: join(home, ".Gimp"), exists_at_start: true },
]),
);
const paths = inventory.state_directories.map((entry) => entry.path);
for (const folder of unrelated)
expect(paths).not.toContain(join(home, folder));
});
it("adds the dotfiles in the home named after the application, which it may only read", async () => {
const installed = await fixture();
const { home } = installed;
const named = [".notes-app-cfg.ini", ".notesrc", ".notes.conf"];
for (const name of [...named, ".notesy", ".other.ini"])
await writeFile(join(home, name), "x\n");
const inventory = await inventoryOf("org.example.notes", installed);
const paths = inventory.state_directories.map((entry) => entry.path);
expect(paths).toEqual(
expect.arrayContaining(named.map((name) => join(home, name))),
);
expect(paths).not.toContain(join(home, ".notesy"));
expect(paths).not.toContain(join(home, ".other.ini"));
});
it("adds KDE's ~/.config/<name>rc, which the application may first write during the capture", async () => {
const installed = await fixture();
const { home } = installed;
await mkdir(join(home, ".config"), { recursive: true });
await writeFile(join(home, ".config/org.example.notesrc"), "x\n");
const inventory = await inventoryOf("org.example.notes", installed);
expect(inventory.state_directories).toEqual(
expect.arrayContaining([
{ path: join(home, ".config/notesrc"), exists_at_start: false },
{
path: join(home, ".config/org.example.notesrc"),
exists_at_start: true,
},
]),
);
});
},
);
describe.skipIf(process.platform === "win32")(
"inspectLinuxApplication relative XDG bases",
() => {
it("ignores a relative XDG base and keeps the home default", async () => {
const installed = await fixture();
const { home, environment } = installed;
const inventory = await inventoryOf("org.example.notes", {
...installed,
environment: {
...environment,
XDG_CONFIG_HOME: "relative-config",
XDG_DATA_HOME: "relative-data",
XDG_STATE_HOME: "relative-state",
XDG_CACHE_HOME: "relative-cache",
},
});
const paths = inventory.state_directories.map((entry) => entry.path);
expect(paths).toContain(join(home, ".config/notes"));
expect(paths).toContain(join(home, ".local/share/notes"));
expect(paths).toContain(join(home, ".local/state/notes"));
expect(paths).toContain(join(home, ".cache/notes"));
expect(paths.filter((path) => !isAbsolute(path))).toEqual([]);
});
it("reads a relative XDG base an Exec env prefix sets as unset", async () => {
const installed = await fixture();
const { home, bin } = installed;
await mkdir(join(home, ".config"), { recursive: true });
await mkdir(join(home, ".local/share/applications"), {
recursive: true,
});
await writeFile(
join(
home,
".local/share/applications/org.example.env-relative.desktop",
),
`[Desktop Entry]\nType=Application\nName=Env\nExec=env XDG_CONFIG_HOME=relative-config notes-app\n`,
);
const inventory = await inventoryOf(
"org.example.env-relative",
installed,
);
expect(inventory.executable.path).toBe(join(bin, "notes-app"));
expect(inventory.state_directories.map((entry) => entry.path)).toContain(
join(home, ".config/notes-app"),
);
});
it("finds a desktop entry by id when XDG_DATA_HOME is relative", async () => {
const installed = await fixture();
const { home, environment } = installed;
await mkdir(join(home, ".local/share/applications"), { recursive: true });
await writeFile(
join(home, ".local/share/applications/org.example.home-notes.desktop"),
`[Desktop Entry]\nType=Application\nName=HomeNotes\nExec=notes-app\n`,
);
const inventory = await inventoryOf("org.example.home-notes", {
...installed,
environment: { ...environment, XDG_DATA_HOME: "relative-data" },
});
expect(inventory.desktop_entry).toMatchObject({ name: "HomeNotes" });
});
},
);
it.skipIf(process.platform === "win32").each([
{ stage: "desktop entry", closeAt: 1, oversized: false, cancel: false },
{
stage: "desktop entry capacity failure",
closeAt: 1,
oversized: true,
cancel: false,
},
{ stage: "executable header", closeAt: 2, oversized: false, cancel: false },
{
stage: "optional Electron probe",
closeAt: 3,
oversized: false,
cancel: false,
},
{
stage: "desktop entry final cancellation",
closeAt: 1,
oversized: false,
cancel: true,
},
{
stage: "capacity failure before final cancellation",
closeAt: 1,
oversized: true,
cancel: true,
},
])(
"retains and retries a failed close during $stage",
async ({ closeAt, oversized, cancel }) => {
const { home, bin, environment } = await fixture();
const entry = join(
environment.XDG_DATA_DIRS,
"applications/org.example.notes.desktop",
);
if (oversized) await writeFile(entry, "x".repeat(1024 * 1024 + 1));
const controller = new AbortController();
const reason = new Error("cancelled during close");
const denied = new Error("descriptor close denied");
const originalClose = OwnedFileHandle.prototype.close;
let closes = 0;
let retained: OwnedFileHandle | undefined;
const close = vi
.spyOn(OwnedFileHandle.prototype, "close")
.mockImplementation(function (this: OwnedFileHandle) {
closes += 1;
if (closes === closeAt || this === retained) {
// oxlint-disable-next-line typescript/no-this-alias -- Retain the exact failed descriptor owner for retry.
retained = this;
if (cancel) controller.abort(reason);
return Promise.reject(denied);
}
return originalClose.call(this);
});
try {
const failure = await inspectLinuxApplication(
{
desktopEntry: "org.example.notes",
executable: undefined,
arguments: [],
environment,
home,
callerDirectory: home,
},
controller.signal,
{
runQuery: async () => "missing",
apt: {
trusted: join(home, "trusted"),
trustedParts: join(home, "trusted.d"),
lists: join(home, "lists"),
},
},
).catch((cause: unknown) => cause);
expect(retained).toBeDefined();
if (!(failure instanceof ArtifactFileCleanupFailure))
throw new Error("expected transferable descriptor cleanup", {
cause: failure,
});
const expectedPath =
closeAt === 1 ? entry : await realpath(join(bin, "notes-app"));
expect(failure.cleanup?.resources).toEqual([expectedPath]);
expect(failure.fileCleanupFailure.owner).toBe(retained);
expect(failure.fileCleanupFailure.cleanupCause).toBe(denied);
const outcome = failure.fileCleanupFailure.outcome;
if (oversized) {
expect(outcome).toMatchObject({
kind: "failed",
cause: {
maximumBytes: 1024 * 1024,
observedBytes: BigInt(1024 * 1024 + 1),
},
});
} else if (closeAt === 3) {
expect(outcome).toMatchObject({
kind: "failed",
cause: { kind: "unsupported" },
});
} else {
expect(outcome.kind).toBe("completed");
}
if (cancel && !oversized)
expect(failure.cancellation?.reason).toBe(reason);
else expect(failure.reason).not.toBe("cancelled");
const projected = desktopOperationFailure(
failure,
controller.signal,
"capture_desktop_application",
"Desktop capture",
);
expect(projected.cleanupIncomplete).toBe(true);
expect(projected.cleanupResources).toEqual([expectedPath]);
await expect(failure.cleanupLease.release()).rejects.toBe(denied);
expect(projected.cleanupIncomplete).toBe(true);
close.mockRestore();
await failure.cleanupLease.release();
expect(projected.cleanupIncomplete).toBe(false);
expect(projected.cleanupResources).toEqual([]);
expect(retained?.handle.fd).toBe(-1);
} finally {
close.mockRestore();
await retained?.close();
}
},
);