@mx-space/cli 0.15.0 → 0.15.1

package/dist/test/cli/update.test.js

@@ -0,0 +1,395 @@
+import { Effect, Exit, Layer, Option } from 'effect';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { updateCmd as update } from '../../src/cli/update';
+import { UpdatePmUnknown } from '../../src/domain/errors';
+import { Editor } from '../../src/services/Editor';
+import { Renderer } from '../../src/services/Renderer';
+import * as UpdaterMod from '../../src/services/UpdateNotifier';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+const tagOf = (cause) => {
+    const err = cause?.error ?? cause?.failure ?? cause;
+    return err?._tag ?? err?.error?._tag ?? err?.failure?._tag;
+};
+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 captureStderr = () => {
+    const data = [];
+    const orig = process.stderr.write.bind(process.stderr);
+    process.stderr.write = (s) => {
+        data.push(typeof s === 'string' ? s : s.toString());
+        return true;
+    };
+    return {
+        data,
+        restore: () => {
+            ;
+            process.stderr.write = orig;
+        },
+    };
+};
+const makeEditor = (overrides = {}) => ({
+    openEditor: () => Effect.succeed(''),
+    prompt: () => Effect.succeed(''),
+    confirm: () => Effect.succeed(true),
+    readFileOrStdin: () => Effect.succeed(''),
+    ...overrides,
+});
+const buildLayer = (editorOverride = {}) => Layer.mergeAll(Renderer.Default, Layer.succeed(Editor, makeEditor(editorOverride)));
+beforeEach(() => {
+    vi.restoreAllMocks();
+});
+afterEach(() => {
+    vi.restoreAllMocks();
+});
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe('update command', () => {
+    it('emits up_to_date envelope when local >= registry latest', async () => {
+        vi.spyOn(UpdaterMod, 'make').mockReturnValue({
+            maybeNotify: () => Effect.void,
+            runUpdate: () => Effect.succeed({
+                fromVersion: '0.3.0',
+                toVersion: '0.3.0',
+                pm: 'pnpm',
+                channel: 'stable',
+                status: 0,
+                upgraded: false,
+                dryRun: true,
+                upToDate: true,
+            }),
+        });
+        const cap = captureStdout();
+        const errCap = captureStderr();
+        try {
+            const exit = await Effect.runPromiseExit(update
+                .handler({
+                check: Option.none(),
+                prerelease: Option.none(),
+                pm: Option.none(),
+                force: Option.none(),
+                yes: Option.some(true),
+            })
+                .pipe(Effect.provide(buildLayer()), Renderer.withOptions({
+                json: true,
+                output: 'json',
+                quiet: false,
+                verbose: false,
+            })));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            const stdout = cap.data.join('');
+            expect(stdout).toContain('"up_to_date":true');
+        }
+        finally {
+            cap.restore();
+            errCap.restore();
+        }
+    });
+    it('emits dry_run envelope when --check is set', async () => {
+        vi.spyOn(UpdaterMod, 'make').mockReturnValue({
+            maybeNotify: () => Effect.void,
+            runUpdate: (opts) => Effect.succeed({
+                fromVersion: opts.currentVersion,
+                toVersion: '0.4.0',
+                pm: 'npm',
+                channel: 'stable',
+                status: 0,
+                upgraded: false,
+                dryRun: true,
+                upToDate: false,
+            }),
+        });
+        const cap = captureStdout();
+        try {
+            const exit = await Effect.runPromiseExit(update
+                .handler({
+                check: Option.some(true),
+                prerelease: Option.none(),
+                pm: Option.none(),
+                force: Option.none(),
+                yes: Option.none(),
+            })
+                .pipe(Effect.provide(buildLayer()), 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);
+            expect(parsed.data.latest).toBe('0.4.0');
+            expect(parsed.data.up_to_date).toBe(false);
+        }
+        finally {
+            cap.restore();
+        }
+    });
+    it('emits upgraded envelope when runUpdate succeeds and an install ran', async () => {
+        vi.spyOn(UpdaterMod, 'make').mockReturnValue({
+            maybeNotify: () => Effect.void,
+            runUpdate: () => Effect.succeed({
+                fromVersion: '0.3.0',
+                toVersion: '0.4.0',
+                pm: 'pnpm',
+                channel: 'stable',
+                status: 0,
+                upgraded: true,
+                dryRun: false,
+                upToDate: false,
+                command: 'pnpm add -g @mx-space/cli@latest',
+            }),
+        });
+        const cap = captureStdout();
+        try {
+            const exit = await Effect.runPromiseExit(update
+                .handler({
+                check: Option.none(),
+                prerelease: Option.none(),
+                pm: Option.none(),
+                force: Option.none(),
+                yes: Option.some(true),
+            })
+                .pipe(Effect.provide(buildLayer()), Renderer.withOptions({
+                json: true,
+                output: 'json',
+                quiet: false,
+                verbose: false,
+            })));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            const parsed = JSON.parse(cap.data.join('').trim());
+            expect(parsed.data.upgraded).toBe(true);
+            expect(parsed.data.latest).toBe('0.4.0');
+        }
+        finally {
+            cap.restore();
+        }
+    });
+    it('passes option flags through and emits cancelled envelope', async () => {
+        const runUpdate = vi.fn((opts) => {
+            const channel = opts.prerelease ? 'next' : 'stable';
+            return Effect.succeed({
+                fromVersion: opts.currentVersion,
+                toVersion: '0.4.0',
+                pm: opts.pm,
+                channel,
+                status: 0,
+                upgraded: false,
+                dryRun: true,
+                upToDate: false,
+                command: 'pnpm add -g @mx-space/cli@next',
+                cancelled: true,
+            });
+        });
+        vi.spyOn(UpdaterMod, 'make').mockReturnValue({
+            maybeNotify: () => Effect.void,
+            runUpdate,
+        });
+        const cap = captureStdout();
+        try {
+            const exit = await Effect.runPromiseExit(update
+                .handler({
+                check: Option.none(),
+                prerelease: Option.some(true),
+                pm: Option.some('pnpm'),
+                force: Option.some(true),
+                yes: Option.some(false),
+            })
+                .pipe(Effect.provide(buildLayer()), Renderer.withOptions({
+                json: true,
+                output: 'json',
+                quiet: false,
+                verbose: false,
+            })));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            expect(runUpdate).toHaveBeenCalledWith(expect.objectContaining({
+                prerelease: true,
+                pm: 'pnpm',
+                force: true,
+                yes: false,
+                json: true,
+            }));
+            const parsed = JSON.parse(cap.data.join('').trim());
+            expect(parsed.data).toMatchObject({
+                latest: '0.4.0',
+                pm: 'pnpm',
+                cancelled: true,
+            });
+        }
+        finally {
+            cap.restore();
+        }
+    });
+    it('runs the upgrade without prompting (auto-install default)', async () => {
+        let confirmImplPassed = 'sentinel';
+        vi.spyOn(UpdaterMod, 'make').mockImplementation((deps = {}) => {
+            confirmImplPassed = deps.confirmImpl;
+            return {
+                maybeNotify: () => Effect.void,
+                runUpdate: () => Effect.succeed({
+                    fromVersion: '0.3.0',
+                    toVersion: '0.4.0',
+                    pm: 'npm',
+                    channel: 'stable',
+                    status: 0,
+                    upgraded: true,
+                    dryRun: false,
+                    upToDate: false,
+                    command: 'npm install -g @mx-space/cli@latest',
+                }),
+            };
+        });
+        const cap = captureStdout();
+        try {
+            const exit = await Effect.runPromiseExit(update
+                .handler({
+                check: Option.none(),
+                prerelease: Option.none(),
+                pm: Option.none(),
+                force: Option.none(),
+                yes: Option.none(),
+            })
+                .pipe(Effect.provide(buildLayer()), Renderer.withOptions({
+                json: true,
+                output: 'json',
+                quiet: false,
+                verbose: false,
+            })));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            // The controller no longer threads Editor.confirm into the notifier —
+            // updates proceed without a prompt.
+            expect(confirmImplPassed).toBeUndefined();
+            const parsed = JSON.parse(cap.data.join('').trim());
+            expect(parsed.data).toMatchObject({ upgraded: true, latest: '0.4.0' });
+        }
+        finally {
+            cap.restore();
+        }
+    });
+    it('emits dry_run command envelope when no install ran outside --check', async () => {
+        vi.spyOn(UpdaterMod, 'make').mockReturnValue({
+            maybeNotify: () => Effect.void,
+            runUpdate: () => Effect.succeed({
+                fromVersion: '0.3.0',
+                toVersion: '0.4.0',
+                pm: 'npm',
+                channel: 'stable',
+                status: 0,
+                upgraded: false,
+                dryRun: true,
+                upToDate: false,
+                command: 'npm install -g @mx-space/cli@latest',
+            }),
+        });
+        const cap = captureStdout();
+        try {
+            const exit = await Effect.runPromiseExit(update
+                .handler({
+                check: Option.none(),
+                prerelease: Option.none(),
+                pm: Option.none(),
+                force: Option.none(),
+                yes: Option.none(),
+            })
+                .pipe(Effect.provide(buildLayer()), Renderer.withOptions({
+                json: true,
+                output: 'json',
+                quiet: false,
+                verbose: false,
+            })));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            const parsed = JSON.parse(cap.data.join('').trim());
+            expect(parsed.data).toMatchObject({
+                command: 'npm install -g @mx-space/cli@latest',
+                dry_run: true,
+            });
+        }
+        finally {
+            cap.restore();
+        }
+    });
+    it('surfaces UpdatePmUnknown when the underlying service fails', async () => {
+        vi.spyOn(UpdaterMod, 'make').mockReturnValue({
+            maybeNotify: () => Effect.void,
+            runUpdate: () => Effect.fail(new UpdatePmUnknown({
+                message: "unknown package manager 'foo'",
+                hint: 'supported values: npm | pnpm | yarn | bun',
+            })),
+        });
+        const exit = await Effect.runPromiseExit(update
+            .handler({
+            check: Option.none(),
+            prerelease: Option.none(),
+            pm: Option.some('npm'),
+            force: Option.none(),
+            yes: Option.some(true),
+        })
+            .pipe(Effect.provide(buildLayer()), Renderer.withOptions({
+            json: true,
+            output: 'json',
+            quiet: false,
+            verbose: false,
+        })));
+        expect(Exit.isFailure(exit)).toBe(true);
+        if (Exit.isFailure(exit)) {
+            expect(tagOf(exit.cause)).toBe('UpdatePmUnknown');
+        }
+    });
+    it('emits an informational up-to-date line for non-json output', async () => {
+        vi.spyOn(UpdaterMod, 'make').mockReturnValue({
+            maybeNotify: () => Effect.void,
+            runUpdate: () => Effect.succeed({
+                fromVersion: '0.3.0',
+                toVersion: '0.3.0',
+                pm: 'npm',
+                channel: 'stable',
+                status: 0,
+                upgraded: false,
+                dryRun: true,
+                upToDate: true,
+            }),
+        });
+        const cap = captureStdout();
+        const errCap = captureStderr();
+        try {
+            const exit = await Effect.runPromiseExit(update
+                .handler({
+                check: Option.none(),
+                prerelease: Option.none(),
+                pm: Option.none(),
+                force: Option.none(),
+                yes: Option.some(true),
+            })
+                .pipe(Effect.provide(buildLayer()), Renderer.withOptions({
+                json: false,
+                output: 'readable',
+                quiet: false,
+                verbose: false,
+            })));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            const stdout = cap.data.join('');
+            expect(stdout).toContain('up to date');
+            expect(stdout).toContain('0.3.0');
+        }
+        finally {
+            cap.restore();
+            errCap.restore();
+        }
+    });
+});

package/dist/test/domain/content-spec.test.d.ts

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

package/dist/test/domain/content-spec.test.js

@@ -0,0 +1,126 @@
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { NodeContext } from '@effect/platform-node';
+import { Effect } from 'effect';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { readContentSpec, readJsonSpec } from '../../src/domain/content-spec';
+let tmpDir;
+beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mxs-content-spec-'));
+});
+const run = (eff) => Effect.runPromise(Effect.provide(eff, NodeContext.layer));
+describe('readContentSpec', () => {
+    it('returns null when no content spec is provided', async () => {
+        await expect(run(readContentSpec(undefined))).resolves.toBeNull();
+    });
+    it('treats ordinary values as inline content', async () => {
+        await expect(run(readContentSpec('plain text'))).resolves.toEqual({
+            text: 'plain text',
+            origin: 'inline',
+        });
+    });
+    it('reads file= paths relative to the provided cwd', async () => {
+        await fs.writeFile(path.join(tmpDir, 'body.md'), '# title\n', 'utf8');
+        await expect(run(readContentSpec('file=body.md', { cwd: tmpDir }))).resolves.toEqual({
+            text: '# title\n',
+            origin: 'file',
+            path: path.join(tmpDir, 'body.md'),
+        });
+    });
+    it('wraps file read failures as ValidationFailed', async () => {
+        const err = await run(Effect.flip(readContentSpec('file=missing.md', { cwd: tmpDir })));
+        expect(err._tag).toBe('ValidationFailed');
+        expect(err.message).toContain('failed to read');
+    });
+    it('rejects stdin specs when stdin is a TTY', async () => {
+        const descriptor = Object.getOwnPropertyDescriptor(process.stdin, 'isTTY');
+        Object.defineProperty(process.stdin, 'isTTY', {
+            configurable: true,
+            value: true,
+        });
+        try {
+            const err = await run(Effect.flip(readContentSpec('-')));
+            expect(err._tag).toBe('ValidationFailed');
+            expect(err.message).toContain('stdin is a TTY');
+        }
+        finally {
+            if (descriptor)
+                Object.defineProperty(process.stdin, 'isTTY', descriptor);
+        }
+    });
+    it('reads stdin specs when stdin is a stream', async () => {
+        const descriptor = Object.getOwnPropertyDescriptor(process, 'stdin');
+        const fakeStdin = {
+            isTTY: false,
+            async *[Symbol.asyncIterator]() {
+                yield 'hello ';
+                yield Buffer.from('world');
+            },
+        };
+        Object.defineProperty(process, 'stdin', {
+            configurable: true,
+            value: fakeStdin,
+        });
+        try {
+            await expect(run(readContentSpec('stdin'))).resolves.toEqual({
+                text: 'hello world',
+                origin: 'stdin',
+            });
+        }
+        finally {
+            if (descriptor)
+                Object.defineProperty(process, 'stdin', descriptor);
+        }
+    });
+    it('wraps stdin read failures as ValidationFailed', async () => {
+        const descriptor = Object.getOwnPropertyDescriptor(process, 'stdin');
+        const fakeStdin = {
+            isTTY: false,
+            async *[Symbol.asyncIterator]() {
+                throw 'stream failed';
+            },
+        };
+        Object.defineProperty(process, 'stdin', {
+            configurable: true,
+            value: fakeStdin,
+        });
+        try {
+            const err = await run(Effect.flip(readContentSpec('-')));
+            expect(err._tag).toBe('ValidationFailed');
+            expect(err.message).toContain('stream failed');
+        }
+        finally {
+            if (descriptor)
+                Object.defineProperty(process, 'stdin', descriptor);
+        }
+    });
+});
+describe('readJsonSpec', () => {
+    it('returns undefined when no JSON spec is provided', async () => {
+        await expect(run(readJsonSpec(undefined))).resolves.toBeUndefined();
+    });
+    it('parses inline JSON', async () => {
+        await expect(run(readJsonSpec('{"a":1}'))).resolves.toEqual({ a: 1 });
+    });
+    it('parses JSON from file=', async () => {
+        const filePath = path.join(tmpDir, 'meta.json');
+        await fs.writeFile(filePath, '{"tags":["a","b"]}', 'utf8');
+        await expect(run(readJsonSpec(`file=${filePath}`))).resolves.toEqual({
+            tags: ['a', 'b'],
+        });
+    });
+    it('reports invalid inline and file JSON as ValidationFailed', async () => {
+        const inlineErr = await run(Effect.flip(readJsonSpec('{')));
+        expect(inlineErr._tag).toBe('ValidationFailed');
+        const filePath = path.join(tmpDir, 'bad.json');
+        await fs.writeFile(filePath, '{', 'utf8');
+        const fileErr = await run(Effect.flip(readJsonSpec(`file=${filePath}`)));
+        expect(fileErr._tag).toBe('ValidationFailed');
+    });
+    it('wraps file read failures for JSON specs', async () => {
+        const err = await run(Effect.flip(readJsonSpec(`file=${path.join(tmpDir, 'missing.json')}`)));
+        expect(err._tag).toBe('ValidationFailed');
+        expect(err.message).toContain('failed to read JSON');
+    });
+});

