@mintlify/cli 4.0.1813 → 4.1.1

package/__test__/deploy-github-setup.test.ts

@@ -1,240 +0,0 @@
-import { execFile } from 'node:child_process';
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-import {
-  GITHUB_WORKFLOW_PATH,
-  githubWorkflow,
-  parseGithubRemote,
-  setupGithubDeployment,
-  writeGithubWorkflow,
-} from '../src/deploy-github-setup.js';
-import { prepareAgentDeployment } from '../src/deploy.js';
-
-vi.mock('node:child_process', async (importOriginal) => ({
-  ...(await importOriginal<typeof import('node:child_process')>()),
-  execFile: vi.fn(),
-}));
-vi.mock('../src/deploy.js', async (importOriginal) => ({
-  ...(await importOriginal<typeof import('../src/deploy.js')>()),
-  prepareAgentDeployment: vi.fn(),
-}));
-
-const apiUrl = 'https://leaves.mintlify.com';
-const site = {
-  status: 'ready' as const,
-  created: false,
-  deploymentId: 'id',
-  subdomain: 'my-docs',
-  remote: 'https://git.example.com/repo.git',
-  branch: 'main' as const,
-  expiresAt: '2026-12-01T00:00:00.000Z',
-};
-const credentials = {
-  registrationId: 'reg',
-  issuer: 'https://auth.example.com',
-  assertion: 'assertion',
-  claimToken: 'claim',
-  accessToken: 'access',
-};
-let root: string;
-
-function stubCommands(outputs: Record<string, string | NodeJS.ErrnoException>) {
-  vi.mocked(execFile).mockImplementation(((
-    command: string,
-    args: string[],
-    _options: unknown,
-    callback: (error: Error | null, stdout: string) => void
-  ) => {
-    const output = outputs[`${command} ${args[0]}`];
-    if (output instanceof Error) callback(output, '');
-    else if (output === undefined) callback(new Error('unexpected'), '');
-    else callback(null, `${output}\n`);
-  }) as unknown as typeof execFile);
-}
-
-beforeEach(async () => {
-  vi.resetAllMocks();
-  root = await fs.realpath(await fs.mkdtemp(path.join(os.tmpdir(), 'mint-github-')));
-  await fs.writeFile(path.join(root, 'docs.json'), '{}');
-  stubCommands({
-    'git rev-parse': root,
-    'git remote': 'git@github.com:acme/docs.git',
-    'gh api': JSON.stringify({ id: 123, full_name: 'acme/docs', default_branch: 'trunk' }),
-  });
-  vi.mocked(prepareAgentDeployment).mockResolvedValue({
-    status: 'ready',
-    projectType: 'site',
-    site,
-    write: { remote: site.remote, branch: 'main', token: 'write', tokenExpiresAt: site.expiresAt },
-    created: false,
-    credentials,
-  });
-});
-afterEach(async () => {
-  vi.unstubAllGlobals();
-  await fs.rm(root, { recursive: true, force: true });
-});
-
-describe('parseGithubRemote', () => {
-  it.each([
-    'https://github.com/acme/docs',
-    'https://github.com/acme/docs.git',
-    'https://user@github.com/acme/docs.git',
-    'git@github.com:acme/docs.git',
-    'ssh://git@github.com/acme/docs.git',
-    'ssh://git@github.com:22/acme/docs',
-  ])('parses %s', (remote) => {
-    expect(parseGithubRemote(remote)).toEqual({ owner: 'acme', repo: 'docs' });
-  });
-  it('keeps dots in repository names', () => {
-    expect(parseGithubRemote('git@github.com:acme/docs.site.git')).toEqual({
-      owner: 'acme',
-      repo: 'docs.site',
-    });
-  });
-  it.each(['https://gitlab.com/acme/docs.git', 'git@example.com:acme/docs.git', 'docs'])(
-    'rejects %s',
-    (remote) => {
-      expect(parseGithubRemote(remote)).toBeNull();
-    }
-  );
-});
-
-describe('GitHub workflow', () => {
-  it('deploys the subdomain on pushes to the branch with OIDC', () => {
-    expect(githubWorkflow('release,stable', 'my-docs')).toBe(`name: Deploy to Mintlify
-on:
-  push:
-    branches: ["release,stable"]
-permissions:
-  id-token: write
-  contents: read
-concurrency:
-  group: mintlify-deploy
-  cancel-in-progress: true
-jobs:
-  deploy:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - run: npx mint@latest deploy --subdomain my-docs
-`);
-  });
-  it('deploys only the docs folder of a monorepo', () => {
-    const workflow = githubWorkflow('main', 'my-docs', 'apps/docs');
-    expect(workflow).toContain('    paths: ["apps/docs/**", ".github/workflows/mintlify.yml"]\n');
-    expect(workflow).toContain(
-      '      - run: npx mint@latest deploy --subdomain my-docs --directory apps/docs\n'
-    );
-    expect(githubWorkflow('main', 'my-docs', 'my docs')).toContain('--directory "my docs"');
-  });
-  it('creates the workflow and accepts identical contents', async () => {
-    await expect(writeGithubWorkflow(root, 'a')).resolves.toBe('created');
-    await expect(writeGithubWorkflow(root, 'a')).resolves.toBe('unchanged');
-    expect(await fs.readFile(path.join(root, GITHUB_WORKFLOW_PATH), 'utf8')).toBe('a');
-  });
-  it('does not overwrite a different workflow without --force', async () => {
-    await writeGithubWorkflow(root, 'a');
-    await expect(writeGithubWorkflow(root, 'b')).rejects.toThrow('--force');
-    expect(await fs.readFile(path.join(root, GITHUB_WORKFLOW_PATH), 'utf8')).toBe('a');
-    await expect(writeGithubWorkflow(root, 'b', true)).resolves.toBe('updated');
-    expect(await fs.readFile(path.join(root, GITHUB_WORKFLOW_PATH), 'utf8')).toBe('b');
-  });
-});
-
-describe('mint deploy --github', () => {
-  const options = { apiUrl, directory: '', subdomain: 'my-docs' };
-
-  it('trusts the repository and writes the workflow', async () => {
-    const request = vi
-      .fn()
-      .mockResolvedValue(
-        new Response(JSON.stringify({ subdomain: 'my-docs', trustedRepos: [] }), { status: 200 })
-      );
-    vi.stubGlobal('fetch', request);
-
-    const result = await setupGithubDeployment({ ...options, directory: root }, vi.fn());
-
-    expect(vi.mocked(execFile).mock.calls.find(([command]) => command === 'gh')?.[1]).toEqual([
-      'api',
-      'repos/acme/docs',
-      '--jq',
-      '{id: .id, full_name: .full_name, default_branch: .default_branch}',
-    ]);
-    expect(request.mock.calls[0]?.[0]).toBe(`${apiUrl}/api/agent/deployments/trusted-repos`);
-    expect(request.mock.calls[0]?.[1].headers.Authorization).toBe('Bearer access');
-    expect(JSON.parse(request.mock.calls[0]?.[1].body)).toEqual({
-      repositoryId: '123',
-      repository: 'acme/docs',
-      branch: 'trunk',
-    });
-    expect(await fs.readFile(path.join(root, GITHUB_WORKFLOW_PATH), 'utf8')).toBe(
-      githubWorkflow('trunk', 'my-docs')
-    );
-    expect(result).toMatchObject({
-      siteUrl: 'https://my-docs.mintlify.site/',
-      repository: 'acme/docs',
-      branch: 'trunk',
-      workflow: 'created',
-    });
-  });
-
-  it('writes the workflow at the repository root for a docs subdirectory', async () => {
-    vi.stubGlobal(
-      'fetch',
-      vi
-        .fn()
-        .mockResolvedValue(
-          new Response(JSON.stringify({ subdomain: 'my-docs', trustedRepos: [] }), { status: 200 })
-        )
-    );
-    const docs = path.join(root, 'docs');
-    await fs.mkdir(docs);
-    await fs.writeFile(path.join(docs, 'docs.json'), '{}');
-    await setupGithubDeployment({ ...options, directory: docs }, vi.fn());
-    expect(await fs.readFile(path.join(root, GITHUB_WORKFLOW_PATH), 'utf8')).toBe(
-      githubWorkflow('trunk', 'my-docs', 'docs')
-    );
-  });
-
-  it('requires docs.json in the docs directory before provisioning', async () => {
-    const docs = path.join(root, 'empty');
-    await fs.mkdir(docs);
-    await expect(setupGithubDeployment({ ...options, directory: docs }, vi.fn())).rejects.toThrow(
-      'No docs.json'
-    );
-    expect(prepareAgentDeployment).not.toHaveBeenCalled();
-  });
-
-  it('rejects non-GitHub origins before provisioning', async () => {
-    stubCommands({ 'git rev-parse': root, 'git remote': 'https://gitlab.com/acme/docs.git' });
-    await expect(setupGithubDeployment({ ...options, directory: root }, vi.fn())).rejects.toThrow(
-      'not a github.com repository'
-    );
-    expect(prepareAgentDeployment).not.toHaveBeenCalled();
-  });
-
-  it('explains when gh is missing', async () => {
-    stubCommands({
-      'git rev-parse': root,
-      'git remote': 'https://github.com/acme/docs',
-      'gh api': Object.assign(new Error('spawn gh ENOENT'), { code: 'ENOENT' }),
-    });
-    await expect(setupGithubDeployment({ ...options, directory: root }, vi.fn())).rejects.toThrow(
-      'GitHub CLI (gh) is required'
-    );
-  });
-
-  it('does not support claimed sites yet', async () => {
-    vi.mocked(prepareAgentDeployment).mockResolvedValue({ status: 'claimed' });
-    const request = vi.fn();
-    vi.stubGlobal('fetch', request);
-    await expect(setupGithubDeployment({ ...options, directory: root }, vi.fn())).rejects.toThrow(
-      'not supported yet'
-    );
-    expect(request).not.toHaveBeenCalled();
-  });
-});

