@sovovs/bycli 1.8.0 → 2.0.0

package/clis/suno/commands.test.js

@@ -1,188 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { AuthRequiredError, CommandExecutionError } from '@sovovs/bycli/errors';
-
-const mocks = vi.hoisted(() => ({
-    ensureSunoSession: vi.fn(),
-    checkSunoCaptcha: vi.fn(),
-}));
-
-vi.mock('./utils.js', () => ({
-    STUDIO_API: 'https://studio-api-prod.suno.com',
-    SUNO_DOMAIN: 'suno.com',
-    SUNO_URL: 'https://suno.com',
-    ensureSunoSession: mocks.ensureSunoSession,
-    checkSunoCaptcha: mocks.checkSunoCaptcha,
-    requireNonNegativeInt: (value) => {
-        const n = Number(value);
-        if (!Number.isInteger(n) || n < 0) throw Object.assign(new Error('non-negative int required'), { code: 'ARGUMENT' });
-        return n;
-    },
-    requirePositiveInt: (value) => {
-        const n = Number(value);
-        if (!Number.isInteger(n) || n < 1) throw Object.assign(new Error('positive int required'), { code: 'ARGUMENT' });
-        return n;
-    },
-    unwrapEvaluateResult: (value) => value && typeof value === 'object' && 'session' in value && 'data' in value ? value.data : value,
-}));
-
-const { statusCommand } = await import('./status.js');
-const { listCommand } = await import('./list.js');
-
-function createPage(evaluateImpl) {
-    return {
-        goto: vi.fn().mockResolvedValue(undefined),
-        wait: vi.fn().mockResolvedValue(undefined),
-        evaluate: evaluateImpl || vi.fn().mockResolvedValue(undefined),
-    };
-}
-
-beforeEach(() => {
-    vi.restoreAllMocks();
-});
-
-describe('suno status', () => {
-    it('reports "Not logged in" when ensureSunoSession throws AuthRequiredError', async () => {
-        mocks.ensureSunoSession.mockRejectedValue(new AuthRequiredError('suno.com', 'Auth required'));
-        const out = await statusCommand.func(createPage());
-        expect(out).toEqual([{
-            Status: 'Not logged in',
-            Plan: '-',
-            Credits: '-',
-            Monthly: '-',
-            Captcha: '-',
-        }]);
-    });
-
-    it('does not hide non-auth status failures as logged-out rows', async () => {
-        mocks.ensureSunoSession.mockRejectedValue(new CommandExecutionError('malformed billing payload'));
-        await expect(statusCommand.func(createPage())).rejects.toMatchObject({
-            code: 'COMMAND_EXEC',
-            message: expect.stringContaining('malformed billing payload'),
-        });
-    });
-
-    it('returns plan / credits / captcha when the session is healthy', async () => {
-        mocks.ensureSunoSession.mockResolvedValue({
-            ok: true,
-            planKey: 'pro',
-            planId: '3eaebef3',
-            totalCreditsAvailable: 2095,
-            breakdown: { pack: 0, purchasedPacks: 0, monthlyRemaining: 2095, monthlyLimit: 2500, monthlyUsed: 405 },
-            deviceId: 'device-uuid',
-        });
-        mocks.checkSunoCaptcha.mockResolvedValue({ ok: true, required: false });
-        const out = await statusCommand.func(createPage());
-        expect(out[0]).toMatchObject({
-            Status: 'Connected',
-            Plan: 'pro',
-            Credits: '2095',
-            Monthly: '2095/2500',
-            Captcha: 'Not required',
-        });
-    });
-
-    it('reports captcha required when /api/c/check says so', async () => {
-        mocks.ensureSunoSession.mockResolvedValue({
-            ok: true, planKey: 'pro', planId: 'x', totalCreditsAvailable: 100,
-            breakdown: { pack: 0, purchasedPacks: 0, monthlyRemaining: 100, monthlyLimit: 2500, monthlyUsed: 2400 },
-            deviceId: 'device-uuid',
-        });
-        mocks.checkSunoCaptcha.mockResolvedValue({ ok: true, required: true });
-        const out = await statusCommand.func(createPage());
-        expect(out[0].Captcha).toContain('Required');
-    });
-});
-
-describe('suno list', () => {
-    it('returns clip rows with truncated id, title, and pagination-aware rank', async () => {
-        mocks.ensureSunoSession.mockResolvedValue({ deviceId: 'device-uuid' });
-        const page = createPage(vi.fn().mockResolvedValue({
-            ok: true,
-            clips: [
-                { id: 'aaaaaaaa-1111-2222-3333-444444444444', title: 'Track One', status: 'complete', created_at: '2026-05-17T11:14:26.338Z' },
-                { id: 'bbbbbbbb-1111-2222-3333-444444444444', title: 'Track Two', status: 'streaming', created_at: '2026-05-17T11:00:00.000Z' },
-            ],
-        }));
-        const out = await listCommand.func(page, { limit: 10, page: 0 });
-        expect(out).toHaveLength(2);
-        expect(out[0]).toMatchObject({
-            rank: 1,
-            clip: 'aaaaaaaa',
-            title: 'Track One',
-            status: 'complete',
-            created: '2026-05-17 11:14:26',
-            link: 'https://suno.com/song/aaaaaaaa-1111-2222-3333-444444444444',
-        });
-    });
-
-    it('respects --limit (caller may receive more from feed and slice down)', async () => {
-        mocks.ensureSunoSession.mockResolvedValue({ deviceId: 'device-uuid' });
-        const page = createPage(vi.fn().mockResolvedValue({
-            ok: true,
-            clips: [
-                { id: 'aaaaaaaa-1111-2222-3333-444444444444', title: 'A', status: 'complete', created_at: '2026-05-17T00:00:00Z' },
-                { id: 'bbbbbbbb-1111-2222-3333-444444444444', title: 'B', status: 'complete', created_at: '2026-05-17T00:00:00Z' },
-                { id: 'cccccccc-1111-2222-3333-444444444444', title: 'C', status: 'complete', created_at: '2026-05-17T00:00:00Z' },
-            ],
-        }));
-        const out = await listCommand.func(page, { limit: 2, page: 0 });
-        expect(out).toHaveLength(2);
-    });
-
-    it('rejects invalid --page instead of silently clamping to zero', async () => {
-        mocks.ensureSunoSession.mockResolvedValue({ deviceId: 'device-uuid' });
-        await expect(listCommand.func(createPage(), { limit: 2, page: -1 })).rejects.toMatchObject({
-            code: 'ARGUMENT',
-        });
-    });
-
-    it('unwraps Browser Bridge envelopes around feed rows', async () => {
-        mocks.ensureSunoSession.mockResolvedValue({ deviceId: 'device-uuid' });
-        const page = createPage(vi.fn().mockResolvedValue({
-            session: 'browser:default',
-            data: {
-                ok: true,
-                clips: [
-                    { id: 'aaaaaaaa-1111-2222-3333-444444444444', title: 'Track One', status: 'complete', created_at: '2026-05-17T11:14:26.338Z' },
-                ],
-            },
-        }));
-        const out = await listCommand.func(page, { limit: 10, page: 0 });
-        expect(out[0].clip).toBe('aaaaaaaa');
-    });
-
-    it('returns EmptyResultError for a valid empty library response', async () => {
-        mocks.ensureSunoSession.mockResolvedValue({ deviceId: 'device-uuid' });
-        const page = createPage(vi.fn().mockResolvedValue({ ok: true, clips: [] }));
-        await expect(listCommand.func(page, { limit: 10, page: 0 })).rejects.toMatchObject({
-            code: 'EMPTY_RESULT',
-        });
-    });
-
-    it('fails typed on malformed clip identity', async () => {
-        mocks.ensureSunoSession.mockResolvedValue({ deviceId: 'device-uuid' });
-        const page = createPage(vi.fn().mockResolvedValue({ ok: true, clips: [{ title: 'No id' }] }));
-        await expect(listCommand.func(page, { limit: 10, page: 0 })).rejects.toMatchObject({
-            code: 'COMMAND_EXEC',
-            message: expect.stringContaining('malformed clip identity'),
-        });
-    });
-
-    it('surfaces feed lookup HTTP failures', async () => {
-        mocks.ensureSunoSession.mockResolvedValue({ deviceId: 'device-uuid' });
-        const page = createPage(vi.fn().mockResolvedValue({ ok: false, status: 500 }));
-        await expect(listCommand.func(page, { limit: 5, page: 0 })).rejects.toMatchObject({
-            code: 'COMMAND_EXEC',
-            message: expect.stringContaining('HTTP 500'),
-        });
-    });
-
-    it('surfaces malformed feed payloads as typed failures', async () => {
-        mocks.ensureSunoSession.mockResolvedValue({ deviceId: 'device-uuid' });
-        const page = createPage(vi.fn().mockResolvedValue({ ok: false, error: 'malformed clips payload' }));
-        await expect(listCommand.func(page, { limit: 5, page: 0 })).rejects.toMatchObject({
-            code: 'COMMAND_EXEC',
-            message: expect.stringContaining('malformed clips payload'),
-        });
-    });
-});

