@mx-space/cli 0.14.2 → 0.15.1

package/dist/test/services/Migration.test.js

@@ -0,0 +1,376 @@
+import { Effect, Exit, Layer } from 'effect';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { Config } from '../../src/services/Config';
+import { Migration } from '../../src/services/Migration';
+import { makeMemFs, TestFsLive, TestPathLive } from '../helper/test-fs';
+const makeLayer = () => {
+    const mem = makeMemFs();
+    const fsLayer = TestFsLive(mem);
+    const baseLayer = Layer.merge(fsLayer, TestPathLive);
+    const configLayer = Config.Default.pipe(Layer.provide(baseLayer));
+    const migLayer = Migration.Default.pipe(Layer.provide(Layer.merge(baseLayer, configLayer)));
+    return {
+        mem,
+        layer: Layer.mergeAll(baseLayer, configLayer, migLayer),
+    };
+};
+const tagOf = (cause) => {
+    const err = cause?.error ?? cause?.failure ?? cause;
+    return err?._tag ?? err?.error?._tag ?? err?.failure?._tag;
+};
+beforeEach(() => {
+    process.env.XDG_CONFIG_HOME = '/xdg';
+});
+afterEach(() => {
+    delete process.env.XDG_CONFIG_HOME;
+});
+describe('no-op when no legacy files', () => {
+    it('returns null and touches nothing', async () => {
+        const { mem, layer } = makeLayer();
+        const result = await Effect.runPromise(Effect.gen(function* () {
+            const mig = yield* Migration;
+            return yield* mig.runLegacyMigrationIfNeeded({
+                isTTY: false,
+                report: null,
+            });
+        }).pipe(Effect.provide(layer)));
+        expect(result).toBeNull();
+        expect([...mem.nodes.keys()]).toHaveLength(0);
+    });
+    it('returns null when only mxs dir exists', async () => {
+        const { mem, layer } = makeLayer();
+        mem.mkdir('/xdg/mxs');
+        const result = await Effect.runPromise(Effect.gen(function* () {
+            const mig = yield* Migration;
+            return yield* mig.runLegacyMigrationIfNeeded({
+                isTTY: false,
+                report: null,
+            });
+        }).pipe(Effect.provide(layer)));
+        expect(result).toBeNull();
+    });
+});
+describe('full migration — TTY says production=true', () => {
+    it('migrates and marks production=true', async () => {
+        const { mem, layer } = makeLayer();
+        mem.seed('/xdg/mxs/config.json', JSON.stringify({ api_url: 'https://blog.example.com' }));
+        mem.seed('/xdg/mxs/credentials.json', JSON.stringify({ access_token: 'tok-abc', expires_at: 9999 }));
+        const result = await Effect.runPromise(Effect.gen(function* () {
+            const mig = yield* Migration;
+            return yield* mig.runLegacyMigrationIfNeeded({
+                isTTY: true,
+                promptIsProduction: async () => true,
+                report: null,
+            });
+        }).pipe(Effect.provide(layer)));
+        expect(result).toMatchObject({
+            profile: 'default',
+            production: true,
+            cleanedStaleLegacy: false,
+        });
+        const cfg = JSON.parse(mem.readFile('/xdg/mxs/profiles/default/config.json') ?? '{}');
+        expect(cfg.api_url).toBe('https://blog.example.com');
+        expect(cfg.production).toBe(true);
+        const creds = JSON.parse(mem.readFile('/xdg/mxs/profiles/default/credentials.json') ?? '{}');
+        expect(creds.access_token).toBe('tok-abc');
+        expect(mem.has('/xdg/mxs/config.json')).toBe(false);
+        expect(mem.has('/xdg/mxs/credentials.json')).toBe(false);
+        expect(mem.readFile('/xdg/mxs/current')?.trim()).toBe('default');
+    });
+});
+describe('full migration — TTY says production=false', () => {
+    it('omits production flag', async () => {
+        const { mem, layer } = makeLayer();
+        mem.seed('/xdg/mxs/config.json', JSON.stringify({ api_url: 'https://blog.example.com' }));
+        const result = await Effect.runPromise(Effect.gen(function* () {
+            const mig = yield* Migration;
+            return yield* mig.runLegacyMigrationIfNeeded({
+                isTTY: true,
+                promptIsProduction: async () => false,
+                report: null,
+            });
+        }).pipe(Effect.provide(layer)));
+        expect(result?.production).toBe(false);
+        const cfg = JSON.parse(mem.readFile('/xdg/mxs/profiles/default/config.json') ?? '{}');
+        expect(cfg.production).not.toBe(true);
+    });
+});
+describe('full migration — non-TTY', () => {
+    it('skips prompt and migrates silently', async () => {
+        const { mem, layer } = makeLayer();
+        mem.seed('/xdg/mxs/config.json', JSON.stringify({ api_url: 'https://blog.example.com' }));
+        mem.seed('/xdg/mxs/credentials.json', JSON.stringify({ access_token: 'tok', expires_at: 1 }));
+        const promptSpy = vi.fn();
+        const result = await Effect.runPromise(Effect.gen(function* () {
+            const mig = yield* Migration;
+            return yield* mig.runLegacyMigrationIfNeeded({
+                isTTY: false,
+                promptIsProduction: promptSpy,
+                report: null,
+            });
+        }).pipe(Effect.provide(layer)));
+        expect(promptSpy).not.toHaveBeenCalled();
+        expect(result?.profile).toBe('default');
+        expect(result?.production).toBe(false);
+        expect(mem.has('/xdg/mxs/config.json')).toBe(false);
+        expect(mem.has('/xdg/mxs/credentials.json')).toBe(false);
+    });
+});
+describe('full migration — partial inputs', () => {
+    it('handles only config.json', async () => {
+        const { mem, layer } = makeLayer();
+        mem.seed('/xdg/mxs/config.json', JSON.stringify({ api_url: 'https://blog.example.com' }));
+        const result = await Effect.runPromise(Effect.gen(function* () {
+            const mig = yield* Migration;
+            return yield* mig.runLegacyMigrationIfNeeded({
+                isTTY: false,
+                report: null,
+            });
+        }).pipe(Effect.provide(layer)));
+        expect(result?.profile).toBe('default');
+        expect(mem.has('/xdg/mxs/profiles/default/credentials.json')).toBe(false);
+    });
+    it('writes empty config when only credentials present', async () => {
+        const { mem, layer } = makeLayer();
+        mem.seed('/xdg/mxs/credentials.json', JSON.stringify({ access_token: 'tok', expires_at: 1 }));
+        const result = await Effect.runPromise(Effect.gen(function* () {
+            const mig = yield* Migration;
+            return yield* mig.runLegacyMigrationIfNeeded({
+                isTTY: false,
+                report: null,
+            });
+        }).pipe(Effect.provide(layer)));
+        expect(result?.profile).toBe('default');
+        expect(mem.has('/xdg/mxs/profiles/default/config.json')).toBe(true);
+        expect(mem.has('/xdg/mxs/profiles/default/credentials.json')).toBe(true);
+    });
+});
+describe('stale-legacy cleanup', () => {
+    it('removes legacy files when profiles/ exists', async () => {
+        const { mem, layer } = makeLayer();
+        mem.mkdir('/xdg/mxs/profiles/some-existing');
+        mem.seed('/xdg/mxs/profiles/some-existing/config.json', JSON.stringify({ api_url: 'https://existing.example.com' }));
+        mem.seed('/xdg/mxs/config.json', JSON.stringify({ api_url: 'https://stale.example.com' }));
+        const result = await Effect.runPromise(Effect.gen(function* () {
+            const mig = yield* Migration;
+            return yield* mig.runLegacyMigrationIfNeeded({
+                isTTY: false,
+                report: null,
+            });
+        }).pipe(Effect.provide(layer)));
+        expect(result).toMatchObject({
+            profile: null,
+            production: false,
+            cleanedStaleLegacy: true,
+        });
+        expect(mem.has('/xdg/mxs/config.json')).toBe(false);
+        expect(mem.has('/xdg/mxs/profiles/some-existing/config.json')).toBe(true);
+        expect(mem.has('/xdg/mxs/current')).toBe(false);
+    });
+    it('removes both legacy files when stale', async () => {
+        const { mem, layer } = makeLayer();
+        mem.mkdir('/xdg/mxs/profiles/dev');
+        mem.seed('/xdg/mxs/config.json', '{}');
+        mem.seed('/xdg/mxs/credentials.json', '{}');
+        const result = await Effect.runPromise(Effect.gen(function* () {
+            const mig = yield* Migration;
+            return yield* mig.runLegacyMigrationIfNeeded({
+                isTTY: false,
+                report: null,
+            });
+        }).pipe(Effect.provide(layer)));
+        expect(result?.cleanedStaleLegacy).toBe(true);
+        expect(mem.has('/xdg/mxs/config.json')).toBe(false);
+        expect(mem.has('/xdg/mxs/credentials.json')).toBe(false);
+    });
+});
+describe('idempotency', () => {
+    it('second call returns null after successful migration', async () => {
+        const { mem, layer } = makeLayer();
+        mem.seed('/xdg/mxs/config.json', JSON.stringify({ api_url: 'https://blog.example.com' }));
+        const program = Effect.gen(function* () {
+            const mig = yield* Migration;
+            const first = yield* mig.runLegacyMigrationIfNeeded({
+                isTTY: false,
+                report: null,
+            });
+            const second = yield* mig.runLegacyMigrationIfNeeded({
+                isTTY: false,
+                report: null,
+            });
+            return { first, second };
+        });
+        const result = await Effect.runPromise(program.pipe(Effect.provide(layer)));
+        expect(result.first?.profile).toBe('default');
+        expect(result.second).toBeNull();
+    });
+});
+describe('report suppression', () => {
+    it('report callback receives status line on migrate', async () => {
+        const { mem, layer } = makeLayer();
+        mem.seed('/xdg/mxs/config.json', JSON.stringify({ api_url: 'https://blog.example.com' }));
+        const lines = [];
+        await Effect.runPromise(Effect.gen(function* () {
+            const mig = yield* Migration;
+            yield* mig.runLegacyMigrationIfNeeded({
+                isTTY: false,
+                report: (line) => lines.push(line),
+            });
+        }).pipe(Effect.provide(layer)));
+        expect(lines.some((l) => l.includes("migrated single-profile config to profile 'default'"))).toBe(true);
+    });
+    it('stale-cleanup emits a warning line', async () => {
+        const { mem, layer } = makeLayer();
+        mem.mkdir('/xdg/mxs/profiles/dev');
+        mem.seed('/xdg/mxs/config.json', '{}');
+        const lines = [];
+        await Effect.runPromise(Effect.gen(function* () {
+            const mig = yield* Migration;
+            yield* mig.runLegacyMigrationIfNeeded({
+                isTTY: false,
+                report: (line) => lines.push(line),
+            });
+        }).pipe(Effect.provide(layer)));
+        expect(lines.some((l) => l.includes('stale legacy config files'))).toBe(true);
+    });
+    it('report=null suppresses all output', async () => {
+        const { mem, layer } = makeLayer();
+        mem.seed('/xdg/mxs/config.json', JSON.stringify({ api_url: 'https://blog.example.com' }));
+        const stderrSpy = vi
+            .spyOn(process.stderr, 'write')
+            .mockImplementation(() => true);
+        try {
+            await Effect.runPromise(Effect.gen(function* () {
+                const mig = yield* Migration;
+                yield* mig.runLegacyMigrationIfNeeded({
+                    isTTY: false,
+                    report: null,
+                });
+            }).pipe(Effect.provide(layer)));
+        }
+        finally {
+            stderrSpy.mockRestore();
+        }
+        expect(stderrSpy).not.toHaveBeenCalled();
+    });
+    it('uses process.stderr when no report callback is supplied', async () => {
+        const { mem, layer } = makeLayer();
+        mem.seed('/xdg/mxs/config.json', JSON.stringify({ api_url: 'https://blog.example.com' }));
+        const stderrSpy = vi
+            .spyOn(process.stderr, 'write')
+            .mockImplementation(() => true);
+        try {
+            await Effect.runPromise(Effect.gen(function* () {
+                const mig = yield* Migration;
+                yield* mig.runLegacyMigrationIfNeeded({ isTTY: false });
+            }).pipe(Effect.provide(layer)));
+            expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining("migrated single-profile config to profile 'default'"));
+        }
+        finally {
+            stderrSpy.mockRestore();
+        }
+    });
+});
+describe('promptIsProduction cancellation', () => {
+    it('treats symbol return as production=false', async () => {
+        const { mem, layer } = makeLayer();
+        mem.seed('/xdg/mxs/config.json', JSON.stringify({ api_url: 'https://blog.example.com' }));
+        const cancelSymbol = Symbol('test-cancel');
+        const result = await Effect.runPromise(Effect.gen(function* () {
+            const mig = yield* Migration;
+            return yield* mig.runLegacyMigrationIfNeeded({
+                isTTY: true,
+                promptIsProduction: async () => cancelSymbol,
+                report: null,
+            });
+        }).pipe(Effect.provide(layer)));
+        expect(result?.production).toBe(false);
+        expect(result?.profile).toBe('default');
+        expect(mem.readFile('/xdg/mxs/current')?.trim()).toBe('default');
+    });
+});
+describe('failure modes', () => {
+    it('rejects with ConfigMigrationFailed on corrupt config json', async () => {
+        const { mem, layer } = makeLayer();
+        mem.seed('/xdg/mxs/config.json', 'this is not json{');
+        const exit = await Effect.runPromiseExit(Effect.gen(function* () {
+            const mig = yield* Migration;
+            return yield* mig.runLegacyMigrationIfNeeded({
+                isTTY: false,
+                report: null,
+            });
+        }).pipe(Effect.provide(layer)));
+        expect(Exit.isFailure(exit)).toBe(true);
+        if (Exit.isFailure(exit)) {
+            expect(tagOf(exit.cause)).toBe('ConfigMigrationFailed');
+        }
+        // Legacy file must NOT be deleted — rejection happened during read.
+        expect(mem.has('/xdg/mxs/config.json')).toBe(true);
+    });
+    it('rejects with ConfigMigrationFailed on corrupt credentials json', async () => {
+        const { mem, layer } = makeLayer();
+        mem.seed('/xdg/mxs/config.json', JSON.stringify({ api_url: 'https://blog.example.com' }));
+        mem.seed('/xdg/mxs/credentials.json', '{');
+        const exit = await Effect.runPromiseExit(Effect.gen(function* () {
+            const mig = yield* Migration;
+            return yield* mig.runLegacyMigrationIfNeeded({
+                isTTY: false,
+                report: null,
+            });
+        }).pipe(Effect.provide(layer)));
+        expect(Exit.isFailure(exit)).toBe(true);
+        if (Exit.isFailure(exit)) {
+            expect(tagOf(exit.cause)).toBe('ConfigMigrationFailed');
+        }
+        expect(mem.has('/xdg/mxs/credentials.json')).toBe(true);
+    });
+    it('rejects with ConfigMigrationFailed when the production prompt fails', async () => {
+        const { mem, layer } = makeLayer();
+        mem.seed('/xdg/mxs/config.json', JSON.stringify({ api_url: 'https://blog.example.com' }));
+        const exit = await Effect.runPromiseExit(Effect.gen(function* () {
+            const mig = yield* Migration;
+            return yield* mig.runLegacyMigrationIfNeeded({
+                isTTY: true,
+                promptIsProduction: async () => {
+                    throw new Error('prompt unavailable');
+                },
+                report: null,
+            });
+        }).pipe(Effect.provide(layer)));
+        expect(Exit.isFailure(exit)).toBe(true);
+        if (Exit.isFailure(exit)) {
+            expect(tagOf(exit.cause)).toBe('ConfigMigrationFailed');
+        }
+        expect(mem.has('/xdg/mxs/config.json')).toBe(true);
+    });
+});
+describe('file mode preservation', () => {
+    it('profile dir has mode 0700', async () => {
+        const { mem, layer } = makeLayer();
+        mem.seed('/xdg/mxs/config.json', JSON.stringify({ api_url: 'https://blog.example.com' }));
+        await Effect.runPromise(Effect.gen(function* () {
+            const mig = yield* Migration;
+            yield* mig.runLegacyMigrationIfNeeded({ isTTY: false, report: null });
+        }).pipe(Effect.provide(layer)));
+        expect(mem.mode('/xdg/mxs/profiles/default')).toBe(0o700);
+    });
+    it('credentials.json has mode 0600', async () => {
+        const { mem, layer } = makeLayer();
+        mem.seed('/xdg/mxs/config.json', JSON.stringify({ api_url: 'https://blog.example.com' }));
+        mem.seed('/xdg/mxs/credentials.json', JSON.stringify({ access_token: 't', expires_at: 0 }));
+        await Effect.runPromise(Effect.gen(function* () {
+            const mig = yield* Migration;
+            yield* mig.runLegacyMigrationIfNeeded({ isTTY: false, report: null });
+        }).pipe(Effect.provide(layer)));
+        expect(mem.mode('/xdg/mxs/profiles/default/credentials.json')).toBe(0o600);
+    });
+    it('config.json has mode 0644', async () => {
+        const { mem, layer } = makeLayer();
+        mem.seed('/xdg/mxs/config.json', JSON.stringify({ api_url: 'https://blog.example.com' }));
+        await Effect.runPromise(Effect.gen(function* () {
+            const mig = yield* Migration;
+            yield* mig.runLegacyMigrationIfNeeded({ isTTY: false, report: null });
+        }).pipe(Effect.provide(layer)));
+        expect(mem.mode('/xdg/mxs/profiles/default/config.json')).toBe(0o644);
+    });
+});

