@uluops/setup 0.2.0

package/dist/test/config-merger.test.js

@@ -0,0 +1,94 @@
+import { describe, it, expect } from "vitest";
+import { mergeUluopsMcp, removeUluopsMcp } from "../lib/config-merger.js";
+describe("mergeUluopsMcp", () => {
+    it("adds both MCP servers to empty config", () => {
+        const result = mergeUluopsMcp({}, "ulr_test123");
+        expect(result.mcpServers).toBeDefined();
+        expect(result.mcpServers["uluops-tracker"]).toMatchObject({
+            command: "npx",
+            args: ["-y", "uluops-tracker-mcp-client"],
+            env: {
+                ULUOPS_TRACKER_API_URL: "https://api.uluops.ai/api/v1",
+                ULUOPS_TRACKER_API_KEY: "ulr_test123",
+            },
+        });
+        expect(result.mcpServers["uluops-registry"]).toMatchObject({
+            command: "npx",
+            args: ["-y", "uluops-registry-mcp-client"],
+            env: {
+                ULUOPS_REGISTRY_URL: "https://api.uluops.ai/api/v1/registry",
+                ULUOPS_API_KEY: "ulr_test123",
+            },
+        });
+    });
+    it("preserves existing non-UluOps MCP servers", () => {
+        const config = {
+            mcpServers: {
+                "other-server": { command: "node", args: ["./other.js"], env: {} },
+            },
+        };
+        const result = mergeUluopsMcp(config, "ulr_abc");
+        expect(result.mcpServers["other-server"]).toBeDefined();
+        expect(result.mcpServers["uluops-tracker"]).toBeDefined();
+    });
+    it("preserves all top-level non-mcpServers keys", () => {
+        const config = {
+            numStartups: 42,
+            tipsHistory: ["tip1"],
+            mcpServers: {},
+        };
+        const result = mergeUluopsMcp(config, "ulr_abc");
+        expect(result.numStartups).toBe(42);
+        expect(result.tipsHistory).toEqual(["tip1"]);
+    });
+    it("overwrites existing UluOps servers with new API key", () => {
+        const config = {
+            mcpServers: {
+                "uluops-registry": {
+                    command: "npx",
+                    args: ["-y", "uluops-registry-mcp-client"],
+                    env: { ULUOPS_API_KEY: "ulr_old", ULUOPS_REGISTRY_URL: "https://api.uluops.ai/api/v1/registry" },
+                },
+            },
+        };
+        const result = mergeUluopsMcp(config, "ulr_new");
+        expect(result.mcpServers["uluops-registry"].env["ULUOPS_API_KEY"]).toBe("ulr_new");
+    });
+});
+describe("removeUluopsMcp", () => {
+    it("removes both UluOps servers", () => {
+        const config = {
+            mcpServers: {
+                "uluops-tracker": { command: "npx", args: [], env: {} },
+                "uluops-registry": { command: "npx", args: [], env: {} },
+            },
+        };
+        const result = removeUluopsMcp(config);
+        expect(result.mcpServers).toBeUndefined();
+    });
+    it("preserves non-UluOps servers when removing", () => {
+        const config = {
+            mcpServers: {
+                "uluops-tracker": { command: "npx", args: [], env: {} },
+                "other-server": { command: "node", args: [], env: {} },
+            },
+        };
+        const result = removeUluopsMcp(config);
+        expect(result.mcpServers["other-server"]).toBeDefined();
+        expect(result.mcpServers["uluops-tracker"]).toBeUndefined();
+    });
+    it("preserves top-level keys other than mcpServers", () => {
+        const config = {
+            numStartups: 5,
+            mcpServers: {
+                "uluops-tracker": { command: "npx", args: [], env: {} },
+            },
+        };
+        const result = removeUluopsMcp(config);
+        expect(result.numStartups).toBe(5);
+    });
+    it("handles config with no mcpServers key", () => {
+        const result = removeUluopsMcp({ numStartups: 1 });
+        expect(result.mcpServers).toBeUndefined();
+    });
+});

package/dist/test/detect.test.d.ts

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

package/dist/test/detect.test.js

