@mx-space/cli 0.14.2 → 0.15.1

package/dist/test/helper/test-fs.d.ts

@@ -0,0 +1,24 @@
+import { FileSystem, Path } from '@effect/platform';
+import { Layer } from 'effect';
+interface FileNode {
+    readonly type: 'file';
+    data: string;
+    mode: number;
+}
+interface DirNode {
+    readonly type: 'dir';
+    mode: number;
+}
+type Node = FileNode | DirNode;
+export interface MemFs {
+    readonly nodes: Map<string, Node>;
+    readonly seed: (path: string, data: string, mode?: number) => void;
+    readonly mkdir: (path: string, mode?: number) => void;
+    readonly has: (path: string) => boolean;
+    readonly readFile: (path: string) => string | null;
+    readonly mode: (path: string) => number | null;
+}
+export declare const makeMemFs: () => MemFs;
+export declare const TestFsLive: (mem: MemFs) => Layer.Layer<FileSystem.FileSystem>;
+export declare const TestPathLive: Layer.Layer<Path.Path>;
+export {};

package/dist/test/helper/test-fs.js

@@ -0,0 +1,161 @@
+import { FileSystem, Path } from '@effect/platform';
+import { SystemError } from '@effect/platform/Error';
+import { Effect } from 'effect';
+const notFound = (method, path) => new SystemError({
+    reason: 'NotFound',
+    module: 'FileSystem',
+    method,
+    pathOrDescriptor: path,
+    description: `ENOENT: no such file or directory, ${path}`,
+});
+const normalize = (p) => p.replace(/\/+$/, '') || '/';
+const parentOf = (p) => {
+    const norm = normalize(p);
+    const idx = norm.lastIndexOf('/');
+    if (idx <= 0)
+        return '/';
+    return norm.slice(0, idx);
+};
+export const makeMemFs = () => {
+    const nodes = new Map();
+    const seed = (path, data, mode = 0o644) => {
+        const p = normalize(path);
+        // Auto-create ancestor directories.
+        let dir = parentOf(p);
+        while (dir && dir !== '/' && !nodes.has(dir)) {
+            nodes.set(dir, { type: 'dir', mode: 0o755 });
+            dir = parentOf(dir);
+        }
+        nodes.set(p, { type: 'file', data, mode });
+    };
+    const mkdir = (path, mode = 0o755) => {
+        const p = normalize(path);
+        let dir = parentOf(p);
+        while (dir && dir !== '/' && !nodes.has(dir)) {
+            nodes.set(dir, { type: 'dir', mode: 0o755 });
+            dir = parentOf(dir);
+        }
+        nodes.set(p, { type: 'dir', mode });
+    };
+    return {
+        nodes,
+        seed,
+        mkdir,
+        has: (p) => nodes.has(normalize(p)),
+        readFile: (p) => {
+            const n = nodes.get(normalize(p));
+            return n && n.type === 'file' ? n.data : null;
+        },
+        mode: (p) => {
+            const n = nodes.get(normalize(p));
+            return n ? n.mode : null;
+        },
+    };
+};
+const fakeInfo = (node, size = 0) => ({
+    type: node.type === 'dir' ? 'Directory' : 'File',
+    mtime: { _tag: 'None' },
+    atime: { _tag: 'None' },
+    birthtime: { _tag: 'None' },
+    dev: 0,
+    ino: { _tag: 'None' },
+    mode: node.mode,
+    nlink: { _tag: 'None' },
+    uid: { _tag: 'None' },
+    gid: { _tag: 'None' },
+    rdev: { _tag: 'None' },
+    size: BigInt(size),
+    blksize: { _tag: 'None' },
+    blocks: { _tag: 'None' },
+});
+export const TestFsLive = (mem) => FileSystem.layerNoop({
+    readFileString: (path) => {
+        const node = mem.nodes.get(normalize(path));
+        if (!node || node.type !== 'file') {
+            return Effect.fail(notFound('readFileString', path));
+        }
+        return Effect.succeed(node.data);
+    },
+    writeFileString: (path, data, options) => Effect.sync(() => {
+        const p = normalize(path);
+        // Auto-create parent directory tree if missing — matches real fs only
+        // when `recursive: true` was used to mkdir, but tests rely on it.
+        let dir = parentOf(p);
+        while (dir && dir !== '/' && !mem.nodes.has(dir)) {
+            mem.nodes.set(dir, { type: 'dir', mode: 0o755 });
+            dir = parentOf(dir);
+        }
+        mem.nodes.set(p, {
+            type: 'file',
+            data,
+            mode: options?.mode ?? 0o644,
+        });
+    }),
+    makeDirectory: (path, options) => Effect.sync(() => {
+        const p = normalize(path);
+        if (options?.recursive) {
+            let dir = parentOf(p);
+            while (dir && dir !== '/' && !mem.nodes.has(dir)) {
+                mem.nodes.set(dir, { type: 'dir', mode: 0o755 });
+                dir = parentOf(dir);
+            }
+        }
+        mem.nodes.set(p, { type: 'dir', mode: options?.mode ?? 0o755 });
+    }),
+    readDirectory: (path) => {
+        const dir = normalize(path);
+        if (!mem.nodes.has(dir)) {
+            return Effect.fail(notFound('readDirectory', path));
+        }
+        const prefix = dir === '/' ? '/' : `${dir}/`;
+        const out = [];
+        for (const key of mem.nodes.keys()) {
+            if (key === dir)
+                continue;
+            if (!key.startsWith(prefix))
+                continue;
+            const rest = key.slice(prefix.length);
+            if (rest.includes('/'))
+                continue;
+            out.push(rest);
+        }
+        return Effect.succeed(out.sort());
+    },
+    stat: (path) => {
+        const node = mem.nodes.get(normalize(path));
+        if (!node)
+            return Effect.fail(notFound('stat', path));
+        const size = node.type === 'file' ? node.data.length : 0;
+        return Effect.succeed(fakeInfo(node, size));
+    },
+    remove: (path, options) => Effect.suspend(() => {
+        const p = normalize(path);
+        const node = mem.nodes.get(p);
+        if (!node) {
+            return options?.force
+                ? Effect.void
+                : Effect.fail(notFound('remove', path));
+        }
+        if (node.type === 'dir' && options?.recursive) {
+            const prefix = `${p}/`;
+            for (const key of [...mem.nodes.keys()]) {
+                if (key === p || key.startsWith(prefix))
+                    mem.nodes.delete(key);
+            }
+        }
+        else {
+            mem.nodes.delete(p);
+        }
+        return Effect.void;
+    }),
+    chmod: (path, mode) => Effect.suspend(() => {
+        const p = normalize(path);
+        const node = mem.nodes.get(p);
+        if (!node)
+            return Effect.fail(notFound('chmod', path));
+        node.mode = mode;
+        return Effect.void;
+    }),
+    exists: (path) => Effect.succeed(mem.nodes.has(normalize(path))),
+});
+export const TestPathLive = Path.layer;

