@mx-space/cli 0.14.2 → 0.15.1

package/dist/test/cli/config/config.test.js

@@ -0,0 +1,281 @@
+import { Effect, Exit, Layer, Option } from 'effect';
+import { describe, expect, it } from 'vitest';
+import { edit } from '../../../src/cli/config/edit';
+import { get } from '../../../src/cli/config/get';
+import { list } from '../../../src/cli/config/list';
+import { set } from '../../../src/cli/config/set';
+import { Auth } from '../../../src/services/Auth';
+import { Config, } from '../../../src/services/Config';
+import { Api } from '../../../src/services/Api';
+import { Editor } from '../../../src/services/Editor';
+import { Renderer } from '../../../src/services/Renderer';
+import { testHttpLayer } from '../../helper/test-http';
+// ---------------------------------------------------------------------------
+// Test fixtures
+// ---------------------------------------------------------------------------
+const baseResolved = {
+    apiUrl: 'https://blog.example.com',
+    apiBase: 'https://blog.example.com/api/v2',
+    authBase: 'https://blog.example.com/api/v2/auth',
+    apiVersion: 2,
+    clientId: 'mxs-cli',
+    configPath: '/tmp/config.json',
+    credentialsPath: '/tmp/credentials.json',
+    profileName: 'dev',
+    isProduction: false,
+    profileExplicit: false,
+    urlOverridden: false,
+};
+const mockConfigLayer = (resolved, creds = null) => {
+    const service = {
+        getConfigDir: Effect.succeed('/tmp'),
+        getProfilesDir: Effect.succeed('/tmp/profiles'),
+        getProfileDir: (name) => Effect.succeed(`/tmp/profiles/${name}`),
+        getProfileConfigPath: (name) => Effect.succeed(`/tmp/profiles/${name}/config.json`),
+        getProfileCredentialsPath: (name) => Effect.succeed(`/tmp/profiles/${name}/credentials.json`),
+        getCurrentPath: Effect.succeed('/tmp/current'),
+        getLegacyConfigPath: Effect.succeed('/tmp/config.json'),
+        getLegacyCredentialsPath: Effect.succeed('/tmp/credentials.json'),
+        readProfileConfig: () => Effect.succeed({}),
+        writeProfileConfig: () => Effect.void,
+        updateProfileConfig: () => Effect.succeed({}),
+        readProfileCredentials: () => Effect.succeed(creds),
+        writeProfileCredentials: () => Effect.void,
+        deleteProfileCredentials: () => Effect.void,
+        readLegacyConfig: Effect.succeed({}),
+        readLegacyConfigRaw: Effect.succeed(null),
+        readLegacyCredentialsRaw: Effect.succeed(null),
+        deleteLegacyConfig: Effect.void,
+        deleteLegacyCredentials: Effect.void,
+        readCurrent: Effect.succeed(resolved.profileName),
+        writeCurrent: () => Effect.void,
+        listProfileDirs: Effect.succeed([]),
+        profileExists: () => Effect.succeed(true),
+        removeProfileDir: () => Effect.void,
+        resolve: () => Effect.succeed(resolved),
+    };
+    return Layer.succeed(Config, service);
+};
+const mockAuthLayer = () => Layer.succeed(Auth, {
+    probe: () => Effect.die('probe not used'),
+    requestDeviceCode: () => Effect.die('requestDeviceCode not used'),
+    pollDeviceToken: () => Effect.die('pollDeviceToken not used'),
+    refresh: () => Effect.succeed(null),
+    login: () => Effect.die('login not used'),
+    logout: () => Effect.void,
+    whoami: Effect.die('whoami not used'),
+    status: Effect.die('status not used'),
+    ensureFresh: () => Effect.die('ensureFresh not used'),
+    enrichUser: (_profile, _authBase, cred) => Effect.succeed(cred),
+});
+const mockEditorLayer = (overrides = {}) => Layer.succeed(Editor, {
+    openEditor: () => Effect.succeed(''),
+    prompt: () => Effect.succeed(''),
+    confirm: () => Effect.succeed(true),
+    readFileOrStdin: () => Effect.succeed(''),
+    ...overrides,
+});
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe('config list command', () => {
+    it('GETs /options and emits raw body', async () => {
+        const http = testHttpLayer({
+            'GET https://blog.example.com/api/v2/options': {
+                status: 200,
+                body: { site_url: 'https://example.com', enable_comments: true },
+            },
+        });
+        const layer = Layer.mergeAll(Api.layer({ quiet: true }).pipe(Layer.provide(mockConfigLayer(baseResolved)), Layer.provide(mockAuthLayer()), Layer.provide(http.layer)), Renderer.Default);
+        const exit = await Effect.runPromiseExit(list.handler({}).pipe(Effect.provide(layer)));
+        expect(Exit.isSuccess(exit)).toBe(true);
+        expect(http.recorder.calls.length).toBe(1);
+        expect(http.recorder.calls[0]?.method).toBe('GET');
+    });
+});
+describe('config get command', () => {
+    it('GETs /options/:key with url-encoded key', async () => {
+        const http = testHttpLayer({
+            'GET https://blog.example.com/api/v2/options/site%2Furl': {
+                status: 200,
+                body: 'https://example.com',
+            },
+        });
+        const layer = Layer.mergeAll(Api.layer({ quiet: true }).pipe(Layer.provide(mockConfigLayer(baseResolved)), Layer.provide(mockAuthLayer()), Layer.provide(http.layer)), Renderer.Default);
+        const exit = await Effect.runPromiseExit(get.handler({ key: 'site/url' }).pipe(Effect.provide(layer)));
+        expect(Exit.isSuccess(exit)).toBe(true);
+    });
+});
+describe('config set command', () => {
+    it('coerces JSON by default and PATCHes /options/:key', async () => {
+        const http = testHttpLayer({
+            'PATCH https://blog.example.com/api/v2/options/feature': {
+                status: 200,
+                body: { ok: true },
+            },
+        });
+        const layer = Layer.mergeAll(Api.layer({ quiet: true }).pipe(Layer.provide(mockConfigLayer({
+            ...baseResolved,
+            profileExplicit: true,
+        })), Layer.provide(mockAuthLayer()), Layer.provide(http.layer)), Renderer.Default);
+        const exit = await Effect.runPromiseExit(set
+            .handler({
+            key: 'feature',
+            value: '{"on":true}',
+            type: Option.none(),
+        })
+            .pipe(Effect.provide(layer)));
+        expect(Exit.isSuccess(exit)).toBe(true);
+        expect(http.recorder.calls[0]?.body).toEqual({ on: true });
+    });
+    it('coerces explicit --type number and rejects NaN', async () => {
+        const http = testHttpLayer({
+            'PATCH https://blog.example.com/api/v2/options/count': {
+                status: 200,
+                body: { ok: true },
+            },
+        });
+        const layer = Layer.mergeAll(Api.layer({ quiet: true }).pipe(Layer.provide(mockConfigLayer({
+            ...baseResolved,
+            profileExplicit: true,
+        })), Layer.provide(mockAuthLayer()), Layer.provide(http.layer)), Renderer.Default);
+        const numOk = await Effect.runPromiseExit(set
+            .handler({
+            key: 'count',
+            value: '42',
+            type: Option.some('number'),
+        })
+            .pipe(Effect.provide(layer)));
+        expect(Exit.isSuccess(numOk)).toBe(true);
+        expect(http.recorder.calls[0]?.body).toBe(42);
+        const numBad = await Effect.runPromiseExit(set
+            .handler({
+            key: 'count',
+            value: 'not-a-number',
+            type: Option.some('number'),
+        })
+            .pipe(Effect.provide(layer)));
+        expect(Exit.isFailure(numBad)).toBe(true);
+        if (Exit.isFailure(numBad)) {
+            const err = numBad.cause._tag === 'Fail' ? numBad.cause.error : null;
+            expect(err?._tag).toBe('ValidationFailed');
+        }
+    });
+    it('coerces bool, string, explicit JSON failure, and implicit string fallback', async () => {
+        const http = testHttpLayer({
+            'PATCH https://blog.example.com/api/v2/options/flag': {
+                status: 200,
+                body: { ok: true },
+            },
+            'PATCH https://blog.example.com/api/v2/options/name': {
+                status: 200,
+                body: { ok: true },
+            },
+            'PATCH https://blog.example.com/api/v2/options/raw': {
+                status: 200,
+                body: { ok: true },
+            },
+        });
+        const layer = Layer.mergeAll(Api.layer({ quiet: true }).pipe(Layer.provide(mockConfigLayer({
+            ...baseResolved,
+            profileExplicit: true,
+        })), Layer.provide(mockAuthLayer()), Layer.provide(http.layer)), Renderer.Default);
+        await Effect.runPromise(set
+            .handler({
+            key: 'flag',
+            value: 'true',
+            type: Option.some('bool'),
+        })
+            .pipe(Effect.provide(layer)));
+        await Effect.runPromise(set
+            .handler({
+            key: 'name',
+            value: '{"literal":true}',
+            type: Option.some('string'),
+        })
+            .pipe(Effect.provide(layer)));
+        await Effect.runPromise(set
+            .handler({
+            key: 'raw',
+            value: 'not-json',
+            type: Option.none(),
+        })
+            .pipe(Effect.provide(layer)));
+        expect(http.recorder.calls.map((c) => c.body)).toEqual([
+            true,
+            '{"literal":true}',
+            'not-json',
+        ]);
+        const jsonBad = await Effect.runPromiseExit(set
+            .handler({
+            key: 'raw',
+            value: 'not-json',
+            type: Option.some('json'),
+        })
+            .pipe(Effect.provide(layer)));
+        expect(Exit.isFailure(jsonBad)).toBe(true);
+    });
+});
+describe('config edit command', () => {
+    it('emits info when editor returns unchanged content', async () => {
+        const initial = JSON.stringify({ site_url: 'https://example.com' }, null, 2);
+        const http = testHttpLayer({
+            'GET https://blog.example.com/api/v2/options': {
+                status: 200,
+                body: { site_url: 'https://example.com' },
+            },
+        });
+        const layer = Layer.mergeAll(Api.layer({ quiet: true }).pipe(Layer.provide(mockConfigLayer(baseResolved)), Layer.provide(mockAuthLayer()), Layer.provide(http.layer)), Renderer.Default, mockEditorLayer({
+            openEditor: () => Effect.succeed(initial),
+        }));
+        const exit = await Effect.runPromiseExit(edit.handler({}).pipe(Effect.provide(layer)));
+        expect(Exit.isSuccess(exit)).toBe(true);
+        // Only the initial GET — no PATCH because nothing changed.
+        expect(http.recorder.calls.length).toBe(1);
+    });
+    it('patches every changed option after editor JSON changes', async () => {
+        const http = testHttpLayer({
+            'GET https://blog.example.com/api/v2/options': {
+                status: 200,
+                body: { site_url: 'https://example.com', enable_comments: true },
+            },
+            'PATCH https://blog.example.com/api/v2/options/site_url': {
+                status: 200,
+                body: { ok: true },
+            },
+            'PATCH https://blog.example.com/api/v2/options/enable_comments': {
+                status: 200,
+                body: { ok: true },
+            },
+        });
+        const layer = Layer.mergeAll(Api.layer({ quiet: true }).pipe(Layer.provide(mockConfigLayer({
+            ...baseResolved,
+            profileExplicit: true,
+        })), Layer.provide(mockAuthLayer()), Layer.provide(http.layer)), Renderer.Default, mockEditorLayer({
+            openEditor: () => Effect.succeed(JSON.stringify({ site_url: 'https://new.example.com', enable_comments: false }, null, 2)),
+        }));
+        const exit = await Effect.runPromiseExit(edit.handler({}).pipe(Effect.provide(layer)));
+        expect(Exit.isSuccess(exit)).toBe(true);
+        expect(http.recorder.calls.map((c) => c.method)).toEqual([
+            'GET',
+            'PATCH',
+            'PATCH',
+        ]);
+        expect(http.recorder.calls[1]?.body).toBe('https://new.example.com');
+        expect(http.recorder.calls[2]?.body).toBe(false);
+    });
+    it('rejects invalid editor JSON', async () => {
+        const http = testHttpLayer({
+            'GET https://blog.example.com/api/v2/options': {
+                status: 200,
+                body: { site_url: 'https://example.com' },
+            },
+        });
+        const layer = Layer.mergeAll(Api.layer({ quiet: true }).pipe(Layer.provide(mockConfigLayer(baseResolved)), Layer.provide(mockAuthLayer()), Layer.provide(http.layer)), Renderer.Default, mockEditorLayer({
+            openEditor: () => Effect.succeed('{'),
+        }));
+        const exit = await Effect.runPromiseExit(edit.handler({}).pipe(Effect.provide(layer)));
+        expect(Exit.isFailure(exit)).toBe(true);
+        expect(http.recorder.calls.length).toBe(1);
+    });
+});