@@ -0,0 +1,25 @@
+import { describe, it, expect } from "vitest";
+import { detect } from "../steps/detect.js";
+describe("detect", () => {
+    it("returns a valid Environment object", async () => {
+        const env = await detect();
+        expect(env).toHaveProperty("os");
+        expect(env).toHaveProperty("isWsl");
+        expect(env).toHaveProperty("shell");
+        expect(env).toHaveProperty("shellProfile");
+        expect(env).toHaveProperty("nodeVersion");
+        expect(env).toHaveProperty("claudeHomeExists");
+    });
+    it("nodeVersion matches process.version", async () => {
+        const env = await detect();
+        expect(env.nodeVersion).toBe(process.version);
+    });
+    it("os is one of the supported platforms", async () => {
+        const env = await detect();
+        expect(["linux", "darwin", "win32"]).toContain(env.os);
+    });
+    it("claudeHomeExists is a boolean", async () => {
+        const env = await detect();
+        expect(typeof env.claudeHomeExists).toBe("boolean");
+    });
+});

package/dist/test/file-ops.test.d.ts

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

package/dist/test/file-ops.test.js

@@ -0,0 +1,100 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { writeFile, readFile, mkdir, mkdtemp, readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { copyIfChanged, unlinkFiles, syncAssets } from "../lib/file-ops.js";
+let tmpDir;
+let srcDir;
+let destDir;
+beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), "uluops-fileops-"));
+    srcDir = join(tmpDir, "src");
+    destDir = join(tmpDir, "dest");
+    await mkdir(srcDir, { recursive: true });
+    await mkdir(destDir, { recursive: true });
+});
+describe("copyIfChanged", () => {
+    it("copies file when destination does not exist", async () => {
+        await writeFile(join(srcDir, "a.md"), "content A");
+        const result = await copyIfChanged(join(srcDir, "a.md"), join(destDir, "a.md"), false);
+        expect(result).toBe("copied");
+        expect(await readFile(join(destDir, "a.md"), "utf-8")).toBe("content A");
+    });
+    it("skips file when content is identical", async () => {
+        await writeFile(join(srcDir, "a.md"), "same");
+        await writeFile(join(destDir, "a.md"), "same");
+        const result = await copyIfChanged(join(srcDir, "a.md"), join(destDir, "a.md"), false);
+        expect(result).toBe("skipped");
+    });
+    it("copies file when content differs", async () => {
+        await writeFile(join(srcDir, "a.md"), "new content");
+        await writeFile(join(destDir, "a.md"), "old content");
+        const result = await copyIfChanged(join(srcDir, "a.md"), join(destDir, "a.md"), false);
+        expect(result).toBe("copied");
+        expect(await readFile(join(destDir, "a.md"), "utf-8")).toBe("new content");
+    });
+    it("does not write in dry-run mode", async () => {
+        await writeFile(join(srcDir, "a.md"), "content");
+        const result = await copyIfChanged(join(srcDir, "a.md"), join(destDir, "a.md"), true);
+        expect(result).toBe("copied");
+        // File should NOT exist
+        const files = await readdir(destDir);
+        expect(files).not.toContain("a.md");
+    });
+});
+describe("unlinkFiles", () => {
+    it("removes listed files and returns count", async () => {
+        await writeFile(join(destDir, "a.md"), "a");
+        await writeFile(join(destDir, "b.md"), "b");
+        const removed = await unlinkFiles(destDir, ["a.md", "b.md"]);
+        expect(removed).toBe(2);
+        expect(await readdir(destDir)).toEqual([]);
+    });
+    it("returns 0 for already-missing files", async () => {
+        const removed = await unlinkFiles(destDir, ["nonexistent.md"]);
+        expect(removed).toBe(0);
+    });
+});
+describe("syncAssets", () => {
+    it("copies all .md files from source to destination", async () => {
+        await writeFile(join(srcDir, "one.md"), "one");
+        await writeFile(join(srcDir, "two.md"), "two");
+        await writeFile(join(srcDir, "skip.txt"), "not md");
+        const result = await syncAssets({ srcDir, destDir, dryRun: false });
+        expect(result.copied).toBe(2);
+        expect(result.files).toContain("one.md");
+        expect(result.files).toContain("two.md");
+        expect(result.files).not.toContain("skip.txt");
+    });
+    it("skips unchanged files on second run", async () => {
+        await writeFile(join(srcDir, "one.md"), "content");
+        await syncAssets({ srcDir, destDir, dryRun: false });
+        const result = await syncAssets({ srcDir, destDir, dryRun: false });
+        expect(result.copied).toBe(0);
+        expect(result.skipped).toBe(1);
+    });
+    it("removes old manifest files no longer in source", async () => {
+        await writeFile(join(srcDir, "keep.md"), "keep");
+        await writeFile(join(destDir, "removed.md"), "old");
+        const result = await syncAssets({
+            srcDir,
+            destDir,
+            dryRun: false,
+            oldManifestFiles: ["keep.md", "removed.md"],
+        });
+        expect(result.removed).toBe(1);
+        expect(await readdir(destDir)).toContain("keep.md");
+        expect(await readdir(destDir)).not.toContain("removed.md");
+    });
+    it("creates destination directory if missing", async () => {
+        const newDest = join(tmpDir, "newdir");
+        await writeFile(join(srcDir, "a.md"), "a");
+        const result = await syncAssets({
+            srcDir,
+            destDir: newDest,
+            dryRun: false,
+        });
+        expect(result.copied).toBe(1);
+        expect(await readdir(newDest)).toContain("a.md");
+    });
+});