package/__test__/deploy-instructions.test.ts

@@ -1,155 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-
-import { createAgentClaimLink } from '../src/agent-claim.js';
-import { DASHBOARD_URL } from '../src/constants.js';
-import { deploymentInstructions, DEPLOY_HELP } from '../src/deploy-instructions.js';
-import { trackEvent } from '../src/telemetry/track.js';
-import { renderWelcome } from '../src/welcome.js';
-
-vi.mock('../src/agent-auth.js', async (importOriginal) => ({
-  ...(await importOriginal<typeof import('../src/agent-auth.js')>()),
-  discoverAgentAuth: async () => ({
-    issuer: 'https://auth.example.com',
-    agent_auth: { claim_endpoint: 'https://auth.example.com/agent/identity/claim' },
-  }),
-}));
-vi.mock('../src/telemetry/track.js', () => ({ trackEvent: vi.fn() }));
-afterEach(() => vi.unstubAllGlobals());
-const credentials = {
-  registrationId: 'reg',
-  issuer: 'https://auth.example.com',
-  assertion: 'assertion-secret',
-  claimToken: 'claim-secret',
-};
-const site = {
-  status: 'ready' as const,
-  deploymentId: 'id',
-  subdomain: 'docs',
-  remote: 'https://git.example.com/repo',
-  branch: 'main' as const,
-  expiresAt: '2026-12-01T00:00:00.000Z',
-};
-
-describe('deploy help and claim handoff', () => {
-  it('uses the actual claim attempt API and returns its human-facing link', async () => {
-    const request = vi.fn().mockResolvedValue(
-      new Response(
-        JSON.stringify({
-          attempt: {
-            verification_uri:
-              'https://auth.example.com/verify?token=attempt%2Btoken%26value&other=ignored',
-          },
-        })
-      )
-    );
-    vi.stubGlobal('fetch', request);
-    expect(
-      await createAgentClaimLink('https://api.example.com', credentials, 'user@example.com')
-    ).toBe(`${DASHBOARD_URL}/agent-claim?token=attempt%2Btoken%26value&registration=reg`);
-    expect(trackEvent).toHaveBeenCalledWith('agent_signup.claim_started', {
-      registration_id: 'reg',
-    });
-    expect(JSON.parse(request.mock.calls[0]?.[1].body)).toEqual({
-      type: 'service_auth',
-      claim_token: 'claim-secret',
-      login_hint: 'user@example.com',
-    });
-  });
-  it('rejects a verification link without an attempt token', async () => {
-    vi.stubGlobal(
-      'fetch',
-      vi.fn().mockResolvedValue(
-        new Response(
-          JSON.stringify({
-            attempt: { verification_uri: 'https://auth.example.com/verify' },
-          })
-        )
-      )
-    );
-    await expect(
-      createAgentClaimLink('https://api.example.com', credentials, 'user@example.com')
-    ).rejects.toThrow();
-  });
-  it('keeps Git operations with the agent and omits identity credentials', () => {
-    const text = deploymentInstructions(
-      {
-        status: 'ready',
-        projectType: 'site',
-        created: true,
-        site,
-        credentials,
-        write: {
-          remote: site.remote,
-          branch: site.branch,
-          token: 'write-secret',
-          tokenExpiresAt: site.expiresAt,
-        },
-      },
-      'https://app.example.com/claim'
-    );
-    expect(text).toContain('Do not force-push');
-    expect(text).toContain('mint claim --code <code>');
-    expect(text).not.toContain('/auth.md');
-    expect(text).toContain('docs.json');
-    expect(text).toContain('https://app.example.com/claim');
-    expect(text).not.toContain('assertion-secret');
-    expect(text).not.toContain('claim-secret');
-    expect(text).not.toContain('write-secret');
-  });
-  it('gives base claim, clone, and push steps without site build or GitHub hints', () => {
-    const write = {
-      remote: site.remote,
-      branch: site.branch,
-      token: 'write-secret',
-      tokenExpiresAt: site.expiresAt,
-    };
-    const text = deploymentInstructions({
-      status: 'ready',
-      projectType: 'workspace',
-      created: true,
-      site,
-      credentials,
-      write,
-    });
-    expect(text).toContain('mint deploy --base --email <their-email>');
-    expect(text).toContain('mint claim --code <code>');
-    expect(text).toContain(
-      `git -c http.${site.remote}.extraHeader="Authorization: Bearer write-secret" clone ${site.remote} ${site.subdomain}`
-    );
-    expect(text).toContain(`mint deploy --base --push ${site.subdomain}`);
-    expect(text).not.toContain('Git examples');
-    expect(text.indexOf('--push')).toBeLessThan(text.indexOf('mint claim --code'));
-    expect(text).not.toContain('build');
-    expect(text).not.toContain('--github');
-  });
-  it('gives the base claim link when one was created', () => {
-    const text = deploymentInstructions(
-      {
-        status: 'ready',
-        projectType: 'workspace',
-        created: true,
-        site,
-        credentials,
-        write: {
-          remote: site.remote,
-          branch: site.branch,
-          token: 't',
-          tokenExpiresAt: site.expiresAt,
-        },
-      },
-      'https://claim.example.com/x'
-    );
-    expect(text).toContain('Send the user this link: https://claim.example.com/x');
-    expect(text).not.toContain('--email <their-email>');
-  });
-  it('documents the command in root help and explains that it does not push files', () => {
-    expect(renderWelcome({ packageName: 'mint', signedIn: false })).toContain('deploy');
-    expect(DEPLOY_HELP).toContain('Commit and push the documentation yourself');
-    expect(DEPLOY_HELP).toContain('--new');
-    expect(DEPLOY_HELP).toContain('mint claim --code <code>');
-    expect(renderWelcome({ packageName: 'mint', signedIn: false })).toContain('claim --email');
-    expect(DEPLOY_HELP).toContain('ask the user for their email');
-    expect(DEPLOY_HELP).toContain('--base cannot be combined with --github');
-    expect(DEPLOY_HELP).toContain('mint deploy --base --push <clone-directory>');
-  });
-});

