@kuznai/inception-engine 0.22.0 → 0.24.0

package/dist/test/unit/formatters.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/unit/formatters.test.js

@@ -0,0 +1,74 @@
+import assert from "node:assert/strict";
+import { stripVTControlCharacters } from "node:util";
+import { describe, it } from "node:test";
+import { formatDryRunPlan } from "../../src/formatters.js";
+function stripAnsi(value) {
+    return stripVTControlCharacters(value);
+}
+describe("formatDryRunPlan", () => {
+    it("returns an empty string when there are no planned changes", () => {
+        assert.equal(formatDryRunPlan([]), "");
+    });
+    it("groups changes by agent, sorts groups, and renders supported detail fields", () => {
+        const plan = [
+            {
+                agent: "opencode",
+                kind: "config-patch",
+                skill: "beta",
+                target: "/targets/opencode.json",
+                verb: "patch-config",
+                patch: { enabled: true },
+            },
+            {
+                agent: "claude-code",
+                kind: "file-write",
+                skill: "alpha",
+                source: "/source/alpha.md",
+                target: "/targets/alpha.md",
+                verb: "write-file",
+            },
+            {
+                agent: "claude-code",
+                kind: "config-patch",
+                skill: "gamma",
+                target: "/targets/gamma.json",
+                verb: "unapply-patch",
+                patch: { enabled: null },
+            },
+            {
+                agent: "claude-code",
+                kind: "toml-patch",
+                skill: "delta",
+                target: "/targets/delta.toml",
+                verb: "patch-toml",
+                patch: { approval_policy: "suggest" },
+            },
+            {
+                agent: "claude-code",
+                kind: "frontmatter-emit",
+                skill: "epsilon",
+                target: "/targets/epsilon.md",
+                verb: "emit-frontmatter",
+                frontmatter: { tools: ["github"] },
+            },
+            {
+                agent: "claude-code",
+                kind: "file-write",
+                skill: "zeta",
+                target: "/targets/zeta.md",
+                verb: "remove",
+            },
+        ];
+        const output = stripAnsi(formatDryRunPlan(plan));
+        assert.match(output, /^claude-code\n(?:[\s\S]*?)\nopencode\n/m, `expected claude-code group before opencode, got:\n${output}`);
+        assert.match(output, /write-file alpha/);
+        assert.match(output, /source: \/source\/alpha\.md/);
+        assert.match(output, /target: \/targets\/alpha\.md/);
+        assert.match(output, /undo:\s+\{"enabled":null\}/);
+        assert.match(output, /patch:\s+\{"approval_policy":"suggest"\}/);
+        assert.match(output, /frontmatter: \{"tools":\["github"\]\}/);
+        assert.match(output, /remove zeta/);
+        assert.doesNotMatch(output, /source: \/targets\/zeta\.md/);
+        assert.match(output, /patch-config beta/);
+    });
+});

package/dist/test/unit/init-fixture.test.js

@@ -1,10 +1,13 @@
 import assert from "node:assert/strict";
-import { cp, readFile, rm } from "node:fs/promises";
+import { cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { spawn } from "node:child_process";
 import path from "node:path";
 import { describe, it } from "node:test";
+import { runInit } from "../../src/core/init.js";
+import { logger } from "../../src/logger.js";
 import { makeTmpDir } from "../helpers/fs.js";
 import { assertPathEndsWith, normalizeSlashes } from "../helpers/path.js";
+logger.silence();
 const PROJECT_ROOT = path.resolve(import.meta.dirname, "..", "..");
 const FIXTURE_DIR = path.join(PROJECT_ROOT, "test", "fixtures", "readme-sample");
 function run(args, env) {
@@ -151,3 +154,84 @@ describe("init against readme-sample fixture", () => {
         }
     });
 });