package/dist/test/services/Profile.test.d.ts

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

package/dist/test/services/Profile.test.js

@@ -0,0 +1,277 @@
+import { Effect, Exit, Layer } from 'effect';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { Config } from '../../src/services/Config';
+import { Profile } from '../../src/services/Profile';
+import { makeMemFs, TestFsLive, TestPathLive } from '../helper/test-fs';
+const makeLayer = () => {
+    const mem = makeMemFs();
+    const fsLayer = TestFsLive(mem);
+    const baseLayer = Layer.merge(fsLayer, TestPathLive);
+    const configLayer = Config.Default.pipe(Layer.provide(baseLayer));
+    const profileLayer = Profile.Default.pipe(Layer.provide(configLayer));
+    return {
+        mem,
+        layer: Layer.mergeAll(baseLayer, configLayer, profileLayer),
+    };
+};
+const tagOf = (cause) => {
+    const err = cause?.error ?? cause?.failure ?? cause;
+    return err?._tag ?? err?.error?._tag ?? err?.failure?._tag;
+};
+beforeEach(() => {
+    process.env.XDG_CONFIG_HOME = '/xdg';
+    delete process.env.MXS_PROFILE;
+});
+afterEach(() => {
+    delete process.env.XDG_CONFIG_HOME;
+    delete process.env.MXS_PROFILE;
+});
+describe('Profile.validateName', () => {
+    const cases = [
+        ['default', true, 'common'],
+        ['dev', true, 'common'],
+        ['my-blog', true, 'hyphen'],
+        ['my_blog', true, 'underscore'],
+        ['a', true, 'single char'],
+        ['a'.repeat(32), true, '32 chars'],
+        ['', false, 'empty'],
+        ['current', false, 'reserved'],
+        ['Current', false, 'uppercase'],
+        ['PROD', false, 'uppercase letters'],
+        ['my blog', false, 'space'],
+        ['my/blog', false, 'slash'],
+        ['a'.repeat(33), false, 'too long'],
+        ['a.b', false, 'dot'],
+    ];
+    for (const [name, ok, why] of cases) {
+        it(`${ok ? 'accepts' : 'rejects'} ${JSON.stringify(name)} (${why})`, async () => {
+            const { layer } = makeLayer();
+            const exit = await Effect.runPromiseExit(Effect.gen(function* () {
+                const profile = yield* Profile;
+                yield* profile.validateName(name);
+            }).pipe(Effect.provide(layer)));
+            if (ok) {
+                expect(Exit.isSuccess(exit)).toBe(true);
+            }
+            else {
+                expect(Exit.isFailure(exit)).toBe(true);
+                if (Exit.isFailure(exit)) {
+                    expect(tagOf(exit.cause)).toBe('ProfileInvalidName');
+                }
+            }
+        });
+    }
+});
+describe('Profile.list', () => {
+    it('returns empty when profiles dir absent', async () => {
+        const { layer } = makeLayer();
+        const result = await Effect.runPromise(Effect.gen(function* () {
+            const profile = yield* Profile;
+            return yield* profile.list;
+        }).pipe(Effect.provide(layer)));
+        expect(result).toEqual([]);
+    });
+    it('lists profile directories sorted', async () => {
+        const { mem, layer } = makeLayer();
+        mem.mkdir('/xdg/mxs/profiles/dev');
+        mem.mkdir('/xdg/mxs/profiles/prod');
+        const result = await Effect.runPromise(Effect.gen(function* () {
+            const profile = yield* Profile;
+            return yield* profile.list;
+        }).pipe(Effect.provide(layer)));
+        expect(result).toEqual(['dev', 'prod']);
+    });
+    it('ignores hidden directories', async () => {
+        const { mem, layer } = makeLayer();
+        mem.mkdir('/xdg/mxs/profiles/dev');
+        mem.mkdir('/xdg/mxs/profiles/.hidden');
+        const result = await Effect.runPromise(Effect.gen(function* () {
+            const profile = yield* Profile;
+            return yield* profile.list;
+        }).pipe(Effect.provide(layer)));
+        expect(result).toEqual(['dev']);
+    });
+    it('ignores file entries', async () => {
+        const { mem, layer } = makeLayer();
+        mem.mkdir('/xdg/mxs/profiles');
+        mem.mkdir('/xdg/mxs/profiles/dev');
+        mem.seed('/xdg/mxs/profiles/readme.txt', 'hello');
+        const result = await Effect.runPromise(Effect.gen(function* () {
+            const profile = yield* Profile;
+            return yield* profile.list;
+        }).pipe(Effect.provide(layer)));
+        expect(result).toEqual(['dev']);
+    });
+});
+describe('Profile.current', () => {
+    it('returns null when current pointer absent', async () => {
+        const { layer } = makeLayer();
+        const result = await Effect.runPromise(Effect.gen(function* () {
+            const profile = yield* Profile;
+            return yield* profile.current;
+        }).pipe(Effect.provide(layer)));
+        expect(result).toBeNull();
+    });
+    it('returns trimmed pointer', async () => {
+        const { mem, layer } = makeLayer();
+        mem.seed('/xdg/mxs/current', 'prod\n');
+        const result = await Effect.runPromise(Effect.gen(function* () {
+            const profile = yield* Profile;
+            return yield* profile.current;
+        }).pipe(Effect.provide(layer)));
+        expect(result).toBe('prod');
+    });
+    it('returns null when pointer is whitespace only', async () => {
+        const { mem, layer } = makeLayer();
+        mem.seed('/xdg/mxs/current', '  \n');
+        const result = await Effect.runPromise(Effect.gen(function* () {
+            const profile = yield* Profile;
+            return yield* profile.current;
+        }).pipe(Effect.provide(layer)));
+        expect(result).toBeNull();
+    });
+});
+describe('Profile.use', () => {
+    it('writes the current pointer when profile exists', async () => {
+        const { mem, layer } = makeLayer();
+        mem.mkdir('/xdg/mxs/profiles/dev');
+        await Effect.runPromise(Effect.gen(function* () {
+            const profile = yield* Profile;
+            yield* profile.use('dev');
+        }).pipe(Effect.provide(layer)));
+        expect(mem.readFile('/xdg/mxs/current')?.trim()).toBe('dev');
+    });
+    it('rejects unknown profile with ProfileNotFound', async () => {
+        const { layer } = makeLayer();
+        const exit = await Effect.runPromiseExit(Effect.gen(function* () {
+            const profile = yield* Profile;
+            yield* profile.use('ghost');
+        }).pipe(Effect.provide(layer)));
+        expect(Exit.isFailure(exit)).toBe(true);
+        if (Exit.isFailure(exit))
+            expect(tagOf(exit.cause)).toBe('ProfileNotFound');
+    });
+    it('rejects reserved name with ProfileInvalidName', async () => {
+        const { layer } = makeLayer();
+        const exit = await Effect.runPromiseExit(Effect.gen(function* () {
+            const profile = yield* Profile;
+            yield* profile.use('current');
+        }).pipe(Effect.provide(layer)));
+        expect(Exit.isFailure(exit)).toBe(true);
+        if (Exit.isFailure(exit))
+            expect(tagOf(exit.cause)).toBe('ProfileInvalidName');
+    });
+});
+describe('Profile.mark', () => {
+    it('sets production=true when requested', async () => {
+        const { layer } = makeLayer();
+        const result = await Effect.runPromise(Effect.gen(function* () {
+            const config = yield* Config;
+            yield* config.writeProfileConfig('dev', {
+                api_url: 'https://dev.example.com',
+            });
+            const profile = yield* Profile;
+            return yield* profile.mark('dev', { production: true });
+        }).pipe(Effect.provide(layer)));
+        expect(result.production).toBe(true);
+    });
+    it('removes production flag when set to false', async () => {
+        const { layer } = makeLayer();
+        const result = await Effect.runPromise(Effect.gen(function* () {
+            const config = yield* Config;
+            yield* config.writeProfileConfig('prod', {
+                api_url: 'https://prod.example.com',
+                production: true,
+            });
+            const profile = yield* Profile;
+            return yield* profile.mark('prod', { production: false });
+        }).pipe(Effect.provide(layer)));
+        expect(result.production).toBeUndefined();
+    });
+    it('fails on missing profile', async () => {
+        const { layer } = makeLayer();
+        const exit = await Effect.runPromiseExit(Effect.gen(function* () {
+            const profile = yield* Profile;
+            return yield* profile.mark('ghost', { production: true });
+        }).pipe(Effect.provide(layer)));
+        expect(Exit.isFailure(exit)).toBe(true);
+        if (Exit.isFailure(exit))
+            expect(tagOf(exit.cause)).toBe('ProfileNotFound');
+    });
+});
+describe('Profile.rm', () => {
+    it('removes an existing profile directory', async () => {
+        const { mem, layer } = makeLayer();
+        await Effect.runPromise(Effect.gen(function* () {
+            const config = yield* Config;
+            yield* config.writeProfileConfig('dev', {
+                api_url: 'https://dev.example.com',
+            });
+            const profile = yield* Profile;
+            yield* profile.rm('dev');
+        }).pipe(Effect.provide(layer)));
+        expect(mem.has('/xdg/mxs/profiles/dev')).toBe(false);
+    });
+    it('fails with ResourceNotFound when profile absent', async () => {
+        const { layer } = makeLayer();
+        const exit = await Effect.runPromiseExit(Effect.gen(function* () {
+            const profile = yield* Profile;
+            yield* profile.rm('ghost');
+        }).pipe(Effect.provide(layer)));
+        expect(Exit.isFailure(exit)).toBe(true);
+        if (Exit.isFailure(exit))
+            expect(tagOf(exit.cause)).toBe('ResourceNotFound');
+    });
+});
+describe('Profile.show', () => {
+    it('returns summary with auth + active flags', async () => {
+        const { mem, layer } = makeLayer();
+        mem.seed('/xdg/mxs/current', 'dev\n');
+        const result = await Effect.runPromise(Effect.gen(function* () {
+            const config = yield* Config;
+            yield* config.writeProfileConfig('dev', {
+                api_url: 'https://dev.example.com',
+                production: false,
+            });
+            yield* config.writeProfileCredentials('dev', {
+                access_token: 'tok',
+                expires_at: 100,
+            });
+            const profile = yield* Profile;
+            return yield* profile.show('dev');
+        }).pipe(Effect.provide(layer)));
+        expect(result).toEqual({
+            name: 'dev',
+            apiUrl: 'https://dev.example.com',
+            production: false,
+            authenticated: true,
+            active: true,
+        });
+    });
+    it('fails with ProfileNotFound when absent', async () => {
+        const { layer } = makeLayer();
+        const exit = await Effect.runPromiseExit(Effect.gen(function* () {
+            const profile = yield* Profile;
+            return yield* profile.show('ghost');
+        }).pipe(Effect.provide(layer)));
+        expect(Exit.isFailure(exit)).toBe(true);
+        if (Exit.isFailure(exit))
+            expect(tagOf(exit.cause)).toBe('ProfileNotFound');
+    });
+});
+describe('Profile.resolve', () => {
+    it('proxies through Config.resolve and yields ResolvedConfig', async () => {
+        const { layer } = makeLayer();
+        process.env.MXS_PROFILE = 'dev';
+        const r = await Effect.runPromise(Effect.gen(function* () {
+            const config = yield* Config;
+            yield* config.writeProfileConfig('dev', {
+                api_url: 'https://dev.example.com',
+            });
+            const profile = yield* Profile;
+            return yield* profile.resolve();
+        }).pipe(Effect.provide(layer)));
+        expect(r.apiUrl).toBe('https://dev.example.com');
+        expect(r.profileName).toBe('dev');
+    });
+});

package/dist/test/services/Renderer.test.d.ts

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