package/__test__/deploy.test.ts

@@ -1,202 +0,0 @@
-import path from 'node:path';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-import * as auth from '../src/agent-auth.js';
-import * as storage from '../src/agent-credentials.js';
-import * as deployment from '../src/agent-deployment.js';
-import * as config from '../src/config.js';
-import { DASHBOARD_URL } from '../src/constants.js';
-import { prepareAgentDeployment, formatDeployment } from '../src/deploy.js';
-import { trackEvent } from '../src/telemetry/track.js';
-
-vi.mock('../src/agent-auth.js');
-vi.mock('../src/agent-credentials.js');
-vi.mock('../src/agent-deployment.js');
-vi.mock('../src/config.js');
-vi.mock('../src/telemetry/track.js');
-
-const credentials = {
-  registrationId: 'reg_1',
-  issuer: 'https://auth.example.com',
-  assertion: 'assertion',
-  claimToken: 'claim',
-};
-const site = {
-  status: 'ready' as const,
-  created: true,
-  deploymentId: 'id',
-  subdomain: 'allocated',
-  remote: 'https://git.example.com/repo',
-  branch: 'main' as const,
-  expiresAt: '2026-12-01T00:00:00.000Z',
-};
-const write = {
-  remote: site.remote,
-  branch: site.branch,
-  token: 'write',
-  tokenExpiresAt: site.expiresAt,
-};
-const options = {
-  apiUrl: 'https://api.example.com',
-  directory: path.resolve('docs'),
-  subdomain: 'requested',
-};
-const warn = vi.fn();
-
-beforeEach(() => {
-  vi.resetAllMocks();
-  vi.mocked(storage.loadAgentCredentials).mockResolvedValue(null);
-  vi.mocked(storage.saveAgentCredentials).mockResolvedValue(undefined);
-  vi.mocked(auth.registerAgent).mockResolvedValue(credentials);
-  vi.mocked(auth.exchangeAgentToken).mockImplementation(async (_, value) => ({
-    ...value,
-    accessToken: 'access',
-  }));
-  vi.mocked(auth.getAgentIdentity).mockResolvedValue({
-    registrationId: 'reg_1',
-    identityType: 'anonymous',
-  });
-  vi.mocked(deployment.provisionAgentSite).mockResolvedValue(site);
-  vi.mocked(deployment.getAgentWriteToken).mockResolvedValue(write);
-  vi.mocked(config.setAgentSiteMetadata).mockResolvedValue(undefined);
-});
-
-describe('mint deploy', () => {
-  it('tracks discovery and registration for a new agent', async () => {
-    await prepareAgentDeployment(options, warn);
-    expect(vi.mocked(trackEvent).mock.calls).toEqual([
-      ['agent_signup.discovered', { registration_id: 'reg_1' }],
-      ['agent_signup.registered', { registration_id: 'reg_1' }],
-      [
-        'cli.deploy.provisioned',
-        { registration_id: 'reg_1', deployment_id: 'id', subdomain: 'allocated', created: true },
-      ],
-    ]);
-  });
-  it('tracks only discovery for a saved registration', async () => {
-    vi.mocked(storage.loadAgentCredentials).mockResolvedValue(credentials);
-    await prepareAgentDeployment(options, warn);
-    expect(vi.mocked(trackEvent).mock.calls).toEqual([
-      ['agent_signup.discovered', { registration_id: 'reg_1' }],
-      [
-        'cli.deploy.provisioned',
-        { registration_id: 'reg_1', deployment_id: 'id', subdomain: 'allocated', created: true },
-      ],
-    ]);
-  });
-  it('tracks a provisioned site when write access fails', async () => {
-    vi.mocked(deployment.getAgentWriteToken).mockRejectedValue(new Error('timeout'));
-    await expect(prepareAgentDeployment(options, warn)).rejects.toThrow('timeout');
-    expect(vi.mocked(trackEvent)).toHaveBeenCalledWith('cli.deploy.provisioned', {
-      registration_id: 'reg_1',
-      deployment_id: 'id',
-      subdomain: 'allocated',
-      created: true,
-    });
-  });
-  it.each([
-    ['https://leaves.mintlify.com', 'https://allocated.mintlify.site/'],
-    ['https://leaves-dev.mintlify.com', 'https://allocated.mint-dev.mintlify.me/'],
-  ])('prints the site URL for %s', async (apiUrl, siteUrl) => {
-    const result = await prepareAgentDeployment({ ...options, apiUrl }, warn);
-    expect(formatDeployment(result, apiUrl)).toContain(`Site: ${siteUrl}`);
-  });
-  it('provisions a base and prints its editor link instead of a site URL', async () => {
-    vi.mocked(deployment.provisionAgentSite).mockResolvedValue({ ...site, orgSlug: 'acme' });
-    const result = await prepareAgentDeployment({ ...options, base: true }, warn);
-    expect(deployment.provisionAgentSite).toHaveBeenCalledWith(options.apiUrl, 'access', {
-      subdomain: 'requested',
-      orgName: undefined,
-      projectType: 'workspace',
-    });
-    const text = formatDeployment(result, options.apiUrl);
-    expect(text).toContain(`Editor: ${new URL('/acme/allocated/editor', DASHBOARD_URL)}`);
-    expect(text).not.toContain('Site:');
-    expect(text).not.toContain('build');
-    expect(text).not.toContain('Write token');
-  });
-  it('fails before provisioning when credentials cannot be saved', async () => {
-    vi.mocked(storage.saveAgentCredentials).mockRejectedValue(new Error('disk full'));
-    await expect(prepareAgentDeployment(options, warn)).rejects.toThrow('disk full');
-    expect(deployment.provisionAgentSite).not.toHaveBeenCalled();
-  });
-  it('persists the exchanged access token for later commands', async () => {
-    await prepareAgentDeployment(options, warn);
-    expect(storage.saveAgentCredentials).toHaveBeenLastCalledWith(
-      options.apiUrl,
-      options.directory,
-      { ...credentials, accessToken: 'access' }
-    );
-  });
-  it('reuses the current registration and the saved site name', async () => {
-    vi.mocked(storage.loadAgentCredentials).mockResolvedValue(credentials);
-    vi.mocked(config.getAgentSiteMetadata).mockReturnValue({
-      registrationId: 'reg_1',
-      subdomain: 'allocated',
-    });
-    await prepareAgentDeployment({ ...options, subdomain: undefined }, warn);
-    expect(auth.registerAgent).not.toHaveBeenCalled();
-    expect(deployment.provisionAgentSite).toHaveBeenCalledWith(options.apiUrl, 'access', {
-      subdomain: 'allocated',
-      orgName: undefined,
-    });
-  });
-  it('starts a new registration only when explicitly requested or the site expired', async () => {
-    vi.mocked(storage.loadAgentCredentials).mockResolvedValue(credentials);
-    await prepareAgentDeployment({ ...options, newSite: true }, warn);
-    expect(storage.loadAgentCredentials).not.toHaveBeenCalled();
-    expect(auth.registerAgent).toHaveBeenCalledTimes(1);
-  });
-  it('requires an explicit site name for --new even when a previous name is saved', async () => {
-    vi.mocked(config.getAgentSiteMetadata).mockReturnValue({
-      registrationId: 'reg_1',
-      subdomain: 'allocated',
-    });
-    await expect(
-      prepareAgentDeployment({ ...options, newSite: true, subdomain: undefined }, warn)
-    ).rejects.toThrow('Choose a site name with --subdomain');
-    expect(auth.discoverAgentAuth).not.toHaveBeenCalled();
-    expect(auth.registerAgent).not.toHaveBeenCalled();
-    expect(storage.saveAgentCredentials).not.toHaveBeenCalled();
-    expect(deployment.provisionAgentSite).not.toHaveBeenCalled();
-  });
-  it('starts again on confirmed deployment expiry', async () => {
-    vi.mocked(storage.loadAgentCredentials).mockResolvedValue(credentials);
-    vi.mocked(deployment.provisionAgentSite).mockResolvedValueOnce({
-      status: 'expired',
-      created: false,
-      code: 'deployment_already_exists',
-      deploymentId: 'old',
-      subdomain: 'old',
-    });
-    await prepareAgentDeployment(options, warn);
-    expect(auth.registerAgent).toHaveBeenCalledTimes(1);
-    expect(deployment.provisionAgentSite).toHaveBeenCalledTimes(2);
-  });
-  it('does not provision for a claimed identity', async () => {
-    vi.mocked(auth.getAgentIdentity).mockResolvedValue({
-      registrationId: 'reg_1',
-      identityType: 'user_bound',
-      userId: 'user',
-      orgId: 'org',
-    });
-    const result = await prepareAgentDeployment(options, warn);
-    expect(formatDeployment(result, options.apiUrl)).toContain('--new');
-    expect(deployment.provisionAgentSite).not.toHaveBeenCalled();
-  });
-  it('does not replace an existing identity after an authentication outage', async () => {
-    vi.mocked(storage.loadAgentCredentials).mockResolvedValue(credentials);
-    vi.mocked(auth.getAgentIdentity).mockRejectedValue(new Error('unavailable'));
-    await expect(prepareAgentDeployment(options, warn)).rejects.toThrow('unavailable');
-    expect(auth.registerAgent).not.toHaveBeenCalled();
-  });
-  it('does not create a site after failing to read known credentials', async () => {
-    vi.mocked(config.getAgentSiteMetadata).mockReturnValue({
-      registrationId: 'reg_1',
-      subdomain: 'allocated',
-    });
-    vi.mocked(storage.loadAgentCredentials).mockRejectedValue(new Error('locked'));
-    await expect(prepareAgentDeployment(options, warn)).rejects.toThrow('Could not read');
-    expect(auth.registerAgent).not.toHaveBeenCalled();
-  });
-});

