@mx-space/cli 0.14.2 → 0.15.1

package/dist/test/cli/post-note-crud.test.js

@@ -0,0 +1,362 @@
+import { Effect, Exit, Layer, Option } from 'effect';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { del as deleteNote } from '../../src/cli/note/delete';
+import { get as getNote } from '../../src/cli/note/get';
+import { update as updateNote } from '../../src/cli/note/update';
+import { del as deletePage } from '../../src/cli/page/delete';
+import { del as deletePost } from '../../src/cli/post/delete';
+import { get as getPost } from '../../src/cli/post/get';
+import { update as updatePost } from '../../src/cli/post/update';
+import { del as deleteTopic } from '../../src/cli/topic/delete';
+import { update as updateTopic } from '../../src/cli/topic/update';
+import { Api } from '../../src/services/Api';
+import { Lexical } from '../../src/services/Lexical';
+import { Renderer, } from '../../src/services/Renderer';
+import { Resolver } from '../../src/services/Resolver';
+import { makeMemFs, TestFsLive, TestPathLive } from '../helper/test-fs';
+const rendererJson = {
+    json: true,
+    output: 'json',
+    quiet: false,
+    verbose: false,
+};
+const captureStdout = () => {
+    const data = [];
+    const orig = process.stdout.write.bind(process.stdout);
+    process.stdout.write = (s) => {
+        data.push(typeof s === 'string' ? s : s.toString());
+        return true;
+    };
+    return {
+        data,
+        restore: () => {
+            ;
+            process.stdout.write = orig;
+        },
+    };
+};
+const makeResolver = () => ({
+    resolveCategory: () => Effect.succeed('cat-id'),
+    resolveTopic: () => Effect.succeed('topic-id'),
+    resolveCategoryRefs: (refs) => Effect.succeed(refs),
+    resolvePostId: () => Effect.succeed('123456789012345'),
+    resolvePostReadPath: () => Effect.succeed('/posts/tech/hello'),
+    resolveNoteId: () => Effect.succeed('123456789012346'),
+    resolveCategoryId: () => Effect.succeed('cat-id'),
+    resolveProjectId: () => Effect.succeed('123456789012347'),
+    invalidate: () => Effect.void,
+});
+const makeApi = (calls) => ({
+    request: (path, options) => Effect.sync(() => {
+        calls.push({ path, options });
+        return { id: 'resource-id', ok: true, title: 'Title' };
+    }),
+    raw: (path, options) => Effect.sync(() => {
+        calls.push({ path, options });
+        return { id: 'resource-id', ok: true };
+    }),
+});
+const buildLayer = (calls) => Layer.mergeAll(TestFsLive(makeMemFs()), TestPathLive, Layer.succeed(Api, makeApi(calls)), Layer.succeed(Resolver, makeResolver()), Renderer.Default, Lexical.Default);
+afterEach(() => {
+    vi.restoreAllMocks();
+});
+const none = () => Option.none();
+describe('post command CRUD handlers', () => {
+    it('gets a post through the resolved read path', async () => {
+        const calls = [];
+        const stdout = captureStdout();
+        try {
+            const exit = await Effect.runPromiseExit(getPost.handler({ slugOrId: 'hello' }).pipe(Effect.provide(buildLayer(calls)), Renderer.withOptions(rendererJson)));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            expect(calls[0]).toMatchObject({
+                path: '/posts/tech/hello',
+                options: { query: { prefer: 'lexical' } },
+            });
+            expect(stdout.data.join('')).toContain('Title');
+        }
+        finally {
+            stdout.restore();
+        }
+    });
+    it('deletes a post when --force is supplied', async () => {
+        const calls = [];
+        const stdout = captureStdout();
+        try {
+            const exit = await Effect.runPromiseExit(deletePost.handler({ slugOrId: 'hello', force: true }).pipe(Effect.provide(buildLayer(calls)), Renderer.withOptions(rendererJson)));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            expect(calls[0]).toMatchObject({
+                path: '/posts/123456789012345',
+                options: { method: 'DELETE' },
+            });
+            expect(stdout.data.join('')).toContain('123456789012345');
+        }
+        finally {
+            stdout.restore();
+        }
+    });
+    it('refuses post delete without --force in non-TTY mode', async () => {
+        const descriptor = Object.getOwnPropertyDescriptor(process.stdin, 'isTTY');
+        Object.defineProperty(process.stdin, 'isTTY', {
+            configurable: true,
+            value: false,
+        });
+        try {
+            const exit = await Effect.runPromiseExit(deletePost.handler({ slugOrId: 'hello', force: false }).pipe(Effect.provide(buildLayer([]))));
+            expect(Exit.isFailure(exit)).toBe(true);
+        }
+        finally {
+            if (descriptor)
+                Object.defineProperty(process.stdin, 'isTTY', descriptor);
+        }
+    });
+    it('patches a post update payload', async () => {
+        const calls = [];
+        const exit = await Effect.runPromiseExit(updatePost
+            .handler({
+            slugOrId: 'hello',
+            title: Option.some('Updated'),
+            slug: none(),
+            category: Option.some('tech'),
+            content: none(),
+            format: none(),
+            summary: none(),
+            state: none(),
+            tags: none(),
+            copyright: none(),
+            pin: none(),
+            pinOrder: none(),
+            related: none(),
+            meta: none(),
+            file: none(),
+            open: false,
+            silent: false,
+        })
+            .pipe(Effect.provide(buildLayer(calls)), Renderer.withOptions(rendererJson)));
+        expect(Exit.isSuccess(exit)).toBe(true);
+        expect(calls[0]).toMatchObject({
+            path: '/posts/123456789012345',
+            options: { method: 'PATCH' },
+        });
+        expect(calls[0].options.body).toMatchObject({
+            title: 'Updated',
+            categoryId: 'cat-id',
+        });
+    });
+});
+describe('note command CRUD handlers', () => {
+    it('gets a note by resolved id', async () => {
+        const calls = [];
+        const stdout = captureStdout();
+        try {
+            const exit = await Effect.runPromiseExit(getNote.handler({ slugOrId: '42' }).pipe(Effect.provide(buildLayer(calls)), Renderer.withOptions(rendererJson)));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            expect(calls[0]).toMatchObject({
+                path: '/notes/nid/42',
+                options: { query: { single: '1', prefer: 'lexical' } },
+            });
+            expect(stdout.data.join('')).toContain('Title');
+        }
+        finally {
+            stdout.restore();
+        }
+    });
+    it('gets a note directly by snowflake id and rejects invalid references', async () => {
+        const calls = [];
+        const stdout = captureStdout();
+        try {
+            const success = await Effect.runPromiseExit(getNote.handler({ slugOrId: '123456789012346' }).pipe(Effect.provide(buildLayer(calls)), Renderer.withOptions(rendererJson)));
+            expect(Exit.isSuccess(success)).toBe(true);
+            expect(calls[0]).toMatchObject({
+                path: '/notes/123456789012346',
+                options: { query: { prefer: 'lexical' } },
+            });
+        }
+        finally {
+            stdout.restore();
+        }
+        const failure = await Effect.runPromiseExit(getNote.handler({ slugOrId: 'not-a-note' }).pipe(Effect.provide(buildLayer([]))));
+        expect(Exit.isFailure(failure)).toBe(true);
+    });
+    it('deletes a note when --force is supplied', async () => {
+        const calls = [];
+        const stdout = captureStdout();
+        try {
+            const exit = await Effect.runPromiseExit(deleteNote.handler({ slugOrId: 'note', force: true }).pipe(Effect.provide(buildLayer(calls)), Renderer.withOptions(rendererJson)));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            expect(calls[0]).toMatchObject({
+                path: '/notes/123456789012346',
+                options: { method: 'DELETE' },
+            });
+            expect(stdout.data.join('')).toContain('123456789012346');
+        }
+        finally {
+            stdout.restore();
+        }
+    });
+    it('refuses note delete without --force in non-TTY mode', async () => {
+        const descriptor = Object.getOwnPropertyDescriptor(process.stdin, 'isTTY');
+        Object.defineProperty(process.stdin, 'isTTY', {
+            configurable: true,
+            value: false,
+        });
+        try {
+            const exit = await Effect.runPromiseExit(deleteNote.handler({ slugOrId: 'note', force: false }).pipe(Effect.provide(buildLayer([]))));
+            expect(Exit.isFailure(exit)).toBe(true);
+        }
+        finally {
+            if (descriptor)
+                Object.defineProperty(process.stdin, 'isTTY', descriptor);
+        }
+    });
+    it('patches a note update payload', async () => {
+        const calls = [];
+        const exit = await Effect.runPromiseExit(updateNote
+            .handler({
+            slugOrId: 'note',
+            title: Option.some('Updated note'),
+            slug: none(),
+            topic: Option.some('life'),
+            content: none(),
+            format: none(),
+            state: none(),
+            mood: none(),
+            weather: none(),
+            publicAt: none(),
+            password: none(),
+            bookmark: none(),
+            coords: none(),
+            location: none(),
+            images: none(),
+            meta: none(),
+            file: none(),
+            open: false,
+            silent: false,
+        })
+            .pipe(Effect.provide(buildLayer(calls)), Renderer.withOptions(rendererJson)));
+        expect(Exit.isSuccess(exit)).toBe(true);
+        expect(calls[0]).toMatchObject({
+            path: '/notes/123456789012346',
+            options: { method: 'PATCH' },
+        });
+        expect(calls[0].options.body).toMatchObject({
+            title: 'Updated note',
+            topicId: 'topic-id',
+        });
+    });
+});
+describe('page and topic command handlers', () => {
+    it('deletes a page by slug after resolving its id', async () => {
+        const calls = [];
+        const stdout = captureStdout();
+        try {
+            const exit = await Effect.runPromiseExit(deletePage.handler({ slugOrId: 'about', force: true }).pipe(Effect.provide(buildLayer(calls)), Renderer.withOptions(rendererJson)));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            expect(calls).toEqual([
+                { path: '/pages/slug/about', options: undefined },
+                { path: '/pages/resource-id', options: { method: 'DELETE' } },
+            ]);
+            expect(stdout.data.join('')).toContain('resource-id');
+        }
+        finally {
+            stdout.restore();
+        }
+    });
+    it('deletes a page directly by snowflake id', async () => {
+        const calls = [];
+        const stdout = captureStdout();
+        try {
+            const exit = await Effect.runPromiseExit(deletePage.handler({ slugOrId: '123456789012347', force: true }).pipe(Effect.provide(buildLayer(calls)), Renderer.withOptions(rendererJson)));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            expect(calls).toEqual([
+                { path: '/pages/123456789012347', options: { method: 'DELETE' } },
+            ]);
+        }
+        finally {
+            stdout.restore();
+        }
+    });
+    it('refuses page delete without --force in non-TTY mode', async () => {
+        const descriptor = Object.getOwnPropertyDescriptor(process.stdin, 'isTTY');
+        Object.defineProperty(process.stdin, 'isTTY', {
+            configurable: true,
+            value: false,
+        });
+        try {
+            const exit = await Effect.runPromiseExit(deletePage.handler({ slugOrId: 'about', force: false }).pipe(Effect.provide(buildLayer([]))));
+            expect(Exit.isFailure(exit)).toBe(true);
+        }
+        finally {
+            if (descriptor)
+                Object.defineProperty(process.stdin, 'isTTY', descriptor);
+        }
+    });
+    it('deletes a topic by slug after resolving its id', async () => {
+        const calls = [];
+        const stdout = captureStdout();
+        try {
+            const exit = await Effect.runPromiseExit(deleteTopic.handler({ slugOrId: 'life', force: true }).pipe(Effect.provide(buildLayer(calls)), Renderer.withOptions(rendererJson)));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            expect(calls).toEqual([
+                { path: '/topics/slug/life', options: undefined },
+                { path: '/topics/resource-id', options: { method: 'DELETE' } },
+            ]);
+            expect(stdout.data.join('')).toContain('resource-id');
+        }
+        finally {
+            stdout.restore();
+        }
+    });
+    it('deletes a topic directly by snowflake id', async () => {
+        const calls = [];
+        const stdout = captureStdout();
+        try {
+            const exit = await Effect.runPromiseExit(deleteTopic.handler({ slugOrId: '123456789012348', force: true }).pipe(Effect.provide(buildLayer(calls)), Renderer.withOptions(rendererJson)));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            expect(calls).toEqual([
+                { path: '/topics/123456789012348', options: { method: 'DELETE' } },
+            ]);
+        }
+        finally {
+            stdout.restore();
+        }
+    });
+    it('refuses topic delete without --force in non-TTY mode', async () => {
+        const descriptor = Object.getOwnPropertyDescriptor(process.stdin, 'isTTY');
+        Object.defineProperty(process.stdin, 'isTTY', {
+            configurable: true,
+            value: false,
+        });
+        try {
+            const exit = await Effect.runPromiseExit(deleteTopic.handler({ slugOrId: 'life', force: false }).pipe(Effect.provide(buildLayer([]))));
+            expect(Exit.isFailure(exit)).toBe(true);
+        }
+        finally {
+            if (descriptor)
+                Object.defineProperty(process.stdin, 'isTTY', descriptor);
+        }
+    });
+    it('patches a topic update body', async () => {
+        const calls = [];
+        const exit = await Effect.runPromiseExit(updateTopic
+            .handler({
+            slugOrId: 'life',
+            name: Option.some('Life'),
+            slug: Option.some('life-new'),
+            description: Option.some('desc'),
+            icon: Option.some('sparkles'),
+        })
+            .pipe(Effect.provide(buildLayer(calls)), Renderer.withOptions(rendererJson)));
+        expect(Exit.isSuccess(exit)).toBe(true);
+        expect(calls[0]).toEqual({ path: '/topics/slug/life', options: undefined });
+        expect(calls[1]).toMatchObject({
+            path: '/topics/resource-id',
+            options: { method: 'PATCH' },
+        });
+        expect(calls[1].options.body).toEqual({
+            name: 'Life',
+            slug: 'life-new',
+            description: 'desc',
+            icon: 'sparkles',
+        });
+    });
+});