package/clis/suno/download.test.js

@@ -1,151 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-const mocks = vi.hoisted(() => ({
-    ensureSunoSession: vi.fn(),
-    downloadSunoClip: vi.fn(),
-}));
-
-vi.mock('./utils.js', () => ({
-    STUDIO_API: 'https://studio-api-prod.suno.com',
-    SUNO_DOMAIN: 'suno.com',
-    SUNO_URL: 'https://suno.com',
-    ensureSunoSession: mocks.ensureSunoSession,
-    downloadSunoClip: mocks.downloadSunoClip,
-    normalizeBooleanFlag: (value, fallback = false) => {
-        if (typeof value === 'boolean') return value;
-        if (value == null || value === '') return fallback;
-        const s = String(value).trim().toLowerCase();
-        return s === 'true' || s === '1' || s === 'yes' || s === 'on';
-    },
-    parseFormats: (value) => {
-        if (!value) return ['mp3', 'metadata'];
-        return String(value).split(',').map(s => s.trim().toLowerCase()).filter(Boolean);
-    },
-    resolveSunoOutputDir: (value) => value || '/tmp/suno-test',
-    unwrapEvaluateResult: (value) => value && typeof value === 'object' && 'session' in value && 'data' in value ? value.data : value,
-}));
-
-const { downloadCommand } = await import('./download.js');
-
-const okSession = { ok: true, deviceId: 'device-uuid' };
-const okCompleteClip = { id: '11111111-2222-3333-4444-555555555555', status: 'complete', title: 'Probe', audio_url: 'https://cdn1.suno.ai/x.mp3' };
-
-function createPageWithFeed(clips) {
-    return {
-        goto: vi.fn().mockResolvedValue(undefined),
-        wait: vi.fn().mockResolvedValue(undefined),
-        evaluate: vi.fn().mockResolvedValue({ ok: true, clips }),
-    };
-}
-
-beforeEach(() => {
-    vi.restoreAllMocks();
-    mocks.ensureSunoSession.mockReset().mockResolvedValue(okSession);
-    mocks.downloadSunoClip.mockReset().mockResolvedValue({
-        slug: 'probe',
-        written: [{ format: 'mp3', file: '/tmp/probe.mp3', ok: true }, { format: 'metadata', file: '/tmp/probe.json', ok: true }],
-    });
-});
-
-describe('suno download argument validation', () => {
-    it('parses bare UUID clip ids', async () => {
-        const id = okCompleteClip.id;
-        await downloadCommand.func(createPageWithFeed([okCompleteClip]), { clip: id, formats: 'mp3' });
-        expect(mocks.downloadSunoClip).toHaveBeenCalledWith(expect.anything(), okCompleteClip, '/tmp/suno-test', ['mp3'], 'device-uuid');
-    });
-
-    it('extracts UUID from a full suno.com/song/<id> URL', async () => {
-        const id = okCompleteClip.id;
-        await downloadCommand.func(createPageWithFeed([okCompleteClip]), { clip: `https://suno.com/song/${id}`, formats: 'mp3' });
-        expect(mocks.downloadSunoClip).toHaveBeenCalledWith(expect.anything(), okCompleteClip, '/tmp/suno-test', ['mp3'], 'device-uuid');
-    });
-
-    it('rejects off-domain URLs even if they contain a UUID', async () => {
-        const id = okCompleteClip.id;
-        await expect(downloadCommand.func(createPageWithFeed([]), { clip: `https://evil.example/song/${id}`, formats: 'mp3' })).rejects.toMatchObject({
-            code: 'ARGUMENT',
-            message: expect.stringContaining('Invalid clip-id'),
-        });
-    });
-
-    it('rejects non-UUID clip ids with ArgumentError', async () => {
-        await expect(downloadCommand.func(createPageWithFeed([]), { clip: 'not-a-uuid', formats: 'mp3' })).rejects.toMatchObject({
-            code: 'ARGUMENT',
-            message: expect.stringContaining('Invalid clip-id'),
-        });
-    });
-});
-
-describe('suno download lookup and status handling', () => {
-    it('returns EmptyResultError when feed/v3 does not contain the clip', async () => {
-        await expect(downloadCommand.func(createPageWithFeed([]), { clip: okCompleteClip.id, formats: 'mp3' })).rejects.toMatchObject({
-            code: 'EMPTY_RESULT',
-            hint: expect.stringContaining('not found'),
-        });
-    });
-
-    it('unwraps Browser Bridge envelopes around feed lookup results', async () => {
-        const page = createPageWithFeed([]);
-        page.evaluate.mockResolvedValueOnce({ session: 'browser:default', data: { ok: true, clips: [okCompleteClip] } });
-        await downloadCommand.func(page, { clip: okCompleteClip.id, formats: 'mp3' });
-        expect(mocks.downloadSunoClip).toHaveBeenCalledWith(expect.anything(), okCompleteClip, '/tmp/suno-test', ['mp3'], 'device-uuid');
-    });
-
-    it('fails typed when feed/v3 returns malformed clips payload', async () => {
-        const page = createPageWithFeed([]);
-        page.evaluate.mockResolvedValueOnce({ ok: true, clips: null });
-        await expect(downloadCommand.func(page, { clip: okCompleteClip.id, formats: 'mp3' })).rejects.toMatchObject({
-            code: 'COMMAND_EXEC',
-            message: expect.stringContaining('malformed clips payload'),
-        });
-    });
-
-    it('refuses to download when the clip is still streaming/queued', async () => {
-        await expect(downloadCommand.func(createPageWithFeed([{ ...okCompleteClip, status: 'streaming' }]), { clip: okCompleteClip.id, formats: 'mp3' })).rejects.toMatchObject({
-            code: 'COMMAND_EXEC',
-            message: expect.stringContaining('not complete yet'),
-        });
-    });
-});
-
-describe('suno download paid-format guard', () => {
-    it('skips wav by default and surfaces the skip in the result row', async () => {
-        const out = await downloadCommand.func(createPageWithFeed([okCompleteClip]), {
-            clip: okCompleteClip.id,
-            formats: 'mp3,wav,metadata',
-        });
-        expect(mocks.downloadSunoClip).toHaveBeenCalledWith(expect.anything(), okCompleteClip, '/tmp/suno-test', ['mp3', 'metadata'], 'device-uuid');
-        expect(out[0].files).toContain('skipped(needs --confirm-paid):wav');
-    });
-
-    it('rejects requests where every requested format is paid and unconfirmed', async () => {
-        await expect(downloadCommand.func(createPageWithFeed([okCompleteClip]), {
-            clip: okCompleteClip.id,
-            formats: 'wav',
-        })).rejects.toMatchObject({
-            code: 'ARGUMENT',
-            message: expect.stringContaining('All requested formats require'),
-        });
-        expect(mocks.downloadSunoClip).not.toHaveBeenCalled();
-    });
-
-    it('includes wav when --confirm-paid is true', async () => {
-        await downloadCommand.func(createPageWithFeed([okCompleteClip]), {
-            clip: okCompleteClip.id,
-            formats: 'mp3,wav',
-            'confirm-paid': true,
-        });
-        expect(mocks.downloadSunoClip).toHaveBeenCalledWith(expect.anything(), okCompleteClip, '/tmp/suno-test', ['mp3', 'wav'], 'device-uuid');
-    });
-
-    it('fails typed when selected formats write no files', async () => {
-        mocks.downloadSunoClip.mockResolvedValue({ slug: 'probe', written: [{ format: 'mp3', file: null, ok: false, reason: 'HTTP 500' }] });
-        await expect(downloadCommand.func(createPageWithFeed([okCompleteClip]), {
-            clip: okCompleteClip.id,
-            formats: 'mp3',
-        })).rejects.toMatchObject({
-            code: 'COMMAND_EXEC',
-            message: expect.stringContaining('wrote no files'),
-        });
-    });
-});