package/dist/test/helper/test-http.d.ts

@@ -0,0 +1,31 @@
+import { HttpClient, HttpClientRequest } from '@effect/platform';
+import { Layer } from 'effect';
+export interface CannedResponse {
+    readonly status: number;
+    readonly body?: unknown;
+    readonly headers?: Record<string, string>;
+}
+export interface RouteHandlerArgs {
+    readonly request: HttpClientRequest.HttpClientRequest;
+    readonly url: string;
+    readonly method: string;
+    readonly call: number;
+}
+export type RouteHandler = CannedResponse | ((args: RouteHandlerArgs) => CannedResponse | Promise<CannedResponse>);
+export interface TestHttpRoutes {
+    /** Routes keyed as `"METHOD URL"`. */
+    readonly [key: string]: RouteHandler;
+}
+export interface TestHttpRecorder {
+    readonly calls: Array<{
+        readonly method: string;
+        readonly url: string;
+        readonly headers: Record<string, string>;
+        readonly body: unknown;
+    }>;
+}
+export interface TestHttpLayerHandle {
+    readonly layer: Layer.Layer<HttpClient.HttpClient>;
+    readonly recorder: TestHttpRecorder;
+}
+export declare const testHttpLayer: (routes: TestHttpRoutes) => TestHttpLayerHandle;