package/dist/test/cli/profile/ls.test.d.ts

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

package/dist/test/cli/profile/ls.test.js

@@ -0,0 +1,93 @@
+import { Effect, Exit, Layer } from 'effect';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { ls } from '../../../src/cli/profile/ls';
+import { Config } from '../../../src/services/Config';
+import { Profile } from '../../../src/services/Profile';
+import { Renderer } from '../../../src/services/Renderer';
+import { makeMemFs, TestFsLive, TestPathLive } from '../../helper/test-fs';
+const XDG = '/xdg';
+const mxsDir = `${XDG}/mxs`;
+const profileDir = (name) => `${mxsDir}/profiles/${name}`;
+const buildHarness = () => {
+    const mem = makeMemFs();
+    const base = Layer.merge(TestFsLive(mem), TestPathLive);
+    const configLayer = Config.Default.pipe(Layer.provide(base));
+    const profileLayer = Profile.Default.pipe(Layer.provide(configLayer));
+    return {
+        mem,
+        layer: Layer.mergeAll(base, configLayer, profileLayer, Renderer.Default),
+    };
+};
+const captureStdout = () => {
+    const data = [];
+    const orig = process.stdout.write.bind(process.stdout);
+    process.stdout.write = (s) => {
+        data.push(typeof s === 'string' ? s : s.toString());
+        return true;
+    };
+    return {
+        data,
+        restore: () => {
+            ;
+            process.stdout.write = orig;
+        },
+    };
+};
+beforeEach(() => {
+    process.env.XDG_CONFIG_HOME = XDG;
+    delete process.env.MXS_PROFILE;
+});
+afterEach(() => {
+    delete process.env.XDG_CONFIG_HOME;
+});
+describe('profile ls command', () => {
+    it('emits an empty list when no profiles exist', async () => {
+        const { layer } = buildHarness();
+        const cap = captureStdout();
+        try {
+            const exit = await Effect.runPromiseExit(ls.handler({}).pipe(Effect.provide(layer), Renderer.withOptions({
+                json: true,
+                output: 'json',
+                quiet: false,
+                verbose: false,
+            })));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            const stdout = cap.data.join('');
+            expect(stdout).toContain('"ok":true');
+            expect(stdout).toContain('"data":[]');
+        }
+        finally {
+            cap.restore();
+        }
+    });
+    it('marks the active profile with a star', async () => {
+        const { mem, layer } = buildHarness();
+        mem.mkdir(profileDir('staging'));
+        mem.seed(`${profileDir('staging')}/config.json`, JSON.stringify({ api_url: 'https://stg.example.com', production: false }));
+        mem.mkdir(profileDir('prod'));
+        mem.seed(`${profileDir('prod')}/config.json`, JSON.stringify({ api_url: 'https://blog.example.com', production: true }));
+        mem.seed(`${mxsDir}/current`, 'prod\n', 0o644);
+        const cap = captureStdout();
+        try {
+            const exit = await Effect.runPromiseExit(ls.handler({}).pipe(Effect.provide(layer), Renderer.withOptions({
+                json: true,
+                output: 'json',
+                quiet: false,
+                verbose: false,
+            })));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            const stdout = cap.data.join('');
+            const parsed = JSON.parse(stdout.trim());
+            expect(parsed.ok).toBe(true);
+            const rows = parsed.data;
+            const byName = new Map(rows.map((r) => [r.name, r]));
+            expect(byName.get('prod')?.current).toBe('*');
+            expect(byName.get('staging')?.current).toBe('');
+            expect(byName.get('prod')?.production).toBe('yes');
+            expect(byName.get('staging')?.production).toBe('no');
+        }
+        finally {
+            cap.restore();
+        }
+    });
+});

