@mx-space/cli 0.15.1 → 0.15.2

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

@@ -1,395 +0,0 @@
-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

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

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

@@ -1,126 +0,0 @@
-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

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

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

@@ -1,126 +0,0 @@
-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

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