package/dist/test/helper/test-http.js

@@ -0,0 +1,66 @@
+import { HttpClient, HttpClientResponse, } from '@effect/platform';
+import { Effect, Layer } from 'effect';
+const toWebResponse = (canned) => {
+    const headers = {
+        'content-type': 'application/json',
+        ...canned.headers,
+    };
+    const body = canned.body === undefined
+        ? null
+        : typeof canned.body === 'string'
+            ? canned.body
+            : JSON.stringify(canned.body);
+    return new Response(body, { status: canned.status, headers });
+};
+export const testHttpLayer = (routes) => {
+    const counts = {};
+    const recorder = { calls: [] };
+    const client = HttpClient.make((request) => Effect.gen(function* () {
+        const url = request.url;
+        const method = request.method;
+        const key = `${method} ${url}`;
+        counts[key] = (counts[key] ?? 0) + 1;
+        // Record the call (capture body before it's consumed).
+        const bodySnapshot = yield* snapshotBody(request);
+        recorder.calls.push({
+            method,
+            url,
+            headers: { ...request.headers },
+            body: bodySnapshot,
+        });
+        const handler = routes[key];
+        if (!handler) {
+            return HttpClientResponse.fromWeb(request, new Response('not found', { status: 404 }));
+        }
+        const canned = typeof handler === 'function'
+            ? yield* Effect.promise(async () => handler({
+                request,
+                url,
+                method,
+                call: counts[key],
+            }))
+            : handler;
+        return HttpClientResponse.fromWeb(request, toWebResponse(canned));
+    }));
+    return {
+        layer: Layer.succeed(HttpClient.HttpClient, client),
+        recorder,
+    };
+};
+const snapshotBody = (request) => Effect.gen(function* () {
+    const body = request.body;
+    if (body._tag === 'Empty')
+        return undefined;
+    if (body._tag === 'Uint8Array') {
+        const text = new TextDecoder().decode(body.body);
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return text;
+        }
+    }
+    if (body._tag === 'Raw')
+        return body.body;
+    return undefined;
+});

package/dist/test/integration/_helpers.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Create an isolated `XDG_CONFIG_HOME` so the spawned CLI never touches the
+ * developer's real `~/.config/mxs/` profile store. Returns a cleanup fn.
+ */
+export declare const makeTmpHome: () => (() => void);

package/dist/test/integration/_helpers.js

@@ -0,0 +1,24 @@
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+/**
+ * Create an isolated `XDG_CONFIG_HOME` so the spawned CLI never touches the
+ * developer's real `~/.config/mxs/` profile store. Returns a cleanup fn.
+ */
+export const makeTmpHome = () => {
+    const dir = mkdtempSync(join(tmpdir(), 'mxs-int-'));
+    const prevXdg = process.env.XDG_CONFIG_HOME;
+    process.env.XDG_CONFIG_HOME = dir;
+    return () => {
+        if (prevXdg === undefined)
+            delete process.env.XDG_CONFIG_HOME;
+        else
+            process.env.XDG_CONFIG_HOME = prevXdg;
+        try {
+            rmSync(dir, { recursive: true, force: true });
+        }
+        catch {
+            // ignore
+        }
+    };
+};

package/dist/test/integration/cli-error-envelope.test.d.ts

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

package/dist/test/integration/cli-error-envelope.test.js