package/clis/suno/generate.test.js

@@ -1,252 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-const mocks = vi.hoisted(() => ({
-    ensureSunoSession: vi.fn(),
-    checkSunoCaptcha: vi.fn(),
-    submitSunoGeneration: vi.fn(),
-    pollSunoClips: vi.fn(),
-    downloadSunoClip: vi.fn(),
-}));
-
-vi.mock('./utils.js', () => ({
-    DEFAULT_SUNO_MODEL: 'chirp-fenix',
-    SUNO_DOMAIN: 'suno.com',
-    SUNO_MODELS: ['chirp-fenix', 'chirp-bluejay', 'chirp-v4', 'chirp-v3-5'],
-    SUNO_URL: 'https://suno.com',
-    ensureSunoSession: mocks.ensureSunoSession,
-    checkSunoCaptcha: mocks.checkSunoCaptcha,
-    submitSunoGeneration: mocks.submitSunoGeneration,
-    pollSunoClips: mocks.pollSunoClips,
-    downloadSunoClip: mocks.downloadSunoClip,
-    clampSlider: (value, _label, def) => (value === undefined || value === '' || value === null ? def : Number(value)),
-    normalizeBooleanFlag: (value, fallback = false) => {
-        if (typeof value === 'boolean') return value;
-        if (value == null || value === '') return fallback;
-        const s = String(value).trim().toLowerCase();
-        return s === 'true' || s === '1' || s === 'yes' || s === 'on';
-    },
-    parseFormats: (value) => {
-        if (!value) return ['mp3', 'metadata'];
-        const raw = Array.isArray(value) ? value.join(',') : String(value);
-        return raw.split(',').map(s => s.trim().toLowerCase()).filter(Boolean);
-    },
-    requirePositiveInt: (value) => {
-        const n = Number(value);
-        if (!Number.isInteger(n) || n < 1) throw new Error('positive int required');
-        return n;
-    },
-    resolveSunoOutputDir: (value) => value || '/tmp/suno-test',
-}));
-
-const { generateCommand } = await import('./generate.js');
-
-function createPage() {
-    return {
-        goto: vi.fn().mockResolvedValue(undefined),
-        wait: vi.fn().mockResolvedValue(undefined),
-        evaluate: vi.fn().mockResolvedValue(undefined),
-    };
-}
-
-const okSession = {
-    ok: true,
-    planId: '3eaebef3-ef46-446a-931c-3d50cd1514f1',
-    planKey: 'pro',
-    totalCreditsAvailable: 2000,
-    breakdown: { pack: 0, purchasedPacks: 0, monthlyRemaining: 2000, monthlyLimit: 2500, monthlyUsed: 500 },
-    deviceId: 'device-uuid',
-};
-const okCaptcha = { ok: true, required: false };
-const okSubmission = { id: 'batch-id', clips: [{ id: 'clip-a-id', status: 'submitted' }, { id: 'clip-b-id', status: 'submitted' }] };
-const okClips = [
-    { id: 'clip-a-id', status: 'complete', title: 'Clip A', audio_url: 'https://cdn1.suno.ai/clip-a-id.mp3' },
-    { id: 'clip-b-id', status: 'complete', title: 'Clip B', audio_url: 'https://cdn1.suno.ai/clip-b-id.mp3' },
-];
-
-beforeEach(() => {
-    vi.restoreAllMocks();
-    mocks.ensureSunoSession.mockReset().mockResolvedValue(okSession);
-    mocks.checkSunoCaptcha.mockReset().mockResolvedValue(okCaptcha);
-    mocks.submitSunoGeneration.mockReset().mockResolvedValue(okSubmission);
-    mocks.pollSunoClips.mockReset().mockResolvedValue(okClips);
-    mocks.downloadSunoClip.mockReset().mockResolvedValue({ slug: 'clip', written: [{ format: 'mp3', file: '/tmp/x.mp3', ok: true }, { format: 'metadata', file: '/tmp/x.json', ok: true }] });
-});
-
-describe('suno generate argument validation', () => {
-    it('rejects calls with neither a Simple prompt nor --lyrics', async () => {
-        await expect(generateCommand.func(createPage(), { sd: true, timeout: 60 })).rejects.toMatchObject({
-            code: 'ARGUMENT',
-            message: expect.stringContaining('Either provide a Simple-mode prompt'),
-        });
-    });
-
-    it('rejects --tags / --negative-tags in Simple mode', async () => {
-        await expect(generateCommand.func(createPage(), { prompt: 'foo', tags: 'lo-fi', sd: true, timeout: 60 })).rejects.toMatchObject({
-            code: 'ARGUMENT',
-            message: expect.stringContaining('only apply in Custom mode'),
-        });
-    });
-
-    it('rejects unsupported --model values', async () => {
-        await expect(generateCommand.func(createPage(), { prompt: 'foo', model: 'chirp-vNEXT', sd: true, timeout: 60 })).rejects.toMatchObject({
-            code: 'ARGUMENT',
-            message: expect.stringContaining('Unsupported --model'),
-        });
-    });
-
-    it('refuses to submit when planId is null (free-tier without resolved user_tier) (#1704)', async () => {
-        mocks.ensureSunoSession.mockResolvedValue({ ...okSession, planId: null, planKey: 'free' });
-        await expect(generateCommand.func(createPage(), { prompt: 'foo', sd: true, timeout: 60 })).rejects.toMatchObject({
-            code: 'COMMAND_EXEC',
-            message: expect.stringContaining('plan id'),
-        });
-        expect(mocks.submitSunoGeneration).not.toHaveBeenCalled();
-    });
-
-    it('refuses to submit when credits are below the per-song minimum', async () => {
-        mocks.ensureSunoSession.mockResolvedValue({ ...okSession, totalCreditsAvailable: 5, breakdown: { ...okSession.breakdown, monthlyRemaining: 5 } });
-        await expect(generateCommand.func(createPage(), { prompt: 'foo', sd: true, timeout: 60 })).rejects.toMatchObject({
-            code: 'COMMAND_EXEC',
-            message: expect.stringContaining('needs ~10 credits'),
-        });
-        expect(mocks.submitSunoGeneration).not.toHaveBeenCalled();
-    });
-
-    it('refuses to submit when captcha is required (out-of-scope for headless flow)', async () => {
-        mocks.checkSunoCaptcha.mockResolvedValue({ ok: true, required: true });
-        await expect(generateCommand.func(createPage(), { prompt: 'foo', sd: true, timeout: 60 })).rejects.toMatchObject({
-            code: 'COMMAND_EXEC',
-            message: expect.stringContaining('CAPTCHA challenge'),
-        });
-        expect(mocks.submitSunoGeneration).not.toHaveBeenCalled();
-    });
-
-    it('refuses to submit when captcha pre-flight fails', async () => {
-        mocks.checkSunoCaptcha.mockResolvedValue({ ok: false, status: 500 });
-        await expect(generateCommand.func(createPage(), { prompt: 'foo', sd: true, timeout: 60 })).rejects.toMatchObject({
-            code: 'COMMAND_EXEC',
-            message: expect.stringContaining('captcha pre-flight failed'),
-        });
-        expect(mocks.submitSunoGeneration).not.toHaveBeenCalled();
-    });
-});
-
-describe('suno generate Simple mode payload', () => {
-    it('routes the positional prompt through `description` (Simple mode)', async () => {
-        await generateCommand.func(createPage(), { prompt: 'lo-fi study beat', sd: true, timeout: 60 });
-        expect(mocks.submitSunoGeneration).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({
-            mode: 'simple',
-            description: 'lo-fi study beat',
-            lyrics: '',
-            tags: '',
-            negativeTags: '',
-            userTier: okSession.planId,
-            deviceId: okSession.deviceId,
-        }));
-    });
-});
-
-describe('suno generate Custom mode payload', () => {
-    it('routes --lyrics through `lyrics` and --tags through `tags`', async () => {
-        await generateCommand.func(createPage(), {
-            lyrics: '[Verse]\\nfoo',
-            tags: 'synthwave, 95 BPM',
-            'negative-tags': 'vocals',
-            title: 'Night Rain',
-            sd: true,
-            timeout: 60,
-        });
-        expect(mocks.submitSunoGeneration).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({
-            mode: 'custom',
-            lyrics: '[Verse]\\nfoo',
-            tags: 'synthwave, 95 BPM',
-            negativeTags: 'vocals',
-            title: 'Night Rain',
-        }));
-    });
-
-    it('threads --weirdness and --style-weight as numeric sliders', async () => {
-        await generateCommand.func(createPage(), {
-            lyrics: '[Verse]\\nfoo',
-            weirdness: '0.74',
-            'style-weight': '0.57',
-            sd: true,
-            timeout: 60,
-        });
-        expect(mocks.submitSunoGeneration).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({
-            weirdness: 0.74,
-            styleWeight: 0.57,
-        }));
-    });
-});
-
-describe('suno generate paid-format guard', () => {
-    it('skips wav by default and surfaces the skip in the result row', async () => {
-        const out = await generateCommand.func(createPage(), {
-            prompt: 'foo',
-            formats: 'mp3,wav,metadata',
-            timeout: 60,
-        });
-        // downloadSunoClip should be called with mp3+metadata, NOT wav
-        expect(mocks.downloadSunoClip).toHaveBeenCalledWith(expect.anything(), expect.anything(), expect.anything(), ['mp3', 'metadata'], okSession.deviceId);
-        expect(out[0].files).toContain('skipped(needs --confirm-paid):wav');
-    });
-
-    it('includes wav when --confirm-paid is true', async () => {
-        await generateCommand.func(createPage(), {
-            prompt: 'foo',
-            formats: 'mp3,wav',
-            'confirm-paid': true,
-            timeout: 60,
-        });
-        expect(mocks.downloadSunoClip).toHaveBeenCalledWith(expect.anything(), expect.anything(), expect.anything(), ['mp3', 'wav'], okSession.deviceId);
-    });
-
-    it('rejects before generation when every requested format is paid and unconfirmed', async () => {
-        await expect(generateCommand.func(createPage(), {
-            prompt: 'foo',
-            formats: 'wav',
-            timeout: 60,
-        })).rejects.toMatchObject({
-            code: 'ARGUMENT',
-            message: expect.stringContaining('All requested formats require'),
-        });
-        expect(mocks.submitSunoGeneration).not.toHaveBeenCalled();
-    });
-});
-
-describe('suno generate failure paths', () => {
-    it('reports all-failed clips with a typed error', async () => {
-        mocks.pollSunoClips.mockResolvedValue([
-            { id: 'clip-a-id', status: 'error' },
-            { id: 'clip-b-id', status: 'error' },
-        ]);
-        await expect(generateCommand.func(createPage(), { prompt: 'foo', sd: true, timeout: 60 })).rejects.toMatchObject({
-            code: 'COMMAND_EXEC',
-            message: expect.stringContaining('All Suno clips failed'),
-        });
-    });
-
-    it('fails typed when generation response clips are malformed', async () => {
-        mocks.submitSunoGeneration.mockResolvedValue({ clips: [{ status: 'submitted' }] });
-        await expect(generateCommand.func(createPage(), { prompt: 'foo', sd: true, timeout: 60 })).rejects.toMatchObject({
-            code: 'COMMAND_EXEC',
-            message: expect.stringContaining('malformed clip identity'),
-        });
-    });
-
-    it('fails typed when download post-condition writes no files', async () => {
-        mocks.downloadSunoClip.mockResolvedValue({ slug: 'clip', written: [{ format: 'mp3', file: null, ok: false, reason: 'HTTP 500' }] });
-        await expect(generateCommand.func(createPage(), { prompt: 'foo', formats: 'mp3', timeout: 60 })).rejects.toMatchObject({
-            code: 'COMMAND_EXEC',
-            message: expect.stringContaining('wrote no files'),
-        });
-    });
-
-    it('skip-download mode returns generated rows without invoking downloadSunoClip', async () => {
-        const out = await generateCommand.func(createPage(), { prompt: 'foo', sd: true, timeout: 60 });
-        expect(out).toHaveLength(2);
-        expect(out[0].status).toBe('🎵 generated');
-        expect(mocks.downloadSunoClip).not.toHaveBeenCalled();
-    });
-});