package/__test__/feedback.test.ts

@@ -1,34 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { API_URL } from '../src/constants.js';
-import { sendFeedback } from '../src/feedback.js';
-
-const fetchMock = vi.fn();
-vi.stubGlobal('fetch', fetchMock);
-
-const input = { message: 'mint dev crashed', clientId: 'c1', category: 'bug' as const };
-const respond = (status: number) => fetchMock.mockResolvedValue(new Response('{}', { status }));
-
-beforeEach(() => {
-  fetchMock.mockReset();
-});
-
-describe('mint feedback', () => {
-  it('posts the feedback with the cli source and no login', async () => {
-    respond(201);
-    expect(await sendFeedback(input)).toBeUndefined();
-    const [url, init] = fetchMock.mock.calls[0]!;
-    expect(url).toBe(`${API_URL}/api/cli/feedback`);
-    expect(init?.method).toBe('POST');
-    expect(init?.headers).not.toHaveProperty('Authorization');
-    expect(JSON.parse(String(init?.body))).toEqual({ ...input, source: 'cli' });
-  });
-  it('reports a network failure', async () => {
-    fetchMock.mockRejectedValue(new Error('fetch failed'));
-    expect(await sendFeedback(input)).toBe('could not reach the server');
-  });
-  it('reports a server error', async () => {
-    respond(400);
-    expect(await sendFeedback(input)).toBe('could not send feedback (HTTP 400)');
-  });
-});