@@ -0,0 +1,137 @@
+import { spawn } from 'node:child_process';
+import { createServer } from 'node:http';
+import { fileURLToPath } from 'node:url';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { makeTmpHome } from './_helpers';
+const BIN = fileURLToPath(new URL('../../src/bin/mxs.ts', import.meta.url));
+const runMxs = (args, env = {}) => new Promise((resolve) => {
+    const child = spawn('npx', ['tsx', BIN, ...args], {
+        env: { ...process.env, ...env },
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    const out = [];
+    const err = [];
+    child.stdout.on('data', (chunk) => out.push(chunk));
+    child.stderr.on('data', (chunk) => err.push(chunk));
+    child.on('exit', (code) => resolve({
+        code,
+        stdout: Buffer.concat(out).toString('utf8'),
+        stderr: Buffer.concat(err).toString('utf8'),
+    }));
+});
+const startMockServer = (handler, prefix = 'v2') => new Promise((resolve) => {
+    const server = createServer(handler);
+    server.listen(0, '127.0.0.1', () => {
+        const addr = server.address();
+        resolve({
+            url: `http://127.0.0.1:${addr.port}/api/${prefix}`,
+            stop: () => new Promise((r) => server.close(() => r())),
+        });
+    });
+});
+describe('cli --json error envelope', () => {
+    let cleanup;
+    let server;
+    beforeEach(() => {
+        cleanup = makeTmpHome();
+    });
+    afterEach(async () => {
+        await server?.stop();
+        cleanup();
+    });
+    it('emits a wire-format error envelope when a V2 server returns 500', async () => {
+        server = await startMockServer((req, res) => {
+            if (req.url === '/api/v2' || req.url === '/api/v2/') {
+                res.writeHead(200, { 'content-type': 'application/json' });
+                res.end(JSON.stringify({
+                    data: { name: 'mx-server', version: '2.0.0', authClient: 'better-auth' },
+                }));
+                return;
+            }
+            res.writeHead(500, { 'content-type': 'application/json' });
+            res.end(JSON.stringify({ message: 'boom' }));
+        });
+        const res = await runMxs([
+            '--api-url',
+            server.url,
+            '--json',
+            'post',
+            'list',
+        ]);
+        // Exit code for ServerError is 6 (per exitCodeForTag).
+        expect(res.code).toBe(6);
+        // Envelope shape: { ok: false, code: "server.error", message: ... }
+        const envelope = JSON.parse(res.stdout);
+        expect(envelope.ok).toBe(false);
+        expect(envelope.code).toBe('server.error');
+        expect(typeof envelope.message).toBe('string');
+        expect(envelope.message).toContain('boom');
+    }, 30_000);
+    it('unwraps a V3 error envelope on 500', async () => {
+        server = await startMockServer((req, res) => {
+            if (req.url === '/api/v3' || req.url === '/api/v3/') {
+                res.writeHead(200, { 'content-type': 'application/json' });
+                res.end(JSON.stringify({
+                    data: {
+                        name: 'mx-server',
+                        version: '3.0.0',
+                        auth_client: 'better-auth',
+                    },
+                }));
+                return;
+            }
+            res.writeHead(500, { 'content-type': 'application/json' });
+            res.end(JSON.stringify({
+                error: { code: 'INTERNAL_ERROR', message: 'boom v3' },
+            }));
+        }, 'v3');
+        const res = await runMxs([
+            '--api-url',
+            server.url,
+            '--json',
+            'post',
+            'list',
+        ]);
+        expect(res.code).toBe(6);
+        const envelope = JSON.parse(res.stdout);
+        expect(envelope.ok).toBe(false);
+        expect(envelope.code).toBe('server.error');
+        // Adapter unwraps `error.message`, which then surfaces in the renderer.
+        expect(envelope.message).toContain('boom v3');
+    }, 30_000);
+    it('maps a V3 404 with <RESOURCE>_NOT_FOUND code to ResourceNotFound', async () => {
+        server = await startMockServer((req, res) => {
+            if (req.url === '/api/v3' || req.url === '/api/v3/') {
+                res.writeHead(200, { 'content-type': 'application/json' });
+                res.end(JSON.stringify({
+                    data: {
+                        name: 'mx-server',
+                        version: '3.0.0',
+                        auth_client: 'better-auth',
+                    },
+                }));
+                return;
+            }
+            res.writeHead(404, { 'content-type': 'application/json' });
+            res.end(JSON.stringify({
+                error: {
+                    code: 'CATEGORY_NOT_FOUND',
+                    message: 'category not found',
+                },
+            }));
+        }, 'v3');
+        const res = await runMxs([
+            '--api-url',
+            server.url,
+            '--json',
+            'category',
+            'get',
+            'missing',
+        ]);
+        expect(res.code).toBe(7);
+        const envelope = JSON.parse(res.stdout);
+        expect(envelope.ok).toBe(false);
+        expect(envelope.code).toBe('resource.not_found');
+        expect(envelope.message).toContain('category not found');
+    }, 30_000);
+});

package/dist/test/integration/cli-help-render.test.d.ts

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

package/dist/test/integration/cli-help-render.test.js

@@ -0,0 +1,149 @@
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { makeTmpHome } from './_helpers';
+const BIN = fileURLToPath(new URL('../../src/bin/mxs.ts', import.meta.url));
+const runMxs = (args, env = {}) => new Promise((resolve) => {
+    const child = spawn('npx', ['tsx', BIN, ...args], {
+        env: { ...process.env, NO_COLOR: '1', ...env },
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    const out = [];
+    const err = [];
+    child.stdout.on('data', (chunk) => out.push(chunk));
+    child.stderr.on('data', (chunk) => err.push(chunk));
+    child.on('exit', (code) => resolve({
+        code,
+        stdout: Buffer.concat(out).toString('utf8'),
+        stderr: Buffer.concat(err).toString('utf8'),
+    }));
+});
+describe('cli root help renders via markdown layer', () => {
+    let cleanup;
+    beforeEach(() => {
+        cleanup = makeTmpHome();
+    });
+    afterEach(() => {
+        cleanup();
+    });
+    it('shows Global options + Commands sections and lists every global flag', async () => {
+        const res = await runMxs(['--help']);
+        expect(res.code).toBe(0);
+        expect(res.stdout).toContain('GLOBAL OPTIONS');
+        expect(res.stdout).toContain('COMMANDS');
+        for (const flag of [
+            '--json',
+            '--output',
+            '--api-url',
+            '--token',
+            '--api-key',
+            '--lang',
+            '--profile',
+            '--quiet',
+            '--verbose',
+            '--dry-run',
+        ]) {
+            expect(res.stdout).toContain(flag);
+        }
+        // Every top-level subcommand surfaces.
+        for (const cmd of [
+            'auth',
+            'profile',
+            'post',
+            'note',
+            'page',
+            'category',
+            'topic',
+            'config',
+            'update',
+        ]) {
+            expect(res.stdout).toContain(cmd);
+        }
+    }, 30_000);
+    it('bare `mxs` invocation produces the same output as `mxs --help`', async () => {
+        const [bare, help] = await Promise.all([runMxs([]), runMxs(['--help'])]);
+        expect(bare.code).toBe(0);
+        expect(help.code).toBe(0);
+        expect(bare.stdout).toEqual(help.stdout);
+    }, 60_000);
+    it('`mxs -h` matches `mxs --help`', async () => {
+        const [shortFlag, longFlag] = await Promise.all([
+            runMxs(['-h']),
+            runMxs(['--help']),
+        ]);
+        expect(shortFlag.code).toBe(0);
+        expect(longFlag.code).toBe(0);
+        expect(shortFlag.stdout).toEqual(longFlag.stdout);
+    }, 60_000);
+});
+describe('cli group help renders via markdown layer', () => {
+    let cleanup;
+    beforeEach(() => {
+        cleanup = makeTmpHome();
+    });
+    afterEach(() => {
+        cleanup();
+    });
+    it('`mxs post` shows the Verbs table with all 8 post verbs', async () => {
+        const res = await runMxs(['post']);
+        expect(res.code).toBe(0);
+        expect(res.stdout).toContain('VERBS');
+        for (const verb of [
+            'list',
+            'get',
+            'create',
+            'edit',
+            'update',
+            'delete',
+            'publish',
+            'unpublish',
+        ]) {
+            expect(res.stdout).toContain(verb);
+        }
+    }, 30_000);
+    it('`mxs post --help` matches `mxs post`', async () => {
+        const [bare, help] = await Promise.all([
+            runMxs(['post']),
+            runMxs(['post', '--help']),
+        ]);
+        expect(bare.code).toBe(0);
+        expect(help.code).toBe(0);
+        expect(bare.stdout).toEqual(help.stdout);
+    }, 60_000);
+    it('`mxs auth -h` lists auth verbs', async () => {
+        const res = await runMxs(['auth', '-h']);
+        expect(res.code).toBe(0);
+        for (const verb of ['login', 'logout', 'whoami', 'status']) {
+            expect(res.stdout).toContain(verb);
+        }
+    }, 30_000);
+    it('`mxs update --help` lists all leaf options', async () => {
+        const res = await runMxs(['update', '--help']);
+        expect(res.code).toBe(0);
+        for (const flag of [
+            '--check',
+            '--prerelease',
+            '--pm',
+            '--force',
+            '--yes',
+        ]) {
+            expect(res.stdout).toContain(flag);
+        }
+        expect(res.stdout).toContain('OPTIONS');
+    }, 30_000);
+    it('`mxs config` lists all 4 config verbs', async () => {
+        const res = await runMxs(['config']);
+        expect(res.code).toBe(0);
+        for (const verb of ['list', 'get', 'set', 'edit']) {
+            expect(res.stdout).toContain(verb);
+        }
+    }, 30_000);
+    it('`mxs post create --help` is still rendered by @effect/cli (we do not intercept)', async () => {
+        const res = await runMxs(['post', 'create', '--help']);
+        // @effect/cli exits 0 on --help.
+        expect(res.code).toBe(0);
+        // Legacy @effect/cli layout markers — make sure the boundary is correct.
+        expect(res.stdout).toContain('USAGE');
+        expect(res.stdout).toMatch(/\$ create\b/);
+    }, 30_000);
+});

package/dist/test/integration/cli-help.test.d.ts

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

package/dist/test/integration/cli-help.test.js

@@ -0,0 +1,67 @@
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { makeTmpHome } from './_helpers';
+const BIN = fileURLToPath(new URL('../../src/bin/mxs.ts', import.meta.url));
+const runMxs = (args, env = {}) => new Promise((resolve) => {
+    const child = spawn('npx', ['tsx', BIN, ...args], {
+        env: { ...process.env, ...env },
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    const out = [];
+    const err = [];
+    child.stdout.on('data', (chunk) => out.push(chunk));
+    child.stderr.on('data', (chunk) => err.push(chunk));
+    child.on('exit', (code) => resolve({
+        code,
+        stdout: Buffer.concat(out).toString('utf8'),
+        stderr: Buffer.concat(err).toString('utf8'),
+    }));
+});
+describe('cli --help', () => {
+    let cleanup;
+    beforeEach(() => {
+        cleanup = makeTmpHome();
+    });
+    afterEach(() => {
+        cleanup();
+    });
+    it('lists all top-level subcommands', async () => {
+        const res = await runMxs(['--help']);
+        // strip ANSI codes — `@effect/cli` colours headings
+        const stripped = res.stdout.replace(/\x1b\[[0-9;]*m/g, '');
+        for (const cmd of [
+            'auth',
+            'profile',
+            'post',
+            'note',
+            'page',
+            'category',
+            'topic',
+            'config',
+            'skill',
+            'preview',
+            'update',
+        ]) {
+            expect(stripped).toMatch(new RegExp(`\\b${cmd}\\b`));
+        }
+        expect(res.code).toBe(0);
+    }, 30_000);
+    it('shows post subcommand verbs', async () => {
+        const res = await runMxs(['post', '--help']);
+        const stripped = res.stdout.replace(/\x1b\[[0-9;]*m/g, '');
+        for (const verb of [
+            'list',
+            'get',
+            'create',
+            'edit',
+            'update',
+            'delete',
+            'publish',
+            'unpublish',
+        ]) {
+            expect(stripped).toMatch(new RegExp(`\\b${verb}\\b`));
+        }
+        expect(res.code).toBe(0);
+    }, 30_000);
+});

package/dist/test/integration/cli-post-list.test.d.ts

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