@mx-space/cli 0.14.2 → 0.15.1

package/dist/test/cli/ai/verbs.test.js

@@ -0,0 +1,235 @@
+import { describe, expect, it, vi } from '@effect/vitest';
+import { Effect, Layer, Option } from 'effect';
+import { AiTaskCreateFailed } from '../../../src/domain/errors';
+import { byArticle as overviewByArticle } from '../../../src/cli/ai/overview/by-article';
+import { list as overviewList } from '../../../src/cli/ai/overview/list';
+import { list as summaryList } from '../../../src/cli/ai/summary/list';
+import { regen } from '../../../src/cli/ai/summary/regen';
+import { translate as summaryTranslate } from '../../../src/cli/ai/summary/translate';
+import { refresh } from '../../../src/cli/ai/insights/refresh';
+import { translate as insightsTranslate } from '../../../src/cli/ai/insights/translate';
+import { run as ttsRun } from '../../../src/cli/ai/tts/run';
+import { voices as ttsVoices } from '../../../src/cli/ai/tts/voices';
+import { Ai } from '../../../src/services/Ai';
+import { Api } from '../../../src/services/Api';
+import { Auth } from '../../../src/services/Auth';
+import { Config, } from '../../../src/services/Config';
+import { Renderer } from '../../../src/services/Renderer';
+import { Resolver } from '../../../src/services/Resolver';
+import { testHttpLayer } from '../../helper/test-http';
+const resolved = {
+    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 noopConfig = {
+    getConfigDir: Effect.succeed('/tmp'),
+    getProfilesDir: Effect.succeed('/tmp/profiles'),
+    getProfileDir: (n) => Effect.succeed(`/tmp/profiles/${n}`),
+    getProfileConfigPath: (n) => Effect.succeed(`/tmp/${n}/config.json`),
+    getProfileCredentialsPath: (n) => Effect.succeed(`/tmp/${n}/cred.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(null),
+    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),
+};
+const noopAuth = {
+    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: (r) => Effect.succeed({
+        access_token: r.token ?? '',
+        expires_at: Date.now() + 3600_000,
+    }),
+    enrichUser: (_profile, _authBase, cred) => Effect.succeed(cred),
+};
+const buildLayer = (http) => {
+    const apiLayer = Api.Default.pipe(Layer.provide(Layer.succeed(Config, noopConfig)), Layer.provide(Layer.succeed(Auth, noopAuth)), Layer.provide(http.layer));
+    return Layer.mergeAll(apiLayer, Ai.Default.pipe(Layer.provide(apiLayer)), Renderer.Default, Resolver.Default.pipe(Layer.provide(apiLayer)));
+};
+const SNOWFLAKE = '123456789012345';
+const created = {
+    status: 200,
+    body: { data: { taskId: '01H', created: true } },
+};
+const silenced = async (run) => {
+    const out = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+    const err = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+    try {
+        await run();
+    }
+    finally {
+        out.mockRestore();
+        err.mockRestore();
+    }
+};
+describe('ai verb flag wiring', () => {
+    it('summary regen --force posts force', async () => {
+        const http = testHttpLayer({
+            'POST https://blog.example.com/api/v2/ai/summaries/task': created,
+        });
+        await silenced(async () => {
+            await Effect.runPromise(Effect.provide(regen.handler({
+                id: SNOWFLAKE,
+                to: ['en'],
+                force: true,
+                noWait: true,
+            }), buildLayer(http)));
+        });
+        expect(http.recorder.calls.at(-1)?.body).toEqual({
+            refId: SNOWFLAKE,
+            targetLanguages: ['en'],
+            force: true,
+        });
+    });
+    it('insights refresh --to --force posts languages and force', async () => {
+        const http = testHttpLayer({
+            'POST https://blog.example.com/api/v2/ai/insights/task': created,
+        });
+        await silenced(async () => {
+            await Effect.runPromise(Effect.provide(refresh.handler({
+                id: SNOWFLAKE,
+                to: ['en', 'ja'],
+                force: true,
+                noWait: true,
+            }), buildLayer(http)));
+        });
+        expect(http.recorder.calls.at(-1)?.body).toEqual({
+            refId: SNOWFLAKE,
+            targetLanguages: ['en', 'ja'],
+            force: true,
+        });
+    });
+    it('summary translate posts targetLang without polling when --no-wait', async () => {
+        const http = testHttpLayer({
+            'POST https://blog.example.com/api/v2/ai/summaries/task/translate': created,
+        });
+        await silenced(async () => {
+            await Effect.runPromise(Effect.provide(summaryTranslate.handler({
+                id: SNOWFLAKE,
+                to: 'ja',
+                force: false,
+                noWait: true,
+            }), buildLayer(http)));
+        });
+        expect(http.recorder.calls.length).toBe(1);
+        expect(http.recorder.calls[0]?.body).toEqual({
+            refId: SNOWFLAKE,
+            targetLang: 'ja',
+        });
+    });
+    it('insights translate fails with the actionable source-missing message', async () => {
+        const http = testHttpLayer({
+            'POST https://blog.example.com/api/v2/ai/insights/task/translate': {
+                status: 200,
+                body: {
+                    data: { taskId: null, created: false, reason: 'source-missing' },
+                },
+            },
+        });
+        let err;
+        await silenced(async () => {
+            err = await Effect.runPromise(Effect.provide(insightsTranslate.handler({
+                id: SNOWFLAKE,
+                to: 'ja',
+                force: false,
+                noWait: true,
+            }), buildLayer(http)).pipe(Effect.flip));
+        });
+        expect(err).toBeInstanceOf(AiTaskCreateFailed);
+        expect(err.message).toContain('mxs ai insights refresh');
+    });
+    it('summary list --grouped --search hits the grouped endpoint', async () => {
+        const http = testHttpLayer({
+            'GET https://blog.example.com/api/v2/ai/summaries/grouped?search=hello': { status: 200, body: { data: [] } },
+        });
+        await silenced(async () => {
+            await Effect.runPromise(Effect.provide(summaryList.handler({
+                page: Option.none(),
+                size: Option.none(),
+                grouped: true,
+                search: Option.some('hello'),
+            }), buildLayer(http)));
+        });
+        expect(http.recorder.calls[0]?.url).toBe('https://blog.example.com/api/v2/ai/summaries/grouped?search=hello');
+    });
+    it('overview list forwards search and type', async () => {
+        const http = testHttpLayer({
+            'GET https://blog.example.com/api/v2/ai/overview/grouped?search=x&type=post': { status: 200, body: { data: [] } },
+        });
+        await silenced(async () => {
+            await Effect.runPromise(Effect.provide(overviewList.handler({
+                page: Option.none(),
+                size: Option.none(),
+                search: Option.some('x'),
+                type: Option.some('post'),
+            }), buildLayer(http)));
+        });
+        expect(http.recorder.calls[0]?.url).toBe('https://blog.example.com/api/v2/ai/overview/grouped?search=x&type=post');
+    });
+    it('tts run posts langs and force', async () => {
+        const http = testHttpLayer({
+            'POST https://blog.example.com/api/v2/ai/tts/task': created,
+        });
+        await silenced(async () => {
+            await Effect.runPromise(Effect.provide(ttsRun.handler({
+                id: SNOWFLAKE,
+                to: ['en', 'ja'],
+                force: true,
+                noWait: true,
+            }), buildLayer(http)));
+        });
+        expect(http.recorder.calls.at(-1)?.body).toEqual({
+            refId: SNOWFLAKE,
+            langs: ['en', 'ja'],
+            force: true,
+        });
+    });
+    it('tts voices forwards provider and model', async () => {
+        const http = testHttpLayer({
+            'GET https://blog.example.com/api/v2/ai/tts/voices?providerId=p1&model=m1': { status: 200, body: { data: { voices: [] } } },
+        });
+        await silenced(async () => {
+            await Effect.runPromise(Effect.provide(ttsVoices.handler({ provider: 'p1', model: 'm1' }), buildLayer(http)));
+        });
+        expect(http.recorder.calls[0]?.url).toBe('https://blog.example.com/api/v2/ai/tts/voices?providerId=p1&model=m1');
+    });
+    it('overview by-article hits the article endpoint', async () => {
+        const http = testHttpLayer({
+            [`GET https://blog.example.com/api/v2/ai/overview/article/${SNOWFLAKE}`]: { status: 200, body: { data: { article: { id: SNOWFLAKE } } } },
+        });
+        await silenced(async () => {
+            await Effect.runPromise(Effect.provide(overviewByArticle.handler({ id: SNOWFLAKE }), buildLayer(http)));
+        });
+        expect(http.recorder.calls[0]?.url).toBe(`https://blog.example.com/api/v2/ai/overview/article/${SNOWFLAKE}`);
+    });
+});