package/dist/test/hash.test.d.ts

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

package/dist/test/hash.test.js

@@ -0,0 +1,14 @@
+import { describe, it, expect } from "vitest";
+import { fileHash } from "../lib/hash.js";
+describe("fileHash", () => {
+    it("returns a 12-character hex string", () => {
+        const hash = fileHash("hello world");
+        expect(hash).toMatch(/^[0-9a-f]{12}$/);
+    });
+    it("returns same hash for same content", () => {
+        expect(fileHash("test")).toBe(fileHash("test"));
+    });
+    it("returns different hash for different content", () => {
+        expect(fileHash("a")).not.toBe(fileHash("b"));
+    });
+});

package/dist/test/manifest.test.d.ts

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

package/dist/test/manifest.test.js

@@ -0,0 +1,78 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { writeFile, unlink, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+// We need to control the manifest path, so we mock paths.js
+const tmpDir = join(tmpdir(), "uluops-manifest-test-" + Date.now());
+const manifestPath = join(tmpDir, "uluops-manifest.json");
+vi.mock("../lib/paths.js", async (importOriginal) => {
+    const original = await importOriginal();
+    return {
+        ...original,
+        getManifestPath: () => manifestPath,
+    };
+});
+// Import after mock is set up
+const { loadManifest, saveManifest, deleteManifest } = await import("../lib/manifest.js");
+const sampleManifest = {
+    version: "0.1.0",
+    installedAt: "2026-03-08T00:00:00.000Z",
+    mcpScope: "global",
+    mcpConfigPath: "/home/user/.claude.json",
+    defsScope: "global",
+    defsPath: "/home/user/.claude",
+    shellModified: false,
+    agents: ["code-validator-agent.md"],
+    commands: ["agents/validate.md"],
+};
+beforeEach(async () => {
+    await mkdir(tmpDir, { recursive: true });
+});
+afterEach(async () => {
+    try {
+        await unlink(manifestPath);
+    }
+    catch {
+        // may not exist
+    }
+});
+describe("loadManifest", () => {
+    it("returns null when manifest does not exist", async () => {
+        const result = await loadManifest();
+        expect(result).toBeNull();
+    });
+    it("returns parsed manifest when file exists", async () => {
+        await writeFile(manifestPath, JSON.stringify(sampleManifest, null, 2));
+        const result = await loadManifest();
+        expect(result).toEqual(sampleManifest);
+    });
+    it("returns null on malformed JSON", async () => {
+        await writeFile(manifestPath, "{ invalid json }");
+        const result = await loadManifest();
+        expect(result).toBeNull();
+    });
+});
+describe("saveManifest", () => {
+    it("writes manifest as formatted JSON", async () => {
+        await saveManifest(sampleManifest);
+        const raw = await import("node:fs/promises").then((fs) => fs.readFile(manifestPath, "utf-8"));
+        const parsed = JSON.parse(raw);
+        expect(parsed).toEqual(sampleManifest);
+    });
+    it("round-trips correctly through save and load", async () => {
+        await saveManifest(sampleManifest);
+        const loaded = await loadManifest();
+        expect(loaded).toEqual(sampleManifest);
+    });
+});
+describe("deleteManifest", () => {
+    it("deletes existing manifest", async () => {
+        await writeFile(manifestPath, JSON.stringify(sampleManifest));
+        await deleteManifest();
+        const result = await loadManifest();
+        expect(result).toBeNull();
+    });
+    it("does not throw if manifest does not exist", async () => {
+        await expect(deleteManifest()).resolves.toBeUndefined();
+    });
+});

package/dist/test/paths.test.d.ts

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

package/dist/test/paths.test.js

@@ -0,0 +1,30 @@
+import { describe, it, expect } from "vitest";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { getClaudeHome, getClaudeJsonPath, getLocalMcpPath, getManifestPath, getAgentsDir, getCommandsDir, } from "../lib/paths.js";
+describe("path resolution", () => {
+    it("getClaudeHome returns ~/.claude", () => {
+        expect(getClaudeHome()).toBe(join(homedir(), ".claude"));
+    });
+    it("getClaudeJsonPath returns ~/.claude.json", () => {
+        expect(getClaudeJsonPath()).toBe(join(homedir(), ".claude.json"));
+    });
+    it("getLocalMcpPath returns .mcp.json in cwd", () => {
+        expect(getLocalMcpPath()).toBe(join(process.cwd(), ".mcp.json"));
+    });
+    it("getManifestPath returns ~/.claude/uluops-manifest.json", () => {
+        expect(getManifestPath()).toBe(join(homedir(), ".claude", "uluops-manifest.json"));
+    });
+    it("getAgentsDir returns ~/.claude/agents when not local", () => {
+        expect(getAgentsDir(false)).toBe(join(homedir(), ".claude", "agents"));
+    });
+    it("getAgentsDir returns ./uluops/agents when local", () => {
+        expect(getAgentsDir(true)).toBe(join(process.cwd(), "uluops", "agents"));
+    });
+    it("getCommandsDir returns ~/.claude/commands when not local", () => {
+        expect(getCommandsDir(false)).toBe(join(homedir(), ".claude", "commands"));
+    });
+    it("getCommandsDir returns ./uluops/commands when local", () => {
+        expect(getCommandsDir(true)).toBe(join(process.cwd(), "uluops", "commands"));
+    });
+});

package/dist/test/settings-merger.test.d.ts

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

package/dist/test/settings-merger.test.js

@@ -0,0 +1,167 @@
+import { describe, it, expect } from "vitest";
+import { mergeUluopsHook, removeUluopsHook, hasUluopsHook, } from "../lib/settings-merger.js";
+describe("settings-merger", () => {
+    describe("mergeUluopsHook", () => {
+        it("should add hook to empty settings", () => {
+            const result = mergeUluopsHook({}, "node ~/.claude/tools/agent-metrics/dist/hook.js");
+            expect(result.hooks).toBeDefined();
+            expect(result.hooks["SubagentStop"]).toHaveLength(1);
+            expect(result.hooks["SubagentStop"][0].hooks[0].command).toContain("tools/agent-metrics");
+            expect(result.hooks["SubagentStop"][0].hooks[0].timeout).toBe(30);
+        });
+        it("should preserve existing permissions", () => {
+            const settings = {
+                permissions: { allow: ["Bash(curl:*)"] },
+            };
+            const result = mergeUluopsHook(settings, "node ~/.claude/tools/agent-metrics/dist/hook.js");
+            expect(result.permissions).toEqual({ allow: ["Bash(curl:*)"] });
+            expect(result.hooks["SubagentStop"]).toHaveLength(1);
+        });
+        it("should preserve non-UluOps hooks", () => {
+            const settings = {
+                hooks: {
+                    SubagentStop: [
+                        {
+                            hooks: [
+                                { type: "command", command: "echo custom-hook" },
+                            ],
+                        },
+                    ],
+                },
+            };
+            const result = mergeUluopsHook(settings, "node ~/.claude/tools/agent-metrics/dist/hook.js");
+            // Should have both: custom + UluOps
+            expect(result.hooks["SubagentStop"]).toHaveLength(2);
+            expect(result.hooks["SubagentStop"][0].hooks[0].command).toBe("echo custom-hook");
+            expect(result.hooks["SubagentStop"][1].hooks[0].command).toContain("tools/agent-metrics");
+        });
+        it("should replace existing UluOps hook on re-run", () => {
+            const settings = {
+                hooks: {
+                    SubagentStop: [
+                        {
+                            hooks: [
+                                {
+                                    type: "command",
+                                    command: "node /old/path/tools/agent-metrics/dist/hook.js",
+                                },
+                            ],
+                        },
+                    ],
+                },
+            };
+            const result = mergeUluopsHook(settings, "node ~/.claude/tools/agent-metrics/dist/hook.js");
+            // Should replace, not duplicate
+            expect(result.hooks["SubagentStop"]).toHaveLength(1);
+            expect(result.hooks["SubagentStop"][0].hooks[0].command).toContain("~/.claude/tools/agent-metrics");
+        });
+        it("should preserve other hook event types", () => {
+            const settings = {
+                hooks: {
+                    PreToolUse: [{ hooks: [{ type: "command", command: "echo pre" }] }],
+                },
+            };
+            const result = mergeUluopsHook(settings, "node ~/.claude/tools/agent-metrics/dist/hook.js");
+            expect(result.hooks["PreToolUse"]).toHaveLength(1);
+            expect(result.hooks["SubagentStop"]).toHaveLength(1);
+        });
+    });
+    describe("removeUluopsHook", () => {
+        it("should remove UluOps hook and preserve permissions", () => {
+            const settings = {
+                permissions: { allow: ["Bash(curl:*)"] },
+                hooks: {
+                    SubagentStop: [
+                        {
+                            hooks: [
+                                {
+                                    type: "command",
+                                    command: "node ~/.claude/tools/agent-metrics/dist/hook.js",
+                                    timeout: 30,
+                                },
+                            ],
+                        },
+                    ],
+                },
+            };
+            const result = removeUluopsHook(settings);
+            expect(result.permissions).toEqual({ allow: ["Bash(curl:*)"] });
+            expect(result.hooks).toBeUndefined();
+        });
+        it("should preserve non-UluOps hooks", () => {
+            const settings = {
+                hooks: {
+                    SubagentStop: [
+                        { hooks: [{ type: "command", command: "echo custom" }] },
+                        {
+                            hooks: [
+                                {
+                                    type: "command",
+                                    command: "node ~/.claude/tools/agent-metrics/dist/hook.js",
+                                },
+                            ],
+                        },
+                    ],
+                },
+            };
+            const result = removeUluopsHook(settings);
+            expect(result.hooks["SubagentStop"]).toHaveLength(1);
+            expect(result.hooks["SubagentStop"][0].hooks[0].command).toBe("echo custom");
+        });
+        it("should handle settings with no hooks", () => {
+            const settings = { permissions: { allow: [] } };
+            const result = removeUluopsHook(settings);
+            expect(result).toEqual({ permissions: { allow: [] } });
+        });
+        it("should clean up empty hooks object", () => {
+            const settings = {
+                hooks: {
+                    SubagentStop: [
+                        {
+                            hooks: [
+                                {
+                                    type: "command",
+                                    command: "node /some/tools/agent-metrics/hook.js",
+                                },
+                            ],
+                        },
+                    ],
+                },
+            };
+            const result = removeUluopsHook(settings);
+            expect(result.hooks).toBeUndefined();
+        });
+    });
+    describe("hasUluopsHook", () => {
+        it("should return true when UluOps hook is present", () => {
+            const settings = {
+                hooks: {
+                    SubagentStop: [
+                        {
+                            hooks: [
+                                {
+                                    type: "command",
+                                    command: "node ~/.claude/tools/agent-metrics/dist/hook.js",
+                                },
+                            ],
+                        },
+                    ],
+                },
+            };
+            expect(hasUluopsHook(settings)).toBe(true);
+        });
+        it("should return false when no hooks exist", () => {
+            expect(hasUluopsHook({})).toBe(false);
+        });
+        it("should return false when only non-UluOps hooks exist", () => {
+            const settings = {
+                hooks: {
+                    SubagentStop: [
+                        { hooks: [{ type: "command", command: "echo custom" }] },
+                    ],
+                },
+            };
+            expect(hasUluopsHook(settings)).toBe(false);
+        });
+    });
+});

package/dist/test/shell-profile.test.d.ts

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

package/dist/test/shell-profile.test.js

@@ -0,0 +1,40 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { getShellProfile } from "../lib/paths.js";
+afterEach(() => {
+    vi.unstubAllEnvs();
+});
+describe("getShellProfile", () => {
+    it("returns .zshrc for zsh shell", () => {
+        vi.stubEnv("SHELL", "/bin/zsh");
+        const result = getShellProfile();
+        expect(result).not.toBeNull();
+        expect(result.shell).toBe("zsh");
+        expect(result.path).toMatch(/\.zshrc$/);
+    });
+    it("returns .bashrc for bash on linux", () => {
+        vi.stubEnv("SHELL", "/bin/bash");
+        // getShellProfile checks platform() — on linux it returns .bashrc
+        const result = getShellProfile();
+        expect(result).not.toBeNull();
+        expect(result.shell).toBe("bash");
+        // On linux: .bashrc, on darwin: .bash_profile
+        expect(result.path).toMatch(/\.bash(rc|_profile)$/);
+    });
+    it("returns config.fish for fish shell", () => {
+        vi.stubEnv("SHELL", "/usr/bin/fish");
+        const result = getShellProfile();
+        expect(result).not.toBeNull();
+        expect(result.shell).toBe("fish");
+        expect(result.path).toMatch(/config\.fish$/);
+    });
+    it("returns null for unknown shell", () => {
+        vi.stubEnv("SHELL", "/bin/csh");
+        const result = getShellProfile();
+        expect(result).toBeNull();
+    });
+    it("returns null when SHELL is empty", () => {
+        vi.stubEnv("SHELL", "");
+        const result = getShellProfile();
+        expect(result).toBeNull();
+    });
+});

package/dist/test/shell.test.d.ts

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

package/dist/test/shell.test.js

@@ -0,0 +1,71 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { writeFile, readFile, unlink, mkdtemp } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { writeShellExport, removeShellExport } from "../steps/shell.js";
+let tmpDir;
+let profilePath;
+beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), "uluops-test-"));
+    profilePath = join(tmpDir, ".bashrc");
+});
+afterEach(async () => {
+    try {
+        await unlink(profilePath);
+    }
+    catch {
+        // may not exist
+    }
+});
+describe("writeShellExport", () => {
+    it("creates profile with fenced block if file does not exist", async () => {
+        await writeShellExport(profilePath, "ulr_abc123", false);
+        const content = await readFile(profilePath, "utf-8");
+        expect(content).toContain("# --- UluOps (managed by @uluops/setup) ---");
+        expect(content).toContain('export ULUOPS_API_KEY="ulr_abc123"');
+        expect(content).toContain("# --- /UluOps ---");
+    });
+    it("appends fenced block to existing file", async () => {
+        await writeFile(profilePath, "# existing content\n");
+        await writeShellExport(profilePath, "ulr_abc123", false);
+        const content = await readFile(profilePath, "utf-8");
+        expect(content).toContain("# existing content");
+        expect(content).toContain('export ULUOPS_API_KEY="ulr_abc123"');
+    });
+    it("replaces existing fenced block on re-run", async () => {
+        await writeShellExport(profilePath, "ulr_old", false);
+        await writeShellExport(profilePath, "ulr_new", false);
+        const content = await readFile(profilePath, "utf-8");
+        expect(content).toContain('export ULUOPS_API_KEY="ulr_new"');
+        expect(content).not.toContain("ulr_old");
+        // Only one fenced block should exist
+        expect(content.split("# --- UluOps").length).toBe(2);
+    });
+    it("does not modify files in dry-run mode", async () => {
+        await writeFile(profilePath, "# existing\n");
+        await writeShellExport(profilePath, "ulr_abc123", true);
+        const content = await readFile(profilePath, "utf-8");
+        expect(content).toBe("# existing\n");
+    });
+});
+describe("removeShellExport", () => {
+    it("removes the fenced block from the file", async () => {
+        const initial = "# before\n\n# --- UluOps (managed by @uluops/setup) ---\nexport ULUOPS_API_KEY=\"ulr_abc\"\n# --- /UluOps ---\n\n# after\n";
+        await writeFile(profilePath, initial);
+        await removeShellExport(profilePath);
+        const content = await readFile(profilePath, "utf-8");
+        expect(content).toContain("# before");
+        expect(content).toContain("# after");
+        expect(content).not.toContain("ULUOPS_API_KEY");
+        expect(content).not.toContain("UluOps");
+    });
+    it("does nothing if no fenced block exists", async () => {
+        await writeFile(profilePath, "# no uluops here\n");
+        await removeShellExport(profilePath);
+        const content = await readFile(profilePath, "utf-8");
+        expect(content).toBe("# no uluops here\n");
+    });
+    it("does nothing if file does not exist", async () => {
+        await expect(removeShellExport(join(tmpDir, "nonexistent"))).resolves.toBeUndefined();
+    });
+});

package/dist/test/signup.test.d.ts

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