package/dist/test/cli/profile/mark-use.test.d.ts

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

package/dist/test/cli/profile/mark-use.test.js

@@ -0,0 +1,216 @@
+import { Effect, Exit, Layer, Option } from 'effect';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { mark } from '../../../src/cli/profile/mark';
+import { rm } from '../../../src/cli/profile/rm';
+import { show } from '../../../src/cli/profile/show';
+import { use } from '../../../src/cli/profile/use';
+import { Editor } from '../../../src/services/Editor';
+import { Config } from '../../../src/services/Config';
+import { Profile } from '../../../src/services/Profile';
+import { Renderer } from '../../../src/services/Renderer';
+import { makeMemFs, TestFsLive, TestPathLive } from '../../helper/test-fs';
+const XDG = '/xdg';
+const mxsDir = `${XDG}/mxs`;
+const profileDir = (name) => `${mxsDir}/profiles/${name}`;
+const makeEditorMock = (overrides = {}) => ({
+    openEditor: () => Effect.succeed(''),
+    prompt: () => Effect.succeed(''),
+    confirm: () => Effect.succeed(true),
+    readFileOrStdin: () => Effect.succeed(''),
+    ...overrides,
+});
+const captureStdout = () => {
+    const data = [];
+    const orig = process.stdout.write.bind(process.stdout);
+    process.stdout.write = (s) => {
+        data.push(typeof s === 'string' ? s : s.toString());
+        return true;
+    };
+    return {
+        data,
+        restore: () => {
+            ;
+            process.stdout.write = orig;
+        },
+    };
+};
+const rendererJson = {
+    json: true,
+    output: 'json',
+    quiet: false,
+    verbose: false,
+};
+const buildHarness = (editorOverride = {}) => {
+    const mem = makeMemFs();
+    const base = Layer.merge(TestFsLive(mem), TestPathLive);
+    const configLayer = Config.Default.pipe(Layer.provide(base));
+    const profileLayer = Profile.Default.pipe(Layer.provide(configLayer));
+    const editorLayer = Layer.succeed(Editor, makeEditorMock(editorOverride));
+    return {
+        mem,
+        layer: Layer.mergeAll(base, configLayer, profileLayer, editorLayer, Renderer.Default),
+    };
+};
+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('profile use command', () => {
+    it('fails ProfileNotFound when the profile does not exist', async () => {
+        const { layer } = buildHarness();
+        const exit = await Effect.runPromiseExit(use.handler({ name: 'ghost' }).pipe(Effect.provide(layer)));
+        expect(Exit.isFailure(exit)).toBe(true);
+        if (Exit.isFailure(exit)) {
+            expect(tagOf(exit.cause)).toBe('ProfileNotFound');
+        }
+    });
+    it('writes the current pointer when the profile exists', async () => {
+        const { mem, layer } = buildHarness();
+        mem.mkdir(profileDir('staging'));
+        mem.seed(`${profileDir('staging')}/config.json`, JSON.stringify({}));
+        const exit = await Effect.runPromiseExit(use.handler({ name: 'staging' }).pipe(Effect.provide(layer)));
+        expect(Exit.isSuccess(exit)).toBe(true);
+        expect(mem.readFile(`${mxsDir}/current`)?.trim()).toBe('staging');
+    });
+});
+describe('profile mark command', () => {
+    it('fails ValidationFailed when neither --production nor --no-production is passed', async () => {
+        const { mem, layer } = buildHarness();
+        mem.mkdir(profileDir('staging'));
+        mem.seed(`${profileDir('staging')}/config.json`, JSON.stringify({}));
+        const exit = await Effect.runPromiseExit(mark
+            .handler({ name: 'staging', production: Option.none() })
+            .pipe(Effect.provide(layer)));
+        expect(Exit.isFailure(exit)).toBe(true);
+        if (Exit.isFailure(exit)) {
+            expect(tagOf(exit.cause)).toBe('ValidationFailed');
+        }
+    });
+    it('flips production: true on the profile config', async () => {
+        const { mem, layer } = buildHarness();
+        mem.mkdir(profileDir('staging'));
+        mem.seed(`${profileDir('staging')}/config.json`, JSON.stringify({ api_url: 'https://stg.example.com' }));
+        const exit = await Effect.runPromiseExit(mark
+            .handler({ name: 'staging', production: Option.some(true) })
+            .pipe(Effect.provide(layer)));
+        expect(Exit.isSuccess(exit)).toBe(true);
+        const cfg = JSON.parse(mem.readFile(`${profileDir('staging')}/config.json`) ?? '{}');
+        expect(cfg.production).toBe(true);
+        expect(cfg.api_url).toBe('https://stg.example.com');
+    });
+    it('strips production when --no-production is passed', async () => {
+        const { mem, layer } = buildHarness();
+        mem.mkdir(profileDir('staging'));
+        mem.seed(`${profileDir('staging')}/config.json`, JSON.stringify({ api_url: 'https://stg.example.com', production: true }));
+        const exit = await Effect.runPromiseExit(mark
+            .handler({ name: 'staging', production: Option.some(false) })
+            .pipe(Effect.provide(layer)));
+        expect(Exit.isSuccess(exit)).toBe(true);
+        const cfg = JSON.parse(mem.readFile(`${profileDir('staging')}/config.json`) ?? '{}');
+        expect(cfg.production).toBeUndefined();
+    });
+});
+describe('profile show command', () => {
+    it('fails when no profile name and no active profile exist', async () => {
+        const { layer } = buildHarness();
+        const exit = await Effect.runPromiseExit(show.handler({ name: Option.none() }).pipe(Effect.provide(layer)));
+        expect(Exit.isFailure(exit)).toBe(true);
+        if (Exit.isFailure(exit)) {
+            expect(tagOf(exit.cause)).toBe('ProfileNoneActive');
+        }
+    });
+    it('shows the active profile with credential metadata', async () => {
+        const { mem, layer } = buildHarness();
+        mem.mkdir(profileDir('prod'));
+        mem.seed(`${profileDir('prod')}/config.json`, JSON.stringify({ api_url: 'https://blog.example.com', production: true }));
+        mem.seed(`${profileDir('prod')}/credentials.json`, JSON.stringify({
+            access_token: 'TOK',
+            expires_at: 1_800_000_000_000,
+            user: { id: 'u1', email: 'owner@example.com' },
+        }), 0o600);
+        mem.seed(`${mxsDir}/current`, 'prod\n');
+        const cap = captureStdout();
+        try {
+            const exit = await Effect.runPromiseExit(show.handler({ name: Option.none() }).pipe(Effect.provide(layer), Renderer.withOptions(rendererJson)));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            const out = cap.data.join('');
+            expect(out).toContain('"name":"prod"');
+            expect(out).toContain('"authenticated":true');
+            expect(out).toContain('owner@example.com');
+        }
+        finally {
+            cap.restore();
+        }
+    });
+});
+describe('profile rm command', () => {
+    it('refuses to remove the active profile without --force', async () => {
+        const { mem, layer } = buildHarness();
+        mem.mkdir(profileDir('prod'));
+        mem.seed(`${profileDir('prod')}/config.json`, JSON.stringify({}));
+        mem.seed(`${mxsDir}/current`, 'prod\n');
+        const exit = await Effect.runPromiseExit(rm.handler({ name: 'prod', force: Option.none() }).pipe(Effect.provide(layer)));
+        expect(Exit.isFailure(exit)).toBe(true);
+        if (Exit.isFailure(exit)) {
+            expect(tagOf(exit.cause)).toBe('ValidationFailed');
+        }
+    });
+    it('removes the active profile with --force and clears current pointer', async () => {
+        const { mem, layer } = buildHarness();
+        mem.mkdir(profileDir('prod'));
+        mem.seed(`${profileDir('prod')}/config.json`, JSON.stringify({}));
+        mem.seed(`${mxsDir}/current`, 'prod\n');
+        const exit = await Effect.runPromiseExit(rm.handler({ name: 'prod', force: Option.some(true) }).pipe(Effect.provide(layer), Renderer.withOptions(rendererJson)));
+        expect(Exit.isSuccess(exit)).toBe(true);
+        expect(mem.has(profileDir('prod'))).toBe(false);
+        expect(mem.has(`${mxsDir}/current`)).toBe(false);
+    });
+    it('returns without removal when interactive confirmation is declined', async () => {
+        const { mem, layer } = buildHarness({
+            confirm: () => Effect.succeed(false),
+        });
+        mem.mkdir(profileDir('staging'));
+        mem.seed(`${profileDir('staging')}/config.json`, JSON.stringify({}));
+        const descriptor = Object.getOwnPropertyDescriptor(process.stdin, 'isTTY');
+        Object.defineProperty(process.stdin, 'isTTY', {
+            configurable: true,
+            value: true,
+        });
+        try {
+            const exit = await Effect.runPromiseExit(rm.handler({ name: 'staging', force: Option.none() }).pipe(Effect.provide(layer)));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            expect(mem.has(profileDir('staging'))).toBe(true);
+        }
+        finally {
+            if (descriptor)
+                Object.defineProperty(process.stdin, 'isTTY', descriptor);
+        }
+    });
+    it('refuses non-active removal without --force in non-TTY mode', async () => {
+        const { mem, layer } = buildHarness();
+        mem.mkdir(profileDir('staging'));
+        mem.seed(`${profileDir('staging')}/config.json`, JSON.stringify({}));
+        const descriptor = Object.getOwnPropertyDescriptor(process.stdin, 'isTTY');
+        Object.defineProperty(process.stdin, 'isTTY', {
+            configurable: true,
+            value: false,
+        });
+        try {
+            const exit = await Effect.runPromiseExit(rm.handler({ name: 'staging', force: Option.none() }).pipe(Effect.provide(layer)));
+            expect(Exit.isFailure(exit)).toBe(true);
+            if (Exit.isFailure(exit)) {
+                expect(tagOf(exit.cause)).toBe('ValidationFailed');
+            }
+        }
+        finally {
+            if (descriptor)
+                Object.defineProperty(process.stdin, 'isTTY', descriptor);
+        }
+    });
+});

package/dist/test/cli/project-crud.test.d.ts

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