package/dist/test/cli/auth/login.test.d.ts

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

package/dist/test/cli/auth/login.test.js

@@ -0,0 +1,236 @@
+import { Effect, Exit, Layer, Option } from 'effect';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { login } from '../../../src/cli/auth/login';
+import { currentProfileFlag } from '../../../src/domain/runtime-flags';
+import { Auth } from '../../../src/services/Auth';
+import { Config } from '../../../src/services/Config';
+import { Editor } from '../../../src/services/Editor';
+import { Profile } from '../../../src/services/Profile';
+import { currentOutputOptions, defaultOutputOptions, Renderer, } from '../../../src/services/Renderer';
+import { makeMemFs, TestFsLive, TestPathLive } from '../../helper/test-fs';
+vi.mock('open', () => ({ default: vi.fn().mockResolvedValue(undefined) }));
+// ---------------------------------------------------------------------------
+// Layer builders
+// ---------------------------------------------------------------------------
+const mxsDir = (xdg) => `${xdg}/mxs`;
+const profileDir = (xdg, name) => `${mxsDir(xdg)}/profiles/${name}`;
+const makeAuthMock = (overrides = {}) => ({
+    probe: () => Effect.succeed({
+        apiUrl: 'https://blog.example.com',
+        apiBase: 'https://blog.example.com/api/v2',
+        authBase: 'https://blog.example.com/api/v2/auth',
+        apiVersion: 2,
+    }),
+    requestDeviceCode: () => Effect.succeed({
+        device_code: 'dcode',
+        user_code: 'ABCD-1234',
+        verification_uri: 'https://blog.example.com/api/v2/auth/device',
+        verification_uri_complete: 'https://blog.example.com/api/v2/auth/device?code=ABCD-1234',
+        expires_in: 300,
+        interval: 1,
+    }),
+    pollDeviceToken: () => Effect.succeed({
+        access_token: 'new-access-token',
+        token_type: 'Bearer',
+        expires_in: 3600,
+        user: { id: 'u1', email: 'owner@example.com', name: 'Owner' },
+    }),
+    refresh: () => Effect.succeed(null),
+    login: () => Effect.never,
+    logout: () => Effect.void,
+    whoami: Effect.never,
+    status: Effect.never,
+    ensureFresh: () => Effect.never,
+    enrichUser: (_profile, _authBase, cred) => Effect.succeed(cred),
+    ...overrides,
+});
+const makeEditorMock = (overrides = {}) => ({
+    openEditor: () => Effect.succeed(''),
+    prompt: () => Effect.succeed('https://blog.example.com'),
+    confirm: () => Effect.succeed(true),
+    readFileOrStdin: () => Effect.succeed(''),
+    ...overrides,
+});
+const buildHarness = (authOverride = {}, editorOverride = {}) => {
+    const mem = makeMemFs();
+    const fsLayer = TestFsLive(mem);
+    const base = Layer.merge(fsLayer, TestPathLive);
+    const configLayer = Config.Default.pipe(Layer.provide(base));
+    const profileLayer = Profile.Default.pipe(Layer.provide(configLayer));
+    const authLayer = Layer.succeed(Auth, makeAuthMock(authOverride));
+    const editorLayer = Layer.succeed(Editor, makeEditorMock(editorOverride));
+    const rendererLayer = Renderer.Default;
+    const layer = Layer.mergeAll(base, configLayer, profileLayer, authLayer, editorLayer, rendererLayer);
+    return { mem, layer };
+};
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+const XDG = '/xdg';
+beforeEach(() => {
+    process.env.XDG_CONFIG_HOME = XDG;
+    delete process.env.MXS_PROFILE;
+    delete process.env.MXS_API_URL;
+    delete process.env.MXS_CLI_LOCAL_DEV;
+});
+afterEach(() => {
+    delete process.env.XDG_CONFIG_HOME;
+});
+describe('auth login command', () => {
+    it('writes credentials to the default profile on a fresh install', async () => {
+        const promptSpy = vi.fn(() => Effect.succeed('https://blog.example.com'));
+        const { mem, layer } = buildHarness({}, { prompt: promptSpy });
+        const exit = await Effect.runPromiseExit(login.handler({ production: Option.none() }).pipe(Effect.provide(layer)));
+        expect(Exit.isSuccess(exit)).toBe(true);
+        // Prompted because no profile pointer and no apiUrl.
+        expect(promptSpy).toHaveBeenCalledTimes(1);
+        const credsPath = `${profileDir(XDG, 'default')}/credentials.json`;
+        const cfgPath = `${profileDir(XDG, 'default')}/config.json`;
+        const creds = JSON.parse(mem.readFile(credsPath) ?? '{}');
+        const cfg = JSON.parse(mem.readFile(cfgPath) ?? '{}');
+        expect(creds.access_token).toBe('new-access-token');
+        expect(cfg.api_url).toBe('https://blog.example.com');
+        expect(cfg.production).toBeUndefined();
+        const current = mem.readFile(`${mxsDir(XDG)}/current`)?.trim();
+        expect(current).toBe('default');
+    });
+    it('honours --production and writes the profile production flag', async () => {
+        const { mem, layer } = buildHarness();
+        const exit = await Effect.runPromiseExit(login
+            .handler({ production: Option.some(true) })
+            .pipe(Effect.provide(layer)));
+        expect(Exit.isSuccess(exit)).toBe(true);
+        const cfg = JSON.parse(mem.readFile(`${profileDir(XDG, 'default')}/config.json`) ?? '{}');
+        expect(cfg.production).toBe(true);
+    });
+    it('reuses the active profile when one exists', async () => {
+        const mem = makeMemFs();
+        const profDir = profileDir(XDG, 'staging');
+        mem.mkdir(profDir);
+        mem.seed(`${profDir}/config.json`, JSON.stringify({}), 0o644);
+        mem.seed(`${mxsDir(XDG)}/current`, 'staging\n', 0o644);
+        const fsLayer = TestFsLive(mem);
+        const base = Layer.merge(fsLayer, TestPathLive);
+        const configLayer = Config.Default.pipe(Layer.provide(base));
+        const profileLayer = Profile.Default.pipe(Layer.provide(configLayer));
+        const authLayer = Layer.succeed(Auth, makeAuthMock());
+        const editorLayer = Layer.succeed(Editor, makeEditorMock());
+        const layer = Layer.mergeAll(base, configLayer, profileLayer, authLayer, editorLayer, Renderer.Default);
+        // Pre-seed the profile config with api_url so Profile.resolve succeeds
+        // without prompting.
+        mem.seed(`${profDir}/config.json`, JSON.stringify({ api_url: 'https://blog.example.com' }), 0o644);
+        const exit = await Effect.runPromiseExit(login.handler({ production: Option.none() }).pipe(Effect.provide(layer)));
+        expect(Exit.isSuccess(exit)).toBe(true);
+        const creds = JSON.parse(mem.readFile(`${profDir}/credentials.json`) ?? '{}');
+        expect(creds.access_token).toBe('new-access-token');
+        expect(mem.readFile(`${mxsDir(XDG)}/current`)?.trim()).toBe('staging');
+    });
+    it('fails when the fresh-install API URL prompt is blank', async () => {
+        const { layer } = buildHarness({}, { prompt: () => Effect.succeed('   ') });
+        const exit = await Effect.runPromiseExit(login.handler({ production: Option.none() }).pipe(Effect.provide(layer)));
+        expect(Exit.isFailure(exit)).toBe(true);
+    });
+    it('emits the device-code response in JSON mode before polling', async () => {
+        const stdout = [];
+        const writeSpy = vi
+            .spyOn(process.stdout, 'write')
+            .mockImplementation((chunk) => {
+            stdout.push(String(chunk));
+            return true;
+        });
+        const { mem, layer } = buildHarness();
+        try {
+            const exit = await Effect.runPromiseExit(Effect.locally(login.handler({ production: Option.some(false) }), currentOutputOptions, { ...defaultOutputOptions, json: true }).pipe(Effect.provide(layer)));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            const first = JSON.parse(stdout[0]);
+            expect(first.data).toMatchObject({
+                verification_uri: 'https://blog.example.com/api/v2/auth/device',
+                user_code: 'ABCD-1234',
+                expires_in: 300,
+            });
+            const cfg = JSON.parse(mem.readFile(`${profileDir(XDG, 'default')}/config.json`) ?? '{}');
+            expect(cfg.production).toBe(false);
+        }
+        finally {
+            writeSpy.mockRestore();
+        }
+    });
+    it('creates the requested profile when the active pointer references a deleted profile dir', async () => {
+        // Boundary case: the user manually deleted ~/.config/mxs/profiles/default
+        // but the `current` pointer still says `default`. Running
+        // `mxs auth login --profile main` previously failed with
+        // `profile 'default' does not exist`; now the `--profile` override is
+        // honoured and the missing-profile error is downgraded to the
+        // fresh-install prompt path.
+        const mem = makeMemFs();
+        mem.seed(`${mxsDir(XDG)}/current`, 'default\n', 0o644);
+        // No `profiles/default` dir on disk.
+        const fsLayer = TestFsLive(mem);
+        const base = Layer.merge(fsLayer, TestPathLive);
+        const configLayer = Config.Default.pipe(Layer.provide(base));
+        const profileLayer = Profile.Default.pipe(Layer.provide(configLayer));
+        const authLayer = Layer.succeed(Auth, makeAuthMock());
+        const promptSpy = vi.fn(() => Effect.succeed('https://blog.example.com'));
+        const editorLayer = Layer.succeed(Editor, makeEditorMock({ prompt: promptSpy }));
+        const layer = Layer.mergeAll(base, configLayer, profileLayer, authLayer, editorLayer, Renderer.Default);
+        const exit = await Effect.runPromiseExit(Effect.locally(login.handler({ production: Option.none() }), currentProfileFlag, 'main').pipe(Effect.provide(layer)));
+        expect(Exit.isSuccess(exit)).toBe(true);
+        // Prompted because the resolved profile (default) did not exist on disk.
+        expect(promptSpy).toHaveBeenCalledTimes(1);
+        // Credentials land under the flag-provided profile, NOT under `default`.
+        const credsPath = `${profileDir(XDG, 'main')}/credentials.json`;
+        const creds = JSON.parse(mem.readFile(credsPath) ?? '{}');
+        expect(creds.access_token).toBe('new-access-token');
+        expect(mem.readFile(`${mxsDir(XDG)}/current`)?.trim()).toBe('main');
+        expect(mem.readFile(`${profileDir(XDG, 'default')}/credentials.json`)).toBe(null);
+    });
+    it('falls back to the default profile when the active pointer points at a deleted dir and no --profile flag is given', async () => {
+        // Same `current` pointer issue as above, but without `--profile`. The
+        // fresh-install path should kick in and credentials should land under
+        // the pointer's name (legacy compatibility: `readCurrent` still returns
+        // `default`, so writes go there and recreate the dir).
+        const mem = makeMemFs();
+        mem.seed(`${mxsDir(XDG)}/current`, 'default\n', 0o644);
+        const fsLayer = TestFsLive(mem);
+        const base = Layer.merge(fsLayer, TestPathLive);
+        const configLayer = Config.Default.pipe(Layer.provide(base));
+        const profileLayer = Profile.Default.pipe(Layer.provide(configLayer));
+        const authLayer = Layer.succeed(Auth, makeAuthMock());
+        const promptSpy = vi.fn(() => Effect.succeed('https://blog.example.com'));
+        const editorLayer = Layer.succeed(Editor, makeEditorMock({ prompt: promptSpy }));
+        const layer = Layer.mergeAll(base, configLayer, profileLayer, authLayer, editorLayer, Renderer.Default);
+        const exit = await Effect.runPromiseExit(login.handler({ production: Option.none() }).pipe(Effect.provide(layer)));
+        expect(Exit.isSuccess(exit)).toBe(true);
+        expect(promptSpy).toHaveBeenCalledTimes(1);
+        const creds = JSON.parse(mem.readFile(`${profileDir(XDG, 'default')}/credentials.json`) ?? '{}');
+        expect(creds.access_token).toBe('new-access-token');
+        expect(mem.readFile(`${mxsDir(XDG)}/current`)?.trim()).toBe('default');
+    });
+    it('prints slow_down ticks in interactive non-json mode', async () => {
+        const stderr = [];
+        const writeSpy = vi
+            .spyOn(process.stderr, 'write')
+            .mockImplementation((chunk) => {
+            stderr.push(String(chunk));
+            return true;
+        });
+        const { layer } = buildHarness({
+            pollDeviceToken: (_authBase, _clientId, _deviceCode, opts) => Effect.sync(() => {
+                opts.onTick?.('slow_down');
+                return {
+                    access_token: 'new-access-token',
+                    token_type: 'Bearer',
+                    expires_in: 3600,
+                };
+            }),
+        });
+        try {
+            const exit = await Effect.runPromiseExit(login.handler({ production: Option.none() }).pipe(Effect.provide(layer)));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            expect(stderr.join('')).toContain('slow_down');
+        }
+        finally {
+            writeSpy.mockRestore();
+        }
+    });
+});

