@moltzap/client 2026.511.1 → 2026.518.0

package/dist/cli/profile.test.js

@@ -1,263 +1,369 @@
 /**
- * Unit tests for the profile layer. Spec items §5.2 (`--profile`,
- * `--no-persist`), Invariants §4.3 (coexistence), §4.4 (no-disk-write).
+ * Unit tests for the profile layer. Spec items Section 5.2 (`--profile`,
+ * `--no-persist`), Invariants 4.3 (coexistence), 4.4 (no-disk-write).
  */
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as os from "node:os";
-import { Effect } from "effect";
-import { describe, expect, it } from "vitest";
+import { FileSystem, Path } from "@effect/platform";
+import { NodeContext } from "@effect/platform-node";
+import { it as effectIt } from "@effect/vitest";
+import { Effect, Exit, Schema } from "effect";
+import * as fc from "fast-check";
+import { afterEach, beforeEach, describe, expect, vi } from "vitest";
 import { emitNoPersist, loadLayeredConfig, parseProfileName, ProfileInvalidNameError, ProfileNotFoundError, resolveProfileAuth, writeProfile, } from "./profile.js";
-/**
- * Helper: create a temp dir, point MOLTZAP_CONFIG_HOME at it for the
- * duration of a test, seed with optional JSON, run fn, clean up.
- */
-const withTmpConfigHome = async (seed, fn) => {
-    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "moltzap-profile-"));
-    const originalHome = process.env.MOLTZAP_CONFIG_HOME;
-    process.env.MOLTZAP_CONFIG_HOME = tmp;
-    try {
-        if (seed !== undefined) {
-            fs.writeFileSync(path.join(tmp, "config.json"), JSON.stringify(seed, null, 2));
-        }
-        return await fn(tmp);
-    }
-    finally {
-        if (originalHome === undefined) {
-            delete process.env.MOLTZAP_CONFIG_HOME;
-        }
-        else {
-            process.env.MOLTZAP_CONFIG_HOME = originalHome;
-        }
-        fs.rmSync(tmp, { recursive: true, force: true });
-    }
-};
-describe("parseProfileName", () => {
-    it("accepts a valid lowercase-alphanumeric name", async () => {
-        const name = await Effect.runPromise(parseProfileName("alice-bot"));
-        expect(name).toBe("alice-bot");
+const it = effectIt.scoped;
+const CONFIG_FILE_NAME = "config.json";
+const CONFIG_HOME_PREFIX = "moltzap-profile-";
+const UTF8 = "utf-8";
+const EMPTY_PROFILE_COUNT = 0;
+const SINGLE_PROFILE_COUNT = 1;
+const VALID_PROFILE_NAME = "alice-bot";
+const ALICE_PROFILE_NAME = "alice";
+const BOB_PROFILE_NAME = "bob";
+const UNKNOWN_PROFILE_NAME = "nobody";
+const GHOST_PROFILE_NAME = "ghost";
+const DEFAULT_PROFILE_NAME = "default";
+const TEST_SERVER_URL = "wss://x";
+const DEFAULT_AGENT_NAME = "a";
+const LEGACY_AGENT_NAME = "legacy";
+const ALICE_AGENT_NAME = "alice";
+const BOB_AGENT_NAME = "bob";
+const DEFAULT_API_KEY = "k";
+const LEGACY_API_KEY = "legacy-key";
+const ALICE_API_KEY = "k-alice";
+const BOB_API_KEY = "k-bob";
+const BAD_PROFILE_NAME = "Bad";
+const BAD_PROFILE_REASON = "upper";
+const INVALID_JSON_TEXT = "{not json}";
+const PROFILE_INVALID_NAME_ERROR = "ProfileInvalidNameError";
+const PROFILE_CONFIG_READ_ERROR = "ProfileConfigReadError";
+const PROFILE_NOT_FOUND_ERROR = "ProfileNotFoundError";
+const WrittenProfileRecordSchema = Schema.Struct({
+    apiKey: Schema.String,
+    agentName: Schema.String,
+    serverUrl: Schema.String,
+    registeredAt: Schema.optional(Schema.String),
+});
+const WrittenConfigSchema = Schema.Struct({
+    apiKey: Schema.optional(Schema.String),
+    profiles: Schema.optional(Schema.Record({
+        key: Schema.String,
+        value: WrittenProfileRecordSchema,
+    })),
+});
+const decodeWrittenConfig = Schema.decodeUnknown(WrittenConfigSchema);
+const profileNameArbitrary = fc.stringMatching(/^[a-z0-9][a-z0-9-]{1,30}[a-z0-9]$/);
+beforeEach(() => {
+    vi.unstubAllEnvs();
+});
+afterEach(() => {
+    vi.unstubAllEnvs();
+});
+const withNodeContext = (effect) => effect.pipe(Effect.provide(NodeContext.layer));
+const defaultRecord = (apiKey = DEFAULT_API_KEY) => ({
+    apiKey,
+    agentName: DEFAULT_AGENT_NAME,
+    serverUrl: TEST_SERVER_URL,
+});
+const namedRecord = (apiKey, agentName) => ({
+    apiKey,
+    agentName,
+    serverUrl: TEST_SERVER_URL,
+});
+const legacyConfig = (apiKey = DEFAULT_API_KEY) => ({
+    serverUrl: TEST_SERVER_URL,
+    apiKey,
+    agentName: DEFAULT_AGENT_NAME,
+});
+const namedProfilesConfig = () => ({
+    serverUrl: TEST_SERVER_URL,
+    profiles: {
+        [ALICE_PROFILE_NAME]: namedRecord(ALICE_API_KEY, ALICE_AGENT_NAME),
+    },
+});
+const makeConfigHome = Effect.gen(function* () {
+    const fileSystem = yield* FileSystem.FileSystem;
+    const configHome = yield* fileSystem.makeTempDirectoryScoped({
+        prefix: CONFIG_HOME_PREFIX,
     });
-    it("rejects an empty string with ProfileInvalidNameError", async () => {
-        const exit = await Effect.runPromiseExit(parseProfileName(""));
-        expect(exit._tag).toBe("Failure");
+    vi.stubEnv("MOLTZAP_CONFIG_HOME", configHome);
+    return configHome;
+});
+const writeConfigText = (text) => Effect.gen(function* () {
+    const fileSystem = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const configHome = yield* makeConfigHome;
+    yield* fileSystem.writeFileString(path.join(configHome, CONFIG_FILE_NAME), text);
+    return configHome;
+});
+const writeConfigObject = (config) => writeConfigText(JSON.stringify(config));
+const readConfigObject = (configHome) => Effect.gen(function* () {
+    const fileSystem = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const text = yield* fileSystem.readFileString(path.join(configHome, CONFIG_FILE_NAME), UTF8);
+    const parsed = yield* Effect.try({
+        try: () => JSON.parse(text),
+        catch: (error) => error,
     });
-    it("rejects a name with uppercase letters", async () => {
-        const exit = await Effect.runPromiseExit(parseProfileName("Alice"));
-        expect(exit._tag).toBe("Failure");
+    return yield* decodeWrittenConfig(parsed);
+});
+const expectProfiles = (profiles) => {
+    expect(profiles).toBeDefined();
+    return profiles ?? {};
+};
+const expectFailure = (exit) => {
+    expect(Exit.isFailure(exit)).toBe(true);
+};
+const expectFailureContaining = (exit, marker) => {
+    expectFailure(exit);
+    expect(String(exit)).toContain(marker);
+};
+function expectGeneratedProfileNameParses(raw) {
+    const exit = Effect.runSyncExit(parseProfileName(raw));
+    expect(Exit.isSuccess(exit)).toBe(true);
+    if (Exit.isSuccess(exit)) {
+        expect(exit.value).toBe(raw);
+    }
+}
+function parsesLowercaseAlphanumericName() {
+    return Effect.gen(function* () {
+        const name = yield* parseProfileName(VALID_PROFILE_NAME);
+        expect(name).toBe(VALID_PROFILE_NAME);
     });
-    it("rejects a name starting with a hyphen", async () => {
-        const exit = await Effect.runPromiseExit(parseProfileName("-alice"));
-        expect(exit._tag).toBe("Failure");
+}
+function generatedValidProfileNamesParse() {
+    return Effect.sync(() => {
+        fc.assert(fc.property(profileNameArbitrary, expectGeneratedProfileNameParses));
     });
-    it("rejects a name ending with a hyphen", async () => {
-        const exit = await Effect.runPromiseExit(parseProfileName("alice-"));
-        expect(exit._tag).toBe("Failure");
+}
+function rejectsEmptyName() {
+    return Effect.gen(function* () {
+        const exit = yield* Effect.exit(parseProfileName(""));
+        expectFailure(exit);
     });
-    it("fails with ProfileInvalidNameError type", async () => {
-        const exit = await Effect.runPromiseExit(parseProfileName(""));
-        if (exit._tag === "Failure") {
-            const s = JSON.stringify(exit.cause);
-            expect(s).toMatch(/ProfileInvalidNameError/);
-        }
+}
+function rejectsUppercaseName() {
+    return Effect.gen(function* () {
+        const exit = yield* Effect.exit(parseProfileName(BAD_PROFILE_NAME));
+        expectFailure(exit);
     });
-});
-describe("loadLayeredConfig", () => {
-    it("missing file resolves with empty view (default undefined, empty profiles)", async () => {
-        await withTmpConfigHome(undefined, async () => {
-            const view = await Effect.runPromise(loadLayeredConfig);
-            expect(view.default).toBeUndefined();
-            expect(view.profiles.size).toBe(0);
-        });
+}
+function rejectsLeadingHyphen() {
+    return Effect.gen(function* () {
+        const exit = yield* Effect.exit(parseProfileName("-alice"));
+        expectFailure(exit);
     });
-    it("legacy top-level { apiKey, agentName } populates default", async () => {
-        await withTmpConfigHome({
-            serverUrl: "wss://x",
-            apiKey: "k1",
-            agentName: "a1",
-        }, async () => {
-            const view = await Effect.runPromise(loadLayeredConfig);
-            expect(view.default?.apiKey).toBe("k1");
-            expect(view.default?.agentName).toBe("a1");
-            expect(view.serverUrl).toBe("wss://x");
-        });
+}
+function rejectsTrailingHyphen() {
+    return Effect.gen(function* () {
+        const exit = yield* Effect.exit(parseProfileName("alice-"));
+        expectFailure(exit);
     });
-    it("{ profiles: { alice: ... } } populates the profiles map", async () => {
-        await withTmpConfigHome({
-            serverUrl: "wss://x",
-            profiles: {
-                alice: {
-                    apiKey: "k-alice",
-                    agentName: "alice",
-                    serverUrl: "wss://x",
-                },
-            },
-        }, async () => {
-            const view = await Effect.runPromise(loadLayeredConfig);
-            expect(view.profiles.size).toBe(1);
-            const rec = view.profiles.get("alice");
-            expect(rec?.apiKey).toBe("k-alice");
-        });
+}
+function invalidNameErrorTypeSurfaces() {
+    return Effect.gen(function* () {
+        const exit = yield* Effect.exit(parseProfileName(""));
+        expectFailureContaining(exit, PROFILE_INVALID_NAME_ERROR);
     });
-    it("tolerates unknown top-level keys", async () => {
-        await withTmpConfigHome({
-            serverUrl: "wss://x",
-            apiKey: "k",
-            agentName: "a",
-            // future-experimental key; should not cause a parse failure.
+}
+function missingFileLoadsEmptyView() {
+    return withNodeContext(Effect.gen(function* () {
+        yield* makeConfigHome;
+        const view = yield* loadLayeredConfig;
+        expect(view.default).toBeUndefined();
+        expect(view.profiles.size).toBe(EMPTY_PROFILE_COUNT);
+    }));
+}
+function malformedConfigFails() {
+    return withNodeContext(Effect.gen(function* () {
+        yield* writeConfigText(INVALID_JSON_TEXT);
+        const exit = yield* Effect.exit(loadLayeredConfig);
+        expectFailureContaining(exit, PROFILE_CONFIG_READ_ERROR);
+    }));
+}
+function legacyConfigPopulatesDefaultRecord() {
+    return withNodeContext(Effect.gen(function* () {
+        yield* writeConfigObject(legacyConfig());
+        const view = yield* loadLayeredConfig;
+        const record = view.default;
+        expect(record).toBeDefined();
+        if (record !== undefined) {
+            expect(record.apiKey).toBe(DEFAULT_API_KEY);
+            expect(record.agentName).toBe(DEFAULT_AGENT_NAME);
+        }
+        expect(view.serverUrl).toBe(TEST_SERVER_URL);
+    }));
+}
+function unknownTopLevelKeysAreTolerated() {
+    return withNodeContext(Effect.gen(function* () {
+        yield* writeConfigObject({
+            ...legacyConfig(),
             futureExperimentalField: { nested: true },
-        }, async () => {
-            const view = await Effect.runPromise(loadLayeredConfig);
-            expect(view.default?.apiKey).toBe("k");
         });
-    });
-    it("missing registeredAt on legacy-shaped profile still decodes", async () => {
-        await withTmpConfigHome({
-            serverUrl: "wss://x",
+        const view = yield* loadLayeredConfig;
+        const record = view.default;
+        expect(record).toBeDefined();
+        if (record !== undefined) {
+            expect(record.apiKey).toBe(DEFAULT_API_KEY);
+        }
+    }));
+}
+function namedProfilesPopulateMap() {
+    return withNodeContext(Effect.gen(function* () {
+        yield* writeConfigObject(namedProfilesConfig());
+        const view = yield* loadLayeredConfig;
+        expect(view.profiles.size).toBe(SINGLE_PROFILE_COUNT);
+        const record = view.profiles.get(ALICE_PROFILE_NAME);
+        expect(record).toBeDefined();
+        if (record !== undefined) {
+            expect(record.apiKey).toBe(ALICE_API_KEY);
+        }
+    }));
+}
+function legacyProfileWithoutRegisteredAtDecodes() {
+    return withNodeContext(Effect.gen(function* () {
+        yield* writeConfigObject({
+            serverUrl: TEST_SERVER_URL,
             profiles: {
-                bob: { apiKey: "k-bob", agentName: "bob", serverUrl: "wss://x" },
+                [BOB_PROFILE_NAME]: namedRecord(BOB_API_KEY, BOB_AGENT_NAME),
             },
-        }, async () => {
-            const view = await Effect.runPromise(loadLayeredConfig);
-            const rec = view.profiles.get("bob");
-            expect(rec?.registeredAt).toBeUndefined();
         });
-    });
-    it("parse error surfaces as ProfileConfigReadError (no silent defaults)", async () => {
-        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "moltzap-profile-"));
-        const originalHome = process.env.MOLTZAP_CONFIG_HOME;
-        process.env.MOLTZAP_CONFIG_HOME = tmp;
-        try {
-            fs.writeFileSync(path.join(tmp, "config.json"), "{not json}");
-            const exit = await Effect.runPromiseExit(loadLayeredConfig);
-            expect(exit._tag).toBe("Failure");
-            if (exit._tag === "Failure") {
-                const s = JSON.stringify(exit.cause);
-                expect(s).toMatch(/ProfileConfigReadError/);
-            }
+        const view = yield* loadLayeredConfig;
+        const record = view.profiles.get(BOB_PROFILE_NAME);
+        expect(record).toBeDefined();
+        if (record !== undefined) {
+            expect(record.registeredAt).toBeUndefined();
         }
-        finally {
-            if (originalHome === undefined) {
-                delete process.env.MOLTZAP_CONFIG_HOME;
-            }
-            else {
-                process.env.MOLTZAP_CONFIG_HOME = originalHome;
-            }
-            fs.rmSync(tmp, { recursive: true, force: true });
-        }
-    });
-});
-describe("resolveProfileAuth", () => {
-    it("undefined name returns the default record", async () => {
-        await withTmpConfigHome({ serverUrl: "wss://x", apiKey: "k", agentName: "a" }, async () => {
-            const record = await Effect.runPromise(resolveProfileAuth(undefined));
-            expect(record.apiKey).toBe("k");
-        });
+    }));
+}
+function defaultProfileAuthResolves() {
+    return withNodeContext(Effect.gen(function* () {
+        yield* writeConfigObject(legacyConfig());
+        const record = yield* resolveProfileAuth(undefined);
+        expect(record.apiKey).toBe(DEFAULT_API_KEY);
+    }));
+}
+function unknownProfileFails() {
+    return withNodeContext(Effect.gen(function* () {
+        yield* writeConfigObject(legacyConfig());
+        const exit = yield* Effect.exit(resolveProfileAuth(GHOST_PROFILE_NAME));
+        expectFailureContaining(exit, PROFILE_NOT_FOUND_ERROR);
+    }));
+}
+function namedProfileAuthResolves() {
+    return withNodeContext(Effect.gen(function* () {
+        yield* writeConfigObject(namedProfilesConfig());
+        const record = yield* resolveProfileAuth(ALICE_PROFILE_NAME);
+        expect(record.apiKey).toBe(ALICE_API_KEY);
+    }));
+}
+function profileNotFoundErrorCarriesName() {
+    return Effect.sync(() => {
+        const err = new ProfileNotFoundError({ name: UNKNOWN_PROFILE_NAME });
+        expect(err.name).toBe(UNKNOWN_PROFILE_NAME);
     });
-    it("unknown name returns ProfileNotFoundError (no fallback to default)", async () => {
-        await withTmpConfigHome({ serverUrl: "wss://x", apiKey: "k", agentName: "a" }, async () => {
-            const exit = await Effect.runPromiseExit(resolveProfileAuth("ghost"));
-            expect(exit._tag).toBe("Failure");
-            if (exit._tag === "Failure") {
-                const s = JSON.stringify(exit.cause);
-                expect(s).toMatch(/ProfileNotFoundError/);
-            }
+}
+function writeNamedProfilePreservesLegacyTopLevelKeys() {
+    return withNodeContext(Effect.gen(function* () {
+        const configHome = yield* writeConfigObject({
+            serverUrl: TEST_SERVER_URL,
+            apiKey: LEGACY_API_KEY,
+            agentName: LEGACY_AGENT_NAME,
         });
+        yield* writeProfile(ALICE_PROFILE_NAME, namedRecord(ALICE_API_KEY, ALICE_AGENT_NAME));
+        const written = yield* readConfigObject(configHome);
+        const profiles = expectProfiles(written.profiles);
+        expect(written.apiKey).toBe(LEGACY_API_KEY);
+        expect(profiles[ALICE_PROFILE_NAME]?.apiKey).toBe(ALICE_API_KEY);
+    }));
+}
+function writeDefaultProfileUpdatesTopLevelKeys() {
+    return withNodeContext(Effect.gen(function* () {
+        const configHome = yield* makeConfigHome;
+        yield* writeProfile(DEFAULT_PROFILE_NAME, defaultRecord());
+        const written = yield* readConfigObject(configHome);
+        expect(written.apiKey).toBe(DEFAULT_API_KEY);
+        expect(written.profiles).toBeUndefined();
+    }));
+}
+function writeSecondProfilePreservesFirst() {
+    return withNodeContext(Effect.gen(function* () {
+        const configHome = yield* writeConfigObject(namedProfilesConfig());
+        yield* writeProfile(BOB_PROFILE_NAME, namedRecord(BOB_API_KEY, BOB_AGENT_NAME));
+        const written = yield* readConfigObject(configHome);
+        const profiles = expectProfiles(written.profiles);
+        expect(profiles[ALICE_PROFILE_NAME]?.apiKey).toBe(ALICE_API_KEY);
+        expect(profiles[BOB_PROFILE_NAME]?.apiKey).toBe(BOB_API_KEY);
+    }));
+}
+function emitNoPersistLeavesConfigDirUnchanged() {
+    return withNodeContext(Effect.gen(function* () {
+        const fileSystem = yield* FileSystem.FileSystem;
+        const configHome = yield* makeConfigHome;
+        const before = yield* fileSystem.readDirectory(configHome);
+        yield* emitNoPersist(defaultRecord());
+        const after = yield* fileSystem.readDirectory(configHome);
+        expect(after).toEqual(before);
+    }));
+}
+function emitNoPersistReturnsRecord() {
+    return Effect.gen(function* () {
+        const record = defaultRecord();
+        const result = yield* emitNoPersist(record);
+        expect(result.record).toEqual(record);
     });
-    it("known name returns the named record", async () => {
-        await withTmpConfigHome({
-            serverUrl: "wss://x",
-            profiles: {
-                alice: {
-                    apiKey: "k-alice",
-                    agentName: "alice",
-                    serverUrl: "wss://x",
-                },
-            },
-        }, async () => {
-            const record = await Effect.runPromise(resolveProfileAuth("alice"));
-            expect(record.apiKey).toBe("k-alice");
+}
+function profileInvalidNameErrorCarriesFields() {
+    return Effect.sync(() => {
+        const err = new ProfileInvalidNameError({
+            name: BAD_PROFILE_NAME,
+            reason: BAD_PROFILE_REASON,
         });
+        expect(err.name).toBe(BAD_PROFILE_NAME);
+        expect(err.reason).toBe(BAD_PROFILE_REASON);
     });
-    it("ProfileNotFoundError carries the requested name", () => {
-        const err = new ProfileNotFoundError({ name: "nobody" });
-        expect(err.name).toBe("nobody");
-    });
+}
+describe("parseProfileName valid input", () => {
+    it("accepts a valid lowercase-alphanumeric name", parsesLowercaseAlphanumericName);
+    it("accepts generated valid profile names", generatedValidProfileNamesParse);
+});
+describe("parseProfileName invalid input", () => {
+    it("rejects an empty string with ProfileInvalidNameError", rejectsEmptyName);
+    it("rejects a name with uppercase letters", rejectsUppercaseName);
+    it("rejects a name starting with a hyphen", rejectsLeadingHyphen);
+});
+describe("parseProfileName invalid boundary input", () => {
+    it("rejects a name ending with a hyphen", rejectsTrailingHyphen);
+    it("fails with ProfileInvalidNameError type", invalidNameErrorTypeSurfaces);
+});
+describe("loadLayeredConfig missing and malformed input", () => {
+    it("missing file resolves with empty view", missingFileLoadsEmptyView);
+    it("parse error surfaces as ProfileConfigReadError", malformedConfigFails);
+});
+describe("loadLayeredConfig legacy records", () => {
+    it("legacy top-level auth populates default", legacyConfigPopulatesDefaultRecord);
+    it("tolerates unknown top-level keys", unknownTopLevelKeysAreTolerated);
+});
+describe("loadLayeredConfig named profiles", () => {
+    it("profiles object populates the profiles map", namedProfilesPopulateMap);
+    it("missing registeredAt on legacy-shaped profile still decodes", legacyProfileWithoutRegisteredAtDecodes);
+});
+describe("resolveProfileAuth", () => {
+    it("undefined name returns the default record", defaultProfileAuthResolves);
+    it("unknown name returns ProfileNotFoundError", unknownProfileFails);
+    it("known name returns the named record", namedProfileAuthResolves);
+});
+describe("ProfileNotFoundError", () => {
+    it("carries the requested name", profileNotFoundErrorCarriesName);
 });
 describe("writeProfile", () => {
-    it("writing under a named profile leaves top-level apiKey untouched", async () => {
-        await withTmpConfigHome({ serverUrl: "wss://x", apiKey: "legacy-key", agentName: "legacy" }, async (tmp) => {
-            await Effect.runPromise(writeProfile("alice", {
-                apiKey: "k-alice",
-                agentName: "alice",
-                serverUrl: "wss://x",
-            }));
-            const written = JSON.parse(fs.readFileSync(path.join(tmp, "config.json"), "utf-8"));
-            expect(written.apiKey).toBe("legacy-key");
-            expect(written.profiles.alice.apiKey).toBe("k-alice");
-        });
-    });
-    it("writing 'default' updates top-level keys (not under profiles)", async () => {
-        await withTmpConfigHome(undefined, async (tmp) => {
-            await Effect.runPromise(writeProfile("default", {
-                apiKey: "k",
-                agentName: "a",
-                serverUrl: "wss://x",
-            }));
-            const written = JSON.parse(fs.readFileSync(path.join(tmp, "config.json"), "utf-8"));
-            expect(written.apiKey).toBe("k");
-            expect(written.profiles).toBeUndefined();
-        });
-    });
-    it("adding a second profile preserves the first", async () => {
-        await withTmpConfigHome({
-            serverUrl: "wss://x",
-            profiles: {
-                alice: {
-                    apiKey: "k-alice",
-                    agentName: "alice",
-                    serverUrl: "wss://x",
-                },
-            },
-        }, async (tmp) => {
-            await Effect.runPromise(writeProfile("bob", {
-                apiKey: "k-bob",
-                agentName: "bob",
-                serverUrl: "wss://x",
-            }));
-            const written = JSON.parse(fs.readFileSync(path.join(tmp, "config.json"), "utf-8"));
-            expect(written.profiles.alice.apiKey).toBe("k-alice");
-            expect(written.profiles.bob.apiKey).toBe("k-bob");
-        });
-    });
+    it("writing under a named profile leaves top-level apiKey untouched", writeNamedProfilePreservesLegacyTopLevelKeys);
+    it("writing default updates top-level keys", writeDefaultProfileUpdatesTopLevelKeys);
+    it("adding a second profile preserves the first", writeSecondProfilePreservesFirst);
 });
 describe("emitNoPersist", () => {
-    it("never writes to ~/.moltzap/ (fs diff before/after is empty)", async () => {
-        await withTmpConfigHome(undefined, async (tmp) => {
-            const before = fs.readdirSync(tmp);
-            await Effect.runPromise(emitNoPersist({
-                apiKey: "k",
-                agentName: "a",
-                serverUrl: "wss://x",
-            }));
-            const after = fs.readdirSync(tmp);
-            expect(after).toEqual(before);
-        });
-    });
-    it("returns the record unchanged for the caller to print", async () => {
-        const record = {
-            apiKey: "k",
-            agentName: "a",
-            serverUrl: "wss://x",
-        };
-        const result = await Effect.runPromise(emitNoPersist(record));
-        expect(result.record).toEqual(record);
-    });
+    it("never writes to the moltzap config directory", emitNoPersistLeavesConfigDirUnchanged);
+    it("returns the record unchanged for the caller to print", emitNoPersistReturnsRecord);
 });
 describe("ProfileInvalidNameError", () => {
-    it("carries name and reason", () => {
-        const err = new ProfileInvalidNameError({ name: "Bad", reason: "upper" });
-        expect(err.name).toBe("Bad");
-        expect(err.reason).toBe("upper");
-    });
+    it("carries name and reason", profileInvalidNameErrorCarriesFields);
 });
 //# sourceMappingURL=profile.test.js.map