@mx-space/cli 0.15.1 → 0.15.2

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

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

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

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

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

@@ -1,5 +0,0 @@
-/**
- * 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

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

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

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

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

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

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

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

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

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

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

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