package/dist/test/cli/edit-roundtrip.test.d.ts

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

package/dist/test/cli/edit-roundtrip.test.js

@@ -0,0 +1,259 @@
+import { Effect, Exit, Layer, Option } from 'effect';
+import { describe, expect, it, vi } from 'vitest';
+import { edit as editNote } from '../../src/cli/note/edit';
+import { edit as editPage } from '../../src/cli/page/edit';
+import { edit as editPost } from '../../src/cli/post/edit';
+import { Api } from '../../src/services/Api';
+import { Editor } from '../../src/services/Editor';
+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 none = () => Option.none();
+const makeApi = (calls) => ({
+    request: (path) => Effect.sync(() => {
+        calls.push(path);
+        if (path.startsWith('/notes/')) {
+            return {
+                id: '123456789012346',
+                title: 'Note',
+                slug: 'note',
+                contentFormat: 'markdown',
+                content: 'note body',
+                isPublished: false,
+                mood: 'calm',
+                weather: 'clear',
+            };
+        }
+        if (path.startsWith('/pages/')) {
+            return {
+                id: '123456789012347',
+                title: 'Page',
+                slug: 'page',
+                contentFormat: 'markdown',
+                content: 'page body',
+            };
+        }
+        return {
+            id: '123456789012345',
+            title: 'Post',
+            slug: 'post',
+            contentFormat: 'markdown',
+            content: 'post body',
+            summary: 'summary',
+            isPublished: true,
+            tags: ['a', 'b'],
+        };
+    }),
+    raw: (path) => Effect.sync(() => {
+        calls.push(path);
+        return {};
+    }),
+});
+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/post'),
+    resolveNoteId: () => Effect.succeed('123456789012346'),
+    resolveCategoryId: () => Effect.succeed('cat-id'),
+    resolveProjectId: () => Effect.succeed('123456789012347'),
+    invalidate: () => Effect.void,
+});
+const makeEditor = (edit = (initial) => initial) => ({
+    openEditor: (opts) => Effect.succeed(edit(opts.initialContent)),
+    prompt: () => Effect.succeed(''),
+    confirm: () => Effect.succeed(true),
+    readFileOrStdin: () => Effect.succeed(''),
+});
+const buildLayer = (calls, edit) => Layer.mergeAll(TestFsLive(makeMemFs()), TestPathLive, Layer.succeed(Api, makeApi(calls)), Layer.succeed(Resolver, makeResolver()), Layer.succeed(Editor, makeEditor(edit)), Renderer.Default, Lexical.Default);
+const commonPostOptions = {
+    title: none(),
+    slug: none(),
+    category: none(),
+    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,
+};
+const commonNoteOptions = {
+    title: none(),
+    slug: none(),
+    topic: none(),
+    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,
+};
+const commonPageOptions = {
+    title: none(),
+    slug: none(),
+    subtitle: none(),
+    order: none(),
+    content: none(),
+    format: none(),
+    meta: none(),
+    file: none(),
+    open: false,
+    silent: false,
+};
+describe('edit command no-change round trip', () => {
+    it('post edit exits without update when editor content is unchanged', async () => {
+        const calls = [];
+        const stderr = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        try {
+            const exit = await Effect.runPromiseExit(editPost
+                .handler({ slugOrId: 'post', ...commonPostOptions })
+                .pipe(Effect.provide(buildLayer(calls))));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            expect(calls).toEqual(['/posts/post']);
+        }
+        finally {
+            stderr.mockRestore();
+        }
+    });
+    it('note edit exits without update when editor content is unchanged', async () => {
+        const calls = [];
+        const stderr = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        try {
+            const exit = await Effect.runPromiseExit(editNote
+                .handler({ slugOrId: 'note', ...commonNoteOptions })
+                .pipe(Effect.provide(buildLayer(calls))));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            expect(calls).toEqual(['/notes/123456789012346']);
+        }
+        finally {
+            stderr.mockRestore();
+        }
+    });
+    it('page edit exits without update when editor content is unchanged', async () => {
+        const calls = [];
+        const stderr = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        try {
+            const exit = await Effect.runPromiseExit(editPage
+                .handler({ slugOrId: '123456789012347', ...commonPageOptions })
+                .pipe(Effect.provide(buildLayer(calls))));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            expect(calls).toEqual(['/pages/123456789012347']);
+        }
+        finally {
+            stderr.mockRestore();
+        }
+    });
+    it('post edit sends a PUT when edited envelope content changes', async () => {
+        const calls = [];
+        const stdout = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        try {
+            const exit = await Effect.runPromiseExit(editPost
+                .handler({
+                slugOrId: 'post',
+                ...commonPostOptions,
+                format: Option.some('markdown'),
+            })
+                .pipe(Effect.provide(buildLayer(calls, () => `<mxpost>
+  <meta>
+    <title>Changed Post</title>
+    <slug>changed-post</slug>
+    <state>draft</state>
+    <summary>changed summary</summary>
+    <tags><tag>x</tag></tags>
+  </meta>
+  <content>
+changed body
+  </content>
+</mxpost>`))));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            expect(calls).toEqual(['/posts/post', '/posts/123456789012345']);
+        }
+        finally {
+            stdout.mockRestore();
+        }
+    });
+    it('note edit sends a PUT when edited envelope content changes', async () => {
+        const calls = [];
+        const stdout = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        try {
+            const exit = await Effect.runPromiseExit(editNote
+                .handler({
+                slugOrId: 'note',
+                ...commonNoteOptions,
+                format: Option.some('markdown'),
+            })
+                .pipe(Effect.provide(buildLayer(calls, () => `<mxnote>
+  <meta>
+    <title>Changed Note</title>
+    <slug>changed-note</slug>
+    <topic>life</topic>
+    <state>publish</state>
+    <mood>focused</mood>
+    <weather>rain</weather>
+    <bookmark>true</bookmark>
+  </meta>
+  <content>
+changed note body
+  </content>
+</mxnote>`))));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            expect(calls).toEqual([
+                '/notes/123456789012346',
+                '/notes/123456789012346',
+            ]);
+        }
+        finally {
+            stdout.mockRestore();
+        }
+    });
+    it('page edit sends a PUT when edited envelope content changes', async () => {
+        const calls = [];
+        const stdout = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        try {
+            const exit = await Effect.runPromiseExit(editPage
+                .handler({
+                slugOrId: 'page',
+                ...commonPageOptions,
+                format: Option.some('markdown'),
+            })
+                .pipe(Effect.provide(buildLayer(calls, () => `<mxpost>
+  <meta>
+    <title>Changed Page</title>
+    <slug>changed-page</slug>
+    <subtitle>Sub</subtitle>
+    <order>2</order>
+  </meta>
+  <content>
+changed page body
+  </content>
+</mxpost>`))));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            expect(calls).toEqual([
+                '/pages/slug/page',
+                '/pages/slug/page',
+                '/pages/123456789012347',
+            ]);
+        }
+        finally {
+            stdout.mockRestore();
+        }
+    });
+});

package/dist/test/cli/file/file.test.d.ts

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