+// ---------------------------------------------------------------------------
+// Block 3: init discovery of GitHub Copilot native instruction surfaces
+// ---------------------------------------------------------------------------
+describe("init Copilot native instruction discovery", () => {
+    it("runInit dryRun succeeds when .github/copilot-instructions.md is present", async () => {
+        const dir = await makeTmpDir();
+        try {
+            await mkdir(path.join(dir, ".github"), { recursive: true });
+            await writeFile(path.join(dir, ".github", "copilot-instructions.md"), "# Copilot instructions");
+            // Use dryRun to avoid writing inception.json
+            const result = await runInit({
+                directory: dir,
+                agents: null,
+                dryRun: true,
+                force: false,
+                verbose: false,
+            });
+            assert.equal(result, 0);
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+    it("init --plan output includes copilot-repo scope for .github/copilot-instructions.md", async () => {
+        const dir = await makeTmpDir();
+        try {
+            await mkdir(path.join(dir, ".github"), { recursive: true });
+            await writeFile(path.join(dir, ".github", "copilot-instructions.md"), "# Copilot instructions");
+            const { stdout, code } = await run(["init", dir, "--plan"]);
+            assert.equal(code, 0, `init --plan failed:\n${stdout}`);
+            const manifest = extractPlanJson(stdout);
+            const copilotEntry = manifest.agentRules.find((r) => r.scope === "copilot-repo");
+            assert.ok(copilotEntry, `expected a copilot-repo entry in agentRules, got: ${JSON.stringify(manifest.agentRules)}`);
+            assert.deepEqual(copilotEntry.agents, ["github-copilot"]);
+            assertPathEndsWith(copilotEntry.path, ".github/copilot-instructions.md", `copilot-repo entry path should end with .github/copilot-instructions.md`);
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+    it("init --plan output includes copilot-scoped scope for .github/instructions/*.instructions.md", async () => {
+        const dir = await makeTmpDir();
+        try {
+            await mkdir(path.join(dir, ".github", "instructions"), {
+                recursive: true,
+            });
+            await writeFile(path.join(dir, ".github", "instructions", "typescript.instructions.md"), "# TypeScript scoped instructions");
+            await writeFile(path.join(dir, ".github", "instructions", "python.instructions.md"), "# Python scoped instructions");
+            const { stdout, code } = await run(["init", dir, "--plan"]);
+            assert.equal(code, 0, `init --plan failed:\n${stdout}`);
+            const manifest = extractPlanJson(stdout);
+            const scopedEntries = manifest.agentRules.filter((r) => r.scope === "copilot-scoped");
+            assert.equal(scopedEntries.length, 2, `expected 2 copilot-scoped entries, got ${scopedEntries.length}: ${JSON.stringify(manifest.agentRules)}`);
+            for (const entry of scopedEntries) {
+                assert.deepEqual(entry.agents, ["github-copilot"]);
+            }
+            const names = scopedEntries.map((e) => e.name).sort();
+            assert.deepEqual(names, ["python", "typescript"]);
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+    it("non-.github/ copilot-instructions.md still maps to claude-code (backward compat)", async () => {
+        const dir = await makeTmpDir();
+        try {
+            await mkdir(path.join(dir, "rules"), { recursive: true });
+            await writeFile(path.join(dir, "rules", "copilot-instructions.md"), "# Copilot instructions");
+            const { stdout, code } = await run(["init", dir, "--plan"]);
+            assert.equal(code, 0, `init --plan failed:\n${stdout}`);
+            const manifest = extractPlanJson(stdout);
+            const entry = manifest.agentRules.find((r) => r.path.endsWith("copilot-instructions.md"));
+            assert.ok(entry, `expected a copilot-instructions.md entry, got: ${JSON.stringify(manifest.agentRules)}`);
+            assert.ok(entry.agents.includes("claude-code"), `expected agents to include claude-code, got: ${JSON.stringify(entry.agents)}`);
+            assert.notEqual(entry.scope, "copilot-repo", "rules/ copilot-instructions.md should not use copilot-repo scope");
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+});

package/dist/test/unit/manifest.test.js

@@ -554,6 +554,78 @@ describe("loadManifest", () => {
             await rm(dir, { recursive: true });
         }
     });
+    it("agentRules accepts targetDir with scope: 'repo'", async () => {
+        const dir = await makeTmpDir();
+        try {
+            await writeFile(path.join(dir, "inception.json"), JSON.stringify({
+                skills: [],
+                agentRules: [
+                    {
+                        name: "my-rule",
+                        agents: ["claude-code"],
+                        path: "rules/CLAUDE.md",
+                        scope: "repo",
+                        targetDir: "apps/frontend",
+                    },
+                ],
+            }));
+            const manifest = await loadManifest(dir);
+            assert.equal(manifest.agentRules[0]?.targetDir, "apps/frontend");
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+    it("agentRules rejects targetDir with scope: 'global'", async () => {
+        const dir = await makeTmpDir();
+        try {
+            await writeFile(path.join(dir, "inception.json"), JSON.stringify({
+                skills: [],
+                agentRules: [
+                    {
+                        name: "my-rule",
+                        agents: ["claude-code"],
+                        path: "rules/CLAUDE.md",
+                        scope: "global",
+                        targetDir: "apps/frontend",
+                    },
+                ],
+            }));
+            await assert.rejects(loadManifest(dir), (err) => {
+                assert.ok(err instanceof UserError);
+                assert.match(err.message, /targetDir is only supported for scope "repo" or "workspace"/);
+                return true;
+            });
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+    it("throws when agentRules targetDir is absolute", async () => {
+        const dir = await makeTmpDir();
+        try {
+            await writeFile(path.join(dir, "inception.json"), JSON.stringify({
+                skills: [],
+                agentRules: [
+                    {
+                        name: "my-rule",
+                        agents: ["claude-code"],
+                        path: "rules/CLAUDE.md",
+                        scope: "repo",
+                        targetDir: "/absolute/path",
+                    },
+                ],
+            }));
+            await assert.rejects(loadManifest(dir), (err) => {
+                assert.ok(err instanceof UserError);
+                assert.match(err.message, /targetDir must be a relative path/);
+                return true;
+            });
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
     it("defaults mcpServers and agentRules to [] when omitted", async () => {
         const dir = await makeTmpDir();
         try {

package/dist/test/unit/ownership.test.js

@@ -1,8 +1,8 @@
 import assert from "node:assert/strict";
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { mkdir, readFile, rm, symlink, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { describe, it } from "node:test";
-import { defaultRegistryPersistence, lookupDeployment, registerDeployment, registryPath, unregisterDeployment, verifyDeployment, } from "../../src/core/ownership.js";
+import { defaultRegistryPersistence, lookupDeployment, registerDeployment, registryDirPath, registryPath, unregisterDeployment, verifyDeployment, } from "../../src/core/ownership.js";
 import { exists, makeTmpDir } from "../helpers/fs.js";
 describe("registerDeployment", () => {
     it("creates registry file and adds entry", async () => {
@@ -56,7 +56,7 @@ describe("registerDeployment", () => {
             await rm(home, { recursive: true });
         }
     });
-    it("sets registry file permissions to 0o644 on POSIX", {
+    it("sets registry file permissions to 0o600 on POSIX", {
         skip: process.platform === "win32",
     }, async () => {
         const home = await makeTmpDir();
@@ -70,7 +70,27 @@ describe("registerDeployment", () => {
             });
             const { stat } = await import("node:fs/promises");
             const statResult = await stat(registryPath(home));
-            assert.equal(statResult.mode & 0o777, 0o644);
+            assert.equal(statResult.mode & 0o777, 0o600);
+        }
+        finally {
+            await rm(home, { recursive: true });
+        }
+    });
+    it("sets registry directory permissions to 0o700 on POSIX", {
+        skip: process.platform === "win32",
+    }, async () => {
+        const home = await makeTmpDir();
+        try {
+            await registerDeployment(home, "/fake/target", {
+                kind: "skill-dir",
+                source: "/fake/source",
+                skill: "my-skill",
+                agent: "claude-code",
+                method: "symlink",
+            });
+            const { stat } = await import("node:fs/promises");
+            const statResult = await stat(registryDirPath(home));
+            assert.equal(statResult.mode & 0o777, 0o700);
         }
         finally {
             await rm(home, { recursive: true });
@@ -121,6 +141,26 @@ describe("registerDeployment", () => {
             await rm(home, { recursive: true, force: true });
         }
     });
+    it("refuses to write the registry through a symlinked state directory", {
+        skip: process.platform === "win32",
+    }, async () => {
+        const home = await makeTmpDir();
+        const elsewhere = await makeTmpDir();
+        try {
+            await symlink(elsewhere, registryDirPath(home), "dir");
+            await assert.rejects(registerDeployment(home, "/fake/target", {
+                kind: "skill-dir",
+                source: "/fake/source",
+                skill: "my-skill",
+                agent: "claude-code",
+                method: "copy",
+            }), /Refusing to use registry directory symlink/);
+        }
+        finally {
+            await rm(home, { recursive: true, force: true });
+            await rm(elsewhere, { recursive: true, force: true });
+        }
+    });
 });
 describe("unregisterDeployment", () => {
     it("removes the entry for the given target", async () => {
@@ -219,6 +259,23 @@ describe("lookupDeployment", () => {
             await rm(home, { recursive: true });
         }
     });
+    it("returns null when the registry file path is a symlink", {
+        skip: process.platform === "win32",
+    }, async () => {
+        const home = await makeTmpDir();
+        const elsewhere = await makeTmpDir();
+        try {
+            await mkdir(registryDirPath(home), { recursive: true });
+            await writeFile(path.join(elsewhere, "registry.json"), "{}");
+            await symlink(path.join(elsewhere, "registry.json"), registryPath(home), "file");
+            const entry = await lookupDeployment(home, "/anything");
+            assert.equal(entry, null);
+        }
+        finally {
+            await rm(home, { recursive: true, force: true });
+            await rm(elsewhere, { recursive: true, force: true });
+        }
+    });
 });
 describe("verifyDeployment", () => {
     it("returns entry when all fields match", async () => {

package/dist/test/unit/preflight.test.js

@@ -124,6 +124,65 @@ describe("runPreflight", () => {
         const implementationOnlyWarning = warnings.find((w) => w.kind === "config-authority" && /implementation-only/.test(w.message));
         assert.equal(implementationOnlyWarning, undefined, `expected no implementation-only warning, got: ${implementationOnlyWarning?.message}`);
     });
+    it("emits shared-surface config-authority guidance when github-copilot agentRules ride through claude-code", async () => {
+        const manifest = {
+            ...emptyManifest,
+            agentRules: [
+                {
+                    name: "shared-rules",
+                    path: "CLAUDE.md",
+                    agents: ["claude-code", "github-copilot"],
+                    scope: "repo",
+                },
+            ],
+        };
+        const warnings = await runPreflight(baseOptions, manifest, "/home/test", [
+            "claude-code",
+            "github-copilot",
+        ]);
+        const warning = warnings.find((w) => w.kind === "config-authority" &&
+            w.message.includes('shared through "claude-code"'));
+        assert.ok(warning, `expected shared-surface warning, got: ${JSON.stringify(warnings)}`);
+        assert.match(warning.message, /requires the primary target to deploy/);
+    });
+    it("emits shared-surface config-authority guidance for antigravity repo rules", async () => {
+        const manifest = {
+            ...emptyManifest,
+            agentRules: [
+                {
+                    name: "gemini-rules",
+                    path: "GEMINI.md",
+                    agents: ["antigravity"],
+                    scope: "repo",
+                },
+            ],
+        };
+        const warnings = await runPreflight(baseOptions, manifest, "/home/test", [
+            "antigravity",
+        ]);
+        const warning = warnings.find((w) => w.kind === "config-authority" &&
+            w.message.includes('shared through "gemini-cli"'));
+        assert.ok(warning, `expected antigravity shared-via warning, got: ${JSON.stringify(warnings)}`);
+        assert.doesNotMatch(warning.message, /requires the primary target to deploy/);
+    });
+    it("emits provisional config-authority warning for supported gemini executionConfigs", async () => {
+        const manifest = {
+            ...emptyManifest,
+            executionConfigs: [
+                {
+                    name: "safe-mode",
+                    agents: ["gemini-cli"],
+                    config: { sandbox: "workspace-write" },
+                },
+            ],
+        };
+        const warnings = await runPreflight(baseOptions, manifest, "/home/test", [
+            "gemini-cli",
+        ]);
+        const capabilityWarning = warnings.find((w) => w.kind === "config-authority" && /execution-config/.test(w.message));
+        assert.ok(capabilityWarning, `expected executionConfig warning, got: ${JSON.stringify(warnings)}`);
+        assert.match(capabilityWarning.message, /provisional/);
+    });
 });
 describe("github-copilot devcontainer support", () => {
     it("emits no capability warning for devcontainer MCP when Copilot is detected and devcontainer scope is targeted", async () => {
@@ -279,6 +338,92 @@ describe("instruction precedence warnings", () => {
             await rm(sourceDir, { recursive: true });
         }
     });
+    it("emits Copilot precedence warning when github-copilot has both shared-via (scope: repo) and native (scope: copilot-repo) entries", async () => {
+        const sourceDir = await makeTmpDir();
+        try {
+            await writeFile(path.join(sourceDir, "shared.md"), "# Shared rules");
+            await writeFile(path.join(sourceDir, "native.md"), "# Native rules");
+            const manifest = {
+                ...emptyManifest,
+                agentRules: [
+                    {
+                        name: "shared-rules",
+                        path: "shared.md",
+                        agents: ["claude-code", "github-copilot"],
+                        scope: "repo",
+                    },
+                    {
+                        name: "native-rules",
+                        path: "native.md",
+                        agents: ["github-copilot"],
+                        scope: "copilot-repo",
+                    },
+                ],
+            };
+            const warnings = await runPreflight({ ...baseOptions, directory: sourceDir }, manifest, "/home/test", ["github-copilot"]);
+            const precedenceWarnings = warnings.filter((w) => w.kind === "precedence");
+            assert.ok(precedenceWarnings.length > 0, "expected a precedence warning");
+            assert.ok(precedenceWarnings.some((w) => w.message.includes("github-copilot") &&
+                w.message.includes("CLAUDE.md-shared") &&
+                w.message.includes("native Copilot")), `expected Copilot precedence warning, got: ${JSON.stringify(precedenceWarnings)}`);
+        }
+        finally {
+            await rm(sourceDir, { recursive: true });
+        }
+    });
+    it("emits Copilot precedence warning when github-copilot has both global (scope: global) and copilot-scoped entries", async () => {
+        const sourceDir = await makeTmpDir();
+        try {
+            await writeFile(path.join(sourceDir, "shared.md"), "# Shared rules");
+            await writeFile(path.join(sourceDir, "scoped.md"), "# Scoped rules");
+            const manifest = {
+                ...emptyManifest,
+                agentRules: [
+                    {
+                        name: "shared-rules",
+                        path: "shared.md",
+                        agents: ["claude-code", "github-copilot"],
+                        scope: "global",
+                    },
+                    {
+                        name: "typescript",
+                        path: "scoped.md",
+                        agents: ["github-copilot"],
+                        scope: "copilot-scoped",
+                    },
+                ],
+            };
+            const warnings = await runPreflight({ ...baseOptions, directory: sourceDir }, manifest, "/home/test", ["github-copilot"]);
+            const precedenceWarnings = warnings.filter((w) => w.kind === "precedence");
+            assert.ok(precedenceWarnings.some((w) => w.message.includes("github-copilot") &&
+                w.message.includes("native Copilot")), `expected Copilot precedence warning, got: ${JSON.stringify(precedenceWarnings)}`);
+        }
+        finally {
+            await rm(sourceDir, { recursive: true });
+        }
+    });
+    it("emits no Copilot precedence warning when github-copilot only has native entries", async () => {
+        const sourceDir = await makeTmpDir();
+        try {
+            await writeFile(path.join(sourceDir, "native.md"), "# Native rules");
+            const manifest = {
+                ...emptyManifest,
+                agentRules: [
+                    {
+                        name: "native-rules",
+                        path: "native.md",
+                        agents: ["github-copilot"],
+                        scope: "copilot-repo",
+                    },
+                ],
+            };
+            const warnings = await runPreflight({ ...baseOptions, directory: sourceDir }, manifest, "/home/test", ["github-copilot"]);
+            assert.equal(warnings.filter((w) => w.kind === "precedence").length, 0);
+        }
+        finally {
+            await rm(sourceDir, { recursive: true });
+        }
+    });
 });
 describe("instruction budget warnings", () => {
     it("emits budget warning for agentRules source file exceeding 50 KB", async () => {

package/dist/test/unit/resolve.test.js

@@ -4,7 +4,7 @@ import path from "node:path";
 import { describe, it } from "node:test";
 import { AGENT_REGISTRY } from "../../src/config/agents.js";
 import { resolveAgentDetectPath, resolveAgentSkillPath, resolveHome, } from "../../src/core/resolve.js";
-import { resolveTargetTemplate } from "../../src/core/runtime-paths.js";
+import { resolveRuntimePaths, resolveTargetTemplate, } from "../../src/core/runtime-paths.js";
 import { UserError } from "../../src/errors.js";
 const posixJoin = path.posix.join;
 function getAgent(id) {
@@ -113,7 +113,73 @@ describe("resolveTargetTemplate", () => {
         const result = resolveTargetTemplate("{home}/.claude/settings.json", home);
         assert.equal(result, `${home}/.claude/settings.json`);
     });
+    it("resolves appdata, local_appdata, xdg_config, repo, and workspace roots", () => {
+        const savedAppData = process.env.APPDATA;
+        const savedLocalAppData = process.env.LOCALAPPDATA;
+        const savedXdg = process.env.XDG_CONFIG_HOME;
+        try {
+            process.env.APPDATA = "/env/appdata";
+            process.env.LOCALAPPDATA = "/env/local";
+            process.env.XDG_CONFIG_HOME = "/env/xdg";
+            assert.equal(resolveTargetTemplate("{appdata}/opencode/opencode.json", "/home/user"), "/env/appdata/opencode/opencode.json");
+            assert.equal(resolveTargetTemplate("{local_appdata}/Temp/config.json", "/home/user"), "/env/local/Temp/config.json");
+            assert.equal(resolveTargetTemplate("{xdg_config}/opencode/config.json", "/home/user"), "/env/xdg/opencode/config.json");
+            assert.equal(resolveTargetTemplate("{repo}/.claude/mcp.json", "/home/user", "/repo"), "/repo/.claude/mcp.json");
+            assert.equal(resolveTargetTemplate("{workspace}/CLAUDE.md", "/home/user", "/repo"), "/repo/CLAUDE.md");
+            assert.equal(resolveTargetTemplate("{workspace}/CLAUDE.md", "/home/user", "/repo", "/workspace"), "/workspace/CLAUDE.md");
+            assert.equal(resolveTargetTemplate("{home}", "/home/user"), "/home/user");
+        }
+        finally {
+            if (savedAppData === undefined)
+                delete process.env.APPDATA;
+            else
+                process.env.APPDATA = savedAppData;
+            if (savedLocalAppData === undefined)
+                delete process.env.LOCALAPPDATA;
+            else
+                process.env.LOCALAPPDATA = savedLocalAppData;
+            if (savedXdg === undefined)
+                delete process.env.XDG_CONFIG_HOME;
+            else
+                process.env.XDG_CONFIG_HOME = savedXdg;
+        }
+    });
+    it("throws for invalid templates and missing repo or workspace roots", () => {
+        assert.throws(() => resolveTargetTemplate("relative/path.txt", "/home/user"), /Invalid target template/);
+        assert.throws(() => resolveTargetTemplate("{repo}/x", "/home/user"), /no repo directory was provided/);
+        assert.throws(() => resolveTargetTemplate("{workspace}/x", "/home/user"), /no workspace directory was provided/);
+    });
     it("throws when the template escapes the placeholder root", () => {
         assert.throws(() => resolveTargetTemplate("{home}/../.ssh/config", "/home/user"), /outside its placeholder root/);
     });
 });
+describe("resolveRuntimePaths", () => {
+    it("uses absolute env vars and ignores relative overrides", () => {
+        const savedAppData = process.env.APPDATA;
+        const savedLocalAppData = process.env.LOCALAPPDATA;
+        const savedXdg = process.env.XDG_CONFIG_HOME;
+        try {
+            process.env.APPDATA = "/custom/appdata";
+            process.env.LOCALAPPDATA = "relative/local";
+            process.env.XDG_CONFIG_HOME = "relative/xdg";
+            const paths = resolveRuntimePaths("/home/user");
+            assert.equal(paths.appdata, "/custom/appdata");
+            assert.equal(paths.localAppdata, "/home/user/AppData/Local");
+            assert.equal(paths.xdgConfig, "/home/user/.config");
+        }
+        finally {
+            if (savedAppData === undefined)
+                delete process.env.APPDATA;
+            else
+                process.env.APPDATA = savedAppData;
+            if (savedLocalAppData === undefined)
+                delete process.env.LOCALAPPDATA;
+            else
+                process.env.LOCALAPPDATA = savedLocalAppData;
+            if (savedXdg === undefined)
+                delete process.env.XDG_CONFIG_HOME;
+            else
+                process.env.XDG_CONFIG_HOME = savedXdg;
+        }
+    });
+});