package/dist/test/domain/envelope-compat.test.d.ts

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

package/dist/test/domain/envelope-compat.test.js

@@ -0,0 +1,126 @@
+import { describe, expect, it } from 'vitest';
+import { detectWireVersion, normalizeErrorBody, normalizeSuccessBody, } from '../../src/domain/envelope-compat';
+describe('detectWireVersion', () => {
+    it('classifies V3 success envelope with meta', () => {
+        expect(detectWireVersion({ data: [], meta: {} })).toBe('v3');
+    });
+    it('classifies V3 error envelope by error.code', () => {
+        expect(detectWireVersion({ error: { code: 'POST_NOT_FOUND' } })).toBe('v3');
+    });
+    it('classifies V3 error envelope by error.message', () => {
+        expect(detectWireVersion({ error: { message: 'not found' } })).toBe('v3');
+    });
+    it('classifies V2 paginated body via root pagination', () => {
+        expect(detectWireVersion({
+            data: [],
+            pagination: { page: 1, size: 10, total: 0 },
+        })).toBe('v2');
+    });
+    it('classifies V2 error by root-level string message', () => {
+        expect(detectWireVersion({ message: 'oops' })).toBe('v2');
+    });
+    it('classifies V2 error by root-level array message', () => {
+        expect(detectWireVersion({ message: ['a', 'b'] })).toBe('v2');
+    });
+    it('returns null for scalar / null / array / non-object', () => {
+        expect(detectWireVersion(null)).toBeNull();
+        expect(detectWireVersion(42)).toBeNull();
+        expect(detectWireVersion('plain text')).toBeNull();
+        expect(detectWireVersion([1, 2, 3])).toBeNull();
+        expect(detectWireVersion(undefined)).toBeNull();
+    });
+    it('prefers V3 when both V2 and V3 markers are present', () => {
+        expect(detectWireVersion({
+            data: [],
+            pagination: { page: 1 },
+            meta: { pagination: { page: 1 } },
+        })).toBe('v3');
+    });
+    it('returns null for an empty object', () => {
+        expect(detectWireVersion({})).toBeNull();
+    });
+});
+describe('normalizeSuccessBody', () => {
+    it('passes V3 envelope through unchanged', () => {
+        const input = { data: [{ id: '1' }], meta: { pagination: { page: 1 } } };
+        expect(normalizeSuccessBody(input)).toBe(input);
+    });
+    it('lifts V2 root pagination under meta', () => {
+        const input = {
+            data: [{ id: '1' }],
+            pagination: { page: 1, size: 10, total: 5 },
+        };
+        expect(normalizeSuccessBody(input)).toEqual({
+            data: [{ id: '1' }],
+            meta: { pagination: { page: 1, size: 10, total: 5 } },
+        });
+    });
+    it('passes a bare V2 { data } envelope through unchanged', () => {
+        const input = { data: { id: '1', title: 'hi' } };
+        expect(normalizeSuccessBody(input)).toBe(input);
+    });
+    it('passes a scalar / null / array through unchanged', () => {
+        expect(normalizeSuccessBody(42)).toBe(42);
+        expect(normalizeSuccessBody(null)).toBe(null);
+        const arr = [1, 2, 3];
+        expect(normalizeSuccessBody(arr)).toBe(arr);
+    });
+    it('passes an already-unwrapped document (no data key) through unchanged', () => {
+        const input = { id: '1', title: 'already unwrapped' };
+        expect(normalizeSuccessBody(input)).toBe(input);
+    });
+    it('does not mutate the input', () => {
+        const input = { data: [], pagination: { page: 1 } };
+        const snapshot = JSON.parse(JSON.stringify(input));
+        normalizeSuccessBody(input);
+        expect(input).toEqual(snapshot);
+    });
+});
+describe('normalizeErrorBody', () => {
+    it('unwraps a V3 error envelope', () => {
+        expect(normalizeErrorBody({
+            error: {
+                code: 'POST_NOT_FOUND',
+                message: 'post not found',
+                details: { id: 'p1' },
+            },
+        })).toEqual({
+            code: 'POST_NOT_FOUND',
+            message: 'post not found',
+            details: { id: 'p1' },
+        });
+    });
+    it('flattens a V2 string-message error', () => {
+        expect(normalizeErrorBody({ message: 'oops', code: 'BAD' })).toEqual({
+            code: 'BAD',
+            message: 'oops',
+            details: undefined,
+        });
+    });
+    it('joins a V2 array-message error with "; "', () => {
+        expect(normalizeErrorBody({ message: ['a', 'b'] })).toEqual({
+            code: undefined,
+            message: 'a; b',
+            details: undefined,
+        });
+    });
+    it('returns empty object for non-object body', () => {
+        expect(normalizeErrorBody(null)).toEqual({});
+        expect(normalizeErrorBody(42)).toEqual({});
+        expect(normalizeErrorBody('plain')).toEqual({});
+        expect(normalizeErrorBody([1, 2, 3])).toEqual({});
+    });
+    it('preserves V2 details if present', () => {
+        expect(normalizeErrorBody({ message: 'x', details: { field: 'y' } })).toEqual({ code: undefined, message: 'x', details: { field: 'y' } });
+    });
+    it('ignores non-string V2 message', () => {
+        expect(normalizeErrorBody({ message: 42 })).toEqual({
+            code: undefined,
+            message: undefined,
+            details: undefined,
+        });
+    });
+    it('ignores non-string V3 error.code / error.message', () => {
+        expect(normalizeErrorBody({ error: { code: 42, message: { x: 1 } } })).toEqual({ code: undefined, message: undefined, details: undefined });
+    });
+});

package/dist/test/domain/envelope.test.d.ts

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