package/dist/test/cli/auth/logout-whoami.test.d.ts

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

package/dist/test/cli/auth/logout-whoami.test.js

@@ -0,0 +1,124 @@
+import { Effect, Exit, Layer } from 'effect';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { logout } from '../../../src/cli/auth/logout';
+import { whoami } from '../../../src/cli/auth/whoami';
+import { Auth } from '../../../src/services/Auth';
+import { Config } from '../../../src/services/Config';
+import { Profile } from '../../../src/services/Profile';
+import { Renderer, } from '../../../src/services/Renderer';
+import { makeMemFs, TestFsLive, TestPathLive } from '../../helper/test-fs';
+const XDG = '/xdg';
+const mxsDir = `${XDG}/mxs`;
+const profileDir = (name) => `${mxsDir}/profiles/${name}`;
+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 makeAuthMock = (overrides = {}) => ({
+    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),
+    ...overrides,
+});
+const rendererJson = {
+    json: true,
+    output: 'json',
+    quiet: false,
+    verbose: false,
+};
+const buildLayer = (authOverride = {}) => {
+    const mem = makeMemFs();
+    const base = Layer.merge(TestFsLive(mem), TestPathLive);
+    const configLayer = Config.Default.pipe(Layer.provide(base));
+    const profileLayer = Profile.Default.pipe(Layer.provide(configLayer));
+    const authLayer = Layer.succeed(Auth, makeAuthMock(authOverride));
+    return {
+        mem,
+        layer: Layer.mergeAll(base, configLayer, profileLayer, authLayer, Renderer.Default),
+    };
+};
+beforeEach(() => {
+    process.env.XDG_CONFIG_HOME = XDG;
+});
+afterEach(() => {
+    delete process.env.XDG_CONFIG_HOME;
+    vi.restoreAllMocks();
+});
+describe('auth logout command', () => {
+    it('fails when no active profile exists', async () => {
+        const { layer } = buildLayer();
+        const exit = await Effect.runPromiseExit(logout.handler({}).pipe(Effect.provide(layer)));
+        expect(Exit.isFailure(exit)).toBe(true);
+    });
+    it('logs out the active profile and emits success', async () => {
+        const logoutSpy = vi.fn(() => Effect.void);
+        const { mem, layer } = buildLayer({ logout: logoutSpy });
+        mem.seed(`${mxsDir}/current`, 'prod\n');
+        const stdout = captureStdout();
+        try {
+            const exit = await Effect.runPromiseExit(logout.handler({}).pipe(Effect.provide(layer), Renderer.withOptions(rendererJson)));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            expect(logoutSpy).toHaveBeenCalledWith('prod');
+            expect(stdout.data.join('')).toContain('"ok":true');
+        }
+        finally {
+            stdout.restore();
+        }
+    });
+});
+describe('auth whoami command', () => {
+    it('fails when no credentials or override auth are available', async () => {
+        const { mem, layer } = buildLayer();
+        mem.mkdir(profileDir('prod'));
+        mem.seed(`${profileDir('prod')}/config.json`, JSON.stringify({ api_url: 'https://blog.example.com' }));
+        mem.seed(`${mxsDir}/current`, 'prod\n');
+        const exit = await Effect.runPromiseExit(whoami.handler({}).pipe(Effect.provide(layer)));
+        expect(Exit.isFailure(exit)).toBe(true);
+    });
+    it('emits refreshed user information for the active profile', async () => {
+        const { mem, layer } = buildLayer({
+            ensureFresh: () => Effect.succeed({
+                access_token: 'NEW',
+                expires_at: Date.now() + 3600_000,
+                user: { id: 'u2', email: 'fresh@example.com', name: 'Fresh' },
+            }),
+        });
+        mem.mkdir(profileDir('prod'));
+        mem.seed(`${profileDir('prod')}/config.json`, JSON.stringify({ api_url: 'https://blog.example.com' }));
+        mem.seed(`${profileDir('prod')}/credentials.json`, JSON.stringify({
+            access_token: 'OLD',
+            expires_at: Date.now() + 1_000,
+            user: { id: 'u1', email: 'old@example.com' },
+        }), 0o600);
+        mem.seed(`${mxsDir}/current`, 'prod\n');
+        const stdout = captureStdout();
+        try {
+            const exit = await Effect.runPromiseExit(whoami.handler({}).pipe(Effect.provide(layer), Renderer.withOptions(rendererJson)));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            const out = stdout.data.join('');
+            expect(out).toContain('fresh@example.com');
+            expect(out).toContain('https://blog.example.com');
+        }
+        finally {
+            stdout.restore();
+        }
+    });
+});

package/dist/test/cli/auth/status.test.d.ts

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